From 62d045512a871733bb756a9b996254097f97cdc0 Mon Sep 17 00:00:00 2001 From: Mysaa Date: Wed, 26 Oct 2022 11:51:37 +0200 Subject: [PATCH] =?UTF-8?q?Mon=20commit=20avec=20mes=20modifs=20=C3=A0=20m?= =?UTF-8?q?oi=20!=20Na?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- MiniC/Makefile | 4 +- MiniC/MiniC.g4 | 2 +- MiniC/README-codegen.md | 59 +++-- MiniC/TP03/MiniCTypingVisitor.py | 12 +- .../examples-types}/bad_type01.c | 2 +- .../examples-types}/bad_type_bool_bool.c | 2 +- .../tests/students/typeErrors/forInitTyping.c | 2 +- .../tests/students/typeErrors/invalidAdd.c | 2 +- .../tests/students/typeErrors/mismatchAdd.c | 2 +- .../tests/students/typeErrors/mismatchAnd.c | 2 +- .../tests/students/typeErrors/mismatchComp.c | 2 +- .../tests/students/typeErrors/mismatchMult.c | 2 +- .../tests/students/typeErrors/mismatchOr.c | 2 +- MiniC/TP04/AllInMemAllocator.py | 22 +- MiniC/TP04/BuildCFG.py | 23 +- MiniC/TP04/LinearizeCFG.py | 26 +- MiniC/TP04/MiniCCodeGen3AVisitor.py | 160 +++++++++++- MiniC/TP04/tests/students/forTests.c | 32 +++ MiniC/TP04/tests/students/nestedFor.c | 31 +++ MiniC/TP04/tests/students/nestedIfs.c | 48 ++++ MiniC/TP04/tests/students/nestedWhile.c | 34 +++ .../students/operators/relations/testEq.c | 64 +++++ .../students/operators/relations/testGeq.c | 94 +++++++ .../students/operators/relations/testGt.c | 93 +++++++ .../students/operators/relations/testLeq.c | 94 +++++++ .../students/operators/relations/testLt.c | 94 +++++++ .../students/operators/relations/testNeq.c | 64 +++++ .../tests/students/operators/testAddClause.c | 26 ++ .../tests/students/operators/testAndClause.c | 26 ++ .../tests/students/operators/testDivClause.c | 24 ++ .../tests/students/operators/testDivZero.c | 25 ++ .../students/operators/testMinusClause.c | 26 ++ .../tests/students/operators/testModClause.c | 24 ++ .../tests/students/operators/testModZero.c | 25 ++ .../tests/students/operators/testMulClause.c | 31 +++ .../tests/students/operators/testNotClause.c | 22 ++ .../tests/students/operators/testOrClause.c | 26 ++ .../students/operators/testUMinusClause.c | 25 ++ .../tests/students/testTooManyVariables.c | 37 +++ MiniC/TP04/tests/students/whileClauseSyntax.c | 22 ++ MiniC/TP05/EnterSSA.py | 28 +- MiniC/TP05/ExitSSA.py | 42 ++- TP01/riscv/ex1.riscv | Bin 0 -> 132448 bytes TP01/riscv/libprint.o | Bin 0 -> 2760 bytes TP01/riscv/test_print | Bin 0 -> 134328 bytes TP01/riscv/test_print.o | Bin 0 -> 1560 bytes TP01/riscv/test_print.riscv | Bin 0 -> 140392 bytes TP02/ariteval/AritLexer.py | 77 ++++++ TP02/ariteval/AritListener.py | 33 +++ TP02/ariteval/AritParser.py | 110 ++++++++ TP02/ariteval/tree.dot | 5 + TP02/ariteval/tree.dot.pdf | Bin 0 -> 5287 bytes TP02/demo_files/ex1/Example1.py | 69 +++++ TP02/demo_files/ex2/Example2Lexer.py | 64 +++++ TP02/demo_files/ex2/Example2Listener.py | 30 +++ TP02/demo_files/ex2/Example2Parser.py | 221 ++++++++++++++++ TP03/tree/Makefile | 18 ++ TP03/tree/TreeLexer.py | 60 +++++ TP03/tree/TreeListener.py | 39 +++ TP03/tree/TreeParser.py | 247 ++++++++++++++++++ TP03/tree/TreeVisitor.py | 28 ++ TP03/tree/main.py | 35 +++ 62 files changed, 2342 insertions(+), 77 deletions(-) rename MiniC/TP03/tests/{students/corrected => provided/examples-types}/bad_type01.c (57%) rename MiniC/TP03/tests/{students/corrected => provided/examples-types}/bad_type_bool_bool.c (85%) create mode 100644 MiniC/TP04/tests/students/forTests.c create mode 100644 MiniC/TP04/tests/students/nestedFor.c create mode 100644 MiniC/TP04/tests/students/nestedIfs.c create mode 100644 MiniC/TP04/tests/students/nestedWhile.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testEq.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testGeq.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testGt.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testLeq.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testLt.c create mode 100644 MiniC/TP04/tests/students/operators/relations/testNeq.c create mode 100644 MiniC/TP04/tests/students/operators/testAddClause.c create mode 100644 MiniC/TP04/tests/students/operators/testAndClause.c create mode 100644 MiniC/TP04/tests/students/operators/testDivClause.c create mode 100644 MiniC/TP04/tests/students/operators/testDivZero.c create mode 100644 MiniC/TP04/tests/students/operators/testMinusClause.c create mode 100644 MiniC/TP04/tests/students/operators/testModClause.c create mode 100644 MiniC/TP04/tests/students/operators/testModZero.c create mode 100644 MiniC/TP04/tests/students/operators/testMulClause.c create mode 100644 MiniC/TP04/tests/students/operators/testNotClause.c create mode 100644 MiniC/TP04/tests/students/operators/testOrClause.c create mode 100644 MiniC/TP04/tests/students/operators/testUMinusClause.c create mode 100644 MiniC/TP04/tests/students/testTooManyVariables.c create mode 100644 MiniC/TP04/tests/students/whileClauseSyntax.c create mode 100755 TP01/riscv/ex1.riscv create mode 100644 TP01/riscv/libprint.o create mode 100755 TP01/riscv/test_print create mode 100644 TP01/riscv/test_print.o create mode 100755 TP01/riscv/test_print.riscv create mode 100644 TP02/ariteval/AritLexer.py create mode 100644 TP02/ariteval/AritListener.py create mode 100644 TP02/ariteval/AritParser.py create mode 100644 TP02/ariteval/tree.dot create mode 100644 TP02/ariteval/tree.dot.pdf create mode 100644 TP02/demo_files/ex1/Example1.py create mode 100644 TP02/demo_files/ex2/Example2Lexer.py create mode 100644 TP02/demo_files/ex2/Example2Listener.py create mode 100644 TP02/demo_files/ex2/Example2Parser.py create mode 100644 TP03/tree/Makefile create mode 100644 TP03/tree/TreeLexer.py create mode 100644 TP03/tree/TreeListener.py create mode 100644 TP03/tree/TreeParser.py create mode 100644 TP03/tree/TreeVisitor.py create mode 100644 TP03/tree/main.py diff --git a/MiniC/Makefile b/MiniC/Makefile index dcfc04a..64ba2d8 100644 --- a/MiniC/Makefile +++ b/MiniC/Makefile @@ -86,7 +86,9 @@ define CLEAN import glob import os for f in glob.glob("**/tests/**/*.c", recursive=True): - for s in ("{}-{}.s".format(f[:-2], test) for test in ("naive", "smart", "gcc", "all-in-mem")): + files = ["{}-{}.{}".format(f[:-2], test,ext) for test in ("naive", "smart", "gcc", "all-in-mem") for ext in ("s","riscv","pdf")] + files += ["{}.{}.{}.{}".format(f[:-2], funct, test,ext for funct in ("main") for test in ("enterssa","exitssa") for ext in ("dot.pdf","dot") + for s in files: try: os.remove(s) print("Removed {}".format(s)) diff --git a/MiniC/MiniC.g4 b/MiniC/MiniC.g4 index 6592018..a27b112 100644 --- a/MiniC/MiniC.g4 +++ b/MiniC/MiniC.g4 @@ -52,7 +52,7 @@ print_stat expr : MINUS expr #unaryMinusExpr | NOT expr #notExpr - | expr myop=(MULT|DIV|MOD) expr #multiplicativeExpr + | expr myop=(MULT|DIV|MOD) expr #multiplicativeExpr | expr myop=(PLUS|MINUS) expr #additiveExpr | expr myop=(GT|LT|GTEQ|LTEQ) expr #relationalExpr | expr myop=(EQ|NEQ) expr #equalityExpr diff --git a/MiniC/README-codegen.md b/MiniC/README-codegen.md index e6923a0..de3a4bb 100644 --- a/MiniC/README-codegen.md +++ b/MiniC/README-codegen.md @@ -3,23 +3,32 @@ LAB4 (simple code generation), MIF08 / CAP 2022-23 # Authors -YOUR NAME HERE +Samy Avrillon # Contents -TODO for STUDENTS : Say a bit about the code infrastructure ... +Same as the first lab, you did the structure, so i have litle interest in commenting it. # Test design -TODO: explain your tests +- folder *operators* checks all operations on operators (additive, multiplicative, relations, unary minus, boolean) +- *nested{While,For,Ifs}* checks with structures of nested blocks. +- *forTests* and *whileClauseSyntax* tests for the well-execution of for and while loops. +- *testTooManyVariables* tries initializing many variables in order to make the naive allocator fail. # Design choices -TODO: explain your choices. How did you implement boolean not? Did you implement an extension? +Boolean Not has been implemented using an immediate 1 and the opreator xor, even though such operator exists in riscV (see Known bugs). + +I did implement C-like loops with the same system used in the interpreter. # Known bugs -TODO: Bugs and limitations. +There is a lot of RiscV instruction that are not implemented in Lib, and that makes bigger and less readable code (for exemple, slt would be better than blt for integer comparison). + +By design, we always use a jump statement before a label. Otherwise, the CFG linearization fails. This is intended (the missing jump could be added in *prepare_chunk*). + +So, there is one line in *BuildCFG.c* that sould never be executed (that's why the coverage is not 100% complete), when a label is detected as a leader, as the preceding jump will always have been detected as a leader before it. # Checklists @@ -28,30 +37,30 @@ and *tested* with appropriate test cases. ## Code generation -- [ ] Number Atom -- [ ] Boolean Atom -- [ ] Id Atom -- [ ] Additive expression -- [ ] Multiplicative expression -- [ ] UnaryMinus expression -- [ ] Or expression -- [ ] And expression -- [ ] Equality expression -- [ ] Relational expression (! many cases -> many tests) -- [ ] Not expression +- [X] Number Atom +- [X] Boolean Atom +- [X] Id Atom +- [X] Additive expression +- [X] Multiplicative expression +- [X] UnaryMinus expression +- [X] Or expression +- [X] And expression +- [X] Equality expression +- [X] Relational expression (! many cases -> many tests) +- [X] Not expression ## Statements -- [ ] Prog, assignements -- [ ] While -- [ ] Cond Block -- [ ] If -- [ ] Nested ifs -- [ ] Nested whiles +- [X] Prog, assignements +- [X] While +- [X] Cond Block +- [X] If +- [X] Nested ifs +- [X] Nested whiles ## Allocation -- [ ] Naive allocation -- [ ] All in memory allocation -- [ ] Massive tests of memory allocation +- [X] Naive allocation +- [X] All in memory allocation +- [X] Massive tests of memory allocation diff --git a/MiniC/TP03/MiniCTypingVisitor.py b/MiniC/TP03/MiniCTypingVisitor.py index a750cc2..40a44f6 100644 --- a/MiniC/TP03/MiniCTypingVisitor.py +++ b/MiniC/TP03/MiniCTypingVisitor.py @@ -110,7 +110,7 @@ class MiniCTypingVisitor(MiniCVisitor): else: self._raise(ctx,"boolean operator", fstT) else: - self._assertSameType(ctx,"boolean operator", fstT,sndT) + self._raise(ctx,"boolean operator", fstT,sndT) def visitAndExpr(self, ctx): fstT = self.visit(ctx.expr(0)) @@ -121,7 +121,7 @@ class MiniCTypingVisitor(MiniCVisitor): else: self._raise(ctx,"boolean operator", fstT) else: - self._assertSameType(ctx,"boolean operator", fstT,sndT) + self._raise(ctx,"boolean operator", fstT,sndT) def visitEqualityExpr(self, ctx): fstT = self.visit(ctx.expr(0)) @@ -140,7 +140,7 @@ class MiniCTypingVisitor(MiniCVisitor): else: self._raise(ctx, "comparaison operator", fstT) else: - self._assertSameType(ctx,"comparaison operator", fstT,sndT) + self._raise(ctx,"comparaison operator", fstT,sndT) def visitAdditiveExpr(self, ctx): assert ctx.myop is not None @@ -152,9 +152,9 @@ class MiniCTypingVisitor(MiniCVisitor): elif (fstT == BaseType.String and ctx.myop.type == MiniCParser.PLUS): return BaseType.String else: - self._raise(ctx, "additive operands", fstT) + self._raise(ctx, "additive operands", fstT,sndT) else: - self._assertSameType(ctx,"additive operator", fstT,sndT) + self._raise(ctx,"additive operator", fstT,sndT) def visitMultiplicativeExpr(self, ctx): fstT = self.visit(ctx.expr(0)) @@ -165,7 +165,7 @@ class MiniCTypingVisitor(MiniCVisitor): else: return fstT else: - self._assertSameType(ctx,"multiplicative operator", fstT,sndT) + self._raise(ctx,"multiplicative operands", fstT,sndT) def visitNotExpr(self, ctx): fstT = self.visit(ctx.expr()) diff --git a/MiniC/TP03/tests/students/corrected/bad_type01.c b/MiniC/TP03/tests/provided/examples-types/bad_type01.c similarity index 57% rename from MiniC/TP03/tests/students/corrected/bad_type01.c rename to MiniC/TP03/tests/provided/examples-types/bad_type01.c index 39f8e7c..1a84239 100644 --- a/MiniC/TP03/tests/students/corrected/bad_type01.c +++ b/MiniC/TP03/tests/provided/examples-types/bad_type01.c @@ -11,4 +11,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 8 col 6: type mismatch for multiplicative operator: integer and string +// In function main: Line 8 col 6: invalid type for multiplicative operands: integer and string diff --git a/MiniC/TP03/tests/students/corrected/bad_type_bool_bool.c b/MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c similarity index 85% rename from MiniC/TP03/tests/students/corrected/bad_type_bool_bool.c rename to MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c index e5f3981..be2d14e 100644 --- a/MiniC/TP03/tests/students/corrected/bad_type_bool_bool.c +++ b/MiniC/TP03/tests/provided/examples-types/bad_type_bool_bool.c @@ -6,4 +6,4 @@ int main(){ } // EXITCODE 2 // EXPECTED -// In function main: Line 4 col 14: invalid type for additive operands: boolean +// In function main: Line 4 col 14: invalid type for additive operands: boolean and boolean diff --git a/MiniC/TP03/tests/students/typeErrors/forInitTyping.c b/MiniC/TP03/tests/students/typeErrors/forInitTyping.c index 6ce6769..2ce0d31 100644 --- a/MiniC/TP03/tests/students/typeErrors/forInitTyping.c +++ b/MiniC/TP03/tests/students/typeErrors/forInitTyping.c @@ -11,4 +11,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 6 col 12: type mismatch for additive operator: integer and boolean +// In function main: Line 6 col 12: invalid type for additive operator: integer and boolean diff --git a/MiniC/TP03/tests/students/typeErrors/invalidAdd.c b/MiniC/TP03/tests/students/typeErrors/invalidAdd.c index 13f78f6..fbf023f 100644 --- a/MiniC/TP03/tests/students/typeErrors/invalidAdd.c +++ b/MiniC/TP03/tests/students/typeErrors/invalidAdd.c @@ -11,4 +11,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 8 col 8: invalid type for additive operands: boolean +// In function main: Line 8 col 8: invalid type for additive operands: boolean and boolean diff --git a/MiniC/TP03/tests/students/typeErrors/mismatchAdd.c b/MiniC/TP03/tests/students/typeErrors/mismatchAdd.c index ea7fd8b..a88dc90 100644 --- a/MiniC/TP03/tests/students/typeErrors/mismatchAdd.c +++ b/MiniC/TP03/tests/students/typeErrors/mismatchAdd.c @@ -13,4 +13,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 10 col 8: type mismatch for additive operator: integer and float +// In function main: Line 10 col 8: invalid type for additive operator: integer and float diff --git a/MiniC/TP03/tests/students/typeErrors/mismatchAnd.c b/MiniC/TP03/tests/students/typeErrors/mismatchAnd.c index 972e09e..2850c2a 100644 --- a/MiniC/TP03/tests/students/typeErrors/mismatchAnd.c +++ b/MiniC/TP03/tests/students/typeErrors/mismatchAnd.c @@ -11,4 +11,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 8 col 8: type mismatch for boolean operator: integer and boolean +// In function main: Line 8 col 8: invalid type for boolean operator: integer and boolean diff --git a/MiniC/TP03/tests/students/typeErrors/mismatchComp.c b/MiniC/TP03/tests/students/typeErrors/mismatchComp.c index a4f962a..724a736 100644 --- a/MiniC/TP03/tests/students/typeErrors/mismatchComp.c +++ b/MiniC/TP03/tests/students/typeErrors/mismatchComp.c @@ -19,4 +19,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 16 col 8: type mismatch for comparaison operator: integer and float +// In function main: Line 16 col 8: invalid type for comparaison operator: integer and float diff --git a/MiniC/TP03/tests/students/typeErrors/mismatchMult.c b/MiniC/TP03/tests/students/typeErrors/mismatchMult.c index c04780e..fbab493 100644 --- a/MiniC/TP03/tests/students/typeErrors/mismatchMult.c +++ b/MiniC/TP03/tests/students/typeErrors/mismatchMult.c @@ -13,4 +13,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 10 col 8: type mismatch for multiplicative operator: integer and float +// In function main: Line 10 col 8: invalid type for multiplicative operands: integer and float diff --git a/MiniC/TP03/tests/students/typeErrors/mismatchOr.c b/MiniC/TP03/tests/students/typeErrors/mismatchOr.c index 37a3891..2ea9ee0 100644 --- a/MiniC/TP03/tests/students/typeErrors/mismatchOr.c +++ b/MiniC/TP03/tests/students/typeErrors/mismatchOr.c @@ -11,4 +11,4 @@ int main(){ // EXITCODE 2 // EXPECTED -// In function main: Line 8 col 8: type mismatch for boolean operator: integer and boolean +// In function main: Line 8 col 8: invalid type for boolean operator: integer and boolean diff --git a/MiniC/TP04/AllInMemAllocator.py b/MiniC/TP04/AllInMemAllocator.py index b4ce296..b79fb9d 100644 --- a/MiniC/TP04/AllInMemAllocator.py +++ b/MiniC/TP04/AllInMemAllocator.py @@ -14,12 +14,32 @@ class AllInMemAllocator(Allocator): before: List[Instruction] = [] after: List[Instruction] = [] subst: Dict[Operand, Operand] = {} + + old_args = old_instr.args() + for arg in old_args: + # We substitute + subst[arg] = S[numreg] + numreg += 1 + for arg in old_instr.used(): + # We have to read them from memory + if(isinstance(arg, Temporary)): + before.append(RiscV.ld(subst[arg],self._fdata._pool.get_alloced_loc(arg))) + for arg in old_instr.defined(): + # We have to write them after to memory + if(isinstance(arg, Temporary)): + after.append(RiscV.sd(subst[arg],self._fdata._pool.get_alloced_loc(arg))) + + # TODO (Exercise 7): compute before,after,args. # TODO (Exercise 7): iterate over old_args, check which argument # TODO (Exercise 7): is a temporary (e.g. isinstance(..., Temporary)), # TODO (Exercise 7): and if so, generate ld/sd accordingly. Replace the # TODO (Exercise 7): temporary with S[1], S[2] or S[3] physical registers. - new_instr = old_instr.substitute(subst) + try: + new_instr = old_instr.substitute(subst) + except Exception: + # We have an instruction that doesn't need substitution + return [old_instr] return before + [new_instr] + after def prepare(self): diff --git a/MiniC/TP04/BuildCFG.py b/MiniC/TP04/BuildCFG.py index 7e4d384..ce6e903 100644 --- a/MiniC/TP04/BuildCFG.py +++ b/MiniC/TP04/BuildCFG.py @@ -20,7 +20,14 @@ def find_leaders(instructions: List[CodeStatement]) -> List[int]: last is len(instructions) """ leaders: List[int] = [0] - # TODO fill leaders (Lab4b, Exercise 3) + for i in range(1,len(instructions)): + if(isinstance(instructions[i],AbsoluteJump) or isinstance(instructions[i],ConditionalJump)): + # The block ends here and starts just after + leaders.append(i+1) + elif isinstance(instructions[i],Label) and leaders[-1] != i: + # The block starts here + leaders.append(i) + # Else, ignore # The final "ret" is also a form of jump leaders.append(len(instructions)) return leaders @@ -64,9 +71,19 @@ def prepare_chunk(pre_chunk: List[CodeStatement], fdata: FunctionData) -> tuple[ jump = None inner_statements: List[CodeStatement] = pre_chunk # Extract the first instruction from inner_statements if it is a label, or create a fresh one - raise NotImplementedError() # TODO (Lab4b, Exercise 3) + firstStat = inner_statements.pop(0) + if(isinstance(firstStat, Label)): + label = firstStat + else: + inner_statements = [firstStat]+inner_statements + label = fdata.fresh_label(fdata._name) # Extract the last instruction from inner_statements if it is a jump, or do nothing - raise NotImplementedError() # TODO (Lab4b, Exercise 3) + if(inner_statements != []): + lastStat = inner_statements.pop() + if(isinstance(lastStat, ConditionalJump) or isinstance(lastStat, AbsoluteJump)): + jump = lastStat + else: + inner_statements += [lastStat] # Check that there is no other label or jump left in inner_statements l: List[BlockInstr] = [] for i in inner_statements: diff --git a/MiniC/TP04/LinearizeCFG.py b/MiniC/TP04/LinearizeCFG.py index d3f185e..b38fce1 100644 --- a/MiniC/TP04/LinearizeCFG.py +++ b/MiniC/TP04/LinearizeCFG.py @@ -23,10 +23,32 @@ def linearize(cfg) -> List[Statement]: """ Linearize the given control flow graph as a list of instructions. """ - # TODO (Lab 4b, Exercise 5) l: List[Statement] = [] # Linearized CFG blocks: List[Block] = ordered_blocks_list(cfg) - for j, block in enumerate(blocks): + + labdict = {} + # We make the label dictionary + for j,block in enumerate(blocks): + labdict[block.get_label()] = block + + while blocks != []: + block = blocks[0] + if(l != [] and isinstance(l[-1],AbsoluteJump)): + ll : AbsoluteJump = l[-1] + # We try to find the next jump according to that. + try: + # If we find the instruction + b = labdict[ll.label] + if b in blocks: + # We remove the jump instruction and we select the block to use + l.pop() + block = b + except KeyError: + pass + + # We remove the block we used + blocks.remove(block) + # 1. Add the label of the block to the linearization l.append(block.get_label()) # 2. Add the body of the block to the linearization diff --git a/MiniC/TP04/MiniCCodeGen3AVisitor.py b/MiniC/TP04/MiniCCodeGen3AVisitor.py index ff75196..f26e25e 100644 --- a/MiniC/TP04/MiniCCodeGen3AVisitor.py +++ b/MiniC/TP04/MiniCCodeGen3AVisitor.py @@ -75,7 +75,13 @@ class MiniCCodeGen3AVisitor(MiniCVisitor): def visitBooleanAtom(self, ctx) -> Operands.Temporary: # true is 1 false is 0 - raise NotImplementedError() # TODO (Exercise 5) + dtemp = self._current_function.fdata.fresh_tmp() + if(ctx.getText() == "true"): + val = Operands.Immediate(1) + else: + val = Operands.Immediate(0) + self._current_function.add_instruction(RiscV.li(dtemp,val)) + return dtemp def visitIdAtom(self, ctx) -> Operands.Temporary: try: @@ -97,13 +103,52 @@ class MiniCCodeGen3AVisitor(MiniCVisitor): def visitAdditiveExpr(self, ctx) -> Operands.Temporary: assert ctx.myop is not None - raise NotImplementedError() # TODO (Exercise 2) + if self._debug: + print("additive expression, between:", + Trees.toStringTree(ctx.expr(0), None, self._parser), + "and", + Trees.toStringTree(ctx.expr(1), None, self._parser)) + ltemp = self.visit(ctx.expr(0)) + rtemp = self.visit(ctx.expr(1)) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + if(ctx.myop.type==MiniCParser.PLUS): + self._current_function.add_instruction(RiscV.add(dtemp,ltemp,rtemp)) + elif(ctx.myop.type==MiniCParser.MINUS): + self._current_function.add_instruction(RiscV.sub(dtemp,ltemp,rtemp)) + else: + raise MiniCInternalError("Unknown additive operator from the parser:",ctx.myop) + return dtemp def visitOrExpr(self, ctx) -> Operands.Temporary: - raise NotImplementedError() # TODO (Exercise 5) + if self._debug: + print("or expression, between:", + Trees.toStringTree(ctx.expr(0), None, self._parser), + "and", + Trees.toStringTree(ctx.expr(1), None, self._parser)) + ltemp = self.visit(ctx.expr(0)) + rtemp = self.visit(ctx.expr(1)) + # Getting a fresh temporary for the result of the opreation + # We could do only two instructions with slt + d0temp = self._current_function.fdata.fresh_tmp() + d1temp = self._current_function.fdata.fresh_tmp() + self._current_function.add_instruction(RiscV.add(d0temp,ltemp,rtemp)) + self._current_function.add_instruction(RiscV.mul(d1temp,ltemp,rtemp)) + self._current_function.add_instruction(RiscV.sub(d0temp,d0temp,d1temp)) + return d0temp def visitAndExpr(self, ctx) -> Operands.Temporary: - raise NotImplementedError() # TODO (Exercise 5) + if self._debug: + print("or expression, between:", + Trees.toStringTree(ctx.expr(0), None, self._parser), + "and", + Trees.toStringTree(ctx.expr(1), None, self._parser)) + ltemp = self.visit(ctx.expr(0)) + rtemp = self.visit(ctx.expr(1)) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + self._current_function.add_instruction(RiscV.mul(dtemp,ltemp,rtemp)) + return dtemp def visitEqualityExpr(self, ctx) -> Operands.Temporary: return self.visitRelationalExpr(ctx) @@ -115,18 +160,63 @@ class MiniCCodeGen3AVisitor(MiniCVisitor): print("relational expression:") print(Trees.toStringTree(ctx, None, self._parser)) print("Condition:", c) - raise NotImplementedError() # TODO (Exercise 5) + ltemp = self.visit(ctx.expr(0)) + rtemp = self.visit(ctx.expr(1)) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + endlabel = self._current_function.fdata.fresh_label("ifverified") + + self._current_function.add_instruction(RiscV.li(dtemp,Operands.Immediate(1))) + self._current_function.add_comment("If the result of the comparison is true, branch") + self._current_function.add_instruction(RiscV.conditional_jump(endlabel,ltemp,Operands.Condition(ctx.myop.type),rtemp)) + self._current_function.add_instruction(RiscV.li(dtemp,Operands.Immediate(0))) + self._current_function.add_instruction(RiscV.jump(endlabel)) + self._current_function.add_label(endlabel) + return dtemp def visitMultiplicativeExpr(self, ctx) -> Operands.Temporary: assert ctx.myop is not None div_by_zero_lbl = self._current_function.fdata.get_label_div_by_zero() - raise NotImplementedError() # TODO (Exercise 8) + + ltemp = self.visit(ctx.expr(0)) + rtemp = self.visit(ctx.expr(1)) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + + if(ctx.myop.type==MiniCParser.MULT): + self._current_function.add_instruction(RiscV.mul(dtemp,ltemp,rtemp)) + else: + self._current_function.add_instruction(RiscV.conditional_jump(div_by_zero_lbl,rtemp,Operands.Condition('beq'),Operands.ZERO)) + if(ctx.myop.type==MiniCParser.DIV): + self._current_function.add_instruction(RiscV.div(dtemp,ltemp,rtemp)) + elif(ctx.myop.type==MiniCParser.MOD): + self._current_function.add_instruction(RiscV.rem(dtemp,ltemp,rtemp)) + else: + raise MiniCInternalError("Unknown multiplicative operator from the parser:",ctx.myop) + return dtemp def visitNotExpr(self, ctx) -> Operands.Temporary: - raise NotImplementedError() # TODO (Exercise 5) + if self._debug: + print("unitary not expression on expression:", + Trees.toStringTree(ctx.expr(), None, self._parser)) + vtemp = self.visit(ctx.expr()) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + + # (not a) is (1 xor a) + self._current_function.add_instruction(RiscV.li(dtemp,Operands.Immediate(1))) + self._current_function.add_instruction(RiscV.xor(dtemp,dtemp,vtemp)) + return dtemp def visitUnaryMinusExpr(self, ctx) -> Operands.Temporary: - raise NotImplementedError("unaryminusexpr") # TODO (Exercise 2) + if self._debug: + print("unitary minus expression on expression:", + Trees.toStringTree(ctx.expr(), None, self._parser)) + vtemp = self.visit(ctx.expr()) + # Getting a fresh temporary for the result of the opreation + dtemp = self._current_function.fdata.fresh_tmp() + self._current_function.add_instruction(RiscV.sub(dtemp,Operands.ZERO,vtemp)) + return dtemp def visitProgRule(self, ctx) -> None: self.visitChildren(ctx) @@ -158,9 +248,25 @@ class MiniCCodeGen3AVisitor(MiniCVisitor): def visitIfStat(self, ctx) -> None: if self._debug: print("if statement") - end_if_label = self._current_function.fdata.fresh_label("end_if") - raise NotImplementedError() # TODO (Exercise 5) - self._current_function.add_label(end_if_label) + + lendif = self._current_function.fdata.fresh_label("endif") + if(ctx.else_block!=None): + lelse = self._current_function.fdata.fresh_label("else") + dval = self.visit(ctx.expr()) + self._current_function.add_instruction(RiscV.conditional_jump(lelse, dval, Operands.Condition('beq'), Operands.ZERO)) + self.visit(ctx.then_block) + self._current_function.add_instruction(RiscV.jump(lendif)) + self._current_function.add_label(lelse) + self.visit(ctx.else_block) + self._current_function.add_instruction(RiscV.jump(lendif)) + self._current_function.add_label(lendif) + else: + dval = self.visit(ctx.expr()) + self._current_function.add_instruction(RiscV.conditional_jump(lendif, dval, Operands.Condition('beq'), Operands.ZERO)) + self.visit(ctx.then_block) + self._current_function.add_instruction(RiscV.jump(lendif)) + self._current_function.add_label(lendif) + def visitWhileStat(self, ctx) -> None: if self._debug: @@ -168,7 +274,37 @@ class MiniCCodeGen3AVisitor(MiniCVisitor): print(Trees.toStringTree(ctx.expr(), None, self._parser)) print("and block is:") print(Trees.toStringTree(ctx.stat_block(), None, self._parser)) - raise NotImplementedError() # TODO (Exercise 5) + ltest = self._current_function.fdata.fresh_label("testcond") + lendwhile = self._current_function.fdata.fresh_label("endwhile") + self._current_function.add_instruction(RiscV.jump(ltest)) + self._current_function.add_label(ltest) + dcond = self.visit(ctx.expr()) + self._current_function.add_instruction(RiscV.conditional_jump(lendwhile, dcond, Operands.Condition('beq'), Operands.ZERO)) + self.visit(ctx.body) + self._current_function.add_instruction(RiscV.jump(ltest)) + self._current_function.add_label(lendwhile) + + def visitForStat(self, ctx): + init_stat = ctx.init_stat + cond = ctx.cond + loop_stat = ctx.loop_stat + body = ctx.stat_block() + + ltest = self._current_function.fdata.fresh_label("testcond") + lendfor = self._current_function.fdata.fresh_label("endfor") + + if(init_stat != None): + self.visit(init_stat) + self._current_function.add_instruction(RiscV.jump(ltest)) + self._current_function.add_label(ltest) + dcond = self.visit(ctx.expr()) + self._current_function.add_instruction(RiscV.conditional_jump(lendfor, dcond, Operands.Condition('beq'), Operands.ZERO)) + self.visit(body) + if(loop_stat != None): + self.visit(loop_stat) + self._current_function.add_instruction(RiscV.jump(ltest)) + self._current_function.add_label(lendfor) + # visit statements def visitPrintlnintStat(self, ctx) -> None: diff --git a/MiniC/TP04/tests/students/forTests.c b/MiniC/TP04/tests/students/forTests.c new file mode 100644 index 0000000..e05c472 --- /dev/null +++ b/MiniC/TP04/tests/students/forTests.c @@ -0,0 +1,32 @@ +#include "printlib.h" + +int main(){ + int x; + + x = 0; + for(;x<4;){ + println_int(x); + x = x+1; + } + x = 69; + for(x=42;false;){ + } + println_int(x); + for(x = 100;x>=4;x = x/2){ + println_int(x+4); + } + return 0; +} + +// EXITCODE 0 +// EXPECTED +// 0 +// 1 +// 2 +// 3 +// 42 +// 104 +// 54 +// 29 +// 16 +// 10 diff --git a/MiniC/TP04/tests/students/nestedFor.c b/MiniC/TP04/tests/students/nestedFor.c new file mode 100644 index 0000000..aa406b4 --- /dev/null +++ b/MiniC/TP04/tests/students/nestedFor.c @@ -0,0 +1,31 @@ +#include "printlib.h" + +int main(){ + int x,y,z,t; + + t = 0; + x = 0; + for(x=0;x<10;x=x+1){ + y = 0; + for(y=0;y<4;){ + t = t + y; + z = 1; + for(z=1;z<13;z=2*z){ + t = t + 1; + } + y = y + 1; + } + for(;y<7;y=y+2){ + t = t + (y/2); + } + } + println_int(x); + println_int(y); + println_int(z); + return 0; +} + +// EXPECTED +// 10 +// 8 +// 16 diff --git a/MiniC/TP04/tests/students/nestedIfs.c b/MiniC/TP04/tests/students/nestedIfs.c new file mode 100644 index 0000000..e72e6b3 --- /dev/null +++ b/MiniC/TP04/tests/students/nestedIfs.c @@ -0,0 +1,48 @@ +#include "printlib.h" + +int main(){ + int x,y,z; + + if (10 == 10) { + println_int(44); + if (10 == 11) { + println_int(75); + } else if (10 == 10) { + println_int(42); + if (9 == 10) { + println_int(12); + } else if (10 == 9) { + println_int(15); + } else { + println_int(13); + } + println_int(19); + } else { + println_int(31); + } + println_int(25); + } else if (10 == 10) { + println_int(2); + } else { + println_int(89); + if (10 == 10) { + println_int(68); + } else if (10 == 10) { + println_int(46); + } else { + println_int(22); + } + println_int(43); + } + println_int(14); + + return 0; +} + +// EXPECTED +// 44 +// 42 +// 13 +// 19 +// 25 +// 14 diff --git a/MiniC/TP04/tests/students/nestedWhile.c b/MiniC/TP04/tests/students/nestedWhile.c new file mode 100644 index 0000000..60622c2 --- /dev/null +++ b/MiniC/TP04/tests/students/nestedWhile.c @@ -0,0 +1,34 @@ +#include "printlib.h" + +int main(){ + int x,y,z,t; + + t = 0; + x = 0; + while(x<10){ + y = 0; + while(y<4){ + t = t + y; + z = 1; + while(z<13){ + t = t + 1; + z = 2 * z; + } + y = y + 1; + } + while(y<7){ + t = t + (y/2); + y = y + 2; + } + x = x + 1; + } + println_int(x); + println_int(y); + println_int(z); + return 0; +} + +// EXPECTED +// 10 +// 8 +// 16 diff --git a/MiniC/TP04/tests/students/operators/relations/testEq.c b/MiniC/TP04/tests/students/operators/relations/testEq.c new file mode 100644 index 0000000..202555e --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testEq.c @@ -0,0 +1,64 @@ +#include "printlib.h" + +int main() { + + // Testing == + if( 11 == 22 ){ + println_int(420); + }else{ + println_int(57); + } + if( -11 == 22 ){ + println_int(420); + }else{ + println_int(58); + } + if( 11 == -22 ){ + println_int(420); + }else{ + println_int(59); + } + if( -11 == -22 ){ + println_int(420); + }else{ + println_int(60); + } + if( 11 == 11 ){ + println_int(61); + }else{ + println_int(420); + } + if( -22 == -22 ){ + println_int(62); + }else{ + println_int(420); + } + if( true == true ){ + println_int(63); + }else{ + println_int(420); + } + if( true == false ){ + println_int(420); + }else{ + println_int(64); + } + if( false == false ){ + println_int(65); + }else{ + println_int(420); + } + + return 0; +} + +// EXPECTED +// 57 +// 58 +// 59 +// 60 +// 61 +// 62 +// 63 +// 64 +// 65 diff --git a/MiniC/TP04/tests/students/operators/relations/testGeq.c b/MiniC/TP04/tests/students/operators/relations/testGeq.c new file mode 100644 index 0000000..dd6a630 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testGeq.c @@ -0,0 +1,94 @@ +#include "printlib.h" + +int main() { + + // Testing >= + if( 11 >= 22 ){ + println_int(420); + }else{ + println_int(29); + } + if( -11 >= 22 ){ + println_int(420); + }else{ + println_int(30); + } + if( 11 >= -22 ){ + println_int(31); + }else{ + println_int(420); + } + if( -11 >= -22 ){ + println_int(32); + }else{ + println_int(420); + } + if( 22 >= 11 ){ + println_int(33); + }else{ + println_int(420); + } + if( 22 >= -11 ){ + println_int(34); + }else{ + println_int(420); + } + if( -22 >= 11 ){ + println_int(420); + }else{ + println_int(35); + } + if( -22 >= -11 ){ + println_int(420); + }else{ + println_int(36); + } + if( 11 >= 22 ){ + println_int(420); + }else{ + println_int(37); + } + if( -11 >= 22 ){ + println_int(420); + }else{ + println_int(38); + } + if( 11 >= -22 ){ + println_int(39); + }else{ + println_int(420); + } + if( -11 >= -22 ){ + println_int(40); + }else{ + println_int(420); + } + if( 22 >= 22 ){ + println_int(41); + }else{ + println_int(420); + } + if( -22 >= -22 ){ + println_int(42); + }else{ + println_int(420); + } + + return 0; +} + +// EXPECTED +// 29 +// 30 +// 31 +// 32 +// 33 +// 34 +// 35 +// 36 +// 37 +// 38 +// 39 +// 40 +// 41 +// 42 diff --git a/MiniC/TP04/tests/students/operators/relations/testGt.c b/MiniC/TP04/tests/students/operators/relations/testGt.c new file mode 100644 index 0000000..e6d6c6a --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testGt.c @@ -0,0 +1,93 @@ +#include "printlib.h" + +int main() { + + // Testing > + if( 11 > 22 ){ + println_int(420); + }else{ + println_int(43); + } + if( -11 > 22 ){ + println_int(420); + }else{ + println_int(44); + } + if( 11 > -22 ){ + println_int(45); + }else{ + println_int(420); + } + if( -11 > -22 ){ + println_int(46); + }else{ + println_int(420); + } + if( 22 > 11 ){ + println_int(47); + }else{ + println_int(420); + } + if( 22 > -11 ){ + println_int(48); + }else{ + println_int(420); + } + if( -22 > 11 ){ + println_int(420); + }else{ + println_int(49); + } + if( -22 > -11 ){ + println_int(420); + }else{ + println_int(50); + } + if( 11 > 22 ){ + println_int(420); + }else{ + println_int(51); + } + if( -11 > 22 ){ + println_int(420); + }else{ + println_int(52); + } + if( 11 > -22 ){ + println_int(53); + }else{ + println_int(420); + } + if( -11 > -22 ){ + println_int(54); + }else{ + println_int(420); + } + if( 22 > 22 ){ + println_int(420); + }else{ + println_int(55); + } + if( -22 > -22 ){ + println_int(420); + }else{ + println_int(56); + } + return 0; +} + +// EXPECTED +// 43 +// 44 +// 45 +// 46 +// 47 +// 48 +// 49 +// 50 +// 51 +// 52 +// 53 +// 54 +// 55 +// 56 diff --git a/MiniC/TP04/tests/students/operators/relations/testLeq.c b/MiniC/TP04/tests/students/operators/relations/testLeq.c new file mode 100644 index 0000000..7d3f861 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testLeq.c @@ -0,0 +1,94 @@ +#include "printlib.h" + +int main() { + + // Testing <= + if( 11 <= 22 ){ + println_int(1); + }else{ + println_int(420); + } + if( -11 <= 22 ){ + println_int(2); + }else{ + println_int(420); + } + if( 11 <= -22 ){ + println_int(420); + }else{ + println_int(3); + } + if( -11 <= -22 ){ + println_int(420); + }else{ + println_int(4); + } + if( 22 <= 11 ){ + println_int(420); + }else{ + println_int(5); + } + if( 22 <= -11 ){ + println_int(420); + }else{ + println_int(6); + } + if( -22 <= 11 ){ + println_int(7); + }else{ + println_int(420); + } + if( -22 <= -11 ){ + println_int(8); + }else{ + println_int(420); + } + if( 11 <= 22 ){ + println_int(9); + }else{ + println_int(420); + } + if( -11 <= 22 ){ + println_int(10); + }else{ + println_int(420); + } + if( 11 <= -22 ){ + println_int(420); + }else{ + println_int(11); + } + if( -11 <= -22 ){ + println_int(420); + }else{ + println_int(12); + } + if( 22 <= 22 ){ + println_int(13); + }else{ + println_int(420); + } + if( -22 <= -22 ){ + println_int(14); + }else{ + println_int(420); + } + + return 0; +} + +// EXPECTED +// 1 +// 2 +// 3 +// 4 +// 5 +// 6 +// 7 +// 8 +// 9 +// 10 +// 11 +// 12 +// 13 +// 14 diff --git a/MiniC/TP04/tests/students/operators/relations/testLt.c b/MiniC/TP04/tests/students/operators/relations/testLt.c new file mode 100644 index 0000000..1360b30 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testLt.c @@ -0,0 +1,94 @@ +#include "printlib.h" + +int main() { + + // Testing < + if( 11 < 22 ){ + println_int(15); + }else{ + println_int(420); + } + if( -11 < 22 ){ + println_int(16); + }else{ + println_int(420); + } + if( 11 < -22 ){ + println_int(420); + }else{ + println_int(17); + } + if( -11 < -22 ){ + println_int(420); + }else{ + println_int(18); + } + if( 22 < 11 ){ + println_int(420); + }else{ + println_int(19); + } + if( 22 < -11 ){ + println_int(420); + }else{ + println_int(20); + } + if( -22 < 11 ){ + println_int(21); + }else{ + println_int(420); + } + if( -22 < -11 ){ + println_int(22); + }else{ + println_int(420); + } + if( 11 < 22 ){ + println_int(23); + }else{ + println_int(420); + } + if( -11 < 22 ){ + println_int(24); + }else{ + println_int(420); + } + if( 11 < -22 ){ + println_int(420); + }else{ + println_int(25); + } + if( -11 < -22 ){ + println_int(420); + }else{ + println_int(26); + } + if( 22 < 22 ){ + println_int(420); + }else{ + println_int(27); + } + if( -22 < -22 ){ + println_int(420); + }else{ + println_int(28); + } + + return 0; +} + +// EXPECTED +// 15 +// 16 +// 17 +// 18 +// 19 +// 20 +// 21 +// 22 +// 23 +// 24 +// 25 +// 26 +// 27 +// 28 diff --git a/MiniC/TP04/tests/students/operators/relations/testNeq.c b/MiniC/TP04/tests/students/operators/relations/testNeq.c new file mode 100644 index 0000000..7904a35 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/relations/testNeq.c @@ -0,0 +1,64 @@ +#include "printlib.h" + +int main() { + + // Testing != + if( 11 != 22 ){ + println_int(66); + }else{ + println_int(420); + } + if( -11 != 22 ){ + println_int(67); + }else{ + println_int(420); + } + if( 11 != -22 ){ + println_int(68); + }else{ + println_int(420); + } + if( -11 != -22 ){ + println_int(69); + }else{ + println_int(420); + } + if( 11 != 11 ){ + println_int(420); + }else{ + println_int(70); + } + if( -22 != -22 ){ + println_int(420); + }else{ + println_int(71); + } + if( true != true ){ + println_int(420); + }else{ + println_int(72); + } + if( true != false ){ + println_int(73); + }else{ + println_int(420); + } + if( false != false ){ + println_int(420); + }else{ + println_int(74); + } + + return 0; +} + +// EXPECTED +// 66 +// 67 +// 68 +// 69 +// 70 +// 71 +// 72 +// 73 +// 74 diff --git a/MiniC/TP04/tests/students/operators/testAddClause.c b/MiniC/TP04/tests/students/operators/testAddClause.c new file mode 100644 index 0000000..50bc64a --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testAddClause.c @@ -0,0 +1,26 @@ +#include "printlib.h" + +int main() { + + int x,y,z; + + x = 12; + y = -21; + z = 14; + + println_int(x + y); + println_int(y + z); + println_int(z + x); + println_int(z + y); + println_int(y + x); + println_int(x + z); + return 0; +} + +// EXPECTED +// -9 +// -7 +// 26 +// -7 +// -9 +// 26 diff --git a/MiniC/TP04/tests/students/operators/testAndClause.c b/MiniC/TP04/tests/students/operators/testAndClause.c new file mode 100644 index 0000000..e6cb58f --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testAndClause.c @@ -0,0 +1,26 @@ +#include "printlib.h" + +int main() { + + bool x,y; + + x = true; + y = false; + + println_bool(x); + println_bool(y); + println_bool(x && x); + println_bool(y && x); + println_bool(x && y); + println_bool(y && y); + + return 0; +} + +// EXPECTED +// 1 +// 0 +// 1 +// 0 +// 0 +// 0 diff --git a/MiniC/TP04/tests/students/operators/testDivClause.c b/MiniC/TP04/tests/students/operators/testDivClause.c new file mode 100644 index 0000000..72d2465 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testDivClause.c @@ -0,0 +1,24 @@ +#include "printlib.h" + +int main() { + + int x,y; + int u,v; + + x = 3; + y = -4; + u = 41; + v = -31; + + println_int(u / x); + println_int(v / x); + println_int(u / y); + println_int(v / y); + return 0; +} + +// EXPECTED +// 13 +// -10 +// -10 +// 7 diff --git a/MiniC/TP04/tests/students/operators/testDivZero.c b/MiniC/TP04/tests/students/operators/testDivZero.c new file mode 100644 index 0000000..5c03d5d --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testDivZero.c @@ -0,0 +1,25 @@ +#include "printlib.h" + +int main() { + + int x,y; + int u,v; + + x = 3; + y = 0; + u = 41; + v = 0; + + println_int(u / x); + println_int(v / x); + println_int(u / y); + println_int(v / y); + return 0; +} + +// EXPECTED +// 13 +// 0 +// Division by 0 +// SKIP TEST EXPECTED +// EXECCODE 1 diff --git a/MiniC/TP04/tests/students/operators/testMinusClause.c b/MiniC/TP04/tests/students/operators/testMinusClause.c new file mode 100644 index 0000000..1c63fe6 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testMinusClause.c @@ -0,0 +1,26 @@ +#include "printlib.h" + +int main() { + + int x,y,z; + + x = 12; + y = -21; + z = 14; + + println_int(x - y); + println_int(y - z); + println_int(z - x); + println_int(z - y); + println_int(y - x); + println_int(x - z); + return 0; +} + +// EXPECTED +// 33 +// -35 +// 2 +// 35 +// -33 +// -2 diff --git a/MiniC/TP04/tests/students/operators/testModClause.c b/MiniC/TP04/tests/students/operators/testModClause.c new file mode 100644 index 0000000..d4a70bf --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testModClause.c @@ -0,0 +1,24 @@ +#include "printlib.h" + +int main() { + + int x,y; + int u,v; + + x = 3; + y = -4; + u = 41; + v = -31; + + println_int(u % x); + println_int(v % x); + println_int(u % y); + println_int(v % y); + return 0; +} + +// EXPECTED +// 2 +// -1 +// 1 +// -3 diff --git a/MiniC/TP04/tests/students/operators/testModZero.c b/MiniC/TP04/tests/students/operators/testModZero.c new file mode 100644 index 0000000..3783dc6 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testModZero.c @@ -0,0 +1,25 @@ +#include "printlib.h" + +int main() { + + int x,y; + int u,v; + + x = 3; + y = 0; + u = 41; + v = 0; + + println_int(u % x); + println_int(v % x); + println_int(u % y); + println_int(v % y); + return 0; +} + +// EXPECTED +// 2 +// 0 +// Division by 0 +// SKIP TEST EXPECTED +// EXECCODE 1 diff --git a/MiniC/TP04/tests/students/operators/testMulClause.c b/MiniC/TP04/tests/students/operators/testMulClause.c new file mode 100644 index 0000000..6ee151a --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testMulClause.c @@ -0,0 +1,31 @@ +#include "printlib.h" + +int main() { + + int x,y,z,t; + + x = 12; + y = -21; + z = 14; + t = -4; + + println_int(x * y); + println_int(y * z); + println_int(z * x); + println_int(y * t); + println_int(z * y); + println_int(y * x); + println_int(x * z); + println_int(t * y); + return 0; +} + +// EXPECTED +// -252 +// -294 +// 168 +// 84 +// -294 +// -252 +// 168 +// 84 diff --git a/MiniC/TP04/tests/students/operators/testNotClause.c b/MiniC/TP04/tests/students/operators/testNotClause.c new file mode 100644 index 0000000..fdc4671 --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testNotClause.c @@ -0,0 +1,22 @@ +#include "printlib.h" + +int main() { + + bool x,y; + + x = true; + y = false; + + println_bool(x); + println_bool(y); + println_bool(!x); + println_bool(!y); + + return 0; +} + +// EXPECTED +// 1 +// 0 +// 0 +// 1 diff --git a/MiniC/TP04/tests/students/operators/testOrClause.c b/MiniC/TP04/tests/students/operators/testOrClause.c new file mode 100644 index 0000000..3f0667a --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testOrClause.c @@ -0,0 +1,26 @@ +#include "printlib.h" + +int main() { + + bool x,y; + + x = true; + y = false; + + println_bool(x); + println_bool(y); + println_bool(x || x); + println_bool(y || x); + println_bool(x || y); + println_bool(y || y); + + return 0; +} + +// EXPECTED +// 1 +// 0 +// 1 +// 1 +// 1 +// 0 diff --git a/MiniC/TP04/tests/students/operators/testUMinusClause.c b/MiniC/TP04/tests/students/operators/testUMinusClause.c new file mode 100644 index 0000000..ace123d --- /dev/null +++ b/MiniC/TP04/tests/students/operators/testUMinusClause.c @@ -0,0 +1,25 @@ +#include "printlib.h" + +int main() { + + int x,y; + + x = 12; + y = -21; + + println_int(x); + println_int(y); + println_int(-x); + println_int(-y); + println_int(x + (-y)); + println_int((-x) - (-y)); + return 0; +} + +// EXPECTED +// 12 +// -21 +// -12 +// 21 +// 33 +// -33 diff --git a/MiniC/TP04/tests/students/testTooManyVariables.c b/MiniC/TP04/tests/students/testTooManyVariables.c new file mode 100644 index 0000000..408e750 --- /dev/null +++ b/MiniC/TP04/tests/students/testTooManyVariables.c @@ -0,0 +1,37 @@ +#include "printlib.h" + +int main() { + + int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z; + + a = 5; + b = 2; + c = a + b; + d = a - b; + e = c + d; + f = d + e; + g = c - e; + h = f + g; + i = h - e; + j = d + g; + k = g + h; + l = c - d; + m = i + j; + n = j + k; + o = k + k; + p = j - e; + q = c + k; + r = d + e; + s = c + b; + t = l - p; + u = d + s; + v = m - r; + w = c + u; + x = k - m; + y = g + r; + z = l + n; + + return 0; +} + +// EXPECTED diff --git a/MiniC/TP04/tests/students/whileClauseSyntax.c b/MiniC/TP04/tests/students/whileClauseSyntax.c new file mode 100644 index 0000000..e4a5a15 --- /dev/null +++ b/MiniC/TP04/tests/students/whileClauseSyntax.c @@ -0,0 +1,22 @@ +#include "printlib.h" + +int main(){ + int x,y,z; + + x = 42; + y = 0; + while(y None: d = queue.pop(0) for b in DF[d]: if b not in has_phi: - # TODO add a phi node in block `b` (Lab 5a, Exercise 4) - raise NotImplementedError("insertPhis") + params : Dict[Label,Operand] = {} + for bi in (set(b.get_in())): + params[bi.get_label()] = var + phi = PhiNode(var,params) + b._phis.append(phi) + queue.append(b) + has_phi.add(b) def rename_block(cfg: CFG, DT: Dict[Block, Set[Block]], renamer: Renamer, b: Block) -> None: @@ -43,18 +48,19 @@ def rename_block(cfg: CFG, DT: Dict[Block, Set[Block]], renamer: Renamer, b: Blo for i in succ._phis: assert (isinstance(i, PhiNode)) i.rename_from(renamer, b.get_label()) - # TODO recursive call(s) of rename_block (Lab 5a, Exercise 5) - + for dtsucc in DT[b]: + rename_block(cfg,DT,renamer, dtsucc) def rename_variables(cfg: CFG, DT: Dict[Block, Set[Block]]) -> None: """ Rename variables in the CFG, to transform `temp_x = φ(temp_x, ..., temp_x)` - into `temp_x = φ(temp_0, ... temp_n)`. + into `temp_x = φ(temp_0, ..., temp_n)`. This is an helper function called during SSA entry. """ renamer = Renamer(cfg.fdata._pool) - # TODO initial call(s) to rename_block (Lab 5a, Exercise 5) + for etr in cfg.get_entries(): + rename_block(cfg,DT,renamer,etr) def enter_ssa(cfg: CFG, dom_graphs=False, basename="prog") -> None: @@ -66,5 +72,9 @@ def enter_ssa(cfg: CFG, dom_graphs=False, basename="prog") -> None: `dom_graphs` indicates if we have to print the domination graphs. `basename` is used for the names of the produced graphs. """ - # TODO implement this function (Lab 5a, Exercise 2) - raise NotImplementedError("enter_ssa") + # Compute the DF + dom = computeDom(cfg) + dt = computeDT(cfg,dom,dom_graphs,basename) + df = computeDF(cfg,dom,dt,dom_graphs, basename) + insertPhis(cfg,df) + rename_variables(cfg,dt) diff --git a/MiniC/TP05/ExitSSA.py b/MiniC/TP05/ExitSSA.py index 5b385d5..c319a13 100644 --- a/MiniC/TP05/ExitSSA.py +++ b/MiniC/TP05/ExitSSA.py @@ -4,6 +4,7 @@ Functions to convert a CFG out of SSA Form. """ from typing import cast, List, Set, Tuple +from Lib.Errors import MiniCInternalError from Lib import RiscV from Lib.Graphes import DiGraph from Lib.CFG import Block, BlockInstr, CFG @@ -24,8 +25,10 @@ def generate_moves_from_phis(phis: List[PhiNode], parent: Block) -> List[BlockIn This is an helper function called during SSA exit. """ moves: List[BlockInstr] = [] - # TODO compute 'moves', a list of 'mv' instructions to insert under parent - # (Lab 5a, Exercise 6) + plabel = parent.get_label() + for phi in phis: + if(plabel in phi.used()): + moves.append(RiscV.mv(phi.var,phi.used()[plabel])) return moves @@ -38,11 +41,34 @@ def exit_ssa(cfg: CFG, is_smart: bool) -> None: for b in cfg.get_blocks(): phis = cast(List[PhiNode], b._phis) # Use cast for Pyright b._phis = [] # Remove all phi nodes in the block + blabel = b.get_label() parents: List[Block] = b.get_in().copy() # Copy as we modify it by adding blocks - for parent in parents: - moves = generate_moves_from_phis(phis, parent) - # TODO Add the block containing 'moves' to 'cfg' - # and update edges and jumps accordingly (Lab 5a, Exercise 6) - raise NotImplementedError("exit_ssa") - + for p in parents: + moves = generate_moves_from_phis(phis, p) + if(len(moves)==0): + continue + # Creating the block + ilabel = cfg.fdata.fresh_label(p.get_label().name+"_to_"+b.get_label().name) + i = Block(ilabel,moves,AbsoluteJump(blabel)) + # Add the block + cfg.add_block(i) + # Changing the jumps + ot = p.get_terminator() + if(isinstance(ot,BranchingTerminator)): + if(ot.label_then == blabel): + ot.label_then = ilabel + if(ot.label_else == blabel): + ot.label_else = ilabel + elif(isinstance(ot,AbsoluteJump)): + assert(ot.label == blabel) + ot = AbsoluteJump(ilabel) + elif(isinstance(ot,Return)): + raise MiniCInternalError("Malformed CFG, cannot have a return in a parent block") + else: + raise MiniCInternalError("I don't know of this terminator type:",type(ot)) + p.set_terminator(ot) # This instruction might be useless + # Moving from p -> b to p -> i -> b + cfg.remove_edge(p,b) + cfg.add_edge(p,i) + cfg.add_edge(i,b) diff --git a/TP01/riscv/ex1.riscv b/TP01/riscv/ex1.riscv new file mode 100755 index 0000000000000000000000000000000000000000..5959395a137460584c4d125d6d1ec89315327fc6 GIT binary patch literal 132448 zcmb<-^>JfjWMqH=CWg-pAf5zN%mFHq@E;_~z`)ADz~I1O!NAPmz#zdO&cMvTP{6{# zz+n9tst}E`MB_tDVF23!G7BM%EW^Ms<03=`Ml%RN_#jnm3`p`1K_UzcGoW;ZAVeL9 z5QK*5a};cJReHeoM62b!z=d??t&Jr%xf2gJO;>7tzd*ojGCKpq#N(c+!mO&k`2rsb zn;NEnWMG)w*tkNtm9bp>8v}zd+c9;{zDC#g3<`qcstgRmtViEV9)+-6E#C`l$a~N5 zfP=|Zhk?=UJ;MVQ$Ni3iN)MWkGgh%ZnfM-Le&gxNRAJUu$>|IX49^)D7+T$x8$MPo zN?=NHWNc~xshD`WGIermV--l1I5Pu7Is*ekQv;(Q+Z&}93<8tcCon0iefig{e&k=P zI*hfi^<%nlE4%J{h6IsDce~a{2~H`ji6C7{FT5U9rc`E5WW;^WA#WtOZfnnOT z^oC^&%Iw=27PD<tn z#!}frqaS8}^uFwRu=IL3YC>D8kLm|7Ah;-Y*f_h zdhfuHD3fT{y6?yPfPm;#Uzi>-JxgZeVrW+9VomN~k75?*Wb90vEY8k+aI*2Y>kOig znAJ{lZBD<=Fnc;XV`cg5>+FuT;)VUn5^Ug))6o)?pN|dkf};F@0eAV)wE6I1fY9pQaB? z51F1aJ&9^gZe^EAYY}D-U`lR!ZqV#5!obS%_xEm=DUQhyCZY*`R6)H>CNse465_3o+S6Pi+xOI_7h=P%+JWf%2FHC z=+)>lnR5Z_Fi9C!=E$Wn?A?6slCyQ z*`0-9_H-?V-RmP$OFFV8I|7ZWeOnCh9<)36`UIAs6 zg~A|PTRmI7C-XE4F}-2*X?oH0rs>J#Pbv(_%}flPnv?&!a7-#sp2o|tyUoh+vF8O2 zX7`W0yvLc<8wDq`edJX(xXi$+-s;xMu55CdL0RXaz-%^l2D?wPAfLKi*GO(DGxwgmSf0P>3 z`d&eSA*y*%4=6?-&u4!$seI<)e1Qdq&EcGklfSdGfOrhi%?6F?%qEQLN~z5zjcUx6 zjB3r6jjGI6jH=C6jVjF6j4I96jmpe6jLOY6jY`b6j7rV6jf%pIj2cZ1lb^6KGW)SG zG^)(pda5<3^}WCaCdq^O0t-Sxc4)f4?0!7;`Hg0AO~%Iu*>4<5OKXFuQYhDYlDHkD zyHVv(+T`ynOv3GL49Pw0N^_F-bta!;SNR+MnDLL=uXHoc=Hy{udIO2e$6f4?S~YFAVwl~}F4eq~jbZZNFZ&yH ztzI;`GrBM4f5=lCp3MJ7Zt|DE-y2nuCvs*a3-h>K{6G1(ECa}v$GzM?CbKgzFJ}EH zF_~whMCNu-x_>;4l!@lDj8=Z((@c$u4myeJ{K4clQ4> z$vo+f>{c&0n55p=J<@yj-XTGD)zwb-q~yn(Ujtg*A2WQ-n9MG~_L%dp-eh(G7Gd@V z*2k=W^@Pj+{{0)i>rJxAABKDZhJeZJ1uV%T-x=}+68tu0PJYfJp!RiAcB6Xo6;6hH zfd`^ZPxrMjy~$?~(1*B5?8o~8htOmJ)~HG4hl-+_=WcFRYZMgj6=!HFpWQ9S!0HA{ zWB1yGd6*fKQykSr_`NNR)Nm-{* zaITvp&*KAS)6tF~~53`1O-*<57<9!6!8J78T0 z1wguzkC#=al~0kBZj)x%%)Xpa+29U?vdJ3;yHCnGAQi&QJdBSo9lHc^|NDXj&tySX zze(j$&6b-de`jHQJd>RXoK{$xSF$lYZesU2BsuveC$sHVkZkfi_BtflZg#KPGdUS& z-{f>W*Z%kx`z@;%!t58AAThp~)4*|AZ>#%b(KioR-IKeXdvLlZH#}FH%zaSeUeDz3 zl?;>H*_jvj|M@rhrX@pK`(K&I(>VW4{wB+i+{>minT>%tx%0Y8rTF6hJO6ffzjk=n zva6?cHz@TRnC;whC>>PFH1A<&nB3dW@VJ|Y>u>mDu0Li;ZH=yJtx_-EJ3Oe>dgGKV z`7mF=LF!R@-V3HTySt}5f>QM4lfVB@zWLJ`l9o6BtYl>Lc|4Q-($0NOU{hN?Wth6H&=k8-HXXjTo@p^(sj>d_6_pe~3#o1eLDV zJ10uWAo!wd=Ke_}<_{u}o%CGRT&F zA0Bh?E_&R?zNq;)J1E8$O@6}S(5RxhXYvyfs0%H(fcy-x(J5r0xN^b29q@wq(A4S&$ND=O&0)16wltzl_OG zSXdfWba%13Cr^0}3RNLa_hr40r#!y}Nn1+glfVCD_$#w(Iw(XY-}GcqZurCScq-?= z-QBYt-?iv&6J`%!dmO#|C@6n1x;47l{gL|degT7~Q}LtnWHDAFQ2p>RZE_o%F{?VL zj%j6Yb;GQS9(!Ep&Id1C4K_0>n@nZ|<=lq? zj?9mP-~5B+S_ZykF;<~TiMr_GG0etH~oy$j~1 z11yejLFGu`4rEsx^po{Zc57p_UEyexe7BDo;fl)$R|Lac@xCB|LG$H7KSvvw-(>wC zAMg7Ms-+)IhlEHoSl>kfP;20E#Pueq{RtOp7{T`Ef4JWW6Pr-|n47ibQTpR9_O^Yk zpt7TYb?F9HP->a=eA`m@<#D2U_5GV=!`Uoi`+cLnlgY#oY+c{g z2bpmpU-2uXR>}XM4;6o(P>{#_6BNq%AM!uJ(@+OT_(5-3pX6iH7#bHGG)cZU8yedn zcNT-g3pE9~{dk{nA@i{a>$`&{kdQu95!L+o*z7-`kX|-j*#M+-GPu?Ng>-T}%w_Kr z0@5B!u)dm9p8sL}JH4>vr~?6N=}l#`x!D<#4?NRK4k};g&rD2dcj?9m} zu5$?=|NXyq`sUxS8Pw8ubC)|NdlVQhOB4Ri;$Yl!hap*>y#So6+^#cB{wBikxQ~rP ztqfGJ9xL56y;TiVdny}jW{_@UV*u5rcAw_DIWj*!e9Wq;%(&wY!)ERd$C>k_+qfB$ zFCSyr*4?O$?51W$X*O{Nn41nlQj!003xu0?cb7RP2Npbphb}CK9xG!EU3t(t`9_U5 zBo*Myp9umXkHuJTKtdLjKPP_`VR$@=wE^UISPlR9ZdofNw%;cR1U{Byy&_cGtlcOW z)sz20zU6V;g(grs1eFht9&>#_X)to(L9^t*8y>CNj=ahSdl;2Xco-q3Ir2QdT=O4d zni(kl`8*b5y#O)qP+3%uqsPtdlfUya?tBa?k9om$dvY^7v~IV0(dwT6q5rAycM*nU z7WNCG`#`0w-HZGW{d*UsFY1wbod3c9(xLP@$@@CmZ)1kbO-R{Nv1sigbl2^6of8c*^^9W*q zGRFsg%LSXS&t!W1#ccV$&a}3s(#bsE{)cl9HL-#2J`AEOj$BJHTKxeb)z& zJx=AW+h=#PF+6rExbC=lS+C+QNS$T(1r#DIkQ%R(_%P5v&z(0D$%o0DPk6BPzf z%T$@+Bi~|%h5U^wu$FD7d;W*~OOv0lD1iD|jVi1x`5)G=0-4EfX!oTQ)aqtJ$ndX( z#LfGJ0;9*0tlL02`0B2i?z6dh7?R(#M;B(?>&$yGnWw`j{{#P8xC`;!Fd#n0fxn&1V1mdv+T;1GsmZbDaU! zQ!GpuW@q=>1@13C>g{yfBbe7dnWK?knBySdy;i@rpjN35?-edEr=^41)l9{!dXibb z*Gy(lVA;&El`&cBI|H*jD>!_US-z*}h3}dHYU{?eo@;gcA@$+?1ObCX6->p)+B9G8 zZlC68_dzclWX`T9Y3a$F-&H`SCa@$6e)n2cu9n`~y*d34!{g8g3Xf;8%Pq?m=1pK* zRX+JUyTjwz>|(GM-{zmzjE$NL*Ssrx{9Wv~FgpYDDd;Ci5f8>5p z3+3oxNUFXI>w6@85PK}kIt!AcqI&W_tUm&a(E!oM0?0D&kATWQ!mWp7x9b+kQfz!p zWuSZ)+MmqMJ_Dl_0qy%L8yp7rf0Ny>`#CZ{U2q80n}g)yE_MM(3w`Bgn2QW}9*eV1 z0Hv|~5BlFgCAwKVs65`xnE#=FBCO5xenNp>QgX5rYZ|C+C=BZPL@YNf%$Ur>p*Q)< zm+!E?UZYB{XRkM-Px1`*1^FM&H@9j-dLDZi^FQS8NNbh)@!sKs>uhdT29PQnyzf}7+f2H zO6+8p;|%#9-nZs|IKO%FcV30$es+t=KY#K=$}#?#lfSblBsW6DM0bLDt?XtX75N|f zr-Auh>?X5kb~4Vs+39$$J^w>~zgqg&@MQPzD#@;IRGP}w(vzLOCqUBGuI|R;%gT3m zKWBiXr^e&U(v$r^6u^86NmIhS1#BSyu1inuV)vO0?gf41Vf1O$%zrTd!>07))9ePI z@BxQ&*z!~*MR=ZeOAma_R$eQ<>qA<4t@*AuU1^{csFj8YVNmLUwcH$;lh57eVJl~LV`oSz z-^|wTIJ=dNL7JV7Avt&(!>+bQwdAl1;PI7h)0GWi_2p$~=qH~#&Ba#k$PCgA(lhz! zxBq{qzU>p8pX~F1!Dvoey6$hc^khbM8#jwxEKIwKy z?Vo()wFS&QMsqy3!@}%Abh0Sx15lVr?uUqh>cxhrWGU8rZRLl`qMDhHu`^662l>Gi zs^Wb@LqxI^>m9u?kiMxKL2=Zfdvzy7|NDdmVad|0w?K0FAKrhS>AiAGQ`zS3I}Dq< zyU|)4`5*LuSK5Ng)O~N3r9Vp*W*1-q_1?E#om~ExpV2LO+Ea$T>XW~J=Vx_O=J?15 z>OUr5XJc5F-s(1Y9ys-IeB@i|o_y!J&1Alh{AFz`T_>{}uvtIf#H-)aJl7BJ;MkbeMSh3>}&ZO{!e`K$)5}$(S1)nH^I~@*eA=g9sTcb>-Er5|T{9|o z&E}P1=yaR7>rrp7+s;krTH`<^*n$VSD+J#=DEPf!z>wHg#_0Bb!hzPSJHzjY6sir2NT>R8qNSbF=<+VEX3UZpX* zxwYwL z%wN2!98`n1c0ZoM-tw+2|AT!SEUpq%k|kMJw3Wm1m(iTR+d%ON8gD4v1yjYKlq|-& zOfMXgm)0KvnVDtY9-68+O`6J*w zs@J&dV}@h6HO~PDP<#2Hx2$in+cSo>3mk2dFL$#;N*qvY9nu#9mpH+9p(W1y1O>@t zdDc0Q(gxI8{~K=iB>#c@Ql|1{<)CsMRQ9W-Cwo5lwY&YbL#z7iZgvJpf8l5U>`rzD z#VxIBn7z}-G1psQZf6iqmSdd;vq5zeDE~=51Gg+WKk^B)8}iR?XJZ!O+01s`0W=CS zyIo9Z-=DP`UzP9syDYu=*x&!m$G$VXYfqND#xR+cfq8NN_J8lnC%1k7zwK}HvG4yM zb6ooesw*e6PGA-;`^KN#x{YCR|M7pkd)3mJ-IjydvRjw+=6~>?s8!C|{g|2kkm1f` z79NKD2m3d&`s6=|-ze#m|KR@ynZt{E@*mVshUJR{8&JMjAoG4fgFYl*B$$HII3!;@ z5Jk-w?fUzkJlzNiv$k?!_7D6`FF@_~rZ>qQ&zUB(ec)G11J5>GJkHcsYR&%4Vb_!9 z%-%D*Z-uYA4}gkpDTTL`*Wtn>@1*pp!^5+O{?0Ow>Fk; zYSU}m*P8#}{MF{`tc=X-j&d?k#Y0a*~07$4$20NKFSgw8T49Y zB)eLbZ6!O^FkN~7VEu(vEylGY4jFmWb|!n=xX(9eb1m^mU;DW$j$A| z+Z#(61(jZ?Jz;yZsztA5=HVUQiszZdSr|d{U6ae&84ga~c}^r}?xt=SGZ2wa(X4l@4;ntc@hrq0mlD)@*ez~=~~>(g(Ozq50^y)2v#3XdlYwV^ln z+qJ%DNQgl-`|hX7-`E+~9-7!a_q9llaC$of$X;cMCkzKC-~1;0ja_3hD}%ygrfokK zwW_tgS1?cq=@-cXsX91$>vo--#

zUD%V`zcQ$S%+CbLE8DQJh~x;DZ~v>T!onc( zAa(mv_c;d;ZdtiKwlL@e^RC7cuODqsm@T{H7d=q>q_yp3IiOk0X7x^n87Y6wlUv$Zl((=jB;IaT=QP|st&4$Kr<37pf1`Tmd#35k z>YWVD=3Vm1BJGTi+tq)cy=~W-xxHE4)3AAKivUQ~%;!<9Ow%9kS61m{DBZ8u$~67s z_EoK*-Vmc}eu98f^K@3m%0i_NeoxrGsJ-!eG5K3NgI>$3&a1CjL4B}>DXusBm1lfq zNDjClV387e{E+y;$*pP4OE?++_9-vmWZFDk_Eo(U?t+i!1jZamcALQPa=X^d$H5c+*d*{&ENk;> z^J{II-Z|&7+k$@}cP}bn%PlMv8^F1i9FuH>Bir$m=3$N_mvPny9;1 z_AE%BRtu=yV0#17JMlayd?!9f=v@R=ZMannG+(X`l2=N7dim*g&{~REIgUc_DAW5+83`6es6+agguFRz>qq*U0v1YtuT9QaId?v#nT{V zm9Ig{2CP97-L*PpPAIxHx+<%&a48$GFesa_FeuxwFeodqFe$6BFbT7|aJ|1E|1&bX z*@TnvW>#d@%}il#?LU*dUi}y5(qf(5>B)I8UD+muS=k_jRoTRaRoTLXmEp%y_Bjx9 zm$7guZ(v~n38FImC3zD8B7utAEJlxb!ySb?W0zs)2obFVXE`za` zs%~5dO3OdfD^n)7vr7xJv`EYLfNGh^AtnxuClW>MrpP4x6-g9nn*Q_;D0MFaua>DS z^n0@XCnJN>2T(Z{^nmS)UYAzq&wYEH)arnJLfD5t-tY8x$c6|^5x#+LkX7;BJ zk8geZ(Y%eZZ1Qt)2ASugz1zPrGAOTEX0~xebV5Yr8EdC8$2A7ehs?$-|Cud17|g#i zG8nU`J2YFcGYYe^PMkGexI%&C-$SY+N zaYki>9}I=tn;Jm&E8AT82XVpUkKcYwzBZjf&@DOt8pq^o=?v1X)0m}2MH!^q+L-xR z^`?p>I*KNv4uDS&yZ!{_Du&crWtWDMjMtqXdv^X1rrf%vUJTPL|=| z@&VvpKLPXI*2NeC;@c zbn7=Zh&!LL@v$!4ziqnYcInn*tPrtntbD8!x6k-G<0Hp=j@K~%U)%}`Vd*e6q|lx7 zRCd2Gn}cX_&NYU~*S<4Ix3;lE%qU~$V`bbf%;pdZkyB@sZoLMTJI2n(dUdNXD?`07 z+XMEOdqJTJiq+n&v4vhg{JsQzfV5ZIo`6~}dR@YttU-+4lerkUTfP5Ag4!O;CY+4P z(I1#*w|xKKB+@vcm1T2F2=k&Tpt>*l_iu(~aTP|T*5o#GMy6TD*{O_-+Msgi@x+#Y z%$A%CkL5Xkp|)%mWk4^CIa;Bdtsh$|MgCSkf`0@NLHnC@W8 zfw^Qdn=3=3dnRjQh2RR%EV=T8XAFnLJJ}9SPUg7E#C)BNLAXquLGlnNU$QoXTB(~; z*%>QuLDX)8s(mbT^-oj7WVTjDMt4qD!4=Zt;ta|YzA-q7{}gkaoXmZdsTpL_weJid zeUgWS)5RG;ttjC#b%x1L#TgQBL3C_`>Ub;(GLKQvF;7{VkwIC8k>Me$4Tms?BSWnm z^L18+pW;77S&tjDFK24Lq0Yd3nVn&C*>T2W(;S;8-(X{un(j7TdBSrB<%!oB9GjKr zKmYf58v9>Cw#jS@8JVxMGjy_ZvMI|y`}cU(^?#uD1amkmLvy$)gXCew^qc+4Grux0 zhpRFyO#dsM%>SKXGJ7h+LDoc8h|Zs)$`hY5Jf5}uA84&(DnlkzT=wzfIm`bEx2rO) zYwu)Np3na8vF!JM&DT{K71L|QA*MDp2)DDM$bT#cwJSmM{ontC>}_gj4tHf>6a)?Ff_VrwKs>cGgOL8Pitei*sm=3oni9zHipMy z+y8;oE2@Chzq~KZ$-u?9f>q`H2m8m#?wt%EIooEn*4pc+wYBhf_799Mtj~oxKYU|c zQET%4L;dZ?{3?H&ue&g)wLblgsv4BeCbKSOWOSEY07?te*V-8Z`)5yYX8@%*P+PT= z&2jSM$yfh@^e2YoZU?o<)!wju@p|F+WL=9^OY&(}w!Q9pZGxz;gNI+HMa3*%%~kngejecIE14^1W>`D>!o z`u>Ccm8X9YbrqzpI~s1yxxpd%_E)yatgVcVo*;kNx-o~hFs^Ig{PHCO^Y!Qde~K$l ze9i!l0U;I!N6W{KYX2Q0UBj(8XF4>xC!c=8X3hDNVXk}fId$e_UQUMQ@D|2eOQqJ< z?#(ZMGQ9ur|M+8Z&VMkQjZF<0A#M4m;Sl>C-}w5c*&XDMC5#{)jqad)*~umy*3NLT zUs}AKL3#eSe~>=ieLF2Z+s&ud4s7-QOIp%BYxDD>nQ3cLtE0 z@`SGp&0(sHli67rh1*>jKK3b3yviWm!N!o>bc{*3J(WRu5-UTcX!A98hM(e`?8@@j z|2>xa`cHWdD??KQNayBnY>dgX*%*a6R2f&bF<)b2=wuUo^>_~3|Cg*F_3Zy1&wct2 zlxI;VO(E zH6Rs+hr2-W^_fQi6mR=KHHR`XG>0=XC3kFRnar-pAk41FWWWJ(cPIPOcc7T(WMBH~ zvBbB3jIN+E8B_)@Y6s<>$!sc&o$Qj&A9q~;1>$$I*WL!Hs0;kkU30|p*c*E zNtj)cVKTcSla53uJ12Xx%r%C`UE6;#hp{t&?BQhZWCx8CJ$`uXmo@7Ghs^z~t~YPi zhI;O=4Xxb|@}JrtSgm8$xv!<|38=5E)v~VBsB2f(`w#mMOlD``H0E6CkbGykz{2#O z;>mZ_<&(R)WSUpGFidd}ZePMUx!r|1xg|^)8nUwA|4n9ZU`}rSrICCwTyQcw150xE zFQv)s0_@3?e`$cqor$S|-YdNqrfa%QW@}?;V^f~>gh6>p38V7tEey(YzA#)kV%&a( zL0R-WgYtq9My1)wF$%KG;oJ<(*IXDUvwz?)F1yZt=Y>R znZy|<$4zfzXJent=EAUOy4iG47|c8*oF>MgJOLDEk7qpp2RG^1xBsR6$^x$$ny;rY z8h<~|5coPdR)M!U+=U@|3cJ+8bWpziDV}^xonKi{g%K3~sN(^kxJZuS6qwA;@I5)| zC*Ndt6^2X}P`(GHu=amHw?A}GZv7=PnLU6xdFn5T)^uU^5A~B-85|6~XL?U=XK#>n z`@5I`ud*@x6sr`|n{GFKayUDq^2BEht=*3&ANlv#UEwn* z9+O*tF@RF0d_TyKA0LDK_c)mIld>QS1MhYa4_f96eqor*?!u7B0u8mf?f*Epqxeqt z%fF+0XR~sG&HKMj@L;Rwt*!||!Eeyi5r5TiFKlV^~ z406-s#$O*mB@ejVdH$0DG`9NwgM9_?gou5PG)7`Q1qVY zJ(--Kp83ZKVDmO#S zP4wRA-RiFEws*H|;i(6HfAl(=BUKsN-Yj~t>`Bm%O)YV6!oEa(NP3a>B2?f-?_x*3JpI~g0@n#0){nnT$bD#fSv_x4Y|#?A<; z2V1);#U2a4{nzRf)cXFz`p?bRkFeB=c(rbR{)a(%+837hAM!sv4l?<@sLd_qS;C`A zr>aF&Ox2IFopKiCFy$_5_iA01!j{SC&gjDN9~s_%xZiVj`>OWIY)=^=rJ3UU z$8)~@6J~c|T!a*M!t5#tKB%1%uEMx5?XTF?eo(7SS@H`*v)EIH#~0XsErOQnfxjNh zT>qC?zOx@B8@XMWodsdS+~@y3mV-uqps8B&3&YgypmJTbaM4RpnZ4}ksfT`l+ujEK z4Eq}OG45^B%e1Fi58wR(mF25IWnhb0rzA?5pDe|$1gcS+uWQ0feaY98+cX)^fy?bq z_GA%=iqfpftX=J(Uda5}$*inO%-2*HnXhXyg4%D!rQaAfmwsnRmio#j+@Zp_tQ}NN zb+Rvg^mq>Ye~^mgX1izGZDSVl)D!r;!RdH3n%J#}x zmBW?$tX4O%sR3+q<5wBARvwP`ANF_fNce&3tB&RpsN3YkG3VFNV$6 z)0rpFW@ny!o11w82M34=(Wp zK_%W#vB$#G{wq(YVvLbMZilu1R~BJp>EwDmG2|zsdyIrI+d>vdxQF&Xo^$*kqxxpk z2MjV2!t9>Ru$-zqAC$ts{acjIls+--uh{0U=MEear`mtxohc2J!7|9C9HdWUoGV{VQoli6JuK{{FfJ(m6Q&vGxL2Xe~z z`4`j*0mm%kR~FkQkeQvF$y3>d9?!n{57a*2*gt#vcLq@Yz?Q#2`TZt1_gvgOxm5+~ z(!b9i&)M?NcYlloC>E2M{&2z5fyDa{{`)txFK}QES7fw%a&h5RZpe%U>+%kvsg#PYrbU(V4(e33{R*%}PhJ|WhSG6#Q zLV8C^KfOK%y=43A_crWl)Wds!9{qUs#kk@rgI=dmi&*snZqDCd~@kHhUA{FY{|ku1VE~m!Ab{dcA3YsfByTLI=QvA-3ye;ZzeOaN}=fM z{VK(LRfW;G{3}DU@OK`#UMY4ykX}eyN}k8A@p!h$f8p@2kUrt;uL6_VG#MEefk>}* zQ22AQCr<~ZgJ=Ih>Ekiak8h`7?hpj&{swgisFc#bn9Rc}0J0bEma?x5#^v7_%sOVX zvNI&l{l*6J35dOSJ0$h8fKo3cO-nub_o~3FWK{`Q<*Q7utW{ZD+0UxoYL?Y#CN?#w zwSwBk>ksk>fPAcfusKALp*d2K>F0|W1{03t?r$=%)CH7|nS>TYmLNTLO z0_^trUw?u81#^GwcSx#d)c7k73IUMI4z)gJ{_(CkoRfi*GkGq%*kfr>`v1nT6MOof z3##u_VEtgpFAR;_h1oqBA^Ji2?aRN%QZN7M60B1cw}V|c_v;go3oG~fwfl9(2$)C+ zzE5tuE&%fxhrs&}=et2ZGwxjJ0O}P?=ImltmVU*gEcJ^?nEe&Yxpr7<>-j%no>MH1 z-jlf+87K2NG6-`kvM^ueV)!X#`m#Cv6iZV3=GVU&n8Tj`uM}4nJkIcV_RD|DGF(iL z=gs;n%(1x%4YIAL(^Gp7iyR;BH|?#+$;-0-T$^Fx#=R z35zi^)r#4@0kssB4I0&yZ32~*O$wEjO$61HZ6>NHTPUh3n;5Dp8#t;eTO=wg8#F2_ z+e}ncwpggBY_d^t-3O!JR!`hM*u7ZQwXNH!C7Fqj$s)AX{Zs4i>CYLI)&4OktGr`) zFR&o9S=~`uc>@=l-3uPh4uSU{-oI@QQ{)1>@as2*&W_Q9T*1I$4N42UL55eWCSHNsi;P?+23HiuJ~y|+}D$B|ER0i;F()kmD{k7u?2PiAHl0NM4J^_x_) zI3v&F%j^m~lESRLrSCuFPf6xu3Dwh2gHYTMMB2Wkmy0IBaGiaPmto2;{uTyQmf7uJ>KZaSNChf##||=yxSMurgh0Q)*iTw!41C1WuSc z_AlSfGMiy`_;1GD?dgotx5XVE%Xa<-$xmkOEj0qQG9L?bGK$MCkdd6srpN=zV~>T{ zKXkH#Lb=feBnR>x#1D&FJ2>Azxc_qo=OSo33l`?){};7#NGgjk^1Xj>|GSJNb2zv} zV+W7TNtyf)YU7dY;8Yf2$44<< z_onpZ$*&of&KG81z$D$m&X64Pok5so0h6YCGWTl>X>M+2VfF`1i#Za-l{p`ZB_CrK z66P@!Z}bu7X5>c>Sw^>atcfLZX%C4Dmx4l55*(V+VxXS=R|Y4s zpQ4VF9?vxW8`UNw328HfMpL)JLzB@>hly0vmi{GEm+QM$1E%I1pz&KahM%I9V#lVh znl20q&52(bSUVpJBSO=E26Na!`N`}u46Qn|S=qp=e3G4}Fx&MoZg&$qnC?31ueh?{ zK_0s=f46~D3iBw6Pi8k17j#b!JI*5Np3M9#iTU{R|C8IE{}(R%&TiD6?8?G4ne_pa zFlz(zWDW-AWVUTl$pKGenvZ|`uiPNU_*YE$8%W*L?ZWH=%*y@G|Fx=oOjT=}+}awQ z)cRhaAg4K8k;^GvSz)3KsF$Ry^-v1bBT8mu7kQM%?9M1YyIq7~&Y@H7yvHZAJzz@a zyDq_eT%4hmz4rHHwg8so)SnEDE0WvQ8JUlN|NmF~vGnzS$_?xcr`jj8F)#_UU0`B9 z&d!j`a-AVrV1@;|xlHy=~_uJ+{M z=?u%-h1nRG!K;a;9AnzduHu*+@SO>?s!ekNm>2n-q1pY(|Hb?)|7t}Zw_pF)>z>^3 zn`cqF@)9n#*`3oF{<wAF%OsiUw znOHNFH>_ei)%spwLoQP}=W&qv%cjdbZZ>FCV>V#~?dDZ&wro^kwqjIiwrW&nwq{gr zwr*5nwqaCiwrNykwq;aowrx}ZuhLN!W@J=vYLMYXsuQHyoj|2kQhI0l>r(v{NZIPaWq_XOq}bB4d}k6)XAZggF_ zeNj3nx9#fz<+aH?3z%lN^Dx*wn7RuTs*l;&pF!ehasTswkNMf3Ab6?YcWwoxg2fyU z#Xz|dlp|YJk^?>{fZVc}^P^a;i7=0&c<)9~nfftxaw}_+S8Hd=djSEj$t_66=^b0`ab6!@Axx!t{e-vdysW%uJ_d8fMFJy3nrp0w-9L0`~b zb#^Y0EzpviN0D#ei%V@2IB&IrdPM76c1X~1^eIQyC#gLJzX0~@>2bmZ{} z&}h@{)}xNIr@1jqoqH^8@^n##ZQ$`YP;LCRAG8YAwlVeT98M+p_)fCWH73v)&*K?? z{zbK8x_EcXT!yyvi=311$}&8j`14b9xS{}axFSyg)6V&Y<L!rf2mKAZS>`gF+zu*_A5UlBw{=USTmA?BPm9w3n!9e^BcaqjnROwD z<^r()+O~fH)mosCc+7F_Uvs#kkW=~3{^aiGIy_R~`u@TErXDV(*7pzOo0!8Hg_*+? zMVaFig@xU}|9291oUAPIP-rvjIfqSc$#EN4PPIA%ObzWq}c zVU(D{#UllpQ(|QR)sN5qb+STb#3ZCnwQDe=ritbMn!^-DH?tmdR2E?rF>6b1WYyUA zW-|MSZ^>uAvNWo4NWFjX{_(T4Rjqr3b}%uAg51R@n#^}phtW@%RZ$e|r#R5ef-&1M zM`N~Yj>2(ljLH*_GYHqoF;t2_p0NBMs~e;R-NE(#!T;_>tsvU}=-b_o(v>+F#k^XS z7qBy|+_|VdLI^Ro_Hg&2a!~5NdmfyNA|bhGgD5B$Iqm_qwemmoe+8A%!l2RfvhQ4z z*#($eRTlSu``5dLRZY3!7{kgvkP<|4!Q-Cm%RsFj(7XVm1gYEuvH@&N@qb!W{#clG&SNK*1>hQlP5tlWZDI_QkA3_9Xj=0zHip)& z$1QC0K(z{}b}?$t-2^r}3S#yLPLSCbceSd6+*rGdfeX}{djCNG@x*jcZf+D3=4=!Y z=28?C?tcD%GH<}&=I}< z`%|n^eBJa-(}h7JqZ7X|uy#EbcK_cTuE@_E?#SP(t}OYHkMTT6Xa5|SXe(H>^m}u7 zqd@C(kZ5w^ZziSoIg+R;Mjh1J68dZMc;c4tJd&XF+P?x+F0q$G+Q|7I&Yxcd?KeM` zW--PvPv78*kz&5e&d?kRYU6RTCkt$4nasLS z#Z8(R#c+vL`#+k{zLW8XVGP)~ldl%>%X zlzKZio3(d7YZgxwO}@>}A|EDZ@P^5P=qpL8VqHyy)b_UQ$ z#ZU1{@v>=J(}Y7IsT$N8IsTu~&33a_+YByta$ z^QP1@kc^ms)TvetX6AdW44tf?_SUigk7q3f$%r(%hHl&<1jwwR_&?R!*hQw{Sf}H&Y;&Kd46(xDf^s!>1 zXXjw_oO)WAi-84Vq5>bt#7589ufpHi6*T{UoIUxuI)gBK2|LJyR(FX95^rQKbZ!T^ zqtSEi{$^1XMzz-W4hsqypMrFH?gy%dIPBS z@jsdEiJVM|NRB|p$JvXf&qx<}H{lg%m4{dBjOXte7*d2;Sr}^oSMdCe!LegaR0{P^x)2$|7pTdyb$gUyio}BvKVDj}82I;ox%(KPB7^GXAO{H`d@atS%1rot9~(D0`;y17HIqp*XmB@{%Vk% z-fB3xr?HlKIS<2bc6UbQ1%DX!wIy?{v4fbB%=q15Gkdq=*7+bA;hNtJ$?QC4t?9UY%b9{9$W=(aJZs%q&<|<`uUe3dy zyd#rQI7^CQC)hk?6K}?3W)tgLx8$NQYmpS;_O5@9vs=4v_K7@M>bjZj2}94bo>$3P z&uo~jx*4KcgxeX*MUs<0e`An&EZp7*V*mZ7BJ+6S8pxVOM%QNvZYiKytw$)cU8;#q z4GsC6YL92NKR^!S$BZnmWm5jSL1G~J_%kWxEu75C8#tMhJUl9XFVR)ZE=F{9J@V;>n^Z$~$HQkHC>MO)DSUl8 z!$h~_PtW)+x+On)CN-P&IP2`Gq71XywzKxJo|`%&@t|mO_frv(^pCTWzg}mM$bLNg z=|7%)P&(y#Bk`i)CBu8h?Sbye_1}4f*&SGu^S+BszJ7#3y6rm~Bu_kN>tp-6kyUSU zxgCQe>%-GBxs3Y-GA2J2Vc>ZJ^3$Rz%3EeKDQ}p`H2Jw0gYq60M&%tWjB}nSP4{XQ zdHkMXffmTUihCzN6JZbm`39ysO&qRz%9BOYy;^5He$Q|~9i;m0X5nil471rGBQA_; zee8Gl313fVn9Vw!8RENk<~~;5?a8br{Gj~BY}LXbTy^UIX7*VQ$*Hp#YTX|@eSZVm zLvcWf(Y0{5blY)Oh;O#D_OV&+Y&K_RtTjuXlP)&7+>F6d_~~!v?VSvhkAMCDvmcZy z+E^by-G1b8GwTs>%)?TEUh4g#w!gcDxwx2?ZUm*Q+1DT|2tla|q_1}CW^QlB&D;f! zm!v1(_GSj>Erts@f5REw9}9myRl9LAXyxLIXKcdPk2B0>{musQ&2zRs)`@$C*&Rfa zGrqG;zW#+lx~-iZ;^K1lKDMpfKzSaNA9uHb^86hJ&Yi;IKFp8B*bjjGA2th=N0m)n z7%Mj_Z^&j;+!)moxUtn;+2l9F+r5)Ps~X=tV-ddoonba>J3GYAa`ryfqnm}<9YT|H zzOzieuEHqYb{%TxarQp8r+XY_l4gNs`xxEt?wicY!syld{=)jRAp1Zr0fjj$$UmXU zkDoCKUsq?G&3YYb_Hp(;*1*k^*+8ozKd=k4K48z?GMSa3elptw_N|*iX|Hnc4EKzq+Y;}MWE?u4hcGWhlhi?cBX_BZcnEM(rnSTtFbo#|$;tg}R- zZoe^`I3uXHQrK@?&d%uj|Dm`d>*JKq|Bn97-40qMZBq+b1I+fu>w#9wx|Y_%!qZI{ zc1`a{<~=HrIODOh1uFw&6*S~5KVdcjmW8hG4GaV{{;X;*{K@Egb~~%5wb)DsqfS{i zF1A)zrPlWb0eq=fS&k~JsWKki-gt6`t4%E*`>yFTl4m^ZdEC?hT8)0h(=l1;184;r z+n1mRdY!8}&02&zS{WNXYK5ECIT!>vS~ZNnr!!cyA7`3w)>L(eJFMna0-0s5A#eQmf!|_%XWv!VE zp!xhqDT^|hvb1O{f% z?w9SI>=2hL8@yyt-k=UzDZ~)eiEMW0_K#_$ur@Ah0JktJYv+4|1(lYCh+PfaTJ%~L zsx5V8`vcnFu+)9`v29FRotrwXx{@zX=W2CtbOp63TU8&Qz5Wk0zjXiEs#eF7t?n@= zm33Shm%1n4HD{kZos&tJdkRD2P)7;Cc9fq93ks$7foq)V?okY|D2Ttq-)B*M+HtL$omiU zT0yN(O_rserTZIQ*P{6H0T0BN4%v?7nffm1d47(2ty=GJajRnV$^VO9pFrUn^Dt@g>^${Fn18qZDsCeFa< zI`?g(fA6a zmQ}U!In>0%O%1cJt22O1<5Ye7>+JT~*WDRF>IGFF{<^z;_VsoKkQs`qSO0-{?2I6D z9bJ!p1M$=uWDaw>HZ>q}2`Gnm7j$qbwV{BgO%Bc1Rw9i24 zgI?FBmgM7_jHlYywfJ=!b?xiC<6_NX$=KtPe7T(gl!osgPUdD65oT^>oGhWjFl)xF z_T+M5Mo=GqBKzaF;{Sy?x)_D$X);XiYhj!$s>$Fq@7vVm$`kyP+ov!J`X_(;DsV9E zuNdcw*_W6YlV>xr333QBCs&@}ZC2u7*!=kt!{Zj_f3upt^*6dOFXv}qUdF^Qk!f@J zb%x#T=1Uw$M5(5+RXl#vE?wxbdZgYJDGkkt1&aoYW~*0sfE$Kc{xAB?3*l%rF~!fcejT# zH7{{yn8-Yl-}vVhhTZMvj63H`PiJS0>{DKM_#gB2_y1>KXJ@o#4`;GwR|m@nDY*3W|C3ACpTRF@jHtm@S3-1?fcMe#`U7Ebn)2PT(`Fm%3V zZDBprkzjamRSSs!_O@EvDeySp{fEg+oGh^Ng|!8>gwg6O1g}2=l~=IRO08`fSf~BH zjt9yHtPHDKYPV~3x^Dk#UJBYrH@}O0*YpX_jc)Hh)UVR&T)My26*S&hzi3s9H*uI z*({O_dM!p>J+7-dg`>k9lCMt(&kljgt?Bo*bIMEZzR=|73A?CgJPP z84KC9rf+MX$gaE&w5ss=zsb|Nm?qzP&UkHFvj%8AWDBEk*)PT}j(sysPYE+KFj+Gn zcG%X+=+3-?ona#DM0RV56AZ@b?2O9mp8jKAe*C|6csj%5N8rzQ)kh04l#21!KIt9)Lm_vbWWm^QXhQ7NeGAK~53S*|ZN? zh1uH}H@9D9Faw$P>#Gp+vg7}o)sFxFC|(FQEjj&~K#$A&5A$1+Ia!667rQVv>$@;M zWD%BAW)S9RVeH}ut*1Vir>vpMs5bA=e7!cc{zi|#a?I-d49#jB41#Q%%da!;ZWm|V z{NoykcAR~UjS-ZKMd#1H#_ni3f3_GqwWtt$Ui%R-SKh$kKdcy z`W@zqrLuH3F}f!|>1Pn0uEwA@UC=H0X+J|NoA5L>hD}p8_Z?+O{&s}*U}{<0vbMjX zGn@q3CbDfV-_8KCRr&_IBgi&uc6LT-33kS}{h)n5jp`tKz_z?R_P18fm~WngaNW88 z#_i`ACq8dhKmNbgxKRA*eNc(3td+_D+u63Poz-(ui(Sj#t&hDq|1o;r-P-8-{=@lC zqDMh0!Kq${6|NdNE*Vt7aj76sk1VR73=!Q>dzqc}kvaQ^`bM|L$v^we*$@2LIX^k_ z14ENotNp>P?4Oz%tl2*}%noyRJnNo(?mEMEb`FN!*RMM?x}mC)Za?<#r+ceg z^0DU(+u0Zzc3*qO(CCh;2GlBY@l^UC%+ku(#j-Oai$_rjHXu1n`9r>ReyPQp$E%bkKkqayH@|ORKhjzCeci0_%oxxi2B!hA0 zPloO6AM8Q2wb*fn$*nE_CyR43fld!eF5JSzyxir#b@+9Lz7L2rDh$dBs~DC|KjAGc62kEQ!}<3hdlL66xz9Lr5T(ReU;s@|5uo^8*P_F~ z_65}L)#`lzLH=P5gIX)d*Y7{XKWJ9>WW3<9$xX?9;{4gu!x=>9?{0g}u&q6qo%K<2 zkmmv_H20(v$+wp?uy1WFYTwRSTx%L!`c)|RZ&Sn9bUxO}?d%g)P47@{Y6$WA zYdZUCs6(sjWcD`3F19Y#ebZJ=P5yYDNvj=PCbJ8&E9E(z$NcQcDt#` z@$C$cxsU&8Y5?_qz7ZHWbqRurO$}Oo zf`y=6tCRT{;pTu$+4K@(j$YfhHXaV_CN*dvn*=&%9x^V<_T;_60>5NWR)(02MG32> z$Gm`?Ee{$^tu3z=|JlC?JcbJq1%*6lCpf6R1KRZp+Ql#Yon1h$WmSt&=eADS#}GZB z(OJ;AEmO&&f^%(NZHqFUGSylirMM>MD+tJe#$!7{X8{{9C^w6FZ1;C$cI zu&SN;I4eUddn+qwUb^&mQ-fAp==R0TYz$2epuWCV`^wiKxBU$jNLFOuTz-vV+w_b5 zSNk7#ZvWTp*8YDp`*Mes$C}-y|DSuV*=_lM5PLhAef{I6 z8=ud0PyTY8g?V#hVe<~gB3ZvFiJRNg7=%xJ`@i`+sOA@EY<({BI8jWIeIe`Pq;vmT zStqlD&e&)^_VvFo$G88B`>+3NJZ0DJ)CQ4B{npfAG(DMvgQ1muaX+Mm2O3*|pMMWJ ze?&NyU>m1;d>-*nkK~JtP6^5K#9|bzu?H;a^>z%Iaz)r5$a(wJC zfemzWy%wVv;^g`Y#L4x3t?v)?Pr*F7{(vbcg}_d(PspU!$@P$voWUm-LQdOkVON=x zWY?K|h+XY(_+!pLNw9P1A9HYuEOmeUO5IgqT>zk-%TgZv@bJ?Yk&Oi+)kO7^63O|$nf&P|NkTdDIzecpW zCyRUqojETIK4p{TZ`Nekx%3Qwvrx~aZ%_oCdkHz0zQNxJ`CR%CPKJC2g9_NW^aWWE zmx=v&Z?M2ESrB$EeImYd>7y{tr9V=}iRWDULuH(xGbBN$)4X>$PzpVlo`Jx*^oNN! zm;UmxD-id;H#lIGECe~1o^?0qM9#;v*jd17hlLq*E`2|HkdvfvBqy^h_+0wO(_p98 zgJnC|gQO)n8KomR9Z$7CzQm4lF1<0Q0_0qJLD0GMk9(fq;B-%Jdu{|eo%UYOchC&%aRLp!Oym&XQt>jGC2?4VV<^7nt?NZ3jB#+Bfc>gTXu*t-pW9{pXe0`&9fU+$Uw7VRweF7^yi zJ^-EN{&y$nv_a4bzo0YOYC)&fLr-@1-GcvQcV?uM-BWjhV*`4!`_#vvIGXu>@^==N z$Mf0q5U097Pz9Z5wy39YALy(=na6?PvxUK@yEFeQfaF)*Eg;uSW^Z6iW(13|G^$AM zL7Yvmxy283!taCiEzpzjKfM39s@)HA68;1KW*Nju_zb-B9`~`&X$GBy-^D%$auWW_ zO`!8WKz1~$)b0Y6At3hSS?sew{XkGCq;5i-*g z@EQB_o}Yo_6Q%OW<%l!(g(IP7?2B^#+YLTrf99UuZCZ|x120VZia3-0An|9?gIr_w z-9r4y^dPsqSJ+TU;>q+aFjolV z!B3`dhKXIsdCbk)_6T$`eaAjfU9#c+?8FVrdiQRFyRn1g0P&~KgWPxwa{9c2K)UN! zGESe5zWxc~IYVomjjZEkCic+ zEES^6& zJr-uYCR7VMkA8m3`b2hEaWZbaZdj~*1;pj`aH_OUc8mh=BSU9eh^ohyJH9*9cfWmSH`Ea83RXV|~r13Iss8FpU%1JF74cA#_YZyZVoiRORszlVO0Q2vMWPiBKoi}xzHeQ-Bu z9bdaX%1QBE>`I{e6nauTH=&c_&)-RXI(<{$<%c)_kd2O2DOlqyV->xsqW@xSZXlfc`VC150n}tw@>CiC?WhE zlp2vSBwZd}%D z^&Dxh*R&+_d-;G$|8l*$D*tq=x2bR+zo57y*Kz^ zla!q7!kPkVDT2>yk6vyII%gRDTzp>0x%gAqXXHQl{}+0j!;^N~!i>1iJjiVh5AOel zwBPWackgiB;c+nAyRV2dj1L}!o?+~})X^sSes?DBGmJrL^S#1>^kga4Uz5rqCuD!z z-imZefB$munfLANCc>3J`8RF@^IF->K)n19`F&u17rTkHWGAC^WT)e)_WTd$+rTI5 zH?bRmR6$DQ{2pP#w@G-mn;K!>CgI4*2kPf0bN@}jb(;ie2DW`0uG=I)CxA+Qcz@vi zJwvE zw@D-iKgdX)$)19In?&*~_83@MX#7)~kx_H*3fS4@#-6aV%LVtpD|`G`>?gJxCOo%; z?;7y^&XVl?hNTH~*MP%!7l^Gm?ivU|wGni_GU%-Ab?M1X>}H@ncc4BDqYtZQ{)76f zc+Z{hd@7@i@4WfT*WD(Qci#M`>yg6boi`tQ-9Zg{-aO2okn`q2;R`x%o)LQ9JmdaN z>B&dgdEogn0D51A{?d)0{0LnaZOzwhptJ75{of1z z>%nK;Gq5^oy(!!YI2^{^(A~+4r#BoX`v>{=-a9xHg3tIiP$&nP20r84U_m(Q8Q<)NM4WwZ;1Ket9Lw4F z1`UPav+o@gVx&1)LFacmEJ#5*``*AHXjwYw?E6#XoPBTbAdIOv*>8csBjmI14H~>b zXWt7~N-`u1a0<8)IQ#zTHt^Z^b?y7Ddh$Qy?+2we#Ci1f^WkUTPh{Wqt}JvPEcO=g zCrh#}LO%IE|HJzquvkvr1yiTMn=Hz@0Cx8M`8^=>VQ1eb!Oy;r-<;RBAq9Ha__R<{0H*Ou%3M% zeZ2wdb^(LBWLeN{G>|l%|Ka_Aa5+Kn^!tzdz$ewSvF|&(4RTWb{0*R!>g_lD1)tBq zf0_*VtoryVuynj25R{JJZ+!1?zy*?y7kDAkv4S>gItHCpueuvlmbTICta?zWuiS(0 ztoqzd_|Kl_|2XkEt0&|nd&4cb&ansC^LG>Il=|2$;L-c%pi|j@G2}m}Z{Fyxyx=DT zB+TlYo0lKuiY*L#v$Yv=q9^3UH_%CMt=*ft4jz`tVzy>u0IegfjoN#>*`%9+*@T;+ zvtf2O3qx{50qb9r$(2S%QZb?pIb} zV*t&Zx)%C<4}1UaTif$RkJbKr{SNvZ^*Zi((&K0UUi~tAvZ`xc=cZo9qc)z&t?W+B z(=l#xUWWB1=NUgiH#skZ-{j28uED&$lQEf-UE?L_Cg;ZIT3^!}1Shw%A1ci*&0O@M z=||HQrFNzlOn;i5G(BK?VE0CtoBO6PC+Dr^~3>oG<%TT!Y&3fadNK+!(whmmcKELE{wjyTnkv2dbjd6 zs!wKJz%;v!{U7K)yyWClEW*>+m?nokV@yihG;NAgQ(L18^D$nA+0#@Qmd=~q&i)s4 z>VPyW+uz+S*BM%QK`S#Je^~twX2RpbQ-A)RR_6K02C}Qwo7GF0r;)wUXL6A)1Nio4 z?PXz;>wP(nm4oh^*wmUljh|t6Ux{O~|Ao|M*Fx5rXD722vbM5|JZ^OpdA<+iPq*aL z$6_|MIkK~=C3iD1ZQF1d@n0ulywAKriXe^vMGvan<2P4!CcAX`9t zZ){YUp(fN+`^s)G2#7({}*}R9xGRB7cTZ?NM>VZ zu%RsG6}%HEYNmGiA8tae*%CFoxAWL`#)3DUgG40HDiC-X9bSc}po zm-8|Sx3w{RJv}FBUw86Jc7ea)j~o85OfLKTy-_WB0(aHpDLf)(y+%(OeHgujc@FYE zYfrxH!+5E^*{zTjbl1h>PPP}byTutYw}R8fg!_*l3$Y4-+y=hwdGhmX&C@j*AD?Hx zBA2o#ZC?V&jZ#$z_vN*nYu#46t1_(hS5{?WKEnqAOxJxp-@KcRVRG5u{f%lyPa54B z-4=5nWT_2H?mfdM{Q28=kYAFgaJwZ>0+itZvB-#~nD`l6#J;2y-3e4eFWvy&7^$F#n%_lW$uyB(>GbJf6n= zZ}L|$hU89GmC39O%*n0WRVu|6^Y8g*&2`GbtkrkLgS z_Y3$p-Q2e*9hAbEK{p7uwKF91^5pytPwx1Wme$tjn$&9c!RpET1N(m}r8ku&bFr3L zbG15}J!$lrxpz?-NMEb>9H)hBW=}vl1(HWT?p&1K;w;?L&X9bUC1f|t1c#(2!pXi2 zuoNVXbyO`<}c%p#NGVlc^kJ zg4v(P>^$2Zx3X;m?HPXD$hJ*5nb!f7l4kA`PL_p-#lmf%ln&DIcs|=E&{+^5xAH<< z$98}%x%YYyEX5i^MH|?XJFf=_C-bs^%#++UIgOXGQEgG`FKtNSbm=oBaJZL#@oF>7ZGn$+x{3lo>#` z19Shg=IU}Z>z%q2RGvMKy0G)0Yx3=@k)SyX#ud`7Y7CC->)H<5B?sPTo!u(N0J_CY zol)83Ipe+`>#jV$u>arR!;liF?8EyH`#T>?v+ioDTNdW%f6xw88cDZ`G0gRU?0o<4 zx9Q3TAf4A4_x)IPWv*NDon9UaVcoPW?4aL48<>f*{*RB& z`}+*)mg$Vpvh?sV8Bj@GxQErP(M_q{bvw+A{y&d7S=Suh!s-eVf4Vohg&kvW-S^?K5bL5t@EC!(5)^WCoge$&{|$;2 zkSUPxo9p)Y@U}0G?9y$b4C~rtH#NGox+=97Zg08*u2ndgIl#3_hy$lm`$0Fgu;jaL zrl8q2#uc;KKry4&=4h3C*N1sFD#U0 zHZg|B$9?{SYB-P%cgB4`wq22Re;j;$%0zftja#e~%#dx6axA=W*BazmNaaom`gQmRj}0m_$F;LkuxlER!^IUQdH-m7pE(2&S zfHKcTmc=|D!DSMxF70#=-SMhz?ly=iY=#I^uKt@`#>?1xXi*xd?)BZD)N1v??8*BJ z|0gn)OLMU@H2UO!$p616b#fUmI8F|pg2YJT_E&92PtI;^bxZEK&e!Soxa<0+S8X46 z2q*I@G#{5`0F{WXy!jvW??dVsgb4q=neNhEJPgV2rn462UFtS_BFxhVx@Gq9 zdrwdP{hJ>Y-}xWx8zz_YDy%#Y63PFt{vU|9^YHB1-HfwucRSu|&;QW>d2$)A!opJ^ z6?gYS(ntP>^Uox`Vz*CbFJ#^Ku@#!L^FQc6Y)V(2@Qoq=gZ?>?-t+I9K(#MZ{s;b_ z5EjJN^FJWG*sYKlegA=fTmFah&(pdn5NKY(Zpi9pE%uCI^NSM<$}7YTl`U>4bh;%oTxFWfrq0mE z#;QK!__pai;N6jv+1VA8ZNAIJ?r&b^Zpi3*u}^u`bpup&O%1i7O%2T38%rGpx3wE} zusvzEXlGp2rq^!Qmdwk+06N=;{Wj=q5!O3yt?wBaq?RW!n1w{ekxlS}lr4nax`N3$r({6wXQ%OHMk@ zGMTM_X;pjjr(;Z@oj1xRpnHQ0n3Mk=X9Df4RJH-}S(%bKp0OxzU}sR?!p@+)gPmbf zf>JAF4Q`|B`vUzp2tMdUd1RG0_rGUoU}bdK=)NdH<{(U$vH>g8WOi0&WfNAW)a@86 zm=zq@h=`x9jipTujDl=$Kr!s~pz|bX-7o0wr={S#pE_TIc33caE=uugh3pMo1UfBZ z!uta@8CsnakMmThwKh#p_F-iKt>Fc&+FbZvCkJuUmRjrk3Gy>Q_XO$GOgswW*-r=E z7W96CeT%XL3&Z;f_nSdBAk2S1LB0vJg81O|Nbva&wUHoGuU_ZL0qKsP?7MwcD`>@Z z{)hWtVhe?t8=1_$%xYtMWA(%C&!Gp$o=81;|KWVwqXf{I=URQS;MLW_%#2J%AI!e! zwase#)QYN>zXhTebjG~jm#7zQPe3QlgKjs`>R#7r)bgI;KtQW|vfNjO+3i373$s7q zPtN$xApHF&zcR~123AkY6_eRqxcu657@}I=3kYcb4cF>SX8p>hdXU+@k)hG0Hfp7p z;R>0A$!+2cA`g@so-?$v*f1=cp8P?D6?E!VjLTp1m?Mubu>TVY+10Al7S)=3ALyPb&@Ey4ANIf1 zdZ5&5^yK}7{^v?*O{q7x!^#J(mQAhj(m@~~nQ-cp$x7~KmukMo$|zg7=mqEujkY(S zGd2AFM16pqrIGbu^7l3dqpnq5dM!K8&&geRe)4xU24+hxhPB5*x38IVGc+`MHo6FV zb06?)3u~QwWLaBs@oa`$ZH;P8)00CMh%}pXF|L}~+0)stZ1IaBxt(1Aqz|O_=Z|Jf zPKIWaP6kKLi`y50#yA?}zb8wxYBYzjFoNs=*>&>&^%=M7i8bE9=q1Zb2xu7+i)^8TY}u=yS>qy(Y4Ws(I=UU zhr{(?Tz7JD4P#O_M}kC7jEhLXt(N4nM*h&c{4F|C;x(GbFXGbWLl0f53l2G9#-9E9-9Vsg66hKWp`Cd(V(y zA(H?y?c8*k2k$5NPjmfwuKirg-0c!M$r<07Bm$D3zGOPrmi*b8@mAaJW6zjC{zz&I zYu(-Uj0xnI#{mm|Z0?-taC2+&=a~%WTI^cYAmM8S3g6vq(;b#g4>=<9;Nw4#E$=7j zPq6$7QXjcj_&b}&V=ne*0s%ZZ(&AzahVy&-XNP=elB--o zFo4e1*v(?jIQbi!!^(5ZKlNG@)%FZjw`hjANF>Z==VsX5mgX2WJ>-bQgWkPrZDF9BA}v<+ zWPaqy32S{nf&UmNd=1@|7rbJa{Qdj)$i1_*Lnz5+>sHo(}>aa?*7Wq zriRMUzuPyvgLao}<~Yi*@bz5x1@uK>MSP{{x-$Fth*R?1k)h)AvnHP7`NrYS3zbTqg?Ng~AHj zJHr3{-{UOt|4j{3Qs>k*?`LIT-p|U|yswp!c^@ki^X672<{hleBG0!ZDjR%fRJM4| zsBCkcQQ6=)v$9D#ld=Unv&?^C_I8%d?9UvOZLa^D+}g_W`1Ge=d$%_qV+HLMDKBSO z%zyn~E9=7R=psM=i|$YUw3KOc`%#AEx~~kz>_-`5Pl4{{{VQH84!VE)@vN`^ni~GP zCqF#S1iJs=+ke+Xt!(?IA@6(v-S-6BVY2r9WDd4}lYemho7};{WXvJTsMo%#T_jnU zotD&D#GdZvoNl|CM)u==T50d#?X`Ec@e+aCsZ!v8lop-xzt%>$UIe zko99WW@k`j-^}*HL3u+4!@6k;IUc9q`zOra@jr34BD-wYuIam`E(P80#`f+1s`jbd zn;M+j7VgKDegueU`+#l{gUmA^ZZk`IVAPr1!78HHqSf_&L;aa%^OpaUSt=PpXHHJ$ zV);M$=kfo^wbQxG!6z{ZyMO(;oROBy zcuhpO?D>DQX##1iUAd16XB)S@WJnI2#?{*0`?%Sf<^SgHD#zyS-3%XR+f6s-HfKx@ znXP8r{gWX%a<<&5)}Yq+8`j^{>XbbTa)~fI>;Ip#uT4*GdoCl~*7<)jdjm`Ii{nbd z>;+88*~i6JwJWuYBu{xPl0N0RMD~o=i$MA(@Hc==xxb%t1?c>#$A475g3c)V#lYwZ zngw}Of_!hRSF2McsC6+XZ${RpPMP;JUN>*=V%Xd^)1lU_wcEJeiZMC;8q4PAKN*y_ z{9=$v2c6y{^BipcPNh!Q{jJ>_zoYs}bU$0lvIOMT3+R5@O|6NE`5XAp9PJ00v$=H^ z1L!QFDNkk653&ZeLQH+%Q2!-%d*STOZ7&&w+gO;AuOH)T?S4Fs{T-?ekZ^nKcKS{8 z_HIVz?c9vuuwiRp0l8nelbbR5;V~Id7@cZQu0PHokuaIPfLVFRYX*rFom+jr#Y~K3+-!J&`|oZB#V~R>fx->s0#JB?!Y%pvF&2oe zk86+r!m#!CaTbXTQ2JBe@R~^?M|sO@rpKb+en=EdZs%qZW?=z^FB7wQ%YWrPubGza zhn%JTf4f%;$VH`_B{C#lO5{kqP3Hc_Ak5AJ>c=q6+zg3@mD@!MgxOh`L46yMk0K=^ zUrjed^>1Fg6~(XY*BD@aowyad-KJYX=WQ_WWMxqL0J;wiwAUKc$4TbqWCFGSlAAf1 zn0Ik9By)2yG@EiU%slx1gZy9c33d(jXU>6oI}QI&p90hMrx&$?_CJE|^kvF|?tW~L zKLxtSI=OW@mrgBc|1V_kuiukZExkt>JtuQAC~R(5Wo$@hJh7;iAwjM6eZ&7_wLjL> zC~`g)vHTC_A6-+>2N!5vJq*;m6XQ|IVa9RQ*4+$7Aa8 zJvpGh7xNaDAl3ss31FEI^&b%~guCwmXzws+-!SA}w5A5*^sNkkgJrvYUr$eGU})an z-Y1YaC2@1nHwNS6Zw&h;ZGM!*kUX=9D_QOulR)Z}R5Y1cMI6b3*O&w{r(~kZOfKR` zWPQl`nDg2%VR1I*${hGftk)#+WSgok2L9jd}8QHfCei z?+%kozw%Ff+0@`T`QT(Y|6x;uaQS!s$=|>8gT$H|nB7>Y7qUJUy7mv$GIeA<$og33+8+>GCM&iObh9?3ocH<>^dag6=#K4XOE!j0UCF)d z0ykXeBx-f9YhmJ0&c(R9 zP0jJt^eac^JTPVl%@4m~h?`~1QsP*7{DzBNt5s*_2T*Ea-qOi%kkfTP^K}-++1xA) zlgrpW?%tXZ(31l?`)cF7-hSzu-xxu&Y1W)K878+$Ge}2DIxL!&TzZqCRo%L?ok6&q z-NEqqsn)30_Y3C#)ao%j*^?93_WpzZ*XHXijFZ1ZTcI<)Fc`DeFz)8AbOgCsd4USE z^0E>}dlN{a$TRt?xhlpPzU9f#g5ew~$(wb1W>*!Oq;+TJgEz3lm^$3efNKF7UJdY$$> z>oKUuZuVkb=c=wvy^Y7`4<`Ps~0Db8~;6+`{ss`4}%lavz&mUW+hj*1F-CMzfm;11rnlU)G#k9FrM2#h!(E zO;_Fknza^VP~M`>X!UT@ow;rY*^>_*Q&UO1)25B)B z2E}=x6PTnyrzv)@{fP9BwPoYZRTUJ<}7hc zc2tO8)Set%!g#NJQQFq|c2AOJ*aJXe-gM_u`{QYBFCL4svw`MwLHjHpPhjWxmk^ht zl)5iPF7sDqRMoC3sp?QxdmzC!b*x`Wu$qcc)}>-QVv8D|=7VgtVaYvb_=Nxc`wp@{c|NyG@-!ZUa0zB*eVg9bi@~m&T(l50;LdEKSh<$ngL4N0BVUYN1KCIccz8 z!E@4mt!|HJocX}&_PFWT8&0?6)?-S-oCo>5dM1CXW|-W@#=MyS4%(cw97A#ws}gul zx^J5TbWWP{q(fP+QP0u6htfbPmU#~wgK$S1LoyRj+~2U|mOEjP`DUjdc3-Ssyx-72 z$titNxl=_l4{M4wXRD*ri$gy_n3_t8exOJj1Nl>1Mfiavm>Zqu!y^ z$=~=OX{nLT3X}?3-Hcu^ZUvbq44N@+ToyOGmF@2)(2Vhm-G@Np($jPptl6e9g7WNc zo^1>udC-jU?thjW!J*AGA#owA-iy{ppg8D!2b$MNp3D{|T*s@hC@qViNmu-u19%!DLk74IF;XGM*%52;QO21&W(rlZA*%+8Wxj}cEFldJT7%u~eXSk2m zExGfU7pL2+zQ^;A-GQW%q_oN3z_ZNY)3YJ7%y$?bPv!n+&DrT#)_Zj0ZoU%7$DtQ? zJGvzYUt^mQeu#9fakb#sAbDbYMK|%+jAL2J~ z_=H@W2XQG>|L4cztjj>Ih3I^^2`c;L{fF}(A4{?>0m&_@ztsMAlcU?Su;c(WR?wWU z;sQs@??3dvdMwX6hbujH*W<}NOUim1eHcB3c@FZ0ZkhazkMZa`aE^tPc1>(DkkZcR zMXTG!Eub_g{GZQ((e+g8N;g&LJgxDy+f0uO>uzr9e$*=5^YuTgs`0nmOww$in?{cQ z1I^R2rGfK<%(6d^xt9HXTwQn7?$5FGWvRd3z-DU8epr2Zzv2J+w)B;5AoH4!iZdvc zAFA7Ix`AQc^nDM~@*kBmx~lpW?g!->(E8{@X;YH6buZm?2t4N*yXjDx(TnEYYz(b# zp_`mi3)6(z+VqXy2$%6PO=fLnP(0Rb&B`ELCd1$hMf}A{!|8 zPX^acdM`TNdN;l5TeuBk3Y#Iql+b^|WxR}wl& z$BjN4cY*d)ye}f^KkSQC{#9w4>^^Q>rj%CRUr3!S);^eCKX| z)o1j=bqA!R1*IN5aTZ3Akjdrk3?WA*i-As=+<00hXW?niw8=le@PF(( z*RuDJM1n}bZuajE$@i|ag}4Z_i8Ba1_-ht&M47>yQ6ivKJ(=Y@2WTX?wY%~7O84a6 zFKnRx6{t@L>2WnRfP1S2{-0Ezg6xBs4YBQGpG?lVmYe^Y)sAol_E(mH&L>iqc)}o& zpsaR<3u5o%W7mH`OxV9z_Mt>Vh)b(G$Q6Ih1RlU#@mSzHR89Rt&x?OU_U?aQF#jCy zcF26PUfaIb{15-%LqdV=OY?TdRIQe6EfY^RO^2Mr19CCw?4G6uMz^k3kmzIaum6-6 zurN$!U%;`bK;{7G#6-{;Q*bl3G?s$QF=`P!tJk)uZB;9%_xU$Gng1*FJGR zjBXH_$D&{VDJ!smWkIISIRLQ{WJ*)}Y<4z=iDyCg-X^DgXHaf9%D@Ub`ICJChs;6H z94@H$<|ruX%J$?v!viT+*Y^wzHqGX(fin+7WG1sR2q-;Zd!p6yenJ0oWt$}doM$Jq zvkHJ_U=>*(%YOaG=(;EYGQV0IdUrppXa3iHRZH^w?F`K3t$}(iqKEldl%{he3p_@I z2#9slUFP7Ul-f{`pFlPlJ$b)Cf1&c8B>`IPk|&kYKx3q=0-!nCh3t>#e*2dTzNZ>? z^E}v&C)?RT?$v9VdR%zADFf(aT;9X2Zplp7S^kD4vtMV@YX#|Nn$GBo7=u@91)VFc z)aI1(C;=40pmU~nt^vt|T(l^K)fF^S58^LMVFa^5;-EXSL1VYuIY7RG%oDJ^0gZC7 zo}Vmk!eBRDCb{?U->~GK>nyEq$<5bUlvMu>s`g_Y3$ZL3}KF5Y@le z|K)CnsOAN`fzuV_|JeQDcoS560-8)yPju{8Pda<=B}ErD7sy~l;cA)&wu3I#@R zD6m~;!X5?*QmA3DauvwFo9=TCu)2c6q^SYKM})zg1E4Tq6!dxkvRm!RUw7u6jit$t zmNRL!Fq?J;u4@rJ%Ez*qy_KOOx#clLFJwL&#J=ecx*-5`+F)%cD11S__iBB=fWJxE zW@Uij$yM#bpp>GI+J+R&T(5orY+POq15{is4{w=-2I&IWDk*R3$sJ zGB7Rxg`HLl+Y^xd`wREKGaO`GU|Oj5lGT0yF{T9W-(8KhZQ8NhdQ zGB60gN>FMA-97=j=>nqr|7V7SwIN5hgUS!dLLG*-Kkq-(|Na}E%=wkU$n{x)bm&zF z)=tjEriNz)jIJOWOU+>faD&~ybwrC>A_@<2S|QFtjK`a6#o`v)7$MZwIA@P zo&O4=c5+)|<%}edj#cfFuP1XP@G`oBd{!H#)t=0Bl&RwpNX)qPIRi*^M$)e7$>Lub z7A15%vT6mn>-~lQPZuR@bO)7+AU?<>kUJSzK=5WvE@h`daD#PPx9RENk#u}SGV1Uf*Il31sh%=nrzY5~Mzj1jw!{15Ck{Jw}Q{@=f9xYCgU;xbuCX1#sY<_y2;pxw0Sq>JE z+~lpI47{(6A0KB(7Gq{=eaH*0p=v|t9y4ogYIywe`2S?#e@u^4#r`M1JptYq0&?%u zkB?=p{(0=h{`YbGi$9fDn;IVH{rh)z`(q~d-?g6`U0um`CFrzj`neLcHY4my(hJzy zjG!N&)fs6|v|5aMwsjS2DljOfPrlB|Tq{0#CM)C5en!p7H#r%FZ+~T;dK@&uncVW6 zqmNTK{3^3?x;f*=>Q>KllC9jEGtC)=rA!(2&2IE*blJMX_|-~=WF{`1S2J7}`4x49sG8%_JVE~zAEak%ZvHB?Y z=I-APuKV8$9FUpK&dPFfyEMD`pUsj_7#O|IZU@`I%B42>%1@@rM?@G}J0`Jcb@loz zOcTDw#r#)HcnTL|Y2TxE$A-zbelaIAv#EejQ02L%!N(#TeuvqypVh@rB(kTloRxjD zxDA8R^hS@(Y~_r?({&h()5RHAx*EGhGYWTzF(e;+s?+J3eE6wGt$3?z^1r7Vwc(7D zH#d7S8uzy|Ob+E@628jLw0XZX<7T7(48~Qj7=HF|?r>+W>l14>ZU@cNeq}Odb!Fbn z3QDUSOnOt3OTRLJ&LFp&{x`gF^5i&HrrO@kKYlPUiB7)7%(QEs+f?Cjex}VoJ~M1C z|Ie_wRh)Tq`!A-=U9Xso*~OVRb9`qIzRt?zHa)rYJJ_6kvq0tuN3k>2_W$i=5}$m7 zlSyy-=ASxJ?uB`{>fzAvV&=J`wync5!_6hTTPkwOOh&Gye3o5W|$FlN5zxY;O=;ns9x=Fg6e{>f#}88`Qx zbDX?ij=`Akzr(s2#^&c4H?wYb*!(`8!Ps~+gK_(Fhep5TlJks{_lYv>nrgiLD}&o~ zWA^Wko8RRz7_(n@oGgBi!Hiw_iYfES{>Yxq<{ub@L+zLYC!g%!#>(1#wm+GdT}b%4 zI74f9Z2x5OFU&XlSsMh?YsH|HZDVg`CK(AXe+f9LFNlpRK zdGZrolUue4Om1^$*u4E4gWZ&E?N3)UdNz8u`q*x6^z8Ie-Ml%yhhgh+(KDbG5)+CU zRVTBH{+|p^&+H7zC%=Ky^K5oVdNvmM!eAW!h9RtUF9ZgSWcrq-@rkH>S^t{rsg-OcFI=+5Zg>alb)h}G%Q zy1CWWc=}TY;ZpWs-nYWV>?+AJ%u2%L?HrHU*{_AQak?jWy-?zHPwsi4#OnTd@{13R zu8gjnOZK`Yb6sax>-L!c`k$yazm`kw&pIydXLYd?0qw=<_4v8ntmENc&S#U`+8G45 z=l+`<=EB_CHS<_)c#wFlcx8`Zy3_Q9X_H%@{ZBsdl%=;>So8{WZ13by69zYN*U5Hl zhgc)~oWu?`UhJKDpm>1@!!w+><#f6yGyP=hb^j}t%>I)hS&Wl`(bcS7aY63A+EBgr z$xlKUR<)LHFTKU+D%}3<|Iz)eZko?0e=TQN)Yf~p(-j!Fhurl4&A~4T0^q* zaHl)ie(s+vz3#~@KUtE+Iawx`e`OGKPi}h7GMU|#!FcO(hE-GTT18h#x3d13%)!87 z9J+*o(LI@6f)RAeBJX@-@h1$i{ScEIT~oJnKAX(m%J2{r=GRS`Tf1kT2H63MHCFe> zO>D0wKT%;Q+&g*tRc7AC*xueoM)$|* ziG$9^6%H3=VD0qm7oPf^IkLC4xzY9Il4PM9%wW^G*^7`(=Unud^~QfzcR%r)ec+Vh zww(=>Qj)#5GYNAruvl~Ka4??E#<)3R8-uX~8zZQuFt%V|1hrc>U){!_HGSXI&F0G) z)=jr+UAtYn9hwTRKVx9@NbV426y{*y0Gly`jnO#c1OrTOqwCG>ps)d@jH~;TTUiB? z9Q>5QSb~*t^V3wYUp7Bw zWi-D2oWZ#DD1+H_u&wOJ88WxeW@Y~)%*?>D`RaC1NN}VxKtke$gYgV@M&pbXaNUgV z7q^4_z1egF!`1!5ED{XD?C<^?7e8T0mSyHMe!QF^S&D-xnVC5R6kf?3>}H6R08IyM z>_M=&H)>^cXLb3wH(BBab20~W6mncA&){G-esPQew31x-h8nYQg#<&gI0u8HyW#>y z_s7jQ{wIqwGk`)_F{M@{aqq>xr}tXj6;l{JPl+?S){0ENW)3PPPc2MiWf5-s_CJ~7 zNYLM~b7FtRzV=TJGi4B-dYw767t}KDZBCZF!Vufr=+1ex)qS5hqbsAQn~1dJPX^Zs zhuDo%R2ZE^K(}5W?3FwWYVj^A0FBpx#-JcKTqN^fVbq#tY`TnL-?UZJgr|OEW^D@W zoqS!4fzh3D>%=3y?#VO0FeFQJGBmm~x{A8b-QMY*Jmm|+V@b|`f5U4-ty)CgJKaF{ zb|rUTaqD$UZocBy_-1n1R|Y}1ae+WyTfMl zrwp6hzdBg8x^92Wed91B&(@NZ=R)^`(hwxiJw2N&3dwO(A12Sgp$pC-{Hz9;IYg?n za3dsdNxn8_UFI;i&)94kD0exywMcbx?uX|u239?6x+`~L$zLa+`RgoN{)&U;ucM5h zvI3sJShqPCw?A_L+suC4Arg|q_z*elIJB(6mcvdW=P-U~4l94pkow;E-7yB^_sbcQ zg*mvA<@i~Wh4|!zJD>a)wv+^?E#vgB49N`aN|VJz8HB^XGEbf=&LI4)jA7SQMt9aj zobJipPh@!AlY5^?vAQ?D5dQX!LC|CJwqyU3CE27ePMmyHl%chg(PiVd$2@$$HnSde zFt*srVBCJ)!I+)hQ8>aJk_Wjt7*NAisxxuB@zbXa$#SeB2-i&ApDcERIhm7R1|?Td z=U`6eR@c{%DB1ny2Iwqmkz?$ zEty%nRnHr9Epyo1`OU%D%#Cq#=Sc^t&g3>uHb2m)UNEETY&O^bli5Eoo3$q&yv{b6 zoq=WQ{LM3OGHee2#jyFgIis=YEr#TCZETG5rP;(8CbNBDPCk5$1=Q9MoWFV6bB4{K zM;VO8pE8{71EoOYr_UHRUq8-Jxz{+=iqY|};{Kr4_Y4ZYptfS<{@LuVzc-8jVqkQw z-7d{8{s)v(HeY)VZd>xw;=h zOLe~84r1AE1(B6|ceU%a@@{2ye=N)SWb(E)cw1`Q)P*2XCe9~sw>P@GwJ^FXZUdDv zPxpg(Qk_TlgUdu$P^nle;^_W%3rLpH<>CIv(ww^{v$ZnBZhOqex$EwJM%S5Vpd}SI zCqr$haLcp*h6_5~AJ6{s?=dImKjHLnhE?r1w=lXtp3m{rbT6a(<4GJVcka<@1C34y zW=x(Y$}o94E922g!t5{pA8h_RG1=of!_sHQX?vOuj`kj6KO}mv88q5?w-+=%+34Qr z+URn0JEI`z&IHJaXR*2hgYZ>%X5rGW^}C_7{oNicX%& z&NzGe7lzngC((nAC!w{}qXf`C63Fzd5AOhWRR@YnAQ6FridMHwfuGoGLP zRF#2qMW_2?@o#@#UTbt0=J-%Q)m8Xen!IT(`9h_g;+zrZ}3)s&%g{^sz{493En8H|k+7&bpo zXD}Au&Tz9|c)B=)aA`S1qpRfEPS<4KZCt&s$!y!WT3scd3739n5cEi9W@Qv)Pn-;C z>oR&YF8CVWIUk(Y!@n~$x+b@AFiNwUvTPPz&H!q0f!auC`%|}17B6K0_lAQHGYheU zY`obIYV`|$EoT6&UwO>K{!aM2D8s|Oo72-7l0`WfT3@9nM0PeU0pw@zknU^Wi_$^cpi zDEauI_}Aa1pfi$K=Jpwfer1@<-p;vdI`dI>2J6;k4owXVP@tN^1!j5rxq<1-yfiTF z=jaEf^AhvGw1J_Kv5BdfxrJq7QgTWvL=gi6147)<$=SsfVh95RgGOFyPL3u6g8>5r zLmd|*!y^_5E<$31#Eg*m`#2dH?r=iXUEpM7_y%Ra;$&o4$3hr`%)^C!*dgXF;bdf} zU}Ize@nINU&lDs#U15XhgQ@X@x@iHDnkRy&YG7)SX^>qYKFIz$H2dwi85uxgR#3aN zxFP0!<6>mE#m2~Rii?q9AJjgO{UCKcNOn$uvO(h0BpDg*2_bNYBqPHFG%;j(TC-vH zgA)-3!R&x4^v@oZ|Hobd4H%#S1zpd)w9LHBl1c@zRs~cpgI^*f9lNTgfaRSMb8_;N z6^cuflT%YuQXzs23=H}uxdr+~nZ?Ovx=E#(IVn(fdS0n+Nq&A#azLoKUDEKA%fn4(c|G)o#{{Q&@;s1mG2mUwwXZX+XkKqr) z4~7p64;T(G!1JGh!k_bp7b-VC*1b3X+@%vNcbDDZN@+TM>D8wzLaLrmbj?isgV&wQ zR<-{+*R48*v`L@wJ&k0eMc8fTIfBy>= zocPO9vMO2C+3>&`o7_kDZpU8uwz+1_f+u@YYTPc|4YgCyQc2qEetm|r{nD3~OVwZ1 zuh6oO=Kkc>xb&^Wz4TpEEM3>iZ9G54zHtBMm7SFt`}BOGANn5IH)ZOxllH#0wl%xV zw0RHx{c|p{MX>zL>L>Q02Ujfda}Z8Ed|5kH@==8N_KP3wxvnoRutgz$*q=Rv4t}G> zIXIda7#jYA#miDBd3iP1i~5|LHC>^LDJbEHYN=6H(79Pg=QMnmKZ&(H8f)D>Z&FlF z(7Ax_j~ceTsp34Pjcui6Cp~=A=KP2V*b@?ydgj}r<%C#CyLP{kM+6!z?sL>FUln8Sl1#&CiaQ)~efrWn{V z2ti@G%`GTOO$Mb~hK2{`m4_Xj#q(IVZrw52?dwnbm(2bazDBYJKRwEuqHOjT*WdLQ zErrbUz4K2c7ltQfq_Ai zfq|ixfq|hTlaXOgG6dHku|Z-sNPNExMux5oh`NLfMut^Txp|q43>nFUF~~ez_+Bc+ z+QUxP}PALMn zR4_91pot;N)0z#lAFVo4K&y@n_?j6RR@Ff;0}>k~wyy~y4q`uQWMs&K^1n1PGPFV2 z6-|r`6?KF$$P7aGL?a`^gL;IWgw)qHpsJnF2;m1H`QuYNM2wJGAbF7eFVO6_YGz~r ziCuz<|UV8=I2>~ zs%3`6;^NdI5LZD-wOC0ZEip4EHN{FHEi)$-ETW^3lbM&QpqiputXj;)z~BtBgn@w} zz(3eCf`NfSkAZ<<+d@VLuelJs0*MV0OG4uNEo5Xk1LgD0XJpv10HP;s0V9LNT*4S+ z9wBVAfRVvx9>iQiYC-Z-(9|+O-82hIgVaPVCEh%c{UK;(S}bH_0EyW_#g(98@L>TX z!<>1H3`GkV8B(D3f$RsV3q!I~1j+`96N+C3xB?9jfb-yt4gpla0tZlWM=)T-0w4;U zz<>!00Lg}nIC+-Gm@u`+NEbx)1De>4O}Ltr!nMnhomg}_T_ zjRU0x&}aoHA4VHM`7qi6%7@VbP(F-KfbwB<0hAA;8=!m`Jpsyx(F>q_7`*|?htUV1 zd>DNJ%7@VppnMqp0m_Hb46mU6htdLQv;ve5qYa>Z80`S%!{`7gA4VrY`7pWw%7@Vn zP(F;F0OiBz1yDYW-T>vp=mStbjJ^Qn!{`T4K8*eV<-=%(*HHgMX#q4^0m_Hb22ehX zc7XC>bO4kOqZ6Qf7+nD6!{`PmA4X4r@?rD>C?7^|fbwDV0Vp3vUx4yq^aCg#Mt^|v zVKl=VsQ;m~02-|T<-=$LC?7^UK>08_0Lq8a2~a+aE`ai3bOV$RqbET5FnR%$52H6g z`7rtbln0BG0hAA;KS22~n&B>0jaGp2VYC6152GERd>9=7<-_O%C?7@_ zK>0Ab0m_Hb6QFz;y#UIG(Ho$A7<~ZBhtU_Hd>H)z%7@V(pnMq3@DA#KC@p|SD?s@$ z+5pOj(GE~Pj1GYEVRQnN52Fj9d>GvT<-_O+P(F-a0OiBz4NyLeJ^0BG1C$S=VdG=C8YV+s zzGwv`es@iR&@g{aI1lBYgU||xsYCxq0SpX`435Fho}MskvCxF%AzJ?bgMbDofQX{c z;{-U@L&1)R5dT2bF)+aRFy}EaFoC7qot>=|G}28i%}kO^lT*w!6$}ma4D}2cAQJ9= zp>PpL3kC)T@DwWpBWM_vMS!)a%*-UysK6jT7epk2h%^w90wR))3Je%H7`eE07+|(> zfbBF`2XWg1Fb|V}sIO&WV1TH<09C&XQz=*kqW%F3OnupUi23-{JF~;o%WQzC*J1-3 zhe1Hhcjt$xciRS0-vMzR4)t=PF!ks5LDWyePze!$n6EDmQ=hOOqCN~FjX^@xzmhgK*^0G zk>P>>h{3>-#Bf0v#NuFJmzvM&7@rCeU`%BC$H2g#2J-bs zkYUV>P@Xm;0|U2Hd@_SN$Os;%_+kciW)L%#k%58LDLxe zB=PNsnuK1ga4>_C8_Ajkk7a2jL=F&UW| z7$7MS%u8T~r@(e*1_m~G3S`WIq(6`?RW|iM<9%GcYiq*F=9SPA=#>)qgN=OyT3aLU_1;AA(E2P?Fg;bj&EZ}OB6;f^T9A{!+@MaXt zW?*1og;b%ekSdhNj){RGfKf1>fq_93sYK&Fw}yd%fe%!offx*Ypb`zl;$UEfRHwX` z-ZL;Ta6_t7kc5fRaSR;9P^wdIlux^Drc7 zgL%aeUIv7h3gJZyFfcHFW@2E_0O?~CVqjpr!vf`95N2RtD`L>(0(qV3A|nGs5)%Uh z3n&5WfZ~aPNu7y-VG1Z9&oePF=z#1}0kvSKKpV%uK+WY#NE`+xFD3?t6);nDA*S>* zF)-YMnW76aWg*Cvw9Sy@3N~c{5{H3l6B7f26&nKsixmq4gWfH61_q{QObiS+K}Dq- z69a=D$TP-b3=E8M%ut>?i1&#R%8Lf^gkdW4LA;ePUNeZd7i2IfTBn0};V|AoF$M-E zPG$y%Q=p0;)ZGAEbrqzD0i+0I@kPdi7B1jL&{uz?UHU>&DFfhVxtN`)g zw$7JgU|@mU%mTNSfvJg^fngg90|Uaw%^;m{8;^r{a6ht1Bikqi;=ygy1M%QCI)Qj_ z8^b_6xUE^zAiut3W?;C&!oa}N2lEfhDj17_DUpSN;SCD|gH(Kc1p}iVGswS;VGK-D zK{`N%AxIn?Cv{-cZm}>hq=1rzH!LAc0@=AA#sjHhsfY2{LCP7MKvD6Eoq=H)NNE|& za#k4z21a!l&m7c)VPKMHWneghVtye=8QlCCG7Jnz=7W?Y%wGdi3O8Rz7TNrMSx_;> z9*p9rgAl=XkcH_WSAtULRapiG_A?+Mevsop`R6OhD1MNyKs-4)1_nkm7|#>LQ-Se{ zK)kge9w;Q+F6%gpGk=8>pO|#LU2;4|48fIR*yKb6X&J8@6}Af}MeZm>3xJK`cg4 zY5=q3VM4Zs3v1F%5qeHKW)FAS>dnIK(f zu5(jBH94rR2Qe79L3KTd#lgS=sq48eT?h4WA$2`S#({woQrCkx1`Z;ix}NC{AE*_< zU%&~e>p>jGdInK&UC(ryot2S+K@3#aGo9tiWnf_70oV1Q0+k0`*Utt8qWD8lL8i5P*(mF->D-V9*1V0!r2l49pCi3=CUA z6+fuZ&;vWk29%(cIT;wvqKMA~iL>)TEdY%ZfFkxIikh_`HOy|D3=E(Onh|d1L9lox zCj)~bsM3auUj>Qt%>^~a;9@U9Vhqd&I2jn$vM?~P39<tN`^)7#JAXs#zHr*6oJ+ zQJj^5p${fw$jZPF1scx)DLVveFk*Pv)s}&Q`7;*-!!i^{tgr)lIGUS*VIPY49*{VD z7SuLAkZ&0n7#^Xhxd2kbT*uA8@C!x!30Qm~Hv@wZDB;6B_X8x(erONG2QV|uP}CTK zR{66VK>Y$MgQ8H>xPjGppsA@tQPT=i!zaegz`$e%i}RWG3=I4!P;F;f85sD_AaNKN zn2&HXFsx){U|{lLg;o~w4h#&;TX+~4l2{oSIM#xML1~=nFAD>MK8V%mz`(#H0~22X z;-!Lkpu}_$!~^w^^g%oyM+OG=KB(tmMY{p0d;|rMJ~K!SgM=fRfPe!uCSgGVPFG+9 z+dvx`7}yP#dl>|l?1V&%7&NLmz{Nf| z%Q3J(ihU_ikq*KPywCxvDs~12Zg8<)4bjbjK5o21AIInc>WC=I2_^;x4@O?lcp49+ zh=-1jvOv3ejVQgEq)^PFGOxSq(Z&uLVsN2zhsqJiM>J3z{IV zaxgIPf)m6_Xo5hW7}#P2N)X878V736f;V0*!)$ibze68<{~x zB!mSj9w97H(WnVZmCT@G5zJ!o1`SGqiXu%&+nyx`O@N&VNtS`78cmv|2TcG~Jp+T( zT3*nQ6%zvkB(cL1tu&}817QYG*Bdn1lg!1yzz0sfH=(H)eVXd131}{dWdmp&2GUAp zgtSso6EQzZ!exZCQW+twR8C_y1_mY%(EJW72h*ulpgyNRNa&&fh;72a1xk2Kmq1NT zZWAU@x?{QwZiO=1!=`<>L)aJ?IGB!K0W~>6$&cwIs13yiN^?wCD?pi*6Ot$HBeDdm z0P{IeGT{Yf3XoNxrsf4<5Q~F>Re<@DGiZ7QlpmOHft}*Ozy!(=%(uZj0|&6fnD2lb z#$Nz-81r3-!|EBhp*f-uG^qk|5%XD)@BR*^e& zunWvv4B@3QXn;J*?!myo0cy2sLNtL|t(tI6pjIoGSLMOLzyfNuYQi+JfLg6!-UE;k zMGRV8Ajb>c;bma(V`5-n2Mq`5ZUlwA@Goc%0nI&w1VA$qENW~F42B>dO!Q=65Mh8$ zXD$Y1BGCXS4_3#sgX&&mP;`J&8+gE843tnonBfexs6D_98@U$&8N$H8fIdfRWC1E_ zu}lu3CRTj2ksOf33QAFo9N=URO0ytuvOv=;h;72aiJWG^(~KBtmJ6C@LFtkkltNI_ zY&|HTI6!jDkgNestURE^3bKQN2ULQCSct?5p7&(FB>)nIPJA-o2J;LYz%GI%RIZB4U||_z}+|WAZDBcs;)rwxr!Lbh$EiR`dkeZ)la>k69HhJ znGXX4FDSvPgYD17#Pl%=fDau(7) zh0Vf4Mhc+qM@A-AHqiJF6Z=(AG(wAFMh?()7jzPx=^GmZL$w%af}gnwR2=^Y4JLtS z;FnSx7Eltv2+%LkBo9Lz7k6gY1%3NUX6@f4UBgT|+N85kHqGji-8?f)5= zZ!$12aGVAe^-N4+APG)ThGtyH#0cv3q5GC`4p#*O<2ojxxeN>pTZ0%FxQkLt7#KG& zae~%l@M!TfFz_A&*|v#^8KmTX5Ca2We0(AUBUFGh7#z-^vKLgjodwl`DB)Xaj~<>Z zR0&U3P(LW=~-zaRvrvR3Qci7GAI#W@~Os zZckxe?rd%b238XWW)38M5)2G%VjyMQ5LFBe?81!PiUL-OAZ?1wjKT~I9K2vXAOUVq zVGC{s22O;@imaZ(3=CYXU?q&!ipn6nK+fStwTXd&2O+=>aWOA9W2iXD20m^^5XCRZ zsLChI%`7i1FUTmwE+EdpAOQ6;2Lpp3*cniFLVP16&dAKi&20r11eqX=tcHO>M32#4 zl9>-8uP*5+3^LY1qDm5^R+O6?MKn?+A0jO=50gMs6ATJUdz^DEEruc>!N4Fs8t$}6*eJm)&cJ{>+|g2|I0FL{ zC`v$i0#uwJmlU9RHB{vc46KO!!iJK&85r0><}fgDcres5)(bN*a3XRW7bLfHBN8;c zc;W%)3q>YtR!}j*z`%=1hN_i21$HHj}$ntpyq+f18HtX z1_l{O5HT>w>M__$+DPW{fl7J?MzCU(q8?l64+?LP4_TnT;6o|wxk05g8yBdg2L+6t zr6PF65Ie+5kUkFd$ORQad{&A~kct7~Yc6PffCM3x11J_b;Hp5C0}muVz)HZC121NL z@PS;*z`zen9Rd({Ffa&WMvD;CLmUhY!l=xKaB*Y;sV5cHdGAlIXK#CwC#|Cyia!O`Lm;*`4m~nzg3(z{0 z3lx%|_~XV5IUcC1L1R{6=Ri{&0|O)%LAekI^P`8H0N8y{H4F@b_(Dzy9K}$zpdb+j zI}|Fwz#xLm1toZB<%?P8LW>-5dIc3hNR1o@1{O#Jff_ML;voA#fyoE2FCji+2gM@? z*yD(J;KYarP{oQ`)q>JA)G$aqz?&|LYVhV3FJ^f2A;OyK@V?HSTYa;=W(#b;QAHR#9?5NfaEVwI+29sIVq491_o)I2_2jo!6w04kDv&F zMi8vk$%0yJfZ_s_)FEv$L_&wO!62c@j;e)$0hG+4#)9LW6CQYq{Gf6R5K4NpxTs+O3O1y`h30KY`x4}Dcm+v%*rJ6cs8olB5hVD%FN1G5?fDB4*tBN^6A;b353 zgEa)$VGRLL;sd2laEk*}?J_WM!rjPf$&K7?fOT}ZA?*`TtU+4gPyq%89*BcMp#wJ* zq>K+7Tu@~o0S4sG9K_|!2$zGpKCp@$w002eRcJyW))OWS?!s1J8$ksw0}E);F9Qby zs4LFM$oQL&mjQG<3n)w(KrDIi^4S&!28I=&ZY`rc6F*B0NES?hh6$NK;~I>tj0~Ji zum$qW%8abc%#5HZUhrfyBP%bIMiGUGK}jUlP!Z5HH6zp%CM2^M*_f+9TvldgHclo6 zMmA;!P8QHwK9C@aUWf@`l8u>>lZSzkxgMkxq=SQj5uz3(16m4L&&dWci;0j~5Pfix zpn3)-77>t@AV)HQY++zx5od<6Bp}XbU}BL1DPm(_1Ti6|lf^P&X5i!in_>ns5W=(p zF8cKGP8hbW(Fn}KQ`tX5C_DB zsGH`KQ7DiCSGcho7f(DZqKY)jqNy`VI zT@j360xciF*6I(bd;kqNT=@{3i3JF*SW|jt6p$3%%QIG-)l$>Ev0ot<2#1aqH#l(^Z zWihiffyy=(21Zs!Hds!D=2A$;AV1CXgSHER3A8j1+dMFu<`Jd+XqtzmV+JOc!I9=~ z3W8Q_eb_6`%ctz!*J?_k0O#6q-nV7nKnpWczOH>BKv)WXc*G6o_7 z%GZ_9=8gmdsIkQkYF98bf?7As^_+a9wqzhp6Hqe<(w0JU11J$gN)0FrQtW_A7;G#t zaDfSug%oul7D64QI7NtQLj1$P!~$ipF;_whO(r&Gc93@%m{>rqM@Z=lVnIy9#u9-R zfJ`hP7DOFk7No5s4|fSF3*rj}W(H96k%5T?#DbU%Vo88~3t~akL4Co%#3Bt3GY|`+ zgD?wX3PPPCyqO4MLBfC;?n@nbOAo|?*ulZfz$pNB6^I2B1J}|FOf1M^;5f!3hA;&Z zYp8l5E=3h%fFwJJ6gcZcT#SfsTr57Yi$Sv3bU^F}$wK^t2xSBd13AEukSRRiZ~?IpCL?4KEQp&y>L70BfxDRx?q(1R zq7KA@m<(b;Os15DFd5gsm7Q_r}EKmy% zlCD53h&sY7h(A!K zggQ`L4@n2l7m!$8+eSI5=e0lib04yAQr^OP!^;%gWC>jPe4?HSP+$< z!5@hK5G*NpS_QEn>M&R!*FY-Lau5^ZebCqpL_K*dNQ)P{URVnnAq#4cLi___K~e%E zq?ZQjpMf>7GP5z)a7uy03({9mgM2X0qfE}KDKrDzq)Zt+PVj;vRXMxfz z#9j~!6!i?CZX-OlwBfD+u^{$gV}Zw*A)W^_xxjvf4^uHPv6w+d%%CiYNgy#479>>Q zwrj!lfLIWf*6`jAhy}?3ps{R-FF@mjkW>I-$$&F~H$3z}EQl#S5Stj7SfDIsRDb)y z{S9J4^q{gJo{faN6~uzL1~f_zk#z?pN=Q!ff*S}MMTEEtML#4RflPwf2xURs3Rme1 z4;2s#qA~^^Dj*g@48el9C=u?AScs_%Oe`Q4L>(#%5~3h6h`SO%zJYkr7Q}>PJkaa` zM0X0@L=X!hhK&U-?P1dnsUXuJwxz;-SpxATND8VLd2|9Y3<@rYz%w?Gc^yvBPJG7e zB9OryW6%T@w#h8i!5!uz(2x$8K#c3acB&5SxDG2bGdnmtLPm6u=C0slJfJ`USKE*| z88mT_EO@Sq8KR~RRKJ3P6qGZ;MH3{v36dc7;2Hv}N{B3k1eIl^m<&=+mdT)Y3dk#v zgv|_MLJ}va9|#cyu^_3B5*Da83CYAD7Q{RRiw}~I8JJi=EQqWCRE(MBBB)XTISa}J z$uqND29Jt>+{nyw6{G@^_=Q1!fV6sqA>qux!~$Z0R5G#1Kym~FgatAQodwCKAaxJ} zK`eB2^-xooS$2bL24!L>6QmN#1X&1WB8j3hL5>AwLvTZYfr&*HG?@d@_!?v~5)-2F zE!fu(mkEM&L%a&APC#mzSU^*jps-?MF@+ar<|r&kquCW2yi6=07RYdP79=1*vJmS) zEQmT#lLulOc#a1WuTJoBJtvU6AQcF>9)oBCGafxF|oMAT>)Z26e3uja9L2L z1MwAz1ySba|17Q`GYxGjh((1#gZB0{S+ zh&pH`$H2q_nj?jT4u}PjMP(smA^t>_h3Ke*y9$W~ihqc77^v9^@gAr^N3bB$=^)=j zypj(0b2_BxVqj)j#sn#?7?@bRKxRU;r+_peF(LYMp{bdPB@Z5s1t=^?k^wmrq8Y@3 zI0Kahku8L$gbI*-kmOMf7pw*eLXt;5hzT(W%!KIofYz^|$vfx}EOZ_YGuQ z6_H80K}?7OFcYEx4-*te%q(C9__Xzc%mu|FGYgmrQQHg>MPfp1n+VRGAYU-EOa`fd zF+u(Wc^N7UQ4LlBVa`C(I18i^R472k$(dQEBS}sNNka4>G3S9qL1~?t12>3u-- zYyt^@B8i!0Gl+?hV`5PSML0-~iA5FCJ9#G(OWLgX}{HZie)I>?YH1+gH}jLHI8 z%EV#>*8yTdtb{je7?@f1f));eQUsU@ZnQ8kvm8M3$3YagGBbi#;4rfs0cix;!OU_L zssc2h1#&CMILOo%$X(1VXF>81rC=tKD1><)q2LmT3Gys63z!K}0A@l=xD8SO31Ki3 zq5z$Vq!yHom|4&jK(y@xjS4{w`vqcxLX?>W%!DYo1F{Wb!e?%!C+*&O}lGu>wiK1(3NA1+Ngy?;s|`;(y>M0u|=WER7)RAVxHTr+Ogl zuV5t*yCH0df#*P`K)l)p(g_IwFcYE}JF^3%7GgpdhzW{jW)?6LqOAvPH$+7rNCm{D zeN4~_k(s3%JO~D{x*Mbdq7lr57&iqZ3ULsa2~mK~gxCQVg%}2AVyN8F()bXe5sCQ-Bnocuz&idAH#|ntc>tsak_o{~i0yco5F@|}Abtij z@oD=EvH}vuU?xN@Iul|pSQKI|n2DkG56Cb`i2!Co6f}Y24q^hBi6lyp32|93$OMR5 zbS5N$O$I4|SOI22)Pk9i!ecr@!3;DeBz$LqL?O0;nV=y_W|l7?4?z@kA{2m`5G#md zBAEcu)(7dSAm$2a0fFXmY^~r zEmLL|R8er_h>f`px*kacw&ohzBw}I_1~uY9Zi0+(fJ|m$0nNF9Tn}L(#IUg-1(p!J z{|910#{)rrVq(z-*`Na+0R{~*K+FI&>>##+SO_r)3pC0Mu^+^Oh&e)=MZ&ZWIDpqD@R!~6&azCij z0jCX!8cY%tJs|Ia*OD_cf|j5o*5$*S-H`Z&%veFpfUZA-1UIO428k0`Qe|QRv0!3g z7ciiR!5TCmLC~^q&_a7IkRZfF#GEB)JP#6;AQr?#Tr5!5fv)%j*B+!^)^JbtJgQgEwX86Ve@LGK~*jjza zF>J)=g|nc%04C7#0_;>OW);v9O0fGNp@Tv~#L-fH4K&rWfU+|vVS-{E;ulcLgoF*q ze~^>_n(>5)fmo2Rp_Bzld8no!Y@?1H2vZ;_1$pEQ94-t@EXZQu(jUJVD=6F5u`x44 zLJ+JNHv3-(3Pp&&kWB@LJxm|iT5#InVgPls85kKep_`b9UDW#*lpw$aH|Qu!#N-d` zP$p(ov;;xB4NTBJ04TSDeTI_sz`+Sx!Y{zU$Xo+TYM=l@E+RqYC<`bgG4)}JfYK>E zyMmG_B)NcCkcdWQK@u!T47}5!3}g*t?u839o5aAx0-6kgBzh1FVg@!AsK)^@4a9<| zqm%`y>k+1amcl?1DToEJ1H^(PClCwb0_e0m0~3oJv{epaLBfI)KCTX8K}-Qny+eEn zVnGJ$KrDnTT;!3ZYMG8^nrDU8yWnwbq$mw@sX3us*na}6lnLUzPJ z>K0}ea67dcBo513;6TF6JYAc=qt>Qn|M z7SK`=NP`h%857tyb)c3Q19-R;ymAM`gtQ?*`XF&kV7Sx@q!NbOfG1q~;fn6^+ z?it7!ZD(R(0c}f#xDd296%x##b!d=+3dDkh3aBjzaRZ2@zyQr|WTY=p;SWh!7`rwg zsRm*u1NOlmkc%L00}TT~f*Hhu#F#jI0hl}}Er2?XOe{(eV;PuOlt6+I-Jt##L^p^9 z(G6mWfO}vd7D5ch0@vsaOe|Ps*_cb9RgDlc4>T>Sfb4_VLhQsS6QmQ$z{CRT(?P-> z#Dchi01K3yLBU%BwO^f$8CK~bihcul@&~aX<{Gdu!zxMxW-h31(EK(eL0EwN0SPxm zI~bJ(RS1teR9T2WP{klNTY%gQ8cPJP^#Cm(00}@$1Fa>1r~>u0A!4AgN3g&>XmGEc z0o;QI7bPGj+#R3^d5C&Y*dbUDb3uJ%Na_c%AYxd1%aBOK*;|H4Lwn1ReTo-BSKTmh zFyLR-lMOn;542~CIT6&T0~75a7I}8xbUNX5(&>`ZWv44nSDmgo zU3a?Sbkm8C!HFB)e9+MZHy9W&u1;{`Gw^9->R^GH&78-KVk*cioc?EIz&NuT-Coe$ zil7?`VZB7qX}=)zocI*nAok{g?DIS62C)g7{t1i>46sfG==?sYelLiAre$0QT|mJA zHUM2eC_X`F{K48uusa~JsRJEY3`^pmBX&Xd#K&jml^7aXD3sIE2%6uYDXH%;V z;E;He_>}zeJg{q!1v4>3inB8dkUZkz>J0LT0azU_M<;<24#M+LJw{+XXfDevjxWi~ zs{~6SJER!XPDuQs=?{rd2J6KTPGyLXuK-18g)u{Xd|3uq6|xPbAa9lBAlVZPj-+IW zJK=saibo`(s`xapIdDnzL}r9(9M}!W;*KsZ@y7AVAo1j!s+3GDa%fIKx5W??(IEZB zrAeS@PfSTMVn|F$F$NLwDfxM+U{`{}B-qv06O`0INuani$&jJAG|3p7bSgt$J}95M z1;m3~=;;^Y8sz8b6Q7cq2JtkCamew8A_2~z#idCQFQ7|7;t<9BRO}XjBDT0R3F4c? zloW{05dU~jzmWLMywr-sWKhCS%d99#E6!vnNKDR-FHX(PEJ`eAhzFHni6zCEB@map z1^N4e^_3QZeGcd6R57>(#Jfg>xca%o=TtGcK+086hJhUEO*f}GR}NCBFXUz(JY z3KxTNP7(xRf#YLzKgobDUsnajX zEzk#FimeN-ilFTDyi(ng{QR8cjKs`5eXxvfdUCREUTS$xW)i4^N>4R{s5LXuEzQf$ z%P-H>y<%)FFKZ$1ND!z7pn$d$kBF#Zyl_+sXzJbLrlVf<4taj1G2AK3yPWDDj&H82^> zXNR#DK*d<=8BA0#%?2q&Ht!4Fbyp0A?MqJtcJ09U}6sQ*@b_SppuMH7}YDE1I2GX+XBMzN|-6M zpdOS4MLjHNd|+Y*^Wjd{m9?aAkPzA8agYjX#ad_mxG^~PZ07V{*y$L4f zFrOX9z5x?6n9qI-%7z&V_6p3V4NytOC=9)fQE;ty5UL(QnO~qZV-)*0DDwxDW{hJ0 z1!ZzUFR}%t4JZ@l3{d3NK$XE@fZWm^id< zfbq}4#G&e8{EIMgsCpRx2}~TS9>)Iz6NjpY@x7q;l0wrGJB%Lz6NjpY@nL)Dpz0ae zF+2>dd$4&JR9C?~JQ?O7sCpP5=0T7JAoVal%!6!D^)NongD~|lKFotK^)NongD~|l zKFotK^)NoNhrx9x%)>APL75H4h8e~fi4l+>WiT_3K?9dDlKljf*#^C%lrfTh7L>UI zN;5{X!#Y=TrWY;BPG8fKCaR69&u z3C%N5aR&Avs6j9%v)40l{r@jDAHxrf>F^u|OJH!d=qU>>fu4lm5*R*D$B1UQT3C=w zg8GRu9WzMM5ph!m^$}wPJB$g72gVe*AC4eY!I&^#Fs87>m=6%DU`&{oKyeCV!+gUS z0guv#jgW|8Ou_INV+1^wVbR2x!j2w8j46o7Nq{*cnH|PVf(mgoGdOVQs3^{7hl!Ly zWq7I?98?@sp|UVhcu*w6gJK6%17kA#0VtCTnyeU;;jZ_AW-rEMb{I1VD#Q-4X+Aql zAOtGGn9L4i!Xgo_7A61>f@I7fNM>L+gNCC8lm-PmjNJwmV@zb<0ksiU2!L|eEvVQJ zD9xD2E&xqJDo~m+kzEbSG=S2KiEwwoN&v=026iE+UHhOkTPq~Pp?d=+jvk#*aRzoi zr~xpKvDZK|98ACgs(>*Lo=j4qK7gy81r?YNrQs5rpaL+z!z38kd7#ENL21T#xbZPi zO^osEFyN(0+D?? zU`~!;?}IW=L21Sac9_SmAcQb{5drsw0?f$~a9?O3gfM&&!N8sXbr=uSd{B_Xf(Mq+ z857xI8O#i78b}!|FyNI|A_Kb@nsID3kQ5Gc^Eaq9FmV_kW+h`P+%Gavt6)lDd^xB% zV;bC#u$Y1=h4Epo2Dui-hWP-d78WQP(8>)a4&%do2{OY8ss`p`P;-;r59(zhsMi=1 z*kMdqMamclPkJUW*C(*Um@pSH*D}s$hjF}M>f+d8%pj-`Ys3Hl4D;Dx+z_~MLj&V{ zb{H3S%Q|BmyrNqNRmm8~4r6YD3bAngub6vrFeEODANT>Gsd&KL7DJ~i)DwUOn7F9hi3*@P&3BE zLp=fNd+vG$W7P@<4qH&A3KL9$N^*iF>KPR0v%`eapi*r03{@a;7#|jkNLpa+(K%2p zC|1G3+Xos{jPdL+W(`azioFiXTn42X zQS3102bfSiJB-NzjW1Aq!q~9*WQ=0Rh)%=#m~H5IM0CO@7Ety&D9sqnzvGg#=&u3uog6i&p z3NwZx#CAaCKut`Tx@k}`wkn1e2D$m{F#as4IAat$j5!Y~#M#Kep`cpDpfsO-0aR!U zlxB=#hcRK6K~z^WD9vYJp9EF53`#S`BgBru#NrSRhS>}X7IX)LMw%``_56dm;z#%bmT zgZ+kN0!#vyO3+PUV7~>m9M*1TOoi7ruqGU1Dg*l=bYTQF|fl%WxSw? zf-wytrUDgXt7d2hp^KyK81!P^P#%XBkxQU*j5&y6a}`W14k0!PD#n&KnImj62Rn?v4NV-z zheZNw-eiu+92g-C5k?pfvr@i}LAe1282gYpx*Y$d<|A}$f?CWN$_`_~>}1Txu#YjH z0aIBXrm{SQGMG;o!w_P-pq8@bK;|c5{9{mY^_2n5>@W>5C$r{Y z4<@iM!hV=?dHhz)$M6^-4Gios?;e4Ag)xjB#=HU*;^~DpA<7sO=QF_l@C7OjN>~~O_w}-)2rHVn(Ko1go=>BH1#dIr^Et26dA2V|pW2yuRBHRH}3TnrqcP+t_hcL@w zjzkfB0(CJ5)W!4JVIr@fGK}%;Fec1-$P3WidkIesUopa+x&nG0htfr>H4v0s2PMRp;qhq0ZYVvKR@FlNOb zgfbX=8cfV^K0A!P2r9-H#|~rufeL{f0%J4mg&2q8auKMY6qE*OfUymrVvKR@Fs9W$ zh#4SdFm?n?%y2$CjGYG)Gnmf~W7j~%7~|OMpv*QX4KfbK-Ubx|4P`)?yPz~{9fP6b ze0CUjA5@qzjvdB?#W*-W^gxrvF=((eM#5tNrVcc_(+5>12Tc@=N$g5cCM<0*Cc)E$ z4J?@?u{%JS0WkBE*u$XA1Srjz1h?`PLg*co35$EiBzTv>@h~McR-ofpfqC?JR$|4vBwz2E(c|*L21S)c-+<@gka1` zFrjF67;_IyD2n|6l*t2)W5y_UAt)1`PNLxHBn2wP7zIx!w-7?Gbn*)!!~{(g0#F*X zYy--KC!HvG(s>7!VvJ({0A+eW69;1yJT>JZgkY(u4IuA zr%WA$kRFt21f?0H;3+c&Ap|SPN)SRADKm^WEf7MmQl|+a1Y>r10g6fEh)!;@hJLI{=&XCQ=N$?y?E2*!K`6NLI|ZnnHf-;F&h5Q1g6M0Qvh z!fS^_c7_bQv@(8DrRC%o>XFEwHVA;i-E^l11ySS;IVcCAp~PSfC@mi` zBeDb`1S?3W$ZLfD^D35Q~`tV&N$OUIxTsrhr(?6cCG<0%9>!KrChoh{a3+u?+0n zpfL|GM-hECczhr_Xi>1hPhy94&{rXZU@aaj9W+>Z%9zBS1r1>nSQsX;n?ad6umB5V z4}&scU311H_H9rhc>5y>9;`^cF<2D`Ylko^#dHz_JFFsv^`#jj*pEQ7 z9XyHkGJXnk~#=s;0A5@AliXFz}gC+v0Dh5LkR#mKL5ClyO{{R2K zT8hISwEm(6ss`45XN+V20u_RFk{F}dVNFa}_nk3{{RcFmz!C*x40{ta_Pd}oV-$N2 zlsOGbGe)t)m@}Y4Y*h^4U@l)Dg0VN7`LMhsirLa2fLO**I)q7WP$oQ+A_jF}Ig>G&9ma&`zIe>s7mJzu;xKbxJUsU`z;a(aJFKdm z0~JC`%GfgJBWR|CRlCe}_4DDK9yMrn2^MsNa$wybMntz~3sj0R8s6ctzlq?4Kcui7__$)HlToL zn=r7$<`Uq3iDF=HgIWk1DF7{#f{hj+nkNhxVq@*2=S4P!LC*9h)okYk7O zU=vob2!ip`P*lTs8BkG}Y8W5Z5&+E{LX|W@X~sDCbk`cF5X1#A-a4o#%uE;`Hh2tb zT0)g5z*+)v@IhmEKQ0cV3k9}@fgLtN0}EnM5`m4!AR03a?664|xL=|e*q=cyhK;>| zlE^BkBVa8S#%Rn!G8(g-iDqDjO{&0kMlrCPK+85*n*~qv1y=mQx*wpONHA@%UJ6Jo z4QgZolxB=#hcTzXgksrYOqi*RG3;lcvKOE#W1;#c1{5(B0c z2JtyLys;OH za3jn<#(22ZGhkL@X(mQ9usc9agIUI03tGrw0xcO}Jp;yAhC|R}hQWJyVZ#7lpt@lT zIbi%BFmdP}TNs~bKV+sGrXI#ugNZ}c!}wk>ap)df7(WCi4pk51hrz_5>S27?DQ576 zB`^=XgE|z{27$3*p5O-e5Dma9m)K!Gkb&9&(g0)2LB;s$894M+YGA9K*kQg1fXajP zz}P`hF^)P0s0}bbL_uXhs$p!H`$5M@JcBw}3aXAV7H*LZLI~Y7(3+wvP@OOjg1XaC zAy`C!_L)Ns5rfi@cnpOeMl4ZZM%Jc9=_GalshH4r9W+2P#rw z-h$c17!S7=WKLHL!2HkZ;H@G* zpB=`9+00%I8oywl&kjp~FuOqKEI^HjfYKmiVQiT7aQ!d=c!WkVz`cnp8NtLApcZh~ zGr-dr13d0wp#ZWT#)i2Pp2!$}K@VO8=VF*6nxF!3m`iy5Qlv%`3>!~8(i zSP@jk94HN5Xai->gVLZlQS2}#%n0Tx{`m|J$YmJJGasOum?mhk!`NS-VxaOuOK(0qjQ<}h4pIwa z8y$d_X^WYcg4DwJ0Z?&}S{SBFQ{TrNWj>BP%-Wb1`cD` z;xu&A8ROV73kr8z4Y>Ojs_na{2V6@uA- zEr4Lgzyb^wMxfzLn0H`SGDfkhK#f#`(n#)y>4c1;!gx^#h3LTtR)`2Zm`h1(Ft@RkEuDH2045Gq591fX#G&e8 z{0}g3sCpQm;}DwpP`(tD2IW64z4`1gei%#~YCepg0uzUt594RS#G&e8eAp?ZQ1cns z(E|t+ALxO@7|o6zE+A#FFfoDpkujPb797){LLg;}pzM868r0f_u}?w87^B%?OjyW( zw8Gf1P+*LP2Z$BagCJ!vb`VsIF`6C5goP7G8H^1JBalO2Y*_e!)WO(O5XQlnGoV7O z)!=2IFfJ@qLDk6;Xo`}7c`XJWDsW{n4D2vv@W6}3R2GX+whd}3V*)#jc@8SX+R*TW zVLm*D*r4`8h0$XKDhvzlOQ@>RlP6R)Ec{iV-e*i;*MKtppfqCwMwl}uu)~5k1Fj0; zrBzV(Ge)t)n6QM$7zXzaERivW!NaEm>So3;c%pfS5P~sbUIDH6g3A7Z(u`s3FeVGs zVXRdQ#wv*HrUVsc41;^r4j}|%IzWXu>KIH^z;iWDP!TsM%@_v{0$8d7?bcWZ_4)-U z4O*BDWx|30v?0+}wHmaq7d`JW#=(PP3d~1wm_ZT8jvf@C#0?9Ue+Zp0CM+zFtcFEA zJUrqs!y}Fz79Oxn2eJni^Kfs+F~FnQ31&C;G>@LZ857{C0hYKy`{kjAz%x(+JXBz% z4`Tv6RAA|xF@YTx0tEcVV+{)`p-TeBaMSpqI(shvI3d}x}Y>; z0(%dX2`>i{7}y1%-cW+le2CeK{q<7w*xqsEDAwu zK%qh~Z*tVbx^}P_#GRtOpn4hO*kMdq$S}skgCzv23Slx#1XlQR*D;jA`=13+;skmumF>QTE`g2 z4s$6iT0zQSsTk%uP&XIdIL25Et)MtDL zR^%=dEL?WLJQT$aW1fHtfxAo$?4+xl2Q`41!(u)=jI#$S$QaKs8Ob4Ru)`#spvU*I zxj`AQvm)6-paQTH9U0hQYGF#*U}|AX*@>kg zP*rTtpbXgYf(&dhDVPi!OzIa@DFd4r^gKD(5sGZELjqxE8M47nGK8HF$cBF2AgZ%q z=j3%j4QA_sGGM3WF|fg;U@~klsRdA_3~YO#EZE_IY`35Suv7Zjc%VD#VTa$bp&zBk z@SO$Gd}gzQD))iXY_N04V8?*5!FH3uj%H#*KZ=PB{R|ccHrSD0up^<^x}e6xHup2I z!49^9oqogyJIdz_bQc>N?2sGSkv(ka$HFkM!45Wp9oxhf2h|MQw9mi>JIV&OUykhq zbT1uj&mh}3r~vFR5QHAsZap>_;|5eI16vMs3vUUOW`iAm1Uos34Yq}S7fc20d?(oM zUj{aq6ikK zn|~SDU{Wv{HkcG_A1m7hsAkxPRt7eh6fBLw6B|q^8%!-C^}*D_Xf~J>DXAQ$8Aihm zfo)D@gE8QyeuBClmUkG~(D$6OSwJ^w+CgasHrN(a*mhGk^rJ@@*kC(5VS7W_&^LE7 zu%U14WLpE>>A49?Gr-LigHBqr$v_!$P?|vndUqNF0|NtF1XMHyO0#7^897jztpLg> zg3@d?P(}lkW`pezgYEBQV1t@m}w<2L)xH>E-1|gTjvj>*MUVX&2P zFbA>0Tx14wnH7`)TWrY&+e`EeD#7*&%J6|sI~H=1R930MN4cj z25k18fep3*0=5W=4aR_N8DxM*Cp;8kYYAZU_zZ0Cpn(KiY{sdhS7K1~yn?fTaaCSlq*+p3M$wF)Z5HU<;dJvBU<8CfEX4HrUeD2xwwti-9s= zsgwHn~i5+n*mh}t3k+bB`wVQ$paBY7{>=v4)CCIz z1~yp!hh={@cl~ zVXK|kU`~YPLpE4Oghd-0EZ$(z#lVI>P0ZE>jlc;|nt=^ADLw}pG;H&r47f|sEoNv$ z?&rYfEMYX;HK@@KpfuYPDB}f`W?+L&A;M_f0RA{TU=?R&*nm}>jbR5?adw6spRk$F z!65J%n>Z(f16FY^WbeS)%naOcHZp^m0d(6MvIvCD%)kp_ppncBd}tyNE;9o^gn>pf zGYFuGK)B2df)EB8$;=>xCIaCyGYCT%Xe2ZIRzQSAFEaxJ3&Y3%2oVSi5{j7d&cc9Q zJ?MTq(9MTzj1ZkLmqB=p3@~ws>7bhtK`cgwJb8!;5D$cvaF`EK#mFE5H6NrFgf(%f z2gxyFNrxt&(@hu{8KTh4ftimk?gcs^g#nR%AnF(xK==PKGGM0LTB!LQXy$i9&GCSy zLj#Zl85kHQfyG%ER-mQxjX3-Tv7eD)5t{kiai~84HXo6XJlG)?pTVIXX8sK{^Dh%n z@5BVr2{E04;RyltZ_w03bTcyWF+*4|a~=^e#|lmTTWI({l7*Nv1!@q4$H;IADh?Hf zmTHU)F!eC;AK-9fVkkHY(Fx0$pkQHSU}9)M6X#;Yo-ZJ}85zptAS{^qJxuu38z`Wv z7bal74Vrq0ZbpW4iVzmeUI>qofkg?zf{DxEFkh9CfdQ1S{h;bW`5&YQqMMNcCJqt< zVVHOjR6R%xg!Q53L_x*T&4G!7)Pk@zRDB#&JuLWO=EKB6YC#w#UZV_Qfy6)_^jAQU{@VB#RPAiNB!UPTw8a2iMu z$vrS}s4&ACsQO({^`LSYBnQ#W$N&=uiGeU^d>G{Zd3q2PY|J20M12hthlnyTfI9Oa z^-ByP>OVmxAUs9}m^f6J0n}Ussh?&9QSk>V0pT$+z{H`#3>Ts9pJWVCApL!?Y5DsyRV2BE+a(KR$3&Ad)gF~Dp6o+~o;zHrr z)xW|aE*6Phy&n$oA5qxVXMidQm}imlQA7-O^&YX<#n0go|AIr@CJxmcP0(fU3``6k zPC~?CJvV&<@!o=FjwJ#04Dk^2VP1A5pxz8kJw!JnLj{_+Hvw}Fp{a+N^9zUgKOEvg z2@sty_d|G$3{%j=g9*524x0KH0_rUiAvVG6O(mfI1e$t+{emP^^I`3IhBFXx^!B^} znm8`=LDzJG>aVsMh&fB39)R!|8DQd2VR(Mms)eXP7q>tYhxK1NIw9)O`!5wxaddNF z>S5wA|4ujyF$dkh3(&+H3535)7sMQx`CSCmN1&;nNAYjfmH1!bOj11S%#19iN zhp88$6J{@j$H;I3hxi*b@iPR>x9NkJ2s8gG0rh2Q>hBX!zhok+`7a5mzlEkAqMMOH zZ4!h9b0>ty$e@EJ{)vG36=>>z6HvbeO+C!sU1;Kdy>sOkyjyDw2h{O_IR>enU^f%hUOfWlyhBre2dtf);Q`wCFs||(tek<7 z;l?Zo3+5yUkC8!d4ul00hn1@Z=ONZ zsqZA9J_$|z6awm7(9|y=p#BJ&`n3eqpFmT;i-7ufXzGs=P|vg$60)!$y+}a49-8_) z1k^{NsejH48Xw?bumE-B85kHipca23V9qKubN&%fe+^AN9}9u;WY}U-sC&c+sE6I| z4OPw{M?gL7LTQ+KH3I5opldK;>h%ezhaF@OQ*S{)J#0fWOuZ8U^{}aIn0h|~>fsaH zPz^Bz)WbGDL6tLP5>OADu_dG)*Zfy83n(38pNGZPu4n|0tFdCtw@!kJqtDMS1&gy_ z%-e1Qi!(FK0S$=39M8bOa0)DrIsbbXERL!EGYbQQ5CbCvY#cxhW)>?%9M<3WfQoZM z#bND3GpM*QD+7Zd0~5mu=s17|R9pqB9@cN20~ObXio@C`NlA13R06fx!VP z4r>S6K-GJK#F-cwVEJenR6GzQ&cMh3EB~#a;*lV6CPoGWXg*y475~Tp@h@y%Ob05S z$jZPV!0_?^g4d|!TQSHS21W*0d%y*%K9Cz?4y@ixfr{5b)x*XCoS@=uP;uBi2&^3I zgNno2Eui)gNXrbUIIO)58@FEy6^G5sz~XBYR2()g#{@Ejfq~%=NSuk00hS*@^Q<7L zb0BdBMg~|r_8Lf#fq~%~R2(*s0~_bL4;6=vS5zEFmYKnP&{I;XV8VIhqm)yK;2^k z6^G5Q!Q#apDsBZG_wbQ|Xz+oG!^YX#Ai@kGP;uBiENmP*4kXUR$N($PVd*vvB+kId z0Bc{>K+VaAio@Co4p8wjs5q=&56c%VY>@oO0L_mlpz0@r#W@%hpy3Ad*CMDnuyzqF zovZ<=XJTjgfY#362~`gp_lCvSai}<~zX|GBfULd(6^D(l!sdf+LB(P1#tx8T1_p-b zP;uC}AFP~t4;6>?n_&L^4i$%u1FVCZ!^jRvKd^aN&^iN<6bCyfd=TqcVBw$uRSz3q z{Qy$Tz`&pe6^FH>VCAG9*c^6-7trv5nd1mm59_bJfXIz7l zfsp|=u6_d~$iTpGA1V%;7lx(JPf&5#{6!yB{ZFVkY#bO?-m-8&(gSS1H3(`D4^$jB zUI9zb3Q%#_`k6ye^9?yb>4%+x0WBW|azf09t)GF}>jE_g)=q}iFWyjb*nEKww3-P4 ziDM}rc0$dE^_%jb?umh_N3YjXK;lUK?l7qN1yFI=_+c5;oEE4!Y(5U={$8kf4s;#_ z)}5XK6^D%*7eUQg01h8ch6-r-z|!q5sCw8u1uTCZ0Esg(GQiqripndJkCr_!ue0M!ee3=5#{geqrX-~`1l8w0~j zNPr1IGd3?Y{9)?~pvi|p2`UboFM#DEEvPtbz6_?`0xAw$Hv;pQ6I5Ib>fbd`2l;S< z+=(c!pu!9hQ1!5NL93t=p!L$Ab{%Z}63qN~u)jDMB%uC;l`9}$8Mw$T?hmCK*%D3fEaoD)40@VGRq2jP{06VDo0jM}^ z{X-K}{5Vv63$z}GTFY<|Dh^wBaRsXW0aP3|uJsBk{v0X}8~=xupC3WuOpFY${*)Hf zf?ptU2E@D)tbSqQVqg$tVq%za0g`^86BGLE;RI46u330%$lFLd9Y0ZD9Uwgo?xF&7r}}&;u2R&4YJA z&6&vs$`^=rcTi!56)^SC{<{uTVm(+rJI4CeUKWr!nB~AWs5!9l{9{ma_Cv*C^L-&u z@e|71Cao9K*tlet?6^E^J5P@b7SEx8_zH$P{a0UhjAE-ENd=i%aqoLxkc`In}Fr+}m zVe^1c=QHF(#bM*Fuyj=k5@%v$fQ|&@mY@pQy_6BMh4ip zhXOPrcR?_>}zk^ql;p#GLq)lKi6L_{7o*hUEO*f}GTn)D%5K>?**<#U~aOC053# z=9LsxGNctH=BCD{l;-AEGUO*^r6!l?88F1hBMHZ6=4F&@*62&C4&!&8Y&Z%1kTKgPILem&uTtoLj(FW+*T))iYoyj!!E}tpJ5daZ*t> zNL?``K=qOtic3;5^TBjcazQ18k&~JSVdO!C;^QIe!Mx~X3O$8;7;>41YN{|@D zzo6(SPE7^7JU6K%zdSh}Bnk30*vYx6xw-jesk+4_rAgqNkeC9JFG@|#1Gxv1w2DiL zl5-36@)^n@VOE}8RFaSW=t`&S0q(C8>ESDQOVhB}Juq$t7tiU?X!flhTuuL59c2y9GJ=y2iWu zxx~kVa#UtsCOnI$pb8Y1Bo>u0#K(g&8j6~NqErkqBmtN{RAo@nTu_pZ&&f|W1eG?4 zd6n_`c?|K8fQ>I=h>wRTD9OyL1ZNmfd>2$QBr&sB_JAuS)N`WN~23TA|s-O6Rk|KuqqEv`RkRx(3lai6rDnmS^Yyw#b zO;kyl>EJXKA75;g!~iZN7{K;{TmUNH<6(78d}2-xD3U-%g6bAX@(00!u8AS}xf;bK2wzQ&D zaO6P4G(I;eKDo3A6cn(w0jOjuD9TR;Sp!Xepg@XGN-PFN1vC-o6lY|nfwF5(NlBU! zLwtN5sQdsq0#@oX#K*&17ces!;&W1xGg85|E6CBA1v!-r#U(|cDgzWMkl;-&EhmD%)GRGP#Xgr%SdGoC}rkD(ph{lq&^3EFTOaf0OXPUf=XyeIRyv9iyx?W63akk z5jY!yf+0J;C^aV)?7R44P@+M&1XM9H#6wyMAmc%er~G6PD?X{X7*v!Nm4HIII29BW zP~$<#swBT8F$bEeib44t6f)rQp8=8_8Nj}Snw40boS7L9sZki>)1dVo$Qp1tR}8LB z7~<1Ftqg{ESY-w`qNE6vMnK^RN>ybr{UC3E3v&iYl%#Z4#^gtZK5T6Qe>47o{sL}^(0W}~%-h!kPu)j+(ic*U+ z@^exc;!#`%4lH=i$xX>jOM?{HAcJ5T1s?G^poSaBL&@Me9F+Ay2Sd^HTj^KhbI!r1lsVKD!#>>gf zONFt){RJ4OxTFZi1gVKf=I1BpWEPjeEi1}Phw!0&KT0TR=-MS%{}nc#0GqdZa1hmW zSbq&BstDB&6Nl|9z5pHAJ^|}6Lp8wqnNThRXdWEYGlfoP!1o`|xCl`Jn{R{gKx-vn zEC_APzyRK@3)2tVr@R2FAKgCaFcN%yhdl!Wcvmk>KWx5y15`guJ;XM|x)7MSH`MFt zV8eJIDKNH%y5ADaLl7{1Fp)Z_{V+a^E`jQ2fF(?*1iJoST>76vG;9GSa0nAjqU)cD zL%#+)M5QfS`iF>ujRF(Pap+GKg{a&CN}yns5CS3!VS~ucIP@z(=T%_iHz2hjj2?fG zeZ~w7=<(+O-ESfQ-FFPq3&Jq_Vf1OJ{pk7wp!+c<;s}43{@YOfAhVJ2L+HK)qhMrF z(ApSO{%aiig`p=$`J!#vhuI4=1;j^lB3LTnFi3`h;Rkd8PmFJfjWMqH=MuyJ}2p&w7fx&|V!e(J$U~m949T>P6I2nW)8~-aC2r^7(U|@LO zzyPP44H!Xk4CxIFAetC8-;`|x8I&y=8H8CFnUoCznUqZunUpOGnUrk~GAkQgWK}kK z$f|7dkyY7dA&auXMmA-WgKWwc7ul3;9g05yLJRNNA3jtZ0y zquikCO_(4eTObreAXMA~%3lDb6Ts#`IY?A04)Giu;tVPk3~9L~@tJug48QGqyUr!QqK!zgD99dx_TXuBslCC82F)V z5Cs!QS8oE6gsMk2A102jehQL$K`0wU!Nk$k!_uEP0|QFxf{CN6w}7S_2?j)%fXs)9 zqpP=pst1J+2!qsuFiad>JuKaW+`|r12*ogQboFKd8I| zxeMw{u$dqNrXT7JkPsMy>;f~O1gKnOW?(3Qa^aLN)IoZ15eNfh7lZ{NL40((K{5$Y z{jhWgvX>hvPrJfjWMqH=CWg-pAf5zN%mFH~gN+HyVr5`paA2@tU}kV&kYEsJU}j(_U}0cj z=zb2C#vm-wL_lVPgg`XNED#%lK_Va)guZbV#AaZC(F_6*K1i000U>_lDM*BY0Y-NS zLexnJL1>shN5Mu{r3Y+Jv|8RPB&aiQZ7i|Lop`uux>D==1s5tOvokPEJnow+%*xuE zuh3xF)G+-c1Hrg(408%mWbY<$~*2XH3Dsg58hI9r7hNcDv24P0V|H>wU4B}5g_8xV4&)~o& z%({T-JwpTkdxi!{VO9aQ_Y4fm!mJAz-ZL~PH5)X7^f0D_^)~)jHV|ZZ&v1a}J;MR9 zW&=hBVa7%VR5=Iv_Y4f8Xma0_Z3G#VEgBhwSs0m=4FZ{zO%j=uEee^GZ4NRk8(d^n zHhIXZZ1Is**=8Y&vcX0+Ws`$!$`%*dlx-feDI0v`P&Q%YRJIW0e9zF}+-%Uu$ZW#M z*lfhe#BAKi)NIVi%xu@l+-%3l!ffBj(rnMj%52)m+HA_m#%$Ke)@;Ve&TQVu-fYgu z!EDjU(QLuUDa_c&33WHzZIrlcGAk>C_)$=pvO2zJNYEXOZiKkc)%-n!gFda?M``>{ zW@lws%>LzHv-_8Sv)kDjgj?A`=}?-Q?qw8Idg1k;GNm$eGW(HOVa}7W#+*ML*xsl; z5stKUNap5b5N0_N+vp;b(8{97(lq_C%*=lf)huzsoSg9>)d-a=ai}UEB{-!lN@2=m zO>Angb=GQ6EK`!Y`@*K$AyP~%-tSaX!ODCi`5UiKZhP1d!pCIlPMy=_QveVdj7VWnIgAh6eVJ>66>r3->)}b>H{I!b3)4GMgxa z-J4E#wI5o4%)Z!N;K|@U-#nd_QFyvKbFwcx1M~8uT%BoG`+t`G6)Wvmp7E7IdD&Ag z0}iFu_X-TroNqNn1&2H2G&pp@dw){Vc zy&cRx{(s}4X1DAAHy&bkeg5CrbOD3i)JoB&hO@Vt-Psvf*(aBkGkpEc*)Poc{eM$~ zaO-q1*$yVRgURJ!@;I2h4k8&DZz$Ucswo>Nsw-PKsw$gIRMzX<)MNHS*`iTR*<_-c zvW=mtvPqz-vO%J%vQ43~vPGk^vcW=SWt)wPT3zoQ3`ArS?OON!c>kgP)2c5_kC>h% zvvDyrt8=j?cd$n>i*qt|rcD-SXFfRD_}g^`(MQZ`C%HDKUuT#-ot?3=eD-yA$6E2i zer1WD42Q&()n0NPoGkpkogtZvU5(kilQEf%UF~JJrh9V#bG5JO&D+~&2y-(^M!m9o z3FggY`lPJGC}8&%%$vpZf$59g$L8Za3{8KUJ}^CGddl=9syVrpT_&wXm_2|gx#_t< zv%3fbE6d;CyIH0w%HLEuY3Y9AxOlE9VSDUVEGMT~Zld{f70qJ&jhPm#J%*p4U z>nNo+yR$H;&bNA!+|MrdF`d~@gkdp1BM&P}ZA_zAqswH@1+0_1kC!j?Wo41(5bC zPbPm-VMuOfV(8SI{MUtJQhD+;UWVOmR*sK7FK{rsf8^yo&aB=jIGODuud=~q23GY} zw^nv#lgkXsIu8YAv#~SSeUb(F)aANHaw`)PNbM9sh{{g4PAn=PyIyTdW)( z`%T~oYfrvx#pu_*D9scUx|7(e9;Jg~wDb6*)S%Y)3JDBR&5L?KG5UBu`=d$aGY{tr zEHG>i=VYAxot*{5V~B1xXjEr5VN_R2Z8m9CW42^eYqo4uWwv5eZMJGuVYX&eX|`@u zX0~BeZnkMuVzy;eYPM}u6lP@9Xlj`JgoTmWkAdC8K0e5P<4{^!8$^{txz>}!?I7KaDu>c0e`jG5Zf|2q?qOG&leDih z`4qd#-|)wbf7B-b{qo)FMWb%=49>h{NuIoSEsQ>m-jjI_N;JEF@CX}cA}?0$Bs=ACQ|lmC9%->7T#qS2kveKG$-p4#wa{x@=yzx@5) zsFFO9Gb34;$K~Sx$-iY8K(;*Y<^D05oq>5V>qm*nJR2o4w}aCC<7q4xKq;Dcw*VK| zKLsE1AB(ZRifWeJJ^6bJ!{bhNi9_jo*@eHe|CdSTNq1zodcnaY^~Uaz-m~`(4FRjJ zcDg4eKj!=z(CYq};cLcZb^*4>oPYHuvkR~Yvp29lX8o%tT>kg(-|$^;l12V7TWs}1U zS)b;*Jw8-sy{z1=yj9z7uCl=!24#~!3|XI)bqWRNx;gSZK2T;Yl)5Rk(T&mV{epz# zrt;Zs-~T7Gu-3I|3wOvc#I>2tRW{&ZR5rN-)^$(-q$~M&S#?_Z6iMkeX@<@0%Ndmo z?l35uykW5Wq^tu{A^_GiC*R~`w%rPnO`gYIha}t0?lpTRC*$m!oQ~((AKzlXW%WXs{Q?st#y4{s zI4(KW4A>cx8p0Yj}fPRWuF^93BF9;N5KV0yE=d%7biMNdBY z`~T#dKb;|IdGpUoMn<21y5coB<@y%JTU0+kaEH1hq=NdGC;* zA(Lv?YWMX0hy87<+Jjo{dhH&*cVJML$xKQH*|P7$V-DU$kK5Q6H6LdO#n__BPgoop zRW$cZej);Oq2(5kzd@=WPhwv%nVo?NI`s`$ET@>>?hMqN@)H)Y4;xiZZgNV0SU&kUd$Y2@N50AI?F@D=K&=$^lF4sX80@|@Te34W z>UO#d^ER+^ZUmXf!ZagkA)DEY{^qCLx1sWuj8NM?t z>Pg)La_40B18m8B|FR$@%+5^^u?Dte_J0|ZpRlkrs_5=wbx)r192BZTobJndA5VFH z3zD{!$|ryS$?#WZ*K|;bOup&Kpxp3>;qg??f4jS9JHBht-6qT)!1g$L`B6~*VsvYC zv->0U6HRF)ia-Dg=D zNRM0Dw&|?uV3h`k89=obtX6SkPWHbZ$5cL>`}_aLK?SqFW*l?_>6qNhG3TI@5v~Y^x#E4n20_i22mKsvV1ASJe|)^}FQ}G&G#wHm&0u{O1wgHV#}U_? z;P&$|g6+@$aK8~Ic7f+HH*3qI^v7N7ZTnh5Wyc2Ar5jj5sb$vlZA;ygpPQS{?&M@% z%xWn4t_76WH%b_8g1f(iW45FJTxU=yt^|c*@O>7D`-K^mO^`$JF*Fp9Juv$NsuKcO z1HV2(3dyz%aP8py*bzB2h0#JYIrjQHh|57{2rw#sh14qfAM~N(?+X^x^Zo>da{h<> zPw+I1p zKR!154=ALUO;6{F%H9#Sq91nBZ`+|n@#}cfsCY9%ZSpQBhEIH~xfLeM}*=%lh zhU5d!w334gm_ca=(YgY)tw3oQWR4^AW3TI6!pDFAubsa6_iF~V^xfR$j>#SchRf1~ zzq2?P_uOGfmS-;j=PI}B43oc!Fg)&K<4`LD)vL!!H%)I<1J$0&2AdhA+t?UDwW-~w zxo(ckj}ITSYAQ4CxWllSyTftjJn1%WhUCk~7`AmcY9qU;nNgZeoB`&hgOF6@f7}A$ zrrq6Tj>&-q58SHn18<3C%<Aq z9ah6XzFXD`iS73V4oQ#YSg#1xHfuKuM)l->kZ*Y$ccBTC4ngIEqsLqyP#TO}c+f04 z@P5F<~9_N4XzjP>l zPV&Ca{15Bz97?x((Y%wL0i;X+(V=t@JO9J`2Zz$7-gGE0WVd_qe!+!;q~ulY`5*Y7 zTfJBc%5Q(oPl8Hk;qSZ-OdsOfR=O;8o6PZn-*Um`>ob`ie=%FWuQRQ!sdO^WxBsoG zdLK4_pUE^E)IQ+<_OJ4OTREsCe?0r^pU0ize;@xfTilhtD%I-8=AJ(ec5P{(dNSaH zI9oZ$tfXXSH*p504@=#Q%?>aaP2cqaWRFw1>-O2*Yz&W`3a&eDUe>F)3sPs)~!c$2@2Ff^V|?&f5e{6vKT)G}3O_{g`IVIhB`3an+@>7M@~|I*|qEDE50 zR-+0lOa6!Tt3YP9m)dAA^7iMqo+Xe0~KI-js+as9QKAEGDUzp<{ z-@R79wxCw25APK|n5CtI+SN?Ot9p`IzSm41v6V4d>N^9oJ1aPRlUcr}=!Nf^ z0cz{UwVrEr`yut={R9J(LlsQL$J#Vs?rxvvX!k)c9AwU}Cu!-)oZnSIrY5i?3x4-n zRj!ua+Pyjb55wco2MUj8vCA#X7UoT0TU9>!JG;Z<+3aGl7T@Nd){Kps3)j3Wd;DGO zw=g>c^W=6hhJAmP8=f(|D|`G(?0@8bPz&YgVMwaJ3-5aodwBJQ9bz|)*pez zXoK2g0c4r?M?mEt;nqX4+jWa%DK@^QGElw??N4TBpMlYefcAZr4Gx3*zsc^`{T!K} zE;t10%|UW;7rOwYg}!n#%tZ;ZkHuLhfYMn02mNoL65XsFR32|;%>U3o5!U8;KVgDV zQgX5rYZ|C+C=BZPL@YNf%$Us6Q8f9>m+!E?UZYB{XRkM-Px1`*1^FM&H@9j-dLDZi z^FQS8NNbh)@&1AQ-Pzo%3?Or0Aq{G8L)zC)#gGgDr`vT)It+0n~%qHC@@{F}OAYmDtHH#~JcJyl>6_aDMaT@4O1h{p=Q#fBxi$ zlw|~sMv(xchd;W*~ezo+k;mPjb zRgzubs5F(Ur6)UmPk^MWUEPhxmzD4Ce$D_%PmRZyr6>D;D1iAClBR@t3)n#ZU6-ER z#qKj1+za~1!|2nhng3w^hfV3pr`Zia;R6omu;roPa4t^V3yK{`+`#H2XgwKmy$>Fr z49W7WpFr{XatBlS*SxvjY16I#q@^G974GGm<9XUGJ@7SKd9C=a4{7PO=DXf>rGZkQ zRvIFNL8%AUa&u%(K6jgkt(@77ogt}wGh4gk>{d1gX?8Y-l3H) zN#!8Dj^?12$=g4zYLHZ*Yyc|xq}w62fAW#n7BKf1&GFn04YLG;++ELUytg>%F$}LuFCT%*WUnCY6KyUOzklavbyMc}$Oq~_CSPY`SeD-EHg_I4^>BRTTk4*C=eo^g zzK{H6Z7W?Tvm3BkKi|f*sl%+bR!o{5)OUXIZ}+inOplK)|2Mmhjd}97Z~T+nU;JOp zf9+rL_v@j;?27!73!0CyGbl4$XJ}<-Wq&;D`v1x7f&w6!&F$ijyQa^OoH>8rpJ(Mw zWvuSIyT38qYflciZl?xI@6ev|!YA`s61p0*#uWl-~42a5t!Rpe*p6A^$=A zg>&us5B}e30*w|h5c1N)T!BhTB7OmFtJ{0;vn zzWL-&29W5!r=FW&Y6}9At;~yW4vhpY`rLthoZDN9u##AFUtnCn$J4DrYLb*RikP@a(BHMz?Ou6$lkpE!*;#K9K8oagp@eKBscV+n>?Au^*wZSx5 zl66H}IV^t}&H1|x6rZ5+hQeJiRRPAyVyw&b!XbHS{SlD)c`qQT>QU#TZirp-yYe60 zp99k)V2~`sx@cV(Q#nZ2ZnoeUsguF|1wS zXp?-on;lZ(fLiO2z7V*?3BC(0ao#5sXeGok}Rs+&Oh zPx2YKWy$%GPng}1e|9??vk1>-w(Aa{QIOf~VnX}=tljvkeBa+?>CMOf{%1b+o#9=3 zvfMR>$*c^_i~G0#dsjZW?fd_2f18he|Nofd+CNZTIhl0=vvAor{^Zte42%1Z|Kr`O zmd@<99L$#8x~w<Mo^fwl?$_f;BR^XYPUDN zN$z;gG@0!Kzgil2w&CJ&rnXXR_Gb>eo-`j9Wte(8EuB?;*Bjw>QHEU~9?!e}CoTP0 z`p)@W>ATyXGwp6KXG9P2%pGp&ps^W{>APP1+zyJT1U67S?e6XdwQ?TJeBSB_Y6G@< z=YQDW29a-72amL&#a{l0{Vj*mW;hAAwK42!OAcmd_!|alxl8x3F&MqDYsr70|F+Y8 z-=B|rK%?!GpR==o=7I7b*f*_e2hEplYSU}m*P8#}{MF{`tc=X-j&d?k#Y0a*~07$4$20NKFSgw8T49YB)eLbZ6!O^FkN~7VEu(vEylG zY4jFmWb|!n=xX(9eb1m^mU;DW$j$Ab`9(%Sr59>X*xsya(QBD`c!#&*d1i4IM$mlM zNgWx%V0A)2621ZwFwgV0VS0viKH>@R zIl}1r^xNd`>>O_|3#Ws^;|W7;=*|6ht?wBY#Gsme_tWHW?2Ky7whJ%xDeiQ!2t}&UFLE$mewjYaH)mq;x1Vn-Ki{yY*9h|&%yG~By*~#oK?8)t4 z8Pq`LXM*IFZCF@Da)isb|5a9DVGwzcx_znpoC65AtlS=381#X8S7V9SkG3bwmR<6T z9;p5C`x5ph>P6g>qzB0yoJ?BX>$+RL{zf*dbTUY{eEFa3$HLIZa%xI)8#hz)_7;WY zrgG+5lZPUYB~1P=OJGZRRN_>*sFJDbQI=EoqHLxd(0p&RdMCq-l)vW5E$uAITUZzp zZ#S!R8t$If#lWo7$?&zmQN8m$({yI_PKIXlF8O4UcE-o;>c7w4w(HE?-mLCv*u1qx z0HkW>^Qcy)=@0iSt8_Ay?$>K&n*MS7s#Z{Mh|x8_;D9q|hPSd%>4V=Bwl8XLyk1QH z*3O{Uva0jyE7o*jcJ_uTt~bGRy~zO=1T0b_j~^00IJq^gc?l=O-#+C9oD4h_f1feB zwYvGWGEM&*uGN;z{#5{!mMl_uDkgT%JTBs5lOx(U^RP{XY+oZ(RkFZW9_Hno49(&! zjJfB(x+Sw-XSnH>EO(txB&W7qnEiYG&wgczFAR_v(8*C=Fq2{8NpM`Xeg)NP3=jN3 z@xDQHoRMqD)uN9Qn>x#>Z@&|5_4-r?WFVPUh`a-k{33yG6yZ(OvNIoWPhP z$!-%EUT)W#`8asOADaZ8ie+tHZGNpy(>v!pc3bcd>ZJh z9UpwC+#ZmjyB(ws=1!5E+0)q>LG!q*=?FLf>|c4^@T zgXEP`pI&~t9khz-Wa{MB)|h;T07*vIriPcPlUrRE<}(yXfOwXLC)3&fDE(0T;`PDr zP0)+5Cs7X=QYW`RPqBF`%-$N@>#l6^G)P(HYml-5YtTe@txlN}if)ar%4#fJ$_6Y9 z$|fuf$~G(v$_gw@$|@{O!mKV_?=RRti_LB};bgp<6`OT8Q<$6k+T^ZNH-)*l?oaO2 ze0(rn*(QZq*&u{f*~Eoa*}{aC;m1<;IS_M~v2ZDGU||5|4COs649W{wn3R{WFbTJU z%-#Qh*`$+kJ3AAD@}3lCj4g~{uIUZ>Ivwl|YoTX^0p zY|znaVLY423JwPq6-JI1!fhng=%k_w=|Y`y7NX5N2WFPUil?0xH2u ze;+JwWk>d-%n9VM2l)^h{^vlsNLhh}P1%NpO<943V^M)pD=bGbWr5OtLxSXyMJiKjx?Z5tR9>q^67DM(kgwPnbU?nkf1=^RqL!KaLGiQEU0LBLLoPUd zK~j|HdK=G)hnpH|H#apvASlIx(%#aP$h9zbYij0FPw=N3wprzMXyV%b8;u= z)%OMoQq0>q8C%nZTfYBgNjGM3ar`(#ZHi$-t%wmzviBE;Mpv)a_YMn8o40c^E}Ndr z_m#n`^}T_DIHHVU%3^c{g~?{t1_zMZ2S$Ixlexb#ZU4^5FuA?GW`=X~HcrOI9?S{?y^|t#3b?w=tGYelE@+^IWud`!_}g z;R;ta+d-x-n{mk9{uO?W5rO4&r5QQ6=JL*e$O29W*AHdp>ZT=4kg zw;z+QO=l2vOU}Q>G5K0LgLLaOW@%AT2I;moWO>;`&c{kzZX`C;aOfqbYncBpZUu#~beI}a=+1d6yI+{iK{Pq%8pGsk-x;J^+t?vy zl(F-%GHw@Ua|ngVsWVEqUW3XVW9MVNx>cB!pv4Bb?LS2JU=IQ<@w3q)fkv9 zxfs?S2i2SA+zbtko{cWT-rNWL+QM4r9$D6wTs)iMR$HT5)AZz!1tQJnT#Tz`cJ_4k zD_i_xNN#5r0OrMVKQ{r5YUvF01 zqt^Ed1%44OG70Betl6hK+RcqPqHM5)vC$LcBDFcKVE61j4>A{I-?ARN*2i-=e=*x| zGBjI)+~m8x(VNk=(TC9|nTvYCie%>=S{*&Jh@ISvrJ&wgigeU{*s zvMhxy^HHT!)uJk<>POj5Ig4_bazU&2AR%)8f8te8{fuZCeB2JIiJ5IW8BVo3az5ta z`3G8~kkq!)HLdl%!UgqYMphA4*4^Aw9d~Yj*6P>xUg3kSOajQXbJJxWy#KKNm+Q}S z?dMwNZkNbO&iKwG5s>`!CDXaKZOx7v0ed&UIvM^al@>+ZH^Od!8J4p{JGbLUKl zn_H7V&ty2)V%Mq$3116P`0i$#?yzin$Pt+bAOC@DdHVK<98h+e~5Pc))VuTu;mq zzh1$uQEks!-z!Ye3vrQ1n9a`3u)8hIF=~3q5s3%Ad)3;)THhN?5M0%h`H?3Fl;-xY z0)?-kyYhlp43ocq{~oz_Hn$7|=Uzj1kT^&*aBFSo%)PONUO)W41bu+C@Y|k%+WUH4 z!knx@jNX&E7`R)#|3-pZ>&zycjLFd-m}a+p|KB9iIH8qgb4v*GqA4KPC;$G<&@8UP zsMMO=X3oeo%Q!ogkx?5|Yd@aY@{ie)li{&E=P%U0z@qG^R;O%GUjWqwNe>`y(CWeI ziWnTO_ycjpqSho#cT9k~Lk`m&OgS)@OlEUsXmrnHO{@@H0a{n0JmDF`A@NSOgOigv zt}-!SXJZg96K9Y-1ggbYn?e1$&8h5+mA4>jw?WlDmbv<;sbMl(DoA| zkN*~%JZN9dpwQ(uOQoGwuOw$*V!35**V#i<)8g~JnQ;D zP#c3eoRy(DT$Mrcuwwene&v~88JNRW85XAh6;I~>&M=uhmEj<3A}d7aPf_KGPZ=K1 zTK*5TFCdj66DltI`0y|U{|~aasi8UCl>yZHWP1ZzQ@yI?E?C&y(4fG77UXaLGQN z+@8W9xd7rO<$2HlJ)V92pYj|Q21k`--Xko`*HaiO?@umg|IqtdxV43Ga;pkMqq|mn za~L~ArMUF8HinD+%7Wh+CSPx3cr3R4A4t8T3P}CS`@)z$pDhG zZB}coy^h+p75>itfzgHaxiII4Z;UHyP2PW~zx|kBOYYF#E{(WpgyeH8@4ZAFZ`aYYtd>+ zKF!Lu*IlnokaaR!3*%nbnq8 zkUwnQn8RBb*R^kc`I3S8`t$!k#g!*MX8^~55DSB&YC%JSF$J(l|VPk9b2LsJ7t=jLy0jLEav7=<}h8CSJ2 zUt?qFWD|V#cn;hDm#iT5?EfCmefkfS?jdFsqM8NHMIcwj7A|@)`S|z$ZBK-!i!@orpgG4T~KaSef@aO^?%LbDvTgCAQgs(yFl^vnMVK=Z~H$rhcYrWhchxIcWh^w z%&y2F%&y2}zyWf1C;QTOpqS@mU;65?#J7KpuAnj*R0c0<2j!m0Y$}YM?2^wPcU=Dk z;&-yw-Ug|t3AscH*eO4dhV|ct=$jupV}W-tz*`?uchrt)Qh+$S}p53 zjkBIx4(Otue&fZhjBAZcK`nWW52S%Z?JnR`#>&I zJfA%GI79L*PN6$4%-35O+t?RPZ@$jX@UwsCZQ(W*W>A^)k)_d{Ih>85`6?U3Pq9id zz3Fz-Cx^2$Do=dI(AxcY@{xa!-4#BA;xW1P7Xv6|%J+l(`0+8we~*JXKPd~cFz{{% z@t|eC;1`C;>@Ez6EYMJ!+y0MpJBsgQzx+G8cQz|0*u4Mi1P``)KAz5X4`c?&w2ONm zH*&o}O(Tydgxzmm-NGO|Tbe;>_G1r)#~?R7Zv6EDRPun!o##IpK(i6=KiD@g?sZJB z6rS`>l57YwQf591qQ#KO{}*oSW)x=cWNdV6 z4rga*4rODg6rbAP+duglJ0qwbZ0)KPdo29+U#m}0>-!JuKQ~`L!cr^Z)w=ol9|q-V zUs&FM$p7>>$mI8;Hn)^#3FvM7W$j+Apte7wJEL2pt7;b@bMiEH=D*XF1uimd{`Q=~tS!0u8Ovn$rwq!17a4@v6B(MX zfoc~}eutF2lCPA77#S9|a<#tyaQ+LZ#sH08w7UNd?{Zq=05-Tu^iNnho)-DFAP(+gUWT$!bLAZW%jbCrylzK zZF?K^Gwf^B$GEpiFVmi8J$&~ERFZ_1WjoPG)6QV!o!r$b4Os5!8M&F8#)^x%4|jveZ{L;SLqX zW$mDHs*`=`qsMdD|ASN{Py4C>F}3+BsN71P$Z7_%myrM7CHSSROX16WRq0i=s*0=n zRkl~osvNG|XSKSCO$}g^8^6k^weoPh|FFMI;{{H6nB@T8EoWdt_buwRTSJryTG@0ckyu|zRk3-`9 zhx{YV(TR))Glh8?S%jsy8I8HJ94GTAGXIqn=3U4(nOBjuIoy$%IXsd1T=yaNUDJ~@ zelcvmp3XdZHaqj=+uY0(ICwbXKVlzbz7P2%y4<^LPqw+JM)!OFZ!G1-3J zesGB=2rBV@iai#d_Fs8I6=RG9ayzX3zp@A;ODEUki6K83-D4z#*%q=u!acPA@touT z7}YnMK46fM5N7vehUHY{`Jfd3?cbtwru2zvf5kR;J$K-cIMpu9&cJeQ8l&6$5C6NF z!x@>I!xzoXnES;QSQK={YI=6z-3@A?ge>|38y~DZpF*nDP$?PtSAe}7#9?O3DXStWr z136{<{0nM@fMb^ND~oLt$jna8h?4LdTI|C?xV9Q^i{C*RhdoFIC z+^Pa~>EGv%=WO}syFW$(6pP7Bf4Jc3K;r!e|NWcU7dSA7D>B+Wxw!lB&tuPKxBvb> zc?LW4lWSm_}{UA(yg!mPnKo{rw3xp`@0!6 zl%DQv4r63w4r647_<3UAX0rtA-yA|pI#q>Ub6l5dmHvN>fyaVkA6J+VqEc*L9f%O#jGn?`US(}P8CMAc2HZ3 zlfCxYV;S@R%wdomzPa=pLvqhowq)TS0w7h(V5NgJyUgR+KmUCN&4HZu0;Tes$qcMg zDEfN8N-R0ik%On7m}8e=do)%o^A49IQ%Q5PdNLlz+^T}M#e=T z(yJX5{+#T|(?RLr**{SFc+B(T+bNhk1VOsLLEQl=rSvZ*^RNnl?1j6f>??zD`8Ni$ zj@hj249Ro9v4MO7V(;A!Nxdwf)C)<|QcwQ9D)1^4gFFHtAL}1%4pC%ij#Om&`67nFgd@58n+z;jXp35%wSQ?c6zcK8@ zp8n^8>N^!!KUne$L*sT~c27o#eo%h<^6#lDT9U>DB)`UK>{%DsN=ew{G_ zCK7`0liRKfz!rY21%vZS>eoC3XYz{xglGMKW^=}5|u;>3P#gzq*Gd!OC@}IH{ z7t`Z;v;GRRdojxh2(v9jEyHFV|M#)%)Ra!Pd#xM-m%!!MGI06zem`?KBWQk}VNolG z08;rS@R8~Lga6-kw@zT-5qSUL{)eR2M%N7-&Ec#Jppv&zv{KA&y5983p`fg z$HHmvpEk$L6Mm1%dKxJivn2MX5wSA2yJ!$)Vh26a|UI#e+U}tr<~F*`;S^@?-6_oD$S1h~QX_%tBTn|mv)cbBGqVYR?0U@l zO{!U(k>~Mcb_E_uVbEN#%pLoe?`E0JFgyG=r!M(Nw)4v%F!e}m*Fv-a*Z0<|(93v)7x%Px?SoXn=k z1IlBMh1frIvV%go(FG(2@*Ttvi&{H4-#@tja|Y)kXgdoQ=H~wwwQ@)*i!k!Ne{lc1 zj3je7xI|+IkIhM${10m5k?i197GdOh|Ka>z=IDd+r76i0+yaw%8+j&kDsl_+D)LWe zZ8^;$`Tl|Z-`bOnZh39Z;cN_(uYPBkd2sSGG4QzJA@Rvy)ff&=o_P>7S_zunQWp5e za7e6D?BJxwl4gIWNXkeuUjw!BI@y%xAN%)s)^<=!MWE5mfQeMomi;ADmup^|2@`WD z8v|$*tWxZ!*sAI4rcb^K%G=*Sd3*9QXlT6upue^`{Gj|_lgG{MAMCo7%0X-6Btd;S zCS{I~V!ZB6>B*B{Gc27i%)Wq0x`mw~IpjNoFv|iaP4{H(*A~*;+|0u4511BnB#J9@ zJ`_tn#x5kxV<_I}Bh1anj~ud$Ztq%~ud^};U;WM?c@Wfx2aVDm5*IE7g{CApG^NEr zJ^QZ=PGUbr9Vb1WY5F&+O-2&ZW(JL>Zi9y=qni#BsirOcOQtT@cdZ6Y%{M^fw`>eQ zMJvUQO>tWpPCU!90 zb<$sPWx<0yc3=K(1F00|Q52udZYVD3o*Z_ZMbtf+`B@V4@#p_1w>|$aT=t#as6E-0 zg=sSD114eC2Ik2e49v-F+oF;Kp2jpE|Mp+GL5%UQnD94{x~JQP*#(%D`=9@7Rr#8# z);77db$(LodxeJJ=5R$Wr*vh7i87#GlCsuADNv6nnUP)OQ5v&5qxkH05r#R3PPOwM zpUn1vDVguO1oLrmhF134-;>z_SdvqJGBB=4ZdYeyKK}jxU-8G%*Z(Ouurr)$pUlR< zB+Pb!iTOA?Lo&;ChGdcB46W>E_j|P{E&z#{wJ0+@VVKM&!qCc|`n%J;+3m~!`gy$pa>H+)Md`{*xY%ZQPG|V*p8V6Cm(_iuJ18wpZadBhYR|B$KmK|1pYoDjY+;R&>7d-UuLqRZCi5&{n%&OBVE16^E>NgGW@CQ_iJ!&&&;LE8@tkU z*W6_}thu22+;D+#tSm!v`yT0wJhwn~>x25q$qoyoZndVhzJIWP(qqR3 z|1PyfwL$py??LtICXn0*{SCWW<}#ez4l0iyPiNn^bxWgL{s;a~i_-s^yKdeiq0~N^ zbs>l50JW}BL{=xjF9xkQU_YdTon8O)` znZp!Cnd20Nh26jZcM^A;tSs?RXfx|MhfQtCaT{1pwNByMBgA|aG*;iqsyu(`zsIw_ z{ZkfUl$gTBBL$jMVr2l;kI(*fvO;CVB&1HYYcQjxiRJ&A!xTj~vmSF)7GV@IYfElq z)!6oCGW&;b$!ET@G^%n)y?^lj@w2p5t$T!aFfoUM+{GxG%y(3W(NCCFQ55W_IMB?3 zG21amW43FK!f|Yj$`g+>2-nFmREj^Iu>2pZ8>9u@!S(*Z|L#StAlm=v+ue`Sl{py2 zyjqkOursXOxu`ut2r;(yaQC8eQ0l&W9-NEjf^(6;g&I&Ua@+%IYvq6F{|YLjg+Zg| zW#73bvkNe{sx0pR_OEvftD17dF@}|UASH<8g2z4Amw{S6pm_mA2~xQSWCPgz`B3xA zK<2aV>EYy%wEOb@!TVhx+1Asb77_oaMdgo$S?4@pw`s;2l|gErh{^G zqmVFXqku4%qM&g1^Z%211O7ILHww+|zW9EIBxXyj1Jn)^c>kb(L5Jk~2l@*b-A=Xn zwS&gAK|R@@VwK|Srf-@q3>q1o_>F#?x=|K@N-e&%pT{$6!u$&Y-D=RrFA=fFf; z!J?(#o5LFgTAzbNlM{b4DYeg$L`^a3pw^bqUz5iZw|wW31f|#h6`*p7eK(|yod4nc z`9;uv^J8iD1H$ZzLXT%Y{|6V7WWN9tySopf6V|@Y|FHh_4Xzj|=Bw-s&7q(+9w&RU zz*d&YtP4dRPuuBzFl+0=_YM=p zlHV+4X>#S=x7Z?kgD|oeD$J)S z+E=eAbv`7xFQpyE2wP(YL`g9mf@JprpN@z50cM8BLkeSj|xC5CRtsd?iXfd6=-S@ zZe>h|k zs?lr&t(E`I&cWz8^|UY-0}I4N1wN38jh?Yzg}<{aX#W2=d-8L224VIRc903J?h+3q z-pE|&+zxU_qvzWF&7vxdYOU`b3UnEtf^>TB2dxwV=@JK@4h33Mymx zv}O#pR%~)hDdS}J2TWR>$uFj}fKC8OezsliJwpNWWEKXd$?OcQf^MKSnV?me=cYG+ zS|9(D*`CPBq=@7QWPF^xX!?wFk#`ebfmV5Vwa$3{p5Z~gFe?jV?V|1M3=IcofYMX) z+vyU?ueV6NXJDwC%w8a${B^q37d}Yddov z8{E!m4QU6(k{jD3{<<12NRDLJV8}`CY7>)5`8eCSeY(Tr>rekNZ{cJz|G~&0%)xO@ zt1VfWMZ9@?CxdjjnnSDW=BZB^l7DTNV&1~Z*lg9pF!|T1|H;p1F>G$1z2WF8B*H-gxIzp2PPp120G!WY+yHr2$YhK77jwa2sC zA0UVEV@8(OGAV!EATf}9{F#*U7EWg64V=u$@$6i}>>uQlGrsfnHiOoNfyyC1cIK^} z41Uvjl4nELonB`+**}?${lCZ?o)^kneljpTZg`7`ug9;pKQaFPm4Wen8*AY#5KB-^ z@Oc|6gq3>#uZJ|V7=yI1Fasa6qp;s(saBa>qrPOOuY5Do?ONvK7tY?yHr*ll;0?aV z$JqWUO&3WQ$na_fjU0$P2dx8r&#)jAltwkTPiA9q5N2aw5oZ0sT)7#Pmc3d*DH)WG z6M{i%?rs%+F2W%3WYHAm9Wxm~V+~%dbDq3sXb1$!KHLh*1z&dxU!Tq}(JlGYGro&% z$&a2%&1OB$I(w=p!)&(gtbMHKrp`z_D4N{;R752GmR$xlTXc%Fd#v}lU*mYGb-8)h<1elEtKyoZHRc?S#QoF_`ty;?;czh`K01G!gm z@8oA93?d-kz*MJ+!&OgtvS_+j>x{?m85TH$RKMLUe9eSmHald*g;A}K{q8>D>*)-$ zS*J5YeAmw0$I81snbm|Jl)sp*S{Q_@PW|7^KFc9FbrwUd`(vl?Z$P__7T7Vm7VegA zJI)I6&34v4Hp`vO=FE(>X32BX#U_`VF*pi8{ms0+lVS4lum6AcgHlBs>*J@}k34Q> zJpzt-SPIZfypp-TH8f3jKC{=;<)o$I)?ajEEyTI|1^yJ&#%#ghG zAoy=Mqx)mwucvA^P6n;>eesM<`1)~%*{t8$AijCd*2g+=uQ0oVXmZAPw#nDOFi5wx zvqM~5&fdqibsH$pgYx6_$=6jFrQ5DU z?L5xj$M$rOqfF8)&}<*0``vw$Sy>ppTHjwdKMQ0Z$R(gKX9f8uH2Lu}CgJPqjI&v< zL(M+U-p3lac`_Sl4erK?`vgb-p9(s zyt$Q$c?T=A$n!0U$_C#Vl`Wn#D%)IVR5m!ytZb6bq-?>?Ec0KOy`5z<`!fe+o9q83 zx3;o8KK<#}-tEoDKsHP+FK1ZHfBj!8>%!~kB0v9&?oa--lxcJOQHJEYuMEcQM;T&I zfp%;D6|WTs?Z|#S>+8R!hQIE~505i}=J&t-cRkd~wr?8qaaM*_kn2Gs4zoZpvN;_T zUTfb^=3x6b`3J|p$sHU_#vG!IdhM&)MUsWt*_kG{vok4gxc;x%to@(z77)$;UwH?J zZvU^m=lZ|LvOoR^m$xwsne5 z3r{y;*fqT)nfItf;*7`27OV`A9UqWWUWM5NSQfgzH~5gG@n=B(9WA9o{q^% zA3*B|*}eol(Cb{)Y1Sg#(aPB9Q7hc6&cPta(W+tmJ)Oat{W#O?YwV1>+m12qW^ZSZ zzRu3Lx%@N3&Uw<)*%)`uSJwOSPx=ZQO?j>boReTI#<0*fu7u&P|RyUCnM>44Q6Ut+U(M{=WZk{}n6O zs@BJ1UH=|hHAzjr#l>XI63v)=btcnalie*Qj*wN-i>5TYu^{QHf6mGR(lzDZqXMTA zGsFjINB&K|AvtUCr4U{@3<{c*5SDhgn^l8YWL;XFfQI(RJsk$=|;7uRJvQ+joY!$0mO>XXpg$ zXnX}y%c|P=9BSg>riR(q)fqshajL%kb$0vg>+TF7^@6Gof8E_a`+7SA$P7i*tN%be zc1Do7j;=?)fq3c+GKV=`n;H~uJLA`W!}+T7rN!78FZL_1 z`}A*i2s`8B_xpcsW`E4sau{Sf$i~N=Oh1^_m>Fg@f9v1W!sy<-oS$L#O%}$|zOVhe z+rycfmpC&_WS+=x{PPOK?sjv=o%5xqvol8aDX%;HkNNuh|Ff^NGg`BUGg-5%gXG%S z!KK9Gw-9?K90vL3arTMN$*v6ymJ4c4IFB?hKk@&g#NXSC3LH){LHD#mcHnJppXxAI z{Nrrles_kiTajb$f+!^RF7Sa?KZD{4w1*ee5;AI8)v4FH^)+XU;*sVpoa`qLOfDB; z=zPuE!g{77!SLX!77+jKZMC*j;8EQB50jZVSzzT0YYS=#qt#gmUOfgXuVAH>TH7+P zPWyWu50nj98CJE_ZrAE`-Tv1cbaoT_<1Y4H(Hbz%&}eb}qE#)D zCnvKDsLPxMmnAz^vVnB>qU2>*stjPXEcE)oywa8Nj%(PH*->E*)}306pfb$wP0)*| z2W)?4vq&=NwHS5vxUT9Hjt+B3zCIm1w+AY>rvC%k7(YAnBxt8Wa%cjxbo;OWlf~JY zgs(qmEM(W3zO8*CyYf2Fn$YL}CQs*LntbayK7~=xE&0U{ zhRy9Aka%lzXV^4t#v#GOYMl};&D%TKm90EIGSFTXYCPlt6aMlH#LoFbr8 z%OA1|v$rvBZokT41~To}S0UzQ$Nx909smDPybx?!a{4ua9+&qY=C>qsvI;RTc42JR zcVT?UA}puOAk5Li*u@W84Sz6CSwodkZQh~zdTna`jUIpHnAQ0in$y;c03No2G2;JIav!?Fj3^)Uvi^ zZGS~)I0>>%WZPW6odIO4^bK}LkZsoN?2OV9?2K>wL3^j$-#iE5 zx^w@H+s`pheBP{n{C}-+q4?ALpb}SEE0qDZi+5Q&tLLH?yOzIOAA58DWAwbcwbAwc zhx4CAkAhT!Q@su=Ts3lBGN?e}@<1T6sDd&?G$G(JJL@BJ_7C-qZjFqhVASe47;yicW87&RVCei?B7rK zR=4D1&l$F}F*NMH_Kcy?9aRmeRpjES^g)=Vm9dLu(G;&2%qx%l_j?lbz^ip#C)=0z zAL=_n<2}~x%N>*#ykyXH7w$UpKRI?en>1VK|KuVUR_5g`{}m7IZaeOwd6?# zkNVYjOv^#7~K`$!Bm4( zfm%(ClbOUBCpU@T?1$|9XUYQk8?>@@ty||jbM_DRyTflX-0W`>XLL_4b72Iz0c2vR zsY=6|g_`L~cVSQxO`ToQE zYq4i1hqE}%zUj_5`RC92P2#IsHcn1%b_ax*Rw$ z=ZrKfD^qe4C)@1Kn|pS5u4E8q31C)Muwt}kUE%<0*(fWlWO$UxROytZ*1D(!)UwfF zP&)Gd1OLxW?wUszxe2o~FmcYep8lM{`r2}a&Cj1P%sFFpY&JU^gR#j623D3kXAYcr zJc;v{H0#qnlf_jSloeJnESrA9TUsQ9;r)m6??Lt??pJc3apoXOiLt-{nx3>l@w=`? zhk@-2sNJj8`Tm3a!yE>+R*AKI}7o@{Qp#JIg0fJO#6}e*(o&@Ym;3pxBul#tv4! zyZxI3M15(0Z2!sqcioe3FK1xi%2?dKy|K8~G`RGuQ10KRhOg;-tdrZ>udJHhq1@CE z;`P^b_SH~_R@KSuZH!%PU99`2t(uzr@j8=MJGe|{7i3q~1NGjn|J&St3|#U~WVf4| zT)ve-kX2ca_21*%t^b-DB0Pn!g*t$1gxKQ@Tol~K^^1=|~~PS8mUb5F;(Nwik(3wEZOTj)8y}8`87eOJ}}8734i^{FWfH9An{1KVLPbr0=}KX=!xEg_Xqs@ zmC~A04{m>y0IFF*dyfms7zMo^Fz;+Eg_OsjvsIE=IT@POIazzp$GCuPIs&#SB-s;W z(-)9UEzg-`5`@2gf!OpwxnVlUrW9DI9jGmA^B*!`9!&StK$*=}&pXYbJ>t z@psc{kV9xQOeqCE~3_GiF#&-rrjbwHX7LeHH zudIxW9-VL7w=1eLVE@*x#ZT zMPHC+qX6z4(uj1 z$RnEsx&;g}6UX-Cy+HzdvL`D;Ova*wRnuc$KyLm5&EM6Q*NXq_Uj&{tgouJ_3(#pj zpgtPtR1(lhOTypT1@u~0wHS47>y&*A(F2+f1kDsOl`JYa*XGr>DAOrZt@TlgYhu2_ z1Xa)sU?=Fl289jf&EhPKAGf2pMZ+J5AR|b$9Sko6J-0b&w0X7YMCmBc-Vhgg% zKxXDE7+Ar^0719%%t)*a1NEb~O~2WHwLf{zaW<{C+6ak9Gg23_DuUYS3=o;e?d;&O zQ0C*J49&+>8I&2mG0Z)^nBf@%>*?m>rVPrA*BIs=Vm|K5u$b{1!^HE=$3q#EnVvCl zo@PFt%CMN}8$;u9W#(rLobQ_&R<$FKOP2m_YS3y6-M*NajiIRl;x?`JjnC)0Cx1E4 z!n~QWsCh?Yk*wd8#Lew#48kYA{oni@)H@JoY<({BI8jWIeIe`Pq;vmTStqlD&K+w$ z_VvFo$G88B`>+3NJZ0DJ)CQ4B{npfAG(DMvgQ1muaX+LN2pWGBhTRDSy7>ooCr}s4 zoj{=5f^ggkw5s#{gZGo5cLGh&|JWSP#R$3;2y~{|sxO_#o6WlzA2+c_fp6@g>^7gi z=QmuZU~5aN9GoIc-5I5U!Ec>*3!VCRG1($m9@a!XGl32Ia0=n=dPYZWt^aMwLvHLy*Jp9(FD1xhk?LdJ%@?7tLO5u zD-id;R}ipE7J}T>!@3)EO8Mhi>@484!@>-@tEZnm$VpN-l9O2$d{@uoX|S7oz_K0e zLDG_(jM9;uj;GomUt&kOtH+pA0diN5An2~1$34$)aJnbAJvRcK*nh8QayjCz9^pvn zT|Hu)|G;T#=z9sRVp785Euu^0}W#n5>4GKC%`Eh(hH?muZzpV%4miGz|N=Uq|rv>H; zheG&mJ|Ds-zzLgvHS`O%lr@e-{9%2gM;ND(Kqsd-0Ak? zy#hnRV+RhEbG3uPV-eN^pnS9vTKkGHKyKC12h~GJ zx9sR|1liqQYWF2@`(#!I7C+EBsSC;ms~D7RRxvzgW_1Fs9a2{K#gzX+e+hD$f!(F^ zbm>9sd3BN0O(opUD64el5mr9ju`bKJ)&UA5s~_(b z7Kl6+XI(<{Z5?$m_keEe0JV^kyV->xsqW@xSZYY%e=N&750n}tw@>CiC?WhE1d!mX2J-|H;NqHIDW z-R9$WJ;0F}=Pfs($EW0f$UguL69I#|$HJ_Adf>ZBBKLz^n&5VSau2%@q>PB%xUARe zMgE8Nb76WuR6Ukt?E-~k{)hZGpu1)eHvygRg{U(7@m`>y;;|@e2l~AzCwIeIZ0`*Y z=qDv7yRfE!T8iL1Y@(Ojg6>}EK)Wl57jjq76!sbU5B~p!-f;D#-L^0zt}_pE!_|ZP zzai~6ymtUOTz7aJ%=QlHUI*5L(0d(xmpa-c-|x=EeXj#3ZN3)}0NwWTYf?Gn){u|e zTaj)q>R%4N2dJIhM7Z)N|Hf@#UMss9h?oB%zYomsVmFbN>|~UV>~uWUp8w%|8~C=N zCUzr`DoBZ(-y=-;hAq!_QzOh9wj4S6K>gfg?!PH`Z`k^U>xM1RspwK4-XA#M0J;mS zfCYTR7Wa2ItT$|Nf7jE4->`M66@0^%f-n##n=;epNruBcV&z3zs@cm1^ z-&vBq->@`+?q72F?gFtD$Nftos5XM`oB-V)vMxQjiQNpes~XgYVf10u%zsdS74Ka< zolj+y@!i35`MTR=^6udIbUjj-ygPVeuREwg@8E&?6LJR+D11S8@GwH};9=aqDLwfp zI}bcx20-udDqgw~l;1()V#qh2$htc+CkJ1D1j+mF1uj@5OR%1Rlo0$6K{=YE$aW)4 z_JdinB)jsmEpYc=qVFu^noe=gM0&o1oA)F4DuiRKM9LB+5Ir_3wp^CtouNv9wZk(j$~W&bsOmZA8`Nofc-`A z{XYz>PFimYcS`!?Kd8SCyIDzhE2y^_*9uGR2L9mtfOuKYA?^b@x)X9AQ0&G>y}fR( z8&5&*=rIr|Tp{@WLH_gi1_mkMdruSuvOuPR?>$kN;DvhcNqZ>~_W>ywxIZe#avzXF zK??XjAOit^X--z~dFB(sk?sRBU~pZQ4!RHM6gl?+DO~VmDo*xWAn*wJJ|KkxJJ5YV z!j+N?$pV}LZUpWFdb$mKA5dNUeyg7R5Bd8+sSR;QPyKxOeLxf0cfBhM-3N=k4?@Y3 ztc#Fu1IqvK{s%0UQ+L7C6$m7YvMzw#2XuZ9$b8s+KuPfXfZ{jjKiEG5rpJIcS(U}`(_kdGy@zzbKclSK@d9VfZ?jGq*c7~7JUQu|*&QGK}c24eH)|>x8ei_#LfTFKA zz}#NIm@Esrp%0R#^FO@*4=yL3f%c6n34G`qhC6zVJY z;Jd#kche!f_wn$5ocNs86LPzc;TBwX`+)5Ey9so2PwW=(=>2ohO*Ow5@*mVUZ**5) z@RI=&X7$a@%a3x!7KXjq+6-A=0XfqXbe3mp_ol9chh?&ut=SkrYt3t;_8xCG>1JRy z;b!P;nBC37kQ`CK`qyOgbQY$`SDrJ1&VAfBMRGxMcMB7b1E_v}FYrK)QB{!TvAFC1 z+ECC62IU=G49ZKm7*N+3fL1XyZ|7p{;@;d|?x?)u7lR}B&EJf!KexYM&_Dm-c8M&> z!}%ZPe^pjtV*t%nx)%C<4}1UaTif$RkJbKr{SNvZ^*Zi((&K0UUi~tAvZ`xc=cZo9 zqc)z&t?W+B(>WPC(;#Qb8h^XaAo_@T*-5U=>DR$K7%R(XUuSo$6))^pp7E36kht=) zms|%Y3x98CNakhNVBX%zn9Rwp@v>XfJ-P9@*4Oj~!O89HY^B+ynTtL&{b;(P)XwyR z=}*&>rUy(9?A{1-bIS^Ia>_Ly=VeH4VwZW>GMO!aDY^5yUh{DghE|rpzpcBrI3}}l zNi7RMR;FyQol&|?oZ-?mWfOPCZ9g_$nd|Pzo_yyx!{ZJ%wh02~Kz`E4CmA6rSGV21S*=_9q zK(_=ZC!b;wp2o&BIqVr@Qrf0zQ=FRG8eN!=@iNSwroymv-t2bvzo3(4q*>Yi?ryox z(8>#1zxDXT>VGg39v7ba^Y^qe&qp?pU9H}%Ucx+$?2SH?i*y;1o0%9owU>oWuJ`3Q zRt~y_Yg23TG=7HNeI<^`{uff4T?<)fo}J8A$lA&-^0?Ja2#eR%)j{#D(#%fgP8H`Ob(gKPnvuaMlf-)(n~ zk7Kgm1piCZl?~b%LE#8B|Kc&H;IU<0(8MX1zvF8hseOgn16~K5I|D?8A7e zz1gjh6?6mG<4(30v%AF^GPi=$#f1DzkA+wTKyK4?f7$(b^7CuW(={0%pJ%@!m$E2r zUjoRDQdJ1|<+Yt_-B!D+GOYDiR%K#7!v_IO*L^(Syqk?-a@pVgjcP_u8r>P)7IPnD zsSQi+J;Nsa`P+ApUy`SAyCqNKsaW`5_?H+1$fb|DxxRqP?!~+xd4zd3^3L22O68B` zxh{ZG?8M!Z%Xt}-r?6*%LxH7vH5)^64|~<@+1!k?Z*x1|Ykz#3{hiSh(CID^+dzBT zUbVHlKc0T(2di6h!*K^rx8$DVD#Ba`d4qZ;f3Iek4DRLr`8WBtHA7Nct<2+T-2Wzj z6=O*5WL25W%D|l5x?QDGY%%|yf7V>59L#!+dVKeST``wE0m&6j>_vy9LFYzVZht@F z|AL$Q7NvtyIP)HMhRJQ95`ZV?Z+LRYpR}~LM%ScPvkz8J-XEx+t(4wWmdwRkX3f>= zX!fMhXXf5TX&`;A-gBH5vY9;rf&pO{vF6U)Qp1__ZT+FM`l%CARoTuFIjbZM-rt~?FTK7$6+W@v_ zG51B5pZkQ9c{yOV9^40FO>UEANN(MpBi+XScUy0x&*O)u_khG_Pt#%8-8PL8R6^|T zImQ5zZ{>ab`Sd^6ZDFleAKoAE?*q-j?0fLOp#ROP_OMpFo_$Z=A9&v*lF3vKGQsT6 zV|Jcxk6YQcfzE|^+{m^~IGNW0l#*ud6Hbg4ZiOu}ug49OkrM$Nlf8CuDU6Qv0Kim%d*5q15ikes$lgHb|OsN}K%sH$$z=rs<%0qRF?t8I&3RFg%{h z{m+`K%h9ZN>P}F3_BiUo&V#PWx35NmW-S<3NVlpnII^#6J7||2c%OB4s~7|5ZdY|i zWs~QO`+lsu^7z93e}4}{N}#e2??24%d@RkntEp~Tn4|weJ5XsP-73Z~*Z;Be{lDL) zD;t1xUT56*W7UCpY=di0VyBD%13$WWI_cBTC;n?@F(|zApRyU<~P@MoO z-&wb?y1i<9JmvU-rS8e^%Oz)bb2BgIE#x)p1?8-byl1yKx+Vu+We3fN2(Fk7j)_g6 zm|U$04pO`vG;|hsQ#!iw?nK1ma3i$jxWYm?p7=+^40)Lyu~=?b`3;b7(f*D4_noJ#En-PFR8@4A_S z=Gz!o%w_|{j9#0gRq|aQ=Gm-}lmapt6vm*K+4FB9)NSuS@IQYn&N@Ra%+U%IFSFUi z7#<(@`3tJyKswwR_x;#*Mb`as@bxJZ;jwxC@nc!mDaXoLceT1Px+%3s?q3G3+3vM7 zrSF_?_ds{k<3{!i5Z}N5@czMLG1f_HVIcEa)h=!T)pz+H_K+M$(h~59>cbde z085jtZc6QYHyb@!yL(Y8XdINS#O%f7GEiOK%CPVlsBD>BCd<%yF1d%BK{#2L0kj%G zndc(QVxEuSG6`0fcDje|c-1y{8^n~hQiLg2|4lCAWo$jPC=FEi`tDC^wfbQ8V z=}hI)T&xU@KKUQ=|1V0NT*eEIlY^%qF_O6bRh!Y1vm0C8l6$W6b-F$7y1waE+s7Tk z$-D~9$7LBnC1NXY{s;a0kU9n-!hdh3yL1;1L-M=ntc7`(y3L*l^YE4Df8c*S`8%7! z-qVwR|Kc<|AGG} zgaxtn{0|5(b}J-C-+y?&HUGo;=V@J_+BW|~|2t5gIJ)yy+uLn_!|fh`>@#Yu-81J< z{)he(Mo%v8Q%aL@66R@Ruq-|L++E_1Zyu3^uiDwV1V8wL(|s3Ve_xyfT-0dt*tn zdAt0^!!z7#J(8VXu(2K$mM~|qo1tuRLZEpCyCJKawb(O;%`Z+cD6bGVRJORG(CL=U zaFuB?n>s@u8>{+^?hGcd@#7f`S%%$UsHQ6|jM zQFeE`qu{1CMmM%6??2rCy?OglCPzWGCrS@Cw;pBM`u_cf_(@tVibt8vTK@~PH?S1W zN)$^@I?ghgt$=A&d-A7aOv(nV49X^~44@VB$$yVCfp(!Q+kp72OvxP2Sd=%gGbnFi zXHee3&afy!sTH#Jx6$=|!u{#1d1sO!d&(_9L(9M*fn}O7xcs=Mm30iLqO65zz_kwo52JJ>;^jwtU)e6~1 zzX)_LQiJ_`n+&baiN|>=)LNUSC;PCnfYLH(_3Fa+Iys12Sk+qJH_ZPAx<68RxTgB9tl3_s5TO0>ecH!IUwElKl*N8 z)e2gvo&Vwfm)JsK=0+y7FSFX%-dO#x`*Y~Qu_sbb-an}S_9y`~o}twj3trVN%*@DS z^ug?lUfZm;PpznG_kV_{1>L6N_a*8@+Y`{8DxiD3w7S=I8nwJ(ifGYEhG$*;`vkb%|Ha>Zme7cRdx9fqjZ_W}vrf5WvplUcvAsUBo@Z)9k6 zsf}9cWw=5nVRD-|gUAErhUW~eEH(_wrYC<;VFjJ<7~}HSJm$#b3+(?yLUy$(wMDfi zAGyx(SR(xI`w#Xz9!t6Yg^b!DkJfiq3`>-=G zs~_X)OuO3OnHJiwEb)y&S?w8D{)hb^K`DiKOJgb98@;wwt&#_9JmwxJqz`oeDCh>+ z{15xzYCTYDHG1;CLH-zMPtwipu<}8xWm7AnbXed@IQ4;CqV@!7wZA}v8!@^dsg?H- zC?B^f8?}OBX@Tn36v3Cmtt`rr^aR=$@HOS={>iN@%1WSno0Us1eoUR*+FAzU9Z;&g z$>@4>Kl4$>TtxcsJ*d|LF%zVwK>@#s4RXjPE|7(o2n!AL(z3yZu+N&eH>NhV&pau6 zZ0f0IcQ%GO2bo>j7>rF9Ff=td3g$3yo@+gXD(=V#-Dl={cYkGQQ$uCwUwC|=yFkI5 zunR!@_?dUIGAMlj-I4{`!wD)6lDRpVK({d_H*+#E@8V=g=H_B(HsxZNdGP%Q`M=SqE?0kP>$cfsrJX38b!{>B9{Nb{Ecf08o?!r{6^+2E%JNuBILHLrUv8mtqgyIWxIV}PY-8cXx{$3Mj&xY;^v}n493ad81_xt{3wYbd1et; zvfMQ$fz&CfXfm^kIFbdgF$rW&$wZTxT*Q&c`jGW8=e1wL;%v;5r?W99OMGV%7H4Cc zJe`dxSqRK#oIIV4FzqWb?sYAUUW_hQop!C72a?O4ut>AB zFj#f&>b7gW)aupte#8G6S6t>KFmLB#+})<;cxw8UBXb@YvxCNzUophZGG-}ptUP|h z#je$=GxGx|H8F4LWH`v_x}W(v3*&5V7KX`X>>hV-O$g}80iB4nab9n~^v!RKpz$|r z&YKLA+oTz!BPAUcO-nAl$GjrRO|Z<`ZKh83{Upt#I?QOaKEwn zItwHGPRJQw7>rqK7%>yD!2f0`xoYjI`oG2>#U5dg?|6T zzQ6m|_I}apWzSDN4*DJSIqrSZ>$K-tk3qGY*^70ZtGYJzHXfgo`?#B3=xdrV7bE}V zHaC^h?5`=8elR_3y2I#xsh#Of(}SiLO;4Dfn0*lD=C+>P!eY~WjF%y~k4-GEMHn>B z-Ed5!*-eCjmF4d*YtAi>$&8$0&%(T>D{laebBi%3Z&7EodbsJ%T(^Vl$p??ADW!o< zRk3DMV>Eh_+|4Eg(mR<~gkdo=Bir8?M$m{hCv-$xO_+57lXM%~zuBy849UqmStg6J zF$rIL%Ggw@H%-8asg2R4`6w@gw3rHm;ylpFF4CYg_BvSqTDKenjcB*AGCcmk{U2t+ z?Yb=UsO9=r|^OOz;Jb zaDc+4oe?EW4j&5=t^oyC&@DG0iZB%x^t=h z@ievuO{<2Tc##3#eum`Wc zV_FO@(=TOJ(g#E!Tn3AD%pcEeaeS;J$WpBU=unw=KFKEIXGi z3`w?uEdxG^-S+qf+Z&@7;8AR_U%{i;eXVYfXPo)K>h`$l*c(o_Bym}^o zt7e$o#>Tvu{|?$Hwj4up6RQ$<6uWPm0(2Cc^Q1#ruTjs@y@%33DVBK;8-s918$&V^ zPu$OkP&L9A9i1?UcBF+ztJguQMpq^G7oEtHD{}%(~Cx*(7jGzy{+CNPKsgu6oZW%ikpS=csXF<=($rkkCzF?3*6|G_ONX7F}CK(dAbbBA{W^Tb3r%nnZ20I z##>_c20SLM*Xd@tcXA#tW24@o)XCrYAZe+Q%?gwXTHTCZFm45zCkz^6Zd?{OyOr(l zCeRr3i`|Dn;?mP}7_8Z*F@o~!Zk}xnAbHRj^X`9^8^NK?G$C;ztKN&&N1!<9duqZ8=kuO4-;Tpr#eT&jW9_`%*GEo>bUfgud3zjl#_d!G(*peH-qAZ{k zn7ZvyT7#2tPaDHyPnKIC6-h4w_l31ueX;xTe!=|(;BoCI?*rujuWAcxHS5{-;{Ag9 z`2v|r<%h~QJxFHeF$3v&%*eKl*^Q0iF)!N|;XKgDHXp;zZNho7@RZrO4U~StYNgpW z39~UUfpUZHHet}1{4rhz5YKQQt6OsCF)vQHSACD?AG-rdB}r+Mzk$c4!DlK%#-;B- z#-%ws9m{%;ZrsgR;`li9!fr>mvV*z@z>VCY|a1oSdMiAMEy;;TloJz76yr4YX1lqJOBH! zBevEt7BQfI|;r2P8BOvOf;F19jv359{APmSA1rXbCdoQv2gm zI)7nx3CLH_`qlmM)#Gy@w!Z(+|LUm081*jHUCJmy;V_i=UIRl7gO(wC+FdIKBVE&E~h<^6&6 zXWG(Nx`E7VJ}S=+Sa{v(;@IE zY3!y$X+|%ace63Hx`l3XN-aziW@9TcdLvxM%QTs_l|k`Xvo$M&aG5LvCuC$cPnSWM zje%L2vyJL$dXbnD&ps&C;oh$(HQ2vb7;377FQY94Y*1C?^1ky*PR zR$rW6ybt)l7gPp-)+;soY}^G}hy8v*{tx91D;bpctYk>$X9eBs$)ddACukM+Yo}CU z(AcduD}(JhNchg({;JRDh3gJTNedd8y!d&oZEGP~WH-OYkJO>(`?cE_< z#;d@148*>>6*9v5b1#I>|4`owVS#kzf3R=8*Ovd`{QpI1$^zFI@;|J92un@tkAg;P z(>g&lO7DhOefb~s|BHaeUGIa}lYHR+aVT|)qi|0v!?up(%WMpPBS5~H-NV6<^kP$Q z{)ha>pw%b8AgfP4=zoQbao7zkX_=Cz7XhC7Dl(OR*>jp@vr}s z7qBo)W?#Uus6gfb=nOKDJlu>ejin%Sj9LWG>a{IuTh$8ccl`}d=Kl&k%Mhe`Q(IRn zqZ>r#vFO)-$_gxCS&*r74uJNuH#LAvX=|}OU0nj*|BI{$>um2cb7bQSO;c7$g?uYeB|GKYgNq)bbf!Vw@P_ISwFdvK3bdF?! z$A}OCv2MD{9DI~g8w&Ch$R?vF?-%G_P~Nj7K&xHyq*5B_Oifk+&`91w_Q!L-{mTX4 z+Y7si8*Imu?Q9_T>a|QgES51j9@lM9CT+e=&aA}93Wpo#$MRofcp2W z=O>GsFxX9(N$x%TH!Qj5I!mita`SZ-rB-DFc7`StyCJ4RYykQB{Q~}j5Fd*kMD_3W zf4SQss(Ha~;B*D~KXyMj-UQX2fJSltx;JlWEKPpAoUM6#OQ2Ru?{Q&qNGPy^LV*z+ z3T)Szu!li{6lxf(Tm`c4ru&=&tgfIiX=(uR5n(Xr04NMV=jMRyR(tZ-9dv$9@}uQU zS}n|`oq_9GM33^ZY-Vp|=typP4ABc2^#rkRx`R$k2c3sg8wv_vkng=(-!I_bsBE(` zK=9>GC9Mx_r35 zHuUCxL|Ord)9dAI%;0cBi?LpCjI|IKV`{DM7o1;;E6!5U;w*K4ZD{Cz*r*oD7#{-z zAK?)t#}$wf^vN6(n2Q-07_?fF-B}qJRbjdA{e%D0K|KkEgSDYww@>D{zzR~8?99r* zxBwJ(S}kl(K=SV&)K6tN$hg3?Q0*z(+jT8UFDG*_uy(bARBN>)`>`@ev#>IN?8JX7|Wn|vW%GA7rm6>@5E6aq~EvY+l_mnCNlrks_hB7ECePvV@dCI6PdX-UG z>?otMcq)Ukg(#!41uLt;Q<1k4UuFI_HE4BwR##w9Or3m#mAO{*Z}`Dx;md5yn}4ie zF#i6P!MJ!a!`J@56aP+1p0R?#IF+4|_hGWUFtg->WVyvm#!rtkh@M=S_E#)<{tX7> z40gt3ZVm?9$%cnPcb>AkCQCnNi0xxMwRiI5cqd~&Z`WMr*ZrPoxx~q`hWp4TI%RttRT*Ca{nrb`;u#g|Aq_SU}ZkoEDRc9tH@w5 z{`ZwZ`07{Yul>g5=?s4-B}-;7Y)+M9Tzj-QL4pA^(wZ!q&anCEafYWqlVv$rKys6} ziZbxNHhz4ZAz6%>sr4Z*xQ40?oqNozwW;Cp%j5r(h5s=VUTtc4ocHhF+3k;+*nii4Zgh1e+m)d6U+L#c*}_FH!oDQEXnO;? z{{eLO1L)?5v?p3EMm^iQiZvA&6w@bPXJxJxpFES5@n=7y=H#24jKa6SGEY4Y8rw^5 zdCt+tDI9*4**M*t@ndzX=Q+t%?#-FzjKWf;4Ets``ZT(1U19ucB||b3mrimMCurZD zzygKY?5qrv+rf zeUy81_iqQ+{qF@1$joMEWjVQBn%(@*X2~ZEj9zEAgKc2tQk#6`C)4C3A`Gn^lUTI6 zdVLnA318!4{wpRtg^RJY?@_yB!{l4Pn3I{=RKRBv@?6v4V-XI&!|d44>f$F7*;81~ z%05}#hQVlhqsL~paz^3lIt<3?;*2X@joqRdg*(I;k`F%B>2ys#{8Xb>ywx@N-&2j+ zaK_1-n>`tg``Z~NhjK9qUu9?7yx*B|v(bMBT5UsZ+PS6$#JYqwY{5v{9s@boqUU#Y1cfrslws>Oq+jv zX4qW*pJ8*WIP>QAUrd|3UNIT7i!*QL_|71Fot4RLdUEM^usQo?fy@z(VrQ!D|J%zX zKKTYGliu{rKYubz4rO6_*l*nZlgYSc2h-;EA54=YxS2M$nlkU3x^71D*B@a0c2g!_ zO3nK>!`P&mVbKg@<2(jq{^bsv?VmF?iO-s0%zV#rvr!(yt?9kEBm~Zy8HVCHIiaSkDj(H$8`CBB^Cp1rVO>WsHFuBd0Ve|HH40cntwLe|a=-KGq>SMdP(X-P>b@S%*9)_*QMbCg{ zohB4Bs!nDX{XZF;p4l0aPksZZ=h^I#^lU8hg~2%d4MSwlX7N7^h2^g7oc)!%lUm<1 ze8`t(Wo5YtPR+(5Zx|Zg&u-tG*26II+~lw?Os!qL9*^g+T|4N~yPMIa(Vfw~)nn;q z5UbOpb#tq$@${z*!lmrNyl;hz*;SHdn3aUf+c_SyvtJ8q<8)8%dZEPYp4{_7iPin_ z^*>Q+y5DS;xb@oXS(F31J*3k;ndv7} zulrxIWcHs7$zq%gjIL(wiVJe@)rRV|Pks`@u&T9md+9AkSK;<=|Bvo(b<=!4`D;1D zqPE_%ovz?`zd5ClPOt*lWFqT?+k*j$^Avd}Glk48}LM zGZ;^Q&S0F%%4lrJ`-`*Nji0tN2%d$yj2RTN$vi(9SY4BaIT=J|6O5C?t}*wqZvJtCu~EgT z&-qsw&bZN7>%DFV~~6->@3V+%`V}nm^Yi1onbQHzyHZn%GSxD8w8Rka&T;Z zdW>P>+hnmDrN+;fGbD4dR|sEMXBKuBXJG9XVrN`6oAvwug%7o+?VGmQd>O;G=|-)> z*Ugz(yOVj@3l!5?Sthf6|DVio#iTaePrO$AXTNZ`C z-Czcr&dpwgY&z$n$E-L0v%33<-|PdY6u0ecpp=sAy`4#zgMr1GV~2zBbT-D#5!)Dy zCD<52HHEPS10$&2via&Z2CeD)rfxQ0&aiH}RqNXA((TYxaQztrqepUwD5Ee30|(fQ z8ElNk87CNEdK+DDZU==8C}mvTpWMnSkSxc+w)yFDhTgZyQ*NXhKRw2f%*dJ{d|eG5 z65HC1THRVEmz6RkPhwL_?qn64Tqe$t+{z{(3dCTaPlBO$Xb`ew-n5`)pSBKf=rm zESs-x2ZaPjIs+smUN{)fU}rSWSOM3~=zeiK$lseyH!xh?FU%srAk6;mzj5&shGbc0 zKI6yB8Iq+qn39>9LqOq`%)xGkND0t%z{VZ~i+iJ1Mt4@1k9(6PZZIcvFh?QBb@B`j zX5$yf7(nZdgm0)Z3s*=mB#Uz}IJzq?V03@neB*zzI5Pt%loeBIMH2U3?0b5z)m<@# z(esozqie0m^e}z$Nnz89JhJDjkO%tB_jhVG6uy^uxF$P9=#;p^N^tva{_`;AZ&B@T{&gd%Y zK6iVkd-9Yo438x_|NRZG4Yg_!b?q@3AcBkGI>C z!#D6GPln{z$DOQ4K>4!wsWID8hs|x*9X6YTQrtHOc<$t5H=8{3I>Y3fHyO0LQrA3Y zym1no!~CH+%w;!^dVxhv!5&g%}FJ6}2oU$36#&7CJ5q&kz^ zINAI_qk6%NsUpwRXESyZ9eaPT73zIk;`X25wsj&Ih$yJi%=X zkXc8!LdrnVo}c}XSy`TFZUXt)t>x-|2rbq5b~}h=yA?!M?%ma{*UGz<)%~$7=ab3X z+Td-eZBrM5M433ByxrdD?$*NSuDA_U$~@f<;z@NL-48AkT|uQ{t%#%h+btkjMwf^C zA4_xYn#|V95WDR$8|SXO`x#wlo`IHB+?))xp~5ZC{u?gnbbmbi%fH8*od1N=!x>h! z-`v9J{&+seQ`5bS?vE#NtlYUrs|_?dA(%0Fnkd8M>8y-LCkeB^_kLbu z8K-?^V04vz*3=-(euFVN^g0vh6l+ipwPxMUu<>XmhogJ)6gJk$*TfkYKH4XKvA_2; ztGnz9R(B`yoBe`mh2^g5(rn+DOy}=ryXF82#m(2RGkEq(x3V+LJZR0jz#;QDXguQM zcF1_d)%}cuka0=NgWz6m$XDj%5LSlW>>nJ2r?4|IP5|`}8Vo0<&Tf6m+&S0PbhG#p z@VU6Nr+i^J+Ixuokm$i?&}iq~UeNetqkE%kqs!6ljDnyOeIX_nt1B=FUv*~|F8x|B zJmomU<8?oP7ZfrC=y|G-?>8eZKHeY9gxirG^N>D z8FsoSA9&8R*S&MTG`lGC=I}2J#v)G`1kvS@V!naSF{PfRgYi2Z7Rkw~rRT1!1j0IfEJjNdAz zHoDh}F5O?OrogZ;L-;x?vvA*!|Hc)^87E)+$~>7}g5ePBPl>IKpmBrE-^Cdj)qMMf zg-t=bCd59LPi|*-u$wWN{Xu>5ZFWx0L%r_F(%+bR&;1P-=6F!g=swkz({=JwQHEsR zWfHuu$!yCcB%cX?{mwAaBbiy0aUwh8`N>aJ88}yTx<3~G_UGlbMt5P35A{=Bg|C-0 zvvv!fX5|oO|4^UI_(H5UEKaOe>|;NO-`kul_JX1Dc&qz4@kTe{@*nk^*n`A3Hs9?3 zCw8@e=E33xq70zB2$~v_9T>PLvmW@<>YnVkgXx_3WR45WvHhDnI2=LwUz(MJA^D6r z>tyx|%(Gcd89L{04*$$xEWDY)*f@b<^Ye5DWAW__H~WRBi!%t9mNPWEN}la>P3GOk z)$5wfwvDURRq~l|>30S}k7Q<6MnU$($&j`#qetU{ui>5Z!FfIWJ42&uavKMuG^;7g zX3^ygpcWUXjdZp@b^B!TQU-8uIQTHL5Ie}moBg0xzwp;`2GGil$2{!sgujb2JlwlE zJ)I$0l!Kx5b))Oqty9l8x+aUCV4NJP&I~G>C$UZr2bmDt-|C(?`bm!nB75)lR@a^Pp6&<9lN(9bxyza^3&loySLE=tx z0jK+8>1Y4m-kSV0lp%BLWcCJTX*~D)<-~?r=bG4iXzArh~-a!OO^S zjTfTs6fYyg2PpdqFC)VW4#F5@9xm+04Ka5fFC#+{7b63R55wqs`jFgojtim>rp5#6 zrddd8?unwRfvH8NL3V-oAp0xO?6=@&WB`eoK zXh1>NGcPSOFSDdl0jx^_mCN9l2uZ)Ls*rTFUc*? zFUl-VF4Ija&CE%GveWZQbxZQ|bCNR>GxPNGQpT_#aY+hDC?};PKT$84 zfkDA9(GTR3|NsB}|MUOH{}2Bk{6Fx&;XlKFhJOry7=AE(V0gfAfB~Kd4HW*IKfF-6 z@v-i``R6X3V7a^O23Jbc=}WIZT@h0Ce4=Y+;vc;3T(+wH*BRd~XGbtDYu|ey{MOQ@ zWs9~N89u+l^69bBWurowOUk#6-g!=lvb0;o5&ZjKsNlq3mXcM;s?LT7*4X4ex_3MF z!ne&eYZg4&lTzb$;clp%f|g3sX7}qelA1q#$I?2nc!Cuto zyZlM4?a^54?s=1kEj#Jq zn>Oc1M8KYqnA9`JCh{#?w?OjoVmG^~{pXM!rmz@V^apCq~%gTovi3^9fite9d8m@vh_mO%&#(`{}+QEDx9~NRHTdaK-V|lCzqtOczi27M)(_ygVPH^!x-AkyJM=^7 zj>8Z->j#)_Xwh>7>AN7545nMIPY2VfXU~FYh4=+bP7DkTFUma3LG+?2Qn^kH3=U7{ z7%XyPV3;6xWY0Ax1_l$guh~4#Fn2O6xX~JJQs&HX!Y@7d;A&?E+ldKJA|5(B^lYt= zT`%eq@cz-YCsN)nldk%*o&V6_^3ChvaVFiZE?ef_taPq;<+7*q#`H~>=GYi7UvX9W zo2RAi@-Hrb`Ij2ao!)bvV^_4QbN-qX4Ym_ptPBhck_-$CwG0dl)5;hbRuw>S7ZMvJ z=7q$MDP?4sQ3_F)SIWq+11h(sjFF+NfG`G`hYP-!rhhcO*c2Ijk z;zdw>AT|iILETpcr9omYwGgvGY+M**7f23dzX+QBT4jt3ATcJWU1CuC@0Bt#R1`5X zY$|1BSO&EZWIsq950afHY9RK5#22(OGFUYs@T68ohFNH0$nvyi!|X?^jugNuR!cIc! z`+8B;F6e{s6OjDDG!-I7$SjaN$o?N__IpiWWB`dhf{L3!&GrC=K`$eNLO&ye5Hu`6 z_Jh>@n}V=&50niO2bC#=;zLIvtu!yWBr`wH3REpKBo-H^7J;}5N~*<53TcU%IjJdD z3Tc@+sbCQug`CX1R0Y)()ne6RE(Qi?kR=QZ3<3VZo)HWT40;R<3_q4JGW0Bh;8#d& zkk}F={)AH?N9GW=Q!Vb55~$Pl%NFb0`N2-huTWawKAF_(~9ko+|?wN6ks z-GR~|HFH)GZyw10X=r9vEn{Q=i8VmQQ=nmDw2YDA-eN|EElU|0mOtbBD1I5>3N%0f&Vw^L1W*AB96-e#!GIA9fGBVR112m0Bo9th&@?ij6eAN8Gcz+Y z%y+D4fQ7<~cChtUt9d>H)!%7@Vm?;!4l(E?CDj8=g1VYC61 z52GERd>9=7<-_O%C?7@_K>0Ab0m_Hb6QFz;y#UIG(Ho$A7<~ZBhtU_Hd>H)z%7@V( zpnMq3@E+=aC@p|SD?s@$+5pOj(GE~Pj1GYEVRQnN52Fj9d>GvT<-_O+P(F-a0OiBz z4NyLeJ^0BG1C$S=89qV%52XdrXay)AMjJr+FxmmihtUC0K8#L)@?mrVln7<~cChtUt9d>H)!%7@VmpP~MT(gJ9-0+bJ<4WN7&?EvM&=m01m zMkhe|FuDNBhtUmCK8&6K<-_O&P(F;_0OiBz15iGUz5wOJ=m$_fjQ#-S!)S&tQ2#?| z0W?|x%7@VgP(F-yfbwB<0F)1-6QFz;T>$07=msbsMo)n9Ve|qhA4YG0@?rD=C?7^& zfbwDV11KLxe}M8~G{aY@|Dm)18m$23!)OC2A4WSs`7jzbUWTh_GSubQt$~EsqPY+n z=Fbb4A$*5R5IW;Hb?E;nfPsOL!7};i=k#1^fW|Cx@oMNu2U}&gksAs?ck#P45g^M^^FfcHH zr(78rLBpyn0<1-4W+s_N1qSiCAR-Y&q=ASO5Rq(DV8Fn^$i=P00JDt)Y-i3Uh}#x` zd6)!5eJv9M14KQ~W{CP_m`cGS5cLmOVCpv!rQVqxraoc|#C$C_uyGg!#C&&tnEIw& z5cM4p=iyKOql?qzulK0mttt1(PEfb0n1^=DvUVB}!U0?9D4Jz-#A z5MW`=%qwAFWaM}Rl4D^H0LgK%dowaHu-#^0U|{y(2RWSm94NVQBr;qO05KRik{B)s zgIF94j2!H4j0_CymmV`PFtD6wU|_ffR^!0Ha+QIB;Wn6K;2@YB~r3IdS%s<8|V4D&!<>ttkL z0Q0yVn;)Ih%e2r`VB5z5nMWMJTS zice-x2N}WR6kp7s&J1FvGBPl*I>o0#BpAb(Y#13B)IkPJV`N}pa)j~rGBPmm6ftOU zgS_;Fk%561476%dor4o?i8RDUdFOiXf0h0LkLrp?2RydeJ z$qh^5V<#)|u_Glu4shb*geN{ujKs%5i^RtTPkdZRiLVcl_|SuZaZWT71A}NH1EVrH z`PDNqFo-2FFe-x+AY062j@Zc@%%1ngP4rW3=EJI2<9a)!&6{8 zGXnz~JOwi5K++#b6)QOXfmn>Oki-XO$Fac^A7cy~Jn1pU!xP>*W(Ee{#h^?Kau`y= zJI27kAORDDCOi!gAD(C!_$*NQ;x9oN43x^j3G)au0|WC4STg<03`#?c9IPlw>?RW| ziM<9%GcYiq*F=9RJvfk7aNK?cNr32J13i?TpajnB@&zz9xfAYKm#0|PU- zN(JfO4B-_ssDXH*oM5?B2rrJ4fq@ZRrh$B=!NtJ92rkn=yx&|549wtK6{PPUH<(w< zpbp}-@ql@$5Z-wn1_nlO=?2p0&db2S2rl11ykI^C2IipnWCjh8K1qHsuNcD1fbdcw zyl4Ri2FA}!3=A3|eT+g342*YJpu7vh3=C{V44PaZuQOd_WMD{QVqjnaC14#;JTWk- zGchns0R`lFCI$u_kXOP$dpCf5gIw}AaNL&HZd_USg|oMuvoD$FzDT4XJBA@#>BvI6I4{XF)=Xcfjna@ z#=yWB#|-7UgLt5U5wKh|h$jqFnGfQvgz=g|yuBcULD4!L#0!V<4vH}_FmW<7Fq{Ha z{Gjdz*tn}8MGPQCAd6puc%3j_oHzpmBP)zoB+kIVVhOSe)I4KR0*QlIj3zL#HjsKQ znD{JlP&>tsnSlXR=rO`=TnADGw^2_5loCODK=#j&M7A+dih+R}%nS_MSQr=(Hf{##gxh!=#Dn{hO&ZxoDG(2CqaKI{x6uj2gWDJe;=ygr zk_P$pB{KuV6&3~tmOhw&SXRMU3`~hE3=D5r7#O7D<0}{#^_W5aWej6rnhMeZDhxs5 z;5exRn|6zZfguHyEWBX}VG_vB{V*O#6-zyg#|~1?*aV7-SL_T7%RoxYV3xDWFfcHx z!+7SP9t;DMJSzjk5ft+aLCWCf&yZnYKr$bs9AW+%kW#q$I;4@Gca%(K#hdCS%@9kHOu8ey&`3HRDZCCqd0jlND%|)1~ii* z(R6WTp$RZmu`w_-q1bmBWE9tAbcJ)-7#LQd2}&b}EQ8Fl9gv_AfQCKGG*DoGOG*Y- zNb6A$6a=6IDpUk&a58}Tpz;;WXJn9F$ilz?!VH&LA#H$ftPBi-;5L9C#B>Jq0g1Dq zq5#qcV1cv&SRicx7DyX_1=0o(g0ulxAZ-8^NWISjsrQ9Jbv+ZL>&$g-3aBOr)%73- z12?Fy2eCL9SRi#h*QM*A9xkM=2gx`va6;;O5XZnl1XR~E-QfeZBKQk9A$2{7!&uKC z3a;y!PP4NzGBAjN>UyTLT)7Mk3_Rev9#o+6fb06%pg-ta-4_?oXnsO(GTvtfb>^sGB7ZL`_3TV1}z2#Nbeb>NlFLSdj|3J z^%xjf!BsrOh@kjl1`UuVLjwi|#-R9A2=AaF0|OJdeg|nM% zWljc$vnb*-LE`LQPzylg1fYohh@xgKNDZ?aCj$ehf@Xx9c@Qj~$;rT=2&%N<;#Wc9 zd~-pKF}T=EkQf8=0Zs;nwJZz_Y(lII3{Un!y;aT1!0>86lq1f{z;FsCW5~+DFzp~z z<`64354+kjFff1SVqjQ?;)oS?AP+}#GcfE!5#Iw6XI}=jjSu8o1_p*lC~7W%)G*g^ zGcf!@5q|;}U&zhCAOuSIaL@e!iL?JZ0C6YGOfwWUMxa&y>^V@sz{;Q~6g6&OH7#gr z>QL0Qg4FPdaWgP5nZe?Grac1#{{pDCv#bmZ{2b790pc()FdyM&U|7k@z`*3g3au>U z9T*sxx9~79B(X9uaI6IhgVH$DUls-ieGseBfq{WZ1}44hP7K#A!hhzIH+>4SJa zjtmU!r=XsPRT2iE@(~n3`ph6T3=)oL0s=KqC&GdPoUXtIwt+S_FtF!969LS~W;7F+ zC-N{b%m!7@V0%E;%mL|?WCimf_A&@O01byRFffQgqnZO;?1Qr$0}G_smjV^(Ak4rE z9iXaWXJFt47wgrKNM%4DH(sHSWAp%ZM3m(O69a<>BQIz?jR#W1Lq|thpxwN3jFD1a zP;n0(DP;wB?btxYJ*aMCU`t}SAPi!`M@m`2T{~t-aSxJlU|@z6_aKge10SfkXTHM+ zvWLHb8B*MXIE?iS{NUoA`7}GIYbO9I?wQYmJ0M#>2u zBL&M^I5RLnih7V=ia4xV$?^9^TjA1x*lFIT#pt!3km|G(n(G z3~Vt1B?#nka@3T-0Zj>@i3C2Bl)wQ^2?ZD_fghR@xx4GwsM;6@|};a{Kxp~47KfF2x- zbJj93FoQL(7-q|NCG@631aMbWnka|#W;v_*_DBT72bh=4&ou= z+l_&NDUm^)3uK#UB`*WR9MFL1TaXhpnZ=i(MJOv98v}zTXp5q`8v}#HHmEdg>>VxlNcr>5l0#xE0E1 z51aPk4q;8F)*-z+QI6e0#(wTfq@-VM1px7pdwO(8Ki+3R6=TiSViv8!7eawF@%@KpaJqI zy9WaU2dLGm3DE>UhNB}e=!J@{-z+edS!9-661`!*mlEt7*B-#Vz!RmN+ zP~B?`iVjd}0}t4Xff6bRGn|1IwFkIiBljX8Ll_ts(C0{vEI>sqmdPR1#ENe=k^_=h zK`Dxn1DxzZX%^&77HFCUu}v5_k<%=Anh_(-azWE9C|z=cQV2?#tp^1Z2S|3z1mC^PbGN1VEzDiBIO+V4i^k*hR3!3U(19v2r0LR4%1tnN@kREV) zRc8h&d+PmzM7ka85Bu=79)c7Wty zr7%MbsET1=NCC9{$jHRX z1{(iiV!sNCMrcvY$N`$}f=;3{ePd%_s1^fF@H01oisS#F!6fhuJkvim28LEKQ*bGY z(r95}`2aGHgZTxR0_P1z0p{%>o&xh?(D+m@0|NtSMvfh%{XYZqO$G)Aj?*EwG?tWMUEnNr2ZVFwJA)=VZQd1(L`Z7*!a! zx$U@_`4||OOcv$+`8Ffg!*fs}DWR538H3o~*n3Ro$Ev?($(3NtWp@PhS#1h_qgEw~vNI1wf*vU&Due6-Ifon7CI$u`ga9|h#k|~%q2eGL__!HC6u%&&DxWYnv%IvtAfphw zfH(t#0MyGI3=D!`XF%Nv@r{r;BQqa2w-s0rWP&iV8U_XtJw|&;WKt$XEx7 zDoK!9QEo;M7sM0;IRumiptfNKFh=l#yhv;Sqecvq1Oo#*YM66iggGdLIUtb$4RbE^ zFdzH@3{Di_xPipC7>a-d1B3WzxYHtGqXe@!0|V}GM@yOF3=B-5C;{aOP;r7>Qh?^w zP?a+<}wK`Z&-d z7gPlCSt&9>Dh7zJxuEd@5`5)>IysBr*w17^hlst1@M zK89A15QngUor*}wtk94HDT0I?8`$;8DVZH%4kRUG#t9-VK3ppWh6hqa5fa!yxehZ@MU|!JAvWnBmQb2ycF{wQ&EVgeAmvg6QEbgc{z$_`+KRJ-kI>$v_O8 z$H5kZ>sL?{hk-!?lD|OdL=u+gq(E927^HC~bZ}|}n*?h;f+7SOL9kXQ3u>_eiVILu zhqTEM2_4b~gM=nKsul(YP%?)a3yybAc;G4WgUT&P41rvt$Om%@H&XB^vV%MZDt9=* zO+7^}kS<25E&u1sE83APxqF4%|?XGCpu{L6w07P&#uE zmop<=4(j^ADss@;L9kb$34vHom@v2tTY+r^6}Sv6phdq791NhYI3pwDZ$4fI&~YuG zFl7L-f~I)E zlg*5*yigiN6e0#CkyJxPK-1KWP*a$Y%wl9?t^#pcnVH!*nHU(^m>D=(Kx_Fxf+%_+ zCV)vcW=2jP21e$3kW!Ei4hBYuT96EADPTP(8^kOoLS{kq!AXMZ8JJi^Kvser$pEs2 zfr&+&8OD-;IG=%uMGB;dje!xwgqThi%Y>PMlLKsu8OT5g(+0$30gKwe&9-G`;N${} z*(0REOsFU%^ck2~>>+yCnCn3y&dSKl0;ZW6m{|PSm}@{B5EG(`2CM*(`yfFR1P`we zI4cy+ih!^n9s_AYiyf#B7?@ZXK@rcyz{m+2Ok(^19$qFbAAoj6FoFrRd;nXkKcw;j zG~jUMLvSu)W&p)BR3(IsS3Oe7hlMyK62(FB07;pM^lt}>FNnMyJSEYC1y1si%mHRX z9Oepg4ih+gc!8J@(Q-%_fCRv04qL2?XCECCSTfMg-I zTTM8eoMQR1!o%3M^1^hD8Nv%OVp?JX9AGOB$5L%+drZ+gKPFSsB@2 zITe~qAsK`GG|vy(kpd>r(mZVQz-XFBl=h=(9+r+7m{r7wsDF%26_1X=(xv4B_*b%a@vwvIg9 zC8#WjFBF&=K+Q)6CKeD2Vls#&0roA31yKj}1p^a{G(5~eEQk)mEQl!xb&Bw2B8UYE z17^4{b>J;M5DQ`l2Qvew0N7O^7EBCWOEWOBAd7+H7>^jj6iBS0>V>!zRg3|W>>yI$ ztPgQ9BEE64_`og($zsz1u^%K0@ed-D5iF2PAnHIYh&m2P&cX1b5ZE@5Iu>LXGl8mE zh)bB@seu+Oh#x^FD}Y@BVnJLCVnKWXVj;w+%|f^UVKPDt(gx#%r!#JNDg?10IUK}- zxD>>Km_jKFl5jw#@PNYw#6p;ikVUW{ZU(7?xS0p;WZk_zqQ5AZ0$Ku7{*H zVolM9moXp~B>X@uSZxRH#WFClfNC8`^dn*)#DeGm)tHb34`Q)_N6`4dBt)JI-sSGqABhEj&oN0ETi54F_? zk%hMUKoJCSCJQqIrxCcaU;%|ABvdTmp=|+g4*>E#W^SjA@+b+5FbNXklGAxJE%PYQ3+x}RDuS7ApS$Jq~K{4#Db{9 zV1Zl%sYuH~Oo;bEV>1x-jvj-5}DR2`(EQA;~7Pz#B zO*^E5OoP~#3io9R#Fro`sAA;N3CJ)gxF7=0*g)oWI6*t{8Lx{#26v1>6I9qHvrq?j zn2SI|I$#1Zt^?btIl%yJn#DgtsNGs{(w z3P|D?2KfQf>Jf&7GXoO~hy_x~#3BR95eyI($RuOf5%h;86G9!R`8 z!N>KSK<W+%jZpaLDif=H)>d=K$TI^56ckfMu$nPnLh zq_kpSV(|i*3DKSc(uBl>=+A|wW+s+AcsLfIupmhWSlq8YBow9{C_9#2_#eqTd5rzk(+3phK|Gc{q@Jp-hl2W|me&Cg}z-Aqv1uhypxJ zP#iI{fED1=)(bKh6pPF(U?xOuGe{JP39)S=ICp}4!OSulqyokS`4i-2s4zq|SOtVR z14-j7kVa6U02wD|W|@v8IUOVk(SyXC2NDIPb!HYY6QTgdgvLKSZ7cwrhiDKmFtONy z5*x^Yko5^5k3m=b!ZfLNf&0v3dzeHN<2v z6QW`n*i#UnEJOGNT%ki0cY;+w%vcO&L&PC$h|V=2vmxGE3t~b<*P}5Zi3jXdh!J2W z#2x5Nh=L6u6F_ZFW|r+>t04(u7f2YA2zG&mA?$TvHpDy#8)8a3NI4`R_k)-a0}q0j z5RG6aMBibMC`22W2@yRC6NRompI>k&a>%q&L`(RUi=US<|B6QTeQ6XIjA0!Wa6nfSDw1z7=63uZ#pqB9}p zf<++_0A^ySJqI!jqV^kz2}wU-CPXcm2@zce8c>CZ9s;R_Xah4LqF2Dl03v)1q2d}? z7~*2EFhn&H^EOxoMB`nkMrb>dndKIe=kQzuP1T!JF<6%OK04sp_8O+3|?K8*kOVdvqySUxnP6c^6wCyvhG<*`VnV_l%!F8i%7nB`nORUp!Hpv}<~rzl zBoWw}YiN^*iA5OHhy%F^GQt5enTZ87=K^v)goO~p#)1@BLh$|{hy@)F1o?@HMH^&; z4tN9@G{gWg1JtmC*a~7H#2_rtC^N)<5DOya2x($6FtLDG5HS}}%MD@-Xk-D>QiSk9 z9Y9dvF|mL~03e3>A(TVMkeTa2Ekj6i6GB3BJ0zon)I$t~7v`KCpoRFL6VF*0h+nrh zA2hTHCeYTc!H#BPCVP!OxTgVeJE*@=4JxZxnVDHZ1r^Bsph^dvHXv#+Nl^5Fya!%O z&ddl}f{s|14{vru;ukVw1u+A<{tOb_pw<~APGCuui3P-hiGf|ffFcHK(0~L%%f3Mi z?YTgL5EBt|mZ0%GNK}GY5EF5+Kv@U6;uDl#m{`O>VF1xB26s0lEJ=7e1hF8lk%WW` z0}~697|1IKX;3tPmuN#e9N;dB(}lzn0}~5k zfDOcgn1{@Q#Rx(S6km`)V}{L}fnp4rK3JLI8w%g7N~GK+6lT zQ>mC$KuajW?t_F53JDQMOZ7F-RL=s+&Y*+|igk!zKq(UvHX#2&QUYkk6Cws;LBfVo z79{1Nnu4&6I(8sTfut1Vkuz|(Ffg$oi-Ajj{9>%2Y*)v|%nS)ZuwvNke;p_kA^t)( z6&&_3ePCz@g;}_8LR`b5VDlBK=U3D z*MnFP^GqRyA_Eh6Rs<#nP7_3lL3(@0=7Ccfie6~!LQ@7LgfJH|Fjs-*Cm=16JT}NA zE3ugkbXf-@m_W;HutTLVN?&SbHc(vx%3Ca;buG*_pmYn_5d*1Pm|4K>)M}78ENg)S z2{ZGMAp*&$AnU=A#*8BUEfwNI z(Arc;FoV{iK?*7m3lb`zwjjg}AeI6HG`o?JzCeXPBxPaj+JK}Qh?xx72Y)~=g18Md z3g5DOAx;_wAv@}RT;>Nqm7C_#*6U}8}M2|{#(`d<*;AQnV7h$RBz{U)#C=Hmopt?cx+mHld0rCeV+z{Oosm9}Cw(rxQ*moh~_DcDmwp)#;kkb*CFnH=XzxoVd}=2OUjt z19V0(=&C9P1_sz&j!t|AK8;KrEHJZ~^O#Xg1(}7@|BRStcB9)1x?2%+Lm{k}2s-T- zWS$eBf*Zu%Jdk~UC*2@6Vbec>k%0l$sQ{hd2i5Nd(a*Gu>!1rL7{CUg>j%Xr=)h`N zI|+6NBsO)R1B+ov9CXAk$e#H4%)AmqBMXJnyyDFCywns1cfU{tXG3%7y`c)axyiZt zDXBTOxv42R`Q=#nC8c?(wnh2L*{LN8y19u($r-lbdqi^+(^8T_B1xIHIR$1WDIhkw zY`TK3f3bqDzY&B^ODfIGNy*Gh*UiaHN>5H!&`rzB*DWqdOwQIVD9SHMO)kkVQqWB+ z%Ph`J%FM|uskF_=Oi4-2W5~(ROD|?fD@sf@0F#CcA#Np=1*r@$k0~T)Bo;Bm$EPPJ z$2F(#~7Y{mG5+o4n7vSjZ9UtTv z9&Z$%mXpum1k&vU(hag)0ZhPc16^VnAD>!Sl4b;U8$=o;nv_{m47MTE&(q&8K9B(v z@C@;3MY$l?rGhkotaJ7ah|esJuSzY-kB7JjS)`I7K0XJo7VI!*M?Zf*PiIG;_z;l8 zKxSZy8-i{24fTolb#)AhcLDjOJToOV-Z-~3Cq5ab5sv~;Se0fl#K)KBFob%9gToPI z7cMPHFf-kP9G&BXgM#Bt;)_c%le0lys4!rN2Wf`Lg*wF>$Cu<5fZYgoJ0h?_s&HA6 z!Vntl33muIo)E!NoROJU!Vn*yTbfgnX3P)-a}d}DgtCx$NVGuQ5)>Q~ZxWx9U!Dhc z4YFV+hDdRCW&x5%TwI+&9x(u`!{z8CP{KiY9;(L(tOw0ynZ@xXnR%69DP)HfW7-Lc zUo`z8@yTGl7{aLx@$nU)2(2(?h>tJJ0INc_p%mn;vK%CPg29oL3~?viZ$|NmL{t@@ z1~vySiJr)eFpUGd0a@J9#U0#L*jmnK1clbDhM(HY_&@97s3 zpP83hk(dlh_-UCHC27T(3i zXw^>#RU5=vqYtiPh*S$HUiFe0p#CA!Igsp0q#e+dOsr~9WP=hok?N6>s$Mb!ByADt z3q*P)U>77k7~xmN08^F0kPkg`2-H|(hqc;EpsjbdsL34BlR4O7eAt;nY>Szfa_P-y zfNMAh(*U{hmmS7`025!#yp%_8K0BNbZT3U22xe!4@{ujzLAKx))F38<`Rp+E9jF*< zJ%fn~rr98+=;kuUF|ZdwwZS~a7zOv=E~pe^0^Fr6P?s?#FtB$)r4K-9#yGgLUkD)v zs1CT!I0p79Q0Wa&nynUm*EU=`Of6KLfqfEGAuJ#nW8i9GeqxM4D7yqz&KQrWES`ZK zb}9A+s4^x)%uoc0F`+pf6ofFR!J>xAa6ZDoLofpk=Ci{T!raGXFrR@PrT`XaAVJU- zd!T7#aFT-=s|U3jmgHc3*pWW)BnQ*r0M!6;BaH0<6LXl)4rAxR#0=)M7eLuCLqV=# zhuP!?m1K;<(90MF*II;7RRLvoL21S)_8us+4@xseu}^?97eHyoDE38ACd?U(Q4H)t zP%)Tm7^C10gDXp9U`O{UGv~kg4D4}G%?VJNqlcl9LD4{SKKmM|2+Rzyk29cxSx_1j z^{}AnfQcE*hdX@*LW}`)Lm@o!V5VMyDu6{Ej1TLL!y^x-;Tco|DDq(JcQ7%B`Rp*Z z2=q2tkUB9a8)hijD=?ehKs7T)Vd!OyVuxv!fEvLV#V!YB8bE2rD0U+#(*#O0MzNbg znQl-Tls2GDm@`0;w*zWB%r%Tr>@X%=St0{FhEI*=GqAHj&0~Yoh`0-aiolEjdzcR@ zC;+8FaR>9B9!$(&KHTMg2r-85l8{*waK?j~x&x{J7I!fIKA1S9tY?Su&%nf?bpwpg z1-;;Lp3e?r!+gk?$qw__C72DFm^NfGuup=T9Iy>?zXe+xq`rokln2!g z6OTjl3{;$fy$@;-%*pKa3|#;JOU=jd17kWohrtpUTrGOaf=i$$A-DvF&(krY8Lk!< zB!2BPJ96OBJ2Nhy%`2U|_K0Ay%0WRFoz&M{B z#)aLo&KL);=w3lpGRCpPnD3xMEL{KV=d;6jpP-_QaqKWAtjWW|^{;+D`yZ$R22d{- z)N+brhcVfpLJ$*Sya=c$V;nn-Sp^eHVBZI2K7-PX3G6?hOg3ncgL(iwP__@021Q8# zlnskUkQj^&izd*hh6yxw?4UGbJi8l|*#M;(RD2-$}Oz06*iZO~E#(V=4if4y0VNDH?sSNB(pbkC-tFprx*pEQP zcEH5)7}#O*5^w_<*h`@Dub?zzGz0q|sNNeev0Q|C^I&56>@emcs1QpJgZz93_G3`p zC!oTNp$M@rP&rT&6Q=GGRE({Pp@l(iK0Azm4JytU#SUZMf(mgqGH@uURxv2eXTJj# z`T(UFqu60gm}L;v)eK7W8Q9N3l|6#ejPVFDCYXcc5Dtdf32ZKhM_@H{MpfqDN zJB(Qd6%y)W-~lbQkt&DMa`V|?auqN&6(A4wF-U>wat0~6`Rp(`SPWt@hk;!VYJd`y z=Bx%8R0j$fn2-uoN)%>)A4rKDSfSE3#1@$0@!W}%H9VP(_Bn%T^5->mT zgZ+kN0!#vyO3+PUU>Ad04r@0vrow9*SQCyhm4W>qG)KUdg<~oUM<|2Y$C$^!4jYwe zgWANHh7e1Dim_EQG=p+CjGqJ*XN+b~fijz*G^lWhfU>ioG$^0K#9(2<7{S2q1eHhh z;1Obo9t=V(2C5!phZmF$a}p?z!-~iUP&vjNM6vk{CKiVfI|mhG%bUy*HkpGR#{YyS z4&%c@mo;xP$7BwS5QYdNjE7k%U&o-_00WGD$Q)gc|5Ec2I^IDoW(;MAF=2Kx=405$ zn9qQzEDuvz9zq$+CyZeTv2RdI*>WKBlQ2FLw4zbZnaokmfa2^PbU(<xnfGGvFW6`^o;K@Un z@Y)oV1~sq zup20i~JiIp#C4Z-MgQE$(=Rql!pVKd|24IcSdqHuVGJ!?x#w zW*)%P{4fodU>cxPAuv9&2JqAaOoPTA$oM&^u?=H8LB$y3*kR11y$EG6b{bTSyPko= zNL9g53N*)G2Ni6A(jaqT><3UW#yEDKeGu~kpfpGsj9mv6V~k^mF}ECmC@fB!n3%zQb{KmHRE#l>eHWB@2ug!&g|RD3b{m z{7LLVP-YU8W=vvFfihvKgfR)8IA%bl7?arNK$$C`G-DDxxokoRp~o&`5(7Ida&@3l z#TW&TwL=J@BT%LgG^!Y*;1TJA5Q>5_lb|$X6g+NsA%tMeb1@cPQOemTi#*BgqMX|?0nbV*&V-!3Y zGC`9NV-!3YiXenw$uJ2agpmxR;K}eGLKQ3-hQX3f6nhku83&~qqu?ns10j?JW#&O? z#wd8oT!0XQ6=WL_LKrDCih=zMv^>#(rai`Zc*@*|5Q3#l6=-^4jEASpFoX~+WtJd> zV5QDJgb<8*1SS-RnKI+yDbom+=HlTgvkM^vE5T+UgkaScyabDfr%XL)+GC7oUj$_y zfzpie@MNe0OHJ|cWH=2W1WSfn5JIqIcm*K@ONMf=)D+JSW2(V~;xLn8JUkgrfvJjz zCqo`s(us#BLj{BoEEy&sgfNm}JUkh~OT&10X&3@aC-LxP7=sXk6_9BNAy_iZK?oH< znMF_l%a*M*0Pf13}a811QZ_2AL6p@!=(I z7(89W>&Y<8L>$HrOT?@8Kr6B^c=Ei45P}t)La>Av22WD(5+n>Bb?|r!gV$Q~Veu3O zj}&&8Ps8Am0tgz;%ql7j9=5PH3u73(wZU{4<{<`lSR)l4I*IVmSp>`V ziR`dke+D7+3Ce_rVIn*X7r}xe5nemM^I#%855jAQM0Qy1;0MctiSRIl*A9vBY{>%4 zU5W5)>3|SQgEHZPpNJXwiSWROw+|BGfe+6SiSWROhjb!lNGD>3bRs;Y;qA3VL`W+^ z1CB8U9@3i-LNMkIm{1%%@ZZ6NV%RYPKL#H7L9nD515dyw5JIq;Uk4UNG4R3^9&0i1 zSQCQ9M+|1H#bCx-3_RBMAT+|7gCfv)VT@siF=b#vaqx&tf(ga2!y7M>^$AT+`fg#;{aW7%O$1(;AYW}=9NCyF&NRk84%1Uv=A!czbX zEN){lQ$Q>{1;ERISj;jY7BdCJVy1vt%oGrdnF3-lQ$Q>O`zL4$fS03)J{vqf5FNB> zu=q$~hjq}OA%tL2gr$Q9YvwQ}u`h$hLjf!dlh})(%nVq@3S*xHWx~4Vj7jXDphEEW z2iD#gtcruRLl~3TYoPHk1xkZDRZu28@Wa?)Ojz5OF$v!OK&t&3b#XG~&;RfO>M!1B)}pM0hU- zHsS)Z0>*}SuoE%kFA?4hgf(a&4uSDt!!RK8EkNyxarE zzXKI#jADl|VaW*;Qm_I8R?!<*A&=`gKQ#-2{jC0?XXcLSf7k6HdpJPS`L7V;noIKL~5AFh;SrLGu;7ii%-}G2z8)6lU=n%?>MR zVS`>s0}m3=0+cbD9hP0;C2kbF#O;8oN@0gFVGSNOPz=h6#^wF7~26V1{%16GU4Sy6ubh372J$5@G>0U)Q)C{F=536V-&m$-v>35 zF^U~F?h4P@Q4H*`oNWfpkBsr`FeWTJ^CIWo`53vJA6eQ^bv`>r){e)_+VPlKJ03G@ z$Fr}3W=dEVM{^5I_!?9hV?4aBe}xc2&$?PDxegS!*t0IkGw3;19YrsW91GHjo>xh+ z6qZHd`7s_NKVpPBEEC>=W=6(%b{G?0lO}6=V=*&fJZ2`0!_0(;VHbEN zjKj!;pxgj!_w>NBRx&$`3Co45^$fKPGAQ8>iaQykVpkU_lkP&8bO_3XXHvwV4lHLf zCc`r+Jom+8=Dt|W+!u$L`{LobZx1Z@#k0ez+8aOH3t+rgP*IqfFg|SX7}T_cwkl$vG-Dim&=}s2i^J$bfvsU+ zhmFv{f*6!UVB;}}#tZ{HY?1};mna5yC8&k4$rDf#c?K1OwOAOV;azTcAsLNX&O|e? z!zNYWI-?la3!r5itj)rRyZHhu{$Sk?&`u&0mH zdCBbdN2J?*S8s?wN)0 zlVIXd^)P-LOdP5n#-9KahpLD1C&9#_>S27?DQ576B`^?o)hUp)hdzDf;jwG%tc7d=pUkR>p7A5@H^jsa=|%n#F`G9cA3Hq8B? zV@X(Gd!Ql}<}H|AjPY=5VdjHE1QwDhDcpv526hdo7Fbk*)Y(AAVE$)y@K%wZ&kp0lY-Xp`|yU9mcnYii6a`*m+Pfm|7UW2PzIy3uCW?iow*v_^?wB znI>p4u)`eI22~6S2^hNzD#l&Gz+ntqoQ7^XV;nn%!JsoyWT2W?L20&1$hiA`z?*5qK~Uf?Nq>!)=a-CoPzNLCRokxNG9sVN96cLCRokSU51o!vh_b zUO>uVK`;g8=aT^{su2#MGqiQe4qyoV>CN@xPX+w!lVG|cgARTSa4i|3W1c}gR*}? zX;5ny#%6;$lQEhd#)O3gNGpsD3kAk#b{Mk^suQFP#_ofPF-Eh)n6PjHDTA?LVFYpr zj13DPkUALq0>U^L^9odmwHmw(6vl;xDyTYn08OM3Q13Fvz(WPDEQWy{rVJiiVe}Y*s)mI&AIw7#L(r2aR5dKn6QHUY6WCLr z%q}R+n1B)Hj0xv)D;I6W(;Y26+IMz+s+Z;rh=$ zA0v%}RHAzoqH+r~fR90G#su~gP$s+_NMK<1fqEkjO7kIREB4n*&1Z*+=RoBd)59`{&Vi0$VZiDJ&jAMr}VIjj94-b|JP*n(% zVIr`?m%EOk4Br1-1695bN;Af@!-8!aR0ushU?nj;4C5Kt8=wIJE9*clZdg9jfyyz) zvBQ!DET@3Ve^`KpK&@kpV~4pE7Ofy=$^O>y*s=NbAv%$_GgB=6L2HQ;rJDQ0N{U|0j^fOo( z*mgiogB=OQb_^;2+uYB<20PdacKQ(;>?j|O9gsxKhJJbv8~U*@3~aE2jbO(%vCV>R zfrD+@XJCUJWdqwU$EE{S0^2jlW&{<0ogRVE1KX{~24jdol`^ocfNtU40HxVrhabUC zj$(stVgCkG@e9g;?fzw8gGs?;*kDpNuuYz@o!zj#w+w7BDVPi!ObWI;nXL+{xeiLR z!8ZHC_6)P_fy(TI(rmEv17KTn8Q5T^!3<-AnFceAtqZDo0+eQ(1!cg_Dqw>hR>LN!=3fRjm=sKg4K4*uIBYyn25dts0~>6MD=dw{6B|q^8%!-C z^}*D_Xf~J>DXAQ$8Aihmfo)D@gE8Qy>Oox(%R3Bg=zC7tN}$=d3Q9Au!M32nwwtn{ zA3egr2HV*Q+Z)P;zPXcu4Si!L+Y9JU&v#Io0d8&(bd@Gs1e6g4r5RM9cc+175ZI* z4A^Wu1KSm-64|uiqVZz2U*wDM@Y_RS>tjo**x0eBGIvW#=0i)3k zK@ClqNiSf^VT^xJ0ZHND1facqRB>j88&9#RXJL4NRh*UK z16FZ1h96kP*%>&#V>6$FApxs6C&L7+;#|nihO?O&xZ!MM1~UWbwl!oC2%DLK7s5az znHl)dL?B#d27U+wjbvsJKofy*nHdBj3^bCNK?qF*!ewRucz%U6c&cg5lEuC+~;V+2&j0{WA%-=^q{R1@hC&Bh( z=3mhDnxGI8LCe>-ahU%E?0z-|j%N^;d9Z^GX83?ZJwz2F!wMD%3!<8V;X48KLaeCj zl^C(7Lx?IyhCOKNVdD4D#Mua#!v#_Rb0pZWAPysg0GhY}0dwTg)Wh5}2Tfd@fH_Oh z)GH8BZ^90-3FK-J)@B67E+fMoMTqzmkRX!3&OpVX!q8G5p&lk~#t6#8Obi=NLd=1c zT=r1$18CwN1l(Bwicpy03=9k(nefN2mI}mPn3g~S=9{6Zhv;TxIH3w*!OVg17#aSd ziAUiuKN%XHUTP4Xpz;x97KF#h022p^fiO(m52_v{2Ew^eb0VPP=;px0L25y`5~@B1 zs$LFaFg(6s;vlsk43TDJs8WZpKw=;a;W08C!XZ9K1EKQ4*&@w zl@Bm+s4xSl{|i#jUEJ%F@RDBOr0;V1&4i#p&0Zr#$pz66G z3gPJ-CJs~o0IL3<5kz4Sgo3MwiNn;tgQ^cOfhe2?m4NUV8DQd2VTLbI_0OQ{LG>R< z4yGO^4iW?5pHTIuOd%@Rm_eeTvJ*rzGQh+^JP>9CU0lt;$Z){|qW%*|5Gnj&;!t4* zE~xrLmJs!Spb`)sBLhqvD$F1WRlm;)qCy5*&_H;M3@~w+dO4{2TXql?EoknCiNn-G zR53EdIYC(H;(4G;lwpDl3=GPkOSu`C7&1;l)Pvf8AZbmg_ynjpthrzS6`ye$q8`-l z1gSTLif@35!_-?t#dn-RRqsfke%XNLPKa(shHW^+_n?XU5itJ{ntGV|*FY5+$U{&} zs9Z{bC2*+v2mS5xRI$PwgOtvXp@}yV zFy{oCdWfqT8MLAyESMD#9wUPd4soRzhzfM|9I@EN!*Gbd!yz6Phuxe%@z}+$Bw!b3 zNWv~|fkXTesG$P$6jC?`rC>M5DHXf8Q5tsf9XQ1A;Sg6#M>VGtnokYRLBwG_?S2CB zo`+@*L^mVDDKv3H`N%2*q7xQG(+JqBl!K~%0Ri>%(A2LWp#BP)dWda|3}T>$BFvEt z3=EqHn3I5}9%jxA9O83uh=0H#Zj=Wx5$2>_1l(hVrv5Mi_1DnU6YB4Hu$&2{C60)WZ-SBLhqvDhzLLSad;Dpo@E;iNpG3Gp0e*qxZ`? zpyKG}z|_OUVg9{v5n>Lye;=TU-zO0MI@2NMz|4p67#UP%Kv*#GX9UbKLR0^qfciW% z^}h(He}bkS;yOkK1yF+==12wx214b44w`yq0^?&h(A4t~P|r6D;xd?%LXtdHlh2s0ZqJ+fH?;9QO!|d0-1<8K98$hh3IBvkXis?fpmi~gvZEGun@umiGeVz zeA{ptB930Z9Y7OrAmDzXH4t+^W`i(<$H)+dCf-HBoE2#5Vdktu6Q4@JoJ(lx=i*Sm z42L+(-bZNWz{KU&LRcWbf-r=~$k2pC{2vbSwsjDlATvN1!eeA$S`T4?#6TFrV`M16 zA-)bxd_4hwnQefW2r?UlAv{Kg0yOcR1k5QyQ-73z`gv&TFAz|F08RZJ0_qtyLVN=9 z69~T~pq>Ry{Wk*Ywb0Zvvfv+IwL??SOF(@VntBNW>ZhTpS7rf?iEuDjnDY$H94i9qg<#8cq2_xLP@jXQK8S#N*sbVL;~Am|sE1v|4O5>)Kt1d(VVL@C z0_tHG0Kn9j5Ks@>2o6(UM?gJn2>?ue7XkI~1p!bEGYF`MZ5V?pXIM%=J#40%ka}G6 zhU>xU5OdxTWFEG0lD**ZGggdw>T^(W^m*-vU~v|V`R-3(ab|`)X!C$g=glR- z;+X37Ss56F7!dPQuo-A`s5q>jt_Cuefq}sVDh}(9dqBl~q2jRil^Ik#oRxt=kb#MT z1KLm5fQn~8)x-LCbD-k+P;pp$BMB;A0~LprdtmP~Ffg=0#bNVhbx`#^P;prM$_6Sv z6(r8Y$N5=HIILgx1FHTrR2z4`xXCY=EkFg^I(*>tN}@7b*_x zAF)BzheE|+<#rTQJOL^W8>fY-&xeY``Vp}B^=AX6TMmW>X#E09ZxvAWu<;O>crzO) zelgpzlcDNi^TIHD=Rw6`;9Tfgd3=U@@>EQ%ay#iRAgP{N#FEIBTLd}7->tN~A z8l;|yoxuUB9%>8&Xx#xQpTfrHVet|MH3v2x3!9&cfr`WC~_4(p-nVdJ!*brm3^ zwnD{W?Lb(0z87o`JA(x@d|>8WfU1X$bH0H3_cl}P*tq=-kRSsCLm5;YHV+OLCvv*io?d4i=gH>a)QE#li>t3d|>H38mb;PKLX2-i6C(% zMg~~>_6XFRe2_Q;BLi%l5LRwfK*eF}USRcj3sfAo9^)3&oGz$1Y(526k5AA z!^S=ApyG*8aoD2r3Sn&nkebFNcc5)}>s5inl??Lty1|ELc4| z#=7W}EFg0*%Z(JMIk0j5V^Di@q2jRl!4Rl;88;|DvNJ@W#mhsedf2*gIjH(RXgI^> z9boS4gQ|zki#b38Xf{+Fw%!RA4lAJIu=(y)(D>Z|6^D&?!PbXtgNnn}p~1?rlTdNk zdKCd^!Ep)fFD8Zy(D7tg^Zgc7J#4%S=Kcpzao9K^tX=&KDh^xkAp&*hXQ()AJ?8{y z`22#3!^Ur6`GS)NQg6cMv!KDlAOsbM%`?LCwJcN|HZBcISLz^fCPoI>IEfzAUIUOg z10w@$z32>RzrzM94qN9i1FGH)Dh?aJg|(9dq2jRd^B}1DNT@h$-W=ACi01*NA2x=B zuaJOQ0ihW3q3U7lQDOe70Esg(GQh@#6rd5A1`RjZd=soa*$Pt6z{mg_uZG#%4Hbut z1HymYJ8ykX%$^pqCG#ic3n<()5xU;^R~D7gOv^2a&&(@fC@v|APt7eTsbt8^EhsHY)k}sl z;!_e!5*a||=_P|S#wY6Lrsfu>g3Ku>ElJKuEYeG6C@3u{)=LJNl9QUJm&{O>2DSj= z?P7>+X$(m@iFw(@dWH;DsYUsz#d-z|<;AHbr3HG)3~6aOrNtQ_MrK}08b~BQKCK`= zCqFqGZ^3 zC+a0Lq!wqSYNb3Q9}LK~766E=eo_sm?4;EGel3u^>SJilO4vRIqDvlS=Z-ljA{> zMX8A?5IQvvWLr*VQhcIraY<2fZh>AtLwRyhNq#OUK+2Or46vTWq;R0y2|rE^Pj zO45u$8cLHOjI_*(lCvNO+isAh8U6nOdqN; zh$yt6V2IBJCENI%{B%Q5iItdF8K0lW5Dy99_#%dQsDhHryh?Cp0Y!L0B|~yfYGPh# zL40~nX(|IWav0)4g$_s)I37R@kW88p132~N!W#i=EbBn#ri7pLXs7o|cR6b~tX5M@*v zEP@zvA=#H99_j^%VpUEa)H0|8K!y~007aD zA}78GT77`h4>(BUa}z7#L5fpT;&W4T8RFxUj8b6fi~$z^keV*OprnW)z9R(ZuI=H!546J#W)vV!C& zkbTKHiJ7_aMX9NIpxl;`X^@mzQVdSi$zYqH*_|Oiz97Hc6jU65Lk3bO#wR8hmSz^E zf}=X4hyhxHgJUbLC>0b*;9LN%+hK_*J~t^oxwHrrIIzYGsQ4==%18bRPhfK;%7a!)=a<;536nhf9|Do!f^c_hD} z5)yXtPQk(OG7g$26U#sa9yl|D5?gkBQEE;q*mv>8pk#z_38-deh=(*pK*obwclnUG zNGdJ{mDfcjpztnE1qB7vcu+zs$uCLFfu^%!P-y`Q8E_@T07;+>VBbN_N-R#!%#4Rr zTMY4Onc#Q=M;y2?Ee6+F4DsOR3qw4tN(5K&aC1tEKuHG_n4rW~1~UZY7jU(~0Ew40 zQ0U}T#g`-|F~kQXmSp&VTOACE;3g|WJh)DZFJgd~Yz%p+J4`3~zMjgm|kTeSRe@RABYH>z>P6|Ujip#(u2hUi!DVb?$kU9Wl5VTE+ zNCi2d<{`*K$>3H4C})C-D^MZ^sn1OWH_bqSR8o|a3aYF?O>0OjfwV!(K#*E+OoGH9 zkqctQC+Ae9WEz272$qF-Iwv2R+2dh_8>~UY0B*n`swhan!JE?z@$rZno&j7OL-Pj6 zesKB$rDAyL5FZc9c!?<~4Dn8&Vu67{uedT7lpOSmONtmbT2aEFSCkJ9e7)2R zNQZ(!4{R*B|G}V#RD|h4)D=Uiq~c-*Jus1+pPLIR)bxrni<8Ur5=%;oGLuS6Qi~b% zQc{yj)8iA167$j#TyU<3NhKu}rIx`If|DXt2Hd-WNfeh9!I&U5pqd`e&rilu^>qwe_(6Hf;O@HXkSh8&H8-1DkJzav2n%`eFS}*#3Hf;}8`mpyLw| z9%u{)#)8nGbq$~{G<13gz7PM#Rfs&gedv5+1_to1b(ntGx`PK${jh#G#54v5=&%=@ zwr5}f?{0_bhpm730M!puk4wKd)c-L3u>Jo(p!x;Sw!)*E7l@`Gc1{4tbBK)*5DHGB z>j%k$#9;Qr&J#$0>WA&yh8X}-3uA-mI0i_V!1Tk;9f0Xi04YMk==zhP?nk!=rXO@j z29kEz@GG3oVPIfjW?+B~JHnNAL)~u)7lAN9X$8W9kf8Mz=wcw5BT)Seu!IQ`gt`^V z1XI0O#6S{9UV=ylhAp534q<{xbh~Ea&|kp~QE7{o{vo1Zqrk*+9QwCPLR9VmB~Y+R z2muj=utDTz9Qq5O`>4!`LA6Vb~D5pT{T|CIX?+)xL(>50OQX$ V1)#(Z(1a2L1H*49A4Z|;2LLefp=$sD literal 0 HcmV?d00001 diff --git a/TP01/riscv/test_print.o b/TP01/riscv/test_print.o new file mode 100644 index 0000000000000000000000000000000000000000..e6f3eb69ea3ced8115017ec35e5429893926453e GIT binary patch literal 1560 zcmb<-^>JfjWMqH=MuyJ}2p&w7f#C)-gw4Xhz~BI8IxuiDa4-lnGX7UK5o8c&Wnd6y zWo4Moz`*dl0mNRw1Y^T!VO9Y)1bYEoZL>im$Q;J>1_lNXPX%93Hv&+8g~8$&${Cb!i0j}GH^Cv! zpi;r0=i_Y1pyy+tz>u4mna5C2l$lqOlNVoHQk0pO4&laU=9MtyrIzPp=A}YKk~0#E z7~uXB2gMMQGhzNVMiK)tc|ZgM1A_zu0|OhB4WeM;=;{SPk_-$CLJSNHkT8V^z{Jtj z%Rr>T>ban75Cs!QSFZw+gqqI{WrHY~IJ$aRN&~qE=4Oz3m^iw68;~T_d}Q@7adh?Sb71a z3y=ymsQu_UYXV4;fq?-zZb3pY{UA07gYp4L3|;>$kR%oias#rkAp@vQH z^*|gXjIJNVhk6xB6$8TwD9-|*#I=$umF=wFh$$1k^aV WfFQ*Ea6XJN0cxl-OaMxw>jwZ>t62sB literal 0 HcmV?d00001 diff --git a/TP01/riscv/test_print.riscv b/TP01/riscv/test_print.riscv new file mode 100755 index 0000000000000000000000000000000000000000..8136e2ba5d13988e9b18199ccf8518a3350d0032 GIT binary patch literal 140392 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

Jp4atw?SXaU7iGv<5w@)tTWPExW66%a_ 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

#`>IB6mB)$~+_q`D2b>#on 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 5: + from typing import TextIO +else: + from typing.io import TextIO + + +# header - mettre les d??clarations globales +import sys +idTab = {}; + +class UnknownIdentifier(Exception): + pass + +class DivByZero(Exception): + pass + + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\6") + buf.write("\'\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\3\2\3\2\3\2\3\2") + buf.write("\7\2\20\n\2\f\2\16\2\23\13\2\3\2\3\2\3\3\6\3\30\n\3\r") + buf.write("\3\16\3\31\3\4\6\4\35\n\4\r\4\16\4\36\3\5\6\5\"\n\5\r") + buf.write("\5\16\5#\3\5\3\5\2\2\6\3\3\5\4\7\5\t\6\3\2\5\4\2\f\f\17") + buf.write("\17\4\2C\\c|\5\2\13\f\17\17\"\"\2*\2\3\3\2\2\2\2\5\3\2") + buf.write("\2\2\2\7\3\2\2\2\2\t\3\2\2\2\3\13\3\2\2\2\5\27\3\2\2\2") + buf.write("\7\34\3\2\2\2\t!\3\2\2\2\13\f\7\61\2\2\f\r\7\61\2\2\r") + buf.write("\21\3\2\2\2\16\20\n\2\2\2\17\16\3\2\2\2\20\23\3\2\2\2") + buf.write("\21\17\3\2\2\2\21\22\3\2\2\2\22\24\3\2\2\2\23\21\3\2\2") + buf.write("\2\24\25\b\2\2\2\25\4\3\2\2\2\26\30\t\3\2\2\27\26\3\2") + buf.write("\2\2\30\31\3\2\2\2\31\27\3\2\2\2\31\32\3\2\2\2\32\6\3") + buf.write("\2\2\2\33\35\4\62;\2\34\33\3\2\2\2\35\36\3\2\2\2\36\34") + buf.write("\3\2\2\2\36\37\3\2\2\2\37\b\3\2\2\2 \"\t\4\2\2! \3\2\2") + buf.write("\2\"#\3\2\2\2#!\3\2\2\2#$\3\2\2\2$%\3\2\2\2%&\b\5\2\2") + buf.write("&\n\3\2\2\2\7\2\21\31\36#\3\b\2\2") + return buf.getvalue() + + +class AritLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + COMMENT = 1 + ID = 2 + INT = 3 + WS = 4 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + ] + + symbolicNames = [ "", + "COMMENT", "ID", "INT", "WS" ] + + ruleNames = [ "COMMENT", "ID", "INT", "WS" ] + + grammarFileName = "Arit.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/TP02/ariteval/AritListener.py b/TP02/ariteval/AritListener.py new file mode 100644 index 0000000..d1ddd11 --- /dev/null +++ b/TP02/ariteval/AritListener.py @@ -0,0 +1,33 @@ +# Generated from Arit.g4 by ANTLR 4.9.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .AritParser import AritParser +else: + from AritParser import AritParser + +# header - mettre les d??clarations globales +import sys +idTab = {}; + +class UnknownIdentifier(Exception): + pass + +class DivByZero(Exception): + pass + + + +# This class defines a complete listener for a parse tree produced by AritParser. +class AritListener(ParseTreeListener): + + # Enter a parse tree produced by AritParser#prog. + def enterProg(self, ctx:AritParser.ProgContext): + pass + + # Exit a parse tree produced by AritParser#prog. + def exitProg(self, ctx:AritParser.ProgContext): + pass + + + +del AritParser \ No newline at end of file diff --git a/TP02/ariteval/AritParser.py b/TP02/ariteval/AritParser.py new file mode 100644 index 0000000..369e7b4 --- /dev/null +++ b/TP02/ariteval/AritParser.py @@ -0,0 +1,110 @@ +# Generated from Arit.g4 by ANTLR 4.9.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +# header - mettre les d??clarations globales +import sys +idTab = {}; + +class UnknownIdentifier(Exception): + pass + +class DivByZero(Exception): + pass + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\6") + buf.write("\b\4\2\t\2\3\2\3\2\3\2\3\2\2\2\3\2\2\2\2\6\2\4\3\2\2\2") + buf.write("\4\5\7\4\2\2\5\6\b\2\1\2\6\3\3\2\2\2\2") + return buf.getvalue() + + +class AritParser ( Parser ): + + grammarFileName = "Arit.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ ] + + symbolicNames = [ "", "COMMENT", "ID", "INT", "WS" ] + + RULE_prog = 0 + + ruleNames = [ "prog" ] + + EOF = Token.EOF + COMMENT=1 + ID=2 + INT=3 + WS=4 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class ProgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self._ID = None # Token + + def ID(self): + return self.getToken(AritParser.ID, 0) + + def getRuleIndex(self): + return AritParser.RULE_prog + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProg" ): + listener.enterProg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProg" ): + listener.exitProg(self) + + + + + def prog(self): + + localctx = AritParser.ProgContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_prog) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2 + localctx._ID = self.match(AritParser.ID) + print("prog = "+str((None if localctx._ID is None else localctx._ID.text))); + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/TP02/ariteval/tree.dot b/TP02/ariteval/tree.dot new file mode 100644 index 0000000..7e64e30 --- /dev/null +++ b/TP02/ariteval/tree.dot @@ -0,0 +1,5 @@ +digraph { + 139921865517408 [label=prog] + 139921863565696 [label=Hello] + 139921865517408 -> 139921863565696 +} diff --git a/TP02/ariteval/tree.dot.pdf b/TP02/ariteval/tree.dot.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f52b906ee995ae2b806c5362d7087d74c06b43a6 GIT binary patch literal 5287 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 TQ3*J7O)QNJxl~nM{oS|#Q1y~h literal 0 HcmV?d00001 diff --git a/TP02/demo_files/ex1/Example1.py b/TP02/demo_files/ex1/Example1.py new file mode 100644 index 0000000..bdc667e --- /dev/null +++ b/TP02/demo_files/ex1/Example1.py @@ -0,0 +1,69 @@ +# Generated from Example1.g4 by ANTLR 4.9.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\t") + buf.write("*\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\4\b\t\b\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\5\7\5\33\n") + buf.write("\5\f\5\16\5\36\13\5\3\6\6\6!\n\6\r\6\16\6\"\3\6\3\6\3") + buf.write("\7\3\7\3\b\3\b\2\2\t\3\3\5\4\7\5\t\6\13\7\r\b\17\t\3\2") + buf.write("\6\5\2,-//\61\61\3\2\62;\4\2C\\c|\5\2\13\f\17\17\"\"\2") + buf.write(",\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13") + buf.write("\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\3\21\3\2\2\2\5\23\3") + buf.write("\2\2\2\7\25\3\2\2\2\t\27\3\2\2\2\13 \3\2\2\2\r&\3\2\2") + buf.write("\2\17(\3\2\2\2\21\22\t\2\2\2\22\4\3\2\2\2\23\24\t\3\2") + buf.write("\2\24\6\3\2\2\2\25\26\t\4\2\2\26\b\3\2\2\2\27\34\5\7\4") + buf.write("\2\30\33\5\7\4\2\31\33\5\5\3\2\32\30\3\2\2\2\32\31\3\2") + buf.write("\2\2\33\36\3\2\2\2\34\32\3\2\2\2\34\35\3\2\2\2\35\n\3") + buf.write("\2\2\2\36\34\3\2\2\2\37!\t\5\2\2 \37\3\2\2\2!\"\3\2\2") + buf.write("\2\" \3\2\2\2\"#\3\2\2\2#$\3\2\2\2$%\b\6\2\2%\f\3\2\2") + buf.write("\2&\'\7*\2\2\'\16\3\2\2\2()\7+\2\2)\20\3\2\2\2\6\2\32") + buf.write("\34\"\3\b\2\2") + return buf.getvalue() + + +class Example1(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + OP = 1 + DIGIT = 2 + LETTER = 3 + ID = 4 + WS = 5 + OPENP = 6 + ENDP = 7 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'('", "')'" ] + + symbolicNames = [ "", + "OP", "DIGIT", "LETTER", "ID", "WS", "OPENP", "ENDP" ] + + ruleNames = [ "OP", "DIGIT", "LETTER", "ID", "WS", "OPENP", "ENDP" ] + + grammarFileName = "Example1.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/TP02/demo_files/ex2/Example2Lexer.py b/TP02/demo_files/ex2/Example2Lexer.py new file mode 100644 index 0000000..f748f70 --- /dev/null +++ b/TP02/demo_files/ex2/Example2Lexer.py @@ -0,0 +1,64 @@ +# Generated from Example2.g4 by ANTLR 4.9.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\7") + buf.write("\"\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\3\2\3\2") + buf.write("\3\3\3\3\3\4\6\4\23\n\4\r\4\16\4\24\3\5\6\5\30\n\5\r\5") + buf.write("\16\5\31\3\6\6\6\35\n\6\r\6\16\6\36\3\6\3\6\2\2\7\3\3") + buf.write("\5\4\7\5\t\6\13\7\3\2\5\5\2,-//\61\61\4\2C\\c|\5\2\13") + buf.write("\f\17\17\"\"\2$\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2") + buf.write("\t\3\2\2\2\2\13\3\2\2\2\3\r\3\2\2\2\5\17\3\2\2\2\7\22") + buf.write("\3\2\2\2\t\27\3\2\2\2\13\34\3\2\2\2\r\16\7=\2\2\16\4\3") + buf.write("\2\2\2\17\20\t\2\2\2\20\6\3\2\2\2\21\23\4\62;\2\22\21") + buf.write("\3\2\2\2\23\24\3\2\2\2\24\22\3\2\2\2\24\25\3\2\2\2\25") + buf.write("\b\3\2\2\2\26\30\t\3\2\2\27\26\3\2\2\2\30\31\3\2\2\2\31") + buf.write("\27\3\2\2\2\31\32\3\2\2\2\32\n\3\2\2\2\33\35\t\4\2\2\34") + buf.write("\33\3\2\2\2\35\36\3\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2") + buf.write("\37 \3\2\2\2 !\b\6\2\2!\f\3\2\2\2\6\2\24\31\36\3\b\2\2") + return buf.getvalue() + + +class Example2Lexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + T__0 = 1 + OP = 2 + INT = 3 + ID = 4 + WS = 5 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "';'" ] + + symbolicNames = [ "", + "OP", "INT", "ID", "WS" ] + + ruleNames = [ "T__0", "OP", "INT", "ID", "WS" ] + + grammarFileName = "Example2.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/TP02/demo_files/ex2/Example2Listener.py b/TP02/demo_files/ex2/Example2Listener.py new file mode 100644 index 0000000..602afd1 --- /dev/null +++ b/TP02/demo_files/ex2/Example2Listener.py @@ -0,0 +1,30 @@ +# Generated from Example2.g4 by ANTLR 4.9.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .Example2Parser import Example2Parser +else: + from Example2Parser import Example2Parser + +# This class defines a complete listener for a parse tree produced by Example2Parser. +class Example2Listener(ParseTreeListener): + + # Enter a parse tree produced by Example2Parser#full_expr. + def enterFull_expr(self, ctx:Example2Parser.Full_exprContext): + pass + + # Exit a parse tree produced by Example2Parser#full_expr. + def exitFull_expr(self, ctx:Example2Parser.Full_exprContext): + pass + + + # Enter a parse tree produced by Example2Parser#expr. + def enterExpr(self, ctx:Example2Parser.ExprContext): + pass + + # Exit a parse tree produced by Example2Parser#expr. + def exitExpr(self, ctx:Example2Parser.ExprContext): + pass + + + +del Example2Parser \ No newline at end of file diff --git a/TP02/demo_files/ex2/Example2Parser.py b/TP02/demo_files/ex2/Example2Parser.py new file mode 100644 index 0000000..2e8beb2 --- /dev/null +++ b/TP02/demo_files/ex2/Example2Parser.py @@ -0,0 +1,221 @@ +# Generated from Example2.g4 by ANTLR 4.9.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\7") + buf.write("\31\4\2\t\2\4\3\t\3\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\5") + buf.write("\3\17\n\3\3\3\3\3\3\3\7\3\24\n\3\f\3\16\3\27\13\3\3\3") + buf.write("\2\3\4\4\2\4\2\2\2\30\2\6\3\2\2\2\4\16\3\2\2\2\6\7\5\4") + buf.write("\3\2\7\b\7\3\2\2\b\t\7\2\2\3\t\3\3\2\2\2\n\13\b\3\1\2") + buf.write("\13\f\7\6\2\2\f\17\b\3\1\2\r\17\7\5\2\2\16\n\3\2\2\2\16") + buf.write("\r\3\2\2\2\17\25\3\2\2\2\20\21\f\5\2\2\21\22\7\4\2\2\22") + buf.write("\24\5\4\3\6\23\20\3\2\2\2\24\27\3\2\2\2\25\23\3\2\2\2") + buf.write("\25\26\3\2\2\2\26\5\3\2\2\2\27\25\3\2\2\2\4\16\25") + return buf.getvalue() + + +class Example2Parser ( Parser ): + + grammarFileName = "Example2.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "';'" ] + + symbolicNames = [ "", "", "OP", "INT", "ID", "WS" ] + + RULE_full_expr = 0 + RULE_expr = 1 + + ruleNames = [ "full_expr", "expr" ] + + EOF = Token.EOF + T__0=1 + OP=2 + INT=3 + ID=4 + WS=5 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class Full_exprContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def expr(self): + return self.getTypedRuleContext(Example2Parser.ExprContext,0) + + + def EOF(self): + return self.getToken(Example2Parser.EOF, 0) + + def getRuleIndex(self): + return Example2Parser.RULE_full_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFull_expr" ): + listener.enterFull_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFull_expr" ): + listener.exitFull_expr(self) + + + + + def full_expr(self): + + localctx = Example2Parser.Full_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_full_expr) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4 + self.expr(0) + self.state = 5 + self.match(Example2Parser.T__0) + self.state = 6 + self.match(Example2Parser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExprContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self._ID = None # Token + + def ID(self): + return self.getToken(Example2Parser.ID, 0) + + def INT(self): + return self.getToken(Example2Parser.INT, 0) + + def expr(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Example2Parser.ExprContext) + else: + return self.getTypedRuleContext(Example2Parser.ExprContext,i) + + + def OP(self): + return self.getToken(Example2Parser.OP, 0) + + def getRuleIndex(self): + return Example2Parser.RULE_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExpr" ): + listener.enterExpr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExpr" ): + listener.exitExpr(self) + + + + def expr(self, _p:int=0): + _parentctx = self._ctx + _parentState = self.state + localctx = Example2Parser.ExprContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 2 + self.enterRecursionRule(localctx, 2, self.RULE_expr, _p) + try: + self.enterOuterAlt(localctx, 1) + self.state = 12 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [Example2Parser.ID]: + self.state = 9 + localctx._ID = self.match(Example2Parser.ID) + print('oh an id : '+(None if localctx._ID is None else localctx._ID.text)) + pass + elif token in [Example2Parser.INT]: + self.state = 11 + self.match(Example2Parser.INT) + pass + else: + raise NoViableAltException(self) + + self._ctx.stop = self._input.LT(-1) + self.state = 19 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,1,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + localctx = Example2Parser.ExprContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) + self.state = 14 + if not self.precpred(self._ctx, 3): + from antlr4.error.Errors import FailedPredicateException + raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + self.state = 15 + self.match(Example2Parser.OP) + self.state = 16 + self.expr(4) + self.state = 21 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,1,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + + + def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): + if self._predicates == None: + self._predicates = dict() + self._predicates[1] = self.expr_sempred + pred = self._predicates.get(ruleIndex, None) + if pred is None: + raise Exception("No predicate with index:" + str(ruleIndex)) + else: + return pred(localctx, predIndex) + + def expr_sempred(self, localctx:ExprContext, predIndex:int): + if predIndex == 0: + return self.precpred(self._ctx, 3) + + + + + diff --git a/TP03/tree/Makefile b/TP03/tree/Makefile new file mode 100644 index 0000000..027b338 --- /dev/null +++ b/TP03/tree/Makefile @@ -0,0 +1,18 @@ +PACKAGE = Tree +MAINFILE = tree + +ifndef ANTLR4 +abort: + $(error variable ANTLR4 is not set) +endif + +all: $(PACKAGE).g4 + $(ANTLR4) $^ -Dlanguage=Python3 -visitor + +run: $(MAINFILE).py + python3 $^ + + +clean: + find . \( -iname "~" -or -iname "*.cache*" -or -iname "*.diff" -or -iname "log.txt" -or -iname "*.pyc" -or -iname "*.tokens" -or -iname "*.interp" \) -exec rm -rf '{}' \; + rm -rf $(PACKAGE)*.py diff --git a/TP03/tree/TreeLexer.py b/TP03/tree/TreeLexer.py new file mode 100644 index 0000000..1e045b1 --- /dev/null +++ b/TP03/tree/TreeLexer.py @@ -0,0 +1,60 @@ +# Generated from Tree.g4 by ANTLR 4.9.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\6") + buf.write("\33\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\3\2\3\2\3\3\3") + buf.write("\3\3\4\6\4\21\n\4\r\4\16\4\22\3\5\6\5\26\n\5\r\5\16\5") + buf.write("\27\3\5\3\5\2\2\6\3\3\5\4\7\5\t\6\3\2\4\3\2\62;\4\2\13") + buf.write("\f\"\"\2\34\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3") + buf.write("\2\2\2\3\13\3\2\2\2\5\r\3\2\2\2\7\20\3\2\2\2\t\25\3\2") + buf.write("\2\2\13\f\7*\2\2\f\4\3\2\2\2\r\16\7+\2\2\16\6\3\2\2\2") + buf.write("\17\21\t\2\2\2\20\17\3\2\2\2\21\22\3\2\2\2\22\20\3\2\2") + buf.write("\2\22\23\3\2\2\2\23\b\3\2\2\2\24\26\t\3\2\2\25\24\3\2") + buf.write("\2\2\26\27\3\2\2\2\27\25\3\2\2\2\27\30\3\2\2\2\30\31\3") + buf.write("\2\2\2\31\32\b\5\2\2\32\n\3\2\2\2\5\2\22\27\3\b\2\2") + return buf.getvalue() + + +class TreeLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + T__0 = 1 + T__1 = 2 + INT = 3 + WS = 4 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'('", "')'" ] + + symbolicNames = [ "", + "INT", "WS" ] + + ruleNames = [ "T__0", "T__1", "INT", "WS" ] + + grammarFileName = "Tree.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/TP03/tree/TreeListener.py b/TP03/tree/TreeListener.py new file mode 100644 index 0000000..17451a7 --- /dev/null +++ b/TP03/tree/TreeListener.py @@ -0,0 +1,39 @@ +# Generated from Tree.g4 by ANTLR 4.9.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .TreeParser import TreeParser +else: + from TreeParser import TreeParser + +# This class defines a complete listener for a parse tree produced by TreeParser. +class TreeListener(ParseTreeListener): + + # Enter a parse tree produced by TreeParser#top. + def enterTop(self, ctx:TreeParser.TopContext): + pass + + # Exit a parse tree produced by TreeParser#top. + def exitTop(self, ctx:TreeParser.TopContext): + pass + + + # Enter a parse tree produced by TreeParser#leaf. + def enterLeaf(self, ctx:TreeParser.LeafContext): + pass + + # Exit a parse tree produced by TreeParser#leaf. + def exitLeaf(self, ctx:TreeParser.LeafContext): + pass + + + # Enter a parse tree produced by TreeParser#node. + def enterNode(self, ctx:TreeParser.NodeContext): + pass + + # Exit a parse tree produced by TreeParser#node. + def exitNode(self, ctx:TreeParser.NodeContext): + pass + + + +del TreeParser \ No newline at end of file diff --git a/TP03/tree/TreeParser.py b/TP03/tree/TreeParser.py new file mode 100644 index 0000000..a1d5b1b --- /dev/null +++ b/TP03/tree/TreeParser.py @@ -0,0 +1,247 @@ +# Generated from Tree.g4 by ANTLR 4.9.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\6") + buf.write("\26\4\2\t\2\4\3\t\3\3\2\3\2\3\2\3\3\3\3\3\3\3\3\6\3\16") + buf.write("\n\3\r\3\16\3\17\3\3\3\3\5\3\24\n\3\3\3\2\2\4\2\4\2\2") + buf.write("\2\25\2\6\3\2\2\2\4\23\3\2\2\2\6\7\5\4\3\2\7\b\7\2\2\3") + buf.write("\b\3\3\2\2\2\t\24\7\5\2\2\n\13\7\3\2\2\13\r\7\5\2\2\f") + buf.write("\16\5\4\3\2\r\f\3\2\2\2\16\17\3\2\2\2\17\r\3\2\2\2\17") + buf.write("\20\3\2\2\2\20\21\3\2\2\2\21\22\7\4\2\2\22\24\3\2\2\2") + buf.write("\23\t\3\2\2\2\23\n\3\2\2\2\24\5\3\2\2\2\4\17\23") + return buf.getvalue() + + +class TreeParser ( Parser ): + + grammarFileName = "Tree.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'('", "')'" ] + + symbolicNames = [ "", "", "", "INT", "WS" ] + + RULE_int_tree_top = 0 + RULE_int_tree = 1 + + ruleNames = [ "int_tree_top", "int_tree" ] + + EOF = Token.EOF + T__0=1 + T__1=2 + INT=3 + WS=4 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.9.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class Int_tree_topContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TreeParser.RULE_int_tree_top + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class TopContext(Int_tree_topContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TreeParser.Int_tree_topContext + super().__init__(parser) + self.copyFrom(ctx) + + def int_tree(self): + return self.getTypedRuleContext(TreeParser.Int_treeContext,0) + + def EOF(self): + return self.getToken(TreeParser.EOF, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTop" ): + listener.enterTop(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTop" ): + listener.exitTop(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTop" ): + return visitor.visitTop(self) + else: + return visitor.visitChildren(self) + + + + def int_tree_top(self): + + localctx = TreeParser.Int_tree_topContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_int_tree_top) + try: + localctx = TreeParser.TopContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 4 + self.int_tree() + self.state = 5 + self.match(TreeParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Int_treeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TreeParser.RULE_int_tree + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class NodeContext(Int_treeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TreeParser.Int_treeContext + super().__init__(parser) + self.copyFrom(ctx) + + def INT(self): + return self.getToken(TreeParser.INT, 0) + def int_tree(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TreeParser.Int_treeContext) + else: + return self.getTypedRuleContext(TreeParser.Int_treeContext,i) + + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNode" ): + listener.enterNode(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNode" ): + listener.exitNode(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNode" ): + return visitor.visitNode(self) + else: + return visitor.visitChildren(self) + + + class LeafContext(Int_treeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TreeParser.Int_treeContext + super().__init__(parser) + self.copyFrom(ctx) + + def INT(self): + return self.getToken(TreeParser.INT, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLeaf" ): + listener.enterLeaf(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLeaf" ): + listener.exitLeaf(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitLeaf" ): + return visitor.visitLeaf(self) + else: + return visitor.visitChildren(self) + + + + def int_tree(self): + + localctx = TreeParser.Int_treeContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_int_tree) + self._la = 0 # Token type + try: + self.state = 17 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [TreeParser.INT]: + localctx = TreeParser.LeafContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 7 + self.match(TreeParser.INT) + pass + elif token in [TreeParser.T__0]: + localctx = TreeParser.NodeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 8 + self.match(TreeParser.T__0) + self.state = 9 + self.match(TreeParser.INT) + self.state = 11 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 10 + self.int_tree() + self.state = 13 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==TreeParser.T__0 or _la==TreeParser.INT): + break + + self.state = 15 + self.match(TreeParser.T__1) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/TP03/tree/TreeVisitor.py b/TP03/tree/TreeVisitor.py new file mode 100644 index 0000000..e2a63ba --- /dev/null +++ b/TP03/tree/TreeVisitor.py @@ -0,0 +1,28 @@ +# Generated from Tree.g4 by ANTLR 4.9.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .TreeParser import TreeParser +else: + from TreeParser import TreeParser + +# This class defines a complete generic visitor for a parse tree produced by TreeParser. + +class TreeVisitor(ParseTreeVisitor): + + # Visit a parse tree produced by TreeParser#top. + def visitTop(self, ctx:TreeParser.TopContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TreeParser#leaf. + def visitLeaf(self, ctx:TreeParser.LeafContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TreeParser#node. + def visitNode(self, ctx:TreeParser.NodeContext): + return self.visitChildren(ctx) + + + +del TreeParser \ No newline at end of file diff --git a/TP03/tree/main.py b/TP03/tree/main.py new file mode 100644 index 0000000..3e3c8d6 --- /dev/null +++ b/TP03/tree/main.py @@ -0,0 +1,35 @@ +from TreeLexer import TreeLexer +from TreeParser import TreeParser +from TreeVisitor import TreeVisitor + +from antlr4 import InputStream, CommonTokenStream +import sys + +class MyTreeVisitor(TreeVisitor): + def visitLeaf(self, ctx): + return True + + def visitNode(self, ctx): + nodes = ctx.int_tree(); + if(len(nodes)>2): + return False + for node in nodes: + if(not self.visit(node)): + return False + return True + + def visitTop(self, ctx): + return self.visit(ctx.int_tree()) + +def main(): + lexer = TreeLexer(InputStream(sys.stdin.read())) + stream = CommonTokenStream(lexer) + parser = TreeParser(stream) + tree = parser.int_tree_top() + visitor = MyTreeVisitor() + b = visitor.visit(tree) + print("Is it a binary tree ? " + str(b)) + + +if __name__ == '__main__': + main()