Re: optimization/8092: cross-jump triggers too often

Re: optimization/8092: cross-jump triggers too often

[Jorge Acereda Maciá]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: =?ISO-8859-1?Q?Jorge_Acereda_Maci=E1?= <drslump@ono.com>
To: gcc-gnats@gcc.gnu.org,
 gcc-bugs@gcc.gnu.org,
 nobody@gcc.gnu.org,
 bernd.paysan@gmx.de,
 gcc-prs@gcc.gnu.org
Cc:  
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Wed, 26 Feb 2003 19:04:44 +0100

 http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit- 
 trail&database=gcc&pr=8092
 
 I have also faced this problem in ARM devices when compiling our own  
 threaded interpreter. I for one would love to see this patch or an  
 equivalent applied.
 

Re: optimization/8092: cross-jump triggers too often

[neroden]

Synopsis: cross-jump triggers too often

State-Changed-From-To: feedback->open
State-Changed-By: neroden
State-Changed-When: Sun Feb 23 21:10:23 2003
State-Changed-Why:
    What's this doing in feedback?  It seems to be a genuine pessimization.

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8092

Re: optimization/8092: cross-jump triggers too often

[Bernd Paysan]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Bernd Paysan <bernd.paysan@gmx.de>
To: Daniel Berlin <dberlin@dberlin.org>
Cc: anton@mips.complang.tuwien.ac.at,
        Anton Ertl <anton@a0.complang.tuwien.ac.at>, <rth@gcc.gnu.org>,
        <gcc-bugs@gcc.gnu.org>, <gcc-gnats@gcc.gnu.org>
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Mon, 7 Oct 2002 13:25:22 +0200

 On Monday 07 October 2002 00:19, Daniel Berlin wrote:
 > In your case, all blocks have abnormal edges to all other blocks. This
 > requires it to end up inserting everywhere because all blocks lead
 > to all other blocks.
 > It's still optimal, given this CFG.
 > You just "know" more than the compiler, so you think it's wrong.
 
 I agree that I know more than the compiler. However, I can provide benchm=
 ark=20
 results that this is a pessimation - it's not just that I'm just "thinkin=
 g"=20
 that it's wrong. The code forms a threaded interpreter, and each basic=20
 block has to be considered as an "instruction" of that interpreter. Movin=
 g=20
 code from one instruction to all others makes each instruction more=20
 expensive, except the one the instruction is moved out from.
 
 > Because it's lifetime optimal, so it can't possibly have made the
 > expression live longer than it used to, and thus, it has always improve=
 d
 > the code (in terms of number of calculations).
 
 Ah, no. The expression in one control flow branch might not live at all.=20
 There's just a chance that it gets computed. By copying the expression to=
 =20
 all other branches, it will be computed. Always.
 
 > Not necessarily. You assume the code is completely straight line.
 > GCSE should never make an expression be calculated *more times* than it
 > used to be (probably some corner case i'm forgetting about).
 > That's the whole point.
 > GCSE makes the number of calculations along a given path optimal in
 > number, not in cost.
 
 Since it increases the number of calculations along another path, there m=
 ust=20
 be something wrong.
 
 The example I gave had pathes like that
 
           /- return calc---\
           |- calc sterr----|
           |- calc stdout---|
 goto *ip -|- calc stdin----|-reiterate
           |- calc 12-------|
           |- calc 123------|
           \- calc 1234-----/
 
 And it becomes
 
           /- return calc-------------------------\
           |- calc sterr, stdout, stdin-----------|
           |- calc sterr, stdout, stdin-----------|
 goto *ip -|- calc sterr, stdout, stdin-----------|-\
      ^    |- calc sterr, stdout, stdin, 12-------| |
      |    |- calc sterr, stdout, stdin, 123------| |
      |    \- calc sterr, stdout, stdin, 1234-----/ /
      \____________________________________________/
 
 Now you tell me that this doesn't increase the number of calculations don=
 e=20
 in a path. I can't follow you here.
 
 > Cost optimal code motion often makes the lifetime of an expression way
 > too long.
 >
 > I suggest you read papers on Lazy Code Motion, and cost optimal code
 > motion.
 
 I suggest doing some benchmarks. E.g. with Gforth. The slowdown by doing =
 the=20
 "lazy code motion" are tremendous. Primitives that have 3 instructions gr=
 ow=20
 to 50 or more. This increases code size and execution time by a huge amou=
 nt=20
 (ok, cross-jump reduces the size, but the execution time increases even=20
 further). Sometimes, the real world differs from assumptions in papers ;-=
 ).
 
 --=20
 Bernd Paysan
 "If you want it done right, you have to do it yourself"
 http://www.jwdt.com/~paysan/
 

Re: optimization/8092: cross-jump triggers too often

