From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============2571248987821199820==" MIME-Version: 1.0 From: kbuild test robot To: kbuild-all@lists.01.org Subject: [ast:bpf_tramp 20/20] net/core/filter.c:8693:12: error: dereferencing pointer to incomplete type Date: Wed, 13 Nov 2019 05:55:09 +0800 Message-ID: <201911130505.KnO9oiAv%lkp@intel.com> List-Id: --===============2571248987821199820== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable tree: https://git.kernel.org/pub/scm/linux/kernel/git/ast/bpf.git bpf_tra= mp head: eb9b9dcbc8ed96e479f5d62aa97c0c2c4b23beeb commit: eb9b9dcbc8ed96e479f5d62aa97c0c2c4b23beeb [20/20] bpf: annotate cont= ext types config: x86_64-randconfig-s0-201945 (attached as .config) compiler: gcc-4.9 (Debian 4.9.2-10+deb8u1) 4.9.2 reproduce: git checkout eb9b9dcbc8ed96e479f5d62aa97c0c2c4b23beeb # save the attached .config to linux build tree make ARCH=3Dx86_64 = If you fix the issue, kindly add following tag Reported-by: kbuild test robot All error/warnings (new ones prefixed by >>): >> net/core/filter.c:8691:9: warning: 'struct sk_reuseport_kern' declared i= nside parameter list u32 hash) ^ >> net/core/filter.c:8691:9: warning: its scope is only this definition or = declaration, which is probably not what you want net/core/filter.c: In function 'bpf_init_reuseport_kern': >> net/core/filter.c:8693:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->skb =3D skb; ^ net/core/filter.c:8694:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->sk =3D sk; ^ net/core/filter.c:8695:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->selected_sk =3D NULL; ^ net/core/filter.c:8696:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->data_end =3D skb->data + skb_headlen(skb); ^ net/core/filter.c:8697:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->hash =3D hash; ^ net/core/filter.c:8698:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->reuseport_id =3D reuse->reuseport_id; ^ net/core/filter.c:8699:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->bind_inany =3D reuse->bind_inany; ^ net/core/filter.c: In function 'bpf_run_sk_reuseport': net/core/filter.c:8706:27: error: storage size of 'reuse_kern' isn't kno= wn struct sk_reuseport_kern reuse_kern; ^ net/core/filter.c:8706:27: warning: unused variable 'reuse_kern' [-Wunus= ed-variable] In file included from include/net/sock.h:59:0, from include/linux/sock_diag.h:8, from net/core/filter.c:25: net/core/filter.c: At top level: net/core/filter.c:8719:12: warning: 'struct sk_reuseport_kern' declared = inside parameter list struct bpf_map *, map, void *, key, u32, flags) ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ >> include/linux/filter.h:439:47: note: in expansion of macro '__BPF_MAP_3' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:469:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ net/core/filter.c:8719:12: warning: 'struct sk_reuseport_kern' declared = inside parameter list struct bpf_map *, map, void *, key, u32, flags) ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ >> include/linux/filter.h:439:47: note: in expansion of macro '__BPF_MAP_3' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:470:28: note: in expansion of macro '__BPF_MAP' typedef u64 (*btf_##name)(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_= ARGS__)); \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ net/core/filter.c: In function 'sk_select_reuseport': >> include/linux/filter.h:453:2: warning: passing argument 1 of '(u64 (*)(s= truct sk_reuseport_kern *, struct bpf_map *, void *, u32))&____sk_select_re= useport' from incompatible pointer type (__force t) \ ^ include/linux/filter.h:439:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ include/linux/filter.h:453:2: note: expected 'struct sk_reuseport_kern *= ' but argument is of type 'struct sk_reuseport_kern *' (__force t) \ ^ include/linux/filter.h:439:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ include/linux/filter.h:474:10: warning: function called through a non-co= mpatible type return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ net/core/filter.c: At top level: net/core/filter.c:8719:12: warning: 'struct sk_reuseport_kern' declared = inside parameter list struct bpf_map *, map, void *, key, u32, flags) ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ >> include/linux/filter.h:439:47: note: in expansion of macro '__BPF_MAP_3' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:477:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ include/linux/filter.h:477:6: error: conflicting types for '____sk_selec= t_reuseport' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ include/linux/filter.h:469:6: note: previous declaration of '____sk_sele= ct_reuseport' was here u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8718:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_select_reuseport, struct sk_reuseport_kern *, reuse_kern, ^ In file included from include/linux/export.h:42:0, from include/linux/linkage.h:7, from include/linux/kernel.h:8, from include/linux/list.h:9, from include/linux/module.h:9, from net/core/filter.c:20: net/core/filter.c: In function '____sk_select_reuseport': net/core/filter.c:8736:48: error: dereferencing pointer to incomplete ty= pe if (unlikely(reuse->reuseport_id !=3D reuse_kern->reuseport_id)) { ^ include/linux/compiler.h:33:34: note: in definition of macro '__branch_c= heck__' ______r =3D __builtin_expect(!!(x), expect); \ ^ net/core/filter.c:8736:6: note: in expansion of macro 'unlikely' if (unlikely(reuse->reuseport_id !=3D reuse_kern->reuseport_id)) { ^ net/core/filter.c:8736:48: error: dereferencing pointer to incomplete ty= pe if (unlikely(reuse->reuseport_id !=3D reuse_kern->reuseport_id)) { ^ include/linux/compiler.h:35:19: note: in definition of macro '__branch_c= heck__' expect, is_constant); \ ^ net/core/filter.c:8736:6: note: in expansion of macro 'unlikely' if (unlikely(reuse->reuseport_id !=3D reuse_kern->reuseport_id)) { ^ net/core/filter.c:8739:27: error: dereferencing pointer to incomplete ty= pe if (unlikely(!reuse_kern->reuseport_id)) ^ include/linux/compiler.h:33:34: note: in definition of macro '__branch_c= heck__' ______r =3D __builtin_expect(!!(x), expect); \ ^ net/core/filter.c:8739:7: note: in expansion of macro 'unlikely' if (unlikely(!reuse_kern->reuseport_id)) ^ net/core/filter.c:8739:27: error: dereferencing pointer to incomplete ty= pe if (unlikely(!reuse_kern->reuseport_id)) ^ include/linux/compiler.h:35:19: note: in definition of macro '__branch_c= heck__' expect, is_constant); \ ^ net/core/filter.c:8739:7: note: in expansion of macro 'unlikely' if (unlikely(!reuse_kern->reuseport_id)) ^ net/core/filter.c:8748:18: error: dereferencing pointer to incomplete ty= pe sk =3D reuse_kern->sk; ^ net/core/filter.c:8758:12: error: dereferencing pointer to incomplete ty= pe reuse_kern->selected_sk =3D selected_sk; ^ In file included from include/net/sock.h:59:0, from include/linux/sock_diag.h:8, from net/core/filter.c:25: net/core/filter.c: At top level: net/core/filter.c:8774:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:469:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ net/core/filter.c:8774:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:470:28: note: in expansion of macro '__BPF_MAP' typedef u64 (*btf_##name)(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_= ARGS__)); \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ net/core/filter.c: In function 'sk_reuseport_load_bytes': >> include/linux/filter.h:453:2: warning: passing argument 1 of '(u64 (*)(c= onst struct sk_reuseport_kern *, u32, void *, u32))&____sk_reuseport_load_= bytes' from incompatible pointer type (__force t) \ ^ include/linux/filter.h:439:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ include/linux/filter.h:453:2: note: expected 'const struct sk_reuseport_= kern *' but argument is of type 'const struct sk_reuseport_kern *' (__force t) \ ^ include/linux/filter.h:439:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ include/linux/filter.h:474:10: warning: function called through a non-co= mpatible type return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ net/core/filter.c: At top level: net/core/filter.c:8774:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_4' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:477:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ include/linux/filter.h:477:6: error: conflicting types for '____sk_reuse= port_load_bytes' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ include/linux/filter.h:469:6: note: previous declaration of '____sk_reus= eport_load_bytes' was here u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:483:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_4(name, ...) BPF_CALL_x(4, name, __VA_ARGS__) ^ net/core/filter.c:8773:1: note: in expansion of macro 'BPF_CALL_4' BPF_CALL_4(sk_reuseport_load_bytes, ^ net/core/filter.c: In function '____sk_reuseport_load_bytes': net/core/filter.c:8777:42: error: dereferencing pointer to incomplete ty= pe return ____bpf_skb_load_bytes(reuse_kern->skb, offset, to, len); ^ In file included from include/net/sock.h:59:0, from include/linux/sock_diag.h:8, from net/core/filter.c:25: net/core/filter.c: At top level: net/core/filter.c:8791:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_5' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:469:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ net/core/filter.c:8791:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_5' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:470:28: note: in expansion of macro '__BPF_MAP' typedef u64 (*btf_##name)(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_= ARGS__)); \ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ net/core/filter.c: In function 'sk_reuseport_load_bytes_relative': >> include/linux/filter.h:453:2: warning: passing argument 1 of '(u64 (*)(c= onst struct sk_reuseport_kern *, u32, void *, u32, u32))&____sk_reuseport= _load_bytes_relative' from incompatible pointer type (__force t) \ ^ include/linux/filter.h:440:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_5(m, v, t, a, ...) m(t, a), __BPF_MAP_4(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_5' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ include/linux/filter.h:453:2: note: expected 'const struct sk_reuseport_= kern *' but argument is of type 'const struct sk_reuseport_kern *' (__force t) \ ^ include/linux/filter.h:440:38: note: in expansion of macro '__BPF_CAST' #define __BPF_MAP_5(m, v, t, a, ...) m(t, a), __BPF_MAP_4(m, v, __VA_AR= GS__) ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_5' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:474:35: note: in expansion of macro '__BPF_MAP' return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ include/linux/filter.h:474:10: warning: function called through a non-co= mpatible type return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_A= RGS__));\ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ net/core/filter.c: At top level: net/core/filter.c:8791:18: warning: 'struct sk_reuseport_kern' declared = inside parameter list const struct sk_reuseport_kern *, reuse_kern, u32, offset, ^ include/linux/filter.h:460:31: note: in definition of macro '__BPF_DECL_= ARGS' #define __BPF_DECL_ARGS(t, a) t a ^ include/linux/filter.h:449:27: note: in expansion of macro '__BPF_MAP_5' #define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__) ^ include/linux/filter.h:477:17: note: in expansion of macro '__BPF_MAP' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ include/linux/filter.h:477:6: error: conflicting types for '____sk_reuse= port_load_bytes_relative' u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)) ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ include/linux/filter.h:469:6: note: previous declaration of '____sk_reus= eport_load_bytes_relative' was here u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); = \ ^ include/linux/filter.h:484:31: note: in expansion of macro 'BPF_CALL_x' #define BPF_CALL_5(name, ...) BPF_CALL_x(5, name, __VA_ARGS__) ^ net/core/filter.c:8790:1: note: in expansion of macro 'BPF_CALL_5' BPF_CALL_5(sk_reuseport_load_bytes_relative, ^ net/core/filter.c: In function '____sk_reuseport_load_bytes_relative': net/core/filter.c:8794:51: error: dereferencing pointer to incomplete ty= pe return ____bpf_skb_load_bytes_relative(reuse_kern->skb, offset, to, ^ In file included from include/uapi/linux/bpf.h:12:0, from include/linux/bpf.h:7, from include/linux/bpf-cgroup.h:5, from include/linux/cgroup-defs.h:22, from include/linux/cgroup.h:28, from include/net/netprio_cgroup.h:11, from include/linux/netdevice.h:42, from include/net/sock.h:46, from include/linux/sock_diag.h:8, from net/core/filter.c:25: net/core/filter.c: In function 'sk_reuseport_convert_ctx_access': include/linux/kernel.h:89:43: error: dereferencing pointer to incomplete= type #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f)) ^ include/uapi/linux/bpf_common.h:17:27: note: in definition of macro 'BPF= _SIZE' .. vim +8693 net/core/filter.c 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8686 = 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8687 #ifdef CONFIG_INET 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8688 static void bpf_init_reus= eport_kern(struct sk_reuseport_kern *reuse_kern, 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8689 struct sock_reuse= port *reuse, 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8690 struct sock *sk, = struct sk_buff *skb, 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 @8691 u32 hash) 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8692 { 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 @8693 reuse_kern->skb =3D skb; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8694 reuse_kern->sk =3D sk; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8695 reuse_kern->selected_sk = =3D NULL; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8696 reuse_kern->data_end =3D= skb->data + skb_headlen(skb); 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8697 reuse_kern->hash =3D has= h; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8698 reuse_kern->reuseport_id= =3D reuse->reuseport_id; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8699 reuse_kern->bind_inany = =3D reuse->bind_inany; 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8700 } 2dbb9b9e6df67d Martin KaFai Lau 2018-08-08 8701 = :::::: The code at line 8693 was first introduced by commit :::::: 2dbb9b9e6df67d444fbe425c7f6014858d337adf bpf: Introduce BPF_PROG_TYP= E_SK_REUSEPORT :::::: TO: Martin KaFai Lau :::::: CC: Daniel Borkmann --- 0-DAY kernel test infrastructure Open Source Technology Cen= ter https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org Intel Corpor= ation --===============2571248987821199820== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICNshy10AAy5jb25maWcAjDzZcty2su/5iinnJamUHUmWdXzuLT1gSHAGGW4GwFn0wpKlsY8q WnxH0on997cbIEgAbE6SSiVid2Nv9I75+aefZ+z15enh+uXu5vr+/sfs6/5xf7h+2d/Ovtzd7/93 llazstIzngr9Dojzu8fX779//3jRXpzPPrw7f3fy9nDzYbbaHx7397Pk6fHL3ddXaH/39PjTzz/B vz8D8OEbdHX4n9nXm5u35+/+Pfsl3X++u36cwd/vzt6envx2u//88fX0VwuARklVZmLRJkkrVLtI kssfDgQf7ZpLJary8vzk3ydnPW3OykWPOvG6SFjZ5qJcDZ0AcMlUy1TRLipdjRAbJsu2YLs5b5tS lEILlosrnnqEVam0bBJdSTVAhfzUbirpjTRvRJ5qUfCWbzWb57xVldQDXi8lZ2kryqyC/7SaKWxs tm1hDuJ+9rx/ef027MlcVitetlXZqqL2hoZZtrxct0wuYLWF0Jfvz3Dz3XyLWsDomis9u3uePT69 YMeu9RImwaXBDl2uuCx5HuH6HhtWCx9H9JpXCcvdibx5Q4Fb1vj7b7arVSzXHv2SrbmbzOJKeIv2 MXPAnNGo/KpgNGZ7NdWimkKc+5vgzYpYfzSzuBVOy28V47dXx7AwxePoc2JGKc9Yk+t2WSldsoJf vvnl8elx/2u/12rDan+qaqfWok7IkepKiW1bfGp4w0mCRFZKtQUvKrlrmdYsWRJzahTPxdwflDUg bCguxYNgMllaCpgbMFLu7gtcvtnz6+fnH88v+4fhvix4yaVIzN2sZTXnnizxUGpZbWhMsvRZDiFp VTBRhjAlCoqoXQouccq7ceeFEkg5iRiN48+qYFrC7sP64TaBFKKpJFdcrpnGm1ZUKQ+nmFUy4Wkn g0S5GLCqZlLxbnb9ufg9p3zeLDIVnvv+8Xb29CU6iUFAV8lKVQ2MCQJWJ8u08kY0x+qTpEyzI2iU d5449jBrkNXQmLc5U7pNdklOHLkRyeuBgyK06Y+veanVUSRKY5YmzBebFFkBnMDSPxqSrqhU29Q4 ZcfK+u5hf3imuFmLZAWynwO7el0tr9oa+qpSkfjnVVaIEWlOX0+Dpq6ZWCyRc8wmGfXWn+xoYq5N LTkvag19ltyfgoOvq7wpNZM7WpJYKmIurn1SQXO3PUnd/K6vn/+cvcB0ZtcwteeX65fn2fXNzdPr 48vd49dow6BByxLTh2XzfuS1kDpC48GQs0S2N3wz0JJ0c5WipEk4CD8g1SQRanqlmVbUopUYzhY+ erGdCoU2ROofyT/YDLNpMmlmimKoctcCbhgQPsBYAX7yGEwFFKZNBMLldP30UwuHDHX8XJRnnlkn VvaPMcRspQ+2Noe6fBjsCew0AxEuMn15djLwjij1CqyJjEc0p+8DldKALWdts2QJ8tBcXMdr6uY/ +9tXsF5nX/bXL6+H/bMBdysksIHEUk1dg72n2rIpWDtnYKMmgaA1VBtWakBqM3pTFqxudT5vs7xR y4i07xCWdnr20ZOAC1k1tfJ5GxRvMsGh+aprQOttg7K7cYygFqk6hpfphIHT4TO43FdcHiNZNgsO e3GMJOVrkUwYIJYCrsjkPXRL4TI7PgioO1qKghkF6hJuO3GTYQeTVV3BYaFABTUdCEfLbmgBT58F qKhMwfAgCEHPh+fhLizPmWde4OHCnhgNKT2XxXyzAnqzitKzsGUaGdYAiOxpgIRmNAB869ngq+j7 PPCsqhqkJ7hRaHeYDa9kAfch2JKYTMEfxJJRcWtPb9tvEFsJr42xAytNPLVvrnmdqHoFI+dM49De jtXZ8BGLvgIErwAbVQYnB1xZgMhrOwviyNH9DQVOmyDpCLIlK9M81KjG6raqmVSYKPQ89WGFYFl4 KgVY2VtvnoF2ld5mjfdpEBwMrMKsoefaaL4dejGfICK8kerKt7WUWJQszzwONYvKUn9AYz9lFNer Jcg3TzqKym8nqraRkYJ2lOlawCq6TY8l5pxJKUKZ5BwrpN4VnkHoIG1gQ/ZQs1l4ObVYB0cI/Hbk zJHXjLr3t8YIfwxNDFOELsrEHV3fN5jtn4hOoRVPUz+CYa8EDNX2du7AY8npSeA+Gp3XxXjq/eHL 0+Hh+vFmP+P/3T+CrcFAGyZobYBxOJgWE50bUWqRsNR2XRgfhnQk/uGInjlX2AGtvUjfEAyFMNC3 JkwzXMWc0VpG5c2cYr+8mnu8DK3haOSCO1vNwy2bLAPjomaAJfw14ATNC+PvYPhKZCIxDltoRleZ yGl+NqLO6JjAVA/DR4744nzu+01bE8cLvn2FYUNcKE9TnoD76M26anTd6NbIcH35Zn//5eL87feP F28vzt8ETAv70Zl2b64PN//B0OHvNyZM+NyFEdvb/RcL8UNEK9B5ztzxNkuzZGVWPMYVRRNdmAJN KVmitWmdsMuzj8cI2BaDZiSB4xrX0UQ/ARl0d3oRu3uB8PWAvaRozVlySXme4NrOJfq2aajze/GA rgx2tKVwDOwNjIRyo1YJCuAxGLitF8BvOhIVimtrJ1l3SXLPFig52DEOZUQNdCXR+142ftw1oDP3 gSSz8xFzLksbugCdp8Q8j6esGlVz2PQJtDGrzdax3BmSA8kVeKotGKjvPSPHhJVM4ymzuxNeMHVz k6fIGhNp8k4wA53Nmcx3CUZifMVVL6zvkYPgAm30wTOY8EgUw+NCrscz4YkVHUYe14enm/3z89Nh 9vLjm3X9Ah8lWigt3QoqcIliIeNMN5Jb+9aXRYjcnrFa0FFBRBe1iR+R+EWVp5lQSxIpuQYjATh0 YlKWvcFoknk8Jb7VwAvIX53dMtEF3q28zWs1WhQrhsaEV9FbFipri7ln1ziIZY5QuPYc0UVBMyby hvICqgI4LwP7vL//VGRmB5cHrBcwjBdNEKuH/WYYywiURgc74rxsw1CHs2BAjUb92/hb3WAwCfgy 150tNwy2pk8U+7KXJg4WxrM8ElqJSZ2H3nfyB2zrskJzwsybHIglsjyCLlYfaXitaEYv0PQ6o1Gg 4Sn+6+V43YRsYg68BA3bCWkbprjwSfLTaZxWSdhfUtTbZLmIVDuGGtchBFSZKJrCXKyMFSLfXV6c +wTm7MBJKVTgAHXxLfTQeM4TKnSHXQL72wvnOYIdGG7bGLjcLapyDE7ApGONHCOulqza+iHyZc0t J3nEqfF9BgHEgINEBdYC7fCzHCh2Ywqnw4z2Uq1kJeivOV/A8Kc0EuTRGOXswxgxAGBdOer4MMRt eAAzZy2K3oh9KgcMBJrkEsw060h3acN5VWkMZFKGseEH32vuABg7y/mCJbsRqj/cUPwDAo53egiT clBL0ARUU1H+QXOUYfUlB4szB0s5UIWeh/Dw9Hj38nSwUeCBYQdnpFMBTYkXmBIzI1LJao+Dx/gE I7mcpjBapdp08YPOOJ+Yr79Ql5wAe6rJnUPgNM5Hz1oqRAKX0SZ3BgnkgHaGtJTqaejDGvBwUFZE ZWzEHyAXHgIZg0oipPlgbJsQlgoJJ9gu5mhLqUhM1QxNHi2UFkmgpnEzQZPCzUrkjkwYWDvMmB+W kBF2Y48eOWsWb0SaU9mYN8sjig4V5RMNCiVju0LWajXYJN6h5XiJcqfeMU/V8MuT77f769sT75/w QtQ4TXv7pmwijDGCx1EpDAbIpg55BUnw1qPyLNzEB0LbPCS3WUMMmm9QGwwMoyUdrDULB5mXklrP 2EEFqy9HKg8uYSHqWAZYDGiwoxbccARoFeNKVnwXMAvPBG3z8gTdNBK3vGpPT06mUGcfTiir7Kp9 f3Lij2x7oWkvgbb3Zo3pt5SYpPICSHzLk+gTXTPKY7PIupELDCrs4lbKz6j0IJv4DcKukilw1RvS G7Dt/mj8cpN6uVMClRHcU7A6T76fxswLXihGOvD6UTLWtQePdlFC+zPb3KnsHbgdmAm3hwy+Liiy YXR7H2IRGawoJtlWZU4nH2NKTGHSlkGRGucZbtOEQK1SkcFsU30kvGec6Rz8/BoTPt6aPNCgJ464 eCNeYGnaRtLU4KwMdHu5BFGQN3EKakQj4a91zHEdlapzcFZqVGy6s8QJKvS4jY9fiIWMFJhPp5d1 QGIV+tNf+8MMFOT11/3D/vHFLJ0ltZg9fcPaMi/MOIoW2AShFzOyYYIRwOWfAmesQ6mVqE2AlcyP 27HQWM/zObjm3o57E/FuSwH3BA8HbroOi6EQlXNeB8SYEhpDN2zFTZ0DDe2qvk79SxjgF9Ri6iC+ XxdjZ3FAJbl31JtP1qwBMZuJRGDQdUKbOhcYj8/Djb7cTTQyA5ZTVaumjjoDRlnqrhAIm9RpEnXS hVPt3IxdprxQoecN1p3DviBdbdtXnUg7nXimtW+aW9rwvOzswBbIVG/++SjJ1y1cMClFyqkAFtKA 1O3KbMDECmfOqLM0mDnTYF3sRi3mjdYVXdhg8GuYSDXVacbKaG6apREkDSUBgoxXKTlwilLE1lgH MjaeI7RIR/vSIyO4qMHTi9c99MQWC8mNnpxaZudcEHq2WzPKq6YGWZXGczqGi+JCdloJskwVcxH8 rRkomXhpndTuBPQEUlSha2j5cq5GfL8k88h2Ao3SFdqJelmlo82UPG2wZGzJZLphYOJOalVDDn9N 1/EZNq65JwRCeJiz9Mmjq4C0iyWnw0sDCQe/8u9IMBg9HS1La53Zy0zKR4G5a+Cw0Py2gijGDkYF iLNNEuLJQgKYGJatTY3juAf+zrzaGF2ri4/n/zqZnJ5xMeKIicrE5VBrNcsO+/973T/e/Jg931zf R461u+NkAo9u3Xcsbu/3XrU39BTedgdpF9UajMA0DZV1gC54SYVrAhrNq8n2LqhJ8qtFuQCob6H1 y/Byz8Y/GZfdOZvub00bsz/z12cHmP0C0mK2f7l596uXXQUBYp1ozxwAWFHYDy9AYCAY3js9WYbE STk/O4EN+NQIv2pdKAb6IpAbCEoLhnEmSnSALVgGNbzG6dupbE7uwcTi7MLvHq8PP2b84fX+2pl6 wzTY+7MhIjKZgNi+P6PHHfVtOs/uDg9/XR/2s/Rw91+bwx68yJSugcqELIwIBJEMzi0tMAohKEkL cFsdMlxUA8KXCgVLluhlgBuCHiwcm7Ux/dNJsEB4nmmYhG/XDogBlm3aJOtqUWio82uCGGlVLXLe r5GqUsC5JbUvNXpQmEZGqEt9Oami918P17Mvbttvzbb7hXUTBA49OrBAhazWXn4NEwYNPt8YJdWB jFjYGmvju9J18AQEPh5xwc/gXQZms+9e9jfojb293X+DqeFtHvkn1rcOS2ysSx3CzNQrm+n3wA6C 6jCW06s4zYhOOgjKeRiTNbG0xMRHMLaVTTzXqGod99cNgK9NMqqkarD9m9J48ljPlqC9FdlQmJrB wk8tynbePTJwY2DSLxrXdC5gezCvTiSjRwu30KmeiJX53UwuL2tKG1oCOx1NUROYDvSnIQsMleGR gulxCV5MhEQxinaeWDRVQ2T5FZyhUUu2MJ+wRjNwZjDS0BXyjQkU12NT0Ud24dcgKufN3L5KsuUf 7WYpQKGJUToQ8+uqD9VoUw5nWsRdqgJDI92Ln/gMwCIB8xpdbkxyd9yDaiamU/zT1PHgm6fJhoHX aiDLTTuHBdrCzAhXiC3w8IBWZoIREZZoYa66kSXIaTgK4d/KuLKK4A+0n9EpN5WlNqtvWlCdEOO7 4inZbVoaxOaGcwzEwRGsX6UW7HnSdI4NhkpGrGRZ3xZYdxnHeO8t1CauJnBp1QSu7zDBLlDblaWQ FLj8HM4qQo4KJpws7ooqAvTo0UKIPvoQaSM0aOvuGEz6Pj4rvOl8q400WAW13wY98QAhFoXjpwcx 31bIF0Vc4OcEUYk5D5TTLir3T+nauiH7RDzW7sUBGlN0Y5AYH1TA6PTRVpkRQno3WkfqkjQ8wVo4 z46t0gYDQ6hLsGoVmZbYJ74VGiW6eZWl2Sg8iQxgmpt8RVAINcwvKAyLlR4OQMrmsNVQa9YxQr1z klXncaeWg7q3S2MVA2sVNvbaF8CNzPVQ9plKP8M01Prw5OLdoWCD0tCgmrR7XSg3XoHZEVTc3B4h 2ZxC9c0lFhE2vrB2EFONTK0QXN0cfIUuDREqnt4kAR1J2Rgomv1C0rhpV4jr0pC9ZZhU67efr5/3 t7M/beXqt8PTl7v74EESEnV7RfRqsM7iY2GJTYyjCkyQxNZktuftv3xH9djkepcwbxb4ZhEs4CS5 fPP1t9/CR7j4+NrS+GZLAOw2Ipl9u3/9ehc6bwMlPssztZI5XiYqs+nRKlYmpm6F6gjzPiW+fNYS 7hddcTZQ4523NgrpHgbzjgtp/8be7xkTWBlL331FYCrBFRY6D1UenTSLxZvNzQEH+sKlQzVlB/Yz TkMbi57KTDnzawqP/SiZ9O+yJ54sOEpBh8g6NB6tBHOMqiqwFFg+uQFrSynUeP0jmlYUJlngeZUl XFTQJLtiXuWj7VKgtDgf5QrmYVoKn8QY31jyT2Fdm3ssM1cLEmhfJkdwDPAspNDEoxsstkxDsEsb mqIDGeI28yAp0YHagirht0PYSrp4YAulRse9q2rWv5Kurw8vd8ixM/3j296v1nfJKXwggc9yAkZj 4KuWAw0VAhJbL8E1uK8qo8DgMiwYidBMigDhVdUlR2dQqLRSdFN8kpkKtTLWLlnqUsL0VTMnZqSq HKakbKiU6ryBtiYSRI4w5JnT4uj01UJQG9Lk5qE3NbGmpCe0YqAA6LH84ojjs9mp9cVHaliPn72h XXAzYi+fFYtPGHMM2RNgaAGLKgSbrKR91V8Njyw9boV2orLlEykYVF38aoxc7eb+nXPgefbJ5Dbc g/VgkJ4VVXnqNS1t5XwNagQlLVgIweP9Dm/MO4s/hiPbbkCm8KnGPjJsHWVZdYXuuCw2EQXaO+a3 GlKziCiTHJPIDUVgTDn37Kid8wz/h45o+OMCHq2tqdhIVgexwiH1bk6Zf9/fvL5cf77fm1+dmZni uBfvvOeizAqNdvvQB3yEETQzKfSF+wfTaOe798I/or5UIkUdil+LAKVEZVex987R7hlnat5mUcX+ 4enwY1YMkf5RbPBopdlQplawsmEUJnaeXE0UV9w3lr16uC1WdnAKtbaB7FHJ3IhiPKhRt62pXx7j M/wZhoWvnacqUUJ4N3CgAUICd8pVGT8ZIFrYghZK0tlqFlPJYitxz4cjL8AoCcUfUc2CxUxYfSNb HT+wspXtVZdNcfJZeQfnFmH23v5ORCrxp40u6Ps9/ZAgxNAvxY7EAUjvn+UbFlbVkWSFfVQ5VY9p I4VY6BOGfglI1LspaDJ17wNN8Ipo5W1lknMwXDriIVEjKxh9M5GiSSYexiC/D0EKYmFXdVXlfoL8 at5QuZ6r9xnWOfeJnitlHzz6Td0bIGCBeupXJVw7E80/8rbApFpc7NzTIql7gjgORPXiujYvy8Ko jn2Tso4CaU5dKPtrIdCkzXK2oPRF3dVlurVyaar38bcvAp+uqUGhlMmyYHI18TgI1CcWHBi+waL2 jHIwgtWYKBLLfZk9LZYHButd+nL/8tfT4U9wkj3h7b1dSVacOgw0CX0XBo3LJKi0MrBUMPqwdU77 adtMFkbfkliYNyZ5qEdLdklDGrW279rxl2vIroDAuQGteURAhUGBqC59HjPfbbpM6mgwBJsi5KnB kEAySeNxXaIWx5AL1Py8aKiaYUvR6qYso7zYrgQRX63ERO2IbbjWdBkxYrOKfkTS4YZh6QHwWFpG P5wyOHCKp5GijsuYfWy/XB+IDBeBdFI7cNh9k9bTDGooJNv8DQVi4VyUlhUdm8HR4c9Fz22U2nI0 STP348FOczr85Zub1893N2/C3ov0QxSs6LlufRGy6fqi43W0oOifAzFE9hcq8HFCm04EXHD1F8eO 9uLo2V4QhxvOoRD1xTQ24lkfpYQerRpg/8/Zky03jiP5vl+hp43uiKkYkZIs6aEfQBCSUOJlgpKo emF4yp5px1TZDtu92/P3iwR4AGBC7NiJqGkLmTiII5E3mrsSm3sFzqRgSxV7V10LNqqtd9qNoQKl KcCeqRw7byCq2ffDBdvfNcllqj+FJq8RPGxPzi6kaATjkvem6XAkY6c06PKySr0Xs0TWBioUGhU3 gJI8xJR6iaKgHoJZevLuVL5UfaRK0fIk9PQQlTzeY/yctvrB0RbE3AltEdrYOSFZs5mHwT0KjhnN GH4NJQnFIyxJRRJ87epwhTdFCjzBQ3HIfd3fJfmlIJ5sYIwx+KbV0rcrbiRQiimWUyLOwNIhckiO abKHkVw+ovRyaGN5wbKzuPCK4uTmLCARXeW94yA3qp+Op4Xn8oIvzDxx3Afh51D0SCWb6cVIFpIT FkCHb2FlVOAXc5uyCXCKkuNZMg0cmhAhUDctdcfVILtJmdrKXRPdW4wEJHT5aru6mtzj7PPp49Nx m1SjO1a+XHPqOJW5vL7yjDtG6J6THTXvAEyu1VgbkpYk9s2LZ7dHnpjqnZyg0kd0ds2RYi5WF16y hNkB+HS3h9MUjOawB7w8PT1+zD5fZ/94kt8JOpdH0LfMJKFXCIZysC0BIQMkgQOk4tA5L4zYiAuX pTh53R05al6DVdkWpiQKvwcNprV821tZwyjhnnxjrDg0CcdJVbbzZGIVBExpfiZ2h8Owu7SjReAE Z8vd8sjI4Tkpk0DbAHEMvquCtWejE6jip/95/m46WlrIXBgW/fEveZNEcKZTS3xVEPBmxSpo7z/J 15n2XQXKEGcNSz/t/mjzsQqrkIFWxvGVhWKCO4kDRDgxN22ZP/JmQOjia8aVlZu5IGd8oW00UCb9 JeQhR5tnWBCe6g5Hyt3YoVeg6GLPaCr4qABNfQsw5aTsTvSNM6ZCLCo0exOASGWvpLL6A1lq3ejd jnh+9rQkd6TdUkGEGQOtGnedMjslJng/uzQPyr6/vny+v/6A3JKP/WHRFPHh8QkCxyXWk4EGaVnf 3l7fP00/2klcg02wg8Db0/rx/K+XC3jawpjoq/xD9L2YKxvbKwsFyo9gXAopVvDScYVGHlHbwHRz RL0VCp+/fm7Zy+Pb6/PLp6XLAQKSxcrpD71trYp9Ux//+/z5/Xd8tcx9eGn5nopR0/J0u4mhBUpK a0OllBN7g0KJchtoKEfTnskWNJ1qx/7l+8P74+wf78+P/zLtwFfItWFyn6qgyXE+XANLTnMstbeG VlbMji5jGQO5EaMrbaVcHHhkkPMivluHW0v43ITzbYieSfhYcOvTns9DIyUpeGxf1W1RUwm+DgOk tQ5BCcEgDUIo8mLugttoVskvVnXT+TCMegHfX5bt8QxHPZIdLzb0cErBlYTTQZvcwUBtmo2LlTNF QyUb3a17+fD2/Aj2Tr3pRpvVmI7Vuh4PghaiqetxT4B/t8HxJZMbYpNR1gq2QI+bZ6CDC/7z95aL mOWuWe2kfbcOLHECFIxiSaSrgxGIK+eoSoudk6pQl0ku/JRhel65v7KYJOOk16qjPkREpTweEdc+ iOHHq6TS78Pwdxd1kC17aVekdPgx5DI22Jm6Kknfm/FNQy3lLOzOBwo2A04GLq/HxDx7xmEZ7Rf1 DD9R0cFn24baiQnKE8iEerQE4OQSlxxnNlswO5cmU6dLId6hrdn0ce2D0gSgRFm1WxwVFXDDxKLc dU9V7nlOAMDnUwJ55yKe8IqbIyrZ3jKv6N8NN5Nht2XCdOdsyy6BcfR0UZqa3hNde6aDABAd5Ymr 9s3ODqID4I5lVBuG8JA1z3nr49QeFVNvZcY2iw3pJpfihutUPZiAMtxjrDJd4apYrRiETjkOTW8P 7x9O8BZgk3KtfFU8TVv+LEZAFoDkjKmESRr0HwykAynA7qp9zr4E3gZUjIzyRmUx3phGAzsXmLlM tmf8leozT/LPWfoKjis6J2r1/vDyoWPbZsnDf2yfGdlTlBzlGXG+JXLTqe0qVPrdVRYHC7+b8uJR YuNtlLsYWjf5CyF2MeZvIdIW0xhpnhfO2N0HS1Izz4Lc8FqRNKK9JUn/Xubp33c/Hj4k6/X789v4 KlSbY8fd1r+ymFEfiQAESQf6zEBWTdkYKPGU/cDxxDSw4PhGJDs2Fx5Xhyawv9eBhjehSxsK/fMA KQuxkaowVnm1+I4NfEwaiyrGKsuLkdyoeKp44hwBkjpnL3cKSNQ6tQwsgn8RtQPOw9sb6MDaQqUt UlgP3yGrirPS2hu5s8GL0aY6XIUT52lC6WifaJbcg69jhM8Qe2KpelVFKQrJT0Mp8dQn6TcLnn78 8wuIEw/PL0+PM9lmS4rxPV6kdLUKRqNQpZCZdsdxNZmB5RfCAQlSG+8S4tEVq31LD0W4OIYr3Kal DrqowpXHJxnAyWjKrMW7BZX/HLBLHEO4g9oLJ37++PeX/OULhWn3qbPUZ+d0vzB0xpBBE0SSJv0t WI5Lq9+WwzpPL6FFFjMpfWSjg9gW66zSV+1B6PnKDrXlYdzN0IF9FnwTJ6yB+u39M6qwGKUgFB9I qpR5PycQ5G1A3c8D8zOg+vcEpKBwENQSJkUcl7P/1v8NpSyczn5qrxD0gCg0e4j36sU2TeUNcX66 4f9yx5eX7ne1xcobc6kMlfDKHHZDSsS0Ojb3JxJbzCIANIWBYvOuNQGu6gnH6V4BsD7/FPFRQXNJ jLyOpgNbhxCxqE1SFM7tTwYo+An6CSxg7JMTwzp2vP2hWGXKddSy+Q5p280qVCgfczdbUFuE6Roy i/1Q/i9K6EilkATJuMbKvffXz9fvrz9MDVFW2OmQ2nCCUUGTnZIEfgyTQGN9Uw6mmhYVNGtCAHXj xSKscRr+DT+mXRsn8DH96ZYmkg3DS5UDo47U2rhwFSqVt3VHo43LCD/I/ZdHmImug4pjPB6RqDfj GQRGAytshz0kbDdhynZkbmk162DAo/E5dhajK26FLSGnYhCALISLsrD4DNwqP1TDKo9VVxmdYJQ3 p628OW2lqOve1e2cMkO5O14AgKMWJgloPJYpBatIuXct7J2l0uxUM23PH98NgbIjSiwTkghK8iEW yXkeGnNO4lW4qpu4yO0EX0MxSNf4JBs4osCtyfEpTa8gT+NyTpRCfDtGGA4kq3Jjr1V8l+qUD8b2 V4XrusYUj5yK7SIUy7kh80tBPckF5GWHFJ2cWhYsKfYnuZWzqYjFdjMPic//TCThdj5fYJ0rUDgf uu6WoJKQ1WpuXSstKDoE6zWW9rJDUAPazg394SGld4tVaCRCEcHdxhJIzq0SDYRnNFZFXlGVnArJ MhQLxHgjcBpnKvz166ZDHlt4a6NuRLwzE3FCXEAjBXRDK1qcC5LZ7BIN3ZtCRzgwySykhommW1BV Lo97aAhrQ+FqVNgnI+l7bAEpqe826xXypS3CdkHrO3OofXldL+/89aQo2Wy2h4IJY91aGGPBfL40 WSDnQ3vKGK2Debf9rTJH220UypMlTmnRBe+2mWP+fPiY8ZePz/c/fqqnYD5+f3iXLPInaD6gy9kP yTLPHiUZeX6DP01aVoFkihKi/0e7GG1SiryBNIHnl8plXBiKjC5/rSUx9oWNh8oOCFWNcfHtKTlL obOTVPjL59OPWcqp5Ejfn36oR52HDeiggMIu7vLw2H2qB0p6hZugfIdiA6AxTEznvLDxhhMtOQWJ ODokw2gOrx+fQ0UHSMFwZQPVoLz4r299HlXxKafBdP7+heYi/dWQ4Pqxx6OsRLcm1FBjsuxyjy8i owfc70bRFpJQyAOCcuU98bHdEg4kIhlpCDf1ItYVOmBCfgQ7S7j8OVoDiJPtZM0RtVJBtGluqC9L wmN429cMsAIs+xdomS2SDGUqU/ZuvAvUCNqudd7bX+Sp+/ffZp8Pb09/m9H4iyQwRia0nt2z8hXS Q6lLMa69r1IiXGMpBeYsttKGdG3t0R7QZ43VJ/bXtXGNQrmS+ImVWECVJ/l+77xQqspVZjDi5qMd ZqvqiNSHs1YgwnWrYze5oxqAbkedSEz9/wjJah5SY44XX5UnPJL/QQAqwZb1eLkGlYUx1E4P4nyd M1uXLrO8wdIApKKoX7yCKU17lw/N/mJa76OFRvNPCyAtp5CirA5v4EQsvAFsN+Li0tTyf+qI+Rbg UIjxwZIVt3WNhUJ04PHCkNbDwG6JHEiwXuL50DUCobeGRziVzK2Z0UMXgNFFqBgu/c6O+exWiwEx jJV+56pJxW8rK7l4h6Tfkr2Rpq5D1PzE6DUACwoPOv42H49DGXSr6qrfUnTnTaJtTYN4WzDxhdu/ 8oXbm184QjW/0TMVW/djR424n3tj6TndLj1qBX1PnOU28+2M9HxKuUMV4wJEtdwpVZEh4jrasCW1 3p7Q9Fb2GNoKdckuqzsqY5c9+tpRj9Fy1j9HADgtdj+SKV2gpSEQOOVtume/BUMGILOWBXemTLfg n1ORkrIq7m9QntNOHCiuSmkphuSnPW/NqiFcS89DiC0UW9KW+SzOyNUvHAGpL0TfhbKZhnoRbIPY meZd6xyIlir2yIbs4+owGoAkv6jyU8EKd2XhKR6ejxvJOPE9F6E/s2JeMiyu6WpBN/LMhU5vA0Rl XI1jcLgAJbiKsg98uF04FIRhDmosBwv2nsIYnnlyMVLbQUqB7yVnIldM7tgbX3ufkKl7UfBUinfe BaeL7epP96DDwLbrpTNJl3gdbOvRkvgtUZrnTG/eV0W6mZvqFlXYunfbhR3v4ffFg7tzFWLL3yIM +9itqmfbX1Mvlrwwxp/vKAtNNsph6i1dI0YXnUwywJKkto1JP16tMxiiLajXJolpO4kVOzM3tCq6 JBiXjJGWqzurTEeWEXW8h1J1DAw6Ho1CwnXJjb3SIrTMu/C6Zvfa67TLbjqes9gM9k9ddYequbNP XIelDRuQ/YHsJSMBP/CH8aARDuYoLsy8BLFy4RZcqBRZYIV1eoGH70teoFGXEtwlNzOriIwU4pBj yy2hKhmilOvOHJJIOZIMtOjVd0ugsk/exGAlHmAGLSe+Z1skMOWQvxUfMuwra8q+sTK3CoZdhpY2 94kHYKoU1ZrqN1utdT55ArAlDC4dH0y7MuJftEvIkV2trsECbKar6os62zDER6hIGcHdNWsRdwzX ocOeGMWeDTB4PE4trLB6H1JomcPs8lcN+jplOWjch9oGR6WTcNIXadUPY2wWLLbL2S+75/eni/z3 61iZIZlqBqFIwxC6kiY/UMtu2gNEVOCO0D1GhiYEGMC5uFqph24NtSdqhMoJy+GJJuWhaDunEAoZ 0VN4/jKqMA5XDkkLIcYaZO20WmQxz2JflKsyg+A6rXuVXvtGTgKfbQiiz5nPL4NQCBvFVaGFF3Su fRDwbPAEvOx9Xg2ECs+ul2OXf4ncE3RVcm9MaXXCxyfLm7NaFZV63NPwecIc6Os1S1Lf4y+lG33b ebl8vj//4w9QcbYu2MRIgGg4SgyhGX+xSm9CgOdWdGIKY0do3VuzoLkVJcWSBTr8liOS3NAaD8Qd EDZbfOby0uHShzW5Fgfc5GSMlMSkqJjlndIWqcfR4ORPNCAvd+scsipYBL5MFl2lhFB1Xx4sXj3h NEedaK2qFbMTxhHKMu4xkWoTRoUm9zEbTck3u1GWkX6Jp+rauQbTeBMEgdfyXcCGdR94sFc7S6mP DsBTFfUedd40hySJWlbZfD259+TKM+uVFN3OBCYit1/iqRJfbHsSeAE+b4Ek8K3f1EY6SdbI/k5V 0mTRZoO+YWhUjsqcxM5JjZb4QYxoCjQYp0+gL0UB1LcxK77P3dARozGPXko9DuYaaM2KE1tVfjAl thElyjDpyagDFTL7vUV5s2BhiValMz9Z81odThlEYIDmpMCDh02U8zRKtPeQPQOn9ODo8TWF5+pM +P2J+4LMO6AzRmQSDiwRtmzUFjUVfkR6ML4zejC+RQfw5MikRGF7l1Gx2f45cVwoFzS3aSQq5ptV 4KmHzDqftG6kmOQRDSaJbWxfVTpVUMIxe4lZC5JEWIJBEuKOR0LuHU/EsNEePOHDausYsXBy7Owb PfACJbC701deiROih9ml56/BZoIK6gdvzNp7NFmgUeVwIhfbhi+F36nl5JtwZdpDTJD7lDYLUPIL xXMXb+5xGtjjulxZ7qEPvPZVcS9NG+JrbukbmQT46rhRSJ0MlQZzfM/xPX5HfE0n1jAl5ZnZWdbT c+qjW+K4x0cmjlcsDtXsSPZCstza8WlSLxtP/g8JW/nFXgkVl5vg3WViPJyW9m47is1mhRNVDZLN 4u73R/Fts1nWHscFp9O8PcEGCaTh5usdrlaWwDpcSigOllO6Xi4mjrbqVTDzDRYTei3tyA35O5h7 1nnHSJJNdJeRqu1soLG6CBfMxGaxCSfuDfknK50kzyL07NJzjSZuspsr8yy3Uzdku4krILO/iUsu mrW6yVSn4J8i35vFdo4QaFJ7pVYWHt1t5dYuXPEVGflZchvWFaoS5seOgDGumB+tb4Y3MSfou84I 2YZ4W/zBgaiX3dBPuTKIgd3xCeGiYJmAR0ssf4d88s7R1gSz0n1CFrXHdHufeFlu2WbNssYHvkf1 yOZATuDhlFpc7T0FL0JfsrYynVzcMrY+rbybLydOU8lAqLW4mU2w2HrysAGoyvGjVm6Cu+1UZxmz vC1MGOTlKlGQIKlkpGxHILhmXaEYqcnMd7JMAOSx38l/9ltHHuWcLIdIcDol8AqeEJsu0W04X2D+ zFYt2/mGi63PjMpFsJ1YUJEKitAVkdJtQLe4XMkKTr2mW9neNgg8IiQAl1MUW+QUVIA1rtwSlbqU rCmoUqXInVzeU2ZTlaK4pnJD+3hxSZw98huYlD13EsdeUjUHcc3yQth5oeMLbepkn6IvUxt1K3Y4 2RlBdMlELbsGvDMpOSDIzyg8qSArRwE0bvNs3wnyZ1MefInEAXqGt4Tw52qMZi/8m5NtV5c0l5Vv w/UIiymFi/ZMNxtvfdVJzf1ktMVJEjnXkwtU89LR6LTnCQBhgTun7OIY30uS2/MEVqhcgBHILjgT qzOhnH3SgFx7X5o0zdwC27rdrjz5vYvC4wPjiMJKwQ3eyF8+nh+fZicR9a6pgPX09NimoQNIl5CP PD68fT69j01OF4dYdpnwmkuMKW0BfVAzp/rSwmCVpQUG26Pfti2hqxFXhTaamvmDTZCh9kOgnZYD AXUyrgdUCu7kyALXeXz9Si5SO/cm0ugg32FAJrlC75yWpFV5YLCeg8CApgeUCTBzW5nllQf/2zU2 GQcTpLTTLMswv5OSXOnYqZqpjImzyzMkPfxlnCDyV8is+PH0NPv8vcN6HD+GfPGZ3VLg4XGdW6uZ afxJtiEjBcevKWU+RFIMDvyviFEyf7YomPzZFE6oXBsk8PbHp9fdnWfFyVg09bNJWGy4h+my3Q4e DFA5LR0I5A2FSE6nWL9tcYRUMA4kJfDeTwvpk3z8gEfCn18kUfnnQ5dpxa4G5l9fulSN8jW/OggW mJ2RcbIzeKv8NCfLF/KuKxzZNcodV+KuTNIw/H4yEIrVarP5K0gY3z2gVMcIH8J9FcxX+I1j4awn ccLAo7ToceI2s255t8FzEveYyfHoCX/tUfaFR963MNR+8yQd7hErSu6WAZ5qwUTaLIOJpdCbdeLb 0s0ixEmDhbOYwJEkab1Y4TbcAYniVGZAKMog9Ki5OpyMXSqPtbzHgaTLoICb6K6V4yaQqvxCLgR3 rxiwTtnkJqnSsKnyEz04z0AgmJdkOV9MbOC6muwRdGuNx0limPQKnvTyqA0M+uWlTZJ0Qbp9S2bv yhqSkSTH3OIGjIXhQzyUxpaPT19O86jETHo9wn4XHpH29iUv0AYB0KAvNQwoJy7PbZpXaAOKNyLu o5UuluAxu3Cw3N3qqUpjigyeK5UY3rt+XjL0mNx7vAspS4662fUoKdkrRTgyAPX8Y15G6BAUMPK9 STmgwcPIE59/4bH8gfby7cCyw+nm0hOxmgcBWhuuV1/yuh6pLgimJOvhhQAMN20HApYsx+2eirrE BL0evhOc3EXufa+eaLCEV13SSPEG3ESo570LE4sXkjeewjqQTDKTntdvBrRjJH9MIRVsT8QJp8Qt mmAlJ4ncolJqwYSG9uuBdAopPJoPcBuF4NpasLLN6Df0YWBsNkW6uZtjRgITjcRivVneDdNvA9eb 9foGbHsL1oYgo6NrMZxcBygi9fQBUmGT1pW3i5NkQnhNOc6vm6jRKQzmAZZ9YIQVbn39gT0pz1jD abZZzbHwdwv7uqFVug+COf559FpVonDi1BEEK8wbgesD7IUvx4kgEBwnbcUNTIdemCgx2c4X2JZ3 kcwkDBbsmhG5733tH0haiAPu5GbiMVZ5pkSe3gQiotQR9aDUdDG3wx1McCtiToxgn+cxr/EODvLu ZAUO48n/MXYlXW7byvqvePXOvYu8kOCoRRYUSKmZ5mSCktje6HQcJ/a5dpxjO/cl//6hAJDEUGB7 4UH1FcEixgJQQ817oOdBlrKnLA1x8Hzp3nhbuXqcTiQk2Uv1JpdLvIimf+FpMeHdb6ZXi8uwM2Vw tTsM8wBXmQ1GypIAPb80uFoWhjEuC59ZTuAeVw8+BvHD00pdNdfeXto+ZiF2RW9M7lUn4vx6a7vk G/0pmQN856Sziv+PEFXqhXeK/990ZzYdvdBjGPu7/XdOs7dyyrN5/o7p5Ma3YaGno9/aQzbPPlEA DfBNrs0W4mqkw4ZvB43q4Ws/hG3sGR7Yzqnomm/aI/zzJkbFDNR7YRIE887CIDk8HVeCyR6Y+apW wffas/83egT1HJfqTGN7R4PhGtNa3VRF6ROJ1ew7ehObQr5n8EybU3sS0Xbx8i/jiSub0XcoKmzO 0yT21t3A0iTIPGaOGuObakoJeUkVebNskrBa7R9apat4ulj9miXmCFJbXzzf8NjWrpogiHjVC8jQ OySlPVqUU6BFpVwoducXdFKq4DY2fxg6FGJTosChxMZNvaAlxqQhb1uev/wqoojXP/av7KAWQsrN gd+N3mdxiJ/3Og9iYhP533acPwnQKSfUclO1WAZaDwxbUCTc1EcO2y8ci5sZNQuIysB+rzSOgVOZ HopLPDlSgNwi5UEgWuDFauZz0YoMNnohC+3esSTJkUJWhiZ2SwLTzjB4DBHk1OZBqDs/YS29xdpB Tubluff75y/Pb+F+zQkTN02Gg93Vl5v1kN+HSQ8pIH3/vUQVHJAkqVnXfEsps0x0ZTHiO+Ouf9P7 bL/uZ4Zfe4hQ7Hya7Tz5CSEK5IReRDciTQW45ULAfs3nrrrKfOHbhX11fWxN6wAVPfjLh+ePbiRU 9b0ivzDV3UwVkJMkQIn8TcNYibDnS+hrnM+KpalDJzgCe/SMkIWJSo8sT+F62CQdqOZi9L2WorEJ NIZuvF9EcPgYQ0feaeq2WlnQd1TzVHUlajtlVOKNTyo+OUs8Crshy0Ry1ApaZ2oG5mmbVnjJykCR n//4AWi8ENFTxGX4VzdwpHqcbyAir6WNzuKxt5EsUIUNruYpDuXN6BK1fmGX+rNn/CmYUdrNHjuB hSNMa5b5wqBIJjXF/zwVZ/iM72B9ia0+zensuX5aSho9hl0SHj1+rAo+sYZ3hpfEEFx1d2qq2WVd I1kb04nVPi2dxkYsWEjrgPf80XeutwSowWdI5Q5JXR/NRfUa2hoOIcum0sITCGoJfyral1p3EoDI UaXc6A06xIC8C49sFAEnez1hnXyLMG2RR/ug7FpCsNomsPpkkW4FJNLszxZZ5HjrTyb3ceeFDzeu mnSlGUZ4JYqcR1xpaD2WZBujsO5A6nrjAE8/97XCEgt9tWxG9H7fiONbDAN4PrY/rdmtROz9t4im sHWyp46KC1p0kodwWJB0NbaOnTY6ambKVX0Smzr+sBj5oMPDK+lWQnsrUF8UkX5b+INr4S+KWdIh yQeoK0uVDuapPvy+t3i4bT4qzvShgssSaHljb0X5nwGLpspbntppRLgQnqjZc900TzJUpEURYat1 HdHV9rQthOqg4wWyVQ54LnaDCYK/yUxGrikI31W5FiDEdOylEBydUK7HjNUZ9wYFWFx7Qoh4bdBz MhxW6MnvBO2BsxqGF5zYXtawzO1fH799+PPju795DYCIIu0AJic85MykC72ZaBx5Dq4WnoEWhyRG IxEbHH87skLUMPOrgNg2Mx0aaYaxRKbc+xhTIpWNCjRZj0R8Z7tFJYXSio+/f/7y4dv7T1/Niima c3+srXoH4kBPGLHQRbYKXl+27l0gxKkVVXWgr7hwnP4ewpju5QaUL63DJErsZhPkFD8FW/F5B2/L LMHC+ioQfKytr4eQOoOxoQRy7Tv9FSDzZJ2WYIvrDwAOdT2jV3FiUEz3GzWl68ThCzE7nyLeWXzI EwsSXh98RFxMOqv5tvaQmIVzYhoFDuMhnU2atBk2CYOw5BYND/MDZjcniqOtm+lTTDr/fP327tOr XyBjlkrr8q9PvON8/OfVu0+/vPsVLEx/VFw/cN0b8r382+xCFGZONfY1clmx+tyJ0GymdmyBa5IH qwtqLKzBFyG7JD36moUdiye+rzUtPIGlaqsrdlYBmPtN4nBDRjqru59Fbgy7wN4xzNG7HS2838vq dvLYsgAszaidNqz+5qvTH1zH5Tw/ynH/rAyA0fGukklwzfn8MNmDbSrAnubqbsv7b+/lpKleoXUX axlQ065VsDLUubsZn42pDp3WjFExXY7WOIGuYQ2nRqRzFqHA3U4Foa28zosbC0zGL7A4uwPtSxzh I21CoWXHgKLyg2nnJDedvJ24DYYDAhhg+GKCiawsVqmCVq3qKRxrt89foYfQbXEo3XlDhO8VW0LP i8DsH/6VDmfmC/mSdyz0fQcQkWAE8mOWYep5Ed8H32Gf5+SZcfZunNZDotQOO54SKWXmgug+0BvN OqThdHCREh6jekvArjvnE3ZALHJ94tqwSWtnPV0qUGblgqaTHK8KoL556l63w/382rqFWJtwyeSi 2lI/KxtEs8gULkahkP8EsmuKjAP43ppzTU2Vktmzv4ey7dlYQz2HjQ8Mu0oZBjOh9uCPdddNg2KX Os7AXr39+EGGyncPf6Akvr0Cx9BHsY1AhdK4xMElLuHCIrrap+31v0Nayudvn7+4Ctg0cOE+v/2P DSgzeOU8AkbVXTXd+vFR+BKBoGwqWkgAp9vDP//6q0i+yOd4UerX/zU+lVdMmOT5XWyAIF0CxZO3 uVKtH1l3cBCy9UpOkHsAjYH/byMsyUYdQE6MWIHiqKXQwzouxJYOJGJBvg2UBWFzmASz+4S2llsI 3zmO49O1rm5uaZb7x1rY2M9TbwbCXEoruq7vIKAd1jUWpqosIFP9o1s0n+z4/ngyXacX8Fy1dVfb hTtsNa1eEKCpbjU7XsazKwC7dGPNKpFlBKl42IkWSCWyOGvyxAMcAh+gXTnBYJEnxiZB5NkS4Qll Kq4kJDrH3UxEtTxUj69tx33Z0WyzdL2oJci6ThNW3MKYRu5uZXa0T89//sm1XFEYoj5LwdpywGdM AZe3YsAtBQUMp/x+dB1NSjH0fVGtW58ISvPEV0bRuCa9PeYpy4w1RdZJ3WOH8AK7znmSOE+4WqdV K/cTfdBPTHbqVE6OfOb5QaFw8WbVul76KQvzfLaasJ7yzP0uzzZwAaMQjWgm4FvdQehBqwZvLExp nOtftiv5up8S1Hd//8lnd/eLlIeJI7+iexM9aZ0XO/fbYGJXl6KaKZnlFS0cp0Q2v6Ki/Kc8QfrU NNSU5PZ9taYKWzUiR96pfKGmxvpN3xVWq9iWghvR7bk/F92b+zThRtty9AzRIcaPMBSeZ2h8D1Wz 5uwpK6lo2sKedaQdSJ5i5DzFapQDB9RibMXzOAvcB123CguG+ATOY8rQyztApF3WPzbxcIiN0zW3 SdVxVP1CU6vTILNVj1OuJzaQVc6Xw/7BkR9yaYmIXh6vooWpklwEO/cRPGNJIxLO+lch0q8a+O5X iVvFQ+h8ghjEhg2/pNMoynNvGww169noPDWPBW+5CB16iISmJFxdvGhbG5HcXXxb+MP/fVB7cGdv cQvV9lJ4X/XGZcOGlYzEOdZ/dZbw1upvXwClZyOlsnONfikir/4d7OPzf9+ZnyBPCCAqoimCpDMj 7+RKho8SVnS6aBqEGasYHML6z/MwdlRqcBDvw7nH9NF4HI2JYXL4pYuiO0X9OUyu3FdAgnok6BxZ HuA1nuUhDuSVbu5oImGmr9tmN9A0bLipvBdX/IpXoiJLCqZ7C5RdhqHRAlvrVDvUuoE93FrdhmUo C4kbU5vSCouS8g3PxAcA7lTHZ5T8QBJZAN4RxAR+h43/BbtyU7gjARwS7BSrhNpzOoHrJQgeD/pN oNupL89CC6cBTs+Nq08DwW8EDBZs9lkY2FFbohcZJVGrVhn3npN3Sjq+JirFkCOFgjz2kjbXQ/ka qQXwngiwwqUitFfj80B0r4HlQUXXbxUFxW1nDeaa6elS8S1rcTlXWKOAmX6G30lbLMQVSSAkRIRV +gyoWtox2vKJXCHlncqctpYnxznBJrzlUTFmhCHqdrWuIL8OtXCAWkgyVx6g57lLVwuaI4LoX24/ bKYoTUJMNKioOMkwn42FhXenOExm93UCOAQ4QBLkcwDIosQVkANJrp8CrCOoPUZxttGXxhDdBi6B ySEO3ReN0yFOjHV1QcStwYUdB8w8zZpDxc/7VU+nIEnqxF+eH0gTsudvfNOG2RiqPLHHerqcL+NF N+iyoAjByiwKDSNjDYlDPOirwYL7u28sbRgQrFubHAkmGgBG+lUTwuIZGBxR6Hn4QHBTlJVjyuYQ zdcLUISn49E44hDJAiyBEK9rDqW4ObPGYe6eTAhz41s5WJRhAjGapSR0gcccQj4j9DAQACLEqWjD 5GFn4d3yGQ9NxVpsednkghhHSIdgQ1WVCH2aB+QrSpYSpBTIlkxChF41DZ8NWgQR65Zy8HQ+SO7k dz6nTh75dvHoCghHRUFywoGcnM6uKKcsibKEIY8w+qBbii30c5OEOUM+igMkYC32RWeu3aC3ZxtO sD7wUD+kIboKrVVxbIsKfSdHBk9KgZWF7//E7LjPlSRey1nJAfeo0I335ITzOkTKn2m8N0h57x9D QtBRKtI6+YLhLjxitdnrS4LjgM5MYK8UogqEzkHCBJUOIOKzb9V4YnzbZvB4rWx1HlwbXniEC2W4 9zHAkQYp+jUCC/eWB8GR5lg9AnTIXpIu4trfXleA1OLo3CqA6OARO013O5jgSJBJTQCHDAW4qAfs ETpEASbhRKV7mLPMUOMKemnNNkXUiqbNkFdyauQWzKnI6s+p6BDk9H2No2nREykNRuXN8XHR5pjm usFYzXIqOj9yOuYup8EJiZCaF0CMtJQEEhcYaJ5FKSIaADHJMOm6icrDpZpNaEiSlZFOfOgglQhA liVYq3GIb433ujZwHALk67uBtpl+qrp9yylPDtpKPrSGfezKp4weEQ2R4NLyxehOT6cBd2VRPB0b LiMkvhwYWsYYJWRX8eUceZDGrsD1OLAkDlDltWZNmofRfqckfIuZIt0FFo8s98z/AIFV6qUprPbH uKM83Fun1OyMfBxHSJAlqBosJytP5C+dKY539XfYKaf6rnbtCnPFFwZEFZ4GFvN9PjpsOZZEaYaH 0VqYLrQ84K78OgcJ0KX7TZP63X0kC3uYdiuc49hczsnR3yiZIiqwY+e56rhtFWYROm1ULbVP810O wvdirhQcSG8kQLsCxAyOs3ZfS1iYDnsTi2Q6RocMqYdpYtAXXaBt+UKLbwBpSPIyD7GT842JZTnJ sT0tBzKk6gteFznBh3xXkGBPmQEG00taQ6L9SWiiGTJIp4eWYmrG1A6hYUKm05EWFnRkHHJ6HGCq B6cTtD9AMGE6XF7Q2zlXmqcFWsAUkl2F8jrlBD8wuOVRlkWo4aLGkYfI9guAgxcgJSapgPAbXoNl bzrgDA2fSCdk3ZNQ2p1RKCXZA7IjlUglIFcacRS/I80M1wI/vWDwvY4EcBj5jnOE6TEI0YMYocQU hs20IkF2uamGYF5oMAfFVLXVyAUGN2blFrZlnA/cMp0tqYVDKk+IqHWHvLEMk2pJQ33ur5D+erjf ajSwH8Z/KuqRT+eFGaIe4wQ/dhkVDq1X7BF12dQ0PbV1AuspRxQEXz8NkxQYwPRW/PXCi7Yv8ZW0 I7jDD3mVCjtNnQre+u3dR7Bm/PIJ8+4WpnnyVbQp9PMyrn3ch0e4i2oHrTsaz7Ge3suJT9E9O9mu BgbD9vw2fDhHFAfzrmzA4L5cjK7l05d8NurOcbforeLUd9OHpRzciAatPPymEC1H8S0em9j0AoHs esbqo+HBzo7GD95TRj3utniK1hAoG396QW0ieB3aT23TksHiEVa6HkL5wsnaV47Jhs+CG5vHnPBI 2wJ9AwBOVxdeZr/99cdbsNldQkg4vao9lVZXBQqcLpvH2hC4VJqHoUkfxEPFRPIsQIrj8iWHwNRn BL08JFnY3rBwzKLE5ZLQoSmXRP0jlGeH4UUIgG0ftdHsgF8awjzh+sWbwMg0xHc0Kx5hS/mK6kat K1E/d9iImjGraANxFzsjxMTY6UAB6pAbDx+kMTh1uVqyWbSUILTIrkJODT3BpUUN0xDS7uxW8cKD 31nznc59KFhNjVcDlfMPDXZJB4XKSe71pRgfEa+qZqDCsNUgMDOx7DaL23F8UQZw4DP89xwUJsra rFPJJEJQWPW6IWLK3/1KwWW4oQEmTBFp25emZRNAj3xd89acsKww0+1tZF9HX8wx7JEn747dcTdn WerRkVeGPMZ2pQrOD0HmvAxMUmy5BdlzHrzh2GZQoFMqN57mM1V3IuERvQSr3gin4cEUbqymi9k8 miHBMrgVxYxEulLNG31lPmlFZxOv0uwJdfKUBJ544wKmyZTkfpxV1HFg0+E6ztLZSa8uoDYJsH2b wB6fct5DnMkM9vyYWchxToLAeUtxhGgru+I9MWo6RAB1qvm2PYqSGQLOWYH6NTZpsWu2pzK7cAts Wiwmp2jwxUp302AHloZB4gnVJux38Q2SCvFmiqQZ/JpCCTqaUGqBlV2v9SXCENnsW5j18Eo/oMJq MEEE5lR3SVoRw/VOIXxuirQDmMVcx1VEFqS4lPrcrwySkQduTUiyCBlSTRslkbP0Ta9bvlHwfPLi 2KArM8q6HCNi2skC+Zd0oTSQ2PqKNoEzHquFgOoJ7yZhe5K0wdx+Sx4HgUMzbLY3mtvEim45mS5I Eni0gVUc0wp8T/tdHl2PxvUXrsSd7EEbz6meK960fTMVaMLJjROiuFxEMKaOXdrK807YCIt98Mr3 ggB8mT3z4bf7amT9tsA0wFp6YyrolOepdi2lQWUS6V1BQzr+z4AicquAQnLr8QkTVer+u4JqWw23 PaXq7EF0fw4LQb97VYixnlMcCDr1WSwhVvCp6JIo0aeKDbON0jekZs0h8lhgG1wpyULMFGRjgtUt Q0UTiOebhTnifuMAC/5dts2ihkw0SvKDD0qzFCsPUzNNNEHnaYMnT+MD/q0CTPcb2NFILYgkXuHy A2pTq/FwHRTvPIDooVdNRL8w2RClhmAI1VMz6XTX5FVDT5c3dtpujO2a54HHsMTiQq//LR7dqHSD MHVSQ5tzYufec5jgsjDktYq1JKglJEoDvCKknoUG1LWZdNXNxkwFzkJDT0ISi43EuE5psb20kqxq G1LVmiKGFe+1Z954bG3BQGQIcAyBpX+z5lW7EkMKd6Oy6ReQ/074Q1hBusQh2vnL85/vP7z96saa Ks7ayOA/wH0sjU2S9PTWugYQWY07egB2rbGZWW7pz5PmXXs9F1wZ1E5FFUGEPjsPF/ZTmOoQu9UT +KT3RpSKEvXx5dR7OUBFrgfUnE+PHbccLmvk5SD71b+Kv3798PkV/Tx8+cyBr5+//BvCe/z24fe/ vjyDMmaU8F0PiCdOX54/vXv1y1+//QZBQuyQt6fjnbaQaUzT3zmt66f69KSTtio81WMrIvLwDlAa T5X6ZhtK5n9OddOMFZ0cgPbDEy+lcIAa0vwcm9p8hG878bIAQMsCQC9rbT2Qivfq+tzdq453YuzG anljPzCj0LI6VePINVd9G8TpDxW9HK338/4DLvQ6DVx4lsA9G7Xty0pFLGNGqVPdCOknGQDSbc/3 S7wd5BIRqrMexwt2v8exoSWGEPw3r+BTf4dIGn3XQT3/Y5b2dKxGgs/6HC5GatUyr4AQUxagg8X6 MgwVeDZrb82QZtZpWIoDTutFMlgXOjtwdKyv2OwAXS2LA6P8psqDJMut4infPjYNRODuKJZgGUpS M5ZFWZ3I9OIkgm/KoDcsfpk26d5Clq+uvrRGJ1lAyMz0+lJh2BkjGklotHKKa9VZFTAWZeWxNYaG n55Cgp36Scx4SQHRsCdDHCAtN2ANLV1sdkjbMNIRFlliswimJM/oLq7FuTI7lyCZ++uNXFCqRx8B oLY6Z83ukblbXKieWw8YI+jKBX266vnkVZtt9Pg09gYhKk/2YACSlNb3TsHh7X/Xvi/73hyd1ylP iV2901iXVYdd8InZ4NFiH1pMn5PDq4UF6JNL42tq0d6rq2nCYID0wqYeW45hpB1b3n2mOAnMYa6O FMzuX/Hu3/VtZYkNoTiIJ0IzNG/rpCRRazS68IoJ+vj89j8fP/z+/tur/3nFe7w3gSzH7rQpGFPR dzd5AWniUxCQmEy6tZEAWkby6HwyfZ0FMl2jJHiNXRsCXDf1gZDZLA2IEQnsoqayJzFW7QBez+f/ Z+1amhvHkfRf0bHn0Nt8iJR0mANEUhJLpMgiKJmui8Jtq6oUbVte2Y5pz69fJACSSDDp2o2di8PK xJMAEgkgMz9v6ntsiovqAuchKsu5Hy5WayccdCNw3O3K7t6mmfvBzG5PUee+5wXUYuqkxcjH7Pla DFGs7t5yWKi5O1AJ7OsTzAk8itOfdAcs6TVkdr9nlUKnn7rHm4yMB9+n42zDKkYVbmP4GNXG5XyO XX0Ra0ayuscsgjd8tjGK1Bdd9EiA0wBVIMTqrRj9bdoD7acfZniJZkyOMQhdo2mHwHNmGWWW1yda xqHrzMhOV1ET7dTmq4XIL0SFcVQBey5TQhRrdGSB3+B4A5F1hZgjO2KkGahuVKIo29eeNyWl3+AA 2DaMF/ud6bhm/dBRoxGpjHJM2NzESYlJPPnaLmxEr9hNLpRDTPzCou2QogF17LB7gltwDqZRtPmJ auBxEKbObG/VxsI2iICMB8/ZYisrTL0feHAahVjh/J++h6vSB+5jkQnJSb5myAZVRXRcWYUekmpZ 8EQyx3kQFB/zBjpsR2yzffphmmq/Gw93CXUP4l1C+bk4fK+X+9VgmPcQgdL6lnL093l+OyTrb98a 8w1nDUwPHX5/kFlOHZIqbeUwKy/3U8eV6Au4lqLM/COKpmZSoUhc0KE5ooMj0Fi0mB0BVSAajIS0 fSL9M+QIpHYGFrvz+YgJP7B5uhmdWKxO08ZaeoomT7HYnxF4+/kgtJTFJu2iWiaOniCpNyOueYK3 BKi6kdIi5rhOiFse5SmOGQrD0twKNUAPAJYCkjNaecSn3khgC80Om9HG1c0qteuLWZWx0a+zlrbw dp6M3dp5iDJHXNnbUsfZqvhxvthaSG9ZYJmxr4GQRJvCX2NauovTdYFnvqIhVK6OGn+hqCkOa2Qm H3GrhebsuOvPxr624rq4ZQqRypqfm5iTZvmaZe1kYr9yZ+azs2psnWTzZjC4LZ1Su4G/Laq165mX zHLMioxZlCachlPzakUNUMMsPDNB3eUeGQZeyZZmYwniKi1rcSq0W17liU86pijeIrSrlURSWZMC MmVzHAS4J3ZyCLHEea/ghS1mPc/6Vrf5Shl/KSi5+Hd5x2pEmJCjaE1kQehik1pTgXXXQHUS1YAN MwKro1NLxebTFFWiCJ8mUorMMvlFWSXYEx+HgBaDhHLfEVVDMGkSRgulYzuWSVgZDQj2BsFwbyfn 75OPy/vkX3fPb5O797fL74+Xu4fz8w8ZI/f+8nC617eYyBMClczTdc5olBicUEHC/Mfr38Qj4ZFx suG161jCYpc0jLxCsRIyR4FO/8e7BCWPLk0jmXzu+X81YGREfSeYDtdTexIfMHQYLhkqTGt0Tn/q 6FbssLYqIQqDKZ0V0IxvyT/D6UAIH3ebbCASaSMiuSGkVQJ4PbimljpU6mJ0D6F0jNWNtf1x/F7Q lVhUW0uCL5NlMdBautrFBpg6pBUISlYzHrGBHtex86KmgXLaVCvLqwafBqKU2Z/z0JRFtCWjtMlM sTQ6k1greBgKMnCK4DRmqE6pOCtnaCXU03h40yaIZo/Fzz7WWF0lu3VN3fuLZADKabRrD6VTXwdK 1HN68FbKX073AHIGeQd+BpCRTcXusbEbyKJqT6szkgu3RHSbhYa/54PS9rAWRotbJtk2pXVfYKuw 3SPVRZtU/Lq1a4yK/ZpRJ2Zg5iwSK3OQRxxd43Sb3FKnHVlmK6ZwTbdiofOxPGIM14UMs23m66nH 1WokZ5LzowmUJmlZEhW5RfsmmoxJ6yRfplVsEVeVlVPka0HLUY+2t2NjeyP26KLEpUA4dV7szItN Wd1tJZ297MJTQHkYKT4175iA8IUtzZtEINU36W7DBsVuhQ6dipVEeghCgixSEQxRYVkyWJlZsisO lJ+PZBbrVK8Wggo/SuPrdPSVcc8AxGqfL7OkZLGnWOb1V7peTB1rViD+zSZJMj4+b+S7Tl7s8YxT nAxeIUbXWc5uVxnjI8JIaGhq2g6KTcHLp1hRMlbyC4D1SwbLDXCDUzkBR1u0q0cAIwSvqGh1Ua5k ofYIoZEVFRpfgzz2hWXupGYQO32scCFw4CnxiSCCLcMHRSceFU02eppEjCTmFicTvahgwXGrCVWa s8b+ypyl49+Js5zvTQdlSYTgX4A+OCiqThh1OtQ8MSvFDpRYrRLll9lwR6hySs2RggMAyRlPzeje LQmtJFl6Lk6VX4pbXUW7TRvUQZY6PRSWSClKngwlQb0RAmUEV1KyAbVP3S6OdGUPO/ix5D6u7yZN haJjibom3eVWu74lVWF/u5b22fz9dhuL7XtUEirH7uPGxEoy6OrJU/8abORZSaMaUWpGj0dHaUUS SE9rRibIk5HWcA5OhViii1H2DnyjCxuQO4uiuLjZqeMoqpMuvtP5zea0ehhfHotNlB7BeCZLtJ1P P8uAr2/SkfomyPsMwI9Gjm+QQPy7G/M0Bb5Eld8wftxEsVX4SA51Byk/JSSSiMi9ItjRy58fr+d7 MYLZ3QdCB+uq2BWlLLCJkvQw2gGFFjEKjcs2h8JubPexP2mHVQmL1wkNuFHfliMwaZCxKsR4KbM7 2u6QdBXLhS5Wp9G2n14tpXu+MBBD+Nv5/i/Cp7fNst9xtkogePQ+Nx1bwH36uJRApX09vKMMatgA gCOJ0WXXWKerHIIqmH4rLe+L3L53R58E4O6SVcHCI7qvb22wU+MuubH2Lfil3scp2lFqHRZnWcFu uROaNWDuRgD8mnQw3/AETcxQmfGTgNOSz8o9UrkkjfvhlHzel2z5PO9YDZREjyKaJgWaGE6JlKFj PoZLamcojtuncDeoixTJtnxmZfHgCze1GyKIpkWAJgZBAx6BOYqY2/HMEJ490R98QyCH9OuJ5s9p /8KWq1wNcKYoSw4Ai5BSt3L9pwka+pMFzZgs7dKEfjPoSuvzVLOaNHCUiWyX744Y2EMtdmPXm3IH R76TLDIMGFoGsTd3vEHvtNMyn3qkwaRMU0cMTNit4a6zKFi4jd1wmLjB38P1Nfl+uU7+fDw///Wb +w8poKv1cqJNQN4BOILa+ie/9QqUAQeqegSqZW5V3wNDWlRA78VE8MWycgtdeDZfDueAcvPUU3tw MwKdqK/nHz8oKVIL8bOmHz7B+g2iPaRi+781RzQVf3fpku0o+5hEzIKjGGl4lOdRtTfOCZLVKwya WtURftYFAsQAC+fuXHO6qoEnZSm5/mKInwDWC3zwEQRruV9NLi9g0z3AIAejaOqwvlfZ+rap30Jp zFaAC6C8Z/WublXR18D2TZxycZ6h7nb2yIla6BSRiTEPhDKuDnDtBWBEiBGL7YlksCTCBDGVosJU z/caMGZgqwWMXVI3VlJxBEDbKhDzVTjyiAkvRZ+8qCtEeXNYFQXc2PeDkcvP99fL6+X722Tz8XK6 /n6Y/Hg/CY2AADzcCJ2oOpAq169KMY5gt0t8FBHicZ3u6LciGZhHG+Qdibmnk5W5WhOGFtQHDek/ dbSpiryHAkbwDMARyTNWopupjlFCkE10FdKxajowQF99n0WHMaHNWjsu39QllY2+02+5WWl2VROF Llgbe7okb5fyPgDdJQzq0pjtn9UHWZesoloq1dkVNVRdXyRwngnlkmZRcRzRufMky9iuaD5Dr4uy rWgwoI8C4lB/VodXGMGDd5SSmc8eSp4Dr92vosvT0+V5EkkAS2ka+6/L9a9+4+lz9DaIfd97Zs6a xXROxc4wEvE08Kcu1RzJCtyRwgVzSssFI1EUR8nMoY3jzGQcXCWOEf0ECym09/yvClJehqRoGPmo 3fjciGm9k4eTdhRkSn55v1IxjURtyaE+pnMvMGI0yJ9HXUqfcpnFXcq+QVT5neAQOuKyMEPwRMYD nwIqPuZLbLyRig+xH3Uzq8Rh6+30cr3cD3tTJXCFA8ZuZguJHKqkl6fXH0QhZc7XZnskQS5hYgoq 5lcxeMc16FDHHasRpvAggSAMS1d7CjniuJndbRrYVMqHx/aB9iIUvxtATeo9vhSjiCa/cQUZX4iZ A2Dwk1dQD7+f743zqXJLe3q8/BBkfonQWa51QiPYKp8o8PQwmm3IVVbx18vdw/3laSwfyVd4IE35 x+p6Or3e3z2eJl8v1/TrWCG/SirTnv8rb8YKGPAk8+v73aNo2mjbSb6xT0vI68Hsbs5Cq//bKrPd viWu5/EQ7c3ZTeXo7v/+V0NvXMVLtWBVJV8pXbmpI3kWbTHs74UcUnONQiJXyWWAO7C0JUVem0bi FX2WYsWZ2AKoQ5VOYIOKa7K+cISgfgvKpAkli8AY3tj1NZPyj+9Zvh/Qjj46yVCUW/x6F7iBQxRe 1fPFzKdd3HQSngcBGVZc89urP+NU0zGioUYnNPSiMlxAUzMn4E+IE8PKPOf1tGO0JMlwS9QH8TD4 W+l4iI4rQNYnPNCniLrUv6Yhs5FnkFTWKnRNQIjSSTwzCb8ZmI9rcptci1Z2f396PF0vT6c3a5Iz cVRyQ4+8QWl5ht8Ci5vMnxpRHTQBO6C1RCu6iyTPBjHqBvwR8LKcuRY6W8480tRUKOBiRmrvtyeK ih0JEQca3XFi5uE6Y+a7tL2sOI9WMRnnWXLMqOXGs4iq0zefGGAE65bBGtNhD/HgpeMzvuiIzd82 PEZRLiRh5CCheFZgom0Tfdm6jkuGZot8z7zPzHM2m6IoSIpgRQPSRDsUkCDTUTcEZz417xsFYREE rh3RSVGtMgWJbHoTTR0HB49rotCjgYEi5jtWJPh6K/R/0iRNcJYscMwdz1qOaok+3wnNBCzUHs4/ zm93jxOxO4ktCSOhsljZE0JE45qZK27melOzRYLihdSOAQwTdUH+nptLfDY146yI36ETWkULyjEF qymxPVQsy0jzRpQOLSvBEYOL6piF8yNuFWAxot8LF5ew8NHv+XyG0i88zF/gAC9AWVDX+TroKETh +zBp8zmmRRFEE3E10XjPnE99ekfdNDMyhLkKAI/j/qmba4tWR950hg6CkkQeLSXHhJQBNcAxMQQV SI/pZqooc0zwQx8RFqHpBg8wNAj0EQgWEgOQFmTPd2wPuCLG8UpqG2LPRx2HSH1x5Mxdguaja+yW OuU0ap3iu57rG1GsNNGZcxQdv00758jhUZNDl4deaJFFAW4waA+fLQIykF8K9+bTwMSGQfCTZrBA OHgLuvwyRFlat25alLNW1HwmVkzBs7pent8myfMDPvcMmPqQ9fIoNHBLNM39MERirk+lVI6fpyf5 BstPz68XlLfOxKCXm9Y8wAx3nCfhfOS+IeJzej2xr5btLJhxVSkonOvScs8pORmo5vBtvmjMLzlo vXHeB3WtvchKepSyweFoc37Q2Scij74KwXaTWi9QGqB8O6PUBlNrNNpIl29qBznvwSW8LuYL52Wb r2sT6p1IYPQMmkWdCHBKZQnSH+UGdVhaC24XzUMBIS2eHnL1/qAnu5j3d2oK07tpgDBuILpd6ODf eBMKpp6Lf09D6/cC/Q4WXnVcMmw1p+nklik4fmUndij0eMEIvWmld1ZzR3DDkUhbsCeE5IMvFDbH XRG/hxp8EC7CEQVdMFHAN/l7bnVlFtInDcEw4ymJ35aO4psu9RE8x7AIN20+J08xMZ9OPaPsPPR8 84Fd7GiBi0P8RuV05o3E/Ba8BYkcJ4S5aJIz9+SLLN4CBCMIZvS5QbFnY8cKzQ5HAjZ8OtGVoZMQ BA/vT08fhFuFXEFpXmaJ8kQlqxgUoEP6nP77/fR8/zHhH89vP0+v53/DC20c8z/KLGtv49Td6vr0 fLrevV2uf8Tn17fr+c93HRuqG7tF+/SP7mRH8smSy593r6ffM5Hs9DDJLpeXyW+i3n9MvnftejXa hY+8K6Gg0QtE8uyB0m36v9bYx9T49EshefXj43p5vb+8nETV9h4pT+MOlkdAcn0HLzJFpHV/eaLH Mq6p+NQEC1rmazcc/MZiWdOQOF41jHtCnUShaDqaFaKmp6MyjC1ufVsV6GCcl3vfMRuqCeSGoXKT p2PJGj88SzZxdk7rtd/if1mLbzhqarc/3T2+/TS0nZZ6fZtUd2+nSX55Pr9drNm5SqY0HpfiIKxn uL5zXNJWQ7M8pB5QVRtMs7Wqre9P54fz2wcxG3PPdw1hH29q81SwAXUaQ74jG1HwRq9J34uae+YW q37jIdY0a2/a1HsaKSudOY6JsSh+e2gYB73UBqJCioIBytPp7vX9eno6CRX4XXy1wZpEwQo1KRyS 5mZkkDy11ljarjErDV4f27wJjc+c7g6wCkK5CtBdp8lAy8NgWIqDnv8Zz8OYN/RWMP5NzFUEHcZG Jia1vxhV9jIyUkg/wfqVAFA3LCNtZeIvYjL5OOoJy8S+TgIfszLmCx+NElAWaAQ27iywfpsjFuW+ 587N91lBMPUI8dvH9muCEoYkou+69FgpZiFzHAKsK+WZt3BcEuhR8Tz6rUEyXY+6DTCvHDPbll7R ywq/Yn7hDByzySfDyglonDdlqTiifFYjlnoHIaimpt+BEF5C1OErNk2jLlh3BROboCGNirIWw21C izLAdda0vtGp6440FlhjWMn11h+BkK+P+0PKzRBIHQmv7Z5sLcI64v7UpdR9yZmhy44Odk+MexDS HZG8EWAH4M1mtHGl4E0DnxquPQ/cuYf8Gg7RLpvSQRYVyzcG55DkWejM0Cn8kIUu+Tr2TQyl52ks VS2FsMRQVkt3P55Pb+pCldistvOFiVHMts5iYW5X+gEgZ+sdSbRvwU3WKLQNW/tjIfeNVQdlJHWR J3VSCXWHvO+O/MAzgz5qSS2rV1qKrf60jf6M3es4H7YEAvjI+ZQAhNQM+3vY7BFvY52qygGvY1ir ouP9yuK1e35rZkYNew+I9fJ4+tt61EZ0vc/fP56fx6aOeeeyi7J0140UKUPVc9yxKureS7HbO4l6 ZAtaa9HJ75PXt7vnB3GMez4ZrihizNqAQP2dj8GEx9+q2pc1/ZBYg2FWVhQlnVtaXhk5uwbTzULH lZfLm9AAzv27Yrc/B97MuDKNuVjdviXNgyl5EyE5cxdtBoKAwGvhFO6QCK7AcX18Pw1yzDg1QArH fI6ry8zWlEc6SHZefBxTJ8zycgEPA8hWlcyizrHX0yuoUoTUWpZO6ORrU0ssPaxFwm9ba5Q0a1uJ S+7/WhYNPI77RKUzgg1UZq4b2DdCNnsEwqTMhITEj248CMkrXWBgAGMtysbbXAf0OWpTek5oiJhv JROKXDggYEHUEi0JNBi+Xqd9hpgSw1Hl/sIPBtsZSqwnxuXv8xMcS8TamzycYQ3em9MEq30jqlUa swocypLjwXwxXbqeb8Z1X8Wz2RQhA1crxwxx0SxQPFJgGw8ohyzwsw6oz/g4n3ZBW8O9Xh7BI+CX L58eX6B7C4+7Hl5mvyhLCdvT0wtcKpFLToiaNFdwlkVU7FXMyuE6AVxQJMyyZuGELm2FqZgjgfvr vHQc6qZGMtCtZC0ENTnGkoH1MQnEPg8se89WrhNfoM+6qymPv0OemPEoxM/J8np++EEaTkHiiC3c qJnSvYYEtdCwp5QEB+aKbTuzQFnX5e76MPREO+QppBbntMBMPW7SVd4gS2G1/1dfJ/c/zy9DH9AW OLL6ak6yQfpuMy0hHuPS9BheFqwC0KooHSDHVynLRJYiqhn1di6kWlKDDVBdFVlmbumKU6c9qJkS F5vbCX//81XayvV9aINUCzZ6VYvy4xbApfZ86QGTsqLf3B7Lhh29+S4/brjptoBYUITZN2BGACYy 6pCJ22rklFi8jLY+zqPlYOzK0/X75fokpcqTutFCjgptfZ8k6yuobIPldn1t9rsYYkZmQ1te9vxw vZwf0LXFLq4KO6JK95yqkhuH4nS5O8RpTmIzMMPuGGzZY+yHr0nHbZ5Q2XdiLRguEPKntrNvw8rc TN6ud/dy67EnP6/NeGR1rlwH4Ckrxap/xwLsATIgjkhhx7kUJF7sK418VZhy1uBtElbVy4TVJHdV V8wMRaRsIGvD47Ol2AElO7oNrTlMQQfR6di8RmFOOnrOKRjAvj11SmYjQMjaO8rhUPX5V+WatrLc 71IYlUMqdq0l6XPIU9O4HX6BBBtAT/Eszcecr+XxI1LoC6SLwx4SIO0aC2j1nnR+FNuRlAiGhI8j Fm2S4w2E1lAOcujWgIF+I3QbcYApWcXJiAkrwOjOTUDOpKm948oQ05pwbFhdI+ODllEWPIX49JSk btPwJNpXynXvfyp7kua2caXv71e4cvpeVWbiRUnsQw4gCUmIuBkkJdkXluNoEtXEdspLvcn79Q/d IEgsDTnfIeWou4m1AXQDvUyYMx3Q1i7wLFpgQGWKpGudOcFyB8BUcoiyWmhXNYsGuv2cZI4dD/yO EqsKigSny/5EcqGmReFI75/PiHAuHV8Z7c+RfgA8nsIPvwKVHNzLqYZsdUOsAgFy2Sk9nixw+0oz AW97XcLvqoSUNb6XpoUBhyQhXdSGydJvVmwGFvPm1OsFBE0+pcc+aaXptAdxeGgSGQxWzTDGnW75 wmfOkBjiKDesVHQ9enAeoI51S2NZo/ioJRsk+RyCOos53ZZS5NFBmJ8GE48gYBbvC5fA7BZxCj1M h8pAGx468pyuAyIFqoH+rDZW4aavheFilPFibAcATyR3u9AQHQeih5RB0+OsyDn6TukMPqM0XGbg Un7l4+1G8TKVVzW0lm4bTJO9RY4gIunMiEo6kbeiBMvXkrWdJH0+582Y/2kSkDSIPIkRY7y+p0pZ +MmIjG8HiAFHXvSPwgMxElIQKdPWmhvWtdW8mTkHkoY5oHkHUd0cTk27hqpi8O5199VKjWXOrjx+ 1HLrze33nZuFqcF9nBREBmpNnv0hq+Jdts7w+A5ObyV2XHz4cOw1+3OVi0iUlWv1BblOu2xuOmTa Qdetb+iq5t2cte/Klm7XHBe3xdqN+sKBrH0S+D3E7sQooDUk4pmdfaTwogJXO6WlfXqzf3o4P39/ 8cfJG5vHJtKunVM6cNl6s4+AYIkgVG5owyB6DLTa9LR7+fpw9Bc1NkEUfgSsXHtKhIH+2TpHBIJh ZCA4m6DDTyBNuhR5JnnplVhDKCiIRKRDZFjP3lyWTvT/QYsxGlpRuyyGgFeELE0TbOIDdtkt1GpO 7FoGEHbQ4h2ufcs5ZLKYFrWJp7QQC1a2IvW+0n+ms8coquHEjPWIRsdNUH1veeGe8hLC2MSELJYF Z9wA8njHIOce83Hc02mQ6n/ToMO+Y4sRa4tC6DBj9iUJnxMAw+wG5skq3Pv9eT4IP3c+ZCjpOIBv 1OHCR1sES1Y0eAg9cUCu0ISN0myZPERxgMs0QVoVeIsN9skVHp5Bx669wBwaml/TOVE0Fp+MDuG7 JBIddWgWpvgrq/JQIZqolqKKyoI2IcQsjo8DkszZWun3qmvTGKiGeixiIIqT16xMeaYH0R6ikSQ2 SiMBDO4rFE1Lh8jVFAxGmvL3DkuKC41Tl7p2yWHPYBE5KpWs8CQBhGhZzovS4NMUkZ40lx1rluSi XW+9xVaIUm2sNqQqgj1mWcc2gctyOwvIFfBD8MGkRg4VUAeKjsTxy/0NJ2wOVwNmcVmXl5pAscWE 9L/Or2eHvpwtU/vb6QDUBOezaVFHW4xMFW/BgeL9rhlpghw5orcUfbz7VhKasFB7IH6nGU6fX29H 0IY3P/47exMQ6RtEfwQxCkLY6HlM5xrwktkXn1fN2t14vKWgf+uzxIV6BxiXvkRvIKFcN2Ji58ZI cC3qsArIcQXhQ7UolotCtJ9ORkmStxCF3RMlDNLrHfxen3q/HRs3DYncgiDS8UoESLOJ3PBr8p62 g5dV1QJF9EvQj3K+YKnSJUnvFEMEwiSktygbryOU8c1CopOjkgIqK5Qu7rPeT+ipM1B+6LumK2Wd +r/7hRvqaYDG77JSXi/pnTAVrs4Hv1GUbig7C8RCJoGNUljxSs2Mn3OyANWGs1Vfb0CgpeNbIlVX Q/jzOD7GzIgM1sAEpd8QJzw8LtS9H2DdI3ylfVXGYkcPi59KFzU9EWVur6Hc2r4ofRAIjErZK5WS LnAi+Xj20S19wnx0jCkc3DnpgeiRnEYKPrf9ejzMx3iVES8kj4j0C3VJLMMED3MWa9cHd99xcZSF rEfyIVrlRbTgC9LpwiVxI2V4n1Pr1CWZXcTa9XHmYkRTAav155EPTk5tc2cfdeKiWJMK4YJM+Sd+ fwwi1hmDP4t9SFm/2vj3sQ9jo2/wH2MfkkbFdh+jbY0YfTgktBkxkKwqcd5Te+KI7PzVVbAUpGFG a26GIuW5UiAiBWuCsuWdrPx+IU5WSvUgU8yPJFeQP9Y2CTCYBeO5nQNnhEvOVyFYqJYyO53miCg7 0YZg7LpgZVhx28mVsOP9AgLu15wn85x6Ke9KAbxvyW8aoJRfWbBcXKMmNoahtK8hnWdL7Uu7u315 BJunKfjlUCocUfZ0wu9eQnLIBjLyBjeuRi7lshFKUCtb+EKKchF5RRmKpORFfS3PM92GO6tFfbaE vPU6q4ZjCqwf2SDsZYNWJ60UqZtXKP48aVDORSJsLS1Lcg5LI2fDm8aAnSvVGW7k9eO+1Q54tkvx oh6uB5Y8r520mxQakoQtP7159/Rlf//u5Wn3ePfwdffH992Pn7vHUXswV7BTR5nFtnlTKGXj4fbv rw//uX/76+bu5i2kifq5v3/7dPPXTnV1//Xt/v559w3m+o2e+tXu8X734+j7zePXHRr0BSywSNO+ zrsFvGa0skvbXIlWn5w430f7+z342Oz/ezN4SVov7aKFHqer+LUMWQOODyXdksTJleRO/pADZH1M pKK/IXKvUvQQiVIPzDTNGoQvZiu4gdD5r06Oj0MaSIsOeSyIz2VX4mVNJhrgRNtWRI0thPLC3FqG OdxXN0MzV3uZRULev0cm06DjrDL6y/v7iGnptpL6psfqIMOwuu4lvYYVvEjrKx+6raQPqi99iGQi +4DJ+9bWzTVsJJVh2fTx18/nh6Pbh8fd0cPjkV5iVnBGJFZjumC2F5sDPg3hnGUkMCRN8lUq6qW9 I/iY8KOlExbeAoak0s5iMsFIwlHK9z9g0ZawWOtXdR1SK2BYAlyRhKTqkGQLotwB7lh1DKjIFuF+ aNZNb8Ixu1SL+cnpOeQY9hFll9PAsOn4h5h/vBVNiYZDU+INb0QRFrbIO7Auw7NCJ17T72IvX37s b//4e/fr6BYZ+xskBP8V8LNsWFBkFrIUT9OAF3iaORZjI1hmjfO2rM0LX56/g8PA7c3z7usRv8dW qc3g6D/75+9H7Onp4XaPqOzm+SZoZpoWQf2LtCCqT5dK+mCnx3WVX4EnXXw4GV+IRk0yMQ8Gpf7T lKJvGk5eOwzTwi/FmhyIJVPb7DoYigQjAsBB/hR2NElDNponQefTVlKdb8nLFNOeJCg6l5sAVhHV 1dAuH7gllo0SwzaShYu7XJoJOYDCgT6EZ+sttd4ZZJdpOzJ08tD3phFrszaWN0/fY8OvxO+gn0sK uKVmal2wMRBNtv+2e3oOa5Dp2Sm19jVCG1DGO4JUxEajoGqScmrD2m7JU0J9054cZ2Iex8RKXGCB AY9ME+z3bZxAiHr+gVKKzd6czYJyi4wqshBqefG891L6ertbkekFHoJth+kJfPr+A7GsFOKMjM5o doAlOwlKA6Bi6IafUShV0Yj0q1Po9yenGh2vFFPXY0GR8inwezs79QQ+C4HFGTEQkIyTJxVl2mZO sIU8uTglPt3U7/24LwRT9chwvdpzg3WghbT9z+9uzOxpMNReTYhaDbm9N1683xBvmhCKQGWX2ME0 7BbIdBY2gQIqoXczF8QiMojgyt3H65UUrl0GAeXt1HAe4rUPhyNP7bSGMlrSSHkaJ4XrALongAsP A4S6tQcbpSKJhH+3CKwyDq+hjGCbCOys5xmPN2yOfw+1bLVk14x6mzHri+WNkl3CURmEmnCAB0Rs AjBrX7APcFnzso3B8RSOF6hprBkiNrCJ6PTVOWiKsJaWM2J8200FrH9g89EEMY4z6Gi7XYL+bMNo MxCPnOa0fw1pF36CW6UTI2pkKHz7DneS64po2/nsgAiaX4djiC/awRjAq7WRUOTN/deHu6Py5e7L 7tFEqKJayspG9GlNaZCZTBaYfYXGLAtGyToaRydStUnSNtT7ABFU9llAtmgOLmb1FcE6oBH2SkM/ 8O7nETaDPvtbxDKS5MWnA80/3mU8AEU5p6Z/SZq3NVeFviDC609I7OdcfBhk3SX5QNN0iUu2fX98 0accbizBTIcP3ifWXecqbc7BLGoNWCiDovg4WM9Z30+3vogH3RY+p012xKLkkFdWW2SjqRphNaTX FATu+QsVySdMvvW0/3avfUBvv+9u/97ff7N8v9AuoG8hE6m+M5aOKXiIbz69eeNh+baVzB6k4PuA Ql/pzY4vPoyUXP0nY/Lq1cYkOaavadrfoECegf9BqyeL4t8YIlNkIkpolJrgsp1/GiMZfXm8efx1 9Pjw8ry/txUlfZNm37AZSJ/wMlULXq6cyWdoXE9wbyKUNAmJnqzhND6eStAs0/qqn8uq8PKZ2SQ5 LyPYkoNFsrBfrw1qLsoMcp6q0UuEmyGokhmpTugnBZaHhUEqLM8ny6A8MNrRgtFGWtTbdKlNLfTt tE0BlrZzEJsw+XOdC3ctKd2sT1O125HbSHriSP1pH2p4ql1t1zuHv9Yo7SqUMmleiCL7GpKoTYUn V3QAJ4ckktRHkzC5UQuG7o/CJ8JtrH9yp9HCKfMDJfGNGvhEaamIo7Y8meuwMquKyJAMNGB3CVt3 7mwO11q+9KC0tR5AM07BKfO9wG7PoqZKiRjoIZii314D2P89XDC6MPR0rkNawWwtYwAyWdhDO0Hb ZVfQlqsDTaPOFTJYtEYn6eegsuGBcwBO3ewXjq2ZhUgU4pTE5NcFIxHb6wh9FYHPwp0CH2rAIcna VJXg3jdVXjlhk20ovISe0x9AhRYqSZfODzQzbDHcvW0xt2VSsiu979hiRFOlAvMo9UgwoWCrUpuc 7ZmtQWA73DubH8AzewRLbC4mlOjVLr6wfZ0RBwhVBL6K+t4IgGNZJvtWydzO/tBsRNXmjn05EivZ K+aT1yxyPQHWjoD+bqOPljWRl/YRkFeJ+8t+Vjd9yQdHXFN0fg0PxxNAyEu4HrPKLWrhBBysIBk8 XEi30hl8NSGGgdZZU4VsteAtPBBW88yetXkFKp6fSxOh5//Y5weCwH1L9Yqn9iBDeIMq9yYFprgG v3znfWxEddrnuZ/nXbM0vrUxoiKFBNAeAb58bljuv6VmvK7s1imG0Lw3SZctSFGRI20MXeNJPO4z uBErEfrzcX///LeOBHO3eyIex1GagrTSheNCPIDBeI9+odL2v0o0WORKNMrHd7iPUYrLTvD202xk nkEKD0qYWdYVYH86NCXjeUTJza5KBqlY44780WEYVd/9j90fz/u7Qep8QtJbDX8MB02bQA4KUABT ayDrUu7kdLewjRKVaGHFIso2TM5pecGiSto5bQeQJeDyLGrylYWX+JpYdHDlBRuItZLURsu1//Pp 8ezcZcxabbEQzKKIuAsolRELVlRErbrZjm8Xh1gvkABZrQ57XzEIr3HgplMoZUV9kIvS0TZ04Y32 2QW3rYK1qSMb+TjsJDiBk5Y0aO4xRDrwvICHflQQDUPb6EIeq7ojGe+3WWtcFWwh0MtPWnqLBRwt IPQkfjr+54Si0qFu/PHRRtg+FJzcPrnWMNnuy8u3b456ioZESnmEpA72jZUuA7DmaPJGakQZvjvg gAB1VJvSUdlRU69EU7kz7sL7sho83qMU11wGqxVJHM1Gw2Wl5p1pscxDVQl4hjdhPwfEYXXEJQWT lt8gwyiE1EJ2ycDDIN4smXa4rl4tRrGz4uYxggjdfW8uJ08HPOwHblNH7GBQ5LXJYKJt0euvaxz3 TY1aF2F56wLfM31jPp9GJmFhfb1QSs/CtuoxR/xAImTbhUspAta58NBmyVq+GohO7kpJ7rmUGNkS RtIKdcZQblWVr5hiZUsQS7E5CB2TWY9YDcYBU7PgW0JNCzno3sqxMAp/4bYsuwKvx/M8HPVmCVG5 /DsvrPEIAva//NR73fLm/psdqrFKV12tymhV921FoqnmbYh0ZAFUBGzCWq15Mm9dlBh29Y5PnqmQ YnnAa2EaVpsazsKRyywq07bIwgVkv+zUhtOyhuLwzaU6etQBlFXa9WIMz0OPm30/Bc0Hd9WqJj3c bLzfTY1EIbtrJ3Cj+pz5XlMa6Eo3CEO3FudQRUq9WnmZ6RGMLkGofcV5rfdxfXsH9iUjkx7939PP /T3YnDy9Pbp7ed79s1P/2T3f/vnnn/92OUgXuUBhedQQLOm1Wo/RMsiJwjKgP9HWgmLYtXzLib3e ZEuOfhz9crPRuL7Jqw1YzMbr3zSex7mGY8vxQI1+CmnYQRTI1WDTBcC44dvBcFhR/IQVKUYHxbIf TbANF4/9OKiq/D+m11SLnoKgbHr7MnKZjj5mdQmlODUafVfCC6LiRn0JduBYXekzLDp66t9gMUuM nSAv1QZpAm+3Q2ahdHmNMkdC458jqVIhwB2Z5WPcOHWAU3JZbILgvFdH+TxmqQd471sbM4yzBeKX tsOYCf7pNCpg9stBTpaEhOyOOTKbEi8hvh7VXPLwFPaNU11ET9jJ2YK3EL+PpCMqnXelVhr8Sp3g NU68IGodMSU0p1dtZd0y4TvbxNHhLUeJkaMVyjogUUIY23QYu5CsXtI0Rl2ee5NMIPuNaJdwpdP4 9Wh0gVIiWivLzCOBSCWwMJFSieFlGxQCr6D+RVE6lKaLnpC6KxBk1WdO3ZTUzTuP1yh+MmC+BmEG 6B1VQv1pgfUa1ds0HDSrqMF1E5xpLT1DSfGFUk2V2kX2NajP3Hr5FQ2ExJWX1+MoD7wy/VZLcSjs GPXyUklK8+kT74zXcHIFLzeKww8RDMwyMAR11AyT25SsbpZVOOsGYXRtbwZ0+Yna+dX0qbN/DmkZ HcdWBxfG15jEBkSzsoRY8pBOGr/j4WwSmKEOf9C1dBSOa5KvMJgoFZBs8lZSTUr4MFskRRejMPvr sKD9CY/tAq9vACOTDcMlfUYNtoWAE1qmDp46djQVhaiINQ6j7l7Vw7PyEEPfEZTGAmI1TOvUeQom Fjz5UmwTxPpiyaLjosMrzINtUtPEcnxNgJG161yASmYYNB5OQQm+IuN9tUzFydnFDN8UBm10av7g jgMNwUHlJX02K8U12i28DCh7vCdR0wyZEITvlWNWAINkd2RkoknnXWTOWwj8puxIxvv3BNVeuPKB G0Hn+hBxdmEhMb2UkKwEHxmxKEHxpdwWkWiksFgUrEZ01XdBc9VChwcHMTj/u3fD2slvoIlyhpGI w+MBLLoGiRUV384R+jmT+WA0sSK7DZ/XLfjzHxDQNlsaWXVJfiACyaD45Qk+psQ4YFqvhC4HzYNn yQwW26G7NUhPiQvseBvJXWtRcDogz0jRBc8NPgWcIb7Yrt8rzGvl9MJfswOxJfSnKAsdwJeFONx9 PU54N11TcZDrDhzpQDX09f2u3AgItt0rWd1ZNgauXwVwv/SPeN+zTr8+/Q9HOyL+79UBAA== --===============2571248987821199820==--