public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-07 4:26 Bernd Paysan
0 siblings, 0 replies; 11+ messages in thread
From: Bernd Paysan @ 2002-10-07 4:26 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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/
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2003-02-26 18:06 Jorge Acereda Maciá
0 siblings, 0 replies; 11+ messages in thread
From: Jorge Acereda Maciá @ 2003-02-26 18:06 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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.
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2003-02-23 21:10 neroden
0 siblings, 0 replies; 11+ messages in thread
From: neroden @ 2003-02-23 21:10 UTC (permalink / raw)
To: bernd.paysan, gcc-bugs, gcc-prs, nobody
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
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-06 15:26 Daniel Berlin
0 siblings, 0 replies; 11+ messages in thread
From: Daniel Berlin @ 2002-10-06 15:26 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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.
>
>
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-06 12:46 Bernd Paysan
0 siblings, 0 replies; 11+ messages in thread
From: Bernd Paysan @ 2002-10-06 12:46 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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/
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-05 14:36 Bernd Paysan
0 siblings, 0 replies; 11+ messages in thread
From: Bernd Paysan @ 2002-10-05 14:36 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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/
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-05 3:06 Anton Ertl
0 siblings, 0 replies; 11+ messages in thread
From: Anton Ertl @ 2002-10-05 3:06 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-03 16:16 Bernd Paysan
0 siblings, 0 replies; 11+ messages in thread
From: Bernd Paysan @ 2002-10-03 16:16 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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"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--------------Boundary-00=_ENHF1A4EXVDXTE4NFNH3--
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-01 11:56 Richard Henderson
0 siblings, 0 replies; 11+ messages in thread
From: Richard Henderson @ 2002-10-01 11:56 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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~
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-10-01 7:46 Bernd Paysan
0 siblings, 0 replies; 11+ messages in thread
From: Bernd Paysan @ 2002-10-01 7:46 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
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--
^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: optimization/8092: cross-jump triggers too often
@ 2002-09-30 14:20 rth
0 siblings, 0 replies; 11+ messages in thread
From: rth @ 2002-09-30 14:20 UTC (permalink / raw)
To: bernd.paysan, gcc-bugs, gcc-prs, nobody
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
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2003-02-26 18:06 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2002-10-07 4:26 optimization/8092: cross-jump triggers too often Bernd Paysan
-- strict thread matches above, loose matches on Subject: below --
2003-02-26 18:06 Jorge Acereda Maciá
2003-02-23 21:10 neroden
2002-10-06 15:26 Daniel Berlin
2002-10-06 12:46 Bernd Paysan
2002-10-05 14:36 Bernd Paysan
2002-10-05 3:06 Anton Ertl
2002-10-03 16:16 Bernd Paysan
2002-10-01 11:56 Richard Henderson
2002-10-01 7:46 Bernd Paysan
2002-09-30 14:20 rth
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).