113458 2005-09-27 20:24:47 +0000 Wrong checkbox in the layout when adding attachments to the composer 2007-09-14 12:17:01 +0000 1 1 10 Unmaintained kmail general unspecified Compiled Sources Linux RESOLVED FIXED NOR normal --- 0 aironmail pim-bugs-null mcguire psychonaut 0 oldest_to_newest 376732 0 aironmail 2005-09-27 20:24:48 +0000 Version: kde-3.5_beta1 (using KDE Devel) Installed from: Compiled sources Compiler: gcc-3.3.6 OS: Linux I've found an incorrect placed checkbox in the attachment box. I opened Kontact, and selected Kmail from there. Then I used the composer to create a new email. I dragged some jpg files there. The files were successfully imported except that a strange checkbox appeared un the first row of the imported files table. Using the scrollbar did it to disapear. I'm going to attach a screenshot. 376733 1 12734 aironmail 2005-09-27 20:26:28 +0000 Created attachment 12734 Screenshot with the bug In the screenshot we can see the buggy checkbox, it's in the bottom left, in the first row in the column called Nombre. 376735 2 aironmail 2005-09-27 20:31:18 +0000 After this, opening an email with attachment I got the same problem. 376736 3 aironmail 2005-09-27 20:33:18 +0000 Additional comment, this happened dragging several files at the same time. 383235 4 aironmail 2005-10-21 01:48:41 +0000 This problem continues happening in kde-3.5_beta2 406238 5 14257 mcguire 2006-01-15 02:58:17 +0000 Created attachment 14257 Patch which fixes the problem The problem is that the checkboxes are initalized in the constructor of the list view item, but do not yet have the correct position. The correct position is calculated in paintCell(). However, paintCell() is not called for attachments which are off-screen, which results in checkboxes drawn at 0,0 because their position is never calculated. The patch solves the problem by hiding all checkboxes until they are to be drawn in paintCell(). Also some code duplication is removed. Additionally, some outdated include files are removed, which are apparently the leftovers of a split of one large files into several smaller ones. IMHO the files for the KMAtmListView and KMAtmListViewItem classes should be renamed to match their class names as well. Please review the patch and commit to 3.5 and trunk if everything seems correct. 406284 6 14258 aironmail 2006-01-15 12:29:49 +0000 Created attachment 14258 New screenshot with the bug Thanks for work on this. I've recompiled applying the patch (gcc with ccache). It seems to be better, but sometimes I get again the problem. It's less frequently, but it still happens. Now it doesn't happen in the first column, but it does in last three ones as you can see in the attached screenshot (column names: Comprimir, Cifrar, Firma (in english would be something like: compress, cipher, sign). 410477 7 14473 mcguire 2006-02-01 03:38:05 +0000 Created attachment 14473 New patch Sorry for the late answer, I was lazy the last weeks. Thanks for testing the patch. The new version of the patch is a big rewrite, and I think solves all problems. If you still find problems, please give a few more details, "happens sometimes" is not enough. In your first comment, the reason was adding many attachments at once, in fact so many that some could not be shown on screen. In your second comment I *think* the reason was you clicked the column headers to sort, but I'm not sure. The patch also includes the fix for bug #119526, I did not dare to edit the diff file to exclude to patch. In fact I think my first patch was corrupted because of this. I noticed another problem while testing: Strange redraw glitches at the selected attachment during resizing the column header. This behaviour existed in the original version as well, I couldn't solve it. 480407 8 toma 2006-10-28 13:47:19 +0000 Why is the patch that big? Is it still valid for the current KMail? 480498 9 mcguire 2006-10-28 15:17:40 +0000 I just checked with KMail from KDE 3.5.5, the bug is still there. I will check against the 3.5.5 branch this weekend and update my patch if it is not valid anymore. The patch is that big for several reasons: - It removes superflous #includes from an apparant spilt between kmcomposewin.cpp and kmatmlistview.cpp - It includes the patch for bug #119526 (also still valid) - The patch itself is a bit tricky (I could not really find a clean solutions, see my comment in the last patch) and has a large comment 481163 10 mcguire 2006-10-29 19:24:19 +0000 The patch still cleanly applies and everything seems to work (there were no changes in kmatmlistview.cpp since I submitted the patch). Tom, will you commit this patch or is there anything wrong with it? 484480 11 18430 mcguire 2006-11-06 00:47:13 +0000 Created attachment 18430 Trunk version of the patch This patch is against the trunk version of KMail. 484710 12 winter 2006-11-06 19:19:47 +0000 SVN commit 602743 by winterz: Patch from Thomas McGuire that fixes the bugs: + Wrong checkbox in the layout when adding attachments to the composer + attachment display in editor: "sort by size" sorts alphanumerically, not by size Thanks for the patch Thomas and sorry it took so long. Will merge into the 3.5 branch shortly. CCBUGS: 113458, 119526 M +104 -215 branches/work/kdepim-3.5.5+/kmail/kmatmlistview.cpp M +31 -22 branches/work/kdepim-3.5.5+/kmail/kmatmlistview.h M +1 -0 branches/work/kdepim-3.5.5+/kmail/kmcomposewin.cpp --- branches/work/kdepim-3.5.5+/kmail/kmatmlistview.cpp #602742:602743 @@ -1,147 +1,30 @@ // -*- mode: C++; c-file-style: "gnu" -*- -// kmcomposewin.cpp +// kmatmlistview.cpp // Author: Markus Wuebben <markus.wuebben@kde.org> // This code is published under the GPL. #include <config.h> #include "kmatmlistview.h" - -#include "kmmainwin.h" -#include "kmreadermainwin.h" -#include "messagesender.h" -#include "kmmsgpartdlg.h" -#include <kpgpblock.h> -#include <kaddrbook.h> -#include "kmaddrbook.h" -#include "kmmsgdict.h" -#include "kmfolderimap.h" -#include "kmfoldermgr.h" -#include "kmfoldercombobox.h" -#include "kmtransport.h" -#include "kmcommands.h" -#include "kcursorsaver.h" -#include "partNode.h" -#include "attachmentlistview.h" -#include "transportmanager.h" -using KMail::AttachmentListView; -#include "dictionarycombobox.h" -using KMail::DictionaryComboBox; -#include "addressesdialog.h" -using KPIM::AddressesDialog; -#include "addresseeemailselection.h" -using KPIM::AddresseeEmailSelection; -using KPIM::AddresseeSelectorDialog; -#include <maillistdrag.h> -using KPIM::MailListDrag; -#include "recentaddresses.h" -using KRecentAddress::RecentAddresses; -#include "kleo_util.h" -#include "stl_util.h" -#include "recipientseditor.h" - -#include "attachmentcollector.h" -#include "objecttreeparser.h" - -#include "kmfoldermaildir.h" - -#include <libkpimidentities/identitymanager.h> -#include <libkpimidentities/identitycombo.h> -#include <libkpimidentities/identity.h> -#include <libkdepim/kfileio.h> -#include <libemailfunctions/email.h> -#include <kleo/cryptobackendfactory.h> -#include <kleo/exportjob.h> -#include <ui/progressdialog.h> -#include <ui/keyselectiondialog.h> - -#include <gpgmepp/context.h> -#include <gpgmepp/key.h> - -#include <kabc/vcardconverter.h> -#include <libkdepim/kvcarddrag.h> -#include <kio/netaccess.h> - - -#include "klistboxdialog.h" - -#include "messagecomposer.h" - -#include <kcharsets.h> -#include <kcompletionbox.h> -#include <kcursor.h> -#include <kcombobox.h> -#include <kstdaccel.h> -#include <kpopupmenu.h> -#include <kedittoolbar.h> -#include <kkeydialog.h> -#include <kdebug.h> -#include <kfiledialog.h> -#include <kwin.h> -#include <kinputdialog.h> -#include <kmessagebox.h> -#include <kurldrag.h> -#include <kio/scheduler.h> -#include <ktempfile.h> -#include <klocale.h> -#include <kapplication.h> -#include <kstatusbar.h> -#include <kaction.h> -#include <kstdaction.h> -#include <kdirwatch.h> -#include <kstdguiitem.h> -#include <kiconloader.h> -#include <kpushbutton.h> -#include <kuserprofile.h> -#include <krun.h> -#include <ktempdir.h> -//#include <keditlistbox.h> -#include "globalsettings.h" -#include "replyphrases.h" - -#include <kspell.h> -#include <kspelldlg.h> -#include <spellingfilter.h> -#include <ksyntaxhighlighter.h> -#include <kcolordialog.h> -#include <kzip.h> -#include <ksavefile.h> - -#include <qtabdialog.h> -#include <qregexp.h> -#include <qbuffer.h> -#include <qtooltip.h> -#include <qtextcodec.h> +#include <qcheckbox.h> #include <qheader.h> -#include <qwhatsthis.h> -#include <qfontdatabase.h> -#include <mimelib/mimepp.h> - -#include <algorithm> - -#include <sys/stat.h> -#include <sys/types.h> -#include <stdlib.h> -#include <unistd.h> -#include <errno.h> -#include <fcntl.h> -#include <assert.h> - -KMAtmListViewItem::KMAtmListViewItem(QListView *parent) +KMAtmListViewItem::KMAtmListViewItem( QListView *parent ) : QObject(), - QListViewItem( parent ), - mListview( parent ), - mCBSignEnabled( false ), - mCBEncryptEnabled( false ) + QListViewItem( parent ) { - mCBEncrypt = new QCheckBox( mListview->viewport() ); - mCBSign = new QCheckBox( mListview->viewport() ); - mCBCompress = new QCheckBox( mListview->viewport() ); - connect( mCBCompress, SIGNAL( clicked() ), this, SLOT( slotCompress() ) ); + mCBCompress = new QCheckBox( listView()->viewport() ); + mCBEncrypt = new QCheckBox( listView()->viewport() ); + mCBSign = new QCheckBox( listView()->viewport() ); + mCBCompress->setShown( true ); + updateAllCheckBoxes(); - mCBEncrypt->hide(); - mCBSign->hide(); + connect( mCBCompress, SIGNAL( clicked() ), this, SLOT( slotCompress() ) ); + connect( listView()->header(), SIGNAL( sizeChange(int, int, int) ), + SLOT( slotHeaderChange( int, int, int ) ) ); + connect( listView()->header(), SIGNAL( indexChange(int, int, int) ), + SLOT( slotHeaderChange( int, int, int ) ) ); + connect( listView()->header(), SIGNAL( clicked( int ) ), SLOT( slotHeaderClick( int ) ) ); } KMAtmListViewItem::~KMAtmListViewItem() @@ -154,118 +37,110 @@ mCBCompress = 0; } -void KMAtmListViewItem::paintCell( QPainter * p, const QColorGroup & cg, - int column, int width, int align ) +void KMAtmListViewItem::updateCheckBox( int headerSection, QCheckBox *cb ) { - // this is also called for the encrypt/sign columns to assure that the - // background is cleared - QListViewItem::paintCell( p, cg, column, width, align ); - if ( 4 == column ) { - QRect r = mListview->itemRect( this ); - if ( !r.size().isValid() ) { - mListview->ensureItemVisible( this ); - mListview->repaintContents( FALSE ); - r = mListview->itemRect( this ); - } - int colWidth = mListview->header()->sectionSize( column ); - r.setX( mListview->header()->sectionPos( column ) - - mListview->header()->offset() - + colWidth / 2 - - r.height() / 2 - - 1 ); - r.setY( r.y() + 1 ); - r.setWidth( r.height() - 2 ); - r.setHeight( r.height() - 2 ); - r = QRect( mListview->viewportToContents( r.topLeft() ), r.size() ); + //Calculate some values to determine the x-position where the checkbox + //will be drawn + int sectionWidth = listView()->header()->sectionSize( headerSection ); + int sectionPos = listView()->header()->sectionPos( headerSection ); + int sectionOffset = sectionWidth / 2 - height() / 4; - mCBCompress->resize( r.size() ); - mListview->moveChild( mCBCompress, r.x(), r.y() ); + //Resize and move the checkbox + cb->resize( sectionWidth - sectionOffset - 1, height() - 2 ); + listView()->moveChild( cb, sectionPos + sectionOffset, itemPos() + 1 ); - QColor bg; - if (isSelected()) - bg = cg.highlight(); - else - bg = cg.base(); - - mCBCompress->setPaletteBackgroundColor(bg); - mCBCompress->show(); + //Set the correct background color + QColor bg; + if ( isSelected() ) { + bg = listView()->colorGroup().highlight(); + } else { + bg = listView()->colorGroup().base(); } - if( 5 == column || 6 == column ) { - QRect r = mListview->itemRect( this ); - if ( !r.size().isValid() ) { - mListview->ensureItemVisible( this ); - mListview->repaintContents( FALSE ); - r = mListview->itemRect( this ); - } - int colWidth = mListview->header()->sectionSize( column ); - r.setX( mListview->header()->sectionPos( column ) - + colWidth / 2 - - r.height() / 2 - - 1 ); - r.setY( r.y() + 1 ); - r.setWidth( r.height() - 2 ); - r.setHeight( r.height() - 2 ); - r = QRect( mListview->viewportToContents( r.topLeft() ), r.size() ); + cb->setPaletteBackgroundColor( bg ); +} - QCheckBox* cb = (5 == column) ? mCBEncrypt : mCBSign; - cb->resize( r.size() ); - mListview->moveChild( cb, r.x(), r.y() ); +void KMAtmListViewItem::updateAllCheckBoxes() +{ + updateCheckBox( 4, mCBCompress ); + updateCheckBox( 5, mCBEncrypt ); + updateCheckBox( 6, mCBSign ); +} - QColor bg; - if (isSelected()) - bg = cg.highlight(); - else - bg = cg.base(); - - bool enabled = (5 == column) ? mCBEncryptEnabled : mCBSignEnabled; - cb->setPaletteBackgroundColor(bg); - if (enabled) cb->show(); +// Each time a cell is about to be painted, the item's checkboxes are updated +// as well. This is necessary to keep the positions of the checkboxes +// up-to-date. The signals which are, in the constructor of this class, +// connected to the update slots are not sufficent because unfortunatly, +// Qt does not provide a signal for changed item positions, e.g. during +// deleting or adding items. The problem with this is that this function does +// not catch updates which are off-screen, which means under some circumstances +// checkboxes have invalid positions. This should not happen anymore, but was +// the cause of bug 113458. Therefore, both the signals connected in the +// constructor and this function are necessary to keep the checkboxes' +// positions in sync, and hopefully is enough. +void KMAtmListViewItem::paintCell ( QPainter * p, const QColorGroup &cg, + int column, int width, int align ) +{ + switch ( column ) { + case 4: updateCheckBox( 4, mCBCompress ); break; + case 5: updateCheckBox( 5, mCBEncrypt ); break; + case 6: updateCheckBox( 6, mCBSign ); break; } + + QListViewItem::paintCell( p, cg, column, width, align ); } -void KMAtmListViewItem::enableCryptoCBs(bool on) +int KMAtmListViewItem::compare( QListViewItem *i, int col, bool ascending ) const { - if( mCBEncrypt ) { - mCBEncryptEnabled = on; - mCBEncrypt->setEnabled( on ); - mCBEncrypt->setShown( on ); + if ( col != 1 ) { + return QListViewItem::compare( i, col, ascending ); } - if( mCBSign ) { - mCBSignEnabled = on; - mCBSign->setEnabled( on ); - mCBSign->setShown( on ); - } + + return mAttachmentSize - + (static_cast<KMAtmListViewItem*>(i))->mAttachmentSize; } -void KMAtmListViewItem::setEncrypt(bool on) +void KMAtmListViewItem::enableCryptoCBs( bool on ) { - if( mCBEncrypt ) + // Show/Hide the appropriate checkboxes. + // This should not be necessary because the caller hides the columns + // containing the checkboxes anyway. + mCBEncrypt->setShown( on ); + mCBSign->setShown( on ); +} + +void KMAtmListViewItem::setEncrypt( bool on ) +{ + if ( mCBEncrypt ) { mCBEncrypt->setChecked( on ); + } } bool KMAtmListViewItem::isEncrypt() { - if( mCBEncrypt ) + if ( mCBEncrypt ) { return mCBEncrypt->isChecked(); - else + } else { return false; + } } -void KMAtmListViewItem::setSign(bool on) +void KMAtmListViewItem::setSign( bool on ) { - if( mCBSign ) + if ( mCBSign ) { mCBSign->setChecked( on ); + } } bool KMAtmListViewItem::isSign() { - if( mCBSign ) + if ( mCBSign ) { return mCBSign->isChecked(); - else + } else { return false; + } } -void KMAtmListViewItem::setCompress(bool on) +void KMAtmListViewItem::setCompress( bool on ) { mCBCompress->setChecked( on ); } @@ -277,10 +152,24 @@ void KMAtmListViewItem::slotCompress() { - if ( mCBCompress->isChecked() ) - emit compress( itemPos() ); - else - emit uncompress( itemPos() ); + if ( mCBCompress->isChecked() ) { + emit compress( itemPos() ); + } else { + emit uncompress( itemPos() ); + } } +// Update the item's checkboxes when the position of those change +// due to different column positions +void KMAtmListViewItem::slotHeaderChange ( int, int, int ) +{ + updateAllCheckBoxes(); +} + +//Update the item's checkboxes when the list is being sorted +void KMAtmListViewItem::slotHeaderClick( int ) +{ + updateAllCheckBoxes(); +} + #include "kmatmlistview.moc" --- branches/work/kdepim-3.5.5+/kmail/kmatmlistview.h #602742:602743 @@ -1,5 +1,5 @@ /* -*- mode: C++; c-file-style: "gnu" -*- - * KMComposeWin Header File + * KMAtmListViewItem Header File * Author: Markus Wuebben <markus.wuebben@kde.org> */ #ifndef __KMAIL_KMATMLISTVIEW_H__ @@ -15,48 +15,57 @@ class KMAtmListViewItem : public QObject, public QListViewItem { Q_OBJECT - friend class ::KMComposeWin; - friend class ::MessageComposer; public: - KMAtmListViewItem(QListView * parent); + KMAtmListViewItem( QListView *parent ); virtual ~KMAtmListViewItem(); - virtual void paintCell( QPainter * p, const QColorGroup & cg, - int column, int width, int align ); + //A custom compare function is needed because the size column is + //human-readable and therefore doesn't sort correctly. + virtual int compare( QListViewItem *i, int col, bool ascending ) const; + + virtual void paintCell ( QPainter * p, const QColorGroup & cg, int column, int width, int align ); + void setUncompressedMimeType( const QCString & type, const QCString & subtype ) { mType = type; mSubtype = subtype; } + void setAttachmentSize( int numBytes ) { + mAttachmentSize = numBytes; + } void uncompressedMimeType( QCString & type, QCString & subtype ) const { type = mType; subtype = mSubtype; } - void setUncompressedCodec( const QCString & codec ) { mCodec = codec; } + void setUncompressedCodec( const QCString &codec ) { mCodec = codec; } QCString uncompressedCodec() const { return mCodec; } + void enableCryptoCBs( bool on ); + void setEncrypt( bool on ); + bool isEncrypt(); + void setSign( bool on ); + bool isSign(); + void setCompress( bool on ); + bool isCompress(); + signals: void compress( int ); void uncompress( int ); -protected: - void enableCryptoCBs(bool on); - void setEncrypt(bool on); - bool isEncrypt(); - void setSign(bool on); - bool isSign(); - void setCompress(bool on); - bool isCompress(); - private slots: void slotCompress(); + void slotHeaderChange( int, int, int ); + void slotHeaderClick( int ); +protected: + + void updateCheckBox( int headerSection, QCheckBox *cb ); + void updateAllCheckBoxes(); + private: - QListView* mListview; - QCheckBox* mCBEncrypt; - QCheckBox* mCBSign; - QCheckBox* mCBCompress; - bool mCBSignEnabled, mCBEncryptEnabled; + QCheckBox *mCBEncrypt; + QCheckBox *mCBSign; + QCheckBox *mCBCompress; QCString mType, mSubtype, mCodec; + int mAttachmentSize; }; - #endif // __KMAIL_KMATMLISTVIEW_H__ --- branches/work/kdepim-3.5.5+/kmail/kmcomposewin.cpp #602742:602743 @@ -2307,6 +2307,7 @@ lvi->setText(1, KIO::convertSize( msgPart->decodedSize())); lvi->setText(2, msgPart->contentTransferEncodingStr()); lvi->setText(3, prettyMimeType(msgPart->typeStr() + "/" + msgPart->subtypeStr())); + lvi->setAttachmentSize(msgPart->decodedSize()); if ( loadDefaults ) { if( canSignEncryptAttachments() ) { 484713 13 winter 2006-11-06 19:25:41 +0000 SVN commit 602752 by winterz: merge SVN commit 602743 by winterz: Patch from Thomas McGuire that fixes the bugs: + Wrong checkbox in the layout when adding attachments to the composer + attachment display in editor: "sort by size" sorts alphanumerically, not by size Thanks for the patch Thomas and sorry it took so long. BUGS: 113458, 119526 M +104 -215 kmatmlistview.cpp M +31 -22 kmatmlistview.h M +1 -0 kmcomposewin.cpp --- branches/KDE/3.5/kdepim/kmail/kmatmlistview.cpp #602751:602752 @@ -1,147 +1,30 @@ // -*- mode: C++; c-file-style: "gnu" -*- -// kmcomposewin.cpp +// kmatmlistview.cpp // Author: Markus Wuebben <markus.wuebben@kde.org> // This code is published under the GPL. #include <config.h> #include "kmatmlistview.h" - -#include "kmmainwin.h" -#include "kmreadermainwin.h" -#include "messagesender.h" -#include "kmmsgpartdlg.h" -#include <kpgpblock.h> -#include <kaddrbook.h> -#include "kmaddrbook.h" -#include "kmmsgdict.h" -#include "kmfolderimap.h" -#include "kmfoldermgr.h" -#include "kmfoldercombobox.h" -#include "kmtransport.h" -#include "kmcommands.h" -#include "kcursorsaver.h" -#include "partNode.h" -#include "attachmentlistview.h" -#include "transportmanager.h" -using KMail::AttachmentListView; -#include "dictionarycombobox.h" -using KMail::DictionaryComboBox; -#include "addressesdialog.h" -using KPIM::AddressesDialog; -#include "addresseeemailselection.h" -using KPIM::AddresseeEmailSelection; -using KPIM::AddresseeSelectorDialog; -#include <maillistdrag.h> -using KPIM::MailListDrag; -#include "recentaddresses.h" -using KRecentAddress::RecentAddresses; -#include "kleo_util.h" -#include "stl_util.h" -#include "recipientseditor.h" - -#include "attachmentcollector.h" -#include "objecttreeparser.h" - -#include "kmfoldermaildir.h" - -#include <libkpimidentities/identitymanager.h> -#include <libkpimidentities/identitycombo.h> -#include <libkpimidentities/identity.h> -#include <libkdepim/kfileio.h> -#include <libemailfunctions/email.h> -#include <kleo/cryptobackendfactory.h> -#include <kleo/exportjob.h> -#include <ui/progressdialog.h> -#include <ui/keyselectiondialog.h> - -#include <gpgmepp/context.h> -#include <gpgmepp/key.h> - -#include <kabc/vcardconverter.h> -#include <libkdepim/kvcarddrag.h> -#include <kio/netaccess.h> - - -#include "klistboxdialog.h" - -#include "messagecomposer.h" - -#include <kcharsets.h> -#include <kcompletionbox.h> -#include <kcursor.h> -#include <kcombobox.h> -#include <kstdaccel.h> -#include <kpopupmenu.h> -#include <kedittoolbar.h> -#include <kkeydialog.h> -#include <kdebug.h> -#include <kfiledialog.h> -#include <kwin.h> -#include <kinputdialog.h> -#include <kmessagebox.h> -#include <kurldrag.h> -#include <kio/scheduler.h> -#include <ktempfile.h> -#include <klocale.h> -#include <kapplication.h> -#include <kstatusbar.h> -#include <kaction.h> -#include <kstdaction.h> -#include <kdirwatch.h> -#include <kstdguiitem.h> -#include <kiconloader.h> -#include <kpushbutton.h> -#include <kuserprofile.h> -#include <krun.h> -#include <ktempdir.h> -//#include <keditlistbox.h> -#include "globalsettings.h" -#include "replyphrases.h" - -#include <kspell.h> -#include <kspelldlg.h> -#include <spellingfilter.h> -#include <ksyntaxhighlighter.h> -#include <kcolordialog.h> -#include <kzip.h> -#include <ksavefile.h> - -#include <qtabdialog.h> -#include <qregexp.h> -#include <qbuffer.h> -#include <qtooltip.h> -#include <qtextcodec.h> +#include <qcheckbox.h> #include <qheader.h> -#include <qwhatsthis.h> -#include <qfontdatabase.h> -#include <mimelib/mimepp.h> - -#include <algorithm> - -#include <sys/stat.h> -#include <sys/types.h> -#include <stdlib.h> -#include <unistd.h> -#include <errno.h> -#include <fcntl.h> -#include <assert.h> - -KMAtmListViewItem::KMAtmListViewItem(QListView *parent) +KMAtmListViewItem::KMAtmListViewItem( QListView *parent ) : QObject(), - QListViewItem( parent ), - mListview( parent ), - mCBSignEnabled( false ), - mCBEncryptEnabled( false ) + QListViewItem( parent ) { - mCBEncrypt = new QCheckBox( mListview->viewport() ); - mCBSign = new QCheckBox( mListview->viewport() ); - mCBCompress = new QCheckBox( mListview->viewport() ); - connect( mCBCompress, SIGNAL( clicked() ), this, SLOT( slotCompress() ) ); + mCBCompress = new QCheckBox( listView()->viewport() ); + mCBEncrypt = new QCheckBox( listView()->viewport() ); + mCBSign = new QCheckBox( listView()->viewport() ); + mCBCompress->setShown( true ); + updateAllCheckBoxes(); - mCBEncrypt->hide(); - mCBSign->hide(); + connect( mCBCompress, SIGNAL( clicked() ), this, SLOT( slotCompress() ) ); + connect( listView()->header(), SIGNAL( sizeChange(int, int, int) ), + SLOT( slotHeaderChange( int, int, int ) ) ); + connect( listView()->header(), SIGNAL( indexChange(int, int, int) ), + SLOT( slotHeaderChange( int, int, int ) ) ); + connect( listView()->header(), SIGNAL( clicked( int ) ), SLOT( slotHeaderClick( int ) ) ); } KMAtmListViewItem::~KMAtmListViewItem() @@ -154,118 +37,110 @@ mCBCompress = 0; } -void KMAtmListViewItem::paintCell( QPainter * p, const QColorGroup & cg, - int column, int width, int align ) +void KMAtmListViewItem::updateCheckBox( int headerSection, QCheckBox *cb ) { - // this is also called for the encrypt/sign columns to assure that the - // background is cleared - QListViewItem::paintCell( p, cg, column, width, align ); - if ( 4 == column ) { - QRect r = mListview->itemRect( this ); - if ( !r.size().isValid() ) { - mListview->ensureItemVisible( this ); - mListview->repaintContents( FALSE ); - r = mListview->itemRect( this ); - } - int colWidth = mListview->header()->sectionSize( column ); - r.setX( mListview->header()->sectionPos( column ) - - mListview->header()->offset() - + colWidth / 2 - - r.height() / 2 - - 1 ); - r.setY( r.y() + 1 ); - r.setWidth( r.height() - 2 ); - r.setHeight( r.height() - 2 ); - r = QRect( mListview->viewportToContents( r.topLeft() ), r.size() ); + //Calculate some values to determine the x-position where the checkbox + //will be drawn + int sectionWidth = listView()->header()->sectionSize( headerSection ); + int sectionPos = listView()->header()->sectionPos( headerSection ); + int sectionOffset = sectionWidth / 2 - height() / 4; - mCBCompress->resize( r.size() ); - mListview->moveChild( mCBCompress, r.x(), r.y() ); + //Resize and move the checkbox + cb->resize( sectionWidth - sectionOffset - 1, height() - 2 ); + listView()->moveChild( cb, sectionPos + sectionOffset, itemPos() + 1 ); - QColor bg; - if (isSelected()) - bg = cg.highlight(); - else - bg = cg.base(); - - mCBCompress->setPaletteBackgroundColor(bg); - mCBCompress->show(); + //Set the correct background color + QColor bg; + if ( isSelected() ) { + bg = listView()->colorGroup().highlight(); + } else { + bg = listView()->colorGroup().base(); } - if( 5 == column || 6 == column ) { - QRect r = mListview->itemRect( this ); - if ( !r.size().isValid() ) { - mListview->ensureItemVisible( this ); - mListview->repaintContents( FALSE ); - r = mListview->itemRect( this ); - } - int colWidth = mListview->header()->sectionSize( column ); - r.setX( mListview->header()->sectionPos( column ) - + colWidth / 2 - - r.height() / 2 - - 1 ); - r.setY( r.y() + 1 ); - r.setWidth( r.height() - 2 ); - r.setHeight( r.height() - 2 ); - r = QRect( mListview->viewportToContents( r.topLeft() ), r.size() ); + cb->setPaletteBackgroundColor( bg ); +} - QCheckBox* cb = (5 == column) ? mCBEncrypt : mCBSign; - cb->resize( r.size() ); - mListview->moveChild( cb, r.x(), r.y() ); +void KMAtmListViewItem::updateAllCheckBoxes() +{ + updateCheckBox( 4, mCBCompress ); + updateCheckBox( 5, mCBEncrypt ); + updateCheckBox( 6, mCBSign ); +} - QColor bg; - if (isSelected()) - bg = cg.highlight(); - else - bg = cg.base(); - - bool enabled = (5 == column) ? mCBEncryptEnabled : mCBSignEnabled; - cb->setPaletteBackgroundColor(bg); - if (enabled) cb->show(); +// Each time a cell is about to be painted, the item's checkboxes are updated +// as well. This is necessary to keep the positions of the checkboxes +// up-to-date. The signals which are, in the constructor of this class, +// connected to the update slots are not sufficent because unfortunatly, +// Qt does not provide a signal for changed item positions, e.g. during +// deleting or adding items. The problem with this is that this function does +// not catch updates which are off-screen, which means under some circumstances +// checkboxes have invalid positions. This should not happen anymore, but was +// the cause of bug 113458. Therefore, both the signals connected in the +// constructor and this function are necessary to keep the checkboxes' +// positions in sync, and hopefully is enough. +void KMAtmListViewItem::paintCell ( QPainter * p, const QColorGroup &cg, + int column, int width, int align ) +{ + switch ( column ) { + case 4: updateCheckBox( 4, mCBCompress ); break; + case 5: updateCheckBox( 5, mCBEncrypt ); break; + case 6: updateCheckBox( 6, mCBSign ); break; } + + QListViewItem::paintCell( p, cg, column, width, align ); } -void KMAtmListViewItem::enableCryptoCBs(bool on) +int KMAtmListViewItem::compare( QListViewItem *i, int col, bool ascending ) const { - if( mCBEncrypt ) { - mCBEncryptEnabled = on; - mCBEncrypt->setEnabled( on ); - mCBEncrypt->setShown( on ); + if ( col != 1 ) { + return QListViewItem::compare( i, col, ascending ); } - if( mCBSign ) { - mCBSignEnabled = on; - mCBSign->setEnabled( on ); - mCBSign->setShown( on ); - } + + return mAttachmentSize - + (static_cast<KMAtmListViewItem*>(i))->mAttachmentSize; } -void KMAtmListViewItem::setEncrypt(bool on) +void KMAtmListViewItem::enableCryptoCBs( bool on ) { - if( mCBEncrypt ) + // Show/Hide the appropriate checkboxes. + // This should not be necessary because the caller hides the columns + // containing the checkboxes anyway. + mCBEncrypt->setShown( on ); + mCBSign->setShown( on ); +} + +void KMAtmListViewItem::setEncrypt( bool on ) +{ + if ( mCBEncrypt ) { mCBEncrypt->setChecked( on ); + } } bool KMAtmListViewItem::isEncrypt() { - if( mCBEncrypt ) + if ( mCBEncrypt ) { return mCBEncrypt->isChecked(); - else + } else { return false; + } } -void KMAtmListViewItem::setSign(bool on) +void KMAtmListViewItem::setSign( bool on ) { - if( mCBSign ) + if ( mCBSign ) { mCBSign->setChecked( on ); + } } bool KMAtmListViewItem::isSign() { - if( mCBSign ) + if ( mCBSign ) { return mCBSign->isChecked(); - else + } else { return false; + } } -void KMAtmListViewItem::setCompress(bool on) +void KMAtmListViewItem::setCompress( bool on ) { mCBCompress->setChecked( on ); } @@ -277,10 +152,24 @@ void KMAtmListViewItem::slotCompress() { - if ( mCBCompress->isChecked() ) - emit compress( itemPos() ); - else - emit uncompress( itemPos() ); + if ( mCBCompress->isChecked() ) { + emit compress( itemPos() ); + } else { + emit uncompress( itemPos() ); + } } +// Update the item's checkboxes when the position of those change +// due to different column positions +void KMAtmListViewItem::slotHeaderChange ( int, int, int ) +{ + updateAllCheckBoxes(); +} + +//Update the item's checkboxes when the list is being sorted +void KMAtmListViewItem::slotHeaderClick( int ) +{ + updateAllCheckBoxes(); +} + #include "kmatmlistview.moc" --- branches/KDE/3.5/kdepim/kmail/kmatmlistview.h #602751:602752 @@ -1,5 +1,5 @@ /* -*- mode: C++; c-file-style: "gnu" -*- - * KMComposeWin Header File + * KMAtmListViewItem Header File * Author: Markus Wuebben <markus.wuebben@kde.org> */ #ifndef __KMAIL_KMATMLISTVIEW_H__ @@ -15,48 +15,57 @@ class KMAtmListViewItem : public QObject, public QListViewItem { Q_OBJECT - friend class ::KMComposeWin; - friend class ::MessageComposer; public: - KMAtmListViewItem(QListView * parent); + KMAtmListViewItem( QListView *parent ); virtual ~KMAtmListViewItem(); - virtual void paintCell( QPainter * p, const QColorGroup & cg, - int column, int width, int align ); + //A custom compare function is needed because the size column is + //human-readable and therefore doesn't sort correctly. + virtual int compare( QListViewItem *i, int col, bool ascending ) const; + + virtual void paintCell ( QPainter * p, const QColorGroup & cg, int column, int width, int align ); + void setUncompressedMimeType( const QCString & type, const QCString & subtype ) { mType = type; mSubtype = subtype; } + void setAttachmentSize( int numBytes ) { + mAttachmentSize = numBytes; + } void uncompressedMimeType( QCString & type, QCString & subtype ) const { type = mType; subtype = mSubtype; } - void setUncompressedCodec( const QCString & codec ) { mCodec = codec; } + void setUncompressedCodec( const QCString &codec ) { mCodec = codec; } QCString uncompressedCodec() const { return mCodec; } + void enableCryptoCBs( bool on ); + void setEncrypt( bool on ); + bool isEncrypt(); + void setSign( bool on ); + bool isSign(); + void setCompress( bool on ); + bool isCompress(); + signals: void compress( int ); void uncompress( int ); -protected: - void enableCryptoCBs(bool on); - void setEncrypt(bool on); - bool isEncrypt(); - void setSign(bool on); - bool isSign(); - void setCompress(bool on); - bool isCompress(); - private slots: void slotCompress(); + void slotHeaderChange( int, int, int ); + void slotHeaderClick( int ); +protected: + + void updateCheckBox( int headerSection, QCheckBox *cb ); + void updateAllCheckBoxes(); + private: - QListView* mListview; - QCheckBox* mCBEncrypt; - QCheckBox* mCBSign; - QCheckBox* mCBCompress; - bool mCBSignEnabled, mCBEncryptEnabled; + QCheckBox *mCBEncrypt; + QCheckBox *mCBSign; + QCheckBox *mCBCompress; QCString mType, mSubtype, mCodec; + int mAttachmentSize; }; - #endif // __KMAIL_KMATMLISTVIEW_H__ --- branches/KDE/3.5/kdepim/kmail/kmcomposewin.cpp #602751:602752 @@ -2273,6 +2273,7 @@ lvi->setText(1, KIO::convertSize( msgPart->decodedSize())); lvi->setText(2, msgPart->contentTransferEncodingStr()); lvi->setText(3, prettyMimeType(msgPart->typeStr() + "/" + msgPart->subtypeStr())); + lvi->setAttachmentSize(msgPart->decodedSize()); if ( loadDefaults ) { if( canSignEncryptAttachments() ) { 504711 14 mcguire 2007-01-28 17:38:34 +0000 *** Bug 125742 has been marked as a duplicate of this bug. *** 12734 2005-09-27 20:26:28 +0000 2005-09-27 20:26:28 +0000 Screenshot with the bug kmailbug.png image/jpeg 43556 aironmail iVBORw0KGgoAAAANSUhEUgAAAsgAAAIdCAYAAAAgWIvqAAAgAElEQVR4nOzdeXgURf748XfPmZnc IRfk5AwkhBvxQkEuUSOHgIIoqLjil/ViXdfVVVf3py6667HqeouiBkUQEFhAFAEFueQKVwgEQkJC 7nOSzNX9+2PIkJBrkpmQIPV6nn4yM91dVV3TU/lMTXW1VFSpADBo0iOOB4IgCIIgCIJwGdqz/E0J QAOO4HjsXY+3b4kEQRAEQRAEoR0NmvSIsmf5m5IUO+5hZexdj3O6yNreZRIEQRAEQRCEdlNwKoWC QxsdPcgAVnNVe5ZHEARBEARBEDoEESALgiAIgiBcpipL87CZit1OR+MdiNE/9JJNt976mgdWS7Xb mQmCIAiCIAiXBmtVGTZTMQnxfdxO69DhI1QCWoPfJZduQzTnH0otTtxmU5AkBbVa1criCYIgCIIg CO3BZiohIT7eI2klxMdz6PARtAb/Sy7dhpwPkCXXAuTqapnuoQFcGxdIVLAXdrvCsWwTW48Wkldh Quel9kjBBUEQBEEQhDYkSS7Hfy1K71JLtwGa89s0k6ECKrT8+baejIzzwagDjUqi2qowPMGf6SMj +HZnMUt/OobaW/QoC4IgCIIgdGSSJDUf/7UivUst3Ya43IOsQss9N/YiLkyNyWxDktSYrXYKKmzO ba7v401BVU82/XoMta+midQEQbhUqCRQSRI2+fdzLyGdRoXNriArnjkmjUrCLiv8fmpIEITLwqXW 09sePcjQeK9vdbVMn67+dA+QCfI14uelRqeGwrJy9v2chlqnw67REhzpR+9ONvb4+1BUUY7eqPfc QQiCcNFp1RLPTurOW99nkFdqabJh2vrsFfx1SRpbjrp/dXFb++mpK3jy62NsOVrikbY2yEfHvNFR /L8V6Vjd/CJxYT128tHy0ZwEvtyWw9Kdue4XVhAEwUmF1ET815r0apaG0l00t2+zKdz93sFWp9vQ vk2tO59ufS4NsQgJ9OVY+ilODe1GJ6sKSQVnsnPYvvMkYwfH0qNHCOXlVn7dkcnPP6dy8lg+YV27 g7cHo3xBEC66+eNjOZVfyanUgxhDuiJp9I1ez/voF6n8tm0TVt9YdD5BF7WcrVGZfRRbpR6dd1Br rlGuI7/cSmaBif8b7s9/NhWDyr1/OKYzR7Ca9PgGBLPgjl78klrEJ1+vxiswCn1gZ/cKCwyPC+TY WRO5pZYOlZYgCBeX5OEe2TrDIFqZbub+H4kaMLpV6S6a25e73z90/vkDCS6l25Bmh1goCthtFkL8 jaSl7KPiuIU+UUZW/7QbrT2UuBlXkZ6eR2RkGDeOjeOWm+IoLa1m4+bT/HigkAMqbeO1IAhChxXf xZurevqT9MxykFTnxlpAY9Hk7lPlVKr90Wu0KIqMpOr4F+wqdgsKMpLkflk//zWXJf/Xl++2p3PK Gux+4WQLT90aS0W1nf/30RrUOiNan0AU2Y6kdm8I28vTevDnz/eSU2RBpXHvlz5PpiUIwkXWDkMh Rj74ZqO7//TuI+fTaUG6d39wmEV/cMxuseiBhDrP6+TZWLoNaLYHWW2tYKAuk34x/sT36U6X8Gh8 vA3kF5ejsYZgtkio1Voysyrw9fNBrwODlxfXXdOFYUOCmf7ZyUYrQhCEjmvSkFA2HcrHVJyPd1Rf VCoND42JZkzfThh0Kiw2mTe/z+T7g0UA/Pz0YP76lQ9bjpWw9dlhPL/iJP2jfRjbNwhFgXc3nmHl nvwG8/r56cFNbt8t1MCjY6Po08WbSoud9SlFfPDTGee46J+fHsyCNRncPCCYPp2NbDxSzJvfZ/LS lO70jfRm98lynvrmBGab7MwzOMCbDyYOJDEmkH0Z5Ty/4iQllTZneu9uPMPEQcEs3ZXHkp15dA0x 8PCYSLqHGlFQ+OVYKW9+n4nlXJpWWWJLahGTr4zmlfXZaL0D3ar/+8fE0TPcm7te/g6bzY5Plx6o 1BoktZZuYc3XR2P1+eG9jvlDX7yjH7uOF/HksgymXxVO0sBgQnx12GWFHw4V8dq609SMFokN9uL/ RkUyINoXrUYir8zCPR8e4c2Zveql5dF/toIgtC0PX/RGrV7eptKNHjS2mWTqB7LNpTvrwyN8dr+j fWsoOG4wT9d6kBv+SXDeUBujr5uIYrej02nx0ulRqdX07RFJUa6KsjLwDwhix440evTszqn8PHx8 FGJiAtm7r6DRdAVB6NgGxvjyweo01F4+qNQaBnULYtqwMKa8tJ6jqccx6lR4eekwGyPQ+4cBYMo5 hq3KAMDc60NYuj2b21ZsZ+a10fzhut4s2ZiCPrBLg/k1tr1/aCSvTe/JpsMF3L/gW4KNsOjpKVSW Gvl0d6UzIJs60Jd/rkxBZS7hvUdvJMIX3t2URcmZ43z+5C0k+pewq8AP6dzwhwcnXclrKw/x0qkz /PeRsfzhSm/+uaEIlcbxq1dSog9/T/6NI0eOIfmG8vojY1i2M5v7F3yLQWUj+dkpTOun5fM9ZqRz 7dzJIpk7hkRh/noPWmNgq4da3HhlHKOH9uD2BRsoKsjHu0scklqLpPHCS6dyqT4aq8/7F6r4+amB PP72GjbuSUdjDOBkz0Ae+M8Wsk6fZEC3Tiz62xRWbjlAWmUg3noNb86MIy2nnEnPLyf7TDbRYf7k FVUx52Mrv/xtaJ20fGP6t+qYBUG4+KQmxuC2Oj1J5UK6zeVZd72r6c76MJXP7o9zPj8fHN/YZHmb KYHU4FJkUWMweONnNOJ9PA3N9m2QdozoqCgyc3LIzYeCIvD1DeDA/jQiIgOIjumMWuPF8p/SG01X LGIRS8deQny1lBQXozH4oVJrKKm2A3DrwBD69ktE0zkea0A31Bodiv38bDay1XFXzi/W7eW9rzaQ V2zicL6Cn7eeytx0FJu1gfwa335ItJFOPlr+u3g9NjuU6iNZfyCfm4dGUpV3AhTH/p+s3s2vO/fy W5YZgK837GHzpi0cybViqrZhVFkxl+Y6t/9o1S5Wb9xJerHCuv15XN8visqcVGqmovho1S627dxH pTaQa/rG0MlHy969BxjYK4J+AwdxosDC1XEhVOWdb+fKq2XCAr2xVZYh2xs6TlcWyC2qABTGxPtj COmKSuuFSmsASWJIVz+X6qPp+ncwhHXHGNadbUfyKKiw4Nc5lkK14wuMj2LCUl7AtT0DCPLW8MKH a8jOK8IQHkeBLhZ9p27O97p2WrKlut3PXbGIRSwuLhdMn+bu4viC3ni6NRrdv5H1zaVbs9QOjsEx ZCNm8Pjmy1tncWh2iMWe9AqSqhWCDRrknr1Rpx9HKixE16MX5Zj4fOVOuoeGEN8nkh69QqisBrsC NquFnacr8E7o1GC6giB0bHYZJBTHeFdJzcl8M49/nsLtQ0KZOW4gGYVV/Ot/WRzIrHD2ytaWcbYY XUAoev8wVDpvABTZhmy3oNHWH6va2PZB5y72zS8swRCViErvTYlZTUiAN9WleXh1igGgzFSNPiAc rXcn53OdbzA6vxAUSUJCApsZFEegn1NQhi4gHL1fCMXVKvy89dgqS1BsjgC7qLQSfUA4et9OBPn7 ADDh2jjUXj5IkhpFgX0n8rFWFKMEO8bfqs9N9ybbLCDb67Srt/QP4uExEefqVmH8aw1dUe2w99gZ DudU8sp9wym27GbdCbWzlzrYR+tSfTRV/7WpdUYmDAnjpsREckoslJ/7IgQgW82E+Dj+TWSeLcTY JQG1zohaZ0TW2eq972qd0e3x0YIgXERtMAbZGXg2lW5zeTYxxKKxfT+9r6fz8cgH33SOZ/50Ti9m f5zWdHkb0OxFeqcqDRxIy2ZEv0jQ6ZF0ejSnTiEFdWJAYk9ydTYKJD3Ld+1HU2YlzK8T/ftHs2// STRRQZ6teEEQLprMIjPB/kagzBEISRLbM8z8tHMrPhoLf5l2BX+fEMWEf/+GxrvhW3XW9HxKWt35 FxWl0Xahoe0LyhwBXSd/b6rVOtRaA8H+XhSUVaHYrSj28z2iklqDWudV77kEzo6B2rMVq7R61DoD QX4GckuqkO02ZPl8b7ik0aLSenG2wjHO+K1vtnGmHOcFiIpsQ633dvSga70I8tGSkWdCkkBBrnOc qw8Us3TzISpzjjlfC4of0WA9AGw6WsLrK/bz12mDKfl0FztyHcdVaLK5XB+N1n8t/aJ9ePzGSG57 ZQvH09JQ6wxMHDzDuT6v3PGFISYsgEKNDpXeCCoVKrWOeiREmy8Il5DGZoX49N4eze47+5PjjabX 7CwWLQyQm0u3dnlrhlXM/uS48/VP7+vZZHkbUqsHueExGBZ9KJt2p3FlQiR6qxlFVlCqqpB1XnTv HIHxwC90TRyOvk9nDBqFn385zCNvJGP0C8SvXw/RWArCJerX9HL69ezCst8KAYnoTgYCjD4cRMZi rqDQ4pjyrTzzAIFx1zSajkqlcfTe1tJYe9PQ9rtOFFNQZub+W4fy3y1FRAQaGNc3kG9/TkVSa1AU uc7+EuoLntceSSbVy9vXoOOGPgGs/DXN0ft5QQApSWr2nq4kLaec5+eM4eXVJzlbZsegVRMdbORo doXj4jlJRXwXIz8fykbS6Bo8Tq3RD+8ucah1RgBslWVovQMarYtlByoJC0jl/80cxEMf7SG1zMhv GZUtqo+G6r/KIhMc4I2UXUmg0VFWf1se4RGxjB4UDUB0eAA7c8rYllZOYbmZ5+4dzav/y6BcpaNb iBfp+WZMZnudtCRUTb63giB0NK2fBzlj1xpihybVT09qfL5iqDVTRRPq79t8unA+OK4p1z2fpLPw 3m4ulLe+5qd5Q+LI6VKO5sv086qGgkJKbpzACXUQBw/bOZ1ZSr9BClqVzLfrD/PzodOED79CBMaC cIlbvqeYj+6OJkC3j2pFwahX88jocKICY0CSOFlQzZOfbAVFwVZtajyhhnoVm+xZqLu+2irzp8Wp PDIylA3P9KXaBusPFPDON1vQeQfWH95xYdKN5PXC/WPJKa7Gy8uLHw4X887Sn9H6BNVvLCXHsLH5 yceZc6WRj+cOwdugo7xaZtPRElJXp6HSe9PJR8OgGB9eWpiC1uiPJKnr5a0x+KMxNNzb3hC11ov3 thQSHmDg37P6M/ejA2RVG1teHxeUY9Gv+Txx5/WE/niMb/aX8v3+HN5/YhIllVa+3lnAok0neXTa taQXb+VgsY2HFx3moRHBfP7wMEDiZIFjuI0s6+uklbzHLNp+QbiUNNKDes/Ck5za+Z1r+zeUXjum G3vFrY3n2Vi6DRUhdtzDyti7HufomfJGy6mqLuL6+BBGXBnHzpMye46UU3ZyP9aysyiSgs0ngtKK cgydAtA28lOrIAiXnrE9Ja6J9eJvK8+gNgZhMxVSnnXEeXGWSqt3jPv1CUbrHUjBgfUYw3tgCIqi 8PBPzseSRkd1QQYV2Ufx7zYErU/9axNq71tve+8gTDnHsFQUIlsqQVKjMfhgDIlFpfdBrTPU27/g wHqMYd0xdIpG0ugoPPgDhuBovDrFoNLqKTiwHkmlRqUzIikyKp0BQ3AMar0Rlc5YLz2Ayvx0rOVF 2KpKQZGRVFq0PsH4RfbhpamxbD5SzJffrMQnIh6NMQC1ztCqer8wb0t5PpVnT2A3V+DfdSgao1+L 6+PC+i9L343FVIwxOAadXzgVOYewVVWgUmvRB4Rjs1RgLSvCN7over9wTHnHsJYXYzeXg6JCrTfi E90Ptd5I+ck9zrSM4b3qf0kRBKFDqirIoG98H4+ld/DwEQzBMZdcurVV5qZRcGija3fSUwyd2Pjz IdZszEFty8PgqyAHdoOAeFAUJJUa/07iYjxB+L35PtWGZCnE15JDpTEAtd4HY2hXJLUGSXWu+ZDU aA0+SJKEMawbWmMAXPBYkiS0fsH40NuxSwPtTZPbq1QYw7qiMfoiqdTOvFU6Axq9scH9jWHdHHMR 1zwP7YbGO+DchdA16x13/FMUO5KkRq03oD53QduF6QEYg2Ox6H1AlpE0GpRzgxdCvGF7egVfr9mC zjcYtVaPRufV6t7UC/PW+4WALKOgoCh2QGlxfVxY/8bw7uirTah0BlRaLcbQriiycm6aOwkdIdgD OqPS6lGw4x3SHbNXvqNnXK1xxMCyrV5asrUK9bkyCILQwbXXRXodLd0GNDsPcg1VVAKOfxudURAd BIJwOZA0Ov6XWkmVCfTqInT+YXh1im50e+/OvRt8DKDx8kPj5efSvg1tr9Ia8AqKcnn/C58bw3s2 ub659AAktQp9QP1bPeebYfmus6i1erwCu6D28gFV62dzaCjvC+ePltTaFtXHhfWp9QlG63P+jn9q L59my9VYfhemJQjCpaLu1GYeSU9SXYLp1udSD7IgCJevmjvCSSrtuWEFHf8W0u1BrdZhCI5CpfVq 9dAKQRCEi0nvF8KhI0c9Mmzh4OEj6P1CnL96XUrpNqTZi/QEQRC0PkHtXYQOT9Lq0GrFUDNBEC4d GoMv4AgW3aXzDXamd6ml25BavwGKAFkQBEEQBOFyojH4oTE0Pvztckm3Xj41D2q6mC3lBW2eqSAI giAIgiB0FDrfutdR1LmKxFJewI9/GXBRCyQIgiAIgiAI7WnUgn11guR6l1lXVVVd1AIJgiAIgiAI Qkci7gkqCIIgCIIgCLWIAFkQBEEQBEEQahEBsiAIgiAIgiDUIgJkQRAEQRAEQahFBMiCIAiCIAiC UIsIkAVBEARBEAShFhEgtxOz2Yzdbm/vYghCHeK8FAShrYj2RbiUtDhADgwMJDAwkJMnT9ZbN2/e PAIDA1mzZo1HCueuwMBAVq5ceVHyaWzZu3dvg/uEh4ezbt26Oml0lHp76qmn6NevH7Is11u3fv16 evfujc1ma4eSOWzfvp2pU6cSHR1NcHAwQ4cOZcGCBVRXV3ssj470frhr3bp1BAYG8sYbbzS7bUPn 5cX4DF0sgYGBfPjhh/VeX7hwIYGBge1Qopb5PZ2XNS5sM4OCgoiOjubWW28lLS2t1ekuWbKEHj16 0LVrVyorKz1YYs/oSO9lS9oId1zYvghCR9bqHuSlS5fWeV5VVcV3333ndoE8afny5Vx11VUXJa+X X36Z/Pz8esuAAa7dmXD58uVcccUVAKxZs4asrKy2LG6T7rzzTjIzM9myZUu9dV999RW33347Gk29 e8xcFMuXL+eWW26hb9++bNu2jdOnT/PKK6/wzTffcOutt2I2mz2WT837calLTk5GkiSSk5NRFKVF +3ryM9Te5/XvgSfPy470ftS0n3l5eZw8eZLFixeTkZHBgw8+2Oo0n3nmGR555BGOHj2Kl5eXB0vr GR2pjXGnjRCE36tWBchXXHEFS5YsqfNBWrNmDfHx8R4rmCeMGDGC0NDQi5KXWq1Go9HUWyRJcmn/ ESNGEBISAsDMmTPZv39/Wxa3SQkJCQwcOJDPP/+8zuslJSWsXbuW6dOnt0u5ysvLeeyxx5g1axbP PfcckZGRGI1GRo4cydKlS9m3bx/vvfeeR/Kq/X5cygoLC1m3bh1/+ctfSEtLY8+ePS3a35OfofY+ r38PPHledqT3o6b91Gq1+Pv7c8011zBlyhS3ypeXl0dUVBR6vR6VquONJuwobYy7bYQg/F61qtWY OnUqx48frzN84KuvvmowcDp69CiTJk2iV69exMXF8dhjj9Xp5QsMDGTZsmXMnz+fqKgoYmJiWLhw IQB2u52nn36aXr160aVLF7p168aSJUuc+7711lsMHTqUiIgIoqOjmT9/fp1hAbV/Hm6uHG1tw4YN jBo1ihEjRpCQkFBvfc3PbTfccAMA9913H7fffjvg2nG++eabDBgwgHfffdcj5Z05cyZr1qyhuLjY +dry5cvp06cPvXv3Blx7bz1Zrg0bNlBaWsrs2bPrrYuNjWXkyJF88803dfJfuHAhN910E6GhoUya NImCggLn+tTUVKZNm0ZkZCShoaEMHDiQiooK5741P38ePnyYpKQkIiIiiIuL47nnnsNqtdbJp7Fz uLl6au4cd9fSpUvp1q0bjz/+OJ07d2bx4sV11rtyXtZ8hi78Sbih543VQ0c5r13VmnO7oddcOcZF ixYxduxYQkJCuP/++yksLGT8+PEEBwdz22231Rk6VLvO3WlbW/p+tPV52pDs7GxnANlQ3TZ1/N26 dQNg7ty5PPTQQy7XV0vyqNmnqc++q21Me9Z9U23EjBkzuO++++ps/+c//5nHH3+83jE09Ly59qW5 z4cgtKdWBciDBg2ia9euzg9pbm4u27ZtY+LEiXW2q6ysZOLEiVxzzTWkpqayY8cOtm7dyuuvv15n u2eeeYbo6Gi2b9/O9OnTeeGFFwDYtm0b//3vf1m9ejXZ2dkcOHCAkSNHOvfr06cPq1at4syZMyxZ soSFCxeyc+fOeuV1tRxt5eDBg8yYMYNnnnmGTZs2cejQoUa33bhxIwAff/wxX3/9NeDacS5cuJC3 337b+c/OXZMnTwbqDqVZvHix80uQq3XqyXIdP34cgJ49eza4Pi4urt6YxQULFjB79mzWrVvH4cOH efbZZwEoKyvj1ltvRZZltm/fTk5ODkuWLEGv19fZv7KyksmTJxMXF8fJkydZv34933zzDa+88kqd 7Ro7h5urp+bOcXclJyczc+ZM1Go1M2bMYNmyZc5/8C05L13VWD10lPMa4Iknnqg37nX+/PnO9e6c 2xe+5soxvvPOOzz//PMsWbKEpUuXMnXqVJ566inWrVvHxo0b+fHHH+sdg7tta0vfj7Y+T2vIskxe Xh7vvvsu33zzDXPmzHGuq123zR1/eno6AO+//z5vvfVWq95Td+vY1TYG2rfum2oj7rjjDtasWUNZ WRngOO++/vpr7rnnnmbTdaV9cfV/uCC0h1YFyJIkMXXqVJYtW4bNZuObb75h3LhxBAQE1Nnuxx9/ JDc3l4EDB7Jjxw6OHj1KQkJCvQZ/7ty5PProo0RERDBs2DBKSkoA6NSpEwCfffYZR48exdvbu85P UqNHjyY8PByz2Uz37t0Bx89FF3K1HO5o6J/uM888A8CXX35J165dGTFiRKvSduU4H330Ua699lqC goLcOo4aAQEBJCUlOYdZnDhxgn379jkDZ1fr1NPlakpDY+fmz5/PtGnTGDRoEDNmzGD9+vUArF27 lry8PBYsWEBkZCRqtZqePXui1Wrr7L9p0yZyc3P505/+hE6nIzY2lttvv71eT2xj53Bz9dTcOe6O gwcPcvjwYaZNmwY4xpaXlJQ4L5Jx97xsSGP10JD2OK+h4esFXn31Ved6d87tC19z5Rgffvhhrrrq Kuf7MGvWLIYPH86QIUPw9fWltLS03jG427Y2pKmytuV5Cufbz06dOtG3b1+++uorXn31VR577DHn NrXrtqVtemveU3fr2NU2Btqv7ptrI8aNG4eXlxcrVqwAYNmyZcTFxTXYG3whV9oXV/+HC0J7aPWV VlOmTOGVV15h06ZNfP311/ztb3+rt03Nz9lffvmlcyyuSqVi2LBhdbar+WDUrK8RHx/P4sWLefvt t3n//ffp0aMHb775pnP/hQsXkpycTHR0dL3gvDXlcMcrr7zC/fff3+C606dPExYW1uq0XTnOthjL NnPmTCZOnMj+/ftZs2YNY8aMITg4GHC9Tj1Zrh49egCQlpZGYmJivfXHjh1zblMjIiLC+Tg0NNTZ E5KTkwNATExMk3nm5uY6962dTs3rNRo7h5urp+bOcXckJydjs9mIi4ur8/rixYuZMGGC2+dlQxqr h4a013ldM971wtdquHNuX/iaK8dY83pNXrW3a+waBnfb1oY0Vda2PE8BXnzxRedP+TqdrsHjrl23 LW3TW/OeulvHrrYx0H5131wbodfrmTx5MosXL+buu+9m4cKFdXr1m+JK++Lq/3BBaA+tDpB79uzJ gAEDePHFF8nNzXWOaautpmF46qmn6gUurrrxxhu58cYbKSoq4oknnmD27NkcOXKE7du3M3/+fHbv 3u1soD755JMG0/BEOdzh5+dXZ1q82uNgm9OS4/S04cOHExUVxaJFi9iwYQMvvfSSc1171OmYMWPw 8/Nj4cKFvPbaa3XWZWRksGnTJp588slG9z9z5gxRUVEAdOnSBXD8FNurV69G96lp4PPz8wkPDwfg 7NmzLgeWrtRTY+e4OywWi/Mn+1GjRjlfX7RoEfPnzycvL69V52VNL727sx+053ndHE+d2215jJ7+ /LlS1rY4T2totdoGhx40pqXH35r6creOXW1j2qvuXWkjQkNDmTFjBmPGjGHlypWcOHGCSZMm1Umn sTahufalI7cBggBu3ihk6tSp7Nu3jylTpjT4s9F1111H3759eeSRRzh58iSKolBRUdHo3MAXOn78 ODt27MBqteLv7+8MbuD8h+3MmTMUFBQ4L4xIT0+vN0evu+Vwhd1ux2az1VtkWWbs2LHOoL6wsLDR nuYa3t7e5OXloShKi47T01QqFXfeeSefffYZJpOJsWPHOtddjDq9kK+vL6+//jqfffYZ//jHP8jO zqaqqorNmzczZcoU+vXrV29aqKqqKsDR6/z1119z9913AzB+/HhCQ0N57LHHSEtLo7y8nO3btzt7 mGuMHDmSsLAwXnvtNaxWKydPnmz0gtSGNFdPTZ3j7tiwYQOKonDdddfVeT0pKQmVSsXSpUtbfF76 +Piwd+9eDhw4wLx581pcpo5yXjfHU+d2Wx6jJ8rYkvejrc7T1mrp8bemvtytY1fbmPaqe1faCIDB gwfTvXt35s2bxx133IHBYHBu21Sb0Fz70pHbAEEANwPk6dOn8/HHH/PHP/6xwfUajYZvv/2WmJgY Ro8eTefOnRk8eHC98ZuNKS8v589//jOxsbFER0ezZcsW5zfMMWPGMHnyZKZOncrw4cMxmUw8+uij /OMf/+Dnn3/2aDlc8de//pWQkJB6yyuvvMKECRP4v//7P2677Tauv/76elcFX+jxxx/n6aef5l// +leLjrMtTJ8+HVmWue2229DpdM7XL0adNmNxxFAAACAASURBVGTy5MmsWLGC3377jSFDhhAVFcWf /vQnJk+ezHfffVdvvtP777+f8PBwJkyYwJw5c5xXtPv6+vLdd9+h1WoZPnw4PXv25K9//Wu9m40Y DAaWLVtGSkoKsbGxjBs3jmnTpvHnP//ZpfI2V09NnePuSE5OZsKECfW+uAYGBjJ69GjnT6gtOS8f ffRR3n77bebMmeO82LElOtJ53RRPndtteYyeKGNL3o+2Ok9bq6XH35r6creOXW1j2qvuXWkjwDHM 54477sBkMtW7OK+pNqG59qUjtwGCACDFjntYGXvX46TlWbCUF7D64bhmd7oU2O12goOD+fLLL7np ppvauzhCOwgMDOSLL77g5ptvbu+iXJLEZ0gQBIAXXniBbdu2ibvgCb9rt/wnFZ1vMOVZByk4tLFl Y5BbeivW2nPoXkx5eXmcPXsWwDlnb1txpU7aqx5aq6MeU0vOv0utzj3N3ffwYn6GLhZXz5/L/dy5 mDpqWyM4XPj+1H4u3hfh965FAfKl8oGYOnUq2dnZPP30084J49vKpVInLdFRj6ml5XrzzTcbnO3i cuDue3gxP0MXS0c9ry9n4j3p2IqLi0lJSWHx4sU8++yzHfKW3YLQVlo9i0VHtnnz5vYugtAB1FyQ J7Sc+AwJggCQmJh42XY0CJe3jneDekEQBEEQBEFoRyJAFgRBEARBEIRaRIAsCIIgCIIgCLWIAFkQ BEEQBEEQaql3kV5b3glNEARBEARBEDoeY51n9QLkq6+++qIVRRAEQRAEQRDa3c/76jytFyBXVVVd tLIIgiAIgiAIQkcjxiALgiAIgiAIQi1NBsiHDx/m8OHDF6ssgiAIgiAIgtDumu1Bjo+Px9vb+2KU 5ZKwd+9eDAZDexfDqaOV53Ij6l8QBEEQfn+avNV0WwfHZrONPXuy2LHjJCEhvtx555A2y6u9Je+y MO+LEmYM0fLOXYHtXZwG2Wx2srIKqay0EB8f6XZ6Z84UNrl+794UbrllhNv5NOfXXw9SWFhW57Wg ID+uvrpvm+dd4/nnn2fs2LFcddVVFy3PxhQVlbNvXzolJRX4+BhQFIXy8iqCgnyJj48iPDyovYso CIIgCO2qyQAZwGQyATiHWsTHx7udqdlsY9++M/z2WxbBwX4MGtSd7duPc/ZsGeHhfm6n36jMNRCY CD7R9cqj1zdbFa2W/JuNeUscFz8m/2oCm4137glps/xa6/jxHIYN68vWrSkeSzMhobvzsc0mY7PJ mEwmVCoVkMjq1ZvaNEj+/vudFBdX8MADk+u8/t57yygvNzFu3LA2y7vG8uXLMZvNzJo1C71ez0sv vURSUlKb59uQo0czOXLkNKNGDSEqKhRJkgCQZZmMjLP88MNuYmPDGDo0rl3KJwiCIAgdQYsu0nO3 R7m83MxPP53go492YDLBgw/ewL33XkvPnmEkJkaybdvJVqfdFOlkMqzsj33PS9j3LgAcQfGRI7l8 +OE2vvxyZ5vkC5C8V2beMgv+BolVDwWSGKkheVs58z4622Z5tp6EJIHJVH8mk7y8ElJSMtxKXa2W UKulc8Gxw5Ah/Vi9epNb6dYmWyoo3/0fSjY8xIYv3+L06XweeGAylZXVdZZp00aTmZnH9184ti3f /R+PleFCO3fupKSkhPj4eHr16sU///lP4uLieOONN5Bluc3yvdChQxns35/O9OljiIgIpqKigry8 PM6ePUthYSGRkSHcddeNpKefZe/e4xetXIIgCILQ0bgcILsTHFdUWNiyJZ3Fi/ehUumYN280kyf3 JyDAgCzLlJSYGDasG7t2ZVBVZW1VHg1RZSSjWdsfXclP+E38HO+RL2HO2snuHcf5/PNdZGebuO66 PsiyioyMIo/lWyN5P8xbKePvJbFqrjfX9tCy6tFQEiN1JG8pYd57mR7P0x01gWtFRd0A+fTpPCoq rERFhbudhyRJqNVqwDHEYvfuAwAeC5KzV/0RnXceIVclklGu46qr+pKVlUdRUVmdpbLSzFVX9SOj XEfIVYnovDPIWjbbI2Wo7a677kKtVnPq1Cl0Oh1+fn4MHjyYcePGsX37dvr3788f//hHzp51fGE6 deqUx8sAUFpq4pdfDnD33TciSQoZGWdYseJnkpN/5LPPNrB06WZ27dpHZWUFd945hu3bD1FaamqT sgiCIAhCR9fkuIILh1XUDLdwVW5uBUeO5JGdXU7//pE88EAC/v5653q7XcFqVaiqsuDnZ6Bbt3B2 7crguut6tPQ46lBnJaM+sgB1+BVob1mMyjeCspIK9h0q5bD8Jn28/Ljvvj74+Hhx+HA2AwfGsndv JjExnht7mXxQzbzVCv5esGqWnsTOjuBz3ufF/OXWIBZ8ayV5czHY7bwzL9Zj+bqjoqISi8VOefn5 9zktLYvKShvXXz+AffuOExCgbyIF16hUKux2O2PHXkdZWQXl5SYOHUp1O10As7WQ0CuuBcBirwQg IyOn0e0tdjPGzt4YQ+PI2rPSI2WobcSIEbz66qsMGDAAnU6HJEnYbDZ8fHyIj49nwIABnD59mptv vplOnTqRl5fH+vXrCQsL82g5jh7NYNiwBLRaNTk5uXz44WpGjhxIUpLjxkAZGbksX74Fm83CsGFD GDw47tw+7g+pEgRBEIRLTbMDb2t6jlsSHOfnm0hJOUthYRV9+0Zw88390WrVdbax20GW7WRlFREa 6ofdLjN0aDdWrtzRqgBZspWizXgXzdk1SIG90YxfjOQTSXm5jZ0/niUtrYq+ffsw694YvLw0KIqC 2WynpKSS/v0jWb16D+PGxWMwaFuc94WSD2mYt1aNv5eVVXdqSDzX8Xq6yM4vx8z8cricLx4M46lP rST/WOAYk/yIe18KPKGioorKyioqKhyBZUpKOlYr3HDDIMrKqigqKiY2NrjV6Tt6jx1/VSoVJlMV VVXmOkMu3GVRNCiWagBGXS/z46amg97RIxTH9mYrFpvnpwW/77776NKlC08++SRDhw7FYDA4j9dm s6HVaunduzeDBg3C29ub1NRUJk6cyK+//urRcqSkpDNr1s2YTCZ2705lyJA4rriij3N9TEwYY8cO ZevWvXTuHEp8fCxfffWDCJAFQRCEy5JHZ7E4fbqUtLQCLBY7CQmRJCWF1QuMa8iyHatVISuriK5d g7HbZWJjO2E2y+zfn0X//q7NoiDZStFnvosuJxlipqAasxh0flRU2PhtcwGZmRbi47swe3bnOhfi 2WwydruMzWbHZpMZMCCWLVvSGDfO/YBg3gYDYOGLqYozOAaIDlLzxQNBJL2azcw3zvDFw1146mMr yT/kOoLkP/V2O293lJdXYTJVU1ZmYvfuo0iShqFD48nKymfLlr2MHj3II/lIkoIsy1RWVqNSqVCp VAwcmFhv1ovWzHJhqrIjW8wADE6EwYn2etscOnVfnecpxxx/jSPuISOjhN27j3DbbZ6bbWL8+PFE RkYydepURowYQUiI4wJNjUaDJEmEhISQnZ2NLMv069eP06dP8+CDD/Luu+96rAwWixV/f28KCgpI STnBlCkj620THx/LqlWbKS4uJigoCIvFc8OdBEEQBOFS0myXmclkwmQyuXTTkN27swgI8GHatKH0 69el0eDYbleQZQWbTSEzsxCDQY8sK8iyncGDu/HDD0dcPgB95ruo83/APui/qBIexWT1Zv36Atas KSQsrAt33jmMgQOj6gTHsuwIjvPyyvDy0mG3yyQmRrJ9e7rL+TZlRrwjsHjqe4nS6rrrru3lxTuz QyittDPz3xm8dG80id28SV6fw7wFBz2Sf2tVVFRSWWmmrMxESUk1cXExnD6dy6pVWxg1aiA6nXsz fdhsMmazHZOpynkhYEJCd+cSF9eV7t1jCA8PpkuXUAYOTGzx2OTKShnZWt3kAtC/f6xz6dMnhp49 o+jcuRMRESEMGdKHZcs824ObmJjI/v37ycjIoLi4GG9vb9RqNX5+fqSmplJZWcn27dvx8vIiKSmJ 1NRUXn31VY/lb7FYWbZsI2vW/EpubhFdujT8S4DZbMVut2O1WkWALAiCIFy2PDqLRVCQkbAwX44f zyclJZtTp4qw2ZQ62ygK2O0yVqsjIFarVciyjM2mYLPBgAExnDhRQEFBhUtlsnSegdqWi8o3gqoT v1KSuouzZ6sZOrQrfn5e9bZXFLBaHdONZWYWYTBosdlk/Py88PPz5tdfT7SkShr0zthqZiTYScmF pE9lSqvr1sGMa3x55/7OjiD5n8d5aU5XErv7kLz2DPNe3O92/q1VWVnN1q37iYuLIT4+llOnzrJq 1RYmTRqOXu/e0BNFcfQam81mFEVp8MuTJ2a5qKyyo1iqm1wazleFWn0+32HDEjweJOv1etauXUt2 dja5ubkYjUZUKhU//fQT2dnZ5OTk8OGHH2Kz2Xj44Yf58ssvOXDggEfyvu22EXTv3oX+/Xsya9b4 Rrez2WzY7Xaqqqqw220eyVsQBEEQLjUencUiJsaf3bsziIsLJTGxCwBr1hzgp59SOX48H6vV7rww z26Xyc0tR6tVOXuPZVlGp1PRtWs469cfcqlcslc0Fq/+SBVpGLpfRef4BAKMVeh0arRaNbt2nWLH jnQyMx2zVNjtsrMH+cwZx/jnmvl5Bw7sytataa5WSZPeucnGjH4KKWdlkj4yU1p1QZA83J935kZS arIz88WjvPRgTxJ7+JK85jTz/r7bI2VoTGnaRvJ/fZeiHe9iOnp+jO6Zk8c5dSqHPn0cwfHq1VuY PftGvLx0budptyuYzY4eSY1G45zJ4kLuznJRWSUjW6qbXBrOF2eAvHv3EXbscJx/ng6SAb799lty cnLIysoC4JZbbiE6OhqtVsvp06d5/fXXyczMZM6cOdx9990eyTMqKpRevaKdS1NkWaa6uhpFaXIz QRAEQfjd8ugsFl27BvHbb2fIyiohMjKA2NggYmODyM0tZ8+eU/z44yHCwwPp1i2EyMhA8vNL0Om0 mM027HYFu92O3Q7XX9+bDz5Yz8SJA/D2bn7WBEvMXFSH30IXdiUqL1/iEuHQoWzGjo0nONgHk8nM vn2ZbNmSSliYH2FhAXTpEkB5eRXV1VZk2fHzf3R0J779toSCgnKCg31drcN6fslUM3O5hlW3W8Au kbxTJuk9E6vmeuNvkJzbzbg+COwy815PZebfU/ji2QSeei2F5O8ywGrjnRevbHUZGlJdnM2J5Y8Q 1/MoMb114K+h4iTkrvoS7953MrCPip6Dr2bFis1YLBbmz5+GweD+rBWKomC1WpEkybk0dWGeO7Nc VJtl5zAKV527V8a5MsncdNPVlJaaKCszkZLSNvMBf/XVV4wZM4bQ0FB8fX3x9/enZ8+eHDhwgCVL lrBo0SJ69erFsGHD+MMf/sAHH3zQqnwqj/+P6vS1Lm8/ISKbgOM7IEPDmMBSir7/Fa9u4zH2uKlV +QuCIAjCpcjjs1h06xbE/v1ZREYGOF8LC/Nl/PhEioqq+PXX46xYsROjUY8kSfTrF0NOTilqtQqj UYfdruDvb8Df35ddu04yYkTzF67Jna7FsnMemvIsVL6R9O7tzQ8/pHHddT3x8tLi7a3nmmt6MGBA FLt3n2Lt2n1oNCr8/IwUFJiw22W8vLQoisKwYXEsW7abBx6ofxFTS5SaIekLiVV3qsGmIXlHFUlv l7Dqj/74G84HhzNuCAbZzrxXDjPzb3v54oUBPPXqXpJXpDsu3FtwrVvlqGGtKufwp5O4YWQR+fk6 MrZYCews49dfB2Sg0i0gKHIw61f7UJ31G4//858YjfWHqLSGLDuC5OZ4YpYLRZbrDKNQqqxQaQWb HeRzZbjgJoaO3mPpXP4SxcVVVFVVo1ZLtKV//etfPPvss+Tk5ODn50d0dDS9evVi3rx5bNu2je3b txMSEoKiKDz33HM8//zzLc7j1PoXSbxrOr6R3oCl2e27cf72232A8sxcUr54kXgRIAuCIAiXEY/O YgGQLu/itXXv889TOjQ2FbGGWB4Z9wiJkf3x9tbSr18UarUKi8XOgQMniYzshCRJmExmiopMWK12 jEYtCQkxfPXVDpcCZAB7779gPvAxhmueA9nGgH4Gduw4xfXX9wRAlhXUahXR0cHodDrMZgsWi43A QCPV1VZKS6swmcxERwexcOFvbgXI10bZeWc8zFsJSZ/aWDVLA3YtydsqSHq9gFWPBuNvrBUkjw4D WWbeSweY+eQuvnh5ME/9v10kf5MGFhvvvD6i1WWpsW/ZAq7pkcOeX434Xv0SIWMmYD67m6pj9+OT oAODmvGh+xlQ/SuWHgryiaVU6n3xir0Bla71vekAVuv5mSRqgl+7vf7sEue3cYxXtlrtaDQqZLkF AbIiO2axkBWUIhNYm79TXU0PsiTVzM1tR6NRtyjf1ujfvz8rVzqGuGRlZbFnzx62bt3K5s2bsVqt 9O7dm9TUVCoqKvjoo48YNmwYN93UskC1oETBNzgXTHtbVUbfs3kUlLTdbdgFQRAEoSPy6CwW876e x/077uHImO0MGTuIkqtK+DToUwb+eyCfblmI1apQXFxJbGwIgwfHMHPmdahUjov0NBoV/v4G/PwM 5OebyM8vIT+/3OUDUSJupvrYBpTqYlCsJPbRsXfv+VsjO6Z0kykuriQ83I9u3ULp3j0Uu11GURS8 vLQUFFTwxReb6d8/xuV8GzOjr513bpEprYakD83MHa5nxjAvUrIsJP0rh9LKuoHbjLGdeecvCZRW WJk5/1deemowifFBJH991O2yANiPLUZrs1AWeg8h/ScAoAqMo6rMDpU25EwzJ9aV03mknvD+GsKD 36aT/iWK1tyEOd+9MsiyDUWRUBTFebFeQy6c5UKv12IwGNDrWzDMQ5aRzVXYzxYhmyqbHYOsKGCx OObErqhwTHPnyNcLLy/3h5e4KjIykltvvZUFCxawdu1aVqxYwfz58xk7dizh4eHY7Xbuvvtuli5d 2qJ0C0oUMJ0Gk6Xly/4cyCh2pCEIgiAIl5EWdQ01Ndzi3c3vklySDFfBwj4Lmd15NiW2EkYykn0T 9zFn+X3EhfaFsk507Rpc58I8u91+7kI5Ozt3prNp034iIvx5662ZrhdO548ScQvmtLV49R6Pr85E qH8ZKSnZJCSEY7PJWCw2bDY7Op0ai8XuvDgvP7+CZcu2AzYeeWQU8fERLamWRs3oD8gq5n2jOMYg P2AEm43kn0tIevk0q/4ahb/x/MVqM8ZHOsYkP7sLHx8dN42OJmVP43eBa4lOejNFBQrq6M7O1059 v4C+4TasWXAwpTudI9PAakUfChTKaHwkeoys5uD6x4i83fVxrLXVDK2QJAVJkhodatHYLBeK4tjP 9fxk5OIyFJPZhW1rZlVRzuWLM19Zblm+nubj48OoUaMYNWoUdruds2fPsnz5cn744QemTJnicjqO ANkKtuaHV9RxugTyK8CmiABZEARBuOy4HCA3N9zivV/eg/Hng2OAAE0APw36iZF7RrLvun28uf5N nr7hFYBzwanjwjxZhrS0XL7/fh9VVSbmzr2eYcO6tfhgpD5zKV89Hq9eo7GW5XPlUANrN6fSq5ej p7ikpIqAAKMzMK6oMLN+/QFSUtKZMeNKrrsursV5NmfGQBXIOuZ9ZSXprWJW/TEA7DaSfyoi6YV0 Vj3TDX/v80Hy6TOuTW/XUhWVEOZr4edNr1NRmINUeoT+ob+ARcXOlAR6z/iYqs3XQIVMzm5fVD3/ jDl1E+EhG+kSeYaSYxsJ6HVDi/LcuzeFvXtTGl0/cGCi8/GFs1zU9DLbbHLLAlW7HbmwzKVNJQms VgWLxXIuX3WdfFWqtguQbTYbFRUVVFdXU15ejt1ux2Aw4O/vT0BAQJ1t1Wo1u3bt4uTJkzz00EMt yqeoTIEqK1hcDJDNNjhbfi6olsEuO9IQBEEQhMuIx2axOO1zmr93/TuzO89mX+4+BoQNoMRW4gyS B9oGcurYSQICjMiycm66NYX8/HLWrdtPWlom48YlMm3a0FYfjOQbjT1gIOaMHdgtNgy/fELeqQfJ yxuAr68ek8lCQIARq9XG5s1H+emnA4wdG88990zHaHR/KrPGzBisAdnAvC/MJL2ez6pHg8FqI/mn ApKeTWXVC73w927bcZ7ZPjdQmr+KKf1PgeGfEKzl+BkfTqtvJ27Gk6i9fLGa7NgzFarC5hLUYwL6 HhNI/2Yccb1Ok3nmaIsD5Obugldz57zGZrmQZbnZ8coXUsw2ZBdvcCHLYLXaGshXQa2W6s3h7a70 9HTWrFlDRkaGc65hq9WKXq9HpVJRVVWFLMuo1WquvfZaZs+e7dx34sSJREREcNNNN3HgwAH8/f1d ytMu4xguYW4iQJZlsCuOixnLqh2P7bIzQLY3P4xbEARBEH5XPDeLhQ5K7CWsyFjBPcfuoXhMMfsq 9vHZ2c+Y5TMLTFAul6HRqLBa7VRUWNi48SDbth1hyJAY/vOfO12a0q052sS5FKy6H4tVh/cNL3Fl TB/Wrk1h4sSBqNUSqaln+e673XTu7M0LL0wkONjH7TxdMWOoDmRf5n1WSNK/sln1p85gt5O8IZek pw4xpLNCaGDbBemjH36H7xdF4X1oFTqljKqggURdM4u4YROd25hK7VQV2VB1P9+TnlsRQW/SsLke o7ZYY7NcOAJWBVluQU9uzUV6LrDbG8sXZ8DsKW+88QYbNmzgjjvuYPz48URERGAwGBrdftasWdhs NubMmeN8LTY2Fj8/P86ePetygAw4At9qC2jOXXIgK87gt+7fRl4XBEEQhMuMx2ax8M/3542iN3iD N6Dmf7cKPi37lE/LPgVgNDdhs8ls3XqcDRv2ER7uwzPP3EJMTCd3jqEOdeS1aIc9g7HnzUh6fwZF W9m06UeOH4/khx8OYjJVcNddQ+nVK9xjebpqxjADyIHM+ySXpJccY5Cx2Uj+PpuUIxbHz+Cu/hTe QnpvX8Y8+CLwYqPblJojMNhTOb51JUO6DsVSWY667ACVmTasbdjB3dJZLpqSV6KiymRBr20+sLsw 37boNQaw2+0sXryYdevWERgYSHZ2Njt37iQhIYHg4Pq3fN6zZw/x8fFcf/31ztf+97//8fDDD5OU lERcXAuHAlntoFM7At7GguALeo1FgCwIgiBczpoNe2p6ji8cbnGhGQkz+CztM7wTzwfUOrWOEC/H pLMlG0sYHnETb731PeXl5cyaNYxBg9yfLaIhur4znI+9vLR07dqJRYs2M2nSAK68suVjmz1pxlXe IIcw7/0zJL1wglXPdOP+0QHN73gRVBivQqk4SHjBIta+XoZSdIikPlmkHfcibErLhle0xPlZLuQ6 s1y4MnfyhR5P3sm/ZgwlxLfx2ySPuL4mX/u5C/VqZtdQzuXb8mNoilqt5rbbbmP27Nk8+OCD9OjR A6vVyqlTp8jMzHSORy4sLKS8vJxOnTpx9dVXc+TIEd566y02bdqEVqvlueee46677mp5Abw0UNVI 8NtowCyD7VzQLAiCIAiXGY/NYvGXm/7Ctve2UaopJXxAOP/O/DcHCg/Q3dCdE+tPkJh5PelH1dxw Qxi33jqu0TwCAwMbXVdcXNyS4jpNnz6U6dObHtvcFvk2ZsY1viB3Zt5/M0h65ihzx3dy/N5fs9gc y9adZz2ab3MSbnqQFa+vZUpCOn01n0MElJdLHNdMY1Ska/NRt1RTs1w0NetFUx5P3tXk+oyMEmo6 qGuGUziC5POvdely/nyoNcoBaN358MQTT7B161a+/vpr0tPT8fHxQZYdtz2vub22ojhm0zCZTKjV asLCwkhISOCLL76gX79+Lc6zRnZxKF1UGa4Fxxesyy7VtjpfQRAEQbhUeWwWC3+DPyvnrmTB/xaw /KPlvBv7LtZqK2SpiMq7nruvuJepUwc3ezFccXFxg8Gqp4PU9s53xnB/kCOZ92Y6CxZnOi6iqhli UW0BsxmqXBtL6yk+wREM+MOXfP7eg/TQHKW4Skt1r7sYfu+TbZJfc7NctJXdu4+we/eRJrf56KP/ MWdO/ZtyuHM+XHPNNVxzzTUAlJSUUFZWhtlsdgbJer0eb29vgoKCWnT3wKb0G3ELr7+5GmjZDX8u TEMQBEEQLidS7LiHlbF3PU5angVLeQGrHz4/vrG5YRVtqXaw2tbBcUvy3bt3L1dffTVVVVUXrUxN 6Wjl+b251M4HQRAEQRBa7pb/pKLzDaY86yAFhzY2fye91txu2hNqgpGLGRy7ku/AgQM7VDDU0crz e3OpnQ+CIAiCILivyQC5vYLjGhc7OG7vfIWOSZwPgiAIgnB5cXkWC0EQBEEQBEG4HNQLkPfu3dse 5RAEQRAEQRCEdmKs86xegDxw4MCLVhRBEARBEARBaHc/p9Z56pm5pARBEARBEAThd0IEyIIgCIIg CIJQiwiQBUEQBEEQBKEWESALgiAIgiAIQi0u32paaNjOXbtJSTnU3sUQBEEQBEFwSkxM4IqhQ9q7 GJcsESC7oSY4nvvAH9q7KIIgCIIg/M689/4HrY4x3nv/AwARJLeSCJDdkJJyiD/84X5MlZb2Loog CIIgCL8jpWWlAMiyTFW1rcX7T5g4mZUrvhUBciuJANlNiqKgKEp7F0MQBEEQhN+RmtiitXGGiE3c IwJkNymKgizL7V0MQRAEQRB+R2oHyK2JM0SA7B4RILtJ9CALgiAIguBp5wPk1gW7iui8c4sIkN3U ngGy2WxGo9GgVqvbJf/2drkfvyAIgvD7VRPgtjbOkJvZp6WzcF1us2J4LEBuz2DF3bzd2b+hnz6i o8LqPJckCW9vH/r168eLLy6ge4+erSrnhbp3i+TDjz5l3LjxHkmvLURHhbVZGS+F4xcEQRCE1mjr IRYpKYeY/9jDLqf32uv/6RAB8sWKN12+UUhgYCAffvhho+vDw8NZt26dRwrVWP5r1qxpk7zd2b/m p4/aC8Bzf/8HJ9KzOJGeyYGUo3z8T5hjXAAAIABJREFUySJOnz7NY489VG/71i6O/F3fft26/3Em K8tj+buyfJm8hMGDh7RJ2i09frGIRSxiEYtYLpWlpgfYnTRcIctys4vF0vRsXYGBgQ0ut9xyS51t auK4wMBAVq5c2bKA65y2jjdrdNghFmvWrKF///5ERkYCsHz5chISEtq5VPUpSsPf7FSSCpXK8f3D x8eXK64YxoQJk3jv/f969KK+xvJvyB/uv4f3P/iE8M6dPZZ/c66++lqANruQsSXHLwiCIAiXCkVx swfZxX1cSdtutze7zcsvv8ycOXPqvCZJkvNx7Thu+fLlxMfHu1S+9tJhbzU9c+ZM9u/f73w+YsQI QkJC2rFEDWvsG5tC/ddzcrIJCQ5GURS6xnbhvffe4brhV/Lxxx+gKArHUo8y887bGTK4H0OH9Oep vz5BdXW1c/+fNv7IhFtvIumWcVx15eB6+Te1/61JjmEID/1xLvfee5dL+TVUxq6xXfjqqy+5bXIS PbpH88gj8ygqKmTqlIn06B7F3XdNp6qqqk4a69evdT7+buVy/vb0X+ib0It+iXF8+eXnzm0/+OBd bhh5LQnxPUjsG8fTTz2B3W53+fiPHj3C9DtuIyG+B0OH9Ofll/6B1Wpt914AsYhFLGIRi1haszj+ z9X9X9c1tkujS+3tmhuDXMOVHmRXAmS1Wo1Go6mz1B4GUTuOGzFiBKGhoS5GWu2j1QHyhg0bGDVq FCNGjGiwZ/fo0aNMmjSJXr16ERcXx2OPPYbZbHauDwwMZNmyZcyfP5+oqChiYmJYuHAhADfccAMA 9913H7fffrtz+5qu+ebyfuuttxg6dCgRERFER0czf/78Ot+Qmtu/qeEcF2r8hHY8ttvt5Ofn8cnH H7Jy5XLunDnLuU3yl5+zYMG/mTTxNkwmE3fddQf/n737jm+qXPw4/k3XvVyQvZQWyixaCqJAC8hS mVdkKQqiKDKvqKggCgI/wYUDF142ikpBKQjoVcEFuKgspbRs2QilgEyRkfz+KAknacZJ0t3P+/U6 L8g5z3me5zw5Sb45fZLExyco+ZcNWv7VCiUn/6wpUybLZrMpLS1VAwY8oOEjRmrJ0i/0409r7B2Q zWbzuf/iJZnH89Zb/9XMmXN8lnfXR/u6WTOn68mRozT73fe1dMknur/vPXrsseH66ONP9P33K7Vq 5XdOdcjw/xdenKAqVaK0bPm36t7jTr3y8guOsrVr1dHcxAVK2bRNs2bPUWLih1q3bo3p4+97Xy/V qlVH6zekKilpiZYs/URvvjkpz5/gWFhYWFhYAlnc5Yydv+93m0d2/p51CqUZ2RWQffE0xSLYzOZr /0AFNMVi06ZN6t27txYsWKDWrVtLyjxYu7Nnz6pr167q37+/Fi1apBMnTqhdu3Z6/fXX9dRTTznK jRkzRgMHDtTq1av19ttva/z48XrggQf07bffqkyZMpo1a5b+/e9/+9W2JF177bX69NNPVblyZa1e vVodO3ZUz549lZCQYGr/pKQkxcXFmRoLq839nz6e/b8xevb/xkiSwsLCVKdOjMaNm6C7e93jKD9w 0H/UuEm8JGn5si+Unp6u2HpxWrPmF0lSTExdrVzxnR5+eJgWLJivatHV1LRpc6f27O2vWvmd1/0D LW/so73d/v0H6cYbGzsefHfd3VtN4hMkSSVKlNCJEyfc9lGS7u/bT/0HDJYk3XBDI815b7ZjW4uW rSRJf/31l6pVqy5JOnr0qKxWq8/j/+GHVUpPT9fgIQ8pNDRUVSIj1aVLNy1auEDDhj1h4p4EACD/ cHyLhbLmjO079qp2rapOt13LZOcUi5ycyhhsZvO2fzACCshz585V9erVHZ119c033+jw4cNq2LCh kpOTJUmxsbH65ptvnALy4MGD9cgjmZ+gjI+P17Rp04JuW5JuvfVWSZmfdKxZs6akzKBldv9bbrnF Zz/sPL1Le3rUGPXufa8sFovCw8Od5uHYy5crW9bx/6PHMvu3MOlj6XJZS0iIbrj8AbcD+/erQvkK Wdu63L6v/QMtb+yjXcmSJZ3WlSxZynHbYrE4ppe4tilJ1apFO5U1jsf8+XO1MGmBqkRGqnSp0k77 +jr+9PTDmf0tV95Rpnz5CkpPTzf9LhoAgPzC9Qqyq23b96hO7Wratn2P2+3+XEH2xcwV5CeffFJP Pvmk07odO3aoXLlyXvcLNrN52z8YAQXkvXv3qlKlSh63Z2RkSMo8MHsICgkJUXx8vFM5+4HYt2dH 25L07rvvKjExUVWrVlXp0qX93t8fnk7csLAwRUREOJXLsq9hfZUqUZKkR4c9oejo6lnaKFHiKu3Z e+VBcOzYMac6fO3v2qa/5T31+/IOzvvYPNfhtK/hwb9u3RqNHTNKy5d/p2qX+5OY+IGjvK/jr1A+ cy5TRsYRVayYef+mHz6sihXdhGoAAPK5KwHZc9jdum23x23+zEH2xUxAfvnllzVgwABTbRoFm9m8 7R+MgAJyyZIltWvXLsdteyC2q1atmiRp1KhRqlWrVhDd87/t1atX6/HHH9fatWsdAXz27Nmm9/eX zeb+5LJ5mHrhVOby3B5Jio9PUN2612r06JF6/vmXFRUVpbNnz2rXrt9Vr16cWrZqrcWLF2rNml9U o0ZNPfHEI051+Npfkv71r38pPf2wLl26ZKq8ax89rXOdZmKzOW83ljf+3/7gtVqtOnr5fjhw8KCK l7hKy5d/IUnavXuXLly44PP4mzZrpgoVKmrqlHf01NPP6ODBg1q8eJHuvPMuvuUCAFDgGK8g5+RP TWdXQA5EsJnN1/7BCOhDeu3atdPmzZu1evVqHT16NMs7hpYtW6pevXp69NFHtWvXLtlsNp0+fVob Nmww3Ubx4sXd/nncV9v2wTtw4IAyMjIcH/z7/fffdfHiRZ/7S9KKFSt05MgRU/00O6nebRlDuZCQ EM2cOUeRVSJ1V8+uur7BterQ/mYt/mShbDab2rXroL59+2lA//vVvdtt6tWrj1Mdvva32WwaPGSo Jr70gqZMmWyqvGsf3a27fLAuxy635bPsaxirFi1bq1On2zRwwP3q1vXfOnv2rPr3H6TXJ72i1at/ 8nn8//jHPzV9xrvavCVNTRpfr169eqhz5y4aPGRoQB+MYGFhYWFhycsl6O9B9mMOcm58SM+dYDOb r/2DEdAV5C5duug///mPevTooTJlyuill17SihUrrlQaFqZFixZp3LhxuvXWW3XmzBmVKlVKXbp0 UcOGDU21MXz4cI0ePVoZGRkaMWKE6bbbtm2r7t27684771TZsmX10EMPadiwYZowYYLq1avnc39J 6tatmz788MMsHxB0x2bL+s5uU+p2Sd7flbkrU7pMGT33/MQsZe1lRjz5tEY8+bTHOnzt36/fAPXr N8Cxzld5d310Xed6++fV6z1udy17a9v22pS6XVarVWFhYXr5ldez9GXYY8Md//d1/LVr19H778/z eDwAABQUNlvOX0Hes2eP3/Vmp2Azm6/927RpE3DfLNHtH7G1u3e4tqef1/lTGfrskZjgj7iImDV7 ju7seZdOnjiV110BAACFyJkzp/XDD6vUs+ddOhFAzjh95rR+/GGVHuzX1+32X9asVUpKqun64uJi s+Wnpi9duqTy5ctr7ty56tSpU9D1ZZfb3tqqiKvK69T+TcpI/dbcFWTXr9Q4fvx4jnSuILL/KQMA ACC7XLmCbH4+sdP+Pq46N2ncKFsCrz/S09N16NAhSVLdunVztW1/mQrIBGLPAv3TBwAAgCe5McUi t9155506ePCgRo8erRo1auR1d7wKaA4yruAKMgAAyG42lw/pBbp/frJy5cq87oJpBOQgBfqnDwAA AE8KY0AuSAjIQYiLi9Uni5IUH980r7sCAAAKoQMHDgS0X3Lyz4qLi83m3hQdBOQg2Ce3Jyf/nMc9 AQAAhVGgGSO7vnWiqCIgBykvPgUKAACAnBPQL+kBAAAAhRUBGQAAADAgIAMAAAAGBGQAAADAgIAM AAAAGJj+Fotf1qxVSkpqTvYl3zHzFSlFcVwAAMgJfDUZ8gtTAdkeAgcPGpjT/cl2U6dND7jfU6dN lySPD1b7uCTE82AGACBYq5PXSvL8ugvkFlMBOSUlVQMHDNCZs+dzuj/Z6sTJE5KkS1arzp276Pf+ Xbp215LFizw+UO3huHnz5kH1EwAASM2bN9drk970GpBz4i+3XLmGK9NTLAL9LfC8xO+YAwBQeNjD 8YD+2fsX7Rkzvf/FGEWPXwHZarXmZF+ynTEgB9J3WwE7XgAACrOUlFQ92K+/Tp05k631+vqLMYqe wn0F+XLADbTv1gJ2vAAAFHa+XtNTUjaaquf4sWNq2aq1o07AqFBfQbY6riArsCvIPGAAAMhXvAXk 9PTD6tThVlP1fP7FV05/aQaMgrqCXDWqktNti8Wi4sVLqH79+nr++YmqWat29vQyQEHPQS5gbwgA ACjsbDabbNasr+np6YfVuFEDffPNN5Kk8+czv1ggIiLC6f9ly5ZVw4YNZbPJUQ8BGa5M/1CI9fIV ZOMiSWPHjdeOnfu0Y+de/bZxi2bNmqO9e/dq2GMPZymf24vrHGS/Fx4wAADkK1abTVab1Wk5dPgP NW7UQG+//bbWrFmjm2++WR06dNBvv/2mtLQ0/fbbb+rQoYNuvvlmLVu27HI9V/bnghhcBT0HOTQk VKGhoZKkq666Sk3iE9SlSzdNnfbfPH9HFuwc5LzuPwAAcOb6mp6enq6EJg01ZMgQpaWl6cSJE45t I0eO1D333KO5c+c61m3cuDFLPVwQgyvTV5DdXYWVLr8Dc1l/8I+DKl++vKxWq6ZN+69ubnOTYq+r pbh6MRo16kldvHjRUbZ69DWaOmWyWrZI0KyZ003tE+wV5OrR13hcnPbnHSUAAPmKfYqFzWrT4UOH ldCkoVq3bq3Nmzdr8+bNOnjwoOrXr+8obwzH9evX18GDBzNvWK/UwwUxuPLjCrKHK6q2KwH02LFj +vTTxVq65BMNG/aEbDabateuo7lzP1bFSpW0du0a3X1Xd3Xp0l2NGjV2VDE38QNNnPiaYmLqmt7H XJ+vfEjP2PcdO/epVs2oLOV37NznVI4HDAAA+Yvxym/ThBtUuXJlbdmyJUs5i8Xi9DpusVhUuXJl HTlyJLMe2ZwupAFGQU+xePbZMXr22TGZlYWFqU6dGI0bN0F397pHNptNLVu2liSdO3dO0dHVJUnH jh11qmvQoIfUpEmCox0z+5hhtXn+kN72HXtVu1ZVp9uuZfiTCwAA+UvmZ4SuTKG0WCxuy7m+pruW tc9llvhQPrIK+mvenn56jHr17iOLxaLw8HDHyWcPpfPnJ2rRwo9VpUqkSpUu7bausmXLOt02s4/Z Pnvbd+u23YqpE62t23a73c4DBgCA/MX4LRbbtu9xG5Jdrxwb84Ajp1htfIsFPAr6CnJYWJgiIiKc ytmtW7dW48aO0rLl36latWhJ0rzED7PUZbxtdh9TfTbxIb0tW3d53MYDBgCA/MX1NX3rtt0eryTb 17lOt7hcER/Sg0emA7LVw1VY+4f03Dl6NEOSdPDAARUvXkJfLf9SkrRn9y5duHDB8e0Xxiu8Zvcx I9ifmuYBAwBA/uLuopf9YpcxELvKcpWZOcjwwq9vsXBdMje432az2dSiRSt16nSbBg58QN27/Vtn z57Vg/0H6fXXX9Xq1T9l+SEPs/v4s3jqu6mFKRYAAOQr7n6XwWq1Km3zTr+CrtVq41ur4FFQc5BT Nm2T5PlnnMPCwjTx5Uma6LJ+2LAnHPu51mFmH7P4qWkAAAoXb9MmU9N2mH7tXrHyZ64gw6Og5yDn Z8H+UAhTLAAAyF98vaZvSt1uqp7y5csTkOFR0N9ikZ8FOweZP7kAAJC/5MQFOwIyXBXuK8hevgfZ n/0BAEDei4uL1SeLkhy/l5BdVq1aobi42GytEwVb8L+kl48RkAEAKDyaNG4kKTPQZqe4uFhH3YBk MiDb37HFxzfN6f7kiAMHDgS0X3Lyz17fUcbFxWp18lo1b9480K4BAIDLXpv0ps8ruU0aN8qTMPvL mrVKSUnN9XaRffx5I2QqINsrS07+OfBe5aFA++1rIO3bXpv0ZkD1AwCAK/LrlVx7OB7Qf2BedwVB mDFzuiSZOsdMT7EAAAAoilJSUtX/wQE6ffZsXncFQejarYcWf7Iw+wKy/Z3T4EEF753T1GnTA+73 1Gne32nYxyUhPv+92wUAoKBZnbxWkrkrfLmtIH5ZAZz5c/+ZCsgpKakaOGCAzpw9H3Cn8sKJkyck SZesVp07d9Hv/bt07a4lixd5fKDawzFzkAEACF7z5s312qQ3vQbknJgLbGZqBwG54Mv2gGyvtKCd GHyLBQAAhUdOzQU2Mze1IOYgOMuxgMwPhQAAgLySkpKqB/v116kzZ7K1Xl9/MZYIyIUBV5Av46em AQAoXHy9pqekbDRVz/Fjx9SyVWtHnT7bNVkuJ6SlpiqqapSuuqpknrRfWHAF+TKr4wqyAruCTEAG ACBf8RaQ09MPq1OHW03V8/kXXzn9pTmYdr05fPiwXnphgr7/fpWOHz+m8PBwVb76arVpc4vG/d8E U3V06nirpk2frXbtO/jdvlnVq12T423ktVy7glw1qpLTbYvFouLFS6h+/fp6/vmJqlmrtumO5ISg 5yAXsDcEAAAUdjabTTZr1tf09PTDatyogb755htJ0vnzmV8sEBER4fT/smXLqmHDhpm/EGzN+YA8 9KFBCg0J1cdJn6hKlUidPn1KW7ds0fbt2/yqz6ac/Uv+Bx/OV91rry3cFwdzIiBbPVxBHjtuvO67 7wFJNp09+5c2p6XqiSce1bDHHtaSJZ+b7khOCHYOMlMsAADIX6w2m6w259f09PTDim/cUG+//bbW rFmjkSNHSpImTpyo4sWL68yZM07rMuuxOuoxc0Es0IC8Yf16jX/uBUVHV5cklSlTVglNmymhaTP/ 6svhqa7Nmt90uZnCm338ObYQfyp1XSQpNCRUoaGhCg0N01VXXaUm8Qnq0qWbNm1KcbtPri4uc5AD WQAAQP7h+jp9+HBmOB4yZIjS0tK0ceOVOcgjR47Uzz//7AjHkhzbjXWYuSAWaI6oFxenGdOmaPXP P8lqtbots23bVt3Xp5eaNLpe8Y2v1+hRI3Xu3DmnLGKzyVTZ7du26cEH7lNcbIxiakerdatmOn36 lM9tNatHavmyL2Wz2bRly2b17nWn6sXWUXzj6/XSi8/pwoULjjZqVo/U0qWLNeaZp1W/Xl1dX/9a Jc79wLF9xvSpuvXmlqoXW0cN4urqmdFP6dKlS077T5v6X7Vq2VSzZ83I1Wxoll8B2Wq1Oi3S5Xdg LusP/nFQ5cuXl9Vq1bRp/9XNbW5S7HW1FFcvRqNGPamLFy86ylaPvkZTp0xWyxYJmjVzuql9zC6u V5CNbXpanPZnigUAAPlK5gWwzOXwocNKaNJQrVu31ubNm7V582YdPHhQ9evXd5SfO3eu4//169fX wYMHM29Yr9RjOjjZ/F/eeGOySpUqpXt699RNzZpo3NjR+nX9esf2v86cVd97e6lJfIJWJ6/XsuUr 9Evyak2b8s6Vei7zVfbUyVPqc09PXbJe0pfLvlFq2g7NnDlH/4j4p9dtrm080Pce1apVW+vXb9KC pCVaumSx3n7zdaf+vPTCc6pSJVJfLvtG3bvfqVdfecmxvXbtOpo792OlpGzVzFnva17ih1q/bp3T /omJH2jixNfUrVuPgMY1kMWfy55+BOSs754yN2Suv3Tpko4cOaLZs2do6ZJP1Oee+2Sz2RyDtDFl q2bOmqN5iR9q3bq1TnXMTfxAL018VV27dTe1j7/vFFz7vmPnPrfHuGPnPq4gAwCQjxlfo5sm3KDK lStry5YtTsuRI0dksVic9rNYLDpy5Ii2bNmSWY/8e70P9IplZGSUFiQt0YKkxercuYtWrPhWd9zR RY8//oguXryoVatWKD09XfXqxWnt2jXatm2rYmLqauXKFS5Zxuaz7NdfL1dGRobGjh2vq6++RiEh IapRo6ZCQ0O9bjO28cOP3ys9PV1DhgxVWFiYIiOj1KVrNy1alOTUn/vv76eBA4eocuWrdcONjXTi xAnH9pYtW6tCxYo6d+6cY2rJsWNHnfYfNOghNWmSoFKlSufLK8hBf83bs8+O0bPPjsmsLCxMderE aNy4Cbq71z2OQZLkdpDs7INkb8fMPmZc+RaLrH3fvmOvateq6nTbtQxzkAEAyF+sVsPcYZstSxC2 c31Ndy1rnMuck3OQ7Ro0aKgGDRpq+IinNPfD9zVhwjh1aN9RR48dlSQtTPpYutw/S0iIbrixkXN7 NpvPsocO/SFJioyMzNJXb9uMbaQfSZcklStX3lGufPkKSk9Pd9qvWrVox237uNpvz58/VwuTFqhK ZKRKlyrtqNu4f7myZXP9QmSOBWR3H3R7+ukx6tW7jywWi8LDw50GyWazaf78RC1a+LGqVIlUqdKl 3dZVtmxZp9tm9jHbZ2/7bt22WzF1orV1226325liAQBA/mKfYiFJ27bvcRuSjUHIYrE45QFHTrHa cuVbLFxZLBbd2fNuTZgwTkcyMhQZGSVJenTYE46Lgu6OwyapShXvZStXqixJ2rVrl2rWrOW03ds2 YxsVyleUJGVkHFHFipnfVpZ++LAqVqyQpT9XZhNcGcd169Zo7JhRWr78O1W73MfExA+yfI+06+3c 4E97QX9ILywsTBEREQoPD89Sbu3aNRo3dpRefuV1TXr9bY0bNyFLmUD2Mb2Y+JDelq27suVSPAAA yHmur9Nbt+32+HptD8NurzIb6sjJD+kNGtRPny5drH379urcuXM6fvyYpk/7ryIiItSsWXMlJDRV 3brX6pnRI7VnT+YFu9OnTyslZWOWrOSrbJubb1X58hU0buwo7dy5Q6dOndLatWt08uRJr9uMbTRr 1lwVKlTU1Knv6MKFC9qzZ7cWL16krt16eMxuNsMYHT2aeZX74B8HdfToUc1L/FCStGf3bl28eNH9 /jabxo4dpY8/nm/6diCLPcibYTog27/mzcyH9OzL0aMZmYN04IAyMjIMg7RLFy5ccNRhM9RtZp9g P6RneiEgAwCQr3i72GVnsVjczkE2rrPl0hzkqMiq+uCDOerR/XY1qF9XrVs11y+/JGv2ux8qMjJK ISEhmjnrfVWpEqWed3ZTg/p11b5dG33iMudXNpvPssWLF9d7732o0LAwde3SSc2bNdILzz+rc+f+ 8rrN2MY//vlPzZj5nrZsTlPjRg3U6+4e6ty5i4YMeThLf9xd8GzZsrU6/buzBvS/X127dNLZv86q /4DBmjTpZa1e/ZPH/T+an6iffvrB9O2AQ7JJwf/UtM3zJesWLVqpU6fbNHDgAypTpoz69n1QD/Yf pNdff1V1YuqqWbMr37lnr8PsPmb77LXvvvZnigUAAPmKp99lSNu8Uzab5znJWeqxXqnH1BxkBTYl 4OlRYzzXebm+smXL6oUXX/a4PW3zTsdtX2Vr1Kyl2bM/cLvd2zZjG3XqxOiDDz8y1R9Jateug2P8 w8PD9eqrb2TZ9/HHR7hty851na/bgcixgOx6QqZs2ibJ8884h4WFaeLLkzTRZf2wYU849nOtw8w+ ZvFT0wAAFC7eLnqlpu0w/dq9YuXPThfSgmk3J8Ved2W+cGrajlxvvzDJ3SvI+ZjrHGR/McUCAID8 xddr+qbU7abqKV++fIEIyMbjKWg5LL/JtSvI+Z3rHGS/9y9gxwsAQGGXE0E1PwdkZB+uIF8W9Bzk Ana8AAAUZnFxsfpkUZLj9xKyy6pVKxQXF+u1TEHMQXCWQwG54AVGAjIAAIVHk8aNJGUG2uwUFxfr qBuQTAZk+zu2+PimOd2fHHHgwIGA9ktO/tnrO8q4uFitTl6r5s2bB9o1AABw2WuT3vR5JbdJ40a5 HmZz6so1cpeZvxTYmQrI9hMxOfnnwHuVhwLtt693lPZtr016M6D6AQDAFfn1Sm5OXblG7vLn/DI9 xSIv3rEVBIwLAACFH6/3RYvpX9IDAAAAigICMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMDD9LRZw 74dN+7VuR3pedwMAAABe3Firom6qF2mqLAE5CPZwvGHtmrzuCgAAALxqLEmmQjIBOQj2cLx48si8 7goAAAC8ePHLQ1q3I81UQGYOMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMPA7IH/55ZcqU6aM3njj jZzoDwAAAJCn/A7IiYmJslgsSkxMlM1my4k+ufW///1P+/fvz7X2AAAAUDT5FZCPHj2qL7/8UiNH jtT27du1fv36nOpXFn369NFvv/2Wa+0BAACgaPIrICclJalGjRoaPny4rr76as2bN8+x7dKlSxo9 erTq1Kmja665RjVq1NDHH3/s2F6mTBn973//83p74cKFevzxxxUVFaVq1arp3XfflSTdfPPNkqQH H3xQd911lyQpLS1NnTt3VpUqVRQTE6Nx48bpwoULHusHAAAAzPArICcmJqpPnz4KDQ1V7969tXDh Qv3999+SpJ9++kn//e9/9dlnn+ngwYPauHGj2rRp41dnxowZo6pVq2r16tXq1auXxo8fL0n69ttv JUmzZs3SRx99pLNnz6p79+6KiYnRrl27tGzZMi1YsEAvv/yyo66kpCQ1btzYr/YBAAAA0wF506ZN SktLU8+ePSVJ99xzj/788099+eWXkqRy5cpJkubMmaMtW7aoePHiqlChgl+dGTx4sIYNG6YqVaoo Pj5ef/75p9tyK1as0OHDh/XEE08oIiJC0dHRuuuuu5yuaN9yyy2qWLGiX+0DAAAApgNyYmKiLl68 qJiYGJUpU0Y33HCDJDlC6XXXXad58+bpt99+00033aSmTZsqOTnZr87UrFnzSsdCPHft8OHDkuQU gCtWrOhYDwAAAATKVEA+f/5f0+7bAAAgAElEQVS8Pv74YyUlJen48eOO5c0339TXX3+t9PR0SVKH Dh302Wefadu2bapXr57uv/9+p3rs33oR7LdRVKpUSZJ05MgRx7pDhw451gMAAACBMhWQv/rqK9ls NrVs2dJpfefOnRUSEqKkpCTt2LFDycnJunDhgkqVKqWoqCinsiVKlNCGDRu0ceNGPfTQQ353tHjx 4kpPT5fNZlObNm1UqVIlTZo0SRcuXNCuXbs0f/589erVy1F+xYoVTgEaAAAAMMNUQE5MTFSXLl0U Hh7utL5MmTK69dZbNW/ePJ06dUojRoxQdHS0qlatqlWrVmn27NmOssOGDdPkyZPVv39/jR071u+O Dh8+XKNHj9arr76qYsWKaeHChUpJSVF0dLTat2+vnj17asSIEY7y3bp10y+//OJ3OwAAACjaLNHt H7G1u3e4tqef1/lTGfrskZi87lOB8ebi9dqwdo0WTx6Z110BAACAFy9+eUjnD6Xp0a43ZNl221tb FXFVeZ3av0kZqd8qLDc6VKZMGa/bjx8/nhvdAAAAAHzKlYBMAAYAAEBB4dcPhQAAAACFHQEZAAAA MMiVKRaF1Y21KkpqrBe/PJTXXQEAAIAX5w+lXc5uvhGQg3BTvUhJ0rodaXncEwAAAHhzY62Kjuzm CwE5SDfVizQ92AAAAMj/mIMMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAgelvsfhlzVql pKTmZF8AAACAHBEXF6smjRuZKmsqINvDcUK8uUoBAACA/GR18lpJMhWSTQVkezhu3rx5cD0DAAAA 8kDz5s312qQ3TQVk5iADAAAABgRkAAAAwICADAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAA gAEBGQAAADAgIAMAAAAGBGQAAADAgIAMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZ AAAAMCAgAwAAAAYEZAAAAMCAgAwAAAAYEJABAAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAw ICADAAAABgRkAAAAwICADAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMA AAAGBGQAAADAgIAMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYE ZAAAAMCAgAwAAAAYEJABAAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAwICADAAAABgRkAAAA wICADAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMAAAAGBGQAAADAgIAM AAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYEZAAAAMCAgAwAAAAY EJABAAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAwICADAAAABgRkAAAAwICADAAAABgQkAEA AAADAjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMAAAAGBGQAAADAgIAMAAAAGBCQAQAAAAMC MgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYEZAAAAMCAgAwAAAAYEJABAAAAAwIyAAAA YEBABgAAAAwIyAAAAIABARkAAAAwICADAAAABgRkAAAAwICADAAAABgQkAEAAAADAjIAAABgQEAG AAAADAjIAAAAgAEBGQAAADAgIAMAAAAGBGQAAADAgIAMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAM CMgAAACAAQEZAAAAMCAgAwAAAAYEZAAAAMCAgAwAAAAYEJABAAAAAwIyAAAAYEBABgAAAAwIyAAA AIABARkAAAAwICADAAAABgRkAAAAwICADAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAAgAEB GQAAADAgIAMAAAAGBGQAAADAgIAMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAA MCAgAwAAAAYEZAAAAMCAgAwAAAAYEJABAAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAwICAD AAAABgRkAAAAwICADAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMAAAAG BGQAAADAgIAMAAAAGBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYEZAAA AMCAgAwAAAAYEJABAAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAwICADAAAABgRkAAAAwICA DAAAABgQkAEAAAADAjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMAAAAGBGQAAADAgIAMAAAA GBCQAQAAAAMCMgAAAGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYEZAAAAMCAgAwAAAAYEJAB AAAAAwIyAAAAYEBABgAAAAwIyAAAAIABARkAAAAwICADAAAABgRkAAAAwICADAAAABgQkAEAAAAD AjIAAABgQEAGAAAADAjIAAAAgAEBGQAAADAgIAMAAAAGBGQAAADAgIAMAAAAGBCQAQAAAAMCMgAA AGBAQAYAAAAMCMgAAACAAQEZAAAAMCAgAwAAAAYEZAAAAMDAVECOi4vV6uS1Od0XAAAAIEe8NulN xcXFmiobZqZQk8aNHBUDAAAABU1cXKwj0/piKiBLmSHZbKUAAABAQcUcZAAAAMCAgIxsk5aWprS0 NNaxjnWsYx3r8nQdECwCMrJV48aNWcc61rGOdazL83VAMCzR7R+xtbt3uLann9f5Uxn67JGYvO4T AAAAkGtue2urIq4qr1P7Nykj9VuuIAMAAABGpr/F4ueff9avv/6ak30BAAAAcsT111+vpk2bmipr KiDbw3FCQkJQHQMAAADywurVqyXJVEg2FZDt4fjCxUtKSUkNrneAMr+su6icS0XpWPMKY4xAce6Y x1gFh/ELjv1HPn5Zs9bvcbTv26xZM02aNCn7ArJdSkqqBvQf6FenAHdmzJxeZM6lonSseYUxRqA4 d8xjrILD+AVnxszpkjKzaN++/fzad86c2ZKkVi1bmN7Hr4AsSVarVWf/OufvboDD2b/OSioa51JR Ota8whgjUJw75jFWwWH8gmMfv5SUVA0eNFCnz/wtq9WqS5cuOf3raV18fFMlJ/+cswHZZrPJZrP5 uxvgYD9/isK5VJSONa8wxggU5455jFVwGL/g5MWYEZCR64rSE0VROta8whgjUJw75jFWwWH8gkNA RpFQlJ4oitKx5hXGGIHi3DGPsQoO4xecghGQlTcddfX3338rLCxMoaGhed0V+MnxRKH8cS7lpLw4 1oLy2Ni/f5/+/vtv1axZK6h6itL5hOzFuWMeYxUcxi84ZsasVs0obdu+J9va9PuX9OzvfuxLtaqV 1afPXbp06ZLT+t9++1XVqlbOUj67ljq1q+nrr5bnWP0sObu4O5d6dO+salUre1yWLvkkT/q6c+cO tWrZVLd37qDU1E0aOnSwkpNXB3Ws9uX06dOa9NrLantrK9WqGaUa1auo0Y31dfddPbRly+aA+uv6 2KhWtbKWffmFbDabFi1KUsPrr1P9uBidOXPGaVtOLe7a2Lp1izp37qA//jiY5+dTbowBS/5dcvvx mRNLMOewP/sGO1benovyegzz8lzz9BzVs2e3bLmPC8viTY3qVSRJdWpX8zfWepQtUyy+X7VS7895 V33v72cs6CifU2zyPWjIh1yeKOzmz1/o+P/777+n8ePHaseOvY51lpCQPLm/f92wXk+OHKW6da/V /417RiVLltQNDW8w1xcPxypJZ86c1h09uujUqVMaM/ZZJSQ0U1hYqH7fuVM///yj401nIIyPjQ8/ /Eh1r71WNptNzz/3rAYPfkj39e2n8PBwp205xbWNCxcu6PnnntV//ztd8fFNg287yPMpN8YA+VQe PT6zWzDnsOl9s2GsvD0X5ZexzDFexk+Sxo4dr/vuu995pcXi9nm8SPJy3NWqVna6fW3dGkpN2xF0 k9kSkGNi6urFFyeoabPmql27TmY55UJANvGuAvmP6ztpuxDDlICQ0JAs64z75qau3Xo4/v/enLl+ 9cXTsUrSlCmTtWPHdi1b/p2qV6/hWF8vrr7qxdU33Yandu37Nmt+k2NdRsYRXVMlUhEREVm25RTX NsLCwvTuex9mW7vBnk+5MQbIn/Lq8ZndgjmHze6bHWPl7bkov4xlTvE2flLmc5Tr85Nxv6L+POXp uKMiK7pdH3tdLW1M2RpUm0FPsZCkUaPHqkyZsnps2FD9/fffl7c5l9+yZbN69bpD9WJrq0nj6/Xi i8/pwoULju01qlfR/PmJ6tHjdtWuVU3DHn1Ix44dVc87u6l2rarqe19v/fXXX07tHklP1109u6tO 7Wq6t8/dOno0w6m+aVPfUauWTTV71gzZbDZt27ZV9/a5W40bNVCTxtdr1Kgnde7cuVz/MwGL9z/V +SozffoU3XJzC9WLra36cXU1evRIpyk+/p5LZupbuvQTPfPMU4qrF6MG9esqce4Hps9tT8fxxef/ 0003tVR0dHWv4+Cr/u+++0Zdu3RS584d1KxpI/sDz6n/y5d9oRsaxkqSHn/sYY188gmnbTabTdu3 bVW/B+5Vvdg6qlO7mlq1aqrTp0+ZGiNv+xrbMPM84G2sc+J8MvavRvUqmvvh+x6fV3z1n6XgLTn9 +PT3+cjXOejutc31HPa3PeO+rnVn51j5ei5ybdvMc7O3/ua3xdP4mXn+8nU/ZffrXn5c3Nm3P117 9h7S77sOaMfOfdq2fY82b/k9W64g+x2QJWXpcMmSpfTqa29o8+Y0vT7plSx3+tkzZ3R/396qVau2 1q3fpAVJi7V0ySd6681JTmVnzZqmJ58cpVmz39fSpYv1wP19NOyxJ/TRR4v0/fcrtWrVCqfyb7/9 uu69t68WL/lc27dv1YsvPOe0fW7iB3pp4qvq2q27zp45o/vuvVtN4hO0Onm9li3/Tr8kr9bUKZPz /E4vcouHc8npvLJ53l67dh3NnfuxNqZs1cxZczQv8UOtW7c24HPJTH0vvvCcqlSJ1JfLvlH37nfq lVdeNHdueznWvXv3qGatWl7Hylf9aWmpGjign54YPlJLlnyuH378JbMtOV+psElauy5FkjRp0lt6 8aVXnLadPHlS99zTU5esl/Tlsm+UmrZDM2fOUUTEP3yOka997W2YfR7wNNY5dT4Zx8v+vHL33b31 8YLF2rZti+N5xUz/WQrYksOPT/s5Fchrm7tz0L7d+NpmX2c8h/1tz7iva93ZNVbGtjw9F7m2bea5 2WN/89viZfzsA2Nm7LydA9n5upfvFuW+bJliYbPZFB/fVP36DdCMGVPVqnUbFSv2L8e2H378Xunp 6RoyZKjCwsIUGRmlLl27adGiJA17bLijngH9B6tRo8aO+u+6u7fi4zN/L7tEiRI6eeKEU9uDBj2k jp1ukyTd3qW7Fnw8L8v2Jk0SJEnLl32h9PR01asXp7Vr10jKnBqycuUKPfzIY/4OA4LgeLC7OZcc ZbxM0WnZsrUk6dy5c4qOri5JOnbsqFNZf84lM/Xdf38/9R8wWJJ0w42NNGfObFPntrdjtdkkm9Xz GEjyWX9S0keqFl1NzZrd5FSPa3uenmTt277+erkyMjI0dux4XX31NZKkGjVqOrZ7GyNf+9r/Nfs8 4GmsPQn2fHLdd9Dgh3R7l26SpG7d79DHH833q/8oOHL68Wnn92ubh3PQsd3w2ubuGPxtz+n8d1N3 doyVu7Zcn4tc2zbz3Oypv/mNr+epZ58do2efHeO07pc1v6pMmbJOdXi7n7L7dS8/yYt+Zc/3IF9e N+yx4fr+h1UaMXyYXnjxFUf59PTDkqRy5co79i1fvoLS09Od6ipZsqTL7VKO2xaLJcuH8q6++mrH 7YoVK+rEiROyWq2yWCyZ7ZUt69h+9NhRSdLCpI+ly9stISG64cZG+faEKKzMBBrjFT9X8+fP1cKk BaoSGanSpUrbCwZ8Lpmpr1q1aKf97X3zdW57O9aoqCjHp7s98VX/gf37VaF8BY+PSXe3s/TFZtOh Q39IkiIjI/0ec1/72sumH0n3eix2nsbak2DPJ+OxSNLVla926t+pU6f8eh5DwZHTj087v1/bPJyD dsbXNsPBONb5255xX7d1Z8NYuWvLtS7Xts08N3vqb37j63lq7Njx6nNvX4/7Xb7h9X7K7te9/KTA BmT7oEdEROi1195Q926d9cLzExzlK5TPnESdkXFEFStWkiSlHz6sihWdX9hd30263lk2mzyWP5qR ocqVr3a06bq9SpUoSdKjw55wvFsyHhNyj5lA4+mK37p1azR2zCgtX/6dql2+HxMTP8h6VdR1Xw/n UkD1Gfrv69z2dqxt23XQzBlTtSllo2LrxbkdB1/1lyhxlfbs3eOo+9ixY26P37X/rtsqV8r8FPCu XbuyfC+xrzHytq+xjYCeB2zuzwOnuoM4n9y1afz/HwcPqkqVKn49j6HgyOnHp6MduZx7fry2Gc9B j/XJ8znsb3vu6paCHyu3fXfzXGS/HfBzfT7l63kqy5sWd3XI+/2U3a97+YmxXxt+TcmVNrPlQ3r2 QbfZbKpdO0aPP/Gktm3b4ijfrFlzVahQUVOnvqMLFy5oz57dWrx4kbp26+E2RLieAK4PJtfyJ06c 0Oeff6Y77ujpsb6EhKaqW/daPTN6pPbs2S2r1arTp08rJWVjlmNiydlFbu6frGXcn29Hj2b+JeDg Hwd19OhRzUvM/DaEPbt36+LFi36fS4HUZ3+Y2my+z21vxzpgwGBVr15DDzxwr+bPm6t9+/bq6NGj 2rB+nSZOfF6/JK/2WX+r1m20fdtWrV27RseOHdMTjz/s/vi9jIXNZlObm29V+fIVNG7sKO3cuUOn Tp3S2rVrdPLkSZ9j5G1fYxuBPA8Yxzonzid34/PX2bOy2TK//3rJkkW64867TPefpWAt3s6d7Hh8 up5fjts+Xts8nYPu6nNdF8xrqbfHUbBj5bYtL20H9Nycjxdv42cfDK/7+7if/LnfzYxtflvs4xcX F6vk5J8DWuLiYuWPbArIzuvuu+8BJSQ0dWz7xz//qRkz39OWzWlq3KiBet3dQ507d9GQIQ+7vfM8 39nOt58Z/ZTu6HG77ul9p/79784aPGSox/pCQkI0c9b7qlIlSj3v7KYG9euqfbs2+mRRUp7f8UVx cXfeOC1yX6Zly9bq9O/OGtD/fnXt0kln/zqr/gMGa9Kkl7V69U9+n0uB1Ges0+y57e4Yr7rqKs2f v1B33HmXZs2arvbt2qjFTU00fPgwnTl9RlWrVfNZf7t2HdT3/n7q/2Bfdev2b/Xq1cft8cvLWMhm U/HixfXeex8qNCxMXbt0UvNmjfTC88/q3Lm/fI6Rt32NbQTyPGDqXAnifHI3PsOHD1OD+nX1wP19 1Lv3verXb4Dp+5ql4C05+fh0Pb/ctefutc3TOeiuPtd1gbTnad/sHCt3bXk6Bpst8Ofm/Lx4ew4y 3ieeyni7n/y5382MbX5ccpsluv0jtnb3Dtf29PM6fypDnz0Sk6XQlClTlJCQoPUbNurOnnfrzOkz ud5RFB7nzv2lb7/9ukicS0XpWPNKdo7xddfW1NuTp+qWW9pmU++Qn+XHx2d+PQfz41gVJIxfcOzj J0l9+/bzUdq9OXNma+hDgzVp0iQNGTIky/bb3tqqiKvK69T+TcpI/TabPqQH+MH13W1hVpSONa9k 9xhzXxUd+fXxmd/6I+XfsSooGL/gGMes2D/DdPrM37Jarbp06ZLTv57WnTlz2u82CcjIdUXpiaIo HWteyc4xfvbZ5xUTU4R/zrWIyY+Pz/x6DubHsSpIGL/g5MWYEZCR64rSE0VROta8kp1j3L3HnU51 onDLj4/P/HoO5sexKkgYv+AQkFEkFKUniqJ0rHmFMUagOHfMY6yCw/gFx92Y/bZxgyTpumvrSZK2 79gqSYquVkOSdODgPklSpYpXB9Sm3wH5aEZGQA0BrorSuVSUjjWvMMYIFOeOeYxVcBi/7NWyRXNl ZJxwur137x9Ot7du/T2guv0KyHFxsVq1akVADQFGRelcKkrHmlcYYwSKc8c8xio4jF9w4uJilZKS 6rjdoH5DHTt2ynG7dq0YHTiQ7rhd5Zoobd++O+D2/ArITRo3UpPGjQJuDNmrdOnSed2FoLRre2te dyHXFKVjzSuMMQLFuWMeYxUcxi84xoCc0/yeYgEAAADkpZyeg+z3L+kBAAAAea1li+Z+3fYHV5AB AMgFP/z4k9at22C6/I03NtRNzZvlYI8KBsYtOIV1/PLVHGQAwTl37pzCw8MVGhqa110BkMvWrdug Rx95yHT5N996p0AElZzGuAWH8QsMUyyQpw4dOiSLxeJ2+fLLLyVJ+/fv1x133KEKFSqoWLFiuumm m7R27VpHHXv27FH79u1VrFgxRUVFadasWV7bdNfW5MmTc/Q47YoVK6ZPP/00V9pyZbPZ9M4776h2 7doqVqyYIiMjlZSU5LbsoEGDZLFYcrmH2SM378/c5npsrudxSEiISpUqpZtvvllbtmxxW8a4GB9H 69atU+/evRUZGanQ0FCFh4frmmuuUZs2bbRixYrcPtRCzf7zt96W8+fP53U38x3GLTiFbfx+27hB m1I3Om5v37FVO3/f7rh94OA+/XHoQMD1E5CRp8qVK6cNGzY4LbNnz1bx4sUVGxsrSerZs6c6d+6s Q4cOKSMjQw0bNtQdd9whKTP0devWTQ0bNtSpU6f0zjvvaNCgQfrqq6+8tvvdd99p3759juX+++/P 6UPNcy+//LKee+45zZ07V2fPntU333yjatWqZSmXlJSkefPm5UEPEYg33nhDFy5c0Pnz53Xs2DEt XbpUu3btUt++fbOUcV1uvPFGSdKCBQsUHx+v4sWL6/PPP9epU6d0+PBhffTRR2rZsqXOnDmTV4dX KJkJKpcuXcrrbuY7jFtwCuP4MQcZhVZ4eLiuv/56x22r1apBgwbphRdeUFRUlCRp7dq1+uSTTxQa GqrixYurR48eSkxMlCRt3LhRGzZs0LJlyxQWFqbbb79dt99+u9566y21bdvWY7uVK1dWZGRkzh5c PnLy5EmNHz9eb7/9tpo0aSJJiomJyVJu7969euSRR/TKK69o8ODBud1NBCA0NFRhYZlP5aVLl1ar Vq3Uu3dvvfzyy27LuPrzzz/Vv39/9e3bVzNmzHCs/9e//qUWLVqoRYsWOXsARZDVas2WMkUN4xac wjZ+OT0H2a8ryL+sWatZs+eYXn5Zs9Z3pYDBjBkzdPHiRT300JX5Uh07dlSHDh20fv16paen66mn ntKLL74oSdq3L/NrXMqWLesoX69ePSUnJ3ttZ9WqVdq0aVOePBkcOnRILVu2VEREhNq2basjR444 tr366quKiYlRiRIlVKpUKQ0ePNjRx0uXLunxxx9XpUqVVLx4cZUrV04ffvihY9/U1FS1bdtWlSpV UuXKlTVo0CCdO3dOUuYV87Nnz6pDhw4e+3Xx4kXdc889Gj16tOPqfWFgsVg0c+ZMNWvWTOHh4brn nnuUkZGhFi1aKCwsTO3bt9dff/3lKO/tPpCk33//Xbfffruuu+461ahRQ6GhoerTp49ju7f7wd6f efPmaciQISpZsqRKly6tadOmZesx79+/X5UqVTJV9osvvtDJkyf18MMPZ2sf4FlhvJKXGxi34DB+ /vErIKekpOrxxx4xveTmFzqj4Dty5IiefvppvfXWW04fYps5c6b27NmjG2+8UTVr1tTtt9+ugQMH SrryYykHDlyZZ2SfiuFJx44d9dFHH6l169aqWbOmli9fnkNH5N748eM1dOhQrV27VqmpqRoxYoRj W2xsrL777judPn1a//vf/zRt2jT99NNPkjJD/euvv64VK1bozJkz2r17t9q1aydJOnPmjNq2batW rVrp0KFD2rx5s1auXKmXXnpJkrRjxw5J0vLly3XttdeqZMmSatOmjXbv3u1o+7nnnlPJkiX1n//8 J5dGIvdMmjRJEydO1Oeff67ExER17NhR48eP1w8//KDly5dr2bJljrLe7oMLFy6oQ4cOqlmzplJT U/X777+rc+fOjn193Q92I0aMUHR0tFJTU9W3b189/fTTQR+j1WrV4cOH9cYbb2ju3Lmm78ft2zPn 7NWtWzfoPsAcgkpgGLfgMH7+CWgOcmGb6I384cknn1SrVq3UvLnznKGHH35YLVq00GeffaZatWpp zJgxjj8fN27cWJUrV9bzzz+vs2fPauXKlVqwYIH++c9/emzn888/1zfffKM//vhDt912m7p06aL9 +/fn6LEZPfXUU+rZs6fq16+vPn36aOnSpY5tHTt21DXXXKNz586pTp06kuQI++XLl5eUeZU9NTVV JUqUUMWKFSVJy5Yt0x9//KFGjRrpxx9/VGpqqurXr+/4oKP98bh9+3alpKTo4MGDslqtGjBggCTp +++/1/Tp0zV79uwC++E8b0aMGKEWLVro1lszf8Vq4MCBatOmjRISElSyZEn9+eefjrLe7oMffvhB 27dv19ChQ92Ok6/7we7RRx/VyJEjFRUVpebNm+v48eMBH9vDDz8si8Wi0NBQRUVF6f3339fkyZOd Qre9jHEZPny4pMx5/JIK5f2eXxFUAsO4BYfx809Ac5DN/FmaQYY/Vq9erffee0/r1693Wr9x40Z9 9NFH2rdvnyIjI9WhQweNHz9eI0eOVNu2bdWwYUMtWbJEw4YNU0xMjG655Rb16dNHK1eu9NlmeHi4 JkyYoMmTJ+urr77SAw88kFOH56Rq1aqO/19zzTU6fvy4bDabLBaLpk2bpnfffVfR0dFO00YkKS4u TkuXLtVrr72mt956S4OW9DAAACAASURBVDExMZo+fbqaN2/umKbx7rvvOoJOSEiI481GuXLlJEmj Ro1SWFiYSpQooX79+mnQoEGSpGnTpumPP/5Q5cqVndq0WCxasGCB40ORBVWZMmUkXQmB9tvGdXbe 7gP7Gyn7mxVXvu4Hu9q1azv+HxIS3GelJ02apCFDhshisSgiIsJt0H377bc1dOhQt/tHR0dLkn77 7TfH/HRJ6t69u5YuXapLly5pypQpzEnPRoVtLmhuYdyCU1jGb8OvKbnSDgEZ+cLTTz+t1q1bq2HD hk7r7XOM7VMpQkNDNXLkSI0fP147d+5Uw4YN1aRJE8efwCWpbdu26tixo6l27VdWIyIisuMw/Jae nq7IyEhZLBb98MMPGjx4sLZt2+YIUFOmTHEq37lzZ3Xu3FlHjx7Vww8/rJ49e+rAgQOqXr26JGnC hAmOq55GCQkJkjI/kFW8eHFJcnzoUcqcxjJ16lRH+Z9++knt27fXqVOnvF6NL2x83Qf2Nxr79u1T qVKldOHCBe3cuVMNGjSQJJ/3Q04IDw8P6j7q0KGD/vGPf2jixIlKSkpyBOxFixZJ4spyTuA1NDCM W3AKw/jFxcUqOfnngPf1BwEZeW7r1q1asWKF2+8vbtKkiUqUKKFRo0bppZdeUkhIiCZOnKhSpUqp VatWkqT169erbt26CgsL09SpU/Xrr7/qgw8+cNQxePBgNWrUSP3795ckpaSkKDY2VqdPn9aIESNU rlw5r4HadX9ft836888/9dFHH+nBBx+UdOXq4759+1S6dGktXLhQUub84YsXL+r333/XkSNH1KRJ E5UuXdrpSvTNN9+sBg0aaMCAAZo9e7Zq1Kih06dPa+vWrWrUqJHi4uJ0yy236PHHH9fMmTNls9k0 e/Zs3XXXXZKUJWD961//kiSVKFHCr2Mq6HzdBy1atFDJkiX1/PPPa8KECRozZoz27dvn+CYWX/dD MOxTIQJx6dIlXbx4Mcv6kJAQVapUSa+99pqGDh2qHj16aOTIkYqLi1NISIgOHz4cTJfhgZn7ktfQ rBi34BSG8asbU0ft2t6qP//8U6VLl/b737///tt0Wzk2B7kgXKZH/vD1119LktuvZatQoYK++uor /frrr6pQoYIqVqyoH3/8Ud9++60qVKggSZo+fboqVaqk0qVL69NPP9XKlSudpgpMmzbN0YaUOce0 ePHiio6O1vHjx7Vy5cosf0o3ct3f121f+vfvr8aNG6tFixbq1auXnnnmGUlSp06ddPfdd6tjx466 /vrrdebMGY0cOVKjRo3Sd999p5MnT2ro0KEqU6aMSpUqpW+//Vbz58+XJIWFhWn58uWqXr264uPj VaxYMdWpU0dz5syRlHkVcP78+bJarbrmmmtUo0YN1a5dW6+++qrpfhcFvu6Dq666Sh988IG++uor 1a1bV1FRUWrZsqXjDYav+yEYp0+flnTlKrY/hg0bpvDw8CzL+PHjJUkPPfSQvv76a128eFGdO3dW iRIlVKJECTVv3lzt2rVT/fr1g+4/Mu3du1enTp3yufAa6oxxC05hGb+qVasGHI79PTZLdPtHbO3u Ha7t6ed1/lSGPnsk63ejTpkyRQkJCVq/YaMef+wRxxO1N+fOndP7HyTqwX59fZZFYOzTDuDdjBkz 9Ouvv+qdd97J666gkLBarbp48aIiIiJ0ww03qGvXrho7dmy2tzNnzhzHBwlnzZqlF154Qbt27TL9 FW7IX3748SetW7fBdPkbb2zIT/6KcQtWYRq/vXv3BhWS//77b8fnNlzd9tZWRVxVXqf2b1JG6rdM sUDh98knn2T5mi0gEGlpaTp8+LAaN24si8WiqVOnauPGjdlyhdidzz77TP/5z390/vx5x4c0CccF 103Nm+Xb4JGfMW7BKUzjl5tXkAnIKPQ+/fRTp+9VBgJ18uRJDR8+XNu3b5fNZtN1112nxYsXKy4u LkfaW7BgQY7UCwAFUbBXkP1BQEahRzhGdklISNC6devyuhsAUCTl6yvIe/bs8XcXAAAAICh//vmn flmz1u9fao6Li1WTxo1UrFgx0/v4FZDj4mK1cNESv8oDAAAAwbKH4759+/m135w5syVJrVq2ML2P XwG5SeNGatI4uO/yBAAAAPyVkpKqwYMG6vSZvx0/jW3819O6+PimSk7+2a+AHNxvnAIAAACFTEAf 0gMAAP4pTN9Hm5sYt+AwfoEhIAO56Ny5cwoPD+ebNYAiaN26DXr0kYdMl3/zrXcIKmLcgsX4BYYp FshzNptN77zzjmrXrq1ixYopMjJSSUlJbssOGjRIFovFad2xY8c0a9Ys3XfffapWrZrP9vbs2aP2 7durWLFiioqK0qxZs7LlOMwoVqyYPv3001xrzyjYcS4oLBaLJk+enNfdyBGux2axWJyWkJD/b+/O 46oq8weOf25sGsjiBikorpCo6SiuAWEiUEmpM1po0qtUyD2UmbGymSibbPy5hb9CTTMz06wmTVO0 xBRHGrefiKIoKIuAoiIXCAHh94eve4b1LtzLIn7fr9d5Keec+5zn+T7Pufd7zz3LI9jZ2TFq1CiS kpJqXafydPz4caWsEydOEBwcjLOzM2ZmZlhYWNCpUyd8fX2JjY1t7Ka2aJrzIrVNJSUlTV3NZkfi ZpyWHr+ePVxMWp4kyKLJffTRR7z//vts2bKFoqIifv7551oT3R07drB169Ya8xMSEoiLi8PKyoq0 tDSt26qoqGDcuHEMHDgQtVrNmjVrCA0NZf/+/SZrT3NlbJxF87Ry5UpKS0spKSnh1q1b7Ny5k9TU VEJCQmqsU30aNGgQcP+BJEOHDsXa2po9e/agVqvJyclh27ZteHt7U1hY2FTNa5H0SVTkWQI1SdyM 05Lj171bZwB699J9kExfkiCLJpWfn09kZCRLlixhyJAhqFQq3Nzc8PT0rLJeWloac+fO5Z///GeN Mnx8fNiwYQP+/v46t3fmzBlOnTrFggULMDc3JygoiKCgIFavXm2yNjVHpoizaJ7MzMwwNzfHwsIC e3t7fHx8CA4O5uTJkzXWqT6pVCry8vKYNm0aISEhrFu3jv79+/Poo4/Stm1bvLy8ePfdd3n22Web sIUtjz6JiqEPNXgYSNyM01Lj17WLU5W/H3fvbpJyJUEWTergwYMUFRUREBBQ5zplZWVMnjyZt956 Cw8P4+6tnZ6eDkDbtm2VeX379iU+Pt6ocg2RnZ2Nt7c3lpaW+Pn5cePGDWXZsmXLcHNzw8bGBjs7 O8LCwpQ3rHv37hEeHo6joyPW1ta0a9eOL7/8UnltYmIifn5+ODo64uTkRGhoKMXFxUDjx7k5UalU rF+/nhEjRmBhYcHkyZPJzc3Fy8sLc3Nz/P39+f3335X1tfUBQEpKCkFBQfTp04fu3btjZmbGlClT lOXa+kFTn61bt/L6669ja2uLvb090dHRJm1zRkYGjo6Oeq37008/kZ+fz5w5c0xaB1G3lnwkryFJ 3IzTEuPn4tyx1vkefXoaXbYkyKJJXbp0CYCYmBgef/xxbG1t8fX15cqVK8o677//Pra2tsycOdPo 7WmexZ6ZmanMy87OJjc31+iy9RUZGcns2bM5fvw4iYmJREREKMs8PDw4ePAgBQUF7N69m+joaI4e PQrAr7/+yooVK4iNjaWwsJArV64wZswYAAoLC/Hz88PHx4fs7GzOnz/PoUOH+PDDD4HGj3Nzs3z5 cpYuXcqePXv46quvCAwMJDIykiNHjhATE8O+ffuUdbX1QWlpKQEBAfTo0YPExERSUlIYO3as8lpd /aARERGBq6sriYmJhISEsGjRIqPbWF5eTk5ODitXrmTLli1692NycjIA7u7uRtdB6KclJiqNQeJm nJYYv/SM61xNyyYlNZNLl9O5mHyV80kpJJ67ZHTZBiXI9vb2VaYDBw7g4OBQZd53332Hg4MDbdq0 UeZt3ryZDh066LVc12TK8q2trVm8eDGPPfYYBQUFNZZ//PHHeHp6olartdbJwcGBAwcOKP/fvHmz suzDDz+kZ8+e2Nvbc+rUKRwcHLh586ay/JVXXmH27Nl6tb361BJoLghITk4mISGBa9euUV5ezvTp 0wE4fPgwa9euZcOGDSa5aMzT0xMnJyeWLFlCUVERhw4d4ptvvqFVq1ZGl62vv/71r0ycOJH+/fsz ZcoUdu7cqSwLDAykU6dOFBcX07t3bwAleW/fvj0A69atIzExERsbGzp2vP/ted++fWRlZTF48GDi 4uJITEykf//+7N27F2j8ODc3EREReHl5MXr0aABmzJiBr68vw4YNw9bWlry8PGVdbX1w5MgRkpOT mT17dq1x0tUPGvPmzeMvf/kLLi4ujBw5ktu3b9e7bXPmzEGlUmFmZoaLiwtffPEFUVFRVZJuzTqV p4ULFwL3z8sHWmS/N1ctMVFpDBI340j8DGPyI8iPPfYYQJUjcrm5ucp8Xcsbs3wLCwvee+89iouL a1yk9Y9//INvv/2WuLg4XFwMuzKy8vpOTk7cuXMHuP+zJ/w30RHQrl07AN58803Mzc2xsbHh1Vdf 5fDhwwBER0eTlZWFk5MTKpUKL6/7T8FRqVR13oFBGysrK3744QcSEhJwc3Nj48aNTJkyhZ49jf85 Rl9dunRR/t+pUydu376tJCnR0dEMGzaMV155hb///e9VXtevXz927tzJyZMneeKJJ+jbty9xcXEA ymkaGzduJCoqiqioKB555BFGjhwJNH6cmxsHBwfgv0mg5u/K8zS09YGufVhXP2j06tVL+f8jjxj3 Nrx8+XJ+//13iouLuXv3LidPniQsLKxKuz7++GMqKiqqTMuWLQPA1dUVgP/7v/+rUu748eOV85Q/ /fRTo+ooqmqp54I2NImbcSR+hjH5fZCHDBmCmZkZv/32m/LT48mTJxkxYoReyxu7fM2RNUtLS2Xe l19+ybJlyzh79qxyhK6+0tPTlTsFaJKU9PR07OzsKC0t5fLlyzzxxBNGbeNBNmzYMADy8vKwtrYG 7l9QpPn/+vXrq3w4Hz16FH9/f9Rqdb2P+g4ZMkT5yRzAz8+PwMDA+jbBKNevX8fZ2RmVSsWRI0cI Cwvj4sWLSgL1ySefVFl/7NixjB07lps3bzJnzhwmTpxIZmYm3bp1A+C9995TjnpW1hRxfhDp6gNd +7CufmgIFhYWRvVRQEAAVlZWLF26lB07diiJ9XfffQfIkeWGoE8SIkfyapK4GUfiZxiTH0Fu164d U6dO5cMPP6SgoEA5x2/u3Ll6LW+M8hMSEigvLyc/P5+IiAjatWunJEi5ubnMmjWL4OBg7t27R0ZG BhkZGRQUFCivDwsLY/369XXWsaioCICkpCQ2b97MtGnTAPDy8sLW1pYlS5Zw6dIlpk6dSnp6+kP9 AdSvXz+efvppwsPDUavV5Ofns2HDBiZNmgRAq1atsLGxUaZHH30UABsbG8zN9ft+V72/Tp48SVFR ESUlJaxevZrTp0/zxhtv6P16XX/rKy8vj23btvHaa68B/z36mJ6ezo0bN5SE9dKlS5SVlXHx4kXi 4uIoLS3F3t6+ypHoUaNG8cQTTzB9+nQuX75MRUUFarVauc9tY8S5JdDVB7r2YV39YAzNrwz1ce/e PcrKympM5eXlODo68j//8z989913TJgwgfj4eIqKiiguLubq1atG11vUVP1ofm2TJCo1SdyM01Li d+p0AsnJF7l8+RJXrqSSlnaVzMwMsrKukZOTTW7uDW7dusmdO3mo1fkUFhboLrQW9UqQd+3ahY2N jXLltuZqb41Vq1bRtWtXHnvsMV588UXWrVtX5QiuruW6GFt+YGAg1tbWuLq6cvv2bQ4dOqTc1eDS pUvk5+cTFRWFi4uLMn3++efK66Ojozlw4ECd9Zs8eTKtW7dm9OjRzJo1S7kIq02bNmzevJn9+/fj 7u6Oi4sL3t7eD9URuupUKhVff/015eXldOrUie7du9OrVy/l51996BqP1ftr7dq1ODo6Ym9vz65d uzh06BBOTk41yq3r9br+1mXatGl4enri5eXFSy+9xNtvvw3AM888w4svvkhgYCADBgygsLCQv/zl L7z55pscPHiQ/Px8Zs+ejYODA3Z2dvzyyy98/fXXAJibmxMTE0O3bt0YOnQorVu3pnfv3mzatAkw TZwfBrr6QNc+rKsfjKH5kq45im2I+fPnY2FhUWOKjIwEYNasWRw4cICysjLGjh2rfFEaOXIkY8aM oX///kbXX9yXlpaGWq3WOclP3VVJ3IzTUuLXr58H8fH/rtfUr59hd2dSufrPrRjz8kKSr5dQos7l x7luNVb65JNPGDZsGL6+viZqYt1sbGzqXDZp0qRGfeqZPu7du4e5uTn/+te/eP7551GpVHz//fe8 8MILdb6mvLycsrIyLC0t+cMf/sALL7zAO++804i1frisW7eO06dPs2bNmqauimghGmsf3rRpk3Ih 4WeffcYHH3xAamqq3rdwE83LkbijnDhxSu/1Bw0aKI/8ReJmrJYUv5j9B0hISKzXa/v188DH24vl y5fz+uuv11j+3OoLWLZpjzrjLLmJv5j+HGRjVT6VobnLzs4mKysLQK/7xp47d46cnBw8PT2VC1/O nDljkqNLom7ff/99jdtsCVEfjb0P//jjj8ycOZOSkhLlIk1Jjh9cT44c0WwTj+ZM4maclhS/hIRE QkJerddrN23agI+3l97rN7sE+UHyzDPPkJGRwXvvvafcBWHdunUMGDCg1vXz8/NZuHAhycnJVFRU 0KdPH/71r3/Rr1+/xqz2Q2fXrl2YmZk1dTVEC9DY+/A333zTIOUKIcSDqnUrcwoK7yq3pav8b13z 6nMesiTIRqj8KFcNzQV5tRk2bBgnTpxoyCqJWkhyLExF9mEhhHg4yJP0hBBCCCGEqEQSZCGEEEII ISqRUyyEEEIIIcQDx8W57oe5nUm4YFTZcgRZCCGEEEI8cNIzrtc6P/HcJaPLliPIQgghRCNoSfej bUwSN+O09PhdTcuma5f/PuzrfFKKSR54IgmyEI2ouLgYCwsLubOGEA+hEydOMW/uLL3XX7V6zQOV qDQUiZtxHob4paRm0r1bZy4mXzXZ47LrdYrFrVu3+Oyzz5g6dSpdu3atsVytVhMcHIyNjQ0uLi5s 3rzZoOW6GFu+SqWqMUVFRSnLfXx8sLOz49FHH2XQoEEcOXJEa31UKhU7duwwqA3iv65evYq/vz+t W7fGxcWlxtMSTT2eDO1fU2rdujW7du1qtO1VVlFRwZo1a+jVqxetW7fG2dm5znEbGhqKSqVq5Bqa RvX9uSWp3rbq72OPPPIIdnZ2jBo1iqSkpFrXqTwdP35cKevEiRMEBwfj7OyMmZkZFhYWdOrUCV9f X2JjYxu7qS2a5t6s2qaSkpKmrmazI3EzTkuP36XL6SYtr14JckJCAnFxcVhZWZGWllZj+axZs0hN TeXatWt88cUXvPrqqxw9elTv5bqYovyDBw+Snp6uTK+88oqybMGCBeTk5HD79m369u3Lyy+/rLU+ +/fvx8tL/6eziP+qqKhg3LhxDBw4ELVazZo1awgNDWX//v3KOqYeT4b2b0vx0Ucf8f7777NlyxaK ior4+eefa/2Cu2PHDrZu3doENRT1sXLlSkpLSykpKeHWrVvs3LmT1NRUQkJCaqxTfRo0aBBw/4Ek Q4cOxdramj179qBWq8nJyWHbtm14e3tTWFjYVM1rkfRJVEx1FKwlkbgZR+JnmHolyD4+PmzYsAF/ f/8ay27cuMGWLVtYtGgRtra2+Pr6Mnr0aFavXq3Xcl1MVb6TkxPOzs7KZGNjoywLCgqiVatWWFlZ ERgYSHZ2ttY6jR49Wh7/Wk9nzpzh1KlTLFiwAHNzc4KCgggKCtK7P+szngzt35YgPz+fyMhIlixZ wpAhQ1CpVLi5ueHp6VllvbS0NObOncs///nPJqqpMJSZmRnm5uZYWFhgb2+Pj48PwcHBVR5kpFmn +qRSqcjLy2PatGmEhISwbt06+vfvz6OPPkrbtm3x8vLi3Xff5dlnn23CFrY8+iQqpjiHsqWRuBlH 4mcYk9/FIj4+nvLy8iofvJ6ensoRPV3LG6v8X3/9lbNnz2odDEVFRXz++eeEhoZqrVPlUyxUKhWf fvop3t7eWFpa4ufnx40bN5R1U1JSCAoKok+fPnTv3h0zMzOmTJmiV9tbovT0+z+JtG3bVpnXt29f 4uPjgYYdT/r2r6llZ2fXOT6WLVuGm5sbNjY22NnZERYWpozRe/fuER4ejqOjI9bW1rRr144vv/xS eW1iYiJ+fn44Ojri5OREaGgoxcXFwP1fTIqKiggICKizXmVlZUyePJm33noLDw+PBmp941OpVKxf v54RI0ZgYWHB5MmTyc3NxcvLC3Nzc/z9/fn999+V9bX1Aejeh7X1g6Y+W7du5fXXX8fW1hZ7e3ui o6NN2uaMjAy9v7T/9NNP5OfnM2fOHJPWQdRNjuTVj8TNOBI/w5g8Qc7KygKgQ4cOyrwOHTpw7do1 vZY3RvmBgYFs27aNp556ih49ehATE1NlG+fPn8fb25vOnTvTq1cvli9frlfdNCIjI5kxYwZxcXGc PXuWiIgIAEpLSwkICKBHjx4kJiaSkpLC2LFjDSq7pbG3twcgMzNTmZednU1ubi7QMOPJ2P41VmRk JLNnz+b48eMkJiYq4wPAw8ODgwcPUlBQwO7du4mOjlaS/V9//ZUVK1YQGxtLYWEhV65cYcyYMQAU Fhbi5+eHj48P2dnZnD9/nkOHDvHhhx8CcOnS/VvexMTE8PjjjytH269cuaJs+/3338fW1paZM2c2 UiQaz/Lly1m6dCl79uzhq6++IjAwkMjISI4cOUJMTAz79u1T1tXWB7r2YV39oBEREYGrqyuJiYmE hISwaNEio9tYXl5OTk4OK1euZMuWLXr3Y3JyMgDu7u5G10HoRxKV+pG4GaclxK9fPw8+jV5LcvJF Ll++xJUrqaSlXSUzM4OsrGvk5GSTm3uDW7ducudOHmp1PoWFBcTH/5t+/Qw78GPyu1hors6vfoGP 5m9dyxuj/D179gD3P+zCw8N5/vnnSU5OxtnZGYBu3bqxdu1akpKS+Nvf/oa/vz+7d+/G0tJSrzou WrRIOaIUEhLC+vXrAThy5AjJycnMnj37gb0AytQ8PT1xcnJiyZIlrFixgv/85z988803tGrVCmiY 8WRs/xrrr3/9KxMnTgRgypQpyviA+1/e4P7dLnr37g2gfFlo3749AOvWreO1116jT58+tGnTBoB9 +/aRlZXF4MGDiYuLA6B///7s3buXv//978qFF8nJySQkJFBcXMyzzz7L9OnT2b9/P4cPH2bt2rWc OnWqRY7NiIgIvLy8qKioAGDGjBn4+voCYGtrS15enrKutj7QtQ/r6geNefPmKV+MRo4cqfcpZrWZ M2eOcvTXwsKCvn37EhUVVeWXkcrraCxYsIBly5YpMWmJ/d5c6fMzdnNPVJqCxM04LSF+QzwHAxAf /2+DXtevn4fyWn2pXP3nVox5eSHJ10soUefy41y3Giv9+9//5vTp04SHhxtUuBBCCCGEEM3B8uXL GTBgAMOHD6+x7LnVF7Bs0x51xllyE3/R7wiypqDG/ilaCCGEEEIIU6grOa6N3qdYDB8+XO9ChRBC CCGEeFCZ/CI9IYQQQgghHmSSIAshhBBCCFGJJMhCCCGEEEJUIgmyEEIIIYQQlUiCLIQQQgghRCWS IAshhBBCCFGJJMhCCCGEEEJUUud9kJOSkkhJSWnMugghhBBCVNG9e3fc3d0ByU1M6WGPa+X216bO BDklJYVnnnmmQSolhBBCCKGPPXv2KImM5Cam87DHtXL7ayOnWAghhBBCCFGJJMhCCCGEEEJUIgmy EEIIIYQQlTz0CXJaWhrJyclNXY0Gd+3aNc6dO0dFRUVTV8Ugd+/e5d69ew26jYSEBPLz8xt0Gw2l oePTGPFvTh629gohqnqQPw+ayr59+zh+/HhTV8Pk9EqQCwsL+cc//sHw4cNxdHSkffv2uLm5ERQU xPnz5xu6jibh4ODA7t27q8xLSkri6aef5tq1a01Uq8aRnp6Or68vSUlJqFQqZf727dvp2bMn3bp1 o6ioqNYYNTUnJyf27t3boNvw9vbm8OHDDbqNhtLQ8WmM+NdHQ43V5tpeIYRupshVHuTPg9TUVGbO nMnAgQNp3769Scp0cHBg3bp1dS7/6quvWLx4Mc7OzibZnjFu377N5s2bCQsLo1+/fkaXV+ddLDQK CgoICAggPz+fDz74gCeffBJzc3OSk5M5fPjwA3O05fvvv8fDw0P5u6SkhLfffpvPP/+ckSNHNnp9 du/ezRNPPNHgg+revXu89dZbrFixosYVqosXL2bevHnMmDEDCwuLGjESormovr/IWBVCVNZSchVj xMTE8Ntvv2FhYdEo7b19+zYHDx5k9+7ddOjQocG3p8u5c+eIj4/HysqKjIwMo8vTmSCvXLmSixcv cvToUXr27KnMHzhwIAMHDjS6Ao3lqaeeqvK3paUlO3bsaJrKAFOmTOHLL79s8ATZzMyML774otZl 169fx8XFBSsrK6BmjIRoLqrvLzJWhRCVtZRcxRihoaGEhoby9ttvN8qpo7qOLje2kSNHMnLkSH74 4Yc68x5D6DzFYufOnTz11FNVBlxtzp07x9ixY+ncuTNubm787W9/o7S0VFnu4ODAqlWrGDBgAJ98 8kmd85KSkhg3bhy9e/fGzc2NN954g7t37yrlXLhwgYkTJ+Ls7EzHjh0ZOHAgBQUFOpdV/klWn7p+ ++23hIeH4+LiQteuXdm4caPJ2j5q1CgAXnvtNSZNmqRXGVeuXOGll15i6NChDBgwgHbt2jFjxgyt 8f3444/x9PSkc+fOdOnShfDwcMrLy4H7N8gGCAsLY86cOTVipC2W2sqtTnMEu3fv3nTq1Inu3buz fft2vWMH9xP5BZgeiwAACa9JREFUZ555ho4dOzJu3Dhyc3O1tlvXGNLGkLZptv/FF18wZswYOnTo wPTp07l58yaBgYG0b9+eCRMmUFxcrHf5tbVHW18AFBcX1zlWDW3P/v37efrpp3nqqadqPUKrLba6 +lpXXepqZ237i2asBgcHExoaWqWO4eHhLFiwQK9t6mqvofETQjQNU+UqlVU/lau2vw15/9eVW+jz +dDcToOsXCdd7dP12dzc2q8zQb5y5Qpubm5a1ykqKmL8+PG4ubmRmprKvn37+Oabb/joo4+qrLdx 40aioqKUD7nq84qKinjhhRcYOXIkFy5cID4+nri4OFasWAFAfn4+QUFBlJeXc+zYMbKysti+fTtW VlZal9WnrosXL6ZLly4cO3aMl156icjISJO1/ZdffgHgs88+Y9u2bTrLKC0t5Y9//CPdunXj2LFj nD59moCAgBp1qR7fxx9/nF27dpGZmcn27dvZuHEjv/32G4DyxJzo6Gg+/vjjKuXoiqW2cqs7evQo //u//8uPP/7ItWvXOHPmDL6+vgbFbunSpUyfPp2DBw9y/vx53nnnnTrbrWsM6WJI2zTWrFnDu+++ y/bt29mxYwd/+tOfePPNN9m7dy+//PILP//8s0HlV26PPuNa21g1pD1nz54lODiYxYsXExsbS2Ji YpXlumKrra911UVbO6vvL5W9+OKL7Nq1S/nCUFRUxI4dOwgJCdG5TV3tNTR+QoimY8pcxRCGvP+D ce/XO3bswNPTs951bQx1tU+fz+bm1n6dCXJFRYXOOx/ExsaSk5PDggULsLS0xNXVlUmTJrF169Yq 682fP58nn3yStm3b1jrv559/Jicnh4EDBxIfH09SUhIeHh7KAPvpp5+4fv06S5cuxdnZGTMzM3r1 6oWFhYXWZfWpa1hYGPPnz6dz584MHTqUvLw8k7dd3zKOHTvG5cuXmT59epWL7Kqrvo3Ro0fj5OTE 3bt36dGjBwA3b96s8/UaumJpSLnt2rUDYNOmTSQlJWFtba2cq6Rv7N544w3GjRuHh4cHkyZN4qef fqqz3brGkC71idncuXMZPny48rN/SEgIXl5eDB48mDZt2nDnzh2Dyq/cHn3Gtbaxakh7tmzZQrdu 3eo8fUFXbLX1ta666Lv/Vufv74+lpSU//PADcP/c5B49etC/f3+d29TVXkPjJ4RoOqbMVQxhyPs/ GPd+/fTTT9OxY8d617Ux1NU+fT6bm1v7dZ6D3LVr11qPrFSWk5MDUKXiHTt2VOZr1HYSd+V5mp/O t2zZoiSCjzzyCEOHDgUgKytLqVN12pbVp66aztHUwdjytJ3ArqsMzV02NAlIXapvY+PGjXz11Vd0 6dIFe3t7ra+tTFcsDSm3T58+bN26laioKKKjo+nZsyerVq1i6NCheseu8nnaTk5O5OXlUVFRoYwR Q8aQLvWJmWY9zfYqv676Fxp9yq/cHn3Gtbaxakh70tLScHR0rHO5rthq62tdddF3/63OysqK8ePH s3XrViZPnsymTZuYOnWqXu3X1V5drxdCNB+mzFUMYcj7P5ju/bq5qqt9+nw2N7f260yQx44dy6pV qzh9+jQDBgyodR3Nh8yNGzdwcnICIDs7W+eHT3WaD8c333yz1vOIOnXqBNw/PaB37956L2uIupqy PF1laI4IZ2ZmYmtrS2lpKampqfTt27fOMo8dO0Z4eDjHjx9XBuyGDRv0qo+2WNan3ICAAAICArh1 6xZ//vOfeeWVVzh//ny9Ynfjxg06depU55F0XWNIG2Ni1lDl6zuuTbE9W1tbUlNTlb8rn+sN+sW2 rr7WVRdj2hkcHIyfnx8xMTGcPXuWCRMm6NV+Xe1t6PEghDCdhspVNEelTXFXBG1a+vuNrs+P5th+ nadYzJ8/n549ezJ+/Hg2btzI1atXyc3N5T//+Q/vvPMOcXFx+Pr64ujoyPLly5Xk7euvv+all14y qDLe3t707duXefPmkZqaSkVFBQUFBZw6dQqAwMBAOnbsyBtvvEFycjJqtZpjx46Rn5+vdVllpqqr seVZW1tz/fp1KioqdJYxfPhw2rRpw7Jly0hJSSEsLIzMzEytp1toPuwzMzPJzc1VTpRPSUmhrKxM a920xdLQci9dukR8fDylpaXY2dnh4uJS79jduXOH77//npdffrnOuusaQ9oYEzN91Kd8fce1KbY3 ZswYJZm9efMm06dPr7JcV2y19bWuuuhqZ+X9pbpBgwbRo0cPQkNDGTduHLa2tnptU1d79YlfeHi4 Sa6WFkIYpyFyFRsbG06dOsWZM2eYNWtWg9Zfn/eb2NhYbty40aD1qM29e/coKyurMhl6sbKuz4/m 2H6dCbKdnR379+9n6tSpREVFMWjQINzd3Zk+fToFBQX06NGD1q1b8+2335KQkICrqyv+/v5MnDiR iIgIgypjbm7Od999R9euXRk9ejSPPfYYgwYNUs4PatOmDTt37sTCwgIvLy969erFokWLKC4u1rqs MlPV1djyFi5cyFtvvcWyZct0lmFjY0N0dDSxsbEMGTIEZ2dnRowYQatWreos38/Pj/Hjx/OnP/0J Ly8vCgsLmT9/Pu+9957Om6Bri6Wh5arVaiIiInB1daVLly78+uuvyrdCfWM3d+5cRo0aRWBgIBMm TGDhwoV11l3XGNLGmJjpoz7l6zuuTbG9559/npkzZzJhwgR8fHx47bXXqizXFVttfa2rLrraWXl/ qU6lUvHiiy+Sl5enXJynzzZ1tVef+G3cuJFDhw7p7AshRMNqiFxl/vz5REVFMW3atBoXh5uaPu83 48aN03qR8AcffICDgwNr1qwB7t/1obbrngy1aNEiOnToUGU6ePCgQWXo+vwwRfv37t1L586dlTsb ae6GUV8qV/+5FWNeXkjy9RJK1Ln8OPf+VaB79uyp8WAJ0bTKy8spKyvD0tISHx8fnn32Wf785z83 dbWEEEKIBlM5H5HcxHQe9rhWb/Nzqy9g2aY96oyz5Cb+ot+jpkXTunDhAocPH+b333+nrKyM6Oho EhMTee6555q6akIIIYQQLY7Oi/RE01Or1SxevJjLly9TUVGBu7s7W7ZsoU+fPk1dNSGEEEKIFkcS 5AfA4MGDiY2NbepqCCGEEEI8FOpMkLt3786ePXsasy5CCCGEEFV07969yv8lNzGNhz2uldtfmzoT ZHd3d9zd3U1eISGEEEKI+pDcpGFIXGuqkiBbtmnPc6svNFVdhBBCCCGEaHSWbdpX+bvGEeTqKwgh hBBCCPEwURJkdcbZpqyHEEIIIYQQzYIKwNV/bs3ntwohhBBCCPGQ6W97W/X/kEBtnBwRUxAAAAAA SUVORK5CYII= 14257 2006-01-15 02:58:17 +0000 2006-02-01 03:38:06 +0000 Patch which fixes the problem kmail-cb.diff text/plain 7797 mcguire SW5kZXg6IGttYWlsL2ttYXRtbGlzdHZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGttYWlsL2ttYXRt bGlzdHZpZXcuY3BwCShyZXZpc2lvbiA0OTc5OTApCisrKyBrbWFpbC9rbWF0bWxpc3R2aWV3LmNw cAkod29ya2luZyBjb3B5KQpAQCAtMSwxMzMgKzEsMTUgQEAKIC8vIC0qLSBtb2RlOiBDKys7IGMt ZmlsZS1zdHlsZTogImdudSIgLSotCi0vLyBrbWNvbXBvc2V3aW4uY3BwCisvLyBrbWF0bWxpc3R2 aWV3LmNwcAogLy8gQXV0aG9yOiBNYXJrdXMgV3VlYmJlbiA8bWFya3VzLnd1ZWJiZW5Aa2RlLm9y Zz4KIC8vIFRoaXMgY29kZSBpcyBwdWJsaXNoZWQgdW5kZXIgdGhlIEdQTC4KIAogI2luY2x1ZGUg PGNvbmZpZy5oPgogCiAjaW5jbHVkZSAia21hdG1saXN0dmlldy5oIgotCi0jaW5jbHVkZSAia21t YWlud2luLmgiCi0jaW5jbHVkZSAia21yZWFkZXJtYWlud2luLmgiCi0jaW5jbHVkZSAibWVzc2Fn ZXNlbmRlci5oIgotI2luY2x1ZGUgImttbXNncGFydGRsZy5oIgotI2luY2x1ZGUgPGtwZ3BibG9j ay5oPgotI2luY2x1ZGUgPGthZGRyYm9vay5oPgotI2luY2x1ZGUgImttYWRkcmJvb2suaCIKLSNp bmNsdWRlICJrbW1zZ2RpY3QuaCIKLSNpbmNsdWRlICJrbWZvbGRlcmltYXAuaCIKLSNpbmNsdWRl ICJrbWZvbGRlcm1nci5oIgotI2luY2x1ZGUgImttZm9sZGVyY29tYm9ib3guaCIKLSNpbmNsdWRl ICJrbXRyYW5zcG9ydC5oIgotI2luY2x1ZGUgImttY29tbWFuZHMuaCIKLSNpbmNsdWRlICJrY3Vy c29yc2F2ZXIuaCIKLSNpbmNsdWRlICJwYXJ0Tm9kZS5oIgotI2luY2x1ZGUgImF0dGFjaG1lbnRs aXN0dmlldy5oIgotI2luY2x1ZGUgInRyYW5zcG9ydG1hbmFnZXIuaCIKLXVzaW5nIEtNYWlsOjpB dHRhY2htZW50TGlzdFZpZXc7Ci0jaW5jbHVkZSAiZGljdGlvbmFyeWNvbWJvYm94LmgiCi11c2lu ZyBLTWFpbDo6RGljdGlvbmFyeUNvbWJvQm94OwotI2luY2x1ZGUgImFkZHJlc3Nlc2RpYWxvZy5o IgotdXNpbmcgS1BJTTo6QWRkcmVzc2VzRGlhbG9nOwotI2luY2x1ZGUgImFkZHJlc3NlZWVtYWls c2VsZWN0aW9uLmgiCi11c2luZyBLUElNOjpBZGRyZXNzZWVFbWFpbFNlbGVjdGlvbjsKLXVzaW5n IEtQSU06OkFkZHJlc3NlZVNlbGVjdG9yRGlhbG9nOwotI2luY2x1ZGUgPG1haWxsaXN0ZHJhZy5o PgotdXNpbmcgS1BJTTo6TWFpbExpc3REcmFnOwotI2luY2x1ZGUgInJlY2VudGFkZHJlc3Nlcy5o IgotdXNpbmcgS1JlY2VudEFkZHJlc3M6OlJlY2VudEFkZHJlc3NlczsKLSNpbmNsdWRlICJrbGVv X3V0aWwuaCIKLSNpbmNsdWRlICJzdGxfdXRpbC5oIgotI2luY2x1ZGUgInJlY2lwaWVudHNlZGl0 b3IuaCIKLQotI2luY2x1ZGUgImF0dGFjaG1lbnRjb2xsZWN0b3IuaCIKLSNpbmNsdWRlICJvYmpl Y3R0cmVlcGFyc2VyLmgiCi0KLSNpbmNsdWRlICJrbWZvbGRlcm1haWxkaXIuaCIKLQotI2luY2x1 ZGUgPGxpYmtwaW1pZGVudGl0aWVzL2lkZW50aXR5bWFuYWdlci5oPgotI2luY2x1ZGUgPGxpYmtw aW1pZGVudGl0aWVzL2lkZW50aXR5Y29tYm8uaD4KLSNpbmNsdWRlIDxsaWJrcGltaWRlbnRpdGll cy9pZGVudGl0eS5oPgotI2luY2x1ZGUgPGxpYmtkZXBpbS9rZmlsZWlvLmg+Ci0jaW5jbHVkZSA8 bGliZW1haWxmdW5jdGlvbnMvZW1haWwuaD4KLSNpbmNsdWRlIDxrbGVvL2NyeXB0b2JhY2tlbmRm YWN0b3J5Lmg+Ci0jaW5jbHVkZSA8a2xlby9leHBvcnRqb2IuaD4KLSNpbmNsdWRlIDx1aS9wcm9n cmVzc2RpYWxvZy5oPgotI2luY2x1ZGUgPHVpL2tleXNlbGVjdGlvbmRpYWxvZy5oPgotCi0jaW5j bHVkZSA8Z3BnbWVwcC9jb250ZXh0Lmg+Ci0jaW5jbHVkZSA8Z3BnbWVwcC9rZXkuaD4KLQotI2lu Y2x1ZGUgPGthYmMvdmNhcmRjb252ZXJ0ZXIuaD4KLSNpbmNsdWRlIDxsaWJrZGVwaW0va3ZjYXJk ZHJhZy5oPgotI2luY2x1ZGUgPGtpby9uZXRhY2Nlc3MuaD4KLQotCi0jaW5jbHVkZSAia2xpc3Ri b3hkaWFsb2cuaCIKLQotI2luY2x1ZGUgIm1lc3NhZ2Vjb21wb3Nlci5oIgotCi0jaW5jbHVkZSA8 a2NoYXJzZXRzLmg+Ci0jaW5jbHVkZSA8a2NvbXBsZXRpb25ib3guaD4KLSNpbmNsdWRlIDxrY3Vy c29yLmg+Ci0jaW5jbHVkZSA8a2NvbWJvYm94Lmg+Ci0jaW5jbHVkZSA8a3N0ZGFjY2VsLmg+Ci0j aW5jbHVkZSA8a3BvcHVwbWVudS5oPgotI2luY2x1ZGUgPGtlZGl0dG9vbGJhci5oPgotI2luY2x1 ZGUgPGtrZXlkaWFsb2cuaD4KLSNpbmNsdWRlIDxrZGVidWcuaD4KLSNpbmNsdWRlIDxrZmlsZWRp YWxvZy5oPgotI2luY2x1ZGUgPGt3aW4uaD4KLSNpbmNsdWRlIDxraW5wdXRkaWFsb2cuaD4KLSNp bmNsdWRlIDxrbWVzc2FnZWJveC5oPgotI2luY2x1ZGUgPGt1cmxkcmFnLmg+Ci0jaW5jbHVkZSA8 a2lvL3NjaGVkdWxlci5oPgotI2luY2x1ZGUgPGt0ZW1wZmlsZS5oPgotI2luY2x1ZGUgPGtsb2Nh bGUuaD4KLSNpbmNsdWRlIDxrYXBwbGljYXRpb24uaD4KLSNpbmNsdWRlIDxrc3RhdHVzYmFyLmg+ Ci0jaW5jbHVkZSA8a2FjdGlvbi5oPgotI2luY2x1ZGUgPGtzdGRhY3Rpb24uaD4KLSNpbmNsdWRl IDxrZGlyd2F0Y2guaD4KLSNpbmNsdWRlIDxrc3RkZ3VpaXRlbS5oPgotI2luY2x1ZGUgPGtpY29u bG9hZGVyLmg+Ci0jaW5jbHVkZSA8a3B1c2hidXR0b24uaD4KLSNpbmNsdWRlIDxrdXNlcnByb2Zp bGUuaD4KLSNpbmNsdWRlIDxrcnVuLmg+Ci0jaW5jbHVkZSA8a3RlbXBkaXIuaD4KLS8vI2luY2x1 ZGUgPGtlZGl0bGlzdGJveC5oPgotI2luY2x1ZGUgImdsb2JhbHNldHRpbmdzLmgiCi0jaW5jbHVk ZSAicmVwbHlwaHJhc2VzLmgiCi0KLSNpbmNsdWRlIDxrc3BlbGwuaD4KLSNpbmNsdWRlIDxrc3Bl bGxkbGcuaD4KLSNpbmNsdWRlIDxzcGVsbGluZ2ZpbHRlci5oPgotI2luY2x1ZGUgPGtzeW50YXho aWdobGlnaHRlci5oPgotI2luY2x1ZGUgPGtjb2xvcmRpYWxvZy5oPgotI2luY2x1ZGUgPGt6aXAu aD4KLSNpbmNsdWRlIDxrc2F2ZWZpbGUuaD4KLQotI2luY2x1ZGUgPHF0YWJkaWFsb2cuaD4KLSNp bmNsdWRlIDxxcmVnZXhwLmg+Ci0jaW5jbHVkZSA8cWJ1ZmZlci5oPgotI2luY2x1ZGUgPHF0b29s dGlwLmg+Ci0jaW5jbHVkZSA8cXRleHRjb2RlYy5oPgorI2luY2x1ZGUgPHFjaGVja2JveC5oPgog I2luY2x1ZGUgPHFoZWFkZXIuaD4KLSNpbmNsdWRlIDxxd2hhdHN0aGlzLmg+Ci0jaW5jbHVkZSA8 cWZvbnRkYXRhYmFzZS5oPgogCi0jaW5jbHVkZSA8bWltZWxpYi9taW1lcHAuaD4KIAotI2luY2x1 ZGUgPGFsZ29yaXRobT4KLQotI2luY2x1ZGUgPHN5cy9zdGF0Lmg+Ci0jaW5jbHVkZSA8c3lzL3R5 cGVzLmg+Ci0jaW5jbHVkZSA8c3RkbGliLmg+Ci0jaW5jbHVkZSA8dW5pc3RkLmg+Ci0jaW5jbHVk ZSA8ZXJybm8uaD4KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPGFzc2VydC5oPgotCiBL TUF0bUxpc3RWaWV3SXRlbTo6S01BdG1MaXN0Vmlld0l0ZW0oUUxpc3RWaWV3ICpwYXJlbnQpCiAg IDogUU9iamVjdCgpLAogICAgIFFMaXN0Vmlld0l0ZW0oIHBhcmVudCApLApAQCAtMTQwLDggKzIy LDExIEBACiAgIG1DQkNvbXByZXNzID0gbmV3IFFDaGVja0JveCggbUxpc3R2aWV3LT52aWV3cG9y dCgpICk7CiAgIGNvbm5lY3QoIG1DQkNvbXByZXNzLCBTSUdOQUwoIGNsaWNrZWQoKSApLCB0aGlz LCBTTE9UKCBzbG90Q29tcHJlc3MoKSApICk7CiAKKyAgLy9IaWRlIHRoZSBjaGVja2JveGVzLCB0 aGUgcG9zaXRpb24gaXMgbm90IHlldCBjb3JyZWN0IGFuZCB3aWxsIGJlIHNldCBpbiBwYWludENl bGwoKSwKKyAgLy93aGVyZSB0aGV5IHdpbGwgYWxzbyBiZSBzaG93biBhZ2Fpbi4KICAgbUNCRW5j cnlwdC0+aGlkZSgpOwogICBtQ0JTaWduLT5oaWRlKCk7CisgIG1DQkNvbXByZXNzLT5oaWRlKCk7 CiB9CiAKIEtNQXRtTGlzdFZpZXdJdGVtOjp+S01BdG1MaXN0Vmlld0l0ZW0oKQpAQCAtMTYwLDM3 ICs0NSwyOCBAQAogICAvLyB0aGlzIGlzIGFsc28gY2FsbGVkIGZvciB0aGUgZW5jcnlwdC9zaWdu IGNvbHVtbnMgdG8gYXNzdXJlIHRoYXQgdGhlCiAgIC8vIGJhY2tncm91bmQgaXMgY2xlYXJlZAog ICBRTGlzdFZpZXdJdGVtOjpwYWludENlbGwoIHAsIGNnLCBjb2x1bW4sIHdpZHRoLCBhbGlnbiAp OwotICBpZiAoIDQgPT0gY29sdW1uICkgewotICAgIFFSZWN0IHIgPSBtTGlzdHZpZXctPml0ZW1S ZWN0KCB0aGlzICk7Ci0gICAgaWYgKCAhci5zaXplKCkuaXNWYWxpZCgpICkgewotICAgICAgICBt TGlzdHZpZXctPmVuc3VyZUl0ZW1WaXNpYmxlKCB0aGlzICk7Ci0gICAgICAgIG1MaXN0dmlldy0+ cmVwYWludENvbnRlbnRzKCBGQUxTRSApOwotICAgICAgICByID0gbUxpc3R2aWV3LT5pdGVtUmVj dCggdGhpcyApOwotICAgIH0KLSAgICBpbnQgY29sV2lkdGggPSBtTGlzdHZpZXctPmhlYWRlcigp LT5zZWN0aW9uU2l6ZSggY29sdW1uICk7Ci0gICAgci5zZXRYKCBtTGlzdHZpZXctPmhlYWRlcigp LT5zZWN0aW9uUG9zKCBjb2x1bW4gKQotICAgICAgICAgICAgLSBtTGlzdHZpZXctPmhlYWRlcigp LT5vZmZzZXQoKQotICAgICAgICAgICAgKyBjb2xXaWR0aCAvIDIKLSAgICAgICAgICAgIC0gci5o ZWlnaHQoKSAvIDIKLSAgICAgICAgICAgIC0gMSApOwotICAgIHIuc2V0WSggci55KCkgKyAxICk7 Ci0gICAgci5zZXRXaWR0aCggIHIuaGVpZ2h0KCkgLSAyICk7Ci0gICAgci5zZXRIZWlnaHQoIHIu aGVpZ2h0KCkgLSAyICk7Ci0gICAgciA9IFFSZWN0KCBtTGlzdHZpZXctPnZpZXdwb3J0VG9Db250 ZW50cyggci50b3BMZWZ0KCkgKSwgci5zaXplKCkgKTsKIAotICAgIG1DQkNvbXByZXNzLT5yZXNp emUoIHIuc2l6ZSgpICk7Ci0gICAgbUxpc3R2aWV3LT5tb3ZlQ2hpbGQoIG1DQkNvbXByZXNzLCBy LngoKSwgci55KCkgKTsKKyAgLy9JZiBhIGNvbHVtbiBjb250YWluaW5nIGEgY2hlY2tib3ggc2hv dWxkIGJlIHJlcGFpbnRlZCwgcmVzaXplICYgbW92ZQorICAvL3RoYXQgY2hlY2tib3ggY29ycmVj dGx5IGFuZCBhcHBseSB0aGUgY29ycmVjdCBiYWNrZ3JvdW5kIGNvbG9yLiBBbHNvCisgIC8vaGlk ZS91bmhpZGUgdGhlIHNpZ24vZW5jcnlwdCBjaGVja2JveGVzLgorICBpZiAoIGNvbHVtbiA+PSA0 ICYmIGNvbHVtbiA8PSA2KSB7CiAKLSAgICBRQ29sb3IgYmc7Ci0gICAgaWYgKGlzU2VsZWN0ZWQo KSkKLSAgICAgIGJnID0gY2cuaGlnaGxpZ2h0KCk7Ci0gICAgZWxzZQotICAgICAgYmcgPSBjZy5i YXNlKCk7CisgICAgLy9HZXQgdGhlIGNoZWNrYm94IGZvciB0aGlzIGNvbHVtbiBhbmQgc2VlIHdo ZXRoZXIgaXQgc2hvdWxkIGJlIHNob3duCisgICAgUUNoZWNrQm94KiBjYjsKKyAgICBib29sIHNo b3dDQjsKKyAgICBzd2l0Y2ggKGNvbHVtbikgeworICAgICAgY2FzZSA0OiBjYiA9IG1DQkNvbXBy ZXNzOworICAgICAgc2hvd0NCID0gdHJ1ZTsKKyAgICAgIGJyZWFrOworICAgICAgY2FzZSA1OiBj YiA9IG1DQkVuY3J5cHQ7CisgICAgICBzaG93Q0IgPSBtQ0JFbmNyeXB0RW5hYmxlZDsKKyAgICAg IGJyZWFrOworICAgICAgY2FzZSA2OiBjYiA9IG1DQlNpZ247CisgICAgICBzaG93Q0IgPSBtQ0JT aWduRW5hYmxlZDsKKyAgICAgIGJyZWFrOworICAgIH0KIAotICAgIG1DQkNvbXByZXNzLT5zZXRQ YWxldHRlQmFja2dyb3VuZENvbG9yKGJnKTsKLSAgICBtQ0JDb21wcmVzcy0+c2hvdygpOwotICB9 Ci0gIGlmKCA1ID09IGNvbHVtbiB8fCA2ID09IGNvbHVtbiApIHsKKyAgICAvL0NhbGN1bGF0ZSB0 aGUgcmVjdGFuZ2xlIHdoZXJlIHRoZSBjaGVja2JveCB3aWxsIGJlIGRyYXduCiAgICAgUVJlY3Qg ciA9IG1MaXN0dmlldy0+aXRlbVJlY3QoIHRoaXMgKTsKICAgICBpZiAoICFyLnNpemUoKS5pc1Zh bGlkKCkgKSB7CiAgICAgICAgIG1MaXN0dmlldy0+ZW5zdXJlSXRlbVZpc2libGUoIHRoaXMgKTsK QEAgLTE5OSw2ICs3NSw3IEBACiAgICAgfQogICAgIGludCBjb2xXaWR0aCA9IG1MaXN0dmlldy0+ aGVhZGVyKCktPnNlY3Rpb25TaXplKCBjb2x1bW4gKTsKICAgICByLnNldFgoIG1MaXN0dmlldy0+ aGVhZGVyKCktPnNlY3Rpb25Qb3MoIGNvbHVtbiApCisgICAgICAgICAgICAtIG1MaXN0dmlldy0+ aGVhZGVyKCktPm9mZnNldCgpCiAgICAgICAgICAgICArIGNvbFdpZHRoIC8gMgogICAgICAgICAg ICAgLSByLmhlaWdodCgpIC8gMgogICAgICAgICAgICAgLSAxICk7CkBAIC0yMDcsNyArODQsNyBA QAogICAgIHIuc2V0SGVpZ2h0KCByLmhlaWdodCgpIC0gMiApOwogICAgIHIgPSBRUmVjdCggbUxp c3R2aWV3LT52aWV3cG9ydFRvQ29udGVudHMoIHIudG9wTGVmdCgpICksIHIuc2l6ZSgpICk7CiAK LSAgICBRQ2hlY2tCb3gqIGNiID0gKDUgPT0gY29sdW1uKSA/IG1DQkVuY3J5cHQgOiBtQ0JTaWdu OworICAgIC8vTW92ZSBhbmQgcmVzaXplIHRoZSBjaGVja2JveAogICAgIGNiLT5yZXNpemUoIHIu c2l6ZSgpICk7CiAgICAgbUxpc3R2aWV3LT5tb3ZlQ2hpbGQoIGNiLCByLngoKSwgci55KCkgKTsK IApAQCAtMjE3LDIzICs5NCwzNiBAQAogICAgIGVsc2UKICAgICAgIGJnID0gY2cuYmFzZSgpOwog Ci0gICAgYm9vbCBlbmFibGVkID0gKDUgPT0gY29sdW1uKSA/IG1DQkVuY3J5cHRFbmFibGVkIDog bUNCU2lnbkVuYWJsZWQ7CiAgICAgY2ItPnNldFBhbGV0dGVCYWNrZ3JvdW5kQ29sb3IoYmcpOwot ICAgIGlmIChlbmFibGVkKSBjYi0+c2hvdygpOworICAgIGNiLT5zZXRTaG93bihzaG93Q0IpOwog ICB9CiB9CiAKIHZvaWQgS01BdG1MaXN0Vmlld0l0ZW06OmVuYWJsZUNyeXB0b0NCcyhib29sIG9u KQogewogICBpZiggbUNCRW5jcnlwdCApIHsKICAgICBtQ0JFbmNyeXB0RW5hYmxlZCA9IG9uOwot ICAgIG1DQkVuY3J5cHQtPnNldEVuYWJsZWQoIG9uICk7Ci0gICAgbUNCRW5jcnlwdC0+c2V0U2hv d24oIG9uICk7CisKKyAgICAvL3BhaW50Q2VsbCgpIHdvbid0IGJlIGNhbGxlZCBmb3IgdGhpcyBp dGVtIGJlY2F1c2UgdGhlIGNvbHVtbiBpcyBoaWRkZW4gYXMgd2VsbCwKKyAgICAvL3NvIHdlIGhh dmUgdG8gaGlkZSB0aGUgY2hlY2tib3ggaGVyZS4gSXQgY2FuIGhvd2V2ZXIgbm90IGJlIHNob3du IGhlcmUKKyAgICAvL2luIGNhc2UgJ29uJyBpcyB0cnVlLCBiZWNhdXNlIHRoZSBjaGVja2JveCBt aWdodCBub3QgeWV0IGJlIHBvc2l0aW9uZWQKKyAgICAvL2NvcnJlY3RseS4gU2hvd2luZyB3aWxs IHRoZW4gaGFwcGVuIGluIHBhaW50Q2VsbCgpLiBTYW1lIGZvciB0aGUKKyAgICAvLydzaWduJyBj aGVja2JveCBiZWxvdy4KKyAgICBpZiAoIW9uKQorICAgICAgbUNCRW5jcnlwdC0+aGlkZSgpOyAK ICAgfQogICBpZiggbUNCU2lnbiApIHsKICAgICBtQ0JTaWduRW5hYmxlZCA9IG9uOwotICAgIG1D QlNpZ24tPnNldEVuYWJsZWQoIG9uICk7Ci0gICAgbUNCU2lnbi0+c2V0U2hvd24oIG9uICk7Cisg ICAgaWYgKCFvbikKKyAgICAgIG1DQlNpZ24tPmhpZGUoKTsKICAgfQogfQogCkluZGV4OiBrbWFp bC9rbWF0bWxpc3R2aWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0ga21haWwva21hdG1saXN0dmlldy5oCShy ZXZpc2lvbiA0OTc5OTApCisrKyBrbWFpbC9rbWF0bWxpc3R2aWV3LmgJKHdvcmtpbmcgY29weSkK QEAgLTEsNSArMSw1IEBACiAvKiAtKi0gbW9kZTogQysrOyBjLWZpbGUtc3R5bGU6ICJnbnUiIC0q LQotICogS01Db21wb3NlV2luIEhlYWRlciBGaWxlCisgKiBLTUF0bUxpc3RWaWV3SXRlbSBIZWFk ZXIgRmlsZQogICogQXV0aG9yOiBNYXJrdXMgV3VlYmJlbiA8bWFya3VzLnd1ZWJiZW5Aa2RlLm9y Zz4KICAqLwogI2lmbmRlZiBfX0tNQUlMX0tNQVRNTElTVFZJRVdfSF9fCiAK 14258 2006-01-15 12:29:49 +0000 2006-01-15 12:29:49 +0000 New screenshot with the bug kmailbug1.png image/png 39393 aironmail iVBORw0KGgoAAAANSUhEUgAAAsMAAAHSCAYAAAAJ7sbhAAAgAElEQVR4nOzdd3hUVf748ffU9F4h lRpICB0RFQRpgkYQBSWCoILilxURy7q46Or+1EV37S52BCUoRUBkAZGqIE1a6KElhEAK6ZMy5d7f H8MMTNrMZCYE5Lye5z7J3HLKnZuTz5w591zFPaPHA3CgNEhGEARBEARBEG4AZ9Z+AID64Uef4Ln3 FslDxj/XzEUSBEEQBEEQhKvjZ8wBsSJ+6DR5yPjnyCo0NHeZBEEQBEEQBOGqKDiTTsGhDagtKwzV lc1ZHkEQBEEQBEG46kQwLAiCIAiCcAOoKMnDqCtyOR21TxDeAeHXbbq1tlt+MeirXM5MEARBEARB uPYYKksx6opISuzoclqHDh+hAtB4+V936dZFfflXhdOJG40yCoWMSqVsZPEEQRAEQRCEpmbUFZOU mOiWtJISEzl0+Agar4DrLt26XA6GFY4Fw1VVEm3CA7ktIYiYUE9MJpnjOTq2Hr1IXrkOrafKLQUX BEEQBEEQ3EShcDjWcyq96y3dOqgv72MnQxmUaHj+vnYMSPDFWwtqpYIqg0zfpADGDojih51FLNl4 HJWP6CkWBEEQBEG4VigUCvuxXiPSu97SrYvDPcNKNDxyZ3sSIlToqo0oFCqqDSYKyo3WfW7v6ENB ZTs2/X4clZ+6gdQEQRAaplUrMZpkJFk8D0gQBMFl11sPbnP0DEP9vblVVRIdWwXQJlAi2M8bf08V WhVcLC1j368ZqLRaTGoNodH+dAgxsifAl8LyMjy8PdxXCUEQrltbX76p3m2PfXGIozm6Wus3zryJ F78/zpajxSgU5jT+tiiDLUddv7O4sWqWIcRXwxeTkliw7TxLduY2W7kEQRDsU6JoINZrTHqWpa50 50/pZDeFhz852Oh06zq2oW2X063NoWESYUF+HD91hjO9WhNiUKJQwrmc82zfeZohPeJp2zaMsjID v+84y6+/HuP08XwiWrUBHzdG9IIgXNf+9c0m0n7ZX2u9JEn4xXZF5elba1tFzlGMFR5ofYKZ/u0x /ti2CYNfPAN7tOH4BR25JfqrUHJbunNHMOg88AsMZfaD7fntWCFfff8TnkExeAS1cDn9vglBbqub O9MSBOH6pnBzT6vNUIZGpnt2/3piug5qVLrzp3Ti4U8PXX79RJJD6dbF7jAJWQaTUU9YgDcZ6fso P6GnY4w3P23cjcYUTkJqH06dyiM6OoI7hyRw9/AESkqq2LA5i/UHLnJAqan/LAiCcMMwSTKaoGg8 /MJqb1QoQAaUtdsh2aRHRmL3mTIqVAF4qDW8OaYtz3+zl/OFepTqZvgGStIz8554yqtM/L8vVqHS eqPxDUKWTChUrg0Rc2fdmv08CYJw7WiG4QwDnny/3sM3znn6cjpOpPvwZ4eZ/7h5lon5TyTZvLbJ s75062C3Z1hlKKeb9iyd4wJI7NiGlpGx+Pp4kV9UhtoQRrVegUql4Wx2OX7+vnhowcvTk363tqR3 z1DGzjtd74kQBOHGogCUGi0KVY0PyTL0aRvAI/1aoFIqCPK2DSgVCgW//b0nf/vOlwn9YgB4/cHO 7DpRyItLM2kd4c30ITF0bOlDhd7E2vRCPtt4DqNkHm/860s9mLPhHCO7h7JkVx6Ldua5VI/JgxNo F+nD+Dd/xGg04duyLUqVGoVKQ+sIL7tleXX5abrE+jKkUzCyDHM2nGPFnnw+f7RjrbqN7RNJSrdQ wvy0mCSZXw4V8s6aLC4lR3yoJ/83MJqusX5o1ArySvU88vkR3h/XvlZabv1HKAjC9cXNN6RxRe9t Q+nGdh9iJ5naQau9dCd8foR5k83tZV2BcJ15OtYzXPc4iqm9jAzqNxLZZEKr1eCp9UCpUtGpbTSF uUpKSyEgMJgdOzJo264NZ/Lz8PWViYsLYu++gnrTFQThBqVQ1moX2kZ48eaYNkyfu5fN2/egkGX2 fzH5yoMA0J0/zoQPz7LjzcE899EqNuw5hV9QKO9Mf4BNhwuYPPsHQr1h/kv3U1Hizde7K6wBYEqy L/9I+4MjR45T5RGCZ3B0o4p/580JDOrVlgdmr6OwIB+flgkoVBoUak88tUreGdvOblmm3B7Gku05 3Ld8O+Nui+Xxfh1YtCGdyXOV/Dqzm7Vuau9ATrcL4okPtpCddZqurUOY//f7WbHlABkVQfh4qHl/ XAIZ58u499Vl5JzLITYigLzCSiZ9aeC3v/eyScsvrkuj6iwIwvVP0cCY2Uanp1A6kK69PG23O5ru hM+PMW9ygvX15UD4zgbLWxe7D90o1Kvw8vJBLRlRHT2MorQUKTyC2Pi27N+3G1+/GDw9wc8vkAP7 M7jppjgCAjxRqWHZxlPgG1xvRQRBuHG8NGEAL02wXffdjjw+Xp/D8C4hZBdWsWHTFrxC49DUajcu t0+S4fLTMr0i2tCvextCfDX8d+FajCYFJR7RrD2Qz129opnzv9V4hbcD4IuVu9i28zgewVFoPP2Q TQYUKq3T9cgtLAdkBicGcK64FUqNJ0qNFygU9Gzl71BZvl2zl6/XHEDrH8LhfJmHfDyoyD2F9ooh JF4RbdB4B7LtSB6Gcj3+LeK5qPIDwFfWoS8zMbRTB4J91Lz2+SpyCivxikygQOOJR0h1rfOk8Q5E 0leh1Ho5XWdBEP4EmqBnGOz3DNvLs66eYUfS/XpSe5vXG+c8zcQvjtsvbx3sDpPYc6qclCqZUC81 UrsOqE6dQHHxItq27SlDxzcrdtImPIzEjtG0bR9GRRWYZDAa9OzMKscnKaT+ggmCcMN4fd5G0tbt q7XeKySWFoGtKCgqQ6HSoPULRaX1sdmnoQYxPMh8413+xWK8YpJRevhQXK0iLNCHqpI8PEPiACgs qcAjMBIPvxAUak8UKrU13bu7BDNtcBRgHts87J267kQ223v8HIfPV/DWY30p0u9mzUkViku9DaG+ GofKknmhCG1gOB4BESgv1VWWjEgm2xvdVFpvRvSMYHhyMueL9ZRVmazbJEM1Yb7mJvzshYt4t0xC pfVGpfVG0hpRKJW10nJ1PLMgCNexJhgzbL3JraF07eXZwDCJ+o79+rF21t8HPPm+dfzx15PaM/HL jIbLWwe7N9CdqfDiQEYO/TtHg9YDhdYD9ZkzKIJD6JrcjlytkQKFB8t27UddaiDCP4QuXWLZt/80 6phgMUZNEAQrr9BYtP7htdaXVxqIDNGgVGtQKFQE+Xva7tBAM1JQbgAgJMCHKpUWlcaL0ABPCkor kU0GZJPhcjJqDUqNJwq1bY/wTweKWLL5EBXnL/cqBCf2rzfPTUeLeXf5fv42pgfFX+9iR665vBd1 RofLYulRVmiuKEuNOZU7x/ry3J3R3PfWFk5kZKDSejGyR6p1e15ZNQBxEYFcVGtReniDUomyrh5v BaI9FoQbWH2zM3z9aFu7x0786kS96dmdTcLJYNheuleW1zI0YuJXJ6zrv36sXYPlrcsVPcN1j6PQ e4SzaXcGNydF42GoRpZk5MpKJK0nbVpE4X3gN1ol98WjYwu81DK//naYp99Lw9s/CP/ObUXjKwgC ACqlApVSgdbTB6Xm8swGsiyz/XQld3aOoVvrcAo0Gl65J9bm2JpzTVbqJUIDfVDkVPDH6XIKSquZ fE8v/rulkKggL4Z2CuKHX4+hUKmRZck2LYWqzvZO4+2PT8sEVFpvAIwVpWh8Auutz9IDFUQEHuP/ jevOU1/s4VipN39kVjhVFqVSjaJGpH9l3YK8zUFtgDGPyKh4BnU3n5fYyEB2ni9lW0YZF8uqeeXR Qbz9v0zKlFpah3lyKr8aXbXJJi0FynrbeUEQbgSNn2c4c9cq4nul1E5PUf98wHDFjBENqH2s/XTh ciBsKdcjX51i7qOtHShvbfanVkPBkawSjuZLdPasgoKLFN85gpOqYA4eNpF1toTO3WU0Sokf1h7m 10NZRPa9SQTBgiDYeHF8f14cX3v911vzmLctj7TN1Xzy7F2UVpr4YP15esRfMe9wjeZk/tYLvPDQ 7YSvP07anmqeXXiMpweEs25WJ6qMsPZAAR8v3oLWJ6jWcIH6ekjVXgGovQIcro9K48knWy4SGejF fyZ0YcoXB8iu8na5LPN/z7fWbfH+En7ef55PX7iX4goD3+8sYP6m00wfcxunirZysMjItPmHeap/ KN9M6w0oOF1QzXPfpCNJHjZppe2pFu2yINzI6ukZfWTuac7s/NGx4+tKrxnTjb/pnvrzdGJqNUX8 0GnykPHPcfRcWb3lVFYVcntiGP1vTmDnaYk9R8ooPb0fQ+kFZIWM0TeKkvIyvEIC0fg4/s9EEIQb R8GBtfVu845og0dAOGU5xzDqilGqtXgEhlOZn4V3ZFu8gmNQqLUUHFhrfV2WdQC9rgjv0Di8I9qh u3AcfflFJH0FKFSovXzxDotH6eGLSutlc2zNYRLO1uPKdPRl+VRcOImpupyAVr1Qe/ujO+9cWaoK MinPOUpA655ofEMoPbXbWjetfyTl5w9hrCxHqdLgERiJUV+OobQQv9hOePhHoss7jqGsCFN1GchK VB7e+MZ2RuXhTdnpPZfPU2T7BoecCILw51VZkEmnxI5uS+/g4SN4hcZdd+leqSI3g4JDGxx7Ap3s FcKGXw+xasN5VMY8vPxkpKDWEJgIsoxCqSIgRNwoJwhC/bwjWqPxqX92GYVKjU9YK6TgapRqTxQK BUqtN2oPX+v4Me+I1mi8A0GhwDuyDR5VOpRaLyRjFd4RrVB7+6FQqlAozU2bUuuF2sP7cv6XjnXl juqa6Xj4h4EkISMjyyZAdrosGv9QfOlgPg816qbUaPAOb4UsySjVGkCBljBMgS1QajyQMeET1oZq z3wUChWo1OZ4VzLWSksyVKK6VAZBEG4wzXUD3bWWbh3szjNsoYxJwnzPcwtkROeCIAjO8WnRwe4+ Kg8/m9eaGk+ruzINpcYTjW+ozXbP4BiX8ndEXel4BLW0ea1QaZwqi9rTH7Wnv/W1xjfUpm51Paq6 pvryq5mWIAg3qvqnFmt0egrldZhubQ71DAuCIAiCIAjXLw//MA4dOeqWoQcHDx/Bwz/M+u3Y9ZRu XezeQCcIgiAIgiBc39Re5m/eDh4+4nJaWr9Qa3rXW7p1sfsEOkEQBEEQBOH6p/byR+3lb3/HP3m6 tfKx/GLpOtaXFTR5poIgCIIgCILQHLR+tvdR2DybU19WwPq/dr2qBRIEQRAEQRCEq2Xg7H02AXGt B9VXVlZe1QIJgiAIgiAIQnMRz+YUBEEQBEEQblgiGBYEQRAEQRBuWCIYFgRBEARBEG5YIhgWBEEQ BEEQblgiGBYEQRAEQRBuWCIYFgRBEARBEG5YIhhuJtXV1ZhMpuYuhiDYENelIAhNRbQvwrXK6WA4 KCiIoKAgTp8+XWvb1KlTCQoKYtWqVW4pnKuCgoJYsWLFVcmnvmXv3r11HhMZGcmaNWts0rhWztvM mTPp3LkzkiTV2rZ27Vo6dOiA0WhshpKZbd++ndGjRxMbG0toaCi9evVi9uzZVFVVuS2Pa+n9cNWa NWsICgrivffes7tvXdfl1fgbulqCgoL4/PPPa62fO3cuQUFBzVAi5/yZrkuLmm1mcHAwsbGx3HPP PWRkZDQ63UWLFtG2bVtatWpFRUWFG0vsHtfSe+lMG+GKmu2LIFwrGt0zvGTJEpvXlZWV/Pjjjy4X yJ2WLVtGnz59rkpeb775Jvn5+bWWrl0de6LfsmXLuOmmmwBYtWoV2dnZTVncBj300EOcPXuWLVu2 1Nr23Xff8cADD6BW13pey1WxbNky7r77bjp16sS2bdvIysrirbfeYvHixdxzzz1UV1e7LR/L+3G9 S0tLQ6FQkJaWhizLTh3rzr+h5r6u/wzceV1eS++Hpf3My8vj9OnTLFy4kMzMTJ588slGpzlr1iye fvppjh49iqenpxtL6x7XUhvjShshCH8GjQqGb7rpJhYtWmTzR7Nq1SoSExPdVjB36N+/P+Hh4Vcl L5VKhVqtrrUoFAqHju/fvz9hYWEAjBs3jv379zdlcRuUlJREt27d+Oabb2zWFxcXs3r1asaOHdss 5SorK+OZZ55hwoQJvPLKK0RHR+Pt7c2AAQNYsmQJ+/bt45NPPnFLXle+H9ezixcvsmbNGv7617+S kZHBnj17nDrenX9DzX1d/xm487q8lt4PS/up0WgICAjg1ltv5f7773epfHl5ecTExODh4YFSee2N CLxW2hhX2whB+DNoVAsxevRoTpw4YTME4LvvvqszSDp69Cj33nsv7du3JyEhgWeeecam9y4oKIil S5cyY8YMYmJiiIuLY+7cuQCYTCZeeukl2rdvT8uWLWndujWLFi2yHvvhhx/Sq1cvoqKiiI2NZcaM GTZf7V/5Fa+9cjS1devWMXDgQPr3709SUlKt7ZavzO644w4AHnvsMR544AHAsXq+//77dO3alTlz 5rilvOPGjWPVqlUUFRVZ1y1btoyOHTvSoUMHwLH31p3lWrduHSUlJUycOLHWtvj4eAYMGMDixYtt 8p87dy7Dhw8nPDyce++9l4KCAuv2Y8eOMWbMGKKjowkPD6dbt26Ul5dbj7V8hXn48GFSUlKIiooi ISGBV155BYPBYJNPfdewvfNk7xp31ZIlS2jdujXPPfccLVq0YOHChTbbHbkuLX9DNb/Wret1fefh WrmuHdWYa7uudY7Ucf78+QwZMoSwsDAmT57MxYsXGTZsGKGhodx33302w3+uPOeutK3Ovh9NfZ3W JScnxxos1nVuG6p/69atAZgyZQpPPfWUw+fLmTwsxzT0t+9oG9Oc576hNiI1NZXHHnvMZv/nn3+e 5557rlYd6nptr32x9/chCFdLo4Lh7t2706pVK+sfZG5uLtu2bWPkyJE2+1VUVDBy5EhuvfVWjh07 xo4dO9i6dSvvvvuuzX6zZs0iNjaW7du3M3bsWF577TUAtm3bxn//+19++ukncnJyOHDgAAMGDLAe 17FjR1auXMm5c+dYtGgRc+fOZefOnbXK62g5msrBgwdJTU1l1qxZbNq0iUOHDtW774YNGwD48ssv +f777wHH6jl37lw++ugj6z82V40aNQqwHQ6zcOFC6wceR8+pO8t14sQJANq1a1fn9oSEhFpjDGfP ns3EiRNZs2YNhw8f5uWXXwagtLSUe+65B0mS2L59O+fPn2fRokV4eHjYHF9RUcGoUaNISEjg9OnT rF27lsWLF/PWW2/Z7FffNWzvPNm7xl2VlpbGuHHjUKlUpKamsnTpUus/c2euS0fVdx6ulesa4IUX Xqg1TnXGjBnW7a5c2zXXOVLHjz/+mFdffZVFixaxZMkSRo8ezcyZM1mzZg0bNmxg/fr1tergatvq 7PvR1NephSRJ5OXlMWfOHBYvXsykSZOs2648t/bqf+rUKQA+/fRTPvzww0a9p66eY0fbGGjec99Q G/Hggw+yatUqSktLAfN19/333/PII4/YTdeR9sXR/+GC0NQaFQwrFApGjx7N0qVLMRqNLF68mKFD hxIYGGiz3/r168nNzaVbt27s2LGDo0ePkpSUVKtxnzJlCtOnTycqKorevXtTXFwMQEhICADz5s3j 6NGj+Pj42HytNGjQICIjI6murqZNmzaA+Sufmhwthyvq+gc7a9YsABYsWECrVq3o379/o9J2pJ7T p0/ntttuIzg42KV6WAQGBpKSkmIdKnHy5En27dtnDZIdPafuLldD6hrrNmPGDMaMGUP37t1JTU1l 7dq1AKxevZq8vDxmz55NdHQ0KpWKdu3aodFobI7ftGkTubm5PPvss2i1WuLj43nggQdq9bDWdw3b O0/2rnFXHDx4kMOHDzNmzBjAPBa8uLjYegOLq9dlXeo7D3Vpjusa6h7f//bbb1u3u3Jt11znSB2n TZtGnz59rO/DhAkT6Nu3Lz179sTPz4+SkpJadXC1ba1LQ2VtyusULrefISEhdOrUie+++463336b Z555xrrPlefW2Ta9Me+pq+fY0TYGmu/c22sjhg4diqenJ8uXLwdg6dKlJCQk1NnLW5Mj7Yuj/8MF oak1+i6o+++/n7feeotNmzbx/fff8/e//73WPpavpBcsWGAdO6tUKundu7fNfpY/Ast2i8TERBYu XMhHH33Ep59+Stu2bXn//fetx8+dO5e0tDRiY2NrBeKNKYcr3nrrLSZPnlzntqysLCIiIhqdtiP1 bIqxZ+PGjWPkyJHs37+fVatWMXjwYEJDQwHHz6k7y9W2bVsAMjIySE5OrrX9+PHj1n0soqKirL+H h4dbezjOnz8PQFxcXIN55ubmWo+9Mh3Leov6rmF758neNe6KtLQ0jEYjCQkJNusXLlzIiBEjXL4u 61LfeahLc13XlvGpNddZuHJt11znSB0t6y15XblfffccuNq21qWhsjbldQrw+uuvW7+O12q1ddb7 ynPrbJvemPfU1XPsaBsDzXfu7bURHh4ejBo1ioULF/Lwww8zd+5cm976hjjSvjj6P1wQmlqjg+F2 7drRtWtXXn/9dXJzc61j0K5kaQRmzpxZK0hx1J133smdd95JYWEhL7zwAhMnTuTIkSNs376dGTNm sHv3bmtj9NVXX9WZhjvK4Qp/f3+bqeiuHLdqjzP1dLe+ffsSExPD/PnzWbduHW+88YZ1W3Oc08GD B+Pv78/cuXN55513bLZlZmayadMmXnzxxXqPP3fuHDExMQC0bNkSMH+d2r59+3qPsTTm+fn5REZG AnDhwgWHg0hHzlN917gr9Hq99Wv3gQMHWtfPnz+fGTNmkJeX16jr0tL77uosBM15Xdvjrmu7Kevo 7r8/R8raFNephUajqXP4QH2crX9jzper59jRNqa5zr0jbUR4eDipqakMHjyYFStWcPLkSe69916b dOprE+y1L9dyGyDceFy6xXb06NHs27eP+++/v86vfvr160enTp14+umnOX36NLIsU15eXu/cuzWd OHGCHTt2YDAYCAgIsAYycPkP69y5cxQUFFhvWjh16lStOXBdLYcjTCYTRqOx1iJJEkOGDLEG8Bcv Xqy3B9nCx8eHvLw8ZFl2qp7uplQqeeihh5g3bx46nY4hQ4ZYt12Nc1qTn58f7777LvPmzeOf//wn OTk5VFZWsnnzZu6//346d+5cayqmyspKwNyb/P333/Pwww8DMGzYMMLDw3nmmWfIyMigrKyM7du3 W3uOLQYMGEBERATvvPMOBoOB06dP13uzaF3snaeGrnFXrFu3DlmW6devn836lJQUlEolS5Yscfq6 9PX1Ze/evRw4cICpU6c6XaZr5bq2x13XdlPW0R1ldOb9aKrrtLGcrX9jzper59jRNqa5zr0jbQRA jx49aNOmDVOnTuXBBx/Ey8vLum9DbYK99uVabgOEG49LwfDYsWP58ssv+ctf/lLndrVazQ8//EBc XByDBg2iRYsW9OjRo9Z4y/qUlZXx/PPPEx8fT2xsLFu2bLF+chw8eDCjRo1i9OjR9O3bF51Ox/Tp 0/nnP//Jr7/+6tZyOOJvf/sbYWFhtZa33nqLESNG8H//93/cd9993H777bXuzq3pueee46WXXuLf //63U/VsCmPHjkWSJO677z60Wq11/dU4p3UZNWoUy5cv548//qBnz57ExMTw7LPPMmrUKH788cda 84lOnjyZyMhIRowYwaRJk6x3lvv5+fHjjz+i0Wjo27cv7dq1429/+1utB3d4eXmxdOlS0tPTiY+P Z+jQoYwZM4bnn3/eofLaO08NXeOuSEtLY8SIEbU+pAYFBTFo0CDr16DOXJfTp0/no48+YtKkSdYb EZ1xLV3XDXHXtd2UdXRHGZ15P5rqOm0sZ+vfmPPl6jl2tI1prnPvSBsB5qE6Dz74IDqdrtaNcw21 Cfbal2u5DRBuPIr4odPkIeOfIyNPj76sgJ+mJdg96HpgMpkIDQ1lwYIFDB8+vLmLIzSDoKAgvv32 W+66667mLsp1SfwNCYIA8Nprr7Ft2zbx9DjhT+PuD46h9QulLPsgBYc2ODdm2NnHlV45R+3VlJeX x4ULFwCsc+I2FUfOSXOdh8a6VuvkzPV3vZ1zd3P1Pbyaf0NXi6PXz41+7VxN12pbI5jVfH+ufC3e F+HPxKlg+Hq5+EePHk1OTg4vvfSSdfL1pnK9nBNnXKt1crZc77//fp2zTtwIXH0Pr+bf0NVyrV7X NzLxnlzbioqKSE9PZ+HChbz88svX5GOtBcEdGj2bxLVs8+bNzV0E4RpguVlOcJ74GxIEASA5OfmG 7VQQbhzX3gPbBUEQBEEQBOEqEcGwIAiCIAiCcMMSwbAgCIIgCIJwwxLBsCAIgiAIgnDDqnUDXVM+ QUwQBEEQBEEQmpe3zatawfAtt9xy1YoiCIIgCIIgCFfVr/tsXtYKhisrK69aWQRBEARBEAShOYkx w4IgCIIgCMINq8Fg+PDhwxw+fPhqlUUQBEEQBEEQriq7PcOJiYn4+PhcjbJcF/bu3YuXl1dzF8Pq WivPjUacf0EQBEG4vjX4OOamDoSrq43s2ZPNjh2nCQvz46GHejZZXs0tbZeeqd8Wk9pTw8fjg5q7 OHUyGk1kZ1+kokJPYmK0y+mdO3exwe1796Zz9939Xc7Hnt9/P8jFi6U264KD/bnllk5NnrfFq6++ ypAhQ+jTp89Vy7M+hYVl7Nt3iuLicnx9vZBlmbKySoKD/UhMjCEyMri5iygIgiAIV02DwTCATqcD sA6XSExMdDnT6moj+/ad448/sgkN9ad79zZs336CCxdKiYz0dzn9ep1dBUHJ4BtbqzweHnZPRaOl /WFk6iLzjYlpv+vAaOTjR8KaLL/GOnHiPL17d2Lr1nS3pZmU1Mb6u9EoYTRK6HQ6lEolkMxPP21q 0oD45593UlRUzhNPjLJZ/8knSykr0zF0aO8my9ti2bJlVFdXM2HCBDw8PHjjjTdISUlp8nzrcvTo WY4cyWLgwJ7ExISjUCgAkCSJzMwL/PLLbpmQ64sAACAASURBVOLjI+jVK6FZyicIgiAIV5tTN9C5 2lNcVlbNxo0n+eKLHeh08OSTd/Doo7fRrl0EycnRbNt2utFpN0RxOg1WdMG05w1Me2cD5gD4yJFc Pv98GwsW7GySfAHS9kpMXaonwEvByqeCSI5Wk7atjKlfXGiyPBtPgUIBOl3tGUXy8opJT890KXWV SoFKpbgUCJv17NmZn37a5FK6V5L05ZTt/oDidU+xbsGHZGXl88QTo6ioqLJZxowZxNmzefz8rXnf st0fuK0MNe3cuZPi4mISExNp3749//rXv0hISOC9995DkqQmy7emQ4cy2b//FGPHDiYqKpTy8nLy 8vK4cOECFy9eJDo6jPHj7+TUqQvs3XviqpVLEARBEJqTw8GwK4FwebmeLVtOsXDhPpRKLVOnDmLU qC4EBnohSRLFxTp6927Nrl2ZVFYaGpVHXZSZaahXd0FbvBH/kd/gM+ANqrN3snvHCb75Zhc5OTr6 9euIJCnJzCx0W74Wafth6gqJAE8FK6f4cFtbDSunh5McrSVtSzFTPznr9jxdYQlSy8ttg+GsrDzK yw3ExES6nIdCoUClUgHmYRK7dx8AcFtAnLPyL2h98gjrk0xmmZY+fTqRnZ1HYWGpzVJRUU2fPp3J LNMS1icZrU8m2UsnuqUMVxo/fjwqlYozZ86g1Wrx9/enR48eDB06lO3bt9OlSxf+8pe/cOGC+cPR mTNn3F4GgJISHb/9doCHH74ThUImM/Mcy5f/SlraeubNW8eSJZvZtWsfFRXlPPTQYLZvP0RJia5J yiIIgiAI15IGxwbUHBphGTLhqNzcco4cySMnp4wuXaJ54okkAgI8rNtNJhmDQaayUo+/vxetW0ey a1cm/fq1dbYeNlTZaaiOzEYVeROauxei9IuitLicfYdKOCy9T0dPfx57rCO+vp4cPpxDt27x7N17 lrg4942VTDuoYupPMgGesHKCB8ktzIHm1G+K+Os9wcz+wUDa5iIwmfh4arzb8nVFeXkFer2JsrLL 73NGRjYVFUZuv70r+/adIDDQo4EUHKNUKjGZTAwZ0o/S0nLKynQcOnTM5XQBqg0XCb/pNgD0pgoA MjPP17u/3lSNdwsfvMMTyN6zwi1luFL//v15++236dq1K1qtFoVCgdFoxNfXl8TERLp27UpWVhZ3 3XUXISEh5OXlsXbtWiIiItxajqNHM+ndOwmNRsX587l8/vlPDBjQjZQU80N2MjNzWbZsC0ajnt69 e9KjR8KlY1wfFiUIgiAI1zK7A2UtPcLOBML5+TrS0y9w8WIlnTpFcdddXdBoVDb7mEwgSSayswsJ D/fHZJLo1as1K1bsaFQwrDCWoMmcg/rCKhRBHVAPW4jCN5qyMiM7118gI6OSTp06MuHRODw91ciy THW1ieLiCrp0ieann/YwdGgiXl4ap/OuKe2QmqmrVQR4Glj5kJrkSx2qWYUmfjtezW+Hy/j2yQhm fm0gbX2BeQzx0659AHCH8vJKKioqKS83B5Hp6acwGOCOO7pTWlpJYWER8fGhjU7f3Cts/qlUKtHp KqmsrLYZNuEqvaxG1lcBMPB2ifWbGg5wB/WXzftXG9Ab3T/t9mOPPUbLli158cUX6dWrF15eXtb6 Go1GNBoNHTp0oHv37vj4+HDs2DFGjhzJ77//7tZypKefYsKEu9DpdOzefYyePRO46aaO1u1xcREM GdKLrVv30qJFOImJ8Xz33S8iGBYEQRD+9Nw6m0RWVgkZGQXo9SaSkqJJSYmoFQRbSJIJg0EmO7uQ Vq1CMZkk4uNDqK6W2L8/my5dHJvNQGEswePsHLTn0yDufpSDF4LWn/JyI39sLuDsWT2JiS2ZOLGF zU1yRqOEySRhNJowGiW6do1ny5YMhg51/Z//1HVegJ5vR8vWQBggNljFt08Ek/J2DuPeO8e301oy 80sDab/kmgPiZzu4nLcrysoq0emqKC3VsXv3URQKNb16JZKdnc+WLXsZNKi7W/JRKGQkSaKiogql UolSqaRbt+Ras080ZrYJXaUJSV8NQI9k6JFsqrXPoTOP2bxOP27+6d3/ETIzi9m9+wj33ee+WR+G DRtGdHQ0o0ePpn///oSFmW+eVKvVKBQKwsLCyMnJQZIkOnfuTFZWFk8++SRz5sxxWxn0egMBAT4U FBSQnn6S++8fUGufxMR4Vq7cTFFREcHBwej17huyJAiCIAjXKrtdYTqdDp1O59ADOHbvziYw0Jcx Y3rRuXPLegNhk0lGkmSMRpmzZy/i5eWBJMlIkokePVrzyy9HHK6Ax9k5qPJ/wdT9vyiTpqMz+LB2 bQGrVl0kIqIlDz3Um27dYmwCYUkyB8J5eaV4emoxmSSSk6PZvv2Uw/k2JDXRHETM/FlBSZXtttva e/LxxDBKKkyM+08mbzwaS3JrH9LWnmfq7INuyb+xyssrqKioprRUR3FxFQkJcWRl5bJy5RYGDuyG VuvajBtGo0R1tQmdrtJ6k15SUhvrkpDQijZt4oiMDKVly3C6dUt2eixxRYWEZKhqcAHo0iXeunTs GEe7djG0aBFCVFQYPXt2ZOlS9/bMJicns3//fjIzMykqKsLHxweVSoW/vz/Hjh2joqKC7du34+np SUpKCseOHePtt992W/56vYGlSzewatXv5OYW0rJl3T381dUGTCYTBoNBBMOCIAjCDcGts0kEB3sT EeHHiRP5pKfncOZMIUajbLOPLIPJJGEwmINflUqJJEkYjTJGI3TtGsfJkwUUFJQ7VCZ9i1RUxlyU flFUnvyd4mO7uHChil69WuHv71lrf1kGg8E8xdfZs4V4eWkwGiX8/T3x9/fh999POnNK6vTxkCpS k0yk50LK1xIlVbbnIPVWPz6e3MIcEP/rBG9MakVyG1/SVp9j6uv7Xc6/sSoqqti6dT8JCXEkJsZz 5swFVq7cwr339sXDw7XhI7Js7g2urq5GluU6Pyi5Y7aJikoTsr6qwaXufJWoVJfz7d07ye0BsYeH B6tXryYnJ4fc3Fy8vb1RKpVs3LiRnJwczp8/z+eff47RaGTatGksWLCAAwcOuCXv++7rT5s2LenS pR0TJgyrdz+j0YjJZKKyshKTyeiWvAVBEAThWubW2STi4gLYvTuThIRwkpNbArBq1QE2bjzGiRP5 GAwm601zJpNEbm4ZGo3S2issSRJarZJWrSJZu/aQQ+WSPGPRe3ZBUZ6BV5s+tEhMItC7Eq1WhUaj YteuM+zYcYqzZ82zRZhMkrVn+Nw583hly/y33bq1YuvWDEdPSYM+Hm4ktbNM+gWJlC+qKamsERD3 DeDjKdGU6EyMe/0obzzZjuS2fqStymLqP3a7pQz1KcnYQP7vcyjcMQfd0ctjas+dPsGZM+fp2NEc CP/00xYmTrwTT0+ty3maTDLV1eaeRrVabZ1RoiZXZ5uoqJSQ9FUNLnXnizUY3r37CDt2mK8/dwfE AD/88APnz58nOzsbgLvvvpvY2Fg0Gg1ZWVm8++67nD17lkmTJvHwww+7Jc+YmHDat4+1Lg2RJImq qipkucHdBEEQBOFPwa2zSbRqFcwff5wjO7uY6OhA4uODiY8PJje3jD17zrB+/SEiI4No3TqM6Ogg 8vOL0Wo1VFcbMZlkTCYTJhPcfnsHPvtsLSNHdsXHx/7sBfq4KSgPf4g24maUnn4kJMOhQzkMGZJI aKgvOl01+/adZcuWY0RE+BMREUjLloGUlVVSVWVAksxf4cfGhvDDD8UUFJQRGurn6Dms5bezKsYt U7PyAT2YFKTtlEj5RMfKKT4EeCms+6XeHgwmianvHmPcP9L59uUkZr6TTtqPmWAw8vHrNze6DHWp Ksrh5LKnSWh3lLgOWghQU34aclcuwKfDQ3TrqKRdj1tYvnwzer2eGTPG4OXl+uwRsixjMBhQKBTW paGb5lyZbaKqWrIOhXDUpedOXCqTxPDht1BSoqO0VEd6etPMt/vdd98xePBgwsPD8fPzIyAggHbt 2nHgwAEWLVrE/Pnzad++Pb179+bxxx/ns88+a1Q+FSf+R9Wp1Q7vPyIqh8ATOyBTzeCgEgp//h3P 1sPwbju8UfkLgiAIwrXO7bNJtG4dzP792URHB1rXRUT4MWxYMoWFlfz++wmWL9+Jt7cHCoWCzp3j OH++BJVKibe3FpNJJiDAi4AAP3btOk3//vZvKpNCbkO/cyrqsmyUftF06ODDL79k0K9fOzw9Nfj4 eHDrrW3p2jWG3bvPsHr1PtRqJf7+3hQU6DCZJDw9NciyTO/eCSxdupsnnqh9g5EzSqoh5VsFKx9S gVFN2o5KUj4qZuVfAgjwuhwIpt4RCpKJqW8dZtzf9/Lta12Z+fZe0pafMt9UN/s2l8phYags4/DX 93LHgELy87VkbjEQ1ELCv4sWyESpnU1wdA/W/uRLVfYfPPevf+HtXXuYSWNIkjkgtscds03IkmQz FEKuNECFAYwmkC6VocbD/8y9wopL+SsoKqqksrIKlUpBU/r3v//Nyy+/zPnz5/H39yc2Npb27dsz depUtm3bxvbt2wkLC0OWZV555RVeffVVp/M4s/Z1ksePxS/aB9Db3b81lx9R3REoO5tL+revkyiC YUEQBOFPyq2zSQCcknbxzppP+dcZLWqjkniveJ4e+jTJ0V3w8dHQuXMMKpUSvd7EgQOniY4OQaFQ oNNVU1iow2Aw4e2tISkpju++2+FQMAxg6vBXqg98idetr4BkpGtnL3bsOMPtt7cDQJJkVColsbGh aLVaqqv16PVGgoK8qaoyUFJSiU5XTWxsMHPn/uFSMHxbjImPh8HUFZDytZGVE9Rg0pC2rZyUdwtY OT2UAO8rAuJBESBJTH3jAONe3MW3b/Zg5v/bRdriDNAb+fjd/o0ui8W+pbO5te159vzujd8tbxA2 eATVF3ZTeXwyvkla8FIxLHw/Xat+R99WRjq5hAoPPzzj70CpbXwvOYDBcHlGB0ugazLVnuXh8j7m 8cUGgwm1WokkOREMy5J5NglJRi7UgcH+E94sPcMKhWXuaxNqtcqpfBujS5curFhhHqaSnZ3Nnj17 2Lp1K5s3b8ZgMNChQweOHTtGeXk5X3zxBb1792b4cOeC0oJiGb/QXNDtbVQZ/S7kUVDcdI8qFwRB EITm5tbZJKZ+P5XJOx7hyODt9BzSneI+xXwd/DXd/tONr7fMxWCQKSqqID4+jB494hg3rh9KpfkG OrVaSUCAF/7+XuTn68jPLyY/v8zhishRd1F1fB1yVRHIBpI7atm79/Ljg83TqEkUFVUQGelP69bh tGkTjskkIcsynp4aCgrK+fbbzXTpEudwvvVJ7WTi47slSqog5fNqpvT1ILW3J+nZelL+fZ6SCtsg LXVICz7+axIl5QbGzfidN2b2IDkxmLTvj7pcFgDT8YVojHpKwx8hrMsIAJRBCVSWmqDCiHS2mpNr ymgxwIPILmoiQz8ixOMNClcNpzrftTJIkhFZViDLsvVGurrUnG3Cw0ODl5cXHh5ODNWQJKTqSkwX CpF0FXbHDMsy6PXmOafLy81Ty5nz9cTT0/UhIo6Kjo7mnnvuYfbs2axevZrly5czY8YMhgwZQmRk JCaTiYcffpglS5Y4lW5BsQy6LNDpnV/2n4fMInMagiAIgvAn5VSXT0NDJuZsnkNacRr0gbkd5zKx xUSKjcUMYAD7Ru5j0rLHSAjvBKUhtGoVanPTnMlkunQTm4mdO0+xadN+oqIC+PDDcY4XThuAHHU3 1Rmr8ewwDD+tjvCAUtLTc0hKisRolNDrjRiNJrRaFXq9yXrjXH5+OUuXbgeMPP30QBITo5w5LfVK 7QJISqYuls1jhp/wBqORtF+LSXkzi5V/iyHA+/KNZKnDos1jiF/eha+vluGDYknfU//T05wR4lFN YYGMKraFdd2Zn2fTKdKIIRsOprehRXQGGAx4hAMXJdS+CtoOqOLg2meIfsDxcadXsgyPUChkFApF vcMl6pttQpbNxzmen4RUVIqsq3ZgX8vsJvKlfLHmK0nO5etuvr6+DBw4kIEDB2Iymbhw4QLLli3j l19+4f7773c4HXMwbACj/SESNrKKIb8cjLIIhgVBEIQ/NYeDYXtDJj757RMYdjkQBghUB7Kx+0YG 7BnAvn77eH/t+7x0x1sAlwJR801zkgQZGbn8/PM+Kit1TJlyO717t3a6MoqOUyj7aRie7QdhKM3n 5l5erN58jPbtzT3AxcWVBAZ6W4Pg8vJq1q49QHr6KVJTb6ZfvwSn87QntZsSJC1TvzOQ8mERK/8S CCYjaRsLSXntFCtntSbA53JAnHXOsSnlnFVeARF+en7d9C7lF8+jKDlCl/DfQK9kZ3oSHVK/pHLz rVAucX63H8p2z1N9bBORYRtoGX2O4uMbCGx/h1N57t2bzt696fVu79Yt2fp7zdkmLL3HRqPkXFBq MiFdLHVoV4UCDAYZvV5/KV+VTb5KZdMFw0ajkfLycqqqqigrK8NkMuHl5UVAQACBgYE2+6pUKnbt 2sXp06d56qmnnMqnsFSGSgPoHQyGq41woexSAC2BSTKnIQiCIAh/Um6bTSLLN4t/tPoHE1tMZF/u PrpGdKXYWGwNiLsZu3Hm+GkCA72RJPnSFGcy+fllrFmzn4yMswwdmsyYMb0aXRmFXyymwG5UZ+7A pDfi9dtX5J15kry8rvj5eaDT6QkM9MZgMLJ581E2bjzAkCGJPPLIWLy9XZ8+rD6pPdQgeTH122pS 3s1n5fRQMBhJ21hAysvHWPlaewJ8mnZcZo7vHZTkr+T+LmfA618QquHEOV+yVA+QkPoiKk8/DDoT prMylRFTCG47Ao+2Izi1eCgJ7bM4e+6o08GwvafHWZ44V99sE5Ik2R1fXJNcbURy8GERkgQGg7GO fGVUKkWtObJdderUKVatWkVmZqZ1Ll+DwYCHhwdKpZLKykokSUKlUnHbbbcxceJE67EjR44kKiqK 4cOHc+DAAQICAhzK0yRhHvJQ3UAwLElgks03GpZWmX83SdZg2GR/2LUgCIIgXLfcN5uEFopNxSzP XM4jxx+haHAR+8r3Me/CPCb4TgAdlEmlqNVKDAYT5eV6Nmw4yLZtR+jZM44PPnjIoWnU7NEkT6Fg 5WT0Bi0+d7zBzXEdWb06nZEju6FSKTh27AI//ribFi18eO21kYSG+rqcpyNSe2lB8mPqvIuk/DuH lc+2AJOJtHW5pMw8RM8WMuFBTReQD5r2MT/Pj8Hn0Eq0cimVwd2IuXUCCb1HWvfRlZioLDSibHO5 hzy3PIoOZGB0PB51Wn2zTZiDUxlJcqKH1nIDnQNMpvryxRocu8t7773HunXrePDBBxk2bBhRUVF4 eXnVu/+ECRMwGo1MmjTJui4+Ph5/f38uXLjgcDAMmIPcKj2oL90iIMnWQNf2Zz3rBUEQBOFPzG2z SQTkB/Be4Xu8x3tg+T+thK9Lv+br0q8BGMRwjEaJrVtPsG7dPiIjfZk1627i4kJcqYMNVfRtaHrP wrvdXSg8Augea2DTpvWcOBHNL78cRKcrZ/z4XrRvH+m2PB2V2tsLpCCmfpVLyhvmMcMYjaT9nEP6 Eb35q2xHv852koePH4OffB14vd59Sqqj8DId48TWFfRs1Qt9RRmq0gNUnDViaMKOa2dnm2hIXrGS Sp0eD439IK5mvk3RGwxgMplYuHAha9asISgoiJycHHbu3ElSUhKhobUfi7xnzx4SExO5/fbbrev+ 97//MW3aNFJSUkhIcHI4j8EEWpU5uK0v4K3RGyyCYUEQBOFGYTfEsfQI1xwyUVNqUirzMubhk3w5 eNaqtIR5mid1Ld5QTN+o4Xz44c+UlZUxYUJvund3fdaGumg7pVp/9/TU0KpVCPPnb+bee7ty883O j0V2p9Q+PiCFMfXTc6S8dpKVs1ozeVCg/QOvgnLvPsjlB4ksmM/qd0uRCw+R0jGbjBOeRNzv3BAJ Z1yebUKymW3CkbmJa3oubSf/Tu1FmF/9jxLuf7slX9Olm+gss1zIl/J1vg4NUalU3HfffUycOJEn n3yStm3bYjAYOHPmDGfPnrWOH7548SJlZWWEhIRwyy23cOTIET788EM2bdqERqPhlVdeYfz48c4X wFMNlfUEuvUGxxIYLwXIgiAIgvAn5rbZJP46/K9s+2QbJeoSIrtG8p+z/+HAxQO08WrDybUnST57 O6eOqrjjjgjuuWdovXkEBQXVu62oqMiZ4lqNHduLsWMbHovcFPnWJ/VWP5BaMPW/maTMOsqUYSHm 7+wti9G8bN15wa352pM0/EmWv7ua+5NO0Un9DURBWZmCE+oxDIx2bL5nZzU020RDs0805Lm0XQ1u z8wsxtLxbBkSYQ6IL69r2fLy9XDFSAWgcdfDCy+8wNatW/n+++85deoUvr6+SJL50eCWR1DLsnlW C51Oh0qlIiIigqSkJL799ls6d+7sdJ4WOUXhtFRmOhYI19iWU6JpdL6CIAiCcD1w22wSAV4BrJiy gtn/m82yL5YxJ34OhioDZCuJybudh296lNGje9i9Ua2oqKjOwNTdAWlz55vaNwCkaKa+f4rZC8+a b3CyDJOo0kN1NVQ6NvbVXXxDo+j6+AK++eRJ2qqPUlSpoar9ePo++mKT5Gdvtommsnv3EXbvPtLg Pl988T8mTar9gAtXrodbb72VW2+9FYDi4mJKS0uprq62BsQeHh74+PgQHBzs1FP3GtK5/928+/5P gHMPz6mZhiAIgiD8WSnih06Th4x/jow8PfqyAn6adnk8or2hEU3pysC0qQNhZ/Ldu3cvt9xyC5WV lVetTA251srzZ3O9XQ+CIAiCIDTs7g+OofULpSz7IAWHNth/Al1jHsnsDpbA42oGwo7k261bt2sq 8LnWyvNnc71dD4IgCIIgOKfBYLi5AmGLqx0IN3e+wrVJXA+CIAiC8Ofl8GwSgiAIgiAIgvBnUysY 3rt3b3OUQxAEQRAEQRCuAm+bV7WC4W7dul21ogiCIAiCIAjCVfXrMZuX7pm/SRAEQRAEQRCuQyIY FgRBEARBEG5YIhgWBEEQBEEQblgiGBYEQRAEQRBuWA4/jlmo285du0lPP9TcxRAEQRAE4QaVnJzE Tb16NncxrlsiGHaBJRCe8sTjzV0UQRAEQRCuY598+lmj44lPPv0MQATEjSSCYRekpx/i8ccno6vQ N3dRBEEQBEG4TpWUlgAgSRKVVUanjx8xchQrlv8gguFGEmOGXSTLMrIs07lTvPgpfoqf4qf4KX6K n+KnUz8ty5UxRWMWofEU8UOnyUPGP0dGnh59WQE/TUto7jJdN778ah6TJj1GRYWeHt3a8cfejOYu kiAIgiAI1wlL7FBaVspPK1cw6bFHqag0OJ1OWXkZK39czmOPTmiCUv753P3BMbR+oZRlH6Tg0AYx TMJVlk9ku/ccF5/MBEEQBEFwmCV2uNwzTKNiCVmS3F20G4oIhl1kuYh79+rIjl1Hrmre1dXVqNVq VCrVVc33WnGj118QBEG4vlliB0sw29ghD5KdY5yd+epGm53CbcFwcwYmrubtyvGyLCNJEr/vOIR0 6WKOjYmw2UehUODj40vnzp15/fXZtGnbrlHlrKlN62g+/+Jrhg4d5pb0mkJsTESTlfF6qL8gCIIg 1McSO1w5ZlhqRC+vvQA6Pf0QM56Z5nB677z7wTURDF+t2NLhG+iCgoL4/PPP690eGRnJmjVr3FKo +vJftWpVk+TtyvGWrzRuu6WzzSe6V/7xT06eyubkqbMcSD/Kl1/NJysri2eeecqlAfKuDLZfs+Z/ nMvOdlv+jiwL0hbRo0fPJknb2fqLRSxiEYtYxHItLZbYwdKz60pajpAkye6i1zc8Q1ZQUFCdy913 322zjyVmCwoKYsWKFc4FV5c0dWxpcc0Ok1i1ahVdunQhOjoagGXLlpGUlNTMpapNls2f4jb/utfm 05xSoUSpNH/W8PX146abejNixL188ul/G/Wpz17+jnh88iN8+tlXRLZo4bb87bnlltsA3FrnKzlT f0EQBEG4llhiB1l2sWfYwWMcSdtkMtnd580332TSpEk26xQKhfX3K2O2ZcuWkZiY6FD5mss1O7Xa uHHj2L9/v/V1//79CQsLa8YS1c3yieyO/j1tPp3J1P7Udv58DmGhociyTKv4lnzyycf063szX375 GbIsc/zYUcY99AA9e3SmV88uzPzbC1RVVVmP37hhPSPuGU7K3UPpc3MPm/ztHX9PinkowVN/mcKj j453KL+6ytgqviXffbeA+0al0LZNLE8/PZXCwouMvn8kbdvE8PD4sVRWVtqksXbtauvvP65Yxt9f +iudktrTOTmBBQu+se772WdzuGPAbSQltiW5UwIvzXwBk8nkcP2PHj3C2AfvIymxLb16duHNN/6J wWBo9k/+YhGLWMQiFrHUtdSKHWTb/2ut4lvWu1y5n70xwxaO9Aw7EgyrVCrUarXNcuVQhitjtv79 +xMeHu5gVNU8Gh0Mr1u3joEDB9K/f/86e2yPHj3KvffeS/v27UlISOCZZ56hurrauj0oKIilS5cy Y8YMYmJiiIuLY+7cuQDccccdADz22GM88MAD1v0tXe728v7www/p1asXUVFRxMbGMmPGDJtPQ/aO b2hIRk2WC/GXDTtrXNDm300mE/n5eXz15eesWLGMh8ZNsO6TtuAbZs/+D/eOvA+dTsf48Q/Su/fN 7Ni5l5/XbWLHjt+ZM+cjZFnm8OFDTJ78CM89/1dW/Liardt2WQqALMt2j1++wlyfDz74L198Mc/u /nWV0bLuyy8+44W/zuSrufP5ccUyJk54iGeeeY7vFy3j1183s2XzRps0uOL3N978J1FRMaz9eQOj 7hvN22+9Yd23Xdv2LEhbTPrB43z51TzS0r7ljz92OVz/CQ+PpW3b9uzZe4glS1aw4sdlvP/+O83e 2IlFLGIRi1jEUtdSX+xgWU6eyq4zNTcohgAAIABJREFU9jh5qvaQR0e4Kxi2p75hEq7GZ/aOb6xG DZM4ePAgqampLF68mP79+wPmylpUVFQwcuRIJk2axA8//EBJSQlDhgzh3Xff5cUXX7TuN2vWLB5/ /HG2b9/Ohx9+yGuvvcYjjzzChg0bCAoK4ssvv+Suu+5yKm+Ajh07snLlSiIjI9m+fTvDhg1jzJgx 3HzzzQ4dv2TJEpKTkx06F5Js/kpj2NBbWb12q3X9q/+Yxav/mAWAWq2mffsEXnnlnzw49iHrG/f4 E/9Hr5t6A/Dz2tXk5eWR1CmZXbt2ApCQ0IHNmzby1FPTWbz4O+Li4+jT51abN96S/5bNGxs8vrH7 X1lGS76TJj1Bjx69rH98DzyYyk29bwbA19eXkpKSOssIMHHCo0yaPAWA7t17Mu/rr6zb+va7HYDK ykri4loBcPHiRSRJslv/337bQl5eHlOenIpKpSIqOpoRI+7lh6WLmT79WYfeS0EQBEG4miyxg3U2 CWoPk8g4kUW7trE2r2vu485hEk059NDV+Kyh413RqGB4wYIFtGrVylrYmtavX09ubi7dunVjx44d ACQlJbF+/XqbYHjKlClMm2a+u7F37958+umnLucNMGjQIMB8F2KbNm0Ac1Dl6PEDBw60Ww4Lyyey /635zeaT2d9mziI1dTwKhQKNRmMzlsayX0hwsPX3i4Xm8i1dsggu7atQKul+6eazc9nZhIWG1f70 dyl/e8c3dv8ry2jh7+9vs87fP8D6WqFQWIeI1MwTIC4u3mbfK8/Hd98tYOmSxURFRxMYEGhzrL36 5+XlmssbEmrdJzQ0jLy8PIc/MQuCIAjC1WSJHWr2DNd0PCOT9u3iOJ6RWed2Z3qG7XGkZ/iFF17g hRdesFl34sQJQkJCGjzO1fisoeNd0ahgOCsri4iIiHq3FxQUAOaKWQIepVJJ7969bfazVMSy3R15 A8ydO5e0tDRiY2MJDAx0+nhnWC7clLtuZ+Wqzdb1arUarVZrs1+tY69YHxUVA8DT058lPr5VrTx8 ff3IzLr8R1BYWGiThr3ja+bp7P71lfvSAbbHyPWnYXPsFX/8f/yxi5dnzeTnnzcSd6k8aWnfWPe3 V/+wUPN4pIKCfMLDze9vXm4u4eF1BNCCIAiCcA2wxA6Xg+H6A9tjx8/Uu82ZMcP2OBIMv/XWW0ye PNmhPK/kanzW0PGuaFQw7O/v///Zu/P4mK7+D+CfRJJaQsSWRHZbqER5mlRILfEIpdRWaq3SqCjV 1FJrLdXSKh5Ka4utdrVVlx8eRS0VuzYSBI8KEdmEbEKW8/sjnelMMsudmSQzyf28X6/7Yu4995xz v3PmzDd37tzBnTt3lI8Vya+Cp6cnAGD69Olo1KiRCd0zvO3IyEhMmDABFy5cUCbb69evl7y/oYQo HFw//HhMbZAJof8boeLv63MAoHXrQDRt2gwzZkzB558vhLu7O7Kzs3Hnzv/g6+uH9h06Yv/+PTh/ /hwaNGiIiRPHq9Whb38AqFq1KpKSEpGfny+pfNE+altXUORYhVDfrlpe9f+KF29BQQFS/34e4h88 QDX76jh8+P8AAH/9dQe5ubl6j79N27aoW7ceVq38BlOnzcSDBw+wf/9e9O//Fu82QUREFkmRO6ie GS6N+wwrlFQybAxT8zN9+5vCqC/QdenSBdeuXUNkZCRSU1OL/XXQvn17+Pr64sMPP8SdO3cghEBm ZiYuX74suY1q1app/IhbX9uK4MXHxyMlJUX5pbz//e9/yMvL07s/ABw/fhzJycmS+qk4M9y3d2ed F8FrutBdqJSztrZGRMQmuLm64a0BvdHypWZ4rWsn7N+3B0IIdOnyGoYPH4lRoe+gb58eGDRoqFod +vYXQiBszDh8+cV8rFy5QlL5on3UtO7vgy1y7NBYvti+KrFq174junfvgfdGvYM+vV9HdnY2QkNH 4z9LvkJk5O96j/+FFypjzdoNuHY9Bq8EtMSgQf3Qs2cvhI0ZJ/mLDFy4cOHChUtZLorcweT7DBtw zXBZfIFOE1PzM337m8KoM8O9evXC+++/j379+sHR0RFffPEFjh8//k+lNjbYu3cvZs+ejc6dOyMr KwsODg7o1asXWrVqJamNSZMmYcaMGUhJScHkyZMltx0SEoK+ffuif//+qFWrFsaOHYvw8HDMmzcP vr6+evcHgD59+mDLli3FvryniRCFf8V9v+eQ8i+uq9E3Aej+C0xTmZqOjvjs8y+LlVWUmfzxNEz+ eJrWOvTtP3LkKIwcOUq5Tl95TX0suq7o4zORl7RuL1q2c0hXXI2+iYKCAtjY2GDhV/8p1pfwjyYp /6/v+Bs3boLvvtuu9XiIiIgsiSJ3EKL0zwzfvXvX4HpLkqn5mb79g4ODje6blVfX8aLLsEm4mfQc zzNS8NN4H9OPWCbWrd+E/gPeQvqTDAx663Vs3yntdmxEREREitwhKysTp06dwIABb+HJkwyD68nM ysTpUyfw7sjhGrefO38BUVHRkuvz82teIj/HnJ+fjzp16mDr1q3o3r27yfWVlB5f34Bd9TrIuH8V KdFHpZ0ZLnpri7S0tFLpXHmk+Ihi246fJP1lRkRERARAmTv8c2ZY+vW/qvRdJvFKgH+JJLeGSEpK wsOHDwEATZs2LdO2DSUpGWbyq53iI43hw/pg0+Z95u4OERERlROK3KEsLpMoa/3798eDBw8wY8YM NGjQwNzd0clif465vFD8Rbfxu7145+2+EELwX/7Lf/kv/+W//Jf/6v1343d7IYTqmWHjv4xnaX77 7TfcvHkTkyZN0l/YzHjNsAnWrd+EPn3fxJPHT8zdFSIiIiqnsrOzEBn5O/r2fROPjcgpsrIycfbs Ga3XDJM6o64ZJs38/Jpj397daN26jbm7QkREROVcfHy8UfudPXsGfn7NS7g38sFk2ASKi9HPnj1j 5p4QERFReWdsPlFSd3+QKybDJjLHNzSJiIiIqGTwC3REREREJFtMhomIiIhItpgMExEREZFsMRkm IiIiItliMkxEREREssW7SRARERGpOHf+AqKios3dDTKBIbebk5wMy3FgSAmkHONCRERkKku9N67i fX1U6Hvm7gqZYG3EGgCQNMYkJcOKgRE2uvwNjFWr1xjd71WrdQdSEZfA1pb3YiYiIrJkkWcvAJCW rJSlqKhohL47CpnZ2ebuCpmgd59+2L9vT8klw1FR0Xhv1ChkZT83uXNl6Ul64e975xcUICcnz+D9 e/Xuix/279UaSEUiHBQUZFI/iYiI5CYoKAiLlyzTmazcunULcXFxJdquh4cHGjVqpLOMEAJCiBJt l8qWIc+f5MskyuPAUPTX2L6Xt+MlIiKqKBSJcJcuXUq03sOHDwOAzoS4POY8pK7UkuGCggKjOmQu qsmwMX0X5ex4iYiIKoq4uDiEhIQgL8/wT3Z16dixI44fP85kuILjmeG/KZJZY/teUM6Ol4iISE4S ExMllcvOzoa3t7fkestjzkPqeGb4bwXKM8Mw7swwXwhERERmpe29OCsrCxs2bJBUxzvvvKP2abHe NiWWKw0x0dFw93BH9eo1zNJ+RVFmZ4Y93J3UHltZWaFaNXu0aNECn3/+JRo2aiy5I6XB5GuGy1ny T0REVJHoSoRXrFiBt99+GwCQn58PAKhUqZLa/6tUqYLVq1cb1a4xeUNiYiK+mD8PJ0+eQFraI9ja 2sLZxQXBwf/G7DnzJNXRvVtnrF6zHl26vmZw+1J5e9Yv9TbMrVSS4QItZ4Znzf4Ub789AoBAdvZT XIuJxsSJHyL8ow/www+/SO5IaTD1mmFeJkFERGReRZOarKwsfPPNN+jWrRsePHigvKPT6dOnYWtr i9zcXLV1ijoMOjNsZDI8buxoVLKuhF2798HV1Q2ZmRm4cf06bt6MNag+gdK9TGPzlh1o2qxZxf4E vCyvGa5kXQmVKlUCAFSvXh2vtA5Er159sGr1t2YPsqnXDJu7/0RERPQPRSLs7++P5ORkPHv2TLkt KCgIe/fuRd++fZXrpF5TXJSxecPlS5fw6Wfz4eVVeH2yo2MtBLZpi8A2bQ2rr5SvWW4b9OrfzVTc PMeQY7M2pNKCggK1BQAKREGx9Q8SHqBOnTooKCjA6tXfolPwq2j+YiP4+fpg+vSPkZeXpyzr7VUf q1auQPt2gVgXsUbSPlKXomeGVdvUtqjtz8skiIiIzEaRlAohkJmZiRUrVsDT0xPJyclITk5Geno6 vv32W2WZPn36KP//7bffIj09Xa0OqUmupn2kLL5+fli7eiUiz/yuzEOKLrGxN/D20EF4xb8lWge0 xIzpU5CTk1Pk7DUklb0ZG4t3R7wNv+Y+8GnshY4d2iIzM0Pvtobebjh86CCEELh+/RoGD+oP3+ZN 0DqgJb5Y8Blyc3OVbTT0dsOBA/vxycxpaOHbFC1bNMO2rZuV29euWYXOndrDt3kTvOTXFDNnTEV+ fr7a/qtXfYsO7dtg/bq1RsfWmEUqA5Lh4oOjcEPh+vz8fCQnJ2P9+rU48MM+DB3yNoQQaNy4CbZu 3YU/o24gYt0mbN+2BRcvXlCrY+u2zfjiy0Xo3aevpH0MDUTRvt+6fU/jMd66fc/oQBIREVHp+eab b2Bvb4+UlBS1JTs7G3PnzlUrO3fuXGRnZyMlJcX4BoXhy9KlK+Dg4IAhgwfg1bavYPasGbhy6ZJy +9OsbAwfNgivtA5E5NlLOHT4OM6djcTqld/8U8/f9JXNSM/A0CEDkF+Qj4OHfkV0zC1ERGzCC3aV dW4r2saI4UPQqFFjXLp0Fd/v/gEHftiP5cv+o9afL+Z/BldXNxw89Cv69u2PRV99odyuyNmiom4g Yt132L5tCy5dvKi2/7Ztm/Hll4vRp08/o+JqzGJIBmfQmWFNieLcuZ+gUUN3NGnsiVeDArBv727M nj0Po8PGQgiB9u07om69esjJyVF+bPDoUapaHaNHj8UrrwTCwaGmpH2kLv/cTaL4tpu31H/R5uat OK37ExERkXnNnj0bmZmZGpfZs2drLVtUaZ4ZdnNzx/e7f8D3u/ejZ89eOH78KN58sxcmTBiPvLw8 nDhxHElJSfD19cOFC+cRG3sDPj5N8dtvx4ucxBN6yx45chgpKSmYNetTuLjUh7W1NRo0aIhKlSrp 3KbaxqnTJ5GUlIQxY8bBxsYGbm7u6NW7D/bu3a3Wn3feGYn33hsDZ2cX/Otlfzx58kS53Zg8z9LO DJt8a7Vp0z7BoMFDYWVlBVtbW1hZWakNpB07tmHvnl1wdXWDQ82aGuuqVauW2mMp+0jts659b8T+ BZ8mXrgR+5fG7bxMgoiIyHxUk5rs7GzMnj272Flg1UR47ty5yseqZQ1Njkz9dPill1rhpZdaYdLk qdi65TvMmzcbr3XthtRHqQCAPbt3AX/nS1bW1vjXy/7q7Qmht+zDhwkAADc3t2J91bVNtY2k5CQA QO3adZTl6tSpi6SkJLX9PD29lI9V8zwA2LFjK/bs/h6ubm6o6VBTWbfq/rVr1SrzT9tLLRnWVLGN jQ3s7Ow0Nn7x4gXMnjUdhw4fg6enFwBg+7YtxepSfSx1H0l9lvAFuus37mjdxsskiIiILIe2hBiA cp1qQqyJIWeGTWVlZYX+AwZi3rzZSE5JgZubOwDgw/CJyrOomvolALi66i7r7OQMALhz5w4aNlT/ NT1d21TbqFunHgAgJSUZ9eoV3i43KTER9erVLdYf5WOVE40XL57HrE+m4/DhY/D8u4/btm0udp/m oo/LgiHtSb5MQnFrNSlfoFMsqamF1+o8iI9HSkoKtm/bAgC4+9cd5ObmKusQKnVL2cfUL9BJXpgM ExERmVXRj76zsrIwa9Ys5eM5c+Zgzpw5amU0rTMkwTX2Y/nRo0fixwP7ce9eHHJycpCW9ghrVn8L Ozs7tG0bhMDANmjatBlmzpiCu3cLP5XOzMxEVNSfxS6T0Fc2uFNn1KlTF7NnTcft27eQkZGBCxfO Iz09Xec21Tbatg1C3br1sGrVN8jNzcXdu39h//696N2nX7H+KBeVGKWmFp69fpDwAKmpqSo521/I y8vTvL8QmDVrOnbt2iH5sVGXSJRGMqx1QGn4Yp1iadeuA7p374H33huBvn1eR3Z2Nt4NHY3//GcR IiN/1xgkKfsYFAwTBjUvkyAiIjIfbcmr4gxxSdZZtIwxi7ubBzZv3oR+fd/ASy2aomOHIJw7dxbr N2yBm5s7rK2tEbHuO7i6umNA/z54qUVTdO0SjH1FrtGFEHrLVqtWDRs3bkElGxv07tUdQW39Mf/z ucjJeapzm2obL1SujLURG3H9WgwC/F/CoIH90LNnL4wZ80Gx/mjKrdq374jur/fEqNB30LtXd2Q/ zUboqDAsWbJQLc8ruv/OHdvw+++nJD82OiGWyMqr63jRZdgk3Ex6jucZKfhpvE+xQuvWb0L/AW8h /UmG5IotQVZ2Fk6d/A0DBgzEkyfphu+flYlTp07g3ZHDNW5ft34TAlv7K2/uTURERNItXrJM63vs 0aNHERwcjNzcXK37V6tWTVI7SUlJyrIFBQX4/fff0alTJ41lC3OegcjKzJJUN1mmnJynOHr0iMbx 1ePrG7CrXgcZ968iJfqo6dcMWzJTf3SDl0kQERFZrqwsaQmratJsyJnhstb8xX+u742OuVXm7Vck hjx/Jt9NwpKpnso3pu+8TIKIiEh+zJUMX42+qdYHMl6pJcPl7Ykpes2wsfsTERFR2fLw8MCxY8fQ pk2bEq33zJkz8PDw0FmmPOY8pK6UkuHylxwyGSYiIiqfGjUqvGTgzJkzJVqvh4eHsm5tmAyXfyWe DPv5Nce+vbvRunXJ/nVWVuLj443a7+zZM/Dza651u59fc0SevcAv0BERERlo8ZJlOt9jgcKEWF/i SmQqScnwKwH+AAqTw/LI2H77+TVXHrsmim2Llywzqn4iIiK50vceay6KE4Dt23c0d1fIBCdOHNf7 x5aC5MskXgnwt8hBa26MCxERUcWheE8/ceK4eTtCJjHkjy3JyTARERGRHPBEl7xI/gU6IiIiIqKK hskwEREREckWk2EiIiIiki0mw0REREQkW0yGiYiIiEi2eDcJE507fwFRUdHm7gYRERER/Y23Visj ikQ4sDVvv0JERERkKSLPXgAASQkxk2ETKBJh/hwzERERkeUICgrC4iXLJCXDvGaYiIiIiGSLyTAR ERERyRaTYSIiIiKSLSbDRERERCRbBifDBw8ehKOjI5YuXVoa/SEiIiIiKjMGJ8Pbtm2DlZUVtm3b BiFEafRJo59//hn3798vs/aIiIiIqOIzKBlOTU3FwYMHMWXKFNy8eROXLl0qrX4VM3ToUPzxxx9l 1h4RERERVXwGJcO7d+9GgwYNMGnSJLi4uGD79u3Kbfn5+ZgxYwaaNGmC+vXro0GDBti1a5dyu6Oj I37++Wedj/fs2YMJEybA3d0dnp6e2LBhAwCgU6dOAIB3330Xb731FgAgJiYGPXv2hKurK3x8fDB7 9mzk5uZqrZ+IiIiIqCiDkuFt27Zh6NChqFSpEgYPHow9e/bg2bNnAIDff/8d3377LX766Sc8ePAA f/75J4KDgw3qzCeffAIPDw9ERkZi0KBB+PTTTwEAR48eBQCsW7cOO3fuRHZ2Nvr27QsfHx/cuXMH hw4dwvfff4+FCxcq69q9ezcCAgIMap+IiIiI5EVyMnz16lXExMRgwIABAIAhQ4bg8ePHOHjwIACg du3aAIBNmzbh+vXrqFatGurWrWtQZ8LCwhAeHg5XV1e0bt0ajx8/1lju+PHjSExMxMSJE2FnZwcv Ly+89dZbameq//3vf6NevXoGtU9ERERE8iI5Gd62bRvy8vLg4+MDR0dH/Otf/wIAZQL64osvYvv2 7fjjjz/w6quvok2bNjh79qxBnWnYsOE/HbPW3rXExEQAUEt269Wrp1xPRERERCSFpGT4+fPn2LVr F3bv3o20tDTlsmzZMhw5cgRJSUkAgNdeew0//fQTYmNj4evri3feeUetHsXdJ0y9K4STkxMAIDk5 Wbnu4cOHyvVERERERFJISob/+9//QgiB9u3bq63v2bMnrK2tsXv3bty6dQtnz55Fbm4uHBwc4O7u rlbW3t4ely9fxp9//omxY8ca3NFq1aohKSkJQggEBwfDyckJS5YsQW5uLu7cuYMdO3Zg0KBByvLH jx9XS5aJiIiIiIqSlAxv27YNvXr1gq2trdp6R0dHdO7cGdu3b0dGRgYmT54MLy8veHh44MSJE1i/ fr2ybHh4OFasWIHQ0FDMmjXL4I5OmjQJM2bMwKJFi1ClShXs2bMHUVFR8PLyQteuXTFgwABMnjxZ Wb5Pnz44d+6cwe0QERERkXxYeXUdL7oMm4SbSc/xPCMFP433MXefyo116zchsLU/goKCzN0VIiIi IlKxeMkyvDtyeLH1Pb6+AbvqdZBx/ypSoo/Cpiw64+joqHN7WlpaWXSDiIiIiEhNmSTDTHaJiIiI yBIZ9KMbREREREQVCZNhIiIiIpItJsMm8PNrjsizF8zdDSIiIiJSsXjJMvj5NZdUtkyuGa6oXgnw B1AYcCIiIiKyDH5+zZV5mj5Mhk30SoC/5GATERERkWXhZRJEREREJFtMhomIiIhItpgMExEREZFs MRkmIiIiItliMkxEREREsiX5bhLnzl9AVFR0afaFiIiIiMhkJX5rNUUiHNiatxAjIiIiIsum+FE0 KQmxpGRYkQgHBQWZ1jMiIiIiolIWFBSExUuWSUqGec0wEREREckWk2EiIiIiki0mw0REREQkW0yG iYiIiEi2mAwTERERkWwxGSYiIiIi2WIyTERERESyxWSYiIiIiGSLyTARERERyRaTYSIiIiKSLSbD RERERCRbTIaJiIiISLaYDBMRERGRbDEZJiIiIiLZYjJMRERERLLFZJiIiIiIZIvJMBERERHJFpNh IiIiIpItJsNEREREJFtMhomIiIhItpgMExEREZFsMRkmIiIiItliMkxEREREssVkmIiIiIhki8kw EREREckWk2EiIiIiki0mw0REREQkW0yGiYiIiEi2mAwTERERkWwxGSYiIiIi2WIyTERERESyxWSY iIiIiGSLyTARERERyRaTYSIiIiKSLSbDRERERCRbTIaJiIiISLaYDBMRERGRbDEZJiIiIiLZYjJM RERERLLFZJiIiIiIZIvJMBERERHJFpNhIiIiIpItJsNEREREJFtMhomIiIhItpgMExEREZFsMRkm IiIiItliMkxEREREssVkmIiIiIhki8kwEREREckWk2EiIiIiki0mw0REREQkW0yGiYiIiEi2mAwT ERERkWwxGSYiIiIi2WIyTERERESyxWSYiIiIiGSLyTARERERyRaTYSIiIiKSLSbDRERERCRbTIaJ iIiISLaYDBMRERGRbDEZJiIiIiLZYjJMRERERLLFZJiIiIiIZIvJMBERERHJFpNhIiIiIpItJsNE REREJFtMhomIiIhItpgMExEREZFsMRkmIiIiItliMkxEREREssVkmIiIiIhki8kwEREREckWk2Ei IiIiki0mw0REREQkW0yGiYiIiEi2mAwTERERkWwxGSYiIiIi2WIyTERERESyxWSYiIiIiGSLyTAR ERERyRaTYSIiIiKSLSbDRERERCRbTIaJiIiISLaYDBMRERGRbDEZJiIiIiLZYjJMRERERLLFZJiI iIiIZIvJMBERERHJFpNhIiIiIpItJsNEREREJFtMhomIiIhItpgMExEREZFsMRkmIiIiItliMkxE REREssVkmIiIiIhki8kwEREREckWk2EiIiIiki0mw0REREQkW0yGiYiIiEi2mAwTERERkWwxGSYi IiIi2WIyTERERESyxWSYiIiIiGSLyTARERERyRaTYSIiIiKSLSbDRERERCRbTIaJiIiISLaYDBMR ERGRbDEZJiIiIiLZYjJMRERERLLFZJiIiIiIZIvJMBERERHJFpNhIiIiIpItJsNEREREJFtMhomI iIhItpgMExEREZFsMRkmIiIiItliMkxEREREssVkmIiIiIhki8kwEREREckWk2EiIiIiki0mw0RE REQkW0yGiYiIiEi2mAwTERERkWwxGSYiIiIi2WIyTERERESyxWSYiIiIiGSLyTARERERyRaTYSIi IiKSLSbDRERERCRbTIaJiIiISLaYDBMRERGRbDEZJiIiIiLZYjJMRERERLLFZJiIiIiIZIvJMBER ERHJFpNhIiIiIpItJsNEREREJFtMhomIiIhItpgMExEREZFsMRkmIiIiItliMkxEREREssVkmIiI iIhki8kwEREREckWk2EiIiIiki0mw0REREQkW0yGiYiIiEi2mAwTERERkWwxGSYiIiIi2WIyTERE RESyxWSYiIiIiGSLyTARERERyRaTYSIiIiKSLSbDRERERCRbTIaJiIiISLaYDBMRERGRbDEZJiIi IiLZYjJMRERERLLFZJiIiIiIZIvJMBERERHJFpNhIiIiIpItJsNEREREJFtMhomIiIhItiQlw35+ zRF59kJp94WIiIiIyGSLlyyDn19zSWVtpBR6JcBfWTERERERkSXz82uuzF/1kZQMA4UJsdRKiYiI iIjKA14zTERERESyxWSYSkRMTAxiYmK4juu4juu4juvKbB1RSWAyTCUmICCA67iO67iO67iuTNcR mcrKq+t40WXYJNxMeo7nGSn4abyPuftERERERFQqenx9A3bV6yDj/lWkRB/lmWEiIiIiki/Jd5M4 c+YMrly5Upp9ISIiIiIyWcuWLdGmTRtJZSUlw4pEODAw0KSOERERERGVtsjISACQlBBLSoYViXBu Xj6ioqJN6x0RCm+GLZexJKdjNRfGmKTgOJGOsTIN42caxQ9mnDt/weA4KvZt27YtlixZUnLJsEJU VDRGhb5nUKeINFkbsUY2Y0nkhrWJAAAgAElEQVROx2oujDFJwXEiHWNlGsbPNGsj1gAozDuHDx9p 0L6bNq0HAHRo307yPgYlwwBQUFCA7Kc5hu5GpJT9NBuAPMaSnI7VXBhjkoLjRDrGyjSMn2kU8YuK ikbY6PeQmfUMBQUFyM/PV/tX27rWrdvg7NkzpZsMCyEghDB0NyIlxfiRw1iS07GaC2NMUnCcSMdY mYbxM405YsZkmMqcnCYKOR2ruTDGJAXHiXSMlWkYP9MwGSZZkNNEIadjNRfGmKTgOJGOsTIN42ea 8pEMwzwdLerZs2ewsbFBpUqVzN0VMpByooBljKXSZI5jLS+vjfv37+HZs2do2LCRSfXIaTyR8ThO pGOsTMP4mUZKzBo1dEfszbsl1qbBv0Cn+EtHsXh6OGPo0LeQn5+vtv6PP67A08O5WPmSWpo09sSR /x4utfq5lO6iaSz169sTnh7OWpcDP+wzS19v376FDu3b4I2eryE6+irGjQvD2bORJh2rYsnMzMSS xQsR0rkDGjV0RwNvV/i/3AID3+qH69evGdXfoq8NTw9nHDr4fxBCYO/e3WjV8kW08PNBVlaW2rbS WjS1cePGdfTs+RoSEh6YfTyVRQy4WMZS1q/F0lhMGa+G7GtqrHTNO+aOoTnHmrb5aMCAPiXyHFeU RZcG3q4AgCaNPQ1NYbUqkcskTp74Dd9t2oDh74xULagsX1oE9AeNLFCRiUJhx449yv9/991GfPrp LNy6FadcZ2VtbZbn+8rlS/h4ynQ0bdoMc2bPRI0aNfCvVv+S1hctxwoAWVmZeLNfL2RkZOCTWXMR GNgWNjaV8L/bt3HmzGnlH5jGUH1tbNmyE02bNYMQAp9/NhdhYWPx9vCRsLW1VdtWWoq2kZubi88/ m4tvv12D1q3bmN62ieOpLGJAFsBMr8WSZsp4lbxvCcRK17xjKbEsNTriBwCzZn2Kt99+R32llZXG OVuWdBy3p4ez2uNmTRsgOuaWyU2WSDLs49MUCxbMQ5u2QWjcuElhOZRBMizhLwiyPEX/alawVvlY 37qSdbF1qvuWpd59+in/v3HTVoP6ou1YAWDlyhW4desmDh0+Bm/vBsr1vn4t4OvXQnIb2tpV7Ns2 6FXlupSUZNR3dYOdnV2xbaWlaBs2NjbYsHFLibVr6ngqixiQ+ZnrtVjSTBmvUvctiVjpmncsJZal RVf8gML5qOhcpLqf3Ockbcft7lZP4/rmLzbCn1E3TGrT5MskAGD6jFlwdKyFj8LH4dmzZ39vUy9/ /fo1DBr0JnybN8YrAS2xYMFnyM3NVW5v4O2KHTu2oV+/N9C4kSfCPxyLR49SMaB/HzRu5IHhbw/G 06dP1dpNTkrCWwP6okljTwwbOhCpqSlq9a1e9Q06tG+D9evWQgiB2NgbGDZ0IAL8X8IrAS0xffrH yMnJKfPT/1x0fwSnr8yaNSvx707t4Nu8MVr4NcWMGVPULtMxdCxJqe/AgX2YOXMq/Hx98FKLpti2 dbPksa3tOP7vl5/x6qvt4eXlrTMO+uo/duxX9O7VHT17voa2bfwVLzy1/h8+9H/4V6vmAIAJH32A KR9PVNsmhMDN2BsYOWIYfJs3QZPGnujQoQ0yMzMkxUjXvqptSJkHdMW6NMaTav8aeLti65bvtM4r +vrPxbKX0n4tGjr36Btvmt7Hio5XQ9tT3bdo3SUZK33zTtG2pczDuvpraYu2+EmZq/Q9TyX9HmeJ iyb37ifhbtxD/O9OPG7dvofYm3dx7fr/SuTMsMHJMIBiHa5RwwGLFi/FtWsx+M+Sr4o96dlZWXhn +GA0atQYFy9dxfe79+PAD/vw9bIlamXXrVuNjz+ejnXrv8OBA/sx4p2hCP9oInbu3IuTJ3/DiRPH 1covX/4fDBs2HPt/+AU3b97AgvmfqW3fum0zvvhyEXr36YvsrCy8PWwgXmkdiMizl3Do8DGcOxuJ VStXmP1Jl92iZSypjSuhfXvjxk2wdesu/Bl1AxHrNmH7ti24ePGC0WNJSn0L5n8GV1c3HDz0K/r2 7Y+vvlogbWzrONa4uLto2KiRzljpqz8mJhrvjRqJiZOm4IcffsGp0+cK24L6WQkB4MLFKADAkiVf Y8EXX6ltS09Px5AhA5BfkI+Dh35FdMwtRERsgp3dC3pjpG9fRRtS5wFtsS6t8aQaL8W8MnDgYOz6 fj9iY68r5xUp/ediwUspvxYV48eY9zFN402xXfV9TNN4NbQ91X2L1l1SsVJtS9u8U7RtKfOw1v5a 2qIjforASImdrjFQku9xFreg7JXIZRJCCLRu3QYjR47C2rWr0KFjMKpUqarcdur0SSQlJWHMmHGw sbGBm5s7evXug717dyP8o0nKekaFhsHfP0BZ/1sDB6N168LflLa3t0f6kydqbY8ePRbduvcAALzR qy++37W92PZXXgkEABw+9H9ISkqCr68fLlw4D6Dw8o7ffjuOD8Z/ZGgYyATKF7uGsaQso+Mym/bt OwIAcnJy4OXlDQB49ChVrawhY0lKfe+8MxKho8IAAP962R+bNq2XNLZ1HasQgCjQHgMAeuvfvXsn PL080bbtq2r1FG1P2ySr2HbkyGGkpKRg1qxP4eJSHwDQoEFD5XZdMdK3r+JfqfOAtlhrY+p4Krrv 6LCxeKNXHwBAn75vYtfOHQb1nyxTab8WFQx+H9My3pTbVd7HNB2Doe2pjXUNdZdErDS1VXTeKdq2 lHlYW38tjb45ae7cTzB37idq686dvwJHx1pqdeh6nkr6Pc6SmKNfJXOf4b/XhX80CSdPncDkSeGY v+ArZfmkpEQAQO3adZT71qlTF0lJSWp11ahRo8hjB+VjKyurYl+Yc3FxUT6uV68enjx5goKCAlhZ WRW2V6uWcnvqo1QAwJ7du4C/t1tZW+NfL/tb7ICoqKQkL6pn8orasWMr9uz+Hq5ubqjpUFNR0Oix JKU+T08vtf0VfdM3tnUdq7u7u/Kb19roqz/+/n3UrVNX62tS0+NifRECDx8mAADc3NwMjrm+fRVl k5KTdB6LgrZYa2PqeFI9FgBwcXZR619GRoZB8xhZptJ+LSoY/D6mZbwpqL6PqRyMcp2h7anuq7Hu EoiVpraK1lW0bSnzsLb+Whp9c9KsWZ9i6LDhWvf7+4HO56mk3+MsSblNhhVBt7Ozw+LFS9G3T0/M /3yesnzdOoUXPaekJKNePScAQFJiIurVU38TL/qXY9EnSwhoLZ+akgJnZxdlm0W3u7q6AwA+DJ+o /MtI9Zio7EhJXrSdybt48TxmfTIdhw8fg+ffz+O2bZuLn+0suq+WsWRUfSr91ze2dR1rSJfXELF2 Fa5G/Ynmvn4a46Cvfnv76rgbd1dZ96NHjzQef9H+F93m7FT4Dd07d+4Uu++vvhjp2le1DaPmAaF5 HKjVbcJ40tSm6v8THjyAq6urQfMYWabSfi0q20GRcWbA+5jqeNNaH7SPV0Pb01Q3YHqsNPZdw7yj eGz0vG6h9M1Jxf5A0VQHdD9PJf0eZ0lU+3X5SlSZtFkiX6BTBF0IgcaNfTBh4seIjb2uLN+2bRDq 1q2HVau+QW5uLu7e/Qv79+9F7z79NCYMRQdA0RdT0fJPnjzBL7/8hDffHKC1vsDANmjatBlmzpiC u3f/QkFBATIzMxEV9WexY+JSugs0PD/Fy2geb6mphWf4HyQ8QGpqKrZvK7wrwd2//kJeXp7BY8mY +hQvUyH0j21dxzpqVBi8vRtgxIhh2LF9K+7di0NqaiouX7qIL7/8HOfORuqtv0PHYNyMvYELF87j 0aNHmDjhA83HryMWQggEd+qMOnXqYvas6bh9+xYyMjJw4cJ5pKen642Rrn1V2zBmHlCNdWmMJ03x eZqdDSEK7y/9ww978Wb/tyT3n4vlLrrGSUm8FouOJeVjPe9j2sabpvqKrjPlfVPXa8bUWGlsS0fb Rs3DFrzoip8iGDr31/M8GfK8S4mtpS2K+Pn5NcfZs2eMWvz8msMQJZQMq697++0RCAxso9z2QuXK WBuxEdevxSDA/yUMGtgPPXv2wpgxH2h88rQ/2eqPZ86Yijf7vYEhg/vj9dd7ImzMOK31WVtbI2Ld d3B1dceA/n3wUoum6NolGPv27jb7Ey/HRdO4UVuguUz79h3R/fWeGBX6Dnr36o7sp9kIHRWGJUsW IjLyd4PHkjH1qdYpdWxrOsbq1atjx449eLP/W1i3bg26dglGu1dfwaRJ4cjKzIKHp6fe+rt0eQ3D 3xmJ0HeHo0+f1zFo0FCNxw8dsYAQqFatGjZu3IJKNjbo3as7gtr6Y/7nc5GT81RvjHTtq9qGMfOA pLFiwnjSFJ9Jk8LxUoumGPHOUAwePAwjR46S/FxzseylNF+LRceSpvY0vY9pG2+a6tM0Xg1tT9u+ JRkrTW1pOwYhjJ+HLXnRNd+oPifayuh6ngx53qXE1hKXsmbl1XW86DJsEm4mPcfzjBT8NN6nWKGV K1ciMDAQly7/if4DBiIrM6vMO0oVR07OUxw9ekQWY0lOx2ouJRnjF5s1xPIVq/Dvf4eUUO/IUlji a9FSx5slxqo8YfxMo4gfAAwfPlJPac02bVqPcWPDsGTJEowZM6bY9h5f34Bd9TrIuH8VKdFHS+gL dEQGKPqXbEUmp2M1l5KOMZ+rislSX4uW1h/AcmNVXjB+plGNWZXKNsjMeoaCggLk5+er/attXVZW psFtMhmmMieniUJOx2ouJRnjuXM/h4+PjH8GtQKzxNeipY43S4xVecL4mcYcMWMyTGVOThOFnI7V XEoyxn379VerkyoOS3wtWup4s8RYlSeMn2k0xeyPPy8DAF5s5gsAuHmr8OeXvTwLfxI8/sE9AIBT PRej2mQyTGVOThOFnI7VXBhjkoLjRDrGyjSMn2m0xax9uyCkpDxRexwXl6D2+MaN/xnVpsHJcGpK ilENERUlp7Ekp2M1F8aYpOA4kY6xMg3jV3JeatEKjx5lKB83buSD+Pgk5WPX+u64efMvo+s3KBn2 82uOEyeOG90YkYKcxpKcjtVcGGOSguNEOsbKNIyfafz8miMqKrrM2jMoGe4S0hldQjqXVl9IZuQ0 luR0rObCGJMUHCfSMVamYfxMo5oMl/Y1wwb/6AYRERERUVlq3y7IoMeGYDJMRERERBbLoq4ZJiIi Iv1Onf4dFy9ellz+5Zdb4dWgtqXYo/KBcTMN42ccJsNEFiQnJwe2traoVKmSubtCVOquXLkCb29v ODg4mLsrJe7ixcv4cPxYyeWXff0NkxIwbqaqqPHjNcNUoT18+BBWVlYal4MHD2rcZ9y4cfD09ETV qlXRoEEDbNmyRWcbVlZW2L9/v/JxQkIC3N3dsXz5crUyqkutWrXQvXt3XL16tWQOFNKOtUqVKvjx xx8lHwsVpxpXa2tr1K1bF927d8fPP/9s7q6VS6U55lq1aoVjx46VSt2WQvETsbqW58+fm7ubFodx M01FjB+vGS6H9u/fj7i4OHN3w+LVrl0bly9fVlvWr1+PatWqoXnz5hr3cXFxwenTp5GZmYkJEybg 7bffRkxMjKT2nj59il69eqFnz54YN26c2ralS5fi+fPnyMjIwKFDh3Dnzh0MHjzY5GNUMOZYi/rv f/+Ltm0L/4rnGNNO8Vw+fvwYhw8fhouLC3r06IEFCxaYu2ulojTHguqYI8NJSUry8/PN3U2Lw7iZ pqLFr7SvGWYyXEr69OmDS5cumbsbFs/W1hYtW7ZULi1atMCqVaswf/58uLu7a9xnxowZcHNzg7W1 NUJDQyGEwKlTp/S2JYTAiBEj4ODggGXLlsHKykpte6VKlWBrawt7e3sEBARgyJAhkpNsKYw51qI6 d+6MevXqAeAY00XxXNaoUQOtWrVCREQEhg0bhlmzZuHevXvm7l6JK82xoDrmyHBSkpKCggJzd9Pi MG6mYfwMY1QyvGjRIvj4+MDe3h4ODg4ICwtTC6qVlRUiIiLQtm1b2NraYsiQIUhJSUG7du1gY2OD rl274unTpwCA/Px8TJgwAU5OTqhWrRpq166t9rG3lZUVtm/fjjFjxqBGjRqoWbMmVq9erbN/VlZW WLhwIRo0aIClS5cCAKKjoxESEgInJyc4Oztj9OjRyMnJMarPABAVFYXg4GDY29vD2dkZH3/8MXJz cwEAAQEBAICBAweiR48ektqnQmvXrkVeXh7GjpV2zdP9+/cBAHXr1tVbdu7cubhy5Qp27doFW1tb SXU3btxYUj+Moe1YHz58iPbt28POzg4hISFITk5WblN8ZK1pjJF2VlZWCA8PR15envKSFF2vYQCI iYnB66+/jurVq8POzg4NGzZERkaGsj7VSwc0PTZkPpEyP2mbBzWNBX3HpkrKHKw4NkOPy8rKCqtW rdI6nlVV1Dmyop2hKyuMm2kYPwN5dR0v3tsSJ4KX3BJBcyNFWlpasWX+/Pni6NGjQuGXX34R8fHx QgghTp48KQCIkydPKrcDEM2aNRMnTpwQhw8fFgCEv7+/OHr0qDhz5owAIPbt2yeEEOLo0aMCgIiJ iRFCCJGeni4SExPV6nJ1dRVffPGFiIuLE+PHjxeOjo5CFwDC29tbHDt2TKSkpIjMzEzh4uIi5s2b JwoKCsSjR4+Ej4+PmD17tlF9VtT3/vvvi2fPnonbt28LV1dXMXPmTLX6ipbX1T4JkZSUJBwdHcWp U6cklS8oKBDDhg0Tvr6+4tmzZ1rLARCDBg0SL7zwgoiNjdVaZvny5aKgoECkpqaKNWvWiLp164pf f/3VqGPRR9uxAhAuLi5i586d4o8//hAuLi5i+PDhatsV40r1//QPxXNZ1NOnTwUAMWvWLL2v4ceP HwsnJyfRtWtXcffuXZGXlyeuXbsmnj9/rmxDNfaaHhs6n+ibn3TNg4bOT6qkzMGqY07qcSnKu7i4 iM2bN4tz584JZ2dnjeO5Is6RS5etEEIIkZWVpXd59OiRsrzcMW6mqUjxW7R4qcjMzBYPE9PEg4RU ce9+krgb91D87068uHX7noi9eVdcu/4/ER1zS/wZdUNc+eOauHQ5Wpw8dVYsWrxU5OTkiPnz52vM a4PmRorgJbeE/4T9wqvreGHUmeFu3bqhfv36yMnJQZMmTQAAKUV+g3vy5Mlo164dOncu/AWW9957 D8HBwQgMDESNGjXw+PFjAECdOnUAFJ4li46Ohr29fbGP5D788ENMmTIF7u7uCAoKQlpamt4+Tp06 FR07dkTt2rVx6NAhJCQkwN/fH6dPn0Z0dDRatGhR7AtaUvt85MgRJCQkYPr06bCzs0ODBg0wdOhQ bNq0SWNfpLYvdx9//DE6dOiAoCBpF8F/9tlnOHPmDH755RfY2dnpLOvq6goA2Lp1q9Yyc+bMQaNG jdCsWTO8//77mDBhAtq0aSP9AAyg61inTp2KAQMGoEWLFhg6dCgOHDhQKn2QG8VZkMqVK+t9DR84 cACJiYlYvnw5PDw8UKlSJTRt2lTSJwoKUucTqfOD1HnQ0PlJyhxszHEpTJs2DUOHDkVAQACGDx+O n376qVidFXmO5Bk64zBupqko8bt8JQo3b8bi9u1b+OuvO4iLu4v4+PtISHiAxMSHSElJxqNHqXjy 5DEyMtKRlZVpVDtG3Vpt9erV2LBhA7y8vFCrVi2NZRwdHQFAeV2m4rHqOgDw8/PDgQMHsHjxYnz9 9dfw8fHBmjVr1JIE1Y+qra3/yd8jIiIQHh4OoPAawSdPnii3qU7mio/lNmzYoGzb2tq6WCIitc8J CQkAAGdnZ+U6Z2dn5fqipLYvZ5GRkdi4caPk6x4XLFiAPXv24PTp05KuZwwKCkJgYCD69+8PFxcX jB49uliZOXPmKL9U9+DBA0ybNg2+vr44ffq02nNtKn3H6uHhofx//fr1kZaWBiFEsWucyTDXrl0D APj6+iI+Ph6A9tewYru3t7fR7UmdT6TOD9rmwaIMnZ+kzMHGHJeC6vXwzs7OavO0QkWeI6Vcl8lr N4tj3ExTEeLn59ccZ8+eMXpfQxicDJ86dQphYWGIjY1VTs4rV640tBo1PXv2RM+ePZGamooPPvgA AwYMUL4Z6RIaGorQ0FC95RRvaPPmzVOeyTaFi0vhfewSExNRv359AIXJk2J9abdfEU2bNg0dO3ZE q1at9JbdsmULFi1ahKtXrxr0xZ5+/fphyZIleP/99+Hk5ITevXtrLVu/fn2sWLECNWrUwPbt2/HR Rx9JbkcfQ441KSkJbm5uTIRLwIoVK+Dk5ISQkBAcOnQIgPbXsJubGwDg5s2baNasmcb6hBAAYPJd HMw9PwHGz8GGunfvHjw9PYutr8hzpJSEozycoStrjJtpKkL8XgnwBwBERUUbtJ+fX3PlvlIZfJmE 4i/4e/fuITk5GatWrQIA3Lp1C3l5eYZWh9jYWJw+fRq5ubmoWbOm2lmxktKpUye89NJLGDVqFG7f vg0hBDIyMnDhwgWj6gsJCYGLiwsWLFiA3Nxc3L59G5s3b8bw4cOVZezt7fHw4UMIIUq8/Yrmxo0b OH78OIYNG6Zxe1hYGCIiIgAUXo4zduxYDB48GPn5+bh//z7u37+PzExpH42Eh4dj/PjxGDRoEE6f Pq22LT8/H7m5uXj69Cni4+Oxbt06AP8kRiVB37Gqevz4MXbu3Il3331X43bVMUbq8vPzkZeXh+zs bERFRSE0NBTbt2/Hxo0bUblyZb2v4TfeeAPOzs4ICwvD9evXkZ6ejlOnTinPalavXh0XLlzA5cuX MWLECJP6WhLzg+pYkDI/qSrtOTg7OxsAcP36dWzevFnjCQxjYqA6L0h5bC5CCL2LpScl5sC4maYi xO/c+QuIiorG8OEjDVqioqJx7rxh+ZXByXD37t0xcOBAdOvWDS1btkRWVhamTJmC6dOnG3Xz9PT0 dIwbNw6Ojo5wcHDA0aNHsWPHDoPr0cXGxgaHDx+Gt7c3WrdujSpVqqBJkyZar6HTp2rVqjh48CCu XLkCR0dHtG3bFkOGDMEnn3yiLDNz5kxMnDgRn332WYm3X9EcOXIEQOEfGZqsXr1aWebWrVtIT0/H ihUr4O7urlw2btwoub3Fixfj9ddfR48ePRAd/c9fnOHh4bCzs0PVqlXh4eGBhQsXYurUqejXr5/x B1eEvmMFCj/xCAgIQLt27TBo0CDMnDlTYznVMUbqwsPDYWtri2rVqiEkJARZWVk4f/48XnvtNQD6 X8M1atTAr7/+qrwdnpOTE8LDw5V3SpgyZQoWLVqEwYMHm3zv4pKYH1THgpT5SVVpz8FDhgxBlSpV 0LlzZ4wdOxaTJ08uVsaYGKjOC1Iem0NcXBwyMjL0Lpb+cXVZY9xMU1HiFxUVjbDR7ylPVOXk5CA7 OxsZGRl48uQJ0tLSkJKSgqSkJCQkJCA+Ph737t1D69ZtDD6bbOXVdbzoMmwSbiY9x/OMFPw03qdY oZUrVyIwMBDBwcEldIhE0q1duxZXrlzBN998Y+6uEJEBrKyssG/fPp2XJFVUp07/josXL0su//LL rcrFz+KWNsbNNBUpfouXLEPY6PeQmfVM+YU/1X+1rcvKysTZs2cwbmwYlixZgjFjxhSru8fXN2BX vQ4y7l9FSvRR475AR1SW9u3bhy+++MLc3SAikuzVoLYWm2RYMsbNNIyfcZgMk8X78ccfUalSJXN3 g4gMtHbtWrRs2dLc3SAi0ok/x0wWj4kwUfkUGhoKLy8vc3eDiCqYRg3d9RcyAJNhIiIiIioXGngX /ohWk8bFb9NoLCbDRERERGTxPD3UfwCrWdMGJVIvk2EiIiIismjubpp/ZKv5i41MrptfoCMiIiIi i3bvfpLOW6uZgskwERFRCSuJ+70u+1r6vdUt+X6xhmDcTMP4GYfJMJEFycnJga2tLe+gQbJw5coV eHt7w8HBwdxdKXEXL17Gh+PHSi6/7OtviiUVpu5fHjFupmH8jMNrhi1cZmYmZs+eDV9fX7zwwguw sbGBi4sLOnXqhKtXrwIo/JWnFStWaK1D33ZLMnr0aFhZWeks06FDBzg4OKBq1ap4+eWXcerUKZ3l rayssH//fuXjhIQEuLu7Y/ny5WplVJdatWqhe/fuyhiXhIcPHxZrR7EcPHgQAFClShX8+OOPko+F ilONq7W1NerWrYvu3bvj559/NnfXyqXSHHOtWrXCsWPHSqVuS6H4OFfX8vz581Lbv7xi3EzD+BmG yXAp2b9/P+Li4kyqIyMjA0FBQdi0aRPmzZuHhw8fIi0tDT/++CO6detm8jUylmb37t3Yvn273nIT J05EYmIi0tLS4Ovri2HDhklu4+nTp+jVqxd69uyJcePGqW1bunQpnj9/joyMDBw6dAh37tzB4MGD DT4ObWrXro3Lly+rLevXr0e1atXQvHlzSXX897//Rdu2hX+Fl8QYq6gUz+Xjx49x+PBhuLi4oEeP HliwYIG5u1YqSnMsqI45MpyUpELXXG7q/uUV42aaihK/y1eicPNmLG7fvoW//rqDuLi7iI+/j4SE B0hMfIiUlGQ8epSKJ08eIyMjHVlZmUa1w8skSkmfPn2wb98+eHh4GF3Hl19+iWvXruHq1ato0qSJ cr2/vz/8/f1LopsWIy4uDuPHj8dXX32FsLAwnWXfeOMN5f+7deuGXbt2SWpDCIERI0bAwcEBy5Yt K3YGulKlSrC1tYWtrS0CAgIwZMgQzJkzx+Bj0cbW1lbt17gKCgowevRozJ8/H+7u0m4g3rlzZ+X/ S2KMVVSqz2WrVq0QERGB3NxczJo1C0OHDpUc7/KiNMeC6pgjwxUUFJhUxtT9yyvGzTQVIX5+fs1x 9uwZo/c1hFFnhhctWgQfHx/Y29vDwcEBYWFhakGxsrJCREQE2rZtC1tbWwwZMgQpKSlo164dbGxs 0LVrVzx9+hQAkJ+fjwkTJsDJyQnVqlVD7dq1sWXLFrW6tm/fjjFjxqBGjRqoWbMmVq9erbN/VlZW WLhwIRo0aIClS5cCAI0XrJ0AABl4SURBVKKjoxESEgInJyc4Oztj9OjRyMnJMarPABAVFYXg4GDY 29vD2dkZH3/8MXJzcwEAAQEBAICBAweiR48ektrXZPfu3QgJCVFLhCuivLw8DBkyBDNmzJB8hhQA srOzsXHjRowePVpS+blz5+LKlSvYtWsXbG1t9Za/f/8+GjduLLk/hlq7di3y8vIwdqz69VkPHz5E +/btYWdnh5CQECQnJyu3KT6y1jTGSDsrKyuEh4cjLy9PeUmKrtcwAMTExOD1119H9erVYWdnh4YN GyIjI0NZn+qlA5oeGzKfSJmftM2DmsaCvmNTJWUOVhybocdlZWWFVatWaR3PqoyZI8uDinKGrqwx bqZh/Azk1XW8eG9LnAhecksEzY0UaWlpxZb58+eLo0ePCoVffvlFxMfHCyGEOHnypAAgTp48qdwO QDRr1kycOHFCHD58WAAQ/v7+4ujRo+LMmTMCgNi3b58QQoijR48KACImJkYIIUR6erpITExUq8vV 1VV88cUXIi4uTowfP144OjoKXQAIb29vcezYMZGSkiIyMzOFi4uLmDdvnigoKBCPHj0SPj4+Yvbs 2Ub1WVHf+++/L549eyZu374tXF1dxcyZM9XqK1peV/ua2NraiokTJ+oso2hr+fLlRm83t9mzZ4vu 3buLgoIC5XjSJSYmRrRr107UrFlTjBs3TuTn5+ssD0AMGjRIvPDCCyI2NlZrmeXLl4uCggKRmpoq 1qxZI+rWrSt+/fVXo49Ll6SkJOHo6ChOnTpVrB8uLi5i586d4o8//hAuLi5i+PDhatsV40r1//QP beP96dOnAoCYNWuW3tfw48ePhZOTk+jatau4e/euyMvLE9euXRPPnz9XtqEae02PDZ1P9M1PuuZB Q+cnVVLmYNUxJ/W4FOVdXFzE5s2bxblz54Szs7PG8WzsHGnJli5bIYQQIisrS+/y6NEjZfmiTN2/ vGHcTFOR4rdo8VKRnJJu1LJo8VKRk5Mj5s+frzGvDZobKYKX3BL+E/YLr67jhVFnhrt164b69esj JydHedYyJSVFrczkyZPRrl075Uds7733HoKDgxEYGIgaNWrg8ePHAIA6deoAKDxLFh0dDXt7e9Sr p35j5Q8//BBTpkyBu7s7goKCkJaWprePU6dORceOHVG7dm0cOnQICQkJ8Pf3x+nTpxEdHY0WLVoo zxAZ2ucjR44gISEB06dPh52dHRo0aIChQ4di06ZNGvsitf2ihBAQQug91vLs5MmTWLNmDdavX6/3 i3MK3t7eWLNmDTZs2IATJ06ga9euei/kd3Ut/PnGrVu3ai0zZ84cNGrUCM2aNcP777+PCRMmoE2b NtIPxgAff/wxOnTogKCgoGLbpk6digEDBqBFixYYOnQoDhw4UCp9kBvFWYzKlSvrfQ0fOHAAiYmJ WL58OTw8PFCpUiU0bdpU0icKClLnE6nzg9R50ND5ScocbMxxKUybNg1Dhw5FQEAAhg8fjp9++qlY ncbOkeUBz9AZh3EzTUWJX5XKNsjPz0dubi5ycnKQnZ2NjIwMPHnyBGlpaUhJSUFSUhISEhIQHx+P e/fu4fr1awa3Y9Q1w6tXr8aGDRvg5eWFWrVqaSzj6OgIAMoER/FYdR0A+Pn54cCBA1i8eDG+/vpr +Pj4YM2aNWpJgupH1dbW/+TvERERCA8PB1B4jeCTJ0+U21Qnc8XHchs2bFC2bW1tXSwRkdrnhIQE AICz8z8/C+js7KxcX5S+9rUdh7e3N/7880+NdVYUq1evRkJCglosgcJ4f//993jzzTeL7VO5cmU0 bdoUTZs2ha+vLxo3bowDBw5oLKsQFBSEwMBA9O/fHy4uLhovrZgzZ47yS3UPHjzAtGnT4Ovri9On TxfrnykiIyOxceNGXLp0SeN21es+69evj7S0NAghJP+xQJpdu1Y4Qfr6+iI+Ph6A9tewYru3t7fR 7UmdT6TOT9rmwaIMnZ+kzMHGHJeC6vXZzs7OavO0gtQYlEcV4dpNc2DcTMP4GcbgZPjUqVMICwtD bGyscnJeuXKlSZ3o2bMnevbsidTUVHzwwQcYMGCA8s1Il9DQUISGhuotp3hDmzdvXolcf+vi4gIA SExMRP369QEUJk+K9Ya2r+04+vbti4ULF+LixYt4+eWXTe63JYqIiMCqVauUj3///Xd07doVGRkZ qFy5st79FTFXXMupS79+/bBkyRK8//77cHJyQu/evbWWrV+/PlasWIEaNWpg+/bt+OijjyQcjTTT pk1Dx44d0apVK71lk5KS4ObmxkS4BKxYsQJOTk4ICQnBoUOHAGh/Dbu5uQEAbt68iWbNmmmsT/Gp jal3cTD3/AQYPwcb6t69e/D09Cy2vqRjYEmkJAz6ztCZsn95xbiZhvEzjMGXSSj+gr937x6Sk5OV icytW7eQl5dncAdiY2Nx+vRp5ObmombNmqXybehOnTrhpZdewqhRo3D79m0IIZCRkYELFy4YVV9I SAhcXFywYMEC5Obm4vbt29i8eTOGDx+uLGNvb4+HDx9CCGF0+1OnToWPjw+6dOmC1atX486dO0hO TsaZM2cwefJk/Pbbb8qy+fn5yMvLU1vKw19tlStXhr29vXKpWrUqgML42dgU/q0WFhaGiIgI5T77 9+9HdnY2nj9/jvnz56NKlSoICQmR1F54eDjGjx+PQYMG4fTp02rbFB/FPH36FPHx8Vi3bh2AfxKj knDjxg0cP35c0u3gHj9+jJ07d+Ldd9/VuF11jJE6xeshOzsbUVFRCA0Nxfbt27Fx40ZUrlxZ72v4 jTfegLOzM8LCwnD9+nWkp6fj1KlTyrOa1atXx4ULF3D58mWMGDHCpL6WxPykOhakzE+qSnsOzs7O BgBcv34dmzdv1viHvzExKDov6HtsLorL3XQtupIKU/cvrxg30zB+hjE4Ge7evTsGDhyIbt26oWXL lsjKysKUKVMwffp0o26enp6ejnHjxsHR0REODg44evQoduzYYXA9utjY2ODw4cPw9vZG69atUaVK FTRp0kTrNXT6VK1aFQcPHsSVK1fg6OiItm3bYsiQIfjkk0+UZWbOnImJEyfis88+M7r9mjVr4syZ MwgNDcWiRYvQuHFjuLi4YMiQIcjIyFD72DQ8PFx5KynFcvjwYaOOz9KsXr0aR44cUT7+9NNP4eLi gpo1a+LXX3/FwYMHDUpYFy9ejNdffx09evRAdHS0cn14eDjs7OxQtWpVeHh4YOHChZg6dSr69etX YseiOA5dyXtoaCgCAgLQrl07DBo0CDNnztRYTnWMkTrF66FatWoICQlBVlYWzp8/j9deew2A/tdw jRo18Ouvvypvh+fk5ITw8HDlnRKmTJmCRYsWYfDgwSbfu7gk5ifVsSBlflJV2nPwkCFDUKVKFXTu 3Bljx47F5MmTi5UxJgZF5wV9j80hLi4OGRkZehdtJy5M3b+8YtxMU1Hj5+5WD54ezmjg7YpGDd3R pLEnmjVtgOYvNjK5biuvruNFl2GTcDPpOZ5npOCn8T7FCq1cuRKBgYEIDg42uUEiQ61duxZXrlzB N99I/710Ivr/9u4+KKq67QP4lxTIUTATgeT9RSCRggFjEPH9BU0tIEWptBlDKe8U8WVGDZtqnsrG GyOpHh6nSAstwhg1EHMUilvvpbxHRwWWUPANDcRUQBIB9/nD2b13F3bPWfYsu7Dfz4wzsmfP71zX tb8952I556z52djYoKCgQO8pSQPVv06cxH/+c1r088PDw7p9rW3mp+L3eT2t3x+xbsYZSPX7Z0Ym UlauQOu9dtUFex7u3S/urai8gK6uLtWFfffutaK8/N/4x6oUZGRk4I033ui2zrxPq2Hn4ISWa+fR VHGcX7pBlq+goAAfffSRucMgIhJtYvQEo5uENatXCT9pgGHdjDPQ63f5yp/w8vzvxcFV8lpJPqFm M0wW79ChQxg0aJC5wyAiA+3atUvjWxeJiIxVW1cPXx83/FFzWbLzltkMk8VjI0zUP4m52w8RkaEu XLwq6TnLvfrSDSIiIiKigYDNMBERERFZLTbDRERERGS1eM4wEREREVmUkJBg/G/2/yEyMsqg9crL /42QkGCD1mEzTEREJDEp7vdqjVg34wyk+j03PgLAo+bWECEhwap1xRLVDIeGhkImk2HCBMssGBER kSUZHxGO8RHhBq3T3t5uomj6D9bNOAOpfkOGDMHkSTGYPCmmV+tnZGSIvrWjqGY4KipKNTARERER kSULDQ1V9a9CRJ8mERUVJXpQIiIiIqL+gHeTICIiIiKrxWaYiIiIiKwWm2EiIiIislpshomIiIjI arEZJiIiIiKrxWaYiIiIiKwWm2EiIiIislo67zMsl8tRW1vbl7EQERGRFfP19UVQUBAA9iFSsva6 quffE53NcG1tLebOnWuSoIiIiIi0FRUVqZoW9iHSsfa6quffE54mQURERERWi80wEREREVktNsNE REREZLWsvhm+cuUKampqzB2GyV2/fh2VlZVQKBTmDsUg7e3t6OrqMuk2zp07h+bmZpNuw1RMXZ++ qL8lsbZ8iaxZf973m8uRI0dw6tQpc4chOVHN8L179/Dhhx8iKioKLi4ucHJyQmBgIBYsWICqqipT xyiJESNGoLCwUOMxuVyO6dOn4/r162aKqm9cvXoVU6dOhVwuh42NjerxvLw8+Pv7w8fHB21tbT3W yNxcXV1RXFxs0m1MmjQJZWVlJt2GqZi6Pn1R/94w1Vy11HyJSJMUfUl/3vffvn0b33zzDVJSUhAS EiLJmCNGjMCuXbt0Lt+7dy/S09Ph7u4uyfaMIXX+Ou8modTa2orY2Fg0Nzfjgw8+wMSJEzF48GDU 1NSgrKys33yKUlBQgODgYNXPDx48wNtvv42vv/4a0dHRfR5PYWEhnn32WZNPqq6uLmzZsgU7duzo dvVoeno61qxZgxUrVsDW1rZbjYgshfb7hXOVyHoNlL7EGJWVlSgvL4e9vT2uXbtm8u3dvn0bJSUl KCwsxKhRo0y+PSFS5y/YDH/yySf4448/cPLkSfj7+6seDwsLQ1hYmNEB9JUpU6Zo/GxnZ4f8/Hzz BAPglVdewbfffmvyZnjQoEHYs2dPj8saGxvh4eEBe3t7AN1rRGQptN8vnKtE1mug9CXGiI6ORnR0 NA4cOKDzGC8loU+N+5rU+QueJnHw4EFMmTJFY8L1pLKyEvPnz4ebmxsCAwPxzjvvoKOjQ7V8xIgR yMzMRGhoKL744gudj8nlcsTFxSEgIACBgYFYu3Yt2tvbVeNUV1dj0aJFcHd3h7OzM8LCwtDa2iq4 TP3PqmJi3b9/P9LS0uDh4QEvLy/k5ORIlvu0adMAAMuXL0diYqKoMS5duoQlS5YgMjISoaGhGDly JFasWKG3vjt37sT48ePh5uYGT09PpKWl4eHDhwAe3YAaAFJSUvDWW291q5G+WuobV5vyk+mAgACM Hj0avr6+yMvLE1074FHTPnfuXDg7OyMuLg5NTU168xaaQ/oYkpty+3v27MGsWbMwatQoJCcn49at W5gzZw6cnJyQkJCA+/fvix6/p3z0vRYAcP/+fZ1z1dB8jh49iunTp2PKlCk9fvKqr7ZCr7VQLLry 7On9opyrSUlJWLlypUaMaWlpWLdunahtCuVraP2IyPSk6kvUaZ961dPPhuzrhfoIMccCSzttUT0m ofyEjsOWlr9gM3zp0iUEBgbqfU5bWxvi4+MRGBiIuro6HDlyBD/88AM+/vhjjefl5OQgKytLdUDT fqytrQ0vvvgioqOjUV1djfLycpw4cQI7duwAADQ3N2PBggV4+PAhZDIZbty4gby8PNjb2+td1ptY 09PT4enpCZlMhiVLluC9996TLPfjx48DAL788kt8//33gmN0dHTgpZdego+PD2QyGc6cOYPY2Nhu sWjX9+mnn8ahQ4dQX1+PvLw85OTk4LfffgMA1bfPZGdnY+fOnRrjCNVS37jaTp48ic8//xw//fQT rl+/jrNnz2Lq1KkG1W7btm1ITk5GSUkJqqqqsHXrVp15C80hIYbkpvTZZ5/h3XffRV5eHvLz87Fw 4UJs3rwZxcXFOH78OI4dO2bQ+Or5iJnX+uaqIfmcP38eSUlJSE9PR2lpKSoqKjSWC9VW32stFIu+ PLXfL+oWL16MQ4cOqX45aGtrQ35+PpYtWya4TaF8Da0fEfUNKfsSQxiyrweM2zfn5+dj/PjxvY61 L+jKT8xx2NLyF2yGFQqF4B0ISktL0dDQgHXr1sHOzg7e3t5ITEzEvn37NJ6XmpqKiRMn4sknn+zx sWPHjqGhoQFhYWEoLy+HXC5HcHCwaoIdPnwYjY2N2LZtG9zd3TFo0CCMGTMGtra2epf1JtaUlBSk pqbCzc0NkZGRuHPnjuS5ix1DJpPh4sWLSE5O1rgATpv2NmbMmAFXV1e0t7fDz88PAHDr1i2d6ysJ 1dKQcUeOHAkA2L17N+RyOYYOHao630hs7dauXYu4uDgEBwcjMTERhw8f1pm30BwS0puarV69GlFR Uao/3S9btgwxMTGIiIiAg4MD7t69a9D46vmImdf65qoh+eTm5sLHx0fnKQhCtdX3WgvFIvb9q232 7Nmws7PDgQMHADw6l9jPzw/PPPOM4DaF8jW0fkTUN6TsSwxhyL4eMG7fPH36dDg7O/c61r6gKz8x x2FLy1/wnGEvL68ePzFR19DQAAAagTs7O6seV+rppGv1x5R//s7NzVU1fY899hgiIyMBADdu3FDF pE3fst7EqnxxlDEYO56+E86FxlDe7ULZbOiivY2cnBzs3bsXnp6eeOKJJ/Suq06oloaMO3bsWOzb tw9ZWVnIzs6Gv78/MjMzERkZKbp26udVu7q64s6dO1AoFKo5YsgcEtKbmimfp9ye+nrav7yIGV89 HzHzWt9cNSSfK1euwMXFRedyodrqe62FYhH7/tVmb2+P+Ph47Nu3Dy+//DJ2796NpUuXispfKF+h 9YnIPKTsSwxhyL4ekG7fbKl05SfmOGxp+Qs2w/Pnz0dmZibOnDmD0NDQHp+jPKDcvHkTrq6uAIA/ //xT8ECjTXkg3Lx5c4/nAo0ePRrAoz/xBwQEiF5mililHE9oDOUnvfX19XB0dERHRwfq6uowbtw4 nWPKZDKkpaXh1KlTqgn71VdfiYpHXy17M25sbCxiY2Px119/YePGjXjttddQVVXVq9rdvHkTo0eP 1vkJudAc0seYmplqfLHzWortOTo6oq6uTvWz+rnZgLja6nqthWIxJs+kpCTMnDkTP//8M86fP4+E hARR+Qvla+r5QES9Y6q+RPlps6nvzjDQ9y1CxwpLzF/wNInU1FT4+/sjPj4eOTk5uHz5MpqamvD7 779j69atOHHiBKZOnQoXFxdkZGSoGrXvvvsOS5YsMSiYSZMmYdy4cVizZg3q6uqgUCjQ2tqK06dP AwDmzJkDZ2dnrF27FjU1NWhpaYFMJkNzc7PeZeqkitXY8YYOHYrGxkYoFArBMaKiouDg4IDt27ej trYWKSkpqK+v13vKhPLAXl9fj6amJtWJ7bW1tejs7NQbm75aGjruhQsXUF5ejo6ODgwfPhweHh69 rt3du3dRUFCAV199VWfsQnNIH2NqJkZvxhc7r6XY3qxZs1SN661bt5CcnKyxXKi2+l5roViE8lR/ v2gLDw+Hn58fVq5cibi4ODg6OoraplC+YuqXlpbWJ1dyE9F/maIvGTZsGE6fPo2zZ89i1apVJo1f zL6ltLQUN2/eNGkcPenq6kJnZ6fGP0MvGhY6Vlhi/oLN8PDhw3H06FEsXboUWVlZCA8PR1BQEJKT k9Ha2go/Pz8MGTIE+/fvx7lz5+Dt7Y3Zs2dj0aJF2LBhg0HBDB48GD/++CO8vLwwY8YMPPXUUwgP D1ed4+Pg4ICDBw/C1tYWMTExGDNmDDZt2oT79+/rXaZOqliNHW/9+vXYsmULtm/fLjjGsGHDkJ2d jdLSUjz33HNwd3fHhAkT8Pjjj+scf+bMmYiPj8fChQsRExODe/fuITU1Fe+//77gTcb11dLQcVta WrBhwwZ4e3vD09MTv/76q+o3QLG1W716NaZNm4Y5c+YgISEB69ev1xm70BzSx5iaidGb8cXOaym2 98ILL+DNN99EQkICJk+ejOXLl2ssF6qtvtdaKBahPNXfL9psbGywePFi3LlzR3XhnJhtCuUrpn45 OTn45ZdfBF8LIpKOKfqS1NRUZGVl4fXXX+92kbbUxOxb4uLi9F6sW1xcDDc3N9XddJR3ZTDWpk2b MGrUKI1/JSUlBo0hdKywxPxtvGevVsx6dT1qGh/gQUsTflr96ArNoqKibl/SQOb18OFDdHZ2ws7O DpMnT8bzzz+PjRs3mjssIiIiSaj3HuxDpGPtddXOed6n1bBzcELLtfNoqjgu7uuYybyqq6tRVlaG v//+G52dncjOzkZFRQXmzZtn7tCIiIiI+jXBC+jI/FpaWpCeno6LFy9CoVAgKCgIubm5GDt2rLlD IyIiIurX2Az3AxERESgtLTV3GEREREQDjs5m2NfXF0VFRX0ZCxEREVkxX19fjf+zD5GGtddVPf+e 6GyGg4KCEBQUJHlARERERELYh5gG69qdRjNs5+CEeZ9WmysWIiIiIiKTsnNw0vi52yfD2k8gIiIi IhqoVM1wy7Xz5oyDiIiIiKjP2Vy52oBJr/9P9+84JSIiIiIawJ5xvG3z/7XFSsY5YQnEAAAAAElF TkSuQmCC 14473 2006-02-01 03:38:05 +0000 2006-02-01 03:38:05 +0000 New patch patch.diff text/plain 13003 mcguire SW5kZXg6IGttYXRtbGlzdHZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGttYXRtbGlzdHZpZXcuY3Bw CShyZXZpc2lvbiA0OTc5OTApCisrKyBrbWF0bWxpc3R2aWV3LmNwcAkod29ya2luZyBjb3B5KQpA QCAtMSwxNDcgKzEsMzEgQEAKIC8vIC0qLSBtb2RlOiBDKys7IGMtZmlsZS1zdHlsZTogImdudSIg LSotCi0vLyBrbWNvbXBvc2V3aW4uY3BwCisvLyBrbWF0bWxpc3R2aWV3LmNwcAogLy8gQXV0aG9y OiBNYXJrdXMgV3VlYmJlbiA8bWFya3VzLnd1ZWJiZW5Aa2RlLm9yZz4KIC8vIFRoaXMgY29kZSBp cyBwdWJsaXNoZWQgdW5kZXIgdGhlIEdQTC4KIAogI2luY2x1ZGUgPGNvbmZpZy5oPgogCiAjaW5j bHVkZSAia21hdG1saXN0dmlldy5oIgotCi0jaW5jbHVkZSAia21tYWlud2luLmgiCi0jaW5jbHVk ZSAia21yZWFkZXJtYWlud2luLmgiCi0jaW5jbHVkZSAibWVzc2FnZXNlbmRlci5oIgotI2luY2x1 ZGUgImttbXNncGFydGRsZy5oIgotI2luY2x1ZGUgPGtwZ3BibG9jay5oPgotI2luY2x1ZGUgPGth ZGRyYm9vay5oPgotI2luY2x1ZGUgImttYWRkcmJvb2suaCIKLSNpbmNsdWRlICJrbW1zZ2RpY3Qu aCIKLSNpbmNsdWRlICJrbWZvbGRlcmltYXAuaCIKLSNpbmNsdWRlICJrbWZvbGRlcm1nci5oIgot I2luY2x1ZGUgImttZm9sZGVyY29tYm9ib3guaCIKLSNpbmNsdWRlICJrbXRyYW5zcG9ydC5oIgot I2luY2x1ZGUgImttY29tbWFuZHMuaCIKLSNpbmNsdWRlICJrY3Vyc29yc2F2ZXIuaCIKLSNpbmNs dWRlICJwYXJ0Tm9kZS5oIgotI2luY2x1ZGUgImF0dGFjaG1lbnRsaXN0dmlldy5oIgotI2luY2x1 ZGUgInRyYW5zcG9ydG1hbmFnZXIuaCIKLXVzaW5nIEtNYWlsOjpBdHRhY2htZW50TGlzdFZpZXc7 Ci0jaW5jbHVkZSAiZGljdGlvbmFyeWNvbWJvYm94LmgiCi11c2luZyBLTWFpbDo6RGljdGlvbmFy eUNvbWJvQm94OwotI2luY2x1ZGUgImFkZHJlc3Nlc2RpYWxvZy5oIgotdXNpbmcgS1BJTTo6QWRk cmVzc2VzRGlhbG9nOwotI2luY2x1ZGUgImFkZHJlc3NlZWVtYWlsc2VsZWN0aW9uLmgiCi11c2lu ZyBLUElNOjpBZGRyZXNzZWVFbWFpbFNlbGVjdGlvbjsKLXVzaW5nIEtQSU06OkFkZHJlc3NlZVNl bGVjdG9yRGlhbG9nOwotI2luY2x1ZGUgPG1haWxsaXN0ZHJhZy5oPgotdXNpbmcgS1BJTTo6TWFp bExpc3REcmFnOwotI2luY2x1ZGUgInJlY2VudGFkZHJlc3Nlcy5oIgotdXNpbmcgS1JlY2VudEFk ZHJlc3M6OlJlY2VudEFkZHJlc3NlczsKLSNpbmNsdWRlICJrbGVvX3V0aWwuaCIKLSNpbmNsdWRl ICJzdGxfdXRpbC5oIgotI2luY2x1ZGUgInJlY2lwaWVudHNlZGl0b3IuaCIKLQotI2luY2x1ZGUg ImF0dGFjaG1lbnRjb2xsZWN0b3IuaCIKLSNpbmNsdWRlICJvYmplY3R0cmVlcGFyc2VyLmgiCi0K LSNpbmNsdWRlICJrbWZvbGRlcm1haWxkaXIuaCIKLQotI2luY2x1ZGUgPGxpYmtwaW1pZGVudGl0 aWVzL2lkZW50aXR5bWFuYWdlci5oPgotI2luY2x1ZGUgPGxpYmtwaW1pZGVudGl0aWVzL2lkZW50 aXR5Y29tYm8uaD4KLSNpbmNsdWRlIDxsaWJrcGltaWRlbnRpdGllcy9pZGVudGl0eS5oPgotI2lu Y2x1ZGUgPGxpYmtkZXBpbS9rZmlsZWlvLmg+Ci0jaW5jbHVkZSA8bGliZW1haWxmdW5jdGlvbnMv ZW1haWwuaD4KLSNpbmNsdWRlIDxrbGVvL2NyeXB0b2JhY2tlbmRmYWN0b3J5Lmg+Ci0jaW5jbHVk ZSA8a2xlby9leHBvcnRqb2IuaD4KLSNpbmNsdWRlIDx1aS9wcm9ncmVzc2RpYWxvZy5oPgotI2lu Y2x1ZGUgPHVpL2tleXNlbGVjdGlvbmRpYWxvZy5oPgotCi0jaW5jbHVkZSA8Z3BnbWVwcC9jb250 ZXh0Lmg+Ci0jaW5jbHVkZSA8Z3BnbWVwcC9rZXkuaD4KLQotI2luY2x1ZGUgPGthYmMvdmNhcmRj b252ZXJ0ZXIuaD4KLSNpbmNsdWRlIDxsaWJrZGVwaW0va3ZjYXJkZHJhZy5oPgotI2luY2x1ZGUg PGtpby9uZXRhY2Nlc3MuaD4KLQotCi0jaW5jbHVkZSAia2xpc3Rib3hkaWFsb2cuaCIKLQotI2lu Y2x1ZGUgIm1lc3NhZ2Vjb21wb3Nlci5oIgotCi0jaW5jbHVkZSA8a2NoYXJzZXRzLmg+Ci0jaW5j bHVkZSA8a2NvbXBsZXRpb25ib3guaD4KLSNpbmNsdWRlIDxrY3Vyc29yLmg+Ci0jaW5jbHVkZSA8 a2NvbWJvYm94Lmg+Ci0jaW5jbHVkZSA8a3N0ZGFjY2VsLmg+Ci0jaW5jbHVkZSA8a3BvcHVwbWVu dS5oPgotI2luY2x1ZGUgPGtlZGl0dG9vbGJhci5oPgotI2luY2x1ZGUgPGtrZXlkaWFsb2cuaD4K LSNpbmNsdWRlIDxrZGVidWcuaD4KLSNpbmNsdWRlIDxrZmlsZWRpYWxvZy5oPgotI2luY2x1ZGUg PGt3aW4uaD4KLSNpbmNsdWRlIDxraW5wdXRkaWFsb2cuaD4KLSNpbmNsdWRlIDxrbWVzc2FnZWJv eC5oPgotI2luY2x1ZGUgPGt1cmxkcmFnLmg+Ci0jaW5jbHVkZSA8a2lvL3NjaGVkdWxlci5oPgot I2luY2x1ZGUgPGt0ZW1wZmlsZS5oPgotI2luY2x1ZGUgPGtsb2NhbGUuaD4KLSNpbmNsdWRlIDxr YXBwbGljYXRpb24uaD4KLSNpbmNsdWRlIDxrc3RhdHVzYmFyLmg+Ci0jaW5jbHVkZSA8a2FjdGlv bi5oPgotI2luY2x1ZGUgPGtzdGRhY3Rpb24uaD4KLSNpbmNsdWRlIDxrZGlyd2F0Y2guaD4KLSNp bmNsdWRlIDxrc3RkZ3VpaXRlbS5oPgotI2luY2x1ZGUgPGtpY29ubG9hZGVyLmg+Ci0jaW5jbHVk ZSA8a3B1c2hidXR0b24uaD4KLSNpbmNsdWRlIDxrdXNlcnByb2ZpbGUuaD4KLSNpbmNsdWRlIDxr cnVuLmg+Ci0jaW5jbHVkZSA8a3RlbXBkaXIuaD4KLS8vI2luY2x1ZGUgPGtlZGl0bGlzdGJveC5o PgotI2luY2x1ZGUgImdsb2JhbHNldHRpbmdzLmgiCi0jaW5jbHVkZSAicmVwbHlwaHJhc2VzLmgi Ci0KLSNpbmNsdWRlIDxrc3BlbGwuaD4KLSNpbmNsdWRlIDxrc3BlbGxkbGcuaD4KLSNpbmNsdWRl IDxzcGVsbGluZ2ZpbHRlci5oPgotI2luY2x1ZGUgPGtzeW50YXhoaWdobGlnaHRlci5oPgotI2lu Y2x1ZGUgPGtjb2xvcmRpYWxvZy5oPgotI2luY2x1ZGUgPGt6aXAuaD4KLSNpbmNsdWRlIDxrc2F2 ZWZpbGUuaD4KLQotI2luY2x1ZGUgPHF0YWJkaWFsb2cuaD4KLSNpbmNsdWRlIDxxcmVnZXhwLmg+ Ci0jaW5jbHVkZSA8cWJ1ZmZlci5oPgotI2luY2x1ZGUgPHF0b29sdGlwLmg+Ci0jaW5jbHVkZSA8 cXRleHRjb2RlYy5oPgorI2luY2x1ZGUgPHFjaGVja2JveC5oPgogI2luY2x1ZGUgPHFoZWFkZXIu aD4KLSNpbmNsdWRlIDxxd2hhdHN0aGlzLmg+Ci0jaW5jbHVkZSA8cWZvbnRkYXRhYmFzZS5oPgog Ci0jaW5jbHVkZSA8bWltZWxpYi9taW1lcHAuaD4KIAotI2luY2x1ZGUgPGFsZ29yaXRobT4KLQot I2luY2x1ZGUgPHN5cy9zdGF0Lmg+Ci0jaW5jbHVkZSA8c3lzL3R5cGVzLmg+Ci0jaW5jbHVkZSA8 c3RkbGliLmg+Ci0jaW5jbHVkZSA8dW5pc3RkLmg+Ci0jaW5jbHVkZSA8ZXJybm8uaD4KLSNpbmNs dWRlIDxmY250bC5oPgotI2luY2x1ZGUgPGFzc2VydC5oPgotCiBLTUF0bUxpc3RWaWV3SXRlbTo6 S01BdG1MaXN0Vmlld0l0ZW0oUUxpc3RWaWV3ICpwYXJlbnQpCiAgIDogUU9iamVjdCgpLAotICAg IFFMaXN0Vmlld0l0ZW0oIHBhcmVudCApLAotICAgIG1MaXN0dmlldyggcGFyZW50ICksCi0gICAg bUNCU2lnbkVuYWJsZWQoIGZhbHNlICksCi0gICAgbUNCRW5jcnlwdEVuYWJsZWQoIGZhbHNlICkK KyAgICBRTGlzdFZpZXdJdGVtKCBwYXJlbnQgKQogewotICBtQ0JFbmNyeXB0ID0gbmV3IFFDaGVj a0JveCggbUxpc3R2aWV3LT52aWV3cG9ydCgpICk7Ci0gIG1DQlNpZ24gPSBuZXcgUUNoZWNrQm94 KCBtTGlzdHZpZXctPnZpZXdwb3J0KCkgKTsKLSAgbUNCQ29tcHJlc3MgPSBuZXcgUUNoZWNrQm94 KCBtTGlzdHZpZXctPnZpZXdwb3J0KCkgKTsKLSAgY29ubmVjdCggbUNCQ29tcHJlc3MsIFNJR05B TCggY2xpY2tlZCgpICksIHRoaXMsIFNMT1QoIHNsb3RDb21wcmVzcygpICkgKTsKKyAgbUNCQ29t cHJlc3MgPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3cG9ydCgpICk7CisgIG1DQkVu Y3J5cHQgPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3cG9ydCgpICk7CisgIG1DQlNp Z24gPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3cG9ydCgpICk7CisgIG1DQkNvbXBy ZXNzLT5zZXRTaG93biggdHJ1ZSApOworICB1cGRhdGVBbGxDaGVja0JveGVzKCk7CiAKLSAgbUNC RW5jcnlwdC0+aGlkZSgpOwotICBtQ0JTaWduLT5oaWRlKCk7CisgIGNvbm5lY3QoIG1DQkNvbXBy ZXNzLCBTSUdOQUwoIGNsaWNrZWQoKSApLCB0aGlzLCBTTE9UKCBzbG90Q29tcHJlc3MoKSApICk7 CisgIGNvbm5lY3QoIGxpc3RWaWV3KCktPmhlYWRlcigpLCBTSUdOQUwoIHNpemVDaGFuZ2UoaW50 LCBpbnQsIGludCkgKSwKKyAgICAgICAgICAgU0xPVCggc2xvdEhlYWRlckNoYW5nZShpbnQsIGlu dCwgaW50KSApICk7CisgIGNvbm5lY3QoIGxpc3RWaWV3KCktPmhlYWRlcigpLCBTSUdOQUwoIGlu ZGV4Q2hhbmdlKGludCwgaW50LCBpbnQpICksCisgICAgICAgICAgIFNMT1QoIHNsb3RIZWFkZXJD aGFuZ2UoaW50LCBpbnQsIGludCkgKSApOworICBjb25uZWN0KCBsaXN0VmlldygpLT5oZWFkZXIo KSwgU0lHTkFMKCBjbGlja2VkKCBpbnQgKSApLCBTTE9UKCBzbG90SGVhZGVyQ2xpY2soIGludCAp ICkgKTsKIH0KIAogS01BdG1MaXN0Vmlld0l0ZW06On5LTUF0bUxpc3RWaWV3SXRlbSgpCkBAIC0x NTQsODcgKzM4LDcwIEBACiAgIG1DQkNvbXByZXNzID0gMDsKIH0KIAotdm9pZCBLTUF0bUxpc3RW aWV3SXRlbTo6cGFpbnRDZWxsKCBRUGFpbnRlciAqIHAsIGNvbnN0IFFDb2xvckdyb3VwICYgY2cs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IGNvbHVtbiwgaW50IHdpZHRo LCBpbnQgYWxpZ24gKQordm9pZCBLTUF0bUxpc3RWaWV3SXRlbTo6dXBkYXRlQ2hlY2tCb3goaW50 IGhlYWRlclNlY3Rpb24sIFFDaGVja0JveCogY2IpCiB7Ci0gIC8vIHRoaXMgaXMgYWxzbyBjYWxs ZWQgZm9yIHRoZSBlbmNyeXB0L3NpZ24gY29sdW1ucyB0byBhc3N1cmUgdGhhdCB0aGUKLSAgLy8g YmFja2dyb3VuZCBpcyBjbGVhcmVkCi0gIFFMaXN0Vmlld0l0ZW06OnBhaW50Q2VsbCggcCwgY2cs IGNvbHVtbiwgd2lkdGgsIGFsaWduICk7Ci0gIGlmICggNCA9PSBjb2x1bW4gKSB7Ci0gICAgUVJl Y3QgciA9IG1MaXN0dmlldy0+aXRlbVJlY3QoIHRoaXMgKTsKLSAgICBpZiAoICFyLnNpemUoKS5p c1ZhbGlkKCkgKSB7Ci0gICAgICAgIG1MaXN0dmlldy0+ZW5zdXJlSXRlbVZpc2libGUoIHRoaXMg KTsKLSAgICAgICAgbUxpc3R2aWV3LT5yZXBhaW50Q29udGVudHMoIEZBTFNFICk7Ci0gICAgICAg IHIgPSBtTGlzdHZpZXctPml0ZW1SZWN0KCB0aGlzICk7Ci0gICAgfQotICAgIGludCBjb2xXaWR0 aCA9IG1MaXN0dmlldy0+aGVhZGVyKCktPnNlY3Rpb25TaXplKCBjb2x1bW4gKTsKLSAgICByLnNl dFgoIG1MaXN0dmlldy0+aGVhZGVyKCktPnNlY3Rpb25Qb3MoIGNvbHVtbiApCi0gICAgICAgICAg ICAtIG1MaXN0dmlldy0+aGVhZGVyKCktPm9mZnNldCgpCi0gICAgICAgICAgICArIGNvbFdpZHRo IC8gMgotICAgICAgICAgICAgLSByLmhlaWdodCgpIC8gMgotICAgICAgICAgICAgLSAxICk7Ci0g ICAgci5zZXRZKCByLnkoKSArIDEgKTsKLSAgICByLnNldFdpZHRoKCAgci5oZWlnaHQoKSAtIDIg KTsKLSAgICByLnNldEhlaWdodCggci5oZWlnaHQoKSAtIDIgKTsKLSAgICByID0gUVJlY3QoIG1M aXN0dmlldy0+dmlld3BvcnRUb0NvbnRlbnRzKCByLnRvcExlZnQoKSApLCByLnNpemUoKSApOwor ICAvL0NhbGN1bGF0ZSBzb21lIHZhbHVlcyB0byBkZXRlcm1pbmUgdGhlIHgtcG9zaXRpb24gd2hl cmUgdGhlIGNoZWNrYm94CisgIC8vd2lsbCBiZSBkcmF3bgorICBpbnQgc2VjdGlvbldpZHRoID0g bGlzdFZpZXcoKS0+aGVhZGVyKCktPnNlY3Rpb25TaXplKCBoZWFkZXJTZWN0aW9uICk7CisgIGlu dCBzZWN0aW9uUG9zID0gbGlzdFZpZXcoKS0+aGVhZGVyKCktPnNlY3Rpb25Qb3MoIGhlYWRlclNl Y3Rpb24gKTsKKyAgaW50IHNlY3Rpb25PZmZzZXQgPSBzZWN0aW9uV2lkdGggLyAyIC0gaGVpZ2h0 KCkgLyA0OwogCi0gICAgbUNCQ29tcHJlc3MtPnJlc2l6ZSggci5zaXplKCkgKTsKLSAgICBtTGlz dHZpZXctPm1vdmVDaGlsZCggbUNCQ29tcHJlc3MsIHIueCgpLCByLnkoKSApOworICAvL1Jlc2l6 ZSBhbmQgbW92ZSB0aGUgY2hlY2tib3gKKyAgY2ItPnJlc2l6ZSggc2VjdGlvbldpZHRoIC0gc2Vj dGlvbk9mZnNldCAtIDEsIGhlaWdodCgpIC0gMiApOworICBsaXN0VmlldygpLT5tb3ZlQ2hpbGQo IGNiLCBzZWN0aW9uUG9zICsgc2VjdGlvbk9mZnNldCwgaXRlbVBvcygpICsgMSApOwogCi0gICAg UUNvbG9yIGJnOwotICAgIGlmIChpc1NlbGVjdGVkKCkpCi0gICAgICBiZyA9IGNnLmhpZ2hsaWdo dCgpOwotICAgIGVsc2UKLSAgICAgIGJnID0gY2cuYmFzZSgpOworICAvL1NldCB0aGUgY29ycmVj dCBiYWNrZ3JvdW5kIGNvbG9yCisgIFFDb2xvciBiZzsKKyAgaWYgKGlzU2VsZWN0ZWQoKSkKKyAg ICBiZyA9IGxpc3RWaWV3KCktPmNvbG9yR3JvdXAoKS5oaWdobGlnaHQoKTsKKyAgZWxzZQorICAg IGJnID0gbGlzdFZpZXcoKS0+Y29sb3JHcm91cCgpLmJhc2UoKTsKKyAgY2ItPnNldFBhbGV0dGVC YWNrZ3JvdW5kQ29sb3IoYmcpOworfQogCi0gICAgbUNCQ29tcHJlc3MtPnNldFBhbGV0dGVCYWNr Z3JvdW5kQ29sb3IoYmcpOwotICAgIG1DQkNvbXByZXNzLT5zaG93KCk7Cit2b2lkIEtNQXRtTGlz dFZpZXdJdGVtOjp1cGRhdGVBbGxDaGVja0JveGVzKCkKK3sKKyAgdXBkYXRlQ2hlY2tCb3goIDQs IG1DQkNvbXByZXNzICk7CisgIHVwZGF0ZUNoZWNrQm94KCA1LCBtQ0JFbmNyeXB0ICk7CisgIHVw ZGF0ZUNoZWNrQm94KCA2LCBtQ0JTaWduICk7Cit9CisKKy8vRWFjaCB0aW1lIGEgY2VsbCBpcyBh Ym91dCB0byBiZSBwYWludGVkLCB0aGUgaXRlbSdzIGNoZWNrYm94ZXMgYXJlIHVwZGF0ZWQgYXMg d2VsbC4KKy8vVGhpcyBpcyBuZWNlc3NhcnkgdG8ga2VlcCB0aGUgcG9zaXRpb25zIG9mIHRoZSBj aGVja2JveGVzIHVwLXRvLWRhdGUuCisvL1RoZSBzaWduYWxzIHdoaWNoIGFyZSwgaW4gdGhlIGNv bnN0cnVjdG9yIG9mIHRoaXMgY2xhc3MsIGNvbm5lY3RlZCB0byB0aGUgdXBkYXRlIHNsb3RzCisv L2FyZSBub3Qgc3VmZmljZW50IGJlY2F1c2UgdW5mb3J0dW5hdGx5LCBRdCBkb2VzIG5vdCBwcm92 aWRlIGEgc2lnbmFsIGZvciBjaGFuZ2VkIGl0ZW0gcG9zaXRpb25zLAorLy9lLmcuIGR1cmluZyBk ZWxldGluZyBvciBhZGRpbmcgaXRlbXMuIFRoZSBwcm9ibGVtIHdpdGggdGhpcyBpcyB0aGF0IHRo aXMgZnVuY3Rpb24gCisvL2RvZXMgbm90IGNhdGNoIHVwZGF0ZXMgd2hpY2ggYXJlIG9mZi1zY3Jl ZW4sIHdoaWNoIG1lYW5zIHVuZGVyIHNvbWUgY2lyY3Vtc3RhbmNlcyBjaGVja2JveGVzCisvL2hh dmUgaW52YWxpZCBwb3NpdGlvbnMuIFRoaXMgc2hvdWxkIG5vdCBoYXBwZW4gYW55bW9yZSwgYnV0 IHdhcyB0aGUgY2F1c2Ugb2YgYnVnIDExMzQ1OC4KKy8vVGhlcmVmb3JlLCBib3RoIHRoZSBzaWdu YWxzIGNvbm5lY3RlZCBpbiB0aGUgY29uc3RydWN0b3IgYW5kIHRoaXMgZnVuY3Rpb24gYXJlIG5l Y2Vzc2FyeSB0bworLy9rZWVwIHRoZSBjaGVja2JveGVzJyBwb3NpdGlvbnMgaW4gc3luYywgYW5k IGhvcGVmdWxseSBpcyBlbm91Z2guCit2b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjpwYWludENlbGwg KCBRUGFpbnRlciAqIHAsIGNvbnN0IFFDb2xvckdyb3VwICYgY2csIGludCBjb2x1bW4sIGludCB3 aWR0aCwgaW50IGFsaWduICkKK3sKKyAgc3dpdGNoIChjb2x1bW4pCisgIHsKKyAgICBjYXNlIDQ6 IHVwZGF0ZUNoZWNrQm94KCA0LCBtQ0JDb21wcmVzcyApOyBicmVhazsKKyAgICBjYXNlIDU6IHVw ZGF0ZUNoZWNrQm94KCA1LCBtQ0JFbmNyeXB0ICk7IGJyZWFrOworICAgIGNhc2UgNjogdXBkYXRl Q2hlY2tCb3goIDYsIG1DQlNpZ24gKTsgYnJlYWs7CiAgIH0KLSAgaWYoIDUgPT0gY29sdW1uIHx8 IDYgPT0gY29sdW1uICkgewotICAgIFFSZWN0IHIgPSBtTGlzdHZpZXctPml0ZW1SZWN0KCB0aGlz ICk7Ci0gICAgaWYgKCAhci5zaXplKCkuaXNWYWxpZCgpICkgewotICAgICAgICBtTGlzdHZpZXct PmVuc3VyZUl0ZW1WaXNpYmxlKCB0aGlzICk7Ci0gICAgICAgIG1MaXN0dmlldy0+cmVwYWludENv bnRlbnRzKCBGQUxTRSApOwotICAgICAgICByID0gbUxpc3R2aWV3LT5pdGVtUmVjdCggdGhpcyAp OwotICAgIH0KLSAgICBpbnQgY29sV2lkdGggPSBtTGlzdHZpZXctPmhlYWRlcigpLT5zZWN0aW9u U2l6ZSggY29sdW1uICk7Ci0gICAgci5zZXRYKCBtTGlzdHZpZXctPmhlYWRlcigpLT5zZWN0aW9u UG9zKCBjb2x1bW4gKQotICAgICAgICAgICAgKyBjb2xXaWR0aCAvIDIKLSAgICAgICAgICAgIC0g ci5oZWlnaHQoKSAvIDIKLSAgICAgICAgICAgIC0gMSApOwotICAgIHIuc2V0WSggci55KCkgKyAx ICk7Ci0gICAgci5zZXRXaWR0aCggIHIuaGVpZ2h0KCkgLSAyICk7Ci0gICAgci5zZXRIZWlnaHQo IHIuaGVpZ2h0KCkgLSAyICk7Ci0gICAgciA9IFFSZWN0KCBtTGlzdHZpZXctPnZpZXdwb3J0VG9D b250ZW50cyggci50b3BMZWZ0KCkgKSwgci5zaXplKCkgKTsKKyAgCisgIFFMaXN0Vmlld0l0ZW06 OnBhaW50Q2VsbCggcCwgY2csIGNvbHVtbiwgd2lkdGgsIGFsaWduICk7Cit9CiAKLSAgICBRQ2hl Y2tCb3gqIGNiID0gKDUgPT0gY29sdW1uKSA/IG1DQkVuY3J5cHQgOiBtQ0JTaWduOwotICAgIGNi LT5yZXNpemUoIHIuc2l6ZSgpICk7Ci0gICAgbUxpc3R2aWV3LT5tb3ZlQ2hpbGQoIGNiLCByLngo KSwgci55KCkgKTsKK2ludCBLTUF0bUxpc3RWaWV3SXRlbTo6Y29tcGFyZSggUUxpc3RWaWV3SXRl bSAqaSwgaW50IGNvbCwgYm9vbCBhc2NlbmRpbmcgKSBjb25zdAoreworICBpZiAoY29sICE9IDEp CisgICAgcmV0dXJuIFFMaXN0Vmlld0l0ZW06OmNvbXBhcmUoaSwgY29sLCBhc2NlbmRpbmcpOwog Ci0gICAgUUNvbG9yIGJnOwotICAgIGlmIChpc1NlbGVjdGVkKCkpCi0gICAgICBiZyA9IGNnLmhp Z2hsaWdodCgpOwotICAgIGVsc2UKLSAgICAgIGJnID0gY2cuYmFzZSgpOwotCi0gICAgYm9vbCBl bmFibGVkID0gKDUgPT0gY29sdW1uKSA/IG1DQkVuY3J5cHRFbmFibGVkIDogbUNCU2lnbkVuYWJs ZWQ7Ci0gICAgY2ItPnNldFBhbGV0dGVCYWNrZ3JvdW5kQ29sb3IoYmcpOwotICAgIGlmIChlbmFi bGVkKSBjYi0+c2hvdygpOwotICB9CisgIHJldHVybiBtQXR0YWNobWVudFNpemUgLSAoc3RhdGlj X2Nhc3Q8S01BdG1MaXN0Vmlld0l0ZW0qPihpKSktPm1BdHRhY2htZW50U2l6ZTsKIH0KIAogdm9p ZCBLTUF0bUxpc3RWaWV3SXRlbTo6ZW5hYmxlQ3J5cHRvQ0JzKGJvb2wgb24pCiB7Ci0gIGlmKCBt Q0JFbmNyeXB0ICkgewotICAgIG1DQkVuY3J5cHRFbmFibGVkID0gb247Ci0gICAgbUNCRW5jcnlw dC0+c2V0RW5hYmxlZCggb24gKTsKLSAgICBtQ0JFbmNyeXB0LT5zZXRTaG93biggb24gKTsKLSAg fQotICBpZiggbUNCU2lnbiApIHsKLSAgICBtQ0JTaWduRW5hYmxlZCA9IG9uOwotICAgIG1DQlNp Z24tPnNldEVuYWJsZWQoIG9uICk7Ci0gICAgbUNCU2lnbi0+c2V0U2hvd24oIG9uICk7Ci0gIH0K KyAgLy9TaG93L0hpZGUgdGhlIGFwcHJvcHJpYXRlIGNoZWNrYm94ZXMuCisgIC8vVGhpcyBzaG91 bGQgbm90IGJlIG5lY2Vzc2FyeSBiZWNhdXNlIHRoZSBjYWxsZXIgaGlkZXMgdGhlIGNvbHVtbnMg Y29udGFpbmluZworICAvL3RoZSBjaGVja2JveGVzIGFueXdheS4KKyAgbUNCRW5jcnlwdC0+c2V0 U2hvd24oIG9uICk7CisgIG1DQlNpZ24tPnNldFNob3duKCBvbiApOwogfQogCiB2b2lkIEtNQXRt TGlzdFZpZXdJdGVtOjpzZXRFbmNyeXB0KGJvb2wgb24pCkBAIC0yODMsNCArMTUwLDE4IEBACiAg ICAgICAgIGVtaXQgdW5jb21wcmVzcyggaXRlbVBvcygpICk7CiB9CiAKKy8vVXBkYXRlIHRoZSBp dGVtJ3MgY2hlY2tib3hlcyB3aGVuIHRoZSBwb3NpdGlvbiBvZiB0aG9zZSBjaGFuZ2UKKy8vZHVl IHRvIGRpZmZlcmVudCBjb2x1bW4gcG9zaXRpb25zCit2b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjpz bG90SGVhZGVyQ2hhbmdlKGludCwgaW50LCBpbnQpCit7CisgIHVwZGF0ZUFsbENoZWNrQm94ZXMo KTsKK30KKworLy9VcGRhdGUgdGhlIGl0ZW0ncyBjaGVja2JveGVzIHdoZW4gdGhlIGxpc3QgaXMg YmVpbmcgc29ydGVkCit2b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjpzbG90SGVhZGVyQ2xpY2soaW50 KQoreworICB1cGRhdGVBbGxDaGVja0JveGVzKCk7Cit9CisKKwogI2luY2x1ZGUgImttYXRtbGlz dHZpZXcubW9jIgpJbmRleDoga21jb21wb3Nld2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBrbWNvbXBv c2V3aW4uY3BwCShyZXZpc2lvbiA0OTc5OTApCisrKyBrbWNvbXBvc2V3aW4uY3BwCSh3b3JraW5n IGNvcHkpCkBAIC0yMjQ2LDYgKzIyNDYsNyBAQAogICBsdmktPnNldFRleHQoMSwgS0lPOjpjb252 ZXJ0U2l6ZSggbXNnUGFydC0+ZGVjb2RlZFNpemUoKSkpOwogICBsdmktPnNldFRleHQoMiwgbXNn UGFydC0+Y29udGVudFRyYW5zZmVyRW5jb2RpbmdTdHIoKSk7CiAgIGx2aS0+c2V0VGV4dCgzLCBw cmV0dHlNaW1lVHlwZShtc2dQYXJ0LT50eXBlU3RyKCkgKyAiLyIgKyBtc2dQYXJ0LT5zdWJ0eXBl U3RyKCkpKTsKKyAgbHZpLT5zZXRBdHRhY2htZW50U2l6ZShtc2dQYXJ0LT5kZWNvZGVkU2l6ZSgp KTsKIAogICBpZiAoIGxvYWREZWZhdWx0cyApIHsKICAgICBpZiggY2FuU2lnbkVuY3J5cHRBdHRh Y2htZW50cygpICkgewpJbmRleDoga21hdG1saXN0dmlldy5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGttYXRt bGlzdHZpZXcuaAkocmV2aXNpb24gNDk3OTkwKQorKysga21hdG1saXN0dmlldy5oCSh3b3JraW5n IGNvcHkpCkBAIC0xLDUgKzEsNSBAQAogLyogLSotIG1vZGU6IEMrKzsgYy1maWxlLXN0eWxlOiAi Z251IiAtKi0KLSAqIEtNQ29tcG9zZVdpbiBIZWFkZXIgRmlsZQorICogS01BdG1MaXN0Vmlld0l0 ZW0gSGVhZGVyIEZpbGUKICAqIEF1dGhvcjogTWFya3VzIFd1ZWJiZW4gPG1hcmt1cy53dWViYmVu QGtkZS5vcmc+CiAgKi8KICNpZm5kZWYgX19LTUFJTF9LTUFUTUxJU1RWSUVXX0hfXwpAQCAtMTUs MjkgKzE1LDI5IEBACiBjbGFzcyBLTUF0bUxpc3RWaWV3SXRlbSA6IHB1YmxpYyBRT2JqZWN0LCBw dWJsaWMgUUxpc3RWaWV3SXRlbQogewogICBRX09CSkVDVAotICBmcmllbmQgY2xhc3MgOjpLTUNv bXBvc2VXaW47Ci0gIGZyaWVuZCBjbGFzcyA6Ok1lc3NhZ2VDb21wb3NlcjsKIAogcHVibGljOgog ICBLTUF0bUxpc3RWaWV3SXRlbShRTGlzdFZpZXcgKiBwYXJlbnQpOwogICB2aXJ0dWFsIH5LTUF0 bUxpc3RWaWV3SXRlbSgpOwotICB2aXJ0dWFsIHZvaWQgcGFpbnRDZWxsKCBRUGFpbnRlciAqIHAs IGNvbnN0IFFDb2xvckdyb3VwICYgY2csCi0gICAgICAgICAgICAgICAgICAgICAgICAgIGludCBj b2x1bW4sIGludCB3aWR0aCwgaW50IGFsaWduICk7CiAKKyAgLy9BIGN1c3RvbSBjb21wYXJlIGZ1 bmN0aW9uIGlzIG5lZWRlZCBiZWNhdXNlIHRoZSBzaXplIGNvbHVtbiBpcworICAvL2h1bWFuLXJl YWRhYmxlIGFuZCB0aGVyZWZvcmUgZG9lc24ndCBzb3J0IGNvcnJlY3RseS4KKyAgdmlydHVhbCBp bnQgY29tcGFyZSggUUxpc3RWaWV3SXRlbSAqaSwgaW50IGNvbCwgYm9vbCBhc2NlbmRpbmcgKSBj b25zdDsKKworICB2aXJ0dWFsIHZvaWQgcGFpbnRDZWxsICggUVBhaW50ZXIgKiBwLCBjb25zdCBR Q29sb3JHcm91cCAmIGNnLCBpbnQgY29sdW1uLCBpbnQgd2lkdGgsIGludCBhbGlnbiApOworCiAg IHZvaWQgc2V0VW5jb21wcmVzc2VkTWltZVR5cGUoIGNvbnN0IFFDU3RyaW5nICYgdHlwZSwgY29u c3QgUUNTdHJpbmcgJiBzdWJ0eXBlICkgewogICAgIG1UeXBlID0gdHlwZTsgbVN1YnR5cGUgPSBz dWJ0eXBlOwogICB9CisgIHZvaWQgc2V0QXR0YWNobWVudFNpemUoIGludCBudW1CeXRlcyApIHsK KyAgICBtQXR0YWNobWVudFNpemUgPSBudW1CeXRlczsKKyAgfQogICB2b2lkIHVuY29tcHJlc3Nl ZE1pbWVUeXBlKCBRQ1N0cmluZyAmIHR5cGUsIFFDU3RyaW5nICYgc3VidHlwZSApIGNvbnN0IHsK ICAgICB0eXBlID0gbVR5cGU7IHN1YnR5cGUgPSBtU3VidHlwZTsKICAgfQogICB2b2lkIHNldFVu Y29tcHJlc3NlZENvZGVjKCBjb25zdCBRQ1N0cmluZyAmIGNvZGVjICkgeyBtQ29kZWMgPSBjb2Rl YzsgfQogICBRQ1N0cmluZyB1bmNvbXByZXNzZWRDb2RlYygpIGNvbnN0IHsgcmV0dXJuIG1Db2Rl YzsgfQogCi1zaWduYWxzOgotICB2b2lkIGNvbXByZXNzKCBpbnQgKTsKLSAgdm9pZCB1bmNvbXBy ZXNzKCBpbnQgKTsKLQotcHJvdGVjdGVkOgogICB2b2lkIGVuYWJsZUNyeXB0b0NCcyhib29sIG9u KTsKICAgdm9pZCBzZXRFbmNyeXB0KGJvb2wgb24pOwogICBib29sIGlzRW5jcnlwdCgpOwpAQCAt NDYsMTYgKzQ2LDI3IEBACiAgIHZvaWQgc2V0Q29tcHJlc3MoYm9vbCBvbik7CiAgIGJvb2wgaXND b21wcmVzcygpOwogCitzaWduYWxzOgorICB2b2lkIGNvbXByZXNzKCBpbnQgKTsKKyAgdm9pZCB1 bmNvbXByZXNzKCBpbnQgKTsKKwogcHJpdmF0ZSBzbG90czoKICAgdm9pZCBzbG90Q29tcHJlc3Mo KTsKKyAgdm9pZCBzbG90SGVhZGVyQ2hhbmdlKGludCwgaW50LCBpbnQpOworICB2b2lkIHNsb3RI ZWFkZXJDbGljayhpbnQpOwogCitwcm90ZWN0ZWQ6CisKKyAgdm9pZCB1cGRhdGVDaGVja0JveChp bnQgaGVhZGVyU2VjdGlvbiwgUUNoZWNrQm94KiBjYik7CisgIHZvaWQgdXBkYXRlQWxsQ2hlY2tC b3hlcygpOworCisKIHByaXZhdGU6Ci0gIFFMaXN0VmlldyogbUxpc3R2aWV3OwogICBRQ2hlY2tC b3gqIG1DQkVuY3J5cHQ7CiAgIFFDaGVja0JveCogbUNCU2lnbjsKICAgUUNoZWNrQm94KiBtQ0JD b21wcmVzczsKLSAgYm9vbCBtQ0JTaWduRW5hYmxlZCwgbUNCRW5jcnlwdEVuYWJsZWQ7CiAgIFFD U3RyaW5nIG1UeXBlLCBtU3VidHlwZSwgbUNvZGVjOworICBpbnQgbUF0dGFjaG1lbnRTaXplOwog fTsKIAogCg== 18430 2006-11-06 00:47:13 +0000 2006-11-06 00:47:13 +0000 Trunk version of the patch kmail-attachment_trunk.diff text/plain 12905 mcguire SW5kZXg6IGttYXRtbGlzdHZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGttYXRtbGlzdHZpZXcuY3Bw CShyZXZpc2lvbiA2MDIzNzIpCisrKyBrbWF0bWxpc3R2aWV3LmNwcAkod29ya2luZyBjb3B5KQpA QCAtNiwxMzkgKzYsMjUgQEAKICNpbmNsdWRlIDxjb25maWcuaD4KIAogI2luY2x1ZGUgImttYXRt bGlzdHZpZXcuaCIKLQotI2luY2x1ZGUgImttbWFpbndpbi5oIgotI2luY2x1ZGUgImttcmVhZGVy bWFpbndpbi5oIgotI2luY2x1ZGUgIm1lc3NhZ2VzZW5kZXIuaCIKLSNpbmNsdWRlICJrbW1zZ3Bh cnRkbGcuaCIKLSNpbmNsdWRlIDxrcGdwYmxvY2suaD4KLSNpbmNsdWRlIDxrYWRkcmJvb2suaD4K LSNpbmNsdWRlICJrbWFkZHJib29rLmgiCi0jaW5jbHVkZSAia21tc2dkaWN0LmgiCi0jaW5jbHVk ZSAia21mb2xkZXJpbWFwLmgiCi0jaW5jbHVkZSAia21mb2xkZXJtZ3IuaCIKLSNpbmNsdWRlICJr bXRyYW5zcG9ydC5oIgotI2luY2x1ZGUgImttY29tbWFuZHMuaCIKLSNpbmNsdWRlICJrY3Vyc29y c2F2ZXIuaCIKLSNpbmNsdWRlICJwYXJ0Tm9kZS5oIgotI2luY2x1ZGUgImF0dGFjaG1lbnRsaXN0 dmlldy5oIgotI2luY2x1ZGUgInRyYW5zcG9ydG1hbmFnZXIuaCIKLXVzaW5nIEtNYWlsOjpBdHRh Y2htZW50TGlzdFZpZXc7Ci0jaW5jbHVkZSAiZGljdGlvbmFyeWNvbWJvYm94LmgiCi11c2luZyBL TWFpbDo6RGljdGlvbmFyeUNvbWJvQm94OwotI2luY2x1ZGUgImFkZHJlc3Nlc2RpYWxvZy5oIgot dXNpbmcgS1BJTTo6QWRkcmVzc2VzRGlhbG9nOwotI2luY2x1ZGUgImFkZHJlc3NlZWVtYWlsc2Vs ZWN0aW9uLmgiCi11c2luZyBLUElNOjpBZGRyZXNzZWVFbWFpbFNlbGVjdGlvbjsKLXVzaW5nIEtQ SU06OkFkZHJlc3NlZVNlbGVjdG9yRGlhbG9nOwotI2luY2x1ZGUgPG1haWxsaXN0ZHJhZy5oPgot dXNpbmcgS1BJTTo6TWFpbExpc3REcmFnOwotI2luY2x1ZGUgInJlY2VudGFkZHJlc3Nlcy5oIgot dXNpbmcgS1JlY2VudEFkZHJlc3M6OlJlY2VudEFkZHJlc3NlczsKLSNpbmNsdWRlICJrbGVvX3V0 aWwuaCIKLSNpbmNsdWRlICJzdGxfdXRpbC5oIgotI2luY2x1ZGUgInJlY2lwaWVudHNlZGl0b3Iu aCIKLQotI2luY2x1ZGUgImF0dGFjaG1lbnRjb2xsZWN0b3IuaCIKLSNpbmNsdWRlICJvYmplY3R0 cmVlcGFyc2VyLmgiCi0KLSNpbmNsdWRlICJrbWZvbGRlcm1haWxkaXIuaCIKLQotI2luY2x1ZGUg PGxpYmtwaW1pZGVudGl0aWVzL2lkZW50aXR5bWFuYWdlci5oPgotI2luY2x1ZGUgPGxpYmtwaW1p ZGVudGl0aWVzL2lkZW50aXR5Y29tYm8uaD4KLSNpbmNsdWRlIDxsaWJrcGltaWRlbnRpdGllcy9p ZGVudGl0eS5oPgotI2luY2x1ZGUgPGxpYmtkZXBpbS9rZmlsZWlvLmg+Ci0jaW5jbHVkZSA8ZW1h aWxmdW5jdGlvbnMvZW1haWwuaD4KLSNpbmNsdWRlIDxrbGVvL2NyeXB0b2JhY2tlbmRmYWN0b3J5 Lmg+Ci0jaW5jbHVkZSA8a2xlby9leHBvcnRqb2IuaD4KLSNpbmNsdWRlIDx1aS9wcm9ncmVzc2Rp YWxvZy5oPgotI2luY2x1ZGUgPHVpL2tleXNlbGVjdGlvbmRpYWxvZy5oPgotCi0jaW5jbHVkZSA8 Z3BnbWVwcC9jb250ZXh0Lmg+Ci0jaW5jbHVkZSA8Z3BnbWVwcC9rZXkuaD4KLQotI2luY2x1ZGUg PGthYmMvdmNhcmRjb252ZXJ0ZXIuaD4KLSNpbmNsdWRlIDxsaWJrZGVwaW0va3ZjYXJkZHJhZy5o PgotI2luY2x1ZGUgPGtpby9uZXRhY2Nlc3MuaD4KLQotCi0jaW5jbHVkZSAia2xpc3Rib3hkaWFs b2cuaCIKLQotI2luY2x1ZGUgIm1lc3NhZ2Vjb21wb3Nlci5oIgotCi0jaW5jbHVkZSA8a2NoYXJz ZXRzLmg+Ci0jaW5jbHVkZSA8a2NvbXBsZXRpb25ib3guaD4KLSNpbmNsdWRlIDxrY3Vyc29yLmg+ Ci0jaW5jbHVkZSA8a2NvbWJvYm94Lmg+Ci0jaW5jbHVkZSA8a3N0ZGFjY2VsLmg+Ci0jaW5jbHVk ZSA8a21lbnUuaD4KLSNpbmNsdWRlIDxrZWRpdHRvb2xiYXIuaD4KLSNpbmNsdWRlIDxra2V5ZGlh bG9nLmg+Ci0jaW5jbHVkZSA8a2RlYnVnLmg+Ci0jaW5jbHVkZSA8a2ZpbGVkaWFsb2cuaD4KLSNp bmNsdWRlIDxrd2luLmg+Ci0jaW5jbHVkZSA8a2lucHV0ZGlhbG9nLmg+Ci0jaW5jbHVkZSA8a21l c3NhZ2Vib3guaD4KLSNpbmNsdWRlIDxraW8vc2NoZWR1bGVyLmg+Ci0jaW5jbHVkZSA8a3RlbXBv cmFyeWZpbGUuaD4KLSNpbmNsdWRlIDxrbG9jYWxlLmg+Ci0jaW5jbHVkZSA8a2FwcGxpY2F0aW9u Lmg+Ci0jaW5jbHVkZSA8a3N0YXR1c2Jhci5oPgotI2luY2x1ZGUgPGthY3Rpb24uaD4KLSNpbmNs dWRlIDxrc3RkYWN0aW9uLmg+Ci0jaW5jbHVkZSA8a2RpcndhdGNoLmg+Ci0jaW5jbHVkZSA8a3N0 ZGd1aWl0ZW0uaD4KLSNpbmNsdWRlIDxraWNvbmxvYWRlci5oPgotI2luY2x1ZGUgPGtwdXNoYnV0 dG9uLmg+Ci0jaW5jbHVkZSA8a3J1bi5oPgotI2luY2x1ZGUgPGt0ZW1wZGlyLmg+Ci0vLyNpbmNs dWRlIDxrZWRpdGxpc3Rib3guaD4KLSNpbmNsdWRlICJnbG9iYWxzZXR0aW5ncy5oIgotI2luY2x1 ZGUgInJlcGx5cGhyYXNlcy5oIgotCi0jaW5jbHVkZSA8azNzcGVsbC5oPgotI2luY2x1ZGUgPGsz c3BlbGxkbGcuaD4KLSNpbmNsdWRlIDxzcGVsbGluZ2ZpbHRlci5oPgotI2luY2x1ZGUgPGszc3lu dGF4aGlnaGxpZ2h0ZXIuaD4KLSNpbmNsdWRlIDxrY29sb3JkaWFsb2cuaD4KLSNpbmNsdWRlIDxr emlwLmg+Ci0jaW5jbHVkZSA8a3NhdmVmaWxlLmg+Ci0KLSNpbmNsdWRlIDxxM3RhYmRpYWxvZy5o PgotI2luY2x1ZGUgPFFSZWdFeHA+Ci0jaW5jbHVkZSA8UUJ1ZmZlcj4KLSNpbmNsdWRlIDxRVG9v bFRpcD4KLSNpbmNsdWRlIDxRVGV4dENvZGVjPgorI2luY2x1ZGUgPHFjaGVja2JveC5oPgogI2lu Y2x1ZGUgPHEzaGVhZGVyLmg+Ci0jaW5jbHVkZSA8cTN3aGF0c3RoaXMuaD4KLSNpbmNsdWRlIDxR Rm9udERhdGFiYXNlPgogCi0jaW5jbHVkZSA8bWltZWxpYi9taW1lcHAuaD4KLQotI2luY2x1ZGUg PGFsZ29yaXRobT4KLQotI2luY2x1ZGUgPHN5cy9zdGF0Lmg+Ci0jaW5jbHVkZSA8c3lzL3R5cGVz Lmg+Ci0jaW5jbHVkZSA8c3RkbGliLmg+Ci0jaW5jbHVkZSA8dW5pc3RkLmg+Ci0jaW5jbHVkZSA8 ZXJybm8uaD4KLSNpbmNsdWRlIDxmY250bC5oPgotI2luY2x1ZGUgPGFzc2VydC5oPgotCiBLTUF0 bUxpc3RWaWV3SXRlbTo6S01BdG1MaXN0Vmlld0l0ZW0oUTNMaXN0VmlldyAqcGFyZW50KQogICA6 IFFPYmplY3QoKSwKLSAgICBRM0xpc3RWaWV3SXRlbSggcGFyZW50ICksCi0gICAgbUxpc3R2aWV3 KCBwYXJlbnQgKSwKLSAgICBtQ0JTaWduRW5hYmxlZCggZmFsc2UgKSwKLSAgICBtQ0JFbmNyeXB0 RW5hYmxlZCggZmFsc2UgKQorICAgIFEzTGlzdFZpZXdJdGVtKCBwYXJlbnQgKQogewotICBtQ0JF bmNyeXB0ID0gbmV3IFFDaGVja0JveCggbUxpc3R2aWV3LT52aWV3cG9ydCgpICk7Ci0gIG1DQlNp Z24gPSBuZXcgUUNoZWNrQm94KCBtTGlzdHZpZXctPnZpZXdwb3J0KCkgKTsKLSAgbUNCQ29tcHJl c3MgPSBuZXcgUUNoZWNrQm94KCBtTGlzdHZpZXctPnZpZXdwb3J0KCkgKTsKLSAgY29ubmVjdCgg bUNCQ29tcHJlc3MsIFNJR05BTCggY2xpY2tlZCgpICksIHRoaXMsIFNMT1QoIHNsb3RDb21wcmVz cygpICkgKTsKKyAgbUNCQ29tcHJlc3MgPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3 cG9ydCgpICk7CisgIG1DQkVuY3J5cHQgPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3 cG9ydCgpICk7CisgIG1DQlNpZ24gPSBuZXcgUUNoZWNrQm94KCBsaXN0VmlldygpLT52aWV3cG9y dCgpICk7CisgIG1DQkNvbXByZXNzLT5zZXRWaXNpYmxlKCB0cnVlICk7CisgIHVwZGF0ZUFsbENo ZWNrQm94ZXMoKTsKIAotICBtQ0JFbmNyeXB0LT5oaWRlKCk7Ci0gIG1DQlNpZ24tPmhpZGUoKTsK KyAgY29ubmVjdCggbUNCQ29tcHJlc3MsIFNJR05BTCggY2xpY2tlZCgpICksIHRoaXMsIFNMT1Qo IHNsb3RDb21wcmVzcygpICkgKTsKKyAgY29ubmVjdCggbGlzdFZpZXcoKS0+aGVhZGVyKCksIFNJ R05BTCggc2l6ZUNoYW5nZShpbnQsIGludCwgaW50KSApLAorICAgICAgICAgICBTTE9UKCBzbG90 SGVhZGVyQ2hhbmdlKGludCwgaW50LCBpbnQpICkgKTsKKyAgY29ubmVjdCggbGlzdFZpZXcoKS0+ aGVhZGVyKCksIFNJR05BTCggaW5kZXhDaGFuZ2UoaW50LCBpbnQsIGludCkgKSwKKyAgICAgICAg ICAgU0xPVCggc2xvdEhlYWRlckNoYW5nZShpbnQsIGludCwgaW50KSApICk7CisgIGNvbm5lY3Qo IGxpc3RWaWV3KCktPmhlYWRlcigpLCBTSUdOQUwoIGNsaWNrZWQoIGludCApICksIFNMT1QoIHNs b3RIZWFkZXJDbGljayggaW50ICkgKSApOwogfQogCiBLTUF0bUxpc3RWaWV3SXRlbTo6fktNQXRt TGlzdFZpZXdJdGVtKCkKQEAgLTE1MSw5MSArMzcsNjggQEAKICAgbUNCQ29tcHJlc3MgPSAwOwog fQogCi12b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjpwYWludENlbGwoIFFQYWludGVyICogcCwgY29u c3QgUUNvbG9yR3JvdXAgJiBjZywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBp bnQgY29sdW1uLCBpbnQgd2lkdGgsIGludCBhbGlnbiApCit2b2lkIEtNQXRtTGlzdFZpZXdJdGVt Ojp1cGRhdGVDaGVja0JveChpbnQgaGVhZGVyU2VjdGlvbiwgUUNoZWNrQm94KiBjYikKIHsKLSAg Ly8gdGhpcyBpcyBhbHNvIGNhbGxlZCBmb3IgdGhlIGVuY3J5cHQvc2lnbiBjb2x1bW5zIHRvIGFz c3VyZSB0aGF0IHRoZQotICAvLyBiYWNrZ3JvdW5kIGlzIGNsZWFyZWQKLSAgUTNMaXN0Vmlld0l0 ZW06OnBhaW50Q2VsbCggcCwgY2csIGNvbHVtbiwgd2lkdGgsIGFsaWduICk7Ci0gIGlmICggNCA9 PSBjb2x1bW4gKSB7Ci0gICAgUVJlY3QgciA9IG1MaXN0dmlldy0+aXRlbVJlY3QoIHRoaXMgKTsK LSAgICBpZiAoICFyLnNpemUoKS5pc1ZhbGlkKCkgKSB7Ci0gICAgICAgIG1MaXN0dmlldy0+ZW5z dXJlSXRlbVZpc2libGUoIHRoaXMgKTsKLSAgICAgICAgbUxpc3R2aWV3LT5yZXBhaW50Q29udGVu dHMoIGZhbHNlICk7Ci0gICAgICAgIHIgPSBtTGlzdHZpZXctPml0ZW1SZWN0KCB0aGlzICk7Ci0g ICAgfQotICAgIGludCBjb2xXaWR0aCA9IG1MaXN0dmlldy0+aGVhZGVyKCktPnNlY3Rpb25TaXpl KCBjb2x1bW4gKTsKLSAgICByLnNldFgoIG1MaXN0dmlldy0+aGVhZGVyKCktPnNlY3Rpb25Qb3Mo IGNvbHVtbiApCi0gICAgICAgICAgICAtIG1MaXN0dmlldy0+aGVhZGVyKCktPm9mZnNldCgpCi0g ICAgICAgICAgICArIGNvbFdpZHRoIC8gMgotICAgICAgICAgICAgLSByLmhlaWdodCgpIC8gMgot ICAgICAgICAgICAgLSAxICk7Ci0gICAgci5zZXRZKCByLnkoKSArIDEgKTsKLSAgICByLnNldFdp ZHRoKCAgci5oZWlnaHQoKSAtIDIgKTsKLSAgICByLnNldEhlaWdodCggci5oZWlnaHQoKSAtIDIg KTsKLSAgICByID0gUVJlY3QoIG1MaXN0dmlldy0+dmlld3BvcnRUb0NvbnRlbnRzKCByLnRvcExl ZnQoKSApLCByLnNpemUoKSApOworICAvL0NhbGN1bGF0ZSBzb21lIHZhbHVlcyB0byBkZXRlcm1p bmUgdGhlIHgtcG9zaXRpb24gd2hlcmUgdGhlIGNoZWNrYm94CisgIC8vd2lsbCBiZSBkcmF3bgor ICBpbnQgc2VjdGlvbldpZHRoID0gbGlzdFZpZXcoKS0+aGVhZGVyKCktPnNlY3Rpb25TaXplKCBo ZWFkZXJTZWN0aW9uICk7CisgIGludCBzZWN0aW9uUG9zID0gbGlzdFZpZXcoKS0+aGVhZGVyKCkt PnNlY3Rpb25Qb3MoIGhlYWRlclNlY3Rpb24gKTsKKyAgaW50IHNlY3Rpb25PZmZzZXQgPSBzZWN0 aW9uV2lkdGggLyAyIC0gaGVpZ2h0KCkgLyA0OwogCi0gICAgbUNCQ29tcHJlc3MtPnJlc2l6ZSgg ci5zaXplKCkgKTsKLSAgICBtTGlzdHZpZXctPm1vdmVDaGlsZCggbUNCQ29tcHJlc3MsIHIueCgp LCByLnkoKSApOworICAvL1Jlc2l6ZSBhbmQgbW92ZSB0aGUgY2hlY2tib3gKKyAgY2ItPnJlc2l6 ZSggc2VjdGlvbldpZHRoIC0gc2VjdGlvbk9mZnNldCAtIDEsIGhlaWdodCgpIC0gMiApOworICBs aXN0VmlldygpLT5tb3ZlQ2hpbGQoIGNiLCBzZWN0aW9uUG9zICsgc2VjdGlvbk9mZnNldCwgaXRl bVBvcygpICsgMSApOwogCi0gICAgUUNvbG9yIGJnOwotICAgIGlmIChpc1NlbGVjdGVkKCkpCi0g ICAgICBiZyA9IGNnLmNvbG9yKCBRUGFsZXR0ZTo6SGlnaGxpZ2h0ICk7Ci0gICAgZWxzZQotICAg ICAgYmcgPSBjZy5jb2xvciggUVBhbGV0dGU6OkJhc2UgKTsKKyAgLy9TZXQgdGhlIGNvcnJlY3Qg YmFja2dyb3VuZCBjb2xvcgorICBpZiAoaXNTZWxlY3RlZCgpKQorICAgIGNiLT5zZXRCYWNrZ3Jv dW5kUm9sZSggUVBhbGV0dGU6OkhpZ2hsaWdodCApOyAgICAKKyAgZWxzZSAgCisgICAgY2ItPnNl dEJhY2tncm91bmRSb2xlKCBRUGFsZXR0ZTo6UVBhbGV0dGU6OkJhc2UgKTsgICAgCit9CiAKLSAg ICBRUGFsZXR0ZSBwYWw7Ci0gICAgcGFsLnNldENvbG9yKCBtQ0JDb21wcmVzcy0+YmFja2dyb3Vu ZFJvbGUoKSwgYmcgKTsKLSAgICBtQ0JDb21wcmVzcy0+c2V0UGFsZXR0ZShwYWwpOwotICAgIG1D QkNvbXByZXNzLT5zaG93KCk7Cit2b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjp1cGRhdGVBbGxDaGVj a0JveGVzKCkKK3sKKyAgdXBkYXRlQ2hlY2tCb3goIDQsIG1DQkNvbXByZXNzICk7CisgIHVwZGF0 ZUNoZWNrQm94KCA1LCBtQ0JFbmNyeXB0ICk7CisgIHVwZGF0ZUNoZWNrQm94KCA2LCBtQ0JTaWdu ICk7Cit9CisKKy8vRWFjaCB0aW1lIGEgY2VsbCBpcyBhYm91dCB0byBiZSBwYWludGVkLCB0aGUg aXRlbSdzIGNoZWNrYm94ZXMgYXJlIHVwZGF0ZWQgYXMgd2VsbC4KKy8vVGhpcyBpcyBuZWNlc3Nh cnkgdG8ga2VlcCB0aGUgcG9zaXRpb25zIG9mIHRoZSBjaGVja2JveGVzIHVwLXRvLWRhdGUuCisv L1RoZSBzaWduYWxzIHdoaWNoIGFyZSwgaW4gdGhlIGNvbnN0cnVjdG9yIG9mIHRoaXMgY2xhc3Ms IGNvbm5lY3RlZCB0byB0aGUgdXBkYXRlIHNsb3RzCisvL2FyZSBub3Qgc3VmZmljZW50IGJlY2F1 c2UgdW5mb3J0dW5hdGx5LCBRdCBkb2VzIG5vdCBwcm92aWRlIGEgc2lnbmFsIGZvciBjaGFuZ2Vk IGl0ZW0gcG9zaXRpb25zLAorLy9lLmcuIGR1cmluZyBkZWxldGluZyBvciBhZGRpbmcgaXRlbXMu IFRoZSBwcm9ibGVtIHdpdGggdGhpcyBpcyB0aGF0IHRoaXMgZnVuY3Rpb24gCisvL2RvZXMgbm90 IGNhdGNoIHVwZGF0ZXMgd2hpY2ggYXJlIG9mZi1zY3JlZW4sIHdoaWNoIG1lYW5zIHVuZGVyIHNv bWUgY2lyY3Vtc3RhbmNlcyBjaGVja2JveGVzCisvL2hhdmUgaW52YWxpZCBwb3NpdGlvbnMuIFRo aXMgc2hvdWxkIG5vdCBoYXBwZW4gYW55bW9yZSwgYnV0IHdhcyB0aGUgY2F1c2Ugb2YgYnVnIDEx MzQ1OC4KKy8vVGhlcmVmb3JlLCBib3RoIHRoZSBzaWduYWxzIGNvbm5lY3RlZCBpbiB0aGUgY29u c3RydWN0b3IgYW5kIHRoaXMgZnVuY3Rpb24gYXJlIG5lY2Vzc2FyeSB0bworLy9rZWVwIHRoZSBj aGVja2JveGVzJyBwb3NpdGlvbnMgaW4gc3luYywgYW5kIGhvcGVmdWxseSBpcyBlbm91Z2guCit2 b2lkIEtNQXRtTGlzdFZpZXdJdGVtOjpwYWludENlbGwgKCBRUGFpbnRlciAqIHAsIGNvbnN0IFFD b2xvckdyb3VwICYgY2csIGludCBjb2x1bW4sIGludCB3aWR0aCwgaW50IGFsaWduICkKK3sKKyAg c3dpdGNoIChjb2x1bW4pCisgIHsKKyAgICBjYXNlIDQ6IHVwZGF0ZUNoZWNrQm94KCA0LCBtQ0JD b21wcmVzcyApOyBicmVhazsKKyAgICBjYXNlIDU6IHVwZGF0ZUNoZWNrQm94KCA1LCBtQ0JFbmNy eXB0ICk7IGJyZWFrOworICAgIGNhc2UgNjogdXBkYXRlQ2hlY2tCb3goIDYsIG1DQlNpZ24gKTsg YnJlYWs7CiAgIH0KLSAgaWYoIDUgPT0gY29sdW1uIHx8IDYgPT0gY29sdW1uICkgewotICAgIFFS ZWN0IHIgPSBtTGlzdHZpZXctPml0ZW1SZWN0KCB0aGlzICk7Ci0gICAgaWYgKCAhci5zaXplKCku aXNWYWxpZCgpICkgewotICAgICAgICBtTGlzdHZpZXctPmVuc3VyZUl0ZW1WaXNpYmxlKCB0aGlz ICk7Ci0gICAgICAgIG1MaXN0dmlldy0+cmVwYWludENvbnRlbnRzKCBmYWxzZSApOwotICAgICAg ICByID0gbUxpc3R2aWV3LT5pdGVtUmVjdCggdGhpcyApOwotICAgIH0KLSAgICBpbnQgY29sV2lk dGggPSBtTGlzdHZpZXctPmhlYWRlcigpLT5zZWN0aW9uU2l6ZSggY29sdW1uICk7Ci0gICAgci5z ZXRYKCBtTGlzdHZpZXctPmhlYWRlcigpLT5zZWN0aW9uUG9zKCBjb2x1bW4gKQotICAgICAgICAg ICAgKyBjb2xXaWR0aCAvIDIKLSAgICAgICAgICAgIC0gci5oZWlnaHQoKSAvIDIKLSAgICAgICAg ICAgIC0gMSApOwotICAgIHIuc2V0WSggci55KCkgKyAxICk7Ci0gICAgci5zZXRXaWR0aCggIHIu aGVpZ2h0KCkgLSAyICk7Ci0gICAgci5zZXRIZWlnaHQoIHIuaGVpZ2h0KCkgLSAyICk7Ci0gICAg ciA9IFFSZWN0KCBtTGlzdHZpZXctPnZpZXdwb3J0VG9Db250ZW50cyggci50b3BMZWZ0KCkgKSwg ci5zaXplKCkgKTsKIAotICAgIFFDaGVja0JveCogY2IgPSAoNSA9PSBjb2x1bW4pID8gbUNCRW5j cnlwdCA6IG1DQlNpZ247Ci0gICAgY2ItPnJlc2l6ZSggci5zaXplKCkgKTsKLSAgICBtTGlzdHZp ZXctPm1vdmVDaGlsZCggY2IsIHIueCgpLCByLnkoKSApOworICBRM0xpc3RWaWV3SXRlbTo6cGFp bnRDZWxsKCBwLCBjZywgY29sdW1uLCB3aWR0aCwgYWxpZ24gKTsKK30KIAotICAgIFFDb2xvciBi ZzsKLSAgICBpZiAoaXNTZWxlY3RlZCgpKQotICAgICAgYmcgPSBjZy5jb2xvciggUVBhbGV0dGU6 OkhpZ2hsaWdodCApOwotICAgIGVsc2UKLSAgICAgIGJnID0gY2cuY29sb3IoIFFQYWxldHRlOjpC YXNlICk7CitpbnQgS01BdG1MaXN0Vmlld0l0ZW06OmNvbXBhcmUoIFEzTGlzdFZpZXdJdGVtICpp LCBpbnQgY29sLCBib29sIGFzY2VuZGluZyApIGNvbnN0Cit7CisgIGlmIChjb2wgIT0gMSkKKyAg ICByZXR1cm4gUTNMaXN0Vmlld0l0ZW06OmNvbXBhcmUoaSwgY29sLCBhc2NlbmRpbmcpOwogCi0g ICAgUVBhbGV0dGUgcGFsOwotICAgIHBhbC5zZXRDb2xvciggY2ItPmJhY2tncm91bmRSb2xlKCks IGJnICk7Ci0gICAgY2ItPnNldFBhbGV0dGUoIHBhbCApOwotICAgIGJvb2wgZW5hYmxlZCA9ICg1 ID09IGNvbHVtbikgPyBtQ0JFbmNyeXB0RW5hYmxlZCA6IG1DQlNpZ25FbmFibGVkOwotICAgIGlm IChlbmFibGVkKSBjYi0+c2hvdygpOwotICB9CisgIHJldHVybiBtQXR0YWNobWVudFNpemUgLSAo c3RhdGljX2Nhc3Q8S01BdG1MaXN0Vmlld0l0ZW0qPihpKSktPm1BdHRhY2htZW50U2l6ZTsKIH0K IAogdm9pZCBLTUF0bUxpc3RWaWV3SXRlbTo6ZW5hYmxlQ3J5cHRvQ0JzKGJvb2wgb24pCiB7Ci0g IGlmKCBtQ0JFbmNyeXB0ICkgewotICAgIG1DQkVuY3J5cHRFbmFibGVkID0gb247Ci0gICAgbUNC RW5jcnlwdC0+c2V0RW5hYmxlZCggb24gKTsKLSAgICBtQ0JFbmNyeXB0LT5zZXRWaXNpYmxlKCBv biApOwotICB9Ci0gIGlmKCBtQ0JTaWduICkgewotICAgIG1DQlNpZ25FbmFibGVkID0gb247Ci0g ICAgbUNCU2lnbi0+c2V0RW5hYmxlZCggb24gKTsKLSAgICBtQ0JTaWduLT5zZXRWaXNpYmxlKCBv biApOwotICB9CisgIC8vU2hvdy9IaWRlIHRoZSBhcHByb3ByaWF0ZSBjaGVja2JveGVzLgorICAv L1RoaXMgc2hvdWxkIG5vdCBiZSBuZWNlc3NhcnkgYmVjYXVzZSB0aGUgY2FsbGVyIGhpZGVzIHRo ZSBjb2x1bW5zIGNvbnRhaW5pbmcKKyAgLy90aGUgY2hlY2tib3hlcyBhbnl3YXkuCisgIG1DQkVu Y3J5cHQtPnNldFZpc2libGUoIG9uICk7CisgIG1DQlNpZ24tPnNldFZpc2libGUoIG9uICk7CiB9 CiAKIHZvaWQgS01BdG1MaXN0Vmlld0l0ZW06OnNldEVuY3J5cHQoYm9vbCBvbikKQEAgLTI4NCw0 ICsxNDcsMTggQEAKICAgICAgICAgZW1pdCB1bmNvbXByZXNzKCBpdGVtUG9zKCkgKTsKIH0KIAor Ly9VcGRhdGUgdGhlIGl0ZW0ncyBjaGVja2JveGVzIHdoZW4gdGhlIHBvc2l0aW9uIG9mIHRob3Nl IGNoYW5nZQorLy9kdWUgdG8gZGlmZmVyZW50IGNvbHVtbiBwb3NpdGlvbnMKK3ZvaWQgS01BdG1M aXN0Vmlld0l0ZW06OnNsb3RIZWFkZXJDaGFuZ2UoaW50LCBpbnQsIGludCkKK3sKKyAgdXBkYXRl QWxsQ2hlY2tCb3hlcygpOworfQorCisvL1VwZGF0ZSB0aGUgaXRlbSdzIGNoZWNrYm94ZXMgd2hl biB0aGUgbGlzdCBpcyBiZWluZyBzb3J0ZWQKK3ZvaWQgS01BdG1MaXN0Vmlld0l0ZW06OnNsb3RI ZWFkZXJDbGljayhpbnQpCit7CisgIHVwZGF0ZUFsbENoZWNrQm94ZXMoKTsKK30KKworCiAjaW5j bHVkZSAia21hdG1saXN0dmlldy5tb2MiCkluZGV4OiBrbWNvbXBvc2V3aW4uY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIGttY29tcG9zZXdpbi5jcHAJKHJldmlzaW9uIDYwMjM3MikKKysrIGttY29tcG9zZXdp bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIyMzUsNiArMjIzNSw3IEBACiAgIGx2aS0+c2V0VGV4 dCgxLCBLSU86OmNvbnZlcnRTaXplKCBtc2dQYXJ0LT5kZWNvZGVkU2l6ZSgpKSk7CiAgIGx2aS0+ c2V0VGV4dCgyLCBtc2dQYXJ0LT5jb250ZW50VHJhbnNmZXJFbmNvZGluZ1N0cigpKTsKICAgbHZp LT5zZXRUZXh0KDMsIHByZXR0eU1pbWVUeXBlKG1zZ1BhcnQtPnR5cGVTdHIoKSArICcvJyArIG1z Z1BhcnQtPnN1YnR5cGVTdHIoKSkpOworICBsdmktPnNldEF0dGFjaG1lbnRTaXplKG1zZ1BhcnQt PmRlY29kZWRTaXplKCkpOwogCiAgIGlmICggbG9hZERlZmF1bHRzICkgewogICAgIGlmKCBjYW5T aWduRW5jcnlwdEF0dGFjaG1lbnRzKCkgKSB7CkluZGV4OiBrbWF0bWxpc3R2aWV3LmgKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0ga21hdG1saXN0dmlldy5oCShyZXZpc2lvbiA2MDIzNzIpCisrKyBrbWF0bWxpc3R2 aWV3LmgJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw1IEBACiAvKiAtKi0gbW9kZTogQysrOyBj LWZpbGUtc3R5bGU6ICJnbnUiIC0qLQotICogS01Db21wb3NlV2luIEhlYWRlciBGaWxlCisgKiBL TUF0bUxpc3RWaWV3SXRlbSBIZWFkZXIgRmlsZQogICogQXV0aG9yOiBNYXJrdXMgV3VlYmJlbiA8 bWFya3VzLnd1ZWJiZW5Aa2RlLm9yZz4KICAqLwogI2lmbmRlZiBfX0tNQUlMX0tNQVRNTElTVFZJ RVdfSF9fCkBAIC0xNSwyOSArMTUsMjkgQEAKIGNsYXNzIEtNQXRtTGlzdFZpZXdJdGVtIDogcHVi bGljIFFPYmplY3QsIHB1YmxpYyBRM0xpc3RWaWV3SXRlbQogewogICBRX09CSkVDVAotICBmcmll bmQgY2xhc3MgOjpLTUNvbXBvc2VXaW47Ci0gIGZyaWVuZCBjbGFzcyA6Ok1lc3NhZ2VDb21wb3Nl cjsKIAogcHVibGljOgogICBLTUF0bUxpc3RWaWV3SXRlbShRM0xpc3RWaWV3ICogcGFyZW50KTsK ICAgdmlydHVhbCB+S01BdG1MaXN0Vmlld0l0ZW0oKTsKLSAgdmlydHVhbCB2b2lkIHBhaW50Q2Vs bCggUVBhaW50ZXIgKiBwLCBjb25zdCBRQ29sb3JHcm91cCAmIGNnLAotICAgICAgICAgICAgICAg ICAgICAgICAgICBpbnQgY29sdW1uLCBpbnQgd2lkdGgsIGludCBhbGlnbiApOwogCisgIC8vQSBj dXN0b20gY29tcGFyZSBmdW5jdGlvbiBpcyBuZWVkZWQgYmVjYXVzZSB0aGUgc2l6ZSBjb2x1bW4g aXMKKyAgLy9odW1hbi1yZWFkYWJsZSBhbmQgdGhlcmVmb3JlIGRvZXNuJ3Qgc29ydCBjb3JyZWN0 bHkuCisgIHZpcnR1YWwgaW50IGNvbXBhcmUoIFEzTGlzdFZpZXdJdGVtICppLCBpbnQgY29sLCBi b29sIGFzY2VuZGluZyApIGNvbnN0OworCisgIHZpcnR1YWwgdm9pZCBwYWludENlbGwgKCBRUGFp bnRlciAqIHAsIGNvbnN0IFFDb2xvckdyb3VwICYgY2csIGludCBjb2x1bW4sIGludCB3aWR0aCwg aW50IGFsaWduICk7CisKICAgdm9pZCBzZXRVbmNvbXByZXNzZWRNaW1lVHlwZSggY29uc3QgUUJ5 dGVBcnJheSAmIHR5cGUsIGNvbnN0IFFCeXRlQXJyYXkgJiBzdWJ0eXBlICkgewogICAgIG1UeXBl ID0gdHlwZTsgbVN1YnR5cGUgPSBzdWJ0eXBlOwogICB9CisgIHZvaWQgc2V0QXR0YWNobWVudFNp emUoIGludCBudW1CeXRlcyApIHsKKyAgICBtQXR0YWNobWVudFNpemUgPSBudW1CeXRlczsKKyAg fQogICB2b2lkIHVuY29tcHJlc3NlZE1pbWVUeXBlKCBRQnl0ZUFycmF5ICYgdHlwZSwgUUJ5dGVB cnJheSAmIHN1YnR5cGUgKSBjb25zdCB7CiAgICAgdHlwZSA9IG1UeXBlOyBzdWJ0eXBlID0gbVN1 YnR5cGU7CiAgIH0KICAgdm9pZCBzZXRVbmNvbXByZXNzZWRDb2RlYyggY29uc3QgUUJ5dGVBcnJh eSAmIGNvZGVjICkgeyBtQ29kZWMgPSBjb2RlYzsgfQogICBRQnl0ZUFycmF5IHVuY29tcHJlc3Nl ZENvZGVjKCkgY29uc3QgeyByZXR1cm4gbUNvZGVjOyB9CiAKLXNpZ25hbHM6Ci0gIHZvaWQgY29t cHJlc3MoIGludCApOwotICB2b2lkIHVuY29tcHJlc3MoIGludCApOwotCi1wcm90ZWN0ZWQ6CiAg IHZvaWQgZW5hYmxlQ3J5cHRvQ0JzKGJvb2wgb24pOwogICB2b2lkIHNldEVuY3J5cHQoYm9vbCBv bik7CiAgIGJvb2wgaXNFbmNyeXB0KCk7CkBAIC00NiwxNiArNDYsMjQgQEAKICAgdm9pZCBzZXRD b21wcmVzcyhib29sIG9uKTsKICAgYm9vbCBpc0NvbXByZXNzKCk7CiAKK3NpZ25hbHM6CisgIHZv aWQgY29tcHJlc3MoIGludCApOworICB2b2lkIHVuY29tcHJlc3MoIGludCApOworCiBwcml2YXRl IHNsb3RzOgogICB2b2lkIHNsb3RDb21wcmVzcygpOworICB2b2lkIHNsb3RIZWFkZXJDaGFuZ2Uo aW50LCBpbnQsIGludCk7CisgIHZvaWQgc2xvdEhlYWRlckNsaWNrKGludCk7CiAKIHByaXZhdGU6 Ci0gIFEzTGlzdFZpZXcqIG1MaXN0dmlldzsKKyAgdm9pZCB1cGRhdGVDaGVja0JveChpbnQgaGVh ZGVyU2VjdGlvbiwgUUNoZWNrQm94KiBjYik7CisgIHZvaWQgdXBkYXRlQWxsQ2hlY2tCb3hlcygp OworCiAgIFFDaGVja0JveCogbUNCRW5jcnlwdDsKICAgUUNoZWNrQm94KiBtQ0JTaWduOwogICBR Q2hlY2tCb3gqIG1DQkNvbXByZXNzOwotICBib29sIG1DQlNpZ25FbmFibGVkLCBtQ0JFbmNyeXB0 RW5hYmxlZDsKICAgUUJ5dGVBcnJheSBtVHlwZSwgbVN1YnR5cGUsIG1Db2RlYzsKKyAgaW50IG1B dHRhY2htZW50U2l6ZTsKIH07CiAKIAo=