diff --git a/.gitignore b/.gitignore index 15b75ab..21d89b6 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,4 @@ client/test.cfg .VSCodeCouter/ meowlib-sources.jar meowlib.aar +client/test.db \ No newline at end of file diff --git a/README.md b/README.md index 420699f..08b2e3a 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ run the shell scripts # Design notes Config is written as a json file Identity is stored as an encrypted json file -Prefered servers (messaging and my contact's messaging) are stored in an encrypted badger db with server url as key -Received servers are stored in a sqlite db for extensive searches, with storage limits +Message servers (messaging and my contact's messaging) are stored in an encrypted badger db with server url as key +Received servers are stored in a sqlite db for selective searches, with storage limits Messages are stored in several badger? or sqlite? db per user with send/receive time as key diff --git a/client/identity.go b/client/identity.go index 8afb032..e3e7b81 100644 --- a/client/identity.go +++ b/client/identity.go @@ -21,11 +21,10 @@ type Identity struct { RootKp meowlib.KeyPair `json:"id_kp,omitempty"` Status string `json:"status,omitempty"` Peers PeerList `json:"peers,omitempty"` - Devices PeerList `json:"devices,omitempty"` HiddenPeers [][]byte `json:"hidden_peers,omitempty"` Device meowlib.KeyPair `json:"device,omitempty"` KnownServers ServerList `json:"known_servers,omitempty"` - MessageServers ServerList `json:"message_servers,omitempty"` + MessageServers ServerStorage `json:"message_servers,omitempty"` DefaultDbPassword string `json:"default_db_password,omitempty"` DbPasswordStore bool `json:"db_password_store,omitempty"` OwnedDevices PeerList `json:"owned_devices,omitempty"` @@ -40,30 +39,36 @@ func CreateIdentity(nickname string) *Identity { id.Nickname = nickname id.RootKp = meowlib.NewKeyPair() GetConfig().me = &id + id.MessageServers = ServerStorage{DbFile: uuid.NewString()} id.generateRandomHiddenStuff() return &id } -// Creates an invitation for a peer, returns the peer containing -func (id *Identity) InvitePeer(MyName string, ContactName string, MessageServerIdxs []int, InvitationMessage string) (*Peer, error) { +// Creates an invitation for a peer, returns the newly created peer including infos to provide a ContactCard +func (id *Identity) InvitePeer(MyName string, ContactName string, MessageServerUids []string, InvitationMessage string) (*Peer, error) { var peer Peer peer.MyIdentity = meowlib.NewKeyPair() peer.MyEncryptionKp = meowlib.NewKeyPair() peer.MyLookupKp = meowlib.NewKeyPair() peer.Name = ContactName peer.InvitationId = uuid.New().String() // todo as param to identify then update url - if id.MessageServers.Servers == nil { - return nil, errors.New("no message servers defined in your identity") - } - for _, i := range MessageServerIdxs { - if i > len(id.MessageServers.Servers)-1 { - return nil, errors.New("requested server out of range of defined message servers") + /* if id.MessageServers.Servers == nil { + return nil, errors.New("no message servers defined in your identity") } + for _, i := range MessageServerIdxs { + if i > len(id.MessageServers.Servers)-1 { + return nil, errors.New("requested server out of range of defined message servers") + } + } + for _, i := range MessageServerIdxs { + srv := id.MessageServers.Servers[i].GetServerCard() + peer.MyContact.PullServers = append(peer.MyContact.PullServers, srv) + }*/ + pullServers, err := id.MessageServers.LoadServerCardsFromUids(MessageServerUids) + if err != nil { + return nil, err } - for _, i := range MessageServerIdxs { - srv := id.MessageServers.Servers[i].GetServerCard() - peer.MyContact.PullServers = append(peer.MyContact.PullServers, srv) - } + peer.MyContact.PullServers = pullServers peer.MyContact.Name = MyName peer.MyContact.ContactPublicKey = peer.MyIdentity.Public peer.MyContact.EncryptionPublicKey = peer.MyEncryptionKp.Public @@ -75,6 +80,7 @@ func (id *Identity) InvitePeer(MyName string, ContactName string, MessageServerI return &peer, nil } +// Checks if the received contact card is an answer to an invitation, returns true if it is, and the proposed and received nicknames func (id *Identity) CheckInvitation(ReceivedContact *meowlib.ContactCard) (isAnswer bool, proposedNick string, receivedNick string) { for _, p := range id.Peers { if p.InvitationId == ReceivedContact.InvitationId { @@ -84,7 +90,8 @@ func (id *Identity) CheckInvitation(ReceivedContact *meowlib.ContactCard) (isAns return false, "", ReceivedContact.Name } -func (id *Identity) AnswerInvitation(MyName string, ContactName string, MessageServerIdxs []int, ReceivedContact *meowlib.ContactCard) *Peer { +// Answers an invitation, returns the newly created peer including infos to provide a ContactCard +func (id *Identity) AnswerInvitation(MyName string, ContactName string, MessageServerIdxs []string, ReceivedContact *meowlib.ContactCard) *Peer { var peer Peer //var myContactCard meowlib.ContactCard peer.MyIdentity = meowlib.NewKeyPair() @@ -96,9 +103,13 @@ func (id *Identity) AnswerInvitation(MyName string, ContactName string, MessageS peer.Name = ReceivedContact.Name } peer.Contact = *ReceivedContact - for _, i := range MessageServerIdxs { + /* for _, i := range MessageServerIdxs { srv := id.MessageServers.Servers[i].GetServerCard() peer.MyContact.PullServers = append(peer.MyContact.PullServers, srv) + }*/ + srvCards, err := GetConfig().GetIdentity().MessageServers.LoadServerCardsFromUids(MessageServerIdxs) + if err != nil { + peer.MyContact.PullServers = srvCards } peer.MyContact.Name = MyName peer.MyContact.ContactPublicKey = peer.MyIdentity.Public @@ -111,6 +122,7 @@ func (id *Identity) AnswerInvitation(MyName string, ContactName string, MessageS return &peer } +// Finalizes an invitation, returns nil if successful func (id *Identity) FinalizeInvitation(ReceivedContact *meowlib.ContactCard) error { for i, p := range id.Peers { if p.InvitationId == ReceivedContact.InvitationId { @@ -121,6 +133,7 @@ func (id *Identity) FinalizeInvitation(ReceivedContact *meowlib.ContactCard) err return errors.New("no matching contact found for invitationId " + ReceivedContact.InvitationId) } +// LoadIdentity loads an identity from an encrypted file func LoadIdentity(filename string, password string) (*Identity, error) { var id Identity GetConfig().memoryPassword = password @@ -134,6 +147,9 @@ func LoadIdentity(filename string, password string) (*Identity, error) { return nil, err } err = json.Unmarshal([]byte(pass), &id) + if err != nil { + return nil, err + } GetConfig().me = &id return &id, err } @@ -215,7 +231,7 @@ type BackgroundJob struct { } type RequestsJob struct { - Server Server `json:"server,omitempty"` + Server *Server `json:"server,omitempty"` LookupKeys []meowlib.KeyPair `json:"lookup_keys,omitempty"` } @@ -223,30 +239,33 @@ func (id *Identity) GetRequestJobs() []*RequestsJob { var list []*RequestsJob srvs := map[string]*RequestsJob{} // build a server map - for _, server := range id.MessageServers.Servers { - var rj RequestsJob - rj.Server = server - srvs[server.GetServerCard().GetUid()] = &rj - } - // add ids to the map - for _, peer := range id.Peers { - for _, server := range peer.MyPullServers { - srvs[server.GetUid()].LookupKeys = append(srvs[server.GetUid()].LookupKeys, peer.MyLookupKp) + servers, err := id.MessageServers.LoadAllServers() + if err != nil { + for _, server := range servers { + var rj RequestsJob + rj.Server = server + srvs[server.GetServerCard().GetUid()] = &rj } - } - // add hidden peers - for _, peer := range id.unlockedHiddenPeers { - for _, server := range peer.MyPullServers { - srvs[server.GetUid()].LookupKeys = append(srvs[server.GetUid()].LookupKeys, peer.MyLookupKp) + // add ids to the map + for _, peer := range id.Peers { + for _, server := range peer.MyPullServers { + srvs[server].LookupKeys = append(srvs[server].LookupKeys, peer.MyLookupKp) + } } - } - // todo add garbage + // add hidden peers + for _, peer := range id.unlockedHiddenPeers { + for _, server := range peer.MyPullServers { + srvs[server].LookupKeys = append(srvs[server].LookupKeys, peer.MyLookupKp) + } + } + // todo add garbage - // todo random reorder + // todo random reorder - // build list - for _, value := range srvs { - list = append(list, value) + // build list + for _, value := range srvs { + list = append(list, value) + } } return list } diff --git a/client/peer.go b/client/peer.go index cc612ca..201c9f2 100644 --- a/client/peer.go +++ b/client/peer.go @@ -21,11 +21,11 @@ type Peer struct { MyAvatar string `json:"my_avatar,omitempty"` // Conversation []InternalMessage `json:"conversation,omitempty"` // My own keys for that peer - MyIdentity meowlib.KeyPair `json:"my_identity,omitempty"` - MyEncryptionKp meowlib.KeyPair `json:"my_encryption_kp,omitempty"` - MyLookupKp meowlib.KeyPair `json:"my_lookup_kp,omitempty"` - MyPullServers []*meowlib.ServerCard `json:"my_pull_servers,omitempty"` - MyContact meowlib.ContactCard `json:"my_contact,omitempty"` // todo : remove + MyIdentity meowlib.KeyPair `json:"my_identity,omitempty"` + MyEncryptionKp meowlib.KeyPair `json:"my_encryption_kp,omitempty"` + MyLookupKp meowlib.KeyPair `json:"my_lookup_kp,omitempty"` + MyPullServers []string `json:"my_pull_servers,omitempty"` + MyContact meowlib.ContactCard `json:"my_contact,omitempty"` // todo : remove // Peer keys and infos Contact meowlib.ContactCard `json:"contact,omitempty"` // todo : remove ContactPublicKey string `json:"contact_public_key,omitempty"` @@ -59,7 +59,7 @@ func (p *Peer) GetMyContact() *meowlib.ContactCard { c.ContactPublicKey = p.MyIdentity.Public c.LookupPublicKey = p.MyLookupKp.Public c.EncryptionPublicKey = p.MyEncryptionKp.Public - c.PullServers = p.MyPullServers + // c.PullServers = p.MyPullServers c.InvitationId = p.InvitationId c.InvitationMessage = p.InvitationMessage c.Name = p.MyName @@ -67,12 +67,14 @@ func (p *Peer) GetMyContact() *meowlib.ContactCard { } func (p *Peer) GetContact() *meowlib.ContactCard { - var c meowlib.ContactCard c.ContactPublicKey = p.ContactPublicKey c.LookupPublicKey = p.ContactLookupKey c.EncryptionPublicKey = p.ContactEncryption - // c.PullServers = meowlib.LoadServerCardsFromUids(p.ContactPullServers) + srvCards, err := GetConfig().GetIdentity().MessageServers.LoadServerCardsFromUids(p.ContactPullServers) + if err != nil { + c.PullServers = srvCards + } c.InvitationId = p.InvitationId c.InvitationMessage = p.InvitationMessage c.Name = p.Name diff --git a/client/server.go b/client/server.go index e247f3a..bee5d5d 100644 --- a/client/server.go +++ b/client/server.go @@ -53,6 +53,13 @@ func (ints *Server) GetServerCard() *meowlib.ServerCard { return &sc } +func (sc *Server) GetUid() string { + if len(sc.Login) > 0 || len(sc.Password) > 0 { + return sc.Login + ":" + sc.Password + "@" + sc.Url + } + return sc.Url +} + // Create a server from a server card func CreateServerFromServerCard(server *meowlib.ServerCard) *Server { var is Server diff --git a/client/serverstorage.go b/client/serverstorage.go new file mode 100644 index 0000000..f84f85b --- /dev/null +++ b/client/serverstorage.go @@ -0,0 +1,200 @@ +package client + +// +// Storage +// +import ( + "crypto/sha256" + "encoding/json" + + "forge.redroom.link/yves/meowlib" + "github.com/dgraph-io/badger" +) + +type ServerStorage struct { + DbFile string `json:"db_file,omitempty"` + db *badger.DB +} + +// Open a badger database from struct ServerStorage +func (ss *ServerStorage) open() error { + opts := badger.DefaultOptions(ss.DbFile) + opts.Logger = nil + var err error + ss.db, err = badger.Open(opts) + if err != nil { + return err + } + return nil +} + +// Store function StoreServer stores a server in a badger database with Server.GetUid() as key +func (ss *ServerStorage) StoreServer(sc *Server) error { + err := ss.open() + if err != nil { + return err + } + defer ss.close() + // first marshal the Server to bytes with protobuf + jsonsrv, err := json.Marshal(sc) + if err != nil { + return err + } + data, err := meowlib.SymEncrypt(GetConfig().memoryPassword, jsonsrv) + if err != nil { + return err + } + shakey := sha256.Sum256([]byte(sc.GetServerCard().GetUid())) + key := shakey[:] + // then store it in the database + return ss.db.Update(func(txn *badger.Txn) error { + return txn.Set(key, data) + }) + +} + +// LoadServer function loads a Server from a badger database with Server.GetUid() as key +func (ss *ServerStorage) LoadServer(uid string) (*Server, error) { + var sc Server + err := ss.open() + if err != nil { + return nil, err + } + defer ss.close() + shakey := sha256.Sum256([]byte(uid)) + key := shakey[:] + err = ss.db.View(func(txn *badger.Txn) error { + item, err := txn.Get(key) + if err != nil { + return err + } + return item.Value(func(val []byte) error { + jsonsrv, err := meowlib.SymDecrypt(GetConfig().memoryPassword, val) + if err != nil { + return err + } + return json.Unmarshal(jsonsrv, &sc) + }) + }) + return &sc, err +} + +// DeleteServer function deletes a Server from a badger database with Server.GetUid() as key +func (ss *ServerStorage) DeleteServer(uid string) error { + err := ss.open() + if err != nil { + return err + } + defer ss.close() + shakey := sha256.Sum256([]byte(uid)) + key := shakey[:] + return ss.db.Update(func(txn *badger.Txn) error { + return txn.Delete(key) + }) +} + +// LoadAllServers function loads all Servers from a badger database +func (ss *ServerStorage) LoadAllServers() ([]*Server, error) { + var scs []*Server + err := ss.open() + if err != nil { + return nil, err + } + defer ss.close() + err = ss.db.View(func(txn *badger.Txn) error { + opts := badger.DefaultIteratorOptions + opts.PrefetchSize = 10 + it := txn.NewIterator(opts) + defer it.Close() + for it.Rewind(); it.Valid(); it.Next() { + item := it.Item() + var sc Server + err := item.Value(func(val []byte) error { + jsonsrv, err := meowlib.SymDecrypt(GetConfig().memoryPassword, val) + if err != nil { + return err + } + return json.Unmarshal(jsonsrv, &sc) + }) + if err != nil { + return err + } + scs = append(scs, &sc) + } + return nil + }) + return scs, err +} + +// LoadServersFromUids function loads Servers with id in []Uid parameter from a badger database +func (ss *ServerStorage) LoadServersFromUids(uids []string) ([]*Server, error) { + var scs []*Server + err := ss.open() + if err != nil { + return nil, err + } + defer ss.close() + err = ss.db.View(func(txn *badger.Txn) error { + for _, uid := range uids { + shakey := sha256.Sum256([]byte(uid)) + key := shakey[:] + item, err := txn.Get(key) + if err != nil { + return err + } + var sc Server + err = item.Value(func(val []byte) error { + jsonsrv, err := meowlib.SymDecrypt(GetConfig().memoryPassword, val) + if err != nil { + return err + } + return json.Unmarshal(jsonsrv, &sc) + }) + if err != nil { + return err + } + scs = append(scs, &sc) + } + return nil + }) + return scs, err +} + +// LoadServersFromUids function loads Servers with id in []Uid parameter from a badger database +func (ss *ServerStorage) LoadServerCardsFromUids(uids []string) ([]*meowlib.ServerCard, error) { + var scs []*meowlib.ServerCard + err := ss.open() + if err != nil { + return nil, err + } + defer ss.close() + err = ss.db.View(func(txn *badger.Txn) error { + for _, uid := range uids { + shakey := sha256.Sum256([]byte(uid)) + key := shakey[:] + item, err := txn.Get(key) + if err != nil { + return err + } + var sc Server + err = item.Value(func(val []byte) error { + jsonsrv, err := meowlib.SymDecrypt(GetConfig().memoryPassword, val) + if err != nil { + return err + } + return json.Unmarshal(jsonsrv, &sc) + }) + if err != nil { + return err + } + scs = append(scs, sc.GetServerCard()) + } + return nil + }) + return scs, err +} + +// close a badger database +func (ss *ServerStorage) close() { + ss.db.Close() +} diff --git a/client/serverstorage_test.go b/client/serverstorage_test.go new file mode 100644 index 0000000..739103d --- /dev/null +++ b/client/serverstorage_test.go @@ -0,0 +1,33 @@ +package client + +import ( + "log" + "testing" + + "forge.redroom.link/yves/meowlib" +) + +func TestStoreServer(t *testing.T) { + GetConfig().SetMemPass("test") + ss := ServerStorage{DbFile: "test.db"} + srv := Server{ + Name: "test", + Url: "http://127.0.0.1", + PublicKey: meowlib.NewKeyPair().Public, + } + err := ss.StoreServer(&srv) + if err != nil { + log.Fatal(err) + } + sout, err := ss.LoadServer(srv.GetServerCard().GetUid()) + if err != nil { + log.Fatal(err) + } + if sout == nil { + log.Fatal("server not found") + } + if sout.Name != srv.Name { + log.Fatal("name not found") + } + +} diff --git a/client/test.id b/client/test.id new file mode 100644 index 0000000..a321e10 --- /dev/null +++ b/client/test.id @@ -0,0 +1,1064 @@ +-----BEGIN PGP MESSAGE----- +Version: GopenPGP 2.7.4 +Comment: https://gopenpgp.org + +wy4ECQMIzFXf1C69NhPgHAuURpMPkk0zJCbzzE0UQJzpribpU6aT47f70IlDsvWm +0u8BhQd3kjTi0QFASv+EUymL8P4I7UIEuaAyy1n4Y/DfzmaGhAhUPb7Rv9GLlaUf +LEYxtj0m87zfc3OJ7kSegw/q0wkyVFGXBGNg29ysGh+gB5XFzj+7rp5xUIgrZgUP +DLVBbGuOkv6z14c4dkdEGOmIcWXRkJS605M0GNRm+8Rt+5nOAahwMzWTlgDNKZRk +0GdIhquuJnyL8LnYa6VIRXWRzUrRDOgzKoafLfdF1cbc+A5VF5KltSL54vzWSjvD +EbMflI72PXUAITR1Gmo1DsTH/FPzhdhmsy3bjUdOTVUBvzfey7572jnqzVM7PEcQ +szNK6PeFEFdRIyhXrucoGHrNgVTpYiWb/aUKp9WgMttexSPOgk9b2dqGQXtEblZD +0099rCuoeBiPn2Q83mqpnV4aqiDyVj74aJJIfawE6bJ447XjkMb3LhYe3qEQZtmW ++dU0oOvRRhTSvk5PKPGrJLgr5uIR8wUAOGlsI8d0YQy2qgjk36gDrBza9WnYqunD +8yHLduA/sMWuqOx1LuCfzEJorsX86IDovNY+HpfSQiHRWaWUMUpBkz5UndSfCMNq +pflNAVkyOUjnvV3NwGOVdb+CPjhpwoQ5YTPPLpSYSJPNGHloYX20pQky8woIRDav +2cZRJ6hYrIzf4fkNMlMdOcoDkGj2EIvgixliYMyqwBwp85RgvK26cVEOUw0UL5V2 +l2WvnCR0Xzssj2Y64MKoSgB4TRrxkFym/snHB4uyw0Iq/HmBvSSFMYGK/Mj1FoiY +Nv8GGmiND+VFGpmr7+xid9ONtf3X+NYiy6AQbBvZ/8rE6kMfG2RFzXk3i6E1ejta +LVOGwbRe8Teno2RA+AtPLxZbFjwHh/XEEoG2RuV4fCXT11ax5Vl9PGKJWWZTXTMy +uC92jI5iFugv3FAHUQIdEH9Hyr5Gq/h1guu2vBHC+j9IsCXvFFkIPmeXSSspn8s/ +sRKNSoLyjMB8SgR6eBvXdp3Hj1lqSGiETkzR4GCkMw9w5Qfx9tkZUwEUtYrIQUco +9JytEWK+M6OQ593nTMumlU0qFvnF1vHJcVnNuS8Rp1gmGHIREQyfqIx8+74R8pXb +wdE+Z57B5o9TQPkFmPLq7Qon3Ul5bR0n2KN7o5pgaPn7gLiJLr+cTqF9g2GOUL2k +rPzqxsrJR/w+nwGxNEzoV5dAfwI3hacSsrcRk7RFW/wzVRmxfBwabEJgrD6wwqXH +H/krYNKAaCARK3ZPkXWPoWx8dFQkTd+A9xIP05aHaau6NmRVIlqnZ+DJGh+46la8 +1dawJf2EO+mYoXP93Xt7pSIBy7LXhsplQAJWQPezu1Q1BaXGPOqkTLgqJF3E3mA9 +Icr1jntHAguwCKIUWap/7kNd7HnCIFjS6cO0XkuXE2TrF10KvaPnVbTpS++8PW9e +pUupEslz4bLqWjm/EfIKh9OJUWPWLe/VSq87gnBuTtiACDMlmcPNi8o1qG1XzCIx +DkuFDD+4p2a0uXjoSZEp3ijqgHoascefQjgV/tLFrJQAN3m7xBYNIJgXG8g63x5s +HKai9sU6ttKqsiFZCxwGUBeBQuTagtAiuKhork6Up9gDfJvSzVSCqrdJ/bKOHLuq +WFULugsG3CK90XHtGAlZR1gGL/cu4t+SgE1qe83EjHTb015TmJRlJRs/0Vg8xIvo +0Hn9si1bCwf7SD8L+PfXJMC/36lsD1fuw6IPoahxZVNQaZy3WVHGj+/kqVFCng83 +ENcQIZKxVbk5u4ah5aDNIPX2WrBeQxeRhTaY5oabkHP7798Iswd+pyqJfdgPrsb6 +dlAvb6o9VVqgEoPX83XAVN7JM9/An+DW7CU1fe9eHdBar2lGgSmCPvlYJTJ+RApV +eMZLBvD8n0SPu+tV2gPbzU2Tle9/2TEDRWe2q1tiK1ZvpQWfipr2TZx1l6s3KKcJ +RH5o3kLBhliOiE860ty2/z/mSjwMqcvuiLWzjIVoydwGD3NBrTMg5r1S8gI8UA2f +GrSp4G+CqGWvSzuMLw8eNN83w2iBmfDKcQimThScf56iZ7my6q69d5G7WKjeeN4X +KZZ1PTBTcFUtJtQ9oCyvozS6aBVrfQKAin3gd/jpvem64JptUKio7PlyWhNur05Z +zIZvH2NfOEdttkaTtoV9tQialluBpTkW21uQa38YRhag32KceCA3+niL8yYFckL1 +gV8PfPV7YGeGjCpakHA8eupjCjSiWA80pCDzQ8O8JOEtXWXH491PB9ftCx+kirv2 +mpfxtshy8iKLSEyCCDpvWLw3j2kvQ4H5/EpCj8ReyGnebz0qAYEIda60fAFs1NfU +VUVyrLVGyzMIP+bMiwXjHxXYqK2Rw83w5n2v1p8/VnvOmA9FSpzSvXvO42JEIhNB +HGTbya5fxxknVwTJeZnANnxPY7Kvpyg/vh88bgty/vZl5xYIoFfFYATySpuCHJaL +DwYrACjG9EyOIBopK5J7/L1MaWPkxIunxCdXBvcssDZZ87hR8IBn91gjj7LxWj0I +COvMCU8y2OsXuY42kT0S3mfPsysL654B5kCmZmLIyUQ1VxavRsB9J4tW3gX96550 +/Pdc9seOTnHyBASZTSfWNrwJXx63ex9ZyFenDWhpu/mReSlE9ztn7XtE+ixrC80l +O+vK/gOsQXOybMPbD80tYcUqaQdX+BIhVxhoKoa3FMZf+g+UKXh2g5dwT825lYeT +h5mg0gzpIoIjn5hum7J8smdcaAS1XQXecSQTVC1gzrJ3wtL1yzC6mOZtcYE51Fww +uR6Z+YxPpvW74N1WWl6wKC8TpyBZvzVAo+Gsirvcq/0tUgvckGzcQICuh1TBdT6c +mDrm+5QijYokL3su4dcLXR8tMslJaH+GvaVw4v7w0wTJQ5dzZxOOA5vccjw/xD+O +OCNdR3j+Ii70FzmndehQlWdLNUSDDJwozNKsnhE7sk5hXrXJsebqN7KrPBliOapi +nk3b90fmEYAO6R5jkdVpUd3VggOjfG5OAxVYA7mZ6L78EMUkS4ibdjkl5UhnNiAT +O9k5KS98XIJg+IEuXesWrU3mrmEyjYFt2IKS2BmTc/eSc3zsOSkCS40uLg1H0Bdj +G/0rlN7rXkEIcAiQN3Ic1Z85TLZAy8r01fqHJnGUbl9mk0XV6wqayEzf/EJSYG2+ +S/8j0GkJmVlxm+RWCkhoe9FhYKShiiPm6RkTkBsMCXhRMkQlAm1OCU9xjKP4zoyt +OFMVtQdKs5Rj1f+o9QR54zF015N/kJeHdGJfUoKNOtKhBx+bzFjKlkSxTV3DXc/Y +XkYjdsnEZO6ujlVyP3PosvQi2qcuAp9aVYlwln7jT/OK+OAflBAhgstiJ3U6BTVR +IugLFQlTiJPsvdN1mv31IvziGH3b9K6Hmn2rRecaQOa5tHx0htglnqqVJztioh6x +8DXtiGoDcVKafBOskMVd1xA/hgMRJjZZjmx/B7U7u7bnZJc/5MGdGDxujDSBolPh +l55Hbn4zbMxI8aK1c4idIZxYlky2RC/0862QrUiEiDpAEJQ93xnx1j78Szx6YamW +hnECo+8Df9Kb2nn3WhnhspMzILQWR/AVu4RlmWoRwt0VqhA7gjrhgWz9OfnlCHNV +CHWV6vwsdPzyV6kEpWHePuQIaxA0jxluOaLDlzE67e3w4VInc/UukII/Jo+9sS62 +GkdT+ePDU2qK21GnZuznFIrydqUxF0jeIFDgFGTSYYx2jzkZeUuZMaw8iuaFYGUJ +cK1exlaqiD+jp6CBgOhy/oqrBmBXljYseP/oWSIl5gtWyidZ7+WW3ipGtvocFCzn +Teq+Lu3eYqI1koJjVxd6571TYIVcGCiBceerLb0W8xncdu3fTevHRIyh/pYnrApS +1GVx/wpY5EnR5b98r/AiP2PyummpU2/Fja2xCDMWzOt5wYOPQPsceYZ+xevVS5nN +SlhZ/0Eq6oPu0VGm0mUTYkuM9jun4CU70fmTcthPPVM2wOAWsHbWU1ClgYf8uNSV +4z6O6XX77/DMvI+VGOaop8+dXvbpc4i34Dcc1VHPt3X2kO/erhnTEgWwEoVeEvI0 +AanoG9NDcVDHELW2V8qHA5PX1GQtxYjmPCJ6coNZeg65dqHmehAAzHhx/2DEsh80 +Ff5cQ/w2ijHHz9XQlJbBw8f3vYlk/GXNFl1K1gR/zzfdQyb8WXUF1D7rcx08dSi9 +chnqQWSLEHEZOL1d2fD3K6OSc+uK/MtOQBdqvr7/lYFLlGFsvY01KWf39iaIcoc4 +jSDmQkgDkTUl8w5dOcQBAjORvT6zKyBb4cf9WxAnbcYQZ1NfwE1ddof9C923rZ7t +R64dyNlx7dc+EikoUxsZxQOUHyDKJRez3vppkoWTbOAI/JSNpyTRD6cMwGekYKG6 +I65U/LHjEG0CMQaTTn5X/h+OsrKsv7nv4wtzBT1+/bn03B5Tx0k80ISkrBV/hgXC +9T9NkIgVTdGP5mU7o7k4yMp04PdSPVBaaHOvvRxaysDpVbX2Ft8ztgT6bewI15Im +cVvoSoXCLAmZE1CSgJIbVAvrBALlct/uvsg5f9zI58jKE+xQGjKNPgkBiAVVk5wy +ChrC8lvm8BbZEUuLlsgHmZBfTUJ/+2Dlr5gz0pV2Zkazak164tz7iyBSs2oUu6PO +Sb5TAzZWRcVCSmgLSPU4QI1Ybrkc5u+HtxptjSN0J+g8FhJbn8Wc/pQ8F9s0YZLm +TCwomsPyv2CxXpkjhrZpCL9hbV7x+j8yjRuVAkx7dd8bqGB12eEt2OTzsDs3FwpE +rZEDX7zhGt56/iVUK4vRf6OvjucAD8ypODo4eNh63kAExdaArevXNbXWnxNXkh0l +ZVdfrvhhPP98CwvxOD7xdxIU36K5xyGonQNTjkadOTwDqoGzdUU1rwpsMzmwqb43 +pyMiE1q7ye7886jcWCUwwBGSVVGDC7B7jgQoZWYmdtPzNSCxQYWwwHnEeLit0xOP +2YRtNZtMg1WOpBaOwAYwyBkPXABfS2/c03miie3ACj3T3YXIJ32wM2//Xv6JZ3hu +BTjRDLp0gLrenLTxz8jksFU2W/I96Jq2u3Sw41HJM80yBmns0cURi0RdjxuBlxVO +NK6qLGN1f+FIsfQsDj4n+8ks/8pqy+tlYyi3NHVe7MShopSlXgIWHKQPW2yD7bB/ +S84lVYI4fULtmDRMQV/3bdl9fBsd5eu3wwm2bVgYyb1hAZO1Uf6klKvhHaGpIZMl +w2m3yj9yoOr82P5UluhHgpmT8l+vcZH001WBn81vesipdyOejboS/CkY5sMEAsW3 +J++JMG/1TYJSCfPutwCz/6PTxYKCjCTwB4N1LgSSg58p59/G5j95+QHBffE+ONM1 +Nmdms+D7VEA3aUkR2UKJsV+ySw+15Ueunvd8+X0lBgecGVPBpvT/bFdEODOPvNLs +4iyAnzkIAsi0ROMSEKLeUB430zAUTH/XnG9WgEdznb+Px579tzVzp2gJXwKN8dJR +6esdqgw4xx5CSYqcQ4SrVXPVo6WygU2SM9ZRsEBqEUxgvtc0Vzzmbx8zG2Q6vjRO +zBfeObrEZ0A9oEpUFewohvE7AMt6I74PPzClVS+BmAOgC7H1AEf1qpJukNfzOPnE +fk4NsmlCVt5n4iLKFdHku8OPDZyln+sHmL9/WucUXNnxMJy7qy5JFvBBLyb0qtYO +Bp83JCPaSZee55kBkLnKr003hmj1+DyiDWvXWaAgBpGbp3hZBi7fyKEbH+g5zzJl +eLaZYX2/IhB+IVgz046TPitD/DPfDHH4Xm00wQu4u2TbLxzzlclNioq4AsUu65dD +ja9LgGlHKhdvK3GpNQYk1uyYb+OeTl/A0jO/+cDTyWzzpE5PkDlA7Dg/Ycmb/+/N +xJNJ3hEyOa493DFMADrfFYj+P+i5KozX2KQAJq20jSABVc2G6nO9k2BvjknlMPyy +j9SeQH6qdlozdrisNkXYfY+D8NSwyZ2BbFX4HWPdW8WB/Y1CZPnjjaoDzWpO+kBH +OvzRftuiMsrEw0CUZ9+VL1g5N81RtoLGsqmJse4FIMr6BvQ891DkcWRRnLwQzhdw +/bb2FVwQudcP+rfIi1dKq+vycteZLgGQOhGpz7BTs6ZbSdtjo1s0UVXwvxZRpALX +wtoFEeLPSOiJRlKj+rgylHDXnWsNJQ9qONhEMD4oqPQ5ejMkTqB9LN/ot/lepm3v +BVzA6anGrtfAUUXlrMINAH6hq8YX/57ajn9RbgzaoUtMY9+IxRXeAsEdEFGgzeQz +pM8D8HtSQp0sxmBpQNMAJ1z+RyCIDAOKS+BRoSxp1U6Eqm8/zrH2h6cwxwYsvIFX +Fs25Jw/SJ35RLdbMzIH177UxJZ/BRvTSWFcDZwNL5Zl4WK+WEZX9PBk3UK66LlNJ +oHU02wtmvme56Yd6T3JmAHhhGTibW/WXBXc5l4igZxBzfgR9kawJVQUD12ivoBEA +sQlkckxTXrzrTa4sRxR+06wYO6ExG6JBBK7tpqiv4ueAmSoN0iNaYBb4RJM4Mcpu +0Tx9fTNyw5BC+7tgV2VmRzq+dRCPr19JtJYQPwhGJfby3sgzJk16Potp9AIyy7JM +ZpnXOp3C2hDxBGLLV5fwXb1jiFHoOxltLrqjZGGQhzNX5UbJra3wAHbcEf3Hcuq6 +ilH8i0+cepCnvT6RRHtQnmbMUOFtte/wW1bQmbg8rnYCmXvwrhPSedp7lPPf8HAh +PYtoXRXIP+hIQMQpgwh/3n1TwXAj9WNGloAdFckb1frKLAME/JiZacGE1TS/M2lk +tXxhwXri8bOXWk8jn7CyBGjjyiiuJuN4ubbi2hR2LrHwjE60fjzPe7Fts181NSHo +c3xQUpxkb1tbuZt6Tb0bOmxyXFx02n9i317omjpKLrjaGyNxIyLMo6aJnFo1S7nK +8UOhU2PU2AoqdyAgRFaQLBE9qFoLlL60sXKyNJIkjpKivbS4JEnXUTQ8p8Ti1v4j +Lh1Fef/FyhKdhnRIizNyL8WZIeIzNKpCGeOrdH2d2Bhp0znoMRBYBybCEkAbcUM4 +nzOVmoWgxolUeHFDXBcJU89zAza0RMJuciPYa0cocuL2e6UWlTNsWk7HrmaH/H/a +UYU8yiPG+sSZSf+wPJ+lOJbI/sP4e6OozwPXx3bMYjh+HIHcDnGHbxKYT8gks+1N +xAwfmjR+5Wbxdivba7f+qVbtd11VeP05iLTS/03N9A9Y1si6k07WmuWL/ofQBpzg +1PEU5bfEk3T8baHeP+Hu7FKLpLPUFBXSrOnksqQDV9m06JVbfr7AbVrLnSsiEqZ0 +Yl9GOXwgLkHYY4rZNeR5E/VJenGK/DW1nxaJJ/XhGBwRgAcp584OJQXulBdYP2oP +TltaSt9B1bfjnDGg7yMUwmYlDDgdlJSD+G4kk6kXBRTrytW1t72SzTYWlvYHxsvH +skJMxxtA3kIZXtELAwqVohPwO8X2PqeHN7JEUeFAPzA6ihrU1Nkm3F+RRf7+7/g0 +b18DWjR2H0sI/s9kxf0Xc2mrtScdlYfAKnd+x/riATUbXIc044nlZio6oz0ijilr +jq1A4MJ7wsophi8vp9b4rIMd8dRP4oeyH/u8CgRa0ct4poHrbX61VPrJLQSWmPbg +k22KzKBIGl88VZim3BmBgYUsXVqximBZ8i/Ru2BdIWSQ83kvAfL1Y6DYUGyQAxmK +O2BcQ5XFqod4u9BccT65uZiKM/qznVS6Fgudy9X9zYCud/lnx/865c9xwtJRvb3C +zyeBZTKVDiAFIqCkrb4lW682bc87fxrp8TUtH6Bv6ExoWHmqHXQiM0L3SrldAUC2 +JlzBI5eLlT3MuuHXrm804i1D9OjqPx5it4Ulx0k2719HHAnHi04iRgphSZ/YxTEu +MwsjuKV98u+n2o1+MxolcZ1+PUWBYojX7FH7r8yts/W3+OXv3Ea0/+iFTEqKK39r +RZtJ5PxJda7MBsgaz+h+fG23bE1Kg1XcK7dGlB7ymIHqlisiedbXJE+b4ELDNQuu +suEDNAjzHtAPM2xosjF9chvKg37h3wvIIf29YErM8GLP5XjUdw+AnBs3uUpK5aXa +fWPsAu7nPN+0Qptn63MxcJMAy86OqfbSS6IhOIkPp24q6kQ/TiOTbuN85pqSF4Cq +EI9ycVctZf/KRKVyHIKppETirzXecOwkJp7wiWZERUw89O9HrNrufOj2W3/viLYA +nzbLSdlFkLJxuXgEbIiXDySSc20yiorL0+rFsswzCjK6nxK5boc+NJdI4r28/49w +ycd+NmBLeIbGSd5sa5dkkQ/LuuCkygY2pe7vqEjNB38ALsPgLKDqnw0/lV/TDYWp +L1zyp18B9WXtvkmZRlkd9ZhqdbI+jn+61lfRhwUjRninOq7X9XLYdWFM3gBV7eWs +sq55HOG86Vws9nO2Bw26DuQynPJLBJcAQnpbfD5XHQOHUTD44/ZRzXuWH1CRvuao +PYI1jK1PmFUENStZq67L5fV/v8SI79cuYvBUhli9lHVDXxwCf5iHYqD1Ji706PXm +ViTPq6eeiWHNW6Olj5t/SVeqaTvjYghc/clt36l35vit91y3tc3WYgJsJ5Z8hGQf +/84l5mF+Z8wm1vkuvpYJZ6tHEpmF2kjkOhmAO8jEvox7GCUa9hMetgvLnk9hZpuC +KTjE7mERBJEJkXmngJYw+E4R7DKHt0ZepcLwuf0HyDutcwMnzLjicbmlGrU8v0cy +FOMg3fyoUbQ2xEXryLUUW++eDd7FEuLH8++BMVEn5BsRW0jfvmmjCIZawr/zvrby +YY7v4MbofaTzLsWd7++3cTuY78qIdHPPj0Q0LZ6cKBNjptR81iZODTevjIa8AZDc +wgFxkHsLr8wjh2LMIbpZnTLAHFYcYuDwvqKtPXa6dzC/OfPH/HNk923FBI2Dy2y4 +zQXeQxOBsVxwu2h2tCPuak1Rze4KaHtQKo9dBjeIAHxaVVJ2u8PYojukqw+4eNbR +NLI9dBMvkl32fpY1Cq565YRKZ8n2MkeC3pI5GSW+iiuVilGdVvMMZNm44YeM9qT9 +Wl3lY4ZLYVSFUkKFitMg+Zr5T8vF3GHsrh3udH2/M+a6J+FrO/4tY30oWSk91G2z +FhCBb1NoxAo93GIJUal1qLgUpBe5QiZAc8qg5c58hw0sdvbZ1G8NQL4+lorYuiNN +izZvPlWTQBTZVAR70CoTKqv8Ya3CkxDW4Ydbl/db2P8zOBpkenbSldiw7PsMnHD4 +A+ZrFMxm7ZuUmvqAt0/IESWNG11bWnWQeTUvgcZsZiFoFdo0/F+Piu8pzmBj18Kc +BCIPY5uo5IlKygSb98FZFnWG40gGr9IMrX1rgMH/0SJGudn4PDHoZ7qhUpY3BCMm +KUWlk5rOq6HermrAWo8l8Kx3xgn/tN1XkFQnlVa9BEnoSWb6XSM9C6uNgKGSA2VF +JD2wMaiZXFH/ABgjue4pbKftu+cy/FoDvX84gQUFT4g2nT6sa/v2Rxr/vtsmS1g2 +u2ZsvHIVlvmqOr/omcsoMDjYjXds35C4Zko8svfP+DKsq11ZjTaec2nVRNdZLps3 +lR1wWTsARvO547FJAAuSHeYpqRArzT0GCXTcKa3fNL4sKw620mozlLfp7fhuXcZm +JVVK7SfLLmoe8mYzbSN1G//749wlgqGWuEDXZRvHNhIL/gwPcy3piho4vKjzLnoh +jB7HyhUwU2ngioaMheYxFy13RWgwKqKOn+PyzmOwaV7d82D2/EXJvA3PrzTs+A4J +VsWdOH5+atw7VOCl7LmD78lbbe/Bo6syrnb34SjYML+RRZixzlIyUe939DnIixpL +DeEo75fC38eI2T1MEPajFysgO09pyC2xUD31e3Y7AojRNwuISRF6HRJMC7J5b4pH +wbuiwuQVIQrzA6BKQmB6QkG2DrwzY0PXwq+q3KeHSQcH+uqctjHgNbchDOC4qM9k +5bhHv4Jg7hIZseYIUU0OAOGX1yQCaB+3dU4VjcL9J7jbLyihj80zaDFPGTKUAMhZ +YQNUBUu7WfSOS53cakpENNPSpqY40IPMglHQF7TCCN5aDkjM0D2uvnayrDqiQt65 ++wL4QY8nESUc/zAXjjrRlSs2sABKSyu+AiRVl4LAcHU1czQAd8X0Y313GTmPrrOu +IZgp4bpNnuQS6vEpNNLsBZ7yEpKcv1033InHSX70DKa2RnwdKJcA5sdwiohPAoTg +1yJ5LWd40spYjsaw7AN1g71cYH5vD3a4gVJeJ2leJbJq41oRVLax9Zy7+K5W/fxs +x/t+/w0aCyHnBkfgFx+70XroC/ne/rjit/L85RC4tHsV4PzvyEE4F1XA4VR9FFc9 +Ec+KlgYh8A4AijEAYi0q/EaQID2lhukCVNGzQ3jlLiXkFKT5zMcz8yayFGNg+Qjh +Cw5YWhjDX68DEw+ABIhDdigj69mhwKlB0NBEanGaXA/FHnbsX6RVNUkh5r2HUrLK +1cYnAT1VHPotsKsG9S2Uj1JbccX57u541jazcaYosM73qTDGB/V86frvNpFNOaKG +BHNwdJwu0FihKnV10Vi78P2XhQHmOgo8sJpUoIG2ml4XWw07+18dMKxez/AzQ0HE +lKbrS5ceX0bAW/Ww01dHThF0UPBdiSqvAxGC2mpQ5tW5ThKhcKse0BuVJ4dc8x88 +fVj/IePsJENwlEdSKUpcy4UAcex/V5j9t5PVgnuREeX7jadm3L2sW3eYFLDUNTTH +Yd0b0wZC1QZJiN2GuZKLtj5m+8FL39PAcCcxy0C3qhgBOx8kGRlqqyGpcqEwHri7 +mKh9mNNAYi29Bj9wLHSmu1J+LVUpVajQy84Y/CeUbD+WRuyGLixuiYYyMJdwhC0h +hVuDThFSCiaeblVsTNARCfP4pFx7P5ijvvtwnuXcDzsmEW/njGCm3rW7G8UDIkk2 +GSle1ojFYZe+AfT0Vby1gLQRYYJ5vZVQhfQB0eNqainm8v094/UsQhSrI/4egaTu +pwDx3yU5Aqzk0Nodg1hwTqnbVDtfnseFU2Rt58trb+epR6XxRiWvmD3SV2//lJju +InFxsS0YElERLS0L3uh9c9vMP9nM/SWKOZMDf25WVzYV+u33//KR4JuHEFijs7by +RkyCODa7KcdIO+0LMfnPdbNTsv4uAXYDe8qt9ifMznM3Y2b9TdLayO0yd9rTu2+p +If46P/Nyrg4KO9PLZDdQbs1RTvGfVa/l+OQ5YDLGNsecgU7ErghFQ1tyunBlLmWn +T8TMyus7QlPioZPtESFM88SJnTM0FL46t1oyi6lxeBIR2a6In/MD3alGbBY1oXMt +7xq9n5MRb3ERcnJEamlUIdPkyDXCsGC3GUtZ8Ooqmfp5JiYqod/grlswVV9JkMze +fwNc0y/7pazadcd5t4BOggHFSMdIoLZFL84PX4Trsm1rFq8Cmy/inSNttPM8YaeH +1N5oTKGsuKWP0Xc8OBmi/ynSboxH+cSAbshA+ITwaeDhQxxc3xSeQ2G8AW5hcnkB +9sJrtYz69g9df5MHLzWfp2uw0iFQzZATtoeWcxYKQ+OOFeJfz+ajTyDXbWxh9zRK +gWQf/72+Xiy5xt5IK2z6cBp0jDeMGlWPTdonr6YhY+K1xNxQuq6qLwRqjWW+NF1a +4bL58JY6k+ptnPSkcvN7sZ3ShInqYnyottYxFkR1ZfZu5I2+Y1ywenxjl0AFDki9 +PiCnOONwTl2XeLQeeRe646Geom+8AhkqbAF89GvjcxK1UU+b+q2XfwGsTMWTFurP +6F+Tx/+qtEnzXcfBZE9201TcKqAdUSsdXapg3jZt/mt+UuX1BkR3iFfnelDl8hNI +e2wplEbP8j49yRXDvT+PE44LqS6oTfM2iu2KvOPw7cLB4S5FgUQz4+WYDfq47dMn +w5X02IPMzeMSOkVeH+zswaaj8OD0T6/2V9///dJpWQ9d8gnewKMl+iAXJiTQKUnm +qiahIBJ2bLIq+OcrKD/aLfUXanBAA+Jw4Q0MFQFMycldH9SbEH1Qr8ws0k/LlwFN +/J4nQjBDwq8+lD/i4qjqbA2TfVMjc8z3OLn2lsNWnCLcBj+PZDthpRUVsCgjlXUG +leH8pI/VGB0A84C7ngK7puF1cmnva+rCGkXpt1KWhekZiUHcI3QtVQmrSrOfZgh7 +hU7k7hySaAc5t7QVErIdZaUhlKNEEuj5KjmoiefeuIX2qcweq2or4IPXJ8lrNZ6h +iVlL6MMNtnmdeL2Ob1NEcU1nNr2wlKrRcl/u69MR/wHIgNScE3dQ0YGXmX/8AQhW +Sbk7tetUgWiC01L1tiyACHWy2kOY+RoRSLQZeuVwHc9f4Jh7a7bkLImpG9VqFCkq +84iLXVOv7MfjiukE86KigkZUsGiuFJSV6d91ExXXxIVeuC0M6qZ3j9Qm3O33RDYA +z/vnx/S9dMvVrKZ6uEJsa+WSGYnILOWxrEDfAzC1Oy7WrLkLQ7RPNluSe0MxtWbJ +hpbV+2IwuKpSDB1WNSauNEAr3KuiYfSLEdar8GRHNyP6vfqpRl6VgJog6bNwQHyJ +6wRYXvzXvsJHZu+dD+KwMJMvpo/ZUdIc5c+EL5jxlRQdyukmL1/ovZ/t8eJ6PMYL +HkiWonefM00FYEM8UKmwi47ceBi4hLakbTNESHpKEWsAfHGqD3gjLGVWGXhF2uKS +TaEpOwkdL3Qu7S7M97lDKmReSRnTcbBoBnOg2ggfJEsuV1vJ6LfJEMz6uW52hhH3 +Rpvt3x5y9ZmQTrsHx06XEPateWnSuirTdUFwKD9Ky18OV2Fud7itCFVNbPW3+WmW +2ADKEtEgR1yvVvyPi+W7PkEUTO1+rVwYBVfAlEolYxLKiFSy95pT+ljneYjnJOs5 +9bjxAdamiRFA6xraxjBTW0RsaoZGYBXVtkP/yldieO42+hmQ8mxWetX07+hJlprg +IMZC2uZzi5M/AxKmfsOaTJQawQ1HiSFvQaPSGVEHYL1aOtG/VYMHCT6kE+qD4Nf/ +W88FZkNKUWkzccE4IhmRwTjReNRpTjEIa7pmZ0JCpYlFGo9B4z9N/0EC5kk9Twm2 +jynidO6mJTEZ7JVrGPy8yZCDCNo05pKC78Dlnjxudlc5Xuz7dPXY0l06fm8tr40O +h73FmbnKlvX3hrHJ0ylLCTQuPRccPRirPFl+KU1bbxFIsv81WLgjA8qYXpg9Mf4x +zt/obYCYyewq3YIp9HlUuE/4EXKBGyDBWq9mLdGF/QF+J5N1Un5xdduDF/2t5GbV +Nv0+/Dru8rD0S/zNKOHwUQseqQ/Ne3QpoBQHfOk6JSwbLEOPmzKf61xhewiRZhPQ +my4A+j96nRFoOttaoulAkLCh/LF51O4Hd9EfW7cIHJF/E4HYBcZWLCn42MeLfapO +cNiPcxdlO6tQuowBhFAfOSRtooffnQ1FWBJZsvQh3rhzfSlCsPWeU6FEGFfSkhNF +tBKyFkNHrQQ7xLJga+XJSvvU9VFAmGK+BE38djL2AB1nkfo7qNdbV36nPjtfDTyF +r+Fm1uanxHm/UW1mMVPO8/plZxfeLSIL5gDA6OBw6J/GIMwksrMXJQPx0GoSCv/U +pG2RPsrKOuvo9plsH2D5bgoFl8qOHRwtGIes57o09WwtfK3wD+hZQ5PcRkrkuPeP +WQY76OYG6OCDsN5k46NOB4SpBMTo65W1I9CmRfTFfNoa0WwjncIXMDb4nBvMcorQ +cVRpte3AIZItnUm76WQvUpc0JTZJarSd2O3hBg1EwBaucBdpXo85jGDTdv4Ee0zp +3ri/eTXdiNEteqnXIIuvGO02LSHE58RUgi7ZtPZl/d+f6dEIrTeefuFdQVwl7tG5 +rGAomnEYuqlPz6oxwhy2WeMme8e3VWFIYHizd6ZjGj46us0Sr4J3UfG8TSywC6DS +xkkaP/0RGIL+pifLyvdWBc3rGkhB29cBkMctqu1OtxB9ayE9EWBw7D7Q7UUjAVqd +eE/x7HNsLnGA1BroMSLOPVC88tbqWp3EarXybdmZSjvXfmfhXqbzjnFJ+ML5fmZo +15mpOMGjnRe6/ovAc82c6AKepwDwk6Vs3gXsqbFdZiyaAINhmbwb6g7jZxeHelga +gPqSfPefw9kDIa2XKYU/6GKbvndf1hWc+si6sFDd6BbtC4iKnObSA4LHZFbavrW6 +MmKQRy3uW5V/n1eg0cs8vie6TlcNoKqymSiz7Rzh6ax9NrBJ9soGSQlfGEMxdYQq +bqgdm4bREuVgJzGIljePIKXUsFdPKmHKvPY7nGq+CrPyyCEp3lJ2Y+sYOSlqDxaW +9L4jXLh0X5uDYTr27tDUjXJA2+eteBmm8bWJZglLBVA+fDMrw6jb1Mbo9V+3XfoB +TPOqurwEmSHv1kQOUmpsddg5AlalgiF5Y+FFiyqg5KNFSxXHKq/A/51KEg4W5SqQ +Oakw9+DRATwS+8N6JjVYR+QC+zWflXXT5TZNsi6apI+jup+7tRHuxJyFmqNRlQm1 +Syz/Mi9QkLbjHIOMN3HnI0iLK4Yw6JO1eXmHzrOaB9T10UnMh2o+lgQtMZNy5xYE +51y1OKdrrN2xTXj+6ttaVX66lgbaeO7TKRPTM5XiHneR0Wl5GBp7Pb5AasRnpPR/ +q8pCLE9oqQWfVm+hrdQuefp66TbBHQMisFgVfGcwRH3zNaKDXUY9yyet3yWT7UNa +DOikZyONq823hz8OsJ5zGtAECSIqwFwiF2Co1rW1Ub/n4AP3iX/xY4+VrOoh0AKb +/IgttNuCPJxcR82KWpHe6LfHsar8KJbM3XQtPnEuhTGWwX7WCmshCNVKtSRsQjOe +RZpqb9KB8AW+ShqQ3YXAz6FEt9otNdfd2ynCpH2B/g9krGI+9BMf2WEV4y8EXtHa +/TaJ3w3GGCqYLSxjsrTvBhgukQzqRt0ocj1pU9FqFaNY4GtXxvPBp+1l+89FRWQu +CnpXR6YzVaLhmR1rHF+KVp7KvuTju1U1C084hCxlyuDxkmGH2ORLnGYqtVIswi1o +23Ucs134k+Uu4DI66yezvKiiAwRBLkMgUHZmBb7UfaJ0QD7qoqKNaBZD5URNZXY0 +4tgbiQnM6S3kfItzAPdsvgAVqvMrDEnYXhVRRVCS3HNqPIKluSnojvlFV108c2wo +07qvAv+f4kGHScS05RduoXlfqOoR/8CAABOgMuwf/5Oxfgz0ghA/qur2ye6KGDv7 +DAvqsY18DUWU8jZ+tSst727iBqe+HaC/vlVSFzAuY64yL0jIqtJEC0AMjF6Cm28t +0qby9woRNO3qNcnpRILSnPGwBCrnx0IDJkEnqZtZJwZYf1eyDpzgeSFCdfcVhPE2 +sSPN4iIMQb17+whzkeG+rUXU0Z2sGqSpA3xrvQQFy835HDVFnpyRMpoS4JnswOnR +24isOmT04bINXMTKuX90I0M8Me6p9cgUsPCTAh196a5KC2ufxhqq65EKOrsAkHwK +zy7ihPvfzN4P9XTMNm/t6dEPhkmUpEI1x23Pbxo2uQT14V+yqPTFhiXuTNJLgC94 +w9ZCGC1xjSXVf9UvvB1r8pZMj6f9aqCze33ZMasNgfzd39pCkvYy0xXl+ZIL9qG1 +k8ILPjNjq4FquL0huxC8f7saLN6Mgpu7XhbuLBttQKVSU6gIwUUky9epY74tGTPI +wyvC6o1mlzEKbwWc/n+JKofIDWiUeq92Eh22fN2lWgkZTryTCYBu9dyQ8rm6UsAs +icUNpad+4nyOVo8ZdgBoyBDBc2F//1Nt5keCSDXnotkUg/jnxLkBNE55crANGgJn +rp7YoXWuiTP6eaXpPTAZT/akPE8eV2zNCkL4JEIq5+8HidV4rYuL5EW9qh8GM0EW +hp14D0Jv5+1TggPhunG2MXv+ucO8L2fK2DXKiOXq8c3CsVZ0/INPw7ltYCmgJTip +YZUf8yjssdzjRxdKMAyjHNcIv0Jvy2t8Btw6xv7cHexdANiIxA3YlQ7DerHiNv9h +KDvyXnuciP8L8sJdQ8s9pgR9dJOBX5+ykLGtgLSene4rwMzjDJUVeGsfD3J9nWcr +zbAy8zQdslXN7yqFTfvht2TjZk1PyNrZBkMAYuw0lpKBSYSnhuiz2rrtMgJDhIlH +J7Ooh+hPeqhkej2F0MpiIM20she46ifOmlXcTJZ+Fd7E5sK8P/0FixcN53tbIO5f +abe66iFrLPhIa90/mu6eCntFufWaJHfh0mca4er/c57z5OgaUmhMUoP9pDuBVlw+ +rjY9OoxJDpn1zHf3Bv6zo4+3UeS0FfuG6yTJKnjw/eD8gJNkBz73dvZEAjBZh+B1 +pG3son/K7RtNH+hB03kXXYrf+48F9a0RtpEZ9+ap/OWeX2Jn3mlaAwUZvm79Ftjw +rUsqyk27xkRQhUwW2NYCzvfyYEjyJCQ8XpL2mT1qkCOP/GN7Yp4Xux+/KVyGsjQn +yPWG63jAbKUGknOLU8OjUayPFjtBHa3W4jMEV2xXzbUALLj7n+a6s8TpirQOkNZl +C+Yjuy+Vi4hv3vh6l0JySTgcWhMcc9/fimPWY9XRDyFGh7XlN4owS3V8CWoq99U5 +ThJPpWsFpGgMKYgt7iSKEcZZyaOhD6vctudMTFiolpXFXQlPkLOzJlc0I98R0LKM +q2DxS8vV6nYXQxlFdBKumw2HQlYpUMWzds/q9KBwn/ptKLiZ3+Sck/+nni7Tjq+2 +q/ZV9sHVmKvq14vUsA8JPTU3diF3X/X0AnrpdH6fbvHEIEvFblDs4XDuX/yHuqWb +/XMRZtAkGI3krO5h4xgOALwOsn7DnCYySJ9YPrtA4IlBRaQKI/90bUYVXnHci4SI +GBpGfZs8paGrzGhx+KwN0Y0HvrvaygulmiVTJ7tW/0/bD+H5meC4vGBlUep2gQz5 +y9rXTR/MqFhrhz2d2Q09mRozrex/e6FPjzqLLzMy5CIhhCtPQ4nQRzAWi7ucwQ24 +qB/g4f0s10YMmEW0mQqNrE1SJXccOBONWrXpLo0ae88QGATnNJ8kvanRPmNoMHFy +PKPx15jNpxaZpzJKm/OJQGWtcvLpKb9YlOsvAJK9IbqhiIIGwgvCmjt+61vhX+9s +uyul54WQEdA9iy2bsLtnpSMltCEyum/CXL6QIiyVAtyN7qUwwqxnM4F79vtsMA7D +jDcz9Fh+TWwx9q0VdYjp9FJZAXD8QO610yqByv3eKQwryTn0fGb+mMIYYqsxByIj +YA5a0a8LFt2D8jTc0eSOYCLG7J7GHVKcoZTvMjyqQP/LNxxv2ivlSJX7N2GjsrQs +rmfN5hUCYLynmPBiIlFUwwxyhMk8e4E++jxXurqa/ZRkdzX7iafF8fUD0akistPt +PSQNO7pXLkDJpB1UF++GYIy4pLoZO0/0CLcu667h40kkrcRlUVdEh69JVFDaSTsE +7yboP71a7QLjNE+caTp8XuToymOEyULRsfLF3yk29PU5Em9tQPtQDjQeH+/mdDnx +jwRXyvib6ct/CZVpdlKKOBUNF8o4A+siO9KBo2DFh8cP2Hu/dSUNDJBfDEBPpYt4 +1l46mO0sRS1lhJfk17AxYqvmsZTQc50Eh9vvaMBSS3gijAoP94/7JJNd6q5yQQTH +TaYnC5gQ+EVgW9Nzs8NIUndYjEKKWO9RXk6p7ncgqzv5iM+rkhClkK3C43XODnPp +kInPLa8aZzdasKRjg8dkTKnNuV5HciIEVG+Nd1sTmIM0EI/MpIKIX8zHyViuZ105 +P0vqxF1cB1VaO9SfU4vWSO1DQ3LumP/bp8z2VZF0XV21v1JBkbTgl58yjRXrgniO +WUuixj//P/Lrir0Tbl6TtPvrQiMjR6b56waOHpZCTNwV8duqLFdN0d7B8IgZXgV/ +mDLrqLe8wfnFPSAl8BS6t7qTwm3XLsJ5x1RjP+RpB2IOcFpc4sI3gKTuFbCuJOhX +cQfc0GFckOwXG+KayfYhFfE+dyWNDiX9XLvvy7ilyhyuDGSFi09AgzY3PhR4A4wf +HWKWMKbL09dst4HKLZm6VMP21j6RBZadJd/m+sXoWrE5nKiETUhAHh6uL1cvXn45 +r91ryTd2/N2ebgHWGeZ7/LPpzgltVEmVwilGBTc+HDqgR5VLcla67BNZtKCHaL71 +zgxmz1dG25YqfTfDK40H/oNlspV7VVTBKv9jvXTaIjjN+ZEx7fN88YXnje/XIPy6 +ybwXJaep+3eiL3u4rcAvxhePyj0Y0pi0afAlOy3p8+Wug4+jVK8RXVZxk2qVXCeS +/5gAmFnyfw/hF7P7TEhXGzk48Mq47cKrHXWMk1XBicrHJACZgDsgF6QCvYdBKrZ2 +1D67xvbbrA0P1iY1+iJunMLIqBnpOOlmyQrl0v2zJlMlt3P2gxtdbJwg3KBRSbbc +GTwIGNm1iQdC/scAtoNT2daZdTAkV/BP5nktkTIF0aDSUxQ+f06/QwIMl8LhxvtG +pXiKupLPZ4y5SYyz7zP0qZmL52XmaKAUrN/RHH58cqE9w2jJU1i4+ScuBS2Ierg9 +bzY0o/R27E6PwyhIL5UjkIY12YjlQPDjHRaWD6LyphDCWidoAYj3hrZO/+yyEfZQ +Lh7wTysGj18ptyWOXZI3aKYmSM5nQB5Ibl2v1uRyxIUhmQRvLbZKckONKZ2s7TV4 +piAsJYgaJZO6UzmWdJL9+8AfxwKxLQkiIKLGdWfHGfQXm3NQkJ55aZkIPNHPcocu +J+reInuLGw60wxms+VWzejU+GGW3bEsLYl0GWXy8VMJ9CCKIN5OxmlHOqmJP8Pyr +QMq/Ht0y/5sipJbZHtiJc4qlB6dqEER6MOqRzM/mzYBotrBVuU0kG6nhMTQ6E9P4 +t6di8cFLVDpQoTUqGqcmLroauody5YTIiFqzZwX7bJqmnaaaVrtQmMhivXkmEf53 +lk1BgyUrWwxICceKBXZS/C8gjaabS8JsXwamwfnF7v60NKAjIH0KP5+BPrm4OVJN +orhcKwzM31C2Ag76pNKAgTNZeWKOqjCJj4VjI+qMqS+SS/cg8Ft7bZk4ghaqmW8/ +ir5vNjUgj4wdHV7YeKA+Gf7mVdiZwlJS3ydF+zCFVElGsPNd0iT6LvIXLZupKiEE +UyJMuYEPt1d1FPA8H9bkch5Ns0nJWxDW6k0WS6iezHBeVtIJuHjYZDoV+uehF5iK +/V2wlIXh9MYuqrpxPSdJu6AsIO2HYg587t268aTYiYkJh79km+kwcE5eLnSdOFrS +RsxWZkC6T92EEKH82FYghBQ6b9p/rC7tVkqaadi79PJbvWW14SKxB/6V/jpQAp5L +NQvtvmeCA6IPfgeOxpTw7uaK1CCKUcDEeD1ODfXxJno/MmxKL6QtYiHjLBqpC+n3 +1IIaDGXc1YrdTLGIHtQVWYm72i5c0Ll/CzBtT5KOznpXojr5mVDIz7mO6ECC0Lg7 +EtVdj5Kmmnb34hENEGxZCIzMZIPQ7q2sKl3nQVUPVucIuMtJh186N4d8vDpA9Jty +q6PH31+A78pgpuLHQo2rxHWszWjV0w3nJ2aD8g79f21+BcyHCuICgr3zGFFqnrO8 +UL41lsMjzr7FC/Ys5qsx6YTInTC1es2LtekYxLrskt4ZYI7kiMwxU7eC3zGmWxO6 +Pl4Wtpy68qhUp2QTUtC/jWeig+3IDZenvvE9EQLkdnfHEH0qQRv5GtP1LLZJ+X+p +ooZP7Ehl1whhiUnFHLzhl5txUIzWqrdS/Dc1iUORY+n6hOj2UrUWifvLDeC8HZrn +yqodUxu+911STKTanOuPHxDHdz5+voSBYbevHnRApG6zjA2GSk9p8n5vCj2FPS7u +hebQ1/QAUtJLWT1/An8zLeJuxNdRVQLn+fW8aZ4wxSI1YEyP68L8WWxy5V22uryj +junh9Z0sx8Wt9FLiISGnfahJEq041RkXIpT3sGFQ0dEnkvTSQafmuFXd9iy9oBOr +Jy7iJFyg7JVcYf7TQZYU4MkXT7h3SkTLRzcO/uirhRcjfkH9E3t3auQvaFslfrTY +ikWKutniqWH0MLtSIQBLU1Qda5ZS0S3hZXkqI2E+eEWNYVkVx1uBEEwLrAMbB5By +65RgKLCNjXDaoJaFXZzdo88xYbaGk6jaMHoFSJmnHBsb7LH+m/WHVs2YGUnfLscr +gd+h9iICbinYMDwvUrAq66DyIZD0nRazwhua5bX9Fq2KIHuRs998G85cTdjxwFZX +/rbUdeXtL+4CIQ4feTY3G9gaVFcu0ocX8NVu/zO4/4Q8F6h64g2H6RS9KWNAIelm +0Hvzfa5tezeOCtL/HEkdk3R4ei/99Etf156vehD1jUUGI0Us6Mm7URaQ3Oq/FyEe +PzQVsyQJuidXUn9iUBM7SgDL3FlT+bh4aCSvGs8WT9BtJG6io+GNa722Nnth5dGd +7cO2B4qdXiUEsRw/iAJdIx4ffrpnaOXPY+NX8jJY0Kqc+iqTV8AxMBmTOhwC2yeV +QQPr91aoFp9p2Q5aFg/qtiYjhvO347lMBisJ+v0PWrvdp4urP+nYO/wUZfqembKC +BR10FFX8Z9NACxU67aZrce4XQiRrZ0rWGI9JES0Bm9e4fXijxhpa6YAf4en1TOKN +21nOZE3wxyqkl/qVbo2u0Kx9/l3VqsXXYB0ahZAbayLJkZB2FETHjX51wc41GJ75 +yb97AGYdlXU23yI0ZPIjKXA7EOwWr6INDH61qOxqSJ7/QrD6qoTzUK6A01bkBJPF +TR6OJt4EbHp8COTwhuHvgJG8HE0sE7yqU0ti8OrrhU/G/Enl0sYOJyWKHdlBhAWg +5EPfns6Mv4ribW3fCKxXxdRpO+jzOk6IK8DpqWiCKUap3EN7O8jfsdRgJrsx1xYP +aCiqe2EKaLXXeU/tXNxusQPeHTP1y60yl+C9Nd+vXhQs/PJw8GRC6XXs+Pz4Zhr/ +4CN6ByjAhtEiItL2rKK7SSkPa5h7kxJPGHsRiWHWV1DwiKWGZkEgSeB8ujGU1odC +plx2Iwnoib+ul9TtdnJNPc67oDn+Sxfk0P03adA0Tt9ZGpAByitHdXUx3SSQp4Jp +tPbD22Ok6KOjfJ2P/MLFP2vlPSVh8xKgocOw9wbm/ssAAKAGjjEGvmWetyheEUv0 +TiFOIKSYBkja2NDjqkLLF62bBixXGyVAWxpblB6BHKCzVTqPQ3f1AyzCx457QyvP +p5nwkX6U61o/riDUrQu/b9Cb4P4JOOU3PsLYBZeV+k1Ulw3F/xPF/j0BQ4GH52fM +kurla/lanQIXSfQb2EsdX7WuXF0JP2hSUN8xDjojRcvPOa3Gmj/JzcE3kjtisL+K +xgDAQaYJnSt8y8daLYIo1LrBrYrGZI0rByZ3klYPoVZWlaKqBaDguw3Iqi8MGPbF +4B7jJRCijgqCsK8cT3iTqcRPlSQhNE4+L8aW113zrzZkd3C6fUpu1hUxgDcZUVLE +Ctv1K9S4+pgYZqdX2Nl/KJo675y5rHAtunrd8biY0ZtwgKbdTfFDG09h7Oie/77X +uFLQRJeq3piWGhNGNsDY95hRVhoA0Pg6Htb7jBRvwnak0rGSOuKknEe9E5y2rfeY +5jS/aEk4h2XkqpkDOjS3Fo4pgZSy14FYQEw/LafCZJeuZDiIUa8UkgSjzlRgsye4 +lowHc0DYuxiVrDq1RSWAathmetd8w93mhbr1pwUm4sFDupLqZxKUrxgfaTkP8tfC +kESSzkUZmWcGw1TnantZ1Qd7qoPjKuO3rPXVmRMOfyU61TEwcBJ+1jNSBZgwooE4 +K7zrMT94gQ9TorQEnNbDiDtX0KcwrNWMHSC5Oc6EsZorSKvBRYGSTr7pULzKw+Ib +sZD1G3HYiQtUqDgzyKB7OplJWBpZHQ4IbU0e1EvmgbZ+1g6zVcH8ZbIADbR5Fd7j +CZZyw6v5OelTggOrnP2QbNzw2huMYTUqoppQ3x8FU/XH90/F1Zy8yNIXwIWR4Mlc +bROPc9u4xDXnEJ7VAzqXtbHATycmv+o2JzfI5upVLxoMDT7H9borILZwNlyluUCf +fbxntHLC7pB/xl2auHDG2aD9oyEYD/PQ6lMIx6A+mIlsaBTlTiHdx2HtcLnzUEXF +zASjQgYUYWen/t6yJKn6OpQalWx/MzrQRkm+DVKrN/kuq0QF9wDsE/SaLHbfqFaE +xDqSd+fiTlgyS9lRCnmAj1F6wBNlcRN+otahJa7T8y//IHzvF7wxcMJMDr2BSDXZ +zQwNs8U/upZjoRErTS8fCK7R8YQceYy5nMf+6IxQ31HXLgMEonFmk2f2WJfpNzZG +w10q+sbIYXG19xkLRecAXeHyGUb4pHllvN56JU0KBPnxOM2HLVGGcevJ7pqOeNCD +W/Xrf0fCLYLCZF7SwsjUYFLUUF/R+NdXn3O3GgBcNMfOGkjaQiJxQiQ2zYcAy04S +ngtHOhmuq0RjUvifGv96K3dasgXeT6svnScODr5QFLGZY9flY/v5T+5tThT97COl +yXfaNOgzRAT0g0i/fjdYkxX2r8MHNjHNRCs665zlBHF4XkSR1FqRc96PJuxr1qXJ +1prB12x+8RlnUWhaOwWxJh2cfG9DhWovi4WjnVP/phGcxSi9MWhsCYxMLfpdlM08 +trH5XSBh2HFmqi8Qwkjnde360jREYPuQnSxwwxEOb0elmi77f3MnksHXluXw3IHC +GB2qIdpIAfBzVjULx1yNWQjQE46ij3OJjnn7oGGHQqHDEA4vXDYe3Ta5CP73LHCN +KtemMxXpjzK+k+OfqNkpTz7GsquuKmVRKdhG921EKR56N3eGnjh24Jn6IGeFHmBY +GRsAJUpwwdL8sviPA7RFTZ497DteNIBjkVBTZXrhAxiD+eo2iiC8e8akKXyoAb73 +11IsPT0I9UHcFv+tYWa8X+CKhoA+B6e8+PTgaLcguxUqwi303rSlHMMhZfZSn5l4 +7ap0H3dlhYtUdD4cWg3mLJxdYZIQo2LfK7S0K4kIMURD4HIYhjzvl8KQN2/SRGO4 +rmJLT8EyZECUT7n/hmk8HQl5FBtEOZ24L63OCNyf7sK5BM9WkLUaxBilSakRGkB2 +aDnNVcakcCNHtQIpvNvBl1I+Qvob2gOjFBqcuQdX/MYS2p/mssbhv5z97Cd27uVP +Gb0wMTIt9O7DkLjcXR7MumI5kDq8uQLOVDrZkdldqbW6tYycTnXIgV1/FGbNEfx5 +z1ITTiKUSq304KfiQ/dPInEt37Tt3jFavybJKJ7R82wnuoJNITtShyhAKzhU6Cr/ +A8MlsOqsPYdC+eYiGRXk/9cDb4Y1G2TholcVrewJVxNZhtIltq1QQhxVhQy+YaHu +x0yQ/8pMEeEZnl5aY5E3+QHV/Civzq4anl1Dd2C9M6CK2Pc1RJkdgqTjRDDaPqan +AmgydajlO6/WiXF1nO7HQBxgohZidY/kl+rsooF1CZZ+DLkJgLoeMMN1bE9iLFtP +2amVIpLULLFxxZb7htKWUoREsmKniMSPKhRbeCZx9sgHF8x5gzH0R8MCp1a84Fct +o4PwTdm2ju0VXdtwI9WPDzbx/rR6A+dORt7XfLw9xUY72yZc5SibUAFjqrAdfOTI +/Dt3rAvGzW0c37Yfmo+5jl35OkIqUm8DeP8EvGizYiblMvQrkoTyR9c0bwUff1zp +3wu++GXm19zsO29esRdCwquUvjqTx1br+Dpy5z5SFl3bGxl3kksXUd+rG9f3Ry5P +V9bFLGSe6B5B4jh/HELC/OBCGfSiYFTugtfy0Ru3VXBZ9uMN0PEnNbgcg8RqVsp4 +2W0vzTO6pgW8PKeoOyCAEImOTCbMzLTSf7xpRoH19uD94YRuVpu7E2o3N4VOWcaP +A5All/9ysOtfeekWN8mSn1fagUU/RKSoyxOWALm0vfCGC36VLIVSR/YEAe209UF3 +rMuNU6C+n6jHHTU37Ws2a+7mUGjscyYrbFAYOcS21YkAOQ2jXTYXcMXX8Tdt1Nhn +CIlW2A348uEqNfaNqK98isSp/Spon0RSJTRfS/bxS0nMd2VtkE01H0pN0TC80Qdx +UKJaqlWDBlgmeYy0R+tmXnaLfU/kwO00LR1cWMEwSG8ouvtvZHIPKKF+3xGadRxg +X29+JFVWdLQ3Uq1Dtw8saUY5XWGns4rvJrQQ3w2p6gR4k3U9RhuGCYjWBzWQt/PY +bishx9psWjhbVUIlPc2rSqg6jS8LwKuGC47tSVm9mESLqCwU7BfcEKrpDQJS1Uxt +sJRLyG9VbR+EKkpkOji0Xq9ebC0fgCHpIKsiP3vlRehVSCWWEmTUg/yBcdeqJnfh +4sBGEYn5DLpVwjap8E9gURS0+LcH12ZZ26U6q4s7RIbmX24QkQK7tRLoZ43Kx/CF +kUyKc0jUpeG27I1NHxrL3zQXXQUciH6wyrLOblVvAgL/n3merQ+LpUBeXmg3CR9W +B5GkHAcn8zB8veUpm6TNPYQcDQTI/9EGUuDM5XWcwXS00YhTFi6Qi9K5hlA+rTkB +A0BrPSB84cQobFxjV5bYHN7Bxj8nAzOr6aIqwxyfuNM7cK7CSWg7pIdCHBORbNGe +5yBSzahUAv2jbDDCu4ysJQRCdHkDyXJmMUyhjpqGft/V/NQglZaWNNFJJRmMlX+t +mgCRhw0tTppWl04pg6KHcXJ1TiQpQjlHH7oyifcomv/BGJqIOID6NnhkY2/lwkQp +eJSOJz97Rt44YDfVYLlJbVkSDenmGs3A5fkNLhddOewst1XHQVFTRfQ3Q5cvfFL3 +5vlASJUtJJhjffzBCvbUFz+6Sl9GX3Odl6CJ2Rh408h9ZY/UnugCgYdeQ6gp5QaX +r2ZLW+TBAZVVldQlmq+blHWeiu0BR2ltmoXITlEC55XL1r+5U3dFfIaht4Iy8w2j +7aarT4lHiwGOI0EZOVZAIHY1VOmTJfQExCPKiJzFAKhw4wiE9QGK3szOWQP6nuWl +DYmWN8XYCl/wAxD7YGfODP1F7fabstJ2EzQA2oUD18ZaxspEh0LQQ4nwrj69ajRm +hz32vZPnJEdT2R7pExZGxeBPHA1R+B/q+ef31aG9qne8keFP9P9Jk0mZ6QMRxw2J +mtVAaBf0fdY4oGwFymbXH1T4C3JJTTvfjQaAyHEPdBYrB7+mpIKzN3cv+sUaib6/ +NdtHm6HMYsiyj8MyXF0TakTtWIakRtEsYaznB3WyUQgNBHjZYrwBAK5kjgqOQcv3 +r0DK90r1rtArCMXolar/9lPJwCwYhvqtoDad5YpCuxHPxvy08OpLMUitQkqNyIVx +ncNJsnZWJHygfVQhH40Lxjfwy2NFLSW9f7AsCOEjsI2y1kYhnu6Sugm7mx2bcB11 +ibiOrqCGhGzrIhFlsCSIMo+YjL91BrsVzqlJKGSh7d/JDS+SbYpo7whpLvcn/dAb +qJd+CrbIvKpnjo1/nxaqqnnnxrhc2JJS1Yj5h5O2RLuMO1uPUGGNPyVGg5cvVtMi +cJCR2B60ZHOv6lc7QbMD42SrT/rnHm7VmFWmY9xroRtr3Fw89Qi9mpJd3lPOp5KJ +VSxHkwJr27JfDjsTe9KRPNKcsrTj4d8Ggb4sQUe8Z9LaUYfspAOs3d3sVbxb75m4 +jgORxTfzvrqDLuKu4TNcPyUjAAIhIBYjM5F/ZuRyLHs380sfTerMhtzx1sDZgneW +GUQ70JsWcQXNWmKvarACZCnUM62YjHGw0gCU+MxBMcytiUzlsRSLEz/5YuQcbM54 +a6RtRKJ+q+moXYs+fp6zoAgcGkUjhxvz49o1WvrbyV84KhC/hG0U+WSsJdPrs1IF +8qIAJnTK/uLABcGCJz3W/DBXhIXxPfyaSg/jrgb8/EX9+WziC0W/HE1YC6ostbkR +CS/AfvvEVw5vVU4HiP6A8ieuDHlQHqlKVIZlSGgYw8KjK+8D2tTInrZLnjys87J1 +Uy2+6s0+7vz7KFMJQgKUWTxFX8h+vBUAwscCwWaOK046a6YgaAByeb4wJqLOhqpq +32U6B5wQPqHFyxYV/vVWLUQ18tsam3+hKv55evVquSUcEP5Kend/r466sS+dkxDj +53iHHR/pV2lptUJgM87vPKRMYD2sUZlR8BveKqPY2ezEGYJwOnnNMgZZ6DszHOxD +ox3ajzApqN7nRuaIkygdFRH7ulFBXYbrJ85unq8jO8/3nws0fXoCR7h8WzQ8amk3 +TPAAC5nshs8qmI9beUi/31OHFGteTB+l9nIn6+ljcYk/9U1ZjZtTQ2RlPEhjiZrI +2nTkHN0415CB9uJjdaGev838X6XL410U5EYuu99UQViNb0g2HfDxGYkDk8+qaEbS +qoWJ49DtyyC5fyZJVyGzj60yd3RmCveWs/Xnab295AKmbFfgSimLc0h0ayfsAtY6 +syGrGhVZnR3OHb0a0hhJdIE1aRIbcicFPV5nNuDi8YNg2ciOgztNd93lDSzl/3rY +j4ZHNADZ35GgMAdCAWYIoOzBvjzpS8nM2SWE6+0UzwVWcMjPVIZd6W7XNA2iA0K1 +JerE7gjHIBDnk0rtx7FNgVMT/vGZCJ00AAA02Rv5Pu4Is2w+Pdr/RM4dpAA9gG29 +afKEsFcF0HAYj38KBD4a/2bfPn/5KsfsnYC8Oi2w2Zf97JyIubTJQ+rAQnY32Kok +RT6BqwTjju4roHoh1X+8KnuFFfuQsKoVDmIBR4Baobcdq5fbvlmsdVh+jt/B+fLO +G2M1iZSfIkS+ZaxStTmYHl76O10kMqF1s8iXEBbPlnHYgBoZ3fFRQnKh0I5hk4eh +/B1JLrS1acy5v6h0QLSHagMWsCoMdgyc9qrpHIZ4fWiwUkl3t1F/aqZslnktMSe4 +tz2vP8/FadFppmdQBNxztXyQ+zEURovTeT9YS/dP4fphClurzRzEtEy7mHGqxK9w +vtvP/R6eLfJa9wqmPa1gM4mJWfcT5WQosp3bokhfhcR8vxcSZTZIGs7wR/UFzCNU +ZWy780vd2sR/VK18/6aMzYYk/SH5BcFgrv7R8kurDbG9Jx94csoHzSuMDiVTwhLZ +2TZfxX0tK4fJHR2DcmoaiN332j50AHycVbHkCGcBP8Ogix80V2eK5aILVFEcEHLE +jPpgqboaaiwyLVtKGMIJvUdTi9LH+BjcH4hO9XbWL8nS2UiWDrZCG+A2rUW3t3vH +a3yF6JE9+a3msOMsIpCXZhJQJZvevA8JNizjee4bg8ZUEJFqg+aRBXu9HSzRpTzl ++BMgqcLuWoNDbJ2rQvK6GWPncMPEm7scDdzS8tikVKyqCm5wyYsiMRAD1S/XumbH +iku3PMMFPvF8WwbBwhXQEJOvAL5nPgaL60qZjz+vnGoKvrUVKIk/yfVt8GljnXHw +2tASe8MoKX9WnO1MWCZDklfjVwAIyp8HDAXgyyN/j3mIsEFF/+Owu0ANsFoICz8a +5NRBuOJYN7UpBUhbDdHyLYYDBJw9rAXYNfeSBB3r+72okGEWuGCqFBoQD7EfndVY +Ai/oBTqoC/w/JEF8cQ20LgRq+l74EzCx18tOY+kiSMnD6lWIsOt0YLKjQ04nrUjo +d+QbhPv3U2ameTv2sptxAEaGdJG+VqrE1qaVdwcWEA+8UmirLuO0+NW5aQzsvUKZ +wto6/qmGfO3pWB0+mYsBhmbU8D+5weYI8Pl3vfHYWoW1qRaMzeEvslmDR8H8GQfT +TTyb5SjHAoVR9BsVbOtcgqOezlEVpSVP6VWWFy9LAGScDELUe4VTDYvroQ2wwqRT +GvBF3kZbRtbKyC567wGvTODEBSxf9UEV935q7cA3Z+A6EfJ+0nqu214wsMhL7K61 +yYNurgMtPQgRy8g2HVbj8eAZTCh68FjooZ+RC+OmpM/wM49JIDNubblM+MIZOpHm +9AxJEsLlzYbf7WMXwL8vSESYb64kJIM79oNC4Xx8MoNUhqd8BHiGrlPutsiIAqYF +DGaF1XX7TmjmImjdgvIUv15yRsQPbCTUtZUpngwUWix3NItgsKS7OVqXEi6ohcA5 +bF4fbZOKQ/T+p06hJvA4jYxcmfK+ynEss1fKGo/ZWSSfBjbpMYqsxwFaHuVTwFHr +2p81/HICI/5DF6xVy6Jsd9FtSNeoYVRKEhzHSQ5l5MWr9O+Aqq/bmzm6n0UPL254 +7w5y1MAwd8YBalfb8iYEeg4gBBAyxgFaNu55O8U3y8Cu/dGRGrWNWYwOi3+MNqtH +97BoYrtYu63FULL/A3B0/7N3TJ0ylfpOSva4kWHPbUp/EfUzawH3YuA6CgbQecgJ +iGgAgD43P57X49F2oeYayIP4cP/JJETP5ASTO41v4NjhS83u8XY5eQkdHUYbP//2 +fXNZXHuiEE5BZL8RnGP6bdPOPK5bpelS6y3GL2X0uVIBWR2XHGd6gzQY1UquHlgZ +aA1Y4RE6CGVIgL8HloZJnRTBlKsgU4JEbsAw4IQFk7VGqMWpeexyyMibPJKLuI3a +ny1SaNBgjSY+kvBXuS7Lub3axMWKWp+tgnH0uFs6IXLoLV6wR2SvChHQDENTa+EC +80DWigu5tmaE/xbd8yUlRV9hGKW0/zq9t+xE0RMh2bkOY4EaeIGPRCzyiMW1ZD8k +mpOX6yZiDdqkT1CbpwV1xyYZbVheAEY9D0tmr+bmn+XrANzg/wgYbONsPb0A3Sjk +aIUVWuzfrL313MfWPQkn+EyhoqYgRhBQcFNCsfuFlZZN8BBHmooLmvpSwQJGo38q +VGGWK5IhND4+Df/g65kDWbvYLxtF8W+R9NqIHPysy4YRnXXuxRfijUkv91llB5mi +Y3ODpG38oksuEDWU4aib7Ki+uFP0i1TVTvH0QwFcOkmieTpbnro2xBS8GWCZarQK +SqnYXViFzlV/MxTXbxda5P5HAIU3JwgN3T5D/4W1HOZl/Bw1OC4Owmbj0LY6s6cy +ycgM29RtQlads9rajYWXh097vtwx/CZE3OxfRf3BVYefiVvTNLC368qZpz10XRGr +ymR6BrHohAcYVskgr7SJfAn2IA7sQwwjTm8k60LP7A8YwLAUB8kby/NHvWvvlkwv +GrRl4xCl1PvT68KyXhK9y2sU6kso/lutwEKwf3LvW4aE3GTeqLNytArAtwNLPnt9 +WtIomxyLNTzJAAPbKWbmUjH2lpR87of82LN5Zm42kcpG6ZDABI0UmH25gAx6eAh1 ++yMnRrT08t8AEunD5amDN5f+nWkEVvLOOwbniRHkELNpVDWfH1K6e2EnAYXDPWHd +eqeovMCocufmKvFTxPca2jkdGMqllr7rfj/13dvHAfhzuoZlwdwv3L+yJJIDAGT8 +j6GFgxuW8qaPXc/sTCmIsIvBv5cM3HCy7tncAjsCgrUT+v9fXGYyYNWfYWcYJvHW +/+PKHnM9SwnA9inH7Zl2zqY+AROa3NubUepJaml9azpt4dxX6itl4HYuAMDyZX7/ +Y1uuTZn32FFRTyTg+seXRGcL/y5ckbisw4neQR8A2yC3ruGU1NtpZiQ+5RhhskOO +xHaGQeXLe4UZX04m2NK648DZRJerFQsw7g6R7NulLN/6VKurP9x/uyNY8RzAw+XZ +G5rXgbt2d3cL7Ja/ihh4xe+ZoKsmLPHAU6U2nlC2FC7beICOu82D/uY84yJ6240X +kV8ErOiMdnZYQ0lxkQZoNamAYqY7tH8M/vQhRHBhinFRvMu3+T9pzV0h/f9owYto +rSzj3sM4+/k4ZMKxnylOixWXDxOzUVtPNHSL7FZ7i8ttlEX4mI+v3rb8m1xUulj5 +ALtYT6g26Efykz7HsJ06bshvvi7DBeVnQwngfQkbe4KC7sqENZlcnO7EOnMa8SbF +vEzzj8ohZLDEpIE4mbLr2gEBua/mRTpvsAwtwDPLfBI//B16G1leAE6692gal+3d +u7DK1Y1mBmm94XMvpxTr9ovKJ5nJNmtKg/DQAfSzmVyB3VY0ZeIZuoFwQYDmU9SV +I5e+jbLowcEiAP8/B1WXnEtHVv6qJcDNwU3fCibE0CP3YF69hyu4rvm5uMoOXsZ7 +SL0jFsfDhm8gqKf1WRa6p/mOkwUbC3DvZiIn1OsnGLyI2h1MFrOkrMCPnvSEs26L ++JKuKEEOPTXE+sRg4+cyiNTZbo8V28bKOJcXWDVN9OS8eMRmZVL1nGZ90Zmi9emL +Y2ppIIzG5iqr4Dh1qAgeP2Wd+50VnCrU/aF7yIEmwZTEYIfMN89qJlufQdMkzn+r +aQhEUWZ5GjljPl2FqPEAehbeaJAVXMYtwrATVX6fyll6YhgfjQlLdd70rimOxyy+ +XIATPj+aWWAHAZ1x4ROZVbtn+Tf75Q5065DUSZrvHklIEjXzXNQO1F7cca5gVrgn +Lu+hgncaSphNK6rUhmT59g2RcqTypQzfqdFzQBIr2gZP5FFAPCQLDRJbSEiRNQvC +cTUw585y3YtOMgHN+/3MNSj8H+UVbYdSGlD/ZNoy/Y33XHijDh8aBVgd0lusKJ6Z +TfCUeWh/tQh5xXmVoLMS0nXUoyVs/ojzME5VFEXyy8w18cfoL/S0t9czRMXLZ/NN +0r2M5NVXAdAnPs85GIDKXcksfxdAsLyfN3ZsjXs21aoNK9EHFoqZoCFo695DJ+Cg +3/CN8+F8Xrouz/Do2MWzHuQVyASPR+TfSCFKQIef6msG48Ekw9uGM5y0wlLIH+ih +q9LxH23dD+wm5jrWPog6dBL+iZuu2tOONObohoVFIq4hldwAt1OXXn2QWCGmjp5j +pfduz6H8+pP7DzlWF8kkSAA92KeOvRD9fty5o64y4OXfohM1iSChppH0U0iIFyHj +kWvDJriPJ5aShS9E0/Q9+e75WbauWLF3MGJmxc9tUqrn3+FHoPbSkKAVU4Z0BG9V +ykUxI0gCgOiHt9v1ufDwEhQVg4FNylejIlp5MCVhOPybMFhVRl7TAVAmz6NyCh62 +HbeYheyZicUBIWeQImPmFB7e3IRlXyZ7E2JUfC9f4EoPEYulvNW38thPSgqoBM0k +qNfwFD6MahxBELwerVpKQ3s/fpp0LDyXolkig9MP0yk60YDSWo74g5U9L4u92Xji +FdRrioscaXCkzOpjrEK2+/MOeY76Sqoz9zjOZF3TTLeECy1hDHPUX67+Qz2Vy7Hi +bP/KHUUnG8dpfDhdIIwI/+CO6as6bDqHoKyBMhQPHKYqN46Rsi+ecberR0RTcJHG +ulbiD2CB+7JaT50oRDJ3rsL7Ll6yXbvH3oMMZfVn2LakLHGK6hIKeQLxriq7owMF +CrpcectRog3wHPXCYEpytlHk3YKg3eNNdgMWBOL47VquMQh1XtVrhY4VN6KoxGhz +wRaop7IpzlK9sYXfpIMEiBV4x+V2/EuAnUr02cgAxZrHGzrT+fIQBCDGOqXa/fUz +LA8xMXrQsWsBdqF1ib5Ez+F2FI5I6G6PFghQyw88tJPptvuzaw3v0T9hXam5hjU6 +zkeAmaR3GSWHBfpaaZFwTipRZqhnf/NIsGrOj+CfR7GpG0ld9LV+uMv9V5hr11i+ +6EfYSbk/NIDF3XSxXaTc95dksBOJZLqjE9P/VCspGVGNEan9vc8ZCxzeyFhA//tO +Dc8AJoP75A7XTUTZ1OR93ZCeCO6QvU61D4CMBZ7lVmE/kXqXQBWkYX8YUny6EDW0 +wGPyIuDHt2fp+l7Qw3cZN1nIb5+UwOViM9mmukWgvfyIIgUZUPf2g/pmixB1Sjjs +6xtZ0vxKA46txLl99ypF7RhBoUcsizbl0cL67N4GfjS6eY4sDohePVPY2H/jTfIQ +O7cWizm7tOS/yOhxLPYyeJvCnGYTMUHgCbtK2YZUCtH2QUXmAVtsYIRYou4WmCrE +nhCddI4Pl3B18/5BaM7vH8UFMU/8yHHOQYUdXlWkMsBKKQVTHnK4Z0a97Ayd6X7B +2l2lf5YCUAqmsu6XNBWSTXj+DdJJ/Zgn/fhHg/hpCmSaFRaWMQT72NQGM0j+W2A/ +BZongxhgLSSrXGQW1zNvxsfkDK0kBEgodifkxDHrPf11HHo9SNCeOf0ihbqBEnSs +K90R+pITZtynMI646yWVrkDG21gp9Q9szueUz0MDrsQ91isbBmiMvtuA2jO++6ua +t0dpkRgJuuuSuoHL81ezpQh8/wTKFAdLyds+gP3Nl6v5dpFEZBkrWFFofB5HCG5R +eraC9ugLbPgDOFZ8oKZdkvPvG7lyvpmw7v/BcJGeiyQSapJ+wCfyOEDvp7sOikWL +/R5CxHaJdPx9rCrLXn7d6RVjSFC9HY40Bpc3pxSctSGiOT0jHY3lcEJsXVH1HQH+ +38WQYIQymZywIfNSBFWO6F1uVaeMYjyXcQpK2LBUGUQjPClzDHl+L4FOZ8QTEW/m +G9No84wwSfKv7pHITPCLhWIrKJsWa36asLmHv1C9A2WZP7U9iNK0zYnq+RoRp5i9 +VKDx3waehtACJy6YKWNzQUwRsgYXR3eC2qol1uKq5dqwpCcBmR1oX8PiHNRMcZmd +8rBPHtuY6y+KeKr7kixBSC3invL0VAA9fmPbeIffAjjMrpY7TgrBkQK/VzC55YdS +OKCYcItD8fz/LR5J4xjq9Cv46w4DkAki4MmBUxukWO454hqR1BnECs08rb3GDScj +yFs17263+n8/3JqMWeST+7S7Rcbsq41barCdQz8QCLXrqLwJUK/Rihsm7e5K4X7H +yTaM59iH25TCB6x6Wy65rEAwmSABM6BwAzt6ncQX0x6hK46Ef0VoQx0igMsqEQ7m +Qm7klN4MHToDdBWXnVZaFiY3bJlxmiwCMz1G3GAmCIlonllxUZz2CNQqNorm2IIa +OAo5nsWlAmvkEG4/qDQGOBuMaMBg2Y6uRvu2dzKN0LYf+0PLt0lAOMMeWGJt2dHb +uCIU29iULfRcie/3Bo+gl5FTbVnfrC6x0eFW+/2UxTHCobV1yLSs0yhBZVgY1cKT +7rDLEvspxPL1X5qYnaCh2uA2qCgXiDFaBNjmFM5KTFirTe+1WxFC5z+6t/uG/3/E +LnZRaQKrdGpP+k3s4eGgoZLzGQ2G+3uAshAmV1pfz/a8Vo6OE/GE/0YrhoAxQyh0 +wgdynLJVmEugIBbfSB4q3VzQV8ifSg7k95fWID9WvhMk28EdkTrch0d04Wumyyhd +OdiaOZs49v+Z2KF933uK2cKnOMrFaZKav2BhqmIYaXR8SGLvtrFvRcoYXPdo2wQU +i8ROUIsjL42zMFy408U/AkDZpGUWxXj41YUitM48r0EoHSuy21XdgLzTowSrrA8t +scFoD+OscFL/0S7Yis+qqpM8agaFfkbgZdLY/Nev7L0kInRP3VGck77ONViWXCFG +BpuFHnmlqnFa+HKOxAC3cnCj6Pl/PdiBGLsbzJyd5vQpvFqi3two1Z0u1TQWNvQ+ +FM6PbOCGeypNj8rE41y0HrXaAg01mw/FJF/x0e02oUl+m1og18CRQQJzGjwkYrv6 +2z5QHp0tGtZBsxG6LW+pBiFRbUzJDUwth3Q98gm6GAnMj1eLtokv80XJCQPlU2K1 +K+Zb8Uzno71mZEye8eaqCRcSDeBfm7XJ06nEWGoMUsYmj86/XHJh3sVqZy3clNa0 +8gKyRLFYGGw+JkW6i7w2sp7Rgm4FEfTQcK5xcBGcCOXBRyBdT8d46jOF3efqwF+m +j05Oq+Lwq19xK5Mkk0WNg7uWZ91C7QAchwMUDoJ49dT3UEOflGSfYGCtaRL8P7rb +wVsicHjQ0qEWOwWyVIgEkTRWTinUGQcp32OXMXme+1XTtxjKoc2kDZ8I892c7XHi +vtm+HsCF522XxHfLcl3zmiBWZGuwcye0R24w5RwTwWmRVZVQfyzVr4jzS2nbkCbO +suJvEGlRFkW+xzI4JqxDYHFKPasbVwsT+hxEi0dgW5VlxCEpRMwk5Lf7vc0jsXev +7Kf3+40uKtUgXKdJISO41GiUsHJ24rgQ0WQPj2V2UdK/hyW8qclcmn9U27EONi3q +gCr6vajdngo93AsWge2CFClQXMYKQ2hA2+zvX/te4DAyry0m8+xfhZTza7cw/fto +7IoeX0ZOuC9bfMOxzVaSv371gbWAUjIk7JI75xkarf3ypETqwCCkWNIINasnup2w +07zjJgXKRy641JFNmpekfzi90LG0hFhhTCXBfV5wObfRBv/AIqX/jQzF2KwGWIJO +PqLKnhbsblheXmd7HTJuyS7p+OxSlzZRnFyOOWfs+4ko4yvv8WCBq7iaf0FfwQs5 +Y+dF8lIfcZYTs9qWH/MKjgLbX+hdJMpYA7AcZ3bU4uf4sNtHXstF+AHHfAilbMIk +MGQLP64BrYEQlT5dBLJLbfE/E0jfRzp9Yt/Otjy4K/vJtooeoG5HwshyNY3ZEpYd ++JuLpt+IRF774fVOrAjCXBbaHKcIIq5UWnfUUsEvU6cftb65bEYvGF25qLBd6fhH +6cI3lzZTO5aEA8DGnJSX3JpgdhFewqQ4QMA/JEls0anVKIrUreOqBkSPcSy0TGRq +js+frInUHZUBMF5UDMX4tiLxdBOF60iq/tH1RKVWWPv1UVzt87PQ3szGbXp42kya +2Kqpjytl/ufX+C231wsA8cQACgesC2UKRvm91bnGKob8bldG4XNTMJonS5wBQaBI +gaz4GqxLVOJniWUxwq/j+xuL3QXVjPpWhJ616jznuP17E4gzsGVGrtoI0pgRVBxc +mb+6EPFAaeaU1eNhWEP/xAF+kOpOSz4y0N9TSgGKa88PYpF2E7FlKXpOx1eQE//L +HgIeG2nnlU+JssgU5yxFDMw2rsi3GPpljq2dIl1kFmlOMc3JUXxFAQXjveVTD6VE +9FC5TALudN3uRB0csRZQvLbBtxm8TuLVBTzBWBZWPiMfp0YvSI+Y5oz6rWH5cSY8 +pwAZlr2cd0HmKzoCE9TY4VcTKi5Pt9mX90DgIs3ttSFkc42EYj/7+WyJr9/jFA9T +AS1tcP5EViLqzKF491GO6EYlxILpfM7URD06WtsEqnqB/oNWcv06pfqOlrcTQrC5 +4UM03sPsb8SSELKaT/Cor6qLl9p224S+Nd65IjczkUG0kkOhUtn+sa8EuRDnN2cp +pbS/4XL9CtzfPeZaM9Lo4ciUK+tHPSyTfdjLoFo75YHIVkh6bez7AxXjAeg9TbJV +JoCekfgmPHXajZBT+i5rmqBp0uHP6gsxljhc16oekn9bM56v3undGFcvT4thLkDa +TVQs46DQJ0Ez9BeaL2GjuZqSxN/VHshP+IxuUCHtSEiXo7R9DUEPdJ0PAyLDgVbU +91xfzLKWT/Xl1FsZbhTvTGaubj3+HxhJ6bdg7RD+d3iNbyhCaBhxhEx/ByXGjKYk +dwd5gFhP2cw0NYGMEp2cWMAaJDqWIoGmnkz/gumuaZg/IaI+PEAxMjglsd5i1wcO +cVAJWXeeykSgN12vVL45uf1ZwF3Y/i6j6XHnyHt2RSgihQO9rnjTFgwD02ON4aHn +bIOyUXRmKoKqZ6a4NQvzvmUOU//xrsDYWO7z30sSXLbBvTqHNTJrBHxkqVwY7wN1 +2S12jYk0MmqQo5YtMHBpH0hRNHSorecoeYXnkRViClwh6nrC99J03PSqWsDyup8E +4BhPsuaRBHzazaV5gzV9hiO4OdmySv0ZWZD+jHNG4uaksbxtceFmD0+qJCfxdVbs +2NBduz+KegQ4lMBGXaVq2BnhY8QlU8y/BAG7pCFsf/Ozow0nm0D2nYK9EZSCPlkV +6CSH16Bz5poBNLC46gZUR51AhYNoV7QpH/gj3SkJP1SFvpk+qYoY54jWLGVXbZHE +L4g92qs1MZ4eMNsfQDSdSHpMZ0CxClxb74igL+kK7AVK1PhGhydZ5rAmgOg/lf5S +688JmwMTYWFDnLKzWZMVMjwBBAG5Huz1JpCKIB/wAXZB+qP67gfdps+aP/XW7ON8 +vHo44frFu/eL1XEwLQyHnyPf/SBmcWkLEUJJ2LPQHnkWUGnTZAQbQtqXgU68vDxk +6Mn+q+C+d1sCR6LpuRufYc9h6/799OOV2lvSJf4pwsbaFM29LtjY6qRreq3C8udb +Va8r5hS+4lH+ssUpLezxzvQq2hSbHkfwGC8sJfRsjyutHc7ADx06+yCwr72JTmWN +8VZlOY/inJx6k1ANYFHFOSnqd+V/ejy5ZuNlGQpZK7NPMLM4i/aAHe0BXgVk+qIr +qKgOO4Eyf8d0QvNxPnno/76YNQacuKRnP/Xj4tSCspb2vyd1mH146mdB0PUN67r6 +zRZdgbeTHAEjS3odpvwPLqa636jlNDKMaW+1euDIdbfeEtZCeg5u3ExbRGo6we77 +wPlgINcjGWA6vqH+YmkwW0Rlv9+SfhF+m1+1T0RUDaDvbNzq9m7pn4qFSX43gc9N +cj6F+RFlgLDeOiLCdrpjLHWYgqN2rm4+i/jCZMqmWXVWfG6sbJqOf+US86mBw6vl +7PyVVi2eJaBo11nlBu6cTSTtchl16BdAcKeAlNPJOlRWXEe4HysPbpgjTsVgYkbm +SPiARUzhV2XKxzdcZs4vCZkFChuPys9TMfZHM43aVb3B0O5QMjsLHS+G4ioW9dhH +oE4VIr/wWG2GUI8yS5P++LnlrKebIt8jAVFThX4Hp19p3NePPdM728vpuewxPRMv +pLuW1MVu+vTPxNZOn+IYhrNyv6w1sEpKBP14OaKIMSOSM1C8BQ/XlOEnbQoCsmnb +vCyGhfd9/rBUbqyfL30xIXSJdk/VaCpC9Aejo6mcuMqmapOCpLLn6fMgHqwXUnLA +fcARSJ5BUjdl9P5PBZy/dmchWbnM+vuSBcbQwN6Dr2Lkv3U0qUo7lj8wAhDIYUh+ +LFnEFCV+U1Swvvv6adywQpQ9et14iGOXyiZkTziDOIG4ocW9oODKgMvE/Qe7GW7x +2A63XCmqayLkCWHi/gZ0VcBoYNJfreU8GdektTLep5ZB+Po3hVJ40tQlCx/tieZC +ErLEEOdI/9LroH8mJr6TqYzNlEC8uM0lXXDWoedIHLdC6SQx8eDIkn6mdB7NIXOA +2s/JvP2M+84WSUsbcfxPJcMBeQrlsfuiXUpY8Ni6kldfcqseMOyMRMMqD13njsvK +j2grNPuqiM6+KsR1GMTArIpppoS10nOzsEmMNGpilC2Gv95FSpCju8jLVH6JBWj8 +4Km33S+uZ9Rb2Qvs75r+t0+XNz2TbtZDLvPR86W31FFhSJuK3eTQNovxoIzImb1n +9QISFmHWlNZbeMw96L4S30kBnxwMbEkHF9JVsOc3AilsfBjN+OyaVqtCujM9sHng +nyBydefCvNngS6HSnz/rTQTLfj4JoDty+rJFkDuJQNCtOO+sAdQflqHhcebmRyh7 +eMdzj4OIqyKhdqBK7caB2yFjvr7zliQaD5Ja5tkzbsWezyYlDi/zNZdqi56XPrVy +oxSCdTqO6XJbY+/gW5P3KHy/uMWuy1lF2tjuQ14JX4TGBWFfpgYNpt2gmXPYvp7x +JMTK+QoiaDHsBU6I1mQXheKwu9bJqXvR23bIORprIRGKauYcwMEor5QqGyfi2Uee +vQKqBxMZHa3QlOfRKAlRME8TjXXG4GQrvN5zjmUMm598eLPfS5+tNVOgB7JBC8M1 +a/66UWEKKeawXAjY9d1Z0a14CHB+s2WYJIc6pWcT54pBhn7w8rJnPK3e8c2qOG0I +HzHvngi2qe4hoTccNXZKq0SPwDS+11KGzGjPpF38q1gwkiOtiRHXQhEm2qKk6BUF +kLN0h1Bf5DkeR7d1rfYf5qxGUW2Cm/N7ExkwIHMVeTlWF6Jfpjp3zx43i+L3lSYZ +RQvKf3eL98aul6SMSbmoUa3N+xPVyXFgbiQ7rtSS2sjxlhR2t9OvWHiRjo4SPaa/ +XAyK2dRxPZp62cUfwu+kt5lYvOHQzhSGTmGHqD0X2dPv89uJR7DC9vuXX7sEjPdO +9hN/U3nuA812GXBWxXZvztlMd5p0M/52tjleOaqCLdWrsYVgVt8WtRudb5DiNzKT +TECNj/udGnTFQO5jhoyOYgA9cowa0LMfsUU5plLy+JFjqBiShrX9rFToSE2mz2+X +Ir3m5dvkGYaIXWg5RTqSL3ckyDbXOWwJRkXMn1isdhABLwdLuw6W3kjAZtKqnQRi +7KsI7bZOoTmXpJEewENhmjsMJ7qRVv/fUVRzp3Xcdm2kYgtwqPkX0zfXR5LYE8yz +z95xGloeHvXNhtZShZoGFYq7m/0FontxBacLKiJowPyC0WK+0aFCDxOALpfRpvP2 +bC8P3nXhFodBpqll3kdHlR11527GaDeGztC1tXWkuV+ek72kWjW7jHO4eTu13JVL +DPmdcZqnlDRj9jHYYWPl2wK8bChBt96pvSXzqZ8BGGngX5VVucJ04B0XXFugsKiR +lEVLbRM/oTSz4TwxDdRNSikrdTp+wsFh9KE8u9xN+aiLwkkW/bPNxWTGuofSRQoh +MuMrWQkyV4qww3BJ3lh28I3+1Yvqxl/oQA2sm4gik+Q/3o955XuQ1WpGQPtal4PK +NzEZ6J+MGL7WhoN7af4PVBfCgwx4pr3f9OgyhITO3w1wr82kQydoHuDlEJMfDBDI +pBJlo/KphzNXaieMJ0NOIjaqTp3mlqLucnQo8//o+irdqHBx4KWHGt6Qmv2cmSfp +xkh/l5guNWFC2yVsYzZgozNlUroNpX/WWszHSnRtIotEwpbqcRfLNcWDQByd0M94 +1S4fDPpsqz5rhIXffzbs4xzlNjAwUx0pjyZvx4vXX7/00jFY7a/fM9/L9J6ntacS +vZQTqSECVqyy0g+LIS0h0fJMo5K3RvA/3Qjz70Y30BnE9tSZQsfZEHIT0GzbwvTL +mccJGTjfIROtXDK+/DJpaXAiLeH1j7xThXrCY7lSqjupl3odxBpFo137eGuqmbCp +YYHXXTnRH/jZTel/6sryQsuj2jCKq+zPgdupSmimpw6G/C2nv+XhgukgIpYmxu9E +AIL+YmqVbTzC/NxqI6h1g0hkeixc8gICqiup9gJyRysP8CsprengumYuCoiaKSNF +FTnA+ojtU+Wsg2pvbvgC+8rww71ze0KJf88DI1WKAnPSt6cE7B8vlj/wC8LNONjU +D3JmDxx/ENPCVXDpioXxMP+rf1GcYjwd7y/KD2wDvd2XPuPh7llxZcJOfblqBCzw +tnqEorksT/6G9XjPen2w+8bOF61S410wv4dFt/4rFM+8kuU+eyvBlMSU2rMt9jKV +Ocw2XdP5zLrGNQZpOopRiHghusD9hm2CmQ/KidxrWk3nGenl6E80aCr8uBg8wvgm +SRBWHZJHhBGpDIXnOdVM84QEguMkzojam0wci8dvZLHWdZ+dZabUJetYX8fgNEqf +3NRfKufpcSAbPXYIP2lFqk6cJOcJSO6TDQtBdq/J9dOD6r9y2PkxGDhJx/MsJjmM +IZGTDuMJZV14ocZju5Nqae39BQRpAAFbHI9+eyg2D3RoPpvDuqEBklTfI0Eb5Wj1 +cyXJ9iPXVyJ3S9x+sZ0PdeWFImY4LAMwEuPYZnG+xxi3r0JqLFE+Xu5HsZC9D3Po +7aVJbbI4n2pb9a8dhQPU8Lgy5cul2yCnk/6W7lxiQd8YVvx3+CN87evX28xXM3UO +ofBmTTLBwAJjeMzpWOII3acU0PpRf9Uuyb/SsOWQrmyFWA+MK3ogbno1S9v9dTkh +L97Lg8h2emVEN4W214Os9EVCDYhBOZw9nmaxN4r98L4nKSsQMvGNtJxOMCBN+B5W +ol5gVdqPDo6uESTi+Sv3OUPCjfBHVYY0slm46Df5EPEpjhqzmrLOzOkZtj8KU90U +eKHRWecl3pbteQcj15OkEJT1C5X56kU2Kcnawvd8BuHPLjc32qNDrrVlCo4LBXEd +yMGQWRQ/waGkxMcpogR8MfwW6m69p2ebuFPMulBwKAAtLPzdi5ysvgxostj7+rlJ +t2YBtnhKTEFQF+wUsHmWI/8+bwLyS4H4tYrYXvBTxos16+HyK56bj3urckpPBYjF +PPBwBexLEsC1xzu9andeaNSU14gL1ionl+nk8DB+9lp2PZ1DLd3PvA2t8s/nqSrG +5Af/ph5gQfKOKB/x83TXEheRU3E8+/ubCT+YXo29JtTjTuxc0fuHB32/ntjVdwJ0 +DtYzute4scpEDLrZLrDD0wGHSWqFn5VnOmjkmnOfcvuFc0YiD6R54U6VE2TMisZr +f66895ThWL33XH5nov28rjdNVsVgmbdutlC4eXqPf2UUW4cmqtj2nXJAZRhfwxHq +di/djOPLcTsQfdwVGj68EOj+6mkl76Y6su/woppPilGmVR67HNWKxzJH/KytJe5m +m/8SNo9UUVe4ZNq4TaHG/S5G87Wu1BXA/ZsUQKxCwiS+0SXDJGm8tgZsZdvWWCIx +jbqU17lp4SQehYYEk4LkbVAiVqRt0vRAoy94suNhlBjHA7LmK4VDhkLKJayUv09o +atZ7PEndlEAXfsHtiIJqit1jE6csr7/R95h3h0XfgjVdtBUkjGhiEYfpFkUd/xLX +xDUKfCeKqhzZHGj9SaKON1EzjcgCSHTp9hDtXo7eYyPe1KS37mlQhcg3Iey67q3Q +t094iJG1SqFu/bK9ju1pbBJS9V7Ji9QLNI0QcQt4Fs5N16GwhnBnm6JH0fHNT7WD +wQe3pIT3uCMA7Y8axB2teKLfzAgZfq42qqTh2eEk+70szx5DERZ2nteD0ThQQK9m +lf48tdfTiD8zTz9tZA5OJ+ENBDELHjHR2x5OmSeicDVSC6heXeSEYkX3l1ld/ean +wjSxm7uRdFFGskZsVI5yk2pugVrCocgyr2N600paCt5O0ImzAzqABMtbl17L5h2P +8W51D859ezw+baUaxdMXbdaVB+3dqBPBf0cvFVBl4mktlN3F9KHZY+EY+YwiHz04 +IE/VCtWcrJW17ckSnVo/WQifj96ZK4MiIgPdr7VEevj7EDpyXj85Vof2vxs5pNvF ++McwGAopB2sTTQ3ZoDqYTnAyG/ZbBico5u8HflcTcCEqeHq8VU+Zc1O6u+vdr7lr +afCHEa02QT+eILngxhGKYPstKm9mWoaGY7iw07bT09FwaVu/d2ZTkRI5HfQ0fBPB +3c44lor/bqpzqzSPzSC5929M2H+JbkBFe6vm/QpMxHlsSZsalomJGdIb6aElu8H/ +X8r9tTySRWhfkhqV8hzsHMmHRkhThzoeBihIZvYWfOxjiKSe9oY+3Pa4288yFftv +0Wv0D5VjqvYFTbxvctFvnl8qvkAK9ljXPHCHbsywbk5gWETBkvgz5Byriv29iqq3 +6QHqWUcFiNiR18wG1PlJvn0+JwbfRxqSdUoa14Ww45BjqkaCe5IuCjkp6aRbiUVx +8LX6q8uh7pJnM0MgO9wKMkSbITv19WxgWI4+4EwzBfK0IXRi+QCQXY6+pFcvvjCx +anYpkqnffMSPJwi/1CC5vgO9HrTemjdF6A+0TDoM1yAIBG8UE+IHVrvPVdOpZJja +N2zqJHHhp6AC1O2amCUl22olTWVPKIrmym041TIn09qbr69Il19afuYBBRzAFLSS +PuQm8YFWeAr8LzkWhaooomxNBNhyCxOeGar3ilFmZLrHUI3ooEeO6F1KrIrZSidc +Lm/ib1fBAE9QMHA5z7M0IxHIqMvJ6NKl3mAaNxf0KBydoEpWTxWVrf2/miaNpcV6 +NxMnDpuw7VyWOj6/jTgnnSG+2TuRETN27YbWL0liqxuk5ybzXWiaGBZ4+bVSRa2F +B2hO1rUTgmZOTtqJ8K3Dki/Lh7WB1F2q1/hfyG6gTLr938x5QK03VlkJ0Vy/rXR7 +doOCCyKoADmszyEOT3h0lBHoOdo2ejhDP5Ng/Ay9hnVMncJffvnCaR/p58X/A+SZ +tj+zZV3db+aHtAcorTNf6XFJSbJDXfn+cvKHzFT/k5lSQ0MivlMXcLeQzRj/SH9y +QVTPplcj0fCUQcKlskwkBhFZUJXqCBhDCNyQlSW6ZdU1t/iIaEim/UBf3bK/wUax +xE3dplC/QJrUsR7v7wtj05HfetarfyLTsl7UH8b68FzMT80XeRma6E4zceb9rt/U +S+Bp2by8hhgLLCD9QsQbZWVLaScTGh0s3SleCC66hO3uLdCq/s/ckRgdUPuJbYhi +dkh1/Hu5ld9pItt/n9Vr9pMtoGCfJ0QtXLfisUVZCVGSSS8dWk8fz5Axm71RS4AV +B5QOQ4ybXlnYV3Yq+iROUS88t4crqLapv5A40BQsmOeo/c9+GqHSkvSlbdyvDX+H +T+tnLP2e+04gUdZbJ7vjk+j6lAQJ0moL9X/m4ttC3YioDhBkchLC+rNjeVpXvRRL +V6Z/lW/xtyUaVXX182S4A4/dfATlj5VGPdoB5LFaUy8sDWxpPgNt62fu/fzQf6G5 +Ceq+LGym1XNst3RuLhjF4v2QSIplXDLMyi+VpAHH/SMqXd9iKJ5bLhr/w6OC5qlN +C9ifS7Bn0cJZStGhiVcP9YiRLXsfisn55r+lrtNxRGUJYLSHuR4VYn079M0mRsOj +X9w8MccM2c2JIA5rXABZZ/5wKgSpvlue7r8X+NY8mj9bO70w7L7eExs5lhK7ROFP +pGiu7DbpnzqK+RmpW1/PtFiGfmmiM0s16nSskW1chsIX9mbTMZsciAUBhqQc3/Ze +UI2SQdE9ZgzShAI24ZMPjOAVAZX8CBuix4I+QCDztGks1WRvEn2G6H02tdCnOSBn +4MNKdUiKOg7s1tfNw5VgJ1zlBtQLzDFVnj83u1vrKkWMe6QC8U3+9w1D6HzLhSlJ +GLHjsh8h84wc+sZOH/ma1XIgpQHYum+bB4kF84JUlhjb1g/w+sN1HPobuTGJjXhM +ch715p4Hg9rZqAvXScnqlXXUc+sVz6JU8N9Hdwok+W09dld57LUsfwUcpSaOcY7z +D7/D250CMAoiv1+bHDaR/Zryd5w/VQB4XJzuhANYHNvbsXSVNqCySiyiSkVIjd/8 +7OPcJN7BxdDRgF7eCnBpJMU7PAtlSVTelS/Oy4F+TuVuXSXEiIkPXR+Egghjboc7 +KtGLsOi4YyDSfjJtugwwL/FJdNYA/U+gxz6hZmL6mg4Xq1gNnKs1RHFDvQwO4xQx +hhMn/etjhjBtRECoGMVxRPYjG9GydKZdiMeGp3oy/0Vny8kVYH9O5z7l0vPayqvC +w7I/ok71t5hG0IGMvP4wp96bkGaCBcVf2iJwegaHl3GJy4CzevqtFg41jLP6hH63 +EUlKwkRDOmRR4rz7TtJA3qrd+GCdT2NbFTV9/Jb+YACUDi3jqrKybqB8kLNQ5FIs +0851bJRNy68LC3nXkmePlauGDsaV8a0MHG/d2kTxYpqSC+8Vk4Yofay87yrXOg/F +CgVx2rAToWfRlwEiRg3wshSypZMJqNtSZeNsLMNMAxc3WdtEcnTFmcHOgWDiuC9j +vWaoXdF6UCpbZ3e6KWypYJOePwFVScWfYzkGqyQLb2ntkJ/eKPuHz7ikYfpJe9hz +WCgg6KZ4O+xe/g9YcgnXYd7x/GRC55/z8r0zkpCunc345OUvBRie/PkPswKO4hWC +wuqYN8BNu1VIWqhmRYmp8OFv4asPv/6r6knkX4Wt/oibAqqwtYFOzJTpnDEcaVBx +/rQ5+x/0qcyMxNEEiHbf4UYIo7wuujx2V4uDbXGyqHAhSsJ7q0FnsVcKqqn7sQ9p +UQmftyegbo5ZtGDKcuFD5mes885i2o/BnO0/KjPk+45hYMYWBMRRR1lr66BGKUjt +cw+mImMvYHKuh4Am/TB903yfiUbVTWWqKfV4xPiwm8iSsmrI6Lrbui8JAbJoNf/j +R/qP0YFTfWLYZ2pGlEpfNVrm1cad7pfG4uoKLFm9zshiBuffhVJQ9YZxfofWwJcq +oInNz3BKPVk1l30VN/5CHsUcxJKJU/Gc5bqxCyek5HXnN84kbxl+1gQ0/nZxgE5i +RVWCAwk86aVhVavXXntHUaXGS/ig/Frs8lH7vvRXfHsSPD1FNBXA6zEIZ/FSkuem +Z7Z5lDzXi3t4cR8FJ1GM9T8FWZ8h62SbXRGeJYSKdtiIicLQmsn/p8Z5P9HHspH0 +I2/SDYZortI2WYNUfOlro6RE9Z2+9r4wcycXwy1v5dimzH2Revual/BDvR9RinS9 +tiyzhYSLIqP3p2rO1cx8NBHZz8ew/GQpRXTJ/dEMDOgqRSBfCFqQGi6Ktquf5Jv3 +idckRpWwFbzBybmgSy6+zDl+BkB3nyx9+uFPjU/FdLRjfP8AAEYMLsTukM8l7n6y +GOPap5+V+9WJ4Hab0gk3S9DpYRKrsL8ow1e4VQeqaTO0hRbPQSmtHYjjSSDDbqTm +Yc3vbx1Kmc4LLEGp2YO/9scmm1GqewCnPKl3p1OFCqgyxcz01PhSYOphuzgouyeA +6LsziJvuvSSrBqgU6joVdqqYV/SjncoyP1yX1LE3dEccb+RiFtjxMrXvRD6tFfEJ +3LIZTBiqIAv6qo51kWCzeMotxjoh+BpFoxp/oMjbnFexfVFn22DDXzAukNlq1hLL +5XPIxeTesjIRu+wk8lXteZKRELk+rYP1M/Hhmm/Gf5FqpGDAXJJWxi87MJZF0Ua7 +pgVkFELGilSp9xQtpvwhACZmQuvV8pT9VnN2VTD7jIY7IbTqcaKyzUNyUGYmfc/j +BjR92Y5wTh9Mb5scuBP8AnTtyISee1YIsy+bFBUQXTbjkALR0KJPZ6QPF8qrGeql +yyUAf+5SDxQWIzpBaNDNUp2oE92srfAwijwd1WLn6agVK7UqGDhzQMxjsQJfPKdy +pfUHDPw0C7wDmJ8EpK8dWY534c9VYysuRmnQid4gVw3euCIdxqSZDs53EYpfVe3b +aTE63PKo3juu8XMPNmIXRbBUEWEZaJWJFzHZQdiRtXadx2q+ChNZn1Wl6nUUvSZ6 +e+0kf11ih/wQ6dH98nbGpPXUTUjmtDk8mnSwdnEHZg5tNbeZw5BZwKNYvmdTeP+3 +fPcnG0htb6Do+T6l3xLmPihFyoYNWnekkYR/Z3zvIZFZYyl9TVRRMx8NxSGtaanD +D0EI82HZBg1jtbZvJQzUNBIHEbGXT7qhVMzIk9/lwjKDCc6wbId/N1JxlXbI/tkJ +hBGVLStC+T9uMZy7F2ERqhxc2gRfYoeovpYsO83uVbU7I7S6YGj9rJxvy6cz32Gh +nHqfwpTcTsoldoGeEFnUfuQCZ5x2rf/SdYeqvoaG+3QaquHGmHM4Bc7UDAt/c4/+ +2F2+qXmgY1rLFQwWPSgkf5JlJCq/ac0Pw7oxpddFtdb0VGRZRcwbUbBEfwwECe0J +F0PmljSuSguIugYOELromPLxRnEru7gpTP2gCiys1cYT4Ye2RPX3+lKvDmU+f3po +tC9EL3HBd9oDTIV0Uaaa4Dutq8Uy+KrZQMlNqedytC8gUcRysczidFt/21Dx3wsv +DqiWNv/3mvkgBlhtnnPt5DdXTew2RW9RWkwCcHsVYA5L9HNOW8cqNX8I52sewDeq +dEC9x6YZ9d6XMU+eVZZ1fh0z6mUr64r6iFFnH1ojuv+zfLpYs9IsXSjsrL2m9kJQ +SswVss31Migb++xo7h1oz2fOQ0g8F4HIFX8IvZID1AkMggbY4cLvx6khukxzR13s +out8uIsznij/Cnl3bN9QslaQjj8WH8RIA2XZvo741AchGZULl+vWm2SFlDJUFx0S +Cxu00d7+v0+qyzTQ5+WGC13B7aaFrMy5QKvJsK58b+qkCpfZTWmqZMVzMwRxhqXP +xDRla1fgc7bOY0hMLucNCDPBLz+9Z1UGWEzJinsjhodhDTRjQUAAKeezDe8VcRpc +iq719xWaiyFIE59nE0vi9uAaEClox21/D7qKyH/bddy4Cz4MEqKKzROndR9OmawT +1prLIXriX4MpjJY8u+UeA7OsAuDH/53+Adbc34i3ib+7na/DPNHzeN0WlO2E4wFH +BsGofhYHYp0mqNTqZjZQKFKNC/gxczh9cqlp6lqrBFk7tldSwYNZS538xPfQe+2S +bxYIzlYwaW4j3Dzndpiya2m/TFWcXfdrmJmHQzMTA1RhDCuI/d7rsrbXyp2+Ha45 +JCxNdsnTVgcxpa35LL8jIWTw5wfKdtWhb8+SWgLM3KYAivvXZWMFV/p/2iP0VxTN +iU4DQ9Z4SCwU+Sv59IWQqPM4bAzp2CytfRjmkRMcYRZkeRNZ/qDAxs54fKvHAHJ7 +jUTkHpDYtaK8u269S7oFqRJv7hjOmXDMd3tWNfyrVzZzNYo66RmMVsq1c4DZDxpZ +ERcobd97RTCf+pATCcjhF93DnE5dSdF3zof9gE+nPa1u+QikbFIPz39/fWVvt0ty +0g/Oxohuwzf/JcCmAin0DDgzGJeRk180GA2pXJw8oH9eWtOH484SUE/2IKw3ti3O +Z82LVfOm0hX60HbT8FQJiI+7p4+9khm0ajmSieKSetulWEaU0ZOuc7BvHyJrPkCA +x2W2nIjFpQxLFWUbw0iuZvyFQ1ut270kHOORJcBxDws8/ydbCJiYXklbqzsZ3D33 +IlB+eBerEgCRx9JipChSXTOkskpa+7Rf60jk7KkXc4wB3wbeSYe6QNZVIwt0HV8m +10rd2JzF9KP2PSbv7Si8fjJtSk7gUkpyKfPyHBkRhR2CbysWwP2u2VBtDZdfGBL5 +XXalZWjvIzP3N5O2kuRctpKMvSsxrAsd+Qasba8iItdrMc9/oPDwfWEO71AYXXuG +f1K6VrF4H22dL+xuBqibkHA4oCstca/YfcmWefqQ2702EjZTEoRy1a6VhXaRcBJy +eG7EgnFXpSOU30xSNvwny8RsU6iPKAdj5Y9UfF/OS/FwXvdHI+/3MNK7yDxXqko3 +GMRE821L8oqozqqzeFdl5WVOU+JuQVIZ9nilqhh1REKseQ/w7jTiqA41dcPBW7lu +krtJOtRYCRHT+Vk2icns1jN/NQoXS3Cbd48hvH84ktf7dO02aexyZN5zryPXYw8U +6xbiYWzuf1xSGRW+HgWlFdTaNAUiPn3VWYuFRqpUPuaAgQRM3ILk8y1Rs2owdlpv +66fz9gPtbpWQeCkwa0HFh3jrQe+mX0k7N0PR69bztuTSJYgglubBMXL64lmpQSIE +r5LMe8TmN/t+kXIZPbKr/BRvjWCufLQ7h0BQW2/bn2KEnCjE+4ujRgMiJ8L6s1DV +M/jev/Z1aet0lreROS+xI0PPim4lIuPTFt757dmkfaOS7cmYEamMd5hlLiw3vt0h +1QPYIzGD3FnuKH/R+7LG8RS6AUIZZytfm+5qw1ZEgMt5q2AAvjg9+D1CErO5007F +TEGaUz5MIcFiFVbagqvxd4q2C+NiFjeBYlDAw/BUoqRRJUBfmR+jU+2NTVTiBj0g +BtLYLk5h5n/hOSkjoVS1cCrxtCTZ1TxkrMt6C0ERB+ojeqc0c+H247NOanuryQXq +yEG7RPwlB95dJddmt59szifno3zaX8NZG+18J/H8YAONyaYYGgCh4iYNgZDWcKKc +J/GfOHPvTymFRlaMR6jwh97ZuOlJC3qgqKoWZhx4m1JBftI97T2c59sozaaQemXA +Mr8wtYukclIumKMGpFGnW9sko8k+Hoeag4DWMQvfEM3qPGs2ff4crthqwOcr5Hdb +tzS4slUjk8eTioQvOKF9H0ymN24AdVwvxwuiUZdsFUKG1q8t3XghdrROFdKnWUPu +R2G+eZxUua1PWBqYj60PMxhWZ67xMmPw2z+Nzfnlu1LtcnkmWcRH/nwSiaDxHqzI +N8mUr9oSu+2WvVH9Jchp2lFjzFro23H9W1iVYOFiCXwgVHtJ/Psuv0SasimQSTCY ++1NhphcNIZfK1G3GBWHwTqHdmdv61QXuUlDzvJU87Hbq0OHEkX4BFCYv9O3c36ce +2H2RxIFCji5SlimYLeTG3T2gtyaNsM4smutaSimVl3QinzKhfDgTCumAJgFaEVdP +hPicaApmWBhbpYBm+i9IMvC4lXkl1gy7yozvhAHobyDnBdFm9bLq0lavAo04VUQy +CCGc0eV46xEOcdvQNrEbKaDbXbF5SnhrAN1UvAE99cA60NwSuC+AFRph57RIERMQ +wA6rtgs7YYxO42ZXXAvbRcn7RSbjVnq6JGNmi4YGMU4akLSTE9OCwNlc+x2hbdkh +nGwaxe1y85iNYAjZzhjx7Vemq7wX7YEAow1hiVEC+PWDAuHQ5UREhGSStZTYZ5Ky +CRKP1ZeKDDChVRTzj22hb2qasszkgvrSgTV+MubgFwJg69vuX6Xzu690Hh9h5bfz +bgPCF+FTVIOxL785A6JN9qCJG/7ckBF17KAeWwMFqqm3TzRV8eJGPoFQMceMRSzu +qw7oXTRddZsVAE1l18CJlJl16fhHOdHmZW9WnD3NGqC6LW8HCOoQ+f1grcxGDCwk +Mz8A8JSHkp2OPZBm7STx+nS1TgdheL+ERZ0lOIUmI56jK+Nfj2L80igv2HtfDDJE +uRsrEoqTzVermoossu3aWYr2nnmICgxZOgK/FIfY2LRyoy+v31cX/v/6RBzxln8g +GgO7ZuTIVM4squ2YCTd9udYXKD1kjRGxr2D0VjSwq6xvrOkBMLcy6VGF5FJsV+vK +GBL/F54ATOPO9oeDSRtWXfO7uNdaU8X/fKVC3LbBmVvOtFOj0FX3+5JLGcSkGYwA +eCDYebtRN5B+ep7nND5uk6cRHyIn+hN+Qz0H79pHdyqp/ZPR1ytv/Xt8cSAjxi3s +Y8JgHPwV0AuCyuT9wG7UwCUNQ5jB/jQDkW4pHZpftY7SsxrHzhLmC3S9VFD3PmFN +y81a0iG8CA4OwbeIvwj/rSqwQc/GZNIvWQZl9D+wjkeZ027KHGA4GWgr7hmWVVvH +PP/jcsRxbFIQ6Fk74fY0FlDMLta6VO2Sri6rNQfvS3yG90Q5Tog8Zwlv17aqYQRy +nzZnwj9zzIEhtYL/8uG3JHa2OGAWpQ+s7kciAOX4tB87hgDMzTg4349tD4gDvUd5 +eQhN2I61LhTCxzwy6aJBbvdsrjfar82vLYfOXpuvcL1FN4OfceFMvCYyW/SemWZe +BjqtUofZloinNKOrHsIewWlwMwANaMvGVZCnYPTyhWgNRApx2vrlzsSzBxuR5nGz +IMcieccjLPsZFKJMMaRFaaSZMHBbOdVmqLXB17Q1yEhdPnoi0QipAdEHsLchu/Dn +TOr8lZkc+I0Gm+fHnksZ7PT5AokBFypiRdYT+8H83QeKiCvC/h0+yuFvoipdopGX +u5Rwhhq8InhHJd47thFHIXSgzveQHjS3YuTzJaxulxWfLoCS7VY5Skrga49NzNod +FfrAuzQJQqfdTGP9IHHNlWYmtYTUA+VN4vMEhvCBZsaeRlGJ6CyqxPLr/Ni01/72 +PuuYsd4rU+hl8ZtSKnUkYfUtJB6XbXnUPHp81XmgylnYY816ELUWQ0x5KNugIgTQ +OMK20iwC1lcONAHGSvvDPvEV/u5vl+G1cf8vBnLVuFcOw0uIfvQqaRSnRjk5EWsk +vfgdkiy0m/Z9sj+VCZ+trNVQH5acoZ+W5Q39602YroVUlJ9C/Lt6HFubkfHd4VVy +M3I8XqLPgOnBVGiVdxIHF9SAC1KUk1qr0ThgnbdQQc4RX+ZoDUWDcL5hy8kMueAB +LkuUp4jfLdY7hGOrI5PJe0dNazg9Euda+B2PzQ4FZIatzoD2C9/MMQg1JDiokqx8 +ijnbZ2ppwrQajYqoLywxmsavN3gu9cqlePWCLYNUHmlinG51PFvWa8uWW+coHY9O +rEeTwK+D7XVusrJo6Ujx+Qas8U4b1Er5RGV2OIHYP+U8aboUkDDMU1VvJJgiw3Wb +5Q83617tOZBfrcTfeXn1Zv+P6tKM22kDoX18ONzTcXOMIOi6Tkp46Ac5K+rsqJGb +SLrEqFRtKwzhYwG+IYG/37MyK0MRMQR5TMjaMNk5dX3gF6LlDq7Yf2XeiYHT0dSI +ShMKJgRTwVSXj/9701JHcCpSxwRxzlh4iak3Egp3+229JjROxNWbZZSyKtC02UW2 +vCc4nLOg17cvAMuEk76IO/aKfGFa+uJoDhkGS8/cTv+JqGfSigMnDuNOj1horqY+ +Oo5/zNJttP0FWJlRBNPnUcnWjJJqwN0b/Momy94bdsGawLwyivoMZKG2nBWFySXn +HBCUfG6ckMkE0pm4N5SPfnWzLNLJe/5kRgPRkRB/+BdZWEMTtJMzHEBHwtWb/obt ++eRyaaQbv3KDvDMvODrWy2DwKKHV/ZaKGNPPBEr1IErrPFGuthnONcFsAdUfCggq +jmvKdGr42/vL1eand55z1vdfMVDNjD4lQVkxNTmYRrp6l6SP3CUbgJLBnzOw94/q +n0ieA4lTYm0DNe82LoEp4vTtRAsTGDNCXx/rSVt1xYkaLoOzcJaSVVQcOFkByNSW +etKcXD+6Y0atwFsvnDkrlSlGhlMRENYblScSNPk94dsaooxUXWjtVuM/RF1rZz5I +ijnX7FcdgVnUnCQ+6ikQIfDb3LV4M4WT7Jas1DrbnS9bfe4WhcmBzyXRjcwhwa57 +UvVtQZDmRIRUmG6EjBZvW9iuNEk/It4dLo4yEx4RSt0zdNjAmseRexcN2QoD6C2n +ByKCKwczlc8C/7X/GwvZ5y3DmCrzvoVNn5qCEQWvhan6RVXsyPMBb3HQjTos6idy +haGb6EF4zzjtSg7d8KcgnHXaZXQlifrLj7sN16rExgglpw8Xfbi9xEb+bLzomHD1 +OjcMVU+smNEIfEZhxh47ivDuCD24gcl7czYso23YQK+lvWvtkcKV3ocAbP2saquc +nYfB/oSMOrvnIMZuVinUWeO+XZPwe8/xVKGe5kC4aOcXF7U0L3AtkNjll4vcfNgS +W1lPC+2f/qhK7wBM9o2g7WrMIGmLGGmH9tiGsvwz8UiVXZw1AeXaFs+3feYaI4BV +cy3jLLLFVBKD/QvdqVnDXApNqDVU8h3wgKZONnXD9AwbBbKk3L54hGQhtXdUn93f +w5ExALEMFC/uOnP/AHr1v0l3lWsW0aaE8zvUmy4qWpz07Proz/siyfjJXBlN0qI/ +UqOMuvkM7qg2v0+ebXRaO1Lk2/WzcdDS3aIlGar/4nWKuiYhfXuyTVCjbeUiEbsx +wNflxhWqvzJUygC8USFnxen4mE5RsGKXOVgyB41Ok3avggRDMF6UAAWbrLXnxDHD +d9umB2XpopfQh69vfoZI973jxdegzkF9CFNQoN9U8T6pCB6u8c1X1eStvaqE9bwZ +2+u/ONYH2bltrb3yJggupjA57pI6vF/UL3JWlA6xJojL6Q+Dru3oTbYgdlOBusRk +LqsCIIuapMJAjy9fB+kNfHBUt8rRiA8BNTYm9pplspkyhpAmdPl39+VhyDTsTMVr +OqPn0c4BWsYBQB6i0EUBIs1JpqTG9UES5mbNek6ddpk9ON6yVr3bsChyAt8ioYr4 +JjBa3ZqlVhBiivEpdbtUaYVtrNCzVMPz9275rmAHpPSGx5YC9HDWWSm23N5pSuOe +xc2IUz7YNRZGMatkWpKo3Y/TcM9XrDDwMicyuCCYh2CIlcBan4NQX0vQTXgs+YZ9 +RjJ5+SlNuhxkd/rQdEPo+OKunFWPaS0ETEiKCAZ8VRAg+Kb2fmJHJZHFo4wK5pIc +O9LG9jvV5asdx6t2BerpZXbxbVri0GGvvCrKSdNMeSn0bDai9hntjoPI6NyvOB+k +tML7kZQe6IIBbd9GGvtvhtF4EPCooMMQMHsauyYqM3z9GwxgI2RGbAbDBU2t/EzV +cIYWirqCA8O1/U7CGSiMxmnlMa2Jq7phdl88xLzwP/UwWtCHviqvP+vVm8uV7nBr +sbAVZfPWJP8SUwJGrImPwg/c9OPXEx/Nfj8WIuEszfp+mqdr3u/5M8QgdRAuVBmU +rj+A7R2x0u6qzRw6ip1+wY0W8zIZyuBnLBT+AxicC/1YEy/mKVbdblj0bGzyYuUo +zGqxnoJuMWq3Ckx5HMgbNLHariuFDbpqLGXQKy2ImkCL6cILQhEDdxugCHTq9Sx5 +GGOj2fxvDb4p8hxcV28j8CiuBcxI/Ao31zwgSE9Hh1j+uJ2W6+D/lf5RHRLh5U5u +Z6LuGpfDV2Vd8XoQxUu3p1C1/EQadc0YxogEmxskEZeS4eqwLlY55tS+qSXm/POr +nwpbtwDKYzAVHn+kkilvmqf1Vq8OH43i5yvKjQ+2ZqkQ2UvdHba0nDr2sRA9QXbS +OfPGOrVe7DdhDf7uKfXQerjjyajHoBedgfhwJLq+lEtXB6wHv0NVs4CvQejOl+3F +Sgodlr4NvuI7GUSKaDIAxCMzgRGjA3cbS1mB08GIoirQ4Ge7fSUse1pXfEyEX8k0 +maWjL2m64RsfoKiKIFhAvcgBJ39eAN1ZMP0jrARk3BhoR12zj0XOTgZEs3+rQ+en +2yMBqtoIX1YnltW/wFrTEYZVHzsOVy1p8hE9yMSRfklSlCl5aVsWcZWmUSSPUuSY +PiC5AGSpOA8TaTkTVhWx35UOI7FrbCbkQ32ARtODMlo8z43SF8FzUx3vA0rz8v0M +rYWff0KQwhzMCQe0oW7yOunifKg43Gzfp1CSR6DuNxsllOLdgzYNRYmhVTvN4EyG +aSeCNIZKnmON7HB+h5PsciAnuJK6uAReh3L31dft29k4FNOPrYKmxVj98taeiEUw +VrqN0R8TInknMFI3tYVnwlOhor1cBAXqQ+ksFvwbK+67C2CDwLljp8O4aPfsKppf +qWgO5oloL2V6j68dzrfKJa/znee2d2iWICjyk79RlJX1D19olwYQWFaNQFnuQC2E +6IXjZiY17hAbmlQg5ckvLNITppSbYXldEImUe/9rozPxwMoljDTLUSVgxwPIhOUo +6zVgz9bo2F9d8i5z5REVYyuUCVzAV5i5Gap0XX5Sr0OXSa+kf1NQGeWh0GlqB/f8 +/+ucT5kIkya+sv8LdeoJRZj6zOe4ew/r3yJ1WBrsL8HiUfMGCuoTevVGcIS0S4Xt +FPTCWc+a03CXlji1rAZxkEdE92LzfoJC/U4WVL/SL18Z6UtZhzbVdcE2ih28n23D +Ntm3GqJOHzn7R3cUAizzq/1xpdw2J6SwGVGMfJX/dv36WFk0IOJi8//ErjRB/2Gg +mq7/rl8hH5IrtrfVzHOQfV2J4jW0JLTDNduxUwtbdJIOYgumgW4sSRPNX18uKvUx +EHD4Hig9NIO7LnyDBojL00ipX43MRdjXQ5/sQ5Qe2ox4ewyhsnuFTsBIqGuU5GE6 +OX5aJWTE7wXNQG1POU8vAn2e1AsB4kRw9v5H3LuXO1YA2FhAWbST4HVELcgUAhDa +LOmClYqqrFPqtGYPkxb1b92BrSsRif3ETHKO4XEpT/T5AWw8Hs5ZeYUqACed0gmw +ey+TL15qHC/Dogyn9OdASF02zbg0lUDpVIyLahK8+1a5jp95+CjkTC77ija4WvM7 +oyiN9BdH85glVWR/aOgtDyEWdlwsOvtFSZc8eMuG26JKNjds3avvpBXR5nMT/ex6 +6O/WkhYnGufM2fQUfgRnVVDKWRErQdSWbekc3N+/MJHTvSTk1kr2Jyl4+bw8Drcs +qyg16exaKtlVnaSbj/wyyxTbID3opZkKVsEShY8xDJvREHuaPVpMqQSQTJBJrycs +gHHGIztj8CwQnBJA6XxKJiHt7Tm4uYyPqj+RvLbEsXUaKptOwDT44UvmStdu3zmg +PUnIxO68y9ZkCNNcXXt7lGJOqY64B38ifAfr9gGr1AfrxTH3+du6a5A775zsQryJ +YvwMhQvvvZ6WdbTCW0vmL6qALbkDpvzSdDw+cwPSfwqcnAGDWrT4uPeVK3XtwRT/ +3HHHSqh/Lot00aEdUBzoNrD7A6D5AhdJkXRCpcgUGplnekQpC3ceSJJuP6j0hr8l +HLrtrCh2QNuyHW0dwrXraQU+1ohIOnWl2tB48DsxFGntKojqV7kHDFNn92aX6Kei +xWVHubE+55A5rha8H0OQ3TIQj3X2Q8WOCh7MC+dRwctT2hGDf27stimqXWFj9ibE +Ipsq6JnReQVuXBGzkQfZTPtaeXGh8guiKmAED1FwA3Q8e9QB2RUyrbBiCHmtI0BV +b2W0Gadtz8LY7RfHFBB41mRjQB2Z1qJgZm65PKuxbzFl7bln0Gbff4ww8G/eCLYV +pd40Sqwb3kiUdhb0UAS9vuNa2EFdCRIx3955MYvEVeDeb2d3s79tEkgvAIKIWiBq +BQxrWlsuFmxPCaFDtnIAVy7qbBW05o357j2DS3sJheuty5iKvCV7aq8Fun14x1Qb +d8bSHdsIt7AImryyhTL/iJt2Sl6fIDdiVQ7ly86Si3TmnWQ87IRxQZW7NTOzFB0r +RDcYML+CZDM4eFi9p7hZfrxN4uLYBGKoV1GFv2zdEiJ6tHqrspwA2KWq5bo5TDgy +wFMhyB44d9gakadSgYWK1MrW+5+2xjouo9JkQpq4k0J5YpxE+UKqxd58HD/9QQDg +bq/AUT7IQXdoK00mb33Ph6Q4QqXo8DOVFrFv112Jc9QMAGkQUY3rnmR12YmpvfeL +HniyABMo5pSgXLQJ3PrvWh9xZQjVJsPfx4DL/WowA2iexBIPnRt93pI3Ig7G71SJ ++xCrasmu8QyK7fj5ZJbwPftchUZe+WBcr6pkOpQamXmHnCNoXEd4CUNLjGsyZdlt +G1SfszTG0ls1CnfIYv+4HMbV2QX+fRhNch3TIsxOzGb0GKlVrwJKujUapgdi30jn +s5ByDCfL6QgYcsN046QgUl0h1Csb+qMTFntNP+11brbkVOoHFarERV15b8O2v2Wl +GoMYNAeWo+Dfeh4wbvZgHZxGCD9BGoqfaDSEdIfN6YNFZf4C/0H5l9qqgYBb7HNc +/PsLdw9uRBzmwreIMcewmOIACtACRljtz628Q1NeZb2laT8QwTmqHsiMl4lptZz0 +cRT3fm6EPX57Fsd8S2e4EHtv2pSXwEvYOrASPmls/S6LEj9WdVhfG/grq7Zrv13w +AVb2Uw8+gDJcgUp9fUd8h6efu0v7elVhVRD6xIfc9r3uhcHOdemv+Q3SjffhY0g/ +CSOD/J5ouqo5EZKVuhwi+3JSIRB7ow+NKJNxEuCBAUbmbDC1HPrxPWGp/h5SMGO9 +aNMkn4+hIdNLmRNpwmbR2UuA5pBjtrX9jP3lWBaxs1JhktFZ4qvG/+wYZ/ifrMeG +gbbvWAVoywObKtqEbpz6kmeNSm5VCp0t67BPYH3wKWcHEYjHNJG0M3JjKCnJbGr6 +fCBHn13XZZKfU4J3npKCbO03iiTchVWEU8hErkGGIHAkqr9yN6xziZRs+m/IJyvg +yx0vmt3jWk/3e0Oo5tGrt9jeyg5yM7aDj4hLczQrKVgI1QRjE6X+0MgBKmpRKJLx +RuGcknX4hdYuQT3gighyoNDV/9GlwZ48hLC9TazyoZtq0bloqc2epruAfayT+rYu +JzOHnlIBUhEbgjewJZjfIfzVKoLJchx7Yp+sGnmXR/Y7xYipY4ydTxdUjGKcf14t +zHbTdJdPFPprxDm/yooBDXan9ybIw6gerJMAqdQgi8uYROGKID4pSGZ8vQx+KgjD +bwVG6tZ8I3GgWnHkpI+hj5r5DyhnsyIZayFt75H+w0T2uHhrrgYkAZ/WlyVfbB32 +V73mXeK/Vv2QXAmfpiaNb9HTC1c+8fH9t2cRUkxx5aUgWvltJ6u+CHi0dVBGmIwQ +P2ahqEPgLqenb04JvxxNnQeRQETW5S55GvJEiK7bjFSRs4DfUT3A1COkLXRPi7Pl +jMc3FQzQ4H0IvgLom4TNsSQBFtLGT2fpoTON+SWVzWMXgoQvD2sfGCk6jNdtUMHp +zrYWKzVVTOOewWyKVMpGOgNDRbkFQWQbXuwgn+eI8revQDXA9zHivkljHNiG0fT9 +80WTZkMFMRcOl4K76alUPPkg0ede000yg0SXQplVYU/lYcrnsamx73YpKd8GP/lb +DL53ee4k+MktqI0MyvIfbw/Da31SERKiO8cdK1m4b4Ds09+8FB18WUWrj2iyMyTi +yznkIAnn2Bl2L1880WH3oY+7QqgDC8lXllkhNmeZxUsbtYl50jNKpuUbcZstcs5+ +8Pixgp3C5K7JZdLb23X35uEP1gNzOifxJdaDEtU+PlERkJjzx3GTaA+i1rTvKBYa +Ysk0v99+xFpdBRiEf4T0ZObEkGVdlvk1dGbUdx9lgboJypde499adfJj1VxrgFXl ++kqHulSoyVGfl9vkBHgvl875iOx5K4/zL4Ui2vYJ821mFgWcZC5h9clM8PUVC/m1 +LQrUi82y/AyuLF4ynnpL05s6zEffBydEFFU1pLWH46Eawq0JDwonKUH/28BLEJUf +2tPjubnA/2otWut8hD4mFEErdwOuERMTp7CaRTHT5991IY+p8DcuioffVGmY/FZz +IrcTkLDY44hao5hIJPJDast5yWYV2lia9XMzhXHiwA2kPDEbS4Lwu2D9WA0AF7xY +h7X3Tc5cojdRIr6LXL4C2fva+MSDmXqkms9TLmSHT08C14R4Yz55CAlvmiYRU2kj +d2UdHoSM2gEdLIs+cNMl2PW4AOtLEQv3wZ+4qhzUTjhJGSuzMu0e1C+ll70tggw9 +5yN6PqmrL09RMBvaIhoWAn8ACbXUyYP0b75Y+MBBHrtTM4KXl5R1Bb+Lw5MqtY6b +ceQQzKbLs7DBO798Mn5ekTBxsUz7ta+eo4SGweHRGeFS2VFxUfnhY5wQ+YEWJitr +3kqlW7qSYbJ1ygVp+XxYfNoypOK70XVnBK3oBxy93jUjR3/5jn5hbLgGcNINl+Ch +48ljBY3fkv3t2hWzKCYhZq36NbHz8DszDQiA3TNmxfTlAYbr5jiUzH52y85pxye7 +9amEiPRq6LNwgAAN9bCCct4+88GuI+aS1U82LYyXqKUzsrXqZZjvypubjv/fCwmc +mZxjpGIgIXrQjctJasjkUq62KvlPIjszdcOSTP+jJNCsq64TS/RGC3s1M/jjM/bt +SUIbWM+/i9M2Z7TOMvU+kcBfdzHhLu4MhJoPPfLCBw9qP6o+GB0UQ3FpjAiHLljO +WsDdobqxf7kt9doN+XS6T2LUmV+ozePyrY31COkNSAbNUQDOncSSpaFraTAutAXV +HAg+T4fgst6P10kYZFAsjjDjFqnwhm+yfyrFaYP7nH2vUanpobjKShcOpXc7dUpi +a+/BUvBCvi7cYSOkB0DkGgcDGKRdr9gRMIZ9UXYBKTT1elU923C3MX6rh+Mgm+hQ +1kIfDuc6i6ZScVRNNpDk+pnGPCDggmNiHrs+7tqvMsOY009ywdXbYkBrhX27ZJaf +6B+7gVQcCa+yOPjHZaQl+nOP39Mo4rBa/PXiAcbyKTRkDDaXxm9dY8lKTyXtMg6F +XUtF/tXIHPFOBI7qsJO5WwXCkrf9oi8r/w0pvs/HSOA5pOiliFmIYMq3iWragsPg +l5SZt85mWZogp+Am4NcN0Af3uCO2gK+pNGJRTbkp6WKRoYizIrIEQilXdwNMmMaE +tf/J90lCCXZxF6GfCwIyrl8cf6HWThN1S7WW17nNg+uGCYSg9Pl7c0NccasDavqC +2CAtdz+1RP75zVjWf/PHhuYHoI1pihUzo1tKKlzasL6DuAYv106HxCiv43AeLdNF +rGOWJWKYlhouiAMI/m1deh8hIiRio8tnC9rMdrlBKdvALjuhKCeWyxGm6L22oFUk +zM9aRcu8HkKMa4uewSXeJ8njb6edjYuRh8ag5RniAmWJ24/mbdznibgvamzIaPGX +Jb7FeVjDDuUnqUJjX7eu5odNNkCVvSW7Gua2oAxX6nnFUIk+BI8spVlCSxiGvYzL +fHZ5kzku0emRfLfDLfnjN+2gzQ5WwoiPMN19NvWqD9Z8ruoKnizmIji+L4PzaHyp +sH/QWLIUrQOpYBve7haEy2vmuHhNbymc/Y9ifi6o3G+ohI8NLe0T/wPYbTO2gYAY +bB/hhCAZXC4Sjh86KwphjVLjsGZ/J92CUpP3RF7Q/f4rWJDQ8Yh7d8DUQo3NtBtg +GAjdai8Cc9Wb0SwYC3Jbyaw6Aalh8K2EM+fHn3H28BrLYVQTvr132WN1jzqEw3pg ++HxFJPpSf3hf3hJsCdghDZEWQKPdYVGW0sW4VBZoP6S6zbh/JGaCZG13fC+QmwGx +2GYPxHaIRXb8QALXGmHDJF2tGkTPdn6xux675ICiWFNbToz/7TSH45/HWKLvIFDM +ykIBk9Ic5IkoKsaGr+YBwT03GeWJdp858Fhz7Ev1INrLjUup3je+0yCDipyIxd5p +AhPx56zUrpXEL5oayrRH5+B8ol3zK5OYskcIqNtFfgWoqBhk8Zq4IHNZLG3KdsM3 +Rwo63fLMx14NJlaXwVJYrAmxUK/gjdy5vf735nqWPkthS84G0NMPunqMaTtWMbK/ +q/RtoyhCb9kRUM3zz4i8NCtwUQ5MOunxo73ZVYjGKpTKT2qJHymH5PL5t5KJwe/X +dpmMMGjYUx0paMbBEix5xiHJRaG8sdSAXrX41iBtVunv+MJwy2ZPxwDBo48jd48h +fL/d1b/kJ26XfHRQnJpQvcszMlQNos3nXDgbL3h93BcmVePCBxV9MV6qj5RFe6LZ +RoML7ptVWcUjo9LrBsPHQsdTYfVZEYCYmJ0BGNmvbcm0lrmi27I1hlKuq6Ou2prT +0oZCKLsr5hollEiyqG003cL0/qXP/Hicln5SqTM9sqzMEkUZgr0/nqcIlJ9cqaeZ +WYSG35FuuLyuJjFfLZXiE+2VKIUTk86jWF1JlMUTfRmHmm3/8V25mPiHqIYZ+s3j +udcNlLbBqQFWGB4YvbRaS9/Awr0s76UmHlZOC1iCpHDw5F+Ey8Bzl6JvFZAPEXHw +mfguYXeSacVWkVj8SBa9ZsiUaZcns3lAAAgK0CvfFpCFJW+uM0X/sFrs3AaAr2ey +hnVoTeBKmS5y0qZlQxV04sL6u0uVu8RvFpOkxSYCnsueyrGWDnSQrhsPxbXUdrnl +n3VqWvAqDl33V6XrJV24Ix3BqtrOcHdPvPAMph2Lj/mKYvS9/4E1djQlk73mgW0c +CwePGRgfzOITFeMwBQ8aM3n/qSims4nDkfmPPd/WP95IOKfUBv3TRg3ndTH3NSgq +vPeOOse45TsZ6StboPdtrGj+OC2RN8HNC+wdlWihpg4Q+j+BSIBBd+SHNK5GivDr +uNKxJ3INR8Juj0U9D2GDEuZIbkcHiGsjv2Yo54tlLiWbaT3Raf4M0Idjrz9/5j2I +veUcLd4R8wXqm49f2SBEct6cRm37LbxgFMPjW2URE/aW1s639XhGNvxWbv+e6dDj +930AVfu1p49KkV1NzCcAsXdG/qAEANS91C/JKPmk1951qFuzpRtzAZ3wng51jGYx +1tzybvM0V6oi8Kc8/Q540KpxGl38c6748IVYM/lhDfSeetpsDYj/8I25MqheGua+ +n5RuhcJfvFVy1dBL538dJ5PCmcowQ3sVcuhYYP2muoSCip2uPMjXCc7fkUK8qqKB +DiyMewwwQU216CWT3kMhXpBqRNndTUgYt1amdr1sLvoqrsfc70OGv02G1s1av7Dh +5nruKN9xKb03vomd0JGARBd199AYZ6AXiu9Uqvm0N7WUYYiXmZL5PPuQLK8p0PUR +hO1xFS1kQwLBvajzhKr6IMumfboqK7VGm/8kGDUsH9m/TfJ3wN5LPmybVoBgw3WN +O1yomaFg6jKkcT72jD7Zqa9kaANF9vqGfAeyGxGCGw4g+O/xr4OoXoGm81Ik6QuQ +hKKkWrkHIc/QIyAUEkzbZP00PYT8COC8y6RL4IA9zTtW50rouE18E48VcUQTYdAF +0jLNoU5H019bZylZ7xIGUtmMHc1VrF+lpFd6WF0g8J+kZx/G1diY6EATafuTRjAv +DgXMv5pQ5VT36qNzt18lGBrDGBKlQzw+4qa+Q7tbZrt+2j5ldN88LFdNAQoBc5cU +TDGyNRqIJigqKdfoUaEQnzM0XCwxGhp+15Ov5RIxKP1pt/oIr82sKn22M7J6cWVj +O1zbcmiOtivUTvEfq9TEHYxjCw1Fff1fBsdk99E5UqynBGzHPnuPk7C8Ug05+9NZ +lRAlLsTs3zjPQppZmsXAqVvavKL9DyKsVo5rfCsvmDHzFaZbo1V3tzBe80gRKIzA +9MPM5BGTpOMMWAZIxD01Ylx6+LfS/J7aewujVQdlISWShPoDoA+U79m1802TgHgi +EUYaCAg56HNBG7/jWkDRgB5d175O0ohnfdl+1XehXeVoJjmOCWkFEHytjc/cOD0K +5emi919tgc4T0mKFy3P0VYfxBjh4KwZ0MlrlYH8G7vswClY9pDNJDX3AodbtyBd0 +/8TSffEAe6sX/qhRq9lBc8gnzbOfJ4OEUguEBjiA7mjNwkJzBkplMUi276UhR3p0 +tBQ0e+26pEhOHvxP0QWwf9kFNZrzctuvuWyA7KbftBukGrM+IBw9cdfxWnIm52cY +rzEOHYrJGu0Mq9h6P8Ssfbh6Uci0ivrWrNenXDzX5rylSmxzJbW4btM8MsKTGQ0d +1uU7BkjyL+4XMuCDo8xeNZcbSBoTxsNnsKyuMy+rVySERRXtZYZy8c+Nf8QKdFA8 +tlHwVSAuy7EkX0G7tNOc4xG1+NG4Gohu6O7QL81hkApOPfwyDNdezFBbAz/HLHM6 +nN2p6VOBNDpIOrMtHcfCn+ANeorPsm4MRRpFNADm6FRrDa5LAS721h6KiTv98bLU +j/K6hsGpa5U1mDzWU5baekjLVKmI47SY6DHGRBCCT+t2VU5I1nf9U4gKb86sPlQH +Nzo5zENlkENViTF3pnScdi9HuHWdttPSTeFa0/kM8m9CbAUb/2yzvWtYM5h0IPeU +oOyH84rhtLPtsZ4rF0YTe8JfEUBzcol6DPWY7kn4AL8V3ioLz3rYFpO6avmg4qz6 +Ibitw2Hwqml/qeAtjOQuW8Vg5hlUI60outJVxs92rSoJsmjz2V1RShRNYRWEGBnN +fGKnpwiJXsJsjMTNXPT1jwyUUa0iHJauiAN8GtsEdMp2qwgNoiXMxL5lLht6QiWJ +mZTz+2sIKkZYkc7X8bd+r2G3aZry7wtZWM0Y/dPL8PcY7/XMJPN7h+M/ZtrsuZMl +9NsMQzmb+EjvxKZKexXBYhFdFpHZSMznTFY0JgK8oJolA0BCXtI0kvQuiQlV6ARm +8Mv44cbSGZVdVoIrtijIvjFrGpg03DJL19yDX8BFr09sikcFvfPaevyZijPbpWYd +PWdL2lu+H+6TRvsOFg7rNwIyqwLv8YrEf2kQymL1kv/oZk4wJXyjI2l3pHDI1Azh +a5KfbEdMISHMFm7wIhVessucF91zWGLWEpRenTxkdevskNDzFpRhdzZAQhTY6par +CFlbaITKP0MAhVhJlRk0T0RfLVuGhDNVhDIjB02XgpuNEiSV2hJIj/lJguk7HYql +3q0CxASBatoHCch3M8U+JHU2TMGvgviJmZZZmEvRlpz3DHmqdXSiZI8LbYq/DW6l +OWrxKMIKi/k+CGHJvgSTloHZcRnZifTsyW+8vDYCXUvq3iMlXTUdswBvgabHL+gc +qETQSpYTQuQZM1UKD90pKjNYwupdpURiHp87VXuDy5ifn2jBxbKOQVrXpOGjq0CO +iK3Gz5Aig9TBob63xnZPMDM5LsrybEp1XEO4xt0cDICIeqJaPwoaNa92QNSXtUW/ +Pq8/3W9KpTiakvVOtjQnN00vbVOuMRk5VkodDphn9pnP01xzokFdSOAWCmCPw5sE +OTte9Kr88WqN7fH3kPkg8e+Gp7OUKFOaNwrvQScEst20w2XrKztZSGWKSZLRvV10 +bOx6fPQ6RY/V33YABbroFrANabhZ/X9lJPjV1G2bzbYQc7h4l32WrCRbgt1cHJLb +RAGSGEexk66eBskBRQfdSkqc+nLglO4R+GWDpZO371nB0qLqtv3Y1XV0fqQM1FMT +XsEuGPMa9roSotnvUDmz+2nvQFRMWgflKDJe4y+c+RIaMx91wsSZxHwy4WNBamZc +tZp57EpxdKKmJ8zp5Nyz6lDosTWv8xre9bHg24QOAO0C1nvnICdp/ez5oxi3YoGC +qhRW0jyDEwRHwmP8+xg/A2/OzkNMB8bVTLP4Y5/nUJpYVAhXysxFHLHc4P49Ohhz +N9tWuX8u5FexWb2yu4FSY7SXUpNYW0Ys+xY/54ot9cbeqS+TuAn9xWTn21geODVb +OveiI443d4rmwxnpQVQ46tcac1ICY2MdWHobPwHU3sAlI3LvC2mmdZEHhSBTR2vN +1amywrEmDpE5oUmPXtDFcFPJaQqAt20fSIpOgPECMFudmASc1D0G2HNgkR7n3wXE +M/C500cSglno3pxImB3rbQV3zPpENzseNP4CFLHME66DyzLl+UZH4U9xcu5UtamX +WjY2kLrU0/hHZgoe+F9ytbVEFP6Ak5Ii0Pk5EQ3zq/HFznkWquV5U8xz0ugZe3cJ +blWZbwGWqCA4jK8Ci1gMEY5sMcRseH2mNZDZn76t1yM4P2LiMRc8VTzGpwBzHzED +AqPgdSmYRSFPcSKRHCKz6VZ77Lw7gPLx58w55qHwmGm4IKKrWSbPlg78JXwF9xD/ +aUsNSAH6a+ebSfp5Boa8SfPzImQxDAlLXSEUmw6USFwE98pKZKccL0axxcvl+jaR +icqw2M8MDfcuZITgQ2BuN4NlqBpEkVV9wSrb3x6KE27yvTxBzVBOv/0n9uAjzGvQ +91XjFDrFXc78PNYWbXho+P9kOOx0rCb/te6gBfN/Lzb9ZwbxXUkCSpLpIZQfUM3A +lJ/j+YCkT5mDZHmrP1MgzmZicKO1Yxx4GjKds8gL7jitdNnBDgsG+xR56n8qAvG9 +Xzt8Vl8ZlVZAlkZXwllh/5ynplAggVOAtOSfL2HcOksw/yXdgFdKi8uZJxKV3QWR +dwbxOJPQvKityrm35/S2DK/po7V25Mbij4vWckMWEFNlbbv55VBXjCuMRr+QoNT7 +APsEGsoRUSEucsAoMzFOriD9Ht6X1zruNJMIrGCiQ7nwxV3iSsRqa5u4ya8BGhIl +d4SYPJ1Y5/McbYtOsihi2oTFePlbgkMqJM3xReuvPKEdfZApKlNXK4Z8rqV5v1Jm +JHSnMfSEvOuv+AnU3z6L6i8IgLxjfCYw0ReogeLYE1ICESYHqZZN99EhGBlAYWMu +N1zOkzL1GGeo7czJ1i86IwNlLiRZ04eUW9unV5GKu6rMYGkoiwcR8MUKSiT8j3Q8 +6y5X6wPLWvrB5okk4KneJUlUFuQSo3zJrr7XmfII3m4VWXPCGSZDc0NCOK6abbWm +cVefwaWvFej8bEIsF2JnF5S/K4H6O8jgmiW3dXo/wcs29QAWFD6Waqtq9IWajDEA +iJrVMDhNYS5PV3wI/JVAe2Ib8tN4M9hhtdEusgv/FV80E/M8DVJ05dO6LqbUQSgh +RuN4CJcLWbb7aVOUf/JVCMRVQ7mf0YfIo/bocspEuDomD47lLBavz5KmXXXxHPp6 +U824GO4RWoJujQN2lVlDvXWWXYhytCgci4fnl+cEtL+zx/XY2z9cKaaeyxztycaN +GMA0gOSj6kYou3dFMSDcdN2U8Ls2xiKwCeq74zE8bVVV7IMiVoVhyLlN9GIcyeeu +SXoXHzDb+YIQ7VYTQCLmFRfrvCDGDcjXCVR1MpwgrcWzYRWQFILzJAAHzZTbVh01 +ZRU7elYXP/QfFcvk2u4TkqwTUi+G2VVa/Ku/3HQ6deAcuQei0tHfcggC2IHtjg/C +TbSBmWg8ZgrN28n/ztWK2mvtKXBPt3DznzyMF6AEO6hZ7OW/DMN9mnCopwTJM4oK +Xwclt5aM0UivoLMdZvBHHcnaF90dv6OpzgJwUcJ6+cACQ6P+dRqXQvS8JSRKH1BR +TXcqTACg4VABkITbGod4h9x+5tmRtumwM06jNU9r8ITTgCI+LFSmKimkuFiHFyqH +Lf7G5e9MFf1cbKmKHib++g9oCkQhIABoDQEoW1VFv5mP0hvNPlJeINLBOd5FleiM +TRQbxXLqMi3hgEhYTapzMSrhc1TeKrDIgbVk7A1JPZ3mL+r5BkDSt2VXERqISEYa +IeEi3RIAXoZRlsoCdz+v9K5gtxRKjtqiosXObys+cQlgtdfo51P+Za/Ex5dZMxiK +w54mYqdUPRqjxtIZAlePIDLLQJgaEeeaZXMuvftkdi+sl7xDIWwXs04mdEHD7+Pn +I5OfX9XS16M22qHHsK38sYC64BuU7sJN0dgi6cbp/r76O3gzwkOeXubYNnihnMP3 +SPINsR85bHy9jhoqCe7HDCy30i5M2y0+wrosDI0ku+p/TaN5CMO8oe2BzfSbiBUf +HjYGglchSQZYUjQwYPfqF8c20QopvWIybKCH0Jr0Nh9NiTHS5QqZxJknt5oxCutr +aZi24VSn8NwSc7sF+3r3RpujGb+LCEovbqdlGxhlzeWSW/wAnxJLL/qo4691Yjk6 +mTW+MUQjzuh52odjcdDJcBi9vJ92OJnvxSbJCWAeCwlx0rijUHnzTfTBUcGtjezt +ABv4JdXAP/34GhWX+B9SiR48OEUJuEv5xWaS08ATpaKnqjZsOJM30KASrMaJNeIq +ejifIoBywfyyLDL2WMXeVq5D/5vX7sB/iRC/WBcGT/kfbNt8JYiDqk15RxmCVVYe +AG5cOwparI0qgAS8GBNZhIuQwE8PwUhGTQrxWohmAL9BRVvjIaJvvdsJACsDIEgR +3/9F+KXsPW4jy6ykmT6r3tquaCIXddEwxWxjKEPPQSBa1TBKDe7X24JLibeFFTFS +1QAtkYGiENTNSz9pl/nyCjr/scnGmj9SXhLXLu6tbqSNoHkGcZMcX3d4CkIRPv73 +P902g8qZLdxCO07j0LdSKZUQgm/dbjFjY/f3wIlPh/48oWnrILApFagr6exNxPIu +SJfZaTohk5OvV5DXh3H5wWralFtNaDlmadOWzuDlLUS82t9Si571UueCpNzshXc6 +itTsWehqpQ7a9RGdvSSCPk120nXUbSu54PkcBfb8huY9TGZzNxRqQ1fQusDENlOt +NtkCel/7cBsrzLN8jw8EJi59Pnk7MyvMPhOd+SA3JlyG2rar19tL0DBnGIo3a+SS +5DzX3WCza/acCFC1NDI5gIsK8hgHTK/NOnkXGI/P7Xb+urIa+WB+l/fRe7fceRYy +BJx+2M7XF6v0z6ifNEKAky/puRpEYmO1TKOCM4gUlgqZtDK11ZQyqcYKaRcXwo6o +QiJ+rgy7wm1X2lwKULHSxql2ESCuKw0fwBjuuye+lAyuRYM7ET0nplyUqrKcOl/6 +HMVq3W/lX2hO6ZGwMiKLNFXjknaGXddtmBm6ecBIB3b6QyE+0RkVlAYBXOl7WiLe +CGefrvWkgyZpoJwbRt3myN8/Qu2GrE/Rgokr/d4ByrtkaCfin8tEyUD+PKeBF1h5 +bDbVRq0tfUVe8rweVKsU/56rvqHRu8JoyxBqB/tPi5smAl4w3O9VWyk96wEN38Ei +32T2IaVKAHKfFdqsfo5k5r1vNxEVRfm82rBUQo56/Y/r2NJCNB11hirKZ16K8E36 +REoa4FQNDhvNCCgF+1Wqh/WsUNSBmy5Vh9FxCLrndSyVrhrgL9YWpWeS3gFXSZxh +SWKLDWtYZMLXgyEdshDoTlfSv3rP0cJO/eJP0dPr1mbgukGGetDCLRMtULGWWvp7 +me0bKQZb5AP56xDCz7G9LVq5PiCddS8nd6JXw681iVGPjleM+zuJEz5lDreD0KWx ++SmhwVsEadKNuC57qimvOFoP3t8flnd9nyFOnVovqt/F6ieSXef+Y0rAJnktGbUe +YMlm3tk6VkwXUGJHwQv+FQ/tRLmhtIn83BpNq2fEbnOhZY90apvi8jzdauwjXuQN +7gZQh339gfTd9DTcbp2OjpxTLpGy+T56WH9AJon1wAQ0CccXAGI8S9ygyzZ78znG +OQi9/STTYavRT2wu3Eq9rsAt2rmJQZzORAdfB3RwRTm+tQfCR/ikiVIN0vBlkuAw +6ugDz1bbf742Nx/jjofZL/IWqKZBXn99hTi8ehFZfzLAN/nIxBUF6qz1NfF9Ovjz +IeBuGr4RVZWiNJH9+Hd0eFJAAoyz8w8jFeKbz4ORSRxkqolCoqNqv7svk9gE9QFi +pqBELFw8BJ3XrzPs4DoewDYfz4VnUnjxttFTnRICiQqJsSCTU+lE+lCxx57Vq7jq +guhdgQAnpxuXX7zG4dGJrLgLMmqSREH4Bbtzb0+tS9pM1KNcWgPwmPFl13D/Cu88 +zZdy5ploYstfgzEbzI1A2ZHFCyz63gxAWkVhsvLWAdXF66w/qZbILOTxClGPDU13 +dMxVvQGog8sgbyyStRdYE1Iq/u0SqK104jP0KYYJOlTxuvnFavN5XWU21tZuy1dW +w3XOySAnjLKitqXh09EeucnxCHSf2yMtVz4wy8xeuahUDkcyIfnOKbEtehX9jx5U +9PIae9EpirHk6Geqy+7w1+LiwI8xy11IMzKr7jganPZNalxirfMrU+KKcRi1kWV6 +B3Rzqs7oRtofX/NRtuHCuTdUJFNHD6MPDIu4SrJgCerlVL6Ht3dpSsdH3zHo8Qu+ +Nt1/VWxauFSNnjuWR0/jh3YMeoMHK4iNQUTszvd1tI3opQhatp2eZN3q/Jq9NxIN +eNfI5TbuOtaMNey27S79kyE+SSfPMKo1hAeD7O16Mix4NCx6/TYMNXWvppZgV2Wa +a9S/8ksF1HcmUvUsS8tfjPhap3z01vL4QYlPLzABY1P/bVzAHHhGXSStA5aM05uq +oGfjhFGheneWlhzUrQOFsi/eIE2Ya7FM7kcxgtYsZrgcRQH816KkVP0ZlCQsVmUA +MYv/oda/1SsHv6gCHlEnAd8NrYWijHog8RpfNxShyXNRTltA75EI8000kx9xH5U6 +tMb81ja7VkWfESANmk7oWc84IWFhQCC8Fxcy7N+Ci+X1TgMHmbkNuaCCrpZsCXp3 +nPBikuau5yRPnrugwC8tB6aErW9rQkCj5szj6l5ujtALGqUEwdy/XR8m6/J2nsrh +qEXj+C6Kn3k7NbXb0vM9NHspo92bmt7CcujU2GcuUSpG7FJ38aMBAErtOwvp2vYq +sbzyh6EU9HVtt7T/eoLAXlqNp6ZALvtQNaxkIzpfmmyW0ATsAr4MlTcjv+4lnkT/ +1E2WBxxR+T0hvvL8sVEJ4MxfmBXayzYJcR8Wyz4XnyeUuLfNHyYtxqbNPPX7cflV +msVoBSmAWyevXLW3s/52bmoSUwnNIyW/Z2VevOPVFCib95t/FebNURFQHxnfo2o2 +mxxpsfTjMDiFTf4Ua+tNBfj/lygwiOAZ7m8bHbhxo+JxQEBd4DPobbpHT8wDVZcV +UH7fPbQVz2p/qXq8vN1EjSu3Ig0q5RtwaQzylh6pKzNokrBQ8Tag2D6V/DD6wAjN +TIrrT+N3luVhgtTmWz8wiaKY8VNudhrEswrP4g452ljwJVegL4/nEVqSmaOpaMwm +wCY1GThTr/I4+vMXkne1Sm0lsxNDCwVGunaZg3kBtvip2SKwopuZwDwDqNQ1+TEK +AF4J+whahBZ1T1vxA1WPBMOY7Qb0DqNXYyvgt6gAHmgS1/ymP2LmeBNoFl3Ge1Gc +axfgt4r63HhtP85F2Y8SSKQ/WkRuVrmr+dONQughbKHC9KyOJhiIcDiQT2JgJI6y +6M45ZkgBKLfBVD5bURHIxvj1BbB8GDuaTeT8F6dV+2u8Cv6mlsa8jTPmybOz/bKG +CHHEjsSdctfFKDPDeG5r+n19e4zmevPaxN2IJbM0bJyk3sdS+DofAk1l18S6+5xZ +xavgWT0k+34B14Wh9qihzmkX8iDqvyMNmEmfTXNsmK6RW/J0t07u+iFePchRe+Rh +OtgG84rBL2MU+5WzxFctBlnl/9HZESqxNuOpxr5qwYKgLI8LHR4tOkOt3CEwyCuK +Xe3b06xJlDV/n5QbAwN58bXBnRAG3mnyyDNs5uK76kNiywyPqi+P1Cq7HLUKqT2f +wiDuNgwH7nVvkF2A2W8mOC1X/HplH/dWn7QvHujyrmV7ePpv/K1WDZxLDlKn/Jpi +O6zWchHvTH/WDvjvvXRlafLW6xJsKepy/xgHWdreCAh4TTFwR11w6rEwn/nx9Zi2 +CTn74MIJoajfUGP9ETQVx+FPut0eivhweoa7n+t8l8f3XuRm7vVzv8IF1t6rPZn7 +HY4Hz7hTNWFzoUAADju6LlhaKIP77ogJGHBAwwrAA/E3I7Ut6zHy3jJxVgN1hgwA +34/4O83m5AEJj/2Khm82OpqO5ovuabxBiumuGyq5S+dJsXpvAAhPO2YqIFrTPdDc +32QfAcwOm+wXgwp6lRW1CeXV4A== +=kkh6 +-----END PGP MESSAGE----- \ No newline at end of file diff --git a/endtoend_test.go b/endtoend_test.go index 3e0cb48..629fde4 100644 --- a/endtoend_test.go +++ b/endtoend_test.go @@ -23,14 +23,19 @@ func TestEndToEnd(t *testing.T) { // Creating New Identity // /////////////////////////// Me = client.CreateIdentity("myname") + // define my preferences (servers) - Me.MessageServers.Name = "Message Servers" - Me.MessageServers.AddUrls([]string{"http://127.0.0.1/meow/", "mqtt://127.0.0.1", "meow://127.0.0.1"}) + srv := client.Server{Name: "MyServer", Url: "http://127.0.0.1/meow/"} + Me.MessageServers.StoreServer(&srv) + srv = client.Server{Name: "MyServer", Url: "mqtt://127.0.0.1"} + Me.MessageServers.StoreServer(&srv) + srv = client.Server{Name: "MyServer", Url: "meow://127.0.0.1"} + Me.MessageServers.StoreServer(&srv) //////////////////////////////////////////////////////////////////////////// // Create an invitation for a friend, I want him/her to know me as Bender // //////////////////////////////////////////////////////////////////////////// fmt.Println("Creating an invitation for the first friend...") - peer, err := Me.InvitePeer("Bender", "myfirstfriend", []int{1, 2}, "welcome, it's me!") + peer, err := Me.InvitePeer("Bender", "myfirstfriend", []string{"http://127.0.0.1/meow/", "mqtt://127.0.0.1"}, "welcome, it's me!") if err != nil { println(err) } @@ -100,9 +105,10 @@ func TestEndToEnd(t *testing.T) { // Packing it packedMsg := MyFirstFriend.PackUserMessage(enc.Data, enc.Signature) - srv := MyFirstFriend.Contact.PullServers[0] - intS1 := client.CreateServerFromServerCard(srv) - + intS1, err := Me.MessageServers.LoadServer("http://127.0.0.1/meow/") + if err != nil { + fmt.Println(err.Error()) + } // Creating Server message for transporting the user message toServerMessage, err := intS1.BuildMessageSendingMessage(packedMsg) if err != nil { diff --git a/servercard.go b/servercard.go index 803c257..abd6b04 100644 --- a/servercard.go +++ b/servercard.go @@ -1,10 +1,5 @@ package meowlib -import ( - "github.com/dgraph-io/badger" - "google.golang.org/protobuf/proto" -) - func (sc *ServerCard) GetUid() string { return sc.Login + ":" + sc.Password + "@" + sc.Url } @@ -12,101 +7,3 @@ func (sc *ServerCard) GetUid() string { func (sc *ServerCard) IsSame(sc1 *ServerCard) bool { return sc.GetUid() == sc1.GetUid() } - -// -// Storage -// - -// Open a badger database -func OpenBadgerDb(path string) (*badger.DB, error) { - opts := badger.DefaultOptions(path) - opts.Logger = nil - return badger.Open(opts) -} - -// Store function stores a ServerCard in a badger database with servercard.GetUid() as key -func (sc *ServerCard) Store(db *badger.DB) error { - // first marchal the ServerCard to bytes with protobuf - b, err := proto.Marshal(sc) - if err != nil { - return err - } - // then store it in the database - return db.Update(func(txn *badger.Txn) error { - return txn.Set([]byte(sc.GetUid()), b) - }) -} - -// LoadServerCard function loads a ServerCard from a badger database with servercard.GetUid() as key -func LoadServerCard(db *badger.DB, uid string) (*ServerCard, error) { - var sc ServerCard - err := db.View(func(txn *badger.Txn) error { - item, err := txn.Get([]byte(uid)) - if err != nil { - return err - } - return item.Value(func(val []byte) error { - return proto.Unmarshal(val, &sc) - }) - }) - return &sc, err -} - -// DeleteServerCard function deletes a ServerCard from a badger database with servercard.GetUid() as key -func DeleteServerCard(db *badger.DB, uid string) error { - return db.Update(func(txn *badger.Txn) error { - return txn.Delete([]byte(uid)) - }) -} - -// LoadAllServerCards function loads all ServerCards from a badger database -func LoadAllServerCards(db *badger.DB) ([]*ServerCard, error) { - var scs []*ServerCard - err := db.View(func(txn *badger.Txn) error { - opts := badger.DefaultIteratorOptions - opts.PrefetchSize = 10 - it := txn.NewIterator(opts) - defer it.Close() - for it.Rewind(); it.Valid(); it.Next() { - item := it.Item() - var sc ServerCard - err := item.Value(func(val []byte) error { - return proto.Unmarshal(val, &sc) - }) - if err != nil { - return err - } - scs = append(scs, &sc) - } - return nil - }) - return scs, err -} - -// LoadServerCardsFromUids function loads ServerCards with id in []Uid parameter from a badger database -func LoadServerCardsFromUids(db *badger.DB, uids []string) ([]*ServerCard, error) { - var scs []*ServerCard - err := db.View(func(txn *badger.Txn) error { - for _, uid := range uids { - item, err := txn.Get([]byte(uid)) - if err != nil { - return err - } - var sc ServerCard - err = item.Value(func(val []byte) error { - return proto.Unmarshal(val, &sc) - }) - if err != nil { - return err - } - scs = append(scs, &sc) - } - return nil - }) - return scs, err -} - -// close a badger database -func CloseBadgerDb(db *badger.DB) { - db.Close() -}