[Daniel Berlin]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Daniel Berlin <dberlin@dberlin.org>
To: Bernd Paysan <bernd.paysan@gmx.de>
Cc: anton@mips.complang.tuwien.ac.at,
	Anton Ertl <anton@a0.complang.tuwien.ac.at>, <rth@gcc.gnu.org>,
	<gcc-bugs@gcc.gnu.org>, <gcc-prs@gcc.gnu.org>, <obody@gcc.gnu.org>,
	<gcc-gnats@gcc.gnu.org>
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Sun, 6 Oct 2002 18:19:44 -0400 (EDT)

 On Sun, 6 Oct 2002, Bernd Paysan wrote:
 
 > 
 > Compile with -O2 -fno-cross-jump to see how the initializing code for "global 
 > expressions" like stdout/stderr gets cluttered all over the place. The dump 
 > obtained with -dG shows which expression is copied:
 > 
 > GCSE pass 1
 > 
 > SET hash table (11 buckets, 3 entries)
 > Index 0 (hash value 5)
 >   (set (reg/v:SI 60)
 >     (const_int 12 [0xc]))
 > Index 1 (hash value 6)
 >   (set (reg/v:SI 61)
 >     (const_int 123 [0x7b]))
 > Index 2 (hash value 7)
 >   (set (reg/v:SI 62)
 >     (const_int 1234 [0x4d2]))
 > 
 > 
 > LDST list: 
 >   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stderr")) [5 stderr+0 S4 A32])
 > 	 Loads : (insn_list 42 (nil))
 > 	Stores : (nil)
 > 
 >   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stdout")) [5 stdout+0 S4 A32])
 > 	 Loads : (insn_list 28 (nil))
 > 	Stores : (nil)
 > 
 >   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stdin")) [5 stdin+0 S4 A32])
 > 	 Loads : (insn_list 14 (nil))
 > 	Stores : (nil)
 > 
 > 
 > Expression hash table (15 buckets, 5 entries)
 > Index 0 (hash value 7)
 >   (mem/f:SI (symbol_ref:SI ("stdin")) [5 stdin+0 S4 A32])
 > Index 1 (hash value 2)
 >   (mem:SI (reg/v/f:SI 59) [4 S4 A32])
 > Index 2 (hash value 12)
 >   (plus:SI (reg/v/f:SI 59)
 >     (const_int 4 [0x4]))
 > Index 3 (hash value 7)
 >   (mem/f:SI (symbol_ref:SI ("stdout")) [5 stdout+0 S4 A32])
 > Index 4 (hash value 8)
 >   (mem/f:SI (symbol_ref:SI ("stderr")) [5 stderr+0 S4 A32])
 > 
 > PRE: redundant insn 14 (expression 0) in bb 1, reaching reg is 77
 > PRE: redundant insn 28 (expression 3) in bb 2, reaching reg is 78
 > PRE: redundant insn 42 (expression 4) in bb 3, reaching reg is 79
 > PRE/HOIST: edge (0,1), copy expression 0
 > PRE/HOIST: end of bb 1, insn 139, copying expression 3 to reg 78
 > PRE/HOIST: edge (1,2), copy expression 3
 > PRE/HOIST: end of bb 1, insn 142, copying expression 4 to reg 79
 > PRE/HOIST: edge (1,3), copy expression 4
 > PRE/HOIST: end of bb 2, insn 145, copying expression 4 to reg 79
 > PRE/HOIST: edge (2,3), copy expression 4
 > PRE/HOIST: end of bb 3, insn 148, copying expression 3 to reg 78
 > PRE/HOIST: edge (3,2), copy expression 3
 > PRE/HOIST: end of bb 4, insn 151, copying expression 3 to reg 78
 > PRE/HOIST: edge (4,2), copy expression 3
 > PRE/HOIST: end of bb 4, insn 154, copying expression 4 to reg 79
 > PRE/HOIST: edge (4,3), copy expression 4
 > PRE/HOIST: end of bb 5, insn 157, copying expression 3 to reg 78
 > PRE/HOIST: edge (5,2), copy expression 3
 > PRE/HOIST: end of bb 5, insn 160, copying expression 4 to reg 79
 > PRE/HOIST: edge (5,3), copy expression 4
 > PRE/HOIST: end of bb 6, insn 163, copying expression 3 to reg 78
 > PRE/HOIST: edge (6,2), copy expression 3
 > PRE/HOIST: end of bb 6, insn 166, copying expression 4 to reg 79
 > PRE/HOIST: edge (6,3), copy expression 4
 > 
 > PRE GCSE of foo, pass 1: 4072 bytes needed, 3 substs, 21 insns created
 > 
 > Apparently, GCSE copies constant expressions that seem to be "sufficiently 
 > complicated" all over the place. Although, in this case, the target 
 > architecture implements (mem/f (symbol_ref xxx)) with the same instruction as 
 > (const_int xxx), which is not copied. If I "poison" symbol_ref expressions in 
 > gcse.c (so that they aren't considdered), I still get a few redundant 
 > expressions spread all over the place, e.g. increments of the stack pointer 
 > (which happen fairly often, but doing so in advance is stupid).
 > 
 > As far as I understood the code, gcse.c copies "partially redundant" 
 > expressions throughout the entire CFG
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 Not the entire CFG, only where it is necessary to make them fully 
 available, so it can remove a later use.
 
 In your case, all blocks have abnormal edges to all other blocks. This 
 requires it to end up inserting everywhere because all blocks lead 
 to all other blocks.
 It's still optimal, given this CFG.
 You just "know" more than the compiler, so you think it's wrong.
 
 
 > to "make them fully redundant". That's 
 > what's happening here. How can an expression that occurs only once be 
 > "redundant"?
 
 It's not, it appears load motion is being stupid, and not checking 
 if a load occurs more than once.
 
 > And why doesn't gcse.c try to remove copied expressions 
 > afterwards after it finds out that the attempt to improve the code has 
 > failed? 
 Because it's lifetime optimal, so it can't possibly have made the 
 expression live longer than it used to, and thus, it has always improved 
 the code (in terms of number of calculations).
 
 Now, if you want it *cost* optimal, that's a slightly different 
 algorithm.
 
 >And why is there no cost calculation? If you copy an expression from 
 > one block to m blocks, the costs are multiplied by m.
 
 Not necessarily. You assume the code is completely straight line.
 GCSE should never make an expression be calculated *more times* than it 
 used to be (probably some corner case i'm forgetting about).
 That's the whole point.
 GCSE makes the number of calculations along a given path optimal in 
 number, not in cost.
 
 Cost optimal code motion often makes the lifetime of an expression way too 
 long.
 
 I suggest you read papers on Lazy Code Motion, and cost optimal code 
 motion.
 
 
 
 > 
 > 
 
 
 

Re: optimization/8092: cross-jump triggers too often

[Bernd Paysan]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Bernd Paysan <bernd.paysan@gmx.de>
To: anton@mips.complang.tuwien.ac.at,
	Anton Ertl <anton@a0.complang.tuwien.ac.at>, rth@gcc.gnu.org,
	gcc-bugs@gcc.gnu.org, gcc-prs@gcc.gnu.org, obody@gcc.gnu.org,
	gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Sun, 6 Oct 2002 21:40:46 +0200

 On Saturday 05 October 2002 11:57, Anton Ertl wrote:
 > 2) Fix the bug that moves unrelated code into virtual machine
 > instructions even with -fno-gcse; we can work around that in the
 > present case (not yet done in the timings above), but at least I did
 > not find the source of this code and thus the workaround.
 
 I also suggest fixing the bug that moves unrelated code around within GCS=
 E.=20
 The code I've seen moved around is access to static pointers, like=20
 stdin/stdout, __ctype_toupper, and so on. This indicates that the constan=
 t=20
 propagation code has some bugs in it. The following code illustrates this=
 :
 
 #include <stdio.h>
 int foo (void ** code)
 {
   static void * symbols[] =3D { &&label1, &&label2, &&label3, &&label4,=20
 &&label5, &&label6, &&label7 };
   int a, b, c;
  label1:
   a =3D (int)stdin;
   goto **(code++);
  label2:
   b =3D (int)stdout;
   goto **(code++);
  label3:
   c =3D (int)stderr;
   goto **(code++);
  label4:
   a =3D 12;
   goto **(code++);
  label5:
   b =3D 123;
   goto **(code++);
  label6:
   c =3D 1234;
   goto **(code++);
  label7:
   return a^b^c;
 }
 
 Compile with -O2 -fno-cross-jump to see how the initializing code for "gl=
 obal=20
 expressions" like stdout/stderr gets cluttered all over the place. The du=
 mp=20
 obtained with -dG shows which expression is copied:
 
 GCSE pass 1
 
 SET hash table (11 buckets, 3 entries)
 Index 0 (hash value 5)
   (set (reg/v:SI 60)
     (const_int 12 [0xc]))
 Index 1 (hash value 6)
   (set (reg/v:SI 61)
     (const_int 123 [0x7b]))
 Index 2 (hash value 7)
   (set (reg/v:SI 62)
     (const_int 1234 [0x4d2]))
 
 
 LDST list:=20
   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stderr")) [5 stderr+0 S4 A32]=
 )
 =09 Loads : (insn_list 42 (nil))
 =09Stores : (nil)
 
   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stdout")) [5 stdout+0 S4 A32]=
 )
 =09 Loads : (insn_list 28 (nil))
 =09Stores : (nil)
 
   Pattern (  0): (mem/f:SI (symbol_ref:SI ("stdin")) [5 stdin+0 S4 A32])
 =09 Loads : (insn_list 14 (nil))
 =09Stores : (nil)
 
 
 Expression hash table (15 buckets, 5 entries)
 Index 0 (hash value 7)
   (mem/f:SI (symbol_ref:SI ("stdin")) [5 stdin+0 S4 A32])
 Index 1 (hash value 2)
   (mem:SI (reg/v/f:SI 59) [4 S4 A32])
 Index 2 (hash value 12)
   (plus:SI (reg/v/f:SI 59)
     (const_int 4 [0x4]))
 Index 3 (hash value 7)
   (mem/f:SI (symbol_ref:SI ("stdout")) [5 stdout+0 S4 A32])
 Index 4 (hash value 8)
   (mem/f:SI (symbol_ref:SI ("stderr")) [5 stderr+0 S4 A32])
 
 PRE: redundant insn 14 (expression 0) in bb 1, reaching reg is 77
 PRE: redundant insn 28 (expression 3) in bb 2, reaching reg is 78
 PRE: redundant insn 42 (expression 4) in bb 3, reaching reg is 79
 PRE/HOIST: edge (0,1), copy expression 0
 PRE/HOIST: end of bb 1, insn 139, copying expression 3 to reg 78
 PRE/HOIST: edge (1,2), copy expression 3
 PRE/HOIST: end of bb 1, insn 142, copying expression 4 to reg 79
 PRE/HOIST: edge (1,3), copy expression 4
 PRE/HOIST: end of bb 2, insn 145, copying expression 4 to reg 79
 PRE/HOIST: edge (2,3), copy expression 4
 PRE/HOIST: end of bb 3, insn 148, copying expression 3 to reg 78
 PRE/HOIST: edge (3,2), copy expression 3
 PRE/HOIST: end of bb 4, insn 151, copying expression 3 to reg 78
 PRE/HOIST: edge (4,2), copy expression 3
 PRE/HOIST: end of bb 4, insn 154, copying expression 4 to reg 79
 PRE/HOIST: edge (4,3), copy expression 4
 PRE/HOIST: end of bb 5, insn 157, copying expression 3 to reg 78
 PRE/HOIST: edge (5,2), copy expression 3
 PRE/HOIST: end of bb 5, insn 160, copying expression 4 to reg 79
 PRE/HOIST: edge (5,3), copy expression 4
 PRE/HOIST: end of bb 6, insn 163, copying expression 3 to reg 78
 PRE/HOIST: edge (6,2), copy expression 3
 PRE/HOIST: end of bb 6, insn 166, copying expression 4 to reg 79
 PRE/HOIST: edge (6,3), copy expression 4
 
 PRE GCSE of foo, pass 1: 4072 bytes needed, 3 substs, 21 insns created
 
 Apparently, GCSE copies constant expressions that seem to be "sufficientl=
 y=20
 complicated" all over the place. Although, in this case, the target=20
 architecture implements (mem/f (symbol_ref xxx)) with the same instructio=
 n as=20
 (const_int xxx), which is not copied. If I "poison" symbol_ref expression=
 s in=20
 gcse.c (so that they aren't considdered), I still get a few redundant=20
 expressions spread all over the place, e.g. increments of the stack point=
 er=20
 (which happen fairly often, but doing so in advance is stupid).
 
 As far as I understood the code, gcse.c copies "partially redundant"=20
 expressions throughout the entire CFG to "make them fully redundant". Tha=
 t's=20
 what's happening here. How can an expression that occurs only once be=20
 "redundant"? And why doesn't gcse.c try to remove copied expressions=20
 afterwards after it finds out that the attempt to improve the code has=20
 failed? And why is there no cost calculation? If you copy an expression f=
 rom=20
 one block to m blocks, the costs are multiplied by m.
 
 --=20
 Bernd Paysan
 "If you want it done right, you have to do it yourself"
 http://www.jwdt.com/~paysan/
 

Re: optimization/8092: cross-jump triggers too often

[Bernd Paysan]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Bernd Paysan <bernd.paysan@gmx.de>
To: anton@mips.complang.tuwien.ac.at,
	Anton Ertl <anton@a0.complang.tuwien.ac.at>, rth@gcc.gnu.org,
	gcc-bugs@gcc.gnu.org, gcc-prs@gcc.gnu.org, obody@gcc.gnu.org,
	gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Sat, 5 Oct 2002 22:44:35 +0200

 On Saturday 05 October 2002 11:57, Anton Ertl wrote:
 > 1) Add a -fno-cross-jump flag or similar, as in Bernd's patch.
 
 I had a closer look to the cross-jump code, and it does indeed add a cros=
 sjump=20
 to every single equivalent insn it finds (which is stupid - jumps are mor=
 e=20
 expensive than single instructions). I added another flag as experiment,=20
 -fcross-jump-min=3D<n>, which eliminates cross-jumps for less than n insn=
 s.=20
 However, due to the way the crossjump search works, this increases compil=
 e=20
 time by quite a lot, due to the O(n=B2) order of the crossjump comparison=
 =20
 algorithm. It's probably cheaper to first do the crossjump optimization, =
 and=20
 then to clean up those that weren't cost-efficient (tail-duplication).
 
 And tell me how cross-jump is a performance optimization. I can only see =
 it as=20
 possible size optimization, but these should only be turned on with -Os.
 
 --- gcc-3.2/gcc/cfgcleanup.c.orig=092002-10-05 22:15:17.000000000 +0200
 +++ gcc-3.2/gcc/cfgcleanup.c=092002-10-05 22:16:45.000000000 +0200
 @@ -1278,6 +1278,7 @@
       edge e1, e2;
  {
    int nmatch;
 +  extern int cross_jump_min;
    basic_block src1 =3D e1->src, src2 =3D e2->src;
    basic_block redirect_to;
    rtx newpos1, newpos2;
 @@ -1323,7 +1324,7 @@
 =20
    /* ... and part the second.  */
    nmatch =3D flow_find_cross_jump (mode, src1, src2, &newpos1, &newpos2)=
 ;
 -  if (!nmatch)
 +  if (nmatch < cross_jump_min)
      return false;
 =20
    /* Avoid splitting if possible.  */
 --- gcc-3.2/gcc/toplev.c.orig=092002-05-27 07:48:15.000000000 +0200
 +++ gcc-3.2/gcc/toplev.c=092002-10-05 22:16:47.000000000 +0200
 @@ -610,6 +610,11 @@
 =20
  int flag_syntax_only =3D 0;
 =20
 +/* Nonzero means perform crossjump optimization. */
 +
 +static int flag_crossjump =3D 0;
 +int cross_jump_min;
 +
  /* Nonzero means perform global cse.  */
 =20
  static int flag_gcse;
 @@ -1023,6 +1028,8 @@
     N_("Return 'short' aggregates in registers") },
    {"delayed-branch", &flag_delayed_branch, 1,
     N_("Attempt to fill delay slots of branch instructions") },
 +  {"cross-jump", &flag_crossjump, 1,
 +   N_("Perform crossjump optimization") },
    {"gcse", &flag_gcse, 1,
     N_("Perform the global common subexpression elimination") },
    {"gcse-lm", &flag_gcse_lm, 1,
 @@ -3286,7 +3293,7 @@
    /* Cross-jumping is O(N^3) on the number of edges, thus trying to
       perform cross-jumping on flow graphs which have a high connectivity
       will take a long time.  This is similar to the test to disable GCSE=
 =2E  */
 -  cleanup_crossjump =3D CLEANUP_CROSSJUMP;
 +  cleanup_crossjump =3D flag_crossjump ? CLEANUP_CROSSJUMP : 0;
    if (n_basic_blocks > 1000 && n_edges / n_basic_blocks >=3D 20)
      {
        if (optimize && warn_disabled_optimization)
 @@ -3907,6 +3914,8 @@
    else if ((option_value =3D skip_leading_substring (arg, "align-labels=3D=
 ")))
      align_labels
        =3D read_integral_parameter (option_value, arg - 2, align_labels);
 +  else if ((option_value =3D skip_leading_substring (arg, "cross-jump-mi=
 n=3D")))
 +    cross_jump_min =3D read_integral_parameter (option_value, arg - 2,=20
 cross_jump_min);
    else if ((option_value
  =09    =3D skip_leading_substring (arg, "stack-limit-register=3D")))
      {
 @@ -4701,6 +4710,8 @@
        flag_optimize_sibling_calls =3D 1;
        flag_cse_follow_jumps =3D 1;
        flag_cse_skip_blocks =3D 1;
 +      flag_crossjump =3D 1;
 +      cross_jump_min =3D 1;
        flag_gcse =3D 1;
        flag_expensive_optimizations =3D 1;
        flag_strength_reduce =3D 1;
 -------------------------------------------------------------------------=
 ---
 
 --=20
 Bernd Paysan
 "If you want it done right, you have to do it yourself"
 http://www.jwdt.com/~paysan/
 

Re: optimization/8092: cross-jump triggers too often

[Anton Ertl]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Anton Ertl <anton@a0.complang.tuwien.ac.at>
To: bernd.paysan@gmx.de, rth@gcc.gnu.org, gcc-bugs@gcc.gnu.org,
        gcc-prs@gcc.gnu.org, obody@gcc.gnu.org, gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Sat, 5 Oct 2002 11:57:34 +0200 (MET DST)

 PR 8092 reports essentially the same problems as
 
 http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&pr=7953
 
 Here's some additional data to give you an idea how far the thumb is
 sticking out:
 
 Here you see user times of four benchmarks in seconds (i.e. smaller is
 better) on a Pentium 4 2.26GHz:
 
 Overall slowdown from gcc-3.2 is around a factor of 5:
 
 0.26    0.29    0.32    0.37 gcc-2.95.3 with explicit reg vars
 1.20    1.46    1.79    1.96 gcc-3.2 with explicit reg vars
 
 Indirect slowdown from disabling Piumarta-style interpreter inlining
 is around a factor 2.5 (interpreter inlining does not work with
 gcc-3.2 thanks to cross-jumping):
 
 0.26    0.29    0.32    0.37 gcc-2.95.3 with reg vars
 0.62    0.76    1.15    0.89 gcc-2.95.3 with reg vars, --no-dynamic
 
 Direct slowdown from gcc-3.2 pessimisations is around a factor of 2:
 
 0.62    0.76    1.15    0.89 gcc-2.95.3 with reg vars, --no-dynamic
 1.20    1.46    1.79    1.96 gcc-3.2 with explicit reg vars
 
 Note that at least the direct slowdowns will apply to all threaded
 code interpreters (e.g. Gforth, Ocaml bytecode, various Prolog
 implementations, possibly Perl6), and maybe to other interpreters as
 well.
 
 As for the explicit reg vars, these are optional and used just because
 it produces faster code than gcc's register allocation; for platforms
 where gcc does well on its own, we don't define explicit register
 variables; hopefully one day the 386 platform will be among those.
 Giving an internal compiler error when explicit register allocation
 does not work is fine with me; in some cases I have also found wrong
 code generated, but did not consider it important enough to report a
 bug.
 
 On the Pentium 4 register allocation seems to be unimportant:
 
 0.26    0.29    0.32    0.37 gcc-2.95.3 with explicit reg vars
 0.24    0.31    0.28    0.40 gcc-2.95.3 without explicit reg vars
 
 1.20    1.46    1.79    1.96 gcc-3.2 with explicit reg vars
 1.33    1.59    1.89    1.76 gcc-3.2 without explicit reg vars
 
 However, on the Athlon and the Pentium III register allocation has a
 large influence on performance (timings from an Athlon 1200):
 
 0.37    0.55    0.25    0.61 gcc-2.95.1, reg vars
 0.77    1.06    1.34    1.31 gcc-2.95.1, no reg vars
 
 And here's my wishlist:
 
 1) Add a -fno-cross-jump flag or similar, as in Bernd's patch.
 
 2) Fix the bug that moves unrelated code into virtual machine
 instructions even with -fno-gcse; we can work around that in the
 present case (not yet done in the timings above), but at least I did
 not find the source of this code and thus the workaround.
 
 3) Make register allocation good enough that explicit reg vars don't
 pay off even on the Athlon.:-)
 
 - anton

Re: optimization/8092: cross-jump triggers too often

[Bernd Paysan]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Bernd Paysan <bernd.paysan@gmx.de>
To: Richard Henderson <rth@redhat.com>
Cc: rth@gcc.gnu.org, gcc-bugs@gcc.gnu.org, nobody@gcc.gnu.org,
	gcc-gnats@gcc.gnu.org
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Fri, 4 Oct 2002 01:09:14 +0200

 --------------Boundary-00=_ENHF1A4EXVDXTE4NFNH3
 Content-Type: text/plain;
   charset="iso-8859-1"
 Content-Transfer-Encoding: quoted-printable
 
 On Tuesday 01 October 2002 20:55, Richard Henderson wrote:
 > On Tue, Oct 01, 2002 at 04:38:40PM +0200, Bernd Paysan wrote:
 > > Ok, here's engine.i (compressed with bzip2). The relevant function is
 > > engine.
 >
 > Well I'm horrified all right -- by the source.  For the record, I
 > wouldn't count on this thing working indefinitely.
 >
 > I had to modify it a bit to get it to compile with mainline.  The
 > use of asm register variables falls over the compiler's use of
 > __builtin_memset, which requires edi.  I wish I could give a proper
 > error message for this instead of ICE, but we don't save enough
 > information long enough for me to remember that this is the user's
 > fault.
 >
 > Anyway, I don't see anything that sticks out like a sore thumb wrt
 > either cross-jumping or gcse.  Can you be more specific?
 
 I patched GCC 3.2 and added a flag to disable cross-jumping (Sources from=
  SuSE=20
 8.1, without SuSE patches applied):
 
 -----------------------------fcross-jump.patch---------------------------=
 ------
 --- gcc-3.2/gcc/toplev.c~       2002-05-27 07:48:15.000000000 +0200
 +++ gcc-3.2/gcc/toplev.c        2002-10-03 21:28:10.000000000 +0200
 @@ -610,6 +610,10 @@
 =20
  int flag_syntax_only =3D 0;
 =20
 +/* Nonzero means perform crossjump optimization. */
 +
 +static int flag_crossjump =3D 0;
 +
  /* Nonzero means perform global cse.  */
 =20
  static int flag_gcse;
 @@ -1023,6 +1027,8 @@
     N_("Return 'short' aggregates in registers") },
    {"delayed-branch", &flag_delayed_branch, 1,
     N_("Attempt to fill delay slots of branch instructions") },
 +  {"cross-jump", &flag_crossjump, 1,
 +   N_("Perform crossjump optimization") },
    {"gcse", &flag_gcse, 1,
     N_("Perform the global common subexpression elimination") },
    {"gcse-lm", &flag_gcse_lm, 1,
 @@ -3286,7 +3292,7 @@
    /* Cross-jumping is O(N^3) on the number of edges, thus trying to
       perform cross-jumping on flow graphs which have a high connectivity
       will take a long time.  This is similar to the test to disable GCSE=
 =2E  */
 -  cleanup_crossjump =3D CLEANUP_CROSSJUMP;
 +  cleanup_crossjump =3D flag_crossjump ? CLEANUP_CROSSJUMP : 0;
    if (n_basic_blocks > 1000 && n_edges / n_basic_blocks >=3D 20)
      {
        if (optimize && warn_disabled_optimization)
 @@ -4701,6 +4707,7 @@
        flag_optimize_sibling_calls =3D 1;
        flag_cse_follow_jumps =3D 1;
        flag_cse_skip_blocks =3D 1;
 +      flag_crossjump =3D 1;
        flag_gcse =3D 1;
        flag_expensive_optimizations =3D 1;
        flag_strength_reduce =3D 1;
 -------------------------------------------------------------------------=
 ----------
 
 I changed the register allocation a bit (this is the current development=20
 branch of Gforth, not the release - new .i file in attachment). That's ho=
 w it=20
 looks with
 
 gcc -O2 -Wall -fomit-frame-pointer -fforce-addr -fforce-mem -march=3Dpent=
 ium=20
 -fno-defer-pop -fcaller-saves -fno-gcse -fno-cross-jump -S engine.b.i
 
 and searching for negl=09%ecx.
 
 =2EL96:
 =09addl=09$4, %ebx
 =09negl=09%ecx
 =09jmp=09*-4(%ebx)
 =2EL97:
 =09addl=09$4, %ebx
 =09incl=09%ecx
 =09jmp=09*-4(%ebx)
 =2EL98:
 =09addl=09$4, %ebx
 =09decl=09%ecx
 =09jmp=09*-4(%ebx)
 
 This is exactly how I want it to be.
 
 Now with cross jumps:
 
 gcc -O2 -Wall -fomit-frame-pointer -fforce-addr -fforce-mem -march=3Dpent=
 ium=20
 -fno-defer-pop -fcaller-saves -fno-gcse -S engine.b.i
 
 =2EL99:
 =09negl=09%ecx
 =09jmp=09.L1143
 =2EL100:
 =2EL205:
 =09incl=09%ecx
 =2EL206:
 =09jmp=09.L1143
 =2EL101:
 =2EL1182:
 =09decl=09%ecx
 =09jmp=09.L1143
 
 =2E..
 
 =2EL1143:
 =09addl=09$4, %ebx
 =2EL922:
 =09jmp=09*-4(%ebx)
 
 Apart from the superfluous jump, there's not much damage done here. Note =
 that=20
 this cross-jump pessimation not only introduces an unnecessary jump, but=20
 kills the branch prediction logic of modern x86 implementations, which=20
 usually predicts following primitives quite well. When there's only one=20
 central computed goto branch, the branch prediction logic fails. And ther=
 e's=20
 really no point in saving one byte with a 5-byte jump to a total of 6 byt=
 es=20
 instructions.
 
 But look at what happens when allowing global CSE:
 
 gcc -O2 -Wall -fomit-frame-pointer -fforce-addr -fforce-mem -march=3Dpent=
 ium=20
 -fno-defer-pop -fcaller-saves -S engine.b.i
 
 =2EL99:
 =09negl=09%ecx
 =09jmp=09.L1266
 =2EL100:
 =2EL205:
 =09incl=09%ecx
 =09jmp=09.L1266
 =2EL101:
 =2EL1496:
 =09decl=09%ecx
 =09jmp=09.L1266
 
 Seems to look the same, but look what happens at .L1266:
 
 =2EL1266:
 =09addl=09$4, %ebx
 =2EL1242:
 =09movl=09996(%esp), %edx
 =09addl=09$8, %edx
 =09movl=09%edx, 36(%esp)
 =2EL1274:
 =09leal=0916(%edi), %ebp
 =09leal=0912(%edi), %eax
 =09movl=09__ctype_toupper, %edx
 =09movl=09%ebp, 48(%esp)
 =09movl=09%eax, 52(%esp)
 =09movl=09%edx, 80(%esp)
 =2EL1267:
 =09leal=098(%edi), %ebp
 =09movl=09symbols.3+24, %eax
 =09movl=09%ebp, 60(%esp)
 =09movl=09%eax, 40(%esp)
 =2EL1335:
 =09movl=09stdin, %edx
 =09movl=09%edx, 84(%esp)
 =09jmp=09.L1244
 
 =2E..
 
 =2EL1244:
 =09movl=09stderr, %ebp
 =09leal=0912(%esi), %eax
 =09movl=09%ebp, 16(%esp)
 =09movl=09stdout, %edx
 =09leal=0920(%esi), %ebp
 =09movl=09%eax, 56(%esp)
 =09movl=09%ebp, 44(%esp)
 =09jmp=09.L971
 
 =2E..
 
 =2EL971:
 =09leal=094(%edi), %eax
 =09leal=0916(%esi), %ebp
 =09movl=09%eax, 68(%esp)
 =2EL922:
 =09leal=094(%esi), %eax
 =09movl=09%eax, 72(%esp)
 =2EL974:
 =09leal=098(%esi), %eax
 =09movl=09%eax, 64(%esp)
 =2EL923:
 =09jmp=09*-4(%ebx)
 
 Or without global jumps, but GCSE:
 
 gcc -O2 -Wall -fomit-frame-pointer -fforce-addr -fforce-mem -march=3Dpent=
 ium=20
 -fno-defer-pop -fcaller-saves -fno-cross-jump -S engine.b.i
 
 =2EL96:
 =09leal=0912(%edi), %eax
 =09leal=0916(%edi), %ebp
 =09movl=09996(%esp), %edx
 =09movl=09%eax, 52(%esp)
 =09movl=09symbols.3+24, %eax
 =09addl=09$8, %edx
 =09movl=09%ebp, 48(%esp)
 =09movl=09%eax, 40(%esp)
 =09leal=098(%edi), %ebp
 =09leal=0912(%esi), %eax
 =09movl=09%edx, 36(%esp)
 =09movl=09%ebp, 60(%esp)
 =09movl=09__ctype_toupper, %edx
 =09movl=09%eax, 56(%esp)
 =09movl=09stderr, %ebp
 =09leal=094(%edi), %eax
 =09movl=09%edx, 80(%esp)
 =09movl=09%ebp, 16(%esp)
 =09movl=09stdin, %edx
 =09movl=09%eax, 68(%esp)
 =09leal=0920(%esi), %ebp
 =09addl=09$4, %ebx
 =09leal=094(%esi), %eax
 =09movl=09%edx, 84(%esp)
 =09movl=09%ebp, 44(%esp)
 =09movl=09%eax, 72(%esp)
 =09negl=09%ecx
 =09leal=098(%esi), %eax
 =09movl=09stdout, %edx
 =09leal=0916(%esi), %ebp
 =09movl=09%eax, 64(%esp)
 =09jmp=09*-4(%ebx)
 =2EL97:
 =09leal=0912(%edi), %eax
 =09leal=0916(%edi), %ebp
 =09movl=09996(%esp), %edx
 =09movl=09%eax, 52(%esp)
 =09movl=09symbols.3+24, %eax
 =09addl=09$8, %edx
 =09movl=09%ebp, 48(%esp)
 =09movl=09%eax, 40(%esp)
 =09leal=098(%edi), %ebp
 =09leal=0912(%esi), %eax
 =09movl=09%edx, 36(%esp)
 =09movl=09%ebp, 60(%esp)
 =09movl=09__ctype_toupper, %edx
 =09movl=09%eax, 56(%esp)
 =09movl=09stderr, %ebp
 =09leal=094(%edi), %eax
 =09movl=09%edx, 80(%esp)
 =09movl=09%ebp, 16(%esp)
 =09movl=09stdin, %edx
 =09movl=09%eax, 68(%esp)
 =09leal=0920(%esi), %ebp
 =09addl=09$4, %ebx
 =09leal=094(%esi), %eax
 =09movl=09%edx, 84(%esp)
 =09movl=09%ebp, 44(%esp)
 =09movl=09%eax, 72(%esp)
 =09incl=09%ecx
 =09movl=09stdout, %edx
 =09leal=098(%esi), %eax
 =09leal=0916(%esi), %ebp
 =09movl=09%eax, 64(%esp)
 =09jmp=09*-4(%ebx)
 =2EL98:
 =09leal=0912(%edi), %eax
 =09leal=0916(%edi), %ebp
 =09movl=09996(%esp), %edx
 =09movl=09%eax, 52(%esp)
 =09movl=09symbols.3+24, %eax
 =09addl=09$8, %edx
 =09movl=09%ebp, 48(%esp)
 =09movl=09%eax, 40(%esp)
 =09leal=098(%edi), %ebp
 =09leal=0912(%esi), %eax
 =09movl=09%edx, 36(%esp)
 =09movl=09%ebp, 60(%esp)
 =09movl=09__ctype_toupper, %edx
 =09movl=09%eax, 56(%esp)
 =09movl=09stderr, %ebp
 =09leal=094(%edi), %eax
 =09movl=09%edx, 80(%esp)
 =09movl=09%ebp, 16(%esp)
 =09movl=09stdin, %edx
 =09movl=09%eax, 68(%esp)
 =09leal=0920(%esi), %ebp
 =09addl=09$4, %ebx
 =09leal=094(%esi), %eax
 =09movl=09%edx, 84(%esp)
 =09movl=09%ebp, 44(%esp)
 =09movl=09%eax, 72(%esp)
 =09decl=09%ecx
 =09movl=09stdout, %edx
 =09leal=098(%esi), %eax
 =09leal=0916(%esi), %ebp
 =09movl=09%eax, 64(%esp)
 =09jmp=09*-4(%ebx)
 
 I noticed a further problem. There's one primitive that converts a double=
 =20
 float to a long long. I moved that conversion out into a function=20
 (double2ll). Originally, this conversion is just an inline operation. If =
 you=20
 automatically inline the function (with either -finline-function or -O3),=
  you=20
 get parts of it moved all over the place, even with global CSE disabled:
 
 gcc -O3 -Wall -fomit-frame-pointer -fforce-addr -fforce-mem -march=3Dpent=
 ium=20
 -fno-defer-pop -fcaller-saves -fno-gcse -fno-cross-jump -S engine.b.i
 
 =2EL109:
 =09fnstcw=091230(%esp)
 =09movw=091230(%esp), %ax
 =09addl=09$4, %ebx
 =09movb=09$12, %ah
 =09negl=09%ecx
 =09movw=09%ax, 1228(%esp)
 =09jmp=09*-4(%ebx)
 =2EL110:
 =09fnstcw=091230(%esp)
 =09movw=091230(%esp), %ax
 =09addl=09$4, %ebx
 =09movb=09$12, %ah
 =09incl=09%ecx
 =09movw=09%ax, 1228(%esp)
 =09jmp=09*-4(%ebx)
 =2EL111:
 =09fnstcw=091230(%esp)
 =09movw=091230(%esp), %ax
 =09addl=09$4, %ebx
 =09movb=09$12, %ah
 =09decl=09%ecx
 =09movw=09%ax, 1228(%esp)
 =09jmp=09*-4(%ebx)
 
 Is this specific enough why I'm horrified with the code GCC 3.2 generates=
 ? The=20
 C code vmgen produces just looks ugly, but this code *is* ugly. I hope yo=
 u=20
 now can see the sore thumb sticking out. I don't want code to be moved wh=
 ere=20
 it doesn't belong to, nor do I want unnecessary jumps inserted for no=20
 particular purpose.
 
 --=20
 Bernd Paysan
 "If you want it done right, you have to do it yourself"
 http://www.jwdt.com/~paysan/
 
 --------------Boundary-00=_ENHF1A4EXVDXTE4NFNH3
 Content-Type: application/x-bzip2;
   name="engine.b.i.bz2"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="engine.b.i.bz2"
 
 QlpoOTFBWSZTWXhHFsUAnLf/gH9z////////v////7////9hB78B8faRspoASR6bWr2M+kwBigHq
 W1GGu7cBFESkAgbM+sqg0cAdAqQAB9AADzvQeA7Y9dFC4HMzW7u4kh4ho9pirNaxtuZstrWaoEAP
 TAHYzY4XO0t1gLsp7zAOq9qzIYNsnoADoAAHWQ6dAdDirsAC9d3dx5KD10M9TU16PJTV2KGEzNo6
 3YAAA6w2HUHoU63WM2kpoKEroFnUO5LzOO9zprATrUOboFGgAKHoOnnsaDoZJUBlic2lEQtmgqJV
 UilRRndxdhttEqIWtKoKkhVFhSL3p3juegGsdDsA843XpQoB0AFXYUDZunoA0A9FPD3d6EQGD3fe
 de2nAAAADwADPT5NfWHrIe9uGVIAtoaFU29opvdzolRbAltp9Mc2fc5xtu+7b3gDu++19Pd33d2s
 e3vuffb7uZ8ULt7p3svec8e2XcdXePbPt7yz73cPSSIokfTC2OuAuJiM201TbrqhRQCttJtnCd31
 xlKQRO5uwYoLra5zrh5LXhQVXc8YAbZrby5tujCU6KGp7SDKFHa7uq61XWh42j0xa1KKp7hzoi7a
 pyaHmADdibBq221S0ZBVISlRUd7LrBPDuqA022DRyAoO17sQqq9sVV73bd7e89iqpdvd05QEjpi1
 c6u9e26HVK1lE10PZvXJ55vdgUvMGqpeWAEqip49uou2OgZVXpr0KA1qwlNEAgTQJoRk0TE0EaKZ
 tJk0xIyNNMgYagABk0yaYI9QSmQIkRJqCn6m1EbSNNDaRoaADQAAAAAAAAAAlTfqpSoAGgAABoAA
 AAAAAAAAAAAASeqUiRBpMENTVG01MgabTUDQMmhoAA0zUZA0AAAPUAIkhBACaEyGpiT000CNMhU3
 kyU/Jo0xNTU9T2Sn5KMm9Ueo9NTT01PTSafpQKiREEAgE0BGmiBkCTaaGhNNTRvUEA8U9TI0aNA0
 ABp+07gtE/BIP3tCYRVVUoRf3CwbQq0AsWIlWRZCFqyQxSDJbUshTFJMQlCxFiFSyRLSkqiClQP/
 VTVQ0iipLEOMTKsgWFLZISyUIVYSSZZEMFREVKgqkgKiVSUiwWSSWSoQSEYMCIP/Qf/saPvjLgKo
 A/QH4P+0f7gsJQn3hhIlIfwEKYT5iN4gARilEWpIpatRBsfSaZssVMMkchmZZrtK8VrG1YxW8qba
 uRtMOiGBqbyRMrCkI22MhB799V7siWTSxRbZassthGUiUmrSpU21zVRbKJwWQRlYvCWRE2JCVBpW
 VN2SqBtZGML25km4tNRf8WZavVuROrfUhKtipKJJxYTS5SRc4DUJAsaCgoQ5/s0B10oBZBZKxto2
 o0WLUbaxo0UF8ueK4RG4ELyeHXninnSEqiSET/Gbf0/+f4f6tmo8HfpYJZqMIQ3DCVpKSyVv8yW3
 S2SpKkpNi0Ri3NubFFEX2WqtnJ5DakhjWJERihNaxIGlvPv0jUwlqLWxbYrYixbGqI+Fc1E0bEqM
 a0aMVi1gTY0jUwlqLWxbYrYixbGqI5XNRNGxKjGtGjFYtYE2enqqt7rmvNu3L1lGmzXZRsonldbt
 UoqVSiGMEbMxHdxoMyUTGoS+fW6qUUDSJGmaMBvK6pV0qkdLdK5EUmmHWssmkqsYkkhioqgh6Lri
 5myToRxhLCuCMYmcSbq2LZLUqNqjWrXdKOzUnpt5I7XcU69Vea+TesoQj3rOeqsynGY2b1umLNor
 LbsxtdI1cqW6zGLWxhhJFTR9jQ0k5mTb+03jUyP/w2Pi2bdROWEorXk0andW1evgyH/o9lnBl7SK
 bBAj/PISVEBER/DQySinJ8zFaYVDRWFKroqeJKSsajls2TWQ8cs2ui1pZWpIrxG5iPOZnjFy5u/B
 2r4vuvkTyixE6lLhISaIJBsSIJLoJgaQjV56XEZKuOdbleXV43ve63KqpybMVpiq5DURu84yFjlL
 tXTFPV514VK8pcXrnbsluXOHLGiuDbWrOKYkxhZRVT1/k/lfqv58f0MSkpf+bTmXq/8qP6Lvbyeb
 7DNhhACZrrRBsFOuls+/q/D9rb2shSIXXd02XjvHOuOjeLeK8eW888eae+vwkklJul0kvjrrJXVY
 0VVcYxVWK0qqw3WNMYxjGG8YmlN1lTSm61VWLWlZZJKyySSS3u3W5ZbW7dlkb052xVlbYxZU2+Db
 TStq5xpptW2m1bZMbVhTTQ1vDStNXTSyyWSXDeluXCSsiW0strduy2luS0miy0kssrJJZreW5d5d
 SSSa5XSSSXd5LyvOukld13kukmTdLpJK9S6SXl3peSSSSTyXXqXS8urry6t1s1lsyUkkklJfHXUl
 766SSUklsSkl69+vV6kkklJr1ddSSSSSZJJJLvXbySSSXXXSktdeuvJLrrpcukk8XSSSkkkkkkkk
 ySUvV5dXiNGGGXTTFVChUlCquViqrGM3jGvpnDbjTFVmMVVSpVYZMcMYxWMYxk0zizNsVYqrJJJJ
 JKSTKWvdK6kpUYYYbuzOG21VisKjgphSlRhTCpX5lYU2MTZhhMaMRhhhKVGFMLFSlUpUw0YTCjSz
 mVi1VLovTdzTbkqcjaNmGExZzCtNmI2YYTattsakrKzaYVSlTRswmFRhzw1OFKu1mml0uml01JWR
 aZbLpxuTW7Ysxa2rpvbjZikwIZYwklJkMJGUiRAZ2yRCJrK22VWucZWzbGqs3jSuNzGlMq0SItG2
 USOLGRJMkloJkY6KkGTUgUihGIpF0MYi1txSkskYxEjMcTG3O2mmMYxxpqafKTGWyW2rDnlddiYl
 9cUuQWvm5b38bz16ulZ+dswblyJDnGpUIY0NJH2twVbFLJ2642CavOV12JiXxFLkJRBxNEXsTVDl
 ZzZgspiQ9WJSoRslUykuJlYpJLGxCKYyRHUMkJ2SRFslEkjBiPPTgkRQsTUSOKzbihDOWTRywyml
 jSsVMVtKpipt3YbpptppdLjFaY1pitK00xpWNYxVaamrUxpiqY0xWMaYxxtpptWK1TGmK3vRVWtK
 Yq0sTW9VlZW66t1bq3It8K5aWkpNExIwmExIxGErCWy1mSymkkkskliyUskrZISMYxAi2DKqSRoZ
 RVUCKBnVogaVJEJMdkUqkVKVRbSWyVrZK2yW1JakpKyVslqkpJKktSUtJVJZVJZJKtJaSyVZK1lJ
 SUtjSLTIm0bFrYtsbUaiLFsaogo1E0VGVGCtGjFYtZETby8rLVS22qW2W1tIEiiYqkqqqSngxNKq
 tGDokjQqFCiUTRExGKTGFYYKUhiIiNMMRImJSsrKSpJUpS1rk1nEUikUlKkVCSlSKlVJUKKlKqIr
 BQmKCoomCzEkVCKkqVFKKqoqS0pSWUtrKUqy2kpaylZLbKlLKSslUtUqkpuV0pSySmltaWtZRUlR
 KFRERlmFVgqIwqJSUoKIiqlKhVIpVSW1kqVlspSXZ1KkibWNrNVfST6RZeUNK+G50aOSpwrGGMxi
 rFqpVQ6JUqd5tdba083NTrrdxDQBPXC6uHYrmPLd5F4t5eck4XaSRrp3TlQaKulkNXqa6njblkLZ
 jd3XLt27lZuXEnTrmddnR3A3nl3lznZ3SUnctOhHDojuMcxd1xSUc1yKunNuWQ2zO7qSOXfulk88
 ubu6HXUJeV554bnLmJ2LlwybQSoqV0aMGhRCqaxTEwaMMIqkVKiqTFSKwdFMVpiuvFs3Jo2VGpjS
 lNMVJVYUSVVVUxU6q3NptVVI0rFMMYkxUURSKkpSFKRUkqEhlzja2NDUUFBtikabUjYkIhMbGQpE
 gKETLReu3N03Ut0xFePHhsV3Hd2dDtzvHXnOdEPF15yjO7cymUzTE0rFVjBWtBjUb0kYoVSuVJtU
 0KqqqTRiaUZf5dnZ01hmIihD0kF8bPgGC7Gf43t/0gYw/bUJ4c9/06PH1SehSBKsSQoiBbba0JlS
 l99ds3W7LakkrFTRKXUurUWtpJWq99Sf+y/Su74XK//WedfKIINrAJCxW362/nqK5tndrbGrW5tr
 GjTLlRlMohaImWJEfv/hkJDa6kttW97UmTKtmVptS1kkpmyat785RPfcm2NtV6qUpSkqa16bXWay
 SkpZWWkyW8JYqn8XWrxlNVJWStaS1XjW6Vkk3N41lLBFWoLaC/EeY+Jh7cQ/0A+EOAeki5N8rfjV
 9tf739f5/2P53P6/y9/x/p/GAAAAJKUMwJAssLLHnvzz33AAAA2bKlQABJfk1TKRViqidTJs71UX
 w49GYScOkrdQREWdCIiTDMHY5SXNmpd1orxZVc7r53anm31CjvSxkSI0LOGjJLDDDBFiEYScJEYS
 SYUIo4FknQ04HDh04WM6FBgdKOnDp0w4cOiJECCgkOnTCTDDp06dKLJNJOEknTpZZYww4UUWcKOH
 Cjhwsso4cOnThwkRJ0gYiLIiiRmHCTSjoijp06Mw0QjTh0OiJBhwMDAkoZJJRpwYRYaJwbcK7JOS
 diaUlJ0Ypyp0dCShmmFFHBGFjNOjKKOGllljGMswRRR00o4MZ04cESaM0w6SaWYcNNJMEScOCMNN
 NLOGDOkmmhDAsREnDhJZ04MCJIg0iCxHDSRmmFnRFFFFDLDDocLKDDChjKOHTDpwZ0osoOkkIMDo
 UGh0OBocDoUwrsdTsdjsdTodjqdimjk6tBIYMGDCwYSEhwZIadJJOkmmOrq04dGOHLhtWOSVHVol
 RjRKiuVRwk5V1Y7OzsxTocnJ0cOpwJCQk4R0OnA4GFjGMwkKDTpRoWUYYWUcNLNNEFhohAzDCjpZ
 pZIwYYFBgYGh0GFESacGdNDTh0koRIjgUWcOmGmjOkkmjLEYRFHBFCMKKGadGaYUMiLKJGdNOHDQ
 w4YaYMZws0wEUScOFFGGHDhgYFhIaHAwOh0DoIJAWxsOZYklStFy7tNItuLhcUZWPl9muE6PXHMZ
 y31GItNNBvXJnH2aSBLLwktArrahXhmbkLnca5w2ZK2tqaprecrr53DqeZdKXnZLvmPhfMVTnJuq
 Q+ZJN5L5N3Wzlbs0JqcTOrCkIp5OVO1vdzjTKyYtvBPitSl28xdtWxLhdznMrObfOBvJV3fObe9z
 NdG95nLa6nm1dcybaNFpbaL1MaiI6o7tvL6nx67VZuGV+QAGfowwiBQoSEl8SGrzbQto+U89HKsC
 LSneLzvUbIGmTJCEI0olQjnUnSVHhpgxml5jbWJM0k9Gmlx8JdEaMYzhwsYxnQwooQSdMKOGHSxF
 hpIiyTTvSSSZMJJEadGd6lRQjShFlHRhRwKNLMETN9qqqqo6VHXblTLmdm+7HJZvRbPJU8zmRyWb
 wWzzhykJdJ4lD2eXVVVanpipcq5nszvJx5tVhxUrq5nkzzk48V1mVltXd1d4K1ztyUqqpRdSpupp
 VVnA5SVnR5jb6ISQhSKu9m8rOau7ztc3ndEJIQpF2uTeVm6u7ztc3nThDmr5mEZmZnTbSMSosR04
 YcxLC3i3jnFeCqVmOcV5N5zt93ZW7u3u7RpPd5VVVVwk6OFnWTCmdN2rouq7kzmGVWWVyW3w5eVt
 KeTc3dKbwkYjkVTbZV7yZmcMOmGjJLLGaM6EnQk6WSI06WSIwOFFhQw3qSSVBtJJJcMBGGgkkkk4
 u+zMzMzMzMxaFUvtVUzM1VVUyjqbR2ilb0d6fUPaMBo+cegHUTrYZYwP/UH4jgZ0R6BD6zedCntw
 XCvnyC0ORxi+aqY6uTEmlLh+ifssMJZUpUqNq/na+dfy7K82/tftAAADtepV+1SQnzFI/sJTsRHa
 pBhoqT6zyNDToc92n87qiZpZDx8VmSHIj+fU/XP3zwPRqalsr1bu7m1fR2fsdW22222PxlQT/Y5O
 rHfif7JpOVfn4Lbg2p3ThDmoPm9Mf1K4da72fJM8jVXf57fL+n153FXJLw390q0fhV0ZWd8lj7+o
 xwBF0bo3PEfP2Oax99biRrJ8hbby3XrBkC9Q453tm0/JuJJevNa+rbXu7KdSihQdxuf3V7KHJZUr
 LIgz/r5OyeL4SMyKS8NjE748a3wIzSVGJze+TJf2pgSB4TwhbSMp5VS3yurL5jx+hJCP7rVd5k5p
 Us1QRkoQs5O79TedOuTpkE2fjQXXl/bXlVsGPmPEbwGDg/9ojcPN98jJIs2yG7qT5AyDyZtTbazN
 o2RzOZxlA46vtd5zOzgGy1w3896DryB9TYGmIxiMH230o0jJHR7Pg/Jtt4PJw2TSe57mnBIzPg/v
 CnD53cvdssxvxS5m9jXsYRRCxyn3qLyctK0x5vkeNPblq3jlMi76evP4DNzAQAIOwOMDjFwOVc/V
 gUyTXE0sZ7/RMdWfcpL06409sssq8b+xVLlV7qaSVeqnd5316q79+UvZ78lu5pL8PsWSy0ytctV9
 iCRXrS+Ue72OPOU50kkqTn8T4GgVFMo5uHfz7OlVle+MYoqtx3DkIcwIICWPQQd8ob4juyMJCXQh
 Lu3S7PPcnwyJnjhA/rRWlSNaZq/JaEGSWdbUvUx63nlWG9EZGTv2nXhanq03jU7+1Yl6kYjeYMgu
 Dhdz8QwdGJtMCxUTsqhRzrb2fNi/OXraB4BBF/gBrQZnqArfHtmjsQNMBm7sSm8TcNphcJCO7nw6
 u3JC1PQuSG1GzGQDYNz5m9zTCV8uSi6216wkmTagXCYxuduELdRKAwHPkGhGpSnp7leeq91rTk1s
 pG81Z6yioeXKVFpMrM8X5tgfO24cTXxcbsegB8B9oec9AhcT2gkO5faPqNwr9Tc/u4oed8kPiSJw
 QPePiKkdZg0aT5bv7fI4er8iPc0eYvZ9qJpjxVCqiKhKo8RhWKrFVUrhisTDFTFYqpWMKmGNMKph
 VFVJKqaKkimDgz8Mkiafdm3GdN6zWzSuFRFSZjFor/IcEjGj8iSCcQTxxqhIggbCZiCgF+FFdcMO
 BjqjhmE5lkwMFAhBzLmCgSFKQvKcQVBNoSWPFsNy2cotW1bAW9MG6psGJ/Fiib9mUJJcvjbVgvFC
 pbjSG2FyKGGU0sr6RdSufPM1rU1UqU0KcVati15NcWeOwcFjUp1qSfqZ243wwsfq15alrY5RAklE
 SQIJSQkJEhAt2wzHoXebl6U7NPzjqnq4STLSpSyKotvnKxJaLtIQq0My5ISSSxXSnURIo2BNjNkj
 bTE+BWKznKycT5hnASBO9pDeolLVMRQpSShYiz74zseg0/TEIwv11jR1giViedmymK2lxk6nhNOE
 cG1c+/M6Fe2IZaX6Wub0vSWrFt5Bw7iGNW6pUaI2multJlPL0sfJ859QjT6mN3DZ+o/CbzxBEQhB
 XBDDm58w3sNSHkw+oYog+kSH7EhTuVIwr3odp8nlPlP9zknR/0nVoUVXiklVTMXGLKrCblm5/6Zv
 pGSQ85hQ4EfIhc8hWw8gJC9UP20d4CsFB3GD/13jqCWCRu73CGxw4NJEJPFcq2EjFypJGLERWZEJ
 iohWPdAkakg0qJJK0OVSEne2WyJ1pEeLq4cDJOhEYsAqyIHglInksSRHZtBPr+4d1jMUnNwiCsqN
 saLbddkBRkZRQaNUbFaKklMaDMkwt1tajXz3quZI60gdGyRuOwmNwSbYZakiJjEZBJjIwkkxjOwn
 JNNSSQ2zIQMfAHUkVPcSoP7VfZLCypDZNP2J5tvtLy/FtqRJJ8yyCLCIJB9sGUCqHxgA6D9eyi4P
 U6iYk7DOHvni+14MJz+3WPa/1/x/poNH9RVUklCUkojA8j9x3NKH4Mwnsf4H9CCftbcqPgqv4j4K
 7nB3Y9RDVKA44dCx850JH2lD79Ds2Y0QY3OIiQ0jdoCwINw8A5HUTeOnc2D5TM4GQ7Tqf8vqobsf
 +KFDvARgcD+n+T9vLf+b1tcTdDINSRqdv6bvl+p/R/7nomVcAbfbmH8r0w9v5pSX78iPQ8QP3/YM
 N7Bm8Rk/YnL7Lp+aCPVor81R+xX2qm1SvqxtX2vmw+5VbMdH4jbSdVK2YOU0xP2zGmiuisFKroJX
 +NTSmhc+BsWKGBwDIbImPMgc2CBqYJEjUGP7BSJ8xIn7nVy8zHXTDs/mafFNuCGNTncyECMyxqQZ
 te5Bg1ahIjGxImNuPvaNBumfvzDcd5uPEscQ2u0bjv4GSWLuoER/ED+Y/M6ENoYPtgfjHIs9hDcf
 UG8++1R6K1Ks/C7q3ws21gg9OK3vh+P359/X/R/qAJqKWVwL9jYWdPuoApjPdW6d5sFLCffgkA93
 Gmk7OKH1meuMxCKI+3nlmkYCtmtA8Yn4iGl9NLlyTaBW+bL0lpoxI3HtIkJXfjrrrW6TXTdUopRV
 Pa21YnhYy217QLKRnhNMq213kDIlD9P8WntUnVKPS22pDzO7XfwRO5/nTE/0FgPzDXHAD8hUNNMt
 qL9kTpAQkg4h4coOONxSwimUQCMGorniEkhDiTlQzgTSe5Kn15d9fRZB21ibtomoVJpK1A2RBC31
 Wt9lfLyPT1brtrfE2r4eC1CIiFeNtcPD95ypv33kxJqUyKyBC1JmlGV73S1K4kg1AMKK1UzpOULR
 zqiqqqqqpQ4n4dLQtreZTMTx0y2IqqsjtKmVHci+55ERA3rLBvx+vrX119vbXzNXx83m3zHttXC1
 Gir2q/VvfbXoQttltW1zQnG1k6Mb03RttvZDmwTCQC9EG8bLkSSTeb6RwE7I8t9fVd3lLqXV3EnX
 cfMh9turdbpg+DvpQ3LgqMpYGZTVpNlTnvLl5KOte18bV83fCLivI9nyT5Tk8LVq2nhYmZqXOQwu
 QgsknDWrd7VSEQLwqcnJ9z6vWs9XuU/L1Sy2xbevTuR3O6RJemvAwuWNq4fym++1vvtb7MfYDq6+
 VTpY+FTLdL81k8Tl8udnZ0xHx8e/Kvs305ERkIyWvW+3tW62tQ9wnYlT+5KRqTlXewe06T0NdrVR
 qbKiKZRk2mptS02iKqbbDVREREJJpLERERBRPw3aq7VQiIiDVijaIX73e/A29+98W929by3XQoNM
 2lSsRSWInb7d63rXrQiogMDffPJJI+CCpJFQUkoFSpJsB8G5ae5KPKlfBnLscFMKhMGGITnc6bZj
 GMl4WYpdMxjGT+N9ynnAkb24VWMVWMYW2dnp1/0X8ePCzs9T0GNTfJ83qeSjxOzTs5Yj1ErTTo2C
 bfVs0mlTHejknwUj13ZVfHHldJTJVPbwkXDVdZkm1qfTGRXosibpDhUjYqSRbNbmQTm7yYl6RVwc
 aymyyYqFs1Fi3CyRactxKbW1VRR+Tj1qcLxwJkYqUJWnEWhRUqNaPkG2Nnd9hRYYYYbqKCrIlVIx
 wpVe7We5XZp3erx4xN5R2HjoPD0x7jn+9HBy+237ACX43q6SSIBL8ruSQggAAANCSAR6HAEgvwTu
 APiVxIkkg1V5mtemtFto1tmZJmVNoEsCht4C6deu3Xdu467uro7riQu67JCHdcndcB3XB3XAEkd1
 x3bgApAAAk7riQAbxGpKr577b39VfZzaSXquhDo70Di70yxCSSKWrQloSSFFVkZC1Un2xkQKsSFW
 dSnger2Km0JMdmjFMVGKqurTsxZOH39HffFu8nyKTryZHZ1Rjo2nl6yHuqRpR7pr3LXltmS5AEUb
 EUYqI2oq6u+L7+vuvLsR9TmSbGQuPbjk4NISLgmmlSx6eMlxTEuTElqE0qV1xEwrqLNcMVppXVvv
 E8k3MOUoVKYljFbnNnXcfBUqWVLPSTZ59w4LGucTrZrndVyOeCc1bJYwJPCGQb9IrlRhYRO0WKxA
 NEwolwMj0FTFYdqdSKsgGVuDIMUBY4ilI4UJJKAECMq2JGXeDcQdImHjFEYWZoVcoqoRESmYXMsx
 TKAclRKmBRjWtzE3OZqqcU4sYqblRwqTmmr0rfkOVjbXyV6pWvHuu7NkLe+Njcv2uWjW+fx9vr1t
 JFeddoLpSjgiZyRbjGEJBhdClq4ZyrGuuOKTd4nacE3hhpeHdETzaI8+1lAbpCTdt62vIbojtlpJ
 jFixC9N70vTWnLYSFU0UdjZqMISzm21NaOA3SorIE9p55DajUsbKWpiRo3iZA1LPSICN9HNjnKMV
 EbUQEg9BAjVFxTaiC4+kKKIlUnVDLFe9zzy81OjTZa7uFy6vXnofFm1dzJZutFRXe+x1PF0Knl5x
 5uqFazifNkmr421zwkb1yJMQSnvNmNIJWGIwokejpza0kjMuI+A21urds4IwJmEmAqwxUTlWIoVp
 RlknF7q2tb8t7HThZWZbXRxty2e6LVqwbpws4H8isSIpUiK0MI8mhgTGmmpJVlyRflt99lrstS3q
 vrAdV8Te8zL3EShhIsWNMUpBpoIxOO3PPYVqWqxNMy75cG5JNKery9ed6301Vq2nW1YVS0W7TEiY
 92Y5djeWa5tt2cS1rFUattCmi9rjDpAJpSozmNKVcbs1ZLx3To0Yw11roaUqppiJIa6MYx2Za6pY
 icx1x6WdF7Ns0bWZKVquLtEQgzYumYQJuEmggTX6uQySBLrXEsaVIJGiZFEISEotQ1MFVEx8cLPk
 KpQeextjYgSWuwUR3QcSKIAwhsQxLzZbJ4RXXudQ8lSddPufVsncpwUpSlKUpSlKUpSlKYoRU4TF
 TRyryNMEqm0kNGGlD/S2SYFCkpKKKUpSlSRPe9/jH2WbOpUp3MiGpWCjFX2716HLc721OHDam6+S
 te7Fsnuxi1jGKvPRrZNuF7fJUNuel8vHHAtsnave7MeK2y5mKWdVwmJYqltuGhL3YQUxBUlk0DQA
 YKhKpJUqSM2vSzSTlJ8WCMhhxiw3EGCWKBstEELzbISEjipmVOhFbox4YjKVSpN8cNM/PEmnPr5e
 r1KSyVbfI+S3Oacy9ZWQAYR9xF+k+I+QJ8h8o2bZAdV2IRYATYlMZlYrZTW1X8zrb+HPTa7cf0jZ
 Bfs7wnefSbQ7wgczzmZ2nITabQ/vPlJI/OotS0tJLUf4DAmCKSgsJKWSR/Bav7LmYmiWkktEC2i1
 NSVJsrZSkkpS2ti2VtkttlYktJbYsqgtRVSLREqobSSKEMpN0MVFoi0ZQE0QrVLS1GipEaNKIgtS
 YJVCqVSqMwgfaJ/XP6JwhqVKBZih3gBQmEzFRzZAZGQYSKihcHDyYG9g+l/M3COAeHEDYfB4lQn2
 0AU2D1DhJCEITD1Pp3M8KNyCIruQBSKijB/LQI1BYAwgwWIEGMAFR9v2BlCJQZZeof6CfqjX+1oa
 klK3i8X+6rlreKv6zhonrrarVerAWyRCWiDigmUOKkkcUG8bwaipUQkUtBAC8VtBEFvEEQNU/WPi
 FAPgf4DXICXA9p9kWw/sYkwWKiWSKDzsVQ+ciSBWpBAr+OYxlYk95k+KcNNTR2aeJ5MTExkfp/zx
 30B2ofzkBPxD8JtKo7GD3Fj3ExVO3LuVQtLPmoypS+sTwH7YRI3CT+t/oKcInwGz/ZgxUlVEdTDs
 QLI/WxtETSbKCqTlEqFRFJJGmk/sfzMfA/kcmD/C/0GjR8VV/mcPVwR7KT6pTuSPMqSOrSIV72BG
 y/5XsIwqSKUSSlI9kqGH+AxJExNJBZKmIRGJMRJwQNIENZ0Y0gkU0YjIHWrapPvWYVKing2EMVFK
 SVSlQ4TBHRL5GJo5TG2kRLt+9jwaaVVVVVVVVaR4pCobsTgqPF1MVpkiUxiSSmGExH5DWn73VoTS
 XEY4SavK7Yv/vumXlbLlRERRBKMDHViJMYjCGGg0xMPBnTQYcJExEVITFIEwqSSJihJOxOD+swbJ
 tXAkipXQ05E2wJPhKOU0e1nQnTE4OE2ahXv9MQ9xTalUqlJHXDEdU6hXM2HUNHB7uj3JIT+RSRJV
 CKsJBakSWiLYSKHRVNOHY6pmKrZKIkVMpSuqojFMKSMp8edPdnKHKunCR8FgknVJCvZUTwezBtFW
 wWSKqKiUhSFdVYtkqpInMqNuwqSq2I9zbRooUqVEYPbe11sppWJWijFaUlR+sxNIFcv9Ar83xJo0
 w4E0wUrgdHRRwjZSctOJ6LIG1SujJ73U/8jybSKoiopJUezbs6nEEj9rs/NonCCcBSijCUxFUY5d
 TTQ+Dybco4OCEf7VeZEmkkT4E9ZhkQwKD4ixRO0RGwiXMwKBfoEeyEdmMEWyRbIKSKiQtiVqUq2N
 GjRpAtV1qSt0GpWlpJLJXWrpK6sToh0JIJSJHEsSk6Indtgju+rhInDkYglMUoo4RE0gqVWBoqql
 MaVURXuVJMRClFbJUTEj4mNvxY4f6xRQBAd5ihFzBbiQcigNUke8JAjqdx+Ec7HDhyx/W/teDzK+
 QSqkKURSkmPo0mnuA9SkDgxEYkjGKh11tYuEK9MV+YD2FywpBRRwIgMEYiVESYkRTEqQmImMEYip
 FSpKlIxll+z4mniVUqrHfMh62aferbq+T9TzOXg6yKrlHm0CaPVs0EUThpoRUd1NomiJh2OW02kH
 RX7WmJtMSpypKikxShpHm0hiiU0ka1+r7chsOEZLBFQjw9PtfBw4coMEpIttK1LbS2WystJJdLpK
 qKSpJiYRMVVKYxHs0HzaY/PhLUcgKn9YfkNE/URo0qqqYNEwww2ldHLAgmkNtJMNNEoaRow0qqqq
 qqogcqNNgGblonx4Jftnk7+oncFU/YJDp4L9uhgXLwj9f4RC9toj6ILh361vOdvKr8ptn+F2+bZs
 j+dkk0p7D1TuJzVzRdUksnQ9EHQDpM6dBMfA3g6fPhp+p72FeZhhOSujDHKtdN7dz5FQN2qhtrW9
 jREO79A41+fW6eTdiiJHRJjwgifPz9yVZUXz7P8rR2bH5nWYWWvNmqdKaQ32rLm7HV2QcXY4QgRD
 NgWHihIhJeI35Qa5YTf4DTwgZggy2+Mn866/Otk7467TVk0lwKO0k0lIjOIZ+vK3S469ngtI0Oyn
 qFYT8J3fE+tHMtjgmkuBo4Szs9LZxuWnFK73ap+WU/p5dNMtLvZKUvbO+2Zsrw5qohs+uCvTRaOx
 1ds9H5Xp0kX0c/TOUcNuBJVJ9JR1taNTWz1o84kK9U+UrTH2nhbYei37rZyzy1RkuNdqpzOt4LXK
 q6M0+cjStZWiidYViynG7ZaxWz4Ur5z3iudns2q9eNK4J66LMWghnQhOgSH6UyzxdRKzIU4aespw
 QteEsjIVUCQ8V3Fiiu2W1SM62gzILXeWuYMZT2wzvPXO7yU1pngCyMWxikXllylRJTqQ81ppOz86
 73ak7XlrwylN/Xm/CYPGtw7q8YlTqW750mZQsbtWTNJm4GSdmOBAnKVaEQDXckVZrHMak+NL03Tl
 LKGinbRQVOVN71GpvwnSYk76NrByCKXzGDXHEiUHKg4ijjOQiMBERXBg1xxe9RqaYTSGDSjRg5BF
 fP7JPD4Pyfz/j/b7P7fgB+wQ+5/exZLYWvsFVB9iTzHmhRKDOM4NAfmO3uOBUMj4ngXOjLQG6Gja
 GYHefbCS4l/Jj+VUbd/mU0JAJfmuottaxpNjSbKx2w+LKzp1aIFG0IHqaII/sdH5QubwmCkb68e5
 T3FfzPe+CmKNqOFKUp1P3nzMNjRowcPdXKVMe+WLKiWVP39X8SdOTToj1kJA0PWExVm1pKVJSllJ
 ZZSWVJJKUpJJKUlbVLfXX9B6tJJtVIqFSSqIlUSlSoVJInxWSJXDGikqVFU6qykkspZJK63V0pLK
 W6+DCRpKkhU0YQYlFSqUqppUBVJJhSkpSkVFCpSqkTFGmjEVKpIqIxTEqSUoGySoPklI0pIkpWys
 doJPCSlfBwYPy/g4R7p7PpNjMGuErbpev3+fv9/v29+4e0MZKlMrTvfGVwmHU9x5tvUo+MEnwezY
 2/ga5ROqhHbvfcVqj+ffMzBCC1clHgXKG4MCZTCG073hMU58UnvUqqqqqqqvhI4cOkD1VC3BhSV+
 5JWMQiqUkVImKrDSpGFJpiqqqEmKkmFKUSaqaVkRqUX7p0tj8fOPKR88O3kikujzkD1isikO1UUl
 V5/XKe+9YCgJCqwFCFuPGWUUt0mEmkenGGsY6XZrEWmIjMFNjTv0yli9oPzhFRFJ84Oc8MmbYK6T
 GaWBpTnOTG0420vAWBIVWAoQtB4vtFLerCoo+nxMcPPnsRwnliJzBTY079MpYvaD6CKiKT5wc54Z
 M2wV0oPaXhFXd1B96IPvJL4/I89J8COKmI8lOrfown7ycvtfYOhz0I7CRw0EIiTSxhh8nCTiNEP2
 J2IaJSVquhI6voInRUFVSVUUTTT1dD3v4PGaq2j4ru3lCj7gu5I5NXg9R5Q0oeQ+Bw8ChWPTtERD
 jXMib9Ts5PtbPZIE2dQ+wn1xhMx83ynzdXm37FBRQZV77qu7pVla9w8lUsvGOx+CRikc5b+iaTqn
 ZDhs982yrVdVt20s9LdjsQO74vB6J6DlODhwYfz5+0/a+hJj5YUfX9ST4qzETU5HQ7D69xwM1PW8
 XNG4ccGwOTCHEPRVjmch8wL0ILoTskJ6TEIQMwfVmcxHUlipRKq9najxrijOMiT2qJHQlSqRJUqS
 FUkSknpgk5pYgI1nQOe6lcoAbDXdHwubJIHtgSOtsDVLZrWSF0wmWSrZUMs+Qq/SnCzV1O0yYbyb
 haRzY5q22LUQFvbXp4229TWddW5sjLVyaFXdOFmrqczJhvJuFpHNjmra0WoC3tr08bbepa+9aKvw
 v76+yOZQGMo+5uaNwCcwweIBI+Ii4E+lTsWHvq4b6u7jw6JOyengxHVYnZTSjso81cHwU7tVy0TS
 uXirGhOXLl7mngftbctDhSMcJRVK+inA23PBih0PI9p7ihQoUKFChoNYqcDgOOGRqQOMw4oWivzr
 7qn03L55c1jUmrLmXNY1Jieyvco2raqp+VJHl2ySG1fahFVURVSJUPd0tySPGiWplFshtwqEpUiM
 SRVSVUkSrbalpKMUjEUMttNkqTaWRFlJBx1upIOOutZZUlJpgwsw2ySVJSSkkqWWrXSqtQoaaKp9
 BHVtwqkmxhjBVRgU+94vk03bHFTJZbbGVMllhNt+31+paZoJ7iLiOZ4cN9nfSIh3erTRIRucD+Az
 OxkGDsbnlgyD2FDuNxsjQZgPWW7hJCB+c5pQKX19zSgUudleSXm3XmmPGuZldJebdeaY8a6qopIo
 +B7moeT8DGnwb8Whtt7jQIOoIkZCNQYapDjaZae+3eudQYGuHOs+kcEEPg+10eTTnXC0kplSvF+4
 jHoJgY5ep5s93dkq5jJR7OqHUnmhp2O6UpSqpR1VilIpQgvWE9h5IApYHIg5mDedpvNwqm09Yn65
 2Q9ng81aabTyTVttpVW2W2iSSQvAmPJc6QGxsbEqE6RBEOMSAG5jbr53lV+qUlJJJJJJbSIqqpVV
 VVEiRtVVDafEPR+joeiIqTlQqse9TyV3YI/WSbT6uhwikPkT4qqvJRiVRSEqoVKkKUwKRhgGJisY
 qkKiY7A2dFOhtp82imOFaKnBsVK8mJtUpOw2qTRpiUpOVNlTCY+iVt+THRhh9D8VOzkO6u7SSV3S
 V8GiMOw/NoaHVj5KOG2PNE9UUqlChXqGJJWMSpFIorGIYUKlSpEpTT3lVHBUn9BWkrSaY9yVGykp
 UUfVMGK4eTTwbPuSaUqq4JhiqqVj0GnxaY81bUTTCmDg+p/Kfyn5nzPifE8Dud0O6MNNuHLu2222
 25Dl0eA0xKJ4GzsdjseBycHBweBs2bPA0aOhhycGzuNqYxO5PonyaV5K+4qqqvmkiUfQd0xw5YmM
 RjFYmO77ST73EP13Tl+LZE+R+1HzaSfzd2hs3vEyFKqVR6qkSO6CtKxhJMejryEoqSIWxLSNH10D
 9RtKPTBse4BXUFQHmVc23CkV7KW2xJFbIYAnipH+lUlWS21b2raS1SGLGNX2U22vZItpTfVLbevK
 tdVpJjTbcxtb+Hrtt4totW5rZVTVpmslqjTNpmErZLbRtiWgiSDYhUUhGwxVaIqJUUHZYK0kxGhZ
 MRZPo2wncqbWOKbVIjh7mSRVQ/tptR5NuHyVjSmK/bxPEWSI9oVD3P6vMbQkJ8zNz9Hz7uH+B4nJ
 pECVUKnm5rFOkg+BY8j85wYJhvVOG5bApzuAUPIwHAYaOnk9iPAkkhtET0NSPF3dPxGJKCGECLjD
 FRkA59/MiRIqL5H73KO74/D4fPvSnI++dw7v+jTT3fK39Upy/zR/h/ht/FKai/QPpNBz7wg9BEpP
 JEs+PK3d3PH6Pyfo15hRMAkM05cjeOXOCdLM9H/ienX+xv0WO1ipGBNhOGSaqnSUPTKCk51tV6WV
 0z3tP9F55VJTTsaImlWl3rC/qMknzR+W+6FJyWB6UxOSe39Pmm3j57Ju+O5MnJxe9dKhfe5+sm6q
 Upf3Ys1fb07Z28A9wfA/CfYSJCBEhz6D7T2CEFCp7yCR7hnKlwuVMy5MmIR+UoVPpEfOcBzMRYsV
 yxKSFJ9a1SKV1iWrPW5eut5zS1pXVa6vmrDcR8Ipt8f1oNg+soQUTksxQ31uxTKh+xuRyhY1E4T4
 u4zD7G83OOPL9yC0/Jleg/V9ZH37yxptq1VDP0h6IVHQ6Vc5wjSLXVqfmvJ70xatlOsR3RzlxIlP
 8WdLFFbh/vis3otS5pHO9ITuO7k0byX1Ze5a8vbbPAkCDeEIPgfx3/k6KSp6Kh8VPq/r88dzvyR0
 7uVzzrSqK1rUqdSZzJnUmMggZGnh0kwGWFDJJDwsJLOAyBmGDDZswww0+xTFcNMOHV0cq+5jho4W
 dGeFFnTRDKPDw0oQYM04fxyjSY5ccgMhxyQVKkjIg7yxkGQWC5qHM++eB7j5z8B0LHM4Dm42xM0D
 2EziblSQ5ufrkHE4nE4nE4nE0Nj9JqcTU3P2jkcDkIwWOpBBU+iscuWlVVU/W6OrTbl4NuH7H0MK
 bdEdnorq28WOE8yjh4MYdmOFYfcUWcNJMNPYhnD2cOFCMPQiSOHo6SEXJjkB3hkGCQIIJkGCCYTD
 xekY1ZEwt3k4OynMnlk3wcDzGUUMYyfENXLL5uL5dzy+vyr7qdeebSMe8+ytt9cnpujayyjxtkZF
 i/geHh4eHh4dbc+D7ttPQ6z471k+/jHHjx48ePHTbx1467+PLhyWLdYivZPSkJJI8a2iVMpT8ew4
 iVWL/Rcr27j5EF+mzrtP7qvmzm+0+e+cpZ6Uxz12lebwd5kYkIicYiZM9Bv2mTDWLOfkLH4CpaZk
 eIeZoGpfKrhxErJ2FyeZ4+KyoOOIlhAhdn31X8bHL2SqqnR+m50ZJqVh39/ZaqPo4FTI6gMBz5iT
 cxL6EGMGMNtwpry4jP8tDvIM9cqhKO48BSLMnHbDGbB4vcuij5sThqBRCnZg6EThpQx02Ilo7zBt
 oq7pJpPCWabMUKNHbPMHOZh8AvzK4lkWNx2CpPJUFZ0/WWopKQbBqNkHBy5N5YXDEL1mh5AcmTMM
 iZo6uz6uRzLIlcnm9G02m4eVq3rDaBq2QEDGTaEdMDSg8XLwJiQ1TOchjjRz1Kg2ZnG6E0tfeJZt
 NoOSSUAbgmAEQGUDcekBzOcjteZkyDpjOSSd3c06JuonNwgpJ0IQkpu7QKjgiXsi7phVxAV0I7+4
 6rNCs8Pl1d2PseY8UnvNj/KfeYdD4H7D9h+h/Kf5DoeLqYR3MI7B2J2HY7HY5nBBpx4tx8InobHw
 GOQciAsCZxtjKD2hIc6uHuVPc9jT3NhpUOT5OPp1eRxXiw9kmMYOk6egueYLhoWMj8S/mFh5yH5Q
 MChIiTafqR8jq+00ez06uX1P+Z4T/kV4nwFVJKfv08CSCcJMg93mjE0oKoSdfB08d90lCdeGI/2F
 JG3rIw21JPNBX5xSex5B+7buT0bdlUfugm+n5IJtwVFE/CCYY+rzPg2qbfJUbf3ofqJUOUP1xkUh
 Ek4huVgxXJAY0B06Q7U4qInQiKj8IKwx5v7HEh0OvYSlClu683f4PFZfGJd0Ek7ij6VZTzmfRn45
 VxJ3LJ89HkK5N8pKTLUlragPhZWvp4j9byvO/nlGu43OS/nPmJUqpVHckflfNM+m7feDyxPF7UtF
 dXrjS87YtbZJrPjE7xPFHm+qu70m1uGc9bNi8fecue5u+e35lcUV4Lp7sO7rzTPLduqlpV9JMV/O
 7zPpm+z6DzPfTovUKCGhlhNknKUTT684MsmslfS02KymM1FlS2imKuzErmSlJbO0fSV0ec65XAvv
 klqkbzpvp66ud/Hhx13y3zaA9CQiblYA4DuQBTI7TQNwIeYD7D1O1AeTsXEfBICjutClJFZCSRkL
 CgDT5S3C1rEttqLY9IJToutQT2SSR8VKtVBYRZEKqRO3xgnIdbI3BOj6fKSXELKnQCDvFUAY2WxS
 JUjK/dK3VotjZNWNm1+rtrXSGQQzEmm2/G7a369tat5ulSqsfafmPR/F3/azPx/i/jacH8bDs5bD
 5Nm3RonucuGnRyTTbaR2adlHVy4RCCJCxiOFGHTpQzBAFGkc603zL2OTzZY+VjvtU9wSmRhQiTDr
 S4VzW3pGGFj7nJmZYyjSRhSSwsow6dpI5J/Wf0hkP0/HJwB4gdytEaI8igP93UAPkAb9IDYG63DQ
 bQa458BBIpyz8JhqwOfTRy5J1FHIdNwc8rhylJXI5d2G1L1lHCyVzWTL2aEqmdmOitCnVAkQkDDY
 kMCjgiNP5oOLSkdx9g+f8S7fqLXE8x1P+RPNXiej0YeJP4THmfa+j7CeCk+16vv3hjGK6SWnLI/N
 cxhIlAnIGQj1iLEDlS5Q8riSWhQkUJmQ6Nujbv2xue93eKJ4IlUSqnCkNFs4eHqfZJZh4MwwkQI9
 jGCODOFHTT3BhZZ4SYacEJjGIoYxBQhmEnSzgYWUdKNPUYMQiEIRYxlR4cGXZZozpgyhCEIKGeEm
 EjGSSWMmvDhppQhCEIPQwZ0R4cOHSyzh5yYZJpRYixGjMPCgkRwQxDOFG9NLGYcLPUSdEIFHgiPD
 pUcDpZjScW93RwdFVyws5Y0fAxct8X/oseksVK+MfKxf+Vt1Ohy0rwMaVqVKaSmoHUOb9sUQMwzC
 hAVofX65NbDa0naJJtPsyP5lH4lnd3+nzZnx+OlVXAUoZ4M+DCywsQYQaaWMsZZYEIA+SkY5OrCd
 XVwTl0V1bbHRpitKMJEcGWEdIDusjVEGqCO9ucQH2oNzJS1GrKZitYjxQJeXMjUYgCuvVAbxykdE
 IoRph4eGDJOHSopLhw8GUatmsq1d3dRZwZZJJhR0wzUvCPZ+xD736AfQcuSX0lD5Dgi4DDQegDfP
 IXUPwDnvqe42D5voMzBmQejaA4TDM4BJuswZjiaXNC4EDdJHRdnKpDsnny00/gpH4Nq+zHB6JQ3O
 wWw6YsdlxU9xxC5g6mDnsGj/eUWDichPVJCkiSOT3CPUUiqQpFVO6o0Jyp4E9xSDxOTzdknc6u7s
 9GKpiVFPFiFUxPJ0r5TwTy3+X7U9DpRz5w9CvTwbNKm9I7nIm2zzc7e90N03W3mjkNPRptRNMMHd
 PBDzlnR0ODo/J96j735MSfko+B6ijI830+RKYQ+Pm8noEIHeVqeBb5j4jHx/uOWjlUxIlRUksfxd
 8kPgrhUqie9TFHwWJ/EqTzOp6+3uXFxc9nV3Z7/B308HlPE3SycKD4MYlqdVDsoQJmCYaBQ6Gxmc
 DBM0MVxBkXLmQTQQEYOiybdGDoo6q4WTSoYXuxhPesj6ippR3PI8nZ358HI6BpUtJ5OGIeM2yDF5
 VMXyU2qdDvGbcurXdtt0eTqORyqHEpOFQqzssIxXB2NOG84YrfAxJNJVkpJ6KxwpindUYsmllV4K
 TSndSdDqbdVcOrwdXgvHc026PB4SCR4CpyqdFiVhhSm1JWGEn63B4n4p9rtOj0cjrEndtkh4qYqV
 ZwqNr4qk2pK8mDFbWMUdDwNvJ5uzu66dnc7DvCdFnCuVKoqngqOD/j8TaTqqDxdleDwbdR2n4qnK
 p7K8VKsOipGKNrE5PA/nT835hMqORxOp7Ac8NcjsegHe5mV9BVJUJECJk7NOGKMGP5HZ1MfecOiu
 yuH7ndh2QTsxTTqExGKiv2tiY6qkR7FDhCVKbJ+Bp1V5J0K8UfFhMSpNKpweTTZWx2YppiqlpaSS
 UstZKUktlJKKRUqihSqUlSSiiFVVVSqVwfMk6q7z3dDDgx+LTTltoxNJU0aerQTuK04Y4aYkP0Y2
 0200rFY0003/FPsPGxVSEnsUEj0K1bYe9zD9s/xz/nSnZ/N9tvCeg3Je9VXnUO02Hcm+eYijfQCe
 2Tw+E9VofCUfF+ttw/NUm3DoxiVyxtppt0bbacv0dm2k6kxsw7JjbQ6JK6OjDt05vMtydl9Qk55p
 ltKdwwoYyiTSTupcNNHiVlcmu0VVVXLSO627EkpOJLhZQ9EndJqkEy4hyRO6Wfn6/YNx+AuDPuww
 x5HmnZ0aafi6NGMafJUNqNGzEaferBsKTFKThjD4uv83JsrU8upZmjoYdv11JPEx9iTo6FU7UxTH
 l5eUCVHjpE0siipcDTMd0CVGOkTSyKb1kZc2kr9TZMJ4CYbGnC5bTErQfr1bglUTkrDgScG0YOpp
 p1Y6o8XiSdnZCpKlJUpVcsSdidAnvO7qd3ZjhOzHP0f93q9V/anJ1LN7tix4OpTgjb+ZjjZwkNFd
 zuU+lAfSeIPkQU8iA+kq5Rc5nw7QOY7ns7MYVZBVK6MYqVUmlqpKzFbTg0/adXR4EPBSfq78afqe
 DlXYktxjlrTHRo1KbV0UkmKOFE028n4ueMdXZjbh3dnTaqsirDl2YkkR0os8KB7c4MNPCSsGdJIa
 EeDI4IUSWImARZZh06YFnBGExEMRpxiYqcqTFFdGTbsxtUkqyJt0bdldmnVyWk6KxUgxUiVUHoUE
 RAxeFEkiTUrhhfiXo9DJMhCQj0IsoYihxggYkWOSjpphY+xpQb5UidngxtLyro07OzerOLHDSMSD
 BcF0QYaMwFFnCiYjDp0sRRokKcujTSJMYx0VpXkbYx9se3vfD9TEfEPe5PtaVNsI/BwfeTbBWxGH
 CH1bSJ+DqNqqck5JoTgmDbY0aYGNEVo5bcGyPMpOESqdVdHLbzPxcNtCaVSqqFVVVSKUVFVJUVVV
 tscjuxohUrSVU5Eadsn2NFiDuWIr7XsIMGQEiHIfPZGx09hNWUSg2p1E4gqD4iCeg8TY2VGRfCrE
 LHEgFnDb6tPq6OSY+1ty+5XRy2pw6qxJpZQiQ6aUSGCBEmiEdOhgySzAsntSdGnzedzOUpy+7pxX
 jKmqqlOHBkIMNCUlw6MEUcOTLb6ItpJpchU25NNNMdG3LHS28PtT4vmeqVDH2j8p6zThVPuTFH7k
 6IaK6HDhJtI9x+afmQEy/u6jOZjUsFQD3B6XIPpYBrbnI6HdLqoJHeR2ExoEDs4mO8Rcgq0VLExx
 QVVzBFnCTNSk06c/EIjwUCPDSY8MKKJKk4c9D+54OJw2xiYw5abacD/kI+kTodLw+A6eHsv1xw0o
 o+CZOiGRYzSTSSiY0DREBZwYVEfC0ku0tOlFiMYUzThk2qlLtc26MXt3aOFdWSYqxIxFHToy7ULh
 5w6cMjBRQxnhh4SUH1G1GGGnowgZ0yPR6Ng9HgyxnTCYk8OmFQ1WCKLNPRhYKPpChiRJp0R5fE07
 MaVaViq7NNPiYxj83ve99h9SNGimkY6FI6Ej3OWmPr7JH5pDoVIlp+p+xPz4A4+ce/3S4+Hv+Lly
 +LgiiSwoYjDSgsNLNPtJOGBwoYDOHSzSwsoYIQM6WSHX1chXVm3JOy4ma7SKeZm1HTphhoyTTDDh
 s6pJcpKm3HC6xtsk4buNuNM6lQI6IReJUrctuutvaIlfB7331V+Oqth8DQmIwAqEeSsdhpBMG9ZP
 BsaRFtXiDc3HKg4iRxRZR4M0okRIxjD7DD6lls4cLPA8OGnUizpZwRQy4oR4MKP0IZ0sYlXscKad
 2I4Ud2nVo4Zw8GTvb4OxYhnhsRI0WIkJhiZDHHDppIWWI4MZZRJIOEMQxi4UeHCs1Mo8LNOkeGeH
 AQMEM6dOFlHRyUOkI4MYIRoiiSRRwoJOjKKGeHBGE3HCTQ4SUUeGkmihCJMOlmdzfDwYSCPHdpov
 R0cuG3Rw+v52TxadVcuxVU3GaYRGoMD0IQgjggjmo8LPRJYrEYieLxanL1OWmO/7XwfBHJ7w6H2v
 qRssj0CPLTy8le5tWPX1w97o9zqdnZpo6KrGmyuzhHDsrlWkrTHLqbJIXLdqFK73nN95t85navtp
 ZnhGmllHnEunSThoy6SZJwZohlGiaX4CN0j7Y+w+wVSbPP4Jhof7nzRHs8Xm5DyKkx7efTBDixRp
 QzYo+wkMGSfQUcv6rwsosp3cPeI005cMaVWMd2JK2xJVJKgYhjBwjhw4dOFjObPoksKg06RJpw6O
 HRZMKZcY5VWNHKSVt1YMUIQihEmlSuFHDSKNEYYOgRIhkBHocYWFlEnSY3PBnh0ohGRgxEsQYx1V
 w6McNlNqdFSd1OynPbLt1Y6uWnZtXQiFUqkQ5WYpXVXdIV3YKpzyxjmO6JK0sM6MGaMRYzDgjCcG
 YcMGeDGUYxWlYV6GMY+Xs2exOB8CaKP7yPc7yEbVJJ5evq8mNNsbV6vU9VFPqdMKEIZwksMLDoSY
 aUcIRRws60bKUlOG1dWxpsqtNOqpoYhHDSygsDh2Jbi+c7dJ295WvLzi5OmmHSLGIOFF422iwQce
 nd67Lsm7d9JOi71t8VtvoyiSYpLoupYYHBQAkfCer1PFjBs9XuTDR6PAieDxeTr0fD9DJJEYIYgk
 cfQRpRwu7k+hYSQgsYj6DI08OGhZalNHQ04IoZo4uPBkdDSyYzDToxiLLRYyhBgj8cfxHFEiZkIl
 msEizez5fjSj5epyaHEH0SNUV9szxTSQB8TTY5iNjY4kyRA5uQOSOZ43EhISPcJ2cuRIcCKTrVrF
 WgfO2tZqqtVm0uRv5/4vc+r6ve9tX29zbXwU0pXDHvH1VDsp2EG/h4kuFnChRoyRHCiTAizgwhFY
 kzph4UIReiIkQzQixBHCzphJhpwo0QdKPCz9WAIsjAjhZZIRw8zw8K2xjhjHdy5YqieRWMY6vwYf
 gEz0EegNIMDh+ywxAGu2ewtzhJROTcChgkM0khjMKJJLCKLNLKJChCGaaIw0ZhBRYQyJGMLODiPp
 zqVXOWuTI3rEO7tPeScEaIR0kw4SYWUYcOFFjxKRCKxJlB0RTSuUuUkj9I+T9hFEH2HketMPzTHo
 9GcOXmrh5vRyJy8mPRo2MDhURBMQixge2MGCpMsIQhCEILGeGnDDt4SSYcOiEdEI6cGYMDssUId3
 CRiidXVhx2d22O7Tu5BHCYk6cCwRGjMKGcJFenSTgzAsoRYgkRkcDCaVnSTojpYxFiGFjGeDOwBA
 YYWOn4Iq0vDhp0wOCNMYUVXMd2jWGMV0Vtphjlo0ru024d3LururTsx2KlVWMacknCunhoSWMOkj
 KGWkuiKBCEIP6sPI090aL3x27vI2o8ng4eTZ0UmxHs4cGWUIsgsRGlmjMCKIo0MGYaWFHBmnBHwU
 IZQJyqSQ1tXNo1Po2b6YUdGUdOyk/EmX1KMJLGJJTivd1Vwrux1Xm3nVu3MPR4E0lJlqyPI6GKYV
 4u7xazTqY5fyTxlxyruVjbJOrrOHRKpVcKMeCmJSlKKUUpTbBhjs6PFhh2VWDGIR0ok006dODGM+
 DDoeDPCjDhYgwXjFidypBgcuOQxU8xmPUABcwWH7RhRpw6eyTBAhEjKEeyoYjD2eHHZpOlt26skJ
 3nV1UxUQ7K6O7q4vJEaUMksww8GeCBHDRFEknSYYaIMEAoR4cOmHTNNKKGcLGIQcEbaPaaPQvsU6
 yH2k7nZ4PDzxjycNugk4M+DRHAigigZQzThhRZh8mBHTltI5dnR2R0VwTCaJjRXRpows6adJLCrp
 ysxMlcONb2rJ7pw4dOiF1KzRGFnCxUlJymNsZ0k6XTzCqqqOlmEnREmG8Sdpfej4DofRgwo6cPZy
 1vgxFlEUI0Qz2cKOFHo9kjNPLzTDhJR0RpYhwhERBpRRpuHSjw8JOkkcKEqlVWnDbTG806NuisdH
 J00YI0RR4USKTBmaCEWSYcMJKVVKqqVXdWNjuqTo4dGjnh1aV0bdZjFdWJyqaOCO6olbYSp1LhIa
 aDARYwR0ss0oko6YWMRpwqPBGlDDw4eEmxZwsoJEzRkabcOjTqTSk4cbbaacKxKU7q8DR5lR+p/c
 r8DH5tJ7n8jRX621cP1tH63R/S/c6Kp/S2xyf51cKm1fyNMTydjE8B+juwdXQ8U8CYw7J1U2rq7s
 Yx8kgfjJLPCxmmDP0BmHBjGWWM/UPyGG3YeTyPJNkxiYmGnLTs2mPR0bTRQWSfBQdLKEeijwR4WI
 8GdKPZYykaV2VP8zo5d23g8VYPcrBU6q6PJ8HBtK24aeLHLxYxjErGMY/Nw7uGMK5dWzTox4NNK+
 JXk06k6vR0OHowYxjIswR98o6Gmn1PDphQxjJMypwMiQVKFRxxz0DyDxD0D2B5hudQuOcguGRIyH
 HHNg4HUcmflGu00UrOJIlKVDzYZgbI1NjgIR7D2ntOBU4nIuIc08d268d43XfLvd+yiHd3cq6ZKk
 lfzi7UmHa7ksXiL9yTwjO+zmJMbSfPzOHte1FrrVzs/F+5a3EpnvrfXSrvjHqjFMnuoonyymSpWd
 ceN3mk/q6dFy59PDw033N+er67InB3WfdeytvZPfiuPHjx48fZfWN9dd5bvxpV3furKOqaPtG0Y/
 xpin7cpfh/KeLl438K6qXMzZRfs+nnKXzxsyu3YSotdb3U5y/xTVHzyZ+zzlfHj3NPfL8dJ+6dOn
 fN9JerozZSzJm6pJ/jPyj8YHwJm9o5jhdZVW+D8+usY86v36n4iHZ/9zv/AftQEmQSRoxixislzf
 RbnjlzTPsQ2g2jIhIhJIkjvzDQPtYpbH2ju4ccbNn6mv9dq+tkLxXSyaZelO6TRZl9fnX4eu19Fc
 opIN67dG/q1/RiA2fAtREqPSwDwfc2RfxgIfJApQJB52TLJ0uKe3j0uls2Imsst3dCD89vATuSij
 DEjaNKjpsYsk5qdKGiJGoy5CdOiEYDweHXpN0ZKEWR9EE9+7z8Tr8G3v479m7fXKXLiUQkZJEtBj
 V8dbny6vS8yr7lXS+TO5IMbYoifR2y/X8X1t51KY3IHU/QXx2JR3ZfKT7HnT50Vk534xOvm2Z7uT
 bLvQ6Y5dEUg0ITFkhiXd1kGhCYskMS7usMmWjSauarhWuRJJsFRudbubKi3Kq/tq3eccukiFHNXL
 u6jUa7uybu7HNrloZMtGk1c1XCtciSTYKjc63c2VFuVV4rd5xy6SIUc1cu7qNRru7JqqmSopUWEz
 6hTz9lg4dxhtUSolRKjg3Ny/WvFeHdbmwH6lwvpXVZJhJqOc8nBjv5cQ6doFd+kRtTx2oamhmY6J
 pT+j+Gnf6V6rY8pj6qvPo5+emumCOPFd/M9ZQb6tddlM46GxnuOfgEdwHAQXj5T4FyQID+M+8/3m
 yJmLoK4aGn4sR3aMbcNtNlP7HiqsPgOT/c3xMbuUkcp1CeJvrMhROa5eM8qs9XnQ6kpKTpfdfyLH
 2CPiLDYc3UkGeWnyfJ/comp6vk9NPLljd3UY6HU9MjiN2glytrlIOPLfGX17SnjvPqLeHB5LU8LN
 oIQg6Hoc7H1Hurfnx6N428XPbX5616+U8LtI9ZTyr7OPlAZANhuLtsz1UL3kG8TIgGfQ+Q8XlRwr
 WJinr1Yfgrh2Yz8XROFc1wpU49mHi2+Ooc6YMqOaYqT+ak/l+LDxFV+tX4DT2da+DSY2/W0cU2o8
 KMe2IYp8Kn4KOFS93zV8HsdnI5r1sDt/K5aePmuHkqq2xrTG2OeFw7ucTwVyU1jk8GzqU0aYPDTh
 U22cFNGmGim2zbR1OTDZth/QbMNm2HQpv9hwcNmzoMODlfrFJ/Sz10NJDocBhfoMDCg9BgMOnB84
 eg6HSw4GgMLDB8OI/G2ffsnlHD0RFp9dsoPy0pAkk6ZTQvjEoR7pyk7sszQhUY7Hwc+wJsPPyf8b
 s/NExWQFp5QOpEnLhRh70e7s90TFZAWneB0TQbnY9h0MxEwRRzHXWK/G7WotTspXHq3teN40zePU
 3qNi9VICE7K2xULExqXN530UQwduethQ976IYkpEqoVSVUklRUtkvxrLdSUtEWxFta8t1oxGlVVV
 WKYQwilQUhSRhhJjBFaK0QVYSD+m1jRFbVEURa1eXlbqrelVRGFVCkpUqRURGCjs22UqFKkNIhVF
 SUKilKkqQYSmCKmJKjBSKSURUFT2MKUUUpCr85JXleXUaNo0aNoyvsvvqj8FerTHLq2804G07NNE
 0cmK+Co+j7WJs6qOFP1thw0PoV+Dq04cHV2NOjHocHJXgTlyRsNE/jfe06vc4TkaT0aaJoeCuynd
 7NuCtuSd2mlVpjFVVVXCVR0cpMTTDTzPEfxtDyKfo7MTox0YhKiqlVpMVNO5OzY4Tg8DgT4PVW06
 oqVJUoeTq08Dqmx4Np6PRp+jZMqeJcgkCBxtAGwfI9m1y5qNqQDXBuZNMJ7O5MIeRPVg7MadXm4d
 zgleqk7qjwVMVOyQnI8FSK8Dq4OToU6DwebxcqVTh0MOimmjabSqqqqlKqq+b5tJOzxfxNv6Xt5O
 Uj2VE6JPVH0f1uXm4THi06KPJ8k095U5dGnL9jlofa8XLTTHRpypPk26tOzCnxUeDxNHZ4p9jlp0
 cGkqodk2e0p9TZh9HyfZtIjoRweJXd5qGH0f7x+h1Op8T5nzPvP5z+c6PBFRSnk8DE7p8DCY2lVW
 AqfVSPEPEniPE8TxPF0fwMPFTwVH4vcr2IGaQIRuWNTU1NSpUqVKlSpUqHEwaHm7NPI8jkMHkTh7
 j6TR3PucuW37HJQTTKjgUKCEcRDZe+ssXn53+5JnBrDfUmBQGvgpW0tpKS0aiBpVrLslpUAt7ykL
 nifxvRp9j8zyctPZicKY+r6vq+r7nLSk5UYpPxdXvNMfwVyqNPB+J/S3s9mJhyxivwerq+1tH9D9
 GOh1RVSVX2NEH5KqhE9TkSPx/J4nZjDH6de1g1KN566U6RHSSGIRi3kopjGrVe4PR0Pg/FuT8mzB
 3UfxqGh7g+5hiVUpKUfapGmhiqpNsIVURVSYqtPufa5dXJHRy6HRsYlVU2VRSqoopTEUlCjaMMRK
 VBhKSkxhFFakHekSIvq+/y9Y3d8HtTwdMdTXTTrSd4LOMzOIRUuOENMSF4H2GA3seeTJFzQrreej
 ZZ39+/kbjYe8IKBCEEYKQiqq7h8w0OrvdjFgbXYOAP2+bz2HcPQo7RSujunmmkkjxAfk5dDbCp4p
 UP7m++7fzNY1GtCVRWNRrQqFskthbEW1QtQ/xMcyjw/VrnU8k9fJ8Ozs5Sk6UHvrsaHD/M2/qdqy
 bxtNU4GlK+w+/9RaqIRCjMbBIbhpsMrPM3R1In8BKlKQqco9iT6KqjCsUYUpSlKUpSlKUpSlKUpZ
 mSZMyRiokRP98TEikrh+L8x7hT4FKV+DzdUvUh2To+9Wkd3V1bR/h/BcSd1Svc/UNGldn+h/uixV
 YiQZi2rRTJhYkJ/qtWRGGMST8VSKo0rTRiVEqkSWoSqqRWybVKVNJZQyjFNyycqOEhJUpLasVtJR
 UlEqvXuRDBCzFttuJViEjTHDhjGOBtJOCFVI/YxWSIkcOFVkh85U8J/DtHav5XJo0i+Z6J3bbd3C
 JGh9n8vqPsT9xj3MOUe5ET5oHkKEjFAg+TwYEOqkkkdmnLsqFSRwQ+rScK4HzcnRSvbwdFDxPYMU
 V7JSlFKr2aYaK008Hn7X+s+95vV7Og+r66Pxebs3mH1g95Kg98fQqAjU2y6GhoVDA1z3A4NM4HkD
 IyIJnDCdCU+ieTl8HufJ8nzeyfU7kMV7/waT5J+Kn4E8/m4HxUH3vxer1er2nufBE+xy5cuXCE4F
 QrxmB+j4P8B3PsewPo+LuNgaTI2NjYggggyNdjozBJhk3PLwJHkdTge97n4muUdkOr4h944dHvOK
 nMT7WHRK+hBVK7MgxQ7DDmI4RCKu/cfqfD7X8QWkfy/1/guRxEcjzMH9Yrd/h/45fvr/yMH4zD+f
 faW3WGiVsc9D9zqfrpaoOBk2P3OdXNKefKr7EANMfh7UJH7gP7N2p++SB+oE2iUHT+0xbun9YmX9
 oJEtVsuVPAAA3gHDHdiV06/YiEWkTBFe20IQYfBuqPqxkqGki+SYoiO4Gc6JrqaGGLGQiMnOGWLA
 xuhIfKnexq96mrN03ZOtd1cLuyt5FpiosVjPjrqa+FvJt8vXW9d0baXnE5pPYkT2CF9pGeTNGZ8E
 IzF0NIq5n9+bs1vWCSJaJipopY1mMcZN6VggliFRWZImwQ2GFJVSRUqQVKRG1SIktq2KtulSlskl
 qS2pSWWpKstlkstlJSSUkpbJKS0qVstJUoKVRFKKoVJFCUoqColVEpFIqKFUlUigRsSpomkuJwKj
 CkEpSbIpQpSUopRJTN6zggbQk1hkxhMQz/MdXn3nlz0RJ0olUYrsSMQsa9OvRlH0R0ToTnfC6iay
 /XHj059qvnDu53uvjW4vOPpod5ASYGYP00cOSO/kDsTl3u0P39a0iIp3vOoXAacHjeYv/xRh4kPP
 nUpG+/OV2R641YyfLSSG5vAisaLNjCGKxSZUuJjQmU0owVOaKzCGWe5LPSUo3agmmT8PJUrhQ3hR
 tU2U4d7crxxWRnqrKi1NY3hbLaEh8To7SqSdBqvHW5iRmDHcMwgYz9IeGoCdpdTzgDBkT/DSxD/L
 /H/P/O9T/n/pWYX1ddGCii2TXXc1vsvK8ruvGtXE5q56s6KzABADluGcZfZcXvq4tcXV9DlSuybS
 PvTHoxQxjExjEa84yYgFDTbEqsVWMS5v0+3yeaU9TZ2A+GI0WKHGWPVNfLCbdcTZ12Ct8gDWqtRX
 IcPh3VF2xs1/j7a25CuJ+n6uXXk/ALFb8xjNN6e9oLxwKaUempQ+Qc8ZFVIASGOInuM0BTApOIOY
 hvnUcGlqMe42XJvw7bYfKmIv7b5fHx1J2eCxVd5+1uMsCnmxK1JUbiAalcQDsl63UicjBO21vQzg
 4ood8Q27tOADOFD3sgVDgW6/6yiVK9R5emgQhCEIQuIWyEIQhCEIQhC2WyEIQhCEIQhCFstkIQhC
 EIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQvWLZCEIQhCEIQhCEIQhCEIQhCEIQ
 hCEIQhCEIQhCjMQhCEIQuBbIQhCEIQhCEIQhCEIQhCjMQhCEIQhCEIQhCEIQhCEIQhCEIQhCEIQh
 C4FshCEIQhCjMQhCEIXAtkIQhCELZbIQhCEIQhCELgWyELgWyEIQhCEIQhCEIQhCEIQhCEIQhCEI
 QhCEIQhCEIQhCEIQhCEIQhCEIQhCEIWy2QhbLZCEIQhCF3b8L8fXoAAHtwAAADnAAAADnAAAAAAA
 AAAAAAAAAAAAAAPhwAAAAAAAAAAAAAAkAAPHAAAAAAACQAAAAAAAAAAAADxwAAJAAPHAADnAAAAP
 HA8cAAAAAAAAAAAAAAAAAAAAAAA5wOcCSSSSSSd/DznbF0nbekhAv2P6GZ2PEV0cieiCdRQTjAsa
 XzJc8YX89Jk4RL7neAR2O9wbLPW+DFpYs1yzg76Q1JWBiAYsXh2xnWkY6QnqA7ejGU0RRUA9lCnm
 5btTfViUvngD0d1rCvPkyhpYaDRQEEP/jRUuLTLT42ZScfjm8tfeQxH1TxH9mYw+PD9JB33HBsc2
 kPUB6SqZUjPcvX7cmRSCM8ruueywZBYqlc7a2aqA3oLRkOEuRtH7Qp477tQkqZn0W4EH1UyBIdaq
 rYASpLHoiT+PdR1dgep3Vt6noUGZFPcFBMHClsje+eeTSoz3mfGSuDsVQUN+ECOzM667izWOm8LZ
 0iZZA48Xp6pJ72vSUymMd5M2jETvvpWDhXRW+rn3/YpTSHZ31Y2FIGW0pfOScqUIMSbTPLlVuicf
 evBwwd/S5PAzR0ejR8ydTlhhy058JEWAEFGQSE1puygk3VcWY1udqhyAIcQ0wKZFiDMMUKpmMnZa
 PZkXksN5FTSgPdDodIMnMk1y5OCsd1hjrr3YopXigG1vzVarb3vxb94RjGDGM9vz7Ggl1WUjvvpO
 copOhvgGO4NAYG68suAkzjaJRU5kHdC8ISx8A9oPd2YDKG2PHbXYhdA4b7vSqMphi8bE+D3HEwOe
 yBytRTJSed0ppCRh2bNUSTcoVtrS7wET14Lpx67UnlBdgKynDAYGDNgAES8O7WWM33FdJZUDg2GO
 2dJcSxRqTpmD2tLExhXlIAXD1VLzbfDQYza+c53zz0t+YZmBmDSejGG5JtFEGYWxneN+OzXh84bX
 LIlfUUbknzVy7r5mZacyQ6bbMZzmc37vug/PS/QYlEkqoSF0AluEMrAP8OOfYu0tDvjvzIg64bMj
 Uk1trMTCXBjNDnTVo7MlTrfQshTtrbjLrANCBgKvK3TPbhRc7glRIa0jIyS1iAFV2II8WBx62P95
 C14FQQoR9HPcu9507e83XwRhvQ4c6C35P0gfxAfj/n8gFLH6KEA/OYKBVbgQRIr+dX/G3sLT/VSO
 u1/yry2kmzZiRSoopSkkpUklKkSaFERfxFGwsDqZtawUUtulywR/TQIkyf7FaSTzpHQo79530Wjs
 vb/hudPvaxeWC9zQCKyaVX9H5LahB/sIZEOZmUB+RQLub1dXiPQd7mH86jnZDaBoWP1E6xsn36/l
 MEjFf87HVOd755Yf7P8k3ephTFSMMcn+tUklbMdFSDCpCoVTgmMSuFViEaUj/WxVbaImIlRUm0ph
 o/2n+g7HY/2nY7HVI6nZNGzg5NnLsYcnJydjZs2djRo6mHJwbOqSNpg20aG2DbTESmnYQaFHxYQ2
 rx0YmkKlJTlQmEwkwTFVUrGEnKuimzbERVYlVUrGjGyliFxcxUc2+sdCwYynLMyxQAhbnc43D/K9
 qZaGDgO5lccQMB2LOSRYbKS5DPahby7vLXdVVOhXR/0voGn7YfzUiSfy0JD8fy/VgYw3tPQ/Va4B
 ARPz8Pu0D61+JfWm20HYJv+WczhbbyVHQlcIlSCv5nb7FP9acllPn+EYYwQKf4yOu9on+d2dLobb
 Z1paY/3VZYYZr1gICWYoxaoNBzP+LNhgkEvtylZvL6RCSSSSSSSen6/5ttPBRvn3OgZ5bvNL9OD+
 BAkYD+CD/pFGxD+okCXEM7JDIzQMdbX1cy8l28oTp14eUwJKc4Tp1hqjkTnEO78d5T4xjSLnbskk
 kkkkkkLpH+DiVrfE48NB/JeNt+i/YwUySVNyUpEqSlK1JQk160rjNGoSRmK6e9pqrzDqqrxlnpaZ
 I0ca3AkKkoRiaHUTtE5FMkkkkkYZabvyadQ3XLcpU0H0BjlAzdpgD81J3w8WxHGXDzL7Yv0e3R0g
 mh++rSX9e64bTkACcoI22bWk6b6N8Lx2pOAacIJi0RKhDkN3dDXnILI+pgANsbTnkgY25vwEAtcp
 SD0BIEgSCnfE0S/v28m0565+u81mWlpadc1317tkyfH4/sh8USRUSkr7RKofrGIUsEwfPBKLOCQq
 qGfatTbbxRXbylzzvPK7bJhd27JjeFlxdYR/Mi/ueMSos/cqQqy1FrNtUlr/VFGsUamWDSbUrNM1
 kyIw/t913bhoENNV4tjfwIk5mQGoUqSocSKRFSyS2T+oWaorUyZayWS/9l1SeXGhMk2yl/+d1KWz
 K0aB/YfyeXKl5/J4838f8fv6v5KZn9k/ZLlGf3LZ4FDPGqZmy2MoqGFIpAEcxq/JtC9VJ8KI+Mxr
 +w2FAgQIEeKH3XXcblyoh1jUKlf8zJGP+djY1i01utSss2/rNeDaNG2Ez6/n5/ZfnTe9kaVK1ipq
 00WwEkkmfbs/fkU4EcIVYgSWh3woS7EFv3bfJS1EkvS215a8NN1uhaUqCjbBoZt2UV6l9319v1uv
 w78fw6t9SZX/KmWuW22+oIWtywE2EW0GmNmIpVUlMRO+J/2nbNl6ByIKZMUIJEaIjQsUzIWYgbbY
 14uxkyhs1ZkGUmxBsJLARUpGKGUHZspMpCEjrG/a14SKr5hNoMtGlIy186W8lXhKnm3ZOZMV1am5
 pYUXDVXMUlqLUqsn4oBUEAJJIvO60jbvGkTxVgXbysklLhUyjA6U1WrJVijF7NK2TZlJtp77LrX/
 x63WZvUtuyrkbMtRW/MOt1fCt1m23rKubJrErNQUaZekO6VEFJRUEbPKlLq7TRQXhCHQW7nbV6a6
 yymusTdTa+joZM0N7bmkkSrJDKJ/nLFRLIxLOFjFUqNqxZsqNVNJGYhkpMpIKrc01MzM2ysq2sy2
 s1sYjEQDoEZEaGDGCEEgiv0fACfm/21atXGLmMZdQj/WT9iitJZV1dS88uh51zlx3XO1JWQpVSFQ
 MSVCVVUrDBMKVjBVQrGFUMVJUxWJLKA1qSWrLLVkksrJKrExMYqmKTCsFGKxKVjFVFTEqJMUqFUS
 p+k3YVuOZvhrpc3n/J6vSInu3XIiIiIiIiIiIiIiIiIiIiIiIiJ/o+6j9MUE9/xn66LCKGrqJQT/
 ZcsC5fvca7srXyNkHM40FSH7B+cXiR4xaIhUQoqiiTL4w45RaUomHkv/eaKqPGonKK1r+1m27X0l
 JvN5tvrvrTuuRERO3XIiflbrk8q65ETy30uYhyfX95qlUK42dKnISZMnAKFEJCQt24WLQl06Dgbl
 4Sw3TSIXLwkJCdh+RbqAjtUza74HVY/+04HA4FVVFFFVVixZbLLkPF41f69XwxDbdXzxlXqHzcRJ
 0e//zb2iPdNgJWLgDHV1q1aqIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJCQlFFQkJCZ/r5+Daztv
 ZsNZ4KoqdRiL5dnarsmxYjxWRju82Zmqxpcz2ce7X0932TDaSokqSpIiDUbBhCQkL9AzjoVW3NCR
 QiJw4iRIkor/plHTTCZ2WIoopVSAiwJCEfcEYYlq1fN6Tms/3eVvW2RHj6+uTUKCY5V3iNRGBDiM
 xEhECmoUKadZqShFBDiMEMRghiLEIptSstyik0gjhHv0FApeJQ6mkJz44QU0aGFSYMQkJAiIiIiI
 iIifZvleTzy68u888uREREREREREXl5edy8uu87y5ERERERERERERERERERERERERERERERERERE
 XXl53ZeXeeeXIiIiIiIiIiIiIiInx7LSX/DfV9Ovnr5XyT+z1yIiIiIiIiIFHCo+PN4iUQJYk8QM
 w3geJqcQ7iohxGZsZll4mvjLJDTCjTSxA0bNqVuTGmIaLMsSwmizLEsJpyGuYzj7nb84aT3uErb2
 aPRW7Lvem7wk05acFOHIw0Y4HVqszJQeHUJCQkJC6QfgklLo/NTfmnDir7mOzNZitLrXu6cN1cYq
 EhISlDU9edSqKquYbu3Kh0NISyj4D4JiNt1atXJjKv4mMq+O58h3TJjE8mDUjdedeXnedxxwfKiP
 rztHTbXg8ELfOdB3bqXcA9aZm8RtA1Ed5mOQozkQSEUIsJTlXLoYyhFkjKbpXLsRYiyFwtKtMWrJ
 TqDHy6g9twG4eG5pNxshO265PVuuREREREREkJCQuvTjRMI0Tbu/jmh3XRQauAAUOInBpHicNtJJ
 HPvY0hNMjLEI+D4Qn9BBuSClQTWATBiw0VXZB7oNy8JT0GxCFGSpbOWaTbil0OO0ec5y5o3jNjqM
 JCzBtjjCbWioTIMP5j9dBrBKtCmVHcVUsHI6ns9iPRIym6XqXYixFiKCU5Vy6GMoRZIym6Vy7EWI
 sRQSnKuXhH3yNLQu3234OkkPfCEIhQfYAJUR06hISLVq1au4PmsPYJSTvCPr1+P6/f83HROhmSUh
 RTKTt7Fnn5HiMIMjIhCBJGKyUkRslJGN+269XcWSw5+4lllmszMy4S0koaFzNzIxs20mGMTKysbx
 qtbbq90jaXTVXO7wWyre6VwvGMZeLUec9fg1S8lELS5Aocdn3JsXWiY6Sb2a7MEzg3zDZmZmmKH2
 MPfyWfcaTM6iiihKqsjoCEISV5bq6E/X4G1N2YsZXaR8PViI8Zy+RnKI1BoqE2GRvM0F5sViG/pZ
 G5HgmBynbPtImN6kzBXoJwkcjYd9oIIEol2EWShYEfbTCEEYWex45ETEv6/JkAsLQpIPCzDRGEjK
 bpZLsRYixFBKcrFqwWhMhR8cVOYidA6FFFUq0UQoCFUt2+woVhFWdb2d0LQtfsPMSQhJuPtRE/S6
 5ERERPy+Wot8+vU9ddc+235SkkklJpAIpJJJJJJJgAB9PjfFzOZpVWIU2q67uKlbAeg0PhyKNhrC
 QkCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJ3u3y/Z5Vvl8X6r5OlyuuUhMkolTxHJuXhKTq
 RQ802GhIwkr9LgzNTI4CORcRmVrWlVSqzqQQSLDlSxIsV9+vPV7+Xz+Pq/G+2SDJIF9JINNW2lVR
 Ytvi+KdLDFZZEjzHy7pS4MQnF5YQ34MQleGYHOJyh2Q2j4RcbCXaxjBctYQ+BZ+tLPcW22vpHmrz
 6JitMZLrM01V95MZVq1atXlPj/o23uxpfciUzidxeZI5nvB64m8mPAGwIG2EfRQxtjQvodJJQvvs
 aE4Y0K479ChUxzOI+XW14rCPvSydHNXMZVq1ce1B57bq1auvFSxQItkQ4TrgHoj6lmnwTPJokZUO
 pyiEWUhISEwj1vw6qter0iIiIiJ/N8vul+a822lDyTkwpHe8NCztNsJQbwN/h1rPAvOx3EkIy3me
 7SylYoB7TtJIQkWlN5vhKHuVPSVZkvma9To6MZ0w00y6zTKvuMVmMjLJjKvx5aaq1aue6h0SwzZa
 eHWIiJNkcSp0MiRoCnOecpkDlCByZQgiIiknpMbcsAHBkm5vguhexx0J3HQnsw0ujc6mw2wYEZgj
 IkQQbEGx6hyRVUFrKZ2d1yaYGEUQjDhJJoyxy82ZsYm869c0iR4kR2cVcPsliyyTTVXAXu4SLlyj
 vAh2h5e4bkA3Yhxrs3bxHY7e06R691NayaUcGr0mEIbEgeYhH7YZEgpijNIdni1vxbnhW7JVxkTt
 fGyYxvULYDNQhJJCVYSrWEs7qV5RXRLpmYt2BcyqOcT5vyb6rze9fPRyc0fiVbNQTCRCQ+c/NyrE
 +iHoenN0IQlJ+WJT5XtQO2cLPVUHSztYWR7bD2iZSbbPPkcelBDNiTm851Y9JZUvWrZRpF5dlfO9
 8VpS2z8JcNpGrFrQovEkX395Xv43vKvKz2LyxzazPju3RnlMnsd9zXxz1Tw2i9J2llkU48YXC059
 uZJuANlDN6xxJCEmQkllqZFSSSnCen196bnk8FVVVVUkkkAACSSSSSSSYAAfuv3J+/b8fi9XpO22
 /SovUq9XpET6W65PVuuRPN01YsdS0aKq3jzarBiEurdzIhDcNd5IMq1Tq7OrM66aams3PwT3py4q
 1atWiIiIiIiIn1XTuu3Lp3XbuiIiIie7ze7tqt16s4JokxZpksJpvWluzaaZLBkzSaZVq1eCbaXW
 MmaJuQns9sgPmSTMVKITz2y46w+ilHHgpEBq5kZIWQboNBuXhLG7lzCy4MQlD5Fi0JVFQm1TpA0y
 dYiBRAV9RAQPHdSHDLv0y2m2EzfOhtjh60oBxxLAEMjWxZCkRnqxMmhc2rKT59VsHxVAirElUgU6
 51davQmiHCyqiJVlUkryyyw8idFGjeySSJToQyShupGSJSxkjcyTbszaW43u3bszaW43u3bszaW4
 iCCBKK5BRwOvr34FBgsE3b8jIgGFzKMsnns6NMDFR/EPzfzJKwP9pUR1VSqbYYVttWkkmm1GMYMb
 YxjGK6oeH2wfs0nRw5b9F/9zbblPJUO6I2iNojn5fKf3wRB1InHUnoKwUWBihFAt3agV7DKL2DwT
 VU3GubbaWrVu/fPlHVLIH4otLPtVOg8KO6hLZFpCOkqQFn34gaURH1QRMDffxnzUVhHXYQHhN8ee
 CZ8RN54mhSb0Bg8BcQjA2FXAsOh5nkPhkj5SL5wjiP1IaHtqE0LD4J+emElqTRuCWTBpSFpiMqTS
 GWRjgoagt+NIjfog0aQQXlF0xeGKClfR9bxwyOY8vzzSVNpcF3AA76AWgYXgbhFeeHSSqpAdhEIM
 Vt81hCiArZP+EUUpVVVLFWCJtJOuHqHvJSolVHuarRNBSpFq0VDoIeCvc9ZcEyFNJxBkClzDJKb0
 odW4Ul6MIFlJ1UMxGMOEwToRITzVCWWS0lU+LIwK9XUTUKGKNTU2VNJTvbTUbk+Ed092wqduZoIO
 YaD5vgzvQQVWu4IGXINx5zYNxzBRlbvDrsOYiaAJFYzUFd4OgDu3skgSEhJvBxCZCJHribaz2884
 U6zQU+cer0We1PJY1BFpVVLIgVYSIqyE8YspKwN1DE0jEyTyB28XfZcogIoiLz3W+K3z88+fl37O
 vAwxwwzMyYrEtmbi8JckfGmgTr27yJ3QtSqhwO8QbdyR+XS20ltwhomqlvlnp83Cwih3ZJvF5muH
 C5Gbxf+DBf+QxDQYYUO4PfbtTqc/oHb92T0GQ9x5Or9f2C5U+swA72Ig9fVMQDlrhbAJfpQ5Q5Dc
 0QEQM0VfUO9Oh6xvtR+AbD6kiV4V4OsdX2fneJI8SgkiyVCUllTU2mqqFb7H5/V7T7nHdxtWg0Z7
 qLDB0QOONbgwgyMILIjCEkIMj8YP3fYf5G0fyh5goT1caoPaO3hBd8HhFDqt19nxfY6CWGIVFKH4
 ykplqhSB5muk5Go7sIX2oYEaI7rQ77j5PQDH/dxg9IihvKH4R0Gt9zeI/YPuH+4ozPhMBR2tTPx7
 pJ2kVI+h9z3nkcOB6SYv6CCfanhJ4lj2lW9Ds8mLdK+lw2xMqY7v5dY0Lk9Ornc4cI/MvFWWxfNm
 zxgneCebk2TliejTTQ7LS+bI0lUafzmMPZtyStDyR1PqpwdVSikhpHzYkOzRgmIoUkxTDhMYxRMU
 /7DCP+t0ctJIcqnl3TqmDQwBf6IDxzAaGZjmQyA4rxVy4BmNe3mtW/uKs229d+e9b9L1CQkJCQzJ
 CQkJCQkJCQkJHXkK31/4Fvla2vdfKSxfA6CJ2+b1qVUI6QjCADjEkn0D4ID8KKaTB8mu65UdiQKF
 oqgqY1JCQiH3gFmfdIPvKjl7m31Scp6j+9MVU+a8fPzWeVxTuTFMFKUqKpVVYxWoqNBUUqxVUssf
 LyaFGwDgc7Bmh5yEJqSQiwZCR/n/m/NYfy/w8P+v3Nevh+r8v58/9f4f0/0c8v9eW9f1ba6xewQk
 kWQKif1RLRQYxELbKX/wM21gwhBELSpJKm0akUsltGtFJrSlX9Fb9GpMm27rrZNJtpKaUnzqbpVN
 s+v/f2n41JYaFj7jEq3w+/3Di/yAVZLYn4a9p8khJL4zMwdD6pcie16/irpJDrw8rySjLzypS0QI
 hGKJIMvCe42n2W2w6w+mSD2EubhoIMYTbMksVnpXKxY3fNkKWyzNdyog4fTXrd/5/doUqlvLHZP6
 nnbVpbLVyJr/HMh7oqcQ3HM/wIcoYPuw0GA3+YlDoEPNJ/vOf525P4Onq18j5b0P12ZqsGUjKAVA
 QagIyCx+QpogV8MpMRUvFXEQB3/kA+6EAgD6oj6MDnBkjx9FrSQ/gO93XV5avy8556u8eEurDlzl
 1zTSV8lVMlLFMVM++v8pOGHuWRDCHECLDN4wNZvP1K6PwOGoFyrNplf3JGXhJm+Ufgr4lfmx3VWl
 H9z3Eens8rrLBXtRWeylQkAChSFVTIgsgo1SSZKmRCNyaF1SlkhiX1nG95zm0qrqccz0qZIBUxS8
 4982yVQ1JDsJ9CdBMqGnj35ZD7M3J400ffbjiao5aycDc8G0z0XhxrbS1NVEjkskS0pSFipPUpP2
 Mf4iSpp/mP4nk0nVSOyCksiLmRJiVZKkSk+jM/4huN4YOObSzUtLSA2jUdYVGWKGpKS1HZJ2Tian
 BQ0UKsNWC1G2rLZTERubllOirpnRsx6uGCmlVmtYVq8Pu7cdMbst3S0yy2WuRVDCSqCiOYKiW5dK
 iURGEWVK0Q7vBX1MBhMwqOXksv+R82wck8p0TFVVVWmMe4eOkNE+9P3PyY0TaPCeL/geTwSOSU3P
 faRbK5+DCmmFJivVj0ZbvdbzWYmsmR7zT8Ouuvwzlyq85prla7qaSpKYVJSoxjCaezWOLHdAeD6J
 DglFSoUnodXLGKZPr5DtJYOwljEqYlm1wng8/Bd3Nk0TxObpNPcdGicMc4sXGUmm2ZFmtFq8IkhC
 LJIpIoypbNUYtVbxOU6FJ0c4Q5m8IUU0uo4ww5aIGRWpIcQI/d7cYHK2gAwDqIRAa1FRU/9xGLIP
 AXmqIO8mA5CyR1dj/SpjUdPRVEJ+EfJBJHBgO7MDgxcRMHkdwUFE5G1gOYlam+LDdqK90kA0mhxH
 JCDmWAjkbD73ildk8HJ4TqbfiPiHoNFFKKPqaKUncbE3/m/P9+V2RmvtT4STzTgzsDcr6r7k/HtE
 PMmQdwNKIUAy1A94wIbBOYJgTIVXY32khIbrgdTvJnkbzDJIJ8r4ph4idu810WrrtrsgfViqqqrR
 pJNNO0Or2moP6lIj5VELbbaYbCmrENTYGYTKmpaWgaLWVUAAmTYAEw2qAAbaMWgrbMrb9JbbYrVw
 womxMtLJLJbZOiuSMY6Dzfu1pEe8RJGE8KtWsEYPZS0qpa+3ieUCZiTd0/E0LmnaRIkcWprcwTJA
 DVKkEqFQ6DfqG4X3Z2T0/1YAsqySXjw49ngl6q0Ga0BhUUIULUwed/R8eRiOEPN+T8DzODAClNkC
 bbCYEDZg9TDPBQmGKgwGM4skdKkInwAWBhLJZCwlQskbSZBkiVBYhSVJZSdVTGpyqan8bDDTyycu
 ch4vJwpWnKno4e/bZEnbKIs94RBpdP7SY+l+Td+SfE+XVqZeJ6i7Oym9famuCLmuREByLURHImFt
 hjU9M4eKuDTHg0MebqrRwbnm0+RHBjGEuVLbEWK0kL1Ljj9uYJTPXvc344dq6PD0HycPZhhgxEI4
 SSMGMZy2m1bYMfg/Npw4cD0eLbYxjDgxg16J9euZjUL1MsbeVFKmD9epu7D16qgbZbZ55HshEfO9
 fupy8JjEHzkzYgsEWiy8NyxreJNKS9CQTLmW+l4741Ti60zKqsuLmaJa1laXMyS1v1O8kQmojljF
 U+hZBihpRdGE0UlUjiPI755Gndp7NnR6NNOro8miY9WOytJjlp2GnLho2rxKrgZEiEUcGMsBFklh
 J9RcqrZsu2yk52kMVZzOV5LSvdVc8c1k2pR1XcC9Y5PV3l1olNr6VHxrpldilxDIyDCNdyyhROuN
 s9Wd+hjyYces28XSd+65zQtkks4OOWJjXSBHREh4xNydyGE5TwR4a1tvcawBGg02oiiC5IyICIiH
 IHGghy1qvV7SSSbNuB4Z7R2YEUmIrSGg3GyujsIFjUGtAkJpoMzHfB3DNy5kAjnYwNFklhvCwpE8
 SpHEsOFIKTbAYhDEMhENlpRAoatE2ndvFruohltHStw0GzmDkDuBE/edKFHOICdDaxiROQ3shdBG
 KeKX3B/GbEcyET2DBdhRqSyLw7Bdp/+QgkQirC+BPX+j5TMPRat56FTkICb3xO+WDcwGnPkUXAhC
 4OOmdZdAxcck0MoZOdGgaKgPd4Os2dHbFPYqVdo8BSdbHdODUkmO5JEqmkuXiQzm98EPpykQ0h9k
 NiO4cv54Ig+p4yTv24eEmJvCbS+9/aIKg0QFBAK3DZioAejH2X5k+UkqS1VV2n8SdefaYeWYVaVV
 pVRr42QZL5p701ND87nJixcSyfGOsqwpVWlQ9bJGSybJiUlSkLIqSfFMxAqUiNSkO1mEVOJN+XeP
 wqPtj9Cj+I5n85pXEI6PWXPrMxQBrcp1TXy6Krx7Ug9syCecHsekgkA0BOCKCbgBRu4/Ajj/H9Mp
 eM/3VCmthsI2EYEeyurD0h4kBAhwHMgmfoOyFJT76YqVLwG0Kj3ypt+Mg3Ep8o3kDMDI7Bl7cyDB
 g7oEJLvKziUaFGZgHonQs3L1JGsS8K3q3o+xyqp9WNXVs0yPiNYsgsNZpJAaIgMIq0pgJUJEVc89
 LV68zplZXREIJcRZVBPhQIuUuAjmN9gy0H2SgBiZj2l9R0HjfU0LWkkkksb0wDvNdierI1REUOoo
 BzvBuN8nawpQHQGzcGY3M58IAckhpKcjWjnG7gX4seIVTCMCg3tdttnSAOjJlCQkh8pcnk3ZKsqp
 xw0J48aSTWCj9jf5aS0k7SL80VBsJUoT3nQPnjykSPPmRBPPCYClCpQ7kRkJVYDEGJZLbF6aTTZN
 wVZ62rZXpa9L6tu6kqC+y3cCs0GqAgiiodVnFTC22LW4gZmAzGcvf7+yHSE5c8eCDFJwOjc6KllS
 u9Y0ucuJjVttAPLzeeeXm88/xpcFb5WvjKQ00EKVX0Po8q+CSFeqry0GRbwX1a1eJaNNeaizXp5L
 u6rwjYs0ZNZCgcpOIxSLEpcQ2xpSxsmMtWMVFqZciVzSgoQUhIYNxSlUilEynSDCCIbcQrUCqlLW
 IxK7UpJQmnBaImWSocyximEhCjCCIQohNQTSbRdU3IZ47Xpbzzt53nddPMSapl7y3kJQogVspGIG
 hCkpkqHkolpJDdS2xlISExEsGTEJMeIc1IwRipEg1UuVSCipwdWnbiGhq6BxbYXCcIhpKJTbJm7o
 csE21UuhNVLUu1SJVqG2VScW3DU2qtOFUyTI3MpEVTBS2iu7jvG5dxd3VfG1sm3nW9eztdU3KSUK
 U4KREy4ly2MUkIUWQoilDebt3dXlkm12T17Xm8Yty7y868ISiEsp1ScqViihUxtDpvIliJQIrnDe
 8za3DUs5uWdUfWHiUKsJ6wcfMK+YIGXGTtb2xV8DRexJKIFmoHWKUQW6xC5qdhYQv8mPUTUu+Xo1
 /vuVMq9Zlf9Hq09X7kssq73zFKHhSzlEklLKUUta+UolnniazM8Q70iSXnmKkstM7XLVfUgkV50v
 lH1exx5ynOkklSc/kdTQKimOcWm2m/Li70iU5zcd+uR2sZoJDAxuaxFo+xBOwT5h9iULZJItQWxD
 +g4TmSJVWWK3D9VkOU4QTEoV4JoMjdkWZMSdCK4fqdmMY+SeXRE6pwcin+Jj+Cfxm00lTsfsK6Hh
 2tWhXCElZqjklDU+9MD3T3ScpE+bs+9Xi00q91rCphp4P8jZg5Y0rbZXLlorGKrFYrHRDxqItSJ8
 ZSI+aiHlCbxJNuXd3d2lVppjgh9H1KhVJMaKqkttT70Fj5rJ96hK3KvRfxS+8HAJt+zeZGfYZCBY
 iOCBPxe+iqo5Deokr8DTp1HfuKbMc3vq/QAsJmQmeSDYJvIZtCTM8uzu9X4hP70ocAoc0RkJ4kNb
 /V28XiY6SQrrT2tYmj8fKGfaPFuPjV5nBV8b0KvGtiQo8RRC4m8HRzhrKn1nqq34PuYzMrGGlXWN
 XfFJL7g3A6nU5hMyJbuMfYOazBpB5hUMmPBGYh0XMATMRkAZEQkRGKkYhtI0VFPW6auWrzt0psi7
 7TEfT/E/dt8Vj4AC+3uAiJA4JX/M2FohfxiZekhwHR+WgNB4/axwbkJKpasieEj+VHhonucuw/g/
 gVj+cojSNKmKxgebo+FGTofxHB8khJ1tSpK8vdks30p+7zV0EP+634WhrWsX1yjJbktJJ8pqP0XA
 +bG6WHNhYl4Gyz4/b+Wm7b2nlq3qrmSFcWrVuOCCQjrDP4gykI+oYxWJCLYQzOkHvu0AmvLO2vD8
 njtKkSQrHjDVunTNUaRlXDZVXJpibitWZKsrNi2IyRmGJS1dL3u7xlJtowmHN1D4fd28dajLWtaM
 ta1oXHVQ2JqME2B70R1RDn82QJ4QL4KMhVcr7oBOlbZA7rXqSXwUVJE9VrWIMQvC0987ExRJeV4U
 aECXlUeeqmI6GLyxclwheTqcyvSF0uiIce3qd7Mvea92IdL3nuSQTkQ7IZK0Lq+Dj20tgopOQikE
 yrYlq3+2B64Vw/0AqA7AKNhWn34ZCI24cE4nGDvh07nW8D4G71rbVttWl6vzSSNv7oiRNsOGKVVO
 UaSUxhOqsVbKSrpblucZFc3m2SxQkWTRQqkVpjGKyFtzMtzBll5zbEFmTSWWKtzE6aENQ0kmJYmp
 mgTiD7tRP8RAsioSWW1FtbaTWTTNtjG22Vm0VCkWhzKnlwJ0U10RYZUcH7x34rVttWl80qbSUnik
 kdqg6bB0TIskxOCdFttq0o21JtOyGyDDg7VXMjUkKq+JHu33WrTmci2oegR3oCI0fKXzI+v92xAb
 N/4/NWhscafnP00tqv8KZnc/QxPf5miIfVEhoCHZAH4sh7oAPsGvsi+DoQkhEkxmqqGzZ5kNr0j0
 DLebPpy25mdTGioD7A1IJBDgiIv2yDdSmQSlRNTMRgqQUiVSgnMJqyzGFoWUxQqpKqYccyK8oWUk
 UVCosIsQCEQIREV0i3biHDiGyPwFV5dqYG+TDlsY0oqcqcxTePqJxwHlZ6mzsT+U/Qf8xr9+jIn8
 GMkKtHBUmtMSFSolkZiMUqqpmO0JJ8U7fEnqmQsjIB7E+KpyhtNUQlEsFsPyfr4l6WVOnyDJRMTE
 qSsiYyosSJgLJ8IEAQcOBjQ9m6STqobXcdiAIDRIxgsFQRiRhGLjGxBVwYwiK4ySPj5nzZWJvFPO
 YYq4xilzy1pCQ9FaoFjOqE2nIHyVEHYPszOSEijp4BfcPD3Z8hRZEdRlAIDyCpBag2GKwZ5RKHiQ
 JxGaHdAMMBYzeHMaM0M4JuoeK7+zVHINpkCLwVi9xqU9Ki31wH+b/eyS55P7bLTcj61HBT+xSEFv
 FH6oyemP5/1UPr//pD4bJ7vt+r8P833MgMhIsE7KBCmDAUhIL2wf9tqS0agK9YlutCFyKQtKJGRS
 RHpJ0pHKI3mjSmtvbavPNuKxbFqUrb0oSrJCf8NBiyDdltVLQmGrbsr2q3N/Bb9d8rbyYNprEqEg
 EILf7NpR/U0JqhpppDbiExsw+4ikSlfGMiBIyOlspYQ8lUPUCNkPyTfzn6ebKmLVLYqqtquIYsP2
 fokiKQSGcAiq1SKNG8BE0A9yCR4vJ+ikQtQImIidYa0SQDCxZDwH7oqnaMN3tFi8BU6xUfuItfnb
 6/YwL1XdAkD7vdttu8CTqA7lH3gIUPvHGJNfjh3H2nQ1ouYuUJKqCU7SpkZOMQimJidW2iWXBc7Q
 3ZsT5GRiDRCGRWwzyHzG5NQNn0Jy6lSpKkidezhg9Ca5kdaIm6AitBrJJJJJHT5wEmu14MA8zUMt
 FLYJJL7iEe5iP0jz4D5+P06qou2OJQSUOxYI05MMoCYsUrI4gYN6jizeSw1uYMOhwZDddCwyW2el
 y9LONpL6srqkzDj3EdtHY0RCgPWcbqzQ1gBqoenB3cEAUwmQbwp4MiWKhDklnwHq8LS9fXN8mc3N
 pgyqpLSpe1/65WHqYtMkOwdjHg/jYMhCne672EtmdtwdoX9dc/QSrvfs8347lSb+opL9nlpx3lll
 W3HN1J4USzzlNTSnnEq3vjOUSxniazMZw7vCXXMWc5memmeC5V5A4tiRMlXuzw/bycek5zpEnSei
 n3HUocgds+O/F3KRKc5uO+3El3YCT4lVUirC6FmIzJ6ZGrYWiCO4UWEEi2IiitoURCgochJJHDDA
 yzFWWz5luG5CQLJIkjglIFKSRJikkhspExZKqSRKoxtjJmY2rFI1LdMWubirVN90Wmq3VWbfOYiP
 zo0jhjCYoxTlrWhlZZlZT7Mw62M4rC8YjEsh/1M3eatYlQ2+kyeugNA2MDSWGrFhhIQGzVvDFx6I
 L4OYcwV6uAzDciBgQ2a9BouVOJNrR4NkLAxAbqGuXw1VVVcKkkmTwRyQ8qGSSQi2JCkqeMrJZQl9
 t0bxvFWxpW8Fq6WxrJYzTUaqxC1NZCDAeW814STJDZRtZyQLqb1dR4BkNxRDWhxxrv4toXfrfPRa
 Wo1+F0b2jxWcTuRhZO5eG24AOa4cDT3PoSiipRjpJJJJJgKYA/OgP1oDZzg2R7PA3COoGBeah0T5
 lSlIUKkijIwQwVkbkDrqMg8DAIufkQhGRpWBTCHGFlvdOQ48sc4hzQHVzF3E3EIRV4dFTzOOXRke
 DlzmFQBHyTWgBRWzghJQgqCYstyKnTpVluk165ZiYqIeOd6qqqoJJJLtxgIAbTkwLPidmb4P+yCK
 lipEhYiSUoUKFVICwCMQfEcAF3WDewtuxAbiEYK+c3UC9wIlHp/ETQDCCa7tsDgWh24LiD7mxtyp
 ZBKCPDPy5SeEFzozEKGzAX8Mua/vd3QDb9vHdx3XXPsy3CU1bXrWW0tRqxbUltZbUpq2kaNRRpbf
 xU24W0UUm0VRa389C2bRvnYmrC2S0aU40aY+y79pc/TDkU/xsfBOTaaSp2P8BW51E9ZQqi0A9EDz
 vYCHlZT8AqmyCB5N/w0FZbQ6BKk6P5y+iFPFCT8kxx9zes1WtZqtawyWyrKXMZmMzO5wSVjAWhRA
 oLYLjBKoqiVJUnwAjceL3CF4j4cylEyYF3tB6m4tmIclRBoRXb7BFXYCbBtt4B2m9NIHjWcJt+G1
 FVa0kx442eRNEDGRpSE7xB1FUE9yfvJU1CJGnZejnK7Sx1oardEgAqROREMI8hlJMowkkksG6qZu
 YMimQoKg0OAVEc+Q5MCyZjgNHBub1dXeXr1xqZVGJUWVZkwdU8/o1Mk3hkTGuuTaF0MrI5mZYtdg
 rhKHm/cP2R4aaHH+xenlJ2Zy5G/n/R7vujojmU9UO2aROij17ksPMR8YrwLIECJx0amwFW2XcgVh
 LGBGong07dOuvcnVYRhEbWkk2pqbFMqpbFsWytJTSqSqSpK1lkmTAiwCDFgQgLCcs+DPyH/eQhve
 73SFYQtXqMrNjyDhbIkLlVqG1B3sUSw7gTEHtba93s7up0iVTSNM5xkkhybCKMGKOzZPjhIVL3kn
 XoA7W1gGLje/NtZtEAvFJZqpKaxHeNHBbCHatn+QfIbCm8aHe3AxTuuNxci10bYMFkKDKWLUu0mg
 8KSjnW9binjghvKZnomioBhMemMdwjCbxEaFRNJISRm4j6D3D0tlbpuJ24qvELZWJknZM7dg3GqC
 GggGHArK9/VyckRHQokiTqpR+x6yV/+5HdJp1VTE7RyxiazIssvZjKt3mVbZbJas0zJUdCHCn++M
 nhvhnBupE//g6uG51ZOli2rdtuyGlRpowWw1Y1phqTW84a8NN4pkfTmW0v5vzeJ4qVESo0ilCqKi
 UU/yH9LH4qQn6HByGleYo7T4CbMf8RshyY/5WGhE4O6vg8Hg8TybcEJt4iPtnlJ+008BydFGmmPd
 Pi6FUr4sR8FTSk0o1dWarFWt61cmZ+rWnk9XV4Inue9oScqg4ZOHiR5P+BQUXoDZDwUatvVXzCRA
 bD6gYN1POssykKqW6l0JEt99ZkhpYhrGCeyUkmVNOWJJ9stt1llJylE44D7LhiqLMz8e1tXjt+r8
 9Zn5fxcdUjlkLbYq0qrRYfIVT7r/WvclSpJJJJZSWUkpYERSklKWW9fvv7zuvfz+d+hc/QWGtuKc
 UfBa1iqoldNoz13+TA+01YZdrQ+Enzx8w4KlVClirImMkiE44xPsO7fzccyTmulWq0qzRNNMTMyW
 RKTGXE1fPDDcmSV2t+ru7uA5nVKqldKtaPFHgmbq/ciOqI6ojo3VqonCE7pOjM7SqRJVCllLbasp
 qUyUy1Lb6vkHn3220XQ+NkOCaj6nRt5PF2aewwfeKXq9W/K8v3q8rfpNt4DQPv30W+kpkhxoh7j4
 SsHf7iZupoYQjCLCEBFQsVLAqpaqiuZPjGT3SIJUjXq6vjdgJJEwMwPxvvvpfDQctBdRCKNK1A0I
 WYRqkhs2koLS2ufJpjyX49yPFEPcJgTzdEQeLvS8yBaAW5dV4HnTJ2WdDQ0IQo0OS+niTSWzVyEV
 M7T+w+xOw7I4j25CkVHbfYYuiNjfbIAyHcaGeZwqIAmaq7szSAALUUzBHMXUdNpcuUUUUUxjGNzf
 XoiKsiiolWEtUsa2tiUTbLLb6ordHbWdS0ZIVK/cKqk00txcXMGMZGZ3kXFNlq0zc1EVJ3mSCpvE
 UnGJHDUsj0gPTIeywzwVrHdIniIKPaUPEs7BUN4kRHfsUgEWBGCpew2SMIODI0Pfx2+rstuOB6wQ
 QbOeR4a1tylH3wth97qZIzGHXlw6zUstFVVS2LZalp376jq6JHUsZjE1364Wqk6yock5STExKmk0
 QwlIY3CNbTaFTCVDcqWUhvtYuEzU7HFIgnNT0eKrMEkP4OdICd7GtwEPdDVoKoNzYGEUkpifKVSh
 ULBY4MSKfVKg+CYCPQiAFMA6cFHhG8TdFJGWqoG4kqKjXU9G5xEhjl6RBF3TL8ZCp4MCHmXU3EFc
 LL8HdihgOQh6sBpEkWHIIQiRSdOBxTggNJIGWIRVt2Ip2QQhYpYSxalFDdB0hvgTIA9iUMCDGAw3
 A2V6KKoQin7RSIrvyNroOcMxUF2jBUP7kQ6idVWxVQtSDpJ6e8TFVVkttlIqKVYssE57cef0+fu8
 eXLTlkSZcBD5089DevkLdpxlCRIMC+g2lg9LfOSuqesr1lZS+8JUaaNJtUJvbq4aY1daysYalzWb
 AoJkfdOZIAmfYJo5gaNMRTvd/mUWiJZEgdXqSxYXwsmQq3dj4ENRDJIqd2QUOt3GY2HzszVGwDge
 IIIPaAqD99AAnPkpkA7RRilKshuDeMSDwRMw7owiSJAgwmjA7xGlDsjp7Q81BKSyDwaGI0eE4OIf
 mnfuFwz9PZuSOVGKgSmeH4JCJjYYHIyvcpOQ9USUKipVIppSqkqpFRKndUJoRVUqkqpImk0xJJol
 JpUUqSTRD5wJHuY2dksSN6kzUkXC5cJiJECYRBQuDGhoIz9exKGz5XvRXKaYr7NObGqCrqLmLj0f
 AniiJ4ojaYiOJY8u+JycojCTHdTCSCaOBVMREqbfIT0+Py8+99Pg/OOHBno8KAYiRDLmbdXQNSn7
 PlPvvkVcW4KgO02gcDQwYMi1r3ve9736KboG+gkRAWI9gxhR8ElFEXbLu1JDTWXeePqX05O7yeSQ
 qpWnHVOjSSRw8GDk06qkIRh1SSUiSiCpImCBhUiUFCFRUSYkKTChFJKKFKqIwU89MJErSsQMMYiK
 pJKqSNNGdI06RDIowsbcIcJy6PQBHsjUR8hEEcMEJcJLG3DKJKhOa3hEwGxHn4rI8vxXx5Zq61V+
 qQkJCQkJCQkJCQkJCQkbJCQkJCQkJCRskJFNIqmkJCQZ3pc81a2rtp+CAkLl4WsVuTPHwoDypxOz
 hv9ivRKq2W5IqYVatYnrZGBghAd6vgFhQHG/ViviNQdFRyUbQ3eUPj9LVjSeDj+xrylpffPfHwQ9
 m6Rm7KhesR1mxDmWsjh3jvkhE2ZpdwIq3E66C4cHbgG/l8Bg+HUaOKUxIO0feHAZ1QvZkSSSSTtw
 +YAO2GuDUcFMzWmNDNRVAGNo/WKgjGPlXgcTiUNhgcvuS219OyXTU6mMsQDgQc5tJx4nIcXefSTT
 s33tHQO2eQ2GDBoVi0RpGENdYkRgSB2vfjEkTCanNjXpLSUymzZPLOjXsPOsEQBTV52rrzkKErZd
 OPTWxpN8jNi89/Ds6zJUL7KnulqkhkMtJNNffsLxmj0XDzi3IZ6i+I0vKTpqzv1tvmSZqJdkhNJr
 K+SxaKqLdJCRtSQkJCR35XWRh3AXDUeiZNrdk4GEwW+EoM6c2FqLlJqsmjDHfUtzXNdNmRtZ1rFH
 OVIJG1Wwi0Ds7P1HDFThUGEfAmJj+CtKm6Kr1dXhG0ZUr3LaSypGRYpIsVKr8X4P4HqeI9U7EMWt
 KdVXrvR6ZJtNM3Y1mXxuW2m8ZW8vVpCMRyrpKSFbLVuUYqpPFxg3J/MK1WjxY6uCbb4YA4MqPF2m
 yqm222mkRtO9mSZkmLLbRak745q1tw00VShh4SeihmCGfUkwkookYgkdbUiVM2dp4ns5NVLRPIIm
 C2QOFHBQCIQZK1mjTC2mHdSaKqlpzD4SRCYm1TxTEkVWA8lJVQwphVKipEUSqxUqRKpIqeqqSooq
 lVIr+co4MfYw0SoT9CjBP3vk+x9rwcJUCikVJVeBCq8Emh1IpGnrHoPRSVK9ike5WGPg4fBy4csT
 wcNaq2A2xGO0TUykQ1OVtFNaqqz7U+C/DHX6LmmN9e21Ojowqqqqc1DsVVRUSlUpKmkqYYYqSpyp
 hK6KjFVwxiqoqkkrHLTajib4XXgdEwYkmDGGmNvJs2Nkqk7TJGJTB4u+Gu9bSnaBMTuEBsJddug2
 EHBJCMtlni+Y5DQ7qaLQJ2OVDQ5TJc5VRNAEUdkJg9h6NbDBunuPkAQ785l6vfu8vfQmUtbLLLMM
 4s2oGA+Fe7ies2GsAWDowxA3GNkw2UjlccENjNsAZRVkktkiqklsHSIQRSgDf7/hZv9iawSIRIJI
 DGJEvRbBIXswaj2oJf4y/ntuUQ8EOAAOp2PjwaePBTTaAfUQUdAE8WBzY2aaqSW6TMttvZESdkpD
 PtbTwG6J8cxfB2DiSyw0PCRiFS/CMJkTclI+9FTxEWRBOA7BQoUKGSeCPvWSSPN/OxKr1RXCfalM
 wpgG6zwHmZME5RUwcgFDSIUIoWWSIi7LKiqmCeKvWCEh8MgTydJthgoitNpaFgY2loCWQ13KB38B
 9FtU2dtTZhO3m75TGZbpZVYpuDPhNBCoo40R5gMQYSDEjEZJRVoUipZFlBSQpYTbUzW1ZlslsVtR
 lZavnrAxzFHwjcUAvvCCDOSY2j2Cuaj8/B+b8nInvt3WJbcsy5X2E7PRuvqrZ9AfRVf0sV3MdH2P
 UW1h9pEk+4qEqqrzTvU+UcXn5SRnl3DzDkPoyUUjIxSDkBTEIsX3fBO+3HxMv0ekhZ2IsiTEwDca
 WYJky262rIi9yyNyOSoYCK7BfvEhKUEDl56BtbK0dRmIr76NV9zaPg7Tj1nLxVrZZhcC2npw656g
 ZDCAwM+rEYORqNbqMIwbeoa+pM+/GYjMU4OlHIRzw/MPzStJF81s5AzSKjFCC7c2jNkJrXh9He7v
 h1BAe07O7ycMaKqivR6GmlYxhW2MRCBlHyUFCDW9xyJIFmkym2Km4SHlWRJGCEwXQG2pZoBmug0V
 Ewi75UGpMPObrcN7rYwMYSSSSSBLNNqAAD5rlrAMw2aGptQZoikmSEDeftPWdTVmPW6+KHHP3H+e
 sVcqNVMUrEjOm77POx4Hm83uaaNFHzYe59jaaKUESaEgiQYR+UdLqkuNpQZScpNjKUclnVXe2Uj9
 qvwlQbdr65+X6JxuLRVlIgFBE8Ta7rWOGZik88GxBgwdjkQyJexlhhlNSTM2x+H3ck6yeISz6mk7
 IalTaaJrBDSbegTfcnWuW1ktkWVJI8nHa1cyLcVmwnd25I/iT3GlVYegfC3DKjvkkkkkkkkw1xsW
 Z9G0w+83Uns93k+KeHHkOXE96TB7TV9NINpDRkL1TXZQBWKBuqbBnmyDVyjVUUUUZK1iyLUOJg93
 tj3eFXeje2M8/0e0Nw7+i8LFiNLuBei4x3p9WY7kHxYVJFKTePayb14jR+q8rJ63lT3+8sr9rh+S
 VwnROkk+Tze7tFUp6sUqy1bJSyrCgYIk7Xq54TA0DAaSDWqCeoIi7VRkDhzEd5o3Vqew11ubm5TM
 dD+A4Dgbwr51KGqWhaSS0ktiG2akB1+zebxficlcBavzvOeeV3jwo1KhUqFSqHPNVYdVSw/Jr1Pm
 z0yAtDnBoO8B8UFRJEDf2L0JEmS9wmZRKUZ3Je+Y1D3/2ftsfp/m/zmVxJCEPzQP1SRBtE/JF/bG
 s8v3a4D926jjNJtiFv2wpD9pF7InAIRPjliy5bw1l1ny2aqz+x+xGmNIrGmKYrSq001P7H3afsfm
 T/DAkfzSP2FK/k8SSZ803/EYnxmogI1f5tJgfoxj7eRXw5afJ96quifeB/M/tJ/Q0Yp/cjTBWCts
 YabNtpjSmzTRTSmIxKlKbVKVjFMNmGGA00qpE0horGIqopVTQqKhSpiUVglI+x3IjwT5tSMKr7G0
 RwfeioQ2lArkkJP8ISogmAmiSKRE5KaJENkkqQSiKQEBYKhRyB9P4lnLl9USSQkMFfdhCEIQtvOx
 17bGdjwCFQiMkg+dUQaSgN9HSojsVITjrtHMf9tNxbbejYeEdFakVLVskJH+MM0tLZtRlrH9etVZ
 wiF6ROlh+Sn5H3y7LS1j4rLayvupUoQRiMlIVSlSUYxMKlK4/3pf8dvs1NSMfmTNS7t21NQ6IfrX
 7v7saeMYOH3LaxbkTaPFR3Alh185XnSDRaroDddLNEcGK6c1fcWF2bAEPabLuYilx7kwefCCDy21
 kNV59OuaCbMZNSFVVDU+/nSCFrmJjOkkkh4iY2Kp7EWMkXjKzO6mbOusW7vyfy69bvO3oXni7O7d
 zC5bkuYXPyZJqouh8BTVhgpxopy6/mr2vO9V50/oO9XRiNvVzP+59weE/1D2X35FUIokfL/TQwqC
 oTpDL7rYh5qIY+lREp1m6k7o/1of9Py02kfh/Vq0S/UfTN/t+2tpzG4kq115WkwGFojlnrdykImC
 D3eL8D8/o+Qff8AKHx+YuYUxvmIgYMl9gBaRofEa59X2IsNuFRDA/bLAPT5bdEUlyNNV2HxkLDDm
 89+lioaOEsLvIWw141G9SNy3/Pv00b/kdXuDSyq+sLCUJCQkLYww4PImGzK2JjeOvPSt11QdipP+
 siVJNaaCaWNNeRduht07Sy6618rypdcipB+CSeiPSIwDIKRWBs5kDkiYQmkz2dh06uewPBz3WT5u
 DqS7dSR4ajIlEDbRGINiFXVsWjZGhS5VFItLcMVBpZkWKyYypNErLMiXJka01qQbbbm9zRpMYuJI
 yzBZMjE1YNTWaaa0kajW8Ylt0u9RNazazLKtshtd5mi5kRWTU1iLDMzUutvPOymanaePNpZc2uWX
 K41mWmTJZcxrE0jMzWmTUrewa1Mu5G03E7d1nbddOvV282klbFkxpFiaUzLbqakjM1LpUmKyFmbz
 G5Jm61kTNWmMxZLMSMyaYXNduu80dXdk28deL23aaxV6jerqS2TFijFZqJCqiSpKBIzaYoLkwsyi
 5MAjIMS7KKjkXUg2N2KqzcxwaMWluJLlmIeTSbpbrKi2uu27x647S8XWZZMu63ZMospqJI3XcVy2
 qRNGqRwOJjUlkzKxlTVd5t2rpYqXdd3TOXmXSrqNs3x523q67VKRu1rbLetPG3gnW8t54VS26nZb
 XivJvPE7HTZImsUlWFMlVrE5iLpcpprJmaks1F2gyoWSbs1KLzctWnEKpCRpUIMlQmSDhyD+UB5A
 B9Y06nVOydA6MR6aerhy25vpmLa2S+MxgIUI+Yh8qXTav9SdsLShDwklJTM+XEc2jfNRWZuqtLYr
 dJovsSeyvVI9hpz0TnfcWjnZp0JHd5Q6WS1E24Txm6rE6pU7PKcGwvLERVQnYHR1SYkoxMG0ndX9
 ay3qd+3h0C+yQ4yWY7lCZBoXO4zKGhkQZkyd73vOtL9nt2V7joC9ATITsEej2MBhobh8n0wSBhT5
 LA+zXNvtU+Hw7RKTmZkbYWxvLjHOGtc8b8DHCq8kpjKYVjaVeXnS6B13Tp1zs63cATzW8emUdmmR
 qWXGJkSbMcnDzcurb0bLGwSdRJVnWdyK2vmQZZ7AzJAyQSQBqIKCDM1mjTS4YMRhmUSlcMhEiDhB
 YBItJYd6867OVdGIYY8UdFJtI2dGzSklOFSMSVtWlGhy07cTU22OGSu2GcQKhKo3rti1F2Fw3Ord
 XXUS6KGkMoWGG6FuCA8923SEkgORqj4kOe5PkjQjdDiOnIgXSKR6EkKFRQKyYifRHzQe76bEJAuM
 aibHm0XWQEfMsns83Vi1ltllVUqleGifHr4JFb7retvHzv2KkusrNWXOXEuXKhUqFSyAGlxVaBRt
 BFcqB2Bz5XYllsqKdfNyqtwKsCpQm1VTfRMsSWVCyoSqJVIu3FWKysVLKeilK5Y1plVdZmqMTGGN
 MW5bq5ayzSJDIyVtmZWMW4TBVjjwTRrbGPfOtcyTy+7Hkf0d5JJ3jwo4TvYdlkg8HuXRsJugDQdh
 sHf5ij0m5VEQjsEOyP2x4ULwY8b1TYeavfVq1avvmE7N9OfK23tNH+I6MkjtJaWDC4jkEyR0SyTk
 TRF8+Bp7NmmYGB7DB5AdCEMIgafy9fHwe/d1O20Qd5UodxAm4JpA3kwzR5iQ1wmNVbGhoZZGQYGk
 TjcwMkJTGSQhJFRnyF7Bt82pMj9/Q01uMijy1CNWuyHv4K84RTyanyWeoTiojExs4sfSDkn2cqyr
 Vq1X2zCdU4LFngR/pVVpVVV+v+pCm+HQhCeZEc9keSx8cZG8YSrJ7+Nx59ea7J6WdTVcP7QFgUZB
 FLKaDrNVSxn3D97P15BIBJI4aUUWT3WlfGo1PKLEKgOshQSmBCTNzVLqqYgkzEJRkIoYJkkRGlhF
 lRhYJI33fbLcyy7dwBg1LmnaOyEeSEaHOJIyKI2StrVc85XK5bL1TmMMqcpokR7+7jwQ5nEWIFSV
 jf9r5YxmY3A6fT/udL75Qgu45QYUdqmykpF6v3Y/gqk/2Va30SKYmZJRScVLkEqp/vqqSkQEywaC
 ZYlAUpUBKlFS4DiEqRM1lBQ0MEhu1hqAlqq5BvJ6/YMjIO3aZHOq9oNCOjTCSsMn7ZuVHvd6fEf5
 EGOqo/ufJjGkwEqYqq/0lkmGjHeIfehP+A6tuFUiKSicqxVUopRSilFKKUUopRSilR/xqEezux0K
 4cqmK/33q0lUr4KwrblSOHsaejDaORQlSTxV6KaKaVEOjRh6uzScmPi0nBUj5sCbU0FBSUSikpRS
 ilH/9dRiIno4Y4dThT37sQ/YqZFxUkykyUllJSyCpJQ/kFRtAUfswfYPQ1DBoe9RUXHn2D4K0Ie3
 Q0OB5iw2F4KCBcOp8I3MEKqSkqR8z0fRhuE4ST+WCB7gqfGIAX/gUBz+aFfVQL7uyYlSwc4F4A63
 fSQxJrt+L1aYw/e+j5/zZORwJRiTw+UiiGSDJbjQKtRnu7J9PR2kEnoYptB5L2UDr7Aj6OlHoiZ+
 1R3DbsLim0tQyxA+9A+mAal1Kf5P77lrrB+dIpRRSWRZqzKnmpq6pLbMMmYlZgeiRO5aL4q9U9tz
 AmQZOI+s+sxYbgDSHn+qhjLuk/oWLUtiPsIZ98fYHgHiGogYxpv7p/45OUw/BUqqqqLZbRuyulku
 ldKSDm6V11ukpMRkkkmAKlJRFSTI1lEskyK1t+/t9n6DXICPNMGoiTunz43GOkpfI5Do4joc+uZ9
 6evBPd7OnsR14S/lJEJ1Bg7g+KTsn2BFCuP2HUsxhCQzpLij9tgZymPxElk4rPN9zUqyOdmD/2tm
 SOB2TInBowJJUlQG4XQO982LsKIyUkUq70uMq67sGBN0AwdYgHKAKQL32bbX4EXsYJCSbwg1WyG4
 uhsWK3rM1GFQmRmo8jPG6nufqrTMkTCyRLS2xaWs/qt0aizFFCqaUbbX8ptPXTUBIWUXftAbwFOP
 O8dhnllA5ZoGvuTBOntD31lBOqR4P8DTx/rbB1JXfTBN66PFtEOiP+1pImzaEfvfqf+JwRNklSVI
 qKVSnp1uITEGY2NiELsOJoebs8FJEjyQIhmCg0cCIrIcQ7Ok1xw059u+JNyXn1B6Ox7FOydk6yd0
 dq4HCH5CuorR1SVKqVEpJTFURpp3SNPytVNkaieC/q3G0pRKqYpyJNITCo7nCd3QnrPump5FPMkT
 n1Xu8HgqmMeatG9tGipj+TXbHGfdiRqneHuQzhfN5SlG/sks2zgq8oSEgKJGAKZEAIQuPiUgEIKM
 Iin3gR/sUT1sWSOE2quVYm4qsQ1J1nX911IcuifFmn/HCYLMe0oiWQ+NgA3XbNvqzJRKJVJ8XJ8h
 81CshWHzqm2GSbJUZ3xE2DBBVDRsXPC46zb3+BB5624YwGZHRRpMmjSDLJJK0yN6ZKrc6En54kii
 IJXiSSUkNpUSXCdmx+Ls2UcYx+7DassyhxHH1T6sqyvLSU6uj6ETny6tTWrdCB/TDhxITzTzxxXU
 sXYNjUYdFQEsWBALG9PWbirxvZTyfJD/oV8VJVNMYH9KhVDCklWkq10tktkt0trdLpEVjGFaV+1Q
 0qqSqfwUYqRswxJVBtXCokaUkqqpHKoNqNKRVVtjpIk0aTCnR/0f9RyhwKFWVUqipQlBkTRbL5S9
 0r6qWyUllQmmIxFOjCaVVJpjExSNqY0xImKYrSmhRRVCqJSNpRwUaVBwrhpglVKpNlKUUpSlKUpS
 lFSUpSlFEYrajErUthalYqaYYYUYlSqUlJI+5CG0ihJSJU/gr8FapAkz+MaRYh/whSh+uvaVVBRx
 AsrygmxRhFUIssEQtWmvXzep6nI4l5kHF1tXWPJV0qG2NWtFKbb0ZUxkostHoskwoLCxP89JK//r
 WtK1lra1v5L14xPhuFi+honzxogECalq/u7Bo//xdyRThQkHhHFsUA==
 
 --------------Boundary-00=_ENHF1A4EXVDXTE4NFNH3--
 

Re: optimization/8092: cross-jump triggers too often

[Richard Henderson]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Richard Henderson <rth@redhat.com>
To: Bernd Paysan <bernd.paysan@gmx.de>
Cc: rth@gcc.gnu.org, gcc-bugs@gcc.gnu.org, gcc-prs@gcc.gnu.org,
   nobody@gcc.gnu.org, gcc-gnats@gcc.gnu.org
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Tue, 1 Oct 2002 11:55:02 -0700

 On Tue, Oct 01, 2002 at 04:38:40PM +0200, Bernd Paysan wrote:
 > Ok, here's engine.i (compressed with bzip2). The relevant function is 
 > engine.
 
 Well I'm horrified all right -- by the source.  For the record, I
 wouldn't count on this thing working indefinitely.
 
 I had to modify it a bit to get it to compile with mainline.  The
 use of asm register variables falls over the compiler's use of
 __builtin_memset, which requires edi.  I wish I could give a proper
 error message for this instead of ICE, but we don't save enough
 information long enough for me to remember that this is the user's
 fault.
 
 Anyway, I don't see anything that sticks out like a sore thumb wrt 
 either cross-jumping or gcse.  Can you be more specific?
 
 
 r~

Re: optimization/8092: cross-jump triggers too often

[Bernd Paysan]

The following reply was made to PR optimization/8092; it has been noted by GNATS.

From: Bernd Paysan <bernd.paysan@gmx.de>
To: rth@gcc.gnu.org, gcc-bugs@gcc.gnu.org, gcc-prs@gcc.gnu.org,
        nobody@gcc.gnu.org, gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: optimization/8092: cross-jump triggers too often
Date: Tue, 1 Oct 2002 16:38:40 +0200

 --------------Boundary-00=_GO4BQ2WDQI76V4XNE8TX
 Content-Type: text/plain;
   charset="iso-8859-15"
 Content-Transfer-Encoding: quoted-printable
 
 On Monday 30 September 2002 23:20, you wrote:
 > Old Synopsis: -fno-gcse doesn't fix computed goto problems in GCC 3.2
 > New Synopsis: cross-jump triggers too often
 >
 > State-Changed-From-To: open->feedback
 > State-Changed-By: rth
 > State-Changed-When: Mon Sep 30 14:20:33 2002
 > State-Changed-Why:
 >     You're suipposed to provide a .i file, not make us go fetch one.
 >
 > http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=3Dview%20audit-trail&databas=
 e=3Dgc
 >c&pr=3D8092
 
 Ok, here's engine.i (compressed with bzip2). The relevant function is=20
 engine. This isn't a complete program, just the part of Gforth that makes=
 =20
 use of the threaded code, and is sufficiently to frown upon the code GCC=20
 3.2 generates. To get a runnable program, you need to get the whole thing=
 ,=20
 as it's a lot of non-C stuff. Gforth is an interpreter, and requires an=20
 image of the interpreted language to run. Stripping things down doesn't=20
 seem appropriate to me, since this is a bug that can't be reproduced with=
 =20
 small functions (or at least I failed to do so).
 
 --=20
 Bernd Paysan
 "If you want it done right, you have to do it yourself"
 http://www.jwdt.com/~paysan/
 
 --------------Boundary-00=_GO4BQ2WDQI76V4XNE8TX
 Content-Type: application/x-bzip2;
   name="engine.i.bz2"
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="engine.i.bz2"
 
 QlpoOTFBWSZTWWWQHaIALxd/kH////73////v////7////8QAGCdfgD6+VNPXUBUQBGmkvrJBenp
 C7e7lBVACCHvY4x9BW9j633ry3vYUa6dY+RbO9do1uO4db0PbI9NaD0rnTstLC612teCp54x93fY
 sM93brp0d27F24XfB3u1QiVU8o2r0Zy+x1fXvs9V1kXpdZC3OaJ1O2b2u3a3qCyR6Z0vS+tJVR20
 M9i651Lp7t30+6x6HNVVavo572XXsO8t5tEOXQ6qq22+y8+t3r187190BBn23z2XyOPS313L7fAA
 duZ659ank23u3bnbNbKmsdbfeqg9sKVsYEvTw8UdLt93uU8l26o0F93exfbKl9PXF7PXto91327s
 GpsesQ7Pu6rnrr617AaDY0GjG2bndwPGy766PZbe2stQHZz17q9MBLXWNdwQFd7vrx9fNvL09Ne7
 OdzdGy2NtItgd3u9S7ZR3N2Cids9b1KbMhjo11DfTezVSPe973mrPiIqc92Bw8e7Oku+5vt9Hwmu
 94cr7M+xJvoQkiBNNEwgTTIJplGmmmhMk3qPU0xGJTaT0nlNMzSQaPUAekaHqZD9QSIIQQQENEAm
 KfoUyjUzyU0/VP9VND1M0gMhoAAAB6hoNGDGooEFNNTamnqNNGgwnoQaAAaAaAANAAAAAABJ6pSk
 TU1M1MT0nlMmTIaGg0AAAAAADQAAAAAAhSIggmhGTQTTJqZlU/Q0ak/Sn5E2SZT1PJimn6FMgA0e
 oBo0MR6gESJAgBAIAJqYJo0yKnqb1T9U8iGEeKD9Q1MT9KAAAAAfS+AgB4SAkQygUNAfijQIagB/
 FAP7cCYEDoCERYhdwCUrgiShQo0qZZMQkkVqEDJIQhQkFDQOCmVIhErlkEJIGSYh/2b0jpVXaiYh
 xCKBoYACmpCGQTQAYGtYIkMtLBBIJocAUcYUJQMcQUTCJAYQEhkAZGRZAlgxARf38ElHo4IYMMC/
 hBxw/tQtCMV/5X9eA/bFTMXZoShHaidoVyYYTUFDJAQkrVXGPAalKTRKaNi0ao2dZ4Dbzzidqu0b
 Fk3+N3a87XJwpKD+EKUVDMYkaZiiORcXFgP7nEiktnwevY89rtJq/6st1Q1F5sYMajEqgxRlRmBM
 +JjJdJhgyTBcj/rHqmlmHr/pHh9ad8j9P5v4JoDvTvGh//IL2AMFBXAKHnBMO8mY2aiUeD/1noN0
 eHDHpLoHBtRq5RfFZdmliEGFQR9ogfohQDF454wGGP+ygkwePJJRBWa9/cxamtwTCgeLKg0YiIjK
 bxURHuahhqVpqp7GNwtXLXTWVNUqKxbcw5CFFDDWx+jS66cAatZDRQBvVajuId521PKrpFG1GYWm
 M0WTNkNoaa5bkGNhXcdabMVFFy4a2u7tbLIzaFjMKU53dauZlt3brWTYucjYsmPpWrhRWxsGmTzq
 4QzFUagtGLbQbu6qi0bXtTUrbMoYwkGsXGKaZhii1hhmYlJq1hZZVJbNIoqyUMTwSmDrnISbTC50
 M1arGjZoDgx1yq4Wl4XAkMIHdSODmZGROGVn/NwAAZIHEJtW1RElHGaknnO6urugGjUrjeO0vK3c
 S5Fy4RFzpM7upKjJaMFWLZLbSZNLrmQKSR1FK6a85t5PLeJPO3KKCRIYGLnQ8Xi7eXjR28eeXU8T
 znDuxV3bu5w7sVd25Xbp3Yq7t2kic9KeFJnju7pE0yoiiyVKYg5xOaeleReaI3jdzmm8u82ipCkj
 LSQNrDV7AdnXZvIuoFvelDcLEBuDJUpQpKGhClRpKSgqi5t8aKMMCuA3hqPvFzQ3Q8mtEjswS8OG
 UmOFEkw4II/qhFPv/X/J6v8/XseHW7GvAyopClpoooxXKanZmHA6SNcBEAUgtCtAtBYtjVHiuajI
 2JqNaEKVCKJdZo3hhihu0G5zQOtVUhMFGLmZjhvHAgiJycd5q1SAo2hF3Ou5jlzm66duFc7u5Z3O
 6Llru66a8tV028tmOEyTqA3AOUQuSLmGta1ZhOIoURJJBEkEIpiBJQG25KKQwNMBDNILqEy3jGYU
 O3p+DfN8MK71drVopTWwzVixYzKo2MbG+d3RJ7F2QUW2qbSu4D2wmgilIUkNQIUZA4Q0lJkGswCE
 iAUDXZXRCAxVitUWrLpWaW0iTS2kTTS2kTUa00tFphoogMbSBsJUGoDIW3ndq3VFsYKCKosmqLbG
 NZNoLFsli1UAlAlUIFCRb0amPhmJuOJCFXLSy2t4yoNpAKz7rWkJisWtwwWg1kBBSgUqjqVHOcpt
 2PGGaNmswtmZS02bNIQ3W44YKqisW2xsbG4pSYiKLmmEXENugogpXFyNreRuNGCaLLphgWoxDKis
 MTGNuJro6Bd7HrMlEJn6sw68GklNnthINFYHoJhSSaIcwNSMCHbRLRgZqrNilDpjHqXKTZTbCm5Z
 TmJqREsJkbUtNjdUymoIhOobk/lxmtTh4prNTJDHEIKKlFTCJbY2iYZUyc/jdFOGer5t7tWsTU5r
 V111XtVhwZWq1xVbULLq9S65Q7VynLi8647nbr1u+fxDzmZHgqZO2ZttlJSQDTBqf8X/v3E1H1/+
 ebtY6/tr85lK4+uvxmvPXqij4QmjIBSBBnOpjrIkUcIRFxWsxQDMojAUxverpaLG2sRbY2o1EWLY
 1RY1GRUZqCtGoyhBRLaNKj7VVQkAB9Nhhux7q6Q2lqupVu66bLMLqrqrpaaqaZZtNiZOnUjV11za
 lalSWYNNNmZNrKy0C2TFspMqlUqJuXJIDNrTVsyVSrqlQjIRUwkTCRhiAJESYMWkqLZKiWbJFy6u
 RbM1ou/2TJNrQskRd9uuNuVmCtl2qHdVwY1KMreu6zMq8q8VXjUjuqKuzWLSO6oq7KotI7qirsul
 JiDZ2dcuMYY7bt211ut4ZbvOkc3RMwkDpzRRCDN3d1y1zcu7ou5JgSl3cp3diE53C5iNhd06o1zc
 ulLd2uuTuzuuzTu4oqURYua5MyA6XW6Rp9Vnnlc6Edzq6mvN554JgXOg27sczKYlsZVkYmngwwJk
 RoDMnAwNOGJQWWMEkVkmWZzrroDNkCZFkhgKZmEBYWSh0uWF0BIrCVvMIlqkiRikEGkAOdjgaC2Z
 lYYVFS5kGiNF5ju5123Kcuki6Wd1c6TOl768h505OXMFLuUY3N0iulrRtrXOYLRVXd01KPRt2sq0
 pVGqaJ61XUGKlU2UUAJzrwtEVyVVDX/07ZIdtPAN6r+raf8TV+7CtiYJb66fnrHPUBYYdmAAiAyp
 NztJm5zurt8Bt4SueClNYTRq5147KomUty1Ltq5tK5a5oo2MSoVSAVGs1Do1mSRa1maxzHKiQbHB
 NE/kst/7LRf+G/stFW8UpUKAKYgVlVAAye0hSdQaBgQzf0v+5h9bAP7Lr+1P419bf6PDAH3m7mP8
 3WbrKj/XemgX9d4dsOpLhRvFNMbGNuiCElqOP4wbMf5bTC5YtVF24qobeXT3676x/e22qGGx/HbX
 XB+uUHm++KwMGX5mzJSMLbY4VNPyfZ9FXwBaMtaPVol/2YkJ/V8k4HXu+M9OCeYtJZSIcx3ZT1W3
 vms1G7w/N4dVznLmMHhkh+/E96mfb1pTtFseoQfnMJ+He/HPS1k/9OuZx4QdukUVHGKm5OHPJiYB
 mz8b2vbWMdN9qjxykovW5xx7tb6N3ob32jio7XdOj+jpjWc4zt8ajri8eUaXFE6NOzeFPPb38a69
 +tU++/tPVu/9T1zWr7NPv/duJU1xgfn43kMm6db+DXbXmylYtaP/JjP+acLquGJPWfPy0ZWfE9lM
 EwZ2jbJ7rpEpKIEdqrVH+TFTp2zrwatcXx2/bmQPBCdIMJKFpa182CpXShr10O7EhTywb7XfckqG
 zVnyu9qprPWSagOd+ZMstqGj7JzPDtJYszXG+sljTbcNYBRGK9xB5XiS4xIdWiJmaesQdGr4qc+z
 I2mSZmSZ5m9tsU0kX0SYEJE4UAf4KRqcI1IiGZtmVQauPSEUlRALEHUkJyIiWlUQU0xrqym2FM+W
 Kzm+WU0cSqYFTOHrzqc5u4+W39XqzuajrR6HTApaMAUCIbVe5xtopzprLUTSijMAhJTFcWFVDpcQ
 eHWxapyTPPq3NYN413nVuVQbxrvOrcqFGpFW6GfpRaWpFvkRsmiiyDhwjklCAZFpTGqkiecVx1Ep
 YRCiIkGOodCPTyO6Tu6I4V29/q97ztHoo29iOY2y5OQmX067aM5xpMuNZ08cWgofGseZX7IzVcel
 QiRjY6aRAwzEevNOV5+kOo1h10p5EBNYhuiCMmkBNedI4II4gKHEIZInKLF4RFMgCAH3xlPiD7QQ
 /f1rjjLvZ041oiMpcMSMulgtULB34dGrjDUcIsGwUQA0bgOJHdQOzcn8Bv+oO35f3f6n/fR/Uj4A
 dBCAeAwA/peQtCvhBUH/Vso4JC5vIwNMA3vBLcGGoOIDCA0TbojFdDwZkLsNhgpoZAmKC9mGQhBL
 BIJ536XyPIhh7vPd5qJM0ISd4jcVD86UTUKDBbLLLIRabQ0+qnu3uWcC9mQIRAxDOnOAnXNRRRRR
 URTKIiAEvS9KvPPN4vPFVY5lYGggHxcMaFkzoeB1ENqcdDo9TSb2azSE9f/k6ImiGmmIBpAIkUYE
 RMA5DB8EKHSr8drHkOKHiHkeY3UVVVPOd/EAHxAB8OO1WCgMREGMERERERERGSiIIiIiIIgxBiIg
 9mr8H8P6MSpGHt/Rx/n5R3V+m1YO95CEZzmStffalp2usM7O2RY+nGn8+NzM0IvKVgmfMV+v6dmT
 u7kYQi7zDwXFb8mZkzFAYiIMYIiIiIiIiMlEQREREREGIMRH7nx7fLst8C9+t8WiDmOc1zO4O3sO
 c3484mfXz6+B34/4LFXcGZongECJTpJTycOA0p7A977HfSu57sNVVEVGEDVmrAkkCSpU1NTagAbU
 00CQJJCENT5QD0y2q8xeQgPhZkYFwIDjAkCoMYwgKEAsGAwHC1KlcoXckg+4GMfjEff5hsa48p04
 Hl8NbxnDpf+JXkjy9rPQU4PUTqJVVLLp/vQ4dwx8X9/+X5vwa1rXJ3gPAWVpdta19C/Ze273aCGG
 c69F2wNr2DxYRDo9PW00+r/i7xnao8l/X3e4eYrXIURlgU4X1Qaa0f2hiAmQCUqn2BIgxoLBDUIa
 HAvXrAU3IkYm1IAP8YCWath3y0dN/9WrkIvXy1vZec++C/OJ7lA7GAccYGtziUkw4QMO00ugdxCf
 rJ+joVAvGBsgMRkZNU5CgKglMqTZ6OgastWIkpKIkpUqmpalqWoiIii1KlZJKKZRJby8vTiyGh9d
 /XDJcrJZIG8cWarg2tqFrFqI2QvIQqcSI3za0cBGzMNBCLqRG3vVHYMHBgK5U8xDQmt4YqHgpj1i
 CB6wqUKMdeFDUNBScyJBKuXUe2aKtDHKAkEEHtkWxYbxAw0oOZmRQ8kQdGZmBjQjhgYj1wD96EdH
 0/DTxBskHcD+vufiPlY+z4o7j3We3fTmmg+8xt+ig8FTwYokYxiDFHrFikwK4JIrzTQiLxXfij7b
 obj/OanD9xBOeqWRXv3F7dR7tsykbgFH8UHQ/Djld3d/FSgHIDHrs7GmL0hvNUaFYwEkVzwFAeAQ
 DzD+QDhtylew+G7htnj713rYQUgcBYxN1btts3DAf49AG1fpEJ/w1uIFpnV0Vp1u16/qAAAA9PL4
 n8PXry92tbrvh/GN90j4iiQUVhkLUGApkCPjivE4F4W/oSCLhkYd7llVY3AL9TEzwZGH/A/kZ6Nn
 sLUcuQFCgjICvoT+yO/Mcg9XgY45QJ9dn44oyZm4zeHdn3QlR86FGv/q2GSEwHV2ncEVVgSEbm3U
 SHFj97YZjMYxfAbZnHNuwGGbN4dqzOjdlmx82zhsjMkw/Ay3xq9zRk9aF/9+jpnhQuTyhyxKyury
 pU6FhVb/42k2bjIb6Y212xOqw/vPw/e2xl/tHRGLNKpVg3ZPn9+92TBIlppGVCnZ4/s7hdYg/wfJ
 uAYKxNb5R0EMdhiTSuWhm7C8lQLXmnZVJFsAfexsSeqcINgkBglA8Ju3aH2V9A4fEf5rZDWNc9Xb
 HPLbB4MUgQrdY9s/NsVYFzW9FusmZyUTGrRoNeIhLFLrAN/sHC6puPFw/Hg4PhGX5VU8a272yL8J
 2ldOuspxO5ireUZZYy27ULH0JYvq3oEt5NJbkTVTUbP0bfillrZAYiD/+MSbBlwV/AgoNQgExbt9
 ubmjJmUsOi7VeR2XatC5sbaQZmTLoFTxJhvOqOsWIR0CwbdpsyJ+kfZS6VZDwY4z1pS0Ie80qijd
 RrRNVtWQZ9WLrjyA5pMebk0ElBOf2qvnvCmJokH2h7RMBKKKJYWgTxhFnYikOzw+NRw+XP980Gow
 l8Bwt8LwkpF3lTCbND1+z9/9nsyyt+T8TCGALIDJLASZOtu2Gl2yg+i8TgcCJPqOh1fYdR4hk/7c
 GS1KScRThF4Ys0N2O7duy3YVvaUr6Suurfr8YGi2++lmg2iefj54kJ8yoSSPc0OjJGqDN+lLgzoP
 DTu8bKYG71L6lIpEIOm84u/MzBSkMFzV4kY2OqmmkemrchEOByQmSEqwKWu6S9HB/16OjH2v2Ifo
 Ac1V4B1CKbNtPruc+Rl9j9on3H0H9B1A4jok4DGVQTjCmSBdVPLNYoa0tKUGiBI41lIUJ+2uHLq5
 IbawQwA9oKnNTEwlTHaP+gsSOgkgRaLaw0CcNQkPMHuZKwQy5ujWME4xekxkiNXEGiMYDAj7nbo1
 xYazsOi/bBwgajE/w5Feg1Shu7UhuhgiBrnVurPlbRXSzJoYYMAg3JXhp76QNydZQumtcYE56saN
 BzsCh0BGpotHPAZe4L0wZ5wKP1Jq8jALTBhFhAbfRXLAlMUD7wZBAwCQa1uNnTjm+xGKrOnA444k
 KTiNdg9FhRdhAVCKdDw78I2ODP9ZvF8bQbSwcASDDqMpOCF3UUKg2fi8sDNwccIY0qkKiJaKN3WF
 SShqG3Px09x7WPufX8lCn4McOTbwPM+W+lAAmVZpH8aLlsKYF4OwVYO/dR/+vx8SeOCZPvZNVxmC
 L1cvE82PxYfzsEE+CT9ihNl8QpbJ6kdlf5eatfVj605Uo1+pVdExgDCBDFSapfqq3STSVO2auuVG
 PkrY80kxUWhm9U3738tROF2+LtDs9Hl5PDTmUUUwCPEmu/GAZtWlsvA0SJBhPJdEiRNNjwASUM22
 EpjGEY2FjyA8g6Nm3M9F+V92Kn9xHqEGh6gwUs8mFJTQJgH9J7vccZzyEwpUysH8UOCDQQhICVtR
 rViySbStZVmmhlI0Rb8VlV3Vy2krFSrSjVoqWlsrSq7YNJBsUTcunc0Fmp1yRYSi5ymddqtuVi1d
 Wi2p0A4GVNMqRQsQoYsoEMHa3Vo2W1EWt1RViqkqYIakoYQmAPGAVDKv5NmtZIUlHXx+fQp4XFQB
 +X8hmihkZY9EYF59gCdCqV8BWJW4lQZj6AE0xxe0BMJMCKgElH3BKoR8vW5uavtpQS8WD1E/dG+P
 2oBeWLkISPJja9G9YHHi4H8zBdXAbzBPhGQJa/eyRqiovARA9ODTyliUFVDUaMfwzm8pJ6B9ZEQa
 D98hIbR/Kwuo/rGzPZobTCJqAXyjHPWaE0TVIENqmAxIpWmElJGIYWZmQY49DoRkv5icotOs9bOy
 SJJvmyOTrsd9Nw22XV2+glgolgmDRxjqFwxFsaJImYIjKLnieY8x7DqOJxLi8vFeF40CJImUJASp
 YmEwXBRo0aODBZZZwUUUbkkmSDBZR03j4jfLt8e/G7s/CruMgyRYMpUrf8iwyyYs7xiUPxm7r5ou
 WzuUJU88zZK/mB2yk/4f7nXh/CXnGxcz/j+Cvz/3c+SvZdnZpm0s/47Ky6N/u+b/3lTJmrgHz67D
 +2E73u/8Ri38IkMwEfMHj5g/h5IXkjtSD4RdZ0g8hHoSEHdZPqifZPZHEZzrE93pR75MFafIp1h2
 xuELkQjSwLClf2Fm5HpwDG/yahnbKDj8s4YddlBBCBRA3CDkxAiM+EZmIk+fbkyItdZM18Ekgziu
 pGJgz/XmaaOvJwzZ9YHBl/CcvzPcWVGp72vBNfkmtCtH56zYceSfJsqXxXPTCJKWhkL4QX6RzUt9
 5L4V8RJbRsJhh84782gMx2O4RGBANDYRgdePX+oQl9lAVRKQHjWBdGd+6wj9MUB3wBMUD9+IADz0
 HoiA6PDge8lNSGXqrjNaf2bUEO/lyhxDXZ32PSJ/rkPAk6hHZ6qFDcxalQQoQGK2nLCmIMSxgwII
 CIMTrj1dJiN42A7GHwhAqH56fSKqFU+tOvsLg+xVHSFM+o+jdj9BNJ2ZlmHz+3Rr2eBLSZND/JOM
 pVGYZVrEMHMnTIZQPs3V6EVOm1O2VAlLEKGI7KHbMGF3KbvVIakfaFv9vMy8+2+xNK0ET0TRxve3
 zxXcnAKNnTE9cal9Go7JwIIgjDXOIA3DiBHDYGcyimgt1UypqAdyrxo3hasC1va+jIcMm8INzpe8
 vNsL1Wg9XfVYEYEYGZVVhmUBr5GwQl6i4HocmnR19XfRXNfR0kw5xOAuCkBRkKZiYiggtm4A7GKi
 /W2BoSJIScKy6aFS22K9B5kKQO7OizMKo5wCkpfikPnjsob84dSe2HG5PMhLkNjjFUmxmGlFwA0k
 WIIOAT0iUHUAYGkQykOro+drpBATI7NCjcELPfedyLnm6Do5tuViJhsedjjmSdp07rLXHiCmBYCk
 FgsBTcIuKb9rTehsaO0DNY8y7rPQkZMwCHJMGrTjKowOfB7xqlBRkyvNb/rbulZu0FFbTWOTTlBM
 s7DvOOHDUNLtOoMu3zwimPZgtuNboHwl8V7LbXx2ZLBjQUHp3d/rsG/l+jkOkbcXgoPowx1nrJEy
 ReCBNrALWtuKh23vNNiRYWZGggTLSSVgStBwbU3GBhCQH2ceyHguOCwOYOOVRcodHsYozCgzUbNY
 kFoKiNAw0iETuxs86h/RG8m/lzcKoZue6UHPnHmY/Yj1Xr+ifT74avDWcAA52bgcqukkhAJCQAAA
 CSBAAEJCQBJJIQCQkAAAAkgQAAJCQA0tAi+REZmrRMIZh7T5cekIexgTiapXBIuszOO7mKzLTiIh
 kbRIQflFcRsn37njA1aEKMyQ0oiG42DLPtvL6UHsSYcw9eTDe+yazRLTNKo7CIEsPPwvrzqctykj
 1rqrN2K3mD7ejdLlobG27dvIDIbriBhOda6mu4PrZCZa4Q5AozV+RCBighAutdUJwlidhGQwQDHW
 IFLU4KMAYsEfBZhP4uiUteqnaiywU6u7GlD05qBdLrJvM6bKaxZm0pbFhpJp4phiqiIEe5SRnI0s
 GC81csoFDxUXGLWpM1t1NmtmDvl1FxBxOEO2XiVDUB7rJCgDm6BGrgzAriWjI+WyWh6860JRTmYk
 L0xB2Scy7GIY2JlIIFFBhxKnMFtFOQ0sQOpCUeGNwF3goaDbwHIHPHrJwwOWVWTYr0mCX3M8vU6+
 geXk+ZUS0zQAvqCCBKPFMa0wRbXns2bNd1s4iHG2ot2S5cSSLDJDIwyMDet1csGbxmPK8/U+e0LW
 aPaBS1dJHWawS0KASZAN+pZQJUQQmBKhG04Nan3nqze1wMiJMCHm0wRqXJXd7I34YZ53Te32tELk
 67nAFqJPwlpajSjACBgKEpHlQNCQGFYcQvAshLEKS6VTlw3ZbGlLWM8IbQgIXRPs8fVzvW8elEhQ
 UtacRSjrVZamKjZbrNCmi7yHrVRaqkhBH2Ro6jQlLgagzLcGkslF6wzuQAT1gJ7AS1EooVGlSilU
 pWADeHyQ2bDSFYdwYbyeDWXxUSUyBvvqHvEQep7SEzaYwnrfCNFT8Oeed6yTRqNS/Z1EEttyzDCw
 mZInvPZo5GGHQ0s4DHUnWAeXWKvVkO4R216qqewUvOfM9PqPVb4Hjr1ySSSSSSSSXQCRo5jL007n
 Rw/OawGjaoYaNGQH82xcAgIYYIIiIiOhKp7/d5J887OxMd0OhLoZSB22gjCLv7K7zh8NtFtlpMmA
 14wNi9IgbIIgY7xNAqWx8GgnGOnMFkEQ1p3ocbtscsgcjguWYoPawC7QMQELdDQUjBSEECBWkeGF
 0WjysEq0NHOgwgxIYM86RAuLQsu0GmXMCm0S2hXRxIEMExLDHGuVGjHKqikcELn581ASm4U+Dnc9
 0utl4LNQ74BBAP1Uic/hXWIe6KP6+RNxz9WX44PPv6Jl/t+Sv9QwcMHy3hTGcXVf2/sf2CGSNsQP
 IVoSI0MB4dz/pHlufrYHtpt6JoH4MqdR/x4gOSH43ET/Kyn9jrT992zg8A2v1P0wOESzd8NB9DJB
 8//EeLgPj9oHKDoEkgSBAh8SiCWKqhfgasA8h81KEIF0OJgyJMXsvu/W8iX/n8MCXefJlcwX+Fey
 QDT158CkSo90uF6LgoHeBw/wGHshjzLPkU22IEYxFIYTmAGw/X9sASkXBi9nT2ui9Vq7dEXW7oiI
 iJKCOyRY7j9DLuU6QsMDJIGJmbR0cXO3YNcAO9FNiGPDIYMNrYaY+j/nHNH+TB9wQZbhfy5ENwmY
 BCe7K4sOBBKUhYQASJD7z+uB0/gV5wn8M0AqAPSP6jdYWuIeMRD3wH1c5QJN4YUrj5P4967a1VVV
 VpFNM3sw0SAB9ofkamgEwgQxf45gEwYQwtFdfgSZT1ukKCfWDHHKGdwOT9ZQWIAZQEA1MgaFHswM
 mHWGo50mGylnjztLA6lVIEBHMIBmBOygD80orLg3bHbIL4wIvRonpCXBgADyIbRcUfGDrBogJGJC
 RShAfmYTZhNAcvpvQQeWjOTCh+Zn7SfPqNQuJkGVGLeLypVNomhHy1P8sDSDnqF+47gSRtIgei/y
 huYKsHTTI8RfuP6wST9BxVH9Gyi+TERPisE6hoBQByQhv1VVClfMVBIBGw4DwNAVOBmkmAGTIZrk
 FO7CIlwZdZOHlH7Riox2l0t3V1Pxr8X8ImWOL/hrGM5M/v/hyvs76nwaF+IRGwzA0YiEqssPeqd2
 2SXixYSjfcRl87nITAFwwIug/lxpygQQYiBu4+o9+WQH1w+YxMCLFpsaskaU321aACUrRgaLJDLK
 qLLiqm+lodEyf7OX5DtaZ2bylDsuZroP0kp1KxhyjIsxD8e/hh6XlAj3s8Phl1SMOh11yvMSu5pf
 bYti7aEPxNDc2TDtwTj+vDEaZvcUxsnHtDjGUdDhUphdc7u7vhXqaiEskrcr/c3nFiekYrzENwuu
 EF1S5Tg5GKYiNTbs4EILw5FNYuo1OOA0yK6kHJil0U1nMNQ8UGLIwMVppEwQoxMNQ8UGLIwMeHQ4
 1FFY4ORrMMzDOHbpmdtxYWWHDmrRPJJk5NGTk0ZKPAp8204qaAla3thsjVC3MyLmf6EEQiK+MUEL
 DcBigIkDFcXHdnH6Z4ct76R1z1GGaPuTOH5Lp15NVzIP8Okyr5j4V8NVGFD54msReI8J67dDWlEd
 +nfHHSZdfg0JS2ppZVMKRqNKtC3kX5Uk09HHa1srejpGud0LOfc115bFR2tBlvhrCHnxuk9cYvHd
 dhY3T3yjttXSVjWcNl11HzurffIwsz5ToWuwWOF2iiHZG+tGyjNraSaUq96uSXx0quo9GFtcbXiT
 k6c656TvE09ppQccLmWvGJuI5525wVwervmRxeggZBgzP3ZrtBn0MGmSC/v9mg4ogENEOzgY1ONd
 2Cl2uunt0I5NAt0HJBf0mCzBvOEH0hakaD7tZrNhbbj+ihsGPD4MXiAasCx3DA/vA6O41jkFFm5Y
 IVPLuw4xQhFXP/NaUQcXK81r1EgDgsBScGYksDECgTfgZaAkKM1asSaEWkgkUZYyIKG1TFIXMVQr
 V3aigXVJtCmFqZlFRIbTNXWsK0DmDPX2oBCEA6/KsvU0+p52Do9rnyJ7yQmJgCgopGg7XNk2rpbs
 aVe/3a14zi8eFmiMjIp3ZHDMzM2mKHj9C1vUFygjRDGTZqbMxa3N00xtTbRNJMYhTBufj/b8W/Yw
 QVcG/HGEMp46SQzMDn3adhxkZCchAE90DqHSwLIsaUkKQsMfUfZsXQBRFBISEh7Tasz3zsjl/Gfn
 KO0JBrr6tj35MF60voW6RACkkAhpncg+P4d+sLz4Br8Xlf0T24egewHxHqhy0N8CQkUZmUU06FBW
 oe+uC+wr5m830En7HKIHDa4F4XX7Nns4mHYuCmkRNlVw2Hqq/A69727InpjnBgrO4eQw+EJJKYrT
 MN3IE6UAi42nj4kAxs51Nw6nBb2JNpN4jAr2LprnhhWtJ8d64P/LDb6t36Nuy19999999+lJ6Nfv
 yNqoWvZlT3Q9OkOrR6xnWEtVyy58fzYtgsC5vPhXPg7vaEIO7x3Edn9OmHVlyyO7t0VOu2KuOQ+R
 B8dtxJccSq2MeSrlTWqQbiQ/VEgntBQFFtIlMbGLLusRyr0XelcJIWsUX/J725YMZyVVCLcWleBs
 fUe3fBy+4xQ7y+5D4gKPYQv1SoxMS6iCFCgLxwPd2QM3IBkCuEQDEA66aieYsBKAggBIAUx/L7wz
 /PA/nivbG4m4VBI+qGzpwsAyCAK7SSHDSsoJ5wfxzSoKcSjSBE0FJQUvQ7IGAhyRSkE/cQJxoEwQ
 IiaSFdaMV1KFArjabWNVKYqyW2La6lTy4yQidDIDkKuQibJGhH5swe5PEmoRd/HitB1AuGUP1TzD
 y/g6eeqKqjBqEQDoHpVQVgEEP1cEPowMCiJoF+CQxT+Xpll+7gUAAmZFeWdVc8NMfay7thmggeOl
 5cFYyKyceMe6cmV5mBAo4VqaC8BEAzAeclqYNtfgUQhsE/bwLvP/N43wU/GpB+zMOM6+xqFVx8aq
 GCMhOVVlX2nhleCNkXO07208a7qUozVjgttWm9CBa5E7pb6lJxYmP4ve4vrGwfcwcHz32D92bNde
 VL4Udp6KXfO8mgwTgxDb8LGQvih28ev4/X6vtvnPD+/9X6sP1w/l/q+L9kZNBi/q4dfDuYyxz0rv
 3vD7ft1Moa7YEt21PN/2PPh/WvtuOq4oQvGV7OHDWXeKmMcSYu86zGNPZqNtX/w7Xxkq3COjLbzj
 zjKp/C2SG2LxNPDilivUi5TrGlsOHwrAxM9iq71FyYnE4fOYp0Px17puqqq/+d9LP2fD3c6+P4fx
 +hs/h+Dw80/Ue/PC6UmaVxg1WaVWPf8u0+rD5M3Y54ef/5jh6sctmbp4xFEUVMHeyawQiMYgoogg
 gnwauIL8s4f80XOr2jzq9suK33zTMRnX+nWbjaJOIijOa4n92uCxcVzNvp58+/4d127N9FlLE6S1
 0pF9PxQ1111111xy+7Zrs0+rbdPhpCfUz78KRbud2Y/BW+EbsYy+NuQzFFzbDBq12PJZjC+Yg3i3
 G2LxqZxnlxrnWqiMcOlrjantcSexYviMSe+UiR4/NoAvYL6kyRaz/NaZDHsNgRUZbR+eZJRtifjt
 8rRu8G7/njHKbbM2sfgM26/W23/a4l3EEBxOLL2H4mRWtarZLdtFs9uA/Ma1caEeJ0aTSN16I0Ze
 I4D6JvDHekvUuFNLpUw2D0TDMJl2QUPzrH3Re3Y3So52wtyZcPsSdw7C3DpBoc7PpqX9Rz9YeAxK
 wk1z7WGBiWA69ixsDsuqPEObvG13laDVTnREscbZYE5zfsmKpWOTMo4e5hJYx1ZnaIZjCUQwz3a7
 YHSpyZBnKb6B6Hf6Wot0NvpBDkx9upYQ3nMlML+3icGwZcC/EvS0Ih7TtHJmpzPI9w9R7ShhcOIv
 HEVAqKoVKlTQ3Msc89zx8kamuhMZ1jWHgRfSWjLTMhpECDIN0eFLYl68zNKUeba83KR+eaQd6X1p
 N6PyoSTsvNn7s0QRxLaHQjt1xpzSD9exf0gc0ren6t4qCWD8o5wWRQeWu/ThkDpE/3yIm7olKaWr
 yVYfRI9TgH2YNw8zG1GrKgvl8FD7R9nE/FycfUP9AjyjtDTMJhAyWzVHkJIRYEJYHvU0Ol4HRVki
 tlbkRPi3s0Cqm37v0nK6I0wlJwjEZD6ic/OydA0ShBSZXA56RJdEC+5AqLnwvMViqvZZgnCB4i0h
 jk0UQhaDa6Dx4cPl8y3rqzgabJ/pIUtvDf7joFH95bPg54g2BfJRytUWLfkj6bMM1l+5bfyNyaI4
 R5RoGgDVlFv4N0/J6nUzy/tnY40EphQSYMyrm4q7pkljQczg4+sQV0NCk/YhZ7vdJusu5NFSN7ec
 9RKTNcHV0megykHwDX4ecEO41y87iDomH1btqI3fAB+zBkD+6KwSR2iWDwjoNhhAUgAvgChQgkDR
 PDeY6B4abK4Q5rMckYcDVSKWRiovEQwQCDcX7Ywhgyd1Q0pN9MblT+2qUMpmKgmfK9akO4LIEKm1
 Ep107DUM9/p6fUdhdEdWb7hAxTKMlgpLjv2wU664C+V4uHYeQ82K6aGhp+J8c3Y8cS0s6v2fH6/9
 GEE+PTXUs3BbZISFkKh9FDbqmMGRA+bYqQJcpgqcSIhAlIhb7a4ipOlE+kIDiw5z5l3P3xPXVJbO
 shY8nMOY+6VKz5zkSh1jJj9VZGwLpULyFKSok+mFK4RRNM0OZYGUCaZgUaey0PhHq1CFLs53pbWz
 AoazKwVDStBtFlSpUjGA020xpjGMwXoyXmOuYyWN5n3a4UbkGSPhM3UkKU1JPXkqbi5+l1VSTERM
 zX3L3Ap5yA0Kp6yVTyi1lefKH6H/IMHU+31SfJsu5OYHmgbeHtJx9WbDHl6h+vw18BYQH3DrsMOz
 YS7NR4PCMMRe/F0uwH3G0SIKes0RE00FMJKIFPoOAoBlsJYxREHP8kFqQ3ypMFB71s0Sc6GWEmqo
 9liJWs+5lHX+Q/o+s0ddaRCOmhliPxdUkEFubhUGMOw86f2LkOiNRUGgbgvq/PMHy2cSAfXFfDR7
 1MA9xGISFJgCC5xVYTAG0DocsiXY6KqZFLiRZBUKRFQFEwlEiHJRUiGNS6iORihCbMOrrk+UF0y0
 7C2NgmwTGxpjc2j5VgVKqkkwGTiAztrdm9EQsigbyKnITzCIcxoQozXqvqeo9HHNd4O85OGIX5gQ
 geqjGnq3jkriYHWb7oexU/QfoDAQVVyPJYEKHCxYyEZkQoupULSqprMgmdhETG2J7/1g+YKXDJcD
 rF3ySSllZDYIsBEwkhQGCrcG7jQjoZj4+9/Jw9/wi4YLUDUxuL2HhxSQyN4GcFufvhuEpjHRGYkT
 WQpTqJz0pzsSnkSIh/p7kT83moeKfFmprsd/GzeOG4B1QwT/EHC8KUwgZFIGky8mRLqLvO87Bd43
 vePtiosW+9s7oGzI60dAu/GunZMyH+slI+OTqWeSXRZ4OHBgwRkJMHzQfO2M+ZBkwUCwmIUEn4Hd
 P8F7A+KrvdTU1OtcSGSh4gcdGaGRdFPBuyzIy/1f5taf3v8qf3uT9X9JH2ya+cjnF/XJ9n8t7cEZ
 3MnbtVMIssGS7T5G0DZR1dYWsheH23R2XryWrWBNRUdg6cda31vLIUTJPSi3pxWsxW+pk4zKIfDX
 67XnN8cuZDu5JhbPXHnilUXioxzERCcREfGt7cNmc+U3cPTl8xN3fSoz20a4xERD8sEmdp8L4XVp
 WDu8sJ53xKTo7vyPI8ToeB5jPgZvftLzUxji7voatG/HZkzfH4enGmmtWeMRXtfdW+ta/MtTLN89
 +7wEdJEP62f8JX5nBtME4ImQFKh0KoSH08PVsP70T9I6vqfY/2UOTEP47bX7q1L1un7Dbv739Du0
 PKixF5MvC9o3VnLyaW2Y8/PKmRVoWn+asa4sIfs+LJBAq02vozvffnFpO1nZtYTt6Luu/GqHSdw9
 Ua6VsS3exDUMmhfuMYdGOsBkBgwG0Nj19VgyiNoGPzGI+ft5yf7bRu4qJ/ztJih5Xc8YnX5aXrqD
 STSiotQkC4VAnIzSmlSO8mNteeEtG/VVIpHMKK0cbBwo/344aJfDlmc6nEpQGm1lwNNebthay4V4
 mRg/86MTUkf05giJN7nGEdp2vIr3ageRvUZf0TMu7khmWRpFDcolrTUsbU3nJlW0NgNmFAoghWxQ
 0qPjOUSUHr9svf6rrYw/Sco1rNFmvdx5DyHcZjvn3WiJ2Ccesb9Eb5T1z8cGpOnp4nXw3o9mXNkh
 WWSFZZAQ4udsPwbx4heCO00JuNZi76hoIZkVv1hvvuXZ7zh27z0tChf5/GHfWePTZDNj0/C/I0Jb
 SNGfjKtpv090Evl6DqRBWgl56V99i4F5nmSBk17JQE7PTjDF5ghSlzjywaQ9JlGlGdCvVJbcS5V0
 XCiGpOuelvHw9zfT7f7ge3rw+zgfFVubEpzsjW43cnPp1rc/V1w5eu4z695qh3GN7HVuwp79R164
 8+f4vAY9TsFC/SXLhx61Odzz3mzf5QVVE3T2ynMZL8DBhsNWE2YbnINh3wlOPuN3VuU4mrSk/h6z
 va3JoYS3Z62s2w2C3Sj0w5XR2XV9PuSrLHk+LQbjMNw2dsSh3T6tMuKn1ac59rb0GgGIeIuDC4SZ
 kyoBS8P27ex8tbm4nQfNUbFoVtDYnZQt+ZlNnk18ny1RbLfegLkOw+Y1dmt+AdagLMisUXYiRUlz
 9caReBbwgTAY52pmynpgitxbzLcxDbbbLFnAQmEaNw/mkOBmWtTLkjqTCCMXEcgPqIFPn69tAPuh
 yRPhCLVU9CSny8s1F6ZzJ65fK9fXNYtHjiQtVDgZGAgbBgsFScDit8Ab4rhDOEshRCNulyS2wvFl
 SLzi9dQyZtenlVM4Od90tiTax5y8kTdDJc3xBTzgh9HBmCGhsbHVo0yKioHUW3Orzuamc5kIUZuS
 AbOYhxpEDuLukdz5dBdPKtp4FoXQTBUJguvWAxGL5vctYElIZYh6KoNa01qEq9UfPdISJJWRr70s
 JJpsGJh1KIQJzefXOAe7jEzGZwwy9QM7sN+8meF8cTmFbAndPyTOJEc6buEUhFBGyZi1kDHXeCoy
 QBQ1dAejljbaeBxHtAibwpGKCEB4RHmcqA1ucg1zA0PvnWXkSp1HUdD5T75TFDIYbFrDK9ciBRSb
 cADXZiOQORchycnJyZ+8g5fDEMM2yVrWtSlKUpSlN+23ZWEQOJgKOhzKkjeLohoxEA2Ahoz85UrJ
 l51ZIa034tfohH2/DPdEdU++AmUG4POsXU4Q/EilzlvPutLkyl1ecxugxpxqoDNDlyly5zomKMBK
 CQ4vNhKIzHmXR+TuzyQ5vp9J+dWB5JiIGCUAGB6qq9tB229eoGmSC0IVISfdbw/ClYQhAkKMpBmS
 pZWqErZWWj77lBnkgOGdWetekr1ZIwG+zDu8em85b91kr69Gvx7eEnePP6oDwaNFwbpituSFKamo
 uz43r0NaTa6cpFQ0mbStrPV20jQD8l9M8scuCPw0oGQTMFHJHjwZH3SZwTx6xkhh+T3Gbp04/HvG
 0N2ilUCgkwhRdjCqpJSOEuCg45vWGitZZvW7QyWhhpMrMc0YZFB1K8lXlprzWNNhKueXL3vKW3N4
 92OMCyxtZbghGSFJImxjNNzMw1Opy4GaElwruhRflSrYyRBQO/PMzDGNjBk+cQOvPypeL2KjI866
 bzuIpiHUMJhYSLmHSlYKImzIrfqlmCsJdVHUjkxivaVDVzF81+kE26ad4e20zQjyxD1qF5Px0b5V
 M7OOVZrWeIeGNCFENId228l4SjDtjwyyuhuqJzK+6Da8I1wzaunXK1M1CULsK5c7lKvTK5pJXmxs
 YIUooVKSIr7V4q/ZzxbIQFNhF8r7e/u+iGkcVRto2KotvoZq5sVRbff6aPzm7MKNQz/oy4eT8fWL
 EYK7Yw0m8AgMBAIJVBECfYv8YD12gYDfV9aeYdg507VMEEu9qwU5xR52SvZN8XcECDUEfSv3IgjB
 A/3SUApQoGh7QLEZzvjbmNETEYfjvb2OPsN6ge8q6IeiSCp9JICIeRrBehI7gaAMjwNGMjSg0jLb
 HYToZhCYqg2yeFwqDLRAJQpEUH2rhhUqPHJFFWKJOFFWJhIImEC6SNcc6FQ3AvJmAg4RveAHvq/M
 /vdQq3wTUCCGshWATaD7s47tCtQNDILDZvFhiAydMzweGF1tW+XlsmEOMD1Vj1PrA4JX0rAte+rL
 oYDuzMIYYA2hviDRiwdhphZ+ieOllcmOK2T3793DjuXM39MV2sdBY8eznlllkZ1SlKUqnll8BU4X
 iS3ab7KKtjjGEIQtj069qRchMN28eYbdfSQmURcy+0Me007Gcc0fXT6ALITakqCaFH8MxYw3KEFO
 XH+t9X5fvC5H+//H+GCOURzPNiW3/x/5VS6Kt+ZqqVpSYj2Xl6y6b0XrjYJbVi6XTeRazFsaFUAF
 M/m3JMx8ov9GFT+xmYP0hYcNP2koEf2hEqv45c6eIK8A45eGUrrtW8gwykLcedVCDDB0M5a8IIJa
 htl+TRhk+4FB6NbO2aOBk8Qd+N9AjwY2Hqw3aJe7FLVMKaWmdyOC3MbxKDIChoGm5wwJOYbIumKH
 FUSKhM6HOA9UHqqH8/YCuRWCvAUJLKstKr+mihIS8UArRG0ynTCqkITGzAdggGwMqUmSyGNSzaTR
 NIyJTVM0jamFS2kjZWlWSIEjSMJCSQFDQmycFDYM6WR4CRQwgBiBANCRARDEEQLGb1nCq7FHWGOG
 DiGfpNjtwuuMoQZYoGbJIhA1PfWSGBhYFc0OUEw/jBx7Y8WPqg3MVTPVlIeIPhIG6QlSEhf5MQHm
 z28iC6aj29vdnEzOPaMhh7AK5OlZDf/iaHhEeW6hOGmm6NUx90NgWe2MWFueAxSHR8o3YjM4sybD
 R0sx0wgyebM2Ep8+BXPSqnwWBqy/b6njO7le2F1a4uYjXltPi+Dnq9PD6nWdINk2UGYe+U3I0Iuw
 ueNxWwcQTBn2hyuA3m1PmQYaT6Oup/jjF3hhTQ0FKREISWKEqRVNPHVBfH0F2PYK0uMxtcVk1gNy
 yA13ZAAwDduMsmsy34ezwPEY+Vlbgu9tQSQi8X7Pf1tHG1vf2nTw2MsCj37DCGiORCH37oRJgDEl
 3c5l0z+Qa+lbdFz7lArDInjN57CZ4huvsUYiZCPMUSACQmyBUEHR+QrNTF/Yb0PpZIw9Gj6309OJ
 S0bjQxmz8DCVEAh55StiVHAo7Fcge6YrjSBzJDO/imxUXHFgyC3DYA2xxcUzA7GJ92+Tu4Pl/KAA
 AAAe44AAAAAAAAAAAAAAAAAAAAc4AAAAAAAAAAAAAASAAHOAAAAAAAEgAAAAAAAAAAAH1LgAASAH
 jgABzgAAAHOAAAAAAAAAAAAAAAAAAAAAAAc4c4AAD5V8O+J73ufIvNpU/OoQxhX9C948yZVj+Xkk
 hLdog1WB0cmI9bomSUbLAAhxOpy2GNby+6N9yqXODvjBZ41Cw1Nrpy0rWMdYT4df49i0UE+Xl147
 jlRE9cEe543Yr26soaWGg0UBBD+3Vl024LcaiDFOF9l4p+TIGeLi2f3ZWDpufi1tytEQRNtkZaXL
 dTLkg5nL5ijCpgsbyfbQWGjMTnXXTmQO8DU0eVsnU/jB+zTRXi8nznoMX2QmwbPKIibAhuT6JqPj
 64h7IIycKXdHmTEmJ+ITGQZzusaVwwso0xKZMz7FeJAgMZMr6HbbAgnlriEKOgE7JIXbPHPQW6Cz
 QINbZaE09+9DBbhxG3ejy3+SNrOLe3ylqROw6XaM2jphgviscLbqLgzjzyqdfC4jURDg81P3uHdb
 Ig1d9qJ0AMMJhQ1q4Tkper8EjGpyoGoBAUgJ2LiBgF8y5kizpsXuTFYvc+p5OmAjZkMhsOIOGtjY
 uTM+uhCAPTr63OosAR4R7eUa4G/R7Ue/XF3U4vB33DhIQLv6bvEkKHhFFTmRN8MQhLPU+A+HbIM4
 b48t9dkMerjh7VRnMmLzsnv+znkOm6B0uimSg+K1CobN4Fy8NteRrtqenZ+fh6dcXtJ781c7CXCQ
 kyvb3dK35jwHs2+MB2W4e/mfE0Wr1jkI1qrysIADZ9JlZLSqgX4KuEpVwwxu6khB4hwAEVEEa+iN
 ioB016JxfGPSXZzDfx57X3+HZ2nmF4ccEvzGsYk61cxddZmYcTIoqIiMQa1rHzeieyL2mDArSqBa
 AFKwEgz8Pst1FVHA5Q5YEIHC8whoRV1AiEM0WYc3tim2zS860SghbxvePNgaGFqKcebzxaQlmgho
 ZtSMjJLsqdyPMhO9eg2N1z3LvedO3gboyGTFkGTA/zWX1h/J7fyACI/mcBEfrdAl9TCLpvyWdME/
 TCdIUSg29fzmgEDV2I684CFPXR4aQHcCT/KT/ZoEsx8oUzvAbm5At/7cbnL61totQko0/7n8Y2Gv
 8Dt/xyQHtElFUWgrLarLMVD8qQqfhAEUQYBcRQmP3oDBhgGHBf5jnaO4I3/Vr/HGzeKVjU2aM2Wr
 YE8ZAJ/FjojX+bO4/Lvjnk/vzBoLEJWxCWhnjDLvLUS/7866rqrvXvxCHPp5fz8c+nv6obG8SEMk
 3lYIUgwkhkoJhzI/oPpNDYbipUuSLiqgRJEyJOo5gwYNiiijYkk0QYLKNC2GItSFySFwFTALyipD
 FuOZvw2v6du07Mv+HvCf2gvzYCA9LAkHu/H7IGS854G7YMzfeVgCQQiJpd/Z66B6n/B/o14dyEFx
 +t2eGA77VJf6wv3O/33T3v0/sm5I79hDhndCXzunZuoyywpO6Q5RqpCuYnAHCNhoVpQFA1PACAQ+
 /fGi7fFmef48bcGhlPcqBSduDRzxXsQKYH9MI/zlBYQ40MeEAe3p18sO+/lRRNmPCmULrQobtzNr
 D6M51vrGUuGI/Jvx06bm9tieDM8eBVUViqrWKltbZxnflnUKZyPZxtq3mLD0eX8K5zRJzAs9yhzD
 KeTzPsOxBjPH668w4ons4ehfUCPGRL3vycxG8TrefCu/0nPbfbzjXnDYWyvKrkx7+GA3nRVQ6RRv
 dvKTtxo4wxHek5B07yWPoysExK8zp5SGWfkkJddut3uwR18o7DANjaMUpcXix3/Pd2rHG3bdFgmz
 3Q0iCdbdUB8hIiJFCBD5lWBY0EGxC/ujTYZRiNYvnXs1XzZSXzZVX7FuuSpnB/tQD/O/0A7eDgPp
 k/mENlr8jToVvLk1hBK3qWjegukkVLMSwB2GFApP3UnXRwnNukcWSml0NCSTaSRlZFCgqrpGD1w1
 dC2/0arAHXE9uNiBpIkrMrIjeHSXXMBhFTdMcbiFTgOqGzoaU/WaM4DMlrBCHxHBwf+SDZA00lBE
 l/T31XgRsau7YSIVg4iYlYOZVVVdA4/mOY2obImoVMOIyrwpACHDDKYwTY85slYE7b1yvXbzN1Sl
 2cKNsGhkaIKDcHJePGKVcuf2QePmYgL1qQOR66KNdi6jrHHTjxGmRhgIGVdCyG42TtzFE6HFjoCC
 pIWqtsGHEPCGgMFxSBNSTFJqlaCVGkjNvJXjbwXpu9LyVlMtDQ0IGnMuyFjjOIo0lCAxS+EDwsLr
 zHF9SsG2NsPTK8nkudqK9ivGrwSzKasDMxKxzjGB144dDM8QcjIYSDYbb8ZoXGW8ygYoVSoExA1c
 INJhbxtollk0UvhXQ7qyoxVGyimjcQh0G7nVvWt67ebrzEuprKEoYpNqe37JDBkGKwxBoB/KMkoQ
 nVJ5jiycs4x3uMXmMI5GFfW7wQtqmA5Aj4gyLkhqDs+HZAO6cIcMzMiiSAyKHqCpHYOhwZ3iK4JC
 cjT93tQPcWIJ+o/tYmKkCVdCcn8RrQbMLjAyXqEgbnRA4EZmFzZ3RVzYk113a5jO7udndRU6cua6
 dRly4O650pu0GSDROZmZgUBPzB/IuztNfrwNn7/ZI+lgEHd2/ncgJAXFBfBABXyj/SDXyvYL9HM/
 nPwHnUEXRDh4kIkDA8S/hNMQneQOSFH+mBxPEgidaE7FDeD8cYaCAQKS/AhCggHr/vORqaeXdJQu
 A6wp7FllFpzgFncUqoGo5NAa69KqrLuSnQn+HShCzaGiHfgAz5/02InGxUSVQizQBYQMv8HHwbtu
 mhrLBKhXMpCcNC0JBoDhgRz0mJn/CUBtLbG21ydDY9hkmF35rEOJ/57jarhxMhRAP3BQcnRW4f+x
 0by2hLjr2hSAwAjL9H0e7h8OnLlw7cO3DuSjQdoA4gaHPlYq50TAhtpVVQhVSoaSE4HCBXbbGNBn
 fCsQPmiM/GJmpkbzUTIkvifRx1PMb45qSZu6aobGxsbHlLbz/7e3knPeTq8pGKmxlvDzEbC0jwgg
 PwGS2RE0ao76ScYYGRcds9VYmTEuBUcRAXzJm8rzDRBEGxASgpg2ebAR7ulCejttjqRB4agS9mB7
 zxOr93BEuXRLiXUxDp06LSNoMc9oboijwsOFhhiAwBvhu0ByzLN35KI8cFR36YHC9cczMqjy3Xph
 kPPBEcDBdGLLBzAm/Bi9GKR9yCNnnxDgLCn3y6Q2oRyPaEpZ7M85nQS5ctVCpdBLltEkK8mOTGY7
 QHgNobgC5CO7ryzHoGN7jKpO3JZ6c/AJAkJC19Lqqrz5yVR1JcuqJNkQOB7bj2HQzou3iZYOznUD
 70Gny0Sch0+01puzBrevjhuZrQ6ID6tyWNmhHHhCgbzLuJCGxnvMxQ84JGA1EJ6eO14FdP9kcT24
 IifRlFnnMDAutm46dLAdkINqxh3MQ6dOiiwEe+Yfkl2PSAIhxRWxCBsA9m9a8I3G9+nvrwD3EB7K
 vE9kVVRTVVVVV493fp6ZZpe/mOdg9Zge/zMOwoujHnIIxYVKgZ4tJemfEc/qr356b99nxmZl4zjO
 u/A3yMY9vITYB0DzZ0GHUa5YqPVhw7N5QYYkY+jp++T4hVUfGeHOZkeJCyMDrNuu24NnaPCJKDng
 DRnF4o6goMFmGWRqDwY0yusDlF7sBHxGFjYNAbwEaZGIKMgIO853jdKq2wyDjFAChJuGd2eeoQvi
 cMbhC3yRoYdEb+neMWJfCfMc+DpSHdlQvh2kaTgdKR7oSpOIczPOiVDqMYM9TRANAUMAOPd6ckzN
 Lbvnz2rgmJmLuWdsiR2beT6WNj2Qp8Tk5MvYeqmeJ5+ETnBhUnjMzmLkA2BAWNe9tiUDSRs1F3Oz
 w7zMHGLC+tmG3p5vAgc3DvNNnPZWDkpp2F75DY/nNySBmNsiuA5JrgpIl7wjhpMkgSRA4S3mQJXM
 CXHDcJLZEWGreL8As71XUra975L2waJhNBnHw1T0zAbRQT71G09moea3k1WrpHEQHDJluGzubwup
 2LJzG+0d+cc11x167VWOmsma0qeo4mt9q7Y5zDrUwt+/L1WT6n4XY2C0qQcuzhCciEHwTbK5EtNY
 NfKUsKnDcam1+viRdV6V7t8L2wAAAAPI/rOuhZEHwYQsgWG4hZGpMV2J7OpIKBlYaB8Eeg2JsbM6
 yRFL5HcsQaYxlAbzdgKFoqoixbCIsHA2awlFop19tK/ODIDmTlt0qb+NYxysoOFGpqc45llcOXNs
 X25EhuAtVHMge8gK7Qx45lvtju4eywopnFthv0LN6UdaWwV6EUEaRUi9ODoGhDzPxYC8wRAIUSc2
 kUe1LO80GahShIIJBBIIJBVWe8IHaxemntqxJz0QM6w4mH9rC7CQrka0DmvKeba/acHq/B+6CW8N
 5FGW6lZIKC3jrZmYZ1H3gR6iOxD/AoImBxuCd1ZBFCKBeoT3JlyNEfqP2a6VUn53+vGKzK9j7nwC
 ED6BKC+YnhBF+iAR8zPP1E/CqyDQ0Hja1uz7x6rvAfmhcjHIsaHvPE6Hr0Q+M3guRQR+SvSlSkid
 x87oW0gyBxDITY5BHBhkO/XgvrA4MRBm1IVYk6c6QMvnk71vACzF6L0JCyiFwno2tYgP7OtiRBsD
 86lSqGwHww9QvsGISUgIgIegj3I9PVYA4wSiwIQXgYUFQgPJ0MHYBAvJKDByiiB5SIQSvxGJgN6u
 gBY6dsbImxAtMdKYb6VGxpTqaVQdwU8g2NjU0AZXHx6bHJF9ggQZsCeQaj6uPKqk9l+zGKqpOgkA
 HAmfO0gB5vU6IgBHtA9RJoRJCSkEChezSEEY4eTbevTbqb2Xd1tuwEBJd3dgAY5p6NajWHlXNorO
 qqnCZEVgAbteAjtkOwK42FPfpJIS+Q6uw3984QUDv3j10wYXI8zl/jYn+oTBcMSQt+oajR9Yq+xm
 6zcd818viRHaOnZBw46ZNiOIJ5DR+CgiZCvuHmnQ944gazRaLPuoQkCNLL7a9zb4cDDH2xsJml22
 kDsqJmE4ewPMQNrgQCC8CL9mx3DzCvDBksIoUvv+fy5IW1StP20VZTTKim7dRvvK5AYb5WQDFmNv
 SDvkPZ5oDmJAYOSTXwPMPOFgXefGfpHIBU7U7P0qWQioDjgdAZc0zj5kSKMkTG6hXisMeBMDBhMe
 49xExgg7wtUVXiSHiGgvKwcz9nQ7S6hUerPLMGKgHZESPQnSKFoAPVmAwSj/ggSgt4Bk0MLqMI0B
 ZkZFxEEv+aDCJGKMyyt0Kb/lgMfqge3wCiaOm7QOS8gPavda9k9TzVfJ1X0nyPWAAAAVWcHflNhz
 EGzoH1ofPVVVVV8fyffCIDYBfpptv9BfcAjLkzHLRokbG83+z75mKr71Fj+8EWc/ioHxYngWKYAY
 B5ciB4xh5GBFEmFgQEV7oezLoQg2PTobCE+EUfBiKmGQ9X8GeuAzM1nu17+M5AkpGhpSkQopAOeM
 Xgzh0HCSiZjhLAUBBJEiUpQUpMu4OZOkULrMBpKViGmkEtNzG2uloCQhG4QRPb3ehPvFiL+cR7/N
 jXTodA6p7PmKuMMo0OglghiVC+1m5Bo8GfU214M6F8ClMGNvAOH9Op7TPFpWZgen7vz8AkHf1nDG
 wbe/j+doXJx5HT/DFhoRcyHAH8DBpvPmHa9AJUKAqIFRQcgVyASgn5jE+j+GwBOJVfD6wPtQfmgd
 h4+7PsqvnrLyMH163assjeBhqyMsss+HtDIiyLMI/afV7E0FIdYLsphTh1+LA5sCk13Lvkk98Rdb
 cBu97maDAes0QtnDL0He5R2AN97EGkDBSzMQChEhEEpjQiuEqwKKCCtDO9vj1m+q1OemShA6Q8pu
 kqkqSHYfMHMBqCG/XY9H2bZAXWy5QLSYag5ksb5S8sYlyLcT2L6ORWNRiC9AlAoIIUkkMIU/BmYd
 rHkheigSkgFAMNDIpD05/4Tt3OFOYG6dtBSUmic8LAqlcjTtjFySlMcwzNYZ484VGq/fm81LdMhj
 awMIbiCB5EkI34AYmmQDJ3dvuu8C5DufIu5JJISARfT7/ZRaTAdg47H48OBmJqMKOsgJIw7QhVEa
 nQ3EW9170xqIDLrCircegxOIUaUUZEiHflctdVF7dDngzIx+HmPRkOgE4MYOiAvPJdAw2WGSSeBm
 QsjNyUOA0945uobNhRENUBSpQUDRqwOHBkYXmAV1AlI0AMzBdjkP5/XtUPGfzE0CmgOyDdlVE/Wg
 RR5qeQwJwhADTUPygVacjQiiJdmEPZAs8fQoqcDVgHsTfsk3bCnfF10DjAJAJmsdLGC9cyZ8LYSC
 0D3zcDmYmOsgGhEUfX5vSPkI7xOJQ9tTj9+PT77usZX4piJfFd05iYA2b3Rj4A8dxk8Sl5u8Kbbn
 EPQmxe+W24IIlWJd6Ibz2FiIeBBBE7xhFkRZAtNU2MGib7K66xYU20kWRJCnSs0arQOJEXoColg/
 bv/Tvu6qLEhh8hh8tLqhoK+F7/J9ffEusGZJBOnPU7F7IngRDL67fnALIQYjwIIq/NgKOkU3gDpQ
 kUdCh+noGlWinzz8/iqiBTvSUqRjeIN/27WqZhRrPUwXLBGhpzlBJwbyEmEC5y1m7AF4CEmGhmUo
 AhNMFqJStqvygiecYKOObY8Vvpcc7XdiasQYXpnXWaMZuI0Uc4xtRJcSzNZJ2jrgEZzC9My297XN
 JxvJGYxLqYN43iVJZmek8NujmaOm+c4xDTzMwREYpU6gI+r8Ju7XfiqCIguIN9+gmsa781OLgtrt
 czRkILEN3SYYjRBnQpNIa1XjBKiXGrlDInxXl1447b+GrK75kCfCKcqpnuEauSn0G2W5breLJY7m
 ye4gzvpRm+9GNq8YxnKwit9FPbJCkyjdzvFvYqPAjfWS4TVFjC50AIwIGtgIBCaKBhZsjtfTOTKD
 csLZqdpiYUzG3OhgG3jgokwthhJk2CW9GDlnBwIw1PMmAmpgJQPMhTbAbJbeBlVKSDVDLlYxRVai
 ZbjebPYMjeon9faUgD25MiQNaGwQg894fu2M4JEdu81liHDqpu/kkiITGSfP/T/DQPXdetE6CIHf
 6PJScJhKIExkBKrv3dTaNEMteMGgyIQnbQvMhsNibJBzjqdGGwiJIUVWS1nPCkV8c1ELHyQwAm4D
 M/YoInqN7uwbwN/+xfJoUDeLFVQLiCKlwLVS4qLj838x+IP0gJ5SSbn7jq7g7pQSMgnjvRKeh3lN
 h91Zrb4pqSDCSQh2igcBogiEiD3EDhAGmAhI26gfSL7H7CBofkVMAvUs2XqHFRN/VInWYPMGu1kx
 WRjcvcG//qpdw5TIkCQ+j1IoEO8MomXecZSUMIMGYE4ELPQUNhAE+SuxsOstwt9yqHt9JebubylQ
 mJInDMgy39EqBQlMY8KbXlAeSzDwizMEGWGXgY2XfG44l543ypmy6NyQZoA0RuOWsAQe05Hsc8F9
 3qqqqvJ0RwdU+TfQpRQXuBTrjFMcdKvbhAHmbscrCsQxLOFweDA7rqDsYQHKj8Z19TQdBvD+cEQx
 yKIAYQvs/DpJDQWaAj3IYIsAYwDIj3x4IG1AQ7+K4AQwAR3guMNunRvcrUt4vZu6IwXt3cDILQmI
 iodTtKBj2rbWdypKKzOuouahkZY7hKImSpmYO5IQGQesYLV1VFEzJJM/+NzLaFky200wISE2gPyo
 DIDIDEVIDKCf9MfXTRB9ZH8uYfkjaMEjL3/bzcf3ZiB+iKT/ZPg0S8y8XaMj7uxgPWXdxnOmgDcI
 ahe0+MPXeDStUKt44HW6y9oDjWDl1nLjjFDWsKDISikEyENQd5E6wPc5wGkoQKA8w+n2RSmZC3gd
 Xm4cvN54nVSv5LKPk7NYYuOysGZp2jC3zY/thXurstWDveQhGlJkrX1tS07XWGdnbAsZY082NzM0
 IvKVgmZnhf6tmTu7kIQi7zCxYy8V7iAyJ+Si9nq1BUjblSww0KgaR62W5BKpgGw94PyKsMHUH5BO
 4wFIKUI0CH5uXoi1FbB/Yl9T0HAgldZgn0fn72Z+UVgYKCmG/8x+0mGjSs+Y863bGh4ElgFFSIhR
 ZswKfcNB1NBDxdg8GSuJZv1xkhVEvAIQgSkVUvFPVE3ImluxJv0IA71DFCYN2m7WpdXMgfREZ8/G
 sS7oqyR+hAn3x8pAEcsTgJ3/Lq+Ljx5QNQHhHOROQa8t3d3+rXttXCu5XWLI1iBiWJYITM1ORw9Q
 P9AwKQzlEgMUN6gXj27jeQzHSnnJQ2e2egcix99CDw1f568lEMJwC03IOxs29GZ4e6x1s3A4HA3F
 58m7ZA5DDDDZHynQ8R/UIe0egoHnCUKPQaGhWgEhZaapKCTgSL6L01h+PeZmep6pmZafydgSBrqQ
 rWEHdxEf9mKCvYxrroU0cKnd8mXXBIL9yQNoHhlqoNjgv6EweKgsClCI4Ij1BgYxV0HvqOucyfZZ
 y79mVP8NhQH154cmUySoAoGe5qMPhlCdJsdBHuprvCH6B7aW6fCBUj8tWyDp7TcY30BhlVRt9w0x
 CFqw0RrTh4bXUgWgo3XcyUylsGjOWnT79o1KjUqNjquyuwWhB3/HhASx9WD7Rs2eU1Dbyw9sTMDQ
 R+ESxuY9ZMsdOIPfEO2auqKoct+B1I/SnCgHT1zxJW1XXaAGex0TNFdVaYWBNdzn1bKBgIRQiViM
 A5f6UBE+hOUGzP+EzETlyTvHcmWhnOa9xiyQJJGZ0jLrfeBTe9HBlUcAaDIOllNQZOkYm0S0lazM
 zDmHZYLhgmiizDATAwTBk5M0AHAHw0AfoVWAlKUSFWhRApaZlGikRhkYiWEoX27Hm1ySZL0D7g78
 RoigqvIcNgwfqBTtC9NgnQjgOhEUFVbNDs0AsG+tXCGlCi8QOkvHxhB3fqNS89xCYZDDN6JZN4fz
 PKZL8sPoh7h7tGZ+Y1sWd31p7BQKGB+eBD6D5/rB9ukkMtAFHu28APRO8OG3duyMqmPouiqsB3EC
 QGyEAmGMSEYhK3E8TExLSKHLSMTAQNg0yGEFVMXisFFSOrSLYNiY0q7dLAwExiQNbyu9WGEphnSK
 AJLsqyzGsW9AswHTuV+w0vkQQj9IGv7CkJGIbZ+DCjJCYCDba05FUZnVV+Me3xh6LKL1DwIZq4UB
 LAgp8DD8zSEDTxQwgHBwYSwHAwFMAYUHbsnDl2+2SeCm9GuWwgJYocA4h5+RRbZyuU7DbHT0SHAq
 ZB56rIU+JGouw6vezAMwELcQehAhBhPdQnPm6vjDOM5dSzRc4JxpOi8eOwmYZAo+vQpcukVTZgB5
 xZAYIRyQfm1hmfZofnqQ3GPxBgQ0BvBXGGVIpOsPw1hrMROkmsxDUUpaspSlOlc4hxK7kmUOJXWg
 ymlKFglT54EKAXmRMkHcVElIpkiOMHEIese/RHQEBMBUQEQWz5Vnr0Det0NllZmBUeIyh0QOmcXx
 qE7g+L46kGSH2KJFDVQTJe/U2QRSAOjdioJLt+85n3I7/AYPVFPtgHM2HEnadpLq5clmXvU+VFcO
 cI+sMwiVg3DeegYI4GBjVQNWY7RgBxmIG4vCYHXwDpeMitSX0QzryoC34qqqqPqDpAhdvB9T8Abx
 0HMQtNtv+UUnMpNL7DjoHXr91Si7dt1MM64npNDoN+aGsMAwlJegdMHoEBM2u7DUclFA2hOKEUDs
 0N2DKCPXlFDMUqyFUOEYKIWHwGYg7DD5FsYdfCJldr8u1Rwdm85cOF25nZp2hG3y4/LCvKuytoO9
 5B40pMla+tqWnS1obhxYM5ODt018emW3NRd9zx28evaIiCZmoj9B2fMujaqyEaLltaL1bizYxJME
 SLQf64DkUsRXMd7xSMGne6G+9Ll0AB4xsCihpgvlgYazAF7grC4SCBEmscQRTiwgMwDBTcCxKIUo
 g7FASVIZQKUUDXvzNxkJqDAQKAIP1OC/sRpN5g5BkcZz6s2JbjGoFIYls1hTnzchwGbMDRmtFUF4
 7O8V9Mg5gmTqCtg6efIKPXlfGtzWC0sGI4U93D6qqTls6PJUADQEPKKUCJAeMDjKqwsqIJKUWgHl
 VDkLB5PNwWohfdfBpMyk3TKqQldCmxxH7XUSiJvHawA1cPO5JJJJH3Q7eB0A0Tkj7g8DuCVIMIEL
 GgEdfbCQI0HnxNPdjpB0XdDaHQW9Wb+RIHFsFUEmKBAoAMsEGN7iNGqVlRezh49X2igB/IFIRUQh
 GAd4+aOuQB0PV+cyMImdtMnsM8KShjZAiGI2ePMiLSxhY9YhkMCSTk+FfBhgBT5TFxVZljau6pVU
 m1Bkkpk2DPuIllQ+0kEoSlR2MQ0OxVpbNjBoptNKsVeyg5RBEBQNI6pWUp+qUOdqEPSX3NV87bDt
 CQTsD6HcAfG1PyBTaC+zEP2wxnyA/SXzQhvVfcFHroAiIsQJqBQe1VMPI7KJzIi4YGR7R7cb9FIi
 Qr/IQlVBUhibiwUYOuaeDsd43F7u5ogZaI0aRw4q0nkAPQfvBoTXPJ56lK3LgaYgiknA3uXh2YGm
 y4aIDsFJhnJRmwzkomAhMTTGQoDrmkchJMCmUUOPAYRFDo8AT/nGolMnIWBt7c+RImGLKrJzF7us
 s8oDxza0Fbx2awlmQh6izbx6bd78WyYsrBbBRJbNllKKC2aFIzSSirHwd8r5/wb3fmpXALr4Gd36
 zKr2EN5FQwd4Uo9Xt15ZpJRgwJs4ACIe3a+2Ky2/F6xDuYGgxwe5+s3ipiJb86kkpmcOTXMLHxG3
 +YfaNgchlDyIOBeNrV5ucoxwNTDDee+obyE7wFaPFtjbg/E48B3XmCQgwhoFkET48uXoQzj7CZzG
 lh1nUL0JZGNdfNU6vEjlYlBDc1gwoIJol8l+f/Omi7jBKDc6EOSMFNXYxwaDDH8x23aOx/3HTQdC
 StdkNYl20FpeRN+cgYT5fLecgWC/3SIS/eSPZ3xzGGGDEDYp/V/kdWBKZKQ5gwhhDEDHw3xxz5PH
 5rZLcNgoY8TM+VjY/KEdY3BupO1Zherj3zADqIQDKLxq5ni+vS853DOP6KuR3V5KNb+KieKEAs9Y
 MMDdFEBGBZUegQBqGIPWQu+TB+BUHJBpXk+SIIzPm7VF9f0dLPv/FvyBqCGBknG+dCTc273eX4X+
 ogXQ98W/TzP1SU1Lzm4ZVXu9SxiYxBftuRkKLZkbUBMwMQmolRy4HShJmm9a+iwMLQxjEjJwI3Fc
 tqEgHYHWZwopEjSERExEwEGeYIhM07RcA+YU8zgewh7MHa/Kw8Z/FVQenmR5tTGH4T8PvLg9Inp0
 AxShVRmUJIiZjovxOPtIdmHOVMxFFVM1Ux7vP3XUd9V7DgtB0tCaIoZvwOpbTOSzcNkigSFo2UuZ
 AXA9xhzz4SVocXzo85dIlJWj+0KClOUEMyAJsWAb9sY3cLioBqom7RUUJB8NAzQHQWq+2oiIiIiK
 Va0IQNAwBjQNHYMMBUEgYFpXDMVwwxV+xgl2VSVRQcBstMJImClCBvaVjC4GKIvQCAfQidd5CblO
 RFPGnnZuEOAE4bLCMIMETFlyZa9Pt6e341yPkCIiBgpN4MPB9WSAxZczcBYySm2xYY8BwBhhGAwQ
 O0TNGhjAh3FA55JKCr6hlBVF4kEX9+VKL5MrcE+tqOjmYZ3mgwgPdFKwwsnBghJ8pI+xOCUCh+Xx
 Q1D3koI9mJcnS8CLkclQWXArvChgAHAlFgrgqeO1ECgPpgNIhxpITrwOD1CAtJIGeUIpfYB6wGXQ
 SrsFd8OBkL8wohCYI8QdJ6KKLELs1oABOrKD/agAsOWNgLddfAIbbTBjaaDGr59fPveVZZcQPV56
 L2S81oPW71o4OxxYSE7lSJdluMY35XUqi8kFoAMB6Zqo9UM3NdGmCHgdvQEbSBvDmxjGECAdgCkG
 ggbYC3XLg0esmYhYGQ80VE7lVEP7FF69EMzgAwSgCQ4cSBDmOqngSEJNWHkpQndrxOqoxiu8spbD
 e5hJHcK/4PYzMDbsr8w4aaGApdl2oMYOMMsIbCA7w14+M+PCdjR4izIUwsLEULlquytGLLLGkjZZ
 WDkpQxTSKsC2GZVGoyzrlfHGlm0Q1im6JaIxoDqc8HPLB9HzkVG1Mh4kmblDuOW8R40OZx0jpxca
 CoJxoMghVFgN8Z6+deocfXFxrmghy446uNbdiKSoSQI5Omaqyqqu64N0pfEOOnSqo2sXPY5FQsyP
 N9uehOqmmjlAeGRekAVpQXOlEaCgKQDFCUQwhQw88QyFDUKNAmrWhYOBKBTi24meQOgdBIsp4nRU
 zWtBSNE3emSWdYZ2UIuWStaLrT7oAQwYl3W5NOVk+U4sgQlByg0QSHIHyLQRMt2EIoQQGX6ebbYb
 z2Gwfmd13ke1yINn0qk3bpJA3rQ9eAZCLkB01Fw9sA37Pb+a8T47g6RiQ4Heh9V9WqkweIhroN5k
 yYcP25PpnMHwMaOpEzm2x5njQd89YkFbqJWmkY5rzwV5r274y3x7eeKvLhQRSwJYWAxPH34+VFdF
 8/TZ4dMvstZUeRaj3/hsm5e74yHh1A+BGD7auXr1q8lHNIzqIBZdQAs7i3MgYGqA3kYfAs7kyLnx
 fW0XOCAeCJYSyNUm4m3hqWsshgc5dekGCiLhFAtKD20/adOXkldzKL7BYhwxyp1BXn17ptMkp9WU
 C4kSgRDEd/tX9k8zwDxeyJlajqV13ogNSGnM8NGWh3DmwxcjKIyQxNprDUfOW1dxXNiwyHHOb1hW
 sOZ1UW47TiaqYZOUiVcJQmlpMUDJhEItH1Q4FSD6lE882A5g0uEYUEkokDNTYZj5/te7HanKhQyQ
 U0pbI/US8otAMSwQkDP4/f8f7m7NAQAuTu0NM7j8HA/KfHyqDGJgbbZOJvyRfrMGxwOI1GqpoGGt
 iEMbaGhMJTks3W7lzcJ27cjxV0m8s9IMrjMqClW6Zsjl44NLYxy6PiwMyamOWTINhwQiEyA5N4De
 ihhsgCDdMJKWSEBTfGM3eTBBzCgtg4siYIiW6diCeABMrAIBfZqIij0iFyi0+z0W7vdcRNzOMYyG
 Wk9wD+Q7nyKSRR5C6x3dDBZ8NLGzQi5NK0odIAx7ffPpekMkzQRiSvTBjBXcC4/RfuveCvkHEANu
 4d45fqXsv5SZ/SzMr+46MZeoCfK37LaMfu1VGBx3ADwINGD3LcnHVMMI2nEaALIjqKRQEPEDzAIB
 AIBsvuhzYxlL0XBPRlx16SUGTkZOnRsnHL5EIbAfhCqCmBxt5jk9QesRy6qGsWhAQwGGEIFI+EE7
 s+43Xdo1VAbwTW6XvG2MOAhSGwGdjoQQSMgXlnq9CDjqiAntUJGKGCIVGqUgSJZkWAWCQACZBJga
 BpRYpADUMxmiDYKcMABOfpvPATRA3fT55CeamhlxPVMB6eI6tUUhnFrgkDECzK3DVsIiDscx6Jrj
 0R11A2AaFT2VIRsDGYJft+i9evH/F76vd1jspADpNGgdNhmt1Ym9mt1C8iPASPcX89WCqnn8eOqL
 T1AwCjOTqRYh6Eq+pgwMmQfu91n07WJrLITFn0TENY2UcxanOX4VdRy6abkpkYztVahyiSdRuybU
 bLVfsj9m+YkbYc8kS4iB1EJsiufKy2cAHy50oAKrLHF0Nc+E6ghLt7DyN1Eut29DOOfQ/vUhRzKy
 wxmaIzT7cHj16dakka9IPSVAxjyTJEkC9PH1/djwpXfGsY1gH76KFEr3nSIoj56lcLdWzDrN2Skq
 K+j2wGyWwDX7tChMkoJgFJXkAb7nWOdy0AeR2aabQBpH7h9p3hpfQHwi3+Dbbbbbp9PfI9u9o6m/
 kaK8Ass7itBzDjSDaBZSE60oYg2vY8ctkmYyIeBRA0DYBggDw7Qd93EsfzhdDmDdtLuAOqZeb+eb
 uJCQ8w3hzg4lx+Eyg85kQOh1IQ+pyMHWaBor3cTZOhCHaoSBCNBBZ2c8JgoIFJWooe4i05zeFD2h
 5cH3Zc/frsVDzIFgcmHgiXAkFkRSRBpR2ZoflqrROr03ZrLB9hrdrQZqqK4qlREIQxbTW6kLmZ7q
 rn4jZuatoWuVGdI0P91rR9cN9W966mvs2YP0xX8EhhBkA/hhv0azR8/XNSGEXGL+3RKdIubvoc5M
 ol20HqfvgXdwJV1CrqS7r9PbzE8z5EIi2gh++/l0oISmRgLxlD5JO3CnwOl5kCBZTM3jJqvTgxXI
 BGlVxVppZEAgKKhVkgSZSYQ6h7f8AdPrmIoYr64QhCEL6acq/H6tfoGf9/GKqgC0iDnr2gHwCEDj
 ScJlVxoAh/YCkQA/aErMT5yoQwKma+awPxh57lMlghMoERZgYTFv8LftF6GnBM5Q/2j4Z+7Gj6Uw
 DP6TwhY7x/CjaYD3YsxMBgkxZidui/VYuvcivyN2DQA8nB7MAjz9O7AjrxkhMyoNRTiQHNYZnYBR
 8Ac2FBLusoIlyKHM+m++bd1GtxjZY2VhZjZI5gesI1/LJ+GDX6cMjUYcBmE6wwoooJKma+ZEuPye
 GMb/uXabo/qhT7foyYjLlGzi7vLDGSQHpYgtXaVKgmEkEqSFFMqLZhgiyyW1eHcLakIOvr2lzdou
 ocV7egAu1pjX4mhj3woOfutLJ0PXZXHLkO68hiJuwvsscyBgWGBHMm+8aQGjlJCZVRmSsUCKX2hB
 BR4IuiRLwGghNzqAnbYkj8VBiiF/mUpL09almr1tK9eUxYtAuWDa/5AY3Zd2XRVMWBRQm1soqCQK
 rYZpisVpTsGZu1EqQhuNr6xybgG25tzmMwwEKaOC4W7Jh2NAeGApSBAijb4o4AazDBHBxoVggiKF
 wHMMWxxzMVNadaMGJRgmRwzBTtwaHds7vJuYN47WZKMyY06XallRsZyR27a5dl2td2E4du6nV1zp
 dsKp1EARlYIZhhKwFgs4uJhBhmEE4LO9CYWgsycxCyOIxISik1mDES5iupMCQNW88V5RAd1eMkeq
 uuMds51psm1jnndTMlkomambED162url6VLqaIxRskYi3UbZslYijlBWHSWoCccNAQuMmvFdLpil
 t3S0rsi3q1XXcDJsWcS0o5CyBjAXFlFOwJMjESayuR4P0KPIesV5HqBx1Ez1Vi+7Y296Ql36WwJL
 hRbAmGlBKXXoKSxoOqXa3PIDTvRsb0iqh9NgcjMA/w3u747rbMHujfcl8tkOPPEwMSADhQNsBXTh
 ALFL1yWWUvNrrqYEEyEDHCANnxzv01XWcdTno7YRGcUg22juJPLBGzQu8QC7dYEu0wuzHooKhLtt
 q7QUScA5AgmADgUDB1BsRzhHGunOVeYBQxxByctE1xa5ipZg2WUltsUgE0zqgPDjrwxtsvl9JGQl
 1LLlZOgnrcmQdbBO51o64DZg2NtomslaAXVNLazzvILkVRj8pgR7sMUgI1mGWWp1ajLIzM2A+kA5
 KAdMHuHr9LYFNTLB248irYJEAbIiN9ByVmRuDiiLIyCj0iLnMZ1hmsSFA0mW7MwDFoOPE062UUdx
 rmvKevk/Tcom5N8cx3RDcQFexYBUALDu2Dh5bhVQ9kUAQhsAd0freNBxKOE3GHt3FRlER1z0Z+og
 phmaaABS3ExUQETXKlBRNSR3BozSBJezacel3DecdkIHvM49ezJFH9La0UdOOd9r33NzGZjtuJsb
 tNshJDYK3/Ax4GFocwqpYRIBvtVuQ2U78ockSBvL7ycwMoBR4L55HlGUUjVnDHgAfmioiivk/OIT
 vg6oCJ5sDFXPZd5O+ikhFhBx2yo5a57c46jl+wRcwQkALQ1ddqoSzT8M/dkSASSYF6hPihODxSFJ
 FT3jgWJFdHoIbFQ4ki2KBgYCC9ISIcJQAO/wNF4WzYweAbg6MapgWSTQbbCoFICbalhRAEoiYch8
 PBx2d4gKfV+GkcGcSCxuRqIeqdSklvLlxrg4DgU5qPNwu2YU12oVcFIIZKGX+rphu/1ycQP+i8op
 esL/+dcT++X/+hOSXvev1my9+db8bDtQ5ESswEsPzxTCLuZ8qA509rB8wwDkB70kvnJwsAhiQsre
 t28lJSUlJSUlJEQRB/vSCfx/fzqSHmZ44fxHVB4aL0sHvmQRy+tkBLAYDQmMAzCgM1lYIQ7PdA8k
 UJpCAIYGCAiCIIg/0SOkgQ8d506HaPTcj+MhxLCFyDGJggkMqwP8QqahA/ej7R7ervzt+Kigm4D9
 IHqHLnsHla8hVSIWwR7zh4UWD+SKPQQ/WCjf/lQ8n84ifec7qpYcYYiumalAleqdK7z8zvP2Q7jQ
 aSeX4wRDyBJdCshP3d/83XcR/Mo3HR7bfAh+uH1TcMOQTqRnsKCfbCdMy0BhSSxqBwg0M5OSfjnV
 qBqcDN60NrAPABzkbD2I7h9diMYp/L+BBIKw9GfvaA/mabGxvgB4AfMB94VGzXwf8gcOHzRVU5GR
 OXI7uAZREVb5Gvhfeb2ebz5KrYMzNHXWoG+MfI2j6sz9Uj1ShmSzQTxAbmlTaSw3AnvR8T4igV0+
 LuuSGlBg/cwNJRA+bHKV7ToXREszoP9BhpTIdikcw1I1KKRw4A8zL0w0URkoYBWHuLCzAm+BkeEF
 TpBVhe26+MDvgTgFFVuhvMOwRDqeBquDNHsyJkSJVpqCmiCKCmaCoCZEPbDE0rgI9OQV3cLjppo5
 AGfoO4sBiaQZAUzBNq7fPyD11cinbk5cVIS/9o2KSmlJSkc9Dj8u1g3g2NjQkKRIADUnntVtpWmx
 JYvkSEgb8ln4lYxgORo1jBZlz2pXPmBvc95CTQ1XZdYZuQZxPaFLYtwI0rRMwMyZdgCPooh0BoDu
 Wg+9baEpKPJxB6INog7vJ3OqfEY+IQdAQWa0bDN5++XaSbyjsII2GJBwHEAlQgEX3W6WgC4spBCh
 /3hAsoupUKAg0OHl881wBB9M0tI6EKA+bAAt9k29mZKoecidBo0GxiOhABRcmkLJ18hj2mSgRgYD
 kchKQBU8VH0uxV+sNttyRDdTeVheO1lZiD7YMDhkMMjDMM+499MOLsaneDxz1LbuSxVT+6hhN48s
 XrF3th0QBaNREs4h7u1Yjix+yMYxEoQj5gw+50h7hEJSWkRQJi1ejWyu5pTUY0TNtSCZiX5kEPXL
 kC0/i+jWlQUz6jUkr1sEv6OxivdcDuKBpkBQwzRBySaC2oCYIQghJCZK6doDmssGKGJkj/SUokIs
 qAlCZX4nbf2ea9Mvm90k0wMivmd9Dzv/xdyRThQkGWQHaIA=
 
 --------------Boundary-00=_GO4BQ2WDQI76V4XNE8TX--
 

Re: optimization/8092: cross-jump triggers too often

[rth]

Old Synopsis: -fno-gcse doesn't fix computed goto problems in GCC 3.2
New Synopsis: cross-jump triggers too often

State-Changed-From-To: open->feedback
State-Changed-By: rth
State-Changed-When: Mon Sep 30 14:20:33 2002
State-Changed-Why:
    You're suipposed to provide a .i file, not make us go fetch one.

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8092