pax_global_header00006660000000000000000000000064130146277010014513gustar00rootroot0000000000000052 comment=6517249fa29a2b3ab61124d808d73490891cc4e8 advancecomp-1.23/000077500000000000000000000000001301462770100137205ustar00rootroot00000000000000advancecomp-1.23/.gitignore000066400000000000000000000005731301462770100157150ustar00rootroot00000000000000# upload makepush.sh # archives *.zip *.tar.gz # objects *.o *.exe advdef advmng advpng advzip # docs doc/*.hh doc/*.html # autotools Makefile Makefile.in compile aclocal.m4 autom4te.cache/ config.guess config.h config.h.in~ config.h.in config.log config.status config.sub configure install-sh missing stamp-h1 .dirstamp # projects *.dst *.epr # others resource/ archive/ advancecomp-1.23/.travis.yml000066400000000000000000000002471301462770100160340ustar00rootroot00000000000000# Travis CI configuration file sudo: false language: c script: autoreconf -i && ./configure && make distcheck compiler: - clang - gcc os: - linux - osx advancecomp-1.23/7z/000077500000000000000000000000001301462770100142605ustar00rootroot00000000000000advancecomp-1.23/7z/7z.h000066400000000000000000000015031301462770100147700ustar00rootroot00000000000000#ifndef __7Z_H #define __7Z_H bool compress_deflate_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned num_passes, unsigned num_fast_bytes) throw (); bool decompress_deflate_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) throw (); bool compress_rfc1950_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned num_passes, unsigned num_fast_bytes) throw (); bool compress_lzma_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned algo, unsigned dictionary_size, unsigned num_fast_bytes) throw (); bool decompress_lzma_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) throw (); #endif advancecomp-1.23/7z/7zdeflate.cc000066400000000000000000000043151301462770100164570ustar00rootroot00000000000000#include "7z.h" #include "DeflateEncoder.h" #include "DeflateDecoder.h" #include "zlib.h" bool compress_deflate_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned num_passes, unsigned num_fast_bytes) throw () { try { NDeflate::NEncoder::CCoder cc; if (cc.SetEncoderNumPasses(num_passes) != S_OK) return false; if (cc.SetEncoderNumFastBytes(num_fast_bytes) != S_OK) return false; ISequentialInStream in(reinterpret_cast(in_data), in_size); ISequentialOutStream out(reinterpret_cast(out_data), out_size); UINT64 in_size_l = in_size; if (cc.Code(&in, &out, &in_size_l) != S_OK) return false; out_size = out.size_get(); if (out.overflow_get()) return false; return true; } catch (...) { return false; } } bool decompress_deflate_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) throw () { try { NDeflate::NDecoder::CCoder cc; ISequentialInStream in(reinterpret_cast(in_data), in_size); ISequentialOutStream out(reinterpret_cast(out_data), out_size); UINT64 in_size_l = in_size; UINT64 out_size_l = out_size; if (cc.Code(&in, &out, &in_size_l, &out_size_l) != S_OK) return false; if (out.size_get() != out_size || out.overflow_get()) return false; return true; } catch (...) { return false; } } bool compress_rfc1950_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned num_passes, unsigned num_fast_bytes) throw () { if (out_size < 6) return false; // 8 - deflate // 7 - 32k window // 3 - max compression unsigned header = (8 << 8) | (7 << 12) | (3 << 6); header += 31 - (header % 31); out_data[0] = (header >> 8) & 0xFF; out_data[1] = header & 0xFF; out_data += 2; unsigned size = out_size - 6; if (!compress_deflate_7z(in_data, in_size, out_data, size, num_passes, num_fast_bytes)) { return false; } out_data += size; unsigned adler = adler32(adler32(0,0,0), in_data, in_size); out_data[0] = (adler >> 24) & 0xFF; out_data[1] = (adler >> 16) & 0xFF; out_data[2] = (adler >> 8) & 0xFF; out_data[3] = adler & 0xFF; out_size = size + 6; return true; } advancecomp-1.23/7z/7zlzma.cc000066400000000000000000000033051301462770100160140ustar00rootroot00000000000000#include "7z.h" #include "LZMAEncoder.h" #include "LZMADecoder.h" bool compress_lzma_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, unsigned algo, unsigned dictionary_size, unsigned num_fast_bytes) throw () { try { NCompress::NLZMA::CEncoder cc; // reduce the dictionary size if the file is small while (dictionary_size > 8 && dictionary_size / 2 >= out_size) dictionary_size /= 2; if (cc.SetDictionarySize(dictionary_size) != S_OK) return false; if (cc.SetEncoderNumFastBytes(num_fast_bytes) != S_OK) return false; if (cc.SetEncoderAlgorithm(algo) != S_OK) return false; ISequentialInStream in(reinterpret_cast(in_data), in_size); ISequentialOutStream out(reinterpret_cast(out_data), out_size); UINT64 in_size_l = in_size; if (cc.WriteCoderProperties(&out) != S_OK) return false; if (cc.Code(&in, &out, &in_size_l) != S_OK) return false; out_size = out.size_get(); if (out.overflow_get()) return false; return true; } catch (...) { return false; } } bool decompress_lzma_7z(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) throw () { try { NCompress::NLZMA::CDecoder cc; ISequentialInStream in(reinterpret_cast(in_data), in_size); ISequentialOutStream out(reinterpret_cast(out_data), out_size); UINT64 in_size_l = in_size; UINT64 out_size_l = out_size; if (cc.ReadCoderProperties(&in) != S_OK) return false; if (cc.Code(&in, &out, &in_size_l, &out_size_l) != S_OK) return false; if (out.size_get() != out_size || out.overflow_get()) return false; return true; } catch (...) { return false; } } advancecomp-1.23/7z/AriBitCoder.cc000066400000000000000000000007571301462770100167270ustar00rootroot00000000000000#include "AriBitCoder.h" #include "AriPrice.h" #include namespace NCompression { namespace NArithmetic { static const double kDummyMultMid = (1.0 / kBitPrice) / 2; CPriceTables::CPriceTables() { double aLn2 = log(2); double aLnAll = log(kBitModelTotal >> kNumMoveReducingBits); for(UINT32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++) m_StatePrices[i] = UINT32((fabs(aLnAll - log(i)) / aLn2 + kDummyMultMid) * kBitPrice); } CPriceTables g_PriceTables; }} advancecomp-1.23/7z/AriBitCoder.h000066400000000000000000000046721301462770100165710ustar00rootroot00000000000000#ifndef __COMPRESSION_BITCODER_H #define __COMPRESSION_BITCODER_H #include "RangeCoder.h" namespace NCompression { namespace NArithmetic { const int kNumBitModelTotalBits = 11; const UINT32 kBitModelTotal = (1 << kNumBitModelTotalBits); const int kNumMoveReducingBits = 2; class CPriceTables { public: UINT32 m_StatePrices[kBitModelTotal >> kNumMoveReducingBits]; CPriceTables(); }; extern CPriceTables g_PriceTables; ///////////////////////////// // CBitModel template class CBitModel { public: UINT32 m_Probability; void UpdateModel(UINT32 aSymbol) { if (aSymbol == 0) m_Probability += (kBitModelTotal - m_Probability) >> aNumMoveBits; else m_Probability -= (m_Probability) >> aNumMoveBits; } public: void Init() { m_Probability = kBitModelTotal / 2; } }; template class CBitEncoder: public CBitModel { public: void Encode(CRangeEncoder *aRangeEncoder, UINT32 aSymbol) { aRangeEncoder->EncodeBit(CBitModel::m_Probability, kNumBitModelTotalBits, aSymbol); CBitModel::UpdateModel(aSymbol); } UINT32 GetPrice(UINT32 aSymbol) const { return g_PriceTables.m_StatePrices[ (((CBitModel::m_Probability - aSymbol) ^ ((-(int)aSymbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits]; } }; template class CBitDecoder: public CBitModel { public: UINT32 Decode(CRangeDecoder *aRangeDecoder) { UINT32 aNewBound = (aRangeDecoder->m_Range >> kNumBitModelTotalBits) * CBitModel::m_Probability; if (aRangeDecoder->m_Code < aNewBound) { aRangeDecoder->m_Range = aNewBound; CBitModel::m_Probability += (kBitModelTotal - CBitModel::m_Probability) >> aNumMoveBits; if (aRangeDecoder->m_Range < kTopValue) { aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | aRangeDecoder->m_Stream.ReadByte(); aRangeDecoder->m_Range <<= 8; } return 0; } else { aRangeDecoder->m_Range -= aNewBound; aRangeDecoder->m_Code -= aNewBound; CBitModel::m_Probability -= (CBitModel::m_Probability) >> aNumMoveBits; if (aRangeDecoder->m_Range < kTopValue) { aRangeDecoder->m_Code = (aRangeDecoder->m_Code << 8) | aRangeDecoder->m_Stream.ReadByte(); aRangeDecoder->m_Range <<= 8; } return 1; } } }; }} #endif advancecomp-1.23/7z/AriConst.h000066400000000000000000000007011301462770100161510ustar00rootroot00000000000000#ifndef __ARICONST_H #define __ARICONST_H #include "AriBitCoder.h" typedef NCompression::NArithmetic::CRangeEncoder CMyRangeEncoder; typedef NCompression::NArithmetic::CRangeDecoder CMyRangeDecoder; template class CMyBitEncoder: public NCompression::NArithmetic::CBitEncoder {}; template class CMyBitDecoder: public NCompression::NArithmetic::CBitDecoder {}; #endif advancecomp-1.23/7z/AriPrice.h000066400000000000000000000003361301462770100161310ustar00rootroot00000000000000#ifndef __COMPRESSION_ARIPRICE_H #define __COMPRESSION_ARIPRICE_H namespace NCompression { namespace NArithmetic { const UINT32 kNumBitPriceShiftBits = 6; const UINT32 kBitPrice = 1 << kNumBitPriceShiftBits; }} #endif advancecomp-1.23/7z/BinTree.h000066400000000000000000000023641301462770100157660ustar00rootroot00000000000000#include "Portable.h" #include "WindowIn.h" namespace BT_NAMESPACE { typedef UINT32 CIndex; const UINT32 kMaxValForNormalize = (UINT32(1) << 31) - 1; struct CPair { CIndex Left; CIndex Right; }; class CInTree: public NStream::NWindow::CIn { UINT32 m_HistorySize; UINT32 m_MatchMaxLen; CIndex *m_Hash; #ifdef HASH_ARRAY_2 CIndex *m_Hash2; #ifdef HASH_ARRAY_3 CIndex *m_Hash3; #endif #endif CPair *m_Son; CPair *m_Base; UINT32 m_CutValue; void NormalizeLinks(CIndex *anArray, UINT32 aNumItems, INT32 aSubValue); void Normalize(); void FreeMemory(); protected: virtual void AfterMoveBlock(); public: CInTree(); ~CInTree(); HRESULT Create(UINT32 aSizeHistory, UINT32 aKeepAddBufferBefore, UINT32 aMatchMaxLen, UINT32 aKeepAddBufferAfter, UINT32 _dwSizeReserv = (1<<17)); HRESULT Init(ISequentialInStream *aStream); void SetCutValue(UINT32 aCutValue) { m_CutValue = aCutValue; } UINT32 GetLongestMatch(UINT32 *aDistances); void DummyLongestMatch(); HRESULT MovePos() { RETURN_IF_NOT_S_OK(CIn::MovePos()); if (m_Pos == kMaxValForNormalize) Normalize(); return S_OK; } void ReduceOffsets(INT32 aSubValue) { CIn::ReduceOffsets(aSubValue); m_Son += aSubValue; } }; } advancecomp-1.23/7z/BinTree2.h000066400000000000000000000002641301462770100160450ustar00rootroot00000000000000#ifndef __BINTREE2__H #define __BINTREE2__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT2 #undef BT_NAMESPACE #define BT_NAMESPACE NBT2 #include "BinTreeMF.h" #endif advancecomp-1.23/7z/BinTree2Main.h000066400000000000000000000003001301462770100166410ustar00rootroot00000000000000#ifndef __BINTREE2MAIN__H #define __BINTREE2MAIN__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT2 #undef BT_NAMESPACE #define BT_NAMESPACE NBT2 #include "BinTreeMFMain.h" #endif advancecomp-1.23/7z/BinTree3.h000066400000000000000000000003371301462770100160470ustar00rootroot00000000000000#ifndef __BINTREE3__H #define __BINTREE3__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT3 #undef BT_NAMESPACE #define BT_NAMESPACE NBT3 #define HASH_ARRAY_2 #include "BinTreeMF.h" #undef HASH_ARRAY_2 #endif advancecomp-1.23/7z/BinTree3Main.h000066400000000000000000000003531301462770100166520ustar00rootroot00000000000000#ifndef __BINTREE3MAIN__H #define __BINTREE3MAIN__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT3 #undef BT_NAMESPACE #define BT_NAMESPACE NBT3 #define HASH_ARRAY_2 #include "BinTreeMFMain.h" #undef HASH_ARRAY_2 #endif advancecomp-1.23/7z/BinTree3Z.h000066400000000000000000000002401301462770100161720ustar00rootroot00000000000000#ifndef __BINTREE3Z__H #define __BINTREE3Z__H #undef BT_NAMESPACE #define BT_NAMESPACE NBT3Z #define HASH_ZIP #include "BinTree.h" #undef HASH_ZIP #endif advancecomp-1.23/7z/BinTree3ZMain.h000066400000000000000000000002541301462770100170040ustar00rootroot00000000000000#ifndef __BINTREE3ZMAIN__H #define __BINTREE3ZMAIN__H #undef BT_NAMESPACE #define BT_NAMESPACE NBT3Z #define HASH_ZIP #include "BinTreeMain.h" #undef HASH_ZIP #endif advancecomp-1.23/7z/BinTree4.h000066400000000000000000000004101301462770100160400ustar00rootroot00000000000000#ifndef __BINTREE4__H #define __BINTREE4__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT4 #undef BT_NAMESPACE #define BT_NAMESPACE NBT4 #define HASH_ARRAY_2 #define HASH_ARRAY_3 #include "BinTreeMF.h" #undef HASH_ARRAY_2 #undef HASH_ARRAY_3 #endif advancecomp-1.23/7z/BinTree4Main.h000066400000000000000000000004241301462770100166520ustar00rootroot00000000000000#ifndef __BINTREEMAIN4__H #define __BINTREEMAIN4__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT4 #undef BT_NAMESPACE #define BT_NAMESPACE NBT4 #define HASH_ARRAY_2 #define HASH_ARRAY_3 #include "BinTreeMFMain.h" #undef HASH_ARRAY_2 #undef HASH_ARRAY_3 #endif advancecomp-1.23/7z/BinTree4b.h000066400000000000000000000004551301462770100162130ustar00rootroot00000000000000#ifndef __BINTREE4B__H #define __BINTREE4B__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT4b #undef BT_NAMESPACE #define BT_NAMESPACE NBT4b #define HASH_ARRAY_2 #define HASH_ARRAY_3 #define HASH_BIG #include "BinTreeMF.h" #undef HASH_ARRAY_2 #undef HASH_ARRAY_3 #undef HASH_BIG #endif advancecomp-1.23/7z/BinTree4bMain.h000066400000000000000000000004711301462770100170160ustar00rootroot00000000000000#ifndef __BINTREE4BMAIN__H #define __BINTREE4BMAIN__H #undef BT_CLSID #define BT_CLSID CLSID_CMatchFinderBT4b #undef BT_NAMESPACE #define BT_NAMESPACE NBT4b #define HASH_ARRAY_2 #define HASH_ARRAY_3 #define HASH_BIG #include "BinTreeMFMain.h" #undef HASH_ARRAY_2 #undef HASH_ARRAY_3 #undef HASH_BIG #endif advancecomp-1.23/7z/BinTreeMF.h000066400000000000000000000004551301462770100162100ustar00rootroot00000000000000// #ifndef __BINTREEMF_H // #define __BINTREEMF_H #include "BinTree.h" namespace BT_NAMESPACE { class CMatchFinderBinTree : public CInTree { public: HRESULT Create(UINT32 aSizeHistory, UINT32 aKeepAddBufferBefore, UINT32 aMatchMaxLen, UINT32 aKeepAddBufferAfter); }; } // #endif advancecomp-1.23/7z/BinTreeMFMain.h000066400000000000000000000013001301462770100170030ustar00rootroot00000000000000#include "BinTreeMain.h" namespace BT_NAMESPACE { HRESULT CMatchFinderBinTree::Create(UINT32 aSizeHistory, UINT32 aKeepAddBufferBefore, UINT32 aMatchMaxLen, UINT32 aKeepAddBufferAfter) { const UINT32 kAlignMask = (1 << 16) - 1; UINT32 aWindowReservSize = aSizeHistory / 2; aWindowReservSize += kAlignMask; aWindowReservSize &= ~(kAlignMask); const int kMinDictSize = (1 << 19); if (aWindowReservSize < kMinDictSize) aWindowReservSize = kMinDictSize; aWindowReservSize += 256; try { return CInTree::Create(aSizeHistory, aKeepAddBufferBefore, aMatchMaxLen, aKeepAddBufferAfter, aWindowReservSize); } catch(...) { return E_OUTOFMEMORY; } } } advancecomp-1.23/7z/BinTreeMain.h000066400000000000000000000300631301462770100165700ustar00rootroot00000000000000#include "CRC.h" namespace BT_NAMESPACE { #ifdef HASH_ARRAY_2 static const UINT32 kHash2Size = 1 << 10; #ifdef HASH_ARRAY_3 static const UINT32 kNumHashDirectBytes = 0; static const UINT32 kNumHashBytes = 4; static const UINT32 kHash3Size = 1 << 18; #ifdef HASH_BIG static const UINT32 kHashSize = 1 << 23; #else static const UINT32 kHashSize = 1 << 20; #endif #else static const UINT32 kNumHashDirectBytes = 3; static const UINT32 kNumHashBytes = 3; static const UINT32 kHashSize = 1 << (8 * kNumHashBytes); #endif #else #ifdef HASH_ZIP static const UINT32 kNumHashDirectBytes = 0; static const UINT32 kNumHashBytes = 3; static const UINT32 kHashSize = 1 << 16; #else static const UINT32 kNumHashDirectBytes = 2; static const UINT32 kNumHashBytes = 2; static const UINT32 kHashSize = 1 << (8 * kNumHashBytes); #endif #endif CInTree::CInTree(): #ifdef HASH_ARRAY_2 m_Hash2(0), #ifdef HASH_ARRAY_3 m_Hash3(0), #endif #endif m_Hash(0), m_Base(0), m_CutValue(0xFF) { } void CInTree::FreeMemory() { if (m_Base != 0) delete [] m_Base; if (m_Hash != 0) delete [] m_Hash; m_Base = 0; m_Hash = 0; CIn::Free(); } CInTree::~CInTree() { FreeMemory(); } HRESULT CInTree::Create(UINT32 aSizeHistory, UINT32 aKeepAddBufferBefore, UINT32 aMatchMaxLen, UINT32 aKeepAddBufferAfter, UINT32 aSizeReserv) { FreeMemory(); CIn::Create(aSizeHistory + aKeepAddBufferBefore, aMatchMaxLen + aKeepAddBufferAfter, aSizeReserv); if (m_BlockSize + 256 > kMaxValForNormalize) return E_INVALIDARG; m_HistorySize = aSizeHistory; m_MatchMaxLen = aMatchMaxLen; UINT32 aSize = kHashSize; #ifdef HASH_ARRAY_2 aSize += kHash2Size; #ifdef HASH_ARRAY_3 aSize += kHash3Size; #endif #endif m_Base = new CPair[m_BlockSize + 1]; if (m_Base == 0) return E_OUTOFMEMORY; m_Hash = new CIndex[aSize + 1]; if (m_Hash == 0) return E_OUTOFMEMORY; #ifdef HASH_ARRAY_2 m_Hash2 = &m_Hash[kHashSize]; #ifdef HASH_ARRAY_3 m_Hash3 = &m_Hash2[kHash2Size]; #endif #endif return S_OK; } static const UINT32 kEmptyHashValue = 0; HRESULT CInTree::Init(ISequentialInStream *aStream) { RETURN_IF_NOT_S_OK(CIn::Init(aStream)); unsigned i; for(i = 0; i < kHashSize; i++) m_Hash[i] = kEmptyHashValue; #ifdef HASH_ARRAY_2 for(i = 0; i < kHash2Size; i++) m_Hash2[i] = kEmptyHashValue; #ifdef HASH_ARRAY_3 for(i = 0; i < kHash3Size; i++) m_Hash3[i] = kEmptyHashValue; #endif #endif m_Son = m_Base; ReduceOffsets(0 - 1); return S_OK; } #ifdef HASH_ARRAY_2 #ifdef HASH_ARRAY_3 inline UINT32 Hash(const BYTE *aPointer, UINT32 &aHash2Value, UINT32 &aHash3Value) { UINT32 aTemp = CCRC::m_Table[aPointer[0]] ^ aPointer[1]; aHash2Value = aTemp & (kHash2Size - 1); aHash3Value = (aTemp ^ (UINT32(aPointer[2]) << 8)) & (kHash3Size - 1); return (aTemp ^ (UINT32(aPointer[2]) << 8) ^ (CCRC::m_Table[aPointer[3]] << 5)) & (kHashSize - 1); } #else // no HASH_ARRAY_3 inline UINT32 Hash(const BYTE *aPointer, UINT32 &aHash2Value) { aHash2Value = (CCRC::m_Table[aPointer[0]] ^ aPointer[1]) & (kHash2Size - 1); return (*((const UINT32 *)aPointer)) & 0xFFFFFF; } #endif // HASH_ARRAY_3 #else // no HASH_ARRAY_2 #ifdef HASH_ZIP inline UINT32 Hash(const BYTE *aPointer) { return ((UINT32(aPointer[0]) << 8) ^ CCRC::m_Table[aPointer[1]] ^ aPointer[2]) & (kHashSize - 1); } #else // no HASH_ZIP inline UINT32 Hash(const BYTE *aPointer) { return aPointer[0] ^ (UINT32(aPointer[1]) << 8); } #endif // HASH_ZIP #endif // HASH_ARRAY_2 UINT32 CInTree::GetLongestMatch(UINT32 *aDistances) { UINT32 aCurrentLimit; if (m_Pos + m_MatchMaxLen <= m_StreamPos) aCurrentLimit = m_MatchMaxLen; else { aCurrentLimit = m_StreamPos - m_Pos; if(aCurrentLimit < kNumHashBytes) return 0; } UINT32 aMatchMinPos = (m_Pos > m_HistorySize) ? (m_Pos - m_HistorySize) : 1; BYTE *aCur = m_Buffer + m_Pos; UINT32 aMatchHashLenMax = 0; #ifdef HASH_ARRAY_2 UINT32 aHash2Value; #ifdef HASH_ARRAY_3 UINT32 aHash3Value; UINT32 aHashValue = Hash(aCur, aHash2Value, aHash3Value); #else UINT32 aHashValue = Hash(aCur, aHash2Value); #endif #else UINT32 aHashValue = Hash(aCur); #endif UINT32 aCurMatch = m_Hash[aHashValue]; #ifdef HASH_ARRAY_2 UINT32 aCurMatch2 = m_Hash2[aHash2Value]; #ifdef HASH_ARRAY_3 UINT32 aCurMatch3 = m_Hash3[aHash3Value]; #endif m_Hash2[aHash2Value] = m_Pos; bool aMatchLen2Exist = false; UINT32 aLen2Distance = 0; if(aCurMatch2 >= aMatchMinPos) { if (m_Buffer[aCurMatch2] == aCur[0]) { aLen2Distance = m_Pos - aCurMatch2 - 1; aMatchHashLenMax = 2; aMatchLen2Exist = true; } } #ifdef HASH_ARRAY_3 m_Hash3[aHash3Value] = m_Pos; UINT32 aMatchLen3Exist = false; UINT32 aLen3Distance = 0; if(aCurMatch3 >= aMatchMinPos) { if (m_Buffer[aCurMatch3] == aCur[0]) { aLen3Distance = m_Pos - aCurMatch3 - 1; aMatchHashLenMax = 3; aMatchLen3Exist = true; if (aMatchLen2Exist) { if (aLen3Distance < aLen2Distance) aLen2Distance = aLen3Distance; } else { aLen2Distance = aLen3Distance; aMatchLen2Exist = true; } } } #endif #endif m_Hash[aHashValue] = m_Pos; if(aCurMatch < aMatchMinPos) { m_Son[m_Pos].Left = kEmptyHashValue; m_Son[m_Pos].Right = kEmptyHashValue; #ifdef HASH_ARRAY_2 aDistances[2] = aLen2Distance; #ifdef HASH_ARRAY_3 aDistances[3] = aLen3Distance; #endif #endif return aMatchHashLenMax; } CIndex *aPtrLeft = &m_Son[m_Pos].Right; CIndex *aPtrRight = &m_Son[m_Pos].Left; UINT32 aMax, aMinSameLeft, aMinSameRight, aMinSame; aMax = aMinSameLeft = aMinSameRight = aMinSame = kNumHashDirectBytes; #ifdef HASH_ARRAY_2 #ifndef HASH_ARRAY_3 if (aMatchLen2Exist) aDistances[2] = aLen2Distance; else if (kNumHashDirectBytes >= 2) aDistances[2] = m_Pos - aCurMatch - 1; #endif #endif aDistances[aMax] = m_Pos - aCurMatch - 1; for(UINT32 aCount = m_CutValue; aCount > 0; aCount--) { BYTE *pby1 = m_Buffer + aCurMatch; UINT32 aCurrentLen; for(aCurrentLen = aMinSame; aCurrentLen < aCurrentLimit; aCurrentLen++/*, dwComps++*/) if (pby1[aCurrentLen] != aCur[aCurrentLen]) break; while (aCurrentLen > aMax) aDistances[++aMax] = m_Pos - aCurMatch - 1; if (aCurrentLen != aCurrentLimit) { if (pby1[aCurrentLen] < aCur[aCurrentLen]) { *aPtrRight = aCurMatch; aPtrRight = &m_Son[aCurMatch].Right; aCurMatch = m_Son[aCurMatch].Right; if(aCurrentLen > aMinSameLeft) { aMinSameLeft = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } else { *aPtrLeft = aCurMatch; aPtrLeft = &m_Son[aCurMatch].Left; aCurMatch = m_Son[aCurMatch].Left; if(aCurrentLen > aMinSameRight) { aMinSameRight = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } } else { if(aCurrentLen < m_MatchMaxLen) { *aPtrLeft = aCurMatch; aPtrLeft = &m_Son[aCurMatch].Left; aCurMatch = m_Son[aCurMatch].Left; if(aCurrentLen > aMinSameRight) { aMinSameRight = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } else { *aPtrLeft = m_Son[aCurMatch].Right; *aPtrRight = m_Son[aCurMatch].Left; #ifdef HASH_ARRAY_2 if (aMatchLen2Exist && aLen2Distance < aDistances[2]) aDistances[2] = aLen2Distance; #ifdef HASH_ARRAY_3 if (aMatchLen3Exist && aLen3Distance < aDistances[3]) aDistances[3] = aLen3Distance; #endif #endif return aMax; } } if(aCurMatch < aMatchMinPos) break; } *aPtrLeft = kEmptyHashValue; *aPtrRight = kEmptyHashValue; #ifdef HASH_ARRAY_2 if (aMatchLen2Exist) { if (aMax < 2) { aDistances[2] = aLen2Distance; aMax = 2; } else if (aLen2Distance < aDistances[2]) aDistances[2] = aLen2Distance; } #ifdef HASH_ARRAY_3 if (aMatchLen3Exist) { if (aMax < 3) { aDistances[3] = aLen3Distance; aMax = 3; } else if (aLen3Distance < aDistances[3]) aDistances[3] = aLen3Distance; } #endif #endif return aMax; } void CInTree::DummyLongestMatch() { UINT32 aCurrentLimit; if (m_Pos + m_MatchMaxLen <= m_StreamPos) aCurrentLimit = m_MatchMaxLen; else { aCurrentLimit = m_StreamPos - m_Pos; if(aCurrentLimit < kNumHashBytes) return; } UINT32 aMatchMinPos = (m_Pos > m_HistorySize) ? (m_Pos - m_HistorySize) : 1; BYTE *aCur = m_Buffer + m_Pos; #ifdef HASH_ARRAY_2 UINT32 aHash2Value; #ifdef HASH_ARRAY_3 UINT32 aHash3Value; UINT32 aHashValue = Hash(aCur, aHash2Value, aHash3Value); m_Hash3[aHash3Value] = m_Pos; #else UINT32 aHashValue = Hash(aCur, aHash2Value); #endif m_Hash2[aHash2Value] = m_Pos; #else UINT32 aHashValue = Hash(aCur); #endif UINT32 aCurMatch = m_Hash[aHashValue]; m_Hash[aHashValue] = m_Pos; if(aCurMatch < aMatchMinPos) { m_Son[m_Pos].Left = kEmptyHashValue; m_Son[m_Pos].Right = kEmptyHashValue; return; } CIndex *aPtrLeft = &m_Son[m_Pos].Right; CIndex *aPtrRight = &m_Son[m_Pos].Left; UINT32 aMax, aMinSameLeft, aMinSameRight, aMinSame; aMax = aMinSameLeft = aMinSameRight = aMinSame = kNumHashDirectBytes; for(UINT32 aCount = m_CutValue; aCount > 0; aCount--) { BYTE *pby1 = m_Buffer + aCurMatch; // CIndex aLeft = m_Son[aCurMatch].Left; // it's prefetch UINT32 aCurrentLen; for(aCurrentLen = aMinSame; aCurrentLen < aCurrentLimit; aCurrentLen++/*, dwComps++*/) if (pby1[aCurrentLen] != aCur[aCurrentLen]) break; if (aCurrentLen != aCurrentLimit) { if (pby1[aCurrentLen] < aCur[aCurrentLen]) { *aPtrRight = aCurMatch; aPtrRight = &m_Son[aCurMatch].Right; aCurMatch = m_Son[aCurMatch].Right; if(aCurrentLen > aMinSameLeft) { aMinSameLeft = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } else { *aPtrLeft = aCurMatch; aPtrLeft = &m_Son[aCurMatch].Left; aCurMatch = m_Son[aCurMatch].Left; // aCurMatch = aLeft; if(aCurrentLen > aMinSameRight) { aMinSameRight = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } } else { if(aCurrentLen < m_MatchMaxLen) { *aPtrLeft = aCurMatch; aPtrLeft = &m_Son[aCurMatch].Left; aCurMatch = m_Son[aCurMatch].Left; if(aCurrentLen > aMinSameRight) { aMinSameRight = aCurrentLen; aMinSame = MyMin(aMinSameLeft, aMinSameRight); } } else { *aPtrLeft = m_Son[aCurMatch].Right; *aPtrRight = m_Son[aCurMatch].Left; return; } } if(aCurMatch < aMatchMinPos) break; } *aPtrLeft = kEmptyHashValue; *aPtrRight = kEmptyHashValue; } void CInTree::AfterMoveBlock() { UINT32 aNumBytesToMove = m_HistorySize * sizeof(CPair); UINT32 aSpecOffset = ((m_Son + m_Pos) - m_Base) - m_HistorySize; memmove(m_Base, m_Base + aSpecOffset, aNumBytesToMove); m_Son -= aSpecOffset; } void CInTree::NormalizeLinks(CIndex *anArray, UINT32 aNumItems, INT32 aSubValue) { for (UINT32 i = 0; i < aNumItems; i++) { UINT32 aValue = anArray[i]; if (aValue <= aSubValue) aValue = kEmptyHashValue; else aValue -= aSubValue; anArray[i] = aValue; } } void CInTree::Normalize() { UINT32 aStartItem = m_Pos - m_HistorySize; INT32 aSubValue = aStartItem - 1; NormalizeLinks((CIndex *)(m_Son + aStartItem), m_HistorySize * 2, aSubValue); NormalizeLinks(m_Hash, kHashSize, aSubValue); #ifdef HASH_ARRAY_2 NormalizeLinks(m_Hash2, kHash2Size, aSubValue); #ifdef HASH_ARRAY_3 NormalizeLinks(m_Hash3, kHash3Size, aSubValue); #endif #endif ReduceOffsets(aSubValue); } } advancecomp-1.23/7z/BitTreeCoder.h000066400000000000000000000111531301462770100167450ustar00rootroot00000000000000#ifndef __BITTREECODER_H #define __BITTREECODER_H #include "AriBitCoder.h" #include "RCDefs.h" ////////////////////////// // CBitTreeEncoder template class CBitTreeEncoder { CMyBitEncoder m_Models[1 << m_NumBitLevels]; public: void Init() { for(UINT32 i = 1; i < (1 << m_NumBitLevels); i++) m_Models[i].Init(); } void Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aSymbol) { UINT32 aModelIndex = 1; for (UINT32 aBitIndex = m_NumBitLevels; aBitIndex > 0 ;) { aBitIndex--; UINT32 aBit = (aSymbol >> aBitIndex ) & 1; m_Models[aModelIndex].Encode(aRangeEncoder, aBit); aModelIndex = (aModelIndex << 1) | aBit; } }; UINT32 GetPrice(UINT32 aSymbol) const { UINT32 aPrice = 0; UINT32 aModelIndex = 1; for (UINT32 aBitIndex = m_NumBitLevels; aBitIndex > 0 ;) { aBitIndex--; UINT32 aBit = (aSymbol >> aBitIndex ) & 1; aPrice += m_Models[aModelIndex].GetPrice(aBit); aModelIndex = (aModelIndex << 1) + aBit; } return aPrice; } }; ////////////////////////// // CBitTreeDecoder template class CBitTreeDecoder { CMyBitDecoder m_Models[1 << m_NumBitLevels]; public: void Init() { for(UINT32 i = 1; i < (1 << m_NumBitLevels); i++) m_Models[i].Init(); } UINT32 Decode(CMyRangeDecoder *aRangeDecoder) { UINT32 aModelIndex = 1; RC_INIT_VAR for(UINT32 aBitIndex = m_NumBitLevels; aBitIndex > 0; aBitIndex--) { // aModelIndex = (aModelIndex << 1) + m_Models[aModelIndex].Decode(aRangeDecoder); RC_GETBIT(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex) } RC_FLUSH_VAR return aModelIndex - (1 << m_NumBitLevels); }; }; //////////////////////////////// // CReverseBitTreeEncoder template class CReverseBitTreeEncoder2 { CMyBitEncoder *m_Models; UINT32 m_NumBitLevels; public: CReverseBitTreeEncoder2(): m_Models(0) { } ~CReverseBitTreeEncoder2() { delete []m_Models; } bool Create(UINT32 aNumBitLevels) { m_NumBitLevels = aNumBitLevels; m_Models = new CMyBitEncoder[1 << aNumBitLevels]; return (m_Models != 0); } void Init() { UINT32 aNumModels = 1 << m_NumBitLevels; for(UINT32 i = 1; i < aNumModels; i++) m_Models[i].Init(); } void Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aSymbol) { UINT32 aModelIndex = 1; for (UINT32 i = 0; i < m_NumBitLevels; i++) { UINT32 aBit = aSymbol & 1; m_Models[aModelIndex].Encode(aRangeEncoder, aBit); aModelIndex = (aModelIndex << 1) | aBit; aSymbol >>= 1; } } UINT32 GetPrice(UINT32 aSymbol) const { UINT32 aPrice = 0; UINT32 aModelIndex = 1; for (UINT32 i = m_NumBitLevels; i > 0; i--) { UINT32 aBit = aSymbol & 1; aSymbol >>= 1; aPrice += m_Models[aModelIndex].GetPrice(aBit); aModelIndex = (aModelIndex << 1) | aBit; } return aPrice; } }; //////////////////////////////// // CReverseBitTreeDecoder template class CReverseBitTreeDecoder2 { CMyBitDecoder *m_Models; UINT32 m_NumBitLevels; public: CReverseBitTreeDecoder2(): m_Models(0) { } ~CReverseBitTreeDecoder2() { delete []m_Models; } bool Create(UINT32 aNumBitLevels) { m_NumBitLevels = aNumBitLevels; m_Models = new CMyBitDecoder[1 << aNumBitLevels]; return (m_Models != 0); } void Init() { UINT32 aNumModels = 1 << m_NumBitLevels; for(UINT32 i = 1; i < aNumModels; i++) m_Models[i].Init(); } UINT32 Decode(CMyRangeDecoder *aRangeDecoder) { UINT32 aModelIndex = 1; UINT32 aSymbol = 0; RC_INIT_VAR for(UINT32 aBitIndex = 0; aBitIndex < m_NumBitLevels; aBitIndex++) { RC_GETBIT2(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex, ; , aSymbol |= (1 << aBitIndex)) } RC_FLUSH_VAR return aSymbol; }; }; //////////////////////////// // CReverseBitTreeDecoder2 template class CReverseBitTreeDecoder { CMyBitDecoder m_Models[1 << m_NumBitLevels]; public: void Init() { for(UINT32 i = 1; i < (1 << m_NumBitLevels); i++) m_Models[i].Init(); } UINT32 Decode(CMyRangeDecoder *aRangeDecoder) { UINT32 aModelIndex = 1; UINT32 aSymbol = 0; RC_INIT_VAR for(UINT32 aBitIndex = 0; aBitIndex < m_NumBitLevels; aBitIndex++) { RC_GETBIT2(aNumMoveBits, m_Models[aModelIndex].m_Probability, aModelIndex, ; , aSymbol |= (1 << aBitIndex)) } RC_FLUSH_VAR return aSymbol; } }; #endif advancecomp-1.23/7z/CRC.cc000066400000000000000000000110511301462770100151740ustar00rootroot00000000000000#include "CRC.h" static const UINT32 kCRCPoly = 0xEDB88320; UINT32 CCRC::m_Table[256]; class CCRCTableInit { public: CCRCTableInit() { for (UINT32 i = 0; i < 256; i++) { UINT32 r = i; for (int j = 0; j < 8; j++) if (r & 1) r = (r >> 1) ^ kCRCPoly; else r >>= 1; CCRC::m_Table[i] = r; } } } g_CRCTableInit; /* const UINT32 CCRC::m_Table[] = { 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL }; */ #define UPDATE aValueLoc = m_Table[(BYTE)aValueLoc] ^ (aValueLoc >> 8) #define UPDATE4 UPDATE; UPDATE; UPDATE; UPDATE; void CCRC::Update(const void *aData, UINT32 aNum) { UINT32 aValueLoc = m_Value; const BYTE *aByteBuffer = (const BYTE *)aData; for(; (UINT_PTR(aByteBuffer) & 3) != 0 && aNum > 0; aNum--, aByteBuffer++) aValueLoc = m_Table[(((BYTE)(aValueLoc)) ^ (*aByteBuffer))] ^ (aValueLoc >> 8); const int kBlockSize = 4; while (aNum >= kBlockSize) { aNum -= kBlockSize; aValueLoc ^= *(const UINT32 *)aByteBuffer; UPDATE4 aByteBuffer += kBlockSize; } for(UINT32 i = 0; i < aNum; i++) aValueLoc = m_Table[(((BYTE)(aValueLoc)) ^ (aByteBuffer)[i])] ^ (aValueLoc >> 8); m_Value = aValueLoc; } advancecomp-1.23/7z/CRC.h000066400000000000000000000011531301462770100150400ustar00rootroot00000000000000#ifndef __COMMON_CRC_H #define __COMMON_CRC_H #include "Portable.h" class CCRC { UINT32 m_Value; public: static UINT32 m_Table[256]; CCRC(): m_Value(0xFFFFFFFF){}; void Init() { m_Value = 0xFFFFFFFF; } void Update(const void *aData, UINT32 aSize); UINT32 GetDigest() const { return m_Value ^ 0xFFFFFFFF; } static UINT32 CalculateDigest(const void *aData, UINT32 aSize) { CCRC aCRC; aCRC.Update(aData, aSize); return aCRC.GetDigest(); } static bool VerifyDigest(UINT32 aDigest, const void *aData, UINT32 aSize) { return (CalculateDigest(aData, aSize) == aDigest); } }; #endif advancecomp-1.23/7z/Const.h000066400000000000000000000053201301462770100155170ustar00rootroot00000000000000#ifndef __DEFLATE_CONST_H #define __DEFLATE_CONST_H namespace NDeflate { const UINT32 kDistTableSize = 30; const UINT32 kHistorySize = 0x8000; const UINT32 kNumLenCombinations = 256; const UINT32 kNumHuffmanBits = 15; const UINT32 kLenTableSize = 29; const UINT32 kStaticDistTableSize = 32; const UINT32 kStaticLenTableSize = 31; const UINT32 kReadTableNumber = 0x100; const UINT32 kMatchNumber = kReadTableNumber + 1; const UINT32 kMainTableSize = kMatchNumber + kLenTableSize; //298; const UINT32 kStaticMainTableSize = kMatchNumber + kStaticLenTableSize; //298; const UINT32 kDistTableStart = kMainTableSize; const UINT32 kHeapTablesSizesSum = kMainTableSize + kDistTableSize; const UINT32 kLevelTableSize = 19; const UINT32 kMaxTableSize = kHeapTablesSizesSum; // test it const UINT32 kStaticMaxTableSize = kStaticMainTableSize + kStaticDistTableSize; const UINT32 kTableDirectLevels = 16; const UINT32 kTableLevelRepNumber = kTableDirectLevels; const UINT32 kTableLevel0Number = kTableLevelRepNumber + 1; const UINT32 kTableLevel0Number2 = kTableLevel0Number + 1; const UINT32 kLevelMask = 0xF; const BYTE kLenStart[kLenTableSize] = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 255}; const BYTE kLenDirectBits[kLenTableSize] = {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}; const UINT32 kDistStart[kDistTableSize] = {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576}; const BYTE kDistDirectBits[kDistTableSize] = {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; const BYTE kLevelDirectBits[kLevelTableSize] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7}; const BYTE kCodeLengthAlphabetOrder[kLevelTableSize] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; const UINT32 kMatchMinLen = 3; const UINT32 kMatchMaxLen = kNumLenCombinations + kMatchMinLen - 1; // 255 + 2; test it const int kFinalBlockFieldSize = 1; namespace NFinalBlockField { enum { kNotFinalBlock = 0, kFinalBlock = 1 }; } const int kBlockTypeFieldSize = 2; namespace NBlockType { enum { kStored = 0, kFixedHuffman = 1, kDynamicHuffman = 2, kReserved = 3 }; } const UINT32 kDeflateNumberOfLengthCodesFieldSize = 5; const UINT32 kDeflateNumberOfDistanceCodesFieldSize = 5; const UINT32 kDeflateNumberOfLevelCodesFieldSize = 4; const UINT32 kDeflateNumberOfLitLenCodesMin = 257; const UINT32 kDeflateNumberOfDistanceCodesMin = 1; const UINT32 kDeflateNumberOfLevelCodesMin = 4; const UINT32 kDeflateLevelCodeFieldSize = 3; const UINT32 kDeflateStoredBlockLengthFieldSizeSize = 16; } #endif advancecomp-1.23/7z/DeflateDecoder.cc000066400000000000000000000154371301462770100174330ustar00rootroot00000000000000#include "Portable.h" #include "DeflateDecoder.h" namespace NDeflate { namespace NDecoder { static const UINT32 kWindowReservSize = (1 << 17) + 256; CCoder::CCoder() : m_MainDecoder(kStaticMainTableSize), m_DistDecoder(kStaticDistTableSize), m_LevelDecoder(kLevelTableSize) {} void CCoder::DeCodeLevelTable(BYTE *aNewLevels, int aNumLevels) { int i = 0; while (i < aNumLevels) { UINT32 aNumber = m_LevelDecoder.DecodeSymbol(&m_InBitStream); if (aNumber < kTableDirectLevels) aNewLevels[i++] = BYTE(aNumber); else { if (aNumber == kTableLevelRepNumber) { int t = m_InBitStream.ReadBits(2) + 3; for (int aReps = t; aReps > 0 && i < aNumLevels ; aReps--, i++) aNewLevels[i] = aNewLevels[i - 1]; } else { int aNum; if (aNumber == kTableLevel0Number) aNum = m_InBitStream.ReadBits(3) + 3; else aNum = m_InBitStream.ReadBits(7) + 11; for (;aNum > 0 && i < aNumLevels; aNum--) aNewLevels[i++] = 0; } } } } void CCoder::ReadTables(void) { if(m_FinalBlock) // test it throw E_INVALIDDATA; m_FinalBlock = (m_InBitStream.ReadBits(kFinalBlockFieldSize) == NFinalBlockField::kFinalBlock); int aBlockType = m_InBitStream.ReadBits(kBlockTypeFieldSize); switch(aBlockType) { case NBlockType::kStored: { m_StoredMode = true; UINT32 aCurrentBitPosition = m_InBitStream.GetBitPosition(); UINT32 aNumBitsForAlign = aCurrentBitPosition > 0 ? (8 - aCurrentBitPosition): 0; if (aNumBitsForAlign > 0) m_InBitStream.ReadBits(aNumBitsForAlign); m_StoredBlockSize = m_InBitStream.ReadBits(kDeflateStoredBlockLengthFieldSizeSize); WORD anOnesComplementReverse = ~WORD(m_InBitStream.ReadBits(kDeflateStoredBlockLengthFieldSizeSize)); if (m_StoredBlockSize != anOnesComplementReverse) throw E_INVALIDDATA; break; } case NBlockType::kFixedHuffman: case NBlockType::kDynamicHuffman: { m_StoredMode = false; BYTE aLitLenLevels[kStaticMainTableSize]; BYTE aDistLevels[kStaticDistTableSize]; if (aBlockType == NBlockType::kFixedHuffman) { int i; // Leteral / length levels for (i = 0; i < 144; i++) aLitLenLevels[i] = 8; for (; i < 256; i++) aLitLenLevels[i] = 9; for (; i < 280; i++) aLitLenLevels[i] = 7; for (; i < 288; i++) /* make a complete, but wrong code set */ aLitLenLevels[i] = 8; // Distance levels for (i = 0; i < kStaticDistTableSize; i++) // test it: infozip only use kDistTableSize aDistLevels[i] = 5; } else // in case when (aBlockType == kDeflateBlockTypeFixedHuffman) { int aNumLitLenLevels = m_InBitStream.ReadBits(kDeflateNumberOfLengthCodesFieldSize) + kDeflateNumberOfLitLenCodesMin; int aNumDistLevels = m_InBitStream.ReadBits(kDeflateNumberOfDistanceCodesFieldSize) + kDeflateNumberOfDistanceCodesMin; int aNumLevelCodes = m_InBitStream.ReadBits(kDeflateNumberOfLevelCodesFieldSize) + kDeflateNumberOfLevelCodesMin; int aNumLevels; aNumLevels = kHeapTablesSizesSum; BYTE aLevelLevels[kLevelTableSize]; int i; for (i = 0; i < kLevelTableSize; i++) { int aPosition = kCodeLengthAlphabetOrder[i]; if(i < aNumLevelCodes) aLevelLevels[aPosition] = BYTE(m_InBitStream.ReadBits(kDeflateLevelCodeFieldSize)); else aLevelLevels[aPosition] = 0; } try { m_LevelDecoder.SetCodeLengths(aLevelLevels); } catch(...) { throw E_INVALIDDATA; } BYTE aTmpLevels[kStaticMaxTableSize]; DeCodeLevelTable(aTmpLevels, aNumLitLenLevels + aNumDistLevels); memmove(aLitLenLevels, aTmpLevels, aNumLitLenLevels); memset(aLitLenLevels + aNumLitLenLevels, 0, kStaticMainTableSize - aNumLitLenLevels); memmove(aDistLevels, aTmpLevels + aNumLitLenLevels, aNumDistLevels); memset(aDistLevels + aNumDistLevels, 0, kStaticDistTableSize - aNumDistLevels); } try { m_MainDecoder.SetCodeLengths(aLitLenLevels); m_DistDecoder.SetCodeLengths(aDistLevels); } catch(...) { throw E_INVALIDDATA; } break; } default: throw E_INVALIDDATA; } } HRESULT CCoder::CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize) { if (m_OutWindowStream.GetBuffer() == 0) { try { m_OutWindowStream.Create(kHistorySize, kMatchMaxLen, kWindowReservSize); } catch(...) { return E_OUTOFMEMORY; } } UINT64 aPos = 0; m_OutWindowStream.Init(anOutStream, false); m_InBitStream.Init(anInStream); m_FinalBlock = false; while(!m_FinalBlock) { ReadTables(); if(m_StoredMode) { for (UINT32 i = 0; i < m_StoredBlockSize; i++) m_OutWindowStream.PutOneByte(BYTE(m_InBitStream.ReadBits(8))); aPos += m_StoredBlockSize; continue; } while(true) { UINT32 aNumber = m_MainDecoder.DecodeSymbol(&m_InBitStream); if (aNumber < 256) { if (anOutSize != NULL) if (aPos >= *anOutSize) throw E_INVALIDDATA; m_OutWindowStream.PutOneByte(BYTE(aNumber)); aPos++; continue; } else if (aNumber >= kMatchNumber) { if (anOutSize != NULL) if (aPos >= *anOutSize) throw E_INVALIDDATA; aNumber -= kMatchNumber; UINT32 aLength = UINT32(kLenStart[aNumber]) + kMatchMinLen; UINT32 aNumBits; if ((aNumBits = kLenDirectBits[aNumber]) > 0) aLength += m_InBitStream.ReadBits(aNumBits); aNumber = m_DistDecoder.DecodeSymbol(&m_InBitStream); UINT32 aDistance = kDistStart[aNumber] + m_InBitStream.ReadBits(kDistDirectBits[aNumber]); if (aDistance >= aPos) throw E_INVALIDDATA; m_OutWindowStream.CopyBackBlock(aDistance, aLength); aPos += aLength; } else if (aNumber == kReadTableNumber) break; else throw E_INVALIDDATA; } } return m_OutWindowStream.Flush(); } HRESULT CCoder::Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize) { try { return CodeReal(anInStream, anOutStream, anInSize, anOutSize); } catch (HRESULT& e) { return e; } catch (...) { return E_FAIL; } } }} advancecomp-1.23/7z/DeflateDecoder.h000066400000000000000000000020341301462770100172620ustar00rootroot00000000000000#ifndef __ARCHIVE_ZIP_DEFLATEDECODER_H #define __ARCHIVE_ZIP_DEFLATEDECODER_H #include "WindowOut.h" #include "LSBFDecoder.h" #include "InByte.h" #include "HuffmanDecoder.h" #include "Const.h" namespace NDeflate{ namespace NDecoder{ typedef NStream::NLSBF::CDecoder CInBit; typedef NCompression::NHuffman::CDecoder CHuffmanDecoder; class CCoder { NStream::NWindow::COut m_OutWindowStream; CInBit m_InBitStream; CHuffmanDecoder m_MainDecoder; CHuffmanDecoder m_DistDecoder; CHuffmanDecoder m_LevelDecoder; // table for decoding other tables; bool m_FinalBlock; bool m_StoredMode; UINT32 m_StoredBlockSize; void DeCodeLevelTable(BYTE *aNewLevels, int aNumLevels); void ReadTables(); HRESULT CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize); public: CCoder(); HRESULT Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize); }; }} #endif advancecomp-1.23/7z/DeflateEncoder.cc000066400000000000000000000501711301462770100174370ustar00rootroot00000000000000#include "DeflateEncoder.h" #include "Const.h" #include "BinTree3ZMain.h" namespace NDeflate { namespace NEncoder { static const int kValueBlockSize = 0x2000; static const int kMaxCodeBitLength = 15; static const int kMaxLevelBitLength = 7; static const BYTE kFlagImm = 0; static const BYTE kFlagLenPos = 4; static const UINT32 kMaxUncompressedBlockSize = 0xFFFF; // test it !!! static const UINT32 kBlockUncompressedSizeThreshold = kMaxUncompressedBlockSize - kMatchMaxLen - kNumOpts; static const int kNumGoodBacks = 0x10000; static BYTE kNoLiteralDummy = 13; static BYTE kNoLenDummy = 13; static BYTE kNoPosDummy = 6; static BYTE g_LenSlots[kNumLenCombinations]; static BYTE g_FastPos[1 << 8]; class CFastPosInit { public: CFastPosInit() { unsigned i; for(i = 0; i < kLenTableSize; i++) { int c = kLenStart[i]; int j = 1 << kLenDirectBits[i]; for(int k = 0; k < j; k++, c++) g_LenSlots[c] = i; } const int kFastSlots = 16; int c = 0; for (BYTE aSlotFast = 0; aSlotFast < kFastSlots; aSlotFast++) { UINT32 k = (1 << kDistDirectBits[aSlotFast]); for (UINT32 j = 0; j < k; j++, c++) g_FastPos[c] = aSlotFast; } } }; static CFastPosInit g_FastPosInit; inline UINT32 GetPosSlot(UINT32 aPos) { // for (UINT32 i = 1; aPos >= kDistStart[i]; i++); // return i - 1; if (aPos < 0x100) return g_FastPos[aPos]; return g_FastPos[aPos >> 7] + 14; } CCoder::CCoder(): m_MainCoder(kMainTableSize, kLenDirectBits, kMatchNumber, kMaxCodeBitLength), m_DistCoder(kDistTableSize, kDistDirectBits, 0, kMaxCodeBitLength), m_LevelCoder(kLevelTableSize, kLevelDirectBits, 0, kMaxLevelBitLength), m_NumPasses(1), m_NumFastBytes(32), m_OnePosMatchesMemory(0), m_OnePosMatchesArray(0), m_MatchDistances(0), m_Created(false), m_Values(0) { m_Values = new CCodeValue[kValueBlockSize + kNumOpts]; } HRESULT CCoder::Create() { m_MatchFinder.Create(kHistorySize, kNumOpts + kNumGoodBacks, m_NumFastBytes, kMatchMaxLen - m_NumFastBytes); m_MatchLengthEdge = m_NumFastBytes + 1; if (m_NumPasses > 1) { m_OnePosMatchesMemory = new UINT16[kNumGoodBacks * (m_NumFastBytes + 1)]; try { m_OnePosMatchesArray = new COnePosMatches[kNumGoodBacks]; } catch(...) { delete []m_OnePosMatchesMemory; m_OnePosMatchesMemory = 0; throw; } UINT16 *aGoodBacksWordsCurrent = m_OnePosMatchesMemory; for(int i = 0; i < kNumGoodBacks; i++, aGoodBacksWordsCurrent += (m_NumFastBytes + 1)) m_OnePosMatchesArray[i].Init(aGoodBacksWordsCurrent); } else m_MatchDistances = new UINT16[m_NumFastBytes + 1]; return S_OK; } HRESULT CCoder::SetEncoderNumPasses(UINT32 A) { m_NumPasses = A; if (m_NumPasses == 0 || m_NumPasses > 255) return E_INVALIDARG; return S_OK; } HRESULT CCoder::SetEncoderNumFastBytes(UINT32 A) { m_NumFastBytes = A; if(m_NumFastBytes < 3 || m_NumFastBytes > kMatchMaxLen) return E_INVALIDARG; return S_OK; } void CCoder::Free() { if(m_NumPasses > 0) { if (m_NumPasses > 1) { delete []m_OnePosMatchesMemory; delete []m_OnePosMatchesArray; } else delete []m_MatchDistances; } } CCoder::~CCoder() { Free(); delete []m_Values; } void CCoder::ReadGoodBacks() { UINT32 aGoodIndex; if (m_NumPasses > 1) { aGoodIndex = m_FinderPos % kNumGoodBacks; m_MatchDistances = m_OnePosMatchesArray[aGoodIndex].MatchDistances; } UINT32 aDistanceTmp[kMatchMaxLen + 1]; UINT32 aLen = m_MatchFinder.GetLongestMatch(aDistanceTmp); for(UINT32 i = kMatchMinLen; i <= aLen; i++) m_MatchDistances[i] = aDistanceTmp[i]; m_LongestMatchDistance = m_MatchDistances[aLen]; if (aLen == m_NumFastBytes && m_NumFastBytes != kMatchMaxLen) m_LongestMatchLength = aLen + m_MatchFinder.GetMatchLen(aLen, m_LongestMatchDistance, kMatchMaxLen - aLen); else m_LongestMatchLength = aLen; if (m_NumPasses > 1) { m_OnePosMatchesArray[aGoodIndex].LongestMatchDistance = UINT16(m_LongestMatchDistance); m_OnePosMatchesArray[aGoodIndex].LongestMatchLength = UINT16(m_LongestMatchLength); } HRESULT aResult = m_MatchFinder.MovePos(); if (aResult != S_OK) throw aResult; m_FinderPos++; m_AdditionalOffset++; } void CCoder::GetBacks(UINT32 aPos) { if(aPos == m_FinderPos) ReadGoodBacks(); else { if (m_NumPasses == 1) { if(aPos + 1 == m_FinderPos) return; throw E_INTERNAL_ERROR; } else { UINT32 aGoodIndex = aPos % kNumGoodBacks; m_MatchDistances = m_OnePosMatchesArray[aGoodIndex].MatchDistances; m_LongestMatchDistance = m_OnePosMatchesArray[aGoodIndex].LongestMatchDistance; m_LongestMatchLength = m_OnePosMatchesArray[aGoodIndex].LongestMatchLength; } } } void CCoder::MovePos(UINT32 aNum) { if (m_NumPasses > 1) { for(UINT32 i = 0; i < aNum; i++) GetBacks(UINT32(m_BlockStartPostion + m_CurrentBlockUncompressedSize + i + 1)); } else { for (;aNum > 0; aNum--) { m_MatchFinder.DummyLongestMatch(); HRESULT aResult = m_MatchFinder.MovePos(); if (aResult != S_OK) throw aResult; m_FinderPos++; m_AdditionalOffset++; } } } static const int kIfinityPrice = 0xFFFFFFF; UINT32 CCoder::Backward(UINT32 &aBackRes, UINT32 aCur) { m_OptimumEndIndex = aCur; UINT32 aPosMem = m_Optimum[aCur].PosPrev; UINT16 aBackMem = m_Optimum[aCur].BackPrev; do { UINT32 aPosPrev = aPosMem; UINT16 aBackCur = aBackMem; aBackMem = m_Optimum[aPosPrev].BackPrev; aPosMem = m_Optimum[aPosPrev].PosPrev; m_Optimum[aPosPrev].BackPrev = aBackCur; m_Optimum[aPosPrev].PosPrev = aCur; aCur = aPosPrev; } while(aCur > 0); aBackRes = m_Optimum[0].BackPrev; m_OptimumCurrentIndex = m_Optimum[0].PosPrev; return m_OptimumCurrentIndex; } UINT32 CCoder::GetOptimal(UINT32 &aBackRes) { if(m_OptimumEndIndex != m_OptimumCurrentIndex) { UINT32 aLen = m_Optimum[m_OptimumCurrentIndex].PosPrev - m_OptimumCurrentIndex; aBackRes = m_Optimum[m_OptimumCurrentIndex].BackPrev; m_OptimumCurrentIndex = m_Optimum[m_OptimumCurrentIndex].PosPrev; return aLen; } m_OptimumCurrentIndex = 0; m_OptimumEndIndex = 0; GetBacks(UINT32(m_BlockStartPostion + m_CurrentBlockUncompressedSize)); UINT32 aLenMain = m_LongestMatchLength; UINT32 aBackMain = m_LongestMatchDistance; if(aLenMain < kMatchMinLen) return 1; if(aLenMain >= m_MatchLengthEdge) { aBackRes = aBackMain; MovePos(aLenMain - 1); return aLenMain; } m_Optimum[1].Price = m_LiteralPrices[m_MatchFinder.GetIndexByte(0 - m_AdditionalOffset)]; m_Optimum[1].PosPrev = 0; m_Optimum[2].Price = kIfinityPrice; m_Optimum[2].PosPrev = 1; for(UINT32 i = kMatchMinLen; i <= aLenMain; i++) { m_Optimum[i].PosPrev = 0; m_Optimum[i].BackPrev = m_MatchDistances[i]; m_Optimum[i].Price = m_LenPrices[i - kMatchMinLen] + m_PosPrices[GetPosSlot(m_MatchDistances[i])]; } UINT32 aCur = 0; UINT32 aLenEnd = aLenMain; while(true) { aCur++; if(aCur == aLenEnd) return Backward(aBackRes, aCur); GetBacks(UINT32(m_BlockStartPostion + m_CurrentBlockUncompressedSize + aCur)); UINT32 aNewLen = m_LongestMatchLength; if(aNewLen >= m_MatchLengthEdge) return Backward(aBackRes, aCur); UINT32 aCurPrice = m_Optimum[aCur].Price; UINT32 aCurAnd1Price = aCurPrice + m_LiteralPrices[m_MatchFinder.GetIndexByte(aCur - m_AdditionalOffset)]; COptimal &anOptimum = m_Optimum[aCur + 1]; if (aCurAnd1Price < anOptimum.Price) { anOptimum.Price = aCurAnd1Price; anOptimum.PosPrev = aCur; } if (aNewLen < kMatchMinLen) continue; if(aCur + aNewLen > aLenEnd) { if (aCur + aNewLen > kNumOpts - 1) aNewLen = kNumOpts - 1 - aCur; UINT32 aLenEndNew = aCur + aNewLen; if (aLenEnd < aLenEndNew) { for(UINT32 i = aLenEnd + 1; i <= aLenEndNew; i++) m_Optimum[i].Price = kIfinityPrice; aLenEnd = aLenEndNew; } } for(UINT32 aLenTest = kMatchMinLen; aLenTest <= aNewLen; aLenTest++) { UINT16 aCurBack = m_MatchDistances[aLenTest]; UINT32 aCurAndLenPrice = aCurPrice + m_LenPrices[aLenTest - kMatchMinLen] + m_PosPrices[GetPosSlot(aCurBack)]; COptimal &anOptimum = m_Optimum[aCur + aLenTest]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = aCur; anOptimum.BackPrev = aCurBack; } } } } void CCoder::InitStructures() { memset(m_LastLevels, 0, kMaxTableSize); m_ValueIndex = 0; m_OptimumEndIndex = 0; m_OptimumCurrentIndex = 0; m_AdditionalOffset = 0; m_BlockStartPostion = 0; m_CurrentBlockUncompressedSize = 0; m_MainCoder.StartNewBlock(); m_DistCoder.StartNewBlock(); unsigned i; for(i = 0; i < 256; i++) m_LiteralPrices[i] = 8; for(i = 0; i < kNumLenCombinations; i++) m_LenPrices[i] = 5 + kLenDirectBits[g_LenSlots[i]]; // test it for(i = 0; i < kDistTableSize; i++) m_PosPrices[i] = 5 + kDistDirectBits[i]; } void CCoder::WriteBlockData(bool aWriteMode, bool anFinalBlock) { m_MainCoder.AddSymbol(kReadTableNumber); int aMethod = WriteTables(aWriteMode, anFinalBlock); if (aWriteMode) { if(aMethod == NBlockType::kStored) { for(UINT32 i = 0; i < m_CurrentBlockUncompressedSize; i++) { BYTE aByte = m_MatchFinder.GetIndexByte(i - m_AdditionalOffset - m_CurrentBlockUncompressedSize); m_OutStream.WriteBits(aByte, 8); } } else { for (UINT32 i = 0; i < m_ValueIndex; i++) { if (m_Values[i].Flag == kFlagImm) m_MainCoder.CodeOneValue(&m_ReverseOutStream, m_Values[i].Imm); else if (m_Values[i].Flag == kFlagLenPos) { UINT32 aLen = m_Values[i].Len; UINT32 aLenSlot = g_LenSlots[aLen]; m_MainCoder.CodeOneValue(&m_ReverseOutStream, kMatchNumber + aLenSlot); m_OutStream.WriteBits(aLen - kLenStart[aLenSlot], kLenDirectBits[aLenSlot]); UINT32 aDist = m_Values[i].Pos; UINT32 aPosSlot = GetPosSlot(aDist); m_DistCoder.CodeOneValue(&m_ReverseOutStream, aPosSlot); m_OutStream.WriteBits(aDist - kDistStart[aPosSlot], kDistDirectBits[aPosSlot]); } } m_MainCoder.CodeOneValue(&m_ReverseOutStream, kReadTableNumber); } } m_MainCoder.StartNewBlock(); m_DistCoder.StartNewBlock(); m_ValueIndex = 0; UINT32 i; for(i = 0; i < 256; i++) if(m_LastLevels[i] != 0) m_LiteralPrices[i] = m_LastLevels[i]; else m_LiteralPrices[i] = kNoLiteralDummy; // -------------- Normal match ----------------------------- for(i = 0; i < kNumLenCombinations; i++) { UINT32 aSlot = g_LenSlots[i]; BYTE aDummy = m_LastLevels[kMatchNumber + aSlot]; if (aDummy != 0) m_LenPrices[i] = aDummy; else m_LenPrices[i] = kNoLenDummy; m_LenPrices[i] += kLenDirectBits[aSlot]; } for(i = 0; i < kDistTableSize; i++) { BYTE aDummy = m_LastLevels[kDistTableStart + i]; if (aDummy != 0) m_PosPrices[i] = aDummy; else m_PosPrices[i] = kNoPosDummy; m_PosPrices[i] += kDistDirectBits[i]; } } void CCoder::CodeLevelTable(BYTE *aNewLevels, int aNumLevels, bool aCodeMode) { int aPrevLen = 0xFF; // last emitted length int aNextLen = aNewLevels[0]; // length of next code int aCount = 0; // repeat aCount of the current code int aMaxCount = 7; // max repeat aCount int aMinCount = 4; // min repeat aCount if (aNextLen == 0) { aMaxCount = 138; aMinCount = 3; } BYTE anOldValueInGuardElement = aNewLevels[aNumLevels]; // push guard value try { aNewLevels[aNumLevels] = 0xFF; // guard already set for (int n = 0; n < aNumLevels; n++) { int aCurLen = aNextLen; aNextLen = aNewLevels[n + 1]; aCount++; if (aCount < aMaxCount && aCurLen == aNextLen) continue; else if (aCount < aMinCount) for(int i = 0; i < aCount; i++) { int aCodeLen = aCurLen; if (aCodeMode) m_LevelCoder.CodeOneValue(&m_ReverseOutStream, aCodeLen); else m_LevelCoder.AddSymbol(aCodeLen); } else if (aCurLen != 0) { if (aCurLen != aPrevLen) { int aCodeLen = aCurLen; if (aCodeMode) m_LevelCoder.CodeOneValue(&m_ReverseOutStream, aCodeLen); else m_LevelCoder.AddSymbol(aCodeLen); aCount--; } if (aCodeMode) { m_LevelCoder.CodeOneValue(&m_ReverseOutStream, kTableLevelRepNumber); m_OutStream.WriteBits(aCount - 3, 2); } else m_LevelCoder.AddSymbol(kTableLevelRepNumber); } else if (aCount <= 10) { if (aCodeMode) { m_LevelCoder.CodeOneValue(&m_ReverseOutStream, kTableLevel0Number); m_OutStream.WriteBits(aCount - 3, 3); } else m_LevelCoder.AddSymbol(kTableLevel0Number); } else { if (aCodeMode) { m_LevelCoder.CodeOneValue(&m_ReverseOutStream, kTableLevel0Number2); m_OutStream.WriteBits(aCount - 11, 7); } else m_LevelCoder.AddSymbol(kTableLevel0Number2); } aCount = 0; aPrevLen = aCurLen; if (aNextLen == 0) { aMaxCount = 138; aMinCount = 3; } else if (aCurLen == aNextLen) { aMaxCount = 6; aMinCount = 3; } else { aMaxCount = 7; aMinCount = 4; } } } catch(...) { aNewLevels[aNumLevels] = anOldValueInGuardElement; // old guard throw; } aNewLevels[aNumLevels] = anOldValueInGuardElement; // old guard } int CCoder::WriteTables(bool aWriteMode, bool anFinalBlock) { BYTE aNewLevels[kMaxTableSize + 1]; // (+ 1) for guard m_MainCoder.BuildTree(&aNewLevels[0]); m_DistCoder.BuildTree(&aNewLevels[kDistTableStart]); memset(m_LastLevels, 0, kMaxTableSize); if (aWriteMode) { if(anFinalBlock) m_OutStream.WriteBits(NFinalBlockField::kFinalBlock, kFinalBlockFieldSize); else m_OutStream.WriteBits(NFinalBlockField::kNotFinalBlock, kFinalBlockFieldSize); m_LevelCoder.StartNewBlock(); int aNumLitLenLevels = kMainTableSize; while(aNumLitLenLevels > kDeflateNumberOfLitLenCodesMin && aNewLevels[aNumLitLenLevels - 1] == 0) aNumLitLenLevels--; int aNumDistLevels = kDistTableSize; while(aNumDistLevels > kDeflateNumberOfDistanceCodesMin && aNewLevels[kDistTableStart + aNumDistLevels - 1] == 0) aNumDistLevels--; ///////////////////////// // First Pass CodeLevelTable(aNewLevels, aNumLitLenLevels, false); CodeLevelTable(&aNewLevels[kDistTableStart], aNumDistLevels, false); memcpy(m_LastLevels, aNewLevels, kMaxTableSize); BYTE aLevelLevels[kLevelTableSize]; m_LevelCoder.BuildTree(aLevelLevels); BYTE aLevelLevelsStream[kLevelTableSize]; int aNumLevelCodes = kDeflateNumberOfLevelCodesMin; int i; for (i = 0; i < kLevelTableSize; i++) { int aStreamPos = kCodeLengthAlphabetOrder[i]; int aLevel = aLevelLevels[aStreamPos]; if (aLevel > 0 && i >= aNumLevelCodes) aNumLevelCodes = i + 1; aLevelLevelsStream[i] = aLevel; } UINT32 aNumLZHuffmanBits = m_MainCoder.GetBlockBitLength(); aNumLZHuffmanBits += m_DistCoder.GetBlockBitLength(); aNumLZHuffmanBits += m_LevelCoder.GetBlockBitLength(); aNumLZHuffmanBits += kDeflateNumberOfLengthCodesFieldSize + kDeflateNumberOfDistanceCodesFieldSize + kDeflateNumberOfLevelCodesFieldSize; aNumLZHuffmanBits += aNumLevelCodes * kDeflateLevelCodeFieldSize; UINT32 aNextBitPosition = (m_OutStream.GetBitPosition() + kBlockTypeFieldSize) % 8; UINT32 aNumBitsForAlign = aNextBitPosition > 0 ? (8 - aNextBitPosition): 0; UINT32 aNumStoreBits = aNumBitsForAlign + (2 * sizeof(UINT16)) * 8; aNumStoreBits += m_CurrentBlockUncompressedSize * 8; if(aNumStoreBits < aNumLZHuffmanBits) { m_OutStream.WriteBits(NBlockType::kStored, kBlockTypeFieldSize); // test it m_OutStream.WriteBits(0, aNumBitsForAlign); // test it UINT16 aCurrentBlockUncompressedSize = UINT16(m_CurrentBlockUncompressedSize); UINT16 aCurrentBlockUncompressedSizeNot = ~aCurrentBlockUncompressedSize; m_OutStream.WriteBits(aCurrentBlockUncompressedSize, kDeflateStoredBlockLengthFieldSizeSize); m_OutStream.WriteBits(aCurrentBlockUncompressedSizeNot, kDeflateStoredBlockLengthFieldSizeSize); return NBlockType::kStored; } else { m_OutStream.WriteBits(NBlockType::kDynamicHuffman, kBlockTypeFieldSize); m_OutStream.WriteBits(aNumLitLenLevels - kDeflateNumberOfLitLenCodesMin, kDeflateNumberOfLengthCodesFieldSize); m_OutStream.WriteBits(aNumDistLevels - kDeflateNumberOfDistanceCodesMin, kDeflateNumberOfDistanceCodesFieldSize); m_OutStream.WriteBits(aNumLevelCodes - kDeflateNumberOfLevelCodesMin, kDeflateNumberOfLevelCodesFieldSize); for (i = 0; i < aNumLevelCodes; i++) m_OutStream.WriteBits(aLevelLevelsStream[i], kDeflateLevelCodeFieldSize); ///////////////////////// // Second Pass CodeLevelTable(aNewLevels, aNumLitLenLevels, true); CodeLevelTable(&aNewLevels[kDistTableStart], aNumDistLevels, true); return NBlockType::kDynamicHuffman; } } else memcpy(m_LastLevels, aNewLevels, kMaxTableSize); return -1; } HRESULT CCoder::CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize) { if (!m_Created) { RETURN_IF_NOT_S_OK(Create()); m_Created = true; } UINT64 aNowPos = 0; m_FinderPos = 0; RETURN_IF_NOT_S_OK(m_MatchFinder.Init(anInStream)); m_OutStream.Init(anOutStream); m_ReverseOutStream.Init(&m_OutStream); InitStructures(); while(true) { int aCurrentPassIndex = 0; bool aNoMoreBytes; while (true) { while(true) { aNoMoreBytes = (m_AdditionalOffset == 0 && m_MatchFinder.GetNumAvailableBytes() == 0); if (((m_CurrentBlockUncompressedSize >= kBlockUncompressedSizeThreshold || m_ValueIndex >= kValueBlockSize) && (m_OptimumEndIndex == m_OptimumCurrentIndex)) || aNoMoreBytes) break; UINT32 aPos; UINT32 aLen = GetOptimal(aPos); if (aLen >= kMatchMinLen) { UINT32 aNewLen = aLen - kMatchMinLen; m_Values[m_ValueIndex].Flag = kFlagLenPos; m_Values[m_ValueIndex].Len = BYTE(aNewLen); UINT32 aLenSlot = g_LenSlots[aNewLen]; m_MainCoder.AddSymbol(kMatchNumber + aLenSlot); m_Values[m_ValueIndex].Pos = UINT16(aPos); UINT32 aPosSlot = GetPosSlot(aPos); m_DistCoder.AddSymbol(aPosSlot); } else if (aLen == 1) { BYTE aByte = m_MatchFinder.GetIndexByte(0 - m_AdditionalOffset); aLen = 1; m_MainCoder.AddSymbol(aByte); m_Values[m_ValueIndex].Flag = kFlagImm; m_Values[m_ValueIndex].Imm = aByte; } else throw E_INTERNAL_ERROR; m_ValueIndex++; m_AdditionalOffset -= aLen; aNowPos += aLen; m_CurrentBlockUncompressedSize += aLen; } aCurrentPassIndex++; bool aWriteMode = (aCurrentPassIndex == m_NumPasses); WriteBlockData(aWriteMode, aNoMoreBytes); if (aWriteMode) break; aNowPos = m_BlockStartPostion; m_AdditionalOffset = UINT32(m_FinderPos - m_BlockStartPostion); m_CurrentBlockUncompressedSize = 0; } m_BlockStartPostion += m_CurrentBlockUncompressedSize; m_CurrentBlockUncompressedSize = 0; if (aNoMoreBytes) break; } return m_OutStream.Flush(); } HRESULT CCoder::Code(ISequentialInStream *anInStream,ISequentialOutStream *anOutStream, const UINT64 *anInSize) { try { return CodeReal(anInStream, anOutStream, anInSize); } catch (HRESULT& e) { return e; } catch (...) { return E_FAIL; } } }} advancecomp-1.23/7z/DeflateEncoder.h000066400000000000000000000045611301462770100173030ustar00rootroot00000000000000#ifndef __DEFLATE_ENCODER_H #define __DEFLATE_ENCODER_H #include "BinTree3Z.h" #include "LSBFEncoder.h" #include "HuffmanEncoder.h" #include "Const.h" namespace NDeflate { namespace NEncoder { struct CCodeValue { BYTE Flag; union { BYTE Imm; BYTE Len; }; UINT16 Pos; }; class COnePosMatches { public: UINT16 *MatchDistances; UINT16 LongestMatchLength; UINT16 LongestMatchDistance; void Init(UINT16 *aMatchDistances) { MatchDistances = aMatchDistances; }; }; struct COptimal { UINT32 Price; UINT16 PosPrev; UINT16 BackPrev; }; const int kNumOpts = 0x1000; class CCoder { UINT32 m_FinderPos; COptimal m_Optimum[kNumOpts]; NBT3Z::CInTree m_MatchFinder; NStream::NLSBF::CEncoder m_OutStream; NStream::NLSBF::CReverseEncoder m_ReverseOutStream; NCompression::NHuffman::CEncoder m_MainCoder; NCompression::NHuffman::CEncoder m_DistCoder; NCompression::NHuffman::CEncoder m_LevelCoder; BYTE m_LastLevels[kMaxTableSize]; UINT32 m_ValueIndex; CCodeValue *m_Values; UINT32 m_OptimumEndIndex; UINT32 m_OptimumCurrentIndex; UINT32 m_AdditionalOffset; UINT32 m_LongestMatchLength; UINT32 m_LongestMatchDistance; UINT16 *m_MatchDistances; UINT32 m_NumFastBytes; UINT32 m_MatchLengthEdge; BYTE m_LiteralPrices[256]; BYTE m_LenPrices[kNumLenCombinations]; BYTE m_PosPrices[kDistTableSize]; UINT32 m_CurrentBlockUncompressedSize; COnePosMatches *m_OnePosMatchesArray; UINT16 *m_OnePosMatchesMemory; UINT64 m_BlockStartPostion; int m_NumPasses; bool m_Created; HRESULT Create(); void Free(); void GetBacks(UINT32 aPos); void ReadGoodBacks(); void MovePos(UINT32 aNum); UINT32 Backward(UINT32 &aBackRes, UINT32 aCur); UINT32 GetOptimal(UINT32 &aBackRes); void InitStructures(); void CodeLevelTable(BYTE *aNewLevels, int aNumLevels, bool aCodeMode); int WriteTables(bool aWriteMode, bool anFinalBlock); void CopyBackBlockOp(UINT32 aDistance, UINT32 aLength); void WriteBlockData(bool aWriteMode, bool anFinalBlock); HRESULT CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize); public: CCoder(); ~CCoder(); HRESULT SetEncoderNumPasses(UINT32 A); HRESULT SetEncoderNumFastBytes(UINT32 A); HRESULT Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize); }; }} #endif advancecomp-1.23/7z/HuffmanDecoder.h000066400000000000000000000063411301462770100173070ustar00rootroot00000000000000#ifndef __COMPRESSION_HUFFMANDECODER_H #define __COMPRESSION_HUFFMANDECODER_H namespace NCompression { namespace NHuffman { const UINT32 kValueTableBits = 8; template class CDecoder { UINT32 m_Limitits[kNumBitsInLongestCode + 1]; // m_Limitits[i] = value limit for symbols with length = i UINT32 m_Positions[kNumBitsInLongestCode + 1]; // m_Positions[i] = index in m_Symbols[] of first symbol with length = i UINT32 m_NumSymbols; UINT32 *m_Symbols; // symbols: at first with len = 1 then 2, ... 15. BYTE m_Lengths[1 << kValueTableBits]; public: CDecoder(UINT32 aNumSymbols): m_NumSymbols(aNumSymbols) { m_Symbols = new UINT32[m_NumSymbols]; } ~CDecoder() { delete []m_Symbols; } void SetNumSymbols(UINT32 aNumSymbols) { m_NumSymbols = aNumSymbols; } void SetCodeLengths(const BYTE *aCodeLengths); template UINT32 DecodeSymbol(TBitDecoder *aStream) { UINT32 aNumBits; UINT32 aValue = aStream->GetValue(kNumBitsInLongestCode); if (aValue < m_Limitits[kValueTableBits]) aNumBits = m_Lengths[aValue >> (kNumBitsInLongestCode - kValueTableBits)]; else if (aValue < m_Limitits[10]) if (aValue < m_Limitits[9]) aNumBits = 9; else aNumBits = 10; else if (aValue < m_Limitits[11]) aNumBits = 11; else if (aValue < m_Limitits[12]) aNumBits = 12; else for (aNumBits = 13; aNumBits < kNumBitsInLongestCode; aNumBits++) if (aValue < m_Limitits[aNumBits]) break; aStream->MovePos(aNumBits); UINT32 anIndex = m_Positions[aNumBits] + ((aValue - m_Limitits[aNumBits - 1]) >> (kNumBitsInLongestCode - aNumBits)); if (anIndex >= m_NumSymbols) throw E_INTERNAL_ERROR; // test it return m_Symbols[anIndex]; } }; template void CDecoder::SetCodeLengths(const BYTE *aCodeLengths) { int aLenCounts[kNumBitsInLongestCode + 1], aTmpPositions[kNumBitsInLongestCode + 1]; int i; for(i = 1; i <= kNumBitsInLongestCode; i++) aLenCounts[i] = 0; UINT32 aSymbol; for (aSymbol = 0; aSymbol < m_NumSymbols; aSymbol++) { BYTE aCodeLength = aCodeLengths[aSymbol]; if (aCodeLength > kNumBitsInLongestCode) throw E_INTERNAL_ERROR; aLenCounts[aCodeLength]++; } aLenCounts[0] = 0; aTmpPositions[0] = m_Positions[0] = m_Limitits[0] = 0; UINT32 aStartPos = 0; UINT32 anIndex = 0; const int kMaxValue = (1 << kNumBitsInLongestCode); for (i = 1; i <= kNumBitsInLongestCode; i++) { aStartPos += aLenCounts[i] << (kNumBitsInLongestCode - i); if (aStartPos > kMaxValue) throw E_INTERNAL_ERROR; m_Limitits[i] = aStartPos; m_Positions[i] = m_Positions[i - 1] + aLenCounts[i - 1]; aTmpPositions[i] = m_Positions[i]; if(i <= kValueTableBits) { UINT32 aLimit = (m_Limitits[i] >> (kNumBitsInLongestCode - kValueTableBits)); // change it memset(m_Lengths + anIndex, BYTE(i), aLimit - anIndex); anIndex = aLimit; } } // if (aStartPos != kMaxValue) // throw E_INTERNAL_ERROR; for (aSymbol = 0; aSymbol < m_NumSymbols; aSymbol++) if (aCodeLengths[aSymbol] != 0) m_Symbols[aTmpPositions[aCodeLengths[aSymbol]]++] = aSymbol; } }} #endif advancecomp-1.23/7z/HuffmanEncoder.cc000066400000000000000000000232221301462770100174540ustar00rootroot00000000000000#include "Portable.h" #include "HuffmanEncoder.h" namespace NCompression { namespace NHuffman { CEncoder::CEncoder(UINT32 aNumSymbols, const BYTE *anExtraBits, UINT32 anExtraBase, UINT32 aMaxLength): m_NumSymbols(aNumSymbols), m_HeapSize(aNumSymbols * 2+ 1), m_ExtraBits(anExtraBits), m_ExtraBase(anExtraBase), m_MaxLength(aMaxLength) { m_Items = new CItem[m_HeapSize]; m_Heap = new UINT32[m_HeapSize]; m_Depth = new BYTE[m_HeapSize]; } CEncoder::~CEncoder() { delete []m_Depth; delete []m_Heap; delete []m_Items; } void CEncoder::StartNewBlock() { for (UINT32 i = 0; i < m_NumSymbols; i++) m_Items[i].Freq = 0; } void CEncoder::SetFreqs(const UINT32 *aFreqs) { for (UINT32 i = 0; i < m_NumSymbols; i++) m_Items[i].Freq = aFreqs[i]; } static const int kSmallest = 1; // =========================================================================== // Remove the smallest element from the heap and recreate the heap with // one less element. Updates heap and m_HeapLength. UINT32 CEncoder::RemoveSmallest() { UINT32 aTop = m_Heap[kSmallest]; m_Heap[kSmallest] = m_Heap[m_HeapLength--]; DownHeap(kSmallest); return aTop; } // =========================================================================== // Compares to subtrees, using the tree m_Depth as tie breaker when // the subtrees have equal frequency. This minimizes the worst case length. bool CEncoder::Smaller(int n, int m) { return (m_Items[n].Freq < m_Items[m].Freq || (m_Items[n].Freq == m_Items[m].Freq && m_Depth[n] <= m_Depth[m])); } // =========================================================================== // Restore the m_Heap property by moving down the tree starting at node k, // exchanging a node with the smallest of its two sons if necessary, stopping // when the m_Heap property is re-established (each father CompareFreqs than its // two sons). void CEncoder::DownHeap(UINT32 k) { UINT32 aSymbol = m_Heap[k]; for (UINT32 j = k << 1; j <= m_HeapLength;) // j: left son of k { // Set j to the smallest of the two sons: if (j < m_HeapLength && Smaller(m_Heap[j+1], m_Heap[j])) j++; UINT32 htemp = m_Heap[j]; // htemp required because of bug in SASC compiler if (Smaller(aSymbol, htemp)) // Exit if v is smaller than both sons break; m_Heap[k] = htemp; // Exchange v with the smallest son k = j; j <<= 1; // And continue down the tree, setting j to the left son of k } m_Heap[k] = aSymbol; } // =========================================================================== // Compute the optimal bit lengths for a tree and update the total bit length // for the current block. // IN assertion: the fields freq and dad are set, heap[aHeapMax] and // above are the tree nodes sorted by increasing frequency. // OUT assertions: the field len is set to the optimal bit length, the // array m_BitLenCounters contains the frequencies for each bit length. // The length m_BlockBitLength is updated; static_len is also updated if stree is // not null. void CEncoder::GenerateBitLen(UINT32 aMaxCode, UINT32 aHeapMax) { int anOverflow = 0; // number of elements with bit length too large UINT32 i; for (i = 0; i <= kNumBitsInLongestCode; i++) m_BitLenCounters[i] = 0; /* In a first pass, compute the optimal bit lengths (which may * anOverflow in the case of the bit length tree). */ m_Items[m_Heap[aHeapMax]].Len = 0; /* root of the heap */ UINT32 h; /* heap index */ for (h = aHeapMax+1; h < m_HeapSize; h++) { UINT32 aSymbol = m_Heap[h]; UINT32 aLen = m_Items[m_Items[aSymbol].Dad].Len + 1; if (aLen > m_MaxLength) { aLen = m_MaxLength; anOverflow++; } m_Items[aSymbol].Len = aLen; // We overwrite m_Items[aSymbol].Dad which is no longer needed if (aSymbol > aMaxCode) continue; // not a leaf node m_BitLenCounters[aLen]++; UINT32 anExtraBits; if (m_ExtraBits != 0 && aSymbol >= m_ExtraBase) anExtraBits = m_ExtraBits[aSymbol - m_ExtraBase]; else anExtraBits = 0; m_BlockBitLength += (m_Items[aSymbol].Freq * (aLen + anExtraBits)); } if (anOverflow == 0) return; // This happens for example on obj2 and pic of the Calgary corpus // Find the first bit length which could increase: do { UINT32 aBits = m_MaxLength-1; while (m_BitLenCounters[aBits] == 0) aBits--; m_BitLenCounters[aBits]--; // move one leaf down the m_Items m_BitLenCounters[aBits + 1] += 2; // move one anOverflow item as its brother m_BitLenCounters[m_MaxLength]--; // The brother of the anOverflow item also moves one step up, // but this does not affect m_BitLenCounters[m_MaxLength] anOverflow -= 2; } while (anOverflow > 0); // Now recompute all bit lengths, scanning in increasing frequency. // h is still equal to HEAP_SIZE. (It is simpler to reconstruct all // lengths instead of fixing only the wrong ones. This idea is taken // from 'ar' written by Haruhiko Okumura.) for (UINT32 aBits = m_MaxLength; aBits != 0; aBits--) { UINT32 aNumNodes = m_BitLenCounters[aBits]; while (aNumNodes != 0) { UINT32 m = m_Heap[--h]; if (m > aMaxCode) continue; if (m_Items[m].Len != aBits) { m_BlockBitLength += (aBits - m_Items[m].Len) * m_Items[m].Freq; m_Items[m].Len = aBits; } aNumNodes--; } } } // =========================================================================== // Generate the codes for a given tree and bit counts (which need not be // optimal). // IN assertion: the array m_BitLenCounters contains the bit length statistics for // the given tree and the field len is set for all tree elements. // OUT assertion: the field code is set for all tree elements of non // zero code length. // UINT32 aMaxCode = largest code with non zero frequency void CEncoder::GenerateCodes(UINT32 aMaxCode) { UINT32 aNextCodes[kNumBitsInLongestCode + 1]; // next code value for each bit length UINT32 code = 0; // running code value // The distribution counts are first used to generate the code values // without bit reversal. for (UINT32 aBits = 1; aBits <= kNumBitsInLongestCode; aBits++) aNextCodes[aBits] = code = (code + m_BitLenCounters[aBits - 1]) << 1; // Check that the bit counts in m_BitLenCounters are consistent. The last code // must be all ones. if (code + m_BitLenCounters[kNumBitsInLongestCode] - 1 != (1 << kNumBitsInLongestCode) - 1) throw E_INTERNAL_ERROR; for (UINT32 n = 0; n <= aMaxCode; n++) { int aLen = m_Items[n].Len; if (aLen == 0) continue; m_Items[n].Code = aNextCodes[aLen]++; } } // =========================================================================== // Construct one Huffman tree and assigns the code bit strings and lengths. // Update the total bit length for the current block. // IN assertion: the field freq is set for all tree elements. // OUT assertions: the fields len and code are set to the optimal bit length // and corresponding code. The length m_BlockBitLength is updated; static_len is // also updated if stree is not null. The field max_code is set. void CEncoder::BuildTree(BYTE *aLevels) { m_BlockBitLength = 0; int aMaxCode = -1; // WAS = -1; largest code with non zero frequency */ // Construct the initial m_Heap, with least frequent element in // m_Heap[kSmallest]. The sons of m_Heap[n] are m_Heap[2*n] and m_Heap[2*n+1]. // m_Heap[0] is not used. // m_HeapLength = 0; UINT32 n; // iterate over m_Heap elements for (n = 0; n < m_NumSymbols; n++) { if (m_Items[n].Freq != 0) { m_Heap[++m_HeapLength] = aMaxCode = n; m_Depth[n] = 0; } else m_Items[n].Len = 0; } // The pkzip format requires that at least one distance code exists, // and that at least one bit should be sent even if there is only one // possible code. So to avoid special checks later on we force at least // two codes of non zero frequency. while (m_HeapLength < 2) { int aNewNode = m_Heap[++m_HeapLength] = (aMaxCode < 2 ? ++aMaxCode : 0); m_Items[aNewNode].Freq = 1; m_Depth[aNewNode] = 0; m_BlockBitLength--; // if (stree) static_len -= stree[aNewNode].Len; // aNewNode is 0 or 1 so it does not have m_ExtraBits bits } // The elements m_Heap[m_HeapLength/2+1 .. m_HeapLength] are leaves of the m_Items, // establish sub-heaps of increasing lengths: for (n = m_HeapLength / 2; n >= 1; n--) DownHeap(n); // Construct the Huffman tree by repeatedly combining the least two // frequent nodes. int aNode = m_NumSymbols; // next internal node of the tree UINT32 aHeapMax = m_NumSymbols * 2+ 1; do { n = RemoveSmallest(); /* n = node of least frequency */ UINT32 m = m_Heap[kSmallest]; /* m = node of next least frequency */ m_Heap[--aHeapMax] = n; /* keep the nodes sorted by frequency */ m_Heap[--aHeapMax] = m; // Create a new node father of n and m m_Items[aNode].Freq = m_Items[n].Freq + m_Items[m].Freq; m_Depth[aNode] = (BYTE) (MyMax(m_Depth[n], m_Depth[m]) + 1); m_Items[n].Dad = m_Items[m].Dad = aNode; // and insert the new node in the m_Heap m_Heap[kSmallest] = aNode++; DownHeap(kSmallest); } while (m_HeapLength >= 2); m_Heap[--aHeapMax] = m_Heap[kSmallest]; // At this point, the fields freq and dad are set. We can now // generate the bit lengths. GenerateBitLen(aMaxCode, aHeapMax); // The field len is now set, we can generate the bit codes GenerateCodes (aMaxCode); for (n = 0; n < m_NumSymbols; n++) aLevels[n] = BYTE(m_Items[n].Len); } }} advancecomp-1.23/7z/HuffmanEncoder.h000066400000000000000000000024051301462770100173160ustar00rootroot00000000000000#ifndef __COMPRESSION_HUFFMANENCODER_H #define __COMPRESSION_HUFFMANENCODER_H namespace NCompression { namespace NHuffman { const int kNumBitsInLongestCode = 15; struct CItem { UINT32 Freq; UINT32 Code; UINT32 Dad; UINT32 Len; }; class CEncoder { UINT32 m_NumSymbols; // number of symbols in adwSymbol CItem *m_Items; UINT32 *m_Heap; UINT32 m_HeapSize; BYTE *m_Depth; const BYTE *m_ExtraBits; UINT32 m_ExtraBase; UINT32 m_MaxLength; UINT32 m_HeapLength; UINT32 m_BitLenCounters[kNumBitsInLongestCode + 1]; UINT32 RemoveSmallest(); bool Smaller(int n, int m); void DownHeap(UINT32 k); void GenerateBitLen(UINT32 aMaxCode, UINT32 aHeapMax); void GenerateCodes(UINT32 aMaxCode); UINT32 m_BlockBitLength; public: CEncoder(UINT32 aNumSymbols, const BYTE *anExtraBits, UINT32 anExtraBase, UINT32 aMaxLength); ~CEncoder(); void StartNewBlock(); void AddSymbol(UINT32 aSymbol) { m_Items[aSymbol].Freq++; } void SetFreqs(const UINT32 *aFreqs); void BuildTree(BYTE *aLevels); DWORD GetBlockBitLength() const { return m_BlockBitLength; } template void CodeOneValue(TBitEncoder *aStream, UINT32 aSymbol) { aStream->WriteBits(m_Items[aSymbol].Code, m_Items[aSymbol].Len); } }; }} #endif advancecomp-1.23/7z/IInOutStreams.cc000066400000000000000000000010321301462770100172710ustar00rootroot00000000000000#include "Portable.h" #include "IInOutStreams.h" HRESULT ISequentialInStream::Read(void *aData, INT aSize, INT* aProcessedSize) { if (aSize > size) aSize = size; *aProcessedSize = aSize; memcpy(aData, data, aSize); size -= aSize; data += aSize; return S_OK; } HRESULT ISequentialOutStream::Write(const void *aData, INT aSize, INT* aProcessedSize) { if (aSize > size) { overflow = true; aSize = size; } *aProcessedSize = aSize; memcpy(data, aData, aSize); size -= aSize; data += aSize; total += aSize; return S_OK; } advancecomp-1.23/7z/IInOutStreams.h000066400000000000000000000012171301462770100171400ustar00rootroot00000000000000#ifndef __IINOUTSTREAMS_H #define __IINOUTSTREAMS_H #include "Portable.h" class ISequentialInStream { const char* data; INT size; public: ISequentialInStream(const char* Adata, INT Asize) : data(Adata), size(Asize) { } HRESULT Read(void *aData, INT aSize, INT *aProcessedSize); }; class ISequentialOutStream { char* data; INT size; bool overflow; INT total; public: ISequentialOutStream(char* Adata, unsigned Asize) : data(Adata), size(Asize), overflow(false), total(0) { } bool overflow_get() const { return overflow; } INT size_get() const { return total; } HRESULT Write(const void *aData, INT aSize, INT *aProcessedSize); }; #endif advancecomp-1.23/7z/InByte.cc000066400000000000000000000015171301462770100157650ustar00rootroot00000000000000#include "InByte.h" namespace NStream{ CInByte::CInByte(INT aBufferSize): m_BufferSize(aBufferSize), m_BufferBase(0) { m_BufferBase = new BYTE[m_BufferSize]; } CInByte::~CInByte() { delete []m_BufferBase; } void CInByte::Init(ISequentialInStream *aStream) { m_Stream = aStream; m_ProcessedSize = 0; m_Buffer = m_BufferBase; m_BufferLimit = m_Buffer; m_StreamWasExhausted = false; } bool CInByte::ReadBlock() { if (m_StreamWasExhausted) return false; m_ProcessedSize += (m_Buffer - m_BufferBase); INT aNumProcessedBytes; HRESULT aResult = m_Stream->Read(m_BufferBase, m_BufferSize, &aNumProcessedBytes); if (aResult != S_OK) throw aResult; m_Buffer = m_BufferBase; m_BufferLimit = m_Buffer + aNumProcessedBytes; m_StreamWasExhausted = (aNumProcessedBytes == 0); return (!m_StreamWasExhausted); } } advancecomp-1.23/7z/InByte.h000066400000000000000000000023041301462770100156220ustar00rootroot00000000000000#ifndef __STREAM_INBYTE_H #define __STREAM_INBYTE_H #include "IInOutStreams.h" namespace NStream { class CInByte { UINT64 m_ProcessedSize; BYTE *m_BufferBase; INT m_BufferSize; BYTE *m_Buffer; BYTE *m_BufferLimit; ISequentialInStream* m_Stream; bool m_StreamWasExhausted; bool ReadBlock(); public: CInByte(INT aBufferSize = 0x100000); ~CInByte(); void Init(ISequentialInStream *aStream); bool ReadByte(BYTE &aByte) { if(m_Buffer >= m_BufferLimit) if(!ReadBlock()) return false; aByte = *m_Buffer++; return true; } BYTE ReadByte() { if(m_Buffer >= m_BufferLimit) if(!ReadBlock()) return 0x0; return *m_Buffer++; } void ReadBytes(void *aData, INT aSize, INT &aProcessedSize) { for(aProcessedSize = 0; aProcessedSize < aSize; aProcessedSize++) if (!ReadByte(((BYTE *)aData)[aProcessedSize])) return; } bool ReadBytes(void *aData, INT aSize) { INT aProcessedSize; ReadBytes(aData, aSize, aProcessedSize); return (aProcessedSize == aSize); } UINT64 GetProcessedSize() const { return m_ProcessedSize + (m_Buffer - m_BufferBase); } }; } #endif advancecomp-1.23/7z/LSBFDecoder.cc000066400000000000000000000007531301462770100166100ustar00rootroot00000000000000#include "LSBFDecoder.h" namespace NStream { namespace NLSBF { BYTE kInvertTable[256]; class CInverterTableInitializer { public: CInverterTableInitializer() { for(int i = 0; i < 256; i++) { BYTE aByte = BYTE(i); BYTE aByteInvert = 0; for(int j = 0; j < 8; j++) { aByteInvert <<= 1; if (aByte & 1) aByteInvert |= 1; aByte >>= 1; } kInvertTable[i] = aByteInvert; } } } g_InverterTableInitializer; }} advancecomp-1.23/7z/LSBFDecoder.h000066400000000000000000000030771301462770100164540ustar00rootroot00000000000000#ifndef __STREAM_LSBFDECODER_H #define __STREAM_LSBFDECODER_H #include "IInOutStreams.h" namespace NStream { namespace NLSBF { const int kNumBigValueBits = 8 * 4; const int kNumValueBytes = 3; const int kNumValueBits = 8 * kNumValueBytes; const int kMask = (1 << kNumValueBits) - 1; extern BYTE kInvertTable[256]; // the Least Significant Bit of byte is First template class CDecoder { UINT32 m_BitPos; UINT32 m_Value; UINT32 m_NormalValue; protected: TInByte m_Stream; public: void Init(ISequentialInStream *aStream) { m_Stream.Init(aStream); Init(); } void Init() { m_BitPos = kNumBigValueBits; m_NormalValue = 0; } void ReleaseStream() { m_Stream.ReleaseStream(); } UINT64 GetProcessedSize() const { return m_Stream.GetProcessedSize() - (kNumBigValueBits - m_BitPos) / 8; } void Normalize() { for (;m_BitPos >= 8; m_BitPos -= 8) { BYTE aByte = m_Stream.ReadByte(); m_NormalValue = (aByte << (kNumBigValueBits - m_BitPos)) | m_NormalValue; m_Value = (m_Value << 8) | kInvertTable[aByte]; } } UINT32 GetValue(UINT32 aNumBits) { Normalize(); return ((m_Value >> (8 - m_BitPos)) & kMask) >> (kNumValueBits - aNumBits); } void MovePos(UINT32 aNumBits) { m_BitPos += aNumBits; m_NormalValue >>= aNumBits; } UINT32 ReadBits(UINT32 aNumBits) { Normalize(); UINT32 aRes = m_NormalValue & ( (1 << aNumBits) - 1); MovePos(aNumBits); return aRes; } UINT32 GetBitPosition() const { return (m_BitPos & 7); } }; }} #endif advancecomp-1.23/7z/LSBFEncoder.cc000066400000000000000000000014441301462770100166200ustar00rootroot00000000000000#include "Portable.h" #include "LSBFEncoder.h" namespace NStream { namespace NLSBF { void CEncoder::WriteBits(UINT32 aValue, UINT32 aNumBits) { while(aNumBits > 0) { UINT32 aNumNewBits = MyMin(aNumBits, m_BitPos); aNumBits -= aNumNewBits; UINT32 aMask = (1 << aNumNewBits) - 1; m_CurByte |= (aValue & aMask) << (8 - m_BitPos); aValue >>= aNumNewBits; m_BitPos -= aNumNewBits; if (m_BitPos == 0) { m_Stream.WriteByte(m_CurByte); m_BitPos = 8; m_CurByte = 0; } } } void CReverseEncoder::WriteBits(UINT32 aValue, UINT32 aNumBits) { UINT32 aReverseValue = 0; for(UINT32 i = 0; i < aNumBits; i++) { aReverseValue <<= 1; aReverseValue |= aValue & 1; aValue >>= 1; } m_Encoder->WriteBits(aReverseValue, aNumBits); } }} advancecomp-1.23/7z/LSBFEncoder.h000066400000000000000000000015441301462770100164630ustar00rootroot00000000000000#ifndef __STREAM_LSBFENCODER_H #define __STREAM_LSBFENCODER_H #include "IInOutStreams.h" #include "OutByte.h" namespace NStream { namespace NLSBF { class CEncoder { COutByte m_Stream; UINT32 m_BitPos; BYTE m_CurByte; public: void Init(ISequentialOutStream *aStream) { m_Stream.Init(aStream); m_BitPos = 8; m_CurByte = 0; } HRESULT Flush() { if(m_BitPos < 8) WriteBits(0, m_BitPos); return m_Stream.Flush(); } void WriteBits(UINT32 aValue, UINT32 aNumBits); UINT32 GetBitPosition() const { return (8 - m_BitPos); } UINT64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + (8 - m_BitPos + 7) /8; } }; class CReverseEncoder { CEncoder *m_Encoder; public: void Init(CEncoder *anEncoder) { m_Encoder = anEncoder; } void WriteBits(UINT32 aValue, UINT32 aNumBits); }; }} #endif advancecomp-1.23/7z/LZMA.cc000066400000000000000000000005411301462770100153320ustar00rootroot00000000000000#include "LZMA.h" namespace NCompress { namespace NLZMA { UINT32 kDistStart[kDistTableSizeMax]; static class CConstInit { public: CConstInit() { UINT32 aStartValue = 0; int i; for (i = 0; i < kDistTableSizeMax; i++) { kDistStart[i] = aStartValue; aStartValue += (1 << kDistDirectBits[i]); } } } g_ConstInit; }} advancecomp-1.23/7z/LZMA.h000066400000000000000000000051101301462770100151710ustar00rootroot00000000000000#include "LenCoder.h" #ifndef __LZMA_H #define __LZMA_H namespace NCompress { namespace NLZMA { const UINT32 kNumRepDistances = 4; const BYTE kNumStates = 12; const BYTE kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5}; const BYTE kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10}; const BYTE kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11}; const BYTE kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11}; class CState { public: BYTE m_Index; void Init() { m_Index = 0; } void UpdateChar() { m_Index = kLiteralNextStates[m_Index]; } void UpdateMatch() { m_Index = kMatchNextStates[m_Index]; } void UpdateRep() { m_Index = kRepNextStates[m_Index]; } void UpdateShortRep() { m_Index = kShortRepNextStates[m_Index]; } }; class CBaseCoder { protected: CState m_State; BYTE m_PreviousByte; bool m_PeviousIsMatch; UINT32 m_RepDistances[kNumRepDistances]; void Init() { m_State.Init(); m_PreviousByte = 0; m_PeviousIsMatch = false; for(int i = 0 ; i < kNumRepDistances; i++) m_RepDistances[i] = 0; } }; const int kNumPosSlotBits = 6; const int kDicLogSizeMax = 28; const int kDistTableSizeMax = kDicLogSizeMax * 2; extern UINT32 kDistStart[kDistTableSizeMax]; const BYTE kDistDirectBits[kDistTableSizeMax] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26 }; const UINT32 kNumLenToPosStates = 4; inline UINT32 GetLenToPosState(UINT32 aLen) { aLen -= 2; if (aLen < kNumLenToPosStates) return aLen; return kNumLenToPosStates - 1; } const int kMatchMinLen = 2; const int kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1; const int kNumAlignBits = 4; const int kAlignTableSize = 1 << kNumAlignBits; const UINT32 kAlignMask = (kAlignTableSize - 1); const int kStartPosModelIndex = 4; const int kEndPosModelIndex = 14; const int kNumPosModels = kEndPosModelIndex - kStartPosModelIndex; const int kNumFullDistances = 1 << (kEndPosModelIndex / 2); const int kMainChoiceLiteralIndex = 0; const int kMainChoiceMatchIndex = 1; const int kMatchChoiceDistanceIndex= 0; const int kMatchChoiceRepetitionIndex = 1; const int kNumMoveBitsForMainChoice = 5; const int kNumMoveBitsForPosCoders = 5; const int kNumMoveBitsForAlignCoders = 5; const int kNumMoveBitsForPosSlotCoder = 5; const int kNumLitPosStatesBitsEncodingMax = 4; const int kNumLitContextBitsMax = 8; }} #endif advancecomp-1.23/7z/LZMADecoder.cc000066400000000000000000000170401301462770100166220ustar00rootroot00000000000000#include "Portable.h" #include "LZMADecoder.h" #define RETURN_E_OUTOFMEMORY_IF_FALSE(x) { if (!(x)) return E_OUTOFMEMORY; } namespace NCompress { namespace NLZMA { HRESULT CDecoder::SetDictionarySize(INT aDictionarySize) { if (aDictionarySize > (1 << kDicLogSizeMax)) return E_INVALIDARG; INT aWindowReservSize = MyMax(aDictionarySize, INT(1 << 21)); if (m_DictionarySize != aDictionarySize) { m_OutWindowStream.Create(aDictionarySize, kMatchMaxLen, aWindowReservSize); m_DictionarySize = aDictionarySize; } return S_OK; } HRESULT CDecoder::SetLiteralProperties( INT aLiteralPosStateBits, INT aLiteralContextBits) { if (aLiteralPosStateBits > 8) return E_INVALIDARG; if (aLiteralContextBits > 8) return E_INVALIDARG; m_LiteralDecoder.Create(aLiteralPosStateBits, aLiteralContextBits); return S_OK; } HRESULT CDecoder::SetPosBitsProperties(INT aNumPosStateBits) { if (aNumPosStateBits > NLength::kNumPosStatesBitsMax) return E_INVALIDARG; INT aNumPosStates = 1 << aNumPosStateBits; m_LenDecoder.Create(aNumPosStates); m_RepMatchLenDecoder.Create(aNumPosStates); m_PosStateMask = aNumPosStates - 1; return S_OK; } CDecoder::CDecoder(): m_DictionarySize((INT)-1) { Create(); } HRESULT CDecoder::Create() { for(int i = 0; i < kNumPosModels; i++) { RETURN_E_OUTOFMEMORY_IF_FALSE( m_PosDecoders[i].Create(kDistDirectBits[kStartPosModelIndex + i])); } return S_OK; } HRESULT CDecoder::Init(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream) { m_RangeDecoder.Init(anInStream); m_OutWindowStream.Init(anOutStream); int i; for(i = 0; i < kNumStates; i++) { for (INT j = 0; j <= m_PosStateMask; j++) { m_MainChoiceDecoders[i][j].Init(); m_MatchRepShortChoiceDecoders[i][j].Init(); } m_MatchChoiceDecoders[i].Init(); m_MatchRepChoiceDecoders[i].Init(); m_MatchRep1ChoiceDecoders[i].Init(); m_MatchRep2ChoiceDecoders[i].Init(); } m_LiteralDecoder.Init(); for (i = 0; i < kNumLenToPosStates; i++) m_PosSlotDecoder[i].Init(); for(i = 0; i < kNumPosModels; i++) m_PosDecoders[i].Init(); m_LenDecoder.Init(); m_RepMatchLenDecoder.Init(); m_PosAlignDecoder.Init(); return S_OK; } HRESULT CDecoder::CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize) { if (anOutSize == NULL) return E_INVALIDARG; Init(anInStream, anOutStream); CState aState; aState.Init(); bool aPeviousIsMatch = false; BYTE aPreviousByte = 0; INT aRepDistances[kNumRepDistances]; for(int i = 0 ; i < kNumRepDistances; i++) aRepDistances[i] = 0; UINT64 aNowPos64 = 0; UINT64 aSize = *anOutSize; while(aNowPos64 < aSize) { UINT64 aNext = MyMin(aNowPos64 + (1 << 18), aSize); while(aNowPos64 < aNext) { INT aPosState = INT(aNowPos64) & m_PosStateMask; if (m_MainChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == kMainChoiceLiteralIndex) { aState.UpdateChar(); if(aPeviousIsMatch) { BYTE aMatchByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1); aPreviousByte = m_LiteralDecoder.DecodeWithMatchByte(&m_RangeDecoder, INT(aNowPos64), aPreviousByte, aMatchByte); aPeviousIsMatch = false; } else aPreviousByte = m_LiteralDecoder.DecodeNormal(&m_RangeDecoder, INT(aNowPos64), aPreviousByte); m_OutWindowStream.PutOneByte(aPreviousByte); aNowPos64++; } else { aPeviousIsMatch = true; INT aDistance, aLen; if(m_MatchChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == kMatchChoiceRepetitionIndex) { if(m_MatchRepChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0) { if(m_MatchRepShortChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == 0) { aState.UpdateShortRep(); aPreviousByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1); m_OutWindowStream.PutOneByte(aPreviousByte); aNowPos64++; continue; } aDistance = aRepDistances[0]; } else { if(m_MatchRep1ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0) { aDistance = aRepDistances[1]; aRepDistances[1] = aRepDistances[0]; } else { if (m_MatchRep2ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0) { aDistance = aRepDistances[2]; } else { aDistance = aRepDistances[3]; aRepDistances[3] = aRepDistances[2]; } aRepDistances[2] = aRepDistances[1]; aRepDistances[1] = aRepDistances[0]; } aRepDistances[0] = aDistance; } aLen = m_RepMatchLenDecoder.Decode(&m_RangeDecoder, aPosState) + kMatchMinLen; aState.UpdateRep(); } else { aLen = kMatchMinLen + m_LenDecoder.Decode(&m_RangeDecoder, aPosState); aState.UpdateMatch(); INT aPosSlot = m_PosSlotDecoder[GetLenToPosState(aLen)].Decode(&m_RangeDecoder); if (aPosSlot >= kStartPosModelIndex) { aDistance = kDistStart[aPosSlot]; if (aPosSlot < kEndPosModelIndex) aDistance += m_PosDecoders[aPosSlot - kStartPosModelIndex].Decode(&m_RangeDecoder); else { aDistance += (m_RangeDecoder.DecodeDirectBits(kDistDirectBits[aPosSlot] - kNumAlignBits) << kNumAlignBits); aDistance += m_PosAlignDecoder.Decode(&m_RangeDecoder); } } else aDistance = aPosSlot; aRepDistances[3] = aRepDistances[2]; aRepDistances[2] = aRepDistances[1]; aRepDistances[1] = aRepDistances[0]; aRepDistances[0] = aDistance; } if (aDistance >= aNowPos64) throw E_INVALIDDATA; m_OutWindowStream.CopyBackBlock(aDistance, aLen); aNowPos64 += aLen; aPreviousByte = m_OutWindowStream.GetOneByte(0 - 1); } } } return Flush(); } HRESULT CDecoder::Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize) { try { return CodeReal(anInStream, anOutStream, anInSize, anOutSize); } catch (HRESULT& e) { return e; } catch (...) { return E_FAIL; } } HRESULT CDecoder::ReadCoderProperties(ISequentialInStream *anInStream) { INT aNumPosStateBits; INT aLiteralPosStateBits; INT aLiteralContextBits; INT aDictionarySize; INT aProcessesedSize; BYTE aByte; RETURN_IF_NOT_S_OK(anInStream->Read(&aByte, sizeof(aByte), &aProcessesedSize)); if (aProcessesedSize != sizeof(aByte)) return E_INVALIDARG; aLiteralContextBits = aByte % 9; BYTE aRemainder = aByte / 9; aLiteralPosStateBits = aRemainder % 5; aNumPosStateBits = aRemainder / 5; RETURN_IF_NOT_S_OK(anInStream->Read(&aDictionarySize, sizeof(aDictionarySize), &aProcessesedSize)); if (aProcessesedSize != sizeof(aDictionarySize)) return E_INVALIDARG; RETURN_IF_NOT_S_OK(SetDictionarySize(aDictionarySize)); RETURN_IF_NOT_S_OK(SetLiteralProperties(aLiteralPosStateBits, aLiteralContextBits)); RETURN_IF_NOT_S_OK(SetPosBitsProperties(aNumPosStateBits)); return S_OK; } }} advancecomp-1.23/7z/LZMADecoder.h000066400000000000000000000035731301462770100164720ustar00rootroot00000000000000#ifndef __LZARITHMETIC_DECODER_H #define __LZARITHMETIC_DECODER_H #include "WindowOut.h" #include "LZMA.h" #include "LenCoder.h" #include "LiteralCoder.h" namespace NCompress { namespace NLZMA { typedef CMyBitDecoder CMyBitDecoder2; class CDecoder { NStream::NWindow::COut m_OutWindowStream; CMyRangeDecoder m_RangeDecoder; CMyBitDecoder2 m_MainChoiceDecoders[kNumStates][NLength::kNumPosStatesMax]; CMyBitDecoder2 m_MatchChoiceDecoders[kNumStates]; CMyBitDecoder2 m_MatchRepChoiceDecoders[kNumStates]; CMyBitDecoder2 m_MatchRep1ChoiceDecoders[kNumStates]; CMyBitDecoder2 m_MatchRep2ChoiceDecoders[kNumStates]; CMyBitDecoder2 m_MatchRepShortChoiceDecoders[kNumStates][NLength::kNumPosStatesMax]; CBitTreeDecoder m_PosSlotDecoder[kNumLenToPosStates]; CReverseBitTreeDecoder2 m_PosDecoders[kNumPosModels]; CReverseBitTreeDecoder m_PosAlignDecoder; NLength::CDecoder m_LenDecoder; NLength::CDecoder m_RepMatchLenDecoder; NLiteral::CDecoder m_LiteralDecoder; INT m_DictionarySize; INT m_PosStateMask; HRESULT Create(); HRESULT Init(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream); HRESULT Flush() { return m_OutWindowStream.Flush(); } HRESULT CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize); public: CDecoder(); HRESULT Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize, const UINT64 *anOutSize); HRESULT ReadCoderProperties(ISequentialInStream *anInStream); HRESULT SetDictionarySize(INT aDictionarySize); HRESULT SetLiteralProperties(INT aLiteralPosStateBits, INT aLiteralContextBits); HRESULT SetPosBitsProperties(INT aNumPosStateBits); }; }} #endif advancecomp-1.23/7z/LZMAEncoder.cc000066400000000000000000000665231301462770100166460ustar00rootroot00000000000000#include "Portable.h" #include "LZMAEncoder.h" #include "BinTree2Main.h" using namespace NCompression; using namespace NArithmetic; #define RETURN_E_OUTOFMEMORY_IF_FALSE(x) { if (!(x)) return E_OUTOFMEMORY; } namespace NCompress { namespace NLZMA { BYTE g_FastPos[1024]; class CFastPosInit { public: CFastPosInit() { int c = 0; const int kFastSlots = 20; c = 0; for (BYTE aSlotFast = 0; aSlotFast < kFastSlots; aSlotFast++) { INT k = (1 << kDistDirectBits[aSlotFast]); for (INT j = 0; j < k; j++, c++) g_FastPos[c] = aSlotFast; } } } g_FastPosInit; const int kDefaultDictionaryLogSize = 20; const int kNumFastBytesDefault = 0x20; CEncoder::CEncoder(): m_DictionarySize(1 << kDefaultDictionaryLogSize), m_DictionarySizePrev(INT(-1)), m_NumFastBytes(kNumFastBytesDefault), m_NumFastBytesPrev(INT(-1)), m_DistTableSize(kDefaultDictionaryLogSize * 2), m_PosStateBits(2), m_PosStateMask(4 - 1), m_LiteralPosStateBits(0), m_LiteralContextBits(3) { m_MaxMode = false; m_FastMode = false; m_PosAlignEncoder.Create(kNumAlignBits); for(int i = 0; i < kNumPosModels; i++) m_PosEncoders[i].Create(kDistDirectBits[kStartPosModelIndex + i]); } HRESULT CEncoder::Create() { if (m_DictionarySize == m_DictionarySizePrev && m_NumFastBytesPrev == m_NumFastBytes) return S_OK; RETURN_IF_NOT_S_OK(m_MatchFinder.Create(m_DictionarySize, kNumOpts, m_NumFastBytes, kMatchMaxLen - m_NumFastBytes)); m_DictionarySizePrev = m_DictionarySize; m_NumFastBytesPrev = m_NumFastBytes; m_LiteralEncoder.Create(m_LiteralPosStateBits, m_LiteralContextBits); m_LenEncoder.Create(1 << m_PosStateBits); m_RepMatchLenEncoder.Create(1 << m_PosStateBits); return S_OK; } HRESULT CEncoder::SetEncoderAlgorithm(INT A) { INT aMaximize = A; if (aMaximize > 2) return E_INVALIDARG; m_FastMode = (aMaximize == 0); m_MaxMode = (aMaximize >= 2); return S_OK; } HRESULT CEncoder::SetEncoderNumFastBytes(INT A) { INT aNumFastBytes = A; if(aNumFastBytes < 2 || aNumFastBytes > kMatchMaxLen) return E_INVALIDARG; m_NumFastBytes = aNumFastBytes; return S_OK; } HRESULT CEncoder::SetDictionarySize(INT aDictionarySize) { if (aDictionarySize > INT(1 << kDicLogSizeMax)) return E_INVALIDARG; m_DictionarySize = aDictionarySize; INT aDicLogSize; for(aDicLogSize = 0; aDicLogSize < kDicLogSizeMax; aDicLogSize++) if (aDictionarySize <= (INT(1) << aDicLogSize)) break; m_DistTableSize = aDicLogSize * 2; return S_OK; } HRESULT CEncoder::SetLiteralProperties(INT aLiteralPosStateBits, INT aLiteralContextBits) { if (aLiteralPosStateBits > kNumLitPosStatesBitsEncodingMax) return E_INVALIDARG; if (aLiteralContextBits > kNumLitContextBitsMax) return E_INVALIDARG; m_LiteralPosStateBits = aLiteralPosStateBits; m_LiteralContextBits = aLiteralContextBits; return S_OK; } HRESULT CEncoder::SetPosBitsProperties(INT aNumPosStateBits) { if (aNumPosStateBits > NLength::kNumPosStatesBitsEncodingMax) return E_INVALIDARG; m_PosStateBits = aNumPosStateBits; m_PosStateMask = (1 << m_PosStateBits) - 1; return S_OK; } HRESULT CEncoder::WriteCoderProperties(ISequentialOutStream *anOutStream) { BYTE aByte = (m_PosStateBits * 5 + m_LiteralPosStateBits) * 9 + m_LiteralContextBits; INT aProcessedSize; HRESULT aResult = anOutStream->Write(&aByte, sizeof(aByte), &aProcessedSize); if (aResult != S_OK) return aResult; if (aProcessedSize != sizeof(aByte)) return E_FAIL; aResult = anOutStream->Write(&m_DictionarySize, sizeof(m_DictionarySize), &aProcessedSize); if (aResult != S_OK) return aResult; if (aProcessedSize != sizeof(m_DictionarySize)) return E_FAIL; return S_OK; } HRESULT CEncoder::Init(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream) { CBaseCoder::Init(); RETURN_IF_NOT_S_OK(m_MatchFinder.Init(anInStream)); m_RangeEncoder.Init(anOutStream); int i; for(i = 0; i < kNumStates; i++) { for (INT j = 0; j <= m_PosStateMask; j++) { m_MainChoiceEncoders[i][j].Init(); m_MatchRepShortChoiceEncoders[i][j].Init(); } m_MatchChoiceEncoders[i].Init(); m_MatchRepChoiceEncoders[i].Init(); m_MatchRep1ChoiceEncoders[i].Init(); m_MatchRep2ChoiceEncoders[i].Init(); } m_LiteralEncoder.Init(); for(i = 0; i < kNumLenToPosStates; i++) m_PosSlotEncoder[i].Init(); for(i = 0; i < kNumPosModels; i++) m_PosEncoders[i].Init(); m_LenEncoder.Init(); m_RepMatchLenEncoder.Init(); m_PosAlignEncoder.Init(); m_LongestMatchWasFound = false; m_OptimumEndIndex = 0; m_OptimumCurrentIndex = 0; m_AdditionalOffset = 0; return S_OK; } void CEncoder::MovePos(INT aNum) { for (;aNum > 0; aNum--) { m_MatchFinder.DummyLongestMatch(); HRESULT aResult = m_MatchFinder.MovePos(); if (aResult != S_OK) throw aResult; m_AdditionalOffset++; } } INT CEncoder::Backward(INT &aBackRes, INT aCur) { m_OptimumEndIndex = aCur; INT aPosMem = m_Optimum[aCur].PosPrev; INT aBackMem = m_Optimum[aCur].BackPrev; do { if (m_Optimum[aCur].Prev1IsChar) { m_Optimum[aPosMem].MakeAsChar(); m_Optimum[aPosMem].PosPrev = aPosMem - 1; if (m_Optimum[aCur].Prev2) { m_Optimum[aPosMem - 1].Prev1IsChar = false; m_Optimum[aPosMem - 1].PosPrev = m_Optimum[aCur].PosPrev2; m_Optimum[aPosMem - 1].BackPrev = m_Optimum[aCur].BackPrev2; } } INT aPosPrev = aPosMem; INT aBackCur = aBackMem; aBackMem = m_Optimum[aPosPrev].BackPrev; aPosMem = m_Optimum[aPosPrev].PosPrev; m_Optimum[aPosPrev].BackPrev = aBackCur; m_Optimum[aPosPrev].PosPrev = aCur; aCur = aPosPrev; } while(aCur > 0); aBackRes = m_Optimum[0].BackPrev; m_OptimumCurrentIndex = m_Optimum[0].PosPrev; return m_OptimumCurrentIndex; } INT CEncoder::GetOptimum(INT &aBackRes, INT aPosition) { if(m_OptimumEndIndex != m_OptimumCurrentIndex) { INT aLen = m_Optimum[m_OptimumCurrentIndex].PosPrev - m_OptimumCurrentIndex; aBackRes = m_Optimum[m_OptimumCurrentIndex].BackPrev; m_OptimumCurrentIndex = m_Optimum[m_OptimumCurrentIndex].PosPrev; return aLen; } m_OptimumCurrentIndex = 0; m_OptimumEndIndex = 0; // test it; INT aLenMain; if (!m_LongestMatchWasFound) aLenMain = ReadMatchDistances(); else { aLenMain = m_LongestMatchLength; m_LongestMatchWasFound = false; } INT aReps[kNumRepDistances]; INT aRepLens[kNumRepDistances]; INT RepMaxIndex = 0; int i; for(i = 0; i < kNumRepDistances; i++) { aReps[i] = m_RepDistances[i]; aRepLens[i] = m_MatchFinder.GetMatchLen(0 - 1, aReps[i], kMatchMaxLen); if (i == 0 || aRepLens[i] > aRepLens[RepMaxIndex]) RepMaxIndex = i; } if(aRepLens[RepMaxIndex] > m_NumFastBytes) { aBackRes = RepMaxIndex; MovePos(aRepLens[RepMaxIndex] - 1); return aRepLens[RepMaxIndex]; } if(aLenMain > m_NumFastBytes) { INT aBackMain = (aLenMain < m_NumFastBytes) ? m_MatchDistances[aLenMain] : m_MatchDistances[m_NumFastBytes]; aBackRes = aBackMain + kNumRepDistances; MovePos(aLenMain - 1); return aLenMain; } BYTE aCurrentByte = m_MatchFinder.GetIndexByte(0 - 1); m_Optimum[0].State = m_State; BYTE aMatchByte; aMatchByte = m_MatchFinder.GetIndexByte(0 - m_RepDistances[0] - 1 - 1); INT aPosState = (aPosition & m_PosStateMask); m_Optimum[1].Price = m_MainChoiceEncoders[m_State.m_Index][aPosState].GetPrice(kMainChoiceLiteralIndex) + m_LiteralEncoder.GetPrice(aPosition, m_PreviousByte, m_PeviousIsMatch, aMatchByte, aCurrentByte); m_Optimum[1].MakeAsChar(); m_Optimum[1].PosPrev = 0; for (i = 0; i < kNumRepDistances; i++) m_Optimum[0].Backs[i] = aReps[i]; INT aMatchPrice = m_MainChoiceEncoders[m_State.m_Index][aPosState].GetPrice(kMainChoiceMatchIndex); INT aRepMatchPrice = aMatchPrice + m_MatchChoiceEncoders[m_State.m_Index].GetPrice(kMatchChoiceRepetitionIndex); if(aMatchByte == aCurrentByte) { INT aShortRepPrice = aRepMatchPrice + GetRepLen1Price(m_State, aPosState); if(aShortRepPrice < m_Optimum[1].Price) { m_Optimum[1].Price = aShortRepPrice; m_Optimum[1].MakeAsShortRep(); } } if(aLenMain < 2) { aBackRes = m_Optimum[1].BackPrev; return 1; } INT aNormalMatchPrice = aMatchPrice + m_MatchChoiceEncoders[m_State.m_Index].GetPrice(kMatchChoiceDistanceIndex); if (aLenMain <= aRepLens[RepMaxIndex]) aLenMain = 0; INT aLen; for(aLen = 2; aLen <= aLenMain; aLen++) { m_Optimum[aLen].PosPrev = 0; m_Optimum[aLen].BackPrev = m_MatchDistances[aLen] + kNumRepDistances; m_Optimum[aLen].Price = aNormalMatchPrice + GetPosLenPrice(m_MatchDistances[aLen], aLen, aPosState); m_Optimum[aLen].Prev1IsChar = false; } if (aLenMain < aRepLens[RepMaxIndex]) aLenMain = aRepLens[RepMaxIndex]; for (; aLen <= aLenMain; aLen++) m_Optimum[aLen].Price = kIfinityPrice; for(i = 0; i < kNumRepDistances; i++) { unsigned aRepLen = aRepLens[i]; for(INT aLenTest = 2; aLenTest <= aRepLen; aLenTest++) { INT aCurAndLenPrice = aRepMatchPrice + GetRepPrice(i, aLenTest, m_State, aPosState); COptimal &anOptimum = m_Optimum[aLenTest]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = 0; anOptimum.BackPrev = i; anOptimum.Prev1IsChar = false; } } } INT aCur = 0; INT aLenEnd = aLenMain; while(true) { aCur++; if(aCur == aLenEnd) return Backward(aBackRes, aCur); aPosition++; INT aPosPrev = m_Optimum[aCur].PosPrev; CState aState; if (m_Optimum[aCur].Prev1IsChar) { aPosPrev--; if (m_Optimum[aCur].Prev2) { aState = m_Optimum[m_Optimum[aCur].PosPrev2].State; if (m_Optimum[aCur].BackPrev2 < kNumRepDistances) aState.UpdateRep(); else aState.UpdateMatch(); } else aState = m_Optimum[aPosPrev].State; aState.UpdateChar(); } else aState = m_Optimum[aPosPrev].State; bool aPrevWasMatch; if (aPosPrev == aCur - 1) { if (m_Optimum[aCur].IsShortRep()) { aPrevWasMatch = true; aState.UpdateShortRep(); } else { aPrevWasMatch = false; aState.UpdateChar(); } /* if (m_Optimum[aCur].Prev1IsChar) for(int i = 0; i < kNumRepDistances; i++) aReps[i] = m_Optimum[aPosPrev].Backs[i]; */ } else { aPrevWasMatch = true; INT aPos; if (m_Optimum[aCur].Prev1IsChar && m_Optimum[aCur].Prev2) { aPosPrev = m_Optimum[aCur].PosPrev2; aPos = m_Optimum[aCur].BackPrev2; aState.UpdateRep(); } else { aPos = m_Optimum[aCur].BackPrev; if (aPos < kNumRepDistances) aState.UpdateRep(); else aState.UpdateMatch(); } if (aPos < kNumRepDistances) { aReps[0] = m_Optimum[aPosPrev].Backs[aPos]; INT i; for(i = 1; i <= aPos; i++) aReps[i] = m_Optimum[aPosPrev].Backs[i - 1]; for(; i < kNumRepDistances; i++) aReps[i] = m_Optimum[aPosPrev].Backs[i]; } else { aReps[0] = (aPos - kNumRepDistances); for(INT i = 1; i < kNumRepDistances; i++) aReps[i] = m_Optimum[aPosPrev].Backs[i - 1]; } } m_Optimum[aCur].State = aState; for(INT i = 0; i < kNumRepDistances; i++) m_Optimum[aCur].Backs[i] = aReps[i]; INT aNewLen = ReadMatchDistances(); if(aNewLen > m_NumFastBytes) { m_LongestMatchLength = aNewLen; m_LongestMatchWasFound = true; return Backward(aBackRes, aCur); } INT aCurPrice = m_Optimum[aCur].Price; const BYTE *aData = m_MatchFinder.GetPointerToCurrentPos() - 1; BYTE aCurrentByte = *aData; BYTE aMatchByte = aData[0 - aReps[0] - 1]; INT aPosState = (aPosition & m_PosStateMask); INT aCurAnd1Price = aCurPrice + m_MainChoiceEncoders[aState.m_Index][aPosState].GetPrice(kMainChoiceLiteralIndex) + m_LiteralEncoder.GetPrice(aPosition, aData[-1], aPrevWasMatch, aMatchByte, aCurrentByte); COptimal &aNextOptimum = m_Optimum[aCur + 1]; bool aNextIsChar = false; if (aCurAnd1Price < aNextOptimum.Price) { aNextOptimum.Price = aCurAnd1Price; aNextOptimum.PosPrev = aCur; aNextOptimum.MakeAsChar(); aNextIsChar = true; } INT aMatchPrice = aCurPrice + m_MainChoiceEncoders[aState.m_Index][aPosState].GetPrice(kMainChoiceMatchIndex); INT aRepMatchPrice = aMatchPrice + m_MatchChoiceEncoders[aState.m_Index].GetPrice(kMatchChoiceRepetitionIndex); if(aMatchByte == aCurrentByte && !(aNextOptimum.PosPrev < aCur && aNextOptimum.BackPrev == 0)) { INT aShortRepPrice = aRepMatchPrice + GetRepLen1Price(aState, aPosState); if(aShortRepPrice <= aNextOptimum.Price) { aNextOptimum.Price = aShortRepPrice; aNextOptimum.PosPrev = aCur; aNextOptimum.MakeAsShortRep(); } } INT aNumAvailableBytes = m_MatchFinder.GetNumAvailableBytes() + 1; aNumAvailableBytes = MyMin(kNumOpts - 1 - aCur, aNumAvailableBytes); if (aNumAvailableBytes < 2) continue; if (aNumAvailableBytes > m_NumFastBytes) aNumAvailableBytes = m_NumFastBytes; if (aNumAvailableBytes >= 3 && !aNextIsChar) { INT aBackOffset = aReps[0] + 1; INT aTemp; for (aTemp = 1; aTemp < aNumAvailableBytes; aTemp++) if (aData[aTemp] != aData[aTemp - aBackOffset]) break; INT aLenTest2 = aTemp - 1; if (aLenTest2 >= 2) { CState aState2 = aState; aState2.UpdateChar(); INT aPosStateNext = (aPosition + 1) & m_PosStateMask; INT aNextRepMatchPrice = aCurAnd1Price + m_MainChoiceEncoders[aState2.m_Index][aPosStateNext].GetPrice(kMainChoiceMatchIndex) + m_MatchChoiceEncoders[aState2.m_Index].GetPrice(kMatchChoiceRepetitionIndex); { while(aLenEnd < aCur + 1 + aLenTest2) m_Optimum[++aLenEnd].Price = kIfinityPrice; INT aCurAndLenPrice = aNextRepMatchPrice + GetRepPrice( 0, aLenTest2, aState2, aPosStateNext); COptimal &anOptimum = m_Optimum[aCur + 1 + aLenTest2]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = aCur + 1; anOptimum.BackPrev = 0; anOptimum.Prev1IsChar = true; anOptimum.Prev2 = false; } } } } for(INT aRepIndex = 0; aRepIndex < kNumRepDistances; aRepIndex++) { INT aBackOffset = aReps[aRepIndex] + 1; INT aLenTest; for (aLenTest = 0; aLenTest < aNumAvailableBytes; aLenTest++) if (aData[aLenTest] != aData[aLenTest - aBackOffset]) break; for(; aLenTest >= 2; aLenTest--) { while(aLenEnd < aCur + aLenTest) m_Optimum[++aLenEnd].Price = kIfinityPrice; INT aCurAndLenPrice = aRepMatchPrice + GetRepPrice(aRepIndex, aLenTest, aState, aPosState); COptimal &anOptimum = m_Optimum[aCur + aLenTest]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = aCur; anOptimum.BackPrev = aRepIndex; anOptimum.Prev1IsChar = false; } } } if (aNewLen > aNumAvailableBytes) aNewLen = aNumAvailableBytes; if (aNewLen >= 2) { if (aNewLen == 2 && m_MatchDistances[2] >= 0x80) continue; INT aNormalMatchPrice = aMatchPrice + m_MatchChoiceEncoders[aState.m_Index].GetPrice(kMatchChoiceDistanceIndex); while(aLenEnd < aCur + aNewLen) m_Optimum[++aLenEnd].Price = kIfinityPrice; for(INT aLenTest = aNewLen; aLenTest >= 2; aLenTest--) { INT aCurBack = m_MatchDistances[aLenTest]; INT aCurAndLenPrice = aNormalMatchPrice + GetPosLenPrice(aCurBack, aLenTest, aPosState); COptimal &anOptimum = m_Optimum[aCur + aLenTest]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = aCur; anOptimum.BackPrev = aCurBack + kNumRepDistances; anOptimum.Prev1IsChar = false; } if (m_MaxMode) { INT aBackOffset = aCurBack + 1; INT aTemp; for (aTemp = aLenTest + 1; aTemp < aNumAvailableBytes; aTemp++) if (aData[aTemp] != aData[aTemp - aBackOffset]) break; INT aLenTest2 = aTemp - (aLenTest + 1); if (aLenTest2 >= 2) { CState aState2 = aState; aState2.UpdateMatch(); INT aPosStateNext = (aPosition + aLenTest) & m_PosStateMask; INT aCurAndLenCharPrice = aCurAndLenPrice + m_MainChoiceEncoders[aState2.m_Index][aPosStateNext].GetPrice(kMainChoiceLiteralIndex) + m_LiteralEncoder.GetPrice(aPosition + aLenTest, aData[aLenTest - 1], true, aData[aLenTest - aBackOffset], aData[aLenTest]); aState2.UpdateChar(); aPosStateNext = (aPosition + aLenTest + 1) & m_PosStateMask; INT aNextMatchPrice = aCurAndLenCharPrice + m_MainChoiceEncoders[aState2.m_Index][aPosStateNext].GetPrice(kMainChoiceMatchIndex); INT aNextRepMatchPrice = aNextMatchPrice + m_MatchChoiceEncoders[aState2.m_Index].GetPrice(kMatchChoiceRepetitionIndex); { INT anOffset = aLenTest + 1 + aLenTest2; while(aLenEnd < aCur + anOffset) m_Optimum[++aLenEnd].Price = kIfinityPrice; INT aCurAndLenPrice = aNextRepMatchPrice + GetRepPrice( 0, aLenTest2, aState2, aPosStateNext); COptimal &anOptimum = m_Optimum[aCur + anOffset]; if (aCurAndLenPrice < anOptimum.Price) { anOptimum.Price = aCurAndLenPrice; anOptimum.PosPrev = aCur + aLenTest + 1; anOptimum.BackPrev = 0; anOptimum.Prev1IsChar = true; anOptimum.Prev2 = true; anOptimum.PosPrev2 = aCur; anOptimum.BackPrev2 = aCurBack + kNumRepDistances; } } } } } } } } static bool inline ChangePair(INT aSmall, INT aBig) { const int kDif = 7; return (aSmall < (INT(1) << (32-kDif)) && aBig >= (aSmall << kDif)); } INT CEncoder::GetOptimumFast(INT &aBackRes, INT aPosition) { INT aLenMain; if (!m_LongestMatchWasFound) aLenMain = ReadMatchDistances(); else { aLenMain = m_LongestMatchLength; m_LongestMatchWasFound = false; } INT aRepLens[kNumRepDistances]; INT RepMaxIndex = 0; for(int i = 0; i < kNumRepDistances; i++) { aRepLens[i] = m_MatchFinder.GetMatchLen(0 - 1, m_RepDistances[i], kMatchMaxLen); if (i == 0 || aRepLens[i] > aRepLens[RepMaxIndex]) RepMaxIndex = i; } if(aRepLens[RepMaxIndex] >= m_NumFastBytes) { aBackRes = RepMaxIndex; MovePos(aRepLens[RepMaxIndex] - 1); return aRepLens[RepMaxIndex]; } if(aLenMain >= m_NumFastBytes) { aBackRes = m_MatchDistances[m_NumFastBytes] + kNumRepDistances; MovePos(aLenMain - 1); return aLenMain; } while (aLenMain > 2) { if (!ChangePair(m_MatchDistances[aLenMain - 1], m_MatchDistances[aLenMain])) break; aLenMain--; } if (aLenMain == 2 && m_MatchDistances[2] >= 0x80) aLenMain = 1; INT aBackMain = m_MatchDistances[aLenMain]; if (aRepLens[RepMaxIndex] >= 2) { if (aRepLens[RepMaxIndex] + 1 >= aLenMain || aRepLens[RepMaxIndex] + 2 >= aLenMain && (aBackMain > (1<<12))) { aBackRes = RepMaxIndex; MovePos(aRepLens[RepMaxIndex] - 1); return aRepLens[RepMaxIndex]; } } if (aLenMain >= 2) { m_LongestMatchLength = ReadMatchDistances(); if (m_LongestMatchLength >= 2 && ( (m_LongestMatchLength >= aLenMain && m_MatchDistances[aLenMain] < aBackMain) || m_LongestMatchLength == aLenMain + 1 && !ChangePair(aBackMain, m_MatchDistances[m_LongestMatchLength]) || m_LongestMatchLength > aLenMain + 1 || m_LongestMatchLength + 1 >= aLenMain && ChangePair(m_MatchDistances[aLenMain - 1], aBackMain) ) ) { m_LongestMatchWasFound = true; aBackRes = INT(-1); return 1; } for(int i = 0; i < kNumRepDistances; i++) { INT aRepLen = m_MatchFinder.GetMatchLen(0 - 1, m_RepDistances[i], kMatchMaxLen); if (aRepLen >= 2 && aRepLen + 1 >= aLenMain) { m_LongestMatchWasFound = true; aBackRes = INT(-1); return 1; } } aBackRes = aBackMain + kNumRepDistances; MovePos(aLenMain - 2); return aLenMain; } aBackRes = INT(-1); return 1; } HRESULT CEncoder::Flush() { m_RangeEncoder.FlushData(); return m_RangeEncoder.FlushStream(); } HRESULT CEncoder::CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize) { RETURN_IF_NOT_S_OK(Create()); Init(anInStream, anOutStream); if (m_MatchFinder.GetNumAvailableBytes() == 0) return Flush(); if (!m_FastMode) { FillPosSlotPrices(); FillDistancesPrices(); FillAlignPrices(); } m_LenEncoder.SetTableSize(m_NumFastBytes); m_LenEncoder.UpdateTables(); m_RepMatchLenEncoder.SetTableSize(m_NumFastBytes); m_RepMatchLenEncoder.UpdateTables(); UINT64 aLastPosSlotFillingPos = 0; UINT64 aNowPos64 = 0; ReadMatchDistances(); INT aPosState = INT(aNowPos64) & m_PosStateMask; m_MainChoiceEncoders[m_State.m_Index][aPosState].Encode(&m_RangeEncoder, kMainChoiceLiteralIndex); m_State.UpdateChar(); BYTE aByte = m_MatchFinder.GetIndexByte(0 - m_AdditionalOffset); m_LiteralEncoder.Encode(&m_RangeEncoder, INT(aNowPos64), m_PreviousByte, false, 0, aByte); m_PreviousByte = aByte; m_AdditionalOffset--; aNowPos64++; if (m_MatchFinder.GetNumAvailableBytes() == 0) return Flush(); while(true) { INT aPos; INT aPosState = INT(aNowPos64) & m_PosStateMask; INT aLen; if (m_FastMode) aLen = GetOptimumFast(aPos, INT(aNowPos64)); else aLen = GetOptimum(aPos, INT(aNowPos64)); if(aLen == 1 && aPos == (-1)) { m_MainChoiceEncoders[m_State.m_Index][aPosState].Encode(&m_RangeEncoder, kMainChoiceLiteralIndex); m_State.UpdateChar(); BYTE aMatchByte; if(m_PeviousIsMatch) aMatchByte = m_MatchFinder.GetIndexByte(0 - m_RepDistances[0] - 1 - m_AdditionalOffset); BYTE aByte = m_MatchFinder.GetIndexByte(0 - m_AdditionalOffset); m_LiteralEncoder.Encode(&m_RangeEncoder, INT(aNowPos64), m_PreviousByte, m_PeviousIsMatch, aMatchByte, aByte); m_PreviousByte = aByte; m_PeviousIsMatch = false; } else { m_PeviousIsMatch = true; m_MainChoiceEncoders[m_State.m_Index][aPosState].Encode(&m_RangeEncoder, kMainChoiceMatchIndex); if(aPos < kNumRepDistances) { m_MatchChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, kMatchChoiceRepetitionIndex); if(aPos == 0) { m_MatchRepChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, 0); if(aLen == 1) m_MatchRepShortChoiceEncoders[m_State.m_Index][aPosState].Encode(&m_RangeEncoder, 0); else m_MatchRepShortChoiceEncoders[m_State.m_Index][aPosState].Encode(&m_RangeEncoder, 1); } else { m_MatchRepChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, 1); if (aPos == 1) m_MatchRep1ChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, 0); else { m_MatchRep1ChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, 1); m_MatchRep2ChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, aPos - 2); } } if (aLen == 1) m_State.UpdateShortRep(); else { m_RepMatchLenEncoder.Encode(&m_RangeEncoder, aLen - kMatchMinLen, aPosState); m_State.UpdateRep(); } INT aDistance = m_RepDistances[aPos]; if (aPos != 0) { for(INT i = aPos; i >= 1; i--) m_RepDistances[i] = m_RepDistances[i - 1]; m_RepDistances[0] = aDistance; } } else { m_MatchChoiceEncoders[m_State.m_Index].Encode(&m_RangeEncoder, kMatchChoiceDistanceIndex); m_State.UpdateMatch(); m_LenEncoder.Encode(&m_RangeEncoder, aLen - kMatchMinLen, aPosState); aPos -= kNumRepDistances; INT aPosSlot = GetPosSlot(aPos); INT aLenToPosState = GetLenToPosState(aLen); m_PosSlotEncoder[aLenToPosState].Encode(&m_RangeEncoder, aPosSlot); INT aFooterBits = kDistDirectBits[aPosSlot]; INT aPosReduced = aPos - kDistStart[aPosSlot]; if (aPosSlot >= kStartPosModelIndex) { if (aPosSlot < kEndPosModelIndex) m_PosEncoders[aPosSlot - kStartPosModelIndex].Encode(&m_RangeEncoder, aPosReduced); else { m_RangeEncoder.EncodeDirectBits(aPosReduced >> kNumAlignBits, aFooterBits - kNumAlignBits); m_PosAlignEncoder.Encode(&m_RangeEncoder, aPosReduced & kAlignMask); if (!m_FastMode) if (--m_AlignPriceCount == 0) FillAlignPrices(); } } INT aDistance = aPos; for(INT i = kNumRepDistances - 1; i >= 1; i--) m_RepDistances[i] = m_RepDistances[i - 1]; m_RepDistances[0] = aDistance; } m_PreviousByte = m_MatchFinder.GetIndexByte(aLen - 1 - m_AdditionalOffset); } m_AdditionalOffset -= aLen; aNowPos64 += aLen; if (!m_FastMode) if (aNowPos64 - aLastPosSlotFillingPos >= (1 << 9)) { FillPosSlotPrices(); FillDistancesPrices(); aLastPosSlotFillingPos = aNowPos64; } if (m_AdditionalOffset == 0 && m_MatchFinder.GetNumAvailableBytes() == 0) return Flush(); } } HRESULT CEncoder::Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize) { try { return CodeReal(anInStream, anOutStream, anInSize); } catch (HRESULT& e) { return e; } catch (...) { return E_FAIL; } } void CEncoder::FillPosSlotPrices() { for (int aLenToPosState = 0; aLenToPosState < kNumLenToPosStates; aLenToPosState++) { INT aPosSlot; for (aPosSlot = 0; aPosSlot < kEndPosModelIndex && aPosSlot < m_DistTableSize; aPosSlot++) m_PosSlotPrices[aLenToPosState][aPosSlot] = m_PosSlotEncoder[aLenToPosState].GetPrice(aPosSlot); for (; aPosSlot < m_DistTableSize; aPosSlot++) m_PosSlotPrices[aLenToPosState][aPosSlot] = m_PosSlotEncoder[aLenToPosState].GetPrice(aPosSlot) + ((kDistDirectBits[aPosSlot] - kNumAlignBits) << kNumBitPriceShiftBits); } } void CEncoder::FillDistancesPrices() { for (int aLenToPosState = 0; aLenToPosState < kNumLenToPosStates; aLenToPosState++) { INT i; for (i = 0; i < kStartPosModelIndex; i++) m_DistancesPrices[aLenToPosState][i] = m_PosSlotPrices[aLenToPosState][i]; for (; i < kNumFullDistances; i++) { INT aPosSlot = GetPosSlot(i); m_DistancesPrices[aLenToPosState][i] = m_PosSlotPrices[aLenToPosState][aPosSlot] + m_PosEncoders[aPosSlot - kStartPosModelIndex].GetPrice(i - kDistStart[aPosSlot]); } } } void CEncoder::FillAlignPrices() { for (int i = 0; i < kAlignTableSize; i++) m_AlignPrices[i] = m_PosAlignEncoder.GetPrice(i); m_AlignPriceCount = kAlignTableSize; } }} advancecomp-1.23/7z/LZMAEncoder.h000066400000000000000000000131031301462770100164720ustar00rootroot00000000000000#ifndef __LZARITHMETIC_ENCODER_H #define __LZARITHMETIC_ENCODER_H #include "Portable.h" #include "AriPrice.h" #include "LZMA.h" #include "LenCoder.h" #include "LiteralCoder.h" #include "AriConst.h" // NOTE Here is choosen the MatchFinder #include "BinTree2.h" #define MATCH_FINDER NBT2::CMatchFinderBinTree namespace NCompress { namespace NLZMA { struct COptimal { CState State; bool Prev1IsChar; bool Prev2; INT PosPrev2; INT BackPrev2; INT Price; INT PosPrev; // posNext; INT BackPrev; INT Backs[kNumRepDistances]; void MakeAsChar() { BackPrev = INT(-1); Prev1IsChar = false; } void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; } bool IsShortRep() { return (BackPrev == 0); } }; extern BYTE g_FastPos[1024]; inline INT GetPosSlot(INT aPos) { if (aPos < (1 << 10)) return g_FastPos[aPos]; if (aPos < (1 << 19)) return g_FastPos[aPos >> 9] + 18; return g_FastPos[aPos >> 18] + 36; } inline INT GetPosSlot2(INT aPos) { if (aPos < (1 << 16)) return g_FastPos[aPos >> 6] + 12; if (aPos < (1 << 25)) return g_FastPos[aPos >> 15] + 30; return g_FastPos[aPos >> 24] + 48; } const int kIfinityPrice = 0xFFFFFFF; typedef CMyBitEncoder CMyBitEncoder2; const int kNumOpts = 1 << 12; class CEncoder : public CBaseCoder { COptimal m_Optimum[kNumOpts]; public: MATCH_FINDER m_MatchFinder; CMyRangeEncoder m_RangeEncoder; private: CMyBitEncoder2 m_MainChoiceEncoders[kNumStates][NLength::kNumPosStatesEncodingMax]; CMyBitEncoder2 m_MatchChoiceEncoders[kNumStates]; CMyBitEncoder2 m_MatchRepChoiceEncoders[kNumStates]; CMyBitEncoder2 m_MatchRep1ChoiceEncoders[kNumStates]; CMyBitEncoder2 m_MatchRep2ChoiceEncoders[kNumStates]; CMyBitEncoder2 m_MatchRepShortChoiceEncoders[kNumStates][NLength::kNumPosStatesEncodingMax]; CBitTreeEncoder m_PosSlotEncoder[kNumLenToPosStates]; CReverseBitTreeEncoder2 m_PosEncoders[kNumPosModels]; CReverseBitTreeEncoder2 m_PosAlignEncoder; NLength::CPriceTableEncoder m_LenEncoder; NLength::CPriceTableEncoder m_RepMatchLenEncoder; NLiteral::CEncoder m_LiteralEncoder; UINT32 m_MatchDistances[kMatchMaxLen + 1]; bool m_FastMode; bool m_MaxMode; INT m_NumFastBytes; INT m_LongestMatchLength; INT m_AdditionalOffset; INT m_OptimumEndIndex; INT m_OptimumCurrentIndex; bool m_LongestMatchWasFound; INT m_PosSlotPrices[kNumLenToPosStates][kDistTableSizeMax]; INT m_DistancesPrices[kNumLenToPosStates][kNumFullDistances]; INT m_AlignPrices[kAlignTableSize]; INT m_AlignPriceCount; INT m_DistTableSize; INT m_PosStateBits; INT m_PosStateMask; INT m_LiteralPosStateBits; INT m_LiteralContextBits; INT m_DictionarySize; INT m_DictionarySizePrev; INT m_NumFastBytesPrev; INT ReadMatchDistances() { INT aLen = m_MatchFinder.GetLongestMatch(m_MatchDistances); if (aLen == m_NumFastBytes) aLen += m_MatchFinder.GetMatchLen(aLen, m_MatchDistances[aLen], kMatchMaxLen - aLen); m_AdditionalOffset++; HRESULT aResult = m_MatchFinder.MovePos(); if (aResult != S_OK) throw aResult; return aLen; } void MovePos(INT aNum); INT GetRepLen1Price(CState aState, INT aPosState) const { return m_MatchRepChoiceEncoders[aState.m_Index].GetPrice(0) + m_MatchRepShortChoiceEncoders[aState.m_Index][aPosState].GetPrice(0); } INT GetRepPrice(INT aRepIndex, INT aLen, CState aState, INT aPosState) const { INT aPrice = m_RepMatchLenEncoder.GetPrice(aLen - kMatchMinLen, aPosState); if(aRepIndex == 0) { aPrice += m_MatchRepChoiceEncoders[aState.m_Index].GetPrice(0); aPrice += m_MatchRepShortChoiceEncoders[aState.m_Index][aPosState].GetPrice(1); } else { aPrice += m_MatchRepChoiceEncoders[aState.m_Index].GetPrice(1); if (aRepIndex == 1) aPrice += m_MatchRep1ChoiceEncoders[aState.m_Index].GetPrice(0); else { aPrice += m_MatchRep1ChoiceEncoders[aState.m_Index].GetPrice(1); aPrice += m_MatchRep2ChoiceEncoders[aState.m_Index].GetPrice(aRepIndex - 2); } } return aPrice; } INT GetPosLenPrice(INT aPos, INT aLen, INT aPosState) const { if (aLen == 2 && aPos >= 0x80) return kIfinityPrice; INT aPrice; INT aLenToPosState = GetLenToPosState(aLen); if (aPos < kNumFullDistances) aPrice = m_DistancesPrices[aLenToPosState][aPos]; else aPrice = m_PosSlotPrices[aLenToPosState][GetPosSlot2(aPos)] + m_AlignPrices[aPos & kAlignMask]; return aPrice + m_LenEncoder.GetPrice(aLen - kMatchMinLen, aPosState); } INT Backward(INT &aBackRes, INT aCur); INT GetOptimum(INT &aBackRes, INT aPosition); INT GetOptimumFast(INT &aBackRes, INT aPosition); void FillPosSlotPrices(); void FillDistancesPrices(); void FillAlignPrices(); HRESULT Flush(); HRESULT Create(); HRESULT CodeReal(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize); HRESULT Init(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream); public: CEncoder(); HRESULT SetEncoderAlgorithm(INT A); HRESULT SetEncoderNumFastBytes(INT A); HRESULT SetDictionarySize(INT aDictionarySize); HRESULT SetLiteralProperties(INT aLiteralPosStateBits, INT aLiteralContextBits); HRESULT SetPosBitsProperties(INT aNumPosStateBits); HRESULT Code(ISequentialInStream *anInStream, ISequentialOutStream *anOutStream, const UINT64 *anInSize); HRESULT WriteCoderProperties(ISequentialOutStream *anOutStream); }; }} #endif advancecomp-1.23/7z/LenCoder.cc000066400000000000000000000030161301462770100162620ustar00rootroot00000000000000#include "LenCoder.h" using namespace NCompression; using namespace NArithmetic; namespace NLength { void CEncoder::Init() { m_Choice.Init(); for (UINT32 aPosState = 0; aPosState < m_NumPosStates; aPosState++) { m_LowCoder[aPosState].Init(); m_MidCoder[aPosState].Init(); } m_Choice2.Init(); m_HighCoder.Init(); } void CEncoder::Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aSymbol, UINT32 aPosState) { if(aSymbol < kNumLowSymbols) { m_Choice.Encode(aRangeEncoder, 0); m_LowCoder[aPosState].Encode(aRangeEncoder, aSymbol); } else { aSymbol -= kNumLowSymbols; m_Choice.Encode(aRangeEncoder, 1); if(aSymbol < kNumMidSymbols) { m_Choice2.Encode(aRangeEncoder, 0); m_MidCoder[aPosState].Encode(aRangeEncoder, aSymbol); } else { aSymbol -= kNumMidSymbols; m_Choice2.Encode(aRangeEncoder, 1); m_HighCoder.Encode(aRangeEncoder, aSymbol); } } } UINT32 CEncoder::GetPrice(UINT32 aSymbol, UINT32 aPosState) const { UINT32 aPrice = 0; if(aSymbol < kNumLowSymbols) { aPrice += m_Choice.GetPrice(0); aPrice += m_LowCoder[aPosState].GetPrice(aSymbol); } else { aSymbol -= kNumLowSymbols; aPrice += m_Choice.GetPrice(1); if(aSymbol < kNumMidSymbols) { aPrice += m_Choice2.GetPrice(0); aPrice += m_MidCoder[aPosState].GetPrice(aSymbol); } else { aSymbol -= kNumMidSymbols; aPrice += m_Choice2.GetPrice(1); aPrice += m_HighCoder.GetPrice(aSymbol); } } return aPrice; } } advancecomp-1.23/7z/LenCoder.h000066400000000000000000000064301301462770100161270ustar00rootroot00000000000000#ifndef __LENCODER_H #define __LENCODER_H #include "BitTreeCoder.h" namespace NLength { const int kNumPosStatesBitsMax = 4; const int kNumPosStatesMax = (1 << kNumPosStatesBitsMax); const int kNumPosStatesBitsEncodingMax = 4; const int kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax); const int kNumMoveBits = 5; const int kNumLenBits = 3; const int kNumLowSymbols = 1 << kNumLenBits; const int kNumMidBits = 3; const int kNumMidSymbols = 1 << kNumMidBits; const int kNumHighBits = 8; const int kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits); class CEncoder { CMyBitEncoder m_Choice; CBitTreeEncoder m_LowCoder[kNumPosStatesEncodingMax]; CMyBitEncoder m_Choice2; CBitTreeEncoder m_MidCoder[kNumPosStatesEncodingMax]; CBitTreeEncoder m_HighCoder; protected: UINT32 m_NumPosStates; public: void Create(UINT32 aNumPosStates) { m_NumPosStates = aNumPosStates; } void Init(); void Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aSymbol, UINT32 aPosState); UINT32 GetPrice(UINT32 aSymbol, UINT32 aPosState) const; }; const int kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols; class CPriceTableEncoder: public CEncoder { UINT32 m_Prices[kNumSymbolsTotal][kNumPosStatesEncodingMax]; UINT32 m_TableSize; UINT32 m_Counters[kNumPosStatesEncodingMax]; public: void SetTableSize(UINT32 aTableSize) { m_TableSize = aTableSize; } UINT32 GetPrice(UINT32 aSymbol, UINT32 aPosState) const { return m_Prices[aSymbol][aPosState]; } void UpdateTable(UINT32 aPosState) { for (UINT32 aLen = 0; aLen < m_TableSize; aLen++) m_Prices[aLen][aPosState] = CEncoder::GetPrice(aLen , aPosState); m_Counters[aPosState] = m_TableSize; } void UpdateTables() { for (UINT32 aPosState = 0; aPosState < m_NumPosStates; aPosState++) UpdateTable(aPosState); } void Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aSymbol, UINT32 aPosState) { CEncoder::Encode(aRangeEncoder, aSymbol, aPosState); if (--m_Counters[aPosState] == 0) UpdateTable(aPosState); } }; class CDecoder { CMyBitDecoder m_Choice; CBitTreeDecoder m_LowCoder[kNumPosStatesMax]; CMyBitDecoder m_Choice2; CBitTreeDecoder m_MidCoder[kNumPosStatesMax]; CBitTreeDecoder m_HighCoder; UINT32 m_NumPosStates; public: void Create(UINT32 aNumPosStates) { m_NumPosStates = aNumPosStates; } void Init() { m_Choice.Init(); for (UINT32 aPosState = 0; aPosState < m_NumPosStates; aPosState++) { m_LowCoder[aPosState].Init(); m_MidCoder[aPosState].Init(); } m_Choice2.Init(); m_HighCoder.Init(); } UINT32 Decode(CMyRangeDecoder *aRangeDecoder, UINT32 aPosState) { if(m_Choice.Decode(aRangeDecoder) == 0) return m_LowCoder[aPosState].Decode(aRangeDecoder); else { UINT32 aSymbol = kNumLowSymbols; if(m_Choice2.Decode(aRangeDecoder) == 0) aSymbol += m_MidCoder[aPosState].Decode(aRangeDecoder); else { aSymbol += kNumMidSymbols; aSymbol += m_HighCoder.Decode(aRangeDecoder); } return aSymbol; } } }; } #endif advancecomp-1.23/7z/LiteralCoder.cc000066400000000000000000000026261301462770100171460ustar00rootroot00000000000000#include "LiteralCoder.h" using namespace NCompression; using namespace NArithmetic; namespace NLiteral { void CEncoder2::Init() { for (int i = 0; i < 3; i++) for (int j = 1; j < (1 << 8); j++) m_Encoders[i][j].Init(); } void CEncoder2::Encode(CMyRangeEncoder *aRangeEncoder, bool aMatchMode, BYTE aMatchByte, BYTE aSymbol) { UINT32 aContext = 1; bool aSame = true; for (int i = 7; i >= 0; i--) { UINT32 aBit = (aSymbol >> i) & 1; unsigned aState; if (aMatchMode && aSame) { UINT32 aMatchBit = (aMatchByte >> i) & 1; aState = 1 + aMatchBit; aSame = (aMatchBit == aBit); } else aState = 0; m_Encoders[aState][aContext].Encode(aRangeEncoder, aBit); aContext = (aContext << 1) | aBit; } } UINT32 CEncoder2::GetPrice(bool aMatchMode, BYTE aMatchByte, BYTE aSymbol) const { UINT32 aPrice = 0; UINT32 aContext = 1; int i = 7; if (aMatchMode) { for (; i >= 0; i--) { UINT32 aMatchBit = (aMatchByte >> i) & 1; UINT32 aBit = (aSymbol >> i) & 1; aPrice += m_Encoders[1 + aMatchBit][aContext].GetPrice(aBit); aContext = (aContext << 1) | aBit; if (aMatchBit != aBit) { i--; break; } } } for (; i >= 0; i--) { UINT32 aBit = (aSymbol >> i) & 1; aPrice += m_Encoders[0][aContext].GetPrice(aBit); aContext = (aContext << 1) | aBit; } return aPrice; }; } advancecomp-1.23/7z/LiteralCoder.h000066400000000000000000000075621301462770100170140ustar00rootroot00000000000000#ifndef __LITERALCODER_H #define __LITERALCODER_H #include "AriBitCoder.h" #include "RCDefs.h" namespace NLiteral { const int kNumMoveBits = 5; class CEncoder2 { CMyBitEncoder m_Encoders[3][1 << 8]; public: void Init(); void Encode(CMyRangeEncoder *aRangeEncoder, bool aMatchMode, BYTE aMatchByte, BYTE aSymbol); UINT32 GetPrice(bool aMatchMode, BYTE aMatchByte, BYTE aSymbol) const; }; class CDecoder2 { CMyBitDecoder m_Decoders[3][1 << 8]; public: void Init() { for (int i = 0; i < 3; i++) for (int j = 1; j < (1 << 8); j++) m_Decoders[i][j].Init(); } BYTE DecodeNormal(CMyRangeDecoder *aRangeDecoder) { UINT32 aSymbol = 1; RC_INIT_VAR do { RC_GETBIT(kNumMoveBits, m_Decoders[0][aSymbol].m_Probability, aSymbol) } while (aSymbol < 0x100); RC_FLUSH_VAR return aSymbol; } BYTE DecodeWithMatchByte(CMyRangeDecoder *aRangeDecoder, BYTE aMatchByte) { UINT32 aSymbol = 1; RC_INIT_VAR do { UINT32 aMatchBit = (aMatchByte >> 7) & 1; aMatchByte <<= 1; UINT32 aBit; RC_GETBIT2(kNumMoveBits, m_Decoders[1 + aMatchBit][aSymbol].m_Probability, aSymbol, aBit = 0, aBit = 1) if (aMatchBit != aBit) { while (aSymbol < 0x100) { RC_GETBIT(kNumMoveBits, m_Decoders[0][aSymbol].m_Probability, aSymbol) } break; } } while (aSymbol < 0x100); RC_FLUSH_VAR return aSymbol; } }; class CEncoder { CEncoder2 *m_Coders; UINT32 m_NumPrevBits; UINT32 m_NumPosBits; UINT32 m_PosMask; public: CEncoder(): m_Coders(0) {} ~CEncoder() { Free(); } void Free() { delete []m_Coders; m_Coders = 0; } void Create(UINT32 aNumPosBits, UINT32 aNumPrevBits) { Free(); m_NumPosBits = aNumPosBits; m_PosMask = (1 << aNumPosBits) - 1; m_NumPrevBits = aNumPrevBits; UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits); m_Coders = new CEncoder2[aNumStates]; } void Init() { UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits); for (UINT32 i = 0; i < aNumStates; i++) m_Coders[i].Init(); } UINT32 GetState(UINT32 aPos, BYTE aPrevByte) const { return ((aPos & m_PosMask) << m_NumPrevBits) + (aPrevByte >> (8 - m_NumPrevBits)); } void Encode(CMyRangeEncoder *aRangeEncoder, UINT32 aPos, BYTE aPrevByte, bool aMatchMode, BYTE aMatchByte, BYTE aSymbol) { m_Coders[GetState(aPos, aPrevByte)].Encode(aRangeEncoder, aMatchMode, aMatchByte, aSymbol); } UINT32 GetPrice(UINT32 aPos, BYTE aPrevByte, bool aMatchMode, BYTE aMatchByte, BYTE aSymbol) const { return m_Coders[GetState(aPos, aPrevByte)].GetPrice(aMatchMode, aMatchByte, aSymbol); } }; class CDecoder { CDecoder2 *m_Coders; UINT32 m_NumPrevBits; UINT32 m_NumPosBits; UINT32 m_PosMask; public: CDecoder(): m_Coders(0) {} ~CDecoder() { Free(); } void Free() { delete []m_Coders; m_Coders = 0; } void Create(UINT32 aNumPosBits, UINT32 aNumPrevBits) { Free(); m_NumPosBits = aNumPosBits; m_PosMask = (1 << aNumPosBits) - 1; m_NumPrevBits = aNumPrevBits; UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits); m_Coders = new CDecoder2[aNumStates]; } void Init() { UINT32 aNumStates = 1 << (m_NumPrevBits + m_NumPosBits); for (UINT32 i = 0; i < aNumStates; i++) m_Coders[i].Init(); } UINT32 GetState(UINT32 aPos, BYTE aPrevByte) const { return ((aPos & m_PosMask) << m_NumPrevBits) + (aPrevByte >> (8 - m_NumPrevBits)); } BYTE DecodeNormal(CMyRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte) { return m_Coders[GetState(aPos, aPrevByte)].DecodeNormal(aRangeDecoder); } BYTE DecodeWithMatchByte(CMyRangeDecoder *aRangeDecoder, UINT32 aPos, BYTE aPrevByte, BYTE aMatchByte) { return m_Coders[GetState(aPos, aPrevByte)].DecodeWithMatchByte(aRangeDecoder, aMatchByte); } }; } #endif advancecomp-1.23/7z/OutByte.cc000066400000000000000000000013371301462770100161660ustar00rootroot00000000000000#include "OutByte.h" namespace NStream { COutByte::COutByte(INT aBufferSize): m_BufferSize(aBufferSize) { m_Buffer = new BYTE[m_BufferSize]; } COutByte::~COutByte() { delete []m_Buffer; } void COutByte::Init(ISequentialOutStream *aStream) { m_Stream = aStream; m_ProcessedSize = 0; m_Pos = 0; } HRESULT COutByte::Flush() { if (m_Pos == 0) return S_OK; INT aProcessedSize; HRESULT aResult = m_Stream->Write(m_Buffer, m_Pos, &aProcessedSize); if (aResult != S_OK) return aResult; if (m_Pos != aProcessedSize) return E_FAIL; m_ProcessedSize += aProcessedSize; m_Pos = 0; return S_OK; } void COutByte::WriteBlock() { HRESULT aResult = Flush(); if (aResult != S_OK) throw aResult; } } advancecomp-1.23/7z/OutByte.h000066400000000000000000000013511301462770100160240ustar00rootroot00000000000000#ifndef __STREAM_OUTBYTE_H #define __STREAM_OUTBYTE_H #include "Portable.h" #include "IInOutStreams.h" namespace NStream { class COutByte { BYTE *m_Buffer; INT m_Pos; INT m_BufferSize; ISequentialOutStream* m_Stream; UINT64 m_ProcessedSize; void WriteBlock(); public: COutByte(INT aBufferSize = (1 << 20)); ~COutByte(); void Init(ISequentialOutStream *aStream); HRESULT Flush(); void WriteByte(BYTE aByte) { m_Buffer[m_Pos++] = aByte; if(m_Pos >= m_BufferSize) WriteBlock(); } void WriteBytes(const void *aBytes, INT aSize) { for (INT i = 0; i < aSize; i++) WriteByte(((const BYTE *)aBytes)[i]); } UINT64 GetProcessedSize() const { return m_ProcessedSize + m_Pos; } }; } #endif advancecomp-1.23/7z/Portable.h000066400000000000000000000015311301462770100162010ustar00rootroot00000000000000#ifndef __PORTABLE_H #define __PORTABLE_H #include #include typedef signed char INT8; typedef unsigned char UINT8; typedef int16_t INT16; typedef uint16_t UINT16; typedef int32_t INT32; typedef uint32_t UINT32; typedef int64_t INT64; typedef uint64_t UINT64; typedef uintptr_t UINT_PTR; typedef int32_t INT; typedef UINT8 BYTE; typedef UINT16 WORD; typedef UINT32 DWORD; typedef int BOOL; #define FALSE 0 #define TRUE 1 #define HRESULT int #define S_OK 0 #define E_INVALIDARG -1 #define E_OUTOFMEMORY -2 #define E_FAIL -3 #define E_INTERNAL_ERROR -4 #define E_INVALIDDATA -5 template inline T MyMin(T a, T b) { return a < b ? a : b; } template inline T MyMax(T a, T b) { return a > b ? a : b; } #define RETURN_IF_NOT_S_OK(x) { HRESULT __aResult_ = (x); if(__aResult_ != S_OK) return __aResult_; } #endif advancecomp-1.23/7z/RCDefs.h000066400000000000000000000037571301462770100155530ustar00rootroot00000000000000#ifndef __RCDEFS_H #define __RCDEFS_H #include "AriBitCoder.h" #include "AriConst.h" #define RC_INIT_VAR \ UINT32 aRange = aRangeDecoder->m_Range; \ UINT32 aCode = aRangeDecoder->m_Code; #define RC_FLUSH_VAR \ aRangeDecoder->m_Range = aRange; \ aRangeDecoder->m_Code = aCode; #define RC_NORMALIZE \ if (aRange < NCompression::NArithmetic::kTopValue) \ { \ aCode = (aCode << 8) | aRangeDecoder->m_Stream.ReadByte(); \ aRange <<= 8; } #define RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, Action0, Action1) \ {UINT32 aNewBound = (aRange >> NCompression::NArithmetic::kNumBitModelTotalBits) * aProb; \ if (aCode < aNewBound) \ { \ Action0; \ aRange = aNewBound; \ aProb += (NCompression::NArithmetic::kBitModelTotal - aProb) >> aNumMoveBits; \ aModelIndex <<= 1; \ } \ else \ { \ Action1; \ aRange -= aNewBound; \ aCode -= aNewBound; \ aProb -= (aProb) >> aNumMoveBits; \ aModelIndex = (aModelIndex << 1) + 1; \ }} \ RC_NORMALIZE #define RC_GETBIT(aNumMoveBits, aProb, aModelIndex) RC_GETBIT2(aNumMoveBits, aProb, aModelIndex, ; , ;) #endif advancecomp-1.23/7z/README000066400000000000000000000004651301462770100151450ustar00rootroot00000000000000This directory contains some source files from the 7z archive utility. (www.7-zip.org) All the files in this directory was originally released with the LGPL license. All the modifications made on the original files must be considered Copyright (C) 2002 Andrea Mazzoleni and released under the LGPL license. advancecomp-1.23/7z/RangeCoder.h000066400000000000000000000075201301462770100164460ustar00rootroot00000000000000#ifndef __COMPRESSION_RANGECODER_H #define __COMPRESSION_RANGECODER_H #include "InByte.h" #include "OutByte.h" namespace NCompression { namespace NArithmetic { const UINT32 kNumTopBits = 24; const UINT32 kTopValue = (1 << kNumTopBits); class CRangeEncoder { NStream::COutByte m_Stream; UINT64 m_Low; UINT32 m_Range; UINT32 m_FFNum; BYTE m_Cache; public: void Init(ISequentialOutStream *aStream) { m_Stream.Init(aStream); m_Low = 0; m_Range = UINT32(-1); m_FFNum = 0; m_Cache = 0; } void FlushData() { // m_Low += 1; for(int i = 0; i < 5; i++) ShiftLow(); } HRESULT FlushStream() { return m_Stream.Flush(); } void Encode(UINT32 aStart, UINT32 aSize, UINT32 aTotal) { m_Low += aStart * (m_Range /= aTotal); m_Range *= aSize; while (m_Range < kTopValue) { m_Range <<= 8; ShiftLow(); } } void ShiftLow() { if (m_Low < (UINT32)0xFF000000 || UINT32(m_Low >> 32) == 1) { m_Stream.WriteByte(m_Cache + BYTE(m_Low >> 32)); for (;m_FFNum != 0; m_FFNum--) m_Stream.WriteByte(0xFF + BYTE(m_Low >> 32)); m_Cache = BYTE(UINT32(m_Low) >> 24); } else m_FFNum++; m_Low = UINT32(m_Low) << 8; } void EncodeDirectBits(UINT32 aValue, UINT32 aNumTotalBits) { for (int i = aNumTotalBits - 1; i >= 0; i--) { m_Range >>= 1; if (((aValue >> i) & 1) == 1) m_Low += m_Range; if (m_Range < kTopValue) { m_Range <<= 8; ShiftLow(); } } } void EncodeBit(UINT32 aSize0, UINT32 aNumTotalBits, UINT32 aSymbol) { UINT32 aNewBound = (m_Range >> aNumTotalBits) * aSize0; if (aSymbol == 0) m_Range = aNewBound; else { m_Low += aNewBound; m_Range -= aNewBound; } while (m_Range < kTopValue) { m_Range <<= 8; ShiftLow(); } } UINT64 GetProcessedSize() { return m_Stream.GetProcessedSize() + m_FFNum; } }; class CRangeDecoder { public: NStream::CInByte m_Stream; UINT32 m_Range; UINT32 m_Code; UINT32 m_Word; void Normalize() { while (m_Range < kTopValue) { m_Code = (m_Code << 8) | m_Stream.ReadByte(); m_Range <<= 8; } } void Init(ISequentialInStream *aStream) { m_Stream.Init(aStream); m_Code = 0; m_Range = UINT32(-1); for(int i = 0; i < 5; i++) m_Code = (m_Code << 8) | m_Stream.ReadByte(); } UINT32 GetThreshold(UINT32 aTotal) { return (m_Code) / ( m_Range /= aTotal); } void Decode(UINT32 aStart, UINT32 aSize, UINT32 aTotal) { m_Code -= aStart * m_Range; m_Range *= aSize; Normalize(); } UINT32 DecodeDirectBits(UINT32 aNumTotalBits) { UINT32 aRange = m_Range; UINT32 aCode = m_Code; UINT32 aResult = 0; for (UINT32 i = aNumTotalBits; i > 0; i--) { aRange >>= 1; /* aResult <<= 1; if (aCode >= aRange) { aCode -= aRange; aResult |= 1; } */ UINT32 t = (aCode - aRange) >> 31; aCode -= aRange & (t - 1); // aRange = aRangeTmp + ((aRange & 1) & (1 - t)); aResult = (aResult << 1) | (1 - t); if (aRange < kTopValue) { aCode = (aCode << 8) | m_Stream.ReadByte(); aRange <<= 8; } } m_Range = aRange; m_Code = aCode; return aResult; } UINT32 DecodeBit(UINT32 aSize0, UINT32 aNumTotalBits) { UINT32 aNewBound = (m_Range >> aNumTotalBits) * aSize0; UINT32 aSymbol; if (m_Code < aNewBound) { aSymbol = 0; m_Range = aNewBound; } else { aSymbol = 1; m_Code -= aNewBound; m_Range -= aNewBound; } Normalize(); return aSymbol; } UINT64 GetProcessedSize() {return m_Stream.GetProcessedSize(); } }; }} #endif advancecomp-1.23/7z/WindowIn.cc000066400000000000000000000036721301462770100163350ustar00rootroot00000000000000#include "Portable.h" #include "WindowIn.h" namespace NStream { namespace NWindow { CIn::CIn(): m_BufferBase(0), m_Buffer(0) {} void CIn::Free() { delete []m_BufferBase; m_BufferBase = 0; m_Buffer = 0; } void CIn::Create(INT aKeepSizeBefore, INT aKeepSizeAfter, INT aKeepSizeReserv) { m_KeepSizeBefore = aKeepSizeBefore; m_KeepSizeAfter = aKeepSizeAfter; m_KeepSizeReserv = aKeepSizeReserv; m_BlockSize = aKeepSizeBefore + aKeepSizeAfter + aKeepSizeReserv; Free(); m_BufferBase = new BYTE[m_BlockSize]; m_PointerToLastSafePosition = m_BufferBase + m_BlockSize - aKeepSizeAfter; } CIn::~CIn() { Free(); } HRESULT CIn::Init(ISequentialInStream *aStream) { m_Stream = aStream; m_Buffer = m_BufferBase; m_Pos = 0; m_StreamPos = 0; m_StreamEndWasReached = false; return ReadBlock(); } /////////////////////////////////////////// // ReadBlock HRESULT CIn::ReadBlock() { if(m_StreamEndWasReached) return S_OK; while(true) { INT aSize = (m_BufferBase + m_BlockSize) - (m_Buffer + m_StreamPos); if(aSize == 0) return S_OK; INT aNumReadBytes; RETURN_IF_NOT_S_OK(m_Stream->Read(m_Buffer + m_StreamPos, aSize, &aNumReadBytes)); if(aNumReadBytes == 0) { m_PosLimit = m_StreamPos; const BYTE *aPointerToPostion = m_Buffer + m_PosLimit; if(aPointerToPostion > m_PointerToLastSafePosition) m_PosLimit = m_PointerToLastSafePosition - m_Buffer; m_StreamEndWasReached = true; return S_OK; } m_StreamPos += aNumReadBytes; if(m_StreamPos >= m_Pos + m_KeepSizeAfter) { m_PosLimit = m_StreamPos - m_KeepSizeAfter; return S_OK; } } } void CIn::MoveBlock() { BeforeMoveBlock(); INT anOffset = (m_Buffer + m_Pos - m_KeepSizeBefore) - m_BufferBase; INT aNumBytes = (m_Buffer + m_StreamPos) - (m_BufferBase + anOffset); memmove(m_BufferBase, m_BufferBase + anOffset, aNumBytes); m_Buffer -= anOffset; AfterMoveBlock(); } }} advancecomp-1.23/7z/WindowIn.h000066400000000000000000000047401301462770100161740ustar00rootroot00000000000000#ifndef __STREAM_WINDOWIN_H #define __STREAM_WINDOWIN_H #include "IInOutStreams.h" #include namespace NStream { namespace NWindow { class CIn { BYTE *m_BufferBase; // pointer to buffer with data ISequentialInStream* m_Stream; INT m_PosLimit; // offset (from m_Buffer) of first byte when new block reading must be done bool m_StreamEndWasReached; // if (true) then m_StreamPos shows real end of stream const BYTE *m_PointerToLastSafePosition; protected: BYTE *m_Buffer; // Pointer to virtual Buffer begin INT m_BlockSize; // Size of Allocated memory block INT m_Pos; // offset (from m_Buffer) of curent byte INT m_KeepSizeBefore; // how many BYTEs must be kept in buffer before m_Pos INT m_KeepSizeAfter; // how many BYTEs must be kept buffer after m_Pos INT m_KeepSizeReserv; // how many BYTEs must be kept as reserv INT m_StreamPos; // offset (from m_Buffer) of first not read byte from Stream virtual void BeforeMoveBlock() {}; virtual void AfterMoveBlock() {}; void MoveBlock(); virtual HRESULT ReadBlock(); void Free(); public: CIn(); void Create(INT aKeepSizeBefore, INT aKeepSizeAfter, INT aKeepSizeReserv = (1<<17)); virtual ~CIn(); HRESULT Init(ISequentialInStream *aStream); BYTE *GetBuffer() const { return m_Buffer; } const BYTE *GetPointerToCurrentPos() const { return m_Buffer + m_Pos; } HRESULT MovePos() { m_Pos++; if (m_Pos > m_PosLimit) { const BYTE *aPointerToPostion = m_Buffer + m_Pos; if(aPointerToPostion > m_PointerToLastSafePosition) MoveBlock(); return ReadBlock(); } else return S_OK; } // BYTE GetCurrentByte()const; BYTE GetIndexByte(INT anIndex)const { return m_Buffer[m_Pos + anIndex]; } // INT GetCurPos()const { return m_Pos;}; // BYTE *GetBufferBeg()const { return m_Buffer;}; // aIndex + aLimit have not to exceed m_KeepSizeAfter; INT GetMatchLen(INT aIndex, INT aBack, INT aLimit) const { if(m_StreamEndWasReached) if ((m_Pos + aIndex) + aLimit > m_StreamPos) aLimit = m_StreamPos - (m_Pos + aIndex); aBack++; BYTE *pby = m_Buffer + m_Pos + aIndex; INT i; for(i = 0; i < aLimit && pby[i] == pby[i - aBack]; i++); return i; } INT GetNumAvailableBytes() const { return m_StreamPos - m_Pos; } void ReduceOffsets(INT aSubValue) { m_Buffer += aSubValue; m_PosLimit -= aSubValue; m_Pos -= aSubValue; m_StreamPos -= aSubValue; } }; }} #endif advancecomp-1.23/7z/WindowOut.cc000066400000000000000000000027671301462770100165420ustar00rootroot00000000000000#include "WindowOut.h" namespace NStream { namespace NWindow { void COut::Create(INT aKeepSizeBefore, INT aKeepSizeAfter, INT aKeepSizeReserv) { m_Pos = 0; m_PosLimit = aKeepSizeReserv + aKeepSizeBefore; m_KeepSizeBefore = aKeepSizeBefore; m_KeepSizeAfter = aKeepSizeAfter; m_KeepSizeReserv = aKeepSizeReserv; m_StreamPos = 0; m_MoveFrom = m_KeepSizeReserv; m_WindowSize = aKeepSizeBefore; INT aBlockSize = m_KeepSizeBefore + m_KeepSizeAfter + m_KeepSizeReserv; delete []m_Buffer; m_Buffer = new BYTE[aBlockSize]; } COut::~COut() { delete []m_Buffer; } void COut::SetWindowSize(INT aWindowSize) { m_WindowSize = aWindowSize; m_MoveFrom = m_KeepSizeReserv + m_KeepSizeBefore - aWindowSize; } void COut::Init(ISequentialOutStream *aStream, bool aSolid) { m_Stream = aStream; if(aSolid) m_StreamPos = m_Pos; else { m_Pos = 0; m_PosLimit = m_KeepSizeReserv + m_KeepSizeBefore; m_StreamPos = 0; } } HRESULT COut::Flush() { INT aSize = m_Pos - m_StreamPos; if(aSize == 0) return S_OK; INT aProcessedSize; HRESULT aResult = m_Stream->Write(m_Buffer + m_StreamPos, aSize, &aProcessedSize); if (aResult != S_OK) return aResult; if (aSize != aProcessedSize) return E_FAIL; m_StreamPos = m_Pos; return S_OK; } void COut::MoveBlockBackward() { HRESULT aResult = Flush(); if (aResult != S_OK) throw aResult; memmove(m_Buffer, m_Buffer + m_MoveFrom, m_WindowSize + m_KeepSizeAfter); m_Pos -= m_MoveFrom; m_StreamPos -= m_MoveFrom; } }} advancecomp-1.23/7z/WindowOut.h000066400000000000000000000030571301462770100163750ustar00rootroot00000000000000#ifndef __STREAM_WINDOWOUT_H #define __STREAM_WINDOWOUT_H #include "IInOutStreams.h" namespace NStream { namespace NWindow { // m_KeepSizeBefore: how mach BYTEs must be in buffer before m_Pos; // m_KeepSizeAfter: how mach BYTEs must be in buffer after m_Pos; // m_KeepSizeReserv: how mach BYTEs must be in buffer for Moving Reserv; // must be >= aKeepSizeAfter; // test it class COut { BYTE *m_Buffer; INT m_Pos; INT m_PosLimit; INT m_KeepSizeBefore; INT m_KeepSizeAfter; INT m_KeepSizeReserv; INT m_StreamPos; INT m_WindowSize; INT m_MoveFrom; ISequentialOutStream *m_Stream; virtual void MoveBlockBackward(); public: COut(): m_Buffer(0), m_Stream(0) {} virtual ~COut(); void Create(INT aKeepSizeBefore, INT aKeepSizeAfter, INT aKeepSizeReserv = (1<<17)); void SetWindowSize(INT aWindowSize); void Init(ISequentialOutStream *aStream, bool aSolid = false); HRESULT Flush(); INT GetCurPos() const { return m_Pos; } const BYTE *GetPointerToCurrentPos() const { return m_Buffer + m_Pos;}; void CopyBackBlock(INT aDistance, INT aLen) { if (m_Pos >= m_PosLimit) MoveBlockBackward(); BYTE *p = m_Buffer + m_Pos; aDistance++; for(INT i = 0; i < aLen; i++) p[i] = p[i - aDistance]; m_Pos += aLen; } void PutOneByte(BYTE aByte) { if (m_Pos >= m_PosLimit) MoveBlockBackward(); m_Buffer[m_Pos++] = aByte; } BYTE GetOneByte(INT anIndex) const { return m_Buffer[m_Pos + anIndex]; } BYTE *GetBuffer() const { return m_Buffer; } }; }} #endif advancecomp-1.23/AUTHORS000066400000000000000000000007161301462770100147740ustar00rootroot00000000000000 =================== AdvanceCOMP Authors =================== AUTHORS ======= The author of AdvanceCOMP and releated utilities is Andrea Mazzoleni. You can contact me sending an email at: amadvance@gmail.com ACKNOWLEDGMENTS =============== A lot of other people helped submitting patches, bug reports and generic comments. A special mention to: * Filipe Estima advancecomp-1.23/COPYING000066400000000000000000001045131301462770100147570ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . advancecomp-1.23/HISTORY000066400000000000000000000145561301462770100150170ustar00rootroot00000000000000 ======================= History For AdvanceCOMP ======================= ADVANCECOMP VERSION 1.23 2016/11 ================================ * Fixed build issue from source code due missing libdeflate header. ADVANCECOMP VERSION 1.22 2016/11 ================================ * Enabled again the command line wildcard expansion in the Windows builds. The new MingW compiler was disabling it by default. ADVANCECOMP VERSION 1.21 2016/11 ================================ * Added libdeflate support. It's the new default because it provides better performance and compression than 7z. From https://github.com/ebiggers/libdeflate at commit 28cc14994b8b57f590d31a7340c8fffc5cc37d88 * Update to te latest zopfli library. From https://github.com/google/zopfli at commit 6818a0859063b946094fb6f94732836404a0d89a. * Windows binaries built with MingW 4.9.3 using the MXE cross compiler at commit 62bcdbee56e87c81f1faa105b8777a5879d4e2e with targets i686-w64-mingw32 and x86_64-w64-mingw32. * DOS binaries built with DJGPP 4.8.5 from https://github.com/andrewwutw/build-djgpp ADVANCECOMP VERSION 1.20 2015/08 ================================ * Fixed .gz recompression of data bigger than 400 MB. * Fixed .gz recompression with -0 and -1 options. * Updated to the latest zopfli [Aaron Kaluszka]. * Preserve the EFS flag in .zip files [Jason Penney]. ADVANCECOMP VERSION 1.19 2014/03 ================================ * Limited the iterations number to 255 with the -3 option. * Added a new -k, --keep-file-time option to advzip [Marco Banfi]. * Made the Windows binary again compatible with old 686 processors. ADVANCECOMP VERSION 1.18 2013/11 ================================ * Added build support for new powerpc architectures. * Fixed build with BZIP. ADVANCECOMP VERSION 1.17 2013/03 ================================ * Changed to GPL3. * Added zopfli support. It's enabled using -4, --shrink-insane. You can control the number of iterations with the new -i, --iter option. Thanks to Darik Horn for the patches. ADVANCECOMP VERSION 1.16 2013/03 ================================ * Allowed recompression with files with zero length. * Some other minor bugfixes. * Now in git repository. ADVANCECOMP VERSION 1.15 2005/10 ================================ * Fixed the date displayed with the -l advzip command. * The advdef utility now detects the file type from the file header instead of using the extension. * Fixed a lot of bugs in the 64 bits platforms. ADVANCECOMP VERSION 1.14 2005/02 ================================ * Relaxed a consistency check for the local header in zip files. The crc and size entries are allowed to contain the real value also if a data descriptor is present. * Fixed the conversion of RGB images with less than 256 color with transparency data. * Minor fixes at the documentation. ADVANCECOMP VERSION 1.13 2004/11 ================================ * Added support for .svgz files at advdef [rener]. * Fixed the 8 bit color reduction of 32 bit png files. ADVANCECOMP VERSION 1.12 2004/09 ================================ * Fixed a compilation problem with gcc 3.4. ADVANCECOMP VERSION 1.11 2004/07 ================================ * Fixed a FreeBSD libc compatibility issue recompressing .gz files [Radim Kolar]. * Fixed a segmentation fault when some invalid compressed .zip files are tested. ADVANCECOMP VERSION 1.10 2004/04 ================================ * Added support for alpha channel and the new -n option at advmng. * Fixed the uncompressing error "Invalid compressed data in ..." with some GZIP files [Christian Lestrade]. ADVANCECOMP VERSION 1.9 2003/11 =============================== * Added support for .tgz files at advdef. * Added the -a option at advmng to create .mng files from a sequence of .png files. ADVANCECOMP VERSION 1.8 2003/10 =============================== * Added support for .gz files at advdef. * Fixed support for .png files with splitted IDATs. ADVANCECOMP VERSION 1.7 2003/08 =============================== * Fixed a Segmentation Fault bug on the advmng -r option on the latest gcc. * Better and faster (MMX) move recognition in the advmng scroll compression. * The frame reduction of the advmng utility is now done only if possible. The compression process never fails. * Added a new -S (--scroll-square) option at advmng. * Added a new -v (--verbose) option at advmng to show the compression status. * Changed the internal ID for the bzip2 and LZMA compression. The bzip2 ID is now compatible with the PKWARE specification. * Added support for RGB images with alpha channel at the advpng utility. * Updated with automake 1.7.6. ADVANCECOMP VERSION 1.6 2003/05 =============================== * Added the `-x' option at the advmng utility to export .png files from a .mng clip. Useful to compress it in an MPEG file. * Fixed the support for zips with additional data descriptors. * Updated with autoconf 2.57 and automake 1.7.4. * Some fixes for the gcc 3.3 compiler. ADVANCECOMP VERSION 1.5 2003/01 =============================== * Splitted from AdvanceSCAN * Added the `advdef' compression utility. ADVANCESCAN VERSION 1.4 2002/12 =============================== * Fixed a bug in the advmng utility when it was called with more than one file in the command line. The program was incorrectly adding a PLTE chunk at rgb images. ADVANCESCAN VERSION 1.3 2002/11 =============================== * Added the support for the transparency tRNS chunk at the advpng utility. * Upgraded at the latest Advance Library. * Fixes at the docs. [Filipe Estima] * Minor changes at the autoconf/automake scripts. ADVANCESCAN VERSION 1.2 2002/08 =============================== * Added the advpng utility to compress the PNG files. * Added the advmng utility to compress the MNG files. * Added a Windows version. * Other minor fixes. ADVANCESCAN VERSION 1.1 2002/06 =============================== * Fixed an infinite loop bug testing some small damaged zips. * Removed some warning compiling with gcc 3.1. ADVANCESCAN VERSION 1.0 2002/05 =============================== * First public release. * Fixed the compression percentage computation on big files. * Added the --pedantic option at the advzip utility. These tests are only done if requested. ADVANCESCAN VERSION 0.6-BETA 2002/05 ==================================== * Added the AdvanceZIP utility. advancecomp-1.23/INSTALL000066400000000000000000000007011301462770100147470ustar00rootroot00000000000000 ======================== AdvanceCOMP Installation ======================== As root or user type: ./configure make To check the generated executable type: make check and as root to install the programs and the documentation type: make install The documentation is in the man pages: man advdef man advzip man advpng man advmng advancecomp-1.23/Makefile.am000066400000000000000000000213141301462770100157550ustar00rootroot00000000000000bin_PROGRAMS = advzip advpng advmng advdef 7z_SOURCES = \ 7z/7zdeflate.cc \ 7z/7zlzma.cc \ 7z/AriBitCoder.cc \ 7z/CRC.cc \ 7z/DeflateDecoder.cc \ 7z/DeflateEncoder.cc \ 7z/HuffmanEncoder.cc \ 7z/IInOutStreams.cc \ 7z/InByte.cc \ 7z/LSBFDecoder.cc \ 7z/LSBFEncoder.cc \ 7z/LZMA.cc \ 7z/LZMADecoder.cc \ 7z/LZMAEncoder.cc \ 7z/LenCoder.cc \ 7z/LiteralCoder.cc \ 7z/OutByte.cc \ 7z/WindowIn.cc \ 7z/WindowOut.cc libdeflate_SOURCES = \ libdeflate/adler32.c \ libdeflate/aligned_malloc.c \ libdeflate/crc32.c \ libdeflate/deflate_compress.c \ libdeflate/deflate_decompress.c \ libdeflate/gzip_compress.c \ libdeflate/gzip_decompress.c \ libdeflate/x86_cpu_features.c \ libdeflate/zlib_compress.c \ libdeflate/zlib_decompress.c zopfli_SOURCES = \ zopfli/blocksplitter.c \ zopfli/cache.c \ zopfli/deflate.c \ zopfli/gzip_container.c \ zopfli/hash.c \ zopfli/katajainen.c \ zopfli/lz77.c \ zopfli/squeeze.c \ zopfli/tree.c \ zopfli/util.c \ zopfli/zlib_container.c \ zopfli/zopfli.h \ zopfli/zopfli_lib.c advzip_SOURCES = \ rezip.cc \ zip.cc \ file.cc \ data.cc \ siglock.cc \ compress.cc \ zipsh.cc \ getopt.c \ snprintf.c \ $(7z_SOURCES) \ $(libdeflate_SOURCES) \ $(zopfli_SOURCES) advpng_SOURCES = \ repng.cc \ pngex.cc \ file.cc \ data.cc \ siglock.cc \ compress.cc \ getopt.c \ snprintf.c \ lib/fz.c \ lib/png.c \ lib/error.c \ lib/snstring.c \ $(7z_SOURCES) \ $(libdeflate_SOURCES) \ $(zopfli_SOURCES) advmng_SOURCES = \ remng.cc \ pngex.cc \ mngex.cc \ scroll.cc \ file.cc \ data.cc \ siglock.cc \ compress.cc \ getopt.c \ snprintf.c \ lib/fz.c \ lib/png.c \ lib/mng.c \ lib/error.c \ lib/snstring.c \ $(7z_SOURCES) \ $(libdeflate_SOURCES) \ $(zopfli_SOURCES) advdef_SOURCES = \ redef.cc \ file.cc \ data.cc \ siglock.cc \ compress.cc \ getopt.c \ snprintf.c \ pngex.cc \ lib/fz.c \ lib/error.c \ lib/snstring.c \ lib/png.c \ lib/mng.c \ $(7z_SOURCES) \ $(libdeflate_SOURCES) \ $(zopfli_SOURCES) EXTRA_DIST = \ README AUTHORS HISTORY INSTALL COPYING \ doc/advdef.d doc/advzip.d doc/advpng.d doc/advmng.d doc/history.d doc/readme.d doc/authors.d doc/install.d \ doc/advdef.1 doc/advzip.1 doc/advpng.1 doc/advmng.1 doc/history.1 doc/readme.1 doc/authors.1 doc/install.1 \ doc/advdef.txt doc/advzip.txt doc/advpng.txt doc/advmng.txt doc/history.txt doc/readme.txt doc/authors.txt doc/install.txt \ autogen.sh \ 7z/README \ libdeflate/README.md \ libdeflate/COPYING \ libdeflate/NEWS \ zopfli/README \ zopfli/COPYING \ zopfli/CONTRIBUTORS \ test/test.lst \ test/archive.zip \ test/italy.png \ test/mappy.mng \ test/basn2c08.png \ test/basn3p01.png \ test/basn3p02.png \ test/basn3p04.png \ test/basn3p08.png \ test/basn6a08.png \ test/basn6a04.png noinst_HEADERS = \ snprintf.c \ pngex.h \ mngex.h \ scroll.h \ compress.h \ file.h \ data.h \ zip.h \ except.h \ siglock.h \ portable.h \ lib/png.h \ lib/mng.h \ lib/fz.h \ lib/endianrw.h \ lib/error.h \ lib/snstring.h \ lib/extra.h \ 7z/7z.h \ 7z/AriBitCoder.h \ 7z/AriConst.h \ 7z/AriPrice.h \ 7z/BinTree.h \ 7z/BinTree2.h \ 7z/BinTree2Main.h \ 7z/BinTree3.h \ 7z/BinTree3Main.h \ 7z/BinTree3Z.h \ 7z/BinTree3ZMain.h \ 7z/BinTree4.h \ 7z/BinTree4Main.h \ 7z/BinTree4b.h \ 7z/BinTree4bMain.h \ 7z/BinTreeMF.h \ 7z/BinTreeMFMain.h \ 7z/BinTreeMain.h \ 7z/BitTreeCoder.h \ 7z/CRC.h \ 7z/Const.h \ 7z/DeflateDecoder.h \ 7z/DeflateEncoder.h \ 7z/HuffmanDecoder.h \ 7z/HuffmanEncoder.h \ 7z/IInOutStreams.h \ 7z/InByte.h \ 7z/LSBFDecoder.h \ 7z/LSBFEncoder.h \ 7z/LZMA.h \ 7z/LZMADecoder.h \ 7z/LZMAEncoder.h \ 7z/LenCoder.h \ 7z/LiteralCoder.h \ 7z/OutByte.h \ 7z/Portable.h \ 7z/RCDefs.h \ 7z/RangeCoder.h \ 7z/WindowIn.h \ 7z/WindowOut.h \ libdeflate/adler32_impl.h \ libdeflate/aligned_malloc.h \ libdeflate/bt_matchfinder.h \ libdeflate/common_defs.h \ libdeflate/compiler_gcc.h \ libdeflate/crc32_impl.h \ libdeflate/crc32_table.h \ libdeflate/decompress_impl.h \ libdeflate/deflate_compress.h \ libdeflate/deflate_constants.h \ libdeflate/gzip_constants.h \ libdeflate/hc_matchfinder.h \ libdeflate/lib_common.h \ libdeflate/libdeflate.h \ libdeflate/matchfinder_avx2.h \ libdeflate/matchfinder_common.h \ libdeflate/matchfinder_neon.h \ libdeflate/matchfinder_sse2.h \ libdeflate/unaligned.h \ libdeflate/x86_cpu_features.h \ libdeflate/zlib_constants.h \ zopfli/blocksplitter.h \ zopfli/cache.h \ zopfli/deflate.h \ zopfli/gzip_container.h \ zopfli/hash.h \ zopfli/katajainen.h \ zopfli/lz77.h \ zopfli/symbols.h \ zopfli/squeeze.h \ zopfli/tree.h \ zopfli/util.h \ zopfli/zlib_container.h \ zopfli/zopfli.h man_MANS = doc/advdef.1 doc/advzip.1 doc/advpng.1 doc/advmng.1 clean-local: rm -f check.lst check.zip archive.zip mappy.mng italy.png rm -f basn2c08.png basn3p01.png basn3p02.png basn3p04.png basn3p08.png basn6a08.png basn6a04.png rm -f advdef.exe advzip.exe advpng.exe advmng.exe rm -f mappy*.png maintainer-clean-local: rm -f README AUTHORS HISTORY INSTALL doc/copying.txt rm -f doc/*.hh # Rules for documentation if HAVE_ADVD2 %.1 : %.d advd2 man < $(srcdir)/$< > $@ %.txt : %.d advd2 txt < $(srcdir)/$< | todos > $@ %.html : %.d advd2 html < $(srcdir)/$< > $@ %.hh : %.d advd2 frame < $(srcdir)/$< > $@ endif # Archives DTOU = tr -d '\015' README: doc/readme.txt cat $< | $(DTOU) > $@ AUTHORS: doc/authors.txt cat $< | $(DTOU) > $@ INSTALL: doc/install.txt cat $< | $(DTOU) > $@ HISTORY: doc/history.txt cat $< | $(DTOU) > $@ doc/copying.txt: COPYING cat $< | todos > $@ # We don't test wth -L the with -3 and -4 because the result is depending on # the compiler and/or optimization options. # This is likely a defect of 7z/zopfli implementation. # For zopfli a possible cause is the use of qsort() (not stable sorting), # that may be different on different platforms. check-local: ./advzip$(EXEEXT) test/test.lst @cp $(srcdir)/test/archive.zip . @echo CRC SIZE > check.lst $(TESTENV) ./advzip$(EXEEXT) -z archive.zip $(TESTENV) ./advzip$(EXEEXT) -L archive.zip >> check.lst $(TESTENV) ./advzip$(EXEEXT) -t -p archive.zip $(TESTENV) ./advzip$(EXEEXT) -z -3 archive.zip $(TESTENV) ./advzip$(EXEEXT) -t -p archive.zip $(TESTENV) ./advzip$(EXEEXT) -z -4 archive.zip $(TESTENV) ./advzip$(EXEEXT) -t -p archive.zip $(TESTENV) ./advzip$(EXEEXT) -a check.zip $(srcdir)/COPYING $(TESTENV) ./advzip$(EXEEXT) -t -p check.zip $(TESTENV) ./advzip$(EXEEXT) -L check.zip >> check.lst $(TESTENV) ./advzip$(EXEEXT) -a -N check.zip $(srcdir)/COPYING $(TESTENV) ./advzip$(EXEEXT) -t -p check.zip $(TESTENV) ./advzip$(EXEEXT) -L check.zip >> check.lst $(TESTENV) ./advzip$(EXEEXT) -z -3 check.zip $(TESTENV) ./advzip$(EXEEXT) -t -p check.zip $(TESTENV) ./advzip$(EXEEXT) -z -4 check.zip $(TESTENV) ./advzip$(EXEEXT) -t -p check.zip @cp $(srcdir)/test/mappy.mng . $(TESTENV) ./advmng$(EXEEXT) -v -z -f -S 8 mappy.mng $(TESTENV) ./advmng$(EXEEXT) -L mappy.mng >> check.lst $(TESTENV) ./advmng$(EXEEXT) -v -x mappy.mng $(TESTENV) ./advmng$(EXEEXT) -v -a 30 -S 8 mappy.mng mappy-*.png $(TESTENV) ./advmng$(EXEEXT) -L mappy.mng >> check.lst $(TESTENV) ./advmng$(EXEEXT) -v -a 30 -n -S 8 mappy.mng mappy-*.png $(TESTENV) ./advmng$(EXEEXT) -L mappy.mng >> check.lst $(TESTENV) ./advmng$(EXEEXT) -v -a 30 -n -r -S 8 mappy.mng mappy-*.png $(TESTENV) ./advmng$(EXEEXT) -L mappy.mng >> check.lst @cp $(srcdir)/test/italy.png . $(TESTENV) ./advpng$(EXEEXT) -z italy.png $(TESTENV) ./advpng$(EXEEXT) -L italy.png >> check.lst @cp $(srcdir)/test/basn2c08.png $(srcdir)/test/basn3p01.png $(srcdir)/test/basn3p02.png $(srcdir)/test/basn3p04.png $(srcdir)/test/basn3p08.png $(srcdir)/test/basn6a08.png $(srcdir)/test/basn6a04.png . $(TESTENV) ./advpng$(EXEEXT) -f -z basn2c08.png basn3p01.png basn3p02.png basn3p04.png basn3p08.png basn6a08.png basn6a04.png $(TESTENV) ./advpng$(EXEEXT) -L basn2c08.png basn3p01.png basn3p02.png basn3p04.png basn3p08.png basn6a08.png basn6a04.png >> check.lst cat check.lst | $(DTOU) | cmp $(srcdir)/test/test.lst @echo Success! DISTDOS_ROOT = \ doc/readme.txt doc/authors.txt doc/history.txt doc/copying.txt \ advdef.exe advzip.exe advpng.exe advmng.exe DISTDOS_DOC = \ doc/advdef.txt doc/advzip.txt doc/advpng.txt doc/advmng.txt \ doc/readme.txt doc/authors.txt doc/history.txt distdos: $(DISTDOS_ROOT) $(DISTDOS_DOC) rm -f $(PACKAGE)-$(VERSION)-dos-x86.zip mkdir tmp cp $(DISTDOS_ROOT) tmp mkdir tmp/doc cp $(DISTDOS_DOC) tmp/doc cd tmp && zip -r ../$(PACKAGE)-$(VERSION)-dos-x86.zip * rm -r tmp distwindows: $(DISTDOS_ROOT) $(DISTDOS_DOC) rm -f $(PACKAGE)-$(VERSION)-windows-x86.zip mkdir tmp cp $(DISTDOS_ROOT) tmp mkdir tmp/doc cp $(DISTDOS_DOC) tmp/doc cd tmp && zip -r ../$(PACKAGE)-$(VERSION)-windows-x86.zip * rm -r tmp DISTWEB = \ doc/advdef.hh doc/advzip.hh doc/advpng.hh doc/advmng.hh doc/history.hh web: $(DISTWEB) advancecomp-1.23/README000066400000000000000000000012761301462770100146060ustar00rootroot00000000000000 ================================= AdvanceCOMP Compression Utilities ================================= AdvanceCOMP contains recompression utilities for your .zip archives, .png images, .mng video clips and .gz files. It runs in Linux, Mac OS X, DOS, Windows and in all the other Unix like platforms. The official site of AdvanceCOMP is: http://www.advancemame.it This package contains: advzip - Recompression and test utility for zip files advpng - Recompression utility for png files advmng - Recompression utility for mng files advdef - Recompression utility for deflate streams in .png, .mng and .gz files advancecomp-1.23/autogen.sh000077500000000000000000000006241301462770100157230ustar00rootroot00000000000000#!/bin/sh # echo "Generating build information using aclocal, automake and autoconf" echo "This may take a while ..." # Touch the timestamps on all the files since CVS messes them up touch configure.ac # Regenerate configuration files aclocal automake --add-missing --force-missing autoconf autoheader && touch config.h.in # Run configure for this platform echo "Now you are ready to run ./configure" advancecomp-1.23/compress.cc000066400000000000000000000256231301462770100160720ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "compress.h" #include "data.h" bool decompress_deflate_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) { z_stream stream; int r; stream.next_in = const_cast(in_data); stream.avail_in = in_size; stream.next_out = out_data; stream.avail_out = out_size; stream.zalloc = (alloc_func)Z_NULL; stream.zfree = (free_func)Z_NULL; stream.opaque = Z_NULL; /* !! ZLIB UNDOCUMENTED FEATURE !! (used in gzio.c module ) * windowBits is passed < 0 to tell that there is no zlib header. * Note that in this case inflate *requires* an extra "dummy" byte * after the compressed stream in order to complete decompression and * return Z_STREAM_END. */ r = inflateInit2(&stream, -15); if (r != Z_OK) { return false; } r = inflate(&stream, Z_SYNC_FLUSH); /* The zlib code effectively READ the dummy byte, * this imply that the pointer MUST point to a valid data region. * The dummy byte is not always needed, only if inflate return Z_OK * instead of Z_STREAM_END. */ if (r == Z_OK) { /* dummy byte */ unsigned char dummy = 0; stream.next_in = &dummy; stream.avail_in = 1; r = inflate(&stream, Z_SYNC_FLUSH); } if (r != Z_STREAM_END) { inflateEnd(&stream); return false; } r = inflateEnd(&stream); if (r != Z_OK) { return false; } if (stream.total_in != in_size || stream.total_out != out_size) { return false; } return true; } bool compress_deflate_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level, int strategy, int mem_level) { z_stream stream; stream.next_in = const_cast(in_data); stream.avail_in = in_size; stream.next_out = out_data; stream.avail_out = out_size; stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = Z_NULL; int compression_window; unsigned required_window = in_size; // don't use the 8 bit window due a bug in the zlib 1.1.3 and previous if (required_window <= 512) compression_window = 9; else if (required_window <= 1024) compression_window = 10; else if (required_window <= 2048) compression_window = 11; else if (required_window <= 4096) compression_window = 12; else if (required_window <= 8192) compression_window = 13; else if (required_window <= 16384) compression_window = 14; else compression_window = 15; if (compression_window > MAX_WBITS) compression_window = MAX_WBITS; /* windowBits is passed < 0 to suppress the zlib header */ if (deflateInit2(&stream, compression_level, Z_DEFLATED, -compression_window, mem_level, strategy) != Z_OK) { return false; } if (deflate(&stream, Z_FINISH) != Z_STREAM_END) { deflateEnd(&stream); return false; } out_size = stream.total_out; deflateEnd(&stream); return true; } bool decompress_rfc1950_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) { unsigned long size = out_size; if (uncompress(out_data, &size, in_data, in_size) != Z_OK) return false; if (size != out_size) return false; return true; } bool compress_rfc1950_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level, int strategy, int mem_level) { z_stream stream; stream.next_in = const_cast(in_data); stream.avail_in = in_size; stream.next_out = out_data; stream.avail_out = out_size; stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = Z_NULL; int compression_window; unsigned required_window = in_size; // don't use the 8 bit window due a bug in the zlib 1.1.3 and previous if (required_window <= 512) compression_window = 9; else if (required_window <= 1024) compression_window = 10; else if (required_window <= 2048) compression_window = 11; else if (required_window <= 4096) compression_window = 12; else if (required_window <= 8192) compression_window = 13; else if (required_window <= 16384) compression_window = 14; else compression_window = 15; if (compression_window > MAX_WBITS) compression_window = MAX_WBITS; if (deflateInit2(&stream, compression_level, Z_DEFLATED, compression_window, mem_level, strategy) != Z_OK) { return false; } if (deflate(&stream, Z_FINISH) != Z_STREAM_END) { deflateEnd(&stream); return false; } out_size = stream.total_out; deflateEnd(&stream); return true; } bool compress_deflate_libdeflate(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level) { struct libdeflate_compressor* compressor; compressor = libdeflate_alloc_compressor(compression_level); out_size = libdeflate_deflate_compress(compressor, in_data, in_size, out_data, out_size); libdeflate_free_compressor(compressor); if (!out_size) return false; return true; } bool compress_rfc1950_libdeflate(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level) { struct libdeflate_compressor* compressor; compressor = libdeflate_alloc_compressor(compression_level); out_size = libdeflate_zlib_compress(compressor, in_data, in_size, out_data, out_size); libdeflate_free_compressor(compressor); if (!out_size) return false; return true; } #if USE_BZIP2 bool compress_bzip2(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int blocksize, int workfactor) { return BZ2_bzBuffToBuffCompress((char*)out_data, &out_size, (char*)(in_data), in_size, blocksize, 0, workfactor) == BZ_OK; } bool decompress_bzip2(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size) { unsigned size = out_size; if (BZ2_bzBuffToBuffDecompress((char*)out_data, &size, (char*)in_data, in_size, 0, 0)!=BZ_OK) return false; if (size != out_size) return false; return true; } #endif bool compress_zlib(shrink_t level, unsigned char* out_data, unsigned& out_size, const unsigned char* in_data, unsigned in_size) { if (level.level == shrink_insane) { ZopfliOptions opt_zopfli; unsigned char* data; size_t size; ZopfliInitOptions(&opt_zopfli); opt_zopfli.numiterations = level.iter > 5 ? level.iter : 5; size = 0; data = 0; ZopfliCompress(&opt_zopfli, ZOPFLI_FORMAT_ZLIB, in_data, in_size, &data, &size); if (size < out_size) { memcpy(out_data, data, size); out_size = static_cast(size); } free(data); } if (level.level == shrink_extra) { unsigned sz_passes; unsigned sz_fastbytes; unsigned char* data; unsigned size; switch (level.level) { case shrink_extra : sz_passes = level.iter > 15 ? level.iter : 15; if (sz_passes > 255) sz_passes = 255; sz_fastbytes = 255; break; default: assert(0); } size = out_size; data = data_alloc(size); if (compress_rfc1950_7z(in_data, in_size, data, size, sz_passes, sz_fastbytes)) { memcpy(out_data, data, size); out_size = size; } data_free(data); return true; } if (level.level == shrink_normal || level.level == shrink_extra || level.level == shrink_insane) { int compression_level; unsigned char* data; unsigned size; switch (level.level) { case shrink_normal : compression_level = 12; break; case shrink_extra : // assume that 7z is better, but does a fast try to cover some corner cases compression_level = 12; break; case shrink_insane : // assume that zopfli is better, but does a fast try to cover some corner cases compression_level = 12; break; default: assert(0); } size = out_size; data = data_alloc(size); if (compress_rfc1950_libdeflate(in_data, in_size, data, size, compression_level)) { memcpy(out_data, data, size); out_size = size; } data_free(data); return true; } if (level.level == shrink_none || level.level == shrink_fast) { int libz_level; unsigned char* data; unsigned size; switch (level.level) { case shrink_none : libz_level = Z_NO_COMPRESSION; break; default: libz_level = Z_BEST_COMPRESSION; break; } size = out_size; data = data_alloc(size); if (compress_rfc1950_zlib(in_data, in_size, data, size, libz_level, Z_DEFAULT_STRATEGY, MAX_MEM_LEVEL)) { memcpy(out_data, data, size); out_size = size; } data_free(data); } return true; } bool compress_deflate(shrink_t level, unsigned char* out_data, unsigned& out_size, const unsigned char* in_data, unsigned in_size) { if (level.level == shrink_insane) { ZopfliOptions opt_zopfli; unsigned char* data; size_t size; ZopfliInitOptions(&opt_zopfli); opt_zopfli.numiterations = level.iter > 5 ? level.iter : 5; size = 0; data = 0; ZopfliCompress(&opt_zopfli, ZOPFLI_FORMAT_DEFLATE, in_data, in_size, &data, &size); if (size < out_size) { memcpy(out_data, data, size); out_size = static_cast(size); } free(data); } // note that in some case, 7z is better than zopfli if (level.level == shrink_normal || level.level == shrink_extra || level.level == shrink_insane) { int compression_level; unsigned char* data; unsigned size; switch (level.level) { case shrink_normal : compression_level = 6; break; case shrink_extra : compression_level = 12; break; case shrink_insane : // assume that zopfli is better, but does a fast try to cover some corner cases compression_level = 12; break; default: assert(0); } size = out_size; data = data_alloc(size); if (compress_deflate_libdeflate(in_data, in_size, data, size, compression_level)) { memcpy(out_data, data, size); out_size = size; } data_free(data); } if (level.level == shrink_none || level.level == shrink_fast) { int libz_level; unsigned char* data; unsigned size; switch (level.level) { case shrink_none : libz_level = Z_NO_COMPRESSION; break; default: libz_level = Z_BEST_COMPRESSION; break; } size = out_size; data = data_alloc(size); if (compress_deflate_zlib(in_data, in_size, data, size, libz_level, Z_DEFAULT_STRATEGY, MAX_MEM_LEVEL)) { memcpy(out_data, data, size); out_size = size; } data_free(data); } return true; } unsigned oversize_deflate(unsigned size) { return size + size / 10 + 12; } unsigned oversize_zlib(unsigned size) { return oversize_deflate(size) + 10; } advancecomp-1.23/compress.h000066400000000000000000000053231301462770100157270ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __COMPRESS_H #define __COMPRESS_H #include "7z/7z.h" extern "C" { #include "libdeflate/libdeflate.h" } extern "C" { #include "zopfli/zopfli.h" } #if USE_BZIP2 #include #endif #include #define RETRY_FOR_SMALL_FILES 65536 /**< Size for which we try multiple algorithms */ unsigned oversize_deflate(unsigned size); unsigned oversize_zlib(unsigned size); bool decompress_deflate_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size); bool compress_deflate_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level, int strategy, int mem_level); bool decompress_bzip2(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size); bool compress_bzip2(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int blocksize, int workfactor); bool decompress_rfc1950_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned out_size); bool compress_rfc1950_zlib(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level, int strategy, int mem_level); bool compress_deflate_libdeflate(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level); bool compress_rfc1950_libdeflate(const unsigned char* in_data, unsigned in_size, unsigned char* out_data, unsigned& out_size, int compression_level); enum shrink_level_t { shrink_none, shrink_fast, shrink_normal, shrink_extra, shrink_insane }; struct shrink_t { enum shrink_level_t level; unsigned iter; }; bool compress_zlib(shrink_t level, unsigned char* out_data, unsigned& out_size, const unsigned char* in_data, unsigned in_size); bool compress_deflate(shrink_t level, unsigned char* out_data, unsigned& out_size, const unsigned char* in_data, unsigned in_size); #endif advancecomp-1.23/configure.ac000066400000000000000000000042011301462770100162030ustar00rootroot00000000000000dnl Process this file with autoconf to produce a configure script. AC_PREREQ([2.65]) AC_INIT([AdvanceCOMP], [1.23], [], [], [http://www.advancemame.it]) AM_INIT_AUTOMAKE([foreign no-dependencies subdir-objects]) AC_CONFIG_SRCDIR([rezip.cc]) AC_CONFIG_HEADERS([config.h]) AC_CANONICAL_HOST dnl Checks for programs. AC_USE_SYSTEM_EXTENSIONS AC_PROG_CC AC_PROG_CXX AC_PROG_INSTALL AC_PROG_AWK AC_CHECK_PROGS(TAR, tar) AC_CHECK_PROGS(GZIP, gzip) AC_CHECK_PROGS(GROFF, groff) AC_CHECK_PROGS(COL, col) AC_CHECK_PROG([VALGRIND],[valgrind],[valgrind --leak-check=full --track-fds=yes --error-exitcode=1],[]) AC_CHECK_PROG([WINE],[wine],[wine],[]) AC_CHECK_PROG([ADVD2],[advd2],[advd2],[]) AM_CONDITIONAL(HAVE_ADVD2, [test x"$ADVD2" != x]) dnl Checks for libraries. AC_SYS_LARGEFILE AC_CHECK_LIB([z], [adler32], [], [AC_MSG_ERROR([the libz library is missing])]) dnl Checks for header files. AC_HEADER_STDC AC_HEADER_SYS_WAIT AC_HEADER_DIRENT AC_HEADER_TIME AC_CHECK_HEADERS([unistd.h getopt.h utime.h stdarg.h varargs.h stdint.h]) AC_CHECK_HEADERS([sys/types.h sys/stat.h sys/time.h sys/utime.h]) dnl Checks for typedefs, structures, and compiler characteristics. AC_C_CONST AC_C_INLINE dnl Checks for library functions. AC_CHECK_FUNCS([getopt getopt_long snprintf vsnprintf]) AC_ARG_ENABLE( bzip2, [ --enable-bzip2 Use the bzip2 compression], AC_DEFINE(USE_BZIP2,1,[Use the bzip2 compression]) AC_CHECK_LIB([bz2], [BZ2_bzBuffToBuffCompress], [], [AC_MSG_ERROR([the libbz2 library is missing])]) ) dnl Checks for test environment AS_CASE([$host], [*-*-mingw*], [TESTENV="$WINE"], []) AC_ARG_ENABLE([valgrind], [AS_HELP_STRING([--enable-valgrind],[enable the use of valgrind in testing])], [ TESTENV="$VALGRIND" CFLAGS="$CFLAGS -DCHECKER" CXXFLAGS="$CXXFLAGS -DCHECKER" ], []) AC_ARG_ENABLE([debug], [AS_HELP_STRING([--enable-debug],[enable debugging])], [ TESTENV="" CFLAGS="-O0 -g -Wall -Wextra" CXXFLAGS="-O0 -g -Wall -Wextra" ], []) dnl Configure the library CFLAGS="$CFLAGS -DUSE_ERROR_SILENT -DUSE_COMPRESS" CXXFLAGS="$CXXFLAGS -DUSE_ERROR_SILENT -DUSE_COMPRESS" AC_ARG_VAR([TESTENV], [Test environment]) AC_CONFIG_FILES([Makefile]) AC_OUTPUT advancecomp-1.23/configure.dos000077500000000000000000000004321301462770100164120ustar00rootroot00000000000000./configure \ CFLAGS="-O2 -Wall -march=i686 -fomit-frame-pointer -fno-strict-aliasing -fno-strict-overflow" \ CXXFLAGS="-O2 -Wall -march=i686 -fomit-frame-pointer -fno-strict-aliasing -fno-strict-overflow" \ LDFLAGS="-s" \ --host=i586-pc-msdosdjgpp --build=`./config.guess` $@ advancecomp-1.23/configure.windows-x86000077500000000000000000000004371301462770100177470ustar00rootroot00000000000000./configure \ CFLAGS="-O2 -Wall -march=i686 -fomit-frame-pointer -fno-strict-aliasing -fno-strict-overflow" \ CXXFLAGS="-O2 -Wall -march=i686 -fomit-frame-pointer -fno-strict-aliasing -fno-strict-overflow" \ LDFLAGS="-s" \ --host=i686-w64-mingw32.static --build=`./config.guess` $@ advancecomp-1.23/data.cc000066400000000000000000000026651301462770100151510ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "data.h" #include using namespace std; /** * Duplicate a memory buffer. */ unsigned char* data_dup(const unsigned char* Adata, unsigned Asize) { if (Adata) { unsigned char* data = (unsigned char*)malloc(Asize); if (!data) throw std::bad_alloc(); if (Asize) memcpy(data, Adata, Asize); return data; } else { return 0; } } /** * Allocate a memory buffer. */ unsigned char* data_alloc(unsigned size) { unsigned char* data = (unsigned char*)malloc(size); if (!data) throw std::bad_alloc(); return data; } /** * Free a memory buffer. */ void data_free(unsigned char* data) { free(data); } advancecomp-1.23/data.h000066400000000000000000000030251301462770100150020ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __DATA_H #define __DATA_H unsigned char* data_dup(const unsigned char* Adata, unsigned Asize); unsigned char* data_alloc(unsigned size); void data_free(unsigned char* data); class data_ptr { unsigned char* data; bool own; public: data_ptr() : data(0), own(false) { } data_ptr(data_ptr& A) { data = A.data; own = A.own; A.own = false; } data_ptr(unsigned char* Adata, bool Aown = true) : data(Adata), own(Aown) { } ~data_ptr() { if (own) data_free(data); } void operator=(data_ptr& A) { if (own) data_free(data); data = A.data; own = A.own; A.own = false; } void operator=(unsigned char* Adata) { if (own) data_free(data); data = Adata; own = true; } operator unsigned char*() { return data; } }; #endif advancecomp-1.23/doc/000077500000000000000000000000001301462770100144655ustar00rootroot00000000000000advancecomp-1.23/doc/advdef.1000066400000000000000000000044651301462770100160110ustar00rootroot00000000000000.TH "AdvanceCOMP Deflate Compression Utility" 1 .SH NAME advdef \- AdvanceCOMP Deflate Compression Utility .SH SYNOPSIS advdef [\-z, \-\-recompress] [\-0, \-\-shrink\-store] .PD 0 .PP .PD [\-1, \-\-shrink\-fast] [\-2, \-\-shrink\-normal] [\-3, \-\-shrink\-extra] .PD 0 .PP .PD [\-4, \-\-shrink\-insane] [\-i, \-\-iter N] .PD 0 .PP .PD [\-f, \-\-force] [\-q, \-\-quiet] .PD 0 .PP .PD [\-h, \-\-help] [\-V, \-\-version] FILES... .PD 0 .PP .PD .SH DESCRIPTION The main purpose of this utility is to recompress the data present in the .png, .mng, .gz, .tgz and .svgz files. .PP The internal structure of the files isn\'t changed. Only the compressed data is modified. .SH OPTIONS .TP .B \-z, \-\-recompress FILES... Recompress the specified files. If the \-1, \-2, \-3, \-4 options are specified it\'s used the smallest file choice from the previous compressed data and the new compression. If the \-0 option is specified the file is always rewritten without any compression. .TP .B \-0, \-\-shrink\-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it\'s bigger. .TP .B \-1, \-\-shrink\-fast Set the compression level to \[dq]fast\[dq] using the zlib compressor. .TP .B \-2, \-\-shrink\-normal Set the compression level to \[dq]normal\[dq] using the libdeflate compressor. This is the default level of compression. .TP .B \-3, \-\-shrink\-extra Set the compression level to \[dq]extra\[dq] using the 7z compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-4, \-\-shrink\-insane Set the compression level to \[dq]insane\[dq] using the zopfli compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-i, \-\-iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes \-3 and \-4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. .TP .B \-f, \-\-force Force the use of the new file also if it\'s bigger. .SH LIMITATIONS The advdef program cannot be used to recompress huge files because it needs to allocate memory for both the complete compressed and uncompressed data. .SH COPYRIGHT This file is Copyright (C) 2003, 2004 Andrea Mazzoleni .SH SEE ALSO advpng(1), advmng(1), advzip(1), gzip(1), bzip2(1) advancecomp-1.23/doc/advdef.d000066400000000000000000000041261301462770100160660ustar00rootroot00000000000000Name{number} advdef - AdvanceCOMP Deflate Compression Utility Synopsis :advdef [-z, --recompress] [-0, --shrink-store] : [-1, --shrink-fast] [-2, --shrink-normal] [-3, --shrink-extra] : [-4, --shrink-insane] [-i, --iter N] : [-f, --force] [-q, --quiet] : [-h, --help] [-V, --version] FILES... Description The main purpose of this utility is to recompress the data present in the .png, .mng, .gz, .tgz and .svgz files. The internal structure of the files isn't changed. Only the compressed data is modified. Options -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3, -4 options are specified it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -f, --force Force the use of the new file also if it's bigger. Limitations The advdef program cannot be used to recompress huge files because it needs to allocate memory for both the complete compressed and uncompressed data. Copyright This file is Copyright (C) 2003, 2004 Andrea Mazzoleni See Also advpng(1), advmng(1), advzip(1), gzip(1), bzip2(1) advancecomp-1.23/doc/advdef.txt000066400000000000000000000050531301462770100164620ustar00rootroot00000000000000 ======================================= AdvanceCOMP Deflate Compression Utility ======================================= 1 SYNOPSIS ========== advdef [-z, --recompress] [-0, --shrink-store] [-1, --shrink-fast] [-2, --shrink-normal] [-3, --shrink-extra] [-4, --shrink-insane] [-i, --iter N] [-f, --force] [-q, --quiet] [-h, --help] [-V, --version] FILES... 2 DESCRIPTION ============= The main purpose of this utility is to recompress the data present in the .png, .mng, .gz, .tgz and .svgz files. The internal structure of the files isn't changed. Only the compressed data is modified. 3 OPTIONS ========= -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3, -4 options are specified it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -f, --force Force the use of the new file also if it's bigger. 4 LIMITATIONS ============= The advdef program cannot be used to recompress huge files because it needs to allocate memory for both the complete compressed and uncompressed data. 5 COPYRIGHT =========== This file is Copyright (C) 2003, 2004 Andrea Mazzoleni 6 SEE ALSO ========== advpng(1), advmng(1), advzip(1), gzip(1), bzip2(1) advancecomp-1.23/doc/advmng.1000066400000000000000000000131571301462770100160320ustar00rootroot00000000000000.TH "AdvanceCOMP MNG Compression Utility" 1 .SH NAME advmng \- AdvanceCOMP MNG Compression Utility .SH SYNOPSIS advmng [\-l, \-\-list] [\-z, \-\-recompress] .PD 0 .PP .PD [\-x, \-\-extract] [\-a, \-\-add RATE MNG_FILE PNG_FILES...] .PD 0 .PP .PD [\-0, \-\-shrink\-store] [\-1, \-\-shrink\-fast] [\-2, \-\-shrink\-normal] .PD 0 .PP .PD [\-3, \-\-shrink\-extra] [\-4, \-\-shrink\-insane] [\-i, \-\-iter N] .PD 0 .PP .PD [\-s, \-\-scroll HxV] [\-S, \-\-scroll\-square] .PD 0 .PP .PD [\-e, \-\-expand] [\-r, \-\-reduce] .PD 0 .PP .PD [\-c, \-\-lc] [\-C, \-\-vlc] [\-f, \-\-force] [\-q, \-\-quiet] [\-v, \-\-verbose] .PD 0 .PP .PD [\-h, \-\-help] [\-V, \-\-version] FILES... .PD 0 .PP .PD .SH DESCRIPTION The main purpose of this utility is to recompress MNG files to get the smallest possible size. .PP Please note that this utility is not able to read a generic file. It\'s granted to be able to read only the files generated by the AdvanceMAME emulator. .PP To compress the files this utility uses the following strategies: .PD 0 .IP \(bu Remove all ancillary chunks. .IP \(bu Use the MNG Delta feature to compress video clips with only small changes between frames. .IP \(bu Use the MNG Move feature to compress video clips with a scrolling background (option \-s). .IP \(bu Reduce the color depth to 8 bit (option \-r). .IP \(bu Use the 7zip Deflate implementation. .PD .SH COMMANDS .TP .B \-l, \-\-list FILES... List the content of the specified files. .TP .B \-z, \-\-recompress FILES... Recompress the specified files. If the \-1, \-2, \-3 options are specified, it\'s used the smallest file choice from the previous compressed data and the new compression. If the \-0 option is specified the file is always rewritten without any compression. .TP .B \-x, \-\-extract FILES... Extract all the .png frames in the .mng clips. You can use the \-\-shrink options to control the compression ratio of the .png files. The extracted images are always 24 bit images with alpha channel. You can remove the alpha channel with the \-n option. .TP .B \-a, \-\-add RATE MNG_FILE PNG_FILES... Compress all the .png files on the command line as a .mng file. All the .png files must have the same size and the same bit depth. You must also specify an integer frame rate to use in the .mng file. .SH OPTIONS .TP .B \-0, \-\-shrink\-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it\'s bigger. .TP .B \-1, \-\-shrink\-fast Set the compression level to \[dq]fast\[dq] using the zlib compressor. .TP .B \-2, \-\-shrink\-normal Set the compression level to \[dq]normal\[dq] using the libdeflate compressor. This is the default level of compression. .TP .B \-3, \-\-shrink\-extra Set the compression level to \[dq]extra\[dq] using the 7z compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-4, \-\-shrink\-insane Set the compression level to \[dq]insane\[dq] using the zopfli compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-i, \-\-iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes \-3 and \-4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. .TP .B \-s, \-\-scroll HxV The \[dq]\-s HxV\[dq] option specifies the size of the pattern (H width x V height) used to check for a scrolling background. The size is expressed in pixels and it must be bigger or equal than the scrolling speed of the background. For example take the game 1942 that scrolls vertically by 1 pixel every frame. If you recorded with an interleave factor of 2 the vertical scrolling speed is 1*2 = 2. In this case the minimum pattern is \[dq]\-s 0x2\[dq]. Generally you can use \[dq]\-s 8x8\[dq] and use bigger values only for games scrolling faster. If the game scrolls only horizontally or vertically you can speed up a lot the compression with monodirectional patterns like \[dq]\-s 16x0\[dq] or \[dq]\-s 0x16\[dq]. .TP .B \-S, \-\-scroll\-square N This option is like the option \[dq]\-s NxN\[dq] but excludes big movement on both directions reducing the computation time. Specifically the check done is X+Y<=N. .TP .B \-r, \-\-reduce Force the color reduction to 8 bit. The reduction is really done only if any frame have less than 256 colors and if no alpha channel is present. To force the reduction also if an alpha channel is present use the \-n option. .TP .B \-e, \-\-expand Force the color expansion to 24 bit. .TP .B \-n, \-\-noalpha Remove the alpha channel if present. .TP .B \-c, \-\-lc Force the use of the MNG LC (Low Complexity) specifications. It disables the delta compression. The file is always rewritten also if it\'s bigger. .TP .B \-C, \-\-vlc Force the use of the MNG VLC (Very Low Complexity) specifications. It disables the delta compression and the precise timing. Warning! you may lose the correct timing information because the VLC format only supports integer frequency. The file is always rewritten also if it\'s bigger. .TP .B \-f, \-\-force Force the use of the new file also if it\'s bigger. .TP .B \-q, \-\-quiet Don\'t print the filenames. .TP .B \-v, \-\-verbose Print more information on the compression process. .SH EXAMPLES A good tradeoff of recompression and time is the command : .PP .RS 4 advmng \-z \-r \-S 16 *.mng .RE .PP To create a .mng file from a series of .png files use the command : .PP .RS 4 advmng \-a 30 video.mng video*.png .RE .PP To extract all the images in a .mng file use the command : .PP .RS 4 advmng \-x video.mng .RE .SH COPYRIGHT This file is Copyright (C) 2003 Andrea Mazzoleni, Filipe Estima .SH SEE ALSO advzip(1), advpng(1), advdef(1) advancecomp-1.23/doc/advmng.d000066400000000000000000000122671301462770100161160ustar00rootroot00000000000000Name{number} advmng - AdvanceCOMP MNG Compression Utility Synopsis :advmng [-l, --list] [-z, --recompress] : [-x, --extract] [-a, --add RATE MNG_FILE PNG_FILES...] : [-0, --shrink-store] [-1, --shrink-fast] [-2, --shrink-normal] : [-3, --shrink-extra] [-4, --shrink-insane] [-i, --iter N] : [-s, --scroll HxV] [-S, --scroll-square] : [-e, --expand] [-r, --reduce] : [-c, --lc] [-C, --vlc] [-f, --force] [-q, --quiet] [-v, --verbose] : [-h, --help] [-V, --version] FILES... Description The main purpose of this utility is to recompress MNG files to get the smallest possible size. Please note that this utility is not able to read a generic file. It's granted to be able to read only the files generated by the AdvanceMAME emulator. To compress the files this utility uses the following strategies: * Remove all ancillary chunks. * Use the MNG Delta feature to compress video clips with only small changes between frames. * Use the MNG Move feature to compress video clips with a scrolling background (option -s). * Reduce the color depth to 8 bit (option -r). * Use the 7zip Deflate implementation. Commands -l, --list FILES... List the content of the specified files. -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3 options are specified, it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -x, --extract FILES... Extract all the .png frames in the .mng clips. You can use the --shrink options to control the compression ratio of the .png files. The extracted images are always 24 bit images with alpha channel. You can remove the alpha channel with the -n option. -a, --add RATE MNG_FILE PNG_FILES... Compress all the .png files on the command line as a .mng file. All the .png files must have the same size and the same bit depth. You must also specify an integer frame rate to use in the .mng file. Options -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -s, --scroll HxV The "-s HxV" option specifies the size of the pattern (H width x V height) used to check for a scrolling background. The size is expressed in pixels and it must be bigger or equal than the scrolling speed of the background. For example take the game 1942 that scrolls vertically by 1 pixel every frame. If you recorded with an interleave factor of 2 the vertical scrolling speed is 1*2 = 2. In this case the minimum pattern is "-s 0x2". Generally you can use "-s 8x8" and use bigger values only for games scrolling faster. If the game scrolls only horizontally or vertically you can speed up a lot the compression with monodirectional patterns like "-s 16x0" or "-s 0x16". -S, --scroll-square N This option is like the option "-s NxN" but excludes big movement on both directions reducing the computation time. Specifically the check done is X+Y<=N. -r, --reduce Force the color reduction to 8 bit. The reduction is really done only if any frame have less than 256 colors and if no alpha channel is present. To force the reduction also if an alpha channel is present use the -n option. -e, --expand Force the color expansion to 24 bit. -n, --noalpha Remove the alpha channel if present. -c, --lc Force the use of the MNG LC (Low Complexity) specifications. It disables the delta compression. The file is always rewritten also if it's bigger. -C, --vlc Force the use of the MNG VLC (Very Low Complexity) specifications. It disables the delta compression and the precise timing. Warning! you may lose the correct timing information because the VLC format only supports integer frequency. The file is always rewritten also if it's bigger. -f, --force Force the use of the new file also if it's bigger. -q, --quiet Don't print the filenames. -v, --verbose Print more information on the compression process. Examples A good tradeoff of recompression and time is the command : advmng -z -r -S 16 *.mng To create a .mng file from a series of .png files use the command : advmng -a 30 video.mng video*.png To extract all the images in a .mng file use the command : advmng -x video.mng Copyright This file is Copyright (C) 2003 Andrea Mazzoleni, Filipe Estima See Also advzip(1), advpng(1), advdef(1) advancecomp-1.23/doc/advmng.txt000066400000000000000000000140411301462770100165020ustar00rootroot00000000000000 =================================== AdvanceCOMP MNG Compression Utility =================================== 1 SYNOPSIS ========== advmng [-l, --list] [-z, --recompress] [-x, --extract] [-a, --add RATE MNG_FILE PNG_FILES...] [-0, --shrink-store] [-1, --shrink-fast] [-2, --shrink-normal] [-3, --shrink-extra] [-4, --shrink-insane] [-i, --iter N] [-s, --scroll HxV] [-S, --scroll-square] [-e, --expand] [-r, --reduce] [-c, --lc] [-C, --vlc] [-f, --force] [-q, --quiet] [-v, --verbose] [-h, --help] [-V, --version] FILES... 2 DESCRIPTION ============= The main purpose of this utility is to recompress MNG files to get the smallest possible size. Please note that this utility is not able to read a generic file. It's granted to be able to read only the files generated by the AdvanceMAME emulator. To compress the files this utility uses the following strategies: * Remove all ancillary chunks. * Use the MNG Delta feature to compress video clips with only small changes between frames. * Use the MNG Move feature to compress video clips with a scrolling background (option -s). * Reduce the color depth to 8 bit (option -r). * Use the 7zip Deflate implementation. 3 COMMANDS ========== -l, --list FILES... List the content of the specified files. -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3 options are specified, it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -x, --extract FILES... Extract all the .png frames in the .mng clips. You can use the --shrink options to control the compression ratio of the .png files. The extracted images are always 24 bit images with alpha channel. You can remove the alpha channel with the -n option. -a, --add RATE MNG_FILE PNG_FILES... Compress all the .png files on the command line as a .mng file. All the .png files must have the same size and the same bit depth. You must also specify an integer frame rate to use in the .mng file. 4 OPTIONS ========= -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -s, --scroll HxV The "-s HxV" option specifies the size of the pattern (H width x V height) used to check for a scrolling background. The size is expressed in pixels and it must be bigger or equal than the scrolling speed of the background. For example take the game 1942 that scrolls vertically by 1 pixel every frame. If you recorded with an interleave factor of 2 the vertical scrolling speed is 1*2 = 2. In this case the minimum pattern is "-s 0x2". Generally you can use "-s 8x8" and use bigger values only for games scrolling faster. If the game scrolls only horizontally or vertically you can speed up a lot the compression with monodirectional patterns like "-s 16x0" or "-s 0x16". -S, --scroll-square N This option is like the option "-s NxN" but excludes big movement on both directions reducing the computation time. Specifically the check done is X+Y<=N. -r, --reduce Force the color reduction to 8 bit. The reduction is really done only if any frame have less than 256 colors and if no alpha channel is present. To force the reduction also if an alpha channel is present use the -n option. -e, --expand Force the color expansion to 24 bit. -n, --noalpha Remove the alpha channel if present. -c, --lc Force the use of the MNG LC (Low Complexity) specifications. It disables the delta compression. The file is always rewritten also if it's bigger. -C, --vlc Force the use of the MNG VLC (Very Low Complexity) specifications. It disables the delta compression and the precise timing. Warning! you may lose the correct timing information because the VLC format only supports integer frequency. The file is always rewritten also if it's bigger. -f, --force Force the use of the new file also if it's bigger. -q, --quiet Don't print the filenames. -v, --verbose Print more information on the compression process. 5 EXAMPLES ========== A good tradeoff of recompression and time is the command : advmng -z -r -S 16 *.mng To create a .mng file from a series of .png files use the command : advmng -a 30 video.mng video*.png To extract all the images in a .mng file use the command : advmng -x video.mng 6 COPYRIGHT =========== This file is Copyright (C) 2003 Andrea Mazzoleni, Filipe Estima 7 SEE ALSO ========== advzip(1), advpng(1), advdef(1) advancecomp-1.23/doc/advpng.1000066400000000000000000000047031301462770100160320ustar00rootroot00000000000000.TH "AdvanceCOMP PNG Compression Utility" 1 .SH NAME advpng \- AdvanceCOMP PNG Compression Utility .SH SYNOPSIS advpng [\-l, \-\-list] [\-z, \-\-recompress] [\-0, \-\-shrink\-0] .PD 0 .PP .PD [\-1, \-\-shrink\-fast] [\-2, \-\-shrink\-normal [\-3, \-\-shrink\-extra] .PD 0 .PP .PD [\-4, \-\-shrink\-insane] [\-i, \-\-iter N] .PD 0 .PP .PD [\-f, \-\-force] [\-q, \-\-quiet] .PD 0 .PP .PD [\-h, \-\-help] [\-V, \-\-version] FILES... .PD 0 .PP .PD .SH DESCRIPTION The main purpose of this utility is to recompress png files to get the smallest possible size. .PP Please note that this utility is not able to read a generic file. It\'s granted to be able to read only the files generated by the AdvanceMAME emulator. .PP To compress the files this utility uses the following strategies: .PD 0 .IP \(bu Remove all ancillary chunks. .IP \(bu Concatenate all the IDAT chunks. .IP \(bu Use the 7zip Deflate implementation. .PD .SH OPTIONS .TP .B \-l, \-\-list FILES... List the content of the specified files. .TP .B \-z, \-\-recompress FILES... Recompress the specified files. If the \-1, \-2, \-3 options are specified it\'s used the smallest file choice from the previous compressed data and the new compression. If the \-0 option is specified the file is always rewritten without any compression. .TP .B \-0, \-\-shrink\-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it\'s bigger. .TP .B \-1, \-\-shrink\-fast Set the compression level to \[dq]fast\[dq] using the zlib compressor. .TP .B \-2, \-\-shrink\-normal Set the compression level to \[dq]normal\[dq] using the libdeflate compressor. This is the default level of compression. .TP .B \-3, \-\-shrink\-extra Set the compression level to \[dq]extra\[dq] using the 7z compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-4, \-\-shrink\-insane Set the compression level to \[dq]insane\[dq] using the zopfli compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-i, \-\-iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes \-3 and \-4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. .TP .B \-f, \-\-force Force the use of the new file also if it\'s bigger. .SH COPYRIGHT This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima .SH SEE ALSO advzip(1), advmng(1), advdef(1) advancecomp-1.23/doc/advpng.d000066400000000000000000000043041301462770100161120ustar00rootroot00000000000000Name{number} advpng - AdvanceCOMP PNG Compression Utility Synopsis :advpng [-l, --list] [-z, --recompress] [-0, --shrink-0] : [-1, --shrink-fast] [-2, --shrink-normal [-3, --shrink-extra] : [-4, --shrink-insane] [-i, --iter N] : [-f, --force] [-q, --quiet] : [-h, --help] [-V, --version] FILES... Description The main purpose of this utility is to recompress png files to get the smallest possible size. Please note that this utility is not able to read a generic file. It's granted to be able to read only the files generated by the AdvanceMAME emulator. To compress the files this utility uses the following strategies: * Remove all ancillary chunks. * Concatenate all the IDAT chunks. * Use the 7zip Deflate implementation. Options -l, --list FILES... List the content of the specified files. -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3 options are specified it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -f, --force Force the use of the new file also if it's bigger. Copyright This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima See Also advzip(1), advmng(1), advdef(1) advancecomp-1.23/doc/advpng.txt000066400000000000000000000052171301462770100165120ustar00rootroot00000000000000 =================================== AdvanceCOMP PNG Compression Utility =================================== 1 SYNOPSIS ========== advpng [-l, --list] [-z, --recompress] [-0, --shrink-0] [-1, --shrink-fast] [-2, --shrink-normal [-3, --shrink-extra] [-4, --shrink-insane] [-i, --iter N] [-f, --force] [-q, --quiet] [-h, --help] [-V, --version] FILES... 2 DESCRIPTION ============= The main purpose of this utility is to recompress png files to get the smallest possible size. Please note that this utility is not able to read a generic file. It's granted to be able to read only the files generated by the AdvanceMAME emulator. To compress the files this utility uses the following strategies: * Remove all ancillary chunks. * Concatenate all the IDAT chunks. * Use the 7zip Deflate implementation. 3 OPTIONS ========= -l, --list FILES... List the content of the specified files. -z, --recompress FILES... Recompress the specified files. If the -1, -2, -3 options are specified it's used the smallest file choice from the previous compressed data and the new compression. If the -0 option is specified the file is always rewritten without any compression. -0, --shrink-store Disable the compression. The file is only stored and not compressed. The file is always rewritten also if it's bigger. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. -f, --force Force the use of the new file also if it's bigger. 4 COPYRIGHT =========== This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima 5 SEE ALSO ========== advzip(1), advmng(1), advdef(1) advancecomp-1.23/doc/advzip.1000066400000000000000000000067161301462770100160560ustar00rootroot00000000000000.TH "AdvanceCOMP ZIP Compression Utility" 1 .SH NAME advzip \- AdvanceCOMP ZIP Compression Utility .SH SYNOPSIS advzip [\-a, \-\-add] [\-x, \-\-extract] [\-l, \-\-list] .PD 0 .PP .PD [\-z, \-\-recompress] [\-t, \-\-test] [\-0, \-\-shrink\-store] .PD 0 .PP .PD [\-1, \-\-shrink\-fast] [\-2, \-\-shrink\-normal] [\-3, \-\-shrink\-extra] .PD 0 .PP .PD [\-4, \-\-shrink\-insane] [\-i, \-\-iter N] .PD 0 .PP .PD [\-k, \-\-keep\-file\-time] [\-p, \-\-pedantic] [\-q, \-\-quiet] .PD 0 .PP .PD [\-h, \-\-help] [\-V, \-\-version] ARCHIVES... [FILES...] .PD 0 .PP .PD .SH DESCRIPTION The main purpose of this utility is to recompress and test the zip archives to get the smallest possible size. .PP For recompression the libdeflate implementation is used. This implementation generally gives 5\-10% more compression than the zLib Deflate implementation, and it\'s also generally faster. .PP For experimental purpose also the 7\-Zip LZMA algorithm is available with the \-N option. In this case, the generated zips WILL NOT BE USABLE by any other program. To make them usable you need to recompress them without the \-N option. Generally this algorithm gives 10\-20% more compression than the zLib Deflate implementation. .SH OPTIONS .TP .B \-a, \-\-add ARCHIVE FILES... Create the specified archive with the specified files. You must specify only one archive. .TP .B \-x, \-\-extract ARCHIVE Extract all the files on the specified archive. You must specify only one archive. .TP .B \-l, \-\-list ARCHIVES... List the content of the specified archives. .TP .B \-z, \-\-recompress ARCHIVES... Recompress the specified archives. If the \-1, \-2, \-3, \-4 options are specified, it\'s used the smallest file choice from: the previous compressed data, the new compression and the uncompressed format. If the \-0 option is specified the archive is always rewritten without any compression. .TP .B \-t, \-\-test ARCHIVES... Test the specified archives. The tests may be extended with the \-p option. .TP .B \-k, \-\-keep\-file\-time When recompressing with \-z keep the .zip file time. .TP .B \-p, \-\-pedantic Be pedantic on the zip tests. If this flag is enabled some more extensive tests on the zip integrity are done. These tests are generally not done by other zip utilities. .TP .B \-0, \-\-shrink\-store Disable the compression. The file is only stored and not compressed. This option is very useful to expand the archives of .png and .mp3 files. These files are already compressed, trying to compress them another time is really a waste of time and resource. .TP .B \-1, \-\-shrink\-fast Set the compression level to \[dq]fast\[dq] using the zlib compressor. .TP .B \-2, \-\-shrink\-normal Set the compression level to \[dq]normal\[dq] using the libdeflate compressor. This is the default level of compression. .TP .B \-3, \-\-shrink\-extra Set the compression level to \[dq]extra\[dq] using the 7z compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-4, \-\-shrink\-insane Set the compression level to \[dq]insane\[dq] using the zopfli compressor. You can define the compressor iterations with the \-i, \-\-iter option. .TP .B \-i, \-\-iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes \-3 and \-4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. .SH COPYRIGHT This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima .SH SEE ALSO advpng(1), advmng(1), advdef(1) advancecomp-1.23/doc/advzip.d000066400000000000000000000063111301462770100161300ustar00rootroot00000000000000Name{number} advzip - AdvanceCOMP ZIP Compression Utility Synopsis :advzip [-a, --add] [-x, --extract] [-l, --list] : [-z, --recompress] [-t, --test] [-0, --shrink-store] : [-1, --shrink-fast] [-2, --shrink-normal] [-3, --shrink-extra] : [-4, --shrink-insane] [-i, --iter N] : [-k, --keep-file-time] [-p, --pedantic] [-q, --quiet] : [-h, --help] [-V, --version] ARCHIVES... [FILES...] Description The main purpose of this utility is to recompress and test the zip archives to get the smallest possible size. For recompression the libdeflate implementation is used. This implementation generally gives 5-10% more compression than the zLib Deflate implementation, and it's also generally faster. For experimental purpose also the 7-Zip LZMA algorithm is available with the -N option. In this case, the generated zips WILL NOT BE USABLE by any other program. To make them usable you need to recompress them without the -N option. Generally this algorithm gives 10-20% more compression than the zLib Deflate implementation. Options -a, --add ARCHIVE FILES... Create the specified archive with the specified files. You must specify only one archive. -x, --extract ARCHIVE Extract all the files on the specified archive. You must specify only one archive. -l, --list ARCHIVES... List the content of the specified archives. -z, --recompress ARCHIVES... Recompress the specified archives. If the -1, -2, -3, -4 options are specified, it's used the smallest file choice from: the previous compressed data, the new compression and the uncompressed format. If the -0 option is specified the archive is always rewritten without any compression. -t, --test ARCHIVES... Test the specified archives. The tests may be extended with the -p option. -k, --keep-file-time When recompressing with -z keep the .zip file time. -p, --pedantic Be pedantic on the zip tests. If this flag is enabled some more extensive tests on the zip integrity are done. These tests are generally not done by other zip utilities. -0, --shrink-store Disable the compression. The file is only stored and not compressed. This option is very useful to expand the archives of .png and .mp3 files. These files are already compressed, trying to compress them another time is really a waste of time and resource. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. Copyright This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima See Also advpng(1), advmng(1), advdef(1) advancecomp-1.23/doc/advzip.txt000066400000000000000000000074101301462770100165250ustar00rootroot00000000000000 =================================== AdvanceCOMP ZIP Compression Utility =================================== 1 SYNOPSIS ========== advzip [-a, --add] [-x, --extract] [-l, --list] [-z, --recompress] [-t, --test] [-0, --shrink-store] [-1, --shrink-fast] [-2, --shrink-normal] [-3, --shrink-extra] [-4, --shrink-insane] [-i, --iter N] [-k, --keep-file-time] [-p, --pedantic] [-q, --quiet] [-h, --help] [-V, --version] ARCHIVES... [FILES...] 2 DESCRIPTION ============= The main purpose of this utility is to recompress and test the zip archives to get the smallest possible size. For recompression the libdeflate implementation is used. This implementation generally gives 5-10% more compression than the zLib Deflate implementation, and it's also generally faster. For experimental purpose also the 7-Zip LZMA algorithm is available with the -N option. In this case, the generated zips WILL NOT BE USABLE by any other program. To make them usable you need to recompress them without the -N option. Generally this algorithm gives 10-20% more compression than the zLib Deflate implementation. 3 OPTIONS ========= -a, --add ARCHIVE FILES... Create the specified archive with the specified files. You must specify only one archive. -x, --extract ARCHIVE Extract all the files on the specified archive. You must specify only one archive. -l, --list ARCHIVES... List the content of the specified archives. -z, --recompress ARCHIVES... Recompress the specified archives. If the -1, -2, -3, -4 options are specified, it's used the smallest file choice from: the previous compressed data, the new compression and the uncompressed format. If the -0 option is specified the archive is always rewritten without any compression. -t, --test ARCHIVES... Test the specified archives. The tests may be extended with the -p option. -k, --keep-file-time When recompressing with -z keep the .zip file time. -p, --pedantic Be pedantic on the zip tests. If this flag is enabled some more extensive tests on the zip integrity are done. These tests are generally not done by other zip utilities. -0, --shrink-store Disable the compression. The file is only stored and not compressed. This option is very useful to expand the archives of .png and .mp3 files. These files are already compressed, trying to compress them another time is really a waste of time and resource. -1, --shrink-fast Set the compression level to "fast" using the zlib compressor. -2, --shrink-normal Set the compression level to "normal" using the libdeflate compressor. This is the default level of compression. -3, --shrink-extra Set the compression level to "extra" using the 7z compressor. You can define the compressor iterations with the -i, --iter option. -4, --shrink-insane Set the compression level to "insane" using the zopfli compressor. You can define the compressor iterations with the -i, --iter option. -i, --iter N Define an additional numer of iterations for the 7z and zopfli compressors for modes -3 and -4. More iterations usually give a better compression, but may require a lot more time. Try for example with 10, 15, 20, and so on. 4 COPYRIGHT =========== This file is Copyright (C) 2002 Andrea Mazzoleni, Filipe Estima 5 SEE ALSO ========== advpng(1), advmng(1), advdef(1) advancecomp-1.23/doc/authors.1000066400000000000000000000006041301462770100162340ustar00rootroot00000000000000.TH "AdvanceCOMP Authors" 1 .SH NAME authors \- AdvanceCOMP Authors .SH AUTHORS The author of AdvanceCOMP and releated utilities is Andrea Mazzoleni. .PP You can contact me sending an email at: .PP .RS 4 amadvance@gmail.com .RE .SH ACKNOWLEDGMENTS A lot of other people helped submitting patches, bug reports and generic comments. A special mention to: .PD 0 .IP \(bu Filipe Estima .PD advancecomp-1.23/doc/authors.d000066400000000000000000000005051301462770100163170ustar00rootroot00000000000000Name authors - AdvanceCOMP Authors Authors The author of AdvanceCOMP and releated utilities is Andrea Mazzoleni. You can contact me sending an email at: amadvance@gmail.com Acknowledgments A lot of other people helped submitting patches, bug reports and generic comments. A special mention to: * Filipe Estima advancecomp-1.23/doc/authors.txt000066400000000000000000000007451301462770100167210ustar00rootroot00000000000000 =================== AdvanceCOMP Authors =================== AUTHORS ======= The author of AdvanceCOMP and releated utilities is Andrea Mazzoleni. You can contact me sending an email at: amadvance@gmail.com ACKNOWLEDGMENTS =============== A lot of other people helped submitting patches, bug reports and generic comments. A special mention to: * Filipe Estima advancecomp-1.23/doc/copying.txt000066400000000000000000001057551301462770100167130ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . advancecomp-1.23/doc/history.1000066400000000000000000000143301301462770100162510ustar00rootroot00000000000000.TH "History For AdvanceCOMP" 1 .SH NAME advcomp \- History For AdvanceCOMP .SH ADVANCECOMP VERSION 1.23 2016/11 .PD 0 .IP \(bu Fixed build issue from source code due missing libdeflate header. .PD .SH ADVANCECOMP VERSION 1.22 2016/11 .PD 0 .IP \(bu Enabled again the command line wildcard expansion in the Windows builds. The new MingW compiler was disabling it by default. .PD .SH ADVANCECOMP VERSION 1.21 2016/11 .PD 0 .IP \(bu Added libdeflate support. It\'s the new default because it provides better performance and compression than 7z. From https://github.com/ebiggers/libdeflate at commit 28cc14994b8b57f590d31a7340c8fffc5cc37d88 .IP \(bu Update to te latest zopfli library. From https://github.com/google/zopfli at commit 6818a0859063b946094fb6f94732836404a0d89a. .IP \(bu Windows binaries built with MingW 4.9.3 using the MXE cross compiler at commit 62bcdbee56e87c81f1faa105b8777a5879d4e2e with targets i686\-w64\-mingw32 and x86_64\-w64\-mingw32. .IP \(bu DOS binaries built with DJGPP 4.8.5 from https://github.com/andrewwutw/build\-djgpp .PD .SH ADVANCECOMP VERSION 1.20 2015/08 .PD 0 .IP \(bu Fixed .gz recompression of data bigger than 400 MB. .IP \(bu Fixed .gz recompression with \-0 and \-1 options. .IP \(bu Updated to the latest zopfli [Aaron Kaluszka]. .IP \(bu Preserve the EFS flag in .zip files [Jason Penney]. .PD .SH ADVANCECOMP VERSION 1.19 2014/03 .PD 0 .IP \(bu Limited the iterations number to 255 with the \-3 option. .IP \(bu Added a new \-k, \-\-keep\-file\-time option to advzip [Marco Banfi]. .IP \(bu Made the Windows binary again compatible with old 686 processors. .PD .SH ADVANCECOMP VERSION 1.18 2013/11 .PD 0 .IP \(bu Added build support for new powerpc architectures. .IP \(bu Fixed build with BZIP. .PD .SH ADVANCECOMP VERSION 1.17 2013/03 .PD 0 .IP \(bu Changed to GPL3. .IP \(bu Added zopfli support. It\'s enabled using \-4, \-\-shrink\-insane. You can control the number of iterations with the new \-i, \-\-iter option. Thanks to Darik Horn for the patches. .PD .SH ADVANCECOMP VERSION 1.16 2013/03 .PD 0 .IP \(bu Allowed recompression with files with zero length. .IP \(bu Some other minor bugfixes. .IP \(bu Now in git repository. .PD .SH ADVANCECOMP VERSION 1.15 2005/10 .PD 0 .IP \(bu Fixed the date displayed with the \-l advzip command. .IP \(bu The advdef utility now detects the file type from the file header instead of using the extension. .IP \(bu Fixed a lot of bugs in the 64 bits platforms. .PD .SH ADVANCECOMP VERSION 1.14 2005/02 .PD 0 .IP \(bu Relaxed a consistency check for the local header in zip files. The crc and size entries are allowed to contain the real value also if a data descriptor is present. .IP \(bu Fixed the conversion of RGB images with less than 256 color with transparency data. .IP \(bu Minor fixes at the documentation. .PD .SH ADVANCECOMP VERSION 1.13 2004/11 .PD 0 .IP \(bu Added support for .svgz files at advdef [rener]. .IP \(bu Fixed the 8 bit color reduction of 32 bit png files. .PD .SH ADVANCECOMP VERSION 1.12 2004/09 .PD 0 .IP \(bu Fixed a compilation problem with gcc 3.4. .PD .SH ADVANCECOMP VERSION 1.11 2004/07 .PD 0 .IP \(bu Fixed a FreeBSD libc compatibility issue recompressing .gz files [Radim Kolar]. .IP \(bu Fixed a segmentation fault when some invalid compressed .zip files are tested. .PD .SH ADVANCECOMP VERSION 1.10 2004/04 .PD 0 .IP \(bu Added support for alpha channel and the new \-n option at advmng. .IP \(bu Fixed the uncompressing error \[dq]Invalid compressed data in ...\[dq] with some GZIP files [Christian Lestrade]. .PD .SH ADVANCECOMP VERSION 1.9 2003/11 .PD 0 .IP \(bu Added support for .tgz files at advdef. .IP \(bu Added the \-a option at advmng to create .mng files from a sequence of .png files. .PD .SH ADVANCECOMP VERSION 1.8 2003/10 .PD 0 .IP \(bu Added support for .gz files at advdef. .IP \(bu Fixed support for .png files with splitted IDATs. .PD .SH ADVANCECOMP VERSION 1.7 2003/08 .PD 0 .IP \(bu Fixed a Segmentation Fault bug on the advmng \-r option on the latest gcc. .IP \(bu Better and faster (MMX) move recognition in the advmng scroll compression. .IP \(bu The frame reduction of the advmng utility is now done only if possible. The compression process never fails. .IP \(bu Added a new \-S (\-\-scroll\-square) option at advmng. .IP \(bu Added a new \-v (\-\-verbose) option at advmng to show the compression status. .IP \(bu Changed the internal ID for the bzip2 and LZMA compression. The bzip2 ID is now compatible with the PKWARE specification. .IP \(bu Added support for RGB images with alpha channel at the advpng utility. .IP \(bu Updated with automake 1.7.6. .PD .SH ADVANCECOMP VERSION 1.6 2003/05 .PD 0 .IP \(bu Added the \`\-x\' option at the advmng utility to export .png files from a .mng clip. Useful to compress it in an MPEG file. .IP \(bu Fixed the support for zips with additional data descriptors. .IP \(bu Updated with autoconf 2.57 and automake 1.7.4. .IP \(bu Some fixes for the gcc 3.3 compiler. .PD .SH ADVANCECOMP VERSION 1.5 2003/01 .PD 0 .IP \(bu Splitted from AdvanceSCAN .IP \(bu Added the \`advdef\' compression utility. .PD .SH ADVANCESCAN VERSION 1.4 2002/12 .PD 0 .IP \(bu Fixed a bug in the advmng utility when it was called with more than one file in the command line. The program was incorrectly adding a PLTE chunk at rgb images. .PD .SH ADVANCESCAN VERSION 1.3 2002/11 .PD 0 .IP \(bu Added the support for the transparency tRNS chunk at the advpng utility. .IP \(bu Upgraded at the latest Advance Library. .IP \(bu Fixes at the docs. [Filipe Estima] .IP \(bu Minor changes at the autoconf/automake scripts. .PD .SH ADVANCESCAN VERSION 1.2 2002/08 .PD 0 .IP \(bu Added the advpng utility to compress the PNG files. .IP \(bu Added the advmng utility to compress the MNG files. .IP \(bu Added a Windows version. .IP \(bu Other minor fixes. .PD .SH ADVANCESCAN VERSION 1.1 2002/06 .PD 0 .IP \(bu Fixed an infinite loop bug testing some small damaged zips. .IP \(bu Removed some warning compiling with gcc 3.1. .PD .SH ADVANCESCAN VERSION 1.0 2002/05 .PD 0 .IP \(bu First public release. .IP \(bu Fixed the compression percentage computation on big files. .IP \(bu Added the \-\-pedantic option at the advzip utility. These tests are only done if requested. .PD .SH ADVANCESCAN VERSION 0.6\-BETA 2002/05 .PD 0 .IP \(bu Added the AdvanceZIP utility. .PD advancecomp-1.23/doc/history.d000066400000000000000000000127271301462770100163440ustar00rootroot00000000000000Name advcomp - History For AdvanceCOMP AdvanceCOMP Version 1.23 2016/11 ) Fixed build issue from source code due missing libdeflate header. AdvanceCOMP Version 1.22 2016/11 ) Enabled again the command line wildcard expansion in the Windows builds. The new MingW compiler was disabling it by default. AdvanceCOMP Version 1.21 2016/11 ) Added libdeflate support. It's the new default because it provides better performance and compression than 7z. From https://github.com/ebiggers/libdeflate at commit 28cc14994b8b57f590d31a7340c8fffc5cc37d88 ) Update to te latest zopfli library. From https://github.com/google/zopfli at commit 6818a0859063b946094fb6f94732836404a0d89a. ) Windows binaries built with MingW 4.9.3 using the MXE cross compiler at commit 62bcdbee56e87c81f1faa105b8777a5879d4e2e with targets i686-w64-mingw32 and x86_64-w64-mingw32. ) DOS binaries built with DJGPP 4.8.5 from https://github.com/andrewwutw/build-djgpp AdvanceCOMP Version 1.20 2015/08 ) Fixed .gz recompression of data bigger than 400 MB. ) Fixed .gz recompression with -0 and -1 options. ) Updated to the latest zopfli [Aaron Kaluszka]. ) Preserve the EFS flag in .zip files [Jason Penney]. AdvanceCOMP Version 1.19 2014/03 ) Limited the iterations number to 255 with the -3 option. ) Added a new -k, --keep-file-time option to advzip [Marco Banfi]. ) Made the Windows binary again compatible with old 686 processors. AdvanceCOMP Version 1.18 2013/11 ) Added build support for new powerpc architectures. ) Fixed build with BZIP. AdvanceCOMP Version 1.17 2013/03 ) Changed to GPL3. ) Added zopfli support. It's enabled using -4, --shrink-insane. You can control the number of iterations with the new -i, --iter option. Thanks to Darik Horn for the patches. AdvanceCOMP Version 1.16 2013/03 ) Allowed recompression with files with zero length. ) Some other minor bugfixes. ) Now in git repository. AdvanceCOMP Version 1.15 2005/10 ) Fixed the date displayed with the -l advzip command. ) The advdef utility now detects the file type from the file header instead of using the extension. ) Fixed a lot of bugs in the 64 bits platforms. AdvanceCOMP Version 1.14 2005/02 ) Relaxed a consistency check for the local header in zip files. The crc and size entries are allowed to contain the real value also if a data descriptor is present. ) Fixed the conversion of RGB images with less than 256 color with transparency data. ) Minor fixes at the documentation. AdvanceCOMP Version 1.13 2004/11 ) Added support for .svgz files at advdef [rener]. ) Fixed the 8 bit color reduction of 32 bit png files. AdvanceCOMP Version 1.12 2004/09 ) Fixed a compilation problem with gcc 3.4. AdvanceCOMP Version 1.11 2004/07 ) Fixed a FreeBSD libc compatibility issue recompressing .gz files [Radim Kolar]. ) Fixed a segmentation fault when some invalid compressed .zip files are tested. AdvanceCOMP Version 1.10 2004/04 ) Added support for alpha channel and the new -n option at advmng. ) Fixed the uncompressing error "Invalid compressed data in ..." with some GZIP files [Christian Lestrade]. AdvanceCOMP Version 1.9 2003/11 ) Added support for .tgz files at advdef. ) Added the -a option at advmng to create .mng files from a sequence of .png files. AdvanceCOMP Version 1.8 2003/10 ) Added support for .gz files at advdef. ) Fixed support for .png files with splitted IDATs. AdvanceCOMP Version 1.7 2003/08 ) Fixed a Segmentation Fault bug on the advmng -r option on the latest gcc. ) Better and faster (MMX) move recognition in the advmng scroll compression. ) The frame reduction of the advmng utility is now done only if possible. The compression process never fails. ) Added a new -S (--scroll-square) option at advmng. ) Added a new -v (--verbose) option at advmng to show the compression status. ) Changed the internal ID for the bzip2 and LZMA compression. The bzip2 ID is now compatible with the PKWARE specification. ) Added support for RGB images with alpha channel at the advpng utility. ) Updated with automake 1.7.6. AdvanceCOMP Version 1.6 2003/05 ) Added the `-x' option at the advmng utility to export .png files from a .mng clip. Useful to compress it in an MPEG file. ) Fixed the support for zips with additional data descriptors. ) Updated with autoconf 2.57 and automake 1.7.4. ) Some fixes for the gcc 3.3 compiler. AdvanceCOMP Version 1.5 2003/01 ) Splitted from AdvanceSCAN ) Added the `advdef' compression utility. AdvanceSCAN Version 1.4 2002/12 ) Fixed a bug in the advmng utility when it was called with more than one file in the command line. The program was incorrectly adding a PLTE chunk at rgb images. AdvanceSCAN Version 1.3 2002/11 ) Added the support for the transparency tRNS chunk at the advpng utility. ) Upgraded at the latest Advance Library. ) Fixes at the docs. [Filipe Estima] ) Minor changes at the autoconf/automake scripts. AdvanceSCAN Version 1.2 2002/08 ) Added the advpng utility to compress the PNG files. ) Added the advmng utility to compress the MNG files. ) Added a Windows version. ) Other minor fixes. AdvanceSCAN Version 1.1 2002/06 ) Fixed an infinite loop bug testing some small damaged zips. ) Removed some warning compiling with gcc 3.1. AdvanceSCAN Version 1.0 2002/05 ) First public release. ) Fixed the compression percentage computation on big files. ) Added the --pedantic option at the advzip utility. These tests are only done if requested. AdvanceSCAN Version 0.6-beta 2002/05 ) Added the AdvanceZIP utility. advancecomp-1.23/doc/history.txt000066400000000000000000000151171301462770100167340ustar00rootroot00000000000000 ======================= History For AdvanceCOMP ======================= ADVANCECOMP VERSION 1.23 2016/11 ================================ * Fixed build issue from source code due missing libdeflate header. ADVANCECOMP VERSION 1.22 2016/11 ================================ * Enabled again the command line wildcard expansion in the Windows builds. The new MingW compiler was disabling it by default. ADVANCECOMP VERSION 1.21 2016/11 ================================ * Added libdeflate support. It's the new default because it provides better performance and compression than 7z. From https://github.com/ebiggers/libdeflate at commit 28cc14994b8b57f590d31a7340c8fffc5cc37d88 * Update to te latest zopfli library. From https://github.com/google/zopfli at commit 6818a0859063b946094fb6f94732836404a0d89a. * Windows binaries built with MingW 4.9.3 using the MXE cross compiler at commit 62bcdbee56e87c81f1faa105b8777a5879d4e2e with targets i686-w64-mingw32 and x86_64-w64-mingw32. * DOS binaries built with DJGPP 4.8.5 from https://github.com/andrewwutw/build-djgpp ADVANCECOMP VERSION 1.20 2015/08 ================================ * Fixed .gz recompression of data bigger than 400 MB. * Fixed .gz recompression with -0 and -1 options. * Updated to the latest zopfli [Aaron Kaluszka]. * Preserve the EFS flag in .zip files [Jason Penney]. ADVANCECOMP VERSION 1.19 2014/03 ================================ * Limited the iterations number to 255 with the -3 option. * Added a new -k, --keep-file-time option to advzip [Marco Banfi]. * Made the Windows binary again compatible with old 686 processors. ADVANCECOMP VERSION 1.18 2013/11 ================================ * Added build support for new powerpc architectures. * Fixed build with BZIP. ADVANCECOMP VERSION 1.17 2013/03 ================================ * Changed to GPL3. * Added zopfli support. It's enabled using -4, --shrink-insane. You can control the number of iterations with the new -i, --iter option. Thanks to Darik Horn for the patches. ADVANCECOMP VERSION 1.16 2013/03 ================================ * Allowed recompression with files with zero length. * Some other minor bugfixes. * Now in git repository. ADVANCECOMP VERSION 1.15 2005/10 ================================ * Fixed the date displayed with the -l advzip command. * The advdef utility now detects the file type from the file header instead of using the extension. * Fixed a lot of bugs in the 64 bits platforms. ADVANCECOMP VERSION 1.14 2005/02 ================================ * Relaxed a consistency check for the local header in zip files. The crc and size entries are allowed to contain the real value also if a data descriptor is present. * Fixed the conversion of RGB images with less than 256 color with transparency data. * Minor fixes at the documentation. ADVANCECOMP VERSION 1.13 2004/11 ================================ * Added support for .svgz files at advdef [rener]. * Fixed the 8 bit color reduction of 32 bit png files. ADVANCECOMP VERSION 1.12 2004/09 ================================ * Fixed a compilation problem with gcc 3.4. ADVANCECOMP VERSION 1.11 2004/07 ================================ * Fixed a FreeBSD libc compatibility issue recompressing .gz files [Radim Kolar]. * Fixed a segmentation fault when some invalid compressed .zip files are tested. ADVANCECOMP VERSION 1.10 2004/04 ================================ * Added support for alpha channel and the new -n option at advmng. * Fixed the uncompressing error "Invalid compressed data in ..." with some GZIP files [Christian Lestrade]. ADVANCECOMP VERSION 1.9 2003/11 =============================== * Added support for .tgz files at advdef. * Added the -a option at advmng to create .mng files from a sequence of .png files. ADVANCECOMP VERSION 1.8 2003/10 =============================== * Added support for .gz files at advdef. * Fixed support for .png files with splitted IDATs. ADVANCECOMP VERSION 1.7 2003/08 =============================== * Fixed a Segmentation Fault bug on the advmng -r option on the latest gcc. * Better and faster (MMX) move recognition in the advmng scroll compression. * The frame reduction of the advmng utility is now done only if possible. The compression process never fails. * Added a new -S (--scroll-square) option at advmng. * Added a new -v (--verbose) option at advmng to show the compression status. * Changed the internal ID for the bzip2 and LZMA compression. The bzip2 ID is now compatible with the PKWARE specification. * Added support for RGB images with alpha channel at the advpng utility. * Updated with automake 1.7.6. ADVANCECOMP VERSION 1.6 2003/05 =============================== * Added the `-x' option at the advmng utility to export .png files from a .mng clip. Useful to compress it in an MPEG file. * Fixed the support for zips with additional data descriptors. * Updated with autoconf 2.57 and automake 1.7.4. * Some fixes for the gcc 3.3 compiler. ADVANCECOMP VERSION 1.5 2003/01 =============================== * Splitted from AdvanceSCAN * Added the `advdef' compression utility. ADVANCESCAN VERSION 1.4 2002/12 =============================== * Fixed a bug in the advmng utility when it was called with more than one file in the command line. The program was incorrectly adding a PLTE chunk at rgb images. ADVANCESCAN VERSION 1.3 2002/11 =============================== * Added the support for the transparency tRNS chunk at the advpng utility. * Upgraded at the latest Advance Library. * Fixes at the docs. [Filipe Estima] * Minor changes at the autoconf/automake scripts. ADVANCESCAN VERSION 1.2 2002/08 =============================== * Added the advpng utility to compress the PNG files. * Added the advmng utility to compress the MNG files. * Added a Windows version. * Other minor fixes. ADVANCESCAN VERSION 1.1 2002/06 =============================== * Fixed an infinite loop bug testing some small damaged zips. * Removed some warning compiling with gcc 3.1. ADVANCESCAN VERSION 1.0 2002/05 =============================== * First public release. * Fixed the compression percentage computation on big files. * Added the --pedantic option at the advzip utility. These tests are only done if requested. ADVANCESCAN VERSION 0.6-BETA 2002/05 ==================================== * Added the AdvanceZIP utility. advancecomp-1.23/doc/install.1000066400000000000000000000010001301462770100162040ustar00rootroot00000000000000.TH "AdvanceCOMP Installation" 1 .SH NAME advcomp \- AdvanceCOMP Installation .PP As root or user type: .PP .RS 4 ./configure .PD 0 .PP .PD make .PD 0 .PP .PD .RE .PP To check the generated executable type: .PP .RS 4 make check .PD 0 .PP .PD .RE .PP and as root to install the programs and the documentation type: .PP .RS 4 make install .PD 0 .PP .PD .RE .PP The documentation is in the man pages: .PP .RS 4 man advdef .PD 0 .PP .PD man advzip .PD 0 .PP .PD man advpng .PD 0 .PP .PD man advmng .PD 0 .PP .PD .RE advancecomp-1.23/doc/install.d000066400000000000000000000005111301462770100162750ustar00rootroot00000000000000Name advcomp - AdvanceCOMP Installation As root or user type: :./configure :make To check the generated executable type: :make check and as root to install the programs and the documentation type: :make install The documentation is in the man pages: :man advdef :man advzip :man advpng :man advmng advancecomp-1.23/doc/install.txt000066400000000000000000000007311301462770100166750ustar00rootroot00000000000000 ======================== AdvanceCOMP Installation ======================== As root or user type: ./configure make To check the generated executable type: make check and as root to install the programs and the documentation type: make install The documentation is in the man pages: man advdef man advzip man advpng man advmng advancecomp-1.23/doc/readme.1000066400000000000000000000012501301462770100160020ustar00rootroot00000000000000.TH "AdvanceCOMP Compression Utilities" 1 .SH NAME advcomp \- AdvanceCOMP Compression Utilities .PP AdvanceCOMP contains recompression utilities for your .zip archives, .png images, .mng video clips and .gz files. .PP It runs in Linux, Mac OS X, DOS, Windows and in all the other Unix like platforms. .PP The official site of AdvanceCOMP is: .PP .RS 4 http://www.advancemame.it .RE .PP This package contains: .RS 4 .PD 0 .HP 4 .I advzip Recompression and test utility for zip files .HP 4 .I advpng Recompression utility for png files .HP 4 .I advmng Recompression utility for mng files .HP 4 .I advdef Recompression utility for deflate streams in .png, .mng and .gz files .PD .RE advancecomp-1.23/doc/readme.d000066400000000000000000000011021301462770100160610ustar00rootroot00000000000000Name advcomp - AdvanceCOMP Compression Utilities AdvanceCOMP contains recompression utilities for your .zip archives, .png images, .mng video clips and .gz files. It runs in Linux, Mac OS X, DOS, Windows and in all the other Unix like platforms. The official site of AdvanceCOMP is: http://www.advancemame.it This package contains: advzip - Recompression and test utility for zip files advpng - Recompression utility for png files advmng - Recompression utility for mng files advdef - Recompression utility for deflate streams in .png, .mng and .gz files advancecomp-1.23/doc/readme.txt000066400000000000000000000013211301462770100164600ustar00rootroot00000000000000 ================================= AdvanceCOMP Compression Utilities ================================= AdvanceCOMP contains recompression utilities for your .zip archives, .png images, .mng video clips and .gz files. It runs in Linux, Mac OS X, DOS, Windows and in all the other Unix like platforms. The official site of AdvanceCOMP is: http://www.advancemame.it This package contains: advzip - Recompression and test utility for zip files advpng - Recompression utility for png files advmng - Recompression utility for mng files advdef - Recompression utility for deflate streams in .png, .mng and .gz files advancecomp-1.23/except.h000066400000000000000000000053371301462770100153710ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __EXCEPT_H #define __EXCEPT_H #include #include #include #include class error { std::string function; std::string file; unsigned line; std::string desc; public: error() : line(0) { } error(const char* Afunction, const char* Afile, unsigned Aline) : function(Afunction), file(Afile), line(Aline) { } const std::string& desc_get() const { return desc; } const std::string& function_get() const { return function; } const std::string& file_get() const { return file; } unsigned line_get() const { return line; } error& operator<<(const char* A) { desc += A; return *this; } error& operator<<(const std::string& A) { desc += A; return *this; } error& operator<<(const unsigned A) { std::ostringstream s; s << A /* << " (" << std::hex << A << "h)" */ ; desc += s.str(); return *this; } }; class error_invalid : public error { public: error_invalid() : error() { } error_invalid& operator<<(const char* A) { error::operator<<(A); return *this; } error_invalid& operator<<(const std::string& A) { error::operator<<(A); return *this; } error_invalid& operator<<(const unsigned A) { error::operator<<(A); return *this; } }; class error_unsupported : public error { public: error_unsupported() : error() { } error_unsupported& operator<<(const char* A) { error::operator<<(A); return *this; } error_unsupported& operator<<(const std::string& A) { error::operator<<(A); return *this; } error_unsupported& operator<<(const unsigned A) { error::operator<<(A); return *this; } }; #define error() \ error(__PRETTY_FUNCTION__, __FILE__, __LINE__) static inline std::ostream& operator<<(std::ostream& os, const error& e) { os << e.desc_get(); if (e.function_get().length() || e.file_get().length() || e.line_get()) os << " [at " << e.function_get() << ":" << e.file_get() << ":" << e.line_get() << "]"; return os; } #endif advancecomp-1.23/file.cc000066400000000000000000000174721301462770100151610ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2004, 2005 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "file.h" #include using namespace std; crc_t crc_compute(const char* data, unsigned len) { return crc32(0, (unsigned char*)data, len); } crc_t crc_compute(crc_t pred, const char* data, unsigned len) { return crc32(pred, (unsigned char*)data, len); } filepath::filepath() { } filepath::filepath(const filepath& A) : file(A.file) { } filepath::filepath(const string& Afile) : file(Afile) { } filepath::~filepath() { } void filepath::file_set(const string& Afile) { file = Afile; } infopath::infopath() { readonly = true; good = false; size = 0; } infopath::infopath(const infopath& A) : filepath(A), good(A.good), size(A.size), readonly(A.readonly) { } infopath::infopath(const string& Afile, bool Agood, unsigned Asize, bool Areadonly) : filepath(Afile), good(Agood), size(Asize), readonly(Areadonly) { } infopath::~infopath() { } void infopath::good_set(bool Agood) { good = Agood; } void infopath::size_set(unsigned Asize) { size = Asize; } void infopath::readonly_set(bool Areadonly) { readonly = Areadonly; } /** * Check if a file exists. */ bool file_exists(const string& path) throw (error) { struct stat s; if (stat(path.c_str(), &s) != 0) { if (errno!=ENOENT) throw error() << "Failed stat file " << path; return false; } return !S_ISDIR(s.st_mode); } /** * Write a whole file. */ void file_write(const string& path, const char* data, unsigned size) throw (error) { FILE* f = fopen(path.c_str(), "wb"); if (!f) throw error() << "Failed open for write file " << path; if (fwrite(data, size, 1, f)!=1) { fclose(f); remove(path.c_str()); throw error() << "Failed write file " << path; } fclose(f); } /** * Read a whole file. */ void file_read(const string& path, char* data, unsigned size) throw (error) { file_read(path, data, 0, size); } /** * Read a whole file. */ void file_read(const string& path, char* data, unsigned offset, unsigned size) throw (error) { FILE* f = fopen(path.c_str(), "rb"); if (!f) throw error() << "Failed open for read file " << path; if (fseek(f, offset, SEEK_SET)!=0) { fclose(f); throw error() << "Failed seek file " << path; } if (fread(data, size, 1, f)!=1) { fclose(f); throw error() << "Failed read file " << path; } fclose(f); } /** * Get the time of a file. */ time_t file_time(const string& path) throw (error) { struct stat s; if (stat(path.c_str(), &s)!=0) throw error() << "Failed stat file " << path; return s.st_mtime; } /** * Set the time of a file. */ void file_utime(const string& path, time_t tod) throw (error) { struct utimbuf u; u.actime = tod; u.modtime = tod; if (utime(path.c_str(), &u) != 0) throw error() << "Failed utime file " << path; } /** * Get the size of a file. */ unsigned file_size(const string& path) throw (error) { struct stat s; if (stat(path.c_str(), &s)!=0) throw error() << "Failed stat file " << path; return s.st_size; } /** * Get the crc of a file. */ crc_t file_crc(const string& path) throw (error) { unsigned size = file_size(path); char* data = (char*)operator new(size); try { file_read(path, data, size); } catch (...) { operator delete(data); throw; } crc_t crc = crc_compute(data, size); operator delete(data); return crc; } /** * Copy a file. */ void file_copy(const string& path1, const string& path2) throw (error) { unsigned size; size = file_size(path1); char* data = (char*)operator new(size); try { file_read(path1, data, size); file_write(path2, data, size); } catch (...) { operator delete(data); throw; } operator delete(data); } /** * Move a file. */ void file_move(const string& path1, const string& path2) throw (error) { if (rename(path1.c_str(), path2.c_str())!=0 && errno==EXDEV) { try { file_copy(path1, path2); } catch (...) { try { file_remove(path2); } catch (...) { } throw error() << "Failed move of " << path1 << " to " << path2; } file_remove(path1); } } /** * Remove a file. */ void file_remove(const string& path1) throw (error) { if (remove(path1.c_str())!=0) { throw error() << "Failed remove of " << path1; } } /** * Rename a file. */ void file_rename(const string& path1, const string& path2) throw (error) { if (rename(path1.c_str(), path2.c_str())!=0) { throw error() << "Failed rename of " << path1 << " to " << path2; } } /** * Randomize a name file. */ string file_randomize(const string& path, int n) throw () { ostringstream os; size_t pos = path.rfind('.'); if (pos == string::npos) os << path << "."; else os << string(path, 0, pos+1); os << n << ends; return os.str(); } string file_temp(const string& path) throw () { ostringstream os; os << path << ".tmp" << time(0) << ends; return os.str(); } /** * Get the directory from a path. */ string file_dir(const string& path) throw () { size_t pos = path.rfind('/'); if (pos == string::npos) { return ""; } else { return string(path, 0, pos+1); } } /** * Get the file name from a path. */ string file_name(const string& path) throw () { size_t pos = path.rfind('/'); if (pos == string::npos) { return path; } else { return string(path, pos+1); } } /** * Get the basepath (path without extension) from a path. */ string file_basepath(const string& path) throw () { size_t dot = path.rfind('.'); if (dot == string::npos) return path; else return string(path, 0, dot); } /** * Get the basename (name without extension) from a path. */ string file_basename(const string& path) throw () { string name = file_name(path); size_t dot = name.rfind('.'); if (dot == string::npos) return name; else return string(name, 0, dot); } /** * Get the extension from a path. */ string file_ext(const string& path) throw () { string name = file_name(path); size_t dot = name.rfind('.'); if (dot == string::npos) return ""; else return string(name, dot); } /** * Compare two path. */ int file_compare(const string& path1, const string& path2) throw () { return strcasecmp(path1.c_str(), path2.c_str()); } /** * Convert a path to the C format. */ string file_adjust(const string& path) throw () { string r; for(unsigned i=0;i #include class filepath { std::string file; public: filepath(); filepath(const filepath& A); filepath(const std::string& Afile); ~filepath(); const std::string& file_get() const { return file; } void file_set(const std::string& Afile); }; typedef std::list filepath_container; class infopath : public filepath { bool good; unsigned size; bool readonly; public: infopath(); infopath(const infopath& A); infopath(const std::string& Afile, bool Agood, unsigned Asize, bool Areadonly); ~infopath(); bool good_get() const { return good; } void good_set(bool Agood); unsigned size_get() const { return size; } void size_set(unsigned Asize); bool readonly_get() const { return readonly; } void readonly_set(bool Areadonly); }; typedef std::list zippath_container; typedef unsigned crc_t; crc_t crc_compute(const char* data, unsigned len); crc_t crc_compute(crc_t pred, const char* data, unsigned len); bool file_exists(const std::string& file) throw (error); void file_write(const std::string& path, const char* data, unsigned size) throw (error); void file_read(const std::string& path, char* data, unsigned size) throw (error); void file_read(const std::string& path, char* data, unsigned offset, unsigned size) throw (error); time_t file_time(const std::string& path) throw (error); void file_utime(const std::string& path, time_t tod) throw (error); unsigned file_size(const std::string& path) throw (error); crc_t file_crc(const std::string& path) throw (error); void file_copy(const std::string& path1, const std::string& path2) throw (error); void file_move(const std::string& path1, const std::string& path2) throw (error); void file_remove(const std::string& path1) throw (error); void file_mktree(const std::string& path1) throw (error); std::string file_temp(const std::string& path) throw (); std::string file_randomize(const std::string& path, int n) throw (); std::string file_name(const std::string& file) throw (); std::string file_dir(const std::string& file) throw (); std::string file_basename(const std::string& file) throw (); std::string file_basepath(const std::string& file) throw (); std::string file_ext(const std::string& file) throw (); int file_compare(const std::string& path1, const std::string& path2) throw (); std::string file_adjust(const std::string& path) throw (); #endif advancecomp-1.23/getopt.c000066400000000000000000000055301301462770100153710ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2001, 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #if HAVE_CONFIG_H #include #endif /* Enable automatic command line wildcard expandion in mingw-w64 */ /* See: https://github.com/Alexpux/mingw-w64/blob/master/mingw-w64-crt/crt/wildcard.c */ #ifdef __MINGW32__ int _dowildcard = -1; #endif #if !HAVE_GETOPT /* This source is extracted from the DJGPP LIBC library */ #define unconst(var, type) ((type)(var)) /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */ #include #include int opterr = 1, optind = 1, optopt = 0; char *optarg = 0; #define BADCH (int)'?' #define EMSG "" int getopt(int nargc, char *const nargv[], const char *ostr) { static const char *place = EMSG; /* option letter processing */ char *oli; /* option letter list index */ char *p; if (!*place) { if (optind >= nargc || *(place = nargv[optind]) != '-') { place = EMSG; return(EOF); } if (place[1] && *++place == '-') { ++optind; place = EMSG; return(EOF); } } if ((optopt = (int)*place++) == (int)':' || !(oli = strchr(ostr, optopt))) { /* * if the user didn't specify '-' as an option, * assume it means EOF. */ if (optopt == (int)'-') return EOF; if (!*place) ++optind; if (opterr) { if (!(p = strrchr(*nargv, '/'))) p = *nargv; else ++p; fprintf(stderr, "%s: illegal option -- %c\n", p, optopt); } return BADCH; } if (*++oli != ':') { /* don't need argument */ optarg = NULL; if (!*place) ++optind; } else { /* need an argument */ if (*place) /* no white space */ optarg = unconst(place, char *); else if (nargc <= ++optind) { /* no arg */ place = EMSG; if (!(p = strrchr(*nargv, '/'))) p = *nargv; else ++p; if (opterr) fprintf(stderr, "%s: option requires an argument -- %c\n", p, optopt); return BADCH; } else /* white space */ optarg = nargv[optind]; place = EMSG; ++optind; } return optopt; /* dump back option letter */ } #endif advancecomp-1.23/lib/000077500000000000000000000000001301462770100144665ustar00rootroot00000000000000advancecomp-1.23/lib/endianrw.h000066400000000000000000000152771301462770100164620ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /** \file * Endinaess. */ /** \addtogroup Endian */ /*@{*/ #ifndef __ENDIANRW_H #define __ENDIANRW_H #include "extra.h" /***************************************************************************/ /* Endian */ /** \name Make * Make a value in the CPU format from a set of nibble. * The nibbles are from the value at lower address to the value at higher address. * Note that the values are not masked, if the input values are in overflow the * output may be wrong. */ /*@{*/ static inline unsigned cpu_uint8_make_uint8(unsigned v0) { return v0; } static inline unsigned cpu_uint32_make_uint32(unsigned v0) { return v0; } static inline unsigned cpu_uint16_make_uint16(unsigned v0) { return v0; } static inline unsigned cpu_uint16_make_uint8(unsigned v0, unsigned v1) { #ifdef USE_MSB return v1 | v0 << 8; #else return v0 | v1 << 8; #endif } static inline unsigned cpu_uint32_make_uint16(unsigned v0, unsigned v1) { #ifdef USE_MSB return v1 | v0 << 16; #else return v0 | v1 << 16; #endif } static inline unsigned cpu_uint32_make_uint8(unsigned v0, unsigned v1, unsigned v2, unsigned v3) { #ifdef USE_MSB return v3 | v2 << 8 | v1 << 16 | v0 << 24; #else return v0 | v1 << 8 | v2 << 16 | v3 << 24; #endif } /*@}*/ /** \name Read * Read a value in the Little or Big endian format. */ /*@{*/ static inline unsigned le_uint8_read(const void* ptr) { return *(const unsigned char*)ptr; } static inline unsigned be_uint8_read(const void* ptr) { return *(const unsigned char*)ptr; } static inline unsigned cpu_uint8_read(const void* ptr) { return *(const unsigned char*)ptr; } static inline unsigned cpu_uint16_read(const void* ptr) { return *(const uint16*)ptr; } static inline unsigned le_uint16_read(const void* ptr) { #ifdef USE_LSB return cpu_uint16_read(ptr); #else const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[0] | (unsigned)ptr8[1] << 8; #endif } static inline unsigned be_uint16_read(const void* ptr) { #ifdef USE_MSB return cpu_uint16_read(ptr); #else const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[1] | (unsigned)ptr8[0] << 8; #endif } static inline unsigned le_uint24_read(const void* ptr) { const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[0] | (unsigned)ptr8[1] << 8 | (unsigned)ptr8[2] << 16; } static inline unsigned be_uint24_read(const void* ptr) { const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[2] | (unsigned)ptr8[1] << 8 | (unsigned)ptr8[0] << 16; } static inline unsigned cpu_uint24_read(const void* ptr) { #ifdef USE_LSB return le_uint24_read(ptr); #else return be_uint24_read(ptr); #endif } static inline unsigned cpu_uint32_read(const void* ptr) { return *(const uint32*)ptr; } static inline unsigned le_uint32_read(const void* ptr) { #ifdef USE_LSB return cpu_uint32_read(ptr); #else const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[0] | (unsigned)ptr8[1] << 8 | (unsigned)ptr8[2] << 16 | (unsigned)ptr8[3] << 24; #endif } static inline unsigned be_uint32_read(const void* ptr) { #ifdef USE_MSB return cpu_uint32_read(ptr); #else const unsigned char* ptr8 = (const unsigned char*)ptr; return (unsigned)ptr8[3] | (unsigned)ptr8[2] << 8 | (unsigned)ptr8[1] << 16 | (unsigned)ptr8[0] << 24; #endif } /*@}*/ /** \name Write * Write a value in the Little or Big endian format. */ /*@{*/ static inline void cpu_uint8_write(void* ptr, unsigned v) { unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v; } static inline void le_uint8_write(void* ptr, unsigned v) { unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v; } static inline void be_uint8_write(void* ptr, unsigned v) { unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v; } static inline void cpu_uint16_write(void* ptr, unsigned v) { uint16* ptr16 = (uint16*)ptr; ptr16[0] = v; } static inline void le_uint16_write(void* ptr, unsigned v) { #ifdef USE_LSB cpu_uint16_write(ptr, v); #else unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v & 0xFF; ptr8[1] = (v >> 8) & 0xFF; #endif } static inline void be_uint16_write(void* ptr, unsigned v) { #ifdef USE_MSB cpu_uint16_write(ptr, v); #else unsigned char* ptr8 = (unsigned char*)ptr; ptr8[1] = v & 0xFF; ptr8[0] = (v >> 8) & 0xFF; #endif } static inline void le_uint24_write(void* ptr, unsigned v) { unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v & 0xFF; ptr8[1] = (v >> 8) & 0xFF; ptr8[2] = (v >> 16) & 0xFF; } static inline void be_uint24_write(void* ptr, unsigned v) { unsigned char* ptr8 = (unsigned char*)ptr; ptr8[2] = v & 0xFF; ptr8[1] = (v >> 8) & 0xFF; ptr8[0] = (v >> 16) & 0xFF; } static inline void cpu_uint24_write(void* ptr, unsigned v) { #ifdef USE_LSB le_uint24_write(ptr, v); #else be_uint24_write(ptr, v); #endif } static inline void cpu_uint32_write(void* ptr, unsigned v) { uint32* ptr32 = (uint32*)ptr; ptr32[0] = v; } static inline void le_uint32_write(void* ptr, unsigned v) { #ifdef USE_LSB cpu_uint32_write(ptr, v); #else unsigned char* ptr8 = (unsigned char*)ptr; ptr8[0] = v & 0xFF; ptr8[1] = (v >> 8) & 0xFF; ptr8[2] = (v >> 16) & 0xFF; ptr8[3] = (v >> 24) & 0xFF; #endif } static inline void be_uint32_write(void* ptr, unsigned v) { #ifdef USE_MSB cpu_uint32_write(ptr, v); #else unsigned char* ptr8 = (unsigned char*)ptr; ptr8[3] = v & 0xFF; ptr8[2] = (v >> 8) & 0xFF; ptr8[1] = (v >> 16) & 0xFF; ptr8[0] = (v >> 24) & 0xFF; #endif } static inline unsigned cpu_uint_read(const void* ptr, unsigned size) { switch (size) { default: case 1 : return cpu_uint8_read(ptr); case 2 : return cpu_uint16_read(ptr); case 3 : return cpu_uint24_read(ptr); case 4 : return cpu_uint32_read(ptr); } } static inline void cpu_uint_write(void* ptr, unsigned size, unsigned v) { switch (size) { default: case 1 : cpu_uint8_write(ptr, v); break; case 2 : cpu_uint16_write(ptr, v); break; case 3 : cpu_uint24_write(ptr, v); break; case 4 : cpu_uint32_write(ptr, v); break; } } /*@}*/ #endif /*@}*/ advancecomp-1.23/lib/error.c000066400000000000000000000121131301462770100157610ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ #include "portable.h" #include "extra.h" #ifndef USE_ERROR_SILENT #include "log.h" #endif #include "error.h" #include "snstring.h" /****************************************************************************/ /* Error */ /** * Max length of the error description. */ #define ERROR_DESC_MAX 2048 /** * Last error description. */ static char error_desc_buffer[ERROR_DESC_MAX]; /** * Flag set if an unsupported feature is found. */ static adv_bool error_unsupported_flag; /** * Flag for cat mode. */ static adv_bool error_cat_flag; /** * Prefix for cat mode. */ static char error_cat_prefix_buffer[ERROR_DESC_MAX]; /** * Set the error cat mode. * If enabled the error text is appended at the end of the previous error. */ void error_cat_set(const char* prefix, adv_bool mode) { if (prefix) sncpy(error_cat_prefix_buffer, sizeof(error_cat_prefix_buffer), prefix); else error_cat_prefix_buffer[0] = 0; error_cat_flag = mode; } /** * Get the current error description. */ const char* error_get(void) { /* remove the trailing \n */ while (error_desc_buffer[0] && isspace(error_desc_buffer[strlen(error_desc_buffer)-1])) error_desc_buffer[strlen(error_desc_buffer)-1] = 0; return error_desc_buffer; } /** * Reset the description of the last error. */ void error_reset(void) { error_unsupported_flag = 0; error_desc_buffer[0] = 0; } /** * Set the description of the last error. * The previous description is overwritten. * \note The description IS logged. */ void error_set(const char* text, ...) { va_list arg; char* p; unsigned size; error_unsupported_flag = 0; if (error_cat_flag) { if (error_cat_prefix_buffer[0]) { sncat(error_desc_buffer, sizeof(error_desc_buffer), error_cat_prefix_buffer); sncat(error_desc_buffer, sizeof(error_desc_buffer), ": "); } p = error_desc_buffer + strlen(error_desc_buffer); size = sizeof(error_desc_buffer) - strlen(error_desc_buffer); } else { p = error_desc_buffer; size = sizeof(error_desc_buffer); } va_start(arg, text); vsnprintf(p, size, text, arg); #ifndef USE_ERROR_SILENT log_std(("advance:msg:")); if (error_cat_flag && error_cat_prefix_buffer[0]) { log_std(("%s:", error_cat_prefix_buffer)); } log_std((" ")); log_va(text, arg); if (!text[0] || text[strlen(text)-1] != '\n') log_std(("\n")); #endif va_end(arg); } /** * Set the description of the last error due unsupported feature. * \note The description IS logged. */ void error_unsupported_set(const char* text, ...) { va_list arg; error_unsupported_flag = 1; va_start(arg, text); vsnprintf(error_desc_buffer, sizeof(error_desc_buffer), text, arg); #ifndef USE_ERROR_SILENT log_std(("advance: set_error_description \"")); log_va(text, arg); log_std(("\"\n")); #endif va_end(arg); } /** * Check if a unsupported feature is found. * This function can be called only if another function returns with error. * \return * - ==0 Not found. * - !=0 Unsupported feature found. */ adv_bool error_unsupported_get(void) { return error_unsupported_flag; } #ifndef USE_ERROR_SILENT /** * Set the error description. * The previous description is overwritten. * The description is not logged. */ void error_nolog_set(const char* text, ...) { va_list arg; char* p; unsigned size; error_unsupported_flag = 0; if (error_cat_flag) { if (error_cat_prefix_buffer[0]) { sncat(error_desc_buffer, sizeof(error_desc_buffer), error_cat_prefix_buffer); sncat(error_desc_buffer, sizeof(error_desc_buffer), ": "); } p = error_desc_buffer + strlen(error_desc_buffer); size = sizeof(error_desc_buffer) - strlen(error_desc_buffer); } else { p = error_desc_buffer; size = sizeof(error_desc_buffer); } va_start(arg, text); vsnprintf(p, size, text, arg); va_end(arg); } #endif advancecomp-1.23/lib/error.h000066400000000000000000000042021301462770100157660ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ /** \file * Error reporting functions. * If defined USE_ERROR_SILENT the error functions don't show the error in the log. * This macro can be used to reduce the dependencies of the library. */ #ifndef __ERROR_H #define __ERROR_H #include "extra.h" #ifdef __cplusplus extern "C" { #endif /** \addtogroup Error */ /*@{*/ const char* error_get(void); adv_bool error_unsupported_get(void); void error_cat_set(const char* prefix, adv_bool mode); void error_reset(void); void error_set(const char* error, ...) __attribute__((format(printf, 1, 2))); void error_unsupported_set(const char* error, ...) __attribute__((format(printf, 1, 2))); void error_nolog_set(const char* error, ...) __attribute__((format(printf, 1, 2))); /*@}*/ #ifdef __cplusplus } #endif #endif advancecomp-1.23/lib/extra.h000066400000000000000000000056101301462770100157640ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ /** \file * Extra types. */ #ifndef __EXTRA_H #define __EXTRA_H #ifdef __cplusplus extern "C" { #endif /***************************************************************************/ /* Types */ /** \addtogroup Type */ /*@{*/ /** * Type used to check the result of operation. * - ==0 is ok * - <0 is not ok * - >0 special conditions */ typedef int adv_error; /** * Type used to check the result of a adv_bool operation. * - ==0 false * - !=0 true */ typedef int adv_bool; typedef unsigned char uint8; /**< Unsigned 8 bit integer. */ typedef signed char int8; /**< Signed 8 bit integer. */ typedef unsigned short uint16; /**< Unsigned 16 bit integer. */ typedef signed short int16; /**< Signed 16 bit integer. */ typedef unsigned int uint32; /**< Unsigned 32 bit integer. */ typedef signed int int32; /**< Signed 32 bit integer. */ typedef unsigned long long int uint64; /**< Unsigned 64 bit integer. */ typedef signed long long int int64; /**< Signed 64 bit integer. */ /** \name Align * Alignment. */ /*@{*/ #define ALIGN_BIT 3 /**< Number of bit of alignment required. */ #define ALIGN (1U << ALIGN_BIT) /**< Alignment multiplicator. */ #define ALIGN_MASK (ALIGN - 1U) /**< Alignment mask. */ /** * Align a unsigned interger at the specified byte size. */ #define ALIGN_UNSIGNED(v, a) (((v) + ((a)-1)) & ~((a)-1)) /** * Align a void pointer at the specified byte size. */ #define ALIGN_PTR(v, a) (void*)ALIGN_UNSIGNED((unsigned char*)(v) - (unsigned char*)0, a) /*@}*/ /*@}*/ #ifdef __cplusplus } #endif #endif advancecomp-1.23/lib/fz.c000066400000000000000000000347231301462770100152620ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ #include "portable.h" #include "fz.h" #include "endianrw.h" /* Zip format */ #define ZIP_LO_filename_length 0x1A #define ZIP_LO_extra_field_length 0x1C #define ZIP_LO_FIXED 0x1E /* size of fixed data structure */ /**************************************************************************/ /* unlocked interface for streams (faster than locked) */ static FILE* fopen_lock(const char* name, const char* mode) { FILE* f; f = fopen(name, mode); #if HAVE_FLOCKFILE if (f) flockfile(f); #endif return f; } static int fclose_lock(FILE *f) { #if HAVE_FUNLOCKFILE funlockfile(f); #endif return fclose(f); } static size_t fread_lock(void* data, size_t size, size_t count, FILE* f) { #if HAVE_FREAD_UNLOCKED return fread_unlocked(data, size, count, f); #else return fread(data, size, count, f); #endif } static size_t fwrite_lock(const void* data, size_t size, size_t count, FILE* f) { #if HAVE_FWRITE_UNLOCKED return fwrite_unlocked(data, size, count, f); #else return fwrite(data, size, count, f); #endif } static int feof_lock(FILE* f) { #if HAVE_FEOF_UNLOCKED return feof_unlocked(f); #else return feof(f); #endif } static int fgetc_lock(FILE* f) { #if HAVE_FGETC_UNLOCKED return fgetc_unlocked(f); #else return fgetc(f); #endif } /**************************************************************************/ /* fz interface */ #define INFLATE_INPUT_BUFFER_MAX 4096 adv_error fzgrow(adv_fz* f, unsigned size) { if (f->type == fz_memory_write) { if (f->virtual_size < size) { unsigned char* data = realloc(f->data_write, size); if (!data) return -1; f->data_write = data; f->virtual_size = size; } return 0; } else { return -1; } } /** * Read from a file. * The semantic is like the C fread() function. */ unsigned fzread(void *buffer, unsigned size, unsigned number, adv_fz* f) { if (f->type == fz_file) { return fread_lock(buffer, size, number, f->f); } else { unsigned total_size; /* adjust the number of record to read */ total_size = size * number; if (f->virtual_pos + total_size >= f->virtual_size) { number = (f->virtual_size - f->virtual_pos) / size; if (!number) return 0; total_size = size * number; } if (f->type == fz_memory_read) { memcpy(buffer, f->data_read + f->virtual_pos, total_size); f->virtual_pos += total_size; return number; } else if (f->type == fz_memory_write) { memcpy(buffer, f->data_write + f->virtual_pos, total_size); f->virtual_pos += total_size; return number; } else if (f->type == fz_file_compressed) { int err = Z_STREAM_END; f->z.next_out = buffer; f->z.avail_out = total_size; while (f->z.avail_out) { if (!f->z.avail_in) { unsigned run = INFLATE_INPUT_BUFFER_MAX; if (run > f->remaining) run = f->remaining; f->z.next_in = f->zbuffer; run = fread_lock(f->zbuffer, 1, run, f->f); f->remaining -= run; /* add an extra byte at the end, required by the zlib library */ if (run && !f->remaining) ++run; f->z.avail_in = run; } if (!f->z.avail_in) break; err = inflate(&f->z, Z_NO_FLUSH); if (err != Z_OK) break; } total_size -= f->z.avail_out; f->virtual_pos += total_size; return total_size / size; } } return 0; } /** * Write to a file. * This function works only for files opened with fzopen(). * The semantic is like the C fwrite() function. */ unsigned fzwrite(const void *buffer, unsigned size, unsigned number, adv_fz* f) { if (f->type == fz_file) { return fwrite_lock(buffer, size, number, f->f); } else if (f->type == fz_memory_write) { unsigned total_size; /* adjust the number of record to write */ total_size = size * number; if (fzgrow(f, f->virtual_pos + total_size) != 0) return -1; memcpy(f->data_write + f->virtual_pos, buffer, total_size); f->virtual_pos += total_size; return number; } else { return -1; } } static adv_fz* fzalloc(void) { adv_fz* f; f = malloc(sizeof(adv_fz)); if (!f) return 0; f->type = fz_invalid; f->virtual_pos = 0; f->virtual_size = 0; f->real_offset = 0; f->real_size = 0; f->data_read = 0; f->data_write = 0; f->f = 0; return f; } /** * Open a normal file. * The semantic is like the C fopen() function. */ adv_fz* fzopen(const char* file, const char* mode) { adv_fz* f = fzalloc(); if (!f) return 0; f->type = fz_file; f->f = fopen_lock(file, mode); if (!f->f) { free(f); return 0; } return f; } /** * Open a normal file doing all the write access in memory. * The semantic is like the C fopen() function. */ adv_fz* fzopennullwrite(const char* file, const char* mode) { adv_fz* f = fzalloc(); if (!f) goto err; f->type = fz_memory_write; f->virtual_pos = 0; f->f = fopen_lock(file, "rb"); if (f->f) { struct stat st; if (fstat(fileno(f->f), &st) != 0) { goto err_close; } f->data_write = malloc(st.st_size); if (!f->data_write) { goto err_close; } f->virtual_size = st.st_size; if (fread_lock(f->data_write, st.st_size, 1, f->f) != 1) { goto err_data; } fclose_lock(f->f); f->f = 0; } else { if (strchr(mode, 'w')!=0 || strchr(mode, 'a')!=0) { /* creation allowed */ f->data_write = 0; f->virtual_size = 0; } else { /* creation not possible */ goto err_free; } } return f; err_data: free(f->data_write); err_close: fclose_lock(f->f); err_free: free(f); err: return 0; } /** * Open an uncompressed file part of a ZIP archive. * \param file ZIP archive. * \param offset Offset in the archive. * \param size Size of the data. */ adv_fz* fzopenzipuncompressed(const char* file, unsigned offset, unsigned size) { unsigned char buf[ZIP_LO_FIXED]; unsigned filename_length; unsigned extra_field_length; adv_fz* f = fzalloc(); if (!f) return 0; f->type = fz_file; f->virtual_pos = 0; f->virtual_size = size; f->f = fopen_lock(file, "rb"); if (!f->f) { free(f); return 0; } if (fseek(f->f, offset, SEEK_SET) != 0) { fclose_lock(f->f); free(f); return 0; } if (fread_lock(buf, ZIP_LO_FIXED, 1, f->f)!=1) { fclose_lock(f->f); free(f); return 0; } filename_length = le_uint16_read(buf+ZIP_LO_filename_length); extra_field_length = le_uint16_read(buf+ZIP_LO_extra_field_length); /* calculate offset to data and seek there */ offset += ZIP_LO_FIXED + filename_length + extra_field_length; f->real_offset = offset; f->real_size = size; if (fseek(f->f, f->real_offset, SEEK_SET) != 0) { fclose_lock(f->f); free(f); return 0; } return f; } static void compressed_init(adv_fz* f) { int err; memset(&f->z, 0, sizeof(f->z)); f->z.zalloc = 0; f->z.zfree = 0; f->z.opaque = 0; f->z.next_in = 0; f->z.avail_in = 0; f->z.next_out = 0; f->z.avail_out = 0; f->zbuffer = (unsigned char*)malloc(INFLATE_INPUT_BUFFER_MAX+1); /* +1 for the extra byte at the end */ f->remaining = f->real_size; /* * windowBits is passed < 0 to tell that there is no zlib header. * Note that in this case inflate *requires* an extra "dummy" byte * after the compressed stream in order to complete decompression and * return Z_STREAM_END. */ err = inflateInit2(&f->z, -MAX_WBITS); assert(err == Z_OK); } static void compressed_done(adv_fz* f) { inflateEnd(&f->z); free(f->zbuffer); } /** * Open an compressed file part of a ZIP archive. * \param file ZIP archive. * \param offset Offset in the archive. * \param size_compressed Size of the compressed data. * \param size_uncompressed Size of the uncompressed data. */ adv_fz* fzopenzipcompressed(const char* file, unsigned offset, unsigned size_compressed, unsigned size_uncompressed) { unsigned char buf[ZIP_LO_FIXED]; unsigned filename_length; unsigned extra_field_length; adv_fz* f = fzalloc(); if (!f) return 0; f->type = fz_file_compressed; f->virtual_pos = 0; f->virtual_size = size_uncompressed; f->f = fopen_lock(file, "rb"); if (!f->f) { free(f); return 0; } if (fseek(f->f, offset, SEEK_SET) != 0) { fclose_lock(f->f); free(f); return 0; } if (fread_lock(buf, ZIP_LO_FIXED, 1, f->f)!=1) { fclose_lock(f->f); free(f); return 0; } filename_length = le_uint16_read(buf+ZIP_LO_filename_length); extra_field_length = le_uint16_read(buf+ZIP_LO_extra_field_length); /* calculate offset to data and seek there */ offset += ZIP_LO_FIXED + filename_length + extra_field_length; f->real_offset = offset; f->real_size = size_compressed; if (fseek(f->f, f->real_offset, SEEK_SET) != 0) { fclose_lock(f->f); free(f); return 0; } compressed_init(f); return f; } /** * Open a memory range as a file. * \param data Data. * \param size Size of the data. */ adv_fz* fzopenmemory(const unsigned char* data, unsigned size) { adv_fz* f = fzalloc(); if (!f) return 0; f->type = fz_memory_read; f->virtual_pos = 0; f->virtual_size = size; f->data_read = data; return f; } /** * Close a file. * The semantic is like the C fclose() function. */ adv_error fzclose(adv_fz* f) { if (f->type == fz_file) { fclose_lock(f->f); free(f); } else if (f->type == fz_file_part) { fclose_lock(f->f); free(f); } else if (f->type == fz_file_compressed) { compressed_done(f); fclose_lock(f->f); free(f); } else if (f->type == fz_memory_read) { free(f); } else if (f->type == fz_memory_write) { free(f->data_write); free(f); } else { return -1; } return 0; } /** * Read a char from the file. * The semantic is like the C fgetc() function. * It assume to read a binary file without any "\r", "\n" conversion. */ int fzgetc(adv_fz* f) { if (f->type == fz_file) { return fgetc_lock(f->f); } else { unsigned char r; if (fzread(&r, 1, 1, f)==1) return r; else return EOF; } } /** * Unread a char from the file. * This function works only for files opened with fzopen(). * The semantic is like the C fungetc() function. */ adv_error fzungetc(int c, adv_fz* f) { if (f->type == fz_file) { return ungetc(c, f->f); } else { return -1; } } /** * Read a string from the file. * The semantic is like the C fgets() function. */ char* fzgets(char *s, int n, adv_fz* f) { char* r; if (n < 2) { r = 0; } else { int c = fzgetc(f); if (c == EOF) { r = 0; } else { r = s; while (n > 1) { *s++ = c; --n; if (c == '\n') break; if (n > 1) c = fzgetc(f); } if (n) { *s = 0; } else { r = 0; } } } return r; } /** * Check if the file pointer is at the end. * The semantic is like the C feof() function. */ adv_error fzeof(adv_fz* f) { if (f->type == fz_file) { return feof_lock(f->f); } else { return f->virtual_pos >= f->virtual_size; } } /** * Get the current position in the file. * The semantic is like the C ftell() function. */ long fztell(adv_fz* f) { if (f->type == fz_file) { return ftell(f->f); } else { return f->virtual_pos; } } /** * Get the size of the file. */ long fzsize(adv_fz* f) { if (f->type == fz_file) { struct stat st; if (fstat(fileno(f->f), &st) != 0) { return -1; } return st.st_size; } else { return f->virtual_size; } } /** * Seek to an arbitrary position. * The semantic is like the C fseek() function. */ adv_error fzseek(adv_fz* f, long offset, int mode) { if (f->type == fz_file) { switch (mode) { case SEEK_SET : return fseek(f->f, f->real_offset + offset, SEEK_SET); case SEEK_CUR : return fseek(f->f, offset, SEEK_CUR); case SEEK_END : if (f->real_size) return fseek(f->f, f->real_size - offset, SEEK_SET); else return fseek(f->f, offset, SEEK_END); default: return -1; } } else { int pos; switch (mode) { case SEEK_SET : pos = offset; break; case SEEK_CUR : pos = f->virtual_pos + offset; break; case SEEK_END : pos = f->virtual_size - offset; break; default: return -1; } if (pos < 0 || pos > f->virtual_size) return -1; if (f->type == fz_memory_read) { f->virtual_pos = pos; return 0; } else if (f->type == fz_memory_write) { if (fzgrow(f, pos) != 0) return -1; f->virtual_pos = pos; return 0; } else if (f->type == fz_file_part) { if (fseek(f->f, f->real_offset + f->virtual_pos, SEEK_SET) != 0) return -1; f->virtual_pos = pos; return 0; } else if (f->type == fz_file_compressed) { unsigned offset; if (pos < f->virtual_pos) { /* if backward reopen the file */ int err; compressed_done(f); err = fseek(f->f, f->real_offset, SEEK_SET); f->virtual_pos = 0; compressed_init(f); if (err != 0) return -1; } /* data to read */ offset = pos - f->virtual_pos; /* read all the data */ while (offset > 0) { unsigned char buffer[256]; unsigned run = offset; if (run > 256) run = 256; if (fzread(buffer, run, 1, f) != 1) return -1; offset -= run; } return 0; } else { return -1; } } } adv_error le_uint8_fzread(adv_fz* f, unsigned* v) { unsigned char p[1]; if (fzread(p, 1, 1, f) != 1) return -1; *v = le_uint8_read(p); return 0; } adv_error le_uint16_fzread(adv_fz* f, unsigned* v) { unsigned char p[2]; if (fzread(p, 2, 1, f) != 1) return -1; *v = le_uint16_read(p); return 0; } adv_error le_uint32_fzread(adv_fz* f, unsigned* v) { unsigned char p[4]; if (fzread(p, 4, 1, f) != 1) return -1; *v = le_uint32_read(p); return 0; } advancecomp-1.23/lib/fz.h000066400000000000000000000073471301462770100152710ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ /** \file * Generic compressed file support. */ #ifndef __FZ_H #define __FZ_H #include "extra.h" #include #include #ifdef __cplusplus extern "C" { #endif /** * Types of files supported. */ enum adv_fz_enum { fz_invalid, /**< Invalid file. */ fz_file, /**< Real file. Read and write.*/ fz_file_part, /**< Part of a real file. Read and write but not expandible. */ fz_file_compressed, /**< ZLIB compressed part of a file. Only read. */ fz_memory_read, /**< Memory image of a file. Only read. */ fz_memory_write /**< Memory image of a file. Read and write. */ }; /** * Compressed file context. */ typedef struct adv_fz_struct { unsigned type; /**< Type of file. One of the ::adv_fz_enum. */ unsigned virtual_pos; /**< Current position on the virtual file. */ unsigned virtual_size; /**< Size of the virtual file. */ unsigned real_offset; /**< Starting position on file part used. */ unsigned real_size; /**< Size of the file part used. */ const unsigned char* data_read; /**< Memory used by the file. */ unsigned char* data_write; /**< Memory used by the file which need to be freed. */ FILE* f; /**< Handler used by the file. */ z_stream z; /**< Compressed stream. */ unsigned char* zbuffer; /**< Buffer used for reading a compressed stream. */ unsigned remaining; /**< Remainig bytes of a compressed stream. */ } adv_fz; /** \addtogroup CompressedFile */ /*@{*/ adv_fz* fzopen(const char* file, const char* mode); adv_fz* fzopennullwrite(const char* file, const char* mode); adv_fz* fzopenzipuncompressed(const char* file, unsigned offset, unsigned size); adv_fz* fzopenzipcompressed(const char* file, unsigned offset, unsigned size_compressed, unsigned size_uncompressed); adv_fz* fzopenmemory(const unsigned char* data, unsigned size); unsigned fzread(void *buffer, unsigned size, unsigned number, adv_fz* f); unsigned fzwrite(const void *buffer, unsigned size, unsigned number, adv_fz* f); adv_error fzclose(adv_fz* f); long fztell(adv_fz* f); long fzsize(adv_fz* f); adv_error fzseek(adv_fz* f, long offset, int mode); int fzgetc(adv_fz* f); adv_error fzungetc(int c, adv_fz* f); char* fzgets(char *s, int n, adv_fz* f); adv_error fzeof(adv_fz* f); adv_error le_uint8_fzread(adv_fz* f, unsigned* v); adv_error le_uint16_fzread(adv_fz* f, unsigned* v); adv_error le_uint32_fzread(adv_fz* f, unsigned* v); /*@}*/ #ifdef __cplusplus } #endif #endif advancecomp-1.23/lib/mng.c000066400000000000000000000462271301462770100154260ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "mng.h" #include "png.h" #include "endianrw.h" #include "error.h" /**************************************************************************************/ /* MNG */ static unsigned char MNG_Signature[] = "\x8A\x4D\x4E\x47\x0D\x0A\x1A\x0A"; /** * Read the MNG file signature. * \param f File to read. */ adv_error adv_mng_read_signature(adv_fz* f) { unsigned char signature[8]; if (fzread(signature, 8, 1, f) != 1) { error_set("Error reading the signature"); return -1; } if (memcmp(signature, MNG_Signature, 8)!=0) { error_set("Invalid MNG signature"); return -1; } return 0; } /** * Write the MNG file signature. * \param f File to write. * \param count Pointer at the number of bytes written. It may be 0. */ adv_error adv_mng_write_signature(adv_fz* f, unsigned* count) { if (fzwrite(MNG_Signature, 8, 1, f) != 1) { error_set("Error writing the signature"); return -1; } if (count) *count += 8; return 0; } static adv_error mng_read_ihdr(adv_mng* mng, adv_fz* f, const unsigned char* ihdr, unsigned ihdr_size) { unsigned type; unsigned char* data; unsigned size; unsigned long dat_size; if (ihdr_size != 13) { error_set("Invalid IHDR size"); goto err; } mng->dat_width = be_uint32_read(ihdr + 0); mng->dat_height = be_uint32_read(ihdr + 4); if (mng->dat_x + mng->frame_width > mng->dat_width) { error_set("Frame not complete"); goto err; } if (mng->dat_y + mng->frame_height > mng->dat_height) { error_set("Frame not complete"); goto err; } if (ihdr[8] != 8) { /* bit depth */ error_unsupported_set("Unsupported bit depth"); goto err; } if (ihdr[9] == 3) /* color type */ mng->pixel = 1; else if (ihdr[9] == 2) mng->pixel = 3; else if (ihdr[9] == 6) mng->pixel = 4; else { error_unsupported_set("Unsupported color type"); goto err; } if (ihdr[10] != 0) { /* compression */ error_unsupported_set("Unsupported compression type"); goto err; } if (ihdr[11] != 0) { /* filter */ error_unsupported_set("unsupported Filter type"); goto err; } if (ihdr[12] != 0) { /* interlace */ error_unsupported_set("Unsupported interlace type"); goto err; } if (!mng->dat_ptr) { mng->dat_line = mng->dat_width * mng->pixel + 1; /* +1 for the filter byte */ mng->dat_size = mng->dat_height * mng->dat_line; mng->dat_ptr = malloc(mng->dat_size); } else { if (mng->dat_line != mng->dat_width * mng->pixel + 1 || mng->dat_size != mng->dat_height * mng->dat_line) { error_unsupported_set("Unsupported size change"); goto err; } } if (mng->pixel == 1) { if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; if (type != ADV_PNG_CN_PLTE) { error_set("Missing PLTE chunk"); goto err_data; } if (size % 3 != 0 || size / 3 > 256) { error_set("Invalid palette size in PLTE chunk"); goto err_data; } mng->pal_size = size; memcpy(mng->pal_ptr, data, size); free(data); } else { mng->pal_size = 0; } if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; if (type != ADV_PNG_CN_IDAT) { error_set("Missing IDAT chunk"); goto err_data; } dat_size = mng->dat_size; if (uncompress(mng->dat_ptr, &dat_size, data, size) != Z_OK) { error_set("Corrupt compressed data"); goto err_data; } free(data); if (dat_size != mng->dat_size) { error_set("Corrupt compressed data"); goto err; } if (mng->pixel == 1) adv_png_unfilter_8(mng->dat_width * mng->pixel, mng->dat_height, mng->dat_ptr, mng->dat_line); else if (mng->pixel == 3) adv_png_unfilter_24(mng->dat_width * mng->pixel, mng->dat_height, mng->dat_ptr, mng->dat_line); else if (mng->pixel == 4) adv_png_unfilter_32(mng->dat_width * mng->pixel, mng->dat_height, mng->dat_ptr, mng->dat_line); if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; if (adv_png_read_iend(f, data, size, type) != 0) goto err_data; free(data); return 0; err_data: free(data); err: return -1; } static adv_error mng_read_defi(adv_mng* mng, unsigned char* defi, unsigned defi_size) { unsigned id; if (defi_size != 4 && defi_size != 12) { error_unsupported_set("Unsupported DEFI size"); return -1; } id = be_uint16_read(defi + 0); if (id != 1) { error_unsupported_set("Unsupported id number in DEFI chunk"); return -1; } if (defi[2] != 0) { /* visible */ error_unsupported_set("Unsupported visible type in DEFI chunk"); return -1; } if (defi[3] != 1) { /* concrete */ error_unsupported_set("Unsupported concrete type in DEFI chunk"); return -1; } if (defi_size >= 12) { mng->dat_x = - (int)be_uint32_read(defi + 4); mng->dat_y = - (int)be_uint32_read(defi + 8); } else { mng->dat_x = 0; mng->dat_y = 0; } return 0; } static adv_error mng_read_move(adv_mng* mng, adv_fz* f, unsigned char* move, unsigned move_size) { unsigned id; if (move_size != 13) { error_unsupported_set("Unsupported MOVE size in MOVE chunk"); return -1; } id = be_uint16_read(move + 0); if (id != 1) { error_unsupported_set("Unsupported id number in MOVE chunk"); return -1; } id = be_uint16_read(move + 2); if (id != 1) { error_unsupported_set("Unsupported id number in MOVE chunk"); return -1; } if (move[4] == 0) { /* replace */ mng->dat_x = - (int)be_uint32_read(move + 5); mng->dat_y = - (int)be_uint32_read(move + 9); } else if (move[4] == 1) { /* adding */ mng->dat_x += - (int)be_uint32_read(move + 5); mng->dat_y += - (int)be_uint32_read(move + 9); } else { error_unsupported_set("Unsupported move type in MOVE chunk"); return -1; } return 0; } static void mng_delta_replacement(adv_mng* mng, unsigned pos_x, unsigned pos_y, unsigned width, unsigned height) { unsigned i; unsigned bytes_per_run = width * mng->pixel; unsigned delta_bytes_per_scanline = bytes_per_run + 1; unsigned char* p0 = mng->dat_ptr + pos_y * mng->dat_line + pos_x * mng->pixel + 1; unsigned char* p1 = mng->dlt_ptr + 1; for(i=0;idat_line; p1 += delta_bytes_per_scanline; } } static void mng_delta_addition(adv_mng* mng, unsigned pos_x, unsigned pos_y, unsigned width, unsigned height) { unsigned i, j; unsigned bytes_per_run = width * mng->pixel; unsigned delta_bytes_per_scanline = bytes_per_run + 1; unsigned char* p0 = mng->dat_ptr + pos_y * mng->dat_line + pos_x * mng->pixel + 1; unsigned char* p1 = mng->dlt_ptr + 1; for(i=0;idat_line - bytes_per_run; p1 += delta_bytes_per_scanline - bytes_per_run; } } static adv_error mng_read_delta(adv_mng* mng, adv_fz* f, unsigned char* dhdr, unsigned dhdr_size) { unsigned type; unsigned char* data; unsigned size; unsigned width; unsigned height; unsigned pos_x; unsigned pos_y; unsigned id; unsigned ope; if (dhdr_size != 4 && dhdr_size != 12 && dhdr_size != 20) { error_unsupported_set("Unsupported DHDR size"); goto err; } id = be_uint16_read(dhdr + 0); if (id != 1) /* object id 1 */ { error_unsupported_set("Unsupported id number in DHDR chunk"); goto err; } if (dhdr[2] != 1) /* PNG stream without IHDR header */ { error_unsupported_set("Unsupported delta type in DHDR chunk"); goto err; } ope = dhdr[3]; if (ope != 0 && ope != 1 && ope != 4 && ope != 7) { error_unsupported_set("Unsupported delta operation in DHDR chunk"); goto err; } if (!mng->dat_ptr) { error_set("Invalid delta context in DHDR chunk"); goto err; } if (!mng->dlt_ptr) { mng->dlt_line = mng->frame_width * mng->pixel + 1; /* +1 for the filter byte */ mng->dlt_size = mng->frame_height * mng->dlt_line; mng->dlt_ptr = malloc(mng->dlt_size); } if (dhdr_size >= 12) { width = be_uint32_read(dhdr + 4); height = be_uint32_read(dhdr + 8); } else { width = mng->frame_width; height = mng->frame_height; } if (dhdr_size >= 20) { pos_x = be_uint32_read(dhdr + 12); pos_y = be_uint32_read(dhdr + 16); } else { pos_x = 0; pos_y = 0; } if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; if (type == ADV_PNG_CN_PLTE) { if (mng->pixel != 1) { error_set("Unexpected PLTE chunk"); goto err_data; } if (size % 3 != 0 || size / 3 > 256) { error_set("Invalid palette size"); goto err_data; } mng->pal_size = size; memcpy(mng->pal_ptr, data, size); free(data); if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; } if (type == ADV_MNG_CN_PPLT) { unsigned i; if (mng->pixel != 1) { error_set("Unexpected PPLT chunk"); goto err_data; } if (data[0] != 0) { /* RGB replacement */ error_set("Unsupported palette operation in PPLT chunk"); goto err_data; } i = 1; while (i < size) { unsigned v0, v1, delta_size; if (i + 2 > size) { error_set("Invalid palette size in PPLT chunk"); goto err_data; } v0 = data[i++]; v1 = data[i++]; delta_size = (v1 - v0 + 1) * 3; if (i + delta_size > size) { error_set("Invalid palette format in PPLT chunk"); goto err_data; } memcpy(mng->pal_ptr + v0 * 3, data + i, delta_size); i += delta_size; } free(data); if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; } if (type == ADV_PNG_CN_IDAT) { unsigned long dlt_size; if (pos_x + width > mng->dat_width || pos_y + height > mng->dat_height) { error_set("Frame not complete in IDAT chunk"); goto err_data; } dlt_size = mng->dat_size; if (uncompress(mng->dlt_ptr, &dlt_size, data, size) != Z_OK) { error_set("Corrupt compressed data in IDAT chunk"); goto err_data; } if (ope == 0 || ope == 4) { mng_delta_replacement(mng, pos_x, pos_y, width, height); } else if (ope == 1) { mng_delta_addition(mng, pos_x, pos_y, width, height); } else { error_unsupported_set("Unsupported delta operation"); goto err_data; } free(data); if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; } else { if (ope != 7) { error_unsupported_set("Unsupported delta operation"); goto err_data; } } if (adv_png_read_iend(f, data, size, type) != 0) goto err_data; free(data); return 0; err_data: free(data); err: return -1; } static void mng_import( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, adv_bool own) { unsigned char* current_ptr = mng->dat_ptr + mng->dat_x * mng->pixel + mng->dat_y * mng->dat_line + 1; *pix_width = mng->frame_width; *pix_height = mng->frame_height; *pix_pixel = mng->pixel; if (mng->pixel == 1) { *pal_ptr = malloc(mng->pal_size); memcpy(*pal_ptr, mng->pal_ptr, mng->pal_size); *pal_size = mng->pal_size; } else { *pal_ptr = 0; *pal_size = 0; } if (own) { *dat_ptr = mng->dat_ptr; *dat_size = mng->dat_size; } else { *dat_ptr = 0; *dat_size = 0; } *pix_ptr = current_ptr; *pix_scanline = mng->dat_line; } static adv_error mng_read( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned* tick, adv_fz* f, adv_bool own) { unsigned type; unsigned char* data; unsigned size; if (mng->end_flag) return -1; *tick = mng->frame_tick; while (1) { if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err; switch (type) { case ADV_MNG_CN_DEFI : if (mng_read_defi(mng, data, size) != 0) goto err_data; free(data); break; case ADV_MNG_CN_MOVE : if (mng_read_move(mng, f, data, size) != 0) goto err_data; free(data); break; case ADV_PNG_CN_IHDR : if (mng_read_ihdr(mng, f, data, size) != 0) goto err_data; free(data); mng_import(mng, pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, own); return 0; case ADV_MNG_CN_DHDR : if (mng_read_delta(mng, f, data, size) != 0) goto err_data; free(data); mng_import(mng, pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, own); return 0; case ADV_MNG_CN_MEND : mng->end_flag = 1; free(data); return 1; case ADV_MNG_CN_FRAM : if (size > 1) { unsigned i = 1; while (i < size && data[i]) ++i; if (size >= i+9) { unsigned v = be_uint32_read(data + i+5); if (v < 1) v = 1; if (data[i+1] == 1 || data[i+1] == 2) *tick = v; if (data[i+1] == 2) mng->frame_tick = v; } } free(data); break; case ADV_MNG_CN_BACK : /* ignored OUTOFSPEC */ free(data); break; case ADV_MNG_CN_LOOP : case ADV_MNG_CN_ENDL : case ADV_MNG_CN_SAVE : case ADV_MNG_CN_SEEK : case ADV_MNG_CN_TERM : /* ignored */ free(data); break; default : /* ancillary bit. bit 5 of first byte. 0 (uppercase) = critical, 1 (lowercase) = ancillary. */ if ((type & 0x20000000) == 0) { char buf[4]; be_uint32_write(buf, type); error_unsupported_set("Unsupported critical chunk '%c%c%c%c'", buf[0], buf[1], buf[2], buf[3]); goto err_data; } /* ignored */ free(data); break; } } free(data); return 1; err_data: free(data); err: return -1; } /** * Read a MNG image. * This function returns always a null dat_ptr pointer because the * referenced image is stored in the mng context. * \param mng MNG context previously returned by mng_init(). * \param pix_width Where to put the image width. * \param pix_height Where to put the image height. * \param pix_pixel Where to put the image bytes per pixel. * \param dat_ptr Where to put the allocated data pointer. * \param dat_size Where to put the allocated data size. * \param pix_ptr Where to put pointer at the start of the image data. * \param pix_scanline Where to put the length of a scanline in bytes. * \param pal_ptr Where to put the allocated palette data pointer. Set to 0 if the image is RGB. * \param pal_size Where to put the palette size in number of colors. Set to 0 if the image is RGB. * \param tick Where to put the number of tick of the frame. The effective time can be computed dividing by mng_frequency_get(). * \param f File to read. * \return * - == 0 ok * - == 1 end of the mng stream * - < 0 error */ adv_error adv_mng_read( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned* tick, adv_fz* f) { return mng_read(mng, pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, tick, f, 0); } /** * Read a MNG image and implicitely call adv_mng_done(). * This function returns always a not null dat_ptr pointer. * The mng context is always destroyed. Also if an error * is returned. */ adv_error adv_mng_read_done( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned* tick, adv_fz* f) { adv_error r; r = mng_read(mng, pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, tick, f, 1); if (r != 0) free(mng->dat_ptr); free(mng->dlt_ptr); free(mng); return r; } /** * Initialize a MNG reading stream. * \param f File to read. * \return Return the MNG context. It must be destroied calling mng_done(). On error return 0. */ adv_mng* adv_mng_init(adv_fz* f) { adv_mng* mng; unsigned type; unsigned char* data; unsigned size; mng = malloc(sizeof(adv_mng)); if (!mng) goto err; mng->end_flag = 0; mng->pixel = 0; mng->dat_ptr = 0; mng->dat_size = 0; mng->dat_line = 0; mng->dat_x = 0; mng->dat_y = 0; mng->dat_width = 0; mng->dat_height = 0; mng->dlt_ptr = 0; mng->dlt_size = 0; mng->dlt_line = 0; mng->pal_size = 0; if (adv_mng_read_signature(f) != 0) goto err_mng; if (adv_png_read_chunk(f, &data, &size, &type) != 0) goto err_mng; if (type != ADV_MNG_CN_MHDR) { error_set("Missing MHDR chunk\n"); goto err_data; } if (size != 28) { error_set("Invalid MHDR size\n"); goto err_data; } mng->frame_width = be_uint32_read(data + 0); mng->frame_height = be_uint32_read(data + 4); mng->frame_frequency = be_uint32_read(data + 8); if (mng->frame_frequency < 1) mng->frame_frequency = 1; mng->frame_tick = 1; free(data); return mng; err_data: free(data); err_mng: free(mng); err: return 0; } /** * Destory a MNG context. * \param mng MNG context previously returned by mng_init(). */ void adv_mng_done(adv_mng* mng) { free(mng->dat_ptr); free(mng->dlt_ptr); free(mng); } /** * Get the base frequency of the MNG. * This value can be used to convert the number of tick per frame in a time. * \param mng MNG context. * \return Frequency in Hz. */ unsigned adv_mng_frequency_get(adv_mng* mng) { return mng->frame_frequency; } /** * Get the width of the frame. * \param mng MNG context. * \return Width in pixel. */ unsigned adv_mng_width_get(adv_mng* mng) { return mng->frame_width; } /** * Get the height of the frame. * \param mng MNG context. * \return height in pixel. */ unsigned adv_mng_height_get(adv_mng* mng) { return mng->frame_height; } adv_error adv_mng_write_mhdr( unsigned pix_width, unsigned pix_height, unsigned frequency, adv_bool is_lc, adv_fz* f, unsigned* count) { uint8 mhdr[28]; unsigned simplicity; simplicity = (1 << 0) /* Enable flags */ | (1 << 6); /* Enable flags */ if (is_lc) simplicity |= (1 << 1); /* Basic features */ memset(mhdr, 0, 28); be_uint32_write(mhdr, pix_width); be_uint32_write(mhdr + 4, pix_height); be_uint32_write(mhdr + 8, frequency); be_uint32_write(mhdr + 24, simplicity); if (adv_png_write_chunk(f, ADV_MNG_CN_MHDR, mhdr, 28, count)!=0) return -1; return 0; } adv_error adv_mng_write_mend(adv_fz* f, unsigned* count) { if (adv_png_write_chunk(f, ADV_MNG_CN_MEND, 0, 0, count)!=0) return -1; return 0; } adv_error adv_mng_write_fram(unsigned tick, adv_fz* f, unsigned* count) { uint8 fram[10]; unsigned fi; fi = tick; if (fi < 1) fi = 1; fram[0] = 1; /* Framing_mode: 1 */ fram[1] = 0; /* Null byte */ fram[2] = 2; /* Reset delay */ fram[3] = 0; /* No timeout change */ fram[4] = 0; /* No clip change */ fram[5] = 0; /* No sync id change */ be_uint32_write(fram+6, fi); /* Delay in tick */ if (adv_png_write_chunk(f, ADV_MNG_CN_FRAM, fram, 10, count)!=0) return -1; return 0; } advancecomp-1.23/lib/mng.h000066400000000000000000000071631301462770100154270ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /** \file * MNG file support. */ #ifndef __MNG_H #define __MNG_H #include "png.h" #ifdef __cplusplus extern "C" { #endif /** \name ADV_MNG_CHUNK */ /*@{*/ #define ADV_MNG_CN_DHDR 0x44484452 #define ADV_MNG_CN_MHDR 0x4D484452 #define ADV_MNG_CN_MEND 0x4D454E44 #define ADV_MNG_CN_DEFI 0x44454649 #define ADV_MNG_CN_PPLT 0x50504c54 #define ADV_MNG_CN_MOVE 0x4d4f5645 #define ADV_MNG_CN_TERM 0x5445524d #define ADV_MNG_CN_SAVE 0x53415645 #define ADV_MNG_CN_SEEK 0x5345454b #define ADV_MNG_CN_LOOP 0x4c4f4f50 #define ADV_MNG_CN_ENDL 0x454e444c #define ADV_MNG_CN_BACK 0x4241434b #define ADV_MNG_CN_FRAM 0x4652414d /*@}*/ /** * MNG context. */ typedef struct adv_mng_struct { int end_flag; /**< End flag. */ unsigned pixel; /**< Bytes per pixel. */ unsigned char* dat_ptr; /**< Current image buffer. */ unsigned dat_size; /**< Size of the buffer image. */ unsigned dat_line; /**< Bytes per scanline. */ int dat_x; /**< X position of the displayed area in the working area. */ int dat_y; /**< Y position of the displayed area in the working area. */ unsigned dat_width; /**< Width of the working area. */ unsigned dat_height; /**< height of the working area. */ unsigned char* dlt_ptr; /**< Delta buffer. */ unsigned dlt_size; /**< Delta buffer size. */ unsigned dlt_line; /**< Delta bufer bytes per scanline. */ unsigned char pal_ptr[256*3]; /**< Palette data. */ unsigned pal_size; /**< Palette data size in bytes. */ unsigned frame_frequency; /**< Base frame rate. */ unsigned frame_tick; /**< Ticks for a generic frame. */ unsigned frame_width; /**< Frame width. */ unsigned frame_height; /**< Frame height. */ } adv_mng; adv_error adv_mng_read_signature(adv_fz* f); adv_error adv_mng_write_signature(adv_fz* f, unsigned* count); adv_error adv_mng_write_mhdr( unsigned pix_width, unsigned pix_height, unsigned frequency, adv_bool is_lc, adv_fz* f, unsigned* count ); adv_error adv_mng_write_mend(adv_fz* f, unsigned* count); adv_error adv_mng_write_fram(unsigned tick, adv_fz* f, unsigned* count); /** \addtogroup VideoFile */ /*@{*/ adv_mng* adv_mng_init(adv_fz* f); void adv_mng_done(adv_mng* mng); adv_error adv_mng_read( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned* tick, adv_fz* f ); adv_error adv_mng_read_done( adv_mng* mng, unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned* tick, adv_fz* f ); unsigned adv_mng_frequency_get(adv_mng* mng); unsigned adv_mng_width_get(adv_mng* mng); unsigned adv_mng_height_get(adv_mng* mng); /*@}*/ #ifdef __cplusplus } #endif #endif advancecomp-1.23/lib/png.c000066400000000000000000000711101301462770100154160ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ #include "portable.h" #include "png.h" #include "endianrw.h" #include "error.h" /**************************************************************************************/ /* PNG */ static unsigned char PNG_Signature[] = "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"; /** * Read a PNG data chunk. * \param f File to read. * \param data Where to put the allocated data of the chunk. * \param size Where to put the size of the chunk. * \param type Where to put the type of the chunk. */ adv_error adv_png_read_chunk(adv_fz* f, unsigned char** data, unsigned* size, unsigned* type) { unsigned char cl[4]; unsigned char ct[4]; unsigned char cc[4]; if (fzread(cl, 4, 1, f) != 1) { error_set("Error reading the chunk size"); goto err; } *size = be_uint32_read(cl); if (fzread(ct, 4, 1, f) != 1) { error_set("Error reading the chunk type"); goto err; } *type = be_uint32_read(ct); if (*size) { *data = malloc(*size); if (!*data) { error_set("Low memory"); goto err; } if (fzread(*data, *size, 1, f) != 1) { error_set("Error reading the chunk data"); goto err_data; } } else { *data = 0; } if (fzread(cc, 4, 1, f) != 1) { error_set("Error reading the chunk crc"); goto err_data; } return 0; err_data: free(*data); err: return -1; } /** * Write a PNG data chunk. * \param f File to write. * \param type Type of the chunk. * \param data Data of the chunk. * \param size Size of the chunk. * \param count Pointer at the incremental counter of bytes written. Use 0 for disabling it. */ adv_error adv_png_write_chunk(adv_fz* f, unsigned type, const unsigned char* data, unsigned size, unsigned* count) { unsigned char v[4]; unsigned crc; be_uint32_write(v, size); if (fzwrite(v, 4, 1, f) != 1) { error_set("Error writing the chunk size"); return -1; } be_uint32_write(v, type); if (fzwrite(v, 4, 1, f) != 1) { error_set("Error writing the chunk type"); return -1; } crc = crc32(0, v, 4); if (size > 0) { if (fzwrite(data, size, 1, f) != 1) { error_set("Error writing the chunk data"); return -1; } crc = crc32(crc, data, size); } be_uint32_write(v, crc); if (fzwrite(v, 4, 1, f) != 1) { error_set("Error writing the chunk crc"); return -1; } if (count) *count += 4 + 4 + size + 4; return 0; } /** * Read the PNG file signature. * \param f File to read. */ adv_error adv_png_read_signature(adv_fz* f) { unsigned char signature[8]; if (fzread(signature, 8, 1, f) != 1) { error_set("Error reading the signature"); return -1; } if (memcmp(signature, PNG_Signature, 8)!=0) { error_set("Invalid PNG signature"); return -1; } return 0; } /** * Write the PNG file signature. * \param f File to write. * \param count Pointer at the incremental counter of bytes written. Use 0 for disabling it. */ adv_error adv_png_write_signature(adv_fz* f, unsigned* count) { if (fzwrite(PNG_Signature, 8, 1, f) != 1) { error_set("Error writing the signature"); return -1; } if (count) *count += 8; return 0; } /** * Expand a 4 bits per pixel image to a 8 bits per pixel image. * \param width Width of the image. * \param height Height of the image. * \param ptr Data pointer. It must point at the first filter type byte. */ void adv_png_expand_4(unsigned width, unsigned height, unsigned char* ptr) { unsigned i, j; unsigned char* p8 = ptr + height * (width + 1) - 1; unsigned char* p4 = ptr + height * (width / 2 + 1) - 1; width /= 2; for(i=0;i> 4; --p4; } --p8; --p4; } } /** * Expand a 2 bits per pixel image to a 8 bits per pixel image. * \param width Width of the image. * \param height Height of the image. * \param ptr Data pointer. It must point at the first filter type byte. */ void adv_png_expand_2(unsigned width, unsigned height, unsigned char* ptr) { unsigned i, j; unsigned char* p8 = ptr + height * (width + 1) - 1; unsigned char* p2 = ptr + height * (width / 4 + 1) - 1; width /= 4; for(i=0;i> 2) & 0x3; *p8-- = (v >> 4) & 0x3; *p8-- = v >> 6; --p2; } --p8; --p2; } } /** * Expand a 1 bit per pixel image to a 8 bit per pixel image. * \param width Width of the image. * \param height Height of the image. * \param ptr Data pointer. It must point at the first filter type byte. */ void adv_png_expand_1(unsigned width, unsigned height, unsigned char* ptr) { unsigned i, j; unsigned char* p8 = ptr + height * (width + 1) - 1; unsigned char* p1 = ptr + height * (width / 8 + 1) - 1; width /= 8; for(i=0;i> 1) & 0x1; *p8-- = (v >> 2) & 0x1; *p8-- = (v >> 3) & 0x1; *p8-- = (v >> 4) & 0x1; *p8-- = (v >> 5) & 0x1; *p8-- = (v >> 6) & 0x1; *p8-- = v >> 7; --p1; } --p8; --p1; } } /** * Unfilter a 8 bit image. * \param width With of the image. * \param height Height of the image. * \param p Data pointer. It must point at the first filter type byte. * \param line Scanline size of row. */ void adv_png_unfilter_8(unsigned width, unsigned height, unsigned char* p, unsigned line) { unsigned i, j; for(i=0;i> 1; ++p; ++u; } } else { ++p; for(j=1;j> 1; ++p; ++u; } } else { p += 3; for(j=3;j> 1; ++p; ++u; } } else { p += 4; for(j=4;j 256*3) { error_set("Invalid palette size in PLTE chunk"); goto err_ptr; } if (*pal_ptr) { error_set("Double palette specification"); goto err_ptr; } *pal_ptr = ptr; *pal_size = ptr_size; } else if (type == ADV_PNG_CN_tRNS) { if (*rns_ptr) { error_set("Double rns specification"); goto err_ptr; } *rns_ptr = ptr; *rns_size = ptr_size; } else { /* ancillary bit. bit 5 of first byte. 0 (uppercase) = critical, 1 (lowercase) = ancillary. */ if ((type & 0x20000000) == 0) { char buf[4]; be_uint32_write(buf, type); error_unsupported_set("Unsupported critical chunk '%c%c%c%c'", buf[0], buf[1], buf[2], buf[3]); goto err_ptr; } free(ptr); } if (adv_png_read_chunk(f, &ptr, &ptr_size, &type) != 0) goto err; } if (has_palette && !*pal_ptr) { error_set("Missing PLTE chunk"); goto err_ptr; } if (!has_palette && *pal_ptr) { error_set("Unexpected PLTE chunk"); goto err_ptr; } *dat_size = height * (width_align * pixel + 1); *dat_ptr = malloc(*dat_size); *pix_scanline = width_align * pixel + 1; *pix_ptr = *dat_ptr + 1; z.zalloc = 0; z.zfree = 0; z.next_out = *dat_ptr; z.avail_out = *dat_size; z.next_in = 0; z.avail_in = 0; r = inflateInit(&z); while (r == Z_OK && type == ADV_PNG_CN_IDAT) { z.next_in = ptr; z.avail_in = ptr_size; r = inflate(&z, Z_NO_FLUSH); free(ptr); if (adv_png_read_chunk(f, &ptr, &ptr_size, &type) != 0) { inflateEnd(&z); goto err; } } res_size = z.total_out; inflateEnd(&z); if (r != Z_STREAM_END) { error_set("Invalid compressed data"); goto err_ptr; } if (depth == 8) { if (res_size != *dat_size) { error_set("Invalid decompressed size"); goto err_ptr; } if (pixel == 1) adv_png_unfilter_8(width * pixel, height, *dat_ptr, width_align * pixel + 1); else if (pixel == 3) adv_png_unfilter_24(width * pixel, height, *dat_ptr, width_align * pixel + 1); else if (pixel == 4) adv_png_unfilter_32(width * pixel, height, *dat_ptr, width_align * pixel + 1); else { error_set("Unsupported format"); goto err_ptr; } } else if (depth == 4) { if (res_size != height * (width_align / 2 + 1)) { error_set("Invalid decompressed size"); goto err_ptr; } adv_png_unfilter_8(width_align / 2, height, *dat_ptr, width_align / 2 + 1); adv_png_expand_4(width_align, height, *dat_ptr); } else if (depth == 2) { if (res_size != height * (width_align / 4 + 1)) { error_set("Invalid decompressed size"); goto err_ptr; } adv_png_unfilter_8(width_align / 4, height, *dat_ptr, width_align / 4 + 1); adv_png_expand_2(width_align, height, *dat_ptr); } else if (depth == 1) { if (res_size != height * (width_align / 8 + 1)) { error_set("Invalid decompressed size"); goto err_ptr; } adv_png_unfilter_8(width_align / 8, height, *dat_ptr, width_align / 8 + 1); adv_png_expand_1(width_align, height, *dat_ptr); } if (adv_png_read_iend(f, ptr, ptr_size, type)!=0) { goto err_ptr; } free(ptr); return 0; err_ptr: free(ptr); err: free(*dat_ptr); free(*pal_ptr); free(*rns_ptr); return -1; } /** * Load a PNG image. * The image is stored in memory as present in the PNG format. It imply that the row scanline * is generally greater than the row size. * \param pix_width Where to put the image width. * \param pix_height Where to put the image height. * \param pix_pixel Where to put the image bytes per pixel. * \param dat_ptr Where to put the allocated data pointer. * \param dat_size Where to put the allocated data size. * \param pix_ptr Where to put pointer at the start of the image data. * \param pix_scanline Where to put the length of a scanline in bytes. * \param pal_ptr Where to put the allocated palette data pointer. Set to 0 if the image is RGB. * \param pal_size Where to put the palette size in bytes. Set to 0 if the image is RGB. * \param rns_ptr Where to put the allocated transparency data pointer. Set to 0 if the image hasn't transparency. * \param rns_size Where to put the transparency size in number of bytes. Set to 0 if the image hasn't transparency. * \param f File to read. */ adv_error adv_png_read_rns( unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, unsigned char** rns_ptr, unsigned* rns_size, adv_fz* f) { unsigned char* data; unsigned type; unsigned size; if (adv_png_read_signature(f) != 0) { goto err; } do { if (adv_png_read_chunk(f, &data, &size, &type) != 0) { goto err; } switch (type) { case ADV_PNG_CN_IHDR : if (adv_png_read_ihdr(pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, rns_ptr, rns_size, f, data, size) != 0) goto err_data; free(data); return 0; default : /* ancillary bit. bit 5 of first byte. 0 (uppercase) = critical, 1 (lowercase) = ancillary. */ if ((type & 0x20000000) == 0) { char buf[4]; be_uint32_write(buf, type); error_unsupported_set("Unsupported critical chunk '%c%c%c%c'", buf[0], buf[1], buf[2], buf[3]); goto err_data; } /* ignored */ break; } free(data); } while (type != ADV_PNG_CN_IEND); error_set("Invalid PNG file"); return -1; err_data: free(data); err: return -1; } /** * Load a PNG image. * Like png_read_rns() but without transparency. */ adv_error adv_png_read( unsigned* pix_width, unsigned* pix_height, unsigned* pix_pixel, unsigned char** dat_ptr, unsigned* dat_size, unsigned char** pix_ptr, unsigned* pix_scanline, unsigned char** pal_ptr, unsigned* pal_size, adv_fz* f) { adv_error r; unsigned char* rns_ptr; unsigned rns_size; r = adv_png_read_rns(pix_width, pix_height, pix_pixel, dat_ptr, dat_size, pix_ptr, pix_scanline, pal_ptr, pal_size, &rns_ptr, &rns_size, f); if (r == 0) free(rns_ptr); return r; } /** * Write the PNG IHDR chunk. * \param f File to write. * \param count Pointer at the incremental counter of bytes written. Use 0 for disabling it. */ adv_error adv_png_write_ihdr( unsigned pix_width, unsigned pix_height, unsigned pix_depth, unsigned pix_type, adv_fz* f, unsigned* count) { uint8 ihdr[13]; be_uint32_write(ihdr, pix_width); be_uint32_write(ihdr+4, pix_height); ihdr[8] = pix_depth; ihdr[9] = pix_type; ihdr[10] = 0; /* compression */ ihdr[11] = 0; /* filter */ ihdr[12] = 0; /* interlace */ if (adv_png_write_chunk(f, ADV_PNG_CN_IHDR, ihdr, 13, count)!=0) return -1; return 0; } adv_error adv_png_write_iend(adv_fz* f, unsigned* count) { if (adv_png_write_chunk(f, ADV_PNG_CN_IEND, 0, 0, count)!=0) return -1; return 0; } /** * Write the PNG IDAT chunk. * \param f File to write. * \param count Pointer at the incremental counter of bytes written. Use 0 for disabling it. */ adv_error adv_png_write_idat( unsigned pix_width, unsigned pix_height, unsigned pix_pixel, const uint8* pix_ptr, int pix_pixel_pitch, int pix_scanline_pitch, adv_bool fast, adv_fz* f, unsigned* count) { uint8* z_ptr; uint8* r_ptr; unsigned char filter; unsigned long z_size; unsigned res_size; const uint8* p; unsigned i; int method; z_stream z; int r; z_size = pix_height * (pix_width * (pix_pixel+1)) * 103 / 100 + 12; if (pix_pixel_pitch != pix_pixel) { r_ptr = (uint8*)malloc(pix_width * pix_pixel); if (!r_ptr) goto err; } else { r_ptr = 0; } z_ptr = (uint8*)malloc(z_size); if (!z_ptr) goto err_row; if (fast) method = Z_BEST_SPEED; else method = Z_DEFAULT_COMPRESSION; z.zalloc = 0; z.zfree = 0; z.next_out = z_ptr; z.avail_out = z_size; z.next_in = 0; z.avail_in = 0; p = pix_ptr; filter = 0; r = deflateInit(&z, method); for(i=0;i l) vsnprintf(str + l, count - l, fmt, arg); va_end(arg); } /** * Skip a subset of chars. * \param p Index on the string. * \param s String to scan. * \param sep Set of chars to skip. */ void sskip(int* p, const char* s, const char* sep) { while (s[*p] && strchr(sep, s[*p])!=0) ++*p; } /** * Extract a token from a string. * \param c Separator character. It's cleared in the string to ensure a 0 termination of the token. It's 0 if the token end the string. * \param p Index on the string. The index is increased at the end of the token or after the separator if present. * \param s String to scan. The string is modified to put the terminating 0 at the end of the token. * \param sep Set of chars to use as separators. * \param ignore Set of chars to ignore. They are removed at the start and at the end of the token. They are not removed after the separator. * \return The extratect token, always 0 terminated. */ const char* stoken(char* c, int* p, char* s, const char* sep, const char* ignore) { unsigned begin; unsigned end; begin = *p; while (s[*p] && strchr(sep, s[*p])==0) ++*p; end = *p; *c = s[*p]; if (s[*p]) { s[*p] = 0; ++*p; } while (begin < end && strchr(ignore, s[begin])!=0) { ++begin; } while (begin < end && strchr(ignore, s[end-1])!=0) { --end; s[end] = 0; } return s + begin; } /** * Match a glob pattern to a string. * \param s String to compare. * \param glob Pattern to use. The glob chars * and ? are allowed. You can prefix * these char with a backslash to prevent globbing expansion. * \return If the pattern match. */ adv_bool sglob(const char* s, const char* glob) { while (*s && *glob) { if (*glob == '*') { if (sglob(s, glob+1)) return 1; ++s; continue; } if (*glob == '?') { ++glob; ++s; continue; } if (glob[0] == '\\' && (glob[1] == '\\' || glob[1] == '*' || glob[1] == '?')) { ++glob; } if (*glob != *s) { return 0; } ++glob; ++s; } while (*glob == '*') ++glob; return !*s && !*glob; } advancecomp-1.23/lib/snstring.h000066400000000000000000000042061301462770100165100ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1999, 2000, 2001, 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * In addition, as a special exception, Andrea Mazzoleni * gives permission to link the code of this program with * the MAME library (or with modified versions of MAME that use the * same license as MAME), and distribute linked combinations including * the two. You must obey the GNU General Public License in all * respects for all of the code used other than MAME. If you modify * this file, you may extend this exception to your version of the * file, but you are not obligated to do so. If you do not wish to * do so, delete this exception statement from your version. */ /** \file * Safe string functions. */ #ifndef __SNSTRING_H #define __SNSTRING_H #include "extra.h" #ifdef __cplusplus extern "C" { #endif /** \addtogroup SafeString */ /*@{*/ void sncpy(char* dst, size_t len, const char* src); void sncpyc(char* dst, size_t len, char src); void sncpyn(char* dst, size_t len, const char* src, size_t src_len); void sncat(char* dst, size_t len, const char* src); void sncatc(char* dst, size_t len, char src); void sncatf(char* str, size_t count, const char *fmt, ...) __attribute__((format(printf, 3, 4))); const char* stoken(char* c, int* p, char* s, const char* sep, const char* ignore); void sskip(int* p, const char* s, const char* sep); adv_bool sglob(const char* s, const char* glob); /*@}*/ #ifdef __cplusplus } #endif #endif advancecomp-1.23/libdeflate/000077500000000000000000000000001301462770100160135ustar00rootroot00000000000000advancecomp-1.23/libdeflate/COPYING000066400000000000000000000020341301462770100170450ustar00rootroot00000000000000Copyright 2016 Eric Biggers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. advancecomp-1.23/libdeflate/NEWS000066400000000000000000000027611301462770100165200ustar00rootroot00000000000000Version 0.6: Various improvements to the gzip program's behavior. Faster CRC-32 on AVX-capable processors. Other minor changes. Version 0.5: The CRC-32 checksum algorithm has been optimized with carryless multiplication instructions for x86_64 (PCLMUL). This speeds up gzip compression and decompression. Build fixes for certain platforms and compilers. Added more test programs and scripts. libdeflate is now entirely MIT-licensed. Version 0.4: The Adler-32 checksum algorithm has been optimized with vector instructions for x86_64 (SSE2 and AVX2) and ARM (NEON). This speeds up zlib compression and decompression. To avoid naming collisions, functions and definitions in libdeflate's API have been renamed to be prefixed with "libdeflate_" or "LIBDEFLATE_". Programs using the old API will need to be updated. Various bug fixes and other improvements. Version 0.3: Some bug fixes and other minor changes. Version 0.2: Implemented a new block splitting algorithm which typically improves the compression ratio slightly at all compression levels. The compressor now outputs each block using the cheapest type (dynamic Huffman, static Huffman, or uncompressed). The gzip program has received an overhaul and now behaves more like the standard version. Build system updates, including: some build options were changed and some build options were removed, and the default 'make' target now includes the gzip program as well as the library. Version 0.1: Initial official release. advancecomp-1.23/libdeflate/README.md000066400000000000000000000177001301462770100172770ustar00rootroot00000000000000# Overview libdeflate is a library for fast, whole-buffer DEFLATE-based compression and decompression. The supported formats are: - DEFLATE (raw) - zlib (a.k.a. DEFLATE with a zlib wrapper) - gzip (a.k.a. DEFLATE with a gzip wrapper) libdeflate is heavily optimized. It is significantly faster than the zlib library, both for compression and decompression, and especially on x86 processors. In addition, libdeflate provides optional high compression modes that provide a better compression ratio than the zlib's "level 9". libdeflate itself is a library, but the following command-line programs which use this library are also provided: * gzip (or gunzip), a program which mostly behaves like the standard equivalent, except that it does not yet have good streaming support and therefore does not yet support very large files * benchmark, a program for benchmarking in-memory compression and decompression # Building ## For UNIX Just run `make`. You need GNU Make and either GCC or Clang. GCC is recommended because it builds slightly faster binaries. There is no `make install` yet; just copy the file(s) to where you want. By default, all targets are built, including the library and programs, with the exception of the `benchmark` program. `make help` shows the available targets. There are also several options which can be set on the `make` command line. See the Makefile for details. ## For Windows MinGW (GCC) is the recommended compiler to use when building binaries for Windows. MinGW can be used on either Windows or Linux. On Windows, you'll need the compiler as well as GNU Make and basic UNIX tools such as `sh`. This is most easily set up with Cygwin, but some standalone MinGW distributions for Windows also work. Or, on Linux, you'll need to install the `mingw-w64-gcc` or similarly-named package. Once ready, do the build using a command like: $ make CC=x86_64-w64-mingw32-gcc Some MinGW distributions for Windows may require `CC=gcc` instead. Windows binaries prebuilt with MinGW may also be downloaded from https://github.com/ebiggers/libdeflate/releases. Alternatively, a separate Makefile, `Makefile.msc`, is provided for the tools that come with Visual Studio, for those who strongly prefer that toolchain. As usual, 64-bit binaries are faster than 32-bit binaries and should be preferred whenever possible. # API libdeflate has a simple API that is not zlib-compatible. You can create compressors and decompressors and use them to compress or decompress buffers. See libdeflate.h for details. There is currently no support for streaming. This has been considered, but it always significantly increases complexity and slows down fast paths. Unfortunately, at this point it remains a future TODO. So: if your application compresses data in "chunks", say, less than 1 MB in size, then libdeflate is a great choice for you; that's what it's designed to do. This is perfect for certain use cases such as transparent filesystem compression. But if your application compresses large files as a single compressed stream, similarly to the `gzip` program, then libdeflate isn't for you. Note that with chunk-based compression, you generally should have the uncompressed size of each chunk stored outside of the compressed data itself. This enables you to allocate an output buffer of the correct size without guessing. However, libdeflate's decompression routines do optionally provide the actual number of output bytes in case you need it. # DEFLATE vs. zlib vs. gzip The DEFLATE format ([rfc1951](https://www.ietf.org/rfc/rfc1951.txt)), the zlib format ([rfc1950](https://www.ietf.org/rfc/rfc1950.txt)), and the gzip format ([rfc1952](https://www.ietf.org/rfc/rfc1952.txt)) are commonly confused with each other as well as with the [zlib software library](http://zlib.net), which actually supports all three formats. libdeflate (this library) also supports all three formats. Briefly, DEFLATE is a raw compressed stream, whereas zlib and gzip are different wrappers for this stream. Both zlib and gzip include checksums, but gzip can include extra information such as the original filename. Generally, you should choose a format as follows: - If you are compressing whole files with no subdivisions, similar to the `gzip` program, you probably should use the gzip format. - Otherwise, if you don't need the features of the gzip header and footer but do still want a checksum for corruption detection, you probably should use the zlib format. - Otherwise, you probably should use raw DEFLATE. This is ideal if you don't need checksums, e.g. because they're simply not needed for your use case or because you already compute your own checksums that are stored separately from the compressed stream. Note that gzip and zlib streams can be distinguished from each other based on their starting bytes, but this is not necessarily true of raw DEFLATE streams. # Compression levels An often-underappreciated fact of compression formats such as DEFLATE is that there are an enormous number of different ways that a given input could be compressed. Different algorithms and different amounts of computation time will result in different compression ratios, while remaining equally compatible with the decompressor. For this reason, the commonly used zlib library provides nine compression levels. Level 1 is the fastest but provides the worst compression; level 9 provides the best compression but is the slowest. It defaults to level 6. libdeflate uses this same design but is designed to improve on both zlib's performance *and* compression ratio at every compression level. In addition, libdeflate's levels go [up to 12](https://xkcd.com/670/) to make room for a minimum-cost-path based algorithm (sometimes called "optimal parsing") that can significantly improve on zlib's compression ratio. If you are using DEFLATE (or zlib, or gzip) in your application, you should test different levels to see which works best for your application. # Motivation Despite DEFLATE's widespread use mainly through the zlib library, in the compression community this format from the early 1990s is often considered obsolete. And in a few significant ways, it is. So why implement DEFLATE at all, instead of focusing entirely on bzip2/LZMA/xz/LZ4/LZX/ZSTD/Brotli/LZHAM/LZFSE/[insert cool new format here]? To do something better, you need to understand what came before. And it turns out that most ideas from DEFLATE are still relevant. Many of the newer formats share a similar structure as DEFLATE, with different tweaks. The effects of trivial but very useful tweaks, such as increasing the sliding window size, are often confused with the effects of nontrivial but less useful tweaks. And actually, many of these formats are similar enough that common algorithms and optimizations (e.g. those dealing with LZ77 matchfinding) can be reused. In addition, comparing compressors fairly is difficult because the performance of a compressor depends heavily on optimizations which are not intrinsic to the compression format itself. In this respect, the zlib library sometimes compares poorly to certain newer code because zlib is not well optimized for modern processors. libdeflate addresses this by providing an optimized DEFLATE implementation which can be used for benchmarking purposes. And, of course, real applications can use it as well. That being said, I have also started [a separate project](https://github.com/ebiggers/xpack) for an experimental, more modern compression format. # License libdeflate is [MIT-licensed](COPYING). Additional notes (informational only): - I am not aware of any patents covering libdeflate. - Old versions of libdeflate were public domain; I only started copyrighting changes in newer versions. Portions of the source code that have not been changed since being released in a public domain version can theoretically still be used as public domain if you want to. But for practical purposes, it probably would be easier to just take the MIT license option, which is nearly the same anyway. advancecomp-1.23/libdeflate/adler32.c000066400000000000000000000136401301462770100174170ustar00rootroot00000000000000/* * adler32.c - Adler-32 checksum algorithm * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "x86_cpu_features.h" #include "libdeflate.h" /* The Adler-32 divisor, or "base", value. */ #define DIVISOR 65521 /* * MAX_BYTES_PER_CHUNK is the most bytes that can be processed without the * possibility of s2 overflowing when it is represented as an unsigned 32-bit * integer. This value was computed using the following Python script: * * divisor = 65521 * count = 0 * s1 = divisor - 1 * s2 = divisor - 1 * while True: * s1 += 0xFF * s2 += s1 * if s2 > 0xFFFFFFFF: * break * count += 1 * print(count) * * Note that to get the correct worst-case value, we must assume that every byte * has value 0xFF and that s1 and s2 started with the highest possible values * modulo the divisor. */ #define MAX_BYTES_PER_CHUNK 5552 /* Select the implementations to compile in. */ #define NEED_GENERIC_IMPL 1 /* include generic impl unless overridden */ /* Include the SSE2 implementation? */ #define NEED_SSE2_IMPL 0 #ifdef __SSE2__ # include # undef NEED_SSE2_IMPL # define NEED_SSE2_IMPL 1 # undef NEED_GENERIC_IMPL # define NEED_GENERIC_IMPL 0 /* generic impl not needed */ #endif /* Include the AVX2 implementation? */ #define NEED_AVX2_IMPL 0 #if defined(__AVX2__) || \ (X86_CPU_FEATURES_ENABLED && COMPILER_SUPPORTS_AVX2_TARGET && \ COMPILER_SUPPORTS_TARGET_INTRINSICS) # include # undef NEED_AVX2_IMPL # define NEED_AVX2_IMPL 1 # ifdef __AVX2__ /* compiling for AVX2, i.e. can we assume it's there? */ # undef NEED_GENERIC_IMPL # define NEED_GENERIC_IMPL 0 /* generic impl not needed */ # undef NEED_SSE2_IMPL # define NEED_SSE2_IMPL 0 /* SSE2 impl not needed */ # endif /* otherwise, we can build an AVX2 version, but we won't know whether we can use it until runtime */ #endif /* Include the NEON implementation? */ #define NEED_NEON_IMPL 0 #ifdef __ARM_NEON # include # undef NEED_NEON_IMPL # define NEED_NEON_IMPL 1 # undef NEED_GENERIC_IMPL # define NEED_GENERIC_IMPL 0 /* generic impl not needed */ #endif #define NUM_IMPLS (NEED_GENERIC_IMPL + NEED_SSE2_IMPL + NEED_AVX2_IMPL + \ NEED_NEON_IMPL) /* Define the generic implementation if needed. */ #if NEED_GENERIC_IMPL static u32 adler32_generic(u32 adler, const void *buffer, size_t size) { u32 s1 = adler & 0xFFFF; u32 s2 = adler >> 16; const u8 *p = buffer; const u8 * const end = p + size; while (p != end) { size_t chunk_size = MIN(end - p, MAX_BYTES_PER_CHUNK); const u8 *chunk_end = p + chunk_size; size_t num_unrolled_iterations = chunk_size / 4; while (num_unrolled_iterations--) { s1 += *p++; s2 += s1; s1 += *p++; s2 += s1; s1 += *p++; s2 += s1; s1 += *p++; s2 += s1; } while (p != chunk_end) { s1 += *p++; s2 += s1; } s1 %= DIVISOR; s2 %= DIVISOR; } return (s2 << 16) | s1; } #define DEFAULT_IMPL adler32_generic #endif /* NEED_GENERIC_IMPL */ #define TARGET_SSE2 100 #define TARGET_AVX2 200 #define TARGET_NEON 300 /* Define the SSE2 implementation if needed. */ #if NEED_SSE2_IMPL # define FUNCNAME adler32_sse2 # define TARGET TARGET_SSE2 # define ALIGNMENT_REQUIRED 16 # define BYTES_PER_ITERATION 32 # define ATTRIBUTES # define DEFAULT_IMPL adler32_sse2 # include "adler32_impl.h" #endif /* Define the AVX2 implementation if needed. */ #if NEED_AVX2_IMPL # define FUNCNAME adler32_avx2 # define TARGET TARGET_AVX2 # define ALIGNMENT_REQUIRED 32 # define BYTES_PER_ITERATION 32 # ifdef __AVX2__ # define ATTRIBUTES # define DEFAULT_IMPL adler32_avx2 # else # define ATTRIBUTES __attribute__((target("avx2"))) # endif # include "adler32_impl.h" #endif /* Define the NEON implementation if needed. */ #if NEED_NEON_IMPL # define FUNCNAME adler32_neon # define TARGET TARGET_NEON # define ALIGNMENT_REQUIRED 16 # define BYTES_PER_ITERATION 32 # define ATTRIBUTES # define DEFAULT_IMPL adler32_neon # include "adler32_impl.h" #endif typedef u32 (*adler32_func_t)(u32, const void *, size_t); /* * If multiple implementations are available, then dispatch among them based on * CPU features at runtime. Otherwise just call the single one directly. */ #if NUM_IMPLS == 1 # define adler32_impl DEFAULT_IMPL #else static u32 dispatch(u32, const void *, size_t); static adler32_func_t adler32_impl = dispatch; static u32 dispatch(u32 adler, const void *buffer, size_t size) { adler32_func_t f = DEFAULT_IMPL; #if NEED_AVX2_IMPL && !defined(__AVX2__) if (x86_have_cpu_features(X86_CPU_FEATURE_AVX2)) f = adler32_avx2; #endif adler32_impl = f; return adler32_impl(adler, buffer, size); } #endif /* NUM_IMPLS != 1 */ LIBDEFLATEAPI u32 libdeflate_adler32(u32 adler, const void *buffer, size_t size) { if (buffer == NULL) /* return initial value */ return 1; return adler32_impl(adler, buffer, size); } advancecomp-1.23/libdeflate/adler32_impl.h000066400000000000000000000236411301462770100204470ustar00rootroot00000000000000/* * adler32_impl.h * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * This file contains a template for vectorized Adler-32 implementations. * * The inner loop between reductions modulo 65521 of an unvectorized Adler-32 * implementation looks something like this: * * do { * s1 += *p; * s2 += s1; * } while (++p != chunk_end); * * For vectorized calculation of s1, we only need to sum the input bytes. They * can be accumulated into multiple counters which are eventually summed * together. * * For vectorized calculation of s2, the basic idea is that for each iteration * that processes N bytes, we can perform the following vectorizable * calculation: * * s2 += N*byte_1 + (N-1)*byte_2 + (N-2)*byte_3 + ... + 1*byte_N * * Or, equivalently, we can sum the byte_1...byte_N for each iteration into N * separate counters, then do the multiplications by N...1 just once at the end * rather than once per iteration. * * Also, we must account for how previous bytes will affect s2 by doing the * following at beginning of each iteration: * * s2 += s1 * N * * Furthermore, like s1, "s2" can actually be multiple counters which are * eventually summed together. */ static u32 ATTRIBUTES FUNCNAME(u32 adler, const void *buffer, size_t size) { u32 s1 = adler & 0xFFFF; u32 s2 = adler >> 16; const u8 *p = buffer; const u8 * const end = p + size; const u8 *vend; /* Process a byte at a time until the required alignment is reached. */ if (p != end && (uintptr_t)p % ALIGNMENT_REQUIRED) { do { s1 += *p++; s2 += s1; } while (p != end && (uintptr_t)p % ALIGNMENT_REQUIRED); s1 %= DIVISOR; s2 %= DIVISOR; } /* * Process "chunks" of bytes using vector instructions. Chunk sizes are * limited to MAX_BYTES_PER_CHUNK, which guarantees that s1 and s2 never * overflow before being reduced modulo DIVISOR. For vector processing, * chunks size are also made evenly divisible by BYTES_PER_ITERATION. */ STATIC_ASSERT(BYTES_PER_ITERATION % ALIGNMENT_REQUIRED == 0); vend = end - ((size_t)(end - p) % BYTES_PER_ITERATION); while (p != vend) { size_t chunk_size; const u8 *chunk_end; chunk_size = MIN((size_t)(vend - p), MAX_BYTES_PER_CHUNK); #if TARGET == TARGET_SSE2 /* SSE2: the 16-bit precision byte counters must not undergo * *signed* overflow, otherwise the signed multiplication at the * end will not behave as desired. */ chunk_size = MIN(chunk_size, BYTES_PER_ITERATION * (0x7FFF / 0xFF)); #elif TARGET == TARGET_NEON /* NEON: the 16-bit precision counters must not undergo * *unsigned* overflow. */ chunk_size = MIN(chunk_size, BYTES_PER_ITERATION * (0xFFFF / 0xFF)); #endif chunk_size -= chunk_size % BYTES_PER_ITERATION; chunk_end = p + chunk_size; s2 += s1 * chunk_size; { #if TARGET == TARGET_AVX2 /* AVX2 implementation */ const __m256i zeroes = _mm256_setzero_si256(); const __v32qi multipliers = (__v32qi) { 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; const __v16hi ones = (__v16hi)_mm256_set1_epi16(1); __v8si v_s1 = (__v8si)zeroes; __v8si v_s1_sums = (__v8si)zeroes; __v8si v_s2 = (__v8si)zeroes; STATIC_ASSERT(ALIGNMENT_REQUIRED == 32 && BYTES_PER_ITERATION == 32); do { __m256i bytes = *(const __m256i *)p; __v16hi sums = (__v16hi)_mm256_maddubs_epi16( bytes, (__m256i)multipliers); v_s1_sums += v_s1; v_s1 += (__v8si)_mm256_sad_epu8(bytes, zeroes); v_s2 += (__v8si)_mm256_madd_epi16((__m256i)sums, (__m256i)ones); } while ((p += BYTES_PER_ITERATION) != chunk_end); v_s1 = (__v8si)_mm256_hadd_epi32((__m256i)v_s1, zeroes); v_s1 = (__v8si)_mm256_hadd_epi32((__m256i)v_s1, zeroes); s1 += v_s1[0] + v_s1[4]; v_s2 += (__v8si)_mm256_slli_epi32((__m256i)v_s1_sums, 5); v_s2 = (__v8si)_mm256_hadd_epi32((__m256i)v_s2, zeroes); v_s2 = (__v8si)_mm256_hadd_epi32((__m256i)v_s2, zeroes); s2 += v_s2[0] + v_s2[4]; #elif TARGET == TARGET_SSE2 /* SSE2 implementation */ const __m128i zeroes = _mm_setzero_si128(); /* s1 counters: 32-bit, sum of bytes */ __v4si v_s1 = (__v4si)zeroes; /* s2 counters: 32-bit, sum of s1 values */ __v4si v_s2 = (__v4si)zeroes; /* * Thirty-two 16-bit counters for byte sums. Each accumulates * the bytes that eventually need to be multiplied by a number * 32...1 for addition into s2. */ __v8hi v_byte_sums_a = (__v8hi)zeroes; __v8hi v_byte_sums_b = (__v8hi)zeroes; __v8hi v_byte_sums_c = (__v8hi)zeroes; __v8hi v_byte_sums_d = (__v8hi)zeroes; STATIC_ASSERT(ALIGNMENT_REQUIRED == 16 && BYTES_PER_ITERATION == 32); do { /* Load the next 32 bytes. */ const __m128i bytes1 = *(const __m128i *)p; const __m128i bytes2 = *(const __m128i *)(p + 16); /* * Accumulate the previous s1 counters into the s2 * counters. Logically, this really should be * v_s2 += v_s1 * BYTES_PER_ITERATION, but we can do the * multiplication (or left shift) later. */ v_s2 += v_s1; /* * s1 update: use "Packed Sum of Absolute Differences" * to add the bytes horizontally with 8 bytes per sum. * Then add the sums to the s1 counters. */ v_s1 += (__v4si)_mm_sad_epu8(bytes1, zeroes); v_s1 += (__v4si)_mm_sad_epu8(bytes2, zeroes); /* * Also accumulate the bytes into 32 separate counters * that have 16-bit precision. */ v_byte_sums_a += (__v8hi)_mm_unpacklo_epi8(bytes1, zeroes); v_byte_sums_b += (__v8hi)_mm_unpackhi_epi8(bytes1, zeroes); v_byte_sums_c += (__v8hi)_mm_unpacklo_epi8(bytes2, zeroes); v_byte_sums_d += (__v8hi)_mm_unpackhi_epi8(bytes2, zeroes); } while ((p += BYTES_PER_ITERATION) != chunk_end); /* Finish calculating the s2 counters. */ v_s2 = (__v4si)_mm_slli_epi32((__m128i)v_s2, 5); v_s2 += (__v4si)_mm_madd_epi16((__m128i)v_byte_sums_a, (__m128i)(__v8hi){ 32, 31, 30, 29, 28, 27, 26, 25 }); v_s2 += (__v4si)_mm_madd_epi16((__m128i)v_byte_sums_b, (__m128i)(__v8hi){ 24, 23, 22, 21, 20, 19, 18, 17 }); v_s2 += (__v4si)_mm_madd_epi16((__m128i)v_byte_sums_c, (__m128i)(__v8hi){ 16, 15, 14, 13, 12, 11, 10, 9 }); v_s2 += (__v4si)_mm_madd_epi16((__m128i)v_byte_sums_d, (__m128i)(__v8hi){ 8, 7, 6, 5, 4, 3, 2, 1 }); /* Now accumulate what we computed into the real s1 and s2. */ v_s1 += (__v4si)_mm_shuffle_epi32((__m128i)v_s1, 0x31); v_s1 += (__v4si)_mm_shuffle_epi32((__m128i)v_s1, 0x02); s1 += _mm_cvtsi128_si32((__m128i)v_s1); v_s2 += (__v4si)_mm_shuffle_epi32((__m128i)v_s2, 0x31); v_s2 += (__v4si)_mm_shuffle_epi32((__m128i)v_s2, 0x02); s2 += _mm_cvtsi128_si32((__m128i)v_s2); #elif TARGET == TARGET_NEON /* ARM NEON (Advanced SIMD) implementation */ uint32x4_t v_s1 = (uint32x4_t) { 0, 0, 0, 0 }; uint32x4_t v_s2 = (uint32x4_t) { 0, 0, 0, 0 }; uint16x8_t v_byte_sums_a = (uint16x8_t) { 0, 0, 0, 0, 0, 0, 0, 0 }; uint16x8_t v_byte_sums_b = (uint16x8_t) { 0, 0, 0, 0, 0, 0, 0, 0 }; uint16x8_t v_byte_sums_c = (uint16x8_t) { 0, 0, 0, 0, 0, 0, 0, 0 }; uint16x8_t v_byte_sums_d = (uint16x8_t) { 0, 0, 0, 0, 0, 0, 0, 0 }; STATIC_ASSERT(ALIGNMENT_REQUIRED == 16 && BYTES_PER_ITERATION == 32); do { const uint8x16_t bytes1 = *(const uint8x16_t *)p; const uint8x16_t bytes2 = *(const uint8x16_t *)(p + 16); uint16x8_t tmp; v_s2 += v_s1; tmp = vpaddlq_u8(bytes1); tmp = vpadalq_u8(tmp, bytes2); v_s1 = vpadalq_u16(v_s1, tmp); v_byte_sums_a = vaddw_u8(v_byte_sums_a, vget_low_u8(bytes1)); v_byte_sums_b = vaddw_u8(v_byte_sums_b, vget_high_u8(bytes1)); v_byte_sums_c = vaddw_u8(v_byte_sums_c, vget_low_u8(bytes2)); v_byte_sums_d = vaddw_u8(v_byte_sums_d, vget_high_u8(bytes2)); } while ((p += BYTES_PER_ITERATION) != chunk_end); v_s2 = vqshlq_n_u32(v_s2, 5); v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_a), (uint16x4_t) { 32, 31, 30, 29 }); v_s2 = vmlal_u16(v_s2, vget_high_u16(v_byte_sums_a), (uint16x4_t) { 28, 27, 26, 25 }); v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_b), (uint16x4_t) { 24, 23, 22, 21 }); v_s2 = vmlal_u16(v_s2, vget_high_u16(v_byte_sums_b), (uint16x4_t) { 20, 19, 18, 17 }); v_s2 = vmlal_u16(v_s2, vget_low_u16(v_byte_sums_c), (uint16x4_t) { 16, 15, 14, 13 }); v_s2 = vmlal_u16(v_s2, vget_high_u16(v_byte_sums_c), (uint16x4_t) { 12, 11, 10, 9 }); v_s2 = vmlal_u16(v_s2, vget_low_u16 (v_byte_sums_d), (uint16x4_t) { 8, 7, 6, 5 }); v_s2 = vmlal_u16(v_s2, vget_high_u16(v_byte_sums_d), (uint16x4_t) { 4, 3, 2, 1 }); s1 += v_s1[0] + v_s1[1] + v_s1[2] + v_s1[3]; s2 += v_s2[0] + v_s2[1] + v_s2[2] + v_s2[3]; #else # error "BUG: unknown target" #endif } s1 %= DIVISOR; s2 %= DIVISOR; } /* Process any remaining bytes. */ if (p != end) { do { s1 += *p++; s2 += s1; } while (p != end); s1 %= DIVISOR; s2 %= DIVISOR; } return (s2 << 16) | s1; } #undef FUNCNAME #undef TARGET #undef ALIGNMENT_REQUIRED #undef BYTES_PER_ITERATION #undef ATTRIBUTES advancecomp-1.23/libdeflate/aligned_malloc.c000066400000000000000000000034521301462770100211150ustar00rootroot00000000000000/* * aligned_malloc.c - aligned memory allocation * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * This file provides portable aligned memory allocation functions that only * use malloc() and free(). This avoids portability problems with * posix_memalign(), aligned_alloc(), etc. */ #include #include "aligned_malloc.h" void * aligned_malloc(size_t alignment, size_t size) { void *ptr = malloc(sizeof(void *) + alignment - 1 + size); if (ptr) { void *orig_ptr = ptr; ptr = (void *)ALIGN((uintptr_t)ptr + sizeof(void *), alignment); ((void **)ptr)[-1] = orig_ptr; } return ptr; } void aligned_free(void *ptr) { if (ptr) free(((void **)ptr)[-1]); } advancecomp-1.23/libdeflate/aligned_malloc.h000066400000000000000000000004201301462770100211120ustar00rootroot00000000000000/* * aligned_malloc.c - aligned memory allocation */ #ifndef LIB_ALIGNED_MALLOC_H #define LIB_ALIGNED_MALLOC_H #include "lib_common.h" extern void *aligned_malloc(size_t alignment, size_t size); extern void aligned_free(void *ptr); #endif /* LIB_ALIGNED_MALLOC_H */ advancecomp-1.23/libdeflate/bt_matchfinder.h000066400000000000000000000274301301462770100211430ustar00rootroot00000000000000/* * bt_matchfinder.h - Lempel-Ziv matchfinding with a hash table of binary trees * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * ---------------------------------------------------------------------------- * * This is a Binary Trees (bt) based matchfinder. * * The main data structure is a hash table where each hash bucket contains a * binary tree of sequences whose first 4 bytes share the same hash code. Each * sequence is identified by its starting position in the input buffer. Each * binary tree is always sorted such that each left child represents a sequence * lexicographically lesser than its parent and each right child represents a * sequence lexicographically greater than its parent. * * The algorithm processes the input buffer sequentially. At each byte * position, the hash code of the first 4 bytes of the sequence beginning at * that position (the sequence being matched against) is computed. This * identifies the hash bucket to use for that position. Then, a new binary tree * node is created to represent the current sequence. Then, in a single tree * traversal, the hash bucket's binary tree is searched for matches and is * re-rooted at the new node. * * Compared to the simpler algorithm that uses linked lists instead of binary * trees (see hc_matchfinder.h), the binary tree version gains more information * at each node visitation. Ideally, the binary tree version will examine only * 'log(n)' nodes to find the same matches that the linked list version will * find by examining 'n' nodes. In addition, the binary tree version can * examine fewer bytes at each node by taking advantage of the common prefixes * that result from the sort order, whereas the linked list version may have to * examine up to the full length of the match at each node. * * However, it is not always best to use the binary tree version. It requires * nearly twice as much memory as the linked list version, and it takes time to * keep the binary trees sorted, even at positions where the compressor does not * need matches. Generally, when doing fast compression on small buffers, * binary trees are the wrong approach. They are best suited for thorough * compression and/or large buffers. * * ---------------------------------------------------------------------------- */ #include "matchfinder_common.h" #define BT_MATCHFINDER_HASH3_ORDER 16 #define BT_MATCHFINDER_HASH3_WAYS 2 #define BT_MATCHFINDER_HASH4_ORDER 16 #define BT_MATCHFINDER_TOTAL_HASH_LENGTH \ ((1UL << BT_MATCHFINDER_HASH3_ORDER) * BT_MATCHFINDER_HASH3_WAYS + \ (1UL << BT_MATCHFINDER_HASH4_ORDER)) /* Representation of a match found by the bt_matchfinder */ struct lz_match { /* The number of bytes matched. */ u16 length; /* The offset back from the current position that was matched. */ u16 offset; }; struct bt_matchfinder { /* The hash table for finding length 3 matches */ mf_pos_t hash3_tab[1UL << BT_MATCHFINDER_HASH3_ORDER][BT_MATCHFINDER_HASH3_WAYS]; /* The hash table which contains the roots of the binary trees for * finding length 4+ matches */ mf_pos_t hash4_tab[1UL << BT_MATCHFINDER_HASH4_ORDER]; /* The child node references for the binary trees. The left and right * children of the node for the sequence with position 'pos' are * 'child_tab[pos * 2]' and 'child_tab[pos * 2 + 1]', respectively. */ mf_pos_t child_tab[2UL * MATCHFINDER_WINDOW_SIZE]; } #ifdef _aligned_attribute _aligned_attribute(MATCHFINDER_ALIGNMENT) #endif ; /* Prepare the matchfinder for a new input buffer. */ static forceinline void bt_matchfinder_init(struct bt_matchfinder *mf) { matchfinder_init((mf_pos_t *)mf, BT_MATCHFINDER_TOTAL_HASH_LENGTH); } static forceinline void bt_matchfinder_slide_window(struct bt_matchfinder *mf) { matchfinder_rebase((mf_pos_t *)mf, sizeof(struct bt_matchfinder) / sizeof(mf_pos_t)); } static forceinline mf_pos_t * bt_left_child(struct bt_matchfinder *mf, s32 node) { return &mf->child_tab[2 * (node & (MATCHFINDER_WINDOW_SIZE - 1)) + 0]; } static forceinline mf_pos_t * bt_right_child(struct bt_matchfinder *mf, s32 node) { return &mf->child_tab[2 * (node & (MATCHFINDER_WINDOW_SIZE - 1)) + 1]; } /* The minimum permissible value of 'max_len' for bt_matchfinder_get_matches() * and bt_matchfinder_skip_position(). There must be sufficiently many bytes * remaining to load a 32-bit integer from the *next* position. */ #define BT_MATCHFINDER_REQUIRED_NBYTES 5 /* Advance the binary tree matchfinder by one byte, optionally recording * matches. @record_matches should be a compile-time constant. */ static forceinline struct lz_match * bt_matchfinder_advance_one_byte(struct bt_matchfinder * const restrict mf, const u8 * const restrict in_base, const ptrdiff_t cur_pos, const u32 max_len, const u32 nice_len, const u32 max_search_depth, u32 * const restrict next_hashes, u32 * const restrict best_len_ret, struct lz_match * restrict lz_matchptr, const bool record_matches) { const u8 *in_next = in_base + cur_pos; u32 depth_remaining = max_search_depth; const s32 cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE; u32 next_seq4; u32 next_seq3; u32 hash3; u32 hash4; s32 cur_node; #if BT_MATCHFINDER_HASH3_WAYS >= 2 s32 cur_node_2; #endif const u8 *matchptr; mf_pos_t *pending_lt_ptr, *pending_gt_ptr; u32 best_lt_len, best_gt_len; u32 len; u32 best_len = 3; STATIC_ASSERT(BT_MATCHFINDER_HASH3_WAYS >= 1 && BT_MATCHFINDER_HASH3_WAYS <= 2); next_seq4 = load_u32_unaligned(in_next + 1); next_seq3 = loaded_u32_to_u24(next_seq4); hash3 = next_hashes[0]; hash4 = next_hashes[1]; next_hashes[0] = lz_hash(next_seq3, BT_MATCHFINDER_HASH3_ORDER); next_hashes[1] = lz_hash(next_seq4, BT_MATCHFINDER_HASH4_ORDER); prefetchw(&mf->hash3_tab[next_hashes[0]]); prefetchw(&mf->hash4_tab[next_hashes[1]]); cur_node = mf->hash3_tab[hash3][0]; mf->hash3_tab[hash3][0] = cur_pos; #if BT_MATCHFINDER_HASH3_WAYS >= 2 cur_node_2 = mf->hash3_tab[hash3][1]; mf->hash3_tab[hash3][1] = cur_node; #endif if (record_matches && cur_node > cutoff) { u32 seq3 = load_u24_unaligned(in_next); if (seq3 == load_u24_unaligned(&in_base[cur_node])) { lz_matchptr->length = 3; lz_matchptr->offset = in_next - &in_base[cur_node]; lz_matchptr++; } #if BT_MATCHFINDER_HASH3_WAYS >= 2 else if (cur_node_2 > cutoff && seq3 == load_u24_unaligned(&in_base[cur_node_2])) { lz_matchptr->length = 3; lz_matchptr->offset = in_next - &in_base[cur_node_2]; lz_matchptr++; } #endif } cur_node = mf->hash4_tab[hash4]; mf->hash4_tab[hash4] = cur_pos; pending_lt_ptr = bt_left_child(mf, cur_pos); pending_gt_ptr = bt_right_child(mf, cur_pos); if (cur_node <= cutoff) { *pending_lt_ptr = MATCHFINDER_INITVAL; *pending_gt_ptr = MATCHFINDER_INITVAL; *best_len_ret = best_len; return lz_matchptr; } best_lt_len = 0; best_gt_len = 0; len = 0; for (;;) { matchptr = &in_base[cur_node]; if (matchptr[len] == in_next[len]) { len = lz_extend(in_next, matchptr, len + 1, max_len); if (!record_matches || len > best_len) { if (record_matches) { best_len = len; lz_matchptr->length = len; lz_matchptr->offset = in_next - matchptr; lz_matchptr++; } if (len >= nice_len) { *pending_lt_ptr = *bt_left_child(mf, cur_node); *pending_gt_ptr = *bt_right_child(mf, cur_node); *best_len_ret = best_len; return lz_matchptr; } } } if (matchptr[len] < in_next[len]) { *pending_lt_ptr = cur_node; pending_lt_ptr = bt_right_child(mf, cur_node); cur_node = *pending_lt_ptr; best_lt_len = len; if (best_gt_len < len) len = best_gt_len; } else { *pending_gt_ptr = cur_node; pending_gt_ptr = bt_left_child(mf, cur_node); cur_node = *pending_gt_ptr; best_gt_len = len; if (best_lt_len < len) len = best_lt_len; } if (cur_node <= cutoff || !--depth_remaining) { *pending_lt_ptr = MATCHFINDER_INITVAL; *pending_gt_ptr = MATCHFINDER_INITVAL; *best_len_ret = best_len; return lz_matchptr; } } } /* * Retrieve a list of matches with the current position. * * @mf * The matchfinder structure. * @in_base * Pointer to the next byte in the input buffer to process _at the last * time bt_matchfinder_init() or bt_matchfinder_slide_window() was called_. * @cur_pos * The current position in the input buffer relative to @in_base (the * position of the sequence being matched against). * @max_len * The maximum permissible match length at this position. Must be >= * BT_MATCHFINDER_REQUIRED_NBYTES. * @nice_len * Stop searching if a match of at least this length is found. * Must be <= @max_len. * @max_search_depth * Limit on the number of potential matches to consider. Must be >= 1. * @next_hashes * The precomputed hash codes for the sequence beginning at @in_next. * These will be used and then updated with the precomputed hashcodes for * the sequence beginning at @in_next + 1. * @best_len_ret * If a match of length >= 4 was found, then the length of the longest such * match is written here; otherwise 3 is written here. (Note: this is * redundant with the 'struct lz_match' array, but this is easier for the * compiler to optimize when inlined and the caller immediately does a * check against 'best_len'.) * @lz_matchptr * An array in which this function will record the matches. The recorded * matches will be sorted by strictly increasing length and (non-strictly) * increasing offset. The maximum number of matches that may be found is * 'nice_len - 2'. * * The return value is a pointer to the next available slot in the @lz_matchptr * array. (If no matches were found, this will be the same as @lz_matchptr.) */ static forceinline struct lz_match * bt_matchfinder_get_matches(struct bt_matchfinder *mf, const u8 *in_base, ptrdiff_t cur_pos, u32 max_len, u32 nice_len, u32 max_search_depth, u32 next_hashes[2], u32 *best_len_ret, struct lz_match *lz_matchptr) { return bt_matchfinder_advance_one_byte(mf, in_base, cur_pos, max_len, nice_len, max_search_depth, next_hashes, best_len_ret, lz_matchptr, true); } /* * Advance the matchfinder, but don't record any matches. * * This is very similar to bt_matchfinder_get_matches() because both functions * must do hashing and tree re-rooting. */ static forceinline void bt_matchfinder_skip_position(struct bt_matchfinder *mf, const u8 *in_base, ptrdiff_t cur_pos, u32 nice_len, u32 max_search_depth, u32 next_hashes[2]) { u32 best_len; bt_matchfinder_advance_one_byte(mf, in_base, cur_pos, nice_len, nice_len, max_search_depth, next_hashes, &best_len, NULL, false); } advancecomp-1.23/libdeflate/common_defs.h000066400000000000000000000232521301462770100204610ustar00rootroot00000000000000/* * common_defs.h * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #ifndef COMMON_COMMON_DEFS_H #define COMMON_COMMON_DEFS_H #ifdef __GNUC__ # include "compiler_gcc.h" #elif defined(_MSC_VER) # include "compiler_msc.h" #else # pragma message("Unrecognized compiler. Please add a header file for your compiler. Compilation will proceed, but performance may suffer!") #endif /* ========================================================================== */ /* Type definitions */ /* ========================================================================== */ #include /* size_t */ #ifndef __bool_true_false_are_defined # include /* bool */ #endif /* Fixed-width integer types */ #ifndef PRIu32 # include #endif typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; typedef int8_t s8; typedef int16_t s16; typedef int32_t s32; typedef int64_t s64; /* * Word type of the target architecture. Use 'size_t' instead of 'unsigned * long' to account for platforms such as Windows that use 32-bit 'unsigned * long' on 64-bit architectures. */ typedef size_t machine_word_t; /* Number of bytes in a word */ #define WORDBYTES ((int)sizeof(machine_word_t)) /* Number of bits in a word */ #define WORDBITS (8 * WORDBYTES) /* ========================================================================== */ /* Optional compiler features */ /* ========================================================================== */ /* LIBEXPORT - export a function from a shared library */ #ifndef LIBEXPORT # define LIBEXPORT #endif /* inline - suggest that a function be inlined */ #ifndef inline # define inline #endif /* forceinline - force a function to be inlined, if possible */ #ifndef forceinline # define forceinline inline #endif /* restrict - annotate a non-aliased pointer */ #ifndef restrict # define restrict #endif /* likely(expr) - hint that an expression is usually true */ #ifndef likely # define likely(expr) (expr) #endif /* unlikely(expr) - hint that an expression is usually false */ #ifndef unlikely # define unlikely(expr) (expr) #endif /* prefetchr(addr) - prefetch into L1 cache for read */ #ifndef prefetchr # define prefetchr(addr) #endif /* prefetchw(addr) - prefetch into L1 cache for write */ #ifndef prefetchw # define prefetchw(addr) #endif /* Does the compiler support the 'target' function attribute? */ #ifndef COMPILER_SUPPORTS_TARGET_FUNCTION_ATTRIBUTE # define COMPILER_SUPPORTS_TARGET_FUNCTION_ATTRIBUTE 0 #endif /* Are target-specific intrinsics supported in 'target' attribute functions? */ #ifndef COMPILER_SUPPORTS_TARGET_INTRINSICS # define COMPILER_SUPPORTS_TARGET_INTRINSICS 0 #endif /* Which targets are supported with the 'target' function attribute? */ #ifndef COMPILER_SUPPORTS_PCLMUL_TARGET # define COMPILER_SUPPORTS_PCLMUL_TARGET 0 #endif #ifndef COMPILER_SUPPORTS_BMI2_TARGET # define COMPILER_SUPPORTS_BMI2_TARGET 0 #endif #ifndef COMPILER_SUPPORTS_AVX_TARGET # define COMPILER_SUPPORTS_AVX_TARGET 0 #endif #ifndef COMPILER_SUPPORTS_AVX2_TARGET # define COMPILER_SUPPORTS_AVX2_TARGET 0 #endif /* _aligned_attribute(n) - declare that the annotated variable, or variables of * the annotated type, are to be aligned on n-byte boundaries */ #ifndef _aligned_attribute #endif /* ========================================================================== */ /* Miscellaneous macros */ /* ========================================================================== */ #define ARRAY_LEN(A) (sizeof(A) / sizeof((A)[0])) #define MIN(a, b) ((a) <= (b) ? (a) : (b)) #define MAX(a, b) ((a) >= (b) ? (a) : (b)) #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d)) #define STATIC_ASSERT(expr) ((void)sizeof(char[1 - 2 * !(expr)])) #define ALIGN(n, a) (((n) + (a) - 1) & ~((a) - 1)) /* ========================================================================== */ /* Endianness handling */ /* ========================================================================== */ /* * CPU_IS_LITTLE_ENDIAN() - a macro which evaluates to 1 if the CPU is little * endian or 0 if it is big endian. The macro should be defined in a way such * that the compiler can evaluate it at compilation time. If not defined, a * fallback is used. */ #ifndef CPU_IS_LITTLE_ENDIAN static forceinline int CPU_IS_LITTLE_ENDIAN(void) { union { unsigned int v; unsigned char b; } u; u.v = 1; return u.b; } #endif /* bswap16(n) - swap the bytes of a 16-bit integer */ #ifndef bswap16 static forceinline u16 bswap16(u16 n) { return (n << 8) | (n >> 8); } #endif /* bswap32(n) - swap the bytes of a 32-bit integer */ #ifndef bswap32 static forceinline u32 bswap32(u32 n) { return ((n & 0x000000FF) << 24) | ((n & 0x0000FF00) << 8) | ((n & 0x00FF0000) >> 8) | ((n & 0xFF000000) >> 24); } #endif /* bswap64(n) - swap the bytes of a 64-bit integer */ #ifndef bswap64 static forceinline u64 bswap64(u64 n) { return ((n & 0x00000000000000FF) << 56) | ((n & 0x000000000000FF00) << 40) | ((n & 0x0000000000FF0000) << 24) | ((n & 0x00000000FF000000) << 8) | ((n & 0x000000FF00000000) >> 8) | ((n & 0x0000FF0000000000) >> 24) | ((n & 0x00FF000000000000) >> 40) | ((n & 0xFF00000000000000) >> 56); } #endif #define le16_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? (n) : bswap16(n)) #define le32_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? (n) : bswap32(n)) #define le64_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? (n) : bswap64(n)) #define be16_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? bswap16(n) : (n)) #define be32_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? bswap32(n) : (n)) #define be64_bswap(n) (CPU_IS_LITTLE_ENDIAN() ? bswap64(n) : (n)) /* ========================================================================== */ /* Unaligned memory accesses */ /* ========================================================================== */ /* * UNALIGNED_ACCESS_IS_FAST should be defined to 1 if unaligned memory accesses * can be performed efficiently on the target platform. */ #ifndef UNALIGNED_ACCESS_IS_FAST # define UNALIGNED_ACCESS_IS_FAST 0 #endif /* * DEFINE_UNALIGNED_TYPE(type) - a macro that, given an integer type 'type', * defines load_type_unaligned(addr) and store_type_unaligned(v, addr) functions * which load and store variables of type 'type' from/to unaligned memory * addresses. If not defined, a fallback is used. */ #ifndef DEFINE_UNALIGNED_TYPE /* * Although memcpy() may seem inefficient, it *usually* gets optimized * appropriately by modern compilers. It's portable and may be the best we can * do for a fallback... */ #include #define DEFINE_UNALIGNED_TYPE(type) \ \ static forceinline type \ load_##type##_unaligned(const void *p) \ { \ type v; \ memcpy(&v, p, sizeof(v)); \ return v; \ } \ \ static forceinline void \ store_##type##_unaligned(type v, void *p) \ { \ memcpy(p, &v, sizeof(v)); \ } #endif /* !DEFINE_UNALIGNED_TYPE */ /* ========================================================================== */ /* Bit scan functions */ /* ========================================================================== */ /* * Bit Scan Reverse (BSR) - find the 0-based index (relative to the least * significant end) of the *most* significant 1 bit in the input value. The * input value must be nonzero! */ #ifndef bsr32 static forceinline unsigned bsr32(u32 n) { unsigned i = 0; while ((n >>= 1) != 0) i++; return i; } #endif #ifndef bsr64 static forceinline unsigned bsr64(u64 n) { unsigned i = 0; while ((n >>= 1) != 0) i++; return i; } #endif static forceinline unsigned bsrw(machine_word_t n) { STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64); if (WORDBITS == 32) return bsr32(n); else return bsr64(n); } /* * Bit Scan Forward (BSF) - find the 0-based index (relative to the least * significant end) of the *least* significant 1 bit in the input value. The * input value must be nonzero! */ #ifndef bsf32 static forceinline unsigned bsf32(u32 n) { unsigned i = 0; while ((n & 1) == 0) { i++; n >>= 1; } return i; } #endif #ifndef bsf64 static forceinline unsigned bsf64(u64 n) { unsigned i = 0; while ((n & 1) == 0) { i++; n >>= 1; } return i; } #endif static forceinline unsigned bsfw(machine_word_t n) { STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64); if (WORDBITS == 32) return bsf32(n); else return bsf64(n); } #endif /* COMMON_COMMON_DEFS_H */ advancecomp-1.23/libdeflate/compiler_gcc.h000066400000000000000000000100151301462770100206070ustar00rootroot00000000000000/* * compiler_gcc.h - definitions for the GNU C Compiler. Currently this also * handles clang and the Intel C Compiler. */ #define GCC_PREREQ(major, minor) \ (__GNUC__ > (major) || \ (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) /* Note: only check the clang version when absolutely necessary! * "Vendors" such as Apple can use different version numbers. */ #ifdef __clang__ # ifdef __apple_build_version__ # define CLANG_PREREQ(major, minor, apple_version) \ (__apple_build_version__ >= (apple_version)) # else # define CLANG_PREREQ(major, minor, apple_version) \ (__clang_major__ > (major) || \ (__clang_major__ == (major) && __clang_minor__ >= (minor))) # endif #else # define CLANG_PREREQ(major, minor, apple_version) 0 #endif #ifndef __has_attribute # define __has_attribute(attribute) 0 #endif #ifndef __has_feature # define __has_feature(feature) 0 #endif #ifndef __has_builtin # define __has_builtin(builtin) 0 #endif #ifdef _WIN32 # define LIBEXPORT __declspec(dllexport) #else # define LIBEXPORT __attribute__((visibility("default"))) #endif #define inline inline #define forceinline inline __attribute__((always_inline)) #define restrict __restrict__ #define likely(expr) __builtin_expect(!!(expr), 1) #define unlikely(expr) __builtin_expect(!!(expr), 0) #define prefetchr(addr) __builtin_prefetch((addr), 0) #define prefetchw(addr) __builtin_prefetch((addr), 1) #define _aligned_attribute(n) __attribute__((aligned(n))) /* * Support for the following x86 instruction set extensions was introduced by * the following gcc versions: * * PCLMUL 4.4 * AVX 4.6 * BMI2 4.7 * AVX2 4.7 * * With clang, __has_builtin() can be used to detect the presence of one of the * associated builtins. * * Additionally, gcc 4.4 introduced the 'target' function attribute. With * clang, support for this can be detected with with __has_attribute(target). * * However, prior to gcc 4.9 and clang 3.8, x86 intrinsics not available in the * main target could not be used in 'target' attribute functions. Unfortunately * clang has no feature test macro for this so we have to check its version. */ #define COMPILER_SUPPORTS_TARGET_FUNCTION_ATTRIBUTE \ (GCC_PREREQ(4, 4) || __has_attribute(target)) #if COMPILER_SUPPORTS_TARGET_FUNCTION_ATTRIBUTE # define COMPILER_SUPPORTS_TARGET_INTRINSICS \ (GCC_PREREQ(4, 9) || CLANG_PREREQ(3, 8, 7030000)) # define COMPILER_SUPPORTS_PCLMUL_TARGET \ (GCC_PREREQ(4, 4) || __has_builtin(__builtin_ia32_pclmulqdq128)) # define COMPILER_SUPPORTS_AVX_TARGET \ (GCC_PREREQ(4, 6) || __has_builtin(__builtin_ia32_maxps256)) # define COMPILER_SUPPORTS_BMI2_TARGET \ (GCC_PREREQ(4, 7) || __has_builtin(__builtin_ia32_pdep_di)) # define COMPILER_SUPPORTS_AVX2_TARGET \ (GCC_PREREQ(4, 7) || __has_builtin(__builtin_ia32_pmaddwd256)) #endif /* Newer gcc supports __BYTE_ORDER__. Older gcc doesn't. */ #ifdef __BYTE_ORDER__ # define CPU_IS_LITTLE_ENDIAN() (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) #endif #if GCC_PREREQ(4, 8) || __has_builtin(__builtin_bswap16) # define bswap16 __builtin_bswap16 #endif #if GCC_PREREQ(4, 3) || __has_builtin(__builtin_bswap32) # define bswap32 __builtin_bswap32 #endif #if GCC_PREREQ(4, 3) || __has_builtin(__builtin_bswap64) # define bswap64 __builtin_bswap64 #endif #if defined(__x86_64__) || defined(__i386__) || defined(__ARM_FEATURE_UNALIGNED) # define UNALIGNED_ACCESS_IS_FAST 1 #endif /* With gcc, we can access unaligned memory through 'packed' structures. */ #define DEFINE_UNALIGNED_TYPE(type) \ \ struct type##unaligned { \ type v; \ } __attribute__((packed)); \ \ static forceinline type \ load_##type##_unaligned(const void *p) \ { \ return ((const struct type##unaligned *)p)->v; \ } \ \ static forceinline void \ store_##type##_unaligned(type v, void *p) \ { \ ((struct type##unaligned *)p)->v = v; \ } #define bsr32(n) (31 - __builtin_clz(n)) #define bsr64(n) (63 - __builtin_clzll(n)) #define bsf32(n) __builtin_ctz(n) #define bsf64(n) __builtin_ctzll(n) advancecomp-1.23/libdeflate/crc32.c000066400000000000000000000304251301462770100170770ustar00rootroot00000000000000/* * crc32.c - CRC-32 checksum algorithm for the gzip format * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * High-level description of CRC * ============================= * * Consider a bit sequence 'bits[1...len]'. Interpret 'bits' as the "message" * polynomial M(x) with coefficients in GF(2) (the field of integers modulo 2), * where the coefficient of 'x^i' is 'bits[len - i]'. Then, compute: * * R(x) = M(x)*x^n mod G(x) * * where G(x) is a selected "generator" polynomial of degree 'n'. The remainder * R(x) is a polynomial of max degree 'n - 1'. The CRC of 'bits' is R(x) * interpreted as a bitstring of length 'n'. * * CRC used in gzip * ================ * * In the gzip format (RFC 1952): * * - The bitstring to checksum is formed from the bytes of the uncompressed * data by concatenating the bits from the bytes in order, proceeding * from the low-order bit to the high-order bit within each byte. * * - The generator polynomial G(x) is: x^32 + x^26 + x^23 + x^22 + x^16 + * x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1. * Consequently, the CRC length is 32 bits ("CRC-32"). * * - The highest order 32 coefficients of M(x)*x^n are inverted. * * - All 32 coefficients of R(x) are inverted. * * The two inversions cause added leading and trailing zero bits to affect the * resulting CRC, whereas with a regular CRC such bits would have no effect on * the CRC. * * Computation and optimizations * ============================= * * We can compute R(x) through "long division", maintaining only 32 bits of * state at any given time. Multiplication by 'x' can be implemented as * right-shifting by 1 (assuming the polynomial<=>bitstring mapping where the * highest order bit represents the coefficient of x^0), and both addition and * subtraction can be implemented as bitwise exclusive OR (since we are working * in GF(2)). Here is an unoptimized implementation: * * static u32 crc32_gzip(const u8 *buffer, size_t nbytes) * { * u32 remainder = 0; * const u32 divisor = 0xEDB88320; * * for (size_t i = 0; i < nbytes * 8 + 32; i++) { * int bit; * u32 multiple; * * if (i < nbytes * 8) * bit = (buffer[i / 8] >> (i % 8)) & 1; * else * bit = 0; // one of the 32 appended 0 bits * * if (i < 32) // the first 32 bits are inverted * bit ^= 1; * * if (remainder & 1) * multiple = divisor; * else * multiple = 0; * * remainder >>= 1; * remainder |= (u32)bit << 31; * remainder ^= multiple; * } * * return ~remainder; * } * * In this implementation, the 32-bit integer 'remainder' maintains the * remainder of the currently processed portion of the message (with 32 zero * bits appended) when divided by the generator polynomial. 'remainder' is the * representation of R(x), and 'divisor' is the representation of G(x) excluding * the x^32 coefficient. For each bit to process, we multiply R(x) by 'x^1', * then add 'x^0' if the new bit is a 1. If this causes R(x) to gain a nonzero * x^32 term, then we subtract G(x) from R(x). * * We can speed this up by taking advantage of the fact that XOR is commutative * and associative, so the order in which we combine the inputs into 'remainder' * is unimportant. And since each message bit we add doesn't affect the choice * of 'multiple' until 32 bits later, we need not actually add each message bit * until that point: * * static u32 crc32_gzip(const u8 *buffer, size_t nbytes) * { * u32 remainder = ~0; * const u32 divisor = 0xEDB88320; * * for (size_t i = 0; i < nbytes * 8; i++) { * int bit; * u32 multiple; * * bit = (buffer[i / 8] >> (i % 8)) & 1; * remainder ^= bit; * if (remainder & 1) * multiple = divisor; * else * multiple = 0; * remainder >>= 1; * remainder ^= multiple; * } * * return ~remainder; * } * * With the above implementation we get the effect of 32 appended 0 bits for * free; they never affect the choice of a divisor, nor would they change the * value of 'remainder' if they were to be actually XOR'ed in. And by starting * with a remainder of all 1 bits, we get the effect of complementing the first * 32 message bits. * * The next optimization is to process the input in multi-bit units. Suppose * that we insert the next 'n' message bits into the remainder. Then we get an * intermediate remainder of length '32 + n' bits, and the CRC of the extra 'n' * bits is the amount by which the low 32 bits of the remainder will change as a * result of cancelling out those 'n' bits. Taking n=8 (one byte) and * precomputing a table containing the CRC of each possible byte, we get * crc32_slice1() defined below. * * As a further optimization, we could increase the multi-bit unit size to 16. * However, that is inefficient because the table size explodes from 256 entries * (1024 bytes) to 65536 entries (262144 bytes), which wastes memory and won't * fit in L1 cache on typical processors. * * However, we can actually process 4 bytes at a time using 4 different tables * with 256 entries each. Logically, we form a 64-bit intermediate remainder * and cancel out the high 32 bits in 8-bit chunks. Bits 32-39 are cancelled * out by the CRC of those bits, whereas bits 40-47 are be cancelled out by the * CRC of those bits with 8 zero bits appended, and so on. This method is * implemented in crc32_slice4(), defined below. * * In crc32_slice8(), this method is extended to 8 bytes at a time. The * intermediate remainder (which we never actually store explicitly) is 96 bits. * * On CPUs that support fast carryless multiplication, CRCs can be computed even * more quickly via "folding". See crc32_pclmul() for an example. */ #include "x86_cpu_features.h" #include "libdeflate.h" /* Select the implementations to compile in. */ #define NEED_GENERIC_IMPL 1 /* include generic impl unless overridden */ #define DEFAULT_IMPL crc32_slice8 /* Include the PCLMUL implementation? */ #define NEED_PCLMUL_IMPL 0 #if defined(__PCLMUL__) || \ (X86_CPU_FEATURES_ENABLED && COMPILER_SUPPORTS_PCLMUL_TARGET && \ COMPILER_SUPPORTS_TARGET_INTRINSICS) # include # undef NEED_PCLMUL_IMPL # define NEED_PCLMUL_IMPL 1 # ifdef __PCLMUL__ /* compiling for PCLMUL, i.e. can we assume it's there? */ # undef NEED_GENERIC_IMPL # define NEED_GENERIC_IMPL 0 /* generic impl not needed */ # undef DEFAULT_IMPL # define DEFAULT_IMPL crc32_pclmul # endif /* otherwise, we can build a PCLMUL version, but we won't know whether we can use it until runtime */ #endif /* * Include the PCLMUL/AVX implementation? Although our PCLMUL-optimized CRC-32 * function doesn't use any AVX intrinsics specifically, it can benefit a lot * from being compiled for an AVX target: on Skylake, ~16700 MB/s vs. ~10100 * MB/s. I expect this is related to the PCLMULQDQ instructions being assembled * in the newer three-operand form rather than the older two-operand form. * * Note: this is only needed if __AVX__ is *not* defined, since otherwise the * "regular" PCLMUL implementation would already be AVX enabled. */ #define NEED_PCLMUL_AVX_IMPL 0 #if NEED_PCLMUL_IMPL && !defined(__AVX__) && \ X86_CPU_FEATURES_ENABLED && COMPILER_SUPPORTS_AVX_TARGET # undef NEED_PCLMUL_AVX_IMPL # define NEED_PCLMUL_AVX_IMPL 1 #endif #define NUM_IMPLS (NEED_GENERIC_IMPL + NEED_PCLMUL_IMPL + NEED_PCLMUL_AVX_IMPL) /* Define the CRC-32 table */ #if NEED_GENERIC_IMPL # define CRC32_SLICE8 #else # define CRC32_SLICE1 /* only need short table for unaligned ends */ #endif #include "crc32_table.h" static forceinline u32 crc32_update_byte(u32 remainder, u8 next_byte) { return (remainder >> 8) ^ crc32_table[(u8)remainder ^ next_byte]; } #if defined(CRC32_SLICE1) || (NUM_IMPLS > NEED_GENERIC_IMPL) static u32 crc32_slice1(u32 remainder, const u8 *buffer, size_t nbytes) { size_t i; STATIC_ASSERT(ARRAY_LEN(crc32_table) >= 0x100); for (i = 0; i < nbytes; i++) remainder = crc32_update_byte(remainder, buffer[i]); return remainder; } #endif #ifdef CRC32_SLICE4 static u32 crc32_slice4(u32 remainder, const u8 *buffer, size_t nbytes) { const u8 *p = buffer; const u8 *end = buffer + nbytes; const u8 *end32; STATIC_ASSERT(ARRAY_LEN(crc32_table) >= 0x400); for (; ((uintptr_t)p & 3) && p != end; p++) remainder = crc32_update_byte(remainder, *p); end32 = p + ((end - p) & ~3); for (; p != end32; p += 4) { u32 v = le32_bswap(*(const u32 *)p); remainder = crc32_table[0x300 + (u8)((remainder ^ v) >> 0)] ^ crc32_table[0x200 + (u8)((remainder ^ v) >> 8)] ^ crc32_table[0x100 + (u8)((remainder ^ v) >> 16)] ^ crc32_table[0x000 + (u8)((remainder ^ v) >> 24)]; } for (; p != end; p++) remainder = crc32_update_byte(remainder, *p); return remainder; } #endif #ifdef CRC32_SLICE8 static u32 crc32_slice8(u32 remainder, const u8 *buffer, size_t nbytes) { const u8 *p = buffer; const u8 *end = buffer + nbytes; const u8 *end64; STATIC_ASSERT(ARRAY_LEN(crc32_table) >= 0x800); for (; ((uintptr_t)p & 7) && p != end; p++) remainder = crc32_update_byte(remainder, *p); end64 = p + ((end - p) & ~7); for (; p != end64; p += 8) { u32 v1 = le32_bswap(*(const u32 *)(p + 0)); u32 v2 = le32_bswap(*(const u32 *)(p + 4)); remainder = crc32_table[0x700 + (u8)((remainder ^ v1) >> 0)] ^ crc32_table[0x600 + (u8)((remainder ^ v1) >> 8)] ^ crc32_table[0x500 + (u8)((remainder ^ v1) >> 16)] ^ crc32_table[0x400 + (u8)((remainder ^ v1) >> 24)] ^ crc32_table[0x300 + (u8)(v2 >> 0)] ^ crc32_table[0x200 + (u8)(v2 >> 8)] ^ crc32_table[0x100 + (u8)(v2 >> 16)] ^ crc32_table[0x000 + (u8)(v2 >> 24)]; } for (; p != end; p++) remainder = crc32_update_byte(remainder, *p); return remainder; } #endif /* Define the PCLMUL implementation if needed. */ #if NEED_PCLMUL_IMPL # define FUNCNAME crc32_pclmul # define FUNCNAME_ALIGNED crc32_pclmul_aligned # ifdef __PCLMUL__ # define ATTRIBUTES # else # define ATTRIBUTES __attribute__((target("pclmul"))) # endif # include "crc32_impl.h" #endif /* Define the PCLMUL/AVX implementation if needed. */ #if NEED_PCLMUL_AVX_IMPL # define FUNCNAME crc32_pclmul_avx # define FUNCNAME_ALIGNED crc32_pclmul_avx_aligned # define ATTRIBUTES __attribute__((target("pclmul,avx"))) # include "crc32_impl.h" #endif typedef u32 (*crc32_func_t)(u32, const u8 *, size_t); /* * If multiple implementations are available, then dispatch among them based on * CPU features at runtime. Otherwise just call the single one directly. */ #if NUM_IMPLS == 1 # define crc32_impl DEFAULT_IMPL #else static u32 dispatch(u32, const u8 *, size_t); static crc32_func_t crc32_impl = dispatch; static u32 dispatch(u32 remainder, const u8 *buffer, size_t nbytes) { crc32_func_t f = DEFAULT_IMPL; #if NEED_PCLMUL_IMPL && !defined(__PCLMUL__) if (x86_have_cpu_features(X86_CPU_FEATURE_PCLMULQDQ)) f = crc32_pclmul; #endif #if NEED_PCLMUL_AVX_IMPL if (x86_have_cpu_features(X86_CPU_FEATURE_PCLMULQDQ | X86_CPU_FEATURE_AVX)) f = crc32_pclmul_avx; #endif crc32_impl = f; return crc32_impl(remainder, buffer, nbytes); } #endif /* NUM_IMPLS != 1 */ LIBDEFLATEAPI u32 libdeflate_crc32(u32 remainder, const void *buffer, size_t nbytes) { if (buffer == NULL) /* return initial value */ return 0; return ~crc32_impl(~remainder, buffer, nbytes); } advancecomp-1.23/libdeflate/crc32_impl.h000066400000000000000000000256211301462770100201270ustar00rootroot00000000000000/* * crc32_impl.h * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * CRC-32 folding with PCLMULQDQ. * * The basic idea is to repeatedly "fold" each 512 bits into the next 512 bits, * producing an abbreviated message which is congruent the original message * modulo the generator polynomial G(x). * * Folding each 512 bits is implemented as eight 64-bit folds, each of which * uses one carryless multiplication instruction. It's expected that CPUs may * be able to execute some of these multiplications in parallel. * * Explanation of "folding": let A(x) be 64 bits from the message, and let B(x) * be 95 bits from a constant distance D later in the message. The relevant * portion of the message can be written as: * * M(x) = A(x)*x^D + B(x) * * ... where + and * represent addition and multiplication, respectively, of * polynomials over GF(2). Note that when implemented on a computer, these * operations are equivalent to XOR and carryless multiplication, respectively. * * For the purpose of CRC calculation, only the remainder modulo the generator * polynomial G(x) matters: * * M(x) mod G(x) = (A(x)*x^D + B(x)) mod G(x) * * Since the modulo operation can be applied anywhere in a sequence of additions * and multiplications without affecting the result, this is equivalent to: * * M(x) mod G(x) = (A(x)*(x^D mod G(x)) + B(x)) mod G(x) * * For any D, 'x^D mod G(x)' will be a polynomial with maximum degree 31, i.e. * a 32-bit quantity. So 'A(x) * (x^D mod G(x))' is equivalent to a carryless * multiplication of a 64-bit quantity by a 32-bit quantity, producing a 95-bit * product. Then, adding (XOR-ing) the product to B(x) produces a polynomial * with the same length as B(x) but with the same remainder as 'A(x)*x^D + * B(x)'. This is the basic fold operation with 64 bits. * * Note that the carryless multiplication instruction PCLMULQDQ actually takes * two 64-bit inputs and produces a 127-bit product in the low-order bits of a * 128-bit XMM register. This works fine, but care must be taken to account for * "bit endianness". With the CRC version implemented here, bits are always * ordered such that the lowest-order bit represents the coefficient of highest * power of x and the highest-order bit represents the coefficient of the lowest * power of x. This is backwards from the more intuitive order. Still, * carryless multiplication works essentially the same either way. It just must * be accounted for that when we XOR the 95-bit product in the low-order 95 bits * of a 128-bit XMM register into 128-bits of later data held in another XMM * register, we'll really be XOR-ing the product into the mathematically higher * degree end of those later bits, not the lower degree end as may be expected. * * So given that caveat and the fact that we process 512 bits per iteration, the * 'D' values we need for the two 64-bit halves of each 128 bits of data are: * * D = (512 + 95) - 64 for the higher-degree half of each 128 bits, * i.e. the lower order bits in the XMM register * * D = (512 + 95) - 128 for the lower-degree half of each 128 bits, * i.e. the higher order bits in the XMM register * * The required 'x^D mod G(x)' values were precomputed. * * When <= 512 bits remain in the message, we finish up by folding across * smaller distances. This works similarly; the distance D is just different, * so different constant multipliers must be used. Finally, once the remaining * message is just 64 bits, it is is reduced to the CRC-32 using Barrett * reduction (explained later). * * For more information see the original paper from Intel: * "Fast CRC Computation for Generic Polynomials Using PCLMULQDQ Instruction" * December 2009 * http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf */ static u32 ATTRIBUTES FUNCNAME_ALIGNED(u32 remainder, const __m128i *p, size_t vec_count) { /* Constants precomputed by gen_crc32_multipliers.c. Do not edit! */ const __v2di multipliers_4 = (__v2di){ 0x8F352D95, 0x1D9513D7 }; const __v2di multipliers_2 = (__v2di){ 0xF1DA05AA, 0x81256527 }; const __v2di multipliers_1 = (__v2di){ 0xAE689191, 0xCCAA009E }; const __v2di final_multiplier = (__v2di){ 0xB8BC6765 }; const __m128i mask32 = (__m128i)(__v4si){ 0xFFFFFFFF }; const __v2di barrett_reduction_constants = (__v2di){ 0x00000001F7011641, 0x00000001DB710641 }; const __m128i * const end = p + vec_count; const __m128i * const end512 = p + (vec_count & ~3); __m128i x0, x1, x2, x3; /* * Account for the current 'remainder', i.e. the CRC of the part of the * message already processed. Explanation: rewrite the message * polynomial M(x) in terms of the first part A(x), the second part * B(x), and the length of the second part in bits |B(x)| >= 32: * * M(x) = A(x)*x^|B(x)| + B(x) * * Then the CRC of M(x) is: * * CRC(M(x)) = CRC(A(x)*x^|B(x)| + B(x)) * = CRC(A(x)*x^32*x^(|B(x)| - 32) + B(x)) * = CRC(CRC(A(x))*x^(|B(x)| - 32) + B(x)) * * Note: all arithmetic is modulo G(x), the generator polynomial; that's * why A(x)*x^32 can be replaced with CRC(A(x)) = A(x)*x^32 mod G(x). * * So the CRC of the full message is the CRC of the second part of the * message where the first 32 bits of the second part of the message * have been XOR'ed with the CRC of the first part of the message. */ x0 = *p++; x0 ^= (__m128i)(__v4si){ remainder }; if (p > end512) /* only 128, 256, or 384 bits of input? */ goto _128_bits_at_a_time; x1 = *p++; x2 = *p++; x3 = *p++; /* Fold 512 bits at a time */ for (; p != end512; p += 4) { __m128i y0, y1, y2, y3; y0 = p[0]; y1 = p[1]; y2 = p[2]; y3 = p[3]; /* * Note: the immediate constant for PCLMULQDQ specifies which * 64-bit halves of the 128-bit vectors to multiply: * * 0x00 means low halves (higher degree polynomial terms for us) * 0x11 means high halves (lower degree polynomial terms for us) */ y0 ^= _mm_clmulepi64_si128(x0, multipliers_4, 0x00); y1 ^= _mm_clmulepi64_si128(x1, multipliers_4, 0x00); y2 ^= _mm_clmulepi64_si128(x2, multipliers_4, 0x00); y3 ^= _mm_clmulepi64_si128(x3, multipliers_4, 0x00); y0 ^= _mm_clmulepi64_si128(x0, multipliers_4, 0x11); y1 ^= _mm_clmulepi64_si128(x1, multipliers_4, 0x11); y2 ^= _mm_clmulepi64_si128(x2, multipliers_4, 0x11); y3 ^= _mm_clmulepi64_si128(x3, multipliers_4, 0x11); x0 = y0; x1 = y1; x2 = y2; x3 = y3; } /* Fold 512 bits => 128 bits */ x2 ^= _mm_clmulepi64_si128(x0, multipliers_2, 0x00); x3 ^= _mm_clmulepi64_si128(x1, multipliers_2, 0x00); x2 ^= _mm_clmulepi64_si128(x0, multipliers_2, 0x11); x3 ^= _mm_clmulepi64_si128(x1, multipliers_2, 0x11); x3 ^= _mm_clmulepi64_si128(x2, multipliers_1, 0x00); x3 ^= _mm_clmulepi64_si128(x2, multipliers_1, 0x11); x0 = x3; _128_bits_at_a_time: while (p != end) { /* Fold 128 bits into next 128 bits */ x1 = *p++; x1 ^= _mm_clmulepi64_si128(x0, multipliers_1, 0x00); x1 ^= _mm_clmulepi64_si128(x0, multipliers_1, 0x11); x0 = x1; } /* Now there are just 128 bits left, stored in 'x0'. */ /* * Fold 128 => 96 bits. This also implicitly appends 32 zero bits, * which is equivalent to multiplying by x^32. This is needed because * the CRC is defined as M(x)*x^32 mod G(x), not just M(x) mod G(x). */ x0 = _mm_srli_si128(x0, 8) ^ _mm_clmulepi64_si128(x0, multipliers_1, 0x10); /* Fold 96 => 64 bits */ x0 = _mm_srli_si128(x0, 4) ^ _mm_clmulepi64_si128(x0 & mask32, final_multiplier, 0x00); /* * Finally, reduce 64 => 32 bits using Barrett reduction. * * Let M(x) = A(x)*x^32 + B(x) be the remaining message. The goal is to * compute R(x) = M(x) mod G(x). Since degree(B(x)) < degree(G(x)): * * R(x) = (A(x)*x^32 + B(x)) mod G(x) * = (A(x)*x^32) mod G(x) + B(x) * * Then, by the Division Algorithm there exists a unique q(x) such that: * * A(x)*x^32 mod G(x) = A(x)*x^32 - q(x)*G(x) * * Since the left-hand side is of maximum degree 31, the right-hand side * must be too. This implies that we can apply 'mod x^32' to the * right-hand side without changing its value: * * (A(x)*x^32 - q(x)*G(x)) mod x^32 = q(x)*G(x) mod x^32 * * Note that '+' is equivalent to '-' in polynomials over GF(2). * * We also know that: * * / A(x)*x^32 \ * q(x) = floor ( --------- ) * \ G(x) / * * To compute this efficiently, we can multiply the top and bottom by * x^32 and move the division by G(x) to the top: * * / A(x) * floor(x^64 / G(x)) \ * q(x) = floor ( ------------------------- ) * \ x^32 / * * Note that floor(x^64 / G(x)) is a constant. * * So finally we have: * * / A(x) * floor(x^64 / G(x)) \ * R(x) = B(x) + G(x)*floor ( ------------------------- ) * \ x^32 / */ x1 = x0; x0 = _mm_clmulepi64_si128(x0 & mask32, barrett_reduction_constants, 0x00); x0 = _mm_clmulepi64_si128(x0 & mask32, barrett_reduction_constants, 0x10); return _mm_cvtsi128_si32(_mm_srli_si128(x0 ^ x1, 4)); } /* * Fast CRC-32 implementation for x86_64 processors that have the carryless * multiplication extension (PCLMUL). * * Note: on unaligned ends of the buffer, we fall back to crc32_slice1() instead * of crc32_slice8() because only a few bytes need to be processed, so a smaller * table is preferable. */ static u32 ATTRIBUTES FUNCNAME(u32 remainder, const u8 *buffer, size_t nbytes) { if ((uintptr_t)buffer & 15) { size_t n = MIN(nbytes, -(uintptr_t)buffer & 15); remainder = crc32_slice1(remainder, buffer, n); buffer += n; nbytes -= n; } if (nbytes >= 16) { remainder = FUNCNAME_ALIGNED(remainder, (const __m128i *)buffer, nbytes / 16); buffer += nbytes & ~15; nbytes &= 15; } return crc32_slice1(remainder, buffer, nbytes); } #undef FUNCNAME #undef FUNCNAME_ALIGNED #undef ATTRIBUTES advancecomp-1.23/libdeflate/crc32_table.h000066400000000000000000000615501301462770100202560ustar00rootroot00000000000000/* * crc32_table.h - data table to accelerate CRC-32 computation * * THIS FILE WAS AUTOMATICALLY GENERATED BY gen_crc32_table.c. DO NOT EDIT. */ #include static const uint32_t crc32_table[] = { 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, #if defined(CRC32_SLICE4) || defined(CRC32_SLICE8) 0x00000000, 0x191b3141, 0x32366282, 0x2b2d53c3, 0x646cc504, 0x7d77f445, 0x565aa786, 0x4f4196c7, 0xc8d98a08, 0xd1c2bb49, 0xfaefe88a, 0xe3f4d9cb, 0xacb54f0c, 0xb5ae7e4d, 0x9e832d8e, 0x87981ccf, 0x4ac21251, 0x53d92310, 0x78f470d3, 0x61ef4192, 0x2eaed755, 0x37b5e614, 0x1c98b5d7, 0x05838496, 0x821b9859, 0x9b00a918, 0xb02dfadb, 0xa936cb9a, 0xe6775d5d, 0xff6c6c1c, 0xd4413fdf, 0xcd5a0e9e, 0x958424a2, 0x8c9f15e3, 0xa7b24620, 0xbea97761, 0xf1e8e1a6, 0xe8f3d0e7, 0xc3de8324, 0xdac5b265, 0x5d5daeaa, 0x44469feb, 0x6f6bcc28, 0x7670fd69, 0x39316bae, 0x202a5aef, 0x0b07092c, 0x121c386d, 0xdf4636f3, 0xc65d07b2, 0xed705471, 0xf46b6530, 0xbb2af3f7, 0xa231c2b6, 0x891c9175, 0x9007a034, 0x179fbcfb, 0x0e848dba, 0x25a9de79, 0x3cb2ef38, 0x73f379ff, 0x6ae848be, 0x41c51b7d, 0x58de2a3c, 0xf0794f05, 0xe9627e44, 0xc24f2d87, 0xdb541cc6, 0x94158a01, 0x8d0ebb40, 0xa623e883, 0xbf38d9c2, 0x38a0c50d, 0x21bbf44c, 0x0a96a78f, 0x138d96ce, 0x5ccc0009, 0x45d73148, 0x6efa628b, 0x77e153ca, 0xbabb5d54, 0xa3a06c15, 0x888d3fd6, 0x91960e97, 0xded79850, 0xc7cca911, 0xece1fad2, 0xf5facb93, 0x7262d75c, 0x6b79e61d, 0x4054b5de, 0x594f849f, 0x160e1258, 0x0f152319, 0x243870da, 0x3d23419b, 0x65fd6ba7, 0x7ce65ae6, 0x57cb0925, 0x4ed03864, 0x0191aea3, 0x188a9fe2, 0x33a7cc21, 0x2abcfd60, 0xad24e1af, 0xb43fd0ee, 0x9f12832d, 0x8609b26c, 0xc94824ab, 0xd05315ea, 0xfb7e4629, 0xe2657768, 0x2f3f79f6, 0x362448b7, 0x1d091b74, 0x04122a35, 0x4b53bcf2, 0x52488db3, 0x7965de70, 0x607eef31, 0xe7e6f3fe, 0xfefdc2bf, 0xd5d0917c, 0xcccba03d, 0x838a36fa, 0x9a9107bb, 0xb1bc5478, 0xa8a76539, 0x3b83984b, 0x2298a90a, 0x09b5fac9, 0x10aecb88, 0x5fef5d4f, 0x46f46c0e, 0x6dd93fcd, 0x74c20e8c, 0xf35a1243, 0xea412302, 0xc16c70c1, 0xd8774180, 0x9736d747, 0x8e2de606, 0xa500b5c5, 0xbc1b8484, 0x71418a1a, 0x685abb5b, 0x4377e898, 0x5a6cd9d9, 0x152d4f1e, 0x0c367e5f, 0x271b2d9c, 0x3e001cdd, 0xb9980012, 0xa0833153, 0x8bae6290, 0x92b553d1, 0xddf4c516, 0xc4eff457, 0xefc2a794, 0xf6d996d5, 0xae07bce9, 0xb71c8da8, 0x9c31de6b, 0x852aef2a, 0xca6b79ed, 0xd37048ac, 0xf85d1b6f, 0xe1462a2e, 0x66de36e1, 0x7fc507a0, 0x54e85463, 0x4df36522, 0x02b2f3e5, 0x1ba9c2a4, 0x30849167, 0x299fa026, 0xe4c5aeb8, 0xfdde9ff9, 0xd6f3cc3a, 0xcfe8fd7b, 0x80a96bbc, 0x99b25afd, 0xb29f093e, 0xab84387f, 0x2c1c24b0, 0x350715f1, 0x1e2a4632, 0x07317773, 0x4870e1b4, 0x516bd0f5, 0x7a468336, 0x635db277, 0xcbfad74e, 0xd2e1e60f, 0xf9ccb5cc, 0xe0d7848d, 0xaf96124a, 0xb68d230b, 0x9da070c8, 0x84bb4189, 0x03235d46, 0x1a386c07, 0x31153fc4, 0x280e0e85, 0x674f9842, 0x7e54a903, 0x5579fac0, 0x4c62cb81, 0x8138c51f, 0x9823f45e, 0xb30ea79d, 0xaa1596dc, 0xe554001b, 0xfc4f315a, 0xd7626299, 0xce7953d8, 0x49e14f17, 0x50fa7e56, 0x7bd72d95, 0x62cc1cd4, 0x2d8d8a13, 0x3496bb52, 0x1fbbe891, 0x06a0d9d0, 0x5e7ef3ec, 0x4765c2ad, 0x6c48916e, 0x7553a02f, 0x3a1236e8, 0x230907a9, 0x0824546a, 0x113f652b, 0x96a779e4, 0x8fbc48a5, 0xa4911b66, 0xbd8a2a27, 0xf2cbbce0, 0xebd08da1, 0xc0fdde62, 0xd9e6ef23, 0x14bce1bd, 0x0da7d0fc, 0x268a833f, 0x3f91b27e, 0x70d024b9, 0x69cb15f8, 0x42e6463b, 0x5bfd777a, 0xdc656bb5, 0xc57e5af4, 0xee530937, 0xf7483876, 0xb809aeb1, 0xa1129ff0, 0x8a3fcc33, 0x9324fd72, 0x00000000, 0x01c26a37, 0x0384d46e, 0x0246be59, 0x0709a8dc, 0x06cbc2eb, 0x048d7cb2, 0x054f1685, 0x0e1351b8, 0x0fd13b8f, 0x0d9785d6, 0x0c55efe1, 0x091af964, 0x08d89353, 0x0a9e2d0a, 0x0b5c473d, 0x1c26a370, 0x1de4c947, 0x1fa2771e, 0x1e601d29, 0x1b2f0bac, 0x1aed619b, 0x18abdfc2, 0x1969b5f5, 0x1235f2c8, 0x13f798ff, 0x11b126a6, 0x10734c91, 0x153c5a14, 0x14fe3023, 0x16b88e7a, 0x177ae44d, 0x384d46e0, 0x398f2cd7, 0x3bc9928e, 0x3a0bf8b9, 0x3f44ee3c, 0x3e86840b, 0x3cc03a52, 0x3d025065, 0x365e1758, 0x379c7d6f, 0x35dac336, 0x3418a901, 0x3157bf84, 0x3095d5b3, 0x32d36bea, 0x331101dd, 0x246be590, 0x25a98fa7, 0x27ef31fe, 0x262d5bc9, 0x23624d4c, 0x22a0277b, 0x20e69922, 0x2124f315, 0x2a78b428, 0x2bbade1f, 0x29fc6046, 0x283e0a71, 0x2d711cf4, 0x2cb376c3, 0x2ef5c89a, 0x2f37a2ad, 0x709a8dc0, 0x7158e7f7, 0x731e59ae, 0x72dc3399, 0x7793251c, 0x76514f2b, 0x7417f172, 0x75d59b45, 0x7e89dc78, 0x7f4bb64f, 0x7d0d0816, 0x7ccf6221, 0x798074a4, 0x78421e93, 0x7a04a0ca, 0x7bc6cafd, 0x6cbc2eb0, 0x6d7e4487, 0x6f38fade, 0x6efa90e9, 0x6bb5866c, 0x6a77ec5b, 0x68315202, 0x69f33835, 0x62af7f08, 0x636d153f, 0x612bab66, 0x60e9c151, 0x65a6d7d4, 0x6464bde3, 0x662203ba, 0x67e0698d, 0x48d7cb20, 0x4915a117, 0x4b531f4e, 0x4a917579, 0x4fde63fc, 0x4e1c09cb, 0x4c5ab792, 0x4d98dda5, 0x46c49a98, 0x4706f0af, 0x45404ef6, 0x448224c1, 0x41cd3244, 0x400f5873, 0x4249e62a, 0x438b8c1d, 0x54f16850, 0x55330267, 0x5775bc3e, 0x56b7d609, 0x53f8c08c, 0x523aaabb, 0x507c14e2, 0x51be7ed5, 0x5ae239e8, 0x5b2053df, 0x5966ed86, 0x58a487b1, 0x5deb9134, 0x5c29fb03, 0x5e6f455a, 0x5fad2f6d, 0xe1351b80, 0xe0f771b7, 0xe2b1cfee, 0xe373a5d9, 0xe63cb35c, 0xe7fed96b, 0xe5b86732, 0xe47a0d05, 0xef264a38, 0xeee4200f, 0xeca29e56, 0xed60f461, 0xe82fe2e4, 0xe9ed88d3, 0xebab368a, 0xea695cbd, 0xfd13b8f0, 0xfcd1d2c7, 0xfe976c9e, 0xff5506a9, 0xfa1a102c, 0xfbd87a1b, 0xf99ec442, 0xf85cae75, 0xf300e948, 0xf2c2837f, 0xf0843d26, 0xf1465711, 0xf4094194, 0xf5cb2ba3, 0xf78d95fa, 0xf64fffcd, 0xd9785d60, 0xd8ba3757, 0xdafc890e, 0xdb3ee339, 0xde71f5bc, 0xdfb39f8b, 0xddf521d2, 0xdc374be5, 0xd76b0cd8, 0xd6a966ef, 0xd4efd8b6, 0xd52db281, 0xd062a404, 0xd1a0ce33, 0xd3e6706a, 0xd2241a5d, 0xc55efe10, 0xc49c9427, 0xc6da2a7e, 0xc7184049, 0xc25756cc, 0xc3953cfb, 0xc1d382a2, 0xc011e895, 0xcb4dafa8, 0xca8fc59f, 0xc8c97bc6, 0xc90b11f1, 0xcc440774, 0xcd866d43, 0xcfc0d31a, 0xce02b92d, 0x91af9640, 0x906dfc77, 0x922b422e, 0x93e92819, 0x96a63e9c, 0x976454ab, 0x9522eaf2, 0x94e080c5, 0x9fbcc7f8, 0x9e7eadcf, 0x9c381396, 0x9dfa79a1, 0x98b56f24, 0x99770513, 0x9b31bb4a, 0x9af3d17d, 0x8d893530, 0x8c4b5f07, 0x8e0de15e, 0x8fcf8b69, 0x8a809dec, 0x8b42f7db, 0x89044982, 0x88c623b5, 0x839a6488, 0x82580ebf, 0x801eb0e6, 0x81dcdad1, 0x8493cc54, 0x8551a663, 0x8717183a, 0x86d5720d, 0xa9e2d0a0, 0xa820ba97, 0xaa6604ce, 0xaba46ef9, 0xaeeb787c, 0xaf29124b, 0xad6fac12, 0xacadc625, 0xa7f18118, 0xa633eb2f, 0xa4755576, 0xa5b73f41, 0xa0f829c4, 0xa13a43f3, 0xa37cfdaa, 0xa2be979d, 0xb5c473d0, 0xb40619e7, 0xb640a7be, 0xb782cd89, 0xb2cddb0c, 0xb30fb13b, 0xb1490f62, 0xb08b6555, 0xbbd72268, 0xba15485f, 0xb853f606, 0xb9919c31, 0xbcde8ab4, 0xbd1ce083, 0xbf5a5eda, 0xbe9834ed, 0x00000000, 0xb8bc6765, 0xaa09c88b, 0x12b5afee, 0x8f629757, 0x37def032, 0x256b5fdc, 0x9dd738b9, 0xc5b428ef, 0x7d084f8a, 0x6fbde064, 0xd7018701, 0x4ad6bfb8, 0xf26ad8dd, 0xe0df7733, 0x58631056, 0x5019579f, 0xe8a530fa, 0xfa109f14, 0x42acf871, 0xdf7bc0c8, 0x67c7a7ad, 0x75720843, 0xcdce6f26, 0x95ad7f70, 0x2d111815, 0x3fa4b7fb, 0x8718d09e, 0x1acfe827, 0xa2738f42, 0xb0c620ac, 0x087a47c9, 0xa032af3e, 0x188ec85b, 0x0a3b67b5, 0xb28700d0, 0x2f503869, 0x97ec5f0c, 0x8559f0e2, 0x3de59787, 0x658687d1, 0xdd3ae0b4, 0xcf8f4f5a, 0x7733283f, 0xeae41086, 0x525877e3, 0x40edd80d, 0xf851bf68, 0xf02bf8a1, 0x48979fc4, 0x5a22302a, 0xe29e574f, 0x7f496ff6, 0xc7f50893, 0xd540a77d, 0x6dfcc018, 0x359fd04e, 0x8d23b72b, 0x9f9618c5, 0x272a7fa0, 0xbafd4719, 0x0241207c, 0x10f48f92, 0xa848e8f7, 0x9b14583d, 0x23a83f58, 0x311d90b6, 0x89a1f7d3, 0x1476cf6a, 0xaccaa80f, 0xbe7f07e1, 0x06c36084, 0x5ea070d2, 0xe61c17b7, 0xf4a9b859, 0x4c15df3c, 0xd1c2e785, 0x697e80e0, 0x7bcb2f0e, 0xc377486b, 0xcb0d0fa2, 0x73b168c7, 0x6104c729, 0xd9b8a04c, 0x446f98f5, 0xfcd3ff90, 0xee66507e, 0x56da371b, 0x0eb9274d, 0xb6054028, 0xa4b0efc6, 0x1c0c88a3, 0x81dbb01a, 0x3967d77f, 0x2bd27891, 0x936e1ff4, 0x3b26f703, 0x839a9066, 0x912f3f88, 0x299358ed, 0xb4446054, 0x0cf80731, 0x1e4da8df, 0xa6f1cfba, 0xfe92dfec, 0x462eb889, 0x549b1767, 0xec277002, 0x71f048bb, 0xc94c2fde, 0xdbf98030, 0x6345e755, 0x6b3fa09c, 0xd383c7f9, 0xc1366817, 0x798a0f72, 0xe45d37cb, 0x5ce150ae, 0x4e54ff40, 0xf6e89825, 0xae8b8873, 0x1637ef16, 0x048240f8, 0xbc3e279d, 0x21e91f24, 0x99557841, 0x8be0d7af, 0x335cb0ca, 0xed59b63b, 0x55e5d15e, 0x47507eb0, 0xffec19d5, 0x623b216c, 0xda874609, 0xc832e9e7, 0x708e8e82, 0x28ed9ed4, 0x9051f9b1, 0x82e4565f, 0x3a58313a, 0xa78f0983, 0x1f336ee6, 0x0d86c108, 0xb53aa66d, 0xbd40e1a4, 0x05fc86c1, 0x1749292f, 0xaff54e4a, 0x322276f3, 0x8a9e1196, 0x982bbe78, 0x2097d91d, 0x78f4c94b, 0xc048ae2e, 0xd2fd01c0, 0x6a4166a5, 0xf7965e1c, 0x4f2a3979, 0x5d9f9697, 0xe523f1f2, 0x4d6b1905, 0xf5d77e60, 0xe762d18e, 0x5fdeb6eb, 0xc2098e52, 0x7ab5e937, 0x680046d9, 0xd0bc21bc, 0x88df31ea, 0x3063568f, 0x22d6f961, 0x9a6a9e04, 0x07bda6bd, 0xbf01c1d8, 0xadb46e36, 0x15080953, 0x1d724e9a, 0xa5ce29ff, 0xb77b8611, 0x0fc7e174, 0x9210d9cd, 0x2aacbea8, 0x38191146, 0x80a57623, 0xd8c66675, 0x607a0110, 0x72cfaefe, 0xca73c99b, 0x57a4f122, 0xef189647, 0xfdad39a9, 0x45115ecc, 0x764dee06, 0xcef18963, 0xdc44268d, 0x64f841e8, 0xf92f7951, 0x41931e34, 0x5326b1da, 0xeb9ad6bf, 0xb3f9c6e9, 0x0b45a18c, 0x19f00e62, 0xa14c6907, 0x3c9b51be, 0x842736db, 0x96929935, 0x2e2efe50, 0x2654b999, 0x9ee8defc, 0x8c5d7112, 0x34e11677, 0xa9362ece, 0x118a49ab, 0x033fe645, 0xbb838120, 0xe3e09176, 0x5b5cf613, 0x49e959fd, 0xf1553e98, 0x6c820621, 0xd43e6144, 0xc68bceaa, 0x7e37a9cf, 0xd67f4138, 0x6ec3265d, 0x7c7689b3, 0xc4caeed6, 0x591dd66f, 0xe1a1b10a, 0xf3141ee4, 0x4ba87981, 0x13cb69d7, 0xab770eb2, 0xb9c2a15c, 0x017ec639, 0x9ca9fe80, 0x241599e5, 0x36a0360b, 0x8e1c516e, 0x866616a7, 0x3eda71c2, 0x2c6fde2c, 0x94d3b949, 0x090481f0, 0xb1b8e695, 0xa30d497b, 0x1bb12e1e, 0x43d23e48, 0xfb6e592d, 0xe9dbf6c3, 0x516791a6, 0xccb0a91f, 0x740cce7a, 0x66b96194, 0xde0506f1, #endif /* CRC32_SLICE4 || CRC32_SLICE8 */ #if defined(CRC32_SLICE8) 0x00000000, 0x3d6029b0, 0x7ac05360, 0x47a07ad0, 0xf580a6c0, 0xc8e08f70, 0x8f40f5a0, 0xb220dc10, 0x30704bc1, 0x0d106271, 0x4ab018a1, 0x77d03111, 0xc5f0ed01, 0xf890c4b1, 0xbf30be61, 0x825097d1, 0x60e09782, 0x5d80be32, 0x1a20c4e2, 0x2740ed52, 0x95603142, 0xa80018f2, 0xefa06222, 0xd2c04b92, 0x5090dc43, 0x6df0f5f3, 0x2a508f23, 0x1730a693, 0xa5107a83, 0x98705333, 0xdfd029e3, 0xe2b00053, 0xc1c12f04, 0xfca106b4, 0xbb017c64, 0x866155d4, 0x344189c4, 0x0921a074, 0x4e81daa4, 0x73e1f314, 0xf1b164c5, 0xccd14d75, 0x8b7137a5, 0xb6111e15, 0x0431c205, 0x3951ebb5, 0x7ef19165, 0x4391b8d5, 0xa121b886, 0x9c419136, 0xdbe1ebe6, 0xe681c256, 0x54a11e46, 0x69c137f6, 0x2e614d26, 0x13016496, 0x9151f347, 0xac31daf7, 0xeb91a027, 0xd6f18997, 0x64d15587, 0x59b17c37, 0x1e1106e7, 0x23712f57, 0x58f35849, 0x659371f9, 0x22330b29, 0x1f532299, 0xad73fe89, 0x9013d739, 0xd7b3ade9, 0xead38459, 0x68831388, 0x55e33a38, 0x124340e8, 0x2f236958, 0x9d03b548, 0xa0639cf8, 0xe7c3e628, 0xdaa3cf98, 0x3813cfcb, 0x0573e67b, 0x42d39cab, 0x7fb3b51b, 0xcd93690b, 0xf0f340bb, 0xb7533a6b, 0x8a3313db, 0x0863840a, 0x3503adba, 0x72a3d76a, 0x4fc3feda, 0xfde322ca, 0xc0830b7a, 0x872371aa, 0xba43581a, 0x9932774d, 0xa4525efd, 0xe3f2242d, 0xde920d9d, 0x6cb2d18d, 0x51d2f83d, 0x167282ed, 0x2b12ab5d, 0xa9423c8c, 0x9422153c, 0xd3826fec, 0xeee2465c, 0x5cc29a4c, 0x61a2b3fc, 0x2602c92c, 0x1b62e09c, 0xf9d2e0cf, 0xc4b2c97f, 0x8312b3af, 0xbe729a1f, 0x0c52460f, 0x31326fbf, 0x7692156f, 0x4bf23cdf, 0xc9a2ab0e, 0xf4c282be, 0xb362f86e, 0x8e02d1de, 0x3c220dce, 0x0142247e, 0x46e25eae, 0x7b82771e, 0xb1e6b092, 0x8c869922, 0xcb26e3f2, 0xf646ca42, 0x44661652, 0x79063fe2, 0x3ea64532, 0x03c66c82, 0x8196fb53, 0xbcf6d2e3, 0xfb56a833, 0xc6368183, 0x74165d93, 0x49767423, 0x0ed60ef3, 0x33b62743, 0xd1062710, 0xec660ea0, 0xabc67470, 0x96a65dc0, 0x248681d0, 0x19e6a860, 0x5e46d2b0, 0x6326fb00, 0xe1766cd1, 0xdc164561, 0x9bb63fb1, 0xa6d61601, 0x14f6ca11, 0x2996e3a1, 0x6e369971, 0x5356b0c1, 0x70279f96, 0x4d47b626, 0x0ae7ccf6, 0x3787e546, 0x85a73956, 0xb8c710e6, 0xff676a36, 0xc2074386, 0x4057d457, 0x7d37fde7, 0x3a978737, 0x07f7ae87, 0xb5d77297, 0x88b75b27, 0xcf1721f7, 0xf2770847, 0x10c70814, 0x2da721a4, 0x6a075b74, 0x576772c4, 0xe547aed4, 0xd8278764, 0x9f87fdb4, 0xa2e7d404, 0x20b743d5, 0x1dd76a65, 0x5a7710b5, 0x67173905, 0xd537e515, 0xe857cca5, 0xaff7b675, 0x92979fc5, 0xe915e8db, 0xd475c16b, 0x93d5bbbb, 0xaeb5920b, 0x1c954e1b, 0x21f567ab, 0x66551d7b, 0x5b3534cb, 0xd965a31a, 0xe4058aaa, 0xa3a5f07a, 0x9ec5d9ca, 0x2ce505da, 0x11852c6a, 0x562556ba, 0x6b457f0a, 0x89f57f59, 0xb49556e9, 0xf3352c39, 0xce550589, 0x7c75d999, 0x4115f029, 0x06b58af9, 0x3bd5a349, 0xb9853498, 0x84e51d28, 0xc34567f8, 0xfe254e48, 0x4c059258, 0x7165bbe8, 0x36c5c138, 0x0ba5e888, 0x28d4c7df, 0x15b4ee6f, 0x521494bf, 0x6f74bd0f, 0xdd54611f, 0xe03448af, 0xa794327f, 0x9af41bcf, 0x18a48c1e, 0x25c4a5ae, 0x6264df7e, 0x5f04f6ce, 0xed242ade, 0xd044036e, 0x97e479be, 0xaa84500e, 0x4834505d, 0x755479ed, 0x32f4033d, 0x0f942a8d, 0xbdb4f69d, 0x80d4df2d, 0xc774a5fd, 0xfa148c4d, 0x78441b9c, 0x4524322c, 0x028448fc, 0x3fe4614c, 0x8dc4bd5c, 0xb0a494ec, 0xf704ee3c, 0xca64c78c, 0x00000000, 0xcb5cd3a5, 0x4dc8a10b, 0x869472ae, 0x9b914216, 0x50cd91b3, 0xd659e31d, 0x1d0530b8, 0xec53826d, 0x270f51c8, 0xa19b2366, 0x6ac7f0c3, 0x77c2c07b, 0xbc9e13de, 0x3a0a6170, 0xf156b2d5, 0x03d6029b, 0xc88ad13e, 0x4e1ea390, 0x85427035, 0x9847408d, 0x531b9328, 0xd58fe186, 0x1ed33223, 0xef8580f6, 0x24d95353, 0xa24d21fd, 0x6911f258, 0x7414c2e0, 0xbf481145, 0x39dc63eb, 0xf280b04e, 0x07ac0536, 0xccf0d693, 0x4a64a43d, 0x81387798, 0x9c3d4720, 0x57619485, 0xd1f5e62b, 0x1aa9358e, 0xebff875b, 0x20a354fe, 0xa6372650, 0x6d6bf5f5, 0x706ec54d, 0xbb3216e8, 0x3da66446, 0xf6fab7e3, 0x047a07ad, 0xcf26d408, 0x49b2a6a6, 0x82ee7503, 0x9feb45bb, 0x54b7961e, 0xd223e4b0, 0x197f3715, 0xe82985c0, 0x23755665, 0xa5e124cb, 0x6ebdf76e, 0x73b8c7d6, 0xb8e41473, 0x3e7066dd, 0xf52cb578, 0x0f580a6c, 0xc404d9c9, 0x4290ab67, 0x89cc78c2, 0x94c9487a, 0x5f959bdf, 0xd901e971, 0x125d3ad4, 0xe30b8801, 0x28575ba4, 0xaec3290a, 0x659ffaaf, 0x789aca17, 0xb3c619b2, 0x35526b1c, 0xfe0eb8b9, 0x0c8e08f7, 0xc7d2db52, 0x4146a9fc, 0x8a1a7a59, 0x971f4ae1, 0x5c439944, 0xdad7ebea, 0x118b384f, 0xe0dd8a9a, 0x2b81593f, 0xad152b91, 0x6649f834, 0x7b4cc88c, 0xb0101b29, 0x36846987, 0xfdd8ba22, 0x08f40f5a, 0xc3a8dcff, 0x453cae51, 0x8e607df4, 0x93654d4c, 0x58399ee9, 0xdeadec47, 0x15f13fe2, 0xe4a78d37, 0x2ffb5e92, 0xa96f2c3c, 0x6233ff99, 0x7f36cf21, 0xb46a1c84, 0x32fe6e2a, 0xf9a2bd8f, 0x0b220dc1, 0xc07ede64, 0x46eaacca, 0x8db67f6f, 0x90b34fd7, 0x5bef9c72, 0xdd7beedc, 0x16273d79, 0xe7718fac, 0x2c2d5c09, 0xaab92ea7, 0x61e5fd02, 0x7ce0cdba, 0xb7bc1e1f, 0x31286cb1, 0xfa74bf14, 0x1eb014d8, 0xd5ecc77d, 0x5378b5d3, 0x98246676, 0x852156ce, 0x4e7d856b, 0xc8e9f7c5, 0x03b52460, 0xf2e396b5, 0x39bf4510, 0xbf2b37be, 0x7477e41b, 0x6972d4a3, 0xa22e0706, 0x24ba75a8, 0xefe6a60d, 0x1d661643, 0xd63ac5e6, 0x50aeb748, 0x9bf264ed, 0x86f75455, 0x4dab87f0, 0xcb3ff55e, 0x006326fb, 0xf135942e, 0x3a69478b, 0xbcfd3525, 0x77a1e680, 0x6aa4d638, 0xa1f8059d, 0x276c7733, 0xec30a496, 0x191c11ee, 0xd240c24b, 0x54d4b0e5, 0x9f886340, 0x828d53f8, 0x49d1805d, 0xcf45f2f3, 0x04192156, 0xf54f9383, 0x3e134026, 0xb8873288, 0x73dbe12d, 0x6eded195, 0xa5820230, 0x2316709e, 0xe84aa33b, 0x1aca1375, 0xd196c0d0, 0x5702b27e, 0x9c5e61db, 0x815b5163, 0x4a0782c6, 0xcc93f068, 0x07cf23cd, 0xf6999118, 0x3dc542bd, 0xbb513013, 0x700de3b6, 0x6d08d30e, 0xa65400ab, 0x20c07205, 0xeb9ca1a0, 0x11e81eb4, 0xdab4cd11, 0x5c20bfbf, 0x977c6c1a, 0x8a795ca2, 0x41258f07, 0xc7b1fda9, 0x0ced2e0c, 0xfdbb9cd9, 0x36e74f7c, 0xb0733dd2, 0x7b2fee77, 0x662adecf, 0xad760d6a, 0x2be27fc4, 0xe0beac61, 0x123e1c2f, 0xd962cf8a, 0x5ff6bd24, 0x94aa6e81, 0x89af5e39, 0x42f38d9c, 0xc467ff32, 0x0f3b2c97, 0xfe6d9e42, 0x35314de7, 0xb3a53f49, 0x78f9ecec, 0x65fcdc54, 0xaea00ff1, 0x28347d5f, 0xe368aefa, 0x16441b82, 0xdd18c827, 0x5b8cba89, 0x90d0692c, 0x8dd55994, 0x46898a31, 0xc01df89f, 0x0b412b3a, 0xfa1799ef, 0x314b4a4a, 0xb7df38e4, 0x7c83eb41, 0x6186dbf9, 0xaada085c, 0x2c4e7af2, 0xe712a957, 0x15921919, 0xdececabc, 0x585ab812, 0x93066bb7, 0x8e035b0f, 0x455f88aa, 0xc3cbfa04, 0x089729a1, 0xf9c19b74, 0x329d48d1, 0xb4093a7f, 0x7f55e9da, 0x6250d962, 0xa90c0ac7, 0x2f987869, 0xe4c4abcc, 0x00000000, 0xa6770bb4, 0x979f1129, 0x31e81a9d, 0xf44f2413, 0x52382fa7, 0x63d0353a, 0xc5a73e8e, 0x33ef4e67, 0x959845d3, 0xa4705f4e, 0x020754fa, 0xc7a06a74, 0x61d761c0, 0x503f7b5d, 0xf64870e9, 0x67de9cce, 0xc1a9977a, 0xf0418de7, 0x56368653, 0x9391b8dd, 0x35e6b369, 0x040ea9f4, 0xa279a240, 0x5431d2a9, 0xf246d91d, 0xc3aec380, 0x65d9c834, 0xa07ef6ba, 0x0609fd0e, 0x37e1e793, 0x9196ec27, 0xcfbd399c, 0x69ca3228, 0x582228b5, 0xfe552301, 0x3bf21d8f, 0x9d85163b, 0xac6d0ca6, 0x0a1a0712, 0xfc5277fb, 0x5a257c4f, 0x6bcd66d2, 0xcdba6d66, 0x081d53e8, 0xae6a585c, 0x9f8242c1, 0x39f54975, 0xa863a552, 0x0e14aee6, 0x3ffcb47b, 0x998bbfcf, 0x5c2c8141, 0xfa5b8af5, 0xcbb39068, 0x6dc49bdc, 0x9b8ceb35, 0x3dfbe081, 0x0c13fa1c, 0xaa64f1a8, 0x6fc3cf26, 0xc9b4c492, 0xf85cde0f, 0x5e2bd5bb, 0x440b7579, 0xe27c7ecd, 0xd3946450, 0x75e36fe4, 0xb044516a, 0x16335ade, 0x27db4043, 0x81ac4bf7, 0x77e43b1e, 0xd19330aa, 0xe07b2a37, 0x460c2183, 0x83ab1f0d, 0x25dc14b9, 0x14340e24, 0xb2430590, 0x23d5e9b7, 0x85a2e203, 0xb44af89e, 0x123df32a, 0xd79acda4, 0x71edc610, 0x4005dc8d, 0xe672d739, 0x103aa7d0, 0xb64dac64, 0x87a5b6f9, 0x21d2bd4d, 0xe47583c3, 0x42028877, 0x73ea92ea, 0xd59d995e, 0x8bb64ce5, 0x2dc14751, 0x1c295dcc, 0xba5e5678, 0x7ff968f6, 0xd98e6342, 0xe86679df, 0x4e11726b, 0xb8590282, 0x1e2e0936, 0x2fc613ab, 0x89b1181f, 0x4c162691, 0xea612d25, 0xdb8937b8, 0x7dfe3c0c, 0xec68d02b, 0x4a1fdb9f, 0x7bf7c102, 0xdd80cab6, 0x1827f438, 0xbe50ff8c, 0x8fb8e511, 0x29cfeea5, 0xdf879e4c, 0x79f095f8, 0x48188f65, 0xee6f84d1, 0x2bc8ba5f, 0x8dbfb1eb, 0xbc57ab76, 0x1a20a0c2, 0x8816eaf2, 0x2e61e146, 0x1f89fbdb, 0xb9fef06f, 0x7c59cee1, 0xda2ec555, 0xebc6dfc8, 0x4db1d47c, 0xbbf9a495, 0x1d8eaf21, 0x2c66b5bc, 0x8a11be08, 0x4fb68086, 0xe9c18b32, 0xd82991af, 0x7e5e9a1b, 0xefc8763c, 0x49bf7d88, 0x78576715, 0xde206ca1, 0x1b87522f, 0xbdf0599b, 0x8c184306, 0x2a6f48b2, 0xdc27385b, 0x7a5033ef, 0x4bb82972, 0xedcf22c6, 0x28681c48, 0x8e1f17fc, 0xbff70d61, 0x198006d5, 0x47abd36e, 0xe1dcd8da, 0xd034c247, 0x7643c9f3, 0xb3e4f77d, 0x1593fcc9, 0x247be654, 0x820cede0, 0x74449d09, 0xd23396bd, 0xe3db8c20, 0x45ac8794, 0x800bb91a, 0x267cb2ae, 0x1794a833, 0xb1e3a387, 0x20754fa0, 0x86024414, 0xb7ea5e89, 0x119d553d, 0xd43a6bb3, 0x724d6007, 0x43a57a9a, 0xe5d2712e, 0x139a01c7, 0xb5ed0a73, 0x840510ee, 0x22721b5a, 0xe7d525d4, 0x41a22e60, 0x704a34fd, 0xd63d3f49, 0xcc1d9f8b, 0x6a6a943f, 0x5b828ea2, 0xfdf58516, 0x3852bb98, 0x9e25b02c, 0xafcdaab1, 0x09baa105, 0xfff2d1ec, 0x5985da58, 0x686dc0c5, 0xce1acb71, 0x0bbdf5ff, 0xadcafe4b, 0x9c22e4d6, 0x3a55ef62, 0xabc30345, 0x0db408f1, 0x3c5c126c, 0x9a2b19d8, 0x5f8c2756, 0xf9fb2ce2, 0xc813367f, 0x6e643dcb, 0x982c4d22, 0x3e5b4696, 0x0fb35c0b, 0xa9c457bf, 0x6c636931, 0xca146285, 0xfbfc7818, 0x5d8b73ac, 0x03a0a617, 0xa5d7ada3, 0x943fb73e, 0x3248bc8a, 0xf7ef8204, 0x519889b0, 0x6070932d, 0xc6079899, 0x304fe870, 0x9638e3c4, 0xa7d0f959, 0x01a7f2ed, 0xc400cc63, 0x6277c7d7, 0x539fdd4a, 0xf5e8d6fe, 0x647e3ad9, 0xc209316d, 0xf3e12bf0, 0x55962044, 0x90311eca, 0x3646157e, 0x07ae0fe3, 0xa1d90457, 0x579174be, 0xf1e67f0a, 0xc00e6597, 0x66796e23, 0xa3de50ad, 0x05a95b19, 0x34414184, 0x92364a30, 0x00000000, 0xccaa009e, 0x4225077d, 0x8e8f07e3, 0x844a0efa, 0x48e00e64, 0xc66f0987, 0x0ac50919, 0xd3e51bb5, 0x1f4f1b2b, 0x91c01cc8, 0x5d6a1c56, 0x57af154f, 0x9b0515d1, 0x158a1232, 0xd92012ac, 0x7cbb312b, 0xb01131b5, 0x3e9e3656, 0xf23436c8, 0xf8f13fd1, 0x345b3f4f, 0xbad438ac, 0x767e3832, 0xaf5e2a9e, 0x63f42a00, 0xed7b2de3, 0x21d12d7d, 0x2b142464, 0xe7be24fa, 0x69312319, 0xa59b2387, 0xf9766256, 0x35dc62c8, 0xbb53652b, 0x77f965b5, 0x7d3c6cac, 0xb1966c32, 0x3f196bd1, 0xf3b36b4f, 0x2a9379e3, 0xe639797d, 0x68b67e9e, 0xa41c7e00, 0xaed97719, 0x62737787, 0xecfc7064, 0x205670fa, 0x85cd537d, 0x496753e3, 0xc7e85400, 0x0b42549e, 0x01875d87, 0xcd2d5d19, 0x43a25afa, 0x8f085a64, 0x562848c8, 0x9a824856, 0x140d4fb5, 0xd8a74f2b, 0xd2624632, 0x1ec846ac, 0x9047414f, 0x5ced41d1, 0x299dc2ed, 0xe537c273, 0x6bb8c590, 0xa712c50e, 0xadd7cc17, 0x617dcc89, 0xeff2cb6a, 0x2358cbf4, 0xfa78d958, 0x36d2d9c6, 0xb85dde25, 0x74f7debb, 0x7e32d7a2, 0xb298d73c, 0x3c17d0df, 0xf0bdd041, 0x5526f3c6, 0x998cf358, 0x1703f4bb, 0xdba9f425, 0xd16cfd3c, 0x1dc6fda2, 0x9349fa41, 0x5fe3fadf, 0x86c3e873, 0x4a69e8ed, 0xc4e6ef0e, 0x084cef90, 0x0289e689, 0xce23e617, 0x40ace1f4, 0x8c06e16a, 0xd0eba0bb, 0x1c41a025, 0x92cea7c6, 0x5e64a758, 0x54a1ae41, 0x980baedf, 0x1684a93c, 0xda2ea9a2, 0x030ebb0e, 0xcfa4bb90, 0x412bbc73, 0x8d81bced, 0x8744b5f4, 0x4beeb56a, 0xc561b289, 0x09cbb217, 0xac509190, 0x60fa910e, 0xee7596ed, 0x22df9673, 0x281a9f6a, 0xe4b09ff4, 0x6a3f9817, 0xa6959889, 0x7fb58a25, 0xb31f8abb, 0x3d908d58, 0xf13a8dc6, 0xfbff84df, 0x37558441, 0xb9da83a2, 0x7570833c, 0x533b85da, 0x9f918544, 0x111e82a7, 0xddb48239, 0xd7718b20, 0x1bdb8bbe, 0x95548c5d, 0x59fe8cc3, 0x80de9e6f, 0x4c749ef1, 0xc2fb9912, 0x0e51998c, 0x04949095, 0xc83e900b, 0x46b197e8, 0x8a1b9776, 0x2f80b4f1, 0xe32ab46f, 0x6da5b38c, 0xa10fb312, 0xabcaba0b, 0x6760ba95, 0xe9efbd76, 0x2545bde8, 0xfc65af44, 0x30cfafda, 0xbe40a839, 0x72eaa8a7, 0x782fa1be, 0xb485a120, 0x3a0aa6c3, 0xf6a0a65d, 0xaa4de78c, 0x66e7e712, 0xe868e0f1, 0x24c2e06f, 0x2e07e976, 0xe2ade9e8, 0x6c22ee0b, 0xa088ee95, 0x79a8fc39, 0xb502fca7, 0x3b8dfb44, 0xf727fbda, 0xfde2f2c3, 0x3148f25d, 0xbfc7f5be, 0x736df520, 0xd6f6d6a7, 0x1a5cd639, 0x94d3d1da, 0x5879d144, 0x52bcd85d, 0x9e16d8c3, 0x1099df20, 0xdc33dfbe, 0x0513cd12, 0xc9b9cd8c, 0x4736ca6f, 0x8b9ccaf1, 0x8159c3e8, 0x4df3c376, 0xc37cc495, 0x0fd6c40b, 0x7aa64737, 0xb60c47a9, 0x3883404a, 0xf42940d4, 0xfeec49cd, 0x32464953, 0xbcc94eb0, 0x70634e2e, 0xa9435c82, 0x65e95c1c, 0xeb665bff, 0x27cc5b61, 0x2d095278, 0xe1a352e6, 0x6f2c5505, 0xa386559b, 0x061d761c, 0xcab77682, 0x44387161, 0x889271ff, 0x825778e6, 0x4efd7878, 0xc0727f9b, 0x0cd87f05, 0xd5f86da9, 0x19526d37, 0x97dd6ad4, 0x5b776a4a, 0x51b26353, 0x9d1863cd, 0x1397642e, 0xdf3d64b0, 0x83d02561, 0x4f7a25ff, 0xc1f5221c, 0x0d5f2282, 0x079a2b9b, 0xcb302b05, 0x45bf2ce6, 0x89152c78, 0x50353ed4, 0x9c9f3e4a, 0x121039a9, 0xdeba3937, 0xd47f302e, 0x18d530b0, 0x965a3753, 0x5af037cd, 0xff6b144a, 0x33c114d4, 0xbd4e1337, 0x71e413a9, 0x7b211ab0, 0xb78b1a2e, 0x39041dcd, 0xf5ae1d53, 0x2c8e0fff, 0xe0240f61, 0x6eab0882, 0xa201081c, 0xa8c40105, 0x646e019b, 0xeae10678, 0x264b06e6, #endif /* CRC32_SLICE8 */ }; advancecomp-1.23/libdeflate/decompress_impl.h000066400000000000000000000276751301462770100213720ustar00rootroot00000000000000/* * decompress_impl.h * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * This is the actual DEFLATE decompression routine, lifted out of * deflate_decompress.c so that it can be compiled multiple times with different * target instruction sets. */ static enum libdeflate_result ATTRIBUTES FUNCNAME(struct libdeflate_decompressor * restrict d, const void * restrict in, size_t in_nbytes, void * restrict out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret) { u8 *out_next = out; u8 * const out_end = out_next + out_nbytes_avail; const u8 *in_next = in; const u8 * const in_end = in_next + in_nbytes; bitbuf_t bitbuf = 0; unsigned bitsleft = 0; size_t overrun_count = 0; unsigned i; unsigned is_final_block; unsigned block_type; u16 len; u16 nlen; unsigned num_litlen_syms; unsigned num_offset_syms; u16 tmp16; u32 tmp32; next_block: /* Starting to read the next block. */ ; STATIC_ASSERT(CAN_ENSURE(1 + 2 + 5 + 5 + 4)); ENSURE_BITS(1 + 2 + 5 + 5 + 4); /* BFINAL: 1 bit */ is_final_block = POP_BITS(1); /* BTYPE: 2 bits */ block_type = POP_BITS(2); if (block_type == DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN) { /* Dynamic Huffman block. */ /* The order in which precode lengths are stored. */ static const u8 deflate_precode_lens_permutation[DEFLATE_NUM_PRECODE_SYMS] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; unsigned num_explicit_precode_lens; /* Read the codeword length counts. */ STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == ((1 << 5) - 1) + 257); num_litlen_syms = POP_BITS(5) + 257; STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == ((1 << 5) - 1) + 1); num_offset_syms = POP_BITS(5) + 1; STATIC_ASSERT(DEFLATE_NUM_PRECODE_SYMS == ((1 << 4) - 1) + 4); num_explicit_precode_lens = POP_BITS(4) + 4; /* Read the precode codeword lengths. */ STATIC_ASSERT(DEFLATE_MAX_PRE_CODEWORD_LEN == (1 << 3) - 1); if (CAN_ENSURE(DEFLATE_NUM_PRECODE_SYMS * 3)) { ENSURE_BITS(DEFLATE_NUM_PRECODE_SYMS * 3); for (i = 0; i < num_explicit_precode_lens; i++) d->u.precode_lens[deflate_precode_lens_permutation[i]] = POP_BITS(3); } else { for (i = 0; i < num_explicit_precode_lens; i++) { ENSURE_BITS(3); d->u.precode_lens[deflate_precode_lens_permutation[i]] = POP_BITS(3); } } for (; i < DEFLATE_NUM_PRECODE_SYMS; i++) d->u.precode_lens[deflate_precode_lens_permutation[i]] = 0; /* Build the decode table for the precode. */ SAFETY_CHECK(build_precode_decode_table(d)); /* Expand the literal/length and offset codeword lengths. */ for (i = 0; i < num_litlen_syms + num_offset_syms; ) { u32 entry; unsigned presym; u8 rep_val; unsigned rep_count; ENSURE_BITS(DEFLATE_MAX_PRE_CODEWORD_LEN + 7); /* (The code below assumes that the precode decode table * does not have any subtables.) */ STATIC_ASSERT(PRECODE_TABLEBITS == DEFLATE_MAX_PRE_CODEWORD_LEN); /* Read the next precode symbol. */ entry = d->u.l.precode_decode_table[BITS(DEFLATE_MAX_PRE_CODEWORD_LEN)]; REMOVE_BITS(entry & HUFFDEC_LENGTH_MASK); presym = entry >> HUFFDEC_RESULT_SHIFT; if (presym < 16) { /* Explicit codeword length */ d->u.l.lens[i++] = presym; continue; } /* Run-length encoded codeword lengths */ /* Note: we don't need verify that the repeat count * doesn't overflow the number of elements, since we * have enough extra spaces to allow for the worst-case * overflow (138 zeroes when only 1 length was * remaining). * * In the case of the small repeat counts (presyms 16 * and 17), it is fastest to always write the maximum * number of entries. That gets rid of branches that * would otherwise be required. * * It is not just because of the numerical order that * our checks go in the order 'presym < 16', 'presym == * 16', and 'presym == 17'. For typical data this is * ordered from most frequent to least frequent case. */ STATIC_ASSERT(DEFLATE_MAX_LENS_OVERRUN == 138 - 1); if (presym == 16) { /* Repeat the previous length 3 - 6 times */ SAFETY_CHECK(i != 0); rep_val = d->u.l.lens[i - 1]; STATIC_ASSERT(3 + ((1 << 2) - 1) == 6); rep_count = 3 + POP_BITS(2); d->u.l.lens[i + 0] = rep_val; d->u.l.lens[i + 1] = rep_val; d->u.l.lens[i + 2] = rep_val; d->u.l.lens[i + 3] = rep_val; d->u.l.lens[i + 4] = rep_val; d->u.l.lens[i + 5] = rep_val; i += rep_count; } else if (presym == 17) { /* Repeat zero 3 - 10 times */ STATIC_ASSERT(3 + ((1 << 3) - 1) == 10); rep_count = 3 + POP_BITS(3); d->u.l.lens[i + 0] = 0; d->u.l.lens[i + 1] = 0; d->u.l.lens[i + 2] = 0; d->u.l.lens[i + 3] = 0; d->u.l.lens[i + 4] = 0; d->u.l.lens[i + 5] = 0; d->u.l.lens[i + 6] = 0; d->u.l.lens[i + 7] = 0; d->u.l.lens[i + 8] = 0; d->u.l.lens[i + 9] = 0; i += rep_count; } else { /* Repeat zero 11 - 138 times */ STATIC_ASSERT(11 + ((1 << 7) - 1) == 138); rep_count = 11 + POP_BITS(7); memset(&d->u.l.lens[i], 0, rep_count * sizeof(d->u.l.lens[i])); i += rep_count; } } } else if (block_type == DEFLATE_BLOCKTYPE_UNCOMPRESSED) { /* Uncompressed block: copy 'len' bytes literally from the input * buffer to the output buffer. */ ALIGN_INPUT(); SAFETY_CHECK(in_end - in_next >= 4); len = READ_U16(); nlen = READ_U16(); SAFETY_CHECK(len == (u16)~nlen); if (unlikely(len > out_end - out_next)) return LIBDEFLATE_INSUFFICIENT_SPACE; SAFETY_CHECK(len <= in_end - in_next); memcpy(out_next, in_next, len); in_next += len; out_next += len; goto block_done; } else { SAFETY_CHECK(block_type == DEFLATE_BLOCKTYPE_STATIC_HUFFMAN); /* Static Huffman block: set the static Huffman codeword * lengths. Then the remainder is the same as decompressing a * dynamic Huffman block. */ STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == 288); STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == 32); for (i = 0; i < 144; i++) d->u.l.lens[i] = 8; for (; i < 256; i++) d->u.l.lens[i] = 9; for (; i < 280; i++) d->u.l.lens[i] = 7; for (; i < 288; i++) d->u.l.lens[i] = 8; for (; i < 288 + 32; i++) d->u.l.lens[i] = 5; num_litlen_syms = 288; num_offset_syms = 32; } /* Decompressing a Huffman block (either dynamic or static) */ SAFETY_CHECK(build_offset_decode_table(d, num_litlen_syms, num_offset_syms)); SAFETY_CHECK(build_litlen_decode_table(d, num_litlen_syms, num_offset_syms)); /* The main DEFLATE decode loop */ for (;;) { u32 entry; u32 length; u32 offset; /* Decode a litlen symbol. */ ENSURE_BITS(DEFLATE_MAX_LITLEN_CODEWORD_LEN); entry = d->u.litlen_decode_table[BITS(LITLEN_TABLEBITS)]; if (entry & HUFFDEC_SUBTABLE_POINTER) { /* Litlen subtable required (uncommon case) */ REMOVE_BITS(LITLEN_TABLEBITS); entry = d->u.litlen_decode_table[ ((entry >> HUFFDEC_RESULT_SHIFT) & 0xFFFF) + BITS(entry & HUFFDEC_LENGTH_MASK)]; } REMOVE_BITS(entry & HUFFDEC_LENGTH_MASK); if (entry & HUFFDEC_LITERAL) { /* Literal */ if (unlikely(out_next == out_end)) return LIBDEFLATE_INSUFFICIENT_SPACE; *out_next++ = (u8)(entry >> HUFFDEC_RESULT_SHIFT); continue; } /* Match or end-of-block */ entry >>= HUFFDEC_RESULT_SHIFT; ENSURE_BITS(MAX_ENSURE); /* Pop the extra length bits and add them to the length base to * produce the full length. */ length = (entry >> HUFFDEC_LENGTH_BASE_SHIFT) + POP_BITS(entry & HUFFDEC_EXTRA_LENGTH_BITS_MASK); /* The match destination must not end after the end of the * output buffer. For efficiency, combine this check with the * end-of-block check. We're using 0 for the special * end-of-block length, so subtract 1 and it turn it into * SIZE_MAX. */ STATIC_ASSERT(HUFFDEC_END_OF_BLOCK_LENGTH == 0); if (unlikely((size_t)length - 1 >= out_end - out_next)) { if (unlikely(length != HUFFDEC_END_OF_BLOCK_LENGTH)) return LIBDEFLATE_INSUFFICIENT_SPACE; goto block_done; } /* Decode the match offset. */ entry = d->offset_decode_table[BITS(OFFSET_TABLEBITS)]; if (entry & HUFFDEC_SUBTABLE_POINTER) { /* Offset subtable required (uncommon case) */ REMOVE_BITS(OFFSET_TABLEBITS); entry = d->offset_decode_table[ ((entry >> HUFFDEC_RESULT_SHIFT) & 0xFFFF) + BITS(entry & HUFFDEC_LENGTH_MASK)]; } REMOVE_BITS(entry & HUFFDEC_LENGTH_MASK); entry >>= HUFFDEC_RESULT_SHIFT; STATIC_ASSERT(CAN_ENSURE(DEFLATE_MAX_EXTRA_LENGTH_BITS + DEFLATE_MAX_OFFSET_CODEWORD_LEN) && CAN_ENSURE(DEFLATE_MAX_EXTRA_OFFSET_BITS)); if (!CAN_ENSURE(DEFLATE_MAX_EXTRA_LENGTH_BITS + DEFLATE_MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS)) ENSURE_BITS(DEFLATE_MAX_EXTRA_OFFSET_BITS); /* Pop the extra offset bits and add them to the offset base to * produce the full offset. */ offset = (entry & HUFFDEC_OFFSET_BASE_MASK) + POP_BITS(entry >> HUFFDEC_EXTRA_OFFSET_BITS_SHIFT); /* The match source must not begin before the beginning of the * output buffer. */ SAFETY_CHECK(offset <= out_next - (const u8 *)out); /* Copy the match: 'length' bytes at 'out_next - offset' to * 'out_next'. */ if (UNALIGNED_ACCESS_IS_FAST && length <= (3 * WORDBYTES) && offset >= WORDBYTES && length + (3 * WORDBYTES) <= out_end - out_next) { /* Fast case: short length, no overlaps if we copy one * word at a time, and we aren't getting too close to * the end of the output array. */ copy_word_unaligned(out_next - offset + (0 * WORDBYTES), out_next + (0 * WORDBYTES)); copy_word_unaligned(out_next - offset + (1 * WORDBYTES), out_next + (1 * WORDBYTES)); copy_word_unaligned(out_next - offset + (2 * WORDBYTES), out_next + (2 * WORDBYTES)); } else { const u8 *src = out_next - offset; u8 *dst = out_next; u8 *end = out_next + length; if (UNALIGNED_ACCESS_IS_FAST && likely(out_end - end >= WORDBYTES - 1)) { if (offset >= WORDBYTES) { copy_word_unaligned(src, dst); src += WORDBYTES; dst += WORDBYTES; if (dst < end) { do { copy_word_unaligned(src, dst); src += WORDBYTES; dst += WORDBYTES; } while (dst < end); } } else if (offset == 1) { machine_word_t v = repeat_byte(*(dst - 1)); do { store_word_unaligned(v, dst); src += WORDBYTES; dst += WORDBYTES; } while (dst < end); } else { *dst++ = *src++; *dst++ = *src++; do { *dst++ = *src++; } while (dst < end); } } else { *dst++ = *src++; *dst++ = *src++; do { *dst++ = *src++; } while (dst < end); } } out_next += length; } block_done: /* Finished decoding a block. */ if (!is_final_block) goto next_block; /* That was the last block. */ if (actual_out_nbytes_ret) { *actual_out_nbytes_ret = out_next - (u8 *)out; } else { if (out_next != out_end) return LIBDEFLATE_SHORT_OUTPUT; } return LIBDEFLATE_SUCCESS; } advancecomp-1.23/libdeflate/deflate_compress.c000066400000000000000000002656651301462770100215220ustar00rootroot00000000000000/* * deflate_compress.c - a compressor for DEFLATE * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include "aligned_malloc.h" #include "deflate_compress.h" #include "deflate_constants.h" #include "unaligned.h" #include "libdeflate.h" /* * By default, the near-optimal parsing algorithm is enabled at compression * level 8 and above. The near-optimal parsing algorithm produces a compression * ratio significantly better than the greedy and lazy algorithms implemented * here, and also the algorithm used by zlib at level 9. However, it is slow. */ #define SUPPORT_NEAR_OPTIMAL_PARSING 1 /* * Define to 1 to maintain the full map from match offsets to offset slots. * This slightly speeds up translations of match offsets to offset slots, but it * uses 32769 bytes of memory rather than the 512 bytes used by the condensed * map. The speedup provided by the larger map is most helpful when the * near-optimal parsing algorithm is being used. */ #define USE_FULL_OFFSET_SLOT_FAST SUPPORT_NEAR_OPTIMAL_PARSING /* * DEFLATE uses a 32768 byte sliding window; set the matchfinder parameters * appropriately. */ #define MATCHFINDER_WINDOW_ORDER 15 #include "hc_matchfinder.h" #if SUPPORT_NEAR_OPTIMAL_PARSING # include "bt_matchfinder.h" #endif /* * The compressor always chooses a block of at least MIN_BLOCK_LENGTH bytes, * except if the last block has to be shorter. */ #define MIN_BLOCK_LENGTH 10000 /* * The compressor attempts to end blocks after SOFT_MAX_BLOCK_LENGTH bytes, but * the final length might be slightly longer due to matches extending beyond * this limit. */ #define SOFT_MAX_BLOCK_LENGTH 300000 /* * The number of observed matches or literals that represents sufficient data to * decide whether the current block should be terminated or not. */ #define NUM_OBSERVATIONS_PER_BLOCK_CHECK 512 #if SUPPORT_NEAR_OPTIMAL_PARSING /* Constants specific to the near-optimal parsing algorithm */ /* * The maximum number of matches the matchfinder can find at a single position. * Since the matchfinder never finds more than one match for the same length, * presuming one of each possible length is sufficient for an upper bound. * (This says nothing about whether it is worthwhile to consider so many * matches; this is just defining the worst case.) */ # define MAX_MATCHES_PER_POS (DEFLATE_MAX_MATCH_LEN - DEFLATE_MIN_MATCH_LEN + 1) /* * The number of lz_match structures in the match cache, excluding the extra * "overflow" entries. This value should be high enough so that nearly the * time, all matches found in a given block can fit in the match cache. * However, fallback behavior (immediately terminating the block) on cache * overflow is still required. */ # define CACHE_LENGTH (SOFT_MAX_BLOCK_LENGTH * 5) #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ /* * These are the compressor-side limits on the codeword lengths for each Huffman * code. To make outputting bits slightly faster, some of these limits are * lower than the limits defined by the DEFLATE format. This does not * significantly affect the compression ratio, at least for the block lengths we * use. */ #define MAX_LITLEN_CODEWORD_LEN 14 #define MAX_OFFSET_CODEWORD_LEN DEFLATE_MAX_OFFSET_CODEWORD_LEN #define MAX_PRE_CODEWORD_LEN DEFLATE_MAX_PRE_CODEWORD_LEN /* Table: length slot => length slot base value */ static const unsigned deflate_length_slot_base[] = { 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 13 , 15 , 17 , 19 , 23 , 27 , 31 , 35 , 43 , 51 , 59 , 67 , 83 , 99 , 115 , 131 , 163 , 195 , 227 , 258 , }; /* Table: length slot => number of extra length bits */ static const u8 deflate_extra_length_bits[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 2 , 2 , 2 , 2 , 3 , 3 , 3 , 3 , 4 , 4 , 4 , 4 , 5 , 5 , 5 , 5 , 0 , }; /* Table: offset slot => offset slot base value */ static const unsigned deflate_offset_slot_base[] = { 1 , 2 , 3 , 4 , 5 , 7 , 9 , 13 , 17 , 25 , 33 , 49 , 65 , 97 , 129 , 193 , 257 , 385 , 513 , 769 , 1025 , 1537 , 2049 , 3073 , 4097 , 6145 , 8193 , 12289 , 16385 , 24577 , }; /* Table: offset slot => number of extra offset bits */ static const u8 deflate_extra_offset_bits[] = { 0 , 0 , 0 , 0 , 1 , 1 , 2 , 2 , 3 , 3 , 4 , 4 , 5 , 5 , 6 , 6 , 7 , 7 , 8 , 8 , 9 , 9 , 10 , 10 , 11 , 11 , 12 , 12 , 13 , 13 , }; /* Table: length => length slot */ static const u8 deflate_length_slot[DEFLATE_MAX_MATCH_LEN + 1] = { 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, }; /* The order in which precode codeword lengths are stored */ static const u8 deflate_precode_lens_permutation[DEFLATE_NUM_PRECODE_SYMS] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; /* Codewords for the DEFLATE Huffman codes. */ struct deflate_codewords { u32 litlen[DEFLATE_NUM_LITLEN_SYMS]; u32 offset[DEFLATE_NUM_OFFSET_SYMS]; }; /* Codeword lengths (in bits) for the DEFLATE Huffman codes. * A zero length means the corresponding symbol had zero frequency. */ struct deflate_lens { u8 litlen[DEFLATE_NUM_LITLEN_SYMS]; u8 offset[DEFLATE_NUM_OFFSET_SYMS]; }; /* Codewords and lengths for the DEFLATE Huffman codes. */ struct deflate_codes { struct deflate_codewords codewords; struct deflate_lens lens; }; /* Symbol frequency counters for the DEFLATE Huffman codes. */ struct deflate_freqs { u32 litlen[DEFLATE_NUM_LITLEN_SYMS]; u32 offset[DEFLATE_NUM_OFFSET_SYMS]; }; #if SUPPORT_NEAR_OPTIMAL_PARSING /* Costs for the near-optimal parsing algorithm. */ struct deflate_costs { /* The cost to output each possible literal. */ u32 literal[DEFLATE_NUM_LITERALS]; /* The cost to output each possible match length. */ u32 length[DEFLATE_MAX_MATCH_LEN + 1]; /* The cost to output a match offset of each possible offset slot. */ u32 offset_slot[DEFLATE_NUM_OFFSET_SYMS]; }; /* * COST_SHIFT is a scaling factor that makes it possible to consider fractional * bit costs. A token requiring 'n' bits to represent has cost n << COST_SHIFT. * * Note: this is only useful as a statistical trick for when the true costs are * unknown. In reality, each token in DEFLATE requires a whole number of bits * to output. */ #define COST_SHIFT 3 /* * The NOSTAT_BITS value for a given alphabet is the number of bits assumed to * be needed to output a symbol that was unused in the previous optimization * pass. Assigning a default cost allows the symbol to be used in the next * optimization pass. However, the cost should be relatively high because the * symbol probably won't be used very many times (if at all). */ #define LITERAL_NOSTAT_BITS 13 #define LENGTH_NOSTAT_BITS 13 #define OFFSET_NOSTAT_BITS 10 #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ /* * Represents a run of literals followed by a match or end-of-block. This * struct is needed to temporarily store items chosen by the parser, since items * cannot be written until all items for the block have been chosen and the * block's Huffman codes have been computed. */ struct deflate_sequence { /* The number of literals in the run. This may be 0. The literals are * not stored explicitly in this structure; instead, they are read * directly from the uncompressed data. */ u16 litrunlen; /* If 'length' doesn't indicate end-of-block, then this is the offset * symbol of the match which follows the literals. */ u8 offset_symbol; /* If 'length' doesn't indicate end-of-block, then this is the length * slot of the match which follows the literals. */ u8 length_slot; /* The length of the match which follows the literals, or 0 if this this * sequence's literal run was the last literal run in the block, so * there is no match that follows it. */ u16 length; /* If 'length' doesn't indicate end-of-block, then this is the offset of * the match which follows the literals. */ u16 offset; }; #if SUPPORT_NEAR_OPTIMAL_PARSING /* * This structure represents a byte position in the input data and a node in the * graph of possible match/literal choices for the current block. * * Logically, each incoming edge to this node is labeled with a literal or a * match that can be taken to reach this position from an earlier position; and * each outgoing edge from this node is labeled with a literal or a match that * can be taken to advance from this position to a later position. * * But these "edges" are actually stored elsewhere (in 'match_cache'). Here we * associate with each node just two pieces of information: * * 'cost_to_end' is the minimum cost to reach the end of the block from * this position. * * 'item' represents the literal or match that must be chosen from here to * reach the end of the block with the minimum cost. Equivalently, this * can be interpreted as the label of the outgoing edge on the minimum-cost * path to the "end of block" node from this node. */ struct deflate_optimum_node { u32 cost_to_end; /* * Notes on the match/literal representation used here: * * The low bits of 'item' are the length: 1 if this is a literal, * or the match length if this is a match. * * The high bits of 'item' are the actual literal byte if this is a * literal, or the match offset if this is a match. */ #define OPTIMUM_OFFSET_SHIFT 9 #define OPTIMUM_LEN_MASK (((u32)1 << OPTIMUM_OFFSET_SHIFT) - 1) u32 item; }; #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ /* Block split statistics. See "Block splitting algorithm" below. */ #define NUM_LITERAL_OBSERVATION_TYPES 8 #define NUM_MATCH_OBSERVATION_TYPES 2 #define NUM_OBSERVATION_TYPES (NUM_LITERAL_OBSERVATION_TYPES + NUM_MATCH_OBSERVATION_TYPES) struct block_split_stats { u32 new_observations[NUM_OBSERVATION_TYPES]; u32 observations[NUM_OBSERVATION_TYPES]; u32 num_new_observations; u32 num_observations; }; /* The main DEFLATE compressor structure */ struct libdeflate_compressor { /* Pointer to the compress() implementation chosen at allocation time */ size_t (*impl)(struct libdeflate_compressor *, const u8 *, size_t, u8 *, size_t); /* Frequency counters for the current block */ struct deflate_freqs freqs; /* Dynamic Huffman codes for the current block */ struct deflate_codes codes; /* Static Huffman codes */ struct deflate_codes static_codes; /* Block split statistics for the currently pending block */ struct block_split_stats split_stats; /* A table for fast lookups of offset slot by match offset. * * If the full table is being used, it is a direct mapping from offset * to offset slot. * * If the condensed table is being used, the first 256 entries map * directly to the offset slots of offsets 1 through 256. The next 256 * entries map to the offset slots for the remaining offsets, stepping * through the offsets with a stride of 128. This relies on the fact * that each of the remaining offset slots contains at least 128 offsets * and has an offset base that is a multiple of 128. */ #if USE_FULL_OFFSET_SLOT_FAST u8 offset_slot_fast[DEFLATE_MAX_MATCH_OFFSET + 1]; #else u8 offset_slot_fast[512]; #endif /* The "nice" match length: if a match of this length is found, choose * it immediately without further consideration. */ unsigned nice_match_length; /* The maximum search depth: consider at most this many potential * matches at each position. */ unsigned max_search_depth; /* The compression level with which this compressor was created. */ unsigned compression_level; /* Temporary space for Huffman code output */ u32 precode_freqs[DEFLATE_NUM_PRECODE_SYMS]; u8 precode_lens[DEFLATE_NUM_PRECODE_SYMS]; u32 precode_codewords[DEFLATE_NUM_PRECODE_SYMS]; unsigned precode_items[DEFLATE_NUM_LITLEN_SYMS + DEFLATE_NUM_OFFSET_SYMS]; unsigned num_litlen_syms; unsigned num_offset_syms; unsigned num_explicit_lens; unsigned num_precode_items; union { /* Data for greedy or lazy parsing */ struct { /* Hash chain matchfinder */ struct hc_matchfinder hc_mf; /* The matches and literals that the parser has chosen * for the current block. The required length of this * array is limited by the maximum number of matches * that can ever be chosen for a single block, plus one * for the special entry at the end. */ struct deflate_sequence sequences[ DIV_ROUND_UP(SOFT_MAX_BLOCK_LENGTH, DEFLATE_MIN_MATCH_LEN) + 1]; } g; /* (g)reedy */ #if SUPPORT_NEAR_OPTIMAL_PARSING /* Data for near-optimal parsing */ struct { /* Binary tree matchfinder */ struct bt_matchfinder bt_mf; /* * Cached matches for the current block. This array * contains the matches that were found at each position * in the block. Specifically, for each position, there * is a list of matches found at that position, if any, * sorted by strictly increasing length. In addition, * following the matches for each position, there is a * special 'struct lz_match' whose 'length' member * contains the number of matches found at that * position, and whose 'offset' member contains the * literal at that position. * * Note: in rare cases, there will be a very high number * of matches in the block and this array will overflow. * If this happens, we force the end of the current * block. CACHE_LENGTH is the length at which we * actually check for overflow. The extra slots beyond * this are enough to absorb the worst case overflow, * which occurs if starting at &match_cache[CACHE_LENGTH * - 1], we write MAX_MATCHES_PER_POS matches and a * match count header, then skip searching for matches * at 'DEFLATE_MAX_MATCH_LEN - 1' positions and write * the match count header for each. */ struct lz_match match_cache[CACHE_LENGTH + MAX_MATCHES_PER_POS + DEFLATE_MAX_MATCH_LEN - 1]; /* * Array of nodes, one per position, for running the * minimum-cost path algorithm. * * This array must be large enough to accommodate the * worst-case number of nodes, which occurs if we find a * match of length DEFLATE_MAX_MATCH_LEN at position * SOFT_MAX_BLOCK_LENGTH - 1, producing a block of * length SOFT_MAX_BLOCK_LENGTH - 1 + * DEFLATE_MAX_MATCH_LEN. Add one for the end-of-block * node. */ struct deflate_optimum_node optimum_nodes[SOFT_MAX_BLOCK_LENGTH - 1 + DEFLATE_MAX_MATCH_LEN + 1]; /* The current cost model being used. */ struct deflate_costs costs; unsigned num_optim_passes; } n; /* (n)ear-optimal */ #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ } p; /* (p)arser */ }; /* * The type for the bitbuffer variable, which temporarily holds bits that are * being packed into bytes and written to the output buffer. For best * performance, this should have size equal to a machine word. */ typedef machine_word_t bitbuf_t; #define BITBUF_NBITS (8 * sizeof(bitbuf_t)) /* Can the specified number of bits always be added to 'bitbuf' after any * pending bytes have been flushed? */ #define CAN_BUFFER(n) ((n) <= BITBUF_NBITS - 7) /* * Structure to keep track of the current state of sending bits to the * compressed output buffer. */ struct deflate_output_bitstream { /* Bits that haven't yet been written to the output buffer. */ bitbuf_t bitbuf; /* Number of bits currently held in @bitbuf. */ unsigned bitcount; /* Pointer to the beginning of the output buffer. */ u8 *begin; /* Pointer to the position in the output buffer at which the next byte * should be written. */ u8 *next; /* Pointer just past the end of the output buffer. */ u8 *end; }; #define MIN_OUTPUT_SIZE (UNALIGNED_ACCESS_IS_FAST ? sizeof(bitbuf_t) : 1) /* Initialize the output bitstream. 'size' is assumed to be at least * MIN_OUTPUT_SIZE. */ static void deflate_init_output(struct deflate_output_bitstream *os, void *buffer, size_t size) { os->bitbuf = 0; os->bitcount = 0; os->begin = buffer; os->next = os->begin; os->end = os->begin + size - MIN_OUTPUT_SIZE; } /* Add some bits to the bitbuffer variable of the output bitstream. The caller * must make sure there is enough room. */ static forceinline void deflate_add_bits(struct deflate_output_bitstream *os, const bitbuf_t bits, const unsigned num_bits) { os->bitbuf |= bits << os->bitcount; os->bitcount += num_bits; } /* Flush bits from the bitbuffer variable to the output buffer. */ static forceinline void deflate_flush_bits(struct deflate_output_bitstream *os) { if (UNALIGNED_ACCESS_IS_FAST) { /* Flush a whole word (branchlessly). */ put_unaligned_leword(os->bitbuf, os->next); os->bitbuf >>= os->bitcount & ~7; os->next += MIN(os->end - os->next, os->bitcount >> 3); os->bitcount &= 7; } else { /* Flush a byte at a time. */ while (os->bitcount >= 8) { *os->next = os->bitbuf; if (os->next != os->end) os->next++; os->bitcount -= 8; os->bitbuf >>= 8; } } } /* Align the bitstream on a byte boundary. */ static forceinline void deflate_align_bitstream(struct deflate_output_bitstream *os) { os->bitcount += -os->bitcount & 7; deflate_flush_bits(os); } /* * Flush any remaining bits to the output buffer if needed. Return the total * number of bytes written to the output buffer, or 0 if an overflow occurred. */ static u32 deflate_flush_output(struct deflate_output_bitstream *os) { if (os->next == os->end) /* overflow? */ return 0; while ((int)os->bitcount > 0) { *os->next++ = os->bitbuf; os->bitcount -= 8; os->bitbuf >>= 8; } return os->next - os->begin; } /* Given the binary tree node A[subtree_idx] whose children already * satisfy the maxheap property, swap the node with its greater child * until it is greater than both its children, so that the maxheap * property is satisfied in the subtree rooted at A[subtree_idx]. */ static void heapify_subtree(u32 A[], unsigned length, unsigned subtree_idx) { unsigned parent_idx; unsigned child_idx; u32 v; v = A[subtree_idx]; parent_idx = subtree_idx; while ((child_idx = parent_idx * 2) <= length) { if (child_idx < length && A[child_idx + 1] > A[child_idx]) child_idx++; if (v >= A[child_idx]) break; A[parent_idx] = A[child_idx]; parent_idx = child_idx; } A[parent_idx] = v; } /* Rearrange the array 'A' so that it satisfies the maxheap property. * 'A' uses 1-based indices, so the children of A[i] are A[i*2] and A[i*2 + 1]. */ static void heapify_array(u32 A[], unsigned length) { unsigned subtree_idx; for (subtree_idx = length / 2; subtree_idx >= 1; subtree_idx--) heapify_subtree(A, length, subtree_idx); } /* * Sort the array 'A', which contains 'length' unsigned 32-bit integers. * * Note: name this function heap_sort() instead of heapsort() to avoid colliding * with heapsort() from stdlib.h on BSD-derived systems --- though this isn't * necessary when compiling with -D_ANSI_SOURCE, which is the better solution. */ static void heap_sort(u32 A[], unsigned length) { A--; /* Use 1-based indices */ heapify_array(A, length); while (length >= 2) { u32 tmp = A[length]; A[length] = A[1]; A[1] = tmp; length--; heapify_subtree(A, length, 1); } } #define NUM_SYMBOL_BITS 10 #define SYMBOL_MASK ((1 << NUM_SYMBOL_BITS) - 1) #define GET_NUM_COUNTERS(num_syms) ((((num_syms) + 3 / 4) + 3) & ~3) /* * Sort the symbols primarily by frequency and secondarily by symbol * value. Discard symbols with zero frequency and fill in an array with * the remaining symbols, along with their frequencies. The low * NUM_SYMBOL_BITS bits of each array entry will contain the symbol * value, and the remaining bits will contain the frequency. * * @num_syms * Number of symbols in the alphabet. * Can't be greater than (1 << NUM_SYMBOL_BITS). * * @freqs[num_syms] * The frequency of each symbol. * * @lens[num_syms] * An array that eventually will hold the length of each codeword. * This function only fills in the codeword lengths for symbols that * have zero frequency, which are not well defined per se but will * be set to 0. * * @symout[num_syms] * The output array, described above. * * Returns the number of entries in 'symout' that were filled. This is * the number of symbols that have nonzero frequency. */ static unsigned sort_symbols(unsigned num_syms, const u32 freqs[restrict], u8 lens[restrict], u32 symout[restrict]) { unsigned sym; unsigned i; unsigned num_used_syms; unsigned num_counters; unsigned counters[GET_NUM_COUNTERS(DEFLATE_MAX_NUM_SYMS)]; /* We rely on heapsort, but with an added optimization. Since * it's common for most symbol frequencies to be low, we first do * a count sort using a limited number of counters. High * frequencies will be counted in the last counter, and only they * will be sorted with heapsort. * * Note: with more symbols, it is generally beneficial to have more * counters. About 1 counter per 4 symbols seems fast. * * Note: I also tested radix sort, but even for large symbol * counts (> 255) and frequencies bounded at 16 bits (enabling * radix sort by just two base-256 digits), it didn't seem any * faster than the method implemented here. * * Note: I tested the optimized quicksort implementation from * glibc (with indirection overhead removed), but it was only * marginally faster than the simple heapsort implemented here. * * Tests were done with building the codes for LZX. Results may * vary for different compression algorithms...! */ num_counters = GET_NUM_COUNTERS(num_syms); memset(counters, 0, num_counters * sizeof(counters[0])); /* Count the frequencies. */ for (sym = 0; sym < num_syms; sym++) counters[MIN(freqs[sym], num_counters - 1)]++; /* Make the counters cumulative, ignoring the zero-th, which * counted symbols with zero frequency. As a side effect, this * calculates the number of symbols with nonzero frequency. */ num_used_syms = 0; for (i = 1; i < num_counters; i++) { unsigned count = counters[i]; counters[i] = num_used_syms; num_used_syms += count; } /* Sort nonzero-frequency symbols using the counters. At the * same time, set the codeword lengths of zero-frequency symbols * to 0. */ for (sym = 0; sym < num_syms; sym++) { u32 freq = freqs[sym]; if (freq != 0) { symout[counters[MIN(freq, num_counters - 1)]++] = sym | (freq << NUM_SYMBOL_BITS); } else { lens[sym] = 0; } } /* Sort the symbols counted in the last counter. */ heap_sort(symout + counters[num_counters - 2], counters[num_counters - 1] - counters[num_counters - 2]); return num_used_syms; } /* * Build the Huffman tree. * * This is an optimized implementation that * (a) takes advantage of the frequencies being already sorted; * (b) only generates non-leaf nodes, since the non-leaf nodes of a * Huffman tree are sufficient to generate a canonical code; * (c) Only stores parent pointers, not child pointers; * (d) Produces the nodes in the same memory used for input * frequency information. * * Array 'A', which contains 'sym_count' entries, is used for both input * and output. For this function, 'sym_count' must be at least 2. * * For input, the array must contain the frequencies of the symbols, * sorted in increasing order. Specifically, each entry must contain a * frequency left shifted by NUM_SYMBOL_BITS bits. Any data in the low * NUM_SYMBOL_BITS bits of the entries will be ignored by this function. * Although these bits will, in fact, contain the symbols that correspond * to the frequencies, this function is concerned with frequencies only * and keeps the symbols as-is. * * For output, this function will produce the non-leaf nodes of the * Huffman tree. These nodes will be stored in the first (sym_count - 1) * entries of the array. Entry A[sym_count - 2] will represent the root * node. Each other node will contain the zero-based index of its parent * node in 'A', left shifted by NUM_SYMBOL_BITS bits. The low * NUM_SYMBOL_BITS bits of each entry in A will be kept as-is. Again, * note that although these low bits will, in fact, contain a symbol * value, this symbol will have *no relationship* with the Huffman tree * node that happens to occupy the same slot. This is because this * implementation only generates the non-leaf nodes of the tree. */ static void build_tree(u32 A[], unsigned sym_count) { /* Index, in 'A', of next lowest frequency symbol that has not * yet been processed. */ unsigned i = 0; /* Index, in 'A', of next lowest frequency parentless non-leaf * node; or, if equal to 'e', then no such node exists yet. */ unsigned b = 0; /* Index, in 'A', of next node to allocate as a non-leaf. */ unsigned e = 0; do { unsigned m, n; u32 freq_shifted; /* Choose the two next lowest frequency entries. */ if (i != sym_count && (b == e || (A[i] >> NUM_SYMBOL_BITS) <= (A[b] >> NUM_SYMBOL_BITS))) m = i++; else m = b++; if (i != sym_count && (b == e || (A[i] >> NUM_SYMBOL_BITS) <= (A[b] >> NUM_SYMBOL_BITS))) n = i++; else n = b++; /* Allocate a non-leaf node and link the entries to it. * * If we link an entry that we're visiting for the first * time (via index 'i'), then we're actually linking a * leaf node and it will have no effect, since the leaf * will be overwritten with a non-leaf when index 'e' * catches up to it. But it's not any slower to * unconditionally set the parent index. * * We also compute the frequency of the non-leaf node as * the sum of its two children's frequencies. */ freq_shifted = (A[m] & ~SYMBOL_MASK) + (A[n] & ~SYMBOL_MASK); A[m] = (A[m] & SYMBOL_MASK) | (e << NUM_SYMBOL_BITS); A[n] = (A[n] & SYMBOL_MASK) | (e << NUM_SYMBOL_BITS); A[e] = (A[e] & SYMBOL_MASK) | freq_shifted; e++; } while (sym_count - e > 1); /* When just one entry remains, it is a "leaf" that was * linked to some other node. We ignore it, since the * rest of the array contains the non-leaves which we * need. (Note that we're assuming the cases with 0 or 1 * symbols were handled separately.) */ } /* * Given the stripped-down Huffman tree constructed by build_tree(), * determine the number of codewords that should be assigned each * possible length, taking into account the length-limited constraint. * * @A * The array produced by build_tree(), containing parent index * information for the non-leaf nodes of the Huffman tree. Each * entry in this array is a node; a node's parent always has a * greater index than that node itself. This function will * overwrite the parent index information in this array, so * essentially it will destroy the tree. However, the data in the * low NUM_SYMBOL_BITS of each entry will be preserved. * * @root_idx * The 0-based index of the root node in 'A', and consequently one * less than the number of tree node entries in 'A'. (Or, really 2 * less than the actual length of 'A'.) * * @len_counts * An array of length ('max_codeword_len' + 1) in which the number of * codewords having each length <= max_codeword_len will be * returned. * * @max_codeword_len * The maximum permissible codeword length. */ static void compute_length_counts(u32 A[restrict], unsigned root_idx, unsigned len_counts[restrict], unsigned max_codeword_len) { unsigned len; int node; /* The key observations are: * * (1) We can traverse the non-leaf nodes of the tree, always * visiting a parent before its children, by simply iterating * through the array in reverse order. Consequently, we can * compute the depth of each node in one pass, overwriting the * parent indices with depths. * * (2) We can initially assume that in the real Huffman tree, * both children of the root are leaves. This corresponds to two * codewords of length 1. Then, whenever we visit a (non-leaf) * node during the traversal, we modify this assumption to * account for the current node *not* being a leaf, but rather * its two children being leaves. This causes the loss of one * codeword for the current depth and the addition of two * codewords for the current depth plus one. * * (3) We can handle the length-limited constraint fairly easily * by simply using the largest length available when a depth * exceeds max_codeword_len. */ for (len = 0; len <= max_codeword_len; len++) len_counts[len] = 0; len_counts[1] = 2; /* Set the root node's depth to 0. */ A[root_idx] &= SYMBOL_MASK; for (node = root_idx - 1; node >= 0; node--) { /* Calculate the depth of this node. */ unsigned parent = A[node] >> NUM_SYMBOL_BITS; unsigned parent_depth = A[parent] >> NUM_SYMBOL_BITS; unsigned depth = parent_depth + 1; unsigned len = depth; /* Set the depth of this node so that it is available * when its children (if any) are processed. */ A[node] = (A[node] & SYMBOL_MASK) | (depth << NUM_SYMBOL_BITS); /* If needed, decrease the length to meet the * length-limited constraint. This is not the optimal * method for generating length-limited Huffman codes! * But it should be good enough. */ if (len >= max_codeword_len) { len = max_codeword_len; do { len--; } while (len_counts[len] == 0); } /* Account for the fact that we have a non-leaf node at * the current depth. */ len_counts[len]--; len_counts[len + 1] += 2; } } /* * Generate the codewords for a canonical Huffman code. * * @A * The output array for codewords. In addition, initially this * array must contain the symbols, sorted primarily by frequency and * secondarily by symbol value, in the low NUM_SYMBOL_BITS bits of * each entry. * * @len * Output array for codeword lengths. * * @len_counts * An array that provides the number of codewords that will have * each possible length <= max_codeword_len. * * @max_codeword_len * Maximum length, in bits, of each codeword. * * @num_syms * Number of symbols in the alphabet, including symbols with zero * frequency. This is the length of the 'A' and 'len' arrays. */ static void gen_codewords(u32 A[restrict], u8 lens[restrict], const unsigned len_counts[restrict], unsigned max_codeword_len, unsigned num_syms) { u32 next_codewords[DEFLATE_MAX_CODEWORD_LEN + 1]; unsigned i; unsigned len; unsigned sym; /* Given the number of codewords that will have each length, * assign codeword lengths to symbols. We do this by assigning * the lengths in decreasing order to the symbols sorted * primarily by increasing frequency and secondarily by * increasing symbol value. */ for (i = 0, len = max_codeword_len; len >= 1; len--) { unsigned count = len_counts[len]; while (count--) lens[A[i++] & SYMBOL_MASK] = len; } /* Generate the codewords themselves. We initialize the * 'next_codewords' array to provide the lexicographically first * codeword of each length, then assign codewords in symbol * order. This produces a canonical code. */ next_codewords[0] = 0; next_codewords[1] = 0; for (len = 2; len <= max_codeword_len; len++) next_codewords[len] = (next_codewords[len - 1] + len_counts[len - 1]) << 1; for (sym = 0; sym < num_syms; sym++) A[sym] = next_codewords[lens[sym]]++; } /* * --------------------------------------------------------------------- * make_canonical_huffman_code() * --------------------------------------------------------------------- * * Given an alphabet and the frequency of each symbol in it, construct a * length-limited canonical Huffman code. * * @num_syms * The number of symbols in the alphabet. The symbols are the * integers in the range [0, num_syms - 1]. This parameter must be * at least 2 and can't be greater than (1 << NUM_SYMBOL_BITS). * * @max_codeword_len * The maximum permissible codeword length. * * @freqs * An array of @num_syms entries, each of which specifies the * frequency of the corresponding symbol. It is valid for some, * none, or all of the frequencies to be 0. * * @lens * An array of @num_syms entries in which this function will return * the length, in bits, of the codeword assigned to each symbol. * Symbols with 0 frequency will not have codewords per se, but * their entries in this array will be set to 0. No lengths greater * than @max_codeword_len will be assigned. * * @codewords * An array of @num_syms entries in which this function will return * the codeword for each symbol, right-justified and padded on the * left with zeroes. Codewords for symbols with 0 frequency will be * undefined. * * --------------------------------------------------------------------- * * This function builds a length-limited canonical Huffman code. * * A length-limited Huffman code contains no codewords longer than some * specified length, and has exactly (with some algorithms) or * approximately (with the algorithm used here) the minimum weighted path * length from the root, given this constraint. * * A canonical Huffman code satisfies the properties that a longer * codeword never lexicographically precedes a shorter codeword, and the * lexicographic ordering of codewords of the same length is the same as * the lexicographic ordering of the corresponding symbols. A canonical * Huffman code, or more generally a canonical prefix code, can be * reconstructed from only a list containing the codeword length of each * symbol. * * The classic algorithm to generate a Huffman code creates a node for * each symbol, then inserts these nodes into a min-heap keyed by symbol * frequency. Then, repeatedly, the two lowest-frequency nodes are * removed from the min-heap and added as the children of a new node * having frequency equal to the sum of its two children, which is then * inserted into the min-heap. When only a single node remains in the * min-heap, it is the root of the Huffman tree. The codeword for each * symbol is determined by the path needed to reach the corresponding * node from the root. Descending to the left child appends a 0 bit, * whereas descending to the right child appends a 1 bit. * * The classic algorithm is relatively easy to understand, but it is * subject to a number of inefficiencies. In practice, it is fastest to * first sort the symbols by frequency. (This itself can be subject to * an optimization based on the fact that most frequencies tend to be * low.) At the same time, we sort secondarily by symbol value, which * aids the process of generating a canonical code. Then, during tree * construction, no heap is necessary because both the leaf nodes and the * unparented non-leaf nodes can be easily maintained in sorted order. * Consequently, there can never be more than two possibilities for the * next-lowest-frequency node. * * In addition, because we're generating a canonical code, we actually * don't need the leaf nodes of the tree at all, only the non-leaf nodes. * This is because for canonical code generation we don't need to know * where the symbols are in the tree. Rather, we only need to know how * many leaf nodes have each depth (codeword length). And this * information can, in fact, be quickly generated from the tree of * non-leaves only. * * Furthermore, we can build this stripped-down Huffman tree directly in * the array in which the codewords are to be generated, provided that * these array slots are large enough to hold a symbol and frequency * value. * * Still furthermore, we don't even need to maintain explicit child * pointers. We only need the parent pointers, and even those can be * overwritten in-place with depth information as part of the process of * extracting codeword lengths from the tree. So in summary, we do NOT * need a big structure like: * * struct huffman_tree_node { * unsigned int symbol; * unsigned int frequency; * unsigned int depth; * struct huffman_tree_node *left_child; * struct huffman_tree_node *right_child; * }; * * * ... which often gets used in "naive" implementations of Huffman code * generation. * * Many of these optimizations are based on the implementation in 7-Zip * (source file: C/HuffEnc.c), which has been placed in the public domain * by Igor Pavlov. */ static void make_canonical_huffman_code(unsigned num_syms, unsigned max_codeword_len, const u32 freqs[restrict], u8 lens[restrict], u32 codewords[restrict]) { u32 *A = codewords; unsigned num_used_syms; STATIC_ASSERT(DEFLATE_MAX_NUM_SYMS <= 1 << NUM_SYMBOL_BITS); /* We begin by sorting the symbols primarily by frequency and * secondarily by symbol value. As an optimization, the array * used for this purpose ('A') shares storage with the space in * which we will eventually return the codewords. */ num_used_syms = sort_symbols(num_syms, freqs, lens, A); /* 'num_used_syms' is the number of symbols with nonzero * frequency. This may be less than @num_syms. 'num_used_syms' * is also the number of entries in 'A' that are valid. Each * entry consists of a distinct symbol and a nonzero frequency * packed into a 32-bit integer. */ /* Handle special cases where only 0 or 1 symbols were used (had * nonzero frequency). */ if (unlikely(num_used_syms == 0)) { /* Code is empty. sort_symbols() already set all lengths * to 0, so there is nothing more to do. */ return; } if (unlikely(num_used_syms == 1)) { /* Only one symbol was used, so we only need one * codeword. But two codewords are needed to form the * smallest complete Huffman code, which uses codewords 0 * and 1. Therefore, we choose another symbol to which * to assign a codeword. We use 0 (if the used symbol is * not 0) or 1 (if the used symbol is 0). In either * case, the lesser-valued symbol must be assigned * codeword 0 so that the resulting code is canonical. */ unsigned sym = A[0] & SYMBOL_MASK; unsigned nonzero_idx = sym ? sym : 1; codewords[0] = 0; lens[0] = 1; codewords[nonzero_idx] = 1; lens[nonzero_idx] = 1; return; } /* Build a stripped-down version of the Huffman tree, sharing the * array 'A' with the symbol values. Then extract length counts * from the tree and use them to generate the final codewords. */ build_tree(A, num_used_syms); { unsigned len_counts[DEFLATE_MAX_CODEWORD_LEN + 1]; compute_length_counts(A, num_used_syms - 2, len_counts, max_codeword_len); gen_codewords(A, lens, len_counts, max_codeword_len, num_syms); } } /* * Clear the Huffman symbol frequency counters. * This must be called when starting a new DEFLATE block. */ static void deflate_reset_symbol_frequencies(struct libdeflate_compressor *c) { memset(&c->freqs, 0, sizeof(c->freqs)); } /* Reverse the Huffman codeword 'codeword', which is 'len' bits in length. */ static u32 deflate_reverse_codeword(u32 codeword, u8 len) { /* The following branchless algorithm is faster than going bit by bit. * Note: since no codewords are longer than 16 bits, we only need to * reverse the low 16 bits of the 'u32'. */ STATIC_ASSERT(DEFLATE_MAX_CODEWORD_LEN <= 16); /* Flip adjacent 1-bit fields */ codeword = ((codeword & 0x5555) << 1) | ((codeword & 0xAAAA) >> 1); /* Flip adjacent 2-bit fields */ codeword = ((codeword & 0x3333) << 2) | ((codeword & 0xCCCC) >> 2); /* Flip adjacent 4-bit fields */ codeword = ((codeword & 0x0F0F) << 4) | ((codeword & 0xF0F0) >> 4); /* Flip adjacent 8-bit fields */ codeword = ((codeword & 0x00FF) << 8) | ((codeword & 0xFF00) >> 8); /* Return the high 'len' bits of the bit-reversed 16 bit value. */ return codeword >> (16 - len); } /* Make a canonical Huffman code with bit-reversed codewords. */ static void deflate_make_huffman_code(unsigned num_syms, unsigned max_codeword_len, const u32 freqs[], u8 lens[], u32 codewords[]) { unsigned sym; make_canonical_huffman_code(num_syms, max_codeword_len, freqs, lens, codewords); for (sym = 0; sym < num_syms; sym++) codewords[sym] = deflate_reverse_codeword(codewords[sym], lens[sym]); } /* * Build the literal/length and offset Huffman codes for a DEFLATE block. * * This takes as input the frequency tables for each code and produces as output * a set of tables that map symbols to codewords and codeword lengths. */ static void deflate_make_huffman_codes(const struct deflate_freqs *freqs, struct deflate_codes *codes) { STATIC_ASSERT(MAX_LITLEN_CODEWORD_LEN <= DEFLATE_MAX_LITLEN_CODEWORD_LEN); STATIC_ASSERT(MAX_OFFSET_CODEWORD_LEN <= DEFLATE_MAX_OFFSET_CODEWORD_LEN); deflate_make_huffman_code(DEFLATE_NUM_LITLEN_SYMS, MAX_LITLEN_CODEWORD_LEN, freqs->litlen, codes->lens.litlen, codes->codewords.litlen); deflate_make_huffman_code(DEFLATE_NUM_OFFSET_SYMS, MAX_OFFSET_CODEWORD_LEN, freqs->offset, codes->lens.offset, codes->codewords.offset); } /* Initialize c->static_codes. */ static void deflate_init_static_codes(struct libdeflate_compressor *c) { unsigned i; for (i = 0; i < 144; i++) c->freqs.litlen[i] = 1 << (9 - 8); for (; i < 256; i++) c->freqs.litlen[i] = 1 << (9 - 9); for (; i < 280; i++) c->freqs.litlen[i] = 1 << (9 - 7); for (; i < 288; i++) c->freqs.litlen[i] = 1 << (9 - 8); for (i = 0; i < 32; i++) c->freqs.offset[i] = 1 << (5 - 5); deflate_make_huffman_codes(&c->freqs, &c->static_codes); } /* Return the offset slot for the specified match offset. */ static forceinline unsigned deflate_get_offset_slot(struct libdeflate_compressor *c, unsigned offset) { #if USE_FULL_OFFSET_SLOT_FAST return c->offset_slot_fast[offset]; #else if (offset <= 256) return c->offset_slot_fast[offset - 1]; else return c->offset_slot_fast[256 + ((offset - 1) >> 7)]; #endif } /* Write the header fields common to all DEFLATE block types. */ static void deflate_write_block_header(struct deflate_output_bitstream *os, bool is_final_block, unsigned block_type) { deflate_add_bits(os, is_final_block, 1); deflate_add_bits(os, block_type, 2); deflate_flush_bits(os); } static unsigned deflate_compute_precode_items(const u8 lens[restrict], const unsigned num_lens, u32 precode_freqs[restrict], unsigned precode_items[restrict]) { unsigned *itemptr; unsigned run_start; unsigned run_end; unsigned extra_bits; u8 len; memset(precode_freqs, 0, DEFLATE_NUM_PRECODE_SYMS * sizeof(precode_freqs[0])); itemptr = precode_items; run_start = 0; do { /* Find the next run of codeword lengths. */ /* len = the length being repeated */ len = lens[run_start]; /* Extend the run. */ run_end = run_start; do { run_end++; } while (run_end != num_lens && len == lens[run_end]); if (len == 0) { /* Run of zeroes. */ /* Symbol 18: RLE 11 to 138 zeroes at a time. */ while ((run_end - run_start) >= 11) { extra_bits = MIN((run_end - run_start) - 11, 0x7F); precode_freqs[18]++; *itemptr++ = 18 | (extra_bits << 5); run_start += 11 + extra_bits; } /* Symbol 17: RLE 3 to 10 zeroes at a time. */ if ((run_end - run_start) >= 3) { extra_bits = MIN((run_end - run_start) - 3, 0x7); precode_freqs[17]++; *itemptr++ = 17 | (extra_bits << 5); run_start += 3 + extra_bits; } } else { /* A run of nonzero lengths. */ /* Symbol 16: RLE 3 to 6 of the previous length. */ if ((run_end - run_start) >= 4) { precode_freqs[len]++; *itemptr++ = len; run_start++; do { extra_bits = MIN((run_end - run_start) - 3, 0x3); precode_freqs[16]++; *itemptr++ = 16 | (extra_bits << 5); run_start += 3 + extra_bits; } while ((run_end - run_start) >= 3); } } /* Output any remaining lengths without RLE. */ while (run_start != run_end) { precode_freqs[len]++; *itemptr++ = len; run_start++; } } while (run_start != num_lens); return itemptr - precode_items; } /* * Huffman codeword lengths for dynamic Huffman blocks are compressed using a * separate Huffman code, the "precode", which contains a symbol for each * possible codeword length in the larger code as well as several special * symbols to represent repeated codeword lengths (a form of run-length * encoding). The precode is itself constructed in canonical form, and its * codeword lengths are represented literally in 19 3-bit fields that * immediately precede the compressed codeword lengths of the larger code. */ /* Precompute the information needed to output Huffman codes. */ static void deflate_precompute_huffman_header(struct libdeflate_compressor *c) { /* Compute how many litlen and offset symbols are needed. */ for (c->num_litlen_syms = DEFLATE_NUM_LITLEN_SYMS; c->num_litlen_syms > 257; c->num_litlen_syms--) if (c->codes.lens.litlen[c->num_litlen_syms - 1] != 0) break; for (c->num_offset_syms = DEFLATE_NUM_OFFSET_SYMS; c->num_offset_syms > 1; c->num_offset_syms--) if (c->codes.lens.offset[c->num_offset_syms - 1] != 0) break; /* If we're not using the full set of literal/length codeword lengths, * then temporarily move the offset codeword lengths over so that the * literal/length and offset codeword lengths are contiguous. */ STATIC_ASSERT(offsetof(struct deflate_lens, offset) == DEFLATE_NUM_LITLEN_SYMS); if (c->num_litlen_syms != DEFLATE_NUM_LITLEN_SYMS) { memmove((u8 *)&c->codes.lens + c->num_litlen_syms, (u8 *)&c->codes.lens + DEFLATE_NUM_LITLEN_SYMS, c->num_offset_syms); } /* Compute the "items" (RLE / literal tokens and extra bits) with which * the codeword lengths in the larger code will be output. */ c->num_precode_items = deflate_compute_precode_items((u8 *)&c->codes.lens, c->num_litlen_syms + c->num_offset_syms, c->precode_freqs, c->precode_items); /* Build the precode. */ STATIC_ASSERT(MAX_PRE_CODEWORD_LEN <= DEFLATE_MAX_PRE_CODEWORD_LEN); deflate_make_huffman_code(DEFLATE_NUM_PRECODE_SYMS, MAX_PRE_CODEWORD_LEN, c->precode_freqs, c->precode_lens, c->precode_codewords); /* Count how many precode lengths we actually need to output. */ for (c->num_explicit_lens = DEFLATE_NUM_PRECODE_SYMS; c->num_explicit_lens > 4; c->num_explicit_lens--) if (c->precode_lens[deflate_precode_lens_permutation[ c->num_explicit_lens - 1]] != 0) break; /* Restore the offset codeword lengths if needed. */ if (c->num_litlen_syms != DEFLATE_NUM_LITLEN_SYMS) { memmove((u8 *)&c->codes.lens + DEFLATE_NUM_LITLEN_SYMS, (u8 *)&c->codes.lens + c->num_litlen_syms, c->num_offset_syms); } } /* Output the Huffman codes. */ static void deflate_write_huffman_header(struct libdeflate_compressor *c, struct deflate_output_bitstream *os) { unsigned i; deflate_add_bits(os, c->num_litlen_syms - 257, 5); deflate_add_bits(os, c->num_offset_syms - 1, 5); deflate_add_bits(os, c->num_explicit_lens - 4, 4); deflate_flush_bits(os); /* Output the lengths of the codewords in the precode. */ for (i = 0; i < c->num_explicit_lens; i++) { deflate_add_bits(os, c->precode_lens[ deflate_precode_lens_permutation[i]], 3); deflate_flush_bits(os); } /* Output the encoded lengths of the codewords in the larger code. */ for (i = 0; i < c->num_precode_items; i++) { unsigned precode_item = c->precode_items[i]; unsigned precode_sym = precode_item & 0x1F; deflate_add_bits(os, c->precode_codewords[precode_sym], c->precode_lens[precode_sym]); if (precode_sym >= 16) { if (precode_sym == 16) deflate_add_bits(os, precode_item >> 5, 2); else if (precode_sym == 17) deflate_add_bits(os, precode_item >> 5, 3); else deflate_add_bits(os, precode_item >> 5, 7); } STATIC_ASSERT(CAN_BUFFER(DEFLATE_MAX_PRE_CODEWORD_LEN + 7)); deflate_flush_bits(os); } } static void deflate_write_sequences(struct deflate_output_bitstream * restrict os, const struct deflate_codes * restrict codes, const struct deflate_sequence sequences[restrict], const u8 * restrict in_next) { const struct deflate_sequence *seq = sequences; for (;;) { unsigned litrunlen = seq->litrunlen; unsigned length; unsigned length_slot; unsigned litlen_symbol; unsigned offset_symbol; if (litrunlen) { #if 1 while (litrunlen >= 4) { unsigned lit0 = in_next[0]; unsigned lit1 = in_next[1]; unsigned lit2 = in_next[2]; unsigned lit3 = in_next[3]; deflate_add_bits(os, codes->codewords.litlen[lit0], codes->lens.litlen[lit0]); if (!CAN_BUFFER(2 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); deflate_add_bits(os, codes->codewords.litlen[lit1], codes->lens.litlen[lit1]); if (!CAN_BUFFER(4 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); deflate_add_bits(os, codes->codewords.litlen[lit2], codes->lens.litlen[lit2]); if (!CAN_BUFFER(2 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); deflate_add_bits(os, codes->codewords.litlen[lit3], codes->lens.litlen[lit3]); deflate_flush_bits(os); in_next += 4; litrunlen -= 4; } if (litrunlen-- != 0) { deflate_add_bits(os, codes->codewords.litlen[*in_next], codes->lens.litlen[*in_next]); if (!CAN_BUFFER(3 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); in_next++; if (litrunlen-- != 0) { deflate_add_bits(os, codes->codewords.litlen[*in_next], codes->lens.litlen[*in_next]); if (!CAN_BUFFER(3 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); in_next++; if (litrunlen-- != 0) { deflate_add_bits(os, codes->codewords.litlen[*in_next], codes->lens.litlen[*in_next]); if (!CAN_BUFFER(3 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); in_next++; } } if (CAN_BUFFER(3 * MAX_LITLEN_CODEWORD_LEN)) deflate_flush_bits(os); } #else do { unsigned lit = *in_next++; deflate_add_bits(os, codes->codewords.litlen[lit], codes->lens.litlen[lit]); deflate_flush_bits(os); } while (--litrunlen); #endif } length = seq->length; if (length == 0) return; in_next += length; length_slot = seq->length_slot; litlen_symbol = 257 + length_slot; /* Litlen symbol */ deflate_add_bits(os, codes->codewords.litlen[litlen_symbol], codes->lens.litlen[litlen_symbol]); /* Extra length bits */ STATIC_ASSERT(CAN_BUFFER(MAX_LITLEN_CODEWORD_LEN + DEFLATE_MAX_EXTRA_LENGTH_BITS)); deflate_add_bits(os, length - deflate_length_slot_base[length_slot], deflate_extra_length_bits[length_slot]); if (!CAN_BUFFER(MAX_LITLEN_CODEWORD_LEN + DEFLATE_MAX_EXTRA_LENGTH_BITS + MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS)) deflate_flush_bits(os); /* Offset symbol */ offset_symbol = seq->offset_symbol; deflate_add_bits(os, codes->codewords.offset[offset_symbol], codes->lens.offset[offset_symbol]); if (!CAN_BUFFER(MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS)) deflate_flush_bits(os); /* Extra offset bits */ deflate_add_bits(os, seq->offset - deflate_offset_slot_base[offset_symbol], deflate_extra_offset_bits[offset_symbol]); deflate_flush_bits(os); seq++; } } #if SUPPORT_NEAR_OPTIMAL_PARSING /* * Follow the minimum-cost path in the graph of possible match/literal choices * for the current block and write out the matches/literals using the specified * Huffman codes. * * Note: this is slightly duplicated with deflate_write_sequences(), the reason * being that we don't want to waste time translating between intermediate * match/literal representations. */ static void deflate_write_item_list(struct deflate_output_bitstream *os, const struct deflate_codes *codes, struct libdeflate_compressor *c, u32 block_length) { struct deflate_optimum_node *cur_node = &c->p.n.optimum_nodes[0]; struct deflate_optimum_node * const end_node = &c->p.n.optimum_nodes[block_length]; do { unsigned length = cur_node->item & OPTIMUM_LEN_MASK; unsigned offset = cur_node->item >> OPTIMUM_OFFSET_SHIFT; unsigned litlen_symbol; unsigned length_slot; unsigned offset_slot; if (length == 1) { /* Literal */ litlen_symbol = offset; deflate_add_bits(os, codes->codewords.litlen[litlen_symbol], codes->lens.litlen[litlen_symbol]); deflate_flush_bits(os); } else { /* Match length */ length_slot = deflate_length_slot[length]; litlen_symbol = 257 + length_slot; deflate_add_bits(os, codes->codewords.litlen[litlen_symbol], codes->lens.litlen[litlen_symbol]); deflate_add_bits(os, length - deflate_length_slot_base[length_slot], deflate_extra_length_bits[length_slot]); if (!CAN_BUFFER(MAX_LITLEN_CODEWORD_LEN + DEFLATE_MAX_EXTRA_LENGTH_BITS + MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS)) deflate_flush_bits(os); /* Match offset */ offset_slot = deflate_get_offset_slot(c, offset); deflate_add_bits(os, codes->codewords.offset[offset_slot], codes->lens.offset[offset_slot]); if (!CAN_BUFFER(MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS)) deflate_flush_bits(os); deflate_add_bits(os, offset - deflate_offset_slot_base[offset_slot], deflate_extra_offset_bits[offset_slot]); deflate_flush_bits(os); } cur_node += length; } while (cur_node != end_node); } #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ /* Output the end-of-block symbol. */ static void deflate_write_end_of_block(struct deflate_output_bitstream *os, const struct deflate_codes *codes) { deflate_add_bits(os, codes->codewords.litlen[DEFLATE_END_OF_BLOCK], codes->lens.litlen[DEFLATE_END_OF_BLOCK]); deflate_flush_bits(os); } static void deflate_write_uncompressed_block(struct deflate_output_bitstream *os, const u8 *data, u16 len, bool is_final_block) { deflate_write_block_header(os, is_final_block, DEFLATE_BLOCKTYPE_UNCOMPRESSED); deflate_align_bitstream(os); if (4 + (u32)len >= os->end - os->next) { os->next = os->end; return; } put_unaligned_le16(len, os->next); os->next += 2; put_unaligned_le16(~len, os->next); os->next += 2; memcpy(os->next, data, len); os->next += len; } static void deflate_write_uncompressed_blocks(struct deflate_output_bitstream *os, const u8 *data, u32 data_length, bool is_final_block) { do { u16 len = MIN(data_length, UINT16_MAX); deflate_write_uncompressed_block(os, data, len, is_final_block && len == data_length); data += len; data_length -= len; } while (data_length != 0); } /* * Choose the best type of block to use (dynamic Huffman, static Huffman, or * uncompressed), then output it. */ static void deflate_flush_block(struct libdeflate_compressor * restrict c, struct deflate_output_bitstream * restrict os, const u8 * restrict block_begin, u32 block_length, bool is_final_block, bool use_item_list) { static const u8 deflate_extra_precode_bits[DEFLATE_NUM_PRECODE_SYMS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7, }; /* Costs are measured in bits */ u32 dynamic_cost = 0; u32 static_cost = 0; u32 uncompressed_cost = 0; struct deflate_codes *codes; int block_type; unsigned sym; /* Tally the end-of-block symbol. */ c->freqs.litlen[DEFLATE_END_OF_BLOCK]++; /* Build dynamic Huffman codes. */ deflate_make_huffman_codes(&c->freqs, &c->codes); /* Account for the cost of sending dynamic Huffman codes. */ deflate_precompute_huffman_header(c); dynamic_cost += 5 + 5 + 4 + (3 * c->num_explicit_lens); for (sym = 0; sym < DEFLATE_NUM_PRECODE_SYMS; sym++) { u32 extra = deflate_extra_precode_bits[sym]; dynamic_cost += c->precode_freqs[sym] * (extra + c->precode_lens[sym]); } /* Account for the cost of encoding literals. */ for (sym = 0; sym < 256; sym++) { dynamic_cost += c->freqs.litlen[sym] * c->codes.lens.litlen[sym]; } for (sym = 0; sym < 144; sym++) static_cost += c->freqs.litlen[sym] * 8; for (; sym < 256; sym++) static_cost += c->freqs.litlen[sym] * 9; /* Account for the cost of encoding the end-of-block symbol. */ dynamic_cost += c->codes.lens.litlen[256]; static_cost += 7; /* Account for the cost of encoding lengths. */ for (sym = 257; sym < 257 + ARRAY_LEN(deflate_extra_length_bits); sym++) { u32 extra = deflate_extra_length_bits[sym - 257]; dynamic_cost += c->freqs.litlen[sym] * (extra + c->codes.lens.litlen[sym]); static_cost += c->freqs.litlen[sym] * (extra + c->static_codes.lens.litlen[sym]); } /* Account for the cost of encoding offsets. */ for (sym = 0; sym < ARRAY_LEN(deflate_extra_offset_bits); sym++) { u32 extra = deflate_extra_offset_bits[sym]; dynamic_cost += c->freqs.offset[sym] * (extra + c->codes.lens.offset[sym]); static_cost += c->freqs.offset[sym] * (extra + 5); } /* Compute the cost of using uncompressed blocks. */ uncompressed_cost += (-(os->bitcount + 3) & 7) + 32 + (40 * (DIV_ROUND_UP(block_length, UINT16_MAX) - 1)) + (8 * block_length); /* Choose the cheapest block type. */ if (dynamic_cost < MIN(static_cost, uncompressed_cost)) { block_type = DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN; codes = &c->codes; } else if (static_cost < uncompressed_cost) { block_type = DEFLATE_BLOCKTYPE_STATIC_HUFFMAN; codes = &c->static_codes; } else { block_type = DEFLATE_BLOCKTYPE_UNCOMPRESSED; } /* Now actually output the block. */ if (block_type == DEFLATE_BLOCKTYPE_UNCOMPRESSED) { /* Note: the length being flushed may exceed the maximum length * of an uncompressed block (65535 bytes). Therefore, more than * one uncompressed block might be needed. */ deflate_write_uncompressed_blocks(os, block_begin, block_length, is_final_block); } else { /* Output the block header. */ deflate_write_block_header(os, is_final_block, block_type); /* Output the Huffman codes (dynamic Huffman blocks only). */ if (block_type == DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN) deflate_write_huffman_header(c, os); /* Output the literals, matches, and end-of-block symbol. */ #if SUPPORT_NEAR_OPTIMAL_PARSING if (use_item_list) deflate_write_item_list(os, codes, c, block_length); else #endif deflate_write_sequences(os, codes, c->p.g.sequences, block_begin); deflate_write_end_of_block(os, codes); } } static forceinline void deflate_choose_literal(struct libdeflate_compressor *c, unsigned literal, unsigned *litrunlen_p) { c->freqs.litlen[literal]++; ++*litrunlen_p; } static forceinline void deflate_choose_match(struct libdeflate_compressor *c, unsigned length, unsigned offset, unsigned *litrunlen_p, struct deflate_sequence **next_seq_p) { unsigned litrunlen = *litrunlen_p; struct deflate_sequence *seq = *next_seq_p; unsigned length_slot = deflate_length_slot[length]; unsigned offset_slot = deflate_get_offset_slot(c, offset); c->freqs.litlen[257 + length_slot]++; c->freqs.offset[offset_slot]++; seq->litrunlen = litrunlen; seq->length = length; seq->offset = offset; seq->length_slot = length_slot; seq->offset_symbol = offset_slot; *litrunlen_p = 0; *next_seq_p = seq + 1; } static forceinline void deflate_finish_sequence(struct deflate_sequence *seq, unsigned litrunlen) { seq->litrunlen = litrunlen; seq->length = 0; } /******************************************************************************/ /* * Block splitting algorithm. The problem is to decide when it is worthwhile to * start a new block with new Huffman codes. There is a theoretically optimal * solution: recursively consider every possible block split, considering the * exact cost of each block, and choose the minimum cost approach. But this is * far too slow. Instead, as an approximation, we can count symbols and after * every N symbols, compare the expected distribution of symbols based on the * previous data with the actual distribution. If they differ "by enough", then * start a new block. * * As an optimization and heuristic, we don't distinguish between every symbol * but rather we combine many symbols into a single "observation type". For * literals we only look at the high bits and low bits, and for matches we only * look at whether the match is long or not. The assumption is that for typical * "real" data, places that are good block boundaries will tend to be noticable * based only on changes in these aggregate frequencies, without looking for * subtle differences in individual symbols. For example, a change from ASCII * bytes to non-ASCII bytes, or from few matches (generally less compressible) * to many matches (generally more compressible), would be easily noticed based * on the aggregates. * * For determining whether the frequency distributions are "different enough" to * start a new block, the simply heuristic of splitting when the sum of absolute * differences exceeds a constant seems to be good enough. We also add a number * proportional to the block length so that the algorithm is more likely to end * long blocks than short blocks. This reflects the general expectation that it * will become increasingly beneficial to start a new block as the current * block grows longer. * * Finally, for an approximation, it is not strictly necessary that the exact * symbols being used are considered. With "near-optimal parsing", for example, * the actual symbols that will be used are unknown until after the block * boundary is chosen and the block has been optimized. Since the final choices * cannot be used, we can use preliminary "greedy" choices instead. */ /* Initialize the block split statistics when starting a new block. */ static void init_block_split_stats(struct block_split_stats *stats) { int i; for (i = 0; i < NUM_OBSERVATION_TYPES; i++) { stats->new_observations[i] = 0; stats->observations[i] = 0; } stats->num_new_observations = 0; stats->num_observations = 0; } /* Literal observation. Heuristic: use the top 2 bits and low 1 bits of the * literal, for 8 possible literal observation types. */ static forceinline void observe_literal(struct block_split_stats *stats, u8 lit) { stats->new_observations[((lit >> 5) & 0x6) | (lit & 1)]++; stats->num_new_observations++; } /* Match observation. Heuristic: use one observation type for "short match" and * one observation type for "long match". */ static forceinline void observe_match(struct block_split_stats *stats, unsigned length) { stats->new_observations[NUM_LITERAL_OBSERVATION_TYPES + (length >= 9)]++; stats->num_new_observations++; } static bool do_end_block_check(struct block_split_stats *stats, u32 block_length) { int i; if (stats->num_observations > 0) { /* Note: to avoid slow divisions, we do not divide by * 'num_observations', but rather do all math with the numbers * multiplied by 'num_observations'. */ u32 total_delta = 0; for (i = 0; i < NUM_OBSERVATION_TYPES; i++) { u32 expected = stats->observations[i] * stats->num_new_observations; u32 actual = stats->new_observations[i] * stats->num_observations; u32 delta = (actual > expected) ? actual - expected : expected - actual; total_delta += delta; } /* Ready to end the block? */ if (total_delta + (block_length / 4096) * stats->num_observations >= NUM_OBSERVATIONS_PER_BLOCK_CHECK * 200 / 512 * stats->num_observations) return true; } for (i = 0; i < NUM_OBSERVATION_TYPES; i++) { stats->num_observations += stats->new_observations[i]; stats->observations[i] += stats->new_observations[i]; stats->new_observations[i] = 0; } stats->num_new_observations = 0; return false; } static forceinline bool should_end_block(struct block_split_stats *stats, const u8 *in_block_begin, const u8 *in_next, const u8 *in_end) { /* Ready to check block split statistics? */ if (stats->num_new_observations < NUM_OBSERVATIONS_PER_BLOCK_CHECK || in_next - in_block_begin < MIN_BLOCK_LENGTH || in_end - in_next < MIN_BLOCK_LENGTH) return false; return do_end_block_check(stats, in_next - in_block_begin); } /******************************************************************************/ /* * This is the "greedy" DEFLATE compressor. It always chooses the longest match. */ static size_t deflate_compress_greedy(struct libdeflate_compressor * restrict c, const u8 * restrict in, size_t in_nbytes, u8 * restrict out, size_t out_nbytes_avail) { const u8 *in_next = in; const u8 *in_end = in_next + in_nbytes; struct deflate_output_bitstream os; const u8 *in_cur_base = in_next; unsigned max_len = DEFLATE_MAX_MATCH_LEN; unsigned nice_len = MIN(c->nice_match_length, max_len); u32 next_hashes[2] = {0, 0}; deflate_init_output(&os, out, out_nbytes_avail); hc_matchfinder_init(&c->p.g.hc_mf); do { /* Starting a new DEFLATE block. */ const u8 * const in_block_begin = in_next; const u8 * const in_max_block_end = in_next + MIN(in_end - in_next, SOFT_MAX_BLOCK_LENGTH); u32 litrunlen = 0; struct deflate_sequence *next_seq = c->p.g.sequences; init_block_split_stats(&c->split_stats); deflate_reset_symbol_frequencies(c); do { u32 length; u32 offset; /* Decrease the maximum and nice match lengths if we're * approaching the end of the input buffer. */ if (unlikely(max_len > in_end - in_next)) { max_len = in_end - in_next; nice_len = MIN(nice_len, max_len); } length = hc_matchfinder_longest_match(&c->p.g.hc_mf, &in_cur_base, in_next, DEFLATE_MIN_MATCH_LEN - 1, max_len, nice_len, c->max_search_depth, next_hashes, &offset); if (length >= DEFLATE_MIN_MATCH_LEN) { /* Match found. */ deflate_choose_match(c, length, offset, &litrunlen, &next_seq); observe_match(&c->split_stats, length); in_next = hc_matchfinder_skip_positions(&c->p.g.hc_mf, &in_cur_base, in_next + 1, in_end, length - 1, next_hashes); } else { /* No match found. */ deflate_choose_literal(c, *in_next, &litrunlen); observe_literal(&c->split_stats, *in_next); in_next++; } /* Check if it's time to output another block. */ } while (in_next < in_max_block_end && !should_end_block(&c->split_stats, in_block_begin, in_next, in_end)); deflate_finish_sequence(next_seq, litrunlen); deflate_flush_block(c, &os, in_block_begin, in_next - in_block_begin, in_next == in_end, false); } while (in_next != in_end); return deflate_flush_output(&os); } /* * This is the "lazy" DEFLATE compressor. Before choosing a match, it checks to * see if there's a longer match at the next position. If yes, it outputs a * literal and continues to the next position. If no, it outputs the match. */ static size_t deflate_compress_lazy(struct libdeflate_compressor * restrict c, const u8 * restrict in, size_t in_nbytes, u8 * restrict out, size_t out_nbytes_avail) { const u8 *in_next = in; const u8 *in_end = in_next + in_nbytes; struct deflate_output_bitstream os; const u8 *in_cur_base = in_next; unsigned max_len = DEFLATE_MAX_MATCH_LEN; unsigned nice_len = MIN(c->nice_match_length, max_len); u32 next_hashes[2] = {0, 0}; deflate_init_output(&os, out, out_nbytes_avail); hc_matchfinder_init(&c->p.g.hc_mf); do { /* Starting a new DEFLATE block. */ const u8 * const in_block_begin = in_next; const u8 * const in_max_block_end = in_next + MIN(in_end - in_next, SOFT_MAX_BLOCK_LENGTH); u32 litrunlen = 0; struct deflate_sequence *next_seq = c->p.g.sequences; init_block_split_stats(&c->split_stats); deflate_reset_symbol_frequencies(c); do { unsigned cur_len; unsigned cur_offset; unsigned next_len; unsigned next_offset; if (unlikely(in_end - in_next < DEFLATE_MAX_MATCH_LEN)) { max_len = in_end - in_next; nice_len = MIN(nice_len, max_len); } /* Find the longest match at the current position. */ cur_len = hc_matchfinder_longest_match(&c->p.g.hc_mf, &in_cur_base, in_next, DEFLATE_MIN_MATCH_LEN - 1, max_len, nice_len, c->max_search_depth, next_hashes, &cur_offset); in_next += 1; if (cur_len < DEFLATE_MIN_MATCH_LEN) { /* No match found. Choose a literal. */ deflate_choose_literal(c, *(in_next - 1), &litrunlen); observe_literal(&c->split_stats, *(in_next - 1)); continue; } have_cur_match: observe_match(&c->split_stats, cur_len); /* We have a match at the current position. */ /* If the current match is very long, choose it * immediately. */ if (cur_len >= nice_len) { deflate_choose_match(c, cur_len, cur_offset, &litrunlen, &next_seq); in_next = hc_matchfinder_skip_positions(&c->p.g.hc_mf, &in_cur_base, in_next, in_end, cur_len - 1, next_hashes); continue; } /* * Try to find a match at the next position. * * Note: since we already have a match at the *current* * position, we use only half the 'max_search_depth' * when checking the *next* position. This is a useful * trade-off because it's more worthwhile to use a * greater search depth on the initial match. * * Note: it's possible to structure the code such that * there's only one call to longest_match(), which * handles both the "find the initial match" and "try to * find a longer match" cases. However, it is faster to * have two call sites, with longest_match() inlined at * each. */ if (unlikely(in_end - in_next < DEFLATE_MAX_MATCH_LEN)) { max_len = in_end - in_next; nice_len = MIN(nice_len, max_len); } next_len = hc_matchfinder_longest_match(&c->p.g.hc_mf, &in_cur_base, in_next, cur_len, max_len, nice_len, c->max_search_depth / 2, next_hashes, &next_offset); in_next += 1; if (next_len > cur_len) { /* Found a longer match at the next position. * Output a literal. Then the next match * becomes the current match. */ deflate_choose_literal(c, *(in_next - 2), &litrunlen); cur_len = next_len; cur_offset = next_offset; goto have_cur_match; } /* No longer match at the next position. * Output the current match. */ deflate_choose_match(c, cur_len, cur_offset, &litrunlen, &next_seq); in_next = hc_matchfinder_skip_positions(&c->p.g.hc_mf, &in_cur_base, in_next, in_end, cur_len - 2, next_hashes); /* Check if it's time to output another block. */ } while (in_next < in_max_block_end && !should_end_block(&c->split_stats, in_block_begin, in_next, in_end)); deflate_finish_sequence(next_seq, litrunlen); deflate_flush_block(c, &os, in_block_begin, in_next - in_block_begin, in_next == in_end, false); } while (in_next != in_end); return deflate_flush_output(&os); } #if SUPPORT_NEAR_OPTIMAL_PARSING /* * Follow the minimum-cost path in the graph of possible match/literal choices * for the current block and compute the frequencies of the Huffman symbols that * would be needed to output those matches and literals. */ static void deflate_tally_item_list(struct libdeflate_compressor *c, u32 block_length) { struct deflate_optimum_node *cur_node = &c->p.n.optimum_nodes[0]; struct deflate_optimum_node *end_node = &c->p.n.optimum_nodes[block_length]; do { unsigned length = cur_node->item & OPTIMUM_LEN_MASK; unsigned offset = cur_node->item >> OPTIMUM_OFFSET_SHIFT; if (length == 1) { /* Literal */ c->freqs.litlen[offset]++; } else { /* Match */ c->freqs.litlen[257 + deflate_length_slot[length]]++; c->freqs.offset[deflate_get_offset_slot(c, offset)]++; } cur_node += length; } while (cur_node != end_node); } /* Set the current cost model from the codeword lengths specified in @lens. */ static void deflate_set_costs_from_codes(struct libdeflate_compressor *c, const struct deflate_lens *lens) { unsigned i; /* Literals */ for (i = 0; i < DEFLATE_NUM_LITERALS; i++) { u32 bits = (lens->litlen[i] ? lens->litlen[i] : LITERAL_NOSTAT_BITS); c->p.n.costs.literal[i] = bits << COST_SHIFT; } /* Lengths */ for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++) { unsigned length_slot = deflate_length_slot[i]; unsigned litlen_sym = 257 + length_slot; u32 bits = (lens->litlen[litlen_sym] ? lens->litlen[litlen_sym] : LENGTH_NOSTAT_BITS); bits += deflate_extra_length_bits[length_slot]; c->p.n.costs.length[i] = bits << COST_SHIFT; } /* Offset slots */ for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++) { u32 bits = (lens->offset[i] ? lens->offset[i] : OFFSET_NOSTAT_BITS); bits += deflate_extra_offset_bits[i]; c->p.n.costs.offset_slot[i] = bits << COST_SHIFT; } } static forceinline u32 deflate_default_literal_cost(unsigned literal) { STATIC_ASSERT(COST_SHIFT == 3); /* 66 is 8.25 bits/symbol */ return 66; } static forceinline u32 deflate_default_length_slot_cost(unsigned length_slot) { STATIC_ASSERT(COST_SHIFT == 3); /* 60 is 7.5 bits/symbol */ return 60 + ((u32)deflate_extra_length_bits[length_slot] << COST_SHIFT); } static forceinline u32 deflate_default_offset_slot_cost(unsigned offset_slot) { STATIC_ASSERT(COST_SHIFT == 3); /* 39 is 4.875 bits/symbol */ return 39 + ((u32)deflate_extra_offset_bits[offset_slot] << COST_SHIFT); } /* * Set default symbol costs for the first block's first optimization pass. * * It works well to assume that each symbol is equally probable. This results * in each symbol being assigned a cost of (-log2(1.0/num_syms) * (1 << * COST_SHIFT)) where 'num_syms' is the number of symbols in the corresponding * alphabet. However, we intentionally bias the parse towards matches rather * than literals by using a slightly lower default cost for length symbols than * for literals. This often improves the compression ratio slightly. */ static void deflate_set_default_costs(struct libdeflate_compressor *c) { unsigned i; /* Literals */ for (i = 0; i < DEFLATE_NUM_LITERALS; i++) c->p.n.costs.literal[i] = deflate_default_literal_cost(i); /* Lengths */ for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++) c->p.n.costs.length[i] = deflate_default_length_slot_cost( deflate_length_slot[i]); /* Offset slots */ for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++) c->p.n.costs.offset_slot[i] = deflate_default_offset_slot_cost(i); } static forceinline void deflate_adjust_cost(u32 *cost_p, u32 default_cost) { *cost_p += ((s32)default_cost - (s32)*cost_p) >> 1; } /* * Adjust the costs when beginning a new block. * * Since the current costs have been optimized for the data, it's undesirable to * throw them away and start over with the default costs. At the same time, we * don't want to bias the parse by assuming that the next block will be similar * to the current block. As a compromise, make the costs closer to the * defaults, but don't simply set them to the defaults. */ static void deflate_adjust_costs(struct libdeflate_compressor *c) { unsigned i; /* Literals */ for (i = 0; i < DEFLATE_NUM_LITERALS; i++) deflate_adjust_cost(&c->p.n.costs.literal[i], deflate_default_literal_cost(i)); /* Lengths */ for (i = DEFLATE_MIN_MATCH_LEN; i <= DEFLATE_MAX_MATCH_LEN; i++) deflate_adjust_cost(&c->p.n.costs.length[i], deflate_default_length_slot_cost( deflate_length_slot[i])); /* Offset slots */ for (i = 0; i < ARRAY_LEN(deflate_offset_slot_base); i++) deflate_adjust_cost(&c->p.n.costs.offset_slot[i], deflate_default_offset_slot_cost(i)); } /* * Find the minimum-cost path through the graph of possible match/literal * choices for this block. * * We find the minimum cost path from 'c->p.n.optimum_nodes[0]', which * represents the node at the beginning of the block, to * 'c->p.n.optimum_nodes[block_length]', which represents the node at the end of * the block. Edge costs are evaluated using the cost model 'c->p.n.costs'. * * The algorithm works backwards, starting at the end node and proceeding * backwards one node at a time. At each node, the minimum cost to reach the * end node is computed and the match/literal choice that begins that path is * saved. */ static void deflate_find_min_cost_path(struct libdeflate_compressor *c, const u32 block_length, const struct lz_match *cache_ptr) { struct deflate_optimum_node *end_node = &c->p.n.optimum_nodes[block_length]; struct deflate_optimum_node *cur_node = end_node; cur_node->cost_to_end = 0; do { unsigned num_matches; unsigned literal; u32 best_cost_to_end; cur_node--; cache_ptr--; num_matches = cache_ptr->length; literal = cache_ptr->offset; /* It's always possible to choose a literal. */ best_cost_to_end = c->p.n.costs.literal[literal] + (cur_node + 1)->cost_to_end; cur_node->item = ((u32)literal << OPTIMUM_OFFSET_SHIFT) | 1; /* Also consider matches if there are any. */ if (num_matches) { const struct lz_match *match; unsigned len; unsigned offset; unsigned offset_slot; u32 offset_cost; u32 cost_to_end; /* * Consider each length from the minimum * (DEFLATE_MIN_MATCH_LEN) to the length of the longest * match found at this position. For each length, we * consider only the smallest offset for which that * length is available. Although this is not guaranteed * to be optimal due to the possibility of a larger * offset costing less than a smaller offset to code, * this is a very useful heuristic. */ match = cache_ptr - num_matches; len = DEFLATE_MIN_MATCH_LEN; do { offset = match->offset; offset_slot = deflate_get_offset_slot(c, offset); offset_cost = c->p.n.costs.offset_slot[offset_slot]; do { cost_to_end = offset_cost + c->p.n.costs.length[len] + (cur_node + len)->cost_to_end; if (cost_to_end < best_cost_to_end) { best_cost_to_end = cost_to_end; cur_node->item = ((u32)offset << OPTIMUM_OFFSET_SHIFT) | len; } } while (++len <= match->length); } while (++match != cache_ptr); cache_ptr -= num_matches; } cur_node->cost_to_end = best_cost_to_end; } while (cur_node != &c->p.n.optimum_nodes[0]); } /* * Choose the literal/match sequence to use for the current block. The basic * algorithm finds a minimum-cost path through the block's graph of * literal/match choices, given a cost model. However, the cost of each symbol * is unknown until the Huffman codes have been built, but at the same time the * Huffman codes depend on the frequencies of chosen symbols. Consequently, * multiple passes must be used to try to approximate an optimal solution. The * first pass uses default costs, mixed with the costs from the previous block * if any. Later passes use the Huffman codeword lengths from the previous pass * as the costs. */ static void deflate_optimize_block(struct libdeflate_compressor *c, u32 block_length, const struct lz_match *cache_ptr, bool is_first_block) { unsigned num_passes_remaining = c->p.n.num_optim_passes; u32 i; /* Force the block to really end at the desired length, even if some * matches extend beyond it. */ for (i = block_length; i <= MIN(block_length - 1 + DEFLATE_MAX_MATCH_LEN, ARRAY_LEN(c->p.n.optimum_nodes) - 1); i++) c->p.n.optimum_nodes[i].cost_to_end = 0x80000000; /* Set the initial costs. */ if (is_first_block) deflate_set_default_costs(c); else deflate_adjust_costs(c); for (;;) { /* Find the minimum cost path for this pass. */ deflate_find_min_cost_path(c, block_length, cache_ptr); /* Compute frequencies of the chosen symbols. */ deflate_reset_symbol_frequencies(c); deflate_tally_item_list(c, block_length); if (--num_passes_remaining == 0) break; /* At least one optimization pass remains; update the costs. */ deflate_make_huffman_codes(&c->freqs, &c->codes); deflate_set_costs_from_codes(c, &c->codes.lens); } } /* * This is the "near-optimal" DEFLATE compressor. It computes the optimal * representation of each DEFLATE block using a minimum-cost path search over * the graph of possible match/literal choices for that block, assuming a * certain cost for each Huffman symbol. * * For several reasons, the end result is not guaranteed to be optimal: * * - Nonoptimal choice of blocks * - Heuristic limitations on which matches are actually considered * - Symbol costs are unknown until the symbols have already been chosen * (so iterative optimization must be used) */ static size_t deflate_compress_near_optimal(struct libdeflate_compressor * restrict c, const u8 * restrict in, size_t in_nbytes, u8 * restrict out, size_t out_nbytes_avail) { const u8 *in_next = in; const u8 *in_end = in_next + in_nbytes; struct deflate_output_bitstream os; const u8 *in_cur_base = in_next; const u8 *in_next_slide = in_next + MIN(in_end - in_next, MATCHFINDER_WINDOW_SIZE); unsigned max_len = DEFLATE_MAX_MATCH_LEN; unsigned nice_len = MIN(c->nice_match_length, max_len); u32 next_hashes[2] = {0, 0}; deflate_init_output(&os, out, out_nbytes_avail); bt_matchfinder_init(&c->p.n.bt_mf); do { /* Starting a new DEFLATE block. */ struct lz_match *cache_ptr = c->p.n.match_cache; const u8 * const in_block_begin = in_next; const u8 * const in_max_block_end = in_next + MIN(in_end - in_next, SOFT_MAX_BLOCK_LENGTH); const u8 *next_observation = in_next; init_block_split_stats(&c->split_stats); /* * Find matches until we decide to end the block. We end the * block if any of the following is true: * * (1) Maximum block length has been reached * (2) Match catch may overflow. * (3) Block split heuristic says to split now. */ do { struct lz_match *matches; unsigned best_len; /* Slide the window forward if needed. */ if (in_next == in_next_slide) { bt_matchfinder_slide_window(&c->p.n.bt_mf); in_cur_base = in_next; in_next_slide = in_next + MIN(in_end - in_next, MATCHFINDER_WINDOW_SIZE); } /* Decrease the maximum and nice match lengths if we're * approaching the end of the input buffer. */ if (unlikely(max_len > in_end - in_next)) { max_len = in_end - in_next; nice_len = MIN(nice_len, max_len); } /* * Find matches with the current position using the * binary tree matchfinder and save them in * 'match_cache'. * * Note: the binary tree matchfinder is more suited for * optimal parsing than the hash chain matchfinder. The * reasons for this include: * * - The binary tree matchfinder can find more matches * in the same number of steps. * - One of the major advantages of hash chains is that * skipping positions (not searching for matches at * them) is faster; however, with optimal parsing we * search for matches at almost all positions, so this * advantage of hash chains is negated. */ matches = cache_ptr; best_len = 0; if (likely(max_len >= BT_MATCHFINDER_REQUIRED_NBYTES)) { cache_ptr = bt_matchfinder_get_matches(&c->p.n.bt_mf, in_cur_base, in_next - in_cur_base, max_len, nice_len, c->max_search_depth, next_hashes, &best_len, matches); } if (in_next >= next_observation) { if (best_len >= 4) { observe_match(&c->split_stats, best_len); next_observation = in_next + best_len; } else { observe_literal(&c->split_stats, *in_next); next_observation = in_next + 1; } } cache_ptr->length = cache_ptr - matches; cache_ptr->offset = *in_next; in_next++; cache_ptr++; /* * If there was a very long match found, don't cache any * matches for the bytes covered by that match. This * avoids degenerate behavior when compressing highly * redundant data, where the number of matches can be * very large. * * This heuristic doesn't actually hurt the compression * ratio very much. If there's a long match, then the * data must be highly compressible, so it doesn't * matter much what we do. */ if (best_len >= DEFLATE_MIN_MATCH_LEN && best_len >= nice_len) { --best_len; do { if (in_next == in_next_slide) { bt_matchfinder_slide_window(&c->p.n.bt_mf); in_cur_base = in_next; in_next_slide = in_next + MIN(in_end - in_next, MATCHFINDER_WINDOW_SIZE); } if (unlikely(max_len > in_end - in_next)) { max_len = in_end - in_next; nice_len = MIN(nice_len, max_len); } if (max_len >= BT_MATCHFINDER_REQUIRED_NBYTES) { bt_matchfinder_skip_position(&c->p.n.bt_mf, in_cur_base, in_next - in_cur_base, nice_len, c->max_search_depth, next_hashes); } cache_ptr->length = 0; cache_ptr->offset = *in_next; in_next++; cache_ptr++; } while (--best_len); } } while (in_next < in_max_block_end && cache_ptr < &c->p.n.match_cache[CACHE_LENGTH] && !should_end_block(&c->split_stats, in_block_begin, in_next, in_end)); /* All the matches for this block have been cached. Now choose * the sequence of items to output and flush the block. */ deflate_optimize_block(c, in_next - in_block_begin, cache_ptr, in_block_begin == in); deflate_flush_block(c, &os, in_block_begin, in_next - in_block_begin, in_next == in_end, true); } while (in_next != in_end); return deflate_flush_output(&os); } #endif /* SUPPORT_NEAR_OPTIMAL_PARSING */ /* Initialize c->offset_slot_fast. */ static void deflate_init_offset_slot_fast(struct libdeflate_compressor *c) { unsigned offset_slot; unsigned offset; unsigned offset_end; for (offset_slot = 0; offset_slot < ARRAY_LEN(deflate_offset_slot_base); offset_slot++) { offset = deflate_offset_slot_base[offset_slot]; #if USE_FULL_OFFSET_SLOT_FAST offset_end = offset + (1 << deflate_extra_offset_bits[offset_slot]); do { c->offset_slot_fast[offset] = offset_slot; } while (++offset != offset_end); #else if (offset <= 256) { offset_end = offset + (1 << deflate_extra_offset_bits[offset_slot]); do { c->offset_slot_fast[offset - 1] = offset_slot; } while (++offset != offset_end); } else { offset_end = offset + (1 << deflate_extra_offset_bits[offset_slot]); do { c->offset_slot_fast[256 + ((offset - 1) >> 7)] = offset_slot; } while ((offset += (1 << 7)) != offset_end); } #endif } } LIBDEFLATEAPI struct libdeflate_compressor * libdeflate_alloc_compressor(int compression_level) { struct libdeflate_compressor *c; size_t size; #if SUPPORT_NEAR_OPTIMAL_PARSING if (compression_level >= 8) size = offsetof(struct libdeflate_compressor, p) + sizeof(c->p.n); else #endif size = offsetof(struct libdeflate_compressor, p) + sizeof(c->p.g); c = aligned_malloc(MATCHFINDER_ALIGNMENT, size); if (!c) return NULL; switch (compression_level) { case 1: c->impl = deflate_compress_greedy; c->max_search_depth = 2; c->nice_match_length = 8; break; case 2: c->impl = deflate_compress_greedy; c->max_search_depth = 6; c->nice_match_length = 10; break; case 3: c->impl = deflate_compress_greedy; c->max_search_depth = 12; c->nice_match_length = 14; break; case 4: c->impl = deflate_compress_greedy; c->max_search_depth = 24; c->nice_match_length = 24; break; case 5: c->impl = deflate_compress_lazy; c->max_search_depth = 20; c->nice_match_length = 30; break; case 6: c->impl = deflate_compress_lazy; c->max_search_depth = 40; c->nice_match_length = 65; break; case 7: c->impl = deflate_compress_lazy; c->max_search_depth = 100; c->nice_match_length = 130; break; #if SUPPORT_NEAR_OPTIMAL_PARSING case 8: c->impl = deflate_compress_near_optimal; c->max_search_depth = 12; c->nice_match_length = 20; c->p.n.num_optim_passes = 1; break; case 9: c->impl = deflate_compress_near_optimal; c->max_search_depth = 16; c->nice_match_length = 26; c->p.n.num_optim_passes = 2; break; case 10: c->impl = deflate_compress_near_optimal; c->max_search_depth = 30; c->nice_match_length = 50; c->p.n.num_optim_passes = 2; break; case 11: c->impl = deflate_compress_near_optimal; c->max_search_depth = 60; c->nice_match_length = 80; c->p.n.num_optim_passes = 3; break; case 12: c->impl = deflate_compress_near_optimal; c->max_search_depth = 100; c->nice_match_length = 133; c->p.n.num_optim_passes = 4; break; #else case 8: c->impl = deflate_compress_lazy; c->max_search_depth = 150; c->nice_match_length = 200; break; case 9: c->impl = deflate_compress_lazy; c->max_search_depth = 200; c->nice_match_length = DEFLATE_MAX_MATCH_LEN; break; #endif default: aligned_free(c); return NULL; } c->compression_level = compression_level; deflate_init_offset_slot_fast(c); deflate_init_static_codes(c); return c; } LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor *c, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail) { if (unlikely(out_nbytes_avail < MIN_OUTPUT_SIZE)) return 0; /* For extremely small inputs just use a single uncompressed block. */ if (unlikely(in_nbytes < 16)) { struct deflate_output_bitstream os; deflate_init_output(&os, out, out_nbytes_avail); if (in_nbytes == 0) in = &os; /* Avoid passing NULL to memcpy() */ deflate_write_uncompressed_block(&os, in, in_nbytes, true); return deflate_flush_output(&os); } return (*c->impl)(c, in, in_nbytes, out, out_nbytes_avail); } LIBDEFLATEAPI void libdeflate_free_compressor(struct libdeflate_compressor *c) { aligned_free(c); } unsigned int deflate_get_compression_level(struct libdeflate_compressor *c) { return c->compression_level; } LIBDEFLATEAPI size_t libdeflate_deflate_compress_bound(struct libdeflate_compressor *c, size_t in_nbytes) { /* * The worst case is all uncompressed blocks where one block has length * <= MIN_BLOCK_LENGTH and the others have length MIN_BLOCK_LENGTH. * Each uncompressed block has 5 bytes of overhead: 1 for BFINAL, BTYPE, * and alignment to a byte boundary; 2 for LEN; and 2 for NLEN. */ size_t max_num_blocks = MAX(DIV_ROUND_UP(in_nbytes, MIN_BLOCK_LENGTH), 1); return (5 * max_num_blocks) + in_nbytes + 1 + MIN_OUTPUT_SIZE; } advancecomp-1.23/libdeflate/deflate_compress.h000066400000000000000000000006171301462770100215070ustar00rootroot00000000000000#ifndef LIB_DEFLATE_COMPRESS_H #define LIB_DEFLATE_COMPRESS_H #include "lib_common.h" /* DEFLATE compression is private to deflate_compress.c, but we do need to be * able to query the compression level for zlib and gzip header generation. */ struct libdeflate_compressor; extern unsigned int deflate_get_compression_level(struct libdeflate_compressor *c); #endif /* LIB_DEFLATE_COMPRESS_H */ advancecomp-1.23/libdeflate/deflate_constants.h000066400000000000000000000043031301462770100216640ustar00rootroot00000000000000/* * deflate_constants.h - constants for the DEFLATE compression format */ #ifndef LIB_DEFLATE_CONSTANTS_H #define LIB_DEFLATE_CONSTANTS_H /* Valid block types */ #define DEFLATE_BLOCKTYPE_UNCOMPRESSED 0 #define DEFLATE_BLOCKTYPE_STATIC_HUFFMAN 1 #define DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN 2 /* Minimum and maximum supported match lengths (in bytes) */ #define DEFLATE_MIN_MATCH_LEN 3 #define DEFLATE_MAX_MATCH_LEN 258 /* Minimum and maximum supported match offsets (in bytes) */ #define DEFLATE_MIN_MATCH_OFFSET 1 #define DEFLATE_MAX_MATCH_OFFSET 32768 #define DEFLATE_MAX_WINDOW_SIZE 32768 /* Number of symbols in each Huffman code. Note: for the literal/length * and offset codes, these are actually the maximum values; a given block * might use fewer symbols. */ #define DEFLATE_NUM_PRECODE_SYMS 19 #define DEFLATE_NUM_LITLEN_SYMS 288 #define DEFLATE_NUM_OFFSET_SYMS 32 /* The maximum number of symbols across all codes */ #define DEFLATE_MAX_NUM_SYMS 288 /* Division of symbols in the literal/length code */ #define DEFLATE_NUM_LITERALS 256 #define DEFLATE_END_OF_BLOCK 256 #define DEFLATE_NUM_LEN_SYMS 31 /* Maximum codeword length, in bits, within each Huffman code */ #define DEFLATE_MAX_PRE_CODEWORD_LEN 7 #define DEFLATE_MAX_LITLEN_CODEWORD_LEN 15 #define DEFLATE_MAX_OFFSET_CODEWORD_LEN 15 /* The maximum codeword length across all codes */ #define DEFLATE_MAX_CODEWORD_LEN 15 /* Maximum possible overrun when decoding codeword lengths */ #define DEFLATE_MAX_LENS_OVERRUN 137 /* * Maximum number of extra bits that may be required to represent a match * length or offset. * * TODO: are we going to have full DEFLATE64 support? If so, up to 16 * length bits must be supported. */ #define DEFLATE_MAX_EXTRA_LENGTH_BITS 5 #define DEFLATE_MAX_EXTRA_OFFSET_BITS 14 /* The maximum number of bits in which a match can be represented. This * is the absolute worst case, which assumes the longest possible Huffman * codewords and the maximum numbers of extra bits. */ #define DEFLATE_MAX_MATCH_BITS \ (DEFLATE_MAX_LITLEN_CODEWORD_LEN + DEFLATE_MAX_EXTRA_LENGTH_BITS + \ DEFLATE_MAX_OFFSET_CODEWORD_LEN + DEFLATE_MAX_EXTRA_OFFSET_BITS) #endif /* LIB_DEFLATE_CONSTANTS_H */ advancecomp-1.23/libdeflate/deflate_decompress.c000066400000000000000000001027651301462770100220220ustar00rootroot00000000000000/* * deflate_decompress.c - a decompressor for DEFLATE * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * --------------------------------------------------------------------------- * * This is a highly optimized DEFLATE decompressor. When compiled with gcc on * x86_64, it decompresses data in about 52% of the time of zlib (48% if BMI2 * instructions are available). On other architectures it should still be * significantly faster than zlib, but the difference may be smaller. * * Why this is faster than zlib's implementation: * * - Word accesses rather than byte accesses when reading input * - Word accesses rather than byte accesses when copying matches * - Faster Huffman decoding combined with various DEFLATE-specific tricks * - Larger bitbuffer variable that doesn't need to be filled as often * - Other optimizations to remove unnecessary branches * - Only full-buffer decompression is supported, so the code doesn't need to * support stopping and resuming decompression. * - On x86_64, compile a version of the decompression routine using BMI2 * instructions and use it automatically at runtime when supported. */ #include #include #include "deflate_constants.h" #include "unaligned.h" #include "x86_cpu_features.h" #include "libdeflate.h" /* * If the expression passed to SAFETY_CHECK() evaluates to false, then the * decompression routine immediately returns LIBDEFLATE_BAD_DATA, indicating the * compressed data is invalid. * * Theoretically, these checks could be disabled for specialized applications * where all input to the decompressor will be trusted. */ #if 0 # pragma message("UNSAFE DECOMPRESSION IS ENABLED. THIS MUST ONLY BE USED IF THE DECOMPRESSOR INPUT WILL ALWAYS BE TRUSTED!") # define SAFETY_CHECK(expr) (void)(expr) #else # define SAFETY_CHECK(expr) if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA #endif /* * Each TABLEBITS number is the base-2 logarithm of the number of entries in the * main portion of the corresponding decode table. Each number should be large * enough to ensure that for typical data, the vast majority of symbols can be * decoded by a direct lookup of the next TABLEBITS bits of compressed data. * However, this must be balanced against the fact that a larger table requires * more memory and requires more time to fill. * * Note: you cannot change a TABLEBITS number without also changing the * corresponding ENOUGH number! */ #define PRECODE_TABLEBITS 7 #define LITLEN_TABLEBITS 10 #define OFFSET_TABLEBITS 8 /* * Each ENOUGH number is the maximum number of decode table entries that may be * required for the corresponding Huffman code, including the main table and all * subtables. Each number depends on three parameters: * * (1) the maximum number of symbols in the code (DEFLATE_NUM_*_SYMBOLS) * (2) the number of main table bits (the TABLEBITS numbers defined above) * (3) the maximum allowed codeword length (DEFLATE_MAX_*_CODEWORD_LEN) * * The ENOUGH numbers were computed using the utility program 'enough' from * zlib. This program enumerates all possible relevant Huffman codes to find * the worst-case usage of decode table entries. */ #define PRECODE_ENOUGH 128 /* enough 19 7 7 */ #define LITLEN_ENOUGH 1334 /* enough 288 10 15 */ #define OFFSET_ENOUGH 402 /* enough 32 8 15 */ /* * Type for codeword lengths. */ typedef u8 len_t; /* * The main DEFLATE decompressor structure. Since this implementation only * supports full buffer decompression, this structure does not store the entire * decompression state, but rather only some arrays that are too large to * comfortably allocate on the stack. */ struct libdeflate_decompressor { /* * The arrays aren't all needed at the same time. 'precode_lens' and * 'precode_decode_table' are unneeded after 'lens' has been filled. * Furthermore, 'lens' need not be retained after building the litlen * and offset decode tables. In fact, 'lens' can be in union with * 'litlen_decode_table' provided that 'offset_decode_table' is separate * and is built first. */ union { len_t precode_lens[DEFLATE_NUM_PRECODE_SYMS]; struct { len_t lens[DEFLATE_NUM_LITLEN_SYMS + DEFLATE_NUM_OFFSET_SYMS + DEFLATE_MAX_LENS_OVERRUN]; u32 precode_decode_table[PRECODE_ENOUGH]; } l; u32 litlen_decode_table[LITLEN_ENOUGH]; } u; u32 offset_decode_table[OFFSET_ENOUGH]; u16 working_space[2 * (DEFLATE_MAX_CODEWORD_LEN + 1) + DEFLATE_MAX_NUM_SYMS]; }; /***************************************************************************** * Input bitstream * *****************************************************************************/ /* * The state of the "input bitstream" consists of the following variables: * * - in_next: pointer to the next unread byte in the input buffer * * - in_end: pointer just past the end of the input buffer * * - bitbuf: a word-sized variable containing bits that have been read from * the input buffer. The buffered bits are right-aligned * (they're the low-order bits). * * - bitsleft: number of bits in 'bitbuf' that are valid. * * To make it easier for the compiler to optimize the code by keeping variables * in registers, these are declared as normal variables and manipulated using * macros. */ /* * The type for the bitbuffer variable ('bitbuf' described above). For best * performance, this should have size equal to a machine word. * * 64-bit platforms have a significant advantage: they get a bigger bitbuffer * which they have to fill less often. */ typedef machine_word_t bitbuf_t; /* * Number of bits the bitbuffer variable can hold. */ #define BITBUF_NBITS (8 * sizeof(bitbuf_t)) /* * The maximum number of bits that can be requested to be in the bitbuffer * variable. This is the maximum value of 'n' that can be passed * ENSURE_BITS(n). * * This not equal to BITBUF_NBITS because we never read less than one byte at a * time. If the bitbuffer variable contains more than (BITBUF_NBITS - 8) bits, * then we can't read another byte without first consuming some bits. So the * maximum count we can ensure is (BITBUF_NBITS - 7). */ #define MAX_ENSURE (BITBUF_NBITS - 7) /* * Evaluates to true if 'n' is a valid argument to ENSURE_BITS(n), or false if * 'n' is too large to be passed to ENSURE_BITS(n). Note: if 'n' is a compile * time constant, then this expression will be a compile-type constant. * Therefore, CAN_ENSURE() can be used choose between alternative * implementations at compile time. */ #define CAN_ENSURE(n) ((n) <= MAX_ENSURE) /* * Fill the bitbuffer variable, reading one byte at a time. * * Note: if we would overrun the input buffer, we just don't read anything, * leaving the bits as 0 but marking them as filled. This makes the * implementation simpler because this removes the need to distinguish between * "real" overruns and overruns that occur because of our own lookahead during * Huffman decoding. The disadvantage is that a "real" overrun can go * undetected, and libdeflate_deflate_decompress() may return a success status * rather than the expected failure status if one occurs. However, this is * irrelevant because even if this specific case were to be handled "correctly", * one could easily come up with a different case where the compressed data * would be corrupted in such a way that fully retains its validity. Users * should run a checksum against the uncompressed data if they wish to detect * corruptions. */ #define FILL_BITS_BYTEWISE() \ do { \ if (likely(in_next != in_end)) \ bitbuf |= (bitbuf_t)*in_next++ << bitsleft; \ else \ overrun_count++; \ bitsleft += 8; \ } while (bitsleft <= BITBUF_NBITS - 8) /* * Fill the bitbuffer variable by reading the next word from the input buffer. * This can be significantly faster than FILL_BITS_BYTEWISE(). However, for * this to work correctly, the word must be interpreted in little-endian format. * In addition, the memory access may be unaligned. Therefore, this method is * most efficient on little-endian architectures that support fast unaligned * access, such as x86 and x86_64. */ #define FILL_BITS_WORDWISE() \ do { \ bitbuf |= get_unaligned_leword(in_next) << bitsleft; \ in_next += (BITBUF_NBITS - bitsleft) >> 3; \ bitsleft += (BITBUF_NBITS - bitsleft) & ~7; \ } while (0) /* * Does the bitbuffer variable currently contain at least 'n' bits? */ #define HAVE_BITS(n) (bitsleft >= (n)) /* * Load more bits from the input buffer until the specified number of bits is * present in the bitbuffer variable. 'n' cannot be too large; see MAX_ENSURE * and CAN_ENSURE(). */ #define ENSURE_BITS(n) \ if (!HAVE_BITS(n)) { \ if (CPU_IS_LITTLE_ENDIAN() && \ UNALIGNED_ACCESS_IS_FAST && \ likely(in_end - in_next >= sizeof(bitbuf_t))) \ FILL_BITS_WORDWISE(); \ else \ FILL_BITS_BYTEWISE(); \ } /* * Return the next 'n' bits from the bitbuffer variable without removing them. */ #define BITS(n) ((u32)bitbuf & (((u32)1 << (n)) - 1)) /* * Remove the next 'n' bits from the bitbuffer variable. */ #define REMOVE_BITS(n) (bitbuf >>= (n), bitsleft -= (n)) /* * Remove and return the next 'n' bits from the bitbuffer variable. */ #define POP_BITS(n) (tmp32 = BITS(n), REMOVE_BITS(n), tmp32) /* * Align the input to the next byte boundary, discarding any remaining bits in * the current byte. * * Note that if the bitbuffer variable currently contains more than 8 bits, then * we must rewind 'in_next', effectively putting those bits back. Only the bits * in what would be the "current" byte if we were reading one byte at a time can * be actually discarded. */ #define ALIGN_INPUT() \ do { \ in_next -= (bitsleft >> 3) - MIN(overrun_count, bitsleft >> 3); \ bitbuf = 0; \ bitsleft = 0; \ } while(0) /* * Read a 16-bit value from the input. This must have been preceded by a call * to ALIGN_INPUT(), and the caller must have already checked for overrun. */ #define READ_U16() (tmp16 = get_unaligned_le16(in_next), in_next += 2, tmp16) /***************************************************************************** * Huffman decoding * *****************************************************************************/ /* * A decode table for order TABLEBITS consists of a main table of (1 << * TABLEBITS) entries followed by a variable number of subtables. * * The decoding algorithm takes the next TABLEBITS bits of compressed data and * uses them as an index into the decode table. The resulting entry is either a * "direct entry", meaning that it contains the value desired, or a "subtable * pointer", meaning that the entry references a subtable that must be indexed * using more bits of the compressed data to decode the symbol. * * Each decode table (a main table along with with its subtables, if any) is * associated with a Huffman code. Logically, the result of a decode table * lookup is a symbol from the alphabet from which the corresponding Huffman * code was constructed. A symbol with codeword length n <= TABLEBITS is * associated with 2**(TABLEBITS - n) direct entries in the table, whereas a * symbol with codeword length n > TABLEBITS is associated with one or more * subtable entries. * * On top of this basic design, we implement several optimizations: * * - We store the length of each codeword directly in each of its decode table * entries. This allows the codeword length to be produced without indexing * an additional table. * * - When beneficial, we don't store the Huffman symbol itself, but instead data * generated from it. For example, when decoding an offset symbol in DEFLATE, * it's more efficient if we can decode the offset base and number of extra * offset bits directly rather than decoding the offset symbol and then * looking up both of those values in an additional table or tables. * * The size of each decode table entry is 32 bits, which provides slightly * better performance than 16-bit entries on 32 and 64 bit processers, provided * that the table doesn't get so large that it takes up too much memory and * starts generating cache misses. The bits of each decode table entry are * defined as follows: * * - Bits 30 -- 31: flags (see below) * - Bits 8 -- 29: decode result: a Huffman symbol or related data * - Bits 0 -- 7: codeword length */ /* * This flag is set in all main decode table entries that represent subtable * pointers. */ #define HUFFDEC_SUBTABLE_POINTER 0x80000000 /* * This flag is set in all entries in the litlen decode table that represent * literals. */ #define HUFFDEC_LITERAL 0x40000000 /* Mask for extracting the codeword length from a decode table entry. */ #define HUFFDEC_LENGTH_MASK 0xFF /* Shift to extract the decode result from a decode table entry. */ #define HUFFDEC_RESULT_SHIFT 8 /* The decode result for each precode symbol. There is no special optimization * for the precode; the decode result is simply the symbol value. */ static const u32 precode_decode_results[DEFLATE_NUM_PRECODE_SYMS] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, }; /* The decode result for each litlen symbol. For literals, this is the literal * value itself and the HUFFDEC_LITERAL flag. For lengths, this is the length * base and the number of extra length bits. */ static const u32 litlen_decode_results[DEFLATE_NUM_LITLEN_SYMS] = { #define ENTRY(literal) ((HUFFDEC_LITERAL >> HUFFDEC_RESULT_SHIFT) | (literal)) /* Literals */ ENTRY(0) , ENTRY(1) , ENTRY(2) , ENTRY(3) , ENTRY(4) , ENTRY(5) , ENTRY(6) , ENTRY(7) , ENTRY(8) , ENTRY(9) , ENTRY(10) , ENTRY(11) , ENTRY(12) , ENTRY(13) , ENTRY(14) , ENTRY(15) , ENTRY(16) , ENTRY(17) , ENTRY(18) , ENTRY(19) , ENTRY(20) , ENTRY(21) , ENTRY(22) , ENTRY(23) , ENTRY(24) , ENTRY(25) , ENTRY(26) , ENTRY(27) , ENTRY(28) , ENTRY(29) , ENTRY(30) , ENTRY(31) , ENTRY(32) , ENTRY(33) , ENTRY(34) , ENTRY(35) , ENTRY(36) , ENTRY(37) , ENTRY(38) , ENTRY(39) , ENTRY(40) , ENTRY(41) , ENTRY(42) , ENTRY(43) , ENTRY(44) , ENTRY(45) , ENTRY(46) , ENTRY(47) , ENTRY(48) , ENTRY(49) , ENTRY(50) , ENTRY(51) , ENTRY(52) , ENTRY(53) , ENTRY(54) , ENTRY(55) , ENTRY(56) , ENTRY(57) , ENTRY(58) , ENTRY(59) , ENTRY(60) , ENTRY(61) , ENTRY(62) , ENTRY(63) , ENTRY(64) , ENTRY(65) , ENTRY(66) , ENTRY(67) , ENTRY(68) , ENTRY(69) , ENTRY(70) , ENTRY(71) , ENTRY(72) , ENTRY(73) , ENTRY(74) , ENTRY(75) , ENTRY(76) , ENTRY(77) , ENTRY(78) , ENTRY(79) , ENTRY(80) , ENTRY(81) , ENTRY(82) , ENTRY(83) , ENTRY(84) , ENTRY(85) , ENTRY(86) , ENTRY(87) , ENTRY(88) , ENTRY(89) , ENTRY(90) , ENTRY(91) , ENTRY(92) , ENTRY(93) , ENTRY(94) , ENTRY(95) , ENTRY(96) , ENTRY(97) , ENTRY(98) , ENTRY(99) , ENTRY(100) , ENTRY(101) , ENTRY(102) , ENTRY(103) , ENTRY(104) , ENTRY(105) , ENTRY(106) , ENTRY(107) , ENTRY(108) , ENTRY(109) , ENTRY(110) , ENTRY(111) , ENTRY(112) , ENTRY(113) , ENTRY(114) , ENTRY(115) , ENTRY(116) , ENTRY(117) , ENTRY(118) , ENTRY(119) , ENTRY(120) , ENTRY(121) , ENTRY(122) , ENTRY(123) , ENTRY(124) , ENTRY(125) , ENTRY(126) , ENTRY(127) , ENTRY(128) , ENTRY(129) , ENTRY(130) , ENTRY(131) , ENTRY(132) , ENTRY(133) , ENTRY(134) , ENTRY(135) , ENTRY(136) , ENTRY(137) , ENTRY(138) , ENTRY(139) , ENTRY(140) , ENTRY(141) , ENTRY(142) , ENTRY(143) , ENTRY(144) , ENTRY(145) , ENTRY(146) , ENTRY(147) , ENTRY(148) , ENTRY(149) , ENTRY(150) , ENTRY(151) , ENTRY(152) , ENTRY(153) , ENTRY(154) , ENTRY(155) , ENTRY(156) , ENTRY(157) , ENTRY(158) , ENTRY(159) , ENTRY(160) , ENTRY(161) , ENTRY(162) , ENTRY(163) , ENTRY(164) , ENTRY(165) , ENTRY(166) , ENTRY(167) , ENTRY(168) , ENTRY(169) , ENTRY(170) , ENTRY(171) , ENTRY(172) , ENTRY(173) , ENTRY(174) , ENTRY(175) , ENTRY(176) , ENTRY(177) , ENTRY(178) , ENTRY(179) , ENTRY(180) , ENTRY(181) , ENTRY(182) , ENTRY(183) , ENTRY(184) , ENTRY(185) , ENTRY(186) , ENTRY(187) , ENTRY(188) , ENTRY(189) , ENTRY(190) , ENTRY(191) , ENTRY(192) , ENTRY(193) , ENTRY(194) , ENTRY(195) , ENTRY(196) , ENTRY(197) , ENTRY(198) , ENTRY(199) , ENTRY(200) , ENTRY(201) , ENTRY(202) , ENTRY(203) , ENTRY(204) , ENTRY(205) , ENTRY(206) , ENTRY(207) , ENTRY(208) , ENTRY(209) , ENTRY(210) , ENTRY(211) , ENTRY(212) , ENTRY(213) , ENTRY(214) , ENTRY(215) , ENTRY(216) , ENTRY(217) , ENTRY(218) , ENTRY(219) , ENTRY(220) , ENTRY(221) , ENTRY(222) , ENTRY(223) , ENTRY(224) , ENTRY(225) , ENTRY(226) , ENTRY(227) , ENTRY(228) , ENTRY(229) , ENTRY(230) , ENTRY(231) , ENTRY(232) , ENTRY(233) , ENTRY(234) , ENTRY(235) , ENTRY(236) , ENTRY(237) , ENTRY(238) , ENTRY(239) , ENTRY(240) , ENTRY(241) , ENTRY(242) , ENTRY(243) , ENTRY(244) , ENTRY(245) , ENTRY(246) , ENTRY(247) , ENTRY(248) , ENTRY(249) , ENTRY(250) , ENTRY(251) , ENTRY(252) , ENTRY(253) , ENTRY(254) , ENTRY(255) , #undef ENTRY #define HUFFDEC_EXTRA_LENGTH_BITS_MASK 0xFF #define HUFFDEC_LENGTH_BASE_SHIFT 8 #define HUFFDEC_END_OF_BLOCK_LENGTH 0 #define ENTRY(length_base, num_extra_bits) \ (((u32)(length_base) << HUFFDEC_LENGTH_BASE_SHIFT) | (num_extra_bits)) /* End of block */ ENTRY(HUFFDEC_END_OF_BLOCK_LENGTH, 0), /* Lengths */ ENTRY(3 , 0) , ENTRY(4 , 0) , ENTRY(5 , 0) , ENTRY(6 , 0), ENTRY(7 , 0) , ENTRY(8 , 0) , ENTRY(9 , 0) , ENTRY(10 , 0), ENTRY(11 , 1) , ENTRY(13 , 1) , ENTRY(15 , 1) , ENTRY(17 , 1), ENTRY(19 , 2) , ENTRY(23 , 2) , ENTRY(27 , 2) , ENTRY(31 , 2), ENTRY(35 , 3) , ENTRY(43 , 3) , ENTRY(51 , 3) , ENTRY(59 , 3), ENTRY(67 , 4) , ENTRY(83 , 4) , ENTRY(99 , 4) , ENTRY(115, 4), ENTRY(131, 5) , ENTRY(163, 5) , ENTRY(195, 5) , ENTRY(227, 5), ENTRY(258, 0) , ENTRY(258, 0) , ENTRY(258, 0) , #undef ENTRY }; /* The decode result for each offset symbol. This is the offset base and the * number of extra offset bits. */ static const u32 offset_decode_results[DEFLATE_NUM_OFFSET_SYMS] = { #define HUFFDEC_EXTRA_OFFSET_BITS_SHIFT 16 #define HUFFDEC_OFFSET_BASE_MASK (((u32)1 << HUFFDEC_EXTRA_OFFSET_BITS_SHIFT) - 1) #define ENTRY(offset_base, num_extra_bits) \ ((offset_base) | ((u32)(num_extra_bits) << HUFFDEC_EXTRA_OFFSET_BITS_SHIFT)) ENTRY(1 , 0) , ENTRY(2 , 0) , ENTRY(3 , 0) , ENTRY(4 , 0) , ENTRY(5 , 1) , ENTRY(7 , 1) , ENTRY(9 , 2) , ENTRY(13 , 2) , ENTRY(17 , 3) , ENTRY(25 , 3) , ENTRY(33 , 4) , ENTRY(49 , 4) , ENTRY(65 , 5) , ENTRY(97 , 5) , ENTRY(129 , 6) , ENTRY(193 , 6) , ENTRY(257 , 7) , ENTRY(385 , 7) , ENTRY(513 , 8) , ENTRY(769 , 8) , ENTRY(1025 , 9) , ENTRY(1537 , 9) , ENTRY(2049 , 10) , ENTRY(3073 , 10) , ENTRY(4097 , 11) , ENTRY(6145 , 11) , ENTRY(8193 , 12) , ENTRY(12289 , 12) , ENTRY(16385 , 13) , ENTRY(24577 , 13) , ENTRY(32769 , 14) , ENTRY(49153 , 14) , #undef ENTRY }; /* Construct a decode table entry from a decode result and codeword length. */ static forceinline u32 make_decode_table_entry(u32 result, u32 length) { return (result << HUFFDEC_RESULT_SHIFT) | length; } /* * Build a table for fast decoding of symbols from a Huffman code. As input, * this function takes the codeword length of each symbol which may be used in * the code. As output, it produces a decode table for the canonical Huffman * code described by the codeword lengths. The decode table is built with the * assumption that it will be indexed with "bit-reversed" codewords, where the * low-order bit is the first bit of the codeword. This format is used for all * Huffman codes in DEFLATE. * * @decode_table * The array in which the decode table will be generated. This array must * have sufficient length; see the definition of the ENOUGH numbers. * @lens * An array which provides, for each symbol, the length of the * corresponding codeword in bits, or 0 if the symbol is unused. This may * alias @decode_table, since nothing is written to @decode_table until all * @lens have been consumed. All codeword lengths are assumed to be <= * @max_codeword_len but are otherwise considered untrusted. If they do * not form a valid Huffman code, then the decode table is not built and * %false is returned. * @num_syms * The number of symbols in the code, including all unused symbols. * @decode_results * An array which provides, for each symbol, the actual value to store into * the decode table. This value will be directly produced as the result of * decoding that symbol, thereby moving the indirection out of the decode * loop and into the table initialization. * @table_bits * The log base-2 of the number of main table entries to use. * @max_codeword_len * The maximum allowed codeword length for this Huffman code. * @working_space * A temporary array of length '2 * (@max_codeword_len + 1) + @num_syms'. * * Returns %true if successful; %false if the codeword lengths do not form a * valid Huffman code. */ static bool build_decode_table(u32 decode_table[], const len_t lens[], const unsigned num_syms, const u32 decode_results[], const unsigned table_bits, const unsigned max_codeword_len, u16 working_space[]) { u16 * const len_counts = &working_space[0]; u16 * const offsets = &working_space[1 * (max_codeword_len + 1)]; u16 * const sorted_syms = &working_space[2 * (max_codeword_len + 1)]; unsigned len; unsigned sym; s32 remainder; unsigned sym_idx; unsigned codeword_len; unsigned codeword_reversed = 0; unsigned cur_codeword_prefix = -1; unsigned cur_table_start = 0; unsigned cur_table_bits = table_bits; unsigned num_dropped_bits = 0; const unsigned table_mask = (1U << table_bits) - 1; /* Count how many symbols have each codeword length, including 0. */ for (len = 0; len <= max_codeword_len; len++) len_counts[len] = 0; for (sym = 0; sym < num_syms; sym++) len_counts[lens[sym]]++; /* Sort the symbols primarily by increasing codeword length and * secondarily by increasing symbol value. */ /* Initialize 'offsets' so that offsets[len] is the number of codewords * shorter than 'len' bits, including length 0. */ offsets[0] = 0; for (len = 0; len < max_codeword_len; len++) offsets[len + 1] = offsets[len] + len_counts[len]; /* Use the 'offsets' array to sort the symbols. */ for (sym = 0; sym < num_syms; sym++) sorted_syms[offsets[lens[sym]]++] = sym; /* It is already guaranteed that all lengths are <= max_codeword_len, * but it cannot be assumed they form a complete prefix code. A * codeword of length n should require a proportion of the codespace * equaling (1/2)^n. The code is complete if and only if, by this * measure, the codespace is exactly filled by the lengths. */ remainder = 1; for (len = 1; len <= max_codeword_len; len++) { remainder <<= 1; remainder -= len_counts[len]; if (unlikely(remainder < 0)) { /* The lengths overflow the codespace; that is, the code * is over-subscribed. */ return false; } } if (unlikely(remainder != 0)) { /* The lengths do not fill the codespace; that is, they form an * incomplete code. */ /* Initialize the table entries to default values. When * decompressing a well-formed stream, these default values will * never be used. But since a malformed stream might contain * any bits at all, these entries need to be set anyway. */ u32 entry = make_decode_table_entry(decode_results[0], 1); for (sym = 0; sym < (1U << table_bits); sym++) decode_table[sym] = entry; /* A completely empty code is permitted. */ if (remainder == (1U << max_codeword_len)) return true; /* The code is nonempty and incomplete. Proceed only if there * is a single used symbol and its codeword has length 1. The * DEFLATE RFC is somewhat unclear regarding this case. What * zlib's decompressor does is permit this case for * literal/length and offset codes and assume the codeword is 0 * rather than 1. We do the same except we allow this case for * precodes too. */ if (remainder != (1U << (max_codeword_len - 1)) || len_counts[1] != 1) return false; } /* Generate the decode table entries. Since we process codewords from * shortest to longest, the main portion of the decode table is filled * first; then the subtables are filled. Note that it's already been * verified that the code is nonempty and not over-subscribed. */ /* Start with the smallest codeword length and the smallest-valued * symbol which has that codeword length. */ sym_idx = offsets[0]; codeword_len = 1; while (len_counts[codeword_len] == 0) codeword_len++; for (;;) { /* For each used symbol and its codeword... */ unsigned sym; u32 entry; unsigned i; unsigned end; unsigned increment; unsigned bit; /* Get the next symbol. */ sym = sorted_syms[sym_idx]; /* Start a new subtable if the codeword is long enough to * require a subtable, *and* the first 'table_bits' bits of the * codeword don't match the prefix for the previous subtable if * any. */ if (codeword_len > table_bits && (codeword_reversed & table_mask) != cur_codeword_prefix) { cur_codeword_prefix = (codeword_reversed & table_mask); cur_table_start += 1U << cur_table_bits; /* Calculate the subtable length. If the codeword * length exceeds 'table_bits' by n, the subtable needs * at least 2**n entries. But it may need more; if * there are fewer than 2**n codewords of length * 'table_bits + n' remaining, then n will need to be * incremented to bring in longer codewords until the * subtable can be filled completely. Note that it * always will, eventually, be possible to fill the * subtable, since the only case where we may have an * incomplete code is a single codeword of length 1, * and that never requires any subtables. */ cur_table_bits = codeword_len - table_bits; remainder = (s32)1 << cur_table_bits; for (;;) { remainder -= len_counts[table_bits + cur_table_bits]; if (remainder <= 0) break; cur_table_bits++; remainder <<= 1; } /* Create the entry that points from the main table to * the subtable. This entry contains the index of the * start of the subtable and the number of bits with * which the subtable is indexed (the log base 2 of the * number of entries it contains). */ decode_table[cur_codeword_prefix] = HUFFDEC_SUBTABLE_POINTER | make_decode_table_entry(cur_table_start, cur_table_bits); /* Now that we're filling a subtable, we need to drop * the first 'table_bits' bits of the codewords. */ num_dropped_bits = table_bits; } /* Create the decode table entry, which packs the decode result * and the codeword length (minus 'table_bits' for subtables) * together. */ entry = make_decode_table_entry(decode_results[sym], codeword_len - num_dropped_bits); /* Fill in as many copies of the decode table entry as are * needed. The number of entries to fill is a power of 2 and * depends on the codeword length; it could be as few as 1 or as * large as half the size of the table. Since the codewords are * bit-reversed, the indices to fill are those with the codeword * in its low bits; it's the high bits that vary. */ i = cur_table_start + (codeword_reversed >> num_dropped_bits); end = cur_table_start + (1U << cur_table_bits); increment = 1U << (codeword_len - num_dropped_bits); do { decode_table[i] = entry; i += increment; } while (i < end); /* Advance to the next codeword by incrementing it. But since * our codewords are bit-reversed, we must manipulate the bits * ourselves rather than simply adding 1. */ bit = 1U << (codeword_len - 1); while (codeword_reversed & bit) bit >>= 1; codeword_reversed &= bit - 1; codeword_reversed |= bit; /* Advance to the next symbol. This will either increase the * codeword length, or keep the same codeword length but * increase the symbol value. Note: since we are using * bit-reversed codewords, we don't need to explicitly append * zeroes to the codeword when the codeword length increases. */ if (++sym_idx == num_syms) return true; len_counts[codeword_len]--; while (len_counts[codeword_len] == 0) codeword_len++; } } /* Build the decode table for the precode. */ static bool build_precode_decode_table(struct libdeflate_decompressor *d) { /* When you change TABLEBITS, you must change ENOUGH, and vice versa! */ STATIC_ASSERT(PRECODE_TABLEBITS == 7 && PRECODE_ENOUGH == 128); return build_decode_table(d->u.l.precode_decode_table, d->u.precode_lens, DEFLATE_NUM_PRECODE_SYMS, precode_decode_results, PRECODE_TABLEBITS, DEFLATE_MAX_PRE_CODEWORD_LEN, d->working_space); } /* Build the decode table for the literal/length code. */ static bool build_litlen_decode_table(struct libdeflate_decompressor *d, unsigned num_litlen_syms, unsigned num_offset_syms) { /* When you change TABLEBITS, you must change ENOUGH, and vice versa! */ STATIC_ASSERT(LITLEN_TABLEBITS == 10 && LITLEN_ENOUGH == 1334); return build_decode_table(d->u.litlen_decode_table, d->u.l.lens, num_litlen_syms, litlen_decode_results, LITLEN_TABLEBITS, DEFLATE_MAX_LITLEN_CODEWORD_LEN, d->working_space); } /* Build the decode table for the offset code. */ static bool build_offset_decode_table(struct libdeflate_decompressor *d, unsigned num_litlen_syms, unsigned num_offset_syms) { /* When you change TABLEBITS, you must change ENOUGH, and vice versa! */ STATIC_ASSERT(OFFSET_TABLEBITS == 8 && OFFSET_ENOUGH == 402); return build_decode_table(d->offset_decode_table, d->u.l.lens + num_litlen_syms, num_offset_syms, offset_decode_results, OFFSET_TABLEBITS, DEFLATE_MAX_OFFSET_CODEWORD_LEN, d->working_space); } static forceinline machine_word_t repeat_byte(u8 b) { machine_word_t v; STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64); v = b; v |= v << 8; v |= v << 16; v |= v << ((WORDBITS == 64) ? 32 : 0); return v; } static forceinline void copy_word_unaligned(const void *src, void *dst) { store_word_unaligned(load_word_unaligned(src), dst); } /***************************************************************************** * Main decompression routine *****************************************************************************/ #define FUNCNAME deflate_decompress_default #define ATTRIBUTES #include "decompress_impl.h" #undef FUNCNAME #undef ATTRIBUTES #if X86_CPU_FEATURES_ENABLED && \ COMPILER_SUPPORTS_BMI2_TARGET && !defined(__BMI2__) # define FUNCNAME deflate_decompress_bmi2 # define ATTRIBUTES __attribute__((target("bmi2"))) # include "decompress_impl.h" # undef FUNCNAME # undef ATTRIBUTES # define DISPATCH_ENABLED 1 #else # define DISPATCH_ENABLED 0 #endif #if DISPATCH_ENABLED static enum libdeflate_result dispatch(struct libdeflate_decompressor * restrict d, const void * restrict in, size_t in_nbytes, void * restrict out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret); typedef enum libdeflate_result (*decompress_func_t) (struct libdeflate_decompressor * restrict d, const void * restrict in, size_t in_nbytes, void * restrict out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret); static decompress_func_t decompress_impl = dispatch; static enum libdeflate_result dispatch(struct libdeflate_decompressor * restrict d, const void * restrict in, size_t in_nbytes, void * restrict out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret) { decompress_func_t f = deflate_decompress_default; #if X86_CPU_FEATURES_ENABLED if (x86_have_cpu_features(X86_CPU_FEATURE_BMI2)) f = deflate_decompress_bmi2; #endif decompress_impl = f; return (*f)(d, in, in_nbytes, out, out_nbytes_avail, actual_out_nbytes_ret); } #endif /* DISPATCH_ENABLED */ /* * This is the main DEFLATE decompression routine. See libdeflate.h for the * documentation. * * Note that the real code is in decompress_impl.h. The part here just handles * calling the appropriate implementation depending on the CPU features at * runtime. */ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdeflate_decompressor * restrict d, const void * restrict in, size_t in_nbytes, void * restrict out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret) { #if DISPATCH_ENABLED return (*decompress_impl)(d, in, in_nbytes, out, out_nbytes_avail, actual_out_nbytes_ret); #else return deflate_decompress_default(d, in, in_nbytes, out, out_nbytes_avail, actual_out_nbytes_ret); #endif } LIBDEFLATEAPI struct libdeflate_decompressor * libdeflate_alloc_decompressor(void) { return malloc(sizeof(struct libdeflate_decompressor)); } LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor *d) { free(d); } advancecomp-1.23/libdeflate/gzip_compress.c000066400000000000000000000053261301462770100210510ustar00rootroot00000000000000/* * gzip_compress.c - compress with a gzip wrapper * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "deflate_compress.h" #include "gzip_constants.h" #include "unaligned.h" #include "libdeflate.h" LIBDEFLATEAPI size_t libdeflate_gzip_compress(struct libdeflate_compressor *c, const void *in, size_t in_size, void *out, size_t out_nbytes_avail) { u8 *out_next = out; unsigned compression_level; u8 xfl; size_t deflate_size; if (out_nbytes_avail <= GZIP_MIN_OVERHEAD) return 0; /* ID1 */ *out_next++ = GZIP_ID1; /* ID2 */ *out_next++ = GZIP_ID2; /* CM */ *out_next++ = GZIP_CM_DEFLATE; /* FLG */ *out_next++ = 0; /* MTIME */ put_unaligned_le32(GZIP_MTIME_UNAVAILABLE, out_next); out_next += 4; /* XFL */ xfl = 0; compression_level = deflate_get_compression_level(c); if (compression_level < 2) xfl |= GZIP_XFL_FASTEST_COMRESSION; else if (compression_level >= 8) xfl |= GZIP_XFL_SLOWEST_COMRESSION; *out_next++ = xfl; /* OS */ *out_next++ = GZIP_OS_UNKNOWN; /* OS */ /* Compressed data */ deflate_size = libdeflate_deflate_compress(c, in, in_size, out_next, out_nbytes_avail - GZIP_MIN_OVERHEAD); if (deflate_size == 0) return 0; out_next += deflate_size; /* CRC32 */ put_unaligned_le32(libdeflate_crc32(0, in, in_size), out_next); out_next += 4; /* ISIZE */ put_unaligned_le32((u32)in_size, out_next); out_next += 4; return out_next - (u8 *)out; } LIBDEFLATEAPI size_t libdeflate_gzip_compress_bound(struct libdeflate_compressor *c, size_t in_nbytes) { return GZIP_MIN_OVERHEAD + libdeflate_deflate_compress_bound(c, in_nbytes); } advancecomp-1.23/libdeflate/gzip_constants.h000066400000000000000000000020031301462770100212240ustar00rootroot00000000000000/* * gzip_constants.h - constants for the gzip wrapper format */ #ifndef LIB_GZIP_CONSTANTS_H #define LIB_GZIP_CONSTANTS_H #define GZIP_MIN_HEADER_SIZE 10 #define GZIP_FOOTER_SIZE 8 #define GZIP_MIN_OVERHEAD (GZIP_MIN_HEADER_SIZE + GZIP_FOOTER_SIZE) #define GZIP_ID1 0x1F #define GZIP_ID2 0x8B #define GZIP_CM_DEFLATE 8 #define GZIP_FTEXT 0x01 #define GZIP_FHCRC 0x02 #define GZIP_FEXTRA 0x04 #define GZIP_FNAME 0x08 #define GZIP_FCOMMENT 0x10 #define GZIP_FRESERVED 0xE0 #define GZIP_MTIME_UNAVAILABLE 0 #define GZIP_XFL_SLOWEST_COMRESSION 0x02 #define GZIP_XFL_FASTEST_COMRESSION 0x04 #define GZIP_OS_FAT 0 #define GZIP_OS_AMIGA 1 #define GZIP_OS_VMS 2 #define GZIP_OS_UNIX 3 #define GZIP_OS_VM_CMS 4 #define GZIP_OS_ATARI_TOS 5 #define GZIP_OS_HPFS 6 #define GZIP_OS_MACINTOSH 7 #define GZIP_OS_Z_SYSTEM 8 #define GZIP_OS_CP_M 9 #define GZIP_OS_TOPS_20 10 #define GZIP_OS_NTFS 11 #define GZIP_OS_QDOS 12 #define GZIP_OS_RISCOS 13 #define GZIP_OS_UNKNOWN 255 #endif /* LIB_GZIP_CONSTANTS_H */ advancecomp-1.23/libdeflate/gzip_decompress.c000066400000000000000000000067451301462770100213700ustar00rootroot00000000000000/* * gzip_decompress.c - decompress with a gzip wrapper * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "gzip_constants.h" #include "unaligned.h" #include "libdeflate.h" LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflate_decompressor *d, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret) { const u8 *in_next = in; const u8 * const in_end = in_next + in_nbytes; u8 flg; size_t actual_out_nbytes; enum libdeflate_result result; if (in_nbytes < GZIP_MIN_OVERHEAD) return LIBDEFLATE_BAD_DATA; /* ID1 */ if (*in_next++ != GZIP_ID1) return LIBDEFLATE_BAD_DATA; /* ID2 */ if (*in_next++ != GZIP_ID2) return LIBDEFLATE_BAD_DATA; /* CM */ if (*in_next++ != GZIP_CM_DEFLATE) return LIBDEFLATE_BAD_DATA; flg = *in_next++; /* MTIME */ in_next += 4; /* XFL */ in_next += 1; /* OS */ in_next += 1; if (flg & GZIP_FRESERVED) return LIBDEFLATE_BAD_DATA; /* Extra field */ if (flg & GZIP_FEXTRA) { u16 xlen = get_unaligned_le16(in_next); in_next += 2; if (in_end - in_next < (u32)xlen + GZIP_FOOTER_SIZE) return LIBDEFLATE_BAD_DATA; in_next += xlen; } /* Original file name (zero terminated) */ if (flg & GZIP_FNAME) { while (*in_next++ != 0 && in_next != in_end) ; if (in_end - in_next < GZIP_FOOTER_SIZE) return LIBDEFLATE_BAD_DATA; } /* File comment (zero terminated) */ if (flg & GZIP_FCOMMENT) { while (*in_next++ != 0 && in_next != in_end) ; if (in_end - in_next < GZIP_FOOTER_SIZE) return LIBDEFLATE_BAD_DATA; } /* CRC16 for gzip header */ if (flg & GZIP_FHCRC) { in_next += 2; if (in_end - in_next < GZIP_FOOTER_SIZE) return LIBDEFLATE_BAD_DATA; } /* Compressed data */ result = libdeflate_deflate_decompress(d, in_next, in_end - GZIP_FOOTER_SIZE - in_next, out, out_nbytes_avail, actual_out_nbytes_ret); if (result != LIBDEFLATE_SUCCESS) return result; if (actual_out_nbytes_ret) actual_out_nbytes = *actual_out_nbytes_ret; else actual_out_nbytes = out_nbytes_avail; in_next = in_end - GZIP_FOOTER_SIZE; /* CRC32 */ if (libdeflate_crc32(0, out, actual_out_nbytes) != get_unaligned_le32(in_next)) return LIBDEFLATE_BAD_DATA; in_next += 4; /* ISIZE */ if ((u32)actual_out_nbytes != get_unaligned_le32(in_next)) return LIBDEFLATE_BAD_DATA; return LIBDEFLATE_SUCCESS; } advancecomp-1.23/libdeflate/hc_matchfinder.h000066400000000000000000000335341301462770100211320ustar00rootroot00000000000000/* * hc_matchfinder.h - Lempel-Ziv matchfinding with a hash table of linked lists * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * --------------------------------------------------------------------------- * * Algorithm * * This is a Hash Chains (hc) based matchfinder. * * The main data structure is a hash table where each hash bucket contains a * linked list (or "chain") of sequences whose first 4 bytes share the same hash * code. Each sequence is identified by its starting position in the input * buffer. * * The algorithm processes the input buffer sequentially. At each byte * position, the hash code of the first 4 bytes of the sequence beginning at * that position (the sequence being matched against) is computed. This * identifies the hash bucket to use for that position. Then, this hash * bucket's linked list is searched for matches. Then, a new linked list node * is created to represent the current sequence and is prepended to the list. * * This algorithm has several useful properties: * * - It only finds true Lempel-Ziv matches; i.e., those where the matching * sequence occurs prior to the sequence being matched against. * * - The sequences in each linked list are always sorted by decreasing starting * position. Therefore, the closest (smallest offset) matches are found * first, which in many compression formats tend to be the cheapest to encode. * * - Although fast running time is not guaranteed due to the possibility of the * lists getting very long, the worst degenerate behavior can be easily * prevented by capping the number of nodes searched at each position. * * - If the compressor decides not to search for matches at a certain position, * then that position can be quickly inserted without searching the list. * * - The algorithm is adaptable to sliding windows: just store the positions * relative to a "base" value that is updated from time to time, and stop * searching each list when the sequences get too far away. * * ---------------------------------------------------------------------------- * * Optimizations * * The main hash table and chains handle length 4+ matches. Length 3 matches * are handled by a separate hash table with no chains. This works well for * typical "greedy" or "lazy"-style compressors, where length 3 matches are * often only helpful if they have small offsets. Instead of searching a full * chain for length 3+ matches, the algorithm just checks for one close length 3 * match, then focuses on finding length 4+ matches. * * The longest_match() and skip_positions() functions are inlined into the * compressors that use them. This isn't just about saving the overhead of a * function call. These functions are intended to be called from the inner * loops of compressors, where giving the compiler more control over register * allocation is very helpful. There is also significant benefit to be gained * from allowing the CPU to predict branches independently at each call site. * For example, "lazy"-style compressors can be written with two calls to * longest_match(), each of which starts with a different 'best_len' and * therefore has significantly different performance characteristics. * * Although any hash function can be used, a multiplicative hash is fast and * works well. * * On some processors, it is significantly faster to extend matches by whole * words (32 or 64 bits) instead of by individual bytes. For this to be the * case, the processor must implement unaligned memory accesses efficiently and * must have either a fast "find first set bit" instruction or a fast "find last * set bit" instruction, depending on the processor's endianness. * * The code uses one loop for finding the first match and one loop for finding a * longer match. Each of these loops is tuned for its respective task and in * combination are faster than a single generalized loop that handles both * tasks. * * The code also uses a tight inner loop that only compares the last and first * bytes of a potential match. It is only when these bytes match that a full * match extension is attempted. * * ---------------------------------------------------------------------------- */ #include "matchfinder_common.h" #define HC_MATCHFINDER_HASH3_ORDER 15 #define HC_MATCHFINDER_HASH4_ORDER 16 #define HC_MATCHFINDER_TOTAL_HASH_LENGTH \ ((1UL << HC_MATCHFINDER_HASH3_ORDER) + \ (1UL << HC_MATCHFINDER_HASH4_ORDER)) struct hc_matchfinder { /* The hash table for finding length 3 matches */ mf_pos_t hash3_tab[1UL << HC_MATCHFINDER_HASH3_ORDER]; /* The hash table which contains the first nodes of the linked lists for * finding length 4+ matches */ mf_pos_t hash4_tab[1UL << HC_MATCHFINDER_HASH4_ORDER]; /* The "next node" references for the linked lists. The "next node" of * the node for the sequence with position 'pos' is 'next_tab[pos]'. */ mf_pos_t next_tab[MATCHFINDER_WINDOW_SIZE]; } #ifdef _aligned_attribute _aligned_attribute(MATCHFINDER_ALIGNMENT) #endif ; /* Prepare the matchfinder for a new input buffer. */ static forceinline void hc_matchfinder_init(struct hc_matchfinder *mf) { matchfinder_init((mf_pos_t *)mf, HC_MATCHFINDER_TOTAL_HASH_LENGTH); } static forceinline void hc_matchfinder_slide_window(struct hc_matchfinder *mf) { matchfinder_rebase((mf_pos_t *)mf, sizeof(struct hc_matchfinder) / sizeof(mf_pos_t)); } /* * Find the longest match longer than 'best_len' bytes. * * @mf * The matchfinder structure. * @in_base_p * Location of a pointer which points to the place in the input data the * matchfinder currently stores positions relative to. This may be updated * by this function. * @cur_pos * The current position in the input buffer relative to @in_base (the * position of the sequence being matched against). * @best_len * Require a match longer than this length. * @max_len * The maximum permissible match length at this position. * @nice_len * Stop searching if a match of at least this length is found. * Must be <= @max_len. * @max_search_depth * Limit on the number of potential matches to consider. Must be >= 1. * @next_hashes * The precomputed hash codes for the sequence beginning at @in_next. * These will be used and then updated with the precomputed hashcodes for * the sequence beginning at @in_next + 1. * @offset_ret * If a match is found, its offset is returned in this location. * * Return the length of the match found, or 'best_len' if no match longer than * 'best_len' was found. */ static forceinline u32 hc_matchfinder_longest_match(struct hc_matchfinder * const restrict mf, const u8 ** const restrict in_base_p, const u8 * const restrict in_next, u32 best_len, const u32 max_len, const u32 nice_len, const u32 max_search_depth, u32 * const restrict next_hashes, u32 * const restrict offset_ret) { u32 depth_remaining = max_search_depth; const u8 *best_matchptr = in_next; mf_pos_t cur_node3, cur_node4; u32 hash3, hash4; u32 next_seq3, next_seq4; u32 seq4; const u8 *matchptr; u32 len; u32 cur_pos = in_next - *in_base_p; const u8 *in_base; mf_pos_t cutoff; if (cur_pos == MATCHFINDER_WINDOW_SIZE) { hc_matchfinder_slide_window(mf); *in_base_p += MATCHFINDER_WINDOW_SIZE; cur_pos = 0; } in_base = *in_base_p; cutoff = cur_pos - MATCHFINDER_WINDOW_SIZE; if (unlikely(max_len < 5)) /* can we read 4 bytes from 'in_next + 1'? */ goto out; /* Get the precomputed hash codes. */ hash3 = next_hashes[0]; hash4 = next_hashes[1]; /* From the hash buckets, get the first node of each linked list. */ cur_node3 = mf->hash3_tab[hash3]; cur_node4 = mf->hash4_tab[hash4]; /* Update for length 3 matches. This replaces the singleton node in the * 'hash3' bucket with the node for the current sequence. */ mf->hash3_tab[hash3] = cur_pos; /* Update for length 4 matches. This prepends the node for the current * sequence to the linked list in the 'hash4' bucket. */ mf->hash4_tab[hash4] = cur_pos; mf->next_tab[cur_pos] = cur_node4; /* Compute the next hash codes. */ next_seq4 = load_u32_unaligned(in_next + 1); next_seq3 = loaded_u32_to_u24(next_seq4); next_hashes[0] = lz_hash(next_seq3, HC_MATCHFINDER_HASH3_ORDER); next_hashes[1] = lz_hash(next_seq4, HC_MATCHFINDER_HASH4_ORDER); prefetchw(&mf->hash3_tab[next_hashes[0]]); prefetchw(&mf->hash4_tab[next_hashes[1]]); if (best_len < 4) { /* No match of length >= 4 found yet? */ /* Check for a length 3 match if needed. */ if (cur_node3 <= cutoff) goto out; seq4 = load_u32_unaligned(in_next); if (best_len < 3) { matchptr = &in_base[cur_node3]; if (load_u24_unaligned(matchptr) == loaded_u32_to_u24(seq4)) { best_len = 3; best_matchptr = matchptr; } } /* Check for a length 4 match. */ if (cur_node4 <= cutoff) goto out; for (;;) { /* No length 4 match found yet. Check the first 4 bytes. */ matchptr = &in_base[cur_node4]; if (load_u32_unaligned(matchptr) == seq4) break; /* The first 4 bytes did not match. Keep trying. */ cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)]; if (cur_node4 <= cutoff || !--depth_remaining) goto out; } /* Found a match of length >= 4. Extend it to its full length. */ best_matchptr = matchptr; best_len = lz_extend(in_next, best_matchptr, 4, max_len); if (best_len >= nice_len) goto out; cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)]; if (cur_node4 <= cutoff || !--depth_remaining) goto out; } else { if (cur_node4 <= cutoff || best_len >= nice_len) goto out; } /* Check for matches of length >= 5. */ for (;;) { for (;;) { matchptr = &in_base[cur_node4]; /* Already found a length 4 match. Try for a longer * match; start by checking either the last 4 bytes and * the first 4 bytes, or the last byte. (The last byte, * the one which would extend the match length by 1, is * the most important.) */ #if UNALIGNED_ACCESS_IS_FAST if ((load_u32_unaligned(matchptr + best_len - 3) == load_u32_unaligned(in_next + best_len - 3)) && (load_u32_unaligned(matchptr) == load_u32_unaligned(in_next))) #else if (matchptr[best_len] == in_next[best_len]) #endif break; /* Continue to the next node in the list. */ cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)]; if (cur_node4 <= cutoff || !--depth_remaining) goto out; } #if UNALIGNED_ACCESS_IS_FAST len = 4; #else len = 0; #endif len = lz_extend(in_next, matchptr, len, max_len); if (len > best_len) { /* This is the new longest match. */ best_len = len; best_matchptr = matchptr; if (best_len >= nice_len) goto out; } /* Continue to the next node in the list. */ cur_node4 = mf->next_tab[cur_node4 & (MATCHFINDER_WINDOW_SIZE - 1)]; if (cur_node4 <= cutoff || !--depth_remaining) goto out; } out: *offset_ret = in_next - best_matchptr; return best_len; } /* * Advance the matchfinder, but don't search for matches. * * @mf * The matchfinder structure. * @in_base_p * Location of a pointer which points to the place in the input data the * matchfinder currently stores positions relative to. This may be updated * by this function. * @cur_pos * The current position in the input buffer relative to @in_base. * @end_pos * The end position of the input buffer, relative to @in_base. * @next_hashes * The precomputed hash codes for the sequence beginning at @in_next. * These will be used and then updated with the precomputed hashcodes for * the sequence beginning at @in_next + @count. * @count * The number of bytes to advance. Must be > 0. * * Returns @in_next + @count. */ static forceinline const u8 * hc_matchfinder_skip_positions(struct hc_matchfinder * const restrict mf, const u8 ** const restrict in_base_p, const u8 *in_next, const u8 * const in_end, const u32 count, u32 * const restrict next_hashes) { u32 cur_pos; u32 hash3, hash4; u32 next_seq3, next_seq4; u32 remaining = count; if (unlikely(count + 5 > in_end - in_next)) return &in_next[count]; cur_pos = in_next - *in_base_p; hash3 = next_hashes[0]; hash4 = next_hashes[1]; do { if (cur_pos == MATCHFINDER_WINDOW_SIZE) { hc_matchfinder_slide_window(mf); *in_base_p += MATCHFINDER_WINDOW_SIZE; cur_pos = 0; } mf->hash3_tab[hash3] = cur_pos; mf->next_tab[cur_pos] = mf->hash4_tab[hash4]; mf->hash4_tab[hash4] = cur_pos; next_seq4 = load_u32_unaligned(++in_next); next_seq3 = loaded_u32_to_u24(next_seq4); hash3 = lz_hash(next_seq3, HC_MATCHFINDER_HASH3_ORDER); hash4 = lz_hash(next_seq4, HC_MATCHFINDER_HASH4_ORDER); cur_pos++; } while (--remaining); prefetchw(&mf->hash3_tab[hash3]); prefetchw(&mf->hash4_tab[hash4]); next_hashes[0] = hash3; next_hashes[1] = hash4; return in_next; } advancecomp-1.23/libdeflate/lib_common.h000066400000000000000000000023421301462770100203030ustar00rootroot00000000000000/* * lib_common.h - internal header included by all library code */ #ifndef LIB_LIB_COMMON_H #define LIB_LIB_COMMON_H #ifdef LIBDEFLATE_H # error "lib_common.h must always be included before libdeflate.h" /* because BUILDING_LIBDEFLATE must be set first */ #endif #define BUILDING_LIBDEFLATE #include "common_defs.h" /* * Prefix with "_libdeflate_" all global symbols which are not part of the API. * This avoids exposing overly generic names when libdeflate is built as a * static library. * * Note that the chosen prefix is not really important and can be changed * without breaking library users. It was just chosen so that the resulting * symbol names are unlikely to conflict with those from any other software. * Also note that this fixup has no useful effect when libdeflate is built as a * shared library, since these symbols are not exported. */ #define SYM_FIXUP(sym) _libdeflate_##sym #define aligned_malloc SYM_FIXUP(aligned_malloc) #define aligned_free SYM_FIXUP(aligned_free) #define deflate_get_compression_level SYM_FIXUP(deflate_get_compression_level) #define _x86_cpu_features SYM_FIXUP(_x86_cpu_features) #define x86_setup_cpu_features SYM_FIXUP(x86_setup_cpu_features) #endif /* LIB_LIB_COMMON_H */ advancecomp-1.23/libdeflate/libdeflate.h000066400000000000000000000250461301462770100202660ustar00rootroot00000000000000/* * libdeflate.h - public header for libdeflate */ #ifndef LIBDEFLATE_H #define LIBDEFLATE_H #ifdef __cplusplus extern "C" { #endif #define LIBDEFLATE_VERSION_MAJOR 0 #define LIBDEFLATE_VERSION_MINOR 6 #define LIBDEFLATE_VERSION_STRING "0.6" #include #include /* * On Windows, if you want to link to the DLL version of libdeflate, then * #define LIBDEFLATE_DLL. */ #ifdef LIBDEFLATE_DLL # ifdef BUILDING_LIBDEFLATE # define LIBDEFLATEAPI LIBEXPORT # elif defined(_WIN32) || defined(__CYGWIN__) # define LIBDEFLATEAPI __declspec(dllimport) # endif #endif #ifndef LIBDEFLATEAPI # define LIBDEFLATEAPI #endif /* ========================================================================== */ /* Compression */ /* ========================================================================== */ struct libdeflate_compressor; /* * libdeflate_alloc_compressor() allocates a new compressor that supports * DEFLATE, zlib, and gzip compression. 'compression_level' is the compression * level on a zlib-like scale but with a higher maximum value (1 = fastest, 6 = * medium/default, 9 = slow, 12 = slowest). The return value is a pointer to * the new compressor, or NULL if out of memory. * * Note: for compression, the sliding window size is defined at compilation time * to 32768, the largest size permissible in the DEFLATE format. It cannot be * changed at runtime. * * A single compressor is not safe to use by multiple threads concurrently. * However, different threads may use different compressors concurrently. */ LIBDEFLATEAPI struct libdeflate_compressor * libdeflate_alloc_compressor(int compression_level); /* * libdeflate_deflate_compress() performs raw DEFLATE compression on a buffer of * data. The function attempts to compress 'in_nbytes' bytes of data located at * 'in' and write the results to 'out', which has space for 'out_nbytes_avail' * bytes. The return value is the compressed size in bytes, or 0 if the data * could not be compressed to 'out_nbytes_avail' bytes or fewer. */ LIBDEFLATEAPI size_t libdeflate_deflate_compress(struct libdeflate_compressor *compressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail); /* * libdeflate_deflate_compress_bound() returns a worst-case upper bound on the * number of bytes of compressed data that may be produced by compressing any * buffer of length less than or equal to 'in_nbytes' using * libdeflate_deflate_compress() with the specified compressor. Mathematically, * this bound will necessarily be a number greater than or equal to 'in_nbytes'. * It may be an overestimate of the true upper bound. The return value is * guaranteed to be the same for all invocations with the same compressor and * same 'in_nbytes'. * * As a special case, 'compressor' may be NULL. This causes the bound to be * taken across *any* libdeflate_compressor that could ever be allocated with * this build of the library, with any options. * * Note that this function is not necessary in many applications. With * block-based compression, it is usually preferable to separately store the * uncompressed size of each block and to store any blocks that did not compress * to less than their original size uncompressed. In that scenario, there is no * need to know the worst-case compressed size, since the maximum number of * bytes of compressed data that may be used would always be one less than the * input length. You can just pass a buffer of that size to * libdeflate_deflate_compress() and store the data uncompressed if * libdeflate_deflate_compress() returns 0, indicating that the compressed data * did not fit into the provided output buffer. */ LIBDEFLATEAPI size_t libdeflate_deflate_compress_bound(struct libdeflate_compressor *compressor, size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but stores the data in the zlib wrapper * format. */ LIBDEFLATEAPI size_t libdeflate_zlib_compress(struct libdeflate_compressor *compressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_zlib_compress() rather than with * libdeflate_deflate_compress(). */ LIBDEFLATEAPI size_t libdeflate_zlib_compress_bound(struct libdeflate_compressor *compressor, size_t in_nbytes); /* * Like libdeflate_deflate_compress(), but stores the data in the gzip wrapper * format. */ LIBDEFLATEAPI size_t libdeflate_gzip_compress(struct libdeflate_compressor *compressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail); /* * Like libdeflate_deflate_compress_bound(), but assumes the data will be * compressed with libdeflate_gzip_compress() rather than with * libdeflate_deflate_compress(). */ LIBDEFLATEAPI size_t libdeflate_gzip_compress_bound(struct libdeflate_compressor *compressor, size_t in_nbytes); /* * libdeflate_free_compressor() frees a compressor that was allocated with * libdeflate_alloc_compressor(). If a NULL pointer is passed in, no action is * taken. */ LIBDEFLATEAPI void libdeflate_free_compressor(struct libdeflate_compressor *compressor); /* ========================================================================== */ /* Decompression */ /* ========================================================================== */ struct libdeflate_decompressor; /* * libdeflate_alloc_decompressor() allocates a new decompressor that can be used * for DEFLATE, zlib, and gzip decompression. The return value is a pointer to * the new decompressor, or NULL if out of memory. * * This function takes no parameters, and the returned decompressor is valid for * decompressing data that was compressed at any compression level and with any * sliding window size. * * A single decompressor is not safe to use by multiple threads concurrently. * However, different threads may use different decompressors concurrently. */ LIBDEFLATEAPI struct libdeflate_decompressor * libdeflate_alloc_decompressor(void); /* * Result of a call to libdeflate_deflate_decompress(), * libdeflate_zlib_decompress(), or libdeflate_gzip_decompress(). */ enum libdeflate_result { /* Decompression was successful. */ LIBDEFLATE_SUCCESS = 0, /* Decompressed failed because the compressed data was invalid, corrupt, * or otherwise unsupported. */ LIBDEFLATE_BAD_DATA = 1, /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have * decompressed to fewer than 'out_nbytes_avail' bytes. */ LIBDEFLATE_SHORT_OUTPUT = 2, /* The data would have decompressed to more than 'out_nbytes_avail' * bytes. */ LIBDEFLATE_INSUFFICIENT_SPACE = 3, }; /* * libdeflate_deflate_decompress() decompresses 'in_nbytes' bytes of * raw DEFLATE-compressed data at 'in' and writes the uncompressed data to * 'out', which is a buffer of at least 'out_nbytes_avail' bytes. If * decompression was successful, then 0 (LIBDEFLATE_SUCCESS) is returned; * otherwise, a nonzero result code such as LIBDEFLATE_BAD_DATA is returned. If * a nonzero result code is returned, then the contents of the output buffer are * undefined. * * libdeflate_deflate_decompress() can be used in cases where the actual * uncompressed size is known (recommended) or unknown (not recommended): * * - If the actual uncompressed size is known, then pass the actual * uncompressed size as 'out_nbytes_avail' and pass NULL for * 'actual_out_nbytes_ret'. This makes libdeflate_deflate_decompress() fail * with LIBDEFLATE_SHORT_OUTPUT if the data decompressed to fewer than the * specified number of bytes. * * - If the actual uncompressed size is unknown, then provide a non-NULL * 'actual_out_nbytes_ret' and provide a buffer with some size * 'out_nbytes_avail' that you think is large enough to hold all the * uncompressed data. In this case, if the data decompresses to less than * or equal to 'out_nbytes_avail' bytes, then * libdeflate_deflate_decompress() will write the actual uncompressed size * to *actual_out_nbytes_ret and return 0 (LIBDEFLATE_SUCCESS). Otherwise, * it will return LIBDEFLATE_INSUFFICIENT_SPACE if the provided buffer was * not large enough but no other problems were encountered, or another * nonzero result code if decompression failed for another reason. */ LIBDEFLATEAPI enum libdeflate_result libdeflate_deflate_decompress(struct libdeflate_decompressor *decompressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the zlib wrapper format * instead of raw DEFLATE. */ LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflate_decompressor *decompressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret); /* * Like libdeflate_deflate_decompress(), but assumes the gzip wrapper format * instead of raw DEFLATE. */ LIBDEFLATEAPI enum libdeflate_result libdeflate_gzip_decompress(struct libdeflate_decompressor *decompressor, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret); /* * libdeflate_free_decompressor() frees a decompressor that was allocated with * libdeflate_alloc_decompressor(). If a NULL pointer is passed in, no action * is taken. */ LIBDEFLATEAPI void libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor); /* ========================================================================== */ /* Checksums */ /* ========================================================================== */ /* * libdeflate_adler32() updates a running Adler-32 checksum with 'len' bytes of * data and returns the updated checksum. When starting a new checksum, the * required initial value for 'adler' is 1. This value is also returned when * 'buffer' is specified as NULL. */ LIBDEFLATEAPI uint32_t libdeflate_adler32(uint32_t adler32, const void *buffer, size_t len); /* * libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data * and returns the updated checksum. When starting a new checksum, the required * initial value for 'crc' is 0. This value is also returned when 'buffer' is * specified as NULL. */ LIBDEFLATEAPI uint32_t libdeflate_crc32(uint32_t crc, const void *buffer, size_t len); #ifdef __cplusplus } #endif #endif /* LIBDEFLATE_H */ advancecomp-1.23/libdeflate/matchfinder_avx2.h000066400000000000000000000021221301462770100214050ustar00rootroot00000000000000/* * matchfinder_avx2.h - matchfinding routines optimized for Intel AVX2 (Advanced * Vector Extensions) */ #include static forceinline bool matchfinder_init_avx2(mf_pos_t *data, size_t size) { __m256i v, *p; size_t n; if (size % sizeof(__m256i) * 4) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = _mm256_set1_epi16(MATCHFINDER_INITVAL); p = (__m256i *)data; n = size / (sizeof(__m256i) * 4); do { p[0] = v; p[1] = v; p[2] = v; p[3] = v; p += 4; } while (--n); return true; } static forceinline bool matchfinder_rebase_avx2(mf_pos_t *data, size_t size) { __m256i v, *p; size_t n; if ((size % sizeof(__m256i) * 4 != 0)) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = _mm256_set1_epi16((u16)-MATCHFINDER_WINDOW_SIZE); p = (__m256i *)data; n = size / (sizeof(__m256i) * 4); do { /* PADDSW: Add Packed Signed Integers With Signed Saturation */ p[0] = _mm256_adds_epi16(p[0], v); p[1] = _mm256_adds_epi16(p[1], v); p[2] = _mm256_adds_epi16(p[2], v); p[3] = _mm256_adds_epi16(p[3], v); p += 4; } while (--n); return true; } advancecomp-1.23/libdeflate/matchfinder_common.h000066400000000000000000000126431301462770100220260ustar00rootroot00000000000000/* * matchfinder_common.h - common code for Lempel-Ziv matchfinding */ #ifndef LIB_MATCHFINDER_COMMON_H #define LIB_MATCHFINDER_COMMON_H #include "lib_common.h" #include "unaligned.h" #ifndef MATCHFINDER_WINDOW_ORDER # error "MATCHFINDER_WINDOW_ORDER must be defined!" #endif #define MATCHFINDER_WINDOW_SIZE (1UL << MATCHFINDER_WINDOW_ORDER) typedef s16 mf_pos_t; #define MATCHFINDER_INITVAL ((mf_pos_t)-MATCHFINDER_WINDOW_SIZE) #define MATCHFINDER_ALIGNMENT 8 #ifdef __AVX2__ # include "matchfinder_avx2.h" # if MATCHFINDER_ALIGNMENT < 32 # undef MATCHFINDER_ALIGNMENT # define MATCHFINDER_ALIGNMENT 32 # endif #endif #ifdef __SSE2__ # include "matchfinder_sse2.h" # if MATCHFINDER_ALIGNMENT < 16 # undef MATCHFINDER_ALIGNMENT # define MATCHFINDER_ALIGNMENT 16 # endif #endif #ifdef __ARM_NEON # include "matchfinder_neon.h" # if MATCHFINDER_ALIGNMENT < 16 # undef MATCHFINDER_ALIGNMENT # define MATCHFINDER_ALIGNMENT 16 # endif #endif /* * Initialize the hash table portion of the matchfinder. * * Essentially, this is an optimized memset(). * * 'data' must be aligned to a MATCHFINDER_ALIGNMENT boundary. */ static forceinline void matchfinder_init(mf_pos_t *data, size_t num_entries) { size_t i; #if defined(__AVX2__) && defined(_aligned_attribute) if (matchfinder_init_avx2(data, num_entries * sizeof(data[0]))) return; #endif #if defined(__SSE2__) && defined(_aligned_attribute) if (matchfinder_init_sse2(data, num_entries * sizeof(data[0]))) return; #endif #if defined(__ARM_NEON) && defined(_aligned_attribute) if (matchfinder_init_neon(data, num_entries * sizeof(data[0]))) return; #endif for (i = 0; i < num_entries; i++) data[i] = MATCHFINDER_INITVAL; } /* * Slide the matchfinder by WINDOW_SIZE bytes. * * This must be called just after each WINDOW_SIZE bytes have been run through * the matchfinder. * * This will subtract WINDOW_SIZE bytes from each entry in the array specified. * The effect is that all entries are updated to be relative to the current * position, rather than the position WINDOW_SIZE bytes prior. * * Underflow is detected and replaced with signed saturation. This ensures that * once the sliding window has passed over a position, that position forever * remains out of bounds. * * The array passed in must contain all matchfinder data that is * position-relative. Concretely, this will include the hash table as well as * the table of positions that is used to link together the sequences in each * hash bucket. Note that in the latter table, the links are 1-ary in the case * of "hash chains", and 2-ary in the case of "binary trees". In either case, * the links need to be rebased in the same way. */ static forceinline void matchfinder_rebase(mf_pos_t *data, size_t num_entries) { size_t i; #if defined(__AVX2__) && defined(_aligned_attribute) if (matchfinder_rebase_avx2(data, num_entries * sizeof(data[0]))) return; #endif #if defined(__SSE2__) && defined(_aligned_attribute) if (matchfinder_rebase_sse2(data, num_entries * sizeof(data[0]))) return; #endif #if defined(__ARM_NEON) && defined(_aligned_attribute) if (matchfinder_rebase_neon(data, num_entries * sizeof(data[0]))) return; #endif if (MATCHFINDER_WINDOW_SIZE == 32768) { /* Branchless version for 32768 byte windows. If the value was * already negative, clear all bits except the sign bit; this * changes the value to -32768. Otherwise, set the sign bit; * this is equivalent to subtracting 32768. */ for (i = 0; i < num_entries; i++) { u16 v = data[i]; u16 sign_bit = v & 0x8000; v &= sign_bit - ((sign_bit >> 15) ^ 1); v |= 0x8000; data[i] = v; } return; } for (i = 0; i < num_entries; i++) { if (data[i] >= 0) data[i] -= (mf_pos_t)-MATCHFINDER_WINDOW_SIZE; else data[i] = (mf_pos_t)-MATCHFINDER_WINDOW_SIZE; } } /* * The hash function: given a sequence prefix held in the low-order bits of a * 32-bit value, multiply by a carefully-chosen large constant. Discard any * bits of the product that don't fit in a 32-bit value, but take the * next-highest @num_bits bits of the product as the hash value, as those have * the most randomness. */ static forceinline u32 lz_hash(u32 seq, unsigned num_bits) { return (u32)(seq * 0x1E35A7BD) >> (32 - num_bits); } /* * Return the number of bytes at @matchptr that match the bytes at @strptr, up * to a maximum of @max_len. Initially, @start_len bytes are matched. */ static forceinline unsigned lz_extend(const u8 * const strptr, const u8 * const matchptr, const unsigned start_len, const unsigned max_len) { unsigned len = start_len; machine_word_t v_word; if (UNALIGNED_ACCESS_IS_FAST) { if (likely(max_len - len >= 4 * WORDBYTES)) { #define COMPARE_WORD_STEP \ v_word = load_word_unaligned(&matchptr[len]) ^ \ load_word_unaligned(&strptr[len]); \ if (v_word != 0) \ goto word_differs; \ len += WORDBYTES; \ COMPARE_WORD_STEP COMPARE_WORD_STEP COMPARE_WORD_STEP COMPARE_WORD_STEP #undef COMPARE_WORD_STEP } while (len + WORDBYTES <= max_len) { v_word = load_word_unaligned(&matchptr[len]) ^ load_word_unaligned(&strptr[len]); if (v_word != 0) goto word_differs; len += WORDBYTES; } } while (len < max_len && matchptr[len] == strptr[len]) len++; return len; word_differs: if (CPU_IS_LITTLE_ENDIAN()) len += (bsfw(v_word) >> 3); else len += (WORDBITS - 1 - bsrw(v_word)) >> 3; return len; } #endif /* LIB_MATCHFINDER_COMMON_H */ advancecomp-1.23/libdeflate/matchfinder_neon.h000066400000000000000000000025701301462770100214730ustar00rootroot00000000000000/* * matchfinder_neon.h - matchfinding routines optimized for ARM NEON (Advanced * SIMD) instructions */ #include static forceinline bool matchfinder_init_neon(mf_pos_t *data, size_t size) { int16x8_t v, *p; size_t n; if (size % sizeof(int16x8_t) * 4) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = (int16x8_t) { MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, MATCHFINDER_INITVAL, }; p = (int16x8_t *)data; n = size / (sizeof(int16x8_t) * 4); do { p[0] = v; p[1] = v; p[2] = v; p[3] = v; p += 4; } while (--n); return true; } static forceinline bool matchfinder_rebase_neon(mf_pos_t *data, size_t size) { int16x8_t v, *p; size_t n; if ((size % sizeof(int16x8_t) * 4 != 0)) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = (int16x8_t) { (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, (u16)-MATCHFINDER_WINDOW_SIZE, }; p = (int16x8_t *)data; n = size / (sizeof(int16x8_t) * 4); do { p[0] = vqaddq_s16(p[0], v); p[1] = vqaddq_s16(p[1], v); p[2] = vqaddq_s16(p[2], v); p[3] = vqaddq_s16(p[3], v); p += 4; } while (--n); return true; } advancecomp-1.23/libdeflate/matchfinder_sse2.h000066400000000000000000000021001301462770100213750ustar00rootroot00000000000000/* * matchfinder_sse2.h - matchfinding routines optimized for Intel SSE2 * (Streaming SIMD Extensions). */ #include static forceinline bool matchfinder_init_sse2(mf_pos_t *data, size_t size) { __m128i v, *p; size_t n; if (size % sizeof(__m128i) * 4) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = _mm_set1_epi16(MATCHFINDER_INITVAL); p = (__m128i *)data; n = size / (sizeof(__m128i) * 4); do { p[0] = v; p[1] = v; p[2] = v; p[3] = v; p += 4; } while (--n); return true; } static forceinline bool matchfinder_rebase_sse2(mf_pos_t *data, size_t size) { __m128i v, *p; size_t n; if ((size % sizeof(__m128i) * 4 != 0)) return false; STATIC_ASSERT(sizeof(mf_pos_t) == 2); v = _mm_set1_epi16((u16)-MATCHFINDER_WINDOW_SIZE); p = (__m128i *)data; n = size / (sizeof(__m128i) * 4); do { /* PADDSW: Add Packed Signed Integers With Signed Saturation */ p[0] = _mm_adds_epi16(p[0], v); p[1] = _mm_adds_epi16(p[1], v); p[2] = _mm_adds_epi16(p[2], v); p[3] = _mm_adds_epi16(p[3], v); p += 4; } while (--n); return true; } advancecomp-1.23/libdeflate/unaligned.h000066400000000000000000000107151301462770100201360ustar00rootroot00000000000000/* * unaligned.h - inline functions for unaligned memory accesses */ #ifndef LIB_UNALIGNED_H #define LIB_UNALIGNED_H #include "lib_common.h" /* * Naming note: * * {load,store}_*_unaligned() deal with raw bytes without endianness conversion. * {get,put}_unaligned_*() deal with a specific endianness. */ DEFINE_UNALIGNED_TYPE(u16) DEFINE_UNALIGNED_TYPE(u32) DEFINE_UNALIGNED_TYPE(u64) DEFINE_UNALIGNED_TYPE(machine_word_t) #define load_word_unaligned load_machine_word_t_unaligned #define store_word_unaligned store_machine_word_t_unaligned /***** Unaligned loads *****/ static forceinline u16 get_unaligned_le16(const u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) return le16_bswap(load_u16_unaligned(p)); else return ((u16)p[1] << 8) | p[0]; } static forceinline u16 get_unaligned_be16(const u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) return be16_bswap(load_u16_unaligned(p)); else return ((u16)p[0] << 8) | p[1]; } static forceinline u32 get_unaligned_le32(const u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) return le32_bswap(load_u32_unaligned(p)); else return ((u32)p[3] << 24) | ((u32)p[2] << 16) | ((u32)p[1] << 8) | p[0]; } static forceinline u32 get_unaligned_be32(const u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) return be32_bswap(load_u32_unaligned(p)); else return ((u32)p[0] << 24) | ((u32)p[1] << 16) | ((u32)p[2] << 8) | p[3]; } static forceinline u64 get_unaligned_le64(const u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) return le64_bswap(load_u64_unaligned(p)); else return ((u64)p[7] << 56) | ((u64)p[6] << 48) | ((u64)p[5] << 40) | ((u64)p[4] << 32) | ((u64)p[3] << 24) | ((u64)p[2] << 16) | ((u64)p[1] << 8) | p[0]; } static forceinline machine_word_t get_unaligned_leword(const u8 *p) { STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64); if (WORDBITS == 32) return get_unaligned_le32(p); else return get_unaligned_le64(p); } /***** Unaligned stores *****/ static forceinline void put_unaligned_le16(u16 v, u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) { store_u16_unaligned(le16_bswap(v), p); } else { p[0] = (u8)(v >> 0); p[1] = (u8)(v >> 8); } } static forceinline void put_unaligned_be16(u16 v, u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) { store_u16_unaligned(be16_bswap(v), p); } else { p[0] = (u8)(v >> 8); p[1] = (u8)(v >> 0); } } static forceinline void put_unaligned_le32(u32 v, u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) { store_u32_unaligned(le32_bswap(v), p); } else { p[0] = (u8)(v >> 0); p[1] = (u8)(v >> 8); p[2] = (u8)(v >> 16); p[3] = (u8)(v >> 24); } } static forceinline void put_unaligned_be32(u32 v, u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) { store_u32_unaligned(be32_bswap(v), p); } else { p[0] = (u8)(v >> 24); p[1] = (u8)(v >> 16); p[2] = (u8)(v >> 8); p[3] = (u8)(v >> 0); } } static forceinline void put_unaligned_le64(u64 v, u8 *p) { if (UNALIGNED_ACCESS_IS_FAST) { store_u64_unaligned(le64_bswap(v), p); } else { p[0] = (u8)(v >> 0); p[1] = (u8)(v >> 8); p[2] = (u8)(v >> 16); p[3] = (u8)(v >> 24); p[4] = (u8)(v >> 32); p[5] = (u8)(v >> 40); p[6] = (u8)(v >> 48); p[7] = (u8)(v >> 56); } } static forceinline void put_unaligned_leword(machine_word_t v, u8 *p) { STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64); if (WORDBITS == 32) put_unaligned_le32(v, p); else put_unaligned_le64(v, p); } /***** 24-bit loads *****/ /* * Given a 32-bit value that was loaded with the platform's native endianness, * return a 32-bit value whose high-order 8 bits are 0 and whose low-order 24 * bits contain the first 3 bytes, arranged in octets in a platform-dependent * order, at the memory location from which the input 32-bit value was loaded. */ static forceinline u32 loaded_u32_to_u24(u32 v) { if (CPU_IS_LITTLE_ENDIAN()) return v & 0xFFFFFF; else return v >> 8; } /* * Load the next 3 bytes from the memory location @p into the 24 low-order bits * of a 32-bit value. The order in which the 3 bytes will be arranged as octets * in the 24 bits is platform-dependent. At least LOAD_U24_REQUIRED_NBYTES * bytes must be available at @p; note that this may be more than 3. */ static forceinline u32 load_u24_unaligned(const u8 *p) { #if UNALIGNED_ACCESS_IS_FAST # define LOAD_U24_REQUIRED_NBYTES 4 return loaded_u32_to_u24(load_u32_unaligned(p)); #else # define LOAD_U24_REQUIRED_NBYTES 3 if (CPU_IS_LITTLE_ENDIAN()) return ((u32)p[0] << 0) | ((u32)p[1] << 8) | ((u32)p[2] << 16); else return ((u32)p[2] << 0) | ((u32)p[1] << 8) | ((u32)p[0] << 16); #endif } #endif /* LIB_UNALIGNED_H */ advancecomp-1.23/libdeflate/x86_cpu_features.c000066400000000000000000000112471301462770100213560ustar00rootroot00000000000000/* * x86_cpu_features.c - feature detection for x86 processors * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "x86_cpu_features.h" #if X86_CPU_FEATURES_ENABLED #define DEBUG 0 #if DEBUG # include #endif u32 _x86_cpu_features = 0; /* With old GCC versions we have to manually save and restore the x86_32 PIC * register (ebx). See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47602 */ #if defined(__i386__) && defined(__PIC__) # define EBX_CONSTRAINT "=r" #else # define EBX_CONSTRAINT "=b" #endif /* Execute the CPUID instruction. */ static inline void cpuid(u32 leaf, u32 subleaf, u32 *a, u32 *b, u32 *c, u32 *d) { __asm__(".ifnc %%ebx, %1; mov %%ebx, %1; .endif\n" "cpuid \n" ".ifnc %%ebx, %1; xchg %%ebx, %1; .endif\n" : "=a" (*a), EBX_CONSTRAINT (*b), "=c" (*c), "=d" (*d) : "a" (leaf), "c" (subleaf)); } /* Read an extended control register. */ static inline u64 read_xcr(u32 index) { u32 edx, eax; /* Execute the "xgetbv" instruction. Old versions of binutils do not * recognize this instruction, so list the raw bytes instead. */ __asm__ (".byte 0x0f, 0x01, 0xd0" : "=d" (edx), "=a" (eax) : "c" (index)); return ((u64)edx << 32) | eax; } #define IS_SET(reg, bit) ((reg) & ((u32)1 << (bit))) /* Initialize _x86_cpu_features with bits for interesting processor features. */ void x86_setup_cpu_features(void) { u32 features = 0; u32 dummy1, dummy2, dummy3, dummy4; u32 max_function; u32 features_1, features_2, features_3, features_4; bool os_saves_ymm_regs = false; /* Get maximum supported function */ cpuid(0, 0, &max_function, &dummy2, &dummy3, &dummy4); if (max_function < 1) goto out; /* Standard feature flags */ cpuid(1, 0, &dummy1, &dummy2, &features_2, &features_1); if (IS_SET(features_1, 25)) features |= X86_CPU_FEATURE_SSE; if (IS_SET(features_1, 26)) features |= X86_CPU_FEATURE_SSE2; if (IS_SET(features_2, 0)) features |= X86_CPU_FEATURE_SSE3; if (IS_SET(features_2, 1)) features |= X86_CPU_FEATURE_PCLMULQDQ; if (IS_SET(features_2, 9)) features |= X86_CPU_FEATURE_SSSE3; if (IS_SET(features_2, 19)) features |= X86_CPU_FEATURE_SSE4_1; if (IS_SET(features_2, 20)) features |= X86_CPU_FEATURE_SSE4_2; if (IS_SET(features_2, 27)) /* OSXSAVE set? */ if ((read_xcr(0) & 0x6) == 0x6) os_saves_ymm_regs = true; if (os_saves_ymm_regs && IS_SET(features_2, 28)) features |= X86_CPU_FEATURE_AVX; if (max_function < 7) goto out; /* Extended feature flags */ cpuid(7, 0, &dummy1, &features_3, &features_4, &dummy4); if (IS_SET(features_3, 3)) features |= X86_CPU_FEATURE_BMI; if (os_saves_ymm_regs && IS_SET(features_3, 5)) features |= X86_CPU_FEATURE_AVX2; if (IS_SET(features_3, 8)) features |= X86_CPU_FEATURE_BMI2; out: #if DEBUG printf("Detected x86 CPU features: "); if (features & X86_CPU_FEATURE_SSE) printf("SSE "); if (features & X86_CPU_FEATURE_SSE2) printf("SSE2 "); if (features & X86_CPU_FEATURE_SSE3) printf("SSE3 "); if (features & X86_CPU_FEATURE_PCLMULQDQ) printf("PCLMULQDQ "); if (features & X86_CPU_FEATURE_SSSE3) printf("SSSE3 "); if (features & X86_CPU_FEATURE_SSE4_1) printf("SSE4.1 "); if (features & X86_CPU_FEATURE_SSE4_2) printf("SSE4.2 "); if (features & X86_CPU_FEATURE_BMI) printf("BMI "); if (features & X86_CPU_FEATURE_AVX) printf("AVX "); if (features & X86_CPU_FEATURE_BMI2) printf("BMI2 "); if (features & X86_CPU_FEATURE_AVX2) printf("AVX2 "); printf("\n"); #endif /* DEBUG */ _x86_cpu_features = features | X86_CPU_FEATURES_KNOWN; } #endif /* X86_CPU_FEATURES_ENABLED */ advancecomp-1.23/libdeflate/x86_cpu_features.h000066400000000000000000000023071301462770100213600ustar00rootroot00000000000000/* * x86_cpu_features.h - feature detection for x86 processors */ #ifndef LIB_X86_CPU_FEATURES_H #define LIB_X86_CPU_FEATURES_H #include "lib_common.h" #if defined(__x86_64__) && COMPILER_SUPPORTS_TARGET_FUNCTION_ATTRIBUTE # define X86_CPU_FEATURES_ENABLED 1 #else # define X86_CPU_FEATURES_ENABLED 0 #endif #if X86_CPU_FEATURES_ENABLED #define X86_CPU_FEATURE_SSE 0x00000001 #define X86_CPU_FEATURE_SSE2 0x00000002 #define X86_CPU_FEATURE_SSE3 0x00000004 #define X86_CPU_FEATURE_PCLMULQDQ 0x00000008 #define X86_CPU_FEATURE_SSSE3 0x00000010 #define X86_CPU_FEATURE_SSE4_1 0x00000020 #define X86_CPU_FEATURE_SSE4_2 0x00000040 #define X86_CPU_FEATURE_AVX 0x00000080 #define X86_CPU_FEATURE_BMI 0x00000100 #define X86_CPU_FEATURE_AVX2 0x00000200 #define X86_CPU_FEATURE_BMI2 0x00000400 #define X86_CPU_FEATURES_KNOWN 0x80000000 extern u32 _x86_cpu_features; extern void x86_setup_cpu_features(void); /* Does the processor have the specified feature(s)? */ static inline bool x86_have_cpu_features(u32 features) { if (_x86_cpu_features == 0) x86_setup_cpu_features(); return (_x86_cpu_features & features) == features; } #endif /* X86_CPU_FEATURES_ENABLED */ #endif /* LIB_X86_CPU_FEATURES_H */ advancecomp-1.23/libdeflate/zlib_compress.c000066400000000000000000000052531301462770100210370ustar00rootroot00000000000000/* * zlib_compress.c - compress with a zlib wrapper * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "deflate_compress.h" #include "unaligned.h" #include "zlib_constants.h" #include "libdeflate.h" LIBDEFLATEAPI size_t libdeflate_zlib_compress(struct libdeflate_compressor *c, const void *in, size_t in_size, void *out, size_t out_nbytes_avail) { u8 *out_next = out; u16 hdr; unsigned compression_level; unsigned level_hint; size_t deflate_size; if (out_nbytes_avail <= ZLIB_MIN_OVERHEAD) return 0; /* 2 byte header: CMF and FLG */ hdr = (ZLIB_CM_DEFLATE << 8) | (ZLIB_CINFO_32K_WINDOW << 12); compression_level = deflate_get_compression_level(c); if (compression_level < 2) level_hint = ZLIB_FASTEST_COMPRESSION; else if (compression_level < 6) level_hint = ZLIB_FAST_COMPRESSION; else if (compression_level < 8) level_hint = ZLIB_DEFAULT_COMPRESSION; else level_hint = ZLIB_SLOWEST_COMPRESSION; hdr |= level_hint << 6; hdr |= 31 - (hdr % 31); put_unaligned_be16(hdr, out_next); out_next += 2; /* Compressed data */ deflate_size = libdeflate_deflate_compress(c, in, in_size, out_next, out_nbytes_avail - ZLIB_MIN_OVERHEAD); if (deflate_size == 0) return 0; out_next += deflate_size; /* ADLER32 */ put_unaligned_be32(libdeflate_adler32(1, in, in_size), out_next); out_next += 4; return out_next - (u8 *)out; } LIBDEFLATEAPI size_t libdeflate_zlib_compress_bound(struct libdeflate_compressor *c, size_t in_nbytes) { return ZLIB_MIN_OVERHEAD + libdeflate_deflate_compress_bound(c, in_nbytes); } advancecomp-1.23/libdeflate/zlib_constants.h000066400000000000000000000007501301462770100212220ustar00rootroot00000000000000/* * zlib_constants.h - constants for the zlib wrapper format */ #ifndef LIB_ZLIB_CONSTANTS_H #define LIB_ZLIB_CONSTANTS_H #define ZLIB_MIN_HEADER_SIZE 2 #define ZLIB_FOOTER_SIZE 4 #define ZLIB_MIN_OVERHEAD (ZLIB_MIN_HEADER_SIZE + ZLIB_FOOTER_SIZE) #define ZLIB_CM_DEFLATE 8 #define ZLIB_CINFO_32K_WINDOW 7 #define ZLIB_FASTEST_COMPRESSION 0 #define ZLIB_FAST_COMPRESSION 1 #define ZLIB_DEFAULT_COMPRESSION 2 #define ZLIB_SLOWEST_COMPRESSION 3 #endif /* LIB_ZLIB_CONSTANTS_H */ advancecomp-1.23/libdeflate/zlib_decompress.c000066400000000000000000000052201301462770100213420ustar00rootroot00000000000000/* * zlib_decompress.c - decompress with a zlib wrapper * * Originally public domain; changes after 2016-09-07 are copyrighted. * * Copyright 2016 Eric Biggers * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "unaligned.h" #include "zlib_constants.h" #include "libdeflate.h" LIBDEFLATEAPI enum libdeflate_result libdeflate_zlib_decompress(struct libdeflate_decompressor *d, const void *in, size_t in_nbytes, void *out, size_t out_nbytes_avail, size_t *actual_out_nbytes_ret) { const u8 *in_next = in; const u8 * const in_end = in_next + in_nbytes; u16 hdr; size_t actual_out_nbytes; enum libdeflate_result result; if (in_nbytes < ZLIB_MIN_OVERHEAD) return LIBDEFLATE_BAD_DATA; /* 2 byte header: CMF and FLG */ hdr = get_unaligned_be16(in_next); in_next += 2; /* FCHECK */ if ((hdr % 31) != 0) return LIBDEFLATE_BAD_DATA; /* CM */ if (((hdr >> 8) & 0xF) != ZLIB_CM_DEFLATE) return LIBDEFLATE_BAD_DATA; /* CINFO */ if ((hdr >> 12) > ZLIB_CINFO_32K_WINDOW) return LIBDEFLATE_BAD_DATA; /* FDICT */ if ((hdr >> 5) & 1) return LIBDEFLATE_BAD_DATA; /* Compressed data */ result = libdeflate_deflate_decompress(d, in_next, in_end - ZLIB_FOOTER_SIZE - in_next, out, out_nbytes_avail, actual_out_nbytes_ret); if (result != LIBDEFLATE_SUCCESS) return result; if (actual_out_nbytes_ret) actual_out_nbytes = *actual_out_nbytes_ret; else actual_out_nbytes = out_nbytes_avail; in_next = in_end - ZLIB_FOOTER_SIZE; /* ADLER32 */ if (libdeflate_adler32(1, out, actual_out_nbytes) != get_unaligned_be32(in_next)) return LIBDEFLATE_BAD_DATA; return LIBDEFLATE_SUCCESS; } advancecomp-1.23/makedist.sh000077500000000000000000000006571301462770100160700ustar00rootroot00000000000000#!/bin/sh # make distclean if ! ./configure.windows-x86; then exit 1 fi if ! test "x$1" = "x-f"; then if ! make check; then exit 1 fi fi if ! make distwindows distclean; then exit 1 fi if ! ./configure.dos; then exit 1 fi if ! make distdos distclean; then exit 1 fi if ! ./configure ; then exit 1 fi if ! test "x$1" = "x-f"; then if ! make distcheck; then exit 1 fi else if ! make dist; then exit 1 fi fi advancecomp-1.23/mngex.cc000066400000000000000000000450421301462770100153520ustar00rootroot00000000000000/* * This file is part of the AdvanceSCAN project. * * Copyright (C) 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "mngex.h" #include "lib/mng.h" #include "lib/endianrw.h" #include #include using namespace std; static bool mng_write_reduce(adv_mng_write* mng, data_ptr& out_ptr, unsigned& out_scanline, unsigned char* ovr_ptr, unsigned char* img_ptr, unsigned img_scanline) { unsigned char col_ptr[256*3]; unsigned col_mapped[256]; unsigned col_count; adv_bool ovr_used[256]; unsigned i, j, k; unsigned char* new_ptr; unsigned new_scanline; /* build the new palette */ col_count = 0; for(i=0;iheight;++i) { unsigned char* p0 = img_ptr + i * img_scanline; for(j=0;jwidth;++j) { for(k=0;kpal_ptr, 256*3); /* map colors already present in the old palette */ for(i=0;iwidth; new_ptr = data_alloc(mng->height * new_scanline); for(i=0;iheight;++i) { unsigned char* p0 = new_ptr + i*new_scanline; unsigned char* p1 = img_ptr + i*img_scanline; for(j=0;jwidth;++j) { for(k=0;;++k) if (ovr_ptr[k*3]==p1[0] && ovr_ptr[k*3+1]==p1[1] && ovr_ptr[k*3+2]==p1[2]) break; *p0 = k; ++p0; p1 += 3; } } out_ptr = new_ptr; out_scanline = new_scanline; return true; } static void mng_write_expand(adv_mng_write* mng, data_ptr& out_ptr, unsigned& out_scanline, const unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr) { unsigned char* new_ptr; unsigned new_scanline; unsigned i, j; /* create the new bitmap */ new_scanline = mng->width * 3; new_ptr = data_alloc(mng->height * new_scanline); for(i=0;iheight;++i) { unsigned char* p0 = new_ptr + i*new_scanline; const unsigned char* p1 = img_ptr + i*img_scanline; for(j=0;jwidth;++j) { unsigned k = 3 * *p1; p0[0] = pal_ptr[k]; p0[1] = pal_ptr[k+1]; p0[2] = pal_ptr[k+2]; p0 += 3; ++p1; } } out_ptr = new_ptr; out_scanline = new_scanline; } void mng_write_header(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned frequency, int scroll_x, int scroll_y, unsigned scroll_width, unsigned scroll_height, adv_bool alpha) { unsigned simplicity; unsigned char mhdr[28]; if (adv_mng_write_signature(f, fc) != 0) { throw_png_error(); } switch (mng->type) { case mng_vlc : simplicity = (1 << 0) /* Enable flags */ | (1 << 6); /* Enable flags */ break; case mng_lc : simplicity = (1 << 0) /* Enable flags */ | (1 << 1) /* Basic features */ | (1 << 6); /* Enable flags */ break; default: case mng_std : simplicity = (1 << 0) /* Enable flags */ | (1 << 1) /* Basic features */ | (1 << 2) /* Extended features */ | (1 << 5) /* Delta PNG */ | (1 << 6) /* Enable flags */ | (1 << 9); /* Object buffers must be stored */ break; } if (alpha) { simplicity |= (1 << 3) /* Internal transparency */ | (1 << 8); /* Semi-transparency */ } be_uint32_write(mhdr + 0, width); /* width */ be_uint32_write(mhdr + 4, height); /* height */ be_uint32_write(mhdr + 8, frequency); /* ticks per second */ be_uint32_write(mhdr + 12, 0); /* nominal layer count */ be_uint32_write(mhdr + 16, 0); /* nominal frame count */ be_uint32_write(mhdr + 20, 0); /* nominal play time */ be_uint32_write(mhdr + 24, simplicity); /* simplicity profile */ if (adv_png_write_chunk(f, ADV_MNG_CN_MHDR, mhdr, sizeof(mhdr), fc) != 0) { throw_png_error(); } mng->first = 1; mng->width = width; mng->height = height; mng->pixel = 0; mng->line = 0; mng->scroll_x = scroll_x; mng->scroll_y = scroll_y; mng->scroll_width = scroll_width; mng->scroll_height = scroll_height; mng->scroll_ptr = 0; mng->pal_size = 0; mng->tick = 1; mng->header_written = 1; mng->header_simplicity = simplicity; } static bool row_equal(adv_mng_write* mng, unsigned y, unsigned char* img_ptr, unsigned img_scanline) { unsigned char* p0; unsigned char* p1; p0 = mng->current_ptr + y * mng->line; p1 = img_ptr + y * img_scanline; return memcmp(p0, p1, mng->width * mng->pixel) == 0; } static bool col_equal(adv_mng_write* mng, unsigned x, unsigned char* img_ptr, unsigned img_scanline) { unsigned char* p0; unsigned char* p1; unsigned i; p0 = mng->current_ptr + x * mng->pixel; p1 = img_ptr + x * mng->pixel; if (mng->pixel == 1) { for(i=0;iheight;++i) { if (p0[0] != p1[0]) return false; p0 += mng->line; p1 += img_scanline; } } else if (mng->pixel == 3) { for(i=0;iheight;++i) { if (p0[0] != p1[0] || p0[1] != p1[1] || p0[2] != p1[2]) return false; p0 += mng->line; p1 += img_scanline; } } else if (mng->pixel == 4) { for(i=0;iheight;++i) { if (p0[0] != p1[0] || p0[1] != p1[1] || p0[2] != p1[2] || p0[3] != p1[3]) return false; p0 += mng->line; p1 += img_scanline; } } else { throw error() << "Unsupported bit depth"; } return true; } static void compute_image_range(adv_mng_write* mng, unsigned* out_x, unsigned* out_y, unsigned* out_dx, unsigned* out_dy, unsigned char* img_ptr, unsigned img_scanline) { unsigned x; unsigned dx; unsigned y; unsigned dy; x = 0; while (x < mng->width && col_equal(mng, x, img_ptr, img_scanline)) ++x; dx = mng->width - x; while (dx > 0 && col_equal(mng, x + dx - 1, img_ptr, img_scanline)) --dx; y = 0; while (y < mng->height && row_equal(mng, y, img_ptr, img_scanline)) ++y; dy = mng->height - y; while (dy > 0 && row_equal(mng, y + dy - 1, img_ptr, img_scanline)) --dy; *out_x = x; *out_y = y; *out_dx = dx; *out_dy = dy; } static void mng_write_store(adv_mng_write* mng, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size) { unsigned i; if (pal_size) { memcpy(mng->pal_ptr, pal_ptr, pal_size); memset(mng->pal_ptr + pal_size, 0, 256*3 - pal_size); if (pal_size > mng->pal_size) mng->pal_size = pal_size; } for(i=0;iheight;++i) { memcpy(&mng->current_ptr[i * mng->line], &img_ptr[i * img_scanline], mng->width * mng->pixel); } } static void mng_write_first(adv_mng_write* mng, adv_fz* f, unsigned* fc) { unsigned char defi[12]; unsigned defi_size; unsigned char ihdr[13]; data_ptr z_ptr; unsigned z_size; if (mng->type == mng_std) { be_uint16_write(defi + 0, 1); /* object id */ defi[2] = 0; /* visible */ defi[3] = 1; /* concrete */ if (mng->scroll_x!=0 || mng->scroll_y!=0) { be_uint32_write(defi + 4, - mng->scroll_x); be_uint32_write(defi + 8, - mng->scroll_y); defi_size = 12; } else defi_size = 4; if (adv_png_write_chunk(f, ADV_MNG_CN_DEFI, defi, defi_size, fc) != 0) { throw_png_error(); } } be_uint32_write(ihdr + 0, mng->width + mng->scroll_width); be_uint32_write(ihdr + 4, mng->height + mng->scroll_height); ihdr[8] = 8; /* bit depth */ if (mng->pixel == 1) ihdr[9] = 3; /* color type */ else if (mng->pixel == 3) ihdr[9] = 2; /* color type */ else if (mng->pixel == 4) ihdr[9] = 6; /* color type */ ihdr[10] = 0; /* compression */ ihdr[11] = 0; /* filter */ ihdr[12] = 0; /* interlace */ if (adv_png_write_chunk(f, ADV_PNG_CN_IHDR, ihdr, sizeof(ihdr), fc) != 0) { throw_png_error(); } if (mng->pal_size) { if (adv_png_write_chunk(f, ADV_PNG_CN_PLTE, mng->pal_ptr, mng->pal_size, fc) != 0) { throw_png_error(); } } png_compress(mng->level, z_ptr, z_size, mng->scroll_ptr, mng->line, mng->pixel, 0, 0, mng->width + mng->scroll_width, mng->height + mng->scroll_height); if (adv_png_write_chunk(f, ADV_PNG_CN_IDAT, z_ptr, z_size, fc) != 0) { throw_png_error(); } if (adv_png_write_chunk(f, ADV_PNG_CN_IEND, 0, 0, fc) != 0) { throw_png_error(); } } static void mng_write_move(adv_mng_write* mng, adv_fz* f, unsigned* fc, int shift_x, int shift_y) { unsigned char move[13]; if (shift_x!=0 || shift_y!=0) { be_uint16_write(move + 0, 1); /* id 1 */ be_uint16_write(move + 2, 1); /* id 1 */ move[4] = 1; /* adding */ be_uint32_write(move + 5, - shift_x); be_uint32_write(move + 9, - shift_y); if (adv_png_write_chunk(f, ADV_MNG_CN_MOVE, move, sizeof(move), fc)!=0) { throw_png_error(); } } } static void mng_write_delta_image(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size) { unsigned x, y, dx, dy; data_ptr pal_d_ptr; unsigned pal_d_size; data_ptr pal_r_ptr; unsigned pal_r_size; data_ptr z_d_ptr; unsigned z_d_size; data_ptr z_r_ptr; unsigned z_r_size; unsigned char dhdr[20]; unsigned dhdr_size; if (pal_ptr && pal_size) { png_compress_palette_delta(pal_d_ptr, pal_d_size, pal_ptr, pal_size, mng->pal_ptr); pal_r_ptr = data_dup(pal_ptr, pal_size); pal_r_size = pal_size; } else { pal_d_ptr = 0; pal_d_size = 0; pal_r_ptr = 0; pal_r_size = 0; } compute_image_range(mng, &x, &y, &dx, &dy, img_ptr, img_scanline); if (dx && dy) { png_compress_delta(mng->level, z_d_ptr, z_d_size, img_ptr, img_scanline, mng->pixel, mng->current_ptr, mng->line, x, y, dx, dy); png_compress(mng->level, z_r_ptr, z_r_size, img_ptr, img_scanline, mng->pixel, x, y, dx, dy); } else { z_d_ptr = 0; z_d_size = 0; z_r_ptr = 0; z_r_size = 0; } be_uint16_write(dhdr + 0, 1); /* object id */ dhdr[2] = 1; /* png image */ if (z_d_size) { if (z_d_size < z_r_size) { dhdr[3] = 1; /* block pixel addition */ dhdr_size = 20; } else { if (dx == mng->width && dy == mng->height && mng->scroll_width == 0 && mng->scroll_height == 0) { dhdr[3] = 0; /* entire image replacement */ dhdr_size = 12; } else { dhdr[3] = 4; /* block pixel replacement */ dhdr_size = 20; } } } else { dhdr[3] = 7; /* no change to pixel data */ dhdr_size = 4; } be_uint32_write(dhdr + 4, dx); be_uint32_write(dhdr + 8, dy); be_uint32_write(dhdr + 12, x + mng->current_x); be_uint32_write(dhdr + 16, y + mng->current_y); if (adv_png_write_chunk(f, ADV_MNG_CN_DHDR, dhdr, dhdr_size, fc) != 0) { throw_png_error(); } if (pal_d_size) { if (pal_d_size < pal_r_size) { if (adv_png_write_chunk(f, ADV_MNG_CN_PPLT, pal_d_ptr, pal_d_size, fc) != 0) { throw_png_error(); } } else { if (adv_png_write_chunk(f, ADV_PNG_CN_PLTE, pal_r_ptr, pal_r_size, fc) != 0) { throw_png_error(); } } } if (z_d_size) { if (z_d_size < z_r_size) { if (adv_png_write_chunk(f, ADV_PNG_CN_IDAT, z_d_ptr, z_d_size, fc) != 0) { throw_png_error(); } } else { if (adv_png_write_chunk(f, ADV_PNG_CN_IDAT, z_r_ptr, z_r_size, fc) != 0) { throw_png_error(); } } } if (adv_png_write_chunk(f, ADV_PNG_CN_IEND, 0, 0, fc) != 0) { throw_png_error(); } mng_write_store(mng, img_ptr, img_scanline, pal_ptr, pal_size); } static void mng_write_base_image(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size) { data_ptr pal_r_ptr; unsigned pal_r_size; data_ptr z_r_ptr; unsigned z_r_size; pal_r_ptr = data_dup(pal_ptr, pal_size); pal_r_size = pal_size; png_compress(mng->level, z_r_ptr, z_r_size, img_ptr, img_scanline, mng->pixel, 0, 0, mng->width, mng->height); unsigned char ihdr[13]; unsigned ihdr_size; be_uint32_write(ihdr + 0, mng->width); be_uint32_write(ihdr + 4, mng->height); ihdr[8] = 8; /* bit depth */ if (mng->pixel == 1) ihdr[9] = 3; /* color type */ else if (mng->pixel == 3) ihdr[9] = 3; /* color type */ else if (mng->pixel == 4) ihdr[9] = 6; /* color type */ else throw error() << "Unsupported bit depth"; ihdr[10] = 0; /* compression */ ihdr[11] = 0; /* filter */ ihdr[12] = 0; /* interlace */ ihdr_size = 13; if (adv_png_write_chunk(f, ADV_PNG_CN_IHDR, ihdr, ihdr_size, fc) != 0) { throw_png_error(); } if (pal_r_size) { if (adv_png_write_chunk(f, ADV_PNG_CN_PLTE, pal_r_ptr, pal_r_size, fc) != 0) { throw_png_error(); } } if (adv_png_write_chunk(f, ADV_PNG_CN_IDAT, z_r_ptr, z_r_size, fc) != 0) { throw_png_error(); } if (adv_png_write_chunk(f, ADV_PNG_CN_IEND, 0, 0, fc) != 0) { throw_png_error(); } mng_write_store(mng, img_ptr, img_scanline, pal_ptr, pal_size); } static void mng_write_image_setup(adv_mng_write* mng, adv_fz* f, unsigned width, unsigned height, unsigned pixel) { if (!mng->header_written) { throw error() << "You must write an header before the first image"; } if (width != mng->width) { throw error() << "Invalid width change"; } if (height != mng->height) { throw error() << "Invalid height change"; } if (mng->first) { switch (pixel) { case 1 : if (mng->expand) mng->pixel = 3; else mng->pixel = 1; break; case 3 : if (mng->reduce) mng->pixel = 1; else mng->pixel = 3; break; default: mng->pixel = pixel; break; } mng->line = mng->pixel * (mng->width + mng->scroll_width); mng->scroll_ptr = data_alloc((mng->height + mng->scroll_height) * mng->line); mng->current_ptr = mng->scroll_ptr + mng->scroll_x * mng->pixel + mng->scroll_y * mng->line; mng->current_x = mng->scroll_x; mng->current_y = mng->scroll_y; memset(mng->scroll_ptr, 0, (mng->height + mng->scroll_height) * mng->line); memset(mng->pal_ptr, 0, sizeof(mng->pal_ptr)); } } static void mng_write_image_raw(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned pixel, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size, int shift_x, int shift_y) { if (pixel != mng->pixel) { throw error() << "Invalid bit depth change"; } if (mng->first) { mng->first = 0; if (shift_x != 0 || shift_y != 0) { throw error() << "Internal error"; } mng_write_store(mng, img_ptr, img_scanline, pal_ptr, pal_size); mng_write_first(mng, f, fc); } else { // shift may be negative, caste all to int to prevent conversion to 64 bit unsigned int mng->current_ptr += shift_x * (int)mng->pixel + shift_y * (int)mng->line; mng->current_x += shift_x; mng->current_y += shift_y; if (mng->type == mng_std) { mng_write_move(mng, f, fc, shift_x, shift_y); mng_write_delta_image(mng, f, fc, img_ptr, img_scanline, pal_ptr, pal_size); } else { mng_write_base_image(mng, f, fc, img_ptr, img_scanline, pal_ptr, pal_size); } } } void mng_write_image(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned pixel, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size, int shift_x, int shift_y) { mng_write_image_setup(mng, f, width, height, pixel); if (pixel == 1) { data_ptr new_ptr; unsigned new_scanline; if (!mng->expand) { mng_write_image_raw(mng, f, fc, width, height, pixel, img_ptr, img_scanline, pal_ptr, pal_size, shift_x, shift_y); } else { mng_write_expand(mng, new_ptr, new_scanline, img_ptr, img_scanline, pal_ptr); mng_write_image_raw(mng, f, fc, width, height, 3, new_ptr, new_scanline, 0, 0, shift_x, shift_y); } } else if (pixel == 3) { if (!mng->reduce) { mng_write_image_raw(mng, f, fc, width, height, pixel, img_ptr, img_scanline, 0, 0, shift_x, shift_y); } else { unsigned char ovr_ptr[256*3]; data_ptr new_ptr; unsigned new_scanline; if (!mng_write_reduce(mng, new_ptr, new_scanline, ovr_ptr, img_ptr, img_scanline)) { throw error_unsupported() << "Color reduction failed"; } else { mng_write_image_raw(mng, f, fc, width, height, 1, new_ptr, new_scanline, ovr_ptr, 256*3, shift_x, shift_y); // update the last palette used memcpy(mng->pal_ptr, ovr_ptr, sizeof(mng->pal_ptr)); } } } else if (pixel == 4) { unsigned required = (1 << 3) | (1 << 6) | (1 << 8); if ((mng->header_simplicity & required) != required) { throw error() << "You enable transparency for alpha images"; } mng_write_image_raw(mng, f, fc, width, height, pixel, img_ptr, img_scanline, 0, 0, shift_x, shift_y); } else { throw error_unsupported() << "Unsupported bit depth"; } } void mng_write_frame(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned tick) { unsigned char fram[10]; unsigned fram_size; if (tick == mng->tick) { fram[0] = 1; fram_size = 1; } else { fram[0] = 1; fram[1] = 0; /* no name */ fram[2] = 2; /* change delay for all the next frames */ fram[3] = 0; /* don't change timeout */ fram[4] = 0; /* don't change clipping */ fram[5] = 0; /* don't change sync id list */ be_uint32_write(fram + 6, tick); fram_size = 10; } mng->tick = tick; if (adv_png_write_chunk(f, ADV_MNG_CN_FRAM, fram, fram_size, fc) != 0) { throw_png_error(); } } void mng_write_footer(adv_mng_write* mng, adv_fz* f, unsigned* fc) { if (adv_png_write_chunk(f, ADV_MNG_CN_MEND, 0, 0, fc) != 0) { throw_png_error(); } } adv_mng_write* mng_write_init(adv_mng_type type, shrink_t level, adv_bool reduce, adv_bool expand) { adv_mng_write* mng; mng = (adv_mng_write*)malloc(sizeof(adv_mng_write)); mng->type = type; mng->level = level; mng->reduce = reduce; mng->expand = expand; mng->header_written = 0; mng->header_simplicity = 0; return mng; } void mng_write_done(adv_mng_write* mng) { free(mng->scroll_ptr); free(mng); } adv_bool mng_write_has_header(adv_mng_write* mng) { return mng->header_written; } advancecomp-1.23/mngex.h000066400000000000000000000057431301462770100152200ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __MNGEX_H #define __MNGEX_H #include "pngex.h" typedef enum adv_mng_type_enum { mng_vlc, mng_lc, mng_std } adv_mng_type; typedef struct adv_mng_write_struct { adv_bool first; /**< First image flag. */ unsigned width; /**< Frame size in pixel. */ unsigned height; /**< Frame size in pixel. */ unsigned pixel; /**< Pixel size in bytes. */ unsigned line; /**< Scanline size in bytes. */ int scroll_x; /**< Initial position of the first image in the scroll buffer. */ int scroll_y; /**< Initial position of the first image in the scroll buffer. */ unsigned scroll_width; /**< Extra scroll buffer size in pixel. */ unsigned scroll_height; /**< Extra scroll buffer size in pixel. */ unsigned char* scroll_ptr; /**< Global image data. */ unsigned char* current_ptr; /**< Pointer at the current frame in the scroll buffer. */ int current_x; /**< Current scroll position. */ int current_y; unsigned pal_size; /**< Palette size in bytes. */ unsigned char pal_ptr[256*3]; /**< Palette. */ unsigned tick; /**< Last tick used. */ adv_mng_type type; /**< Type of the MNG stream. */ shrink_t level; /**< Compression level of the MNG stream. */ adv_bool reduce; /**< Try to reduce the images to 256 color. */ adv_bool expand; /**< Expand the images to 24 bit color. */ adv_bool header_written; /**< If the header was written. */ unsigned header_simplicity; /**< Simplicity written in the header. */ } adv_mng_write; adv_bool mng_write_has_header(adv_mng_write* mng); void mng_write_header(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned frequency, int scroll_x, int scroll_y, unsigned scroll_width, unsigned scroll_height, adv_bool alpha); void mng_write_image(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned width, unsigned height, unsigned pixel, unsigned char* img_ptr, unsigned img_scanline, unsigned char* pal_ptr, unsigned pal_size, int shift_x, int shift_y); void mng_write_frame(adv_mng_write* mng, adv_fz* f, unsigned* fc, unsigned tick); void mng_write_footer(adv_mng_write* mng, adv_fz* f, unsigned* fc); adv_mng_write* mng_write_init(adv_mng_type type, shrink_t level, adv_bool reduce, adv_bool expand); void mng_write_done(adv_mng_write* mng); #endif advancecomp-1.23/pngex.cc000066400000000000000000000260401301462770100153520ustar00rootroot00000000000000/* * This file is part of the AdvanceSCAN project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "lib/endianrw.h" #include "lib/mng.h" #include "pngex.h" #include #include using namespace std; void png_compress(shrink_t level, data_ptr& out_ptr, unsigned& out_size, const unsigned char* img_ptr, unsigned img_scanline, unsigned img_pixel, unsigned x, unsigned y, unsigned dx, unsigned dy) { data_ptr fil_ptr; unsigned fil_size; unsigned fil_scanline; data_ptr z_ptr; unsigned z_size; unsigned i; unsigned char* p0; fil_scanline = dx * img_pixel + 1; fil_size = dy * fil_scanline; z_size = oversize_zlib(fil_size); fil_ptr = data_alloc(fil_size); z_ptr = data_alloc(z_size); p0 = fil_ptr; for(i=0;i= 12) { cout << " width:" << be_uint32_read(data + 4) << " height:" << be_uint32_read(data + 8); } if (size >= 20) { cout << " x:" << (int)be_uint32_read(data + 12) << " y:" << (int)be_uint32_read(data + 16); } break; case ADV_MNG_CN_FRAM : if (size >= 1) { cout << " mode:" << (unsigned)data[0]; } if (size > 1) { i = 1; while (i < size && data[i]!=0) ++i; cout << " len:" << i-1; if (size >= i+2) { cout << " delay_mode:" << (unsigned)data[i+1]; } if (size >= i+3) { cout << " timeout:" << (unsigned)data[i+2]; } if (size >= i+4) { cout << " clip:" << (unsigned)data[i+3]; } if (size >= i+5) { cout << " syncid:" << (unsigned)data[i+4]; } if (size >= i+9) { cout << " tick:" << be_uint32_read(data+i+5); } if (size >= i+13) { cout << " timeout:" << be_uint32_read(data+i+9); } if (size >= i+14) { cout << " dt:" << (unsigned)data[i+10]; } if (size >= i+15) { cout << " ..."; } } break; case ADV_MNG_CN_DEFI : cout << " id:" << be_uint16_read(data+0); if (size >= 3) { switch (data[2]) { case 0 : cout << " visible:yes"; break; case 1 : cout << " visible:no"; break; default : cout << " visible:?"; break; } } if (size >= 4) { switch (data[3]) { case 0 : cout << " concrete:abstract"; break; case 1 : cout << " concrete:concrete"; break; default : cout << " concrete:?"; break; } } if (size >= 12) { cout << " x:" << (int)be_uint32_read(data + 4) << " y:" << (int)be_uint32_read(data + 8); } if (size >= 28) { cout << " left:" << be_uint32_read(data + 12) << " right:" << be_uint32_read(data + 16) << " top:" << be_uint32_read(data + 20) << " bottom:" << be_uint32_read(data + 24); } break; case ADV_MNG_CN_MOVE : cout << " id_from:" << be_uint16_read(data+0) << " id_to:" << be_uint16_read(data+2); switch (data[4]) { case 0 : cout << " type:replace"; break; case 1 : cout << " type:add"; break; default : cout << " type:?"; break; } cout << " x:" << (int)be_uint32_read(data + 5) << " y:" << (int)be_uint32_read(data + 9); break; case ADV_MNG_CN_PPLT : switch (data[0]) { case 0 : cout << " type:replacement_rgb"; break; case 1 : cout << " type:delta_rgb"; break; case 2 : cout << " type:replacement_alpha"; break; case 3 : cout << " type:delta_alpha"; break; case 4 : cout << " type:replacement_rgba"; break; case 5 : cout << " type:delta_rgba"; break; default : cout << " type:?"; break; } i = 1; while (i #include /* On many systems (e.g., Darwin), `stdio.h' is a prerequisite. */ #include #include #include #include #include #include #include #if HAVE_UNISTD_H #include #endif #if TIME_WITH_SYS_TIME #include #include #else #if HAVE_SYS_TIME_H #include #else #include #endif #endif #if HAVE_DIRENT_H #include #define NAMLEN(dirent) strlen((dirent)->d_name) #else #define dirent direct #define NAMLEN(dirent) (dirent)->d_namlen #if HAVE_SYS_NDIR_H #include #endif #if HAVE_SYS_DIR_H #include #endif #if HAVE_NDIR_H #include #endif #endif #if HAVE_SYS_TYPES_H #include #endif #if HAVE_SYS_WAIT_H #include #endif #if HAVE_SYS_STAT_H #include #endif #if HAVE_GETOPT_H #include #endif #if !HAVE_GETOPT int getopt(int argc, char * const *argv, const char *options); extern char *optarg; extern int optind, opterr, optopt; #endif #if HAVE_GETOPT_LONG #define SWITCH_GETOPT_LONG(a, b) a #else #define SWITCH_GETOPT_LONG(a, b) b #endif #if HAVE_UTIME_H #include #endif #if HAVE_SYS_UTIME_H #include #endif #if defined(__MSDOS__) || defined(__WIN32__) #define HAVE_LONG_FNAME 0 #define DIR_SEP ';' #else #define HAVE_LONG_FNAME 1 #define DIR_SEP ':' #endif #if defined(__WIN32__) #define HAVE_FUNC_MKDIR_ONEARG 1 #else #define HAVE_FUNC_MKDIR_ONEARG 0 #endif #if defined(__WIN32__) #define HAVE_SIGHUP 0 #define HAVE_SIGQUIT 0 #else #define HAVE_SIGHUP 1 #define HAVE_SIGQUIT 1 #endif #if !HAVE_SNPRINTF int snprintf(char *str, size_t count, const char *fmt, ...); #endif #if !HAVE_VSNPRINTF #if HAVE_STDARG_H #include #else #if HAVE_VARARGS_H #include #endif #endif int vsnprintf(char *str, size_t count, const char *fmt, va_list arg); #endif #ifdef __cplusplus } #endif #endif advancecomp-1.23/redef.cc000066400000000000000000000376761301462770100153370ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2003, 2004, 2005 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "pngex.h" #include "file.h" #include "compress.h" #include "siglock.h" #include "lib/mng.h" #include "lib/endianrw.h" #include #include using namespace std; shrink_t opt_level; bool opt_quiet; bool opt_force; enum ftype_t { ftype_png, ftype_mng, ftype_gz }; #define BLOCK_SIZE 4096 struct block_t { unsigned char* data; block_t* next; }; void copy_data(adv_fz* f_in, adv_fz* f_out, unsigned char* data, unsigned size) { if (fzread(data, size, 1, f_in) != 1) { throw error() << "Error reading"; } if (fzwrite(data, size, 1, f_out) != 1) { throw error() << "Error writing"; } } void copy_data(adv_fz* f_in, adv_fz* f_out, unsigned size) { while (size > 0) { unsigned char c; if (fzread(&c, 1, 1, f_in) != 1) { throw error() << "Error reading"; } if (fzwrite(&c, 1, 1, f_out) != 1) { throw error() << "Error writing"; } --size; } } void copy_zero(adv_fz* f_in, adv_fz* f_out) { while (1) { unsigned char c; if (fzread(&c, 1, 1, f_in) != 1) { throw error() << "Error reading"; } if (fzwrite(&c, 1, 1, f_out) != 1) { throw error() << "Error writing"; } if (!c) break; } } void read_deflate(adv_fz* f_in, unsigned size, unsigned char*& res_data, unsigned& res_size) { z_stream z; block_t* base; block_t* i; unsigned pos; int r; base = new block_t; base->data = data_alloc(BLOCK_SIZE); base->next = 0; i = base; memset(&z, 0, sizeof(z)); z.zalloc = 0; z.zfree = 0; z.next_out = i->data; z.avail_out = BLOCK_SIZE; z.next_in = 0; z.avail_in = 0; /* !! ZLIB UNDOCUMENTED FEATURE !! (used in gzio.c module ) * windowBits is passed < 0 to tell that there is no zlib header. * Note that in this case inflate *requires* an extra "dummy" byte * after the compressed stream in order to complete decompression and * return Z_STREAM_END. */ r = inflateInit2(&z, -15); unsigned char block[BLOCK_SIZE]; unsigned char dummy; int dummy_used = 0; while (r == Z_OK && (size > 0 || z.avail_in != 0 || !dummy_used || z.avail_out == 0)) { if (z.avail_in == 0 && size > 0) { unsigned run = size; if (run > BLOCK_SIZE) run = BLOCK_SIZE; size -= run; if (fzread(block, run, 1, f_in) != 1) throw error() << "Error reading"; z.next_in = block; z.avail_in = run; } /* The zlib code effectively READ the dummy byte, * this imply that the pointer MUST point to a valid data region. * The dummy byte is not always needed, only if inflate return Z_OK * instead of Z_STREAM_END. */ if (z.avail_in == 0 && size == 0 && !dummy_used) { dummy = 0; z.next_in = &dummy; z.avail_in = 1; dummy_used = 1; } if (z.avail_out == 0) { block_t* next; next = new block_t; next->data = data_alloc(BLOCK_SIZE); next->next = 0; i->next = next; i = next; z.next_out = i->data; z.avail_out = BLOCK_SIZE; } r = inflate(&z, Z_NO_FLUSH); } if (size != 0) { inflateEnd(&z); throw error_unsupported() << "Extra " << size << " data at the end"; } if (r != Z_STREAM_END) { inflateEnd(&z); throw error() << "Unexpected end of data"; } r = inflateEnd(&z); if (r != Z_OK) { throw error() << "Invalid compressed data"; } res_size = z.total_out; res_data = data_alloc(res_size); pos = 0; i = base; while (i) { block_t* next; if (pos < res_size) { unsigned run = BLOCK_SIZE; if (run > res_size - pos) run = res_size - pos; memcpy(res_data + pos, i->data, run); pos += run; } data_free(i->data); next = i->next; delete i; i = next; } if (pos != res_size) { throw error() << "Internal error"; } } void read_idat(adv_fz* f, unsigned char*& data, unsigned& size, unsigned& type, unsigned char*& res_data, unsigned& res_size) { z_stream z; block_t* base; block_t* i; unsigned pos; int r; unsigned char* next_data; unsigned next_size; unsigned next_type; base = new block_t; base->data = data_alloc(BLOCK_SIZE); base->next = 0; i = base; memset(&z, 0, sizeof(z)); z.zalloc = 0; z.zfree = 0; z.next_out = i->data; z.avail_out = BLOCK_SIZE; z.next_in = data; z.avail_in = size; if (adv_png_read_chunk(f, &next_data, &next_size, &next_type) != 0) { throw_png_error(); } r = inflateInit(&z); while (r == Z_OK && (next_type == ADV_PNG_CN_IDAT || z.avail_in != 0 || z.avail_out == 0)) { if (z.avail_in == 0 && next_type == ADV_PNG_CN_IDAT) { free(data); data = next_data; size = next_size; z.next_in = data; z.avail_in = size; if (adv_png_read_chunk(f, &next_data, &next_size, &next_type) != 0) { inflateEnd(&z); throw_png_error(); } } if (z.avail_out == 0) { block_t* next; next = new block_t; next->data = data_alloc(BLOCK_SIZE); next->next = 0; i->next = next; i = next; z.next_out = i->data; z.avail_out = BLOCK_SIZE; } r = inflate(&z, Z_NO_FLUSH); } if (r != Z_STREAM_END) { inflateEnd(&z); throw error() << "Invalid compressed data"; } r = inflateEnd(&z); if (r != Z_OK) { throw error() << "Invalid compressed data"; } free(data); data = next_data; size = next_size; type = next_type; res_size = z.total_out; res_data = data_alloc(res_size); pos = 0; i = base; while (i) { block_t* next; if (pos < res_size) { unsigned run = BLOCK_SIZE; if (run > res_size - pos) run = res_size - pos; memcpy(res_data + pos, i->data, run); pos += run; } data_free(i->data); next = i->next; delete i; i = next; } if (pos != res_size) { throw error() << "Internal error"; } } void convert_dat(adv_fz* f_in, adv_fz* f_out, unsigned end) { unsigned char* data; unsigned type; unsigned size; while (1) { if (adv_png_read_chunk(f_in, &data, &size, &type) != 0) { throw_png_error(); } if (type == ADV_PNG_CN_IDAT) { unsigned char* res_data; unsigned res_size; read_idat(f_in, data, size, type, res_data, res_size); unsigned cmp_size = oversize_zlib(res_size); unsigned char* cmp_data = data_alloc(cmp_size); if (!compress_zlib(opt_level, cmp_data, cmp_size, res_data, res_size)) { throw error() << "Error compressing"; } data_free(res_data); if (adv_png_write_chunk(f_out, ADV_PNG_CN_IDAT, cmp_data, cmp_size, 0) != 0) { throw_png_error(); } data_free(cmp_data); } if (adv_png_write_chunk(f_out, type, data, size, 0) != 0) { throw_png_error(); } free(data); if (type == end) break; } } void convert_png(adv_fz* f_in, adv_fz* f_out) { if (adv_png_read_signature(f_in) != 0) { throw_png_error(); } if (adv_png_write_signature(f_out, 0) != 0) { throw_png_error(); } convert_dat(f_in, f_out, ADV_PNG_CN_IEND); } void convert_mng(adv_fz* f_in, adv_fz* f_out) { if (adv_mng_read_signature(f_in) != 0) { throw_png_error(); } if (adv_mng_write_signature(f_out, 0) != 0) { throw_png_error(); } convert_dat(f_in, f_out, ADV_MNG_CN_MEND); } void convert_gz(adv_fz* f_in, adv_fz* f_out) { unsigned char header[10]; copy_data(f_in, f_out, header, 10); if (header[0] != 0x1f || header[1] != 0x8b) { throw error() << "Invalid GZ signature"; } if (header[2] != 0x8 /* deflate */) { throw error_unsupported() << "Compression method not supported"; } if ((header[3] & 0xE0) != 0) { throw error_unsupported() << "Unsupported flag"; } if (header[3] & (1 << 2) /* FLG.FEXTRA */) { unsigned char extra_len[2]; copy_data(f_in, f_out, extra_len, 2); copy_data(f_in, f_out, le_uint16_read(extra_len)); } if (header[3] & (1 << 3) /* FLG.FNAME */) { copy_zero(f_in, f_out); } if (header[3] & (1 << 4) /* FLG.FCOMMENT */) { copy_zero(f_in, f_out); } if (header[3] & (1 << 1) /* FLG.FHCRC */) { copy_data(f_in, f_out, 2); } long size = fzsize(f_in); if (size < 0) { throw error() << "Error reading"; } long pos = fztell(f_in); if (pos < 0) { throw error() << "Error reading"; } size -= pos; if (size < 8) { throw error() << "Invalid file format"; } size -= 8; unsigned char* res_data; unsigned res_size; read_deflate(f_in, size, res_data, res_size); unsigned cmp_size = oversize_deflate(res_size); if (cmp_size < res_size) throw error() << "Data size bigger than 4GB is not supported"; unsigned char* cmp_data = data_alloc(cmp_size); unsigned crc = crc32(0, res_data, res_size); if (!compress_deflate(opt_level, cmp_data, cmp_size, res_data, res_size)) throw error() << "Error compressing"; data_free(res_data); if (fzwrite(cmp_data, cmp_size, 1, f_out) != 1) throw error() << "Error writing"; data_free(cmp_data); unsigned char footer[8]; copy_data(f_in, f_out, footer, 8); if (crc != le_uint32_read(footer)) throw error() << "Invalid crc"; if ((res_size & 0xFFFFFFFF) != le_uint32_read(footer + 4)) throw error() << "Invalid size"; } void convert_inplace(const string& path) { adv_fz* f_in; adv_fz* f_out; // temp name of the saved file string path_dst = file_temp(path); f_in = fzopen(path.c_str(), "rb"); if (!f_in) { throw error() << "Failed open for reading " << path; } try { // read the header unsigned char header[8]; if (fzread(header, 8, 1, f_in) != 1) throw error() << "Error reading " << path; // detect the file type ftype_t ftype; if (header[0] == 0x1f && header[1] == 0x8b) { ftype = ftype_gz; } else if (header[0] == 0x89 && header[1] == 0x50 && header[2] == 0x4E && header[3] == 0x47) { ftype = ftype_png; } else if (header[0] == 0x8A && header[1] == 0x4D && header[2] == 0x4E && header[3] == 0x47) { ftype = ftype_mng; } else { throw error() << "File type not supported"; } // restore the file position if (fzseek(f_in, 0, SEEK_SET) != 0) { throw error() << "Error seeking " << path; } f_out = fzopen(path_dst.c_str(), "wb"); if (!f_out) { throw error() << "Failed open for writing " << path_dst; } try { switch (ftype) { case ftype_png : convert_png(f_in, f_out); break; case ftype_mng : convert_mng(f_in, f_out); break; case ftype_gz : convert_gz(f_in, f_out); break; } } catch (...) { fzclose(f_out); remove(path_dst.c_str()); throw; } } catch (...) { fzclose(f_in); throw; } fzclose(f_in); fzclose(f_out); unsigned dst_size = file_size(path_dst); if (!opt_force && file_size(path) < dst_size) { // delete the new file remove(path_dst.c_str()); throw error_unsupported() << "Bigger " << dst_size; } else { // prevent external signal sig_auto_lock sal; // delete the old file if (remove(path.c_str()) != 0) { remove(path_dst.c_str()); throw error() << "Failed delete of " << path; } // rename the new version with the correct name if (::rename(path_dst.c_str(), path.c_str()) != 0) { throw error() << "Failed rename of " << path_dst << " to " << path; } } } void rezip_single(const string& file, unsigned long long& total_0, unsigned long long& total_1) { unsigned size_0; unsigned size_1; string desc; if (!file_exists(file)) { throw error() << "File " << file << " doesn't exist"; } try { size_0 = file_size(file); try { convert_inplace(file); } catch (error_unsupported& e) { desc = e.desc_get(); } size_1 = file_size(file); } catch (error& e) { throw e << " on " << file; } if (!opt_quiet) { cout << setw(12) << size_0 << setw(12) << size_1 << " "; if (size_0) { unsigned perc = size_1 * 100LL / size_0; cout << setw(3) << perc; } else { cout << " 0"; } cout << "% " << file; if (desc.length()) cout << " (" << desc << ")"; cout << endl; } total_0 += size_0; total_1 += size_1; } void rezip_all(int argc, char* argv[]) { unsigned long long total_0 = 0; unsigned long long total_1 = 0; for(int i=0;i #include #include using namespace std; int opt_dx; int opt_dy; int opt_limit; bool opt_reduce; bool opt_expand; bool opt_noalpha; shrink_t opt_level; bool opt_quiet; bool opt_verbose; bool opt_scroll; adv_mng_type opt_type; bool opt_force; bool opt_crc; void clear_line() { cout << " \r"; } adv_scroll_info* analyze_f_mng(adv_fz* f) { adv_mng* mng; unsigned counter; adv_scroll* scroll; int dx = 0; int dy = 0; mng = adv_mng_init(f); if (!mng) { throw error() << "Error in the mng stream"; } scroll = scroll_init(opt_dx, opt_dy, opt_limit); counter = 0; try { while (1) { unsigned pix_width; unsigned pix_height; unsigned char* pix_ptr; unsigned pix_pixel; unsigned pix_scanline; unsigned char* dat_ptr_ext; unsigned dat_size; unsigned char* pal_ptr_ext; unsigned pal_size; unsigned tick; int r; r = adv_mng_read(mng, &pix_width, &pix_height, &pix_pixel, &dat_ptr_ext, &dat_size, &pix_ptr, &pix_scanline, &pal_ptr_ext, &pal_size, &tick, f); if (r < 0) { throw_png_error(); } if (r > 0) break; data_ptr dat_ptr(dat_ptr_ext); data_ptr pal_ptr(pal_ptr_ext); scroll_analyze(scroll, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline); ++counter; if (opt_verbose) { int x, y; scroll_last_get(scroll, &x, &y); if (dx < abs(x)) dx = abs(x); if (dy < abs(y)) dy = abs(y); cout << "Scroll frame " << counter << ", range " << dx << "x" << dy << " \r"; cout.flush(); } } } catch (...) { adv_mng_done(mng); scroll_done(scroll); if (opt_verbose) { cout << endl; } throw; } adv_mng_done(mng); if (opt_verbose) { clear_line(); } adv_scroll_info* info = scroll_info_init(scroll); scroll_done(scroll); return info; } adv_scroll_info* analyze_mng(const string& path) { adv_fz* f; adv_scroll_info* info; f = fzopen(path.c_str(), "rb"); if (!f) { throw error() << "Failed open for reading " << path; } try { info = analyze_f_mng(f); } catch (...) { fzclose(f); throw; } fzclose(f); return info; } adv_scroll_info* analyze_png(int argc, char* argv[]) { unsigned counter; adv_scroll* scroll; int dx = 0; int dy = 0; scroll = scroll_init(opt_dx, opt_dy, opt_limit); counter = 0; try { for(int i=0;i 0) break; data_ptr dat_ptr(dat_ptr_ext); data_ptr pal_ptr(pal_ptr_ext); if (!is_reducible_image(pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline)) reducible = false; } } catch (...) { adv_mng_done(mng); if (opt_verbose) { cout << endl; } throw; } adv_mng_done(mng); if (opt_verbose) { clear_line(); } } catch (...) { fzclose(f); throw; } fzclose(f); return reducible; } bool is_reducible_png(int argc, char* argv[]) { bool reducible; reducible = true; for(int i=1;ix, info->y, info->width, info->height, alpha); } else { mng_write_header(mng, f, fc, frame_width, frame_height, frame_frequency, 0, 0, 0, 0, alpha); } } void convert_image(adv_mng_write* mng, adv_fz* f_out, unsigned* fc, unsigned pix_width, unsigned pix_height, unsigned pix_pixel, unsigned char* pix_ptr, unsigned pix_scanline, unsigned char* pal_ptr, unsigned pal_size, adv_scroll_coord* scc) { if (opt_noalpha && pix_pixel == 4) { /* convert to 3 bytes per pixel */ unsigned dst_pixel = 3; unsigned dst_scanline = 3 * pix_width; data_ptr dst_ptr; dst_ptr = data_alloc(dst_scanline * pix_height); unsigned i, j; for(i=0;ix, scc->y); } else { mng_write_image(mng, f_out, fc, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, 0, 0); } } } void convert_f_mng(adv_fz* f_in, adv_fz* f_out, unsigned* filec, unsigned* framec, adv_scroll_info* info, bool reduce, bool expand) { unsigned counter; adv_mng* mng; adv_mng_write* mng_write; bool first = true; mng = adv_mng_init(f_in); if (!mng) { throw error() << "Error in the mng stream"; } mng_write = mng_write_init(opt_type, opt_level, reduce, expand); if (!mng_write) { throw error() << "Error in the mng stream"; } *filec = 0; counter = 0; try { while (1) { unsigned pix_width; unsigned pix_height; unsigned char* pix_ptr; unsigned pix_pixel; unsigned pix_scanline; unsigned char* dat_ptr_ext; unsigned dat_size; unsigned char* pal_ptr_ext; unsigned pal_size; unsigned tick; int r; r = adv_mng_read(mng, &pix_width, &pix_height, &pix_pixel, &dat_ptr_ext, &dat_size, &pix_ptr, &pix_scanline, &pal_ptr_ext, &pal_size, &tick, f_in); if (r < 0) { throw_png_error(); } if (r > 0) break; data_ptr dat_ptr(dat_ptr_ext); data_ptr pal_ptr(pal_ptr_ext); if (first) { unsigned frequency = adv_mng_frequency_get(mng); if (opt_type == mng_vlc && tick!=1) { // adjust the frequency frequency = (frequency + tick / 2) / tick; if (frequency == 0) frequency = 1; } convert_header(mng_write, f_out, filec, adv_mng_width_get(mng), adv_mng_height_get(mng), frequency, info, pix_pixel == 4 && !opt_noalpha); first = false; } if (opt_type != mng_vlc) mng_write_frame(mng_write, f_out, filec, tick); if (info) { if (counter >= info->mac) { throw error() << "Internal error"; } convert_image(mng_write, f_out, filec, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, &info->map[counter]); } else { convert_image(mng_write, f_out, filec, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, 0); } ++counter; if (opt_verbose) { cout << "Compressing "; if (reduce) cout << "and reducing "; if (expand) cout << "and expanding "; cout << "frame " << counter << ", size " << *filec << " \r"; cout.flush(); } } } catch (...) { adv_mng_done(mng); mng_write_done(mng_write); if (opt_verbose) { cout << endl; } throw; } mng_write_footer(mng_write, f_out, filec); adv_mng_done(mng); mng_write_done(mng_write); if (opt_verbose) { clear_line(); } *framec = counter; } void convert_mng(const string& path_src, const string& path_dst) { adv_scroll_info* info; bool reduce; bool expand; if (opt_scroll && opt_type == mng_vlc) { throw error() << "The --scroll and --vlc options are incompatible"; } if (opt_scroll && opt_type == mng_lc) { throw error() << "The --scroll and --lc options are incompatible"; } if (opt_scroll) { info = analyze_mng(path_src); } else { info = 0; } if (opt_reduce) { reduce = is_reducible_mng(path_src); } else { reduce = false; } if (opt_expand) { expand = true; } else { expand = false; } adv_fz* f_in; adv_fz* f_out; unsigned filec; unsigned framec; f_in = fzopen(path_src.c_str(), "rb"); if (!f_in) { throw error() << "Failed open for reading " << path_src; } f_out = fzopen(path_dst.c_str(), "wb"); if (!f_out) { fzclose(f_in); throw error() << "Failed open for writing " << path_dst; } try { convert_f_mng(f_in, f_out, &filec, &framec, info, reduce, expand); } catch (...) { fzclose(f_in); fzclose(f_out); remove(path_dst.c_str()); throw; } fzclose(f_in); fzclose(f_out); if (info) scroll_info_done(info); } void convert_mng_inplace(const string& path) { // temp name of the saved file string path_dst = file_temp(path); try { convert_mng(path, path_dst); } catch (...) { remove(path_dst.c_str()); throw; } unsigned dst_size = file_size(path_dst); if (!opt_force && file_size(path) < dst_size) { // delete the new file remove(path_dst.c_str()); throw error_unsupported() << "Bigger " << dst_size; } else { // prevent external signal sig_auto_lock sal; // delete the old file if (remove(path.c_str()) != 0) { remove(path_dst.c_str()); throw error() << "Failed delete of " << path; } // rename the new version with the correct name if (::rename(path_dst.c_str(), path.c_str()) != 0) { throw error() << "Failed rename of " << path_dst << " to " << path; } } } void mng_print(const string& path) { unsigned type; unsigned size; adv_fz* f_in; f_in = fzopen(path.c_str(), "rb"); if (!f_in) { throw error() << "Failed open for reading " << path; } try { if (adv_mng_read_signature(f_in) != 0) { throw_png_error(); } do { unsigned char* data_ext; if (adv_png_read_chunk(f_in, &data_ext, &size, &type) != 0) { throw_png_error(); } data_ptr data(data_ext); if (opt_crc) { cout << hex << setw(8) << setfill('0') << crc32(0, data, size); cout << " "; cout << dec << setw(0) << setfill(' ') << size; cout << "\n"; } else { png_print_chunk(type, data, size); } } while (type != ADV_MNG_CN_MEND); } catch (...) { fzclose(f_in); throw; } fzclose(f_in); } void extract(const string& path_src) { adv_fz* f_in; adv_mng* mng; adv_fz* f_out; unsigned counter; string base; unsigned first_tick; base = file_basename(path_src); f_in = fzopen(path_src.c_str(), "rb"); if (!f_in) { throw error() << "Failed open for reading " << path_src; } mng = adv_mng_init(f_in); if (!mng) { throw error() << "Error in the mng stream"; } counter = 0; first_tick = 1; while (1) { unsigned pix_width; unsigned pix_height; unsigned char* pix_ptr; unsigned pix_pixel; unsigned pix_scanline; unsigned char* dat_ptr_ext; unsigned dat_size; unsigned char* pal_ptr_ext; unsigned pal_size; unsigned tick; unsigned char* dst_ptr; unsigned dst_pixel; unsigned dst_scanline; int r; r = adv_mng_read(mng, &pix_width, &pix_height, &pix_pixel, &dat_ptr_ext, &dat_size, &pix_ptr, &pix_scanline, &pal_ptr_ext, &pal_size, &tick, f_in); if (r < 0) { throw_png_error(); } if (r > 0) break; data_ptr dat_ptr(dat_ptr_ext); data_ptr pal_ptr(pal_ptr_ext); if (counter == 0) { first_tick = tick; if (!first_tick) first_tick = 1; } ostringstream path_dst; path_dst << base << "-"; // not optimal code for g++ 2.95.3 path_dst.setf(ios::right, ios::adjustfield); path_dst << setw(8) << setfill('0') << counter; path_dst << ".png"; if (!opt_quiet) { cout << path_dst.str() << endl; } f_out = fzopen(path_dst.str().c_str(), "wb"); if (!f_out) { fzclose(f_in); throw error() << "Failed open for writing " << path_dst.str(); } ++counter; if (!opt_noalpha) { // convert to 4 byte RGBA format. // mencoder 0.90 has problems with 3 byte RGB format. png_convert_4(pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, &dst_ptr, &dst_pixel, &dst_scanline); png_write(f_out, pix_width, pix_height, dst_pixel, dst_ptr, dst_scanline, 0, 0, 0, 0, opt_level); free(dst_ptr); } else { png_write(f_out, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, 0, 0, opt_level); } fzclose(f_out); } cout << adv_mng_frequency_get(mng) / (double)first_tick << endl; if (opt_verbose) { cout << endl; cout << "Example mencoder call:" << endl; cout << "mencoder " << base << "-\\*.png -mf on:w=" << adv_mng_width_get(mng) << ":h=" << adv_mng_height_get(mng) << ":fps=" << adv_mng_frequency_get(mng) / first_tick << ":type=png -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=1000:vhq -o " << base << ".avi" << endl; } adv_mng_done(mng); fzclose(f_in); } void add_all(int argc, char* argv[], unsigned frequency) { unsigned counter; unsigned filec; adv_fz* f_out; string path_dst; adv_scroll_info* info; adv_mng_write* mng_write; bool reduce; bool expand; if (argc < 2) { throw error() << "Missing arguments"; } if (opt_scroll && opt_type == mng_vlc) { throw error() << "The --scroll and --vlc options are incompatible"; } if (opt_scroll && opt_type == mng_lc) { throw error() << "The --scroll and --lc options are incompatible"; } if (opt_scroll) { info = analyze_png(argc - 1, argv + 1); } else { info = 0; } if (opt_reduce) { reduce = is_reducible_png(argc - 1, argv + 1); } else { reduce = false; } if (opt_expand) { expand = true; } else { expand = false; } path_dst = argv[0]; f_out = fzopen(path_dst.c_str(), "wb"); if (!f_out) { throw error() << "Failed open for writing " << path_dst; } mng_write = mng_write_init(opt_type, opt_level, reduce, expand); if (!mng_write) { throw error() << "Error in the mng stream"; } filec = 0; counter = 0; try { for(int i=1;i= info->mac) { throw error() << "Internal error"; } convert_image(mng_write, f_out, &filec, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, &info->map[counter]); } else { convert_image(mng_write, f_out, &filec, pix_width, pix_height, pix_pixel, pix_ptr, pix_scanline, pal_ptr, pal_size, 0); } fzclose(f_in); ++counter; if (opt_verbose) { cout << "Compressing "; if (reduce) cout << "and reducing "; if (expand) cout << "and expanding "; cout << "frame " << counter << ", size " << filec << " \r"; cout.flush(); } } catch (...) { fzclose(f_in); throw; } } } catch (...) { if (opt_verbose) { cout << endl; } fzclose(f_out); remove(path_dst.c_str()); if (info) scroll_info_done(info); throw; } mng_write_footer(mng_write, f_out, &filec); mng_write_done(mng_write); fzclose(f_out); if (info) scroll_info_done(info); if (opt_verbose) { clear_line(); } } void remng_single(const string& file, unsigned long long& total_0, unsigned long long& total_1) { unsigned size_0; unsigned size_1; string desc; if (!file_exists(file)) { throw error() << "File " << file << " doesn't exist"; } try { size_0 = file_size(file); try { convert_mng_inplace(file); } catch (error_unsupported& e) { desc = e.desc_get(); } size_1 = file_size(file); } catch (error& e) { throw e << " on " << file; } if (!opt_quiet) { cout << setw(12) << size_0 << setw(12) << size_1 << " "; if (size_0) { unsigned perc = size_1 * 100LL / size_0; cout << setw(3) << perc; } else { cout << " 0"; } cout << "% " << file; if (desc.length()) cout << " (" << desc << ")"; cout << endl; } total_0 += size_0; total_1 += size_1; } void remng_all(int argc, char* argv[]) { unsigned long long total_0 = 0; unsigned long long total_1 = 0; for(int i=0;i 1 && !opt_crc) cout << "File: " << argv[i] << endl; mng_print(argv[i]); } } void extract_all(int argc, char* argv[]) { for(int i=0;i 250) throw error() << "Invalid frequency"; } break; case '0' : opt_level.level = shrink_none; opt_force = true; break; case '1' : opt_level.level = shrink_fast; break; case '2' : opt_level.level = shrink_normal; break; case '3' : opt_level.level = shrink_extra; break; case '4' : opt_level.level = shrink_insane; break; case 'i' : opt_level.iter = atoi(optarg); break; case 's' : { int n, s; opt_dx = 0; opt_dy = 0; n = sscanf(optarg, "%dx%d%n", &opt_dx, &opt_dy, &s); if (n < 2 || strlen(optarg) != s) throw error() << "Invalid option -s"; if (opt_dx < 0 || opt_dy < 0 || (opt_dx == 0 && opt_dy == 0) || opt_dx > 128 || opt_dy > 128) throw error() << "Invalid argument for option -s"; opt_scroll = true; opt_limit = opt_dx + opt_dy; } break; case 'S' : { int n, s; opt_limit = 0; n = sscanf(optarg, "%d%n", &opt_limit, &s); if (n < 1 || strlen(optarg) != s) throw error() << "Invalid option -S"; if (opt_limit < 1 || opt_limit > 128) throw error() << "Invalid argument for option -S"; opt_scroll = true; opt_dx = opt_limit; opt_dy = opt_limit; } break; case 'r' : opt_reduce = true; opt_expand = false; break; case 'e' : opt_reduce = false; opt_expand = true; break; case 'n' : opt_noalpha = true; break; case 'c' : opt_type = mng_lc; opt_force = true; break; case 'C' : opt_type = mng_vlc; opt_force = true; break; case 'f' : opt_force = true; break; case 'q' : opt_verbose = false; opt_quiet = true; break; case 'v' : opt_verbose = true; opt_quiet = false; break; case 'h' : usage(); return; case 'V' : version(); return; default: { // not optimal code for g++ 2.95.3 string opt; opt = (char)optopt; throw error() << "Unknown option `" << opt << "'"; } } } switch (cmd) { case cmd_recompress : remng_all(argc - optind, argv + optind); break; case cmd_list : list_all(argc - optind, argv + optind); break; case cmd_extract : extract_all(argc - optind, argv + optind); break; case cmd_add : add_all(argc - optind, argv + optind, add_frequency); break; case cmd_unset : throw error() << "No command specified"; } } int main(int argc, char* argv[]) { try { process(argc, argv); } catch (error& e) { cerr << e << endl; exit(EXIT_FAILURE); } catch (std::bad_alloc) { cerr << "Low memory" << endl; exit(EXIT_FAILURE); } catch (...) { cerr << "Unknown error" << endl; exit(EXIT_FAILURE); } return EXIT_SUCCESS; } advancecomp-1.23/repng.cc000066400000000000000000000265661301462770100153610ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2003, 2005 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "pngex.h" #include "file.h" #include "compress.h" #include "siglock.h" #include "lib/endianrw.h" #include #include using namespace std; shrink_t opt_level; bool opt_quiet; bool opt_force; bool opt_crc; bool reduce_image(unsigned char** out_ptr, unsigned* out_scanline, unsigned char* pal_ptr, unsigned* pal_count, unsigned char* palrns_ptr, unsigned *palrns_count, unsigned width, unsigned height, unsigned char* img_ptr, unsigned img_scanline, const unsigned char* rns_ptr, unsigned rns_size) { unsigned char col_ptr[256*3]; unsigned col_count; unsigned i, j, k; unsigned char* new_ptr; unsigned new_scanline; col_count = 0; if (rns_ptr != 0 && rns_size == 6) { /* assume 8 bits per pixel */ col_count = 1; col_ptr[0] = rns_ptr[1]; col_ptr[1] = rns_ptr[3]; col_ptr[2] = rns_ptr[5]; *palrns_count = 1; palrns_ptr[0] = 0x0; } else { *palrns_count = 0; } new_scanline = width; new_ptr = data_alloc(height * new_scanline); for(i=0;i 1 && !opt_crc) cout << "File: " << argv[i] << endl; png_print(argv[i]); } } #if HAVE_GETOPT_LONG struct option long_options[] = { {"recompress", 0, 0, 'z'}, {"list", 0, 0, 'l'}, {"list-crc", 0, 0, 'L'}, {"shrink-store", 0, 0, '0'}, {"shrink-fast", 0, 0, '1'}, {"shrink-normal", 0, 0, '2'}, {"shrink-extra", 0, 0, '3'}, {"shrink-insane", 0, 0, '4'}, {"iter", 1, 0, 'i'}, {"quiet", 0, 0, 'q'}, {"help", 0, 0, 'h'}, {"version", 0, 0, 'V'}, {0, 0, 0, 0} }; #endif #define OPTIONS "zlL01234i:fqhV" void version() { cout << PACKAGE " v" VERSION " by Andrea Mazzoleni, " PACKAGE_URL "\n"; } void usage() { version(); cout << "Usage: advpng [options] [FILES...]" << endl; cout << endl; cout << "Modes:" << endl; cout << " " SWITCH_GETOPT_LONG("-l, --list ", "-l") " List the content of the files" << endl; cout << " " SWITCH_GETOPT_LONG("-z, --recompress ", "-z") " Recompress the specified files" << endl; cout << "Options:" << endl; cout << " " SWITCH_GETOPT_LONG("-0, --shrink-store ", "-0") " Don't compress" << endl; cout << " " SWITCH_GETOPT_LONG("-1, --shrink-fast ", "-1") " Compress fast (zlib)" << endl; cout << " " SWITCH_GETOPT_LONG("-2, --shrink-normal ", "-2") " Compress normal (libdeflate)" << endl; cout << " " SWITCH_GETOPT_LONG("-3, --shrink-extra ", "-3") " Compress extra (7z)" << endl; cout << " " SWITCH_GETOPT_LONG("-4, --shrink-insane ", "-4") " Compress extreme (zopfli)" << endl; cout << " " SWITCH_GETOPT_LONG("-i N, --iter=N ", "-i") " Compress iterations" << endl; cout << " " SWITCH_GETOPT_LONG("-f, --force ", "-f") " Force the new file also if it's bigger" << endl; cout << " " SWITCH_GETOPT_LONG("-q, --quiet ", "-q") " Don't print on the console" << endl; cout << " " SWITCH_GETOPT_LONG("-h, --help ", "-h") " Help of the program" << endl; cout << " " SWITCH_GETOPT_LONG("-V, --version ", "-V") " Version of the program" << endl; } void process(int argc, char* argv[]) { enum cmd_t { cmd_unset, cmd_recompress, cmd_list } cmd = cmd_unset; opt_quiet = false; opt_level.level = shrink_normal; opt_level.iter = 0; opt_force = false; opt_crc = false; if (argc <= 1) { usage(); return; } int c = 0; opterr = 0; // don't print errors while ((c = #if HAVE_GETOPT_LONG getopt_long(argc, argv, OPTIONS, long_options, 0)) #else getopt(argc, argv, OPTIONS)) #endif != EOF) { switch (c) { case 'z' : if (cmd != cmd_unset) throw error() << "Too many commands"; cmd = cmd_recompress; break; case 'l' : if (cmd != cmd_unset) throw error() << "Too many commands"; cmd = cmd_list; break; case 'L' : if (cmd != cmd_unset) throw error() << "Too many commands"; cmd = cmd_list; opt_crc = true; break; case '0' : opt_level.level = shrink_none; opt_force = true; break; case '1' : opt_level.level = shrink_fast; break; case '2' : opt_level.level = shrink_normal; break; case '3' : opt_level.level = shrink_extra; break; case '4' : opt_level.level = shrink_insane; break; case 'i' : opt_level.iter = atoi(optarg); break; case 'f' : opt_force = true; break; case 'q' : opt_quiet = true; break; case 'h' : usage(); return; case 'V' : version(); return; default: { // not optimal code for g++ 2.95.3 string opt; opt = (char)optopt; throw error() << "Unknown option `" << opt << "'"; } } } switch (cmd) { case cmd_recompress : rezip_all(argc - optind, argv + optind); break; case cmd_list : list_all(argc - optind, argv + optind); break; case cmd_unset : throw error() << "No command specified"; } } int main(int argc, char* argv[]) { try { process(argc, argv); } catch (error& e) { cerr << e << endl; exit(EXIT_FAILURE); } catch (std::bad_alloc) { cerr << "Low memory" << endl; exit(EXIT_FAILURE); } catch (...) { cerr << "Unknown error" << endl; exit(EXIT_FAILURE); } return EXIT_SUCCESS; } advancecomp-1.23/rezip.cc000066400000000000000000000366031301462770100153700ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "zip.h" #include "file.h" #include #include #include using namespace std; void rezip_single(const string& file, unsigned long long& total_0, unsigned long long& total_1, bool quiet, bool standard, shrink_t level, bool keep_file_time) { zip z(file); unsigned size_0; unsigned size_1; time_t mtime; if (!file_exists(file)) { throw error() << "File " << file << " doesn't exist"; } try { mtime = file_time(file); size_0 = file_size(file); z.open(); z.load(); z.shrink(standard, level); z.save(); z.close(); size_1 = file_size(file); if (keep_file_time) file_utime(file, mtime); } catch (error& e) { throw e << " on " << file; } if (!quiet) { cout << setw(12) << size_0 << setw(12) << size_1 << " "; if (size_0) { unsigned perc = size_1 * 100LL / size_0; cout << setw(3) << perc; } else { cout << " 0"; } cout << "% " << file << endl; } total_0 += size_0; total_1 += size_1; } void rezip_all(int argc, char* argv[], bool quiet, bool standard, shrink_t level, bool keep_file_time) { unsigned long long total_0 = 0; unsigned long long total_1 = 0; for(int i=0;icrc_get(); cout << " "; cout << dec << setw(0) << setfill(' ') << i->compressed_size_get(); cout << "\n"; } } else { cout << "Archive: " << file << endl; cout << " Length Method Size Ratio Date Time CRC-32 Name" << endl; cout << " -------- ------ ------- ----- ---- ---- ------ ----" << endl; for(zip::iterator i=z.begin();i!=z.end();++i) { // not optimal code for g++ 2.95.3 cout.setf(ios::right, ios::adjustfield); cout << dec << setw(9) << setfill(' ') << i->uncompressed_size_get(); cout << " "; string m; switch (i->method_get()) { case zip_entry::store : m = "Stored"; break; case zip_entry::shrunk : m = "Shrunk"; break; case zip_entry::reduce1 : m = "Reduce1"; break; case zip_entry::reduce2 : m = "Reduce2"; break; case zip_entry::reduce3 : m = "Reduce3"; break; case zip_entry::reduce4 : m = "Reduce4"; break; case zip_entry::implode_4kdict_2tree : m = "Impl:42"; break; case zip_entry::implode_8kdict_2tree : m = "Impl:82"; break; case zip_entry::implode_4kdict_3tree : m = "Impl:43"; break; case zip_entry::implode_8kdict_3tree : m = "Impl:83"; break; case zip_entry::deflate0 : m = "Defl:S"; break; case zip_entry::deflate1 : m = "Defl:S"; break; case zip_entry::deflate2 : m = "Defl:S"; break; case zip_entry::deflate3 : m = "Defl:F"; break; case zip_entry::deflate4 : m = "Defl:F"; break; case zip_entry::deflate5 : m = "Defl:F"; break; case zip_entry::deflate6 : m = "Defl:N"; break; case zip_entry::deflate7 : m = "Defl:N"; break; case zip_entry::deflate8 : m = "Defl:N"; break; case zip_entry::deflate9 : m = "Defl:X"; break; case zip_entry::bzip2 : m = "Bzip2"; break; case zip_entry::lzma : m = "LZMA"; break; default: m = "Unknown"; break; } cout.setf(ios::left, ios::adjustfield); // not optimal code for g++ 2.95.3 cout << setw(7) << m.c_str(); cout.setf(ios::right, ios::adjustfield); cout << setw(8) << i->compressed_size_get(); cout << " "; if (i->uncompressed_size_get()) { unsigned perc = (i->uncompressed_size_get() - i->compressed_size_get()) * 100LL / i->uncompressed_size_get(); cout << setw(3) << perc; } else { cout << " 0"; } cout << "% "; time_t t = i->time_get(); struct tm* tm = localtime(&t); cout << setw(2) << setfill('0') << tm->tm_mon + 1; cout << "-"; cout << setw(2) << setfill('0') << tm->tm_mday; cout << "-"; cout << setw(2) << setfill('0') << (tm->tm_year % 100); cout << " "; cout << setw(2) << setfill('0') << tm->tm_hour; cout << ":"; cout << setw(2) << setfill('0') << tm->tm_min; cout << " "; cout << hex << setw(8) << setfill('0') << i->crc_get(); cout << " "; cout << i->name_get(); cout << endl; uncompressed_size += i->uncompressed_size_get(); compressed_size += i->compressed_size_get(); } cout << " -------- ------- --- -------" << endl; cout << dec << setw(9) << setfill(' ') << uncompressed_size; cout << " "; cout << dec << setw(9) << setfill(' ') << compressed_size; cout << " "; if (uncompressed_size) { unsigned perc = (uncompressed_size - compressed_size) * 100LL / uncompressed_size; cout << setw(3) << perc; } else { cout << " 0"; } cout << "% "; cout << z.size() << " files" << endl; } z.close(); } catch (error& e) { throw e << " on " << file; } } void list_all(int argc, char* argv[], bool crc) { string file(argv[0]); for(int i=0;i 1) throw error() << "Too many archives specified"; if (argc < 1) throw error() << "No archive specified"; zip z(argv[0]); z.open(); z.load(); for(zip::iterator i=z.begin();i!=z.end();++i) { unsigned char* data = (unsigned char*)operator new(i->uncompressed_size_get()); try { i->uncompressed_read(data); string file = i->name_get(); // if end with / it's a directory if (file.length() && file[file.length()-1]!='/') { if (!quiet) cout << file << endl; file_mktree(file); FILE* f = fopen(file.c_str(), "wb"); if (!f) throw error() << "Failed open for writing file " << file; try { if (fwrite(data, i->uncompressed_size_get(), 1, f)!=1) throw error() << "Failed write file " << file; } catch (...) { fclose(f); throw; } fclose(f); file_utime(file, i->time_get()); } } catch (...) { operator delete(data); throw; } operator delete(data); } z.close(); } void add_single(zip& z, const string& local, const string& common, bool quiet, bool standard, shrink_t level) { struct stat st; string file = local + common; string name = file_name(file); // ignore special file if (name == "." || name == "..") return; if (stat(file.c_str(), &st)!=0) throw error() << "Failed stat file " << file; if (S_ISDIR(st.st_mode)) { DIR* d = opendir(file.c_str()); if (!d) throw error() << "Failed open dir " << file; try { struct dirent* dd; while ((dd = readdir(d)) != 0) { add_single(z, local, common + "/" + dd->d_name, quiet, standard, level); } } catch (...) { closedir(d); throw; } closedir(d); } else { unsigned char* data = (unsigned char*)operator new(st.st_size); try { if (!quiet) cout << file << endl; FILE* f = fopen(file.c_str(), "rb"); if (!f) throw error() << "Failed open for reading file " << file; if (st.st_size != 0) if (fread(data, st.st_size, 1, f)!=1) throw error() << "Failed read file " << file; fclose(f); zip::iterator i = z.insert_uncompressed(common, data, st.st_size, crc32(0, (unsigned char*)data, st.st_size), st.st_mtime, false); if (level.level != shrink_none) i->shrink(standard, level); } catch (...) { operator delete(data); throw; } operator delete(data); } } void add_all(int argc, char* argv[], bool quiet, bool standard, shrink_t level) { if (argc < 1) throw error() << "No archive specified"; if (argc < 2) throw error() << "No files specified"; zip z(argv[0]); z.create(); for(int i=1;i= 8) { unsigned char data[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 }; unsigned run = j / 8; if (run > 255) run = 255; /* prevent overflow in the sum byte registers */ j = j - run * 8; __asm__ __volatile__( "movq 0(%3), %%mm2\n" "movq 8(%3), %%mm3\n" "0:\n" "movq 0(%0), %%mm0\n" "movq 0(%1), %%mm1\n" "pcmpeqb %%mm0, %%mm1\n" "pand %%mm3, %%mm1\n" "paddb %%mm1, %%mm2\n" "addl $8, %0\n" "addl $8, %1\n" "decl %2\n" "jnz 0b\n" "movq %%mm2, 0(%3)\n" : "+r" (p0), "+r" (p1), "+r" (run) : "r" (data) : "cc", "memory" ); count += data[0]; count += data[1]; count += data[2]; count += data[3]; count += data[4]; count += data[5]; count += data[6]; count += data[7]; } while (j > 0) { if (p0[0] == p1[0]) ++count; ++p0; ++p1; --j; } #else #if defined(USE_OPTC) /* C optimized version */ j = width; while (j >= 4) { unsigned v0 = *(unsigned*)p0; unsigned v1 = *(unsigned*)p1; v0 ^= v1; if (v0) { if ((v0 & 0x000000FF) == 0) ++count; if ((v0 & 0x0000FF00) == 0) ++count; if ((v0 & 0x00FF0000) == 0) ++count; if ((v0 & 0xFF000000) == 0) ++count; } else { count += 4; } p0 += 4; p1 += 4; j -= 4; } while (j > 0) { if (p0[0] == p1[0]) ++count; ++p0; ++p1; --j; } #else /* standard C implementation */ for(j=0;jrange_dx;i<=scroll->range_dx;++i) { for(j=-scroll->range_dy;j<=scroll->range_dy;++j) { if ((j || i) && (abs(i)+abs(j)<=scroll->range_limit)) { unsigned count; count = compare_shift(i, j, width, height, p0, p1, pixel, line); if (count > best_count) { prev_count = best_count; best_count = count; best_x = i; best_y = j; } else if (count > prev_count) { prev_count = count; } } } } /* if the number of matching pixel is too small don't scroll */ if (best_count < total / 4) { *x = 0; *y = 0; } else { *x = best_x; *y = best_y; } } static void insert(adv_scroll_info* info, int x, int y) { if (info->mac == info->max) { info->max *= 2; if (!info->max) info->max = 64; info->map = (adv_scroll_coord*)realloc(info->map, info->max * sizeof(adv_scroll_coord)); } info->map[info->mac].x = x; info->map[info->mac].y = y; ++info->mac; } void scroll_analyze(adv_scroll* scroll, unsigned pix_width, unsigned pix_height, unsigned pix_pixel, unsigned char* pix_ptr, unsigned pix_scanline) { unsigned char* ptr; unsigned scanline; unsigned i; scanline = pix_width * pix_pixel; ptr = data_alloc(pix_height * scanline); for(i=0;ipre_ptr); scroll->pre_ptr = scroll->cur_ptr; scroll->cur_ptr = ptr; if (scroll->pre_ptr && scroll->cur_ptr) { int x; int y; compare(scroll, &x, &y, pix_width, pix_height, scroll->pre_ptr, scroll->cur_ptr, pix_pixel, scanline); insert(scroll->info, x, y); } else { insert(scroll->info, 0, 0); } } static void postprocessing(adv_scroll_info* info) { int px = 0; int py = 0; int min_x = 0; int min_y = 0; int max_x = 0; int max_y = 0; unsigned i; for(i=0;imac;++i) { px += info->map[i].x; py += info->map[i].y; if (px < min_x) min_x = px; if (py < min_y) min_y = py; if (px > max_x) max_x = px; if (py > max_y) max_y = py; } info->x = -min_x; info->y = -min_y; info->width = max_x - min_x; info->height = max_y - min_y; } adv_scroll* scroll_init(int dx, int dy, int limit) { adv_scroll* scroll = (adv_scroll*)malloc(sizeof(adv_scroll)); scroll->info = (adv_scroll_info*)malloc(sizeof(adv_scroll_info)); scroll->info->map = 0; scroll->info->mac = 0; scroll->info->max = 0; scroll->range_dx = dx; scroll->range_dy = dy; scroll->range_limit = limit; scroll->cur_ptr = 0; scroll->pre_ptr = 0; return scroll; } void scroll_last_get(adv_scroll* scroll, int* x, int* y) { if (!scroll->info || !scroll->info->mac) { *x = 0; *y = 0; } else { *x = scroll->info->map[scroll->info->mac-1].x; *y = scroll->info->map[scroll->info->mac-1].y; } } adv_scroll_info* scroll_info_init(adv_scroll* scroll) { adv_scroll_info* info = scroll->info; postprocessing(info); scroll->info = 0; return info; } void scroll_info_done(adv_scroll_info* info) { free(info->map); free(info); } void scroll_done(adv_scroll* scroll) { data_free(scroll->pre_ptr); data_free(scroll->cur_ptr); if (scroll->info) scroll_info_done(scroll->info); free(scroll); } advancecomp-1.23/scroll.h000066400000000000000000000040131301462770100153650ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2003 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __SCROLL_H #define __SCROLL_H typedef struct adv_scroll_coord_struct { int x; int y; } adv_scroll_coord; typedef struct adv_scroll_info_struct { adv_scroll_coord* map; /**< Vector of scrolling shift. */ unsigned mac; /**< Space used in the vector. */ unsigned max; /**< Space allocated in the vector. */ int x; /**< Start position of the first image in the scroll buffer. */ int y; unsigned width; /**< Additional size of the scroll buffer. */ unsigned height; } adv_scroll_info; typedef struct adv_scroll_struct { adv_scroll_info* info; /**< Scrolling information. */ unsigned char* pre_ptr; /**< Previous image. */ unsigned char* cur_ptr; /**< Current image. */ int range_dx; /**< Horizontal range to search. */ int range_dy; /**< Vertical range to search. */ int range_limit; /**< Sum range to search. */ } adv_scroll; adv_scroll* scroll_init(int dx, int dy, int limit); void scroll_done(adv_scroll* scroll); void scroll_analyze(adv_scroll* scroll, unsigned pix_width, unsigned pix_height, unsigned pix_pixel, unsigned char* pix_ptr, unsigned pix_scanline); void scroll_last_get(adv_scroll* scroll, int* x, int* y); adv_scroll_info* scroll_info_init(adv_scroll* scroll); void scroll_info_done(adv_scroll_info* info); #endif advancecomp-1.23/siglock.cc000066400000000000000000000031131301462770100156600ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "siglock.h" using namespace std; #if HAVE_SIGHUP static void (*sig_hup)(int); #endif #if HAVE_SIGQUIT static void (*sig_quit)(int); #endif static void (*sig_int)(int); static void (*sig_term)(int); static int sig_ignore_sig; void sig_ignore(int sig) { if (sig_ignore_sig == 0) sig_ignore_sig = sig; } void sig_lock() { sig_ignore_sig = 0; #if HAVE_SIGHUP sig_hup = signal(SIGHUP, sig_ignore); #endif #if HAVE_SIGQUIT sig_quit = signal(SIGQUIT, sig_ignore); #endif sig_int = signal(SIGINT, sig_ignore); sig_term = signal(SIGTERM, sig_ignore); } void sig_unlock() { #if HAVE_SIGHUP signal(SIGHUP, sig_hup); #endif #if HAVE_SIGQUIT signal(SIGQUIT, sig_quit); #endif signal(SIGINT, sig_int); signal(SIGTERM, sig_term); if (sig_ignore_sig) raise(sig_ignore_sig); } advancecomp-1.23/siglock.h000066400000000000000000000017311301462770100155260ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __SIGLOCK_H #define __SIGLOCK_H void sig_lock(); void sig_unlock(); class sig_auto_lock { public: sig_auto_lock() { sig_lock(); } ~sig_auto_lock() { sig_unlock(); } }; #endif advancecomp-1.23/snprintf.c000066400000000000000000000462011301462770100157320ustar00rootroot00000000000000/* * Copyright Patrick Powell 1995 * This code is based on code written by Patrick Powell (papowell@astart.com) * It may be used for any purpose as long as this notice remains intact * on all source code distributions */ /************************************************************** * Original: * Patrick Powell Tue Apr 11 09:48:21 PDT 1995 * A bombproof version of doprnt (dopr) included. * Sigh. This sort of thing is always nasty do deal with. Note that * the version here does not include floating point... * * snprintf() is used instead of sprintf() as it does limit checks * for string length. This covers a nasty loophole. * * The other functions are there to prevent NULL pointers from * causing nast effects. * * More Recently: * Brandon Long 9/15/96 for mutt 0.43 * This was ugly. It is still ugly. I opted out of floating point * numbers, but the formatter understands just about everything * from the normal C string format, at least as far as I can tell from * the Solaris 2.5 printf(3S) man page. * * Brandon Long 10/22/97 for mutt 0.87.1 * Ok, added some minimal floating point support, which means this * probably requires libm on most operating systems. Don't yet * support the exponent (e, E) and sigfig (g, G). Also, fmtint() * was pretty badly broken, it just wasn't being exercised in ways * which showed it, so that's been fixed. Also, formated the code * to mutt conventions, and removed dead code left over from the * original. Also, there is now a builtin-test, just compile with: * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm * and run snprintf for results. * * Thomas Roessler 01/27/98 for mutt 0.89i * The PGP code was using unsigned hexadecimal formats. * Unfortunately, unsigned formats simply didn't work. * * Michael Elkins 03/05/98 for mutt 0.90.8 * The original code assumed that both snprintf() and vsnprintf() were * missing. Some systems only have snprintf() but not vsnprintf(), so * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF. * * Andrew Tridgell (tridge@samba.org) Oct 1998 * fixed handling of %.0f * added test for HAVE_LONG_DOUBLE * * Chris Kirmse (ckirmse@yahoo.com) May 2003 * fixed handling of leading zeros in the fractional part of a float. * * Andrea Mazzoleni May 2003 * added minimal support for %g. * **************************************************************/ #if HAVE_CONFIG_H #include #endif /* moved above the #ifdef to avoid warning about empty c-files */ #include #include #include #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) /* varargs declarations: */ #if defined(HAVE_STDARG_H) # include # define HAVE_STDARGS /* let's hope that works everywhere (mj) */ # define VA_LOCAL_DECL va_list ap # define VA_START(f) va_start(ap, f) # define VA_SHIFT(v, t) ; /* no-op for ANSI */ # define VA_END va_end(ap) #else # if defined(HAVE_VARARGS_H) # include # undef HAVE_STDARGS # define VA_LOCAL_DECL va_list ap # define VA_START(f) va_start(ap) /* f is ignored! */ # define VA_SHIFT(v, t) v = va_arg(ap, t) # define VA_END va_end(ap) # else #error NO VARARGS /*XX ** NO VARARGS ** XX*/ # endif #endif #ifdef HAVE_LONG_DOUBLE #define LDOUBLE long double #else #define LDOUBLE double #endif int snprintf (char *str, size_t count, const char *fmt, ...); int vsnprintf (char *str, size_t count, const char *fmt, va_list arg); static void dopr (char *buffer, size_t maxlen, const char *format, va_list args); static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, int min, int max); static void fmtint (char *buffer, size_t *currlen, size_t maxlen, long value, int base, int min, int max, int flags); static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags); static void fmtfpg (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags); static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c ); /* * dopr(): poor man's version of doprintf */ /* format read states */ #define DP_S_DEFAULT 0 #define DP_S_FLAGS 1 #define DP_S_MIN 2 #define DP_S_DOT 3 #define DP_S_MAX 4 #define DP_S_MOD 5 #define DP_S_CONV 6 #define DP_S_DONE 7 /* format flags - Bits */ #define DP_F_MINUS (1 << 0) #define DP_F_PLUS (1 << 1) #define DP_F_SPACE (1 << 2) #define DP_F_NUM (1 << 3) #define DP_F_ZERO (1 << 4) #define DP_F_UP (1 << 5) #define DP_F_UNSIGNED (1 << 6) /* Conversion Flags */ #define DP_C_SHORT 1 #define DP_C_LONG 2 #define DP_C_LDOUBLE 3 #define char_to_int(p) (p - '0') #define MAX(p, q) ((p >= q) ? p : q) static void dopr (char *buffer, size_t maxlen, const char *format, va_list args) { char ch; long value; LDOUBLE fvalue; char *strvalue; int min; int max; int state; int flags; int cflags; size_t currlen; state = DP_S_DEFAULT; currlen = flags = cflags = min = 0; max = -1; ch = *format++; while (state != DP_S_DONE) { if ((ch == '\0') || (currlen >= maxlen)) state = DP_S_DONE; switch(state) { case DP_S_DEFAULT: if (ch == '%') state = DP_S_FLAGS; else dopr_outch (buffer, &currlen, maxlen, ch); ch = *format++; break; case DP_S_FLAGS: switch (ch) { case '-': flags |= DP_F_MINUS; ch = *format++; break; case '+': flags |= DP_F_PLUS; ch = *format++; break; case ' ': flags |= DP_F_SPACE; ch = *format++; break; case '#': flags |= DP_F_NUM; ch = *format++; break; case '0': flags |= DP_F_ZERO; ch = *format++; break; default: state = DP_S_MIN; break; } break; case DP_S_MIN: if (isdigit(ch)) { min = 10*min + char_to_int (ch); ch = *format++; } else if (ch == '*') { min = va_arg (args, int); ch = *format++; state = DP_S_DOT; } else state = DP_S_DOT; break; case DP_S_DOT: if (ch == '.') { state = DP_S_MAX; ch = *format++; } else state = DP_S_MOD; break; case DP_S_MAX: if (isdigit(ch)) { if (max < 0) max = 0; max = 10*max + char_to_int (ch); ch = *format++; } else if (ch == '*') { max = va_arg (args, int); ch = *format++; state = DP_S_MOD; } else state = DP_S_MOD; break; case DP_S_MOD: /* Currently, we don't support Long Long, bummer */ switch (ch) { case 'h': cflags = DP_C_SHORT; ch = *format++; break; case 'l': cflags = DP_C_LONG; ch = *format++; break; case 'L': cflags = DP_C_LDOUBLE; ch = *format++; break; default: break; } state = DP_S_CONV; break; case DP_S_CONV: switch (ch) { case 'd': case 'i': if (cflags == DP_C_SHORT) value = va_arg (args, int); else if (cflags == DP_C_LONG) value = va_arg (args, long int); else value = va_arg (args, int); fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); break; case 'o': flags |= DP_F_UNSIGNED; if (cflags == DP_C_SHORT) value = va_arg (args, unsigned int); else if (cflags == DP_C_LONG) value = va_arg (args, unsigned long int); else value = va_arg (args, unsigned int); fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags); break; case 'u': flags |= DP_F_UNSIGNED; if (cflags == DP_C_SHORT) value = va_arg (args, unsigned int); else if (cflags == DP_C_LONG) value = va_arg (args, unsigned long int); else value = va_arg (args, unsigned int); fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); break; case 'X': flags |= DP_F_UP; case 'x': flags |= DP_F_UNSIGNED; if (cflags == DP_C_SHORT) value = va_arg (args, unsigned int); else if (cflags == DP_C_LONG) value = va_arg (args, unsigned long int); else value = va_arg (args, unsigned int); fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags); break; case 'f': if (cflags == DP_C_LDOUBLE) fvalue = va_arg (args, LDOUBLE); else fvalue = va_arg (args, double); /* um, floating point? */ fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags); break; case 'E': flags |= DP_F_UP; case 'e': if (cflags == DP_C_LDOUBLE) fvalue = va_arg (args, LDOUBLE); else fvalue = va_arg (args, double); break; case 'G': flags |= DP_F_UP; case 'g': if (cflags == DP_C_LDOUBLE) fvalue = va_arg (args, LDOUBLE); else fvalue = va_arg (args, double); fmtfpg (buffer, &currlen, maxlen, fvalue, min, max, flags); break; case 'c': dopr_outch (buffer, &currlen, maxlen, va_arg (args, int)); break; case 's': strvalue = va_arg (args, char *); if (max < 0) max = maxlen; /* ie, no max */ fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max); break; case 'p': strvalue = va_arg (args, void *); fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags); break; case 'n': if (cflags == DP_C_SHORT) { short int *num; num = va_arg (args, short int *); *num = currlen; } else if (cflags == DP_C_LONG) { long int *num; num = va_arg (args, long int *); *num = currlen; } else { int *num; num = va_arg (args, int *); *num = currlen; } break; case '%': dopr_outch (buffer, &currlen, maxlen, ch); break; case 'w': /* not supported yet, treat as next char */ ch = *format++; break; default: /* Unknown, skip */ break; } ch = *format++; state = DP_S_DEFAULT; flags = cflags = min = 0; max = -1; break; case DP_S_DONE: break; default: /* hmm? */ break; /* some picky compilers need this */ } } if (currlen < maxlen - 1) buffer[currlen] = '\0'; else buffer[maxlen - 1] = '\0'; } static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, int min, int max) { int padlen, strln; /* amount to pad */ int cnt = 0; if (value == 0) { value = ""; } for (strln = 0; value[strln]; ++strln); /* strlen */ padlen = min - strln; if (padlen < 0) padlen = 0; if (flags & DP_F_MINUS) padlen = -padlen; /* Left Justify */ while ((padlen > 0) && (cnt < max)) { dopr_outch (buffer, currlen, maxlen, ' '); --padlen; ++cnt; } while (*value && (cnt < max)) { dopr_outch (buffer, currlen, maxlen, *value++); ++cnt; } while ((padlen < 0) && (cnt < max)) { dopr_outch (buffer, currlen, maxlen, ' '); ++padlen; ++cnt; } } /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ static void fmtint (char *buffer, size_t *currlen, size_t maxlen, long value, int base, int min, int max, int flags) { int signvalue = 0; unsigned long uvalue; char convert[20]; int place = 0; int spadlen = 0; /* amount to space pad */ int zpadlen = 0; /* amount to zero pad */ int caps = 0; if (max < 0) max = 0; uvalue = value; if(!(flags & DP_F_UNSIGNED)) { if( value < 0 ) { signvalue = '-'; uvalue = -value; } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ signvalue = '+'; else if (flags & DP_F_SPACE) signvalue = ' '; } if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ do { convert[place++] = (caps? "0123456789ABCDEF":"0123456789abcdef") [uvalue % (unsigned)base ]; uvalue = (uvalue / (unsigned)base ); } while(uvalue && (place < 20)); if (place == 20) place--; convert[place] = 0; zpadlen = max - place; spadlen = min - MAX (max, place) - (signvalue ? 1 : 0); if (zpadlen < 0) zpadlen = 0; if (spadlen < 0) spadlen = 0; if (flags & DP_F_ZERO) { zpadlen = MAX(zpadlen, spadlen); spadlen = 0; } if (flags & DP_F_MINUS) spadlen = -spadlen; /* Left Justifty */ #ifdef DEBUG_SNPRINTF dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", zpadlen, spadlen, min, max, place)); #endif /* Spaces */ while (spadlen > 0) { dopr_outch (buffer, currlen, maxlen, ' '); --spadlen; } /* Sign */ if (signvalue) dopr_outch (buffer, currlen, maxlen, signvalue); /* Zeros */ if (zpadlen > 0) { while (zpadlen > 0) { dopr_outch (buffer, currlen, maxlen, '0'); --zpadlen; } } /* Digits */ while (place > 0) dopr_outch (buffer, currlen, maxlen, convert[--place]); /* Left Justified spaces */ while (spadlen < 0) { dopr_outch (buffer, currlen, maxlen, ' '); ++spadlen; } } static LDOUBLE abs_val (LDOUBLE value) { LDOUBLE result = value; if (value < 0) result = -value; return result; } static LDOUBLE pow10 (int exp) { LDOUBLE result = 1; while (exp) { result *= 10; exp--; } return result; } static long round (LDOUBLE value) { long intpart; intpart = value; value = value - intpart; if (value >= 0.5) intpart++; return intpart; } static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags) { int signvalue = 0; LDOUBLE ufvalue; char iconvert[20]; char fconvert[20]; int iplace = 0; int fplace = 0; int padlen = 0; /* amount to pad */ int zpadlen = 0; int caps = 0; long intpart; long fracpart; /* * AIX manpage says the default is 0, but Solaris says the default * is 6, and sprintf on AIX defaults to 6 */ if (max < 0) max = 6; ufvalue = abs_val (fvalue); if (fvalue < 0) signvalue = '-'; else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ signvalue = '+'; else if (flags & DP_F_SPACE) signvalue = ' '; #if 0 if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ #endif intpart = ufvalue; /* * Sorry, we only support 9 digits past the decimal because of our * conversion method */ if (max > 9) max = 9; /* We "cheat" by converting the fractional part to integer by * multiplying by a factor of 10 */ fracpart = round ((pow10 (max)) * (ufvalue - intpart)); if (fracpart >= pow10 (max)) { intpart++; fracpart -= pow10 (max); } #ifdef DEBUG_SNPRINTF dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart)); #endif /* Convert integer part */ do { iconvert[iplace++] = (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10]; intpart = (intpart / 10); } while(intpart && (iplace < 20)); if (iplace == 20) iplace--; iconvert[iplace] = 0; /* Convert fractional part */ do { fconvert[fplace++] = (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10]; fracpart = (fracpart / 10); } while(fracpart && (fplace < 20)); if (fplace == 20) fplace--; fconvert[fplace] = 0; /* -1 for decimal point, another -1 if we are printing a sign */ padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); zpadlen = max - fplace; if (zpadlen < 0) zpadlen = 0; if (padlen < 0) padlen = 0; if (flags & DP_F_MINUS) padlen = -padlen; /* Left Justifty */ if ((flags & DP_F_ZERO) && (padlen > 0)) { if (signvalue) { dopr_outch (buffer, currlen, maxlen, signvalue); --padlen; signvalue = 0; } while (padlen > 0) { dopr_outch (buffer, currlen, maxlen, '0'); --padlen; } } while (padlen > 0) { dopr_outch (buffer, currlen, maxlen, ' '); --padlen; } if (signvalue) dopr_outch (buffer, currlen, maxlen, signvalue); while (iplace > 0) dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]); /* * Decimal point. This should probably use locale to find the correct * char to print out. */ if (max > 0) { int i; dopr_outch (buffer, currlen, maxlen, '.'); /* print leading zeros of the fractional part */ for (i=0;i 0) dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]); } while (zpadlen > 0) { dopr_outch (buffer, currlen, maxlen, '0'); --zpadlen; } while (padlen < 0) { dopr_outch (buffer, currlen, maxlen, ' '); ++padlen; } } static void fmtfpg (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue, int min, int max, int flags) { size_t len = *currlen; size_t i; fmtfp(buffer, currlen, maxlen, fvalue, min, max, flags); /* remove ending 0 after '.' */ for(i=len;i<*currlen;++i) if (buffer[i] == '.') break; if (i<*currlen) { while (*currlen>0 && buffer[*currlen - 1]=='0') --*currlen; if (*currlen>0 && buffer[*currlen - 1]=='.') --*currlen; } } static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c) { if (*currlen < maxlen) buffer[(*currlen)++] = c; } #ifndef HAVE_VSNPRINTF int vsnprintf (char *str, size_t count, const char *fmt, va_list args) { str[0] = 0; dopr(str, count, fmt, args); return(strlen(str)); } #endif /* !HAVE_VSNPRINTF */ #ifndef HAVE_SNPRINTF /* VARARGS3 */ #ifdef HAVE_STDARGS int snprintf (char *str, size_t count, const char *fmt, ...) #else int snprintf (va_alist) va_dcl #endif { #ifndef HAVE_STDARGS char *str; size_t count; char *fmt; #endif VA_LOCAL_DECL; VA_START (fmt); VA_SHIFT (str, char *); VA_SHIFT (count, size_t ); VA_SHIFT (fmt, char *); (void) vsnprintf(str, count, fmt, ap); VA_END; return(strlen(str)); } #endif /* !HAVE_SNPRINTF */ #ifdef TEST_SNPRINTF #ifndef LONG_STRING #define LONG_STRING 1024 #endif int main (void) { char buf1[LONG_STRING]; char buf2[LONG_STRING]; char *fp_fmt[] = { "%-1.5f", "%1.5f", "%123.9f", "%10.5f", "% 10.5f", "%+22.9f", "%+4.9f", "%01.3f", "%4f", "%3.1f", "%3.2f", "%.0f", "%.1f", NULL }; double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, 0.9996, 1.996, 4.136, 1.05, 0}; char *int_fmt[] = { "%-1.5d", "%1.5d", "%123.9d", "%5.5d", "%10.5d", "% 10.5d", "%+22.33d", "%01.3d", "%4d", NULL }; long int_nums[] = { -1, 134, 91340, 341, 0203, 0}; int x, y; int fail = 0; int num = 0; printf ("Testing snprintf format codes against system sprintf...\n"); for (x = 0; fp_fmt[x] != NULL ; x++) for (y = 0; fp_nums[y] != 0 ; y++) { snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]); sprintf (buf2, fp_fmt[x], fp_nums[y]); if (strcmp (buf1, buf2)) { printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n", fp_fmt[x], buf1, buf2); fail++; } num++; } for (x = 0; int_fmt[x] != NULL ; x++) for (y = 0; int_nums[y] != 0 ; y++) { snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]); sprintf (buf2, int_fmt[x], int_nums[y]); if (strcmp (buf1, buf2)) { printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n", int_fmt[x], buf1, buf2); fail++; } num++; } printf ("%d tests failed out of %d.\n", fail, num); } #endif /* SNPRINTF_TEST */ #endif /* !HAVE_SNPRINTF */ advancecomp-1.23/test/000077500000000000000000000000001301462770100146775ustar00rootroot00000000000000advancecomp-1.23/test/archive.zip000066400000000000000000022774271301462770100170710ustar00rootroot00000000000000PK 1LwBc ì ì felicegimondi.jpgÿØÿàJFIFHHÿáÄExifMM*bj(1r2‡i¤ÐHHAdobe Photoshop CS Windows2008:04:21 08:18:41 ÿÿ R  &(.ŽHHÿØÿàJFIFHHÿí Adobe_CMÿîAdobed€ÿÛ„            ÿÀN "ÿÝ ÿÄ?   3!1AQa"q2‘¡±B#$RÁb34r‚ÑC%’Sðáñcs5¢²ƒ&D“TdE£t6ÒUâeò³„ÃÓuãóF'”¤…´•ÄÔäô¥µÅÕåõVfv†–¦¶ÆÖæö7GWgw‡—§·Ç×ç÷5!1AQaq"2‘¡±B#ÁRÑð3$bár‚’CScs4ñ%¢²ƒ&5ÂÒD“T£dEU6teâò³„ÃÓuãóF”¤…´•ÄÔäô¥µÅÕåõVfv†–¦¶ÆÖæö'7GWgw‡—§·ÇÿÚ ?â1…€49Ü :‰=–®#íÆuµ×cÃIk‹\ÝHÚâç-gcµö][éé{@$€¨àÍG¿k}ËYõZSÃèk@‚âNÓî«ó¶7jaK/sÜí­cI#p#nïÞõ&Zrk>£w<©¥Û ¿ú5=6ÛH,- ‰™Ýßý´z}*?JD×i‡¸jtI×%%9v°1æºXw¸íh „GÒþ®ç'¥û?Fç›C‡¡Þí?•Oî*C%­ÈqÇ.­ÌöïÞZuÚý¾êß¹f¶ÆzFÍ–ƒ£‹fIöû¾—ÑjF6]<'²nªØ&ÃéAŸ§K_ó“iUåõÔ+uD¶?5Ç÷¿³ü¶ÿ×?ÁªŒ¹÷º­–n°XÆ—FÖþ÷ç=öûÞãÉtó»ù·ní¿ÕM×^£Tl5ØùNÚÃ둽¤nÓRÑù®ÝµR­•9Îl¼I-²×”ÊòÚúš@’×6Ɉs¦Æ£ý§~ÔXæXLí݈Ж¶7noÓzp¸š£Ek9˜Ñ{ßk¶ŸˆŸÍ×fÅv«(~1²Ãé‡84H†îÍ·wæþï±c2ã“o§aÛYv÷ÒǶ?­_y¬¶—û[Q>Òyk?«c¾Ÿók'«REþ»I²·’Ù$;kÆ×mýæµÕ½žßøÄA³J¦v?eînèêÖΦ}§Ø¨f¾m¯½æ&L‰Ü7VØoï8­á½–]è—¹¶4H"G‰‡{6 õJªûc]i!Î,€ÈiG¦ö–¾ýÎú?ͨ¤@Ÿ…©ÿÐâhkÛSlkÒçl‰—¸¸“gàýŸÛ[ ¦ªœÖ_Y­–ÒÝ´û¾žÅ”v·#pq`kžç%ºr×–íÿFö³Þ¯>ÒËZÖƒSí–´8i1fýÍö³é~raÝ+çÔklÒÿZ›[HzлÛùkÁس©ÊËqf8w¡C½Û„:ÏÝÝdzúµ-.¡{lŤµiÞ,eGÛ·O{y¾æª·Rúì{Pcøà8û½ßI¦«±Çß\ni!ý pÞAéøî9m¬× 4̘k¿ïªû…¯›ÈÞÆ;AïÛµ§Ú=»¶ÿäÕL&¼=î}ø<’w[óR~Kk¦¢Ñ¡!î:$9Û¿èª×ç8‹½A¸ZíÀðN¿÷åwxÚÂ8“ð¾Å„Kí,hN5BFäûÚ÷A!Í6Ój“Ÿ¾ã]2æ¹ûkgr'ôaZoD-sE÷CLÑ´‘ú>ãôwUkQ‡‰„Óf#wh7—jèJèúH€4×òU“ú8¡Õ\,µƒôÍ ¡¥ûí÷~z¬ÛûÜy­‘n+ÁØd rÙýíß½ùË;2¡»VÁ>æøG’Q•Q²=¶ÚöVÁ6>IÑ«¢é3‡?u®9N1àÖ·Is'wÒúû¿ôbÆéÎû5†÷€ç´m¯qÚˆ;½Ãw¿oµ«Y™v>›¯cÉo¶&&?›,Ÿú…S"xFƒö¨öEm™Xy¦«®-ktsš GµÛü•¯ÒïDzÇØȶÀÐYE®hÖñùÛ·ý{èer+t2Ù{AÕÍôÚÛ\¬[—…Kjn=,¬ºYe l íÜâï£c}Þƃb’7Â/zÕ,ò.sîÜ\K~‹œx†Éó•l¡]øÛ ;÷Ó¬#‘?KbŽNV-lÜ^Ò"CõZѹö¥•n.Õ¤î`}²»¿ç9Ô[:4dúu´¹ÖÁ$ÃâZæzl–ÿSz©Õlq4zŽ–×¼¿R#] š¬cÞ K˜Ö½Äp÷9£Ä:ïjÎÍéù™Y.ÈûC"×9» kš?4qûŠ^í+¿òô _ÿÑãw›2[XÇ‘`aÕ­Ü}ÍfßÒ¿m¯sÿ­Ôú,©ï¡ÖZhsÈ.í}{¿œvßrŸMÅƾÚè°°meƒÒtíGŸoèÿêr™VN+ªg­ê0±Ä²6Ëvû¾Ÿ½®Ù_ÓL]TÙäWê¼´Öç°U§v3Üçnü×þg½/cŸXØâêÏ¥dHl;Û±ßú³ûÏ}¡Áºå3o«ŒZÝ®-eVãÙë7;mßÍ×Çt†¶ÀÚ¯àÝs˜,w°±ô{òYul6¾¦VÏSзôž¢u*‰Ø9µÑs±\íõ’ǸIݺÓF²] Ö65»GÒŽÞÃèmj·{hÆ÷Ñ®>U,¾†<—š··SköÒÛ-Ç{?œc}?Ó«NéÖet¶u KNCK]ì­{Çþ–»[ê;Õô¥¶þôé»Ô¹*üG³ŒÐáue…²Ü™=¿wkVgJ¤ØëÏhnž~â´Üÿç÷NøþŒhÓ¶ç±Ûî«©ôѺgC¬P2†Oê­‡æe1Ž>ƒKFÏÐí~VE6ng©}4~‹þ/ô‰t!TP×hô˜k@†@'lµ°ëmgø*Uz âÐ)¤°ºCG¸É×k¶Ÿ¡ýF­OÙg3ì9—Yö–†”†·ps÷3Ò²ãµÛ©ô®«'Õ§×õ}/ûGz²:VMvßVcZ(cí59àºÓN÷ÞÊëk\Öoö[Š÷9ÿ¡é?IU©U&Žî-fÇÚ,#p¤5ÇËùÆ~c‘ìi©K\L6Ép¯óý´l\ ¦ãä¶ï³3,PÈÞÙ¶¯B×;cÿEöç˜Û=OZš¶;j+ñê鱑é>ûq_ôƒÛemŽuv6·1®m¬²ªýK.ÿKïö%ÒÐFþ ,¶>êëÒ m3,á¡¿¿û«g¦6Úf5­cšÁ×xt88nk«º¿§³Ü¨°uû«Åkòv½–0Xöµì fÝÞ›ìôþ’¾Ç›E¹ÎÚ÷5ƒ6µ¯¥s^âíÛ?Áþþ“Õ|¶tÒ†º|È$èÃ2ŠjöW¸cïÝ©pÖ­Â3ù¿üPê6Ýq{íææ#oÒýÕ½Ùlm42¦º›G¢ûZ&Æ–‰¯ú»Úßç™úOÌeˆâàåŸTo¦Ó±¡­÷nôFÍÖ7ý#>ŸúSÕRc˜á“u­„˜šyÚöíp iÁî %ܤþëZ¶ªèt:vä[µÚH ‘¬ïŽÜ£Oª’};`#KßMŸºîÖ»ù÷'Ë$@Ýir류îmÖ¸‡A€ÑÄüýßõ WdºÚ½ÐÂѵ®oÒ3®÷;ùÎßú4l­”3s¸¸ím`46@÷—¹ÄÜúôYô¼¹Ï2“.Ñßkô·;oùŠ/œÙP©ÿÒÄéí»§äãf_]®ÆkŸ[MÍcw;Ü×ÜßR¿SØí—WüÝž§ü†~‹›\ûëûkem&w²šÞú½:¶ý •ÿÔ-1Ñj³µ~еÃtŸMÒàï¢ÇËÙ쥇c=ÈÞŽ5@ïÌÈkªhsj†ŸSºïoµß¥ÿIZm€ê ;9c'/×s˜×µa}vlÕ®¯a ³ÜÖ~…¯ö†ôÿœVªiÅ9õUŽÆßcÆ<Ù²¶[nÖ5¾¯Ú^ÿAßi~Gý§ôÿšõžê:~y70Ú÷í±¡í Ѥíö7{™¿ßùÿADôüØÍÕ±þ“\[éìo Û÷1îþmÎýÐ@J&ëÉ"RîÉ®Ê.¢c~+¦«€²NfÜoI¸ŒnìjÿÃ;ô÷ÿ6›ß]‘öL2çß›ãcmôýk_½»¨Çôý¾¥¯ôÿànÅ¥ùBáU„ímmk^Æ £ßµþ•ÝúF;sÝnÿÒ£ôÔk«‹Æp 6÷Y½­}…í“ô+†{}ÿA!ãþú½C®í~™‹C^ÖˆÚÂÒÖ5ÌtúÏ ¾ß¥ú6Y·Ñÿ‡ÒßUµÃëhã}œ9ƳU õcle¾ëjþy–U¿góµÿ…6E¸Ì²ì§ã1ÖÚÇ‹Ý¿{½{½»öÿ-¾šˆÎƆYˆÚªcÀô¡°Ý6´G·fßýH£žQ%i‘êÊÓ]8q$bVEGl¿aûC›meÇݲܷûßìÿD„hé-Èw£ìÈ¡•èѽ²Ö¹§s¬ß±ÿ¥ÿÌì<º÷šë`°¸úôÄ8†íóý'±ÿàÿÁ¨À¯x,ôÝ·±=?ÝÝ_³ô_ñh Ð:ð›*‘šCMxBš²Yc·TÍ̆‡<:Ƴc?Gm£ýüóv)Qv=˜xÃßö}>˜'xwӾï¿Ö²«¿KþÄØùÞ¥gìÂãé8µÌa : Þß¡¹Ë/¡ìnC-¤@Îy‰#Øvû[îþJ“Žµ¤˜ßV`Sa/pÓ—8ˆpCüoænj{¯hc*šÝ.u;X-qDÙúW{vìþe^Ç£3 Ç;!õfÔé{Ÿî,#óZí­íoÐÝêÆ,ΧëÑc*µÍs$»kÀö:gÜÖ}:ölö&È›„UPDGDç6úÀ6š]S®p—I-w®X÷Y_¹ý¤Æz_è“ÿÎLö9Öâ¾¾dH;m —iÜÖú~¦ÆÀzU¬Úí ©ÞßMÓ¾—{dûµs}ÿºƒ‹‘Œ:ŽèÞ@~Ñ tÁº#w´¤‡[\±OVÍ°0?*ÚÈkD´43c·ÿšcÖÔçZKh¿cˆcƒ„‘ù‡ûMYö’ –Øæ‡zoÖ}ÞÝ®kK~Š®oµØoO¬ÍÃOÌxþ§ò“gŠõßÏ¢$,5ºæk,Ê4>;  Û®ï¥ü¯b«…S½"\ý•’Ë 8’uØÝîo»ùNAwØéfçØ}Êæ66ËæËM¯a¯µÇé{¶¶­ÿûûÓôŒhlÿÓË«®dÙ_±¯±ßq/Úæ³ówmúJ6uL†TXõ\ÐÝHÞcK'úÑôÖ[ýMÎû €Æ’GÏþ Kõ¶°}«ßWø9ì-;›÷zmþJ¬Aè£mžŸ”ê=wìÛík‹f{ÿÔþr==FçS`i-ô‹t8¿›¹žß¡µgâxph–ûŽšô$~ûÁ«@RöQmGg.÷7û#éú¿Êoù‰GÃùÄx¶({Þ>ÏEûìn¯®ÇOç»sµ¿œ†âç49ÎatüµÃ³¹Û±VÚE›Z7;M®løûsþ¥\Êqö:æ˜ôÇ´Çø_LîB¤wÓ²íÐê˜ZZâÀIq<C·ïþ§±>Cko§滑ܗiÿªx¯°¿ô,³ãä!ÞãÿVÅp»s+!Þ}6´ËëSù›¿u@ƒfWÞÕC»ÕU^“›Li£A-$NÇ}Ùþb4\ê ]d“ï/-‰;.c7~‘ªU\@0Ö¹Û ‡/Òigçÿ£Ø Âè¨k§°ÿß·góÓ€Y£&d¶»CÜ«ÚËLzqí§ivïk¶·Óÿ®u&ÑoOmvZϵÒÒêØ]ô?¬c¹¯ ÜË6ÿƒgèÿÁ,K>Óe¶Yiaô½: Àt‚µŸŸôþ‡³ý"ÐëaìÇkº‹›l–vñh ÜÆz;þ“žô¬þÞôáU¢šøv=„úìŠò"5kÈkšêšïÒU¦ÏMèýO'©_fü›Ùé†6½²Ö¹›˜Æ6Ý^íÎX²ë}Ê,ª²þÞ 'Ït?kÿÎZV?0a¸Ù[M@7pt ?˜µÿæ{‘×è‡1¸yMµ¶ûš!Õ´C?­Ïç~îä h}̽5È'é5Í“ºUÜ–Òq·Ô烵¤ÕæG½»ã÷–U[½¡°Z@‡7§î§7²©±¬m•˜p±Ì$ƒ¦îÿEÊTfTðÏ´û¸~­×ÉÃ÷–{R ;ê <ÄŸkvír(Æ—û¤ºZØ€Ò×ù.IIòÞXç?{ŽéѾ¥—3ØïoïªOÈ¥ŒÜ-;ÚßÒ´wnÚÝíþG¨‰`´VðÒKw¸È1û¼˜¡8{_êz’ ž=Ÿð‰¦_ÿÙÿívPhotoshop 3.08BIM%8BIMíHH8BIM&?€8BIM 8BIM8BIMó 8BIM 8BIM' 8BIMõH/fflff/ff¡™š2Z5-8BIMøpÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿè8BIM@@8BIM8BIMQ Rfelice-gimondiR nullboundsObjcRct1Top longLeftlongBtomlong RghtlongRslicesVlLsObjcslicesliceIDlonggroupIDlongoriginenum ESliceOrigin autoGeneratedTypeenum ESliceTypeImg boundsObjcRct1Top longLeftlongBtomlong RghtlongRurlTEXTnullTEXTMsgeTEXTaltTagTEXTcellTextIsHTMLboolcellTextTEXT horzAlignenumESliceHorzAligndefault vertAlignenumESliceVertAligndefault bgColorTypeenumESliceBGColorTypeNone topOutsetlong leftOutsetlong bottomOutsetlong rightOutsetlong8BIM( ?ð8BIM8BIM8BIM ª Nà’@ŽÿØÿàJFIFHHÿí Adobe_CMÿîAdobed€ÿÛ„            ÿÀN "ÿÝ ÿÄ?   3!1AQa"q2‘¡±B#$RÁb34r‚ÑC%’Sðáñcs5¢²ƒ&D“TdE£t6ÒUâeò³„ÃÓuãóF'”¤…´•ÄÔäô¥µÅÕåõVfv†–¦¶ÆÖæö7GWgw‡—§·Ç×ç÷5!1AQaq"2‘¡±B#ÁRÑð3$bár‚’CScs4ñ%¢²ƒ&5ÂÒD“T£dEU6teâò³„ÃÓuãóF”¤…´•ÄÔäô¥µÅÕåõVfv†–¦¶ÆÖæö'7GWgw‡—§·ÇÿÚ ?â1…€49Ü :‰=–®#íÆuµ×cÃIk‹\ÝHÚâç-gcµö][éé{@$€¨àÍG¿k}ËYõZSÃèk@‚âNÓî«ó¶7jaK/sÜí­cI#p#nïÞõ&Zrk>£w<©¥Û ¿ú5=6ÛH,- ‰™Ýßý´z}*?JD×i‡¸jtI×%%9v°1æºXw¸íh „GÒþ®ç'¥û?Fç›C‡¡Þí?•Oî*C%­ÈqÇ.­ÌöïÞZuÚý¾êß¹f¶ÆzFÍ–ƒ£‹fIöû¾—ÑjF6]<'²nªØ&ÃéAŸ§K_ó“iUåõÔ+uD¶?5Ç÷¿³ü¶ÿ×?ÁªŒ¹÷º­–n°XÆ—FÖþ÷ç=öûÞãÉtó»ù·ní¿ÕM×^£Tl5ØùNÚÃ둽¤nÓRÑù®ÝµR­•9Îl¼I-²×”ÊòÚúš@’×6Ɉs¦Æ£ý§~ÔXæXLí݈Ж¶7noÓzp¸š£Ek9˜Ñ{ßk¶ŸˆŸÍ×fÅv«(~1²Ãé‡84H†îÍ·wæþï±c2ã“o§aÛYv÷ÒǶ?­_y¬¶—û[Q>Òyk?«c¾Ÿók'«REþ»I²·’Ù$;kÆ×mýæµÕ½žßøÄA³J¦v?eînèêÖΦ}§Ø¨f¾m¯½æ&L‰Ü7VØoï8­á½–]è—¹¶4H"G‰‡{6 õJªûc]i!Î,€ÈiG¦ö–¾ýÎú?ͨ¤@Ÿ…©ÿÐâhkÛSlkÒçl‰—¸¸“gàýŸÛ[ ¦ªœÖ_Y­–ÒÝ´û¾žÅ”v·#pq`kžç%ºr×–íÿFö³Þ¯>ÒËZÖƒSí–´8i1fýÍö³é~raÝ+çÔklÒÿZ›[HzлÛùkÁس©ÊËqf8w¡C½Û„:ÏÝÝdzúµ-.¡{lŤµiÞ,eGÛ·O{y¾æª·Rúì{Pcøà8û½ßI¦«±Çß\ni!ý pÞAéøî9m¬× 4̘k¿ïªû…¯›ÈÞÆ;AïÛµ§Ú=»¶ÿäÕL&¼=î}ø<’w[óR~Kk¦¢Ñ¡!î:$9Û¿èª×ç8‹½A¸ZíÀðN¿÷åwxÚÂ8“ð¾Å„Kí,hN5BFäûÚ÷A!Í6Ój“Ÿ¾ã]2æ¹ûkgr'ôaZoD-sE÷CLÑ´‘ú>ãôwUkQ‡‰„Óf#wh7—jèJèúH€4×òU“ú8¡Õ\,µƒôÍ ¡¥ûí÷~z¬ÛûÜy­‘n+ÁØd rÙýíß½ùË;2¡»VÁ>æøG’Q•Q²=¶ÚöVÁ6>IÑ«¢é3‡?u®9N1àÖ·Is'wÒúû¿ôbÆéÎû5†÷€ç´m¯qÚˆ;½Ãw¿oµ«Y™v>›¯cÉo¶&&?›,Ÿú…S"xFƒö¨öEm™Xy¦«®-ktsš GµÛü•¯ÒïDzÇØȶÀÐYE®hÖñùÛ·ý{èer+t2Ù{AÕÍôÚÛ\¬[—…Kjn=,¬ºYe l íÜâï£c}Þƃb’7Â/zÕ,ò.sîÜ\K~‹œx†Éó•l¡]øÛ ;÷Ó¬#‘?KbŽNV-lÜ^Ò"CõZѹö¥•n.Õ¤î`}²»¿ç9Ô[:4dúu´¹ÖÁ$ÃâZæzl–ÿSz©Õlq4zŽ–×¼¿R#] š¬cÞ K˜Ö½Äp÷9£Ä:ïjÎÍéù™Y.ÈûC"×9» kš?4qûŠ^í+¿òô _ÿÑãw›2[XÇ‘`aÕ­Ü}ÍfßÒ¿m¯sÿ­Ôú,©ï¡ÖZhsÈ.í}{¿œvßrŸMÅƾÚè°°meƒÒtíGŸoèÿêr™VN+ªg­ê0±Ä²6Ëvû¾Ÿ½®Ù_ÓL]TÙäWê¼´Öç°U§v3Üçnü×þg½/cŸXØâêÏ¥dHl;Û±ßú³ûÏ}¡Áºå3o«ŒZÝ®-eVãÙë7;mßÍ×Çt†¶ÀÚ¯àÝs˜,w°±ô{òYul6¾¦VÏSзôž¢u*‰Ø9µÑs±\íõ’ǸIݺÓF²] Ö65»GÒŽÞÃèmj·{hÆ÷Ñ®>U,¾†<—š··SköÒÛ-Ç{?œc}?Ó«NéÖet¶u KNCK]ì­{Çþ–»[ê;Õô¥¶þôé»Ô¹*üG³ŒÐáue…²Ü™=¿wkVgJ¤ØëÏhnž~â´Üÿç÷NøþŒhÓ¶ç±Ûî«©ôѺgC¬P2†Oê­‡æe1Ž>ƒKFÏÐí~VE6ng©}4~‹þ/ô‰t!TP×hô˜k@†@'lµ°ëmgø*Uz âÐ)¤°ºCG¸É×k¶Ÿ¡ýF­OÙg3ì9—Yö–†”†·ps÷3Ò²ãµÛ©ô®«'Õ§×õ}/ûGz²:VMvßVcZ(cí59àºÓN÷ÞÊëk\Öoö[Š÷9ÿ¡é?IU©U&Žî-fÇÚ,#p¤5ÇËùÆ~c‘ìi©K\L6Ép¯óý´l\ ¦ãä¶ï³3,PÈÞÙ¶¯B×;cÿEöç˜Û=OZš¶;j+ñê鱑é>ûq_ôƒÛemŽuv6·1®m¬²ªýK.ÿKïö%ÒÐFþ ,¶>êëÒ m3,á¡¿¿û«g¦6Úf5­cšÁ×xt88nk«º¿§³Ü¨°uû«Åkòv½–0Xöµì fÝÞ›ìôþ’¾Ç›E¹ÎÚ÷5ƒ6µ¯¥s^âíÛ?Áþþ“Õ|¶tÒ†º|È$èÃ2ŠjöW¸cïÝ©pÖ­Â3ù¿üPê6Ýq{íææ#oÒýÕ½Ùlm42¦º›G¢ûZ&Æ–‰¯ú»Úßç™úOÌeˆâàåŸTo¦Ó±¡­÷nôFÍÖ7ý#>ŸúSÕRc˜á“u­„˜šyÚöíp iÁî %ܤþëZ¶ªèt:vä[µÚH ‘¬ïŽÜ£Oª’};`#KßMŸºîÖ»ù÷'Ë$@Ýir류îmÖ¸‡A€ÑÄüýßõ WdºÚ½ÐÂѵ®oÒ3®÷;ùÎßú4l­”3s¸¸ím`46@÷—¹ÄÜúôYô¼¹Ï2“.Ñßkô·;oùŠ/œÙP©ÿÒÄéí»§äãf_]®ÆkŸ[MÍcw;Ü×ÜßR¿SØí—WüÝž§ü†~‹›\ûëûkem&w²šÞú½:¶ý •ÿÔ-1Ñj³µ~еÃtŸMÒàï¢ÇËÙ쥇c=ÈÞŽ5@ïÌÈkªhsj†ŸSºïoµß¥ÿIZm€ê ;9c'/×s˜×µa}vlÕ®¯a ³ÜÖ~…¯ö†ôÿœVªiÅ9õUŽÆßcÆ<Ù²¶[nÖ5¾¯Ú^ÿAßi~Gý§ôÿšõžê:~y70Ú÷í±¡í Ѥíö7{™¿ßùÿADôüØÍÕ±þ“\[éìo Û÷1îþmÎýÐ@J&ëÉ"RîÉ®Ê.¢c~+¦«€²NfÜoI¸ŒnìjÿÃ;ô÷ÿ6›ß]‘öL2çß›ãcmôýk_½»¨Çôý¾¥¯ôÿànÅ¥ùBáU„ímmk^Æ £ßµþ•ÝúF;sÝnÿÒ£ôÔk«‹Æp 6÷Y½­}…í“ô+†{}ÿA!ãþú½C®í~™‹C^ÖˆÚÂÒÖ5ÌtúÏ ¾ß¥ú6Y·Ñÿ‡ÒßUµÃëhã}œ9ƳU õcle¾ëjþy–U¿góµÿ…6E¸Ì²ì§ã1ÖÚÇ‹Ý¿{½{½»öÿ-¾šˆÎƆYˆÚªcÀô¡°Ý6´G·fßýH£žQ%i‘êÊÓ]8q$bVEGl¿aûC›meÇݲܷûßìÿD„hé-Èw£ìÈ¡•èѽ²Ö¹§s¬ß±ÿ¥ÿÌì<º÷šë`°¸úôÄ8†íóý'±ÿàÿÁ¨À¯x,ôÝ·±=?ÝÝ_³ô_ñh Ð:ð›*‘šCMxBš²Yc·TÍ̆‡<:Ƴc?Gm£ýüóv)Qv=˜xÃßö}>˜'xwӾï¿Ö²«¿KþÄØùÞ¥gìÂãé8µÌa : Þß¡¹Ë/¡ìnC-¤@Îy‰#Øvû[îþJ“Žµ¤˜ßV`Sa/pÓ—8ˆpCüoænj{¯hc*šÝ.u;X-qDÙúW{vìþe^Ç£3 Ç;!õfÔé{Ÿî,#óZí­íoÐÝêÆ,ΧëÑc*µÍs$»kÀö:gÜÖ}:ölö&È›„UPDGDç6úÀ6š]S®p—I-w®X÷Y_¹ý¤Æz_è“ÿÎLö9Öâ¾¾dH;m —iÜÖú~¦ÆÀzU¬Úí ©ÞßMÓ¾—{dûµs}ÿºƒ‹‘Œ:ŽèÞ@~Ñ tÁº#w´¤‡[\±OVÍ°0?*ÚÈkD´43c·ÿšcÖÔçZKh¿cˆcƒ„‘ù‡ûMYö’ –Øæ‡zoÖ}ÞÝ®kK~Š®oµØoO¬ÍÃOÌxþ§ò“gŠõßÏ¢$,5ºæk,Ê4>;  Û®ï¥ü¯b«…S½"\ý•’Ë 8’uØÝîo»ùNAwØéfçØ}Êæ66ËæËM¯a¯µÇé{¶¶­ÿûûÓôŒhlÿÓË«®dÙ_±¯±ßq/Úæ³ówmúJ6uL†TXõ\ÐÝHÞcK'úÑôÖ[ýMÎû €Æ’GÏþ Kõ¶°}«ßWø9ì-;›÷zmþJ¬Aè£mžŸ”ê=wìÛík‹f{ÿÔþr==FçS`i-ô‹t8¿›¹žß¡µgâxph–ûŽšô$~ûÁ«@RöQmGg.÷7û#éú¿Êoù‰GÃùÄx¶({Þ>ÏEûìn¯®ÇOç»sµ¿œ†âç49ÎatüµÃ³¹Û±VÚE›Z7;M®løûsþ¥\Êqö:æ˜ôÇ´Çø_LîB¤wÓ²íÐê˜ZZâÀIq<C·ïþ§±>Cko§滑ܗiÿªx¯°¿ô,³ãä!ÞãÿVÅp»s+!Þ}6´ËëSù›¿u@ƒfWÞÕC»ÕU^“›Li£A-$NÇ}Ùþb4\ê ]d“ï/-‰;.c7~‘ªU\@0Ö¹Û ‡/Òigçÿ£Ø Âè¨k§°ÿß·góÓ€Y£&d¶»CÜ«ÚËLzqí§ivïk¶·Óÿ®u&ÑoOmvZϵÒÒêØ]ô?¬c¹¯ ÜË6ÿƒgèÿÁ,K>Óe¶Yiaô½: Àt‚µŸŸôþ‡³ý"ÐëaìÇkº‹›l–vñh ÜÆz;þ“žô¬þÞôáU¢šøv=„úìŠò"5kÈkšêšïÒU¦ÏMèýO'©_fü›Ùé†6½²Ö¹›˜Æ6Ý^íÎX²ë}Ê,ª²þÞ 'Ït?kÿÎZV?0a¸Ù[M@7pt ?˜µÿæ{‘×è‡1¸yMµ¶ûš!Õ´C?­Ïç~îä h}̽5È'é5Í“ºUÜ–Òq·Ô烵¤ÕæG½»ã÷–U[½¡°Z@‡7§î§7²©±¬m•˜p±Ì$ƒ¦îÿEÊTfTðÏ´û¸~­×ÉÃ÷–{R ;ê <ÄŸkvír(Æ—û¤ºZØ€Ò×ù.IIòÞXç?{ŽéѾ¥—3ØïoïªOÈ¥ŒÜ-;ÚßÒ´wnÚÝíþG¨‰`´VðÒKw¸È1û¼˜¡8{_êz’ ž=Ÿð‰¦_ÿÙ8BIM!SAdobe PhotoshopAdobe Photoshop CS8BIMÿáhttp://ns.adobe.com/xap/1.0/ 4294967295 850 416 1 72/1 72/1 2 2008-04-21T07:16:51+02:00 2008-04-21T08:18:41+02:00 2008-04-21T08:18:41+02:00 Adobe Photoshop CS Windows adobe:docid:photoshop:301a3648-0f62-11dd-bee5-9621e35f8936 image/jpeg ÿî!AdobedÿÛ„         ÿ RÿÄÕ!1 A"#2$0B3%&!1AQa"q2BR#‘¡b3±ÁrÑ‚ðáñ’¢C$²S4ÂÒ%5âcT6! 0@1PA`Qa"2qBRbpr’ÿÚ ø6vRD$”ªúc!̯¤8N´0Hm)MŒ)–N±(’Ÿ5—mpωqšõ*fô|äg:kAh ¥Ubó Òå Q˜í -3`yÂÝsÐ&éÏ3ÛmP PÌó›ÓŒÕ⩯&3çNyÌDý¬Öˆ†¬ç;¡Â—G'|›e˵TR*,%›…&ÉmÌåAô¤‡¤1r¹Í%s¤Î:ëS W*£I@º@Äç ƒ¾‰—6ž™NµÑwAMÎgG|†¤áP”¢™fÄ謡·²¼ iÀ”xÊœôËx_j *A)¬g‘QSÈIoC…D—X%ûRÍ@g6Y›^I¯D®²J½mnÕ¦óôŽ¬ªÎÌfZgžéÑgC›kìe ‰Ä&Ê)(û Nåšn+égS£45ƒè9ÍSª©¢ "–……L)™@¢†íÖ² ¼„¦K—pÀge:ÈIL4-ÐÓC/R¤hª¡,º?’ÐÅ|Ô¿[½‹ô3ZLôZщ»É,Ò¹2Ô«XCr „(TcI:ÐJ⚘*^‹ÐöÁSH8æuÕ³Íu5€Ë%ªæ£fé¬Å WRzqÑãc?˜Â%~Ï#ÙeY$B.ê”M±™(ª„D×y¦š|ÏF}MWE ®’©=«©Ii:rE¬,*5E8A Zò4ʘ©ƒªï&Ùë ‰‰ÑR" å*¡€ô™ÒkCËE¢ ÍÝ[Ò3‰‡¾—FIútËh1—*/Âo•UÔŽ!T’9PpïHÚžR‚°I "«¸‹4ÐÓg«4‘Üi9Z­’Ö“\õoŒyeúíicÒ‰'Cߢäèß<¯S—Kg v ÉC<¹rçe ˆRrZÕZ ­)jh6+É¡´Ò_E`‚eḖѦ?h&öÒ³Šï¨ª¢Œ¹ XÒû­T+ZK7È͆¡tC6´I#FaMJmÚ Ý"ˆ­AüÒšmN„ÖskÚ׆LRu–Ä `9ƒ¶JA¶3B1 ©4ƒPÑt‘ 0&"ÓHcjD³y«äÎÑm0bí =i¹óÅ÷ÃŽ±7KiP8ÒöKIÊ6Ï,ß}"ÝØ"Õ½‚Š¶ ©KS¥æ­ 6XM[Rýås¶#FãΈY àlR:‹†µ³œý <†è³Ön5èª(d,Ó6=´ùÔ‡ÒU #¢OA –™²s*²UByÇBÒ[//×Ujèrt´:©µ)d¢ÅLð¾9*¤1º ) \¨c%iéÍ5C°“2L5,TÊÙ˜Í;˜Vtßž¦šf¬þ}4Ù>¼m›hÛ+н ®k‡­ãeÆv¹ÉöÕUàÝ:؆¢5]I`¾…ËlÔЊ¶²À!æõŽMJ¡\;ä6²ÂrB ¾ŸåNë%˜õ’÷v3j5® ÏQÉY5ÌPh -ox-«à¤;@¹sÎîz‡œ4Û…g:WÌýk¹ŒñòFCѾ(›ŒVÖoe⇌ØÏ}hgZ’R*b0BTÁÓilÔ«br’§š´DË7KÊÓ¹_iĺÓ|§9¬ÝŽÚ æ{%W- ®Î!¤ ÊtN›GÜï–t!t¦’b{-uM!‹•¨Š, ™á!D3Öª(Pž‚è®VtÕdÅÎ<¾«æ«;^k½¯uÖhtF$6t3¨©ª—3ÒpÜ|Ú󶪔ä"f‰É‘šeÅ0“®ÔtMS˜ÎÇj³=[°—6-kC™§·o™±ái4‰Õ&£ jE´lR±Š›ÐÊ×ϬT• Ò(R¹;ÄÖm‡S!©²zKÎzjuÔ>–5®M L¬«?¬_ ¶B³6 õKuîèdÑê³-tD:Z™RDp¾…Mx$Ey–$ç}CË‚\—m©§™^¹Ü6M4r ŠÏQNZLÑvˆ"V<òZ’nÐô¶xº×xÒ¼›b“ô¥”ÐìÜsæuÖÑÒ%p›Pû6Üm¹'j‘SGˆv†m`0¡œ®2t‚Jôó–è“7G“Xæ I:XH†2qSk(JZ| iöÒ˜Hö+@Mæ Ž6ªv‡²Vw4ƒVºÔ©äUƒm m”¢š ©$Rº©Ö ŠõVK®Ö›)kœ¬t:ØÙÜËNt¥ÓH£…™jüõ*Y¦BhŒoçzb5UÌœ ^Ç|f§ÄQI?Dãû¶…«Ršn« ¦r]&ÿ:ÉPÅ ˜6ò&a)zîR;4@â’òRzy*Ǥ­•µt M”µV®OR uO¢[ó˜ŽædQÔ)r+œ™4Msª‰(®9MªÆ56&l³Ó5]¤øs—X^ƨLäqù83­ù+hl¹sSÐ9†Ê»!/M)µ2§¦sI¾ZÓKFœ+²×jšbÆc–x”.Š '´ï Øy3ÌY|ê–c±åýîh¹¬v±l6ÊJ¡“’6Ñ5Km’‚™›¬/ Ú‹ awª¤½ŠF…Š™JM¦ä,ƈ¹˜7jIhZ-N¹–z–¼úäzd‹“†¤FXRªƒâÁiì5Ô«Jb™"]PÔBô^Yò\‰…ÅIÄÄjÆVOÁ0Ûù™?]è êÁÚw‘á¯Û2Êy…4§kCá%pŠ tIµÍŠ!4—4÷+sæË=¥Y0›¤ÁúûÞ?v³w5Ê}ƒÜé¤ém·7<©©š90ÖÆâo§–³Ð6hi;žÊ)Rö¯‘äSLæ)õ…¡²mÄÒÐC&‘RÍ$hÑDto’ÏT‚:Gç$&®§a©ÐÍAC JBV„ÚèÎOÓvŠÄü²i\Pµ›©Ï[¹=_Rà”o=ÓCëbÔÐÃfÛKÔÊC¬6Ðò¤Ô”Z^gK@ü.íQ)“"ñeºsÑÐÉåOü¹fË„Îw2²œ÷CÌz;±‰f]Ç-cxço¤o£%«m-±Ä󻤙ÅÚTu™ëÊ}™¥…c¤V¨Iœ°ØB¹«¢ÒÀc¥x‰9¥Sw ä´›PÉ´«ÂÒƒjBÒg~fz¦À‘2Œšû&5™©Ìܯ§pìDÙ&ßBÙ¯@v¦^HiξçLʆï+Ò²žƒC¬Ðg£O*dêЂ¨°%ƒ.ö’Û;ôVc£+ØÁ˜W–á‡3]ÐØó¬Çuç:í¬9ÆxŽ¶Âùt[M™¿çfêÆÌöç-²ÙI]bm)¤,d²Ñ£Šh%lÌè]#yIt@VX§I-¢yZ4r‰@m¶yåëEÎ( m‘Kƒ®‹Ròª€‚¢ôD›Gõ^;öîá$NVº¡È­ÄS²É—ÖPÔÁ¶ÛÎÎjOΘæËÉžc±âý’†íu¤‡j)¸v7RHa´œ St€‡$£“·F§H=ºdRHœÓ¡ä©c#¤Ek›êH»tô,s[èæFAžÑµç4ÉΚ‰r©"2ùl‰MMD£>ËÆ+›Se4Ü‘À6ëÏQd´Cxz0›3brx»¾&+è©…°$gEÑÅ+ ¶\‹UÏ¢Þ§}É Nr˜¬© nf©–TZ¨…tº÷™-ð‘„%Kœé¾(œèWÎýëUV®ö:‘ËZü®ªI„-€‚¬}–,¶ùè&™ ¤]J]‹Ë^l¹']æèµf¯ª•hÀêÙ>ˆ4¥›p¥“§­ÀÓ1B¢-` #ç)î±h-!¨­ a#RÝ(I d1-®Ju-›,b”IœÃkq†Òº%–Ôu‹ƒ­¨²IX›\Þ÷ÌÌáÂÝ=Unµáp &‡`BÅêÉ›˜tà}'ʉL£“('¼Ò/R±~…TѪA䔇Êúá;E ºÊƒ²ÍÎäÕ qp)\”ó–þt˜‹µœ&û¦èÑ?B°% ›„¬,YQ⨩a(Šc%ªb†\Þ`´T¸"Ë8¬eƒbÈÛŠ8‰¤²Ø©¢Éi.0k¥P(Ð gHIUÇ<™%/¹Û¸Ñ¶6Ó""Hån»S€¤B… ¨¢jìÑô?33³)ÚűGŽ©¯³³³Aw¤QZ´ž$ŒW-eÖÝb‚j·FòT6\n«ˆ¹Q4w‹jcœ*Ý+5ù§©¼(ƒV¢Ñ¹%œR•Óüô.«ƒTHvUî´IF‰㹇èïNóhëH¤Î&ð´È”£DÚSÉb°{]¨¡XàžiT“EIðycLéšz¼©Ç[œ¯ë¡ÙnCl ^|u&Y²Qº^âC1X¼>’yÊhxâÍ(¬Z½¤Ùd±MƒeŒ)õty.ÑX‡ŠÈr²§-JæËE,‚WNþ}ZTçô‹h5$ØðcÈ^ds¡Y‚îµ;Ü©Þ™rÍ1úÒ)Ïk•UI±icD–Y6Û@]d)S2ò]¶±úLš†­í:•ÑºkæÕ¡3¤É ’SLvˆdè9¨ùæ–®¢Ä@:ÖŸi1Ò½¯”í¤Ê[<*¬ßšYÓ [yÏEæp5~·Ê•›çH. jd¢J™óAyåË«³d®–n–¿©ªÐoÎC¥¹JM²A)…I#„÷ZV:ºP3)#•Åp[lï;s[K€¬s»^3.€X¦˜Ø;¥{;e…£³KОÚru9Õèn:RÂêÝç:!†§Lé4„˜y”·YÇ:8`ºd¤f×¹lÀf‡|¥a:„ÔRòCØd2R'Hùö´¯5Ž…§ä{ }§W]¦˨¹@Nr«XYµyS8wJ£Y)¯T,b–¤Ÿ†J*)§4,¼ÛÃÕñZ¿6îc} âd6U&),”A–Ò1,³M^;PEI-®¢àa-sU7 ‡4•‚·©(ÒÍÒÖËȆæ ÓßUšAUt•ÙLh@Á⬳C úH¬¶L½3äx!èÏB? /¦–6J ˜+š\ḵ#™5*ꦛ¹šn0›X"©K8z<´^ÍD0ôZXkh^ h) eÊ\àX­ ìaÔK-Â@Î2l.\SmË(uÉNÔË$ç›mW k´æ»…ã‹è1ÎZ”q9mfàYÊ$_BBâ":Å]¢ÅPj—3UlÌÒù¨ü3ë;—èlÕÆØZwèŠÊÕX|Óa{wC)–Òv,ݲ¥!lÕ+èÔA“·$š#hÙ3Q(1¬`{W!kp ^ÑsdµêX­ÁÐçgɧ­TV¢FaÑ›Tf­ä„ÛEŸ ÐÖP+К›8)”˜Ò¹hoxwI¨â×eçSŒâî˜ÊõÎ[·]RµÍ&%›­œÖˆV+%sq Fb, ðE“‘xQ û†ñG[Óñ%]F{kKÓ¢ý/_ªËÕ‰5QÉ3–éO]_•$ÙC˜X}ÞË Yn)2Eäñµ ÐH<•)x¦4ž¡s²ÁrAjUÕé¥ã ­O‡´Âïisz»ÄPlQq¯’æˆN"[¤õ2¥ø49ºt›H^­  Ãa´Áæ¶Ã9¼Ù ï;a†Ž9¨ôj¹)cõÙú^m97[_p-NyÅc˜æŸh˜L¥ÏBRæÊK"•(i„ŸËÌìßiç –«³£Ô‹€HnÙ‹G,vh‚Ð:šO“¡®Š Žš‹ü†bÆ2jåÚ±ì&zÌ… ¤0iZEf¿#´¾s°3ƒ3½†=­X"¯o;S£‡‹Ú*¸ “£))UcULÒ û*c¥>VÒ)JÅUd1O° ÏM%™]o$…¼g}”Ø]MÔâÒ•ô… eE+º§©ôDHóQ(@7sà Ui§ÓJÜÛœ™4F³½3ÚIƒÍÜéó$Æiä-M-Þm~+eòŸ@}ˆÔ”ÜU/j†¤Ôô-+v‹ôWHPØÃç:=,H­Ø%£s(:œ–­;†¹^«-¤¢¤¹l¦€£­ .MEb¹Qé*°„íOA ] QK"ÐBMb†¦|Õ™æ6xzïYʳ[32ÛgÁ&\ª Ä–úzm˜õ¡•Ñj• ¦ ðe™d©6Ju5`ÁKÙKžh²$|€5¡iñÝŠfÆ­ƒëÒ³Ú'ÐÒR;š ¶»u4íÊÙ”°i@e46‰•kj¤• ¥RžR<>€hƒ½°Ñ[ r¸.L`()©Æh&é©Î˜°+ZqcèµY5­D:ÁÚÑÅf­pPâKH"Oâײ†ôܹ¦Ï&S¦.E ™B ¤-ïO6§Ðªí%¨£J¨\ P‘Ø3"‚Uy’¢”“n© 䃱˚USB"(¹T$æ›Ïj¢¥cA[ÓcB³™K-PôQ7M‰Ù«…Ö5@kCÔª\'¥vÖ|ƒÝu “-†9„¿0 Ï ´+ssaÒM¥VclËluÐIh A)H<2ÊHwAµÂHÊF&¡Å­³—ѶboÉè2Y­Mçcåf¿¢­µ4¡U‰w†öØt/öúyéÅåî÷—??” v†n"K›¸*Ò°}Í_Œ‚´FH3šŠ X•`m­ìi­Høyá»SM1b6Z`i¢užré €´PPŠSëC8 Óq+Õ?LÛ?›-„Åê&Vè誴ªRX']¢ÏRœ&«5Lbtø[Z°¼Rm6Á¹†:=+S^ÒÇ,›ßóŠóØE+©1'-( —@û)ÒÓ?¦vçKòO_ÉDç†G¹¾çÕ®9¸åZ ïŸAØ¿¿Ÿ5-„dOg Þo¡›œRo \…s‹¶Ø@ äA#8³â3Ú’¦Z»yåF”¿}KÒúMŒ$m.ì¡Ýt3œôZfM.Õ=Ì)€Ö6Í~•óþzºWÜõË ®¸^fÚT´›Ú¿s礄§A¾üîõêuŸ8÷—̹ºMÊ–ZL“hf"=Ÿ}z + „iôØèË9"ïXó¢z~‰•£1Wr(X¡}4<Þ±—çút}~bþMW­è×X*Sz3RVæ1#l”—²ÈuÄÍçE稻½'  gFØË}åu]Ñ~±õ"èׇU¿S›,e¨9:R_̃¨U –åâNÙéÏ59ƒ¦‘«#W}ÉÐè‡(†õëê^«ÆÌ6HÊ2Ö4™")Úœz³iO´f<Ý>½nõ¹;ÇË9±úK×ç:ïú+<ÿ=ìãÏÌ \{3Ï¿ôg_/ž D-ª*ºÍÄ$9÷è!è:Q*v×EͦÍåòÝ5UÏŸ·Z)ô™–_@©6£èZs|£Ãô<ú9þŽùÞ¼×ùc†ï§ˆ^ ù ãýK§7ÁðäõQÍèŒè¬!Î<Îrþ„}Ÿ¦Ïl¯©n£±×'‡é†óX__AùútÛæ²jíå¶P#ª-™¶«¨¶ê,êwsÊxYëEóÀ:ÞÑkÒŒÊ+Óq´,´hˆÌ•ÕPŽôõ]G×·YÞlÔ#­üö¤¬§NêS׊ô9IÖ7ü>xãÍô>2ûô>,yšŽ[ éy?Bóý$~ÏŸ•ãÂЙéå=;î¸wk¥Âü¿œpkóËuÉwVdg¨-ey÷úN=¿GÊúDoóŠµYíöÍ'óÇg*/;s³ßèÚcóÊ‚&µP¬§?ÎÝ}ËÎôníáÍïƒÒ´^/±ñ_OÏý,×2I9½åÌN‹C®š>a.•¾óžsV7«¦‡ÊŒ¾ÒÆúåã‚`—ZSÑ®ˆÎÎm†ß"²²°çª˜4­ßH™<óH9M|ÍDŠgPJJ‘mH¶u:ZŽ‰®rtÍÊ”£}絚^/»Ÿï¾w¬ÃÖóþ_çå<Ò­% b÷<Þ†;«“%ÐþÇÃÝ¥x|¯£ž“o¦Gf^L@^¯ô+¾ï_Ìùg T¿¬|‚žŠµÐw¼ß™zÙãø“‡Q¬;0ÐpzL;8?=é_tó=$ý¾oÒs׺3žOI×w*/|}΋.ÌOlÍp;ÏtuŽÆðùo«Ï½ñ½ ½çŠìä¼>†c«?ÐZòüë óæIç.éujÄ ”J¾í aÖHª˜8g!´é‰îXE…Rê4ãyF#7geÜ–oÅÆÞU+t ¶ˆ‹¡Z>sÙ¢í· ¢@´Æ ’aR¬˜Ãj½Ÿf-Ÿ7èl:“û~lóy}œë‹¤Ú^ÂzQi(éµ]nùpÖñíŒíØo{Åû'Áüߥó?¤ò®æìÛvòdùa<é¡ãïËöc£çtQå¸91‘:L;trÝZj9úVTêòèù7£æ}JumÃXþ‰kŸ§§èór~~ÐÍ÷^÷ü‘‚ô úÏ7®ZWÈN{«¬Ï]g5æ½4Ùi´Ó4ÉM¡ÐD9r«*Œ*¤ùïW[%ß4Òà ÚÍé–ã—Cªpý5¾ç0½ ÖtÈjq*HÊÑ%‘Þ|ÕïUá-8¥²KõÈŽ„lMWŠíÙ>ˆ ³¥ŒfŽ†å5SN\åëÒÇ}žgZŽn¼—g™t@ã’3€µ…¶ÀÝVz}›@7ãäêŸxúNfg¦q¶™†aÐÿ£4÷Ì=”Í#]/p¤Ý\{+ÈÎ ~{Õ-UhŒÞéƒ_#ÃÑ;“©ßw–ÑÏb€9kGX(Q§®[¨}N*­Í{/LáeÊÔ5,ÊÓSYÞ!{*—{|wX½’Ô+„‡¦Ûà ÌÏvY8ɲQM¤ zíNŒéÜß&—„¢Û8¯k'ZÎk&òczκ„¢“3ß½,©—Xã:?<øž»8ÃmN4jtÜ®~‚R}|.43\ΓPÝe¢rî²gÞ.«Œik“že9¹Cå&5EFjc¥Ë1ÊóÐ+“žs¤Ü_žþòï±ß¥æX‘F¢7³¬V¶£-cKO®)óÑ\é¬Ójo´Óš´+Þ¸ÝÕN¶³ÉMžçˆ2W‡.TNê¯V}G­«ÚRõ_¥;ÂílóY—§ærvvkAë\ihE¶ø6¸ÎlÍݳÇõÅ™f;¢¦Yå˜ äº)^–YtÈMРÖsåÈšîö½RFª±ú\ÅÒlµÙ®ÍTÁœHy¡Ò8¸uP¸µÙé!^F’å¢ìÜxódç9\Å© v;NE›F¢ñ~/ŽOs•ˆj˜Á¯Ž\uèVQØL²æÊ&ö:r¨ZWÍÞÇn •©Ï±Ý4óÑ­™Ìd ·YÜ,–âøÒç£\³7 {MdιB²öC¶ŒÀÉ‘î8OM#‚¥>ºÓºíÓdÌô²vqs3œuÈM%›H*=O±-±„-ü»ÖÔ-&N§, c“×ðäªêÙ]1êÇOR¶©^v(جô;B˜Ó¹QTìÍ߶(í /Dþ±G,õZÁáèÔC¢rq«Œ 7¼qñ¼ÆÏfdooN_–Õj·—Í™½rbú<Ê~vßrD¹ô w˜î{]1®vCM›Å®’6Ï^Yc]½|dÙ^™©˜ !Êä´ŠqbL„ßuåWuiÝŒ.Wvh¬S–inºP’Ý´cw„3y©–FÓbU¹^Û¹C;‘ YÅMy¢%¾˜ŸBmUÆ -·›>èºT'rö¶ÑcXŽÓi8³Ý|ém Á«ÉÞƒ—LõšÞjñ«¥aÞšNLò}{è§tK¾g’ÛEY=ôg±ê‘1Æo|ÿ¢²Åë/6¼õõÕ-7QÎòýô¬fª ÂjÍÅ>Î,eíÀˆïnvÚý®TÒŠ8(©"é\ßAXèí ™â¬ª˜J^É«,´Xçž ú4e£‰E³>ªa)jc%Z í5‰îÕ'6R½\Ê*Ÿ:¼”­´Í­¥ì›¬a\cT<ïF©úûçr©°D¼×@¸sÃÓoc#w· î³ït„’ôÌÚjsÒða!ÌwŠ¹íg<‡èjêºJRØAä9HKuàc, SeRÝ)ðQbF<Ù„×Á¢·œ7ϯ1tnñ“FU:/XtÚd„Yµ7Ð;Òû»Ñ&é„Ò Ôî‘Ø f3f‹Lô’…_9Z2BÄÒ§1u–ËðFž”tRÕ%Øä¦0"Û1ÈT=J†É 7 …&+»UÝ=§VIÎjÕfæ5Æ-æËì^¦÷ºš’Fù%AѱLT£&w›3D¸ÓEý†”ÆH‡¡œ©Õ+MSSE¤‰J¹Ns9t:Qt+V54®ÈÌróºç‰fTî½dJOsV˜ïo£7P5¢§7 ͘šj'N•òàöôYÕ -z@ë5È÷šÈy[¹ôý` `ÃÂÅÜ,qI¹s”ÉhDÛ–Ié³¢Ó¦Ò3dËIé†-§!^SŸÖ³=QE©Iáù¦N±bÑ]¶¼¸Ý\?¤öõ,m¤KjnÕÒ¢KÒ¢P\Ù#¾|„觽;.ÒÇnôŽZò$…kæqÌÓ - ! VgÝ.°˜gŸ9c!µû<ô¸k Q,ÄÛi*ÛÒŪ)¦hX¥xC§D}V«—-Vj]›Äo"x´Š”†Žq^ë–šÖΣM¦yB‡ñK%æXéMŠèd€© ˜©¨¼ýF×½Wm)Ó; 0› Að.ö£3PÌ ‰¦™HÑ ö׳~ol+kÙÛž¦ï9tÀÝU"ö1‰7’žlœ »­ÞÒéEå&ÛÉ"ØžB•Ôêís@) å%a¦[²¹¼¥ÜHª¤ñ›}tÇt 9qušÏ˜™2:C».º·[g4§YÙYJÝóQÖ ­[§RnY=”G¾q”//&o;—=µ×%]S°“Q¦y¡ïí/“–¹Æ)Bè†hMhF[zá^G ´U°kjoœ5t朄P˜#q$Š¦8O99÷t%ÖÙb€œNyçõݺº.'@À†‹/K²iÛ3ˆË4yå'Os5úWºvKDù»¾ê„ÔÇLË?¢œ6´XænTrÐ}ðŽÚÛ/=Mi>P¿¡Œ+­†¤w"å6Ö•ívˆüUÙ6˜Ïµ²t±êTë#FÍD.«P)9 aÚÕ%òú¡stT*v–hN‹IS¤‰ù”h¹4Í„ÚЕìz2šZ8†gHs5§† v4ƒ¤ÁŽ"‰G¦×\vZâx œ“Í];RÈå6ç«Ñý;Žik¢:WuÆuWu{¤$­S¤n)ÊZ”ë yæç}è‹¡NÐÄZèy‘–Ia]‡r‹j9%šyúWP>´öD-6×T½¬Jƒå È1WwS”©‰„Ï=_:qÓyΚ˜Ë-"7ŸÉ{W¼rÍÑñÚ ÌAoNÑŽš>åÒž8Q£5<ûSk9jŸKz‘ME<–’zìƒæ¸À*T; CÈgª4&D³Œ_£ÓfP…v‰’ŒTL¸è‰Í§5uºÉsœ±èÛ/<©[94Á#è±6¸Ì÷x& Úìç“,vÖºÖAÌ%€UwÇJóN9ÂKM ,ÍÙåbƒqrì7J¿‘C®&ß»k·iz×@ŽW<œú@5]i¬*“9sÐ-Ô*[Á ËÓ­½Ó‚“9‡?1tÙŽ%+¥FkaO-kD,B¶*¦ç-lÙø2…bSETWI„1©Š›l…:%WÜÕé™-»žKYG˜*@ ;^§«æ€hMœ‹u¨æju×Ô1‰aZ*…eA¼yÓ¨¯[²an´½®­tYRªsòosvôôŠ¿žNvFy‘µß½ªª—&t¶µÅp™d»Dl9úFëÉ¥i(×4ýlbTnÈÆÌÊ粎Sm4»·"6PpØ5ÍâyÊJõ § ™<@¦(¾WuขÞ|ÚiMµG’z8”¹:•”ª Ç%k…8¸MÈLGšæªá3ЦnR§r˜CËkwrW6e(,]±¹à¹$ŽÕðȼf­ijK´¦8Í[Zú+u£†-h’įM3P„¸8s½ÎtX›ëÞó51ZðŠ*“p Q7$'ío¶P7D(ÉW«lêþZc©ÑÌ¢·‰ˆˆs©¨ºˆ¢ÈDÒÚ5r÷Jº‹Y¼Ü ©u %³Ds›ùíÎ٫蓪²£&lM²†èvÕqŠ¢s:N“"Ó5Nà­‰iEÝ wË ¨ Ü—Iq!® Ò[jÉ ÆRïQ£yçH;–fš*cËÌ·ZÓsæ¹Ú÷@ëª>ª¿9æ¶þ]ɉtŽzv‹Â<®Î|dÒ½Y²[ Öc-À;uUÌL›s!vÊQÍÐÕPg³Þ“mÍ9î{f(ëº&åc8Ùh½)Ⱦ@±¯Qä} nØ$ Ÿ±înT­Äíc©XäÓ|åÑVA†zƒqjûT”"™è¼#!5ƒ©¨²´•µÊ®4nMfˆ¸¡Ú)¯M^ IU,âMÔœRê{8îÖ·5zBÆMn£ì¦‰Ñ„>RO®ŒuuÉ¢âÈ]t#}J»Îj˜f¥ ~8ž¥;UÓ»%£§ºÍäÛº·Q •cE2æ>Ikp€-”e!Iˆª²L¨-ˆÊÜà-oódÓÐHæP ºKçÅ1âÕw¡Œ5"H:Q¢8Ñ1¥§VÒÊ@`0¦9áP9*kÌc }†¦ºåÔR›–3PBöX å¯P¹¶Ã‚l _ìòu5+h*×µDfÏÐëLñÉÆ4ACëwiS¥6gcw[‡FÌ.¬¡- ê'•úÊ{'Ê0»Š ´a³‰eMtË( *„seLÚÄ ¼‡iP©¨ •E!‡$±(jޤ₩¤Ìyc žÂírVºÉ¤’nölœæÝ\,Ð(%M;@¬£Í'ld† À½6lld“/Ò¤Qù¤„ß!n«mø‚¹qDøÐu />ÊARVs ”3VÝv¶¨«­96æDÝÏmK½l´Y† :YÖŠ e‰U³CƒTѬܨ6Æm-CüÜi§cK•tŽ ž†ìP%ðØÚƒ@ŒaD ÆGâåqz(íÚz=Ú@Ö€gCYððB?ypðJg”áàðœÇ…ÛÈò™!jîÒ® šàt‘ž”$-Qà—88(¦¹yEŽÆ8„Çg‚Jk‘òÜ#ÁY_ÞxÂ( ‰ã ÇÎ|åAÙ%J‚¢VjÂêQóýƒ]0‹Ôe1àœ¬"sÎ|“ç++²ù@¬ùÊŒ ˆ +úã¶Wôáà‡|†åIgðôFTcËØ2èL—Ék\Dc=j꺡˜™¢ˆ@,§ å• Èé”Á_ÕIMç7àrxr +K›á±7·Uœ!ÆnÉÂÂ/ë,,  E‹pAG#-ðF _à'Ÿ 0› Ã1‚ÀS[‚Bió×Áb-DaD oE4"‚!#Ã>O‚ úÀ],q 0Š%g€€EJþÏ—0'Œ€‹²š<”Ç—sžã(…Ÿ%a‚“áH;&BÁDd”‚‰ã<á”>WÏXRð R‘8¦µH@`·Â%<σðrŸå1å0ðQøFN@§Œ#‚‰0‚ƒWTü…„x¬áOÎ|»ä'Óç>AòQ¢‰AÁXDœ†…á vš`ÅÂD÷(Çäœ („9sÁàÀ¬ù-ò]„JÊc+Y๠)ÿ?ÈvQ>]ò(,pJë“Ѓý‚ÆPAH”ï„„VP(ùä"‚}ƒ–»+þIt@¦Çç)¤'¡ðOÐ@'˄²ºùcü¼„Î0‚ išÁ4(@̤{ ­'Šê†'‚ŽÂk‘(YD j ++8]ID¡„xj B+ªÂ8p@ðSVxoË€(¡À +<G„O Þ=Š 9a+ªŒ¢xøâiÃW_ òPä˜d%ÁuXNn8„?à 8øh쎅Ž$„„èž‹qürEg`#åt+²)…g·,Ó¾HA…„ (ŽQçûÏ— p~0³Ë“ÁEÎþ@'„VÒy1’£$Á@ ²³ã™g ìÖ¦TÉk DÅ7DÇvh>X]x(/Ÿá„B>C…„D#òTöZÕ<¤&âr¢fUÔ,„xb{²²¼'&"|áxbÉ$øÊ%a`ñÛÆVW_Eš|±à„PDxhCÿÂx’PÐfq=Ó^P~CP$ñŒ¡áeÁáJü8à8€ØÉ”øŠ áéꬸoeÙw]×uÝ$7–£ÁEÜ2žp ÍÃ-‚¥½°A„¦·];ÁoBoÉù>Pç9Rx â3åÇÉ9D¢|c"±Vp <ãŸ+²}€»å8e"M$æ8c¼ü A†WdPDá>P÷|&;*%+ˆ#/D`5ƒ1ÃÙEA|,ecŒrVN ‘à5þß/ˆ¹~8Ž¢<8µ˜Œ/…Œ¦µ=ÈeuÇ9>SGRä §ËØ„h¯”x _Þ!8¦ùD/ì"y  ªÂœ,/…Œƒ&B‹²dbc‹NA]TÂp_7)ÂyA 9@ SŠµžÄ@¢@1•7…ƒ¡O{.@•…Ž"@§³ÎG *Gž =HNø?´v3†–VVVSŠo…„àÂ@ |á…òá£É9yNð»8&¹Ç€åÀ×L%cË£a79 ¦7 (”Q+JÀPŒÆ0ˆ •0öŸë²à VO øhYðAXX@,s„[ç”c W^ì'JšJìQzs‘hptM ñÚ±Ø3Ás°Z<¸`…œ'ƒýr<“Æ)Äy#Ê …ž'‚Vp‚<Qø )«~jðˆã<‚²²€ÊpÂÊÏðÎIòº”ÎQnP A„,a+qò(·ÎpN ˆMgWFì Ôô]„\Ôø¼É-l/ "rÇᨒ˜œ2Cp@òÿð{¤§.9_X(05wLp%Œ9ÂyE4Ÿ—!å|&ü¸aàe‰AXãž3„<Ÿ áa pXCä”Sx Sئ¦üöÂs“|€‹¼¢‚þ‚sqÇb r<°²Š|¬!àýÁ'žäý„L.pPÈ cD¬¦¬ Vy¡ÿá’@Ô\\rSœ MŒ§„ÈÔmÇYN>HÁpuÉqê¾Pò‹POQœ#áß— /é?äBþ‘ò±áÊÇX@q•'À&§#„5egÉ<çÆ2ˆÂ Š£åe0"<’œÕ‚_•V¢i´—·Ã „ e5«XXàp9j#Á /¸]åáPbÂøNw†˜Üœc‚Ì/íÄaó ¶Në¶JpÊøàJ)¿.+(”JjpòÕðƒ¼ÿxÊ(„<„×xAd¬!ã—¬p!Ç„çegŒ¦•ŽE8 8(„QS84½øow––á}§òš.aCËacZÐA<ã”P@¯„Þ ”² 2˜@OLòœü†÷Õ4.½@ C”€Ã:¦Œ"…ó$”MðO’ù<´áe”à»)‰ÁQáçÎxђ⚀a°‰Y(e³”VVQ)È!ä[ Ïzd‡ =‹Û”k8Àrx kdîÊÒåÁ½C"È'¸NÀ¿‡qžGME
XÓŠ¯{SfiRÕÏ®DÑuk§­De}YQ¸°ÆîÌ}2[Xgâ3!ŠB !ŒE(ÄŒõ¯­þ9Mj‘À4¸:E–|4"p™ñ”÷ VSò›,¯BKdk²Òö…Mh+éå:N×.àoºS1,-vZSåÖ|(I$8™#„¸uàaGIà5g ì Aà<'¯VöjÁvLcí’0’pü91¡ª9ÇLZå'”Ù<}á(œIÙ:|(£sHVÙ‡Öq{åÈ1Éï-,$¶Lµ‚^ÂFø'7,eLÒå€ÊàèÞ&l‚ g Øgd؉³”•œUxÈjnWB„ö‚P8ý «„B{@AÞdqJ;Z°vBt¤¦œ¢¼c±Q7É(16$pQ}óáŽ-ÙU\DŽ ”c ®ùþÜ0^2òÌ)d뽇3;»³âsÑ”*8¶È/k?äBÖ˜Ü×5ñ;̾\<'¹¤@ܺĭaepè­¸¡P5á²]'a+Ïjów2aª˜?c•4!ÊIúÉ6ãÀ¬K›Y§´í-ÆLO g´ ±’§fð_7íZ÷ýeó²BdêÏÅËbv˜pdA¡Ñ‚¤„a®Bÿ=Pjt` Ðbù „ã„÷´±«íhAà·Âao”€Èb+ÿâSÎQ39NI%ËQ8‘Œ&¢ $âò°®‹ªúšŽ sœ#Ê' ¼}L}bkˆsžPR5Hl³‡S4fF´õNXeƒ#„fC÷†GaÁÇ;Þè§ë‰í•Ñ–w”y-ʲñ¡d9YÞðöIbûdÿ ÐqÈf\K˜ùfî+d˜úµJ;)l}#]°/6ŸÙ¹‰³HðXÈL¥ï„öìæ£ÿA­B³Xç‚Dq¢´sψã~DaŽ^ AB"k°Z;IpÉüboý‡?ÊbÉl@r{£^‹¼aØ‘Û Äà¹ÎN$#Sàó×*1Õd¬(ÆS˜ƒ:µCµ„|&³+ªaò%9ŽPÚs‡¼’—£åe× ’à»x{Zî*HƒÅjma 'YêçÊJtmy`5ŽiîNÉ#àÆ úú©+—zµò(©Jæ¡袃 ÀÀ!ñ!8pr#)д†1­Xi]Bë„Ü" þ9AESBwCŒpÐÏX átsU»Ø™‚dàœeLî¢;ƒdæ9C…Œ…¿óád³|œì/´‡ÏS$™Qñ€Z Ï)¸!­ÿ¢r²³À G`6PGÛ…ù%uÂliÌ62¯“Ó¢1£Aˆ· ®£7%¡4/ujì D”qÁÏ- ÄÏ/p!ÌÛŽì.ÁS×`»Ô÷a5ঔ÷D‰‰è0š8' ¥åïÂû$qÌrx³ÿOš"ÖTFövF1Ÿ¬8DCS Án ,L8AÀ¯••Ô§ÅäÅ„Z»aF@Dä1¸E©N89ñ %uã+>àŽN=BpM + £óýVêˆð>:åu ø DáxN)§Ãœû‘v¼çþ~P🔠#¹ÏdÓà”á‡È|ü—J8p‰É²äQ(• ¢<1„0dv,8? Ê'`¦ŸùOr…Ùó9ð_áÃ+²–<Ü&DræŒ#åkÑnQf|ˆãLnQŒæ˜òo8ð<§*H «8@ðOŒ‚ºœ±¸®¾àÔüȘ[‡1}a=Á4¢ðyMyEÞAðçÜ®å6|žà ܯ©Ë¯ r‚-r’Ôp+®[#>¶¸ß–…ƒÝŽÁÏ—5¾D¬þÀÊÆÆWôNL“_ r1€>ò x$|q–à¡„×$ì1Ød»€Œ ¯°'HdAã%è•ú¢ÿ/p(ágÀ+ªkr˜Äpº§F¢NbnWUõ LÈ$œÀœÜäàŠê² ,Ê?òP@ÿÑ,jÁ+úþ»J^âp!©­Âî‹C‘ÿ—e¦^£>‡&œ)ëŸ' '³‰Lp ÊdåÎ9$!Øà½ä´£à±Ù$î^Gð‹°Ês0œæ7xq°æ§?ÏÚ1ö`¾B¦Ÿ$<3ðZ›eÉ–B\®èÈSæÂbt‰‡' xCå‰ã< à”ÈNć„\º¬"Õð€X Ǖߩ݃“ˆÆ@_<—Œä•32¼ãÆIá1«(ž A€ÇòJú!?Ê. 8E¡ã¦Q#JшÀì pýwjsÛ’öà”Éú£!%Ò’»’¼•Ýè=Ë.XXX5uœ'J¦Â’ÜÒõ²:•Ð¬¢ ì›&àÈ‚i)¬]Gäž2²³Îx0UÓ¹aÆW•ÕuÂÈ@„J{AQ²‰c)¿¹DÖ O>HMo2š²³ÆWd_‚OdOøÿ´^p_` =vEëº.+±Eä#"•ä/½Ë¹*Œà/ xC %e"VQ(JÊÂpŠs¼¼‡'4…Ñ¥2µ5­`áaòá„Zšì.ȼ"ñžÎL”“Õ=Äæ@.¡;ÂkÂ%.øL(94§”[ÁXYYA‹rº,, 0²‡€×e‚•3SZƒSFVx%<øÊo’Sœ‹WEŠì@¢DùþÞ2Ò°@ÊiÊ„¬§|’‚ ûäù EBnÊ (,a<ø'$4øS˜ÂéÙ9ˆ(ú’[‚H(1a9…uMgýd(@XRFìÆ!Èå•õ U !¢9Gäe•‘’Õ„JgŒ¬ 8<5‰@ <„–9#(0gª.Àî²²Š‘íÃbÂo̯ÉÈä”8Êì²HGR_` ’e4'"|„ß“òNo  <“þÀŽ@Hò°Š›¶XS”nN §ùEž ¢ÄÀ@,ìƒ^Ò dÁs]v ZD'Må²å–…•Œ¬á/)Ã)ñ¨r +9A©¥9«xN –üpGàCˆç+…òƒ@_ÙRÉ…åÅ­+HÜ Öµ8…Õv]²».Èü&;(»ÎQ)ÎXY !a5ùN>ò' “°‘+ë9 À (¸'‚QD&‚WdHR¼öèÊÒ„¾~SpPbè¾´|&½”øÉO9¡yiA™Aˆ7 ÌÊkp‚%vYXÈ@"<¸&ðV L8E¬¯•’‡AaòOÊ ñÁYã+äá³Ã£ð+–…ý=ÝQ×D]„Ù< åò‰L*E“¤Êk˜ 155¡1¡€³”3Ú(z;°È>;.Ù9Då9Ëí]Ñ+²áp>§.?Y*O/oü†XóNo•„J“å¾J.Â>S™”êãKTo_<áˆÊêA2»a (áŒ,œ§9à„SA(áœ.Èa8ad¬¦£Áø0‹²°ƒp‡„IÊùCx$²,—Pñå¢ä|€0¿ ¤Œ—²å4xqGÈ$§ø0p ÂÁw‰9.ðQ ¡9)X‹Po—ðcDaEóœ‡54 áau_NSbÂiN7%uƒržÏ-šAãò°a¼!ád"²œPcŽ¨±>4‚ÇE¨µ7<ž ¤à(äxÏð 9@ QpYã(†5JÔãëMa_X ÞSb¼à’„i…9ÊRJ„u )ž-No€0ŸåuÂÂ$§´(Ó>Êcp‚sB ¬¬,¯+#ðZhMg†µy ²ÎQ_ (ÆK›<&ÈÔ| 3ÀÎXövAË$'|®«•Ù•……ÕcƒÁàž0PÈD¯èøAa”VPòŽ,á:L/µ1ÙÂ'+ Ä„R\ ~aÈî±Éøò ÊkÉ nòÂïÕ;È躢ÔZWDFN G\.¨! Õ`¬ #$~Pf@ËVdNWž2‚)Ï-M°¾ÀS˜£`j$Ø®ÞAÂ÷ø@p<¬,!òBaÀ8EÈ”ß(Ž:”PEVÊè€(” '€ŠrÁÀ€E8`8ö>S ä'y!ùLnð˜Ü®€,´’Ü œÄæš ^]‚-Ê 9úüõ9é”YƒJ#Œ/•‚P(”äBÊÂ…„ß‚Õ‚xÂø]TðA ¥F|J#È(.ë?ÃûA|¬,¯àxrÆä¹JoJ([åÍeBùLð±äµtÁê‹ hXXCƒáQjea §9e5Åv9ÂÏ|,y ‚Yà”ç›ä;áÈ|¸x+ („PCÂÆV8ÇD&ñýÊêßå…ã‚GáåÀNAE4¢‡Á.YEÐr-㯠¢8rÇñóÀ_¹v@¢0ˆXMf,"Š_+<„PXã+(ø,A)Í!ã(”>þ pG€¿¼/è (Ð XCø€‰@äCŒ sÆ"ãú P_Ð(¬a‡„J +ž¥Ç#§ã…”P+ÂÊð_+8XÈøE‘„JvYä"ßäPÊ1…„åËŽÂ)Þ0²‰CÈè‹VVx9 ÁyÊþÉEPÂðã•„A@àœ¬,á"àŠËã ª?(…× Œ ä< $¯èMù'øag<Žr€Â9”ç,’‰ðï`‚‰Á'+¿€ ÀA Á|ÞÁ¼@¢2²‚.ž¹D¸/°¢WTVãˆç<2ŠaÊøgŒ#È…„φ•ÛÏ…²ñ”A+rBäœñž0€ç+<ƒÁãáŠÇ`"@#àœ£äà„Ñ…à¢S†VWd#xþÀG€ "H]PD¢V0àe•”Q( ˆ]qÎxÂ' á‚HàçŒñ” 8@¢VVrˆEag‚V>WpJ)¡ Î(&•ý,¢€çÏ’À‚‹ðƒòC±ÁÎE©©È”pWP=¹gœå’‰DøÈLE™]0º¡À ÅÈx%‚ð X<ý¾ ¾FWÊÎAD r±‚FQvA8eF‚ à QYA•”x ]P XÂÏÊ!c ®ˆµ>P y@ ÔBø@¢P ¥4ùr?À"3Ær8Yá¡™‚'œ¢Pá§)Ç;<Æ3ÁGpB å„|†¹c‚VVx(|VQYYä ³Àã2‰YXÏã(¬, pB€GçŒsÙ‰ åBg(£Æ@ žB.«¶Yçc(ŒrFWõŸ +<yÏ#Œ"Š %ac+®BùMiCÂ(#ÀyçŒðP( ³ÆQEe("‚+>OQÊÊ)¡!ò°XCÂÂøCÏ8C(”!C‡|¢PMDá)ù@á•ýg!y Èp|¢³à"À‚°‰Âù@"šÔçxŒ‚°àg$¬ñ•ž1Àð³À>8„eegœ¬òxB?$ð>Qs„<PYEdñ••ã rŸ8EÔ\š;0„ðšQ(‚>3Á(,"0‚ÇðÇYç(¹‚ÂÆIXMpˆE5Ë9Yã5?ˆXA„YÂÊÇðÊPà"‘E4 à¡ÁàüÿyäyàŽ+<ùÀC‰<•œ PE¡/NøþÚr‰!’BQ,¢PþBÊ'Ÿ9GžZ˜ÞŠÂøà,ù/óÆPXCÂÇeeˆþ#ñž/”BbÊ#€yÂÊ>Qq”<"D,rQM(p‹ª D&œ r²¾IXM_+ÎsÁXEa‚983À"ï"^ÔÖá7‡4’É[9’G½¡ î-tD¢ÐÞ Ç=pŸÕc(³ KËásI ÆÕôåŤ9Ñøª{˘O ªêº¬ Wd]•„0š‡R‹“~@Ê#(óÙ(;È'4„POrfQ09XoRÇå( kŒí ´9a:«ˆŽ_ùmg•hïè(âîc¬×4Ôs s0,'&°“-N¯©š…À™¡/&¼>78ð3Ú §«ÏP]Ø· Ë'Ø^ЄøÛ.CËRµK‚ù,:X¡yby.!§á}žì¢ÆD_ò%f _a Ç^µž:Þ˜º/¦NLsd—ä‰:—? 4v ¡…á•ÙwO85%0"zHÜ Ó–›¯5ù§$?i€,ƒúË”ÔHŽÜç\ª¶s+|ˆÝÙ 7cûwÆ }œë2G‘ ù;8¹Ü®ÅQÉ@9V<€›ò @yÂ-òœŒàò-MÎÇŽ©ÃBrÂùE`â Q]‚Ê#Ž©­X 90<×)§/°I!¡Ï,y%}á­kNkLcœ÷‡&DK:‡µÅõØ\æö ðÈ^AkK†H*/þRCë*=_0Æ#wVœÀ7ä™:´85¯”)ÿUq‘Ø$®"¦ÖDȼ¸e5€(­tqUfc_zfH[eŒcß”×4·ìgo¼4ìBA—9¤:g^à|ðJD¬¦¼.ø@„ÿþNKŒo-mò¡!ÍÙ8/°cí!+¶ $ó+‰Èq”¡aÍ.µ•ùGç"BŒÅ:Bä^šò¤$†‰rÊSÆ|tÏÊqÊ%A@ ;„^„€¬§=¢ò~SŠkÊk‘q'(”J?(|±„Gœ¬eeMø!cyYAùY+¶xP͇M9(XÈsð~Ï vV8•Ø¨§!wó÷§ƒŠk×ß„fN9E6Cƒ#±ÝÈœ”;"‹\S[•Ð¯­9¸(åF܆¿,>IGÏ„(e7ç!;àü3À-8v@…¤ ÂS˜B…¤’ܧŒ‡³/•+0ƒ2r°Š;מ¾z”Z„|ááð†P ðð²7ã!0¢pòšÕŸ9Ece8„Ù.Mq_ô¿é9a5…t(ÆSšB%1™_X_XNfxXjÃSüqÁð»'’š×cÉ9ÈtdYÙΈç¢ú²ˆÁ %FÜü˜t¡ˆ|‚0”Á€Ï’NIÿ™#"Cÿ2yÉ ³ÿîÌxt. Çó;2æÿ ¯ƒ#²™ðÒˆã  àxM]Q8Ê-@ùÂ!a5¨øM>:…Œ,y(œ!å&¢à²¿°<ö@,•“Ë”ÂDñ’à˜†PÊ{NNS2°å‚ŸE˜Q·+„c9¸Q€ƒØðšÐL­6L60ò‰ðžšäÀAå­%ª7 ¦áJ<‡Ô÷¢ì¢kÊf&$0¤ùˆa1Þ$ È $—92< Ñ—7( .¹MffQˆ”#!}h·ÉiCŒaá¯Nò¾¼'7Ái@¯ åé¼x åß1ü7åÈy(Âð€ÊF‹r^F„àp"움ó„æeàŸˆþñÕg!P±à%8eyNIL(4 к„@D´`¢ðH+ÇyY+'€°‰ãÊq!&µtMòÂëä VxÁ¯é¿( Žy <ae„r‹‘nCZ%tYNLAÁed'¦x]r켆xD¦Ÿ#(„Á…Ø!„\¾SA å‚°ˆ(5t ^È]‚ÈN‘vMpÃNŠÂÊÊøMr.蹄Մä”x!aÁYEÈœ¢<°ðN("°‚Ï9C‚Êð{qžrœQ@a §#Œñ……×+'=w(µcÆUÕt]0º¢Tÿ ®”À¼/  (’šâ‚9äžNAàN”r)Ò`9ù¬,¢€Gë]HMyËdò]ãì9å,®ÉË+²(”!k¶pD x Ä„I@¬¬e°‡à"^APjÂÊy@.¡eWe•ž”FS¼'Ÿ¢Sy8Ê(QAŠ-]—u…„|,&5a°€CÂ+c+ªÂi+IòÔ#ÇÈ<”9!’ß#äÈïÉp_Ör(y_ Çøxk–ˆ+ûáß<ŠÊ%JðøeacŒ!åxr?€vã)¾T€¦µ2º¦’OÂÆVGÊ>e•œ¢IA«ªêPp8iòŠê‹‘z@ðçaev_(¿Q>:€°œð»x]“Oe„ PE8qÔ¢°Døí’H^x(4ÈWo+ªdpF_=aBc‚TÂ| ÕŽG‚ÃI@¢<¬ð•”öˆà2³À@§;(  €XD!ÎyÊÊ! ä"šy<9ÂÂÇŽåæ¢Dº„B ;Âo”Ö„àTh ÏXã_(xYà,€³ÎQ_ ±_<¸ VA@,,ðGñ(ÆQ@"ì´"‡$.«ªÂò²¿¾<PãÈxE|EÉE8…öp ï”~^šì'VSA]pIÂ8¬a(”ÞOÇ”pxÂhÂóÀ(žs„JÊÊÊN8!¬pxÊÆPä' å”[”ÑŽ(…”\ Ï>‘ÈÏÊÊ?'Çç€QYM(”ÔPòŠò€( Q+å¢x%ã•Õc(1„ãäŸ$ ˆhA¸ ‚º¬ü&yA7‚‡ð€±„sü à,q”@ðA,,"‰ã(§ ‚MÊ ø@”~ rš !žr³”JÊ)¨Ÿ#ÂÂ(qŽŒ,,!À<ä8?e;9v_ÿÚ—g#[Jx>÷Y Q`×9í©,±C36iv7?7[iÑRØÖ£n#û*;Sì6oWgßOI®a³Jhß K—6ûý…ÚÕ4›}¥Ê³ì¶]ÚÃg³V -Åt¿cNŠ“~šcêžÐ‰—æž6G­Ùº;0ÏöBùõDÖÈ?I¥³—I3þÍ=ù@Q»ZƾFë6Zºõ*6ƒ„sEH>”® AQÿ›,•Þ¬81»ÊRÏ%ž+ÓAf¼LéLàÊÊLŠÉ5ÓÔ€ü8d×ÓsÝ “26GÙ²ì(°³×¬šñm"•·a¨K ž³fo¯‹Ôæ/l’˜åZûñµ±Þ¯^nM¥e‘²Å:-#V*ÆͶBØ´‚F‘ø2º»ßæ}IÜ/’«œ ¤s­¼¸Oë¾±òÅ?VÓj£¯ÿ;Kmݬ£žŽÒû)ÅbV׃^ûíõ¨vûW^dH'2¾·Òú;K_luÄ×EjÍ|»M*¬±Ô’žÆ¼æÍú%´6ïiÙXlÕ¬ZŠ»ö7å–h¤­J½¦Ú•Ýž¬çÓ¸#É–c$‹Îºë£s¥…úYâ¯n-Ýé"‚m˜Ž–ÊÉ/|Õ]²t–nÍeÆ”´æ™”îUŽoc{lUÐÊËjÓYZ+QBë{7Ã#hUü«ûXµsÅF½×&v’M…ZӾɮGÿ{_rHá©l~\0dì¡dröÙ³–Í©-ûµÑE3wƒbøâ¯(Î úý¬òkw] š9kí§»Æ;¶gBÀÒéuûWî^È`×ëæ²]«”VŠ¬Œš(ša«mL«IE­Kb‹cea3-û;$îqlÆVɪŽ3©j›b9¯X¤_*2 ö5§‘AVʼ–%Š´Ž&b’[vå§bŽ]]­‰óJïµ®‘ԞÛuŒ‘RtsX†w±ÕŒîŸ×õ‘ëô[(á­¢××dî‚a‡Q¥¢“kW.‰òË3C&á¢Ì5s2=„M‚hœ_g\k];:Ï–Åk²Á[òÞ,ìÌ¢C-)kÓµôÜqŠkSˆÚûã\m…k^>ý…lZµªš³»„,ú}+#§zrÊÌ”³_ võ;*:ZšR$­ëåΧùu&ìl;9º½ŠKL‘îeûn‘¤ŠÛë@&ŠŒÔ¶Æݘµ‘¸Yìµ»®Gi¯|¯`lpÙ®e|bÝ#5½†ËK±«&º?º+ò:¢Óî[iûX!š8 cªÌ÷¹kœàê–äŠ]¼°t/Ùt=–Ìr^õHßV+Ýašã¤®n1ñ‹3Y¬Ëõß]÷@“¶ªhv¶BMüÒ¾â/hc,@ $´è®±DÊ«ÄèCh6aId•…ì{îý6lÊb±F³¬Õe(…e–´ñØ~Ã5­Ge­|óÃeµ¬²xjÁ kÛ„Hí|–,7b×æx¤.’›˜Ñ¾âù»áâÕèg¥«žÌzÿIš±Ð^]¤Iêúˆd±3õ¦lõÛÔŠ%e¯Öÿ'ë¥ ©ÐNË7eû„Ý#v”:Åêv×Ø!tWXÆȶcÔu¬ÆÙ)IˆßÒJÛ"ýHåk+NzCºüõƒ·Û©¨àV lÒCbŠ:Î|ѲHÕ aòTkõñì6±KKì|Q›ûßbĶÛ½¨{v$W©BGÆÊLb’%í\lÍÚ¶a Ž RÎêûÎÎ×C}ס–Ã>ý¥Éœ«Ü–J³6XÖ² þªÑÅ´¡§±¯wÓ®ØíÙ²µ“›³¨ž'Zû‚‚ͨä‡]N×­NjÉ^Ý b ÛÄûw±;,T/×}¯¯·³¢x!k­}±“³GIò=»[Uã¹ö‡Å,ÐÆÍMi&šü¯¡~ÅŽ‡eô¾={á½N»¯#½$m‡eVF”˼mkuuÓ bšì“ÔÖþ_ÐDSÇ##«\v€Ë)»$V«YžÄn€:yëÂ_v¼Q«Uìž»®f—Sº³+ãÔÖûäŽ9jˆª=ÔÄzÉörËͬË%‡ý¬Š´ÁôÃJgÙ»Ú­WšXµwìV·¦{g«²”OxžøíÅs¥™ìˆ¸‘õ@ìG`8—Ja’Õ«7v™êë%µ±µ(û«*m{Ød|f'kË+ëÉ;b©½4[)¯C-\È ‹1º'²Ã§‚û"e±”'qžFµª»"c V$ŽY«Ãn ÞZÙ¶ô£ÉÒê‹,¹Õç†6Gañ6‘ÕBd[( ™ÃiøVêÝ–[¯šJ·Õ±Õæßk¥–¬ÚìøÏÛfäO~+nËR)1<Õ©ÔuW|ÚÈ!_þ´VÞ`¯fÄ%úàsôý¡‚ýMTìºØ‚žW}Teér©µbܲågþ&¢ÔQÃNãa>ų»rÈ’GKC¤­©÷6MUY,;gÐvì¼ëöR>îͱQ}é]èÛei*Ëö¯Ë.uûø#|±CžÓÚØÔ’8!es-˜þÖR³(°ÚfIå­±tÕ¡ü™õÚï¹úë’8W«ë¯ÕÝÓ—ñâ ‰· Fi«Øl3CkEcVé©C­œ‰Ãã>ÇTVµ¯ÜÊé¦ÙC&SÞ˜'‚Õ›±§KqÁó[€@ûšTßrOe¯>¤jkÊ"ºL±XÏø–aÕœHÖ»\ëtµñ±ï‚Ý@) `û&¦=†³RÙde—+0Dø«CYõ\&Å:N•«j(ª“^æÌÚaÜÔ™zβJЊ¶]åOj¦Ú[ÑEeí׶ÓÆ5γrJ›®žíú?…Ú«â®Ès²ðÍUïÅ{gë-KOZý *?»¶¬gÝ¥|/ˆ¼{ Ö›Ú™„Žµ'×°µdI5ØîEová$¶¤†j‰ñê#t²h>ý:í™Òµ®@è˜]Hë«ÓuÉ=‰£.†Î– ²ë¶-P.“ñýsGbJg\èf–ms™%í}‘cÔ[zξ â7v ŽþÆrùbµõEw`ÉY­¶oRšOþ#3ìDb°ÊðJËñ1 :ÔµßÁî¥êšk[íç²z¨¡WE­Š8jZ{`ÖÞ ¥5W]Ž•˜èêv›3MÈ¥?|—«2 ëÓ}xFÕ—¶ sÌÊpÎû­¾ø:{ ’áÕ¶‚-€k„æpöÇ,pÃ/×i%k4ÑGþ½3í Qɱ†R_ dK,¯ïu6s3<4=Ï—U[^hj^ÉM;T{+ý4Gœ'ë):·ªÖ¾¿ZÁðÜkÛ¶¦`y–BmDɚȢa©$ºlnk62lî0M}«²ÍjÛ­ÆÝîš#jĬŽ¶(kuí§´ÚL×?wMÕîí“ëö„æÕö—·®v3Ç-.ÁðÊ틤§±ÿ“­|‘ºíÊÁ¯.°ê¯sìä±OY%Yj×´Æ>¼Ø‚³ `‘‘܇g«’µ¨©µ³8;ò(ç£qŽªÖ™"wæKSazé±1z”r³Dv“Vï¢fÓP’¼qZŠ;{T~—¶Rë $;ìXÀlÎ-l²µVÝÓš:ViXŸnÖE<¡³2Y9–G6/ÕnŸCWa÷m(ÿw^!éUl=ðê%¥þ<Þ»´¤[zƒØ5ÒÙÖT’6Q’yÿÌdDrMFóœí•*õ%‰ýŠ]‹²KUî†H›R4Ö4'Ï\ÍÑ]|5MnV³Qjû ÛVÔöÍ{,i峌µÁ•û:ÈsXZNë©Ô»f®ÂÁ 1˜g2iåu9/™Ý5Šò·_zPù5mšË¶ì+ÁµºÉhA-‡²©mÊ®úB «Þ¼uRÍ*ßQ`|šK’CªhúÇq‘¢¼±]ÕWsÝB­ ÷,R³J]¥ªR9íò"|Žº„–lÔØÍUòX‡2V®$«r´uêR»<› âse†7Í(NÜ7¨(1Jö¨ššX]>âWÅR¤{½K×#•ÚúÐÝt>»f:»YìÁ5¶Çmµö£‡KaW7dm.‹”àØÕmC©ž¼·ý–류E›P…:uäŽZQë÷2ì5vµ› ÐÆè-¹¬5£kÜØd§¯ŠôîÒ¾‚“K Ú°\fŽ –ª2Õß^Ð~,u´Ô¦g«ëÜÿýØ”Q2ÄÔi²w1S0~^tŸB­mY|í/­Ðûë;E?àE{ÛÛèÀÙçÿéHÛ%­¯f¥®ÉìFÍœAe²6Z²Ö[w=“Ó¶ÆjNÿ_·×í%½f I˜ùf3µôÙ##”´6cÅ×:·¯ÚÕ@%­¦¿\²­vÄú/ŽYcÚÒê]gBÛ;[ç]#,kvW2ˆ§ûZkDZy³±»Jí}Õ{N3ÄmÁ8|ð[|luÌÉÊšû $‹dn^ éiT°.=²Ø´éS§lqÓÖlV‘õÛƒùsÇ5‹»K‘CzÝyòÑŽ;‚Ë®k«Éõ8z´‚FKˆ83ºˆŒ2zƇý]ƒ¥£bž®ÿåëæ}‹ZI&%Mb–v1K Üýl펎Öf::Ílíž¹#W¥©V¿þÃBa^ãlE+r=-è[_Ø¿6¶Çß+¨Æ÷Æ‹šõZ9ÔR¶ôB:$Zž»&uSFËç›U Ú1i¬Ö§í{Hª‘v]Œtö0ÅúºõQÎŒÞØ ^ϲäGñ™$º[Ï£¯ÙÜ‚9[JêÔi¥¬ÛN2²þ»ëux¤xdw¥£4¯ªÛ1º TöÒ2fîÙV×LERhå—bÀTï…ª–ÎR‹í6ì[Z+[%»L™¡ÖXé¬5톌¥ÿÖfîmLêw,Ƹ|»;sKCw²•î/7ôÍ;U¯6MxÅabÃ,:i>½”Öb|w,²]ù2ì$q!h:Ðù£“[ LtâÄõŽ¿n6?=\à˜Ì­s¾©kYy“‰À Ì#/-ÍŸ­ñÌ)ìÙÚwñ”숰Æ‚Ö4±…Íyé+׉®ÕÛ´uڭг_´« xÜèo¹í®÷Lö²{"Hö•˜DSÙŒí?Me—lá®M\ºú”®ÓÜk£±-­+,AYö 5ã4õU÷­5 ”ŸÕåѲF¾ÌB8Ì®j¡cé5nK÷6=äõëTáî÷NŽ¯µ6±ØW±F¼6ïÒ²ï¡YšÃaˆÅ™¬‹ELÝÛlmn²ÅšÏ‚¿°?òŒ–¬KRÉûjºK¶éësÙ,Võó5 ±R`Æ&2Ö©´ØÅ®ÍY§½r6Çf¯ÿWü8¥s¯@(Ú}«²@Ö±ÐSaW(˜\el@Î\Lm$}¬eZŸk®²Ýhæ’Nô úcs-WŠit¦¾ªõ’¼•¨TqÖºx¡ÙÌÁf²Az9~Ñ'þ6ÈÙ#w“í,¨ëQXŠ”°Õ[)g± ]RgÎ$ÈZÆ<àj´5µœC¢$¶_ª˜ôâåm;!“Aa楩lÈÆÒ[ìà#ÿ§€r\ö<­'¤SƒXhÚ…ÒQÚÁOW%ÖŠö$|u*ͯ£±fÄØ­Ò7Å,Œ»r·ü×’%õ¯R¨ùªP©^ÖÞxœmTKkP'Ž¦¦ƒ »$žõKâôÑ([†O4¯œ´E'ØÝ„ŽuyþÙ_§Ðì¯G¬×ÚloÛm›fÄËWW§¿S]íº³ô[Žvª¾¦þ3ɦµ*-‘3Ö¾Jð²ÒY–J,|z^±<×wY.Êå˜ÝNÍÉ!·ÿ®œ¸–ÏÝu–V‚»Ûobv)åúhJZý<¿•«Ùê™rÝ­æ³]$Œ‹è³fËâ…Ç5K¤—i]­ˆÖWŽ?¥Ñ´–F ôÔÙ½„Zl®®df¿_#ÝJX¤šÕ,MUÏúçØâ´ŒdÖ5†JÒ~\‘Vºö@æG%žò¾Ã]#ÝQÑT†Sä…ãTe1аù¬3ò­ëìlmÒ±ZDÆ2öFÖ–†Ö³¡êñYÍî÷$pÇÃ¥½!œ6JVüÈòÑ™dî‡7¯G(Ÿ—zF³[ViljnÞÿY%9w{3­ÿBXb¡ìóÂífÞ¿Û-ç~M¶\uygé;ÔÿÖYujj³S¦ïI¯¹·sàžYcµ+ä} ±+™J¤µ-*ž°7XûL-|?sŒð—‹q<»G±±Uº›÷gŽáÿ~ѲËìû,¯’‘·/ißfF~EÄÈmÅ%­érzÌ’ã –\óXÙdí¼­ž{zÞÖa®èµþ½%+…]¾¿a®oa¿C_5[Ѷ61¾Å±ÙÖÇwñ蹎§°öx(XµµØÚ’zV桾ìZ ÷K8«0Q| yÿŽ9¡׋ìŽ(Ù§^ÃÍZ“›ªõk衤ÓÕcYÑÓÄ×ÉZ0Öíî³ê½r¼­ÖûF'Ô±bI[°²6\™ÌÃïZ–ÑË+¢?—_]°²)b™®xkA ,²2]¶í‚Ú3FèØ#lÈ×WºGK_{ðß"G@æÄ ’ÄÂ8Ë |Q'¿& Ó^zé}ns=ý/µm n›¼%Ô6:×4SÝ„Å ¢B[Aѵó3Q`O@º!ªêÚJPײíç–¬mg ^Ý| HçØ–Í–#·UBÆÔ}YáÇuQòÁº‚(_W9:÷:Ø,‹75²OJ^¸×}øŸoþÜ ¦[5?j³]• 1ªÕ{¿ð¦ïdufî«ô©Z{vw’G hl4-}hl¼»Sd0:Gµ½ËBÌmå<Ô1û²”N,ž8[yñ‹o®[Újˆ,ܳÅ+õ{Åìñæ°é$câ'C/G{d‚)šÃøàÈXhnž‘½±µ­ÓHw~µ¯ŒÞ èƒ³â|6b %•ÑÆ Ù,¸¨_zµÆG26ÅŠv g©¶*5´zZµêmvê´Üë,E¬§FŒþ½¥|VYgVç¾[ ‚hõP9í–«Ø´O$9¾Í<Ô)hâÛä^¡;K™8§–=•µìì,Q’ÅÉa­®öe²Éé½·¡tvõìªøbö(c©é£–½WŠu·ÒÓtýÉÓjì[Ó›aÙÂ#YY(û=Vŵ«ÎÎúçýmBžYj•Wl,kµMOj’³kë˜×[шÉÞŸN¦Äœ×¥ŠSV¼·(´º)¯ØÅvê¼PR}[6+lu‘—ŠÃ赬ŒÐuV6´5&tZÍ„ð2ÔÐ[†x™lì!tU}í7)Ìúö¢ûYV·Ò¶_[ÍZE•´u¤s½¦¼®Óë&´úÿc¡Z@®FçITµòìY<Pß± ?ªµ8–aWÚ"//‘Ca$N†MeÇ@ëöœçÈbt€3~MFºËýr¾¯U­t3þ{ÛÔÛ rǸÕS‡A+­6(ZÛMru–ws€Q±ÀGkÛžîï3Þ0Ý®]Û)§¦/YŽÝ+´ìÈÅÂ×­#­Õ¹3OoZœm¡‡2¬Íõ.ª²oÉ[kËél[$•nk­C šµ˜â·EûÊ1XöŠpT"µ3bŽ8ßþ¿ª#«µÆ̱7Y¹üǶYêÕÝlä}NõÜ6ôa±^ÒæËlÔž.µ¨Į́Ç}4ëˆâ«PÓ0RŽÅ=¨ì×E ßScèû&|QK-_²xtÒ2›}ÎVC£ÔJÈep¯,Z7ËöØ´ùæ{5òÅ(,‡«gtMu‰;’A.qcG‡€Bˆ’ë;½{/ašA4¹*) H÷õM^5ðÛ§×dúÕ¤‰×?µØ'¯mÒ oÔØèžâúì H[›¤‘±²(‹K¥{"622´‘;]¦3lYz ]„[J›ëS§cj6l&½ZÅ]Æ»6ק-}”Ðõ‘íŠ8£žFªöæ‚X÷Ï ދ붾ÊÓ«­„¬…õàÒØ}HÜs#ìÆ×¹±ÑšÇâl{V½¨6{d ñ+íÏ(9•²É,r:XãpÕi7mZÍl³Ç²gãD÷aû{‚Ñ’ôtÙn{¿T‹_ ûÎt“ZÃ^$‚]{Ž†¼6(HnÈ^"*¶ëCŸ3ÿ‰Ë®† ¹ÐÒ¹×W]4Ž×MF#j-q-š³_Z´qR«4/~¿s=–n)I¥s©ÍHÅè%Šœ¬ªùåØ÷±^­‡;NÛ}m½ñEî—×5nŒtÐÉd–kÞЀëß4Ðرs¬r—9ö$/p= žà›ØŽà¬ôk†Hð[Øž½NŸ×6[7Sõ½\5Ä2“,ms#ÖAíÊËMŠ­8UˆYÕùcedd}9uúþ z<½ïpÇBæ8èõ¢ÍÊ¿³Òd¶Ûj o§´×W¹<ñ—´½ÕtóZ{½Ÿ×ìK<”æ.uõ®Mb'zÁ”ý&i™_ÔbŒé›¡7²_‰í²Ú´uð:réÛ]’2Á?cªaºæty‚8äÛWŽ-uÿ$W‚I&6[|\·ëòDȽeøPín6Mâš¿°oØûbëç ·4ÒÉ$®?ê«rٔ镞É¡“óZ_NGIKE6ݬ4ÚEç@jzäºúðÏH:ǦÛpÛÜ¿®¯sÛÝÚ†Wif‚'0SÔ՞ɥ+-ËjÞ¡æ^ùdÛŠ; ;¹vG5ˆT“´Û²×O¯°Ùb³uZ_¸Ž´ºgËbÔârD±Á©œ!¨ò\è.X­ôÉ-XÄÍ«}ÂiÕÅý~²cc?¶FÒ{yËVr|9G ’;_éûiØí<0I]æ#sCæljÒÇP¼Ul$DÜ‘îd-”bl=§…„—)Ìa¯Ö8%ÿ—Ét oMF¦Î¯[›X­¦˜ØßZmn’ëa’õx]aÔÿÄÖ¡µmÐ4]3ê×™¿ëZö ¥ºCi³¾k:¼€€ºÂ©Ï5wM«„k·˯¥ùi‡¬WÕÜÅkg–Z`Š:šÖÃQÖì_¡Qæ´q¾ëÍÇÂLõlKª³}Ì|[§ˆõm·~…‡² «w·# RžÚн ‹h²äô‚ÒÕÖ‡ë{[ºÌ’>1ÄÊûZÿMºÑYñÅÚ+þø¬L纼²>v¿¥z·®Ú$JÙŽs<øs¤$=Ä–å¸4= v§0zÖÁÁžšÐÝnª»*W{‹mêÉ­GT[gb]šy¦²öÍCYƒ¤Â{«ulu]%®ë-ëeѶ'ÜŽ3fZmìù¾¢Mzç>«Q£mµÙWtòû ®mVXµFЬ#Õ=ÀMEí¤“K³1Oî¯W‹¨VsYqØ:; w¯>jºù,S”mv1½WÝ §eª¯2ä¶'}jÄæ9)ÈüÔ–7Íy¦ ô›v±ö\~‹’JçÓÖÊRgÚ‚ý†]¯ ìK0ƒsrè©.öwYŸ]O×/]ŠFÍ©„ÄÂ&ú­*p:½±øöªnçŽKðÏ3¬jdÙ<ܹr oÙÊb­¯Æs˜Ø5o¯;·šŽÕZ|ȽÁ›{ò× èðÊ®uÒÊjX]ªÕNéd¸\ØÊmvÉ®‰Ôf¦"—ERY«}YoG/ùτljî:3HúWZû¯)«<]¡ y²êB5d1‘ÓaÃ"µ´ë㻋ËÞ]Cit´ÅVÕõýqs5%òšý`ûD_‡R5ÊSþs±dpR›eNKMˆì‰Uoù;+8…¨ öZí™MàØ. ¾lÍTèâhoqÞµ‰*2¥(¥ƒg«ÖªÜ»ÓÔmÚqêŸAVÛ²{›6Ç ©bX,;j*U¥š ªØ¼éu›É«ì,îõs×­r¬ëi,lo´mv õ‹Éi®tf §`·vw¹ÀÌÊÛ)[ÙmkÈÚÅšÔ,˜ìÕ0˳Öu‹û Á¢Ýëóë´½ÐǬ3Ïi­’?¤Æn}r>fZUªÐGZ¾Šµ«3z†Í÷ýga­ÿª£ký&êõÛJ1îà$jëXn줆Üȶšë5Úé.:½Íu˜-iá¼ÇY³Oa_ÖªÏ sk¤³¨Ø^&8\ã,2Õ±kCZ(äßK,ÕuÕ›ªôcºÍ‹ŒõÛZ¡¦ë÷Ü®g†ìQÃ6¶«§lÇ;ä¬æ®:Ó®jª~ µb3¯•’ŠÚæ²In8¾ñš(ãî0ìOõÄYiï!+SU“>”Œ±.¾Œ6”°TŠß$Ñìà± éehŠ@ceVFÍ5«2‰l-¤U hÜø⩺–­µZÄ%”ÛN„Z ùïÁ-Û:ßË­j´ñM3GäÆêõcl-8âó^üôg“c5ŽÊÝ›5b»j»Ùzk6µl†‹wÕ4;Gm]1»%@ôÝØ*Ç7]\ŽÖéÇb°ÖU!­d¯º-ϸËVÃcÆ{:ð×öznu¯oeŽÞlŒ¶%{Š¢y¾X¿»$•Ò½ÏÉÁŠ¶Öó†¼Q± [0ÿ9îŠÔL­¤Æ:'^…ö'ØD¢Þ\€µ²Ù¿ÿqÚ­Œêö5-XÝ颤,Ôµ-:úÊ»f1¼Ö:µ[5e«¦•’Y5ÉeY¦èþ$1k5½¬ßÔIûZ}-$­pŠ¬P2jÍ/Ø͵®[ÖX¼ÍÄ,tÑÁº«z›µµ­Ym+=ŸOcU•¢ {é‚jP2È5föÊz–e«M’×db jÄÀØšÛV#ÿYíÞs]`kM—3ÿð={MÊíºšÈL¶,vôËw%··×þÏùêë|Ú·-YÚkx§’aØ: ön üö_µ>øä¡= §Õ -\ÍŽ-LÙ dðÉ,Ö>­–l)åÕ#­+`£ÔÔ¢$ØìªW‰ôvÅÆñ¹q±Æ×T‰°Šºè¶6ul¸ÝïY|ŽÚjï2ã.ÆÀç™]®ŠôξÚÔ)Ͷ-VÚŒ’ÛÔê¤û$œSk²€¶¹–G¸Èö5Ž•£þÞeûKb„)û>FD\æ•ò s˜š×02Yø¶Wi O²W:ùå§iVƒ_!¹,ÖÝv†ÞIã.½>Àý°/gоãhïÿ ”6s?[JI&’…ÒR±FÄ ‚jë79õn¢ÉâN×ë$ò`½>¦Õ¨!færì·+æ­‰¡®Ç¾ 2X°úŒ‘{ªJÖ)4ë_3gØljÐ46•ïº¬ÃgÛkqmÄCœêñÎcõpö~Ò¥¨µ¯}…­€>·M&EØßüôÝ$Bɘ³gÖxOý—‚Öèê2=uè1$U†i#ÿ>ÃjÕ¾í¥‘bÖ¯KyÌt:«²ì¨1²WõùÜȵbÑ—ÝØÊÙuöYCdèm\xi®K,cÝlŽ³ 3ÝöY(Å,fÜ,†J΂HÝ%XAV žx-X±NìÏk‹˜Ù¥iÕº¼•!Úí£[²˜Å²õ˜g§{Ñù*ÕtꞯX\#¦ŽMU9¥·`ÀÑ3L–£ØPÛ‹OeïhAÀ‡i"Š3^(ƒµÆÖ8ãîÞ°¼CÑJÜí ã³\Ö5¯ËŽ“Q Û™-ZÔ Èufœ»­he§UÝ®Í\ßɉ3o®“c»ÓmzõZV>㥯Ú6AŸ¯ÔÌÆÛ oM;®a,sݬÆ*[‘r\¯gi¯¶ù«ß€þlü¯xµ” mK¶òš¤K®:½|[½R²xd–¤Wÿæ ›Ÿ#-Hɧš¼ÖiRxµV»à4å†(¯¼<ëê¦h-Ï4ÄW‹Y³ŠÜ°ÇÝE\2½Ë!1ØexM›-±5ˆÙAñWeA Šûª\ý :ÿò¨ëš=†Ý7í6V¬Ã%š:û[Oe¯°¨lNªXü{¶`ÍbizÇZWºW;fÆù$‡g‡m»Êþ®ÛèÅi‘ª*Œ¯mð}QY¯j€ÚɲÑ{~ªH.رƒMÒ5ì¥%¸b×ÌèãÚ<Ñõÿwu-„žéPÇ%Zvi 6¸}‡7I `b³JÍȽVWÑ«&èÏ=‰ØvÖaé+ ÐogË hah¤"Ö*JK‹±ka‰“fGÏ“/W´‘ c$ƒ_ªŠC CCX+ šÌõ¶veÔÄ[²šôUöÖãxÿ>U¨}«2¸Ö—}PCQ®}M=WÝ}­D•ªØ؉¬K3ß­Ó{åÏ°¶kî6(=ñmêÖ°Ê}Æ×ØÁÉÿòý±FŸÿj¥ÊT¦|”6V¨Í=6¿iQÌmqm Œmfâ«n’ÏÑv¾Î‡Ñ~ÜWØ÷Ò­,7tzï§héb›Hi^{ZIe–­J €Ñlls¤$OP1ëqµÛ:1ÖŠkâë`Üȶ®{¯«\Ô­²¿4Ú÷&Ñ馎µ¦–ZÀxqceØiºkBI~¸Z-Q«²ˆin­3G`ÑɯµvW§}x¶»5 ve‰†³ÜiÇ5½›ÈŸ$QúÜ|:¾œS±´¤¼nx­ ]wD¾ª5íÕ‘^ÅbÃ# –*–!|sz쎊å½äG²Š¬BHœæÙ£;çúz†8°ÈþÌkrà;Hè‡×öKÌDÕdAÊæ´Ç4á²ÇJ[²VŽ í·i®} 6 ›ŠÖ"°Ù¦ŒÚ±  söCeìþ,+MfÈü‹‹üÖ°hnkߧÑÜÚÀËÛØq&îX`£vîî}%‹zæû˜Z–õÈÝ%ÑfŸ©°2ï¶DmÔ§ÿ–F ;i‹+kçeªý®Ø½WSézœ'4ÙTAïÜæhçÏÄ6d¾×I?ÕVØÙHÙVÄŽ:×6`x|q‡É3dMbY*>žÍáïumµ*ÿÂH{¨G 6oõšÀçQ£í’8íšÛ—@èMÛ1ë·Ug­s[³®,l,Tµ¶§ë$;Ú)ozV÷mWe´»%bÛ{(©ÚuæÛ ˆß‚õm•Í`6®Xui*ìæ–œ—fezNs_i¿ønBá3XL³ÆÖ£!뮊YÉš´ î ú/Ì$ k$¤%²é^bÓ]2EB¼ßsa²Þ±M´ˆ29Ã\úì"´,–zvu&ÆÖëAªøÞߺ5Ws —1د%-½®ÕÍö6t*ó`ÙM[\µt©éìêîÓ¹Vm…YÙ¿¬æ²¶®8•XˆSGZ½ •ÜL5ãp±eòS–„NŸGVGµl5'Ó^‹Ý"¯e–)mtÒZ§®ÐÉZÕeÓA:ñÓdö^нΒíMç«C5˜%ª`š¼ÕÞdŽÆ»XÉ&ý¡Ö­:j÷úþIhLæÆÚWjF¿×³k^È౪Ë]ÓMO3VÚI.»ÕSÑS{"£]£kÄt½†ƒ4–®Üü±Õ‹[yŒsä|SV²âø¬U‚Îêä2Âø£Tž8¬—êbd–d°×Évµ½ƒ(Ã<û U=MM¾£bû7$õ}\Víj¥ŽÌ³[¯¯¯¿»h2X5×ö[d¿N':øüJ¢k°DçÁ›5¯¶!ª‘¯—>¤˜•:&ƒ ®ikŒ?ñ}ešØ–ÕÜ6zñvŸ¬•ç¯N´Ô³Ê g]¸ëó±ö˜Ž¶XÍŠB9c‚p Ÿ±‚ÃëC«ïvK_?ŠÅ§¥ø3Ö`·^íK•=‹ì?ÕXñK׃P±%¦û>­ÇSM÷ÙWMoU¾¼‚å»8] Œ–C)¿l.û~æÅ#MK°M>­ð´o¥TÖC;+Яy¯|ðPž7jlŽóoÒ¯ù5!5ß+œÛ¦Çxk¯AF[[ˆ-Âʽ_ºŠáäúΤÄê²±¡ÛBÊÍò#šä©O[n¼‘~yeŽ 3OÆÄ´õú*åÏÜß¡´Rí6"üÒ>ÃeknºθùÛ­£°úQ6m•]yÆæš±¾êËž#+ê»jX¬,P"›N'=•Ÿ0žJÓmb‚¯°è˜E__tV4ÔY40?[K_²š&ìz‰Ÿ´}­mmË›}½Í@¥¾Úk«™·ý{ìp¦í÷õ}çÔt:étŽØÖ¿î³&ãÑõº“uNlnn¼Ö‘ =¯|$3°=Ò}Ny {`„µ»Gâ@'†)B¨ñ;vHæEM±@þ8YgOmØÙ°a¯4Ζf ñõÚêñWŠËÿz„/—[-­ìt>¹nÄÉ’@Ã\鵶•ý%gU²ÀýeJÙ&Ž7 )Ú?êÁªë#D µ#c¶4~ªµµó2Ô2I$–m°èì°ÙÖ~…Øl¨{_¨ÝÓnYj»ªúlU*Å´Þ6¼íO†[Ôlâ­­ÜS/ØmàìÖFÉáÚZ€Èéær£Nñ’<d¶â܃%†ÿR¦ù©ûF«Øh6†ºÌQZ‚VACcb´tµ;}õ‹Zíµkqk£k®ÖÖZ¤»+”²ÇÒµ^_Å ž…kwg>­é;-,sÕlril؀©ÞJzöR…šÝ.ÓØ.lô·u£bçú‡9ÓÙ©hV¡4rǺ¬*ïnì.RÖnÛ:Cí·¤ž··‰µ5÷35¾Ìû’lµ.IWO¥¯V[ºÊ{'Ð’Û5šÓíçöÏQÜÅp^õÿ]š{1ÑöͽP©{i§“ÕöpÑ0A^Üúç“5a˜ÞÅŒ³MNËXjZ‘Tc‹l2¼Ö'ˆ¶Ó új{ÅxkA]—$ccž{8¾ñWW3¢³,pTµj&W†ßþ %™"t®‘÷ µ%jß“}Ɋƨ\–of×]ê}Sw«µ-bbO­â¿j–4– ‡Ø665»m/²Ej „LŠ»dÜ׎=B*?±5^¹R[“Z7õ¦)꟨}bå/Ú¯›ê–é@ÊóÓ`žŸ­×¿k{7í¿cš/vÖ{²zýÃU{µƽ$·×´Öïmiè½v󶩬ê®û¤S‹×ïÆ ª1½´-°×wÝaÌÕí&Š&ÀêÌõ¿tÒV[;ÍíÿTooÜ÷ï×;_ÖÔ=jÞ®%¦Ò~Ï‚¿¹zVÆ­oDôcö;žÿê~Ïè¿]5Ûgn}’¦óÙ+{w«EÔ=ƒÕý${ß´TŠï¨{g¢IR·¢ûÕÒûªiýR·½î_ Ðz•ÿd‡C{u¯:ÖÚ=†”zåkuoúw²EZ–ò} í™öm–±¤Ô˜,Ô=GÙlúÃìÂú»{O³$‘Ó¿¨ÐztÛh£,ôHYgi±ÐJÓ¿[VM”1Q¥>¢ H"ŽE7Y½’! oî´×¶ôõvf:>Áé2êÝ£²AkY~ŽóÙëºæÊío±úsžÏV×W¥¾´\™ê6^#ôIžÉýFJPO{ñYÿ±íC6>õ-’=•‡SÒÕkzGWcé=¶Ûu;»'Í1˜‡ºhk˜ëËUZw–2´sÇùP+vlP’Y í­x6~¿n}îÒÓd’eλQêÖ¯Zwu`µì‘‰6š–”.’¥Ôu*lo°É^÷ª{ª[¡îÚ}jØŽÅÿw÷­}oIÑê=ÇØ¿gþš‹Õôi¿×’ë4>·vžÙû¯×~㥡£ÞÐu/umƉ¤’(gšÛgÔæ~—jÚt½×ý‹õߺÖÛû¿ëÿfõ9(ëßõïacEg¾kU=›úöÔ¥K^eõÿa“ðöžÍcc^%ïÚ7ÿ¤.këúîš:ZšoغouÝ—±úo±{/´í½ÂÍ]ö†¿u¥l«è^³Ún¿`SÕA²ôÍŸ©MëU n\v‹÷Å}Cý^žÎ!ëß ½‚ÿV~¿õúv½‹Ø=‚í¯aô_hŸG¥§í’é½Ûó'×ûOªl4¶}+Ø©ÃKÛªÃeÖ+ë¶SÅÀuªHõÇA:²Ó«{ö—[fhõ*ñ˽šÿ¢jí>çëÛ™j®ZØÙQ¾xjŸ0Áf­]”=um~Ï×w¥÷/g¹NŸ³úÕ½Þ«uCv:z}ººu&ßß„û?´Æ¿öÝÓÏzÚƇì óŒ±ý©§ÿÚ>Ø ±½Ê˽‡e±Újß ‡íÃuÔ„R˜¢š{bÝ@jOn=¬T’)˜èösŽ¦:o|OmA%Šßm]F½ÕÛeÌ`üÇ«LŽ7=ñ@½’[47t÷°Ø­°ÕÝÑ_ÙQ¥µ×j(l(n½æ“lê½…–j/¼[¯4mkõõ.oc·ëûŠõåŠZ:ÏlôçÖõ¿×,Øýçw°m¿\ne×^öoØ”6>« 4÷Ñv·cGØ —Иٽ{Ú5BOM¥dínî`tŽ£6ËñéÚÛT»ú]kßnOí-üÈ¿'Ýý c¨ö -Ÿf½MÛ ,’ä~éé´; ªÉcÕ}Ëõ~ï×iÆé©-βOZõÏF½>†OÛR¿èÿ°utõºïÖ÷nE¸ö½Þ‡Ýÿ^û ®úVÓ]BÝãö§Ÿqµÿ(Kz–¥ÕýöæöOØõ^׺µK÷+{@ÉHwè‹·­ú÷¯»aZ¤Ûw&Ò{ ð´þ©Ku´æ=¿êVÚ´ÓWa7»iím¡–ƒc½°÷ ¤›m¥›L:UŸ_¯cÙtÕ- ôÚK:+:ék:Ÿ¬U£±Ô²=[}ªµZ¾«h*ëî_WyžÃ¥k5ÞÑ¥€oNŽÍms´Œ¡ílõ˲¿_¼±º{bž¯Ô=抛k¾¢Éèì~é·M½v-¥U¡ëúM5¨.ÒÖk›¨ßkuÚýÎëi³‡[AÒ+þ¥4tÆš&Ép>¸§/Ó$­}‰^)ôöÍ®Y±µ¯¼ÿ²ÎÖÜ‘jàº\%–FGe쀗>/ýoh­Ç;ΟOmË`Çíöü5Û¨ö?·Ô?d~¯Ùú¸ö«bA­öïÈnÚ¤vµìÖך¿®TŠhýyÒÑõÝmˬ¿¯Õɱö¿Û›MuJPíô”42U¿±½ë:Ön=³ÞýÊ„ÛËÞ¹µnÏm^{ûm”[ÿe÷hõuôµ6;<ÿ­ôqGV¼ÚèvvÿeÝÓé4~Ûf õ¿ÿæd¿¯ö_nßè[ûNÖãY²öŸØߧÝk¶ÌŠ}–•û4ÛšÝÐõªm×zžÊ¦Çyé5¨Ú³wÚëW‡Ò/¶Z³þ¾¡4~¿îL›V®ïJçê-ûŸí¿44Ùúëöw°ÃOÕ=õM–×öéÖ¡ìú[ùýJžûq7ìm´5Yê>Ón]Õ‹n¿5ÿ\¿\÷öoO¤fa±}n Yý[¯lÛ8?fÏGjuѶÞëÙ$©ú®Îù–Ÿ,ºçÔÖ>6ݵ££,›½“R‹Vêñ»ÖŸqëQ#ª‘©š l–?]«µ¢col+Ù«¥ÿC­}ÕóbײïO]kyÚúou³<¾·i›o`Ðë´Û-סéµV(zëÞÑíƒêº}áýéLÐë{Øóûžµ~Ÿ³êuÍWìUßSõ¿fuQÞí&žÄB bkÃÛ³HÆÆ÷º6vkcip¬Õì`͹°[0ûuê SH£š{@TuiÅƾ)?!Ëóï-s¤|ú8ï]Ùè÷,«èÿ¨,ïõß­½SA²«ûëÙdØè6zŸ`c=wIyãü¦Û›NÕÒ¯Cs¨€ïj·EzU¥»¥ô­†§Kckª}Û;ûö}mÞ¯¯³ìµ=V—êÝ5¿fÝûŸ»ÇKÚ=Ç]ú¶-l>Ñ´Ñm}÷Ù¶û]½DÞÇúÑôë»'II£E¾å²öŸ^£®Üz•©·4·ÞÕJ‹7léêé=sñÿWRt1ÜudõëZè+Q—bè ×êM¿NõßV—M{}¥«-`õ}ÞÝÔ*Mè~»ôx=ÊÿíÿÔúÿY?ªµm§¯÷}Žƒo²öèô{ÁGÔ}[S¹ö_^«ì^Á ¾•­Ûµ¾¯ìÚ?°R¡êuÚ×4•¥Þ~ÄÙû’·«ÞUì[*-O´úw±úÖ»×,é±l½6=½zÖ*ÑžY-Vn¨G0ÓÈ·Sn¼—«mìM^£Ù4S»–l»cm ZÍe›ž£þ$Զ߱¬[¯­Õzä{=>“Ò)ë¤ö‰ŸZ·A©ŸW°Òz=-oë{n7>Ìø£G~ÇìÏ¿u±Úoõöªz†êm.ûîQlvWÿglå>¿´ÿ ÖÒÌ7Ëì6k7SS†®Îݘ[mæ½-ãIvBñ–+ mxš ˜faU^Ø\†:3ºíͤÓÏ(ce•Íèê[ ¶¹2*VèI6ÏÙÝö£œÉ]šiœí^ÿiìwµÞ—íšo^ÖOïÖ´Ph·yµŸ €kC®¶ÇÃÒÔ•éWž;6uô-ë™cs&ÍÆ ¡þ×°’3[½ØDÏpßowZ­Ìº—车·[êÛ wÚïô [ÚWì™dŠM}Ï|±VJÞŤŽŽž=Û"õ½¬BqGGî[G×DGܯú•‰aÛ{$ÚïW„ö°ý—µ¾M×Äh¶ôÎÐÛC÷Øvowûš’Vµ´Õh5²Ç¬–K™?Zûý‡YýcïÃj#IõSmDŸ©nÆbŽÓ6ÕÅ™mä‡i«×ÚAUŒÞV·™ý6dV­^šªŸýš÷I…Îwh®ÄêšöÈ!¿Y̱ì7!•ûŒ/±ÆŒ¯dñýLdB&‡CÇ:™v»Woka­ü—/YõÝv†åúîߨõ‹n¿õ´eçõ¨Híì&ó=‡×õãÿ|õèÔŸ²µÑŠ~ßOw²Ø±²Y³ísúñwí]ª—ö–è-Gº_Þí¶ =¶û}¶¹ÿ¹Jd¿ïR·Ôíû·ì‚ë­æõÏýGx×Mé·œ=V¤ÚÍLŒ\ÑzÓd–¯ V¥7ëuG»Û4v®í¥×CY—}lZe¯\¼ÚÞÒíB£f½Á[ØkA¯—Ù/É ýUB”¶¤ÙKªÖè­nfÚ}½ž]Í˧t[ïØû]u½Ï±6'hµž·ùïÚ…ßI{ }Ëq-þÚÍwTô›m‘¾ÙLÍ-ÊÔ ÔÇRÆ«&¾ ¿ll5Û ®Úg‚Å?`ž§á~ÓÝ{ÇÖeØY}f†ëÛÛF]ìû®ŽŠ9ÙZŒñ<‡‰Z§ÐM©~ q4Òuš°X§cS<šûíz°úšå-\‘_2Ø€J[r9mle®ý¼Î¢uû ¶°÷U–ö½³ÅB´› úë¶Ãà¶+jNí~þg·7²\¥f†êÖÑ{—³m4,õ]ï¿ì¶Qû7² ÜÛýÔ•½sazíížžÞÓÞ·Pѽ¾õ;Q;e¹½!Óë¦lÚí¼¡úÍ•½~ÏÒc•teÿÞcÑÇ´Ù{¶Œh=µ‘¶jôÅž“;lèžú÷•ÿ.ß²úŒ»ŸQõ«IWÕt»½®Ý³&ß׫K±î6»ewu²;€?Ìô­&ê=O»úÎÞ®ÇÕuö`×þËÖY­²Ýzî®Ï£z>¦þ¿{¿ÕE=êÕ¯?Y¨ÖÜtVtÛ0Û>µ·­ô¿NÙiõÞÅèíÝ©êSU©µ©®±RZ))Ò×k¡,Ñil¾o^Ó¾ ”õÒRž]|!ûFÍbí6]µCUXÙ˜WuËþ—£•Û- ݵßë@Ù6» ik¬Ts¡²ß¢&K³¯^Ä»Ú,³¢Õl-V~£a-¡Wè«4újÝ«UµÀ‰Mt¹•ï›[9D±‰Ã#|1Ëz¥HY0A#.–ÃTìg:•ÒȤ†V0ô>-q×ÑõvV£¬«jy½¦™¹¹JiôÔ*>²ee÷õòþ¸Ù>í?jÙ^ÖÞ³£}…j6µÛ]5kš»ZG¶c¾fݞǣÿ5º ô÷«[õûóH+ì÷MÛÁ[méÖ¥­ëµª³k)ªÏIl­îúöZ?¬÷ŽõȤšMŸ¶ ˜³èç[uÚß{õïF½·ÜQ»¶õ›†i6¶ft±¥°}{Êzßç;U²­_²­§¯%¿hÑ e_dýƒ4{¯gÓå³ ¾›îLŸÒ5O­©Ý~¹Øí&±èwþ†¾("¥ë£ d¦e—o,2ÅI*ÙÕëvu£×z÷Ð/é Pmµ4`›Úi¶(ìèj ;ë2²/dú­Mì×ûê'Ÿgö¥—gº|BæÚ@×Û’i`˜´Âà ÖÆöKG" r—EF9áºJÑ:?\ÕËmG¤»*Sµ¤öD»mÞº•}³ß°Ÿÿd€j2pé$ŽG™L¾³FÄ”*ÉYùñ@.Y„CµŽxlFÉ£Þë®tÌn—Wf[ÇYôÕ³; ·©tðÅn­Í[4gÙGdÕ†vF!ºÊ²MB)Û,6bdõ&­®;9î6í€bFdÆ©cûÙx͈V†…‹»+:Z¦§%M}ýŽÂŸÑ=–zß®½sq¬›Ùµw.¾_GÜN$õ/hl-Ð{cëú¶»oZ®Ö†êC«û› o§llÏ{Ríú¶žù´Öv2O«ÙCf®›föm}/hù}GUm•wž‰·¿oÓ°‚§ú“ܤ¥_ôg·Û³¤ýyAoÛÿ_ê·Òé½Ñu5húêýs"Õþ¿¬ê¾Áéšù$Ø~®–[’þ´|qûO­Aþé \}êü _ØžÌæØ÷Ob»Ù=‚Ágº››ŸVkæ-–›M~µ «(Ë&ªRû—i+n ”ÀL5éìê¹Ï§4Á Â9¬Öt¹$P˹«iCÿõ[Õ{ÄDßÏhí§Dgð¡dÓ¶ §®Öˆ$«yç†2'cu‰#u]iÔ½aô¨ÚÖ²´ó £z¿ùÒLJG¥}kúK, Ÿe€c­m³ìc‰Ñìãûk]»4ðBë-½ë–#·º:íÜ2HcÜ9–!Õ†G}Q¶'[c6´-×–É™,–#klÁŸq~õy$J4RÖ³ ÅV ›#67>ú’½•àµØÖ4g¦ïúKœ2*ÚˆlWŠÒš»®Ø°ÙÛ¿#X«úöЋ^½´Žx}:ù±7«6¾Ž¢ÃëDýòcÚúœAÛIcföÏRd³{Ÿ¬ÀÇï(Ü~äØFûÚç¶Ê[ûuóû–ñòiö D>Ùìåµ÷ÞÅÒý­ˆo®MN [zV„n¹M½®ž?©”‘jMxˆ’0!ŽG-›$´\SË|/úuOúªX–8è¾åº3k·tg|’_|–nleŸêÉjÎŽ e‚¤V)³I¾yŠÄt->k–•©%65vÈž“b*Á5)Yî@Y-Yã«°ß÷ZÙ}‹Vì@ùwVæŒì®0‹îêÍë_=èùd7M±•í»b¿]¶–¼Þ·¿¥°§nœ²R†ýHªìuZm«·š›1IV±CF*˜üÈè#¹‰)6'E%{“NNÊhëÒö›5Å×Ú„[¿$Ð5ÚǾ)jÝ|b­æÕ±BYen×GôK^ÔŒ–Û*4ì+ 눊7ÉZƯi†Ñ¢:³Nè¡´‡ý.&:gÆæ¶8^E-|Îq×®5ÕÏÜ$}x^ÆE°1¯ÍÚ(míÞrR«Ô‰†„n­g^ÈÄ5™÷l Š³C…­f厯caµ®ý–ÎÙÿN H­ýu,Ýnk ’5õ™Ž:å±W.-º÷:œ}ÝFÜ&]h…®Õà e›ufsµÐ½®µŠR,Q×vm«jC-–:9#sHŒÏ Únäaמøöì± Õû¸aÓìî٬ə/>¢nÁΖPÒ6ÏÜC¯i ô4ÐÞ©gfÊ’Ú»j8Û_sZØ®çH6ÅÐÖ˜’ÖÙŒ-åËM«Gg­qÿe4÷ºÕ§÷Í­õˆ;Í¥ž«´d§_ uô¶k×{6 5Ùëû7ýZ?muZlÛêoE°Ö>8õ—¦½ Õ¿ Oj–˒ׄ>'V2J¡’Tû!f¾oɳvx%ì!“:˦²=£Ý÷k6nyÖlëË­u‰Þ­l~¸e¿ã´ÈI©y`–0Ú’¹`’»ÊÑ6äó})ÊáºiÜ5Â2ȤêÊ'Œ×j·O6·wͳ$š µ{m []ºíPUjö6k½’Ô…¯Ž´nöc¤ˆ9¶n0I%2²Ó[¢ÏÆßêÀß6ŇMBËKk³Z"ŠÕYáµ]š´]'­6TQõnǼ:šaÎÕK<_Jé’Öéé㞥u¨“žÛr6zFÜ[égšý]—{ógsJý™iR³Y»vlûé%Q¦eƒ-Ÿ[ŠðÙú”µ-ê5óÕ}Ø[#mkó5H5f¾bŠó65ßN¶ ŽÂû«èý–ãéXÖGr»µ²Öš®ÂHI¢ë0ßd­; ìÌÓ¾ÝM§¦²«´r*z³SõzûD¯¨`ƒQ°§²Óº“îOGWskLÑ“[½Ž%²½Æ®ºãëÉëÃGXè5BI=£Ùwt¶Úêõ6#Üô·bµ·¯=Ùö5õesžùf¯$sìåol±Õ6ô­-—åÿ¡y“G=Û$AzزÚoÅL¯aaknÍ1N &ÓâœX…ªµ¯®;Ð5õÉš:®a‡am †`ú6ÚùéY‚¤°YWëµÌퟫ«#íÒ²&“fñNÌDý]ûÒЀV‡ý*ʼ„>ÝW6Íÿõª9òŵ¹ XílÚÛŒwÚê Ūô€—cm­›{#$ºÿ¼I36ÒDf$«^9¬¶Y/Í^´~³=[;è¬ûuZÙ½¯Ø4RZÞûsGK¾˜Ç°o_gm±snlÃ-7gWkNGíêÃ.·sa¶+Ëä‘õëK ŸU™“®½VÝ\|O¡Qΰ-¿ñ¬ÙkHÀËõ›‡HøcQöZw­ £‹HÈ…jñÕPÓh›ò¬Õ|R=ðý“4Ϧ¤»Ȩý“¾•ibV}±6¶Ôqz%ˆéEm•ö†¼”lÎíÆy"÷º"•ÆÍ,ZöêÙ`Ïa¨ù[wÖÕÃ_Þ+ÇïSKtßZØGNÞîÜtžÉE×·ÛJ—n5QEe‘J,E.ŶaM¶Òµ7¦)ñHúòÖ}¶ìµ•âÖGÍŸ](ŽÞê·ãÙx|•+Ï#UÛŒ{d™î³­Ú6«è\†Xþ¨¤'C ÕU²é¨Ú×Y£r:دr!†Íí¤±»[RËfƤگ X¹-[UíÚ¾6åx+[½ :…WØ.ÂüÍúõ›G¼E콃zlÕcÜùéÞ‚°†õimí6ÐR¯nÄ“W½ Ž ÙMÑîöBZ›Ø|òÅ5=¡÷eö)->«þnÂ_É£VpW¹þU‹Û-%Š?‹VÄбí´è ­x‡¾S2·BFªlŽ6:i#ya|/¬Ç¶:2Ë JÐV¬ý“ûjâs(ôe‹×½ÓÇk¯…ïˆ[j:_¢9'©ºØ†Á^;©ªmƶBý¾Ìlu;*Ör¬²ÐlSÕµX‘{\øÞ!§¹?É©bœ´å¯­×Yž¤´ö{Í‹uuÝW]EìíVú®ûCkEµ¥;_²*Û½c–Ö–ƵWê!×zýâê•·:Í~§Ø776WvûÆ­oeµ,o’)ß{y­«z]­K§kZÍ‹”´å¯«;cU6-r³R±•[=+:–¾fйô¶±Ú©VÖ±ì­L~ÊáÌ‘¢G¼XÖíNÜÓö}[îrl¡îm­ҥ,O±$0nÇÁNƒ®JYV­9 ³$Ã=v•Ý-nÌ©òü‘\†Ŭ¢½+ïa°è¡ÜKÕÛži÷ï«:SHÓn óÖ³i‘¾]´A›{´Úm}£‹êëŸA¬Ò¸O~J.e{ºý3ä»,UàÔlÚD¶Ä¶gq–›ÙN:•…ñÅ ±VÄÑ7_ Ûj›ŸcQ^¡ŠÔ,tv¢…±Ã3ä…óºW¬9Í\¼m'–¾Ã]b£)Øl• Å“,ѵ£|ö=ÓFÆ8ÄóTuº6ÇÞ×Øl×-G×}y6ÕÜmëµ’°úûÜ+]›ëµRKVÑO­mj$ŽÄ­µ0k%±î0íÛ]»omªØºHývK[ dÕgk£ß_¾il^Ö¾k®—Y¯×T« ”lUJõêì š_O|,ŸvË¿íGë4,Ë_O^Ä“jã…–é=Õ†¬¶kS†Ǩ­5/ò%a×׸mV&í SǼ{j†²ùs ¬Ö8f®¢î¢ãìmiÚÙYˆXµ®šY÷KJI NǽížikÏ_e &m¹Z$³6ß^Y¬ë›±uúÑD$/s$ÚG ŽY&šœ†¤;¶:[U´:v¶yêçý‰Õêb³g%ª”l|Ô¯V¯6ÃØã{,Ç%6÷/í*Åz¥zSÀÍ®®Í¯Ök¬ŽÒ”›~Òع©úd‚{´u²7^·fjÔáŠ×a™>9ëGooÃtë -†ÂÔ¾•[©¥ÕÓžýänXß½·šÅ³’ÌÚ«ž [s¼Ã´®étö-QöU>½iÕ'ÙêãØÔ§FÁ.¢Ø}Gë*êç- ð°µÕ›ö¾(á"[6lÔlPÛ•¢jpË4OØÁYCmϳ ±‚ÇI4ÁRÔì($ž?böØUŒ,u{±Kb+²ÕfªVA_TVXÍ{iËÑ –¶Uµ}—ìEC^ ÖNß¼ >ÃøÖ¸ìE´t±Aþ­…ùÙ¯bgCy!ºÇZ.‚¥X)GsV×Ôšå°»´hÞMr8êkÜø¶sÞüé*h-`g{¤­°cTWËœÝEw‹ZË”§Õl≛x)1¶é¾tÈš]=‰¿ÆnͲ7Waõìûs¡³´©¥±{;6#« Ù1ש%©r?k[BiY®ÔÁZ„÷¬¾-N÷_¸›wF>¤·Z´[z¾ß@nR‡k —Úô¾ËaüsSqNfZ»ZÍV5æÏ,Vjn™M‘Z•VÙ2؆Íkóêª[û·®Áp}hMa…·Ÿ†Ù„™ q·a¬[Iæ–­d†ù3ÇFA]æcû²Ca2Ó…†NçCRàzØ^sbÙnjÁjxb{µìdOoÓVF‰g¬Î½ r>ÛYûQT³1nÊäSK#YQŒš(Ù±¢ÇºŽŠÓêÉEôäd6;ÚNf-í!µ+)¸GbÕ¨šgÜ}bϱÔ{£ö+mn¯gfîÎݶi£’ygÔWŒË°‘ÅÚèkÒªd­±‚Võ½åX5#û'–¡ž†Åöi\ü)·›&Ú²Ë3=Vµ$ûŸa𺳠ÑÐ2ëe´õBä4âÙlæµ²ìˆ%ž 5µÓ¦ØÂê5Í—O²¬ÇÓŽˆí ³TtRÓ¹¯ÔX­RÓÌG4r’Ò[bèþœ D·}~j’SØ\q¿z+Š*”¢ÄдX‘ÐÖ·°Ãv>›hlLïÙ„Šk,Ñ|[fÙôˤë¿ÐÒƒì÷¤®ÿcÕ×·BÃ.k÷´MýˆÑQWþm6=-@¢5žÚñJ[¿©”wf˜‹s¯{¹“¬“Ó™ÑÚÕ>­šQU³-9›Ž­eù­×™ ™Æ™°ŽÃß¥í§ ÐKtK±vä13eÝ´ÚT‚‰Üé.¶:vªÅ ÛQËõ¬Çi¤ÛŒJYe’†ÏZG lá¦Ä=…».‰õaØ[‘´5nÄϧ\ÇÇ^¾¯¼3i`-ü-” †_ôå1Ý•±[tîbŠ¾¾yíKRõoªåfk™bQþ¨š Ûn꘰Ž¹¢Mb¨ÎÙ †Ä3²ÍVÅ,7^cdÖÚvR½ÃNvmv k,²WG éŸ; ÿ“^ßÕ!–ÄKI9tÐ]¨fݶ+A^‰¥’¸žÅ¸DöÜ÷Guó]–”ÐÚfÅ‘8ݯ< ÛIgmCêºlR’à°ÆuúÝ#d7éÁkor;‘Ë í}šÙÝÕ‚ÇArFG±í‚ÅÆDÇZ²$eIëÍ'·i«Ú•¾•YÖ õ¨j×ÕZÞj›c_íp}¥.º›Ò¾hcÜ=÷4ìÚ¼Ô‚W4ܼó6„Óì=ˆG4.£¦p¶Í€§[a5xf¸ë­–ÿK¸žËPFø­j*É.ÃIN´–h׎]Ì¢8Y^ÉcÌ`ÙDêõç ;(æc¦ë=y%±9±f*3O;¡"›)m®Ã$W¢²jëàc.Sd ¥r³êC#oÁ#MvˆÉ·ˆ~¬–çLû…NÄs2«`%¶>é¯ÎiWû¤´C`´é)YŒ:Ïh%­n´ “\øºm¬I,U¾ë¶&£jÞ·9±é"×Ú’I6°ÊÇ‹Î ×Ýd.’̉–É3I4qÍJÄÒ×d¬tôfc½b7?e«’¤wb¬iA¼du"°×ÔŽkPKZü³Þ¬5Õ.°×Šì¶ëŽë/ZÌu÷ͱžA5j7 tÕZÚ²ÛƒjUSb'M´wù›uÏTW6]”osŸNÅ“¾a›k_ðª¾{2E¨´Û;ae±nK&È¡Û0w|³úÉÑx¨?:/T•éõö(¾Ñcñ ì±árkšÇ¾‰™ÂˆT@øWggxr/XC‚øŽËÅ;­l!¢…Ã^µY¡Oû–8±^¬¸L¡æ²äp^úÔÊà­•›æ8Åh¼ÞÊŽË/±@¤ýI‰žÓZŒElQ|âQÙ|nÑE GËKá"ôØŽã(Z ¼^¥À¼\a”Xù^o* ЋËËÚ¿A­îô¿±O|«*1ø,e¡ð/z\€…%·)F;Šz"#/eî.=òÜÈâYbÑ|J/ tw…‹Ú¿Vz&,)ž=éQèOÒ\Y®•±z˜ã¢´. æÖë‰Ð°ð¤®Y{µh~´óbÁpIGÆ`½pP±yzß úÜS¦Ê&ˆòö‚|½”‰Þêj½v=K6N‡ï¡ EŸ¯ñ,Z^Q÷Ïz˜ãJùÃ'ÎgõehZ?ø‰ô(‘„O¹>k©>P(•ñ!Í/}=ç¼"´¸ÜQ¦ô>BgÊ?´ÿ‘Ô•#÷:ÌÈý„|ˆB™ÙÙÞ›ŒVP¶è™‘Çxb,¬Ad“â‹Çà¡áÉÆE‡#eü‡%eË¢¢‡0?ˆdˆsÐà¢ÈˆÏôÇË'Æ:’I<Ñ<Î.D¡8/lq‰–|Gzl¢Ê/6=”(#OßÄCÑQ3$ù ì#ú“äDAù‘ä>æsB‘GcžÈƒç‹±'Ä’|£¢dr#¡’þÄÆQ]“3ˆ*l²ú‚‰¾>3ì!eaǶ‹SX‘“‹Äb¸=eF'ï$ü¿» ˆ™ω3"‚þ¾'ÇÇÜ~0üËt~ž¼Hÿ+öÂòr?)ýH?ãñëÂ1xr| r(þ"ã²cÈÿR ùG¹g_´á”X½‡J‹Ü¿&= •%i½5©3õœøD"àDÌ…%”1ùǾµ›* i®&c¡IBÄ—Þú–~K­5…ÃëVhìïKZ:ž·k(enY#ñìSÞo3ÄÎ+~ðàz¬y|>õ<,^+S:'2ô½1rkE\!ááeehp)œ=^”-L‘F®¶{;;;ghÎg,ÄƵ’¤HZÓÏz*KÙcÑ{oeì÷Z%â„D7…‹ÂÌâG؈Ď4¬2°ÇÆ¥:;ÅΞ¶h½ÛW.ðËЊÊÍæ ˆ‚Ž´vw³â~³¦õ)Åz%ïÞ(ïqò§ ;=‹)ôZôÛ×gZ,²³Öl^¢§*JàtW7­kÓVŠ?bø•–8öÅVŠ;¶"J/CܯBz/+rÄX§¢‹Ð¿´™}•ºÊIb>N¸kr½ Ç¡jbNÞlq—Í̈B‰|u¸¹ ,I bðó[¢Ë>R4!zŠÑ[.xV^/bö±Z^Ýâø+Ðl‰Ž³Zÿ!afÊÍã­‹õgÌB^kUj¼Þ§·\)™ô¾´V«‘Àäeah¬Ö«Ñ{µ³Y¢ÊÏà|wºµVšôX·V/bõVµ¿ebý/ÿÚ?ôµÂ|÷©•Ä\µ‡qê5³~™Eñk’µÏÓ·•éïŸcæ±îÖµëKn¸6"¹Ëè´Y\'ô½ ZVÕágóêÔ_é¼Ælx~®½Ii®ú"µ¯K­Åɲ¾º|Å닆´×Ò¯ëèëׯe}E[/èúúÎ÷+Ô«èªõkúZö_Ô}}!R>ei¿¢o+éWé—ôµåâ§ÓÙíè7Õ\’¡ýÏ‹& øæ(&}¶`—žô)ÄÃk³å'äS±d¯í²‹Â’gÆýÌGeˆ‰ö&UI2Eñ”D;¶·–1 cMv!ÀÅ¿{•Ù1ÞÔ)ˉ¢º>^‘Çíê{æÉñhù(‚á"µYCð¦2ÇÌ,G‘åã1d?ä)£åãíŠì‡Þ'Æ=Å=ø“$xøÂGìI[p1]Có…‡;/KÝ@õþÝØ~"Ÿ8ò‰¡À¼§õE(Ÿ&a1A0Ïùÿ³Ì®‡‡Š,EŠG¼5>PLLߎ+³åýÅöv6O”v,üÈ’TX…WP!4|E:/ ³[½aá±É3™BÜsØÈdxLöL>>ÅŠ&|‰"Oø#ĘòþDÆ‘^Ï {ÄAUŽŠ>pt)&}‰?AñsãäxÌûaŒ™á¡hzk„ ‘mkü³1ÿÒ?ñ>1ˆòžŸþ¸™ò*QAÏda–?å'ËÞO”ûˆ¬&DIEâ|¤–UçdÌÍ‘ ¢av'E“'Ƙ&d‰ÍÅ.3Ãä¡G~C™?"×ÑÙC>>‘± Ùe ²‹Ê">ØY¢$p9(©ÂöÃÓx¬Ñx| Ík®#ÊXè¡NËe•‹ËÒõ÷…šÅëèë=b‰ˆ´=Uî=Ûãw±y¬ttt=,GggbÐä¨Ùÿ¾dŠ÷<§¨Å÷…–=DzÇÊèëc³³¼Ùp8ŠË~çËËDɼPç’F‹ë µ)Å;&fY{Ï}përöº"1gtD}…¦ÉÄj­Rw›ÊX뀅;Õþ;:+_g{Wõ›…¯C¿I{ ÔkKõªæ¾è¾u}5eý^¶/mý |kç²¾†¿©ëÔ—¤­úúž‹l¯Ax¯úQÙÿÚ?‡hcÊNÉ%DJ9)òœ V°:¬xDfþ2l­º¤¨‘–ÐáN×ÞªÚh|W±ÒYçŠäÖº;ÎTÜU…ö ç_TõÇû:'ç©Ô 2#d7löônVßSYzôêq‡ŒÞ›ruÛàÀŽ«?V~èÜÔV5ë;þloÙsžšªmpY{‰a~[‹nHAx1(>¢†r÷8¡¥%K«}Du2¨µ¹ êÃi¡VKkÐGl«Œ,²žTxö!”$;x’sÙäV”Y@x,K¯@ áãòØ î‰CÖH:Èʹ¢Æ®—´íCÈ´=ƒÛ µÅ䬲ÖÃnÔ»£ü05BÂÄíAcne3·o©rÁzûaHk¨éŽö]‡´µ ?ÔÃ-R  Ñ$C4˜? ~8±‚¡šXˆ'¶™{•vsê!WÒzÂ|þljoseS4»uYí=× ]u×L?)ÛЃü¼sd/¯MñÆ­ô“§—luÔl$6¤Ãí‚[¹ë?Ç]¥uÓñËVêä2‹**î]a±èäUgìà Žå&OÌŸ/æÀü¾;®æ*…^wŸÊ`±\Þè̤(Ý"zÄ`KšÊž$©}¦'§š]He >R4ÐÿŽqï±Ë=ƒÚzTH0t#Ã/©Z9kh !v¬‡‰žã7/¦AÐO|W]A†ÓüqšÐΤúÐéü3ݺ¦© XuÜ$¯†o¬|¾¯û±H°+ÛbG‰Æ¨þ¦Æ“ùFZ–H½ VÝ€òs1UöŒƒ#P@"0R. ¬Ö‡¡1¬œzŠ®ð`Ço!ˆC’ ùeL ›Á `?Rè _·]º§O–t#v²AñÅep˜ÔùåjIZ™¡§æÆ1…GqÜC¼õõÊîàß·³*ä”cØGÒq«¼¹*X1– "N‡m!{Ä|1=<€ä@ÚÑÒŽ=–‡ýÁoZ"úC†. °‡å®•Âú`Pë‹kz—R=Yjª¨;¤¿p|0ÕsG;C.¤4ÿ†:Øg¡Z:FqË•ZÐÃÐ êrûib³K §CÞÀĉi'XðÄ£o¨É #Š€ÁõG_áŒP0ïü0Ý ×RqAc§XøN-šªHzkŒÖ;UJ¥”I“= Ë_‡k;T€Ü,25ïå–×}»VeWX ê#6ídJ˜*¦zür×›•ð'?iÃ)MEX1VøyãÝaѶ’|ôקu ´µj Nígá‹Îã(Álƒ¨+ÐârW²äM"•Ø=$jáÚd 13ðÊ­ôè龘ÍYj\¨ÓAÌÖ¸O!¦?¶cwÒ<2Å&«ñÀ,Ï–[O°¤joSMf®Rèã ‘†·;‰èqH:ƱŒÈÚÿ)ÃS?¤Žƒ¾¶lo—âq]}fuPc?¶ßœ j²™ß]”‚õH;J|Ž=ÆË[†@v­U‚£©ÝénÚgïø<½Ö•Ü)°“0uT'§’ãrOÔã"†ÞT‘Æ5Åä¬VSäAã"½»çºm[-G–`’zÌ`NMa}ÀJºõ1ˆ¶(±A Œ~YŽù±«N+TƱH®? ª÷x#ÓW ÊC)í¯¤ã×Bµ–ªî дvPzœ÷·;É ˆ IÍ‹¢#Î2É%Z5=¤ã+VT±Ôùc”ôÔ$¨í"øB²:ÃN`@hoÃÐÛë²}¸ ½Á9¶öaWQ3×Äe6Z7[T&胴t9¤bîqî‰ GžBúM{õÅZܪ˜xÈþYcZ¡ŸH1þ8SŠ6ߨ+°¼3q–§Vt5‰ÖcÏ,¶Ä>ô(èCGø`^Y*ÆvƢ˫­w±ô–>1 å|†KAYË “»bƒ×ið9]l¡HÆ{u[)ZCNšÙ°3=}PuÅu¯KÏeï†Ã!äDz{N'&À ê½Hî5V‚dªôíß-´’I‘¯ð‚I?H=5ÊY_y¼$tÊ3ppç“j®è3æá_!ÎÀ›«cä;xåUš¬2^ ÀÎG#rò­` ±1±ftüØ®èhm¤÷'/kT*Xñ·ÈtœV `:¨ü¤aWe€ QF€0QVÛ Û†‘Ö|²Ú·†z›SÚ|¼²µ ÖIéñËGA¸GF €×Q5ÄYÊc?nê+è€F/±é& 1ü0;ǹ?¨H턽~µœ±5«;è1­:«|£Äá5èNïòÍáˆB&Cˆ:ØXz|p8:Σ¾,lŸ•®*¸²·Û¼ AÖIÏœõÛŒDÜNŸ/X&Ç$È:c‚:N$-ŽH$wµ†ã[vŸ zý¿um˜êI8, ’ˆµ HôêUln;0+‘ªžÄ e…YNÜíè#Wò0º'U¹kvÁ€IñïŠü»B5P•+}@¢}_å]c½lu!uÕéUð·*æZÿne‰!b“8Îk5qÂi ûHÝ?éðÇNEL¶!”j|Œgi U¨_o(3J‹ÉòÎ*¼Y2X ÔémŠÇÔ7õ~SQ;ïä°×@J ýå´²ÖöýZÝAÂ;ç¨IT…L®ñÇG¬V€4Í­(‡å?Ž1R}º7Q眲²¶P7€tܳÿVVﯜøbˆ×M¤à,í"@Ãï jȇu™І7–W»_iÕˆV¦æü2¾'ÝSö–(Øo­v‘ª¿_›ÿ´s+¾ÕÜ1}G¬Hüp¯&Ã[üáСБ–råÙÀrUˆÐ>ç¸æ-EÃùåv©€üOÃJ£éd·rg0Bìo”÷0{emÈã­ÕÔC+°îƒ9Mœ+–­b ë¬.±#˦{V9öälÿ–{ ˜ÐŒŒP”~¾kåðË–½kb ÙTõÀÜBG,5ƒ”XHjÉôGá‚Çyh˜á•›B…@ª]Çc†îÿJƒ¨#¼b¤M‘ÜèOÇîõûR4U#X'yVˆòÀãÃiÓ\EäjË#n¢vÝñȽÙäYFî #,/<^{€Õº‚j°ÓM˜i¬(´zK &>9·nÑ×ÃXéðÊî¥KÕ°™ã–=¥[ú„?Þq ²ð Ðvœ³OP’‹pp.ƒµHñ9ú‡Ö« ìcÃh-o’{ ª´2A†$búˆn¨Ëô*5zû“ðÇ}Á”4GMŽoF…˜añË]Ûdxë¤õȦ·¶ÄÊ¢”ryD‹=TdƧí¥B-ì1ùLktÔ¤9ÚL´cö­kA¤š•Dí_§*4V$‚ÄHT˜'øâW\+ ƒtqzbû*/Nú `ùÎR©{vC>Ÿ#j*:š—ã3j.àÂCY#Òq­OPS‡¸òDzÀFó #QŒk ¤u:c×Ij[a 4Ú|§+m®È´hXh'¶4c$(LeMa7yǬèñúdt8]ÒU„1Å°Ê4ŒÜÈ0»{0í„L€4Äò¨Æµô`'\æ]Ç®·åÚ“¾Á,µÎ¡ñ˨ºn®Ke¬=[@ùg?¸Ÿ6îÿኀ ß6í’  ª¤´)f#·†+²ë ãñĤUÙébïã8ÔЫm{ÉTfJöÓÛ¨‡=A×QœGF’Öm° §l|.1¹a€W¸ñ'ÏÛú¸˜k¶0ÔÊV½d‚ Œq¤•u3åã9e©Þ@UrX¯Cã–z=$îõ1:Œ{BJ€$É&N£ªÛQÈ2Çò˜oJö «D˜£tj âñí%k'gÌ7Ú†Ô·Û¹ ’e‰2$é¦2²)­‹ºA;‰+¿ãk Ïý÷åRé¡Äù ” ½©³nž¥o—,b¡Y ­Š°×^±ÛLz€™s1í=†28ÜÊeA3ÓÇ ­`6‘  àâ܆•Ö ¬ÁÏØ]Èk9ŸÚUýj'F&<³Ú±J™#oFR4#\g,}ÇÕÖ¿4Œ[üFgŽÕq^ÑuPt×LG¬u>8}¤ U€« "Œá‚µ=éðÅ,vîEücBGǶòÃR5×l%´=t¡Ñ+c¹÷1¯XIxõÜÁƒ9Jì $0c.¥n ‘´‰0ë‹È7†çq^l¦ÆJ³|¾-›+,‚ÂC¤$ñÄ,G²!Y”믖'SÜ*à¤A ±‡÷T÷=ã{5Um0©#ãòÎ3"ïT2š?á›G)k,„Y]Á´=cPuÿN+0Þ€Ÿ,©…¤  Å®µ&&èÇËMhlµBº~,ö”šÔ…,é´ÎÕè¦77CX´O¤VL•>^Yé•Q«Õ{ž˜h-†êl$ˆŸ”þ9\Ùú¶’ÛF‹×þX¶“¾z|0îc½ (::kŒ·XBH2GË8Ce,¿¨Xƒ ®Ð{<ªª̬w,ž¢OlqÈt²5ˆa¯ÊGIÏeÁ^Mp;‡}zåœn–R Fé¸øxÊ«úk)XP6žúõÇãÙè­Œ—èLô×Aet HˆÐàv¨lc¦î‚|üò¦AµY6º4ø`]ÐPCA˜ÓLJ‰1ÜØIÚ WÇŽQ{بAˆ ãÜáF †'|}GËrÃ]"c\š›wr¢#jÊãüŽp¹KKYw2W•2aÓQ´c\۪ć0Ú VXT]‰Ð÷‘[ô\¬ è†{‹U·­\owfá?'ŸÃ9^Ç 55¡ec£maœ{µýp ôî1¸ÛB׸5zôþ¬ã°>èUÑÆ„üqfÉ%ý¶ÓQ9mFâmQ*è;FUƒ®òtŽò—[–ÖH>(dÖÕ"£àÝsØg* íqáu/aA¸½jOŽ-u‘¼D¡é®¸l}V³^pAºµ=OŽ®B°ètÏnÁL #HžØ@Q§Ç fw7A€©Nùe6¯Ùï9õ¿Ê"oœâ¦ÍòzÒF`P0!” „á´‘gÂC+|ÊFŸ†V8À.ѹ¦5f =¦†R«¸NÐGåÍê U“=:n¦qø·ñM=êžâ´Ã D ^?$„zYºÇH‘ßPŽõ!þà@ÓL¥žFÑøuÈ$… bÚ=MºzŒöØÕaý$y%s¯L!f»Vwž ã?N@µlb;ëðÿ÷v…´>Ò½ÌuÓ¦\̧Ûßú=ŒOðË(u(û&¶2 1¨Ä¬ÕÜA:½ˆ>9b'¯bÖ 9(X¬ê#Ê#U´»€‡ÌIË>Ùé—!­¸–˜–b§ü±øõWý§* ï]N3‘ ÿÊ;eü¾CÞ /]Òz.rŽqE€wÃê §CùpòR m´N:éc!1é?†14°öX€-OÔ‘Ú:9û›t“=@'×V-±t [´1ãÙéô(iC¦£ D‚D‚Hí•ÙJÙêb6džX ‡Rö3甽fatR|ÌŒ@FÞÐ1‰Ë¡E–8Ûum¬Hë €Õ›½!¼q&·°zG`{þ¬-uK±I]§ ='_<÷R R`DwËI HtÔb>±>,ŠÔY"OQ·ü0û¬5'Û^ºšfÆ †ÑƧo|V¤¶¦óÀ‚–ØN‡A9Ox~GÙŒt†é—~áÑadLÙfÊ ~À!ø‚—ˆÝC#Y™Êï±ý»,`R=CoÕ88é´pˆ51]úAå#"U@t]; # ¹Á±H–þ™í›Eg{íôFtË3Úwír»è="u†Ö°µ¡¥—üºe×V§ÛUÞÍØËÇ`û…õc©ÛL«NÒ®¾±ýC ‚%§L¨/̤ví!»ôƒ”ŠO·e,4ÓU=3ÙmDH8¤F‘ˆu8 6Ò:¯–Y[‡X Ÿã€Y\ZFã=4Æä^@{582íÕA튳 įÇ:–Ë›ÁNƒ¦€xçê: •bA ëàZ)]áµ1,½2µ{…ŒÐ›t‚GŒøæÖF YDk¬k€Ña~jÉDLI×,4•7ñÀäÖºšþ“ñ0]SÊÖUŒŸcÀ èfŸP 3'=Ò¥9]I]A‘‹¿Õ{&à:©ñøÝsÇЇp™]zøäV•-¤Xf*`÷ qR2)(ß2&%l)}›÷Ê$‘ÐLa²´5 Sb’cHÓã”ß´2=k-õç‰q§é$@ ê5øẩ,Ž?oB ºG‹,å\Î?·G26Ô¶=$ò9MÍÄßÌpZÞJØMjÊtDŽ³›ù$‡1z‹ôÖuÔå©r Xé°Ûrm>…iÚ[±8‘Ê[‹Éʼn¸%O\käNu3íµzÝ yúzáåÚ§“û•%¬X;\ùu Œ®ª¨Ä2ZKË+ã)äÞ§¼ù tÞ ‰ÏXœÕæÅbYXŸ× mfàtðË K(A$!ÓMDÎ5DË*[ÃðÊ´ ë#N‡YÔeL ¸H'Açp¤nPLSeCÛfP€{íÐœ*ú: ­¯½a  ;`Úžß!ARGå=çô&Û+0Äë¯X×)/ú;Ç¢ÒuWðÊ­ky =·Pd¯¦Ÿ•×dÍ›ÆqUáÀQÔøµ=FÝ'øᶢôÖÃÕY ¨ž‘ßL™NÑ¡#±Ï|NâvÁ×OÅ6)"ÍtÒw p…dM À×XñÔõÄÙ !tôë2>J‡¤H1ßÈ~9ÈænæñíⶇCóÚ3ÝIÞä3×ðÂìe˜âóíp68ö‘µëÔœ^W±`Ü?pÑ¢–ì{uÏܽU‹Ía^×m«êêÀª=3ˆ‰Ç®Æq7Ú¤în£kF‡ú["©RPµ5GÎWS?ñÏkßt©\o®G¤ƒßÅݱV/1 ÄéåŒņZÃÕŒuÀ«˜ÝßA•[î–eÐ&‡oòËE­¶Ú5¬;ÅTöá˜NºfZ–¯¶–4NÇ6o†° Ü0ê1©¹¶ì,µ6†@Ë 4ô±ÓL6‰6“Ó-³h÷˜ë:DgíHNËuÖBÖš³ JøˆWˆ¶¢ ÉÏ™ËßÞßqP“Ö2 RX•QÛN™ÊäØ?²`ÕZt .{ô Õ»‹¬.£U1‹È±Í›”‹êUíx ®ÆMÜK½»—æèË—(ökT6· 4˲ !—”Žç(äAö…º’: êü«#hH$N˜ü[ÒöŒô> 8©[À%W¶‰óÁµ‹*©khÞr<²À„®Ö•/ ¯m‡ÒÄtÐÏž{€À ÆOž3Z Sª¨è±À»‹¿>øó%—I9,z/†ä ßLZ~×À­P,=œã=•ÙUv ×oa]¶nzãs+hP5'®{\U!+щô+\¬ÄŸÀ`€K®²ƒøg÷OHéü°ë¹6©ÒGŒä5·®,ü§P xuÈ ¡×Y4×(¤zMŒ71=õ”0g¯BIÑç¡øå¶XX:l¬;±X†§a[Â&|°Vw-šm"Jtƒ‹].h'DÚŒzŒ¿}eÝÒIÛ1ÖrÚkp¬ý FºˆïžÝŠµâTŽ¤ÇˆÄE´ß@ ûš+ "TzÎ:r{—Ñcè70Gõe|¡ëµË .†<™S´ûMX^;@3 4b¨m7HÚ IS>8žÐ´ 5lD€Ç¯ÿ·úqHKX›ì´Nå˜ϹÒ7_Éf6;™V³¤÷Æ h~1;+¿H…;‘´ùJü¿êÊÇk† "ú¦"ZF2£ï‡79÷C Tuí¯LU ”ã-"­Ç]zΞy_íìf¼,Xç¯Âzç»}’ªzk‚»,4¬=LaІÆu]ëP;£¸Ý¨ôü¿Ž7„W×RAp|džWAZÊÄ.å1ô°×¾nwQbÀFA Hñ€Ç"¿ŸwÊ~¨Í#gI ļÞ»A: :GþlŽßAã€Çé“ã›}ÂŽ †4é®; aµ¿Qz¯«UÅvÒŸ‰ŒÝbþ¥fUÀÔkß ûK=¬gÇNžy¹G¹Æ>â ÑÞFYgû¬alÚ «1ß-¦ð=åRQŽ„>X’úƒøõÉFÙ„ùæùÞ‚ëü1« 9AˆñôŸã€"¥¤ÏÍGHÀD®„°: z8µÚÅö‘íª‰œzìsS«ÄDÝû+ ¾‚Ó¾`;xœga¾°À1A®ºç¾„×"T¬• Ú#ækÎÅ"V²"g®z¦z¯œbØÌ•I!wÉÜ{@âZì¶Ù°¨Œ§M̱Ö'Ši}bÀ‚ž=Ép²ë¤¨H zˆ:öé‚Úål¤’Œ ,ADœ²Ä-û†]Á„d÷À/2Ó§¤tÀÝ”Ž4Ó®k>g5$ÇlÞ¤ŸD¹ý«—@#Oâ1*P ¨[“Üb[X;±°#_‡LnDJuÜ<1HÑWA¸bÖ§@tw˾áÉã‡naŸpk°kuÚrÄáª2ì!ö„PLÈÔý9Éãò” ´o¨ÖÁô#³…]6¹ï}²Ä.J3M„ë¢"­dóG Ìma:Œa®»VÞ;Iƒ‚go‘ÊjåÆ¿O`Z¤I³ÓÝ·Cs5dî•ÔÊÄt\J‘TÛªÚƒü°U`/Ç$…p4$vxÖÓÑ@–cê:>ýŸÚu1§l¦ÐŠô1#oXR~¯iøâ½%•õ¨ÓQ‡k¤iÏ™f»&'¦3+ãÒš†:<4ÏÝ:ÓÈB¥¶«G¶Ÿ›Sg”¶«kU&YP ÆZƇ®1AéÔɈÇ5ºª¨ÜÊz0'?üz¼zwÍ®ãÐ;žƒJÝ™4ý4  4ã^å†Á¸ÖÒ ²ƒß6¥K]`Ê‚I$yøb\åPSbú™_ªOÆ2C ì:wF‚Ç/’ld«ê?íÛ-7©Û0`ínºŽ+PÒAÝB5ôÎ îµÜ79ñ>0pÔ.Ú–Nå$ëߦ2² ëІIgMá·nRL˜ÑuÐcÛÈ+µÚihÐ>S’kRµ’ö’= {e>íº³Ÿr°³¾ ³òyæÚT`}¥0GE_ãŠËUt…tP!L|Âeep”©¬Tmzc¨×ónœ>E{lZE•‘õtÊÿd8…¸$±úæ9Y°±¥†Å07£”’#qñÅæM m1bb ë†ÐhµA™Lã-¸àܳcËŸ„ùtÉbw‘ÜŒ $‘Ø kà¢DÎ!×e[w@"KOXƾ¥ô“úÁ„ŒÏ\6%fÁÓ_†z·Ôˆÿ BÄ'îÛS¡%¦4¦{º» 2ÀÜu k×\ªÂ» h?LAÖ']CvlhЬî11•„wœe·eº Nš|suj$Ú¶±=ÒÚçé†te.šÀ•×»\Ú4Pz>–À(ÖÐD j J9 öqíbôÜ;騞˜éiÅפ™Óç¨ËvÕ³“õŽÌ]§\fPB®šõØã;½ÍcÄ|1Îí íêOã„ïÍtø†Cz¼@&;IÄõ-GÒ+÷p,z .º†±ÐîIDÈÏoŽž–PA àŽ„‚GŒaƤîX†I:dž.Â%$|p ÇÒ!{Fo±µÄb3H¤|¦ †-5Ô ,Ȉœ°€«;µïðÁq`µƒ˜˜ˆí‡Ø·k¹?¢ &_D°›†…|4ÏÚûJur¤öí®2FÝHë>xaj„ùœÔ@ fr~^ó„+ßFáçŠÊÄYÕBéÒÄÁ´Â¥ö}k>=£6€'±èc8ßpç׿Ž_ô¸í0Ê>¦ü~\t­@ÈZw.‹·¦±ß)¥-4Ôd²ZÀè>u8x¶ÒÔr”…¶·$Êý1ñ±q§t‰#,¡×eöBÆcÇâ1Ú«TZv±CáõÍüV›‹Èb‡À‘œ[nmUu&uÁÒc,àÙÑŸôì†{ë_*»‘ƒfÐëü³R@·vª°Ìé–×fÁU„iÖwyâ•ã(+ ÙZ믉>´ßrì¹B¨b>c 8ÌGâX¨é\´4ʲø©ùsî¿oæ“ï‚ „ôvÙùuË8œ¤*ë>ÛU“±Û¸k§yΧqÐàÄ©êGl%×Y$ö#¶5ŒÕÆ¡Àœ/j§6–=Å#h ³Ø½¸àõ§HŸøgí„¿ßyI,ž‰e%lvù¶²" ù`·Ø¶ÞUÖE„8TÛ ÊþœŠî¡ ²«kÅ]ß(õêÍŒ«Í/o$Ī…’Xõ÷ ù5ÏìWÿÛþàëÿd¹X—y ž¸)¼,„ÀÚ|ÇS9Ʋ¶ ÆF€ ?ÇRx1Ú2ªÃ‡7±VP Áí'ÚYVêIR¬±ë'©ï¯Ž'×û^J©îKŽ»êËm -°ÚÅØw$àj‰k€•Fè@×Ñ‹[,[ aã»áŠ÷”Y0ö"…Ò1T"ò ì,c¿iÇ©˜—VJI uÛ fuõ2‘êcù´Æ¬­¸ àOCá¦T†¢ ‚*H }ZTybÅU-*Œ(;uíM ¸¾­FíŸá9s#§‹vÒú‘´(³†©qâîGg‚:/pË—P\ *S} ó²[ŠÇeÎCŠ¬JKòªn­†³þŸÃ=×´ÔV&aºGõ@À í´Üë©í>$ã1ôøÔœ6Õ–dŽ„a¯  Àu#®Ã$ òˆó˪w.-…×XPdÀóÀ–)jYHzÚ ±ÓAí£ ÆOh-PÖJ¾óx`[Q ÖK%óÑŒh#¾'(1 b¢Ü,‚$t)߶~ÀÑ`t±[QÐÀÆ2™ ˜bzÄõÁm#q"wwü1é%«o¬/p5‡nÛÿÌpÔ•ï“à{‚:á{ ê«Â†ê_†˜A&â}ȃåå–R•À‚Æ eWoÌVzË–Wd7·‰´ùa!ML¢ ™~>XæÂvçÄb­dˆMqh:ÎgÞ_Œà X"HêGýŽ3(©@—A½@ÓIœ­«°Aì,œüÙbòË’åÝ]¾éÑ”x(×\k•w1'ÔÚþ3ß™×ÏÇ6©×¸ÅS&$Ÿ€È­}%@>1‰c€6°åçl{{˜šÏäù+@7xœ÷QΟ2 AË…Z£nZÔž¸÷±€Þ’€õfë8ö+S0½IãžÒÊ•ÀI¨i©ì2@Ôô>¯MsC¡Ï#× Ô@Ái Ø~QØac˜Îç¾mkRº¨ßÜ0¾”_ÇÝʯƒÎã.ÏJ(©”JÂú‰›ÊÍPŠ©b,Ô;¶¸95ZÏo’IôØ‹Ðècr$ò]Ç­õ;@í9ïqˆ~=ë$Ä{å,ª b‚|´PeK Aÿ†YDÄí[A¬¦sHf`-6q–öúF¸ªäR¢*77F$jÀyg3—r¯"½åxïÔÀ3º;SÕ¹‘dâ1kA:n='Ç,â–½léת¹ä«º^ÇE IýYO:»Sßµ?QªÐ]D†p>æ,÷Xˆµ€€»õãšNÂrÛ»¯ž<‰ópb¡¦zÇžo:3k8Ñq@c_† VöJ¾B o-8⥳h^á BõžØiæº-Ürv½cH=OŽRÕ·MˆÈDt ñÊÇ o °Zk`¤‚ÓÐN® J¦Ðy‚~¬/Uj–±¥ˆ(@ÐçÿÌìþߟÍùp; ÚF§ÄõS8¬­¶ÈÚÌÝtÅ€Þ€ïñÄh>ám›Ê|1’Äd#E•‰WïêP+q°7µšÓÓø羌jç×S*TýAëÔ|Ãòç!Í߬Ãu-jÌ4i¹GQ»~Þ¿u6­ÁE&«^“ôŒ6í!Û]Ñ* èÞ9e.ãk,n#t±F]D£o]«{@ ‘§ðÊÖ·K«©-dšJø–) ;li: HžÙî2]ÃiÓªÿŒâr*qÁÁ€ºÌë¦_ÈPÏCÊAÜ’|é8ªT«Á”Ï`Ýð2³1'ôêQ¤à†•©2 霪‚*#TË(á ´ú€>¬ ÆsC5NŽf Àù[Ä¿ú|m ;NîÓ?Ž«õmcºÅÖc^øµÖ€+ê ÖöŒ¶¿q¡ùaÈé1ˆÊàÖ_Ç•Xé#LÜŒ=:Ÿ3w½Èé ÷1}«ïÒº°* Èé8Î jJUÑúà}ÂÊ 4ïŠåkjÕøÚ:þ#Ö°¬sŽÚÿÇ`»›å#E×XŸåòêâîáq¤_¸ÈŽäbÐÖ,q¾Ž2B?3ê;b*°.#eg  ëÇÐ7Fí ëõ3eh¬Es¼ÇË»ËøåMÇ>Û«1×qëå·S»mK-ù‰îrÚÔöñÇ}¦_å'¾)azá»t¯ñÉ´¯÷×»&JØ ù<Æ3Ù¼3@Á§S3ŒEÕª“ZjIíÓêñÁK0²•]€Ð0ÅéßðÀ#ÕÒp†íÐœÜç,ܤlúAÍëó¨=5Ê 6±òñ“ž™*N ã}KÓÃ70Ôt¾:!œ«ˆ ‰YùO€ÄƒÀuÉ2?„©ÚÈÃ:ÈÉ'®t™Éy`ßË è@8È£sŸJy`­îöÎŽ>mã]3ÝF"âa7¤Æ›Ž*òkEP Ðe€Ÿ™¿¸/åòö.ÒèaMdÿŒå©K «³ÕSéZb„õ•-·¬ùcMrŸOê#DÒ|rã\+³†a0X tEÔ´±ê<ð0@Ê7Bô+ü0[V¼‹ÁÞEŸIŒý§4¹Zê¤t88f½áØ–p°Å¼ç¦5î¢íêÁôÉì–5vƒì 'UÁjÚH¸Ñà˜ïFÖG3í´j0Î*qîÞÈ[ÜWêKŸ«áœþ;„[˜Ím:)N›F~Û’›HÕHñÖº÷8 í'æîL9>’zGL)cAÖÃÕ1ªª-·ÜcD7–=nÈIÑ®²4Ó àìsT¶æ‘ ;ÀþXf—`¥T5cõ§‘Åö›ÝR»¬½†¬ç¨ÿ—YÇwz0ÄZê`¨oÌÄþcŸÛošïøyd2 ©ic¬žñðÃ0ˆ umN̯émÇÒKtã‹é_O¨‹@f?ž/”5Ü´Ü-, £GB:i•²Oî}ÔHÝ€ë?Š¸ëM¯bû‘¨ô½Nèý Ì t:aãŽJ‚Ä› ‚ûœ×ÿéÇ*6‘òî xê2꘮ʛujIô’GM°q‚Øju–Ü;Oc9`­G¸ÂAܪ£k O¸U}Ê›_P:‘±]ÑV¡¸N½LIÐéŒÕ²=P6ï0duXëç‹]$îjÑ¥FÓÜxùbÚ Z ïž„k‹¶–÷‰Ð z™=IÅdPµ³Ê‚FàͤG~¹x žA µK\ H,<³“ͥŶ×X­å;ÌHù·Û,»’û}Ã.: 1éR$‚4b ÑHä>8Z³*I‡LI1'Ë73ððñÃ+¨Ðxà ;¦rŠw2Que‚£z¢Lc…#bžÝ4ȱ3:ô1…)¬Ö$P;цژ Ú ‚ †] åÉ Üô;»kœŸ`Ú©Ê ¶VŽ6i†¨ÆFý7¨î¤'¤1=ÿ‡Ïè³·tsÐOžYE൪X #@ ¸õ);Ëß¡ÔœTF!µ–=<£Â ÷‰Èc~£Üef!¾\Τ7„ejµ‡¦ðĉ.¸´Û@hôS`,6 G|^9}²Î›:mʬãRnàR¿VšCq=Âd2É\Þ·ýùº$Ì –õ7ŽÎ>ãêãŠ:΃ñÆWõxÃ[1Ú5Û@?ŽHÔŽ§„£«xc£6 Á€(6 äAøc–bHðœV™´ÀåðÉ=:f‡AÖp N¿Àdt Í©­Ž@Œ¸ýѳ‘´ºÔ›X…Ž¢zœK“vÀþ–e€~>W-ÌWsJZe-á#¡—·–˜4€HóÆ°Yek±«E'Ü­‹Nàg,§†=ËXËWdõ •zôƉùp=µ¢;Ã1øu˯½ƒnV#Ã&‹¬K(PÏÃ)Z¬öT÷K|ªYN£ÈNrîç}³%`™Õ„bûph¡@;išTKOÌ5NøImô1õ„é#?M6Û¸úû»ù œª†ãT¬ôM¼Vj]€ùõ7A¼„´#©"äo˜>=Kók¸“ÑOXœµouNÁn¹`¯Faeú,Øzz @Ú…ŒcÅF¹”ý=‡ŽæÔêtKt 8¦ž)ä*Ê=0Fï9Ë–´Zy €{eÈõŒ~Cµ—³zÑc×®5ŒV/ê¬JkÛ¥ik¢Î{¼ŸÎÞ3ûùºöþ8•9%,#vÚG©˜u xbØIØ­ú^ ø~l²Ô…¹ªÇ k‚ÎI%g¬öì1­e%L•vw0¿&à•ˆ`¡fgÎqj¶ôTi+ÊÔˆ’`Cƒš¨ %Íhõ˜<£¾YÉãÚ_e{k©·Πνðóy ¥­ ²˜0Äé§Ã- _¹ (H“3ê?ZÀCWúO朓´û†nŽƒ^Ç€®…·#®£PØÈŠŒ¬=‡`GøG|ìWG¶ƒR@“ ž¾x†ZÛBOBGXŒjù'}´›H$7ÊÚ~\qÍsÇãP‹ºÊÉ ´C©’AËxã’9amuY.¾o=»e—֮įxmF*DvŽúuÉHKÀï§]{5Ö(@ÐÛ&N±×Q)|gX‘¡éŒè tÀ ~˜Ó^³‹.Á®ò¢+;Uv ì½Dá[|°õUb‡Qù ’qFíI€Ýœr¤‘$hf:œMé>Üg¯†™í½aJ²vt韬ëí,¨xÕLåèa-ñ:÷Ë\ KܤêÐeì§r³Or§¾n“=Çã†Æ‰ošm˪ìGˆÊ­vS{O¸µ¨Q×MÝç6¯É¤|3`ôªüÇ èYoòÂXÌ™é1·$ë:²žCãÓ“¬œ ÐxâªÈ tÐùŒ[-0 A>Ym­` ƒµ:“Û7÷>>abtïƒhF“ß5Ðv8uõÖpé'¹'¶èGñʾå÷j%÷•¯g¥@g®¬F__ Zª·ï¦†­³ÐêDké˨¦³W1}*›eXƒ®ùÐgì+Z,ÌÚwÓÁ´ÇUm‹±¤ÁS‡qkºI†H c2îTW¦€ÎV."¿Ü ¦Àê:ê:âܶìjÒ“ ÁêprP,7$÷úŽWÈå7¶¶¾Â¢`a©ïÓ,²·~?™O(†Ü£æ?Ò|0ÕÊl%ìä.æü tÓð,k(k,èõœ³‹ûuV.GîÈ€;¼ª´¼w×¼å•T XÁÍg¨ j2îM ä+Tš¸ÊyÛÊõ†î'ü±k#möÔ3Շ˗P§hµŠ«t ŽÀùã-èÈ¥¾¬*Ýt€3pô•ÓM$` =O‘óÀ+A×ÇLd­ÙRLœµ¬äµ…=vVcYðc‡•Æ¼Û ¸Ò}á‰û[6Þ­ \n’Ý¿ däßîT¨ãc¬ùx¬ ®>n¤Æzˆ  Yëñ8]›Ñ':Ÿ–z,!iÛTj>£¤åsY60£YxœE's(Üúmö†TZxµ$B“««::øf׶hIV¦Ó=†n»s%Pʦ@]`ec‹í½•}‡m“¨ò‘·67ôWm Æâ˜yjë}jߧB˜mÓçùqèäÉvfô@1ÖDeê´5‰Q$YÔÖqi±}›“k(:©Ž„vÖYHã2©½Þ’GrN\We‰%%`tÜsܤm7íÐÿ~IÙai/ô‘¨Ê®¼-6.ãi°ú\Žr87µÎ0ÿÛöþ¬7ÞæÖaò5ž˜–R"ÂLëâp[s¶Û ‘åþx´Û©ÒOM£]1ÚÓ¶¶þÙ u°2¾ú›o¬x‘ÓÉÚÄë°fIðŒ ð4·Ã »Ó¨óéÓ6¢À¬Nã.º›Þ26룳àXü·÷-D™,ZtéÛû;|ÇÄ…Hÿ·LfÚ!>¾ƒMAÊÙL®- 鮳ŠÖ0G¶{“rÊ÷a”hv“8$®’;äª{”»kSz ¡‹q®CÊß a]eULu¼elZÉ‘ÓAße´O^¸$èzü2‘]ÄmoJ/@:ä¡ëØåµØzB÷`F/· ™©u øâïê½:a ô2ÉÒN0'·¤ŽÇ'Ç® •˜p'@Aøç·j”n€a|g¹È GˆÆp:öÿ†H˜û`*ZHz ƒ-3Ðc:u-ÔðÁÔ°Ð,hpauÓ°ŽØŠÙ˜ -žÐ:Ië…‰F³›çIüpÆ€ôCܽÕöíJÝHß&@“cÙW»¾Ôù*“X©`®!§Õ;NWÒkJÃ@`ÎÇú@ËöÔß»'[\™-ÜÆ€è«âùãR¥‚ƒ! ’¸² øäVJÖÓk‡ìÛ©j'Scîk ï¸1žÞlí¨‰4Ðœ®Šéy`Q= éðÈ¿–EUz²€ vþÕ鸅vÇðÁsW±cÔƒC1ß=Å1Y“ð8ö½e”†[ é=Â^Ò…,™üs“W ƒaI©€ê|ÎqØ8 HÞ天'P€ ãsIUäÙaÚBˆÞYe–3ˆ²Û%ªûÁ;D÷a¡œ¬$j<ñ”Žº‚0r>’ÇluœCÅ4Öî²^ø†¾9_îøⷨɲ€!ãÂ0YW5Ñ‘C½œ}9c$0*[| ˜ˆ,šŒÕ¼5—È|ÿ¹”Ê7’Í Ð,âÓD×uá‹P:(Yd-·¯†Î=Íc†vý:‚÷î~òþßã…OX0,ÃV ‚p?ª—DØ@OiÅu®ªûñ”(Þ  Ôˆ¿}qC¼Á#¾¸•òaªVõ‡àljM`ØDíê`$ôÈ„mÚ¨@‰ÐéŠZ,³ûhé ªžÇ\Ü•­ƒ€’:ØþxÖþât*Ç D•#lmÕ±%•È=ÈÓ@sßà¡®ŽA ÐÃTu:ß”çB*³æ²:ãLE@íQôí2ISˆüë´c!4:zà«íèêàêïHbûŒJ.»;Lë¦WÒÄO– TƒÔ­”!öäúºÇøå|+U¸ûVm×pWï(³‰®Ã«¨5ü5Áû§)m6zÁèL}:cL"oP›CŠu!¡ë®1©^óŽ`±~‡ü0· Í©SY±Z›çc'zœbŽÝ?›®=o¹ÉU,âP ÉñÆm¾‘ªŸ3ㆠG®gÇá' ~Ú²tÉ:ŽþXÅJ®ä+¦Aè'¶˜¥Çë–ý-'H×—¹Müg>öÎ¥íYøF \0=›¶š`ÓáåEvnk'ug >8‚T—¼` ÿ ,ÌOåøažƒ¿Ç%¢Mzà=€€tC‚êßÖ€¡¨Vï8\2ú‘Yˆ-0p‚tí9nØ×]sÔÞù¡ ÿ ãñÑw†±E„L$IhéŠ8?o÷¸Â+EâË6ѧÊ||¬Ut5…‚ÖÂ]Y{ÛeÞž=ÁòTƒ¦‡ËrFã¡òÀŠÛwj½ÁÅ}@A§ÇÉ–=| XDsÜØ$h| ÏÓ÷Ž˜ºœ3¡ŒÌF™=´Ê.½öZ@6TXCü»Tk”Ûw ˯rMelÐmÔ³ òâRhB,]W'`WB¾ŽF‡\JMž%Û€uݱJ ôžŸù³™]¼Èkªh­SÚß>¦B4þœ¬R¶qì¹JÅ>â7l}Ñê':zŽµ’ N3 ´a]AWJ2¥Àè݈rÕÜH#Õ·P>{ °™”ôƒ—qøî©Y…5/ʬOrråN>ÎMv²XÛ§Uéÿ›^A=*N‚OL÷-tV»Ò›{F½0›÷1BQwhžlµþQ$ öé›Ü•à¼ï]%µœ4£lª{‰×*z«&×ý+6ΙÅn(aCÔš°Ð|ÞC=­í_¹±ä†<³u»%¬Ú“¦è1¨Ë¸w0´Tàî'PÇþɸùÆ)©ƒ9ªû67 –„ðTíµzØ·‡†*qAR¤m C>í_ÍÙG ‰É]{ãò9•'îXU¤'@Út8)ä2-6)µÜC¬ÇÃ9³›ø|wUnJzùŽÇ©êÞA[˜mRˆòÆ%ƒd…eé=Ï–;)b«øOÊÞ=Öq ½‰ïŸ+wó÷ñÀé( ’DÈëÓIÆ`6Öž¡XžýÛ ®—Z …:ißCãœN; [“¸4HÚ:ñ‚Xë\ô¹‚£&™€Ü'HñÇäVÔ³údB‡"$8„øe¯È@ÀXƒ1¡ãœ;8”‡“¶ñlÊõƒ†Â1j‰AñÀ-õ6âù¦>V"'Lö”(S ¹wDöüscuI ×X4žƒ^™É¢Ú+²§—¥À ‰2ËÙÛÛDù˜3ÞOYížê†íô©$ÿ ÍìÙ‚zg¸ƒk>ž–>ãUG–WYì:ø.-(”ÔFé• w‚;ÀS@ÐÆ“×LJ7Á2 2Ôæ¨UÞxmGXóÃÅ*¯FÝm¬õ†=¬Á¶L}SÔã5b¡cQèÂ!ÈVèâ9%¬$Ëž›F‚1omFàHˆÓÃ\¤¢] A F'=À4WÛ`X‘¸å9wê•P¾èê$øeLÄ*.£·\°'¯Ó¡cOðÄªÄ Õˆ÷@ |GŽ2Mð^·ÓÒO^øij†e È¿+£vn,7Â{ä ÖpðGÎ:Ær`tP|3¤ŽÑšjFžY½›S¬uÈ'©ŽÃ7ùã"&¶O}:e)c´NÐdNQ ç„)ê{wͱ‹Jl&?íðÁBÔ¬-_Õ¹Ø.çë¼“Ø eœî&¾"„$ª;msÿ(>3ˆöûƒú·±QÔm?ãˆöÃ»Ì zÄÆn2š­Sú•öøŒ–Ô øx`z‰;zŸ¨¾¢d·lÚ†|mCv°¨>Ÿg´þ´#¯Ã×ÛL…ПðË-¬E~áÉ×Iê`gñ8ÂÉã~§Á¸JzC+|Äþ_—+a[Õc&Uq¨ ÷?6Xÿ»M»6R]}#HüÀëÛŽ–°ãqÐW%Š² »t,qM„‹T†¡€Ý¨0F½wbÊûä¾Í¢Á·º)X}§·§#“É^Päûn-áÕvŸKj¬»‰Ë©XaYc#¸wÃ部ñîî’€î‡Þ³Û1é2{Œ#‹k-ˆH@«gq¦ x«6¶¶†0kN£.0¡ì*lÈ x¬Ð,OR9ð=±ö±}D€§ã‚‘q(¦DüÓã…(R Áo/ã‡&ÔbôÙÖ2×·i¯‘µ7šzÎ:À° téŠü1·xñ}ÓQß*°µaµ›Pë¡êØËZÊ립°#q+UPŒIƒIË­¯Šª„²ÅÐÀ=‡€ÏxU³Ž§kØ ¸h×Iú²³bš8»÷zÌùoŽ?C à.Ù*Gr<ñùˆÖ¦ÔÔÑ :éþyȶÐÕ«h Y²ýãŒH7”:°ü çÿɇËíÿpü¿ÃæÅØÁGÌÌLIðóÀ•“ûÛmŒ íóÉÜI®$L‰PuþYÇ®—VzTûÉÔÐfsöÊE¿r ,I“ÓQ‰Æj• IýöY.W¨Ôi‡ŒÊô)$-m¬ü>',!í·‚„•“ßÇ9;×õQIRa‰©ÌÄ÷+B†´ °ÊÀHá‹ÍGp‚DÀ#ÀAú±ËV aòv=F1HºË¾Òd•&b§óãòm#ÙºjEUmÂ]¤ÆÝ=-õbÏÈ AIÄZTÅ`J÷1¨#â/îªcZ1[Té §Q—W´²a‡Ò<åvˆTPCý4øbKþ YÜ|q‹êÀúPt#ùã3Ô*irê='¶-ÞàTvb£«;æ]ïƒuV브e´ÖkD­jŸû† <0WhÙUžŽ¾’@ÓófÙW‚ ~]HUª–þãü5œ.ÌJê©þ‘ÓJ›õŸ ¹[i+:3Ù'IÓ7Ö¥ÑÝ>œ¤{£k¤•ª¸V‚f5׶5mµŠI‘¤Šê&ä°Ç Ï-® ,¬Þá&‚|2ºÔÀQ¹Ì¹¸Ë¡=ºá˜ÀdL ÔŸïŽmŸWxí{æ£L ÉõaRd'5Õž3ô˜åÛ6ƒ§^¸á#¶0UþuÏÜ5Q{±ÖÍ=#ùë•WË©KTäé¨ÚF£ñÀÞ÷ºŒ Rý—úvÿN~îäÙe`{±å´?ËÚ}—¡‡B&AêAòÃb䀬ÝóÇz†€úÑzp6á‘Y¸_ „¯æðÀàÌ÷;'Ë=V>švͳ¡“€®¿æ29TµnÈ-ã5²Ça¤Üy圃EfÖ¯z]¹C(Ô¬gsž›@o¼R‚Ü›NÀ@'Ó:åÜÕEÀ5^ÁR­¬Y~¬äÒ~Ù_Ýmª–Ó¸  QÔîÛÛ)¿ì´š(jRç¤Ê†HtVc»lŽøn6¯™ƒYQÌÇ°¿ ²«}®LÁãØC­£Ó$$B¶r8ê–*ÖíS-GÒÀwàÌ© Üüû`U":Æ{•µ{õœÛxepfSëÕ±.©‘‚ˆy0vŽØ¯î¯t’OI='Ã+¾«ûä¥~˜ƒœe±[”ÿß*!Tx,ã5­©`6÷厵Öw.­cuÏq[aTö‘åÝ{"H$DëÛ¨Ohu‚Ç@4‰=ÎYÎ÷k­‰¯C¢âXQ}ÙƒâF1®”†”>káŽìòt=~8D¡h ƒ‡hI“¦åé–]uA‹ ‡í¿Â2ÅVÔ“:ùâòjd¦±Ó{Fèñ_ öKü¤m«Ü@zce’ Qk2lü ùãò-¨T¶‰®½»HóŸ‚´™ A|1¸¯¹Ô;Zu±kYˆ™ïÿ«® ïÜäúR°@éßþ\CM¤ZlÛ}‚%ÖLGaŽ8‡iº«5sÐ"ÁëݱŠn;ÒHƒÒF'=.‚P-+0à©×\k9ŽDÆ¢ÁáñXØUéÛ´\ÃA=~9úœ™Ot{Žš ¬«_ÂœwkpcÈ -±{Ë,;¶qF×ù½]çÔ¾ã(ÜŒP< Û½@N^XåXRïh ¡‡oõ|ØÔ] OÌTˆÜNšÇXÁxsíVëR¡XÒ«NÇêǸ®Œ`L©Jü2“C5…V¾²" ü>œDß6Ü¥Mf ÓU¶Á!UŽ«¸”ãÔS[IG-® Ì ¬Æ"tׯž"PÇzŽÂ&Lç‹U@µ†Ñ˜±ƒ¡ü¸ “ì‚XiAœöPn"Ë-=A (9-Z2RÌÈ$ê4ú²žUÁÍHžŒ|3ܶiv2@ÐAùrê¶NÄ=‚ŽÞxYI!5:købµ@ îÜ`¯yÅx6Ž³ uN­ÿ~mO“¡ŒÛ¿|ž¤ä;“g$u× 7ðñÍsNùê‰ÿ†b²•7Ís˜Hïå+ì+7T±„±o{ùdüˆNÿ†={n¢u'_¸neí©Ý ¤Ê-¾ßtRbº½#ÖcžÞøª•Ú¢déÓ,jâ¿lo÷#¤cµå“é~§&´ÑŸÚO—Ûéôøÿ«Ï8â±%€FŸ24×»˜‡¬Mm?žq^šýÛ7’ÕÉ*`ú€ð“•±¬WejIBf5ïüqé;½Êœ½VW£)Ðíƒó—-‹}éz€L o˜å¶mÚ•‰µBú†º˜>yèÚ\‰,z>Yaä:× ò‚$žÆ2Þ@ºiØÁ¦Û6Ÿ—Ã-¥‹_ÆBV»uPË”ê'µ ÚJ…u: í‡(ŒÍ ·ìHü3Ü“í–⟨¯Cñ×kXmõ#¯Lé¯Õ>Øêg¶ CDèð4Ó§ãœî9h7( oM   ¼ê3pd ¯ÆrijÓy×ÄÜèQˆšÕdž"–ÛO¶JÇ^˜v@`žäŒT“LáÖsþXI’{fâz䞧 ,ÛÐw93¦12Rtïží•þÞ¾¡íÿNS»Ž·ÛP £@ðÀõ)ýª‘ú#@§Ë•·+|³Øøbi&DùⴠׯÀjôo•(Ý|úæå}Àèõ±‘–Fûv¯´ÀAuëáŠðÉÐôï ñÓ9HdÜÒ¤ürü½TöžŸá“WΟ:üO\PT 6΄uÂë;º€6‡¤àQ¤LŸŽm|‡]rª¯ä¢§8j¯mŒJ:6»çÃŒ¼{=ÅŠï²v ²¯L§Aۯ͕Qe×IOî#évêÀþ|BXªE5 ¨èHÿõdò6^ìÞà#FÏ僈œ‚œ®=ƒuTìoô·ô¶#†¤Ã- ¡pÖ—þÒ€»¤ê=K)Ö:`às--ÉCîUȬÊÚ†Úb{eD’…}o¸˜èÑÛ®z„ÇBO†P*Bì­u8C¦Ð Ú:yëžÛE)ºF°r»jX\q@O´ßQ?†]ÎûEîêÑoºë DWl÷9€Ö®d‘§a$À=1öBÕ±ëü1¬ÖZTm5¶Ù ØÁD˜:åµµÝ úI#øç+“%Ö´–¬‚qÛj¬­Vi`ðqÔü3j±ôÞ 4Öso¹¿l†EÔ4õ9¶‚5*è[°ïžþṞˆÓC•Ü౧a眊µj®2#´÷üpÖ\)"QÉ‘ÿ~QG–÷Z¢l[%jßÒuœíÎ’Öa´‰èÓŸ¸±½,©S¼¯ˆœqyHËûf@P4“çᆧv¹>ܯBOIu—˜f2£Ç=µÛ° 4? õݱ z¯Ç>C…‚ŠÜ8“–_M¥9E‹Ê‚­¯€úq7úZ¥ ¶C Âgù °‰*Ãw^óã”Öy®BYXq›SóDF2ñP%”Ó×pbN²“øàä(ÙJz9)°;´>}|2ÚÕ í0Ž‘1`íÁjÖJ°6‹Ž±Ð`âVÍS›ÉGå×MqiôŽAu[t0Ô̽4ɺÅe$ªdOLkÉ j ? 渽}‚Š¦ˆ–FЃà'+¥ÉPëlŽÚhqÄŠÀÐ8AŸ‡\ºÅbÄX@ptI°r˜›K#WaÒ ‰¾8-;G¼Û›¤˜ÔGà0Xõ©qõÎÙøŒ¼j¶"4‹Œz¶ŽšvË®ä„÷)µM @0 ÷Î=xê„#ìÓhHür†gÒX£ýLz&[6ØúÉÓNƒ§L+Ƨc“$¬ú LŒ°óŠÚõŠ±:O_Ž¹u–)c£W©%gÒAœûƒèmý³:{Ç÷*K´COYÓ€4  Ê^ºØÖSqLgµZ(©Û°™3® ,^Fò¼j‹:Ž¼¿NYapy*S8+`¢bSYü2ªÅRÌ\H H3øÆ@7n˜ñêc5¬߶z€J°%`¡'¹ðËÀC2÷ÐÎÚÓÇ=#§c†t#®htXÅ~e"뮈IPô>’59]•ñ¥šw 'PGÊ»¿æÂüN'íˆ$°TÁð# 5š±ð°ÔÑï—ôÈŸ¦¤äD³7¦š×° ýG.¹¹>ÕŠt#±ÛÔ.WmaKÀ°GHËE\²¡•VdéÛ?v÷·Ðóäiëc %›:Tþ—‹dÚÛ_XÓæŒ7++ >² 9ïTŠH±µprŠŠÙ}.ƒN§Ï*ivŸXjn)í˜?Œc ½€qž5 ˆ…þq ÑàCÓ ©ÑÔ$šÈ<°€©íºNÙ3å×y–-¼H!Wpô´ÿ–rìCqpª'Ñ°øâpG"[U+P¤’"&~49_{R9UM£«©núcÔÀ'¼Fáõ«/üqÖ㵜zAè|§Ô¢ÐqU×Sâp½È®·ŸÓeë#¨ g·VŬ.ò‚qE «±…_ŽlI¶¤`S]¤¦¸ka@V]—Ib$‚âÒŸ1Xv1¨çÏ-Òzxy [­1_E'H®™jnŽ½4Êž· 'VM ƒßÛ`ª\²«ÏSÿ4cÛÉOv§Ý±Ãm@W_SØEÂıXUeöÉíÔôŵy5ÙXk­q–¦Ýkf ;ÄâWXUJ—|©Üzt-ã9Ýk¦!NšøÿºG÷a•iYRÎz0ñË.åR9(Cx)µú–Ü£´Œj¾Üë{îedr dOÐǶqù|£± ûÜjMÊ@?*˜Ü'?ü¸üÑý¡òþlÝÇâ†%X³uïço+ôªf ZÖÛ‰3Б–r®§Úíµ—PÄbóV¦zxÌòº€³çg­¢ÀFæÔ)>žú¢¦…PzHñXÔ㳪µ·±ÝàA×l÷SœŽ A+­+iQ&UѨreQNí ’$å\§ç/êU úF½2ê8›«ýÆÔÙ´’ /§Vé®C#ÔðI"Ç ßËöyVÅõ´ü¬½>¯OÍœd¦êï/>áP 9 ùq•–BJ¨ž†N{WµŒu¨ŒýÞÍ˵«µÚÝÁøFr+¤ Èm°c;VHí®2X°• ò-&Z1ìµÉ¬!öÜoOËÓ ^ÜÑi8[Ѧð{7fÆÜ«±VÝ´5ç‰X±T "ôß"cñÎKÐ V€’ÄI&bs.†ãò„‘ K@×9 ÞË)¹!IÐ.Ó®±•-Š «ê+ØAq»mù:Ïh(²æª‡ÛX‘¡Ó=ËLVÄ íÔ‰ÿ†¬¦³0WS,zåaæâ!“SIb<ç•:C’zˆ{e|pHd>äG«¦S±ÆúþqÞ é•€B±inâqšµ•Ü=¢5'^±œ…b`¹&{γAÀ©ª÷ÏŽºùc3Efvø·†-,ÞÕ­ R¬è:DwÁUœV§€Ç$ ሕºaZ9íi´ƒêP1ý´÷.F>ÔA$ô1Šy”rNÀ~YÌN±Šœ‡TXnr5×Ìõüq†Ïc8,TÃÂLôœ­>à¬üUÝ%‚êWO|«‘JäS¯´Þ™é×?r8ÞÅÃû´¬,ð8Êê095m`õ~a€«Ô¼;LÁ^š|3€–®“®y*J¸Û¡Öz¬NZ.F°w 7æc=þ=¬9¢äfü¬§¶6Êö[b«l¯JÀï ô“–"¸I×"Aëצ¹Rmd á„L vÕ(œge„ºwÀ¬díé>yvÝvîTlúÉÄJÛ÷w”±ßÿ.9èÅÌD±=cÏ++ÍVjÔÓ}{¶8˜Ó5¨Ö¬Ö¤vé‡z”²ÖôK>’×8¼NR‹Þ¿S¦¬v¨là[Ĥð9¡ -Wªè²AуfÞB2^¬} Ô6-ªÐÚÄf¢Dêšg·ÂM­[an¥|Žr÷ª±u_¤Â~¬¢õ_c(ðnäâñÒ™¸¤÷óÏÛØâŸlÅŽ §A•½6’S;hÓYñÊX„{í½ÇRbðÄjße;€/3¯ˆËi²Õx#R5hðñ¶ ¤€“…ÁS½dGPqZ¬ÿH8ƳŽÐ¬=Qç×Pì^„yyà Äõ>X»3+$k§†{{ÆÀw>ÌXÉÔá“¡ÍÄê{cV܆ö¿(è|¹¤ÜòJŽ§h2Y±TR(¯®ÅÖ± ã†î45. °¦¬žFzg¶¨êÏ¡RG~“M¼ozËQvØb°–-å–rl_d5€qÅd825Û8XÝìV±ÿÇR­,ÂL¦á×0'ëv>™.LmFÑ_·KV´n» Ù#æ9ýÑÿø¿?þßðù¼°ßÆôXÄ:) *“Û_ÙÆN;Sjš>¨ú2Î[»[_²7.ŠF‡ÔbsÙ㯵Iº€àD™ür‘c¢ñVJÒWrÀ3¼rµã’–!+}L±ÿ,ãp­ð¹™>ªìm§°“–RÊá”2ÜT Dn$zîÉG*Ê7séh×þ9q.ÚéT)UeÐ'IüqxìŒBþ x·wߨùq½»öÙÉx ¨%ˆ-¸};Ç+_ÝYe6»B–ùW¿ñÊì@ÉuO¶±§WêǦYfø±Xôë)Ümy’2`™e¨±€ÆÖ=µÃo¶*Fbµ,Ø¡·gSÓ=áxfezÌ< öö6v9pÚH™ŽÞÙG,\õ–PÜšIjà̓Ïúpqiª¬ DcÒW{X^×]U@ FƒðÆ÷d’¤Õ‡m2ÖµTå÷0ÜÛ[NÕŽ_•ï%†AÙ´ˆü5Ó àîW&DLô9û¥@NÒD*{eí´•UAé¹{vÄ£I¨ŸKhG‰1•‹ÎåvÛZ‘Ž‡Vª*qú`É785¸ý=Ǻ÷8M{€v!ž"ðÅG zÂ0ðà3c(z•IDj§¹8èÀ2UF€@ž¹] ¢’|HÓ5=$œÜ4=Ƚ‚ñê]Ö3’z(Œ®¾Êýµ«DêOññÍ¢ÏI tøwížÕŒÍH@ „™ Ø|Nrj®»‚‹ 0®'±Ü¿×)­Omeee»™Êž«ƒmºÄ‘wUý_ÓƒŠªÄ€Ar°Oøà(ƽãB:ÇlY¸ÙËB u 2rËZÁÈ»nÖ¶Æ3YñA‹UV2\„ïÜÒ„ô N?.¸äÓ &DîR1l³kRѽO¾x×ñˆ± -: ¤õVŽÙ´‚\S0}fÂÖ¿DC®ÞòOl½¥NVYvî<çÏå_qìXPzh{ 6Ò·¡RR:í^Þ¬E¹ý…,od·œe¶ÚÿXðÛž®NžPjÈ*Gqƒxý7Õ€ñƒ8‹Q, ‰Ê·Ÿl¯öœËæR•ÄoP %À§,±ŠSÈs«õ6€diž¡èŸ[ uŸóÁ}u‹kLcN™B×jq¹Mµi3ÔþÜo¸q#jl{+]Êá{³,™l Å]¼ ÑZf²Dî×éÏnö÷lOJ4†h^ÄŽ¸U¾iƒ#HóÀÕ¾ÖS1ãå¬Î©·ÆA?ˆðË®¥Á e$IêG\­*Ræ">¡”­öî9âe·u¿F`z˜xãMFµ©Ådõ ãUrÛ[;k¨kZŒ‡ÖIpˆfp¬u?Ç3 ;ÏQ¦JŸÀfæèrAÞ{d.½õɃ7R!NL ë5ðÿÜ nP i¦2ñßd¶æÓ®W]÷o¾Ö&è¬w 06‡­¶žÙÇJ›)Õ‹2’;i‚ž9¯*APR60= (ù†C½¯Vãe ¾ªËø¿óeV}ÊyoÅ#e µ\è¬ç©Œzø=ÞÒŞϥ•@õ1=6ü3ûCû{?¿ÿ¹ÿ—ûŸÕˆëKWbK¶æwtë…ªf>–À ×,ãWgéò+fJe}Ï^¤±õËO.±€ŠD«v½N@m´kúdè,’=$wðǧ†ÎJX7`|ÿÇ.¯iKÝUÚÊÉ’Uµõ ~\â{+,Ê^ÄymûŽ›„ëÓ&ô G%È£ÔÃ;Ié´à²úUj[U'bŸ0ß,âŽ3&ý­î2° ,yÆ[ʵ+ J²×JÅXêº=_QË­ûÀò=Â^…C0’ 5a"ÀvÄè&gL í ÇÐÛH$Õ—Â þAŠ… ¾×gXÚ<ðº0±À…­OB#¡:n#+äqëÈ…¶©k (˜Ý`OK¬&"5ЙÔe6Ú=Ï·\¡MÅ„Þ˜…êóÛ9 õ³û{‚¬•" NžÝÍ ôô&OæüÚç n£’¡…„˜ò{éifV²lmD°ùAuÁx¥Ñu“¸·æëòœeÖñÐLF{\uyi2 1¬e캚‰Yc+¹]È ¿¹DÕ•„bØóU• 0uÓ¨‰òïŽVÒIbÛ¼‰œ¦€ؤÝr¨F‚GùN/8ûlÒài"{ ³‡e¡V6núÏùåÜk€%[ÒdÿÇ7Fш¬J‚a‡Ó¯q…ÕV€H$‡|­›t’¼ œ§Ž‘ewIHÄ)ú‘żX¬ÛG¼U`ø~QŒH;:À×ãJê Ûá§OóÅ°8F&$X >1–Þ,ô[XšbÚ¨1M2°PtôèFÇVf×^úã nÛHˆëÞq,Gadƒ ˆÐt1ß'“[rôŠ€]:K4úcý9kÑm{ Auf iaçý9Ç~pJõÙb.L>؈•8õý§Œmµì§!܇­>­#QžÏÿ!9Ð[o·µ±ÚÄíƒæØ+K VO¦zõî1ýëVQ‡MÞG‹xZÐÎû úl‰þèÑbr»«þÕm¸ÌGa¦1£r~›‰ [òÁ×vM¶›Öªz(ƒ”7Øe, Ž“8þãTÖ¸ÒgË2DiØàÔëiê¯z‘…•t¤‘â{aÖ" wÆÓvÀtóÈ*Ç®èu,H:ÿ…cLRå9ý õòÉ-'læ½N .!QÌjÚÆ-TòéNÚÁ| 9 -KÔ)½ji² ôÉ §óÊSˆÜ{n¹ÅËÈåúl«»Adysñm®ëÙîy ’ ’6‰#Õ–òÈ6*­^抭2OH8Üu¸©µ¿ù® È“ÔõúsÿÇO—wWùü~9Èûo-ÂiªI¬}SŽ”2šZµQÒl$Ú'.ºäù# õËM01{T‰„:c1Úxòê#FíÓüðh3Aíå’m §kªîÔÈ=ÎMœ…÷+ E,Xõüqø¥J¾Ò¸ƒ²ß¶òA¯„%SŒf“O–ãˆÔ†âÚWÔ£ÎHǤ+ÔÔ…÷¬tL×Iœ¾Ð_ݱßtˆŸT,Ÿ†ql´Iã(ªØÔCÈc¶[QFTߧhùY±§HÏy¡dzˆÛ++I “¸ë>xª.zO¹1¹‡Ó¦*\ªÔØÌ¥—B ¾s•Wʼ–ÖÜ¥Hô·”ô8…Óa´©waÛUe^ÍçœÞ}Ä£ÒU€ReØêV05^ÄXê ô9ÃãÝX?·Fì5Ú_H?VWǦ¶jƒ $jr‚G¥ÙƒNƒÕßê1–PWÚ¶Uƒ%_åÊ«GÜ–G«¡™è'¦ —k’Ûn,!ÁVˆË–p‡'ݱbH­z•òœZÈ+$«dÀ$ >²¿” kÝ*¿£o@:k‹a®1/®°Úž5;Ë…’D©o>¸õØ»vÁ0Aa¦¸Õ\]šN±&ñË#ðóÁ:žñ‰Rê “ðœjxîö*µf¨= Pî UÚÀøŸŽ!6{^äAnƒã‹@©Vž²$«ç\^/Úk_f÷c{ ³ý-?Èâ5go,î ²ÃÂ3U_ÒÓlÀ øg‘UA(${Õ©mÀÏRzAóľª¦û+÷*äHp¤DL`K꡹*7%ÕÔ+²ObWOå€\L°…:k•Úv’P@>',DplfÞÖ,ƺ÷ÍÌ 0ƒ¨žâ;bbëêdøáWDÄvñÈéÛ7. tïŠÐÊZ°¤žºh ËîOÕåUa²ºIíжqù·©f6>¢Ýt®ØõcW\ˆ¯kN„Ï\©ËïuH´kxZ¥ ÌÚ|g¼eFÅÛÉ@ò#Op,+~Wïþ¬nUbcågË µWÊtkø綨é×Xü0¨=|†) n(K À牮¤U%zjF IŽçA›Ç^™^݃L ;Øà Dxcz¢N«„(•–øüp½•»° h¿‰8_‹Æ÷,AíìúõïŽ×Šiu“vö=ôÃu4Ö»X;»t=rÛªFãV½ªÎF…†½úáS}–=~¥ž§±×+K®÷-)íÒ‹k‘«>£Š«ÅÀ€-£¹Žû‰Î½½Î½ü2ÞUV+žEŽ·a¶; ö>9È[-º“©JG¨ô™ÅJocO rëÂÿx¢Jž’:e*SmE¯¬Ÿ9Ç5vtøöÎÜÙEAÙù:zìÚ?ú:FZ鶕T'm›@m¿I3¡`0ž¹¡“½Ž<3“ºŠÝ‰Pm†ÚDéýC7\“¢ØÆ]Äi1Óé­ÕLˆH˜±Èåuñ(²=Ý{“¡Ë}Î8ZFÐ4oØ~QaX7m J€4ÏS…5C#ðÁ6;š¥·ÐŸqøgr©i^AõK1’¤øx´û³íŸy«R;}2'Ã`PÞÛ„e$ B“õ~Yå^š«ö˜zˆe&I?Ž[Å63ó=!KF‚°`Ï]qPÖX= šså›j'eU€Ii–Ô’q¯&´ùc¡ìL¬Ô¾Ý´ºûÁDk1œ+-C«Wcƈ ”Ÿã•?O|)PfcO†p­i¬ïßbf{ ׶l°5hª^(mD™ðǸ3+VòÁ †’6ëðƹH[̃à0EÐCºdñþ9r@´m:TLøa¾–%-ÛÛ£6±¯†ùYd8WNÿŽs¸:Ém'ÀtË”kë"<<°€Ak9¹‡¥Q·“"0šÀ’¥U[¨Ý¦„â!E½K:0ÊÉH(ÊH–ècË7KÄ Ü=Ec+MAÜAÜDF‘Ó=Ær(öˆ˜'Ìc2ǹ2¢b|óÛäsl㥪CÔµnÜO›-RNÚÙ–[¯¤è#7C%`5Íâ½áNªÄÁÈ+¶lÀTIQtÈu”$:@ÃIId$žÝóQT¡+*`éÙ¼q½ÈVQòžã´b6ŠÂÏOŽZ–¢é,GH Ä*X XZA vÀ¶‚µ³ +‡§ˆÆä)õ4m='\rÚ²ê£àrÝ HÌ Ÿ×á‚ËHR,OlOÎ Ïùg*ůÛ÷”(p`³ˆƒ§}³”'(H«Bu’'ÒtïŽ6ée»ÀøòÏÓ}º¤˜49Y2¥ÛB“ø‘Ø`¢öPìemÒºâÝO¹ú nÚNšõ¨l^KPÕÚ7%üŽHÞV¤À×YÄå?1ëËï-~,Ñ£6…vüÃì[uüU—RX¸êV73Û8œÛ5à+VYRv»C¸k×]söœÀ°Ö'YüsA}~~xW—¶D.Ï0€óÊí½ R Úá~t'Ò¬uˈv›Wh*:wÚq™eÕ0$øŒc·õžœC¨øäªg“×'Ç6ƺôÅì€OIÆrIP“¦†c+°ˆw_PþyYÛè$¿ÿ~WVù¸|é…[Õ´ Äbi™ žÃ¶~¬-ƒØ í°è‹ÒLRÀµk£l¿‡Lup70$Ñ“¸Ä^¨6ɶ‡S¸F~‹mYïÔãWFv€Ö|Î{®ÔÁµ,zÏÃÕ¬laØ|1M¹¤(P 3vóŒè¿—¯óÄ­“cïFXö«9öºŠÛk¨@Ã=Û-€¢J¨“ð8ô3¡x`Ô’CŽ°WMN)¦‡¹+etaC¨Ÿêúrû9H+u¬í§Ûr#Õ™8–Ôûî©Ã•+¡1MtÅ« ˆ_pã©Ú±ä žÛW´ÐÈ ×¢îŸòÂm©n÷T¶ôz®½Æ.Bð"`4uÊ €¬X¶|§?sȬ¸Pi0t'Ç=ž+J…÷7©FàtèÚŒv"(+?4GÇÀÐU5aÜ@Å´ÒGÈ_y}IZ¶ž¯À°®Ž=‹zÏhòÊí¦tÖônéY ±Þg?s`-wÕUD˜fNÀxþlåVÁ@´oÂHÈw¶XêT õ|3sRj;K*Ž‡Ôe¼51R8ö¯·q2aÔžšeh´‚àÉÈŽ éÝÉK;*j}K:Dâ£I,…-þ’½C|FT¯¹‹'¶= ¨ëç1éÅâ^U%÷V ’à]Då‘ ŸçANžX êT»w`'L¬7¢di:Çs>Y6?¹K’TtðÅý£FXµl)ˆOLdHªŠ -ÊK3°2zéúÍî@BAøyŒQe$RÄgÞźÇ4’ ‹0 öÂí«»¾4׶š‰¾9*%ÕᶻšÖ`–èq™âÜî¾¥ÜDN’cÏ€³êÒl6æ¤Ã­§i N-ãå gb|ñ®¢ŸfÊ*$“Ó #ãÓ=ÇbvÔ:tÆuv 0#_3‹eµŽG§‹hru™î:nËB)®ŠØ„®t5“ ú—Ó®< …Xk úF/é4²m:Ï]$FXŽK¹Û´»PuÓYÒr±Q.õ±Y‘¤J÷í•q^ \º±N¤ÖGã•¥Cpj‘•AêTzšQH;[Ö¨GS¶:c·¼Ùê½*cJnŽˆe_ôãÞœsììýÀ(M‰ uPÞ¡êœU®«+µ””)X¬°ìÛA8¼+C—²½å'hn ããœkn²,.CSRíb ˆ}]7tËÒ¾M(qEà*¦îŸ«´ì#)­›Úâ5 ØSÒ¬¡º¹¯w¦~Vôãqß‹ÏýWµj+h€fXLî˜÷rš»kuض‡VVCý²6ˆ¿6Ÿ65UZ®gOS’¬l¡™‚ù8RµP-Ô¨Ôˆê|¤ãH†]JõòƳ­/ž§±ÊÈ_PÝø™7èDu9½µÝÛá„L¨ÂDít'©Ó+­†ˆÄ‘Û?@AÚ ÞrµfÜÛ`¨ì ÊëCú[cÿ0×hž¿†™eúMj å“P%‰%Pyä½dƒü?‰QtM¿2$‰ò$fÚ©z¨7¸$îïöÒÓhØcÒž3¦{b´±âA®gÃ\'•d/`o ZÖÖds «ßÕ­ap€h :þ9c "†¬– NŠb€¾Û(Ú•€cøa[X)¬îúIýÔëùNS_Žµ]KU¯ªªýS>9t2Ø–'¶†ñÏÚ­eÅúÖ«®±Ða¥ÃUɵƒT¶' Dë»æÔöþâÂÁi ¥N îÔ¯O¤eÐUiýÍæ1Ö`gö„3FÆÓ®]u¨wT7‹çj©Tü²¾[:û‹xb4Úž Àï—Wp°škrâì¢Ó)W©Ž× ã¬áâìÙ´ …„“"ú±)k}°“êb Úå–RÑd{lzîÜ#ïRíéÛÈã0b£¬LãqŠí ¡m­z0óÅ»‡*ôíh0 •×i†ØÞõ±e„ë-B³Ã]7)#r°Ô î2ʨ‹;RVyLáà4 QTòtÛ:.=ib·+†¦díþBñÔXìëïj>X;°Zµ£oaí¢ŸÔÿQצSE’îÒå¦X4îÿ ºÄv¶ÎP–tV×Õü±¶­§kPÀ’k´AAý@ë”Þ¢—+~Ðe¾ŸG©ÚǨ¡IЄßü|ñ.k¿jŠÎƒUå8—6¡hS—BåÇg«·¹»å&NCŸI`éÜÀ‰÷rîu˜ÀË|Œ’ ’|Î(³i%”2N‘—¸bÈXÁ:‘Àë»,±¡µ cC#XímFf`X:a¼ÖUP±ŽáQ$iÓ*㺲Ò+d °4Þ§¾áMuŸfÆtÔ—ÖÓë#oÓ“ݵþ¥hÚüŽ˜©î0]Ú(3ãåhØÔº~£Ô3‹îHÞÚ˜=Qã¼­¼ÇÃ7Öû‰)ƒ³ˆµ8vìÂ$×Ó᎔ÐRðƒÜµNÝ  ÔùfÔ,@®ÏÃ…÷~8äÔÊÛU[k©:­¦Im°Ñ¯„é*r,é*gC×L÷+Û`V†Ôë=õ8Ãóí2:ŒÛÉ©JŸP,k‰ðpÜ´% }%S@c§òÊžÍBV²<ˆÄ÷íy `'Òf ˆÏZ© À8HÖžø†ŠÎçs)׬nürÄÞUêäíyt9[ÓWÿ"² FÕzêǦî>ç¶(A I;zŒâû‘î,¤Y–3;`m* z[ÕêËh¬{œ3¨žÒHiÝ'Õ9ǺÞO»Ìv-U2×¢“>’?ÕɱU,.­Ô’‚Htôï×Y}œ‡¥t*t*tؤDzq7+Š¹ˆÌâõcPAéU@{iú¼­À7XÒzíÝ «\áäÖñu4¡¹kµÚŠv3šÛÕ½N¬¨~\<Žeët)Y (܇Ô}#Ï) CTXÒó†T&¸cÿŠª'¬m:uèrÑÒÉ*Èà‚˜:÷ƪՆªu:tš`k¯A…Ò}Ä!”tŒ'¨PDŽšâ€#±ðÍ¢!„©Æ*Û)üHðÊ®#W€c¨qHRk*6°Öcl¾¦Ú h œjlÊÀ@ï¶vOè2úFîZöX®®›Iï×{šLB( €Äk8¶ðÔåUÞÐ=PÆY¹«HkÊtì1)®Ãí4ÊÄ)8åJ_©ã]ó×øbŠ¶“hÒ`þÙé­51„Ô¤'f8.V ÓÜôóœŽuÀÚÃÑQb?3c×°ü½Ðxœþáë»ðñÆkißd¶ )Θí]b…*‘ÒI×L[=HÀÒ嶲ë鎜××»Ðû¤m:zN ¹XÁb+aùDÿžE#uct†ÖvXU½nKuÄF^W”[=  „ƒÏyg’WY1†»8Ì–©7+×ýÂ˧AÕcÝO´£u•˜â`¶Ãòü1Y˜ Œ{ØGE>X¦ØKà~Œô ëç‚—VÙ_l€5P‘Šiàí, 4 öØ|é¤|F{ËÈöŠ®íÇÕº5–NÅb§h·†ZbmêǨ Lx£ÑîTÅ­˜ƒµ¢zxˆÊ¯ãÕÞÃæ†Óº‚@P>9É® $€ÎF¥  cãŒô¸S´Àê #¤|qéâ¶ã©±kX‚5,ÇÀe|šÂJ€dc¾½Úr׳Ó*CC$i$xk„º…µJŪ`¤O—Lº÷åVT!Ò!,®°ÇóÀ¼ÂU¢.¨®­¯§l}8C)@§@t*‘ÿ0Œã2Ûú4Éi“ºdÁþ9Æ{+ïƒí–Ü6†X¯i( é" ÎWcÊ.øRHð:ÿÝ—{ £z“¡`t~C,ó§EíøáLþ³ŠP5ürÊönµÞòñÅÙsì:2!Ö;q«ãò’@séÇǦ3£ôŸYî¾ဣÃé-4Ôç¢ÝÛˆ|OÕŠX¬CZÄnn³"1¬ãÖlº²MÛNÝ»µˆl)PVjjsÈ5xŸ¬—úÕ¸á! ü¬4ëÛ¡^Ö2Ϧ Ôykm2º6·ˆ:™ŒMÉ6âlÐð6Yo¶°¦H=YÓ¨׆b„’–|¢AÔFq,ÞÄDLÌøŽX#tÌxåw#mÞu ÷-ýB ˆ=±[7T#æýݵ²P«¬b@?H:ƸÇUJºƒ¡»bPû{H`uW·ã›]B¤ƒÐ¬wÊ}ß]bÝŽÝ&Dƒ”XÕ ,ìžâ1èÀC<º•õX6†Xj`ü2áÊVz¹,l4×fÀ©1«NV¦¦àY=áâÆKðÆ{$-Ú431ñÄåqÁ–iTèv›wRpßÎ¥ïÙ°û(\'R~HòËUö…÷lšÀ ê¤F=¿n¹x#’ ‚Ïœ*uô Î;¿¶hG+ȵg{Ÿ¦ß×*¹¹¤—¹Mibë±ÔâD)ìØ—R–ˆÇÞä+#éµ üã–{5«‚”z½ Ë 0Õ•óW‘OÈ¿öÕò­`U,EõëôåÕý»ïlßtûj„çý»•I¯ÜyÚÍC@Ã*·Íƒ›Äå~וÄõ6˜Õü°צ7û»›dÿ¹Õ}Â…*KP§Û[™¯´Keÿy~Çí67·W3oé?I=·vË+SépF¶ã¡`-ÁÄÆ24 ¬ö1ÓO1•‰ŸÃ s!tx`5®¥`Ôbæ@Y_5Ó§.FhÿKvÏz¦–©ˆbÝ6‘”Xë$¨ £Æ:Ï㋲Q,:(ñîrË-yjŽ¥zœ'Žƒyù½È ü<óÚ±ý×Ex;—NÃá…˜8!Gyë#¶˜ZÂ=ÒB¡X€ƒ´c»&éaµÔìé—dXNÕÇ^Ø4C–†ù€Í aQ…P~š’wØO¤šàâWanCö…é1Ðy``›‚TŽ¿Žj¿ÿ.JKT"ØAà¬ê<²ÊcÛ“!&ZgS'ÇÃ¥oU‹¸ ÓN梛 ºˆüqQP ,HwiÇñ8ìhÌ¥@cßIñĺĬC‡R;ê2Òž ß¨¢IeV:)Ëkµ´L‚Fšâ]ÈQ]ªKiÐƾ‘ŒÅ@*¥ÑH ÔŽ‘â0§…· µYßn°3ÝJÅ\êWq%Ö>_ˆŒ÷m±¬w³dýD綄,ï »PTXkIžŸ dR 3{Œ½Tþx¬±Uêâv“©Ï ×R«´ûk•Þ¦CÕÁö¢ËÀ4'ÔÌÇiUñ–ËýëÀç:{µðnSb© íµ]wì‘îµ~šó‘ÂæYX±T §Ví´2º°ê¬¬2Ïh}Ch±|²ÞEŒ¨·$ÛÉxUNÅLçè(³ˆ–5%ÏKÁ-ý=GL³ÙÖÖ®7Ê,?Ó×MÑœ{¹ö‘Gl¨t°“¡Ó¸ÎqJƒÔš+êÄt žž¬ârœBÞfÐdlej Ö>õŸ¨UDmÓøa.6¡cè:È?–URB¡ö ÷'¨#¶Xvm…!›¡o,-µZ²Û€S'q Âœ˜¶ÊTIˆ:‰Ž¸µƒ!Ĺ.Ùœ:€¾?Ë$v€T|0”ßGA D“ êqÙì¢î"^ÜWäpnKk÷B‡(Ycé=~\KírBÌÀ9"í¬Æ UÓSã>j[Çþü£Åã·'›x5ñé@YˆPX…Q×Òá®Àü;ÓbÕí€5õA©Ü'\¿²àûö'¨’<{0?êÄF²›éfô‹%AëÓÃ÷¥Í?µ¦½Îe¾eQ,brÚnªÅÝÆ îCꈓjжÔ÷$ˆ#¦ªÌÔ€7k(D u¢+ZG¤u…ŽÚàûw “ȯýÅmnü¹;©áÛɨ3¿èªªÚ¡S’ÇvæÎ-\ê+vbLèT͇™Âã_Ë ‚ÖYÇ©œV'ÿpóz˪ú‚ô:H Œm„ÃCZð E'ÃLCˬ[p…L(uÄbq¾ÛÅäØŒ–=zÃ!ôí,NÔ åœ.}_¶¶½B3žä†RÈ˦šçº°áN…zDvÊÇ÷+†B:š‹^–íÝZ‘±¢"Ž}½,`ì]¶º˜$ÔøœäòÞY}á½OM®GÀå\š?M¬¼Èw)$™%È_Ëœ–#P  º“ºðReÓÿ†3£”ã;ꬥ6)?0e>¨'·«»¯¢àjÀ É%Wêʇ8%«·b«´@m_—†ö®ª†R§þÞX‚³²ÊÞ½˜ƒ'øàáìÛMÀ&Æ=Æ’¤÷ÎUÜϺ/Ý>×g»E|„‰Èâ¤Òꆑ¸g6Þ/ž'ý-•½š¬¿Š„ï²  ®ävïú?«*æý°rÛ‰÷ž {ßîȬHc°û6Ä>ÖOC|뜯öó}ª³÷Þ2U7Û~Òñû}º¡wF…Sõaâòø g?îzHȃ´Pðh%K@b&")"€vù'FÞTÊj\Ž  ]ÌvI þ8cƒZHþ #¦)K€ê2l¶ë®(RV¨/_ùHÏXšzT$||qÍAìž­§ðÓScÝm ’pSr†R»ëѧÇËwY΢˕lNÒžsÔÂÇ2 dô:ã;‘´ãÚÔèšö-ä8ÛÒž&{ a·`Úuqœn]€§ÿþËôýÇÍßÿÝ—Wrt’:I3d3T­ëY:Ÿ.±œzxò@UKY É:¬tÿ «÷®#qµ×ulä =ÇOô­‹ëõÔS<Ðè~ /¶ŽÀÞ€Wn€©n‡ó SKã0 TvöÏþ#’l‚öXtf¹˜Dí–­*¶Ölcíž½dƒá£—Åý¿¸DpwAú”³j£ý8}’Z™fFëÃp™\¯‘Þ¶|Ìzj49÷KÈû×*˜âYh¸×]HÕ#ŸÒ(CÚÖèê˳g¯>ÕÊÿn­y9å'ÞEf-èc]Åš¶ µõ|Ø”ReÞ Ô¶†?ÇÆ­ÜèíRwÃÿ¸>ñÈŽetìàR¢…F¶³`@ÎŽöܨ§ÜÛµkÊWˆÞïÛ¹‰¿ƒeÌ Ì‹Y  2ŸéÏvô³q‘VË,våõØÛ¯Ô1ŸKm‚¬–·ôJ ‰îI>–ÆãoÙñÚŸÜYV×±–à v®¬íêÛök?Û~÷È!¾ßβO /z.ïm­m+æü5ð>ê>çöØö>íÈ°'¸Ü¦@è–Vçôëe!·Rüž¦Ççpyœ®Kp}VÑo„ÎË•?¢²Ë²»Uþl+YëHï"N²zøbT}„z‹<´2IÆrwi>:/°7h3Öd†–¨2°ÚÒ>ãßa%ˆÜÄ ziw7í]¼k/z•ÄN@¶ë%"û\ÊÓO÷JªãýÒ®º/·÷#ˆµÅß2¥GÒkÝò¦p¯û­ÿµþÝÎû|žY„sb’¦šTµ²QC²6ßow©•su–ñ¾õÁå5¼k94¯Ù°Ä%µÉ,̬¥H;qøÜŸ|_~ÓÄØWØ-1¶Ô:ë::ŸCe_rÿn}ƒ÷O·“hºš/»Ü± íÙs+9Kîù7íÃo?íö[ÝI¢‹†ÊËj·yVðTÞÏ–µÕÃûbÖû§8šxµ©1;â]µùWÿNp­­}ÉÃû‡°BôúIŽôèo§8ÿî^O%~á÷N-ôÑOÚ¾â€×ɼ®ÕÞÏ·ô+…±¿§,û§Ü¾ÏW®‡þ·Áâ×g¶Þݬ?VµÚwAØCz¶çý:Ÿ¶ñjûw;€‹ÊâWÇF²«-R¢Êýµšý'åfúwmßœîÝÝ>áU·T^ê¸ûX0ÑÃ1ÝmÁ+5ÙJ'¥ŸÓ”óp“…÷ ªï¶P¾×1ÓŠ+¸~å„{õök*­žç¥¶g-¿Üoçóy¼‹H¥¨±€¡Û¨ë°‘é¿v5T}³-­›dñÞ»2õ1hú’ mm¹j?ê¿Ý\.E¾ù¶«Rŵ=ÄÏ®Ýë5ÿNìàQÅâQÂ<}ïÍûŠ*†½=.…õ!¦¯3…ųî*÷šÄÌ óêÝŸqàSU"8×æŠÚºÑ!GÊ›]T‹T¶/ûƒ•Yf·Üo¹rœ~â•FC-Ǧ§®ÝÔݵ^Ûjdsúq¾ÇþÞÿoÝgÝÈ{x¼õ´Ö—ŠîÙeo￳géÃ*#{ªÎ¸ü¾WÛÝ(ãÕFÓj© îQêH3œ.=|ÿÛðöµüc_¹'ÝfÝj¶—Ú6n×~U÷®g³öÄ¿ötýƺì¬[b®àŽ.%·{a¿ý^¬¾´Bk !¶øi:eŒ¶„&Iƒ;HËþüx«Éàð\{̶ªÚ*Þë&íû.qîã±K+¹·ÖÆYK‰ù‘–½«%á¤ê= i‹}Õ1Eô¥U6Ø`:ÃnÎk·Ü8ü ø•³ÕG+Ü yPNÅeVU0>k6®ª“¨‘¡¯ŠÜ®/ ˜<žU¦ºˆm=Dïßn?q?oâq®¸õ;Ò²ÛEµšß[žê1xÔr©æ½nãriÜRåï´¸FüÊáv¶%Ÿs©øÜ.Cí7Ô›˜j$m$Iø¶XxÜ—æp†ãÞ ÖÌŽÜÕ¸[]½vúr—ÛèyV,}GÃ\ÐÆ:Jüs‘÷K^ÛQéùƒÒˆw€HSFQGy~•§a%C™€ºi·)ÿcýÓOÜ~ÍÈ>õÿujYŸ‰Èt$% Ó+]%×nrøÿpæûwÔÎ-¿Œ!‹*ˆež›¥ZN_OÞ–ËþýÈ _ÛþöšúÁ„ˆ]ß—>ïs#ýµ>ѲϹXˆv^fÆEsî¿nåònâ}‡îeMMV6ïR§r†¡éÛ»nº³*?X_­tЦp×G“È[’Z(ÿÌÀÆ÷~×kêTO0+4ø„A€Uö$S×õ9—?åUÀéöŽžÞSÏþ¡’>ËöÖby$IÿŸ!~ÉÀÔê'”Gÿ^Oý#íÕi®Þ=„?U™e÷QêŠþfZÄù·dTœEÚ›Ôûj½?+wÆ>êÖ\ÈŠi Á0ƒÍk[_í ­~Å^@e÷‡ÎuzÆh·˜Œ"šÕ¡·†sï·†¶2´_fÓT£óø|¸x—}›öÜûj)_¸&’Â!Ì‘ Ý°ºïDÙs¶Kj Î#0’NæÆ ™COS”×ôöñ'M°ºÇEü0ºèÇõ'O#Ž Û¨h>Ç?³ÿ¹·©ÿ͆ÍG´ ìT&'\TëMÛ¡€;£^ºœt¹õ®…,ÝZí`L–_S†m£ó&r[íÜ$ÙU|z©ª™åU_¸ÅŽ¦@ù½yÈárƒÑɨÁ¡f—$ˆÚLh`­ZØ}N§ÁØüÓ›·û°¬—ñí0ÊAô:“þiäZ+®Å4-m “üÔ#]úJ÷DYd_” ¦ÊxKŪ H[̧º?ž5ŽkàÚBämWpgÛÓñÃÄf ÝYK—·ŒãÑG&®-}555ß`´Æôb°@b'æôg5~éÃ?wû—îëÔymÆ+W·ÕWRÛT_—8_ÿoßhû"Ƨ•ÃæmnGõ°Ù\+×bÈñŠx¬îÁ‚ÖPþ¡“ gË)ÿor¾ÏÄá]}÷pÙiBÇõ, ,ÉküÞÓú?£9¿oû×ÝyvröŽE<û­[‚Â?OÛq¦Öù6mUü¹ÿZás.ç¥VµoÚ!lôú6?Ž¥C%À=ˆÄèH‰Q¯lûÇ&çQ÷.[ìoÛ‘eÕq— dµWoSg+‰ö¥¶ÚyWŠ«±ƒ†Ö‚}ZíÙgØ"š¯ûiZ9v ªkHÝê;vZÝcåÎGMf”º×Õ –%YX|êGËœž#Xß·µw׸'¡üF5+ÕR¶ý£lõþ£óg'—Ǥû|P“ÍÊmÐI^þ¤OÍœWôç_[J-?üvÛý@ý üßÕ•ý“îq»÷¸R¨Ö[Å– =ö*Q—õ[è÷6¾Ï—>ÜŸíÿ¿½œ»‹¸ü^_»r€ê»˜rŠžÃzÿéÎ ßt¤¬_:“îqÝÆ¡Aƺ£îde•D2uÎ2•T²ÀZ –ÀþDcX#a€ht=pPZÙsXV*…tñøâÓG¿uZûWÓ¼X·1>—©†s“Ç䲪V6ÝÆ@J|ÛMŸ1ÚØü~#Úåq‰?µeOfÞ8PÁP8'Üëþœãó-ãr~ô¼v û U^vÖí``”5ŠŠžßööÿVr/ÿt}å¾ÇÅàÐyIÅâqÅà ðTÈ¿ª3‡÷Ïö¯ÜßøV__¥õ~Úî-¯;Zõ,ÉíióîÎOÙ~õ¸sRëW™ÉãZREjY·(zˆeVüŸÛÄû?ßhW­}§¢ßºÏ ì¡Y’5¤¾»¿P¶öOV7ÛþãÈ~Û9»-Åt¿‹} 짨~’ô–UùnqþßÈ¿õé©}ªyü…Oyè]‡Û èKXA‰ýLæ}šÿµqܔԩy'bW\¹G¬6ÇufÜŒsíô}“–y¿¿ûM÷‡²Ôzj»Û I½:«kèa½_ÓêËù|Žaá}“ŽþÓ}Ū7n_NÎ8]»ÝX|ß*ç“önU–ñk _#˜YKMDÃ8ªOm§wú³ííO÷96[÷-ÜŠøûB¹°ØJ¶û&ò¥Or·Õœ´ã²ó8‹InšPÜk•fÍßR6íÕîÛˆ¿oçq¨àrMVQ÷ `0'}2VÊŸÛDô¿ÍŸs¿mny<†äþíÂü‚~p©FÕÛVr(ÞC€+öÄËeNî¡GåϺÔ+zÿb-”%l62–•#U=³ŸÍûѳþ‹ÅcÈ·Œ}/uö£ØV£ÕiÎw;‰o6®/<¦·(´ ÊÂÀÛ¢«8¿íÎwÛÐð9ÆÓq¸®óg©Žèk‹Ÿêϼð¿Ü òJÓÃåò*~UMM°j•­½_×µÿ¹œËxwwù>Å|ŠK*zžT,éYÛ¢çý©ÍáQ÷‘u¶Ó÷ ]ëM®w9°{¤zƒ:ê=KógÜxR›,©k îƒUõ€í}CŠ‡µÈÝwFž¢&>x\NE•-eW“öÞS•[Kºªí·ƒõcÔ#îovµ$ì“ü§Óœ zù\t:õ[:2ü2ÊZ¥¶ÚíeöÈcýP3‹} ´]Ç°ÚìT·¡ ÛÉ]>]¿.pþýêžý΀üŸ¶ñ”ª¥é(Ήò­víª¿Õ›¶m$ Ru;Ìcá‰ö¤çP9К”#ÛÅ® PЫ;H÷wg/íö“z}ªê®û}À(ý¿¸Î,Œ6ÖTc"r¸¼kl1†±×òàážfî)úv´• ¾£Y:Ìþ\¶Ýþå©x)ÄPAí™ïÿ›+åZ…ÞØQLjeỔĤ–Pè`ƒ¶g®q«nC9­‹òxËò£T¡?ú³öÿ¸µƒ„וåòÀ‹´–a3—=µ‡6?¼n,KŠìã¦ÐzÌçÛ­åßdzíw=¯Åå3z…•)e©ÇÒwz}C8ü>sÛħ—î7>æ!³¿¸…BŽÇÓ÷NG),û…¶Rím°µš›N'ý9$‡¤‰Ri¬(;<ðZYÇRjIŸŽÑ›ìàñ‡FT*G Òë–Y¬ |=X¡8t  1ıÃíñ)1 0YÐw€rYxë Àþ8÷-”¥Tª uþ? ²®O.²ÉfÛë§RDnÜ©&FÀå-(+"Ý¥vI 1ª½þKzêT 'w¸ƒUÝ®žk–3¶ç$IŸ” `c]Æ䩦K4ˉ趧ܣo:“¾Þ0iׯYÏÞ½×d³®âv5êg®– öóÍÄh£¦ßôÁèIÖ>{9m_Íãž¡Æ»e›@d:*™ƒ…‹ˆ,@íŸÚ?4öþßæëü±©Ñ¬1eDÄ‚D‘8-qí³Xz…/æGL§÷½)â­ÐAÚšmã8Ü=ž#[Q¶à!V aWê3¿«>ÝÄç:sþнy¾Ç-WÕ¥Ë^çsÅRÿCã¼]ü —R>—B`Æ_Ä6×i¤K±¹:‡#ÄtÊ>â”…¶‡–u–Yv™Q¶sƒÏáï§hj6Ha-ÓÌ4sk°¹0.X¾˜.½š¶¸I NòDŽ¹e*ÖhõRL^±êá•Þ]kö^ĵ;”ÏVŽÆ:ç¸ÍU\’ÀÝÈ[Tµ’Á’TIÐçîuó¶òyÖ«žYW´!:Ü‚Ñœo¸ñø¶s?éß®¨…WÖ¿!õèv?l[êªÊù”;Y>ãu]L dsî?väEŸr¨WXãXEkX¹B ±3‰Åû‡Ù9|6SŽíb*3°îƒsô-íŸÍêË>ÒÜv^^ïf°Hº ªg±Sºr›¸ÔñÛ“öÕ†å:Ë"!HÕÏú²žE—]Ä¿“Ròª¤ZQ‚ØgP„ûèaŸrû‡Þ’¯¸sIjë·¢À²º Ì^ùöŸ÷¯ ”1z€!†’Åx×çù²—bB&íË€&H•5[B‡s$ŸcÌe_oAs}¿›h[^¥‚çi!dúO¨mŸ§•]/îñ.0K"ÁÒ¦íñüÙ÷*›˜ÿkû%Ç‹RƒjÞÝÑÛ_i~õc±)NE¿û!Û,*6ß] »hÚFæzýL>óö*”q–¦Ýijá¾],Û;Žèܧý9û¹Òxî© ‚ª±e] æ¸)1áÛ\qh{¹ÏUZ k]ý#hõÎþ]Ÿ¾Y[[Îãñ[rñ`Åu›>G}~ß“9üž/-ªûÕ\Ê*áV Å[Ë™ÛÅBÂçÛ.ä¿ÿÄ>áÃÿ¨rÔÙèöÙŽÒ½ ¯Ö«š‹fïIV%¥„Lç ~äã–¼Ô¸ño ²5w:«&öúë•ÜS9|ú _s¥h8î 6TD¶‡Ò˯ɟÿ™Êªõ¤V’+6'éXîL¶Çú?&}ºµSG¾±äÞ¹;‡êÝcS—:ÿNìä}é-n?'†*Zdn­ÒÍÁ‘×PWÛ êÿîmÎW ÍáQÍå9©®b+u wš÷%VU0s¹oàý÷‡Î£öÜž/>¢èÞÙ܇­Ã4ï\ËQøÕY ¶ÛYLúk'ò 8ü­ÙǮԬVeeUˆ`캶Õõ*ŸVr¸tž3ýªºU)<&n<%‹¶v7ÈÿU‹ÿ—Ž:­¼7‚Õ¡T;˜G¨!ù[8ôq¸ãõßïåˆ]A0ßJÀè2¾Ýý“ÃåVȨ7éÙÙœ¶®?>SþÙæÛEN"›¹EAg±Pép²}í:lÄûWáËJ§•À´1ÞÛL±F„í¹:« tñþæá1s]è¤Úu&Ë%?ÏÙ¹+_î¹VÞ‚«71+ZÅH;½H¹ÇJ.®ƒÇÍœt ¶†PF›»HÅâýÊÏÝlg²µ,®èZ‚“è,9¹Â·ï³Æ*ê–20?ýÂTɘÎ_Œ ²žaMŽeMvúYPèǾ[÷︑zÔõ¥úÃ({°‚æiÛý÷o¹òBµ\°ì.P+€(Nß(Êo¢9Y–À*=Øx£tųœëg*°»p Fªí¬ˆRü¹_(K¹6PN5a}*°AØ|û¾¬á) ïq¤@(Çn ëÕq*áñ‡ sO¿c™ì7žsŽÞûÑÌ´µ”×LØ zØê6ªçÚ«ûg•8´5|î]„=×– µ¶ƒ¢¤6ÈƯ’ŽëUL¼¢#vË BV™÷>?¹ŒÕXœ#~· z¥6 Ò}ßK6Wö¦6ñ_ƒY©ŠmÉmûŸ»1ošs‘U–#TE65ˆÀ 1»NŸÕ•ý£ŠõÕÆ®ÔåÕË²Ä ©´†©GôãmF7§ê­–€™ƒžÕܺ-ß¹}'Á|1“‘ϬÖNúܱäs÷vr-²åe²µw¢ì;œç£×cr¹]R[ìØë¸:µGE&X)϶}×ì_º~AJèäqÿie~õ”…Q´8„OËÄûgûcîMCrZïqè*ÅÎѿ厙Éãýïí\þ?/’ÞÇÚÃ{hÆõ2›µù~–ÍÍö¢ÖW«÷òøõ­€Ú ±Õ\Nìà}¾þ79VÚxáG5mJöZÒƒÑÔkÌ·ïíÚY„<¦² ÉÒ;ãñŸî¿kãp=¤6óÅ=mc|ÈŠ=A†ÿý›î?p;×ÿÇûq*Â~PÏÿ§/{~Ý÷ži[h¯„õqÔV ¨¸¿Êÿ -Áÿg·ËÃóy¿q6”bJ¡Û¿ÂsEKön7!Pn¶þ œ¾Q$õrLcqŸîKÊâ1FJkâUĬ2´üª73—UbÖK¦ízã·ŠÜ5Ö„Αˆì}AaÔt“‹_Ê1?ö1WbX÷$üpÙ©§p;O@AÐÇ|÷+$ßt«6¢œgÌ.UàÄÿ ‡-È=ŽÞ$œbè_l£Äa´µtS•ØP¨¹ˆ­Ïq¬˜8V·[[k#uÜ1ª±,"MÒDÑŠ1aA&g¶øM×oÌ:û±ùU!e-Ù´Ÿø`äs—ôo·Õ«³ü1ÕéöjoE¢Òê—ä áøç#ŒÔìt>Á†m¬H$Oo§?Û<îZ„£‘È«ˆ^ßI_sôýÉð ?2çîÜ^J¶òìd³YÒ›o,ÈP·M¿&UËãúùT¯µ}ˆ6ïq¨0:@Åà[ĺ‹Š·±á ^~a®[È ±©¼©?HÚHVìzá¶Ù`ÀÑ·_ðÃÅEdpêò§Ô@ôŸˆ÷d*¸³Û[@¤‘9]Ðb×jìiõ¾‡áã•ý¯í¤ºÙÉöèaÙCü߆}—ìÖäYƾ»y¡*Í]z,+·«l|¹Ææý¯íôÓgöÜ>3Ù½ÍT–ÙeÖ@Ým¥µoË·Jï$ï¤).©ÐŽqøõµý¯o2þ=v~ß÷.ÅÕFÓíËÿVUEÖ—^ŽÔ‚Ë=§L¦¯³ñìçÜÊxüz ‚ ƒ-Ò6 =ŸNUö¼ñâÚ‡½÷^5¤íw´zj~]¦w+gß>×ö¯²qx|-_eu! c‚µ õ„=r몧héÿÕœJi*µs™jš@ÞÇH 3ŸnûÛÅŽ?µ5riÚÃлt#êž¹WÜ8DþPä‰K˜4™©V-×>ã÷>R²}”ñŠrÙ``mÈâ:kþæàsñwUoÊwoW4…±Ê½~©_—>ç÷o¶5ãí\Ë|Ÿ¹$;[ l;OvÉt_êÏ´Ô9 w0 –½q·Y¢;/£ÝnÈ¿*®]\oZ[b¾Ó·þc”}×ì5Uw+€}ö÷5½°ágê#w«(¨q-ÜÖVLIw;™¤õõ}9}ÂÒm ÙeâÆÖ¸#·¤g#•÷o½7;îÙû>ô²–×Ã{gs £?ã»(¦ú†Ã5SbNäB5¯_™r×ØJÕúA Léùæp½Ü[+¬¶Õk‘ué©Ã_³-ƒí¯ýC‘XSM¼‡õ{NßÐ;gÙþéMÞÏ>ÞÐþ’ ±¡ÁX,þ’¿êÊ~÷Äq_)îö졆¬¬¤‡¦r¹œÏJqlWç;„J«o]?û“ƒÆŠxÓÆ£ŒX{f²6€ê=]zçýÃÀTáýìsšÛ8÷4Räþ¦ê•ô Ÿ™½YOÝÛÿî å#UÈ»ƒuiaäuBÕ©;6üú/«•ÉûW›}–»7!šÅùÏBªchùqSöú¸©¸È©¬ «@btÄqh᪰­¯‚ʪîÞýq·}óˆ¶QXd5qÜYî·Êêä§B¹E”ýž@‘ø¬›nfù£ViPÚåõ¯%ãŒÌ×Z”첉úSX¸«C}Ûï\ŠÎÒV¾%bJÌv%~sŠ+o÷;•PV«^ž.5¶}£ýÑ{¶=ûdÿå´Ó9–ñаn׳Ýy$–ÙaþÞîñ‰e¿ì®»„«s~èT<®®'\'û7ì5ÿ»Ï6uøŽ¼öÇûlk ô—µÃ!óÓ 'í-ʶ ‰Î£Ý¥cÿ²ŠÜ×gû~›¤€+ûIe•êÔe¢¯¹}¥¾’©ö•]z|ǧ–5œŸ½ÑÃû•µ*Ù÷B2í_·òî«8Ô÷‡!é勾WŽ?´µÜÅ È>ÝÆ·ýÛÿZ·™È(–Òà·q_Zò±Ê¸Ÿ{ÿr}ßÚ´ínE¼§U1Pž„çÙù¸r¾ã_Ýù‹ZÛȵ˜54*Lcê˾ÑÆâ-âªØ·¼n±•´8ÜÍ´¬kŸíÞ7Ûø5Tœþi®ôõèvúâ}8Êÿfà"!â¥ùc^ÙÏ·‹öêøŸo¯‰íÓÆÚŒ›ª}¾àÓ«g í´qhäJ²».ÙhH<3ýÙÊ~Ec˜¼×o·Ñó  ª'9Ö}ã…ûŽk{•Óû:A@`Iž¡³ƒÆíÅäÛMPÜËŠ¨g&~XÝüñnä%)k=ºUUWâWý)b¯Ì\öÕ‰c¦¸#®¢ ïÛlŽ’dÎȤxuÃXU¿Üõ¡'MdwËYZkH 8×ÌiNZ«Pn]ƒÓm’@_1M†WæÛÛøb¢¥Žút=Å}å5`½uƒ9ºÔ/c´o 0\ž•ªt=g>wéîüÇæñÍÖr¸Ô;i'Ç>åutîv‚–PBÖe«°wüߦ¸¿wäñí¢‹Èö-²"É6Á0vùc}ÃîPµó®~0r¨A>£>—Û&Ó•òùz¯ûWÙÂÑö® ís4ˆnC×ôîoíÎ[öÏ´°^O¸‹]À’Sêtéó6~êÇ-Ê%Ú„j" ég*ËÛ÷Š†Å]ˆÂ=–I…H+Öþy Ä[¸Ä½vÔu€ Ažþy]Õ^iê tÚ¬;çßþÅǵ7ðêo¹r˜²¢­ ·ÜÛ'W»nSÂäÅ^Z:ð9ŒB%›]ßF¿Nryôìû…¡ |;'Ö¥´h¿óÙ÷?÷‡û›•O +*œjob–ÚÌEdKªêÎ"}»wìÍt§Úì ª8kO§ÔwgïþóDÝb§ØiÔk´3î_ÛÚ¿÷ÜÞªEƒc GÊ`ëù°?>ÏgŽ‡Üû‡%ô¡h%‰ŸStEÆâ‹ß‹þÙåñ¸Õ\á]ê3•Åã[Êû…WÛ-G²ª°=¶€5fmÛ‡§nr8|ÁÈ£vëE Zu‚ý†š®r­¢ÏÚsOØ{e-¹M¨ðÌÐUiôz×ú²±@ }êŠÛ•ÊæÚÁQBŽ:§LO¸/&®H¦šÐ)s¼¹}¬ Á_L‚Þ­»sÃás¸_våï¿›÷7 .÷íQ]Kc°•]ËWé~oV}›íÜϸҖÛÇ-cñúèööM66{Ê=;CgÛ©ãýƾB>Ò5.!‰ÞacÖO|pv'Þ9(Íw:f®6á?7ÎÀ~_—>ËþÝû_8Ùöî®-Š¶:r-ô‘o¸lP»‹|«»,û7Ýkn-\i£‹È¥†ÕØaìå5Úº!ÛéÏcí—r«âòk­Öùªßi’Á¯¸Â¿î|›rÁǾÓÇàÔ‰`tÐ2]Uࣟôã ªk¾ð¡OzÞÃk ²zÿê˾Â8Vq\1±mùUím2Çëõ;7ü¹ö^|‘îpø­J…‰3û¶Èë ÿN_oíM}|5÷k™TÚ#Ö­ó7×ÌýÊr‘²°•ªí»)ö7×¥Î7û}“Wª¹}ëî{¡€ùdwÇâÙMkcòìºÚÙ…« ›Tosòý?›ï·Ò8\>) ÁâÞ¶þ™êÃz˜+»¢F[Æä}Ž¾_Ý+«Û~S¦åGp`×$úzöÅû‡ù41F[Ƭ0ƒíÈø®þÕþß»…È–¯Ÿg¾,wˆeR¬ŠQŽíU@'þŸGêÐÍ?š`N7 Ú‹SÉF5Ê…XQØiß,±^«xçZÍv@•1ÜE6*g±AݪŸðÏݦßj›ÙʱYB&tŒRG¸ž´­B“$ª$c\ü”DU!ý½òv€úu×ÓžâÜ”ûíÕw‘¸ Ùìº51eOZ¢ØN䎱×qù²„Ns¹f{Eˆ'XÉÿÒ§=ë›w6Ú÷0d X†'¯_ŽSC¥n¼ôkj 9¬'¸ ‚ëêH9ÃãrÚMV¸ÄAd®­ÄÄ å¦~¬âr_ÛBö2›ƒ…³lÞ§ªî8ÕY÷n(týe¯p(YÚwÌ#*JT½iu¨¢^² !€éœ;¹w«(¬ÈŽÃA2>­3—wýNÞMþÛ½UUMš¼‹¢xå÷>= %Se[%àÇ@Ýs’~ßÆæ55ð¬N%fµ]b•ìÃÒAÎ=ÜêÿhÜ[+²Àî´¶ÕÖUœçï·•(F[Ü´ºË6¦‹9þݨµ\Vû;×mú–5°±…‚3•÷>O59Ö›ô64ô!Zc>ÛÏu°¶Xo®µ@7ê,|¾œn=TÂ\¥YÉU`¬#òrÛ¾Ùî!jJ¿»qcÖt*;î)UœÐmîìX(;„ncÒqif㊬2k)_©›ðÖs—ÆåÑéµøþÀudeh ª›GËù½9ÊGk‹W­E‰õtГ‚‘!Wê‘劷[: õÊ™P× Vd°"dK&u+çÀ0tøà[ºHòÀjô³FÖ‰ÐùcI`ÈŸT u¦]{ËÔ¤’£¹ÖlU¤oR'¾@¸è±Ð ‰&NƒñªÄÕÔˆî:-Rù¬'æo†ä2Öˆ»™š ‘×¾5cØ¢Æù˜~ó'ö£åÿÑþ¬·Ý?ü’¡¿0:J“¦%UrY6rˆ'{;ƒ9õœo·û¬~×öÒ/È_i•’uVoÊ7ËŸv¢ãmŸvåÞVº[’öqÖ¸RŽhÛldqêÝœþÍ¢K{—ƒ†Â[Ü#³ 5ÁÎäžäŠÀÕWY  ³.%¤,Të·Çå¼·ÀT#Իǧ ÈæšÆòÌK„˜ÿÇ ®Ÿmìv—Ò$|s’˨(^݃]£æ×à1GŽkãò8þžÑuk 4•>°~ ÙŨ¸·‡öâ-®‹ÛÛf¯p¨WTÅŒü¹eWñÃqì°_§lmV#©ÙáŸeãSsWS‹U­ªíèBTw«¼ul Ç÷ê§ín*áñowØ›~P«¢íü¦0sùöN7*Ž7¹#e·£=®Aùá*çñùbúÊ-e£k+¨Ò[SO3íÉÈpžG=Ý£púT4ؽ=_6}ËïTq‹SBò)á×Ë#õRÒ)Ø“¶+µÚݱófú/½½²/û{¥m­ÍfÅk‡Ò»s…u|t¦Õ_cî²ì­.[y-;`é œj¹í5Ú®¾¢„…‘¸t9ýÒÞEvñš›=ۚݥ¢?Pú~Fm¸“Ë¥ØRYwYŽš âýÇí¾ÕõÕîV¦NÕn›ÖzíÂl^=wݨemÌ“?çœÎ'&ÐÖZWÝu]ĺP’?·>xF^žÛÒR5Ï·ó.±ï³÷kjTT,°$¤’~–Úq«ç>î=¬ Ü5°ÃLüY¾l»†)ýÅ,O¡×MÑ@Ǻ®ÍkÇb#¾ƒ]3XãZSŒ=®9bãmmÕ CéÁÏ·‡]|û]‘šÕk-mèá” z[aZ™ˆ;`’u'HÔ“•ÙjÖ´Ü»z[Åz‰Ï¸SUïRñír©ô8㳄$2žãéœnRÜ?w½PXæo1$៲ûñùŒu0aµž½©ŽñœZùû—›Rm¼z“Ô…úNTõY²;×ú‡ê… no­¾lgäs–Æp7»ÚI;zLŸ§éÏ}~ä§Ùõ=bò PC4j2Ûiތŋ3Ó¾¸üEä-òJ„½ô L·_TfÛ?Üàé?Ž[¿ž¼Ô²½Š•³¥Z|{Î{½JÕ³2™:Ž‡Rq¯çýÓöv$T+ jÚyœãýÃ…÷OÜÚŒUép"ºO†T+Ùµä6³ c~÷u¨´ˆã„$îÝ;·•]öë/ºÙ€H#z°‰×êÏM»ËX’°ãêèwžïÜøƒ“ÇbÄ!0=ÃÑá—Ÿ³p¨Ozºˆ‚ðu“eJ¥@evkêSá‡í–p(¶ÊÏ´lØ ’ÍÜõï–¥öÀImHÆ+K*Yêgn{œ® ˆö²Ö@ü2í‡PKLôƒ¦rFÝ/$€Vg§\†(µ¾Õz•ë1„.ŠÎÛæ?9Œ¦$Ô¬…„÷œ}²°žÃv™Z» ¹(»Qô†‚NÖ“Ô tÂükXšµj]Œ!”#?xn ¶û…PÑ‹·ŸÌi¥P»nU:tZQìVu•ÙéVŸ#\Dä7(T[VF¬#^ø´q&Ê­ ^ì[mQ: (Öu«Ø̌´Ԩ>=rº÷ûå’L–Iï¹zîûO¹T¯Êµˆ¦Ó?Qé»Ë+ZíÇ"]ƒôztÓø÷V²¤EQ©‚zŒE¤{È•3SÉ—xÜííŒiã^õ¸¥„®ÍÍÄxe6Å«]Ž)Dw†A0Ãæé–[[»íYjšÂ'o—á8Gܳh@-ܬ1ÞÚŠ©e'pæ#Ç8¬ ÖU·g*åX©Èã‹7T€²&¹ÛÛ8÷7¨üŽžæ»òŒ_uÎýåG«CßwL6ÑÆWFõ5¯Û¶‘®YÄäÕcX‡zÜѨ˜ôÂ71©Õêüdf® DÃORîÒLøcH††2+PJvwˬ¸pFˆ:qëÚkkXƒa0u˜éÆx5“¦æú ÷Æg“ÐøaêìÞµ A>¥ÿðÁJNË},ÀIœ·íÜ~w ¼.¶õEö1=:ònö½·5¿þå.ghjìIm½õ\ÿþ›ÿsÚÿñ-þïÿ·Ï ÔYUéÇ…dß3:vœ³öÉ]m£XÎûdw˜Ðà?p¾ -ÔU%ÔšÚAaÒ2«le•!RªöO‘ŽÙe†¶«Oö”J€Oõ~^ØyUT—qÍ­Z†@¶)^º“©Ä­?FÅ°*(Pê tõ½vr6ƒD$Ä j?é~ð`ÊKèÂ: AgÂÕÈwk&uÓ9<^GñëãmzÖZAOWÃ=¡ÆU`¥«4¥LÌ)˜çι6„ßa2ûI!€ò× ?jêzìÔO`{cqjâ²q\CTTFš>¹gï¡—Œüy¨²€Åƒ(Tg±k›øö±¹©¼‹Ü©±_ †ÙéÊ«û=uÒõ ܘÐK 0!åŠ×²ï GÀ>ïÜkSÞùõÎg‘jòÇ%ÖU‰§^“‡ŽW½:¯mzô뇓Ïç5•þš§ŠIüg7ÜÙ‰ê: Unm„“ê]<yºª³È3â)åpÍœÒä1ïgÕƒgÚш“¯Žq¨áýµ)æ{©ì:õÜN£+EY1…‰&;‰ÌåT— B0‘-¤ÆGƒZ×кþ8k^5ru‘ ƒ21þáíV –¼–6À=2Ö 3FƒL_Û×zÞv› ŠÛXÿLé÷»·ÏÚ¹VÜœ~PŒk*Öä7mÿÍ–Ye^è¥ÖÆ ‘ºbF[ÉàYî¸mÕQX'ÛÞd¨ñÍ”r.²ÏÜX¥¬S¦¤žÇ$FíŒÇXºÿÓ‹ÊŒ?(b¾¤Þ|²ÒÈöæAb:Ã,§†'“d-Bcùœ%+v-réüòåû³(STTZÅ ¶íz¶†1TÖ¸… [ȶYÉãò©ãq©Û]†ÖÚ4‘ücÿNqy\ïºqíãXfÖ'R¾Iâò*¿Be> qîóÀUPØ^O—HÎ/:ºYÈ¥o¯CS ÅXO¯íÿ¹+Ê{T×C«)m­¬*[Ë+^u6[Kغ«`Œ]ˆ^Ùe´ðl~7$ 5 2…mc^¹w&¥e… L™\<>ÓKò›õý^ã² å´=T jåÓ]›YR²½ZNšŒ«‡ÄBöÛUºtÐ($Ÿ†\÷Û`ãÖHRÌHÐcþaŒÂŸÛþÚ²…·nÝ'¨¦?ÙOœÚà~ã|l ÎØĶʫd¡¶0f kÕf} ø’@Ê™ýJ/ª±cÜN1C1ÐnÅ°»ûë 6΄´{t9½åÉ>Õžé¤hu?0í‰rÖ¾Êèì%·ÖHi „Èa1ˆ¼„P HpËÎNVÜt‹î¯¯nà ³2ïm×¥c¡#®½Lö´±Z‰ÜZÉ;ãœ;éYöAýP£@HÐFq9N0÷CEàÉõ΄xa§ÕW.¿K—&ñ,GLs'0Å"µ-¦ã»VèFP´Ô ×]neQIOo,Kwz¢µÜá¶$b>,^J)IÝ]»d0PJîþ¥úN]Y¿e6#z«*G§ÂN3«¶ËH§áqg6Wr)d€;ùœKÁ.XÌ“ÄRNÉܤž„é8ÞÉÐÐຣé:Z¤÷^úøæßmm-õßðÅj«³Ü*åÐF?kuQ,`I9êÜ®u g§˜ÃUnT©Ü\õ$é¤d}×:îêFffsЃ¦ m4eLvÁUr^ºLB€:/ጩõ ~?´ÖÆ$ÏØàbŸ3bºë¸Î¸ëT‡:Hž‡BLvÁÇå}®ŽEœfR‘ó¨fÚ?Q7kêÊ/áñ«â‚»¹·:±ÉP/Lù©ùýÿîYóxÿý9Ìãð/ŠnÚìIÚDnA#=§@kµ°H#oþfÏÿ)ŠB¯ÊzõÉý¾í½5–q¹hþ`e©ö½õðÍÅ•ZÀ­A+ŒA%Ñ 3ã™Ä®îB±ck‰;IôÀd¯Ûé u„ærjáTò”1Å\TK*¬ojÿNT´#¶”Ú²%÷wÀ´…#“·tÈ;d,w3x&VLzF5¦=Š›Žº–Pt?«Üƒ•…Èøʇۃ³Ú£Ý( 0:a>ÝÆuè{fåªÙÿ,æ7Ý=Ô±-S#¾½ÂI$•$“¡ó-‹g‘QDY½‚ú¤ž„ø`s¸ÕtZä| ‘‘ÿRã»ê»Vä;LH˜$åtsn¬Y[Xnfrº3?í9+ ;šzƒ2tË/çýàÓcö"£žáÐtŒýÛóù—qÍ玺I›7Q]uÎ'Ý©±øö-•?{Ôm¼6»‘k{ jÛ±>ÕM–žv㵸S·RwGl­ù¼cÊã»lö•¶Ìt3¥ûB&Õ•/qõ Ô`ý¿ÛiGCêõ4ŸŸ³ãý¾¡S^Ó-d,€^ ŒnGî¦æ%fDióÞºàÔñyp!EL~o çð‡.ŬÙb×Á°!M·9·ÜûÊ2¯§9«Íã×Èž/ÿ²¤»;'Ê‹ò·¨üÍœZ¨µ…ër×uï´IÏŽqéâýÁ®à†,Ö‚6µk Éa#ÕéÊÑ•ÂdF³¸O`3ƒjó¯}÷ÖÅQ¬¤Á’ ‘ÛzçÛ¸ÿyû“Wu–Tl*l¶—ôîõl é)æ¼ ö]*T]üš·¥ áA©X/£nŸ/«9»•ÙEQ¶¦ÚìcM­®ØñÂ!¬¹yWcW{2l ‘£ó|óëÎOÚìÜ¢·%œ’̪É)?™Èz9(ÐÀëYÔ>{µÊQ¯jø­V÷¨jŒÀ‘%{‘Ÿmgô¢¥„³©X;`.£Ã8U‹TÍ.=°Ae(³ Z ÷­\^5Aù6¹ˆö­{ã«Ì:bGܸªþÁ¿Ùýcb´–Te¯dz5ÙýYönU÷ªói½OŽõ±vBH³õ zGGnpoû’{Ÿm«”ÏP &€AmLå|ϳò›ö*ëÛÄ}Y;ª7ª±`ÁfFoÜ%¬¦d£Iðú²ãA{’Ïr¼!v¹ÓÔ o íÖ¸\ ÑjäÞ¡ØÒõDŸW«lçî¼µlãòÜ[Ö~d×Çêû·«ÙnSû¥^ ýVÜ~XN_íŸK'^ºâ?`õëçØeEˆ€Ä` £÷$ªsìP7„êgL§B¡YvXÚ¾CÏi Êàu= ÁX9©–%gwŒ62Ò¥˜¤­1ÁÖh‡°~›RdH=v·Ó‹W¼Ï¶}Þ ©åÝߧ´®ý½°[tnSç?¨ú^°Aw!µ4KÝMšÂ¬*·pHŸç€C9éc*gMCƒöV•¬k±˜mÔë ãy Ž›}KhñÓC= Õyjœd‰0;ðÄöÉB¤øè<ÇÃ)¹r<Íùˆ`åkKþºt~ä£<¤[GS ¬yáäpëª ܤƒ#Aä3Ümµ]ZmØ–¡’"qø©E°³QKmõ(útÆ©¬²º˜î}£C¦ŒÊÂË}ÞA¹ûjFÖ‚d1e¯dM'¾VÍ fÔwÃíØ+r6• þ8Ér¡ î_IÓ´b*…&t‰˜À» f0Y=#ËL@im,q„â»>Ô?‡ŽZSBŠIaÛL±k«±go«øæí¾“Û¿ÇGcá…É©¾‘žÚ7é¨ß,â”1ÈAùewTïU-Ék¶Ô°GÊŸ_†Ü6rÃSb/¤!™U‰-œ›n±XT"°Ö:ê%I×A×>JzïþÒÿåéœÑ÷/vêö®Ž`nžÆ:äÙúZ€" ù…ÊÉæUÄJ”npƒt‰ëÿÊÿqðjÍzèŽ%ãýÅA 6–mÓà;³Ú«š·×w!Å6²‘½£P»†:,[*¼F„ ô×,³î7^¼±´êM …8Æä¡å5*HÜ@i¯xÍëÄä2°Ü²ƒ·Ç®?/†]|”ÔCDùµP;åÍX?ü[íáØ‚KÖ·  ¬P÷ý£þ¨nC³Ô@¬¨vƒógš¿Û¼VkªÊÎä«° (ƒŽ>ÃÂZʶêÔ±¾@‰Ø Ú³ã”rêûwûÔ™DHÐÒdv»WÛRÕµm%•ˆDzc8¿ôýÈܸFtTc# ‡ =X8õÕÌû—#G¹ÉûmžáÝà*ˆÛ:ç3‰Íû—*²ÁýŠýÆ@cè*§Òã£g*Ê,4ó)`lovÛ-e"¤}zgÝ•{Ýûf©k[ Ü  '©=óìü^'y\›ñí%(b%‰±Ô‡@ŸOÍœ¥ãðÖÏÝÚµ{tµ¼e*6ng°î#æm¿éË®ŸiU?©6C²Ãi¤~9Ë®À\ŠÌ<Τé¯Ã8Î¥½UwŽÂçÝ®{äqì µ´PýL맥W>ËÅûyJùÝz®×ä vƒ@Ü õøç;‡*gàïT#T¨–ï»"¶ c™Úcêí.w šë²ÖghÄô:ëÓ8w"‘½œ•ðקÃ>áe¿t©õmù2ÞGôå}ÇŠHãñ”QFRƸx:“ŠüÄòXnµQ@Q48üÏß\—ÜÊV_pP’B*’!!½JŒ»²»W÷5æ¥h`5G²±µ¬¥;=­úœ9îäc7»o¶bµ}µ,(«µ i—–•¤’ Ó¡Íôìj-µš°äQ:…–Ÿ«/û‰¡¹<Îz­TSUoem VÔ[Žªlôç —È$_ʧ“EÕ1ÞkáÃ7Km ím¢ºv9Ç»“cSPãXA ±õD|¯ªKg Šÿo{¨tßÉASïb¬R¨ÜØéŸe ýºþ-œMÿ¸,¶´úÌ~V2®GÛصřkUÜÔ‚Fò‹wè+é Ô@eÕu÷<³öüú}·{K²Ê ’: åßÂTöì¬-v[uJE´ÓtÁ\¤\ˆ¼”`öYûš6ƒÖ5;ÎWÇär©[ƒ’ä\«£ù½_჎üº VUBJôè í×=Ê-¥‡¨YÉ­Éøh0Ü—Ðy[ƒ‚y ¶G—_—=Î_&–Ty ]ª6Ÿ„å¿Üª©ØŽŒ¯ ?2•–?é8 s‚ú•À0Y¤GmÙÅ´µŠ7dAzÄw×.Df´mF°°DK¾¬½B„Ók€IÓÕ©9eU†n=PFŠív-Û9—ÕvÇ©…½PLI뮸é¬Pnb¾¦*~m~W_,>ùg’0$°aÔΟÃ-V"ÅÞâ@'ÃpÕ0PVÔƒ=†))'oOÄF¯PÔ¡9bæ´9jÇÐß>šëW,¢® •_ˆ×ùàØ?V˜öÉ:i¦£Sò೎}±#7~ÛµÏc–‰m6&}U“¡pý8x¬CTX­m!ƒÓÖ‘Ŷ«»ì_Q¯¦½40eä¢ØPrõõ¬ïÿN;|Ö††BÀˆ×¸Ûœt4þ€¬.Ý $ÉA1ëMì¥JÁ^ƒO q-4–1Qêìwev®úý7!Ž£¸>.Ý ¬<5ÆYöàÊéÔüsj Öé33·mi_„FZ %œO¨ÿ†:Ǩkã¡É=<3i]Ê:•ëS•ÕgÐ÷(fæ\T=sòú€2Ûhå-×qÑíVÛbºÄ™$…:” ãÓa=¶ïå"¾ß(ŸN©å3R k`ÒuÔ´è?[Ko(Ûƒ€e˜õúc>Cù»|¹É·u›vnoYÞQÄuŸÛuÄ… $ú™·s“ÉrßÈg­q0òÄ<^!¾‚«,NºÇúq°C4ú¬2€±’é#ºåtÔ­U-Yô4Kö? ëŠËpkÕV£Æfôôƒ#¦¾9Ê¥À¯÷'(V‡vóblv×_Nݹûÿ·r=¯Û&ö®Z OH9ûô¨Ú”´"ÃoHB5Þ œªÇãSËäSKHäêi‚ÿ,°%%¹Xô:¹Ð)yXzeÖÙY«- ©3Ÿm{ªX³¥†'M#—û¾òWÝZ*³ÉeZéî"üÚË[g;î•CîªÞB:¬)ºÓò…==ËöN_mhÅž¡î1˜SòŸÔ¹ÎºÃWµ_©NÖõ}9÷ß½qÔq¿x]¨áéQÈ°Ÿ.Û³—ȼ‹-¹Tt&ƒO,âý»¾Åä³{öÄ@Ýý9öÝä7+fÇP{F}ÇÌä%µÛÌŽ/¡U’šX﨤ÆÝØ,®ÒàõÓj6ÍÀèÃý>9ÃûO©tªÔk/ÚÕØ*©w[»q+µ”ß6}ŸZ3ñÞÎMÌPBÖÖJ…x|ž•Î';îLœn%¯²`6Ý6Ào_åÎ_+í|+ÿé£`áÍO6íPâHèíôcŸÙÛG'nä# W¾˜õÑö®CvãjT õyçºq¬Nk\ïb2“´1• WË®\¼n?™¬«í*¬w4N£9¼¶µtòžÞ/"t l©Ã¬9ÕNÑù¬‚›Ôí¬8¤ïݸåu¿Ýîåšáë[ìßb‚d Ì|žX«}ÛžâÁ«[ ²øN{¼pUÑ@#N€|?2âYËzÝÂ_Šý˜™ë=ñÙEEz 6•]zOÃÇ8Bˬ±8AkJ+$På'æ ó㥕‡­¶†­ë%¶ÏÒ>¨Å¦Ší^2HJkP¡CÝ™9¹häØ­é>¥IŸ†¢1*áý¶äDÞÇÜ»v·6÷;Œ’KØÔŸ¶qïù6¯*†TÉTôÆÿø÷™ahô¡=”†3/‡ÆdôŠÂC«®gôÐé3&zv­ÌpÄ|Êt:HÐacͼ’Ñ!£ãÒ1”òî2!¥Úcë5ñvàsy²È&,ßæqƒ;I’r»HwSŒQ&Ò1½C~ŠÌ:wŒÜåè i𻃸ôËøª}I-Q?.Õ:Æ(¾¥o`Ê£¯a§æoÍŽÁZ½ŠJ°Ið8éed5„E¨T·Ã)æqÖxêê9RK¸†Ö|¥°r¾ÏvÞ)>àÞ¦KY¾2²G'’B_j„ahVÁ=G«{~åjDÉ<„xcÚ+­öÿñôzLé$áM•¸6˜3áá·Ûý½í$ª“àF-6 ¯ÑI>c–«WíÖÅ¡\káÛÜ‚à$뺻¬#ô¬2Ê|°ñé*}Ò“éÛÇ@+"@&Hñøcº'E§P t$þ9÷+/%·ÞÛ¥¡F݃é‹Ì¢ÖvÁI°uë\·” Crþ¾ÐA DNž8&’Äêáõ{ƒ›•v0*äôøb½Ú¼¢ òëm|=C¤F"nVÐ){5’:ñÏnÆÞèb:ë•óƒ’†VÖðQ¦¸/K¥`lMÛAݯS°opa«ê ã]uŠÌठiyÚ4–Ž‚zá'ùNFj>3›Ðôè0f;‚ÀÉÃn!X ¤ùbÒ©¼Ù!tƒ¨ÃO5.ÈÚЧ¡&&1î*Çk•…3ÿÃN»ú¾? QžæB®tzæ·7o¶­9d6¤NqŸ‰C[}öئ [– (èY‡¥OÓ‰íð¬§hÝê!¥µëÝsÈãqþ¡Ä,‚XMˆÝC„Êm]IH€5ÖN~ãG³xÓ¨ÞƒÓåÀÿo¦»,F>Ù±Šn„ŸÌ5é‚õWJ’¿KŽd·úÄáýýjBˆën¬¾$G§(—^G»TûAÛé”Óv£v™Ì^o;ˆÖÙíÊ­€00{w ã[Ëûí\xªÕ„]¥ÙXî3'9 ~ïÇår. Îä ±ÑYv•ÎÀê¡£ŸõÞg!¶ª8Ú$m_ù± rä[JÜƲ_M|±,¢Ë›aa\Wa1Öq¯·ì×_É{7—'C=IõœA_ûlYe~¥/`™*'w\dâÿ¶èªF°½>1® ªûU5VÄmY"<>XÀÜ~5U81Õ›OÇ+Ut¤·X@IãiæÉU'hUü0¿ïmP]øè;â»ónÚ[Öwžþ9¼ó !ÑXNÖžšt1›’áØ€«¸ê½g,ºÆqϬE3ìIô‡ë¡ÂÿpÙȸ¥B’T¨ÒTÿÓ}ÜcH±¦²°Y=»lg"¶{9ÑR!!€üÀJ¯lª‹¸MûŠ .ǯÛ-'ipcÕøà`¥Y¿üµO”1úNã?.{\voq‚‡¶2ˆÔ=1ýºÁêåœÎØ”Ú<òƼíä»odh1à7ˆ,}¦é#Ò6I#A匶¼:ÈÐËÐtœm²Ç,7G¡„)ðœ_lþˆÑƒm™u¸ÓLªŽAvŽšŸ‡_ˆÁ YÄÆ=}È]#¨ËIhÔÁ1ˆÌÀ?Ç ³h\‘áã´Hi`|ŽT ":õÆnÇ¡Žñ´pD¡ó éÛ¾q ¡'gG•Ü¤˜ÏÝÕ`FVÞÀ ¾DuÓÒã8¼ÊØÛÆä¬8=dë£yewp%ù¤= €G]ÃæSœ¾6÷¤0ZÊÐŽòݼ²ú.VªùT°+Xo—NÙcñnKh­w›Ç¤ºš tld®,S#pì{ôéE¬–ôŽ%\ªÖ¬%zj5À {T4áƒeŒ0ë¬ÉÒTQŨmó¸‘äq,}ª—±R„È$ ÐuÆzìSÆo•¾¨ðo<%Q£cðÊ樓Ôwв÷¶Ÿž%Ôk¯„ã×Z“AỔÄ磿ï (>‹“«y¯–'þÝÎོgæưë–P£ËH ô8‰ÇxÒÔ¹ 錭O±a=IܧøcqÊþߣԿK)èDâ¡ù\äÞ ,ð®FŒ&pñnúåUuƒ§CñV¢´›²5ú¥©¬ý ?+.94`c>yí‹\æäswÌN‘€´˜ë:à×N²r&Lè3h%!çœ[™‚TŸ8='¬N¸ GϯñÅ[ p£sØ⟎{\Š·ÒueÝ<£¦dþ_îíþ_ŽWmÉjñËE­Z‡p;ÀèN9á¡¿Ž Únؤ«t, ѱeÓˆ` ¹YiëÓv5—}ŵaw¬~#ဿÝxÆgp$žÝ³mßr¬0ƒþc=ñ÷ «XjVÍ e‹¾ÛÙÚwFÐ$LhpöXÇPµ– ÊOLSÅ¶Ö †”Äw˜9´}¢ö`dXYTkÚ;cÛGšX)µÕ„ΣX$iŒçUlÒ+¶Ò:ÏþlVšI]•µuöqê&g×ðħÆâÙ¤û­T9×¹,´V`•ÛJÃYÍÇŠÌ¢/oÃ?OŸh)+CðOïïð#y#N˜ö·&æHÞÓær˾ç}ôñÏH÷tz’3ôvVeor„‚u¨ùGüÙïê©—ñížÞÒÛŒâvŒ5é¿h!A>yb˜†T>=°…è ÁüqG~±¨ËI>®ºtþ8ªWY~9]•‘´ájq¡´#qÓ8ìZT Ï-ÜÚ:ˆœçÓ´u!U‰èC pj@Õ·ðüÊ ³k,Q|CÏ|[TV9K(õNž¦Ï–'+‚žÒ!,«;˜´k´eá믎NÐB±fm±òàæZ95òSó¦ 7jÃî;QìBÔ½­õw’ÐÄü±–âô…g²¤F»Oú ý8ÁyˆœXQmnµƒ5Õˆòù[,§ÜJ9BH¶ÉV@¶3zƒ <Ž;×ÉVÕÖ8$ÁÚXí1‚”ã%[AߵжîŽ[Õ:OM¸ªKÆ Wq+îIêEÅ¥Œ.Ñí«!Iî@ë‹Ì©ÅÚ*ùŽ³å›d’vÊ?MIÃã–-u­Ä+m­ X¥DjØ/¡ƒ;t©Š‚²³˜ÃÞ%CsÒKòCmE¶¤¡ó ¹îX¿3êªDiðøeüŠ*¤Õ­PÜtÓ©b[eÐÊ!¬`YØhC /ËlbìÒûà…= /OÇ?s{Ù`ÝÀàFF"ÔkEQýÍ ¹Qåÿ§/uwXArNí: ïßw¬rä§`'LMÖnJ«"?†~º)f’Æ`4øÆ,Pµ(Sí‰$©ˆ 5Ö2ÊïAEŠËWÿh‘¡zü7÷LUáªYÆdMjb#ª†ï¹Öõ§lµGem'þXÆnW±Fí&ôB“Ò{á ^}²ÇÒJø?úsw(¢º—U¨±•4Ñ| NÓ‚î"G‚êÁ#v×ëyÎ$±Ômøôœ6Hf@Ô‰×7.(%Nƒ^›p>â4¤`Y‚²uÓË-Z÷6õý"ƒÕï/}5`çs¦ñÊŠ¯­À€:nX_ÕˆÏ許íJ7N™¶eº=pRÖ† Ö1F„+3Ó·Ç «b²ü¯Q0DP?Ó„X‹bªºë½@ÔþS–W}jüA¸û¾¿çgÃ…3æ¨øŒ,àµQëª{žð[ ²ÐXwþºJ؆bÃË:AŲ¶>àir»-PÕ^v¹#ThÒrñP>‰ÏM뮘[i]¤í§ã›`|Àæ£h=ðu× Œ F§@pm‰éåÿ6 ´.â™òbSu¦ª6-GUŽ½;á`û•ÚHî¾qŒÅ·"ˆò„Y'ç §msÿÉŸÞùGÉù?Ó–Wo7‘¶7m÷ž5“cµ§¾÷fïæq˜Ùí«u“µ`ŽæpzA,£ùü0é€Ð5×Â2ÈC#E31¦‡3ÆgSê Wswü2Å°Á?+¯ŽQÉ®X!2©'¬öÅ›]”Bïtñ®h~lõ–4#TôçNúøàÚ©Z*îQ†þ–é]÷t{Q!µÒcÃ)öÔeçî¨OIÔŸ¦0Јm'¾4$, òÒp•éÓ¦=šDwœgxS#¶¹Ç é* ‘×Y ™tÓøœVÛê ìH,—ÔÁ'ÈN(î@þk m2 ðN!¬°õC||2͇դîð>XeÁ]ÈUOëoè#‹oº-!lzÀ2N x嵕cr¬l&ƒ¨×?øhy/R†"°ZTVßÌS¾Ü ÙY·‹î{|Í‹.±Ô‰Ý–GÚë¡{V|õðŠ° ñéü²ë^òˆÖ áW_–v’0QKÒ’þ¦Ø¨ê?6Ý3öÇ‘EÕ¬3,±!d×¾ÜÊv±CN¤Ø.6; mÊ,c;Æž=pµª{ë»~ž=~8W½Z2Š•ÉVs«>Ó¤œäy!V”WPòmYÚ~QóF¿6 ù<ˆU©¬cY=}&d7üØ¡C×SÏÆeA Bõÿ—í-/µVçaí0qc Xc´îW žå|®:W\8cq*ÀýK=zü¸Ém­*Åk³XaÔ™øâ¥p§£ßèËj¯I!¬Û–ž¡TNŸ› ¾Ç¹ÊHöØ6Æ#ËÄæËE…Hd$OÇ—S]Œ–«l ]Oˆ:ÿVRÖXõ^L1PÛ¼?ÒÕŽû}²¾Øf¬ÏWuo3…ÆàÄzk•X€ß‹TCÖ€f`tÊøà•¢æ!}È`-ÇüÙeO\uˆœ2mŒxÏiËŠ d3(Ô03þÂFÐ@hƒüq$úŒ'BHÄ.O ÃH f©À®¸÷Xº<4ñÏÛÕ%ÞÚ«XöÄjQ Æÿ¨RC]Y©˜°,7f<>a—ÕÀv¯—µ“Œì ³§^ºc}·î(G$ŽÂ Ün/4[ÈàØÆÞ;Óô·Fxù†%¼f¬SXjxê5ö@:ˆÛøç£hgÐta:|p¡î@b{‘Ûu™Zöü0= X 0S¤€~l#ÛaíŸÔЈ#ðSV›d:‰Ô N[ÃåÖUyíã©Q3ØüUƵǣÑ@îfÓŒk.„žñ‚ņPä¤ eÊmù5Ëí«}m ë¨3ÿ˜eaÆÁ£#vëzÎ5Uª‹Wp¦@cáÛ).MLê§P ̬¾#¶3ÐI;¡‡„ÿÇ,®ô ±µ˜jÛ³†IøìžÄô' ý62³çÛE†êHî\" #¬m:þ9YBÖÖÀ)Ò6žààZ†âtëã–- ¹–E‚4á8Ç¡ñøbÂZ5aÜo$â×vР˱˜òÔg¿OGÁ5ÞÀ%L«ýGL~-¢tG®± 棿žV-‘`ìÿÑÍ®ÄQP–wdFFð}Y_¹ZZWnõ·jÀ&O¥×ñÎBqk^?YºÛ]ÝB)õYý¾7Ï»¡ù'Çú2ÀÊAÛ=° m$øÈ8Šë ăüóÔaW¢#Ó •Ð4€1šLw®Z$¬‰ÞqÕ‰Ãð9`’Ì<0+jG–{±$°Ç†¤Oá—:Š˜¬jãq‘¯~þyjØûy¨5ýDé™Äêl+ùuÁU E ·ò¦:¹šLÏ–™b±Ú’ÀáHÜcü#Ðüûåöv©- ê2Öµ¢èBžR%` i¦;þ8*®3ê@Ôy|1ÕTÈZ4Ó,·ŒÂÚãc[Xܧ¡=°lP¬]™TuÒO«ÔäRØY£åù· g»—_Ãê°%t@ê­ôà«ibÖP™ì<bsøü4 @kß*}=º1ÜʱŽ”Ñ_ù•‡È‚äÂ};†åxü‚/zÙKZGë3/F-ã\÷n!]‹m¹ZK©ÕcU×®[Ä¥«®®¶(Xþ£ñóÅ­ì.òó$Ÿ ’wˆ–U"uøôÁ]•Ê>ºAñ$e•Ö£c1šÝIpFš0ðÅVr¡DG‰Žù!Š±"Vc®˜ïfråâ ¢qÐÖ¬ Ÿ¤Î‘=ð.ïTþ™K7cðNî`S\43È ¡‚4–é—r›Eün1@ØŒ/õm=öåKG1¹<'›ÕOXbwhúA·éÃû†SíX7iùXøc½V!HÞ*Ž§¤(?ã‰ï© 0¡b{xgíÍGU“aïÊ] m’,öÖ§kNµ²•»jsg29î´ÛAMѨÓä™Êèçòqí‚»+ô$¨‹e.ãq,µ)™óœýµÛš§2ô·Rzg*Œ­S‚Ï"T0ôÆ{žïí•ì÷ùì]w×G6Ô¸_òÙùC! ¤ÞknmˆENH*Ív‘ßÈâYvœ[Á•ª¼ÆÖü¸)¹!w²ri$¾w#‡Cð@ÓI=ôøa,ÆQn?ýžÛ”Ë7´7ͧ¯>oèùG_rÍ´ˆ É#¶ZöZ'*#©€Fç·E"$‘á‚•sµlˆÜ{ãY0XHQ––0ñ ‚`¸$`e( Òí ¯YÂkÑCzÀ&„+Iu’«RªÈj“$é×üsÿ‘vãZèµk¡Þ°a±R¾IµŠÀV+¨ñ˜ú¿)XërÛœêk"I=4ƪËë¤ì6[mŒ@|@ç®`xÒ»Uîq0Ûº0aqÙ„W»¬ë¯Oå–€ï­1é ŸÌqJÖ+»p {Á£æ·ú¾\®ƒQjôýN²F“Ç•UmZ‰,@!Lö×Ï­»H1´õáƒyˆ%K©µ={à»,õVb8WhÙ>£â<±T6ŸŽè'¿–{H ¸ý ‰-…«#ÕÁÔƒ á´Sé¬@3ñŒdjä²ÄGùáªêŠ÷VRWOmºƒ€T ‚4ˆG@FȤîS´×ùã5CÛn°q¬Çl ]j§Su„ô^ÄV6Öµ…°îÃ@±Å×}šlÇ_ A{mµ@`ÀNº ¢q¹íZÉÙNã W© ®Œðû]¤‚Ûž¹¾¦÷á(½@ëÐbŽ=N›þjëƒÕÀùpSW)ž«vKmB~‚LwÊ™œ‹6€žÂ’JGB{F|ü—Ì¿>ŠC/¥ÎªÃðèq*ãÖÐã¸%¿Ë„”fê§I>d5›Z×ÿ»,³‡ºëv/¹Å¤)¦¡ÊY?I§r‡cdg£h0Zocj0p³ÿ/òĬz%šæB1ŸQcNÙU¶o!H5²© ¬hk˜R6 «²Úì}=·QZ•RÔ|FÞRÓ …ÑOõ4PÆ«Uì@$H€<°­tÿ¬XH“ù•†£ý9eW2–¶²)@»•ÖdF»sbØ-_pµŒA:h%F»Hï‹Ì¶÷ã\Àj¶-E›PY”cÕvë-ûÌN¢zÌ‘´ybÕj¡¥Xøëù”ô9íÕ`öfزOeì†rÈïZbÙmâ¾…}%~9Çjª+aõ,A t0{`†!œzwצµKíµ^f]ÕV,¬Á…o” w|3Û±€ L•‚DŽ hN0©Ñ×s¾™þ8Þí͹ :˜â;à¤7½X0¥€uÇ]2ÅE'dè # ÝÝzÿÚrºÐ”,À àʈúzü0¡;™Y‡EA×^ç*ZÔØL3o†„Øã×euÕub=êÑB² ¡–Žº¶ *ud…s ;·t>Xü¥r”Ü…Z“&i¨¡#mGÜ6Ì“øö8m´³»`ùDöü2³B«ÙÊuÐîDôÄ®ÚÿZºÁäX#ÖÓŒ¥¶ ü0ºƒî±*d‚¥'YÈŸ Ê ¥rGH“3ó ýÊÆF½zƒ‹k~ ß(‘ÚÏ#c!‚ÂÒt™ñÃo"ÇK•tS?÷`J-°oè=K #ǾôŠn =–‚ÝÇ]¸îƒc‰­ˆV]>“ç¡àŸd‚ uÿPžØÞí[Ø€]„k»@Àya®é¦€I,Hõô‚›²ßpÖ0¼n §O˜ŸILåÈÁR¦TW¨ÄûŠ=L±ÑváöyFªŸ}ÅaYMý †é•%H9\ŠFpgТ{ÁÓî\0¦žM{-?2ûŠ=L ýAs*ý;8èªA=º÷ËiµJ«yubPX}0{+Êøíc©"KL‚fz ‘àv2ꡇæ?÷aûÏ{¯Ä ]ä¨>â¡1ù1·@2 ˆjtÅöJ_c©>ëjûÉóï–q‰ ɬ–°0Ò"øåË ( ÀÕGQŒìÛ«•5“¢Ÿ<¶ˆÚ-«ûdêÖ4ÇkJ˜3},Ï®§úF)²_€ÿ¨`â³ãç–t¹lm6©Ž˜ ‹µm)tþZåOS Y@gEÖë®Iõ%°ÛˆêùepHÚv…ë¸øa¯q-¡ñÁº>é°jJªDÿ ÕíÐ,– üN{0/Aè §?©Q‚ëÒ;c@÷Ô‘Õ j1lQ.šÔ’4×+vU ý¶-¨!¼|ó™öÄã¯3‘i-]€K}[§ò°9û{’Úù6m -R£^‘ሀÌ6[dl»I€|»çìMAÍãôlV7ÇÃ+ýÂíWÜ©† ƒ©"ùf½-!a‡ò)eÚÆøˆ8}Ea»ç‚,)ЀWOç€ê-·‡þnµP›qPb²Gm¸…ÿ²ƒs%~”fúTÇl-Å jZc¤Gc×"ÕK8íëimŒ¤uÇeeä+1Jª²HÚ|džVÛ#çP|W]UVÎðÖ{‹¬ªÏr›Åt£R¨cX n‰ÕŒåöòùa_zZÒ¬{‘·•_%V=|U% '±ñÏÿ—Ÿž~o£Çã…õ¹Ô/MÂ;`Úb³!ÕF¤Ÿ†¸ìi.ƒMÃÔ@þ¯Šo>Úƒêƒ A:ÃJ:½J=N°zúvÏÕˆÔX¯E„{õ,¤dü2º¸`ž[ ¬©˜ õÐåC—Äöiö˜C-ïº|ô×ZšU¶a‹–JÔééP}3ƒ•î%õ¡‹>àŒ«˜u¼¼~Ðl˜–ƒ¶u«.¬›*q­V0‘µÐÆq’Î;½ƒ@Á„:cZå•ßsE_2;éÈàØ·S}ejÿîùbó æûb½ŒÓóGL§‰Rûx‡rÙeD*¤moHÓwž!©bÍLAžº`ßX¨kY– fìxfÞ5¾å«`Y ™×Ç W¦ÛQTté‹W!\ =|ƒ¡Û݆{•¨[:‡B <Ý]Åe)I#¬öÁî†6õ:ëá‘[½|Gš©“1©nß6*1‘DN =åV¬úë%tÒ|ñ8\Z½T3ò•$¬ÆíÝ‚žÙ^ö‚KX4$üWel·Taw;vð)HjÏ®²@í=pX²ÅÆ_ô¯S–—°UZ+=¶NâI:«ÈA*†Ï©tÛg¯ž{iúN­×Ä×ÉRÊ!Éêz þÂöÚZ7m=ÏÃ'Þ!†öµê¡tX”ò˜\ªé=zfúœ#¶¤ÈʸÕ[±9~Ÿv¾¾è†žu-sÞàïf”ˆƒ¡è¤öÀ)„i4¢Ñ3ê+SV},EŒ@T kóv0~\õÍk¸©bA"° ˆü¹`¥µëŸîÖÚˆŸ ÇEvNÖ×iÝБ¡Ól7Wc÷!ˆÓCÔižõüÊä_©¥4>`úq iìqÀin²;åÜ+Ã{UhLü¦=$¿–üE>ñ-âXô$/á”SU¶ãØDWò¤KOðïžÕ(=ƒìuÙä†Ô Ç¥&FºéœŽ's%Šåê¬À07™îñ‘Ù6L‘×öåïS¸€£q×L³qRVÁîÑ”uÏ}ž»½ýõÙR™u©aÚ|rªkôk ^Ÿ–vþ3‹l‘ÉRO»¢É'Ô'ë‚WËR•èÓ-»¶q+ásŠÓŹ`wù¿09{ÔeˆÓæ„ýÃcØ„¥Ø‹KÄ)^Ûdz±k/(¤"¶/²›vˆ+ÐG–ZØ8ïæ<2ÉpkvÛíž°DõøŒ;€R@RG€ÂÕ6Ãâ~=³}ŒLI'®BŸSjz bÄa‰8ŒŒmßéÛÙ¾¢N{Äl[$•z»éŒwÁ/;.UZrø¦v®¾àùÆûÇ;)5$±\§’-&¨À>€Ä‰Àiô <ö8·î’RÄê¡×¯_z}±¸Ë'` ÆÞIJ‘´øÏ„gëq=IðÅP½tO, FÈ’ ŽŸç›«0cæ‰ÓÀå–³W3µµA?”˜Õµ›xöEšè{ëÐGlý^Mlvú„‰1ãÜJ›Ø¨@f0øŒFB.Û>•Y`{ˆÃÍãRµ -a„’Çê`p5Ȥ´úÏQ:öð8ׄ÷71%»™0ub¾K;J·Ê? ãžæày v’­%”t,™Û¤÷ëá”òhÜœ’?^¦cµ‡–-•ì ‘& ‘áŽ+UØêÕÚ½D#_Ív èrw)˜ wkß8ör8è!è†Ý¬ ê§ÏR¦¶j3~bSœ§n/¼m%ªå¶­'Q 0Ë…±Ô+$2‚º“Úr¶OжØ.jyRÃA¯Ã¨Â~à¢ÝÐv#/¸¬"w]§ ïu VÍk±¤Ú¡A„@Êí²Ó_-¤f¨X€ºvÃƵk¸)9˜Sçÿ<´(ÁèÒÆH‰ðéã_u]Õ –`ƒ×ݲͫé&ÈüTF"Õ{5ŒÐPþHTç¼4 ž§_)Ëmb傺‰'Î'L5TÇjw˵„™ê3׫¨:;7xc-Õ­d S3ðÆzlk4%t$’?à1°“á–6øvÄbå\ƒÒ0¥« ANîúwÏÜZ}æ+=fŒe¬–ã€vX ÈJƒÓ+ ­„×äÝƘB ±¯iñ#´UxЩú”hužÜKĆé+×®k,œÖÍ°#¤k‡–•­1îVÇtžÄLúq=˺AÕu‘ÓæÂ… ‘°4zˆÇžIc´ ‰ë1–µ «VAI|ºŽ£”gP†XõÖÇ·tªÙ©Fˆõ¸õ7¸ÜíÊn³¢íÞùPxH;çI9ZÝ (ý7xæí‡xÐ7_å×=E~choÅä¡Òvè>íÒ¾]p¿Ò#dê{é8ŠêA.GÔR0òÏÜ_Z¸bJ ÕJÏõbñí*nBƒ¶w@cÐw›kÛz·ÉbŸ#¤Œ[x Uo7:ógpøxgª±ua :ÈÒ%€î[GªTZ@µ”=P V˜œ+Â9¨®õàÄ÷óÅ.£z™A ço!U'©*^“¤1Y¢Ú|×I×êŒ,^²KPÎ::£Hÿ "†]¶.•Ì(DO\£œ»Ýh!yý#Y*X;€Æ_nÅ·_п@ð}DeŽ[éÙXIôÏS¯xÓÑa(Á¶*h[y˜fÅKP© #éÜ`ŒŠÍ•òÛ¤é׿©Oá‹Mj²TÊ`MÆ5Œ^WÛÝW“Y-Éâ´ÄO žýÿ«¾¥GESAÖzž¸Ük)BT¥ÕlXÚk?<#_2Ö‹9LÖƳù«ÚÖMŠNøÆ[̹’`$zB¯–*wHÓ6o!×ù‰ž¸HÑûÇ=½Xÿ‰8Ãå=6¸žþ9é¤êN¹ê#jdÏŽ¸ RÕ?á8mŠ“V'ä¬ê¦b'©ÁSˆ[ˆ4Ùá¯Àç³u{zR; I²A ôˆÀŠ â±.õŽó×®4†¦ýhaõ0Ôæ;g·i‚’k1Õ{Œ·ˆÚ½Ž½r·*÷×Ë-Ý« Ðƃ]sd~¢A6uŸ 2«`™‘ÓÔ0™ >‘2mݵ»kßà‘(zÇ Nª°AQvƲ› «±Øó0;`¯ÚVÜXµçBtù±¯PXH­ló=±•µ÷ŸäOs8iäÿlzKk§Äg¹Â‰–`³.âó7Ýé?µBÕcԱѰ&ÒOþá¨Ï•¿óøáªð­Q3ý@ôGc–:+5s© ƒ]´ÅÜä¥Äî~¿€é•cr±`*^¤0"ñÀ¶±>Øÿã¢"†ÿIIÆ÷kBl´3(tIŽ†a²†ä©ãÝXue´€ŒT•š2KÝÚ¶çR±¡ôh4Æä@j¶£^íÒg¿~še¶ò÷=ŒwmªÐ~’ƒazˆYOP># õC:èAë,|›êÌ[NÀ‘•5ãPÅ­f‘´)ÖDü£Ï*³‡[Š¹ Y¼¯)Íœ…d½”èÀ‚ß•†V¯>“ëCg£ ÇNBîÅ Ië ÐåÃå*ISeO(Ó§LäX›Mou‹c,@€:ŽÛq©½ö¼Â©V•˜ÈPÚ;ôéñÃ]¼qµDnv– 9ÔúO^¾q…„‚5M°[_3ö´U·X Ç Üddž#ÒÕÙKj}`²°ê¸¬ W&FФu‚UwÜ.¶ÒÙÓR ï¦JX$ö)wBå‘YL€Dtü2^°DÆä‰R<‡óÉ.¥“E`ÀóaVí¢Ò|;® j¯Ò77¤ÐÄ ª±$î*ݼ5ÀòLÌ…„ãr‰H;”nW\Zù“îXB«ªèGH'¦ øêÆÁòk¤Æ Æb•¶vu:v9[^ØÛíöêtV­m¨ï5‘®€³þ9EŠ6®×­´(ýõ©gËjÎö Äu2ª¬«eN¾›6èHÓrþÕqÜãÙë÷N›¦Ñ¬ú§Ãí÷* ã‚©r¯êß$pŠ —fê@ÒtÒq>á[¶í¡X˜$Àñ×æ`Ô‰?ášX*¼×tÁðéã›Øö0†î‚>\¶—­ý‡Üwø3´‰î³—_É´M(’H$¨’$ŒEªÃª’+:2(Ö '\K•W-Pží ÊI½+©L:‡—]|»åj»ª »Û«V~b½¤gî”mKë W*¦Ѓðט̄´^Œ¡–‘ý:xåÔQ¶î;Ø}—pÔž‚Qå‹oš³WxmU‚˜q¸âö÷‚¡ÒñŽç8´ßÊöYƒé-OÃ?I€}»\“½GÔTj¹Y¶4•' “¡ q––si†K˜lPÝÎÝz“”òéR¾jMt_ŽÒî£ÖŠ‘ÐNšbÕY¬V¼SNÒѹF­ºg_ô®=ª¥¥!+:êMzéžõ*Ê$V`ø‚4‰Å÷W{?¨±Ó"±é&@cáŠ]uùˆc70+·©8.ߺ¶ƒíôÏPrÏdz¤yÉÍÛõŸ2OLZŠÕ`Ô daâ¾ÑVDÈóðÅ÷’'¤uÒ:bß´5•X ê1],tXóïð²6¯ª|>xÅ ƒº¶îtY¸]o¸2ž„ç«—¶A÷4¡ëážåJ}›}è'¨Œfú:mq·,HLƒøeœ{Óè> ÿ~FÀ­:0×\,zŽ˜»¾VÑÖDŒ”ù“A'¶=jJ²A†'X8©EaU-q®NѨ‚1±¹"* êNºà¤ºb ÐyŒ{(§qù,S -ã>XM6 güð½î#éh&|¤à½iÜRÈdAñÏì/þ^Þ8ˆêª¶†„:ôüU¶±ªÅ…'HÓ\ö›åY,ŒtžíŠÓvÛP,…îÃLNZmuÈz·m ©B%¤c_WVÞãi– þ¬DYq[~·¬Ãn:°'^˜ö •vŸÔ¶ÏP,ÚuÓÇ.¢ºH©lÖêÃKmÓn½¾­q:×Xl²c®¦;åü¾A JºÙ6>ß;!ž™ZDERžåsZØ»¾¥ÔNÜ«š£ÜepÊD< a»’㼪±¦ºê2ËË a@¬©õnY'éí• ®!•C!ñ1Ó_”e|¯keJ¡Χ¯LeØÂêÿµaÓϯ|·þÖëWm¨Àe—ã×?o÷ od-Õr7÷?2ëÜ1锵”Ô¶Ôî[çób·¹;Œ:NÐb½¿åËY.}®e«bFŸ ý@ÕIøá W˜,Þ Gœh1k²§i_H1»·«’);ºüÑ¡œ÷ 2¢ŸÖ1O öþÜZ»IÝU­ úž™µqóXž¯«¦˜žùOpÁ'Óßøa¬ŠÓ¶t“ñËj É;“°_ʬ»ÑP=MI>8Üoj·°4%‰ +ÞqvÛ,ò`÷GË-½Zv‚H{N? Û»ñ·iœ"µjùp×{¶DéñÆ©‰­^îÑH¾T›¡êpC£§uƦ³¹ù¶m I&'s垀kŸK4zˆFVÑ @‚½C|ðr8M[! 2– ³í8©ÈRç–C{ÊÅŠm¨8»l‚]Ÿ‘V›EsAË-©Ç+ˆÏ²Ä÷Ql€C§æ‰y<ˆÚÖÆr t˜#Ã94YÇN!Ú^´¨šøŒ[®ç­(ÛO¸o¯Q¿VÛúŸ+倀ÜÐTµºO¶F¾Ÿobëªt”îô³ ƒã•Õ˨—¨~‘aêiÖ'¾¹rY{RGºmÒOLe'q][i*D¤ŒÚŠ·nÕíÁ`ŒRš–«Z—#éV^šž˜í_ 7£Ø]•—¹?ÏÀÖÖ¶ö ÄŸp.µËhpð¹ÊËtþ›ˆbŒtÚÇ¡Xü¸µ©%’RÚ„´GI镘ܰH °5 Hô$t# ÑXJ‰«¨QØ í±>°{k ¬'œž"ºÑò‘笭5ŽãË"=.toÇ ZLj|Ož8,ÖÅW] ž‡Z…`^¨ððÃ}– •‘xF-¢A1&qXÙX½ÓuhÂKzr¡w’ÛfÁ>.?+ŒÂÚvéQ2@ì? µ`õ:ˆÈYRš4ô9º¸ÝY:iì±õ4ü­w9]ë‹w'Ðê §€À€’¤ÇŸ–oÇgq¡œjø!?qh ÖX:‘Úzk›yI²Û›\ü¢|<3b*ÜÕh̆FžcÇ6,®íÅVgM~ÎðMv“ó/HÏs”ÂÈÕ‰ÃS“`’M‚¸ â&:g÷S¯µÔôÊ®b\+í}ª7)íÐ÷ƬqÜ›DnoH1Ûã‰{Ö £ ×téî¡ÍX|{þpåØák¥ iñÿO†V‰Èý¿²‰Ǻ'HŸ«6º±b»”hvöׯ᛽ H¨Çc1ÜbRÊiVbÅÁÐ k;Ž55q¬B‡¤ß-«“cn1G¹êfCÿÓžÑmÎ *@óðÁDzV·$¤'÷u‡E$Žð@ßǺAcP“ “©$êTV5€‹3äÈ O‡ÃÆhSÞAíý8j£õŽ»Ç¤¯áK؉άo¥\€Ë`àpðùµÖÌH¶A˜'Àøö…uI*Œ}!—§Ã+ vC±:™Q1]½HL³ÔdëÐí9²°x¥„ûå½3ÚPøåõ\[|‡ªõõ©_\÷ R„n®¢>#òáànÔ¬ëÔgª©¦ýß ãMÑåg툞ëXEØŒN|| Ì ÙÍé`R4˜÷œZê­E—Ê‘ü—Q‹Ée6§Ò‘¸ž‡ËÔMv­»§lë Ë«²ÿhXÇi~Ÿê a]ÛÁÑþ]À€ƒ¯ÄF-V:Ô­'ÝùŠ4yç‹`‹t™)?Û>Ñw&@‘º4×ã‰ÉBµß2ÕøÇRݧ'Ôd¯iëÙ€Y‘ãÓ7ÖȈîî]ûW@X!‹öfU°,ä›u,Tˆ]Ÿ”±.¨*h¬iÓ¾ì¦Ï»qU¿nŽµÜÁ¶Ln:jAŒ»‡Ä¸ÔÕ ´Ô‚V='QêÔ2ŽE®¶R±Ü‚¢¦=SŠ=ÓcªI ø¢Ê‰d°mä)éY|ñ6Å•ÉÛ¦…z囓ӹ¤±áUˆv[ói¤¯Àâ½Ö@©[âFq ÍÁÂ0ÖLÉÐ÷Ž·±$*"炾<Ò‹êº1;£6r^®e–1°W)“;An™M¼>2ñî ~§Þ6†2ÄÑÛ9÷«‘jU‚ª¬N¿Qƶ¾-h«» j@…“ÚrÅÜ.í |±áñϸJû_sûkE6¸€ÑêVú—\J]B¹iv2Xiò錢Ê6%ô—opõhõÓáòÆ*9.ì£ÔLø~9P.S`ÒL“ÜHóÏÛ×Zº—Cÿ~G²ë¼…¶éô´yé…½·@;¼üsÜáî7@÷xö êOÑù¶÷Ïq‘}êô°ÖÞŸO‚™2Ûí­LÈ2áâp°]SA·SøeeÚ8|ƒíºYªÉè@=0lPŽËúµ:“ôœ_}äô# ϘÅ^!÷ø§i“«Dj',5×í;’À2ªàXO¥F¤éãÛ(›BÇü1–ªƒ¨ÉÆ*î=+ÚGžšt á²™‚ÂPÔáK” k]õ‘צ£jŸYü{ç¶ÇsBÌç¹y60Ñaà{ΠÞé=€o®È^¢hÏqê;Ø–`½ öŒ[_ܘYòú¾ H’|p¥§i]ƒÓ々ܟ¡g]×O<$ðÆ°‡e«[`N‡¾-þ¿n½Ò’žÙî“d-mÑ„õ_ŽËüq G0 :ùÎ3XìK ªÃOÆq­&6‘êúûm:q.æSír++í1@î~>yV‡×+`s ÷Ý=óô÷`ÑgMÀev+ûÌ +$m#kt9î5 Ï^¯Suøƒá9+H”c´‚#aë‚ÎûjFãY0­=tøç»Æ`•Y@*¼N{Œän5€:ˆÿÇ/´×eŸp°”¬‡*ʽ 4Ûã‚ËvVÈ¢*×s”25ë×,w*•îê L®§\~ÝÃ|–îAètË™$Ò§Fî|°?Ie?(À/|RçÖw =çÒží¢P º³ží•-¬ïm´2zF§¦(bS“$°OPÔJü<0ÚÖ ZcK.¤ý+õt×,¬{la’u%ºmžç5&ÊÜÍVG§àÃúzb=T€¬Nå¼»m(ÃÛ) ôê{c/%w†Pß”£ôtôÀd­ôIx–Œâ¯‘ʬ°vÑ‚eJôèÓógî|§¡>åÊU£Š °r¤î±UºvÝ·©ÚϾ®ÿ%Q Ã]•Õ¬2.áÓI=qè-ew|ÐGq¤áGuGÐZùöÆ€qŽÚkå—ÒkLÌø{v tqv¤Þ,T]ø¯½˜ ÁTˆ×ÀW ˆ:ß'j”ÔÿëÃTdZ«^D.Ó*dn®n¶¯v`±iþ=pTl5Â"ÀBï?p†¸'§R'ËÆ’ÊͱOŸIÇV]B˜=Dã ¶ºIøœ ½:ˆÏKëøƒ‡~ Q=|¢qÀ&… "uÆ*›<Úsܹºé9îtÁ‚)>'Ç –zƱ·lã¢)U†Òt˜Âÿ¸GPùf‡¬ßã‡Ù:õžädZ7)Ñ€ë¾1+²»Ò§Y?žÚI$Gln¥A3ÙîVà¢0ÔÓr±„HH1•û,8õ¬¥[ŒA8òÎê€þž§týZvðÁ¯¸±!II˸‹YZ§‘aé³ò©îNV•UUîª\4­~•õi¿ÑÇ{l½=µ¬¿Ó=¦øãÃûÇþÓŸÿÙPK äMwB'~n*RÚRÚ pg1000.txtLA DIVINA COMMEDIA DI DANTE ALIGHIERI Incipit Comoedia Dantis Alagherii, Florentini natione, non moribus. La Divina Commedia di Dante Alighieri INFERNO Inferno: Canto I Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura che' la diritta via era smarrita. Ahi quanto a dir qual era e` cosa dura esta selva selvaggia e aspra e forte che nel pensier rinova la paura! Tant'e` amara che poco e` piu` morte; ma per trattar del ben ch'i' vi trovai, diro` de l'altre cose ch'i' v'ho scorte. Io non so ben ridir com'i' v'intrai, tant'era pien di sonno a quel punto che la verace via abbandonai. Ma poi ch'i' fui al pie` d'un colle giunto, la` dove terminava quella valle che m'avea di paura il cor compunto, guardai in alto, e vidi le sue spalle vestite gia` de' raggi del pianeta che mena dritto altrui per ogne calle. Allor fu la paura un poco queta che nel lago del cor m'era durata la notte ch'i' passai con tanta pieta. E come quei che con lena affannata uscito fuor del pelago a la riva si volge a l'acqua perigliosa e guata, cosi` l'animo mio, ch'ancor fuggiva, si volse a retro a rimirar lo passo che non lascio` gia` mai persona viva. Poi ch'ei posato un poco il corpo lasso, ripresi via per la piaggia diserta, si` che 'l pie` fermo sempre era 'l piu` basso. Ed ecco, quasi al cominciar de l'erta, una lonza leggera e presta molto, che di pel macolato era coverta; e non mi si partia dinanzi al volto, anzi 'mpediva tanto il mio cammino, ch'i' fui per ritornar piu` volte volto. Temp'era dal principio del mattino, e 'l sol montava 'n su` con quelle stelle ch'eran con lui quando l'amor divino mosse di prima quelle cose belle; si` ch'a bene sperar m'era cagione di quella fiera a la gaetta pelle l'ora del tempo e la dolce stagione; ma non si` che paura non mi desse la vista che m'apparve d'un leone. Questi parea che contra me venisse con la test'alta e con rabbiosa fame, si` che parea che l'aere ne tremesse. Ed una lupa, che di tutte brame sembiava carca ne la sua magrezza, e molte genti fe' gia` viver grame, questa mi porse tanto di gravezza con la paura ch'uscia di sua vista, ch'io perdei la speranza de l'altezza. E qual e` quei che volontieri acquista, e giugne 'l tempo che perder lo face, che 'n tutt'i suoi pensier piange e s'attrista; tal mi fece la bestia sanza pace, che, venendomi 'ncontro, a poco a poco mi ripigneva la` dove 'l sol tace. Mentre ch'i' rovinava in basso loco, dinanzi a li occhi mi si fu offerto chi per lungo silenzio parea fioco. Quando vidi costui nel gran diserto, <>, gridai a lui, <>. Rispuosemi: <>. <>, rispuos'io lui con vergognosa fronte. <>. <>, rispuose poi che lagrimar mi vide, <>. E io a lui: <>. Allor si mosse, e io li tenni dietro. Inferno: Canto II Lo giorno se n'andava, e l'aere bruno toglieva li animai che sono in terra da le fatiche loro; e io sol uno m'apparecchiava a sostener la guerra si` del cammino e si` de la pietate, che ritrarra` la mente che non erra. O muse, o alto ingegno, or m'aiutate; o mente che scrivesti cio` ch'io vidi, qui si parra` la tua nobilitate. Io cominciai: <>. E qual e` quei che disvuol cio` che volle e per novi pensier cangia proposta, si` che dal cominciar tutto si tolle, tal mi fec'io 'n quella oscura costa, perche', pensando, consumai la 'mpresa che fu nel cominciar cotanto tosta. <>, rispuose del magnanimo quell'ombra; <>. Quali fioretti dal notturno gelo chinati e chiusi, poi che 'l sol li 'mbianca si drizzan tutti aperti in loro stelo, tal mi fec'io di mia virtude stanca, e tanto buono ardire al cor mi corse, ch'i' cominciai come persona franca: <>. Cosi` li dissi; e poi che mosso fue, intrai per lo cammino alto e silvestro. Inferno: Canto III Per me si va ne la citta` dolente, per me si va ne l'etterno dolore, per me si va tra la perduta gente. Giustizia mosse il mio alto fattore: fecemi la divina podestate, la somma sapienza e 'l primo amore. Dinanzi a me non fuor cose create se non etterne, e io etterno duro. Lasciate ogne speranza, voi ch'intrate". Queste parole di colore oscuro vid'io scritte al sommo d'una porta; per ch'io: <>. Ed elli a me, come persona accorta: <>. E poi che la sua mano a la mia puose con lieto volto, ond'io mi confortai, mi mise dentro a le segrete cose. Quivi sospiri, pianti e alti guai risonavan per l'aere sanza stelle, per ch'io al cominciar ne lagrimai. Diverse lingue, orribili favelle, parole di dolore, accenti d'ira, voci alte e fioche, e suon di man con elle facevano un tumulto, il qual s'aggira sempre in quell'aura sanza tempo tinta, come la rena quando turbo spira. E io ch'avea d'error la testa cinta, dissi: <>. Ed elli a me: <>. E io: <>. Rispuose: <>. E io, che riguardai, vidi una 'nsegna che girando correva tanto ratta, che d'ogne posa mi parea indegna; e dietro le venia si` lunga tratta di gente, ch'i' non averei creduto che morte tanta n'avesse disfatta. Poscia ch'io v'ebbi alcun riconosciuto, vidi e conobbi l'ombra di colui che fece per viltade il gran rifiuto. Incontanente intesi e certo fui che questa era la setta d'i cattivi, a Dio spiacenti e a' nemici sui. Questi sciaurati, che mai non fur vivi, erano ignudi e stimolati molto da mosconi e da vespe ch'eran ivi. Elle rigavan lor di sangue il volto, che, mischiato di lagrime, a' lor piedi da fastidiosi vermi era ricolto. E poi ch'a riguardar oltre mi diedi, vidi genti a la riva d'un gran fiume; per ch'io dissi: <>. Ed elli a me: <>. Allor con li occhi vergognosi e bassi, temendo no 'l mio dir li fosse grave, infino al fiume del parlar mi trassi. Ed ecco verso noi venir per nave un vecchio, bianco per antico pelo, gridando: <>. Ma poi che vide ch'io non mi partiva, disse: <>. E 'l duca lui: <>. Quinci fuor quete le lanose gote al nocchier de la livida palude, che 'ntorno a li occhi avea di fiamme rote. Ma quell'anime, ch'eran lasse e nude, cangiar colore e dibattero i denti, ratto che 'nteser le parole crude. Bestemmiavano Dio e lor parenti, l'umana spezie e 'l loco e 'l tempo e 'l seme di lor semenza e di lor nascimenti. Poi si ritrasser tutte quante insieme, forte piangendo, a la riva malvagia ch'attende ciascun uom che Dio non teme. Caron dimonio, con occhi di bragia, loro accennando, tutte le raccoglie; batte col remo qualunque s'adagia. Come d'autunno si levan le foglie l'una appresso de l'altra, fin che 'l ramo vede a la terra tutte le sue spoglie, similemente il mal seme d'Adamo gittansi di quel lito ad una ad una, per cenni come augel per suo richiamo. Cosi` sen vanno su per l'onda bruna, e avanti che sien di la` discese, anche di qua nuova schiera s'auna. <>, disse 'l maestro cortese, <>. Finito questo, la buia campagna tremo` si` forte, che de lo spavento la mente di sudore ancor mi bagna. La terra lagrimosa diede vento, che baleno` una luce vermiglia la qual mi vinse ciascun sentimento; e caddi come l'uom cui sonno piglia. Inferno: Canto IV Ruppemi l'alto sonno ne la testa un greve truono, si` ch'io mi riscossi come persona ch'e` per forza desta; e l'occhio riposato intorno mossi, dritto levato, e fiso riguardai per conoscer lo loco dov'io fossi. Vero e` che 'n su la proda mi trovai de la valle d'abisso dolorosa che 'ntrono accoglie d'infiniti guai. Oscura e profonda era e nebulosa tanto che, per ficcar lo viso a fondo, io non vi discernea alcuna cosa. <>, comincio` il poeta tutto smorto. <>. E io, che del color mi fui accorto, dissi: <>. Ed elli a me: <>. Cosi` si mise e cosi` mi fe' intrare nel primo cerchio che l'abisso cigne. Quivi, secondo che per ascoltare, non avea pianto mai che di sospiri, che l'aura etterna facevan tremare; cio` avvenia di duol sanza martiri ch'avean le turbe, ch'eran molte e grandi, d'infanti e di femmine e di viri. Lo buon maestro a me: <>. Gran duol mi prese al cor quando lo 'ntesi, pero` che gente di molto valore conobbi che 'n quel limbo eran sospesi. <>, comincia' io per voler esser certo di quella fede che vince ogne errore: <>. E quei che 'ntese il mio parlar coverto, rispuose: <>. Non lasciavam l'andar perch'ei dicessi, ma passavam la selva tuttavia, la selva, dico, di spiriti spessi. Non era lunga ancor la nostra via di qua dal sonno, quand'io vidi un foco ch'emisperio di tenebre vincia. Di lungi n'eravamo ancora un poco, ma non si` ch'io non discernessi in parte ch'orrevol gente possedea quel loco. <>. E quelli a me: <>. Intanto voce fu per me udita: <>. Poi che la voce fu restata e queta, vidi quattro grand'ombre a noi venire: sembianz'avevan ne' trista ne' lieta. Lo buon maestro comincio` a dire: <>. Cosi` vid'i' adunar la bella scola di quel segnor de l'altissimo canto che sovra li altri com'aquila vola. Da ch'ebber ragionato insieme alquanto, volsersi a me con salutevol cenno, e 'l mio maestro sorrise di tanto; e piu` d'onore ancora assai mi fenno, ch'e' si` mi fecer de la loro schiera, si` ch'io fui sesto tra cotanto senno. Cosi` andammo infino a la lumera, parlando cose che 'l tacere e` bello, si` com'era 'l parlar cola` dov'era. Venimmo al pie` d'un nobile castello, sette volte cerchiato d'alte mura, difeso intorno d'un bel fiumicello. Questo passammo come terra dura; per sette porte intrai con questi savi: giugnemmo in prato di fresca verdura. Genti v'eran con occhi tardi e gravi, di grande autorita` ne' lor sembianti: parlavan rado, con voci soavi. Traemmoci cosi` da l'un de' canti, in loco aperto, luminoso e alto, si` che veder si potien tutti quanti. Cola` diritto, sovra 'l verde smalto, mi fuor mostrati li spiriti magni, che del vedere in me stesso m'essalto. I' vidi Eletra con molti compagni, tra ' quai conobbi Ettor ed Enea, Cesare armato con li occhi grifagni. Vidi Cammilla e la Pantasilea; da l'altra parte, vidi 'l re Latino che con Lavina sua figlia sedea. Vidi quel Bruto che caccio` Tarquino, Lucrezia, Iulia, Marzia e Corniglia; e solo, in parte, vidi 'l Saladino. Poi ch'innalzai un poco piu` le ciglia, vidi 'l maestro di color che sanno seder tra filosofica famiglia. Tutti lo miran, tutti onor li fanno: quivi vid'io Socrate e Platone, che 'nnanzi a li altri piu` presso li stanno; Democrito, che 'l mondo a caso pone, Diogenes, Anassagora e Tale, Empedocles, Eraclito e Zenone; e vidi il buono accoglitor del quale, Diascoride dico; e vidi Orfeo, Tulio e Lino e Seneca morale; Euclide geometra e Tolomeo, Ipocrate, Avicenna e Galieno, Averois, che 'l gran comento feo. Io non posso ritrar di tutti a pieno, pero` che si` mi caccia il lungo tema, che molte volte al fatto il dir vien meno. La sesta compagnia in due si scema: per altra via mi mena il savio duca, fuor de la queta, ne l'aura che trema. E vegno in parte ove non e` che luca. Inferno: Canto V Cosi` discesi del cerchio primaio giu` nel secondo, che men loco cinghia, e tanto piu` dolor, che punge a guaio. Stavvi Minos orribilmente, e ringhia: essamina le colpe ne l'intrata; giudica e manda secondo ch'avvinghia. Dico che quando l'anima mal nata li vien dinanzi, tutta si confessa; e quel conoscitor de le peccata vede qual loco d'inferno e` da essa; cignesi con la coda tante volte quantunque gradi vuol che giu` sia messa. Sempre dinanzi a lui ne stanno molte; vanno a vicenda ciascuna al giudizio; dicono e odono, e poi son giu` volte. <>, disse Minos a me quando mi vide, lasciando l'atto di cotanto offizio, <>. E 'l duca mio a lui: <>. Or incomincian le dolenti note a farmisi sentire; or son venuto la` dove molto pianto mi percuote. Io venni in loco d'ogne luce muto, che mugghia come fa mar per tempesta, se da contrari venti e` combattuto. La bufera infernal, che mai non resta, mena li spirti con la sua rapina; voltando e percotendo li molesta. Quando giungon davanti a la ruina, quivi le strida, il compianto, il lamento; bestemmian quivi la virtu` divina. Intesi ch'a cosi` fatto tormento enno dannati i peccator carnali, che la ragion sommettono al talento. E come li stornei ne portan l'ali nel freddo tempo, a schiera larga e piena, cosi` quel fiato li spiriti mali di qua, di la`, di giu`, di su` li mena; nulla speranza li conforta mai, non che di posa, ma di minor pena. E come i gru van cantando lor lai, faccendo in aere di se' lunga riga, cosi` vid'io venir, traendo guai, ombre portate da la detta briga; per ch'i' dissi: <>. <>, mi disse quelli allotta, <>; e piu` di mille ombre mostrommi e nominommi a dito, ch'amor di nostra vita dipartille. Poscia ch'io ebbi il mio dottore udito nomar le donne antiche e ' cavalieri, pieta` mi giunse, e fui quasi smarrito. I' cominciai: <>. Ed elli a me: <>. Si` tosto come il vento a noi li piega, mossi la voce: <>. Quali colombe dal disio chiamate con l'ali alzate e ferme al dolce nido vegnon per l'aere dal voler portate; cotali uscir de la schiera ov'e` Dido, a noi venendo per l'aere maligno, si` forte fu l'affettuoso grido. <>. Queste parole da lor ci fuor porte. Quand'io intesi quell'anime offense, china' il viso e tanto il tenni basso, fin che 'l poeta mi disse: <>. Quando rispuosi, cominciai: <>. Poi mi rivolsi a loro e parla' io, e cominciai: <>. E quella a me: <>. Mentre che l'uno spirto questo disse, l'altro piangea; si` che di pietade io venni men cosi` com'io morisse. E caddi come corpo morto cade. Inferno: Canto VI Al tornar de la mente, che si chiuse dinanzi a la pieta` d'i due cognati, che di trestizia tutto mi confuse, novi tormenti e novi tormentati mi veggio intorno, come ch'io mi mova e ch'io mi volga, e come che io guati. Io sono al terzo cerchio, de la piova etterna, maladetta, fredda e greve; regola e qualita` mai non l'e` nova. Grandine grossa, acqua tinta e neve per l'aere tenebroso si riversa; pute la terra che questo riceve. Cerbero, fiera crudele e diversa, con tre gole caninamente latra sovra la gente che quivi e` sommersa. Li occhi ha vermigli, la barba unta e atra, e 'l ventre largo, e unghiate le mani; graffia li spirti, ed iscoia ed isquatra. Urlar li fa la pioggia come cani; de l'un de' lati fanno a l'altro schermo; volgonsi spesso i miseri profani. Quando ci scorse Cerbero, il gran vermo, le bocche aperse e mostrocci le sanne; non avea membro che tenesse fermo. E 'l duca mio distese le sue spanne, prese la terra, e con piene le pugna la gitto` dentro a le bramose canne. Qual e` quel cane ch'abbaiando agogna, e si racqueta poi che 'l pasto morde, che' solo a divorarlo intende e pugna, cotai si fecer quelle facce lorde de lo demonio Cerbero, che 'ntrona l'anime si`, ch'esser vorrebber sorde. Noi passavam su per l'ombre che adona la greve pioggia, e ponavam le piante sovra lor vanita` che par persona. Elle giacean per terra tutte quante, fuor d'una ch'a seder si levo`, ratto ch'ella ci vide passarsi davante. <>, mi disse, <>. E io a lui: <>. Ed elli a me: <>. E piu` non fe' parola. Io li rispuosi: <>. E quelli a me: <>. Qui puose fine al lagrimabil suono. E io a lui: <>. E quelli: <>. Li diritti occhi torse allora in biechi; guardommi un poco, e poi chino` la testa: cadde con essa a par de li altri ciechi. E 'l duca disse a me: <>. Si` trapassammo per sozza mistura de l'ombre e de la pioggia, a passi lenti, toccando un poco la vita futura; per ch'io dissi: <>. Ed elli a me: <>. Noi aggirammo a tondo quella strada, parlando piu` assai ch'i' non ridico; venimmo al punto dove si digrada: quivi trovammo Pluto, il gran nemico. Inferno: Canto VII <>, comincio` Pluto con la voce chioccia; e quel savio gentil, che tutto seppe, disse per confortarmi: <>. Poi si rivolse a quella 'nfiata labbia, e disse: <>. Quali dal vento le gonfiate vele caggiono avvolte, poi che l'alber fiacca, tal cadde a terra la fiera crudele. Cosi` scendemmo ne la quarta lacca pigliando piu` de la dolente ripa che 'l mal de l'universo tutto insacca. Ahi giustizia di Dio! tante chi stipa nove travaglie e pene quant'io viddi? e perche' nostra colpa si` ne scipa? Come fa l'onda la` sovra Cariddi, che si frange con quella in cui s'intoppa, cosi` convien che qui la gente riddi. Qui vid'i' gente piu` ch'altrove troppa, e d'una parte e d'altra, con grand'urli, voltando pesi per forza di poppa. Percoteansi 'ncontro; e poscia pur li` si rivolgea ciascun, voltando a retro, gridando: <> e <>. Cosi` tornavan per lo cerchio tetro da ogne mano a l'opposito punto, gridandosi anche loro ontoso metro; poi si volgea ciascun, quand'era giunto, per lo suo mezzo cerchio a l'altra giostra. E io, ch'avea lo cor quasi compunto, dissi: <>. Ed elli a me: <>. E io: <>. Ed elli a me: <>. <>, diss'io, <>. E quelli a me: <>. Noi ricidemmo il cerchio a l'altra riva sovr'una fonte che bolle e riversa per un fossato che da lei deriva. L'acqua era buia assai piu` che persa; e noi, in compagnia de l'onde bige, intrammo giu` per una via diversa. In la palude va c'ha nome Stige questo tristo ruscel, quand'e` disceso al pie` de le maligne piagge grige. E io, che di mirare stava inteso, vidi genti fangose in quel pantano, ignude tutte, con sembiante offeso. Queste si percotean non pur con mano, ma con la testa e col petto e coi piedi, troncandosi co' denti a brano a brano. Lo buon maestro disse: <>. Cosi` girammo de la lorda pozza grand'arco tra la ripa secca e 'l mezzo, con li occhi volti a chi del fango ingozza. Venimmo al pie` d'una torre al da sezzo. Inferno: Canto VIII Io dico, seguitando, ch'assai prima che noi fossimo al pie` de l'alta torre, li occhi nostri n'andar suso a la cima per due fiammette che i vedemmo porre e un'altra da lungi render cenno tanto ch'a pena il potea l'occhio torre. E io mi volsi al mar di tutto 'l senno; dissi: <>. Ed elli a me: <>. Corda non pinse mai da se' saetta che si` corresse via per l'aere snella, com'io vidi una nave piccioletta venir per l'acqua verso noi in quella, sotto 'l governo d'un sol galeoto, che gridava: <>. <>, disse lo mio segnore <>. Qual e` colui che grande inganno ascolta che li sia fatto, e poi se ne rammarca, fecesi Flegias ne l'ira accolta. Lo duca mio discese ne la barca, e poi mi fece intrare appresso lui; e sol quand'io fui dentro parve carca. Tosto che 'l duca e io nel legno fui, segando se ne va l'antica prora de l'acqua piu` che non suol con altrui. Mentre noi corravam la morta gora, dinanzi mi si fece un pien di fango, e disse: <>. E io a lui: <>. Rispuose: <>. E io a lui: <>. Allor distese al legno ambo le mani; per che 'l maestro accorto lo sospinse, dicendo: <>. Lo collo poi con le braccia mi cinse; basciommi 'l volto, e disse: <>. E io: <>. Ed elli a me: <>. Dopo cio` poco vid'io quello strazio far di costui a le fangose genti, che Dio ancor ne lodo e ne ringrazio. Tutti gridavano: <>; e 'l fiorentino spirito bizzarro in se' medesmo si volvea co' denti. Quivi il lasciammo, che piu` non ne narro; ma ne l'orecchie mi percosse un duolo, per ch'io avante l'occhio intento sbarro. Lo buon maestro disse: <>. E io: <>. Ed ei mi disse: <>. Noi pur giugnemmo dentro a l'alte fosse che vallan quella terra sconsolata: le mura mi parean che ferro fosse. Non sanza prima far grande aggirata, venimmo in parte dove il nocchier forte <>, grido`: <>. Io vidi piu` di mille in su le porte da ciel piovuti, che stizzosamente dicean: <>. E 'l savio mio maestro fece segno di voler lor parlar segretamente. Allor chiusero un poco il gran disdegno, e disser: <>. Pensa, lettor, se io mi sconfortai nel suon de le parole maladette, che' non credetti ritornarci mai. <>, diss'io, <>. E quel segnor che li` m'avea menato, mi disse: <>. Cosi` sen va, e quivi m'abbandona lo dolce padre, e io rimagno in forse, che si` e no nel capo mi tenciona. Udir non potti quello ch'a lor porse; ma ei non stette la` con essi guari, che ciascun dentro a pruova si ricorse. Chiuser le porte que' nostri avversari nel petto al mio segnor, che fuor rimase, e rivolsesi a me con passi rari. Li occhi a la terra e le ciglia avea rase d'ogne baldanza, e dicea ne' sospiri: <>. E a me disse: <>. Inferno: Canto IX Quel color che vilta` di fuor mi pinse veggendo il duca mio tornare in volta, piu` tosto dentro il suo novo ristrinse. Attento si fermo` com'uom ch'ascolta; che' l'occhio nol potea menare a lunga per l'aere nero e per la nebbia folta. <>, comincio` el, <>. I' vidi ben si` com'ei ricoperse lo cominciar con l'altro che poi venne, che fur parole a le prime diverse; ma nondimen paura il suo dir dienne, perch'io traeva la parola tronca forse a peggior sentenzia che non tenne. <>. Questa question fec'io; e quei <>, mi rispuose, <>. E altro disse, ma non l'ho a mente; pero` che l'occhio m'avea tutto tratto ver' l'alta torre a la cima rovente, dove in un punto furon dritte ratto tre furie infernal di sangue tinte, che membra feminine avieno e atto, e con idre verdissime eran cinte; serpentelli e ceraste avien per crine, onde le fiere tempie erano avvinte. E quei, che ben conobbe le meschine de la regina de l'etterno pianto, <>, mi disse, <>; e tacque a tanto. Con l'unghie si fendea ciascuna il petto; battiensi a palme, e gridavan si` alto, ch'i' mi strinsi al poeta per sospetto. <>, dicevan tutte riguardando in giuso; <>. <>. Cosi` disse 'l maestro; ed elli stessi mi volse, e non si tenne a le mie mani, che con le sue ancor non mi chiudessi. O voi ch'avete li 'ntelletti sani, mirate la dottrina che s'asconde sotto 'l velame de li versi strani. E gia` venia su per le torbide onde un fracasso d'un suon, pien di spavento, per cui tremavano amendue le sponde, non altrimenti fatto che d'un vento impetuoso per li avversi ardori, che fier la selva e sanz'alcun rattento li rami schianta, abbatte e porta fori; dinanzi polveroso va superbo, e fa fuggir le fiere e li pastori. Gli occhi mi sciolse e disse: <>. Come le rane innanzi a la nimica biscia per l'acqua si dileguan tutte, fin ch'a la terra ciascuna s'abbica, vid'io piu` di mille anime distrutte fuggir cosi` dinanzi ad un ch'al passo passava Stige con le piante asciutte. Dal volto rimovea quell'aere grasso, menando la sinistra innanzi spesso; e sol di quell'angoscia parea lasso. Ben m'accorsi ch'elli era da ciel messo, e volsimi al maestro; e quei fe' segno ch'i' stessi queto ed inchinassi ad esso. Ahi quanto mi parea pien di disdegno! Venne a la porta, e con una verghetta l'aperse, che non v'ebbe alcun ritegno. <>, comincio` elli in su l'orribil soglia, <>. Poi si rivolse per la strada lorda, e non fe' motto a noi, ma fe' sembiante d'omo cui altra cura stringa e morda che quella di colui che li e` davante; e noi movemmo i piedi inver' la terra, sicuri appresso le parole sante. Dentro li 'ntrammo sanz'alcuna guerra; e io, ch'avea di riguardar disio la condizion che tal fortezza serra, com'io fui dentro, l'occhio intorno invio; e veggio ad ogne man grande campagna piena di duolo e di tormento rio. Si` come ad Arli, ove Rodano stagna, si` com'a Pola, presso del Carnaro ch'Italia chiude e suoi termini bagna, fanno i sepulcri tutt'il loco varo, cosi` facevan quivi d'ogne parte, salvo che 'l modo v'era piu` amaro; che' tra gli avelli fiamme erano sparte, per le quali eran si` del tutto accesi, che ferro piu` non chiede verun'arte. Tutti li lor coperchi eran sospesi, e fuor n'uscivan si` duri lamenti, che ben parean di miseri e d'offesi. E io: <>. Ed elli a me: <>. E poi ch'a la man destra si fu volto, passammo tra i martiri e li alti spaldi. Inferno: Canto X Ora sen va per un secreto calle, tra 'l muro de la terra e li martiri, lo mio maestro, e io dopo le spalle. <>, cominciai, <>. E quelli a me: <>. E io: <>. <>. Subitamente questo suono uscio d'una de l'arche; pero` m'accostai, temendo, un poco piu` al duca mio. Ed el mi disse: <>. Io avea gia` il mio viso nel suo fitto; ed el s'ergea col petto e con la fronte com'avesse l'inferno a gran dispitto. E l'animose man del duca e pronte mi pinser tra le sepulture a lui, dicendo: <>. Com'io al pie` de la sua tomba fui, guardommi un poco, e poi, quasi sdegnoso, mi dimando`: <>. Io ch'era d'ubidir disideroso, non gliel celai, ma tutto gliel'apersi; ond'ei levo` le ciglia un poco in suso; poi disse: <>. <>, rispuos'io lui, <>. Allor surse a la vista scoperchiata un'ombra, lungo questa, infino al mento: credo che s'era in ginocchie levata. Dintorno mi guardo`, come talento avesse di veder s'altri era meco; e poi che 'l sospecciar fu tutto spento, piangendo disse: <>. E io a lui: <>. Le sue parole e 'l modo de la pena m'avean di costui gia` letto il nome; pero` fu la risposta cosi` piena. Di subito drizzato grido`: <>. Quando s'accorse d'alcuna dimora ch'io facea dinanzi a la risposta, supin ricadde e piu` non parve fora. Ma quell'altro magnanimo, a cui posta restato m'era, non muto` aspetto, ne' mosse collo, ne' piego` sua costa: e se' continuando al primo detto, <>, disse, <>. Ond'io a lui: <>. Poi ch'ebbe sospirando il capo mosso, <>, disse, <>. <>, prega' io lui, <>. <>, disse, <>. Allor, come di mia colpa compunto, dissi: <>. E gia` 'l maestro mio mi richiamava; per ch'i' pregai lo spirto piu` avaccio che mi dicesse chi con lu' istava. Dissemi: <>. Indi s'ascose; e io inver' l'antico poeta volsi i passi, ripensando a quel parlar che mi parea nemico. Elli si mosse; e poi, cosi` andando, mi disse: <>. E io li sodisfeci al suo dimando. <>, mi comando` quel saggio. <>, e drizzo` 'l dito: <>. Appresso mosse a man sinistra il piede: lasciammo il muro e gimmo inver' lo mezzo per un sentier ch'a una valle fiede, che 'nfin la` su` facea spiacer suo lezzo. Inferno: Canto XI In su l'estremita` d'un'alta ripa che facevan gran pietre rotte in cerchio venimmo sopra piu` crudele stipa; e quivi, per l'orribile soperchio del puzzo che 'l profondo abisso gitta, ci raccostammo, in dietro, ad un coperchio d'un grand'avello, ov'io vidi una scritta che dicea: "Anastasio papa guardo, lo qual trasse Fotin de la via dritta". <>. Cosi` 'l maestro; e io <>, dissi lui, <>. Ed elli: <>. <>, comincio` poi a dir, <>. E io: <>. Ed elli a me <>, disse <>. <>, diss'io, <>. <>, mi disse, <>. Inferno: Canto XII Era lo loco ov'a scender la riva venimmo, alpestro e, per quel che v'er'anco, tal, ch'ogne vista ne sarebbe schiva. Qual e` quella ruina che nel fianco di qua da Trento l'Adice percosse, o per tremoto o per sostegno manco, che da cima del monte, onde si mosse, al piano e` si` la roccia discoscesa, ch'alcuna via darebbe a chi su` fosse: cotal di quel burrato era la scesa; e 'n su la punta de la rotta lacca l'infamia di Creti era distesa che fu concetta ne la falsa vacca; e quando vide noi, se' stesso morse, si` come quei cui l'ira dentro fiacca. Lo savio mio inver' lui grido`: <>. Qual e` quel toro che si slaccia in quella c'ha ricevuto gia` 'l colpo mortale, che gir non sa, ma qua e la` saltella, vid'io lo Minotauro far cotale; e quello accorto grido`: <>. Cosi` prendemmo via giu` per lo scarco di quelle pietre, che spesso moviensi sotto i miei piedi per lo novo carco. Io gia pensando; e quei disse: <>. Oh cieca cupidigia e ira folle, che si` ci sproni ne la vita corta, e ne l'etterna poi si` mal c'immolle! Io vidi un'ampia fossa in arco torta, come quella che tutto 'l piano abbraccia, secondo ch'avea detto la mia scorta; e tra 'l pie` de la ripa ed essa, in traccia corrien centauri, armati di saette, come solien nel mondo andare a caccia. Veggendoci calar, ciascun ristette, e de la schiera tre si dipartiro con archi e asticciuole prima elette; e l'un grido` da lungi: <>. Lo mio maestro disse: <>. Poi mi tento`, e disse: <>. Noi ci appressammo a quelle fiere isnelle: Chiron prese uno strale, e con la cocca fece la barba in dietro a le mascelle. Quando s'ebbe scoperta la gran bocca, disse a' compagni: <>. E 'l mio buon duca, che gia` li er'al petto, dove le due nature son consorti, rispuose: <>. Chiron si volse in su la destra poppa, e disse a Nesso: <>. Or ci movemmo con la scorta fida lungo la proda del bollor vermiglio, dove i bolliti facieno alte strida. Io vidi gente sotto infino al ciglio; e 'l gran centauro disse: <>. Allor mi volsi al poeta, e quei disse: <>. Poco piu` oltre il centauro s'affisse sovr'una gente che 'nfino a la gola parea che di quel bulicame uscisse. Mostrocci un'ombra da l'un canto sola, dicendo: <>. Poi vidi gente che di fuor del rio tenean la testa e ancor tutto 'l casso; e di costoro assai riconobb'io. Cosi` a piu` a piu` si facea basso quel sangue, si` che cocea pur li piedi; e quindi fu del fosso il nostro passo. <>, disse 'l centauro, <>. Poi si rivolse, e ripassossi 'l guazzo. Inferno: Canto XIII Non era ancor di la` Nesso arrivato, quando noi ci mettemmo per un bosco che da neun sentiero era segnato. Non fronda verde, ma di color fosco; non rami schietti, ma nodosi e 'nvolti; non pomi v'eran, ma stecchi con tosco: non han si` aspri sterpi ne' si` folti quelle fiere selvagge che 'n odio hanno tra Cecina e Corneto i luoghi colti. Quivi le brutte Arpie lor nidi fanno, che cacciar de le Strofade i Troiani con tristo annunzio di futuro danno. Ali hanno late, e colli e visi umani, pie` con artigli, e pennuto 'l gran ventre; fanno lamenti in su li alberi strani. E 'l buon maestro <>, mi comincio` a dire, <>. Io sentia d'ogne parte trarre guai, e non vedea persona che 'l facesse; per ch'io tutto smarrito m'arrestai. Cred'io ch'ei credette ch'io credesse che tante voci uscisser, tra quei bronchi da gente che per noi si nascondesse. Pero` disse 'l maestro: <>. Allor porsi la mano un poco avante, e colsi un ramicel da un gran pruno; e 'l tronco suo grido`: <>. Da che fatto fu poi di sangue bruno, ricomincio` a dir: <>. Come d'un stizzo verde ch'arso sia da l'un de'capi, che da l'altro geme e cigola per vento che va via, si` de la scheggia rotta usciva insieme parole e sangue; ond'io lasciai la cima cadere, e stetti come l'uom che teme. <>, rispuose 'l savio mio, <>. E 'l tronco: <>. Un poco attese, e poi <>, disse 'l poeta a me, <>. Ond'io a lui: <>. Percio` ricomincio`: <>. Allor soffio` il tronco forte, e poi si converti` quel vento in cotal voce: <>. Noi eravamo ancora al tronco attesi, credendo ch'altro ne volesse dire, quando noi fummo d'un romor sorpresi, similemente a colui che venire sente 'l porco e la caccia a la sua posta, ch'ode le bestie, e le frasche stormire. Ed ecco due da la sinistra costa, nudi e graffiati, fuggendo si` forte, che de la selva rompieno ogni rosta. Quel dinanzi: <>. E l'altro, cui pareva tardar troppo, gridava: <>. E poi che forse li fallia la lena, di se' e d'un cespuglio fece un groppo. Di rietro a loro era la selva piena di nere cagne, bramose e correnti come veltri ch'uscisser di catena. In quel che s'appiatto` miser li denti, e quel dilaceraro a brano a brano; poi sen portar quelle membra dolenti. Presemi allor la mia scorta per mano, e menommi al cespuglio che piangea, per le rotture sanguinenti in vano. <>, dicea, <>. Quando 'l maestro fu sovr'esso fermo, disse <>. Ed elli a noi: <>. Inferno: Canto XIV Poi che la carita` del natio loco mi strinse, raunai le fronde sparte, e rende'le a colui, ch'era gia` fioco. Indi venimmo al fine ove si parte lo secondo giron dal terzo, e dove si vede di giustizia orribil arte. A ben manifestar le cose nove, dico che arrivammo ad una landa che dal suo letto ogne pianta rimove. La dolorosa selva l'e` ghirlanda intorno, come 'l fosso tristo ad essa: quivi fermammo i passi a randa a randa. Lo spazzo era una rena arida e spessa, non d'altra foggia fatta che colei che fu da' pie` di Caton gia` soppressa. O vendetta di Dio, quanto tu dei esser temuta da ciascun che legge cio` che fu manifesto a li occhi miei! D'anime nude vidi molte gregge che piangean tutte assai miseramente, e parea posta lor diversa legge. Supin giacea in terra alcuna gente, alcuna si sedea tutta raccolta, e altra andava continuamente. Quella che giva intorno era piu` molta, e quella men che giacea al tormento, ma piu` al duolo avea la lingua sciolta. Sovra tutto 'l sabbion, d'un cader lento, piovean di foco dilatate falde, come di neve in alpe sanza vento. Quali Alessandro in quelle parti calde d'India vide sopra 'l suo stuolo fiamme cadere infino a terra salde, per ch'ei provide a scalpitar lo suolo con le sue schiere, accio` che lo vapore mei si stingueva mentre ch'era solo: tale scendeva l'etternale ardore; onde la rena s'accendea, com'esca sotto focile, a doppiar lo dolore. Sanza riposo mai era la tresca de le misere mani, or quindi or quinci escotendo da se' l'arsura fresca. I' cominciai: <>. E quel medesmo, che si fu accorto ch'io domandava il mio duca di lui, grido`: <>. Allora il duca mio parlo` di forza tanto, ch'i' non l'avea si` forte udito: <>. Poi si rivolse a me con miglior labbia dicendo: <>. Tacendo divenimmo la` 've spiccia fuor de la selva un picciol fiumicello, lo cui rossore ancor mi raccapriccia. Quale del Bulicame esce ruscello che parton poi tra lor le peccatrici, tal per la rena giu` sen giva quello. Lo fondo suo e ambo le pendici fatt'era 'n pietra, e ' margini dallato; per ch'io m'accorsi che 'l passo era lici. <>. Queste parole fuor del duca mio; per ch'io 'l pregai che mi largisse 'l pasto di cui largito m'avea il disio. <>, diss'elli allora, <>. E io a lui: <>. Ed elli a me: <>. E io ancor: <>. <>, rispuose; <>. Poi disse: <>. Inferno: Canto XV Ora cen porta l'un de' duri margini; e 'l fummo del ruscel di sopra aduggia, si` che dal foco salva l'acqua e li argini. Quali Fiamminghi tra Guizzante e Bruggia, temendo 'l fiotto che 'nver lor s'avventa, fanno lo schermo perche' 'l mar si fuggia; e quali Padoan lungo la Brenta, per difender lor ville e lor castelli, anzi che Carentana il caldo senta: a tale imagine eran fatti quelli, tutto che ne' si` alti ne' si` grossi, qual che si fosse, lo maestro felli. Gia` eravam da la selva rimossi tanto, ch'i' non avrei visto dov'era, perch'io in dietro rivolto mi fossi, quando incontrammo d'anime una schiera che venian lungo l'argine, e ciascuna ci riguardava come suol da sera guardare uno altro sotto nuova luna; e si` ver' noi aguzzavan le ciglia come 'l vecchio sartor fa ne la cruna. Cosi` adocchiato da cotal famiglia, fui conosciuto da un, che mi prese per lo lembo e grido`: <>. E io, quando 'l suo braccio a me distese, ficcai li occhi per lo cotto aspetto, si` che 'l viso abbrusciato non difese la conoscenza sua al mio 'ntelletto; e chinando la mano a la sua faccia, rispuosi: <>. E quelli: <>. I' dissi lui: <>. <>, disse, <>. I' non osava scender de la strada per andar par di lui; ma 'l capo chino tenea com'uom che reverente vada. El comincio`: <>. <>, rispuos'io lui, <>. Ed elli a me: <>. <>, rispuos'io lui, <>. Lo mio maestro allora in su la gota destra si volse in dietro, e riguardommi; poi disse: <>. Ne' per tanto di men parlando vommi con ser Brunetto, e dimando chi sono li suoi compagni piu` noti e piu` sommi. Ed elli a me: <>. Poi si rivolse, e parve di coloro che corrono a Verona il drappo verde per la campagna; e parve di costoro quelli che vince, non colui che perde. Inferno: Canto XVI Gia` era in loco onde s'udia 'l rimbombo de l'acqua che cadea ne l'altro giro, simile a quel che l'arnie fanno rombo, quando tre ombre insieme si partiro, correndo, d'una torma che passava sotto la pioggia de l'aspro martiro. Venian ver noi, e ciascuna gridava: <>. Ahime`, che piaghe vidi ne' lor membri ricenti e vecchie, da le fiamme incese! Ancor men duol pur ch'i' me ne rimembri. A le lor grida il mio dottor s'attese; volse 'l viso ver me, e: <>, disse <>. Ricominciar, come noi restammo, ei l'antico verso; e quando a noi fuor giunti, fenno una rota di se' tutti e trei. Qual sogliono i campion far nudi e unti, avvisando lor presa e lor vantaggio, prima che sien tra lor battuti e punti, cosi` rotando, ciascuno il visaggio drizzava a me, si` che 'n contraro il collo faceva ai pie` continuo viaggio. E <>, comincio` l'uno <>. S'i' fossi stato dal foco coperto, gittato mi sarei tra lor di sotto, e credo che 'l dottor l'avria sofferto; ma perch'io mi sarei brusciato e cotto, vinse paura la mia buona voglia che di loro abbracciar mi facea ghiotto. Poi cominciai: <>. <>, rispuose quelli ancora, <>. <>. Cosi` gridai con la faccia levata; e i tre, che cio` inteser per risposta, guardar l'un l'altro com'al ver si guata. <>, rispuoser tutti <>. Indi rupper la rota, e a fuggirsi ali sembiar le gambe loro isnelle. Un amen non saria potuto dirsi tosto cosi` com'e' fuoro spariti; per ch'al maestro parve di partirsi. Io lo seguiva, e poco eravam iti, che 'l suon de l'acqua n'era si` vicino, che per parlar saremmo a pena uditi. Come quel fiume c'ha proprio cammino prima dal Monte Viso 'nver' levante, da la sinistra costa d'Apennino, che si chiama Acquacheta suso, avante che si divalli giu` nel basso letto, e a Forli` di quel nome e` vacante, rimbomba la` sovra San Benedetto de l'Alpe per cadere ad una scesa ove dovea per mille esser recetto; cosi`, giu` d'una ripa discoscesa, trovammo risonar quell'acqua tinta, si` che 'n poc'ora avria l'orecchia offesa. Io avea una corda intorno cinta, e con essa pensai alcuna volta prender la lonza a la pelle dipinta. Poscia ch'io l'ebbi tutta da me sciolta, si` come 'l duca m'avea comandato, porsila a lui aggroppata e ravvolta. Ond'ei si volse inver' lo destro lato, e alquanto di lunge da la sponda la gitto` giuso in quell'alto burrato. 'E' pur convien che novita` risponda' dicea fra me medesmo 'al novo cenno che 'l maestro con l'occhio si` seconda'. Ahi quanto cauti li uomini esser dienno presso a color che non veggion pur l'ovra, ma per entro i pensier miran col senno! El disse a me: <>. Sempre a quel ver c'ha faccia di menzogna de' l'uom chiuder le labbra fin ch'el puote, pero` che sanza colpa fa vergogna; ma qui tacer nol posso; e per le note di questa comedia, lettor, ti giuro, s'elle non sien di lunga grazia vote, ch'i' vidi per quell'aere grosso e scuro venir notando una figura in suso, maravigliosa ad ogne cor sicuro, si` come torna colui che va giuso talora a solver l'ancora ch'aggrappa o scoglio o altro che nel mare e` chiuso, che 'n su` si stende, e da pie` si rattrappa. Inferno: Canto XVII <>. Si` comincio` lo mio duca a parlarmi; e accennolle che venisse a proda vicino al fin d'i passeggiati marmi. E quella sozza imagine di froda sen venne, e arrivo` la testa e 'l busto, ma 'n su la riva non trasse la coda. La faccia sua era faccia d'uom giusto, tanto benigna avea di fuor la pelle, e d'un serpente tutto l'altro fusto; due branche avea pilose insin l'ascelle; lo dosso e 'l petto e ambedue le coste dipinti avea di nodi e di rotelle. Con piu` color, sommesse e sovraposte non fer mai drappi Tartari ne' Turchi, ne' fuor tai tele per Aragne imposte. Come tal volta stanno a riva i burchi, che parte sono in acqua e parte in terra, e come la` tra li Tedeschi lurchi lo bivero s'assetta a far sua guerra, cosi` la fiera pessima si stava su l'orlo ch'e` di pietra e 'l sabbion serra. Nel vano tutta sua coda guizzava, torcendo in su` la venenosa forca ch'a guisa di scorpion la punta armava. Lo duca disse: <>. Pero` scendemmo a la destra mammella, e diece passi femmo in su lo stremo, per ben cessar la rena e la fiammella. E quando noi a lei venuti semo, poco piu` oltre veggio in su la rena gente seder propinqua al loco scemo. Quivi 'l maestro <>, mi disse, <>. Cosi` ancor su per la strema testa di quel settimo cerchio tutto solo andai, dove sedea la gente mesta. Per li occhi fora scoppiava lor duolo; e` di qua, di la` soccorrien con le mani quando a' vapori, e quando al caldo suolo: non altrimenti fan di state i cani or col ceffo, or col pie`, quando son morsi o da pulci o da mosche o da tafani. Poi che nel viso a certi li occhi porsi, ne' quali 'l doloroso foco casca, non ne conobbi alcun; ma io m'accorsi che dal collo a ciascun pendea una tasca ch'avea certo colore e certo segno, e quindi par che 'l loro occhio si pasca. E com'io riguardando tra lor vegno, in una borsa gialla vidi azzurro che d'un leone avea faccia e contegno. Poi, procedendo di mio sguardo il curro, vidine un'altra come sangue rossa, mostrando un'oca bianca piu` che burro. E un che d'una scrofa azzurra e grossa segnato avea lo suo sacchetto bianco, mi disse: <>. Qui distorse la bocca e di fuor trasse la lingua, come bue che 'l naso lecchi. E io, temendo no 'l piu` star crucciasse lui che di poco star m'avea 'mmonito, torna'mi in dietro da l'anime lasse. Trova' il duca mio ch'era salito gia` su la groppa del fiero animale, e disse a me: <>. Qual e` colui che si` presso ha 'l riprezzo de la quartana, c'ha gia` l'unghie smorte, e triema tutto pur guardando 'l rezzo, tal divenn'io a le parole porte; ma vergogna mi fe' le sue minacce, che innanzi a buon segnor fa servo forte. I' m'assettai in su quelle spallacce; si` volli dir, ma la voce non venne com'io credetti: 'Fa che tu m'abbracce'. Ma esso, ch'altra volta mi sovvenne ad altro forse, tosto ch'i' montai con le braccia m'avvinse e mi sostenne; e disse: <>. Come la navicella esce di loco in dietro in dietro, si` quindi si tolse; e poi ch'al tutto si senti` a gioco, la` 'v'era 'l petto, la coda rivolse, e quella tesa, come anguilla, mosse, e con le branche l'aere a se' raccolse. Maggior paura non credo che fosse quando Fetonte abbandono` li freni, per che 'l ciel, come pare ancor, si cosse; ne' quando Icaro misero le reni senti` spennar per la scaldata cera, gridando il padre a lui <>, che fu la mia, quando vidi ch'i' era ne l'aere d'ogne parte, e vidi spenta ogne veduta fuor che de la fera. Ella sen va notando lenta lenta: rota e discende, ma non me n'accorgo se non che al viso e di sotto mi venta. Io sentia gia` da la man destra il gorgo far sotto noi un orribile scroscio, per che con li occhi 'n giu` la testa sporgo. Allor fu' io piu` timido a lo stoscio, pero` ch'i' vidi fuochi e senti' pianti; ond'io tremando tutto mi raccoscio. E vidi poi, che' nol vedea davanti, lo scendere e 'l girar per li gran mali che s'appressavan da diversi canti. Come 'l falcon ch'e` stato assai su l'ali, che sanza veder logoro o uccello fa dire al falconiere <>, discende lasso onde si move isnello, per cento rote, e da lunge si pone dal suo maestro, disdegnoso e fello; cosi` ne puose al fondo Gerione al pie` al pie` de la stagliata rocca e, discarcate le nostre persone, si dileguo` come da corda cocca. Inferno: Canto XVIII Luogo e` in inferno detto Malebolge, tutto di pietra di color ferrigno, come la cerchia che dintorno il volge. Nel dritto mezzo del campo maligno vaneggia un pozzo assai largo e profondo, di cui suo loco dicero` l'ordigno. Quel cinghio che rimane adunque e` tondo tra 'l pozzo e 'l pie` de l'alta ripa dura, e ha distinto in dieci valli il fondo. Quale, dove per guardia de le mura piu` e piu` fossi cingon li castelli, la parte dove son rende figura, tale imagine quivi facean quelli; e come a tai fortezze da' lor sogli a la ripa di fuor son ponticelli, cosi` da imo de la roccia scogli movien che ricidien li argini e ' fossi infino al pozzo che i tronca e raccogli. In questo luogo, de la schiena scossi di Gerion, trovammoci; e 'l poeta tenne a sinistra, e io dietro mi mossi. A la man destra vidi nova pieta, novo tormento e novi frustatori, di che la prima bolgia era repleta. Nel fondo erano ignudi i peccatori; dal mezzo in qua ci venien verso 'l volto, di la` con noi, ma con passi maggiori, come i Roman per l'essercito molto, l'anno del giubileo, su per lo ponte hanno a passar la gente modo colto, che da l'un lato tutti hanno la fronte verso 'l castello e vanno a Santo Pietro; da l'altra sponda vanno verso 'l monte. Di qua, di la`, su per lo sasso tetro vidi demon cornuti con gran ferze, che li battien crudelmente di retro. Ahi come facean lor levar le berze a le prime percosse! gia` nessuno le seconde aspettava ne' le terze. Mentr'io andava, li occhi miei in uno furo scontrati; e io si` tosto dissi: <>. Per ch'io a figurarlo i piedi affissi; e 'l dolce duca meco si ristette, e assentio ch'alquanto in dietro gissi. E quel frustato celar si credette bassando 'l viso; ma poco li valse, ch'io dissi: <>. Ed elli a me: <>. Cosi` parlando il percosse un demonio de la sua scuriada, e disse: <>. I' mi raggiunsi con la scorta mia; poscia con pochi passi divenimmo la` 'v'uno scoglio de la ripa uscia. Assai leggeramente quel salimmo; e volti a destra su per la sua scheggia, da quelle cerchie etterne ci partimmo. Quando noi fummo la` dov'el vaneggia di sotto per dar passo a li sferzati, lo duca disse: <>. Del vecchio ponte guardavam la traccia che venia verso noi da l'altra banda, e che la ferza similmente scaccia. E 'l buon maestro, sanza mia dimanda, mi disse: <>. Gia` eravam la` 've lo stretto calle con l'argine secondo s'incrocicchia, e fa di quello ad un altr'arco spalle. Quindi sentimmo gente che si nicchia ne l'altra bolgia e che col muso scuffa, e se' medesma con le palme picchia. Le ripe eran grommate d'una muffa, per l'alito di giu` che vi s'appasta, che con li occhi e col naso facea zuffa. Lo fondo e` cupo si`, che non ci basta loco a veder sanza montare al dosso de l'arco, ove lo scoglio piu` sovrasta. Quivi venimmo; e quindi giu` nel fosso vidi gente attuffata in uno sterco che da li uman privadi parea mosso. E mentre ch'io la` giu` con l'occhio cerco, vidi un col capo si` di merda lordo, che non parea s'era laico o cherco. Quei mi sgrido`: <>. E io a lui: <>. Ed elli allor, battendosi la zucca: <>. Appresso cio` lo duca <>, mi disse <>. Inferno: Canto XIX O Simon mago, o miseri seguaci che le cose di Dio, che di bontate deon essere spose, e voi rapaci per oro e per argento avolterate, or convien che per voi suoni la tromba, pero` che ne la terza bolgia state. Gia` eravamo, a la seguente tomba, montati de lo scoglio in quella parte ch'a punto sovra mezzo 'l fosso piomba. O somma sapienza, quanta e` l'arte che mostri in cielo, in terra e nel mal mondo, e quanto giusto tua virtu` comparte! Io vidi per le coste e per lo fondo piena la pietra livida di fori, d'un largo tutti e ciascun era tondo. Non mi parean men ampi ne' maggiori che que' che son nel mio bel San Giovanni, fatti per loco d'i battezzatori; l'un de li quali, ancor non e` molt'anni, rupp'io per un che dentro v'annegava: e questo sia suggel ch'ogn'omo sganni. Fuor de la bocca a ciascun soperchiava d'un peccator li piedi e de le gambe infino al grosso, e l'altro dentro stava. Le piante erano a tutti accese intrambe; per che si` forte guizzavan le giunte, che spezzate averien ritorte e strambe. Qual suole il fiammeggiar de le cose unte muoversi pur su per la strema buccia, tal era li` dai calcagni a le punte. <>, diss'io, <>. Ed elli a me: <>. E io: <>. Allor venimmo in su l'argine quarto: volgemmo e discendemmo a mano stanca la` giu` nel fondo foracchiato e arto. Lo buon maestro ancor de la sua anca non mi dipuose, si` mi giunse al rotto di quel che si piangeva con la zanca. <>, comincia' io a dir, <>. Io stava come 'l frate che confessa lo perfido assessin, che, poi ch'e` fitto, richiama lui, per che la morte cessa. Ed el grido`: <>. Tal mi fec'io, quai son color che stanno, per non intender cio` ch'e` lor risposto, quasi scornati, e risponder non sanno. Allor Virgilio disse: <>; e io rispuosi come a me fu imposto. Per che lo spirto tutti storse i piedi; poi, sospirando e con voce di pianto, mi disse: <>. Io non so s'i' mi fui qui troppo folle, ch'i' pur rispuosi lui a questo metro: <>. E mentr'io li cantava cotai note, o ira o coscienza che 'l mordesse, forte spingava con ambo le piote. I' credo ben ch'al mio duca piacesse, con si` contenta labbia sempre attese lo suon de le parole vere espresse. Pero` con ambo le braccia mi prese; e poi che tutto su mi s'ebbe al petto, rimonto` per la via onde discese. Ne' si stanco` d'avermi a se' distretto, si` men porto` sovra 'l colmo de l'arco che dal quarto al quinto argine e` tragetto. Quivi soavemente spuose il carco, soave per lo scoglio sconcio ed erto che sarebbe a le capre duro varco. Indi un altro vallon mi fu scoperto. Inferno: Canto XX Di nova pena mi conven far versi e dar matera al ventesimo canto de la prima canzon ch'e` d'i sommersi. Io era gia` disposto tutto quanto a riguardar ne lo scoperto fondo, che si bagnava d'angoscioso pianto; e vidi gente per lo vallon tondo venir, tacendo e lagrimando, al passo che fanno le letane in questo mondo. Come 'l viso mi scese in lor piu` basso, mirabilmente apparve esser travolto ciascun tra 'l mento e 'l principio del casso; che' da le reni era tornato 'l volto, e in dietro venir li convenia, perche' 'l veder dinanzi era lor tolto. Forse per forza gia` di parlasia si travolse cosi` alcun del tutto; ma io nol vidi, ne' credo che sia. Se Dio ti lasci, lettor, prender frutto di tua lezione, or pensa per te stesso com'io potea tener lo viso asciutto, quando la nostra imagine di presso vidi si` torta, che 'l pianto de li occhi le natiche bagnava per lo fesso. Certo io piangea, poggiato a un de' rocchi del duro scoglio, si` che la mia scorta mi disse: <>. E io: <>. Allor mi disse: <>. Si` mi parlava, e andavamo introcque. Inferno: Canto XXI Cosi` di ponte in ponte, altro parlando che la mia comedia cantar non cura, venimmo; e tenavamo il colmo, quando restammo per veder l'altra fessura di Malebolge e li altri pianti vani; e vidila mirabilmente oscura. Quale ne l'arzana` de' Viniziani bolle l'inverno la tenace pece a rimpalmare i legni lor non sani, che' navicar non ponno - in quella vece chi fa suo legno novo e chi ristoppa le coste a quel che piu` viaggi fece; chi ribatte da proda e chi da poppa; altri fa remi e altri volge sarte; chi terzeruolo e artimon rintoppa -; tal, non per foco, ma per divin'arte, bollia la` giuso una pegola spessa, che 'nviscava la ripa d'ogne parte. I' vedea lei, ma non vedea in essa mai che le bolle che 'l bollor levava, e gonfiar tutta, e riseder compressa. Mentr'io la` giu` fisamente mirava, lo duca mio, dicendo <>, mi trasse a se' del loco dov'io stava. Allor mi volsi come l'uom cui tarda di veder quel che li convien fuggire e cui paura subita sgagliarda, che, per veder, non indugia 'l partire: e vidi dietro a noi un diavol nero correndo su per lo scoglio venire. Ahi quant'elli era ne l'aspetto fero! e quanto mi parea ne l'atto acerbo, con l'ali aperte e sovra i pie` leggero! L'omero suo, ch'era aguto e superbo, carcava un peccator con ambo l'anche, e quei tenea de' pie` ghermito 'l nerbo. Del nostro ponte disse: <>. La` giu` 'l butto`, e per lo scoglio duro si volse; e mai non fu mastino sciolto con tanta fretta a seguitar lo furo. Quel s'attuffo`, e torno` su` convolto; ma i demon che del ponte avean coperchio, gridar: <>. Poi l'addentar con piu` di cento raffi, disser: <>. Non altrimenti i cuoci a' lor vassalli fanno attuffare in mezzo la caldaia la carne con li uncin, perche' non galli. Lo buon maestro <>, mi disse, <>. Poscia passo` di la` dal co del ponte; e com'el giunse in su la ripa sesta, mestier li fu d'aver sicura fronte. Con quel furore e con quella tempesta ch'escono i cani a dosso al poverello che di subito chiede ove s'arresta, usciron quei di sotto al ponticello, e volser contra lui tutt'i runcigli; ma el grido`: <>. Tutti gridaron: <>; per ch'un si mosse - e li altri stetter fermi -, e venne a lui dicendo: <>. <>, disse 'l mio maestro, <>. Allor li fu l'orgoglio si` caduto, ch'e' si lascio` cascar l'uncino a' piedi, e disse a li altri: <>. E 'l duca mio a me: <>. Per ch'io mi mossi, e a lui venni ratto; e i diavoli si fecer tutti avanti, si` ch'io temetti ch'ei tenesser patto; cosi` vid'io gia` temer li fanti ch'uscivan patteggiati di Caprona, veggendo se' tra nemici cotanti. I' m'accostai con tutta la persona lungo 'l mio duca, e non torceva li occhi da la sembianza lor ch'era non buona. Ei chinavan li raffi e <>, diceva l'un con l'altro, <>. E rispondien: <>. Ma quel demonio che tenea sermone col duca mio, si volse tutto presto, e disse: <>. Poi disse a noi: <>. <>, comincio` elli a dire, <>. <>, diss'io, <>. Ed elli a me: <>. Per l'argine sinistro volta dienno; ma prima avea ciascun la lingua stretta coi denti, verso lor duca, per cenno; ed elli avea del cul fatto trombetta. Inferno: Canto XXII Io vidi gia` cavalier muover campo, e cominciare stormo e far lor mostra, e talvolta partir per loro scampo; corridor vidi per la terra vostra, o Aretini, e vidi gir gualdane, fedir torneamenti e correr giostra; quando con trombe, e quando con campane, con tamburi e con cenni di castella, e con cose nostrali e con istrane; ne' gia` con si` diversa cennamella cavalier vidi muover ne' pedoni, ne' nave a segno di terra o di stella. Noi andavam con li diece demoni. Ahi fiera compagnia! ma ne la chiesa coi santi, e in taverna coi ghiottoni. Pur a la pegola era la mia 'ntesa, per veder de la bolgia ogne contegno e de la gente ch'entro v'era incesa. Come i dalfini, quando fanno segno a' marinar con l'arco de la schiena, che s'argomentin di campar lor legno, talor cosi`, ad alleggiar la pena, mostrav'alcun de' peccatori il dosso e nascondea in men che non balena. E come a l'orlo de l'acqua d'un fosso stanno i ranocchi pur col muso fuori, si` che celano i piedi e l'altro grosso, si` stavan d'ogne parte i peccatori; ma come s'appressava Barbariccia, cosi` si ritraen sotto i bollori. I' vidi, e anco il cor me n'accapriccia, uno aspettar cosi`, com'elli 'ncontra ch'una rana rimane e l'altra spiccia; e Graffiacan, che li era piu` di contra, li arrunciglio` le 'mpegolate chiome e trassel su`, che mi parve una lontra. I' sapea gia` di tutti quanti 'l nome, si` li notai quando fuorono eletti, e poi ch'e' si chiamaro, attesi come. <>, gridavan tutti insieme i maladetti. E io: <>. Lo duca mio li s'accosto` allato; domandollo ond'ei fosse, e quei rispuose: <>. E Ciriatto, a cui di bocca uscia d'ogne parte una sanna come a porco, li fe' sentir come l'una sdruscia. Tra male gatte era venuto 'l sorco; ma Barbariccia il chiuse con le braccia, e disse: <>. E al maestro mio volse la faccia: <>, disse, <>. Lo duca dunque: <>. E quelli: <>. E Libicocco <>, disse; e preseli 'l braccio col runciglio, si` che, stracciando, ne porto` un lacerto. Draghignazzo anco i volle dar di piglio giuso a le gambe; onde 'l decurio loro si volse intorno intorno con mal piglio. Quand'elli un poco rappaciati fuoro, a lui, ch'ancor mirava sua ferita, domando` 'l duca mio sanza dimoro: <>. Ed ei rispuose: <>. E 'l gran proposto, volto a Farfarello che stralunava li occhi per fedire, disse: <>. <>, ricomincio` lo spaurato appresso <>. Cagnazzo a cotal motto levo` 'l muso, crollando 'l capo, e disse: <>. Ond'ei, ch'avea lacciuoli a gran divizia, rispuose: <>. Alichin non si tenne e, di rintoppo a li altri, disse a lui: <>. O tu che leggi, udirai nuovo ludo: ciascun da l'altra costa li occhi volse; quel prima, ch'a cio` fare era piu` crudo. Lo Navarrese ben suo tempo colse; fermo` le piante a terra, e in un punto salto` e dal proposto lor si sciolse. Di che ciascun di colpa fu compunto, ma quei piu` che cagion fu del difetto; pero` si mosse e grido`: <>. Ma poco i valse: che' l'ali al sospetto non potero avanzar: quelli ando` sotto, e quei drizzo` volando suso il petto: non altrimenti l'anitra di botto, quando 'l falcon s'appressa, giu` s'attuffa, ed ei ritorna su` crucciato e rotto. Irato Calcabrina de la buffa, volando dietro li tenne, invaghito che quei campasse per aver la zuffa; e come 'l barattier fu disparito, cosi` volse li artigli al suo compagno, e fu con lui sopra 'l fosso ghermito. Ma l'altro fu bene sparvier grifagno ad artigliar ben lui, e amendue cadder nel mezzo del bogliente stagno. Lo caldo sghermitor subito fue; ma pero` di levarsi era neente, si` avieno inviscate l'ali sue. Barbariccia, con li altri suoi dolente, quattro ne fe' volar da l'altra costa con tutt'i raffi, e assai prestamente di qua, di la` discesero a la posta; porser li uncini verso li 'mpaniati, ch'eran gia` cotti dentro da la crosta; e noi lasciammo lor cosi` 'mpacciati. Inferno: Canto XXIII Taciti, soli, sanza compagnia n'andavam l'un dinanzi e l'altro dopo, come frati minor vanno per via. Volt'era in su la favola d'Isopo lo mio pensier per la presente rissa, dov'el parlo` de la rana e del topo; che' piu` non si pareggia 'mo' e 'issa' che l'un con l'altro fa, se ben s'accoppia principio e fine con la mente fissa. E come l'un pensier de l'altro scoppia, cosi` nacque di quello un altro poi, che la prima paura mi fe' doppia. Io pensava cosi`: 'Questi per noi sono scherniti con danno e con beffa si` fatta, ch'assai credo che lor noi. Se l'ira sovra 'l mal voler s'aggueffa, ei ne verranno dietro piu` crudeli che 'l cane a quella lievre ch'elli acceffa'. Gia` mi sentia tutti arricciar li peli de la paura e stava in dietro intento, quand'io dissi: <>. E quei: <>. Gia` non compie' di tal consiglio rendere, ch'io li vidi venir con l'ali tese non molto lungi, per volerne prendere. Lo duca mio di subito mi prese, come la madre ch'al romore e` desta e vede presso a se' le fiamme accese, che prende il figlio e fugge e non s'arresta, avendo piu` di lui che di se' cura, tanto che solo una camiscia vesta; e giu` dal collo de la ripa dura supin si diede a la pendente roccia, che l'un de' lati a l'altra bolgia tura. Non corse mai si` tosto acqua per doccia a volger ruota di molin terragno, quand'ella piu` verso le pale approccia, come 'l maestro mio per quel vivagno, portandosene me sovra 'l suo petto, come suo figlio, non come compagno. A pena fuoro i pie` suoi giunti al letto del fondo giu`, ch'e' furon in sul colle sovresso noi; ma non li` era sospetto; che' l'alta provedenza che lor volle porre ministri de la fossa quinta, poder di partirs'indi a tutti tolle. La` giu` trovammo una gente dipinta che giva intorno assai con lenti passi, piangendo e nel sembiante stanca e vinta. Elli avean cappe con cappucci bassi dinanzi a li occhi, fatte de la taglia che in Clugni` per li monaci fassi. Di fuor dorate son, si` ch'elli abbaglia; ma dentro tutte piombo, e gravi tanto, che Federigo le mettea di paglia. Oh in etterno faticoso manto! Noi ci volgemmo ancor pur a man manca con loro insieme, intenti al tristo pianto; ma per lo peso quella gente stanca venia si` pian, che noi eravam nuovi di compagnia ad ogne mover d'anca. Per ch'io al duca mio: <>. E un che 'ntese la parola tosca, di retro a noi grido`: <>. Onde 'l duca si volse e disse: <>. Ristetti, e vidi due mostrar gran fretta de l'animo, col viso, d'esser meco; ma tardavali 'l carco e la via stretta. Quando fuor giunti, assai con l'occhio bieco mi rimiraron sanza far parola; poi si volsero in se', e dicean seco: <>. Poi disser me: <>. E io a loro: <>. E l'un rispuose a me: <>. Io cominciai: <>; ma piu` non dissi, ch'a l'occhio mi corse un, crucifisso in terra con tre pali. Quando mi vide, tutto si distorse, soffiando ne la barba con sospiri; e 'l frate Catalan, ch'a cio` s'accorse, mi disse: <>. Allor vid'io maravigliar Virgilio sovra colui ch'era disteso in croce tanto vilmente ne l'etterno essilio. Poscia drizzo` al frate cotal voce: <>. Rispuose adunque: <>. Lo duca stette un poco a testa china; poi disse: <>. E 'l frate: <>. Appresso il duca a gran passi sen gi`, turbato un poco d'ira nel sembiante; ond'io da li 'ncarcati mi parti' dietro a le poste de le care piante. Inferno: Canto XXIV In quella parte del giovanetto anno che 'l sole i crin sotto l'Aquario tempra e gia` le notti al mezzo di` sen vanno, quando la brina in su la terra assempra l'imagine di sua sorella bianca, ma poco dura a la sua penna tempra, lo villanello a cui la roba manca, si leva, e guarda, e vede la campagna biancheggiar tutta; ond'ei si batte l'anca, ritorna in casa, e qua e la` si lagna, come 'l tapin che non sa che si faccia; poi riede, e la speranza ringavagna, veggendo 'l mondo aver cangiata faccia in poco d'ora, e prende suo vincastro, e fuor le pecorelle a pascer caccia. Cosi` mi fece sbigottir lo mastro quand'io li vidi si` turbar la fronte, e cosi` tosto al mal giunse lo 'mpiastro; che', come noi venimmo al guasto ponte, lo duca a me si volse con quel piglio dolce ch'io vidi prima a pie` del monte. Le braccia aperse, dopo alcun consiglio eletto seco riguardando prima ben la ruina, e diedemi di piglio. E come quei ch'adopera ed estima, che sempre par che 'nnanzi si proveggia, cosi`, levando me su` ver la cima d'un ronchione, avvisava un'altra scheggia dicendo: <>. Non era via da vestito di cappa, che' noi a pena, ei lieve e io sospinto, potavam su` montar di chiappa in chiappa. E se non fosse che da quel precinto piu` che da l'altro era la costa corta, non so di lui, ma io sarei ben vinto. Ma perche' Malebolge inver' la porta del bassissimo pozzo tutta pende, lo sito di ciascuna valle porta che l'una costa surge e l'altra scende; noi pur venimmo al fine in su la punta onde l'ultima pietra si scoscende. La lena m'era del polmon si` munta quand'io fui su`, ch'i' non potea piu` oltre, anzi m'assisi ne la prima giunta. <>, disse 'l maestro; <>. Leva'mi allor, mostrandomi fornito meglio di lena ch'i' non mi sentia; e dissi: <>. Su per lo scoglio prendemmo la via, ch'era ronchioso, stretto e malagevole, ed erto piu` assai che quel di pria. Parlando andava per non parer fievole; onde una voce usci` de l'altro fosso, a parole formar disconvenevole. Non so che disse, ancor che sovra 'l dosso fossi de l'arco gia` che varca quivi; ma chi parlava ad ire parea mosso. Io era volto in giu`, ma li occhi vivi non poteano ire al fondo per lo scuro; per ch'io: <>. <>, disse, <>. Noi discendemmo il ponte da la testa dove s'aggiugne con l'ottava ripa, e poi mi fu la bolgia manifesta: e vidivi entro terribile stipa di serpenti, e di si` diversa mena che la memoria il sangue ancor mi scipa. Piu` non si vanti Libia con sua rena; che' se chelidri, iaculi e faree produce, e cencri con anfisibena, ne' tante pestilenzie ne' si` ree mostro` gia` mai con tutta l'Etiopia ne' con cio` che di sopra al Mar Rosso ee. Tra questa cruda e tristissima copia correan genti nude e spaventate, sanza sperar pertugio o elitropia: con serpi le man dietro avean legate; quelle ficcavan per le ren la coda e 'l capo, ed eran dinanzi aggroppate. Ed ecco a un ch'era da nostra proda, s'avvento` un serpente che 'l trafisse la` dove 'l collo a le spalle s'annoda. Ne' O si` tosto mai ne' I si scrisse, com'el s'accese e arse, e cener tutto convenne che cascando divenisse; e poi che fu a terra si` distrutto, la polver si raccolse per se' stessa, e 'n quel medesmo ritorno` di butto. Cosi` per li gran savi si confessa che la fenice more e poi rinasce, quando al cinquecentesimo anno appressa; erba ne' biado in sua vita non pasce, ma sol d'incenso lagrime e d'amomo, e nardo e mirra son l'ultime fasce. E qual e` quel che cade, e non sa como, per forza di demon ch'a terra il tira, o d'altra oppilazion che lega l'omo, quando si leva, che 'ntorno si mira tutto smarrito de la grande angoscia ch'elli ha sofferta, e guardando sospira: tal era il peccator levato poscia. Oh potenza di Dio, quant'e` severa, che cotai colpi per vendetta croscia! Lo duca il domando` poi chi ello era; per ch'ei rispuose: <>. E io al duca: <>. E 'l peccator, che 'ntese, non s'infinse, ma drizzo` verso me l'animo e 'l volto, e di trista vergogna si dipinse; poi disse: <>. Inferno: Canto XXV Al fine de le sue parole il ladro le mani alzo` con amendue le fiche, gridando: <>. Da indi in qua mi fuor le serpi amiche, perch'una li s'avvolse allora al collo, come dicesse 'Non vo' che piu` diche'; e un'altra a le braccia, e rilegollo, ribadendo se' stessa si` dinanzi, che non potea con esse dare un crollo. Ahi Pistoia, Pistoia, che' non stanzi d'incenerarti si` che piu` non duri, poi che 'n mal fare il seme tuo avanzi? Per tutt'i cerchi de lo 'nferno scuri non vidi spirto in Dio tanto superbo, non quel che cadde a Tebe giu` da' muri. El si fuggi` che non parlo` piu` verbo; e io vidi un centauro pien di rabbia venir chiamando: <>. Maremma non cred'io che tante n'abbia, quante bisce elli avea su per la groppa infin ove comincia nostra labbia. Sovra le spalle, dietro da la coppa, con l'ali aperte li giacea un draco; e quello affuoca qualunque s'intoppa. Lo mio maestro disse: <>. Mentre che si` parlava, ed el trascorse e tre spiriti venner sotto noi, de' quali ne' io ne' 'l duca mio s'accorse, se non quando gridar: <>; per che nostra novella si ristette, e intendemmo pur ad essi poi. Io non li conoscea; ma ei seguette, come suol seguitar per alcun caso, che l'un nomar un altro convenette, dicendo: <>; per ch'io, accio` che 'l duca stesse attento, mi puosi 'l dito su dal mento al naso. Se tu se' or, lettore, a creder lento cio` ch'io diro`, non sara` maraviglia, che' io che 'l vidi, a pena il mi consento. Com'io tenea levate in lor le ciglia, e un serpente con sei pie` si lancia dinanzi a l'uno, e tutto a lui s'appiglia. Co' pie` di mezzo li avvinse la pancia, e con li anterior le braccia prese; poi li addento` e l'una e l'altra guancia; li diretani a le cosce distese, e miseli la coda tra 'mbedue, e dietro per le ren su` la ritese. Ellera abbarbicata mai non fue ad alber si`, come l'orribil fiera per l'altrui membra avviticchio` le sue. Poi s'appiccar, come di calda cera fossero stati, e mischiar lor colore, ne' l'un ne' l'altro gia` parea quel ch'era: come procede innanzi da l'ardore, per lo papiro suso, un color bruno che non e` nero ancora e 'l bianco more. Li altri due 'l riguardavano, e ciascuno gridava: <>. Gia` eran li due capi un divenuti, quando n'apparver due figure miste in una faccia, ov'eran due perduti. Fersi le braccia due di quattro liste; le cosce con le gambe e 'l ventre e 'l casso divenner membra che non fuor mai viste. Ogne primaio aspetto ivi era casso: due e nessun l'imagine perversa parea; e tal sen gio con lento passo. Come 'l ramarro sotto la gran fersa dei di` canicular, cangiando sepe, folgore par se la via attraversa, si` pareva, venendo verso l'epe de li altri due, un serpentello acceso, livido e nero come gran di pepe; e quella parte onde prima e` preso nostro alimento, a l'un di lor trafisse; poi cadde giuso innanzi lui disteso. Lo trafitto 'l miro`, ma nulla disse; anzi, co' pie` fermati, sbadigliava pur come sonno o febbre l'assalisse. Elli 'l serpente, e quei lui riguardava; l'un per la piaga, e l'altro per la bocca fummavan forte, e 'l fummo si scontrava. Taccia Lucano ormai la` dove tocca del misero Sabello e di Nasidio, e attenda a udir quel ch'or si scocca. Taccia di Cadmo e d'Aretusa Ovidio; che' se quello in serpente e quella in fonte converte poetando, io non lo 'nvidio; che' due nature mai a fronte a fronte non trasmuto` si` ch'amendue le forme a cambiar lor matera fosser pronte. Insieme si rispuosero a tai norme, che 'l serpente la coda in forca fesse, e il feruto ristrinse insieme l'orme. Le gambe con le cosce seco stesse s'appiccar si`, che 'n poco la giuntura non facea segno alcun che si paresse. Togliea la coda fessa la figura che si perdeva la`, e la sua pelle si facea molle, e quella di la` dura. Io vidi intrar le braccia per l'ascelle, e i due pie` de la fiera, ch'eran corti, tanto allungar quanto accorciavan quelle. Poscia li pie` di retro, insieme attorti, diventaron lo membro che l'uom cela, e 'l misero del suo n'avea due porti. Mentre che 'l fummo l'uno e l'altro vela di color novo, e genera 'l pel suso per l'una parte e da l'altra il dipela, l'un si levo` e l'altro cadde giuso, non torcendo pero` le lucerne empie, sotto le quai ciascun cambiava muso. Quel ch'era dritto, il trasse ver' le tempie, e di troppa matera ch'in la` venne uscir li orecchi de le gote scempie; cio` che non corse in dietro e si ritenne di quel soverchio, fe' naso a la faccia e le labbra ingrosso` quanto convenne. Quel che giacea, il muso innanzi caccia, e li orecchi ritira per la testa come face le corna la lumaccia; e la lingua, ch'avea unita e presta prima a parlar, si fende, e la forcuta ne l'altro si richiude; e 'l fummo resta. L'anima ch'era fiera divenuta, suffolando si fugge per la valle, e l'altro dietro a lui parlando sputa. Poscia li volse le novelle spalle, e disse a l'altro: <>. Cosi` vid'io la settima zavorra mutare e trasmutare; e qui mi scusi la novita` se fior la penna abborra. E avvegna che li occhi miei confusi fossero alquanto e l'animo smagato, non poter quei fuggirsi tanto chiusi, ch'i' non scorgessi ben Puccio Sciancato; ed era quel che sol, di tre compagni che venner prima, non era mutato; l'altr'era quel che tu, Gaville, piagni. Inferno: Canto XXVI Godi, Fiorenza, poi che se' si` grande, che per mare e per terra batti l'ali, e per lo 'nferno tuo nome si spande! Tra li ladron trovai cinque cotali tuoi cittadini onde mi ven vergogna, e tu in grande orranza non ne sali. Ma se presso al mattin del ver si sogna, tu sentirai di qua da picciol tempo di quel che Prato, non ch'altri, t'agogna. E se gia` fosse, non saria per tempo. Cosi` foss'ei, da che pur esser dee! che' piu` mi gravera`, com'piu` m'attempo. Noi ci partimmo, e su per le scalee che n'avea fatto iborni a scender pria, rimonto` 'l duca mio e trasse mee; e proseguendo la solinga via, tra le schegge e tra ' rocchi de lo scoglio lo pie` sanza la man non si spedia. Allor mi dolsi, e ora mi ridoglio quando drizzo la mente a cio` ch'io vidi, e piu` lo 'ngegno affreno ch'i' non soglio, perche' non corra che virtu` nol guidi; si` che, se stella bona o miglior cosa m'ha dato 'l ben, ch'io stessi nol m'invidi. Quante 'l villan ch'al poggio si riposa, nel tempo che colui che 'l mondo schiara la faccia sua a noi tien meno ascosa, come la mosca cede alla zanzara, vede lucciole giu` per la vallea, forse cola` dov'e' vendemmia e ara: di tante fiamme tutta risplendea l'ottava bolgia, si` com'io m'accorsi tosto che fui la` 've 'l fondo parea. E qual colui che si vengio` con li orsi vide 'l carro d'Elia al dipartire, quando i cavalli al cielo erti levorsi, che nol potea si` con li occhi seguire, ch'el vedesse altro che la fiamma sola, si` come nuvoletta, in su` salire: tal si move ciascuna per la gola del fosso, che' nessuna mostra 'l furto, e ogne fiamma un peccatore invola. Io stava sovra 'l ponte a veder surto, si` che s'io non avessi un ronchion preso, caduto sarei giu` sanz'esser urto. E 'l duca che mi vide tanto atteso, disse: <>. <>, rispuos'io, <>. Rispuose a me: <>. <>, diss'io, <>. Ed elli a me: <>. Poi che la fiamma fu venuta quivi dove parve al mio duca tempo e loco, in questa forma lui parlare audivi: <>. Lo maggior corno de la fiamma antica comincio` a crollarsi mormorando pur come quella cui vento affatica; indi la cima qua e la` menando, come fosse la lingua che parlasse, gitto` voce di fuori, e disse: <>. Inferno: Canto XXVII Gia` era dritta in su` la fiamma e queta per non dir piu`, e gia` da noi sen gia con la licenza del dolce poeta, quand'un'altra, che dietro a lei venia, ne fece volger li occhi a la sua cima per un confuso suon che fuor n'uscia. Come 'l bue cicilian che mugghio` prima col pianto di colui, e cio` fu dritto, che l'avea temperato con sua lima, mugghiava con la voce de l'afflitto, si` che, con tutto che fosse di rame, pur el pareva dal dolor trafitto; cosi`, per non aver via ne' forame dal principio nel foco, in suo linguaggio si convertian le parole grame. Ma poscia ch'ebber colto lor viaggio su per la punta, dandole quel guizzo che dato avea la lingua in lor passaggio, udimmo dire: <>. Io era in giuso ancora attento e chino, quando il mio duca mi tento` di costa, dicendo: <>. E io, ch'avea gia` pronta la risposta, sanza indugio a parlare incominciai: <>. Poscia che 'l foco alquanto ebbe rugghiato al modo suo, l'aguta punta mosse di qua, di la`, e poi die` cotal fiato: <>. Quand'elli ebbe 'l suo dir cosi` compiuto, la fiamma dolorando si partio, torcendo e dibattendo 'l corno aguto. Noi passamm'oltre, e io e 'l duca mio, su per lo scoglio infino in su l'altr'arco che cuopre 'l fosso in che si paga il fio a quei che scommettendo acquistan carco. Inferno: Canto XXVIII Chi poria mai pur con parole sciolte dicer del sangue e de le piaghe a pieno ch'i' ora vidi, per narrar piu` volte? Ogne lingua per certo verria meno per lo nostro sermone e per la mente c'hanno a tanto comprender poco seno. S'el s'aunasse ancor tutta la gente che gia` in su la fortunata terra di Puglia, fu del suo sangue dolente per li Troiani e per la lunga guerra che de l'anella fe' si` alte spoglie, come Livio scrive, che non erra, con quella che sentio di colpi doglie per contastare a Ruberto Guiscardo; e l'altra il cui ossame ancor s'accoglie a Ceperan, la` dove fu bugiardo ciascun Pugliese, e la` da Tagliacozzo, dove sanz'arme vinse il vecchio Alardo; e qual forato suo membro e qual mozzo mostrasse, d'aequar sarebbe nulla il modo de la nona bolgia sozzo. Gia` veggia, per mezzul perdere o lulla, com'io vidi un, cosi` non si pertugia, rotto dal mento infin dove si trulla. Tra le gambe pendevan le minugia; la corata pareva e 'l tristo sacco che merda fa di quel che si trangugia. Mentre che tutto in lui veder m'attacco, guardommi, e con le man s'aperse il petto, dicendo: <>. <>, rispuose 'l mio maestro <>. Piu` fuor di cento che, quando l'udiro, s'arrestaron nel fosso a riguardarmi per maraviglia obliando il martiro. <>. Poi che l'un pie` per girsene sospese, Maometto mi disse esta parola; indi a partirsi in terra lo distese. Un altro, che forata avea la gola e tronco 'l naso infin sotto le ciglia, e non avea mai ch'una orecchia sola, ristato a riguardar per maraviglia con li altri, innanzi a li altri apri` la canna, ch'era di fuor d'ogni parte vermiglia, e disse: <>. E io a lui: <>. Allor puose la mano a la mascella d'un suo compagno e la bocca li aperse, gridando: <>. Oh quanto mi pareva sbigottito con la lingua tagliata ne la strozza Curio, ch'a dir fu cosi` ardito! E un ch'avea l'una e l'altra man mozza, levando i moncherin per l'aura fosca, si` che 'l sangue facea la faccia sozza, grido`: <>. E io li aggiunsi: <>; per ch'elli, accumulando duol con duolo, sen gio come persona trista e matta. Ma io rimasi a riguardar lo stuolo, e vidi cosa, ch'io avrei paura, sanza piu` prova, di contarla solo; se non che coscienza m'assicura, la buona compagnia che l'uom francheggia sotto l'asbergo del sentirsi pura. Io vidi certo, e ancor par ch'io 'l veggia, un busto sanza capo andar si` come andavan li altri de la trista greggia; e 'l capo tronco tenea per le chiome, pesol con mano a guisa di lanterna; e quel mirava noi e dicea: <>. Di se' facea a se' stesso lucerna, ed eran due in uno e uno in due: com'esser puo`, quei sa che si` governa. Quando diritto al pie` del ponte fue, levo` 'l braccio alto con tutta la testa, per appressarne le parole sue, che fuoro: <>. Inferno: Canto XXIX La molta gente e le diverse piaghe avean le luci mie si` inebriate, che de lo stare a piangere eran vaghe. Ma Virgilio mi disse: <>. <>, rispuos'io appresso, <>. Parte sen giva, e io retro li andava, lo duca, gia` faccendo la risposta, e soggiugnendo: <>. Allor disse 'l maestro: <>. <>, diss'io, <>. Cosi` parlammo infino al loco primo che de lo scoglio l'altra valle mostra, se piu` lume vi fosse, tutto ad imo. Quando noi fummo sor l'ultima chiostra di Malebolge, si` che i suoi conversi potean parere a la veduta nostra, lamenti saettaron me diversi, che di pieta` ferrati avean li strali; ond'io li orecchi con le man copersi. Qual dolor fora, se de li spedali, di Valdichiana tra 'l luglio e 'l settembre e di Maremma e di Sardigna i mali fossero in una fossa tutti 'nsembre, tal era quivi, e tal puzzo n'usciva qual suol venir de le marcite membre. Noi discendemmo in su l'ultima riva del lungo scoglio, pur da man sinistra; e allor fu la mia vista piu` viva giu` ver lo fondo, la 've la ministra de l'alto Sire infallibil giustizia punisce i falsador che qui registra. Non credo ch'a veder maggior tristizia fosse in Egina il popol tutto infermo, quando fu l'aere si` pien di malizia, che li animali, infino al picciol vermo, cascaron tutti, e poi le genti antiche, secondo che i poeti hanno per fermo, si ristorar di seme di formiche; ch'era a veder per quella oscura valle languir li spirti per diverse biche. Qual sovra 'l ventre, e qual sovra le spalle l'un de l'altro giacea, e qual carpone si trasmutava per lo tristo calle. Passo passo andavam sanza sermone, guardando e ascoltando li ammalati, che non potean levar le lor persone. Io vidi due sedere a se' poggiati, com'a scaldar si poggia tegghia a tegghia, dal capo al pie` di schianze macolati; e non vidi gia` mai menare stregghia a ragazzo aspettato dal segnorso, ne' a colui che mal volontier vegghia, come ciascun menava spesso il morso de l'unghie sopra se' per la gran rabbia del pizzicor, che non ha piu` soccorso; e si` traevan giu` l'unghie la scabbia, come coltel di scardova le scaglie o d'altro pesce che piu` larghe l'abbia. <>, comincio` 'l duca mio a l'un di loro, <>. <>, rispuose l'un piangendo; <>. E 'l duca disse: <>. Allor si ruppe lo comun rincalzo; e tremando ciascuno a me si volse con altri che l'udiron di rimbalzo. Lo buon maestro a me tutto s'accolse, dicendo: <>; e io incominciai, poscia ch'ei volse: <>. <>, rispuose l'un, <>. E io dissi al poeta: <>. Onde l'altro lebbroso, che m'intese, rispuose al detto mio: <>. Inferno: Canto XXX Nel tempo che Iunone era crucciata per Semele` contra 'l sangue tebano, come mostro` una e altra fiata, Atamante divenne tanto insano, che veggendo la moglie con due figli andar carcata da ciascuna mano, grido`: <>; e poi distese i dispietati artigli, prendendo l'un ch'avea nome Learco, e rotollo e percosselo ad un sasso; e quella s'annego` con l'altro carco. E quando la fortuna volse in basso l'altezza de' Troian che tutto ardiva, si` che 'nsieme col regno il re fu casso, Ecuba trista, misera e cattiva, poscia che vide Polissena morta, e del suo Polidoro in su la riva del mar si fu la dolorosa accorta, forsennata latro` si` come cane; tanto il dolor le fe' la mente torta. Ma ne' di Tebe furie ne' troiane si vider mai in alcun tanto crude, non punger bestie, nonche' membra umane, quant'io vidi in due ombre smorte e nude, che mordendo correvan di quel modo che 'l porco quando del porcil si schiude. L'una giunse a Capocchio, e in sul nodo del collo l'assanno`, si` che, tirando, grattar li fece il ventre al fondo sodo. E l'Aretin che rimase, tremando mi disse: <>. <>, diss'io lui, <>. Ed elli a me: <>. E poi che i due rabbiosi fuor passati sovra cu' io avea l'occhio tenuto, rivolsilo a guardar li altri mal nati. Io vidi un, fatto a guisa di leuto, pur ch'elli avesse avuta l'anguinaia tronca da l'altro che l'uomo ha forcuto. La grave idropesi`, che si` dispaia le membra con l'omor che mal converte, che 'l viso non risponde a la ventraia, facea lui tener le labbra aperte come l'etico fa, che per la sete l'un verso 'l mento e l'altro in su` rinverte. <>, diss'elli a noi, <>. E io a lui: <>. <>, rispuose, <>. E l'un di lor, che si reco` a noia forse d'esser nomato si` oscuro, col pugno li percosse l'epa croia. Quella sono` come fosse un tamburo; e mastro Adamo li percosse il volto col braccio suo, che non parve men duro, dicendo a lui: <>. Ond'ei rispuose: <>. E l'idropico: <>. <>, disse Sinon; <>. <>, rispuose quel ch'avea infiata l'epa; <>. <>, disse 'l Greco, <>. Allora il monetier: <>. Ad ascoltarli er'io del tutto fisso, quando 'l maestro mi disse: <>. Quand'io 'l senti' a me parlar con ira, volsimi verso lui con tal vergogna, ch'ancor per la memoria mi si gira. Qual e` colui che suo dannaggio sogna, che sognando desidera sognare, si` che quel ch'e`, come non fosse, agogna, tal mi fec'io, non possendo parlare, che disiava scusarmi, e scusava me tuttavia, e nol mi credea fare. <>, disse 'l maestro, <>. Inferno: Canto XXXI Una medesma lingua pria mi morse, si` che mi tinse l'una e l'altra guancia, e poi la medicina mi riporse; cosi` od'io che solea far la lancia d'Achille e del suo padre esser cagione prima di trista e poi di buona mancia. Noi demmo il dosso al misero vallone su per la ripa che 'l cinge dintorno, attraversando sanza alcun sermone. Quiv'era men che notte e men che giorno, si` che 'l viso m'andava innanzi poco; ma io senti' sonare un alto corno, tanto ch'avrebbe ogne tuon fatto fioco, che, contra se' la sua via seguitando, dirizzo` li occhi miei tutti ad un loco. Dopo la dolorosa rotta, quando Carlo Magno perde' la santa gesta, non sono` si` terribilmente Orlando. Poco portai in la` volta la testa, che me parve veder molte alte torri; ond'io: <>. Ed elli a me: <>. Poi caramente mi prese per mano, e disse: <>. Come quando la nebbia si dissipa, lo sguardo a poco a poco raffigura cio` che cela 'l vapor che l'aere stipa, cosi` forando l'aura grossa e scura, piu` e piu` appressando ver' la sponda, fuggiemi errore e cresciemi paura; pero` che come su la cerchia tonda Montereggion di torri si corona, cosi` la proda che 'l pozzo circonda torreggiavan di mezza la persona li orribili giganti, cui minaccia Giove del cielo ancora quando tuona. E io scorgeva gia` d'alcun la faccia, le spalle e 'l petto e del ventre gran parte, e per le coste giu` ambo le braccia. Natura certo, quando lascio` l'arte di si` fatti animali, assai fe' bene per torre tali essecutori a Marte. E s'ella d'elefanti e di balene non si pente, chi guarda sottilmente, piu` giusta e piu` discreta la ne tene; che' dove l'argomento de la mente s'aggiugne al mal volere e a la possa, nessun riparo vi puo` far la gente. La faccia sua mi parea lunga e grossa come la pina di San Pietro a Roma, e a sua proporzione eran l'altre ossa; si` che la ripa, ch'era perizoma dal mezzo in giu`, ne mostrava ben tanto di sovra, che di giugnere a la chioma tre Frison s'averien dato mal vanto; pero` ch'i' ne vedea trenta gran palmi dal loco in giu` dov'omo affibbia 'l manto. <>, comincio` a gridar la fiera bocca, cui non si convenia piu` dolci salmi. E 'l duca mio ver lui: <>. Poi disse a me: <>. Facemmo adunque piu` lungo viaggio, volti a sinistra; e al trar d'un balestro, trovammo l'altro assai piu` fero e maggio. A cigner lui qual che fosse 'l maestro, non so io dir, ma el tenea soccinto dinanzi l'altro e dietro il braccio destro d'una catena che 'l tenea avvinto dal collo in giu`, si` che 'n su lo scoperto si ravvolgea infino al giro quinto. <>, disse 'l mio duca, <>. E io a lui: <>. Ond'ei rispuose: <>. Non fu tremoto gia` tanto rubesto, che scotesse una torre cosi` forte, come Fialte a scuotersi fu presto. Allor temett'io piu` che mai la morte, e non v'era mestier piu` che la dotta, s'io non avessi viste le ritorte. Noi procedemmo piu` avante allotta, e venimmo ad Anteo, che ben cinque alle, sanza la testa, uscia fuor de la grotta. <>. Cosi` disse 'l maestro; e quelli in fretta le man distese, e prese 'l duca mio, ond'Ercule senti` gia` grande stretta. Virgilio, quando prender si sentio, disse a me: <>; poi fece si` ch'un fascio era elli e io. Qual pare a riguardar la Carisenda sotto 'l chinato, quando un nuvol vada sovr'essa si`, ched ella incontro penda; tal parve Anteo a me che stava a bada di vederlo chinare, e fu tal ora ch'i' avrei voluto ir per altra strada. Ma lievemente al fondo che divora Lucifero con Giuda, ci sposo`; ne' si` chinato, li` fece dimora, e come albero in nave si levo`. Inferno: Canto XXXII S'io avessi le rime aspre e chiocce, come si converrebbe al tristo buco sovra 'l qual pontan tutte l'altre rocce, io premerei di mio concetto il suco piu` pienamente; ma perch'io non l'abbo, non sanza tema a dicer mi conduco; che' non e` impresa da pigliare a gabbo discriver fondo a tutto l'universo, ne' da lingua che chiami mamma o babbo. Ma quelle donne aiutino il mio verso ch'aiutaro Anfione a chiuder Tebe, si` che dal fatto il dir non sia diverso. Oh sovra tutte mal creata plebe che stai nel loco onde parlare e` duro, mei foste state qui pecore o zebe! Come noi fummo giu` nel pozzo scuro sotto i pie` del gigante assai piu` bassi, e io mirava ancora a l'alto muro, dicere udi'mi: <>. Per ch'io mi volsi, e vidimi davante e sotto i piedi un lago che per gelo avea di vetro e non d'acqua sembiante. Non fece al corso suo si` grosso velo di verno la Danoia in Osterlicchi, ne' Tanai la` sotto 'l freddo cielo, com'era quivi; che se Tambernicchi vi fosse su` caduto, o Pietrapana, non avria pur da l'orlo fatto cricchi. E come a gracidar si sta la rana col muso fuor de l'acqua, quando sogna di spigolar sovente la villana; livide, insin la` dove appar vergogna eran l'ombre dolenti ne la ghiaccia, mettendo i denti in nota di cicogna. Ognuna in giu` tenea volta la faccia; da bocca il freddo, e da li occhi il cor tristo tra lor testimonianza si procaccia. Quand'io m'ebbi dintorno alquanto visto, volsimi a' piedi, e vidi due si` stretti, che 'l pel del capo avieno insieme misto. <>, diss'io, <>. E quei piegaro i colli; e poi ch'ebber li visi a me eretti, li occhi lor, ch'eran pria pur dentro molli, gocciar su per le labbra, e 'l gelo strinse le lagrime tra essi e riserrolli. Con legno legno spranga mai non cinse forte cosi`; ond'ei come due becchi cozzaro insieme, tanta ira li vinse. E un ch'avea perduti ambo li orecchi per la freddura, pur col viso in giue, disse: <>. Poscia vid'io mille visi cagnazzi fatti per freddo; onde mi vien riprezzo, e verra` sempre, de' gelati guazzi. E mentre ch'andavamo inver' lo mezzo al quale ogne gravezza si rauna, e io tremava ne l'etterno rezzo; se voler fu o destino o fortuna, non so; ma, passeggiando tra le teste, forte percossi 'l pie` nel viso ad una. Piangendo mi sgrido`: <>. E io: <>. Lo duca stette, e io dissi a colui che bestemmiava duramente ancora: <>. <>, rispuose, <>. <>, fu mia risposta, <>. Ed elli a me: <>. Allor lo presi per la cuticagna, e dissi: <>. Ond'elli a me: <>. Io avea gia` i capelli in mano avvolti, e tratto glien'avea piu` d'una ciocca, latrando lui con li occhi in giu` raccolti, quando un altro grido`: <>. <>, diss'io, <>. <>, rispuose, <>. Noi eravam partiti gia` da ello, ch'io vidi due ghiacciati in una buca, si` che l'un capo a l'altro era cappello; e come 'l pan per fame si manduca, cosi` 'l sovran li denti a l'altro pose la` 've 'l cervel s'aggiugne con la nuca: non altrimenti Tideo si rose le tempie a Menalippo per disdegno, che quei faceva il teschio e l'altre cose. <>, diss'io, <>. Inferno: Canto XXXIII La bocca sollevo` dal fiero pasto quel peccator, forbendola a'capelli del capo ch'elli avea di retro guasto. Poi comincio`: <>. Quand'ebbe detto cio`, con li occhi torti riprese 'l teschio misero co'denti, che furo a l'osso, come d'un can, forti. Ahi Pisa, vituperio de le genti del bel paese la` dove 'l si` suona, poi che i vicini a te punir son lenti, muovasi la Capraia e la Gorgona, e faccian siepe ad Arno in su la foce, si` ch'elli annieghi in te ogne persona! Che' se 'l conte Ugolino aveva voce d'aver tradita te de le castella, non dovei tu i figliuoi porre a tal croce. Innocenti facea l'eta` novella, novella Tebe, Uguiccione e 'l Brigata e li altri due che 'l canto suso appella. Noi passammo oltre, la` 've la gelata ruvidamente un'altra gente fascia, non volta in giu`, ma tutta riversata. Lo pianto stesso li` pianger non lascia, e 'l duol che truova in su li occhi rintoppo, si volge in entro a far crescer l'ambascia; che' le lagrime prime fanno groppo, e si` come visiere di cristallo, riempion sotto 'l ciglio tutto il coppo. E avvegna che, si` come d'un callo, per la freddura ciascun sentimento cessato avesse del mio viso stallo, gia` mi parea sentire alquanto vento: per ch'io: <>. Ond'elli a me: <>. E un de' tristi de la fredda crosta grido` a noi: <>. Per ch'io a lui: <>. Rispuose adunque: <>. <>, diss'io lui, <>. Ed elli a me: <>. <>, diss'io lui, <>. <>, diss'el, <>. E io non gliel'apersi; e cortesia fu lui esser villano. Ahi Genovesi, uomini diversi d'ogne costume e pien d'ogne magagna, perche' non siete voi del mondo spersi? Che' col peggiore spirto di Romagna trovai di voi un tal, che per sua opra in anima in Cocito gia` si bagna, e in corpo par vivo ancor di sopra. Inferno: Canto XXXIV <>, disse 'l maestro mio <>. Come quando una grossa nebbia spira, o quando l'emisperio nostro annotta, par di lungi un molin che 'l vento gira, veder mi parve un tal dificio allotta; poi per lo vento mi ristrinsi retro al duca mio; che' non li` era altra grotta. Gia` era, e con paura il metto in metro, la` dove l'ombre tutte eran coperte, e trasparien come festuca in vetro. Altre sono a giacere; altre stanno erte, quella col capo e quella con le piante; altra, com'arco, il volto a' pie` rinverte. Quando noi fummo fatti tanto avante, ch'al mio maestro piacque di mostrarmi la creatura ch'ebbe il bel sembiante, d'innanzi mi si tolse e fe' restarmi, <>, dicendo, <>. Com'io divenni allor gelato e fioco, nol dimandar, lettor, ch'i' non lo scrivo, pero` ch'ogne parlar sarebbe poco. Io non mori' e non rimasi vivo: pensa oggimai per te, s'hai fior d'ingegno, qual io divenni, d'uno e d'altro privo. Lo 'mperador del doloroso regno da mezzo 'l petto uscia fuor de la ghiaccia; e piu` con un gigante io mi convegno, che i giganti non fan con le sue braccia: vedi oggimai quant'esser dee quel tutto ch'a cosi` fatta parte si confaccia. S'el fu si` bel com'elli e` ora brutto, e contra 'l suo fattore alzo` le ciglia, ben dee da lui proceder ogne lutto. Oh quanto parve a me gran maraviglia quand'io vidi tre facce a la sua testa! L'una dinanzi, e quella era vermiglia; l'altr'eran due, che s'aggiugnieno a questa sovresso 'l mezzo di ciascuna spalla, e se' giugnieno al loco de la cresta: e la destra parea tra bianca e gialla; la sinistra a vedere era tal, quali vegnon di la` onde 'l Nilo s'avvalla. Sotto ciascuna uscivan due grand'ali, quanto si convenia a tanto uccello: vele di mar non vid'io mai cotali. Non avean penne, ma di vispistrello era lor modo; e quelle svolazzava, si` che tre venti si movean da ello: quindi Cocito tutto s'aggelava. Con sei occhi piangea, e per tre menti gocciava 'l pianto e sanguinosa bava. Da ogne bocca dirompea co' denti un peccatore, a guisa di maciulla, si` che tre ne facea cosi` dolenti. A quel dinanzi il mordere era nulla verso 'l graffiar, che talvolta la schiena rimanea de la pelle tutta brulla. <>, disse 'l maestro, <>. Com'a lui piacque, il collo li avvinghiai; ed el prese di tempo e loco poste, e quando l'ali fuoro aperte assai, appiglio` se' a le vellute coste; di vello in vello giu` discese poscia tra 'l folto pelo e le gelate croste. Quando noi fummo la` dove la coscia si volge, a punto in sul grosso de l'anche, lo duca, con fatica e con angoscia, volse la testa ov'elli avea le zanche, e aggrappossi al pel com'om che sale, si` che 'n inferno i' credea tornar anche. <>, disse 'l maestro, ansando com'uom lasso, <>. Poi usci` fuor per lo foro d'un sasso, e puose me in su l'orlo a sedere; appresso porse a me l'accorto passo. Io levai li occhi e credetti vedere Lucifero com'io l'avea lasciato, e vidili le gambe in su` tenere; e s'io divenni allora travagliato, la gente grossa il pensi, che non vede qual e` quel punto ch'io avea passato. <>, disse 'l maestro, <>. Non era camminata di palagio la` 'v'eravam, ma natural burella ch'avea mal suolo e di lume disagio. <>, diss'io quando fui dritto, <>. Ed elli a me: <>. Luogo e` la` giu` da Belzebu` remoto tanto quanto la tomba si distende, che non per vista, ma per suono e` noto d'un ruscelletto che quivi discende per la buca d'un sasso, ch'elli ha roso, col corso ch'elli avvolge, e poco pende. Lo duca e io per quel cammino ascoso intrammo a ritornar nel chiaro mondo; e sanza cura aver d'alcun riposo, salimmo su`, el primo e io secondo, tanto ch'i' vidi de le cose belle che porta 'l ciel, per un pertugio tondo. E quindi uscimmo a riveder le stelle. PK ³$,AÌí¢ú? ? rcu.h/* * Read-Copy Update definitions shared among RCU implementations. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Copyright IBM Corporation, 2011 * * Author: Paul E. McKenney */ #ifndef __LINUX_RCU_H #define __LINUX_RCU_H #ifdef CONFIG_RCU_TRACE #define RCU_TRACE(stmt) stmt #else /* #ifdef CONFIG_RCU_TRACE */ #define RCU_TRACE(stmt) #endif /* #else #ifdef CONFIG_RCU_TRACE */ /* * debug_rcu_head_queue()/debug_rcu_head_unqueue() are used internally * by call_rcu() and rcu callback execution, and are therefore not part of the * RCU API. Leaving in rcupdate.h because they are used by all RCU flavors. */ #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD # define STATE_RCU_HEAD_READY 0 # define STATE_RCU_HEAD_QUEUED 1 extern struct debug_obj_descr rcuhead_debug_descr; static inline void debug_rcu_head_queue(struct rcu_head *head) { WARN_ON_ONCE((unsigned long)head & 0x3); debug_object_activate(head, &rcuhead_debug_descr); debug_object_active_state(head, &rcuhead_debug_descr, STATE_RCU_HEAD_READY, STATE_RCU_HEAD_QUEUED); } static inline void debug_rcu_head_unqueue(struct rcu_head *head) { debug_object_active_state(head, &rcuhead_debug_descr, STATE_RCU_HEAD_QUEUED, STATE_RCU_HEAD_READY); debug_object_deactivate(head, &rcuhead_debug_descr); } #else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */ static inline void debug_rcu_head_queue(struct rcu_head *head) { } static inline void debug_rcu_head_unqueue(struct rcu_head *head) { } #endif /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */ extern void kfree(const void *); static inline void __rcu_reclaim(char *rn, struct rcu_head *head) { unsigned long offset = (unsigned long)head->func; if (__is_kfree_rcu_offset(offset)) { RCU_TRACE(trace_rcu_invoke_kfree_callback(rn, head, offset)); kfree((void *)head - offset); } else { RCU_TRACE(trace_rcu_invoke_callback(rn, head)); head->func(head); } } #endif /* __LINUX_RCU_H */ PK ³$,AÓ•³åžž sched_fair.c/* * Completely Fair Scheduling (CFS) Class (SCHED_NORMAL/SCHED_BATCH) * * Copyright (C) 2007 Red Hat, Inc., Ingo Molnar * * Interactivity improvements by Mike Galbraith * (C) 2007 Mike Galbraith * * Various enhancements by Dmitry Adamushko. * (C) 2007 Dmitry Adamushko * * Group scheduling enhancements by Srivatsa Vaddagiri * Copyright IBM Corporation, 2007 * Author: Srivatsa Vaddagiri * * Scaled math optimizations by Thomas Gleixner * Copyright (C) 2007, Thomas Gleixner * * Adaptive scheduling granularity, math enhancements by Peter Zijlstra * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra */ #include #include #include /* * Targeted preemption latency for CPU-bound tasks: * (default: 6ms * (1 + ilog(ncpus)), units: nanoseconds) * * NOTE: this latency value is not the same as the concept of * 'timeslice length' - timeslices in CFS are of variable length * and have no persistent notion like in traditional, time-slice * based scheduling concepts. * * (to see the precise effective timeslice length of your workload, * run vmstat and monitor the context-switches (cs) field) */ unsigned int sysctl_sched_latency = 6000000ULL; unsigned int normalized_sysctl_sched_latency = 6000000ULL; /* * The initial- and re-scaling of tunables is configurable * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus)) * * Options are: * SCHED_TUNABLESCALING_NONE - unscaled, always *1 * SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus) * SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus */ enum sched_tunable_scaling sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG; /* * Minimal preemption granularity for CPU-bound tasks: * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) */ unsigned int sysctl_sched_min_granularity = 750000ULL; unsigned int normalized_sysctl_sched_min_granularity = 750000ULL; /* * is kept at sysctl_sched_latency / sysctl_sched_min_granularity */ static unsigned int sched_nr_latency = 8; /* * After fork, child runs first. If set to 0 (default) then * parent will (try to) run first. */ unsigned int sysctl_sched_child_runs_first __read_mostly; /* * SCHED_OTHER wake-up granularity. * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds) * * This option delays the preemption effects of decoupled workloads * and reduces their over-scheduling. Synchronous workloads will still * have immediate wakeup/sleep latencies. */ unsigned int sysctl_sched_wakeup_granularity = 1000000UL; unsigned int normalized_sysctl_sched_wakeup_granularity = 1000000UL; const_debug unsigned int sysctl_sched_migration_cost = 500000UL; /* * The exponential sliding window over which load is averaged for shares * distribution. * (default: 10msec) */ unsigned int __read_mostly sysctl_sched_shares_window = 10000000UL; #ifdef CONFIG_CFS_BANDWIDTH /* * Amount of runtime to allocate from global (tg) to local (per-cfs_rq) pool * each time a cfs_rq requests quota. * * Note: in the case that the slice exceeds the runtime remaining (either due * to consumption or the quota being specified to be smaller than the slice) * we will always only issue the remaining available time. * * default: 5 msec, units: microseconds */ unsigned int sysctl_sched_cfs_bandwidth_slice = 5000UL; #endif static const struct sched_class fair_sched_class; /************************************************************** * CFS operations on generic schedulable entities: */ #ifdef CONFIG_FAIR_GROUP_SCHED /* cpu runqueue to which this cfs_rq is attached */ static inline struct rq *rq_of(struct cfs_rq *cfs_rq) { return cfs_rq->rq; } /* An entity is a task if it doesn't "own" a runqueue */ #define entity_is_task(se) (!se->my_q) static inline struct task_struct *task_of(struct sched_entity *se) { #ifdef CONFIG_SCHED_DEBUG WARN_ON_ONCE(!entity_is_task(se)); #endif return container_of(se, struct task_struct, se); } /* Walk up scheduling entities hierarchy */ #define for_each_sched_entity(se) \ for (; se; se = se->parent) static inline struct cfs_rq *task_cfs_rq(struct task_struct *p) { return p->se.cfs_rq; } /* runqueue on which this entity is (to be) queued */ static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se) { return se->cfs_rq; } /* runqueue "owned" by this group */ static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp) { return grp->my_q; } static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq) { if (!cfs_rq->on_list) { /* * Ensure we either appear before our parent (if already * enqueued) or force our parent to appear after us when it is * enqueued. The fact that we always enqueue bottom-up * reduces this to two cases. */ if (cfs_rq->tg->parent && cfs_rq->tg->parent->cfs_rq[cpu_of(rq_of(cfs_rq))]->on_list) { list_add_rcu(&cfs_rq->leaf_cfs_rq_list, &rq_of(cfs_rq)->leaf_cfs_rq_list); } else { list_add_tail_rcu(&cfs_rq->leaf_cfs_rq_list, &rq_of(cfs_rq)->leaf_cfs_rq_list); } cfs_rq->on_list = 1; } } static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq) { if (cfs_rq->on_list) { list_del_rcu(&cfs_rq->leaf_cfs_rq_list); cfs_rq->on_list = 0; } } /* Iterate thr' all leaf cfs_rq's on a runqueue */ #define for_each_leaf_cfs_rq(rq, cfs_rq) \ list_for_each_entry_rcu(cfs_rq, &rq->leaf_cfs_rq_list, leaf_cfs_rq_list) /* Do the two (enqueued) entities belong to the same group ? */ static inline int is_same_group(struct sched_entity *se, struct sched_entity *pse) { if (se->cfs_rq == pse->cfs_rq) return 1; return 0; } static inline struct sched_entity *parent_entity(struct sched_entity *se) { return se->parent; } /* return depth at which a sched entity is present in the hierarchy */ static inline int depth_se(struct sched_entity *se) { int depth = 0; for_each_sched_entity(se) depth++; return depth; } static void find_matching_se(struct sched_entity **se, struct sched_entity **pse) { int se_depth, pse_depth; /* * preemption test can be made between sibling entities who are in the * same cfs_rq i.e who have a common parent. Walk up the hierarchy of * both tasks until we find their ancestors who are siblings of common * parent. */ /* First walk up until both entities are at same depth */ se_depth = depth_se(*se); pse_depth = depth_se(*pse); while (se_depth > pse_depth) { se_depth--; *se = parent_entity(*se); } while (pse_depth > se_depth) { pse_depth--; *pse = parent_entity(*pse); } while (!is_same_group(*se, *pse)) { *se = parent_entity(*se); *pse = parent_entity(*pse); } } #else /* !CONFIG_FAIR_GROUP_SCHED */ static inline struct task_struct *task_of(struct sched_entity *se) { return container_of(se, struct task_struct, se); } static inline struct rq *rq_of(struct cfs_rq *cfs_rq) { return container_of(cfs_rq, struct rq, cfs); } #define entity_is_task(se) 1 #define for_each_sched_entity(se) \ for (; se; se = NULL) static inline struct cfs_rq *task_cfs_rq(struct task_struct *p) { return &task_rq(p)->cfs; } static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se) { struct task_struct *p = task_of(se); struct rq *rq = task_rq(p); return &rq->cfs; } /* runqueue "owned" by this group */ static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp) { return NULL; } static inline void list_add_leaf_cfs_rq(struct cfs_rq *cfs_rq) { } static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq) { } #define for_each_leaf_cfs_rq(rq, cfs_rq) \ for (cfs_rq = &rq->cfs; cfs_rq; cfs_rq = NULL) static inline int is_same_group(struct sched_entity *se, struct sched_entity *pse) { return 1; } static inline struct sched_entity *parent_entity(struct sched_entity *se) { return NULL; } static inline void find_matching_se(struct sched_entity **se, struct sched_entity **pse) { } #endif /* CONFIG_FAIR_GROUP_SCHED */ static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec); /************************************************************** * Scheduling class tree data structure manipulation methods: */ static inline u64 max_vruntime(u64 min_vruntime, u64 vruntime) { s64 delta = (s64)(vruntime - min_vruntime); if (delta > 0) min_vruntime = vruntime; return min_vruntime; } static inline u64 min_vruntime(u64 min_vruntime, u64 vruntime) { s64 delta = (s64)(vruntime - min_vruntime); if (delta < 0) min_vruntime = vruntime; return min_vruntime; } static inline int entity_before(struct sched_entity *a, struct sched_entity *b) { return (s64)(a->vruntime - b->vruntime) < 0; } static void update_min_vruntime(struct cfs_rq *cfs_rq) { u64 vruntime = cfs_rq->min_vruntime; if (cfs_rq->curr) vruntime = cfs_rq->curr->vruntime; if (cfs_rq->rb_leftmost) { struct sched_entity *se = rb_entry(cfs_rq->rb_leftmost, struct sched_entity, run_node); if (!cfs_rq->curr) vruntime = se->vruntime; else vruntime = min_vruntime(vruntime, se->vruntime); } cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime); #ifndef CONFIG_64BIT smp_wmb(); cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime; #endif } /* * Enqueue an entity into the rb-tree: */ static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) { struct rb_node **link = &cfs_rq->tasks_timeline.rb_node; struct rb_node *parent = NULL; struct sched_entity *entry; int leftmost = 1; /* * Find the right place in the rbtree: */ while (*link) { parent = *link; entry = rb_entry(parent, struct sched_entity, run_node); /* * We dont care about collisions. Nodes with * the same key stay together. */ if (entity_before(se, entry)) { link = &parent->rb_left; } else { link = &parent->rb_right; leftmost = 0; } } /* * Maintain a cache of leftmost tree entries (it is frequently * used): */ if (leftmost) cfs_rq->rb_leftmost = &se->run_node; rb_link_node(&se->run_node, parent, link); rb_insert_color(&se->run_node, &cfs_rq->tasks_timeline); } static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) { if (cfs_rq->rb_leftmost == &se->run_node) { struct rb_node *next_node; next_node = rb_next(&se->run_node); cfs_rq->rb_leftmost = next_node; } rb_erase(&se->run_node, &cfs_rq->tasks_timeline); } static struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq) { struct rb_node *left = cfs_rq->rb_leftmost; if (!left) return NULL; return rb_entry(left, struct sched_entity, run_node); } static struct sched_entity *__pick_next_entity(struct sched_entity *se) { struct rb_node *next = rb_next(&se->run_node); if (!next) return NULL; return rb_entry(next, struct sched_entity, run_node); } #ifdef CONFIG_SCHED_DEBUG static struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq) { struct rb_node *last = rb_last(&cfs_rq->tasks_timeline); if (!last) return NULL; return rb_entry(last, struct sched_entity, run_node); } /************************************************************** * Scheduling class statistics methods: */ int sched_proc_update_handler(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); int factor = get_update_sysctl_factor(); if (ret || !write) return ret; sched_nr_latency = DIV_ROUND_UP(sysctl_sched_latency, sysctl_sched_min_granularity); #define WRT_SYSCTL(name) \ (normalized_sysctl_##name = sysctl_##name / (factor)) WRT_SYSCTL(sched_min_granularity); WRT_SYSCTL(sched_latency); WRT_SYSCTL(sched_wakeup_granularity); #undef WRT_SYSCTL return 0; } #endif /* * delta /= w */ static inline unsigned long calc_delta_fair(unsigned long delta, struct sched_entity *se) { if (unlikely(se->load.weight != NICE_0_LOAD)) delta = calc_delta_mine(delta, NICE_0_LOAD, &se->load); return delta; } /* * The idea is to set a period in which each task runs once. * * When there are too many tasks (sysctl_sched_nr_latency) we have to stretch * this period because otherwise the slices get too small. * * p = (nr <= nl) ? l : l*nr/nl */ static u64 __sched_period(unsigned long nr_running) { u64 period = sysctl_sched_latency; unsigned long nr_latency = sched_nr_latency; if (unlikely(nr_running > nr_latency)) { period = sysctl_sched_min_granularity; period *= nr_running; } return period; } /* * We calculate the wall-time slice from the period by taking a part * proportional to the weight. * * s = p*P[w/rw] */ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se) { u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq); for_each_sched_entity(se) { struct load_weight *load; struct load_weight lw; cfs_rq = cfs_rq_of(se); load = &cfs_rq->load; if (unlikely(!se->on_rq)) { lw = cfs_rq->load; update_load_add(&lw, se->load.weight); load = &lw; } slice = calc_delta_mine(slice, se->load.weight, load); } return slice; } /* * We calculate the vruntime slice of a to be inserted task * * vs = s/w */ static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se) { return calc_delta_fair(sched_slice(cfs_rq, se), se); } static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update); static void update_cfs_shares(struct cfs_rq *cfs_rq); /* * Update the current task's runtime statistics. Skip current tasks that * are not in our scheduling class. */ static inline void __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr, unsigned long delta_exec) { unsigned long delta_exec_weighted; schedstat_set(curr->statistics.exec_max, max((u64)delta_exec, curr->statistics.exec_max)); curr->sum_exec_runtime += delta_exec; schedstat_add(cfs_rq, exec_clock, delta_exec); delta_exec_weighted = calc_delta_fair(delta_exec, curr); curr->vruntime += delta_exec_weighted; update_min_vruntime(cfs_rq); #if defined CONFIG_SMP && defined CONFIG_FAIR_GROUP_SCHED cfs_rq->load_unacc_exec_time += delta_exec; #endif } static void update_curr(struct cfs_rq *cfs_rq) { struct sched_entity *curr = cfs_rq->curr; u64 now = rq_of(cfs_rq)->clock_task; unsigned long delta_exec; if (unlikely(!curr)) return; /* * Get the amount of time the current task was running * since the last time we changed load (this cannot * overflow on 32 bits): */ delta_exec = (unsigned long)(now - curr->exec_start); if (!delta_exec) return; __update_curr(cfs_rq, curr, delta_exec); curr->exec_start = now; if (entity_is_task(curr)) { struct task_struct *curtask = task_of(curr); trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime); cpuacct_charge(curtask, delta_exec); account_group_exec_runtime(curtask, delta_exec); } account_cfs_rq_runtime(cfs_rq, delta_exec); } static inline void update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se) { schedstat_set(se->statistics.wait_start, rq_of(cfs_rq)->clock); } /* * Task is being enqueued - update stats: */ static void update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se) { /* * Are we enqueueing a waiting task? (for current tasks * a dequeue/enqueue event is a NOP) */ if (se != cfs_rq->curr) update_stats_wait_start(cfs_rq, se); } static void update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se) { schedstat_set(se->statistics.wait_max, max(se->statistics.wait_max, rq_of(cfs_rq)->clock - se->statistics.wait_start)); schedstat_set(se->statistics.wait_count, se->statistics.wait_count + 1); schedstat_set(se->statistics.wait_sum, se->statistics.wait_sum + rq_of(cfs_rq)->clock - se->statistics.wait_start); #ifdef CONFIG_SCHEDSTATS if (entity_is_task(se)) { trace_sched_stat_wait(task_of(se), rq_of(cfs_rq)->clock - se->statistics.wait_start); } #endif schedstat_set(se->statistics.wait_start, 0); } static inline void update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se) { /* * Mark the end of the wait period if dequeueing a * waiting task: */ if (se != cfs_rq->curr) update_stats_wait_end(cfs_rq, se); } /* * We are picking a new current task - update its stats: */ static inline void update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se) { /* * We are starting a new run period: */ se->exec_start = rq_of(cfs_rq)->clock_task; } /************************************************** * Scheduling class queueing methods: */ #if defined CONFIG_SMP && defined CONFIG_FAIR_GROUP_SCHED static void add_cfs_task_weight(struct cfs_rq *cfs_rq, unsigned long weight) { cfs_rq->task_weight += weight; } #else static inline void add_cfs_task_weight(struct cfs_rq *cfs_rq, unsigned long weight) { } #endif static void account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se) { update_load_add(&cfs_rq->load, se->load.weight); if (!parent_entity(se)) inc_cpu_load(rq_of(cfs_rq), se->load.weight); if (entity_is_task(se)) { add_cfs_task_weight(cfs_rq, se->load.weight); list_add(&se->group_node, &cfs_rq->tasks); } cfs_rq->nr_running++; } static void account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se) { update_load_sub(&cfs_rq->load, se->load.weight); if (!parent_entity(se)) dec_cpu_load(rq_of(cfs_rq), se->load.weight); if (entity_is_task(se)) { add_cfs_task_weight(cfs_rq, -se->load.weight); list_del_init(&se->group_node); } cfs_rq->nr_running--; } #ifdef CONFIG_FAIR_GROUP_SCHED /* we need this in update_cfs_load and load-balance functions below */ static inline int throttled_hierarchy(struct cfs_rq *cfs_rq); # ifdef CONFIG_SMP static void update_cfs_rq_load_contribution(struct cfs_rq *cfs_rq, int global_update) { struct task_group *tg = cfs_rq->tg; long load_avg; load_avg = div64_u64(cfs_rq->load_avg, cfs_rq->load_period+1); load_avg -= cfs_rq->load_contribution; if (global_update || abs(load_avg) > cfs_rq->load_contribution / 8) { atomic_add(load_avg, &tg->load_weight); cfs_rq->load_contribution += load_avg; } } static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update) { u64 period = sysctl_sched_shares_window; u64 now, delta; unsigned long load = cfs_rq->load.weight; if (cfs_rq->tg == &root_task_group || throttled_hierarchy(cfs_rq)) return; now = rq_of(cfs_rq)->clock_task; delta = now - cfs_rq->load_stamp; /* truncate load history at 4 idle periods */ if (cfs_rq->load_stamp > cfs_rq->load_last && now - cfs_rq->load_last > 4 * period) { cfs_rq->load_period = 0; cfs_rq->load_avg = 0; delta = period - 1; } cfs_rq->load_stamp = now; cfs_rq->load_unacc_exec_time = 0; cfs_rq->load_period += delta; if (load) { cfs_rq->load_last = now; cfs_rq->load_avg += delta * load; } /* consider updating load contribution on each fold or truncate */ if (global_update || cfs_rq->load_period > period || !cfs_rq->load_period) update_cfs_rq_load_contribution(cfs_rq, global_update); while (cfs_rq->load_period > period) { /* * Inline assembly required to prevent the compiler * optimising this loop into a divmod call. * See __iter_div_u64_rem() for another example of this. */ asm("" : "+rm" (cfs_rq->load_period)); cfs_rq->load_period /= 2; cfs_rq->load_avg /= 2; } if (!cfs_rq->curr && !cfs_rq->nr_running && !cfs_rq->load_avg) list_del_leaf_cfs_rq(cfs_rq); } static inline long calc_tg_weight(struct task_group *tg, struct cfs_rq *cfs_rq) { long tg_weight; /* * Use this CPU's actual weight instead of the last load_contribution * to gain a more accurate current total weight. See * update_cfs_rq_load_contribution(). */ tg_weight = atomic_read(&tg->load_weight); tg_weight -= cfs_rq->load_contribution; tg_weight += cfs_rq->load.weight; return tg_weight; } static long calc_cfs_shares(struct cfs_rq *cfs_rq, struct task_group *tg) { long tg_weight, load, shares; tg_weight = calc_tg_weight(tg, cfs_rq); load = cfs_rq->load.weight; shares = (tg->shares * load); if (tg_weight) shares /= tg_weight; if (shares < MIN_SHARES) shares = MIN_SHARES; if (shares > tg->shares) shares = tg->shares; return shares; } static void update_entity_shares_tick(struct cfs_rq *cfs_rq) { if (cfs_rq->load_unacc_exec_time > sysctl_sched_shares_window) { update_cfs_load(cfs_rq, 0); update_cfs_shares(cfs_rq); } } # else /* CONFIG_SMP */ static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update) { } static inline long calc_cfs_shares(struct cfs_rq *cfs_rq, struct task_group *tg) { return tg->shares; } static inline void update_entity_shares_tick(struct cfs_rq *cfs_rq) { } # endif /* CONFIG_SMP */ static void reweight_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, unsigned long weight) { if (se->on_rq) { /* commit outstanding execution time */ if (cfs_rq->curr == se) update_curr(cfs_rq); account_entity_dequeue(cfs_rq, se); } update_load_set(&se->load, weight); if (se->on_rq) account_entity_enqueue(cfs_rq, se); } static void update_cfs_shares(struct cfs_rq *cfs_rq) { struct task_group *tg; struct sched_entity *se; long shares; tg = cfs_rq->tg; se = tg->se[cpu_of(rq_of(cfs_rq))]; if (!se || throttled_hierarchy(cfs_rq)) return; #ifndef CONFIG_SMP if (likely(se->load.weight == tg->shares)) return; #endif shares = calc_cfs_shares(cfs_rq, tg); reweight_entity(cfs_rq_of(se), se, shares); } #else /* CONFIG_FAIR_GROUP_SCHED */ static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update) { } static inline void update_cfs_shares(struct cfs_rq *cfs_rq) { } static inline void update_entity_shares_tick(struct cfs_rq *cfs_rq) { } #endif /* CONFIG_FAIR_GROUP_SCHED */ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) { #ifdef CONFIG_SCHEDSTATS struct task_struct *tsk = NULL; if (entity_is_task(se)) tsk = task_of(se); if (se->statistics.sleep_start) { u64 delta = rq_of(cfs_rq)->clock - se->statistics.sleep_start; if ((s64)delta < 0) delta = 0; if (unlikely(delta > se->statistics.sleep_max)) se->statistics.sleep_max = delta; se->statistics.sleep_start = 0; se->statistics.sum_sleep_runtime += delta; if (tsk) { account_scheduler_latency(tsk, delta >> 10, 1); trace_sched_stat_sleep(tsk, delta); } } if (se->statistics.block_start) { u64 delta = rq_of(cfs_rq)->clock - se->statistics.block_start; if ((s64)delta < 0) delta = 0; if (unlikely(delta > se->statistics.block_max)) se->statistics.block_max = delta; se->statistics.block_start = 0; se->statistics.sum_sleep_runtime += delta; if (tsk) { if (tsk->in_iowait) { se->statistics.iowait_sum += delta; se->statistics.iowait_count++; trace_sched_stat_iowait(tsk, delta); } /* * Blocking time is in units of nanosecs, so shift by * 20 to get a milliseconds-range estimation of the * amount of time that the task spent sleeping: */ if (unlikely(prof_on == SLEEP_PROFILING)) { profile_hits(SLEEP_PROFILING, (void *)get_wchan(tsk), delta >> 20); } account_scheduler_latency(tsk, delta >> 10, 0); } } #endif } static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se) { #ifdef CONFIG_SCHED_DEBUG s64 d = se->vruntime - cfs_rq->min_vruntime; if (d < 0) d = -d; if (d > 3*sysctl_sched_latency) schedstat_inc(cfs_rq, nr_spread_over); #endif } static void place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial) { u64 vruntime = cfs_rq->min_vruntime; /* * The 'current' period is already promised to the current tasks, * however the extra weight of the new task will slow them down a * little, place the new task so that it fits in the slot that * stays open at the end. */ if (initial && sched_feat(START_DEBIT)) vruntime += sched_vslice(cfs_rq, se); /* sleeps up to a single latency don't count. */ if (!initial) { unsigned long thresh = sysctl_sched_latency; /* * Halve their sleep time's effect, to allow * for a gentler effect of sleepers: */ if (sched_feat(GENTLE_FAIR_SLEEPERS)) thresh >>= 1; vruntime -= thresh; } /* ensure we never gain time by being placed backwards. */ vruntime = max_vruntime(se->vruntime, vruntime); se->vruntime = vruntime; } static void check_enqueue_throttle(struct cfs_rq *cfs_rq); static void enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) { /* * Update the normalized vruntime before updating min_vruntime * through callig update_curr(). */ if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_WAKING)) se->vruntime += cfs_rq->min_vruntime; /* * Update run-time statistics of the 'current'. */ update_curr(cfs_rq); update_cfs_load(cfs_rq, 0); account_entity_enqueue(cfs_rq, se); update_cfs_shares(cfs_rq); if (flags & ENQUEUE_WAKEUP) { place_entity(cfs_rq, se, 0); enqueue_sleeper(cfs_rq, se); } update_stats_enqueue(cfs_rq, se); check_spread(cfs_rq, se); if (se != cfs_rq->curr) __enqueue_entity(cfs_rq, se); se->on_rq = 1; if (cfs_rq->nr_running == 1) { list_add_leaf_cfs_rq(cfs_rq); check_enqueue_throttle(cfs_rq); } } static void __clear_buddies_last(struct sched_entity *se) { for_each_sched_entity(se) { struct cfs_rq *cfs_rq = cfs_rq_of(se); if (cfs_rq->last == se) cfs_rq->last = NULL; else break; } } static void __clear_buddies_next(struct sched_entity *se) { for_each_sched_entity(se) { struct cfs_rq *cfs_rq = cfs_rq_of(se); if (cfs_rq->next == se) cfs_rq->next = NULL; else break; } } static void __clear_buddies_skip(struct sched_entity *se) { for_each_sched_entity(se) { struct cfs_rq *cfs_rq = cfs_rq_of(se); if (cfs_rq->skip == se) cfs_rq->skip = NULL; else break; } } static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se) { if (cfs_rq->last == se) __clear_buddies_last(se); if (cfs_rq->next == se) __clear_buddies_next(se); if (cfs_rq->skip == se) __clear_buddies_skip(se); } static void return_cfs_rq_runtime(struct cfs_rq *cfs_rq); static void dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) { /* * Update run-time statistics of the 'current'. */ update_curr(cfs_rq); update_stats_dequeue(cfs_rq, se); if (flags & DEQUEUE_SLEEP) { #ifdef CONFIG_SCHEDSTATS if (entity_is_task(se)) { struct task_struct *tsk = task_of(se); if (tsk->state & TASK_INTERRUPTIBLE) se->statistics.sleep_start = rq_of(cfs_rq)->clock; if (tsk->state & TASK_UNINTERRUPTIBLE) se->statistics.block_start = rq_of(cfs_rq)->clock; } #endif } clear_buddies(cfs_rq, se); if (se != cfs_rq->curr) __dequeue_entity(cfs_rq, se); se->on_rq = 0; update_cfs_load(cfs_rq, 0); account_entity_dequeue(cfs_rq, se); /* * Normalize the entity after updating the min_vruntime because the * update can refer to the ->curr item and we need to reflect this * movement in our normalized position. */ if (!(flags & DEQUEUE_SLEEP)) se->vruntime -= cfs_rq->min_vruntime; /* return excess runtime on last dequeue */ return_cfs_rq_runtime(cfs_rq); update_min_vruntime(cfs_rq); update_cfs_shares(cfs_rq); } /* * Preempt the current task with a newly woken task if needed: */ static void check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr) { unsigned long ideal_runtime, delta_exec; struct sched_entity *se; s64 delta; ideal_runtime = sched_slice(cfs_rq, curr); delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime; if (delta_exec > ideal_runtime) { resched_task(rq_of(cfs_rq)->curr); /* * The current task ran long enough, ensure it doesn't get * re-elected due to buddy favours. */ clear_buddies(cfs_rq, curr); return; } /* * Ensure that a task that missed wakeup preemption by a * narrow margin doesn't have to wait for a full slice. * This also mitigates buddy induced latencies under load. */ if (delta_exec < sysctl_sched_min_granularity) return; se = __pick_first_entity(cfs_rq); delta = curr->vruntime - se->vruntime; if (delta < 0) return; if (delta > ideal_runtime) resched_task(rq_of(cfs_rq)->curr); } static void set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) { /* 'current' is not kept within the tree. */ if (se->on_rq) { /* * Any task has to be enqueued before it get to execute on * a CPU. So account for the time it spent waiting on the * runqueue. */ update_stats_wait_end(cfs_rq, se); __dequeue_entity(cfs_rq, se); } update_stats_curr_start(cfs_rq, se); cfs_rq->curr = se; #ifdef CONFIG_SCHEDSTATS /* * Track our maximum slice length, if the CPU's load is at * least twice that of our own weight (i.e. dont track it * when there are only lesser-weight tasks around): */ if (rq_of(cfs_rq)->load.weight >= 2*se->load.weight) { se->statistics.slice_max = max(se->statistics.slice_max, se->sum_exec_runtime - se->prev_sum_exec_runtime); } #endif se->prev_sum_exec_runtime = se->sum_exec_runtime; } static int wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se); /* * Pick the next process, keeping these things in mind, in this order: * 1) keep things fair between processes/task groups * 2) pick the "next" process, since someone really wants that to run * 3) pick the "last" process, for cache locality * 4) do not run the "skip" process, if something else is available */ static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq) { struct sched_entity *se = __pick_first_entity(cfs_rq); struct sched_entity *left = se; /* * Avoid running the skip buddy, if running something else can * be done without getting too unfair. */ if (cfs_rq->skip == se) { struct sched_entity *second = __pick_next_entity(se); if (second && wakeup_preempt_entity(second, left) < 1) se = second; } /* * Prefer last buddy, try to return the CPU to a preempted task. */ if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1) se = cfs_rq->last; /* * Someone really wants this to run. If it's not unfair, run it. */ if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1) se = cfs_rq->next; clear_buddies(cfs_rq, se); return se; } static void check_cfs_rq_runtime(struct cfs_rq *cfs_rq); static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev) { /* * If still on the runqueue then deactivate_task() * was not called and update_curr() has to be done: */ if (prev->on_rq) update_curr(cfs_rq); /* throttle cfs_rqs exceeding runtime */ check_cfs_rq_runtime(cfs_rq); check_spread(cfs_rq, prev); if (prev->on_rq) { update_stats_wait_start(cfs_rq, prev); /* Put 'current' back into the tree. */ __enqueue_entity(cfs_rq, prev); } cfs_rq->curr = NULL; } static void entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued) { /* * Update run-time statistics of the 'current'. */ update_curr(cfs_rq); /* * Update share accounting for long-running entities. */ update_entity_shares_tick(cfs_rq); #ifdef CONFIG_SCHED_HRTICK /* * queued ticks are scheduled to match the slice, so don't bother * validating it and just reschedule. */ if (queued) { resched_task(rq_of(cfs_rq)->curr); return; } /* * don't let the period tick interfere with the hrtick preemption */ if (!sched_feat(DOUBLE_TICK) && hrtimer_active(&rq_of(cfs_rq)->hrtick_timer)) return; #endif if (cfs_rq->nr_running > 1) check_preempt_tick(cfs_rq, curr); } /************************************************** * CFS bandwidth control machinery */ #ifdef CONFIG_CFS_BANDWIDTH /* * default period for cfs group bandwidth. * default: 0.1s, units: nanoseconds */ static inline u64 default_cfs_period(void) { return 100000000ULL; } static inline u64 sched_cfs_bandwidth_slice(void) { return (u64)sysctl_sched_cfs_bandwidth_slice * NSEC_PER_USEC; } /* * Replenish runtime according to assigned quota and update expiration time. * We use sched_clock_cpu directly instead of rq->clock to avoid adding * additional synchronization around rq->lock. * * requires cfs_b->lock */ static void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth *cfs_b) { u64 now; if (cfs_b->quota == RUNTIME_INF) return; now = sched_clock_cpu(smp_processor_id()); cfs_b->runtime = cfs_b->quota; cfs_b->runtime_expires = now + ktime_to_ns(cfs_b->period); } /* returns 0 on failure to allocate runtime */ static int assign_cfs_rq_runtime(struct cfs_rq *cfs_rq) { struct task_group *tg = cfs_rq->tg; struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(tg); u64 amount = 0, min_amount, expires; /* note: this is a positive sum as runtime_remaining <= 0 */ min_amount = sched_cfs_bandwidth_slice() - cfs_rq->runtime_remaining; raw_spin_lock(&cfs_b->lock); if (cfs_b->quota == RUNTIME_INF) amount = min_amount; else { /* * If the bandwidth pool has become inactive, then at least one * period must have elapsed since the last consumption. * Refresh the global state and ensure bandwidth timer becomes * active. */ if (!cfs_b->timer_active) { __refill_cfs_bandwidth_runtime(cfs_b); __start_cfs_bandwidth(cfs_b); } if (cfs_b->runtime > 0) { amount = min(cfs_b->runtime, min_amount); cfs_b->runtime -= amount; cfs_b->idle = 0; } } expires = cfs_b->runtime_expires; raw_spin_unlock(&cfs_b->lock); cfs_rq->runtime_remaining += amount; /* * we may have advanced our local expiration to account for allowed * spread between our sched_clock and the one on which runtime was * issued. */ if ((s64)(expires - cfs_rq->runtime_expires) > 0) cfs_rq->runtime_expires = expires; return cfs_rq->runtime_remaining > 0; } /* * Note: This depends on the synchronization provided by sched_clock and the * fact that rq->clock snapshots this value. */ static void expire_cfs_rq_runtime(struct cfs_rq *cfs_rq) { struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); struct rq *rq = rq_of(cfs_rq); /* if the deadline is ahead of our clock, nothing to do */ if (likely((s64)(rq->clock - cfs_rq->runtime_expires) < 0)) return; if (cfs_rq->runtime_remaining < 0) return; /* * If the local deadline has passed we have to consider the * possibility that our sched_clock is 'fast' and the global deadline * has not truly expired. * * Fortunately we can check determine whether this the case by checking * whether the global deadline has advanced. */ if ((s64)(cfs_rq->runtime_expires - cfs_b->runtime_expires) >= 0) { /* extend local deadline, drift is bounded above by 2 ticks */ cfs_rq->runtime_expires += TICK_NSEC; } else { /* global deadline is ahead, expiration has passed */ cfs_rq->runtime_remaining = 0; } } static void __account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec) { /* dock delta_exec before expiring quota (as it could span periods) */ cfs_rq->runtime_remaining -= delta_exec; expire_cfs_rq_runtime(cfs_rq); if (likely(cfs_rq->runtime_remaining > 0)) return; /* * if we're unable to extend our runtime we resched so that the active * hierarchy can be throttled */ if (!assign_cfs_rq_runtime(cfs_rq) && likely(cfs_rq->curr)) resched_task(rq_of(cfs_rq)->curr); } static __always_inline void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec) { if (!cfs_rq->runtime_enabled) return; __account_cfs_rq_runtime(cfs_rq, delta_exec); } static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq) { return cfs_rq->throttled; } /* check whether cfs_rq, or any parent, is throttled */ static inline int throttled_hierarchy(struct cfs_rq *cfs_rq) { return cfs_rq->throttle_count; } /* * Ensure that neither of the group entities corresponding to src_cpu or * dest_cpu are members of a throttled hierarchy when performing group * load-balance operations. */ static inline int throttled_lb_pair(struct task_group *tg, int src_cpu, int dest_cpu) { struct cfs_rq *src_cfs_rq, *dest_cfs_rq; src_cfs_rq = tg->cfs_rq[src_cpu]; dest_cfs_rq = tg->cfs_rq[dest_cpu]; return throttled_hierarchy(src_cfs_rq) || throttled_hierarchy(dest_cfs_rq); } /* updated child weight may affect parent so we have to do this bottom up */ static int tg_unthrottle_up(struct task_group *tg, void *data) { struct rq *rq = data; struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)]; cfs_rq->throttle_count--; #ifdef CONFIG_SMP if (!cfs_rq->throttle_count) { u64 delta = rq->clock_task - cfs_rq->load_stamp; /* leaving throttled state, advance shares averaging windows */ cfs_rq->load_stamp += delta; cfs_rq->load_last += delta; /* update entity weight now that we are on_rq again */ update_cfs_shares(cfs_rq); } #endif return 0; } static int tg_throttle_down(struct task_group *tg, void *data) { struct rq *rq = data; struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)]; /* group is entering throttled state, record last load */ if (!cfs_rq->throttle_count) update_cfs_load(cfs_rq, 0); cfs_rq->throttle_count++; return 0; } static void throttle_cfs_rq(struct cfs_rq *cfs_rq) { struct rq *rq = rq_of(cfs_rq); struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); struct sched_entity *se; long task_delta, dequeue = 1; se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))]; /* account load preceding throttle */ rcu_read_lock(); walk_tg_tree_from(cfs_rq->tg, tg_throttle_down, tg_nop, (void *)rq); rcu_read_unlock(); task_delta = cfs_rq->h_nr_running; for_each_sched_entity(se) { struct cfs_rq *qcfs_rq = cfs_rq_of(se); /* throttled entity or throttle-on-deactivate */ if (!se->on_rq) break; if (dequeue) dequeue_entity(qcfs_rq, se, DEQUEUE_SLEEP); qcfs_rq->h_nr_running -= task_delta; if (qcfs_rq->load.weight) dequeue = 0; } if (!se) rq->nr_running -= task_delta; cfs_rq->throttled = 1; cfs_rq->throttled_timestamp = rq->clock; raw_spin_lock(&cfs_b->lock); list_add_tail_rcu(&cfs_rq->throttled_list, &cfs_b->throttled_cfs_rq); raw_spin_unlock(&cfs_b->lock); } static void unthrottle_cfs_rq(struct cfs_rq *cfs_rq) { struct rq *rq = rq_of(cfs_rq); struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); struct sched_entity *se; int enqueue = 1; long task_delta; se = cfs_rq->tg->se[cpu_of(rq_of(cfs_rq))]; cfs_rq->throttled = 0; raw_spin_lock(&cfs_b->lock); cfs_b->throttled_time += rq->clock - cfs_rq->throttled_timestamp; list_del_rcu(&cfs_rq->throttled_list); raw_spin_unlock(&cfs_b->lock); cfs_rq->throttled_timestamp = 0; update_rq_clock(rq); /* update hierarchical throttle state */ walk_tg_tree_from(cfs_rq->tg, tg_nop, tg_unthrottle_up, (void *)rq); if (!cfs_rq->load.weight) return; task_delta = cfs_rq->h_nr_running; for_each_sched_entity(se) { if (se->on_rq) enqueue = 0; cfs_rq = cfs_rq_of(se); if (enqueue) enqueue_entity(cfs_rq, se, ENQUEUE_WAKEUP); cfs_rq->h_nr_running += task_delta; if (cfs_rq_throttled(cfs_rq)) break; } if (!se) rq->nr_running += task_delta; /* determine whether we need to wake up potentially idle cpu */ if (rq->curr == rq->idle && rq->cfs.nr_running) resched_task(rq->curr); } static u64 distribute_cfs_runtime(struct cfs_bandwidth *cfs_b, u64 remaining, u64 expires) { struct cfs_rq *cfs_rq; u64 runtime = remaining; rcu_read_lock(); list_for_each_entry_rcu(cfs_rq, &cfs_b->throttled_cfs_rq, throttled_list) { struct rq *rq = rq_of(cfs_rq); raw_spin_lock(&rq->lock); if (!cfs_rq_throttled(cfs_rq)) goto next; runtime = -cfs_rq->runtime_remaining + 1; if (runtime > remaining) runtime = remaining; remaining -= runtime; cfs_rq->runtime_remaining += runtime; cfs_rq->runtime_expires = expires; /* we check whether we're throttled above */ if (cfs_rq->runtime_remaining > 0) unthrottle_cfs_rq(cfs_rq); next: raw_spin_unlock(&rq->lock); if (!remaining) break; } rcu_read_unlock(); return remaining; } /* * Responsible for refilling a task_group's bandwidth and unthrottling its * cfs_rqs as appropriate. If there has been no activity within the last * period the timer is deactivated until scheduling resumes; cfs_b->idle is * used to track this state. */ static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun) { u64 runtime, runtime_expires; int idle = 1, throttled; raw_spin_lock(&cfs_b->lock); /* no need to continue the timer with no bandwidth constraint */ if (cfs_b->quota == RUNTIME_INF) goto out_unlock; throttled = !list_empty(&cfs_b->throttled_cfs_rq); /* idle depends on !throttled (for the case of a large deficit) */ idle = cfs_b->idle && !throttled; cfs_b->nr_periods += overrun; /* if we're going inactive then everything else can be deferred */ if (idle) goto out_unlock; __refill_cfs_bandwidth_runtime(cfs_b); if (!throttled) { /* mark as potentially idle for the upcoming period */ cfs_b->idle = 1; goto out_unlock; } /* account preceding periods in which throttling occurred */ cfs_b->nr_throttled += overrun; /* * There are throttled entities so we must first use the new bandwidth * to unthrottle them before making it generally available. This * ensures that all existing debts will be paid before a new cfs_rq is * allowed to run. */ runtime = cfs_b->runtime; runtime_expires = cfs_b->runtime_expires; cfs_b->runtime = 0; /* * This check is repeated as we are holding onto the new bandwidth * while we unthrottle. This can potentially race with an unthrottled * group trying to acquire new bandwidth from the global pool. */ while (throttled && runtime > 0) { raw_spin_unlock(&cfs_b->lock); /* we can't nest cfs_b->lock while distributing bandwidth */ runtime = distribute_cfs_runtime(cfs_b, runtime, runtime_expires); raw_spin_lock(&cfs_b->lock); throttled = !list_empty(&cfs_b->throttled_cfs_rq); } /* return (any) remaining runtime */ cfs_b->runtime = runtime; /* * While we are ensured activity in the period following an * unthrottle, this also covers the case in which the new bandwidth is * insufficient to cover the existing bandwidth deficit. (Forcing the * timer to remain active while there are any throttled entities.) */ cfs_b->idle = 0; out_unlock: if (idle) cfs_b->timer_active = 0; raw_spin_unlock(&cfs_b->lock); return idle; } /* a cfs_rq won't donate quota below this amount */ static const u64 min_cfs_rq_runtime = 1 * NSEC_PER_MSEC; /* minimum remaining period time to redistribute slack quota */ static const u64 min_bandwidth_expiration = 2 * NSEC_PER_MSEC; /* how long we wait to gather additional slack before distributing */ static const u64 cfs_bandwidth_slack_period = 5 * NSEC_PER_MSEC; /* are we near the end of the current quota period? */ static int runtime_refresh_within(struct cfs_bandwidth *cfs_b, u64 min_expire) { struct hrtimer *refresh_timer = &cfs_b->period_timer; u64 remaining; /* if the call-back is running a quota refresh is already occurring */ if (hrtimer_callback_running(refresh_timer)) return 1; /* is a quota refresh about to occur? */ remaining = ktime_to_ns(hrtimer_expires_remaining(refresh_timer)); if (remaining < min_expire) return 1; return 0; } static void start_cfs_slack_bandwidth(struct cfs_bandwidth *cfs_b) { u64 min_left = cfs_bandwidth_slack_period + min_bandwidth_expiration; /* if there's a quota refresh soon don't bother with slack */ if (runtime_refresh_within(cfs_b, min_left)) return; start_bandwidth_timer(&cfs_b->slack_timer, ns_to_ktime(cfs_bandwidth_slack_period)); } /* we know any runtime found here is valid as update_curr() precedes return */ static void __return_cfs_rq_runtime(struct cfs_rq *cfs_rq) { struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); s64 slack_runtime = cfs_rq->runtime_remaining - min_cfs_rq_runtime; if (slack_runtime <= 0) return; raw_spin_lock(&cfs_b->lock); if (cfs_b->quota != RUNTIME_INF && cfs_rq->runtime_expires == cfs_b->runtime_expires) { cfs_b->runtime += slack_runtime; /* we are under rq->lock, defer unthrottling using a timer */ if (cfs_b->runtime > sched_cfs_bandwidth_slice() && !list_empty(&cfs_b->throttled_cfs_rq)) start_cfs_slack_bandwidth(cfs_b); } raw_spin_unlock(&cfs_b->lock); /* even if it's not valid for return we don't want to try again */ cfs_rq->runtime_remaining -= slack_runtime; } static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) { if (!cfs_rq->runtime_enabled || cfs_rq->nr_running) return; __return_cfs_rq_runtime(cfs_rq); } /* * This is done with a timer (instead of inline with bandwidth return) since * it's necessary to juggle rq->locks to unthrottle their respective cfs_rqs. */ static void do_sched_cfs_slack_timer(struct cfs_bandwidth *cfs_b) { u64 runtime = 0, slice = sched_cfs_bandwidth_slice(); u64 expires; /* confirm we're still not at a refresh boundary */ if (runtime_refresh_within(cfs_b, min_bandwidth_expiration)) return; raw_spin_lock(&cfs_b->lock); if (cfs_b->quota != RUNTIME_INF && cfs_b->runtime > slice) { runtime = cfs_b->runtime; cfs_b->runtime = 0; } expires = cfs_b->runtime_expires; raw_spin_unlock(&cfs_b->lock); if (!runtime) return; runtime = distribute_cfs_runtime(cfs_b, runtime, expires); raw_spin_lock(&cfs_b->lock); if (expires == cfs_b->runtime_expires) cfs_b->runtime = runtime; raw_spin_unlock(&cfs_b->lock); } /* * When a group wakes up we want to make sure that its quota is not already * expired/exceeded, otherwise it may be allowed to steal additional ticks of * runtime as update_curr() throttling can not not trigger until it's on-rq. */ static void check_enqueue_throttle(struct cfs_rq *cfs_rq) { /* an active group must be handled by the update_curr()->put() path */ if (!cfs_rq->runtime_enabled || cfs_rq->curr) return; /* ensure the group is not already throttled */ if (cfs_rq_throttled(cfs_rq)) return; /* update runtime allocation */ account_cfs_rq_runtime(cfs_rq, 0); if (cfs_rq->runtime_remaining <= 0) throttle_cfs_rq(cfs_rq); } /* conditionally throttle active cfs_rq's from put_prev_entity() */ static void check_cfs_rq_runtime(struct cfs_rq *cfs_rq) { if (likely(!cfs_rq->runtime_enabled || cfs_rq->runtime_remaining > 0)) return; /* * it's possible for a throttled entity to be forced into a running * state (e.g. set_curr_task), in this case we're finished. */ if (cfs_rq_throttled(cfs_rq)) return; throttle_cfs_rq(cfs_rq); } #else static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, unsigned long delta_exec) {} static void check_cfs_rq_runtime(struct cfs_rq *cfs_rq) {} static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {} static void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {} static inline int cfs_rq_throttled(struct cfs_rq *cfs_rq) { return 0; } static inline int throttled_hierarchy(struct cfs_rq *cfs_rq) { return 0; } static inline int throttled_lb_pair(struct task_group *tg, int src_cpu, int dest_cpu) { return 0; } #endif /************************************************** * CFS operations on tasks: */ #ifdef CONFIG_SCHED_HRTICK static void hrtick_start_fair(struct rq *rq, struct task_struct *p) { struct sched_entity *se = &p->se; struct cfs_rq *cfs_rq = cfs_rq_of(se); WARN_ON(task_rq(p) != rq); if (hrtick_enabled(rq) && cfs_rq->nr_running > 1) { u64 slice = sched_slice(cfs_rq, se); u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime; s64 delta = slice - ran; if (delta < 0) { if (rq->curr == p) resched_task(p); return; } /* * Don't schedule slices shorter than 10000ns, that just * doesn't make sense. Rely on vruntime for fairness. */ if (rq->curr != p) delta = max_t(s64, 10000LL, delta); hrtick_start(rq, delta); } } /* * called from enqueue/dequeue and updates the hrtick when the * current task is from our class and nr_running is low enough * to matter. */ static void hrtick_update(struct rq *rq) { struct task_struct *curr = rq->curr; if (curr->sched_class != &fair_sched_class) return; if (cfs_rq_of(&curr->se)->nr_running < sched_nr_latency) hrtick_start_fair(rq, curr); } #else /* !CONFIG_SCHED_HRTICK */ static inline void hrtick_start_fair(struct rq *rq, struct task_struct *p) { } static inline void hrtick_update(struct rq *rq) { } #endif /* * The enqueue_task method is called before nr_running is * increased. Here we update the fair scheduling stats and * then put the task into the rbtree: */ static void enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) { struct cfs_rq *cfs_rq; struct sched_entity *se = &p->se; for_each_sched_entity(se) { if (se->on_rq) break; cfs_rq = cfs_rq_of(se); enqueue_entity(cfs_rq, se, flags); /* * end evaluation on encountering a throttled cfs_rq * * note: in the case of encountering a throttled cfs_rq we will * post the final h_nr_running increment below. */ if (cfs_rq_throttled(cfs_rq)) break; cfs_rq->h_nr_running++; flags = ENQUEUE_WAKEUP; } for_each_sched_entity(se) { cfs_rq = cfs_rq_of(se); cfs_rq->h_nr_running++; if (cfs_rq_throttled(cfs_rq)) break; update_cfs_load(cfs_rq, 0); update_cfs_shares(cfs_rq); } if (!se) inc_nr_running(rq); hrtick_update(rq); } static void set_next_buddy(struct sched_entity *se); /* * The dequeue_task method is called before nr_running is * decreased. We remove the task from the rbtree and * update the fair scheduling stats: */ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) { struct cfs_rq *cfs_rq; struct sched_entity *se = &p->se; int task_sleep = flags & DEQUEUE_SLEEP; for_each_sched_entity(se) { cfs_rq = cfs_rq_of(se); dequeue_entity(cfs_rq, se, flags); /* * end evaluation on encountering a throttled cfs_rq * * note: in the case of encountering a throttled cfs_rq we will * post the final h_nr_running decrement below. */ if (cfs_rq_throttled(cfs_rq)) break; cfs_rq->h_nr_running--; /* Don't dequeue parent if it has other entities besides us */ if (cfs_rq->load.weight) { /* * Bias pick_next to pick a task from this cfs_rq, as * p is sleeping when it is within its sched_slice. */ if (task_sleep && parent_entity(se)) set_next_buddy(parent_entity(se)); /* avoid re-evaluating load for this entity */ se = parent_entity(se); break; } flags |= DEQUEUE_SLEEP; } for_each_sched_entity(se) { cfs_rq = cfs_rq_of(se); cfs_rq->h_nr_running--; if (cfs_rq_throttled(cfs_rq)) break; update_cfs_load(cfs_rq, 0); update_cfs_shares(cfs_rq); } if (!se) dec_nr_running(rq); hrtick_update(rq); } #ifdef CONFIG_SMP static void task_waking_fair(struct task_struct *p) { struct sched_entity *se = &p->se; struct cfs_rq *cfs_rq = cfs_rq_of(se); u64 min_vruntime; #ifndef CONFIG_64BIT u64 min_vruntime_copy; do { min_vruntime_copy = cfs_rq->min_vruntime_copy; smp_rmb(); min_vruntime = cfs_rq->min_vruntime; } while (min_vruntime != min_vruntime_copy); #else min_vruntime = cfs_rq->min_vruntime; #endif se->vruntime -= min_vruntime; } #ifdef CONFIG_FAIR_GROUP_SCHED /* * effective_load() calculates the load change as seen from the root_task_group * * Adding load to a group doesn't make a group heavier, but can cause movement * of group shares between cpus. Assuming the shares were perfectly aligned one * can calculate the shift in shares. * * Calculate the effective load difference if @wl is added (subtracted) to @tg * on this @cpu and results in a total addition (subtraction) of @wg to the * total group weight. * * Given a runqueue weight distribution (rw_i) we can compute a shares * distribution (s_i) using: * * s_i = rw_i / \Sum rw_j (1) * * Suppose we have 4 CPUs and our @tg is a direct child of the root group and * has 7 equal weight tasks, distributed as below (rw_i), with the resulting * shares distribution (s_i): * * rw_i = { 2, 4, 1, 0 } * s_i = { 2/7, 4/7, 1/7, 0 } * * As per wake_affine() we're interested in the load of two CPUs (the CPU the * task used to run on and the CPU the waker is running on), we need to * compute the effect of waking a task on either CPU and, in case of a sync * wakeup, compute the effect of the current task going to sleep. * * So for a change of @wl to the local @cpu with an overall group weight change * of @wl we can compute the new shares distribution (s'_i) using: * * s'_i = (rw_i + @wl) / (@wg + \Sum rw_j) (2) * * Suppose we're interested in CPUs 0 and 1, and want to compute the load * differences in waking a task to CPU 0. The additional task changes the * weight and shares distributions like: * * rw'_i = { 3, 4, 1, 0 } * s'_i = { 3/8, 4/8, 1/8, 0 } * * We can then compute the difference in effective weight by using: * * dw_i = S * (s'_i - s_i) (3) * * Where 'S' is the group weight as seen by its parent. * * Therefore the effective change in loads on CPU 0 would be 5/56 (3/8 - 2/7) * times the weight of the group. The effect on CPU 1 would be -4/56 (4/8 - * 4/7) times the weight of the group. */ static long effective_load(struct task_group *tg, int cpu, long wl, long wg) { struct sched_entity *se = tg->se[cpu]; if (!tg->parent) /* the trivial, non-cgroup case */ return wl; for_each_sched_entity(se) { long w, W; tg = se->my_q->tg; /* * W = @wg + \Sum rw_j */ W = wg + calc_tg_weight(tg, se->my_q); /* * w = rw_i + @wl */ w = se->my_q->load.weight + wl; /* * wl = S * s'_i; see (2) */ if (W > 0 && w < W) wl = (w * tg->shares) / W; else wl = tg->shares; /* * Per the above, wl is the new se->load.weight value; since * those are clipped to [MIN_SHARES, ...) do so now. See * calc_cfs_shares(). */ if (wl < MIN_SHARES) wl = MIN_SHARES; /* * wl = dw_i = S * (s'_i - s_i); see (3) */ wl -= se->load.weight; /* * Recursively apply this logic to all parent groups to compute * the final effective load change on the root group. Since * only the @tg group gets extra weight, all parent groups can * only redistribute existing shares. @wl is the shift in shares * resulting from this level per the above. */ wg = 0; } return wl; } #else static inline unsigned long effective_load(struct task_group *tg, int cpu, unsigned long wl, unsigned long wg) { return wl; } #endif static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync) { s64 this_load, load; int idx, this_cpu, prev_cpu; unsigned long tl_per_task; struct task_group *tg; unsigned long weight; int balanced; idx = sd->wake_idx; this_cpu = smp_processor_id(); prev_cpu = task_cpu(p); load = source_load(prev_cpu, idx); this_load = target_load(this_cpu, idx); /* * If sync wakeup then subtract the (maximum possible) * effect of the currently running task from the load * of the current CPU: */ if (sync) { tg = task_group(current); weight = current->se.load.weight; this_load += effective_load(tg, this_cpu, -weight, -weight); load += effective_load(tg, prev_cpu, 0, -weight); } tg = task_group(p); weight = p->se.load.weight; /* * In low-load situations, where prev_cpu is idle and this_cpu is idle * due to the sync cause above having dropped this_load to 0, we'll * always have an imbalance, but there's really nothing you can do * about that, so that's good too. * * Otherwise check if either cpus are near enough in load to allow this * task to be woken on this_cpu. */ if (this_load > 0) { s64 this_eff_load, prev_eff_load; this_eff_load = 100; this_eff_load *= power_of(prev_cpu); this_eff_load *= this_load + effective_load(tg, this_cpu, weight, weight); prev_eff_load = 100 + (sd->imbalance_pct - 100) / 2; prev_eff_load *= power_of(this_cpu); prev_eff_load *= load + effective_load(tg, prev_cpu, 0, weight); balanced = this_eff_load <= prev_eff_load; } else balanced = true; /* * If the currently running task will sleep within * a reasonable amount of time then attract this newly * woken task: */ if (sync && balanced) return 1; schedstat_inc(p, se.statistics.nr_wakeups_affine_attempts); tl_per_task = cpu_avg_load_per_task(this_cpu); if (balanced || (this_load <= load && this_load + target_load(prev_cpu, idx) <= tl_per_task)) { /* * This domain has SD_WAKE_AFFINE and * p is cache cold in this domain, and * there is no bad imbalance. */ schedstat_inc(sd, ttwu_move_affine); schedstat_inc(p, se.statistics.nr_wakeups_affine); return 1; } return 0; } /* * find_idlest_group finds and returns the least busy CPU group within the * domain. */ static struct sched_group * find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu, int load_idx) { struct sched_group *idlest = NULL, *group = sd->groups; unsigned long min_load = ULONG_MAX, this_load = 0; int imbalance = 100 + (sd->imbalance_pct-100)/2; do { unsigned long load, avg_load; int local_group; int i; /* Skip over this group if it has no CPUs allowed */ if (!cpumask_intersects(sched_group_cpus(group), tsk_cpus_allowed(p))) continue; local_group = cpumask_test_cpu(this_cpu, sched_group_cpus(group)); /* Tally up the load of all CPUs in the group */ avg_load = 0; for_each_cpu(i, sched_group_cpus(group)) { /* Bias balancing toward cpus of our domain */ if (local_group) load = source_load(i, load_idx); else load = target_load(i, load_idx); avg_load += load; } /* Adjust by relative CPU power of the group */ avg_load = (avg_load * SCHED_POWER_SCALE) / group->sgp->power; if (local_group) { this_load = avg_load; } else if (avg_load < min_load) { min_load = avg_load; idlest = group; } } while (group = group->next, group != sd->groups); if (!idlest || 100*this_load < imbalance*min_load) return NULL; return idlest; } /* * find_idlest_cpu - find the idlest cpu among the cpus in group. */ static int find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu) { unsigned long load, min_load = ULONG_MAX; int idlest = -1; int i; /* Traverse only the allowed CPUs */ for_each_cpu_and(i, sched_group_cpus(group), tsk_cpus_allowed(p)) { load = weighted_cpuload(i); if (load < min_load || (load == min_load && i == this_cpu)) { min_load = load; idlest = i; } } return idlest; } /* * Try and locate an idle CPU in the sched_domain. */ static int select_idle_sibling(struct task_struct *p, int target) { int cpu = smp_processor_id(); int prev_cpu = task_cpu(p); struct sched_domain *sd; struct sched_group *sg; int i, smt = 0; /* * If the task is going to be woken-up on this cpu and if it is * already idle, then it is the right target. */ if (target == cpu && idle_cpu(cpu)) return cpu; /* * If the task is going to be woken-up on the cpu where it previously * ran and if it is currently idle, then it the right target. */ if (target == prev_cpu && idle_cpu(prev_cpu)) return prev_cpu; /* * Otherwise, iterate the domains and find an elegible idle cpu. */ rcu_read_lock(); again: for_each_domain(target, sd) { if (!smt && (sd->flags & SD_SHARE_CPUPOWER)) continue; if (smt && !(sd->flags & SD_SHARE_CPUPOWER)) break; if (!(sd->flags & SD_SHARE_PKG_RESOURCES)) break; sg = sd->groups; do { if (!cpumask_intersects(sched_group_cpus(sg), tsk_cpus_allowed(p))) goto next; for_each_cpu(i, sched_group_cpus(sg)) { if (!idle_cpu(i)) goto next; } target = cpumask_first_and(sched_group_cpus(sg), tsk_cpus_allowed(p)); goto done; next: sg = sg->next; } while (sg != sd->groups); } if (!smt) { smt = 1; goto again; } done: rcu_read_unlock(); return target; } /* * sched_balance_self: balance the current task (running on cpu) in domains * that have the 'flag' flag set. In practice, this is SD_BALANCE_FORK and * SD_BALANCE_EXEC. * * Balance, ie. select the least loaded group. * * Returns the target CPU number, or the same CPU if no balancing is needed. * * preempt must be disabled. */ static int select_task_rq_fair(struct task_struct *p, int sd_flag, int wake_flags) { struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; int cpu = smp_processor_id(); int prev_cpu = task_cpu(p); int new_cpu = cpu; int want_affine = 0; int want_sd = 1; int sync = wake_flags & WF_SYNC; if (sd_flag & SD_BALANCE_WAKE) { if (cpumask_test_cpu(cpu, tsk_cpus_allowed(p))) want_affine = 1; new_cpu = prev_cpu; } rcu_read_lock(); for_each_domain(cpu, tmp) { if (!(tmp->flags & SD_LOAD_BALANCE)) continue; /* * If power savings logic is enabled for a domain, see if we * are not overloaded, if so, don't balance wider. */ if (tmp->flags & (SD_POWERSAVINGS_BALANCE|SD_PREFER_LOCAL)) { unsigned long power = 0; unsigned long nr_running = 0; unsigned long capacity; int i; for_each_cpu(i, sched_domain_span(tmp)) { power += power_of(i); nr_running += cpu_rq(i)->cfs.nr_running; } capacity = DIV_ROUND_CLOSEST(power, SCHED_POWER_SCALE); if (tmp->flags & SD_POWERSAVINGS_BALANCE) nr_running /= 2; if (nr_running < capacity) want_sd = 0; } /* * If both cpu and prev_cpu are part of this domain, * cpu is a valid SD_WAKE_AFFINE target. */ if (want_affine && (tmp->flags & SD_WAKE_AFFINE) && cpumask_test_cpu(prev_cpu, sched_domain_span(tmp))) { affine_sd = tmp; want_affine = 0; } if (!want_sd && !want_affine) break; if (!(tmp->flags & sd_flag)) continue; if (want_sd) sd = tmp; } if (affine_sd) { if (cpu == prev_cpu || wake_affine(affine_sd, p, sync)) prev_cpu = cpu; new_cpu = select_idle_sibling(p, prev_cpu); goto unlock; } while (sd) { int load_idx = sd->forkexec_idx; struct sched_group *group; int weight; if (!(sd->flags & sd_flag)) { sd = sd->child; continue; } if (sd_flag & SD_BALANCE_WAKE) load_idx = sd->wake_idx; group = find_idlest_group(sd, p, cpu, load_idx); if (!group) { sd = sd->child; continue; } new_cpu = find_idlest_cpu(group, p, cpu); if (new_cpu == -1 || new_cpu == cpu) { /* Now try balancing at a lower domain level of cpu */ sd = sd->child; continue; } /* Now try balancing at a lower domain level of new_cpu */ cpu = new_cpu; weight = sd->span_weight; sd = NULL; for_each_domain(cpu, tmp) { if (weight <= tmp->span_weight) break; if (tmp->flags & sd_flag) sd = tmp; } /* while loop will break here if sd == NULL */ } unlock: rcu_read_unlock(); return new_cpu; } #endif /* CONFIG_SMP */ static unsigned long wakeup_gran(struct sched_entity *curr, struct sched_entity *se) { unsigned long gran = sysctl_sched_wakeup_granularity; /* * Since its curr running now, convert the gran from real-time * to virtual-time in his units. * * By using 'se' instead of 'curr' we penalize light tasks, so * they get preempted easier. That is, if 'se' < 'curr' then * the resulting gran will be larger, therefore penalizing the * lighter, if otoh 'se' > 'curr' then the resulting gran will * be smaller, again penalizing the lighter task. * * This is especially important for buddies when the leftmost * task is higher priority than the buddy. */ return calc_delta_fair(gran, se); } /* * Should 'se' preempt 'curr'. * * |s1 * |s2 * |s3 * g * |<--->|c * * w(c, s1) = -1 * w(c, s2) = 0 * w(c, s3) = 1 * */ static int wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se) { s64 gran, vdiff = curr->vruntime - se->vruntime; if (vdiff <= 0) return -1; gran = wakeup_gran(curr, se); if (vdiff > gran) return 1; return 0; } static void set_last_buddy(struct sched_entity *se) { if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE)) return; for_each_sched_entity(se) cfs_rq_of(se)->last = se; } static void set_next_buddy(struct sched_entity *se) { if (entity_is_task(se) && unlikely(task_of(se)->policy == SCHED_IDLE)) return; for_each_sched_entity(se) cfs_rq_of(se)->next = se; } static void set_skip_buddy(struct sched_entity *se) { for_each_sched_entity(se) cfs_rq_of(se)->skip = se; } /* * Preempt the current task with a newly woken task if needed: */ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags) { struct task_struct *curr = rq->curr; struct sched_entity *se = &curr->se, *pse = &p->se; struct cfs_rq *cfs_rq = task_cfs_rq(curr); int scale = cfs_rq->nr_running >= sched_nr_latency; int next_buddy_marked = 0; if (unlikely(se == pse)) return; /* * This is possible from callers such as pull_task(), in which we * unconditionally check_prempt_curr() after an enqueue (which may have * lead to a throttle). This both saves work and prevents false * next-buddy nomination below. */ if (unlikely(throttled_hierarchy(cfs_rq_of(pse)))) return; if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK)) { set_next_buddy(pse); next_buddy_marked = 1; } /* * We can come here with TIF_NEED_RESCHED already set from new task * wake up path. * * Note: this also catches the edge-case of curr being in a throttled * group (e.g. via set_curr_task), since update_curr() (in the * enqueue of curr) will have resulted in resched being set. This * prevents us from potentially nominating it as a false LAST_BUDDY * below. */ if (test_tsk_need_resched(curr)) return; /* Idle tasks are by definition preempted by non-idle tasks. */ if (unlikely(curr->policy == SCHED_IDLE) && likely(p->policy != SCHED_IDLE)) goto preempt; /* * Batch and idle tasks do not preempt non-idle tasks (their preemption * is driven by the tick): */ if (unlikely(p->policy != SCHED_NORMAL)) return; find_matching_se(&se, &pse); update_curr(cfs_rq_of(se)); BUG_ON(!pse); if (wakeup_preempt_entity(se, pse) == 1) { /* * Bias pick_next to pick the sched entity that is * triggering this preemption. */ if (!next_buddy_marked) set_next_buddy(pse); goto preempt; } return; preempt: resched_task(curr); /* * Only set the backward buddy when the current task is still * on the rq. This can happen when a wakeup gets interleaved * with schedule on the ->pre_schedule() or idle_balance() * point, either of which can * drop the rq lock. * * Also, during early boot the idle thread is in the fair class, * for obvious reasons its a bad idea to schedule back to it. */ if (unlikely(!se->on_rq || curr == rq->idle)) return; if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se)) set_last_buddy(se); } static struct task_struct *pick_next_task_fair(struct rq *rq) { struct task_struct *p; struct cfs_rq *cfs_rq = &rq->cfs; struct sched_entity *se; if (!cfs_rq->nr_running) return NULL; do { se = pick_next_entity(cfs_rq); set_next_entity(cfs_rq, se); cfs_rq = group_cfs_rq(se); } while (cfs_rq); p = task_of(se); hrtick_start_fair(rq, p); return p; } /* * Account for a descheduled task: */ static void put_prev_task_fair(struct rq *rq, struct task_struct *prev) { struct sched_entity *se = &prev->se; struct cfs_rq *cfs_rq; for_each_sched_entity(se) { cfs_rq = cfs_rq_of(se); put_prev_entity(cfs_rq, se); } } /* * sched_yield() is very simple * * The magic of dealing with the ->skip buddy is in pick_next_entity. */ static void yield_task_fair(struct rq *rq) { struct task_struct *curr = rq->curr; struct cfs_rq *cfs_rq = task_cfs_rq(curr); struct sched_entity *se = &curr->se; /* * Are we the only task in the tree? */ if (unlikely(rq->nr_running == 1)) return; clear_buddies(cfs_rq, se); if (curr->policy != SCHED_BATCH) { update_rq_clock(rq); /* * Update run-time statistics of the 'current'. */ update_curr(cfs_rq); } set_skip_buddy(se); } static bool yield_to_task_fair(struct rq *rq, struct task_struct *p, bool preempt) { struct sched_entity *se = &p->se; /* throttled hierarchies are not runnable */ if (!se->on_rq || throttled_hierarchy(cfs_rq_of(se))) return false; /* Tell the scheduler that we'd really like pse to run next. */ set_next_buddy(se); yield_task_fair(rq); return true; } #ifdef CONFIG_SMP /************************************************** * Fair scheduling class load-balancing methods: */ /* * pull_task - move a task from a remote runqueue to the local runqueue. * Both runqueues must be locked. */ static void pull_task(struct rq *src_rq, struct task_struct *p, struct rq *this_rq, int this_cpu) { deactivate_task(src_rq, p, 0); set_task_cpu(p, this_cpu); activate_task(this_rq, p, 0); check_preempt_curr(this_rq, p, 0); } /* * can_migrate_task - may task p from runqueue rq be migrated to this_cpu? */ static int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned) { int tsk_cache_hot = 0; /* * We do not migrate tasks that are: * 1) running (obviously), or * 2) cannot be migrated to this CPU due to cpus_allowed, or * 3) are cache-hot on their current CPU. */ if (!cpumask_test_cpu(this_cpu, tsk_cpus_allowed(p))) { schedstat_inc(p, se.statistics.nr_failed_migrations_affine); return 0; } *all_pinned = 0; if (task_running(rq, p)) { schedstat_inc(p, se.statistics.nr_failed_migrations_running); return 0; } /* * Aggressive migration if: * 1) task is cache cold, or * 2) too many balance attempts have failed. */ tsk_cache_hot = task_hot(p, rq->clock_task, sd); if (!tsk_cache_hot || sd->nr_balance_failed > sd->cache_nice_tries) { #ifdef CONFIG_SCHEDSTATS if (tsk_cache_hot) { schedstat_inc(sd, lb_hot_gained[idle]); schedstat_inc(p, se.statistics.nr_forced_migrations); } #endif return 1; } if (tsk_cache_hot) { schedstat_inc(p, se.statistics.nr_failed_migrations_hot); return 0; } return 1; } /* * move_one_task tries to move exactly one task from busiest to this_rq, as * part of active balancing operations within "domain". * Returns 1 if successful and 0 otherwise. * * Called with both runqueues locked. */ static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest, struct sched_domain *sd, enum cpu_idle_type idle) { struct task_struct *p, *n; struct cfs_rq *cfs_rq; int pinned = 0; for_each_leaf_cfs_rq(busiest, cfs_rq) { list_for_each_entry_safe(p, n, &cfs_rq->tasks, se.group_node) { if (throttled_lb_pair(task_group(p), busiest->cpu, this_cpu)) break; if (!can_migrate_task(p, busiest, this_cpu, sd, idle, &pinned)) continue; pull_task(busiest, p, this_rq, this_cpu); /* * Right now, this is only the second place pull_task() * is called, so we can safely collect pull_task() * stats here rather than inside pull_task(). */ schedstat_inc(sd, lb_gained[idle]); return 1; } } return 0; } static unsigned long balance_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest, unsigned long max_load_move, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned, struct cfs_rq *busiest_cfs_rq) { int loops = 0, pulled = 0; long rem_load_move = max_load_move; struct task_struct *p, *n; if (max_load_move == 0) goto out; list_for_each_entry_safe(p, n, &busiest_cfs_rq->tasks, se.group_node) { if (loops++ > sysctl_sched_nr_migrate) break; if ((p->se.load.weight >> 1) > rem_load_move || !can_migrate_task(p, busiest, this_cpu, sd, idle, all_pinned)) continue; pull_task(busiest, p, this_rq, this_cpu); pulled++; rem_load_move -= p->se.load.weight; #ifdef CONFIG_PREEMPT /* * NEWIDLE balancing is a source of latency, so preemptible * kernels will stop after the first task is pulled to minimize * the critical section. */ if (idle == CPU_NEWLY_IDLE) break; #endif /* * We only want to steal up to the prescribed amount of * weighted load. */ if (rem_load_move <= 0) break; } out: /* * Right now, this is one of only two places pull_task() is called, * so we can safely collect pull_task() stats here rather than * inside pull_task(). */ schedstat_add(sd, lb_gained[idle], pulled); return max_load_move - rem_load_move; } #ifdef CONFIG_FAIR_GROUP_SCHED /* * update tg->load_weight by folding this cpu's load_avg */ static int update_shares_cpu(struct task_group *tg, int cpu) { struct cfs_rq *cfs_rq; unsigned long flags; struct rq *rq; if (!tg->se[cpu]) return 0; rq = cpu_rq(cpu); cfs_rq = tg->cfs_rq[cpu]; raw_spin_lock_irqsave(&rq->lock, flags); update_rq_clock(rq); update_cfs_load(cfs_rq, 1); /* * We need to update shares after updating tg->load_weight in * order to adjust the weight of groups with long running tasks. */ update_cfs_shares(cfs_rq); raw_spin_unlock_irqrestore(&rq->lock, flags); return 0; } static void update_shares(int cpu) { struct cfs_rq *cfs_rq; struct rq *rq = cpu_rq(cpu); rcu_read_lock(); /* * Iterates the task_group tree in a bottom up fashion, see * list_add_leaf_cfs_rq() for details. */ for_each_leaf_cfs_rq(rq, cfs_rq) { /* throttled entities do not contribute to load */ if (throttled_hierarchy(cfs_rq)) continue; update_shares_cpu(cfs_rq->tg, cpu); } rcu_read_unlock(); } /* * Compute the cpu's hierarchical load factor for each task group. * This needs to be done in a top-down fashion because the load of a child * group is a fraction of its parents load. */ static int tg_load_down(struct task_group *tg, void *data) { unsigned long load; long cpu = (long)data; if (!tg->parent) { load = cpu_rq(cpu)->load.weight; } else { load = tg->parent->cfs_rq[cpu]->h_load; load *= tg->se[cpu]->load.weight; load /= tg->parent->cfs_rq[cpu]->load.weight + 1; } tg->cfs_rq[cpu]->h_load = load; return 0; } static void update_h_load(long cpu) { walk_tg_tree(tg_load_down, tg_nop, (void *)cpu); } static unsigned long load_balance_fair(struct rq *this_rq, int this_cpu, struct rq *busiest, unsigned long max_load_move, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned) { long rem_load_move = max_load_move; struct cfs_rq *busiest_cfs_rq; rcu_read_lock(); update_h_load(cpu_of(busiest)); for_each_leaf_cfs_rq(busiest, busiest_cfs_rq) { unsigned long busiest_h_load = busiest_cfs_rq->h_load; unsigned long busiest_weight = busiest_cfs_rq->load.weight; u64 rem_load, moved_load; /* * empty group or part of a throttled hierarchy */ if (!busiest_cfs_rq->task_weight || throttled_lb_pair(busiest_cfs_rq->tg, cpu_of(busiest), this_cpu)) continue; rem_load = (u64)rem_load_move * busiest_weight; rem_load = div_u64(rem_load, busiest_h_load + 1); moved_load = balance_tasks(this_rq, this_cpu, busiest, rem_load, sd, idle, all_pinned, busiest_cfs_rq); if (!moved_load) continue; moved_load *= busiest_h_load; moved_load = div_u64(moved_load, busiest_weight + 1); rem_load_move -= moved_load; if (rem_load_move < 0) break; } rcu_read_unlock(); return max_load_move - rem_load_move; } #else static inline void update_shares(int cpu) { } static unsigned long load_balance_fair(struct rq *this_rq, int this_cpu, struct rq *busiest, unsigned long max_load_move, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned) { return balance_tasks(this_rq, this_cpu, busiest, max_load_move, sd, idle, all_pinned, &busiest->cfs); } #endif /* * move_tasks tries to move up to max_load_move weighted load from busiest to * this_rq, as part of a balancing operation within domain "sd". * Returns 1 if successful and 0 otherwise. * * Called with both runqueues locked. */ static int move_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest, unsigned long max_load_move, struct sched_domain *sd, enum cpu_idle_type idle, int *all_pinned) { unsigned long total_load_moved = 0, load_moved; do { load_moved = load_balance_fair(this_rq, this_cpu, busiest, max_load_move - total_load_moved, sd, idle, all_pinned); total_load_moved += load_moved; #ifdef CONFIG_PREEMPT /* * NEWIDLE balancing is a source of latency, so preemptible * kernels will stop after the first task is pulled to minimize * the critical section. */ if (idle == CPU_NEWLY_IDLE && this_rq->nr_running) break; if (raw_spin_is_contended(&this_rq->lock) || raw_spin_is_contended(&busiest->lock)) break; #endif } while (load_moved && max_load_move > total_load_moved); return total_load_moved > 0; } /********** Helpers for find_busiest_group ************************/ /* * sd_lb_stats - Structure to store the statistics of a sched_domain * during load balancing. */ struct sd_lb_stats { struct sched_group *busiest; /* Busiest group in this sd */ struct sched_group *this; /* Local group in this sd */ unsigned long total_load; /* Total load of all groups in sd */ unsigned long total_pwr; /* Total power of all groups in sd */ unsigned long avg_load; /* Average load across all groups in sd */ /** Statistics of this group */ unsigned long this_load; unsigned long this_load_per_task; unsigned long this_nr_running; unsigned long this_has_capacity; unsigned int this_idle_cpus; /* Statistics of the busiest group */ unsigned int busiest_idle_cpus; unsigned long max_load; unsigned long busiest_load_per_task; unsigned long busiest_nr_running; unsigned long busiest_group_capacity; unsigned long busiest_has_capacity; unsigned int busiest_group_weight; int group_imb; /* Is there imbalance in this sd */ #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT) int power_savings_balance; /* Is powersave balance needed for this sd */ struct sched_group *group_min; /* Least loaded group in sd */ struct sched_group *group_leader; /* Group which relieves group_min */ unsigned long min_load_per_task; /* load_per_task in group_min */ unsigned long leader_nr_running; /* Nr running of group_leader */ unsigned long min_nr_running; /* Nr running of group_min */ #endif }; /* * sg_lb_stats - stats of a sched_group required for load_balancing */ struct sg_lb_stats { unsigned long avg_load; /*Avg load across the CPUs of the group */ unsigned long group_load; /* Total load over the CPUs of the group */ unsigned long sum_nr_running; /* Nr tasks running in the group */ unsigned long sum_weighted_load; /* Weighted load of group's tasks */ unsigned long group_capacity; unsigned long idle_cpus; unsigned long group_weight; int group_imb; /* Is there an imbalance in the group ? */ int group_has_capacity; /* Is there extra capacity in the group? */ }; /** * group_first_cpu - Returns the first cpu in the cpumask of a sched_group. * @group: The group whose first cpu is to be returned. */ static inline unsigned int group_first_cpu(struct sched_group *group) { return cpumask_first(sched_group_cpus(group)); } /** * get_sd_load_idx - Obtain the load index for a given sched domain. * @sd: The sched_domain whose load_idx is to be obtained. * @idle: The Idle status of the CPU for whose sd load_icx is obtained. */ static inline int get_sd_load_idx(struct sched_domain *sd, enum cpu_idle_type idle) { int load_idx; switch (idle) { case CPU_NOT_IDLE: load_idx = sd->busy_idx; break; case CPU_NEWLY_IDLE: load_idx = sd->newidle_idx; break; default: load_idx = sd->idle_idx; break; } return load_idx; } #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT) /** * init_sd_power_savings_stats - Initialize power savings statistics for * the given sched_domain, during load balancing. * * @sd: Sched domain whose power-savings statistics are to be initialized. * @sds: Variable containing the statistics for sd. * @idle: Idle status of the CPU at which we're performing load-balancing. */ static inline void init_sd_power_savings_stats(struct sched_domain *sd, struct sd_lb_stats *sds, enum cpu_idle_type idle) { /* * Busy processors will not participate in power savings * balance. */ if (idle == CPU_NOT_IDLE || !(sd->flags & SD_POWERSAVINGS_BALANCE)) sds->power_savings_balance = 0; else { sds->power_savings_balance = 1; sds->min_nr_running = ULONG_MAX; sds->leader_nr_running = 0; } } /** * update_sd_power_savings_stats - Update the power saving stats for a * sched_domain while performing load balancing. * * @group: sched_group belonging to the sched_domain under consideration. * @sds: Variable containing the statistics of the sched_domain * @local_group: Does group contain the CPU for which we're performing * load balancing ? * @sgs: Variable containing the statistics of the group. */ static inline void update_sd_power_savings_stats(struct sched_group *group, struct sd_lb_stats *sds, int local_group, struct sg_lb_stats *sgs) { if (!sds->power_savings_balance) return; /* * If the local group is idle or completely loaded * no need to do power savings balance at this domain */ if (local_group && (sds->this_nr_running >= sgs->group_capacity || !sds->this_nr_running)) sds->power_savings_balance = 0; /* * If a group is already running at full capacity or idle, * don't include that group in power savings calculations */ if (!sds->power_savings_balance || sgs->sum_nr_running >= sgs->group_capacity || !sgs->sum_nr_running) return; /* * Calculate the group which has the least non-idle load. * This is the group from where we need to pick up the load * for saving power */ if ((sgs->sum_nr_running < sds->min_nr_running) || (sgs->sum_nr_running == sds->min_nr_running && group_first_cpu(group) > group_first_cpu(sds->group_min))) { sds->group_min = group; sds->min_nr_running = sgs->sum_nr_running; sds->min_load_per_task = sgs->sum_weighted_load / sgs->sum_nr_running; } /* * Calculate the group which is almost near its * capacity but still has some space to pick up some load * from other group and save more power */ if (sgs->sum_nr_running + 1 > sgs->group_capacity) return; if (sgs->sum_nr_running > sds->leader_nr_running || (sgs->sum_nr_running == sds->leader_nr_running && group_first_cpu(group) < group_first_cpu(sds->group_leader))) { sds->group_leader = group; sds->leader_nr_running = sgs->sum_nr_running; } } /** * check_power_save_busiest_group - see if there is potential for some power-savings balance * @sds: Variable containing the statistics of the sched_domain * under consideration. * @this_cpu: Cpu at which we're currently performing load-balancing. * @imbalance: Variable to store the imbalance. * * Description: * Check if we have potential to perform some power-savings balance. * If yes, set the busiest group to be the least loaded group in the * sched_domain, so that it's CPUs can be put to idle. * * Returns 1 if there is potential to perform power-savings balance. * Else returns 0. */ static inline int check_power_save_busiest_group(struct sd_lb_stats *sds, int this_cpu, unsigned long *imbalance) { if (!sds->power_savings_balance) return 0; if (sds->this != sds->group_leader || sds->group_leader == sds->group_min) return 0; *imbalance = sds->min_load_per_task; sds->busiest = sds->group_min; return 1; } #else /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */ static inline void init_sd_power_savings_stats(struct sched_domain *sd, struct sd_lb_stats *sds, enum cpu_idle_type idle) { return; } static inline void update_sd_power_savings_stats(struct sched_group *group, struct sd_lb_stats *sds, int local_group, struct sg_lb_stats *sgs) { return; } static inline int check_power_save_busiest_group(struct sd_lb_stats *sds, int this_cpu, unsigned long *imbalance) { return 0; } #endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */ unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu) { return SCHED_POWER_SCALE; } unsigned long __weak arch_scale_freq_power(struct sched_domain *sd, int cpu) { return default_scale_freq_power(sd, cpu); } unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu) { unsigned long weight = sd->span_weight; unsigned long smt_gain = sd->smt_gain; smt_gain /= weight; return smt_gain; } unsigned long __weak arch_scale_smt_power(struct sched_domain *sd, int cpu) { return default_scale_smt_power(sd, cpu); } unsigned long scale_rt_power(int cpu) { struct rq *rq = cpu_rq(cpu); u64 total, available; total = sched_avg_period() + (rq->clock - rq->age_stamp); if (unlikely(total < rq->rt_avg)) { /* Ensures that power won't end up being negative */ available = 0; } else { available = total - rq->rt_avg; } if (unlikely((s64)total < SCHED_POWER_SCALE)) total = SCHED_POWER_SCALE; total >>= SCHED_POWER_SHIFT; return div_u64(available, total); } static void update_cpu_power(struct sched_domain *sd, int cpu) { unsigned long weight = sd->span_weight; unsigned long power = SCHED_POWER_SCALE; struct sched_group *sdg = sd->groups; if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) { if (sched_feat(ARCH_POWER)) power *= arch_scale_smt_power(sd, cpu); else power *= default_scale_smt_power(sd, cpu); power >>= SCHED_POWER_SHIFT; } sdg->sgp->power_orig = power; if (sched_feat(ARCH_POWER)) power *= arch_scale_freq_power(sd, cpu); else power *= default_scale_freq_power(sd, cpu); power >>= SCHED_POWER_SHIFT; power *= scale_rt_power(cpu); power >>= SCHED_POWER_SHIFT; if (!power) power = 1; cpu_rq(cpu)->cpu_power = power; sdg->sgp->power = power; } static void update_group_power(struct sched_domain *sd, int cpu) { struct sched_domain *child = sd->child; struct sched_group *group, *sdg = sd->groups; unsigned long power; if (!child) { update_cpu_power(sd, cpu); return; } power = 0; group = child->groups; do { power += group->sgp->power; group = group->next; } while (group != child->groups); sdg->sgp->power = power; } /* * Try and fix up capacity for tiny siblings, this is needed when * things like SD_ASYM_PACKING need f_b_g to select another sibling * which on its own isn't powerful enough. * * See update_sd_pick_busiest() and check_asym_packing(). */ static inline int fix_small_capacity(struct sched_domain *sd, struct sched_group *group) { /* * Only siblings can have significantly less than SCHED_POWER_SCALE */ if (!(sd->flags & SD_SHARE_CPUPOWER)) return 0; /* * If ~90% of the cpu_power is still there, we're good. */ if (group->sgp->power * 32 > group->sgp->power_orig * 29) return 1; return 0; } /** * update_sg_lb_stats - Update sched_group's statistics for load balancing. * @sd: The sched_domain whose statistics are to be updated. * @group: sched_group whose statistics are to be updated. * @this_cpu: Cpu for which load balance is currently performed. * @idle: Idle status of this_cpu * @load_idx: Load index of sched_domain of this_cpu for load calc. * @local_group: Does group contain this_cpu. * @cpus: Set of cpus considered for load balancing. * @balance: Should we balance. * @sgs: variable to hold the statistics for this group. */ static inline void update_sg_lb_stats(struct sched_domain *sd, struct sched_group *group, int this_cpu, enum cpu_idle_type idle, int load_idx, int local_group, const struct cpumask *cpus, int *balance, struct sg_lb_stats *sgs) { unsigned long load, max_cpu_load, min_cpu_load, max_nr_running; int i; unsigned int balance_cpu = -1, first_idle_cpu = 0; unsigned long avg_load_per_task = 0; if (local_group) balance_cpu = group_first_cpu(group); /* Tally up the load of all CPUs in the group */ max_cpu_load = 0; min_cpu_load = ~0UL; max_nr_running = 0; for_each_cpu_and(i, sched_group_cpus(group), cpus) { struct rq *rq = cpu_rq(i); /* Bias balancing toward cpus of our domain */ if (local_group) { if (idle_cpu(i) && !first_idle_cpu) { first_idle_cpu = 1; balance_cpu = i; } load = target_load(i, load_idx); } else { load = source_load(i, load_idx); if (load > max_cpu_load) { max_cpu_load = load; max_nr_running = rq->nr_running; } if (min_cpu_load > load) min_cpu_load = load; } sgs->group_load += load; sgs->sum_nr_running += rq->nr_running; sgs->sum_weighted_load += weighted_cpuload(i); if (idle_cpu(i)) sgs->idle_cpus++; } /* * First idle cpu or the first cpu(busiest) in this sched group * is eligible for doing load balancing at this and above * domains. In the newly idle case, we will allow all the cpu's * to do the newly idle load balance. */ if (idle != CPU_NEWLY_IDLE && local_group) { if (balance_cpu != this_cpu) { *balance = 0; return; } update_group_power(sd, this_cpu); } /* Adjust by relative CPU power of the group */ sgs->avg_load = (sgs->group_load*SCHED_POWER_SCALE) / group->sgp->power; /* * Consider the group unbalanced when the imbalance is larger * than the average weight of a task. * * APZ: with cgroup the avg task weight can vary wildly and * might not be a suitable number - should we keep a * normalized nr_running number somewhere that negates * the hierarchy? */ if (sgs->sum_nr_running) avg_load_per_task = sgs->sum_weighted_load / sgs->sum_nr_running; if ((max_cpu_load - min_cpu_load) >= avg_load_per_task && max_nr_running > 1) sgs->group_imb = 1; sgs->group_capacity = DIV_ROUND_CLOSEST(group->sgp->power, SCHED_POWER_SCALE); if (!sgs->group_capacity) sgs->group_capacity = fix_small_capacity(sd, group); sgs->group_weight = group->group_weight; if (sgs->group_capacity > sgs->sum_nr_running) sgs->group_has_capacity = 1; } /** * update_sd_pick_busiest - return 1 on busiest group * @sd: sched_domain whose statistics are to be checked * @sds: sched_domain statistics * @sg: sched_group candidate to be checked for being the busiest * @sgs: sched_group statistics * @this_cpu: the current cpu * * Determine if @sg is a busier group than the previously selected * busiest group. */ static bool update_sd_pick_busiest(struct sched_domain *sd, struct sd_lb_stats *sds, struct sched_group *sg, struct sg_lb_stats *sgs, int this_cpu) { if (sgs->avg_load <= sds->max_load) return false; if (sgs->sum_nr_running > sgs->group_capacity) return true; if (sgs->group_imb) return true; /* * ASYM_PACKING needs to move all the work to the lowest * numbered CPUs in the group, therefore mark all groups * higher than ourself as busy. */ if ((sd->flags & SD_ASYM_PACKING) && sgs->sum_nr_running && this_cpu < group_first_cpu(sg)) { if (!sds->busiest) return true; if (group_first_cpu(sds->busiest) > group_first_cpu(sg)) return true; } return false; } /** * update_sd_lb_stats - Update sched_domain's statistics for load balancing. * @sd: sched_domain whose statistics are to be updated. * @this_cpu: Cpu for which load balance is currently performed. * @idle: Idle status of this_cpu * @cpus: Set of cpus considered for load balancing. * @balance: Should we balance. * @sds: variable to hold the statistics for this sched_domain. */ static inline void update_sd_lb_stats(struct sched_domain *sd, int this_cpu, enum cpu_idle_type idle, const struct cpumask *cpus, int *balance, struct sd_lb_stats *sds) { struct sched_domain *child = sd->child; struct sched_group *sg = sd->groups; struct sg_lb_stats sgs; int load_idx, prefer_sibling = 0; if (child && child->flags & SD_PREFER_SIBLING) prefer_sibling = 1; init_sd_power_savings_stats(sd, sds, idle); load_idx = get_sd_load_idx(sd, idle); do { int local_group; local_group = cpumask_test_cpu(this_cpu, sched_group_cpus(sg)); memset(&sgs, 0, sizeof(sgs)); update_sg_lb_stats(sd, sg, this_cpu, idle, load_idx, local_group, cpus, balance, &sgs); if (local_group && !(*balance)) return; sds->total_load += sgs.group_load; sds->total_pwr += sg->sgp->power; /* * In case the child domain prefers tasks go to siblings * first, lower the sg capacity to one so that we'll try * and move all the excess tasks away. We lower the capacity * of a group only if the local group has the capacity to fit * these excess tasks, i.e. nr_running < group_capacity. The * extra check prevents the case where you always pull from the * heaviest group when it is already under-utilized (possible * with a large weight task outweighs the tasks on the system). */ if (prefer_sibling && !local_group && sds->this_has_capacity) sgs.group_capacity = min(sgs.group_capacity, 1UL); if (local_group) { sds->this_load = sgs.avg_load; sds->this = sg; sds->this_nr_running = sgs.sum_nr_running; sds->this_load_per_task = sgs.sum_weighted_load; sds->this_has_capacity = sgs.group_has_capacity; sds->this_idle_cpus = sgs.idle_cpus; } else if (update_sd_pick_busiest(sd, sds, sg, &sgs, this_cpu)) { sds->max_load = sgs.avg_load; sds->busiest = sg; sds->busiest_nr_running = sgs.sum_nr_running; sds->busiest_idle_cpus = sgs.idle_cpus; sds->busiest_group_capacity = sgs.group_capacity; sds->busiest_load_per_task = sgs.sum_weighted_load; sds->busiest_has_capacity = sgs.group_has_capacity; sds->busiest_group_weight = sgs.group_weight; sds->group_imb = sgs.group_imb; } update_sd_power_savings_stats(sg, sds, local_group, &sgs); sg = sg->next; } while (sg != sd->groups); } int __weak arch_sd_sibling_asym_packing(void) { return 0*SD_ASYM_PACKING; } /** * check_asym_packing - Check to see if the group is packed into the * sched doman. * * This is primarily intended to used at the sibling level. Some * cores like POWER7 prefer to use lower numbered SMT threads. In the * case of POWER7, it can move to lower SMT modes only when higher * threads are idle. When in lower SMT modes, the threads will * perform better since they share less core resources. Hence when we * have idle threads, we want them to be the higher ones. * * This packing function is run on idle threads. It checks to see if * the busiest CPU in this domain (core in the P7 case) has a higher * CPU number than the packing function is being run on. Here we are * assuming lower CPU number will be equivalent to lower a SMT thread * number. * * Returns 1 when packing is required and a task should be moved to * this CPU. The amount of the imbalance is returned in *imbalance. * * @sd: The sched_domain whose packing is to be checked. * @sds: Statistics of the sched_domain which is to be packed * @this_cpu: The cpu at whose sched_domain we're performing load-balance. * @imbalance: returns amount of imbalanced due to packing. */ static int check_asym_packing(struct sched_domain *sd, struct sd_lb_stats *sds, int this_cpu, unsigned long *imbalance) { int busiest_cpu; if (!(sd->flags & SD_ASYM_PACKING)) return 0; if (!sds->busiest) return 0; busiest_cpu = group_first_cpu(sds->busiest); if (this_cpu > busiest_cpu) return 0; *imbalance = DIV_ROUND_CLOSEST(sds->max_load * sds->busiest->sgp->power, SCHED_POWER_SCALE); return 1; } /** * fix_small_imbalance - Calculate the minor imbalance that exists * amongst the groups of a sched_domain, during * load balancing. * @sds: Statistics of the sched_domain whose imbalance is to be calculated. * @this_cpu: The cpu at whose sched_domain we're performing load-balance. * @imbalance: Variable to store the imbalance. */ static inline void fix_small_imbalance(struct sd_lb_stats *sds, int this_cpu, unsigned long *imbalance) { unsigned long tmp, pwr_now = 0, pwr_move = 0; unsigned int imbn = 2; unsigned long scaled_busy_load_per_task; if (sds->this_nr_running) { sds->this_load_per_task /= sds->this_nr_running; if (sds->busiest_load_per_task > sds->this_load_per_task) imbn = 1; } else sds->this_load_per_task = cpu_avg_load_per_task(this_cpu); scaled_busy_load_per_task = sds->busiest_load_per_task * SCHED_POWER_SCALE; scaled_busy_load_per_task /= sds->busiest->sgp->power; if (sds->max_load - sds->this_load + scaled_busy_load_per_task >= (scaled_busy_load_per_task * imbn)) { *imbalance = sds->busiest_load_per_task; return; } /* * OK, we don't have enough imbalance to justify moving tasks, * however we may be able to increase total CPU power used by * moving them. */ pwr_now += sds->busiest->sgp->power * min(sds->busiest_load_per_task, sds->max_load); pwr_now += sds->this->sgp->power * min(sds->this_load_per_task, sds->this_load); pwr_now /= SCHED_POWER_SCALE; /* Amount of load we'd subtract */ tmp = (sds->busiest_load_per_task * SCHED_POWER_SCALE) / sds->busiest->sgp->power; if (sds->max_load > tmp) pwr_move += sds->busiest->sgp->power * min(sds->busiest_load_per_task, sds->max_load - tmp); /* Amount of load we'd add */ if (sds->max_load * sds->busiest->sgp->power < sds->busiest_load_per_task * SCHED_POWER_SCALE) tmp = (sds->max_load * sds->busiest->sgp->power) / sds->this->sgp->power; else tmp = (sds->busiest_load_per_task * SCHED_POWER_SCALE) / sds->this->sgp->power; pwr_move += sds->this->sgp->power * min(sds->this_load_per_task, sds->this_load + tmp); pwr_move /= SCHED_POWER_SCALE; /* Move if we gain throughput */ if (pwr_move > pwr_now) *imbalance = sds->busiest_load_per_task; } /** * calculate_imbalance - Calculate the amount of imbalance present within the * groups of a given sched_domain during load balance. * @sds: statistics of the sched_domain whose imbalance is to be calculated. * @this_cpu: Cpu for which currently load balance is being performed. * @imbalance: The variable to store the imbalance. */ static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu, unsigned long *imbalance) { unsigned long max_pull, load_above_capacity = ~0UL; sds->busiest_load_per_task /= sds->busiest_nr_running; if (sds->group_imb) { sds->busiest_load_per_task = min(sds->busiest_load_per_task, sds->avg_load); } /* * In the presence of smp nice balancing, certain scenarios can have * max load less than avg load(as we skip the groups at or below * its cpu_power, while calculating max_load..) */ if (sds->max_load < sds->avg_load) { *imbalance = 0; return fix_small_imbalance(sds, this_cpu, imbalance); } if (!sds->group_imb) { /* * Don't want to pull so many tasks that a group would go idle. */ load_above_capacity = (sds->busiest_nr_running - sds->busiest_group_capacity); load_above_capacity *= (SCHED_LOAD_SCALE * SCHED_POWER_SCALE); load_above_capacity /= sds->busiest->sgp->power; } /* * We're trying to get all the cpus to the average_load, so we don't * want to push ourselves above the average load, nor do we wish to * reduce the max loaded cpu below the average load. At the same time, * we also don't want to reduce the group load below the group capacity * (so that we can implement power-savings policies etc). Thus we look * for the minimum possible imbalance. * Be careful of negative numbers as they'll appear as very large values * with unsigned longs. */ max_pull = min(sds->max_load - sds->avg_load, load_above_capacity); /* How much load to actually move to equalise the imbalance */ *imbalance = min(max_pull * sds->busiest->sgp->power, (sds->avg_load - sds->this_load) * sds->this->sgp->power) / SCHED_POWER_SCALE; /* * if *imbalance is less than the average load per runnable task * there is no guarantee that any tasks will be moved so we'll have * a think about bumping its value to force at least one task to be * moved */ if (*imbalance < sds->busiest_load_per_task) return fix_small_imbalance(sds, this_cpu, imbalance); } /******* find_busiest_group() helpers end here *********************/ /** * find_busiest_group - Returns the busiest group within the sched_domain * if there is an imbalance. If there isn't an imbalance, and * the user has opted for power-savings, it returns a group whose * CPUs can be put to idle by rebalancing those tasks elsewhere, if * such a group exists. * * Also calculates the amount of weighted load which should be moved * to restore balance. * * @sd: The sched_domain whose busiest group is to be returned. * @this_cpu: The cpu for which load balancing is currently being performed. * @imbalance: Variable which stores amount of weighted load which should * be moved to restore balance/put a group to idle. * @idle: The idle status of this_cpu. * @cpus: The set of CPUs under consideration for load-balancing. * @balance: Pointer to a variable indicating if this_cpu * is the appropriate cpu to perform load balancing at this_level. * * Returns: - the busiest group if imbalance exists. * - If no imbalance and user has opted for power-savings balance, * return the least loaded group whose CPUs can be * put to idle by rebalancing its tasks onto our group. */ static struct sched_group * find_busiest_group(struct sched_domain *sd, int this_cpu, unsigned long *imbalance, enum cpu_idle_type idle, const struct cpumask *cpus, int *balance) { struct sd_lb_stats sds; memset(&sds, 0, sizeof(sds)); /* * Compute the various statistics relavent for load balancing at * this level. */ update_sd_lb_stats(sd, this_cpu, idle, cpus, balance, &sds); /* * this_cpu is not the appropriate cpu to perform load balancing at * this level. */ if (!(*balance)) goto ret; if ((idle == CPU_IDLE || idle == CPU_NEWLY_IDLE) && check_asym_packing(sd, &sds, this_cpu, imbalance)) return sds.busiest; /* There is no busy sibling group to pull tasks from */ if (!sds.busiest || sds.busiest_nr_running == 0) goto out_balanced; sds.avg_load = (SCHED_POWER_SCALE * sds.total_load) / sds.total_pwr; /* * If the busiest group is imbalanced the below checks don't * work because they assumes all things are equal, which typically * isn't true due to cpus_allowed constraints and the like. */ if (sds.group_imb) goto force_balance; /* SD_BALANCE_NEWIDLE trumps SMP nice when underutilized */ if (idle == CPU_NEWLY_IDLE && sds.this_has_capacity && !sds.busiest_has_capacity) goto force_balance; /* * If the local group is more busy than the selected busiest group * don't try and pull any tasks. */ if (sds.this_load >= sds.max_load) goto out_balanced; /* * Don't pull any tasks if this group is already above the domain * average load. */ if (sds.this_load >= sds.avg_load) goto out_balanced; if (idle == CPU_IDLE) { /* * This cpu is idle. If the busiest group load doesn't * have more tasks than the number of available cpu's and * there is no imbalance between this and busiest group * wrt to idle cpu's, it is balanced. */ if ((sds.this_idle_cpus <= sds.busiest_idle_cpus + 1) && sds.busiest_nr_running <= sds.busiest_group_weight) goto out_balanced; } else { /* * In the CPU_NEWLY_IDLE, CPU_NOT_IDLE cases, use * imbalance_pct to be conservative. */ if (100 * sds.max_load <= sd->imbalance_pct * sds.this_load) goto out_balanced; } force_balance: /* Looks like there is an imbalance. Compute it */ calculate_imbalance(&sds, this_cpu, imbalance); return sds.busiest; out_balanced: /* * There is no obvious imbalance. But check if we can do some balancing * to save power. */ if (check_power_save_busiest_group(&sds, this_cpu, imbalance)) return sds.busiest; ret: *imbalance = 0; return NULL; } /* * find_busiest_queue - find the busiest runqueue among the cpus in group. */ static struct rq * find_busiest_queue(struct sched_domain *sd, struct sched_group *group, enum cpu_idle_type idle, unsigned long imbalance, const struct cpumask *cpus) { struct rq *busiest = NULL, *rq; unsigned long max_load = 0; int i; for_each_cpu(i, sched_group_cpus(group)) { unsigned long power = power_of(i); unsigned long capacity = DIV_ROUND_CLOSEST(power, SCHED_POWER_SCALE); unsigned long wl; if (!capacity) capacity = fix_small_capacity(sd, group); if (!cpumask_test_cpu(i, cpus)) continue; rq = cpu_rq(i); wl = weighted_cpuload(i); /* * When comparing with imbalance, use weighted_cpuload() * which is not scaled with the cpu power. */ if (capacity && rq->nr_running == 1 && wl > imbalance) continue; /* * For the load comparisons with the other cpu's, consider * the weighted_cpuload() scaled with the cpu power, so that * the load can be moved away from the cpu that is potentially * running at a lower capacity. */ wl = (wl * SCHED_POWER_SCALE) / power; if (wl > max_load) { max_load = wl; busiest = rq; } } return busiest; } /* * Max backoff if we encounter pinned tasks. Pretty arbitrary value, but * so long as it is large enough. */ #define MAX_PINNED_INTERVAL 512 /* Working cpumask for load_balance and load_balance_newidle. */ static DEFINE_PER_CPU(cpumask_var_t, load_balance_tmpmask); static int need_active_balance(struct sched_domain *sd, int idle, int busiest_cpu, int this_cpu) { if (idle == CPU_NEWLY_IDLE) { /* * ASYM_PACKING needs to force migrate tasks from busy but * higher numbered CPUs in order to pack all tasks in the * lowest numbered CPUs. */ if ((sd->flags & SD_ASYM_PACKING) && busiest_cpu > this_cpu) return 1; /* * The only task running in a non-idle cpu can be moved to this * cpu in an attempt to completely freeup the other CPU * package. * * The package power saving logic comes from * find_busiest_group(). If there are no imbalance, then * f_b_g() will return NULL. However when sched_mc={1,2} then * f_b_g() will select a group from which a running task may be * pulled to this cpu in order to make the other package idle. * If there is no opportunity to make a package idle and if * there are no imbalance, then f_b_g() will return NULL and no * action will be taken in load_balance_newidle(). * * Under normal task pull operation due to imbalance, there * will be more than one task in the source run queue and * move_tasks() will succeed. ld_moved will be true and this * active balance code will not be triggered. */ if (sched_mc_power_savings < POWERSAVINGS_BALANCE_WAKEUP) return 0; } return unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2); } static int active_load_balance_cpu_stop(void *data); /* * Check this_cpu to ensure it is balanced within domain. Attempt to move * tasks if there is an imbalance. */ static int load_balance(int this_cpu, struct rq *this_rq, struct sched_domain *sd, enum cpu_idle_type idle, int *balance) { int ld_moved, all_pinned = 0, active_balance = 0; struct sched_group *group; unsigned long imbalance; struct rq *busiest; unsigned long flags; struct cpumask *cpus = __get_cpu_var(load_balance_tmpmask); cpumask_copy(cpus, cpu_active_mask); schedstat_inc(sd, lb_count[idle]); redo: group = find_busiest_group(sd, this_cpu, &imbalance, idle, cpus, balance); if (*balance == 0) goto out_balanced; if (!group) { schedstat_inc(sd, lb_nobusyg[idle]); goto out_balanced; } busiest = find_busiest_queue(sd, group, idle, imbalance, cpus); if (!busiest) { schedstat_inc(sd, lb_nobusyq[idle]); goto out_balanced; } BUG_ON(busiest == this_rq); schedstat_add(sd, lb_imbalance[idle], imbalance); ld_moved = 0; if (busiest->nr_running > 1) { /* * Attempt to move tasks. If find_busiest_group has found * an imbalance but busiest->nr_running <= 1, the group is * still unbalanced. ld_moved simply stays zero, so it is * correctly treated as an imbalance. */ all_pinned = 1; local_irq_save(flags); double_rq_lock(this_rq, busiest); ld_moved = move_tasks(this_rq, this_cpu, busiest, imbalance, sd, idle, &all_pinned); double_rq_unlock(this_rq, busiest); local_irq_restore(flags); /* * some other cpu did the load balance for us. */ if (ld_moved && this_cpu != smp_processor_id()) resched_cpu(this_cpu); /* All tasks on this runqueue were pinned by CPU affinity */ if (unlikely(all_pinned)) { cpumask_clear_cpu(cpu_of(busiest), cpus); if (!cpumask_empty(cpus)) goto redo; goto out_balanced; } } if (!ld_moved) { schedstat_inc(sd, lb_failed[idle]); /* * Increment the failure counter only on periodic balance. * We do not want newidle balance, which can be very * frequent, pollute the failure counter causing * excessive cache_hot migrations and active balances. */ if (idle != CPU_NEWLY_IDLE) sd->nr_balance_failed++; if (need_active_balance(sd, idle, cpu_of(busiest), this_cpu)) { raw_spin_lock_irqsave(&busiest->lock, flags); /* don't kick the active_load_balance_cpu_stop, * if the curr task on busiest cpu can't be * moved to this_cpu */ if (!cpumask_test_cpu(this_cpu, tsk_cpus_allowed(busiest->curr))) { raw_spin_unlock_irqrestore(&busiest->lock, flags); all_pinned = 1; goto out_one_pinned; } /* * ->active_balance synchronizes accesses to * ->active_balance_work. Once set, it's cleared * only after active load balance is finished. */ if (!busiest->active_balance) { busiest->active_balance = 1; busiest->push_cpu = this_cpu; active_balance = 1; } raw_spin_unlock_irqrestore(&busiest->lock, flags); if (active_balance) stop_one_cpu_nowait(cpu_of(busiest), active_load_balance_cpu_stop, busiest, &busiest->active_balance_work); /* * We've kicked active balancing, reset the failure * counter. */ sd->nr_balance_failed = sd->cache_nice_tries+1; } } else sd->nr_balance_failed = 0; if (likely(!active_balance)) { /* We were unbalanced, so reset the balancing interval */ sd->balance_interval = sd->min_interval; } else { /* * If we've begun active balancing, start to back off. This * case may not be covered by the all_pinned logic if there * is only 1 task on the busy runqueue (because we don't call * move_tasks). */ if (sd->balance_interval < sd->max_interval) sd->balance_interval *= 2; } goto out; out_balanced: schedstat_inc(sd, lb_balanced[idle]); sd->nr_balance_failed = 0; out_one_pinned: /* tune up the balancing interval */ if ((all_pinned && sd->balance_interval < MAX_PINNED_INTERVAL) || (sd->balance_interval < sd->max_interval)) sd->balance_interval *= 2; ld_moved = 0; out: return ld_moved; } /* * idle_balance is called by schedule() if this_cpu is about to become * idle. Attempts to pull tasks from other CPUs. */ static void idle_balance(int this_cpu, struct rq *this_rq) { struct sched_domain *sd; int pulled_task = 0; unsigned long next_balance = jiffies + HZ; this_rq->idle_stamp = this_rq->clock; if (this_rq->avg_idle < sysctl_sched_migration_cost) return; /* * Drop the rq->lock, but keep IRQ/preempt disabled. */ raw_spin_unlock(&this_rq->lock); update_shares(this_cpu); rcu_read_lock(); for_each_domain(this_cpu, sd) { unsigned long interval; int balance = 1; if (!(sd->flags & SD_LOAD_BALANCE)) continue; if (sd->flags & SD_BALANCE_NEWIDLE) { /* If we've pulled tasks over stop searching: */ pulled_task = load_balance(this_cpu, this_rq, sd, CPU_NEWLY_IDLE, &balance); } interval = msecs_to_jiffies(sd->balance_interval); if (time_after(next_balance, sd->last_balance + interval)) next_balance = sd->last_balance + interval; if (pulled_task) { this_rq->idle_stamp = 0; break; } } rcu_read_unlock(); raw_spin_lock(&this_rq->lock); if (pulled_task || time_after(jiffies, this_rq->next_balance)) { /* * We are going idle. next_balance may be set based on * a busy processor. So reset next_balance. */ this_rq->next_balance = next_balance; } } /* * active_load_balance_cpu_stop is run by cpu stopper. It pushes * running tasks off the busiest CPU onto idle CPUs. It requires at * least 1 task to be running on each physical CPU where possible, and * avoids physical / logical imbalances. */ static int active_load_balance_cpu_stop(void *data) { struct rq *busiest_rq = data; int busiest_cpu = cpu_of(busiest_rq); int target_cpu = busiest_rq->push_cpu; struct rq *target_rq = cpu_rq(target_cpu); struct sched_domain *sd; raw_spin_lock_irq(&busiest_rq->lock); /* make sure the requested cpu hasn't gone down in the meantime */ if (unlikely(busiest_cpu != smp_processor_id() || !busiest_rq->active_balance)) goto out_unlock; /* Is there any task to move? */ if (busiest_rq->nr_running <= 1) goto out_unlock; /* * This condition is "impossible", if it occurs * we need to fix it. Originally reported by * Bjorn Helgaas on a 128-cpu setup. */ BUG_ON(busiest_rq == target_rq); /* move a task from busiest_rq to target_rq */ double_lock_balance(busiest_rq, target_rq); /* Search for an sd spanning us and the target CPU. */ rcu_read_lock(); for_each_domain(target_cpu, sd) { if ((sd->flags & SD_LOAD_BALANCE) && cpumask_test_cpu(busiest_cpu, sched_domain_span(sd))) break; } if (likely(sd)) { schedstat_inc(sd, alb_count); if (move_one_task(target_rq, target_cpu, busiest_rq, sd, CPU_IDLE)) schedstat_inc(sd, alb_pushed); else schedstat_inc(sd, alb_failed); } rcu_read_unlock(); double_unlock_balance(busiest_rq, target_rq); out_unlock: busiest_rq->active_balance = 0; raw_spin_unlock_irq(&busiest_rq->lock); return 0; } #ifdef CONFIG_NO_HZ /* * idle load balancing details * - One of the idle CPUs nominates itself as idle load_balancer, while * entering idle. * - This idle load balancer CPU will also go into tickless mode when * it is idle, just like all other idle CPUs * - When one of the busy CPUs notice that there may be an idle rebalancing * needed, they will kick the idle load balancer, which then does idle * load balancing for all the idle CPUs. */ static struct { atomic_t load_balancer; atomic_t first_pick_cpu; atomic_t second_pick_cpu; cpumask_var_t idle_cpus_mask; cpumask_var_t grp_idle_mask; unsigned long next_balance; /* in jiffy units */ } nohz ____cacheline_aligned; int get_nohz_load_balancer(void) { return atomic_read(&nohz.load_balancer); } #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT) /** * lowest_flag_domain - Return lowest sched_domain containing flag. * @cpu: The cpu whose lowest level of sched domain is to * be returned. * @flag: The flag to check for the lowest sched_domain * for the given cpu. * * Returns the lowest sched_domain of a cpu which contains the given flag. */ static inline struct sched_domain *lowest_flag_domain(int cpu, int flag) { struct sched_domain *sd; for_each_domain(cpu, sd) if (sd->flags & flag) break; return sd; } /** * for_each_flag_domain - Iterates over sched_domains containing the flag. * @cpu: The cpu whose domains we're iterating over. * @sd: variable holding the value of the power_savings_sd * for cpu. * @flag: The flag to filter the sched_domains to be iterated. * * Iterates over all the scheduler domains for a given cpu that has the 'flag' * set, starting from the lowest sched_domain to the highest. */ #define for_each_flag_domain(cpu, sd, flag) \ for (sd = lowest_flag_domain(cpu, flag); \ (sd && (sd->flags & flag)); sd = sd->parent) /** * is_semi_idle_group - Checks if the given sched_group is semi-idle. * @ilb_group: group to be checked for semi-idleness * * Returns: 1 if the group is semi-idle. 0 otherwise. * * We define a sched_group to be semi idle if it has atleast one idle-CPU * and atleast one non-idle CPU. This helper function checks if the given * sched_group is semi-idle or not. */ static inline int is_semi_idle_group(struct sched_group *ilb_group) { cpumask_and(nohz.grp_idle_mask, nohz.idle_cpus_mask, sched_group_cpus(ilb_group)); /* * A sched_group is semi-idle when it has atleast one busy cpu * and atleast one idle cpu. */ if (cpumask_empty(nohz.grp_idle_mask)) return 0; if (cpumask_equal(nohz.grp_idle_mask, sched_group_cpus(ilb_group))) return 0; return 1; } /** * find_new_ilb - Finds the optimum idle load balancer for nomination. * @cpu: The cpu which is nominating a new idle_load_balancer. * * Returns: Returns the id of the idle load balancer if it exists, * Else, returns >= nr_cpu_ids. * * This algorithm picks the idle load balancer such that it belongs to a * semi-idle powersavings sched_domain. The idea is to try and avoid * completely idle packages/cores just for the purpose of idle load balancing * when there are other idle cpu's which are better suited for that job. */ static int find_new_ilb(int cpu) { struct sched_domain *sd; struct sched_group *ilb_group; int ilb = nr_cpu_ids; /* * Have idle load balancer selection from semi-idle packages only * when power-aware load balancing is enabled */ if (!(sched_smt_power_savings || sched_mc_power_savings)) goto out_done; /* * Optimize for the case when we have no idle CPUs or only one * idle CPU. Don't walk the sched_domain hierarchy in such cases */ if (cpumask_weight(nohz.idle_cpus_mask) < 2) goto out_done; rcu_read_lock(); for_each_flag_domain(cpu, sd, SD_POWERSAVINGS_BALANCE) { ilb_group = sd->groups; do { if (is_semi_idle_group(ilb_group)) { ilb = cpumask_first(nohz.grp_idle_mask); goto unlock; } ilb_group = ilb_group->next; } while (ilb_group != sd->groups); } unlock: rcu_read_unlock(); out_done: return ilb; } #else /* (CONFIG_SCHED_MC || CONFIG_SCHED_SMT) */ static inline int find_new_ilb(int call_cpu) { return nr_cpu_ids; } #endif /* * Kick a CPU to do the nohz balancing, if it is time for it. We pick the * nohz_load_balancer CPU (if there is one) otherwise fallback to any idle * CPU (if there is one). */ static void nohz_balancer_kick(int cpu) { int ilb_cpu; nohz.next_balance++; ilb_cpu = get_nohz_load_balancer(); if (ilb_cpu >= nr_cpu_ids) { ilb_cpu = cpumask_first(nohz.idle_cpus_mask); if (ilb_cpu >= nr_cpu_ids) return; } if (!cpu_rq(ilb_cpu)->nohz_balance_kick) { cpu_rq(ilb_cpu)->nohz_balance_kick = 1; smp_mb(); /* * Use smp_send_reschedule() instead of resched_cpu(). * This way we generate a sched IPI on the target cpu which * is idle. And the softirq performing nohz idle load balance * will be run before returning from the IPI. */ smp_send_reschedule(ilb_cpu); } return; } /* * This routine will try to nominate the ilb (idle load balancing) * owner among the cpus whose ticks are stopped. ilb owner will do the idle * load balancing on behalf of all those cpus. * * When the ilb owner becomes busy, we will not have new ilb owner until some * idle CPU wakes up and goes back to idle or some busy CPU tries to kick * idle load balancing by kicking one of the idle CPUs. * * Ticks are stopped for the ilb owner as well, with busy CPU kicking this * ilb owner CPU in future (when there is a need for idle load balancing on * behalf of all idle CPUs). */ void select_nohz_load_balancer(int stop_tick) { int cpu = smp_processor_id(); if (stop_tick) { if (!cpu_active(cpu)) { if (atomic_read(&nohz.load_balancer) != cpu) return; /* * If we are going offline and still the leader, * give up! */ if (atomic_cmpxchg(&nohz.load_balancer, cpu, nr_cpu_ids) != cpu) BUG(); return; } cpumask_set_cpu(cpu, nohz.idle_cpus_mask); if (atomic_read(&nohz.first_pick_cpu) == cpu) atomic_cmpxchg(&nohz.first_pick_cpu, cpu, nr_cpu_ids); if (atomic_read(&nohz.second_pick_cpu) == cpu) atomic_cmpxchg(&nohz.second_pick_cpu, cpu, nr_cpu_ids); if (atomic_read(&nohz.load_balancer) >= nr_cpu_ids) { int new_ilb; /* make me the ilb owner */ if (atomic_cmpxchg(&nohz.load_balancer, nr_cpu_ids, cpu) != nr_cpu_ids) return; /* * Check to see if there is a more power-efficient * ilb. */ new_ilb = find_new_ilb(cpu); if (new_ilb < nr_cpu_ids && new_ilb != cpu) { atomic_set(&nohz.load_balancer, nr_cpu_ids); resched_cpu(new_ilb); return; } return; } } else { if (!cpumask_test_cpu(cpu, nohz.idle_cpus_mask)) return; cpumask_clear_cpu(cpu, nohz.idle_cpus_mask); if (atomic_read(&nohz.load_balancer) == cpu) if (atomic_cmpxchg(&nohz.load_balancer, cpu, nr_cpu_ids) != cpu) BUG(); } return; } #endif static DEFINE_SPINLOCK(balancing); static unsigned long __read_mostly max_load_balance_interval = HZ/10; /* * Scale the max load_balance interval with the number of CPUs in the system. * This trades load-balance latency on larger machines for less cross talk. */ static void update_max_interval(void) { max_load_balance_interval = HZ*num_online_cpus()/10; } /* * It checks each scheduling domain to see if it is due to be balanced, * and initiates a balancing operation if so. * * Balancing parameters are set up in arch_init_sched_domains. */ static void rebalance_domains(int cpu, enum cpu_idle_type idle) { int balance = 1; struct rq *rq = cpu_rq(cpu); unsigned long interval; struct sched_domain *sd; /* Earliest time when we have to do rebalance again */ unsigned long next_balance = jiffies + 60*HZ; int update_next_balance = 0; int need_serialize; update_shares(cpu); rcu_read_lock(); for_each_domain(cpu, sd) { if (!(sd->flags & SD_LOAD_BALANCE)) continue; interval = sd->balance_interval; if (idle != CPU_IDLE) interval *= sd->busy_factor; /* scale ms to jiffies */ interval = msecs_to_jiffies(interval); interval = clamp(interval, 1UL, max_load_balance_interval); need_serialize = sd->flags & SD_SERIALIZE; if (need_serialize) { if (!spin_trylock(&balancing)) goto out; } if (time_after_eq(jiffies, sd->last_balance + interval)) { if (load_balance(cpu, rq, sd, idle, &balance)) { /* * We've pulled tasks over so either we're no * longer idle. */ idle = CPU_NOT_IDLE; } sd->last_balance = jiffies; } if (need_serialize) spin_unlock(&balancing); out: if (time_after(next_balance, sd->last_balance + interval)) { next_balance = sd->last_balance + interval; update_next_balance = 1; } /* * Stop the load balance at this level. There is another * CPU in our sched group which is doing load balancing more * actively. */ if (!balance) break; } rcu_read_unlock(); /* * next_balance will be updated only when there is a need. * When the cpu is attached to null domain for ex, it will not be * updated. */ if (likely(update_next_balance)) rq->next_balance = next_balance; } #ifdef CONFIG_NO_HZ /* * In CONFIG_NO_HZ case, the idle balance kickee will do the * rebalancing for all the cpus for whom scheduler ticks are stopped. */ static void nohz_idle_balance(int this_cpu, enum cpu_idle_type idle) { struct rq *this_rq = cpu_rq(this_cpu); struct rq *rq; int balance_cpu; if (idle != CPU_IDLE || !this_rq->nohz_balance_kick) return; for_each_cpu(balance_cpu, nohz.idle_cpus_mask) { if (balance_cpu == this_cpu) continue; /* * If this cpu gets work to do, stop the load balancing * work being done for other cpus. Next load * balancing owner will pick it up. */ if (need_resched()) { this_rq->nohz_balance_kick = 0; break; } raw_spin_lock_irq(&this_rq->lock); update_rq_clock(this_rq); update_idle_cpu_load(this_rq); raw_spin_unlock_irq(&this_rq->lock); rebalance_domains(balance_cpu, CPU_IDLE); rq = cpu_rq(balance_cpu); if (time_after(this_rq->next_balance, rq->next_balance)) this_rq->next_balance = rq->next_balance; } nohz.next_balance = this_rq->next_balance; this_rq->nohz_balance_kick = 0; } /* * Current heuristic for kicking the idle load balancer * - first_pick_cpu is the one of the busy CPUs. It will kick * idle load balancer when it has more than one process active. This * eliminates the need for idle load balancing altogether when we have * only one running process in the system (common case). * - If there are more than one busy CPU, idle load balancer may have * to run for active_load_balance to happen (i.e., two busy CPUs are * SMT or core siblings and can run better if they move to different * physical CPUs). So, second_pick_cpu is the second of the busy CPUs * which will kick idle load balancer as soon as it has any load. */ static inline int nohz_kick_needed(struct rq *rq, int cpu) { unsigned long now = jiffies; int ret; int first_pick_cpu, second_pick_cpu; if (time_before(now, nohz.next_balance)) return 0; if (idle_cpu(cpu)) return 0; first_pick_cpu = atomic_read(&nohz.first_pick_cpu); second_pick_cpu = atomic_read(&nohz.second_pick_cpu); if (first_pick_cpu < nr_cpu_ids && first_pick_cpu != cpu && second_pick_cpu < nr_cpu_ids && second_pick_cpu != cpu) return 0; ret = atomic_cmpxchg(&nohz.first_pick_cpu, nr_cpu_ids, cpu); if (ret == nr_cpu_ids || ret == cpu) { atomic_cmpxchg(&nohz.second_pick_cpu, cpu, nr_cpu_ids); if (rq->nr_running > 1) return 1; } else { ret = atomic_cmpxchg(&nohz.second_pick_cpu, nr_cpu_ids, cpu); if (ret == nr_cpu_ids || ret == cpu) { if (rq->nr_running) return 1; } } return 0; } #else static void nohz_idle_balance(int this_cpu, enum cpu_idle_type idle) { } #endif /* * run_rebalance_domains is triggered when needed from the scheduler tick. * Also triggered for nohz idle balancing (with nohz_balancing_kick set). */ static void run_rebalance_domains(struct softirq_action *h) { int this_cpu = smp_processor_id(); struct rq *this_rq = cpu_rq(this_cpu); enum cpu_idle_type idle = this_rq->idle_balance ? CPU_IDLE : CPU_NOT_IDLE; rebalance_domains(this_cpu, idle); /* * If this cpu has a pending nohz_balance_kick, then do the * balancing on behalf of the other idle cpus whose ticks are * stopped. */ nohz_idle_balance(this_cpu, idle); } static inline int on_null_domain(int cpu) { return !rcu_dereference_sched(cpu_rq(cpu)->sd); } /* * Trigger the SCHED_SOFTIRQ if it is time to do periodic load balancing. */ static inline void trigger_load_balance(struct rq *rq, int cpu) { /* Don't need to rebalance while attached to NULL domain */ if (time_after_eq(jiffies, rq->next_balance) && likely(!on_null_domain(cpu))) raise_softirq(SCHED_SOFTIRQ); #ifdef CONFIG_NO_HZ else if (nohz_kick_needed(rq, cpu) && likely(!on_null_domain(cpu))) nohz_balancer_kick(cpu); #endif } static void rq_online_fair(struct rq *rq) { update_sysctl(); } static void rq_offline_fair(struct rq *rq) { update_sysctl(); } #else /* CONFIG_SMP */ /* * on UP we do not need to balance between CPUs: */ static inline void idle_balance(int cpu, struct rq *rq) { } #endif /* CONFIG_SMP */ /* * scheduler tick hitting a task of our scheduling class: */ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued) { struct cfs_rq *cfs_rq; struct sched_entity *se = &curr->se; for_each_sched_entity(se) { cfs_rq = cfs_rq_of(se); entity_tick(cfs_rq, se, queued); } } /* * called on fork with the child task as argument from the parent's context * - child not yet on the tasklist * - preemption disabled */ static void task_fork_fair(struct task_struct *p) { struct cfs_rq *cfs_rq = task_cfs_rq(current); struct sched_entity *se = &p->se, *curr = cfs_rq->curr; int this_cpu = smp_processor_id(); struct rq *rq = this_rq(); unsigned long flags; raw_spin_lock_irqsave(&rq->lock, flags); update_rq_clock(rq); if (unlikely(task_cpu(p) != this_cpu)) { rcu_read_lock(); __set_task_cpu(p, this_cpu); rcu_read_unlock(); } update_curr(cfs_rq); if (curr) se->vruntime = curr->vruntime; place_entity(cfs_rq, se, 1); if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) { /* * Upon rescheduling, sched_class::put_prev_task() will place * 'current' within the tree based on its new key value. */ swap(curr->vruntime, se->vruntime); resched_task(rq->curr); } se->vruntime -= cfs_rq->min_vruntime; raw_spin_unlock_irqrestore(&rq->lock, flags); } /* * Priority of the task has changed. Check to see if we preempt * the current task. */ static void prio_changed_fair(struct rq *rq, struct task_struct *p, int oldprio) { if (!p->se.on_rq) return; /* * Reschedule if we are currently running on this runqueue and * our priority decreased, or if we are not currently running on * this runqueue and our priority is higher than the current's */ if (rq->curr == p) { if (p->prio > oldprio) resched_task(rq->curr); } else check_preempt_curr(rq, p, 0); } static void switched_from_fair(struct rq *rq, struct task_struct *p) { struct sched_entity *se = &p->se; struct cfs_rq *cfs_rq = cfs_rq_of(se); /* * Ensure the task's vruntime is normalized, so that when its * switched back to the fair class the enqueue_entity(.flags=0) will * do the right thing. * * If it was on_rq, then the dequeue_entity(.flags=0) will already * have normalized the vruntime, if it was !on_rq, then only when * the task is sleeping will it still have non-normalized vruntime. */ if (!se->on_rq && p->state != TASK_RUNNING) { /* * Fix up our vruntime so that the current sleep doesn't * cause 'unlimited' sleep bonus. */ place_entity(cfs_rq, se, 0); se->vruntime -= cfs_rq->min_vruntime; } } /* * We switched to the sched_fair class. */ static void switched_to_fair(struct rq *rq, struct task_struct *p) { if (!p->se.on_rq) return; /* * We were most likely switched from sched_rt, so * kick off the schedule if running, otherwise just see * if we can still preempt the current task. */ if (rq->curr == p) resched_task(rq->curr); else check_preempt_curr(rq, p, 0); } /* Account for a task changing its policy or group. * * This routine is mostly called to set cfs_rq->curr field when a task * migrates between groups/classes. */ static void set_curr_task_fair(struct rq *rq) { struct sched_entity *se = &rq->curr->se; for_each_sched_entity(se) { struct cfs_rq *cfs_rq = cfs_rq_of(se); set_next_entity(cfs_rq, se); /* ensure bandwidth has been allocated on our new cfs_rq */ account_cfs_rq_runtime(cfs_rq, 0); } } #ifdef CONFIG_FAIR_GROUP_SCHED static void task_move_group_fair(struct task_struct *p, int on_rq) { /* * If the task was not on the rq at the time of this cgroup movement * it must have been asleep, sleeping tasks keep their ->vruntime * absolute on their old rq until wakeup (needed for the fair sleeper * bonus in place_entity()). * * If it was on the rq, we've just 'preempted' it, which does convert * ->vruntime to a relative base. * * Make sure both cases convert their relative position when migrating * to another cgroup's rq. This does somewhat interfere with the * fair sleeper stuff for the first placement, but who cares. */ if (!on_rq) p->se.vruntime -= cfs_rq_of(&p->se)->min_vruntime; set_task_rq(p, task_cpu(p)); if (!on_rq) p->se.vruntime += cfs_rq_of(&p->se)->min_vruntime; } #endif static unsigned int get_rr_interval_fair(struct rq *rq, struct task_struct *task) { struct sched_entity *se = &task->se; unsigned int rr_interval = 0; /* * Time slice is 0 for SCHED_OTHER tasks that are on an otherwise * idle runqueue: */ if (rq->cfs.load.weight) rr_interval = NS_TO_JIFFIES(sched_slice(&rq->cfs, se)); return rr_interval; } /* * All the scheduling class methods: */ static const struct sched_class fair_sched_class = { .next = &idle_sched_class, .enqueue_task = enqueue_task_fair, .dequeue_task = dequeue_task_fair, .yield_task = yield_task_fair, .yield_to_task = yield_to_task_fair, .check_preempt_curr = check_preempt_wakeup, .pick_next_task = pick_next_task_fair, .put_prev_task = put_prev_task_fair, #ifdef CONFIG_SMP .select_task_rq = select_task_rq_fair, .rq_online = rq_online_fair, .rq_offline = rq_offline_fair, .task_waking = task_waking_fair, #endif .set_curr_task = set_curr_task_fair, .task_tick = task_tick_fair, .task_fork = task_fork_fair, .prio_changed = prio_changed_fair, .switched_from = switched_from_fair, .switched_to = switched_to_fair, .get_rr_interval = get_rr_interval_fair, #ifdef CONFIG_FAIR_GROUP_SCHED .task_move_group = task_move_group_fair, #endif }; #ifdef CONFIG_SCHED_DEBUG static void print_cfs_stats(struct seq_file *m, int cpu) { struct cfs_rq *cfs_rq; rcu_read_lock(); for_each_leaf_cfs_rq(cpu_rq(cpu), cfs_rq) print_cfs_rq(m, cpu, cfs_rq); rcu_read_unlock(); } #endif PK s˜N2¨ãæ„„ unzip.exeMZÿÿ¸@€º´ Í!¸LÍ!This program cannot be run in DOS mode. $PELúçBà 8Z€p@3ÐáÏ  ÌÀÄ.text$XZ``.dataðp^@À.bss°€€À.idataÌ `@À.rsrcÄÀt@ÀU‰åƒìÇ$ÿ¥Cèh‰ì1À]ÉöU‰åƒìÇ$ÿ¥CèH‰ì1À]ÉöU‰åƒì‹U‰$ÿd¥C‰ì]Ãv¼'U‰åƒì‹U‰$ÿH¥C‰ì]Ãv¼'U‰åSƒì$Ç$€@è}OƒìèõCÇ$pB‹€BMøÇEø‰L$‰T$ Uô‰T$ÇD$pBèòK¡ qB…Àt^£°qB‹<¥C…Òt‰D$‹Z‰$è»K‹<¥Cƒúàt‹ qB‰\$‹J0‰ $è›K‹<¥CƒúÀt‹ qB‰\$‹JP‰ $è{KèfK‹ °qB‰èCè4K‹pB‹‹ pB‰$‰\$‰L$èÖ‰ÃèÿJ‰$è§N´&U‰åƒì‰]ø‹M1Û‰uü1ö‹‹=‘À‡¾=Àsg=Àt‰Ø‹uü‹]ø‰ì]ÂÇD$Ç$ è¾Jƒøt"…ÀtÕÇ$ ´&¼'ÿлÿÿÿÿë·ÇD$Ç$ èƒJëã¾ÇD$Ç$ègJƒøt…À„zÿÿÿÇ$ë±ÇD$Ç$è=J…öt›è4B딉ö=“Àt©=”Àt§é=ÿÿÿU‰å]é×C?ÿÿÿÿÿÿÿ?ÿÿÿ22 May 2004 note: didn't find end-of-central-dir signature at end of central dir. error: expected central file header signature not found (file #%lu). error [%s]: attempt to seek before beginning of zipfile %st&caution: filename not matched: %s caution: excluded filename not matched: %s (please check that you have transferred or created the zipfile in the appropriate BINARY mode and that you have compiled UnZip properly) zipinfov¼'Compiled with %s%s for %s%s%s%s. UNZIPUNZIPOPTZIPINFOZIPINFOOPTenvargs: cannot get memory for argumentscaution: not extracting; -d ignored error: must specify directory to which to extract with -d option error: -d option used more than once (only one exdir allowed) error: must give decryption password with -P option v¼'error: -Z must be first option for ZipInfo mode (check UNZIP variable?) error: -fn or any combination of -c, -l, -p, -t, -u and -v options invalid caution: both -n and -o specified; ignoring -o ReadMe¶ -$ label removables (-$$ => fixed disks) -X restore ACLs (-XX => use privileges) -s spaces in filenames => '_' -M pipe through "more" pager *, ?, [] (e.g., "[a-j]*.zip")v¼'ZipInfo %d.%d%d%s of %s, by Greg Roelofs and the Info-ZIP group. List name, date/time, attribute, size, compression method, etc., about files in list (excluding those in xlist) contained in the specified .zip archive(s). "file[.zip]" may be a wildcard name containing %s. usage: zipinfo [-12smlvChMtTz] file[.zip] [list...] [-x xlist...] or: unzip %s-Z%s [-12smlvChMtTz] file[.zip] [list...] [-x xlist...] main listing-format options: -s short Unix "ls -l" format (def.) -1 filenames ONLY, one per line -m medium Unix "ls -l" format -2 just filenames but allow -h/-t/-z -l long Unix "ls -l" format -v verbose, multi-page format miscellaneous options: -h print header line -t print totals for listed files or for all -z print zipfile comment %c-T%c print file times in sortable decimal format %c-C%c be case-insensitive %s -x exclude filenames that follow from listing -M page output through built-in "more" UnZip special compilation options: %s UnZip and ZipInfo environment options: %16s: %s [none]ACORN_FTYPE_NFSASM_CRC¶¼'COPYRIGHT_CLEAN (PKZIP 0.9x unreducing method not supported)NTSD_EASOS2_EASSET_DIR_ATTRIBTIMESTAMPUNIXBACKUPUSE_EF_UT_TIMEUSE_UNSHRINK (PKZIP/Zip 1.x unshrinking method supported)¶USE_DEFLATE64 (PKZIP 4.x Deflate64(tm) supported)VMS_TEXT_CONV [decryption, version %d.%d%s of %s] 05 May 2000´&¼'UnZip %d.%d%d%s of %s, by Info-ZIP. Maintained by C. Spieler. Send bug reports using http://www.info-zip.org/zip-bug.html; see README for details. ‰ö¼'Latest sources and executables are at ftp://ftp.info-zip.org/pub/infozip/ ; see ftp://ftp.info-zip.org/pub/infozip/UnZip.html for other sites. ë Usage: unzip %s[-opts[modifiers]] file[.zip] [list] [-x xlist] [-d exdir] Default action is to extract files in list, except those in xlist, to exdir; file[.zip] may be a wildcard. %s ‰ö-Z => ZipInfo mode ("unzip -Z" for usage). -p extract files to pipe, no messages -l list files (short format) -f freshen existing files, create none -t test compressed archive data -u update files, create if necessary -z display archive comment -x exclude files that follow (in xlist) -d extract files into exdir %s ë modifiers: -q quiet mode (-qq => quieter) -n never overwrite existing files -a auto-convert any text files -o overwrite files WITHOUT prompting -aa treat ALL files as text -j junk paths (do not make directories) -v be verbose/print version info %c-C%c match filenames case-insensitively %c-L%c make (some) names lowercase %-42s %c-V%c retain VMS version numbers %sExamples (see unzip.txt for more info): unzip data1 -x joe => extract all files except joe from zipfile data1.zip %s unzip -fo foo %-6s => quietly replace existing %s if archive file newer ¶¼'U1À‰åƒìƒäðèp3èÛ/膚‹U ‰T$‹U‰$è‰ì]Ãii-Z-d-xvUWVSƒì,1ÛÇD$p%@Ç$èƒ7ÇD$ ½@Ç$èß6ÇD$ ½@Ç$èË6ÇD$ ½@Ç$öÿÿÿè·6ÇD$ ½@Ç$ è£6ƒ|$@‹|$D”ˉl„B‰ $è7‹‰ÆÖ‹T$D‹9Ær´&¶€ú\t €ú/tN9ÆsîÇD$FÇD$þ@‰4$èU5…ÀtAÇD$ÇD$q%@‰4$è95…Àt%ƒ|$@Žäü‹l$D¿t%@¹‹uó¦…ÊÇD$ J@¾T$@‰5øƒBt$DÇD$B@‰t$‰$èq…À‰Ã…€‰t$D$@‰$觉Ël$@…í‰l$x…Ût ‰ØƒÄ,[^_]Ët$‹T$DF‰œ„B…ö~]´&‹œ„B‹¶„Àt,<\„‹=¥C‹‰$‰T$è´5ö„ÀuÛ‹œ„BNƒÂ…ö‰œ„B·‹t$@‹T$D‰t$‹L$1À‹£t„BƒÂ…ɉÜŒC‰T$(‰T$D‰ p„BŽ£ÇD$$‹*1ÿÇD$ ‰=x„B…퉜„B‰T$„l‹ðƒB…Û…¥ü‹t$º¿w%@‰Ñ‹.‰îó¦…ˆ‹|$(M‹D$$9|$‰ ðƒB”Ã…À¶ó„5ÇD$$‹L$¡œ„BljÍ)ÅÁý‰-p„B‹ðƒB€;uƒD$‹L$‹…À„³£ðƒB‰Ã‹L$…öQt$‹A…Àtz‰œ„B‹D$(‰×‹l$)ÇÁÿ)ý‰-p„B‰T$‹:…ÿ…2ÿÿÿ…Ût ‹„„B…Òt èÔéDþÿÿÇD$°@Ç$¸ŒBè#4‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C뿾¹\pB1Ò‰5x„B‰ œ„B‰p„Bë‘ÇD$ð@Ç$¸ŒBèÌ3‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸ é®ýÿÿ‹T$ …Ò„ãþÿÿ‹|$‹- „B‰ûÇ)ëÁû‰t„BéÁþÿÿ‰ö‹l$ ‹D$…íP…ÿÿÿü‹0º¿z%@‰Ñó¦uÇD$ ¡œ„B9D$tW‹t$$…öt&ÇD$$‹l$ÇE)ʼnëÁû‰p„B‹ðƒB‹T$‹D$(‹t$ƒÂ‰Ñ)Á‰ „BÁù)Ή5t„Béƒþÿÿ¹\pB1ÿ‰ œ„B‰=p„BëÂÇD$$‹l$UéZþÿÿ‹ðƒBé]þÿÿ»‰x„BëèÆ/éßüÿÿÇ$p@è«2éüÿÿÇD$ 9@1Ét$D‰ øƒB|$@ÇD$3@‰t$‰<$誅À‰Ãu½‰t$\$@‰$èé8üÿÿë UW1ÿVSƒì‹L$0ÇD$‹T$4‰L$‹*‰T$‹T$ƒÅ‹2N…ö~‹U…Òt €:-„ß‹„B…Û„Æ¡8„B…Àu+‹ @„B…Éu!…Àt ¡@„B…Àu‹= „B…ÿtG‹$„B…Ût=ÇD$0@Ç$¸ŒBè™1‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ƒ=üƒB~ º‰üƒB‹ („B…Ét‹=$„B…ÿ…ç‹X„B…Ò…¹Nƒþÿt‹|$…ÿtW‹L$‹T$‰1ƒ=D„B‰*~Ft0‹5l„B…öt‹\$‰\$0ƒÄ[^_]é‹l$…íuäÇD$ ëÚè[ 1ÀƒÄ[^_]á„B…Àu(‹=8„B…ÿu‹ D„B…Éu‹P„B…Òu ‹<„B…Ût1ÿ‰=„„B‹T$‰2‹t$‰.믹‰ „„BëåÇ$è!/…À”öËI! X„Bé'ÿÿÿÇD$@1ÛÇ$¸ŒBèG0‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‰(„Bé×þÿÿ¡8„BéCþÿÿ¾BZ…À„ƒè$ƒøV‡ôÿ$…ô,@”.@à0@à0@à0@à0@à0@à0@à0@à0@P.@à0@à0@à0@à0@à0@à0@à0@à0@à0@à0@à0@à0@¼.@à0@à0@à0@à0@à0@à0@à0@à.@þ.@à0@à0@/@à0@à0@à0@à0@à0@9/@c/@à0@à0@„/@à0@à0@à0@0@10@R0@à0@s0@à0@0@à0@à0@à0@à0@à0@à0@í0@1@,1@L1@`.@·1@à0@ë1@à0@2@à0@#2@à0@M2@n2@˜2@Ñ2@à0@ê2@ 3@,3@L3@à0@`.@à0@x3@Gë ¶¾ÀC…À…qþÿÿNƒÅ…öŽvüÿÿ‹U…Ò„küÿÿ€:-„Aþÿÿé]üÿÿ…ÿt‹ 4„B)ù‰ÏÁïO!ù‰ 4„B‰ö1ÿë¬ÿ4„B뤅ÿt‹ T„B)ù‰ÊÁêJ!щ T„BëØÿT„B뀅ÿt 1ɉ „B뺉„Bébÿÿÿ…ÿt 1ÿ‰=„B뤹‰ „BéDÿÿÿ…ÿt 1À£„B뇹‰ „Bé'ÿÿÿ…ÿt‹ „B)ù‰ÏÁïO!ù‰ „BéXÿÿÿÿ „Béýþÿÿ…ÿt 1Ò‰X„Bé<ÿÿÿ¹‰ X„BéÜþÿÿ…ÿuH‹ ôƒB…É…Êþÿÿ‰ôƒB€;u"ƒþ~*ƒÅN‹U‰ôƒB€:-t¶„À„ þÿÿC¶„Àuøé“þÿÿÇD$@Ç$¸ŒBèü,‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸ éøûÿÿ…ÿt 1Ò‰<„Béþÿÿ¹‰ <„Bé/þÿÿ…ÿt¿‰= „Békþÿÿ1Ò‰ „Béþÿÿ…ÿt 1ɉ H„BéMþÿÿº‰H„Béíýÿÿ…ÿt‹ L„B)ù‰ÏÁïO!ù‰ L„BéþÿÿÿL„BéÃýÿÿÇD$Ð@Ç$¸ŒBè/,‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C´&¼'ÇD$ésýÿÿ…ÿt‹ üƒB)ù‰ÏÁïO!ù‰ üƒBé¤ýÿÿÿüƒBéIýÿÿ…ÿ…‘ýÿÿ1Ò‰üƒBé4ýÿÿ…ÿt 1À£„Bétýÿÿº‰„Béýÿÿ…ÿuM‹ðƒB…ÒuP‰ðƒB€;u+ƒþ~3ƒÅN‹M‰ ðƒB€9-t!¶„À„Üüÿÿ‰ö¼'C¶„ÀuøéÆüÿÿÇD$ð@é.þÿÿÇD$P@é!þÿÿ…ÿt1Ò1ÿ‰@„B‰= „Béàüÿÿº¹‰@„B‰ „Béuüÿÿ‹\$ÇÿÿÿÿÇD$0éàùÿÿ…ÿt 1ÿ‰=„Béüÿÿº‰„Bé=üÿÿ…ÿu ÿD„Bé.üÿÿ‹ D„B)ù‰ÏÁïO!ù‰ D„Bécüÿÿ…ÿt 1ÿ‰=$„BéRüÿÿº‰$„Béòûÿÿ…ÿt‹ („B)ù‰ÏÁïO!ù‰ („Bé#üÿÿÿ(„BéÈûÿÿ…ÿt&‹,„B1À£„Bêç‰×ÁïO!ú‰,„Béîûÿÿ,„Bçékþÿÿ…ÿt ‹,„B)úëÐÿ,„Bévûÿÿ…ÿt 1ɉ 0„Béµûÿÿº‰0„BéUûÿÿ…ÿt 1ÿ‰=8„Bé”ûÿÿ¹‰ 8„Bé4ûÿÿ…ÿt 1À£@„Bétûÿÿ¹‰ @„Béûÿÿ…ÿ…Þþÿÿ¡D„B…Àt @£D„Béøúÿÿº‰D„Béèúÿÿ…ÿt‹ P„B)ù‰ÊÁêJ!щ P„BéûÿÿÿP„Bé¾úÿÿ[-Z] ´&VSƒì41Û‹t$@‹øƒB…ö•Ã…Ò„ÇD$$p%@ÇD$ p%@ÇD$¨@ÇD$Ô@ÇD$p%@ÇD$ÇD$ ÇD$ÇD$Ð@Ç$¸ŒBè¾(‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$@Ç$¸ŒBè(‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ð@ÇD$ ÇD$ ÇD$ ÇD$ ÇD$Ð@Ç$¸ŒBè4(‰\$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C1À…ö”ÀƒÄ4[Hƒà ^öÇD$Ô@ÇD$p%@ÇD$ÇD$ ÇD$ÇD$0@Ç$¸ŒBèÄ'‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ 0!@ÇD$¢3@ÇD$p @Ç$¸ŒBèƒ'‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$É@ÇD$p!@Ç$¸ŒBèJ'‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$$@ÇD$ ÇD$ ÇD$Ð@ÇD$ ÇD$ ÇD$ ÇD$ ÇD$°"@Ç$¸ŒBèÙ&‰D$‰\$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$Á@ÇD$ Á@ÇD$È@ÇD$p$@Ç$¸ŒBè&éWþÿÿ%d ´&ƒìƒ=,„B~DÇD$'ÇD$U6@Ç$¸ŒBèX&ÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’CƒÄÃvÇD$Ô@ÇD$p%@ÇD$ÇD$ ÇD$ÇD$0@Ç$¸ŒBèô%‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$Ð@Ç$¸ŒBè¿%‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cè™vÇD$0@Ç$¸ŒBè…%‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$«@ÇD$T@Ç$¸ŒBèH%‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$»@ÇD$T@Ç$¸ŒBè %‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$Ð@ÇD$T@Ç$¸ŒBèÎ$‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ @ÇD$T@Ç$¸ŒBè‘$‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$@ÇD$T@Ç$¸ŒBèT$‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$@ÇD$T@Ç$¸ŒBè$‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$-@ÇD$T@Ç$¸ŒBèÚ#‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$7@ÇD$T@Ç$¸ŒBè#‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$B@ÇD$T@Ç$¸ŒBè`#‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@ÇD$T@Ç$¸ŒBè##‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$°@ÇD$T@Ç$¸ŒBèæ"‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$â@ÇD$T@Ç$¸ŒBè©"‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$@ÇD$p%@ÇD$ ÇD$ÇD$ð@Ç$¸ŒBèT"‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBè"‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇ$3@èâ!…Àt€8u¸¤@‰D$ ÇD$3@ÇD$™@Ç$¸ŒBèÄ!‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇ$9@è‡!…Àt€8u¸¤@‰D$ ÇD$9@ÇD$™@Ç$¸ŒBèi!‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇ$B@è,!…Àt€8u¸¤@‰D$ ÇD$B@ÇD$™@Ç$¸ŒBè!‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇ$J@èÑ …Àt€8u¸¤@‰D$ ÇD$J@ÇD$™@Ç$¸ŒBè³ éVúÿÿVSƒì¡€B…ÀtZ[^ÃÇ$èÒ …À‰ÆtF1Ûv¼'‰Ú¸‰ö¼'‰ÑÑéöÂtñ ƒ¸íH‰Êuì‰ žCûÿ~Љ5€B‰ð뤡€Bëë ƒì ¡€B…ÀuƒÄ É$èH 1À£€BëëVSƒìD‹´ŒB‹\$P€bþè¨}ÇD$,1É´&¼'‹ÈŒCJ…҉ȌCˆË‹5ÄŒC¶F‰5ÄŒCˆT 0‹L$,A‰L$,ƒù ~Éè}‹´ŒB€J‹ ˆ„B…É„;1ö…Û‰5ˆ„B„[‹ ø‘C…É„ãt$0‰4$è‚1Ò…Àt¡ü‘C…Àt ºƒÄD‰Ð[^ÃÇD$,t$,v¼'ÇD$øC‹àŒC‹ø‘CÇD$ Q‰\$‰T$‰t$Ç$ðƒBÿd’Cƒø‰ÃtI…Àt‹ ø‘CÆÇD$,T$0‰$èó1Ò…À„{ÿÿÿƒûþt ‹\$,…ÛŒédÿÿÿ¸£ü‘Cëç‹ ø‘C1Û‰ $軉ø‘Cºé=ÿÿÿ‰$èƒ@‰$誣ø‘C…Àº„ÿÿÿ‰\$»‰$è—‰ü‘C¡ø‘C…À…ÖþÿÿÇ$Qèh£ø‘C…Àº…àþÿÿéÓþÿÿ¡ø‘C…ÀtÔ‰$è01Ò1À‰ø‘Cë¸t&è d‹L$,·Ðé4þÿÿë ƒì‹ø‘C‰|$‹|$ ‰\$‰t$‰T$‰<$è›…À‰Ãu‰Ø‹\$‹t$‹|$ƒÄÃv‹ø‘C‰$è’@‰$蹉ƅö¸ÿÿÿÿtˉt$‹ ø‘C‰ $范ì‰t$‰<$è=…À‰Ãu ‰4$èo똉t$‹ø‘C‰$èkƒì‰t$‰<$è ‰ÃëÑ´&VºxV4¸‰gE#Sƒì‹L$$‰’C‹\$ ºxV4£’C‰’C¶„Ò„¾‹5¸ŒC‰ö¡’CA0¶ÒÁè3–‹’C£’C%ÿÐiÀ„‹’C@£’CÁè1Ð%ÿÁê3†‰’C¶„ÀˆÂu¬‹ ‰ $‹S‰T$‹K1Û‰L$´&‹ ’C·ÁƒÈ‰Âƒò¯Â¶¶Ä0ˆ¡’CC0¶ÒÁè3–‹’C£’C%ÿÐiÀ„@£’CÁè1È%ÿÁ鋆1уû ‰ ’C~”¶T$ ‹´ŒBöC„¹¶C9Ât ¸ÿÿÿÿƒÄ[^ËÈŒC¡”„B9Ã~‰ÃK‹5ÄŒCƒûÿt¶¿· ’CKƒÉ‰Èƒð¯È¶Õ¶0ш¡’CF0Á¶ÑÁè‹ ¸ŒC3‘‹’C£’C%ÿÐiÀ„‹’C@£’CÁè1Ð%ÿÁê3ƒûÿ‰’Cu1ÀéWÿÿÿ¶ CéBÿÿÿ‹5¸ŒCé“þÿÿë · ’CƒÉ‰Èƒð¯È¶ÅÃv¼'S‹’C‹D$‹¸ŒC‰Ñ1ÁáÿÁê3‹‹ ’C‰’CâÿÊiÒ„‹ ’CB‰’CÁê1ÊâÿÁé3 “[‰ ’CÃë SºxV4‹L$‰’C¸‰gE#ºxV4£’C‰’C¶„Òth‹¸ŒC´&¼'¡’CA0¶ÒÁè3“‹’C£’C%ÿÐiÀ„‹’C@£’CÁè1Ð%ÿÁê3ƒ‰’C¶„ÀˆÂu¬[ÃUWVSƒì ‹T$(‰$è…À‰Ãt9´&¾‹ ¥Cƒ9„ÂÇD$‰$èî…ÀtCë×…Ût€;uH‹T$,‰$èB…À‰Ãt?¶¿¾‹-¥Cƒ}„]ÇD$‰$è…ÀtCëÖ…Ût€;u 1ÀƒÄ [^_]É$è+@‰$èR‰Æ…ö¸tÜèb“…À„ï‰\$‰4$è>‰4$è&‹L$ ‰Å‹9ø…‰$è …À‰Ç„¦‰D$‹\$$‹ ‹ƒÁ‰ ‰ƒÇ€>"„8‰7ƒÇë ¾…ÛtI‹ ¥Cƒ9„úÇD$‰$èÊ…Àu‹¥C‹ ‰4$‰L$èBÆë¾…Ût ÆF¶¶¾Ø…ÛtC‹ ¥Cƒ9„ÇD$‰$èw…Àt‹¥C‹‰4$‰\$èïÆë»…Û…Fÿÿÿ‹t$ ‹ÅH…À‰t1‹\$$‰Â‹ ¶¿‹1ƒÁ‰7ƒÇJuó‹T$ ‹D$$ljNjL$‹\$$‹|$ ‰ ‰/ékþÿÿ‹ P¥C‹·Zƒàémÿÿÿt&‹ P¥C‹·ZƒàéÿÿÿF‰7ƒÇ¶¾Ø…Û„eÿÿÿƒû"t)‹¥C‹‰4$‰T$è/ƶ¾Ø…Û„<ÿÿÿƒû"u×…Û„åþÿÿéÓþÿÿ‰4$èE¸éàýÿÿ‰t$‰$è? ƒìé þÿÿ´&‹5P¥C‹·QƒàéŸýÿÿ‹=P¥C‹7·Vƒàé:ýÿÿ´&W1ÿVSƒì‹t$ ¶G€û"„Û´&„Û„˜‹ ¥C¾Óƒ9„¦ÇD$‰$èÖ…Àu"‹¥C‹‰4$‰T$èNƶ뷴&¶„ÛtI‹ ¥C¾Óƒ9tKÇD$‰$è‹…Àt‹¥C‹‰4$‰T$èÆë¿„Û…Sÿÿÿ´&ƒÄ‰ø[^_ô&¡P¥C‹·Qƒà뵋 P¥C‹·SƒàéVÿÿÿF¶„ÛˆØt€û"t1¶¼'‹ ¥C‹‰4$‰T$èŒÆ¶„ÛˆØt‘€û"uÜ„À„7ÿÿÿFé.ÿÿÿ  !"#$%&'()*+,-./0123456789:;<=>?@A  !"#$%&'()*+,-./0123456789:;<=>?@ABAÁAÁAÁAÁAÁAÁAÁAÁAÁ A Á  A Á  A Á  A Á  A Á AÁAÁ     UWVSìL‹ÈŒCÇD$4‹ ”„BÑùA ö˃ÁöþŒC‰L$,„,ÇD$< rÿ…ö‰5ÈŒCl$@ˆ‹=ÄŒC¶G‰=ÄŒCp1Û´&¼'‹ÈŒCJ…҉ȌCˆÁ‹ ÄŒC¶A‰ ÄŒC‰×ƒçO‰×çðÁïW¿=w$¶‰LCJuøNu¥û•Â¶ò‰óÁã‰ß…ÿ‰øt ÄL[^_]ÃÇD$\$<|$8‰\$‰|$ÇD$ ÇD$ÇD$‰,$è‰}…À‰Ãtƒøt‰Ø뮋D$8‰$è~ƒëî‹5ÈŒCN…ö‰5ÈŒCˆã‹ ÄŒC¶A‰ ÄŒCp1Û‹ÈŒCJ…҉ȌCˆ­‹=ÄŒC¶G‰=ÄŒC‰×ƒçO‰×çðÁïW¿ƒø@w%v¼'‰LCJuøNu£ƒû@•Á¶ñ‰óÁã‰ß…ÿ‰û…QÿÿÿÇD$H@T$0|$4‰|$‰T$ÇD$ H@ÇD$ÇD$@‰,$è“|…À‰Ãtƒø… ÿÿÿ‹l$0‰,$舂éùþÿÿv‹=ÈŒCO…ÿ‰=ÈŒCˆÑ‹ÄŒC¶C‰ÄŒCp1Û‹ ÈŒCI…ɉ ÈŒCˆ›‹-ÄŒC¶UE‰-ÄŒC‰×‰ÕçðÁïƒåWM¿,ƒý@w(¶¼'‰Lœ@CJuøNuŸƒû@•Ã¶ó‰òÁâ‰×…ÿ‰ûuYöþŒC„ÇD$H@|$,¾‰|$L$(‰L$ÇD$ PI@ÇD$\$@‰$ÇD$@è{…À‰Ãt0ƒøt‹L$0‰ $èz‹D$8…À„àýÿÿéãýÿÿ‹t$(‰4$è]ëÕ‹T$8…ÒtW‰t$‹|$,‹\$(‰$‹L$4‹t$<‰|$‹l$0‰\$‰L$‰t$ ‰l$èÏ‹|$8‰Ã‰<$è‹L$(‰ $è‹D$0évýÿÿ‰t$‹\$4‹t$,‹l$(‹T$0‰\$‰t$ ‰l$‰$èĉÃë¿ÇD$H@T$,¾‰T$l$(‰l$ÇD$ ÐH@éùþÿÿè!U‰ÂéjþÿÿèUé5þÿÿè U‰ÂéWýÿÿèÿTé#ýÿÿèõT‰ÂéCüÿÿèéTéüÿÿÇD$8Zÿ…ۉȌC|$@ˆç‹ ÄŒC¶A‰ ÄŒCp1Û‰ö‹ÈŒCJ…҉ȌCˆ¯‹-ÄŒC¶UE‰-ÄŒC‰ÕƒåM‰ÕåðÁíU½ƒø@w!´&‰ ŸCJuùNu¦ƒû@•Á¶Ù‰ÞÁæ‰õ…í‰è…àûÿÿÇD$H@t$4l$0‰t$‰l$ÇD$ G@ÇD$ÇD$@‰<$èty…À‰Ã„úüÿÿƒø…ãûÿÿégþÿÿèçS‰ÂéVÿÿÿèÛSéÿÿÿ¶U1íWV1öSƒì,‹\$LÇD$ ‹L$PÇD$ ‹@‹\$T‹<@‹L$X‹@‰T$‹@‰D$¡C‰|$‰T$…À‰D$(„R´&‹=ÈŒCO…ÿ‰=ÈŒCˆ£‹ ÄŒC¶A‰ ÄŒC ŃÆ…ötÒ÷Å„µÿL$(NÑí;t$Ls=‰ö¼'‹ÈŒCJ…҉ȌCˆz‹ÄŒC‰ñ¶;C‰ÄŒCÓç ýƒÆ;t$LrÌ‹T$‰è÷Ð!ЋT$@´&¼'<¶O¶Óí)΃û vpƒûcºt\ƒã9Þs:¶¿‹ ÈŒCI…ɉ ÈŒCx/‹ÄŒC‰ñ¶B‰ÄŒCÓà ŃÆ9ÞrÒ‹ @‰è‹W÷Ð!ÈëèKR‰ñëÚƒÄ,‰Ð[^_]öW‹\$ ˆ“¸ŒBCû‰\$ tf‹|$(…ÿ…àþÿÿÇD$‹l$ Ç$¸ŒB‰l$èšS…À‰Âu­‹”„B‰ñ1Ò‹=ÈŒCÁé,Í…ít‘‹5 Cº)Þ)þ)Ή5˜„BéuÿÿÿÇD$ÇD$Ç$¸ŒBè@S…À‰Â…OÿÿÿÇD$ ÇD$ é_ÿÿÿè|Q‰ñÓà ÅéŒþÿÿNÑí;t$Xs<´&‹=ÈŒCO…ÿ‰=ÈŒCˆ“‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$XrÌ‹L$‹D$X!é‰L$$)ƶL$XÓí;t$TsCë ‹=ÈŒCO…ÿ‰=ÈŒCˆ#‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$TrÌ‹|$‰è‹T$H÷Ð!ø´&¼'<¶O¶Óí)΃û vfƒûcº„Hþÿÿƒã9Þs6´&‹ ÈŒCI…ɉ ÈŒCx/‹ÄŒC‰ñ¶B‰ÄŒCÓà ŃÆ9ÞrÒ‹ @‰è‹W÷Ð!Èëè;P‰ñëÚ‹D$$‹T$ )‰T$$·_)\$$;t$Ps4‹=ÈŒCO…ÿ‰=ÈŒCˆ.‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$PrÌ‹|$‰è‹T$D÷Ð!ø<¶O¶Óí)΃û v_ƒûcº„qýÿÿƒã9Þs/‹ ÈŒCI…ɉ ÈŒCx/‹ÄŒC‰ñ¶B‰ÄŒCÓà ŃÆ9ÞrÒ‹ @‰è‹W÷Ð!Èë—èkO‰ñëÚ·…ÛtHƒþw3‹ÈŒCK…ۉȌCˆ]‹ÄŒC‰ñ¶C‰ÄŒCÓâ Ճƃþv͉éƒîáÿÏÁí‹D$(1Û)ø9|$(–ÃK!É\$(d$$ÿÿ‹D$ 9D$$‡ó»)Ã9ûv‰û‹D$ )ß…Àt‹L$$9L$ †®‹L$ º°ŒB‹D$$)Á9Ùsmv‹L$$ÿD$$¶¸ŒB‹L$ ˆD AK‰L$ uá|$ t …ÿu‚é\üÿÿÇD$ÇD$Ç$¸ŒBèP…À‰Â…üÿÿÇD$ ÇD$ 뿉\$‹L$ ‹T$$Á¸ŒB¸ŒB‰T$‰ $èr\$ \$$뇉\$‹T$ ÇD$¸ŒB‰$èZëÖ‹T$$»)ÓéÿÿÿèãM‰ñÓà Åé©þÿÿèÓM‰ñÓà ÅéØýÿÿèÃM‰ñÓà Åéãüÿÿè³M‰ñÓà Åésüÿÿè£Mécúÿÿ´&¼'U1íWV1öSƒì,‹T$HÇD$ ‹\$LÇD$‹<•@‹T$P‹ @‰|$‹•@‹C‰L$‰D$…Ò‰T$(„°¶‹ ÈŒCI…ɉ ÈŒCˆ‹ÄŒC¶C‰ÄŒC ŃÆ…ötÒ÷Å„ÿL$(NÑíƒþw=v¼'‹=ÈŒCO…ÿ‰=ÈŒCˆÝ‹ÄŒC‰ñ¶C‰ÄŒCÓâ ՃƃþvÍ‹L$ ‰ëˆ™¸ŒBAù‰L$ toÁíƒî‹|$(…ÿu€ÇD$‹l$ Ç$¸ŒB‰l$è N…À‰Âu‹”„B‰ñ1Ò‹=ÈŒCÁé,Í…íu ƒÄ,‰Ð[^_]Ë5 Cº)Þ)þ)Ή5˜„BëÝÇD$ÇD$Ç$¸ŒBè©M…À‰Âu»ÇD$ÇD$ éZÿÿÿèéK‰ñÓà Åé)ÿÿÿNÑí;t$Ps9t&‹=ÈŒCO…ÿ‰=ÈŒCˆ“‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$PrÌ‹L$‹D$P!é‰L$$)ƶL$PÓí;t$LsCë ‹=ÈŒCO…ÿ‰=ÈŒCˆ#‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$LrÌ‹|$‰è‹T$D÷Ð!ø´&¼'<¶O¶Óí)΃û vfƒûcº„·þÿÿƒã9Þs6´&‹ ÈŒCI…ɉ ÈŒCx/‹ÄŒC‰ñ¶B‰ÄŒCÓà ŃÆ9ÞrÒ‹ @‰è‹W÷Ð!Èëè«J‰ñëÚ‹D$$‹T$ )‰T$$·_)\$$;t$Hs4‹=ÈŒCO…ÿ‰=ÈŒCˆ.‹ÄŒC‰ñ¶C‰ÄŒCÓâ ÕƒÆ;t$HrÌ‹|$‰è‹T$@÷Ð!ø<¶O¶Óí)΃û v_ƒûcº„àýÿÿƒã9Þs/‹ ÈŒCI…ɉ ÈŒCx/‹ÄŒC‰ñ¶B‰ÄŒCÓà ŃÆ9ÞrÒ‹ @‰è‹W÷Ð!Èë—èÛI‰ñëÚ·…ÛtHƒþw3‹ÈŒCK…ۉȌCˆ]‹ÄŒC‰ñ¶C‰ÄŒCÓâ Ճƃþv͉éƒîáÿÏÁí‹D$(1Û)ø9|$(–ÃK!É\$(d$$ÿÿ‹D$ 9D$$‡ó»)Ã9ûv‰û‹D$)ß…Àt‹L$$9L$ †®‹L$ º°ŒB‹D$$)Á9Ùsmv‹L$$ÿD$$¶¸ŒB‹L$ ˆD AK‰L$ uá|$ t …ÿu‚é`üÿÿÇD$ÇD$Ç$¸ŒBèrJ…À‰Â…€üÿÿÇD$ÇD$ 뿉\$‹L$ ‹T$$Á¸ŒB¸ŒB‰T$‰ $èâ\$ \$$뇉\$‹T$ ÇD$¸ŒB‰$èÊëÖ‹T$$»)ÓéÿÿÿèSH‰ñÓà Åé©þÿÿèCH‰ñÓà ÅéØýÿÿè3H‰ñÓà Åéãüÿÿè#H‰ñÓà ÅésüÿÿèHéûÿÿ skipping: %-22s need %s compat. v%u.%u (can do v%u.%u) t& skipping: %-22s unsupported compression method %u ‰ö¼' skipping: %-22s `%s' method not supported storeshrinkreduceimplodetokenizedeflatedeflate64DCL implode´&¼'%s: bad filename length (%s) %s: warning, no memory for comparison with local header ¶%s: mismatching "local" filename (%s), continuing with "central" filename version v%s: ucsize %lu <> csize %lu for STORED entry continuing with "compressed" size value %s: bad extra field length (%s) file #%lu: bad zipfile offset (%s): %ld %8sing: %-22s %s%s%s %s: %ld bytes required to uncompress to %lu bytes; %s supposed to require %lu bytes%s%s%s %s: bad file comment length local header sigfile #%lu: bad local header v¼' (attempting to re-compensate) warning: %s appears to use backslashes as path separators t&warning: stripped absolute path spec from %s skipping: %-22s %svolume label warning: cannot alloc memory for dir times/permissions/UID/GID warning: cannot alloc memory to sort dir times/perms/etc. t&warning: set times/attribs failed for %s replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: NULL (assuming [N]one) new name: ‰ö¼'error: invalid response [%c] At least one %serror was detected in %s. Caution: zero files tested in %s. %s: stored in VMS format. Extract anyway? (y/n) ¶¿ skipping: %-22s unable to get password skipping: %-22s incorrect password %lu file%s skipped because of incorrect password. ¶¼' (may instead be incorrect password) No errors detected in compressed data of %s. No errors detected in %s for the %lu file%s tested. t&¼'%lu file%s skipped because of unsupported compression or encoding. error: %s%s %s error: %s%s not enough memory to invalid compressed data to inflateexplodeunshrink¶¼'warning: %s is probably truncated %s: unknown compression method bad CRC %08lx (should be %08lx) compressed EA data missing (%d bytes)%s compressed WinNT security data missing (%d bytes)%st&¼'bad extra-field entry: EF block length (%u bytes) exceeds remaining EF data (%u bytes) ‰ö invalid compressed data for EAs EAs fail security check t& unsupported NTSD EAs version %d bad CRC for extended attributes unknown compression method for EAs (%u) out of memory while inflating EAs unknown error on extended attributes error: unsupported extra-field compression type (%u)--skipping error [%s]: bad extra-field CRC %08lx (should be %08lx) warning-scentral‰öU¸1íWº´„BVSƒì\£ˆ„B1À£ÄC¡p„BÇD$HÇD$<…ÀÇD$0ÇD$,ÇD$$ÇD$LÇD$PÇD$TÇD$X‰´ŒB…3 ¡t„B…À…è ÇD$(ÇD$4ÇD$81ÿ´&¼'ÇD$‰þÁæÇ$¤„BÆ´„B‰5´ŒBè›9…À„ˆ ÇD$ÇD$PpBÇ$¤„Bè÷ô…À…¼躪…À…«·50CÇD$‰4$èJ…À‰Ãt 9è~‰ÅKW·2CÇD$‰$èñI…À‰Ãt 9è~‰ÅKï· 4CÇD$‰ $èÇI…À‰Ãt 9è~‰ÅKk‹x„B…Û…–¡p„B»…Àt1ö1Û9Æ‚í…Ût1ö;5t„B‚Š…Û…b‰öÿD$(ƒÿ?†Óþÿÿ‰l$‹ÄŒCL$X‰L$‹ÈŒCD$T‰D$L$L‹5ìŒC‰\$D\$P‰T$@T$H‰\$ ‰L$‰T$‰<$è …Àt9è~‰Åƒ=ÈCÞƒýP„Õ‰t$‹äŒC‰÷ÇD$ Áÿ‰|$‰$è’ó£ìŒC‹ÀŒC‹ äŒCÇD$ ‰T$‰ $èmñÿD$<‹|$8‹D$D‹t$@…ÿ£ÄŒC‰5ÈŒC„êýÿÿ‹D$T…À…è‰?‹|$0…ÿt3‹\$8…Ût¡p„B1ö9Æs‹|$0‹·…Ò„zF9Ærì‹t$0‰4$ènò‹D$,…Àt3‹T$8…Òt¡t„B1ö9Æs‹L$,‹<±…ÿ„óF9Ærì‹t$,‰4$è3ò‹|$8…ÿtk‹L$4…É…R¡8„B…À„ËD$H‹L$L‹,„B‰Ã)˃úŽ±…Òu…íu…Ût]…Àuƒý~?‹T$L9Ðt+‹t$$…ötƒý~…Òt …íu½ƒÄ\‰è[^_]ýQëïƒýнRëã‹l$$…í•Á¶éMƒåºƒÅQëÎÇD$0a@‹=àŒCÇ$¸ŒB‰|$è ñÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‹D$Hé[ÿÿÿ…í„è‹àŒCƒý¸ªg@‰\$ t¸³g@‰D$ÇD$ð`@Ç$¸ŒBè½ðÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‹D$$…ÀtRƒ|$$¸³g@t¸´g@‰D$ ‹T$$ÇD$0c@Ç$¸ŒB‰T$ècð‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹D$L…À„7ÿÿÿƒøº³g@tº´g@‰T$ ‰D$ÇD$0b@Ç$¸ŒBè ðéæþÿÿ…Ûtq‹=x„B…ÿt ‹t$$Î…öt:ƒû¸³g@t¸´g@‰\$ ‹àŒC‰D$ÇD$ðb@‰\$Ç$¸ŒBè¹ïé÷þÿÿÇD$°b@‹ àŒC‰L$Ç$¸ŒBè–ïéÔþÿÿÇD$0a@‹àŒC‰T$ëÛÇD$ð@Ç$¸ŒBèiï‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBè4ï‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…í…<ýÿÿ½é2ýÿÿ‹ „B‹²ÇD$0@Ç$¸ŒB‰\$èàî‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡t„BéÁüÿÿ‹œ„B‹ ³ÇD$ð@Ç$¸ŒB‰L$è”î‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒý~ ¡p„Bé5üÿÿ½ ëïÁà‰$è²î‰D$ …À„ã‹T$Tƒú‰Ñ„Å1ö9Ös‹T$X‹\$ ‰³‹|$XF9΋‰T$XræÇD$ œ@‹t$ ÇD$‰L$‰4$è'm‹T$T1ö9Ör‹D$ ‰$è1îé~ûÿÿ‹L$ ‹<±‰<$è-…À‰Ãu‰<$Fèî;t$TrÜëÉ‹WÇD$0`@Ç$¸ŒB‰T$è›í‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…íu¯‰Ýë«‹L$X‹\$ ‰ épÿÿÿÇD$ð_@Ç$¸ŒBèOí‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹T$X…Ò„Äúÿÿ‹‰$‰D$Xèdí‹T$X…Òuêé©úÿÿ´&ÇD$8é‰úÿÿvèË…ÀtGé‘ùÿÿÿD$$é‡ùÿÿ´&‹ „B‹ „B‰L$‹ ²Ç$øC‰L$胅ÀuF;5t„BrÐéAùÿÿ‹\$,…Û„?ùÿÿ‹D$,Ç°é/ùÿÿ‹„B‹ œ„B‰T$‹±Ç$øC‰T$èÌ‚…ÀuF;5p„BrÐéÞøÿÿ‹L$0»…É„Íøÿÿ‹T$0Dzé½øÿÿÇD$¸ CÇ$øCèu*‰D$ÇD$9^@Ç$¸ŒBèýëÇD$ !‰D$ÇD$¸ŒBÇ$ðƒBÿX’CÇD$8éŒøÿÿÇD$¸ CÇ$øCè*‰D$ÇD$ ¶g@ÇD$P]@Ç$¸ŒBè›ëÇD$ ëœÇD$¸ CÇ$øCèÝ)‰D$ÇD$ ¶g@ÇD$0\@ëÀ‰Å뇋D$(f9JCtnÇD$P@‹\$<Ç$¸ŒBÁãl;‰l$½è.ë‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBèùê‰D$ÇD$ é÷þÿÿÇD$ÇD$XpBÇ$¤„Bèœë…À•Á¶Ñ‰T$4éßþÿÿ½3éÕþÿÿÁà‰$èë‰D$,…À„öÿÿ1ö;5t„Bƒóõÿÿ‹\$,dzF;5t„BrìéÚõÿÿÁà‰$èÈê‰D$0…À„¶õÿÿ1ö;-p„Bƒ¨õÿÿ‹L$0DZF;5p„BrìéõÿÿPKVMS´&¼'Sƒì(‹´ŒB¶C¶K$€áþÁˆK‹´ŒB· CÁéˆÊ¶K€âÒ€áýшK‹´ŒB¶8C¶K$Àà€áûÁˆK‹ ´ŒB‹$C¡üƒB‰Y‹(C…À‰Q‹,C‰Q „rH„Q€I€=C„K€=C†³‹,„B…Ût v1ÀƒÄ([ÃÇD$¸ CÇ$øCè¥'¶CÇD$ÇD$ÇD$ «r@f¶Ë‰Ñ’‰ÑÁéÀéˆÊÀâÊÒ(Ó¶Ó¶Ù‰T$‰\$‰D$ÇD$0[@Ç$¸ŒBèàèÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’CéZÿÿÿ·CJþfƒùvfƒútfƒú †Šv¼'‹,„B…Û…"ÿÿÿfƒú wCÇD$¸ CÇ$øCèÈ&·C‰D$ÇD$°[@‹ pB‰L$ Ç$¸ŒBè>èéYÿÿÿÇD$¸ CÇ$øCè…&· C‰D$ÇD$p[@ë‹´ŒB¹øCt&‹ƒÁÿþþþ÷Ð!Â €€té÷€€uÁêƒÁÒƒÙéøCQ‰$è%è‰C…Àt@ÇD$øC‹ ´ŒB‹Y‰$èèèp7· 6C‹´ŒB¡@Cf‰K‰¸é þÿÿÇD$¸ CÇ$øCèÊ%‰D$ÇD$P\@Ç$¸ŒBèRç‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C늀=C*vF‹,„B…Ò…¸ýÿÿÇD$¸ CÇ$øCèd%¶CÇD$ÇD$ÇD$ ®r@éºýÿÿ‹ 8„B…É…þÿÿƒ=|„B„ þÿÿÇD$¸ CÇ$øCè%‰D$ÇD$pa@Ç$¸ŒBè™æ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ ‹<¥CÇ$¨„B‰T$è綨„B€úy„ýÿÿ1À€úY…áüÿÿé€ýÿÿ¶YˆØÀ$€ã÷ÈYéœüÿÿv€a÷éüÿÿEOFhard disk locallseek¶¿UWVSƒì‹T$0ÇD$‹l$H9T$ƒIë ‹D$4‹\$ÿÁã“´„B‰´ŒB‹5ðŒC‹‹´„BÎ…ö‰ðˆÅ %àÿÿ‰ó)É÷)ß…öˆª ;=ìŒC„v ÇD$ ‹ äŒC‰ø‰|$Áø‰D$‰ $è+æ£ìŒC‹ÀŒC‹ äŒCÇD$ ‰T$‰ $èä£ÈŒC…À‰ÂŽ ‹=ÀŒC)ډȌC߉=ÄŒCÇD$Ç$¤„Bè=*…Àum‰t$ÇD$ Év@‹l$4‹E‰D$ÇD$]@Ç$¸ŒBè¾äÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C½ÿD$‹t$09t$‚ÆþÿÿƒÄ‰è[^_]ÃÇD$ÇD$TpBÇ$¤„Bè0å…À„H‰t$‹D$4ÇD$ W^@‹(ÇD$]@Ç$¸ŒB‰l$½è)ä‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹\$4ƒ;„ß ‹ ðŒC…É…Uÿÿÿ‹\$<‹…Ò„GÿÿÿÇD$^@Ç$¸ŒBèËã‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡ðŒC…À„p ‹|$<‰1À£ðŒC‹=´ŒB‹‰ $èÀA…À‰Ãt ƒû„Ôþÿÿ‰t$ÇD$ Év@‹t$4‹é„þÿÿÇD$Ç$¤„Bè–(…ÀtÈÇD$ÇD$TpBÇ$¤„Bèöã…À…à ´&¼'è;Ÿ…À‰ÃtF‹D$4‰Ý‹ÇD$h^@Ç$¸ŒB‰L$èåâ‰D$ÇD$ !ÇD$¸ŒBÇ$ðƒBÿX’Cé'þÿÿ·CÇD$‰$èÈ8…À‰Ãt 9è~‰ÅK* ¡´ŒB‹X…Û…Ifƒ=C…ƒ‹ C9CtuÇD$¸ CÇ$øCèµ ‰D$‹ C‹5CÇD$ð\@‰L$‰t$ Ç$¸ŒBè)â‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹ C…í‰CŽ®¡ôŒC…À…Œ·CÇD$‰$èð7…À‰Ãt 9è~‰ÅK5‹´ŒBöC…o‹=8„B…ÿ…‹„B…Ò…1ö‹´ŒB€{„ˆ…öu €=øC/„ö‰4$èV‰Ã%ÿ€ÿÿt9Å}‰Å‰Ø%=Žû=t|=t=Ž”üÿÿƒý‹üÿÿ½éüÿÿÇD$¸ CÇ$øCèe‹54„B…öt2ºÍv@‰T$ ‰D$ÇD$P_@Ç$¸ŒBèÚàÇD$ ‰D$éðýÿÿº³g@ëÌt$‰4$èV‹T$…ÒuO…À„üÿÿÇD$_@Ç$¸ŒBè’à‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…í…Ñûÿÿ½éÇûÿÿ‹|$@‹\$Dÿ‹ ‰ ‰é²ûÿÿÇ$øCènA…À„–…ÀŽjH…—¡„B…Àu ƒ=|„B„yûÿÿ‹=@„B…ÿt…ö„gûÿÿƒ=|„B„b…À…ZÇD$¸ CÇ$øCè6‰D$ÇD$p`@Ç$¸ŒBè¾ß‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ ‹<¥CÇ$¨„B‰\$è?à…À„e¶¨„B¾ÂƒèAƒø8‡ÿ$…ˆ}@‰ö<@@@@@@@@@@@@@}@@@@l~@@@@@@@F@@@@@@@@@@@@@@@@@@@@@Hx@@@@l~@@@@@@@F@ÇD$¼`@»øCÇ$¸ŒBè[Þ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$‹ <¥CÇ$øC‰L$èÜÞ‹3ƒÃ–ÿþþþ÷Ö!ò €€té÷€€uÁêƒÃÇ$øCÒƒÛëøC‰\$è¼?€8 t)…Û„[ÿÿÿÇD$øC¾Ç$øCèÔƒìéüÿÿKƃøCë͸£|„B1Û…Û…øøÿÿ1ɉ ÈCè#…À„ãøÿÿ9è~‰Åƒ=ÈCŽÐøÿÿéÝøÿÿº‰|„Bé»øÿÿÇD$Ð`@¾ú‰|$Ç$¸ŒBè8݉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé(ýÿÿÇD$£`@Ç$¸ŒBèþ܉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƨ„BN…í…Wýÿÿ½éMýÿÿ@…-ÿÿÿ¡ „B…À„ ÿÿÿ…ö…ÿÿÿé øÿÿv‹„B…Ò…ÿÿÿ¡|„Bƒø„ì÷ÿÿH…“üÿÿéèþÿÿÇD$¸ CÇ$øCèĉD$ÇD$_@Ç$¸ŒBèL܉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…íu½ºùC¶¼'¶ˆZÿB„Ûuõ€=øC/tÚé‰úÿÿÇD$/Ç$øCè#>…À…\úÿÿ¶øC»øC„À„Húÿÿ<\t"‹ ¥C‹‰$‰T$è¿Ûö„Àußé"úÿÿ‹ ÄC…ÉtÆ/ëÏÇD$Ð^@‹=àŒCÇ$¸ŒB‰|$ètÛ‰D$ÇD$ !ÇD$¸ŒBÇ$ðƒBÿX’C¸…í£ÄCu®½맋5ôƒB‰4$èP»ÿÿ…À„{ùÿÿƒøt79è~‰ÅÇD$¸ CÇ$øCèi‰D$ÇD$°a@Ç$¸ŒBèñÚéúÿÿ‹ ,„B…Ét ‹D$8ÿé?öÿÿÇD$¸ CÇ$øCè#‰D$ÇD$ða@Ç$¸ŒBè«Ú‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cë¦ÇD$¸ CÇ$øCèÔ‰D$ÇD$ Øv@ÇD$P]@éuùÿÿ‰$1ÿè¡Ú‰=ôŒCé_øÿÿ½éHøÿÿÇD$øC‹x‰<$èÙÚ…Àu#‹=´ŒB‹O‰ $èdÚ‹5´ŒBÇFé}÷ÿÿÇD$¸ CÇ$øCèNÇD$¸LC‹´ŒB‰Ç‹S‰$è3‰D$‰|$ ÇD$\@Ç$¸ŒBè·Ù‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹ ´ŒB‹qÇ$øC‰t$èíÙ…íPÿÿÿ½éFÿÿÿÇD$¸ CÇ$øCè·‰D$ÇD$ Øv@ÇD$0\@éXøÿÿ‰t$ÇD$ W^@éPôÿÿ‹\$<‹‰ðŒCéŒõÿÿ‹=ðŒC…ÿ…/õÿÿéõÿÿ‰|$ÇD$ Þv@é“õÿÿ‹ÄŒC‹ ÀŒC)Ê)ÚÙÈŒC‰ ÄŒCéÔóÿÿt&ÇD$ p@‹=àŒC½ÇD$°@Ç$¸ŒB‰|$è¥Ø‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹t$4ƒ>…Úóÿÿ‹ ðŒC…É„ÌóÿÿÇD$^@Ç$¸ŒBèU؉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹=ðŒC1Ò‹t$<‹´ŒB‰>‰ðŒC‹3…ö‰ðx@%àÿÿ‰ó)É÷)ß…ö‰ƒòÿÿÇD$ p@‹-àŒCÇD$°@Ç$¸ŒB‰l$è××éóÿÿ†ÿ븆ÿé0òÿÿ%-22s OK extract[binary][text] [empty] . warningerror] [explodinflattestV1À1ÒS1Ƀì4£¼ŒC1Û1ö‰ÐŒC¡8„Bº‰ÌŒC…À‰ ÔŒC‰ÌC„Ò ¡,„B…À„W èð4·C·Âƒø ‡=ÿ$…ì…@‰ö†@ö‰@ Ž@ Ž@ Ž@ Ž@X‹@ Ž@|Ž@|Ž@‹ 8„B…Éu‹,„B…Û„º¸ŒB1À‰ðC£ôC‰ö‹ ÈŒCI…ɉ ÈŒCˆÛ‹ÄŒC¶C‰ÄŒCƒúÿte‹ ðCˆ‹ôCÿðCCû‰ôCu³ÇD$ÇD$Ç$¸ŒBè‰Æº¸ŒB1À‰ðC…ö£ôCu‹ÈC…Û„qÿÿÿ¡ôC…À…1t&‹ 8„B…Éu ¡„B…À„ ¡ÈC…Àt H¾µƒþo‹¼ŒC¡C9„ÿ‹5,„B…ö…”‰T$‰D$ ÇD$pd@Ç$¸ŒBè’Õ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹´ŒBöBu¾èë2‰òƒÄ4‰Ð[^ÃÇD$pb@Ç$¸ŒBè=Õ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CëµÇD$¸ CÇ$øCèf‰D$ÇD$!…@Ç$¸ŒBèîÔ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹¼ŒC¡Céÿÿÿ‹8„B…Ûtt‹ôŒC…ÒuH‹,„B…Ò…;ÿÿÿÇD$(…@Ç$¸ŒBè‡Ô‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céÿÿÿ· C‰$‰L$èN9ðŽæþÿÿ‰Æéßþÿÿ‹,„B…Û…Ñþÿÿ…ö…ÉþÿÿÇD$-…@ëŒÇD$¸ C¾2Ç$øCèf‰D$ÇD$ðc@Ç$¸ŒBèîÓ‰D$ÇD$ !ébÿÿÿè¸öéêýÿÿÇD$‰D$Ç$¸ŒBè›é¶ýÿÿ¶èë‰Âé)ýÿÿÇD$¸ CÇ$øCèð‹ „B‰Â…É„Œ¸/…@ƒ=üƒB‰D$tO¸³g@‰D$‰T$ ÇD$2…@ÇD$»]@Ç$¸ŒBèEÓ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céküÿÿ‹C…Ût‹ ´ŒBöAu¸:…@뙸C…@ë’¸L…@닸³g@éoÿÿÿ‹8„B…Òu‹ ,„B…É„¨èÍ‘…À‰Ã„Ãüÿÿƒø1g‹5,„B…ötdÇD$¸ CÇ$øCè‰D$ÇD$ Úc@ÇD$˜c@ÇD$tc@Ç$¸ŒBèxÒÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‰ÞéPüÿÿÇD$ Úc@ÇD$˜c@ÇD$‡c@Ç$¸ŒBè,Òë²ÇD$¸ CÇ$øCèv‹„B‰Â…Ût{¸/…@ƒ=üƒB‰D$tO¸³g@‰D$‰T$ ÇD$Úc@ÇD$»]@Ç$¸ŒBèÏщD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé×þÿÿ‹ ´ŒBöAu¸:…@룸C…@뜸³g@냋8„B…Òu ¡,„B…À„ è\¾ÿÿ…À‰Ãtzƒøt~ƒø1‰Æn‹5,„B…ö…šÇD$ Òc@ƒû¸˜c@t¸®c@‰D$ÇD$‡c@Ç$¸ŒBèÑÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’Cƒû”Á¶Ñ4•ƒû…ãúÿÿ‹ ˜„B1Û‹ C‹5,„B9Ñ–Ã…ö…™ÇD$(U…@…Û¸W…@ÇD$$³g@ÇD$ ³g@‰T$u¸³g@‰D$‹C…Û‰L$¸Z…@‰T$u¸b…@‰D$ ÇD$-…@ÇD$Ð]@Ç$¸ŒBèXЉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…۔öóFé)úÿÿÇD$¸ CÇ$øCèu‰D$$‹ C…ÛÇD$(h…@¸W…@ÇD$ j…@‰T$u¸³g@‰D$‹5C…Û‹ ˜„B¸Z…@‰t$‰L$u¸b…@‰D$ ÇD$³g@éFÿÿÿÇD$¸ CÇ$øCèþ ‰D$ƒû¸˜c@ÇD$ Òc@t¸®c@‰D$ÇD$tc@Ç$¸ŒBèkÏéIþÿÿÇD$¸ CÇ$øCè² ‹„B‰Â…Ût{¸/…@ƒ=üƒB‰D$tO¸³g@‰D$‰T$ ÇD$m…@ÇD$»]@Ç$¸ŒBè ωD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cétýÿÿ‹ ´ŒBöAu¸:…@룸C…@뜸³g@ëƒt&ÇD$¸ CÇ$øCè ‰D$ÇD$0d@Ç$¸ŒBè”ΉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cèþ+ºé ùÿÿ‹ 8„B…Éu‹,„B…Û„Þ1Éfƒú ”Á‰ $è[8…À‰Ã„1øÿÿƒø1‰Æ&øÿÿ‹5,„B…öueÇD$ Êc@ƒû¸˜c@t¸®c@‰D$ÇD$‡c@Ç$¸ŒBèíÍÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’Cƒû”öÓ4•é·÷ÿÿÇD$¸ CÇ$øCè ‰D$ƒû¸˜c@ÇD$ Êc@t¸®c@‰D$ÇD$tc@Ç$¸ŒBèpÍëÇD$¸ CÇ$øCèº ‹ „B‰Â…É„‚¸/…@ƒ=üƒB‰D$tV¸³g@‰T$ ‰D$ÇD$t…@ÇD$»]@Ç$¸ŒBè͉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·Cé–þÿÿ‹´ŒBöCu¸:…@뜸C…@땸³g@éyÿÿÿÇD$¸ CÇ$øCè ‰D$ ÇD$³g@ÇD$³g@ÇD${…@ÇD$»]@Ç$¸ŒBèz̉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé?õÿÿt&‹ „B…Ét'ÇD$€‹<¥CƒÂ ‰àC‹Z‰$èôÊé õÿÿè…Àº2„øôÿÿé¯öÿÿ´&UWVSƒì‹l$0ƒ|$4ÇD$wK‹=,„B…ÿt 1ÀƒÄ[^_]ÃÇD$(…@Ç$¸ŒBè¾Ë‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C뿉,$èC(U·Ø‰$è5(‹t$4·øƒî9÷‡NûSD„ûSDƒû „Pƒû 9ƒû tt&‹t$4l/)þƒîƒþ‰t$4wé?ÿÿÿûM3„ÉûM3qƒû „[t&ÇD$ ‹L$‰|$‰,$‰L$èd…À‰Ãtž‹-,„B…í…Õƒû•ƒû‚ƒûts€ût<ÇD$Ðf@Ç$¸ŒBè ÊÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‰Øéžþÿÿ‰ÝÁý·Åfƒøt‰D$ÇD$Pf@Ç$¸ŒBèRÊë°ÇD$f@ëšÇD$e@ëÇD$f@놃ûO…pÿÿÿÇD$ -…@‹D$ÇD$°d@)Çwú‰t$Ç$¸ŒBèÊé[ÿÿÿÇD$¸ CÇ$øCèG‰D$ÇD$!…@Ç$¸ŒBèÏɉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CéÙþÿÿÇD$éœþÿÿûALtëûBe…ˆþÿÿƒÿvöEu ÇD$épþÿÿUwû‰$è2&ÇD$9ðuÙéQþÿÿƒÿ w ÇD$é>þÿÿU‰$èã%¨tä]‰$èô%ÇD$Oò9ÈuÊéþÿÿûM3…Äýÿÿë²M]‰ $èÄ%‰\$Wü‰Æ‰T$Ç$èkê9Æ„“ýÿÿÇD$f@Ç$¸ŒBè¿È‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CéYýÿÿûIM„MýÿÿûIM%ûG„9ýÿÿûGŽ-ýÿÿûALéýÿÿ‰öûBeéýÿÿt&ƒÿ»Ov(€}… ÇD$ ðªAÇD$‰|$‰,$蠉ÅۄÖüÿÿ‹,„B…Ò…‡ƒû#ƒû¾ýÿÿƒû…3ýÿÿÇD$²e@é8ýÿÿt&ƒûOt>û@…ýÿÿ¶}»ÇD$Ðe@Ç$¸ŒB‰|$è®Ç‰D$ÇD$ é ýÿÿÇD$ -…@Oõ‰L$ÇD$ðd@éuýÿÿÇD$¸ CÇ$øCè͉D$ÇD$!…@Ç$¸ŒBèUljD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé'ÿÿÿ»@éÿÿÿ¡,„B…ÀuG‰t$ ‰|$ÇD$0e@Ç$¸ŒBèljD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸éûúÿÿÇD$¸ CÇ$øCè!‰D$ÇD$!…@Ç$¸ŒBè©Æ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cégÿÿÿvƒì,1À‰\$‹\$8‰l$(‹l$4ƒû‰t$ ‰|$$v.ƒýv‹T$0ƒÂ‰$è#…À‰Æt(S9Õw!¸O´&‹\$‹t$ ‹|$$‹l$(ƒÄ,É4$ètƉDžÿ¸tÙ‰t$‹D$0‰ê‰<$)Ú‰T$ L‰L$è9…À‰Ãu#‹L$<…Ét‰t$ ‹\$0‰|$‰l$‰$ÿT$<‰Ã‰ö‰<$èƉØë„t&UW1ÿVSƒì,‹\$H‹ ÈŒC‹5”„B¡ÄŒC‰L$ ‹l$@‰t$(‰$‰D$$è*"S·ð‰$è<"‰D$K‹T$L‰ ÄŒC»‰¸C‹\$Dƒê‰”„B…ö‰ÈŒC‰-¼C‰ÀC„¹^øƒû‡M1Û1Éfƒþ ”Á‰ôC‰ $è$/…À‰Ãtn‹=8„B…ÿuPÇD$ Êc@ƒû¸˜c@t¸®c@‰D$ÇD$‡c@Ç$¸ŒBèÅĉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒû”¶ò<µt&‹D$$1Û…ÿ‰¸C‹t$ ‹L$(£ÄŒC‰5ÈŒC‰ ”„Bt ƒÄ,‰ø[^_]Él$‹ôCÇ$‰T$èÓå;D$tÖ‹-8„B…ít¿ëʼnD$ ‹=àŒC‹\$ÇD$pg@‰|$¿‰\$Ç$¸ŒBèýÉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cépÿÿÿ´&¡8„B…Àt ‰÷ÁçƒÏé*ÿÿÿ‰t$¿ÇD$g@Ç$¸ŒBèÉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céçþÿÿ´&‰T$‰L$‰,$èðË”„B‰ôCé¿þÿÿë UWVSƒì‹T$0‹t$8‹l$@ƒÂ‰$èÒ‹L$4‰Çƒé ‰L$ƒç…Ü‹\$…öt‰9ë‰Øs‰è‰$èRÉÆ1À…öt+‹T$<…Òt9ë‚Šƒÿteƒÿ~@ƒÿt‰4$1öèÉðƒÄ[^_]É\$‹T$0‹D$‰4$ƒÂ ‰D$ ‰T$èèüÿÿëÕ¶…ÿuÁ‰\$‹|$0‰4$ƒÇ ‰|$èÃë²v‰\$‹L$0‰4$ƒÁ ‰L$èIë–´&‰l$‹l$<‰4$‰l$èÌÂé]ÿÿÿ´&‹L$0ƒÁ‰ $èÑ·Øéÿÿÿ‰ö¼'W1Ò1ÉVS‹\$‹t$‹|$Kƒûÿt2´&…É~<öÂt'IÑêƒù ¶GÓà ƒÁˆƒéFÁêKƒûÿuÕ[^_ÃÆIÑêFëì´&¶GÓà ƒÁë·vWVSƒì‹t$ ‹|$$¶‰û„Àt"‰ö¼'<w0Æ^C¶F€Â@ˆC¶„ÀuçƉ|$‰<$訷ƒì‰øƒÄ[^_Ë ¥C‹‰4$‰T$èHÁ…À‰Âtĉö¶Fˆ CJuöë¶t&ƒì‰\$‹\$$;ÀCw=‰\$‹T$ ‰T$‹¼C‰$èƒÁ¼C1À)ÀCôC‹\$ƒÄô&¸2ëê‰ö¼'‹L$‹T$‹‹H‰L$‹ ‹Q‰T$éQÁerror: cannot open zipfile [ %s ] %serror: cannot delete old %s error: cannot rename old %s ~error: cannot create %s error: zipfile read error warning: filename too long--truncating. warning: extra field too long (%d). Ignoring... ¶¼'%s: write error (disk full?). Continue? (y/n/^C) ¶¿error: zipfile probably corrupt (%s) --More--(%lu)t&¼'--- Press `Q' to quit, or any other key to continue ---´& [%s] %s password: Enter password: password incorrect--reenter: wb%u¶¿UWVSìŒÇD$XCÇ$øCè’…Àu.¡„B…À…ò€=XC‰ÌÇ$øCèè>…À…–ÇD$Ξ@Ç$øCè ¿£àC…ÀucÇD$¸ CÇ$øCèßûÿÿ‰D$ÇD$¼œ@Ç$¸ŒBèg½‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸ÄŒ[^_]ö‰$‹5C‰t$è^ 1ÀëÙÇD$¸ CÇ$øCèfûÿÿ‰D$ÇD$~œ@ë…ÇD$€Ç$øCèä»éÿÿÿÇ$ºœ@»øCèþ¼‰D$v¼'‹ ƒÃ‘ÿþþþ÷Ñ!Ê €€té÷€€uÁêƒÃÒ‹T$ƒÛëøCtþÿŽžÇ$èм‰Å…í¸„ ÿÿÿÇD$øC‹D$¾ÿ‰,$)Æ趼Æ.9ó~‰ó¾ÇD$ºœ@<+‰<$蔼ƒ=|„B„‹L$)Þ‹D$)ÎÇFÿ‰|$ƒø¿ÿÿw!ÿ$…ð @¸¡@¿¡@É¡@Ó¡@¡@¿'1Ût$ ‰t$‰,$èt…ÀuÇD$Ñž@‹T$C‰\$‰$觻9ûvÓ‰l$Ç$øCèC<…ÀtZÇD$¸ CÇ$øCèÛùÿÿ‰D$ÇD$œœ@Ç$¸ŒBèc»‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‰,$芻éïýÿÿ‰,$è}»éxýÿÿ1ÿéJÿÿÿ¿ é@ÿÿÿ¿cé6ÿÿÿ¿çé,ÿÿÿ‰,$\$ ‰\$装À…Hÿÿÿ‰,$è<é;ÿÿÿ‰4$è6»‰Å…í¸„†ýÿÿÇD$øC‰,$è'»é{þÿÿ‰öUWVSƒì‹t$4‹|$0…ö‰õtEt&¼'‹ÈŒC…Ò~:9ò‰Óv‰ó‰<$‹ÄŒC߉\$‰T$èöºÄŒC)ÈŒC)ÞuƉèƒÄ[^_]ÃÇD$ ‹ÀŒC‰T$‹äŒC‰$è ¹£ÈŒC…À‰ÂtS…ÀxìŒC ‹ ÀŒC‰ ÄŒCé|ÿÿÿÇ$Öœ@è&º‰D$ÇD$ ÇD$Öœ@Ç$ðƒBÿX’C1Àézÿÿÿ‰è)ðéqÿÿÿt&VSƒì‹¸C…Ò…2¡”„B…ÀŽ/‹ÈŒC…Ò~s‹ ÄŒC‹´ŒBöCtDrÿ‰Ëƒþÿt:v¼'è‹žÿÿ2N¶ÈˆC‰ $èšžÿÿƒþÿuå‹ÈŒC‹ ÄŒC‰ö¼'ZÿQ‰ÈŒC¶1‰ÄŒC‰ðƒÄ[^ÃÇD$ ‹ÀŒC‹ äŒC‰\$‰ $è㷣ȌC…Àtw…ÀˆŒìŒC ‹”„B‹ ÀŒC9؉ ÄŒC~F…Ûx6‹5ÈŒC‰ÈŒC‹ ÄŒC)Þ‰5l’C ‰p’C‹ÈŒC)Ó‰”„Béÿÿÿ1Ò1Û‰”„Bë¾1À£l’CëØ1ö‰5ÈŒC¸ÿÿÿÿéHÿÿÿPÿ‰”„BëãÇ$Öœ@芸‰D$ÇD$ ÇD$Öœ@Ç$ðƒBÿX’CÇ$èm¹¶¼'UWVSƒì,‹L$@‹¼ŒC‹\$D‹t$H‰$‰L$(‰\$‰L$èƒÙ£¼ŒC‹8„B…Ò……Û„ˆ¡ÈC…À…•¡´ŒBö@u|‹5„B…öu7‰\$‹L$(‹-àC‰L$‹}‰<$艶9Øt ƒÄ,[^_]鉋„B…Òt/ÇD$ ‹L$(‰\$‰L$Ç$ðƒBÿX’C1Ò…Àu ´&1ÒƒÄ,‰Ð[^_]Ã…ö„ïÇD$ ‹5ìC‰t$$‹-ÌC…ít%€x„”ºÿÿÿÿ‰x’C1ÿ1ö‰=ÐC‰5ÌC¡x’C…Àˆê…Û‹l$(‹|$$„”´&¼'ƒøwkÿ$…¦@0¦@§@9§@0¨@Ψ@‹T$(1É‰î‰ t’CKÿ)Ö9΄µ‰,$ƒÅè:·È¸‰ t’C£x’C‹5t’Cƒæ‰5|’C´&‹D$(‰é)Á9Ùs ¡x’Cézÿÿÿ;|$$†ðþÿÿ‹„B…Ûu;‹\$$‰ý‹t$$‹àC)݉l$‰t$‹J‰ $èµ9è…tþÿÿ‹-„B…í„«þÿÿÇD$ ‹L$$)ω|$‹L$$éqþÿÿ¶U¾E‰5x’C‰t’CéNÿÿÿ¶MºE‰x’CÁá t’CéGÿÿÿ‹T$(¡t’C)ê49ðs ¹‰Æ‰ x’C‹T$$‹L$ Ê)ú9Ö‚)Ö…Òt´&¼'¶MEˆGJuõ¡„B…Àu=‹D$$‰ù)Á‰L$‹D$$‰L$‹ àC‰D$‹Q‰$è´;D$…„ýÿÿ‹„B…Òt/ÇD$ ‹L$$Ç$ðƒB)ω|$‹|$$‰|$ÿX’C…À…ýÿÿ‹|$$¡t’C)ð…ö£t’C„hþÿÿ´&¶UEˆGNuõéPþÿÿ‹T$$‹D$ tþ9÷vl‹ „B…Éu/‰T$‹ àC‰þ)Ö‰t$‹Q‰$èi³9ð…Üüÿÿ‹5„B…öt/ÇD$ ‹D$$Ç$ðƒB)lj|$‹|$$‰|$ÿX’C…À…èüÿÿ‹|$$Æ 1ÒGÆ Gƒ=|’C•ÂÁâ‰x’Cé²ýÿÿ1öE‰5x’Cé¤ýÿÿ‹l$(€} tk‹t$(1Ò‹|$$‰ÐC‰ê)ò9Úƒ”ýÿÿKÿ¶E< t"< tˆG‹D$(E‰ê)Â9ÚräépýÿÿÆ GÆ ëäÆ GÆ G9Êt €} uÓEëо‰5ÐCëË=ÐC…ÿt‹E눋ôŒC…Ò„^üÿÿ· C‰$‰L$è‘…À„Cüÿÿ1À£x’CéBüÿÿÇD$ ‹=äC‰|$$é üÿÿº2éÞûÿÿ[Warning: CRC error, discarding PKWARE extra field] t&¼'UWVSƒì,‹|$DÆD$#‹t$@…ÿ„¤…ö„œƒÿw1À€|$#”ÀƒÄ,[^_]Ãt&‰4$è8V·Ø‰$è*·èWü9ÕwɃû t{ûIMt‰út5)êzüƒÿwÃëª^‰$è=VFABuÛÇD$T$(ÇD$ ‰T$‰l$‰$èÚîÿÿ‰D$$…Àt¯ƒ|$(v ¶X€ãˆ\$#‹L$$‰ $èD²ë‰öNUü‰L$$^‰T$(‰$è§Ç$‰Ã‹L$(‹D$$‰L$‰D$èIÓ9Ãt:ÇD$Щ@Ç$¸ŒB衱‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céÿÿÿƒ|$(† ÿÿÿ‹\$$ƒÃ‰$è‹T$$·Ø‰$èfƒøt#‹L$(‹T$$)ÙƒéDƒù‰L$(‰D$$w¾éÆþÿÿ…ÛtÙ‹T$$¶J€áˆL$#ëÈt&1Àélþÿÿ‰ö¼'ƒìÇD$¸ CÇ$øCèIïÿÿ‰D$ÇD$@Ç$¸ŒBèÑ°‰D$ÇD$ ¡ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ ‹<¥CÇ$¨„B‰T$èR±1Ò¸2€=¨„By•ÂB‰ÈCƒÄöUWVSƒì‹l$4öD$<ÇD$‹\$8‹t$0‰ï+‰T$„y‹VH…Ò…n¡<¥CƒÀ@‰D$v¼'öD$<@t…Û…:‹–è …Ò„vNtVl‰L$‰$è^ƒnlöD$< ts‹–è …Òui‹T$‹JI‰J…Ɉċ Æ ÿ‹L$‰ $èã°‹Fh…Àtÿ†ä ‹VpÇFxB;Vl‰VpoöD$<t ‹FH…À…캉–è ‰ö‹Nh…É„Œ‹\$9\$4s~t&¼'¶< t+< „¤< „€ÿFx‹Vt9Vx|ÇD$‹L$…Ét%ÿ†ä ‹^pÇD$ÇFxC;^l‰^pÜ‹ ¥C‹‰<$‰T$èõ®Ç;|$r‰û)ë…Ûu 1ÀƒÄ[^_]É\$‹D$‰l$‹x‰<$褭9ؕ¶…ÀuÕ‹L$‰ $è̯öD$<t‹VH…Òu‹D$1Û€xÿ ”Éžè ë¤Ç$è­…ÀuÛÇ$è ­…Àtˉ\$‹=<¥C‰l$‹oP‰,$è0­9ؕöÅÀ…]ÿÿÿ‹ <¥CƒÁ@‰ $èO¯ë‰l$‰û‹D$)ëC‰\$‹h‰,$èñ¬9ؕ¶…À…ÿÿÿ‹\$o‰$诹‰Žè ÇD$ÇD$÷@‰4$ÿ–péÀþÿÿ‹Vx…Ò‰ÐxƒàøƒÀ‰FxélþÿÿBëíÇFxékþÿÿÇ$è5¬…À…þÿÿÇ$è!¬…À„ìýÿÿ‹ <¥CQ@‹BH…À‰Bx‹Q@Æ ÿA@‹ <¥CƒÁ@‰ $èk®é¹ýÿÿ‰T$Ç$ 覮ëØt&ÇD$ÇD$÷@‰4$ÿ–pésýÿÿÇ$ ‹T$‰T$èn®é*ýÿÿ‹L$CÆ A‰L$é×üÿÿ‹D$€xÿ uäéÈüÿÿ‹ <¥CƒÁ ‰L$é–üÿÿ¶ƒì,‹T$4‰|$$1ÿ‰l$(‹l$8‰\$‰t$ ‹…Àt]H1ö»°ž@‰‰$‹L$<‰l$‰L$èoj…ö‰Ãt‰4$豬…Ût!€}u¿þÿÿÿ‰ø‹\$‹t$ ‹|$$‹l$(ƒÄ,ÿëãt&Ç»Ÿž@Ç$èy¬…À‰ÆtÇD$¸LC‹T$D‰$è_êÿÿÇD$¸ C‹T$@‰Ã‰$èIêÿÿ‰D$‰\$ ‰óÇD$Œž@‰4$èÏ«éGÿÿÿ;Zx—µÔó0NmUWVSìÜ‹”$ð‹´$ð‹Œ$ðÁêƒâÁ$ðJ^ ‹¼$ð‰T$Áé‹”$ðÛƒáÃâIÒ‰T$€–»ÁúÐÁí ·” ±@Áïƒåƒç?ÐIþÿÿ~ƒæuû‚t þÿÿt&‹L$ií‹D$ÊiÒ€QL$ ‰ $ê‰ýÁå)ý4¨‰\$è+®ƒì@ty‹T$ ‹|$‰ÓÁã)ÓŸ¼$ðÿÿ1t‰D$v"=ÿÿÿoÇD$ÿÿÿÿ¸ÿÿÿÿ´&¼'…Àˆˆt$‰4$è|«…Àtn‹h …ítg‹”$ȉÑÁá)ÑÁáL$¼$ðÿÿ1tv?‹D$=ÿÿÿoÇD$ÿÿÿÿ¸ÿÿÿÿ´&…Àx ÄÜ[^_]ÃÇD$ÿÿÿ¸ÿÿÿëå‹D$ëÚ‹T$tëšt&ÇD$ÿÿÿékÿÿÿ[ %s ] t&¼'U1ÒWVSƒì,‹\$@ÇD$ …Û„ºƒ|$D‡«‹T$Dÿ$•4³@¾µ@P³@M·@Ͷ@Ó´@P³@M·@‰\$(…Û„R‹D$(‹5äC=‰óv¸‰D$‰4$è°îÿÿ‰D$$…Àº3„F)D$(‹äC‹L$$ƶ„Òt¶€ú „÷ˆCF¶„Òuìƃ|$D„u‹äC¾¸ŒB¶ÇD$ðƒB„À„z¹ðƒBˆÂ÷Ù©8÷ÿÿ1ÿ€ú„0€ú„ïˆFD5=ýÿw…ÿt:ÇD$ ¾¸ŒB‰D$ÇD$¸ŒBÇ$ðƒBÿX’C…ÿt¡„„B…À…„vC¶ „ɈÊu–÷\$ÇD$ ÇD$¸ŒB‹|$Ç$ðƒBœ>8÷ÿÿ‰\$ÿX’C‹l$(…ít ‹t$$…ö…®þÿÿÇD$ @ÇD$ÇD$¸ŒBÇ$ðƒBÿX’C‹T$ ƒÄ,‰Ð[^_]ÃÇD$ÇD$ž@Ç$ðƒBÿ`’Cé]ÿÿÿ¶C¿< t"< …ÿþÿÿ€{ …õþÿÿC¶ CˆF¶éâþÿÿÆ CéÛþÿÿÆ^FÆ[éÏþÿÿ‹´ŒB‰Ñ€zuHöB@t¶RˆÓ€ë€ûv4€ú(t/‹5äC‰t$‰4$èÀƒì‹=äC‰|$‰<$蛃ìé5þÿÿ€ytËfy2 uØëÁvC¶€ú t÷éûýÿÿ‹5ìŒC‹-ðŒC‹ ÄŒC‹=ÀŒC‰ð)è)ùÈØè…À‰ÂˆÖâàÿÿ‰Ã)Ó‰Â)Ú…Àˆ‰9òtoÇD$ ‹=äŒC‰Õ‰T$Áý‰l$‰<$è—§£ìŒC‹ÀŒC‹ äŒCÇD$ ‰T$‰ $èr¥£ÈŒC…ÀŽxþÿÿ‹5ÀŒC)أȌCó‰ÄŒCé^þÿÿ)Ù ÈŒC ;‰ ÄŒCéHþÿÿÇD$ p@‹5àŒCÇD$°@Ç$¸ŒB‰t$è/¦‰D$ÇD$ éüýÿÿÿéÿÿÿ¡ôŒC…Àum‰$èb¦£ôŒC…Àt‰\$‰$è=ëÿÿ…Àº3…ÓýÿÿéÒýÿÿ‰\$ÇD$P@Ç$¸ŒBèÃ¥‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé{þÿÿ‰$èå¥ë‰ÇD$$ûÿ‡Þ‰\$Ç$øCè¿êÿÿ…Àº3„YýÿÿƃøC‹´ŒB‰Ö€z…ƒ|$DtöB@t¶JˆÈ,<†p€ù(„gÇD$øCÇ$øCèo›‹´ŒBƒìöBt#¶øC¾øC‰÷ˆT$„Ò…–Æ‹´ŒBöB tƒûv €=ŽC.tb‹|$$…ÿ„°üÿÿÇD$¸ CÇ$øCè ãÿÿ‰D$ÇD$í²@Ç$¸ŒB葤‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹\$$éEýÿÿºŽC¶ˆZÿB„ÛuõëŒt&‹-¥C‹M‰4$‰L$èK¤ƒø‰Âv#Jƒúÿt ¶JFˆGƒúÿuó¶„ÀˆD$uÆé+ÿÿÿ‰|$‹¥CG¾l$ƒ:t/ÇD$‰,$èl¤¶T$…Àu ‹l$FˆU븉,$èᤈÂëê‹P¥C‹ ·iƒàëЀ~„þÿÿf~2 … þÿÿé~þÿÿÇD$@ëÿÇ$¸ŒB臣‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‰\$$»ÿÇD$ éÑýÿÿ‹T$¶J¶Áá ÈÃë ‹L$¶A¶QÁàÁâжQÁâжÐö¼'ƒì‹àŒCÇD$€‰$è÷¡£äŒC1Ò@t ‰ÐƒÄô&褋‰ $è!¤‰D$ ‹àŒCÇD$Pœ@Ç$¸ŒB‰T$蟢‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cºëš´&¡ÈŒC…À~”„B‹ l’C…É~'‹”„B ‹ p’C£ÈŒC)Ñ1Ò‰ ÄŒC‰l’CÉöÁèH!ÈŒCÃt&‹ ÈŒC‹”„B9Ñ~@…Òx,‰ÈŒC¡ÄŒC)щ l’C‰ÑУp’C)ʉ”„Bô&1À1Ò£”„BëÉt&1À£l’Cë×´&Sƒì¡ðŒC‹L$ È…À‰Âˆâàÿÿ‰Ã)Ó‰Â)Ú…Àˆ¡;ìŒCtyÇD$ ‰ÑÁù‰L$‹ äŒC‰T$‰ $èF¢£ìŒC‹ÀŒC‹ äŒCÇD$ ‰T$‰ $è! £ÈŒC…Àº3~‹ÀŒC)أȌCӉČC1҃ĉÐ[Ãt&‹ÄŒC‹ ÀŒC)Ê)ÚÙÈŒC‰ ÄŒCëÒÇD$ p@‹àŒCÇD$°@Ç$¸ŒB‰T$èÊ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cº놉öÿéîþÿÿt&‹T$ 1ÀÇÃvWVSƒì‹t$ ‹|$(‹†è …À„Ô‹<¥C‹Žä ‹T$$ƒÃ@‰L$‰T$‰$èa¡‹ <¥CƒÁ@‰ $è`¡÷Ç„„t&èûñ< ˆÃt< t< t case %s conversion) %8lu %-7s%8lu %4s %02u%c%02u%c%02u %02u:%02u %08lx %c´&-------- ------- --- ------- %8lu %8lu %4s %lu file%s %9lu %6lu %6lu %02u%c%02u%c%02u %02u:%02u %c -------- ----- ----- ------- %9lu %6lu %6lu %lu file%s %lu file%s %lu bytes of OS/2 extended attributes attached. t&%lu file%s %lu bytes of access control lists attached. NXFSvStoredShrunkReduce1Reduce2Reduce3Reduce4ImplodeTokenDefl:#Def64#ImplDCLUnk:###%03us hass have a total of%s %s ´&U1À1ÒWVSììƒ=D„B‰„$”ÇD$|ŸÂÇD$hÇD$dÇD$\‰”$Œ”$ ‰´ŒBÇD$XÇD$PÇD$Lè ͉„$ˆèt̓=,„Bˆ„$‡Ž` ¸‰„$€t&ÇD$Ç$¤„Bè<Âÿÿ…Àº3„sÇD$ÇD$PpBÇ$¤„Bè“}…À…SèV3…À‰Â…@· 0CÇD$‰ $èµÒÿÿ…Àt‰„$”‰ÂH¡ôŒC…À…÷·2CÇD$‰$è}Òÿÿ…Àt‰„$”‰ÂHÝ‹5x„B…öu/1ö1Û;5p„B‚‹x„B…Ûu…ö„ƶ¼'·52CÇD$T‹ôŒCÇD$`ƒþ‰Ó/…Ò…Ñ1Û…Û„q‹K¸…ëQ‹k‹{ ÷é‰ÈE‰ÖÁþ™)Ö‹C¶4’Áæ‰D$p)ñ‰L$x‹K‰L$tƒ¼$ˆ„%ƒ¼$ˆ„öC¡(C‰D$ltƒè ‰D$l‹\$l‹5,C‰\$‰4$è# …Àˆ»Æ„$“ H¾gfff‰È÷î‰Ö‰Ê· CÁþÁú)Öfƒù ·Ùv» Ý°Þ@”$˜‰L$‰$èl{Køƒù‡0·CÑêƒâ¶š¨Þ@ˆœ$ƒþd„ì‰t$ œ$о´$“ÇD$pÛ@‰$‰t$è¦z‹”$Œ…Ò„8‹5´ŒB‹D$xöF‹5$C‰l$‹-,C•Á‰t$4¾´$‡‰|$ ¶Ñ¼$˜‰D$(‹L$pJ‰t$$ƒâƒÂ^‰T$8‹T$t‰L$0‹L$l‰T$,‰t$‰\$‰L$‰|$ ‰l$ÇD$ÐÜ@Ç$¸ŒBè zÇD$ 1Û‰D$ÇD$¸ŒBÇ$ðƒBÿX’CèU ƒ=,„B·-4C”É,$<›‰|$èåÏÿÿ…Àt ‰„$”‰ÂHIÿD$|‹t$`¡,CD$d‹T$lT$h…öt ÿD$X‹L$`L$\‹l$T…ít ÿD$L‹|$T|$Pÿ„$€élüÿÿÄì‰Ð[^_]Ë ´ŒB‹t$p‹D$töA‹L$x‰|$‹|$T•Â‰l$‹l$`‰t$,¶ÚK¾”$‡ƒãƒÃ^‰\$0‹,C‰D$(‰L$$‰T$ ‰T$‰|$‰l$ ‰\$ÇD$Ý@Ç$¸ŒBèæxéÔþÿÿÇD$wÛ@œ$Љ$èÊxéþÿÿt&ƒû †áýÿÿ·CŒ$œÇD$ß@‰ $‰\$è•xéºýÿÿÆ„$“-¹)Áé<ýÿÿ‰ë‹l$x‰|$x‰ßééüÿÿ‰ë‰ýëó‹5 C¹…ëQ‰òÁê‰ójP‰èÁë ƒã÷á‰\$tÁê’<€Áç)ý‰l$x‰÷‰õÁîÁí‰t$pÁïƒåƒd$p?ƒçéqüÿÿ·52Cœ$ÀÇD$‹= C‰\$ÇD$‰|$ ‰t$‰$èç0¨„ïûÿÿ”$ĉ$èÀx‰ÃéÛûÿÿK‰ $è^Ôÿÿ‰$·øèSÔÿÿ·Àƒø t3=ALt‰ñ\)ùqüƒþË‹ôŒCé‘ûÿÿk‰,$è>Ôÿÿ‰D$TëÔS‰$è-Ôÿÿ‰D$`ë÷4Cf…À„ÏýÿÿÇD$·Ø‰$èTÍÿÿ…À„´ýÿÿ‰„$”‰ÂHŽ¤ýÿÿé«ýÿÿ´&‹ „B‹-œ„B‰L$‹|Ç$øC‰|$è\ …ÀudC;p„BrÏ…ö„¨úÿÿ1Û;t„Bƒšúÿÿ‰ö¼'‹-„B‹= „B‰l$‹ŸÇ$øC‰T$è …ÀuC;t„BrÐé\úÿÿ1öéUúÿÿ¾릉$1ÛèÃv‰ôŒCéôùÿÿ‹¼$€Of9=JC…ƒ=,„BŽÇD$ÇD$XpBÇ$¤„Bèúv…Àu,‹l$|…íu ƒ¼$”~ ‹”$”éœüÿÿ¹ ‰Œ$”ëæÇD$ð@Ç$¸ŒBèæu‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cº‰”$”ë‘‹D$h‹t$d‰D$‰4$ès…ÀˆRÆ„$“ H½gfff‰È÷í‰Ö‰ÊÁþÁú)Öƒþd„ ¾Œ$“œ$Љt$ ÇD$pÛ@‰$‰L$èKu‹¼$Œ…ÿ„Œƒ|$|¸ß@t¸ß@‰D$‹T$|‹D$h‰\$‹t$d‰T$‰D$ ‰t$ÇD$Ý@Ç$¸ŒBè÷t‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹\$\…Ûu‹l$P…ít5ÇD$ß@Ç$¸ŒBè²t‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹L$X…Étb‹\$\…ÛtZƒ|$X¸ß@‹|$\‰|$t¸ß@‰D$ ‹t$XÇD$0Þ@Ç$¸ŒB‰t$èHt‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹D$L…À„Õýÿÿ‹T$P…Ò„Éýÿÿƒ|$L¸ß@‹l$P‰l$t¸ß@‰D$ ‹L$LÇD$pÞ@Ç$¸ŒB‰L$èÖsÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’Céjýÿÿƒ|$|¸ß@t¸ß@‰D$‹t$P‹D$|ÇD$ÐÝ@‹|$\‹\$d‰D$‰t$‰|$ ‰\$Ç$¸ŒBègsëÇD$wÛ@œ$Љ$èNséþýÿÿÆ„$“-¹)Áé¥ýÿÿÇD$P@‹¬$€Ç$¸ŒB‰l$ès‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBèár‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CºéJùÿÿ¶‹ „B…ÉtY‹´$Œ½ppB‹|õÇD$Ü@‹õppB‰|$ ‰\$Ç$¸ŒBèsr‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé=õÿÿ‹œ$Œ¾ppB‹TÞÇD$1ß@‹ ÝppB‰T$ ‰L$ë¥t&U½W1ÿVSƒì\‹T$p‹D$tÇT$ lj´ŒBt&ÇD$Ç$¤„Bè,·ÿÿ…Àº3„’ÇD$ÇD$PpBÇ$¤„Bèƒr…À…yèF(…À‰Â…_·0CÇD$‰$è¥Çÿÿ…Àt ƒø‰Ç‰Â7¡ôŒC…À… ·2CÇD$‰$èpÇÿÿ…Àt ƒø‰Ç‰Â‹ x„B…Éu%1ö1Û;5p„B‚U‹x„B…Ûu …ö„¤v¹øCt&¼'‹1ƒÁ–ÿþþþ÷Ö!ò €€té÷€€uÁêƒÁÒƒÙéøC…§‹ôŒC…Ò„‰· 2Ct$@ÇD$‹ C‰t$ÇD$‰\$ ‰L$‰$è—)¨tP‹D$D‹T$p9}‰‹L$tÿ·4Cf…ÀuEémþÿÿÇD$·Ø‰$èjÆÿÿ…Àtãƒø‰Ç‰Â~ÚƒÄ\‰Ð[^_]Ë C‰$èuÄÿÿ뤉L$Ç$øCèóÑÿÿ¶€û/tœ‹´ŒB€z…1ÿÿÿÇD$/Ç$øCè'Òÿÿ…À…ÿÿÿ€û\… ÿÿÿébÿÿÿ‹„B‹ œ„B‰T$‹™Ç$øC‰T$è…Àu[C;p„BrÐ…ö„sþÿÿ1Û;t„Bƒeþÿÿ‹ „B‹ „B‰L$‹ šÇ$øC‰L$è×…ÀuC;t„BrÐé0þÿÿ1öé)þÿÿ¾믉$1öèo‰5ôŒCéËýÿÿMÿf9 JCuzÇD$ÇD$XpBÇ$¤„BèÚo…Àu‹l$t‹E…Àuƒÿ~‰úé²þÿÿ¿ ëòÇD$ð@¿Ç$¸ŒBèÏn‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C릉l$ÇD$P@Ç$¸ŒBè”n‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBè_n‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cºé÷ýÿÿt&ƒì1À‹L$ ‰$‹\$…ɉt$t(ù€„v@¸ÓMb÷á‰ÖÁî9Ùr Áê)Ù 1Ò÷öt&‹$‹t$ƒÄÃt&Áê)Ë1Ò÷ö÷Øëà9Ùr‰È1Ò)ØiÀè‰ËÑëØ÷ñëƶ)ˉÊiÛèÑê1Ò÷ñëÇt&¼'ƒì‰\$ÇD$¸ŒBÇ$øCèÕ«ÿÿ‰$‰Ãè›m‰D$‰\$ÇD$ Ç$ðƒBÿX’CÇD$ ÇD$ÇD$ß@Ç$ðƒBÿX’C‹\$ƒÄÃUWVSƒì‹T$4‹D$8‹t$0‰T$‰D$t&¶‹=¥C‹‰4$‰L$èélÆ…Û„%ƒû?„öƒû*„ƒƒû[txƒû\tf‹|$…ÿuO¶Û‹T$…Òu3‹|$¶9Ãu‹¥C‹\$‹*‰$‰l$èlD$ë‡1ÀƒÄ[^_]ËD$¶‰ $ènmëöë‰,$èam‰Ã륶1ÀF…ÛuëÌ‹l$€}t¿ÇD$¶‰÷„¹´&…턉1í‹¥C‹‰<$‰T$èòkǶ„ÒuÙ1À€ú]…Yÿÿÿ1Û€>-”Á9þ¶éƒ•t&¼'…íu¶€ú\„'€ú-„‹l$…í…ó‹T$¶*€~-t6…ۉ؅Զ¶Â¶Ê‰Ã9Èwt&‹L$…É…œ9ëtyC¶Ê9Ëvè1í1Û‹ ¥C‹‰4$‰T$è@kÆ9þ‚vÿÿÿ‹\$1À…Û„£þÿÿ‹¥C‹ ‰<$‰L$èk‹¥C,8‹D$‹2‰$‰t$‰îè÷j‹l$<(‰|$éçýÿÿ‹t$1À…ö…Tþÿÿ‹D$w@‰D$éÈýÿÿ‰$èÀk9ètÕ¶éTÿÿÿt&¶é*ÿÿÿ‹D$¶‰ $è™k‰Åéþþÿÿ¶^ÿé5ÿÿÿ½é+ÿÿÿ¶€ú\t€ú]…hþÿÿé‹þÿÿ½éYþÿÿ¶énþÿÿÇD$éþÿÿ€>u ¸é¶ýÿÿ‹\$€;tE‰4$‹D$‹l$‰D$‰l$èúüÿÿ…À…ýÿÿ‹¥C‹|$‹‰<$‰T$èúiD$‹L$€9u»¸é^ýÿÿv‹l$€}„Kýÿÿ‹=¥C‹L$‹‰ $‰T$é(ýÿÿ‹t$€>”öÃé#ýÿÿ´&ƒì ‹T$‹L$‰T$‹T$‰L$‰$èaüÿÿH”ÂƒÄ ¶ÂöSƒì‹\$¶„Àt.<\t<þÿÿ‹T$$‹t$ òêú…ÒÖýÿÿé#þÿÿÇD$ ÇD$ÇD$ªü@Ç$ðƒBÿX’Céœýÿÿƒ|$(…oýÿÿéŒýÿÿv…ö„ýÿÿ‹ ÜŒC‰ $èêñÿÿ…À„†‰4$èÚñÿÿ…À„èüÿÿÇD$ ‹5øƒB‹ÜŒCÇD$$…öÇD$‰T$ tC¸þ@‰D$ÇD$`õ@Ç$¸ŒBèéZ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céyüÿÿ¸#ö@뻉4$èäZ‰5àŒC0Ç.zipÆCÇD$ ÇD$$ÇD$Ç$è ƒø ‰Ãtƒø %ƒøt…ÛtEƒûŽüÿÿ‰\$é üÿÿÿD$(ëèGëåƒøLuÛÇD$$» ëÚ¸éºúÿÿÇD$àó@Ç$¸ŒBèZ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸éÔýÿÿë WVSƒìèÅËÿÿÇD$Ç$豘¡¸ŒC…À…סø‘C…À…µ¡ôŒC…À…“¡ìC…Àuu¡äC…Àub¡ÀŒC…ÀuO1ÿ1ö‰=äC¿À„B‰5ÀŒC1ö´&‰óÁ㋃ЄB…ÀuFƒþ?vëƒÄ[^_Ãt&‰$èˆY1Ò‰Të߉$èxY막$ènY딉$èdY1ɉ ìCévÿÿÿ‰$1ÛèMY‰ôŒCéXÿÿÿ‰$è:Y1Ò‰ø‘Cé6ÿÿÿèÈ8ÿÿ1À£¸ŒCéÿÿÿ %sEmpty zipfile. warning: cannot set time for %s Archive: %s U1íWVSƒì,1ÛÇD$(‹àŒC‹|$@ÇD$XC‰$èó …Àu!‹XC1Û‰Ñáðù@”Ã…Û„þ…ÿ„–ƒ=,„B‰‹ÜC…Ò„“‹5øƒB¸A‹=àŒC…ö‰ò‰|$u¸¸ü@‰D$‹-ÜŒC…Ò¸þ@‰l$ u¸#ö@‰D$ÇD$ õ@Ç$¸ŒBè§WÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C¶1É…Û•ÁIƒá½QLƒÄ,‰Ð[^_]Ë øƒB‹5àŒC‹ÜŒC…ɉt$‰T$ t¸þ@‰D$ÇD$ö@Ç$¸ŒBè-W넸#ö@ëßt&‹ˆCöÂ@‰èŒCt½è´ÿÿ…Àº uŠ‹¸ŒC…Ò„ ‹ðƒB…Òt‹5„„B…ö…¢¡øƒB1Ò‹ÀŒC‰ìŒC…À‰ÄŒCu ‹ ,„B…Éu‹5<„B…ö„…À„š‹èŒC‰$èÛ…À‰Ætq‹ äŒC‰ $è—U…íu…ÿ‰ò…÷þÿÿ¸º £ÜCéãþÿÿÇD$@ö@‹-àŒCÇ$¸ŒB‰l$è7V‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cë¡è?:ƒø‰Æƒ¡øƒB…Àu8¡èŒC=Ð~¸Ð‰$è6…À‰Æ…WÿÿÿèÇ ƒø‰ÆGÿÿÿ¡øƒB‹=P„B…ÿ~…À„1Û…À…7fƒ=DCt»…ۅסŒ„B‹„B)УðŒC…Àˆv…À~~‹PC…Òu‹=LC…ÿ…þ¡ðŒCº¸ü@ƒøtº¹ü@‰T$‹àŒC¾‰D$ ÇD$ù@‰\$Ç$¸ŒBèU‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹„B…Ò…±‹-LC…í…£‹øƒB…Òtqƒ=„B ~a¸A‰D$ÇD$AÇ$¸ŒBè²TÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‹ äŒC‰ $è£Sƒþ‰ð|‰Âéýÿÿ¸ëò¸¸ü@ëÇD$@ú@‹=àŒCÇ$¸ŒB‰|$èITÇD$ ë•‹PC‰$èq²ÿÿƒø„©…ÀuÇD$Ç$¤„Bè`™ÿÿ…À…`‹-PC1À‹5ðŒC£ðŒC‰,$è-²ÿÿ…À‰ÃtnƒûtGÇD$ p@‹àŒCÇD$€ú@Ç$¸ŒB‰T$è¼S‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹=äŒC‰<$è­R…ۉ؅ÿÿÿ¸éýþÿÿÇD$Ç$¤„B赘ÿÿ…À„vÿÿÿÇD$ÇD$PpBÇ$¤„BèT…À…RÿÿÿÇD$àú@‹ àŒC÷Þ‰t$ ¾‰L$Ç$¸ŒBèS‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹PC‰$è!±ÿÿ…À‰Ã…‹-øƒB…í…‹<„B…Ò…Û‹D„B…Ût‹-8„B…íu‹„B…Ò„«èt]ÿÿ9ð~‰Æ‹ äŒC‰ $è Q‹=<„B…ÿt‹øƒB…Ûu‹D$(…Àu‰òéëúÿÿ‹T$$‹-àŒC‰T$‰,$è7¡…Àt߃=,„B~ …öÒ¾ëËÇD$@A‹=àŒCÇ$¸ŒB‰|$èR‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cë´èIÔÿÿéPÿÿÿt&L$(|$$‰L$‰<$è¬ßÿÿé3ÿÿÿè’:é)ÿÿÿ‹5äŒC‰4$èÏP‰Úé6úÿÿÇD$ÇD$PpBÇ$¤„Bè\R…À„•þÿÿéwýÿÿ‹5äŒC‰4$è‘Pºéõùÿÿ´&ÇD$àù@‹ àŒCÇ$¸ŒB‰L$èBQ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹5ðŒC1À£ðŒC‰5PC¾éüÿÿÇD$€ù@‹-àŒC÷؉D$ Ç$¸ŒB‰l$èàP‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cë¯ÇD$à÷@‹àŒC¾Ç$¸ŒB‰\$èšP‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céàúÿÿ·DC·FCf9„Áúÿÿf9ÂvWÇD$€ö@‹5àŒC·Ê‰L$ ·è‰l$‰t$¾ Ç$¸ŒBè'P‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CésýÿÿÇD$ ÷@‹=àŒC·ò‰t$ ·È¾‰L$‰|$Ç$¸ŒBèÐO‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C1Ò…Ò…ýÿÿéúÿÿ‹äŒC‰$è²Né)ýÿÿÇD$¸ C‹àŒC‰$è×ÿÿ‰D$ÇD$bAÇ$¸ŒBè_O‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡øƒBé“øÿÿÇD$1Ƀ= „B‰$”Á‰ €„BèŽ=‰ÃŽ/øÿÿ‹-äŒC‰,$èN1Éû ”ÁT éq÷ÿÿèN.ÿÿ£¸ŒC…À…ã÷ÿÿ‹=äŒC‰<$èãMºéG÷ÿÿ[%s] vW1ÿVSƒì0¡èŒC= Ž³…À‰Âˆžâàÿÿ‰Ã)Óƒûª)Ø£ìŒC‹D$@)؉ÂÂÿˆ„‰Ö»Áþ …ÿu9óŽp…ÿ„×ÇD$‹ÄŒCL$‰ $¡ÀŒC‹=ìŒC)Âú‰Œ„Bèc“ÿÿ…Àº3„’T$t$‰$\$袪ÿÿf£DCL$|$‰ $茪ÿÿf£FC‰4$è~ªÿÿf£HC‰$èpªÿÿf£JC‰<$肪ÿÿ£LCT$ ‰$èqªÿÿ£PCL$$‰ $è@ªÿÿf£TC‹LC1Ò‹5PCó‰„BƒÄ0‰Ð[^_Ë,„B…Ûu ¡øƒB…Àt?ÇD$'A‹5àŒCÇ$¸ŒB‰t$è:M‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$€û@Ç$¸ŒBèM‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CºéfÿÿÿÇD$ ¡ìŒC‹ äŒC- ™‰ $£ìŒC‰D$‰T$èŒMÇD$ ‹ÀŒC‹ äŒC‰T$‰ $èlK£ÈŒC= …2þÿÿ‹ ÀŒC‘ÿ9ʉÄŒCr¶¡ÄŒC€8Pt6H9ȣČCsì·C¡øŒC…ÿf‰¶QˆP…ïýÿÿ9óŽOÿÿÿéÚýÿÿt&ÇD$ÇD$XpB‰$èØL…Àt ‹ ÀŒC¡ÄŒCë¡‹=ÄŒC‹ ÀŒC)Ï)=ÈŒC¿ëþ?éqýÿÿÇD$ )Ø™‰T$‹äŒC‰D$‰$èL£ìŒC‹5ÀŒC‹ äŒC‰\$‰t$‰ $èoJ£ÈŒC9Ø…þÿÿ‹ ÀŒCt ê9Ή5ÄŒCr"´&¼'¡ÄŒC€8Pt"H9ȣČCsì·‹5øŒCf‰¶AˆFéÀüÿÿÇD$ÇD$XpB‰$èìK…Àt ‹ ÀŒC¡ÄŒC뵋ÄŒC¿‹ ÀŒC)Ê)ÈŒCë¤ÿéWüÿÿÇD$ ‹äŒCÇD$ÇD$‰$èŸK‹ÀŒC‹ èŒC‰T$‹äŒC‰L$‰$è}I;èŒC£ÈŒC…!ýÿÿ‹ ÀŒCtê9Ή5ÄŒC‚*üÿÿ¡ÄŒC€8PtH9ȣČCsìéüÿÿÇD$ÇD$XpB‰$èK…Àt ‹ ÀŒC¡ÄŒCëÈ‹=ÄŒC¡ÀŒC)Ç)=ÈŒC¿éËûÿÿt&ƒì·TC‰\$1Ûf…Àt+‹P„B…Ò~gÇD$·È‰ $èþŸÿÿ…Àuv¼'‰Ø‹\$ƒÄÃÇD$€ü@»Ç$¸ŒBè­I‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C뺅Òu¶‹ <„B…Éu¬‹,„B…Òu¢é|ÿÿÿ¶¼'ƒì è(…À…—¶C‹ ´ŒBˆA‹´ŒB¶C<v°ˆB‹´ŒB€bï¡ „BƒøtvH~ ‹ ´ŒB€I¡´ŒBö€ú t9€út4t&€`ß÷A\?AÒ@AÒ@AÒ@Aˆ?A¶?AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÁ?AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÛ?AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@Aø?AÒ@AÒ@AÒ@AÒ@AÒ@A`?AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@AÒ@A@AÒ@AÒ@AÒ@AW@Ai@AÒ@AÒ@AÒ@AÒ@AÒ@A{@A@AÒ@AÀ@AÒ@AÒ@AÒ@AÜ@AAv¾B…À…¤þÿÿK…ÛŽqýÿÿƒÆ‹€:-„}þÿÿé^ýÿÿ…Éu¸ë £„Bë¹¹þÿÿÿ‰ „B1É명Éuí¸ëß…Ét 1ɉ „Bë㸣„Bë……Ét 1ɉ X„Bëɸ£X„Béhÿÿÿ…Ét 1ɉ <„B문£<„BéKÿÿÿ…ÉtÇD$$ÇD$ ë‡ÇD$ÇD$$ÇD$ ƒ=„Bÿ…ÿÿÿ1ÀéIÿÿÿ…É…Hÿÿÿ¸é7ÿÿÿ…É…6ÿÿÿ¸é%ÿÿÿ…É…$ÿÿÿ¸éÿÿÿ…ÉtÇD$ÇD$é ÿÿÿÇD$ÇD$ÇD$냅É…ßþÿÿ¸ éÎþÿÿ¿é„þÿÿ…Ét1À1É£P„Bérþÿÿ¸ëïentryentriesisare¶Sƒì1Û‹„B…Ò…üƒ=„B †¡P„B…Àt·TCf…Àuv¼'ƒÄ‰Ø[ÃÇD$·Ð‰$è–qÿÿ…ÀtâÇD$°&A»Ç$¸ŒBèY‰D$ÇD$ ¶¼'ÇD$¸ŒBÇ$ðƒBÿX’Cë™ÇD$!AÇ$¸ŒBè‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$P!AÇ$¸ŒBèà‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$!A‹„B‹ Œ„BÇ$¸ŒB‰T$‰T$‰L$ ‰L$è‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·DCf…Ò…¾·JCºõ@A‹ LC‰L$fƒø‰L$tºû@A‰T$ ·È‰L$ÇD$p"AÇ$¸ŒBè‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$P#A‹PC‰T$ ‰T$Ç$¸ŒBè׉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·TCf…Àu*ÇD$0%AÇ$¸ŒBè–‰D$ÇD$ éEþÿÿt&ÇD$P%A·È‰L$Ç$¸ŒBèe‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$°%AÇ$¸ŒBè0‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·TCÇD$‰$èoÿÿ…Àt»ÇD$&AÇ$¸ŒBèÛ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C…Û„"ýÿÿÇD$p&Aéÿÿÿt&·HC¹AAfƒøt¹AA‰L$·È‰L$· FCÇD$#AÇ$¸ŒBA‰L$ ·ÊA‰L$èV‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·JC‹LCfƒø‰T$‰T$ºõ@Atºû@A‰T$ ·È‰L$ÇD$0$AÇ$¸ŒBèñ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$Ð$AéÒýÿÿv‹àŒC‰$èâƒø&¹Ð A~¹ö A·JCº° Afƒøtº± A‰T$·Ð‰T$‹èŒC‰L$Ç$¸ŒB‰T$ ‹àŒC‰T$è]‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé{ûÿÿ -‰öU1íWVSƒì<¡p„BÇD$4ÇD$0…ÀÇD$,ÇD$(ÇD$$……¡t„B…À…:€%Ì„B÷1Û1Òƒ=@C¹´„B‰ „B¿‰ ´ŒB”ÂÁâ‰T$8vÇD$Ç$¤„Bèì[ÿÿ…Àº3„BÇD$ÇD$PpBÇ$¤„BèC…À…ÈèÍÿÿ…À‰Â…·0CÇD$‰$èelÿÿ…Àt ƒø‰Å‰Âç‹ x„B…Éu*1ö1Û;5p„B‚¿‹x„B…Ûu…ö„?´&¡„Bƒø wFÿ$…ôFAv0GA GA GAÆGAÆGAÆGA0GA0GA0GA0GAÍGAè+¨ÿÿt&¼'·2Cf…Àud·4Cf…Àu+‹(C¡,C\$(D$$öCtƒl$( ÿD$,Gé½þÿÿÇD$·Ð‰$èzkÿÿ…Àt¾ƒø‰Å‰Â~µƒÄ<‰Ð[^_]ÃvÇD$·È‰ $èMkÿÿ…Àt…ƒø‰Å‰ÂŽxÿÿÿëÍè'빉|$t$8ÇD$ð&AÇ$¸ŒBè÷‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‰4$è>éoÿÿÿ·2Cf…Àu=·4Cf…À„:ÿÿÿÇD$·È‰ $èºjÿÿ…À„ÿÿÿƒø‰Å‰ÂŽÿÿÿé3ÿÿÿÇD$·ð‰4$èjÿÿ…Àt¬ƒø‰Å‰Â~£éÿÿÿ‹„B‹ œ„B‰T$‹™Ç$øC‰T$訪ÿÿ…ÀuwC;p„BrÐ…ö„ þÿÿ1Û;t„Bƒûýÿÿt&‹ „B‹ „B‰L$‹ šÇ$øC‰L$è]ªÿÿ…ÀuC;t„BrÐéÁýÿÿ‹T$01ö…Ò„³ýÿÿ‹D$0ǘé£ýÿÿ‹L$4¾…Ét‹T$4Çšë€wÿf95JC…p‹8„B…Ò…¨‹T$4…Òt+¡p„B1ÿ9Çs‹\$4‹4»…ö„:G9Çrì‹|$4‰<$袋D$0…Àt+¡t„B1ÿ9Çs‹\$0‹4»…ö„»G9Çrì‹|$0‰<$èoÇD$ÇD$XpBÇ$¤„BèÓ…ÀuK‹t$,…öuƒý~7ƒ=„B ‰êé•ýÿÿÇD$ ÇD$ÇD$©EAÇ$ðƒBÿX’CëÒ½ ëÂÇD$ð@½Ç$¸ŒB蛉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cévÿÿÿ‹ „B‹ ºÇD$0@Ç$¸ŒB‰L$èT‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡t„Béùþÿÿ‹œ„B‹ ºÇD$ð@Ç$¸ŒB‰L$è‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡p„Bézþÿÿ‹t$(»«EA‹|$$‰t$‰<$蔣ÿÿ…À‰Áˆ‹‰\$¸gfff‰Î÷é‹\$(Áþ‹D$$‰\$Áú)ò‰D$<’ÿ‰T$)ù¸° Aƒ|$,‰L$ t¸± A‰D$ ‹L$,ÇD$0'AÇ$¸ŒB‰L$èU‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céªýÿÿ»¬EA÷Ùéiÿÿÿ‰|$ÇD$P@Ç$¸ŒBè ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p@Ç$¸ŒBèÖ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cºé^ûÿÿÁà‰$è‰D$0…À„¯ùÿÿ1ÿ;=t„Bƒ¡ùÿÿ‹D$0ǸG;=t„BrìéˆùÿÿÁà‰$è‰D$4…À„dùÿÿ1ÿ;-p„BƒVùÿÿ‹T$4ǺG;=p„Brìé=ùÿÿ yestextebcdicbinaryexelnk arc dir lab sys hid rdo may be.unXABFHCFABunknownXABALLXABDATXABKEYversionXABRDTXABPRO%02xnonot ´&UWVSìL‹œ$`ÇD$@‹@C‹9Ât…À… ·=0C‹5(C·2C ‹”$`ÙñƒÁ‰ ÇD$‰$èLeÿÿ‰D$D…Àt¡ôŒC…À…ª‹l$D‰l$@¶C‹´ŒB<¶K‰L$<¶sÇD$8w¶Ð‰T$8·C¶=Cfƒû ·ëv½ ÇD$ ÇD$ÇD$±LAÇ$ðƒBÿX’Cè ¡ÿÿÇD$P)A‹ @CÇ$¸ŒB‰L$ ‰L$è{‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒ|$<‡¹‹\$<‹ÀpB‰D$»ÍÌÌÌÇD$°)AÇ$¸ŒBè'‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$ð)A‰ð÷ãÇ$¸ŒBÁê ’‰T$É)Ήt$ èÜ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒ|$8‡ñ‹L$8‹ÀpB‰D$¾ÍÌÌÌÇD$0*AÇ$¸ŒBèˆ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p*A‰ø÷æÇ$¸ŒBÁê’‰T$Û)߉|$ è= ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒý ‡+‹­ qB‰D$ÇD$°*AÇ$¸ŒBèô ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cƒý„vuøƒþ†öC„¸° A‰D$ÇD$°+AÇ$¸ŒBè” ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CöC„­¸´LA‰D$ÇD$,AÇ$¸ŒBèI ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$Œ$‰L$Ç$ Cè‰+ÇD$P,A„$‰D$Ç$¸ŒBèê ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹ôŒC…Ò…àÇD$ð,A‹$CÇ$¸ŒB‰\$è ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$0-A‹ (CÇ$¸ŒB‰L$è^ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$p-A‹,CÇ$¸ŒB‰T$è ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·-0CÇD$°-AÇ$¸ŒB‰l$èß ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·=2CÇD$.AÇ$¸ŒB‰|$èŸ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·54CÇD$P.AÇ$¸ŒB‰t$è_ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·6CÇD$°.AÇ$¸ŒBC‰\$è ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C·8Cº¸LA¨u¨º½LAuºÄLAë ‰T$ÇD$ð.AÇ$¸ŒBè¸ ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¡évþÿÿ‰$èCàé6þÿÿ1Àë¢U‰åWVSRQ‹u )À…ö„›èƽþÿ‰Ç‹E)Û‹M÷Ð…É„€÷Æt2FˆÃÁè3ŸIuê‰ÊÁétN3ƒÆˆÃÁè3ŸˆÃÁè3ŸˆÃÁè3ŸˆÃÁè3Ÿ3ƒÆˆÃÁè3ŸˆÃÁè3ŸˆÃÁè3ŸˆÃÁè3ŸIu³‰Ñƒát2FˆÃÁè3ŸIuò÷ÐYZ[^_]à SetFileTime failed: %d ´& CreateFile() error %d when trying set file time %-22s t& warning (%d): could not set file attributes ‰öƒì\‹àC‰\$L‰t$P‰|$T‰l$X‰$èïÞ¡„B…Àt‹\$L‹t$P‹|$T‹l$XƒÄ\Éö\$@l$8‰\$,|$0‰\$‰l$‰<$èÐ4ÇD$‰ÃÇD$€ÇD$ÇD$ ÇD$ÇD$@Ç$øCèâß‹ ´ŒB‰Æƒì‹A¨_…Þ‹ôŒC…Ò…âƒþÿ„–…ÛtB‰4$1ÉöÔÁ1ÒI!ÏöÔÂ1ɉ|$ J!Õ‰l$öÔÁI!L$,‹|$,‰|$è†ßƒì…Àt‰4$è‡ßƒìé ÿÿÿèŠß‰D$ÇD$0AÇ$¸ŒBèâÛ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cë°èJ߉D$ÇD$PAÇ$¸ŒBè¢Û‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé†þÿÿ· C‰T$Ç$øC‰L$è±/ƒøO…úþÿÿ¡,„B…Àuo‹ôŒCƒÂ‰$èî7ÿÿ‹ ,„B·Àƒè …ÉtGº‚A‰T$ ‰D$ÇD$ðd@Ç$¸ŒBè Û‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé‰þÿÿº„Aë·ÇD$¸ CÇ$øCè,ÿÿ‰D$ÇD$…AÇ$¸ŒBè´Ú‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé?ÿÿÿÇ$øCƒà‰D$èÞƒì…À…þÿÿèû݉D$ÇD$AÇ$¸ŒBèSÚ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CéÁýÿÿwarning: cannot set UID %d and/or GID %d for %s ´&¼'warning: cannot set modification, access times for %s ´&warning: cannot set permissions for %s ´&VSƒì‹t$ èÒS…ÀuÇ1ÀƒÄ[^ËôŒC…Ò…¹øC¶¼'‹ƒÁ“ÿþþþ÷Ó!Ú €€té÷€€uÁêƒÁÒƒÙéøCQ0‰$èEÙ‰‰Ã…Û¸t’S,‰S‰$ÇD$øCè2Ù‹ ´ŒBS‹qK‰s$s‰T$‰L$‰4$è­0‰C éMÿÿÿ· C‰T$Ç$øC‰L$èÊ,ƒøO…?ÿÿÿ¡,„B…Àuo‹ôŒCƒÂ‰$è5ÿÿ‹ ,„B·Àƒè …ÉtGº‚A‰T$ ‰D$ÇD$ðd@Ç$¸ŒBè&؉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CéÎþÿÿº„Aë·ÇD$¸ CÇ$øCèEÿÿ‰D$ÇD$…AÇ$¸ŒBèÍ׉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cé?ÿÿÿ´&ƒì<‰|$4‹|$@‰\$,‰t$0‰l$8èR1Ò…Àu‹\$,‰Ð‹t$0‹|$4‹l$8ƒÄ<ÃÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$@‹WÇD$(‰$è…Úƒì‰Åƒøÿ„±‹w …ötN‰,$1É_÷Æ”Á1ÒI!Ë÷ÆO”Â1À‰\$ J!щL$÷ÆW”ÀH!‰T$è9Úƒì…Àt‰,$è:Úƒì‹T$(é0ÿÿÿè9Ú‰D$ÇD$0AÇ$¸ŒBè‘Ö‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$(ë¤èñÙ‰D$ÇD$PAÇ$¸ŒBèIÖ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CÇD$(édÿÿÿ//\\VFATHPFSFAT´&U¹W¿Å†AVSì\‹œ$pü‰Þó¦t‰Þ¿È†A¹ó¦u.¶C„Àt&‹t$(´&‹=¥CF¶ƒ?„”ÇD$‰$è}Ê…ÀuÙ€>u‹D$(Æ‹5„B…ö…|\$0‰$胀|$0uiÇD$¸ CÇ$øCèÿÿ‰D$ÇD$°AÇ$¸ŒBè ÉÇD$ ‰D$ÇD$¸ŒBÇ$ðƒBÿX’C‰êâÿ€ÿÿÊÄ<‰Ð[^_]ÃÇD$D$0‰$è?ÇD$Ç$øCè+‹ ´ŒBöA „Á¶Œ’C\$,fÇD$-:\‹=,„BÆD$/€Â`…ÿˆT$,tCÇD$øC‰$èã̃ì…Àt‰êâÿ€ÿÿÊéiÿÿÿÇD$ðAÇ$¸ŒBèÅÈé ÿÿÿÇD$¸ CÇ$øCè ÿÿ‰D$ ‰\$ÇD$ŽAÇ$¸ŒBèȉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Cégÿÿÿ‰êéóþÿÿ·=C‹ôŒC‰|$‰$芅ÿÿ…À„cþÿÿƒÀ‰$è%ÿÿ‹L$$‰Ã…Ét6‹t$$‹=¥CF¶ƒ?„‡ÇD$€‰$è†È…ÀuÙ‹T$$ƒÂ9ÖtY…Ûx»ýL$0‹1ƒÁ–ÿþþþ÷Ö!ò €€té÷€€uÁêƒÁÇD$*ŽAÒƒÙÁûãÿ‰\$‰ $è£Çé¿ýÿÿ‹D$$€xuÆ똋=P¥C‹·Q%€ésÿÿÿ‹P¥C‹ ·QƒàéhýÿÿÇD$Ç$øCèA‹5€’C…ö„ö¡,„B…À„—‹=´ŒB‹G¨ou‰êâÿ€ÿÿÊé¦ýÿÿÇ$øCƒà‰D$è£Êƒì…ÀuÓÇD$¸ CÇ$øCèHÿÿ‰ÆèqʉD$‰t$ ÇD$0ŽAÇ$¸ŒBèÅƉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CévÿÿÿÇD$¸ CÇ$øCèëÿÿ‰D$ÇD$eŽAÇ$¸ŒBèsƉD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céÿÿÿƒ=|„B…Týÿÿ‹´ŒB‹B¨o„CýÿÿÇ$øCƒà‰D$è¼Éƒì…À…%ýÿÿÇD$¸ CÇ$øCè]ÿÿ‰Çè†É‰D$‰|$ ÇD$0ŽAÇ$¸ŒBèÚʼnD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’CéÈüÿÿt&ÇD$¸ CÇ$øCèüÿÿ‰D$ÇD$ŽAÇ$¸ŒBè„ʼnD$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C÷Åÿ€ÿÿ…øúÿÿåƒÍéêúÿÿÇD$l$0‰,$è%‰Å%‰ê=Žqúÿÿé¬ûÿÿ‹ T„B…É…Súÿÿü»ØˆA¹t$0‰ßó¦…:úÿÿÆD$0ÇD$ é(úÿÿ‹=0„B…ÿt Æ_Fé0úÿÿÇ$øCèÄîÿÿ…À”Á¶ÑJ…”’CuÚÆ ë؉t$$Æ,‹t$$ëˉt$(Æ;ë‹¥Cƒ:tdÇD$W‰$èýÄ‹¥C…Àu ƒû~†Ðùÿÿ‹ ‹|$‰L$‰<$èhĉD$‹D$‰4$‰D$èÔÄ‹¥C‹‰4$‰\$è@ÄÆé‰ùÿÿ‹ P¥C‹9·_%WëŸÇD$øCé„÷ÿÿÇD$/Ç$øCè…&ÿÿ‰D$éW÷ÿÿ¶øC¾€=úC/‰5„’Ct$2ˆT$0ÆD$1:ÇD$úCtÆéäöÿÿÆD$2/t$3ÇD$ûCëå‹=P¥C‹/·DU%é¢öÿÿÆD$0/¸£„’CÆD$1ÇD$ùCé˜öÿÿ‹L$Æ/éöÿÿ¶¿ƒì ‰\$‹\$ÇD$XC‰$èE…Àu‹XCâðú t‹\$ƒÄ É$è=ÉÂBt´&¶Lÿˆ JuõÆ_ëÓcheckdir: cannot create extraction directory: %s ¶¼'checkdir warning: current dir path too long checkdir warning: path too long; truncating %s -> %s ¶checkdir error: path too long: %s checkdir error: cannot create %s unable to process %s. checkdir error: %s exists but is not directory unable to process %s. ´&UWVSì<‹”$T‹¼$Pƒâƒú„¼ƒú„`ƒú„ƒú„m…Ò…9…ÿ„%‹¸–C…Ò~´&1ÀÄ<[^_]É<$èËÀ£¸–C…À~âX1í1ö‰$èãÀ…À‰Ã„‰|$‰$èÝÀ¶‹=¥Cƒ?„©ÇD$‰$èËÀ…Àt €{:„‹¸–C¶Dÿ¿‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‰$1Ûèc¿‰¸–C¸éUþÿÿ‰$èK¿1Ò‰¸–C¸é;þÿÿ‹¸–Cé1ÿÿÿ…í…)ÿÿÿéÿÿÿJ½‰¸–CÆéšþÿÿ¾éuþÿÿ‹=P¥C‹·Q%éQþÿÿ1À£¸–Céàýÿÿƒú¸c…Ôýÿÿ‹-¸–C…íŽÄýÿÿ‹œ’C‰$趾ëÈ¡¸–C‹ˆ’C‹„BÐ…Û„†ƒÀ‰$èž¾£ ’C‰Æ…ö¸ „|ýÿÿ¡¸–C‹ˆ’C‹ „BØ…É„FƒÀ‰$èd¾£¤’C…À„‹-´ŒBöE „Ç¡„’C…À„™€:„wÇD$t$T$ ‰t$ ‰T$Ç$ÖˆAè\Áƒì=‡¾|$ ‹  ’Cƒï`‰=Œ’C¶Œ’C€Ã`ˆ‹ ’C‹ 4„B¾ƒè`…É£Œ’C„œ€:`Ž“ItaÆ‹ ’C‹-¤’C‰¨’C‰-¬’C¶ „ɈM„züÿÿv¼'‹=¨’C‹5¬’CO‰ ¨’Cn‰-¬’C¶_„Ûˆ^u×éBüÿÿÆD$:@l$ˆD$ÆD$/ÆD$‰,$èÑÀƒìƒøt&‹ ’C‰$è ½‹¤’C‰$èý¼¸éõûÿÿ‹ ’CéEÿÿÿÇD$0šAÇ$¸ŒB脼‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C¸é«ûÿÿ¾‹ ’C‰$èX½ˆéÃþÿÿƒ=¸–CŽdþÿÿ¡œ’C€x:…Uþÿÿ¾ëÊ¡„’C…Àu5‹5¸–C…ö~‹ œ’C‰L$‹ ’C‰$èe¼é þÿÿ‹= ’CÆé’þÿÿ‰|$ëÙ‹= ’C‰<$è¼éYüÿÿ@é·ýÿÿ@éwýÿÿ¶1Û‹¨’Cw‰õ„Ɉ t8´&‹¨’C‹  ’CB£¨’C)È=ÿ€¶F‹¨’Cˆ „ÉuÏ‹5´ŒBöF t3¶‰î‹=¬’Cˆ„Ét‰ö‹-¬’CE£¬’C¶F„ɈMuç‰Øé‚úÿÿ‹5 ’C‰4$è"åÿÿ…À”¶ÊI… ”’Ct®ÇD$¬’C‰<$èëȉ¨’CÆ‹ ’CÇD$¸LC‰$è@ùþÿÇD$¸ C‰ÃÇ$øCè*ùþÿ‰D$‰\$ »ÇD$pšAÇ$¸ŒB詺‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céÿÿÿ‰<$‹-¤’C1Û‰l$1íèݺ‹5¤’C‰4$诺‹ ’C‰$衺‰¨’C1É1À‰ ¬’C‰-¤’C£ ’Céùÿÿ¶1Û‹ ¨’Cˆ„ÒOt%¶¿‹5¨’CF£¨’C¶A„ÒˆVuç‹- ’C‰,$èéãÿÿ…À”Á¶ÑJ…”’C…d¶O‹5¬’Cˆ„Òt‰ö‹=¬’CG£¬’C¶A„ÒˆWuç‹ ¨’C‹- ’C)éùý~»ÇD$XC‹¤’C‰$è&…À„ž‹5€„B…ö„h…ÛueÇD$ÿ‹ ¤’C‰ $èV;@„½¾‰5€’C…Ûu9‹=¨’CÆ/‹5¬’Cÿ¨’CÆ/‹ ¬’C‹¨’CQ‰¬’CÆAÆéGøÿÿÇD$¸ C‹- ’C‰,$èA÷þÿ‰D$ÇD$КAÇ$¸ŒBèɸ‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹= ’C‰<$è긋5¤’C‰4$èܸ¸éÔ÷ÿÿÇD$¸ CÇ$øCèÎöþÿÇD$¸LC‹¤’C‰Å‰$è¶öþÿ‰D$‰l$ ÇD$›AÇ$¸ŒBè:¸‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C‹ ’C‰$è[¸‹ ¤’C‰ $èM¸éëøÿÿ‹= ’C‰<$è:¸‹¤’C‰$è,¸éäøÿÿ´&‹=XCçðÿ@„„þÿÿÇD$¸ CÇ$øCèöþÿÇD$¸LC‹¤’C‰Å‰$èìõþÿ‰D$‰l$ ÇD$p›Aé1ÿÿÿ´&ÇD$¬’C‰<$èpé´ýÿÿt&¼'UWVSƒìl‹œ$€‹¬$„‰$‰l$è9…À…|‰$èáÿÿÇD$…À”ÁÇD$€ÇD$ÇD$ ¶ÑrÿÇD$‹˜’CÇD$€‰$!Öè4ºƒì‰Çƒøÿ„‰$L$PT$H‰L$ \$@‰T$‰\$趺ƒì‰Ã‰<$躃ì…Û„Þ…ö…Ñ‹T$T1Ûu@‹L$P‰×1ÒÑûûÞ±‡dr ùÿ>Õ‡VÇE@‹t$H…öu ‹\$L…Û„0‹T$L1Ûu8‹L$H‰×1ÒÑûûÞ±‡Ãr ùÿ>Õ‡µÇE8¶‹t$@…öu ‹\$D…Û„Œ‹T$D1ÛuH‹L$@‰×1ÒÑûûÞ±w)rùÿ>ÕwÇEH´&¼'1ÀƒÄl[^_]Ãû^H6rwù€é¥ÔvÇÿÿÿÿëÜÇD$€–˜é€>ÕÛÞ±ÇD$ ‰ $‰\$èt±‰ë°‹E@‰EHë¨û^H6rwù€é¥Ôv Çÿÿÿÿé;ÿÿÿÇD$€–˜é€>ÕÛÞ±ÇD$ ‰ $‰\$è#±‰é ÿÿÿ‹M@‰M8éÿÿÿû^H6rwù€é¥Ôv Çÿÿÿÿé”þÿÿÇD$€–˜é€>ÕÛÞ±ÇD$ ‰ $‰\$èÌ°‰éeþÿÿL$P|$8‰ $‰|$èÁ¸ƒìT$d‰<$\$f‰T$‰\$趸ƒì ·t$f·D$dÁæ Ɖ4$è¼ÿÿ‰E@‹L$H…Éu‹|$L…ÿtI|$0L$H‰ $‰|$èe¸ƒìT$`‰<$\$b‰T$‰\$èZ¸ƒì ·t$b·D$`Áæ Ɖ4$è`ÿÿ‰E8‹t$@…öu ‹D$D…À„™þÿÿt$(|$@‰t$‰<$踃ìL$\‰4$T$^‰L$‰T$èú·ƒì ·|$^·\$\Áç ߉<$èÿÿéNþÿÿ‰$èã·ƒì‰Ãƒøÿt¨u ¸ÿÿÿÿéÝýÿÿü1À¹‰ïó«Ç$!èÃÿÿ‰E@1ÒöÔ‰EH‰E8Jƒâ€Â€A‰Ué ýÿÿ failed: %lu directory entries with %lu bytes securityt& updated: %lu directory entries with %lu bytes securityt&ƒì,L$(T$$‰L$ L$ ‰T$T$‰$‰L$è‹8„B…Òu ƒ=,„B~ƒÄ,Éö‹T$…ÒuK‹T$$…Òtê‰T$‹L$(ÇD$©AÇ$¸ŒB‰L$ è`²‰D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’C막T$‹L$ ÇD$ЩAÇ$¸ŒB‰L$ 貉D$ÇD$ ÇD$¸ŒBÇ$ðƒBÿX’Céoÿÿÿ´&ƒì ‹T$‰\$1Û‰$è;…Àu»‰Ø‹\$ƒÄ ô&ƒì‰\$è4,1Ò…Àu‹\$‰ÐƒÄÃt&‹L$ ‹Q‰$葳‰$‹T$$‰ÃÇD$ ÇD$‰T$迵ƒìºÿÿÿÿ@t¶‰$è¼µƒìºÿÿÿÿ…Àt¢‰$ÇD$ ÇD$ÇD$耵ƒì@•Â¶ÚSÿépÿÿÿ´&¼'UWVSƒì,‹|$@‹l$D‰<$èùÚÿÿ‰<$…À¡˜’C”Á¿ÿÿÿÿÇD$ÇD$€ÇD$¶ÑrÿÇD$ !ÆÇD$ÇD$@è ´ƒì‰ÃƒøÿtS¸€–˜|$ ÷í€>ÕÒÞ±…ö‰D$ ‰T$$u>‰|$ ‰|$ÇD$‰$èÖ³ƒì…À•Â‰$¶ò~ÿèгƒìƒÄ,‰ø[^_]Ãv‰|$‰,$è„ë´‰ö¡ÕÒÞ±‰D$(‰T$,èg¬ƒì…Àt3‹D$T‹t$(‹\$ ‹‰÷‹T$,‹l$$)ß9ÞÛù)ê‰9ùsC‹|$T OƒÄ<[^_]Ãt&³Røÿÿéÿÿÿt&UWVSìü‹¬$Ç$øCèÓÑÿÿ…À‹˜’C”¶ʋôŒCI!Ù…Ò‰L$x„€· C¼$àÇD$‹5C‰|$ÇD$‰t$ ‰L$‰$èˆ`ÿÿ‰D$|¨„<‹œ$一–˜÷ë€>Õ‰E‹D$xÒÞ±‰U…À…!öD$|t1‹œ$฀–˜‹l$x‹´$÷ë€>ÕÒÞ±…퉉V…öD$|t.‹œ$踀–˜‹¬$÷ë€>ÕÒÞ±‰U‹T$x‰E…Òu‹D$|Äü[^_]Éœ$¬¼$¬‰<$诧‰Â…҉؄‹j‹J‹r‹Z‹z ‰L$X‹Ãl‰t$TO1ö·Œ-±@M‰D$P~HöÃu¸…ëQ÷ë‰Ø‰ÕÁý™)ÕD­€Áâ9Óu¸…ëQ÷ë‰Ø‰ÕÁý™)ÕT­,’Áå9ëu¾, Ûï4Ë,¶‰Þ‹“øÿÿ¸…ëQÁþ÷鸅ëQ‰L$<‰Ñ‹T$<ÁùÁú)Ñ)΋¿ùÿÿ‰Ë÷é‹D$XÁûiÀÁú)Ú 2)‹T$P‹L$T´;6õÿ‹l$Tiö€QÁá)éˆÓ3=ÿ¥Î‰Âº¦Î¸€–˜‹¼$´$˜‰t$÷ê‰<$€>ÕÒÞ±‰„$ ‰”$¤èu©ƒì…À„vþÿÿ‹„$‹¼$ ‹œ$˜‹‰ý‹”$¤‹´$œ)Ý9ßÛé)ò‰9ésC‹¬$ Mé,þÿÿ³Røÿÿéçþÿÿ‰œ$Ä”$ĉ$èߥ‰Â…҉؄‹j‹J‹r‹Z‹z ‰L$d‹Ãl‰t$`O1ö·Œ-±@M‰D$\~HöÃu¸…ëQ÷ë‰Ø‰ÕÁý™)ÕD­€Áâ9Óu¸…ëQ÷ë‰Ø‰ÕÁý™)ÕT­,’Áå9ëu¾, Ûï4Ë,¶‰Þ‹“øÿÿ¸…ëQÁþ÷鸅ëQ‰L$<‰Ñ‹T$<ÁùÁú)Ñ)΋¿ùÿÿ‰Ë÷é‹D$dÁûiÀÁú)Ú 2)‹T$\‹L$`´;6õÿ‹l$`iö€QÁá)éˆÓ3=ÿ¥Î‰Âº¦Î¸€–˜‹¼$´$°‰t$÷ê‰<$€>ÕÒÞ±‰„$¸‰”$¼è¥§ƒì…À„qüÿÿ‹„$‹´$¸‹œ$°‹‰÷‹”$¼‹¬$´)ß9ÞÛù)ê‰9ùsC‹¼$ Oé'üÿÿ³Røÿÿéçþÿÿt&‰œ$Ü”$܉$è ¤‰Â…҉؄2‹r‹B‹J‰t$t‹Z‹2‰L$p‹z Ãl‰t$lO1ö·Œ±@H~möÃu.¸…ëQ÷ë‰D$(‰Ø‰T$,Áú‰T$<™)T$<‹T$<’€Áâ9Óu.¸…ëQ÷ë‰D$(‰Ø‰T$,Áú‰T$<™)T$<‹T$<’€Áâ9Óu ¾´&×Û4Ó ¶‰Þ‰L$hþ‹“øÿÿ¸…ëQÁþ÷鸅ëQ‰L$<‰Ñ‹T$<ÁùÁú)Ñ)΋¿ùÿÿ‰Ë÷é‹L$tÁûiÉÁú)Ú2‹t$h‹T$pð´86õÿ‹D$piö€QÁà)ЋL$lË3=ÿ¥Î‰Âº¦Î‰,$¸€–˜¼$ȉ|$÷ê€>ÕÒÞ±‰„$Љ”$Ôè«¥ƒì…À„?úÿÿ‹Œ$Ћœ$È‹u‰Ï‹”$Ô‹„$Ì)ß9ÙÛþ)Â9þ‰usC<}éúÿÿ³Røÿÿé÷þÿÿ´&‹C‰$èrõþÿ‰Ã¸€–˜÷ë€>ÕÒÞ±‰U‹T$x‰E…Òu ‹U¸‹u‹¬$‰U‰uéúÿÿv‰œ$”¼$”‰<$èÊ¡‰Â…҉؄2‹J‹B‹r‰L$H‹Z‹ ‰t$L‹z Ãl‰L$D1öO·Œ±@H~möÃu.¸…ëQ÷ë‰D$(‰Ø‰T$,Áú‰T$<™)T$<‹T$<’€Áâ9Óu.¸…ëQ÷ë‰D$(‰Ø‰T$,Áú‰T$<™)T$<‹T$<’€Áâ9Óu ¾´&×Û4Ó ¶‰Þ‰L$@þ‹“øÿÿ¸…ëQÁþ÷鸅ëQ‰L$<‰Ñ‹T$<ÁùÁú)Ñ)΋¿ùÿÿ‰Ë÷é‹L$LÁûiÉÁú)Ú2‹t$@‹T$Hð´86õÿ‹D$Hiö€QÁà)ЋL$DË3=ÿ¥Î‰Âº¦Î‰,$¸€–˜¼$€‰|$÷ê€>ÕÒÞ±‰„$ˆ‰”$Œèk£ƒì…À„@þÿÿ‹Œ$ˆ‹œ$€‹u‰Ï‹”$Œ‹„$„)ß9ÙÛþ)Â9þ‰usC<}éþÿÿ³Røÿÿé÷þÿÿ´&UWV1öSƒì ‹L$ ‹l$$¶‹}A…Ò‰û„´&¼'BÕƒø2‡ ÿ$…4¾AÀAÀA6ÀA¿A6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀAÀA6ÀAÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀA6ÀAÀA6ÀAÀA;]„øÆ_‰Þ[ë ¶¶ÐA…Ò…ñþÿÿÆ…ötgÆ.‰ò)úƒú~A‰ñ1Ûw‰ò°.vˆCABƒû¶„ÀuïƉU‰õ)ý…í~€~ÿ tƒÄ [^_]ÃÆFÿ_ëò‰Ù)ñƒù~ ^‰]ÆFëω]ëÊÇD$_‰<$èÃÿþÿ…À‰Át1‰Â)úƒú~º‰Ø)ÈHƒø~¸ƒø~ ‰Î…ö…Tÿÿÿë‘‹U‰Ù)уù~ J‰MÆBëÞ‰]ëÙ¶„À„ÿÿÿ<.tÆ_¶¼'Céúþÿÿ€yuäÆ.ACÆ.ëêˆëæUWVSƒì ‹D$$‹T$ ‹l$(‹|$,ÇÇ¡ €BÇEÇ…Àu ƒÄ ¸[^_]ÃÇ$à–Cè¡‹50€Bƒì…öt\‹V‰T$‹^‰\$‹N ‰ $èç…ÀtZ‹T$ ‹^ÿ‰$èr’ƒì‹L$$‹èâ ‰$‰t$‰ÞÇD$èÜ ƒì …Ûu¥Ç$à–C1ö‰50€BèÑ ƒìébÿÿÿÿE‹N‰ $è’ƒìë«t&ƒì<‰\$,‹\$@‰t$0‰|$4‰l$8è…Àºu‹\$,‰Ð‹t$0‹|$4‹l$8ƒÄ<Ãt&‰$èØ‘ƒì1Ò…ÀtÔ‰$l$(|$$‰l$ t$ ‰|$‰t$è¿‘ƒì1Ò…Àt«‹T$ …Òt‹T$$‰$貑ƒì1Ò…ÀtŽ‰l$ ‰|$‰t$‰$襑ƒì1Ò…À„mÿÿÿ‹D$ …Àt‹L$$‰ $èt‘ƒì1Ò…À„Lÿÿÿ‰l$t$‰t$‰$ès‘ƒì 1Ò…À„+ÿÿÿ‹D$…Àt‰$èf‘ƒì1Ò…À„ÿÿÿ‰l$‰t$‰$èY‘ƒì 1Ò…À„ñþÿÿ‹D$…Àu ºéßþÿÿ‰$è"‘ƒì1Ò…À„ÊþÿÿëßvU1íWVSì\¡ €BÇD$4‹œ$p…À„Ø…Ût €;…òÇ$0˜Cèßž‹=—Cƒì…ÿtÇ$—CT$@‰T$èþžƒì…À„>ÇD$81ÛÇ$0˜CèÍžƒìL$<€|$@ÇD$ÇD$‰L$ÇD$ÇD$ ÇD$ÇD$„WD$@‰$è+ƒì …À‰D$4t@öD$<t9‹„$x‹p…öt+€|$@„D$@‰$è4ƒìƒø„à´&Ç$0˜Cèôƒì‹L$4…Éu)1ÿ‰=—CÇ$0˜C螃ì‹D$4Ä\[^_]ÃvÇ$—CM1ÿ‰L$T$@½‰T$èCƒì ‹t$<‰=—C‹\$8‰-—C‰5 —C‰—C‹¼$x¾—C¸$‹_÷Ç‹o‰—C‰-—Ct‹5—C¸ ‰7ƒÇ¾—Cü‰ÁÁéó¥éGÿÿÿ‹¼$tT$8»‰T$‰<$è¬éÿÿÿ1Àéäþÿÿ1Àé¦þÿÿ‰$èQ‰Åƒì1Àý‡ÿÿÿ1À¶¿¶€ú/„“ˆT@@9èvê€|$@\t)¶D$A<:t ÆD$@1íé³ýÿÿÆD$B\½ÆD$CéŸýÿÿ¶D$A<\uÓ¸1Ò9胇ýÿÿ€|@\t+@9èrôJ…týÿÿ€|,@\„iýÿÿ¶\$@ÆD,Aˆ\,@EéUýÿÿBƒúuÏ@‰ÅÆD@ëÊÆD@\égÿÿÿ¶ÇD$ÇD$Ç$ètœƒì …À‰D$,tf‰D$Ç$$€Bèiœƒì‰Æ…ÀtT‰D$Ç$$€BèPœƒì‹T$,‰$èašƒìÇD$ÿÿÿÿ‰4$è>œƒì‰4$èCœ¡ €Bƒì…À…›üÿÿ1Àé¾ýÿÿÇ$à–C¾—Cè+œƒìÇ$0˜C蜃ìº$÷Æt1À¾—Cº £—Cü‰Ñ‰è‰÷Áé¾ó«èE‰5 €B‹L$,‰ $èÛƒì¸é{ÿÿÿ¶UWVSƒì<‹ €BÇD$0‹l$XÇD$,…ÒÇD$(ÇD$$ÇD$ „¯‹D$Tö@t‹H…É„|ÇD$,‰,$èJŒƒì1Ò…ÀuƒÄ<‰Ð[^_]ô&‰,$|$4t$:‰|$‰t$舌ƒì 1Ò…Àt΋|$T‹W…Òt&‹G…À„‹G¨tÇD$$¨tÇD$ ·D$:¨t(ÇD$0‹t$$ÇD$(…ötÇD$0 ÇD$(¨t‹|$$…ÿu‹T$ …Òt L$0ƒL$(‹L$(1Ò…É„=ÿÿÿ‹\$$…ÛtL$,ÇD$‹T$,‹t$0ÇD$‹D$P‰T$‰t$ÇD$ ÇD$‰$蘃ì1Òƒøÿ‰Æ„áþÿÿ‰l$‹L$(‰$‰L$莋ƒì ‰Å‰4$蘃ì‰êé¶þÿÿ‹(€B‹ ,€B‰\$$‰L$ éÿÿÿ‰l$‹\$P‰D$‰$蚉Âé‚þÿÿvÇD$ÇD$Ç$èt™ƒì ‰Æ…Àtb‰D$Ç$$€Bèk™ƒì‰Ã…ÀtP‰D$Ç$$€BèR™ƒì‰4$èg—ƒìÇD$ÿÿÿÿ‰$èD™ƒì‰$èI™¡ €Bƒì…À…Êýÿÿ1ÒéñýÿÿÇ$à–C»—Cè1™ƒìÇ$0˜Cè"™ƒìº$öÃt1Ò»—C‰—Cº ü‹D$(‰ÑÁé‰ßó«èP‰4$¸£ €BèΘƒì¸ëƒSeRestorePrivilegeSeSecurityPrivilege¶¼'ƒìL‰\$D‰t$Hè ˜‰$L$,‰L$ÇD$(èø‰ƒì …Àu‹\$D‹t$HƒÄLÃt&ÇD$0\$4t$0ÇD$<‰\$ÇD$œÉAÇ$èÀ‰ƒì …À…‡‹(€B…Òt‹L$,‰ $èÿ•ƒì뙉\$ÇD$¯ÉAÇ$肉ƒì …ÀtÐÇD$‹\$,ÇD$ÇD$ ‰t$ÇD$‰$è[‰ƒì…Àt™è¯•…Àu¾‰5,€BëƒÇD$‹T$,ÇD$ÇD$ ‰t$ÇD$‰$艃ì…À„>ÿÿÿè^•…À…1ÿÿÿ¹‰ (€Bé!ÿÿÿ¶UWVSƒì ¡ €B…À…‘ÇD$ÇD$Ç$èЖƒì ‰Ã…Àtb‰D$Ç$$€BèÇ–ƒì‰Æ…À„d‰D$Ç$$€B誖ƒì‰$è¿”ƒìÇD$ÿÿÿÿ‰4$蜖ƒì‰4$è¡–¡ €Bƒì…Àu 1ÀƒÄ [^_]Ë\$ ‰$è?–ƒìh‹T$(‰$è]‡ƒì¼4‰ÆèÌ•‰$‰|$ÇD$èx–‰Ãƒì 1À…ÛtªÇK<‰K‰{Ç$‰{ ‰t$‹t$(‰ $‰t$è‘‹{¸$‹t$$÷Çt‹¸ ƒÆ‰ƒÇü‰ÁÁéó¥‹s‹K ‹D$ ÇF‰l$‰D$‰ $èÒÇ$à–Cè•‹-0€Bƒì…íu)‰0€B‰ЖCÇ$à–Cè!•ƒì¸éñþÿÿt&‹=ЖC‰ëÓÇ$à–C¿—Cèu•ƒìÇ$0˜Cèf•ƒì¸$÷Çt1À¿—C£—C¸ ü‰ÁÁé‰ðó«è–üÿÿ‰$¹‰ €B蕃ì¸émþÿÿ¶UWVSƒì,‹l$D‹t$@ÇEÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$‰4$è’’ƒì‰Ãƒøÿ„äÇD$(t$(‰t$ÇD$ ÇD$ÇD$‰$è4†ƒìè|’ƒøzt‰$è_’ƒìƒÄ,[^_]Ãt&軓‰$‹L$(ÇD$‰L$èc”ƒì ‰Ç…ÀtÉt$‹T$(‰D$ÇD$‰T$ ‰$èÊ…ƒì…Àu!èn“‰$‰|$ÇD$èj“ƒì é{ÿÿÿ‰|$ÇD$‰$èN…ƒì …ÀtăMë¾ÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$‰4$èh‘ƒìƒøÿ„ ÿÿÿ‰$èt‘ƒMé ÿÿÿ%lu.%lu.%lu%lu ´&¼'Server 4.0, Enterprise Edition Server 4.0 Server Advanced Server Datacenter Server Standard Edition Web Edition Enterprise Edition Datacenter Edition Home Edition Professionalt&SYSTEM\CurrentControlSet\Control\ProductOptionsProductTypeWINNTLANMANNTSERVERNT¶¿Microsoft Windows Server 2003 family, Microsoft Windows 3.1 with Win32s Microsoft Windows Millennium Edition SE SP1 OSR2t&¼'WVSì0‹œ$@èË¡`€Bƒø„uƒø‚Dƒø„«ƒøte¶‹ T€B‹X€B‰T$‹œ$D‰L$ ‰D$ÇD$ÏA‰$èq‹ÇD$ ÏA‹=\€B‹Œ$H‰|$‰ $èP‹¸Ä0[^_ÃÇMicrÇCosofÇCt WiÇC ndowÇCs CEfÇC ‰ö¼'¡`€Béfÿÿÿ¶‹T€Bƒú‰Ð„=ƒø„ôƒø‡_‹ X€B…É…QÇMicrÇCosofÇCt WiÇC ndowÇCs NTÆC‹5`qB…ö„ ¶ê€B<„Þ<t%ÇD$ÏA‰$èXŒÇD$d€B‰$èHŒéSÿÿÿƒ=T€Bt öè€BtÇ$ ÏAèUŒë»Ç$@ÏAëð¡X€Bƒøt@…ÀuÒ€=è€Bx%öè€BuÇD$LÏA‰$èê‹ë€ÇD$TÏAëìÇD$eÏAëât&€=è€Bx/·è€B¨uf=t ÇD$xÏAëºÇD$ŠÏAë°ÇD$—ÏAë¦ÇD$«ÏAëœöé€Bt ÇD$¿ÏAë‰ÇD$ÍÏAé|ÿÿÿÇD$(ÿT$,‰T$ÇD$ ÇD$ÇD$àÏAÇ$€èª€‰Çƒì1À…ÿ…þÿÿÇD$ ‹|$,t$(‰t$t$0‰t$ÇD$ÇD$ÐA‰<$èw€ƒì…Àu |$(ÿv1Àé´ýÿÿ‹T$,‰$èc€ƒì‰t$Ç$ÐA莃ì…ÀtI‰t$Ç$"ÐAèéƒì…Àt ‰t$Ç$+ÐAèÒƒì…À…þÿÿéšþÿÿÇD$LÏA‰$èrŠëÎÇD$ÍÏA‰$è`Šë¥ƒø…Ìýÿÿ¡X€Bƒøteƒøt9…À…µýÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs 20fÇC00ÆCé„ýÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs XPéYýÿÿü¾@ÐA¹ ‰ßó¥éIýÿÿ‹X€B…Ò…þüÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs NTÇC 4.0ÆCé ýÿÿƒ=X€B3…¶üÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs NTÇC 3.5fÇC1éÈüÿÿü¾€ÐA¹¶¢ÐA‰ßó¥·5 ÐAˆWf‰7é8üÿÿ‹ T€Bƒù„®‹X€Bƒùt ¡`€Béûÿÿƒú t(ƒùuìƒúZuçü‰ß¾ÀÐA·äÐA¹ ó¥f‰éçûÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs 98ÆC‹\€Bº1øÿÿÿ·v(ú†w‹ T€B‹X€BëˆÇD$æÐA‰$èwˆëàÇD$êÐAëì‹X€B…Ò…JÿÿÿÇMicrÇCosofÇCt WiÇC ndowÇCs 95ÆC‹\€BŠIüÿÿùv%ú8w ‹ T€Bé÷þÿÿÇD$ïÐA‰$èˆëãÇD$êÐAëìt&ƒì è¡@€BƒÄ Ãë ƒì èè¡`€BƒÄ Ãë ƒì èÈ¡T€BƒÄ Ãë ƒì 訡X€BƒÄ Ãë ƒì èH‹ÁèƒÄ Ãì èx1Àƒ=`€B”ÀƒÄ ô&ƒì èX1Àƒ=`€B”ÀƒÄ ô&ƒì è81Àƒ=`€B”ÀƒÄ ô&ƒì è1Àƒ=`€B”ÀƒÄ ô&켋ð€B…Òtº‰ÐļÉöÇ$P€Bºœ‰P€B虊ƒì…À„ ·\€B¡`€Bƒø‰\€B„ǃø‚®ƒøtƒøt º‰ð€B듹‰ @€Bëæ¡T€BƒøtpƒøtZƒøw#‹X€B…Òu¸£@€B· ä€B @€B믃øuì¡X€Bƒøt ƒøt…ÀuÙº2‰@€Bë̹<‰ @€Bë¿‹ X€B…Éuœº(ëÚƒ=X€B3u‡¸#뙺‰@€BéLÿÿÿ‹ T€Bƒù…=ÿÿÿ¡X€B…Àu"¸ £@€B‚Iüÿÿ=w}º ‰@€Bƒù… ÿÿÿƒ=X€B t ƒù…÷þÿÿƒ=X€BZ…êþÿÿ¹éòþÿÿ‹\€B¸£@€B‚1øÿÿ=·w º‰@€Bë¶ú†v®ºëé´&ú8v†º évÿÿÿÇD$”1ÒL$‰`qB‰ $èÒˆƒì1Ò…À„ þÿÿ‹T$‹L$‰T€B‹T$‰ X€B‹L$ ‰\€B‰ `€Bé þÿÿUWVSƒì,‹T$@‹\$D‹D$L‹|$H‰T$(ƒû‹T$P‰D$$‰T$ wƒÄ,[^_]É|$‰Þ‹l$(Ñî‰Ø‹L$ ‰t$‰ò)ð‰l$¯×‹l$(‰D$‹D$(Õ‰L$‹T$$‰$‰T$ è‰ÿÿÿ‰|$‹L$ ‹D$$‰,$‹T$‰L$‰D$ ‰T$èeÿÿÿ‹L$ ƒÿ‰L$„Æ…öu0‹T$)ӯߋ|$ ‰\$H‹\$(‰|$D‰\$@ƒÄ,[^_]éw‚´&‹D$…Àu(…ötį÷‹l$‰l$‰t$‹t$‰4$èI‚맴&‰l$‹L$‰ $ÿT$$…À~0‰l$‹L$ý‰|$‰ $èg ÿL$‰D$…ö„gÿÿÿ‹D$…Àu¿ë•‰|$‹D$N‹T$‰D$‰$è4 |$ëËöD$(…/ÿÿÿ…ö„+ÿÿÿ‹L$…É„Wÿÿÿ‰l$‹T$‰$ÿT$$…À~,ÿL$‹MƒÅ‹T$‰ ƒÂ…ö‰T$„íþÿÿ‹T$…ÒuÆéÿÿÿ‹D$N‹T$ƒD$‹ëд&¼'ƒì,‹T$0‰|$$‹|$4‰t$ ‹t$8‰\$‰û¯Þ‰l$(‹l$<‰T$ûÿ† ‹ B…É„ª1Ò‰Ø÷5B9Èv,‰t$8‹\$‹t$‰l$<‹l$(‰|$4‹|$$‰t$0‹t$ ƒÄ,éà蛋‰$‰T$者À‰ÃtCè‚‹L$‰‰|$‹|$‰\$‰l$ ‰t$‰<$èPýÿÿ‰\$0‹t$ ‹\$‹|$$‹l$(ƒÄ,éD€è?‹\$‰éhÿÿÿt&Ç$Uè„£B‰ÂBt2¡B…Àx$Ç$Áø£Bè]£B‹ BéÿÿÿƒÀë×¹ÿÿÿ‰ BëÁ‰$èã‰D$‹D$‰l$ ‰t$‰|$‰$è§üÿÿ‹\$‹t$ ‹|$$‹l$(ƒÄ,Ãì‰t$‹t$ ‰\$‹\$$…ötZ…ÛtVÇD$‰$èU …Àt8‰\$‰4$èõ„ƒì1Ò…Àt‹\$‰Ð‹t$ƒÄÃè ‰ÆèB€‰0ºÿÿÿÿë݉$èë¾è*€Çëâƒì‰\$‹\$ ‰t$…Û„‹è€‹0ÇD$‰$èÒ …Àu^ÇD$‰$è¾ …Àt;èÕ‰0‰$èk„ƒì1Ò…Àt‹\$‰Ð‹t$ƒÄÃèo ‰Æ訉0ºÿÿÿÿëÝèšÇëì‰öÇD$€‰$èP€ëèyÇëËƒì ‹T$Ç$‰T$‹T$‰T$è ƒÄ Ãì‰\$‹\$ ‰t$‹t$$…ÛtNÇD$‰$èɃƒì…Àt‰t$$‹t$‰\$ ‹\$ƒÄéª|èµ ‰Æèî~‰0‹\$¸ÿÿÿÿ‹t$ƒÄÃèÖ~ÇëâUWVSì<‹„$T‹Œ$XÁá…À‰L$,„UHÿƒø‰L$v3‹¼$X\$8‹T$‰\$ ‹¬$PD$0¯ú‰l$(ï9؉|$$‚I‹œ$X‹T$‹Œ$P‹´$P¯Ú‹|$,ˉ\$7;\$v‹\$‹¬$X|59߉ý†Ù;´$Pt‹¼$X‰ó‹Œ$P¶¶ˆCˆAOuñ‹´$X<.;|$‡’‰þt&‰<$‹œ$X)Þ‰t$ÿ”$\…Àxå‹”$X‹„$XÖ9þ,8tN]ÿ9ûrG´&¶ ‰Ú‹„$XˆL$)Â9ò‰Ùr´&¶ˆ‹„$X‰Ñ)Â9òsì¶D$K9ûˆsÀ;l$‰ï†nÿÿÿÄ<[^_]Ét$‰<$ÿ”$\…Àx‹Œ$XÏ9ßváéÿÿÿ‰þëê‹D$$1Ò‹l$(‹¼$X‹\$()è÷´$X‹L$(‰L$Ñè¯Ç؉D$‹t$‰4$ÿ”$\…Àˆþ‹T$‹D$$‰T$‰$ÿ”$\…Àˆ‹¼$X‹l$(‹œ$Xý‹|$$)߉ö‰,$‹t$‰t$ÿ”$\…Àˆ=¶‰|$‹D$‰$ÿ”$\…Ày ‹Œ$X)Ïëß9ýƒõ‹´$X‰ë‰ù¶¿¶¶ˆCˆANuñ9l$„¼9|$„©‹”$X‹œ$XÕ)ß9ý†cÿÿÿ‹t$(‰ø)ð;D$,w=‰l$(‹|$$)ï;|$,wƒl$ ‹T$ ‹L$ ‹‹i‰\$(‰l$$D$0;D$ ‚œþÿÿéNýÿÿ‹T$$)ê;T$,v29Ð~‹L$ ‹\$(‰l$(‰y‰ƒÁ‰L$ ëËt$ ‰.‹l$$‰nƒÆ‰t$ ‰|$$멉l$éNÿÿÿ‰|$éEÿÿÿ9ý…Oÿÿÿ‹´$X,>)÷éFÿÿÿ‹”$XÕé›þÿÿ‹´$X‹\$‹L$$¶¶ˆCˆANuñ‹L$(‹t$‰L$‰4$ÿ”$\…À‰Cþÿÿ‹´$X‹\$‹L$(¶¶ˆCˆANuñé þÿÿ‹´$X‹\$‹L$(¶¶ˆCˆANuñéßýÿÿƒì ‹D$=ƒ‡ÿ$…¬ãAväåAäåAäåA¬æA¬æA¬æAëåA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA˜æAÐåA¬æA¬æA¬æAæA¬æA¬æA¬æA¬æA¼åA¬æAæA¬æA¬æA¬æA¼åA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æAæAæA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æAæA$æA,æA4æAJæA<æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æACæApæAzæAJæAQæAXæAXæA_æAiæA„æApæAzæA„æAŽæA˜æAÐåAÐåA¢æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æA¬æAèoxljö¼'¸ÿÿÿÿt&¼'ƒÄ ø€–˜ëõèƒøº‰Ðëâèý‰Âëó¸ëÒ¸ë˸ëÄƒÄ éÌƒÄ étƒÄ é ƒÄ éd¸ë¸ë–¸ÿÿÿ븀눸 ë¸éwÿÿÿ1Àépÿÿÿ¸éfÿÿÿ¸€ÿÿÿé\ÿÿÿ¸ÿéRÿÿÿ¸€ÿÿéHÿÿÿ¸ÿé>ÿÿÿ¸ÿÿé4ÿÿÿèwÇ(éÿÿÿWVSƒì‹|$(‹t$ ‹\$$ƒÿvI‰ñ÷Ùƒá)ωʅÉtv¼'¶ CˆFJuööÃuD‰\$‰úÁê‰T$‰4$è ‰úƒâüƒçÓÖ…ÿ‰útv¼'¶ CˆFJuöƒÄ‰ð[^_É\$‰ùÁé‰L$‰4$èÈ뺋D$ƒøSóƒøR}Pƒøtƒøtƒø Oƒø}Cƒøƒø|ºt&¼'‰Ðúëöƒøtƒøºëåº ëÞº ë׺ ëЃø ôƒø }Ƀø ºt¼ƒø uººë°ƒø"/ƒø}ȃøt‘ƒøƒøt¹ºƒøu닃ø~¨ºé|ÿÿÿƒøAt™ƒøAƒø$tƒø5…gÿÿÿéOÿÿÿƒøC„FÿÿÿƒøP…PÿÿÿºéCÿÿÿv=¡„%ÿÿÿ=¡ª=h=€º ÿÿÿƒøl„,ÿÿÿƒølƒøW„ÿþÿÿƒøY…öþÿÿº ééþÿÿƒøpº„Ûþÿÿƒøp º ƒømé:ÿÿÿƒør…ÃþÿÿéÖþÿÿ=„„Òþÿÿ=„=‚ëÜ=‘º)„’þÿÿ=ž…Šþÿÿé¤þÿÿ‰ö=΄eþÿÿ=ÎN=ª„Ýþÿÿ=ª=¤„^ÿÿÿ=§ë½=·„òþÿÿ=·Œ7þÿÿ-¼ƒø‡)þÿÿéjþÿÿ=kº$„þÿÿ=k=ׄ ÿÿÿº=]é`þÿÿ=Õº„ßýÿÿ=Õº=°é:þÿÿ=…Áýÿÿéâýÿÿ‰ö¼'ƒì èxv‰$è`ýÿÿƒÄ Ãì‰\$ ‹\$ ‰l$1í…Û‰t$‹t$$‰|$t÷Æèÿÿÿt'èòsǸÿÿÿÿ‹\$ ‹t$‹|$‹l$ƒÄÃvÇ$€è„xƒì‰$è©vƒì‰ÇƒøÿtBÇ$ècxƒì¸ÿÿÿÿEt±÷Æt÷Çtƒætƒçu1Àë“èusÇ ëè(ÿÿÿ‰Åèas‰(½ÿÿÿÿë©ì<‰œ$,‹œ$H‰´$0‹´$D‰¼$4‹¼$@‰¬$8‰\$‰t$‰<$èéƒøÿ‰Ât‹ áðù t%‹œ$,‰Ð‹´$0‹¼$4‹¬$8Ä<ÃÇD$l$‰l$‰4$èµ@ºÿÿÿÿt»‰\$‰l$‰<$è}‰Âë§ƒì ‰|$‹= B…ÿ‰øt ‹G‹|$ƒÄ Éöü¿0B¹ ‰= Bó«Ç$0Bè!w‹= Bƒìëɶƒì ‰|$‹= B…ÿ‰øt ‹G‹|$ƒÄ Éöü¿0B¹ ‰= Bó«Ç$0BèÑv‹= Bƒìëɶƒì ‰|$‹= B…ÿ‰øt‹G 1Ò‹O)È÷w‹|$ƒÄ Ãü¿0B¹ ‰= Bó«Ç$0Bèyv‹= BƒìëÁ´&¼'ƒì ‰|$‹= B…ÿ‰øt‹W‹G )Ð1Ò÷w‹|$ƒÄ Ãü¿0B¹ ‰= Bó«Ç$0Bèv‹= BƒìëÁº@¸@‰P˜CÃì‹L$ ‰$‹\$‰t$‹T$‰Øƒàƒøw`ÿ$…HíAÊíAÑíAhíAÙíAæíAóíAîA îA‹ƒéƒÃƒê¶¼'‹rƒÂ ‰AƒÁ ƒëu‰1‹$‹t$ƒÄÉö‹‰1‹r‰A‹B‰q‹r ‰A ‹B‰q‹r‰A‹B‰q붋ƒéëÓ‹2KƒÂëÇ‹2ƒéƒÃƒêëÜ‹ƒéƒÃƒêëÉ‹2ƒéƒÃƒê 붋ƒé ƒÃƒê룋2ƒéCƒêë’´&UWVSƒì ‹T$$ÇD$ ‹D$(‹t$ ‰ÑƒáƒàÁáƒâü)L$ƒø‰L$„æƒø‚̓ø„¨ƒø„Ž¶L$‰ø‹Óí¶L$Óà ʼn.‹J‰Ý‰ $¶L$Óï¶L$Óå ï‰~¶L$‹<$‹jÓë¶L$Óç û‰^¶L$‰ë‹z ƒÂÓ,$¶L$Óã $‹$‰^ ƒÆƒl$(uŒ¶L$Óí¶L$Óç ý‰.ƒÄ [^_]ÃÿD$(ƒî‹B‹‰$ë’ƒD$(ƒî ‹ ‹jƒê‰ $ë–´&‹:ƒî‹ZƒÂéKÿÿÿÿL$(‹*‹zƒÂé$ÿÿÿë ƒì‹L$ ‰t$‹t$‰$‹T$‰ðƒàƒøw`ÿ$…ˆïA ðAðA¨ïA#ðA1ðA?ðAMðA[ðAƒêƒé‹BƒÆ¶¿‹ƒê ‰ƒé ƒîu‰Y‹$‹t$ƒÄÃv‹B‰Y‹Z‰A‹B‰Y‹Z‰A‹B ‰Y ‹Z‰A‹B‰Yë´ƒê ƒé‹Bëσê$ƒé ‹Z Në½ƒê ƒé‹ZƒÆëÓƒêƒé ‹B ƒÆ뿃êƒé‹ZƒÆ뫃êƒé‹BƒÆë—ƒêƒé‹ZFë…‰ö¼'UWVSƒì‹T$ ÇD$ ‹D$$‰ÑƒáƒàÁá)L$ƒâüƒÂ‰ $ƒø„ðƒø‚Ôƒø„¶ƒø„™¶ $‰ø‹\$‹r Óè¶L$Óå è‰C ¶ $‰õ‹ZÓí¶L$Óç ý‹|$‰o¶ $‰ß‹jÓï¶L$Óæ ÷‹t$‰~¶ $‰î‹:ƒêÓî¶L$Óã Þ‹\$‰3ƒëƒl$$‰\$u…¶ $‹T$Óï¶L$Óå ï‰z ƒÄ[^_]Ãl$ƒêÿD$$‹r ‹Z뉃l$ƒê ƒD$$‹Z‹jëƒl$ ƒê‹z‹r éFÿÿÿƒl$ƒêÿL$$‹j‹zéÿÿÿWVSìP‹¼$dÆÇ$èÁLƒìƒø‡4ÇD$ €eBL$,‰L$ÇD$ÇD$Ç$pdBè™Lƒì…Àˆý‹\$,T$(‹3‰T$‰$1ÛÇD$`LBÿƒì ´$@èÒpÇD$…À‹Œ$`”Ét$ÇD$ ÿÿÿÿ‰L$ÇD$‰$è®pƒì…Àˆ’‹T$(‹ÇD$‰t$‰$ÿSƒì …Àxs‹\$,t$0‹ ‰$ÇD$ÇD$ ÇD$‰t$ÿQ ƒì‰Ã…Àx>‰t$‰<$èSpƒì‹|$(‹‰<$ÿQƒì‹T$,‹2‰$ÿVƒìè­K‰ØÄP[^_ÃèÜöÿÿ‰Çèk‰8èŽK¸ÿÿÿÿëÜ.lnk‰öUWVSƒì ‹\$ ‹l$$‰$èÉiƒÀ‰$èîi‰D$…À„¢‰\$‰$èæiÇD$.‹D$‰$è’k…Àtü»)óA¹‰Æ‰ßó¦tÇD$)óA‹T$‰$èkÇ$€è;oƒì‹\$‰l$‰$èèýÿÿ‰$‰Æè^iÇ$èoƒì‰,$èGFt‰l$ ƒÄ [^_]éit&ƒÄ ¸ÿÿÿÿ[^_]Ãƒì ‹L$‹T$‹D$…Éu…Òt…Àt‰D$‰T$ƒÄ é¥!t&èëiǸÿÿÿÿƒÄ ÃU1ÀWVSìl‹´$€l$…ö„X¾‰$è–j…Àt‹„$€€x:„<‹”$€¶hÇ"1ÀëÛè/hÇëï´&¶F„Àu-„Ût €û/t€û\tˆ]FE¶„Ût €û/t€û\uêÆEégÿÿÿÕÙÞ±‰L$‰$èŠW‰Â‹Œ$ÔÁèH!‰Q8‰$‰t$ÇD$€–˜ÇD$ è|X €4‰‹„$ÔÁæ‰óÁëK!ó1ö‰X<‹T$8ÇD$€–˜‹\$4ÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$èW‰Â‹Œ$ÔÁèH!‰QH‰$‰t$ÇD$€–˜ÇD$ èõW€‹œ$Ô ’Áá‰ÎÁîN!ΉsL‹T$H1öÇD$€–˜‹\$DÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$è|V‰Â‹Œ$ÔÁèH!‰Q@‰t$ÇD$€–˜ÇD$ ‰$ènW€4’‹„$ÔÁæ‰ê‰ñÇ@PÁéI!ñ…í‰HD‰øx;1ö‰ý‰Á¬Ñ ‰Óåÿ‰ðÁû ètƒÁƒÓ‹”$Ô1À‰JX‰Z\ļ[^_]ÃÿƒÒ뻉4$¬$‰l$èœ`ƒì‰„$”é]ýÿÿÇD$,L$,ÇD$‰L$ÇD$ ÇD$ÇD$‰4$èe`ƒì…Àt‹L$,1À‰„$‰Œ$”éëüÿÿ‹Œ$”éßüÿÿºé‹üÿÿº éüÿÿ.lnkKERNEL32GetCompressedFileSizeAGetBinaryTypeAPATHEXT‰ö¼'UWVSƒì\‹T$p‰$è-‰$è¥ôÿÿ‰D$<…À„,‰$èñX‹T$t‰Ã‹r ‹z‰ð ø„‹L$<‰ $èŸ\ƒìƒø„‹T$t‹r‹z‰ñ ùu(‹l$<1ö1ÿ…ít¶]„ÛˆÙ…Š1À1Ò‹l$t‰E‰U‹|$p1Û…ÿ„p‹t$p€>…p‹l$p…í„WÇD$.‹|$p‰<$èPZ…À„;ü¹‰Æ¿«Bó¦”Á¶Áv…ÀtË ‹t$t1É‹=`B ‹^‹n‰Ø1È1ý è…„‹ pB1ö1ÿ‹T$t‰JPÇ$°Bèg^ƒì‰ÅÇD$¹B‰$è"^ƒì…Àt3‹\$pt$@‰t$‰$ÿЃì‰Ãƒøÿ„‹t$@‰Ù1ÿ1Û‰ò‰Î þ‰ß ×…ít ‰,$èü]ƒì‰ý‰ê‰÷ òu ‹D$t‹x0‹h4‰l$‹pB1ö‰t$ ‰<$‰\$è9S‰D$0‹ pB‰l$‰T$4Áé ‰L$(ÇD$,‰\$‰t$ ‰<$è(T‰Õ Åtb‹l$0‹t$4‹D$(‰l$ ‹L$,‹\$(ƒD$ ‰t$$‹|$ ƒT$$÷d$ ¯Ï‰Æ‹D$$ʯØ<‹\$t‰sX‹t$<‰{\‰4$èíVƒÄ\1À[^_]Ãv‹D$0‹|$,‹L$0÷d$(‹\$(¯Ï‰Õ‰Æ‹T$4ͯÚ<+ë´èòY1ö1ÿ…À…îþÿÿéÕþÿÿ‹T$u‰<$è \ƒì…í„ýÿÿ»Iéýÿÿ‰4$ÇD$.ètW…À‰Æt͉D$‹ €B‰ $èŒW…Àt½ë°‰t$‹pqB‰$èoW…ÀtšëáÇ$ßBèíT£€B…À…nÿÿÿ‹5pqB‰5€Bé]ÿÿÿ¤÷¾ÁÁæ™Æ׉ú1Ûâÿ‰Ð Øt‰Ñ1ÀÁé‰ò1ʉù1Á‰Ö‰ÏçÿÿÿE¶]„ÛˆÙu½‰ð‰úé.üÿÿv‹|$<‹l$p‰|$‰,$èÌS…Àu‹\$tÇCÇC éÎûÿÿ‹l$p1ö1ÿÝt¶M„Éu1À1Ò‹l$t‰E‰U é¦ûÿÿ¤÷¾ÁÁæ™Æ׉ú1Ûâÿ‰Ð Øt‰Ñ1ÀÁé‰ò1ʉù1Á‰Ö‰ÏçÿÿÿE¶]„ÛˆÙu½‰ð‰úë¨ì<‰œ$8‹œ$@‰$è$‰$èœïÿÿ‰$T$0‰Ã‰T$L$,T$(‰L$L$$‰T$”$0‰L$ ‰T$ÇD$ÇD$èGWƒì …À”Á‰$¶ÑJ!T$$è¿S‹D$$‹œ$8Ä<ö¼'UW1ÿV1öS‹l$…ít¶M„Éu 1À1Ò[^_]ä÷¾ÁÁæ™Æ׉ú1Ûâÿ‰Ð Øt‰Ñ1ÀÁé‰ò1ʉù1Á‰Ö‰ÏçÿÿÿE¶]„ÛˆÙu½‰ð‰ú벶ƒì,T$$L$(‰T$ T$‰T$‹T$0‰L$L$ ‰L$‰$èá…Àu ÇD$ÇD$ ÇD$$ÇD$(‹D$ ‹L$ƒÄ,¯Áô&¼'ƒì‹D$ ‰t$‰|$…Àt=ÇD$.‰$è}T…Àt)ü‰Æ¿«B¹ó¦”¶Ât&‹t$‹|$ƒÄÃt&1Àë춿ƒì‰\$‹\$ ‰t$‰|$1ÿÇ$äüAè_Xƒì‰ÆÇD$ÐB‰$èZXƒì…Àt‰$L$ ‰L$ÿЃì…Àu_¡€B…Àtv…Ût€;u‰4$èEXƒì‰ø‹\$‹t$‹|$ƒÄÉ$ÇD$.è°S…À‰Ãt͉D$‹ €B‰ $èÈS…Àt t&¿묉\$‹pqB‰$è§S…Àt–ëáÇ$ßBè$Q£€B…À…qÿÿÿ‹pqB‰€Bé`ÿÿÿ¶ƒì ‹T$‰$èÁWƒì1Òƒøtƒøt‰ÐƒÄ úëót&º ëç‰ö¼'‹L$1ÒöÁ”ÂJâÀÿÿ€Ê$öÁ·Âu ’Ãvƒì,‰t$ ‹t$0‰\$1Û…ö‰|$$‰l$(tS€>uR…ötJÇD$.‰4$èšR…Àt6ü¹‰Æ¿«Bó¦”Á¶Á…ÀtË ‰Ø‹t$ ‹\$‹|$$‹l$(ƒÄ,Ã1ÀëÜÇ$äüAèVƒì‰ÅÇD$ÐB‰$è‹Vƒì…ÀÇD$t‰4$L$‰L$ÿЃì…Àu`‹€B…Òt~…öt€>u!‰,$èmVƒì‹D$…À„@ÿÿÿ»Ié6ÿÿÿÇD$.‰4$èÔQ…À‰ÇtɉD$‹€B‰$èìQ…Àt ÇD$멉|$‹=pqB‰<$èÌQ…Àt“ëÞ¶Ç$ßBèDO£€B…À…iÿÿÿ‹ pqB‰ €BéXÿÿÿ¶VSìd‹œ$p”$0‹´$t‰T$‰$è7ïÿÿ1Ò…À„â‹Œ$0öÁ‰‹„$4‹”$8‰F‰V‹„$<‹”$@‰F ‰V‹”$H‹„$D‰V‰F‹”$L‰V ‹”$P‰V$…‹ÇF(‰$è܉$èTêÿÿ‰$T$0‰Ã‰T$L$,T$(‰L$L$$‰T$”$0‰L$ ‰T$ÇD$ÇD$èÿQƒì …À”Á‰$¶ÑJ!T$$èwN‹L$$º‰NÄd‰Ð[^É$è¨ïÿÿ‰F(élÿÿÿU1ÒWV1öSƒì‹\$\‹L$0‹|$` Þ‹D$L ׋\$d1ÒöÁ”‰C‰{‰s JâÀÿÿÇC€Ê$öÁ·Âu ’‹\$T1Ò1í‹|$P‹L$d‰þ ‰ß ï‰Õ‹\$d õ‹t$X‹T$@‰{0‰s‰Ñ1ö‰k41Ò ÎÇD$€–˜‹\$<‰ñÇD$ Ó‰Úê€>ÕÙÞ±‰L$‰$èJI‰Â‹L$dÁèH!‰Q8‰$‰t$ÇD$€–˜ÇD$ è?J €4‰‹D$dÁæ‰óÁëK!ó1ö‰X<‹T$8ÇD$€–˜‹\$4ÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$èÉH‰Â‹L$dÁèH!‰QH‰$‰t$ÇD$€–˜ÇD$ è¾I€‹\$d ’Áá‰ÎÁîN!ΉsL‹T$H1öÇD$€–˜‹\$DÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$èHH‰Â‹L$dÁèH!‰Q@‰t$ÇD$€–˜ÇD$ ‰$è=I€4’‹D$dÁæ‰ê‰ñÇ@PÁéI!ñ…í‰HD‰øx81ö‰ý‰Á¬Ñ ‰Óåÿ‰ðÁû ètƒÁƒÓ‹T$d¸‰JX‰Z\ƒÄ[^_]ÃÿƒÒë¾t&UW1ÿV1öSƒì Ç$°Bè9Rƒì‰ÅÇD$¹B‰$èôQƒì…Àt/L$‰L$‹L$ ‰ $ÿЃì‰Ãƒøÿt/‹t$‰Ù1ÿ1Û‰ò‰Î þ‰ß ×…ít ‰,$èÒQƒìƒÄ ‰ð‰ú[^_]Ãè®N…ÀuÜëÆ´&U1À¹ WVSìì¼$ ü”$pó«‰T$´$ ‹”$ ‰$èëÿÿ…Àºÿÿÿÿ„‹‹”$t‹¬$x‹¼$|‰”$¤‹Œ$€‹œ$p‰¬$¨‹”$„‹¬$ˆ‰¼$¬ö˼$Œ‰Œ$°‹Œ$‰œ$ ‰”$´‰¬$¸‰¼$À‰Œ$Ä… »‰œ$È‹„$ |$p\$,‰$èm‰$èååÿÿ‰|$L$$‰Å‰L$ T$(¼$p‰\$‰T$‰|$ÇD$ÇD$‰$è˜Mƒì …À|$0”É,$1í¶ÓJ1Û!T$$èJü‹L$$‰N¹ ó¥‹|$\‹T$`‹L$0 ý‹t$L‹¼$ Ú‰W1ÒöÁ”‰o ‰wÇGJâÀÿÿ€Ê$öÁ·Âu ’‹\$T1Ò1í‹|$P‹Œ$ ‰þ ‰ß ï‰Õ‹\$X õ‹´$ ‹T$@‰^‹\$<‰Ñ‰~01Ò‰n4 Ó1öÇD$€–˜ ΉÚÇD$ ê€>Õ‰ñÙÞ±‰L$‰$èõD‰Â‹Œ$ ÁèH!‰Q8‰$‰t$ÇD$€–˜ÇD$ èçE €‰‹„$ Áã‰ÞÁîN!Þ‰p<‹T$81öÇD$€–˜‹\$4ÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$ènD‰Â‹Œ$ ÁèH!‰QH‰$‰t$ÇD$€–˜ÇD$ è`E €‰‹„$ Áã‰ÞÁîN!Þ‰pL‹T$H1öÇD$€–˜‹\$DÇD$ ‰Ñ1Ò Ó Î‰Úê€>Õ‰ñÙÞ±‰L$‰$èçC‰Â‹Œ$ ÁèH!‰Q@‰$‰t$ÇD$€–˜ÇD$ èÙD€‹´$ ›Áâ‰ø‰ÑÇFPÁéI!Ñ…í‰ê‰NDxP1ö‰ý‰Á¬Ñ ‰Óåÿ‰ðÁû ètƒÁƒÓ‹”$ ‰Z\‹œ$ ‰JX‰T$‰$èNîÿÿ1ÒÄì‰Ð[^_]ÃÿƒÒë¦t&‹„$ ‰$è±èÿÿ‰„$ÈéÑüÿÿt&üƒì,1À‰\$¹‹\$0‰t$ ‹t$4…Û‰|$$‰÷‰l$(ó«t€;u1Ò‹\$‰Ð‹t$ ‹|$$‹l$(ƒÄ,ÃÇD$‰$èØÓÿÿ…Àºÿÿÿÿuщ$è‰$è_âÿÿ‰$‰ÅÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$èµIƒì‰Ã‰t$‰$è4éÿÿ‰$‰ÇèºIƒìƒÿÿt\‰t$‰,$è6íÿÿ‹âðú@t3ƒÿÿtÇ$èLƒì‰,$èJF‰úé%ÿÿÿèþÒÿÿ‰Æè7G‰0ëÒ‰,$è{çÿÿ‰FëÀ‰t$‰,$èºúÿÿ‰Çë ƒì ‹T$…ÒtƒÄ ë@èûFÇ1ÀƒÄ Ãë ƒì ‹T$ÇD$‰$è ƒÄ Ãt&UWVSƒì‹|$0‹l$4…ÿ„€?„ìÇ$è¤E‰D$T$‰Ã‰T$ ÇD$‰<$èÖHƒì‰Æ…À„£=~…ítgèYFÇ&èNF‹8ÇD$‰$èÒÿÿ…Àu¶Dÿ…Àu‹”$ÔÇ@é*þÿÿÇD$ÓBŒ$°‰ $è¼>…Àu‹œ$ÔÇ@éýýÿÿÇD$×B„$°‰$è>…À‹´$Ô•Á¶ÑJâ@‰éÉýÿÿ‰ö‹¼$„¸‹”$ˆ‹Œ$Œ‹œ$‰|$4‰T$0‰L$,‰éüüÿÿ‰t$D$,t$0‰D$ |$4‰t$‰|$‰,$èØEƒìéÐüÿÿ‰t$\$,D$0‰\$ t$4‰D$‰t$ëÒ‰<$è:Eƒìè¢Ëÿÿ‰ÆèÛ?‰0¸ÿÿÿÿé¿þÿÿ‰<$èEƒìè¿?ÇëÞ´&W1À¹SƒìT\$0ü‰ßó«ÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$Ç$½BèoAƒì‰Çƒøÿt{‰\$‹T$d‹L$p‰\$‰T$<‹T$t‰L$@‹L$l‰T$8T$,‰T$‹T$`‰L$4ÇD$H‰T$ÇD$ÇD$ÇD$ ‰$è¥Dƒì ‰Ã‰<$èAƒì…ÛtöD$Htè•Êÿÿ‰ÇèÎ>‰81ÀƒÄT[_Ãt&¸ëï‰ö¼'UWVS쌋¬$ èê·ÿÿ…Àtè1·ÿÿƒø Ž(ü1À\$0¹‰ßt$Pó«ÇD$ÇD$ÇD$ÇD$ ÇD$ÇD$Ç$½BèH@ƒì‰Çƒøÿts‰l$4l$,‰t$@ÇD$<sÇD$8,ÇD$HÇD$‰l$ÇD$‰\$ÇD$ ‰\$ÇD$‰$è†Cƒì ‰Æ‰<$èù?ƒì…ötöD$HtèvÉÿÿ‰Çè¯=‰81ÀÄŒ[^_]ËT$T¸‹œ$¤‹¬$¨‹Œ$¬‰‹|$X‹œ$°‰}‹t$\‰1‹T$`‰ë¹t&‰,$‹„$¬‹Œ$°‹”$¨‰D$ ‹„$¤‰L$‰T$‰D$èìBƒìéyÿÿÿt&ƒì,‹T$0‰\$‹\$@‰t$ ‹t$<‰|$$‹|$8‰l$(‹l$4‰T$è@¶ÿÿ…Àt0‰\$@‹T$‹\$‰t$<‹t$ ‰|$8‹|$$‰l$4‹l$(‰T$0ƒÄ,é þÿÿ‰\$‹L$‰t$ ‰|$‰l$‰ $è`Bƒì‹\$‹t$ ‹|$$‹l$(ƒÄ,Éö¼'ƒì‰t$‹t$ ‰\$‰4$èi…À‰Ãt€8t…öt €>u+t&èK<Ǿÿÿÿÿ‰$è8;‰ð‹\$‹t$ƒÄÉ$‹T$$‰T$èÊöÿÿ‰ÆëÖ :/¶¿ƒì‹T$ ‰|$‰\$ ‰t$‰l$‰$èõÿÿ…À‰Çt;‰$è³:ƒøv €:„´…ÿt ‰<$è˜:ƒø‰Å~€?/t,¶¿1ö‰<$è–:‰ð‹\$ ‹t$‹|$‹l$ƒÄÀ/uÚÇD$/O‰ $è§<…Àu2EÇD$]‰$èo<‰$‰Æ‰\$‰|$è­;ÆD5ÿ/ÆD5ë“ÇD$/@‰$è`<…Àt¹)øhë³t&€/…BÿÿÿÇ$ "Bè 9¾‰Æ‰$è<ˆéHÿÿÿ¶UWVSƒì ‹T$ ; BÆD$ „è¡B…Àt\‹\$ 1í1ö1ÿ‹—¼B‹‡¸B‰Ñ1ñ1Ø Áu ¶°BˆL$ €|$ u EƒÇƒý ~϶\$ ‹l$ ¾Ã‰- Bˆ€qBƒÄ [^_]ÃÇ$èc …À‰ÃtY¶¾ðÿÿÿ„ÉtM‰$¾ùƒÆ‰¾°B‰úÁú‰–´Bèáäÿÿ‰†¸B1ɉ$‰Ž¼BÇD$èC;‰ÃCt ¶P„ÒˆÑu´‰$¾‰5Bèá8é!ÿÿÿ¾€qBéiÿÿÿ :\¶¿ƒì ‰\$Ç$`$Bè½7‹T$‰Ã‰$è¿þÿÿˆ‰Ø‹\$ƒÄ Ãvƒì|T$‰T$‹”$€‰\$p‰t$t‰T$‰|$xÇ$è‚ 1Ò@tÇ$`$B‹|$ è]7‰Æ‰<$ècþÿÿˆ‰ò‹\$p‰Ð‹t$t‹|$xƒÄ|Ãnotsetrw %d %d v¼'UWVSìL‹qB‹¼$d‹¬$h‰T$‹”qB‰$è08…À„è\$ t&‰\$‹ ”qB‰ $è.üÿÿ…Ày/¡”qB€8tÇD$‰$èÐ9@£”qBëÈ1ÀÄL[^_]ÃÇG %BŒ$ÖT$l‰O\$|‰W‰‰,$‰|$è1‰,$ÇD$%Bè¡9ÇD$‹”qB4(‰t$l$¾%B‰$è[9ÇD$%B@£”qB‰,$èE …À‰Ãt'‰Â‰Át&¼'¶<\„©ˆA¶‰ÞB„Àuè‰7‹D$…À…uÇD$%B¾%B‰,$èõ …À‰Ãt'‰Â‰Át&¼'¶<\„èˆA¶‰ÞB„Àuè‰w‹D$…À…³ÇD$%B¾%B‰,$è¤ …À‰Ãt&‰Â‰Áv¼'¶<\„'ˆA¶‰ÞB„Àuè‰w‹D$…À…òÇD$%B¾%B‰,$èT …À‰Ãt"‰Â‰Áv¼'¶<\tnˆA¶‰ÞB„Àuì‰w 1À‹T$…Òu4ƒøt&ƒø~‹”$`‰$è¦ ‰øé9þÿÿ…ÀuæÇGÇGëÖÇD$%Bwo‰t$ ‰l$‰$èÝ7묀z0t=<\uˆ€z0t<\…zÿÿÿ€z\…pÿÿÿÆ\Béiÿÿÿ€z1u߀z2uÙÆ AƒÂéRÿÿÿ€z4u½€z0u·Æ ëæÇD$%B‰$è‡7D$éõþÿÿ€z0tA<\…Ëþÿÿ€z0t<\…½þÿÿ€z\…³þÿÿÆ\Bé¬þÿÿ€z1u߀z2uÙÆ AƒÂé•þÿÿ€z4u¹€z0u³Æ ëæÇD$%B‰$è7D$é4þÿÿ€z0tA<\… þÿÿ€z0t<\…üýÿÿ€z\…òýÿÿÆ\Béëýÿÿ€z1u߀z2uÙÆ AƒÂéÔýÿÿ€z4u¹€z0u³Æ ëæÇD$%B‰$è¥6D$érýÿÿ€z0tA<\…Iýÿÿ€z0t<\…;ýÿÿ€z\…1ýÿÿÆ\Bé*ýÿÿ€z1u߀z2uÙÆ AƒÂéýÿÿ€z4u¹€z0u³Æ ëæt&ÇD$Ç$èœ:ƒì‰Ãèb8‰$‰\$ÇD$è9ƒì ‰Æ‰D$‰$èm:‰5”qBƒìéÇûÿÿ%s %s %s %s %d %d ¶¿VSƒìD‹\$T‹t$P‹‰T$ ‹K‰L$$‹S‰T$(‹K ‰L$,‹S‰T$0‹KÇD$ÇD$‰L$4‰4$èò…Àº…ú‹\$ ‰Ú¶„Àt(´&< „R< „J<\„BC¶„Àuà‹\$$‰Ú¶„Àt#v< „¢< „š<\„’C¶„Àuà‹\$(‰Ú¶„Àt#v< „ö< „î<\„æC¶„Àuà‹T$,‰Ó¶„Àtv< tY< tU<\tQC¶„Àuì‰T$‹L$4‹\$0ÇD$¡)B‹T$$‰L$‹L$(‰\$‹\$ ‰T$ ‰L$‰\$‰4$èð2‰ÂÁêƒÄD‰Ð[^ÄÀt³‰$‰Óèå1…‰$è2‰D$,‰Â¶< t6< t!<\tˆ¶ BC„Éuæ‹T$,éqÿÿÿÆ\BÆ\ëåÆ\BÆ0BÆ1BÆ2ëÔÆ\BÆ0BÆ4BÆ0ëÄÀ„ÿÿÿ‰$‰Óèp1…‰$è‘1‰D$(‰Ât&¼'¶< t2< t<\tˆ¶ BC„ÉuæéÑþÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØÆ\BÆ0BÆ4BÆ0ëÇ„À„nþÿÿ‰$‰Óèô0…‰$è1‰D$$‰Âë ¶< t2< t<\tˆ¶ BC„Éuæé!þÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØÆ\BÆ0BÆ4BÆ0ëÇ„À„¾ýÿÿ‰$‰Óèt0 …‰ $è•0‰D$ ‰Âë ¶< t2< t<\tˆ¶ BC„ÉuæéqýÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØÆ\BÆ0BÆ4BÆ0ëǶSƒìH‹T$T‹ ‰L$ ‹Z‰\$$‹Z‰\$(‹Z ‰\$,‹Z‰\$0‹Z‰\$4‰Ë¶„À„ã‰ö< „X< „P<\„HC¶„Àuà‹\$$‰Ú¶„Àt#v< „¢< „š<\„’C¶„Àuà‹\$(‰Ú¶„Àt#v< „ö< „î<\„æC¶„Àuà‹T$,‰Ó¶„Àtv< tX< tT<\tPC¶„Àuì‰T$‹\$4‹L$0ÇD$¡)B‹T$ ‰\$‹\$(‰L$‹L$$‰\$‹\$P‰L$ ‰T$‰$è¬.ƒÄHÁè[ÄÀt´‰$‰ÓèÆ.…‰$èç.‰D$,‰Â¶< t6< t!<\tˆ¶ BC„Éuæ‹T$,éqÿÿÿÆ\BÆ\ëåÆ\BÆ0BÆ1BÆ2ëÔÆ\BÆ0BÆ4BÆ0ëÄÀ„ÿÿÿ‰$‰ÓèP.…‰$èq.‰D$(‰Ât&¼'¶< t2< t<\tˆ¶ BC„ÉuæéÑþÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØÆ\BÆ0BÆ4BÆ0ëÇ„À„nþÿÿ‰$‰ÓèÔ-…‰$èõ-‰D$$‰Âë ¶< t2< t<\tˆ¶ BC„Éuæé!þÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØÆ\BÆ0BÆ4BÆ0ëǶ„À„¸ýÿÿ‹\$ ‰$èL-…‰$èm-‰D$ ‰Â´&¶< t9< t<\tˆ¶ BC„ÉuæéqýÿÿÆ\BÆ\ëéÆ\BÆ0BÆ1BÆ2ëØ´&Æ\BÆ0BÆ4BÆ0ëÀ¶éwÿÿÿ´&ƒì‰\$‰t$ÇD$Ç$è¡3ƒì‰Ãèg1‰$‰\$ÇD$è2ƒì ‰Æ‰$‰D$èr3ƒì‰ð‹\$‹t$ƒÄÃwë WVSƒì‹\$ ‹T$$‰$‰T$è†-…À‰Çt]ÇD$Ç$è3ƒì‰Æèâ0‰$‰t$ÇD$èŽ1ƒì ‰Ã‰4$‰D$èí2‰”qBƒì1À…Û”ÀƒÄ[H!ø^_ÃÇD$Ÿ0B‰$è-…À‰ÇuèȉÇë„t&ƒì ‹D$…Àt‰$èm-èh0‰$‹ ”qBÇD$‰L$è^0‹qBƒì ¸‰”qBƒÄ öWVSƒì‹|$$‰<$è^+‹T$ ‰Æ‹Z t&‰|$‰$èt-…Àt#9Øt!€xÿ,t&‰$ÇD$,è†-…À‰ÃtCëÍ1ÀƒÄ[^_Ãt&¶„Òtí€ú=tè€ú,uÈëá__fxstat64: bad file descriptor %d ¶¿ƒì‹T$$‰\$‹\$ ‰t$‹t$(…Û‰|$u8…ÒxT…öt0ü‰Ø‰÷¹ó«‰t$$‰$èQ,‰D$ ‹\$‹t$‹|$ƒÄé)Íÿÿè„+Ç‹\$¸ÿÿÿÿ‹t$‹|$ƒÄÉT$Ç$ 2Bè,èT+Ç ëÎëþƒì‹T$ ‰t$‰\$‹Z‰$è¶+‰$‰Æèl,‰D$ ™‰4$‰T$ÇD$ÇD$è»0ƒì‹\$‹t$ƒÄÃì1À‹T$$‰t$‹t$ ‰\$‹…Ût-¶„Àt€zuX¶ ‰Ú8ÁtA„Éut&¼'lj؋\$‹t$ƒÄþЉT$S‰$èš+v¼'‰Â…ÒtÊÆB‰ëȉö‰T$‰$è´+ëâtmpfw+bD¶ì<‰œ$4\$ ‰´$8ÇD$ÇD$ 4BÇD$ÇD$‰$è1Ò…Àu0‰$ÇD$èú1҉ÅÀxÇD$4B‰$èB+…À‰Æt‰ò‹œ$4‰Ð‹´$8Ä<É$è++ëÝfile%.*s/%.*sXXXXXXTEMP/tmpTMPDIRTMP¶UWVS쬋„$Ì‹´$È…Àt‹”$Ì€:…4¸°4B½‰„$Ì‹œ$Ð…Û…T…ö„Ž‰4$èÔ'…À‰Ât¶D0ÿÇD$ èÔ ¶ˆp7BˆM‰$‰t$ÇD$>ÇD$ 莉$‰Ã‰ÖÇD$>ÇD$ ‰T$èŽ ¶p7BˆU‰$‰t$ÇD$>ÇD$ èH‰$‰Ã‰ÖÇD$>ÇD$ ‰T$èH ¶ˆp7BˆM‰$‰t$ÇD$>ÇD$ è‰$‰Ã‰ÖÇD$>ÇD$ ‰T$è ¶p7BˆU‰$‰t$ÇD$>ÇD$ 載$‰Ã‰ÖÇD$>ÇD$ ‰T$輶ˆp7BˆM‰$ÇD$>ÇD$ ‰t$èv‰$ÇD$>ÇD$ ‰T$èz¶˜p7Bˆ]ƒ¼$¤„Iƒ¼$¤Žƒ¼$¤„̓¼$¤„|»Ð7B…Û…x‹D$…ÀySè>#ƒ8…½ýÿÿ‹°ƒB‹ ´ƒBÂaƒÑ‰ÓG‰°ƒBÿø¢‰Î‰ ´ƒB‚óýÿÿèþ"Çé{ýÿÿvèë"‹t$‰0‹D$éiýÿÿÇ$‹Œ$ t$ ‰t$‰L$è¸ÿÿ…Ày„è´"ƒ8…3ýÿÿè¦"‹\$‰1Àé&ýÿÿÇD$À‹”$ ‰$èB£ÿÿ‰ö‰D$é,ÿÿÿ´&‹„$¤…À… ÿÿÿÇD$€‹´$ ÇD$B…‰4$´&èë#ë¹ÇD$€‹œ$ ÇD$B…‰$ëÝÇD$\$‰$èi‹|$‹T$‰ù‰ûÁáÁû¤û‰Ö‰×‰ÊÁÿ1ò‰°ƒB‰Þ1þ‰5´ƒBéüÿÿÇD$OÇD$ð7BÇ$08Bèw#ƒì‹T$$‰\$‹\$ ‰T$T$‰$èa…Àºÿÿÿÿu"‹L$ºÓMb‰ ‹L$‰È÷ê‰ÈÁøÁú)‰S1Ò‹\$‰ÐƒÄËÀƒB…ÒuéÑ1ÀÃWVSìЋœ$䋼$à…Ût)T$ ‰$èù"ƒìƒøÿ„’1É‹t$ ƒø”Á‰3‰K…ÿtqL$‰ $è¼&ƒì‹\$ÇD$€–˜‹t$ÇD$ ÀÁ*Ö!Nbþ‰\$‰$‰t$‰t$èQ‰‰$ÇD$€–˜ÇD$ ‰t$èS€›Áâ‰WÄÐ1À[^_ÃÇÇCè ¬ÿÿ‰ÆèB ‰0é_ÿÿÿƒì ‰\$‰t$1öèn‰ÃèW9Ãt¾‰5ÀƒB‹\$‹t$ƒÄ Ãè'‰Ãè9ÃuÙëÜ1ÀÃ1ÀÃ1ÀÃ1ÀÃÿ%¦Cÿ% ¦Cÿ%¦CºË~—-Ï¢)ª=sRÔnü@8$Ï£Û6ñ%Ønü@8$Ï£Û6ñ%Ónü@8$Ï£Û6ñ%Xjè ª+Ï¢)ª=sRÖnü@8$Ï£Û6ñ%×nü@8$Ï£Û6ñ%Vjè ª+Ï¢)ª=sRUjè ª+Ï¢)ª=sRQjè ª+Ï¢)ª=sRWjè ª+Ï¢)ª=sRRjè ª+Ï¢)ª=sRTjè ª+Ï¢)ª=sRSjè ª+Ï¢)ª=sRÙnü@8$Ï£Û6ñ%Õnü@8$Ï£Û6ñ%Pjè ª+Ï¢)ª=sRXÙ}‚˜ÏŸ©ªlBÄXÙ}‚˜ÏŸ©ªlBÄ0ÀFRã ‘ÎãªK¸QRã ‘ÎãªK¸QRã ‘ÎãªK¸Q"ûd„í+.Ç2ÀFçÉêyùºÎŒ‚ªK© ãÉêyùºÎŒ‚ªK© äÉêyùºÎŒ‚ªK© âÉêyùºÎŒ‚ªK© åÉêyùºÎŒ‚ªK© ÀFÀF1ÀFæÉêyùºÎŒ‚ªK© ÀFÀF ÀFÀFÀF ÀFÀFÀFñÉêyùºÎŒ‚ªK© !ûd„í+.ÇÀFÀFÀFÀFÀFàÀFRã ‘ÎãªK¸QÐÉêyùºÎŒ‚ªK© ÑÉêyùºÎŒ‚ªK© ÀFRã ‘ÎãªK¸QàÉêyùºÎŒ‚ªK© áÉêyùºÎŒ‚ªK© aùVˆ 4ЩkÀO×¢Â*²êÁ0ϧëÀ[®  §4‡eÐ’J ¯Ç¬M  0–«+Ï¢)ª=sRÕÍÕœ.“—+,ù®à…ŸòùOh«‘+'³ÙÕÍÕœ.“—+,ù® CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 « CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «ÞÀF CPf¾‹»ª0 «€ÞÀF CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 «CPf¾‹»ª0 « CPf¾‹»ª0 «CPf¾‹»ª0 «à6‡a=<Ï ª8›qðÛ¤;<Ï ª8›qá*»ù¤Ï €_,Ðdaºáêí¤Ï €_,Ðdâ*»ù¤Ï €_,Ðdã¡Û+¤Ï €_,ÐdagÑéƒÏ €_,ÐdÀF%ÀFBò:– ΠϪ` ¸ÓÉêyùºÎŒ‚ªK© ÐÉêyùºÎŒ‚ªK© ÀF¡Hü©+Ï¢)ª=sRÍÉêyùºÎŒ‚ªK© ÁÉêyùºÎŒ‚ªK© ËÉêyùºÎŒ‚ªK© ÀÉêyùºÎŒ‚ªK© àÀFàÀF ÄvÏšñ ¯nrô@ÀFÀF²–±´º¶œª4=ÀFÑiõô;Yµi+-¿zÑÉêyùºÎŒ‚ªK© †²–±´º¶œª4„²–±´º¶œª4*ÀFʼ"·hN¢¼ª@Gp@3ð"}TŽe++ÑÀFÀFÀFÀFÀFÀF#ÀF$ÀFÀFÀFÀFÀF!ÀF"ÀFàÀFÀF…²–±´º¶œª4‡²–±´º¶œª4ÀFàÀFÀFÆÉêyùºÎŒ‚ªK© ÀFÀFÀFȼ"·hN¢¼ª@Gp@Ãç³—ïΛɪ`ŽÀF;ÀF9ÀF ÀFBJ7<äºÏ¿}ªiFîÀFÀFÀF ±ò}TŽe++Ñ@Ê'1nDÎ5ªK¸QÀFðÊ™^Aψªµiõ@·¼‰a¼·ÝU¯àö¾t¨‹ºª0 «àö¾t¨‹ºª0 «FÀFÃÉêyùºÎŒ‚ªK© ÇÉêyùºÎŒ‚ªK© ÅÉêyùºÎŒ‚ªK© ÂÉêyùºÎŒ‚ªK© ÄÉêyùºÎŒ‚ªK© ÒÉêyùºÎŒ‚ªK© ×ÉêyúºÎŒ‚ªK© ÀFMm8gÏ–ªh ´ ÀFÀFÀFÀFÀF Yt÷š¿ÏºNÀO×ÀF ÀFÜ[ËÁ“Ï €_,Ðd£Hü©+Ï¢)ª=sRÀFÀF(ÀF)ÀFÀF˼"·hN¢¼ª@GpÀFˆ²–±´º¶œª4‰²–±´º¶œª4ż"·hN¢¼ª@GpǼ"·hN¢¼ª@GpƼ"·hN¢¼ª@GpÀFÀFÀFÌV ô^‹Èª>;)ÀF€­,œ$4϶pªLÖØ ­.’$4϶pªLÖØÀFÀFÀFÀFÀF0óú¡—ïΛɪ`Ž ÀFòЗïΛɪ`ŽòЗïΛɪ`Ž°ÓJ‰—ïΛɪ`ŽÀFð(R äβɪh 7p@8I äβɪh 7 ÀFÐiõÕ;Yµi+-¿zÀFªÓk7E8„í+.Ç ÀF ÀFàå½®¦Î½7PBÁÉÉêyùºÎŒ‚ªK© `OØ7ËBÎ5ªK¸QXõ" (Ш© É  ÀF ÀF€#ÕN®-+.Ç€ ø{2¿‹»ª0 « ø{2¿‹»ª0 «  ˜Uª5϶qªLÖØɼ"·hN¢¼ª@Gp XשFÏ•üªh ´*'UËBÎ5ªK¸Q‚Xõ" (Ш© É Š²–±´º¶œª4¼û›ñï„íª4²–±´º¶œª4eFä¬$„í+.ÇŒ²–±´º¶œª4:ÀF8ÀFƒ²–±´º¶œª4À:¼¦ªÛÎãªK¸Q'ÀFÀFíQÏþbÏ¿† ÉH6ÀkŸò!PΪi)? ÀF ÀFÀFÀF`kõÕ;Yµi+-¿zÀF4jõÕ;Yµi+-¿zjõÕ;Yµi+-¿zÀFüjõÕ;Yµi+-¿z&ÀFÀF0:s *έåªDw=Ðiõô;Yµi+-¿z>ÀFÁ@Qm6t΀4ª` ú+tæ‘Nª0 «‹²–±´º¶œª4ÀF ÀF ÀF&ÀFÀF`= ßTŽe++ÑÀ“‡TtžÏ–U ÉI#€Œ÷ÕRRÏúªBnÀFÀFÀFÀFÀFÀFÀFAJ7<äºÏ¿}ªiFî ÀF'ÀF’Bò:– ΠϪ` ¸Á*²êÁ0ϧëÀ[® a Ó¯ÍЊ>ÀOÉânßÀFØÉêyúºÎŒ‚ªK© ÖÉêyúºÎŒ‚ªK© ÕÉêyúºÎŒ‚ªK© 0ÀFÞÀFÞÀFÞÀFÞÀFÞÀFÞÀF!ÞÀFÞÀF ÞÀF ÞÀFÞÀFÞÀFÞÀF ÞÀFÞÀFÞÀFÞÀFÞÀFÞÀF"ÞÀF ÞÀF#ÞÀF ÞÀFÞÀFÞÀFÞÀFÞÀFÞÀF ÞÀFÞÀFÞÀFÞÀFÞÀFÞÀFÞÀF¾"·hN¢¼ª@Gp¥Hü©+Ï¢)ª=sRÿ% ¦Cÿ%$¦Cÿ%t£Cÿ%„£Cÿ%l£Cÿ%€£Cÿ%|£Cÿ%x£Cÿ%ˆ£Cÿ%p£Cÿ%h£Cÿ% £Cÿ%£Cÿ%Œ£Cÿ%`£Cÿ%d£Cÿ%˜£Cÿ%œ£Cÿ%”£CU¹€Bù€B‰ås‹Q‹ƒÁ‚@ù€Brê]ÃU‰åÛã]ÃU‰åƒì¡ÄqB‹…Òu‰ì]Ãÿ‹ÄqB‹JB£ÄqB…Éuéëã‰öU‰åƒì‰]ü¡hBƒøÿt)…À‰ÃuÇ$ TBèK»ýÿ‹]ü‰ì]Ãt&ÿhBKuöëÝ‹ hB1À…Ét˺hBv@‹L‚…Éu÷ë¸t&U‰åƒì‰]ü‹ÀqB…Òu'¡hBº‰ÀqBƒøÿt%…À‰ÃuÇ$ TBèÖºýÿ‹]ü‰ì]ÃÿhBKuöëá‹ hB1À…ÉtϺhB‰ö@‹\‚…Ûu÷ë½-LIBGCCW32-EH-SJLJ-GTHR-MINGW32U‰åƒì¡p˜CÿP‰ì]ô&¼'U1À‰åüƒì¹‰$‹]‰|$‰ßó«Ç8¡ÐƒB‹äqBÇC`B‰C¡àqB‰SÇC,ÿÿÿÿ‰C¡àƒBÇCÀUBÇC$‰C(¡èqB‹ìqB‰C0‰S4‹$‹|$‰ì]Ãt&U‰åƒìX‰]ø¡p˜C‰uü…Àt ‹]ø‹uü‰ì]ÃÇE¸AAAA¡ UBu¸ÇE¼AAAAÇEÀAAAA‰EØ¡¤UBÇEÄAAAAÇEÈAAAA‰EÜ¡¨UBÇEÌAAAAÇEÐAAAA‰E࡬UBÇEÔAAAA‰4$‰Eä¡°UB‰Eè¡´UB‰E졸UB‰Eð¡¼UB‰Eôè- ·Àƒìf…ÀubÇ$8è&…À‰Ãt\‰$è¸þÿÿ‰$è`f…Àt‰p˜CC£`˜CC£€˜Cé%ÿÿÿ‰$è؉4$èÐ ƒì·Àv¼'‰$èȉÃë¹èë U¸‰åVºSƒìP‹ut&¼'…ò±Au±aˆL¸ÒHyï¡ UB‰EØ¡¤UB‰EÜ¡¨UB‰E࡬UB‰Eä¡°UB‰Eè¡´UB‰E졸UB‰Eð¡¼UB‰EôE¸‰$è4 ·Øƒìf…Ûu 1Òeø‰Ð[^]É$è9ð‰Úuçëç´&¼'U‰åU¸SƒìT1Û·EÇD$@‰T$‰$èì ƒì …Àt1¸ºt&¼'€|¸AtÒHyôƒ;8u ‰Ø‹]üÉà Óëëè_Q‰áƒÁ=réƒ -ëé)Áƒ ‰à‰Ì‹‹@ÿàU‰åƒì(‰]ô‹U‹M‰uø‹E…Ò‰}ü‹] ‰ÆÇEèÇEì‰MäuP9Øv*‰È‰Ú÷ö‰Ç‰ö1ɉ}è‹]ô‹Eè‰Mì‹uø‹Uì‹}ü‰ì]Ãt&…Àu ¸1É1Ò÷ñ‰Æ‰Ø1Ò÷ö‰Á‹Eä÷ö‰ÇëÀ9Úv 1ÿ붶½Âƒð‰Eàu9Ów1ÿ9uärš¿ë“v‹E๠)Á‰M܉ð¶MàÓâ‰×¶M܉ÚÓè¶Mà Ç‹EäÓæ¶MÜÓê¶MàÓã¶MÜÓè öMà‰Ø÷÷‰Ó‰ÇÓeä÷æ9Úw9Ú…5ÿÿÿ;Eä†,ÿÿÿOé&ÿÿÿU‰åWVSƒì,‹UÇEà‹M‹] ÇEä‹E…Ò‰U܉߉ƉMØu_9Øv;‰È‰Ú÷ö‰UØMè…ÉtÇEä‹E؉Eà‹Uà‹Mä‰Uè‰Mì‹Eè‹UìƒÄ,[^_]Ãt&…Àu ¸1Ò÷ö‰Æ‰ø‹UÜ÷ö‹EØ÷öë®v9]Üv‰Mà‰}ä‹Eà‹Uä‰Eè‰Uìëµ´&½E܉Ãóu%;}Üw9uØr ‹UØ)ò}܉UØMè…Ét‡‰}äémÿÿÿ‹Uܸ ˆÙ)؉EÔÓâ‰ð¶MÔÓèˆÙÓæ ‹EضMÔ‰U܉úÓêˆÙÓç¶MÔÓè ljøˆÙ÷uÜÓe؉×÷æ‰EÌ9úw:9út.Eè…À„!ÿÿÿ¶MÔ‹EØ+EÌ׉E؉úÓâˆÙÓè ‰UàÓïé8ÿÿÿ‹EØ9EÌvÊ‹MÌ)ñU܉MÌë½ÿ%Ô¤Cÿ%ð¤Cÿ%ä¤Cÿ%à¤Cÿ%ø¤Cÿ%ȤCÿ%ؤCÿ%̤Cÿ%ܤCÿ%ô¤Cÿ%ì¤Cÿ%è¤Cÿ%ФCÿ%¥Cÿ%¥Cÿ% ¥Cÿ%À¥Cÿ%¥Cÿ%T¥Cÿ%¥Cÿ%¥Cÿ%Ä¥Cÿ%¤¥Cÿ%°¥Cÿ%à¥Cÿ%¼¥Cÿ%Œ¥Cÿ% ¥Cÿ%Ø¥Cÿ%@¥Cÿ%¨¥Cÿ%¬¥Cÿ%Ô¥Cÿ%x¥Cÿ%ä¥Cÿ%D¥Cÿ%„¥Cÿ%œ¥Cÿ%ü¥Cÿ%€¥Cÿ%t¥Cÿ%l¥Cÿ%(¥Cÿ%Ü¥Cÿ%|¥Cÿ%4¥Cÿ%\¥Cÿ%ˆ¥Cÿ%”¥Cÿ%è¥Cÿ%¸¥Cÿ%Ì¥Cÿ%p¥Cÿ%8¥Cÿ%´¥Cÿ% ¥Cÿ%ð¥Cÿ%˜¥Cÿ%X¥Cÿ%ø¥Cÿ%h¥Cÿ%¦Cÿ%Ð¥Cÿ%È¥Cÿ%ô¥Cÿ%0¥Cÿ%ì¥Cÿ%,¥Cÿ%$¥Cÿ%L¥Cÿ%¥Cÿ%`¥Cÿ% ¤Cÿ%УCÿ%L¤Cÿ%¼£Cÿ%œ¤Cÿ%´£Cÿ% ¤Cÿ%”¤Cÿ%¤Cÿ%X¤Cÿ%à£Cÿ%è£Cÿ%¤¤Cÿ%¤Cÿ%¤Cÿ%Ø£Cÿ%Ô£Cÿ%¤Cÿ%˜¤Cÿ%Œ¤Cÿ%$¤Cÿ%@¤Cÿ%ø£Cÿ%ô£Cÿ%€¤Cÿ%ˆ¤Cÿ%ä£Cÿ%Ì£Cÿ%8¤Cÿ%`¤Cÿ%l¤Cÿ%°¤Cÿ%¸¤Cÿ%¼¤Cÿ%À£Cÿ%h¤Cÿ%¬¤Cÿ%„¤Cÿ%d¤Cÿ%ü£Cÿ%\¤Cÿ%P¤Cÿ%T¤Cÿ%t¤Cÿ%Ä£Cÿ%¸£Cÿ%¤Cÿ%D¤Cÿ%°£Cÿ%x¤Cÿ%´¤Cÿ%,¤Cÿ%0¤Cÿ%4¤Cÿ%<¤Cÿ%ì£Cÿ%p¤Cÿ%¤Cÿ% ¤Cÿ%¤Cÿ%|¤Cÿ%È£Cÿ%¤Cÿ%(¤Cÿ%¨¤Cÿ%H¤Cÿ%Ü£Cÿ%¬£Cÿ%ð£CÀFÀF ÀF¡ÀFÐÀFÑÀFÒÀFáÀFâÀFãÀFäÀFÀFåÀFæÀFèÀFéÀFêÀFëÀFîÀFïÀFðÀFñÀFòÀFóÀFôÀFõÀFöÀF÷ÀFøÀFùÀFúÀFûÀFüÀF€žãˆx5Ï®i+.bŒöò“Ó£ÀOy«ÑðÙÃ\Ñ•¾`——êOßOðÎrþÒ‡¥ÀOh7Ïá‹MÒ…]`“gÀ*²êÁ0ϧëÀ[® Á*²êÁ0ϧëÀ[® Â*²êÁ0ϧëÀ[® Ã*²êÁ0ϧëÀ[® Ä*²êÁ0ϧëÀ[® Å*²êÁ0ϧëÀ[® Æ*²êÁ0ϧëÀ[® ßÀFßÀFßÀFßÀF ßÀF@å‘°ãƒÏ§ ¯×—b@;òûðㄈª>Vø€;òûðㄈª>VøŠ'WFAÒƒšÀOÙЋ'WFAÒƒšÀOÙІ÷[ÞzGÒƒÀOÙÐPèBÒ¾, É¨=¡Bl ‰ÅЙšÀOÖUáU‰å]éwªýÿÿÿÿÿhBÿÿÿÿß[@å[@ì[@ì[@ì[@ì[@ó[@û[@\@ \@\@п@Û@ÐÛ@Ü@PÜ@v5A}5A5A™5A_9Al9Au9A…9A“9A˜9Av'A'A“'A—'Aœ'A£'A¬'A¼'AÊ'AÓ'AØ'Aà'Aå'Aî'A(Aü'A (A(A(A!(A/(A6(AI(A\(Ao(A‚(A‹(A•(Až(A¶(AÈ(AÏ(A×(AÜ(AÐüAA%B%B@ hBÿÿÿÿÿÿÿÿ  ±`£Ü D²¬£ø¡ˆ²Ȥ4¢”³¥<£¬³ ¦P£À³ ¦,¦D¦`¦€¦œ¦¼¦ܦü¦§(§D§T§l§€§§ §´§Чܧ𧨨$¨4¨D¨X¨p¨€¨˜¨´¨À¨̨à¨ð¨©©$©D©X©l©|©”©´©Ä©Ô©ä©ø©ªª8ªPªdªxªŒª ª°ªÀªܪøª««0«<«H«d«|«”«¤«°«È«Ø«ä«ô«¬¬(¬@¬T¬d¬„¬˜¬¨¬À¬̬جä¬ð¬ü¬­­ ­(­4­<­H­T­`­l­x­„­”­¤­´­Ä­Ø­ä­ð­ü­®® ®4®@®T®\®h®t®€®ˆ®”® ®¬®¸®À®Ì®Ø®à®ì®ø®¯¯¯¯$¯,¯8¯D¯P¯\¯h¯p¯|¯ˆ¯”¯ ¯¬¯¸¯įЯܯè¯ô¯° °°$°0°<°H°T°`°l°x°„°˜°¬°¼°Ì°,¦D¦`¦€¦œ¦¼¦ܦü¦§(§D§T§l§€§§ §´§Чܧ𧨨$¨4¨D¨X¨p¨€¨˜¨´¨À¨̨à¨ð¨©©$©D©X©l©|©”©´©Ä©Ô©ä©ø©ªª8ªPªdªxªŒª ª°ªÀªܪøª««0«<«H«d«|«”«¤«°«È«Ø«ä«ô«¬¬(¬@¬T¬d¬„¬˜¬¨¬À¬̬جä¬ð¬ü¬­­ ­(­4­<­H­T­`­l­x­„­”­¤­´­Ä­Ø­ä­ð­ü­®® ®4®@®T®\®h®t®€®ˆ®”® ®¬®¸®À®Ì®Ø®à®ì®ø®¯¯¯¯$¯,¯8¯D¯P¯\¯h¯p¯|¯ˆ¯”¯ ¯¬¯¸¯įЯܯè¯ô¯° °°$°0°<°H°T°`°l°x°„°˜°¬°¼°Ì°AdjustTokenPrivilegesÃGetKernelObjectSecurityÔGetSecurityDescriptorControlÕGetSecurityDescriptorDaclÖGetSecurityDescriptorGroup×GetSecurityDescriptorLengthØGetSecurityDescriptorOwnerÚGetSecurityDescriptorSaclIsValidAcl IsValidSecurityDescriptor IsValidSidLookupPrivilegeValueAeOpenProcessToken‚RegCloseKey›RegOpenKeyExA¥RegQueryValueExAËSetKernelObjectSecurityAddAtomA AreFileApisANSI&CloseHandle<CreateDirectoryADCreateFileAOCreateMutexAlDeleteFileAsDeviceIoControl}EnterCriticalSection›ExitProcess¦FileTimeToDosDateTime§FileTimeToLocalFileTime¯FindAtomA±FindCloseµFindFirstFileA¾FindNextFileAÕFreeLibraryÜGetAtomNameA GetConsoleModeGetConsoleScreenBufferInfoGetCurrentProcess"GetDiskFreeSpaceA(GetDriveTypeA2GetFileAttributesA6GetFileInformationByHandle7GetFileSize9GetFileTime:GetFileType=GetFullPathNameACGetLastErrorEGetLocaleInfoAGGetLogicalDriveStringsAMGetModuleFileNameAOGetModuleHandleAjGetProcAddressmGetProcessHeap~GetShortPathNameA‚GetStdHandleŒGetSystemInfo‘GetSystemTimeAsFileTime¨GetTimeZoneInformation®GetVersion¯GetVersionExA±GetVolumeInformationA×HeapAllocÝHeapFreeêInitializeCriticalSectionïInterlockedExchange LeaveCriticalSection LoadLibraryA'MoveFileA.MultiByteToWideCharDPeekNamedPipeeReadFileqReleaseMutex¡SetConsoleMode²SetEndOfFileµSetErrorMode¹SetFileAttributesA»SetFilePointer¿SetFileTimeßSetUnhandledExceptionFilterâSetVolumeLabelAUnlockFile%WaitForSingleObjectWlstrcmpiAZlstrcpyA]lstrcpynA`lstrlenA_chmod_close'_getpid+_isatty;_open?_putenvA_readG_setmodeT_strdupU_stricmpX_strnicmp\_struprq_write'__getmainargs0__mb_cur_max<__p__environ>__p__fmodeP__set_app_typeo_asserty_cexit_chmod‚_close˜_errno§_fdopen­_filelengthi64·_flsbufÊ_get_osfhandleé_iobë_isctype_lseeki64^_onexit__openg_pctype„_setmode›_stricmp±_tzsetabortatexit!calloc*exit-fclose0fflush3fgets8fopen9fprintf:fputc;fputs?freeKgetenvOgmtimeRisalphanlocaltimermallocsmblenxmemcpyzmemset}perrorprintfˆreallocŽsetlocalesignal“sprintf–sscanf—strcat˜strchr™strcmp›strcpystrerrorŸstrlen¡strncmp¢strncpy£strpbrk¤strrchr¥strspn¦strstr´tolowerµtoupper CoCreateInstanceHCoUninitialize´OleInitialize-CharToOemA»OemToCharA                 ADVAPI32.DLL                                                                     KERNEL32.dll( ( ( ( ( ( ( ( ( ( ( ( ( msvcrt.dll< < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < msvcrt.dllP P P OLE32.dlld d USER32.dllúçB(€X€ˆ€úçB@€úçB ¸úçBôp€úçB ÈúçB €úçB ØèÀ¨É¤É ( @€€€€€€€€€€ÀÀÀÀÜÀðʦÔðÿ±âÿŽÔÿkÆÿH¸ÿ%ªÿªÿ’Üz¹b–Js2PÔãÿ±ÇÿŽ«ÿkÿHsÿ%WÿUÿIÜ=¹1–%sPÔÔÿ±±ÿŽŽÿkkÿHHÿ%%ÿþܹ–sPãÔÿDZÿ«ŽÿkÿsHÿW%ÿUÿIÜ=¹1–%sPðÔÿâ±ÿÔŽÿÆkÿ¸Hÿª%ÿªÿ’Üz¹b–Js2PÿÔÿÿ±ÿÿŽÿÿkÿÿHÿÿ%ÿþþÜܹ¹––ssPPÿÔðÿ±âÿŽÔÿkÆÿH¸ÿ%ªÿªÜ’¹z–bsJP2ÿÔãÿ±ÇÿŽ«ÿkÿHsÿ%WÿUÜI¹=–1s%PÿÔÔÿ±±ÿŽŽÿkkÿHHÿ%%þܹ–sPÿãÔÿDZÿ«ŽÿkÿsHÿW%ÿUÜI¹=–1s%PÿðÔÿâ±ÿÔŽÿÆkÿ¸Hÿª%ÿªÜ’¹z–bsJP2ÿÿÔÿÿ±ÿÿŽÿÿkÿÿHÿÿ%þþÜܹ¹––ssPPðÿÔâÿ±ÔÿŽÆÿk¸ÿHªÿ%ªÿ’Üz¹b–Js2PãÿÔÇÿ±«ÿŽÿksÿHWÿ%UÿIÜ=¹1–%sPÔÿÔ±ÿ±ŽÿŽkÿkHÿH%ÿ%þܹ–sPÔÿã±ÿÇŽÿ«kÿHÿs%ÿWÿUÜI¹=–1s%PÔÿð±ÿâŽÿÔkÿÆHÿ¸%ÿªÿªÜ’¹z–bsJP2Ôÿÿ±ÿÿŽÿÿkÿÿHÿÿ%ÿÿþþÜܹ¹––ssPPòòòæææÚÚÚÎÎ涶ªªªžžž’’’†††zzznnnbbbVVVJJJ>>>222&&&ðûÿ¤  €€€ÿÿÿÿÿÿÿÿÿÿÿÿÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÿåøÜÜÜÜÜÜÜÜÜÜÜÜÜÜÿåøøøøøøøøøøøøøøøÜÜÜÜÜÜÜÜÜÜÜÜÜÿååååååååååååååÿøÜÜÜÜÜÜÜÜÜÜÜÜÜåÿøÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜåÿøÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜøøøøøøøøøøøøøøøøøøøøøøøøÜÜÜÜÜÜååååååååååååååååÿøøøøøøøÜÜÜÜÜÜåøøÿåååååøøÜÜÜÜÜÜåøøÜÜÜÜÜÜÜÜÜÜÜÿåååååøøåøøÜÜÜÜÜÜÿåååååøøåååååååøøøøøøøÜÜÜÜÜÜÿåååååøøÜÜÜÜÜÜÿåååååøøÿÿÿÿÿÿÿÿÿÿÿÿÿøÜÜÜÜÜÜÿÿÿÿÿÿøøÿÿÿÿÿÿÿÿÿÿÿÿÿøÜÜÜÜÜÜÜÜÿpppp”p”ppÿÿÿøÜÜÜÜÜÜÜÜÿåÜÜÿpÿÿpÿpÿpÿÿÿÿøÜÜÜÜÜÜÜÜåÿåÜÜÿÿpÿÿÿpÿppp”ÿøÜÜÜÜÜÜÜÜÿåÿÜÜÿÿÿpÿÿpÿpÿÿøøÜÜÜÜÜÜÜÜÿåÜÜÿpÿÿpÿpÿpÿÜÜÜÜÜÜÜÜåÿåÜÜÿpppp”p”ppåååÜÜÜÜÜÜÜÜÿåÿÜÜÿÿÿÿÿÿÿÿÿÿååÜÜÜÜÜÜÜÜÜÿÿÿÿÿÿÿÿÿÿåÜÜÜÜÜÜÜÜøøøøøøøøÜÜÜÜÜÜÿøøøøøøøåååååååøøøøøøøÜÜÜÜÜÜÿåååååøøåøøÜÜÜÜÜÜÿåååååøøÜÜÜÜÜÜÿøøÜÜÜÜÜÜÜÜÜÜÜÿåååååøøÜÜÜÜÜÜÿøøÿåååååøøÜÜÜÜÜÜÿøøøøøøøøøøøøøøøÿåååååøøÜÜÜÜÜÜÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøøÜÜÜÜÜÜÜÜ ¨ 4VS_VERSION_INFO½ïþ3ê…O3ê…O?.~StringFileInfoZ040904E4XCompanyNameInfo-Zip <www.info-zip.org>BLicensesee contrib/LICENSE ÀLFileDescriptionUnZip SPECS UnZip: list, test and extract compressed files in a ZIP archive@FileVersion5.51.1871.34282,InternalNameunzipj#LegalCopyright© 2005 Info-Zip <www.info-zip.org>\LegalTrademarksInfo-Zip®, UnZip®, unzip®< OriginalFilenameunzip.exe,ProductNameUnZipDProductVersion5.51.1871.34282: PrivateBuildPatchlevel 1r)SpecialBuildGNU for Win32 <gnuwin32.sourceforge.net>V#WWWhttp://www.info-zip.org/UnZip.htmlDVarFileInfo$Translation äPK 1LwBc ì ì ¤felicegimondi.jpgPK äMwB'~n*RÚRÚ ¤ pg1000.txtPK ³$,AÌí¢ú? ? ¤•ærcu.hPK ³$,AÓ•³åžž ¤÷ðsched_fair.cPK s˜N2¨ãæ„„ ÿ¿ùunzip.exePKæ} advancecomp-1.23/test/basn2c08.png000066400000000000000000000061441301462770100167320ustar00rootroot00000000000000‰PNG  IHDR üí£ +IDATH  ßóÿÿÿÿÿþÿÿýÿÿüÿÿûÿÿúÿÿùÿÿøÿÿ÷ÿÿöÿÿõÿÿôÿÿóÿÿòÿÿñÿÿðÿÿïÿÿîÿÿíÿÿìÿÿëÿÿêÿÿéÿÿèÿÿçÿÿæÿÿåÿÿäÿÿãÿÿâÿÿáÿÿàÿÿßÿÿÞÿÿÝÿÿÜÿÿÛÿÿÚÿÿÙÿÿØÿÿ×ÿÿÖÿÿÕÿÿÔÿÿÓÿÿÒÿÿÑÿÿÐÿÿÏÿÿÎÿÿÍÿÿÌÿÿËÿÿÊÿÿÉÿÿÈÿÿÇÿÿÆÿÿÅÿÿÄÿÿÃÿÿÂÿÿÁÿÿÀÿÿ¿ÿÿ¾ÿÿ½ÿÿ¼ÿÿ»ÿÿºÿÿ¹ÿÿ¸ÿÿ·ÿÿ¶ÿÿµÿÿ´ÿÿ³ÿÿ²ÿÿ±ÿÿ°ÿÿ¯ÿÿ®ÿÿ­ÿÿ¬ÿÿ«ÿÿªÿÿ©ÿÿ¨ÿÿ§ÿÿ¦ÿÿ¥ÿÿ¤ÿÿ£ÿÿ¢ÿÿ¡ÿÿ ÿÿŸÿÿžÿÿÿÿœÿÿ›ÿÿšÿÿ™ÿÿ˜ÿÿ—ÿÿ–ÿÿ•ÿÿ”ÿÿ“ÿÿ’ÿÿ‘ÿÿÿÿÿÿŽÿÿÿÿŒÿÿ‹ÿÿŠÿÿ‰ÿÿˆÿÿ‡ÿÿ†ÿÿ…ÿÿ„ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿÿÿ~ÿÿ}ÿÿ|ÿÿ{ÿÿzÿÿyÿÿxÿÿwÿÿvÿÿuÿÿtÿÿsÿÿrÿÿqÿÿpÿÿoÿÿnÿÿmÿÿlÿÿkÿÿjÿÿiÿÿhÿÿgÿÿfÿÿeÿÿdÿÿcÿÿbÿÿaÿÿ`ÿÿ_ÿÿ^ÿÿ]ÿÿ\ÿÿ[ÿÿZÿÿYÿÿXÿÿWÿÿVÿÿUÿÿTÿÿSÿÿRÿÿQÿÿPÿÿOÿÿNÿÿMÿÿLÿÿKÿÿJÿÿIÿÿHÿÿGÿÿFÿÿEÿÿDÿÿCÿÿBÿÿAÿÿ@ÿÿ?ÿÿ>ÿÿ=ÿÿ<ÿÿ;ÿÿ:ÿÿ9ÿÿ8ÿÿ7ÿÿ6ÿÿ5ÿÿ4ÿÿ3ÿÿ2ÿÿ1ÿÿ0ÿÿ/ÿÿ.ÿÿ-ÿÿ,ÿÿ+ÿÿ*ÿÿ)ÿÿ(ÿÿ'ÿÿ&ÿÿ%ÿÿ$ÿÿ#ÿÿ"ÿÿ!ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿ ÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿýÿÿüÿÿûÿÿúÿÿùÿÿøÿÿ÷ÿÿöÿÿõÿÿôÿÿóÿÿòÿÿñÿÿðÿÿïÿÿîÿÿíÿÿìÿÿëÿÿêÿÿéÿÿèÿÿçÿÿæÿÿåÿÿäÿÿãÿÿâÿÿáÿÿàÿÿßÿÿÞÿÿÝÿÿÜÿÿÛÿÿÚÿÿÙÿÿØÿÿ×ÿÿÖÿÿÕÿÿÔÿÿÓÿÿÒÿÿÑÿÿÐÿÿÏÿÿÎÿÿÍÿÿÌÿÿËÿÿÊÿÿÉÿÿÈÿÿÇÿÿÆÿÿÅÿÿÄÿÿÃÿÿÂÿÿÁÿÿÀÿÿ¿ÿÿ¾ÿÿ½ÿÿ¼ÿÿ»ÿÿºÿÿ¹ÿÿ¸ÿÿ·ÿÿ¶ÿÿµÿÿ´ÿÿ³ÿÿ²ÿÿ±ÿÿ°ÿÿ¯ÿÿ®ÿÿ­ÿÿ¬ÿÿ«ÿÿªÿÿ©ÿÿ¨ÿÿ§ÿÿ¦ÿÿ¥ÿÿ¤ÿÿ£ÿÿ¢ÿÿ¡ÿÿ ÿÿŸÿÿžÿÿÿÿœÿÿ›ÿÿšÿÿ™ÿÿ˜ÿÿ—ÿÿ–ÿÿ•ÿÿ”ÿÿ“ÿÿ’ÿÿ‘ÿÿÿÿÿÿŽÿÿÿÿŒÿÿ‹ÿÿŠÿÿ‰ÿÿˆÿÿ‡ÿÿ†ÿÿ…ÿÿ„ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿÿÿ~ÿÿ}ÿÿ|ÿÿ{ÿÿzÿÿyÿÿxÿÿwÿÿvÿÿuÿÿtÿÿsÿÿrÿÿqÿÿpÿÿoÿÿnÿÿmÿÿlÿÿkÿÿjÿÿiÿÿhÿÿgÿÿfÿÿeÿÿdÿÿcÿÿbÿÿaÿÿ`ÿÿ_ÿÿ^ÿÿ]ÿÿ\ÿÿ[ÿÿZÿÿYÿÿXÿÿWÿÿVÿÿUÿÿTÿÿSÿÿRÿÿQÿÿPÿÿOÿÿNÿÿMÿÿLÿÿKÿÿJÿÿIÿÿHÿÿGÿÿFÿÿEÿÿDÿÿCÿÿBÿÿAÿÿ@ÿÿ?ÿÿ>ÿÿ=ÿÿ<ÿÿ;ÿÿ:ÿÿ9ÿÿ8ÿÿ7ÿÿ6ÿÿ5ÿÿ4ÿÿ3ÿÿ2ÿÿ1ÿÿ0ÿÿ/ÿÿ.ÿÿ-ÿÿ,ÿÿ+ÿÿ*ÿÿ)ÿÿ(ÿÿ'ÿÿ&ÿÿ%ÿÿ$ÿÿ#ÿÿ"ÿÿ!ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿ ÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿýÿÿüÿÿûÿÿúÿÿùÿÿøÿÿ÷ÿÿöÿÿõÿÿôÿÿóÿÿòÿÿñÿÿðÿÿïÿÿîÿÿíÿÿìÿÿëÿÿêÿÿéÿÿèÿÿçÿÿæÿÿåÿÿäÿÿãÿÿâÿÿáÿÿàÿÿßÿÿÞÿÿÝÿÿÜÿÿÛÿÿÚÿÿÙÿÿØÿÿ×ÿÿÖÿÿÕÿÿÔÿÿÓÿÿÒÿÿÑÿÿÐÿÿÏÿÿÎÿÿÍÿÿÌÿÿËÿÿÊÿÿÉÿÿÈÿÿÇÿÿÆÿÿÅÿÿÄÿÿÃÿÿÂÿÿÁÿÿÀÿÿ¿ÿÿ¾ÿÿ½ÿÿ¼ÿÿ»ÿÿºÿÿ¹ÿÿ¸ÿÿ·ÿÿ¶ÿÿµÿÿ´ÿÿ³ÿÿ²ÿÿ±ÿÿ°ÿÿ¯ÿÿ®ÿÿ­ÿÿ¬ÿÿ«ÿÿªÿÿ©ÿÿ¨ÿÿ§ÿÿ¦ÿÿ¥ÿÿ¤ÿÿ£ÿÿ¢ÿÿ¡ÿÿ ÿÿŸÿÿžÿÿÿÿœÿÿ›ÿÿšÿÿ™ÿÿ˜ÿÿ—ÿÿ–ÿÿ•ÿÿ”ÿÿ“ÿÿ’ÿÿ‘ÿÿÿÿÿÿŽÿÿÿÿŒÿÿ‹ÿÿŠÿÿ‰ÿÿˆÿÿ‡ÿÿ†ÿÿ…ÿÿ„ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿÿÿ~ÿÿ}ÿÿ|ÿÿ{ÿÿzÿÿyÿÿxÿÿwÿÿvÿÿuÿÿtÿÿsÿÿrÿÿqÿÿpÿÿoÿÿnÿÿmÿÿlÿÿkÿÿjÿÿiÿÿhÿÿgÿÿfÿÿeÿÿdÿÿcÿÿbÿÿaÿÿ`ÿÿ_ÿÿ^ÿÿ]ÿÿ\ÿÿ[ÿÿZÿÿYÿÿXÿÿWÿÿVÿÿUÿÿTÿÿSÿÿRÿÿQÿÿPÿÿOÿÿNÿÿMÿÿLÿÿKÿÿJÿÿIÿÿHÿÿGÿÿFÿÿEÿÿDÿÿCÿÿBÿÿAÿÿ@ÿÿ?ÿÿ>ÿÿ=ÿÿ<ÿÿ;ÿÿ:ÿÿ9ÿÿ8ÿÿ7ÿÿ6ÿÿ5ÿÿ4ÿÿ3ÿÿ2ÿÿ1ÿÿ0ÿÿ/ÿÿ.ÿÿ-ÿÿ,ÿÿ+ÿÿ*ÿÿ)ÿÿ(ÿÿ'ÿÿ&ÿÿ%ÿÿ$ÿÿ#ÿÿ"ÿÿ!ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿ ÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþþþýýýüüüûûûúúúùùùøøø÷÷÷öööõõõôôôóóóòòòñññðððïïïîîîíííìììëëëêêêéééèèèçççæææåååäääãããâââáááàààßßßÞÞÞÝÝÝÜÜÜÛÛÛÚÚÚÙÙÙØØØ×××ÖÖÖÕÕÕÔÔÔÓÓÓÒÒÒÑÑÑÐÐÐÏÏÏÎÎÎÍÍÍÌÌÌËËËÊÊÊÉÉÉÈÈÈÇÇÇÆÆÆÅÅÅÄÄÄÃÃÃÂÂÂÁÁÁÀÀÀ¿¿¿¾¾¾½½½¼¼¼»»»ººº¹¹¹¸¸¸···¶¶¶µµµ´´´³³³²²²±±±°°°¯¯¯®®®­­­¬¬¬«««ªªª©©©¨¨¨§§§¦¦¦¥¥¥¤¤¤£££¢¢¢¡¡¡   ŸŸŸžžžœœœ›››ššš™™™˜˜˜———–––•••”””“““’’’‘‘‘ŽŽŽŒŒŒ‹‹‹ŠŠŠ‰‰‰ˆˆˆ‡‡‡†††………„„„ƒƒƒ‚‚‚€€€~~~}}}|||{{{zzzyyyxxxwwwvvvuuutttsssrrrqqqpppooonnnmmmlllkkkjjjiiihhhgggfffeeedddcccbbbaaa```___^^^]]]\\\[[[ZZZYYYXXXWWWVVVUUUTTTSSSRRRQQQPPPOOONNNMMMLLLKKKJJJIIIHHHGGGFFFEEEDDDCCCBBBAAA@@@???>>>===<<<;;;:::999888777666555444333222111000///...---,,,+++***)))((('''&&&%%%$$$###"""!!!  h¸÷yŽ5ÈIEND®B`‚advancecomp-1.23/test/basn3p01.png000066400000000000000000000021661301462770100167410ustar00rootroot00000000000000‰PNG  IHDR D¤ŠÆPLTEîÿ""fÿlÒ&+IDAT8 ßû$\Èž<ùIEND®B`‚advancecomp-1.23/test/basn3p02.png000066400000000000000000000021741301462770100167410ustar00rootroot00000000000000‰PNG  IHDR D¤ŠÆ PLTEÿÿÿÿÿe?+º+IDAT8 ßûdÔ 6-ŠIEND®B`‚advancecomp-1.23/test/basn3p04.png000066400000000000000000000022351301462770100167410ustar00rootroot00000000000000‰PNG  IHDR D¤ŠÆ-PLTE"ÿÿÿˆÿ"ÿ™ÿÿfÝÿwÿÿÿ™Ýÿÿ»ÿ»DÿÿDÒ°I½+IDAT8 ßû                                                                  l3¡Ù‘úIEND®B`‚advancecomp-1.23/test/basn3p08.png000066400000000000000000000035601301462770100167470ustar00rootroot00000000000000‰PNG  IHDR D¤ŠÆPLTE"DõÿíwÿwËÿÿ :w""ÿÿÿ""ÿ¬Ufÿfÿffÿÿ"ÜÿÿÌÿ™DDÿUU"ËËÿDDUÿUËË3ÿìÜíÿÿäÿËÿÜÜDÿDffÿ3D"ííÿffÿ¤DÿÿªííËËþÿÿýÿþÿÿ3ÿ3U*ÿˆˆÿªªDˆˆÿä˺["ÿ"f2ÿÿ™ªªÿUªªËcÿÔÿªw:ÿDDÜkfÿˆBìÿÜkÜÿܺ33íísÿÿˆ™Jÿÿwÿƒÿººþ{ÿþÿËÿ™™"ÿÿˆÿÿwˆˆÿÜÿ3ª3ÿÿ™™2fÿºÿDÿÿÿªÿwþþªJ™ÿÿfÿ""™‹ÿUÿÿÿÿˆÿUÿÿþÿýþ¤ÿDfÿÿÿfÿ3ÿÿUÿwwˆÿDÿwÿÿffÿÿíÿõíÿÿÿDÿ"ÿÿííˆÿÿw“ÿ"ÜÜ33ÿþþººÿ™ÿÿ33c˺º¬ÿUÿÿÜÿÿ3{þííUUÿªÿÿÜÜÿUUfÜÜÜ܃ÿwwÿþþÿÿÿËÿUUwwþþËËþ"ÿÿ"DD›ÿ3ÿÔªU™™ÿ™™ºº*UÿËË´ÿfÿ›3ÿÿºªªBˆSªÿªªíººÿÿþD™™™™ÿÌ™ºˆˆÜÿ“"ÜþÿþªSwwË3ÿíÿºÿ33íÿíÿĈ¼ÿwªff""ÜÿËÿÜÿÜÿ‹ËUUˆ"ÿÿËÿËíÿˆˆDD[ºÿ¼wÿ™ÿfºÿºwwsíþ33ºÿwÿDªÿªÿþþ""Äÿˆíí™ÿ™ÿUÿ"ÿ´f ÿÜÿººÿÿˆÿˆÿ3ÿ¹ŽÓb+IDAT8 ßû¥¥¥¥¤¤¤¤////ÈÈÈÈ}}}}ÙÙÙÙ]]]]þþþþƒƒƒƒùùùùyyyynnnnððððøøøø ¦¦¦¦ööööÓÓÓÓÜÜÜÜññññŒŒŒŒXXXXttttFFFFÊÊÊÊêêêê0000 íííí¨¨¨¨¼¼¼¼áááá8888++++————¯¯¯¯mmmm««««ÚÚÚÚ@@@@5555""""^^^^åååå{{{{˜˜˜˜ÒÒÒÒLLLL====    bbbbçççç…………ÇÇÇÇTTTTBBBB1111µµµµÛÛÛÛVVVVwwwwÁÁÁÁ\\\\JJJJ­­­­eeee[[[[½½½½hhhh¾¾¾¾ddddÆÆÆÆ9999¶¶¶¶ÑÑÑÑ....YYYY´´´´ÀÀÀÀ3333ŽŽŽŽââââÌÌÌ̹¹¹¹ëëëë®®®®ÉÉÉÉ::::QQQQ&&&&ØØØØ¢¢¢¢ÔÔÔÔ????™™™™DDDD‡‡‡‡ÄÄÄÄššššßßßßHHHH%%%%èèèèGGGGóóó󸸸¸““““ééééOOOO¡¡¡¡’’’’»»»»cccc££££‰‰‰‰kkkkMMMM))))››››AAAAÝÝÝÝ,,,, úúúú×××׺ºººiiii;;;;KKKKggggÃÃÃ秧§††††4444SSSSÍÍÍͲ²²²‘‘‘‘©©©©****ZZZZˆˆˆˆÿÿÿÿ>>>>####€€€€qqqq````xxxxŸŸŸŸ uuuujjjj””””õõõõ ÷÷÷÷ffff±±±± rrrrssssvvvvããããUUUUÐÐÐÐzzzzœœœœììììààààÏÏÏÏIIIIòòòòýýýý„„„„----llllRRRR¿¿¿¿6666ôôôô‹‹‹‹¬¬¬¬ääää····ªªªª$$$$<<<<îîîî••••7777aaaaNNNNEEEE³³³³ûûûûææææüüüüŠŠŠŠ____°°°°2222žžžžÞÞÞÞÕÕÕÕCCCCÖÖÖÖ––––WWWW‚‚‚‚~~~~||||ÎÎÎÎ!!!!ËËËËïïïïppppoooo((((ÅÅÅÅ''''PPPPþ´ï^HIEND®B`‚advancecomp-1.23/test/basn6a04.png000066400000000000000000000101441301462770100167230ustar00rootroot00000000000000‰PNG  IHDR szzô+IDATX  ßïÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿÿfÿÿfÿÿfÿÿfÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿÝÿÿÝÿÿÝÿÿÝÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿwÿÿwÿÿwÿÿwÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿDÿÿDÿÿDÿÿDÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿÿÿÿÿÿÿÿÿÿÿÿ™ÿÿ™ÿÿ™ÿÿ™ÿÿDÿÿDÿÿDÿÿDÿÿ"ÿÿ"ÿÿ"ÿÿ"ÿÿˆÿÿˆÿÿˆÿÿˆÿÿÝÿÿÝÿÿÝÿÿÝÿÿÿ»ÿÿ»ÿÿ»ÿÿ»ÿ·Wd–ñIEND®B`‚advancecomp-1.23/test/basn6a08.png000066400000000000000000000101441301462770100167270ustar00rootroot00000000000000‰PNG  IHDR szzô+IDATX  ßïÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿ?ÿ?ÿ?ÿ?ÿ? ÿ?)ÿ?1ÿ?9ÿ?Aÿ?Jÿ?Rÿ?Zÿ?bÿ?jÿ?sÿ?{ÿ?ƒÿ?‹ÿ?”ÿ?œÿ?¤ÿ?¬ÿ?´ÿ?½ÿ?Åÿ?Íÿ?Õÿ?Þÿ?æÿ?îÿ?öÿ?ÿÿ_ÿ_ÿ_ÿ_ÿ_ ÿ_)ÿ_1ÿ_9ÿ_Aÿ_Jÿ_Rÿ_Zÿ_bÿ_jÿ_sÿ_{ÿ_ƒÿ_‹ÿ_”ÿ_œÿ_¤ÿ_¬ÿ_´ÿ_½ÿ_Åÿ_Íÿ_Õÿ_Þÿ_æÿ_îÿ_öÿ_ÿÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿŸÿŸÿŸÿŸÿŸ ÿŸ)ÿŸ1ÿŸ9ÿŸAÿŸJÿŸRÿŸZÿŸbÿŸjÿŸsÿŸ{ÿŸƒÿŸ‹ÿŸ”ÿŸœÿŸ¤ÿŸ¬ÿŸ´ÿŸ½ÿŸÅÿŸÍÿŸÕÿŸÞÿŸæÿŸîÿŸöÿŸÿÿ¿ÿ¿ÿ¿ÿ¿ÿ¿ ÿ¿)ÿ¿1ÿ¿9ÿ¿Aÿ¿Jÿ¿Rÿ¿Zÿ¿bÿ¿jÿ¿sÿ¿{ÿ¿ƒÿ¿‹ÿ¿”ÿ¿œÿ¿¤ÿ¿¬ÿ¿´ÿ¿½ÿ¿Åÿ¿Íÿ¿Õÿ¿Þÿ¿æÿ¿îÿ¿öÿ¿ÿÿßÿßÿßÿßÿß ÿß)ÿß1ÿß9ÿßAÿßJÿßRÿßZÿßbÿßjÿßsÿß{ÿ߃ÿß‹ÿß”ÿßœÿߤÿ߬ÿß´ÿß½ÿßÅÿßÍÿßÕÿßÞÿßæÿßîÿßöÿßÿÿÿÿÿÿÿÿÿÿÿ ÿÿ)ÿÿ1ÿÿ9ÿÿAÿÿJÿÿRÿÿZÿÿbÿÿjÿÿsÿÿ{ÿÿƒÿÿ‹ÿÿ”ÿÿœÿÿ¤ÿÿ¬ÿÿ´ÿÿ½ÿÿÅÿÿÍÿÿÕÿÿÞÿÿæÿÿîÿÿöÿÿÿàÿàÿàÿàÿàÿ àÿ)àÿ1àÿ9àÿAàÿJàÿRàÿZàÿbàÿjàÿsàÿ{àÿƒàÿ‹àÿ”àÿœàÿ¤àÿ¬àÿ´àÿ½àÿÅàÿÍàÿÕàÿÞàÿæàÿîàÿöàÿÿÀÿÀÿÀÿÀÿÀÿ Àÿ)Àÿ1Àÿ9ÀÿAÀÿJÀÿRÀÿZÀÿbÀÿjÀÿsÀÿ{ÀÿƒÀÿ‹Àÿ”ÀÿœÀÿ¤Àÿ¬Àÿ´Àÿ½ÀÿÅÀÿÍÀÿÕÀÿÞÀÿæÀÿîÀÿöÀÿÿ ÿ ÿ ÿ ÿ ÿ  ÿ) ÿ1 ÿ9 ÿA ÿJ ÿR ÿZ ÿb ÿj ÿs ÿ{ ÿƒ ÿ‹ ÿ” ÿœ ÿ¤ ÿ¬ ÿ´ ÿ½ ÿÅ ÿÍ ÿÕ ÿÞ ÿæ ÿî ÿö ÿÿ€ÿ€ÿ€ÿ€ÿ€ÿ €ÿ)€ÿ1€ÿ9€ÿA€ÿJ€ÿR€ÿZ€ÿb€ÿj€ÿs€ÿ{€ÿƒ€ÿ‹€ÿ”€ÿœ€ÿ¤€ÿ¬€ÿ´€ÿ½€ÿÅ€ÿÍ€ÿÕ€ÿÞ€ÿæ€ÿî€ÿö€ÿÿ`ÿ`ÿ`ÿ`ÿ`ÿ `ÿ)`ÿ1`ÿ9`ÿA`ÿJ`ÿR`ÿZ`ÿb`ÿj`ÿs`ÿ{`ÿƒ`ÿ‹`ÿ”`ÿœ`ÿ¤`ÿ¬`ÿ´`ÿ½`ÿÅ`ÿÍ`ÿÕ`ÿÞ`ÿæ`ÿî`ÿö`ÿÿ@ÿ@ÿ@ÿ@ÿ@ÿ @ÿ)@ÿ1@ÿ9@ÿA@ÿJ@ÿR@ÿZ@ÿb@ÿj@ÿs@ÿ{@ÿƒ@ÿ‹@ÿ”@ÿœ@ÿ¤@ÿ¬@ÿ´@ÿ½@ÿÅ@ÿÍ@ÿÕ@ÿÞ@ÿæ@ÿî@ÿö@ÿÿ ÿ ÿ ÿ ÿ ÿ ÿ) ÿ1 ÿ9 ÿA ÿJ ÿR ÿZ ÿb ÿj ÿs ÿ{ ÿƒ ÿ‹ ÿ” ÿœ ÿ¤ ÿ¬ ÿ´ ÿ½ ÿÅ ÿÍ ÿÕ ÿÞ ÿæ ÿî ÿö ÿÿÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿ?ÿ?ÿ?ÿ?ÿ? ÿ?)ÿ?1ÿ?9ÿ?Aÿ?Jÿ?Rÿ?Zÿ?bÿ?jÿ?sÿ?{ÿ?ƒÿ?‹ÿ?”ÿ?œÿ?¤ÿ?¬ÿ?´ÿ?½ÿ?Åÿ?Íÿ?Õÿ?Þÿ?æÿ?îÿ?öÿ?ÿÿ_ÿ_ÿ_ÿ_ÿ_ ÿ_)ÿ_1ÿ_9ÿ_Aÿ_Jÿ_Rÿ_Zÿ_bÿ_jÿ_sÿ_{ÿ_ƒÿ_‹ÿ_”ÿ_œÿ_¤ÿ_¬ÿ_´ÿ_½ÿ_Åÿ_Íÿ_Õÿ_Þÿ_æÿ_îÿ_öÿ_ÿÿÿÿÿÿ ÿ)ÿ1ÿ9ÿAÿJÿRÿZÿbÿjÿsÿ{ÿƒÿ‹ÿ”ÿœÿ¤ÿ¬ÿ´ÿ½ÿÅÿÍÿÕÿÞÿæÿîÿöÿÿÿŸÿŸÿŸÿŸÿŸ ÿŸ)ÿŸ1ÿŸ9ÿŸAÿŸJÿŸRÿŸZÿŸbÿŸjÿŸsÿŸ{ÿŸƒÿŸ‹ÿŸ”ÿŸœÿŸ¤ÿŸ¬ÿŸ´ÿŸ½ÿŸÅÿŸÍÿŸÕÿŸÞÿŸæÿŸîÿŸöÿŸÿÿ¿ÿ¿ÿ¿ÿ¿ÿ¿ ÿ¿)ÿ¿1ÿ¿9ÿ¿Aÿ¿Jÿ¿Rÿ¿Zÿ¿bÿ¿jÿ¿sÿ¿{ÿ¿ƒÿ¿‹ÿ¿”ÿ¿œÿ¿¤ÿ¿¬ÿ¿´ÿ¿½ÿ¿Åÿ¿Íÿ¿Õÿ¿Þÿ¿æÿ¿îÿ¿öÿ¿ÿÿßÿßÿßÿßÿß ÿß)ÿß1ÿß9ÿßAÿßJÿßRÿßZÿßbÿßjÿßsÿß{ÿ߃ÿß‹ÿß”ÿßœÿߤÿ߬ÿß´ÿß½ÿßÅÿßÍÿßÕÿßÞÿßæÿßîÿßöÿßÿÿÿÿÿÿÿÿÿÿÿ ÿÿ)ÿÿ1ÿÿ9ÿÿAÿÿJÿÿRÿÿZÿÿbÿÿjÿÿsÿÿ{ÿÿƒÿÿ‹ÿÿ”ÿÿœÿÿ¤ÿÿ¬ÿÿ´ÿÿ½ÿÿÅÿÿÍÿÿÕÿÿÞÿÿæÿÿîÿÿöÿÿÿàÿàÿàÿàÿàÿ àÿ)àÿ1àÿ9àÿAàÿJàÿRàÿZàÿbàÿjàÿsàÿ{àÿƒàÿ‹àÿ”àÿœàÿ¤àÿ¬àÿ´àÿ½àÿÅàÿÍàÿÕàÿÞàÿæàÿîàÿöàÿÿÀÿÀÿÀÿÀÿÀÿ Àÿ)Àÿ1Àÿ9ÀÿAÀÿJÀÿRÀÿZÀÿbÀÿjÀÿsÀÿ{ÀÿƒÀÿ‹Àÿ”ÀÿœÀÿ¤Àÿ¬Àÿ´Àÿ½ÀÿÅÀÿÍÀÿÕÀÿÞÀÿæÀÿîÀÿöÀÿÿ ÿ ÿ ÿ ÿ ÿ  ÿ) ÿ1 ÿ9 ÿA ÿJ ÿR ÿZ ÿb ÿj ÿs ÿ{ ÿƒ ÿ‹ ÿ” ÿœ ÿ¤ ÿ¬ ÿ´ ÿ½ ÿÅ ÿÍ ÿÕ ÿÞ ÿæ ÿî ÿö ÿÿ€ÿ€ÿ€ÿ€ÿ€ÿ €ÿ)€ÿ1€ÿ9€ÿA€ÿJ€ÿR€ÿZ€ÿb€ÿj€ÿs€ÿ{€ÿƒ€ÿ‹€ÿ”€ÿœ€ÿ¤€ÿ¬€ÿ´€ÿ½€ÿÅ€ÿÍ€ÿÕ€ÿÞ€ÿæ€ÿî€ÿö€ÿÿ`ÿ`ÿ`ÿ`ÿ`ÿ `ÿ)`ÿ1`ÿ9`ÿA`ÿJ`ÿR`ÿZ`ÿb`ÿj`ÿs`ÿ{`ÿƒ`ÿ‹`ÿ”`ÿœ`ÿ¤`ÿ¬`ÿ´`ÿ½`ÿÅ`ÿÍ`ÿÕ`ÿÞ`ÿæ`ÿî`ÿö`ÿÿ@ÿ@ÿ@ÿ@ÿ@ÿ @ÿ)@ÿ1@ÿ9@ÿA@ÿJ@ÿR@ÿZ@ÿb@ÿj@ÿs@ÿ{@ÿƒ@ÿ‹@ÿ”@ÿœ@ÿ¤@ÿ¬@ÿ´@ÿ½@ÿÅ@ÿÍ@ÿÕ@ÿÞ@ÿæ@ÿî@ÿö@ÿÿ ÿ ÿ ÿ ÿ ÿ ÿ) ÿ1 ÿ9 ÿA ÿJ ÿR ÿZ ÿb ÿj ÿs ÿ{ ÿƒ ÿ‹ ÿ” ÿœ ÿ¤ ÿ¬ ÿ´ ÿ½ ÿÅ ÿÍ ÿÕ ÿÞ ÿæ ÿî ÿö ÿÿˆÇÀ{.IEND®B`‚advancecomp-1.23/test/italy.png000066400000000000000000020562311301462770100165400ustar00rootroot00000000000000‰PNG  IHDRçXXy.ibKGDÿÿÿ ½§“ IDATxœ¬¼ylÇuÞùËÌ»×^]½¿}Çú° A€7KIY)ÑÚF–hKÖ6¦'ó×8d;&ãðx<£]²dKÜ%Š)ˆI öýa}k¿×{íu×Ìœ?nuãhŠáŒèê®êº7óævÎù¾ï¤Øwh½íÝoÇ`©º¹Ö$¦@"Œ5h+NµP2Ì4 £¬@cvŠR’Š!ÀZŒ1!@€@`¬E B`ÁZ‹¢üÎeÅZûڛˮÓ¿-,)ÁZ¬µh#±h\GÂôrû†6¾ñ=Ó¶cB`­EJÉ«k6_9Í•W¤×2Æ=±!ÖÖ²{ á Ia Zkäô™ ]g9Ý­k«ÛGg®I«]À À”RDAHw{À³Ï¼ÂÌl“AoD§D•€+¯9¸ÛÖZ<×ÃsÃ!=ò"sË‹\yt c-ÖX„,Çq’&\XÙdmeƒ[îx'ß¹ï\uÝuÌtæv»`k8Ašm¥qìkcXóC†iLäú)0ÆîŽÕeÓ~5Æ¢”,Ç”×¾g¬)ÿ²m,HvÇRŠé|»lÌÅtþ ÞS~j­Åb‘ÊEbÖ"¤B"Ȳ¤l‡Ulå†ÙС(R¬ß÷ÉóéxxŽ McòL£A–4[-ò¼À˜œ,+¨T*¤i«g/±±ÞãŠyêé—˜í48|p‰ÓçVY[ërà WðØcÏsðà‡ì%I'Da…_:ÍúF—8Îv»àæ›®B[ƒç¹xJb­fY:&™d8N¹vŒm ZçDA€6')•ZƒZ­Âd4$Ïc\é0ž¤8ŽDº.Q¥¶ ÑFc%#×a<Žq}%Áó}„P£9×5ìi |×#‰'H!ˆ“˜0ª¢¤@)‡qqš‡¿ö·ÿøm,^Øñ=ßhü€ÅbI¬O ÄÎB™~Žm4XÃrTee4F¹å¾¿Sý?´—eÖZ¬6ì«dÖ`´%“‚QœRL÷©d¹ùº{ @ Ú"‘„R1 ðA žÛ¬qãü˜|÷"ñºë-—2„-äåÐå¶ûœ¢ ›•Kw´…:3´›m¤”¯0ÿ;EK˽§`¹ßø³ÿuâú+ûº·Ü½‰°a§ã. ¬(¹£ˆ„Å‹AàPPó<®OW Ë™g^ிþ*­vƒ§Ÿzž§ž£'!•ÄQÎ4‚~-ê•R ¥ú; ³¬±»ÆØq\ m,Šb–ÞúZìq¼pÊhú²©²SçN$¶[×e^˜ ôÔŒ1<÷ôi>ùgwÓï™Y˜ãÔÓ¯P«GÜøÖ+H³œ§y‘Ïö~®:y‚ÞÖ€{ï~ ¤á+÷||”ó+çyö¹¸ëÎûxâÑÓ 1o»í~ôçþ7¼ý*®ºfëÅ,£KgHã<&->ýç÷ð ¿ò#l¬õ&Ôª!7ÞrŽ,£Q­5Zk Äqšç Ò)ˆMÆ8æ)“xÌ(™ <·t€€F¥Âr5a{û,’ ažr×þšï|ë~ÚÍ6³‹K)xf¥KÇ!„ÂqÒÀbhVj˜éd5¶\ Xð\ŸoÜ÷mþà>Á»ßs_¹û~>ó™/Ñn7yêÉS<òØ9°€p\¤ã „1„^ˆ1Gj¶77Q^ˆã(¬5H%¦h™Y EQ𵳂µ‰Ï-SFqŸ$3Žé÷z¸ŒÇ)ÖZ’ÉI©K§tV4àã0xj=D3z]Œ1tû#7`naŽN¤Ðh½BI²´(½ã(àâ¹³é„ãјGŽ?ù¯Ÿçºë®äËw“Ïüå]´Z yôI^|ñ,7Ýtœ‡>…综㎷EQèã(IT££çyéÕKÜûÇøê½³ººÍ‰ã{ùŸ~î}\sÕaÚO«Ó&Ï2^zéºÄɎЙo1åÌî]à[÷?Ê7ï˜a¿àôË—èuGÔj5~ùc?Åí7ßÈp´ÉH×è4¡í>ùç_áé§^©48•íaý™Ç(–nä‡nÃ:ïÿ‰Ûð(>é¨]G¥Ðš¢È1¦Œø¥«PRâLŸ_8 ÇB;ª£µÙõ•R„®“žåt±ÈO¾ÿ}¬®­òÕ/}‘ çβ÷è!.í#_@Èc¦ÎШ„îÿÖc|î3÷ây‡í#Ïsæf8ö"·½ý&¾ú•oò±ùÏùÂ÷pâÄ!„€å=KHå”ã¡ë1Ž©D«4šs8Ê2öD•Ú‰Ð¸®;E<,¹Àr4f64XS°µ¹’N¹ÀCÇQŒ&#ffæè zx®b2Iñ¢ 4öyVBœIAKlrh6dm£Á£Zmây>33-*~‹—WVè4"ò4k¨TªÔju²4ÅB\G1xú¹ó¬¯yàÛOòÊé-66Güô?y/=ô Ͻp‘Isë­·ðÐCOà¹.×]±íKç GT¢ñ$&™Œ&ÜqÇMœ~õ,ûöÍsÇ­×ðÞw]OøŒFzý1­™WßO:îsîü&Q%àȱã€Kª •zÇ‘$Ã>úçKžü‹Ÿ½ƒg»’­‹`2Q©µqüˆ$‹ÙÞîS©VѺ`2QDUŸ­ím’´ MSº½ Ô›ÈÑç^9GP¯ $T«Ø £S£!‡à…g_àö·äK_¾j5`n~žÅÅ’$¦R¯QY¤^¯OáqÉ`¬éÌ.2iæ[MzyN#,Q¢Þ¨Àè°Åã݈\:|àŠ¹tð|—­í›[„õ3­y2b8IècZó h!9|ôV)¬´ÌÌ.°µ¾J½Õf0Ôj3Ôë>Ež£¦ƒ’,7¤yŽã9Ì´›( £AÁúú&“´ ü’z |:­&¯ž9Ï‹|ò“_¤V«räèAÂÐGJÉüü Zkœé|ÆZ2]0Ic2ãJYB,JX¶Ò’n@@Ì]æÅÇ_fvi†ÖBûõÆ‚× ÌVV”ðÒ›>€#±Õ4Ü Y‘b”à5škay‹ç.rŵ'8ûÊ9VÎ^äÄ5Ç©ÔªxŽâ–cGJ1)ò)5PîïFkæ£ zÇJIlÊ:¥˜qí%yœ"gw_h)ŸtŠÔîÆLÑãÔjÁl”#q@¼>š;¡ÜŽOr9›ºCÇî"„¯9;]”¦)Aàº>É$áÄ•Çi´l®o²rn…_üõ_à«ó5;„ã:,ï[þž£àÁ>†³Ûñ;•Ú !±*ÄšÅZŒµr·á¹±(kð=Ÿ¡Né!ÖraJòO?úaþÛù+~ñŸýÔn‡j­q„$/ SÃ<劧½€ÖzêH²,Áó\Œ¶Hë€SÖ-ɉm ‘¥±ÚpMÛ’ëÒ“Y_ï²µÖ㊫òÝŸ¥»=d}u›å}st:M®ºî ®ëRº¬ÛQä…FÍZƒ3++»Ô™ŸÁͯ}ìC¼üÂîûÚã:ºÌüB›v»ÎüÞY°“|àÇÞJžeÔû­_æ¯>ó7|è#ï§È5ïyÏÍ´ë- ’L ³´ËòB‹÷Û¿ÊÚæ6F„øܱôaÂJ‹æìfćßšéx¬m®#§ h„(ÇAª’§j¥†. „¬on€ï°Ò]ÃÏqÑ¢MɇK¡¸"8Å… ÅÏô—xö¦›¹óSŸä?ÿ›Ëûþñsó;ßÉ`’²½ñžx*Ÿ.ÿÄ]<ûÔ«|ö³_åš«Ž’™Œj%B …Õ% í(AžM¸âØ~ÒƒûÉ A $`ѹf4Ω×}¶7.xO=õ}ç× &üú/Z£]B´ÇuPByš#aÁd4d2ÑhTAáây.Ýîµz‹µÕ ìYÞǨ¿ÍxØ¥Ú®¡„ƒ’á°O’jŠ ƒ]þe‰ã8)IŒD ‡Ó¯>ɨzŒS§N±¼8‹+ ú 'C¤¢ürƒqƒ*ÕzVWÏqìøL[8A… ‘ù#$ÏMfñãsÌ,ï%R[[ÌÌ.džõµmü ¢^(„$U.kÛ#ίlpewıc‡˜_\Â*ÁÌL›ñ8# acuƒ¢½Ÿg¶%£8e=ïR©øj5ºŒµ Z«Ñ a¼ù"ûÇ)Gduý•Æñ¸GÅwð–iÖ*l®¯2Œ-Qà6:äEŽïúlm¬Ñh´PR¡” 1·7¨Rk8t:m&£¶0¤I†%¥V›¡ÛíRmV¨7+xŽO<ìÑ ýAŒPaÅÇuÒTR†4áH‡v³Ezüê¯ü<ø'Ÿà×ãHÓéHìt}b-Öh4–IVFÍ;ˆ«)ÍPra2fŸ°ra¿ùø×hεv#»£aß`t¾ßb1€"+ÀuT0]®ý˜nüB S"½,é ­.—”h R—ÿ·Ö2 ø•ßúçÜùñ;ù±ŸÿQ$‚\iƒd‰ŠJá›”ýõZç  .‚­8Á*ùš£aÁ°CO–/rJA %Ý<+0¢¤PG0Ê|ötª¼­¡Xp‹ôïu^vuL¼Ö¯;†{·ŸwÇç2GAX†£!õJƒzµF–f|ëÞøèoþ"g^9³{ÿWÿ¾ÆC;’Ñ8)#çÞvý®×àJpŒäô¨ÆŒ;ÁNE¯½RFšž¤( fjUò"÷Þó7ßz5õ‰{Ù\ïpþ̯¾¼‚RŠ›®½ŠÈ ¨†QÄp8¤ÛòŸÿ¯OñäÃ¥°êÖw]ÇÁC‹˜©'vøÐ~Ž\¹Ä¡#Ë,,u8vø ƒá€ÅÙy•:ŽRø~À…s9uêîxÏÍüð{oåÊ#ð<—Q/38®ä÷þèóŒÇ ×_w”›n8A¡sÎœ]ã?þ§óÒËçY½´ŽŸ`S²Å… k~•Ï|î^²´`c³Çù <ýl¹øþ—ßøvăß~˜ýàm|鮯E'¯=Îí·]ÍÒÒqµÍ­Gšø¾ÆóõjÈÖÖ¾çFUÂ(b°ÝÇ <öíY¦ßÛ¤ÝjS«†4UŒ²Ô[3dqÌÅ‹+<òØË?¶‡CKuÎ_Xgiß gOAygÇ!ß¼û^zƒ ?öcïàè‰c¨Þ*wžõx˲KTð<—|RF…žãà.J‚Õºý1ós‹Ä“.I’°¾ÞE7R5]b\ë«èÂ2™_˜§Ñ¨S­Vxæ™øÜçïaqq‘þÒÏ°µµÉ 7_Kä;x•®çp6‰[Á‹}8º¿Í’¯1Û¯²¯K hú>£ñýÍud>fy~†³g^%I4ž€x’’‡……9lóÜSÏpàðò<'+Rê‘ËxÐÇš7ˆ¨VëT*>Ý^Ÿv{–íí>Ívf½AµP¤1“ñ„LçZ U€Q‚Z³Nä¸Ê#OcL‘#¤C·7 ÉR*•*KKûHâa"•à‘Gžçs_ø îÁóî¾çnºù$KKsåº6%¦ÐH)Øœ §b01¥žv8XCFI!6¥Cæ¸õß¾ÀW䎾ž(ËÉ¡ ³6 š^·‹6–Ùz ×uÈÒ„<3Q€ïyô#R›’¤1Žë’Å™dšóÛë(“3–md²Æ¡Î^.ÆÛø®O-¬¢,¬l¯ø.(I <†ñˆ}Ë{8·z9]$‹ Klnn2ÛšAÇŽë2É3ºÉ“£Ù·¼1…„¥«,ÃÉ„Z¥†²`tQ‚Íí>BäL„OP¹’¥N SÀÙW_áwþÃÿ¹;6ǯ¾Ïuxæ‰'°Öò[ÿÛ/°Ô™!Ó†ßý½Ïpöì%ÞzóÕÇþ}‹\yõaž€ô0"žï 3]Še¹­{®Ë¹µ‹X ŽRk^KP( Ö¹4î“YÍ©ûŸçùG_âCÿâÕèuÑÛëÅ?¬8¶ w] ¹a9ASr¨—qY„Îeb.ˆõ­$Q%Ä|(¬‘Ë‚A¨ ç#¬ïMõL + ³A€_2κÀÑ’ 4¥XÇÏE ¹kvxßžù8%*bÈR˸¨³¿cÐ6ðÜzÎ|´‰p ”Vßwßì<çûxW£%Æ–\w½Òø÷ýßUŒpøÿ§œóÛoØUþ]ˆ}:žÁc¤Ø‘Z¤,™5!,sAˆ¥€Æ£ÀQådFÒÜr)OH,ìCªŽ‡µ¥J[J‰Ñzªj3HiɵÀ–Aê²P•ìŸÔÜœvT”mÈs2£yqË¥ hù‰N5ÿúÿ}ŽÛˇ>ü^ýaWå½v¡Ë¹³«dYÁÜ\“­­¾ïRQ:³L† ?õ‘÷rû;NrâŠ#8²„»z}åÏb IDATËyâIÂÆö:J)|ßc’ÄÄqÌ$OH‹„fµAQ„Q@Zd´›M„…N» ¹á• §Iœ&c—¹zJ%¨²9°oq ×q±rÁ4u@XA5ˆp”C3¨Q©U‰ÇzÃ>K³óè¼ÀŠRí¹ŽTHk™ŸéÀT Ÿe¥ñÆ|Ç+O½.ÊuQRQ  cÑ:EæëtY á9´Zmžxôa–—™›[(£±W^any/K'oæ=o=Â$Nèv{\síQ~è=·0Ó©ñ݇Ÿç¾ûåÈ9æ;LFCüÀGH‡ñ0e0ÒnÍa¬&ŠªäYÂp0FÙ³k¬®uÙ³ÜáÕ3« G—üÈÝÂÉ«÷rìºëŽÆ\¼°Ê“ϼÊs/¬ðõžãåÓë\¸¸Í¾ù*­zM¦ ?UÚ¸O%p9ûâ‹XåSo¶‘Ž¤Úh³1òY™xÔƒl±‚(&¾ËpSoÕxËÇñ¥&ð«ÄY†#+HãœÑxˆë*Æã˜=Ë{H²µZ•­Í-6.uñªm.‰‚cs.7`<ž œ€°Ö@‡úLéù¸aÄ$‰iµèþÏ>÷ ÷·Hâ„$\ZÍqZ”y¤JP­´©T"\?àŸ.‘‹_û•ãÆëŽpìØ>´’l\\! Š¸Kýø[ùñt’oû)&qÊÉkò®w\Í‘ƒsx¾ƒŠZ­No{m,ã4gqi‰ÁúnT)Ó´”b¦³Ä7^êrÍBAXôð]ßýƒ;ùòÝrÿ·žá«_Œ{ï{m,×]{ˆîÖ6AXAõ» ú=ê3mf;mZíkSlç.¬SH8ztžg7 n\n‚õ8ÿêY‚(¢Ùªã;‚j%¤ÞhLÅ|’ PJ 5Ô¢Ý^¤äðÑcÔjJ éH¤N±Vàú>'/qìÀ Oö¹u¤æz¥øÊäÔª°0è˜i‘%9£ÍU¶{ÛezSµB¥Zcn~Çs1†‰fccƒ(¬2ènѳi:’‡çù\8·ÂVo€Tð£ Ú<·OÆIL6q!%ë«D•j™Kí{8T+!Aèa­Å÷}*¡OX©Ðn·KÁW2f8˜UENFø~„ãäEF’gX!Ц Í4Ž µ™Fü%5æ¹^™#=Åu¡‘JQèœ\H©vÓÁ"ee<@KÅÝÿõò4çC¿öA”ë|ß²!r¶ò=ËÑÙœÐÑ(i¨‡Í  ò ¬Q%¥ñƈù²òFÁ™”¥öLA%XK û¢€T•é¤¦0à8 µÝIºØyAZÚ§HmHµa+OÈÅÂÙ¯C“ßÈ_&âºü·#-ÃlÍÇw„’$Ú• Ô  ò,]JÖßW.W‰ï¤]í¼WJbŒ%týiÚç›ïWLSI¿Ÿâz>LUçÏ~çÑÒ8¿åÖ"gsO2fkV(¤('J!-KQˆ/%Ø©haÊ;ÒåRyQ ­Kž ±Œ”¹ÃDXéÒq3%™©ÏOzñB²5ШÖÀZîùÛïòÊËç™™iòþ÷ߎÅàúiÓiÏP¯Öè4›\uÕ!ŽÙÇp8áç~ö}ÔU*Q@£Qãÿøí i–V#Ъ֩R:xž‹«êÕ:/(Jp½)STG”B¢þ`DRLÂ'45OñbŽ-¶Å„HaYjÍÑŸ ñ\—…ù†ƒ>¨’0Úâ8…°ôú=ÕÚh¢ Äè2*6Z“$)Àôp,Ó^zæ¾çã*U®!pR’eñ—8ͦžº ªTÂ']ÅËÖ©5#òê w\Sexþ4aÍPó„€Ù™6õJ•n¿‡ë{‡ïº!xæ™úƒ1í™:í*^ mñý)J(tÜ_§ÛÝ©@kÎœ[cks›Ã‡–èw·ð¤¥Þ^Ädc2±¥ê\`†·ß|Œ·Þ|œý{gùóO}gž?O­Ñষ^G¿ÛŪˆj½Mg®ƒà¸zN§ME¸®Ë±ŽÏ…W_D É_|ú^.¬lrøÐ"‡,1ß©òÖ›®âæ·œÀ Z3 ÆqÂv*èÔ+D•×óp•ä⥠öí³ÚiͶÑh&:d~&ÀQ0ŸAˆ/ ò4¡È2¶·»h œ°tPó”¸ßGyÕZ•0ªÑh4ÙÞ¸Äxœ ¥ † g7Hâ1zD£=_ Óšç/nòä3§yî™Ól®m±g±ÅÆÖˆßr‚(òXš_æémÉÁY‡á`“Ž"ßa~~†0ŠèÌÎ0÷1FOÆã a XßRoÌ0ÈsA¥â(€2½faï2y¦ÙÚÚF¹Uöì_d<¿­¹e6%É2¬QÄãÍjÀævŸÐ/óÝuž²¾¾NX«cÍp8"¨¸qJ{O&IB«Qcïƒllo„!Õj ¢Ýi0Ä„• ËKó Ž£¨×Úà:‚8N% ò\Sk4ˆÓá@¡ ¢J„´P‹*X­ÑEÉs,ŠÍõ5”2èrmiµkøA‹aÔßÆñ<Ç# B”’(W”‡XHÁx2Á<|¯D¬ÌÎÓ6úA@–¦aË>šžÑÛ ¥äOÿNžøæ³¼÷]'Y\œåæwžÄ …}3úÆb)-R¶’ˆ¶7¦Ú)\=5m¶üÁ–9ÕßË0_^vŒsV,UÂ2€*h §¤±–Iœ„üÔ`K;=;cŠÛ+™«HrÍÄ‘¥s2MkÚQ9í€ö¯Ï¸Ù% _Ñ ÊJ†¹¡Yiâ*És+öµK!›œ¦H)á\×%Í”[rýåÁ/ÿ>Ø“§AŸ1†È¦mxóµÉ$ÁõÜïyC­ /õ–k©r\$}k9_ÿö·ðºÏþvN§jB5XGRU’å¨Jš¶ã˜ºWD¢ ý,§WäXåàAŽ¥?Óª×X #Ò…8Ã(p¦Ê;G)òé!½BRžÜŒX¨Y‡Åö"‡AèxyVP Cæšêa«]VÒ :u¤€• k|îs¥‚ñöÛoàÕWÎóžæñGOñ¶›N–hœ  MèHi¹å–“T+!q’’¡¹æÚãT‚’3n4š(+ȲœV­Ž±¥βÇQè¼<égWÔfÊtÏqÙØîRhÍÚæ&…°Œ’!O_ʸ8p‰ KUŽ(ò©$Yf˜ow臌F#²,ciq‰É8.óîìr$Íj ØÉ÷µ»')UòW‘fé®Ç©agcqÜò`1åo”tp…Cœ$¥XÌXYÂè¾ò±V°¹Í[®9.¯¼r‰:À¿üÍŸâª+ö²¸8KèB¸.\<{ ælL,3•€Áö:Öhƃ>Úz¤yÆ°—Rm5ylÓçP fZ-Â4C8…)˜i· ÈHÒœ­íV(Ò,¦ÙœÁu²tÂúÊE\ße<…®ë§)^è¡„`uu‹Ñ8Åi>¡Û17ßai¡IÅ Xß²¾Ù#N n{ûüä‡ßC½•ç1^Ñ =æ–—‰*É$c8QhCŬovÉÒŒZ½N³Ý"™Œ1ŽD˜©ÊȯßáJÁ8É‘žGo{ÈüCHå²´g‘ÇΨ…Ž5rr'`Òí"´Z¶Ö/¡ dɘñ(¦3;‡.R¤T˜Ü ET>RY\×c}mƒŠ¯ˆGC¶67©ÖjHéRK«]emu“z£JœfŒ{[ôû#‚¨†zX@©€…ùYÆ£¶LHÄq|”[¢V•J…Èó§öt»]’IŠ# ãÉ„™v ­sŒ…z£É`0@*—¬H‘”à¹.£Ñ¨v9bzÈ’!Ë3&yJÑëõJ¡­A Éö°O„èBg B”4_†üÙïßÉ…s¬¯u¹þæã:°L­øMå0˜j/¾—¶Ò µáL?d±f0VsyÒêš}yêÖlàQºú%*ª… Žr(²?ðåú2ôkéIe–Å Q’$ßpðÇN;§Ru»Ï}™=Ü·­°¼¸±V DË€j p¤³ ; Q¶W*É8ž”u™ïÝŸLëÝiû´-DAåuÜôå%MS<ßûž=šJ—åp‚f‡ã–|÷[£®ºþšß>ôÖëØ[¹|ÀKïNCÝuYO’"g¶V¡—æô&}[€Sµ䶠*$-סæyÄq\v~TEEá¹Q8²à¾s; …Çb5ñ5 ã>ÛãBƒ¶†J‘ç%ì3žLØO¨u\''- έ¬ñÌ“/ðÊ+ç9wn•µµ-¶·û(/âС9Œð™§2ö‡ a% MS´1lOú[Û]ÜÿŸ´7‹±e;ïû~k­š«ö¼{:ógN÷êr´HS‘œÈr E1â 0ì— Oy |ÈC‡Ƀò"¶d%€ ˜Ž¨(”DÒä%EÑÇ;Ÿ±§=ïš«ÖZy¨Ý}Î彤(g5ú4лvUí®õMÿAuAÜw}„µÄQÄf³aœŒ©šš^!éæF¾ë# ƒþ#¨Ë–û³©Î¨)©ZÍ·îD@º.u–!Ú‚³ùš~/d½X!u7ÞJó’ƒÃ=lSuò£yFQTăE¶A·-£½Vósª¢¢7™bl7Ú?¸Šr|ê¶Å IùdiŽôŽ‡]—)ŽHˆ¦5äEC^kªºÂó,Û¼ævr4€À H× ŽOçá0žîqrz‚n¬1lÖ9eÕÍÔèO«†ÃÛÍštuNÒR75žïÐ6-m£QžËƒÙ)ŽÛ’„#¨Ú†Ö´lò R VÛ5y^`•åp¼GèDnÀÿåWyü±«ü§ÿàW¹þØÒu°V#•dÛÔÔæ!­õQ°Ò£ÁV K‹Ä A¨æŽ%cßóÚŸgY R Zað-L‚*Ú¶ÝI?dÜc©›_*šÚú=FŽGßó¥e[4H¥.@.®é"p_̶%’VhÇ¡6ãš÷ ®/¯Å‚¦aVùÜùÜ]ÂQß"­ø‰y°¸üýÈ1Í.°JûŽóO[—í}ѵö}ß¿løÿäjšÏ{p–J¢­âÁ¶fh„vÇì®ëµ¯|õ¡W^øÂà‰Oq´ï;€ÆPØf®¤M‡°n•ÀÛqòº`7ã¸Ûd69~à_rÐL“wÜ>[q^Hîe±lyr_ ­ÀêŠá`@ÓÔô“>a2ìq}O*Œµ¸Ž‹T]4 |Ϋ–ÓùŠd8¢Âð÷ÿÃ_æó¿ô /~êU>òÉ_à¹=Í«/=Î Ï?Ç&]y0í+†^Ë,ïT³´éäJ=×A)ÙÍ]ã¨ËÒ”ƒ²‚(Šh´Á‘’ÅjEYׄA@'IêP7][y™o8®Áw%ïnzáÉ+_[j«º i I˜W%Æ”rp”¥ˆ½k-ƒá*¯p}µÓ:ˆ‚4ËPžKšeôâÞå–R Ýj|ÏÃW]5ï:.Z´Ñ´¦{(×!ôÃ5o B Çé´~¥Â÷šªA)Áq}–ó%ëmJ^gÈÀ¡8|‰O¾°×é¬kMäG邶…¸—àJ…°šºØ²Z­(‹Œù¼àÛßyÁ 晧®‚0è¶;~è¶f»\±X­8¸r²ªùÓ¯~á0áÉ'ŽRñ­tÀÕÃ!Õü{.§'§œŸœõŽ±ç±YoȲšþ´O™füù_¼É¨7 Ø6Ô:'‰þäËßâŸþΟðíó&Ï<{“¥3`{ç­Ð¼òѧ¸v8ä7þö'°Và8.›õ†ƒIÌrÓë9ܽwÌtÿ€½¡âü€k=U.½þ”éáʸ|ìZ€(ÎجÖh#¸~ãóócVë-F[Ã>~è3÷™Ï°\œu¹¥Ønp½€¦mØlÖD¡O¹Ù0Ÿ¯ ,‹î³t$¡ï2ô°¶!/Jz½Ïõ±Â!J"â$äÆÍC²,ð^ç4UNz8JðýsÅSWc’¤OöèõúDqDUT Qà±Þl0ò¢@¹’¦Ñ\»y(‰¢ÉpŒˆ§|o2× …Ù žŒJ|Çgµ\n„Q€®k¬òhÊ‚Ðw; ò¦íuš†¦n)ËŠ8ŠÀQÄIŸ:ÝÒîôɇã1Z74eÍáþÙv‰n5e•!½d€.Ž„®ï"‘()YU%E¾¡q=Þ-IÈ(ŠI듈?þQÃÐ-Ù®râÁþ ç*úý!ýÁ¦É9<º†R–8îw2‘ × â>UQã{A'¯k»¡Q«5ëlKà{•‡¾RªNw_J¬+8è»Øa KK¾üåoq~¾ä¥=†ã:XcP®0šÂXjc¸T±â¡NÅåü8Ü^»\ õeÌ°»Q×Oó2ø«–µ†+~H(:Êmk Ãp@­ëK^¶¯³iZÜÀGKÁÔ÷0ºAXÖ-®pXéæò<~…ýhëÚZƒj4C/`U×(«º"ã}¿×q¬5!û‰â,s˜†Šgt=]P÷<?ô)ë~ŽÖþe‚³û¿6߸ a?ºšúƒƒ³ E­IIßcGš{˜p¼Öµµ?ô…ÏöÙ.P°ã‰IFwsg:DÐ÷’@1P’uÓÒ—’‹ !p»ì^7 ŽçSYƒÅç´éc¬Ä*ÍAÕõ륶Möp¤$ÂN1Ùézë.‚EKÓ4„~L‘•$²æÆÞPXöz1žãáº5|ñ÷¿ÄÿýûÌóŸøLèòÝ3gFš£Ñˆ<¯™ ôü„8ŒD}\% ÄÀ жEJCäXcȶkLSSdš$Ž(›NðÞS›mÆ6ÍyP¬ñBIà{ \ɾ_aª?8²Y®˜ŒÇl‹‚q{1e[‚Ñyš²7ž èÔÒb?b“¦,×fD~LõøW·‡\­ÑUMàyhá#MC/Š)šªA`´E¨®ë &p}ÊÒ• Wº`Às=Úºé4¡±¨˜%Ï–dYIZ×:ÌѼõí`MMqkÿ<¯±ÖP9ýÁ˜,/Y.–Xk9>>Å÷<î?˜ó£×ïðüû¿ÈõkŒé:G¶I2+X¬W8Ê%ß.X­+Ë ¿þ·>Dèy”­æs/rüú8®CUähãFÓ6„¡K±ÝЉz¢ àk_ÿ³ùc5dz%iZò_ü&?zó˜';âïÿ½_áKø¯ùþ_üG5üÍϾH±nØ’æ-Fƒëthïãó’'»Ê»ï<àêáˆõl†Ö •ÒM¨´a<éñÚýšçÇç«%óÓ£$d±Ù0ŽÙ®–$I JQ—[ÑêšÕÙ}ªJÇ>ëù)EšS”5‡WÀ6/ÉÊŒ^ϧÍk¬ëS¤¦ÌXn6ø¾ÃéÙ†½é(EèJ¼ $ðºñEœ„ $ùöœñ^Ÿéác—^ÏÅ·ëÙ)ÛÍ߃¢(ˆz#ÎïÝã<-¨+Ãx2áí2Áõ‘OÓj”;àûÉ“ã€Ð¤Üì[®‡uŽ¯<îÝŸÑ묷9›õ…ál¹% èEŠ¦6hÓ °ôŸå6§¨L«©Úš<­ñ\‡þxD±]cµF K]—é“mdy‰9ÄAH–®°VcÚŠ~/¦.³®] 躣$QÌãžkɳévMS”\(¾=wxrÏ! cêlÅj³BÐRWR8äÙšºÖÄIL]µà*<¥0Š¬¤-¾ãnVÔ­%+rÖåv·i{Ø]ìTòBïÿá&íXR"´¡®*´nyëíû¬×)Ͼp«û±ÜÏ3²ÖÒZ.Fï«–Y\÷‘ˆa¹‰ý¼YHЦÅ(EP§«tí®ÃºN×L'SòmºŸ=<£¦i GJŒ6\Lêj£¹Ÿ5<1ê³Úä:°.¨óHÛû‚ÿÝXË¢4ó}g‹z4 :z£þÙ*|Ï2v[ø ièG—|TäD@U•´ÊÿŠ÷eb°V%¾¼ï¾ÖUýÞ¶¶´¸åk·[nNº±nwï½ö•o¢ñÅ/¼üÉW¸Ð0o( —}ßG ÁëJwÙQ \rc8ˆ"rÝpäG( ­µ4eƒ8(ëp´×Cof$N…”nç²ûCõ¤dÜ"¤ *+€K³ßóhÚöÒ…ÄZ‹±VZzI‚ïz(ÑeÇÂZË%¿û¦æí¯}…Ãý¿þ·>N¸<3Ï »ÌT”ÓÍÇ])¨Ë-u ÓɈÅÉÚªÅÏõ¨ª”"oȵDzÐ`‰£€(îq÷ä„uµÅ¸šI˜0Û*RtÕyt5­Æõ?¾ëú!÷gH¼¢m0¢KxÏÃhÓ‰tì|$‚žŒ#ÙúH,S¿á‡ç=ÆÁ ×ñV}ÈsšÖ! <äîÞº®C«Û]ÛØ>uÓ„3k)%M³sÛ1ˆÖ(B/R”•i¡äÇß»Ç?ù_¿ÈùñG>ýʇÉ+¢^çR„ǧ§Nq”‡–( ‡\¿:¥© n¿û€ßþ/sÿx†#%¿û{Âç>÷r7¯mjʾøGßáÉ[Sžyü€mÞ²X§ÅoþÆç999æGož"Ã>ŸùÄÓø¶%O±¶ÄéYÚÕ’“Y†R#nÜJ(² ÏuY/Ö8½y®±Žu}þ|ésØy|Ô ›Wj” HÓM˜vüØÓ³s¸‡¯«õ‚ÑäOZÖó9ýဦ¬^„ B\ihËŠå¦ë„шÊÆ£!AQ´ ¬C]i]sppˆçX¶Ë9­¶­HbÛwpeŠÀ0GTMηNá™qÄ»·osåÚU²,g±ÜºdÆ#÷¦Ü<#õšk£±ÝÒšÝÖLqy4ÛÒ–eYâ*‡7|‡~/&¯*LS£›–éþZ×øžÂS­î(gQàÓê–¼nð=å(®\Å ctUvŠ8[svZákEVR6-ž EšRíl²7%K3Ú¶Åñ|ʼÁŠ®Uþ­™Ës{E^#¬ i*Yž3 ¹[æU@ì[ª²d³-p•C‘—kÉÒœ$‰QN€n[,†`7gÖÏ¡ik”tº*I ò2Ç‹ç¹—"ìâN‡ ëÀN­iitCÖ”TF“ÕO=wïþù›„¡ÏÕk\ª;4ðŠf|À**EÖ\èR_p…‚­~¾%vtÚk¾OèKäËhµF9ãQ ÓQ¡wU¥@ • )[|Çíì­îŠ,/fÓ =éMƒU„§GªW!º*9ÝÄ|ö£ŸãþÝ×ñÂŽíÖEkŒa8RÔ‚$h‘tIˆ?ãjmG‡;ÕÂ,O»}twgþÕy xŽG×2øúŸlk[#±ŽdØ5‰P†÷fk»õÚW¾‰zú¥¿ð‹Ÿ¤Æ ‹ß¶F>¡ï!Û–eS»»‡KvnN­ô]ŸVWô¼€ZvBQµ†ç=Òº%0^ Žêäà ±2 ;Ôð®Å«vº’¢(ª^@Û6´Â0À÷:¢’²¶»B Þxë.ßûÊ×ù¯þ˿˧?óJ÷Z×Ò”š,_ÑÔ– ôq¤¢*¶YÙRš’Í6à C‚ЧL7”ÆA2èÓïùD¾‡ï†l²5'³3<_áø>JH¾zWðÔ¤û#E®ï]AךÖ6ô‚ví5´åo·MÛ ”ˇ?ôÿâÿüSʪáÓ¯>K«5U¹æ‹_úïÜ9ã?õ"·žx×iqiУ[èûoe){7p\IºÜ2öÙn Ò¼ 7îóÔ“øŠ×ø6Ù¦âù'nð¡çoò¹Ï<Ç'?þŸûÅñì3£Kø|úÓãÓ~ ×w ‡}NïÞ§q#NƒÉ”ƒƒ˜Åù c[ŽOç”MrZ­‰z‡ûàx¼Ø+جWw€Ä°]ž’-ãé„õjAžŒ† ëmÕÍt·æç§x®O¾™SX%-›õÏ•4MMèûl× ‚££Š2co:a}~Ârµa<éÃaLà‡„QH¾]ñàÞÝî}—s–óýÁ¬¡(2Ú¦·¥ÌrZãÒÄSÆbE¯?`6›EqÒCû~ɾ³ÆõC–Çw©u…®V‹ ›åŠ~àø1‹ù’^qÿÞ’¢¨8<ìq~¾Â„m(‹/ê’Ót½! \ü8 L¶›%¾ë1™Ž©«š0IØ,jÚ`€±–8N˜ÍN±ÚAë–t«é"†“1yY²šW8AG=M§”U @ÕÊÚòæ²âL÷¨mÀgot*וäÙ–ª®9Ÿ­ØÛ?B p|—Ej¡Ùt‚CÓ)m]¢¥‡ò#‚0ÛP×¥\¬„@:´m‰e³)3|×cÑÚâ>i–Á®èP»J°ãêvúÿ;6Ñ `»b$ô}¾÷oÞb>[ó‘WžêœÜ´~_uÕ…ñè]`–̺xNÇ×M‡'º i= êú«µ°][¹çºt¦]U[”egÚ¡ÅÎbÕîŽy1ßÖÖ’¥QQ%V@a,ÇUŽãøœ¯×ºÅh+ÕÊõ'€Ï«zÄ/ôoð•ï}ƒQ²Á5ÎÃø}‰žîž-b|GÐð?õӮ𢭽X,£Ïs;|ÀOA^ÿ¬eª®ü€ y]ùßå.(r P/5yíÓ \ú}Ç{í+ßD½üñg¾ðÑO~¸k%[ÍA¡-P6,iÑB¢¬d]—$»jÕk­5]À6 M[áZAUW¼5·|øP2ñínèmQBíNÔr0š ÄCäÜE¦q!Åv)šÄaHž—XaȲŒÀ÷ nø.vTkAYÅoý/ÿœÓ'üúo|Žº)©Ší®MTu^DUæÌÎϘ/6;žcÀÞpH/ô©Š‚À÷p„ÆQ.›MFUµl·›2¥65ÂÙù™Zd͵Ûb´Á‘.Á,–×%ý8é„Ùw>·{½˜¬nèºm)ªèÚ+EU„Rt‚£xÀ_œ²ó cÅ( 8Lr²ª"¯J<ßÃ~³­Öls¿9M7Äñm:C è„÷W±].p|Ÿº)ˆÃ€¼Ø’§kúý1u³¡-Â0âþß׸÷Œÿäþ»|蹧1uË|±À÷|Ö‹9H—£«ÌÏw_ œù|ƒŠ,]\½ºÇÑÕ}|åñçßy_û•òôS×ÈóZËý“5Ï?}ÈM8¾½e“n0~殄?Xt××”(Ñ°Xi<·e½¨h•àæÕ«¼ñƒwY-g€GcêÎ1MÅÜ¿wNùDQØ™ôb–çhMÃü쀲4 ¯Þ²<©ØdšVບéÞ”ýý}¢þ0â #Ü>Íæç§÷©µ"‰C¦ÓÛ劢¨‘¦¢©k„p¨êš7¯sïΛÄQBSU!1mÅÞþ>óóczqÔ)ë)‡ºÌ°ÆrrMYÖ«-®¤YF?‰É6åq~r̶jIönpÿÎÛ$q‚ÉפyNš:ßqHâ!‹å–¸7b>_b=ŸgŽ²uNÆL§SSy­ió5M‘±Þnéõû,+ßçøøœ½ýuë’ç z½iZai©+(ª ã½+l—gDaŸ³“-Ž«N¦H£©Û–:Ïñ$xJpçvç•çkzIB80;9à ‰G e]]~ˆ(¢›?‹Žçzh­i«–"/hÆó\úý>žãî*í.Øk­©ëšßþgÿ’wÞyÀÞtć_ºI]5(!ŽGÓ ¤òñv ¤¸×£7éítP;ÕŸÕz‰©kNOOÉŠ‚Õ&¥²7tYm7”z‹u;¸¿ÖÏ‘|g­˜x0éI«Š«l³”ÐëeVç vöŠ*h=•óãÓ†+ƒ.PúžKÕÔ VXÜÀÇE!¬ / ÆrÉõg?Ëñ½7º|ç F!ôhwâ#eQÒ4 £ÁˆÕvÕÃ)«åÇ ;Ôj’å)žï’§+­‰â]çäyA]6ÄqŒë{4eC^¦üåïòÿüá7øè«ÏðÒËOu˘6 mYâG1ÍfAUµ”U1“ýî{ìñ§¨Š-m]1˜0ê…¼ö­ïòî·®Œ¹qýÿèû"®r¹~uGº4ÚÐ6ÜéUÄðˆž¨hu§Ÿ}û‡1Aè°Ý®ÞèÇ nÐ'¯3Ó!Žôèì_¹Âdï*A”&1ŽR[â8´Šùél§ØÔ….ƒ¸SŽ:ŸçQÑ‹]âQBo´‡tB¤QÖƒi; —y@ºNi´Bº~R×[ÎîP–%e]#A™7ô†ÊlF¹18¾¤* ƒ>MÓÒVEV¡ÛN÷èpŸ³{§HW¡©ÑF"¬ È ´‘l²-­–TUAZVL†|yq…Lró%e YVpýúMšÆây1Y±fÿÊu ß_ÌĈ=µìfÿªKÈ·«‹Åô¨Ws[’U†^¯G±MïM(ŠŠ¶VÔuFÓ´ÌOk‚DP¤iŒ %q³Xô¸swEèHŠ,ENàƒÖŸ—$=¶µL&}Š<Å÷CÂá%,ïQ–ÊqÈÒ5ŽÛ¼²†î¾@Z½ >IÑÍ£…4uó®ñPL  A‡K²GŠÛKÅ2k{S\4R^»ãscdþâûîÙÅ{@£ÛN¤©­¹,Çÿš«´YʪØÑ« >±Ý¢0M J}`êСµ_~é /êc}H 5xG[”Ô”Kª oÌJQrwáðüP2{|å.<9h¨1Œ"1"•ï×X÷:5§ÓØöv VrGÆÇvš¨m«R\¢Û¢0aq=ÐõÑM³C(;»Y´¡ª5ÿãÿôOxë­{üê/Œ¿û›ŸÛÍ]å²@ p=—ªÎÙ¬çd› MY€®YÌç¬×9••ÄñéX¼$"ÏsÞZ´¼ù4üx滆YêÒë ®Gz' ÂÛX¶EÊ ×£,&£ÚZb'!(ò‚ ™-ã Ä÷<Ê¢êÐϦ£9åYSÊÁuÂ(ä[oýˆŸüz{ÃÔÏA„"àd9#‰"¥HË Ï («Š Є”EAÙ4Ù¶ùѹZUEEWQ;Ha©Ëcj×a5OùÇÿûé~ý?þwXâ "ê² ð<ÎOΑÂPÖ5Žãw€¸ñl±­©Š5Âõ;A‚¯ó{üá—¿€ë{üóÿãˬ697¯plÀÞ¡‡Œc˜>Æݳ‚C»$ݤHWG‡1d]ƒ²Ìæ9ÈNEíêþt›2Çáå Zëqg[pÚöyPG¸Ò ÖsŒ°lhÊÇñ¹û¬Y¥ú“)½Ñˆh0"ô¼!Ž²l•Ïirc6''$ÏÖX!b,]•ªÜ€ °ôâ¶éà·'iáô¼¢­[”ãctN]74m‰ç ÷öȶ)EÑàG­Q8nŒ.Òõ~®K¯7 B”ø2èsw£‰Ês öp|ézTшïÍ%IoŸïÞK¹Þ³ í‚ýzŽQžÌŽQ®Çj¹!x»ÝçH­‰÷YœÍé÷;50ÇUØÆ°^g`Ž[£[‡(l×t"q‡ÔÕºBá±\e<öØ>wß9'é»4EëšÙqâq¾Nyúú[Óéh«®¢UR ¢)¬3Š¦ áÎ(§Ñ 8>óí’ÖʲB:[ÈnìöhpÞ!²:mí‹ }×êîöDEÛh¾ñÕïó™Ï¾Ä‹yŠžë2pUÛ`¤|ŸªÕ{XÕÑ;)ÒÝamÞKMz_ú¨xø‚N4j×ÑÐmÈ,†ÕzP’Öjæ«5FwT7\ŸeÙÈxž»S{$Aá'’„Ýíù` šèLÞÓÁø`¬&ô#ehLǾ¾:†B ”0t·í'-.¿+©vûa@^æm$ûÅá¤TAçÎwA‹ú ĶU-?:q¹¿€0ÜYZ¦ñÃ÷|í+ßıÖbŒáZ³ªòÎ1D¼»8dL¤e+ZžÞƒH$Üêkj!9Í üÄãÞ ø÷nÕ”Uõž›'…äÚþeÓ¡ÕêªÛø?p]hkˆ£]7uKQULÇ#„ßhšÎ»`»-ù¯ÿ›ßÂó\þ‹ø«Ý<ÂÙÀü| * L\†Ó®Ó!&óÒâyF£˜?üÎÛ †J)²4 ¶ßønÇÏÒ‚:¯¸yåÓj„TÝü+Ï0&¼ýömP´èÙì.ÈÒœ~/!öh´Áé{6•½qŸÇnðáç®sëñ#Zî5=^<ŠY¿ó#ölÈþÁ”õbÃz5ÇYœ7á½Êð‚>ýIÈÞÁ¦.¸ýæTxhwÀ»Öå¥iÌhè‘8óù»¸nDrÄq3áëo,øÔuDzZŸ0½6!é†hß!–‚ ñhZË›'1Ï]ñ˜ÍÔ§„Æe–grªÒÒëINœGàNÆÌŽ—ÌÏa›6<ùÔ>'÷JÊ|Ûáuž/O©ª9ö¨+ãHÎ×K¶•åèêcÄ{{¼3+¨«’¬é63Ou ÔÝÓ ÷f‚ yzèp{¹Âä>°|}"Ïxyä1Ž-yYr+Œ Îf|âJÈòÁÂAÂyVóØÕ®-I]E–å\¹vûwnsÀ / 9pJÔÑeÁb^±\ÎIå¤Û‚Ç÷÷)ò ÷î–ô‡–rq4Ä‘‚Å<Ã=HRsz\spe@YT¤ƒã z=—¢ÈaW¥h­±Æc½Ú`„ɲÜÒúŒ'ûÜ~÷ý¾Gž]ÒÔu†¶Z%¤Ù’8îìX¿üŽæ—^œ Ñd«SV³ŽÒà —V[F“!Ê ¨«š8ŠYfs é°œŒ1Í®€èF@’Õì”RA£|? 4 y[‚±ÜÚ»Áâx†*Óì” ìeÅôjí®"´<´T„‡4t²ÆÇ÷ç\yâÚåë’J)>¨n¾¨¼/ÖŸ¿5âåÇ—`ÜŽ.ºkþ­NÏqØT‘R]ÁÃÚjÝu/v;JZ¤ñ O‘uÎ…˜ÈEKÝóÓüëÿy‡‚²®H¼ˆãÂr˜(Z]q/KxrØ Œþy(Ìý|¨Ÿ÷v3æ<ËÁC!•ÐÜÚðÂIƒåë?²|ü©÷O½ôò _xåS/3×eG%‚·Ï}¦[n†!¾+é;¾PHi;i ‰ù†QŽë»]U+UÝâ:ŠÉ`½Ó\Wr:;g˜ ¸TÁxär¬µ´;ÕÉ· \Eu2‹ÅkÁó<aAyüÓöqr2ç×þögyþ…›xªºå|žríÆ-z±‹ij0-M™3;?ïäü4MIË‚ÚÔhÇ!PPK—ïÎ/]ì%cb1CÉn¾aéü„±’Ø ØïÁìTfvî2Ö tÓÍw=×% *]ã(Õ=$x8TÚáOßuÙ¤í8ÔÛ2Cu®ãeK„X þnNa…å±!¼ö çÕ§?Ähô½Ñ-Þ8›Sµ’ÖJ~03´¶¦®—\Ȥú^„ ¡©5y¾&N†ÝgˆAhËo¼EÐGÅùlFz—¿ô-¬í2¾›7zX)É7[ꪤ® ê<ãþýª¦Åõcâþ€áp@4E¹–^/î,öl‹«¶õxìåqxë}üÓ¼ðÌ n]á­ÜãÙ+ íü.ÍfÉz-;iÇÍ‹a±hij‡4+‰¢î½ÆûLœŸœðÎí»‹}Žn=ÎÕ±"ÊïQÎÎØÎϘŸ¯9;-<Ü{ÀÐox|?Á ~¸²dvyú‰}¾}§â…£„F:Ü_(®ö]¦~ƒ)çlÖ+Ú:ãø옽ý#¶›%«yÃpä²Z*°)n0ÀqõvCQ¶,W”£q}ØnJŒÛç XÑ4~Š•.^Üc¸ÿwLÄQ¬YŸÜeD†ÙœóÄÔ!ifôT͈5G¾æé¸æºš1 åÕ§÷x¶W‘/Nùð¡ÃM¹bFä{ÝÌ4ŽIg眞ÏØ¿v“¬(ióáz$QÀƒ{÷ð‡Ù|Åh<ääÁ1VWL¯^Gäs\×ÇC»;Û×®Kråêù<¥*+âù[CÞxý{“Ï>w‹ÙzA'T¥¦j4µ]½Édÿ€ë×PºäôäajŠ<Ç•1wÞ]ѶŠÎqã0Ôd Û-ŽnH܆úø”ƒ¤}Â2…4mFS‡;þ`†é¡‡n%* è÷z?¸ÇÝ»w‘Oòê³W蛋û'+¹…6.‹åP4uÁü<% %u:‡¦âC·¸Ñ¸9ôñ—£D!¡tèi«¹÷Îë Ng z!Ö8l7sÎN3Ç#Ýæ(å×58“ñíbÁz³îT“„àÖ­›ì¸–¬ÙŠ1o™CÞl$Ã)7{ÇiT –Ççø±ƒl4ïÞ>åÊ•=î¿{Bú,V+¨*–ËÙº%Í2[Žïv²˜½QŸóóS¶E†¯$éÎ’1+2FÃç§3Fã!¶­)ë†Þ O8 È2”ôû/bÔYÊ×î*†Úp÷¸À÷<”gQ" -uiˆ—4-Ñmƒ\×eµ*OG°Ù”Œ'J„$}AUÖL÷QJâE>aÒÇs=6ÛŒ¤—0ð¢]—Xi^1Ú»‚µ’¶ièa?A‰ãø¸~@Ô‹ñ|åŠn¾_k®D.y‘“mסGäèºÅ A[ÖëÆÂf³¥¬êNx¥ª0UÉŸÝkx|â!E“œžžày}ühÀ$Hù£7 ®Æ5RvÚòZëŽaât"?Õ°’;Ïuk©êßóv$å)wÁû$vœ µáôþœõ/þŒ^x|‡Ìv*ïkk_.­rI|sY¥?Z­^ÄŸÞ:îÂW}! ²ÛÙ¬()ÐÆ2 :  µAkìCÎõŽÀ= #NëŒQØ‘¸¬ìD•=n÷~gÞï9‰]+~©ÛŠ÷VïK0»8¤IBÉ÷Ï|µe¿‚ýÙ€°G—ë¸ÿömíËÕ9!~çïüÞ¶¶eùÞ¹Ï Aã6¨Hº¶¶€ZiÞ=éóÜA‰ÜysÞn*œ¤1ìÅ‹±½)Ûn÷z¥Ë ”Ó¡ =·ãùFcb¤£¸·8g±]1ì—æO IDATõ@Û\¥ðŸ¦jwQv÷Ztæ Æ6]íz|éK_å÷ÿϸ~}Ÿÿìï}ž_x’tyÎx²‡’‚t³@IÅ&ÍIÓœ›×¯s|zÆp2a1O9¯g † ž–|ý%qàQÔ5ÏzÄA‹Â#×5ÊQ´Út 2+¸2=ÄÔB±›Ù¬èDÿQ»ù/? qa¡i5IØçOo>}Ø!=5ŸèßaUdLúÓKÅD'0M?ÃÝ»ßàêH:h©Ú–Ȩښ—oŒ;D$ ùæ/y|Ø2u6 ÚX ŽöÀWc‰cŸ{ïÞf|pH¯“nWÄI~?ÆKœ4A9!›&c9«xéºÃ(yšåù–íz‹­j¦ñ¤û,zaÒ©IQ²]l°z„nÛÎ\À K˽ãc®^‰p¬0—û–cá ›Ô1hw‡H4J§´êM~챌×î\ìÌÂÀܘ~ئUFåXTJ‰A”R$÷Ó)L [¤¥ªÒŽ6¬ £0)R¾ø¿ÈG?ÿOi{Ü»ýÃ]š¥Ê)•Äó|V Ø,&'¨²ÀµkÌæ9a‘»N§¹âÞË*árr’¤²«¼u+äñ'ûÜzãxÌç+êõ-²,§W«st÷˜í½€2©Î]lr×Øç±æŒÈw™'&—‡—}M9sçxD«Õ$‹Rjõq8Ãñ´€õZñèc»L§!ÃíQ˜099-Iâ‚årÅpo»¹Ø&³ù’n«…ij„pÈs0%†)±m—»·G•Û—ßâätÊÞ¹6^P«nºé˜R‚*RLC‘†)ÚŒ1…Ãl.Y¯"’pÍ:×äÅQeÄU–Ü»wÓ¨“«‚UuîŒét=nÝœqí±‹ÔÏ ¸óþˆÎÖYz„ãî¡Íœ$a¦eS–ëTrñü !)¤‰”6„hqÊéhMw ðÜIÑ|FÝ ¸w÷?(Pe‰0lÇf6/(s‰aY¨ò˜ ×ûÌG²ÕŠÁÎË4q|—­­ƒA“ÅtŠe:`Úôv¶YÆ ;Ý‹”eQY.®Sv·wYÇ+‚ À¶<¦“C”Ê°Lƒ\ /àî"á¥þ’à Ûû{¤iŽØ–Á«‡)–]±}£2ççküÝ«62Ï)ó‚U"• ê,ÄޠWk¢Ñä²À¯·˜¯C„QÇÒ•Û[^äàx\Û J1ZNqüižâ7k¸^%²cQpµ]ç/\^ØäF‰± R÷[Ò‚ªÊTJ!‘¿w)]µÀ-a }‡;ó1{¢…FVÕ5‚sçüGÿùOðÅßùí¨*ÞùßÓÖ5 Ú~öðïRê,Ðœéëÿ-×ýyõ¶WY‰ ¹ ª­ä™]¢q×¥+à›B3ŠCÌ É,mÐjÆÕ^'ÄýÔá!Äõ÷&Ëh,¿ôóÿV«õ·>öÿë×ÿ‡ü¨htêánGiÜ]*òÒd$m}è¼5B L»â¼›»×ŸøGÝÇ^b»Q¢…zrŸo¦ A.%BÙ¬”d¯g†ms¾¿Ãbb:EVpáÜyšf½ÎÆS¡¡Q¯q<a8ÝV—Õ*Æ4,LÓÄ2%Óñ ­–çc™šÕªÄ³L Ûb¼,ùïë÷hÙ9Ï>y‰f³‰.5¦‹åšÉ|…4Ùj·9>9Æk6ðm‡(\r0=áë³Çùô OqÞ‘«»\ì;¨R2ìÀ¶º¬Z4:ÍI‘‚ÖlÕÚX–…)¬Ê9ET¼5a˜¬Ó˹Ÿ`ˆJEÈRâxvE “•ƒùœïÞ‹xtèalF§³ Z(ÂU„cºìt{ÌâåíÓ5f(UÍ°Ò2'šÌfK¶¶ÚdIÊäÍU“¶³ \ĸ^ ßóX„3dºFf…HebxÂpɲŒuª8¸ý6Q^"tÀ|vH£æb™6ãÓ»ØNÀ2Zóúkïó¹O?Ç;ï¼Ëïþ_æµ7ïòâÓ{dÒ¢XNX%®íc8Pb£q™E)ñ*Bë”fÓÇ O0mzÓ%—Ñj…czH•Ól8ŒG9Qb9)Y’s:9š¢0X,"–a F>÷ûÁEÅûo-É…âÆ#ןQ¬3Æã‚8ΉâŠ*µ˜DX:E*iwúÜ»…Ö>¦X±^»”åŠNs tÁ"¬$LKÓäÚõ Þ½ƒ_oszrÓð©×:$IŠkû,æ)ŽgÑïxžM¡ªÊ?Ë$R[¸ŽÅÑñ1J„Ë ‘.—4Û[„tÚÓ0f0hbY}&£)†rioÕAu1Í„"ó¹t¹ÃñÑÏvȲ”ƒ*S”Œ¦OžiÚ-élÎd>§7lb+Á»k–Ë9W/9TÝ„¢(ÈË¿`›Àæîá)¤[;=Zyš1Åx¬u Ç)ñ½ª c: šÇÉ(ÄÆakwH¾Ž±]Ãó†Üœ4(“5«8'sJÃ`Øm³^­p<­[ýQÒôNŽî@™Òïï1 #’´2¢iµ¶P†bEÐ X…K„aaZŽ‘3pׇ .v=zŽÄs„Ö˜–‰e™Ôjqáº.åfÞ«”‰ç¹—¶J¿ÙU°ZÇ ¦mgsV”ë˜0[•ç¶ÚÄiJ³V#pk,’aÁŽ/8IR:¶-ÊJìbX´Ú´ª©^?MÓª»¸Á­˜â¼¥64*—´|ŸÖ+š¶ Bc"ІäË_üÑ"æ™O>ÉÅÇÎU°lŽ-lÀÄ2áæ‰d»UéHßWû°nõYиßÞæC•ñ™CW6— TF]8H!pm—4I«gnŠ+Ó0ÎfÃWaZ6ËÕ a7øسŸe»s7ŽL<{‚¡$Ò”x@iÚÃýÿ5Š“»§<ÿäGð<_ø…_`8²»»ËïþîïòÊ+¯pëÖ-æó9_øÂøéŸþi¾ô¥/ñû¿ÿû”eÉåË—ÿÆößeýù×þŒ½k;=&¨€ež_Ç•ÊÞhw˜Ú`»&yû(b»ëVLÍõ1rÁ½TдáþM¬^Cs£—ž½%gíãÁðÝ ð§EBÇ÷ÑZUB!ZÇ+×AjE! (r„ª†U«¿jÿXÂäÊÞE–Ñ’ÅbNÝ÷±-˜Ïg¥¢Ùl!±±UJj8h×çµ…I<͸Q%Ž,æ1žçÇkjuñdNôiv»xŽÍ2šQkl1YÖ}¾=V|â™ãï[%_ãìÔ2<ߥ«ùpžã•±·vÇEÊ’¶`™öCn)ÖF:/Ë«¶™ïx8feŸ)T^¹“›œJ –m!KIǵùÑk¯ZkÍbVÛu T »[Ì£ÏvˆV%d1ž¥èt:Ìç zƒs{»,Sí.RiF‰É!ð|ƒU4GÊÏ6)´—XALÊvoÀ»cƒÓ´F·å0a%s¦ï¼=£=¨±Nræ“’uš`Ø+Î]¸Ìí÷Þ`§?Äë(eL@•xA›‘Ä÷K:Êc9shv Z­+Ìç3v·ÛL§!…NitÚ˜®oƒ0}‚@¡EI£ÓfkX!© ©YNN¹s8âòÕk¾ÁôäÓv˜-Wvù2åqJÝéÑmøÜ™.yq`³+טN‹$O+»Ì8¤Ì üV×µˆVsVñš è!ó %ËMG+G ¨ù^å+m8´·¶0LëÌ0ŒW˜–I^J²¢Àðlâ4F“0L’—Ç*-§eIšÅ ºƒjOP˜•Gz‰Di£"k]a}¿Å«6•®ÞÌ™+Œ‘V’›™(r.ÔŽâ%7`¡sl ª¬^gµŒ‘Åf¾}õL ÊÅ4·Ç%û=‡Ë} ÊF!« ùÄÚ¿N|䇡£MÓÀ”­z5“²$JÒüFél3o¢b®X ´ep'ŒX{ç0 24?öÄ%´q™?ëñ¢rŒú¾__‘Ò’BV†LðÀ‹/¾xöµZ›7oråÊ>õ©Oño|ãì{ï½÷¿ò+¿ÂoüÆoð¹Ï}Ž_ýÕ_¥Ñh0ɲŒ_ÿõ_? –ÿß,åX„Ñ×qjkK4ÊÐNÝã[SƒµlðÛÐÓw <ÃPѪ™ô= ·AVóc©ÔFf“áZNõG·ñNV(L£~Øõ%%ZiL6ÀM{Þ÷¼J[Ü4)U ª9‰’ CU7¦a¬ó5¶ãŠAo€Ì ¥Øîö8ÎáÕ[1Ÿ¼à0›˜Oæ á‚4M°WXº40=‡"-QJÔjLNîbX>q–R÷;t»vrÁ.¹^ewyºi€Y™‘d«1†ácØ#l¡ — úÃ* œÅ)WLøØ Wyôê9;VÓ¹áqáÜy–'·)ò’ h4}òå)‡w šÖ%‚ÀEJÍ2œq®Þg9É)¤A»ÐnבE½›'Ôj¶5d±¾Åù Û4[mÒ¬ ÛX-Ž¦‰r±¼‚^"ÍVÝÑÛïs::$Š5ý­-ܺ‰°5šœgžpzT⻕°J’T `š–øµ:£Ó¦]Í ûÖÑŒƒ;Õœ7hR Ç—ô‡M<F lõÖéÛÌÈÖ VKƒ8:fk»Íòô€x™² NGsÎ]¬c)áb‰1^=%ORúý&¦‘ ¥ëv¢ÀõlLÓc-s²,b:i7<ò"g08¿áÁº$Éší᎓a×îÑj ÂÅ„¢4кäø`Ær•ÓÚ²én™NîÑéy\ØÛçäÎMºƒ!átÆø8ak[‡)7½Â·ß:à|ÓbgËáÏŽ.ZGÜyßbwOÒ ÉËÞ±˜&XfLÿB‡e´äîJñ^dò×k˜hÂÑ!Y®HòBbš.‰²‰Fóªr55n³Ç"“Ô{|ª! Ébqʵ«ÛȬ²…UIF«f3Y†8V弚ÑíJåÓ£ÔXÎOÐZ1›Îè ÷(²„Zàây>žgQk£BPlÆ÷M ÃÆ’ŠF¯‡”’¶·Â54 ‹u1ßÜÇš8‰öúŒ—SPm^+®ul[Uhàû­íû3Þ ÊØ4*….%«$¥Qó+ÑÍþzZ…Ä6]¦e¡!&O|êÇÿlÌÍ×n±we‡ÝË;ª³É<µp›p±Ÿ£D†RJæfuŽg-m¾pÅ_W1ßÞÔè^›Ç{A€!EQ ŒÊöUlÎK@Å!6eQV´*Û M3¤,ȵâÚn)ªý²(”I¢2ÃøÉÁÆ|’"/xýõ×¹}û6«ÕŠ^xÃÃC~í×~ßú­ßâ§~ê§~pˆÜ\‹n·Ë/ýÒ/ñÛ¿ýÛìîî2X.—$I›o¾É¥‹q]÷‡EÛ‡–ëy<õÔS?ð{úìlŠ$OhxÍŠJìú  ÆQÀv3¡4¶öQäÕuPš'w\ÐUBbi(¯zAñà‚i4–ÖHSÐòQ …"Ë3t ï|p‡Ë—/0?8¡V÷XNK‚–ïؤ¹@•à ç9¼÷+Û¢T‡t:”4‚n£CQjÒuÄ `.­ŽÅñÉ]ÊÂd0ܦÌS²Baº Ó9® ¦ðMsÂṴߥÌáÒ›{Gsz½í¶K¡cŽ˜,<Ýoqw>æâõ]¦'K;à»ß¾Í¹A‹y¸æö½5/žoroZ£Ø?Ç|ú>E~¯ÙA8]Z; 6ãyÈkQO_péÜ}¯ß¹ÂEyÛ,ñj-0ÙjÍ,ØåQO–ߤ!b2]ÔKœúš(ŒÑFNÝs™Oèõöèoï“&†P´:Ê,Bk“BÆ”2Çu=ÚÝ-f‹)®é2¢òYäh%ayž4’"§YHŠ¢¤ßÝb:Ÿ`Û.Y4Ckh \·…JbbeÒª›góÖ( ׫ Gb(”Ö<Þ³8 ú†0+ç© l +¾³Ò dKiJ,, ­Øv},ÁFÛ^b™&oóþ³W8ÿÈ>;¶P¦ÂPŠ(wèÕst®Ñ¢¢åHYl\ü8™ž‰||OðûÞ¶¶ŠŽk3Ï „26ûUù;J€T”R²È #Çwšfw` ʬd¾^Óh48\GR0/wøØ7@™bø¬Ñt¼5B ~˜P¦±:øå_þe¾úÕ¯Uu{{›ßüÍßäâÅ‹|ç;ßá•W^áãÿ8/½ô×®]ã _øûØǪó¼ß6þ²ü±Ç Cž{æ~ðzçwàãnUçðª‰FS”‡#8wÎ`§› K0´‰¦8£ˆ}óvÆG¯;°‘Úþª ÷ÑÃ{nI™"¥@ …R­®é’+MVÔ䃷w¸ÕÛPI‘n†â&B+|Û&Ér<ÇEh½iy ÃâNd⟼ÃoýOÿ¶zÃV•£Ëö°ËË?ùׯîç%ýþyš³ˆê6£ñÃdeÊYžø4÷ŽC´¸‹rÌ+D®‰…Døu¾uà±ÝUÚ$ËRLÓ8£rUÎNú¬õ¤µ$Ëò* Á4\Ò f¾˜bš‚8ZÒélQ–åÙMá:.¾ë±LÒŠ¿Øhà˜žmSÏëŒ3›?=ªÑá€×?7›Ó“OñÙ>Žçðæ3®l¬ CIz½E™! vv‘áÛ5M§8&Äé 9˘ÎVt/]&Ž–Ä‹ˆ,+ÑHêAÉñÉ ÇÒ /ø¬Ãl·C½Ûešæ¼óæ=¾ú•oð{¿÷¯è´ëÌ1ÿâ_~Dzùô§¡æÔ³˜í~›2ža¶jìžßA')Óãٔíw?XcØ6¦á¡ÉPÚ`r“¥Ô¾írp2ÂqŽkãx6_»ÂâtJ«;àÎÝð–Óƒwy|·I š$ £Ù˜­ÞyŽN¹p©Ïd”âù=Žîqý±ë|ý+oa{.5ÏÄm´Ù^f¾œ²\0èµ¹ùîœnߢÓ¸ùÚ{Û¥7pH E×°H (Ë„ÉrM8ŽmKTéávö88º‡,bžzæ³ñ1u¿Æhš¢ŠÇ÷&ØV›År„Ö’8óHe‰T6QµÒ¤“âïtxuѤ/-<Ç¥g™FЮ™|b'çèÞ RYžfز #¦Êå´8×hò¤™°ZÆD©ä|Pg9šq: ÙÙÛ'SšLØZãz&Ѩ$©/pœžï†sLÓ$Z­çÛ•VŠ!Ld™c©õ Á(“„sÆ˃í!hƒ¼(qü†0pj6É:EheŒ¦c Ë +3„YU,ó8Ä™íÑÔ!$²¬’ö34¶-Õ&1×l5R<]aT`ú v6ãþ{´ãº&+†ní ߯×ü/ÿäË”¥â?ý¹íûD÷fg{ñb¼¨8Ãqni de$!°)eùtt¿ÀÕhMk›ñäýŸù@™Ö•{¥«ê,”JaKA?¨¡T¥×h-ùügyQhCsyè}ìrt¬ rnAÍó9‰2Tnë ۷ЙÆõl^=‰yvè p*_iÓD#0Ls#`ajË´ÐH–˶µÉ˜eAN(KEžWž,y‘ôq\DZÐJ³˜NØÞÙfžÄåؾËóW?ËZ)‚Æ^½}Êe¹Æ“ ŠÔ¤ÙòÎLó|_²˜Çlu’¤dÐi1“ÇK‚ j™L± èà IDATi©¸zcÃrX'“ù’h.¹|e›“ƒ–ia¸•Ä¤iŽ‡P’áö(ËૂǽÈd2çt´8ËêÞ¿} À[7¸|aCÀGŸ¾F·ß`trJoØÁ š¼ûÖ]üš‹mK†;&a¸f2[!eÁpУ^ï®è v¸uë6õÀâêµsÄ«%ª,IÂ%‹iN{«M­îrÎi·Lf©Ã¥vgyÊSOßàö­{Ôƒ.ñjMš¬ºƒgµXN#ž|j‡$Ï8¸bd¦ca ¸tá'ÇGXNÁp0äî­ûöùî[ïqþ¾—³šŸPo÷°\Ÿ ûÏi®K:[=¤œœNXÎG<ÿÂ#ܽYýýûµŒ(rðI/Ø=•t5¢Ñê“çk¾ùêLæ15G²Ûkr4 Ï3,7¢ž¹&O#ƒ'Çk¦'ǤyÊåkCFG)qQ  ÝX%)®['[/ U„qBàÕ‰¢{4Û5,³éX”… ËJ¼zI£Þçƒ7>àÜù>Û;¯¿~ʹý&ÃáyNŽn†1[ý€;w˜Ö€¬H0M–¬ÙŽæl7Z¤“ˆÒZk”Óf«Ó¢Q÷ñGÇä˘îöº¥ 3=Æwš¤YŽP•Æ•‹Yœ³»Ç«¨VÝC {sO!5ÓɈÝsÔjY²¦Öè€N)ŠÏ­¡„‹ ¾ß$ÍcÇçúëLǧ\¾pŽR”R¡uÉÖÖ¥Tˆ²ÄÅ"—9˜Ë6)Š¢b¥¨JH£²pTØxFÁ½¥ÉNS Dŵ¶,kc«Zmœ¦x(V2À'Â0ê›*è¾ø54I©ÕüŠr¤–Çe†QJD!9~û˜ù,ààƒ1ç.oó•/¿ ÀOýƒÏ£€¼”¼zÔá#û SmÞš ïRÊòaæû{¾¸OQ2xwj²Î\žÛ]¡M6sÜû…„‰ ÖqŸ*ª+ D)`UäX%”Ú^Eñ  ز2¶ðlK(4¡ôùüãŸFiÖP á‚z»MVh¾sóÎ76†BŸqšp´ÿïÄ@þ/ôêmtYþjŽ&NVç› ­‡Ò‘ï™a>È\¿þî Í»ôL—PÙx"'WChÂUÄg®µxclñΤähe£-ƒWG‚À¯ÕPYL²Îq÷Œ*á¹Jʪ*Ùp5õ¦mE+Çr*ð‰ª´d=ßGHÉ2ZàZé:¬ ãKIV*þ¯CA¯=äýƒSFË%w"É'ÓH(•fEÔ ‰çUÖ‹½NŸÙtŠi˜ÌƧx~2KYÌçôz[lï ‰£9á"æàƒJ­hu[ÄQÈ:ÎÃþ°Á|–ÓﶘMsLK³X¬9·¿,%;ƒ>O<¿Ç³Ï=Ë‹}Š›üøgŸæ‘k{üø}”<¹O¸J¹w4a4YòÝwî’g‡‡cÛ$.2lÇ`:™“­l¤4Â¥æµÚðB“e1ÓéÓʹtiÈt”°˜å,–%¶YËáðà! .Øn—ÁnŸõèË¥Ãtv‚ÖÇm-"¶¶\üzÉhJw;`t:ű‡h]&1µz›ZÐb4ž.Cžzê‡wç”Êât<âÙçn ”d6ÊÉrE«Ó$Z.I“”»G!uÇEjÁd³\qãÚ”–L&9n£Áb–bš%ãYN·Ù J ~çþ?øÖëo#Ó)[µˆŸüÜyڶŽqF’I>ñâ Ô‡x1Ç°a#ËÃvñlƒö–K³YãäpM-hP¯åL'+òl…ëù,sÇcÐ3ñžgP®=ÚÝ6Ê°ÐÊÆñ,‘‘­-ŠB³\äÔê>Q”cÙ¶­Î.Óñ)½-ñxíòÌ K vΆ‡éºYJ£æ’¦)ByÁb±ÄuLÆËñ2¤ÝnCY’¥¦ãSd)–c3M0|ŸV³Î|²Âvl¦Ó9ŽëV,¦S Ûa±\áù‚Z­í8di†a*Š,c«¿…íXHUù ·Z[¬V“é0X̬–K‚V“ PU•ëX6 h-¿NP«³Ã*¨ñ ŠÔj3é4 –.­ÐRbYPÙF»¢Y–Íí…¢Qw±DÆ}KÇŠ_\}ž9Žãp_C;0-Z¶MÓq9š,ø£ÿíüÀãåÿâ'ðúM2öŸ¼ÀÎþ€Áv°lá»6; •†‰…66ñFä é|Òg_Ú`ÐÐ ýhƒ^×Îy3X~ͽÙûS©ÓŒXh×ÇEbb°Œb\Ïe™Ô-‹I#„…ï+^?q±¿O‰DhƒÓxÍ¿~õUìòm,¡ÐfõøæÍúþcøP,ºsó.çÙáyÞ¿SÀüZ·oßfoo÷oõœétÊÎNõœ£µµÖx®)Ìï›ó'yÁ°nr²v<¡d%­ÀDèM²€x öüKÏ=x¡yenPÊF¥Ôµ?Ø©t“ƒÊqÃ2«Š º;ÍrÚõJêÐyµÔ‡ˆÖ¦i ­ml¡I–|ç»wØnñù}‰RXN ‡t™’¥1yQp|:Ãò›Dùm¹ôÏSƒ‰ %Ñø&W)Çˉû×ö®% ½f€P˲±M›-¯äb×âb[Ю .55¯k®u,LÇÅ ¢gÄ«Š“©ÊÊ-É3lËD``š6…”x^^w‹(ªŒVIA·ÝDÉ)‹Í:f|:Æ@3:=Ef—Îoqg2åªwŠS¡m¶ûMÖªËIV§uþ –*àJÛDE²À¨ÄQ–qŽí9´[m,¡8=ÎHÓ1Íz“ñ(§VÓ¸A‹á°G¿?`µŽ êÞ]²w®Íáñ„¬ÈP(.]¿@4“I…’®Ýà; ‹Ý ò¥ŽæøA“FÍ%\.xöÙÇyüÑ}>òô>óyÎÍ;ÇÜ;šqåÂ͆G·ßÆ2m’tIÅt·šäYQÍÆD•EIiàù{ãIF¸\‘ä’v»ƒåÖX')¶€v×ažhhu©¯ï°Œ$IRrþÂd]âz¹ÔÔ}IYz–Åøð{çw8ͨ[U€NsF£cÂÅ);Ã:¶-XFãñ1=¾ÏÁÝ–¸M—FÃ%OKóŒ~¯Îz]`»-æ“c.ì·OÖ„aFPD˯Öä[¯¿Ï¿ò*yžpë­¿$+ûC‡½AÆ3O\âϾró8gºLö»<öÈE”ÇÎ1ÐxžÁr1#K"–á’tRk6XG ¢åajße>_Ðh´‡ŸR÷ê”eÆÎþ^õüB£óÃòX,æXv“4MÐÚd±)UN»ÃG‡Ç´:¤Ä«5¶EoÐEKE¦XŽÅtÑløA‹šgW÷»2±*`¤6AWæ$¥öPeÊÉaˆaeø&:Ï)˲ҖÏr Ó¦V÷É‹¢b|lÀZ T>rõjA­È‹Ó´°‹<]“' –ãP%¾ç#µÄ÷›hJŠB3Ø° #\¿FQæø~×õB¡•¨ö5`•¤•Ç¸eœ9ÜÁ^²!LKr{aÑ­ ¤ÐU…½Ñ—¾׶|ÅÛ®È?hY!ªµF EžX¶…iUì–ÊÏD—¯üá_2ŸE\ùÜ#‚6·g`P”ng€ð‹Ô¤ç•‡4m×$Ί)Žm´¼Å÷Hb”⃹CÛ/ц†…©*r½ò¨6¯Méß&—šAÿü'qM“wo¿Â^›h4,Ë3ÇØ ­±†ä\æºÒŽ‚$IðƒúFCØ! à ÑíyH$–¨ZæÍvƒåb„Ô ´…ïÂ:Iâ®Wæ¢EHw°Ãx4Á¬÷9N3±âs—=bé³c)ÖóÈÃœ·^Ú·Iç79 þl\g?á×G–K½Ùe@²^srz„o›˜†¤ÕðÁ1–°;\¹vp<&œLi6ë”2E¸¾¦Ñhã×tž3›—Hf@ÎιK<ß)ÐÚ¦Öj‘çn- ÀBÚRœÛßåäàO?ºÏϼü<ã©Dë˜A¿ÅèdLšì_ºL†Ý që6­ ÉdºSóMv¶û¬¢’/ÿéw¸}÷€Ÿ}„k×®‡c¿Æb¾â=û>+ŽIR×k±Î–¤IH«µC”¬qÍ*y´ å*Â0}Þ~ë€fÃÁ04µÆE¶Æ·$Nà!•Ádœ°ŠKö/tù7øWØ–ÍG^¸B«i1›†Ü|}Ê?ÿßÿŠ^·ÅÏüäðÎûoò§_ÿ#¶:M.^Øá…§¯£µÇ½£cNNNùö_­ZxNNË^àv >ÿSŸFf#n½qÈëo­yóƒA½Æ~棜ÛÙFI¼XpýÆË书Ñò†ƒ&ªLñê ®>âqr4C³½7 Ý©“e£ù’n»‰ßr|x‡{wè Þ}ï„^+ M–  æ³# aÓÔ~Ÿùñ‚[šlÓåöí†äöûÛçJê.»u‹ÓÃ%õz“ù,¥çTXI’æH]!‚“•&h*’ué ·¯ ‹co÷-._Þ§ˆSÂÕšíísà I:[½êT¯"‚faX¤EÎt¶¦Ñðq-‡ÉdJ¯×Ãtë(%YNgt}Š"ƒÒÀm4;[ÔkkÒ4í7IÓßó˜NÇìlo#„IžF´ÚNG#úƒ!¶e1 gUÓ²Z)µ†*LË¢á­S0œ4¨M»Vl„—¶ëCÄ%¤ÊâÝÐa*>±·FáPd°°Ê\—›‡'|éŸüÛ3PìËÏu(M…Ù—”††R"LÍl­ÙêJ"­Ù÷DYbªûì‘j½ßBÿ¾ªY”¼yÚâ‰mÖpuÊ[ÁÕn%’§kVR3SÖJÑk¶Ù6“Bãæfž]£iÄEÁ=¥Ñ…Ä°ª©¸Á²0|æ±k˜Üèv¸Ò~‘oÞûCÜÒe»Q’„ZU8Ã0ÙߊAšdeÌí‰ÍÞ–ÄN´õ×Ãþ—Jõaº”eYQ§þÿ¤Riõý ‡Møú/\öÑeŽÌ ê–FHóLíþªR±™3ƒÚÆýDn³F`h,$Zë Ý,ª‹VÊ×µÑZá;.¥±±ûP`Vê~-0 (ÊYÄ<>s}zÆÅ :íA§ScµœPäì³Ê8×')r¬Ößáï]预Fš?yã7:'”(êŽ †@.¾4,®u:(eà‚"Íé6ZH)Ï’ Û¶)d‰o9\ë·ÈÓ˜?>Èø‘+ul{cn.q’ ´‚€²¬n\ A«Õ ÍÖDqÊVSgÌ9yšÑl66m~›ÌõÉòŒz­†Ñôé8M¦ÉttJ&Mê»}¤TÔÓ XKd\çôî‹ày럼rŽuQæ áø”zÝe2š1¼t‡ÄÉ”ÑÄ"“vaÒh÷ˆÇ§¤«%EaO¸på2¾írr˜±½½Å:*¹ûÞˆs8NƒRÏèt‡ôîpwåòì• wÛ´X®–\¿~b½dqrˆR—¯Ø¼ùÎ!_ú£Wù‡ÿàó™O2¤X°·Û'±=ööêAÀûïPoÚ ¶:D¡àÍ·o“¦pûî!íV@šæ|ý[ï°»Û§øt·ÛÜ+¯ò)ëUx¬Ó/°‰£{Øc­±Ý™ÌÐÚÁ´M”NéõÏqçöM.]ÜætTÍëA=`±\qp´-âx‰&Z®È´¬´›½J©ê\˲ ïAlÔ±)+¤il”¶¿4`ÚPÔMÁÇü† •Ag4| :C ‹›#Å[ú&J*~üå—xüÉK(ª±C) -ª S•ÔlEÃò0sͽuÅ7„i˜(rP†!(E5¶½n)K L®íHJm!dJ¬¦m¡ÈPJc¹WÛ(ÆYÊy×FRl‰ÅÙ^þ÷&1–eçßïœsÇ71GäœYY‹Ud©HŠEŠÔТ(Jð7†à•áöÒ@/ä•€†¼2 ÃZ4Ü2$¡5Ñ¢Zƒe d‘¬"k`UeeåP™‘1¾yºó=Ç‹û"2‹¤Õ-CjßM¾ˆÈ/Þ}ïÝïœïûÿÿ<Ï°…DhP¶E&ÓEÌç_ø…BY¬(FПÇü`ïÿ¦åI Yš£…@ 0H´‘ ™.·-f¹ƒ°RüÜ[=OS~ØJõäçïÇÝ~òëg¥Úßßg>Ÿóÿößòƒ¼ý²RY–ÅÇ_|éG¾/噾êG6έø䎦H:¾…Ñ)RÉs\ôGçì·9šªícM,5"Íq-‡N«½\<ñÚ~7qv" ±|žk,KjÎNÒt:FJðü*Yž³(.Z'£ݪñßý·ÿ)JI⤘WÍ!ÕZ#lQÄ4<å^z‘_¸ØÄ QFñÛ¯}/nŒIs6©ÑXZ²Þj‘/#už“&9¶]̤,rSÏfÆŽTõ‹”qœó3K¼pcÍ/B8E­\!Ë2,[‘çI¡‚ÌRÆ‹Õú íÖ*& LÆ<„1:9dº°-›0Nñ+5”]"bš¥ ®­°m‹87$qH¹“ñ€ÙpÊ|2Ç­ÖQyDÃœôQ¶<Ž3ʵðiw[ q–qéò Ç'!UO`•kln4˜1Ä‘Âr%ÅáA8Éôkôû„TìíöR¡µdR¯×‰ç)3]A ˆ£€é´O2›4 æIÊ|³ºÚåÁnqç¸6ÓiAÂi5VÙ}Øcs«Î"+óáý€îF [*<\Ðlui7;|ë{÷QRòkÿÅOÅÿóoý)ûêÛü³Ÿ~Êm^ôÓ‘f0Hbp«P­ÕŠt1ס7èÑjTPrÂhÐc­»ÉñÑÝ•*y–,BŒNè§öNùÖ«ß+þV[Q+;|ü©&—vàxhøÎ÷Ç ÇsvÖ /¼xLï‘oD¼øñç!Ëx´;a\פV÷î1b:UÃjÝ!É&¬­6i¬¶xúÊ:oüõm¢8§ÜXgÿÃwØÜèIÉ¥‹;ŒÇ#t.’4‹è µZ“ñ¤OµlÓï'€àðÑ-„esùÚ‚c.\Þ ß!•ÇF»ÃIÂ$IñmÉd¬ÉÌO_d6 OÆ4[u4šrÙÁÞYe6… FCB3[Dx>,æVV6™Ï§Ì&S´–(+bëÒIéð#“é” [k´›e¢Pàúƒ^„R)ãa‚WŠ¸°±Ét2ìÔ%fƒS¬f‹Nw…†Ö¸žƒÎ JÁlºr‚É€(Î@lÇÁv<¢<ų-)ÈsÃõë7öO ‚€ÉhHÉv1FS*û û­Ɔ½F³V%M²$9ÇC†¡0F“iPÑÏÖrc²ô*# ‹¥„T8Ÿ€åŒ—‚˜e–÷7°‰-gÖgÊl!Ιg¢+)%yžÃé.Þ;àÚSÛ<óüã–«“ r¡HEÆY8dÉñÇ)³ŽjbÕ[Ìf§ ûlßc4‰ˆƒ „¦\v‰‚“é„R­B­ê1î¹”kmzƒ1R‡¤ÄqkŒF=š ‹(„ñ¤O³UF ‹r¹B¿7Ä*×X½p‘<Ë)WK̦óñ ‹Ñ˜J©ÉÝ»osí©§¹ûþC6·ë„³„ÃG{l_¾‚4&Ó1;6˜M'L'!ýÁ‚zÕ*fhóˆîj ×i,æ”J.3Û຃"M ÃÙ[J’$&Ët¡pw]ŒÎv w© Îó"f/Ëc’0¥p\ ŒRP©ø(Sg4œPñÊÌŽãâ%#p]‹AÿÑRláû. gÄiJ£^Ç÷”íkƒµ\¤?¾nXÊbG*fw¬Ù©»f±¼° )·|—ÌýâÂ_³4Ž±íBM]°Œrr ¯½ú>ï¼uï|þ¯þÇ@©ä±~q•íW¾È ›† •G˜Ôæ–Ph!F#„!•Š$W7Rùð“Ä&ˆ¹—¼œT8¨"éaŽ íRAÞ²l‰e™Sò+ää4l›i–aS茤„Pçø²<åþ¬KÅî²Q÷ Á19§‡½×¸ÚÖHŠ¶6¾G/Öç ”'.ôò¶2a"7<µ•±ß3lwÀä¦XL=Qíž´Rý°]ê‡oÿǵR=–ÍsÊ~™®Ò ,(™Óõ3Ú%ƒ‰f³öDúãò(aŸ~-:ÏXˆ [YÅÛséŸö¨V«ËÕ‡<7ÛgY†²¬‚H#èœ$Iéç’š§ŠQŽ1 ƒá)ÕZ¤â­‘ËU†e¥XÒâµ×oóÎ{øô+O£ÂI»ÛFÙ‚þtHd¢ý >váÒ^ß=åŠó€VÙ'Ž#Ì’UëÚ¾ã-Ն˘.×.Ô—Oœ'a¾ç!¥$M\Ç[ú!Â$ [‘¸Ê! #„Ëq±)-l»à&ÛŽ&g:‘¥1J*”4œö‡\ØÞ ˜ÏIsˆâ”z¹A?·Y”žeÝGÇ{LgϽðqæÃC41ã>X¶!æ,f *–f­“ E [(Ë&ˆ$iB%D‘â¤7àƵUÊ%‹½G§lluxxû¾ï3žŒ¹r¹KfÜyï-ÊÌæctžÄ)ö&yfsppD»Ó ‰bí±dξép¡j˜ ûضM°ˆ¨V|†ýziIJõ*q¼`­[#Có{_ÿ;vòέ]V×Ô*5ÇAˆ£"8¢T­3›LYítñ]MµÒDY¥r•`ðèèˆõÕ··Ñ|ϲ=”rH’ ß÷ñ=ƒ_Ú ß?fmµ‹åV ´b.89Üãù§WyôhÊÆV…£G=ONGG¼ò‰g˜/fô¼øÒ~UqÿÁ³±¤Z“ÜúàÒq% IDAT>W®]#&tÖ+ìÝ]`»-2£2¥Ó–\¼R! NOOè®–ÉrM–úúýÝVúZ eOù‰žædTe65œÌùÍ7¸quKò|Êt:ÂhC§ã‘¦ ++ žºyÏ“¬l´¹xi‹Z½L­Vg:‰f#’0`euÉxF«# &tWÚäiˆ°%Zé8 Ë Óé˜R¥ÌÕk—ÑÑœFÕexrB£Q¥Ö^Áq¸vc‹Û·îÓí¬Ç)ë—6R’$)Nϱ°,‰ISÚk]Úu—Jµ„eIêõ aq|´Àñ§Çs†€ÓÞ„Îê –mÑl¶9Ë–R’¤9¹6ø¥ ¹ÎÈ…AZÅ‚07zéÏ•8®» Θ3!K ¢ˆZ³ŽA`»>Ëæó¹ÖäYFŠaÒï3_ØŽÃÊê*‡(ŠÉrC¦3¢$BÚÖ9f³¸V[=½¼vu}‹dÖ£— |K=©Æ5ËvøcO®e-­5Iš1Ÿ†ü›ßúS>¼{@’¤cô&¼ü©§¹tm“ýÝúÇC¾ù&‹Ê& eÊ”…Öd(´ÎˆŒÅÁ\1™ š~ÎJÓBæ# ï¶okjvBÃMFR³}²<#5¦È8ÃúNÏcµ–-wà9³8B(‹(K° xf‹eÛK‚l¸{ó2/^ý)žÙ^çòÚ:C¸Èø³w^ÅaCŽA!°‘„Z“êœ4Ép\çüœ#¹´{Ū˜ãkê. £ØÃS1{÷öùÔ?¡ZûÞ½;t;íÐ}f³Û;€¥ ìú:r9 ¨”+H©[Ú–G–.s΋v¡°—ö§°ZÊ—¨µâ8WkâÓ/’ë˜×ǵŠ¦ŠÂ8bsmýü¤”…J-UuB°X̦aÄ7Þñ©k«¸&/Š¦„Ó iž¶mÓ)+ Ë‘D‹jÕG ÉÊZiùTj†£fY‚/ÛW~š×îí#Ã`qÄv-ä ”…çxQ„cÛ´*‚íšç$q²Ì™ÖdiZœ,Š"í»^aYE`º\Š¿ò\#•Â+yXréâØ×qžD üR~ï8I¨T*ìï> Óq£G§T› ãq”Riw©×Z”j½´Ìg¶†'O<Ë¢\o£uÆÁý}ú'1~É!R*åuN(×l<¿ÅúZÏõOð|kO]£\óɃÇV„!ž„!–³E”gÔš+ô«t&ƒ!Y¢„Âw5ãñ„0 ©·J\»v‰{œàx!åú*Ï]i#²„é Çx¥Š$‹c’0ÇRÁtŽçúT›MjÕ2§‡._Ü`{«Íý‡<Ø;Ųê—FcƒébDžeL‚€›×.påÂUòlÌx‘!0!UÀ?xÀÏá%Œ,¢#ÃHcɦ–fÃátŒ´K8®Dj½Žë•è²³å“觽ÊÀ_~ëöÞa£c±¿»W.±Þmp²?¡ÞQ<ÿ‰ñJwîì±sé*Fä´ZktV+¼õæm*UÞyç®ß|–Ùé˜z£ÁpÐgµ»J0–¼ðÊu>|ð.†!¶ïpéúó”Ýœ£»#& ÇÖŒ‚(c2‹ ÏÐÚa8^°½Y²\Çc¥[GŸã£Á,Ǥ fÃRÃÃ݇4WºXŽE„ôN‡lnorz< Õ¶èæÅÅËÖx–EºÄé”n·°Uµ%nßÚ%Mööú”]M”Æ”mò,!‰CVW*ô3¤tP®Ö(Wk´š úÇx®C8‘,ĉæô0!Ígd¹*esãi"-Í|º T²ÉòœZk•4ˆ¢Ëq¨Õ*L'Sj¶[ ~-GQó}l) Ø(K ¦³mS®”PB’ÆÉbN†´;ëÌæ!YnðýATÄ=FQD£Ùâ)‡rµÄt<§Ñ¨† ÏCKˆã”A+0g)(„¢Ëž’©$& y÷´ÄÚ2Ž^½Ìˆ×Ea1[™gLǶé´Z¼ýÖüáïþ5ßûÎm’$ã+¿úY>ýÙç¹ñô¾ô /sñÊë›^þÌÓÔJ.÷ïqi»ÆËWÛ¬y筲êç²j %…ïFÔ½2+Êbš'lÕÚŒÂy¡—©=ªŽÍ ßržãØ…?Y*è:sŒRËç]XxbmˆLFS9“s%t¶¾À[wÆdi—»=Ã/¿ø ¤£p‘dþæÎDÁ=šnF¡U º˜—‘lú.ƒ4A¢ Þ¶õ˜^vÖæç\q¾´ëæ¤EŽÀs4›W¿À—?õ o¼ñ¿ó;¿Ãññ17oÞä7~ã7øö·¿ÍÚÚßüæ7ÿ?«µÿ1ŠóÖõu´64jÍbÇÏcÕõÙ!d±a<;g‡ÖJùraøÑâl3ƒ¥Ažb+·hä)µJ2]¼ÈÆp03ˆk¬7zÈHZ|b£Á,Œxç8çŸæ"JhR ¶L†}´Öø®OÉ+bŽR.ØCƳ”AÁ·¾ý6ŸýÌsØŽOµ^f6Ÿ€ï¢òœÌ’°x‡Ÿ¿ Ñö:Í ì™e–ï …¡Yk;yY°l•ë‘$ yžm/ÀP€Pt^ òŒÑ$YŽ’ÏóHÓ Wy¹(PJ L†É=í¢U¦%¿‚m †ýî:a“å)ƒÁœÕímò\ãø-,7Ä9óù”T”yª’sç½Û̧ .]»Álܧwt@µ~ÁV·É|’2‡Ð?`sµƒD£ãC’hÌ|"0Ìðœ#N4š+ØŽ÷‰¢íö:£þ‚r=$úÇ°-ùÉz“ZÝÆö–í28]Ð])3MpÜ?øÁ»”ê6ªv k­Š¯à΃ûÄ¡f'àØ>®ç0Ù‹±l˜ ûØ%ÉæΛjL's3øç¿ú ¿ÿ'oñÝ7Þc6øä'ªÜ¹ÀÛïÝ#Ë2~å—~†)—]6ë’ƒÞ˜ZÅŠÆnÝ~À§^¾Áp@æpëÞ=Þ~ï””üôg?N9« Â9‹JÅçÑÁ>ÑbŽÐsÒüó0!-‡ñdFÅsi¶bn>s“ÞiÌt2@«œƒ½1óù÷¹|ãY¾øs?…‘°²¶Æ믾Éðp—gž¹Äƒ{);ðá·™Ngøœk7·8|1 &|ÿÛßåÆõ-„•#S‡ï>`cÝbZ$óƺÈèôë_üô5NN ò·¤ÿÿú&üÚþ³Œ&)Q,AdLg!¥RÌL'†(‰évô°¶sÏ«0îqxð!žç‘å’õ•2Q Î*»bY.;ÛWé´ËŒú§Ì&#J^™þé×sØ;°²Ú¦\Š¸xù‹hÎt8 ÓäyHêÔ0BRo֙͆˜,.ºe9 ÇSü’V1¥r‰Å|Ñ‚Ð>ƶ}‚ Â.C£Ýf2‹ÐyÌÚúƒÑÏóÉrC£ÕYŽƒÊX–EÇŒÆ3”e‘æŽR8®S÷rVÅ'8_’ö½cÊ­fÁåEÔiª3šÍ¶%ð-NOq%”E¿×£R«#8–‹Sw’2ƒZª´—•ãübŒY2°žÙ 6M7*"m³ì£Ø¥ßølg˜éœ½G|ûïÞe: øÜϼÈÇ^¸J¹\@TôfbLq?… Ê fcuÅçQ’"Ó)%×°ˆ〈]$?M£ˆ …jü`ÔGKStîŒÄÈœiª W^d0gY†ÐaA®–—¸‚¦ η’°? Ñ2§Ñy…Ë«Ÿ{å|ÖŽ0L¯Ý}N5 #]´Ia©ë¹ ×J*fh‚EPœI‘¯°TŸÅìžÍ°Ï[Þ˶À`Q´µÉÙ¬líO|â|ãß(|ô@§Óáøø˲~Dý[­] <äbiÇûÑÁ³eYDa„ëÂ3e ¹ÔÜ>)ótwðCjmCñfÙ®VÉMF–e°N)K²‹€÷r¾ôœ"6šÕU !SÆ¡Í_}ñK×]Ì’fÛóq¿ ðHÈð%’?¿=âRM"Ö}þâÿü¯¯`”~ég?G¹VFMHŠ…²,l!‘ÚbžFøÂ>o?gyásܳÓ^AK0HžçËYIJ\X¾‰=×E.aŒ1,¦#l¿²÷ÊóÔªUZõûû»ÔÊ‚ª'©øe&‹úÆ»»¼ñî.Ptg¤€²+˜.4ƒQ•˛”Ê%úƒ£QÅd@³V¡V¿ŒòjœÜÀæFáÖY­ Úµi>g:î3èÅżô©u‚E‚e)úb]¸F2>âèîº+køõk\l­rz2`±ˆq½„›Û¼÷·|ù—¶Ù?x›µõþÍûïNñœ2QtÂ'æ‹Ä“Û4»"kÐ;¾Ãg~òæ£1îOqì 6ŠÕ-‡7Þ ù›Wß⳯ݵmªÍ6¦Þb8àWµz Ƕ9>ÇšãG)ñ|¯`^G˜N#6Ö|pûˆŒ˜jÓãêõ+diÂt0 Úîâ9ƒÁ õÆ*®g¡¤M’Òƒƒ}Jå¥r™JµÌ" qœe{Ôú–,ˈ!iš#¥"Œb,Ë'M ýþ¿Z¡T)3˜öQJ… y¶ ä—§cFaH³ÕÁ± £Pè$c0ã——Ê¥ìlæ,X¶^•B+Ò1­º"Ž%¶Ñ)Ï lš$¨e›û\ðH%ñ¼¢>óò ÊÊA MvfÃZ>ž"“Q-•y镧ÙÞZ'5™¼˜‰‹b1 •:/fEÎFQ´’…ðÊ’lÛ>{‹yÑAÌòbN®–à”³v¨É9WXk„XF#¤"Ï®ò±ëW¸ópŸÛý)¿úôJÖ¡—› ß¼÷ۼNJïãG“"—|m­s,e¡ b–e-Ejˈ< ççù¬`Ÿý{F';ÿÙ†rÇqøõ_ÿu~ã7~ƒ/|á üÚ¯ýY–ñ›¿ù›çB¯ˆZû,øâÏÿâ/¸ýþ­P±v½ŸþÌçžxþ„`?”묀¼R‚Á‘þ Í:ûí]Ðc¤¤Q®£ŒÄ²—s£™$~ò¹BX 3´”ä¹Á—)¿òB“hâMè<.О‡ãµø½ôøÚ˜Ÿ¿(øÁ»wù_¾q—{÷Bð?ý«ÿžy¸(”yJ`“<£Û,|ižáYE&¬c;Á©ÓÅœËë;¤qŒk9Ì‚Åù“²mÀ€%-¤$IZÀáÑÄAJ¹â!•" ç„‹B¶"¯Fnri£ä‚Ûc‹g×,FÃR©SYZ|¨|éòðÃ{H•f a4ûwL*™Â¶Y”±~q‹ ˜âHÅdÒmÕ™ & Æ3”­8zx„T.9 O?»Eÿ8#Ê#”¶Ù¿„[Ò´6ÖÖ·øàƒCòÀ`;cšµUl¯ÉÉÉ!kë¤ù€þ8ÆVÌײ©u4žWe:9¥Ýr0v ‰a‘æì¥U^¨B\¿ÈÆJÄ…­2á|ÄôäñdÎV¹‚Éftm¤ôðð½ íf™ãÀżOϹ|a‹½ýåŠK¥²J/“€NmO¿ü1>ñÂ3<ÜÝåækLF'¬¬l0 ¸z@½^b´v®òápÆáÝÂrôì5“JöN"S‚µ›L¥ÃÍ{|ãÏÿ !/<{[ælmî°w°O¥V'‹3l;BZm²$e{kƒ’ïÑëßbm³M~tLnÁ믲²âÏ|:k6½ýhµV8}pÈúƽÁ˜Ã8áêÕ–±lò0àâÕÛ/ñüKc”R,²{l¯oÎsŒ™Ñ]Ûax2^Œp,›Ï\æoÿäm‚8a&ÞbmÕå•­ðÆ»» ÆsVVšLÐã>íÎRÉ3Át2+æ‚S°ÍxlrH¥ÝäêåKôÇJ.–² FOAÇLûû@Ž²,WÒïÅ#˜Íg¤™C…¥½Rpª÷wïѾr“VÜÒ S€X0žEX~™|Ò(ûÌ&cŒ6$IÈ…+—¸w÷.ã…¦»Ù•²Çb¾ Œ¦ÓX~yƒºã/Éq§ø~¡l‚ ccs›, „PäK˜‘Lq[YyÒ]Y£j˜g9™Èi•|jµ‹,ætÔÃR’É|JÛoà8.³á1Z \ea[¡‹Å”z½Ë4Yiu˜F“ó æc±RÑjT²Àu :„ÂÊXFéžÕ¥B@Ò8™ B¤llv9:èS±]N☮eVE[Ü`°\¼¹Fi¥N® (™,Ø „´Î[Àfiã*´?œ£!ó0äá"@Úîy¢ 4žÄŒ0(¡ˆ 8yŽ± |éS6Zsý Ïìl3x­ 1V.øú[ßg£ÒGÔ’ü,hpÉŠ\æ¥N@¥¹Rû '@Tg‚\!Σ/ÏNø“Q–F˜óÄ™½àþàxï½÷νÎôGÄ›o¾É¾ð&“É?X­}|±÷à[k­e}â˜,Ò|](ñ5yž¡”õñÛ“ÇÙ @hIb4]/¡~¤0ò8Ÿ¿1—+¿þ°ÏFw­sŒx>ãÃaŸj b¤´¦’ˆ¢˜8 I³[•™ ²\ã¹EaLã)_½é0™Íøíÿã¯ØÝ;ag{…¯üÂ+¼üÒ ’$,^SØ°¤¸¾ž¥œÆE‘G>0µlƒUËåeL§SÜ’ºPOæ:ÃŽµô`».q⺞k1ŸŽƒ$I@Jæƒ>Â-cÙk¹z6ÆðT×áoÍøüªÀ$!¶Pè$e>0žÌظp…Iï€$œóàèoõ=©é®Z”¤&MÈtÆh0 â0' 5FÎÙ¹X£ßKMW³¾~é8縷K§»Â"œ’g)¶ï“ç9A–±¶Ù± òT±·÷!õjÁ·lÅdÔõlæ“„FÇÃ+W‰´¡µ¹M²˜áºeÆxŒ2ŸÏliæ³ O7â¨JozÂäø4”¤2%  ŽbÒpÈ|jVB£™3Ø–Ït6äÒN DŠmæÓîybÛ6J:¸¶@‘±±R'O#„2ôNv±l‡zÝ‚Î:§Ú§iNÙ ºh¯]\oñ·æe¼Î[˜¬ÁW*#JÕ§>ë­ üî׿À§?ù³ãrzéOµAE6ž`y>Êñ gT[]VZU@°Ø–EÆÔM†y”2õAØø¾Ï"H©Ö},%™MGLF3²Lã—*,¢DN¹ä“fY1fò ¸Qñƒ¥’‹”M ÆÍh< ÖhÒ©´£ÂcKâ gdK* b2賶±Á"ÏI’˱9 °W°¼ÈJ0KJúaÀª_¥„h 4MQÚàº."/D?Be ?¶ ŽfüÞ¿þsžùä5žûìs() ”xÜö=o¿/WgCÙ+&ñùï“êñ.í¬X]QÓlcb6yû=ª–M£<"Í5ý¹$É,šåœŠ²Ñ…7ùG« !çMŒPhK´'<ÊgAgçø‡w™imŸ½|t'üµ¯}¯}íkç_õ«_å«_ýêù×ÿ¿ªµ—çÖZÖóšóÉã#a#h,¥® iüc­zþÅgÿåKŸúÛAJÎA§9µJ©½qŸ™6YõZŽ0¾ò,öÑ’Ïyzáz¤Ðç^b!sz§#þ×ÿíÌf!ÿÙò“¼Õ}…¯}¬‰k;ŒÆF˜¸ÑbŒ‚v©ñØ?-‹¶¦ësá ‘J¡l WÙ$Jž‡cÛ¸–]D>æ‚Dgä¹Fg Q8#ŽBò,a4â¹^1?.—){qœ`²ۑتŒPª/Ic.\~‘o¼·ÏS+5’´ð_‹(D–jXJPjVyôà„“Ò ž¿öëk')²däÔù‹ûÏ­”É´¦âÀé(àòµMv{d&¦»â£µÅt`Ù ª5›“ÃSº+5\„Sbg«ËÞî#Z þÉ„õ¹Ÿäî[ß'3ï¾sÊhpØ`Ûš›7›g4½ÃCVÖÖi­ïp|°Ïêö ²hÀñþ-,P«xä®]¿Æd²¶¶Š_)1ŽIµd>ðÅ/}–»·Þ§?ŒÙ{tÀb>à3?ù)îÞ9äÃÃm4®e±³Ý¤Ru"õª<:84óyÀÅ«› ‡}j«"Ç/7y?kòùµ”¦Su=>\xl6b¤Sc1¡±h6mFã¦ÇÆz£Ã®eÏÇ­Ôȳ”,™M""§D׉Pɘ­JÎ_~(ø‰–>á[G¦rƒV%ÇwÊžD9.ÕZÅø”8 ˆ“„ÞÉ«kkh­™á"FYív—F£Øц‹1Ã~<×øåRIåf¹I— I,0Rà*‡RÉ'šÑÚ0Ÿ/ð‡\BµÒ"Ísr‘&RÈbah, rCÅ´Z]¢$)ÔÝ– J’æ1r{~­Z “„”øž‹¢Ècò<£â@vîÕ-Éûó1“¢4g6 8Žðj%l!˜ÌÜÚE»Õniš3Nc‚8a‘e4œb¨µ¦Ö.sÿÁ1Ñ,ââ3Ͻ¾öG3›‹ûŒ›¶] r1šƒÓKÝdŠe45'§é¥øÖÒ_­´]lÌ2YPHV¼ s¢Î2ÎþnŠÛ•ÊOÖ¬'þÃ=ϳ"í8ïìòÊÇ?õO¦Ö¾}ë]jÿtŸ8Õ\¾z(aW×R'q‘©°| zÛãs—&Eö€D!LÊ4”xJS Uώ׾ù:ê™—žù—?÷…Ï ¤AÁJ«C¥TAJÉt1#É2Þ4øüEÍØÝQvaN·ìó]wÇ”Ëeò<$Kã%ÆSqçî#~ë_ÿ;J¾Ë¿ø_fÞx‘ŸXÓ”D@jüj!Žç0Ê–‹ëzç«‘³œeÏqÏfKáÙ6žå%q¼¡‹7àhÒg2žjp|—Šg‘†!Iá¸n!ÿcJe,I韑†“ɌټVÄóQAS6Òs™õOxå©—¸=±ñ²SæƒcD©Ê!ÌCɤñ£þ„“Þ”áhÀúj‹I˜ðö¸ÄÅJJ½,¹ÿáBÄèÌ€pq=Ež+òLÑë©Ô$[[ ’Øe6Ž#ð¼iÅ ýÓ#ŒÑÔ*i½Aଠ¼¡]b¥êS&¢…~¥Åx:EÁÿù÷é¶ NùÏø\'$Ó ö÷qáÂ&wï>¤ê ÆÃæä¢D0bwÿ7ÞzŸûñpwwnÝàÙ…É-d6ƒŸ~†ÍN…Qÿýc‡+OÕQ¶æò¥.O=µÊ[ßQ©ú  ´‰ð\M¨­\bk³‹íùÜ¿õ:I1QÄá£GDqÂ7©Wª…­&1ŸGÔ;5le3-XÛ^¥Ó)ñâ˯0<}È£½S†sÉ"L¹÷à˜Ýý Ýf‹îFƒaJ­^¡\ñ©·Z”J^«ËûSOdtí wÞÃd § †G§t+ ß׸º^Bf9Ú’äÄØÊ!Ó9ãÉ„z³Ží•ˆâŒÄ¿Ž°<ª•v³NÛÊ°¤„dF×LÊå[½*Ÿß1È|ÈN}žÛv8Ü{Èb2¢\kaS<áÏ IDAT”D ¾çF“ñ˜•n—y²}áI–1Š] ´Q–P6 £”(O‰Ò€V³‰³¼ˆ»®ƒ2…HÕulŒ†4-èVB¡'†8-x÷‹8FˆâˆJ¹B«Ù%N¦äFRmÔÈ!‰R<¿B%X–E¦5ZùÌê|.Z€EÎíUK5vټݷXu%G{Ç ¡£PÒåö÷?à¯ÿø;ÜzýîþàÞÛÅ`¸tóï|û'û}®<{ÇwPP £,ÆiÊ4ÉŒ¡Ÿ$\¿y‘Õ«›¼úõïpçÍ{\¼y©ÎöÇOì,ÏŠÙ² =9›=+ Vâ#ÅR Ét¦iúFnõk<»QDBæ:_š{Ìã"ÿcŽóHJÎfàš(Ë8sêžçEŸA¨~œRYüÈâï;›S8ovïíý“Z©þ1Šó[[Z‚8Ž°m ³L;{òù=Yœ¡8o–Òim¿öÍ×±j®ƒÌ3”åàJ æKŸ I,‘r±Q§`&¦ó„R½D§Ó"¼Ï3ë×yóè*Í’"ñ+U‹¿|X¡UªcfÒ¯cN Ë+ô†’h‘"m…V¯öòMNv°¼?{ÍÁ>ûG‡TÊ%Ça.(×=‚é€z«Ëîî.žïc«œ`®88à8†Å\â9*Õ‹é Íöjá¿ôR¼Àš)¥R™y8g¦äÕ:Mèt`ºˆ©×Wyëß%Ï5G'Xk8ü?³‚¼û€×ï<¤U¶˜Ì3†ÇpùâOáWʬVr*Ä8õ²È@vÄJgƒ ·ÔÄqfØ–Ãb1§Óˆiùݵ.étÓƒŒýG=>|˜ò ?ÿ9úý|÷Û6¶Kì>8¡Qo1žÂ£G÷YßlquÕ£Þðɇ9?ù³¿È[ß{Gýã^ÆÚvÊb|Èl2æäèÛ±™Í7o^Âv;7® “€8œp|°ËðhÀÇ?y‘íîiåüÙNúœv…P”(u%Û%)UyçPó] NwéösVw<&óŒ Lg!ÊŃÝÏ® ;DÍ]+*”º©&Il×EJA”Ä8M›±.ñþ& üT×æ’˜0ŸÍ˜Ïç8¶Ãl‘€uÊËU¿û°ÊÇ.–ødg‚N«(·LšL˜ NQ^) žS@†*e,7ÄIL³Ý%¤%±\ ¡$QcY6I¡1hKÓnÔ0ºÊé¨ÇZ³ƒk¹dYŽåYôö¡ÛeÛG#©5Z =”—“¦9žã¢”b½Ùa0€Rœ ûì¬là8Ui!ZS*U ʵA¡ó¢ w‘kÑË.f¼ÍRþtˆ²,´<ÓÊy÷íüÅ7¾ó#ì«Omqñæ6‚Ýwòæß¼Cûò~ñ¿ú2'»}üj‘cZ(c–B4‹Ø¤–äRày6Žçpøà˜þaŸµÕóÇøápáU^îöh4¨Â/gÙ, ©6ÅæÊÃ…ŽàîDR÷K<½>Fg¹Ñȳ¨…sFÅ¿Gå´¼öG©Æ ¯BHR@PR$®g#PË¿å‰Ýý8Tmt!f“òÜnðꫯòꫯrùòe~åW~…¯ýë¼õÖ[ç„°³Û_üâ?ò³/~ñ‹ÿsøÇ8–E5Ï ÂhŒV`GªÿwŒ' )Ön<žk.>²s(2–, OÙ”\Ÿ4)øØJ)¤£'5ž[­V$r,@*Mž™¥/«XÂÍ'cªåÚoY6ÍÞþ ŸýÔs|á§>FªlZÙ-t)a0Sktq<ëFȧ8v‰ñHÄ4‹xNB–Š¤‚C¹2ÇÚê£aYRJ­€3§)†¦¡ˆH"z±ˆ )UÖéwC†ÃAèܦZÓQÕœú\•Ö‘‹eÍ!Š.ó ‹t{û‚Œf•…©=d¾d²ß2¿¼ÂÔõ0 ~ÏGREJEÅù Ý¡® œ?»Fïè5«H·R9Pˆ=ž½¼Î[õ_çñk[Ôë«ô6•z! ñ5‘ uðó€kϬ“ĵû¨rŠ®,Ðéì" !#æk lŸYäûß|þ Ç,Tâ´ÅíÛCJ•€ÐKyæ¹ó¼ùú.çÏÊdê6¥ÚcX:žï“¥YcJÆÌÌEQ˜ú3`–(|@kâ$ DQH?JP5 Çv¹ñÚ®<±ÉàDýË_{Ž·^¿ÏÚÆ<+gæYYY$KcD–Î,!‘²dùuƒã;”j–Ϭ< wµèÍ¥uË;ìÞÚÀ*Y N²ùÓ€ä³õ+Ï"V “ÛC”rIx(•yšiÇ9lW<"Ñ ‹u!}øÙ§§YÌùèÓ{zô^„l¦1‹¾³V "òÌ´ã@÷h5à4Û?=üÌ“Lú£Tªÿ/N+½‚ ÌÐõ³³¸VO 2 Sôä8IhÖæf"ðIF&æêL+Ž|nõL6k³Ý@’$†Ét
hSZ(ðàÝ”ª&V½ˆ¤¨TÊ+øb 1\º°®øDéˆb±Nû¸KØæÚSõîÜnE{¢q°÷.çž~–¹Foh³·k£÷&¬m,¡k&Rh3ö=®>÷aÝÛãí;ØSñxÊù‹Ë”,‘Îþ}DA¦Ð\ä:¿˜= °ºÌ/+SÚõíVÈÔíòØÅeì4@W4ú›BAÃ*[Lœ€bÕ \«2 )•+$qŠ…DqŠj©äÙ”©¯# Fx“/VMâ8f܉Y__Åw;x£Ù¯ €@žä„QŽb©Î[8ŽËB³Æ }L¡PÀO@á+gUZž‚,öˆÃAé´öÕ"š)Œ&ˆÄ¹J&Ȥb Ñ4Ñõ™ ‰$Š¥ÄIDž‚$K(’Œc»¸±$ÏèBºeÎĤ™Íc’¦ˆ’DµnâµF…†i&1yžaéÒ8g4c».º¡ø!µZ Y›Ñ3ÿä›?dç~‹‹mð‹Ÿà™Ï<Ž©Ê\¸|‰PIÉQ•YöX•E&QB–G<ýÄ&ßÙÜxù+› ˆdùÇ—Œ%I"?YeE~(ö”‰9¶eE!Ïfœa%S’f'¦EÙ)êù}ïÓìYÉREF΢™’ãiàf–…çÂ,H>ÚþØñHÿøôå å1W(àÅ!n”  "ESŲtZ®G–f3óŽ,û¤†ðÍüh™þôØG©ToA>öõ£¿ÿUTª—~ð ›kK«`-Èo’!Šiš%!ª,!ð7 Ði–pë8äÚ’ú¡ã²À Ï“D1íÉðDŽS rÅàùÍyòÌCÈ4IFD$IE’5$Id<ê"ˆ9ºV&ct}ÖþÃo½Â»‡üÏ¿üs4eQ$ŽS¦v@sqÝÉSìÄ•£;è¡é*)§å04m¦•}ÚßN““¢ˆA¢ëú‰E£‡¢©èFaÖ1ÉfþÄŽ3BÓLÇç•+„Çáˆ" L{G¸aB±X%TP5ÂÀ%t¡Õ³)”k­¾7%}&¾Ëdì`„:S{ŸÇ.]cçÎÛ̯¬pt¤ h&Õj`dEE4Se.x÷í=Tµ€wÔF8³Î¨³Ã™í«ø¾‡V\"îrfµÌ`dE‡{3wŸ‚Yb{ØÍ%æ#›ìè.eAÄÊL2æÉ“ŒbÑd0èS ]dY&ŽDâØ£Ù( I9;·w9{aE6iµB*UE6‘$=Œˆ]›½Ý=.l¬pØ:b®VG7樯̡:²$b íÐoÛèºEH’†(ªôzÒЦ\_" r–iQkΑ$‚ãG)z¡Š¦èè–‰ëhؾƒïGä´v÷ðƒ˜b¹†¤Ê«eövw¨— ¨bDi¾B»Õg~¾N˜$ä²ÌQ§ƒ¬¬®2Y.–é$E¬B†ƒcOYž+’ 1FµÉ u©CR;G'N¹\¬! 3êI”Ä„~„¢Jä‚€¢¨tÇ}Â(bsi…8ŒHÈè‡È4ê Ò4Å·=¼ÄC-î”U%ÍRò(EPò £3ò­ƒ"/nNÈ㔂¡“™ ÉÿÛÿñ[ôS~öç?ÏæÚ"ÿü·¿E±háØ­vÿcͯÿügÙ8·Äö¥uú<Õf²S›-äâ,D C„‡Ô(C‘°”"]ßg~qŽü?|•Žíp«m°5/ ¥îÌßùÑÿ$U›ž¸~•ß›ßû¿¾É×ÿ»Ÿ¡T¶HÄŒ<›]AšIqŠYFr’i†YJUóœŽë!(3} !Í‚Æä1©tVå?)…çˆ'ìi‰ùCýí¿d< 4Ë…PÙ "]ן=¡LÀË&¶CY•ÉÓ Aœõ·áTÇà~øŒm“ž^äáø(•êïj|qJ¥ºûÞÌþÊ©þĈ„?!ÏR²,Ç\DÃB>É¢ÿú!qyQûð„é‰'/ÿê>ÿi‚8¢n”é;câ8àÁP¦®k˜jŽ¦¨¨¢r²(3¡‘é˜0ˆÅH9º6ÛAˆ$‰¤YΕ˨ªÊp4ÆöfjAZA!KgÈ4MÑT©kƒ×ÁRŒ™ŸèIOeFªŸñLÈÓ MÑN„FdÂÐ,;A› ²„;éãN=d™xÌwÈü)N˜P)YäÌ\¡×Ç44ŽŽ9³±Âáî]$Röö”æJ\ºt‘Ñ°Çd4DLb\ÇÁwúý„ZIDÖŠx~ˆ;qÉÉ05 !ɘNg»ã$Wñ}‡<‹˜«×ôFJ25]%Œs<ßÆ2 ,ÃÂöeº’–°´X&S21&ç™ {”*s X•‘ÛG7†ƒE·¨U*$‚…§„±ÏêZ…BÁ¤×óŒ#æª&®0šú¬¯ÎF:y®°¿ß"#G)(M©8¢‘šõ ‰ïàù6ÁhŒ¤ÉÈŠÀtá¸>ºž#K*¥b‰©cã¹³ Œ?™0˜Ûà Ãe2ñX\8ƒ¡ÇÌÕ šÎ°?A2œ0¥¬ËÜÞ=F$¦l˜5™O^–¢RÛ¸H³‘òàÖ!¯üàˆ]òØ&MCêM×莦l®Ÿå¨3$ˆlj¥"¹h³un“…Í‹Ø’H£qŠ$5b{y`:d~±€(¼˜òâõšNïpŒ*ëtº=´²ÆêÆI¡XnréÊ9zû÷p§õ EËј+Í ·ÞY\)ãô#öw1•aSª*,ÌI¸~Le8Ã#^¿¹Ãë7÷Iòˆ—x‡ƒã1;{]4Ý`:bȆ"Ç!Š$P¯UAÈ1LÝ0ÑK*¹ `JX¥Šf¢h*ó‹uâØ'‹"æjMDÝdЛÚ†&a÷‡¸¶ƒièÌÍUgziŒ*J¨ºA1‹ÅŒnZd¡QBÈCòP&Í#þ¨Ue~m™íºD-Ÿg"~8Ó¼¶m—BÑšµÌ$,Ið"I‘éOÆL ð@‘EÇsðBŸ p3™·ŽdîDæ„Ñ äæÛ$ȼ|oH,«ü—J%ÇIøÿûßÑ=ê0¹”JE:Ý ÕrgŸ½Œ¢ª´Z=Š¦h,×Y<³Àý›;Ü¿¹ÃêÅ5šÕ ®?S(+j:A’ÈÂCªW.ŠøÉ,.ê3·»‡`0Ä4'=é¯4ã|”öô(•é£ÁåQºÓïÍD«òüô8§BŠrrº¡cY:š©"©2H A”’eA“¦aR®VtáÄ%Ê¢T Lr†Ã!µJ™V»7óœg(ÓÈ·‘=«lñ^Ê–ˆ©\])2óPö¢”L”ñƒŒTznŠ¥LÉü®R6M¢$B%dIBeÈfØYQ‰so>(³YÉX)ÛlZ>ãTA#AQekMæ4›óKóüöo}‹ñ/ÿŒWx“8iµúììóù/|’ÕÍÎm/â$)Ã0%mœåùçÖxþù <ó‰+J« ¬‚Eq~ž/}á{»mŠE“§Ÿ~Œ©ã2šH²ü!¢|F]‚ô”,Š3Ž¯8ã1›ŠÆØu5…±"媜R/ŠbÊÛm“j%Cy(NñÁâlMæ×›Ü{ëï¿~—ÇÛ ‘fɈ8ºFå Bv¢!3)Ц¨2HBd@@¢.ËØyúЕïTä4K‚Çà4:ŸŠ—ÌŽ|d!ð¡ßO ‘N7-¢ â¬d.Š¤É¬ÿ¡ñÂü!šG²\vïìóü“ÿñÐÚÿaƒól“Çš¢ÄËG6A¢@„¨ÚG.(ÈÜ= ¨—dN{ ¯¾ôÒÓO_ùÕÏ¿ø)ÚGIÄB½‰®hÄQŒ$L(™²¤"K3N`EÈŠJ§Û§T©`™ 3&JsIäåWnòÏçÛœ?»J¹\`8#ɵZÃ2É…”,;émˆ9ýñ5¸Ñ+ÓÏæÙêL 4iŠoÈ%Y•ÉI± ‹$IÐuVß=DQ`ÐR©Îá… \{Lê{Œ'.º’3¸Ôj^ã1¦e!Hy€¬’G>19¾­à6Kk‹xΘb¹Bç°C†ŠqšS*/ÐN(D*Õ9~ °ué ’4c8‰05Y/ Ê ãagÔg<ž"É I’”æ·ö H15ƒÅE‹Izƒ šV —Ô™xŠ¬¦9i¶ëûÌÒ<öxŠ,K¾O± 1œº¤a@µ¹@¥Hjéôsg×HRŸ8IS‘ZÍDQ*$±‡¬¨$l,—è·]¬ÒÓɘjEA/”H’„ÁÀ¦Þ\À*Öx÷æMÙD£@œäLFCÜ(Ÿ ˜$—æÚ}¢$ãw¾ñ§¼ñö-zƒ)Q<< F6Ï>ó4Yâ°¸dQ04TUâÒåMÞ¸ñ€©“ðäV…ÜKøò³Û쫼±h°°ºÊÖÊ<Ѩ‹¥IÔë5&½#Bße}³Jà‹±Ã¥ ó œ„`ÔçðpHš79<°¼¨Óë‹œ]hu§ìö|––¤4`s«„†DŽí‚Î+7{|âñ ÛW#ôÚ¬,,°±œsýé¶6+|îSç¹tÆ@WrzÈRÚ=‡×nìðɧ·‘Ø;ìSo4鵉Ÿ‚e2²²ŒZuf«h …r‘(™•K C¡\­PªT(W+è¦I¹R›óæê5$!#ÏR’\¢ÖœGSTªFÈ3¼dÊRUåȳ¨ªqœ#߸«0t^ØT©I)oŒš¼9ÔÅ uyrRñJfHiDò4c¡Ñij=n E¾v¥DÚÔÊM&±‹%‹Di‚”&䔋MŽ;üÁ|IùÔó×ø¥öuúÝ!ÕíËL4kk5:öÈ)$怵ʦUáöþ1õFƒã¼Ê7ß™’2AS¶/¯qõò9²ü8 Ê…“ Ý)ÝçƒLO–eú¾O?Ë(ë:±0+sFŽ‡(‹²J&œQ… ‘„ESÄKLd9€|˜Ž´¶G~Hs­jj´´Ée‰Æjcv=AeNÈ°2wÁq IDATÞ$BŽ,‰Ìi:v#‰2¤~fdÃJIÎN}$?T„ü<}ýq@±G3íGÀâ(úÀ•éÃ1ëá¹?ñ99ìßÿK¥úœO§‘ã¸6–þ“åï8~”N f1™¬a*ÙÃgÿêK¯!gyN«ßCQg8IbTiæ¬ %QDÂ(@VTvYYZDgžÉä9Yáçßþ?·ÂÂBÏ (W›H’€¬8ŽM%ÄyŠ(ª€ T×®óÕ å¡ý#Ì }×áν·X(µ)kÊ!ÉQ%‰þ`@½:3¼PT ]éõ†lŸ?Ϩ{ˆÃakÀ™Í33ŸÙRÛq1ËUVV=EVù!‚’áÛf…#§O¹iP² ‡¢Î‘\;@Wd„,c8S«fK ®ãúJsÞ{÷Õj™Í‹L§cò4Ãõ',­lžm3J!«6‘»8ÅÎ.Ö{2¢ÛöeÃÔŽÇhZ„çOQ¤&¡ï#+9‘qþò vŒ¨–Ž{HbJunMÏ }{dc»éhÄÚbƒn/¢RÑ‘UÃèu¢´‹z”J*Q$“ :dIŠ”f­"¾ï`¹¦e°¾*Ðju)”æ05ÍPöHrÂ`Œ.[(ŠGoa“²Ýfwߧ\«òg/½@£¤r~C¡TXáÆû;´ΰG¹±Äña›…%Ï}æ ®ò=UA”ŽC>óâîÞ»…¾¿ÏWL“ÖAÌجR"²êX,m,ðü¶…39`rÿ6wwö©Vç¸woˆ¨Xµ&ÏêyîïîóïÀתŒÆCÖ7×9Ø9FÓeŽ:Ôç«Ì7ʼ÷Î1ËË&‚¦³uf™÷o¾KäøLÇ=LÙ Õ› ‰²èâx ¥‚Åp”Å6qÍ$MÜi]Qõ ÆÓžyú"ªÚâÓÏ®ð½W{|êé‹Ü¼ÕÆmúãËÛ5^·ÃbU {è“q‡åå bAD–îîîrîÌ‘7 ó<2Mç‹Ï&¥&©;áÏ_òàÞ[ »:?ºµ À׿|ÓPùÍß}™ÉÔ£^+P)›œß^ey¡ÄÂÊ*Qœ°°¸HèHª‚ç»(òi_8ɪ„^4ñ£˜A§‡7 ‘¢h‚,q¾ä³Øœ'ÌaÑÊx«S ”O¹ÝKø§×ªd$iRÂçW\òl¦m{ˆPÐ äYŽ.é´†-²4¡X*sA²ÉBŸ¢Q IÔLa¾Ö ?ÉVó<Çu'üþïAø_þ×_Â04$Aà—~ñ§™z.q–±Tm Æ,Áe‚8BRÎ-5±§S–Ô€_¸¢‘g ÷'{=•ËÕ)ï¥,–J4‹¡dps$¡““%ü™²b–b)2sšÆ¡ã¢æ)óšÎü| Ûö™æªI.Ì(©‚B&&”Ä·:*ËVIÄ÷þíKZÌ/<¹ÅWþáO¡[úÉR.)‰¬¡„ÑÌÏ€™Ú˜¡¨(9X’ȱ;%OsReFsÍ2ñ‘~ò£™ð«îIÐ=¡§~ÜøØ |rl&Îò¡7ÉŠgâUWÆ?¥R–Êê†g³#ÀïýÞïñöÛoó /pýúu~ý×AøÙŸýYÞ}÷Ýÿ´Tª‡9}ž ="£úѹyÌÞØäL%%$šfÆ4N©¨XkÊ‚ °ÐhrÐ:D–$”“’L§×ã}·Âçª"i†Iš²º¼ˆ,KˆùŒþàø!²">,÷lm.†Qš "îxJ&åLâÇ@Lu>óä3Øýßý zÝ+kk$IBÐeeí /\—4^º}“«a ™RîR©5 †Jú ÇÕùl{„;µétÇ,­¯á™(¢Ë i%ËdÒk3Mi¬®¡—jÄþˆ\иÂÜ‚E¹Za:" *A1NN|­Jœf Q˜àLR*åI‘©Ï/p°¿Kà{Œ‡¢$&ðªåyâ8A$Œ¹&a§‹7xŸòœFµ˜rpïó+óÔæ¤iBà$ŒÇ#*•Œˆõõ9÷‡¬¯/ÓïM¨ÖLîÜ:Æ0%¢u I•ˆ×Ñå2‘Û¢V®‚R%œ  rÚíc C"Î|ª¥"÷”³|ÆlcÕ  íV‡4§œÝ®q¸×¥Ö,Ø …BEÍÑÌqV"?" G‚¥³¬…„R™Ðóx°ßB ¦ûÌU œ Ë’a¬âÙCÒ4g4N ‰sŸ(ŠÉÔ”+×.s÷í÷Md‚ fcu9Ýc÷~‹,‘Èéñä³×èÝ¿G˜„$‘F¯²¸xÿøuWtjõó<õüÓ¼ûÖ«œ=ÿ ;wyÔfËT¨Ì5ÄaäÒî»l‹Øm•…•îÈãòVƒþá•’IayŽ$lòÊË?diµÂ{o©Õ-FÏW)—Œv¸xñyò¨ƒ—/r÷í×(•«è¦Œë(W5‚Èe±1ÏK?Üã̺H—(œÙj0¿d’&‡Ú„U.¤ðànŸÕ…uŽü ã;?FÑUÚ¶DBÀvcDLùÊçk\Ø®Ó=<@R.\¾‚, Œm8 8»QÁC›?øÖkºÊsOmòøÕ-LF G6¯üø_¸~‰4“ ˆ³[K$™€Q(ÍŒ  Y]! ›$QL.€Ç(BÆ\µF†dyÊ·öŠüÜ–O»/¡‡&ß½Õâ…ÇV( %R9AÀ \Ü8 \*ÎLb|C58ìµqã1{NÈîÈä³K#{‚¡jXºE³Rƒ4#I“‡\XÃ0ØÛkqþâ…²NÇtzJå2ÍZ/ÐéŽz,ÖæÉÓ™cSžd'ê_P+“¤)ŽçD!K…}¯LG¨ðì²C*¤Ä©€.¥<]ÍiÖ²Á1BD4)'I"¬<%$¦yŽ•‹È’À²¥sä…ÈäyB–ÍÚ„Q–që_ÿƒõy>ñ3OóÅüSŒ;´vºÝ;æö÷¹ýÆ}¶®m‘=w‘âÜL"T–òüÔôA$LRœ8`"I é@ü³ü0j äŸù~8ŠðÁ9Ãñ0Š£#Áà“—®ò›q‡ÏÚdYÊÁH§²1s)™´^&ä¹€,¨Œí)™ ÅD óC°Fã)º¥`h*סV*cOFd9ADs®ÌŸ¿ô÷±µ¾Œ5WFQEü(ÀKB„T Ë6/^YùànSøÝßúMîÞ¾…$Iüè¥ïÿÄdVÖ7xîÓŸaqù³L‘;;ûœµï£Ëel'$ #TÃD&%ô!Mֶ蚂,Ì éã©MµVfjûd”ÊEÂiɪû"öÔ§>/£*sz­/˜°QZ@^¬Q­fk« Gi#ËIà‘Šuš «¼{ó&¤é,ø>²¦“§ žÛ#ÇÄl§‹¦Jll/ss ³6Sm˜ZÅ­n›¹ŠN0·‚m©¨BÂkžÊ¥5 ÏóÈäÛõ©V+$qFuTÍ"—4J–JêKdŠŽ–Èr]™ñCû£ [ëu´Õu&‚†åiÔ%žuèÚUƒ2!ÅrgÚ¡\Ö bD¥B–†øaF±R Í¢8Ûh.oÐm“ãÓ]>Ï%Á!‘$Ž÷ö™_\¡ÝŸpõl‰Ç. ìÜ!oQÔ^|¶ÆуÛ|ûõü÷ÿèç9ìvxùG7¸¼­r÷í!õE™…• Æ[÷Ðœ7É$‹ÎÑ]¾ö÷Ÿãþ;÷™º¹”Ó=îàúî?8 TK(5VYÙXÀ›’Å o¼ö ÿåµ-þßÛÏ,UH« S FHû¸…YG,Ö´Š©£+¢ª³ÿîRÖW×X^]½BÀ…‹5z8îìrfu‰~çÕTxÿP®Vyõæ—7¼õæ1ŸùÜÓïß…hÂê‚LµªóàN‡Z£†c{ˆÄ\ºü8’&¡+SÇERäÅsü?Ý9~yiŸ¿È׸zv™ÅXárn¼ô6/|îP {¨à%|9\&;[xÿÖqçáç!|У~´ŸüèßÁøÑ~ó£ÎTËõÌÊÁ¿ñ¿Á¯üʯü]©p‡?øæ1WQ”û,ÿU£¾¸ÎÏ|ýþŠ¿ÈÉÈØ=ê¥&ÇIK‰—ß½Å'·£™Œ(qi ü8G?™¶, Ðë÷Ñ•¹Z8Šq<‡{Oo k8®GD‚+ºÔšUò<'NbDQFUZ#¦sg™oÞæý;‡œ;†g×—èMº¢„, dxvs‘ñpȾ÷]Ý.¿ðOþÿàŸü·(Š‚ªidY†ïy˜ {:áî­Û¼ùãWù×ÿßoñ‡ßø]^øâ—xág¾ÊQ¿‰3½ÍÙ…¼þ.IâúIP¯7A´(—Ê´[6Ïc4R.•ñ\ŸÀO‰¢ KO¨ÔjøNEñ½!»÷\ºƒ„¹šÀ ÛÅ÷-¬roþ˜Í3X¥ ƒá„X”˜L<çóóu\GÇ÷<Ä|‚&ÊžO±Q¥Ûíâ¹#´‚̹+ç¹·;æbÁc<S/ ‹2‡­,¬QµÆ^€;râ)Ÿ^)§4 DI±}HO#aZÀ,xDéÃZ£Û°°X¡\[¤ÕïbH&‚0«ozV,Ap¹Ýïðý{&vÄ\­L-xGC¶66H³QV™NŽ©ÏÕ¨V,‚8$ˆR––Wˆ¢ˆ^g„ã¸Øõ9¶Ò!b¡†ÇèæˆBQ£–*üÔ'Ïr÷ö{(âE¢¸KÅq\ŸÈµøý°ÈŠ&Ó(kôǼõöMÆSE†í³+Œsˆb›×_}™Ï}ñk,®lÒ><àðð ®^­0nÐëç}BgB±¤³¾q$•«O]fÔß'ñ&üÙ·ßáâ“WYX®‰*?µÐ楽ÎÕ–É“ȉS‰3ËˤY@«Rª.°¶Ò w]lÏ!IRJ5“AoJ¯uÈÚú½Þ€Á MsÎmYX¦Âp˜"ª!Ï>÷8o¾Õ£PÌHâ”…å*ªaqåêeÇfo·Í… WÚ?dùÌKóó´ÚÇôG¬.U0¤7à·w,þ›K¿ì0ñb>W›PÍŽZÞ¸™ãÅoßxÇ;ÏÒÊ ãзûÔWÉr™ÞÈeõâ“ÈBJ.ëÔ«E «À™Ûïí’f*QbU¾|ý,wvö9³UãüvD¥j !óu‡Á0c8²ùÞw_畼ÍÂ| ×õ¹xqƒsg׸|y“woÝãÁý#,Kç©'Ï¡ë:¡ïj*²&óµKu2Y¥7!Ë)+ ]!IÀ §z)MÐ$‰Ø3që€rµÉ¸ÛA5 TêB!b:2ô9:±»{ÄÚrIùôó× ÏH‚¢aQRKˆ¢H¡h1žŽ‘4‰ Ñò/ˆ Qä ×õgv–ddIFàeäYBɬàÙCâ(e˜fHš‰LÉ)I€wGì¹€MY!2È2¼4AA ~(ù”±ïz¬Y¢,A$d jŠŽdüÃúe櫴€eEcœ‡xA†$‹4–ëüìÿøUî¿uÀ[ߟµ‰Æ½1£îˆÛ?¾Ãý?} AUq¢ˆ\gæ@‚tg¡â£IˆŒü§R·>Ôÿ>áh#òðk¿ök‚Ào¼Á3Ï<ówv¥zî¹ç8Þ¹‰Åðouïbaõ¯™ÛìZRó!oýá{'ß…”l̉ˆ' ¤ª$?ü~¤ëןûÕ/}ñ:AR6 3Tn<åêÒ»íc‚ÔGLEEªEQYbGCÊŠJ.ˆôÛCî1Ƕuά7qœˆ—^~½ Ó¨Hńפüøßà‰çžãþÝ;üáïþK*Õ —žz’¢iñ÷[¨dDšÁ¿{‡½}öí)Ç‘Ì•g>ÃÏ|ùó¼ÿÎM:ÝÏ=²¥P)Ísoïΰ‡¥ÉhF‘b©Dº(’ÊÁA›étLµRc:µ)VJDaH¿?E“edIÆö}L«@8øLF1²,å)Íf!¦™àŒïSªÖIR‘A¯ÃxØÆ]²Øa~eƒÉxJ·×AÕ%üé˜(•6²R´˜›+°õÔì¾}@³V¢Ûå"ßzÈ;Z*¶ÌÃ\Æu&HÌÕ ´ÛcrŠ z4JåÚ"Ë—Q¤˜ÉÐÅO]ŒÒÛ›«(bÌîÞ!’ªQ)–±Ý ¥Ê"b?ò°ŠsüðÕ|ï•›¶ô‡cö:Hbη_z‡½Ã>_øì 䊄çO([&SÇ#öStË"f&$aì$1š"¡)eꦇ¤V û¦I·7à{ñ&kg‰ý#*¥óL¦T½ˆ ˤBƪ×!ž¯P“==.Ÿ] ÙXE’Ò(åŸú o½õ>Ë :iRâÍ›¯’¥ ™#ĬÄ$.ÐouñÆ}ü(AÒ=.]ØÀ²nÝ8æö­#V t‡CEÄ´òŒfmÿýí*SJ¦JìkE…Þ^oæO+V¨­Wâ’1ßþãWXYP¹w'¢± {!ýAÎtaš,žÙ懯¾Å¹óM¦¶Ãƒ„×Þî1èÙ”‹)_i K!ºQÇŽvo 8léõpéâ"Ûáõî°µRcÐi“¤!w½y&íw˜÷ÛÈBÆq¯E¡ª“‹þøå]$s‰íóË•WŸyß茺|æÙOP,ÈÊôb…õRlS1uFö£XGL¦žË Ï_E7>ý™ç(•4üTa4áù1¥j‘•µºÝ>O=y•gŸ:ÃãW—øú×>3òî­c|?dÿ Ãý#ž}ú<òÇ?àÕ×ïb™2Ûgøá+7˜ÚÕr‰W~ð¦¦P+X”uzÙ$uÒ b<S«6È—$ñ qžÎâ‡-zý…bù„®$à8I ÷wŽøWÿæû¶†üôW>ÍõëOb&a“„1¾ç ä1Iä’E*) ^ Š¤Q,X·ˆ“]3˜*Ï2ÂÀG–r¼ BR,4à %§Z­à8Ó™`Š[UØ·neΉ" "%IÃËS†®ŠÄ|¹LÛu™ä)eE%ÍDLAb% ‚€¡#è EMGD¦ñLäEf€ØÆòW?y‰Çž¿Ä•O^Dµf@1UW©-T‘¤S´õ‰ûÓIÿö£æ ?QN~äø£Ùô£¥é¿4}¤§úhßø£NSI43¿8U7{øù¨=z§çîß?àù'>ÉOÿôOóâ‹/²¼¼ À… xá…X__ÿ;Q©Þz㇨øé?nj™‹Wž~’JõÁ³™ýTem†;ùý! ìa R"Þík,.ˆ¯¾ü:Ò3Ï^ûÕç?õ4Žïb*N€({fƒ¢¤“È)UËDtdAÀÔ D!%2FC—·l™Ç´!i¡˜E®=µÍw¿ó:—W¸ñ昗ÿíQ(•X~ü\ÞÚäó_ý{<óìóȲÌwo¾Ã¥ÊË¥=íòX3ãB]árMãZM`^ csþ‰-”•Ç) ¼qÿ>ɈåŠBQIˆƒˆ,òI¢I2 ÜËËóçô{jõ9ZG¬¯¯G®ëQ©V Ú4æšL½PÄЫŒÇTÅbnaƒ£Îˆ¹ÚŽÒï´Ÿ­³u¤X¡47Ïp0@UrT¥@è{ˆB@Ѳ0 Ž3¦2gr¨,àÝßùÿ™{³ Ió¾ï—wfÝ÷ÑÕw÷t÷ôœ{ÌÞK€K\DP Ò ‘R„(;h‡ÃáÉŽ0_#üè°ýäðeI”²@Š‚ Ž½Ï™Ý¹§§ï³Ž®3«*ïL?ÔÌì,@ƒŒPVtTUgVfuUuþëû¾ÿ&¹±›Mþãw~Ìðxë´ÁÁÖ6‹só˜f秸c  P Uך6Iç1 ‰%e"ˆ,Ëdó†Ã!û›íI8ƸmAHÒˆa;&ÕjÏ•øá›â¸g}ž~ržû»}Z_~å"¾ocbFŠl.G«Ù$“‰Ó팱íŽc#D ‚7à4U#c5©T³ìlÉ°-ŸnÀÇ·ïºä³ b‰–mbû.Žm‡”§$bÑ¥0G»{‚¥é›§ÔO¤RúýŽç‘L$°-IŽè7X®fIæ×&6§½.³ "²<ä Ÿ‰áð˜^[d{³M±#Ÿ‹ãzP™™F–N›ÇŒÝ3ú&?è$±œmdÕcDÄÈwñBW´X^B‘#öoÜäúí½ž‚¦«ô{!æÀ¥Þ¬# ªì±»×£3ôˆk*7·&A1óS"çÏf£ ãQƒ¹ùiFã>¹bŠnߤݰ˜_¨±qï€{wtûÃ>! O\¹€FÄÎÖQè‘LÄ{{6O]š£š;"«y(¢ËÈòÈ â {t»Crù<ݾI«Þdcçˆx"O!¥0[R‚¸*“H$8jœ23›#tÌÌMS›)SHjt»._¾Ì {D·×æâÅ D‘ËÚÙEZ­>FŸ¯üÞï2}ö2²ªóÄù>óÂy²Ùùl’W|×ß¼ÁÛïÞbk»Î;ïÝæýn23•¡P(â:c" “/a™mŽ[Ô¦g°Ç#úƒ!Ét†@H犤³9bÉ!ñDB‹|>¦É|ù‹ÏJ§‰Çã[ÚT’D"N"nÐétÑ´ Š* é*B¹tv’¿†ØŽMmªŠ¢@D@Âh8"Š@”×#Î É*^ + 'Í:ˆrœ&FJ É'<ÞmÄX͆¨¨ôÃÏe‰ÞxDLVIk1T ëºäuƒ½±‰+Á{¯^¥¾[gvmÓµéúÁŸ’ñ´A"_Ér´}Âö­=šûM¦ÏL£Hò#ÀûikÌGD/á“áñ‹ð0>Æ´þkgÓ?µþ¡®úñë‡ë=×CQ•OžËãýà¹ýL`† ü­_üm³€€$KHLTN<ö:LØÚŸð¶ë¥”iÂÀ“i E>zû¤çŸ{òk/¼|?ô"‰Že"E:’®PL$E™ YkÔ#pM@Àìx³§±¢ô¨Î-#ª‰T’¿öÛ[G|éמÃlvùî7~ÌÜÒ~ýï¿L<ªóƽóÓUÞ¾ý>ªµÉlN&—L!F²¤£HŠ¬Ñmà!ÃÖ ï\»Ã{oÜâsó˜œt,æʪJ¹‘C»7ñ N§cDìíœÍ§H¥â4›mÊS<Û!¤u<$“Ká¹ö(ÂxÄ“E,קÛí!‰.½qH«¾K©X¦qtˆ³(cdSi‚0‡’,¡é:çà»>VgÜ¥\.Pß«ËÅ)RÜ¥Y :ÄËU¬Þ€PN²}ïRh’ÖM¦ N>çÎÌ`2£±G"áaö9$—J#ÉYz½:®#£rʽA™¼2 ß±IeR’ŒmwôG,,Qµ8ÍÓR$.©”ÁmnoÒaeAA–ûäâ "!Η?[&ž(0òÈòÄÑÇó<Çej.ï„$I≠æ!~i†I¤Ñi!yù¢ŠeEï³°8Ïöö%deeËñIg2 †LJû<{¥Æþ^—j%Å«ÃE^*µ ³<["­†ôÌ>cǧÙS«-ÒL:#sósŒÉsÒ8B•Áu۸È©j‚ÆQƒ£‡Ã½>sË —ž¸ÈÖæ&–íSœ©¡ ²1ã£=¦.°’xu3Ë“3/_¼Dè„TJi*¹2¡¤°}ë&\»Í3/\ šÓPµ õÖ1Qè+Ê”«3S%>Úè°:Ä·añ÷>¿N5î‘T}4ÙÅòáZ/†+ê¼òÂyª¥,ÓÓEþáoß÷ØØ<âÃk÷yê‰9z½! c2#•e…n¿ƒ$:bÆä²Bo@ã¤ÃÉQ‡7^Ÿþ¯^åä¤Ég_¾L6;1|0Gòùf¿‡$OÆh–í`Ä8îE’‘Ae At;Ø–Ãxl3¶¬IX( "–í ÊÆÄÝ0ôi5›D’ˆ¢L"%l"šŽÍœ‘ mÃTÜç'‡:ªj‚ á‹RsA9 IDATá‡ÁÃ=lFÃ1?ùÁ‡óIdYfûö>GÛ'L/N¡ë:‚! ëÍçïG'|€"™…µin½w±iqç½{Üxûö¤>]|äô5IÚú¤}¦Ÿ2á/ýÝÏs·ú”Îù/e²ß ˜°óåÇó°¢… Éï¡DíaåüÝï~—¯ýë‚ÀÜÜßúÖ·øú׿ŽïûܺuëÑíÅÅÅO­{X=ÿUËß8?ÔŒ{¾O<–àñ©Â'àüÉû+2²$RˆEdô€BLâÚ»ï#¿¼öµõs ´]IÎ"†mò¹""BÉDœÐs‘ ß·%™Àµð㳬çZ­ª¦K%ÇüËÿçÏ(–³<÷Ò:¯¿Û¥S?äwþ«_#¦‚À\Ê¥×Þ#gxäÓ94YF@Äv|×Çs}B? Œ| ]Æøão¼Ãq½ÍÊr]‰1ŠB²z„ïD¸ÖˆF«‹KRª”膌mŸ Š|~wÀìÂ,Ö C»%`Y³`lùh±šglY¦ ŽYœÎKñ܈(²4[¦×÷ÑâÓ ]«×àèxÐß IÆGÒeêcôlÄTµŠéx¤­>¡à»"o}x‡ïþà'<ýÄY"ËfqÑÀê4{µRŽ™Åþ‰3˜š-“L%é´Lã:†ž¡Õ1ñ›3•j"Käõð<—x2K$ªÌÖ H¢K»9@À§:•ÁXè1UŸ°ñK©I:W"#iºÌ{7šx¾ÄTµÆphRÌçñýŠªá ÀÈgi6Ç4ŽèM%gPd‘еIæŠÔ‘eŸx<ƒÙÚ#IŠ2^ `‡w¹òÔ=sL¹´ÎÁÁ1a&Ëåb€.¥" _™áÂ…'HÆCÜqfÏ% Eâ D¢ŠeY46I¦2LOÕèôN‘Åá@§ë1³$“J—‰d™L¶ªD*UDˆ´ds0"•«aÉ&¯oz¬Ì ô·v‘¢B±Êææ}RÒÄ&öò¥uFý¡'rõ£û´û§”«:—έ³³Ñ"™‘(æTöNÆ„‘ÄÉÑ)¥\–™3ó4šGȆ@»Ó&7ØÙ H} =ÅìÒÞxH½’0"béa¢‚,$ÑæŸl’P$ê§}nß9¢ÝrÔrÙÛugŸY!žJ¢H [Û{èÉ$º#ÏqÚê ê: #A ËœZ&—–ôܼ}€$‹$²Ì®E¿3a»v­êÌéÒ4•r‘ñ¸Ceö ®erpr‚9ù|÷‡÷iœŽyêò2ç×çYV¯ÏØ 8­1„KKótÚ{ØBœ(¿ÀlZ%W.‘IÜß:àµ×oðÎ{wyýÍ|põ«KÞxç6_ÿãŸpwã€ÅÙ<¯~ÿŽê]îÜÝÁq=nÝÝãß|N×dy©Æç~åyòù4ª† ÈQ0ñív1¾;X? ˆ"IQ<!q]-¦!H*‚ #«:²ª¡q$IAR4Í`ìZX®Ã`dI h R$`†×Ee†Ž39)‹PM88‚Žã„È¢@$‚ëøøBŠ­¦N)îðíó:ÍÝî\Ûâæ»wñ½ßóÙ¼¾Ã…Ï!ˆâ¤r>ÔOW¨âľS’¸ðì:7Þ¹ýh]¿ç°úäò=õƒvõãlíˆOõ§@åçÜÿ+ÁêAûüáþUîaôèË¢*Œ‡ã‰Çc-݇¡#k›abÑ,Jâ§Â¹zõ*—/_æÛßþ6¿ÿû¿ÏŸüÉŸÐëõÝ~ñÅ?µîÅ_äþà¸zõ*ßüæ7ùÎw¾Ã+¯¼òÈ·üo§rŽu0TE}ô•>ç‰Y‹‡/jh„ðpü LÌW&:g?@Je¸w*p)7"¢iŒ0@R%EÁ¶†Øã1Ž‚013èt:r›¬`¢¨‰DœV¯ãx¢À—~íYvÇ3,MÛÜÿî޼ť'ÎPHgȦdBÿ§ª¶9"UÈc½þ)a¤3YxžÀ—~å2¡¢ ÂÀ!¯Üh§YÑG$UÅHrfi ³ÛB#ŒB]Wô:(²Fë¸ÇØb¡Šº´û#ìQQ¿cKÄ0M]•q]‹—çغÌphS›]`Ð Ø?êà†iNî}D¡\B\Dk¡h·nìðìKHG Îç}ÂHYeýÜ­“CÌnÛö£6£¾H¿ & Œ²1õ餒9†]\I£˜ÎsÒj“J‡€‹*K Æ>™L MU9Úß$›K霶ºÌÏfØب3;C”tæÎÌsÿ£[|æW¿Êÿý΀ßÒöè¡¥àÌrš^7dk·cµyj%ÍìL ÍÈñöëÆÚ¥Uîì7ÐÔMQŒ,¹O¿o!òé–i¡µÙ2¢‡;-*3§ø‰ÏF—u2‰4JÁcowÑÈ'_б, U—°-‡T>Ëõ;?á¤ç‘ØùÊS ´ÄŒahS™]%¦+$Sy,Ë¡Þ8 f(x²È…µû­ñø=¼HDõ<"ÏA–ó¸žO±\à 4uDÁå‰ ‹¤“1,Ûã£[[´°‚¬'é {ÜßÞ§–“ùñÁ˜<}žÞ MëD$_Ò¨TÒô»"ˆÓó«xî½ÓSÚs§Xœce-…¢Ç©5i·$¤Pgì69ÿôYD#I2“⃷Þ`íⓈb„€ˆï…¤²UZÃf–xõúm^^Ï¢ˆ~Ðèt(s˜ýO?}‰awLφBVà ÷M¸°ºÈÂÂ#sDµRdÐï"©qÒñÏ¿ðæ ‡¢(üÓÿþ·pCùßþχçùTJLs@·ÕeõÜ„ù.&sLUkø‹ç$â aàrtpH,£XÌ2ª›¢— ÐèµÉ&2Ä4…áÀflÐT5®I>§B±xœ0 ˜xQON˜!†$ÃØE*©Z81àð9ì·q¢€éX‚R5 +Åyº<$dn¿vA’øoÿÉoÒY̯þ&Ç»u*seD-" D¶Zóy 5 @Ö zðÙuAP}\!DC ð]dQA‹ÀfÒ5‹0ö©ï5 ™èÁÃ0$ ”øyøMÇ?Ãô~|“‡ZäÇH]¯>6b"Ñ}ä™-|ÂÆñQ…, HS±Ä„5L:énZ?ÍÖþ› ¾Ø¿ÿÓ¹þÏy1>½ô½©OÝ÷Õع½ÇÌrêB……õÙGÇ<:8æt¿Íö]]“ôOÿw?Þ Úcý—ž#'ù×ÿû¿}´¯åsKTfJ\{ó#¤õ+/|í¿üòSx¢OÖH⹚ª¢«ÖØÂqfãΟùìÓÚ1UcÐëÐíö‰'ãˆaÀÑÁÙò’f¿Çhl¡¨*•Z…F£ËŸþÙ;˜=“Õ¥i\Ég³+`c Y§Ýê ÇÄ Çè´\IgÐ?Ķlˆ@Qƨ²euPÔˆB¥Dû´N"•!«Kçˆgr %&q˜²ˆSÈäK Ç#dUCT#$)@M$žL3wæ,'Ícæ½6¦—ÄqRºÎÎ~þÿþ€û;û\<#¢‰7nÜd88AJˆŒÇ2¶Ë WÖ¢{|Jº8ÍÜâñ˜Hã ÎiÛ"W0p]@ôl"dœÞ1±©%L¯KQ38Ú9"“2~è/¤ØßïcIJ¥<·>¾Çp8B£‹W‘B—ƒÃ.^a$skãˆéjÓ4ñüQYž­°4"’¡o:(ªD,žB3 ®ßÙåÿô[¼ýÞÇtûCtY%ðlÛâÙ+Ëܼ}Èi§O¹AU5î¢ ¥©iÝ÷ÅåÁ.’§7òH¥jxVHqá’¢“L$ùñkïà[mÖ×òxžAý൵*×Þ¿Kmq Û2ñ°|ÝHSžGPD"YçÌò,abÛc 9âîÝ \CGV%þø Åÿøò*Íú!¹˜ŽaÄh5dò¤0¤Û¬#ʽ¾‰™^\dóNƒV#`l…4Û§îï`»>¹„ÇiÃæèèIÍàá±63ÏûïïP*%1]5ŠhõLòq ×±qý…¹)†ƒßš¦}ºýý8[;°}C–˜œ[w÷yâÒs?ÃÖþ› ¾¸{ó]R†ó×þ?½8a’Å•'I[Û[$3 †ý›×·9Ü<&Wɲ}s—×¾ñ‡;Çdòiž}å ™|šÜâþ-š.ÏG:U"®Ù¨Š‚†$ÓYüÀ#•L#E–ë…cέŸ%ô£!¹bšþÀ$ž2H¤²KÆž®¦“1ä˜ÆÖHf½¢¡ê:w Az‘;K-¢§p%ƒL.Fˆdhdª ì yʪG0lqTÓ\?¢~Úáû?¹†ëz|îÙ$1=ÃÑI“ tY¿²Îl%Í÷ß<%›Ž³¼PÀó,ÛCÖ51…A«AHˆ,J´;& C%](é F§¬®®ÑÙ½ÏÖ0AFôÙÞÞ'ð$N»]ŠÕÒƒoËrºz)2ê;´ONp-›‹«W7°í1RLãìò ­fQŒX\ÈA-¤9—žZ&[É‘¯”(”§ðÍ.›÷š LjÕ 6¿Äx8$W®qoã>‘ç°¸²ÆÝëïqÚêóOÕhnmѱTöšˆFLÂÃг¸v—AߤoÈg'yêV(â†K3Ó~„ ÈDl^û€nßåÜê:‰Tœq`Óìž"ê"ùå<çÒ³4Ž¸tæ2ƒN®9 ?stÔ$Oqïæ]~ò®ÉßÞ£yêpvu–\"N¨hÌ/Ì#DíÞB¹Œ¦+ Oñì€fsÄòÒªèáÉçPd!Ò±‚/rs RÐ ‹† i*‘Ô4|×&“Jrt¸¬hQD£yJRqn}ϵètºØ–‡¦Å)O1Tk8¢kDŠø²K(D(Ê„øåÚáƒêM’$lÏ }dEÂ|\ß™D1…TAÙ#YaÒêE‘ „É8N’%4IpÒþ ÂI,“$Jä3±½q€‘4˜_žââ¥E®Oø Yw2ŸeÒ‰È>=@•%TÑ¥=’e‘ZÒ%¥â>ù¸O> J"ÍCdâ^–7"Ši…Ú|Šqo„ó)}8ýi[ɇ`úsKêO?æñý=’OýTE-ˆ“ÊÙó|del‚(<óG‡”Dbš†!LÌ\<Çcgû'.=÷·ÆÖþ›ç¿ú,ógg9si‰é凛GÜzç.ý+—Îð¿ûkœ}bL> @e¦ÌÅçÎAe•©|ÄìÒ,篬sœ9¿Ì½7ØÛÛGzæ™K_»üÄ: Ý ‹¡k:ÖØ!ŠB$E"ð<¼@$ÒÓ\3ãÌÇÄryÞ|ëÞ~ó&s eVjÌÏçyá—ž$™MÏ/Sòn" K»Û'|å+/’K*˜¦Ép4&Ï`ûôz#òÅ4†›0&%Ðã ð]<DZmý»‡=66©TÒ”s 4#Aù\o'™/J誎DÀx<±<ÌAH2™¤Ñ<"Ô¸@®PÅ}bñ ÉLw8•4^;5е8SR—´ÕdØëc¶Z¤„1SÆ€œsJE1—Ö)h£NéZ‰H2(&8¾‰/ÊHx¤Ó ïtÀ·_}{›¸®ÇR%Æôtš“ú."*‰|Š§ÏÍñλ‡·¾ø+—¨–Ó(Zœ•õ (šL»Ó¥Óî…†.“)Næ—3µ*÷î’J&i·É–Ó$c ‘,“ÍJÄU¾9"›KºA—¥Õ3(BÀæÖ>o½¿‰5ªS,ˆRYÖ/¬¯NñÕ_ý?zí:¥JŽçž9¾ËÁV?Rq½õ!·nÌÞQ›Èí!xctÅãÒú M&Œ<#—Kæ©Ô¦ùÑOnÐhõxr)ÍÆ혣!®3bv6…9>¢T›â•sôè€d¢€$éöÚÄâq~üÎu"«Žoxå¥9*…"¾(óá;ïÑj¶é÷OYÐmž¢è"+çÎQ©f1O¶hõ<ªó³RLÒﶱl›ý½=$-IO0å$«1™j¶J£ÑâÌÒ<–9Äs4DÙçpÏ¢3ã¹#j³~ùågxã/Þef¶Œ=iwnow9m›<÷ìó‹5’ºŠ*LÍ.ó½?û>‰œ€o%@óÇ$s¦WI&â¸ÃÝv›“¶Ã7 \J6 -Ú.m;Éú¬‚®*ܹwH,Q —Wp†c¶·QtƒZ¥ˆ"„ìî¡ z“\¡†h¤I&%vv)äJþ¤ùDaŠ½ã6ŒŽOHÆ'ÙÖj$°8_#ŸÏ/ä‘õo¿·M<¦ñ_}‰rm)–¦6U¢×i1°| ¥B`1j7ñ<—nÛ#—ñ|›¡cQžªù!^à!I"¦¡¥ ÄPÅPœšmüÀÄ l"lÇ&$lÇQAd½F,6—¸=|? <½D­VÁ AV RÅc1ŒÐŒ!0tÆXÎÍБE‘r®D§ÛAVeEÅÀ–D‰À ØJ¢ˆ ØŽƒ¢kôû“V¸øÙ” ‰"¡LØÜ€ LªoßóP5•0'î\’Dܹ±Ãøw?æÆG›ˆ‚ÈüB‰PÓ$à¡œˆ¿£ÈG’teÒ¥£_8¥þýÿõ¹wí>Õ…2zLÿþUÇüO©¬™™<¸„á$«>ÝB~¸øž¢(’øhßL9‘ˆ]˜$i,ËlÜÝáÉËÏÿg ÎÂŒ¸Îâ…ÄfÖÎðâç® +þÃÅs=bÉ8¹8ÈâD™ðpÑ õ§Öøàí«È¾ç“Íe8íwÉItqbß9ÉŒí£Ç lOAˆÜêi<ŸnÒwÄb Zbò‚å²I®+Ä%××ÐYu¯òí¯ÿùB†/~ùYþ§ßÿ]TQ¦×9E”5*…"Ðë H¥’DQÈhì×üÀCpI¢Õ Ê`}¾õÝw¸¼>Ë/æ,ž§15UÀ¶lÒÚÔ£ú®5Y¡ÝõÙdÅ BBKÄQUIÒÈ+¸®a¼s*ñÙ•$g¦Bzƒ&ã@â´ï† éišG‡¤cS¸A‚Àís´@:­`Ùf£ŽÄØ; ¨†§xŽÌasÀ[ï]cyFE—u"gH¥#ˆú,¬žgçþ&/¿ò›7> {j2?“aeyQ)ó4÷nãK*ùò,N¢‰"²oúCJÅ2§í>šîáGŠ§yÒ¥87͇MŸ+FÏBÕERÉ$›w¶HÕfI& êÛG¼öö­î +i¤T…Hj3S«rtïcŽ·Þ —–xíë|ðÁ]ç+,/,póêÆ)æpD)>äwk‰±éP?Ó7E6î_ÅéȲJMBÝ5]¥Tœ´zc‡R!ËåË3„qƒÍ[7ÉͯqË_â™X›7›N0BUDa@·“ÁÉ,”XIHD^‘­ý&âñ6—Ÿ^góþz,rD±t…µsg ‡MšÛ÷õÇŒ¥–eSoñôú“¤S9,«C­6EÝ8õáÆ}g?SÂlž0]+3‚k·î²º2C"ë!$‘óäÓçùøƒkôGÃá€ÝÃ6ž'27›&&I„Î1ßþÆû¼øüólÞ½Kkh©çϯóæ·È%+$sb™4­ÝXB’¹Õy~ø½L¯-ñ/?ÿ$7ßýa$ÒªI(Rˆk¹çfX_-1t,Ìá)ù©Yƽ:ãQ‘æiÇ×ÉIƒ¾É ]§P¨ÑwU¦g3lmà;.hÈÎH`S°ø¥ó‹Dq™a¤ÒluÑu™ƒWo³°²L{`òç¯îð¹ÏšÛHL²|Y@ B¢Q¾?=ˆxùï>Ïëßx›ïþ«¿ _Îqæ‰%æÏÎ>’*M¶ûDþô(«™ŸÌ;|}*‰êÁ.Ân# >S CSiŽmü‡îi²JŒ€±€IYFxç.Wž_geu‘ é÷tÛ}¦jSž‡=î30mÊ• ¾3FÑ5!äô¸y+Ó”«EÜñˆãF‡ûÛuþÑo¿Ä؆™¥ÜaúÑ Z¦À7ïŽYO98tY>ÃaŸxJE5´¸¤dÊy|A$©Ç¸ÚX›6˜Qœàº#wêÈR„c¹Š¢&d…á  Ç <™0Ðè º¤s2 ‰f£¡k4›&¢:ßûÑû8ŽË\!¤X $ÃÃ:ƒŽB¾’¦ºr–r\àÚMÖÖKÔŠ1r¹íÆvkÀioLB±Æ=â±$‚¢Ðï;zØc‹©¹E:‹˜¡ÓkIå&„/O”(¥2DîI¨ÖféöÛèƒÓýú½1?yûSEX[[@Ödzb„64‘Ü1ׯ7QCˆgDšmw’¼¹G§ÛÇu'ÿ$Ï]žÅê(lî´˜]NÔUÙbiq?P8lšdÓI  YŽŽÚìõQñÐD‹i¤gVXX¬1|ÿ ö{íÖ©Ö‘%‘~ÿ!ê1W3å*¶è²³½3êâ¸6O¿ð4+çV©M˜ªÖHdÄÀåè`“;7š ÅY=3 htÆ=2ñ4BàÚ#®ßؤç…ø‹i¾XÓXŸžÃMpºæÛ(Måˆ'ó G&SÓëMæ—V%…é…"½vLZ`a!=âF{ûŸýÌS|tý©|†íÛ;\zéöîÞbaa† ò¸w{Y²ðÆ©*1Eň©tB ³_çí·î±[H“\¹8Ç­]¦—.r~­Ê[¯¿‡g 4ZmDÕÀb LAª!ž²¸²Ž¬Çé˜]*å"ýN‡\>Çvëç/=Í»·nsiu‘¡;@ Gx¡ÀSO=ÃÒú™lŽ7ÞÞæÖí&««s|ù×?K¤DCCPÂ) 8í¶YX˜§yrˆëùHÒ$1ø¨=@6T4M#eT=1±Ezñ*I§ˆHºˆbDZpQÅ1wûEª) ÏQ°|;pñL:ªh ͉TÕÐeßsq]s4F7 ’©™x -R CÕ™ÉUðlãÓ&H²ª £@{Q䉛–‚0!Ô “lfY‘‘$ QP5A±mQ°|›V·M³ßA‘$ÜÐglqÍñ‡ßbsãáТ\ÍñÅ¿óà Ì"Ñ ŠÆâ¤+ó¸ØÙu\4]%ó¹ÝP)ăŸ9Æ{o¼,Š¢†¦‘MÆ{~0áú¶ëà9.QÄõ%ßÅ ®½yëÑ7¤ÿãý7vü…¿ó,W®¬3[®QšÎÑlŸ"DÑ$°]Qðƒ€d2‹¸ôMϲñ¼= žŒá øO"®±¹Û$fhX¶¬¥ ì>㉪‹ôëu~}eŠÝm…T¾ÀhÔ"“J˦AI6pdŸ¾Ðw4ôñçò.R”çð¤Ãh,"Gx¡5rÈôN]dU¤}ؤTJ7R L³_§4“#“‰Ñ®7ˆÇÊ4ê'D‚G©Ráè¨Ç/¿ü,ßøö¸¶ñù¼Îâr‰d.ÆpàᙜŽí¹ì×÷X_¿Â?û÷·´ÏïýÎËz ;Ó·,$K¤R58êö)Í–è7I'"v6îP›'žbÌÄiw¬¬Í¢uL:¡áÚ¶e£—Jœ™ž¦ñ/¾ó*¢_øåKLÕ|ðñÍR õ´ÏéöZLãÙó Ä Ÿoü‡Ûò [¦ª r1=5M¦¸@ÿtëà’2‡ZU8[¨qãýÕrM=áíï1´¾ò¥+|ásOòƒ^÷G4z&™Ã~%ï^'ž™a{{J-ƒg9Øn“aG¤¸*#D666H©ù‚ÀO=Aè˜Üûð}Ry^S X‘ÙÙoqùâŽö,\^X_æøèüÜ2®çà¡ïR?éqne…7z‡üÅ{SüæçEèžp¼ÝBQ™è]ãqJ©4’$#¨2ÍÃ^xñE†DcÔ"Êds ºRÆ bHŽB½ërã£T5E:Wà™+/pÔ³H]y„cÐo¸ùDš›w·™Ö5â©iî½þ.í©—¨žlÑ'yúRJµ‚lÄI¥ ä 1~òÃw™Z>ÇLAGÕ$fW–ÑFùtŠ¾ sjöé·-tY%´Fìß¿ÇØñü„! ¤rÌ—çy¯W!§õp=ꎆç„,g3,H&®§#F>½Þèà ”³EÊù€·6`µ¦ á£HD“Ê«Õk£)*ššÀ \,×"‹¡éiV*³Œ-‹X\Ã÷-Ffkì ‰&ùÎÞ¦;F3&€-ŠªLâ‘ÝñøÊh2ã,«ÊƒÜz&¡€ï¸Žƒªªô]l"†&K€BÃPT ï½y×õùÝÿæ+d³II"ŒÂIÕ(‰Œ$…ðAu™BbªJÛòñ…ðƒQ)é*2!û¶;ñž–d$)B$bD”uƒapê;~ôÿ1÷¦AŽäç™ß/ÿy'n€PwuWßçÌôLÏ ‡Kqxè E­Ì•,iÃ^ycµ YaE¬ìp„?8¡/¶c?ø›ÃGHK…,ÅR«•d®(R+R$gÈ!»§{¦™>ëD¡P… $wúª{z(j—²´þGd!3,d&xþïû>ïó€GQ*Äñ‚U‘‚¡j¼puŽõ¥%^Pú¼ýÕ<|ç1ßyŒ$I|òŒb¥0¼7|(Â~Ú"uÔ…tdõxY?iÉê 躶>5Ê%tB?@³  "YB C&SÕhxcDè1¢zWã‹'­To]¿ËÒ\òoe|¡íºßTâᛤ#‰€ÐsP% Y·žN „$ñ?þÆøÿþWØÛðÖ—¾ÇÇâcÔ¶÷èuz|æó?0Mï˲@•¢(b4†þ”~ÇŒl‡Øб”€Í®Ç |‡ú8ÍP›! Cžñ ­fÓgVèuÒ44K¦o¡ÉÔö˜›­ây>}Ç¡ßw)Î&ð°ô$Ýñ˜t&¬ËLl„BUØÛéòàѦ¡¡IJ³3Ôí€R¢ÛÝâøÚ Q‘3 ºÍÝžMnÆ DÆ“=\$úƒ/¨}fuƒQ¿ËV½ÃsÅ ™¼Áp8F’t„ ÎxD¡8Jƒ¨ªB:S¤×Òm0[MQH¥xÿÖ}æJHrŒjf(“Ôj5ªÕš­ˆOÿØ9¾öWw9œ(ä%‹¹åó¸öˆ±Û¥”-rý/¿Ìç~æ5ƽ= 9fÇc¿ÙduÙDϧAMbhnP^˜Çvm²Õ n»‰•Pˆ#h=‚‰D<~¼M±Tâæ>¬&¦i£õÃ=Î[ÁuØÚ¬So´9½’B Æ7Äõ} Ó@³T‚F=WÀâ:IþÅÕ6®§ñðÎ=7ÁùsËL&.«Ç—h7b‡Ù¬Êüü›hôCFÈQ? ŒqÜf8ì™Ç1‰ÐÈæ3ñÞã/ÿÝ[lœ¨qþ…—Hç“(²Ëîõ»VŠ[ï6‘r"2Å*/|äuþ`GÐ Ë|æ§ ˜šKóà|*͉sg‘“ÏþÜç¹ýîÛlï"’vö{˜‰1Cw‹ŽÓæ#—_awk³PfwoHa¥Bý`ÓÐyTÛ¦Þl1©&°bƒˆ›Û[òYJÕïï> °¸Æ pbù,ç7ܹ[ÇJeéŽmœý}ò‰4-M;ê“ÎçðUÁ^}#™¥<_¤ÓØFÄ}*…4/:È“'ÌæXPUzÝ!zÔ&B ªg¡iBBdI`™2cÛãÊR’ÚÐe,¥µ§­80Mñvœ>q£ÉƒžMÚH0î  ? ƒˆNk@Å€¶™™- †]¢#ßè(Œðˆ%¦fŠÌ’•@LkãR< p¦®NS˜,ˆAD Š„\{û1o½q‹ÿæ¿ýÏyó7xë;ï°¸R&KË2Q Š‰)Š™·Rè"&Ž"ü0F’¡bNÁÉDàÆ¡,s0œ ÅBL msf‚0 ð£EW˜8.×C“d|C<½Æ0ŒGinéH62–r$³ZŽ¸¿_æÇéÓÔ·vù«?zƒ8Žù‹ÿûüì¯}Ã4~dÑøëê`ÏŽ(Š¦÷<ŽˆÃ! Fã > KBhHUEqR #{ šŽKÓ âé»Üºu‹7ÞxƒW_}•—_~ùïl|ñ¤•ª¹÷2§Žÿíì#÷šúß|W¢)]HÓI¦ùX?p_ßúö÷8ù<ýÀཷþ˜ljIÑ(” S‘–£¡AHÅ(ªL$Î$ÄÐu|šÆ”„J&cát"QJgxÐ/ñ‰cVJt_?EZOáÓY’&v66©¬¬àx*…"~¡«DaˆP¦™$“jX -fÄŒl$›Bª€ai4wwQ%(äsL?ÿók\½z\Ik  ýÚêld2‹½×eáä…wÜŸ\J` ÔF5¶ï…æ5º-™8‚V»‰çH m‡R¹€í¶©–-F£ýAD"•Ã4 šVòœ1«ÇÏððÎC‰YðGôz©\ ?1Í$žR˜‘™[Xa»Þ§\p£CºÍ&Ë'¯PÛp8<¤ïHT£1ÍŒ2âÇ?»ŒQRùã¯ÞäÔéã\<Ÿ'Žr•%F“–œ$ÇhšÊÄñ±‡#æhÖ6écôDšá`ȼ*sryÉñ{ŠÐøε÷ù7_þVjDß é´8Ø“9ñâ9üN›ÇýgÔ“8±ÊîÆ6¥l^­Mþù*Û·¿‰ªÌ`Fzd“+d)ÎÀpì#GÕª„f§±×c{ó1/¿tŒ?{ãø¿~çÿÁ÷B^{)I˜}šŸæLc›½}êŒ`ëJ ¬žo¢¨‚8ahiü`ª/êtŽ­Ýî<¼Ë~Ëæ…ã'Y:Y$ð™+­Ñîôˆ²+,.–ɇD£ÇOŸfãýëÔêèÆ%Z{už¿¼ÀÎöÇ––8˜ä´=ð¹s튈,ž;ÉÞî:ÉÔ~ƒçOŸFŽcŽ;Íh8¤²R¥h¥°Å#a‘-&ø‹Û·X˜9A$IEgºÌ¥sÜ|´ÎÇŸ¿Â£{[;Ž,.¸s·Î·Þ¼A¯7"“4ùÄO\¥;è£X:­&i-ÁÊÚ)Zí©\†½ýYUbg·)ëÛ÷1#…P³0 ‹F¿EÊJ㸄Ëk'º}|;¤Û’J¦ÐCò) ×wÑT•8ž«ˆcTU ËÂÝÐɦӸžÇR•ªIÌÌWÃEV04•€R¡H{Ð%¡XšA·Ó#“Ï1˜ Ø£iÙP ƒÐ ÃàC>¿²˜*q!IxžGRÕÙr\öö[SòWpùÕ³äŠYõC®¼|¡ÊU¦Ìu0´c Ùý‰b‘Œ•`8ãŠî`€*ËŒ]‡XÈôCb]%*Óß#ô<$M#rFxQŒï†È±„/0o¥MÆtž©?ÏH&.H‚c•>7wr\Z.ó‹¿ù°cî]ð4ãúyòš¿—ž¦¶Ÿô8K’„$@0›¶XI”M 9žzrgÒY{i™C×ÃežJ—‹/ò§ú§O·?÷¹Ïñ¹Ï}îéög?ûÙ­?»ýë¿þëüê¯þêðÚþ¾‡ïù¸ ƒ( 1LE‘ÙÞ¨±µµC~®L­­ó_ý‹_æO~ç·ù¥ú‹:^~ùês_øä'^#Š¦7OÓ5TÅÀuGDD ÉÈšàa+ââÜ n‹cE ß™ÉÞØò4dEžŠ”(2[›TæP$©kŒFc,Ãb¸¸‡”š$»Ô·ÖqCÕ(  j‰$î€a·®'èôGȺÁê|×…ûë{Ü{°ÇK/=ÏAcM3 bŸRi7–Hš·Æ‚…rJ2öÁ´fš4-Zm? qŠ`š3˜É4ÝÞEv<•R)GyFcëþ:;›CFm‡Þø‘Ȳ°²D)_DD6Öw™?žÇw&h¾Ë­}nÝÙ`¡’!›µ£@’h;}¢";¦G„„“@N`¨ 43EÓ1WI Å £~‡Q¯ÍŸüùÛŒÇ.ÿðÓs8£³ Kd³&V2ÇÞ~‡Í>Üò.rÊl2[ÔÑdhuFD’Ïå/2QZ˜–F·wȸ§c¦4¬LE’ØX@ôIf’ºD:#pÇ6jc–N¤hU¯ð¹ó%ªQ›Û×·MZd«óœ9žÛ7öûܹñ>•Ù µ]‰úAØL’À0d4cŽA¿Mmë>§ÏñƉ¤‰¦´Û$EÏ`¿é¡(CR¹ó…Y¾qÿºlðÇvŠÿî•+|þ¸ÆîÖ6¶ö¸xá ÃÁ“î!íÆ>ª©Ó?è3œ„lnŽð£š)˜¸=ŠÅ4¡ïQœ-BìR™ÍÒöÉgQc›cË ú#R 3‹n$¨?¾EsdÊÀ÷Aö;Ôê-Ö×·8}á"n ³¸X$ö¸}{—ÍG[Œ|‡ÅÊ,ž$8l cƾÂØõ8Ø}Ìa³C£ÕÃÁ§ÖÚg}³†Êh4f¯ÕæáÁ.[ûl{6×Þ£°TÊï!ˆ‚±ht;XºÂÆÖžµÚ6KÕ9²)ƒï|÷;[û4÷;ììpùtCVI˜i†î„ž3ÂÈIÜ0$Í`;cÌLñÄE72XÙ<ªaQ­ÌLY”f+„Qˆ*«¤R¶7A¨ qŽ7FSdU!D K>Ñ´‰Ó($$&ðºƒ!Ùdš(ÑTÐqÆδ¦8®ƒ®èh’J0öÈ¥³t;mòù<º¬"bAìFòFöâ€Rz YU™xÎSG¨0§$GUA–$ÒŠBÂ2¨T äóIU!“N0lŽ ŠQ"ýˆ^o@gÐC îØA5 â(bdivØ®Ãáa W†¾O$ )$’d¤#%/ ÐUÅ0ð|]’ñ%AÏ÷‰d„DZÕ9ô\œx È‘=M¡NIg12R,‘)ev; ²²T4]áô&¦©-AŠžûÃÆJ‰>au?Ëò~*Ë=E}$IÂs=TM¡ï: \¡çÑ°'>C!¢*2±3-‡ÿ§7¾xüð] yùouÌÐVX\> Àßù6¹J†0œJOÇG:â®ë!I‰d‚€XŠŽD¼ Nž9ç/œ¦”øÖW¿Îéó§™[ø@Üäڛב¯\¹ô…O}ú£LlM—ù/ù7¹|á7oÝáKøŠ³E¾ùí·xxç=>úÊ%:ÝÎQ/´JC†¸®‹ïùÒyêõél‘t*‰ÓzŽçû!1v'H2tF½é—K1ã‡{2ÁÐMfò9²™ ž1t‹ Œ)dLFC—•å^ûè% é“ñL&ƒ$³iJ…  à)Ï-UÑô›{‘gSI¦¸ñÎ<' ²¸H¬h §ñˆÝ};ïïðÂÕ‹TËf‹3¨xÂekdó(¬0 |¥OËW¸7p¹ÞÒ‘LƒÅ¬`2 Ù6õú!_ýú»ì5:Ì• ®^½@j¦Œã…”JK4zCÌDD#“ä·~j{7¿ÃÖ£6ëu29#$žªY ,Ý@¶ Rù‰՘™Ù2ƒŽCªX 47lj3çØÞ¼Çòê3…òJš|äuNø·µëììî1´;dg’Ø.ÌåM>°t=º6Ø£Ӫе}6>"sr»¶AH47ÑE‚哳DšÌÚ™tÚûXJÙÈ3ô°.f2ÍéKçq;Mšƒz¡ÈÏ,§Y©h6êìؼpõ2ãq‹ÝÚ±=æî½:Ï_ºÈ»ïÞ£¾g“H&8h®£§O­P9v7Š8áõÇ5j[c9‰li"Èçu¶jcò¥ W®\¦?péC:û[òóÈY“8ð”4/žàþƒ‡DJ‚—N,#œ!ý~ ?-–¹û°ÎÜb‘D:I¡\bäº8*¬ÌŸ@Ö-Nž?I&›bo¯‰YLRoì³ÓØA5 KaÇu°Ò 0d4E#>ý‰¢ OxÈt Ë•žÑØÙeyy…0ô9µ6Ïê9‹_þ'?ÉÛwøí/¾Áß¾Éã{5œ¡ÇòêõÑ'rX(”ð&cT+A±XDR`4´™¯ÎbºHB&—Ë#dHXéTC †cLÃÄÔTFΡLÜåHææ~LÙž–¤)yJˆ$‡›¡3Ƨr”Š&ÐM!’쵨¦Nʲh·ºØŽ‹¤ÉH1 ûCÙ$»­}¢(DÒzÝŠi6-¢hZgŽhªÊÄ™ **“É„N«ƒHš,/•9ô\AÌ„;ˆd[ÄxA€‡L„`t]_WF!™¤…"b F²„ŠDNô"ã#ARW‘£ÇqõǸqLs2Á‰#82ˆã; §FG“‰™TÇs‰£¤1Ÿ•Ê”ˈ5‚)ùõþõÔ78ûÂÚ‡ÚœþcãC“|>~¨ŸÔ±%IÂ÷§ÎTO PB"–’© ¦¥Õ8~ªÆÆ3®T×®]ã·~ë·øéŸþi€¿7ã‹¿+8÷ûßaå쪪"T‰l*GÚJãG>ª&˜ê OeMcb ÍDÕTJå"ù™‹«‹×.pæÄ,Ïf ®½yùµ×^üÂÇ>z!+|ãëo@qæâþøþŒDÂâÄé¸aH"i°º²ˆíØDÑ´™ßq\¢0bàŽI§’¸ž‡"kÈšŒ,Éxžq„¢MÛRfESÉ&RšJ*• ‘°ˆÂiÓ}ÚHÐé4c‰\!K*•¤Ûîâùº¡¿÷¥¯sæä<ž’Jë,/ϲ¹U§X.QL§Xø€þÀ#S*£ ¹„Šd²Yœ‰‹¢h8öI·ñôÛ3“µˆeoõ‰óŒ&V:+~÷Æ&¯ÿÄÍ[Íôˆûo]£ë+”KÇ™[›§P]`aù,ww©T²IG‹I#\3F3’Œ‰ ¡â#˱µfƒ¥“gÑ© l^{é,ÉI‹ÆÞ!û­Š™äù«/Sž[¢:·ÌNm›îÁ! «géµ»ä²)ÊË'é4› ÆÊ"Ç›Ñ sÃ[$ò2VJf,'¸ôÜi¿û†¦spÖ‘MZdg –/RÈfy÷ö=|¿O3ªòs—Öh5Ù«wÉÎf‰œA R* IDAT þÄaiaŽÖa›ñ$ÂÔV{àÐv™I9s¡ÂíwúT .cÇg8ti6ñ#—ãÇŽ1öd––™)Î’3’É$ÿþ·Q‚sKÇÉÌh¶»\¸pûï?FV-Ã{0ÆUz´'>õ6skÇXY]$›×yø°Íg?û»õ&’rþôq4¡ÓëµÐ4ƒ;ïÓí·I‹Göb.ËPt"hº.(ªI1~=%9=±JÑèb]&ô\ZŽÇñ™"›ÛÛ¼úâ%dá1ôÇ4öêd³3ôûî´”b;´¹þý÷yþ•ÓÓÉ›ãÓìv‰â©crEÌÌä‘¢ƒf›~¯O:•Âˆ‡Æ^ƒ Œñ‚l>Ë°?YFqF.匆ˆ#Â8šöGA4­SKB ÄT;AÓT ÂJ˜„Á*„,hõ;(ª‚=¶éMFøa@ù8®Cw8Á‹]öˆÐH¦O fg xŽGÊL‘J$Hè&ƒÑÝ4‰ã$‰õ¿…ñÄgõÔ£8@‰¦ç4•Úœv­ !IÍdlÛ¨ºŽlÏc$ELü€HHI&g%¨¹.Rà³l¥½‘K7ð°…Œ¯|@ÈÊÓ‰Ö'Y’ÈÄqL%‘D‹|rš ©éŒ]_H>ˆnc¦ÇÈѤ•MP¼Ç½9qùÊ 3ýƒéíg[²ž*I¨€IÒ“>g Ž>Çérô|–aÏø:Ç0ò «Ë<ÛÆþ”­Ç1BÈÜ»ÿ˜÷ïopýÆ;H’Ê/ÿ“Ÿåwÿ«|æ} ÅPØ®×Èf³„QÈÀ!Ý^Ÿs§NâM<‚("–$LÝÀó<¢8ÆÔ4â4EÅu'¨’Ê ßÃHç³I@¦\(0ìÙn4ФUè6êÄB!;S¢PšaØíðÍ7¦ä ÛöùÞÍ[üƯýCv·¶©V«¸£n?D—U–Ï­1ì4(ÍÎÒm0è¶È+$39×a2L1A`Ä4êœ9]¢±±O¶8‹"[ìÔ°’tCesc ~³…¬£½Ý–.³¿×Å‹[H"÷޸G¿ÝäøB‚Ëkiª³2)5B—|*•úL'´yîÌiÚÉ:ƒî6AQ·*Õ*θÏòêÃn€·o<àíøÌO¿Æ½úþÎ ª¿òÏ1œŸ^M²ßØ&T,²–…Ëha„z¸Ã!;;hJÈ«—,N=™š!6ß}ð.Ú©ÆoþÒ<ÿÓ—¿ÈËÕ/ŽˆŽÍ!|Ÿo*4;YCA´øüé–æx|ó}Ο9Aï°Oµ\¦Ùí2W®à»c„°Ø ©5=†‰ ×{^dñó/ÉèN/p(‹¬­c<챿~=•càñÜ…Ó ¶yøxƒÊÜÙ|{4a¦<Ïá`ŒœSùÄ FõôI’N§sÈ]ý ¥{ï2[X¥ÝUAPÍfX­«*:v0;[ ¹ÈȵQ5UQ±’ ºí’â %ö ÃUÑ|ªi„„B’èTKZ­¹l–År•ÐŸz¸q€íx²lÔk,Ì̲Ûi¢(]Óð}IOÛ°tSçÑíužýâ”™|dêðÄ¢qÚ÷t¥JŽ3!’§5kMÕMbÊ>‹ˆhÚ#I"VTvú}bUAÒeÄ‘ê[,ÉS0|¶6ü„!CHBP³‡„¨B ÂQ$!Å ŽêèOÏñÆʱ ×€(Œxç›·yñÏO'~ÈxÖóùYw«¦Áýá÷ŠÑ í¨HÿÐþ'%>¸wÎÄ!ŽÀ?êsþ›ÆÿWã‹8Žñ<;wï£ÊTåGèV\ïhd“N¦îIŒidPe©š?ì *™ˆ›µˆK žÉW_ºü…W^y!W_Ø Â#3“' Z]T]¦|"t¦Bc¿†"ûÄ¡E6›@’Sø¾G:‘BÖSDÈÄÑ×î‘L'ñ|Ç —T*Åpè`Z*²lñõoUòQãCJ%ƒ½ ~좘 ¶·jì‡òyʦEíþ vlﲺPe¿Ñ Z©b¥r¶',¯d„¶Æ<|°C·±ÏxlS1&ш¤aÑ=l¡h Š³3ªÌA}› évº4òòÕ“ôšbwÀhØÆûl%>ýêÏðkÿÛÿÉÿü“.Ï/ wFœ./SŠ4.¯Ïñɳ%®ÎšÌæòìmàõêì<Üam¥Bw—îþ>v«ÁÆÃûä2ïb9{œŸ³8“dn¡¸]?¦{p@·Ý`k}“ýÚ€‡šxBâÄ…óè¡MKŒûC½¶ÐmÒiïcX)²Là;tšâ0¤Ñ¬r,ëóàÁ:²˜a¯¾C¹œ¥ :œ¸òQ¶·î²óx—L±Bf.@w}V+UÒÉ$IÝ`{{“µå9îÞz‡n»Ð"Î8=ž-'ØC>ú‘çôm†ƒ1ºŽCæŒ<^ùÈˬ?Þàµ~Œaoª89¼{{—KWOSLÂúÎ.Ëssìõ(I 3a Øl5H' ·“üüó Æ.½ƒ[´ƒ˜å¥ãÌòDãMtUe¿Õ¡”S¸}g›‘ã“®äȦMdE¥ÞàÅÉQ*O½{%@QTˆ§¬`Y–?$§(IA<ÝVÄTî"VdÆ.ƒ^—‘ïáô:tu‹%3…dªÇ÷¿QgПðùÏœqèM¥É¦³´{] É –n1è èL$“½AŸBa†´i2\Y&“Ë{‡û”ËE2©)+‰*«D^ÈLºÀÀí±7ÒiÅÀˆ\T-"’5¢8@‘B\OâølË08èé´Æ »‡Œ<—”™ Óø6ßÜSÒ=._¥ªøR–ûN“Š%aÛÌ”¦Ê¨ªÂbužþp@©0ƒ!kŠLxTCŒÂUU™)f¹ww“AoÄÂÚÜÓhTQä© ñÓ¨–X"–etUÇs¼iê“égö¬®ôÓV XU™ÖØ~¹ã#G’g#TYÈSfùQ+•" T!… –BV>d^ñ,áëY•d‰T>Åî£:ÝfoJÚZ,ýèèŸüps izýAà8®ãøa2ØHLÉRÓ%Àu<|ÏÇó</ 𬄅ª«ìnÖyùò+ÍÄ™L5Ö¥)¯b2“ËäðCwJ4”Õg>×g¬#I<ÚwYšùœ¯½yùÜ…S_øäë¯"!¡ª*¥J‰b©ÀòJ•—_¸@±˜ÁÒ2è&DDÌe‹ÄaD1›¥Éa%R¤3R†AÅ–N«Õ™6ì{>±³·»ËîÎ&ž=¡q8•gt‡Í&c' X)ãÚC6mʈCBßS‰BÓPQe|>E·ã@<âÌ©%LSðý›ë NœX£±{ˆiIè©$IËà`o‚©Ak¯…¦…dsÖ„Êü ãñÓJãûù´J"»D}w EUH¦2¸G*•¦^ÛEQt¯Oë8þEÑ©Tæð¼ÛP*ÙÞÝçþÃM4iÄ¥++¬>Ã~«N,ˤ²%RÅYêú„?Emã1l 'óÌÍUiïíD!µ4M£X®b&eRiƒËç繧–Y™­ò³¯Ï‡#6ÿÇo…—_:‡–4‘‘ðÁ8ÄH$Ù?ìóõo=æÇ?ù=»G*ÃÙ8¾ £eX=v…Ÿ+mÒ¨ïÓÚÞ`o{¬£[ß'–t×£±u»Ù$$ĹìÖ=t½…3³½u€©&¨ïÖY]Záệ<Ú:¤ŒB]›NËa¯y€&T<ju›D"‡•Ž™YZd¹œbýÎ]Ö }†ƒº1ìwÑIŠDó°ëtpÜ £qŸ\5Gbv‘Þ½w8ui÷omSY6ÙÝiñoc¬fê“(ÍsîüEÞnu¸Z™!›œX0qÆ[Yfóу‘Ç™ËWЕo¿½G~Æ@ŠBV×Ø­=bgs„¤ÀÊñ%P&ƒ1K‹³´º#¶ƒ$M0÷Þ«ñWoî2·’ãå«/áŽHÚ Fz†®Û!•NÇ1ÁØc‚LÝáT¹Ëüì1Ü äÛ‡çùË‚B*OsoCOððQ‹d&…„Ä08VŒ'BôD‚wö÷ñ§?Ù-røA Ž¢©¤dÇ„aHxT£}A?!²*cK"©a;1ÂE¦˜LóW_~L}·Ë'>ófÆ Z,‘K¥I› $v;‡ŒìªaH™ô†C–‰Ÿ0Š±tƒÞ°OoØcû,«˜ŠŽÑi˜Œì²¡â:yÓ#«K$õ˜º£’Qc"ß!1tC4Mæ Ûå^ÓA¨:‡#ŸC/A9-¨÷úl U|!ñÑY %‰ïÚ~€oÛ<·âÝŽÇr9I*’I¥2$4 ßõ‘…Ì ? ‘H0Xš¥$u“ÞhH¡¦ß·yüÞ6÷ß~„$Áêâ,߃£”³ôÌã“èÈs<„"¦ +}ðy IÅÑ‘è#ˆ#§'€øÄYê©<¦$žjLêêÓëy’Ö^ZZâ~áXXXþîƺ®cš&íÖgNWÈfS?ò2vdªsÇŸ‚sy¥D}ØŠSÓ{-£D>a¢kÆÓìÇpx¯%¸¼4-å|œ_ûÈ•/üø§>†IØÞÓ0 Œ‰¢€(ˆ™!º4¡Z:A³±‡lH˜¦EÃdì ™ýþ0ÐT UÓÐ B6M8é“/Ì‘Nê T KC–bÚ­6'/ž&mÄŒúRƒáÀG7MT]gÐéÑjOhwZØC‡áÐ¥Vk#Iªš¦Õ;di>M»íóö­‡äóE,äÓésâÜ*n Òˆˆ<¬â»‚ÉD¦0+ÇY„¬à96®ÝCÍJ£[*ºbÐؘzšVû Ólì²vº„3„áÔJ.•+â9ÜQIÖy´Q£Þ8`mIg¹’¡ÕêóÑý—^x>ëµ&s¥<¦?ÆÎÌHg©VKì4¨w].^¾ˆä{4›uRV‚ù¹ï×÷°Ši©D!“,Í }îÜ;dn®L*“Ä‘<IP*±Íïÿëoâz E¸té6ö¶Ñó3ÄJ’ïóln^çå3 …"ׯ½G2mòîÍÇ9M¯ßãä¹SìÞŸSgOñøÑ6–Ó9„l.$™Uèõ&nÄþÞ)Òhîw©,ª¤Ìe¶Ï0v-ôÔ<“avsÌ`ä’Ÿ)³½uŸ|®„6£1ĸ~Ä°·ÃòñY†í€Ãƒ˧–øþÇçgqGCl»Å¹ Ë,z‰ 8ÇéÄ€Íõ:KKs¼ûÞ#VŽ¯¸#þ‡_ù,7¾ñ5òÕ5æOÌašÿò/옖×'i˜BãúÝ|êõ±ûø6[Ùü˜Ù¹e&GwàÇÃa M—È瓨ŠÄ 7Á ÿs¯S8^¦¨'˜„.I#‰*k¸‡Þp@&•b쌘Í14Z½FÈ$3&ŽãH%I› L¡!+ ¾çc'¸¡Oà…D’D<`43Uè’ £M“ž’¢óýõÝ ¥À±Ò yK¡šOaÄ•ŒÆÃnÀRNp®R$£Ç$­ ¾ïÆfÂÂJìõ[”¬˜ïoÇhì2ù =ÚÃ>(ª¦âZí.“ɘ0Š¨î“Ídq\‡¥ce–Ë~È{7á (”g>q$Æ! é¨í*Â0 b# ‰XÄGWñ‘®ô?!dIŽ’Ÿ%] éƒV¥'VŒOÈrOû‹‰ 쩶zàÝcÏq§ªàù>çã»>Q’È%ÙyP#Š"Þ¿~ŸN³Ë©‹Ç1tU›ª¥i†‚¢XSž>TUWPuM×QtùhŠÅ£áE(„DSÙQ×G5T¢£IÄS½o>¼þäºw׸úŸ­½¹ñ>•râouL§|œIZ üà¨ýøèu~0XZ]Õ§¼…£gŸg?–‰$0âH™:Ÿ]{ó:ò+¯<ÿ…×^½BLD†ÄbAÇB04<ϧÙî¢%dtúaãHºDš¦$|Ÿt*I·×Å ]$IÂ2 “þ€Æn Ý4ЙÆÁ!él‘X’Qu“q§E§7&›IÒ¨ù¨f@®T¦PÈÓo7éõ&X–Žçyä²9ÊsŠœå°uÀÊj•„aR®.ñÎíû¸®ËBu†lVÆÐêµ²"Qß;¤T¬ÒŽÑtí:Q,ÐÍ$²ª#É:Ã~ÁÀåûoßEÓ-†ƒÍM"o€¥)¬.eéw<öô¦IÉìïÖ0*ƒÑˆ/ÿù7‘e™—ΔX_oáº}=îÞ{€jp˜˜2R£ÏÃõ]¢pL·¾G¶ºÈ`8äìÅsl­ßcâD Æ.¹\Š­í#4v9~á“dfºd„Fa& ²Å¥Ëç8ìµHšÝáN³E½±M$Ö–,|5ÇíÇï±PY"žø4‡mþ³ÏüS®×ÎØÚÞᵜí]ŽŸ<†®¸ÈÂ$“Jx=&[ïlâ»>õÝ’$#K9=Ÿ8ø‚¬¨jš[w·(VËÜ|÷Ä]’†Fs¿Æâlä‡-½.‹§«œî4E+=ñyþê2…š¦qüt‰ÉDðæõ®œŸ¡P¬0´¹pyiª,˼ë–I wˆE„™˜Å¶P3 Ksľœñ Š¦! ‰J´I7UÀ³;¬Ì/Ñé9lw9wê$ƒîžÝ§~¸GÏv@WXX>ÇD ÉÍ9qê'ÎäÑÆ!jÒÀߧ‹÷¹|å õÚ&‹KY4Åãì™K´.cwÌX ˜ÄsåTMðgu‹5ËåÌYÈb ÇΆÐ;¬³_;d×¹I9è²ÓðüÅ—øþ ]µÓkŒŸºâb©ˆkÃÑZC•RSOàŒíiª,«H±4UÁBLÓßÏ(*ÅqŒ‚ÂÜìÃÑðh{Z#íû.wÞz̨íñÏþùÏ" é”Ål¾„,Å誆ª¨žG£Ýâä±ã$ ˨B¡83Ã~³E>›E–Aáº.©ä´täú¦¡£é‡ƒ&Aì#‹)ÅW?R ÃðCâ‹9XHxœªáô›HQÀN?fmVÅöÆ$Lk*JLµ¬e!Ð4 Ïõ1L2ƒ® ©,:Q†JZGQ%&“ ®ç1r'bÊžÂÝÔ ƒ©‹U1_d¡ZaâOxðþ6¹B–êryzžG­DÄ d1õ%>šˆ(ªBÆD,CQH˜dT¾ëÓÖ-×ñp‡0ñ]?ðÏõƒÏŸ¦ƒ=oº/ð|?8Špƒé¶ë‘L'Š8"Úš ÈhÆ@U?ˆTµéúL9ÏÉË«Œ• öÁ!“á„Ñ`µoÜÄîÙº¿KÁØ‘H›O£ó§Q;1DD0“/ÐnuȤ³!£©* +d‚0øŇ#ÿ§uû£ÉÉöãÿ߃óÂÉ ªª}ÎbJh‹0 ãˆìödüupNª  Ÿ®LÙô‰SB˜ëzôûŠ³EZ ëtú=r3y\w2m1PqÌj1Æ4uü0 ;èøá»Ñ ’B„¦2š I%R¾ šI.¡Ûi’43X†L«±Mua‰l:ÃÐÒ)›õͱ’Éñ\V§E f+9dME•eö¶÷™)βñ¨Ny>‡"bú=UÎVkõê«/…=zÍ>ŠbBä²8_")0ñcòÙÍú Ëb2™ 1-‘ã_ÿ›/3q\î¾Ó0˜8}õ*©”ÁN½™(¡H©d gì𵯅7nÓrTR7ß}Œ™T0Ks(Ù<¯^8Gg KŠ¹pÀn{€)4’V)°½µM®X¥Õ±9þ ÷n1·\FQ|ÆãïöZ8¥çß~—=iÌþw®ó“?~•W_{‰„¥!Æ2#ß%•4ù_þ×ß#“ÓÉ_^âñÄbcTâ_~v‘û;zzs¿ˆìÃ?>ë°»¡ Ñ=ÜáòÙã¼ÿÞÛ$õZÓtД,ë6˜[L“Iê$’*!3ùˆÃCá`„:a$Ñ<Üåê‹kìlqæü/œ_á{ßZ§ïŒi ‡­&¦‘¢\ŽY-Ïpïú5úNHõì%ð†Ôî|¡´š]jµ€ŸþÔ1¼±Ê½G÷Y('¹õÎ6s‹ó§–±ßÛ¦»Pb/»Ìƒ¾ÉÒÉWÐÔ€ŽUâ{÷[œLÚd¥oßy‹¹Ù)ežM/àD&4°Añ˜_š¥»¹‹ä;6ÿ_æÞ+Ʋ<¿ïûüO7§Ê±»ªs˜™îžÈMÜ]rgAq½")›°@²!ðe‹O/ ¤áЃaÉ Á&)›µÜÀ]îÎNžÐ9TUwå|s:ù?ܪêê™ÞÕR„ÿ€BÝ{n¾÷œóûÿ~¿o¨’+¥ÎLÒð:TÝR:¦Þ«1œÉÑiU™›¤P4iWZ c¸N]W˜>uŽ¡JžõÕÍ KMô(e-²aštx¯mòêTÂW¦bNÌ „DõÝmZZ‘—&‡X]\¡RÎó/ÿÕw™™Ò¹tf‚wÝÆUf6G 'ȇF‡'C‘`¨&™tå€ œ„1Å|EUh4”J%Â(:Òö“˜Z½†nèt:FÇÆ ¿ +:®ïá© ¦¬Ño…¼üÂ5ò_±p<¹`£K*Žç`h¦nµšIÅë;½.j*O«ÓE—d)¢ïô15“(ò±S)zN]ÓðÂpÀðÐTJù Ý^—XĨ@,M×Qfšq!˲Aâz!q¡ÂP‘L2Ic)ª¦ )žë <œ{=oP<qÄæþ.º!sº¨“Ä ÞÚM˜1ª®Ð#²q„¦i$qL»Õf{·ÊÍ[ð†ªÒï6ˆã>‹+…iƒ÷~tÑá!ºu‡0Nˆ$›7Ö–HU/Uè:]""\À‘T:­¥P…rtBF€„L&dÓ9B?z| ‰r¾BÇ¤Í ‰?x $IئM>_b»ºNßq¹÷ËTǼöÏ+š¸a„›„1ín‡0 ÉXÓÅaIÆ ÁiV±ì4{*C• nà \lH„\×¾ãF!-ßÁ­¹Ø©Aõâ:Š"£ú{ÓcžsDQ‚®iÔÛ rÙ,²ŒU† }ŸµõšNB­Ö"t=ê­ét I’¨wZèú@´Ä4MÚí>Šâáº!W ¡§òÎZÈpºŠ©É"Dj«Ì¦Mú‰K¿ß#ê‡hv/m :Ããì”õ8É%E8) F¬“4BÊCˆŒŒEa†娴QTå¨r<êŽ$ÇfÄâñO™$gÇgÜGמçñû¿ÿûO(ÁýmB™¬™Ã÷ƒ'G¹Lž$IHY©A÷G<ý M²À %Dì“HƒÏ¡DQL½Ý$et{fʨ„*» [V©É9k0¤Wß÷ˆãˆ¡b]tȤ–‰$Hv÷™¿|ŽþÖdŠY.žže¿Ñ¢Þésj~‚ÖÖC"YÇÐe6W¶ØÞjsúìj•™¹yÚÍ:V6E©G7 v·Ö0L›šGºhpâÄ$ëV¨Ö|„Ü#ŽuÞÿð7n/òÒÕiB!ãz‚©™ úM—ˆ˜½ý=üXbue¯×e6T*C,¯ü€É‘<±“ªØ çX&<ù›,ßzŸšH‘M/q~v’ë›<\Øâþè»|öËϳèMñâ¨Ë¾[Ái~J¥Àý¹•LõÍ‡è¹ .ì°î3']åÙÑ2½(F¶$®¿ñ>…©úI›ÂÔ<÷–Ö™93E»Ýg|lˆ­}¼Ðd|vÝVøðíw¸põå»ln…t:>nTÃʘ̞ºÀ_ýÅ÷(•‹Ôö;Æ'õ=Îœž§P(¡©‚Åûë<\Þ"52ÅÊD–T*‹¢…lo׉T‰ŽRª¤YyÐ#}¾öÚ‹¼þú¸|ùr£cÐjr÷Î:ëû!gŸQ‰™g¼Xàûÿö;$ÆIΰ»ºÂÞÆ2Åa’~L”ô{1õ=—á øÅ/~ƒþÅøÙS4 Î]>‰ÒéqóÃë\¸|™ëïü˜jݣߕ(œ-³·«}úku.ez¸Œè÷ø‹·ß$êy„rẨ!HͦÇ?_-ñŸbk§ÇÜÜ È )Õ¦Þ­Ói¶ÑEȽUº¢ÍTqšN7bÏ‹xæÜ Þ»ñ6ÕNg^x™È?¨J•Qè9t]GŠ@C HòcJËχmâÁÉåqÅåö½ŽGJI±·WÅ\ŠVKÒq½]׈žãàx=<Ï'|TM# @Ãé¹ ªªà{>²¢$1¢ýžC§ï7SH² ðB&FFÙÜÙF·L‚8 X)ëYHDQD!wàÏgIÄQD.ŸEÈd%D㈀_œ·ˆDÈ@ý9ÀT6û]2²FdÈ(ZL;ŒHÐM×ñZ°ñAuô˜æ$Aĸ•¢cGB4u0÷½`0ÿ—›¾®iGÉ6I’¾L” WÇQÖƒß>Ðçâä‰Ç¾ösêÃÇ& a¹F!ô©CÎïûˆ3~rš¿ûߎ"ǃ„‘/打IÄâ*|ÿc|Çç¥_|YÒIÛ †ª¢ÂAUŸM爣˜l®D½U¥+¡É:¥|ù±§³4ÀQ$9p#—~¯û3õ¾—––øõ_ÿufggL0~çw~ç‰}~¶ñÅ~ø&뛣œùŸ3ƒ+×¾'B’qÂö±÷:ÐU'à ¤ŸñŽÇp& íI¤äµS×Ée3¬ln!èæ uC 53¡¹D̦=ˆBîª6€…ïW«h’>00—i#E=ÙFU¼´AÒj°´±Íܹ3~Â~µŠÓѵ˜Øwé¹'ÏL“ÍX„¾ÇÆæ&v:ƒhôËÐp»]’8æìéqB?fgsY.±K)máøƒžO)4Z]¾õ½¸xî,««-–VÛܹ¿DÚ28}bˆ[6è9>Í®KÔ{“ù‰­Ú6cE›‘©Yî,nrj²Daø,å8âáZ•jµÆ·¿÷WܼsÓ4ø‡ÿð¿âõþ%v¦ÀÎE.+CܹÕ#ðCdµÃÜé<ºäsãƒ[äsiöëd/Bèišõ6[?~‹³—.£ 9'áõ]ù]ÎL§ñ[ ÍuþZ:ÃWƒ6ßß­òß¿ +»°çTùÍß~…{Uþúeþô_|—ÏÿÊ T­ µö€}íÊ0±'s÷Á¡¯sky‹û© üã¿óßñÇo|‹Jé5ö7y¶,S.*ì<ºËÌ… ÌM]cõî;ô=8}ö¹\žB¹¤KŒ–ó¼u÷6'.]£º±È[Uˆ=Š¥§Nœ§ Š%…W¿ð2n¯“Î &Ç \{á9vVP[ÈòÂ6/¾ú ²fÓÙÙbÓ9{vŽå%²•aÎ=gðí¿Zæ+Ÿ9ÉÝû‹$VBV5y´ºÁäÌI$-Kss‹Õ•ûd3YÎÎϲ¿¿GèÊäðè¯VöYÙ0‘cÝFGÒxýÁG¼27Isk›‰ùqTa /ý9÷¼]RqšÓ³3ì-,MüåŸþ[î=¬3>lÅæ†Ê™sSl·Z¬¸`×üàõ÷Š„ˆFG‡p’€¸ŸPÉçé)}FDfËFFaw»JâwÙØmbÛ)³¾±IbIFËüàî}Ì´‰äÇTß®SÈ[ÜÜßäL¥88¶.ü|·?h¦m$E{\ÿÉsG’`Ø^ÿ±žª«ôm8@•JòÀ»Øs¼£mÛ6½z‡ÑÜH`)ÍîÖõÇ?Äé¹!0Lƒô?üg„=‡|6…"©hŠSEQ$¤$@ÓbdÝ"&BTFÇʈX‚0¦˜³ âCKבµk;ëX¦u@C2,Ë"ŽÂ¦y0oæ•þÊû›8þ&ÿ3#$Bg8Sbam‰ˆó—çyéâo¾µ@»îP9ÿEl«ÎÃ[+Ï?{…l)bbb ÅNá¸Ãc“tªÛ¬<\eñá#ÆFKDn—ÅGkd³9îÞ}@¢hH2H†Aà !-1_,²³ü€•¥>¡Ý~›Ý>gN䘫¥º»G„ÄsW.³¹r]LUcam‡gÏŸfugÇ øã•/Lç™G!by§Ã×¾öeÞovøÍ«ÏP_¼ÅÒƒE$9ftj# )Úû›K<¸¿Â7öYz¸c®=“§”7)æ5ú¡Í£µ*Í@¨ vÙàʵgØnîðÊåK4ö»\<7OZ–X¾÷ˆ?ºÓàŸü½/¡•ŒH–—7h'!nØF¤TFÇŠ¤òVê Ì|CÕH$³Pàî£U¦NÍQ(å ]t²þkº†nêGÊJ²,m?üSuY,¢5c°MVž¼>X`Kè€,ÝÔQY‘1,ÍÐدîrû» $1äÇ3¦³ôöFÎŒãÆR"‘2LzÝ);ïût:}tmÀÕ˜lÓœ„d ?ðÑ4Йv§ƒP$’ßGQä£îh¾ÂÚö.¦©?¦%1²"1Q!K2R ~#es¨!ˇª]ƒœ£PÇ Ý$£*hÀÙ Hd!©Ø²ÌF¿CÇéGŽ*U(§6[Y¶ •Ìã¥aŒÌ ðs~£(¢bÙ ç‹ØªÍÚÆ6m×Å ]$Y¦îzHŠòdÛV (PÇ+^ø©¾ËŸDt]>Þ¦>.9lóX½ëè>Çžö8ëi'1²ÉYyDSsã4:>ï~ç œ®O&“F’®ßÇTm MÇÒ-Zåà¹>ªª É<=·ã—–¹rñÚ§aªªòâ‹/púôi>ûÙÏ255ü|TªÃXzx‹råo6k·&&NðîûïR˜Ì¶³øw0bPdõè—yZ¨šJ¯ÛCÓUn®øèiƒR*yŒÖ~îÚ¥oþâ>‹„DDO¬¨T¡’×uŠºÃZ¯Àlz`B¾ß¬"ë*š‘‰¬m#S­ÕÈäòdSaã[Ñ%¹ÉÆú6Ab ž"I!Ý^ MSÑ,?ˆ¨ W(äÒô{\Ï% "‰v¶{T›>?zû:º¦^ÛçOþßo³º¶Î£…Ÿpæ„LXTJyòù ~¿I1£‘I[L¡X*SÎuÉè}™Vý>çæóÌN€dãAQkµ‰œ3³&a`‘ɲº|ƒJѦX,Ó¯o216ÂêÆ6ô¶™;•Åïûhf HضA®h°³ÞÇÊ¥±,MŽ©íwÉ–ÊÔö÷›žàôùyœVö7ùüµkT¤,Joáé«|~î*‹¾Ã÷î3Wé³»¾ÉÃÕUn.Þcêä$'Ç&}AuwŸõzêV_ùÜyâÂF´këûܺ½A9›e·×Ã÷«¼6ÔÄsÚtZYo“·œY~û•Idáã' ã“'(VlJÅ2µýzý!«¬.|LÙ\}î¶äQÛZåö{ºÆêÊÙLˆiZ¸±ÌôÄ}ÏçôÙyjµ:õF‡âÐ…Bš\!Ëô‰YÆ&çyóúT¦ <7wž•û7 »»UØÙÛ`|TÅõMÚí.šâSanþ"ÖP=èÐܯRëË(jJŠPÀó—Ÿåí>àìs3\Ÿ#òšÜ½yŸ³gæ¸ww‘úq‘ÿôBš·ï¡ª‚ÜðQØ& 3±”•c¯—ÎŽpþâ8¦ìÐiw‘ee¥8}fÓÔéöò–Ly¬ŒïúD"¢d¦hõ<†*y,¬#‰o|fœêÆ6ÂíÇ÷v¨u[4ÒSÃD}GÕYØ­"4 UÕÅPLLËO¡µÞ¦0š;Riú¤`Å¡èÄÏú;|Üaß~|Ûñ8>Lâ„L:Ëôå †¦KL_žÀ©ºtª].¿z‰lªDÍ0ò© ®ÓA ‘¤ ª*¡PÈpwPÇñÀð]ž²*áú¥tŽ”a#É2~1’/ai&†f #áxÎ@ÐCâ`ËÀŽQ–‰â˜á|'p¦öƒ)5ˆãIGö·ƒÓæã*2­Ín—€„†ï„;L%z™HyÓ§”ƒåºFÎp‰¿þã׊D!Ÿ}<ò?èJ¨’`4•ÁT-ö÷ªô‚>’® k*QÑ=&Dr\êŽ%åÃíÇï‘R˜xò÷ú©!xê¾qüõŽõñ œ§K ^àÒsºØi›åûkÜz÷ë7¸ñî-ÜXbá£%Ri“ÜP$ÚóAàchˆ˜$‘ˆeAum—Am¯Šb˜È²@HîG–¹rñê8ã‹¿er~ãí3svE–±š¢¡ÊÚÁîgÿ6‡ž‰Ž°²\„ˆÉ­-¿üÒ•o~éK¯²×l ©Ì À÷|ˆ|j¡NVó§^&p÷‰‚'tДjÒw\Òvš ß¡Ýv)UŠ´ªM:¡Ë~[gÈìãô|òåaš­.)Sa}y•òÈ8‚©©)TUÐnÔðz=ßÇ6M.íQ.ù]íˆ?ùóÐívÙÚÚBš¸½*W/¤¸öÌ ÝfHßW0ì<›+‹äÓ2…œDàV™™Ê#È"+}dCÆ›|í«Ÿcui‹žk“+óñõ÷¡ÛØ$“Ë’²d„È°³¿ïtQ$ŸJå½Î:z[ó p)³¬,o2{z”j£Í מcgk‡§¦U?QQ“l)‡¤(aÈÖòªmè>–³¸t—Sã£|ká8Ïüøg2‹H´‚F¡”ed¬Âli ™z£E×÷)Κ,|¼‹PáꙣåÏ¿t‘×_ÿÏsÈdU*³“t•­U‚fÆËäF^âö½p*g°×Ž8{f†êö.Ší^ˆjg™Ÿ`áþCÆçOc¦ó g¸³¸‰Š™Jaê ‰œáÑÂ#ò¥!Š¥B‘øøÆã“3”†‡hÖv±Ê£hîÜ_ä½÷9{fš´a25|x—wý"/œÝÄ"æf¦¹\ÖÆu#šm·Þ]#ˆ<Ï'­öX[Y'W¬ iQ,P”„V½Š”øŠZ½§Nžæƒ[ñ™ËWØÙX'_ÈQßß!Ñ-ÖÜ*Û»!“Sã|üþÇTk}\]B«Xx ìtzì9½¾K,‰mQ¨ÈBAUT’$![N£*÷¶)Œ=Ùn{Z‚ýyãoò¸ãB%’,¡§t$Ibù£u Å£3£Ø¶jt#—~¯@%J$öZM$Ua¨T! -¿”eáûŠ")–EQDµV€ƒäái˜Ôj5šC…"Š$Óît*•±M‹v·ÃPe˜¾ã’ËæèôºÈºžƒ¨séC Ö m8¨Ò‚ †n÷eà"eZ=×|æ¡£ 3˜%‘)YÕ¦êˬÞ}Du£Êì¥YDTÏA0™JÓj´ð€z»IÏéÒUåAEž<‰æ>ZµÄc‘Ÿ†%8¬pÚíÇ·ò>Ç¥@¶%É“"(ÇÄlžxÞƒ‘@ +×sÉT.½x–©³“d‹9:.­Z‹‡÷Vhì5øþŸþ€_ÿ4›ý ÃúÍ4j2Å4õÝÿÏ?û3n½w‹×¹ñÎ z;{Ôvj¼õýwyí«¯ýÿ69¿õî[ŒÎ•ñŸn¿ƒeZÈBþ)ó'Ã÷|4]#d)!%{$‰Š@ ’ó™ óßüÂgž§á¶P$…XŠéG1–6Ðsm‚3•"lÜ^ë“1ëH àø±342Œ"õjÇ‹ÉeLêBÓ9YQÀ b…©é Hbö÷öTÃÒ(•+î`¸.Iãú>ëk %Ñ‘a¶7:ì·—9²D.cÒØßàµ_šåäÜ)ïÝFÕ‡QR.-!K>'g²”K6óçg¨ °±v+›eîô)ž¹8Ã÷‰E 3£QÛq’ˆÐm06k HY}'äáÃMÊÅËHcdò¬®< mø¤‘¢}榇éº>±¯8}Œ”Dß‹°39öw¶I‰é¤3i¤D¡Ûï3ZÉ1{ê,ï/-²8WÈb¨‰fpv$ËÞÝkã|룛ÌO8I‰â8Y¹@äù´»¦mñh}…´¡òèADÂØt?ˆùàý»v!KËs±Nžã^{„/œ!é5I—*¬ì×y7ç×NKüÊÅp;=„'æNPÈdèxkÛÏ^™áöíM|ϧ˜öQ­<©l¡ZHšn¤i4ZìWë$˜Ìž¹ÈG÷ïpîÔ,Ýz•n§ª(T÷ê8ȘrÈï}”ãjj Ó*£¦-CÂPz=ªêDĉ`¸4LÚÌ é¨"–$ #ePËñà­‡dJ)Mù'æ§VKOÙþ´¿ÃÊã­DŽÙº³Ëê­ æ/Î1sj‘šÍ:IãµÀÇñzô<#‘0UƒZ«iêD¾‹ˆcY'Œ}U!I#'ƒ9ªH’DJ5p¢œ•¢çzQˆ¥^€ªk4ju²™ ¦ªaê&~à…@U…òrü0ª„ƒö7q‚$ü(Ó3#hj“0Hh6ö²A³¹ €z˜JƒkŸ;Áþv‡T>a±´¸Ž¶É¤3ÌÍ=ÏÊò]<¿ÍxEF˵¹üòE‡7¾¿L¦8Êý®ch*šáb§ Cc¿ÚáÅ_x‰Ýec½ÅéS)rÙ4ÝÆ %§JŠe+)PÝh³²Úæü•Yœpt*&û˜Fš“§ÏÐí÷ØØX'=zN«åùù¹óñ‡øQC8„©Ïáp=]@5V×ÖRHW6IZ)n4;L¦mî¬^Ç42Š‰H$î­nRªTèû>¾24\ Ž"zÇ_}ÿ=Êy“‡¥\5Í7†ÓÔî­qòôy–6—™Ÿ"íyx«Æíìç1ƒ¿@RîÞ¼‹fZ¤½û(šÍÜÉ9>|ï=ôÒ[»UæN]B–cÞzn`0;w‘í½=FNLϦ­.'Ä’-êµu6×v ¢6§ÎL3od‰}¿ã"‡û‘¦fˆÌ€ýê6››;ÔÛå‚N‚MÝé3UߦãEüÂ+Ïâùö«].¾ò9VÝÇõ%2c•6­Í6Ù|™í‡p x¶ØÅótÞ{û&ÝV‹\N#¥KDn›jˆ$?Íç¾t‘~·Ãæ­ëÇK„q„DD1Ÿ%&‘§8UCŠ\¿u“/}åØ^XÀJ›$I·Ó%¦f¦‰Ã¿4²Åv ÏobÙa×EOgtM:à‡Š"èõÚdìÂÉð0„^€ÓõÐí§ íÿ‡Ž8‰ñcݽ]î§.ïƒ IDAT¿±‚ª«L]ž  ïº„Iˆjh¨‰DÅN%1´drînm’oVɦl;‡E,4lfò¶a²ÙkÇŠ¬¹.~c% dq0;?V½Ì¿ÏŸGÆâñõãÿ.$ýD|º-ý´Vuœ<–=üâøÉ–¹,ÉG” ãR•ÇŸëñÛYð«ÿàWX¼õˆ?û,ª¡ƒHpÚ¿ú÷™(Ž€)ÆOŒ1vb"ÁØô(AÐó`c£ÅÊ­žú]”J¥#úÔ'©Sÿ1©TR¢@˜PÊ–þßü»ÚOF”noöyqJ&‘¥CKm”¦³÷Mc³ÓÃU5¾«Ã¶ó«ç÷7V˜Ô³'Ä”ÄfrxœF½C¿Ó N ")B3TÒI SUXÛÚgtxÅ0‰%[SÙ\Û$•+²ßØãÜ©i{»Ôê=¢$F73œ9’Fm¯Ñè8xý7ÒiušHBP*êŒ Ï±×–év:|ôþFf&3-²ÙI[›Üºñ!#cY&JgéuZl¯m{‹Ì\¸J­ZÇñ]v|H* =¯ÉèH‰©Ò­’˧‰"Ÿá‘ûUŸbÎàãë+œ:óµZ„ƒ.›|tg™ù±=FFÎÑØmâ5[LNMÒªÖ˜-ðÆ»oñüåó¼|íök-RºÉ­%œz›É™Ó¬o­’•±‚‚¢v¬,x1‘Y®ºz’E¢¶Éª]n´R\ý5ªëŽ¡GäËE·e˜ŒMåéôü¯ÿóŸP,gyíÏñîÎ#çù/OwÙÙßÁLçøî?âÕ?ÃhºÀ w¹ÝXã¼ý:ßöU>_È’J!)ÃDq€)Ü]\Á6mâØ#ŽSôESØÛ÷(Ž­)PÑéàÅ j›m_0=šæáκ=ÊGí;äò£þð.Ï<;Ï;˸AL $\ºPaeeå]Hš<ÿâe—_|žæÎ÷pñùH%੧ùɃ>ïå_å­ëÿ +Í«ÄEv- Ã29wn¿×& \ÏcûÁ‡ÜYìpvV£ßu‘œU¦Ï]eeq•\yŒññqHBÚÍ]BßÇ,šìU× 4«l±ûh™¾ë#dÁòÒ*"[@Ó†yóƒÐriÒe3Uà£{¿PòÍ,-jâÊ2 Dh"ä„L¦Œò‰ªöxœûì)Dn(ÈxŒ}úüRÁîîî@4%N¸ôÊ9fí,a<‰R);í6»q@Å°· b×Ã/”Ȉ„‚f¡*éT…n§…•²2“BÁÒM$ö÷w.aè:v—L&ëyÄQ„¡ëø¡,I&Ž"LI%Ua§ºC?ô(EmÏCÈ‘ EQ‰ã˜^"ÈËU†Ún‡R:M%,wšHBF×ttU%$!I$!rQÖMB?à_üïÿ†íÚÑw²²¼w€Ž/óêŸeÓõP•„ å€(4|®Yw'j=Eâî¡(n¢¢Èr¬à;ùB–v¿N!_¢Ñh€H>¥«ýIÊÃí‡qÈ«ŽãøSè'{¬m~¼µ}„vÄ“>°pŒ“ø¨ÒBFá@>öàùžX$ƒU@"IbråŸ}íe/$JBÚí6ý^Ÿak„n¿GÚNC"QoÔ@NÈÛ’TY!g róEÖî<=ÍýÖoýÖ}ê¸âÝ'÷_øÙTªo÷‡\¿“FUÿÝ6™‡aéE^zñkÈ’‚Ê¢$DÉÏM›Š“„˜({2/MFÄRˆIDb°pP 5Æ”%Ê© í  ÌDå\©ÍU;Cà{äÒün€¢)d²2V %Y„HB¥Ýï“Î¥ñ\¯ïÐi5©Œ”©Öö(äbÒ…"íÆíž‹+ÌŸœgee“n¯G¦4ŠfjتJ}{›z]b»V¥Î •v}›JÆÌsT‹Û÷îQ*Ž²º½Ç¯ýÝWÙZ»G¦8ÌðÔ îtÛTF=’Øâæ÷± ›8éÓìêìT÷™=Iß Èûyúµ}æKÓ˜é4[Õ#S3ÈšŠ¬¥x°ZGÏÆ´{=Š•k«7%“ÊP†f7"“R¹pá~ò“ut#B1 ú=;Wäã[Ëœ;w™ÚξףÙnÒëªhyƒSósloìPaµµÌÒn—’¹ÍlÉâþæ*w6xå¥Ìnßfü’ÄA‹„ÒàäpŽÿíÆŸ«,¢jö@­ˆ„—¾8I½ÚcyQgj>ƒÐû¸v™g”ëÜ^1² Óé1>7ÉâÒ-nÜL¡á°­œà²Ôãæj†‡ör#5©öú²YzžCß èï3;5E¶X@3tî=@6tlÃfcs“|ZA&õ0"ç€ç¼Ó|@nt˜ÿäâ³8Í­Z•­íÙ¬I¬Å,o´Id™á!Å(±ßt0Óeü†‹§&ˆ(à™Ë©×VX\Üâ½7ñ¢÷é91n×ç|Ž+žË¯œºÈvµÉÝê½Jˆá ®œ9˃åꛫì¯.°×r˜>yšN?"[°‘,XRIçl~ôÁÛüò—_ecmMŽØÝÞBV$dE¦Vm0\*Sëõ¨õ|Ö[}rIÈ^= R l%ÃN°‡/Òð}Rˆ(äÊdÄû«y^˜ðˆ—zTàÎz@Npq|‹Ó¹$’† ü©°$KL_ž(NIŸ>轞ÇÇß¹ÍÙWç‰üÕTIåb­Ý6ÙJæSKøãUÖ¡™B†èºþTÛ¿¡òð@ÛàZÄü3sÔƒ9E!9hwžÃhƆ8aÍíRCaB—ivÛôâ„rÙ&êµq f»5¨JÃM(’r…G8a`œS¯¢jª¡á„–¦£)*Žï æáÊõËäØoÕi{.¶¢ÝmÍqIì(f-ì2®„ĤM 7ÙèôÐ ’A•ÆMI‚HI¥Èé¢0>JÌ¿ôÕW8}~‚áR/Øo6P1 z²¡ÅÑ@ŸÕ†B9›B’dvö¡×Is)­ ’pÛ"g jmx.Ý¢˜.Òïw‘¤HˆZÖŠ¢†!â Iþ¬ùò ÚH…¶ o;ve°ð‰ üÒÃÁÑó€Ï¢8B=XøߟŽ»fq¸˜~`„áÁ¨D!—Îaê&N¿¢*$$IËäÞƒ8¢ŒÆ!Íì“qœ>Õjµž NýM¨TKkW(Oþ4õ®§‡Û|r±,‹(Q9THÿyBÔDÁ.N&l7 ;$§ƒN _¼rþ›ÉÈËŒf»ŒÊÄm—¥®ÉTN#Œ#Ƈʬ4jäËs8½u V†ÈéÑïwé´û ÑlT±¬û{»¸®‹¥(ˆ(b}}ÑÑ)-ݧ<2öQ„@)ËÄ0bºíV*M?ðèõ«ÌŸ"ðUök ¦§+%ËÍ; D‰B6¥PÛZGVBJy…͘í $Åãä©Ël®Þcey‰IÝP)”uŒlYO‘ΫdK å"FºL$ÛhšEz¸‚ª™Ä’L»Óctf–ÙÙN‡TÎÀÒbF*Cìïö;™eu±E·ë 2Iâpî™ç˜›dêä<£S¤m %ö¹woIØ_û;_@1 "$J•2Ý^—U¡ï¶ }MX&$(²J³ÓÆ6 NMœ`igRyMÕØkµñÓPYÛïé ¦,˜–ÒÔÚ]&†"BÙBàaÈ1ãi ÕãÞÞå|]ƒ£4ùôªÿ0B?âöàõ<¶v)MH’„•ëëIbìÔ0>Z#ðCVo¬“ÍÑ©vY¾¾Nc»EiªpÄc~,Ž$ íNUUQÇqPåè¾0xOª¢A …±›wwØÞ¬Ó%DMEI"LB*Š$Å´]HHL“\(Hå $Qß‹u M×Ñ ˜Û2!æhF!¦e È2–®‘D!’H“º¾‡¢*շ˜´•¢Þí Å …|žF§…¦jøá ånJ&BÀq©Ê<ÚÞÆHÛÄI8¨”±´ˆa4_ÂPtYã[ñ&ÿìŸÿ9I’ðò+—øÌgž%—N P…D»ßAVâ8Æ2,z~p"“•œ"#ÐäL¬ÜÇÕ4÷ÎŒDØzD1ðh_'g ÍÆÐMYÅó]$!†!&”G øi@°£jZOTǃÇ|—gЇ2 G”¥O´ºOî+â°ÝÍ “ä`Á˜ ^÷¨U/|rÃ0 ]×!æ`ñ50Vñ?p¸®‡©HÉõîÇ£+OEk§Oýû¸RÆûbgøÖ±cÒÕ™›½Àw_¯8GÛñ)ÙÇáÃˇ ûÉ×ÑqÃ>ï- ¦‡eŠZH‹]èà¿ÿæOÏ={ö›¯}õ2JÑouxg_áˆHÇЋÊf–õmb;áöVÈÑ"ŸÊá÷;4ÛÿwïdIvÞùýÎIý½åmwuwµÇÌô8Ì``­$hVÁ5¥¥"V!>PÁ>Á§C!QŠÕ†(­DW B\ @qIà`À¸Û=íMys½Iòè!«ª«gºÁB”{"*ÊåÍ›7ÍùÎ÷}S­UöÚLMNÓÜÝa|b?‘Æ!Ýþ·Ø@‘6ðÕˆBÑC& íÍUˆ^·…[¬âYšQ·Kµ\eˆ©×m:íC î¬m±µÛÅ æÔ©1Š®Íæfzý$[Û›:£ÓÜbêÈq&ç¦ÐV‘ÅS§)VÇ9qæ 'ŽÎà2ŒIü…ÌÏŽa:)%[Pñ,J¶I£Z@ÈŒHiDªØZßᱧžäεÛØ®K÷òõ]j’`P²£Ü2òÆ%¶WVõvhïnrçÖMf—NQ©Óëuê€Ýí¦iÑî÷p-O·¨za‹4N°\‡lTØâøDB¦ þÝÝ Ç^¦nîR(H“ô> Ǿ®lŽ°Í]iL»H(¤Nq]Ó2y«]bÙÜEëkH-8â®1Wn4oòýV™SnŠmºD;M“Ó ®íÞâäÙeR¥™.5°Ü"~ø ÒÖ™œ¢âؼwù6Ý̇²‹eId¦¹ÈS<77Ã\Ñdsí&ýŽ¶+T5ô¥‚ÇÖÖ&ý®ÏD£J»Ûââ.å'ÿ o~ýë*/¿|‹;wÖ˜_\`v¶ÂÐa‚O>ÿ›\¿~™ßùâs|õÿxù¹ Ç–ã8Vֻ̖]6Ößåø‰Gèõ}L—®õY<>O·©ON°|b–WÞ|m 6¶ºd‰Ä4ýaÈ`rûΙp›˜Ac$ WïÜe'ìse{NIÒ·Ý(ÉË£¦AÖ쳩´™s+3%,,Ö[]fææ9{¤„#V"‹qK’’=´f9&SKã!™?3ÃîJ›µË›Ô¦+Œ/4°=‹òX‘©cÔ¦*D~Œi›ùÈÒx÷À¿È…%¤Ä&ŽcdRÊû|ž¢ "ŠzHK •Ákó&+ï­ë˜ñã „™ÂOb2•PÞ3˱¤)àøÔ,i²ÚÚa¦>F«Ù"H3ÊÅÒȽ¦Mi`fN‰RD†iZŒ>þ`„çy€ U Û²HÒ„$IóiNä¾ÔQ1Qc·×³]"•ìevš’W`¢P–}ßg§?$ólŠÅr^3Up14¤©"¥¬¯lQ-ùþÞæȱYž|ö žÊvkÀúΈë+7˽B å<ƒMj\»vƒ'&˜›åø‰%Š¶Éìü½ÕëDÃ>ë7¯òÎÅÛ\y÷k7VðÌ€ÛWï2Ønû)ï¼ñ.ÝÝ+·1™Ÿ›b8Ѩ:loï"ìi¶îlpôÜSã’7/59}¼Â[o®Si˜L/ŸÀ4n\[¡26MìwqDA‚¯G¤™¢Ùm²¼|×)ÐóGhBf`ÚÛ±°NgŠFC"£„å9—qc Ï-PPýLGJy -›e¹1ü~ùIJÉ”5 5n¡€SÈiš®e&q®h& k¿l«±=›T)¢0`rl’Lkúý.ÒÌùÏr[æj†ØA3a ê–C¦bª¶…ÎÐ^ð/þåŸÆ g9É… ')5<Æ'ª(­PZᘽ`DgУÙî`&;[;tLuÀ ~p$IÒ\øE‹ƒŠŒÊ2l» Â"ÍR[s@ÛÏŠÄiÏwÈý´1¸t÷Êéã¦I'd{$óà Â=ù^9Z0Ø—ÉP¤{î\B4›»Ôª5Š…2*UHyb÷þñ°àüçþç|å+_AÁW¾ò•äv½^ÿ±ÐÚ?ipþÞËßãø¹£ E[S4 ¥5I–Ñ Ú}†ÁnOh‹XA/°pÅÏ,‘í­ê¶Šª#ÐÚƳÏ<ö¥ÓOœgªœòø¤M§? S1aª±m‡a§E¦5‰PdB’锺U¤ÕíQ,Us3n¥ˆ¢DKÆ5âpD‡¬®oaÇð1TÊÔÌÒv‡K»)sµ£á†(²»Ó¥T²é4i¦¦‰?ŠÄĉâøòwïnóÔc'™ŸÃ+”™¬±Ûƒz­Ì ¯¹³ò:Ÿþä1n\¿K»Ý¦\téô6‰#Þ~u­-‚Kq|i—Ðf•Q·I¦#‘dè;lí4‰ŸÆÔ+¤â68þ4×ß½)–xó­78¶<Æé³s¼ðwwX^Â’R(š[[ÔÆhÃæäÙ3ęɨ7d÷IlJN;EÔÔt†] i¬6u¦i]Þ‰bÞ¼ûfÆ=LÓ9È’÷é6û?ïßЇõ’áÎîÞÿ•å6|:C"HTL?õét×>y4û=”ÈpK6v½HɶèŽú4j n®Þ¢é·1 ŸyêiÖVÖce}Ïî“Ü~ï ~PnY»¾Êç>÷‘Ã×i¼þýັ‚#KG0´àÖ­;K%¦,@¬ðe‰rÑávõ)~ã|Bkk—Å#㬭\ãü™²¾³ F™WV¶øÕÏ|ñÇ_á×~æ$ï]¦I*¥ º£›m8w®NÕ®P+énm²tâ*U“Li¦ŽÌ†!ë+ë¬mo!¤ËÌÌ4¥Ä P#7B8&m™ŠÍV?ès3 ðK¡Šqls¯¤—±0µD¹XF eÙxŽK©Tµ\f¦f¨Õ*Ì4¦):Ń $dÒÅ@aÞ¹íáxN(¶þÀu*$¥FË3‘2׋~?5˲ƒmc?fØQ/#M“êÑ_d{ã]ž=õEæj§x}í*’ÏŒˆM+͈Qئ½WBÍÈP<·ô9NÎ/±|ôIû(›obZ)ž’ܾ¼É»oÝIJLææ'@äZÖ¦eb Ût˜Ã+¸$iŠ!%Y¦Ø ¹±$c½!J ÇFk…) Â(¦Z¬äٖΰ +WTË2ü ¦ïw‰QèDá:.–i3 †Ò`4ò±ŒÜD Ãa—B9ÏxsN4L7&)Û%¶7ÛxE›ŸÿùçU„,%S*G K‰úÃ*Mé$ #ÂLѵ56V˜ô½ ÷þþpç†ù“.HU‚D",%\^߈0-›Š“㪄˜–mÚ8–CÁ+Zd¸Ž‡ÊrW.-㦠æåàºX¥9ÍõòØá`{ ¶Ÿ‰ç·Ž>ô»@‹\¥“4E¤ žGÁ0ð ƒ a¹˜Ìêþb"ßÛ~†­‰“×öÈ´>°ô úˆ½9­Ûkã¸N.“¯ô¸qõO=@!ìôéÓ;vŒ‹/R(è÷û<öØcT«U¾ñoð»¿û»|õ«_å¹çžãË_þ2/^äk_ûßüæ7yþùçôÄÿŸÎKg–öŸV 4†KJÊyÛ„jÁ dƒg JNF¦4ZÞ›»ËI?Ô¸ŽÉ+/½‚ñøç¾ôÜsO)Mg a1V¬Ðµðœ2 H²  ƒv·ÏX£BµV¦\*Q,×è··öì´†ØccdžÂ0\fƧ±‚&í~ŸW{5>±TÀµ :-E’&ØŽ`äg€!Qb;·\$I2Ž[¤ßߥäTq<•™¼ðÊ¢ÔÀ”çOˆ’EÞyw•Ï|æõ͘Ÿ™F)ÅÕw *KÊeº½hÍøD…fÓGhƒBmŠBaÈD½ŒçY”ê“x—Áú*†‘råÊMžº°ŽKÔoqåvÈ“çT'¦‰³SJ¼z•R©Ì‰åã¼óÎ5¦çh];ci|–P%llï°ÛëÒlíâ¼û³ù›1×Ðœ_(òý—v9{ºöa¥T¾zô»Ý†¸a8¦i䵤8Ž‘ÒÄ´…±Aß¡d¹6²¡q-“˃Ón®|wsƒj£B¥R¢;0êiÊÖÎ.]¿ÇX©ÆÊF‹'–Y¹»Ži™,/”ï¾õǦêHËAg’0Ë(¸ƒÖsGŽ" ‡XJ^ ?mó×+¿óÑ"»71u†W©1»x‚8Pð\Þ¼z›l¾ú §Îv™ðüÝ‹W#6Cþôöîl•Ï֫Ңײzë2ñ¨¦ÃÅ·Vxòca½µÁØÔ8 HŒ¸ÞÚá­;+t=AšÜM":JcHÅÝž†äØÑ“Ô« „R)³ã è‘i BK’0þÏÒ{Áò¾ l¤‚ÅbuFÂf_P-|p2"¿fû•‘}äìþ÷ýÊÉûQ«åñ×~p‹Ù“Ó¨8 œbyñI´‘`'¦Îp|ú1Æ'žäõ;!k;MÆJÆ>MQ$¼Ù²9:6VãžG;™%쿇=çðì“s :ï¾q—bÉcjfì`Ò6,“pâyBÈ\çzŸª¤2 #hI”gdzË0ÑYÞ¢ñƒ˲èTË”Jól;UxŽE4R,Ôñ£‘Vd©ÂÐZh´€‚W \(‘¤)ZhÊžGäýpaJå*Nyé•7xñÅ7™žo¦™N…# '9ÎtÆ UôâˆÓØNX¼ï¼Î>}Á‰{jÕýA—‚ç1_VtB“ÍNÌXI€0"Cè;8–‹çyøA@Å­ææCB¡µ QpAkl1 ”¹Å}Ç´\‡UÀö¯³<PŠ–Eò¨Û6sõq´iĆaPÒ‚Aò^ÏùOþ¼vx‘²—‡q€cºX–…à\¢(@H°¬< Â!!H|Öo¬?P¾3Iþàþ€ßú­ßâ‰'žà¤ n IDATÙgŸåÿðùØÇ>Æ÷¿ÿ}ž}öY¾÷½ïñÜsÏñÎ;ïðÛ¿ýÛ\»vóçÏS«ÕX[[cee…¿øÆÿI¦ݶO{wø¡¾:­§ÿ8°œ|ð¡ýôL?8ðu6…Ä42†QÊk/¾Ž)ÌÜgTí!B³8%3Y˜r›y¦¹Ò!QI‚of¸®Ídq‚zÅcg{‡(ÊÀ²I3QQ˜Ãv,6C—'ìöhíî0ì,ÇúnßØ$Ó‚¥£ãìnG(F#ŽmGŠúx•Åcó¼»ÑÛ@–ª„>ó“e†~?s÷.__ñÌ…“4eÈ®¼s•‘3ìqýú¸–¦>ëÑݽ­‚#Gæ0ÃG« ¦'àL¶7?érfr’ëÍ-œÌáîõ÷F!¯\l±¸¼ÈÜÉc<~î «]j¾ÏÌÂYF~ ¥R6×vØmŽ(×jÄiÄ#çÏÐíivÚDQB©T@kuue?Ö:G=Z‰bÆd2cä:Tƒ±HòÉ`$RLaf %5Rk,Ó@%)Â(Ó¤ X0ˬŽFcXiNp†Ä9â5Í,ŽÔ4†=‘%®¶ºD*ÃH J#4Œ×Ëy€ÐŠZ£A·?DX‚bÁãÌÌ ®Ý¾ƒŸØØÚ@™ía×±¹/óËžÒbDÊ…ÇNa„šÄ«sçî:‘Ìp-“õtÈ#'NszÞ¾|™ZÑ¡:±@»ÝÛd²\ãµ—ßâ[¡æŸº²³ÅüÒÓ\zåEÜò$ëmªfßÿ?O4jñÆ‹¯²xt8Ö_>ÇÕwßåÎÎO>½„ÖŠs'NseýÃ`HS%ÄžKii•¤¤Z³m@aïÙ„;qSZæ‹ž©±Ùƒìpæz8‹x?BtÛ÷‹‚:$ÅÀšòX‰ Np¬²,ÏÎ…&Irîá…Øá÷8ì*´ÿÿýÚòÓljã„<ò‘  R[dB“¥šÿö_¥QLù‡Ïÿ#´z eÃß^üŸ˜+•Ø”‚µ~óçΡ•dßjö™¥£üYç38½¿Â˜©ðñŸ:Æ·¿~“¿û›‹œ=¿„4sjN»Û¦Qn …À&±dQ„mÛÄ*&U9w9ÉRêå aSðl‚ A§`š6˜šR¥@¿×Dšqjây™Þ+™úª^RÑf§Óe˜vÂÈM¼aã9Vf`¦4R°¾³M7éÐïØÞl±½‡Ì¶‹“Ÿâg>ñ†4¹æ°„Æp¤Îƒ™ÊëÏyf(k}Lup óþìÞ}Ðt1¤A§ßB`r¤âÐ2-ü8 E"“!š4ô‡=ª•:cµñ½ {ïÎJDÙ0(Ù& ãUîôûÈL‚i‘÷÷÷éRT«Cåhä·‹ “Pµ Š€JJ•:žåbë i—Ä>Z fÝbNÏ6,¶F#tŽÄ9@mk4†0ò²x¾;x¯î C¡è¡30„A©X!SûÜiãäA½`—réÖŒ/ùË!¸xñ"›››ÿÞƯ޼€š ~g⃣Lü[ø¡² ‰¤lKL ÆO=ò¥g>ö8¹Qù¾›ÆÀ÷¹Õ©’F;Ì”m‚8Ø€”qaY1 2$C¡eL¡QávO²;\˜rõ:ýÛ;™q¡ÁLEÐë·˜›®³µÐôI“ŒJÃÆ°\2!1‹ ®o‡Ì$[ü_·%§Æ+ŒÕ="Dœ \K‘ÖqÜ!¯H•cwiŒ„ÕõÛ„©ÏøÌ"Nq†õµuNgb²ˆ˜AHÅ*u½+w®“$#ÎœiP«ÐiíR)Ô)Å©ÇÐÄÌ;ÆÇ?ö8í­›¼ûNB«ë37[¦ïûÌ,gvþ(X†k36VŲrU°µ­MFYB–&”J%Â0¸oB½¯³¯¤{øEÁέ€–1_ªqwä³™D4ŠE\a`Y&Ž´y½Ó¤¯Í4eu8`ÎóH2‹ë½!‰S`ÇÐÏÀ´MJÂÄJaW%t☱Xrø³Û%”Ñ&`86­8¦«›¡Ï®JiùýÀ§¥RJ®…ÔŠVwD”Å8®Åë×® vy%šã£žf´ó •£$æèñYªVÓ€Ýn›™…Yš£§–ãû!Q×gffŽæ. 3l¯¯P®5ÀÎøÚ_þ%·Jcü³Ïÿç|ïæ¿x¶EIÁ ß}‰£Ë ôÒ„ÿý¶Á§§$ï]¹K¯Õäâ;Ûlotèô|c“ã|äÂ)ÊžÇÍ•»,Í,P(h§CB$RšA´AšfZ2=1ƒ)­‡pö¯ÛûU¸—1ضû#ÍŠD@ÆížÆ*p³?6°Œ{¯=œ¥ý°cÚÏÖ-»ÀÜàéóŸB™‚^—Š»—žKÍãgÎñÈ‘Sh3#Î"ño^Þ!Ô}~ý‰ÂÇÏJ0²{Õ!ç¦çQÕ³¼uå¯X›djÎåò›;4&ª4ÆÊ”½"šŒf»Z ã 4B’H%$iŠcYH©sŽ©8¶Ã ×"S)Qâ:EÒTaJI’Àýñ7øÊŸþ5žçR.š¸…YÑ纔-— MH²„ÉJ c_ƒ\ Û&Š"Š…Qã:ýÈg­Ý¦47ÆÙŸáÔ£'(VŠ¬ÝXggm‡ ` ”]BæZÜ{Ùàá¬ô>ñý¡=°î¾oÁágþຠÐRP4ÒÊ¢ê:h2TšÛg%q„e:-Bd®Ö%…$VŠ²a~ªÐÆýÄžý^ôAùð1ï}Ïí'¡aÄa’3„¦7èS)U°Ïq){Ej¥*ŽaÓéu¨X6¡NÐú^ëíàóí·¶Ž$NÈ„"N#‚0@é Ó6{¸ ¡÷AŠ‚Õ›kì9?ÿüó<ÿüóÌÍÍýDƯ]z]üqB3¸i‘G–~²Ìòs±Ÿ9¯¼ø*fÉ-"u^&° cÀ®©” <Ýp©;EV·;,LΑeŠ$ËèøíØ¡8.) =¿GX(²Ý39í(NÔ V(°µ³Ëôø Ûk¸… +aãTŒON%!~âã9 ·Z§X®# 5Ò¢ãÆÌëUº;6»«··xôÂqv×SÌÂßøÚ ÔK6§æ29»È+/¿Æ§>¾DB ·P"‹$ŽÝ ;hL.“&"?e¬°½ vIP,40<Ç4iuVI•MÐ"Šu¦§&©$1—oßF–Æyùê÷ÈR—µN‡¥0LD8ôý±ãV\ÌPreíæA)ǶM -ÀøþQ.H[©-„©A(²H§ í>ÜXõ°oÜáü‰¼ÛëínƒëÁ}™·kzûIŽ]ä½a˜OζÈ&™†­aÈú^Ÿ2/‹KDæðV7äh±ƒ-<†¦ƒ©#D–ƒ\9à R iHº~JÁq*b=ŽYëרUšþÄŸ®xܽø¯yn¢D¯ÝäH£Áë7nà`ᨔÅÅE’AÀpàó×/½Àôô4Åb•Ë—.Ó ;ܽšâ•%«wn3}tŽ»Õeþ³Ÿÿ/øÛ¯þkvÅçŸy–æúMŽŸfùô9þàò%>[íðg_¿Èé““]^àä9‡Á`ÀæÚÉ)¢¨Åpg–†Zm‚Ë·®sáÔj»k U†2soVI­XǶíƒlõ>Cˆ÷õÙ”Éîõã6L™«€™Bs¢.éã!¼©Ì¹ÿj!†•’¦Š—.ý¯¼Ý²øçÿá^3„0‘r;:p ÍïóÏ9yô¿öèDgib¥âï£ Í™J™‹…gùþÚEžrë¦ä;ý:3sãhMî‘+a˜†¤"Ã’‚‚cÒêuÉtFÁsÑZ¢Ò¡Á²$†Äiœó•eFÙ-θxùW¯­°µÙäã{Œ^o›ji’hO-Ñq¼ÀE¡hzL×&ŒTåªM–a` p-) za„W­¡È„Å;¯½ËÕ×n|Ö™™ ÊŽævÛ¥QL(šìUr®k½¿ÀÖäÏØ~EÌ´MB?Âvìðómm‚À‡¢‹›Y†Mn‘‚]4Ía“Š!ÑJS®”ƒƒý C èÆ)ÚÊpB¢<åoöc¾OÏ{/¨î¦Ë„º´‰ãÜv´ÙoStÂw^yÿí«/#ãè“G {âqv[]*õ*åZ KBÇÜÜ^ÁvöÀB`yÙÚ¶m„TjV=–íI¤JØèwÙ42Li‘¥UË¥+2¦œë³ç@ ÐØ°Ã@°' =0‘ FˆlÒzè~÷3þ®©ðýáÈǬ”ø¹¹"¯\þfm±¡`§§¶†,--qóö*©L8wb‰õÕ]\Ïc8ub™V§Iš¦´F]R!ˆâ˜™³GÙn7¹Ó¾Ëÿx=æ¿þßæÆë¯359ÃgŽºøþ€(•h§ÂÚí«d%ÁòkÏÑ_ëÓi7Q*Æus`–”KÇ—yãâ[(Y¦½³AJ±^äÊÚm]8Eç½K„RR®4°MCäèÑápˆç帀U:>Ìù><>ìµÒZ“*‡{i‡_}´@ƇW/Ú¦iîñN3Ž<:Ç[/ÝäŸþ—¿G¨áƒëô|d~ç³ÿQ'ƒø‡|L)©´b“'Žžæ½þ*?ý…³üÍ×®ð?ÿ_ã~á<ýìyâQLÉv©Õëlno1lîb;6ËͳIÓ§öÝ£¥ÒÁÖ¸MgŠ×^¿ ÀéSKضE’$Ôk³ô»»8n.È$j•´“৉V¤aL½V%MR’(NèözûÊØ=Ì¿òÅÏqòÈ qªˆ²„‘¡ñ0¹¼mpv2zè9ÙûYj¦²û(JJíQÕضR­0ô‰ÂiŒ\®ìx,ŒÛ8Dh ÕIÒ$ÁFNQÊôžŽ3 `' –ÄÈò`}x®8Pþ:|œˆßçƒm4H­ã–°r!Ky¥Áp8Ä(ô{Æ ¢T±0»ÀÆέY˜šG$Šxä#le‰iÙyàå0`•ƒRwÐÊçIË¥èÿƒÌÀ!ñ–üÏ&2øÃÜÄÝ ^­ã:¾a–Š)’(fwkǶ F‚[40ÊŠÕp‚Ÿ=Û-Ÿ£‹38 vÛ-vÛvGm&™±r½ÍØ„AAk¾½Í0VŒ¢€±…c¼=*rÆ\ソF:°¹£©],ËÀ´b:Ý”ÉÙ¦ýÜF dÇqòS”xéÅïò±ggvñ4¦[ÀsŠè jõI¶7w1“Va ¡} ;ƒ+;,ÌxLU›L–cž{lœn·Íêîˆkw=.]Sìnöø“?ü·lÝ ›+òø…“ÔÊ…‚…aYÔ§&´-.¯ßäêÆ,ÛDZ[Z˜†À²-<ÓÎ{o†ÁµA€/=Þêíb‹*V–âh+íœæbZ,œ. {»ÿB>ü$ÿÀ "44Üênû€|¸Tä~Ö¨µÆVÊ´±ë iq©³°3|Ý¥­bn‹»6ˆL±tü($¦³Ýgiv†42h#ÌXs|zžŠírfæÇfæ)ÕK¼zù]¾ýÖ[ü |„þÿ–isûÖ ¾²²…m–ØØhrëN§èñW7VøýO-¶-Šå3‹K<ñØG}Â(Ä+xŒ‚˜ñÉ‘Jq9}Š$ˆH²ŒÝ^×ÑÄí¯†…y€ŒÏy¶±ŸÓUV>¼Íᯇýk»ÿÞ•t—_<_ã»×-ÌX"pȈIÐÓ¹Ù+™‘˜JÓL®7#®õàr¯Ä‘'~4VØÙÃAjÅœ匙r/€4L~ëó?ËËw}*æ,7‡}ÎT $E¯DµX!øÌNL³09ËD¹ÎÐ÷I²„Dåþñi’‘é\s© ‰#Ÿ(òõo¾È›«üò/}š/|áS|þóÏ’¦Š0 iÔ$Q.T’(Åh4¢^ª‘¥Í~ǵI’¼DÇ *Ë3Úv·E¤5{­VF<èþÌ?z«Q V©ˆÌÀŽB´H˜(›÷zÉ?ôºï'}{ÁNæÀ)CB×}Oÿ{·µC”d*ehvw81ióÎZ~^„©@íí‚ìõyU–k^›ÂÀ¹ov‹ï ƒh<üï{?èû·B0Q2)®÷£÷©É•€ö‘¹RLÏL³ûlŽzx¶I7I¸xóYaÔË\in2 úñˆ çOSÞ½u%áµ+/rt~–KƒMV×Çyò©ßâ?]ž#6,Þ¹ø*ŸÿÂÌÔ«ÿœ+w¶Yi¶ñDÊŒ3ÇÆØiL FÙg$xA@©:FµVàƵëLÌ(•f¨—y{µÃ 1[gS‡üííËT„ɹ#'Øé¯à”&‘?"SýQýç‡mó£^w˜•<¼4ãÙS¯\wyä¸Â<ÈvöG–Y˜2F'ðâÚ,Ÿ8w’OÌN¡RWC*4i¢{\Ò‡‡Ì…4ôÀ÷‡­= òßç¯IZ~걧Xßz…¥£Ç1«CŽLã‘ÇO²Ûëà ‹8M1-“LÝû|åB‰î°),«ŠiZDa÷-÷Z ß'U‚oç5Ξ9ÊY$JRšÿæ¿ûcΟ_æóŸ¾IŒ?á=”€Qà351Å0" IEy?`X*U˜¶}ÂœZ˜à—û X–@d’õáˆ)Ç"H4Ø™Òxvpp&¥ ””NŽ¦F|æýs¿?!ç×á^pªÕÆöûx®Ë`8`»³É™é±\-tmêõ:ÙÞ‚f?®Z¦…JÕA]ä»»7öÕ~~ïÃÜLÓ@jA’¦H-¸qçZ ËôH“ЄIH&4–” ýË4HPYFŒ¢±r…ÅÙ9lÓ¤ÝëQõŠô#ŸiÏá–œ“¼×}0·Weèô:¹&ÀCÎñ'?ùI^yå€ÿÏ/~’ñÃæÓ2-¼‚GÁÍùt;»-¼bf§ÍäÄ4›++Š%&&&twÐIˆ„ ™«º­ØjÅÔ%ÆÝ1‚¨Ï ¹ŸØÌ.6FÛ›ô;¥ŠE½QÆ-ºt¶îrL›ÜHæk+”³Ö€JÍaÔqÝ©P®NF!RùH©p O»l¬*N-¡ßëóÆÛ×8yrŠ¿øÖKœ_žFÄ#„¡Øn®óö¥ËÄiB^b|¢Á±¥q⑃eµ)Ô l¯ôùèéy‚îcõ9ºí«Ì/iÌåÎ]–ŽÏ±¹¾ÎM¿G¯>àäô²`Ðö¸³yøG¢×ä%PsÔ#K;R©°(Ò,ÂyaÑÊb¤aáJ—Li‘bì;ã—ùŽ=åàwÅÆÃ/îÃ2éû)>?:Û6³ˆ7w|öÈàCmx‘h¶;CìªM&$†ÖX¦CÏ–d®`2LhzíöåR35:ŽN̳Õnâ1,¨%&BŒÑ›$Ö<ë·o3ì÷¹²ÕáêVÕ˜@NÑí„?}g—ù+_à•wßdòÔ½Û»lº¤1E¯‚ízœX>G?ô©Õp,É‘Ê8oÞ¸Âã§Î0ÞÌxjüoÇC^ÛºCfšT¢æ¡±ÿßBˆ÷aåà³T%„F„§ F·?À¶m¢($S9ZY)E¥PbP¤$IŠí˜ ü!óÅ…È…;â$à;‡°‹Ôëeâ8â±GOñíï¼ÆÑSó|ô#§ñý€A˜Ó¶ ELgT E !±l›(Ið‡>Õj)”㠨잨O¼;¢Fzr‰õÕ“3ã$Ã!iÓkï²µ>Äu=2Ï  "6¶ZŒÙ„CA·›°º¾ÍôÂ$®1êö©”\Ï¡V¯319A£Ñ ³Ó§;Œ8¾Ôàöí‚À§Z­!”B›+½ˆ,Ðìö9}z™FÉáæÝ &K 6M¶·v)T¼6†î17_`ýn“'ŠÜ½}‹Ñ`€Ê2\R:ÝMÆ'ñQœÿIšÀ^ϵR­0ðû|ók/ó·ßz•õí&çÏ-cìIF¾øÆ;üù¿ù6ï\ºÍg?õB 2‰T%ð ‚8@™9z¸hšœ^šds½MÏ*p|¦ŽÖ¹â–”SdÜi™D©‰áh™;P]Ú´™ðÇ Ó cµ´†If*^Jšj²,¦é[ض•s¦¥ ÉLîölvú‹…¤ˆ+‡dB`ÛE¾sÝâÌXBÁÖÃÀ6Œ\ ŠbñâœH™ÛeºvØ“4!U¹£•4äsd?K…û9úyû7c¾àåÊh©ÊûÛ{‹TƒÜ_Û²mÂ0BHaæèú­pÄ@æñ£T1P)Ã,%–‚@dtUL_(¤aâII’(ú™BJóÞqp¿n¸”’;×ïòì…}€J5==ͯÿú¯³°°ð_¼uõMìÚ¸Á™¥sÀß•J‹ŒïþÍ‹>qîK>zžéñ1VWÖ927KÁ,0v‰¢ˆÈ°mÁ¨ßãÿæîÍ‚$ËÎû¾ß9ç®ys­}é}™îéîÙ;1ÄJØ$’‘Ä­ Ã´LÙö“ÌéÁÃŽp0¤)…‚”hq!’†H@˜Ì>˜Ál轫»kͬÜóæ]Î9~¸™ÕÕ==À 0`0üuTTgUåÍ»œ{¿íÿýÿ£Ô2HƤa‰{ê:Û»”g*Äý»›diZDÅHÂJ U P™¥Tð¤e82Œ“˜*ÔsÄÝ6[;-”Éé¶G mòlDs«‰µ†êÜaú½ GjÕÒó1J ¥KÚÙ`¥1³´Lµ\åÈáÃ<ùôólu5p∠鈨÷=pŒ ªT$þ#'PŠGO)"z“sêÞûØ\»I¢SVáä©{É…`n®ÎÆö&ÃÜШù¼Øë1Î-I:fÔé"¬ÅõràÕþ»‰Å•R¢ñûçmù®ÿ ôrb¨—Ÿë€DÕpÏ߹řL{hÖZ^¼YåPd*ÃR°! "öi ®øì¢|_<&_Ò$ÃõŠLDPÌÃhÑ‚ñÉq<šy†Œ"Wpc»IÔ˜iÐ:#åä£-17÷Ӭ׎‹ãºTj Vfjœ_{Š( y冤* ´&öÝ!³*§åëçß âZRQTb£½M§Õ!ÖšÀ÷Às8Ÿ¦T¢ –Wi6·™oÌ#Œ¤T*aŒ™0©Ý]+ö‡ÙrÎw"í¥”(¥yc3%¬ú·M?I8pðO0“ïH\ÇA: x•rAÌ`,®’Ï!Nàá{ÿ'çh[0=ñµ¯rüÞs 7Ûß#Ï —75ç^ÙÇ‘™ÑlŽz$Ý6G–¥j™¨brKg<ÄW‚Lgè,g#ƒ3su漈õA—jT#MSjµ:~à“Œ“½çéèÙ{éœ÷›k’ùOž¿ÎbõµºäÏŸ}‚Ÿ:°Ã+›÷!Oê6ó>rïG8¾85ìq(¿—ëaßÞñ­ï¾Ìì\…ÐccwÐ1 ã!å°‚ §.›½6Ê…ÈHŒ²T©-Qqßý'˜ŸoðÚ«—xüÏ.\¼ÁïýîWxî¹×ØØhrýú&Ï=ó:ûéGؾÙæ·~ëßóg^åчO±²\''(Ç%'T*U¼ zÞµ#gOŸfv6äµ×¯ðüó¯óÌs¯òüóÅèÕ§?÷!Î.–Å1¥RÈÞ†«›=ÜÌ2?[#H…ä™ï¼ÎßüùS|ï…ó|ïÅ‹èxÄ}º!Šþ²6)®t°€² e/C8 ƒP!ÜIÀ ÖjV£ˆ^šãóeK5’¥cü@Ò2âÜÁ“…¸ÅBUpµª 숊?`¶ÒÅ•ŠA¼Ë¥f……†4)‹•’’0Õ>BgI–`(ÐÛܺèÛÛÉZ±ÜÞÛ[?êÃp0¢DøªÈè×'çt‡â|D5Šè¤)Ý<™ôܶdÞòµŸ°EÊB'}Ú¦»zVì-š8ìÿ¿9ç‹MÅÕ¿äP’9ÊSŒGãÛ²g<ÿQg9û›}ò dÓÝmQi`’ŒJ­ÂxS Cv»#„W&Ž4'«KQ•j9bÐï–"6×® …¡Ý¥ ‘/P~™åKx9»­QPÁ˜G ¬ÑÄcI©äÐlŽŽG'ì´‡œ:¾ŒÖ–¨‹ò"†½¥RˆFlnocrK¿×åÈE|à,««+$Ã!ª\¸xn¿x—BñÂs/2ì·xàá‡X\=D§?B8ï{ô JHF6GHÉÌlµëlt·±&#VXKßä(i§)Ö  kñç»d%Ú¡æÃÆ(AM¢Æ»eµ?ìAz»Ó+JÝZºTOçG½ãíLÿnZ:56G9­žTcs–g—§eN­–¨GuýÂJÑ,3Õ9ªQZ¹N­RÃqýn› æg°Æ¥Êq&%—<˨Dæê fê³ß´N&%5UÌgNA)B`Xm:ábÏáþ#ËXáàjÁÅï¿ÎáSÇØî .Ýø&ˆœåù /ï,óà¡š7‡SvŒvÙíKœtÌÀñYÛm±èG¬‡\jmÓ·’#å2važï^º@dë%F£^m`¬Á•9Û»;ì¶;4f§]”pßuÿy¿sžV&ò©ð|;ƒ²Xó¯¹|é¿ÂŸ~ó9sú“\m]äBûqJâ$±ÆRýO]ø§Ÿû‡šm P¤š·o3¼f…¥×?OÃoñÔKoðßûC.½z‰<ÑRÖ/nòÒKçY¿¼‰Ís–Vq™ ¶=’î˜ßúßþ€/ýâ§øð‡îàùçßàÊå›|ücòåüsœ}øG-3[¯b #>ÿ…ÇXYZÄäc¨˜‰ö}ñ8F 1Fã„!ÃÜ¡îkŽ=L³ÕæòåuJ‘Ïé3GøÌÞÏêÂ2ã,åôé£Üwßq àOþð«|ãëÏÒê ènïò7_y’ëo¢sÍh8ffi†Ï|ù“HåìëSNZ£ZUc)°²è‘¼ß -HmecìÄ™÷ž@g9ž¢¬`ldÁŠ5é  UGƒÈ8i±º(ùºJPŠi„'¯…Ì.D G/\·¬6D!N!A¸Yžz%ªQ­5Ž£HÓô6²‘½QÊ `Í‘.V”Jè4ai~‰8‰q¤$5;í¹5tÝ ƒ!IÇå¶I¥o:Ò%,ˆ‰Dä4°ßÏšf%K³Bäb"=9 R÷Ôµ&»vñ:|œóÛ)Uý¸Îù;Ï<Éü½pL¡½-T±64¹H›• ¹pèŽàP£KÉ/á*Ð&/Fo+m ž}âyœ@9´cjõ,ËŒ-‘Îgš²£èwv¹Úl³tð$­¤ÇUþáƒsì¬oQÉúÜØlá ï» f"°íѦÌÕ4ËæÍ ò{„µkäIkFdH'œg Ó lÌL=¢VYd”ÄüÉ_| ¡wù๠»ÝMN™A)ÁööÚXêÑ"÷žžã¹§¾ÅÉcG™))QΓ_ÿ&am–êìý`À7/„Nàc­e^(*¾ËÅAÏ:8®Ã¡ âRsÿÜjœó•‹u¾|v@.ŠA~xwNù™CL„æuËò©w¶P÷@Ó Ø\éàK!¾ïSò=„…7[ÕòAo”r´1ÃZ¿ÏÍí7h¶ÎÞ{ÅnÖZ²,#‚b\Jx(«¹ÙOùüÃÿ„s'‘„/}òWØv¨§¯a­âzç%®6æïŸ=Ë£÷Ô²Û»?a=ðÓˆä8YåÊâ ÆZ^îM¾÷å,' H—^½ÊÚk7ùÄgeèR×á÷댆¬®,òÙŸûŸûìc´;]ê3Ò$!(—b“S©”ø¿ô3Xk¥C„ði·vñ=‡R"(f}Ç©&#D*ª•øÜg?Êü— zX&ÏsÇ¡;èøÂÀûßÿ ÿâŸÿ6/=ûúÞ‘:¾Âû>ÿ(žëëÓ(ö=9ª˜q–ê–´æt–x|Õýáp€_*ÑOâ½rñþïAíË iœ¢eÁ³.™È8T¸ÙíâønÁß½W©’ ň‡–ûDÌQ‹<>~Ð’’ÓGR– H)W«è$f0¤ÉžœdQùž:È‚É—:˘ñBú¤Y‚’Vo—¹ò,ÚZúñ€Dgtº}<ßÅNF²r Z„¹]OˆIÐi‹Ê™EUNIu+[ì›âÄߌ5{r˜{Ùý@Å¿»s¼ê½²8ƒ:‚w\Î-”.Æ…t¹¶-I´¢Z‚5øÞuÍѹA1ËÞÛàÕÁ¯zÀ݉m_8h1è shÌÍÒîuX^š'õÐÖgñÐi¶ú;¬ù«|êðˆN@½Þ µu™0*ÓßÝ¥µÃqÌ(P­†4æ稖qHma™­k—që•h·cϧ×3÷Pa /ð!Ót{Cª¥¿^£ßE>~YáUæ±Zã…%ìxŒqzý-æçêHÕ@+Í·¾ù »í§¯põÚuÞÿþd©Æ¢8ûÀÏÒìŽxå…§ÙÚð#—›7ØhõÐZpîþG‘®¢V÷¹q-#šDjFŒÖ(×Åô;Œµ%T9V*ÖÓ˜‡üî(åÃÕ‹¼oÁòævOJ„œ–Š2ô»±Ûú/Ó ·êÒ|â:3Gka†5ÓžÑ[å"÷ÐÆj2[š)jÕ•ðv’‘Ü kðÑc)Bx{<Γ½Ý&¤E²;™™œI¿ÄQδ% k,ó…‰c·Z<Œ”’æÚÞH†T0E†a$ãDâ˜>j`4Ì7é ø³§þŸ:+ÙÜÊ°R"pÐVsdá 6)Tˆ>uÏŸ¿>Ï/Ÿ#·—’Öæ1ÆP«UÙØØ`~å ëëët;ÅÌèé#Çö(:¥T¡¢¹¾ÍÙÕN¼À :Á3ro¶øG °|ß¿õ³É€O?ôkdVð¿üá_ò/õsüá7¿Ê¡ZÊ(©òKý8^¼wl$¹ü[ôËÏÌD÷ˆp@i¾ôßü<ƒQŸq³q}‡œ=Nn2©xþé7ø/ßx‰ýÛN½^æŸ}?û_}ŠY!8p` )ãqBàIV—Ȳ ë¿£Î.Ž§ÆCb sYFý!ªB¦Á (—k ‡m\×e0ÓëYXZFEŠÀwIb‹ëº¬./Rò¶6·p«:Ž Âk ­&‹Õ•Àç_þ¯ÿŒ?ûý现“%Ôf¦9®Ýw¿Kó–âÄYk­Q®Bå­ àÌ^ïö8R­¡²/ˆØq÷JzRÆURu&Ê\ªÞPˆÜ À+Ðà¹U8Ø ­5JHŒtúm*¥ Žt‘(jŽå»×,H²2k1:§ä×ÈóŒÜj•Úý]„d¢Å,ñ€ªë»˜Ì2&)”¶ˆûcv²¤”´â>2Ë¢ÚS”Q$°ì—JÑŒè¹P±ŠšKKCI”6\ŒNH3Âà 6šÄ±¸"Çщ*PìÒJ”«pŒ@OJá? ›Þ¿¯¿þ:qóÜ·ßdeýî]ø­ßÎ"u‹ÈUšVÜc!„4­ñÄšä¾Å6 jž.ª\R°Ý³j(Œ,×8~À1¶øÎõyÎ5Š£-ÚŠÜBk$p|Ïc,n sÎTð}æÈíÍmÆ©F†!üÆrmÌÂÌ2¤´67 Æ=q„«ç/â8´N¨”G¦ù\»t‰qf g9yß¼þâKe éÓjí0Ó¨£ ‘(¬'a´C)¬£—nûÃ~ ¥4óVkÉx³‰E“Æ=î9QgÐ1´³~©ÊG?úaæb¸ÉìÌ!ž~ªÍ8m±¸qc£ÅÊáÃ|ä§>ÆÍW8p௽ü*Çï9S(²x±Ê¹zåM"?@›%o•µò<‡Èç}ªÄ+½&Þ侑 ™q™s¹ï{x$ù?jà·ß ¤ýŒÍך,Ü;ÃÁ“ N,/šœÍÝ&†B#÷N›Ò7VK :íË‹+·P™ûÌ‹çNÅ6ÞùþM³ñýû9e¹úAÇ”e ³‡Š¿·š,OÈuÂp0B‹|â4N‡82 ×ïòú˜]™árÿ*rpÅ-¦²ý}3'0üüYøúUɹƒ%–ã>Ù4¸± Ï p‡ÕÕÕ½ý™Ž1Ykéö;dY‚öa<–üõwÏóȇF§Å<újBò<¿Ej»y ,4G}¾ððQntÚü³Ïÿ=^ßÜàtcù=IþQMYX­†ìör¤.ÖX¡9r|¸ÊAÃ#<Í=g³qc‡ WÖ‰fªÌÕçØÞÙb³½MɨF²,#EÐÎò1 ³óìtvp]—Ì®ooà$1išà7:Û˜[¢ßmQ ý€q2Æ`q}—Èuйfiq~@:N”K£Tf{Ø¥¦sz£.¿ð‹Ÿb}kƒšŽØÖšÀw ±ÔE‰ÍlT8y E<]ïŽS0]ß!K  ,„¾ÏÆxD®5ž¶{ÙâiÉ$pÝ Õ㎄,ˆDæ}…r=Ö‡ql[ƒšŒIã$Á÷À±V硃+‰6\ï•8¾¡µÁ÷ƒ¢ÖnA§åJò,§'  ]”à@µ†Ç4G1‚ˆ–ɉ‡c¢îH±›fØQÌárþV–¨Î,°xð•j™V‹Þ°ÇüÂ"a¹¶¥ßæÎ:A¹£q”ÄÚ¢„V‚ÊS6G1JNÄÚÃ2¾kù~gˆ¼Mo&¨ÞI¾£3Íp;¦s­G6Ê ª·Á®}gƒÙã5¢¹oÆåékuŽÏ¼°Lœô˜Æ™¦¨Cc2Ëòò2ñ0f¦:K9ª€¹;«Àps`X.NãnYû~»“œdÿßü0Ô4›·&GŠ ZÔJ”p(ÚêâA&I’0Œc<ßÅ­;<¹Êv3g~Τ)R <' pƒ[Õ…,Ey.‡Ê#vRˆ<ª ’@y>`ûFK¦ ­5íÁ.Õr4‹¹¶¶Íƒ=Œ²¡¬É&óÛw—†¼Ó²4Ãq=Çì8BxH´ xiÍòð‰sT¬ËáÙ¿ý­¿æ¡CG8ÎàIΗ©¿'&,¹6¼xñ<‹Õ¬ ?êc1XGRñ<¦•)%®RTëÂÙ nàÒð=ºý>¹Tièz”ÃHI–¤T¢2ƒnGy¨ÀeœÄHcñ\”Ä_ p…ã(<ÏÅÁG)I–ŠJÍäŸ1„Ŧ™5…ô\+ ÿT«Ôh¶Zh“F%:ý> µY¢RiJf X#±Õ{¨ã½>èÞ¥(î7)óaÄ0I‹õ$E‘ic÷4Ž÷°Ó5!Õ> è‰ã—¢@"T‡8Õ(G"Œ¥¦Ã\#&ö¤‰ ÆéG98Òa¬S\¥èZ S‰ç„„A„ïHGáºåR‰,ÏiTëTü2Õ¨D’¥`%[þ’ µf7ËÉM1¾ÕO5Z#%B 2ip”"ÆX“ã:!ãaŒ’Ìò¦Í8&u\&âÖYKÛ "ס© ½QF¢ 68)À“‚Àñ Þ‡)ˆL ®]XãCÿø=ç;Ç«¦vþê³+‡ÞÕ¶†­m¯,ðäÓO°zÏ"™‘DÂ’ZƒpyŠ’[ݘÜsäB’¦9Zk¢ºÆÁhM½$Q¢òÁKO¿„6§„á@©ÇS­&·\¸~ƒq‚”M7£iÊœ™™ÃÐí´Í°¯È’;[1iR!˵Š¦¿;âÆZÇsðßWdqj­ a‰ÝöˆÃÇV ÚTgWjó £Œxœáe½&½Î6ñp€”’¹¹Yî»w…S÷̳rp4Qäf‘4OY\¡W° é3 ñ\0"ÆÍìÈòÒãϱ½¶Eú`E¡óŒ¢\®R«Õ UH×€’Š‚gÝh Ö`r3éh †©f{œ²ål†¤YLx¬§)›é˜¦É0J!Æq=¦üÙJ N–K„V¦A² •¥¥5×ú#6£ Ê4¨áïDé‡ÙÁR…ªÔ,xJ%†b$OsL¦É'ZÍy’‘I0Ê £t IDAT¥3Ê!ÏZO#ƒEá7df,GŸ@5÷Îv¸ró:m‘“VþKS"FŸ>²ˆ¶%$I< ÝjS­„ôãm²L³¾u‘j-ÅØ2™¶eßw¨–*¡ÃÆ¥‹ˆlÌÉî%ËÁóaãÆuÖ¯]a8Ñîuq䈭&ifvwñ½§NŸ ÕjÒ8\¿sùÊ6iîÑŽÇèüö¥/+0"áŸ|*âÇ Y)bžÝrhõӢ߹ï}Óë½8»Hf3ª~K‘åçyÒÒÚ¼BÿòëH)ïÎZt·s3uÌÖZÎÎY>}ê,›”Š1Œt _}ùilb0êÝ«OýdM`üŒsG¡ƒ°ßó‰‚ õê,õj%+ «¬,Àø%¢¨L6“Ä ×;mŒ’,WËtSM¬5Z †ý>OùŒFCúƒ!Ín“W·ýàWÚ†X¶Ó”,#Æâ{!ZJ¼À%Žcà–$cžk ¨PŒÓŒ¨\¡ÓÞ¡×n¡ean–Q¯ÍÖúM\åphv›¦(G"=‡ÅÅ9¬(¦|×c7îe¾Ó{Éq\”’\IVëe ç"È´Þs¶ŽÈÑÖ•Éd}Ù[A¬Ñ@j?jÅËuˆ”dgc¥b¾ä‚£(û! %1JMðÓÑ$c5­n³`ß²cp|.mõymCñj3ã÷ÿ¯xöÛ/òÇ¿÷6¯6÷®n1Áâ€z­šIÀ\®J)¤’{kxúÚs$RZ¬çqsœq3ÉPÒâI%Šþ¸£œ -iøjcYë XŒYÅ{ãSÖ*@à{ŽÖæ{Aˆï„AxוùwFøÂÂÍáÃÈm»qj aqz+!Q’ã!}kØζÓã:È»qžOÌ‘B°³yÃÕ:kùWÆUòžåÕ1Ÿ=&©Gu²4Ʀc†"Ã$šµ«»¸¾åÄɣă>RÍÐifHÇ%îtX^™ak¶Ö·X˜§µ³Ë¨/Hó]2mX\Z-D¶E)$ñ¨E°²Ta÷(E‚(r™›?ÈxØg·)Ê‚^wÀÙÓØjnâɈ­àÊ«/ÓŽ¹~£èS™ñ€›W_¤ÝMÙÚ¾Èâân`8tä:½˜'¾ùW¾ç^´•D¡âšcó xËÈý‚M¼Öë‘ Kä;4GCÖ§~7׸NŒxèQŠ·²°ÅÁuo X~`þ6‡:{¢Îç·ÈâœåÂ}ü‹2‹p ?{Ÿâ•¦æTi¿`òý„úwß—;fÈñÉ/¾ßå™K%Þ¢ƒu$Ž-ÄGM8‘ßžl @»ëìä±ý¨mTÑ_ž)ø­s“ãº.ñ á䱂ã¹èI©qÿðþ­R1È…‘ qxh5G;’Í‘beŸœTžãsâÐÉ=ªi?Úä†ù¥UÖšÛì^¾ÈêêÁ½cÞ¯Xu·c3¦àgö-\K\þ÷Ï?Ä7¿ûñ¾û ‘Y6vZüê‡ÂH…ÿÞµØÞ3€3†7¯_g±£RGyžC»ÛD ‡•jÄ…­M*aƒa2Ä:7I¨ÕçK>ÃÝmF£1µÀG[ÍÖ ­@s­Ë©£ÇIº–Á8æµí]î?óEŽÍ–ÉW’[˳ß?ϼ³Mn]vâ6‰/7,Ì̓(äY}ßC%#õ‰*E/¿ÎÒí¶é´w˜iÌÒŽñƒWi†Ã”Õ¥6v¶1Ò’9¾ãàé R¬5h,J€“b4nnÙ'E»‹‰sE³R)#´%×9Ò‚Fc'Õ¡)á‡TÅH™ü&×R:¸B¢Æ)»Ö²T¯aÒ1©Y ¥pŒe! ÙŒŠ‡½šªåp9hjµ›Ì6hw›¬Ô2 eo‘ç’áÞ5ýÊ¿ýKΓPsÇ+tú$ŠRT¢5ìÑÞ"ÝˆÑ æÄCܸ¾A:²xžO©T#CF>…ÍX¤µ½A¿Ÿ1JSª¡Cµä`Ó.ž+˜mÔ `‡PtúCúݧî=LàK†ƒ>É0!Ë ÕzÎk¬ÌÏ°¾žpþÚßyö Ì~0‚Ž/2N‡,Ϲ|úÓ§Ùêô‰Je6·vÅÉ3gÑ:GŒËåó×ÈÄ-ú´;N ciZ‹…2–Ÿ#@Æ‘8V0°Ù{R~ gú›CfOÔo]s!8ðèâ[ׂ(úk‹#2–¼8 (1ÂüGWø¤vLCå¼ÿȈ7ãeü4æ™ËC~åŸ<Lg?À¦Îu ty/ʱS–4i‚À¥\«påµ Žœ;pK@þ]šÈ]’´N÷-wþ”{Ç¢R…¬cã!&ºÝïä/ÊíZH—,ù¤Ý+ñaÉÂÜ #íàýäi¼ßµI©Ðœ>r­a«[kÜ·4¢Ýi( Y2æx­ÎXæKeÆ:'ŒB.oo2ª”q Œ“¥$ç!­8áäì ž+Áhœ0 Îpp¡‚@àhð•âS§Nq/ÿቯñèŠË ›ã…]îIǬ.­â*E’¥äXÌH#uÆns›jµJgØ#(yÛ[7™_<ÈÎÎQÙGˆ!¡;ÉT°½³ƒzÔ}¬"Ïu¡À¤}ŸÜÀ¶N˜/Eì F{òÔe›Y²¶µ– ß½ÈÆÕm!õ…:GÏbåÈJ*z½J¹“òü×^ah=þëÿá—yñ;ßåɯ>¹wm_áûœºÿJs!¾ ð\o’5;´ûÛ¸ÂÃU.q:"pCr£)…ÑÞû… Zç$IBš$X ó³³t;»8FbŒFOžIž[’€ ×)ªµÚÞ‰šž£;ð£ .ÞùÜ™¾¾›ðE·Û%Žc¾ýÍÇÙÄxÞ;ç×N{m{äþâ…eïYdm¡VM“ko5Ry…ÞÄäîµ:¦ûyGµUO4¯ìîöQˆr-‹¥i,£tŒà¸’^g&[¶Ö®"•$ÍSJQ{Nΰv©M¥>K³Ù"ŽÇ4·]z½>Ž °h´ö‰Ç=ßa<²»³Ë gp<Ÿë×ñ|r$ÇŽ/²³q“ñÈb¬¥V[ Ë-ÃáÏõH2M†äÉgÞà“?‚›tÙØÁW#"¯Ï‘CeßãÍW×(W|6ww¹÷þÓäIµ‹¯óÈ>ÄÎƾþå•Uœ|¼w!ïÌüVëu¶Z-<ÇvÂë‹-r²@úÄöÖûTóJë7·9ç;M:ŠG»Ó"µ9J“`ׂ)dQ…‚å™»yJ© ÊuHó ‰ÄõE_u˜f´Û,Ì?†”¡=Ĥ]›K|ù±Ÿ¡er.­1¸˜l€ ×uÆ¢³”¨’s<™“&c„-tÔ3“á¹­æ&ÒóPR!Qtû}jA HÆq‚ïydyŽ’†Š´ø¥›ã[IÊ¢ëRŠÝѨà½ÖÏuˆÓBð¥¸>ÀßÃw\êe—­xÌ°7äÊë×õbüÈ£ÓìòGOsôø2ëà)h&®+ ‰ÄÃ`0ÀŽ5µZuïœO™Íø‹?ø+ò4'ª„œ{ä,':1yÄ(âÑ€+—v8xω·Õÿq…/¦híkí˜ÕßZ»wùZ[©i•m"Ù¹¯í`mW®Ük£M³ãéãYëºõ±ï ¬ ôB<×Ã1Æ0¿´B/ë³à»…òŒÖ ’˜J)bÜë1hw¹~½C’÷ *Ç­àúeª w;øÕ®]»A:îQ-WÐÚ!ÑÝîˆÜzÔkaØfq¶Êp”³»3¦\.áü0¦6³ÌÚ¥ól}®­wY»Ù¢Õî±vcƒ#WøâÏ}„ѨÍvgÄ°×à#…Ëp\Ì$k­ —θÇa·ÂdÈÀB9PTr-›'†¡NAZ2c(™¢/+¥ “k^ûö«¼1I öÛt}üéÅ ~ùš¥•yB/dY‚µ[Ø\µ’ã4£Õiãø^átÎãîNG?ù÷>|”†ãápqmëßßbãÊ&s 5úØ«>òð¬ž/ÈE2CÁixä#2ÊLj,áþè[XkùÌ?øŽ]¥ßïóæKçØÝnó•ßý*ŸþÒ'X9¼Âw¾ö ç_¹Àg¾ôqŽœ=R°ü H“„—ž|…ãgŽ2³Ð –‰‚ò­„goÂTòú³¯ÓÜhâº.ÃÞoÜü‹¨ÏÖxæ›/óÆóoðëÿóžýÖKüw¿úÖ5ùÀð•¯|eïõ¾ð…Ûþ¿ÿõoüÆoðë¿þëïná¿C«EuŒ)X¾´)x1‚ÑpDšÅÈ;ÚoûûÌAÐëöˆÂQXÞû½Óë÷ȳb€_ ‰³˜•ú ëÍ Ž--3h·éõ»”g#Î;Ckó¹±4ÑݹÁöŽÁ‹\âQÌÊB c-¥Ú^X!Ž;Ôgh5·Çåät¶ ÊQä:Ǧ)3sË4[]€ã˽}0’tÖ:–—‘ZÝä²Âî?©Åß»_cl€ ,º½Ú·+ùìgÛ 8Œ N!÷xt-jÖÓ”$àÖy‹ï¿sld¿Ý)ôð®œ)a$¯m;Úæ÷Ÿør2›‘Z—­^‚œw0ï®ð·bÓk*¥DH­‹”Ž+0X£ÙŒc• ¤žàÄ(*MÔ!ÖZz&f»è4¥R-1¡2ÏÆîU§Îkë»|ìp‘‰Ý-®L’ø|oíqî_H¹:ªs¢Òçr¿K°³Ã飇P8 †#Vf8è „™ž\ a¢²W¦g‡øž$&3XmŽ"ǸN±Žê®Ç(‹™qBv²%ÐËB%(GÍÄ©ŒÖ„šQ!‘Bá*ËÚ…ÌåÂ9-2¿2K®5~ÉC§9ßø£o“¦Ýgš&ý‹Ð–Ë×oº.©€’²–Žp‡•R™^žã—|î{ô$U¥PÆàbhÌÍ2¿´ˆ}ì>Ó*ŽæÄêÖ΃´H+ÐiÊJv¬K— “òÅ_û9.¾rž!ðÄ…]^þ£?à±Ï~„ù•yþäwÿŒ¯ýñ7ö®…ò<þêçþµ3\»¼A­VáÈ=xö[/2yñ‰ïòЇîã‘OØÖî§vw;<óõ£/ÿÆ/qþ»oòo¼Às¿ÈÇþþc!¨ÕJ,=@/rê¾ÛGŸþ.Ú´ ó)ºÿ–#.Ge Œ±†þ¨»7P°¡Ïm,å°BVöÞg-8àÒ×}”RøJù%¶º9t˜kW®"ŒEUæX™+sõÕ‹tz}Ÿ®°ysƒñpHš@»=À÷ ×c’Z­+x¥~Xbk{‡¹F«s0>aU’RŒP”Àn§G·µÉWþúiæ*šÙjþàœJ-ñÕg|þœƒñ¦Î[·õ^›kŒLxßrŒ: €…#³Tf#ÒQJkm—å{ÞÚ£Ë>fCÏpþ†àìü˜Ü18öîˆÐ½÷V2[_þÿ˜{³É®óÎów–»Ä‘¹geÖÆÚ‹dq_Lš¢%Yc·mY-7˜ö4äy˜y˜'c^<ðÒ³áó0~iÌ^ºÛRÛîn/²µP )Š—b±öª¬Ü323öˆ»œsæáFfU‘Em–[ú€,d¢òFFÜ{î=ßò_R255õ¡ÍYJyPIïs§÷77-Ás’0ï1sxÀ·ïL#µ3ÂÏàƼûŸÑOº ]gbòa‰(n"¥À8CèB ü kE+•Ù )IÈ4"(–õ‡4&¦N0ˆ E?e%­ë”ÀùŒ/iî¸0§9>õ4_õ9ÕˆÕ<7VÖ9¾¸D©TdÈÊtZ-ŒM |‡Šv§Kˆ!êÇʆÃ!BHÊ¥j$IF1ÖXð2LGšŽýÓ}Á„ QR““†žxJÊ”r¡HÎ:v:]Rcð´ÂËË¿ñ"ùR>q“$¡Óé21Y¡6QæÖ 3}z¡$ÈLóa$ý¬èùóù*7Z[Ì»Àã/Åb™Noa/a8ì199ËÎι|‰fs“$Ž¹rsJQðâ£5âÑž?Edª¬mõÈr;àØ‚¥2=Çés§™(ç1½.Io‡Å¥Eçg9Ü8J£T¡uè¦Cb£±ÊÃËçéŒRRÓ‰‡LVëmI´¹ïª„àúÞÛ1hÏ’Ó·–×®æøô‘.ÎŒBR>sÄp¤1Yêq¸:äSg¦¶Éá҈ɚå|Ý£8„@ï±Ýö©Läq#‰•{„xDbÊKŸ‰RÀh3¦~x’¡`’„Ùê,8Aä20Æ=Ô‹…‚c(–þî{‚`r­[„©ÊLåï‰ý‡à^g|)—)¢ ußÿ퇠G`G Ó™g\*q*á^iÒ}Wª?Ê&nÈ þ®åø´ÂÓ RPø8añŸóÙ¼¾M¥k…ïûzB8¤ñ¾ ¦ ÆËqYõg‘¡mà Kä>ؾÿ B]Aš¤x¾—mÐRàD‚oòµ|ÊÂÔI”°l´7X¨M" ó³B´ò¸Þ\a¡ÄØÝ(C#`ÂÏ‘ÈR‹Ô¹±VF&ڒĆ|àÓ7‚JµŒ´ eÁI‹31ouë<º4OBŒQcSÂDaÇKKiAd%SÁ5<Š¼sý]>~ê“|ck•£yÉ@Œ°ý!ÆZR›‰ÔrE´rX’Ä ½<*©™+Zl r>‰5û­=‚0ÀŒu²µÎÔ]šŽíZIò^€H ¡RëÀ¤Xk$)Òó°qÂõ·o1½!Êu() \JNJ"Ï>ŽÍåm¾øg_¡¾0A£Qc'l‡ ‹³‚¶Mé% Î ^õmÞùêEJAe¶Œ/$µÀCYÈ>{Ã%2Ô¯T_d‚!ƹ̄Áe’˜Ê2¦Ii†É˜æ#3À£V>ÊÓ”Jy åÒ=›ˆ¢R-2=ß ÈçpN3{t–“gOqáÅ3T&‹=”ŸûØÃÔÊ!„úl‰«—W¸ôÆ.¿}ÓžB(Á÷¾ù6o½~™—é1”ç“D1ºpâᇨ/L µäèÙ#:¢D¦–vãòMž}ìù‰|ñ‹_äÏþìÏBðöÛoßgjñQ&ŠK7–)Ïüh"$ÑÞÇæ³Bà›¯~ƒ£§a\‘ØôQÚb¥,ÖIîÅ­Šƒ8ðµGdâ>ôu~í•ï ý!R Bá11U…ίP¡´Okc•­•&±Ë1L ‡¶VoqäÄ)®ÝÜ%ÌåqaÒ²½Ý'—+EuGk/¢Xð°©¡QŸ¡iîl!¥ÂÓÃa©év6ïÏ´{~m’õ27.µp²O>_æÆÕw©•Ó“œ9{˜æ+ ¬a˜$´öú :<-¦Õ1è“å:™0hµvÑŸ‘!byûíÎ\½p ™luF£:;µÀíZhl’ru/ÇéÆ_{Ø2I•(Šô{D$HCp¶T#‘zCæ*úƒU¥YºXÓÅIMµ’ðîrŸ¹z@Ô¯³›æÙë¥)Hcéüˆ™RŽz¾@UN TŠ±Þ0>X‚û7)ÀOþ»‡%«üÕEÍ/vqû±L¥Ta4ˆ Ô*µý Ø×Qœ^tèÔ:Aâ™ Hfî}Ísþ)µ”åK”ïÈ©Ä="æÞæú±'sçâ7Þ¸ÍÑÇ–>òõ”¶8þäbʯœÑ¨ï“ðìõÁϲ_ÁïWËB(÷´÷Æ÷ÜAQFüÃ¥¨ÑkìD‹øÖ‘þìîÍ$8”ËèiB€Ö‰a,¬v;Ì犕f-âqkÚ:;ùX&ÒiH„¢à…ÑFðsÇÎ!\Ân«Gßn3WšCHöŠ’¢µ¬E’YßWüÒÃ/ñ½ëLñ:7“.(¦àL7èÀc¸›¢u•J5sOêtx¡Ç^·Ml ‹…i¬1tF]¦“lí5ñ}o úÌ6±¤.!>Ö9¢Ñí)$…B I1¨„ðÖ­ ÞþæEfÍ01U•‘ej~ˆMaÛôÉ)ÅüñY ÅÝíú‚+3a“á2P§‚w¾y™Æt™¹C tj s>˜¬°HRƒ/RR¡PJ£œc$NHBg™,é¦ ÝÑ„ ït¢Rg¯‘­Ñ±<¨–H—‘Ãœu8w/¦&û&1íð‡)V:¦Oáy>g¨à³¹½Êüä¿ú?¼ÌÊj“oÞâÒZ„ß^áÛ_~Ç_zŒö`—‰ò÷“8.Ý𸵹M¡1É\àá„d¹×ãÑ™Y¾uí2æìaéí¼ÍéF/½ò:Ÿ~éÓ8™­g'ìøš™P³ÛÙ¦X*såúàÛ+Ÿ}ê“ü»o/ð™“Cl(ØÜÚ&!er¢N©R£¹³M˜oŒ%y=zƒ.ÚSÌMLÑêôÉAVM2vØóçµÄÃs“ó¬73 %%žIq*kS›4CèJ¡HlŠJáÔ|ƒc¤8Ž ? $$Ö%(åá)‰Àa’„ó?~Š0°ºÑ$g‡êXk£€‚ÇóW8VHÝEfɸŸø(`®P`„`k8ÄL4b)_ Ög%!ОÆWV@!W`eÐGK=NV3>v§ÓA¨k$É>Uðþ»"N%ç'G$NÒm·ÇX%PF±:Œ¨(J^ û> ‡æ˜=4ƒgcúùÿ׿Àä\•~<¤.Ý^›|9y“K˜ Ø4"P«ftàWþÁH’„?ú£?âw÷wùÃ?üCàÇ£R}íÿ#;=¼J%‡->ñTfê«Œ"…DKbà‘9 7ö`®Ê¸zþðÓåÞx³E#’b1¤¹±…C¢4ô; {›Ûôâ˜#Çç‰#VÖv‰Ö6&'5{í-vÖ×hL”ØÜ1јe¯ £H1ìg4—îžáÐüJú(ÑCÊÖ¥T«EÖVo¢•¤R*“ÏùĽW[;ržj£@§Ó'_È1jm²³1d}gˆ•«¤¬òÒÇOpõê Œ ¹|e“Ó'0Ú48º”&ê?³¸ëŽ"œL ºœ>y‚ÛËwp8F½ä ²Rà ‰Q’²ðiK¨è9þ÷rtû1W–›óÙ,1ŽS¬2ÈåsÄÃ' J(Vº»±s¬8x¶Pd;H•ÇµÞ)‡ü:;Q„άˤBMjPå<ÿý³þþ”Ååås帾÷‚:ç²×+á¹ n „¹~ý)ÅåÕom•yöðÅŠ”ö@>PŒù…QËðo·øÕç+¬¬Œrš‰yŸÔJ<Î ©è”O• N—ù»ÿðóçNóüqG’HâÔÜ—mÿÓC ~ó‚Ã9bàq¨ ÿõêˆ_:ᙾºk¹Öo غ¹Í÷Ö¿?’[ ëøì“®îD/Æè@[q0³³™–à}ÈJ·y=…I ‘—â‰*ÊD$Â!C‰McRað…!E,ûë,Á¡IœD‹QvºUÒâ—ô.fB ÁB}–¸µL’œ‹ðý"&àd¦?=0™eÞ>s¿U†„õ3Ìګ¢„ä•ånn+N¤²ÌÖz‹Æt™\®L»ÕÆR ÝMI­À:I©\#I ‰LÙÝìR(• Õšds«ÉÌô"ÝNŸ|(˜›«Ò¨çXœ™%Wšà¯¿r…·ÞÛàÜ!ÇÞn£K3˜¡áí·ÖÉ•#žyê­MCdÛœ8s|É'ÆlnlÓiРژ R¬P(Jy¬0 “Û›; †#’8EÊŒþ „À '%¡P¼²âxl6¥¨ú4wúl47)¹I¿Dµµ$qJ(/Ï¥nÄj&Š!E?$czølï¶I}…3–^4ÀZPŒûsŸAo@©Pf²®Yyõ*ó§çxDÏÚÿ2Z³(ú‰G=·(”•LÖ4ç¦JÚçÏߌ91™qt£Áˆns@øóSO=ÀO<Á©S§(—ï&Âï^_&7õ£Íœmg‹‡ögÎßäÈéÑœÌl0¥TT}ËJ[2S±|ÐÞw?4s–Z{H¡ñCŸ‡Ž%±¢7챺¾Ã¡#Ó´[mŒõ˜=4Çõ››Ü¼qc†ìÜÙ¦µµ±Ž6Š•‚Çd­Ìêê r¾C›”é™IúZYFì’ÞظEœ$Òë9ÖÖ†ÌΕð}Ÿ³§B ¸ts3çOqíý¼}qQ2àÑÓ‡xïÝ.{=M¿­Y»y“J N>|‚3/qþü,S“e<±±y›z­B¯Õ¥T,¡„æÂéóX¾¯Âaž*MBòêö&©)pzöu/ÁsAÈnHé4ÒÓ þÕ“Š '¸}y…÷¾q“h8 T–¼ò·W©Ì–9ûÒYž~næ›7t-kØYÝâöw®qó†cãÆûÿ]áÉóeÂR‘ Ï̳x¸Êó?Î;¯­£Q;ü‘ü !Mª,©0 xáx­ÿîuÍž- ¤Å$Ö¶n6imtxÿ×X¿¶Åů^æµ/}þÞ »†n,—çR:>}!Ÿ´ø“¯øÓ×ÚŒœÃ #¬ü_Ñ|ñ¢¡9ˆÑ¢>Vxõf“5ÅS mUB¤ ¥Ä'“-|êX‡/¿øHFñG_7Xáów× ŒDŽÿõ¹ @õÁëý3ÆA*$þ’Ìêå2ǧ};EiÝß1ãµíŒÃ¦1‰ðXéõ‰âˆÛÛ-þîFZ9G$O<ü1®5[xAÀ·o¼†Ñ ÿpé*ƒÝWÙéí±Ûßf4R-Ö$c8hR´|IœJ¤u(!yþ‘¸²³‹D†E’Ô1 (_¡„ÄXƒ§5hElzý>Qø>Jz¡JÅh¥QBÒít™(–IMŠq©²jZ©ÔtÀ°Õçý‹·ÙÞh¡=%}´˜$EEg8Ã"Ze+µG.ôùµßx(Jøãÿ미üúU6ïlñö»WH¢„£,Òtà‡!žà‚\¤ŽXjö¬cm·Åj³f m“°±¹Åuý!ibèuúäryækSÈT0Š#œsÔ¥$Ìâ[ E¯ß¥uéEÚƒ=Óe®1"JR§®³#Ã(©Ù¥ T& :¶ÛÈ{ŠˆŒzæœ ½„™$ Z„(á‘8;ý€¥©³•øËñg<a3Ì€gS„vœšÏaíGϹtï«çž}âó^8C!ÒëìÒíô¨Tëøa_pçæ.N+[¢ÒTS,M"u€M~ ÙiîÑéF £!ѨG¹T£×í1ј"±‚úÄ»;{T«9¦f*XÓéÆ8cHâ˜bI“õ¯Ëñ‡féînÐÚöXYÛâüÙ)®\Ýafî!6w¶Èå'¹~s…d4 Ÿ¯Ë\¿}ƒÔZv7·…E259Ën§ÍÊÚ¾ Èù)i¶0´C¸Ùí³:bµdÔÏašï³;è’Ïçªë}µ*+Zx,Ç#V:=ÎÌÎs»ÕÎZ°cç¢Ô HŒÅš„‘Vì † ”F(œ=˜QfÕ-Øí4IÓ”Þ¦ãÐBþ>z“L—®vxã¶ãæ—ߣ4[¤V/qbV£TD#°”µeŒ@áÞJLJÉzs…æ£8¢7ì’WU¤€£§¨ÔK_ræT¿–'ïg®A3sEÞym™hóöuøÅ}šB!á[ú]^þ—DŠ¥ó%rai]ËßirìT)ÃË¢a„¤ìq~Á£Y¾ue‡ÃSERg¨ÏVX}Ú\•é£“Ì›Bšòdñ£ÅRœáÌá€ó³yr:Bž=,95íQ’TVÀõQ.f®ä#E‚”!BÜE| !î·Ït!>g p‚ÓµÄüÛ_øuR'2$7ÿ—Çó=R—'q¦¸'€#ð³Yl·×ÇSa3ÉÅBf`®r Ï 0QŠŸ;ÃÜM¨’4Á‚×_}Ÿ£Ç瘞­g —µæ©I±Æ„ñ¸RrÖb¬¥R*P9:ƒˆ®½·ÌÕ·npëò*¿ú©§ÄÉÝ„`ˆl½(©R"= h¡H¥ gR¤öôº4&ê/@IMàiFÉiZ[ú‘É*Û{ªa©ÆE"n55¡qW ÇÝî#ŒE_ößã~·éÞ{¤„ Uãu/V¤¤Òc`-y,¡o¹ye™g/|Ø2ò÷~ï÷øÖ·¾ÅÌÌ ¯¼òÊÖþ窜÷C(É¥UÃl!Åiñ‘mú$y@ål¬AIIjamy…ÔXúýÃ~L¥Z#W¨`ÔBM²¸´À Ýáö=¤6,¯ÞdC©Xe{kÈâÒÓ ŸéIÇÉã³t;m:q’Ø(º6‰Ënèn?áú• —Q*Cœ¤x~ŽB£°píÖ5Þ»r‡£ÇŽ!]Àµå«Ô¶6‹KtCl”àäeæ|ª•<«·ßÃóO?ÿqfçæ)O.0¿x˜À³Ü¸z…V{—Út­î6«Íõla‰ %µ$ðC”öñÐ\¥ì¢(ò‡’ú®ÿªÈ¤©ƒ®qä´æJ³IB‚t™’–^&y/‰çÀŒ5 …ËÚGû.LY‹Ü“x:@Éá%Ç_üù¾üï/òîå]Þzóú—7ؼµÍ/>æsî‰9B% eB(‰P¤ÖàÒ1”I:î´7XÙºAapP±¿ùÊ÷K>Ng€kciP „cÀ+†<õò1ªð+ŸœFYIà|ìß>GXñ™>^% ²ÍNK&ÇãÏBaI¥O‚&Ò RiŒÍ2àôGt®².£åa2­a—åø°(ÚiKË–ºsraŽ-“ãv¿Ä{â0[a™n’0´ ï¿z›^»Ïîöä‡3r©´ÙüÌ<2Õ .%ÕÁcÖ)’(2àÒ{®å‡?Ÿ”*£Kð­@ãH…Ã3ñÁ›×þo”t$:Ŧ)â£îàŸbì?Ps^ˆ7óó¬´‡(ÕrkÆšÂÎâ¤fg!Æ›ÒH@9 ØZ_ÃË+ò%R“°ºãUªYçB(b—çÐÄ,‡Ïþ*~¥ÄÞ@ =ê /âd€pȪãf¯ƒOi$G*9–Â*k[]´s˜ñ©{òÉ_¤7Š €|±ˆ_›|P@i%~àøJ)raÀÄD™Q’0Š3a_xhÇ1­½A.¤R,3U™ MS¦&ê¤ãÍÙ÷|ÂBŽÙùW.-ã3 ´ÎøÓ€Vz ärŽjJYÖãc zœÿÄ“œøÌgyò_~’‡ž<ÍégNa•»ReÏ­1ÈplkÇ­ölS ¹8R}“bŸë·o°ÙÜe·Ýe³¹C¿? µŽ©rƒZ½FNxÌ ãB0N2{I#ŽÔÍ]+\dÆîä¾)Œ1&J1ÞèEæsïDæ׎»Xcªâµf€‘–R¨(Á$)…1m4Yµ­õ:û»ßý.À‡~þ¾Àïÿþïó;¿ó;üöoÿ6I’üÄï ë Z'$Òܽ¯³su÷ç ˆFÑ}Çê4I‰Ò„áh@®2I ˆMJm²†IbFý!§Ï] X,pãêEÞýÞUŽ˜afºÁ¨Ól'´‡01Y§ÝîS­ÌÓé5évº¸ÔÒì%´6n#mÂÍ+oRŸ[do÷Wfuy•R5O¹,X»Ó£ßꃟðÊ«ïŠ7¾ñuòù+­]/ !xáPÄ+ñn·Ç©J•¼6 ´&oÆã8«ô¤Â)MÄ"cÑÚ;Ð\þ Ä~6ºô•RÇñõdN/aMðÜË‘”œªWø›o¦üêK t±D"RüÐ#_y°pF¦hfXß^G(HҘÅ2Û½.N‰5H—u:q ;•)<¼û îbµp° „„Å#­µLÍÎò¥?}ãGsln@e®ÎúÎ:¡I8õȳ“™—óN{ z#0ÆÂí7ÚÃ<IJXQ_Ìf³….‘Í3YòöF@è§\˜ ØŽ—ï8žø•ó|÷o¯P*kê¿°ˆû1Ô?’$²ªÉ÷ýûÜ?jx唿z«Èå½o3êÇüÖÇ_À}UÑŸj8$ òÇHXF;I¹X¦?è³ÿ°‰• ç5$ëƒ>ÝnŸÈ1ˆØ $yå1_\§àßÏFPJ´,w Aó/©<úòž%\øynoîñúêÛc†Í¦›ép¢˜£ÛëQT%æåwøêÅž~èLæ!oSnì9<9B£È…ycˆ»Ò4¡eHÿéÚJ(’4AK‰ÄIŠE”ŠEÜÈÐObªµLó:(¥1‡ ¬47Æ^‡() skwîz±‹ñçJÓ¬SwWvwLMr’ãÅ2ÿe¥Ëc“EvãìLŒ €Gš¦üÁüÁ}…Ó½ñýÐÚ°7æí7^§ÞŽPú‡§VåÓ<{þ‡ûek©„?ƒ£µf4„wŸ­ ÓúÁóÒó$a£µ»‡¯CZ{ÛJ%V®ß¢\¹ðô9Š¹W/­bED£Qfwk“Be~wj0¬0ݤ\.S/ýc\¾|…£G'X¾Ód²Q"ŽUf¤±Ýâø‰%FËÅnŽ;`fi‰Û·yãJÌÇŸ«pår§ž=Ç«_…ÅÅGÙÞ¹JR|ߧÓêâÛ./¾ôž4¬-_bзTgæinnP™*ÐŽûÑB1?~dÔ‚¼Õ D)mE€ånéwXÌùÜèöX*äXî¶9í‰ò!AÒ§àÄý„Ĥˆ$›#Çã›pcÖZܘpW= îÑ_6{[©#I a’úŠ\jùÊŸ_XB12¯ÓÉÃu.}ý*åF™úb• ”]ДˆÖV‹B{)*ÑMÕó¸õ±Å OU«üã·nR=Z&5—6›ÌÌÌ Œw`qè¬Ý'8ß÷žP(;à_|ö,I”ròÑÌÿõ;…Mwxÿ’¤Ìâ¡Œ°(,™ßNŒr¡)ž$xù"ÎŒ(H8?§xd~ÿZY@cåeÇçeNðè4€Gì,Ïòè€Ï Ÿ9Ïë_¾Íû‡?âcH…¾OyìûÅ>?ò^Õ½ÇI)ÁD$Âà™Ï:6Mž¢…ÿ²ìóøt¡ ‡1Æ…+E<ôD™ïlì±8µÉ;ís<œ¯*‰Ÿ:-Qðüi„2Ùy>11Ç×/ïñèìO(´¯‰ã!3àc×::c ¥|:íÃ@ᕆäòšÇ—òÈ!0îVîß¹XŒ$OÌØ$Ô'B¤M9º0ÁÑÆKD:åñcS¼{ó›$V2]®ñ~¿Ï’òÔä.o¬]æÙÅS˜Ô{Gyk9íS­4² QJ´§)KÄf„ÒÎÙÌã[H|/À:K¹RF!jö:mÙœ¹ pÎaâßÓŒÆù˜T’h³±Öää™»mÎ}1­u¦»~AÓì ¿Ë¿;Çõµ>O.Bo„ß¾Îëk>'&§0Ρ,|doï§V8MÏðöòû”CEàyDÃÄ=ZåãucRK£Vå­å-N,γµ»Â„.& ¼ü}¯8tøk{ÜÙy‹¿½Ô¤æWxëÎ7YßÜc¡1CêRVšïC4¢9h1Ø>ÍV—7–»<¶t ‘÷Xœœ¡Ý»NÞS8­²:IèvÛ´º-`S”¦æñ=8I¥ ‹µŽÔ¦™A‡u:@YGÞÈåò$©a ÇndpéÝ[\¾x›_þõŸ# ýŒ«ÌÝǯ‚8IÈ…!&Nð|-=ÒjEGÑס0XÚƒå2¡‚QÌáJƒ¸ÏÑB•n2`¾T¦œÏ“³ DX IDAT µ0ÀE)i2æÂGäÑûzGÏ ÅšÌis4dh }'ØŒð”Ob W·JÌTz8wÿœ©qRŒgÜ:29wÀr1÷TÐRJ¢(Æ<ŒÔø9A íQLYù ²NÔÍ+\xø™ÍœO:ÅK/½ÄÒÒÒ…Ö‚€\.ǵµŠ 'ñÃÜýÄmN/Í?x挰ÚtTJá¾J°xì ¬ÞÙùÈö’×^ùꙧûü‹?ÿ4Ã("ŽbO1öØÙ^§\žÀ(ÏÏc‘ÔHÍõIÔcgkÈÚÆ&è­œÀ"ÙY¿6¡21M«Ý¦‚R®ÆÚê&Ê3äòŠÁ¤J9tü0_ÓÙnâ’‰ªÀ—Í7˜™¬qãN“[ë]/dh6vû„ÌÌ.2Ü&h6·ºÄƒ€ÝÝm–fñ<Ì•X¾u›µ½M,¡þ|%DFõÐ[£ûQÅÖZÖ:)'ª#’ýjÎsæs9&B%³!ËÊ`ˆr™w'â®2Àș둉JtàƈE2/\©¾„ØÀb}¯Ú`"_æ­vRÞc³çñÔ’È( ÎÜóHÇ(íÓ‰Z”¦ó¨ÀC[A9É•™ C*å*ÎḊEº`âR{x¤ø¾Aé")¾Kˆ‡‚“3#”Ê¡Qèü‹|ãͯrfî!¬üÉxdÿ$C""e²qœ×®,3WÊôš‡qÆç¿T”¦1‡ —ØØhq­°Ü´œ:|ö@ü_dÜ$b€NÖ¤h¡ˆâ˜R˜ÇIIšX…<˜”45øZPñ|¬ËäR­s™ˆˆpÄÆ`ÉÀX÷µ¹¹»1#À !¢"354e³ö´™J¢™äìõfÀ‰™! }06Æ"”@)‰0,^@Ï„¥²Ù²q,¨q¾`¬;¸­‚$ŽÉyyŒs¬îxTB RÒö¨„!Î9Vnoòð¹'?´9ÿ¤â­«·ñ‡~¤cDoû‡ÜœŒEY€pô’€ëkŽ™rfF"†HI’âûøÎ+¯¡µÊÀNaè‘£»›]°–õ•;LÍÎ!„biq7®ÓÜm3u¨ÌÊí¹bÂÉ3 TJô†ÃÌ’ÌYêµ IbôútwרV}|­8þø¬$©¥ÛZÅÇ7oKŽš5rEE¿«Ùvü|©Fc"å—?ñ ¯½y…«ËkùÕ·×hTÚ|úãs\¹:äÐâ)Þxë+|â_¼HswH!KSs¸Bˆ/|<œ«ýH±xîþ™00žÿÂÀøŸ“Úá|ÀÙL·'ÐÆ)rò.BJÊôId'ÀÆ}PE¤W˸4@Ç1F‡,ÖfÊà)})æ¥ó9ò¹<.î dˆ•†æp` (å!t–‘vG˜aŸêCeæu¤ 1—–ÀØO¤s”ý"ïloRK85}Œv¯MÁ÷1±a.éZËƤDêì„ £+ëwX˜]À¤vL±ÿpè£ÚÂQª(©”ç/!]Á™Çœy´‘y^ýÊçŸÌúû`(k HEg'AjËÌé9æNÎsãez»Jõkh[cÙ¼¾M4Œél÷˜?5C}¡v÷úŽ«î­•=:Í>O=9ÏíwÖxïU^üô ¤Öàe€ñ€V{Ž«ÍˆÎZ#sT'Kµ*Qº‡:ÓÈÔ¡v[¤J°÷ú{Ü(N?1ÅĤ‡’ÀZ¹Ç—¾çxñ1ÅâT‹^ÒIÊeËrç47Öÿš7WÀ+ßäSç?ð³þ4à sžO<ñ,Íæ×À†xÂ'͉ÂÚYŠ8.2?±È܉sT‘ô1hïî}—˜”ï._çÜä p{ý…ÚˆA›_{æ3˜œÏ¯?÷ ŒU¡€Ô$ö,Î6#‡“Ð\_ÉÖP­ÕØÚÜ`rf>‘' ÝÛáìÃg)B®¼»B¿Ý¦V-²·Ý'Ž4‚ ÕéÆKE´n°¾¶…oG ã3‹óH_p²1H†}ƒÒ-s¡ Še:­]/áèñÃœ8~˜Å¹ žyô$““h_·†¬ïn°ºy‹R© )OT™?üÄÚƒ!±ÜGüÝ¿(œß96¢ä.m@J¢(¢^SäÄ.ˆÆž¬Oᓲ?˜7¥¹½×eºPd4a\¶9i­³–g.ÇwÖV[JaÐlÜÖYvÍ!¾³]æá#³üÇ÷äÿÏÝ›Yvw~¿sÎï›_ΕYó¦@ R$ÈVKj‰lË …鎶íaá…Ã^(¼¢Z+G‡wŽðÂÉív‡)u·¨Ö@5Ù”H ¦* æÌÊùÍw>çxq³ U@‘¢Ô¢üETD½Ê|ùÞ}yÏ9ß÷ÿÿþÄž¡ÛstÎ'¶%¢ÊXï0NHŠ)Æ:ó m+4õ®ËoyL·¢\‘: ³1͹6U¥Ñ¦VKº®ËRsŽç_¼HwÁcõè :+¾ƒ2’Ò:Ï‚ëtHn͉nm^PX¡ÏÆäYN«ÝäG»Ð?îäì Âc˜Cè¦øÂa&%®ô"ÅÏýåŽÝÛ­íh¢îäæ™àÏÿìŸûG‘N­vï,µ¸òÚuö®Е!j)Èg9»×ä³/òhõ¬ž]&j‡¼úõóø¡K2ΰÆòγÙ»>àä'â9–Ê÷)v§hmxã]Í«¯¬³cŸùù®÷íJø‹ó<¶È¡9úû”ª@ù.ÒU{¤¦ j{¬[âÈ= ¾ñÒ˜¾Ò¤ÓŒ QUýj·÷:¬®XüÊ¥ëø*ƒrÄZ+àýÌå¿{ò‰ÛsËŸÇ4šÿû…gç4¾ë“i½±¥žÉgEʵ™åÑÓáKC%}P5òÖˆÂW‚óWÞÁ™lÓn,°²°@£ØàÒþŒþÂIGáÚú9BÔcíHJQ:š†oxíÂë$ƒtOÒT.Êìí^Ä- :íU– …$ÏK¶'feŽ•à)ßñ%»XiÏêlgƒ¥¬*övç-K'”¥¡7ÈŠ k ¡ x¡Ãk/_DHX>4‡P‚Yiñ<—A‰¥5eJñÎ8à-¸·í3Q†žã" ®rJá(µ&ð]š¾Ö%¾ç€Uu¤çÍt¾Gì(Ò¼¨µ+ºú  t«kxÀÂØ«2ÚŽ‡•O8Lu…Eqc²Ðœ°ÄÌÊck±l†äEÉ°HÐƲ51J0Ë5¹Ð(!i¹.Mé3µ%Æ<%éû1ã,Ãûq—@`´ÆILIn5«&ƒ,¥ßn’LS®_ß䑇žàÅ_äw~çwøâ¿p—]êÍ7ßük[©þöNÎõØtšLêQ_W­ÓÙY•»/ß𸸫Yî*.nƒ¯|P†óß 'Ï|7`oç&íVýÑÒhŠ¬ïÒ¬$Ÿ)“)‰27?O¯·ímŠªb~>æÆÆŒªª6Ö×YY=Æhw‡fì€uØÞÝ¢Ê4¢6žïðþ;Iº÷’NnPá $L&cŒ–xn€OˆZ-._½ŽÑ×(©YYî#%lnísñæ6++¿±F³Ý&ÏRŒ2Îf¶`w¶KÜŠk<Ý°àÖMΕ’ AŽÂÑ×ÕŒuDùÄå­úP<Ôï“U9ˆz÷S¿íPU†Z *Çgà¦4‰´†›û†ÞrÊã …tP¢`oóú;%Q·)#±Ç/¯ î¶xjuBÏPª² mkq…²µèÂ{;ØÜPŽƒ[V¤¶âpØ¡ÿÇÞ[{d:âÔáþ¸×åðÂ2³<ãÚÎO=q–7¯’Mî=rŠK[×hE!7gSd²µ»ÇõáŒ3§2 XO ‘_{@·<Þ†7oЊŒ'cçW°Úâ¹õ¬ä£Ò„°XJ^¼jù¥“‚JU ð¹ç^ŸSg»ìoå|û…÷PŽF³tß2ÿø??Y/ÌwdaŸùÔ Œ6ìo Ù¼´M™WL÷g,X 5ßüЂúàçïåڛ넀îr›¿pö®¯Z Ù>÷ Ý1Çpz2üù7nòÄ3+Ì· WÞsãí<òÙ“H墄¥@cÅ•N  „[¢r‰°õ–NÐâ}:àÒKï3K+Þ|u›sŸ=Éôæ„åðfxá*%AD´¢m,fè(]þR1n+Ô%¼ðÃoó?=óYnî½(zí^m’>;ã &‡Oœü|z&’[Ûܺ/ÚB?èoñþÆ5<ÇåP·É0 ñT€#V\[¥!³G(&~ãs¿ÊöpÀ¿ÿösü³_û<Ͼñ2çz†¥ù%Œ†iVâÈ:%«ÛèG³$¡¤v`8A„+íf€ë¹dYF¿Ó»M³¶¢È*ö†û9rÇ«3Ú |ãxK+}¾ÿì›,Y‚ù—Ϭi´.Xî/0Nh¸>»ãö,ºwAYÔ-f]ÕÖVckpK^i|ßCŠú¤ì:N BÉ4ÊQ¤YF)Á5á*‡Öº­&€ˆ"J]QMà\›Ž9Òh±—$,†-Œ)QÒÅêz PˆŠNàáRàRáC'Œp…Gò±]Ö¤µYÊJà3‡lÌ\,m¥˜f «~ĵr‚/]fyJßhùƒbÆ8¯Ý,ÊULÆS K郪JaXõl^Ñh6pU½ æ3ŸáÅ_¼}íï ·pçï,øø@',Zk&Ó ÈZàUç8Oj[š‘ÝEU'YͽsC´ìqiWr¨•Ñ‹s@!°8i2%ìn“¤%‡¬Ï&\Ó»—túó\¾xÏ÷)Gc—ŽG\|û¹ÖtÛžÓá°~cÌþøk‡ZŒWð”Dxm”„Їþ¡cL'߇v/`¬Š°¢W()¼¬Èq}Í`ÿ&®RæcæZ„±‡çxlm@yœ÷2½6Üÿð'èöºtç– šqÄk¯½ARÍ‘pîîVî]ÝàÈŠ\j’Ì_xtB^ø |\k8ÚíÃÁíõÖsoY¡êöwÎõé¸.ŠÚ•æ9c;Ïr*‘âX…TMš_xH1-ÚqAfªÊCz)¾ ‰ç3›îÊZ ³¾wWyÒvH!ÈmÅÙΗ†7麖¢²Ì?°ÌKÏ_cÔpq¸çÄI|é` ÃÞtÀ}§ïa²7ââëS––#¦Ý1'…4g}_+J'bi5&¶–̺D^ʉn“7·÷n·Èn  F³)®ç±=¸--®þ•§»Ia)•àï Ðs‹1ÿèK÷‘€kP¶¼+¸ü®÷AIæÖz@æüÑùÎR®âع ]²2/ ŒÉgAèà4¿ò+§øÆ×^ç‘G»¼ðò>¿öëg¹çôQŒö0wu\~\ä¤.fH×åÄcÇÈ+…¯JrYáø’Å“sT±EƒQ!ÿþ%ÃSb)øç¿ùë ÒŸCkÕíM.ðä#Ï°W nf9‹ž¡j]…p›]Î6ïÇo˜º-û1×S”ðЩ{ØÞße®ÌØ×!~žãÁ˜òÃÏ»å+—R²µù<q>å¿ùìø§¿ôtRª Ý°/CE=‹5OtZb£€i2c¹?O)a¶7Å8’Q‘ ²½V›ÁpH3Ž B—"¯hv{„ÍI2C†.Ú@â¹'åÿú/ð/÷Ϙ&6syt)ck’±Òh²¾·g]:í6Aàãû!ãÉa’àz ko!45 Ý>—¯^'îÔb´(™kuYßÚDyÖ²,Ó•ìš¡ŽdºÂ: • (s„øŽ‹1¸ÅV2a1Š©·Çu÷¢²% aÈF^RV%ÚsÐÃ&VhD£|B¬<ŽÄ ]qs6åFj鹊×ÁxEQ¢ð¸<9YQ ¥`lKF¥Fd9«.Óº]í¹žWaŒåòÈÅÑczNÀ4Oñl©?ÉçðGÿ~çã|ñâw¾ÅÜúN­ø «)røôCh]±?ÞC)U³Š{ ŠÔ¦BŠz]°ÂÒk÷J°7Ø«ÿ£Ú OØ”œ ƒ] =y;éÏ1–Zæy(›2›ŒÙ¾¾IZVôÝÏsX:|˜ýí=8¼6‡ëFlÞœ±•&9Òdg;ãÞS‡Yìeܸr‘d¸H:¢DÁ+» Oú)®nÜäüÕ íæñ_Ü¥ªÍŠ”Õn‡o¾Pð‰@V–JK”S[ ­q=Ëkóñ] Ƴ”B kˆ¬<V̸4Ž¹w1£ªj¡Ye ¤Ñ(å =I ŠJ`µƒë*le))X_¿ˆ‚©/œ£ý!«µ[T\´{$Xv³‚ŽçR™SBéÒó[Œ¶†5ø^Xæ]ÚaæWÿ³‡ù“÷ Ï|þ£íc]pÿ¡\ܾÆn6â¾Î"×7™_]¡kCª¢à¾¹³Ò0HR:AÈF>£,3€u\ß½BÛïáï.¥zý3× ö2»eþÿð®UI¬¡nojÅÇ/¸wÖ[˜?®ŒÕéP#\4ß»¿ú ¤Îkq\Á3_<ÎÕõœ_þb“ÒuÑ•EKM¨ -,J|@Žû¸ÅY:îí_ÄȳX«QtV{(Oòûßöø'Ÿ1\Nùç¿ù_óü[ÿZŽÐ¶dZªhK?‡¥ˆ¢äkßxžùÃ!s l¨ªbZ{`m§ææ©]¥SÃ}þð¢á8n‰[³¾ûŠ ÂÔsÌ;êÜST ²ÿô‰Gù¯}Ç 9uô~–%aØc6`mEžÄÙlŒ®2ò4 ÅÚ@eYè-ps{å)J+°¥ Ûn’$3¬©/”hj+NžgAD^H!ù½ßûw¬®Îóßþ÷¿Î„ŒÍ¸¸ãq¼¯¨² *ZNDèºà¹€¤×éPšJj¬5iL9Œ'cŽ^ãúÖ&žã{!y–cÕA"•¸¾Ï~2%‘ GJÀ°5Ó‹#©ÈŠ‚V“›£5B)lQ9~}È°5¦³,J×AW%Iâ1®*ÚB±3™±Øˆ0§vÏñ°Ž"¯*””,7ZX)ÚiôÈ)“×ñ8Òé"Œe=KPå@ai4cŒÐ¬>…6lOg¬„M.$3ú‡v6³zD42†Á¨äµ×^ã»ßý.O=õŸúÔ§î²K%Iò×¾xm}ŠsìñŸê3ì¾óÁsAÈ~‘‘•ž¨Q¨R(´Õkn2­0ììî×0j'ŒÒá&KÝ%ª†Åê¦êS?ü•§Ÿþ~2ÚÞEù>£ýyQ±°Ø!n6p”dgs—"Ÿ’½ÞV”EŽÑÐí¶¹qcVÛ¡Ýn“3\§ÁîÞÆHæ™N÷9urž8rH“šBvr­G‘N =EU)†û¬Q”ºàÐÚ¦²DQ“꤬˜˜¸áÐouXh–llï²¼P)ï]¸Æ¡µ;Û ÷'ô-’çÙm!Ä7ЙÙÈrVj¾­g+æ”äh³†¬xEžÂ úmpH’1ð6Æ)MßÃ(…É-©ÌG Œa­ÕbPeÔí8­õíhA­õí:Üj‹p{óp÷Mþî’B`LΉv›£A³'¸µpe66t‚6C1c˜%ÌL†”‚åÅEòI†´š8j3›dɘ‹›WÙÙÙä½õuÖËŒGV8Ô™g˜Œ œZ5ê8¹ÖH óqÌÅ­ë©[ö¥rnð£}ʼ¤Ýjßõnu¥æDÛ= ³ýÝ–PÎ Î_—<}ÚàaŽ[c}í”xHÛëÔt/Y!ÑT4ñTÝr¾`¸ó5ß…ïü˜r<‡?ûÃK|þ¡ß¼ì‚mÐïΡó·øæ«ð©ûBØ!~zXʪ²'dz'Ž¥>Yzf`MF´9шWñƒàÇn`tUÕ E~း¡h{šnû ¸uÖðe4Ù„õñ³TùŒåîIŽ¬­qbe‰È ‡ ´ÁC „e2áú>íNŸ |)îH)I+nB •¬HˌРﶉ:7 ƒÛ]¤ª, ü€?ø·ÿ‘×ÞxŸgž~,+èˈ£mÅÞÄ2t4]ò´" BÆÃ}Ê" ……"Ï@è`,Íf‹ííƒû„e”LˆÃˆñlJì…,ôçiF1ºÌé¸.“²nO§ZžWÏ¿ÌwúyAše¸Já §$¶Î}©­‰²ø 3˱®a1†¦uÉEX·7š2×nÕÏá[%€6 ž„†ëÑð|ÂЩyñEÉÐjV££$iU`´¥+].ÏFh]1Í4[a A;,‡5gcšç()¸vù&ŸzøS9r„/ùˬ­Õóá;íR?KðÅ«ï^EvWªÏ¼“ìrß±zæüÒ‹Ïsüä³|Ìp0¤ÝiQ™Šgÿâ9¤ï»L&3´†æ¢*ð§Áé(â´§8ÇÌEjgk)d]”âƒÅYEQT¥84ºàH3¦* rSðêµ×5<Ò‰¹1œ  KBuB¢mÒ"<‡¶P”ºÂ`o/úÆÔJ ªOÌ‘`RXË}ó ¸ÖRJM6«gýÂQœ¸§Mʘ9§Ï…÷˜óçè7»ŒGSÆiÊd2äÝw®Ói¹”Ò`„¦shŽÃ‡y`~Ž#««Xé‘Ï*P‚ûNœe®5Çrgž¦ã¹§çV)ûN¶Ûœlµé8ª›%ð,W7¯°5ؤ2Uµ:L+ÉÓkêïnaÖU-1•?¸’1I?! d= µÕ~taHTÀv.°ŽÄ‘)øRFRƘ<å_~Æ››åÕàÿ[‚‚­+*“’Ùá@é¸UUï˜]D„±>¿ü_üÞõ]>sÏk%ܬ,ÿóoü3„u&Áý¼”²Ît–Š{ÍqmÜb<þ}d:!juØŽ‰¨>΀ (GโOœ\dW¥!‡Ø²¬ªV Ê?× ƒ xâÖŽÈŒEW–²¨"i¥‘ÒâùŠÉ,Á÷\\i˜Žw0ºÄƒ+ªR#¬À.¡°ÐíÓõZ^€EãH—,rË´²²LYUX e™ƒP ’1Ÿûìc<ýäƒ8,µ{¸¡"W‚N`™N=®&C ›!• Õíãù-ŒR´£˜…^Ÿ•¹Eú­ó½9|åqteåöK¿Ù¥¬ J Ú6Â@–¤ w–C^@–Íp…d?IJ!$lv ü)•Öˆëš©Ìí¹¨”`ÈóŠqGÂË>‹AŒ,KœÐcMðì˜0õÖHU‹Tòv¢•É5¦2X¥X "ÊÒÒ¶;Ò©-f®ô)©-žŽç"<‡ÊT@Œg4G1‹qi͇®ûÏSc¨Êú>|¤Õ£ë:”â`£kg ‚ƒ‘JýZn8+µ3Å:´»]¶¶·I’¤^«Æã)axŠ2™‘g•±(å’÷(ÓZäIHLQ²~ãQRæ%s ‹,9ÌÑ“kÌ-öèö;,,vyäáûX\lÒh„lml²rè(³¤äÒûïÄ-ªÔ2%ÜËtz}’|„À©“«¬­öHS‹ëù vS”#ê6R6"Ϧ©ä‡o\`8ɸ¼S°¾½ÍÎξ¯yöù,.­LöIÆ®Q¨âƒ¹àX4YÔ–cîýW,·žs²°® IDAT‹öe­­“m”Âfõ©´%I^1Êû$»ƒ!‡V–ɳ”*+YX[%™NOžã€HÙ%Xc‰=…p} nÛi­éöÛ´£Ùd—­Í)‚ £¡CZy„®&I*&Ú ×±¹WKÉ7E›“‹T–3§sþ ܸ>!IR¦£ ¿ÙÃõ†¡Û[âϾùžñ‡ÜÜޯߜJS}’g‹>ÜšlrÇhZ +8"çðÊÙ¤¢¤sºäÚÔ%àcIukÁ4Ö€’Œ§c¢fˆ'%¯M,2ñþ^AÜ]as< Š}|=æl¯Ïe“ò‰¨C§¡ØMspºª¸¿Û§ë8‹8•aXWájKª,ž–”¦ÀQ©êP )r¡ñ/$MPƒÉˆÕåeºnÇh–ûót}ŸiZÒ <ÆÃøqŸb2à¯ÝäW~õ6wvèö"N®œ„|Âåk›<ðÀYZ2fckŸ¼˜qli•F#ÆË¡¥C4´Ëþl¹Ógè8vFû8¥e”åÍ™—DCš)Ýer kˆƒˆï¾Sñé³Òj¤­ç/ðñ¾èŸµêõ¿ RòŠTø|ëÕ’{×]Uâ¥Áu 2ʸ86£²•(n{¸]‹¤ÄÈZ§`…E9U^+gµ–œ9 ‰ qeÊÌŸ2u8Õ›qx>B PXz¾ÅÕ–î’Ï ý$Ïž‡ß|ò Q‹s|’¿|w“ÑMþÇ_úçþXó÷hqæ¼aP¼zý g怔è²Äóû¹*_°™LéˆéB‘_%-*Z­€+CÅB«ƒø‘Ù»§-~ã0Ͻv“×· «Ý˜“j›ç.MXë®peT²âO ”Âòµ¹‰ë×jæ¼,AkLU1®+gc¢(FHIšehcˆÂ¼ÈèµûTÖP”YžE>Žë¤õxo8د_£+øÿâ_ñÊßçÉOžâ¹çßä_ÿ«?çú]~é3à:aÔ#•ÁV;"ŽXm|‡ÁÞŒ ò|Ÿ,›eŽ2äYN#j“•µ˜p<ºè·zLÇSW’JÄ‘f2MØ™LQP¤D¹í°‰ÑuûU¡˜”“ƒxER,u}×Å ËÞtH‘çx¾‡DÐj4é·{Ä~H;j2És\!ɪ%j,²µ ¤Äƒã»($x QTh+ÙA¸µNÇ”Çqè;’w·8þ„ÓK‡i¸õ8áê¥ Îž}øCVª¿©TªŸ¹­ýýç8÷ÈÑ4%\¤ïày¹>èis×2sÙ|9ív\¬0h]¡Å«/üõȹû¿òÄãÐŽBn®o0N”t(´F Ëöö£Q†ã)î=sŠýÝ­Ú_Újá9R*<·Ž>[¿vý½Š<ÏqT›ýáEVÇmyÌòÞõ”:#n6ꧣnþ›(Á¬Š9Ãrt¾äÔ¢¥ªr”<˜KP¢ä[oì—^ìà °>J|tçâN€ãÔ³v¡Ø1›IÄsa<‹¹·WPƒ÷#3g#ï\óø'Ÿäé«Ì¨zÁyìè¾ôàãø¡Ñ¿NÌ?ZŽ­8}ødmå‚"ÏñýàǾ&m5m' / ¾'ùú+çYlÕ½ÁhŸ¥µ#(ó×jQ«k$'–qÏJ—¨}’kã+,¹STt’q©ÅæÂÉlJ«ÓÆó\Š¢À¢èöQNÙÌŠŒ(Žëv¢’ø‹£nyî“Y‚”’Fâ8 °5ê3+h6›·# ¥#éõÚ¼þúE¾ýÝ×¹t¹Ž},g3^ߘ²ÒpiõÚžç{ëPV9e‘RV–B—„a€ëºTyVwî*ðƒQÌõæŸÊö’1 'àæîÝF›4OhºC“‘$õ{´Øn³ÐÃSVÀB³ ¶öŸ;®ƒÖ¡ŠÉuʯ+>wOPº•Áçú·?ÇÆXf³ «Š"/˜Î¦XkXj÷˜éœfS”E-àSu+׃•’Á$ÅzÊWÔímS!… Ž²<ÃQš4Ç1e^òæ[ïñÀýŸàÌ™3\¸pá¶ÈëÂ… ŒÇcÎ;dzÏ>ËoýÖoñð<õÔSüÉŸüÉ]û·›W^y…?ú£?âOÿôOyæ™gê~öÅù;ß{–Æ‘eÉ7pÙ/rý€Q–!‘|@=½¼ÂÿV/ÊT6 E^â9>ç_yÇó?Âñ}¢Ž¡é†»û„AHà zxKï^$ $7÷,¯gëæ 0 Ãð€£‰¢(tØݢ¥cš$iE’UxÊ0$,-Ï’$\¦Nq“=FK§ÝÂõ=ÊÒ'ðB6Öo ¬$j6ÐeÁÞ0ašd|æñ“¼ñÃh%hö:dºÀ“Mߟ–”u¸çd—ÿ囂ÿê Œ¦S½6–8ôO°8X,ÂÖ4¬7[xQÄ¿½Öfw,X˜óyàô:+ñ O¤¹¥å»óg‹êµød À³äUã˜ä%R ¤2h#ecÒYF£¥ÐÊåTŽÑdÌ¢šà¹§AkW7yôÜý„¦qÅÕ›¸žG¡+9tš«>z”ÁÞ ËK¼±þœ½Ÿ×οE‡Œ'3J[âfÚwøæ›»<|¼@ú†B¬oÝ pBú½~5XKLêwûg\°ë¹DIÁ¿ãð‹÷ÃCÇ,UeQÂÅQ5+Ï"ÐBr#iò™ûÆ(|„²•äùk3îYnÐôê›F%Àµ†ºƒŸí–°¯†÷”ˆ9êM9ü ,-V)lòþ'òðá1o¼õ»üë7Ûü¯_ú·ôëVr¥QFQþœÏÙþª’Jaµ¸w篼®ª²”ª"$¹ÎùüãÿÁæ×)âÁ‡ÿ!^VÞ‘ttpÓ—Jb•ÀšžÐœ=ñ‹¼ùÎ7¸yõ(ÔI²Pà‡1U™ƒäEN†h#)Ë”Jk¬¸ž‹.-®/‘u,tMÂ98Õ¸¾‹Ñšw®~`ëM~é:Œg3ð" ]²Ƭç)y âà›o%†Y°âƒ¶¶= ˆuÛ=¢0¬­ˆ÷ßwæ+Ÿzâ!Ú9Leð\u0¨6ä%̦3¢nm$KY¤XÑlvð½Ñ8a2MAk&ӣɘÉdÆÒÒ"Öæd¥F CYZ¢– Š›ô­!Í”lgƒéH‘ge™0ÚÏ)Êœª²Ä6Zk¸Ãd–âRòÍï¼@6pÏÙˆÑ`L³â¨%=:+ï]c°¿ÍÉÓ§qº üÂaøß_wYëíÓ2’—³+~Q‡:|ĽûêZ4‚ï_¿Q󺽿´`XÚá˜fZp¸±Üêa­¦á…,vÙÚØ$rj ÛúÞ5©ê–QRà‡!ç÷öÙ™&$Ž‡£À.ªT,\®ŽÇøqH& «9ÜšãÂh“å IàläS:•$+ å°Ü[dgo—ÑlJä„Ò²yã*k‡–y÷ò6[Û Æº\¹±Å`:C» ÷Ÿ¹YYÊtÌîÞ€²p™ ÇN®(7^•<²¸´D© Ž®bÄD—¼óÞ»lííÐZôÚÎ_|k4aèÓp~EŠàß\å™Z@AÝ™ ™ÌÆŒgc’dV‡Œÿˆý¯UN‰,Nàqo\'"Yq)Kí=T©nL-'š–P´1TH+ÉЬ´ ¡£ø?^Q¬,HzÊ’‰uŽ‘ç9¾ïSUu*š6*¥Ö"D-Ò¥þZ[جÄp¸S±)ß‹[ÊmÃx4AÛ’×^:úÜçžúÊãݶ`š%yq0Ä,¯.… :6Èg6›RiÉâò2ÍfD…´Ûmúósh\Ï'#B_1 QJÒéöð|Ã`o@;8ŽËs;§£1YR!¤é°½½G»ÕÆ ˆã9¦³ŒÁxD6Ò%Óοõ'ŽÌsß=Kìlä?qãڀݽM*›sùÒ6B9ÄA-ÞȧŽðè²¥HÕ )wHó+w `ðqU•%£YÁÉ#óôd›W¶`u^âEZ  vj|^UT™_egwÀ~1åž#§y÷½ËÈ~‡L ®Ì2ßc»Ìñâ€cí ‘G ÄBr¬á¡LIRi†Ž"-R>Ùè²Ôhpu6âDsŽÂTHaQeÉ ¹Îò|‡kï'´: ßg~nka4É =._ßãíwö(ËÇɘ[YäɧNS¤°§\Öo\à ¬ÌñÃBÁúµ VœD§SÒ|Æ¡¥Uʼ ÊrºÝ6Ž#H«œk»›lïï¡Ë’ÍL³Ÿìf›‰åÝAŸÏßÆhÃ=Ý›izxÛ--M³Ù@Ÿ~–ÅYT­ þõs9gVTÍNÿè…µP9>RAHN&gȆ¶+ÚºaxtÉÒP9~^sºÈ~¾[Ÿ™ÛÑyQ?ÎJ¥Ñ\ÙÈ9wôaÌßãöõOZ·ÚÚ?®öÇ|ÏCKK¶ý76Þ¤‚–çs¨Qå}‚лýù¹Sl¥úYS©nÕËo_ƶV~ªÏ³Ÿï°8ïYÏ£¤Â‘ éPÊ’® Hµ¦°ä‡øÊ=pçÔ¥[!Lw£U¡¬ ¼Àçß{õø|å|á³…¥ÓîâxíN—(Š(Q²³½ƒR /‰”rðü:Áš’áþ€v§C³ÝÀBëõŒÎuCét;ss Ä­.Åþ:ÛÛS‚¨Gš¤,,4)2p½mãÉ>ýX!”CÐ被’÷ß¿Bd‡8² Õ¶œ½ïæ—›4Ú1 Ë]W³rä‡A¸>y–³½uS–ØR²´Ò§ïw(«ƒ¹;ê5 ×ZӊÙ)-|1à\kJi4‹½®p—†stþiYrñæeºÍï^¸ÈüáET–°ÌûÛ³}N6¸B;PLVÃn¡ …䇃ÚkîaYhµ©ÊŠ–ëQ`ý„…Ý+š:L!3ºÍ˜—_ºÆÂbÄÚÒ<ãqÂÂÒØ@` Ç–$ïBB¥‘8HioÏ<ïœAÿh}Ôâ\ŠŠ?ý¡ážyɾ 9³zñä«ÿ¿UU–xÓ6t„¦T‚Ñä{4Âã¸ZòÖæŽÅ.+‡Ÿ!™]CXŸT_¥¬Öp¢;4 ·6K½V‡‹ï_äêdH«½@¸`G—W¹¹u_ZÏ£*k%­ë*tUây5ªÓ÷\ò¢@ä2‡Ñ…MH0õ½ nG*\G°»»‡£\LekÝy°qÚ”õ·[– jGK‡æÑÚòGÿï×¹|yƒsŸûy~àdª4x¾ËËß{õȹû¾òù/<ï{h­‰£ÁÞ»;[t»F{#ûà B:(ÇËÊ:Œ†›ìíŒèÎ/ÍFäÙ £-V›¦+qÃoLz\˜¶˜6V¹<…íj:§× ‰"Á`wh ®±»»A§in“çðo¼ù.ŽM9}t‰@U |ÒTòÞ…ìlOY]q1EÉé³gètÛ´{ H/$ câV¡\¼(Àšë×o2Õ3÷ãOjârË,\…, —³’OÌ…„¾"L¸ ,gŸ ÌK&yÊ'NòÖ[Y>¶Äœßd¶]ZÑt%£N«ƒåhÝ2Ѥ MsœŠƒi›Lˆ ]‹‡Ã·^%Ê3ö·ö¸ôijüÝßýò'‚‚µµµŸøâ§mÎ/¾ô=6ŽÍ‘‚T”š0Mhš&R\ •Q3Lò¢(£+dBã NðÒò¿¼N'ä*ãàÀãæí½ƒRÁ«–™Ò<¤ÙÔq­ “0çÍwPEÌöý›DyBgyFg™ÁxÌÒªC·krçzÎæ}70éﲿ}x:@iÍf‡£KTkŠ¹Å¦ù6J­(Š÷xoK1Cy¦¨”BE)i‘ñù ƒË{‚q†{÷6¹uï.¶5ÃWžsqt½9ÃÑù%t]§áÖ¨™5‚8a½ÝælÕád«Gd~IôREJZÄ€ŽÐ$A1f§·õøš ’z4éÐrÁ¥=Iß÷±f¬‘d}^¼aÉ2[øýJ/ ËsšZÊ$×–î YNq‹ˆøàü_ÍHy£·ÎVü1Ž­Ô)ÛQèzŒ*üüîõHûcK(îoÝ¡wpXØ|üÌq® u2~áâ%.ïh$…Ž«+4Íx¼[~çˆÛÔlDO7·¾A’Áµþ¯íì0ãlù&z{躉B1õC²BaÊ”h:-Ç¿iB®U(¤,w—Z`û} IDATR ’S¥ä‚vEð`ÒÐuÒ´\déK_â·û·¹sçð6øâ•W^y×ç?ú5€¯}íküáþ!¿÷{¿Çïþîï’¦ïÿþð_SBhhF©QyŽ’’XäiŽÒ2ÝÊ¡/¼tà”ÓìŒyÇ.mɈ¢UÛááÞ•—ÓÇOpÿö}ò8G¦Ô9 kIDDÁ¼a“¦§BJɽ‡÷˜›™áùø!ÇW–¸ùú&¶î’Æ)¿ñϦ1“ÁÛ¶9º°Špåú´ŠÁÍ›79uâ4õj¥Î,‘ð—õmž¾¸Ê­;c>ùìIReðòk÷ù¿¸ÄË/ÝäÈ¢‰7.mo1ßm¢‹’Ùœ$·¶w8yò4–Ë\»Í­ûwY__d0x1¶ˆÉU“óOœáÕ+¯ñÆ[»èŽä…íÿþWçPÒ!ŽðÇSŠùŒ§ŽŸAä¯m_­ ®r¼ Ä2 *zN®ÎWªxÄxÓ)ƒ,#,r,Ë"/RîîÞfev©ôÇ>xWÒâù×|þlå1ÅëG+ÓA+ 6VjLTŽQ(Ðþiuô†ð´„L/¹Qe7t‹zî“ õ¾»àQ^ãüÄ2å`ëkhJñß|ÀøÓÿÌÿük¿Ž)ä£ÄПËÊó÷'whIÊ'žxŠ]`1… Zªø¥óŸæ[¯|ƒ/<÷>{æI rÚ]…@{×Hû¥”BÆ‚³G~‘o^yÛ¬T&¼tûŸùÈ'øÁ«‹ÍÂ\›8ð1¬ i"DJøÄIŠa˜(­ôCÙä@”AL†I‘ƒ”&¡2žL¨ÕÛåØ;Ë‘V9)Ñ !îÝ¿ÃÊÒ‘ôÉŠÛ²L=þê?ý#7n>ä+ÿößð½¸ÊâL‡O?÷ò¢¤5éå{£(7†!ÁLÃ)­z“<ql‰JÜZ$IÉó‚4K9²¸JoÔ'Lb‚"]gq~‘ÝÝ=4Óz xHÓ”ñd‚ TW›–.$¡E«3ñ|S1þt‚t*ŽSæ›9J%ˆB§æ¸DqFžø„Ó1šèÒ@šq1žLPZjK‹™zŠ©I’,åØÂoÞ½A»Û Y•Ø9ÄVŽ“VVú8O=MSþèþˆ¯|å+ïºæ?-øâ¥xgá.ºñá#rç\Ÿ{úñ=§IIMLEÆJ½AŽb;˜s]ôŠ]åÆ+ÔZkLüˆÓKLýC üØG†sçÞ6333ôöÇÌ/¯S×®_ëí‹÷¨Aÿ¸Fý(õÉ4K•cE+0 A”3ߘ£($£pÊbu–í=>÷Ü'ùö+/pîä „fÒLÈtEÝBÓ4\Û! bò¢`êùJ°Ò]Æú;gÎ*ÎlžÅö,M£Áƒ‡»œ8º‚f¾ý·j!µºMµ^ňr²8"bv=FÝ¢Õ0¸üÚ Î›cu}žÑ8ä_ýæG‰¦cf[’¿ÿÇ»LÔ'ή㸠Ë=”e³}ÿ!GŽ§?Øgyuƒý•J†¬‘99sÝ·îôIŠ˜û;;„*d”¼îåSK›¤Ê`ëöCj gÖ`bâê»ãÖØ †¤A„iÚÄI©J—›O¢ç¸¹&mꎮ¦$œ¤<ÙìR¯Ô©.¦¦“*u¸{{´ ÐÈB,ÃA—Š÷ Y“h Y,Ș,1²TI~P ¡®££?FWêyΚ/mE<¹a¨99²°Éµ€T%(Už[YXî¶eFZèç<»8ÇÖæC‡„oåøy*a8X¬û¹ä_¼Æ¿|úÓàE>~ªÆË÷îréÈ:ZV …D õö¤äG4#RJ”‹O?ûKô|WTв×ù‡Ëû¯¯’ä)u×Å"¦âTÈòœi0`¶=O… ´Ã8Ö·Óf…PL}¡•9ÜÕJ ·Rü}ÔÝ Iš’QŽÆui°±qŒ©ç1õ#4"„Ñ¡â:œ;”7òû_ûßï?|å-þÍ¿þu$9©€ÁxL½ÖDÒ,ùóŽëà…ST®ˆ¢•ÆSíÖšF\ĤiŒ%-2]°2×à­»÷(TÆrgÓÐI’¤ty˜&íV‹8ŽÉsE’ )¤ÞD¨!vņÔbêM°]…‘;( NbtM/óô*ŽS¥ÈJft­;ƒŠc²dJàÑ ›Š[ÁuKqXo8 ²BfšMC4ÏH²´‚,èQÎDèIÎÞ$aÅÉ)T¹°ûÚ×¾†‚Ë—/óÌ3ÏüÌÀOßÍ]ø‰îÙnp÷ñçª(mo¦a²¬y†Ê2–]—ieŠše”²ôí Y¡ t©“deþ†)¦Uç^>fw4ÄKtÇv’:%tËdoo4Žé´›dq†í:LŸiqåaÊç6LÆþ¥hãO,¯æ1¹¨¢âŠBaU3èHòi›ç€ñ ;µ˜èZËé2Ó´[-L)K!F>a4ô8sf4‰Ù|ÐãÞ?|k“Í=]4Y9uŽÂ}ÀÚÚ33]ºq̵+¯Òš] ^­³Ö<ŠîèL&!»[[dÊ"ÐùL§SÖ®²Ýß&Îß=J|Ô¨£(ÂqœÇ°†wVžjŒ‹”nÅ%Œ<’BQ>‹íÂi„Y±ˆ“ËuˆÁÕk7ÙëpæÒ"ͼl$žçaÛ.º¦qo{“óGN°½¿O˜FèÂ`¹5eš¼výM¬eƒ×¯nst}™é0Ç ¦TBdT›:ë K¼uý:ýqÀÚòÝ™¤Ü¿}][`qu©›èf‚Ô%Íf)r.]˜¥;·È ¿ÏkWîÒ?˜ðìSó,-ÏÑëosæÌ“ û÷ÈÉÂâ:›;tæ;äiBOèί°hk {üÿîK‹YΧ7(rE¯ßG³tî=Ø$̶&|üâEö¸¿ûf³I$œê¶É¢„p:¥Ò¨Ó ÊŸ(PEƼYÃl¸löÙ*NµÍL¥I¡²÷à$cÝàS'kˆbðO¾ÀòBÙ0ß—”ôaê™9?~¹ÆgN¸vB­’RDIú6bÓ1e±;öXjWÙŒR¾uó€«;:ñϹ(ìÃXÃ)X”&_¸t¼ð|áÒGHw¶MG´¬Zéi>ü™~Ðn :Ny¹—°Ü–ÜwXhm³8{ŠÅê_¿úMN¤¬Í-¢Þ]ÓÀ¼(J~ø¡ ðùŠØ¶…ÐdyΛep¸ƒ7(­N¢SË(a˜­v“F£Š?e“ã'Öø­ßú5nÞ|ÀGž9ßÿåwö†dJàåh] £i‚, …n¦‰c– gIœPX“ñ€©?¦Ó]€LáŽéPqªÄÉ”n³C¦¥ôÆ}tM£U­Sã‡>ÇŲl‚0À­ØL¦SžœƒWvu”(°‹!³‹K¤IL'ˆ ÓD&¡ãj!Ù4¢Ð l×! ClÓ ®]Á´l¢$ÆÒMò$õ\*® J‘Ä1™.½á¤–Güø±ªâÕ‡6¿q ,æÓ(±°¿ÿû¿ÿ®ëûÅ/~‘/~ñ‹ïúóû}íw~çwøò—¿üOÞ‡?iiRòlŠ" WÒtIž$Ô5ƒBÏQš„é6fôÇhC“L“/)õ…Ÿùä¥Ó_ýô§?F¥æRq,ӤѨS«wé†DQH¢Á½P'MŸ:^'šN9ØSHA£Þ@·m¢hBo¿@aÙiì“LG ¨uºŒT*5‚hH¿?Bjýá”ÑdL­=G¦dyÈñŒ†:»=™®‹!a¯ç±×ó!µÙ¼~‡SG*ܽ6äêµÐhÕñö±u0­£é‘ïQ¯×Ñ]aëØ5—FÓ¥Ó©‘eív›¡7~ת[Ó4â8.=·ð®ó,EV®¦I¤Ö능öYZÏ[õßøþwøÄGža:ñIužs‡Ê\ÎtRÐߨÏ8ºàæ|/fûÁ„{wûÜ¿Û#‰ Š\ãè±9ª ]I†Sf£J½æðÚ«¸u}ö² ï4j5DR0žŽ9sô8Žc±µµƒ¦kÄQH³9‡ÒnÅ)wš jÛäqÄ­Û÷©6º,,β²²BO0 IµV¡;·‚nZhRãÁƒ]vzŒ&cÜz C3Ùy¸K&]&ƒßÚÜåµ]Á¯ÏiZ«‚.$ýÝ;ŒF£qÄÞpÈöt“Ç×ÊX:MǶÂ"f<š »UÃ$JN® æTBÃ(F v²„é„'k-ö£˜4Nˆ‚/öh4Ú(¡Ê<ß2a026“-)_0?’Íû(KX’’ë5„Š]¹ÿ•%àL7Á5 lÃÀ›jlŽM^ºqe×ä¢$M3^Ù~“߈øô©eþÝÿõùôÚ>gºÝó ëˆâçWöA‚°G%…"74ôB§V K‰—Nxéîeάm• „xÄSÿ¬‚0OX\:ÊÝÍ[[Ìq+Oó­—!»Í¹3¿ÄŸ½¾KGìaš6UÇÁ°l¤ŒN”†,íL¢„pø&úè_ÑD©ÌÎU~Hu*ýÑR—è¦A§XºIèõIÓ˜0JgBQ`é“áëë+l]¤ÓtI2ÁÕ+×ùøs—0mDAžä˜ºVûåªH‰|Ÿ4 È’4˨Të8¶‹7õwo6Bj¤iÉdö&cH3†“)º£3Ûîbê:J(’$C`»qœ €Q0b½åÐlè<Ù4¬Œ8KiTlË`4 R’åY.PEJ½Þ@j¥UÈ´ÌR•- â0$MSªõ6šÐÈ•"/2üÉ%t&Ó€ªarm?äìÚ:|HÝ*8Ú-wñ^põõë<}éãÿÍÔÚ/_»CVÿ‰žã¦#.[*ŸÿÒ ¬¬w趻øQpH0 ¹*Ðt ò¼œ¸¨â]:âPø—¡å9i~È7H3^¿üòÒų_ýôgž+=VI‚!4z½=Ò8Årm„¦ñÑÃ/«ãä>Q3õC:&?Å0R˜–ŒO)Óé!$a0e×#=V×7ØÙÙ§;ÓÅ­L}jE£Ù°ôZR®¥ÁÝ;w)rA)„^ð—Þ@jŸ|n…í){{>ùìE"oLñð®O­R0S¯%Š0 ¨š:3Í6ÚáYaIÑÑèïÊ9}tÎüδu¨ÖŒ¢EÁ‹[užš;`®½Jšeh”oôõj• ©Õkxc7®ÞAeKG[tº¶mâ{1^?g0˜rá#+4[+G;|ú¹‹,Ì6¨UMæfÚˆ¼ æÖšÆp2¢ÝîpåÕûüÚ/ž§;×aÚq#õÐ, çЧ­Ò‚™™’$¡PSßgmm¢Ë2q-Éöæzý¤árìØ*–!ˆÃ€õµUöúH‘3;ßE¡ŒÇ8×­Ðî¶RcìyÄI€7êóÇ·_þä)ž\%÷Üv“`äÑnUH“”ñ4Bš6só]–ççIã‚ÉdÄ|wò‚{R­¹¬ÌÌ3Smqÿ`ùÖ ãј˜œcó+ÜÝ|ÀR«iH©Ó¬Ùìxºc¢ô’ªÄc¼`Œïû8• º–ãê9/¿ql¾”^ühs.TN‘C,¬hB.ä{ó“”*ԡ¶ôÏêZAÃJ9ÚÊxæ¨ÍýI«{ûÛpåÞ >qÚD—½„c @èe"ÕÏiåYöOÂìU‘ò>ÿ·œ^=R ¡tA§Ùd4¡Â-,mž<¦i¼½€†«i å9¢9O-²;Øâ.|Š+7orwç¿ùÌgxåÁ#¸• qá8J%?ûð¯+ñáâí‘ùÐn'5 M“dYeYDqTªùMƒ,Ké÷äYe•~io:¥Rk’Ä!yž¡K išÌ5-¾÷ýk˜ºäìécå¹³i0õü2wBJâ$Åqʼé¼ÈËÒ<%ŠÛFˆŒ"Oqíº¦cè’jµÊt Yh®á‡>yšc9öÛ1¨EA…ª ÈËÆ^«ÔyãÁ„¶­ÑªÕPèÄq@è{hBRk”¤‚‚<‹I¢€¢ئ‹mºÄ‘‡& Ï Â @š¥04Ë3ÚÍþxºFÏßõQ°83¡h,Ý$Š"ÜÛåÒ…gÿÛœ¿ÿò‹|â¹K¨$§P Ë´£èñcË#˜Ã~Rï’BXÏmÇ1zª,ƒIÒ$åê+o Ÿýè“_ýìç>‰:´³$™À BtËÅt Lˤå80=àÆ{d™`uc`Ú'ðB×Eˆœ"-H“Ó21ÍûýÞYâ2?[g·×ãÄé *§4ð[œjÛ­93 ]––ç©8&ÕšBŠ(Ѹví!Ûû}–;NÇŒ=Åɳ \¿±Çüj•AO’)q‘pëæ=¢8Å­8d"a< I3ˆ¢Ç.ƒâ•tf» ýRÞ®ÔcrÔ;ÏžK †]5Èɺ•óܪ‰FŽ[mà 'Tª’(B ¸~ë+‹+ z k¼ÔC9Ív !axàñù/~‚þ¸Ç©#Çè útk-•®ëíj“½ý>7oÞboØgw‡gž>Å›÷ïÒŸáÕ»7™Z&ŠDĈ f¶Õåàà€ÅÙ9öû=L]ãà OgÔj·o\c®»B.lŽŸ8Êöæ D–Åû{û¼üê—.¬3ö°í ….°+5¤eÑî²4?Ï[·oÒBþý›óü¯¿¹D–ÅdÇÆ–®é2nòæµ»tfæˆÒ”µÕ öú#–—æ©Ú.ÞhB¥Þ Q)»ã[›;œ?ÿ–eÑvjÜßÙ)µDqHË©RÄ1ƒL‘h9G܃(BhF©¢)~àq˜«ÔX]NДþ8\õ(&O”ÈNeò_®&¬.4Být»Öwž*¥°¤ŽHM4+µrN7k¬6ëµJ-Å* ’\có`¹õ'µ~~wÎ&!¬HO8I%hRÃÐ%¹™byn×ßÚeà_fÐsXê6‘‡–£’`¨Þ3:ÿ¿ÿòo9{ê4óâ781kb«‚oßx…ÏœùuÐYw«,t—y­w;HiT*$áäðl0/K,“<ËQ¨Ã`¦wB?¶r•Í-:œ$iZÂò‚Z£‹eìïï%Šz½K¥Zaê)òŒVk?š‚Qåƃ-n_¿Ï“çŽÑ¨×‰ŠŒCoˆ”†i”º‡Äg}ÅE×TÉ\ͼú÷ÃÔ>¯Œ'UDiˆ4l4a©! M¢ I!s •¡;óQEösFòa„„B®Ë’}«Ê‹Ò4Dš³´¼Â~ßåã玂Ї6¼ÓoþÎôù³Çxóá&Ÿ|âIöú¯n=äì¬Áó×nѵ&¼rëÇŽg¡v’«»o’ø=ªN '(r¤×% SlÛ!M2„®#8äöéGþü†¦4‰RI£é’jµŽm[ÔêU ½>Z8I™øB¤Œ ¯^çü¥ãT\ )$º!ˆ“iX˜¦i™y!ñ¼¥–c‘çåέPå¸Z%Àc0¡Õi& qšyi–Òl·š$ôG$aˆRi‘ç ]Hl«œ­Tuî÷è4ëxž‡P ¡ ²4E 4TB•6©!5IV(â´ŒKÍò‚,˱]—4ɆN!t^¼ü àxÓãèR,Q$yF¥Z¡V¯¡ —/_å©KãâÅ‹9r„Ë—/sñâÅŸøâ§mÎßûÞ·9rf$QJ^ä8¶M£RÁ1-4]’Ä)µJ•0 Yìγ;8À´Läá}lm·JÓЩé%Åî‡/_Aw]—F«‰Ô4LÓ|lÒ/ý·&Ï.i–)[…`ï€F£ÅîÞmš­ 3ø“1Q” ë’`2&E£ÑlP‚Åå[›}v·=æç* StËÂ÷&TêS–7V™ö¶È o’“¤’8Nº…©çäEi¨›ØA@»ÑdÄi]&¤I‚"ãÎÍóŽrÿöÊLX^]' ÆÜßߤÑlà6¾ŸP«— Ú$MªàÄú^¿ñV9nørÈ£f]¶mãFp¬µ®äß~ë.ÿË/¯S­:dYF–¤¬Ï-qmç›[cöv=ÚŽ…cÛBcci)%QsöØ zcƒþ.¢³ÆþhLQîon£×jhõÂ÷¸ó`gæa-ÁI4îŒ|ÜVƒ;;·±1sÇÖXµM†£1Aâ´]üéýAˆ×ñÜÓ%Ã%«xìîîRsªÌ..d)™”9y‚'#Å7ƒ¢é=FaÎo=»Ák·nÐ\˜aìûl´,þàWfi˜U¢dÈÿó×·è6 ÜZÎñÎ<ßýþ t‘ráÌ,‹ G8ql™ý½aòæƒ ‘sõÚX•X ?K©¶«E7ô8¹¸B'Os’8ÇK6VV‘–æØê‘u“§k @*Uu &,ÌÖIÇ!kºÉÃÈ'Š"n{6§v˜ ½=”.Ñ Q0`à (ü$ÅÒul]'MÖ“eÙûq?d½³Q§iŠeYï9*'Q5á“¡0¤$û`}Ó?ëúI²ÂܨZ˜:Z¡èÎ4yåú_svãWkCÞùœwŠ8 2ž\YáOð·|þÄgX[ý/ÝxÈ/¸Ëå½yž96àëßùS>õÑ/qêįrïηIú;›YFeîöt4,w™Y@žh±‰éØïR‰+U ¥î •8–Y6R•#…†i›J!u­û÷(òœ4ÍðBV»É«{Ožœá­™qœ¡k&9)yXºAU+8šÐˆâ»^¡“Ä J)šÍ.šnY<%Š|6V—™LÆ*n‘ç)½ƒ®e¤!¦å A€‘Œâ I\ðÒN•ÏU¦Ô« ò0%‰b ™Qh9iƒÊ±m“$I1 i¡I¤éä9Rê8¶N0"Ã8ž¿ÕçSÇêt–%ãXÇÒëd¤8•**ÍËʼn5·¼×Jõ³_\~á›ÔW~"+U$ ŒU(Â8 U©1ð<¢8À6,(ÊÍ­[]ijõw7Ps+t-ö}²"Ç4­’@¦eÏÉ2t¡!Ÿ"z†¾ IDAT~êÌW?þÌy¼±G¦DQH­V+¯UŸ¼•r¼© DqD¥QÅ2­zMD¤QÈ°@…¨4>ÜÖ‡Ô«U†ƒÍn­H™NËûâJƒA/¡Ýu”ƒA/#Ë$BÚ4m¢$À0,ËÆÐ7îlr0ôY7˜N<ÖO,Òïï±µu•#„qÌ™3MîÜ»C·Ý`{{<`~ižþ`H0¤Þì0?7Çpä¡é©‰Òk–æ̶º ¦cÒ¼¼¹Úõ&kKËì÷{h²LZí.ÑìÔ9ØßA ƒ£m“¿z+¢!0kTdŽ‚ÿüWñO}ê,ûã>º&X™YÄ›Ìwç˜!i”±»ßc8ñ¸»ùf£ÍÍôŠ„Óoøi…‹O™m\bcþŽ®<ËøÆ=~áH©™˜Ízomort¦E]wXé.Í(Ð-‡o½ù™ïQwšõ÷ïoÑ2+¼¶y“jËæáuŸsçb¹u^¹|—oôPÞ6ãþ˜“'1 R\Û¡n ¶w6¹rå€,8yv‰ÐÏhÌ4Y\i±¼Ðàï¿þË Mò|Âh2%Î&L¼£Þ¤Ûi“‹ŒÕ…%ò4eyaj¥Zf)ç)a`Ù&­Vƒ<)˜x>uÇ&‰ öÃ!WÑq긮M³^§Y­1 <Ž¯l°»»‹&7{ ¯î|dmB ™Ô ˆTA¥R¡?r¼>Ç\£ Ó ™^îpR©Ÿ’d1­FûF?I QŠ:,»´G½GY¬B(„f²Ò>O—ÓœŸ×ú0‚°w 0ß38TÁ¶LŹÓpøu)Á ÇÈSRQn) )ÐJ#8¾ºÆ7¯üVºë¬ÍÎòúÃ1gz<ÿ–ų'ê¼üz£ Ø•eîy»dñ·& Â8Á±m¤!$–aàM|„&1í•âqcÐÊD0U^ï"HS… Ùa\­ã6PL})-êÕ:­ŠNLjþ꯾Ðaa~†<‘ÒÀ4MtÓÀ÷LÝ$ð} C'cšRjèºN–%Äñ”f£C–ùd™"Ë~’0'̵;( l×µ-¦žnÚXN4õ‰ýˆ$É0‹\eTëWF¿|R`šºèR£Z­ÆI†b×h¶ÛLÆ# DZ ü)Y&²‚¥¥e‚ÐDzl,CàØU:¦Æ(‰XiºÔ+5"?´`HÁhØ'Kl·Ê•×ÞàüÏðð(¥¨×ë,--ýÌÀ÷†rõiìÎò‡þ=_ÕxòD™ñý‹ßåèéz½04¤Ð¨Ú.·‚* ‚  ^/s&þ”öL Ë0™ ÇtÚm¢°Ïvºxž‡4t¢8áÕ¼Ž|ö£Oõ™=‹[q¨6ªˆÃUaš¦ºäÜœƒ£ëôGÔë.µŠK4áMÇ •7¬?gS?BA¥Þd2S«7Ñ4È÷ Âœ<¤IAd©F»UÁ­ê´gtÜŠNØÙ> È¡PŠ8 iÔ%õšËíûû¨Ο[$Š<––çyöãÏríÍ7h¶lT®¨Öl¢L‘£!M?ŒÈ X\^§@²³@…Tk•Ç«ìYN³Þb¦Þ¡[ocK“,ˆéM†œÚ8F§ÑD£Äµ­..úSÖ;MNÏÁ_ßÕùÌq ‰NÆ,.6©Ìtj-&,Ó c|Èpm‡ïýà%&*eßÈ9¶°ÀËû9²ØáfçG©Íÿ2¿ú‰ÏÓ4+˜¦NBJ&2¾tî,ù xá ƒ¡‹^R­6ظƒn茣—n_‡D txîÔ)Þò‡Ü éV*Tj5nìÜå-¯ÏJ½IÐÏøþËבᔧžœãÄŒÉ8(8uâ_ÿÆeÚXF?ê! G>ŸüÔ¶†L³b°¼°€­Kþþù«œ:Þ¤ÖÐüo²º~ŒN]Ò Y˜Ÿg2R­Tp4ƒ<Ðl¶‚¤€ýÞ€íÁ>…žqÐ0Oiwªì÷÷1 ƒªt±u›Ø©¹5D.ØÜÙCO´ê2Ÿ].hd§[»Y‚ih~ÎZ³Î=oÂ\³Š'ä²N,2Ì(Cº.]¡±?¡4E®2Lýï¢ß¯Þßù°ò£ão!/Þ9;¿€úgN¢ú ú lퟤҒ=ñ¶)øú•Ëlz,Î,a™½ÝäÎ@Ñ­7B ‹œåÅãÜÛße¦Þ`­=OÏ¿&š4í£sÿøúUŽ,®±±t”ƒñ…?"JSªn$Kñ¦>–©£iYìcšqcš¹R‡¢±ÃÈM­URgDäZŽÊK´%…BhàO'覅[©&)I“k‚“GWñ¦!žpêÌzyühºN'ضE”¤d9eƒÖ~âºqütiV2âý0FêNÅÁrmli—¤- ’8G7LLË&Œ3 ÓÀqë„qHªrMöÇ9Us‚-MléR³,¢`Lž¥hš ÏÊ1nyåW¦Ó *ËB’£áºU²LSÏ'OSÂ4ã{› óõ#‡(NѤÀ9´ñ:V Ó*Á%×Þ¸ÎÙóÏðùÏžÏ~ö³,-•ãäŸøâ¥×o“8³?Ñ}X-&›óóÏ?Ï™s+˜¶IÅ°p-Û²0 4*ãVuI‘—yäŽn—ôGÛB×d™{‘Ä4ì U·†¡éxÓ)—_¾‚|棿ú¯þ»i˜L†= ¡£i¥ZRß¾§X¬æäyN«Qc:¢{;;YLGh,§JµV¡Q¯—ÆþBX–Íx¸i9ÔšóäYNäd(Ò$' `2 AÖö'T+6¦S#öŠ,59~¼Å /ß!±Ròàî„þ`—ZSÇócÜÎjê£,ƒT*fÜ §6VX]i³²Ü"/ *—~Ø£áTØØXåoÿîœ\o¥ñ×o°¶bz);ã} Wg®1ÇL¥ÁÝ»yýêN¬»´;‹loïpúÌ9|ï€{w¶¨6ºÌtZŒ{{P$˜v•©ç“)Å`8$Šv†»è¦-çÜÉSlïîàÖήgïá6‰)£)ÝV“¢DAÈþ¨V‘ÂaÁ H(xꉳÜÝÙaÁ´QyÁZ·¥i,×*øAÌÉ€°qŠ'ja‚c›ô£ˆ ™«8<ì&1®ë"Ô;ìt?!„£ÌÈ5ß“Áý£'ñ€ù'Ê<åŸÓ2Í2Ì´~º­â5!PºBÐ]Xewÿ%Ö:§Áæþ=ž8zžÉþhJÅt… [kQ䊨¹GXîÎsÿ ı=Úÿïk{<1W§Õ9ÅÃþ}zYLMWXn•ÙV—BÁÎî>Q”1õ©7›d™@š'Y™Š¥•6¦$Îˈ_]/ÉOzy½mËD T‹$Mh´šdiAPLY¨wX?ºÈGŸ<‡aض‹?`ÙªÕJ966 4 n­F’A­Ù"Ms4­(…ähšD…‚z½ …@Ê2+\Û´P(Ò¼ÀÔuÒ,¥‚(Ž©Õ«t ¶¶·˜eÏOY° ¢\±¿w€ç•b3 RàOcÒ$ÅŸz覉¦£á€0HÈ…¤Rk ™RèئE‘¥ÜÁ³k.U£B—ÓÊ0¨V˜¦…ÔjUò<çõ7®sîü3ÿÍÔÚ?msþÞ‹/ šs­:±7b¶ÕDÃt0¤D—:qä!аm Û²Q¸–©éhJ£8\¼¨\ÓæÕ¾‰üس¿úôÅSøþ„Ø÷AšååPàðÖâÌ‚I2 QyL’dì÷Ç´Zm·Âx<ÆóüÃÔªŽe0iuºT›~ozkž,²»»ïù$èЩõ÷1 …iVpª ßöLL»Š” ¶“SkH²L1?ÓæÂ… ˆÜcowB³«qâÔ2­Ö,ëG×X^îR¯Xt» ºÍ*y³¸¶ÆìÜ †.¸þÿq÷f±’åyßçö-Öw_2oî™U™Y•µWW/0À0£Ï€7dÉ–- ›A6š'4Óö‹Ÿmy‘ñhŒe ! ØC7Ó@wuÑÕY•UYÕY[.•Û½y׸±Ÿ}÷ÃÉ*h†BÝ#Cÿ¤xˆ‡ˆ‡ˆsþ¿óûþ¾ËÍ;¤EJ³Ù&Œ|jŠI”$ئ‰òX3™¦EQà¹.‹½y<×ÃÔ ò´"ºµêmÈ«Q–5ò$% l)åþà}>ÿò„’ I‚0‰Yìö8rG~€¦©Ô µQ£l4Ï<6ºk(ŠÁ(½ÌO¾øó¼tâ ãf%^Tç‚()˜z»‡CT§‰¡ªL¼/͆àÔâîlFo~ž*Ièªe‰*WJ˜ÆdIN) &Á„ºmS$9¢ÈQeÁ8Q¹4d£ÛĶm:Ý.ÍV“,K £”F£‹¢éÄ™ ËQR"©–ia7$I¥B’ˆ¢ݨaÚ9÷†>í¦MÝ28ŽhÏõ˜ŽG˜¦F’¦4ëuÃîÝßáü…gyçwøÍßüM8{ö쌭ýý6ç7ßþ6oþñ»|xk›Óç—ÈKÐe“ÉxŒTÿUI½fú.¾ç¡ÈjÅ;ð<Â$ÆÐu,ËDUe$$^ým$Š!J$!“” v›8‰‰Š”<¶B!‘¦å q\²²²ŽiiEÆboŽÞêºa ¾ë1›ÌŸ L “’Л¢X-V–[è†DKË™ï4ÙèÖдˆÝ‡‰É´r¸™¹yj28ŠÑ “¥¥:£þ×oÏÆôÚ&þ¾ùêwˆÆ‡$“ÞüÆûô>âþwnßç¯}…Ý{ñá;´ÚÖÖŽQ3 GcÜ?$ó"Üý]²(£aÕèÖj8¦ lÕ$NrZ M(ôèš "¦Å`2嵇)ã½>ó‹­žÅr·‹&ë¨Båpç€sËÇyjó<–äà–2r˜qãÁ.ÆoìÌóÜ…ÿ„÷G¾È$H8˜„ŒÝÐÍbÆnÂ`ìD ¥QG9‡ý‡ý)ãiÆ4.FnXP(º&hHW·L–—QEû§xõc$*E[:FÖTHì:oß¼Ž¤–Ôl“÷oÞ& †©±¸ÐC–4çeæ»ü£ŸýV·†nèlnžâÒò&R˜±údJ†l œù«›ËJ«ßzÏó©™2öî#ʈƒÝC²Â@­w™[h±±ºŠ£Z’†©™,uæ)Ê’w·éŽ¸³ŸË—ždÍŠ é4rðb¿òP–e:NG±qÔ˜ùù.¶iƒ£ õšÍ™ã'8µxœ'7ÎñуùÍ»ÿ`MÐ’fœ¶,6Ûs<)›œkÕ(Š”óss<¿rœsírœáE»‡»ìöwˆóJ»øÝv¯™7ûŸ¯Odz’$}*Ïû¤QR€H•¿úKþ–×_‡öW•‘Àÿú‡€F†$—ü{?ö£|îì,,}µÎ •3ÞcˆYAFŽœäĤ ”B0ð%ÞÛu)’˜W·ÙžäîÞˆo>ø€Ï_z…µåšÛå^$ø¸¿( ò"'ˆcšEdY¥Hfˆ,# ’*]H’(óÝÒÈÊ´ ÓÈK¦³VÍAÕLÓ¤VwPŒ’ªÓ®éüعy~çÆ 4G;}‚`F‘¥hªFšæèªÄhx„;áû3L]CÎK²4)gq~ ÃÐI³Œ(Œ صÍVí$þ˜2O* !/rTEP³jÄy„eÛ,÷–%FEf‹B—iÌ_'#¬$cÜɘ(Hã„š£cYN§mÑè6pm Ýa†’,£j N½NJ‚ex¹A¸ËÔ÷«T°,B³Mò´²¹ô‚ˆnwÏK€ ’žL&4›M:iš¢(Êÿ¯Áðïüüç™ö'ü«ß¿ÎoýÎ5¶‡}Ð,[GÑE¡ÖhF®‘çYWL½2ýÒe•$Ê0Tf£Aš¤ÈçÎúò•gž&KrLÓ$K3d!cë&e‘"é‚Z™§B˜tzsª`6›0sS|/ ÉÁ4tœZ“Š¿&aYq’ÐjÕH3Á\ËÀŸ™NJ¢¤ÄÌ"¶ò:­FAà*–Æd|D«Õ¨4ƒ†ÂÁþ!›Ç;¸î”Þü ··yï£GŒ™³Ç{ììllα»ÐêZx.mðAðÇßz“Y¦ù.‘7ûL/3ðü'xûíküÝ¿óž9Áø`ÄÇïß…²ä…ç.²·Ó'KcÂ`BžEÄiA£Ý&Š¬z%U‘ÉŠ ?¡(e•Ã~Ÿ×¾õò+ŸþË?þŸGÖed]!G—9P–ŒeŽå¨hªD0›åµzÇ6¢€²Ôêu†£!v½ÅlêÒí¶M}4%ex8Ä0tfnD³~(Èå[øžGYªXv¥‹’˲™ë:øn†©«ää,-Ïck&Ë‹=š®}¸Åõ÷ûŽ#dQÒpÔÛ-fÓˆ¼Œøÿeú{GŒ¢,†(A`Z5T­‚ÜÝ=DFÅn9HRÉíoÓ˜s°4™{·o£ª&ËË‹ì›'è6[LÆœFƒv«…,IDaÄ`8¦Ñn±ÖªqýÖmúå~é‹ÿ/`äÅÌü¡Äy"•èZ=EiNÅÕ£¨ØN,ÏH³ Í°ÉsE†Ÿ¤„aiŠTx¼táǘê§ØìtAʨYÇæŸçëß¹G ô F ¾a…cææ懤e“›gˆ¾?â`rÀ3Ožåµ?¹!ktVºllcÖÑíͱµ·‹Zkr»ôt¥¥5kÇI§Õâ÷÷û Ï]^£LS¦£>²¬Òn7’€?¾K­ÖÆql\7¢Ñ´˜ìqëîºSc¡ÑÄŽ(„Äòâ£ý4]%uGL#RwÀᘶ£2_ï¡ ™¤È±4‹ÁhÂr§Áx2ák‡%?v¶Nêy˜†RfJ‚0¹ÄVU‚™_ ö'Rà /3ʸ˹óOñÕ¯~•ßþíßæÊ•+lnn~ßlí8Žñ}Ÿ?þöu³KVBšçŸée¤S^yº θöÆ·9÷Ä&5ÍäØê"·ïosçæ6ašplsÏ‹AVI3hÔa€¦åäEAÂcn–¬ k Aa:¯¾zùÙ§/|ùK/?ƒnØÄá Ë0àqè¸i˜¸¾Ï»G*õJe(*{ûû´ÚóÔ&çÒhÎc˜QRk4¨ÙsÝ£QŸ……y&ê&“§‚0ÇÑ”’½@a³£Ñ˜«s°H{±‡e”̵ v÷)sÝP™Œ§”EB³Ù Þ0Q” U‡ g×¹÷à/HØÚ Ð‰»wîâÔΟ?*I¼öê-Nž]¥Þh.o¼övÓÆÔ•Çy§eP•îœÃÁ£H#Âq„GxQ‚c)„^†,Kìïî0<òQë=®K^Xm³µÓg}£ƒŒÀŽ9<Ò¬·JÁ£G;dªD¿ßçÁpˆÞªÓ?±1ÿ$Ó?LÑu‹¢¬\Ì ¡“¤%A%1ï¥f½‰iÄa€¤(ØNYQá±ñº$ ‚8c6›áE9Q^°Öë9²¦QUO®ããƒ]º½÷ú[$LöOÆœ=u’‡Û˜.²®Ñškrûæ-žºrš$xí·éueº øýŽc²?#l#MiÈvȲ”ÞüÇЛù)›ÇNðh´…$$Â8D•+¼OößUÏø77ç?«}œ'.+,úE´ø!%†} ÏÏ\åcOI  ‰R…ÿþÿþ*A¾ÅÖø—› $RõÛÿ©?~5E"ó­ ÍRcåñA>æ<‹ê.÷ÙX9 ñ!Ž*³ÒȸôÛ‡{˜2òeΟ~§]0õgÄE†ÈR|ß'M2âÊ"e6›!ËR5Å© †a $P5UQhÖdYBÛÈx{+e½WÝ_šiR&Óñ²”(ðÈ‹‚Ñx†nÛ躎iéBÃÐ ü,"L"Úµ:Y’¢+u#¥kh(j‰çH:Ä^HôزT•î|¼ÅÙ³—¹t鯼ò ›››À÷ÏÖ®×ë´Z-nïÏ(»§0œÆg~-Y%WάðÖµ7xæžnA] IDATé3ÕÀÔ4ØXZäáö>¾w—?yí]Þxã}ö^xöIDY%ŠªðK¿ôÏyâ‰3Ôj6ÿä¿üg==Fí8,2—–Ö° Áýþs½9nÝ»ÃÚÚ ÿø¬ÁöÞvKWXœë2rg,uFaP…Å›&q™S—%eX*Ø›Ìe)óCD Ò¼‚¾ÛÍ&£ÑÛr>íŸerþÄÔ擉N)MòD"Rk˜ví‡vrþ,žŸµ>i¸2”9ZYòüÉc_:Áb{“×î“õöñ*Ôþ/aÛW¬ï’oßp~®Ï{¶èÕ5ZºÁØÛBWAB'ÏKŠ<¦¦¦ÈEFÇ)Pò>¦ª% ©(9 C¦i‚Ÿú”EÎhr–±~l‰ñ¡„ö‘I(“„[ì¶ïïóµo ¸uç[BŒ² ×kù1¶ÙÂwú‰?!OS IeõØ ¢2åš iÎÿóûßáÉ‹kì=z€d††ïº”"å‘RPZ&¾È¸Ü]âï'œ6;G>E È %Šª¡˜:¡ë#IÕîN&8s=jõŽ­3›Œ(³³Ñ# =’$D‘eJJ¢8D  jŠ¦“æ´–••ŽÐ BM#P×M^>÷ߺqÀá4'#Æ» »ÓGDc—L‚Y3SJv݇‡‡4ä’ãÇÖ™Ä}ŠX!·c$Ë¡P Ò,Gd).éÈC‘Tîöwi::¥¤rúøIêv‚c .\XGÓu—{¼þö6Ë™é`ˆá4rAÿ`ÀÉSkLû»NÇx㘲ÉTØ|n]çæ­»œÚèqqAg ˜wLææh†I‘•Œg.£áE.Øß9¢Þ0‘ó„©£k çVŽs°3b®]GS jšÅ$ ¹xì¶í0ó’0&ˆKRÀœ©³Úl0ŽÉu ÍP™o/1IŠ„²(1-›OèÜy^Máß«9·ÁƧS´ÈRÆûû)O.¬UZ˜ÂúAi¿»JDRD‰„(%Š8âÝ»#jÚ-†IƒfÍ@*SJ!!>E,Äã,ÍÞ"on yjYC<¶äÔ$å±jI”…èJÅ>6 ‡Ã K&-cZKLýKñQ•f£’†jÚ`;”¶Aš‡4u›L‘ˆÂ˜P*i•ÄÏó#’4!W2õª¤2ót˦Q3xó÷¸zõ=Î_8‰S3QT…<Íp§.†aâû‚J6U%ià{B”Œ'Žc¢>Öë놉ªŒ¦Ó*•J(Ã8äJChšL–¦„aˆ¦hªŠ$ ¢pVóŒšÕÆTK^{r¼%“¤H‚vsŠŒ<ÏèöºªJ™K¨ŠDYd¨(dYŠ¤H؆””RÁBÓA+r,ÇÆ–%.­Úœ7èéïrälĽ»¸ôäsc›ó›×®rùâIÊ¢ÀÒ,<ß#K2zÏ>{£Á„Á`³/œ#Ë„"ó_ý~ô1õºÃƒ{[|ðámj ›‹OžficUVùú ùÅ®|ù¥.“d)Šª’Õ´Üjͬ¡ë2Q”àùÖ:xSŸ8Éèvš FS Ó$Is ‘c›2Ï2ÚÙÆiµ¸ss,O$Í2\7ˆéô–¨IS²´ÊÂ,Š’ÞÂ\eZ’”hºÍòJ££Ý^ƒƒ#Ò$§ÕDBš„˜õ‘7eq¹M³©Ó°u6××¹¿½ÏÎá˜0“Í|Ž/FܸσG>ÎãþÝøÖ˜[·xøÈýôGOÒ‚å®Å`0Áu+©€ëå †#ìv¤ rVÍíšBÛ1¸Ÿ$Î8sz^w)Ÿ’DðÇLHP$‹áxJ"àþý‡›‹'ðr…,‰Ñ ƒ¦éDž¢@U,9ãÁ„Ö š¢S†Ãqe¥*¼£zKkľK§äqŒ¬Û´ÚsU€I’bX&BÖ˜ºY)H³”²¬’tIæʱ ^8ý_½qŸVsÂü\ƒÏ?q…£IY8V£0@®ÕQ‹‚ýƒ>­…6á,ÂhËCѧ,¯nâz„¢0” BwÆb§ÉùSøàƒ›L¦’8Ibóô9šó= ác×[\o—3§7 ŽX\šÇ44ʢ䣷H‹”ÿãQòJ=ÜâáÎ.Oœ?ÇÎVŸ½½Cp`¡µŒ" ÌJî<¸O. l?äæöge•'º-nnõ± 8½º‰e[øC§îШµxôhMÓ‰ƒŒí‡[˜uØOÈ,•³f­,‰=Ÿ=!s¥erx4Å i–Å9ÝÎ<»{÷i6:•cÔãÆû—Mξò<§,KºFÄBûle2ýCX?HBØ_VeY’•³ÇðÓ6ïÞHžÞ¥ÕÚYFQgŽZò¨Ÿy»2Î|â™]½TYg2c[ž7ôLžÙXcNÙ: ™æMšÚ”(KYLP$‹(2R!1,â2'W1áÌ¥ÈrÂ8dn®ª†(d&ÁŒˆˆgŸ¸„dl=Üæ­·nòüÓ§(…@U4Ç©v”†Áx8A’$dIa:àÏ*­±®é¨ŠJ–DqŠaXU RšPHŠ"“gI–#Ê’ÄŸø–íP$!yžcš6Qè!̦I¢é&]ƒ×ëšÈ’@QdjN¢H(²?¬>š"“§ãÁ]¯vÛ »AÇDqDQe˜†ÊÎÎC,£ªH ‚õÞ*ßyÀ…óOc¿ø‹¿Èüü÷<Šj"©:ªªbZYQ€,Pd…i8æÎ@âD·FQ@”„¤yåv“æ–cbèzeä!KdQÄ,LPTƒ8˜Ð[X - lÛ$Iá@í1ÏŠ Ï‹TæñdN«†¡É4› &YS˜k7i64JòŠ ”Ç´æ:tzóÔm™,M˜Ž« F’JΟZåÜ©3 GxaÆúòYnÜí³ÝO c…µ :s56Ö{\:¿ÎçVøèö.BÀ…“½Å¥® ò’"sìÄqlKe8ÿ®¾Bàîó¯~ç*…HxëúŸZÃ2t¶÷vü‚Yèa7cRšØeŽ¢ î¸ó\:óyùÌÓìöÇAˆfš(ª¬(Lg.¹$Q– i–S"E1V­A‡ŒŽÈŠ*Þ.MbÌZÏ÷‘M7ÈJ¬ÙºJž¥l*dÒ$¡æÔÑM“(ÉIã„8Éó’R²JÁS§ŸÂ¬_â›7^Ê<úIÈ3+§{C Å ˆ#&Q†Ñ[`ÇðÑ»{4L0-˜S2SEd é2r’á* µ8áö½ûµd}uƒš]§Ýí2Nð'‡Õ!àY\Y$ŽCn|äÒ¬Ìušôû#¤,çíp•ÿô¢ Š=’À%Nsn}pÙÒ9uf“8ŠÙ\XÁP îßßæôò î<âê¾Ã•Ó:O..â' ³Év£AË®!R¹c:Í{»#‡·¯n±½uHš r|Ó”N]G*eŠ¸àÐ÷8¿Ða2ö˜ëvhú9£$Å1LÆÓ#ÖWN2ž N†Ô5ò´B-4ý{ïXÿüç9Š _{ûçŽüÔ®ò‡©~ „°ïQŸüžº*Ðr-«œ^_¤¡/óÛo\ckÿ.çW(Ê!Édq„dIp÷Á#Z‰ …ªàp ¨àpYUÈò„医û{¨bÂFG¦­G”YÄ1[CWU,Y¡a8ª‚Š , mÖ)KAIÎœeäuÛÆÔ ŽF#dUBS5¢4QR¤9G©Â“Oõ¸~õ6’$Xšo¢›vÅsxÒãÔêA@INeh–ƒa™PædE‰@ª¢m%E©àjÏsÑ4]Q?Uø®E†Ð*w+!Jd &£1ª¢%Ó™Çââ2º¦‘d)« øð0£Ó0Ф’í‡ªD6]' "tÑ1›ººI§3‡?›à»S²\°ªt¿8¯àóZ­‰ª*¤i†jY8š†T­[÷¹pþi^}õUZ­Ýn—¥¥¥XðÅ÷Ûœ¿ñ¯³¸Òà`8"ô# rŠ¢`2ô¸¾5ægò4¯¼ü¢(HòŒv£‰­j\xâ ífMQhµ[¨¦Z­¹$KÓyí›o¢¤YJ”æ(ªÀ°tþ‹_üUþÙ?ÿeæç;üâþ«üÂös|íÍ]šâˆéæÏ`[6u­AhšFͲQ™ÙpH½9GEŒûφaLwqI–XhôHº££Ž‹*A%É©7Uv‘e¢Åä°Ok~‘~ÀÒò"yf3::$‰Rz½Iä¢M‚8Á÷}&ƒ#v¶b S"ŠBLGau¹I^ÂO›/p4š ;O_yžÃý=N[¡Ûsè-Ôi/õðg­F“¯üá ¢8!ÍáûKó‚ûÃ&^ƒþ O8œNÞOÔ°”‚4|îÊKÜÝ° ßFQÔ?·›UQð¢ˆ,ÏQd•š‘’§3 ²&¬¶¸°6ïúUÒ™’@É2Üp²¢@’T¹ (J’$¥e5 âÊÄ)M3˜ºSÂœŸ¹p†ÛÏìpíú-þÎ/áŽp-„¬ø3‚Ù”îâY–3žÌÍup§#l]g2ƒ¬±¸²Š,$„T êíÎ<‘_¡…Ÿðæº=ûƒ>rw¢,0 Ë2ˆã˜(ŽÙ<¾ŽçÍðüˆv§CZd´,)O˜…) KËì3Mq“8Q‹*;Ë#Æ£>ªGG.íù5“8L±t$Áp:eyy‘",I‹’ö¦tLåS~ä|ÀÇñ<+W®üÀ‚/†[·ÐrÔ¿ÆÊŬýéêi2ñøÿ‡ß¥5WG×d~ò§^ÁóÆüÆ¿ø Ç6—‘.÷Ø=Ø£nÛhŠJ–åDAD]ÕÑ54N1*jtÌXìôH£„,ËQ$Y± dUâ_ƒ‹Ï’§9ÿú«¯²yvŽT~ê…u÷,ZƒÑV½N­V=Å•eAâçønˆ®yDaÈâò1ŠÜÇ B¯bçqÎÑá€'ÖOzŠ3GæOX˜wÈòˆÉØÅ2œFEÑð#`8A–@–J’´@V5 Ã$K+»FÃlÒ]šQf Š¢2·´ÀÁÑ!ÝN‹vO j{GÇWº,´mÂ0À0 ¼ @2¶mPŠ˜ŸÿÙWø?ëU^{'deÝäÝt™ø3+HÓ>»ÛGœ;3Ï7¾qÓ´h¶khFÈÃû(’A&¼{÷–,Qo˜ ‹’Nƒ“Ë¿ÀÄ YZà…P¨w{乄ª™È²B–å€@‘ /«?^Ó JÉ'HrLLÝ È*õZ£zê¢Owœ†¦!„L’ÅÔ«Ê •$ ÅüôBÒ4 Y–IÓ”< ñâ0*PÚ TE£^À¿ÿã_fûãÿ™;—KºÉñc›H;ÜZªÄ$ÏXùÜ*J(¸ûÖC†÷}šëuŽ)º*a¨¬3K&hšÍñ¥%¦ã£é^³É`æ’È%ƒÐeóÌIF“ Ï>w…'G|pã6M;aóäI>¸ù€µõ‚æây«Åtâsîä ß¾Áé3gHâ”ÅÆö©uêäqÆ7·ø¿ø4öðJËT©Û-¦žOY9DGª¤ð•¯¾Íæz gW8hjMÎœ_â_þÆòÌ‹Ç‘z%ÇŸæÎö}–º«d xaÀb»‰•åè†IÂG³ §ç,Þêψ#Ÿ¹Ú2CH­¬üÛ•ò_F¦øÄf þÂ"‹ˆ¢(™ýÁÆ*Š/( %)(•¿ýP÷_ÿø·TE^ 4‰ÿéë¿Ï+ÏSû”’Êëï?äù ?ÁÇÛߤ×~–ww·°-ƒ§V{”Âäl×áõûžX\¤,‹ïJ¨ ™"-Rù˜[PMÙYPH‹FˆZoN\œf“étB)WÈ‚m"aˆ*©<œLY5möÆûئMžg˜M‡¥N—4É؈½ˆ§Ö-¤\æ•—Ÿ¢,R² Jý>s ¨TšÙñð€ÖÜ<Ýù.²&c×[x£Š¦cš&i¢X6™²ÌQ…Ò2É•,Q$$+,,.ç9AQ¯;$iJ‘ç­V“ét„ï…hªB–ä¤eÎ’#ÊÃÒQµõ5&“iR‚±Œ6q#I Gý]Z­6EâãO\¿d}m‘áØE×Æã1Šª ÁzKæž«ãS~åW~…W_}Ç©˜¿÷{¿Ç»ï¾Ë—¾ô%¦Ó)¿ök¿Æ‹/¾ÀÉ“'ÿÌûOî±Oî¹²,9w®’B=ýôÓß×õÖhØÌf3ö¬®-²¼ºÀ[»Ì/¶ùÒ^AE+‰ó”,K©Ë N£FAA’¥¤qJ)JÛb{ì0ßî"Iù™g/~ùÇüóŒÇS~ÿ+_çæ­» —ìírõúmž>^çǾô «KóU¬¤ªU>À’ò<'ŒT]'Kb²ÆËë*¥ú7•ˆÎnž¢? ˜y)þô6'—ÏPSæÛÇ°T…Í…û;×x°ÄZoQÂñùs<8z€¡ÊÈB ÄŸÊØMÓ" üÇËh(Ê„u»N\äxqH–E•‰FÑ©·‰’ÊŸ xü–¬ BQ™“(%5eæ5äFã1†¦WûZUÃR«•G»ÕäÔ©ãlm=âÿèúƒ1Ç׺HŠ‚;>" FSZ­†%tMA7LtMAÓU\wE D’+£]×+vv¢jYž?¾&P¢ª Š"=– ÆGG Ǧ ¬¨š]€Ž*r(KB߯rÙ£¢”¢"¶Vë½€ò1M(ív›À#„FÆ”B$)E^Æ1]Eðê‡|þÙ1 ƒ –––€\ðÅ÷[ï\¿ÆõOÿ#¾øÒ9Ο_¥HBæÛ5^|þ)š­5ÓÆ6m,Ý f:¨²Š¡W<«(I)˜¦Nš¦Ô ›Yâzo_{ù™ç/}ùé+O h*/¿ô “Ù„çŸ}’SçOàå?ý#/‘dŠª„!r YšS–£Ñ„(I±t½r©É¾7!È I†"ω’U–‰â¡58áx¤aŒêØh†‰$ ööûȲ^í’»]Tµ$Cf®ï†hºB!$ÆnÀ\o®‚~£ŒZ«ÉáÞiâF^—Þâ:Š!Îþ?êÞ,V²äÌïûEÄÙsϼy÷[Ë­­»««÷f“CÎœ5Cel¯ÀøÉ‚aØ/ö“ùbÀÖƒ H Ãô$ɲF˜9·^ØdïÝUÕյߺ{î™g?œ¬b“# FÒx– 7oæ¹™¨<çDÄ÷ÿþËccÍÓéW \‘¤%Ri:këD¡"Œ†ã”kWÖÉG×ùâSm>z÷:»W/ÓìõOçLÆS®ì^äh:ãÁè„ÃÁ1'Æó7#™`ûÒÓ85Ú­ ^Ýý ã4f83,â9Ò ÂƒÖ†¢È‘²ºY\/¨XºBV®lRTD®é ßs˜ŒÆøµ®ãà(¹tZ`¥¬ÞC–i¥$*_±?Þ·üübm© ¬tÐÖÄ ŽšŒW.^b·×åÚ¥_àÿøþ-ºå1 d˜Yúõ-šõ:«+«äqB£Þd≯qïݵ.Om_¦®êG3Í nÝ"ò=´ÓâppÄ3—.'†I>ݹÉË—®pwÿ„Õ~“ïþð.§i€;›°Ñœsù¹3lonÓ^­óúë÷ñò}¦£”Á(á /_c¸·GgóœG³·?WpõìYB×g¥Û@YÖ–ñ$æ _ºÌîz›ÑtŠÖµ ¾Ï5“dÄ3Ûçivž¾z–“ÑCŽörž»v†f¯ÍýGäqÉÃCVWœï÷Ùn®3±9ãYmx¼ÒYåýƒLònäÓòê,GÃc‹ÉtŽ_«ãˆŠûù Z’ÍPðŸ½Ëų׈l…DT§í¯î"ýg)¥ú“ÆãEFYÁZ«É™•÷ðhv ëq¬Aë‘[V7.ó£[بßá£G%k=ÎÈsüáí[œíG”Üå†Yµ¨Î"ž#¤@ 8\ÄlGMÚ¾d”æø‘‹,,§ã!žïcŒFJµP–u×#6#aËqèF!…®H„ndXÄ1^àòƽ’݇(Q¸Œ&•üï~ûMíxå¥gÉM(rŒ.ÉÒåEx¡W!D@2› ”ƒD ó)l…†@µh—%Ú”X!P²"ŠVóÒcW1‰µ¡ª9RZp\‰FBÍ‹Xh©hm˜LuZax IDAT¦d¹FÉ,Ìgs2SmZF“E¡™ÏbFã R:LÆ)qs:±±±V飃€(i4k ìóÌ3/ýÿÆÖþw¯¿þ}žÞí‘åš(¨úƺ4äYB=ƒ€"+©ùÑÒ G …D¹Iž!”"S+4Iž#xó‡?Aüí¿ýŸÛÿþø¯ð|ëHOÊããÈ’õN—ããíNkÁU ]hê‡Ç‡t:BÏg:>¢(aT'K§L¦)›=ŽŽNIâ‹%žåÜ‘¾´j8Ü;$hµñ\…’‚ÑdF­ÙÆBVºöÞÅõêøÊPš‚¢7é¯t8<|€°.+g(H°IÊðèß­´q!è­n1Ÿã É2öÆ Ž[MÈÂq¨7(QEþÿÓ?â•kMž¾v‘£·q\C«Ö Ñ]¥×[㤜ñèpB^ÎYé·ST£Éál@jEÅöJ*b“ñòÙßàÞÁ„X+F£1~½M‘e¤E‰r«þ†»ÜÉjSyò>¶ÙK’c,I’Ök$‹˜ VGb ×UÔÀ˜<Åå5Ÿž~·Gè6°‰æÎÝGD2ÇLJÖWjll¬ŸŒ0¾CdKæ³ë›g¸üÌS̆' GšÏ&÷i6jLNǼò܋ܽu(°EÁëoÆó—šLÇSúg·ðPÔúkÜxÿ:ûG12;âÕ¯¼ŠçööN™¥%x´•æKÏïpñÒóù„ÉÌòé­C^ûÂ%¦‹)ßÿÁ-VÛ!gvû¸uŸÃé)ÂÂÙîa#@e–CQÔë·>=äáÞ wîÒ]kqõé~øý›\z¹Åj¯Kœ-(SÉÀÓœkuqw=âR«Ç'Ó!Wv.ñàpÁ:Ϻ¬õV1•RSØ'1ƒŸª´üðPñ›¿ü¢s‹RâÉÄûWq̦ÍÖŸëgZkÁX$–ïÝþ„Ë­1¿w3ã7~ñW(•áþÑ g×V¸qýÛ´"ÍæίWr*Æ'oâ,I® ª¶„€ñdˆ£ eA—¬x5jNu¬¶!i’ œe@‹RËö“B:R¶˜&ÔÑ’x˜ŒŸ514›9ue‰(P(J­éõVYÁt4a8Ï‘j^IäU ó…–lŸ?XVúe–2›Lh4k A ˜Œf¸A@§³Âd<Àw$ÇG‡tûkUâ•ë2_,–Õ®\Ê4«¹"/2ÒE‚’í-,i¥)䂆, |×uXÌR<Ï0ŸL±eFZÎìl2Ï ëmêõ:óùå:XÀõŠ"§ÔšÂh<ÇÅc5ÿüŸý³¹%9„nÕ÷×e…Båy†ëxX«FËþøÿ`­Y"’€5¥~J¸\ÞNÖ<ž3©Î±½4&ÂÖb°,JEͳ• œ1”EÉ·¿ó‡üwÿÍÌóÏ?¦bŠäy (GU²cÏ£( ,P–%A (Ïa:1+b’PyøQÈhtÊßù;ÿ{åy0XL ±8BÂä|û|óªG¿ù•_çAùM~ôúÿJ­8aåâ%Ö¶{ŒcÒüˆÛ^Jێؾtžû‡wXÛØ%8r)³¼ócD´F ^¸r…{q?ž“ýøG¼zõy@âXË‹/*¶ú.|p›<7Ô"£5W_xµÃûxÁ%þÙo¿ÇÅs-¾øåùßþñ;ü§ß¼ÄÁÞ˜w>¼C*þà>`çÌk« ÊBóÆëwè´[\yjÖz ´f«×áàôá <áRRPFi+½ˆƒqÆ/ýúSÕ¦ñÁ ëmž>·K/jR*‡ï¼ûC.®nç ŠÂ¢­Å¢±¥fšÄXG Œå\g•ï= ·¾ÆéÉ:Ól®í ìOƒ4/ÒÆW¼¼Yò~ÿÛü—_ûkX •ÏÕ_ÍúÏ‹öù!„@HMéÀ¯\xŠÓBðõÝos:Ÿ±Õª1½Ã úž»úk|ï½ï ½ðÞÞœïù¯Ò\ÿ"Ç÷~ŸVÔ Nc/ÂJÚ­Ël:FH‡aº€¨F tEú²à¸.Ö–HUÝWŽãcA Å0PkÖq,ÆðîIÀ [Æh£)a«ï¬î×ÏÆ4Ãa£É‡o¾É;?¹Ž‚W_ÜåµÏQX—Ép\ÉaK@`©ÂzʶBÔñ¤Ë7¿ùUjµVæ c‡Á,g·'‘J:•Ÿ96!žÏò¼¨Zi‚5ÐîvÉÓ€4Ëh¶zË¢Bë²Ú8ƒÑKÇ> RH|Ïg8دXîŽC- ™'%ïìíq¾Ó$.(‹˜ßú¾Ï+¯>$`6!–‹ºT¥”¥’4OÉuÝK[Pk7uH–çLÒ)“Ñ”õVÅW¯~áùo½ôÚ³xÊÁZK»Ó&Nrί¸H]Òé´ÈâGIi¾ô/×Ô¢×QžGY䬬ôÐeFY¤$iL§Ýe/ÀæÌfz½k++ăca°”ó”4š‚ À \\Ï#)J4BARdµZ£…NK¢ ¤Ûnðhï€f«ƒT’B@»Yg8±½½‰µN‘&,ç7Ö)˳Éßs(‘dEI½ÑŠ ¸w÷!É|ÅÏ>sÜ:䥦Ù]áî=<žºò4§÷öh‡¾ûæ[\8wž8IÈLɶë±S÷Xq%¿óތ̳üg_úëÂát–-™›.JŠª¿cªPv³Ì[ËÉXkMY–`í“þœ. ?ª&mG!x®£$B˜J—¹Ü äŸ(Áù¼mäOà ‘¯!Å’Õ)ÐÆШû`$Žc®Ëk»O³vöøäþ{<{é)ZnHoóen>ø>M§C\hN?;dëÅs”º ›fîïñ¥¯|‘nè“OæÔ»;„µ; v6¶yÿOx0>`Ѩ³Ö98Ýc{{›ÛwðÂKW8~tŒßi¡K‘ƒ“!~ƒN»Ë£{·yùÙóÌÞÝKù/´¸xá»É…µ-ôè¿ÞÄU‚no8^°Òí0Nèv:8®SEKº k–*ñÓM½ëúËVŒ¢Ýn3šœÒnv˜ÍôCÁ¿ø̲»æarÍþÑ€t:Áu¤äyŽ. â$¦Óm1“-RJ£°ŽK™[¼Ð§ÕÈò «+âç{ÔƒEV¸ŠµPóÙÈ¥áUb:™Vžâµˆ$M)´&ËrVúk˜"¥(òŠ ËÊöPŽSñ °Øe˜Nœ$A@Qæ82¨xSÖäF‡7îÁVO0ÏXéuyîêE®=³M«ÝÀó}¬Íȳ*t$NRvU@ » 3ªÔ‰¼º(Bâ:.¡à{ƒù„7~ðÔs/>ó­/}åe°–0  GxÊÅÊ„FÐ`2›1ZÌXd ¹NQžÄu¾ë¸U^.:g:ã9Ñ*ŽS|?ÂqÜ*t\V¡ã÷NR6»>i3M‰¢ Šýš×ï< Þ8³½A?wù$á89<¤ÞŽÈ§ãñ‚îâF-2|·Éúj‡\¶·Îa]ÁgYÈñK;Ü9Òr6×w S¤4ÌóŒQ¡DHßa––¤yF£Ò ëÏÖ6Ü‘ND  ã” gγ î Çlµ:ÌæSŒ´DaÄ|1#ôÃ'çÓZ BÉ9?¸ug/<‡Îô“ Ý_¥ñçFû× »„+Ï®¬s4½Î‹«_à è6·ø»ô‡<þ,°Skóæ‡ß!—-Lžr®{žáè>q HD“³=ÁZÇÅõB¼0ÀW¢J²r$ d½×Çó=|墱„^€¸¬­ö¹tf¤ä£ïóòóçRàGµªÏ-,BVþíN—ù|N™kæãÒ Hó˜À H‹”2Y§ H…•©ˆµ–,Ë*²©¬Èq‹EŒï¹HQ½ø>i2­¼0&S®m×q…ÇïÜðÚÅMT ![p<3”ÚÒèv‰ü€t:&IKÚk}²ù„ ¬ôÕZRST‹XUq`¬eÇ…E.8\XÎv+­¶¢BF•Ou•Ñpˆ‚ÕµMêEž/£2a±HQŽ¬¸&aÅó‘X¦ÃÂz„.-¹Îɳk-QäS˜oIfͲ1[‚×÷ +Mƒ«ª“^g…ßú'¿Ç÷¾ÿ>g¶WIâ×étû$‹!ežá¸^…@èÊ¿Ô×q#M—FŽ”DAÀÞ|õ‹_ù·~ý×¾NäEŒ§S¤ïóÞ±Ëz 0 MI·Õbu¥G3¬W‡òV ¸®Ëh4"Í2êQÈd:#ªEÌÇê­.yž°X̉ãÊÑ+R)žÒí´ð=eÁb‘`t:]fãN˜Mfdi†.5íf e5k=”’L3â2Ã(Èu†ÑšzPg2ŸÑ_ïVU š8Îq=n»Åéé)µ¨IЉøû÷ÿææ§xþÙUVWWén¬Òê­ÐèÔ™ öÙXÝdÿôÇ­söÌíf“sç6YÄ ïí?älo…ù"åá|ÄÅz‡°³ÂÔ»À¹Õ³d:$Ît%ûªwp‚ Šë 壼?ŠŽƒ†‹ÒjÊ<'ltð‚‹dŽïhct†¶€Î¶ZÐçóŠàVd)eYPd)ÖTºhk i¼¨ñ‚riLoŒ¦ÌÒêõÅŒÐwÉsò,!HójÃ`5ñdŒëI¤¨ 9i(ÉÅÞ:HJ>铯´z”qÁ³O]emå2ÞºI«%¸³÷ÈSì'#:µ&ãEÊp‘±Ò_çµ/¼ˆ(¡ßZ§ÈJl1ãàtÈ@x ÍÑ|ÄÜÎùÕ_þe6êm¤ôúm”ë’Ž 9p6é0ÆpåÜ&ñtÁÁñ[g·ùôÖg,ò˜°"•àÜæ>¹{‹F£ŽT  §£*·ÜZ²¬àèø„nw !]¤Žô k5Ï']äÜøäÀè4kÜxx§z¯Ð#Y$œœÐ_ész4ä³é W·ÏÒ  ç„¬wÚ¼ûð.f‡£Ñ1“ᜧ7ÖiD’“á„ÌqYd Êj¿V! J,Û]k½~ë­Ÿðꥑ’eú/l­û7ÚÊÙ˜J¡‘¥)ÖB¼˜Wm­I–ýÐ4I(òœ<Ï(Šœ,MÑeI’ÄóÓã>ÿÓËbc°¬º-ö¿ƒm¡¬äÕ³Û¤‹'Dí»ç.cÇoqïdÀÅÝKçmzQŽôêa„çyUeå*”«*äÏ÷p=ÏwQŽK)¹1ì4š,|…ÜzP±À[’çÏ;:Ç ­QR’%Êu•U·áE謤ÖH¦éß\áÕéÔ<Þxû]ÀöZZTaRVšoc–ìO¡ŠB¥…Z­M’¦¬¬¬P =æÓ)AXÇ÷NOÔêuti(—…€’ªºî–$2c £ñŒµÍ |Ça>›re³‡„âþá)”Û¼|©C*Šñˆdž’颲_u\¤ðÒ0ŸÏ©Õ"¤Rx®Ãd<%ª…¸nEl6åíCřքVXc§hmp}ÇE Ò¡Ûë’e¾&c&“ãñ„|‚HÖê °–Rü°öØ}—,ÏQžS«A@žÄSõœ­Ph«9Û È $Òm5¡¬,’øÆû¼÷Ám¾þõ/W½ôÐCÉ B"°XQ%>jk°TlwG9Ký¼B Tçí»ß{«‚µ_ýâ ì⸒ÅÙ–e«×'p}j~Hgø®ËF¸14ê8E‘Qä®ëáˆÊUFù5æIJ§Õš‚¢0äÚ"kmD:£Ô%eºàøðˆZ«…몊ܔ¦Ôê‹…&¨7huÛøa€ò*ÒXàE ˆç šQ@Ã÷Ù\és2ÑiÖ) CV¬4j$óžë‘ç%¾2ŸN~D¯ÛeÇ|ç_¾Å+/l°{¡Ëþd@î$\:wŽNq÷öm>8 »²Î½ãû\»ò4~z“z“Kgΰw: 61·O„a›Óî×Øì<ÃÅ̓EPó8[J¦”R(åáû.ISæ9Ä0:Þg:™Rk4жúŽ³xŽ• ¨7:8~åÞE!AÒh5ð<×óQŽ‹F8®‡„?óS¹R9Q ×óŸ<ßmFx®‡DøAˆr¼ Äõ|×7Ä—ÏcDYM”‹ùŒ<¤Hs¶Ö6˜äïdÔóî²±¹ÁƒG F3×çpÿE«[+ HŠœVTçt:¦ÈKfÓE%óÐ!,ƒù„ÓcÂz“ƒjʺžÓïwØûì¿ý/¯Ój…œ9ÓåãÛŸòÒsW ð8:9¢Ukàúãé?pÙîtq¬&)JêB!Ë’©’g)¡tpëÃù„t x®Ý£ÌrfÆЪµM=|D—]AnY’±UÓüáûoqfãyœ%)ƘÊŸŠt•% Yš’¥)Žë1ŸNžü¢B¨âEõ\–¡”b>›>9FI’ĤIL–¦ËØCÁâsÇ(å°XÌŸ|ÖãEôó˲¤ÈsÒ8ÆZO—°ðòØ,ÃZC¼˜£µ&ËRÒ¤’µEõ:~â¸n% ò\׫<¢]ßð|¿úçùÕ랇üÜqÿšŸ²áñúÍë¼u눮¹Ë»<à¹U¤×÷+"›Ëö™Cž&•Ýr^à{.ÖjÚíÚÝY2çhK…ª­ÅX*ò’¬<Ì-¶"9)¹”Ót–U•©±äEFYäø¢äîÉ”»ó€gvj<ÕUxº@J£ãc 7lR«×H³”~¯‹)æL¦)ý~‰ -r´µ4ê5Š¼$Ïs"σÀ%Ð3´6´êÍjn•“ÇdiA¿Ûg0xDµR±˜Ï(Ë’V§G»Ó­`fÇAˆª°(Šk«ük?ˆã~âHEž%•:fI˜+Še ÉgL´"'ŒSÖ·úycmÅø-ŠœõUòc2?¦ß]¡æ‡Ïcgg‹áé›ìît™ÏÔ<Ïů59ÈDµˆz³FÃu˜ë„´, c ;›kxÊ%-4½^ ©2šík·>½_ó9¬õÖ¸ÿ!A³ŽÐ†íÕu²¤¤¯Æƒƒ=Öê5úÊa¾ˆ¢ÓŘ86ܘL™¤)MÇa’ÌøìyôÎ)‡7Nع²[wÃ^à±µZç{×opåòè…(+³j§ï¹•–>ñƒ)å“Ç~â8Îr{ü\€TêgŽQŽƒçûO~÷|õsÇH¥ðýà§ïûxýÜãÇ×ÆãçÇ¡Þl}îØàÉc×óž|¦rœ?}9þo9¤•\½|†ã“»\Ýqøýö¸²±ÉÍã}ÚAš/±aƒ4oÐðÆ”å‚/_ýoÜ=a«QQ{±Ã"†Gœe *»LHiZP‹ÂŠxd+“¡Š1\qNNš^áîV’%%)2<*îU‚õn­ ]E“ZtYY€µHF‡õמÞâƧ{||ý>¯}á³……’%—‘²rÔšþêóé”< |R—¤…¦( ÂZ„ëV~VÊ­ RTbIf­ÎÓðô£-Óùé¸T‹¡:ÔÌ ‰ƒZZZ.⤚?¢A³ÙÆ‘‚ ë•Œ#Ç#M2Ç­,>…"+J”#q=ðãG’«ÛJ£‘Beñl.Sf‹­Ö R)¬Ðø~ÖPäõz“4M È,ÍHæ#E|Bž&¤IAo¥ƒã¨eE ¤ƒTd†"Ž±Êa2ždõfÖÆíS˜’F«C«Ýæã×YÝX¡Ö8ÏÑÂÒlµEm‹!³xÎ?ü{ÿå ^úâk›}Ù‚O“uO‘-bú­{ã1½A½ÆgGéÊܺŠ\å–ýãõZ‹BZ³óü/ÿû¥àxšr:)0FgÙRô/p”ªÈR ‹¢J‘ZÂ|F—ŒFjíŽ!Œa2xAˆRÕ÷Ó¨EEF­VÔ~cž„&<îO>^”­µ(¥ª |Y‰ÇzMµŒÐû\ÿù_Õ«~Ì.Œ!p Š@š'©I?ÿ7S‡”Ë Îclwå ¬…ë·ï1Š>øà:^‰æx2åý[×Y8}¯ÅÝxÌ3½>Ο£í58>2.gìž`CËå]taY¤…Èç #Ç#)K¦ó”öj“VñΣÛŽ LJ+º€ð£p^ IDATRi¤6(©¸OÀ*N¬fœfœLƬ·û„Žà`rÂd2À 8=>ecuOo?"+$/^»ÀþÞ;ç×Yiö"ŸápÀæÎI¶à¹  ]#õ¨Æýý;lmmâ Á$žÒ ´ú ú¾‹)á‘“óòú6õºÇ½ûÜÿÞ1ñiÊÊåñ #ÜñéôšËh¿JºæÂxþoýàwùΧ÷ùþ{×yþÙç‰R0î_Î~ô_!ì_1¬±Ø:­]féCVÃwo³¶vž½ù„õZ“ïݽ…kîNÚ<³’³7¼Å+ç^äÿýñ}Ö;)Íàiž9w»Ã0)UnÖX,)ÅÒù%Ç^P¯ÕÇ„QmyÉV K–W‘ñ|Át<¥ÛëaµÆ:U>n ´5£ÙÙÞ¢Ôš£ÉˆÓÑ g·++ÌÜ0çDµ«-z¡3Í6Õ¼ù£yõ«g›QQòÎñ _ÝYCz>Ïž»ÄþþÝv“îÝãÑà˜‡ÃS.¯m’Qòþñ žã²½¶ÆÝQ3çþ&¿zõE<ÇA—†yVU›Òu)­Äu=TÕ Ä ) Ê,'Mb&Ó)Bù Žq=á„á2œâ*ô«Ýk= ±Úà9>V”¸®ªØÞº M”´HåV.cR`´~bŽoŒ&KæH×Áêå‚n Ô–¢Ôø‹\~ÿð³‰=|mÀwD•2ãóľðóÇÃOS‡ìÖ³6‚€ßywPiÖ[Ħ`ýòî?¼[†œß^ãÞÉ>žërs1§ÌRV›m²EÉp:!³ GÃ!ýNš®ñÃëïsñÂûû{ܚθxî N«Óc4ãí;wpÃL',ʉÒ\XÙªr®‹‚F³Éh<¡åzt[ Çe”ÍqœGEÂI<çB¯Ã³»Os2:Áó}󄧟>Ëßú”~?"lù4üˆxžààb=É­‡wð¢FØ rBxtôˆW¯½Èþþ#¶¶ÎQ¦ 7ŽO¸Øn1Œ§4ÃÍf“|:âúpÂìÓŒùI¯üÚEÖ¯ö¨]éáÕ$e©QB"]Á4žáz.BHoóòK]v· o¼ÿOé^üEš"G/%whIÈcEžãù¶‘‘ÿ¶ãɦÔZFYÈ»·PoI¶Ã ÃYƒõv‹­V‡•Ðçÿzë-¾zõ«Ü9zÀÉpo¼ðUõ³üàî'<yyç*ƒñŽ¬ßk›—ÅrÅÏxr›$T²ÄU.³"£áJŒ©îÙY²X.£x‘ÆÔj5Ê4§ˆçXSRhAa3 -Èó”¼€d>Eaxé•g¹~ã.Ž’œÙî£ó¤"¡â¢\”¢ê•;c Ú f“)¾ë!©$`a½EY–¸^Hž¦!*›Ñ @J‰ç¹k(uµàEM+j‘OT«ãza½†ø8Ž"Mr?±êú8F„¾pp2àt<¥(Јh¯ãû·n♄ûiLYžãµ§ÿ^~ú56šPjÁp^òèdÌ,)Ž‡¤òž$YB‘g¤ñœÙdÌx4&I2Œ.ÉËéUpq‘§”yJ­ÑÆ[Úr>žZƒÀ¥, UbÌàô!Ò ˆ“œ¼(IÓc-Rˆ'!%ž,{|Á÷ªÅÜóÜÊÚïO¨ž+nE©* Þ÷KϪŸù›?ÎÆÏï^àîí?BmžÇ)§=¢¬7é*ËÇ{÷9Ò•ÑÂV#àÁ8#Q–ý#²²@Ë,M¹7³Vopýöm:u—OÌcl-¤6Ÿðêµ:ý~ŸN§ÃAó¨ˆiæšW.^åÑmTq{“é”F»I™'ô[A“®ï1̶š=nŸ£lÎÃÑ1Žçç)eQ0”4MÖz ¬P`ŸÞgQ¤è"ggk›–±Ì çÏœ¥Ôß øðÎu†yÁæNäÔU@Že4]ðÙ"çÕsëŒÍžÄ\zv•[Ÿ±÷þ_{î ùœY‘Æ zÍ~uŸHÉáÝSÚgê„^‹V I'7ùþˆÍ­ç‰”¶‚CÿŒ¢ÈÿÌóœÿ]‡ÀÐ œÙÝåýÛ×ÙÝüývüîwƼ}ûÿõ׿J¦ ÷&[ís„5·ò~ÞÚæÁÁ'8Œ¹¸óEŽÆClYÝÆ|·’1)¡ˆ‹Ê‹»4(ÇòhºÃl˜³ÚÈÐÒÅUŠÉlBàùxBáùÞOÙú@–eÔ£®Pä1—$É^e´±HæBºÔ\¯ýòkœ=³Åd:#\¤Ìg¼°þÙ‚ s”ÄuC„R$YŒçº”e±œ— ŽZ¦¦9•6xòºU%Ñ„Q„ò\J]0[$Œg#Ò"E IFA„£ yQ³§„Ä8A 7ŒHã ¨ÏZ!EÅ5jD!³ÉŒ!_V q<£Elv]b ß'Ëb´.‘X<åpzrB–kâ$¥Ùjãº.“ñ€F=d<Ðj¶)²˜Éä˜<Õ“1›O)Ò’V«Jý³Úí6Ya¸uZðÚŽËl–2›ÌèöºŽK©5žë`ÊSVá&xûÇŸpfg3g¶H’E•üµ´k¶ÖTF' ¥( MYVmÉébÎÞ|õê®~ký¹/±Ìçš!½šà퇆͕ŠÄÒt|<×Ãêœ[èKÃã=>¦Ès’$C‹Ab¥K½Õ}¢y3ZÔëXQ<°‹"«o´&çè¢Ä "” .Meå)ér7FcQ¸ïy8®‹ëºhchÕƒ'æ?›Â󳋴µ–$—Ô\Q k ž´•­ßçŽýyØò±Bg<²‘³Õéñܹ‹tƒ·Vãé§6¹ùñg¸žäðd€*V{k,âOï>ÅétL€+ñeÀápDšg¼÷é'lm®âI›fDAÈå³»ØÒb0\è·Øè®sz:`ïÞ„Û7N™%4£€OosåüñpJ!tÕOB/$Ï ™;m—=š^ÉèGãë6¥1zó<þ<òœÿÇcI¡‘\Z¿ÄÄþÅÛbSÃW_y†µàß»¾Ïs›g9»ÚÄ(‹/þÑïþV—§¶.pª› Ç‘."V›.^èQ%EQùUøI„2«…ÄIAË3‘giÖ4ºH‰ÑlÖ[ÚµŒ¬´¢Ê]¶X´.T«ïFH“ø!®ð)ÊÇw1RSš’yQ™.}vë!ïïÿ¾þÕ)uÖú!ãÿcîÍ~-½Î3¿ß¾yg®áÔÈ*Δ8I–%K¶¤È6ÒÝq£›ôMHþ„\)#h$è¾ dË@ÇSl·Ü–I©YE‰"‹¬b ¬:ãž÷7®o­\¬]G¤e«,kNÕÙ{Ÿ³÷÷­õ>ïóþI„+–¶&Ž3ʲ$ 5ÎZ¢P^¹‰“`·Hë Šª&Š$¦6ôz}êÅœÏwN“˜{G#¶ûë,Ê’PÅ8)麌g%,CºŠÞ`) GG†ëÛôzvU•›rA¹˜±œY.æ„QŒ’ÉxÂÆú:pT)QCU[RÑr|tDYä,—Kzà úÝnF]ø –º*™/ ¬5k˜Ì+Â4£JéåªÐ›M)G3ŸrwÚrõtŸ›‡÷8µ}šºªXLçTmMDTÅ”0ÈÐb{gƒ/ù;ôzçÏmy?VSù÷ÖZÂPS%ÂAU•¸Ö!a¢”àù翃ºðÄÓŸÿÏ>û,c8Õ·tdÈë!/îµ<¶1]ÌéöÜÞ»C;*3i,O_ ‘J#Š Ú¾v£Ä-¦t“Í~€³íÊç˜OGô‡›Ø¶õ§2à,”e‰Özµ 5h­HÒ€$ˆ"MšÅØ:Qèû/i‡ª1˜ÖkGãé”°ßCUã2çÒé]®í3ˆü¡¢—tÙ;:æh9aQT\óéå[k§}u'lw"þßï¾Ê *ýÿégÿ%®¹ÊÕ­ÇxòÜ|øây¢Pr8.xóÆ=öæ Ë¢âνAcQLg ¶Ïì’¤YêAùM]aê–ÑñˆÖ:ËœÚ8T¥]ºýï ;ç%¥ ã˜0¼‹suZM“„0 )Ê‚ºö3ØA”’ub´Ìg3tûKNI/¹Z‡˜Ö…zµy’˜X…mÁ ðÿãMú' b¾RVÂKra¨M ÿ‰¼^ñãKº1×ï}å Qщ†¼þÞÛtµ¦›í°7sþÜEÚ¶%C”ôkkìœ9…’$í…› {Læ÷8¯&Bú°ú¿þÚWÏŸÏ–¼çjzƒ”g6Î#•&íd´aÂåÍÓØEÅÖÖ»ëg¨ëšu£˜jËã»3Ï+òª†ÉMYò¥¯¼ÅCW·ØÜÚ$Ž"n޹ɣ>Ì‹/½ÈÕ‹—‰Ã˜;G‡¼ôöØ>5@hG¯Ûås—Æ1]zi%ï¼{“8 ¹töõÅ×iÛ†ƒý%ŸþÜã,«O<³FÜMxóîˆýÍyêò6ã@PæsŠ©cqº¡—yÉ.ЋBkM)nóµ7Æ<{é®uï×VÿAÖ?ôœóß¼VàÕg¥§ O_:ÍlqwîŒùèƒãµ{GBã4ËöXA #ÞèP5ší‡)Ê#îŽÒõ.e)ÍŒ$†a˜ÞÿØ ©jv7OÑ4 ukjS³1\§5†ÅrV€õ"Ûzc”O¢Óœq¼ôÒ›œ¿p–^/%Ib‹9Q”zs˜s$Aì ¨uƒ\ÍDw»ê2G ÛBY7ôzæs?Š$„`±\P š¦"Š´ ¨«Wç¨0`t4b0쓦 mí˜-$ èÄeÉÍý÷N^s]5ëP®e¶¬¹pñóÉ1E±D☎Éç‹óêr™“$)AÑíõQÒ1ˆ~ûÕœszÌ{û#T˜‚ iªª”ƘÓÔ„aÈ"·t{,Úï]:¦?ìÓƒ5†ÛÇ–·Kõ£%ç6RÖÓ„0 ¹|fȃ)g76(«’i± ÅÑ8ïß©Êš¢,Rríí[¼òÊ[<óä#l®§ÄIŒ’‚"/)W¿oߺp,K¢(Â9Ç|‘ÓÇ·¿ý*ê}üóŸþØc¡C´ íFX.nÆ\—ˆ`åü6E´ÆN¢É¢ˆ¾N#?¦„@'ªÅˆ³ \8ÏZ7¦e)ze¯ªŠåôˆù"'Œ4óyÎl6'I– X»Ÿt•çUÙø&}Y£e„câ8Dyáeíb™s+Ÿb…àL–±|D>[P Á ™Œrþ—ÿù ܾsø³<üà?å•o}™ðܧøÌSÿŒ[f—{Ç·9*Rþñ?úïxìÂ'yt÷aeÉ[É´l9ž7h¡X”Šýã#FÓIgÀb:b¸y–Ú¶«H;=tã„d2ÓÖ‡{{Ôa:"ÈÖAg°A§7D!R‡´uÃt|„ŽÁÚN"­I“¼¨¼ë6 ©ªŠ$I‰Ò ¡4RH¤²,g3Ê¢DëÈÏðZ8"œCë¤"Ž¼»ò~ÖÅþÃaíOöœï¿Âr½P€”ä¥!‹ÔIÊU‘/IÒìo… ”^xç-vÏõ‰%í¯sï½wØÚ:C/K £˜ Nž_àç(oÜ|‡õá‰Öríð˜n¯÷ã¡ÕòYÉ ½þÃñ”À.Ùélò÷ÞÄZ˽ñ17oß&Ž:d>ï¼ó.·ö¡­hÒ„yqL±˜rõüEªJð;߼ÕMË˯íÑë†h©Ñ©du‰f=ʸvóu[su÷,¶v©¦ “jBF‚SŽež³Ñ2=šp4Ÿ±½=äàæ’4 xö#WøЇϑ„µn9»³A: QE¹s÷Úœ_¸ºf³¿Î|é¥f4$:¡iktÐAKE™ç(!èd=t¨il‹5§@IÁ•ËçÙÙÙô2«5¤iLYX¤ömjã!NmK´â?‰BÿµÑñŒõÍm” I’Œ¦.qÖe ådB’ö2¤®k¤„ Í8Þ{(M±MC•W4Rñg7"Îņ^'`´Dn¢,¤mqØe0ì3Ú?¤‘Š4ÑÌÇc:”£ƒ=„m‰E]ÓPW5mízÓÉ”°·N¬ZÎF [Û[„aÌÆÚRZ_ KÅäèˆÁšçºß¹s‡´Óź!Q()MCÓB’GŠHÍyìô—ÖSLÙB6'a¥LGúk]´R ûîÒT5AÑëÅHðGòUF£¿ù_~–ÖjªeEÅà 2ˆØXß ®+„ÛB…>…0LP²åù¾ƒzúÙÇ>ÿÌ'žB9‰'XDz*È¢ŒaÈ\Ë©^FÄ´íÍGn5äž„!qÚ%TjmYŪŠkIšuÑaÂpmÖ4~LCûÃù²¤×ëSV–CxžiišÚÒ"ÙZpëÎ=jcq®eïø§jºÛg¨ª%‘…EÛ2·Ž¬—"üoÿæ÷i[Ëlš<ðÚ=Ç3Ÿú,O^¹Šp™Ã#gž&vI‰X6ÓYÅ{“%ÁÑè˜eU1/ÉóÜ#ùTÄÖÎiêVÁŠ=묣©+³1U¾àx²(˜/—'9ÔBGtûk :ŠPZ£¤XmÌ’îÆ&Öz9;ËbšºF)Eš&'7!f5J!`ŽŽPwZ:Û‚m=›6ŠPA@ 5ê>_µ9G‰ŸÙ»?Rõ·–û/J”´€ZáçÏŒ.‹‚8N~òûî;êÙÞõÏÓ:Úªfsó,i–`l‹ò„xö~CZ7ëù×¼Ê4«R_àØlðâ7xâÜ6ïݺŽyqçä1¤—º×;=n0½»G(nNÇÜæ`4åâ c1ÇX‹B´Tø9,‚ngÀ{‹³Hpqk“üh†JË¥…LT†#r>¹óÞm.œ=G¬Cö÷÷Ø&Œ!K6¶6ØÞØáÚµ÷xíû7¸sû.ƒnˆ)-­$QÈdï²\rz{-ü\¹k,?xýi–0aƹÍ]la™°±9 L=ÈdV̉TÃÌInÏsdÓòN±àÑÇ/²t%—¿ˆ0KîNÉó9ÚæMÉB8Ö¢„ªÎ©š%w÷î0èõÒª}F¦ÇfÒÿ©œem)óÊÖQ¶`„d^Kº²aE¼=š’tv9’넵88áš¿ÿ(ENœ\à _ÿŸzâC¼~óë‰àÞ\Љa-Õ\¿§Hå„$ë’OÇlgÇ©$¡¿ ñá3þ¬³´­a²œÓ” ëÝ>E[SÔƒlà‹Ö‡ë4M‰@òÞáB:´Ò Ñ4%yòCq°7æ«_{…¼¨XO[¦Ç‡4HÂ$¡Å'-•ó%ûûÌ9eÕ’uü—T~Ä«5†b™c¢®‰£ˆ¦nˆâ€ÙhLµ˜£;íûåƒÁ© o ß½ö4\+ָܹGâöØŠ Þ(B]0™ ã€nÔa1ŸFÄTE”š4Õ4­$ëd„Ú[à‹²€6çÖñœïÞt\ÙŠXÎÇà,UÕœ„N´­cm󭱬­o°\.(+ÃÚú:˲ ^~oÉ­¥å¡ kl¤mãA@ª•Ç=on°XLYÎ é Ë÷¾ó:ÿúßüþßbï€ÑñŒwoÝåW>ó,×ßy÷GÏsîâiLÛbMCSæ„Y‡^·GQ”tº}’(æèèç|Ž¶W1þò¯žG=õÌcŸÿØÇŸÂZé•mÞW0iœP Qâœc2Ó»´Æ`%Ï ÂÐÛçÛ¦¡iZtÒZKh‚À ƒ“Þs–%LÆS6·N”Xá8<>b}s©$A¨Ð:`:™Ñí}J›%ghéùµ:À Iõ©ÌœEaiTÊë7¹6xæ꯱yê gÎ^f)ÖÈ‹š²0¶u IDAT†²n™ç>·t4Òˆ€b6e™—h‘W5FU RQW'ýe:›±¶µãç#W-$K¨qš2›M‘R\¸Rz“†iJêº!M3Z> Ÿ-ȺC²ìCáø³ë »5ãÙM~t¯áêöB9œûÙÅ~em+ ²€P ¤gÊ ¨œB(ÅN¯Oháþ[ü£GâøâŸðK—.FŠÆþX°h’g/í’ Îœ'J.òû9׎ NY0ÎLqD§×ao2!¨[Â$Â÷8 Ä+,¦TÞÏÃ*Ý(VšV8拹ÿ]¶ø^/‚ù2'H½‡ÄƒKî+\0ì÷yèÊ9†Ã>_þê‹”Fð¡'®®R™‚ÈsúkÓÒéH²Û[Û$q@h”T^©“ „`6c[þ‘¤óãC”Œ& †Ãuâ4!ÔÛTLŽ÷XÎ+} 6<²íˆCÅ0ϸzn^’ò¥ëðÄ@3-—\¼pž:_â\KÖíqtxŒ•!Ýnï$ÏÞ"±å’ùx†k —7$­ñ!µ1ÓF )´²¶¾AÕ4¤i„u k:Š˜7Šgv;œê…´eƒ’š¦ñ¦-Û ”ôCàØÜ>M†üÉ¿{ŽñxÎg~åI~åW>Êoþ³OÓøþk×XÛèñ{ÿö/™Læ<óìÃtz Q{x WhU\‹1½Þ( ½R¦Áó/|õô³OøÍyWçœ;a¦Ê•Å»³" åeA7í0Χ,Êœ(Žp­·‚ëÐoEQ~àïÍ^juCõ_›ŒFÔ­ n -Ž8‹X FÇdi­%¯jòºáx1§‘-¡–ÄA@i,Áúp‹$òÖ@ ög<Átðàæi«š´·Ãq¡¨EͲ¬©Ãt¾`Y”QL‘/‘AÄxtL$´€©[Ò´KÓøy¸²¨¨›†ª¬ ‚²(¨‹1-UÓRÕfEjÒè8%Œâ´‡ŠSdaäo…ïÙ*¥Y.4²neîûíRJš²ðöþÉ1ËÙ„¢È‰ "áâeâétJYÕh‚ŽV¶XV!xˆµ­w}¯’PÿßßtWÀ’¿ Jrÿ½‹Bq2z…s´HÒ`%Yþ”0t'®¶ìÍÞ ­¼k×KLŠNÖeaáWvw¹:Ø&–(RLòš$ñþýÞ6üx“~­¤àÚÛ„ 2E°Æ7Þ„½YÄÝ‘dw  `¿Q‚­$e}ã4¯ïßæ…;[ü'ç4rKqîb— åhŠ’³›§H‚wo¼M7íQ–Ãý^<ÍöP!„,í3Z¬¯ ºì^Ø湯¼F·Óakkˆ#®½õ.9ÉC—/òî»ûœ¿¼Á|TQæ–GÞäÒ¹K4ÒѺ–^Ö!/+œtº1j^0±9ÓeI/Q¸$¦©Â0ÄK+0’õX¡ò†»Å‚4î³¥¸ âËoHž97GGš¶*Æ3®CÎnlž¨)?‹õóX97mKiäª ÷ÁU0N€üÚ#WhJGw1®[žÿÁë<¼}ÚÖòüëßçâæZ*¦‘ò}éÀð»ß~ßü…gée§¸¾€ˆ~ÈdrL’$LªŠÒ:’Õ8x؇Òo¬î~ì%4­a¹¬8½¶I·ÓñA Zј†K–&¤AŒš²*|!„IFã1m¹t~—µA—¯~í%nÜÜ㋧iŒ!í¦ * Hâ4Š°Î#Uïc+ï‚0¢Óë1±mÉøèÛZyÐkë=Bá8ØßÚgyUrqç_½e8;XµB0Ö±µ¶Îl|Ì•í€ýRáDA´£ÌçÞU¦=.^Ø%-ÇÇG¤Ý³ÙS´Æû_êÖ¨¶u]{À“³L¦3ò¢"ŽB&Ó9›ë,—†ÖóY Ê|A§ÛG(I¯Ûó …V¸¶a6›0MqB'©?buíØ•óÚóq…ôÙ«¦ª(ŠÒf±ÊgÅKÜÖ ã|oZ}°’z?Àµ–(ðøV/·C‹@šœ0ú)=gá@ ~tøY¬±­G B)c²nܹÅÍëwx`w—jžóöõk Îì"ß·ãÛ.Vä¨ ¢(h¦ ØÞ`Â-nÏQ±b«»`3›se;À9‹–z~Ìz2£jClÒÇZËoœ7ØÊë µ[C¥°…¤A‡TYf³ :è0š&w&?╽1›‘¦([’NÈN¿Ã[o¾LbºzS.xñÅ·øÃï󆴕ܹq—,ÊA&ìß›Óë'œ9³Æ÷¾ó&ç/l“×9“bÌlY°XÌ ÌFSP’5s¯Ê¹g¬ á«©ªâ°*ت mðúÁ!·tUƒTŠ¿úAÊ#ç"Lù:UY’—KzÝÆ4t“/¼5âC»ç ”ÁØ¿ÿ úç©rvX”€q±Šsü ™_œx1„”ÔN"Én'e+ÍxwVñÀé ”ki…äÂÖ6B[c¾ôÒs\ݺÌÿõ¥/òßþêgX1ß½ý-ž<÷‹üÅë?âÑÓE«È¢ˆÅbNGÌ«š¹±ŒòœG?N¦¥YµMã×2”Œ'S„ð4+-û£cÖÖ, æË­ò2_Å!úÚ^¾pê¤;[ë\¾´Ë׿ùï\¿Ç“O=LÇ'^ÛÚ•±R†!B(ÚÖ¢µDJE‘/XÌÆžÝ`üXkÕ‚Ò1ë}¥™ïáZEQ,*E6\ãhÿˆ€HÁÖÚ:Ãþ€µ~ÊbvÌøxNÖï³ nL4½BZ¢NŸíí ”tL÷ïç9UYHMe!ÄÏuƒmTmÛ çýÁ:ýáƒ#KR犳€_ØimŽ"bïèˆ~ÿñ·þþòËßã#Ï<Ö`mË¿ú׿ËsÏ¿Ê÷^ºÆ7¾ù*Ö:~ó7>”’ÉxŽÒ!­•|öW?ÊÅÝÓ¬ ûØ*§©+z>BúøKðyÞý^¥$Ž¥$B:”Ô lkyîùo¡ž|æ±ÏD?é’¥)Iꃟ›ºù±óWXŠÕiì~8µ'PùH¯?å~”£±-e]"…"Mb„²LŠ;§¶¸{¸O$aˆ]õpÄB2o&mKH g=[ZHâ4cÖ¸Ö‘&uUs0/èdÏptó›#ÊÚö†¨(¡© e]b, ­(2[.} º h[áíì*¤­«à¼^¥håTUµÂÖ9úë[4g¡–EŽ—ÃT@ÆI‚Ôú¤Â»¿š¦¦i[ä Ð| òkÛöÿ¿u–8N<ÏFG‡4MÃ|6æèÐÿ=#â$û1/[hÏ&—¡ÔÉ{ „éo0Jkʺ&¼ÿW=f‡O˜ªê†4 N^ÏûQ ÷«Õ²®âÇ£9Æ:hkïDüÛÖêÞ÷ʵo1ìD„uƒ‘Ž™ÌÈ$¼=ƒ³Ã-ôZF1;â°¬ ztºÙ‰â×4Í "ˆ )pÄ|åõ¥ëðõ·ÎíœÒ. µ¡­-ý~Âht€EÅ!McY,ǘb†6–Í$$75g‡CnŽ®c£;AÀCçÏs|pÈ|1§Û]§rqš°Û½Ê½¹$K[ªâˆªm 0QÈÙÓۈвÙí’t{l_ðOŸåLWðÐ#gÉ«€—^¹Ég>û8Ï>y•^c‘¼òý[tú .4Ô­!É"”ÔÔuM–uhLÅvÖñ®]!ÿ«ŸûM'Ì‹œß4¤p,«Š8ŽÆ "¢±°¾±FÕÔ84^U–´­ÅÔ>1JHÏ2µ­£.rŒi)Ë’<ÏÉó¤ÆY?Ú ‚ØÇ,–1`[t”uº«D¨)4‰³~¸ß˜–¦ñ©BBúûûeãûéû}^¹Š_DHÿX¡µsRQTÄDIFÒé¬NµJ½/õJ*Ôêqî‡`t;Z>mJûq‰n·{ò|Rz—¾`>!ŪÇäÙàBø*[+M „õŸç8Ac²ø§ÐŸV÷¾›û/³¦Z*z¼pËð`Ïð‡o…\Ùòç·Ù-±£ ûãœõËgPÖ ‰iÊ%"ˆ!ƒWo9’8#´†K; []Ëç,¡hqfD£Ë ÛÀÔ-{“C.g=nLÇôã„y³ômJ]r©?d4:¦¬pë4gS:T£xïÎ=zÂŒsÃZ³´K~ùñmþøµ9wk*íx÷ø€§®\¥—…ŒîÞäàøØs’;œÛôÁišqêÌ;§czÄH†üàÚ ¾÷â >õÙ‡yí×8u~Íí!³bJ''=º¯kÕ5˜|É{‡S¿|™å4g]J&8õi>zaƒÚ¾ƒ©ýû×b˜Ì&ŒŽY_[£6ue"b§{Ì ?x“Î?´z|ü{µúYËÚΡ¬ `å ¥ÓžnÿNkUYÖV‘7ðð¹3+´°'ç}é¥Whäuž<÷8O^zW 6“Ô#1­âÃWB yõp¤-†cFyι^†izhfm˨6똶-K Büf[Õáó€qœÛ:Å¢*èFI1Ÿ/VsÎíûÚ>ë,ƒ(óãŠf‹%ÝnƇ>t•W^~“—_úyúQ’ØËÙR*Ú¶ñ“6ÖÒÖ†ºªQ&ŒîÞÝ£µ­Rzt¥”0gØŠ¢& U1ÃÁ×|æáÕ|ν½LQœŒáÒ:5óEŽP Ÿ ™/-A Yw@ ,e£"ŒSfË‚ ˆ±¶A³é˜eÕ¦)mëSqŽ0Σ®§t†4MBÍ0íðö½#ÿ™Ï|!%£Ù©MUF‘7@Õ†(éuº4eƒPj…òœÖ;‹)ÛA ýÜq]°, )˜. ÒnÂl6õV|bœ`¯*Y G&HS“…!³ºÂ¬œÉg“€a³tLÖéèºò„,)"¢ BJÁ5»kJ Vñ¬hê)CLÛbZCÓxIt±˜£‚cü|ï}ùj>ŸŸÄã%ÝIÖ#ŠSt£tˆ”©|…j#éö‰’Œ0¸/É“ ³ª< Ƭ¢àþ¶Óù‰ëø}Õvk-ÎZâÔ#õtD1i’’uº¾Bv‚@‡Øäò^âߟ`õúî{ âH{Eøt³ê‡ß—DQè /î¾äçolþaˆÂ÷=ŸStÒÿpåüÿ|çeŒÞ†%n”Ø@òH¿"M-,7ŽïÞK韽‚mººÆ eÁ!çikË94"t¨ê¦ó)Æf³QaÚ†íõÓÜXŒÉ€ÚRíSa,v>#” o´5÷& ¶kÎĉ‡>ô×CÅÛïñìS¦49ÒìßÛg–üÅAÆùNÆ #ÙÈL'%;›çiZÉþÑ„ßzÙñxpÌîéÓ+V±Ä˜†4˨—5ßüöuvvúüÁï~‡_ÿ'ÏrþÔ“ÙŒñtB8L©#AU6EÁ¸r|k\óÂí!ûEÀ¢ü!‹ƒ’F%üþ›Üš°¨F4uCºâX;k™Oæü /¿ü/¾ôCžøð”ðq†àUÓ@ÇôzHÓJ ¤t$qDcþùÇŸ~˜Ù|¾ª–Åêt©0Ör{>c=ñ3˜ËeE¨í r¡„Ä1Úy'›“’PI„V„¡f¯Êiòå@‚EÝ0m*6:C¡]‹•š{EŽ° œm鄲6„(æ•!Ò—M…`VÜw˜T“ù‚³Ûg}ô™ñ§¼(NNÒ4%¦qž5­$óù»̭w2ZëûJË匼ÈO*G$„qŠÖ!2:@jåeé @(åYàIwçN\–RJcpÓx Àû6å¿Ùh%>°ÁH%½,cíÉ)Y®äjðTçÄIÈ8Â'ݼÿñ}ákI³ôÌqŸó&!~,Ìáãíä‰ S á eí=UKk—ɬ7r8+ˆy‚ç”+êÍ0 qˆãâƒ?çýblÙ¾ÅÝ9] ‰XТÅ))ØÝŒèE†^Pr¯Hùú;5N¸Ôê†EÞ C°­ÅÔ–ƒñ½Žç¾WmEQäèÕAQjÉh1%hÛØd4_R” R‚‚5%v»ôº)[qÄ÷Çš³ÝœnœbóœN·O„$É"òù„ª‘„i‡Ë•Ó[<±‘ñ‡¯îñkO^¤\Ölô~tí D ‘Úñ Û1çv7˜0a6¾Ë`¸Á{·ïrpoŽŠ,çÏ éõ#Îï yãÖM¬qÜk¾zÓòÈŽàÍQÌFf uHk4÷šuþ‹Ç*>u¾ÏÞØòf§Ë3[)»ý µm9—jš¦¦¨=Ç·..\¸È­£›h0̆(¡ Âjò¦ àèð¼pã˜'/\F˜Ö_ ÎoÖnu8“ÊÁ¤‰ìgos %ihPbœ7,An€Õ÷ïZ4ßߔݪ+„§åiép­¡4‚0T„aÀÙµGùøƒý¯IH„²H¡NÆãNÄ¥ô]’@’/ Ný¸‘+[”Ðl÷Öh´Æ‚ûXU$YŠp-H/Yá͸A P"Œµ/6äjtRùÊÔóùŒñ|F"½ã[ µ¢ÛëðÈc¸òày†k}†ññUUç æ‹˼¢Óé“fóÙ˜¦®±mCÖíÓí®1…šãјÁÆ6“:‡8ÀÆ’VIŠÚ±ÞÓŒ‹9© ©ƒk‡Ç«`Y“Ä!“ãUëxtwÈ8êÂCWTˆ“1Y·C¢@ÅË)„$îoÐ÷)‰)•GKME×r0©ùèƒtcQÄF¯ƒ³–Ç>t•koÞâðhBcì¡•1ú=?‚h-ô{/lÓtø­ÿé·yî¹—xôá]¤tº]Š|AkVÈÔX k ˆ@:â0¤— (ªóEM¯“`Lþm­]¹µŸyüó¿ø‰§N BÂ( 5-A hÁ0í°l-ý~ʬ©94-ŽI•#tH"$SD8´•LšÇ”­¥SS°§\?<ÂIIl-¦¬È’Ó4,›–ª®HBÉnw7ïÞcÚ:æMËpm;³š–«lm>F"Ïqzçg»›\ÜYg<]2ç ƒ5òܧºXgO6c”UIcA…1N(dQV5EU{3œ¤>*Œ`%‹°Ê“¾?o{"E·ÆçŸ\¾âḑµíÉFýþùÜŸ&Ÿýõ‘!Ó¶h-qö¾ÁË»/Áù÷Éá:ШU¥sß0¥•$˲Õ÷ð $«×晽òûû‡ÿ3ú›‰[®­³~`•­]T Y¬Sbš†~æÃþ¦*çÇNþø»¯ñÀ–ÿw‹wãVH´Çý'$°åB?g£ç°R²wï€~¯uŽ( ¹}|H„dYc I“—ðãÍ«Ý3«ˆàì Ç¨\P‡ mØî$÷m>ùàS˜°A:h2’„ÖÿcÖÏÞ&·˜XZñcÍÿ_åþäÕ ”`^â‡'X qÔ@ÞJ– T(B ð$€D+sŒ©kjÛÐJÅ´5Dø çi¾d< ´ÄÕ†¢¬¨Šš[ã£y‰u ‘Ì湿 ŸNÕ‰cv›¦XæœÝØa4™à´DK…Ò  ¤¥³âуX«f ]^xþe~ç ÆîÙÓ¤Y†µ‚ Ž £€(öãVZi‚0!M†,æc¢8¢ßïS–Ý$¦mj²8b­Ûcwç q±}v‹Å¬à•CÉ0(Qf=676™Lç8ëÉyJJg¬­÷QBpj°Æ¿¿Y“d Na,¯Nk}ÍhV“õb´T$qˆRÞ°¦Õª œ£Ès²¬K‘O˜Žð¦ß%¬G>ŸÒëwXN'´U‰©+NŸ?ÃK/¾Á­[{|ý¯òÄ—ISŸinLK·Ûc¸6@þÞøè£çùî÷Þâßú8ÇÙÓà~Œ¯¿' !=¬%ŽiM‹i-‹EŽ”žïQs?y£ôjïP<ÿÂw½!ìã¿ôoó‚“Í@H/}¸Ú$šiÛ0˦¦ ^Ù¥VÓ2k[,Žƒ¢Âа‚²5>êpåh<^”t×6Xï AÆRJnŽ)k@ zâòô™ÿ¸7ý±ôºïü>gyö»×ÖUÝ]ÝÍ^¹‰E‰¤{lÃã $HÞNäÿàËü c`d`'AflÏH–,Q¤ÄE⾓½wíUw{öç9'/έên’’eš Ñ]·oսϭçœßö]*%B±±zŠ¬¶‰ÈÎ IDATˆà[ÌjÉò@“ps;ãóíC¶w¶1~Hè'Ôm½à) #(Ê’n’0ŸÏ)ˤ„(?@y^àF]‚¸Ku0X¼‚‹86S÷3c mS»Yðô¨¥”'`9)%u]5oøXƘ¯ wÜû[‚Àóp{<ŠÂ‡hSÇÏw?× µ&çá{Žs×ÔåbÆüÀa$-R(Œ…0\ ù¥DMì&e‘#µÆóÔñ»üÒ5 !øÛwnqq%C‹û´¨ßªLÔÒu]înÝÙ2Ï&Ìó)³iÊêð ³&C4ÖÑ®4Œ'ãæm–"Ïð"Á¸Ì¨ëŠK˜[YÃsË« GÒY…)¶v·ôàå-¸°Ö°;¯hƇl¬lÐâqúô&û;(¡9³y–£½1§N¯RTå%Œ’ãƒ-Šº¤Ep{o›Í‹—ùÑ{—–k:½.§O¯3·ÏòßþÑEÒ6e<óGW:\îi^8ïsª»F·Óç³­Û<±~™"»Ë•å€X׬vgèR²ŸW¨Q^£9;<Ãöá6äÃ)é“Õ¡¯Ø-ª“϶m[<4ól‚Žp{ë:ƒÞ*ãÉ.¾-PI¬—Ö»ÜÞù9ÿþ½†6Ïò—¿~…7Þ}•Ëçu3¯±þÿ„YëfÌB Šê¾Ý×YB&)Ô@"‘ÖbZKi%­Åi9Â:?`[P6>ÊWŸãyÎ7'Œ¼i6ã‘^ÂÐӥѵó[Ãa,F Æuƒ‰b¼ ÃëG¥a§4ž‡-µ?DZiEì„Êg\ä,÷L¦7Â2†3£U:QLc »{{x~ˆö5Z9€h’„\¿¾Å›oÌsÏ?No µ«Ô˲B …BZòòÈ¥ÑMÅt–â1Ó4Eð”ãçiJäIön]ÇÚo\0) Ï#ÑH×™”¥}”çS4°º2"ôé<ç™Í>«a@=ߢŠ»\îYÈ2ºqÀ_¿—ñäfB6ŸžüNöv¨ë?ŒPR.æðNºn EÝpúÂ&ÿî)OŸR¦GUK–—¾Ïr¿ÇŸý‹ï¢¥äÃo2™Îùö·'|²,Ù8I‚ F«€¥ÑÏ~ó"wîíñ«7?Á÷5kkƒG,:&å-žvŒ–(Ž¾¥i,’Š²,B;¿géÆ‹?ùW¨?øÞw^|þ…oR5•3{æ~´ªjªÊqicÏ#M+D …p-m)@KåS55¾ça¤B!O@cV)lmY-jß¹rH‹¯5ݨK·×ô-YY²ÅؼF[A¨5“|J…¦˜u9šN±VP%··w)jKi|ÉÆ÷áiß;IÙÞçûZé¡=ß%€°®B<…Ø…xykŒkïZ‹]´î1–¶iN: M]ãùî@Ò²€Ò,(RNêR (ë íû'­å/R“Tåzð1Øß+b‘ØûAùdÖ¬Ä   \¥›Dékm‹öa¨‘Ò’¦)Ú÷‰Ã€ìòìÅÊpÄÞ{,×±²åæö]>N5ëzÌ™SëÌç”ÖòùÇwùø“]½˜•å?úïñã½ÏÓOŸã£ÛŸbMËT֤㠛Kì÷kMÔ%Œcü@¡Ê‚ÚTäM…ÀµôŽ²)F„•ì¥s‚8 ,*×1ñ%EV±±vš{Ûw‘r&÷Ö2Ëfô’¾k« PÊR—¦|¾ÿ:}±Íéuø«¿ÿ5ß¹ü4JÙ¥¬ßuý§jkŸ¨ÜYghÝÔ·‡¿FõœˆWíŠ}R"„ÄXçÔj‹–Ž-¤¡AXÊÚP55–tCM+ûù”¸Ï~ÛpPäEÁÍálNY‚Èg|”’V-7&>—Î~—˧.ðÔæU6–ÏóÆ'w8° žŠÊgZ””SlÙ"„B‘7ËËKäE ÆÓR,ìs•a–§ÌæS:‰›åFqÄ7Ÿ¹Ê³Ï>μÎù×ÿû_ó7ÿþ%~ø^åï~ô{{GœÝ\#Ž"Æûc†£%ò"§®[†ý>¦­1ָў”UEQUíQW%k«§XíÄœF¼yc›ªœÛiK+«D¦n[º˜ªnEY”X뤞EQ…Æâ΀‹ë±sÁÂéžÏ§GHk¨«š²È)ª†~/Á´–ÖBžø~@ Af3´W“¥kœÙÒkâ{>gNØÝŸ2>œðô“çÈóœ8îa1”E‰ïyxž¿BŽxê‰Gøø“›üêÍOùù+ïÇ!맆€‹¥emˆ:­miŒÅÚ©÷)Vš4S–%Z{ÔuÃ/_{õìwžzñ{øeåªK)Ži6æ$Hè…¬\Ð VJªºÂk-ç“>Y9§±î`·f1Ÿ1.«ôú~ˆ@œh2ÛÅMãôᳺ`ucÈÚò*¤ÇJýE•ÒTÐí®²wtˆòãü€Ís—!ßcçpŸ èóÖ[ŸóÇø§¼ùæu>ÿü€?üÁ%¦³ŠÍs#ÎnžerxÄ ŽÙKçŒÆ|ëÉo°}°‹ÂÑøZ_ƒ5(4­ cŸ£Ã#L+ ; ©ö1ŠÔÞ Q±yæižRÛ SÛ)×3«gO€ª®hÛ†¸qgë&"ðJIЙ­=COÊEÐûÝ×ê¶vÖ*Œq5BÊÆÐÒ´œlªÄrgõ—÷ì°¡‚º± ½/KáZymˆ¤a©×çâÆöŽ>ÁSA°z<öØŸð£·>áÍ{Šg.}Ÿ_ÿ€gÏø¿õÏ\»†þ‡ÿ÷‡å±3U¼¿“³qþ;øí+ ´mMo8dšfôƒˆº¬ã4ÏPZ1ÏSf©syòXš¶jœæÁb$7MçäEŽÐÖ†k×γvjÄ»ï~Æk¯½Ç·Ÿ+%¶…(îÐëõi»Æñx†°Ž/Ýí÷Ð^„Åc¸´„ik7z3Qæ|Z‚ $IÐë…(cØÞ›0$TU‰1ÂÞ<ÉìpÂþþ6ƒáUU#uåeäóp³÷l6#¯jÚ¦AkÉÊÚ)ö¶îàGÑbJ)Ýç`ZšlʯŽ<]ï¡=hKÜ€µ †=Ž&êÚðêëðÂóãiIU§xžs´ FÓ1—\*ÍSO?Ê3߸Ƚ­=~ñêdYÁ¹s«4uËhi8Ô¤YÅþø€^·³P|dÙœ0ð]a§\¢ýÓŸ½†züÉË/>ûüS¨Ì´E*°’2/)±äÂRÖ Z{¶¥ijZ!Ð<:^À¤-‘R`Z˨¿D²p*RP. ø;G;Äa²h-ÀgšN7¦›tè…}òºâÕ[‡ô³äiôC²y¶p{X+ÉóŠº1Xël±´uÅl:¥¬Jâ(MëڱLjIDó'i±˜“ëvUªAJ'í&”kã:mI‘Î ãÞ-C7×ÖÊ#-sGͪjZëŒÈåbÈÿÅ s¼á7ðñgÄ}ßäBK'PòUsë@»ÅI0µàù PÔUm…ïydY VÇ.¡0’ÖúV{´öþ<î¸=$áýäâ>¯ZPµ–P,NB°›Ä¿10ÿøµ×xdãYaï#Œ¢µ [[ô‡#„yp#MÛP6NßçRf¬!"ê¦ÁÁ#ˆ¯®É• ksÆûcúý>Qs8;¥9,s†Ú# „$Q’<Ï]Õ£§Kt‚˜›wn“!¾Æ³ ¿¸Ñã\oF+¥6Ÿa…eë`‡~¿G/êrptÄ'wïò“Ï%—W}ªº&è…Œ†=¦³9Êämídz.áì.É ¡wI‹” ¬‘¼þÆMž}æ<:R¤“ët„³£%šùcàôêiŽÒ”Y:£ÓíbÒŠª(ˆ;Æã)~Òô1yFmzJ±/ ´î¾öýé|JYW(á‚rÓ¸Cù`r@/éŸüŽg阬L9˜"…FI§Ó§.+îl¿Âëo½Ì£<ïb܉æo[uUá¿…n÷O\'¼|`\§[o ãË=BcÄ?:0ŸÜ—­)¨šÅ>^4³ *‡Ÿð”tÁ/°Ž÷””’´r=‡ûÒOÙ›4l<¦iŽŠ"^Íöö¯Ùnú\|ä*¢y—3½˜VAW§üúó;¼/ç_}ï[<}áß¾x–ož¿@OIt4â­Ï>ât¢©ê†‚†ƒÉx¡–“øó4EjM- ÂBÝ"¬,¯poûI’à{U]!}ÅÚúˆÍ‹k,¯t9þ «+#ÞyçSž|ò"£¥„jœö@šfÔmK'ôC¼  (k–F#´rê§V%Q/f2Ë\—Q·¬÷W¹wï.ÃÁ²ãûší4­¥×à{‚|6#êö1¶E«–O¶ V–F˜2§¨*lå䤭uÖ¶ÝNBž§c˜Ž'´Â£Ûa¥ÚãÒj‚•’í;c^yý}þæ¯_fkoÂrß# |âÈçå_¾ÏÑᘫWNc[KkjÊ2G)‹öƒ… “AàyKÃ!×.¯ðÊ«róÖ/½ü.a䳶Üqɉ‘ô»Ú¦¡Zè‰ø”eåØ9JÒ4–¿ÿ髨o?ÿô‹ßûÁ³øR9ïâF²Æ =MU×H­Xºt´BÙ‰d¿,©•[ù;U†¨,ÂS`q”ey•’æ)M[“×9=!©Mƒ ËC!øàöŒ÷îÎ,mx÷£;Ü9€þÌ¿àƽCûEŠÁ#ÏÍG83åyÎËXkò{eF¨Ç$8HÉ©áºãÉ+gh%!Gã#¼ÀÃÓ>ÃþÛBcêùŒIsÀãçþØ©¼Ù/W’_µêºZ(âý~׸0nNjÝ,š”"¯Ú“3àwY&ÑBI§2eŽ»T ­¥< ¦t:âMI‹" $«Ã˜ñ¬$J:TUE6Ÿá{Ž>>é|ê”+u@S[¢NŒÔšn`MÃJ¿ËŸmñ?þOÿ'·oïд-7nÜåó›;œÛ\eeiÀ`˜ð“Ÿ½Ã7®®1›MI:}”t2«R<幑¡ö§¸Ø¶|ï…'xâ±³xÚg{û«W6R‘ıS PÕ Ú×تb>>"‰Bªª¦(+^{ý=Ô3Ï>þâ¿ü/þ OzLf3'˜®°'"Ö+eNcEhA&ÀWß'Dp7/\5«ݤG$X,¾çQÊw OëIŸÄWèÚ²=Ð;Ó0“—xöòe|yÁ:ýÎ)Kç¸~÷€¬q '?êã…¢$&+Ò¢Z8iµ(í!•¢Ès‚(F…žç£¥kñÂñ|ÈÝÐJ)‹*éf­B-f®j|‹ ðð&¨ëÒÑP¤ta+œÞvUž¨êoî¯Ú ¿+r;£“@ÿ…c„%ý‡ÞYÛ¶t’ˆ¦v|H¥ÚÓO'èÅÁ{üóµ´4ÿþµÚÖÙÙùž£Y|„vŒÜF)P·–Ž/œÃU i± ”ãïsÈy7ã7FðÎíwYJ4‡Ó#´iñ1(\u`´B)£ÄçÆÎ>ÂZ–‡Ë€¤¢`ئ)Ò,+ rr}Ê Ø«sں娜1ê÷°ä¦a2§ª Ö¢€Ö×4YŽ"éA+žO¨M–2 }NwV¸W–¬Æ-?ü´Ï¥QM¤cvÛ;ÓŠõžÏ(HCŸW¦’ï_ðH”¡i Anéõ‡(å‘6J|þÑ÷>9ââcë {†¼­(ª‚;ûœ;·ÊÆJüÅ¿ù9Ÿ|²ÍÕk¼ýÎMnßMÙ¼´FÐIXY1w'GøBFEYFKkÜÛÙÆ÷|ÂÐi°gó9u°7Ÿ#œIBB+9ÈSšºÁ CÛÖôûËxJ1˦XaO8œàùn„S¾¢„"ð|zqŸnä±yêùÅ-ñ»)l•Eñ{mk Ûr”·Hå=œ0E³Hæ×õuJÚ³@0-Í 3B Æù_4VUƒç}5ôxÿ—­¥h,Œºl¬/ñÞ|ƒõƒ?å_ÿâò:eeØÇ“ ZR´\H·òå3E ×ù¼rf\&ˆ. “ ŒÇóì©Mtì³uÑÌL‰i¡GøA„ô@µ>fØŒqþÅÎQ´Ô|ôþMîÝÙçûò4Gó1Jj$ƒáîîySb±ÌÒ9Y‘S6yU`•ÅÖZKšW(Usýίn{Œü1ƒ fc¸D‘eyŽ5Îœ'ð“9æiŽç¤YI’$xA€1 ­¹;-Yß8O6?b<É‘¢|ZÓ0§tÂ8 ð5uÝâɆÉî.Úüíß¼ÂÎî˜'¿q…ÿþ¿ûϸ|ñ4?ùé[lž?C/‘¼óög|﹫ÎáJB[UøѱT±!ÏçX+ Â%=f³„•Œ†C”²\¹|†§¾q‰ÝÝ1ý·¯"„%$´9iZ²´²ÌáþÒó)æfÓ½Áˆ—~þ:êþà{/þ³ï?†(Œ²’¢®˜Oæ$IÌ4aqÕ’1Öi={ΖÌ*¨òá9έ¯ýEpƒ––yS.$é4]B¶ó’¥Ñ‡éRxlŽ.³u˜âÇ’ýÙœOîpp”1¯K‚dHÒ:}ïÆiDûAèéž±‹dBšÖ`¥ç¨RÊ©faí gøA…ãCÅÚ/W†_µQÿmZ‡ÔNÓ”$I˜ç™c‚~ôõUYó?f)ùðæ>~æ¸å®5¦iNä6ÛÖ ÕGQt¢†j1d?ž¡›E‡ÀMË]5{?1h_;t딓kBkA¤Iൺª°* T.ñ}ŸÐ¹$üìÛ”ÍÇغa’æxÊÃø1u]Q–%;ó{<Ó8]#(•e2'1±N¸³{ Oùað•ÆÇRæ‘RlD ;Ó#<åS”§VO1¡}Óaˆï…ôý%UÓR”%ûÙ˜¼-9µz eEQ xÂRiË…î˜IòÎ4áî8ਠyížåÃI¯2Îs.ˆFzk8ê Z¹DW+°Røš,­Ø<×áog!—C'ÔÐ }&Ó +K#¢0àò•Už|r“~?!J$žï¾»ÅÕÇOш†;×·yþ;ß Q½¨ËJ2 (+îN÷¸ºñ||Nשå­W¦bµ“P-tˆ÷§R⧗Î0LFxBcDÃ4PÖ¶®J®ÝßJ+â8ÀS®êÕÚÇoÚè4}?¦â!.ÿoZb1‡•_ƒ½ð»,Exš¦ýzûíxì³E‚9Ë%e#¨´AÉý¶¶§,R|Y´ÅéÆ»2æ·½NU–Ô¡G"$]8Ï;ŸÝbàoaõ¬®b¥»cQê«GFž3ÖZÐkVx,E‚Ñà1^¿UñÚ]ç[wö ûóœéÑ”ÇV»l.a>‘•5­­œõ¯Ç1žôÈ‹©œõï›o|Bž•¼ðƒ'e«,8ÑÐ⇾ PJ¡”ÄüEr£ÈC–¥xaÀÞtÌîá˜iïn.-­ÑÆû”yF# ŽœØ‡<ÔÂ#@)MÝÔø¿Hò·¶šAP3Ÿñ~¹Ì餦¶IÇÙývú}°PÎ'ìålž=KQ¤“ þoÆg7¶ùþsWø¯þëÿi+â0àï_z›7î’g¯¼ö1_=Íh©‹„ ,M‘QTîìõý­Úóiš k$yžFщK–1-MÛò£¿Éko|È÷¿÷$uëƒEE·×C‰+qQÕ ¿|í-ÔSO?öâ·Ÿ{šÐÓô;Çi•š£ÉØ!ïlƒTß÷ñ¥¤•àkífÆV ”uU¬ö0mM'éâü/,ãt‚j[6ý„ÞÇô ”4àëøPð=‡l5¶aOa,æ)UUœØp£G~àºu]SV%Rº1D–NÚÇó?Ù*',žºÿ>­…£Ã1 šª±ø>H{òAa±$!øÚ"D‰¬S#Z¡}…lj$)Ü{— wÛ4÷nN@Z.w[^¿ÕåüJLYOÁ îìpîÌY¢Àw¢8"Ô«kË´¶%"ä`>…¡ ;ʉچ>ýŒSçÉŠ ª±ÜžìÒ ´ït“|ʨ³Ì¸š³,5éTr'hyneˆoîíR‰’£bLYT”eEkŒ=z‚ÑpĨ7¢ PÖ£µ-ZkªªDš·ßåÊÆ7q^ßÿpUª´C¤þ¾ªgcA+(›¯œOfÅ8­£9è…ÑËqí乺Ċ‡¿¿~ûûBÐ65Q4IÅærŸõîµqûp¶þ×oÿš¿{;ã‰óg0¦jR,Z!Ê"ZC¥)Á¡@Šé+„²¬"†aŸÍó°²´Äcç¯qᑧyÿîÛTÓ1í¬¤çiÖ×7†Åƒ¶n1MKè‡ôâó"c2I¹}s‡g_xaž!‰P–²*O®­m-R œ^Šb¯m˜› QäX Eàqs°d(œZc§Ó'ÍœŒf[:“–ñlÊ ;B‹çùÄI!Zª¼vE™V˜¶¡(<­97xALe=BÒEŠÆJüdÈ™³kÌÆ{DaH[;æ«WÎòÝ<…šÍ©uHxMÙÙszc•ÐW¼ðü5ÇqôðÃ.éìˆN ™Ï3¼0r ®tFÆD¡5 AØÁcòtFÝ4$IÀ·¿u•ï?ÿBJºýÎb é#=0­FË©|–_üò-Ôó/<óâýñw™ç‡ã)BH”L¦ŽòÅÑb6%¨Œquøm FsP91t ¨Kò:#¯kf¤=nMYlÅ1••4MŽôÑ œÝ¸ÂöÁœýÉÄ´H„öQ^ìdÛ‹<‡þnœêQ]̦3äB“Zi ñ<ÿ$дm‹V’ù|αÿqÇÔ ¡Žã r\eÛe¯R ŒCn#\¥ª¤¦.s¤ö¨›õ3·jÅì*Þð„%ä¢úäað˜\TdÇÜëãYpQæ'mmkß²©+ÚEÅü3Ü¡bñÔŽut)µxž1íÉûhs!HBèú’²(©Z­Ï9 cʪ!7ŠÂhJãÞŸx r–R‘Í™ÓÏñÒ;oÅ9Icét‡ˆªö Ÿ²¬<¼$á “•’Õ~YÝPU.@gyŽØ\]£Mqa¹ IDATø £g†kÜüüS,Íbæ8›Í¨™’Up4™0\ñÆGïàÇ!j1Ž(Ë‚Õ¥ïí#Ò4„:`m¸D•gXOaCU¹ÃÁÄ!Ûó9O0 ‚ó©³|vóûG”¢¢Óé²}câþïê*²µœŽÚ†ŽêRV)Ãn—nÜ%¥ ÜýW79»º2à“϶ÐFs8ÛáüÙ³líM™lmOÙÙÎX_Ð*G<–d}dy“Ú4œ®ñɽ{Üa†oëQȬj¨eEU!ótN÷µÞµ¢­[Žèú ×{³õÑZ“Ä’µÁÁ?‡NÖï“ë,¤`š=$ö—µ–²²X©øMÛ¸5†HZG›úšù@Uº™‚ÈkÕ>ëˆÓIŸ÷î~Èfõî”wnÜåÞá=6z›xÊrcgŠw™Î®³{ð>my‡[ïps÷cî|Ƈ7·Ùç|¶{ˆQšåå.ý@Ó÷%VišÆ°1|”ÿøÉ ÆxKIŒT­ÕÂQÊàE1óÉ!é4E†¡“ëÄ©fY1-žçQ×Rêûc±ÔÄ‘ÆT9ïç]6û‹ ét¡Îøå+ïðoþòg,û ‡]®^»Än©X;sSMÖríÚ9^xöÛ½küàÑe)Ц@']ò¬f}m…¢ÈiZK·ïÜí<­©Ê’¶­)Ë‚ ˆKUä ³ÈÙ<çý?þš<«9sfÏ̦¬¬¬0›ÍÈó)ॗ…zò™G_|îûÏVHÃx6c2›!Ck[Ξ>C±8 ³¹Ó=l-GUMa ¯Îô;tU@‹%PŠµ ¤§]kìóÉ” ÃUöË™' I0â0K áúõ]ð’Á2qoHÜí#µ(ò<§Û8që>Š,£ÌsZkQÚ¹(eEéZ‹SÂGoÊÒ¥$eYhkk­iÁ´íâYˆsˆ%ê~[º­””(O/xÏ–ºtmõ¦mOt°\¿­Eþ›Ö z[‚0<1¢BR–ÅâYg7“ñ\›údÃó4ÊLk4XkÅäbÀ¢óàò®8¶Ö™_‘Sâ$±ÖâIuɯoße}4rã„Úu¬•,ô ÜáS5‹¶ùq"FK”…o]û67ö>¡/rc ‚pœ'l&=°–ª­¢d$ZB+™ KYæî³°†F ¬iø!ðÃí-Œ†OÞwØZ\ žð؈crÓ@Y±~f|2ežgt»]Ú¦aui…IQ0Œ;$KCÆ»{Dž‡Ñ¿±,¯œ¢,kŠ¢äz6áÉA‡¥ CÝ4`¹Ûç×|Àc—.±}+å­_Üfm¥Ç#×–é&ú]ñï>·\XÊ9½zŠ³§Î0ŸÍ <í{øÚ£¬+’8Â÷|¢^À/_úŒ¦(+>ýð»Û)g6"¶w3VG1ãlŠò%žrö€ŸÞÛbce…›×osÐ<¹¼J§‚J5$Âg=éúŠ­Ù!Rù'ëZk꺦**Î;Çõ›Ÿ³´´|Òâö}ÉdBàuø›?ä›gÊc±…ß~¿ÿ>¹ÎUÛRó×Ëþª%„ +ÁH¾Ô²w{Õâ)µóPÿºù@UŽ¿+Ê7j’yk±ºåÂÊ5üøoÜœsi¥¤NÙªWXŠúƒ€í£È+ ›AÄJàq¶›Ð6+]ÍÀŸÐ׬Å-»oóòç·éû+ÄIä|Ù•àüÚûÕ>ºÊI§Ú—¤Ù ?ˆ¨›šN±¼´„ò5Ãá€'ž¸ˆ(¦yƾT4¡ã/d„ô[åI„…f0è#Ê‚P::hÖZzaBØíÓñ=vöõ{43Ü°‚À9†Ó’NÇ}öX⨠»îœ_€˜•³nÑRRT5ÁJWbªåk¦ÓYQó¿ýùYvøÞsW˜k¶G.c"Q"¤ÇÁî=„Ôôº ›šÒ‹ˆ—aû6û¦Ë[éêó,£Óí:ÿÍ;ÛHM†TeŽ1Nw6KRóÁ‡7øõ›ñ“Ÿ¼Áø‡ã9מ¼À°7"ˆšºæåW~…zæÙ'_ü³?ùƒN—~§Ët>Å‹gæž;‹ÁñxÆölJªíBúÑÓ áT/au°DQøÂrvu[wîºÖxV`PL*u¢./_×MUSd3æÓ“É”¬¨ð‚ˆ¦µTMKÄN¹ê Hi!åâиïÔT•å‚kZÑnfmûZR;ð”Ô µà[ë€XmëÐÚuÓ ½cC󯮖çà,\ Œƒ„%ŸO1mKUضÂóœè†Åœpã„E)h«)…üÅhŒ¡1-³é”ÁpôZ™Àu›«ºÁ|Ä¢Ò4Æ8 e ¬ ¬ Ø­·«±°Úb¥Óþ.‹Â%rÑ_TæJ)7›;v°B ,(ÑÐ"ùÕ‡2Äì–»$*Æó<²|Ì…¤K7è2.gtZŵËO°¿¿Ç^šC¨ñ­âB¿O¯2¬öú”YFiÒ"¥ÓéVµrâ1Ç÷‚Žv«°õ˜9{û‡X)3|÷Ùô“>×ïÞ`V¤Üºy›¤#=qþ‚UÅx2!éÆÜ*Ræ ,û¢vÚƒ¨Ãa9#¯ÿòÿå¿|¥A+Éöîó›£Gxë3ŠvÌ@tºN]«mÛÓ<í±Ô¸Q””¼ýögl¬-h˜µ%Gµ ОXœmpÓ¶äyÎöøÙ „–„JÒQ OÁ½ùŒÚ :Ý·ïÞ!ö<’$AJíÜ£<‰mZ”c$BH'®¤=L[8P%IâøÐÚUÉJ€iæÔÛ†~'a¸xaƒ«çOst8ÃZ'$U¦‡dþ*ºIQMå€aDž—tÜÞ=àO>ʲ¨¸2Ì-ÿÏ Íw/ža–R–5aøÁ‰wCSWÔeIÛ6ø¾GÛ8¬O<ÿÝorþôˆ0ò¹}g½½#š²áÊ•s„¾OSWü䧯¢ž~扟|ú*I”P–5Ý bi0dëÞYÛ 0ÜËS„±Ò_&ŠÒº¦e-éP·%GSªºA(…'<¬´L°´Ò§;èûƒ¨çÄÙ½ ¯¹Ëxv÷¯È§/¡uMžµ4-”E¶žå®•Ö6̧sl ó,Ç"Z+Ñ^€ïN*Mʇ8—ÇÁ@ʇÓÇÕÔ±M£ÿ@&,zaJWZ?Ü6.ªÒLœÛ‹…‡ªÊ¯ ÆÑ1~C°n?_â„D$öD}F{>(oásÌ3v'‚·¨è¹ÎKÝ?üŽ8~Ô! \’q|-Ç­q±ðoEì4fã/×Öµ¿|%4Cc-µÄžtò­¸öœÿÅCw1¿« ÷e:¤‘ˆºá—Ÿàõ{pºÛwC­Q“C¦ó9;³]Ê´æ£|ŽÏ©DÅÖá”Q2$ÍR*S•)ýnƒe>Ÿ†M[±Gh¡Ié'¨qc¸t8¬çŒÂÄù\+…µæ„–gjÃa6Fz½ßí&TU…°Ð cÆó9žç!µd·. ô…d%²²²Š­N/-S57×xíë,-u¹µw‡YU ŒÅöè’$Š(딬©Øºs‡y[Pç%RinܾE쇬ô‡˜¶!ìƜٸûW6Ob>7NŽ8~ÍÙ¹ZÃþÖA`µàÔ`…@ N%#FK#¶wwðÀƒ­=æYAÜÉË”Ãê¾Ô«ÖÚ%#¶E*±ðî­©Z \]ZÁ÷||?F6’¿zíž¹ø$¢ý‡[Ê¿ÏÊ9¯Ì‰(Î×]Ç3ç,/*\$©_ ,Yè‡NºóŸòZà¾Ý›âùд5¾ç;0§r÷`Ý8éä Ž}Ÿƒ½Þyó3þâ/_â¹%†ƒå×Û²¼v–Wïe\;P–ýá€ÉÁ-Pe3m¸wïT"ˆ‘_‹hÚ)¿Þïse-a>ŸήÓ÷|¬1¨…q‰RÒÑ[=E]Õ„Q‡$öxìÚY¾ý­kܺ½ÏÛï|Âò*÷îmóèÕMþîǯ ®}óÑÿÙxݾñpÈ Ë ~öþ N/Ï¡uŸã½é˜4%­*浡õC¦yŠ§}š `emÁ`Èá<ãH z~‡w¶ïR+ÁJ-*|MGJn1ëâB³jA°3_ð²:éB7ï*Kò¶& ¤D‘Ë„}²ÇY55Qä2îµ a§ª9GlÏ'c©³ŠZJª¶EPsýö·ïÝey½ÏÚÊ*Ê“HcÉmCßXj ˜† Ih늋›ç¹uû^ 8(æÌæ)é,smH!¨šš~¿ÏÖÎã»·YZîÒYQššºi˜§©K Plïîq~ýUZ“•©ñãÏS{yv"N"…«Úšº!OsιH?î3êܽáÁ­»7ãˆSËÙ•G©¥þ À¨ûë÷Y9K%©ÌýØC(íïlÔqœÌ+,™qøˆibF¸Äy.L3þ‰@)M™;ŠÐý÷±Hö¥$-Š´vø ¡=¤ÙpíÔ%Òx“—?¸Éz¯!¯AÝBàXÅÎÑRûÌÒBAikl#¹>žòé¶å¿ùÁc„@{ÂH£è6Ùoã©ŠawDže®,%“2ŶŠªi8w~,/Y?»Â¤m‰{C´ÐL‹’iS31Ëq‡¬­W–¼lÂk’Ž|²3c¸Ü…"Ç70A(A[£>óyAQT¡Ñúv¿“ ŒÙÛÝE)Eضfž$qLQV‹¢ÃÐ, tÀK¿ü€²(ùÞs²´²Ì|ž‘×Î>v»ê±, zƒïQçsÒ¬À÷`|`0m Z“$§ƒ! Á¥ÍGšõµUÊtLxg¼º8kïŸõR(¤„í]ºˆ££! ú§ßgm}™C>úø6/½üü9ê‰gžxñÉçŸÆ3-UÛ"­¤­ ãùŒýª¤4†áp™²ÊÑÊcžÏ(ë a g‡#úÏrÑA°2Z&Ks<­ÙM_ W™I!ÈŠŒ¬ÌP2ä@lpªã³µŸqï(¥2– î üñ4](Ähªª¦©ªÅŒY£¼žÐâ2¹ŠƒÌ¢ê{Ðê8po4)å‰óÝñÌXi½˜›Ø‡³XÌÓʲ!¨«‡«ÄßÔÊþ]€a'U¾\´Ò­ãQ{z.žõ•ßg­ÅÓW*‹÷šÅ!²³,[ˆšXO^9Ííí;È@á…>ÒwíñlJ^–´»=Ö—z$q m,6 dH'ép¸{ÀÙN‹­¼8z¶êºÆ“>çN_`2¢©™fS†³!ム§ÎœÄ“>JÞÙïs©ÛŸ«˜}²ýC©)Ìýq£èñ‘TÙ"cnŒFHh‰&¬µx¾¢(K¼0BIAx®äm-ucHBÀqB ŸÌþd´& ÄÇFn´µ(#ùî{±ÞÍ1'g¨,‡é¦Ô¬¬¬ù«K«Üڹʹ˜0Ž‘ž‡iìQÀ›®a3QŒë†ÆW¼Øî£<ºhØ ét¬qÈ’Å¢ÂxŠ‰v2©±ô(åÖxÆR (ŒeûÞ=¢(¦ª+”RøHêFsÐ4¬ø©ÖDAH¼ÜaµÝåÄÒ›k+œ\ßd:;¤¤äƇC–7b¢0"Š[¨rŠ¶ +a‘!Û;‡”"cme•PúÝ$¤uÆ0¡kMÆ(å±?Ú£ Oà½w¶Y^kaƒÐà+7N%¥ jE$A@Ï“ŒÇ3b?fg|@ø¬®­°ÔéswoûìçB: ¡ÖšÁÒ€{{wç”…µãaW <˜ŒÆLfcÿÿemaŒSh:¦7ý›8f¸ìJ+ÑXŒ¹OS» þì‚(R«>7Ç ÑšZËJh°Òé›y•,PO›ØXTÑ„D!A*Nu;¬­tÄ›<{á2Ïž=ÅÅÓ—9·±IÒîÑ]Z¥ÛŠ¾3æصãæ·5)I²v™×n¼Ï“}Â(¢.K°’ª.‰“ˆ<Íéy ·ó a«ÍÍ÷oqîÒYZÝIœg™k³Y=§?–GûmÖh^»ãsy#£² §:-šªÁË çäF$IBú4ºr×*5R8àÙt6Ab{$cÙîv0UAže¤iF·ßŸ“ò8 Ïíí~ö‹ø'úIèöû(ôɳ){ûû =~qsÌÓ'[xfÓ)Arp0ƨk¨ÊŒÁªÁÎ7B¡lD9í°æ—Û–õNˆÖ¥óbþ½ ˆuÚ–v»‹Ö QÔb<#'É{æÔ_ú½§¹wo ™–ÆF³”·oÝ¥ÛoÓ‚ª†ƒIF«ë8wÛ6Y–;kYYZA4‚a]qP•ÜœLX;±ÉÅ5N·b:¶dZl³¢®ŽWØ<ýgÄ'ÿ¾ôyw·Ï³§¿€° a în3™¦“Éä,x!º±@Z/G"Ö›Oœ/¨Êh²ª<"±<Úi_€‹ÏX œË²tÌs¾ŸÛº|¤-ä)?ÍŽS>øwCQ÷GÂæ¨õ5#€A3è(B¯! ŽUìƒ[™”a’8DM+<×£wýHk÷Ú#.öO¹¦Å᎒|Ë_üÉ¿ 5-§{‹c“£L³1¢+ 7önËšJ€ð¦¨8™„i™˜šk¢æm“sey3Qˆ(+Dàq¢·L·×¥Õi5lÓPùŠ_î3Åb¤GŒâ^YÐXCLÆDžÂ ò9p3§¹¤‡PÍAmÙª "SÓïô ‚F¢KàÛãîͽ„ƒÛßûëøàýi·#J‘ð¯ßßÄPbýŠ'Ï_f¶ç”«¨²œ0Ž8,§\»s! Ïs|_ÒD%Q’„!Ož}‚ÇÎ^æôê)f³Ù|c÷¸½}Ú†di’ö2FH®Ý¼ÁõÛ·(²‚IQ#µCÁ¦iJ†d³)‰òGÔžÙ¤Ä#âäÆY–ûëXWV”ÖÒ'Ù¯{®³JQ™ßŽ7û>×½8ÊV[ËsU«SwÿÙmÔ.…Ãq´‚ûd(±gø$ºãAÐü¯ßÿw¼üÖ¿çìZ‡Á ‚~‹0 ‘aH· K׳~µ¨„¾Ä«jÎ_úCþõ+¿äÍ›× #I;IÑ –<¼‘îBóüç¸úö‡ˆ9 tÐ_¦×é¡ðÆ‘­´Ú ˜Ú*FCE¥5'ZkÜþäy¤EŽÀ9õ´Î¹·³Ët2&Ž¨Ë%-ÂXº­y^Î{º–¦,O2,’F74M¸½§¿´‚ž?¶)1UASæó*bˆçù¤YÅ¿üâXC:›¡µ¡,kVVzô—ÃyÅBÐ4söCmðLÉÒ TÅÁ>_Z­ÁX¢0FaðæUF_8ùÝÑ(©¨›šºvAIÜîD¾çÅ­v„ï)Ô‹_þÂ×ÿðí´ú ×ïeÈ"#è h„¢ÝYH ÊùìZ]7X-H„V!?¸:â+g/7†i^rëö>ãÙ 1—Õ’*ÀóÒ¬psÄvžY‹ ¹›C/kíF@¬µxÒe½yY#¥¢©ƒ‹{ýƒÎØ}¥aÝuu£É‹’ºn€àE™\×ÕQæü¨Þòo{äâ\|Ž’xÊûd€Î ûþB}êþk¤òˆÂ`NÆ>?.–( °R`uƒ55eeèµÚêÆÐh—Ñ<¼) !ª×"K·÷ÏÕ)–iâ@Ò”ÅQþQH‹g5›%‡y ‰Õ‚ÛCI¤oc¥‡°’AØÂF°5Üfm°†Õ3žŠÛœP>Yž1ÎÅ!ÛÃ/­.±¤"öšŠ5’7qÒKbÛ0ɦlïìÑŽ~1ž’6c­ÙÍJ„òæ×æPð \e,«"çL+&Í œïÝÏšŒ+,wŠ‚óaÈͺ ®J~‹›Û·6BဒnÄÆú*ï¼¹ÃÚéˆ;·F<õÔIå¡Ó!_=#ù7WC¾².¸µ³V0èô±ÆP–%“*£$Ty‰l ÷Æ@¤ð­Çjg‰õ×–I]¿m8¡­ãðjÍéÓg™MgT4Ž‡iÙMðŸ[e‰ô$VADn²¡ª)Š)kKëôã½~—Ћð„š+è¸YúÿïÕïñâå/#ùäRòç9[ Òºb#Uý›‰p8å#'%À–L;Ge„£¹Mâó+e7×& çÅHAÕXB J òÊ"EMì;܉5­,>–FHîîíòúí×yïÎë\>õ ÖÆ´Õuf³;ÔÓv¦-úíek|1°Jwç`¥»[í€á’#¹ÝÉå“Os=µ|tó]ÒÑË'XëèG1ëQ‹ÑhL¦$ŬäÝ_¾O^dœ:{’avH]×ôÛ=¢V‹º¨iŠ”ÈóÙIÎl–NvX "!X?ÍÊ‚È H³œ~¿CÇ<â8&MK‚PQæSòtFwàzÆMS;!hwÛtÚ p-”¸µ!Ú IDATuä¼¥òùÁÉ™3k,õÛTE‰®*òÙT@' ùå´í”2»=Ø*­ ý?!,I»GàKfã!Y:C`‘Öù)jÆiÉÏG]N3²éˆÉ4¥Óns°»‹n BA«ÓžǬSÿÌÁmšvó·ûmÔæ“OýOÿä‹øÒㇷþè¹ÿ€ŸÝ¼ƒl+Š´`¥“`…ÀÔ5µ ïÞ•ìN onv'Îõ»´Z#ÓæâÉÌc'/Òn Ö[-bßÃɤ\¿·T–»{#öF);»Sö‡(?"/Œ•Äq‹,/Ђºn\-1b-Ø"+\ô•k½x­r²‘s`Ôâ=‹žsU× $Å|–x±`—y;Ik-uU¢<ÿÞò£þ' [ü:3óq®…}ìøÖ±›UUEèûGY«£æ4Dá1Îma衤!¹ùÓo#uIí$þxæ{’,+Aˆ˜Gê‹c.6¯Ggéî¾h,Ò|zY[[ˆ‚û=燃€‹½e¶'o€˜“ D²˜q¥¿ÌW?"NB|,* ÒšÍ^ÝTHÆZš¼"«44ôZOž}œ¶—°µ»åæ ­`Tæ4¾G!4Zˆ#ò‘Å94ÂRLSÎ- ¸•¥mYSNÕŸó /æ…r¥À*#ôºl´#Öã¯Ï9ÛíóÑõkÈ@2­RVâe®~t›ƒÙ.ýÁ'Ï÷xéÙ§8Ø;à…ËW¸qýñ¥gø/~8ã+šåÞ (Kâ8æÜú)tcØ>Üsu"•¢íEŒ§3vs¶oÝ¡Óí!£É˜Á OaJìœOµÑ_xÒË}Ƴ‰Û ¬àêl‚Jbðçü„Q]Í«à‡nn:¯2 NÌ%÷öîÑiwñý„­ýÛœZ°¾þ‚z¾õÜ>o@˜+˜UPÔ®_üY쨳u GÌ“7дAä‰O¬¼}ÖÔÕÑÚqŸa ë0ieQ¢O·ÙþÏïÿ×8½RÓcÄ kmVäÝÎèÆ!íÀâah#joÏ÷ñµã½o IíAhpÄ5D#Vǃ}·¯žî­°²ñ$¢Ž¿{ý]Ç· 2´’˜•$!Y»p„àíWßåÝ×Þ'ôCüЧ»Ôc:>ħA¶Ü•œZïRÔ9ÂBe Ó²à .$=fS|)Yí,Ó“y!)ˆ¼¬¨k¨ƒ ±’ôúH!(Š|Ž ªÙÚÙ%Í2‚0BÍ“¥Iñò÷~ÊêêgÏž ijüÀ#Ï3¢V—ª)I’.¾©°ˆ­+W2ïõÈò‚ÐWxQLè+GJ4?ÅZŒµ”ÖÓ+=—5ë!$“ñÔU'A(Ï ±Öa¥whµ:(OáY‰©/¿ü ê÷ÿ…¯ék_ÆÚŠNTðÓ#þèÊWYn¤œà{ïÝ`\uxûÎ.­ütG󵧿ÊÙÍs\9}–‹'.„›¼·ýe™qòÔe²"§¨}¶gšT´N ö÷9MH'eQ“¥•µH¢­+o´Aë9Çòb¡Ó,Ê' Ã#‚Œ…ó[,,7‡ìÔbŽkP[k©u3—´ÔuC£õ8&ÐFláw¼Çe‹éxæü(öñc|Vsò“÷7‹Æ¥¬÷Íb¥:â}Œ¬P ‰Á7ãû’À÷ÜmáÞë?àíïý5+›¬œ8íÊþ¦!i´=*]¿ŽãÀ:¬qbá‹€ƒ6 ›òHééQf²±øž@Ñ€86o}ŠÓüWß»Æ3zpIl‘V÷M$aCE̪†^¿…§\”ùâ©‹¤c¢8d-Šð¥Dy!wïm#•b–ÍŽ ¶Ëã+”(«¦±˜ù9H¥(¥à ,˜ébÅé0!§ÆS÷AznŒÎàiI®-+¡ Äi‡wü€P:mì}çËë-Þzí.|¸Íê©|/£»Ú¥uØßrmëìÏvyl#bYp8ÉØN8»¶Éîþ>aóÓwÞ`u} c ÂÂåÓ Qä2繧ãÕÈÆJ‡0Vøø”yÉpvˆxÊcVTìïï3èõ©ššÝƒ=¨ÅtÊ•SœB²“ÙÊKê²p¼ìó¹vå)fé uÎx4_0>QSÐÔš–lñwÞâ…óÏcyô³ÿy„µLj1‡g¨—ɧØQÖl5By(«Ñ8ô­ U)èÇŽ~Q…ú‡rÎ @˜;¼ëKFs g"ÿþó_½Æ;{×­þä…¯ñŸß¦Ð)³Z)ÅWa-4dMÊa–bu5ûÜÛ›Ãü#>¸ý‡é †o³½ÿ·v> =|ÃÝ|÷ú]¶ÆÒOgïÝ»Ëë7opuë*—7Îy>—O_æ@l0ίÓ̦¡ž UpþÒ®¼p…ƒƒÞýùû|øÆ5Ê:çò…3ôìŽ'Lõ -/£ÛéQä3ô$塘JŠ²bwo—ØBb+ƒ†( ñ#q6E7%C¦Ã„tAvš¹j™T’v§ç)¢ÈÃ÷Œq•Ð®Ý!MKž}êÊèÎZ¢$F ADÎßï¬Ç –šlZ¡|Ëd–úÊ÷˜N'„I‹éØqç )çç#©Šœ0èÈ‚oÝM“6už¢|Ÿ(é&1élŠò|ºØO¥OYVÏt6E*‰ò<^~ù'¨§¾üG_?ýÔ€[5/ý§—Vð%(³'ûëœY?Ééþ&»“-ö2É¥sG#=ó'—šY:æìÚ†“í%nnu.@‘æÒÁ 讞!h÷Ñ¡ÒÆ•WÁóV£5Yšá…1A”8-e!ñ|߀æåѪúx†kŒ¡nô}&¬#»Ïb´Pa:¢ÈŸwY[ K®M5|†%ç€^‚ɬffáBdªÑx¾D‰=ç?Ðd¦´Ö“ïKæBW[#¯®ñÔ‰Mžœ†ºæ…õœÚ8Çzëׇ>¯Üüòö]ürBW a€Ì¦ä“’ï¥h 4£¬„¦¡«jB-aè)kr i¶8Ø}cJL]ú«œZ8Îu!XkGœX~Œo]+è¨!çWÖQuÅÖÞ>K+¬žìsæ©sØÊðÎÏßçÖmԠ㘯T‡åŽä`›4›‚åÁUÓ ­¥×[&­"Ïb¥æÞÞ>a;vYxÜ¢©k¢8"ðJ]£¼˜0HHÓ)Ý~!Ê‹évABYæT区*øñ+¿âÇ?y‹ýýôµæ{¢Gùdã1ÊwãͶ¥•´¨l@øaLÒꢂˆ(‰ÑÙÓh’AŸ2/À:@ZQ®Ç/]ûïT”qz}@i@ÔðÁLÑ®3V×Ö –ñ¼æ@±8 Ñfuy™é,E øá~†Ë™è¹øx›(UTϽ=ʺáòùMdYq³®xóƯøÚ™‚·÷»++|ùÜyšà2¦ihŒÂÅ ãi»"ˆˆT@¿ÕÂ֚鬤»´ŠJ3´vcRBBU•Ìf3’vé…AEH{Ÿ@Ã)09é°ã€.k-UU=r<\J=Þû\8û‡ËØ:Æ‚úáëÿ¼l!E¹.‹ö8ötñ™‹³(CkcñæÄ$àJÔ‹­K 5ðâôŸP¥#¾û¿ýüóÿü¿¤·¼Â0úØ=yxs¥¥)*c±Æ² ö2KQÞ'½”õø¥`RZºÞÇï™þâk_âï]w}R/ —Ÿ€KqÂZ³)c•çyèYÍ,ËÙOyîüŠØrãæ 7›*¼ÀÍëæyN«Õbw:ƶûXa©ò’³í\=ÌŽÎÓƒH"V•ä:%ƒ°ƒšM±‘<º×MÓ %„F2¥&”-jáF²¯ÉÓš0 hµZTMC!‡MNk}‰ÐJʬàòÅK¼ùÞt»].¬]àjý!;×BÂË Y© |Źîýn|–ÒKb.Ÿ½ÄõÛlnn"LÃÉ•S¿&ô ZÉ iV°½³Í`m==¤Ö}Œ±øžA†Ï]z–ÉÎ>'7×øñko¡ã‚>Ý¨Ï =Ÿ&«y7ÍLÇz««HéFñ¢("uÝ°¶´Îþþ>½Î€8n±µ³…®-êB€ù„êòç³ÖMRXû‘ǯ›{«Ú"T€o5“R¡ìc;ÈP2.,«1|:Ôñw·Å¹8Mxéè'Ü?㬄̰QBdÁ7>•—7ΰ¶y–•èI„ iª £Á÷Îà ©¨=IÈëmÈ‚¡²$ۙК³«ši$ëë)„<†"°’²±ü“gŸæoÿþ*ãÉ{,¯bíÄ Æé%-—º gþü‹¬]ÜàWßùh3èŽ4MU¨>­ÏCuq6¢ëKz­„[Ãm¼ `”iú-ÉS—/¢´E*·'+ˆ¥M•"}Ã8„=„‚Ào¡LÁ‘êüäïßdµßçì™ þê¯_ÁóM£‰ãã锕•eÒ|ˆM‘X´ÕèYru7åòj„/ ƒ/-e-zkã]‚*&jµ)Ó1Íœ-R)5÷?‚Í•eö÷ï±±±ÁÎöuÎy1½g¹wPrÞ+I«yåAi`eeƒáÁ­¸6µããxâ _ýúÅ/ý÷G¤Balï ¹³½C¶hwcV¤âÉ“ˆÚñäɳ 4öب¡ UZA?Q¼õþ7Yí­‘ø!¥ÖÄQ‹V ë ÓhÇÇl4a<×5.6Ú ¤çæjåý¬P›E4/ÐÆ:q v®Ò¤Í}ÉÂãBÇéýà‡Ç‡þýá×5UuDVÿëóg§,z½yž"$(,º©±Ú¸žNWÕ9Íy©Y8y:µÈp•ÂS%sNúG}x­k"_z>ž~–›oÿ’«¿|…ËÏ™JÛ#ùã×z¿e i¬ Ÿ§ÍŒ“ 4Öz ­þÔrå°7"9üƼ ¹¸×’8¾E£|&ã=RQr69l4“4£Ýé¡Êšë&çd¯M "ªºb¥×¥×î²µ}H!KƒÑ0'žYŒÇm.-d»:ÂÇ"ËaVPûàá"i4~ðt·KSæ˜y@fæY³ëÁ;ÊϺ‰š¿¤Ó’÷ÞØei5áˆ7ÿ1Ý_än¾ÌÏ®~ÈZSL¶ØÞ’jzJàK$Ix6:àßÂKNús7›HI X:­„~Üuà¡B#•e4pùÌã¼ùÎM:ý6§Ï %øÝp¦tÚ1½N—žÑju˜Ž3‚ØgHÒ4ÃÖ†N›µ^ÏŒê†&ËèDQMCÞäóìyƒ­;äUF·Ýá[oòÒù ùqßšº&ølÂoj.ô´LkŽÈ>Óûçë|VºYb„ƒ±Y|¬S½+ÒÎùç{u=Éyúwµª,ðüÀ‡%çR”Çö¯£+,B( 3_[¾ßÌÇ_Cà¼zã}®¼É÷Þø/=ñ,>Ð`çUÏ‘tHÏ(é4ª¥’XO …R>žôÜhçÂæ ŠR’'Ï_âímÒ:ãD«ËþxB dÒf6âÌÊÏ~åvä*µm8·¤h4ÈÞ)¼ú.‘’Îf B‡wI„rÓ V=$Ši–ãy¾cKô”;?­iµZäEEØŠÙÚÛÆWáQ…ÌS Oyü×ÿíÿAÕ4<÷ô9¾ø…‹üé¿Ä|õi,!¡Ûí2ONÆxãHN<é±ÖMH<ƒVmÞ†œèBäÅh@ù1µÖ?>¢„ŽÂº®çŸïÔÛ„µYŽµ.ð±¦áýYÈù•ˆº®˜eÊ4˨gcfyAGùŒüàgÈÑxÆ;ÛÜÞ?¤®=F“ ·înF-†iÃ054Ò8!íZ£•áN5å[?@ËÑŽR †é„µ¶`ÿûô[Oc$Š•AÄj_Ò‹5¢žÒiG(iHbO@èILS®‰BÏ)óÔõѱÀ°‡ËÙÆjã6ã±ãeÙã ò×ÙÃöå݈ ×"hPJÆWx8H8îĵÖ«,ª ÊSGçÛ4 Y–¹*CâKˆ"M+iñçÿéF]æüû¿üïp¼ød¤¹B(°¦þع‹9ÉÉozB&…Æa£ïž–[‰ )|ÒbÂ¥¸Íx\óÑtJíǼ¿·Ï›MŽT‚SK§‰[!÷¶hÅmf£ÙxÊ“gÎs~iýHÀÁm\þÑ3ÅŠPjÖü˜º®)Š‚S.¡xxÆhCžçÔµS“Bpvó$UU=ðì=ÛM¸5JfӒ׺ÅãϬÑîüËÿð?æO.äñå>öÔþÕ?ûWüÝÕ~·M¥O:“$ Qqkx—“'N‘ɆzâsoˆÆÒIBÞ»uÉx àD'<_yX\ .+r²²`8.é÷"b“á‡#.ž=MOFdEÎp4©¦DAÂx<£i 2öÉuNĈ¶(*L©©³) ÆGk®¢U”T³ŠÞR{÷˜¥)¢VDm+§®“Fð¨'âÓƬ>‹k™šúhV÷³£yHîá€tñSTÝ›0h ÝrU¨ÏÇ\€àIÍRºA” ¥Óm—òãU¾GícðÚsÆŒµ|éÂÓüÞã_ã_üÁ?Ç£9Ú?ÇŒÅþ½ø7üúïKT‚ôÌs O3i öW¸=‹y厦ɯn+¢»¯ñ£¿ü·lïPe˜ñ5<©˜5ç–úÜÍ îf9"ˆˆ¥`c©OÆxÊc˜(‹rÜƒÑ e>C7š$Œh©€•Á­NB–§¤UAU×ÔeÁææÏ?}éIâVm žïSW aÐa:: ŠÖOž)1eAS»ûzéùÈ&å‰ä€­©d[öùÎݘqiøÁn—W·€¨KFijM];e8‹3§u…b*£ñSå”Ù.‡;[ÄQH¥!V–º©hÊ« Â9æ@züÙ¯Ÿ¹òíÎ2Ò×ìoï0N+ÂVŸN¯‹/-‘JÔ%øñÏ~Hœb­=àˆÎ¶®(}G·÷ái:RñÑÖ”Ò šªáÖ­{ìì I3'¨‘¥Š²¢$L§Sš¦¡,¯ªþ‘ZÒCIqÄþ%„8¦Ë<ï[pÄÇ3äã‹íc˜øxÆøi¯w£TŸÞ_ý,=ç‡G:¤H¡°JBÍiHç„*ÖZ‡Ú”÷#X ô:-Ä\ºL̉UŠ¢" <ʲtì[¾ òƒÚí6§.\æ•oþ'Î_BDmGî"žï=pÿ¬vlÁ¸ÖÃ"XX1¾øu¶x¶‚D.€a ½ÀS–;£×¹»çÖÖ)'S®å9JJÂd‘¹ykÐã ;»<ÿÌ34EÃ8qêģà “¼àæÖmzýîQ7`±!•MA赉=[ÕÄaÌ,¯˜ùÊU)p#ROµ—ÐBÏ•½HñîÎ6±Š)ŠÌ1Êá”Ö»·¦SvßóÔ‹k„±Û¾ñƈ—»ˆ®Êñ«[÷xnùŠÌòÎh©œì´8½v‚i:åÚx­u–˜2j…´¤!›Öt:‘a,rVúKD~BF(á1™¤)ƒÞ2Óá„+WÎQå9ÓéŒgNª€íñ!Êl.­¡Œ"§áö½[XañZzFY-hæØ…B7TB¨š²Èyay•½øÀgÞÿðO<Ï2ËYëúøRñúµ3¿ÅtöÃÑU~|mJO]ãý[SV×VðÁ]~ä@磀 Ò ºøBûV|œÿû„QŒÖ÷nß!î.áGmÖÖTù̉ZxN¹È– «ç8Ù^¦êÂ!ŸÓ¢Aç9¢œ ¥KÞúh—›÷¶©µagoŸñx†ð<òª&+JFŒGSf³eéÀ&Ö:áiå¹ì9Œ"ô|Vm‘Mû¾OÓèœðÃåêßd”é“ó'™nêo±1ÿ®ö€S~("6Ö±z-¸dåü5ÆZ„¼/ä†!e6ÃÔQìÊ%¡§ÀhzݔĢ ÀšÐ“´Qµ{¾ò§ÿ”V! ¬ç‘ùCt€'êy®» j¸ß£¯Ê‚0Šãë6Rx’ãÛ‰gaŠææGß%¯±ÂÎJF¾ \Ï*­3–üˆ³xK-üP1hw‘ºÝ6é¤$«J³1'–—gNî“»4FÐAðN–²oj¶Ë’I]S5NÜÂqRKfEF?¾³Ö’$ Z4Ô%üù½² »UMxtzJ(êªáÙS%Më ­9aNì'L·^eÜTœn÷xã —Ÿd}°Ä,+™¤c‚  ãµ¨Š’I:¥Ýnc­åtw‰v¤MÀ;è0"L°‡ ûÓêÙ”*UTäuÃÓ'jNn|éckéó„I'Mó‰¨ðO3c VTÆ …úµk\ ì ×Ö2.4ÊS(k¨Í' íÀ­ª¬°â>Èq‹DIà)¾ýÆ4Ó›\èøJáyýhÄÛ7Kž¿ô2xâÑåûG-lq}ŸV94Vc\8}Š5ÿ·oý‚²øˆu½‹žÜf|ð{ï1š]çg7^çë·ÙÜ<ïÆdqsî¿÷Ì“‡•4*BRS%Ê‹h…–Vàsáô:ív k윞〘V»IÓKkLgI¡­e< µ›½V¾G‘g(éäë¦&šKKϵC}ORèJó×ó#ÖV;t: b.B W‘ð$ŸÍg´—O Ꜻ))Óœáp‚±µÚ´"i:ãîá÷†Œ³†ƒIÅ­­}¦;‡%Û‡)×·ö™ÌRP-ÒÙŒÉxLw©+MZVLg3ò¬¤j4W®¨²’²,©ê’0q›Cmç°Ê‹XÄ‘TØq‡ú0¡ÀñrÍ£ìøÿ?*¢|”ÕeF%ü¿ßÆ,®#¢ùßç´—sI9©¼9rÛE–þ­m1è*gyÐÅ<IäáKð• ªÚ±O  ðçÇŽxx÷û¿ül^~åÇ \¦ÙJhz$ˆ2Ô•Ëàű’`‘çDñoîœàI5/2gKCj-Y~è!xãà/é·`·¶n’5 IˆžLXéöØ;Ügç`•Î2yUÐjÅœ\_ÇJÁ4áû³Ù ­-yîØÓ0)r'”àKZÊCù¡§¨uPŠRhÖ£øck.Nb¬ç@Rj¾a®†!?m‹3›®šTU5Q¯Ë·~ü+®\ya*†ÿýïxz}È´–¼9ÝFëš8ôQ¸ž"¹f}½äÍmK7¬AÀádJl,÷&L‡C*cX ¨ŠŠÃÉ!«ý%ân‹3Ë,õ#¾õòÏ0õß)Ë çÎ?ÆÎöƒN¦ljºaB9ÓXʼn͘¦bï`¯ÑîuÒNªYÆqÊn ¶¹±ÔÚ Œ¡0š0¹Ôí£†{ìŽ .ž»Œ»´¢ÇïÏçÎí·sv•0Ö€”¤õgwÌÇ÷ˆIÑà©àKÄÇmQêüÅšsÁ)ÖÍX >žkhúqIÝLñCH)"Œux×fiði¢„˧VÒâl{ʽƒ yQâyKœ=ÿ5¦ºf MçöG•t`§`>Û[ B•$B!ê #¬cìš_²o–í™dÁ IDATGΧX<~|šŸ¾÷ÒL!5ô¢ˆ»Ld›(äL7äñ删ºÅ[ýŸ§•øhkØ\ZáûoÿŠD掅k<å£÷oóƒ¿þ«7Y^Ž¦ìÌ&¬vúTu=pÝøò|‰ýˆ(ŒB…!“,å`2¤ÆH¥ÈÓŒ¥¥%¢8Áó&ã1QRéßAk¶wöù7ÿ×Ë<~ñ4Nì(í}Žn'?i¨jÍòêq’—A·ÛwJ^>½~gŽ¢IæäñþyYâI÷]O§)Y^³ºq’¼Òìïø+kkDí6ž>W.žÁ–S†C"?@ I„Œ&ƒ•eÂ(pç)?üá/Pçžzéëžù µ5H©ð£þ û4Æc¦³”¬ÈÁZ²¼æ½·ØÝ3™æ <ò²$/*Š²b4žÑhǶUiKZ”4F`½凔µáÆa¬PxaŒERk‹ "‚¤MÔîapHÉ ú¾ ½át‰rÌÇÿö›DÅrŒŸôž¦*ñ>@˯3k-Á1zÒ‡í¨.¤k+H…a ÓéÔIPâFŠâ@1H$-B©éDsÀÝ¢D&yžñ‹ï~‹ƒ;rÞgfkú-ÅÀ¯ù¿_þoxïÚM^¸ô43Óà‰ûÕƒ"ÏÈœ“Rcä3ï9»×ú¾äÖÞ=šòYY’¦’«§œ*Ô\«úK›g9Ûò‰ŒGBZ”çóÁµkœ;wŽÃÑ? ¹v÷bd8YPAED±B[A$L›‚ˆ€Çú-–}å…Ä~ÀqHOx.º÷檪rýf!ÚðÄÙKêUJš&gë°`)Œ(Ê © í)Nõ4ûoòËwþ5yƒÇ{Cf)œŒ:a›Ý²b¤6;Œµ¼º{À«·—øó'"R¡ñ (CÁ,/9Ùéråòc,Ö*ð·ïÝæ¹'žáðpD?îæ7oyòÉ3´;}¢xÀÎá~èñÑá]Îlž`·i°|ðÞ5ƒA°¸Çã_!‰¶nߢÕn;†,/@‡!ëV’kM3ÿÞ’/mn°5™r}g—²³L»Ýb”™¤»ìŽV¹°¹þÀwþÛÎ9/Ö±1‚qâ·È˜[Ù<šXçQÖèŠ~rÿY?ž~RµMiMåÁÏÞú6Ê®Ðí ð¤ÀK$ ¾²4‚@@]†5†×>¼Ã˜%ά¾ÄJï2Ê?I;öé+…Œ\µbQ1{,V‰’ö¨_Ù„%ß|ó-ö÷ßãêö-Ö6Ï‘àas† ¤A…’—ßz¶ÞæÝÛ¯Pfw±Á“¨à4Ï<ÿ¤ê$ϲ¾q‰Ôöøö»¯q±å¡#Á‰(¢£·ùàúÛ¼½µÅ¥õs\>ù8/ßÚáƒvyõßáö‡·¬õ9ûÌyl¬hë):sBM]c´¦( ª¢$#&ù eÝ8_Ó4$­ZkºÝÂB·I³ èŠÃá!I«K£-yYÏ™(»­6/ïçlmòÂsŽp'EQÅ¡kƒ`ê‚ñ,eey ¥BQØ¦Õ @xDALi,ƒ¨&ò ñ…äáÄuhÂV—Õ‹O³|ú""êáûî!ì¶$J״À´x•ƒÝ)/=õU²ÚõÆÁÑΙ9ËÑq€Í§š5$cÖY8g©-ÿÝß}“ÇÖ4é4cœ¬¯®ù>‹òe•³5óÞè€hÀØ×Äž 4¼ýɧ6Ö¸¹ww>û­x|ó ×ïÜÆx’À gS¬5´”d'¯¾ •˜(Á¯r6Û]Fé?ˆˆâðþx•p`é{\Ü8ƒ°0šœî·T$¾ÏÍëC>¼>äìÉž)_B?²hk˜LÇ\Ó5iù Ë1‘ä…î2{:g…‰ž±¼âóÜ`;Ój.(9˜ÎhÆc’ò:#NfU…)ÚQBÅ(/ •x ]F‡÷˜•šÕ¶¶îqåüc覢Ä §)O=~‘,Ý!òÚ´úf£!ïß¹~4QU5M/ÉuÎJr¢•Ðñ+*ág»÷½¤•€n‡¥Xj­24Oœ8ÿ€3;^ÖþõMëÀRPÔ–q µŸÉ1Çs,~–Ʊ-*pŸdRX<¥Ë¿Î1ƒcµ–»çéwÚxB£µ»!R:€e %ùÃïrñì9bk9»²ÌFo χÂÏ£2‚ÜòÚJFž@˜)ŧ§$ieÑBÑ!‘1©O 6¹1Ñ\X2øåMÞ»û~tõCÆi¶†Ÿ¼ÿ }}•g–jÎ'5—Öô”åB/§%÷ØÚÿˆ·oÜB‡]ºaLÅ<±ñoŽÚ¼wó‘¯é¶|þâ޴ײ+½ïû­aOgžî|kfUq¨"ÙÍɶÔjYjÈ–F'‚Î'ÈWhäu Œ8A[%P"[±-¹[Rj‘M6›dsl’Åš‡;ß{æ}öÞk¯•ëÜ[—Å*’Ý¢¬Eï™ö°özÖó<ÿ!±%Ih‰[gP..œ@¶Oq}´É©_ù/¾°À¯}ÈÎí¾rnÿëþ·üÕ÷ßâÜcëìí h4ªDAÀLÖ;=¶·÷Ø›ô©Ô+Ô«¦³c Õj [Z/û× û¼'½™»NÒ1HAÆ|ç»/“å¿ñÍg盀‚8N(K‹^=Ò:ÈrCJ„õUÜ( N¦„±¢Zk1psßmç,:ÉÓ ¦ôA;‰4»4«5ÆiJ#©4›4Öw‡%§×&'Ïfsí{G¦Àšk¼ôt§·ÄK?~uæé¾}á¹oz8¿Â¥4eé¥-‡Ã‰·^’r®õ;O¼y’ã)LÒ“÷Ua¬C‡¨r$""¥ž÷lAE!aœø­ÒHÌ]tÔ'8ÇǨãØñl>]Vzðëj=l|ìËÖZ’$¹¯ú%˜£/=üÿøùÇq|$wØBA b’@Òk %I”ÿφ y*½@ɼwÈ12bÿæG4–ɲ%¤¯¦‹¿ÿ?áýÚÃÈعt¥ßäT•AØ+üfâ‹É–:B‰·’›Ÿi©ùøUšµ˜$Ih4$I‚t¨¹»yÛ÷†Œ!ˆc6'2áXÐ!ïúÜœM9ßè²»µŒšQ^Pãv¡S[ E¥R%—‚¤Ü= ´ddaA¬Rœ\Zc{wÌäÄqÄÞÞÞ'0Eiè ˆâ„JÓŸxµ’j5dq¹Â`kJwÅ„è9]Á4MqÖ2´Pu%»¥E*ˆUÌÝYÁµ=D#ƒ€û÷æ -ßçȈ ¢*.T*îl±²´ŒDz mgyõ§Wyö+§Ù¸³Ã“O]À”Žh¾ÑUL=Ò…Àš )KîÝÛƒPs0îC iÔj¬­­1LqóÞØd2¥V©"œCd’wÓ>Ï·×¹39 ,­ß$V*®$5C²RòÄúÓó9ìïñƒeíÏ{­ gÎ[óýr¸f•‡¿uø¯Ò‚,+I=8„€HÿrNTR)ìœvH/sX?<¦íÝ®m9±²ÈÌ*r$™U0×|?.)<+™dB‘ZEj$#°Ê—l#…!’[ŒÒÄæMŠl×Y¨.°RÕt+c–uŸzd§%{“WöÇÜÞÜf˜Ž1¥ ©$Y™ÒK >Þs²³ê%BÓmUxlåI‚è ðÒ˼?Òœ_ŽÙÛ~›~¼‹ntèo¼Îò©gøÕóOrcÿCÞøw?¡Ñ©S[ë±Ú©3¥Tk ñÝ×ÐæÒÓSfEÎÔä´’½v K¨a¡Õ%MÒ›ïEFÕ £8Š(Å)Aµ^Á?üÞO¹zõ¿û÷¿ÎúZ0®„5ÒÙÜUQ‚0¢·¸„s‚Òä¹! fE‰s%A ‰ƒ(Š™ŒÇh­Èòp G´”äyN:+ˆ“„ýÁÝNþh‚‚ÕÕT‹ªÕ€<7é¥íö:ˆØÛëÏÙÂøl…¦ÖhóÊ«o N_~áÛç¿ö͹9„ð%%qÖRi´‰*U´ÒX³é„Y^ BtQR„q‚Žýßt˜ÅU1¢„Dëç<“P*M$”ÖyŽâ\ýëAÎàƒøÁöƒ ªÏê1þÃgŸ5ë£ ¡09µZ\9/­H´TDaˆ’¾oâ?8wð*fìïÞ£˜M)§†•…˜H*^~çyji@;˜Ê ÞºahÖjDJÐÏ¥%eiøËÿã¿'LêôÖÏ2ýu/_⸙ •ðÜ=g©P9.ˆçsþóÅ\œ€zèEö}OÏq}ûUu—Y^Ì9¾”¨¤D‚ñt„ÚͳIJ…($ƒÑ˜Bhίã»×0Z¡­dœ¦lîîr`s"!¹¾3dC:Ò1ck½¼,ufSÒÒ±\©2›NÙÉÆDaDYÕ:™1DaxÔZ1eÉt–²Øì€ôæ–oYV°µ™ÒlG$Õá$ýZ+ÊÔ0U‚±•,×ëôK‹µÃqJ£b”׃7³‚¯4ÛdL:ÃÍu¼‚±„e “YŠA"#Xhvý¦ÖZ‚Pñî{wxìÌ*¸{û6R& 'S*µˆF\gsó†ê×oÞ d4{]ºë½e5Û›„IÄùõÓ¸ÒÎÕÁ Æ£)&çr³Æ~Q2´%ÂW(y"IX¬ÆläÓñ€gÎ~Óg7`Â>ëytÌ)wBâ„üÂùòQÙ× Çâ~y܇Š0œ£(½-¤§"Í :óÏ;ëU»>ǪúSã/b”H&…cfýFÙƒBª¸Æ¥ÅYéÐB)ŽrÇ2úà ¯æ>(- ÆzÓ-üõrΡ¥@Š’È8þògßc$N2ꗔŔ<ëS˜‚²0ìN§ž²¥7ö:<ùw8¹r‘ÎÂ%í'™%g±b…Þâ3œl-ƒRóÍ4àEc xöâ%.¯žBVÎè”neL2½ÍS]8U™"Ëk¼öN›[VŸ<ʼnõ„­˜³çWXéµyó§1Ì8sa™v­A¨C}f&§?2ŒNS¥˜MFÔjuÏºÈ [Í=œµX»ý]ò¼àå½Eÿ`Ì?ù¯þ!R¨JAŒ- ¦iJ§Û¥ßR«7G6›‘Šleœ\ŠqÖQš’étJ½Þ$ÏS°^?¢Ó[ ŸMÑÂXËxZÐn÷ØßÝ¥(%µz{û[ôÚ]ÏHÏ B è%“tJj”„iš†5âZ¼°,-/ðgßýúþDú¤NµR¾A/¤"š»Ô˜¤JY–>èú'„ð è¼Ìù #kó]g0ßeEÉç (JÏû(ö¡eè‡eÇ ¾zíË_MóSã¸åbkÅ¢´&Ïf^d~Í‚98éÐÒÎK\y–’§c°Š 5a£}tÌ™nr²»é¡*´j ZÒ«¸ DN]~‘^úSÎ~õרÔêÌÒ &7ÄIH{¶tÑ­,7 RAĺõy·Á›ÕzÁëFÜÚ}‰^4Ïä³ûZÝeaºù1kk=ÆÃõzþhÀb·ç•¦ÌŒímF#Ãêª`2±˜Âà‚œÙÌ1 ¨Æ°¾r‚4KIwv)ë- c¹~ó*¿ò̳\½y“ýíï߸ɩÓ+¸ÒÒ¨{A—ÁÁ”¨ðLÔâí[wÇ ¯íß­HjUž»°† <_\Í%¯Ž+„}nÆŠÃ:r¾ýòEÆášá•ñæ÷k.%êùÂþ}‡-¬#Õ + Ý9*Úßу8~bþ;Ї뗔á°Æk'´íLª± pþø&Fq±î¯ž6)œE”÷¥Eíü·r eæhTfdø•Ëß„R‘ØsLf¸0¤k&®ä¯óäÒ)´-Yè ´8—ÌïKUjí–¿^Qx?Á‘/V!µ#TeUcRÃ7¼Ø•Dµ(®íî°¤cþÁs'_\â÷_Ÿq*Ï8ì:K(Î?u’w_ÿ˜w_»ÂÚo/b­#Ÿf,,ôÍ&Äí›ãêùŒPh¬)Ž§ÔêuÒ"CkI:Ë©ÕkȘ0™¦lL¶yñò%nÞ½ËêÒ›ÛÛcpUG7xug‘4bPqL¢®Tä“1AçEB]̃ó/s¨O(×}æÛçùP¬hì`2¢èÓv¨Ççg‰ poÓíËÐIÂøŠ…t÷ÎÝ‘-ÏîÞ>}—û ‰sX…u,Ç çOž!Q5j‰b¼?¢ÕiS3þð~‰Õ&wnm$ž¶³³G¥Ò"„•õ5l6E(I³³L³Û%‘ JÑëöhWš(°XkQ©ViWêLò”XG˜É˜•@ÑÔÛÃ)Ei±RcLU‚Ÿ}ø_â¬}8 ýì9! L̓ ¯Þw¬¿ìœCiÅpìí#µÒ”ZƒC _¾¯<®ýï„df3¹“ã7,šÀ:ÉÁ$%sÁ§¨¡Ç‡t–8”Dª¤È2ìœ9qø>cÍ$ô¸ëÐJS8h¢@y Ò~M—øõɃºnǃòÃîS „0%˜0SQrzñ4Ÿ|œ¤{‰+×%¯^»B(B=åííuªÉ¯^/øhã€Sç‰Ë’÷ß½ÁÇܦV©Ð[lS«UR±7< ŠÂJÄÖîVxß{¿~zÇ9!¼oyQêµ*QðÚOÞçäú"««ksn³ò:ØJÌyѾUÞØ”$Ý3„ò¯—ÎaMIFŒÇÞ C©Âä †ê•xž¬Hò¬`’d”0š Ø?8@š…îΤ(­ `<<@ ÈmÎlèÁÔ¥PLÓ”J­F…|÷»?D¹ü·Ïõ×Aø¬À/»âÈñ7EÒ“äQÊ_Ú’Ò–ÆP˜cŠ¹qƒþ„Ãñ||WöE)O_Fùøw}Þ(‹ìKí9‚ß[Z룬YO÷ˆcoH!çǨ”¢( jµA¨(íýk•Ÿ@KAšNhƊ׮¿Å…Ê5Ì dËL³œ©q¬-gšìR¬ò=S!qµÎ•Wÿœ…Ó©¶zÇ®#Ñž}X‹éZ¥Žp†©ñAt‡ØçÝú´@@QŽXN ­¨Wë> / ìœÖª¤&úûÛ´» $IF³ÍÎÞQRÅ9C¨õv›N§G:a¹·ÈR§Ç¤@µµÂÁhD*ŠF«‹Ë§llX&阧×Ȧ3´üÙŸý%êÌå¿}á¹_÷’‘sïd“g>0?Ðç•BáÜýÞô¡[Èñë·<¢@=œœp–N>k< öËŽÏÛ>l|Y€°²ôÖ…á\¨Ýïô¹«T¤5Â9’Ø‹ãžaÀá)WÂQ©&¸ù?µDÍù½1µØ’Ú’V¶Ëâbn²3™’‹€µÞI¶†…Ñ$±Ç8ç¨4;Ü~ï5òtÂêÅgúxyž…- G3–äYFE>‹=¢ôÁ«yX!8¤„jn3 …-Ѭ”TtˆDa… ° g%ˆá'» œa°ó>…d“MjÎ2î!¬` C:M=ÂÛÝ×*ï·x¶ÛE”Žý<£Ym²µ¿ÅR5fs¯O#ª2’9KI…Ž¤©§6› Úa‹Ùè€ÉÁ6~t“sgÏ"ƒX+jq^£Ë`4`:Íȧ93UP«F¸X²;žÑmÔB°±±Å¹S§˜9“Ù­³YæÁ} ö§S‚ÀòÖÆ Ã=.÷ZÆ€-1Î2Í2”R,%1kÕ“¢ —åí8àü‰³ll]çô©§‘sc$æþø§Ü¹·Ëýí:ò IDATÙ³ë¼òÒ´›%ZV¹»¹IL»ÕàÄ™U¶77M Ï_$yQppp€ "ZÕ:?¿uÝþ.÷v©7+ÜëiUªŒqÎ{k"dz§$ÝÈ³YpéÜ9?ïeΟ÷ܹy¿6+ñ5×ã¯ËDþfKR#±xÓŠûU9|d…Ü@^ r3c ´<:9<Q}A­ø/:\gŽC!E–ÆÉÑÆúaeåÏ_J‰÷Ä9öÞ¹]¬œ5h%<º^(/p㘷#}Kê–VÚ¡Áb½C ÷«»G‡×ýß¼÷*kñ>¸9áæpÄÎÁ˜Õ¥:–À9Œ  ­X ƒ§ Ršg?Éwߟg{+D±â‰µ^¾ú.g[_»tçßÿÞkÜÛØc}uÁlÄzw‘A:õ–­J#ôGCÕ†oÅAè+¹ssš‹OóÊ+ïhÍB·NG˜²@I…’¢ÈJνÚ¢8@ëˆ"c²Æ)JW(E¨ãÉ€H+F£!¶Ì(MF‡˜|†´s¥±ÒaÊ’F«I]GŒû(%Ióß¿py‚(¦´ý½B¬žXçýßÿ¯üäçœ>Ù£ÛkóüŒ:}é…o_xî~ÏYJI‘¥„ÇD%oÆá"{Ÿ3¬È‹ü‘÷èÿy%¬‡•´6!üüñÉþYßÿe “ç_ŠÉa¦á§èÇ!H.˜gÊIJÑH ´ð%;Ö¬)˜M3t ©7•à£ëoÓªd\X\aksŸp±Åh‡^÷iép²‚Á¡Õ}ó‡|6åæ[?æü‹ßîߣÒ:¢@Q-0…_p­Mé|q¬uh%°±CÉÝÑ„nÐG‰Ï¦a Y™2›]etû*«QB4bs:¥ÕìR©TŽ„¤RäeÎþ`›q–á¬D”Ð/,VÌPRso|@TP1tœäl5f¹³L¢cN.¯Ò¨ÔiÇ!e™ñúOßàÜÅg8`„cZfŒ#v†}úéÅ…*µ˜jð£^ãüùyV°;K©â‘Àyiè´ZŒ§c‚¥…E¦EF\”ôuî3ª±åÔbUd^n®FRÝÇheÉÞ¬Àš•¤Â‰N›Í;÷¢¤ZoRiQpöôoþìc~ï¿þ „*غ³ËÛïo“Nïðëßø{t;5öö6¹ùñMVOŸõŠHÍ&Q\aÿ`€ ®mÜðå@¼w¸,©Æl d™Áe &Š$¨ÒèÔX~²K¡'ˆzÁã«Ï¿¸B˜ÄQJuT°„}8/,Š´0ó¶ÜèH)Ñâ1ðf<È@qÎy·®(zè:ú°syØkΖôê%,qÀ¼ýuX½ \­üu DéKý'Ùꉔ PÞ6îa”Öã »é,C{¼qÇr!ùˆv¼Ï`p…ýÁÛ¼qí Üé³Ôë‘YA 4BX kf\n-òÊÝÛüè£wQÙÇLrÍÂúóüìÚ\8Ó!Ž5›wö@ .’TžNFLû’ztH³Õ¢tÖûº‡[}IBQÒÉ”›c¸ÐQd»·‰]ƃï]¹ÇÉ•:ë+Þ|÷&ƒá˜K—Ïñƒ¼‚:ûô ß¾ðµoÝtkŠO”´…’óßzp—-1sMÒ‡M ÿö¨àÃ&ëñR˃ßù¨‰ùe–·?kü"€°CöCË:/OwhÔEÂOü ”TãÄSœCHGê<—~‡(Bå-Ô”k ëð&Pg ‹µ€ý+õ%fã1û³1{ƒ!Ë‹ h}–IaȳHó2»pè0áêO¿ÏÂÙ'¨5ZJ‡yF¤ÕH ­d–yÓ )¼nTn}ŸÜá°n^=ÐŽ¼*X dix;åæõߧ·üB#ÑZF¸C Á'¯™sü³?{‰µ·î݃^—~™¡E×ØÞÝ$ОWì¬%ÏR¦ã”†T‚´†V¥‡B#¥4“ñŒ<¨˜œÓKë´â:Ó<%–7n~ÄÖÆ.ÕJƒn§E^ÀÁø€ÁtHÒ¨1šŒüuF¹˜þå‡4ÚšN·‚r0ˆk_.Öb{oi?yŽÙhÊÈ„AD>ËHóœ?»]c­Þg=nSj8Ý^bg2"~¢(;ÇH@¤I>c©Þfss“íjõ&e i™!,¸s“@KR$·Ò)c¥˜…)é4¹ùWwi·Zä&'ꌦ3ê‹-j¦àôÂWqÎ’ÍÕ°¾È~6b¬7JyØg¾ÇlŠ’´G Ný¾‡¬Æ9l)ˆ-Æ÷KÏí§?P>>Ô¦ÿ¢•Y=54"(g^ æô*ç­| ƒ–%ÂÀ?ÿþwyíÚuÖ+ûlm¿IQlq«ƒk{‚ýRp¢‘ •§Õ–¥Å µæhc8+¼~u õJ›…æ)ë´X\}šƒb…ë›cz‘AÚ çëCîm|ÀÎøcÞºy Aƒå¤Ê4/ + kíO/Ÿ$h®q÷ÖLÆWøæ‹ÿ˜ýÖgzpñ…§X^YfãÖm¾÷ï_§·Ø¦Õm(ŸÑ I¡C5I‘T*,tˆtH«Ñ@jÉíÛ›ü‹þoyê©ótz ©û)Èò‚,Ëqâ(&Ïgáå¡) F„iÙ˜Ž©Ë8¬PšŒÌŒ•d…¡Ùl2N0ÎR¯Ö÷G”hZ“ÁR…DIÀÙzΤP\¹7!*ú¼ôÚUþê•9±Ú¡ÕL¸»ÙçöÝ=ž}úñ…ÍãS W–ÄáßLû‹¾nŠœð—’5…vU ÁÿöƒÏ{Û7¸¸°îé•Êkî‹Ò0‹ÿíþ¿|ý±³œ?û88a¹2bo0BðæÕ¿uù«Í% ®ô´!…Å Mn £ œÒdÆ1-|?·„8§YH,ë g¨UÏ°Ò{’ ùµh•õÖ%öGŠƒô w¶Þà¥wÞã‰SPZE ,­_äý‚^#æמ⧖ÏPF–½{|´qÀS.ŠO¤< êæ ¶((œúÔ „Ï“Pkψ´C9HÉ'„<6œƒP:ÂàË ÎŸ5vEž}np>¾Ž:üy¶jQJdi¸¼v’K «ˆ `b³Ü‘_Х᧴Š$€f«Î÷~rƒ¯=ý[|÷õM~÷…o t" Ö‚½ÔëSäV2)e úÀ ^1RH9o¨yœYêJ““TCÆ9©‰*U-XoW9Ý=ÉJûOŸy‚Ùx@P©16Ž¬”äHN.,Њcv‡o~x…ëÃÿù³¿ÎË·ïòÍo]bíÜ*3—óöß&‰«D±B(ïT¥•&š«y¥³©½³a ¦sùòcœ9ÑC`¨&oM*Æ„«%P!è!CBeF„Q„ÉgTê†yN‘¥`}¹^¯SÌRªµ:Û;¤*Ñ*à Ñn%T’*û#”²8F£¡¯LJMoeßùí¯3ܾG@ÉëïÜà ?æýÿÃ[ï}ø¨à|©}8™²"?"ï–›Ëç••öÞ3äÏ þ[ãa=çG)a/Ïö˜æÃ÷Á¡míÝî€$Iðع†’8½|i‹v‚f$©'‚z¬‰´ ÑmeéHª5„+‰eFÃn1™(áîî¯o VÖcwoLP©ÁÙ©¥¤0°–M†lü6§ŸÿJzOÔ0ð`³¼0„Òb‹œ(Žq”(¡ø_þê_ò­ßeyò!—/Lxûí×80·pÃ]ª6·_牕€›7ÞFÖ#Ö–¿Jf$Á¡Dâײ,KÒYÆ[×oa³×°#ÇJw\¶ÑÔë=â$¦Ùh²5ž²¸~i2䜊V%I\¡Z­EÒbŠ) Îf<Õ[D™’v¥Áh8¡RkzZË者nt:¥ÝlcÊ’ñdÄ«y›³;Ôê1'kR3.ž;LJÜá_½ÌÆþ&wÆc¾²p–¼0äYƇû[t㘵åU0©Ý^½Á>—Ï<ÎÆÖ&ÎlââÎZj¡%B놎ÉÆ3¶»„q€‘ŽÅJ“½<%’’•j…3ëg(ÆJÒlTXí.q0#ˆÉ ÇÎpBZB±¸¼ÄJe›Ó=F§0dhyæ«—û‘T«LŠwö7X^^âöµ=έ¯1MPåóŸbfR.^^B)ÁÆ,C+y$¸Òh6ÑF“„:QÆr÷2¥sG•ŸŸ‡­ Öúã¬|xPãh½¸¼”öÜ{á<ùÓðÄc¿]Zê5ý×´ÑøÅǃçbŠ‚ ¼oOúàûŽ÷Ø=õË»[©@ ¤ãÀÀ¤PbJp¨¹Ø‰¯:ÌJIf%š¬”XSra}c-ç×ÖÑZ¢ôJcBbÊû 9'äÉêhæð>¾àËèNJ+0η&œu­dP0s $dö¼ð€¾FEÓ©Æ<æ¥pÜ›¸vw‹ižÓíÆüŽÊÏÞø€“§ViÕ+óM‚#*Þ^)”ôú{{;üà/ßfm©E·Ûòžã³'¦,ȳH(ÓÉ ”ô*dÒPKR ±VQK¡ÚhÓ/R&Æ0It‚= 3Œ"Úí&[»Œ‹zƒÑd†–š@Zú»»s¶MÉõÛ;\¹r‡•vAÄ`<æîFŸÝÿ[_ãåW~öi@øà„ÑQp±ÖÎTù ùË|î—å=ÿMãÆŸxX>§„u褥pÄý%ŠB€çÍ$©Ç‘÷& Q¤¨$1R–X'ÞT†nCÑ® *"%Òš@X¢*êUA˜h&‘Xë„“k¬tzlíÐ79á⋘ÒPPõþÔ´J_bo,`ùñç’ªß<ä9ZKŠÜÓ„BZxðƒ ®üéOÌóËuN¯tؾ±Í(/XX^äÞp—v˜píömâ¨Â¨¾ÄÎf“Ëgž"²§ Ö«{͇žÛÉ-Tšt[_ã¥ÛŠ~ ‘£C¨´jŒöǔƲШ0™¤è`„þ>IçéA-&[»ÛLg#ÊRpr¥‹Ž)•`µ½@–¤.EIoü>™L0YN«Õ"Bjµ*F¦¤ã’V7ÂIáù¤yÉFºÅ­{;Xg¹9°‰aXæ GCrÐÓšííZÕÃlÌG_幧žä{/½Œð×Úüã'&eÆ,Ó’1£é)5Z#,y™Y™Ñ‹›¤ÅŒšV´¢*×~þ.û3Ã¥‹çØÙëSSõvÁSG K½F £iÁpo‹J«G§Q%7'O^$ËyQ›‚ýž¹ô$+µùÔpáâ)žº°ÆÞe2ÌX?w’Ëp0d uÀ@(Åx:`w¸Kj&˜Ù„?~cÊ×Nž$œS¿H5l.ï3a>{ ¹ÿšohE9Ø1´„Hö{þ¦ÆñD$ϲOÈš Þ?Wá8”#u®D H‹‚4S(„)ápJ{±§ùG¥>PÍe=…aY …fRzÿåi^„!¡ô Í¬ô¶˜‹‡’¼|4 ÷èÿ $åÀ'…§OfÆ!œ9j=¨¹ ®:Š*ócS¡¦Äª€Iš!‚„3 K<µvŽ‹èÏZ¤-ÍlgŸ7~ü7®mðÁû7ùó?ý ?üþë(%9wv(  ø§ÿì_óö»×yìT—N·E¤iJ¥ÖDGšzµŽ)2Ÿx„qRÃYËààSæT*]êõ„²(H³)“ܾ¢0BVêì¶É2ƒÉrÂ8"‰6vöI–lol±~b@–¸²$ )rÃ4Íùƒõ2ƒaÊÅKÓíµév{lïpíúÕ˜ûeíƒs9ßÉ é,õðó_"À~^F||< öE?ÿ7=©TæÏ;.k-QíâK[Tbâ0À/'P«UÐJŠJ¬‰#íe0]‰ŽJ!@:¢Xâh)SšÙ,ã'¿Ætz‹_¹Á{÷nqiõ’ZTr01=ø9Kµ%œ+¸=ñØúeJBJüNS]z1ïƒTšl2ô "µ&y!w¡B´e=ÈG8Á`’ó»_{¿úèÿãÖÇ×Q™¢vq•ï½¯ØßÙCtƒÿìùÿ‚^ù˜ ‹C^xp^¤¤($Æȹ—ò@Sçæ›xîôIž:û'Vž}Ž»[ÐnVtŒ #”ô†‡.BN8/H"!/r6†;Ø|̥Ų(h žv<#W7n3ÊÆ,·˜L¦ÜÞÛâÔ©h'ØÚÚ)12c°ŸyÚY% ŠC†ÅŒV½JYÞ~uƒ/­zÓö0Ä C•*Z:’¨Â½‚Ðñî ê!üɽ„çOI6F}ÖdÀÅ…ÂYЂ­Ý]NôVôLLêÏÇ:t(hÅ1嬠Wër}û€“ç×)ú}&ÓŒ0‚,s,/wɳ‚áÞ6…Uh)X^\æƒvøÑK׸}g›¥å‹Kuf³1íN—åÕ%â8¢Soq÷öo¾u‹¯>}š·®Wi¶›ÔZ6öîEUö†´’S-èà, ´¢Ì íf‡³K3ÚO†¾|ûÅžéyÙwN ûÂATø@†¾¼û¨ßPÒÍöþ¶Æñ²¶c ¤+Á–GþÍÎ9Š3GaQ€µæR Îá¤$‘–^â¯WyLúsê}VŒJ`p(ú5H*²¢dZ@nÆ”žÊf“ÜÞW|`MþÔùø#ž«Ù{R^ üÐÃaÈ?ù]þ¿‰Š<Ë ¢˜¬¤¬Pt5.Ÿ}œ¯}ã7ØÝú97®Ü¥Ö¨ð«_!¯½öW¯ÞaóÞ.ò§¯°¹µÀïþö³”(Æã)R‡Ô ²,GG¨C¦ÙŒZ­Êxìý¤ŠP*Àš Bi¶wwi† a ˜š’jµŽDàtÀÁlŠ¶%Zíím&®`”NiöšTdŒÍ3„°ä©7Ýøƒõ £ñŒÿä?ýM.ž?ËÍ&g±[áå×®píæ.»»ŸÎBÊ9Z»( òÝv™™)ûû{HW‘&Ç-HËÅõsÜÜÞb2²²²Læ  #3bšŽ©© ÕzƒYž1)¦$Í/ßåÜã ÈÀæÌDÑmµh-Ô©IØÍs\¨ÐîL3ÖµåÎÖƒã¶Ú”2æõ‘â÷ž¬ÒÓ–ZT²›e¬ÉˆÛ£ µj•(ª"$£Ùø²’vRåÔò*³¬àÀä<î,ýAŸ¢„j%bkc J§^! "jÕ*Æ–üÉŸü„^¯NX©ÒîöxëgW¹pªÁõë7XZX& küþ¿ü îmŽyñï\ Óª!ÒSN †¤YIúÿS÷f±’%çß/"Î~r½ûRU·ö®ê½©f³IQ¢FÖŒli463¶¯¿y¿Ù/|ñ‹Ÿ Ã/ž—ÈöµŒ Ù‰")qmv“½¯U]{Õ]ê.ys;{DøádÞ­«º›‹¤HTÝÌ?éð5ŽÓÔ¨E;Œµ1‘ù ÏùäûG?ÏŒ È ï|ê1'û¥ŽàRb¬Å•çÜßÞäʳ³œ¹ºÊ•«kÄí€_zö2R*66vxïý›ŒÆ)_ýÊÓ¬.ÍMð’8n¢ ¤yNàùµâZ3ž`,aÔ*ߧ¬4»»=WHòÏ©i{½°5£fDì¤F»û$:§ìjË‚«Â% "úƒ!ÁD…ê;¯|ÄSWÏò÷ûklÞþ˜ 5Ç0É™é°8ÛæÚÍuÞx󃺔êÒ/ý*UUÕ¹Q,yžPÙº$FL,a„åÝ~š¡þi øÔ8Oÿÿó4ÌÓA]æÒ9N­÷y$]×Å©+ÿ±×4ŽãÐŒ|¤Ïup¤$ô³±ÂW‚؇ȃ†ch{)-_’•š™¨~Véè{4¥CËõØê QR0²)ÊT|pë×i‰ ”ã°Öœa£?⣾˧.’”õ"f9<‘²xT•!Ù»w2KX¾ú"µÄ”… \¥ñg"߬,Ì"\ɹ…yà¹aMr‚`EE”Íç¸u'á©Ë—I5hëLö÷â5.êN&×õ«¦Uµ7¿ÏÄVß IDATÙ„dŧW‹|ò@(iÑLŒÕHiØÊyâçn˜Ê"?H# Àu˜CoÕJKž‹ºÖ]H]@èOØú¿£Ô`\›ápÍz\žÿ`çeÊùYM&÷üÉrXmºšàÇîíqç®# G´“"Ž<|ßǪÓìí}Œ =:ÝöÒí†Ï¯þÚ ¸ŽÇíÛëüÿýÉ“—NÑhÅ$I†ã*(+´ã±±µC;ŒØº¿ÁÂòÖh’¢À÷ü /¹D[˜™™™¨Ñ•X{ã}’Jãù.Šzq=l‘M™g¬µ[h,ífßõ‰Â! ùwØØÜã×óEbÇC»±/9söË©æ žo·X N3ÈÇôw÷p½# ZF0§f]ƒa¡=ËÖÖ6#¹¸v‘ÝmÖÖÎÑ |n\¿Ï›7ßã¥çŸ§keŸ,e¿·Ï©•EƃâF—™VÄ`€ÖCòTðú›·9s¶ÃÂüqRŒ{|ë;7¨´Ï[ïÜbgÏ0Û•Ä‘Kà…ôv÷i¶ét»lÆ ˆãRƒï°ĤYÊ03ÎF¤Ã”ÊQ¸lpjù×p…Auìu¤²šÂÈcùÉÏÛ„ו]óg[k ”¥Ƀëþ¼×—º”Ê?¼‰‘›n`7åds ¾£A(öǵÅÑŠ°Çæ£ïÓþ>ÙY§§°ÇÞe5)p&X‚Ïj'3¶V²Ë x(G³Ü9Ïo‘b—fÓèvY Ù¹¿Åöf¯ýú—°º"ÉrqH^Tˆ°É݇ ת–»ÂuÈó‚Ðój©Úé½ K²¿G^•„aŒµ•P’ÞpXË;£ñ,Oi·:uŠA€¬4§–Ñy‰ïùdã!¯¿}¿üÖëüÝß~ ‹dqn†ÁîC†{ìïï>Ÿ·Þzïé¼ÔI–RNˆE¦ ê”cwÚÙ'ió¦4GâÑp÷£q> l:X¦‹ûÏ{âÔ÷[‹o aá@‡åðóO;ja kAࣱõè´–ªÌi„13¡‹¯,Ø£Ô–Y×à9R¦h ý,åOðîõ6ù^ûK¾ûþ_Ñâ:q#¤e¾Õäê©3„DžËÌdקÐx®¤‰ ·CE§ÑÀ‘5m]¨ "_ÔÇZ4É¿~£©JàÐÉÊCI°FÕŠeè“‹ÖPYC/-ÙË >"ðA<ñøèñð›­wôÃúµ²™œ|f\Üè<ŽŠ¢ÀIeJ„’ ÒÖqp­ÄšÝ,eýáŽëaLE&$×ö2ÈKð*7Ä1‚¨ùªRžG8xžRŠd\É—×ÎQæ9y?åã·‰»!ò'?ááÃl¥é6»¢.{ûÇ»DýZ¦ð7Ö¶èš1ƒý1ÍFWKrGcl)Åä:eY‚2˸xá¡Ñr#ÖN¦HÇH\ÆeÉÚêî?dgsƒn§ÍÒò"¸ËæÖR ú;÷¹ÿE™bµbw‡ç_8‹¯ä$×–âz–ÄŽû|å…6WÖ†( zƒYaqÃ×wh¶;´Vè÷iwZ„ˆíý>§ÚMžs|–Å“.ÈÒœ¬Ê…f6ZæÍwB||ô´ŽÍ#¾+>síxä±V€Ð´èÆ‚À“Æáç¹¾L¯}T2V<27X”0¿_Z‰• ¬!t•†A.HJÁTáÓÚtÝ><\ëûJL"ç“sZ[c!ŒÁNØ°‚aaé5û‰f8ÖTÚb­!+5{©®õ°­%Ë ý´Í°õ€®5¬ëÓÛz‰­ÉÄê0½Ö‘Ÿ í©¨UÄòÊcß¼xñiN/ü:ï¯'´tNKU¨( (JîܾCa¥–ôz y!Ùîír3ësåô*ßÞ˜At¿ÂwïÈÆ}”T5©”¤ã7j“¥ýÞ€ñ8A[MìùœžïbóŒÊj/$ô"Fƒ>±â¸¸ºÒD~HQlí%üþü5®ëð_ü׿Íj«‹§+’Á‚ i”l²½;âÒÕ‹TÆÔªTkO¿\wòôÁaûÄ"Ë£wV{ïß&Äý‹Ò¬5”y†r]¤¬™š>OXêß9%1Æày΄6PÅŽøJÒ Ž‚@(º Zò'¯¾ÏGëìnÞ¢+?f©›cÓu®žžÁ­†J‘5t‘þ0È ¹Q KWþ¦c`º+ðœIÝ¥µxgÞà å‚ò ·¶GÈ­]Ldq=ËR +—¨Ó )ÓM{ÄP•U…øÌÆm·nÐòbò¼`koc4eZ°¿?âòSç-8žâÚÇ÷X=sßqÐ:#KK„p¸}w7ÞZçúuaÎÒÊaÔFJIgfßɸ·9âã ¢h0J¶PÊãÌ™eÊÒ0ÊÒ<§×ï“›”$ð<"×ãƒÑ6ëYŽ-áÞ(#- ¨ ³ 4Â&ÒânÄþèC¾|á)ô‰ðöã<¹ ž´ú›‹ä^ãkí¢Æøx¾ÿ)øAYÖ °ú³šr´,!ŽD-rSL"_R€©9ۧ矶£Ô›GiƒuMc{ãw‚þ†,·dUM SXÈ CšWä•Âšú¾„TJPhI^ ´­×‰“?)­E^‘”©¶d•¡Ô’$¯È%Ó“WøTµbÖAªëÈïQJbE-ͺ8{–ã€õÍw¹rf–×tõ}«m< ›ƒ©Í¹xú,f¼ÅÛë|yiÀ÷¯ ™íJ.µcŠbŒ®Àõ²,­•ÍPä:ÇH@ÙZ/Ið…e{o jÁ„>ò,£—¥äé˜È)sÃ_|óû¬?Øá?üOþ/áz›÷I‡L™2Î µ†2+ B@z¼úã·Pçž}ùëgžyùà!I)1U]Ïû(ø¤A:ùïÑA÷ysÑ´?¯vò^±Ö´€©°ÇÉ>9Ù¦»acÌ„X]"d]·‘§PÒÐ }"%³ —H”àTR1Ü`-ì3¿² àḤÑhR”3®GÛu¶BcÉŠ ¥,´»X£¨ŠŒ^Y 1Tº@šÝd„Óˆ9݉øþmÃÕsËøËŸ¼òt2 ‡Œ«%BŠªD"X Ñ®ƒT å( [;>‰-pµEHÃ@[„p¦Û¤2%R°’á~Æ™Õ%¢ØE½=žøo8wþktg‰my‘Þöw™kÏòÅ/^$7=*Q±8u# ³ÝK”åˆFè33ßÁš­½‰²S…ãøØ<çÃ$eÆXffñ•Ï¸H¹µq—•…UîoܦÓèp}ãç/¬Ñcî\¿Íh4ÆóN9…pàÿõ|pm›•å.¯þä.¿ôT‡ ŽXYžÁA1³°ŒëªIrÅ¥sg1Õ$éáWŸ~’{wï°´|†0ðÉŠŒÍléHÂ@ñp{7“>mZk+p—W./vñ4OHòí¸Åb”К}¯² Ô±gú¨¹d'›áØ­q0®-)¬ªáKŸsøEJ‘lEžçi;¶þXC’ k*øN)Jƒ–²¦ÛÔµ¤äãÖä“8™ƒ9gAÖRÓôÓ)=ŠJ“—æÀÕB ­±*ò x€±L78!B€±5ðÊÖrÂXA]Œ(±“ÏêCã,C 47d¥ÁhS[`¬Ä¢°¦®ê°JQ!hDmÚKÏòÚuVWn¾q‹Íž`¿½Êž h7*~rãyçk¬ïm9çㄽÌùfE¯?Âõ˜0~µ&ô¥×qØÞÛ¦@Sê‹A*ÁLØ ¥fq´“͉çyÄq“ý"eÜðêßå•ï½ÃìL›ÿôÿ»ŒÛìîn!UÌÆÃ].]>I‡8ŽÁz1RY~òÚû¨ÓO¾ø «5Êõë)?ª}ž<Åßdbü¼&ÓѼµR—„ÇÂíÛ˜m¾ïÈÖ¢ï–FäùÐÁ±Wç•ËdÈŸ¼ù§Ï0LF8ÕqQàIÃnnp]Î2æcŸn#¦5˜ ›è²$´’0 0iA¿ß#ŽšxŽàÊâ2ÕxÄÂÜ<í°ÅÝíu:ALgöÿìwÿŒøŧ€:/õdJ3]ï¬áxÜùÉ·iίÐ^9w¤ }„Ñ̵}F¶ä‡ïŸçÖ®ÈF:®Ã°˜(åüF÷qíQŸi ‘''ù®i® >¸»A«³M7î"Q4£Ýö,îPBx!¨É0råô“le;<·˜|f½€þ8A8>­ÐEhM‘ Þùñz-]·èTÛÃ!?¾¿ÊßyáùMw&bwý'\¹x£-ƒ|ŽäýqNf4Šom2»Ö%)ú\9u–þÞ>kKË$IŽ¶áÀÃý”‘c‰ü&·oß&Ž™[tã6ƒ<¡—ìÓì³S¦t¢9ÈXXZæÏ¿õ!{û%Ń=ª<çÙ§WyîÙËœ[ ¸ùñG8Q—0 q<ÁL§Ãæú}ò|ˆ£…óÊ+·Á&ø~H«Ûfff¡ààø>;6p|¬°”ÒE¶óäÂs? PŽäûßyÈ™µîß»G8xá,K+Kô%›[Û¼ùöXZê°´"ｶÎÒ‚b¡Óbéô «èR¬1îP8©°´\E'”4•Cr÷«‹ \ZXá­>Âoø\õ]Þ®†.p¾áQù!÷˪ìñ¿þßÿÿôïÿgy…U.±9>pĈGGã~^?M›¢,!øQü‰ï[×1e ±IQ¡Ãp ±oéF‚Rƒï®&1pE-É”`òcL­N(š­¬ñº&>ª›ÆXƒ¨¦óׂTÇ€]Ó ³­jn‰c ¶fðšøú74—šì[sX+rRm4ÖT˜‰wn9ÄBõÒ s¢ch £ËšQNxTX*!)±\ýÂ?à~ø-žá—Ï[òäCŠM¾}wÈ;U*¨Jcòk,EVÔ5¥ÐTF“ÆÌ.Ì2LúŒ­!-³AL…Ss{[3©í®u¢…ãŒ%~§É?þG¿Á0´,­Î3 éFxJa„ʼnçÂãʳOQ z˜dÀíÛ …®PkO¿ôõ‹_ø•ã£OPw~–'sò;Ÿ•~\ˆüç›>¹û;yoº*q'‚'_'=zïužRãùJÔ(ca+†½`YîƸBRˆŠ¼s/ÌnÞ½C§;Co¼AâJé¹e¾Ï ·CQXŠÊ5b´ÖŒ‡CÆUZÍ&E’R”q£®4{Û» öGlö·p¥C6ð<‡óÝ&·{‚nܘ„»£¬:([ÉKƒ6–Û ó”¥+/ü.%%ZòdD蹜ëòåóÏb¨÷¸ªÑµ‚ãÁ&a2YOA¤ÕH ZÔ%ꀽ÷0„9{ãmVÛM2-pœ˜Vç¥Ö–|¸ 냋­ ÁaŽ­YETU…ë¸dyÎÂâ{û»l%C")¨*‡·ïn°þúÅ0çÜü •q,ñ}¿FujMVV[›ñ|/Db(l¯¿F:èShÍ(Op]Y6²Œž©ÈÁÜc}˜c¥ê<±ïú~8Ù4ö«°–A‘A’qg¬8{i§( ü€F³…ŠýÞóçÎR}Lš°õp‡Qaiµš¼öãwQkOñë^ø•ƒpÔ8ÿ"´Ÿå}óvaœ§åü8éô\jÊ9,¾ïÓŒv¶7iÆMBG@ÛaëÚóthP8ŒDM§9ëûD®¢ãF“’÷ÇìîètæÁÑŒ“ŒeTe5“±Y†(+FIÆ(IÙÜÝ¥?‘êŒà;„AŒR’‚’L®Ð ëß•%½á˜¢ªû<«k7Øp“t›ÕgùØó¨ÊGÏÇE |”5™Bj'¨Ó#ц“ƒ IsJm•‚L ²B“•?TŒ“œÌ8 Ó å:8òðX_ÄôX+ɲ‚Ð;¤G­¤àéå5^8ÿ¯^{—™†:,Ë×u‘²æõÖ¥eœ ñݱŒÙËöîiÚK1ÁbÀb×'ö\¯&ä‘ŽBiKVÌ8!ï¶$MV¥„ë_x›¢Ö6¤)¶®U÷º³Ù§h YñÛ¨ÐaÿäYº(p ‘O>ñwï~óÀkp}#5[ë,Ï­¢Ë’È‹IË”3mEvøÑî‚çDp?\ê„]—Y^#4MEb3–ª›;›¼ºamÉBËãÆÝ{  Òs& †ƒ+ ª¼ÙØqùü oô·x¾Ý©ä%Gq·Ç/w—`\¶51…”t”`1¹²zŠþ`̽M~ôæÈÒãk_{G<›p™[œåÖµÛ„®"mE(·ÁSO?MÇ à©+Kt»]úýF‹¥ÅgxÿÝ·h·;5ÆZZÃÁ>ÃÞ}J£éYAø|¸~¦1QàùÍv›(î2NƸ3Šþ`@³g»-îÆ\Kú8¥!1ue@UŽÙØݤÆܽû!/ü3ÆÅ*—Ïšö¥U„@ cæð¹þ¢f%,‘/5˜ê¨Ço­Åc»Gý1àZƒÖ"­kŸ´×!BH4T§I`–há0Ý÷ÔéE\QI§Y•FLJ´´ÑÓ/3LRªV¬‚á£Ã{?¹îÕ;ê°Æ,ˆ8ò)&ùó#騣ir!Ä^]éM½A¨ ¬­©a=×ÃPéa]Jé’¦E­æ7Q$“}«œâ^üêÓ/û.¹t»°EŸµÈcGF|øñmºQÌÆúÍnL•¦øá,~àa$´”bcœDMŒÕ,ÎÏ<Ãé/T´’ììì`´æK¿z©–'ƒ<Áw\VZsÜ¿}d‘—šµóW(lÁâÜ ýÝmŠ¼8B-ó3l'ÃØGó½¿íä½c¨Êê‘ß=yÏGk³?›Š¢+¢ÀG˜ !]\×Åõ}þ£/=Ç'·÷{\YYãÅÕ³xÊ!rÒAŸáî>óK‹Hðñû°µ±Mo/åÁú9Qä‚Rl%#L{åZ‘™Á©v—'–N*ŸQ‹Ej%–I ‚š÷Øõ søÛý¸M1ôÍ´ÂÐÅ‘ ëø®bTÕ,aÓß~2Ô/•ð’täÓ69B¬”$Eul´žŒn¤iŽÇŸ‰S\™›=›L›²¢¬ÎŸfcçÚ’4EkÍÍÝ>7z}Lž£÷2œ¼"'Çâ`£á8Óä©ôg€ôâ ÇŽwŽKz£žSo>´Öt#sÍ Ò4ÁíXî¿7ÄäŠõQÅõ½=îŽrv†Cº¢Å‡é>+qLT¦è<£4i JS ¬âÎõ^ýö-<_²xÎ¥oûÜÙ{H¯pq”σ[7pe]vóÁ›sÿî.3³³Ü¹õ1Q°µ= Ï+º33lnÝa}ãív‹,Ë°Ö²¶vÏ…bØçÞGìn㈜ïç»,®œgue–K§Ïsiå ñ k3 ŒÓ”ñþ€(ŽÙXßÆ)-3^0qY[æÜò–æVè4gqؽÞÞyÿ_“(y„@ò³›¬4ÍPýÿV³‘#Yž IDAT9º@}nnu ]Uì<¸ó)§‘ÇæÉaŠðÈW¦ŸOÆ裦Te%¶,Yæ0þ¼RŠcßGNʦ¤¢Ð’¤0 ² ×­ç˜1†Lx¥ÅêòX?MÃÎB é“”Çg–X/c¬µ”ã}z®`'OØ*² ÇeœŒ‰Â˜N³ƒEPJM%N‘«;¡ qŽ ð–;½YLûÏüÃÿ˜…¥…ššµ, CA”’'Z ÑíR”ã$'¥¤yTêì3/}ýüó_=èd]ÖeTb²[íhúä{'ìŸÅÎøä5­µ2š''ÆÉPíIâÏóÀ:Í&¡/ñ\I§!±\Ça¦?|ç®4öØߣ—Sövw˜iÏbŒ&KR†ƒ>ã$cçaÄ,¯ž&n´;m‚n»ËVo‡Âsˆeyy‰•Î,3a“ÁpÌüü£Á˜*+±R0Ê7àþÐ0×îbŒ¦Ò†AªXŠjâé A>î³ùá9ýü×okk¶)r<7 ð‘3™ @j8"¦Q£J“Ìà(KYŒ¥–zDŸÄ%Ô_2”Fºâøjt¤UÂ!rL½?8oƽ½¯Üø€S³·Þ¤¿¿ËÃÁ³Ý”TdyÎ0ÛG©z1s¤aT8—݇´/¶1VвÏs)…S–T˜Zë¼,q°uHA(}J Í(<`…BÉݽJ[0DMÁ@ej‰W¿y EŒ’¬]Zc·?âràqõ²þžÍȪ’/ž¿J׋xý­Û|á…5dlPÊ!+ „/˜kµ@ƒ |l:¢*5³+s¬ž¹€ç+ wïl1°fH£=ËþöC<×%ð]Òá>;›ëè²DPðöÛ;d©ªâúÇ{<õÜy|§D Ú%nDŒÇcºóxžÇÖέv c*šQÈV‘¢„C8`\$£iD1{£-Q“È ØÜy—Ùŧñ¬¡ÒzÂ)ðÉv0.&Ï9pYYb¨©!¥ðólÈ MejÞl¥Ž¯Ež1³¸ÂG¯}—2KY{òùcÇKÀ—†–‚ˆr"+kÈ´©ûÿ–WÕ:×iQM"R€ŠRÔósšS®û´Žle•=@†–A)ËHë×Ôé˜"¥~Ä'¾?=¦>ßÔ;›Ý£ïO!jQŽck‘t™’¼´Dž•„¢* „£^ƒL]W`Ì䚀¡®ÎÌŸå¯ß&Ž3|Çå¯>±c}<•3EHj\ÌÝûwq]‡Ò¦Tä,uŸ!pyskˆó”j†;½Š;=IÕ»Ïl¡¸t)¬Ë8• ¬*t©‰—Ýý>3ÂfD:ܧ37r'@8]ñþ…:ÿì—¿~þùÃ\âTy =Ú¿­þyBׇé“üo»-0GrÎGûä(²û¨ažnn”R„a€«¾ ¾§èxWY-÷¾÷Ç(!˜mÆäªb¡aKƒëø(›±½¹A·Ý&OSTØàÌ™‹EêŒ{_g<ÎñØ$á;.¾ëQeÊ‚Ñšq^°¹³ÅÞ`Ÿ±) ð¨ (Çgc¿`µ½ ® (-½Q†”Š´¨&EUd¬¿ûCVž~¹&|Ÿ<“²,p¥Àq=B§B`-éQ¡ké§D[ƒïº”Sfþ#}|²onvu,rÄcƒ=ˆ[ƒW¨)+åðÍ÷Þáw¾ü›<Øøˆáxi Ì4 óó|xóΟ¾@¥ Ò,«õƒÓ”ÂæV)U~…,%R9dÂrsHßVHë"ÂãÃdȃ,e³ÈêM„r }÷î@!dŬ²ÒlÑQŠÙ8âÂÜ,I¶Áâ™E^ß^dQjæ»3ì–;(«hú>»»;<{î2?üÓ÷hZÅžUl=|H{”ªÂu%JÕ—SsK´Ú]ÊlDw—ý>{½ÝÙeâÈ%ËÞùà—Îu1Ö27¿HÔì°¹¾…E ¤áÖÛlmî’÷ï>D[¢,HRË°?¢flÜÞ%mpýýwqEÎpoHwv†<ӌҡ&ÕUÁ©°ÃV2¢,+,–Ùî vîáâQd%‘çâ….ý½÷HÌA»ûÉ¢‰Ç6_ÕL|¥9äwþEiõH´P8Žó‰5Ìõ|Òd̸ßãú¯pá¹—ð£ø`Nh 2„ó½röÜJA3*òØ£Œ›ïW@1Iý-š§”¢B¢\—ªš–5M=ju,-4}ÏZ¨Ukœ¼‡£e§B°5•j’W•!+‹¿á8IÉùï¸.y:>âÖ×”Ç^b¢rUš W¹Q£ÈµP$YŽï9XcÈóò©Ê ªÊà;púô?¾SòÜêˬ,,óäòEî ¶™,CV•ôËœž®(P˜"çÔ©§é„Š ³sœé´Yh\\Xàòü,ôÏÿ9¾û6Ï~åY„­Óxyž’ZMS9()¤£›‘gT¦fãì ûtÚ¾ñßAæå¯?ù¥_§¬ªC#ä7BŸg'úÓÔD-Éùä`ú$qÉÑö¸BýŸ¶”GðãÎ_9~~b³r8q¬¸ß‚#k gW)šÍ8r¦ÂC³ØñPXÜä]~óê7w¶È1¸E-ˆ±<;ÏÍ›wQ^Œ+»»Nê°ñ`‹Ýí ‹-6î®c¤ Bš­6ûûû„Ï|³K?±Ô!KF \âFL«ÝDÍ©ùEúƒ¸âÁÜÌ,”¶ƒY©yi&€Õ÷Þøk.¿€ßìÖ}&J(ŒNqϱ´¨lMï—VGh=¥$ÉM­ïj£a2!(<}øää?’"Lèí±øѱ)xžÄµ†÷×÷øÝoÿŸüŇXŠBþÅ~ÂÇ»ƛ癋¡ÛÆ C§ÙB¢V1יæ3äJëÈ%çž8K¦]°?Ìq\Ö‚QUÑË5[i‚”Žtð¤Ka ûã`š«q •6H¥¨ª]»,í d³ñ•sÿæ]A[ïã…Š¢ÌÙ.3æBŸ¥Î<ëwö™;åñÞ››\ûh›ùù&Ý™‰I&”äÓ czƒ!³ÍÂwiÅmT8ƒ¸”ùo~ó}ž{ê4+«óıÇxœQ–2Šð¬Ë¸QVŠÎlÌÚÙs¬œ9EåHš-Ÿ$éqöÌA(ö)ò€þ~Bo§O>QÚŠÒ–V—èï÷pý~añ\I7¹¿Û£ÝmÓíÓlté6fp jdC6{÷¡Úà›?ºÉÓW¯ÒЭŽÔ=¦ !q” ¨u 0ül7òŸÞ>»"¥, Î=õ7Þx…Ûï½Á¥_úÊAäÀ ‹, O¯B ©a˜ôdì?J|ÇZK6¢œÜ[ËÑ ªªîJc&eS€¡\Æ•%ð¡ï2N3¬©5Q¤« ¡µµ R’W5M§‘èÊRTõßþcÁt],‚,+)´(fÕ()Æ@YèÉysp£+ÔDÏ`z>„@ᛨÅm kÁA½VÔÑ$Cà×Hï“}%&÷•O:\]ZÆ:G12pIʃýkœž_ÄssU:¦——¬.¬psãc¶{wyÿÞç—O3%^ý³?ün}|úÏþ;®ïf,´4º,q|£5”FÐ ]|£ØÞÝciiG)²2Ãõ<~øý×Qçžy¹–ŒœŒ›£žóÉôiíqÆùQÆî§ñÆÞþ<÷ôyš=á¹=ʃJ©uü£ò/XK†øƒ†ÈwÐYJ!†Ü¹÷–Øà™Å5>X¿Ïb§Ë©ØglK¨JÖ76iv:Ìu[¤£Unظßc4L1Ö’ ¬ç·;x¾Ïö`‡°2מÁÃ!ôŠ¢@—…†­Ý‡Ìv»ÄNÄý÷雂РY]~%ÖXR«(ª:ä\hƒ’SOrïïpúù¯6»HY{ÀVÁÜlÌù³§éímRäš( ð}M«éÓˆ}Ú³m{Ûtº+Ä®Oì·ØØÙ G¼7ØgkŒ#ñm)ÊOA€‘†­ Š4giö4sŒ×>~“pæ<‘¨¹Ü?—7,,¾+Ý:”Œø¤áúElEžã‡+¯ðî÷¾Á½Þåü3/â¸.B‚A’”‚´‚¬š¤n£? «’ïþÑïòã¿øcžøâ¯ÖÊÖ¨Øɦ–zÎHÇa˜æXéà{µô©’*K§ŽëT6ŸIZâ8îb¦:œ—š¢4ä…¡(+ŠRSVuÜ8Š#Ú RNÐÞv‚궄¾G‘gÇJX§Ç=êÿŽǼïéçe%ˆ¼I™Õ‰¾š{D9¦ÆÐX‹,,Í æ»×n ²M²qAFÄQÌÖ`@«Û ë”œi5Ùäa1Ïl#äÎÍüá¿úßùÍßù÷yȥ•%vÒ˜>­Øà»ìbhs£ƒý33óôîî`•b±Õä›ßü^Í­}ùů€ªIÎù?à3Ú£<Êiû¬Üõ§¡?í~ãü(4øÑû;êAŸôÔ§;8×; ÷Ÿ4æjñŸžË?èC‹SUô¶7q£&ªÞ{|çÇ8yÈBÃg±ÙÅ!K3m‘ÛŠ…NS¦éˆ$M)ª’¸5›HW13·@t»MööT”Ì6»è¢@9>Ò‡|0Âqæçºu˜»Ò4Z ú£1.ÍÆ9 ¶.³¨`8.p\‡Òy¦RqáËÿ~£}Ð/JHŠ²D M»Ð ê|kMT‰U8rB ë’ŠºìÁX\×ÇuÖÖ ;gª•xì±úèà ÌDÚÔûpWBìRY!M¯2¶ö”°ì&9Ëæc¢,"0 ÷ú‹ü·ÿÎoñÂŧ渹ïóö¦ËÚâWÉ«khí°ym‹K/®!u,ºc­EI…Š~o@£Ñ¤ÒÕ:¤”TU…reY"•ñ ãz!¹¸z « :©0C‘@)Œ6x¸¬dŽ)†ÏÃû[D—½4£÷á¿úkO3z¸Ï^Ùçüù34\4ÕôÆ{ø7‰rY–´H‰¢ˆ‹kO°¹µËÂêç7â 1LÀÜ>CŠÒ¡´'Ðá™sÛ"éTª*Ï8 Ï(¥ Q0Ëð°9ûi%I4õÅ+‰T‚'/Ý YyžãòÁÉ=6—7¹²Ò¡8ì!¼gµ³Œt1ïîreó¥ÉùÆŸý‡ûû\òIš­Kµ6på!Bh BÇC¢²`yu•;»t–<¹y™aÿ„¯|õ;SáüéSál/Χ‡†gu¢Waê"ëø£X××r¾Pk:÷[çáõY)EgË3ˆÂãîÕ{_YSSëÙ¹’( X^íÒiÇìïä\Ûz‘Ÿî&¯¾ÿ>Ÿ¼²Æ{wîP¯×qiŽó†v³CÁ`ÿ½Ë«+Dµ©BÍ&K5´6¸<ãÞwØÚºÄR³‹r–ãƒlYPš8W¦’¤‰GÐïõiÔ›L#\£ÆqÖ$R’É$à Í8-±ÎÏÃSá©Å6gQº‚n+!ž†OXgQ _ù}+eZ$Ö1È*vø8/‘A„Ò¤©ñB2J ¢àlœ90O¼à|µGøÝoþ÷¼°öó®‚Ñ*%Èc<\o­°¼üsüþÝ—1ã~å/ÿ]p)Åj»Íõ ^¼v•îr‹íú³|åö!âøëO®TD‘9\vÖµEõfÑxtáF†!)-*XB)Àx:µ&¤Áp2¡VK8öpÆðÞpȉ)¨yI«»Î{÷-k«Ž£Ý1û¯¬'Œúô‹ å6ëÝ~üÎ;ŒÓ©%O\¹N»ÑbÐðü•›Œ&Ö–×yùÍW9ž xñæ G»LFÇå„»÷÷¹²Ùemc“Ñx„WE™“Ôc¬“”ÆÓj­âðˆ0guyƒ²œ •$ŠcÚ—®\aT:¢ö2>nËÑýséò%¨0fd'˜"ÇkÉ÷w÷8(= ]Õ÷ÕR“$5J[`&)¥w6EE³Ódg÷>n‡ë‰åÍý7VW>öº„¡J4k]å£üÿa+òŒpŠÌ5»«Üxñ³¤ã!7>Q%þ™ ªPFy.“š¢òUïë|ã_üc^ÿú³vå¿üþ=¶o>‡ð’¢°HžÙ³Îðx¨ÜFÎUé0KkAi²ÂÅ Ré‡ö7 Jzn^ô÷q¯ÅcŸiö ‡4õ‡„êyƒÎy)KÂÅútïDêl‘•GÍ¡P2å_O¿—‚À|í­wÃŒÉ`H :­&+la)‹œkË¿ûú/=yO~ê%ÞþÑ›üÙþB®=q“f=¦Ù¸Ìp²W…FE¯ÌØÙÛge¥ÃJ»‹--û‡Ç|åkß™ÖsþÌOiõI¶q¾]¤…xïاÅ45çdñ˜}TrÙùß›Ýßâ&|¾~µRê ÜÑäZœèIR«,A%´ªªêÀ[BᨷvÇŽ¯¿úuRç)Š¬ÒPd ±iFš‘úƒ>ÆÔš-¤’lm]¥Þn!̈£Ãô±:$ˆÆù€ÒÂúúUŽ©7[Å„ÞÑ R‡ˆ@3™ŒBrw¨Õfo¢ÙZZ&‰CÆE•”!0nªÁ^ 1ŸQdLA=D²J }¹MŠ*á½wHþôÕ¯óþ?<µùh…“Ö Š¢¤4Uâþ¢´€3U½è3 ÐkQÁÛÒbÂäÁëüozŸÏ=÷R ¼«¾ôRh‡>±ùi.]þ"MU"‚€‡T'Ú)¤H-ynû ~æSŸç[ïLˆÃ!/+BŒR\gm•ém÷`§R¯gÉœ@MC)fó¨Κëµ&…1\ߺLïpÀȤHR¤)ýtŒtŽÛ“!Fh´Q§Ùu<ûÌG£Øܳv³‹Z‰š‚­•%”€¥z‹•F&t–:Ä:ã9œÐï Yª7ñB°¶ºÌ“7¯39:&àý·ß!©/ñíï=à…ç–‰ë!YjXZß Óiw7¡Þ¬a…ÇK½Ñæ¤w‚pž4!”"‰cv÷ E$qˆõ/b‡{> ¬%”¢¤^OŒD׆ý>a#!ÏsÖ–× uÄñà€ÑQŸ ]Ã:C+épÐÛGjAاo†lÔ,­|‚È‚ÿ¡SV¨Š¯ ‡µ¶‚å~BËyña-åóóG¸AÐ;o&`?Êý=Î7>Ÿ¬ÀéçûeQ¸/N,=Õ2Åtc—JN©ýŽÃÝ=Š² ±Ô%`{ý:ÆJ#¦9:¨`®Yõ­G-:¨8 a Ð’ªþ°u 3‡PÞ  ÞÝ¿Å[ï}›§Ÿúe% ÃÒØ)Üu Ù)11 N…]õDñrDáÈå3|ûöoóÅ繺W9 +ñ+7ÝX– ª05ݘÅtíÎT*‰ÀYϳëWxbëþço¾ÏsK•_ J)†ã!©™`L‰U˜ÆöÊ%z£“꺢‚ÏLaѦ`­VÃXÃFg…ï(°‰$C)Áp<ÀãÙ/M¥ñ…/ñù_ýxò¥_ Ù]yè\DIÂSšSX•‚J@;ÞT3åü¢ˆï~ZöÃóü^.ÊgîõÜ÷ež¡£cJÊj<i}W‰s‚0œVÅ:òI$r•]<¶ÊÆ6ã*H9%¢J¢0"Ÿ¡mã¸ÏíÝ#T;d£½Ä¨?@Š€úÝÃñ•Û#~õ—~™îr—¯üñqãæS¬®¯sçdH+œTî0)ˆâ|2 t’IQðO߀·ONøÞw^­,çY(•s¾}\{œÐoÞÖžyÿQ­áó×ù°ó>Šå|Ñu/:ÿüDóÞW•c>„ÕÄ®’RøyM ífƒZ{™îJ—D:ÖÛŠ¥ê‰g­ñÎí{4ef´:Kc-\¾z•"Ïh·šŒ‡=²ñwîöènlÛÊ–|á…k<ÝLѾàÍ#ÉZÇÓYj‘D'‡Gĵ:Ž't—: CãˆâˆvÍÑhl’a)SKj+‚F^ºùÂ|”ï_ðõZ‚C–ŽÜxPôNäDD‘äjÔåg.««¸ ^m‹ŒëJ±sxê´%iVžúŽ¤f) ùòÍOS¨hîó¯Æbéª‚å ¾®#Rà/=_xêiÄǽûÔ„™‡EqÄp2 ÓêÒë TÀj{•a:8Cb3¥á™µ5´t•à k|ó^Éç>ó7øÆ­ûÈÁ-JáÍAšN‹xB/H½åóO;ŒïÐiiÒ<Åû*–SÍíɵ( t0E•–"/Xj/¡b…Ö1J º­6ýÁ¤£‚„£Ãkkˤh–»„FIÃý{\¾|á<ÇGwØß»O­£d¢,3’V“̤¬,µY]]cwï塳¼Æ0óìٜ͵mÒᯎ'4Zkq“];Æd–ë7nRLÆô³#”ðèÒhA™–„I•§ØZ;}µÖRKjluCþé×ÿ˜Ï<õ a…Ÿm‹éëÊR ÷3¡ó¯W8+uZÐåQó¯,/œ£¤>ÌBº›—¸þÂKlß|ŽÎÚ&j”ø¨&½Ciæ9ºÏ ª*ÞXUÉuÎ)æeµÖL²õ—å¬}˜P|T+Ëœ ¬aÆÄñ£ùPBˆŠcP–DQpª47µœ?Â8kIÈSeÚ2<‘¨ÈR%ûÅë-Ëa€È ¤5Rul^ÐHúÜ>¸ÍË߃ña¿þïþ{„aȽ~ŸF0*%éøø˜½Aƒ"ŒÉ3ËÏ.G¼õ½ïWqÎ×?5ΦDéà‘Áÿµ‹xö¹›ú±g)1gðñãbçáåG]ñü‹&Úⱋ¤ó÷üašÞ,#”öÍyŸº\Ð,«g+ÑZ!…®Â¬' ‚@'!¡(YkzÙï~ðûôúïpMöøä•÷YZî—«ëäiÆpØ'Žjôîsg`I{,¯ÔI÷vq:äæÓ79Ù»CÓZjóöqÉå¦ÇæŠ2ͨÕ[]ùþ‡&e½³Ä°?fd-¤†âð:XGV„¦Ày_ÂfÁþâ¬ÿu>N8”t(‘Äj UAõ)Aœ ]%'Q!©Ð„Æù*T"5yaðB"”ï©Wbj);µc‡VW4 IDAT yéI +hºÔñ|_˜•”NP'“ 2Ï\•\¡,K‚P!…CâÀûibþéóz1 q’´“&Om|‚ßûîlwÇ(,BL&#ªÁÚÊ:“,å`°å<í‰Q”…áJ·‰™Ö³=9îóó×W`üjt¬L+—– &ˆ°"½Xï¹¼¾Í~È«·™m›€åPÐ^hMè?óìuözdé R& {ûôvw)ó’ngg*e§Q«cŒ!bšÍ&^8²ÒT}–¬´„aÈåõK$õ€Ò: g9ŽY #z“’Ô )¶!2kBV¥i%`BaAqõŽ(P¤E¹°§Ð5ge–%°îãGµ™¢˜³µ½¨ª[iÅ”Ø÷(ãpšYLžº"iÆ CVêïõbŽé,¯0N°Â²s¸OiŽ†îõŽè®®"…ä 7diù:ÊkFi• Y%s€³ Ëyè_kE‘§$q„°•Å«„ÄxÒceˆFiNQ2ç50»¦”¤Y•ªnršÅ#Þ”EAYäØ¢Ä[AZZ„¢Úh.ÐÚžz"¦!Ó{W”h ™81MâpÎ77 9’O?õ4?Üy“8Ô8W²·ÄæÖ6:‚“áɵ¨Î1)>ˈÃYšs£™06%Òzd(Ù99fg¯¡C‡ ë+¨®ÞX¢ŸOÓ¨:¤}s¹¥ü}–Ö×ùãÛëÈrÀ•&Ãz£Á;ï½KjJîî’–µ ¤Þh2èt–ØÙÝg£»Ìàh'"šKÈ÷òÖ»·IâÛ[M¾õò—7BöïÝ¢ÝêòàÝ7¹ôôóôîÞo8ØÛ§Û®s°Œ 4Â{¢YxPJ²¾Ò%T•ß|dR:µéÉ„û‡ˆ"çvY"èõ†Ô£­Ps¹Ó¢*¶k5B [aéˆv="re\Œòqnå A IG‡|çý^|âEfUŠ~Á ýtì(᪂/Æ ð†HKÆãtí¡MÖÎûœ/jÎù çûÇmRzòÜŸ©p~ $”þl«Y;‹rI„òXóñQÑÒlYœÆ9S!RQÊs- vw®oÎßÇì”ÔhTÁIjµ#‰#´4‚­åwöh¸Œ½Þ!Î:Ö×VÇ<8 Þîð\§C=ѬuÚ|úæSÔEÈæÒ ·oÝBÇB8ºaX¥A•žÞ±44<Óê²;c¬a³y…N[ñòw¹´þ4uë‘Ú.”&üˆÂZˆêQÍõ$ª|Ý…u)梚tþ»ÓBÆ•ð«j#¡«š8wJõøÛýÉ„ßy´Ï;OiíæÖ^DXßA8- ÇGG´ê-Š‰áÆöuv'=„ˆ”d÷¨GYf,×ks‹ç|)%·ó”À«Š ´àƉ‚€I:扥NLŽÅòÏ^»Ž¯{žêvŽ÷’«Í„HkÕC–åö+­.G½^„ŒzG¬mlU1cÙXZæîÉõ$¡µèõÙÞ\æ_üáÛ`&Ô"L«þh‹À°uåA¤‰BÍÑÞI{‰þ`Ìh8dØ;Æä)N—þh„ð‚{G{¼xó9Þ¸õŸº~Á¤O+<¹|‰­î ‘“ä‡G€¢Õj3S_³skJîäÏwÚ4—ÈrvŽ{H™Ðît¹—K¶“’Ãþ7øÚûwð&bµµŒU¢Ÿö´¬æsïL•1ý#¦õ€ö¶r÷_¸²*"3µØe‘}!ì§i³pÐù{™QgÖœ⌞ñNE ½ÐðRk~z=7ˆœ£<‡X !0Æ…„Ÿ+µÝŸ5–HWc'D#žæ´´ìÂïU/¨…Ìÿ°æ¤'©Åìôwqù ƒ2ã`R%)jÅm¤õ|çO¾Ë[?x—ðÒuv²Ïn^øä xg¹tó9þø[¬5%ÝÕ%V7Ö8š¤ô†#~øý7ªÂ7_ªê9?*;؇uä£ÈT³ïgÂùQ¬êÅЫÅÎ}ÜûG}vþÞïåüÿÏw^Ã„Ó Ó”ÅCÂyñ£ DMŸ­Òî,QT%´Ä£ÑN-f)´<ìÒmXšÒstxB½VãÇ;÷ ›!›kìõ¸´µpž¨V'ˆ5ÝîµzD…ã>AÒ ˆêäyA«³DÄR“¨˜N³I”" ƒŽßØkÐ%VZ-F:ñžû}ÕµëHaæša€’…­Ré‡ùNûÏ*I9Ï,K‡Þ+ŒÍp6À8[%Ч"õ(éɤ0‡C‡š4-™…$9çp¦ÄC™e”EA^‚Ð1a­‰AØdie‰8¬Q¯EÔ(VàXßYéÑ*˜+k¢2ÛI „ºŠ‰eš%„@(‰×Ö7¹}üÚ+„§*ØÔé´Ûô͸bšK‹Bp©Ù丘°ÕlQSÅ?KðÖ¡U•š«aÂ~^‘j¼÷U¥ÈŠ a<¦@ ^à øwnj†vŒR!ëR³i\å„«,‹ ¦]o ,Œ‡Cj:ãaF½Ñ¦ rãÐJ°5§Ýn­k¨ æÙ§¶ùæwî°Ô”´š GGGÔk ¢(æέX^Û&*¥bÒ;¤Ýé¢j1£IN=é0ìíÑ]ZÅ{ÁîáÇÙ Ï_{ŠQžÒŽ"jqMH¬êIL–ö998 ‘´èÔº±æàè¥4R…luš¼¼{Äf xíþ1ÑRÀJs‹·ú Z“·iu[<ØÝg©^ú]>8~‹?úá=®_½L,Îó>Z›­ëP b­¨…‚ÂØ9/Á¹é>æÁP…#r:ZÈ*Ê ¡–D"Ò‚$H<ÆÎB*§Ö×Bv¼#„ý´MJIo\âµf’¹ù²^Ü¿÷a!ªZÐÌöÃG £‹%cÝ™5÷q„óâ½Ìöá²ÈQÓÊn‹†–óÕ<ž#N ßÏdŒóUè£äÔ@BRAÚ3‚}qÜqŽÑhH‘çäYFžg”eQý- Š"§, ²2ÇŒ2NN>`¹)Øh7YŽêŒ½§Ñn' ¥ˆ{÷|ùËŸf«}Z¤äÆ×ÈuÀ_ý·?ÇK?÷KË]Fã!Z+t󭯿\ùœŸøT%œMQð;ÿÃßgûéOòþ÷ÿœWÿøŸÓZ^çÞ[¯rçGßcó‰ççx¾Cß?ªã5`åüŸ¤:/¸×Ùw3âÚy¢×lË<%ŒÇê §ÚÝlDq„£QŠ*ÃXDZHO¿ÌÈÇ{¨l̵ìˆ×›lGMH c[b³Ÿç` l™Ñ?§–ÜH„Ö´j1Q(pN±¾¾ŠpŽ^ï!ÃAÆÆF…f8ž„cº«k¡ñ8*°Ü:°\]ßD Í(‡É$#Hâi‡]‹HA(ò¼*”á-$‘ç)e8ñĉÂ:`V[U¤Æ"µÂX(ËŠ–2ÛfqöÖZJãÈòçqRGé¥4q ½GIC<…µfþL‹ íQ9‡5OJ[ÅkŸ'…Ìq¯=é„Ç(á§þ+Ïý“b?á™z‹¥:zœä)/mm“æ)EQB ¶66¹o§‚0½@y°Ò3)íœÝ ÕÓù7%ç\ë.Ô4ãáëJzª¤L-*/0Ö’ç%Kõ&¨†Šv«…²‚ ‰8ºqaè4kU¾e¥Ø¿ëaÐî´#Í›o¼KQ&iÅmœ¯˜â:Ô´ºËXS’fYUËZKÒŒ"Â0BkM%¼{x¶.Ù?‚±$J’9Ëd<æ«_»Å¯üú ŸÆ^ ȘQ@½V¢§Ïf)]PÓ‚¯þùËèEmåýW¾Êåg_àùÏÿUº›WèìÐ\^ûÐØçóVêyRÖùN¯:øTs9o½þ${‘¥ü¨û8ýݳÕWª  ÎãÉ`ŸCAÂã½ÅäÞ{êI¼1èZ ëÁ{‹s‚qáx~ý"¸É?ûïñ¹§OXé®ÐRc=;‡x Jžk/3v 5±ŒËŒÜ•ï§c¿PCÖÚÊbvÎ0ÉJðÆÔ’Yê@‰÷¦"ª”%µä´Nò¨€\j±" ÞV%òÌ¡«…½Ó»j¡ÈyŽnðHRã(œ Wþ¹E¯Û¯¼ð ßë[ #@²søÄunÔ–Çý‚Q3&œ8Ʀ$VO!ÍÂsxï(Ž¥ ؈5wF#V©aE. –LÔ¨3"—:oJ–Ú¿÷J/¿Ðäð8#V{倫[—I‹Ê?Ü;âòÚ'»4;«Ü½s‡¤Ýb<±y‰ßý½—Q:"ˆ4ׯ®†}Â¥v÷x°;`ck“ô䀵•:ãqILNM$”¾ Œ9¸w8 9. W7)æ 8¤9#ç‘ÔN³CÏóݾΗ>ÿYn¿õd…Ï<ó»ÇG(ýþ1ƒ´À£H‹˜“á6nƒóä&EbÈäº@ùˆ¯¼¹Å¿ÿ‹JkFãLa°QŽÓàKKÔgµµÊáÞ=ò`e¾6Úæ5¨¡˜BÓo¦sBJþÇùûü—¿ôej2˜ïcSv¸ó OUu‰ñ …!µ‚~™á}ë!¤Ê{¸*&{nÄÎ’' üúæ#›³`]U8æ"7ã %tÎQX‡w§¹É/Šœ9ß¼¼£Y˜dfš äaƒ«Z‡SNpaŸÍ~³VoRä)qR'›Œ¦®"Ùí+Té\rº¢½ÇžNkéÌszï(tXtWxïéÖ«:á…·ç«ì…=ç,ƒ õø2am—°´D.IGHŽÝ€½7ßà†Güêüת<úÂà 0vÄÍn€“Õ¸éh5;œd)«ÎÐVz_?¼û‡÷oÑZÙ¤Þêòö·ÿ_¾øügóï­1˜"=3!t=’D6[þÜæþ(‹öQþŸ¦]41V ÎÞÇÃE¿ªã§Ï¨už3ûé5”ªêŒî1 âËuêÖóë¿ôy>8<äýãlÊ÷™Ø0©ñTs‰{'ÔF‡µVÄ“kW9Ù;d÷μQ["‰ ›«K#UH½Qg8òX' R–ºM²¼@+A" 'xc×ðÔ:ô&Í`ŒW =­ÍŠ¸Øº\ìï}UTÀž~æJÇ0ÏYjÇ(¥(Æ•µè½‡)˜¦)UPgÂ2fþhk å4é} 5A”Ì‹Jxù©ë|ùKŸæG?x;ï³pÈ•ú*{w÷i´[JóÄ“Oòú~6âWn±~¥K{¥ÉR«M#®s”;&ý FZºkmÞzoŸ¬×ãxÿyš³õô U!_rëG¯³Ùêºý{º#ÈuŠS5ޘ䈤† øn•¿ùo•ììïWkI+ša‚ñ†.#[PJ_UçŠîðïí_Ð>"Îü™½1´÷ü½/ÿu¢ÌâÎï_åžþã¼ ’•º¦9r릊%äEÅÑÈ씸Æ)ä[ýýxO¢EŶî,Bx~ßuΑç9Bœ…’÷èÅãOÏ—s–1R=66ô¦_)êˆÉô7+ec>¯9-Ù¤J•›4Zóë(=-…).6šfÂ9 & KQùÝ/äx8*®,éÔƒGræc Fý!Þy¼ô(Pš’Üä˜ò˜ïÞßæKÏ»¹¡Ðª788Ù¯Œ“kŸ8…µ7o>’KO’?ÿ§ÿ RiêíeêåyG© D/¼ðž2›TeðÊc Ê<¯2Se)Þš ª4%ÎX[Ræ¦Ì« éBÏ ñŸ´] ¹< ÅÌ,æEô`f¥-kŠÇgMÓJ£T¥c‹i§( æyh”„8ŠÐQ@Ò±…dïäeš]I³½MHŽS†k„åZ‡F˜@ X[ê²ÙÝ`çÎ'EAg¥K-®qõÊ%¢ÀÓ;Ú'+,…ƒz£NÒŒŽ”®d`GÖ²Ö^Æ ˆUÀr­²b£xÌÓ—>‡ñe-»Ç¬¯4ÂÒ1ךûoÖoAPY Ò[Â(Æ{‡ÐXK £Ì†AE›’|Fi†œU¡©.ZYæÖb¬Á;G–U¬}V!s%ÇSKÂJ˜:¨ÅÁ)Ú"WU–ÉsCšÄa¥Ì|„Æ8&“”^¡IKÉÄF…!óŽ$æVübF$´ë«*=²Z¦ÒþüVÊrrH¤=ƒkc!F†¤Ö–6i’S°ÑhP–%Žòv›ÿüK •ÂÚJ‡?{ý»¬$%ukÙ¨7ð™#Ç! Å«yJR–hÑí¬‘„oìÜXqoeCŠÂ²Öj°Rkpu}›Z°s÷ÍÖ"ð„µW–¼óÞ;÷yö…M—g4êÐétyõµØÞ ØÞ¾D¤!i¬€2¬o­Qot©5%APGÇ!a ‰Ã˜“Á!õÜ»{@Òl„UXU·ÑáÁÁ2eAîRÂÚµ(¤õxppÄ•+Wíqx×ÑŸXnß:!ˆrJc"A”<ÄÄB²¹¹D$™äÖ–¨8ÀÃv«Ë‰(ñ£ «%Y–SøëCêaI-yšV­^YZÕôyÈ*ýišrUÈM`,6V˜¬¼ ÞþÛcZái’%u”’¢*à-<µ@R U¥… ô"ƒ|¦æ~„gs1- ûŒgóÞZË8ÍRŸ!1ZcHÇCLYPæE–bMY…9šé¾^ä8SR9EQ`ÊSȸ,r’z‹z½N«QoÄ$µ&…B‚©¡§ƒ Šç/ï=q­1ƒ¶ÐZ"%u5V¨èEE~ÚëR "õpŸ 3[ÅKMt.åç☉¾: «"¶V¯Ô®Ñì\æO~¸C+,øÑwߤÌK.?±ª5pÚ3ÊŽiˆ˜8iÓ îñænƒí¶Ãâ«ð¾(æÍo½ÂÙÙä=/|á¯ð¥¿óß|ø`J(Ì‹M”%Ñá3¡5KN’O†SHälì]u‘SëÕ;Pòìû 7©&ÒÇ;ß„PS¡|AÜìcæ½£²òæf Ÿ’(|8ÎWž—–V£FšN°"'+@%Ðp šZpàoºoóæý¶;7W·YmÔ¹¿wÌïî CM£^§Ý¬£‘ NöèÓ;Ìh.µXÝÚBxC÷°ÖF1$žN½5‡¦s›"•B;A»@0ÏÚ<™Ìr‚ùX†Q[mTUu&Sæ@EªòÎÃLÙ•ïÀÙ*|«( :¬êI+žÉÙ[¯…xSÒjF”婶nŒ!œ¬˜áó‚ã¾A K9Sk€@x„˜ÅnIp’“QF«W¾Å…tŽÂA ´‚–á*!ü·¿ðsüƒ?xŸO\—Ô”àíã²´<µÒe¿´\–SoQjØ¡‚ᥔ”¶à7^R¤Þ¡ƒ+Ö–"Ò.5"r+ù ìó|³Ã[£>‘ôö*J8^ßò™Ku‚ÝýU¬¹RïØ\ß$P“þ EiÈLF 4qòÆ;?ææ›<ûÌzµù‡’ZÔdwç„<õüê¯~‘þÉ!eiH‹”eûÊu–»KLF”ÌȳŒ“¾á¸ŸQžÕík”eÁõ%ÉújƒVk•Q1"†ån‡ÝÁ>QV¬_zˆ2„¸=:äðèÇ ?óä2~”¢ã­ЖWïðÌö¼;ÞÒÐH”é©K´Š¸wð{|åõ/}á×i‹éíCE#~šæ§2Ñ+²T‘?A“Ót²jëó­D æËÐ{ˆÄIÅë ”x '#Ë º¨ÍÖí°w‚šæ«7…'w©m±9kçŒy“•eN×ÂT@'ÖWÁy·aµ^ÚB–»¹p›WO"¼7*Xߘ‡“ªœ÷/‹)Ùq¦ƒ ‚‡BÀ.zöY¿,^~ZððñÁTÁ’Ó‹ó™ÂÆ™¡/ɘ©¯ Ï=å¥Ïâ…áËÿ©ãþÁ?gÿÁ>íµ?úqÂË5t:Bã">±™óþ¡áÆZ|I>ž µæcÍÖÇY¶3{VFÏ9W…Ë\äƒYð) !ˆjÍs6g E:Æ;w*À©Ø±1úUzM‹œÂ4ÎYœ5H ÕiÐýǹ'¥Ô™4¥Bˆ9¬T£,HjU=²¬0Ⱥktcˆ„C«’×ï}…Ïl-smÓÒ!a8Né÷˜ vƒ$é¶:äÃ>Fzl–!lI^ Ôä˜lÒ"$…1¨Ò@p0š°™¨ù³ ©x0¸ºÎE` IDATÄí“û|ñ¹&Ê9¼Ò”ײªîb Ž)ðˆñž¡•së´"¢¥´kÕÂɲŒ<Ï „£—•¡çB@xŸÎ•Ù"ÖQE¼›Õy%.99I.e2€f½†h´°EñТžkù®ÀZ‰ÇMŠyœ»¨*ÙTŸ… R‡Ê-é½/>·C2œX:±€PSàù[¿ôk¼rûÿ$w†š)•âÕþ D d3BõRÖÛ]‚r2·H´4D~ë›ÿJ~–P|…PhŠ´à¾hŠ m]ãîQ“Md IeAÇW±á+Í(¬Öš³ïJd  ƒ€“AÕÔ=`R4´d<Ñim0¥ŒÇ[[KX爊’£ÉIåj±)y6&iµÊ›YÆ.#ª%es’Áàˆ;ïѽ²ÁꕱM‘çÕ÷9¥™°÷à.õfÖò%º-É䃒ÂOȲŒ iRõõ+ìܺϻï>àÉ+]ƒ;Ô[Û¤ý1:fÐ#"E¤5[ËWyÐ?d7_æç³!—¯>EopÂÎè­$?Ó]%뱓Œ Õ$/r¶ZMÞõéè˜ÁíQrÿöÿÎ7z×ù•ÏüÒdžÿM¶ó¾qS–¤édþÝlÍXc"µéª|ð©%Ô| ÎÌŵÑì,Íÿ_sž£ qj(-BÔÎ9œ,@¢\¹&/Šn©ž)ëöÆŸ¡’ÒÌó¤iÆ¢ÕÞšPÂÓ¬GÉ<=òŒÀû8”UJ‰deê~Ü&¡7*èÖ6øê±:sÏç]¥p d.xòÉÏó¯äï0V›¬®ý­UICyþÕ›o³^Üf#‘`F\î,±sâYo+Ö’øxÂùüZgË©sþlO8[/yñóŸÆÇü¹K*âzóÂïR5äS8ûôûl<œgš)Ò Þƒµ5Õ¾³U²_„Y†ðž8Iä´T´Û FÇG(¥˜ û´[1A‘4jl4RÂBðæ­ÿ‹n«Æ߸¶L-Ihê¯Ýz—‘-ØhuÑQÈöê&f2&Ž888¡Ùj3™dLÆ–µµk# àèèÆ…ä‘Å[C¨+ø­"yS·O>à/æ‹¥'-KŠ¢JMgÊERUýq§îüâ…ÓR nÊ®ž1<½×ÜÛÇ1Ö;B¥é 8¡QÊà½~hóÊáÑÈ`66 ã:ÝlŠ"WY„ãñ„u)Т"Í£Ù½VV{ˆõ/n*Œgy¶g¿«8%Š) 8ÉQ¿ =qR%ÏŸÞNJ†ÆUð¢ó4tÌw_3üü [ìÞæ‰+7yëoâË€V]qR FiÊQY°Üiòro"ãŸÝºÌ½ƒ¯²SN¢¡ ÈJCê=Bz’0Á—·Ÿe2Èùö~ÄK—sš5Ëþá]Ì´Ö¶Ž#JëpyA§UcÿÞm†£œöòI¨¸5°ÿú[ë+ŸŒXY©£µ"jÔ(@™uz½Z­„)¢(&ŠbŠ,#HBŠ“Wž]¦Þ𮂫Ô’:l±sÿâÈ2ê1ôˆ¢ˆíF‹ƒR‘—%Š§%¹òÄg–í•Òž{áßÿÎ=–Öj”:‚@ò©§ŸÃŽlœc DZQŠˆFPg$ÇÈÒqóÆS¼òƒWЈ¥¥&—£„׊œwûté)UÎñ½ŸøÅgQZrcù_ûàóòkžÿú×~ƒA)X†TA–çºñÑ7ž…6ªùi zÊ0e‰ÒUñS–è ˜ÏÏŠwR}æ½?s^ÿäx>¢(¦Ùjè=ÔdƹGé ¸{žp~¨¦ƒ4ëøÅ8/€gÇÿE’½>Î}.þÝ×EñÕ³6ôÓ+ĵ3(È"y,ÔBz¸†- œs$Q‚w%eQ&u¢(BkIx"åQÙ*@•tT‡tbØÏ&ßÛÅ«*ÙX ÒÉÁAÁdD½Þ¥Ö¨cLAs«ÉÁÎ=N)2ˆ89:A†-T\c2Ψ#ŽÆÔkÉ”\’ó—>ýTfÈ$hr4™0Ê ªÌªª¸¤¢3c:{ÖY¿ÍÿoíÜOå§p~­V«H^EIZVýš ­æð¢’ÂÙê\*„ÁOè"ÓVJ‰ÒQU«GYZNzV:­ê\ÇÜʆŠ2+œ°ˆÐ,nD‹ãhŒ™}©~sl$ªðÈp‘Å-˜X‰V‚H8 ,ÿÕßúOøÆkÿˆzíß~MréÒl„ð£ã}ŽûEˆ `2žà’]xþ?ÚÞìDzä¾óûDÄÙïšûZ{{ç&²IqÑHòHaÏ@3`ÃÃO† ó0~2À?€öƒaÆxŽdy<âH3’E‘l6Ù${ߪ»öÊõîçž5"ü÷fÞÌÊên’š($òVÞsÏvOÄoûþ¾_ÏoðîÞ>x’Žß<¹·óŒ‚©K–;k´½¢,ù?/ø½#“ ÂœÚ<ß›Ý#‡÷x3-ÿ‚o¼ðuühÄÑÑ!?¾³ó_kD¼öê}¾ð̃¼dïþC6–šÔ¥¢?-Q“ê$ÄÍ*Ȳ ‰`šMi¬ÅD^è0iˆâ€Zk¬ÔTuͭϽÀínÓnÃûÇ„±æÝÛؾy™Ï]ºŠg$>äÆÆ6yfé,'<¸}‡¢Ì(LJe%Ý•ëXr”´Ž‹[­Uži~D¥b²lÈx”Rd|ôÝÕI[Õä“ŠxT¢C×=<>˜2é¥L'S÷Øj]bZïsµ¹ÏŸÿè¿GÚÌ(î(þ“ßû#²I?f½ÆOÿíZ{N îg1žŸuch4ù ¢µ†X üÐ’iA½=ýX–V¤åkÏ·ó-¥¿Ü¹Ì»\;s\sº¦ qÿ|B¹Ü†>º¨~¥óY<¯‹^gYA…Ÿx¿Œ€I)ˆ”ëY7Æ •"­ Ég B°´¶ñd©´¬ÐÂãKWnò…+Ï1þˆŸß³l´½ZPØ Ï­§kd>m,.œó/AyBÎòõ‹ žžÿÛ6Ôç·ø÷§EýçëOÛŸscÖží£=9†!­%C!UUÑŒq”–qÏ,Ã;wkþæ½·È«)Ÿß…Ĭ5"¦¶ \Y¡ÄŒªŒ+­˜ÍÎ*ù4GE«Íëk+YJ)ÒሲÒtWVIšãO³»„U–¥Õ%¬§[MÕ˸—Æ|ÞdªD×5A1NSúy…¯Bzƒ«éD†ª,B8’‘2!ðüªÌ][€u¨ÎE$]ÊMùá)å@ÖÆ‚ÚH¬Nñ㘺®ÐeÁt2¡*JT˜¸‰*=ìl´f*)©r‰5¶XÛ‰ÙìtÙ¿³Ïúæ¯É`D­<–š S3l_Z‚h‰[·.¡¤¤Ê4ƒlÌdœR‰šg¶—yã ÇŠ7ÀJC©kšžbwy‡l”RIËûßäùg®¢µf8Îy4áåøF‰ƒ˜xYqü(#NVh6;QÀ‚MË_¿õÇüöWþc"c©gœøqÒxâ÷g]ƒ¤d± ±˜—rœ|«†1OXªÀò`p€1‚Õî-%1J¢­EêOˆgñ©’‚¦ti?µ§8‰çÏþüùOÃhª°¸z®Ö+$i1Ã],dÎÈÉnÎ{žÏ=k†½Ae%–³:B&ÓŠ¤á#,èWr\Èʉžq‘§y±ÏþX Bkƹ$öjŽ8h1cWZ†µh+y èÛuti ¥vUYkj«(±DêT8çÂïç)6O‰)‘ø¢MNWIÐ>]¡HÔ•¿z‚Ö6ºFÎØX.n9zò sOk±n1…}z‘û²lOK‹_)?Íø$ã<§äë‹—»Þ ÷PƒTßWx3ƒ‘$1jFW)©èF¨Ó éÈ|õrÂJ <šj–WÖH¢ßÑùˆ°ô'²siß“Ä¡O:âû!Ãñ?jÐ]Z¡ÙtJA…¶¬¯¯Òj$dÃýª¤7xÿ¨àÛ_þ-¤§ÄF³IZòZ(&Dq‚ò<Â89APaŒF(Ï'cž +{Úb@e­kùôT€2OÊ`ÖGÙ+NKiç3§ço±BP#ÐV ´“9õåbòþWBðê;ÉZÒ¤Û-1BPjÁë?ú)Þüd‹éø jÑÀžOÿžái]@]?iž5âÍ_ïº>ÙcY4ÞŸä`|ÖcY;O³.Ü‹™×¤µ¦Ùl`k÷ÀY)ˆ_‚šÐ—4â儈Ø5o–ŽFì„!ÇJòhì±÷à˜g×DILVh>È ÚM®¯wè{¬-­2ST÷{¬¬ob0¬­v(Æ}îݹÇÍç>O6)Ž†XÒñðØØþ"º€‡µšaV3Õ’¼¨AJíáûgë(ó pp“Râ„ÂÓñF»º1¢”ÂÊxÃÖXë“NsI§ àZ4ŒÁ Bâ¤9«ãY|åüÖº® ‚9â¦KçÚÒ BŒÑ(¾RøíyQ e’å¨(¦›HP _IZQp’æ¶V–F¬hµ:N6Î…ÒtbNÀ&‹‹Õ?ýÃ?b<òo?øS®w+˜• ž¹þ̉øG0˦ÌËÍn›ÇG÷i´j[ÐZZ"ÍÝ ÄÊSÀÝ•Ý«Î!‚ÝÝËxžÇ¥Õ&ǽ»TµáÒÕ5LUóѽ÷iÆ W¯oqÃlq{ø€2¨Ž :­ˆØ×üýß¹Âñ àǯíóͯ]3¥--ûÓ]¾J3Ih5ÊýëKjQâK…¨%ç|jee–z’â‡D!“»wyç7Yë¶ôðZƒIÁWv¯0ö!ÍK¦ýK—¶(§#²á©©±¦âÞ½w™N*ڌިä`ÿÿÍ×CºÑ ãbÄåí+,5Û¼~÷–Ã6UY²¼¼'}¾û¿ýœî—×xa³MT5ùñðˆ¥FD?•([Ï°pÿŤâú¥ëc¸…üõ»ÿ'ï>ZáÅ«Ïò¥«Û(áckožÀ•sž²ƒ£ð´CåIÞüøw÷Þ¡=d:ê#›_e½½ÌþdÄñø˜‡=¾}ð”(”/¸¾{—e<ÖM‡=º‡>a#bZ|}·Ç«ïþäö7ùÖ3_D ƒø ”¤VHB!È0X©ˆ•e,$JœÖ^O†‚Vès¤5vFN’ÅIm@`0ºÂj T¾‡´g×Ô“²–0X„84·'Ñëɲr¶•õd[‹ãƒçéØ׿x,\¿ô$›Ðòc°ŽFw¾2`¥Å7.y5ßÿâù,ž·Û¿ËU4cÀR ö×°gÖRÛ Ð6Á蚤‘PÂ)}çÓxµ/JIŸ¿é‹Dþó÷?ÍpþûO„-{ñ øÔÈYWx~xæçûòfè_?p 1p$Ž(‹œV«‰±†8’ø¢@ „å¯ÞzGã5^¹]‘¦-^¾ù —77ù«÷se%¡Ý]BÛš+I‚A²ÚébŠŒûŽèv—^€ Ýv‹lÔgï 5c3ÎS SrTMñ„N³ÔÝAØY½èJŽz#ç­U/pôçIX.òj]êHéÏ‚é쟑* +*„òñ}g¨FÃ!uYRV5a”4Z Iè´–ç ƒÖ5Ù4uÔ‚¾s!A«yVu œ¡>Ì’"Ÿ2O¨´¡® EQ1fL‹cO åû(!P —âÇÉëm‹ÜÃõ‰XÆâ5”eÁ¥_àÞÃÛDAF,”u}æ>ÎkëJ)¬±´mzƒ!ï¢Ò¾—qs5ÄàÒòsá·ÿÏóf){Aè×t’„8 1žäó·^äÁÁ£iN6-ÙÝÞâ`У¶(rƒB0=~ÈÁþ>K+-*SóÓ×ö¸÷xÊRRst|€vÇŒFw‰Â&¾ PR¡KÍh:q­9FÓê4Ù¹r™áÑv›X”µàÑãÇ 'ªé”å•%Ê2# |î~|‡(Š¸ýî{¬ï\¦»ÒÆËx<ƵÐô'þá¯-ÿé·ž!¬‡¼ÿá}v·¶™8šŒRÒh4yÿÝwÙX]E›)b§Éƒ½Ç¬4cV☨†‰gèøŠ\ &eA>™°»y/ô88Ú§ÑlÀ­¥‚Ûoþ̾ÍÞñ¾ÉGýW¿Îƒýwy<|•ÿñ/ïòÖ~ýÎÛ|ï·~ÎÿôÊ=žÛÞæ½#.u±ôÇûÈü¿ù¥ÿ/_¾Ì×®Üä÷_z‰tü1ˆŒ~ÿˆë­-<òªäZ²Døg}´ôkíËTð³Û#n]¹â´Æ?ã0J` H«)„g ö\O°ÅrL+ãÀÖ¢‚€²> ¸t]Í°%Î0ÏûžÏ¯BˆFÀOŠ†ÏÏ“§m?Ï÷U™Ÿ‰œÏþügf/N£~ëtâð¬ŽÏSiY¤|Ú¹ž* I$Qº:!ùU†ëZm©>ÆšÀñÿúÇÂμ“ó;üº(Zý,ð׿*€a¾0Î÷±øŸ‰¶Ï{Š€5†Fœ`Œk?ŠUr²¸Ú’®5ž¸›.À”‚¨å¼îª(ø­Ïý6?~ÄŽ#ü#¹A»YÓL–™#ŽÆW[ Ö:Ë4ü6ãÉÃÞ”ç_x†(MA'é t…©4+K†^ÆæÖ….¤C‚TÑÓ–Š˜%¿IQY5(/*Ç*'û'„À;‡~~^C'©7G¦Î£É²Ô±¨îd©jˆ’&ÂÂÐC×5ºvd#ÅdJyŽ(À;Íuš(V¢6¶ ËÍ.G=¢fÄþä˜k«;ôìÓZÙb3^emó2Æ™í‘f–Ÿ¾>âæe(v Â$¤è)ïßemg›JC»µÂ²„aÿ˜8Ži7cÜÁ÷}ªJ3šô)󌥕-¼õ >zïÖÊ”wû¬nnRLFtoÞbÿþcV6ÖÈÒ1&Oi7–yttH b¾{§ä¿ýσ–+gK Œ¸¶½Ëj£Í÷ßú9ÑRƒù§¿À߀›kt“]Þ¹âG´›ÏJÇu¼7íä†Øoá³Ïò¸¿GĬÑ8`÷ùm„4äºÀ× Fy˜¨P_ã}µ@‹€[Ý핾֘¿ø GÿšÏµj¤µ`%M?dsc›^:bÃ_B IeÿÏÛð‚$£ IÂÔVH`mu‰òøˆ[ÉK:iÒNËùdÛÙoO)˜ øêxd­¥Õl¸‹§,IìÓm Ú¡¥¬ ìMxïÎ}FiI²¶Kw} òX‰`-Úc’ö¹Üj³µ¼†'î>|Ä°œÐétû=¶/mAVLI§cŠ4¥Ûír4Òmw 2LŠŒ~]Rh4/;::%9î—ô‡)Bù¡°ÒC.8[‹éìÅg`ñµÑ5ÁL©  ªkÂ*,hA[GºIúÜýªëŠñxBY9Ôfi,R*â(`<0O‘B8e+Ry(å¡|ï„R/NB0†²,I§EQQÕš8Nž" BêZ\)¥\”/•Â¤òð<ßÒEE‘3æH9s„3¸RRU‚ ˜ÍÄ g²Rr朹yP–ab€ÕN“›/ðΣwh„k„°gONæ‚ÉãŒ{ÿæu>ÿòAÃGÙ³Ïøb¦Bx‚ƒÃ=Lä!:-üª Õn³ÜîÐ;ê3Ñ9ëÍ%vVÖy<<Ƴ‚k»TžÇx0¦* v.]¢.3* W.oÑ÷(ꯞÐXYÆWÕtÌþÁ>Öh:.yY2öõ)‹ß÷‰ü!-Åä˜Ñ°f2ÐîvxöÙÏq°Àx0¤µ²†0pôø€goùîßc8Q[ÅáÞ”?ùɈüuþø»¯òâ³[`sòÉ¡\MÓXZY&Ÿæøϯ=@ì6ø;/Ý`=ˆÉmÍF‡’²Ö¤ã)£¬`Tk¶WwX^]Fø€I6#¨Š‚$iqðñÛ·ÖÙ?Þc4ÓŠ[(OQWeù˜Ÿ>¸ÇÍæ}Dzÿð<èßa£;D"(ËŒ£qqšñ¹nƒ5Qñg¯ýþòœÚ xëî€/l÷ÉkÃ`pÈ*>Ï]½ÉZg/Žð­bgeA¯O)-[­&÷)’‡\ßü:Ÿ¥ô|’Õ²®ž:­æT˜¯‰ BE­%š3S£3ölvQ=¥óaÞs?J§Ì©4/ZS/²§‘í“åP€(ð{‚9þóq>3zò3Ët qšÍ ýÓkWVr³®ª@ëéïŒïb‘“áÉk8}a øÊ‚ø%°óc™Ž?¤Æi©ë c-?ýák§Æy‘¢òywÎ0?í5@Q'†é¼wõïÃ8ÿºcñ\Ÿ†æž_ã“)KÇ@!]®73ÎB8˜ï»”cø”Ù„ñ`@6I©Ó‚_¼ñ!ã1V…\¾ù~”°ÒVl¶áÏþú{\] (´f-iÐòöð=‰VšÑÑ1Ó¢FF‚­ö*ã´ÇðàQ×( £ÑNÓIéÕ(ÆÓ ¶Ñà­¾ä¹î6µµd•a2ÕÔÆ–ÚÂG {Æ{›;!'Ä CqF}Þ&¡¤<Ã{-„C!+ßCIReY2˜N3„ðˆ[m¼0!ŒBOM'h혵JS¶BűC;ãîùd2b:™0És¤ôñÄ ŒJ…1ÂZÊ2wÀÊEºHM”ç;šÀ™ÔçIiF¸íêºbšTÚRCE'\¦ß›ßWÏŠš(ð¶áŒ|8s\dí‚þÊ Êüm„ñ©u}Ê=¾ðÌ”YÅ£÷ö¹ñµK“£äSÊMÒjBYå(«NsvÚM&Ù‘kŠ4ç¹ë7yýwé®®Òn5Ù\ZEgÃ}Ö6/Ñj·é.uyûÍ·HÓ”›Ï=ÏöÚ ¯¿y›V«Ã¥k—PJbUH=>&+sêªf{÷*+KK|øÆÏȦSv/]å'?úkÛ<üè2ô ¥¤²–ûw?b}ç²Ê¨¤ÇÕ«×0@èy4[1ãÃ}ÂîÓ¬âÿøÁ„ÿîŸþ.zÀæVÌÿõÝŸÒïxóí}2åaá IDATvw7™L‡DžÏÚƇ‡}<#xçãû\zq—o_¿‰À§ÈKJ«)+Öð`’Ò—‚•Ö ív—{wÈ« O¤ù­Ý¼ ½‰ YŽN(/¤&Ι´~h¹Y&ºFˆ )A ¹{tHZæ)J×¼´³Üè²±¶Ì7¯>K»~›{^AÊ÷ɦôÓ#Š8`-npðxõ­-d^TT¦¢·ØZ^g˜Žè„>‡ÓcvZ¿IöÎW+@èÚ5?ÅhaI³-, W:*g*ió±AžÖtmÐöt}’A>ÿ¬_ôÞÉßq™´º,.T¦ZÜקefq6ÄÁifðLöWhJ£©¬¢Ôeʳ„Iîß975Âñ| Õ ®òï Ym•£;ö=W¾ÿ*êÊ /çÆ—¾E].; ùk ‹xQê÷|šû³xM¿ê8Ÿ¹(’Zt‘·õI‘óüoº>gœ-„~0KIº‡8œQ‡Z,U™¡«’<›2ÐÆ ¤bš¦ôF)™64:+lî^ÅZC»áÑ-¡„fw›Ñø-v“k­.ïtR”§qˆï 6—×(&cÒIŽÔ9ÆhöŽ&´š {Sü¥ãO²ùxfD·{‹Ú úiÅñ`ŒL‹¡R¸ºê¼_x9Ÿÿ>ïWYä'Ü·s°ØÜ[µ³×'¸œ!³Ö’Žû¤“)R*W juI˜v¢hÆŠãÃCª²¢4–¸Ñp©s)ÑÖàyò¤íCÎZÚ”àùþ‰Ü@ù`5e™“¡\¤l…‡Pà©Ó…ÄX ‘FÔÚø>vFv „DHå-\– !¯ ÐcÎÍ.=ÇY\U†À÷\}u®ÿ=k/ •åùwïñìyq™HAÒŽéoms½;ZÀ tgQN- i‘a¥å…Õ5¬®ðjÉÊÒ*Óèe}úÇ=ÚI‹Õf‡(h´ZeF¥-ÓÉ”¥å5^üü—öö¸ÿà˜j:`m{•Ac©‘fŽ2F£T1`ïx@gu“ƒ‡ öI<Ÿùp•ßûÂ2¥. 2ŒFC^úÂó ¢$¤£ yQ²½»E^ä”eÉá àÑã”béßúâUžÙꎥ)W//³ÔmÒíÆüÛÿï6W¯oÓíd“šƒÑ€¿úÁÛ\}v‰nâqïá#åsiu“X%ìõû!a“‹…è¼Ï0O‘Â'ÍSN¸™­aü Ct ­N“ñhÄZg „dÿxÕå5L¥ÑÒÉY !ðBûá)APYžïvX Cj —×w0µb4ì1Ô;í6¥­¹Òî²¢<^ÞÚ¥á+ʺf©ÑDWšÀ X[Z&T“<£* ʺàÎ$ccã+´ã_BRÒºõ´þt=sk-­µa]q&-J°ædM˜çó6Àƒ³2wâÏÛùçž<î“åÑÅíj«‰Â]׳µHùìåGÎΑó땵P¹c®|B±L:¢&\¦AãáIPj®¢÷döáä\ ”¥%öÌ,ÇöÙ£hkᥭ5–[»¤ùëúцWðSÔ•_þÎõ/~“º,NÔ¥ÎߨExùyÛâM9Oõ¶øÞ¯‹–^‹Íìóý<Õûºà!yš³ðTãƒÑ„;~ÈàxŸKtºK´š â8BˆSd|üÞ„¡O%c®l­;«¬R“áw»t“5÷÷yé…l^»Äƒî²¼Ü"Þÿ˜Iûï¾ÁêzÇymHÇ9•q"ÓqŸ,3-kjcyí—v·xû@ó‡ß¸ÊñÁ}†yÆññåÕMí×n\¢Ù™9;Û»<øˆw?&šKW×y~í&ëë«DâÑãcn?þ¯}ùk|xï.?;êÓŽ} · Û~ÌÞt‚ôNù™­1¤ –w»ŒÊ!Ù8g¹³B£Ó¤7Úg<qÔ; +FT:ã¨Äh8a}i“Á ÇKkKºF*Éîê¾ô¨EÍ¥å-¼Zá…>ºÈÐÒò¹Ýëøx¬5»DÒCƦ2õúUɤÈȳ ?ˆØ?Øç%ßüÒWd|áwÑ°|%H«O_g…•(ßP×>󲌆ڜ® O˘Οï²ú䶨 û A8 ñ"/ˆãˆb:9³?-þI×jŒA E^i<%P3ƒ{‘1·²Z“Wš(˜·¡=å:¤c3K+E¥!˜‰î|¶a1Bð¯Þøk®w|Œp÷¯þÍO\Ÿóµ/|]W¨äíÜ Ö禋7f¾ˆ/¢¶/ºA‹ Ô'E©ŸzÖ:€®™Á²pÆñlk—ÓhvÚ!çÇEÎE{q»óªTÆ:±‹¹¨¸–ª f(AAU×Dqâlãˆ.t-ˆšKÄí6a(K‚áJSÑÝXaÅ{À¶g0Zx>oÜù˜R)*%¾`3 Ù]Û!ñB<¼ÏÎΣñ)|ŽŽûÄ„V«éŒ·'Ùè.1I§V€©'¯bâ'ž»®¶4?w][¤ç¹ú<gûù¥°4ã€"Ï1ˆ“28a]•Ñ*-¥q߸ÄP™€¼,Q§=U $iV‡!‚ÓBM µäGo¿ÅR ÆHKnjb_P *SñÏðõ›1‰M)eˆ7wv<É`2`”ñ,\ét¸GlG!®VZAšOå)ÇGôGCÂF@è{øBKͤ(YݼÂöêǽ#‡Œ÷}†Ã{{GL‹!“±&LøøaŸ×^ûç¯w÷FÔ¾Ç ë³³}…ƒ½>Ý=$%·^zÃ}V·wø“"þÞË×™ßeÔÓL̘ãÁ˜ÉÈ£Õ ÉRI¡{¤eI-—X¾õ ÿðå5”È †˜ZFIk ?ö9>îÑjF&´Û1½qÁì³~³AÒŒˆ¥bµ»Â(Íñh,µyçƒw Mîy<·Ò!hH¼,˜7ºKgWS=zÐ'^ѺÆ÷’°Áþñ#@²Ü]e¹µJ»±Dä'´“­FË=saHÃj®í^B—«­%ŒµHá»~pßC"XntYí,;ÑT£qJ3i1Ms”’hm‚€²ªIGCÞÛû·øÿŒnØø¥jš CDë™ã,9ÁjœŸÇNŠÀ9Òv–õ²Ö:½ö Ù‹Ck Ö¸m/èm~Úø¤mN²Ÿ³´q^”[»ºó,Z7³ÔôÜ,Ÿ/Á.ŽEC.q´½µ¶3ãûg˜O·ŸñýK]Öø¾<“?wÆŽëB€‚¼4$žÆJùÄ—Æp4þIÆîoÞøw|írŒA¸–6¥øñ÷_E]~á«ß¹ñ¥oau}’ןE‚‘óž!ì¼q›«T×tž¿ÿ«çy™3Ëi[Š;ç9—÷)­ã¢cñËÛœ‹œÞ/7KçÚÓ}»óФiJžçÔÖ"ULw©‹ôIˆ­ –B0Θ–ŽŽ~Æ­–Çã£!q”ðÁ£‡„í.«ë«„V³Õh²½ºM=óàÑcÍ.n“<7qƒ¤Ñ`cmƒ<ÑOYn¶§)ÃᩘÆM6“„Þ¤FKÈjG<§½¶'i¦ RÙ ­ë Ü¢è‰”c ZWäYéPáBœèȆEYSk3k PJÑhD()èaø“Œ›ß÷<<%¨ª£+À9Êóg"+.“øN´CÎêßQäxNãY)å€iÖž_c¨ª’(pÄ)Ó¼<óÌÕU…™Óz!Ê ßw]ãyk`’k´±$QXÊ"GIpJR ÎYó:X{Çõ"™öZE£k9žÆüÞç4ž`…<ñ<{{w¨EEŒÇ­v“Ë«ëADUUdEáÒÿócI‹ <’$t-l3§)Ë2âVLorŒ¨IZL =Ÿé¸¤BÒhw¨Ê)JÔlîtxþÆ·?xÀ_þðßþÊ3TBRË~øˆ­eÃQ¯â¯Ü#‰ëÛkü$<ß1¤…bÿîG¬ì¾Äøð°ÝæñýQ3§Î öG¼|™?ú;Wyë‡?Á(ƒ©R¦©LIâ]åDIë¹²ÆO_½ËÞp½ãC.Ý\eg¥Ci »k›”yÉÁá÷2ÍRdØàÃ"§ÝøâÎUtíPû¾ç ð$•)fÆ_P *ÚÛ °ÔYB¡˜dCjch&M<é?±Î9I؈ï}Lbàòú.ÆjZQB(xQ(—2Mâ_zU‰µ†8ifB[*]9CŠæï½ÃAQñýþuþóßù/è´¤Ó–|êu;'ÉŒ}|áñ§ÌckœºžòyqZk®í“Fy¾Þ/®·RJŠêI±Åóù´q>À;»EžeÔŠ²"ËK¼߀9‡zšq>ÿž‚Z(7¯¥•°ÎÚç´ƒ¶0-jâØÇs¨ÏO¾!½‹iT­­èÊÉÏØßÉ1Ûˆ¸5ÆÍÓ»šóW¿së7~ S?©Y|Ñ}>z>oxçcŽt¾¨'îÉkùô/ð”Ã[Ï ³Ä¡.cu –SùdzŽÄùkú´qyUžÊ5µ'`;›K¥k‚0 ®g:§U‰Ž‰>±/PBÐŒ<6[ëû|xÔgÉ;äÁÑWz-V[%¸M³Õ`Ø?ä™ÍMºQ›ã㢠ÓìB½ã!0¶fi©KUçìïAððp¥f›Q9eR¼uqce“Qm±6 Ã'D?,Îxœôý^[ežá‡gë`óÉë ^…6³š°çn2%aˆÀRæ9A!•ëWmDýýG¤iF%¤u¢Åj&‰¿ó\ˆ¤¨¡ª $vçikZÍ%Ÿ,£Ø™ò•KO¹Hµ‰ÍÏ×ÕoÃ@Q”Úœö©ðƒ pŽ„çùX$e¡Axá(lÓÊù`Ë „HžÐ 3ã^íD¼ƒ”>þ¦åù+>Ïm º!¬&µ#ä— „D JrÐ{<Ó”¶\ët±yEè+Ö’ͤM¢"úy渌A‰­còóáKIBaj¤/©jA·2ÉS6–W #I–£¥ÆJƒôºËëì^½Á›»Lú)SmX[]áõŸßæ /<ÃÿéOøÖï<‡'ÒŒyöó7x÷ý!^¹Ï?øk$$qÀõ/~É`À/ü+l´™Ñì^Eø1™öùÃßÿ ÒÜÒ;:äG¯|Ì׿ò9†Ã>+«KLFc˜¥vǵ¶Ón¶Ù½¹Ä7_úEU3ÎRÚA‚F®]¾Šð=Žâ5;Í«­.ôXÛؤ4Y[Y§7ê³â‡lE!‡Ú`Ë•HêJÓiwý˜,ÏðCEšéÓiuÏ€e¥”H »´ÊÝ~ŸþáKí6I¡+÷ åY”Šþ`ÀÛÞF*§/^Užï¡ñb>ƒ¡<ýÏgn€Ïž¬“ü*Çœ9Z{qÞLNÍrªlK i‹çDQB’4BDZó–Cßv„fš¨³œëQ“Zìpi厪=Ö}IÜJÈ&=Ö‚½Ã>u©Ù›ôØ^_çƒ{w©tÎÆÆ&A†!Ù4##Œ®hwZL‹Ìñ÷Aå+~ñ°âùÍ+¤§«Ìé}ù$âò“FUOçù³0ȳ ©ü“è°"$ž¯˜L&X+HZ-ŒÕDÇàøº6DÍîI ŠBäÌèíØž˜õ$†s”ZÍ»€X\ôLÜb^ Ÿf%a¢„9šT3E!_ Òiê4¥g­WYájÈba¿J)¤RNB(â0À³šJ ¬) £ˆJÛYDëÀ5¾öLå5¸²¡iIC­Ÿ¶¸°ô˜š |¿ªyØoFcžÝ¼‚©,¥ÖÄqÌÃã”°'…ø¼ÞÑ°‚I1%Ír|?âÞ`ÀfÒ +K"/¤,kâ8 ŽúÓ1ûƒ.íî°¾¼Ìp“7®l0Ü#j¶0Õˆë×wÈDF³Û¥¬séÚ0%½^Êß¼r—?xL3ÌY^êPìݦ]>àúz—mjà»ûKüÞo¾ÀÑí(+ÃñÑßxùEÜl³pH³Ù ª+²lÌh0rÆ®S£âŠÏßx–ºÐ –;Úqƒ‡H ·ï~ÌáÛ«4„$/2 –ÕV_*Æ£1‡ƒ>…)Ãc,UM>È™ìeøQH»ÙFƒÉJ—mÙÙºŒ5ö‰ù1Ÿ?GãžßÙ –!¥®'ìpÔ?&¯s„ç²CËËËÔµ&¦“ŒI‘Ëq¿ÇòÖ*?ßà¿üƒ¿OàgÖ±OokÁ¦Z>Õ8ŸDŠ”²L§)ÃæAˆ83ŸæãÔF8*Þ‹îË|;–B®ªêÌç/2ÎóÿÏmȱ=ÿ»òýw·DùgÓÇO;‡“ýÏŽ;oe¬ªÚ­Ë'À¯³Žƒ³u+±‚Oã‚™þ@ra)BÁ‹—wÙê½É Ž©ÒŒ½Þ>¾ï9jPéãÓœJ Ђ<ö¦9ø>= à ·ÏÁñ1»»—°¥fœOТâþã=Ö’†Ó”$Žy÷ƒûX£h7Ûè¨Ae E#bU–õå5–;MÆYɵÝAè3LùཇÜÝËØÝ©òŠ½ãÛË]xü€ŸþàMöS~÷·^`s{ ‹d¿?`kkƒµÕŠš­eâ¸C«Õ¥252mÿ¸°$˜ÀhG J­ùàÞZË "ß!éo­]c­½F£Ñ . ÃaìÓmµÙh.óàÞ= Âf@Ö+©4[·6ñý€I9<‰óiv9_„¸Ühã …FQ×9¾”DIÌíG÷ ’˜Ð÷HË‚v1f|üèw‡üÍÝL¬á•ô7ø¯ÿƒ¿÷·d˜Iì ÆE5“ŽýäÔ³/5E-žt">žÄ÷E¡]6Gœ¶¢ÎIŠ<)±Ú`X<ÁœÄDˆ™ÈÌ Ã´˜u—ŸÎG«‹ç§ëÊeÙfkû\þÕ‹1‚@)\þòtœÏ˜žÒ†žÍJ)Ñ>RZBÏ' ¤ëo.J겤*2gðE[(+ƒE$ə֥ª=<åÀ}u]“—RùÔútxBS•Ù4EHo„æ#U]ãII‘ç(?À÷æ¬uÚÚÖb=øúµçÙX[ç¿ÿ17ºc”ԕΓ÷’ AJ"飥å‹«ú Æ9W66Éòœ?ÀXC¹hÿÖ•›<Þ?`+ñÙcîLS<éS{å)¥§ˆÛmŽö!„d0?Šƒ€ãÞû‡¬n®;'@Â^ÿ1vDÔJ’NSš­&ºÐí☵µeŠé1»[MŽû㩦*r.ß¼ÁÏ^¿Ï ϬòÍo™o}ûYÞ{Ÿ²‚ÊüPшc0§­3a’çNíðø€kW®(²¬IÓ)ÆX”ìú¤eÊ‹Ï>GGFôÓ {ýC–Û-ô$c0qo´ÇÆÚ:½£cÞß»O-íD³Ÿå<~½G$¬~™Þàv§MšMNKxx4“Ö…€å•>ñÚ{o’–)ÃiÎûǼ}ü˜c]roØ#Í &ã)w÷öyí£¸SLQ­e”ló¥ÏÿþîK/áûÞ/•Ùû¬£ÐŸóIÊ|.•KÏ3WV‚Ч,+¤:Û=0ßFy’¢,qeÅùq4`NzÉ/Â1}Úçº,ž(»Î‡µ–²ªðÂàÄ^´¯óÿ?»c4IìJomãJa‚Ä¿€£üÉ3ÂX¯æ0OÐP%R ”’ŒÓ1ÚhB?œ£µ_þε/|ãÂåù&ìù˜ßÜ“=¥ñüÓÆùö¬‹úÕÿþ3ç·û4Ã|>">¿ï‹Î­^P4š{xÊS3ZNK%îa”NZ1"”TŽ†ÒŒOyL§qQW–¬˜RV%qܦ»´Bà‡$Í€ Œˆ<Ÿ8Ž ¢îRÀ¸÷ˉåãƒGÔÂ'óC„t5ë( Xê¶ØYY£™¤S’VB+Œy¿?d{m‹,òóG’¯n]Cz>ƒ¬Bx!Y^¸ ĹÝ/9×u…TÞIæÄZ‹†4-ðü„y°EÓh„kñEI:“g9Ry©ÐU5…/‰âĽö}šÆÉ”ÑZÏò36Ï!]«¦Èsòé£kêº㸴+mA(¤ºú±ï¡f¶S0Š#œQÒÕÛÇiŠï»s)« ]×ù„t<@yÍVçdŽ)ñ<!%Jüÿ´½Y]Ù™¦÷¬igŠ9‚ ’Á1gejJ¥R¹«Ûm¸ê6úøÚ¾ð_Ð¥_Ú—¶6à ûÂî®V¹ªÔKSJ™ÊTf*•I&çˆ`LgÚgOk-_¬}NœF0™jiɈ=ïµ×7½ïû ê2Gš ªB …Æ¢JDZxb™ðµ—?GgíK|ï½Yo—HepÞÍRB †ãø°€ÔÂÓS]{hÅ<úä¶÷vq‘¢Ûj³=Ó‹b²£Þ ^º|ƒÕÅUÒ²`µÓb{’! ­• }™Á³Önq8™(Mž¤íwÒíõÈ\IåJFÙ„Q6¢»ÔÁ$²QÏsH-yr°Ç$+8áãmW·n1î÷É‹wKvï¼÷˜µ7nÞ@—<ºÿ˜A©¸yc‹í½––Û”yM§µ@«• ¦³ä`4dcm_‡…¾ª+L±?<"ŸÜyü€Åå.K%––p“ŠkW¯àpˆ88<êsqmƒƒ£Òvʯžô9|XcXþÜ"¥+0QDQäTuµ%4kfNαXëh·:¬¯\Æ%)³Cdš £(8jqÌÈ9žT9…S\½zƒxiƒË—þš¿xñH-Hã6Ó†l×ç÷¯ŸŽié(2:Hý†TxVá— ïxz”y*eX÷šx]@» µÄÖï×èyÃø¬ÀnúmVU1S#<ÓÖHIQ£gïóŒóYû )‰´8¿~-B8ZšF¦÷£I'x/² óÎœ Áƒ–|ð᯹°áÇ¥¶5–šVÒâç?üy@ko½úLÏ<¢ù›™æåÏ‹RÿPÃ|ú<ÏéÎÕóØÏz)ϱÏßÇôw®¡˜ÍŒ: ¥ÂC«ÕÆ»iõ¶Ñ¢õA²“ø@_ IDATS*E’¦€@ IÅ$IB”Ĥé"qÒfq¡=¹%F‘$‚X×|ïÿ†Ãá‡$z›Må9ŽX^½‚-kÆpqi)U@Ûš£ÃŒ¼,y¼¿Ç»\¹t¬§¨Ã"gëò 8ã¼¢r¡Î¢L4ùl`=ï=y6ÆDq#S:M?yʲ"NÓ:[JElZAšhÆ£ÃÁºvhc"¤˜…T(T»„ÔÄqL¤?„л ÈVÖu¨ {GU9Eè+êf1ÈŠàŒ˜8m]1BH¢&í9?ó$±&j«ñ¤¬‰PPË'ª*4Õè.,Îû'Ìðl½­ˆ“˜IQÐmEà¡ð’H ¶iBƒH^½xƒÿõGwyamˆô;cxÚí.í´Ãáð­{¶¢**ZµÄ¤-t+ááxȽ:§Bro<`-ŠxéÊ –ÑÚPŒkö·±UÍ­n—ž––eYQʈ;Ã{¾ ·ø°˜°[–¸4&QyYЊ¬«è¬,ñû|Ȳ‹àÕKWÙÝ}B«Û%ÀIHò2§ÓZD«”8’¬.8öJÖ,¯¾¶…ï v+M–y®o]¦m O†z tZ†û÷Gžõyÿøzu‹íG÷év{H£èFm£^‡2Ϲûd›½£}º+ ¼þò+¸¬D;A»Ó&R(ÅhBœ¦d“ŒÂÖ<ÙÛcggÈR§Å•”ÿôs¹?:B›.ÎÚ€AP)$—6¯­|u¶Œe˜CÍ!´À AOJSówuŽMÍúç¥$‰øc\Û@ú°N?«ssð@%u˜§ûzï©Rxç×?äå­W׳ ‘ÖŠ¼˜0©s~þÃ_ ®}î«ß¹úÚW‰ÓöS7}Í;Ÿ]ÿ¬cÞžÙžÞfþgó/øy#¾ÓÛž5AfÆÙÖ3ãœ$ Zkâ(BÑÔ›}Œ ÆÄÖjÖ1HˆÐ "I’™1@Ttº Ùh@QLX^é…–©yrô˜—ÖG|n±ÍR¢™äŽ‡w–∠ÝEvv÷éO† KI›þQ†Ãóp¸Ï¡p,¯-Q•Š‡#ÏýáÏ^þ‡R‚I-q(¼T3Ǽ—ùY t‘O‚qö~ÖÆÐÙÒA„zŽiÔ”œ-ÁÕHïPβ³{@ÚéÅ1J›YÚZš8t‡::c®ÔÔ¯w9<ÅdÜPªŽ?ZebLÒÆD Re íÇô]OßwÜ”eÉ$Ÿâ0$R8&Ù„$n!“6FFLèi À: FÃŒn«E$5aŽEÔd.Φ}fsW)¾õÆKü¿oÞfsa„'¤6«ª 5z«ËkôÇGH+¨PØŠ½ºäÐVX©‰D‚ŽDD\hµˆ+ÅÎûà$ï=zÀÂBÊŸßzµ¸Ç WoÒ)=Yå™`I´$²†¡·h¢¤ª¬ÈJÇ¡,)I«Õ¢Žxì*.¥mŒ¬uVH“”ñdL6£MÀ€XkæG\ºx‘åÅEÚ­ˆ…¨à½‡t;ŽkWnñÓ–Oònv%>¸ÃæÚ:e]2êç ûJÃÒúe\1A©Šƒ=ÚÝ%ƶàâÊX˜d9£²äÖ«\Û¸@™•tãEžS”%žìR{ÏêÊ*Gùˆµ´Í[ïÞ§Fp¿Ÿñþ»ûäÖòϾxƒBzºJq!MÙÎ2Œ1MqOVÉFC|Ýè<Ç÷adŒÖ†(J褌2LŠŒN+ ˼൫ßÄÔ'Ãœ‹âçë[ü‡ŒÂžMï9oDJ4µs‹h&¬sŽIQá÷à)û”AÓ@*Ižç3±&w5ëyGU˜(9±ÖÏÿ™SÈP¢UOS£ž5¼$æØ8Ã)¼ p$F~ºqžíÀ¬œEäB­z@¢5 æÖÞ°æE2æ7?9õø¼·TU13ʧëð´2×üC:÷¦ç½žNeŸetÏÚ÷¬&ØŸõŸýŸu¾é¤;`¼ \k s¾¦ª Fý>ƒÃClY¡ç‚:RS‹=<<¤®kªª **lY“”•C9ÏBG°ÐÖ|xoŸ²òìÔwûÄ ¼„¥¤ÍÑþo}ô1c#¹´²Æ¥…ÊIN¯Ófw¸ÏD.,­Ñ͹¹ÉÊÂM¾ý…¯£ô4ò”Móò-Zdxžñ¾¦?›¾ûé{"¶Ê² Xó<¤ |ûh†õŽªªg9ùdÂþámzY™8Ôìu„ÔZ©@™ÎQ“¶ NL+Çó&‰ Ò{ªºFjŽRò²FG†8‘*Fêű!Ö/6ým±uMUUìî>aûÑcFƒ!eYAÀO=j)ÐR1)K¦©u[—xgƒ®¸à©âćCKžTh”€q=Y8~ÎZ(deø/ÿò_òáþ«Ô¦ÀÛ&Ng™ƒªª°Uˆd¢Øà¬EÉdÓJ"•CIðÊq8¤ï V/nqÿá}®®_`4³Û?"]Xdç=é¹(#Ä$ óÝHp嶰™ ËÒ‡}²Üâ[^^YyURæ¾vÜ}ðÄDt“ª¢$M0´¤°0)<•Œ¸~ã"Yf¹{ï1ßÜ2¼¿sdY±7: î& ŽØí³²¹†#e¡ÓC&-l&VdÃ#Œ<ÜÝfPf$ILQ—DNQŽòÐÎr2â(ËÈŠ’Tk>yx—ÃÃ}"«xÜ›„ÇuÅöÕ[üçÿâöƇżÌC‹¢)F[ÎÖÀrRã ŠCjW3­ÝžçÌ !ðÂÇÜDmˆLB$ÒÐ9ÓT´©¼ÀjfÇûS!ülÞú¶!ZLã°D!©Î<: G¯á[ªËšº¬É³1ø5çåÓBTÏ{Ÿ¶ÖÏÛoµ -§×v:àœ_Ǩíäø,ÆŠ{ê'Ͼö¦äÞ€«á¿ýþ/~sg›Nš$CçÏá0*"Ib>ðœ·^û¢©M#–Ó)c8)Jræ…œw§þý¬‡ý¬ôÃüÏž½Ÿþÿi/ë,Ïè¬ëiÚ ¥Í,b›ªiy7=N“aàØy™F‘óFÞCQ—hB}R© B•v—ðuF»e÷ ¾úê&Ú’çÞB&`—´„çÞáˆdi‹qÄR«ËÝÛŸ`…aûÉ.OŠ‚µ•õðÑ(Åû;,©{¼ùÁo¹´ù2º¹Ÿ<¯ˆâ”¼(1ÚPTÕ þ³ÞɼavÎ1è¡MÅœÎk-Ey|Ì@7óàj”ò8R(L+¦ª‚ô¦nz4Ÿ¾†VÛ ˜¦‹Ux—Žº_žÒ¥ qš ¥À9PŠÚ‡Ú_œDTµ?1¯;-ClTƒÔn¡¹û²uIí–) R#uø"/=x´ ×_74)CÆDJ,I ¼GkGå4iÜ`äVÒQvÖ vzïVI^Û¼ÄG=ŒÜZ‚H!Yè,ÒI;´â6vN«Ëh< `´ªb±³Âbo‰G£ëFSŽ¸·À­­ È$‰¼DÙœÉx‚T äC†6¤*CÇ°ú)ô¬S°Sdô‡ŒŠ‚žV¼råEúýŸì=拯¾Æ+—oAvDìSn\»EWF¬tÁ;Ö/\$iuÙÞpõÆ%V7VQ±âíûû¸ñ6ÝvÄ£G ‹ ™6×ÖƒJ›²¨ùx‚V‚Ãþ€N·JpÖqç17®^ÃHI-@xAY–³4âÃÇTꢤ²–½ƒl]°×/XXŠ¹uõ:‘PdUN[żúÒk|rûN+¬’M|È,†}·Õkà³Æôý*©PR1Ök¤ò€‹k_bêO›¥ü©F^Ùæ¹|'À:Û8§J¦©k;3,ó×|J¸®-“¼B©„iªèYJ^ÏuUœÙ™ê´}˜­Û¶&‰Í‰¨yžk=ÿ·âDä<œçóžØ|¶¶i¨þD¸uüÕ«/aòß ”yj[ßè› Æ~ö£_ #¤ ê!Π"ÍåF<Š>o̧>Îã>Ÿ•¦˜Š˜œÞç¬ènzžÓ‘ð¼§tVäzÛùû @ŸpÍZk²É„¢,g5‚éù¦Ï%|À ‡ˆ’¥eÓ–Ð`¤¢rPVG‡‡x©Ñ‘M*>úè!»‡C3~ôþ6IºÄúÊ:IÔ"JbnöÙØÚârsùâöwX_¿ÄÑä—³¾¹‰*§cymUòàIÁ ×ÿŒ¸vaÒyj­ œÅÈ ÞbŸ‘ý˜¿Ï©ažöŽ“mæ¥0²1˜n+ #â¤K«ÝÅ$m”4(ÀSósiú^“H"œ?.4b!Qû”B#e Yygq.€ÇŒ‰Ñ*Aèð{˜V¢HcI§ežÊÄXk±.vEH¥ˆ’qÒB›€Â7‡ìƒ”²iYÏžKY…¾Ó^„/Lé8«‘˜(ENëoSÃcì5²Ùgz=Ú…’ÀŸß¸Åov–€!eö;•ÂÓRa¤áÊÆWÖ·¸vñ:Ý´ƒt’Ë˹3*¸ûä÷Üáöm®\Ùàúâ*qÚa4©N öövxqëEÖMBíÁáN”¦ç”B£…F·R¼ÒŒªŠw>zÃrÀÂJ3ÌytïCö÷ŽpBó½Ÿüþá˜7ûwm“M2”´ììöƒü­ø¼æ¿þöMþí%!N"âVÈ&u‰2’¤ÓkµÈ²ŒÃþ_kªIê¸RâC\y´THëIÒ@y3F· £º¤§ôí„£r€3Ž…++8!ˆ; “£1 ­./^¾ÆÍK[ŒX+¹¹ÔÃz(¨±Âⲑ‰õîäšqÖút:Bƒ€<÷ÞÓK3„‚·ÜCšc‰ä?åPÁÏ2„’¤‘bº›¥§ÙÖ³ï_Ê0Öh¢¤—Çkäój(œ§ª³þÌŸ!)§ŸÓï&üçÄñ DÃÂ9FYÅyCà©¥úTœöüù¦öcúð¤”X'¨(Cí3äL”Òx_ƒ³¨­W¿úëo|#ðx碉yÎyóD®ÿ3ŽÓu€O;Îiog~œ&²Ï³ÎqÚÓš?îéëpu9 Ûغ&šöw– ÂY(¤6h)ÐZ!¥rÂabƒT U™4I‚Ò†ñh>`y P^ðÂê#–ã#Lœ2ìÙX½HGæŒFý£#†EÁîðü ^\ n d¿@’¶x÷Έ¯~៳Ð2ÔZ"\ã¹+…Fã²ÓÆPÖä1‘þÝœ÷^¤”ت$N['~_ÕBèY͹,˦á„2¨ZQ—꺠,mƒÖ™ˆé¹ƒ1íâNc¦º, „Ô³†Z*ÆYÖÔ&’Hdƒš<)1?_¦Ç6ÆàlMU:¬0ŒG£ A®"j„>¼Í5¦â#Â7ý˜½CIƒsÇY¥º*g¼Ì8Vx /BCÕt+kAËЃ’“ZB>¿õÿç/ÞçúR71·ΧòÎœëÒ“´: ÒŒãå«WŽØ¾ÿ˜j2dL„Ð G§Ó!‘šƒì/%µu'žÕésZk9,JZQ‹ƒl̲éàrËú渜NwÞÊ:?xûM„¶D‰d¡Õaçá6««m~òó»,®Dè(âñƒ','ºKÚy"§X[ß –†TGDJsÿÁ6£²F'mÒn‡¨“NxÖ—W°µ¥Îk{‹X_SínÂ;w~Çjw‘—¯Þ`0è³¼¸Ä¤.™d €Ë½˜I9A©„E'í±t@å+¼ñl´º\í®°wØÇ«&âSçc­Ìseßæ× 5Gà ¹ßakå /¨ÊâOZsÖZRØc&Àóï=‰ÑŒ² ^H¤ TÆó ¤”©M€qözûYÏ_WQüü?P•5‘=¡Y†lþBÌb=‘>;2v>¬Ó-ÍÌØž{ê¹{¤?¹žR3ïb³ Ü4“ÑH½0q%þâ]Ե׿ökŸûúSºÚS°³^À¼'ø¼*`ÓñiÑöéyVt|Úû:«Ž}úÇçétýé}çÿÔe9{6Jé $Á<(DÐX¼ µV 8[2 ˆ›qÃCëˆH·XXì ãˆ¤ÝA˜i4cÁB·Kgé&?z÷m^¸´Î <àh¿OQ[ o©£­^…ŲrL‘çH-)Š’wöà/_ÿ'8”7hÔLPFiÁ(÷ŒÊÐh\JøÙs^áÔ˜=Ëù4ª= ½ÁRxª"GCí,ZGäEN꺢²ÂWŒe“& 8âÞ‡úýQV‘VA"pú.E¨ui¥HÓ%=UY#U„”A1Ð 2š<â}Ó‹¶¹‡j i”ÎûP+–’¢®1RLÊ ´Á9 z\x‹V!ËäE(axg© Ün˜ …¦*r¢$,&I «÷$Ó:“@pÖÏt‚…÷ÌOwà+/¾Á݇ï¡L„8k^Ÿåèâ1¶Š¼±ÕZ¦_• ®V€äý»ïw"„6ÜÛ}ÌÚr—KºËîd@I”=pu£Knqx+±Êa´bì,C Oú$±fÁÄloï1NxóƒQù‚76/Ñk­°¶¶@§»Ä`8`éb—•Å“ Jìä5-]ñ•¾ðRpødŸƒ'XXX%^ˆèµ;2= ‹‹Œ³Œv’¢•FdžHi†ã1y]ðÖ‡ïð¥—_c±µDQLX]Xæí? Ú­„Ûo=!¹ +Ëþà!% I‹¬*yrtÞ#ñ¼¹ó¥ 4âÞ…f-Y™ÑJ[$*88SVËüö´Ñ:^”Hq•9âÇ¿ó¹‹WðÔÔr‚–šÔ¶0©<ʦ®C9Ëv Ëd,@…}]]ÌJ2³ù'¦éP ˆ¢¬ª3@|š‘>yQÊPäÙS©íóöq64>*ªš8Rx_Êâ®aÜëzÏJ™LǼ¬éü5N‘œóÛÎÔfê@ˆRa#iêHÇÛ 5IÓXøšNË`”$Ö‚VÓnº‰àÚÚ üÝo²?*¸~±K·Ó%mµˆ¤jÎá˜LrÒH1)Jœuì•\ظFbb¤8ÖÂUJam„®«ØUW';®Ì¿“ùÚ9GSu]ÙZœ÷ùç,JÒv›l4ÂÕ5¶Ù¾*Ç/Nbjë1Q·ÌËÐÆÚšãcž²˜ 'ÁO]îtx!F‰pn/ oÐÒ3ž­Â|nj©ÖÚÐHÂZ©AûŠ²5i)<ãáªétÝtiÓZÏjÉUY„gÐ8qø³¶®"!+ bcfºÞ{ª²lÀ_%@ÍMÁ A^ ¬%ˆœ¢& «—^aïž^âÎÎrÌÏaë,‡Å78¢?°—1ʆ<°ƒ'’Å(%¯ Þ=a‡þÅç¿B¶Ę -5¥oF)Ö/lÐ5)KÝUŠ*G ÓŠûÙ˜jœ3©jj,¢`mó2ýÉ„eí¹¶¹ÉãŸðû;ú\¿¾ÁÏ?ú=GÃ#þfØæŸ\é²Ò^A–†åÅ(+Šl@¯Óæ“Oî…°º"MS~÷ø6±6TeEÅyNmk’(âàà€……¶.]A£(ËŠ(2 F^¸z ! —/m²Òkñó|Lk!áÊ¥5²‹­nÓ)(€0¥”<,'¤2Bœc’R1ÊFô–z¸úlÎ3‡Ì‘¢¤($+ñ?½Ûç•k7)†ÙÌ©ûc)BÉ*،τ:Æ œ°X¾Ç8Ž)ªSÙÕ3æ_dL¬<0=ËnÌG·³@P\£9ñ©—zÊYÍ‹ÙUµ å«Sö#ØA¬Ï~²)Õwã€Öö:±Å(EaAyÇjK*G$›¬Ÿà©,…õ––P\^¹ÁÍõ›üèýl®à5µ­P:èüð~ÜDίýD×¥çå.Ã|:ºÿÙécµØœu¾gÕ3£½s"òùãHyÜÅ*¤SBZ Ýj£Îàè<Ÿ@*M¤5Z¬u­‘ò˜ë&„£Ý2(h?­Xc¼e©ˆðZ62…B ^ÜÜäÖ¥[¨è?~wÅå’¿ÿ$åÕÁÎhŸ^Úe˜(‹p­¥ºÀf÷‘>îˆ4]<”’´bÍ8¯©j-Gí…3ž6Îóïnz¬*ŸÌÒÚZ†¨]ëаÁ#˜d“ÐËYê K­xG¯·Ò7Yš´G ¶¶8±Ö8W‚ÔÔUIžå”eE‘BޤɔÒM³‘ ê¦SMô¶¦•Æ£Z££(p2a&ºâEŠ@ËK‹’lÔÇÚK<<˜ñ§ÏÂ5‚+x¬s%CzÊ ò|Bœtñ8êjB§MZ&EŽIQÐJâ ´/@¸©6ÔHâ)Nd&ØQoßÍ؈îr(;ȺœÍ¿iFä¼oÆD†NÚå'¿ý ú#Þ¸±IÇwÈ KçÂnïp?ëÓnu謬óÖðË7¸ýà7/,³äUÍW×IËŒòq½´Òž,#øšÃ>;“!›qŒK{,,´¹ûðz¤èOàßýͯù/þÕyô`—wò#ŠÑîóõ—®óÑû{ìîñ㟼‹­'¬¬´pÞ⬭]²=«½evž0*G,ö5DQDQ•\XÙ R†HJ¤Ð ‡}t+EkÃjg‘¢(XjõøèÎ=oØØìññ;¤Æ°raÞJP³%ÇfÒf½ÝâþpŸD$XŽù¯RJŽúG(‰l<.“|Úð^5Ùˆ1ñ«òmþí»Û¼|å&Qûá…¨P|6Ò3N"Z ‘š*†=ï¾5N(²¬8Æ“xÛÈg>u § L‡ª)AÁóçù1=¦­Êsóé²ç|Æ$¶irÑN¤|:H›:&RˆSƽـÊIŒt(©%1%=ãÒ“šóL奧†ùT€ˆ©†Dµ ›d£OÐ"¢?>¢¬ &eί~öVh|qís_{ªéÅy†î<ƒú‡Œç‰pŸLqÞïNïwÖÏÎK‰Oku]Í4Ç«" rç3O[8¢È çR\F@Å|ßi%Á9OY–¤QL¤C ;ïF‰Yç–)ŠÙ:‹’‚­eÒø*÷÷?BzÁbœ2ɇ¤i‹…Þïn ¾ùÆ7CÖHâíqù!Üo8^;„T”Õq–$/*Ç)¸ó²Ó¿§uU×d”ReE0"RÅ3e5áIS•%ù$­!ãdÔptdÀ‹mÎjªª¦ªê&kQ‚[Õx\йnä4½‡ÈpœšJzOUUszºŠ<σ༎0QÄ$2DigÆ—žˆ´ÖTeAY–¨FEŠEØ: „¥ÒXW#\Mœœ”Õ*ôÑ.ë’Øè™ûôý€ ®=FÍÍCè[/l\æ·{¿aQ8¦Rβç9ÓSãícëÂeÖ/]àƒÛÜÛëséâ‹«K1©ISÁ%WcV/Qä‡DK=¾|õ:W—6Þ}À'ÙåNÊoûûdÕ ÝU:­Ù8t ëµ{l¬]dyé"FK‹‹”UÅ“lB5Éùõ/n³¼°À0ïó{ßgqa‘ß|o—¿üW[ì<áÊÆ2¯¾t•/~þãá~ú‹GÜ{Ðg}µMÖL;Ž(&#²ñ„ÅÞ2+Ë+qbð²,c”Ëò>9N±ÖòëŸþú|ã|օϧæÂg'½¢§A^Ï)Ÿ¼ßgçÓ÷2]´æ¡õggT“*¥Içœ7½÷¤-ƒsõ,!¥ •¦§îÑÇ)šÆ Fb¤'2/ ›Ho1úØ °¶Bk‰ö’Ò×¼²y•Õ+äõ.U©ˆ·· ÿìÕ¿Àú`([RPûy}ØiD q¢(*À`Ój³¡aÄœãrâùAˆö¦„z[ýk .˦?2äy‰Áø˜((~XçÐ"æ², õ_c¢7íã=i«®ÙO{CÅ5­4JkŠ¢"ŠD P6œåÐý)к¤Dqˆš¼ƒÑpœ«2¤„Ô‰é %I‚óž2S–ž(iášy¾ŽØnG #œs$iÚÈWÚ‘’Áùªê* ÷q˜(¤µñ¾Ñ·(£qÞGÓ¤çŸuí eæê`ÎcE¨‹[}•*»Í ¯Ã³U¢i#ùt zúïPÊ°T‘FÚ‚åö:½Õvï2Ê2Ò8ÁñÆ…uV—6xëÎÇÔZ’ÖÞØÜâö½;tu—ïÞcóâÞ úãŽö÷è¶Hâ”N»‡‘…¢¦×íá±±œ.óöOîйž° *|˱´¶ÆQ]Ò]‹¹ÔÕ¼öâM÷Ÿ Ñ1[[[¬/+Z©äÃßïqûÃûö)²>q”PæË‹«”uNo±Ãá~Ÿn¯‹ñ’NšRújÇ¿ÿÛßpt4æãžðλ¸¶¹Ì•­WR¶«>‘Ѽ¼uƒn­q÷Þ>5÷ï IDATK •R†î^BR©¸ÞZæÁdð%Ó«´‘ôÇ}ziï„þßÅ<Ê>.§Ï-Fs‹áü˜€óÇ8+j8m\žíûFTNÍ‚áö”“qhO澡LÓ:§‡÷ž¢,qu…³ívJ’Ä'@>Þ{:­x†ìUJ¡´Ó°ÀãA*“ºáÝ5év¡ÌB*´2 ó³Е»ô’´Tl5ž¼Ç¥Õk!²òážn¿ÿ…ÅYb!Ò{òÊbbC6®Q¢AêÊé¹é3 `fQ}žÑÚP×%U•ãñLŠP7–B Lèã|ü±IZIÈBdÙ[‡t²µ¡ŒR ‡'Ö*Ô˜¬e\”ê¿I«Äïeñ4F6T‰Œ‰ƒW*ƒ|]ÔuhlE I’ txÎÚ¦mÈ”eIUVèè˜6¦#Ï+ÊbŒ MÒ|Hõ¬W´’(ŽHŒ¡*Žµ€µÖM÷¯À×6:ü~ ^;áJ’s:¿Dý#Xl§|¸—òíWþ)/òÿ½ùkË5JêP'…Rª'¾DEBXÑŠ;”EI«Õ&^ZfU–;KäGOHÒˆ•vL×¥Um•òê«/Rd%NÕ,HÉ…$a·.8x´ËÆ¥ ÔEH9Ch0ŒšÄßßáóõ9Ʀ Ô¿myõ…uìp¯þÃäeÃW/^çá“}dZÑm÷èïPJ‘Ä°¶š²¶±L‰âÝöùèî!·®\A8wfZö³ ï<¥ûlǨ#/ nÇÔµÅÖtÚ^3 Rîÿé N’Däe9{6gÙƒO³-SpîyãÓ²§µ³¤ ó¼}󼤕œl<lDKAY Ò(¬9±œÞ‡úL†ÀÚ i>ºûtcÐÍ:„ót[~ð½}zä|Ö üÇŒy ‹÷SšÆÙiìÓûÍGr§)gí3Ýï4ùäϧóI~w8W ÄLÛ" ©¨«ŠÈÈOáI"­r²Ñˆ4‰g&}‰Çþº\Ùº*¯®1†xj뉵eYSVuSB9é¤Îæ&¡gõT§Ûî"…äî“;tEÅÝG¹qé2kË«\[Zã'¿~‡/á5öžŒØíï²vñ"‰IèF]>ØÞ&÷†Þò*ãñÒ·ˆ3s8…¸ÚñÞ÷?äÕ¿z‰®bc\»ÅÎïvYŽW¸uùÈ16¢gKîí³¾´ÊÚj‡Ô´¨ª!»Û»ŒÇ’$âò¥%n\ßàÅ›k€äè¨æí·o“˜¼}gÀøþûܼµF>²$1¼ñúuÐîÄhøÉ*–$i•‹öÓŽÚüíwßfss…×6Yì¶ÐN±Óß›­ ©ql$-Ö[†1ð5¾ðøfZ Ť¤ÝH!ÿ!£,J’´‘©4 UÂbZ±Þ;àüþ¯y÷_¼z ÉÉuá³ -%ÖzÜgp"*먜Aêy í®Á˜PŠ Zö '^Dq ÐÛQ¬BͺN·™ŽOã@Ï÷t>oê 72%`Ë™Qœ¦ç£Þéögy:Á¨úæ8ÏÍŸŽÿ¯aþü¡ž¤±Uˆ¦ PS¼Ÿ cÔXWc«[Wغ ÈຠÛ긡ýÈÆ€yÚ©Fp²G¶R £%‘†"ÏñÍ  [•DFŸ¸!Kí6ËÝk«×ùxç7¼÷PòÂÍxôx›ÅnWU¼ùƒ¿ãõ¯‹—¾ðÕÓ¯1.kÆãIói¤É« »ç½ŸIõMëJq£]W˜8¡È'¥#JÛȆvâOe"”´Z òìˆIVPU%yQ‘´Ú³ÔX;‰''¸º¬Xèv ú$IÄx<ÂÕ9„Š`p†â”ج *YEžcË2¤±Ò˜$íb´8A„ÀW—RÅqãõKª¢êקÓkÞûY[L…h|ˆ¾Ë²&Ž£€êDP—Ýn‹VªˆŒ$2ŠºöØÚ541ƒÄáð$JÌdeSŠå5B*bÃ,]è (ÙdjïùÜ•k,u^äæÅ/siåuÖ^çÿŇ¼´¡±¾dªp5½‡yå¯éÏJ_óùÍˬ/­0ÉJ²lH>¨yr´Ã…Í-~ùá;tÛŠžéÒï÷yéú ö¶·9Ò5KΑEžíðÄNÈGG<ì3Ò]^¥îô–{èbÈŸ_{™·ÜG^NqûCbexïý»üâh™¨û«‹ »w²¾¼Äöý––‰;댭#M»\X¿HYè´Ž”¼ûÁ­vÌp˜ñ­¿|…ƒñ K]ÖÖ(ó"…/*öŽB㌸ƒð’bRRf%‡UF>É:þì7Y\êòðã;8±²ºÂ `´¡vec„ ¸Õ(eu±Ã“qŽ@âÀú…Ë&õ;ŸÁ;kœŽmíЦÁ;ðNNøŸèùë/w¸Ñ{ÂÝÁm~öþ;\ݺJìb²ª$"D·ÏÁ9çˆÀ6ÌÚg]Ÿ˜­yU»ŠWQHéº: ™;mƒtžªYÿ8…jn)]`X;+ɞힶ*Ïmù\£wXÇÌñ=‹Z4+B 2ÇÛ@dÚ×ĦIçã"p¡Ÿ·£˜Œ<£Z¢Ê]l]3ÅÎû¦ýæ¨T×^ÿÚsÚÿcŠàƒã´á‰´ÞéH”ón´ig¶8s»ÓötÚzþgó¿›9ä.ç·³¶Æ{‡1ß6(¥)˜L&bH[íMÎI¿Í”Z #é¶C«“8©ˆeØþW?ø;þïÿéà`w¥ Ë«8 ++׸±qiV»‹ öw^ðÆ7¿Í¥ë·Î}^àp6DÏB#VÔÇýW1³ç¥õ±“O2¬«©j„ŽR§©ã ‡Gá)'9y>"Ÿ”A-ËAÒê 8nU ¤ ÏÆ¡§R }¼­¨Ê"84&BiƒuU ¤áPR‘O²‰(PÞ’öÄû­ª*è7×6IñÎ…6–R¢£8HwžŠ>E“i™.jRL³0v6'µ’IJ¢ÕJ±µ£*s¼³ørÂh’££„²¬ÐJckp2ô~Ÿ·JJj“ "-QÞ΂Y„"ZË€ú’ª˜Øñõ—_ÅêéÞE‹§£˜Ó=Ú·vX´–÷>ºÇ¸˜ðã{˜øœC«¹»¿ÏÖÚ*yíèÄ1w³ÖêRN`©«øÚ­WØì.óÊ•[ØOvñ±ä+ë,ZÏÝÝm†{+WW踒½lB7…‹²E™8îŸÐº¹ÎKW4¿x´@-ðÞ¶¥×­9:Ü%‰[ŒKËûì»a-V×°{0ÆÃ…Kù‹o}#Æ\¼¸†u5#7¡ôJ¨ DÑII¢[[â8U^0±­n›‹ëã1—/l°²ÔC‰àH Ê,”}ª u£'ŒF{ÁYŸ–Nx´¿K¿¬ˆšÒ@?;D¡IGûy#ÜA«ÑsŽ¸÷ž¿}Çð/¿Ñ‘á;´mE·ãíý†{£÷øÇß÷yáúu´­g¨ègŸ'€Qé±~AŸ}ÓykIlR8\]Ñ2šN*0M)&Ï "cÈËãF0§)¹¡ìäH#ƒ«+¼pƳ9ëy•Ï¨9?ïRRŽ4m:RÌ­·ÇkW  Î_Çüõ¤ÆSyIkj佧ô’qî‚4°ç3‡ðܹó#ÒÈ À]8OXóñ“_¢.¿ü…ï¼ò~îùSŒi´:ÿPÎó|Nîy£5¯{^Jä¼cŸÇ—>½­JT7‚ïàñMê#FIÒA¨BEœ&ücB¥ $&I('C\1Æ{‡2¡Th£FPˆÒFÒÖÓ|NyBr'è(Gwi„àÞGð«ü=oþàïxrÿ>Ô°¼´ŒI¶oÌÿñßÿw¤˜µK[x1‡­æüict Q¤fŠ\§‡sAsà¼`¯-+ð2`‚±a•W´TòÌ㞸!xïîÇlva8— „Àáøá?üµõÊ—¿sëËß~¾´Àaœ6–ç÷ÓPágÖ?äú?5ýD&t6ÒRiƒ™VƒÎ‚BÕ4ímtD Y^”“ŒV{HKð‚NK“&Õ yÚ±ÀágéæÓÃzhE“´Øºõ_øæÂk_ù­N—wùõþŸÿïøè­_ñó¿ÿ÷l\ºW_áÕ­ëë‚>ë9"ÈjGÚR´cÍ0› ¼hJeYÎèGÓÉ=:½­ƒ£AH‡[kƒA#V4õÇéÈ‹Š²ªÈó *CÍX›d¦M®¤hŽq”€”ت €ˆù§¯nÐé.0ØŸ É]M'é‘JÏRw™/Yê¦8+YY¹H1©±Þsic“‡Ûé´Z¾M­³´ÐAM)gÍív,©+×(†ýá6@i(&!u][„à,|ÐÙ#m·ù×ÿÕÕ˛üoo¾É.]aRW¤ÒÍ$÷f÷* Ïkƹ`w4ë–ÒNâºb*Æ~ ƒå;ÒÅnª.†À¥#[q\Çlê¶y^¥-LÚBE jöá˜FÿÛã]M1QUep|¥²¿ M‡jµ6ð kk±¼Šˆt„Ò1Iš€]©Î<#›ä  Ò‡2E>ÉO&DI5‡ÔžÎGk-Ú„²†­Kœ ¸”’Ô.8%EžÇ[D&¦(ÃQŸñ$È• ©jžÀ˜Z3Q„¤)18O7tŽ©¡È­ ö‚Ô€˜>ÿ§¶ µp©óÝwï±Ù„”§í=…XU!…äû¿ü W®½ŠÏ†U’Ë[7ñÂ7=¶k„””»;èVÌÁ£]n\»HYŒÁ%<ÞÙãÑn-$w'c.lnÒn÷(«‚··³s»^Ñlv 7V.aÒ”ÉáýÉ!Ö69È2F®&I où³ÍÞïßæ+ëžïÞNØìy6––ÈÊ Cë1vHä;(£½ç­OØZ¿€ñŠ£ÁbÉG·It”Çy‡uŽõ üöwïSzÇÆò*ÖU¤I‡Â´º]ªª¤¬JÖ.,ñ7ÿî-V;ܽ{Èŵe0 LJïbâˆv±kÖ¢ˆí|¤N›5-’þÿgí=‚$Ëï;¿Ïß=—™•e»ÚwÏôxƒ!0ú%Áå’Œ•‹(qCºêªƒtÐ'¤Û†Š ic¹!‰ZшäÒ 9€˜0Þ÷´+_éžûþ/³²««§z5••öåÿýîkð’(f¡­w(¡ݨEÊÍùª©OÇLÊ)Ó٘ÃCToÀ~=àÒ`Æg‡·˜–Ž§‡Lë1£Ù“rÄd6bZN9#Œ 3)J ”œëµïðɽ÷©ÄkƒçÂYDåº]ädL´$ÓQ¡ž‹ýtmßG÷uø¬%Ò(!Mâ¾á|XºÞÿ¸åýYjP\K§g.hð¶­ïSkœË–cÉ<ÑŽ¸•N„iþ7ynÐúl¶Íü˜ãl–Sóåû':`­§Ð!&šVrEê ¥7:v&SV“Q|¯!Djj·ï¼úíï¡®>ÿòןzåkœìÏûýaès?ìñ¾VÇCÚÎgÝ÷ôû:+0ŸN,þ]ŒÄlS£ºÀ«”ÄyK–§äyŠÌDЗÑÑïÙúý%,F£S¤4(<^ò¼GYθ·´@~ß»s‡Ò+VW‹9„‡ùã-+y'õ¹˜MLø6Ц–$)ؾú8Ͻòó¼ðK¿D/$H™ðâå ^òßÿ?ÿ ?÷ÂWáþsçlB‚ÒÈnž#¥¤,K²¼»¸?HÍ“¸¶®0IB‘‚tUvLN{pC éªæºµ¤YuË£;;I’tºÕ}[WS@QU5Ö:”6H¥QR‘¦éÂCŠ«€.8;kÑ&‰'*Jo&&¶’-ÞRΦØÖQÎJF£ãñ„¶iRQô¬¿¹—oÛèÛYX¶Öw‚Ãè(zaŒf<:B+M]×”å ïu 4ýÁ©²›Îõµ•”Ô­E«èæƒ[Ì£æ߬s˜Ž"–ZÛ§THžºô$·Žß! `U‹èàʼn48*¶7/@–1Ò¿Áõç…ÿõ[wx|pˆLŒT|²ó.»eÉõAŽÏRööG õ€÷o~ÂGûûLdà‡·?æù—¾Âîþ²¬ÇíƒCŽÞ«¸ñòã\½r‰ÊOIÚÀѽ]¬ìUÖâNY/Ö\LJFUÉKE¦'öXï¯óÿ¾%Iõ„Ç6>-áÓÉm>=¼Ë~[syí<~6ã`<Æ Ï¬œPѥƬ³Ü¾{D}ü£Ñ!WÎ_¢)òÞ€÷?}Ÿþú€²š±¹6äÆ㛨Äsñú¾ÿ)ß횬åÒæ—Ï_`z<¦ª*ò~KYŸO¦cè4ZeHm\/N 2'ñ(š¦äÜú9²d…±ëñìvËý;Ñ.±œtV¢fÀt6Â:G¯ßÇy‡†Ä”ÌŽÞäúó÷yùù'RÒŠ UkR#Dk‡Ø¢M”À[‡ÿšåÃ;‡ŠºþÉ÷êYϧ*çÓ•ôIˆH—l›8X¶œ3HæbAg¼úýŒ¶)QªSxìéG~žùûhšš,=é.?.McÒ`¢jR 2õÓ+`w2bÅŒËóÂàÕo½†ºúÜË_òå_=3è=ì÷Óæ¬jûô±|âvÿÓôtp>ý\§·”Öòø¢'P–ø‡‰¼ä^¯ IL—ùÖ =ŠD2(Š‚É蘢ß#Ï ½Tc›–$KÈ3…’)½þ€^¯À¹@ÑDΤѬ®­£Óœ¦jÑê„ïíƒg¥Ð1þ¹_ ~ï›Á[‡‡¼ÿÙw8ý€¾ñ6O?ö"Áÿø'ÿš—žz‘ßý€+«·yrëKŒ²qÃ!z'‰¦jZ2#ÈSÅÑÑ”|¥gI´T´ÎN½~ÛÔh“ ´¢i;Û»Ž¯<¯4—7•hÖ®Hò”ºq¤Y9‚€$1Ï]PÛ–‰b!õH—˜ÉË!BÀ APqM¸à˜–†ý!—h /\vŒö~Â݃³³÷ßþà&ÞàüJ©NDzŸ±ÿâ%I4Z@ÝúH ‚›oŽgî™J „„Ê«ˆ; ¾ã€ûØÉ:•DžÞÇ—»¢Rvø)XMÝàÚ–$5$Iý/@FÖNžÀcÛ­5½^†ŽÄÚ¦¡(RƒôÂÓñã$ñ‰Zø§c†µ-J¬QÏ_ šÈE…÷wÎ:„„;‡w¦  ¹8=]p~eœÏ z?M0[~ÌY³à³‚èY9Q®„Ϻßéçý¼@ÖïËÇ<+kë y)yž"CT3Æg<©‘h©H³„"3˜Ä hÍÓ‹<6’"V RD$M» æ£0‡µ™f¹r­UÙœa8ÿì.ðìµÇyãíïðâ…‚àÜŠåV»Å…bÀËO>‡ a÷ÎqïÐðãÝ–¿ùÞßò³O}iA“šÓÃíëQF’&†Y[C¸Èí¶nnÖÞµEŘH}*«º›/‹°m©(kç-ÞE§)»6µ‚ö ÞÖø@|N“ Ó“æ‹ÑÔê>k7k-¶mÁ{êº%‰V©¢)|¯_,ÚjZ'8[RÆdIêëyÑCë@ï"‡¹iêng‰úèÖ¶B[*¢K”u…–‚ÙlBZô@ÆsR5Ž¢7$+Šèg¬e4pïu]1«J¤VݬW4Mäe NÆ<‹$°>0imÓ2,4ÂÙ˜¤Ä“Þ-!Áù­Un¿‰ qÓð“{çø_ùO¸rqÛó*çdÿäŒmQk IDAT}ž»øïÏú|vø!Mh¹7šq|\óiö"¿ýïý×<{ùdr…ÁÅ_äÏJöþþ5„ð¬^Y£äq„¼}|DÞë¡]ËgÇcl–‘È)/m9ŸöyâÜud+°•'„É %S&ÆQ•ó¿øòÕ “& óÒšÆ)&FsÏVì7 A ÚYÍÅÍÈQÎóh-ÙZŽÆ\è1BóúGo³;;bc{Fxì¤ââê¡ mkY]ëóÄãÛŒ~% úID€7žEÀw>‚FY €§i_óþ~©á¸Ïdi†’`ÝùD¦Bš%h)«J ²4í”ç-yAš& Á¡³öýåsS"Ž(9£׋´FO¤>¶AÐÔ<Ê…K`æG¾ÿá«\Z+0b>šŠâ= xõÛ¯¡®>û•¯?õÕ¯}î}‘ãaÁî¬` '-χÚåãô‰{Ø}OWÍ«®?ïýÎÿÖ4 ‰V(“eÑ1iÐ+>Î'µ”YÌâlëÉRI¯HHEªD”ßLò\“ð$“É„¢(ðÞ3:QôrŠºóüÏë·ŽyìÒ5þ·?øcvª’®ÿ [¿Â»}gWyéñËH[6¡Ë˜‘0mLŸÛy‹@R½`¬E(©Y¶EŠÀ¬êОƠ“ )ª»˜Ó4[èߺõnÛ–r6‹Â'*E J“çEtç/t-ô@@*ƒšYYaLl“ÏÙÚ¶ÅÖeGËŠ[júŒIB1›•H%@(tšED¿Œ‰Ap-B&Xð^ uB‘÷º‹VtkˆEeG`Rlõ؃P8¡hššÂDtéYÝ!£$^*ëH‘‰ŠšáFÇ,>„¯ùá?üÓã[üðÓuþ«ßøϨ}À»9óá¤ZX\cÊòìÆuž¿ñ |ó]ÇŤ¢÷ØE~ç«¿CT¢$«Àµ —¹øôW©²C6V’KB©X)zôsŽ;;Ü›+.om³¹±ÍÑÑïíh„ãøÎ]ŽªcÆ턃Ã#B*ÉPÜMä?|éoÞ™rnÈÓVW†l¬m°[¼ã…ÍóÜ©ŽHLB›äl§±ó0ÎAP–‡yT{Ú9Ü'3 [›«ôtÊµí ¬®­Ñ.¢êwîMøô£}._ „¤5„ÇcRmx{ï6½"gÍn븺½†±Š’x¸”e\îõ¸=>qBu²ÖâË)øæy~ý9Åc½cn~BЙm)Å3ÃC'™9õ?»¾Áªò\ìe\(rÙ £)n.9ÙÉB Ȉ?2)'L§¬¯máB…ô‚D¥\Ùh¹¹ó&?¾ûß|÷m¾tý´8¡ P†^¦ñ@û©Ê F@¦¡læû¼ÂŠ8‚™¯ßeÐÜ|ßwÛ–GbR*¤ (£¨¦#tbˆ:ö%äBk ¾_¹&˸3D¨æ¿?¬Û*;LM–ÜßÚŽçXo×ÖJ}ÕCðsºåçS©Œ·<}þY>™ÜÞÙas NÎE¼ö­×æhí_ýÜ`õ¨ãtõúyUô½Ïé#„X¥,wÍ?¯5>¿}®=u¿Ó­õeD!Ðq˜Û(—ÙA㎵á€Oƒ\ꊭÛÐ!©½TЙ‚Ìg@RBc;ÐÖï=.X¤ð¬ôŠ(ùi[Žªša[ !nX[41±%ÍÉÅÔËÓÅÿÏ¥ &+0I¿;ï˜s’" „ÒYYɨ«&F¥,”êœÄ4¶©:'¨X&„BˆH›“ZGyÏà(ËÐI‚éÞ§VñïZITš!Bì·›4Cjƒ”gM5ëè'>r¤EóH°>DW-‹@0kÓªaZ¶Ø¦):  ±S±;£©ðÌZMY;* µ¬ ¹zù¸vík¼üô‹ññRÜ·‰œµy ^FPÏK×®²~ég¸uK0®-WVû4ÙQ`½4ã±gxóÞkd¸Ð{»)ýé˜=+¹²uŽsÛ°»¿Ãêp kÛÜ=>b¿œ’ôs>k=w«On¬rèÓn3>¬ùñ-xòâ67ÂN¸´Öçßâ9ž®“[õþ*Â;¦Àí½CŠÄ ­G'ŠwŽ'¼°u_6)†„àpRÑL¦ û«àâzn[Ï_þÅùÍßz•A.¹·¿‡IŠ,á'Ÿ½GªÆh¬w¬ö ëhÚNâSF„†€o,‰4Ú†ØKðÎò÷·/ñÏ^QìÞ¥r 8Aj A*[â}Tt[K6“”&x„Ôø¨ò–Í µ\ØIÆAÀµ5Bƶ¸_º¾Ñ¥Ï6-ÚÌãT·Ç/dÈÅzß:~HlñÞã¬í*ë8ÊZàM„$OÔ}Ék|¾¨ ‘wâJu{¥„V L‡Æ|U À!@Ãö0ã°Øú.EšFº(ðÚw¾þ< ×£Ž³ÚÈóÛOŸŒÓíéùc~š¤`9Z®Ê†Ìþ"_ÐÁr"B q e3#Óù}ß±’Åcë-*Üä­w?c¢,û£ŒõÕ—øÊcO’‰õžD dªX‘²…IëÉüòa´`c˜ÐZ8®£¾{"J´©Uð¸ ShB€ªòL›°Ø£æ£ÆåϲüûüšýiâÉüyætO¥Ô#gÅóÇy !£h Ö (ßeygƒÝÃC¾|ñ ÿÇ«»ü㧉I°6îOêÊs‘ç¼xчpÒ–Û gÚåÇœU)/ÿít«óQ'5„“ùÁ¼]ºü˜åç]~¾ÓïåôíεР‹ÌoWJb´ ‘‚>@IAm­…¶µLֵɕŠ3~cÒ k[‚ DôaÞ£dX¸¢ ½²•ŒÊdEÝzt7 1*zGwãñ…V¯è’» Oõ}ÕÆüJDÀR„!ÝO‡@Æݤ£µ82šŽ,Wó Ò£f9ßøÎ w9>¾‹:*ùxÖ°½½…k=&1‹$"ØMHI¥«YF‰a°²Î®=ÇÊÆ5Îo&VÐ&C.Ÿ¢uÅî¬äœ\nSÅ4îïò™-Ù¼°MSµÔMC–fôò ‘¦x»¡å¸…s™Ä¶5ìs}}‹½ÃCŒ1Ôcέop|4æâå!¶ üå_½Éµ«ëQÒ×ÇõtûŽ2´&Kiêý´àNéÙmk&8îM†rʽ²aâ-ï¿vij¿°É¥g{ì½?A'’ÃHÖ4Rj¬lyqu ‹Gy¸xþP˜ˆ®Âì“‚YÛ€‰#)Å¢¢ô.0+g4mCž÷sn)°xQ£ H ‚¾±äá€vÿžî®]8‡j¨ˆ£Qú© qÑþtg¢PIa$ý‚”4¸Ñ»èêå F œƒÖ:ÀG™4V¥‰‰Á°©ªŽµe3‹IøʯG?çqAv öéX’ÉaDLÄŒ h)»Ža—Ä¥[Ûù÷¿¶GJ‡ž©üwôoùµŸbc½‡r ‹Üï}稫ÏõëÿÌ/ß÷aNWž§çÛÿžU±>ìxT;û¬ô¼ŠXÞ¨ö¼ºmQÍ:ùÆ“`’¦)IbpMƒI#ø$K½,Áè@jÁE ÄjOò“[wúϹtqÀ…á³qã•Ñ毗JŒL+‡'`ôɦ$¥$K"Êp8(0:¶µ!š¡ËŽ7 Tà÷þìßP$oP¨›LÆïãª7ð"D—™ªBg†­õ lnn1›•TíˆíÍ‹ŒfG<¿âWž¥ÏëÜÝû+öÆ5ç·ÏÑÓƒÓÒÅq4)ÉÑñŒÖûhN¡ãÉ”¢(‚…-bDûÛÆ%Ñ’YÙ`­§‰š ipDúUkB¤‘J•åQmŒ“J~ù»KÓ¨|4åɨê ++½®l9Úßa|J¾vÞá&IilK’ÄùùüœL&x©‘:‰B)™V-eÕfsq”åu?O¸½ˆ6¡‰‰r  »ÊèMéeãilœÍ %i[…2–Q ³ŒQ)8*;máøJ÷ƒùñ3WÎóŸ¼A}t‡]ßðØõ§cBjIš<°ĽEp·Lجpwïž¿œ1ìpÃL¸u4å¹­~´ ,aR1Ó+É £ã]„”<ýÔ“dÂáË)kE)'s4WòŒÃªÂ ÐH´÷¬¸>öÆGœ_Y£¬kÚƱ}a oY–ñûÿæï‘FpëÎ?úÉg¼ûæ.Y®yüòE®l_b}mÈÛÝãOþô®¶|x8àãìqû.üð톢/yã»5—3¶6´Î³r¹Ç¥aÁö àÃïí`Î'鹘åx`«?d5°:Xec¸N?ë3™M"{bi_\.ªBäx¶+L§,ó=4~?ZëÈ2PžÉd[ùœ$W÷u©$8¤$&'ÏŽøäÞ«üÞŸðÔ¥+,RFÞ~*bQѸcó÷é|d)ä‰"Q‚tîïßYøYsäÓ‰ÀYíì³*öÓ÷™ÿm¾`ç¦ @Ç…Õ4MocpN‰F“¦Š~¡Á:Š\³Òk1AòÍü)ǻW/¿¯ˆÙ“ìfeuã˜T-išˆi>³Ù”4OY1ëã²gâLÉ„€SŽ7÷Žq£?§0©0|¸÷1OnlpNÁ­é,Š‡è¡¬¬ô™LÇŒÊcpû÷ywîø]šYŵóÿü[wø§_zŠÖY\Ä’ßw^ë'Ó5IÔ$îÊ2¢ÃK5+I‹Û´87x=É–»uÒ´ç±’ý•2$YÞC«ðÐÚ ”$WžqYG°Ç|-v³Û,UôúƒLÐK“éDä1ßûì&mUqçömú+C¬ÐQÞJFq” O|°Ôu€užÙtF]×´mÛ™ž¨ˆ"2Î¥l3‹ FR#!pÍ ¡âLoþy뺦œ•˜¬Ñ:=„èGÝ º,€/ÎbmõÚ ²4Å»)¡ª*”$Úଧt“÷q!â"×Ò!•fZ9FÓï|lzâlyéºðÄ¢R‘¢SÖ¥O(m4“BÆÄÉ j Á´ºÏNŠÖIj F ”áý ˆ¨{­¦µ<ûÄsXî±R¬H½·›– j/hÔwvkV†+|t×ñö¡à…M4LoÞd¿<"%°ž¤\ì><Ü£HVhEEYNH²ŒÛw>†ªÁ(ÃxZSÛf´³š½¶AŽg\ØìñØÚ:Ê:R“pܲTc2‰v‚$IpÞ‘g³¦¢lJòAŸ•¢Gš”rüâ/=‡10X7˜ã·~ë®mmð­o~È­[Ü;âÛß½Íïü§ÏðÄåœ ——4˹úTÎמ.èoÄï,Qï[Ë ²žáÎGG\èçŒ ÏvRDàú…«”³Y¤Q9G¢5kƒ!çV7¸°qŽýÉ^8D8‘ÖkÅ+kiŠÑ U…¡³h·ÄAHÁhv̤1š3+gLÊ1Óîßñ䘦m˜ÔSŽÆû”å˜õÕ!WSv? ¿ú¤à‘BÉ–ÔHÊ®c%bI Î#º±Mœ…GDx–è8‹î$@…ˆ^Y¢É ZÆ™u*0´YB¢ðõ*¨­GŠ¸Ÿ/ïaŸ|õ·ø?ñáý¢‚^tYeôT?í‹-ˆ–œÃôS¤Q–×?¹‹TŠ¿û¤¤½Éó‹E\RJwhíç¿úõ_þ%–aæ zŸ—a,W×ÿ?mð_þyúöÓmŒå h^Á.Ï4ÒÄàƒGxÏêÚ:àôS$#a˜)´·Ü9<à÷¿û¯øÏå¿àé'~“K—^¾¯âëÞõ•¥Ii}7ÓVžA*Hd@ hÑJÅžd®»î@°üÝ»qûÖÿ‰é)´Pìíßâ¥sC|ÓR Ãv¿ÏÎdJª%eݲººÆ­»7qÁ±1Ø"Q ƒáe. fù uUóú½gøoã?`×N˜” «Z±äÝ 8$¹TuMÛµ¢Æoä9§yk-If˜MgXíé6êÙlÁd§FócYá'„(ê2‘jÅ8º¦×+Hô2ð-ƒÜ°sç÷îÞ%Í lS±p¸¨ÆU’¡Ó^¤T-+•í.%#âÚv|ØùXTšm‹w U9‹R„Á1›Íbë^‚­ëˆ.ï(a0˜D.t’Ý:4©¼oÝYk1I"ºƒ5]p׶]ª¦!1 Gšed‰êtaRF¿k ÈÐ"´>PסÂÂBò¾s/­‡ÚK,ú8wÆu¶ìëß»Æv¶šRJOÇ1?©ÌNªÞ>”ôÕ¸~¼óLŠ¿}?á¥Í '½dÂf/pµï¡­é¯oQ7‚µÍ‹|°ȹ¢Ï­;w)E…[y,„½Ã‡‡#jQ1žLHTÂ=Z¶‹œÆòüêJ-=©9˜qlk®õV¢HM’D©ÚnÝ·eÅ“[—˜V%™Žö§ãñ˜¼—²>\%O2•"…äêõ †«¡ny÷ãCn<=`kmˆ˜ÍØL.LÆcZ!)<³:ä\–°i4[E¤ùàÊc«o¿SÓ® 6ú‡‡Ç W‡˜SëعæÚ®±³¿÷3b^D<…\Î3œ×3d‡ã˜+-#%A„øOè‚Ý|\µå=ÓrÂx2bk¸ÍÁÑ·yõÍ÷xìÊS “•Î¢‰"Sä]—¦q¡Nê?Ía„Lj®ª«š4ËÉe¯:ëñB¢‚¥jì"ù=« ;ëxT¼r¶]Œ– S¼#3÷w“ç‡Ð?#8;¦•¼rñ*Gv‡Ÿ¹ Øîk!XŠ¯~ëµèJõä+_ûÜàwÚÅf~œ…†>}a?ªz]þ¹|<¬: ìt¶ù{ít`^~Lš¦½^AŽ,MðmK’ˆˆvŽ4Qlà~𴞺~#TÇ¿»ß¢/þ‹U#®FEžÊÅî(mÓÐÁXD[2ãg|ÖXŽw~W·(_ód?çB@JJUW¤Rps4áñ­uꪢ )2"¡¤Ÿ¯š‚"7x ZÌÈ‚c}ígyý³OùùËWpZ8[:çû“&"Œ„c<ª2$³ªåp´èa«ŠºG^£µ$iÞT˜•‰¹|~ï[ÀÄ9°o+ZkiêŠÙÑ>uU1ž•ä½RHzýD Ï” eعù·wvÐz@Ó”LFddÅ“ö£Ù@—xE38&°uKS—TeÙµÔ¢P]{M)IU•ÑÊYŒÒï9>“Ã.Pw8 ¡‘]b»Ð—çҬߵøUì*øˆ0&é(gë¢3W€è¤¥TlýéؤW:ÁMÝÖ¥WŽ•ŸLgG4¼– Á†”óâ¿Ôó]ʃȤ:d4óøöƒã7yw§åêÚ¹ÅÚž'èB2-i¬ïð;÷ã[ —’Ú¦^ø¦#I©Tm rŽPïv‡Ä´‡ÝöàëF^’X,ž#8²4~Îy²:?Aè%ÓîT*xêþíëòô†EA¿ñå»kT ¾û7‡ºþÂW¿~ãËÿèàüE3“öðÙAô,4÷yü©À•0,K¢Õ’?ðB¦ÑU(MªrF¿ßÇ;G^$äZÑKeTd ’Wßù—l­´<}ñK÷ƒor$‰Á:‹µ@$©hYíÇ™kJ ñŠ^0Rò»ßùczê-î ²á+(Ûš¦n¨Ú™D‡«µT“ÍZšÒ7Šwo³éç,I¿à潙̠¿Å¯¼üOxæÜy¤(!©:÷šå÷ˆ‚!xf³ÈEn\ µg[úƒ¨¡<-k¬õ(mHÒ¬Ó¼UXëÏL²æß] >m›( â=¡SÒIBÒÍæ"®i¨«Çû»âQ$YÖÇ©©1)­ó˜¬ˆb#]û.„À _M9-ñ®Å»ödŠ¨y]Õm'P"PÚà‘´Ö“½ìK"W¹m[è,C¥º_0bûÜyÒ¬XT4ó5)å‰;œ$ˆQšU º á]4ñ(d“”JHŽ˜‡:p‰ÀH:-sç=Ö;zEŽT1øŸeV—kqÝÖÓH ž²qLkMë$*Ž]¥¥ç›_GY7Šyà -¿ÿý›||sDÖøÚõ +½–Ú{ÔçðAO_OãéŒOnÞâ°i™M>¾s—ƒñ"W[t‘¡D<¿pmCªSz:eÅdˆÆS5 ý~‚à°ž±ª4AK.o_‚ʱ>Xe˜8šN¨ë–~¿ÏÝ;÷Ï&ôëY¤$*27¤R z=îíìpëðÏßx‚ßûö!¿ùÊ9¶²U6‡ë¬FåŒ^ž“)…슖³¾©$¿·Ïõ'6㺑ß{°·G¦3TˆŠ}sw¼ùá¼gss“{û;Ûˆ IDAT‹nÓò÷³üû0-XÍ2îU3:REŠJó¤ÒŽ¿ï²J&nóÖNÁõ­­'¥ 5’¾ÆG%¿ÏÃ=ìh›†$=q¦ŠJ}P7é\w:ÿÀB iù½Þç:û’¶µh5 '÷MŒDwßß*t¶“÷?ocׯ¯âgŸ`eXÐZ/‰àÛßøN¬œŸøÊÙÁù‹æ‡Ä˜¶Qœþ§_kùçéç]¾}N­9ê^~­³žÃûè ,D\8¶ièõzÙœµôsÅZ&I}àê•ŸeuãK¬õ%„"x­¢ý\O‡ŽÃ+I• “<…Á7ßý1zú7Ìêš—¶†l¡ 2pns‹édŠ“ðìÅë`=ûÇG”màpÌÑdJ‘’Î_zØË9ØXßdÁûŸÜä­Ýsäâû\¹ú2ÿò/þ€ç®>¶DžÞÒùI 4møn-A]¶ô‹RÞåÚÆó4¤x|¬Ç…@‹š\…Žì4Ñùz|ÔjÛS¶‘±ƒNÓƹ°ŸÐ–öÓmîùï‹%ˇ' û˜9øq©‚öÎEýíSŒä&JŸÎ>x|"xý­¿a½oP^Ÿ¾ !„8s¾þâÏ~ýÆ—ÿÑ}<«Š} µÁƒmìG‡ˆ/’|Þó„S ütµ|Öãx=é-Fk„ìøÈ&z ½ I ×KɤGøþêÿ"U’ÏŸCuú³<„ˆ‹œy†µüH‰!¶qþáÖŸqÁW<‘¥H=B]k)Òœ²‰¢Û÷v7¶n¹3™r0Hq¼¸¶ÍñlÄÁCØ9±µ}Ž÷î|Ê“Ï~‰§.j,‡w~Èß~ oî¾É«oük^yæ×âœp±ZURq4š’åýØêm-“É1ÖuÚµóª9I:½jÕÍT=BßïÒ"¥ì:)½"g|tÀèèeÒˆ^V:R«¤¦(zôŠ<.~…<¼sLg%­õ4­CCš÷£ÂW’EÑÛ`‰VhM)\Û°··×éa7MëAj”ŽAYt#s´ùœk-E†"JQzgÑ:A[ÝýNÀ8÷o"^@p–¶©@Hœó‰JçËÎâ½Cë­Tº‹þÓÎ6¥®!xOžF ‹˜0µ$i†Ññ3”U$V£™‰Á3ÈMl©GW\yJÑÝý·ƒ³Ô­ãàpLãâ<Þ;…UdÜ€”´­¥iM-IÒ8ÊhZ‹I eÙÆjBœðkB[Óïe¼qÓ²’ï#«& Ìg_:±"—&͘ƒý;<ÛëóÙ½;|¸»ƒ=šPd«\è­c«1O]–à$“É%ˆ&ZI® ´8Ž‘RP× Þ{ò~Áq=e{k“L+ZçYÑRb´B É°`+©¨ê’,v‡£cªàùðƒ÷øë×=?óÌíõu¨ÅpÀ¨š(Å0_aæj- æKAU¶|÷/?aí\Îp-vâºêÎSèPçJ°{pÀêúz¼Vƒˆér€"MWÙ;Ú¿¯2]öe€Š #Þ 'àbÑcKVSÍfšr.K¸ÐÏÕ%­tlêÀå<çJ’²šÆÕ1Ï×9Ÿ¦4mËA;áx6c%˹½óüÏ}ßøò“ˆ|âAŸ ž$Â’hM?ÔÅËØR_^7gM]ßW9¡«œŠ~FU5 }ü³Æ ËúQ±g>kŽÒÅ~¸˜my&# ð¾× ”6ÐÓð€–:-ÕdÊz~ÇDg¼¬ÝÌùú çÓÇ\Ðaù8†;Ý¢8ý÷Gž„GTÌ~©÷'§«÷åvõÃÞσ¯‰IL¿X#=Yž¡Eô_®e³o(Û–uûm¾÷Ñ„Ÿ»ñ<­z°5ñïzøÝoü1/­9¦ö./?öo~ô!é àÆ…Ë||÷6RÌܤÝ{ôÙÁód‘Ñk5By†EAëZŽŽgÅ!/æk|¶?"(˃šÜ­ðýãßæ—®<Ïó~S¤–“žª qÆf= q®a2™Äà—eGÔ B ÕÜø"f´>„û\WzEŠgvïÞ†àé¯n¢Óm &I¢˜”äå¦+:™MFIyâ\ IRt’F¡!è÷Qìb2ὧª¦]Ò LŠR¡ ʘE幬Bˆ6 Ý±ÞEþ9"¶·‘4MKÒQB¬ÈtÛ6(ÝÝæÞÚn „Ô4u¤O%Fw€‰±Cà½Ç¶5®.IŒ¡.+ð–¦mÁ-6ë´ÈJ_2d° úYtÞê6ºm)Lä$牤Ÿ Ðú®™L&LjÁÞñ”º±ñ¼t¶uQ”!ž¿9Š½­fh­ QŒ'“I R!µ‰ÁÛKyâ\ “†Tnlžçý{ÍÇèÎí§¾>B@‡„<rè·§ˆá·g‡]ƒÑÒ0Þ½‰kZ²¤G%O_¼Î»˜žæù+OÉÞñišžTXÞr89fÜ” ³>mÓ°1XÇ5ŽÃñ1½,§œ•(¥¸»·ƒÉ#Ýíðð§$"ðwß¾Ã/ÿú/=õ8™Íùð푨{Õ„Aš±6\çòÖ6ÎZfM þ¤€1FqãÙ ŽfLG–¦qé9:(6ÜýlŒ6 ©:3N'ìîS$Y\36ê H{£ÃÅùš·¿—×ôò>h¤!OЯÚ\÷Ý µá\–3/m—ü­%=Ë1È5òwFôzëdiÎSçyû³·ÙÞ~-Ìâú™¿¦#²øéJ… ”hΙ«;ÚæTpî¤2ƒˆIŒêôbGçAÝŽ³ŠÇ/ÒV÷!²:œsÕy± k"uržAGç’’L=XTJ¥(m@Ú{gR°æïëµoÂÙ€¬åãtÀ;냞õ!VŸ>Î ´Ë@³å7½üó¤át´ ˆ8ý~æÏóÀ qÝ!n”b…PV”³ ÒÃJ‘ôeàöhif‘ˆß>øZŸwÌZF?g¯‰õXÕòßü«?`ë\ÃÌ f‡¿ý5.\¸À Ö-׶/áÃÁkY¯@×/¯éKM/‰ ¬g¥XáüÖ«yÂäÓ]öTÆæê9&3\9åHZTHpÊ­ö;„Ö rZÁ 0H­È{EÔïÕ)&KIÒÈV:AhªY—]FAx:aƒ…ƒŽˆ¾¶EÛÏý"åø`à­îDØ PÁLàãýÏxç&ìÜäƒ[ŸÆs‹s9O¬–Ïáò>Y»À{…tà¥\t)%"€—ÕqÃcBu²cÔàáå‹8Øù„ªáƒd=óüè½ÿ·îÞŠÝÈädoWB2—…È¢ØèEd6¾yh 8}Ì“é~&ÈRE¬%U’A¦è%Ôµ¼Æ–×ש% zSßgc ‘’Ì‹ ©#êjÎñÁ~à,ç½'F¬}"·*„`0‚w ò­`ïÑCªÆ’ ÖBà•r¹90¶%R*” ½ïú³e A:Õq–wÙº\ÚBöû}L]Ж!¨×UIÓ´Ák×zòÁJP÷ZzÁ.ècaœI‡òw[… ï]@.BI¼5XçÀ‡r—RjYþ 1…ijDWê^€ƒ¢XŒsá½´V´M³T8 T‰Ž²,H+j­‚÷tÓà]( j3›Ï‰à=ƒ~Œ´ «™¢7TŒ¢`'é¤b=‡^äéÇŠ´¨±5LŠš½Ã)2JH"M韹±ßl½¤iUÓb¬ b3: æ£j-ÓY‰CÑØð™E—ÙkªÂÙÎ踃³ ×.\g\ßF»ˆÓ‹Óóª^Ïš?§_µÖ\ëgŒ„'‹œ5äñˆƒ£ “¦eR³ººÞUD¯¿ø*«½¶ïßçᣇ\Z½@ë,½á*ÓÆqP‰Ìc,û´„@4™ÏŽ†Ü{øµõ5ŒiIÓ”y]ñö{·ø_ûÿð?¼LžåÛ;‡¤yJ’)R±:X[^-5Å|Îæh©4Åd‚o-7®\c5Yakc“¶-¸ùÒyÖ/¤h­:Õ8OÓ8ò^ôTëNkxÂJð`o­‚ŠÞé@ü¬5õ´Ôîéùÿ¼kö<§)´2QœOÞßy€5–¬?[£ÌþâaÉKç¯ üóÏ/DÊ&Zk:ñ”§×¤ÏgÎÝ3D z‰Â"‚vµzR8êÔûˆÏç/zÖNo½ýÿºª‰;míÖ^öbý€Mö Ú{‡V‚²|xê=ÅS?‡Î•êÚ—‚BØÙÅÙ øEeê/ºùÏ:~š ~zÏ:÷³ÊÔgƒõ³2ûÅXÏ"µ³4EO–'AŒ ‰išŠa/#͹–h,Y,ÏTHîì¼Ï­ÇñÊå/aœÅb‚ÝßsŽe‰Ã÷>úMöŽÞäÜÊŒª8f”ÒL©ŠGíŒË½c~û#ïmIî>xÀt2emuÇ;»Ì«)_zñevðÖris‹^œãZÏÞÉ‘efÆ|r2&_¡#‰ð’HF—Š|¤ùö«ßàßÞúˆ[Ÿ×/|H:¶‹1ÿê{ßå+×®!墿Ùкà 3™¤€²n?¸.imÌIÚ{꺷¦ 2Jâ¼'Öl›œOO8>Ú3zÖ¢¿/$qÐÎ☶.CP´kÆ{¬´¦$M<>€šê‚£½&“Ú¦arrÞ2›ÏÑqì7½06ÈjZçÀ´` ÕlL[µ=*˜hà‘Ž:)NÄù }Aïi– döuUÇIÐAÐÚ4gÎÒÔUgMh©ëš8Ž2\ƒbvÂìø¶*ñx’,Céëgkë"Iqr2'K‘иù1ÿì=Ï·®j”°üæ‚ïïNØ/-³ù šò¯þÕ-Š“’ýÎ}>8Lïnówþöu^8…÷?¾Zq2?f\N µDIBzfž¤LŠ‚Õþº­d=ÖFk WWI Ì«$ŒúC&³9U[/õ´{ÃÓ8âäóúõ‹ /íJõ§×¸³ÏçcϾ.ÖÞÓ ÐY¾õRãÛXš¶åâ`…½rNUÕ¬×pN°p÷àcþð[äÑ:†=J_£¥Äùål@»5\R@§µybm«uDU•–O_‰ókI/†X+æeh/AÀu]oÛاãÀÓçúJëéÔ¡¸Ó$éŒÓƒòÞâp„ñ«3ÁYJϬ¬Áîñ$(c¥$MÛ’Ä1ßÿî_<ÉœÏîôë“ñ=?øžíûþUŽçmžµÃ{V`ÿI»½³ÇÙàvž:ìj´!È"ÁÚjÈ7$±¤9 üÏÿ×oñÆϪnù­¾É¿óêÏ¢[…?+óŒãýöo‘›óÕÁJn$)[½œK:â|’rP•Ìë’íb“™»ÍFža*ÏÛŸÜ¢ÔŽÑ`€o<—.^àÒèÚJ“ù”½ƒ=Dü€­1´J0­ÆGÇŒ†#´rumÌjœ!˜±9Øçë?óp^ð?ýæ¿ä΃#þá/üu¢$YZþ “©Å ˜Ìk´VïïéI/* rž hú±­ nVG/ÆY’€ðTÅ”ÉxŒõ„Üߎö´(©™¶eQÐÔ52JÈò~Ò>Pž¢$øIëHc­£­+fÓ ¦Ën›:p­«¦Eê4Èav×Æ[d3› œÅ9K]̓ôiY`MÜôø¥hˆó-ÖµK„¦qA`ÄšÑZÒ6ü笇haâ!@ EÝÛQÓ6xßq­[nÓ$¡5Møü~ÑS4­g0Å1ý~/€cI Ú²"’°¹1B{G?Ud©â~ü¯ù›/}+d¼.âxR"uLšåœup¾êzÌt  ëZE  Û‚Ž&e0QJ-Qø®keíÀpŠÆµTµÅKMkÜçzÐuUñ3/}•Ç³»$to%OÇgQ‘âxzLžå(¯:ïíNk.œÆ1è8cÛ<¼·ÍFÚÃq /_a£7d÷ø¦©I’[[pÐöH“˜HGeEاœNQJðË×ö ü£?­ù~eÀ—R¾vµGR:¤©ð¦aý’ãÆfÆ‹‘æÆKWyùê„ŒòýµŽgGdIB!ZæÓ)ý,cØÒÖmp&s)"šÚ b͇w>agg—Ñh••~}ôUYa\À1XkI’„½í)ÓIC”8ò<_ιÓÀijUÃÓÊa‹ÿ/uÍϬÛ_ÔÂ|^P_|-¥$ÊbÖ£˜ýÉû³cD?#£G,—Îßc÷ä=þòÁÛ|÷ƒ‚¯Ý¸†& ¥ýÓçw-<½TbL°mRÒÖõÓˆí3Çr¬Î‘Åx׶  b­‘Xb@“U]c;ÄÐé8túÚ,ÁEulùOéeÒÑZO¢»øØý~$ƒµðéC¦‚Ïîÿƒ$êûžÐžW3¦“)?~ë½€Ö~ñë¿ôÌÌx1¸çÕèÏîÚÎÞȧÞü9øôÏŸ]êx6²îìø¾hSp¶,§.¾€IÇãbÅheÀñÉ:´Œ1RRÁõ+×èH91B{>ú˜¬s²÷>wë-þóo¹0üðÖÛ¼võÅS×æ ϪۡnïïÑ®Ñ4AKégm "á°m…sž^Þë„]JFW)ÃáöNEI…Ô12Š;«ÇÐWFJšºF/R+¥‰“”^–Q–­q$i†ÐšHJ´TAåˬii뚶ieE´Ž‚@Jc¬ÃÑa ¼GHM%*ꀤ(Ðã­ó$YÀXÎâ}'r#Šé‘*Ò{Óôµ”x‚k·¼P×ÁŽ2xO+„”Ènƒh4uM1›Q× ±x!‰âtÉe†Ð¥kLM=›r°³Ï¤h¨œ&R7çá/?û>¯]}ƒi!8™4ÄYÌ­1X/X„ :à šW=›÷¡‘Ž l¬'*r§ƒ®µÁîR‰Pžk­Ã‰RAŠgBb­¡Ç|øð=†‰ÀIO"4-ùÙUk˜´-ÃhDejâ.Kj}ÃýãL« ÇK0WgYYîñ×.¾È¬ƒpl[eÿxʇ۷¨N*zƒœ7®¼ÄýÇÛ̪)/^¹Îüè!ó“1ea™× q¬HÓ”õሣƒ”üòë+´ÖɈX÷±ÞpñüeŠ™å›_y.^ekkëÏ“Hͼ˜Ò´Ž8–\\ß"Ž¼‡ª­Y­°’h‹–²(íi¤Æcöhc‰Ž÷nȘïˆûYX—÷DJò¾äÖû‡ä«C×R{»].‚ð“{b—x‘éÏåB?«2ùEkøéjäòkÆs®—s%é±|Ìîì€Ö”ôû£@ýk,£XsumÆÎÑû¼ÿûìLÖ¹´>B8‡ð6è»K‰w×€4ÆQTUÐä!5Ì«Ï%h w;I¢%y¢‘8ZïÁÊàµm-±Vø¶Á¡pODÓžYÙ§®ÑrãÖ¢•@uçi ‰BÿYNÁÞý3Æå€Æ Ú`qÜ›ÖR·Ó¶ŒVF|÷þìi´öÙ ôY ô³7ìYAï§)kÿU¾¿8ÿbgOÛG>¯DþLà×™s­Iç’£µFË`nIK?OHôb‰W‰ÓüÑ»?`E7_…ïÑQÄÖÀ³’ÙÈÇìN>åßý¿÷ɧÌfßç ¸…->dCµÌë9u;C‰°!Ð&Lª(‰™6 UÑ‹û\Ŭf'\ì[ñÒªbU§¼|íR™°žg<¸wŸƒ9ES“' »'‡ÔÞKÅÞ¬å³é1*Šéå=ê¶%Š·ÔÚ–ª.(«)q”1?ÚæÏo½Ç/Þø:¯¿ôÚË'|ÜÖPÛˆ\×*Ê‚áh ç|'Ëו¥B+Él:!M³ Òá-J âDbª†½ím&“I§¤ˆÒIÚ™HøE6¨¨ÅI‚Žc”ŽhÛ%û»Ûa¡Ò1^².{VZaMC[×TMCÖë¡âQ’c Æÿf¥4IšdˆH#• =bOÇö/œ÷ÐQ0óȲŒ8‰p¦]öÓéäö¤R$I„”!S>Ü}L¸ºÔØÖ`L»”<»˜¿(!ZÚ¦Æt à©5d´kjÚª`r2e: æYÞ§1Žª14mC)®÷_Åá9œVH“õ²å3[ÕM@Y«Ï›ÉDQè÷óNª´ >»‹±œ-.榔냩Ig -±Ž1Ægá9©ª’<Žøgßÿ„×.Ô<Ú¹Ožç<>Úg÷dÂøx†‘Šî“õB[Îí£‡|¹¿ÆÕ$E;ÏÃñ£aPÎ:¸ÑZ¾vóU6‡¬­n0›ÜغÄ_ܹÍ0Žølû¯¿ø"k½å¼bo{'”BmƒÔ)É §Çlß»8æÓ1ÃÁ€“YAQÌÙ~¼ƒL#Ý;fwÊë¯\äø`‡µÑ*{Û·™LŽPjÈÆÚ%4³Y`¬­¬r~ea=wŽ[>«cvf†ÛÇ%7{Ž¤Ÿ°±z‘­~Êä¨áÀk¦mÂæzŒm*²¨RÿãVx®\ðæîs2€^³ÒËiÛ€«hš<»õï4¸ë´\ñÙ5ól/ÿYúykíéõxÑz°„ägÇ\ë˜5–ãâýãCʲ 6‘–()èÅ JÝæ;¿Ï w‘Q–xzà K/‚H´ c¬sHM×|Þ G/VÄq[»Àÿ(ZkÀ}q«õ´Õé¶A¬ºŠÆJ¬$Z¸ÔI´Ó]zÏ;>ãçnÀ(²4´—$qÂÛZ.$ZÆXÛ>M¥zÖE”ȲÏS•Î)©_ IDAT§‘ÎögøÓ?{Öï²îy˳Þïì±ø›Hi¤‚4Ïȳ˜XyÒX0ê§4UÁÚ0ÃXÏ0èeŸz>¼ý/(ë1Þy²4lj†ÃãƒP2µ-µåÜPòâŠc”eDRððh£Ùö´86}‚Æòò—¨Ëþñ ŽÆø4æÂÆ9¶v¹–EœþùÖXÙ¬ø›7¿ÌîÎÃ,çÁ½]¬–è8cue•~Šm,IªIÄîä+®¯ x|¸Ã•TsgrÌÑî>¥ ¢Z+'3.¬%ñ ®­œgæ°(# ‘’•,¢µÁYÊzOQÕ $M]"‘HEI±–ª,éõ‡x!èçqÂxGÛ¶”³9ã“ ^)²Áˆ¬·ÒQ(ÀyÛIC†§®.+"´«½wï1\ÝæΑtŠ[Ö…2uUH©ÃæAk¤Òá\*¸é.@/¥ÛÀ;®­AiÐQçé¸ÒIÕµÙ ¥%shû­µ(!pHŠ·–þ`DUM)›–2í6 „ݾsË m]ÊÖ4àBEEÙ¡@;ç4©‘ÒGšªœSNgÆÕ[!Íû̧3ª¢àx2Òh Þ´œœŒÑqÊiG6!iš€wôz›ª´€6×…˜…ó,Q°Ëù´ØôJ‰Ö1Îc „'îL Á¹Kg96Ò}înK.zý>½Þ&ÈŒ·wÏóë¿ðŸ²w<¢±‰#‰+'üüÍW­œãý}@›Æ +8ë鯟c*%ß¿‹šVÜýì1÷Qž”f‚ó¹ä¥ë7•gr\á÷~ï^yq…“ãCŠ¢ l Â5d‰g|°O[¶l]¸ÆxrB–¥˜Ú1꯱yΧ–—Îõxy5ggïˆú±åzºÏ­¢Ç÷íók/naÌ„±ù;®@ÇALܶÈAŽT’Wožgïî˜G“–«r"¥i;“#<ßý½;4•áGþˆ‡ŸÐÄîÎHsxöûé2÷é²8°dÃ,’šgUKsÀ“MZxÎý2»´@ž)ö¦5J+„ s¦4%³rÊ´œ0è ØÌ$Ey›ÿçG÷ùæK7±"ðõhð2ÂIƒi,ý,%iç­ • ëBŸ×‹ÓÓ‡Gâ,‘Ž¶µ¬f[!CÕìÔ3}:)<Ý&8ÃZc:} "Èôc‚¶µ³U¾°y™ß~û.7Ï©`ã=qâ¸8LÆM•Lñæ¿ýÁOÇsö~ xÚŠîôO€'÷t9ù‹6_ôóÓç?ýþ_¤(vúoÏn Ø9€`rñ3G¬%£•XG¦ Q‘èSÜÍXòéïÒT ƒþã“1U[SÃþ¨Jx¢— ´g{ÿ1¾žò‹çÙ”’ËYFMÄÔÄ´d\LбfGYb'™4©0œÏúxQók×5¿õAY}ȵ­‹¼÷ñ'|²­Cog{¼MÐ#í‡,OXÏzÞç|¿;öÝœýUtc©b‰ k,uÓÇ=~¼ðòú—¸yq¡Uã`ç¸ VŠƒ“2¹ ISU´mCk=q’wÔ*8úyBUÎCV¦ƒ-f¸Þ¡÷6ŸM0NÐm÷‡8Ïr"‡…!ܳĂ4M»ª†dr2å_„7’(ôº=ж5å|8ƤˆU<$q²47²4pm",¶ã"/ʶJwâ#J‡š”€3A¦Ô)Eç‚s]UK‡gZ„’ÌgR­è 4wÏ{ljìz¨Þ;¼µDi†ŽÒ$ŒUwJeuÓé­óé4d×6,@IšR×MUR”­ 4@ëL°òt!»èõûH©¨æ%““1eÝ’æÃeF¾X€­÷Äb)¤°[Šª!0ÑMk–\ëÓˆáÏ•üœ%Ocb6‚€þ·ÖG1¿ÿÞ_"MÄßÿ¥ÿˆ$ÿ*?¸3çÂpÎvý%þÛ_üUð–͵uΟ{ƒíƒw9™ž ŠŠÃGûû†BÀ 7 9D9:âîÉ2·šr4žS:ÏK뛜ïm°}ÿÚ7Ÿ²y~““ã1ׯ]a^ÌÙ:žýG÷‚#š3lï±äT' =çÖÖˆ¢ˆ‹ç6¸yíI’1\9‡:Ê9<œS”ž|¸NUN™“ê„•þ:i*8<øŒù¬`mm•b^1žN(Ê1ßzý*£aÊlVð«/_å`gŸ¢-é%ðåMKBÅ?~[ñ×.3ÛŸpùÂEíîråÆ%>z÷!ÍaÃp-h8 ~mÈ;¹Ë¹­_ùæÃQÊþÎœÇ÷'ì<˜rñêÊr-\ »Ïú!,ÖÙEÐ>{¯Ã\ ó÷´s¡µvY:wðJJÁq]#õBåît+Ó³2gZ.­lï§;ïò§}È{÷>åüú—S¸‚4ΟcO9òX2k~ÁÉÏ+O±è‡ÿ+ ISWEX_„¤µO÷ëOÇŒ³1dñuÐ+PKerT!‹x²i-Y´"o\¾LQíã¥Ã*ƒ°aP½X ÄŒ&åÓ|ÿ'ç0ˆEI=x¶¼µøÞé׳ìY¥òg©z=+èŸ>ÏæÓcxV0OÓdYxí÷r´ (a×4ô‰Ôšaä*kíøïý‘{D¥4uCÙΩꆋç·LÀ§ÇÕš†í½Gˆb«ÄŠˆ°XÇ¢!±AÎM¨Pž=,f`,[£5®g3_óõ«_çÏ?ø„~îï³QÌ|2çƒù3Ýð -8‰¢$ânÕpéÜhί®q~°ÊJoÀ‰Ó1‘õ¤YÄÁÎÄyW¾´y‘7·×ø¿ð³xôrãbš–“Yͤ Ìåãi…Ò¡ô[L,š(é!„¢×‹ñÖ …oAJò^8}æÓvv(¦SDœ“Ö@[Æ,MiÛÓ¶áZÊÁ68A)„=Ú¦!N3„Œ– FÜeÎB &'clÛ £8€Ñºà¬„¤˜Ï—›¦^ÞÃ-„uµóÈ]LP¥"âNH$ÍÒ$FI(fS ü_kmW†vxÎ.Üàp<¢!J’¥šjÊg÷n³±ºÊþÎ6Ål|Œ%â…+•ÃKÕ —¸Úß ùäÓÏ8<žrùêóz‚ŒèˆÆâ~ÄJïBô‰²œÖ6TEƒob¦³}fÓ‚8É ‰®¬!„Ç6’•Ä¢Šš8˱ÒQV%Nµh‘ñ•MøÁlÎo¾+Ù\9a>.ôú|Xòó¯Üä£ý(ýæÍïÝgz^8¿ÎæÅœ­Ë9ýadnœïsáÊ Þyt¤HÓ'óÈ{ß ™ñ ÓëúÒ©í”ÐF¥u¼öò+$:b:Ÿ=4;¬Bà­ã¨žÑ –SœÐjë/2JÀ z‘à|n97lØ1»\X•¢,É“xbãˆ8!èE-y܉ü¤˜—ülü°›ÄŠªv(,•ñË*Ðéß=ýz6ÎàI,— Q§öŠD¤$LÜ* ’üÉÇcæeÄ«W¿Éýð®:f|rÂÖ Ïwþä/¾88?™tO\ANñõóvÎgëâ{g©Q_´C9{îŸêbùús;zïÑJ •$Ë“Î74oɳ”H l5¡?K|W½`â}ú;lfšVz® V™75W/Þ@zÕér//-{Ç;ø#׶ÖIœeV)‰e‚¶u˜Ö l$çz9‰kiZÃׯ¿Ê£½m&å!ï>žñŸüÊÅ?ùÑûl­µ¤ñ€<Έ‘8óƹ#¯¹¶¾Ež÷Böhëù*ý«++´µã[""Á¯¿ô2Ç·¹7ñs/&üá{wxýâkÈNcûpZáuÆx2§?0›Ìp@c?zŒJúH¡£pîî0ŽY]]ÅO¿×ÃZ Êù„£ƒ}æóƒ&Ê$izÑQ„L]aë‚œ[öƒ¼÷4M”Ñ¢¨s¤ .FJjtJÞ±tìƒÈ8Âú0ù½wÓК†8N–YøB.XÚšÈ(ÂÓq”!V2ô”»Rþ‚Ò +BŒ e3)eY¢uŠ±†¶žÓšP*ºï .]T¥|ˆ·A|>Ÿ‡ÅQJd¤qÚ¶AB»DOœ¥©ë¥¬fà_w¼Ï$GM9ŸQ”s\ÛbÛ†¦ €4ëŸïŒ¥§“$1hÆõíW_fb[z:c^V(Óš'}ð³‡s¡Ì—õ4¹‚ͬEièk‹Bcå½¾z!å×^û:RÔ$Q„å`VRË„ÖøPJj#H¥bkí Þ¼wDÜ_ãò…„TõÀŸÓô ‡³–+ç·x1‰X÷‚,TÎñí¯}åîÁiž0žOyçã÷ùÖ7¾E1m©\KUÏöµ6ÖûÜúôEɧå!y#¨'ct¢8<<áøxÂÖFBÛÓ•G™Ù’skëL¦„4mÃx:AÄ ™GlŒ6IÒ^0çÈz8g¤)óÙï5žrVP¶5.k\ ð)ÁFjùÆVÄÃù:oŽ-e:#nõdL³š3s†‡o²þâ ?weOÇL•åÆh“Ö¶Oe¿ö‡wŽ+iwÏ\gXÓ%H‘â^Qs.K—eîZYÚ¡µ±³·ÇÉtú¹uú4iQ•é'mÐÉ2´“D7ëº$K2„WˆÎ]ÊCçI.I]Áøèû{?àòÅoRK^ð E—µÊàY,±¬ó÷9.œß{æµÁYCc RÇÏLþž›v•9}Ê©-’A7 OÄò½báƒØ‘¼°²Âw?ºÏ7¯]æÆ 7)çðÎRWyšðöŸÿðÿ'ÍÉŸp|nWÍçï³2æg]ŒŸ&c>û‹r <ÙùÅqÜQmSá|‹AMGyG?—HIPÛêÎÛ7’¿ûKÿ={{û(+¹½ó˜ùtŽ3ösÕc UUuà«®×hMY‘¦AòÊÚœ¼qý%¤÷˜®)}¸‰¯Þx…ßùÞŸp{g›CŸq5{Àöÿ /m"ì“M΋ë}^eDÖ7×x÷áíÐ4ÍrBI4‘JøàÝ[¬ö2~feƒIU°µqŽ¦)989àBú)?ˉ´6Ì™Îæôú‡sŠrÎÉdÎáñ„Áh%¤]iØ[Co´ÎæÖš(ÑËÏÄŠÉø˜ùÉcAÖè G˺”שm ¤¤RTMKY¬ë\Ë(,ïÞ¢*æKGªÓJ?BˆÀ!^l»²¹µv)Oi:u¯]'ëŒ'ò,ÃtÁÈ{4Ä[ƒëÞã©ç“N6ОÂPJvej½,!6MÖ`ëzùYŒ1”eùd#éÞ:lk°Ý3U6ðÖXOÕXêÖb4&l,jcqB‡žNÚP«„ªj8<8bŸƒƒŒ1Ï´U]<ïeQp8/8©Zô@…ªF=YÌ}çE)S)ÉZ?!‹`3…Í|ï£ÁoüÙòÞÎ!µáÞúèO‰GE)Â9ŠÆ„Os<Š4¥d:á¿ü¥¿Ëðíÿ‚[ÖÒ=µnh­™4%µð4Br8sõ·îl³–äÔEƒm,£4ç¤8b÷`‡×_}‰Ù|ÆÚÚ¤ðÊk/ÄMÄí0›;¬hQÙˆÊy™Ò4–Ë—Öx¸]ÓÃp0d%p~°A/K¸¿û‡‡Ûdý',Õ>y±ÒËHÓ”¨Óo?::¢­jlÓrn°B/ËiL RP ÇFÚg½7\>c9)*Îxm£âï]ùÅ4'K~g•÷v׌úœûê éºæíñ„•8Æ'CÞ)Ž—R‘‹àú·þãWypg¼¼ßJ©¥”©”åàµ~¾œ“‹µ³,Kªª¢iŠyE]ÙÞ¦ih:A³­ÈÓɘŽìRôì±Ø¸>wí÷ŠÆNh]ÄÿñNÏKp-7Æ3È=_Äl=Kâø‰SÜé÷~ÖÜ8{xïiêú©ó>ÙÐtïqö¼½ˆÇÓ=¦Ø¥e,B¥Ùò^=•9?OHä‹‚áO>‚à‚÷OJgò_åü?éB-~gñP|Ž­$‘TH)H´&ÏÓP25†4MQBK¦%ŠSZ#ÄÂ#¬"»üM†þˆ|Ðgscë©Œ|q •’èX3Ζ¥›ýÙ„sƒ>º÷ˆˆ¸óè>‘Ö¬ä}c(Ê[c˜O+>üì!e3U-MÜðr“¿õú}lÕ’zÈ"’ºa#OyíÚ ìïî±>Xc¤S²<Èû:ÒÜ{¸Mºž±Žà•K×¹û{uÉX[’¼¦ÇgG_Þ:Ð’“IAQ[ª:p–+Yݼ@>\¡*§• uŒw6d¡E)zYDÓÔ z)´5‡û‡´’þ Q’u»éÀÓ\ì|3h)0m0‚ 3èžT·Ñ*, yG%%Óñ³ù $eË£: Îi$é7ÑÖ5ª£-a-m]#p$IŠÖ1iÒ¡ÇEM>P„šª¤(Jš6ô|• nVrÙ·ux8ëàÁ[U5x]'oIg Ù½ÃÚ6(uäb±ù’réö¥´YBYÖ@àRK¥i¡µ–ÖvHW/‚5žÖ4 M;'’’ù´`VµäYç'“ãL‚Ó`+)”\fÞÎ!•,P -˜ÍßeKÞa¼óÿò½¾zqƒ¯ÜüYf6¢h$R ŠÆR “Z⢜žv3 ƒ¡Ã"ýÑÚá¤ã×_c÷ðÃ\T’òx—5ÑòóWo𥵠Ž?ä“jŠª ¦¥A ™×è$áíÛ·8J3îͦ$½ŒvÞ8Ža|Яï÷{Ô&¸`¥YJ1/饽øèX__%S9Ys0=àÃHb‹†ªª™U [IÌ·ÏG¼¶>å·o¥ä7­ƒ„×Ö6ypr‚ˆžãÇZGšÞ0&Ë#Ú¶ýÜl[íªTÊÙNS;>›OÙ«kL’°)\Ó¢:_rÝK)ëc}°`m¤¯Y2¼Ôì—Õ©JGL;¥¸AÎĉåØ:g-çÖ=׿†óωBà]Pé*Z×UÈžý»B"-)›eîŸO+{–1‡ð ¤"ÖgÙ@-ƒFIKA+=ºC„{)øÒk<Úÿ½õë´Å.‘TLæÒ8åÍ?û!ËšÔOÒ0ý«‹‡s¦û?nÆiÒÿ/ç>ýÿÏÝHžVZÖ†Òu’jb-QÞ‘ç)óÒIôx•Ã™'•YDœ9Þë/xõÂÝHÆã1+++ËqÈX0ŸÏC 6Ú# »ÁŸY¿ˆÍq+)ûŠÍA‚sŽÝô-Ù Cz¨ªŠmSR¯ôˆcÈjÃÛ®ók/<&r–7._ÁLIyÆåsiæ-/\¾Á(Ò¨ã,U=GÄ’Éä„íƒLäøÚ+¯`8ë¹zõ*óûŸr±H’.L?ùÿ,² m’$Ì›•ç¬­%¤JàZÏvY"µÄ¹'Uï=–H(Ö†}Œ±Lf³'}8ÌÞûà•½ÜD²3OСÞûeùKÈð”?Ko½*Kªºê<3P²S;»´n¯ô‚¢(Âæ-Öè4A!PqŒà e(ÍâðžÝxŒ1ÔÝ.ùìswö™tÎÑ4Áõȃ®5ÌšŠ4MC†‡^àd:¦m+Ò|Æ×â8U‘1¦3Ññ° MXº÷dÁ©Ö­s¤7ÚxAc-ÖxÒ$˜Lç%q5&Žc¥rÛz¤Š8™x'ˆ¤bïp Þ†6€J8O–ýDÁ“Ït²ŠmS1›ÍÈò>ÇMÉÇû·Iw v}N[Õh¹ÂÉxÊÄ)âdÀ¼uÄBp83 ‡# ÝFJ›P<@jÉÀ¾~õ2IÕp»œpòi³ I ._a3¢”àþî6¤ßJsˆSjSo¬@QòèÑ.[7/ñ曼ñå ܼy‰Í^夘soÿ¯Þx™Q”³óè>ޔ̊KÔ( èR2)KL‘8®\ÜbwoÎùóç0M…ýÁ /Ç1ŸîÜãâpÄAÒ"U¨Y%ùþþ>¢ߺ^Ö|÷ð_ÎxëλˆÑep+·ê‚ .e%rìïž°ûhN-ŸãEàiš†÷¦fZL¶mqÂC剓ˆHj&Ó’«›kÜ:ž9Ë•á”⳦EØ–ÔYªª!–ð²ìãD˜‹ÒJEŸ €~1§~Š eàŸí'ŸŽ ‹Ä,UÐ|ÁY½nSÃLq4mñÎ`ýúÙYìÒÙ÷Z\»ãÂ2Ìc0Mh» Á¼òôR…#å“;¿Í—¯ü»dyŽõ°®#ÖÏÿ2ßùþ÷ø™+)ßQøյ7‚BØóÐÒŸû §ÎgO2HÃå½8|ʳ;’geë?9CöËB<?ëkkm‡¼Žée1i1È#¢ Ó‹5ýL#¼`”Œ$ÍBO\i8&Îrûñ÷éG>”.<{ý‚6`™Ì'LN&DIŒ1-Ö+l[ÒÏb¼3œ‹¶Ò”•Ž7km‹Ö ÛêÆИ†K£U6òŒG‡3D,ù`»àÅÍ†Ë ²8ÆG´–W/ÝD¸àPµ–æÌfGÓÆÝŽYjÉ»Ÿ|± Mcvvw¹´²NQ¶ö97Xå½ú˜ã“1«ýWÖ$úá˜×¯^&"p†éÌ­ô‰eÐï5MÅÑþ^E(¡¢pXk˜ÌƬ¯ Ä -;w©Û†²¨0MKã N{ÝBÞ¡ƒ­ë°Æ!°xoƒs”\c©¦ ´Þ·’cêbÊl6GE)Þe1GèÕ©Nµlì–B>Ù™wA?”·#ô¤%BGš(ÒxÓRW%³Ù$Hi:‡ó¢U \Þpzçhª©$UUã}à+:ÓÐ(k¨›& ƒ/ur[øEÖˆ eeeÄI ŒiqÞ T ¡PKå¢ëÁºàõ+|èÝPúÖ¶8Â[㨚:H×ö2tdB­qÌËš¦i1Úî³ oˆ’`€²xþ­mÁv¶·i]ð%¯*ËÕµo’oü"W‡¯òÆõëòèñQ6D8³„VÉÊ hE?†X©¥êvh €PÐׂï|ðjü{ä¦a$=¹o¸´yO?~€Ò’öóÆÕ«ŽKÞšü,¯¼þëÄö>ÇÍœ‡C†ç.qx´Ç@DüxÿETÆ°žhšY|½Åx6æÁÉcFù*ïONXË2ï9š¡úHÇ¥5ê|NÚ÷žåšõÁˆ¦nب[Çì(h£×Õ”ºñôG( ‡“1h ‡ä±ÂzÇx6繸¹‰r’½£Ò$"Žb.mœ£)-Ó¢Ä{æætÆË›› ´d£—p9ÙÒGìûÞxý¿æî†ò!hÏ0Í8l*öËš+ƒ÷o¹xuˆ­4­±Ä-ܛϰ^ríâeFé +¬æ#VWVöVXŒ˜œœðh6Çk‰‘Áõ\”³Sv‚1lÕ8ÇncÙ-+öª!5ù¹@'¬V‰:šãÙxpú0­AkÁðc¾rùet¤0&P•Î† !©v4^~îgO…BâÖÔì¸ÀŽp*&>˜ü丶!;oy =²X ¥äúW¨çdi<µ½ÄzÉÕË×øÁ‡qamHëjæÅ„¿øÞ›OËwþ´ù¬ ×Ùß ¯§K‰’…&ï³Ê?Í{ŸC¸¹‹¿}šƒvö\Þ{’$A©€NLaZ ¬`8vwt%’4ò4u³\xÀÓ‹VÀÿðÁÖ}Fç|zçÇŒúkOgíö÷9wn“²,px"ÛÐGóŠa”ÉeTu½ì‡«ÎˆAG1’„ñ|B)VY¼—ÜoòK7ªN© Ò M1§—E̦Sööi[Çt:§2–|°†Ž“$òŽ$Öô{9óÙ$Ѓš†ª,ƒñ eÀH‰7Ám)ŠB+‹‚ª*;ÌÎæ®›PZ%!p.Ú§Ú ú‡<õ³`ž¡‰ã:=ç~–ašŠj>¥šÏƒé†Ö:Š""ô¥OÛòá}0ÛhÛn¾¯f/(…ÖqǵÖÛõÜ;«IÙL´Mƒ1EÈ®çî…$Š’%¨-®” tð¦&ˆé,ú†iœ D .Ù®¿Ü´Á @*µt”ÚTD–õñmƒ5†ºªPRe2­Ã}‹ÂØ£8 â.Êš÷ž¶©™M'ÄIÂ`¸Êt>C%ïhÌ IDAT Mã)'L ÷(Šï!I³¥hÇ `-MkP‰>eUàɵ` þ÷ó»ÄÙHÌ ß¼ü+:ãÆ¥ïMx4>àwß½ÅðÜ —h¹+…ï›_çÒZ̹õ7˜W»Tó)y¾Âúê&ES7JCGlös¤ŒxÿÓÛüx¶K/NØ)æì—S¢|ÀaSã$‰"b/¸qõ'GSò¨Ç÷ÿô>¿þë?G&‘ˆ0u˨7bïhŸA?%ëõ™Í ÃÕuò<%¹pþ<©ŽÁÖÌfmpkæœLç$iÌt<Ãøë=e]±w0áýOo75÷æ3æH¶O&¨²Á×–ÚXÖ²„ññÓêújÆjÚçþ.¬Æ ½áyð–Ç“c¦»^|J/C@kZš¦!KžH’>ë0­!Jr.ôwÄÃñˆ+ëkØçheÓ™I˜ç•À»y[­ñÔmPå;-ûEŒ¡Åß ïAlLÚÍCCpLÕ°–fXÒ‹e¥@YÉ —nò¿Ë…‘fKEüðß¾õ$8‘²×" ?ɆŸ,rO‚±]ö– z»R†ïtÆü¬Àü¬òóÙÌyQ:X¢„Ó,Ð~Oûì Š£%%Qd³8¡—uæß8­‚½› {AlÄ´mXˆ¤ ²0ˆ¡0 ?üsþý_þïxë³÷™M>c¸²R åB8be4äðh;ôH¼ÄTß8¿‰®KN)&¢èiCp!;MÃNSR‰˜º•´‘Á‘s÷PðËç búÙ ;{{¼pñ“YÁ¹þÞÃÁøˆÁ O©¥ïJo…ó£ êªÆ ÏzÞã㦄|…dus.¢Ð4­¦ßï£#ÅW^ùU6ò˜Ú¬Š±B0Jc"å)«!Êù ÛHë<Κ`Åhj'ã#ŽN¦TCg=œ¬¬­!U„Ä2ì÷ƒì  Y··†¢˜‚Œ‘S‰¦,cB5#‰ÑI‚õ®³g´Ð!¬½ŒR£tÜ•Á TªÓüü@]Zˆix’2\³HµHJlUr|xäB›: ¿•¥vE)2Ž—¦BꦡnjŠÙÅK܃T tJœ¤ÄIÆ$xÂ/µ 2 ßwÖ`ñDILœ¦OÍ%­£n˜¶Ä5%e+ˆâ'DWî©#’8…E¿£‰…ëÐáK‚*NéGDINª ç¸+ÐQq²¸FQǽ~âÛ]Ö†²1AàE;’d6Ì¡†ñ™äôò>eÕ t̬*ù€,K:G2‡³ ¤ED)}úè{LÓ¦¢’°jöù/}‹ïýð¨Zòà`‚ÁòOßkø{ó¿á¥k¿À17¹qq3Ðì¼B©˜[_áÃÉcz¨V)Éh°Š—ž›Ã>펹µ¿‡æ¤iÎÞ¼æÚ ¯Qú%<Èà6ö þY{³ɲü¾ïs¶»Å’‘{eíÝU]]ÝÓÝä 5œ…¤DR ˜ eH6D/ôîg¿ð 76üâ[l‰4$A’)Dr†CÎÓÓ=3½wWu-Y•kd¬w=çøá܈\*kH¾@VFEFÜõœóÛ¾¿ïwÊ–Ò|öà'G<üt—kOž2œœpíêƒ~¼¨±MW‚ÙlÎÖú:ƒ•tKY—9‘éðüù§è¤Ãöæ®r̪@†“õ:8_áµæó'i"Ë`Ð#Š1®KVú]"%±IÊÓ²áÑ4§Ÿîú\I3º¢f$jºIÅǯrg³!J3æyNš¬p"ÇìM ŽËî^¿Çj·ßíiRîxá%!§°;+Y—NºF¿·Bì3?£ŽWîÒËbVW6hJKíCÔ¼PnZkË°¦‡’— w/µC‹9ÜÔc^€eñƒG5oÞØÁRÓ8…¢&–Ä)¼Rh)(­$$/Ù·µ–¼¶u¤pç*_É_¤Dˆ@´Ò’&Y/ÉŒÀ¡x<ÞÅM¿Ï?ÿñÜß¾M$5NB ÛøœëIÄÆÚ:ÿñ?|ÿçKF^Œ”O£áSÓ‹Èétø«ƒ½~Þß_4è‹ã¼¸x¼E=3Žc¢HE†4Rt³x¹ï8 OÞ Ý …¢*Ëeä,½%Õ­ÿè‡ùúÍ;ìW?âÊÖßçW¾A#W©ç±•àp¸‡0 Æb‹šÛ[x[“u»ôÁÓù¬“’*s®.j­e3IÙ*b¯Ì8n2^KÆüú+åcní\ãã/¥1[›Ûl¦>ýòh…” Í©Çg­%j9£S©±UÍž<¢¿Úc<=¦ªsNæzI†îd<}üõ-þð'Ïùúk_i£Ñ@"¢XëÐ&¢¬CÚm˜ç%HEQ5(t¯“ÍÞî3œ—8!¤ÂÄ)qÚÁ{‚à™zª1šñhDQDqî·L+!z3gÚÚìÉx2E™8D™Ržû/8á»MSОÖËtWÀDxʲ ŸM™M¦áF1*J‰²nhÝ2!«ÚZûbsÎQ–%ÎYêb¾µoð®AÅt4¢–_¸ù«i~Ú ¨ÿÆÒ3ðí7ÞaM*|>fµ×áÁdÎçG{lè¥a'<s{ÝòÁð:¢~È[A^flÏߌ—÷W/¯e&𧱡ßKÚôCXÜÓø”ÞhG¢= ¨«´ï ·CðëwÞ ‹ ׺or}­G¢ñ`ãƒwñB2žŒ(š9[qÌz¤d]¢€£GKÉ›¯ÜáFg<Ÿá½ÃC]ÛeíÕ+ØŠ;ì×û¼ÿ4ãw_±¤"Æ5¥¬î\»Éj·O]Õ<;Ø£¿ÈùW:¤q5¤>]…Æþ6%úðÉcö#ÅÝ•çø­_ú:r2¦[”qJ–öø|Òðõ[o#-q¶¡éC4Û )‹‚¢(Âs¡ã%]£k*|S1Ï瘸ƒ21^j¢( ™Á’Ë·ì\xúw뚬?@)Ãî!µnYËdKi‘@™ÏðÞbQ˜–PfÉR$Õã|:6%‘°µ¬_Ñ ¼ÃV%MÚžt£“×F‚BÉÀõÝÖƸŠº®™Ífahºp-qš¡´AÓ¦ÌãÓº¹oÜ©®R!¥†‹^ž³mA°Ã9‹­*ªù¤Ab!ÑR¶/DÚ€ð4UÉ|ž‡Ò’T˜8AHx˵ô§áà§h»„<›ÚSÔ]ò§#Üe^×5žSéÌ8ÙZÖ:Ì7%I²<$± Ö†2Ÿ1=9áðdFo¥ÖŠn*&´: !j†{ÿ_|Ø`ã_ç¿ýÖ7ð‰æÉ~Á ·Ãõ7¹ã ^õ&Æ£°*ÆŒL–¼·('I•àG_Ö ²£eË;K%ÄQŒwžÈ„V<ïû{l z¬JÅ›WoÑLÇ(mÙNRïùx>!®º=ÉÍU>üé1;Û}ŽN†t»]†''¬xD?:Y!¶*Ž8:>¤®jzkWQ‚•ŠÚyL³½¾ÆŸN#¾rë.½¤Ï“½=œ‚ÃÉ°•#ÔØïQ”¯¹’&<¯GÕŒ-clM]CÞ̹z-#ê®°»û%ó“’µ•5L'fsu…Åû (j®–|±§xõæʽkßdkã—¸ºò&Ïgš¡Ý#Q5?|ºÎóçš•äm†²G,R-[íú½Æã1H~ÑÞ¢Qlo\aue^ÖC^²®_̨*­(ó–ta8u¢âJ¢˜NƇþœë×¾Šªƒ|©‚Äõ´Ej}ak8CM=™Ì)‰“sç±Ä]ÀI]fœ=ÌX7AS@xGƒ M#ØY»ÁûÞåwÞ¾Çÿòïqÿê+(­ùl÷µ±•tùã?º„¾ó²ƒ q>‚¾HH²xï”Eìå½j‹c\4Äg·—Ñr^ŒÊÿ²tCGxïèv;t²%ñ§6R £Û([–Xk<¢õ¤‰–b”–È0” Œ` ~ÊÁÑÔMŵ¬Çz¤q.€–NN·4ŠX'üø“éô:ܽ~ 7 Ⱦ²©ˆbC™™Àïò^sÌ|ô‚{Wo0Èz¬d=”P”E…’þ`%¨«ƒÐ5bƒ(ÑL ÍÿøoŸó7ï­2¢TÄ$ŸS5 7:)Q³÷ô9_¹}¥">=9¤Û]%J#no4ü›Ÿ¼Ë/Üþ*RâXRU H 0bÊ<§¨jêÚ¶©^JZ1Lð8úý°.­¼÷¾“µ´™‚¶^ó:Š)«&Ƽ£(Š`œUh« “Ú㚆²,(Ši"ä™È2Ô—†y1–N_Ÿ]|ø$ôr&qÌ|2AëÅtûýVj1¦ƒAµÖ†± C´)D@~C+G xÛuzAË/äÍ™ñ œÒ,,QÙ¡¾(©eÍÚ9:ïC$íZ4¸§U3­!D0·kjÊ¢BŠv~¶Ñ‹Óg­5‘‘ÌfSœmZ œ#/Jâ$iùÎCx]×TeM’Ä /Šeº0Dî/Îs <‰ M¶ÈHŽö9¹vóI,Ñx2íÙìBb$³Q àúƒ÷øæÝßÀ9ÅpV°4e\44V··Éº«È(Â0RÀxJ¥h›§yåÊ6ßýä#ÖÓÓžvÑF‹J©¹¡IÄVo…¦˜ð;÷ã9T’W¯Þb{e•wvn"Žg ëYÑô9|2áî«›-™s’,Axèe)ilxþü³é1y~Âl6eëÊ]º½u¼³ÁèXË$ŸÒO3¦£ këk!žõùìÁ—ÔMÍÕí-úI‡~Ö àÏÉ ³ùŒ¢©ñ:´Þ^éòüdÊó¢áJ?ãI9ç¯ vøh÷!Nnpì3d“¸š­õÞ:ÐÑr¬.RÚ^:¾÷dÿæW~‡N‡P­ñÙ¬px’òù—ðöÍ_äþ­kìl¬óÓÿŒM ¡â¢Rj²^2K§/Dë 醳6åb`vñ½"/HÒdùÙv, Bb7Öüoß}_yý®çµ½ž–Mgó’Æ‹0ŸäyÕµ‹öål€yvË¿r#£u(4ŽXB£4k«¯òÅ'Ì›«ÝBwÞýd»›y1ágï~t^øâ²0}áYœ7¦ò…·ˆ”Ïïò͉.3Â/3¶÷²tÃâFgi²¼¹q$ÉÒ˜–G€¸/*!^vÄZâTe±4ΚS¤ðY~Yï=‰—Ì›’w?ü•¯xg­OzÆy)[‚‰N§Cm&“íî›Fiª¼æ`xL–¦”eÉ?ü®ãŸ~0æŠÍÕ„_¹á©ËŠé,gwoçGL3ØŒ •µÜ¿û:©SžðçŸ~ÂíÛwy|ð+<ÆÇÜ»þ‹8Ã3å9©Jù¶Ãƒ=¦EÃl–Óéõñ"¤dZÓ´’dI$ôŠ! ÏE«òr¶¡Èg4uAÓ„·ñ¬@ÚyϹjš ÷ÜÞó¦©(ó" ¥ÛÔò‚©J^ˆ”_îàFÒMSb…|Žk*œÔ­ðGPXòB’%I¸¾¶¾È…k­Îfm½&ê„ô.‹ÈøŒq^ŽiNçÛy‡sA²rÚZ¶`+°Þs¡ÇÄH}‘'q¢q_¦©1(™,‰þó"¨[)´/-^ IƘ6bVå©ò£áˆÃÃC6¯ÝB'‰A¤ùW?úÇüá{ÿ„|vˆ›GìNsn¬Þ&—e2d²‚õ°¶µMwu %¡Ç^›Ð '4Å©ˆÚ·d6.hø†%¸ëuö~r."ZÎk £Ù=]ñðÉ>Y"yuí üì'ôz ¥cøôˆÚ{®ìlq|xÈÝW_!r„åñ¸~uiʘˆNs¸û¥ óÙœ¢¨89ªÉVRzýøˆÚÜÞFÇš®‰H┵~p¾ö˜ûŠ+W6˜å9“¼ä³‡ˆÒPJŠ’˜ºiOçô{êª`<ÍÙ¹{3±ººÊ{Ã=¾º} o±å͵ŒéÐòÞ8y|ÄÖÎÊœ*VyïYÛþÛüÚ7q®Æ²hs ÿŽÊ’{›[Ü¿u•ÿMñW6*œ^`LÄp8dRœ0¯æ,8µÑLL¿Óa ÿy¶c±Ù&ä\ ¼T¼±eù?xÄ/ß½Óε çXÙÅ+×;›—8¹™9Ý÷ÅÈùâw/n§A€¢n*ðMñµTDµæÇGÇôVàñžæ¨¼seD”ÀÁxȃŸ|Žºõ•¯ÿ¯þ⯼4¥¼¸‘áÿ `Šzás=œn–¿}¿øùŸ÷ݳ¿ÿÒ¨Ùº–D’$&K 8GÚFÒ Ö¨¦© Ú:%1J,™‰ ,FzO'x$ãÒ†4¸í$V€šÛW÷¿˜r·?¦öŽ×o½Êd4¦l,tRò“1±Ié÷zæo‹ãƒÇä³)Âi®¬¯ðô.¿øêWp(¬é¢Œ§Ožƒ6XQÚÃ#[CW![϶n*œ JSÎŒ´ó RíÒÙdЗZRV%uUuûÔÞ‚|èCª¥°”óÎ;ª¦Lam¤!ež´¶!Š;ÁùkjXv,\8Ÿåù²ŒàÎ:ÀÖ6ȶ¿[H‰ôÐXGQÕˆ¸³$ZYÌÕÈH¼ çT9ÒÛ ’åj„P(µmX•Mzm*òé|Úr#kM”f R€³.M4Ž( QºÒ‚²ªÏ6!C$[II£Cº^X¤2uЫ“¥ª†ÝÝ]òÙœ¸Ûcms›|2b:1óùÃ1_ÛùOx­³Áá<ÇÄt’Òï­Ð]d’N%h¥Ñ2m½4@µ”-©òkR ¡&^ñ½ßeÐ+Q2>7^”ÄIF5s42«-ƒRpõê fÓ9Må¨lNÓ””yÎW^}Y7žL™‹9ûÏjú©åúµòy Âsøü e^’uSÞÿ‹÷Èz}^}í5«kH©˜9Ób†ÇÒI2Æ£NŸá„àhï :Ò$q†‰$£qο ³Ùà ÏÓyÎÓÑ„a]QfGó9»'dš`iAỶœæ‘›3”$/Iz1÷~a‹÷žFô唬‚"¡°ý_çVÚ%/ÊP‹­ƒÐŠ’oLšðÿÍ¿ákwnqPL'Ÿb½GˆÉòÀ¼˜“ucº‘Lp6Ýl¬lÓOzK欋6ç2qö§©â$~‘¡oa¼ÃyÉíõœò?åwÞ ¼÷B’jϼ^ô'[œuËyWe üT§ýß—ÙœÅ9ž J—†ûŒMò¾%úq ±VÔ@ÙÐ)!#…*±ÓŸa:[dfŒrW5ÿð'¨[oã|⿈>b‘È—ˆ¼ÌÛ9kX/K¼Ì ¿l?•ïD-0˜_´¤‘FŠÐóÙ4 ®®©ê’¼²í±u@ÿ¦q@hWe‰‰b¼·h%É‹šÊ j'¨jKuTê¸}ãÅÞ¨dÀþɹm(l:…Õ>£çψÃwîs<2ÎR`¤çO3îmÃÝÂ45oܾÇÑè„áxÂê`@¬4©ŠøðãÏØ=:¤éIþÅùû¿ò*I3£‘G@[/˜ó"'JbŽfC:„ª®¹}õww^åÝÿŒ÷ËcÖ·ú\‰<­x|8âæõW°¶b:û‚»7ÿ&‹ÌÉBf®¨=ÏŸíbQÔCêDKñçl[žn¯K’fL'cë©k‡Ž4¾ñTeHKÏg3¢(¢i³YŽ6:°þÈ ;ãØMHô ƒÍu¢8Ø¥ã3ëÑ‹k€’+XHÍ5”Ô˜Xà› eô’³øh.難eÚsñÌ=`©Ù› ùúöò’‡{$Zr}ûZpàt^Ö#1Ž¢ž³ð”ÚÆØÔóþ_<âÕ[×°å!ÞuYß왚fŠ·‚Òà×áäd´QÎÊ‚kW®šÐÖ¹ÿüKpŽ¼¨¹rýÓÑ!›«+ÌçŽ^/£Ûï1˜äײ˜c[aµA{—+LÓï®È„¼²d½>ÛZ3ªkP©dèàèos{GÑL íGåßþLñÛoþÃYÁÞÔ’[Á¼/4³¼ ¨©køúoð¾û=V³O­Ó{ú\b:+hš¶9«>£L‚ŠzƒU´Iƒúà¬GÇZi¤Ñ¨ÈPÛ†N@ÒôûtúŒNñ^™¼DØ0èoC-Q‡v)„j[ Î·£]c‹×Ça«j¡^üNp€ŠT¡Æ›&^#–úL&)¤ÏÏ ,úBþÞ[¼ ­3ÖÖ4Mž8»˜\æÀmÚY´s/Ôîj× ]à| j±¿Em;ð•×g<ü…žõ)Ú]J01ÊÄ4Nuû (ÕÙlFQ”e…mBš<ŸÎ˜OG4U·5MU°S{œEVj1Wóµia‡#ÒÕM:+ÔN1«€h“­Ò¬‘]}…l­ËúæzÛ;”µ"Nâýþó3lXáü§Ëyœå=µˆ–±à[o¿ÎqY/ÿ¯¥ÂÕ5¢ªxúô``VPÚ½ÙCjØŸŒØ;1-s oÉÍt2ÅVŠÚ5¸ºáÛ¿u—¼ûʯÑ[ù¸ K Ö'ì>?¤ßí& ÖÕt;†étΕõª|ÊññQÀxÁõ[÷¨ªÛTtºëœœL‰#É ³B=+ÑÊá E##|ã°> Žµ4Xë889`wÿ)[›Û¤I‡Z÷è$¬ul¯^¡(‰‰˜¬­ñ'ÿìÇìM¦üwÿÙßeVÏ,‰wæd\0ÎádG¥do4åüÊ7éeßæ?|Qae“1”+Λ?­çÛå%W7¯-¿³ãþâ˜~ùÏEóéíÓ1Æßþ¶åÿø“±DP­É´£ŠÑôtž„̉ MõRBöìùœý}¥·é~ªiX`_ÎœÔLs‹+%e#Y|÷Å ‘‚¯n]#.g¤"Æzº¹Lk/Œòiø~¶ÏëìBòóÏAq IDAT ìËšËnÜÅ×Ù>_-¶…¨Àâ/Î{´­ÚˆÆÚÀ„“$¬on†þP2N±Î"„¥(,»¬9Ÿ½n!(FjELj¶}Ä£o-¿ÿçßã­»G˜H!µ ßï1œŒØÏÙI2|Sé˜Ã“}Œ2ÜܾÃprÂWn$[¢½CGŠÍÕ5꼤›uè%=¾üò1‡UNÒŒUo])»ˆ¾ ­aFkºYjZej¤uÅÎÚZ*Ò(A Åáþ‡ÏØÜè“êŒ/Ÿ<ãËá×_¹ÁÁlJ9/鮬òGŸuøÖkwò´V:WŽs&³¡SV×6Èk‹hIC„RdI‚”¥uSRBèXuêdu}“º(I™ÎfD‘¡×ÉZcmIU”ÔQPR[Ì‹Óò]EUÎF! ôÒ’(¡w©«O©gßv9:Xå«wî²{\2+* }«°ÈÍÊ’ÜBU z2æ×^yÁÆ×ø×ïï¢Å«qPS»8ëùÑðˆ8:Å-ð<—ãžÎo¶±˜È¼ðþËœ6)%Wÿû}È×ïÜGAª%óÆ¡¤Â³Xã%^hh,w€¼ôÜÏë,ßöbMxqkí¢PÔuM¤%Ö;ŠÚrïÚk|òìÆ LFÇy¾÷§ï†šs ï<¡\l…:{bîe¡þeQÁeQöÙ<þÙï_<ÞÅÏ¿,ŸÆÉ2Ê"(úÄiŒTAž¯¨‚¸–¥5Y ²”!]§µ"I³€ô¬J:Yzî¼ÃCÇ® Ö€÷a1P<:>æW¯¯óøø9išñÞxŸ^-y|<¦7èq³›"ž‘fMÓ0š C‹ASðû÷xmeÌk7ï!ÄQÂJ’"„ç“/v™‹ŠnÇóÏ?ùÊ $–’£ñQá­gxrB­jzÝ‘4îøüñç<=>`oxH7ëðýüˆr+Cç9æoÝzwv^ã+;×è*vNG§|2q0ñÚ Ëε[\[ÝæøèˆÍ•ºÝÓOØ?:DHAžÏXí¯°¿{Ì繺Ýa6Q+…‰ ZÀþþ>ó¼$Ki’rppHšfTuIÜÙ&J¼´t³ ›—9ãÙ„83h)8ÞòìxŸ2Ÿ³Ö_e\U8í<–ÕÞ:kÝu666yò|—º.™×sN¦'t“nˆG`¹SA‚Ut%ÿÅoü=N¦%Gã4ÂPÖ–yQR¹Jc¢C¡©˜5Pû˜¦®ùåWns}ý«<ÍרÅ!1§ Æ( T4B…Þo!|†kdS ½A:ƒô ºíd¨i𧠱ÐËâOS7çŒóÏ ò³µãÞÉ}Éýí»8oIcCe=ZxœÈ+ŽGjZGËñµœkí>ýrîy¼¢ Ÿªv-éJ0ÖZ4€Ò‚²nÐ-b}Z;¶Ö_e÷ðs\qÄÎÖÿá;ß=5ÎçkG/OŸ] ~ñF\vsþ²¿}ý2'à2Gá” %„\DÕi³h© ÔˆÖŽmïãñhÙgGŠn!}Ä”eÃJ79w^ËÅè)€:-eœwàüñG̯Þ\åÉÞ“P÷Ñ’Ç£ 614Ö1¯-ƒè”79Iî^¿ÍVþ*¿z7á³ñ7:–~ÖÁ¨ç=?~ÿcŽ«C:Ý>ŸÚ>¿¾Vb¢–•L)zÝ+>iš²wˆ£„GOž±;Ù稪H+LÊ’Oxï±-€²n<ÒÄDI/ðW·é÷së€kHÓhÉ-.Dh÷*Ëòœ–ðÅÅXIO–Äg$=½$(™…E1”¨Ì…¤äHŽæ+ù®”®b4Ÿp|¸‡1J*ŽG'M'¬®õ‰¤¤¨ùñªiè VèÆš/¿üŒTeøÄPÙifÅœÍÁ*£I%ïýl—+Û«£(XY½‚·%Ý~—_|I¯·"€/{ –Ëx2¥v)Ý^Ç{»ÄY†òŠI5ÇD -=›IŒpŽ© ]eU°2è zðŠét†Ö’²¢ &Áðw¯þ©ŽNsòFPÑRà¶óÌhH‡jˆÒ@E,Ìt5Žª†FÇPÜÞXáÚÚWØ\ùlr?ûìSÖRAì@…§ÆKËaîxp¢x<ó ‘1£Q/ ´™²À(–AéEãüWÙcg#.ø÷Ÿ8î_ßÁ;Kb$Æ(ÊŠ%|2ž’u:Ô¶]Sà-UUp6šc+Ýñ¬h׶Ààç=Ì‹‚²j(˚ƆΗ`ØuUŘ5ºÿ &ž/ŸÀgï}‚‚'È…í2Oõ²ÏŸ8—E×gÅËÔ…¿/Ëí_æM…”uE¤M×4ÌÆaáït²@¨ U]ÓM´òLó]xWщ×Ú‡/ÐRàxç_8ÇÄ@dB´° 0ô>gøÊΔg£!Y¯‡Ä³î"™)‘ðêöYS2iõz š7nÞ¥.«¶Æí¶ÃÿúÃ~ë¿ÚDÊг÷½½ÏƒÑ.¯¬¬óGÏ þúµ)R¬Š‘ÎóÚµ;à<Â[jï˜Îg˜‰f\—NÆ<žÌPÅ„LdìܹG>šÐ ¹û*UiQFs|pµíkˆZa¥à·ùw‚ä!!Š<ÍÙ=˜à½"ŸN¨*‹éFH©Ñ‘ÁèZ÷Ö¢dë‘+0&Bk8<<¦×M˜Íkfó¥ UU£âëUU’¤©ðjJwš®VR¡°(ïp­‘9mùX(Ÿ-€Q§«‹cïl=ôl=vQÓ é-ÊÂêÊK‘OQQB§x)À‚Så,e1E™E-ú_µìcž$ÍZ´õéØ^Èþì#f“)Ím¾˜Ì¸×_GP±wyRËàÜìîáq¬­­Ñ_[a½¿ÆçO>Ê’µ®lË7 ©øƒ÷7ùï_͘•óÒ¡&²­ñ6& Hkß8p0> kk–D(,´e‘ÙÔ1—†2WôSÆs-îò»ßø{Ì« +$«Y²îåx$ÑFœï=ùyð]Š^…¡‹÷ö…µÿ²ñ}Ù&„ÀJÏ[W?dîß$“†F ¤õ¤Æ’—¤f°’2šVÄ‘a^Y¢4ÆU%M1G÷œ 1ᘡO;,š²È´¶R²b ²™À(Q8ï)f5Q8ËmU3èß¡³} kþ,ÐwÞýÚ¯½p—mSÌ/K%\–Ž¾øÙ³ä2Ã|ñ{?/e±¼é64|/Rrλ 7+ÅÁ½ˆ¬¢Ø U@4 ¢îÆZ’8†–„¤Û‰/Å6¬õ$Ô!7 µrüéÏþ%rêxçÊ ¬÷ ó)ªä2çj§CUädY‡í•5¶VÖ[ÓëN³.?}ðœ¿y'à Å<ÏÉÒÓ¦â#WñÊê6eƒÇsÿú=6:+xD¨ý Éññ ^Iù˜ƒÙ”GŘt½O'Îh$TeÉÊú€,é`]ÃpvÀ-ãñ•D‰Õš?ýÐó›o¿„€Æ9Gs¬4eMY×X ˜˜(éôj;0“$Ak Þ’¥&x•^"¼¢(æ4Řˆ<ϱ-’š¦ªˆãˆ¦®(æsʲXöæ¶ø´ÇüL=6ü}I]FŽóòlÍÅ Ñbœ-÷-e{_¸†b6m#¾¨5ÜôUçóÙcâ%ÚÛ;»LÛ.Ró‹¨|q¬<ÏŒ`Q1/ zý¼÷̧'Te…Ž;x•m–ˆò—͉SÞ-É÷/^»÷ž,Ë8²8"ŸŽ(‹‚ÆZP5 Ut£;½~`KZtixA‡…ߨ€çXLÙ˜4M¢ÀÍ­EY½À­/DhU4­€‡÷žN·5ùÓ(ÚÒK#†ÃæEAÖéQ•³Ù¥4eSœ-ˆ¢ Õ‘rÄæå£öõñ¤âÁÞ1IºÊª–X!y~ô€GÃ/™×3Ƴ#zQDWžî1Îùê+¯±xHšF¼uûu’F°½±”’½§Ç̦s>üðc67»ííadÆÞ|HÒËp³Úé3OiêY§GÖÉR§†ÕÁJà¨ÒŠõ Žq²:Xg6/Ø\_GkÍG{ŸRRP–ÖÃÆÕ+_³ÞíòY~Â8/x8]˜ ‹ºÈK”/y|üŒ»×^c}ucéÜꨢ˜ ~÷›‡º®8™UçDi‡ªÝ BBm¡ñ ¤Ä¹fYª­ øž›œm‰eQRÕ땵£‰•"QžÆ^NDuq½wγÕ[esë ¾óÑ'lf3”Šhªmô¥sàⶨ9/^‡X7çûÍxëÆM¼HÒ¿ç%FIªºÁ AÕÒÙNgóÑŠâM8¸I%¨ë——z—×$[ÚGKYVxi’"¤ h ï~ÿÏ«R]LW_Œ`/ì/3ΗÝôËö{ÙqŸ;kL/;þÙTÚ"’ŠL´L{ª…ZçÒdBâ$Â9ß.ô‚,ËP-‚hIHú½$ôÀ]8už¹•héQ–ÌJ^¹òä+¯óGòûQ€ð {]ÞétºÔ¸ºáúæ”?Ÿ¢3Z+ÇoÝßd¸ÿ„?}HÖíRLç<>㣓¿4˜c#Ík×^§Ê+fE‰Ñ†¢(LpNNŽ9ãtdx«¿É••”Aí8h*æuNq2ç¤ÓØ‚ñ³CêÕ¬êqãêßæoÜ'=u”Œ¾ÜÝ£vŠi^QYËÉx B‘ö˜(E,ZzðA¥ÊY´ÔU…žµÕˆ¦.© RQ%ù|Žuž(É¥dK‰kgSâ‘3 § :ˆÓÔô»>›®½8ÞÎn—•NÎ.g™hÁ„MU2ŸŒ©ª2ôÖšGèU˜Í”DjƒŽ¢¶à(LÛ*Ó4Í2~zì5®D IeÎàÉð€(Í°LÒE":´™Iq98óü5{Ò8=Ùg o‹ãz×0 9RL'Ðv&4Ö!´ÁD&ŽQª­-.zÇ=ı!Ž4‘QàçzÝ*pYk‘"à0¼³mšNëã-ÝiYôµ”D&tˆ¶—=,ðá£M‚—’²¬‰“Œ¬ÓYš-Áa çW‰9å³é²Ïz1‡cy:!ð¤iïuUc¢–_œn]!³ $¾)1F¿ð •ÖŒ§s²n—8MqÖSsŠÒ’uWÐQ‚T‚¬›¡uP†ë¦­a¿sà€A*I•g¥cˆ”çûŸþvöU]róêm&ó)ÆI>šŒkÛ+×Ðô¹±y•ãш·Þ¾Ïµî:ããcòшºœ2<“v{ŒgsðzU¤ô{öŽŽ˜ÎÆ\ÝÚ`6žò?ÞåÛßz Û4¡´#5I£”$M_3—¤iÆ<Ÿ#…`gs›Æ;vùäáçìb’+={åœ82ÜA±Ñ‹ÙÒ†õ8áðdDã+Ý>‘ŠCkT¯m]'pé, ßzý·1J1OE”õ™ö¼8Âù“ĺ Ó¸ÐâH ¸¬­c^̃‚›DÆ€pàMá$™‘Ì­¤t’Â…6Ã^¢i\‹¸0p°{uû »G?ãªú¥híËòßó\ÙRüä‘á͵ %BÖ«=v^7Hç(¬ É2f³9Z›%Oüb.Gç±îr‡ùÜ »ä‘2ðD¤i`ÛS:ô¸G‘á½?ùra ­µç€5‹Ÿ‹$.\àEàÖei鋯h%xc—!/Ͻþ²úÁÅm$º¸]¬»-¶½ "¤L“¸í%myµ5‘‹Û¹›­€cqî‡Õàò†•;¼yã6E1£[ŸîçÁÎ_sû»i¾|°Oíz<Ÿ°7Ûe{kI*i¢„[ƒ†Øiºý.q/c8}v‡¬ñÔªŽ"¢vž8ë0ØØ ­4Iëƒõu„2ÔÍùg]UE>cxtÀî“/™W yM§ÓA)Õª„EDqLÓê !N…&âi"\i.3Îy ¼ýþÿµJ}q-((µÖäyNš¦t»]ÊÉ!B¢ yæ{UUÍî¢`4Þ:«]Þùê;ܾ¹ÁïÿÞŸëa%‰I‡ˆÅ:ÔIè zŽO¨¼å³Ý§üìóÏùâÁc>úüc²ýÍq¬ùt0öS±JÁ¯Ó.}Š¤ZÑ@/ͯë ñˆHIÆZqhóh™c¥à`:cßt±ÄOœj2ÒKûÔÍœÃÆ{G û¤ý1yi8š.1µCé>µ«Ù¾xŽíÍsHiÔãæ3xðàˆ~¦87Þd™çarV­xKSxzÔ¬Ÿ1/§”¶äå—žÇ5†ë—¯p49%¹ÇœöKÉxc“ ƒ &Å‚ÉlÂaUc½äüÖfó9E±`o¶Ãx0&ÖmÍËŠ/¿“ð™¼B,eÙP8j¨Ö… Ž”h2nÇëDÈNˆ¹l'ËR¤Òh­VŽ^Ð4ŽÊ6Si…5–Z„º±ê(“ʽå8jq$œÌæ à;{ ‘¿G)êJÒ%×>,{R&Í Ë(ËøG¿ô?ðÒ‹ ÷‹5ÔDÄR²X,Ú’R ]BœQ¯®ÕYª:HèÊSsÔYëi—"‰"Ðäf½‰àëÿîWÑg]ÀwÛμÐSiëõíñÏÂç§Á*ÿ¾çqÖf­­~¯ƒªw‘Åj> IDATzwü¦i!>¬È#”oEKFÒö¦¹“ˆÔÇ7!h¯G7}¥ØÌÄô«âЊàçÇ›íï:–‹´âí{ï£{çxÚž &?ç¹SŒ{9oÍc5O§#ú:æÒö9œƒå²àÁÞ.£­!ºÔDIÌæø*‰uÐRÀ`ó|h%óÇ6¿~]å"Gó8-®Â­fo±Tôx ¯»÷g£¦iBya0 ,Ë•t_÷ÛRʦÑ*µ‰Ö†]›CrR=>¦;ïßÚfåÔtUçܨ¨G*EQ0è÷û”uݶû‰¢ˆ¦iн@‘JSã#˜O§äEŒ2L]’ϧè(e0àMŽ±†H‰Ð¢æôŠ¢”SŽ´ó‚X8¢HP;ABƒñÁÉø¿öOùÜ‹Ž¢8‡rnž¿ŠöŠß{ó[XWÏ_ç^|qíX(‹‹7“Þ8fùvθ|íyÄrŸ!ž÷ï<`ëòuòå+•,¹|ùUY©ˆÆ7 *ÊÒ1ÇX“³¨2´ÖTUÎ`ÜãÞˆéî;lm^ÁzÇsoE¹EͳמE:ÅÕsWx´Ø£² Qúl“žæhzHÿü²ç1xâ$áÚµk”ËŠ^},4aúŒ¿ô“?‰—ŽÚyâX“ ÅrºÄTPž© ™ÏJ¡ì^fM»Û³Ê† ºŒ¢ÇG=µcœÆ  AqT4lö”opR’›@?œÁ9c¼ãóÏ¿Ìíåe^ãÿå©q ßñ»lݹ+)Îðƒ˱U”AÿÀ7ßx¤v¤iLŒ¦¨ Æ”N§û[ˆúôü‡­_ý^‚Z³az¶ôÚël¹Ç'y&OŠŽ»Áº^Oî&’®uå4-èYÇí¾Û©Ü|ØÖíã±8¨×Š¢XM¬ë¯U ‚&DhêÚ­&(Ú[t¶æÉÚuûvh7CKˆãú׿ƒVÞ©™Ø …àÙë7Ûš†Ù¢d²˜rïðã̓´Tƒ„B ͳ#âÈâEÃo}ãàÆvÊM¼õÔeIÓ8lاÎ_ÚæùëÏP– ‘ôŒ£!—._ÂÎùÈèßúà6¿~ µàµ¯}•÷&ç("GãÔ×Þç«È‹rußÖŸ‰Òô°(¬ó$±ä4µ ˜ïÑq/,̦GäEÉîÞû“9ÂKL]RW*ŠÐ-å«5AÚµ—Äàâ;ßü:ÞxzIÙl—–HL]¢ø¢Á5Èd½åwÞâÖƒ»ÜytË[—X–Y±³w—£ûwÙ™îÒË’€¦v-K¾sx‘ ¤‘€Ø+=Q@]°„¢ÀÓÞ¶ c°Î´jl–ç%ù²d¶XRTu Üµ 9Z,¨­Ã65ÂÁti˜”àœDàY†àkÌÄÊž|àÏŒÎñSŸýsLËc¼C^æxq¼ÖœŽl׉I~„W…¬çý†äEÄëQµÀJ…@Ñï÷p@ªCÉ;·rv»ßBà°ô²l5LÎZ3»¬ôßÿžÃûüî¯üs~þïþ-n¿ù¯ýÆ/ò+ÿì§ñ µGváõiV°õŸ®íµ ŸÞžTO^ï3=}¬'‘ŸœUÏ>k뢟UÔÆÉkX߯ۺԶ’żÄÔÇ=tîôS›ô¡Åª;vQài*æ½É:ÒÀ‘RPVÛx\‹>¶Öñ'>ÿ3üôþü›÷®‘÷3vÒ‚ï¼ûöæS\Sr÷þm6c\KAoÔ#‰"¤óäyÅ°ßç\/”ve8šqïÝÛ<ÜÛåüÖ£s(¯±…C7Šùђ׿y‡É¬æ¯üå?ŠÒo+êjÁt¶DzËd÷>‡Gì<8‹˼äþþ.Zk2™â¼äÁÞ¦1^œÍ’{÷yïþ»Üß¿Ç[ÜâÁÁ}&ÅÑã6î»G;Ä™¦ áÇÿУ׋±æ8ø«|hÁEJ’(”Ÿ¬ meî ç¤d„”žá(¡±%ÞŸ½>~ã·~™g^ý4Îòéâ¿ü9¾óÕßäÜ…+œ»|5.•ï‰‘ë“þVðÝRŠá³.õñéºòú¶~ÜîûBXGx ëÇ_±rþR„©©µ\‰”žT±š(œ€…ñè6í=Éçúš›Ú½s¬¤e&Fx¤ƒs£”Œ‰œá¥ Q2"õŠºn0Α/æ Æ#äl7AhÝ.z-çj$•åxºÅÇRó[cœ­‘šª&šÍÍ L¯&ÒK1ˆ{\ì;¶77yëö»<3zŠg>úÓýG|ÿ+¯²»ÿ›|ôúÓÜ~ç€Jk&÷wÑ>fÔï“d1Ó»3.\¾NgàCJ«”s¬õÌç9Q¬‘Ò#T„õòxð¶À ç\K?鈳*Â5-÷^háÉKúýþJÌ|Ø‹˜ÌfXª5zݲBÑF¥RJlè5Y¥€Ã$²Š±}K7)Žs§K-O²Ñ³êBÖ7dq R¢¬'ŠÂ¢XͦÔeÉ`û2ºeàr~ÍÉTJyÊÚ"¥AcñÈàŒ(…S1¾šë4Dª-¥æÊão£!©ÃsÎ!…™§£ÓBÂ… ƒÇ…€Ž¨ò9iXºÄI¢ Çƺ³HÙQw*dxÃð¡^»¶iÑjH¯;6Âãí±ˆT Ö8oiŒÁ;‡VÇã;íÆ=Îئ!Jʼ õ¸¼hÊ#e„ó1u iŽø¯Z›Z”‚aÏ"Ú¶“G¥Ç9IOǽõ0ÎðŸ~þs4òsüÛßûXÝðþáÍhÄ9—`ê†ço¼À½ÉFÆcœ!‰®Üxš7ßøoçëŒ/_çöÁ}b—0±åþœ¸ïÙ=ØáÜà .nlrïÎÛ|ß+[TeN‘—$qÛBØTÌž¥©Ç<ìóñO~ ‹ŠÙr%ô‡omnâ”ç›ïÜ"I¬ d9ç}®zÔEEÑS|ÿùËàîíÞm!4Îk¼/ÙY<í{]9£qž²±èHÑÏúäEèTp„ô ²„E^‚Ž¾eÐó†º0ÔáÿZhpžH©'s ˼!V¡ä#¤ (†ƒ¬ë*8ô‘õ(ËZPç ^6Hc|jóVòúëÿŽ^sÐ…ñE>xx›, ”ËÃaSæyÎÆpW[$!87óp?çÁ£Þ–|ìªAÇ UÕó-dêB0•Eš¥J3£hڌܓœcïé%)yeD˜ª ݽǽwßäÞÛopåÚ5¼³±–<ûѯƄ1þ¸æü½lßk=ï¬Øw‹^ÎÚÿôäὧn[B„'z`×ϯ‹bV R-“×Éc[¬­Qijΰì(‚·F7Æc›¥EˆvÇvëaw®¸Õ cÊÚñÒ+Ä:%ó·ïÝAhÁýƒÝ:—2hæ*ÅQQ0Lœ‹ÑY×ï øäå9/†Ôµ%_:„´$½(Ô€*Ç ßggg‡ÑÆ!$½4CDŠïã’„çÂ{¬=ÎVH))|@ U•c9-ˆØ9¸Ì¬wŸE­hoðòõ%XÏýÛøÞ‹¼²µÅÞÞ!³¼$Ù¸D>_²·À[å‚ÔIÞÈ'à=¿û)ž?ÿÂK¦®^½Ä/ÿÚ·øÔ÷¿ÀîáWΟìyÂ#]ƒ·“Ã#.^x‘ûnqýòUöwÞcwƹóO±,rtx×oß¿‹Œ%£!ÖÆ_¬¹ÜëS”5o½?£š×üÂk¿Ë Sš%½ 1;w—diÆôí7¹ü‰?žïÙÀøfCMm ‹ÂàlÐR¯êzeƒ«Ìp4¶^«­Šõi]¹¢Ëm3A´‚JA¢,Žé‚L)%‹ÂÓO%‘ðX•0/½Lиi=‹ÿò·¿Ìï»ðpa¹_½ð÷÷î˜ë¥”Ü{x—Kç/™ã,Ö¼¿¯ùâ§ÿ.Y¶sŒÀXÏÂxÔÚœ!¥¤ŸÅÌ'¢ñË9µT((ˆ×“nÿªn(ë`L’”l0ZÙæý‹ÿ_û׿À3¯|ç-ÿ×ÿø·ø¡ŸüOŒ-¹¾¾þßç¯ñ‡ÿÜ_çÞ­×yðμüÙgv°C1;ä?úÇù^¶Ó‘u„ëñäþÿ^éH|w!GìÇ}©‹“¿ç ³½‘²e0 üÀ«ïú¶Žc-ˆ=xéð¾ œÃ+‰r ÛY'ÄpüR€l®"ÕûL…¥”†fY¥Š7ï݃سs°»ªùÙ…Ú4 oK¥eiøÒ¯0[îòìÅ‚Òõ¨LÂÛÕ¯^½€[Ù½ƒ i’ÐZªGhI±œRL*¶ÏoðÞ[oró™—Ø<7äÒÅà·¿ú?óƒ_àõ[·xîÚm=Ã훌·¶ˆ„@‹ïõhªPOds»$MŠÆ€#Ž4ôRŠ"è[_â½…6ÆêÚ0œ÷(,¶²qdi„·ŽÉÑ Ù¦¢H‚R¸ºF¸SxoqBRÖî±^õÎníWà½8ñ¼Ïr׿ۥwƒ½XS?êbÐ$‰8<Ø'ð±’eCLS“6H³µ œØ±–íùŸ·išàë4xÙ:AÇ1em鉭•qÄ‘ =ɈãœoBo°³Ñ´È®.Ü®øö 9O¥lÇ—TQ§Ûšlà iÉî}0m*ZH„w”eA]×$Iºú]ç=º§°x„µdƒ c¤ôTeŽçÂÁªbw’¤×r”·èꦪ)‹|Pò2UIÖ:3༢ª*TB£ÆyHÓZj’X¨[WíÂÑÚ@ ÄË$€Š8š[ÒDÓ‹¾1Ð9#B#¤C¢³…„~ öǾˆõÓ4+§æK_ûß8ßsi˜ðtÖ#K†Üzﻋ†ýóÙ!…P¨~FÿÜÁsªAŸo|ð€b¾$JS^¾ùnß¹ÂP.CÍrïpBYÃÑä｟+×n²y~ÈþÑã Þ{óå6›[$‰DÅ›Ä}Ç0ájK<äµo½Ž‘–ñÆá‘”Ìóœz¯àÓŸ¿Ai »ú¿ñ•¯0Àç®?Å·ûôz?Éúè³4(œ ©c¼eVyÊÊ£TP€›.+"y̬Ø)\ÅqDY7Aɬ !i³ŠÀCÍúØ µj°Ö²T!DDã5‹¢¢G^€Ò‚¼òm]\ AQZú‰Â+ÁPöøó?öãM?Å[þïAµýÛ¯±³ÿ(LRÐJKí?äæ¥çxÿá»\Û¾ÉÅóᙫŸ%3ê¹Àè#æKIÒ¶üµkˆuA Æ{–‡{ètD’õCiHÓÑvsJ»<`¨èÅ';Ú‰ª¬ùôýx8wé*?ø?¤a1=äοÃÁ·øοûRŒìÂÞúÝ_'N{l?õ wßüŸûٿ·þí/ráÆ (±uùÆcÜ“ŠÞgM†Ý@ZçØ]Ÿ(×_§ÓÙëžïzm|=Zéjr‘îÂSkM¤Ž'¤^–®&$)xÀpkÌÃ;S.\ís~¸Ét±ähyÄK×o0ŸÌxVñãŸú“¨X¯Z•<¡”7--• ÎàMèÑíë ˆÚ6…/±ÔÅ’8 €Ho¼©WêOø ÙÙO³Ù‡s UUàê g ó|Éj%F£"Ò 5Þ5x/°Ö`M…iƦ³¾i²e[k¿ N³]9 Ý­µÆSS×!«ÛýzI¤3 +"úéÈO**hñPÖ({C¯§À±ƒEUÅ EËRJ\aø™ÏüEþþ¯ýnçË|ß”£:§l±3yÈ9 úü&ÏnŽøê[ïó‘¼Ê;ï}ôèI6âyÁ'¶{|é—¾Âû‰Oóþ[·Ië#ꣂK[ñˆgž»Š÷’$ÙÄŠŠýCÇõg>ŠDâÙy´ É¦Ý}Ÿ›/Þäàý Ú)„k(ò‚ï{îUðPå* Nì2/¹¹9 Nàâ…óìíclŠKHÒù€j³„Mm°Ã8C½ êcµøÎqt.t tÎ\ûìfËíOQxçÛayƒ³$Q:¦®*âD#¥Ag}&GGÄÎa¬÷Í7ª*'‹uU mÿóÿóOøáß/0Õi¯uÐ ´¥×ûOsÿá]Ò^ºœÙ_î‘ö3²FpkrÑÆÆÊn¹Ã :¥žyp(j/PqŒ1B=¹Ã@+1åj‡Zµ½ÑÖòîW~™÷¿ò%²á˜ïÿŸæ#Ÿú4YñÖûwÃâÜÕ¬þÀOý¾ý[ÿ’+Ï¿ŠsŽ_ÿÇÿ¯|î'V“—m ¦.#[O[o­ÇrZa Ö’ô†í~_؇M¤gÕºNoÝ‚ôœýñäM虳¶A‰cŒk슒±qŽ¼X²¹¹I]•8ÛPä%Èœ²ÊÙÜÜ$‘뇰VA³Xz‡!`…'FPbƒ7I®mVìîi®nmò[ßáÚÍkì ÇÝå„ —F\cˆÚ:ñ•ÍÞ?ÚæÏ~r]f\¾úBˆ®“-$¦¬97ìñh=•P%XÇýûwØ>¿ÉlúˆÅlgy¾Ä ‡m –!2ö÷Ù¸8¦¬jœlnd¤£ÿô_ümþòŸúïÉÌf5u#qEʈ(Ò˜F„û©c¤Ž±k5Îõ›¦)yž#¥ KƒH†ÐñªMIÀ[d  ‹Ò Öd‹m– U¨ƒÔÞNG1Õ`·”çãmÁî>̉<™±9Qç]ËÖ„ÅKàðt}FqƒÔ GÛÄÙ M¡K”€q?dœsdiFÑTœ!*‡w6d‹VÙŸ9ðR“&Y(kDøcšL'4¦,ˆz[+ǸKC+àƒH|XõƒSx*µ~Íýä˜ Õ6d&Œ‚¸†HùbŠHž”Õ,MMD„_ÎÁ5Lòe˜4Û^Ö.:PQBQzB`ÌÑ.ºÞšß"ÏÉc´èlˆÔª-ƒt3 ÞÓ8Ûò™×Aá}Œ±0^²œÍP-Z\jœhI,ÖÈMÉ€#qÎã±xPR–…E+IåCûÚ¸‘8Ï_ý‘/òÍŸæ~õï†O ¦ó„ÏßËl¸Óƒ=žÙ¸È{ÞfÙ¼ÌoW çã§8ô{|éÞ!þ­÷xýå»Ü¼~…A?åÖí÷yóî{DR£"Á³ƌƒ£‰%õ¸piÄîƒ µ°¼øÂMâ(âܸOq4çòƲ´žY±¤Ÿ%¼ýÖ¼ô ôTÆõ?r“íÑ€ÿﯢÓŒú#âºBåJKœ’tÔ†Þ¦…eQT(•„9IóÀwã%üYçšUÙ£®J¦M×ÉáHÒ¬•ïk%È–ðÞ±È ‰Ž‚CÖ4ôú=z©Â­EB¡¹ŸE[“¦ŠØÃñ³ŠßþÎ/rñ¢Æ7vµ/aNm¼Á»à´k©1uPT»víFÖmÀhð¨3gm·n8Ce8åhã†3ç”°9†ý„¢:#«¬èlqpÈëÿâ²Ø»Ï3Ÿù#|æG¾ÈÕq„ˆÎ8zZ³¥uìà1 IDATá•ø¯œ¿Â+ŸûñSÖ$ÙàøNxè]ÝUžˆ²»Ëå¼Eç®M¦ëv»¨v…Hð 7Ze&Éþ¤D(Ïö(C©\ ÑDN°T ©’¼·³Ïí;ÿŠ ƒˆG ìô5{‡^¢­e.c§ ∹1Ü)Š’jYñ±k)Ó™f£—" Ñh9/)ª’~¿ÇÖ`‹h“,NPBÓ4ž8‰˜N(—–Ñ8Å G¯×'Ib&ùœá¨Ï»w8´9W¯]á[Üâê•+<}å¾}ïm~æSÏóó¿ô·ù‰ú댲ˆ™9&ˆh'=¥T«½ü¸è}·O÷ì×£éζº¬Eà–Vi‹pÏUûyUBѦr•?¶±®5ǯlîlGí¬Åù1zÈÉଟ§[kŸ‡xÕñëž¼¶îwÃ5§è¸n©J£à$y¿òàç@F1BE+ZŸS‡ ²m$Ù]C-ÓWƒØÖK@ë}ÞÇ©5ßÖ“¼Ðè$¥1›Q/g ¶.­úW»v®îxÆTÄúd*oî·CÓu\Npm´Ey^Љ“¦<¦L çxìXcpÞIEÓX„o˜MVzu^›#Lûl¢öþHQ,±æ$/‚i³2ÁV[ȽIšIa¥-N*ŠÆ¡$¸Æ2©-[£„╧.a£¿€š~ŸïñìÆ9¾öÕoññ^D’"ê]n?üç_üÓHáÀ”Lxã½wyýö·ùø³×Øoðæ׿N&{ì¹Ûã¹+™æíPVsÒ8#ŽJ+yæéëxàððt4`k4¦Ès&“L¦ Ûׯ¡‰hp\ÞÜäÖ­‡ÔÖSåó dGÄ*)Yêší­s”^¢1Ä>ØpY×ÌæKó¥£ ‡h³)öDZ¶i ÖC•\SÇËxT“f=„Ô&Ô÷…TeA/IV¼-"0‹Äª¤³\.ˆT%£•-!'5¥qdqÌ´¶l¦ Í|úÏð7ÿ ^ŸÄN…¹]€]™¶ÛåsW¹yñY h!Àtîì@±+ucðmKáº3¿¾yßex sí^ó­ýÏ(&û|úÏüu.>ÿ,‡·øç¿ù þêýÙ ! :L,S‹­og¥”A^~}},ré¾› FÇ©µ´Üwëm^÷àMUnU­j-iªV%¨½¶A* ÁYƒ)«°°ûðý|>åü¥++ïÑ4Ž¢4í$÷,³}Ë%^HÆãMŒ©)óŠÝGwHî?|ÀÖù1ßxó£óçÙÝòàƒ»ô·¶Q©â©+×xçö{%-ñÎsɯ|õ·ùá_ÅÈPJ2²‡×}’QJ]†Ù¸ÕðÍÑݘˆ’š¢¨Q±"“Éj­ëze—ÎyÒ¬uA"RIVÇì°V*¢(Ô¨ãdëñšS¿cÞS7žaâ1J2ÏK´¤MM£^¢tߢ¯¼ëPãAŠÑ ‹hÇ‚1¥w½Ëå Žaaš†(Ò¸:”ÉΚSµ–EŽA“õue®Í5«Î 0?îæñ¬œw •äæü4£ñ0à&„g2ý]¾ø~Œª2È(È°ª¯üþŸ{î?x¢p¿>ñ|XʹÍ2žðÖϺÀ.õu:ÕöaQÌé}€•ž­Žbtœ t„Tá½4ë±ûö³(IØ$‰ÑQ„ŽtÛ ¤ã„8I™îcM…ÀSKpAs´ª*|ãÑ‘ |©UŽbªbI"lô”Kš¦¡(—˜Æ Šš~ñ%~íí÷HuÎ ËV†Ø‘œwg’$,‹š”ÑhH^†º‚[1?¸@Pí°µµ…ÉkzÃ>ƒ!R‡x ‡{B±»{Ÿ(Ò,—ÓéŒñxL–eäyÎx<¦(krãYø’£é”ýÉ„b1åÍÝGÜ8­ÿ˯Þç~ò³‹DjM]ÝVcC%ÉÚXtHñ•< ºR*=¤ Ò~]4íVâ*–Æ9ƒ8C]«¶¤Ó@?)Æ6«Á „XµÐµÎØ@ݵïó¸ã¹šÜMI±œ…V’5[’&DY¶Xÿ­Óÿﶺ*‘:L@eY‘¤é*¥×›°xœÖ à,ÎY¼Ð8¥ð.€mÅ"O#@‘ÓÎîêúš*z±j“B¶¥šHE«¶—³u¡$uc-ÀÒwNÑfIÒlвG…ãê65*“ó:@ÈÚ ,æÄ*Ü”0Ü,ùrIœÄ$i ¶:"N3œóÈH¢”à´– ¥{Æ]mz÷Ñ}eÍ|™Ó8ÁÑÑ¥x¤%—¥!FA4"µ¨Æ‚êPàæwBSZ‡FIÅ@ß@>Æ;w•¼ÄnÁ{¹âÅ›ã=;K‘ ‹é‹g>S•†o}pÄ8¿Ã£É„ç®<ÅÑÎœ½wöyç~óß~›ÝC=Êyã͇è‘ç·¾üƒs=Š¢¤(+ª¢b±<¤—©ª‚á(%R’¦nh¬åê•ËüÎW?à#Ï]àü¥ã¬Gb“|Á«Ø÷ g¦Sž}ñs¤2!IS²~Œ%H9zDÈÖ´¦|z]èþÂ(ˆ]mÙ74¦Béø1ÀTxVk¨ï*|éÎÒëõÖŽí‰õ±ƒÙ•LÂÜ"H»B¬ÔØb‰Î2nl^¤ôW9:z¨M¬j­@±wmM8ÖüÊ%Ÿ¼~•¤L—öÄ8<9®Ú…WJÊZ d|…¾>¬¾/ÀÚO¯{]6GgýŽõe/l?O¿l[눯ü›_EÝx%è9¯?„ï¶(¯úc¯(Ú3Žµ~¢g-ØÝvÖ{'?w¶‡µ R…Ôºài¥òða"p$¤cÄè½#NR¤ŽñB‘ Fdƒ!io€”ŠÁÆ6ý~ÐÖqF¯—rqœ¡ã„ ƒ„(MI’”¿ûo~…/|ôcÈ(a âæ[¤‘ÆLæfž¦•4xzµËeÉ0 ²„_~ †É„Ù¼äþQ,Y0@ "ÍÃŽ–î<Úá\oÄÁlÆd2¥.ÓÅ‚ežóàÑ.Ã~ŸÃ½GTÓ£‹QÞpééç©ÊcrÆ£ ÑËÙ)+rçyw¹äÊÍg¹ÿð>x—ç?õ—¸8W$Ô5eÕ`] [´­Ç[•I‹ µ€~Un蔾DûŒšÆ!­0yð4›Æ¢¤d>= XÌpÖ T Zµé´Ø%0ζ¨\¥³Å©t¼ ÛÖ.\pQéÚèü‰ïvv¸n“ÖÕØ*x»q–!µB„Ÿô+Û>+m&õP‡–Såè(%¥P:½ÐJ@‰T­üåéqæÁYúý ¿)œ%Öš,‰q¶¨b@œ¢¸›$N×!Dáx‡õ­±J©«ÖÂS•E`É‹Ò€®–&d‹¶UºÕ¤ÖH¥ñR´­&!Ó:l`õÒIX”[òŸ²¬žãóóÞS—‹¶ön(«iêªäèpçýþ˜(NÛlB·@)Ó(bÅé­Ô1p(ôÖ;fóqÜ'ë P‘¢. ››[ØÆP±ò”óe!Öa«*s<;Þ9Áb™“—Ls6HU–%¢©©LIOUlžÿ ¯Ýsß=Ã¥þ«X g Bfx$(AQ[*¯¨œà£7^àŸ¾q›O]3Í&“‚ý¸ägòð™ï…Q&¹x}̳/\bo2áÞí)×_QË’ÍÍ166ñÍŒbQ’ö$Þ+&Ó9q$yîùâLŨïŽ7ØnâšÀòuå©KL÷v™“…V8µÉ³?±Šü$A¿x¶,Â3A«{,ÇËi»ãˆ$xètHË2GF´›®]1`vZœ’ÐAùJ§=°œÀ¨ãì1ó[ˆšƒðËF"Ú¹#òº êQB°5réâÇøû_yÄs9¥-™Í\ÙºÄÑâëU$ëŒÁëçxùéëDxj¡VÎÈã)êö}$µèH`êæÌaÕI$$KmNb¦ÖǦ&´žENÙ€P)›ƒïáË¿ñ«Of;y‚¾P®&‚9Îéc<~N~~¢æ ¯q Õ·TtÆ´2wëÔ}f4ÍP3‘V'ŽmO’&Ôv¬µãÛ@ù.mÖ5 Bíë¿ù±/²lujÿÞ/ý+¾ðbÛ;»yž¯eç'l£iÐò˜Ä$[nv ãA Z,2^§Õ?tœúÐ2”&1憃m„-y‡ O&ݹu™DŒ©JScmRÅX< /gˆCÅ1Ó|Š´7ÀTE ®S–Ó qfˆ’ÆT,&66FTó%2íq´\9JI¢D#a:/‰“”ýG6·FئÁ¥¦®ˆâ„Æ¢8ÁÖ•zœ©hÊšª*É‹‚áxƒÈzã”$3AkhKÚëSI/A‚2›wÌ+M„`Ø£¤#÷ŽÍÑ! }'ùÙÏþ8¶iØ9Ê™O¨P­ãjê‚<ÏIÓ„¢n(lÅ|ò§yýî?F¿wŸjÔðŸy•wÞ¹ÇùÑ.ÇÄ’ª*Ø]ìGšsã1£áˆ‹ã ´ÓL¬%I5‡»9Üñhž2›W|pÉû·'\½¨øüßàÑÁ>UU²Xæ,ª‚²¶<=„¢w…ÑðG©œ%k»²í¯O´¥YÖf…©X·Íõ1³tGÞ9ÇE]IH#BRÕê=hE$Qpª¬WÌæKÒ4&25G6‡ § xŒ±œ$’’R²¬@fí<±ƒ¿ù£ˆß|ó]úÉWØÞR5– ã+  “I8 ?òÑQ-p9Ï+’$iƒ·ÓÃ&Dųù’ÉÑœ¸×ôãNð©±-„x ³¾žYB'XYOqtt„Ž#Ê&A·ø-õô«Ÿú¹ç>ñÐúߧky§·õõ¤çï%½þ;§÷颢®Î®¼ëk (Â8 ¤î«4ËÉ“¤q6Hበ\ … )BáÉÒ8LTÖbAGš,IP±&‘”¤:´ed*€ViHžœÏ~ä&oS™)/Ýü)Üù™A*Ó’¥à²o÷sÏÞÔñôȲw8£çr爳¶(‰â˜žô˜Ú¡µÄ”•·àÛçÏ#H'‰ã„üè!GyNoµôšíË$qóÛ[D‘fk{Ìb–“Ä}ö‹6,‹%[Û\ظėççøì+ŸÂꈽi1ýñ§Râ$ M¯7$ëÃ=èC !Ié÷ú«rCk¼8Ò3‹Ùט6Ý]P×%I¤HÒ[ئÆ6!Å(‘äó ¶®hLR!Z¦©)ó9M]r˜¦ÁTM]µ‘¢.óГÝ4ÔEŽÒšºXPW5Î64¦Æ5Mø=S%):ªå³\ÒÔ¦*1&è;kq¡.s\c°MMSWDqœ·º¢\LÃbÕ”4M1ù¢Ή Bò–,3h®®Âµ¶Ä"u±¤©ËÕo7uèð¶Á5u±ÄY( õ<¡quÁrvˆµMàï6UûªqA*Mµœcê SWXkH¢—²·»îÛöÖƒk ¸ŒºÌ©Ûûkª¥#ÊbÑŠPä!òñžºÈ1µi ;e1”ŽÉ'¤ñqùIkE´*E…Ì•Œ2ÐqjÑR„–¦ÞxeŒ†ÁÆÃ~;.ƒ®vœd8ï‰Ó”4ë“d=”ŽBÏyY“fåÿÏÛ{ýZ–¦i^¿Ï-³í1a32ÒggfUv™nªª Ý=x3 ¦Å€„©‰ „WÜ!Ô7\a„j4i0BBÍ84@ûjºªËe¥ÏŒŒ sâ¸í–ý ßZÛʼnÌê™%ʼn}ö^kíõ™×=ïó,—(mR£’œéÑ1>D —I4¶.PÀb>çl±¤ª[Ú¬ƒªŽÏ¯’Ú2-)Š‚Ö |Èॠˆ0èJùµ_ÿ?^pttÀtrùø>÷>=ãG?ø€ïýä’a¦¸sgÀKw9;+Xi6"4gL&C4‡×G<:}ÄÁሞ>ÁŒ~‹o¼ò*€oÎË€—!©Ñ”ëÚàNDçxßÜ/=õ%9ݧâÆ÷ÖMCð¶Ëf)‚˜ Ø‚E{| ÒzÐK·1 QYLlÙ“$”Å’AžbdÜË…”¼|ë:wo|ƒŸæ¼ºÍ²œs464M‰ “ã_çZ.h‚«MÏ÷SŽˆ+9›{ê²ÆäCZ¯º.‚È·p•- ’4Q”Mû§le_ÃœƒaΪhHRŠïþ_ÿiúΫjv_åþ,uãŸå|ûÈ·«êyûÑtÿ³ót2QTþêûÙï×!0 ίÁ<’Àx‚'“ŠDKx)˜˜€ïy´·¾—)üè ¡ñ!åÃg„£×)'’.—ŒBAEÎ*˽—ñÛ__iÊÚbsÏËù˜ºv¼[¯ M9Ú6‚òAŠ*‚§`cû‚TŠAžsþØAë8zî§>#Í@³\­ÐJÆ>o/ ‡|ôø!*ÓH!xù¥—ð. ”ezø4 OÎ.#%`UaËH0à7)TBÀµv]ã#–Ë%yaQ)k£P”¦(û£uÇ{»ž :!M²n\¢Wœ'×Ù#‘uUäC*ìµã…j´F4GéÉؾ;=“ON“ä#¼n7óOE9Å~ÓÙõ½&­?§MÂ@«š¦\’¦87 9.g+F£.lÚÏbÊœõü…ˆ|΢LŠ&àBˆuçX·¬–s’4ÃäC\Ø<þ>C‘²³û]Ks5NÏPIN:œºö4“™Ú­J²u$ÝσÃë1³Q,×׌&ô}rÞ{|í{稊‚ÚGzÏ$IhÛvçù Ñ}Ï~£WD.â$GkEšg¸îy,+ÊElÍêëÌÎA¯¢Ù;âMÓÐ4UÕÐØ@MC6EdpðŒsƒ­kX,.—\*u–$‹s§'²ÖÆZºó¤©¢°–<!‚£i[.mÀ:O–VË*‹^jš¢X1ž®7ï~L´Ö´F’ñòÛ¼õˆ·Ç)ƒ|„ÉÇ<|ðŸß[pøÚ_½þ'³/Üœð·ÿ—?&Oƒ¤a˜¶œ_žñóo>Çi†ä ‡#Ž¯•¼úÆÏóüO>¾ÅbYfS~ôÑüâÏ“?ùÉxÿñ-~ë¯<‡ïæߣYÅÁÁ†•&Ì[‡ojÒá„U»B‰lg­ô] =Íqÿúz/ :OÆtYKE¹"¸ÈÝ ”Z ]XÛvûµZgo¼w Ū¢Uo àh­qÖ¡ô^æËYF¬I?úõêlàŸ{ë«´T¨Rû¯cüÉ»“Ægèù {|›åÊu"ŸÎìF _C‘ÜG(¹£P¶Þ»ô÷7Œ)‹fM.t•¬ë†A6A m+ðI<·zéíoÿΫßüµ+òvúbÛSzV]ù‹ ôU‘õU†vûÜûïí7ð}­ÿ¿ê?Kïmu5“®~)¤É&Í*„è«~­²ä½'OZL"É´`œKžL 2ÕÅí‚H•Ø݃’ÿã‡Æaúˆ•þUþè“ïr›ÃdƧ'+ŽG)–šk‰âoYTH$mhlÃÐ ¼œÖ Þ˜ÞàÇgO¸3L™/VŒFC<®ßÆHÍ$¢uÂürΪª¨jOQ´­#áCS¡Íƒƒ&£1mÇN5NÇ<>;¥žÙÅ sNÎÂóm`<9Š4š†£1mÓRT1uèǶíZ ¸w¬zÔzY¬bmŽ(ØX6º«¾×7ŽiO Ñ/ïmg´¤Òr ¥EM²1˜ýµ»Œçì W~]ëê½Ü~.íF±>Ý3\õ¤ R'lK§öŸ‰õÏ8·²,C («H[Š÷kâ ë}ܧČٰUõXžÅèbvþ˜,ϱ6öçî;«;s\JD°%ãéʤÐE6ì¥ú{¥µŽ"uªw–¶S/£«I÷c?ï(Ê‚Õ|FÓÔ1"rÁÛ³ÇÅ=%à| ˆ(?BÀ(k‚2Že¢5Rt%)kãÆM÷,L‚ÒI$‰! „‡MSQU Öãà *ÍH‘ž,‘\xð.oÃ7ŽoS œ€ËÆ1N ÞS6‰`›–ùª n,u(8>óúÏ=ÏùÅœäú­ \Ìæ &>»÷S¼‡»/¾Fž{2Êr ^}í5Οá€Ã,åhTs8¼ÎÃËGG‡ÈóŽ B*Æ£qä^ÆÑÚÓ!¯#Åž µ–ª\a›¦3ŠñG½a‚ê¤ÜzL7s#¢À7ÎV䎿ïâöžeÌÚš¦®úA~j¼{ï¿›]qîêá}Ÿ¶RE¹÷¹íùQÏ!ŠˆØf¤Ä{ÓTÞÑ´ mÛ’h‰uÑið>R`Î./I³ì° B› ª½{®Î{”è» ãý¤©a5{Ò¥ª£¤èö|¾J²w|$‚ÉѵèÅKµq’ö€™}fÀ{OÓÔ”mCð3F£UU2Oé]¶Ô§d4žišweŒ %¿î3î7²¦ªÈG)mÇaß¡{·ÀC½Ó$ˆ¨p)«²f Ii#‘íÏyÛI‘FU´Ði ÏFÌ/gT­C9…ÉS\]v½o¥!ÀZ¨ª†ºµH©Ö|!ekQ¼Ó8Î ‚N"Ò6ÍÖ”¾ÛY:ïcf®®Z´˜áˆ|а_ðÚ͊ã[Ü;yÜî}vŸ·^xWx¾õ­_a9/©¦3æËf ˜¹vãW(‹‚{~‚ž-©Ú–—^Ÿò_øŸÜÄ‘4¼[žrïâŒ*UÈ[ÿ&©p,… X<™×È,åä|N™ ÆhmPº„ÆRWЛùä£3&Ùš*6F¨vÍ1íœãâüœ,Í©ëš< “4Òy®×» ô¥$Më×¢1uí°Ö3DV½EQ‘jIž¥ÑIS304>Î>çŠô& IDAT™é¸û×bggt£F¿M‡àñ*êB[emˆsvš¦Å;(ªŠ¢¶$Z+¬€·€Øzÿæz»ö-Rxâ=.8ö+¬Û{‹¡b‡Pª%‹e‰®¤D½øö·~ç•oü“WF±_ ѱmXÿaηoÜwSbWŸÏèM¡~;‡MÄ®Õn5v®Bh‡$*¤‚ÑI§ µ.¢mût S…~õåÛ8‚PÜæ|÷Ór÷ú¿„«ŒCvÍÿŸ<@%³Ç'È<å´ö´Ñ|îZMË5“ %H­¸}pç<Ã$cU–œŸ_2>q}r“Çî³8ÂxzÀ`â›ó³$é„Ñð˜‡?c01oK[sê ¨V<>ÂÃëÜ}ó¯r÷ð:IjH´dQ²Ô ”æìâ’ªªq.¦bµÚ‰ÖBD‰Â™I)1IWƒÎ[éX¿y/¬•‰úk-¢W±Wgg¶‰6œsŒF#”èt“ÛØ-x:B±!ÅÙ^HÞ»Íé"Ö "’Zî9‘ÛÎ_žfŒ†C|Ûàš2ÖfÛ6‚ÈDl…p>¬7°bvŠGlBu¯a0$%*[†¹¿Vð–Äl´¢…L§cÎ|JQ– Æ“(Ã)v½ømméõ:”Q=Ë$çc]O¬7”§¿géõ¼ÖRªªb0ž õÓÄ)q­¤Œˆn„Œ´7:5yD€K…s“¤£Æ&]í£A.Ë’´W‰“‘P"ÊŽæÃáàE¤4kÊ¢Yß·2ézNÙº¦)VÌ.f]¿Íá4auþˆ‹Ù"₶%®Zs½¼@Ü`txÌ¿ò‹ÿ,µs§8™WÔr€‘àUBU[‚PÔ£i­UH &Í©›Xî©Š"ÄÖR—ÎZ²AlÕ¤[?ÎÚØ©ÑÍól0 D&3×­‡¾e)Ikc¦ ïY­dQ‰miª±.ª6Uš2-ð2 B@k…ª—è$ÝIJo?û9êËZ"q,«Èóß[uÝ°š/X–Kܳ”–“ÒÔ.’hiµ~²õÙí} Ë‘QŠVe…»¥µmÛÔ·µm "0šòýßÿ{èí4á—Ïk]uüÃõ/D›~Áy·ÌU5å¾ïÌ$‚ýÖ;’-âx×2 X\.â†"%&ç9›µôÎub-L/P`Aù€ e”³kh 埢D Vã‚E M"<¯ŽoñÈžp¿.yãöó„åŠG"¶Ï×ç)UUdÔræSRxo¸=ÍOFœœptt £³³'ݤ¬jVeÍ+w^£*–Œ†‡<~ü€´UŒF|Ý)Þk—älÛ0ñ€ëÒ·®a’¥Ü4­QÅAJ«²™ „µW(ºtçÚ(Få))y’àu4Lmëwê5±%K"ºŒ…ïêUÛãÝ/€~þyï †,‰N(Š9ÁuÑž³hmbÚ´÷r¥À55R%O9lýù•È+úãýmÈò-=çóSê²¢,Wx¨¨s &M±Â')"!¥@¨ Óu(“®Éÿûù«eÀ˜‚c¾,cÚÌÇH´_wY7'çB¬7ë–Š¶lÑfS7°uÇí«zæ6XÚ:‚¾„ ôõâÃâ×Eÿº÷¥cO«î6C4VÛÄ ñ™Å2A_®@(LÅaDGÀ$ñ¬Kú™—«¤(*ŒQHcV«X£GªÓ>RLêHé ñÞŠÚc³¤ÔëZ¹s‘m¬q‚d0&I '÷òèä„¢Šá8f0ÎÊRI泋¥ucrxyÔרv¥PBGƨNÖTÈh˜·¹—û7inA¦7ò„Ë?¥ ?þ野Ý#ÇñÁ \œá}Ëdr€µ–E±àÎíCVuI±hY•KÎÛÃl€ Q¬DÙ„‘óáù#fFóÒË_A!ùßOùÕׂu<.*ꑳî×mɘ¯j‚kAe£pA`” Õ1M&qZ‰B’„år¡%øh˜ däUOó!T§ë­H’…·ÖmöçŽÐDNrl j@ X®j²,Å9B³ª&CÓيãƒ!x®³•% ÉÈò4–7mk»–¦H†‚RÌ›¡—!A*‡ìüà=Ö:f…%ÉðE´¤YNÙZ\å*fU„x³ }:|í€ul‚MSSsR“PÕ©³c¼í<ôëGJI>ˆ¼?¤*«Ÿ­•j{ÛjýÿqìÊ!‚‚¶ÐÓ½ j#AØ1°Ž`š&ÒçöêªF[F.ŽQ–_~?F½Cv ©³(†ÐVh©xðà!ËÓLj|‚ÔŠl‘૲“ …f|4 už¶õH£#1$O­÷¾M3KÓ ˜TÊ(níàl‰{H)(+Ë£ÅsÜ_òI³àƒ‹GÔ²å•Gg(±äìl†i%‹å ÇÓ «'' d†I‡È ™¹šÉ`Há(ççî¾ÌO>ù€•¯˜ ^ºþ"HOZþ‰7¾MpŽEÙT†2‘ÙM‰N O4˜5Jƒ‡.m¬I’Ž ¤[·I;[r™S—®Ã|VU…Nòñè××f š¦Y?Ë>«‚²±è<!ЉÁ…ÀdrÐí7qÖÖòùé%ÇÃ!J)–¥å²Z µá"F™à΃X.Òšeh]kk¼\œ/°2~÷²,£šàøÈÈ؉²·ƒ´¾Ýv{ TµG¥ÃŽŸ5„xßÆmŸË†€Ð†TO°Þ?Ö¾êØN=nßÜþ{®zm{’^õú³ÞU.ÿª{B0Èò/ŒèC袟n“ÐF’ë$oñ6¦L’1Ÿ_2§QÖ ÎNOAhnÝœ’(SÙ‘8èzw!rD/m´¦CÝF­X¤¢¸8á›/¾J½pœÍf¤‰!M>·eKC+Y×ÝðŸ~ü¯¾ü:ÉñΫŠ›“C~ü?åí¯¼E®3Îç3VåŠkÇS>´‘¼‚€*k>~r—ï¾À{Ÿß£l-ÉxÀÇï1 ùÿê_¬‘·äøæmÎÎÎIÒc“ÓZPÛÀ E¤/è¾µÔ1¥Ý©íñèA%ÁÅJé°N¡º–„Π$Æ€1´mw~1½Ó"§=m¹ä§}‚Ç`ò(G'µÚ¡ø쯭Ôeºoô·ÉæðkºÂªm0RP--¶®¨Š’eÅë“$Eg1xKÒ!¥FˆÈž„ìjkv¹Ñí8ã%]„V­PáJÓl©þ¤€ÙÅŒé(ÅhM¹¼¤ 5Ј6òûu„í‘W(m )ðÞ tûÊ÷žÃ¾¡Þ’—ï½_ƒ4m‰%ˆ€u6’‘HIíb*4Ióu­Uwé{£%õj{ç;ªÇà½ÇèÈe_7–á0Ýa-ó¾Sôñàlˆ””=n@(DÓ¤[3¹ÅuuªÑ†²j3./S¦ÃA@–Y\žá…Æè„étJÝ)& !`-r/Ç…ßÏ•¦ÇWH@lgtzD²-£LQÔ”ÂY‡÷ 5Rüæ¯ü2?|ÿSîÜÈñîU}“jÎíãÞ~ëuf§—(áQÊ£“Œ“''ŽHÇDcYÇEÛr#H>8¯ø|U²Ð»×ïÆ{"f¯~tï=þµ·ï¢Íˆ¢­bóLãýT°QYÊJBïkEžœs,‹Š€¢ªk´R(5ÂÛRt¬[ô›»{ŠåhDCQÛã*xŠ¢ˆÙ Ecm” - >?_"ˆ: g~÷×ÅŠ|r@‰,êÀ¼p ËÒÓ阅oÁhdˆ‘>:oÛ@é<AåÞAã-I:Ä;¿Î2 )ÖÂ*Ûçâ>æCÜ߀PLo TBïª}YBÜMuø`:ýÙŒóö†ø¬‹üe#ÝíÏ\u<«®¼}ôrï™>ë|BlXe¼s¤iŽ·]ÄÜ©!yW³˜-hÊZMÑN‹S¤”dy˜4"!DxZ€cûÐBãlËö7þGþƒ_ÓÔ£€—Ž;“Ž†œŸœ£\Ö–óUÉã1w¤F!¨Ûv=Œ”d£Œ'ŸsãúÀ%óbÉóÏÝá³G07_dVÌyõÅ©‹Šº¶ཋì^NðÒíùñçŸp_rá²àîíÛ\4`’¨=\• Ý É¤a4=@,—„ªí2ÝÉømG@Û´ÿøÐ’ç9uµZÿÍ÷`§­è5Ë2\ÓÐt$%QjX®ë‘ûuÔX'ª*ÇÙßÔÓÕ¦}j{lÏ«Ÿåè KŸ]imÑ£MMÓZ²|@6œ¢óUíÑi‚#‚…v®%"Ù‡óªµ$@¢mÛIâ<Œð•>ÂÚ—@ãZÓ1yšòà³O±­¥l[R¡PI×âÑŒLKLfX®ª¸n;C¼‘%}ºlû^·âýg±]VÐZsyy ¦ÓiGÚÓÆ1ì° ýuú,EOùØÔLš­ûVÛ8œmcd&6™’þ~ú¨­Ï 8ëÈuéÊZG[ø<®šs~ö˜ñäHM>ƒŒŽÂÙÙB†ã”QˆDG‡£Xéž‘Òж"Äù¨»ì@šÆzç “\”q®d½pHèTѶ–¦±xe¸6J°ÎÓÔçóVq”xVÞqÛä¼ö‹«Ÿ~ü ONóÚ«· Þptë'Î88:棓û¨T’'š×Vetö”àöøÆniFI^;>Eè,Y¢YU»Žh¬…ï%}D¾[¿ÝBj¢žñ|™Ôú9ÅøôÚÚ:ötƳ; mÛ¬ç}$nÉ¡eµŠå’Aš “lÝŸ?/bËf];™¡“hϲ„"DìCˆr­«šãƒH…ûðtÑ9!-©Ö,[2Á ¦iwÖáö^·O´(¥ÔuCck‚2_\³æÄØñpÖB[ˆµ¤ÂËþ‚Ù^ÜÛ¼o\¯:ÿþ îæ‹6Ò/KGöiTDGë`<œ¥© \[Çâ}iŒ&G(“#¤Æ¡pA3žã¥ärÙD¬±†+¤ÅúÃÑð»ÿàoaE Tõk‡´Äö‰õ{œå014Ë™'ØÖóØV•°ZÕ¬.¼ùâk¼ñòë¼ùò«Ñ@‰aIhþà½Ï¦’ÊÖ+ijÇÙù)‡‡SªeÉl±)˜•KžœòîýϸhæL†9­ø¥Û·qMË›ÏaTJÓ¤¯ÑBòùù’dxÄ­Û·¹vã˜ÆÖà Úº&ÑqlGU=ú²ÿýª´Í Ë‘ò<›¦ëQÞ›y71J|ø5ož% ò”¶©p®¥—& !ª+!:M:¦ÝóÑ“ž2ÂWÍÅ«H|-ò§ëêkÒ½ß ‰Lr’l„Jsʲê¤#‘Š#àÅÆa R¤™€LhÔu$0 mô–,Ÿ¢L¬Ë9Û:2º-ãĵŽ³'qÎS6-‚˜®“étÇIR:"ÆÓtW‰'ˆÈMlôn‹ØS¶Øpto?›õ8wÆ>¸€Ö&ê§wÏMø‹5I†!Z€$Öë‚Ì|[b´‰šÂ]Äшë4Ö²+7Åžú¶r„"ÄóçwPìÎGNüÙbÎ|¹ *W”óSË9¨“jŠÅ‚N®ƒ²î@2ÁZG" \ÌqM½¾NÿŒêª¢-kšzEYÌ)–T«%uQ³œ]òðó¼·8×B¤I Ú¦Åqëë¨kÏ4Í㋇X+øóý€ž<`Ö´|í¾É‡ï¼ËŸþñqz²ÀÉY]  M8Ö9¯Ü}×î¼ÂëϽÂp8Üíë÷‚¯ßÔüïÿäI‰WOÛëÀ9Çr¹äüü’¶‰Ä4MUP­±/9IÎ2Γ °ÓÅqöA`½Åù“DJ\ˆ€àZDpXÛš$¶Ð9·³#dEáC”jÝd³ eH²QW2ñÕát¢q­£ZͱmÃÁ0X‚&à¼cY¬¸X´$&çbÖr¾r ¤f:’¤…$é£5Z´Ž¢'JGA!ûÚõÓAêþ>Ó?Ç,K™Œò˜™ b÷{îÙ¿ý s_Y·RíÛg¥“¯JîÃØŸõÙ«ÎïiÿŸåˆü½ƒ,¿ÒP÷÷¢;Í×b+mšõ=+É9úÔŠ6†tÿ?"y¿p ³"h(vÜ]}Í[×g<)Kþ÷?þ=¾}çË`ç=‰4|º¸`¶øóœ &ËIQ`4ŸÏ–üá÷¿Ç/½õ5´V<ý9ž”3ÊÖðÓSÍ¿ó¨ÛˆÀýøÑ»¤ãÙtHÓ4œ<æàÚu–U‰2Š{Ÿóͯ¼¶ªy.?æâü’ÃÑˆÑ å¢X±,CƒÃCš³ç<Ò;”w,ª )3|ð8Öuæ/')7ÄÛŽ™ëé2»ÈT®€(oÁ9}EºòD'§(—¸Ö"uÂd2ݤ˜öeûsbÿœÛó'„Mßóöç¤R­IrE¹\"¥¤iʤëv’þ\}¤¿›Þï ;ˆ’˜BcѤdqq†’É8Evu²4IY.—”åŒÅù9Iš³¨[®ßDu%¡»G-‹åÝÕCgl³$’é"bvÿØv¨û´äNö£{Þ¶im6€°ªCÓ¶­¯ù§iίÁcÞÇÑZK>žF6´°q”Rû!¶µxgqVS.‹µàœc8>u=Oq/ï)¥ŒõÃ."3IÊÉÉ ©QLX®µëþ\çOÎ/ñÞ3™Œw2:óUÍ Õd,‰-U=#xÉp8¤¬«¨:g-më8š £~´õŒÙN@i³ÂR´‡sÆ×Gc _óË?ÿuŒÔ´yνw~HCÆñs׃&N˳¨–çïT%Zng‚¦ÙåÀÞLÜ@Кۃƒá€‹‡+<»àÁí9Ðg"à EQ°ª,ËÚ‘E&Tdz3†¶m&†yYâ[‡Ðg¥-;ÀfÎl¾Bë°Þ{û JQkìJw£x$&˱uCUU ól¤XÕ->L:ìœ÷„ …Éb´”’ºiiŠ2ªvÔ¿OY–ÌØe<´ŽÀµÖ× Ô:³ÔG÷ûíRÛÇv½ÿúþ¼Ì²„ʺµFõ³>³=vkÇYˆÝ~¼«# ψ·7Ý}ã~Õì·Ç\Õ.ó³ýç›-‰¹íûŽ±FKdˆ‰èàãB”:‰D 2ûÇCƒ·‰4xÙ@G¨¾„ãéˆñHEP-qaבٹ¦x#ù½?ùÜ_æ¢Å+M[ÙKTB©n˜Ó¾r¸ XÍ–Ø4ás¿ÿý?c¾¨x罟*Éù½ÿò[7ùÖxÉÿ”,Íø¥¯}‹!šï½÷f«ùø¡ UQðùå ¯¾ò2¾ª©–%Y2àèø! MæÉW§Ü Ž<8jZÚàxÿý©ëš>|ûŸ}ÊÅécœ…ºZâmL^]ŸÝ›@Ó¶±FاC¬ñ[i4qœÃ·-uS3[ÌÉò!uSGñ ) Ö!cY3ºC[©0¥&0˜^c|p ! !ô©¬§=Ôm'Òû{oñ®…àÞv4ƒa}!b ]kƒÉ‘¬_Eµ3™d•D*Nb] )0]±®kUªª¥Å T†Ô9·\,e¤#¼Ö¬.S­V4­Ã9K]ñœ 9¸q© ’ôH‚£¶Q–Ô ‰’ÉhŒµ-eÓdCÒlˆ×9‹²áñÃG”‹9m¹ ,—TÅŠÖEfÆÉ(Ãh¹Î6ù¶EøÛV]›¢A'¬µëòD¯n¦µf˜åø¶#ë’ºkQâ»1Û¶¬–%uã°6PÔ-A$Ì. f³Kî}ö9NÀ²©Y¶Yeiƒä¼(i…Áë‘$¸®¶^V–'Ô6é^éçd$qëLÚú÷/9BØpí®“¿u÷6pã!„ø‚üìÞq•ñ¼*$ÿÇy|™A!<…•J®=±~Óu®éR«tY"Ј-$ªÇ{h놂4FÏ<Z ¾óÊǼtÃðÑÅ7i[Ào!ÅUàÆõ[|ä*žø:RqvR6HQZ µæd`ø¿ß‡3íøÏ"ø¾íx0»äÕç_äÕÃY.—\¬ܽó<“$ãáÉc–Í’¢Zq9¿äð` Ë–Ù¢X£ =žÅù%mëX,–\|ö˜V)j#C¥ ³jEµrè|B4eÝ¢LBÝ4ëHøgëÑhô”³Ö{ÐÛ¿µ–å|ASÕŒFCò<'Ol]Ç~Á¶“÷[ ·®×¦i#Äg¤©×Ï| }¼ÿs•!‡Ý…Ôk%ëŽP!Ióµ4ž#ÁZTðø¦Az·¾n¬³S~ƒï?¿Z´C%i$Æ–Åb‰Tšf5#Ô+ª¦%˜!zt@–¯tp§ÓC’,CkMY–;N lêZW}ÏÞP÷ïÙN±= ][ X«Õª+|½ÂûÀr6#O ¢m¶¥\.(«šd|¿{—~í;-úûë¯ÕjÁr]«ÒöýöqÛõÖzÁDu]ïF5Jã¥B˜“ 0]ßvŽ~L·Ë3ÛYÄé(ÅÛ¢»v Ër&“ÖUdyÂÁÁˆÁ`@–e1û\dv³ „C†Mþz>†€Ñÿ7þi&!ç/.ÎxçÑPÁ?¼G©sF# [“å7nÞ4žžiƒP’[Çw¸sãNžÜçíéïLSûõ¾·Î*Åßúýßç`h¹qc}—†  FvÊr8|[áÙ£þµ"M’ˆ#0)çË‚³ÅŠEQ"¤îZvƒÎEùÉ 4:ɺ½vCFÒw½\ØõG]×TUE]×ëÈw¿“#„Øoò “ŽÈò1Íh|ÀááaWÏŽXˆ^@§¬êÆ2_T;ã¾½N÷ßÏ"]ŒnßSÿ×qˆY™mûX;ñ_ôæý÷þ‰®ÚĶ‹çÙHø/sìLtù CˆÎÃÙ º‘š³©!Ž¢XxäzíúO}ß*aiÛ–ù|…÷‚U[‹Ä3Œ" ÜXq]¿Ç/\ûL;DÇÝ =Ù¹à…wÑiƵãk$&Á xur3 «\QŽùÍ×æ4ECµ<çÿùé Æ´Îrÿä!e]óæK¯bÒŒV:Ò4áÅ—_äü✥LFSœ´ÖR7MQ Í£¦â^±ä'ï?!káÑ£s@p0˜0º~£k·MŽMðH”N‘R¡õÕ ‡#D’­7éÝhd7ó¦m[Š²Äuµ¹ÕbIӴܺýÞÖ$&’U4M½Ã0Õ#fÛ6êØúNÿx7MÆúZñÇwµ?Ö)ëõ&²½Àè32MÙ~£ÚžoÊ$Xl6‰õz eQb}€@Œ¨ô@Ķ©£¨Æ–s¹m„¯Ê‚õ®ÞˆÅ>Ö6¹s‘o: ˜Ï欖+êÕ­5ÅrΣ÷™_ì>»~\·£ï=u¹¢*KT_zç¦ÓÃA†P‚¶mhšzýÌyÞ#<Ôå’jU=½^‚Ç·EüùâOæ £<ÁžÏyôñ»ÿÔoü3œ–sVmdZ+Ë‚Çó.K"XRI´4H!9ÈRRÛ0jÙ`‚2’ª)×óÝ:Ë×^<åOîÿÏ|÷? ž£,p˜Yò\’e°,N˜Ž” à£á°£ÙŒŒµ r IDATWȆcŽo’ 'Œ'äù ö{»,œí2l‘º×uK²wæúÌUžg;¸“ÍÜëe_ãkËÕŠåªØy_¯  „4I–£LN>Ðø ÖN²k…ìÖºPlóóo÷znýìg–„kúÎýLó¾q¶­[¯¿«·Égà¯B¸­½ŸâÚ÷ökÌWáŸÅ(aZtïÚ_ô>£ž–ðŠîÛh½@½ ¬ûæõçß K>aši‚%4žQ–P•5E]1H3î?~ÈäÚK ¯ßæüzÆo¼ø×HRE60œ:C–çÌ.Î(Š"Ö…Æt"¶¹ºŒðÔØ8KØ2je{dÛºF(ƒõž4mp:Ï™ G˜$#KR´ô,W%mçZ„Š”žÐZ¢õ°›Û«ÌAW¿’‰¦,–»ïéÇp=—;dxØšçõ]Ý,¢„=ƒtC»éz®g©¨š–‘¨TS7ÑÁ 4mT(k;ÍÚuú[¤ép J!}…W)Á[R…#Ì`7&}קj½‹‘˜„¦ ˜4#8yŒñxDS.q.êÐF SØq8¶#Wè39›Í’ÐqÉKS~]Ý_IÅS:å)Ûäã)JL> \Fæ§4IÑi7ªþ¹ZYÝDÓè ‚íþ.¥Y® †Ã!mS#’Žƒ >5MC m|ÇÚ§MJ],¨ª!Z)ð¡‹ ’n×Ý.qø:»sv=¦uÝ`Òœ$Q]½^`tŠ "Ë¥Ô6ŒsÐɺ–àÁzOPŽ[ÁÓ:ÀÇÖ¯Ç>å«£%¿|pYˆ´À´1ÚûàÓilKh,ÞŒøðó÷X5GGG|øù§¼óÑ»ܺÆ|>Ç{Ï'ŸÝ#ø€0×Xj×°ZÎ99‹HFœGÚŠºnXÎ.¹<;¥(Š.ÃKëùð¬LÅ3ƨÿ};µg:F«uzW'¸ ˜/æÜÿô–ó¶©ñ¶!¸fM¹_+ÝM/]í(ö­í¤&ƒkñÎîÌ…í¹~Õ¼“]K×ö÷ÙL׫’ 6)t­`8H!XR#É2Ãx2Äùö©ëôs°n«"Ž‡m+v«j7‹­31¡Ò4¶ÍˆØî$ƒ£\αMMÙXjeÓF¬ÅÞ±]÷êÇ}¿×¹Û›Y¶lÊ8K’fb <Í  (³¢ ]+£ëÐÀu]DzKÛy»Þðútdö !°X,˜Íf4MÃÅÅÖ5X×£Äè:¸Ök™üÎfÜ·¾e.„Àd<é"zMšnR²}‰¥i :Xêå%óË®µëkJ)ȲlêN¶˜ ûg§¤#HÖ“yÏ?]ð^1§Y²ñˆWß|™Úx>yò1ƒ4‹¤©E×!ãóȲ '=§ŒF\¿{ o†%ðï18ÒËû|xú~Ä“åE—&ŽT›JT0ë¸{ìøã?ÿ¯iŒáÎTóÚq†w–Q*¥ŠQž Dˆc´Î*MKµZÒVÅf­u²¯ð4X×9ñ[ÏÅ9GQxð>¬SÙk~ƒ p60Ÿ-׎>8Š­š²âüü|gŸé3<=ñIÛ¶O¥±·çþv z;Rï×ÓU)ê~MöçYÏñH3ü[¯=+¨×ØdÕKo{‡[{»kÿgû$ÏúÛÿ×c?U¾ÅoÝtžÉú%Ù{ùñsÎZš¶‰M÷žþ.«Š‘‚'Ös4HñÎ2O9ŸsrzŠ6Š{m‰DñÊ[¼éùêÝo0¯÷Oæ¬V52MI²1ãÉJIV•_g¤”ئ&ÙÊ\9Žt¤/Þ"4u5qÛg­÷‘7lÄ„wÔÅŒªª(W«Ž€ zÂZ„qCtRׄH(ijK)!Dñ„¶ªX-±Ô!@‰Èó,”éX¸úʼnb[GXïB¤r­bt}Ð !D¡i2lS‘e‚oéE<ÖÚã>ÎÕ‰*ô `Û†>JÓEÆ5©%Jk„J"5¤R„­¡¾ûN2ª=yO].Ñi >P· ÎŒÉÐJ#‚èZ|b”¸ýìöï#Ò~Æþ„âìF >x$Õåóù%‡×n¢Lì_ö>êV ÛRúVº$I˜Ÿ°8{Lm» žÐµÖDò•€XÐE-H‰·¥65ãMÉÄ“¤ƒ˜~m*<mPe¢£áƒ‘³­ Z¤Ø”/”„ó³ÓXŽ1 £1¸`v¹Xo춭YÌçEÙÍ]"Ž©6 Ã4fò TÏǼ›­ G>ˆÑ¸‚ï¼ö>½|¿|B:Ê9Hs²Äðò­<á=/šœ¢m)½ÃC¹ªxåî«,Îóæôëy'jÍ­<åFäZ2Ì<ŸfL´ávšpM+š¶â“‹r“òèâ1óÕŒËÕ’ë7Žù›ÿ¾õöÛ ·F JDÏÖEe?)ãXYÛ ¤fU–Tm‹õo}”w”© Um×ÜÚë¨ÓÏ>òò{ïhê a R÷FISG€[ÝD¶Ã$KqÞá| μ³èÔt¼ìžùbA]ÇòÔgyžã¥DéŒ45‘'[vœ Ûxƒ=pto·ƒÔm[ô¬àuýZ‘ÓÀ>M}-„è².žAš‘˜hK¤€üáßÛô9÷^ãE«ÿ¨Ý(èËÞ³‰¢ú£íl“%ìôzîÔ5Úì úþ²Ýš[ Ï£¼^—/M€‹Â3«öÚª¬'7 F€“žÛƒ!Ïç9Ýÿ©ÚeMo[\–ðÉ|A­¡i,5÷/3²aÆ“vÓŸ˜˜¦‰ó í›g¼÷ÿÿÍÿô»ÌæQ\A¦Š›ù€²)8MpuCžçT#ÃÏ/øêtʵéódeKQ^ÐZÇ'Ÿ_Ò8Ïõçï’å#l[uõ#÷”~ëÏæŒ ª:¦·š¦a>Ÿ¯=Wi‚ˆ¢âýøôÀž¦q”EEÝX´JÖ`Ÿ¾6µ]¿IÓô) ÉþÑ{èóùŒår¶IÛjH4¨0FÿýàiPHÿ½ëÖRT›´~Íö›Îh4Š­;z8×Ͻí#: ±×gÑ_+¶&‘‚RgOeª¶Á1ëÃ7Ww*]ëjŒNQ:Å+µÖ••R²XVÔ_ôö½þíµ¸Ý˾¢•Àh<ņ]4x¹j­»”µåÞû?æìñƒ¨‹¾QöèÝþN¶£ù^º(Š€P(Š[“"Zm2F3ñ>ìàM¶7ËÚyƇG´!‚öêºæÉÉæ³Ès-¥¦j,Më]Ú^gyT$ I6@ŠÍ&l$$Jà»Úg?þÎ9P’³‹šË*ëY ˜ê1ÇÙo¼ôÞiò\é9Mbd_Ö¬(e4r1òŒÚNY,5ÎzÞ|éunò­Wßæîí—øù;¯!½àÕ;¯2 𵎣lŠ›ÏùÚñvö„ ²v$‰¢=yÈWn=á~ðß²”€VŒǵ‰f”:œ«ÐÙÌÀ8Óà£öøp|È`t€÷>Ò¯ö8…nýôÙ·í4p7€Ý’J?×´Öh“’åC†£ QØR’$”Jb ;l¨€Ó|ÈáñuÆÓ#F“c”ÎÖà¸D †™¡ê4çûŸm<Ëþ>ðeëâËŽþ»n¯ÝÝýSDiXÕný½ñ½ð•oýÎË_ÿ•õ…÷OôëØ7´ñ&w=’&pâ}ö›`QžEna%ú”Œ <ËÄ÷¤I¨<h©žú®UU’ç±/YKÏ 7¨Ð×&=©‘]´&:‡À0k·rËOXT3>}rÊÝk7Ñå‘uÜ8¸¶62ý¡¤"5QfÎ:ËeUF !xqÒQ$JÉãÅ‚ë&eU­H”FK‰ Q0mxízÀÕ Ó|B’HÎV57ò!i–£PÔ¶Eᱩ᳇\¿†T–‡Oð•Ÿûu²dLHsDpÌ..h- †cÚÖ¢$´]½RIEð.F%[‡ë"«µqB€º±TM·QO¸µQܾ¯ølèÓŽßp ¼ ¤ÒÒ`­HÈÙéyPDJr’Ñ”4…#J‰“8çDA}-Ï3¤Œâ›”‡ããS’A”ie¬…@Ú¢v¤‘&q5ôḖrv0£Äñðà)¦2çOåû¼vç6÷?&š#W[E> Õ 'Ës®¨˜7n½Š0–L¦Ä:&BQCÇh-Ùosøä!ÎEˆTp÷Ú‹ÌŽÙ§Ü/*t/ŒrOOÙÙÙåàôÛüáwÞ#Í^àÚNÌ8’$Z¥Žªr¡®»(JQ7­‘)%i6 ¹l!À[|+½èœ\_[îl¤wE¼Ð:`”­º™@È¥#”Q#c-qƒ%xMU¢;QµÑžÐªªÁûpÏóe¾å·Mà®Ç÷ y¢œ6ºµŽl»†¥ïÏ•õµ²Þ‚¡ Þ€ªça}y®Á #Ä‚÷ÿìP/½ñs¿uç+ßxÆuÿÿ³]d…`V4\O3rpzÊ·ïp|~¸1Üžíñ½Xðý‡Oùù·þ:'§sŠ†–ÀPW ‹b‰w–º18JG!ß^•DqÒ÷Ÿ÷žé4'ÒŠ²¬Vw׿"„^­÷ b¢(Æ´¡ì>ª"„Ò!œ,:N[¹>RA+WERé• Å@Çõ™pQ%q8c0Þ"#ŠRTÓåSÃeVÖEù î»R %=q¬qnUoݽwh<6U8Ô—KLkØxkzObˆ<7îم݉ÝÕÞKJÉ(‰H£ˆXk¼5Xç µ¼5ZF¨V(€·Ö7Ž„^}®Îȩʺ_Ý{7Q¬J)¼mð-‹YÓT¥PQŒT®Ö4uð åªtmœgغ¦ª–‰+’bI”ÑQŒ–B(ŒFgÝ8|k ©N8£ ÖU½b ¢õÈét„$OCkÊÅ‚qž“Å l¶íXgYFkb­X.‹žª*æà,:I™nïö¬”š8Ä‘b"íVJá1¤‘êsÏ«g“ýü®™®yÊ ÞxãgøÓ%?|ð]¦MÁiuNš%\ݿβ\0NGT‹‚ç8­@9.ï\åñáâ4æjœpzzN>ÓT ¦iðÎÓ45Ó­)[£œó£',çÄoÜ|…r¾dkoŸã÷@KÞL¦$JsO.99:¤)Ù¨`[ðÛòÄ2æå[×Ùö0Îc¼m˜nåœÏÉâ(”]*½¶ã8Æai×®HâàõzïHÒ”¦ é¥ƺ~ïVC¸=È×4 : ŠgMU"{¢©¶OÛh°µ–º iðaߊº1dI†@¶FÄÐp”í æq¬À:O¤b¬­Ÿã³±A)Ž²(W„€$ ÕAÃ=óûöû¨[oÿâoÝýÚ¿uáax‘›ÿ¼öç@ßôB‰GèÄ‹ò`kÏØN|-$‹ó¶•A\AJ"À6˜, ù˜qõ×t"ä2 i¬CŽvœ“Æ]¹h i´ªìŸË9²ˆ¨Êßü³„à„JXÞ޻—ŸžóâΔû§ÌšN(FYÖOŠ`± ²$c?ÍÙo1ÇlËÚÖøH“8PiŒ‹4çuÃq]qy’òâîu^¼|ºjXÚjËÉbF2š²«ei •žž´ñkÒñ?,~ÌÉÑ-~þÕŸg2‰¨,4Ö3_”Ì–%QÓ‹ápì !kšÞsöR2%x'hZTò³ã¥‘¦©J¬w(r£B3,怎öÞ·âìÁ“ë^—Q@Z/Ñ#.x“>P„Ö¥A;Ç[/^Gn½ÅG'ßáîþ”½é5Êj΋ׯ’é˜ǧìïF\—‹’íé'ç'”MÉU•pýò Êe‰NÓéY6fšgÔ‹9Õ2äÍ'yD]”ckg—'ÇO±šv¯Q”Ô\!f{œsýò.Ó¦f+³ì¤ ¤>áñüÆ[oYIši|Ó`œÀzM¨œ+ÊÛv5Uó uÀÎøàÙ½•UÙ§†Ò$¦ZS*ÎÝï\HM ¤t¥N¨ª´D ôÓ½ÇYƒ H¨¤?W@PÕ†ÚXjã‡H¶u&^Ò¦OMˆÄꈢZ‘7Wu¼ú NñÏ;¬qAúµ6¡\¶ÜÞ#¸–wþä_üô$$as¸˜Àáyïûiâò›„?uλ³äYmª‹Åb-‡<Ì IÖ6ak‰µDëu9±aÂÇÏ h­t¿ûíŸ0O)–sîN&4ÅYYÎ#Á÷át ,Ê|Ê|y“ß:Šù_¿ñzö˜$Ö4¨kö÷÷‘m½ž!ÄèJÃGOïQÖ5û;»¼zõe")ùÚå›h*þâð)?8?¤‘’¯¼þ&ûù”3 E˜`×ÅÏðü;¿‰Ö#™–h³5“Dš$Í*ð'%‡ì8Ã|_QýïW! ‹· MYÐT5ÞØžTdh]wVnè"T…Ð祼 Ôèî9üÞ]§Gù²Žz0!»Ã¶óÐ6 96 Ùnn­Bê«ZڋСB0)Ÿ]Ë=ÉÅÆuºÃ>Ë2´ZDò°uÏ;ìÃá3†NÔFƒlÿ5ì‹p!Eœfý— Ú‚,Ž¡â”t4î7Y‰çàɇ÷Ù¾ò2Î:IòiX“r”ŠÆ®H††O§j%œ§ñž$ˉÓq”G)JÆÁ‹á-‹ó3æçg(á¹~y ¶æÞƒO™lo±³µ‡·R­ˆ$$±@ CUHBÍ:@žçAØÂ{¼©1u‰wÄZ0;=Æ6U`ÑsÕ²á)òÀNò‘àÒ¶FXKcW¡øšVBˆ …xp¶ä¼’¼ym‹³›,œá/>x—ííNŽ8=9%ŽcêÊðx6C ãšG8é$eûÒBùÃÅüŒ£Ãû”ÅIŸ³?>[²,Š¢àá£G|zð€¯Þù2wö^B(ÍÕéoß~Ÿ"ÎÏY, >:çƒÏî“F’âè˜üÍH–È ®—¦ÊU˜úYO²‹ ‰cºr§ŽØhÒ"ä»ñþ" ”âÞ„@´äÀe³îw*NQQò ÷7·¥%´‹EH)JŒEcóeEQ[PAMN¶jƒÝê11?¥#Ûúã,fš'LódpîHðL«üâÃy¸07RmD›vÑ{‡­ÛŒ¾èC=ó\ÐÇûÙ'dIJ,[àÂγ”QÁ£I à! ‹å IÍúá6uG¦/¶†Æ‰À øÝ¿xQýJåpÒS/æ”XŒòÜÝÙåË7®‘R³§»NPYÁ¢š·Ÿõ¹µ…o\[à…cY—ˆHa‘Ü{øˆºnZ‚~E% *ÖHÛæ<â'÷>cÿÊe*QñòxÄíë—Éö.3Q’o~ëÑã„­$fÜØwÙi¸ui‡Æb$OŸ‡’›óæçÇ8G¨•½`\z€‹s,Aus »÷ÔU5Ž¦±X¨»¼ÍêÀ#xØ*B©¨Í5´r‡ÆÞœOÏôêW„vUÑxZÄ÷úø =Þçʼ÷keTÃRŒþY¤À ZLïÈG‚•ÁÉUˆ«ŸK^h…³5‡ð„*ÃçuM'ãÖ=‹n“ObE$C•Ù`²ÛŒ> ”@¯êYÌ æEMië–ÅÐÈPí8it@PÎÖx¥CÙ””A¹Ë†(J’$è­K,ÏO®"ÍFÄÙckŠå‚º2¡œF§túá+ã tK{kŒa¹XŪ(%N²¾DË É|v£G÷pÆ°\Ì9?:àñ½Oùþ»΃Ïî‘f»Hqy?Âx‹¡œ)K4±ä£ïB=ü(¡ž³\.ðÆâ½E 8?>¢©<~§ŸÞãt¶àãÏ>%I’PRÖ”EÙŸÊGœ–4&PÖzj¨Mci¼ vŽYQÇ ^'<<+ñ.âïý{ÿ1?XLñÛ#æ‹Söwö8<>€Æ"œÀEá#–ÕˆÆ0˜¨„ȶF[LGSòјÇOŽÁ«^©+I4q¤¸qy‚ô–»Wo)ÉÍ×ÙN¦\ÚÞçä윗®]ãü´à'Þp <_yó-Ž–'ŒG)/MøÃüþç?ø=t¤™F–8RußF‰èæV]’¦AÂ4U_iŒÁ¸á¡j&Dy²8‘$aÆw( >¬5¡döléC$ÃyÙ„Zǽ<å³{E»¶¼DȈEQἤlÀR1R$4µÀG¤Aª@?+¤Ci¨ªwÆÒÝ:ê"Æ]zÆCYÖÔµéß«^þò/üÖ¯üê…›Òç…•/ò0?ÏÒùüCzþbPZ·á'q܇NV¹3· ¡H«–0u¯,måϼc2NˆTSvVWe_&Ôuä$•ˆÁF9ôlFQ€ÃÿÎ÷þ7’ÓÛiJ9[rçò®í]fgìM·¹²µM½(¸}é*׶&,(¤d>_°=Ýêó´ÞI–ñˆ+ã@HQ5u‹\ à"E\Šb®¤1‘lec²(át¶àéâïáúÖ.£8Ã%ÛñˆÌæœ;ËÓ‡§,m…m’|ŠJ’ø.™Ž8==ãÑI…S’³eÃhû2Iœ„ðó€MGJ¢!‚{=/;Ì݆±ž5ÞãE(ê×QÜç].JYôž5’ÍÃä¢y8¼gwMïƒÈ†Š"’$íé"»±í¾_4Ÿ7Ǻ«x^鄳¦­%"ÖÔ$Ùˆ$IHâ€u eëÏæb(ß²>lF~cÝ,‹Y’ pA"Ó…<ÝÚØ8‡n) †ØØøÛ6 ã“wη¹Õ‚U*HîI!ºì¾ZE:BE:Jhª k xÛ–ÄU,ŽO‘iÊtg¥#Êet–cœ¤nåH»9äÛ>É’xe@)ÙR‡ê~>ô^ºT-IàÔå’Ó³3šÆ£â$|&o9?>äÖµ=fÇO1γ˜Íyòè1uU3›/¾£ª(fgè,G)³ Åbæ@âÓWÄIJšæ)X,ĽÐË ÜSVMk€Z:Ô™#Y. cIÒ,ðXGJ†ƒmœJ^¼üUÞÿÉ#\ÍK—®prtÀÖt‡GOGœXÛGÞ¼°\ØI·8xt,=äüü¸ƒýžj IDATqË€!•À‡Žå|‰÷ª•ø„EY’¥ RHΖsª¦âÒÞ‡õ’\ Nç3æMƒÁ‘HÍÝ’ÇòÞýo\z…F&4-'vÜÞÓ9ÃÓ§GXÇš÷*¥DEѱ˜Ý\ëŒÑÀæ«AÙ«[(AU,åãµõR75uÓà¼èé}7£c+À"ÉÌ¡`\‰6Z渎) ÞS7Mð¢‰B£d EÚ\O›ß/úyØ´V$mÔæ{ßú&ê替ð[¯|uu8C‚›‹ø‹èÍœ]˜¤C:@×OØõ?õk~~¾#„ KÓaÝ&¬¬Ž«7mkš»r )%i¢±Ö‘%!/×,Ýg1M݃ÂDqdz•ïZ1Ç[7 pâ yœñé§áœç¥ë/²›LPVrwç:¾®™Í-‡§3ÎqxéÐR£eØp”løûßüÚ-T1qšR” ð„°£'ÜÜã\ÛÙG Åg³5ÊxíÅ—ñJó½÷? öŽOžr}:fÇxfyBãáÅËWx|vJžfTî%ö'9ççs&û×qÌV1_Ì)+Û¢¡×sº¶©QqÒ%Ì×æL·ø†¨_g EQ ¥¢±¡>3îëÀ¤õ0ý<.¤áXÍžîÿë¦÷¾]üñ3‘î:?íá,„X+Á>gy ‡eGÍjM@mRâ\Cð>WÏÕ}ïr¦Î9¼!O,D› ïÐâá^JI”˜¦ ©…A8<Ô9‹¾ä.Mª^zò9 Ï>ÊŒP%ŽÃØ®¤E`›)WÞ>Ðòú<¡ê « ÷΢•âôä€<‰q.“®¼ðEY!¤¦. œŠÑi¸¯ã D Ê”´„âu8{˜ÐpÏP/$5Œ'“¢Tš4õå^ÅlÆütÆÑádzå¼`~>ëù»ë² 1 ÎyšºDƶ14ME]UTeImC¿(æ¯óPU$qJcjLË­Ðׂ;Û—ˆÍ–W;¯ã8Ôo#ñÖ¢¥ga<[‘g$ç|üø}N–gìˈé(ãød΢)Ø™ä<®­:–CHÏÕlÄ —¯óø“éoÃELð=‘Ji¼®– ®]¿I>³,KïHãˆbYrp~ŠÊSüù9çÖq['䣜Ây^ÜÙG,qzŠôšë—ÿ ©©¨Ôˆ²XPUEýº*Bî?ÍB½~;§­µ}±!´,„èk£(îý€æ`?}eñ’$Y¥…¤jëãmmOØ3ø>, \¥ªº×:”¶ N$q^SR‘ÆA%‰äœ…¼ó­ºùåŸÿ­;_ùÆ3ëvÓ3x^[ó.|°Èkõ»NÒ¯{_GË&í ¿Ù|ÛAR:fcM(mñAäÊHt¤Á;¶&#ʺlÁ.áYóD¯u\÷sSW«ÃYzòXô,6}¾4j?Y*øàÃÂËiž—wÎ2Šõúüêþ»À@êæZG,3L]1šLAwž™EH%”µ¥1–²cGË¿¤6UO· tŒŽÓYÝT¤i¢8”å%qKn¥Á«n¥ !ÙEY!uŠÖQ > †ŽoÓC p(åAEìÆŽoZóµš[[S&ã1Mm87%uÓðÂhÄÓÚ„²³\Ést¥[<}D6ÊZ t…P’wõ_埾wÊ7^”åŒIžÒ[±˜²8?c’e$q†© ù$ãàéSJk(cÅA]ðtV0qŽf1çØIbQ‰š¯ÞùU¦ãŒyQsr^&Møµ•”%N3¤Š@e)%ç³9ÆXòñ˜²ZÏW‡:ÂY×zQ´ó`/‚¦©ˆ¢„ºnz¶:àÛþE´ ÎÀÇ?ek÷ðÞ#ì’²©Iâ æ˜÷&éu;×פµmYEI>ÏyÝü\›çex] E0ÞýÖ7‘Ý…¿(7üymÓóÞtó}ýíçyã›MJÙ€”AGu2ÉIÒ¸×|Ýôæ¼wìLÆýbùi›o@«Ïï‡M—üŸö?ðr4⵫·!U|}²Ë4ÖLF9ùtÄÎþé8Ç• ózÆNq5N1^Pµ\´ 'üÎ;ãÕõ•doºÏåKW¹zåeCÇèt„t†·nß!öŽ­$ ìmmsewŸ×oÝåF~‰YSóKo¿Ôì\Ú'Éb>ª%£þ hÏvž°\mÁ8ìÒ4íŸq<£DÈ%mlz™Ãy‘¤9^®rAÿy^{ÞœérÜ]ë@Ýu×ÇÖ¯º×»{tÑ~üý ©}‘µ;1:ZJWá„‹`‘o³†Ï6n mþm=rä‰cEšÆ°(,Î5¥Y”ÕJ »›+ÐWç $±Búu\‡÷~À#Ï&y¶6ÆþSJŽ¨CQ†RÅ¡aÕ‘Elî:S[A%3²ñvˆ 蕤x•à̳ô¥Ý}­yŽî}8ÌÏ/[ É8!T—. ¬u•ÅEã–£2©#šÚ8TœQµÞeQ÷¦îsvž—Ž*ãPqŠŽ3„NZÍ^Ù ݘ(­lCÿqüŒ©)©#ªÚóØø¯ýÂ_åÝGŸ², ’†ÝÑ6J*ª6RëÀ¨µ( FÓˆéΈ[·n!„X÷¯Öÿ”ÿü­ o ³ƒC}ò#šºâôôŒ²\0Ê'‡TEMãZHÞ¸}—Ÿ{õM^Brg+Gš’co9°ðÂå8­x4ÓŒãÉá1G§ç«õ/5£| 2uÍ®/…d£1BÅŸœ_š Ðn^®ŸOëCPê満N/Á®yÐõ "½Î ÙŸƒNÃðžÃ=åyQgXÜ: Øn^ úÖ Î`X[eÄïýˆ—÷¯píÚ5Þ¾uïàÞ“§<9;¥±5&†_xóg(æ%mƒô‚Q– ú"çË7=Ú[„tø ºAD‚ò’$Ò8%‘>8;/xztH’Œ°¶æðô”ù¢âàø˜÷ü!ï~ö [[c¾÷oÞãË7^d1ʽcœå’ú:èÕAZT†ÃÓ‚§‡‡àa4Ιne R„¼ŠT0Ÿ`›cV ¤Í1ìÈCÆyàíÎÚ:n-׬[Ky Çãó¾C Dñnź$!5Z ʲÖÙµçrk¤\yäÃüó&ÃÜfëÀXÖ68·‰IÙF:âˆ8N[–v®w÷v}(Û:tn­e¶X´ªÍãZFqD,%ÂUïéµemSãTgQ„žŽˆîTv{¿¾¦{`¬È(0¤5µ ¼KÂ’¥×ÔACÛ Ê¸¬ ô¡ZO†õuB‰-a €R$Y¢ÓT–=yŒ÷mÞù̦gÛ°ê(ú1yf ºÍŒÛïV"xZq64§­w¦£˜º zÔ.àí"AÊ„$™„×|(«\–eÐªÖ (ŠŠº6ÔÖPÔó傲®5ö‚¢h½=ï)ª! *KšÆr6_!U¶X„Ÿ£–J¸ƒÐUª¯?÷¼”¡Y:ÊÞ2âÃÓÙdL–u%a†DE¼¹³&xþÚ’ÅÙE³@X‹EG‚„†e´÷†ßþ®åpçïr‡i$±e÷ÒMž<8¡± eÑô‡ÈgQ”;ã]f§ î\ºJìj¼ðœÎO9›±¨®²P’Ú9ŠÆ¢#Ár¹ K“ÀOž&H©C©SûÙ½P 5‰8[3Ùš2Î3&ãÎ×ýû:ç*Mm˜—¾ßó7pï×9¹‡ës•fX7Àâ|ÒóZwFMÇ•zZHÚÀ_›—ÁÃÅxÇl¹Äz±"Çie×~‰öýÝZî4¢»ó¬óú…ϪR]´Q^´8žæ¢X‡íó<ãÍÀæ½Öî#Â&e½ ‚±"ŠGk“Îyâ¶VÖšfm£BeŠqQÌgä“­þßq"[´àó›Brkg‡o5[pY‘V’O?»Ç¢n¸ûòm¤qD<>?`y¶ Iž<~ˆÅsÜxî^½ÂŽíõ¬ÔìŒ N*¼ø–4þã{?&ÎR:)C!¡ž&)N ”ƒX¦<<ü1þä1JI¦“Œ£YâhøØÄ~Bk˜/°{7øõ·nSz‡wpvvÆ{=fYTœ5W®¿xŠ'Ôdz¬sdQÉ-Š&”Í|Ê9Nµ³;áèèˆÚÔÄ*¦l½^Ñ 6ü4–µ>—2Ô¼öº®1>ZX[1Ì“o^ûyaêçͽîçPçÛ ?Ðß»8‰ƒ7%,ãQ²vÍᢶÖàlƒð–yYã¼$ê®#eo8tßÊ-Êu>Ÿ#dÜ{rUÓ§éYõ Ò«Ðþ&¨­i]1Ë(Y.C¨Ð±Ú¢g-R¯“øodµîµÖ­ ÅÂ϶a £Ú‡r(%W ¼ÍÖ=ëûÓöÞšŽâöànߧã–M⌠šØÂ!Zf³Î©è@¨Ý\ò^ç9ÖâÇç-p­ªF£¬×7·Ö¢’ˆÙ²a”¨öùó¢bv~†ó0Ê“þž7¾¹ïyï©ë-àdQ“ùŠ¿ûko¾û]±3oM¹6¾Â~L¢c Wö?EY“D9Gg˜ÝÈdo—÷*Þ)÷øW SmøO^÷|öÞŸòËoý2ÿãûc~ó툇÷̵ۯs~z@Q×”¢a:Ùe_H>¸ÿ ¹ Üè¹¼¹³ÏŸ=9ÆIŠ/æ׉e¨ÏÍó<ÌçXÅIÕˆ"‰ëoˆT ¦Ó-ÛÔm$gÄlV´ {멦¡!Ýõ›jyñÃë­XQë^T~8,‰¼h¯ï}àžŸÍä£tíYºyßEj‹¦A ™Ï ’X¡tWÖu±‘¹¹‡Ÿºb°/h›ññÍ2’‹Ú¦Wü¼ðõóþ~e¹¬×? !@v†ÂØõÚe!J´bãµ}Û_C K4ØÅ.ŠˆæÝGs°ü‚„žÕ!ö7¾ò_ò|ç>ûûûTÎ’N¾ÿá{üð“ˆTF5¯¹W,øaUá·¶©E„Äíf¿B1:"ÊXˆWÈÆ[/ßÁ7ž¦¨CÆ7ÄMEéWö.S[ÇñÑ ¯½|—·_{/ݾë7_!* Ÿ!Ó1·^{“/½ô/Ýzƒ{§‚¢”Ë‚ÇÇ3~ühÆù¢æ…»oqýÅW‰¢l·Öƒ’²¨©*Ë(ŸmpZ‡>ìÆÆ“èÐXë‘(b­p¶A ÙG3.òœ/:8×ÂY¢8ë'·i•«LS‡¼çÄ5œOaœƒÇÖÞCöê=¶÷°­m0­wfM¨Óî,v!‰ÒqK–3eäÙˆŽÄzhч£oƒg:[Vx!QZ‚ìŒKG¬‹Vœ·,®ipMÓnfµUPí:ÍÞ{¢4 I¦ƒPËe‹q‡NŠþsê(¦d€„ÄZË– ˇ£à„DÔ6ôr/j[yHKÚù•'2ô7bÕ·¸ëêgŒ¤<ÏH’ˆ8ŽZÕ#³ Ö”®tFG Z)”´¯*ŠQ-{ŠWJ!£8‰*F¨˜l¼E6™R6u`²ëBÙZ£“˜(MP* ‡›¹mñHÙí”äèéSÄàpÎõõ¹Ãò½n3Æ°,j Ó`Ækj#}ƒÞãÅÛ/q}wQ+4Iwg Õznó¢b²;aœeœ ªóS¶Åœ_‘ï“ûDD>J¹ý•_A‹š¿ó%Çoÿ« ‘¤œ=øF+òiÌ££'œÍæ4Î+XÚŠÈKÎÎyR\É5E¹`y^ Ò1Þ+œ“8Wƒ·Dqƒè”VìºS'„:ñRB»ÖlS:ßô‘n yº‡û}šO¨ê/ÛR,¿l©ªºŸ7–ÐGEQc¾u†ç̳©¶6Ò+³E‰qçC.½óz3ÔÖbMkx{KYË@†ÔÝJëUÎZ)¢¸­î¾º{Ë@‘Û»Ïó„ŸÞیˑ·ó¼×Ÿç¹|ÞÁ,mˆX`Ø™Î9’4YCà…uX ištãEèÝ÷ë`'W%æ‚gð¤ódÊ£^̨›‚ËÓË(¡Ð‘æáÇìîˆÃOæ#^ÐÕÊz2‚ë—o $<>~ŒpiwŸâtÎ?ú““3t¤Èg)oÞ~•ÃÃ3>~tË—.!|…Wû4m8Ïsì"C:ÃáÜòøà Ǽpû§'‡T¥Å:Kš¦kù³ f¿’à¼hÜüŒF)ÎZÒ,âü´ ŽeŠt:öÞ‡§–œ¿æíºúj±qÏnCët¦ã8¦¬—-áŽÅ¹Õ¨o=Ëå’(Êq¤ôŒÒ8”‰Lóݸ<Ö¦•â ²Ÿ7­ã÷ü>ÙÙÙ…(¦, šÅÔ¶®yðÉÇÌñ(c²µ…1£QÊõFÁïÞËøÛ_Þezùe~øч˜¦á³ÇqUÉ‘\ò'óSŽH¡˜/Q*æå—^æß|ôÇ|ý•Û,jJÆù8ùd(A ¡Ý`8 #BÈIÀzªbcì3åI’yÅ@èÛð°îà‚aœ³{OUUaÊ–rÕ÷³RŠ<ÏûŸ7×r7NÆ„0yY–äYŠ¡A‰n¾k–‹yH- æ]˜ )W‡þÐzÿ›Mˆ–þó¼Ûç…©7wQzóûó¼¤MOz®ì îkj¶@¶~‹ßZ¦Ó@ã'Á:®éˆÑx›¦ ãEQDš&å¯Ô3cÙõ•õ6¨xYC’ÄD„³XcÚ°• ar·n ǽ»Ö&xos®t}¡4:Îñý¢÷¢¹6|ö.,:Î3Ò$"Q aƒ‡lëamÈu Já£à) ©û°æóæújðάXÐ4&X÷BGÈVi¬_¬rãÁso°¶õ¶u…­b„Ž]gëe BÎ6ääC1”ˆ:É3FqD$èówu]s>+ðu‰±–‡w y¬Þ£•"R'â}›o·–ºªB‘¤#â$ëçD·ù,ËuÐ^7Æݸ6Mƒ‚qž#º\Òx‰1–ÙÉ ÅbŽs+ðŸóï :Mx"ᨫ çw{§>³¾YD‡1éInt¯˜ÔBH¤ ºâž˜c… B²ÎöÆ‘Ç…ühmhê2 ÕUR㔦qDiÎ¥+7ˆ¢Œ$¡„èïÙ=çÅQ£v~Z˜—…ä'çWp Ò’ÆIæó§Ü¼váišƒ÷Œ¤æ£‡Ÿ’¤ ׯßÀIÅr±¤hj¶÷_¦˜Þdrý5®\¿Å¥W™Nb¦ã‡Ñí/Ñ ?EF9>˜?Xܽ¼Ç¨nPj„)Kn¿x›»·^çÎÍÛDJóË/À¿÷.˜ŠÉxë5Q‡9ÜØÀÓàšÍôë,{]š(p# ªv^uãÕõ‹µAh㢨Xç|u¸d ñRôÜX‹·†€wY)º- ª¦îóÊ›g‚!Óa¦f‹%u³2Tgóe\êÇ3`žœ3,Š‚ÆŠ dãŸè çÁfDà/Eß¹Ù67Ë絋îÍøþE7¼G׆€—îõº®ƒÞg+Ø>|¾(Š¨êz°ù †Œ\›V6@šF½ŽïEMzË$ då²-WIÊ¿þàçÕW_ÅÃÏïdäM…&]…+¬ãòîãé¸O( =œ¡ò×_ùg”$^aåJƒÚË¥ý+\Ú¿ÂÞtKÛ—E96ññÉœŸð§Ÿ½1 /]¿‰*Ê@¾³…”’ÓóÇ<åŬà¿þ‡ÿ=/Móe…–½Ë(‘$I «w+¯°8 £Ñ(ž3îÖ…Ò9ïÞ6TeÁr¹¤,Ë@ugWa½‹æFw€mŽÍóÚÐÓþiÞQë¤ÝgíÂø½$£x©‘*î žçý Ÿ«cAR“v¡Ëîï/ôàݺ!À%–eU·¼Óq@·MÑG"¼ið¦YQ–ÖÚ°Ö¶tØ,gËe`gë›uDê0ÕÔQA¦YÚÏݺìÆoˆM>k’$k¿ë×> ¼¥*+Òñ„8I‘´òƒR’l]“*H¤§*—x[£äÅ©©ÍÖƒäQ‡îKwt›»ÍF9ãÉ”¨%ÉhŒÃµ%žUU!¼@ Ïrqx£M "¬åùg§§Ë&”ò‰‹Ÿëó–`äÕ+Ïñëß Jsjßp2+ØÙºŠ¯=oßy•—÷¯rkçeYñêË·‘BôÞþ /¿Ìäæëüžù9þ—G—¹¶?BkÃã}Äñ§˜KFÚŸü€ÿî» ËÅ‚ÆøÓŠÏ–§¨<æþÓS>ž•<© 7^|1(ÕõµÉ†SRþÁýK{»`”h%˜Œ"lµ$n%.“$!‹Ç~÷™;o2ÔcGÄíZÔZ“¦éæ@Jqášñ>ˆcXV%E]Q3èÇ°ž‹&|u©­áøcz¤÷óÊî½J)ªªb^T,ò±/@Y–ÌŠ˺ùçñ, ì/ۆʵ‹<ëaëó0Ù½¯ß<4!¨"kÉó<¨ ‰aÇ‚÷Ž¸U  ›¥Ç bÝ«ò> H­3!gvAs¤3LRî utïÜÿˆ'GÿìR|‰Q>â;OOˆ+‡Ü8gP¶G æìˆGe…Œ"NJöÇÛÄIB,Âèñ Rþêëß9qûoìÜ Þ\KÙ ‚ñgÛã)Iñðá#dœq}2æö•©ãàà€Â7xì»qN¼‡«·þÿíÛ9¦®Y”’ á+‹l½VÅYƒ÷ª­qVh¤ýèP¼ƒ‰Ü¡ —Ë%ÂYªÒc›k ‹eµŽ²Tu¡ØgsH…|.ŽÌ„zXïýZ™ËçµMÏ[¶azáçûp¹± ¤ •BÇ1O¦£ Ó"Ãy<æÀŽÔk{‡Šbªº^)÷ôÞ¨(‚,‚@†³aúùÞ5Fã½ÁØ^¼WvÆ`÷ú0j¸(+œi¨½à Ž Égø…WÞæÃ?dwïËeÅÎΧǧüìí7¨š*ˆK”gh%©¬çàèŒ_ÞûŒÿðÒ)ãŒG+Ãós~ÿ“+Œn¾Î¿›þ÷•sÕ—¹¾åHãŒ×§Ûüóœ3»"¸’°‰âÑ£ûŒÆSvÇ;bÎj ²âï|Í£e0šTG’4ò4‘%9_6ØÖ\Scã¬vÐGÆx„Šˆ"0Ö¯]ëwDa‚^ŽE8‚Æ}IêÀ¬R(6䢑 ,qxgˆ“ˆ¨5Ö¬ 2–óÅ2g-S×D¹ÃÀÅá|£wó¾ ÎC[û¼"’Ų‚v¼µ–Äq„uj7œ?,Ôr»ŸÎsþ¼áóÞsÑßo†Ë/²ª7ÛÐbBàŒíC«¿“Ha{0ÏP8¢xFBÑoÀCb×r"ïMÛbs¿þ R‚öŽ‘(GOàÈ>]üKìâˆÊÂgG"ek4†”»»;|eg›·'cîäÛl%’ŸÝÛæÎ$ák“_ÝÙæÞý¸ÿð3ÕŒÆ7áð³‘rÜ/ø›_ÿeþä‡s‹j:ÊFÒ¢ ÊÊríÚU²4caÃFwÿ'sëöËÍ¿¬ IDATHcÑ‘¢nJ¡øƒšÆ9x‚b“óh)999ÅšG´­Fn—w[JG!DÈ×á„÷àÞ]TçeYP–gg3æ³ÆZ¼”U…Ö1TZ•2mÎ9)%Ö4Èöðq®#»ùâ&„ÀùàÕÆѺʾÔ}Ã{w ñóæõÏàzƒEPŠ¢,ûy=”퉕$Ïó]ðð‚—T‡&ÉF¡LK­ž­{¾ù|N]7œÎfŸ1›ÏY–e0ŠžøÐøM“¸Ì„ç‰>„C.yðù¥ d/-IP¸z@aCà?ŒéçÏ°áƒ:lˆru ÷%WšrISÍ™\ºw†¦\2?=æÆÕKììî3Á[”Ò4ƒ’¾á÷~<\¨'L]ÃÈŒì?OÇHæ·c<Ê‘œm¬M«3xŽŽ™ÍfÔVà…B¨˜ºj8<>áò w˜Lw°ÞQ”Õ…ÎÆÐø‚^‡óÜ p6ó™bkK$0^SÌεÅW%Õ²¤ªMà¬÷ž­í]>þôµÛÛ1âüSÎç»»{Üxñ*Ó¯qvùWøÍ/óñ¿Wƒ­yû…=þ§wæx$t¿ä­;cnß>ºB¡ï0™¾Ä{O¯óý³=léÙÏ<ÛIÃqy´dk¤QR ,—JFÁá±M{[v÷¶‘ºCt5'¸2ŠbFYÚGi†{ƒR’ñ8§•;ïÉF¼k¡»ž Ó.UP+*h¨ög¥5Î1.0“µ<òÝóÅ’ªiÓ)Ϥׂqª• ‘‘v*µ®¦7\+6äY­ƒªvœÏ–A»ÀAŽtsC€ŸÏ­ýÿVû¼C{óß›žó0ìE©Ë;t-ŠÃ¢žN§jÓªª ùGÂÔÖ¬ŠÀãöt[Û…@˜Š,R,aãÙ”‚i"PøF†gÊ$ÿSuŸŽAí–o?s5·dqj;:=äë7_áéãCîÏNÙ¥loíóááCð ã˜Ÿ{ûo°›´%Îp<„2ÎQ2Â3jA'ýÚåC'ã­‚.vÖ²Xâà,ÅrÁb>£* óBi,št4neªÕ¸Ãyq‘ç< ×UÙç|Ãkë8‰aÛ MI©ÚšÓQ)<~€ÄnLXGѾÿ‹šµÁ‹í"«ëK¾w%h‡vGÄQwÀ­”º‚— il "ê¢Px¨UµÖ´èï–…I)¤Žq^ÐÔUOæÐõO(ÒƒüŸBë(l|ή'ô?[”„ª:Ó÷ù°¥{ænÞ4M ÁFýá9lNNä$iÓ>¢¼úóù‚4a§UMi–³Sêª$ÍÇ|öñ)— T”àQÄqÒòn¯ê£Ã\±Ï`Vóëbœqžã­#RŠ¢â4:Š‰u0äLU⃊4*‰ˆu†G<…ŽQFœ$à¦.ɲte°¸uÒ!Dï$lÎ[¥$Ò5ìîŽÈÓŠÙü~æÊ4ÖA}F$%‹Ù)2Ê°´p¤4žpéÊU¦Ó-šªdkk‹|t"=âÅ-G~úg‡‡”joÁhÎÊ‚ŸÙ·4RP¥3’¢æêÖÆ=æî=Šù®L—ÜÝÕÕPû tÊxô/îm#𜭇 84ΖdiFc,JÆX[!mƒk‘Ð]¤ª›CZµï(éÓ']ßõáçn¯hǺ©«@)̪¥”˜¦!ŽžåÔ_í+`[ñ áñ2ÈÚZÓ<óZwíÍ}j]Zöb€Õ\l× ±­ˆhœsTUÍ÷ÿÕïý?k?¯]dÅ>ï}å^6­H)<çg'Œ³8t˜ÛKKƒÓÕæÐ.mOøäð½u ƒÁÆaB~ó0Ž\…zÒþžòDàuÄfŠ(––q¬ˆ––ï?âÏ?ú&·§Žû­¿‡‚¯¿|—¿ÿûï°û‚ kéæ^BaÏç4JRÓ$Â5CÌýãRHö³˜×nlQ͹²w™ÇGG<.—||öˆÛÛ×Z m‡ª)yåRÅ[/qþtBqò;|çä:ÿé¯þû”héùæwßáØþ„OïÝç{Oñ¥«{H+ypð€W·÷y\¼UŒ°eIIU4,m ¾ Ë'(c%åZΦ*˜Œ'¡t§÷,ÁÖç4MM c±>€“òéçó9M–Q„Pq»!‹`õ°Z4›T7/’$f¹˜¯.cPJâ@¨úñyms~¹6ŒàÚ²¤ ž%oç¤rd±fY¶®ªªzœ‹k•»" &Ò-o}ýfMTzÙ®+)I”fY7k@3¤`Q½Aä½'’ª7T»¾nš¦¯Bú3ÀÏ¢X’gR¯:Š“àñûuÁ¡$8ƒmJ¢h²výµ}GBG[mœ§6–²îŒ]…㧌üÿ² 7Ìõ0õºÇT·åiš¶ÒZe[^¾:¢ôÓãCœ©ùì³ÏZ&ªÆ9::êLµžD°X‡Æ3Ïѵ< e&?çPü—ô#¼YÒ L›¿õ‹¿Á?þ ¨LC]T|R6¼·\òѲàÝ“cþôÉCþüì€,æ̵¢¥ìLs´LóœËW.³h1–šû> Wõ9¿vûo³k,¯Ü|}ë?ã—nÿ,Zµ¹’Êaï¼ùÿÑ/þ7üÑÇ÷1ãœlk·ò.]Ù¥8>aY,‰È)EUOþøø˜Ñh4- †(ù¾³®ûàp][Ò°ÊizT”ãE²öûamç_n²„o]¨Kknk)ÿÒ—j?Sε¡•Ü¿>ïy’qö‘öf±–eç}ßoM{:çÜ¡†®ê¹›ÝÍ&[¤(š&#Y††Èˆekp¦…HJàˆƒ<%y ò$/yËs$pb$0$PlØ1ì†EÖ`ERÓg²É®žj¸·êÜ3ìq yX{ï³Ï¹·šÕÔBWßiŸ=¬½Ö7ü¿ïû3mð6R)*¥®ô°…ˆ9Óó9g÷tvÇîC³ÆŽf9‹"g–¥dFã]‹ëj´ÞQŠÐ :ÍQ&CètŒÅ_ÅW?$FÍŠ”Y–î ’Á“›¢cÒUïÝô¤Ãç¦ó(„ˆá£ÎFM,š ¬Ä$¡Ú{F>‡0²+é$A$s®ß~‘d>£m[Š"ç»ßüMg±"æ7ÐÚ1ÞÔ%Áw{Ixóþ›züiEÛ÷#ž&½UUµ±BŒz¡@„I@ïú„­R´¹O;dlטV¤LC'ˆûûËw3>Î6÷q©C’ùì=»†™¥Ü[>àåW>Fª4ß½Ã÷¾ý îÞ}‡ªZam`ùhÅÅrMSU<|pF>O¸÷ÞÛÜ{÷mê¦cÛ8VËs„ $©6Xg9]Ñ”[R­8JØtŽg¯M<ÄXv‡hÜØ^u³Ù’ç9E‘£µf³ÙŒÈB°Ý–{ëe`%›ÖÇ=²ë/>0Åõ«&ïv—è8M†<ÌCBàlëjÔCÂØ4™øP/­×kÚ¶¥m[šr ¶ÛÛÓÑLzZ:º4Ý_»µ²ò½$uæ‡y#O2žôSHsº™á¨MŠ6)A Ûá™p(;ó‚|qŒG1;¾Ž °­k@ …¦šÄÖ”RÑ‚›\Sá°á2mWŸêçE1Ç©Ÿ$´esL!ö½™K¾ô“?Cp³ù‚?÷"^^¹}$Ï=÷2©2(Vxê®æÖõ§yöô)>ýñOñÁû÷8^äxïùÌqAÓÕxb†ôO|æKt*AgÇÐ >‘'¼öôsX×ÇÍt@÷M/º®æ~ñ¿ó2í¦åë ¬7¼½)1‰â½÷ßãáò%<¥å«ß¾Ï¶©™#uÖ×#Nw&e/1›q?Ac€¹…”Q˜õñd¥"lŠ %u$ȨÁk>PxSƒìªÑv턼A ´AÉdo1ÿ0ãPñLû6KHŒ‰ÉUÈ‘XbˆÈ(=Zû±ç#Kf’KÑï¨Ôi¢cÙ .!5Ã|€DŠÈÜ%ÄU™é‘¬Ãw£ˆÈ†.ünÿ å$WíÁQ@•Jn$E¢ð¶" ßáç¢Å{¯«šÎºKó¶C£úcYbP“§ŠÔÄûï†DN)¥ 8 t-ynpÎaŒ<‰É0yŠQïDL.”m f1C')mSƒß% M_ŒßkÂeèðî•R¸®¦©6TÛåj‰­KڮƆ@×µ„àw ?>^_®úy‰ïTG&"öüq~º¾Õ ¢«)ïÿ ãL)ÓcKƒ^¸ñ[Q#•¡--ï\Ü¥®,m°|ç­ïrúôÍØBÑv<óâ'xö…“å×ɲ‚ºé˜ÍfEAk‹›·iZOgF:k¹qœâC‹ %áCžf,ÛŽom7Ô+î”kŠ,gÝU£A‘Ïÿñ‡§ùIæ™f³¾ nZÛá• ©jл$«¦iGJå(Ç=]³ßzͶÙ#ò>²ãYk#⦢l—BzÔ't àhÚ2²ð±Sò;£ °)·±þ]Dnçb¾Ìt) RQÖ MgiºØ:tx–Aþxëè:GÒ÷8¸J¦M+†=8…ÊG£‘Ç0„M­·?«r¾Ê‚˜þmzóK›r¢ÇÔ½5 Œ_‡— •æââå8$¡§sŽq‹zϲ*L„ìTA¦àQéRA.yåö³Çáü–“|qåÜŽÂG Ζ[þôûwùæ»ç¬—9Í?ÉÿýþÏ?wÂêì.ûħ9™Ÿ°’%¯Ý¾Åw—kÖ«Šåv˦u>;"ûæ°ö†ž¯]×Q×u,ê6ËGÔ›Iš#C ­KVÏÉóœÕjM1?&-æ?P_5†ë7Msi Æéöà¬+γwm± ƒ§´^¯©ªjßKœœ{z­©GBÀ%O½ÕoŒ¹l„ø%#SØpî,Ë/%œL¯9½÷Ã{×»‘X„î#íÙK–zo /Š×6pàŒÏê=dI¬ˆpì4d¸W×EÏ~WiK½p}¢³¬V«É»‰ŸoÚ†4M8™ÏF6?¥E–bÛzdö L>#ŸÍiÛ¥$i>G'ÙȾtøŒÓ50*¥ú¤Çè^Rš$+(Ún—½>õÀwõëŽÙ<6‰|Êž¦¬Ø¬×tm³í¥ùØʦs7¼wï‡J“@g;~îÏЙïžm |ò•7øÆÛoñÝûïóvfI‚'8O‘e,—Ë~ßê‘β®kÒ4%Ë2Š¢àڳϤ¡ v»bµnyøàŒLGå¿©¬ëXÌOyá¥×xá¹qóä&·nÜ¢­ZÎ7g¼ûà6eËs‹ŒGÞ£½`ž€·-BgtNÐmËþýÄòÁ4M™ÍæÌgóÑ°s“¤>çÜ(‹†¹HÓtDµ†9›«ZÆwØÔ5ó,§kÚ=Ït˜W¥Ôˆ.™,¥éZg'ó/išvo½ ŸÕºç5P’²®võ÷/ßCžç{{õpï¡#2ô¡Û?,¾8†¸ÍeávÕ‰/[ö—ÿ~ÕïÀ .!¡ïýj»–G«Š5tmÓïùO)§±U]]³8Z€ïzâõ¾­˜Ð‘£¹¿çMãIœ%L`RïY&˜'&–Q‰ÁÓè/ð™×oSüÏÿìïòÒíÀBÍù“;ÿìWÿ¾öµ¿ƒÏR^}õõ>§[òèÑ#n¼x“<Ïy?¹Ëºkxó[Ê3GOÓqŸu»bv\°ÙX|»&½vÌw>¸Ã3·nõñ¢ËPò0w›²bYztz ÁqÑÀ­Å-¾ðÚÊóÿW~æó¿ŽÈßûÚ?äç¿ð_ ‚$ Ž%Â{®ßz-%e¹Á‹KÐætA 3·;Ûõ囋‡tγHæx¥Ð&åÚõ›XçH”Æ›Ÿ;å>´6øêw©4cÔP‹1Çà0„6 ™diáíºa6Ï }jËúž.ˆØO;„€Âœe~tJp-í&ÁµÛ˜Ü¶nQR‘¦ ‰Ø ±Ö+‡Šk²n:tzJ*;nÏOy¸Yr3H¾þÕ7YÁ‹¯ÜÆ×]Y«Dß.¶s-E‘aí Ï<›‡gïãCËr¹âøøßf'7™ Ñ'Ð*ŠYÎv³…ֳ͙îsB¬GIɪ)iÖ%ï,×O‘ç1©ïëßü_XÚ7øñO|BI¹R¸ÂSä)³¸Î#Ò(SšºChGð}¨ŒØéËZ׊ cX)¢¦ ]Û’LŒ®LŠã†pÎ`„ˆ b¢lÍhüÄÄ$Mc3%ÇѪª{^î~­ô=¸ée„³–®iÇüCgaªØ§ëìq¨ôð<ãq\Qç¼ÿ¡ý¯¦Dg±?΋yÒ1NhŸùê‰]v„hÒuÛyò$¡ë" &4è$£®kŠ¢ MRºÖ±ÙlÈócúwìßsœØݽ)!ÊŒ tÁ!ä'_y D¬=ýÄó×Òí¿ü™3Þ[V|gûÉ£7yöÖI>‹Z'\lÎñ®æý*Á›À,‹ÔzŸûÄòÇ_ù E¡8W¢Þ² ‚ì‹7öçs˜k-­ 4­CW)uÓÒ‘ò'ß~—/ýìÏss~ù‘" ¿DnÀ\Îxëì*Ÿã½ãÞÝ÷xêégÆÒ†©Ç7,)åX_+•¤Ù6”Û Uç9¾þ&IŽ ܽÞ"‚‹ÊÜ»½s=éžWƒR‘†u/Ãú ç‹Åo£q§„ èX.w8—!ôÊbë¼Éáøá²C\LøXF6M<ÚT%­í(÷/AX! Íå‹Ã1ÃZÂ'çyì„4ȉƒ5;5ˆÓDÇó}ÆəŸh¾¼ñy\Lê“}ËPÑ›3æ2‡vÒ·DT:zÕ®‹y ­í!&‹u!BÙ£Pê½Pë!Ígx@ë»)±J“ŸÌxôp…ˆ†ºõ\ÀHö”ÜàÍNÛv~˜ã0J)²"1?Iв•Dnn×5Ø6’q¤ó9Ef0Ês±ºÀ»€JlŸ$¨ñÃó騠‡nnC›ÐáüÃ\ŒïWÅPQÒÇê—üóoðã¯uœ—%ÛÀçž½Ék×os^·,rÍÉ|Î[ßy‹›·ž¡±¡­É²Œ4M™ßàüþ=œÈyxÑPÌ Ö«‚­u×¢¼æöÓ×x18Þ]½‡÷QI çl‘±|øˆl–Pw-×®)®ÏéÚ¯ÜûmÒù,/>{‹Ô´6edçZýJÕ6Þíâïƒ!ãýŒgï#³X’D OyP Ãk~¼Æ>ž—"µ1­&K“=$UˆXž˜$fi:Bl6¤”ÌçóKžòtL¯;=×U†â“Óƒ¦1ÆxƒeßGW°SþqÿždLo8Bc ¥&Ëç¤Y†l꺯£ó 3ò|Æl6§ik¬­ A ’œÎ+‚p´MÉz[õÞEŸÜ¢@M¢…!À²†M7—‘-NˆØWÉŸ|¿À¸š·~ áÿç¿É?ûy¾üÎ Š%[W!•DgŠwÎÞAù€Ñ ǧNOùÌ­—øô³¯óæ7¾Á½íŠªÜõRÏX7ž<Éx·ÜGã¼ø«œ­c_夷ú¥T•C~ï¼Ûp¶i©«Ž¯üéw!@ ß»wN4UI°-§7ŸÅú]ÛϪ¹dñ ¤½’î¼âøÚM’4Ç»Žv{A½]-x;fAf&é=`÷‘ÖÀÐÈ@+Cð%cãxd¬M“LÏå¼ÿv4_DH"Ï#ì˜e)i¦)f¡'Ük!–x%i} £IbË»¾Ò{;ÂúCKUm©ë’º)éuÑË–»VŠrˆC^ÞSÃ|8ס$ø®Ãµ-¶kØlÖضÅ5ñŸíšž4zùr‚p(©0*Æ]ÛÄù‘áZTïéZïã{Áí`ë¶o8!{kÁËϾ€’ÌZNò#~ïw~ŸóåC0Ë ²4a[­8_|àúÍ[Ý<%?>bk;Ò£*=a~ü ןz‰£Óë¼wÿ.o¿{×uØÚ¡ûr:)%J(^zþ%`2ÃÙò>m×"µ¤­7|òÅ¿BæEªH{*a%ù*ôešZyÚÚ’$¦Wf‘!ÎõUFG´Ò‹Xkn»¦GkÈ¥ë.N«c©ãà¹ú}è«Œ²,í;œùÈ•à\lHä‚‹ÈàfCY–{†žèïCø€ë.óèÑ£]zœ¾eªïð¶Fr¹Ì°ß—c·Æ4H}Õ±‡øù¡×uUvä3¦›ê°nqˆmª’ÐÇB}i7V–e$‰FÊ(dšv°`#iÛËñJçøÀ¦ÞYßÓgz¶0è$É„¦ÒüÊÏþ2­üÇ¿òEžáoщÖZ6› µÝÐvÕÿ.ðÍ;oqœ¼úìó,tÊ鵌¥’÷î=à•—^a³9çÿüíÿi_)÷÷aÜ}¸a[¶¤ENÕv}ÎRœ“4˘ðÞƒU|ñ/~†Gë–/õ»¤óÊõ’|~-6‹Ðû­W 3!b™Ègc!P×eYQ7–ûÎ1I3QµÚŽ‡„ O:öŒ¿ÿoJ:Bß”Øų,AJ¶…¾]£·Áu$‰LçyÖíÁt=´±u]™»R'‘$DªKëþpo\5ò<Âf³a»ÙâÚßÙB·ãNçrú®blMPÌ2°á,išŽkv™£Ó¯Órð8ä>Ýå¥÷2‘ C¬°ë:îß¿¹Ø«-óÑ Wš ­í³nÕγ/ë–™o@,ÆçÑŠ¬˜áB Hu1p±¼@zG¹ºÀ»Åó<È„«ÞÁ“:ØÊ“˜èñÂx~¥$Û²äͯ}›Ò š¦Céd„X …ì ½8žä^†ÐÁ¶3¸Jð­3ƒK>þ싛ЬÏùà웪evt‹·^¦¼xÈ;o}‹³{wc¯w 6Uê%wW¸{qŸo½û|*Ð3ƒ8.°}[Ò!Ù/®ŸHS•‘/¿«#"Õunc9:9És”6HX_,1IAš§x/¢[ÇÇ%?­×™wxÛŽÙ×c'±+(¾Å·ß~æ ²dF‘/xî©ŸåæÑbrO@<¼Xsÿ¢Â¤3’MÙ MŠê¡Xç=Jëi[ǵÓ¾ò­·©$›ÏñmƒÊNJcƒ#5;h§ë"öÐihT®Ö¢´Áz‹·–¶‹ ±ª±%cès ]×öphÌPÝyâ—3?l ÇÍŠRHmF£M„ˆ{ª”¢È ´ê[ÑõŸÕJR)ibHŒÆhM–œµX×á}¤ø³vWš§”ŽÖ|O—*dΞï‡þ;)%Ê$±U¡‰11ç,iš_ƒ’ãשWG(­éº^õiè;x±Ñøº”moOõíú­I{˜y°€õ IDATú‡kŽûw¢¤RtÖÉRtÏHvàu!W¿Ÿk"…$MÖë%Ïâä:Iš£Œ¡ªš(˜„ˆ}Ö«T*–©´ #YoÚÄÎXMSœ#Ÿ1?:!KRšª¤ÙnH‹ZïxÁ§sû ]Oºæ†ããÜ…Èy. kw•Á{¶Û5F)®?ó\_¾¦1YŽq¦iÿm–:2rþ¼j?¤©F8K1K(„`‘^}ù3œ?¼Ãw¾Mnê&3Î..hlEå*|HÑÙc2$’uUAÛÒV5i–ríô«ÕCžÆw˜¹¡“°Y-Ù4Éìôóż_ãïmßhÈq|òÛí’çŸy™åÅCn?õ‹ä:iöIŽRÍEY±Ú44MD¤‚LiÛ’å£5Uµ‰Î… hùê³€À…¦m+¼‹uýqIÇ€©êöd RÒ5åX êC4à†ZâøßeÝB|¯ÎÆf.MÓÄ0„‹¬r]¯tå&oš†º®h»Žíf…sŽ¦mÉó¢G¿ìØ qX¶ër—t¹.«È0ÙYò¾‘ËÔ@ùÚüVŒ9Øb*©CO*òVeÜ®C»¸éç¯R؃¯õ8%¯ß_[HÒ¬ÀÐB£tŒï(mAŽí÷òÌD˜eRØA`–[Çq¦/][)ͺ†²d×tàTÕüá7ácÞ)#ìâ[pr)xæF!°(Žxiøþù9‹,á…ë'”›ÀEW‘å) ¡ø“¯~…ûxž_œ ]I)5þÅgé›dÅž»ÎQÕ5V:)PFr±ªI²|„8açdYFck,·äÅ#4ï¿ó.7n?˶¶(•€ø–BBï¡IU@˜ÀÚ}œ^ Aè[ìi­Q"n.¥«H%h-iÏzSõB—þ<„ §ë$˲‘gz÷Nú:ìž?]ô}š½³ ¢`'€ÖO Ü–QqkÓ ]ü›ß é½`ÜŒi’CYU „¨8B/x¥Ú!LÓû•“‡jŒ…Âô«’,I)«î²751’…#«Øî\=Uh/¬"¬ˆ¼àÖUn?ÄÏu×P(i"\ĸþ&·„êdvû$:O°6á$+"hR¤R”e‰ >®1Ð%Ž7ƒT† 5õ4=ä7˳ؕ«ëH³9fqŠ)u°RÒ#n^šÞ¢ŽkdâúF š)µè0'Q† ŽѦÃ{O¹]Ç&I"PÖ%‹ù¼GKƒÊ3‘/X)$•Â:‡íëÕ#ŒQ”Ä 9šÍ~ #cmË,ÏèB m=³\s¿´<•zÌ¿Ä[gÿâýïaZÏf»¡¸vLÕ:ÖmÍÍ¢@¹@×t¼ñêëÈLp~qÁÓ7nñ{_þ#þœsl«–ï®ïñâéM\mùúÙ}^»~‹¯ŸÝGyÁë7n“v+ ¢q¬làwÞcÐüô§.(Û õrÅSÇ/!Ø0¿õ‹|òæ¶ ëÒᥢj‚T¬—ðÞSs1/"Ic¶zôŒRÇä¿z¯³›£^ÁoA ë|ð²mêÅ}›¥Yl£Tdýóãq’a?¬½®®ãºÑ¡åvQ$bˆçæÍ›Ôõ®ò kÒ4gÝ”¸ Ð&EH 2ÐÚ–vÙ’$»†EY– €Œa$çb7:!°Þ“¨>nú„°«àËÇy5‡ñœ'ùÌSqÙê½ìU_õù¹ö$b×åɶµàÂ)„2c¢Ìðr…ˆ›Xwªÿ/iTÁyGè­œZ¥üíKüÁwþ÷ýèîž­ÿòë[~îãñ%½rëŒV|óηá|ÃÛå–/ܾÆ{>€™I¹ ÃÌ ¤”ê”X>ÿr`ìÖÛ{ÄËm‡Ð9*’4¡(BiÚžh€_†¹i;ÇEí¹X.ÙŒ·nSÕ-Å|†Vc2.–)@$CqÎÑ4mä•CÁþŽžq(/ʦÅõÑÛÈðHÚºŽqâY+WÅf†cœµMÛ­IÜÙÙ=81…pŸú13u GÒ‹Ø‘«žxkÜgiFm;|ØŸ×iâÉUkx:†u7¼›á>Ò4<ÎW”‰ _CQpL~Þ=ûåÌÐCˆlzüŽLäꘘuiĤýæáîKµŒÖiƒ'¥¤ndŸL3@Ÿ:‰¬fq]ÞÓC\Ï@h:Ñšd–ƒèÃ(®!Õ "¼‹¬L>ìÂ-SV»!' 0&Q¶⟆p®|™eYŸDºƒÌ«ª"Õf\+#êM S”R˜4%›-(Š$!Ø1ÁlxWW…OŽr”ˆYù®WXt¢ð‰æÓÏÝà_½õ÷ês:éȮݤ” «Jê,å/h¥ó æþ”s´ÀµÅ '§Ç0Bó›ð56­åSŸùu~÷+ßཷ¿Â¯þäœuYòÞý ëc6tð‚åjM–  ^¨ØÙ®_ëU]aú¥Ø=PÑöqýé;Ø­ãÝza— )zmûDH Ï2‚cÒ¢õn,+Zk·m[Ž ý»ìºŽ¢(¨mC’dTM32ÂÙ®ÁÛ–dTUŵ›Ï Ò /$y–ÑÔÛÞ)HèœCI‰ód)¾‡ÊG$ H“$v5›rHžº1  ï²a7x —îtâ¦ã*E~ÕF8üù*øûªÏÅÙ· ÖbLJÛu¤êÖ±˜gx¢ãøp˜¾öÒ#D ñ`"\¶‚,éù¢o?zë¯óÓϨ{gÞ:G*óç~ƒßþ¿Ë'_YÑ°åÎßã•g?† šÜ/ùÚùîø”?¼û>¯óÒ³·yt¶æÌ[^¿ýó|þå/wóå£í<ÛªCê!Jj3»Øx‹ójOA‘ÿ›ÿŠã›OQÌ1Q(DÊ»8WŽT’Ä`ÎÎî£LJ:?²÷ÃÂ’TUCp’]ÜÓõ¼æCÙÎGb!öz³>nŒïrì.Ï]×嘻S>ƒÞ}æ5}ùNž$¸›MI–iÀ\TP"Ø“ûm£ï9U/zÞh±_ügH öc¬'ßUìÇ5Ó¶ŽWÊ!bW#ï-ÛÍšb6Gé¤1™°_'B’ß)fÿ;²4%x;»‰ý¶·‡s7î/qšÎ¢•Å[xZ)ÑBók?þë”Ró?þæÏÏühÖßë Î9’,å½»wÈŠ#Þí:šª&ËÔ·1Z°Ý”8Û"E›qëú-ÚfÁñâ&‹¤âAeøÂ'¾Äçà °]G]udyÂ_û×^%„O"üÔo€yƒ®jøÖÛgˆdF’EŽe Fd’aÌŒ Eÿ¢íCÀ…@’¤lꆮ«Σ“Ø/½¨8W"°]m"Ò{È.Äü… XL|,Sá=Z(±ß‚€ˆ¢*C:t’ Ò” b"¥Rё˳Z ªÍ=Äß½¥µžòá}„2$ó#‚³Û±<»@úÖ¹>"-!:WUY“gã. µÙlÉÓ >È®Ã9,É€Iû¡U~UÌp*0¦_¿û‡x‡÷4Üðtñ ¨Að8ç*Z»¦‡T“ t|àuÙ1~gTÐu»LÕå#KšIŽ‹ýúÃÎ:Œ)(Û@avÆLùqÊÙj»å¦“t*°H_ü…Ÿåßü¨% áÛÔ(si-HÅz[sãÚÓlê-þá¿ý^Îøù_#h9–0ŒÊ/Ê.P;ÁÑqÞ'ðÄù-Ò$’hôÆÔЭi° Ÿzþc“ÐvŽbfÀ_öÂ"a½£*Kf³H=L=!ÄžåBŒ=׶EMÒ_;„06kbú=\¶º>;sÊ»[KŒç~7ž+ìJ+€16½ûlè•Ó.Ô‘ëd’ô´lÓ ‘"n¦kÇç0¦Ge|@˜†ÔìÖÏãˆF®òØò<´”“1E¦{nÈ06ö¨œÙyèû{$^o½^ƒèé4e¼ÏDî(=ż’Y– °ÄönWqM ð!¡Oº {è€p~~>^ïqÞëàYn›8×EŸ¨w¸vüDA# ,«> 4éåؾÁ:|núõª1ð0WU…2š,/Æœ!*íßó(ìûÆ m­Rx7(Ý“Åã÷yë¯ÃÚUJñpÓp\¤\”-¹QäF‡–ßøâ¿Í;ßþÍq‡ë¦iBëZdbHµæÅœ//—Ô›†,ÏuMP’W^~r[síôˆ 8>ÏOüÈë¨ZP5ÎH/¹(=V÷ äÅgn’ë‰ä|»!4pÑZÎ65Ç× AáÐ\\<˜4Æ\•ÇØ65®WŽI:Ãyɽûçháp]G’õÂÎÀ‰ï{XŸš ÷«ÜıDì—éMKf‡„ÅC8›åxBÏ&0I†‚Dk‚‹ÞxèÑŽÐÃîBiŠyJ[Wø¶¥n·<Dë6n&Í 'ø®RÌ;o0v›hȂܱQõ™Å!ZÄB‚ }öCIúOAïÉIIÓZæó‚ /=»Øåg쌇ý¹šË 15þvYè‡^}ïbü8 hÀ€)cL»l#MêÑ,‡°Ÿ©?ñ>°8:Áº¦÷¼ÔžA ìü‡wž¦I,ýÃ’£ù‚¶«QIBðÄcB½äá¡£Á³Ë€·ÖÆ<@ë¸v¤Ô—Þå¡c³i<³D`Dìoím`U9²T$s0N"¤‡Ðç=Òvè ©­ƒ,áÇNPwئã©k×™e Î.>kheŽo·üÂÿ»°\ãËŽUëYnkšYžrÿÁ#òbFUw|ÿýs‚«¹qrÌû.P&¥i+×n“Îh6kºò‚º*IçÇXð´8©‘ȱÚ#&ÍEE–š|4ÀÇpdˆ n·Æ'+4þ.–»z©ã>é‹,‡W;$ÈZç"Ú"cݨ[¤Ž5ý ¡u\³2–ú¾ŠÀ…(_{CÐv-Á¶4u Jsýö³´Þ3K]c÷ ä^n žÿà¹w6Ðv išbtOœôÄ;í#Žý…?x7ÒOê_e]ï>{²^û6¶BR¢õŒmµ¡®+šD/jhmçñ]Ëìä¤Ðñ:Ë­ÞóÄ€‰ qÐØ€‘š™ÞçKŽ‹V(‘òò§øé—žåÇ^˜Ìf_úñ/ñŸÿýÄë'os#ÕÜm^à—?÷+ˆy’§ó!C “Š²ë_œ6±—qˆ1µ‹MÍ|½ö¶kcŸf%Ù6±U  #¸ÕÇWw-)¸–ÓYJc=›•%ÑŒ°J¹¾@e3¤VHcb¯ç (ËM¿ÂŽŒ¾ÀÓv“?ìØ­ƒAúq§ ¤JI²,µ†ÎQU±Þ;z5qÌfE<—ß78½c,}ðýPpü #ùûŽ;SOmê½~¬B;\ .[û6wûç_w°¿ŠÍî)Òþ~ö)%E_‚C>±ºÿ£Ñ‹Kzå9p];½k²’§2lú’E©&µ¸œ>æ (¹÷.É;’=E<­Û?œ£iH!˲}¶$—³ª#=燿 Ý—1ÎÄ !‰H¢Ôõ gÌ„Lc@†µÑu"M ìò¤”x×"Œ¦i,i®öÞˆw–³õVõ£$…‘„ª¤ÍMCZä\;=E xÚ¼€P×üþ{sþö¿þEî߽Dz]й˜iL“mÔ6«- Ø®K$ž³‹÷©«eR§×˜ååÃ3.VKªª$[œÒY1±J±¿î}°ÔMÝçÉQ1?ndYFÛî“Êì³ËúvûuS;£Vì ÞÉç‘Úø½Šá!2ƒ)JC콩S²cÉ f³‚ºªHL¶wÿB›^!3:}Ó5Ú¶-mãpÞ]­œŸT¨N=ìédìOØå^˜O2¦Öðèþ÷píÀ3}¨¸˜ã‚ßn·Ì]]b²/$–+æó#¤Œ™¸M×÷lÛ±]op^pãÆ5l[E%,ËÒqš½ÃI0út‚ÚE+Þ¡8ÅcÑ•$2 qüÆOý ÿõ?ü»<ý…/*H¹LpÁó_þâ_¦¿Ào}ýM~íã?B§Rx;?‰ÐR5‘ì½±š,Q%„ÂZÇÅzEp!-Ji.6 Zª²‡q<(mPj·øDp¤i‚÷ððÁ}:'ƺÂõ£û±±Ag1Éж-Ö6BTÌÞ[¬õH9g¥,ÛÝ8TP‡ÈUkc·¶¢¢Ÿ&ñ ŸÍúÒ/OÌÈR `Cl —$I9ÜPª0®!½ƒ!EÀ0êjE8(®,K/=×f³°%ÝXv?ä }\Éõìh£(ˆÍ4BˆíÙÅÖr…à\ŸãÏ3Jã˜ÂÚ—§Ý<ƹHM†C\¯´½"앵·=uá!’qµr8Æw }yfh]Ü+¢¿ßT12`¥QYülÓÔ’Èi?´§6>綮9YÌ ®¡ .æœÄËœË:&ÞÉÈÅ}˜'0xhÞu8­z’A¢RnV¤I/LX×!¤Áö¤š¶F‰19>Ô±zï‘%ªïòl\7aP¾J1ÂÏӱ˕¹ÙÛƒ—9O4¯#1–U4â¼bÙl¸V^˯`;‹ÈÖÃâ¨àSÎð'w¾K* ž¹y›ï=¬xñÆ_åoýÅ#ª®CÍŽ6gGxÛá¤B©ÈaäyÒ I×®¦ 1y°íÕæ‚‹ó8aHò|”J"*$vT¡1›WRí'Æ®a)Z‹1»Fä;*NisQ.DôÌï!&ùC¿ ìQ» +"¦z,"/)/Ü+W¤š#… k+¾þå?âù—^#»¹ÀÚ.!É]žÊµ–ZBL¤³ÖtÏy*¼áåáïS u¸ð;¦0ù@(òaÇ6MCÞ³îÄÌS‹êcˆÆœÒ­µ4Á¢” k"·«”’‹‹5Bf³iߤ{ÕZ晓NöŒ/8ò Õo=«¼”Ô>.¾“Dð·ÿòßÁ¤¬ëØ a–´ÑdÂóo¼ñ#TF‘u¥ ¶*Áµ®w@ëu˜if™¦iZòôˆív‹YoI´ŠœÑC±|´iš1Äçóéc³Š‹å’ÙÉ ´ÖTU£2”uCëA*ƒëZÒ|~ˆÁF^çaOõÓ>Ûœ¸´.>êÎ9d‰»ž07Šå2Zúª¯›”Îg)N?x‡™óO2†kN³âCð,²"¡C;ÚÓçp.R¾Zçé:‡˜dDˆÑ+¼,‹Þ‰ T÷Š¡7ŒÜ›¿Lᙥ†¦ŒdÅâˆr½!9žÓÖ%³ãSœsäy† ˜åGl×+Š´àÞ½»ÈÜ㥠óÑœçÅø¼³Ù,±ahQê©+Åéqq”vynó\º©_{]Ël–¢øãwJ²Iª¸ÿà!¯^?æ¥Óç0FÓ9Ç7¾ÿDšpV•<Ÿä|îhÁH«šŸ{ãWi»Ž‹Ê£AÛ)„ò(X7Ö·Ñ› ~œg!uÝà]†)IV¡“Œ€gSnbNÎq 2¢Ê •¬©˜B×Oƒ ð²¬.ôìŽBFRÃýs(_/#`W{íÓ¼¬©ó(‚ÃZGÛ´<õÌs”Û5óyyü.;½æáu†yPJ¢Cøp4½éáûirËU0ÀUÊùq ð)8Ø+Ï%ÀÚ+UÙP5-)‚B)êªBË€ë[Ù qÂÓ55MÓa%™a}ãAUƒÁ£²„à4«²ãú@àHU`[U|ÿûß'“ç3”ÖdyN[¯ð@š/H³Œ€  !5JÅxZUU‘Hk¤Räi2ñqz ‘H3é\l$1mHp5»o™N¿OÓHŽ?ŸÏÐÐÃaÅ|N×µÔE 3ZÔC“tß iÛuPZa»ÁË2àc¹—”`mxì}Þ£÷çbmš³øØÀª6f‰öÙÞ‚!‡#òÄðV¿_|ŸœÖ¶øàQ=™L´ì¯VŽ‡ˆÄU÷zI€ôû(3´Fi…÷@¢‘"°Cü.S^þ ý;×—±H©º®ëY”bÖ,œ‹¤ >ø¾m#áÊølŠLÓ¶½@×)Å€`ȼ%ΡÃv5*$yAUWøà€¾ÄoòLk—q„ó”«Gݼ !9«5&J¶(r‚mY,ŽPÚ’d)¹Ì(Ëš<Ñ× õŒ\ßõH¼gVÌ°]ì–50\I©r¦á¥« ò¶‰œá»µ?SV ™)¥ç$óüÓ?úüÒgââþüc^~êEBÌó9u[óÌõ§ùÞý÷9o:ÎÒÀEÝðÚñsÜzþ‹$©ä«ïncïìP"e,àY¯ZT~¼Hâõ´Äu£ڦù€4| 5s†˶ªXܸs£"ùÂRìó_!¦CÝpÕ\ c£ŽÉ¯²÷/c$!mÓúÏôŒ»ÐÁÀ&&/­ñC#ýªûe“·i¨¶ë¾æ9!Í2ÊmÉf[1/rT÷‚šœwêèM‡1Yò#yÎWA‘WmØ©«~ø u|”s©I’œÍò>JIL>Ç[Ëfµ"3šGÏ@1+(f ºzKÓZNoÜÄ»ÈMmôŽ¾é,ÉP2#$ËMËl½²é •¢¯H½ZzŒá C¸ Æ „Âöó»®]P‚%I­õ˜ÔðÖwïaŠŒuuAžñ`¹%8 Úp±¼€$AöÜbÒ9ÖFnëÎÚ>~èÉRƒR% UÕqÿÁ9³Å1³£S¤6tmä.7%]ç)ùŽs[G8xÚ|^™ØWWÊ)õFÁ‡ ö¾Ð‡}˜{øyúûCT&fqFšÈb>ë7}Œi%9Êæ©Ñ½r.²£¤û}’Žk\Ÿ6´;àÌæ3‚¤÷‡ãÐHF4=ÁŸ×ÎCˆçwƒbÔšÖYæ³Rö™ôJἧêºH™Ù—‹i= ?nÌ ¾ Uïg(Oæ®=¼W&ç =ë•ØûÛ¾B’}{(\Ò1Ö»»·Áëò=í«uŽlžÒUòü8B‹-4¶Ù{ÿ!ÒTÔt]ô`»>kÛô Y]gñ=-®6)ÊhfjFY–{ç ”Ru®cyqA¢#wxlCCVi1Cv;B˜Åü“ÀÆ–œ/ßá³'7øÿÞºYÃÒÓÈɯT¿Ž©Ñ,R@ÛÔ´mÇb±ç¸ëö“\¥âïvæ€þ©Ô ‚ É=ÞIþêë%÷ï_ðŠVdJò‡úe>÷©ÏB@,f3YÎ 3Á\åÈãŒðísþæ§rÞzû=¬7Ì‹Ûª¤­ªª¢˜‘(EUEºÏfÛÐÔ5>uHmZö$7ûÊ,Ër6u1)¢/ie¢3¦1ßaý^ÕãøqkløªÆ¹ž¬Õ]ð´u;WMILˆ¡¯ñçq?É=™´Cj¯@½æ!!Ù{GšÍHò‚à,YªÙn6l.r|z#6Ç`çÅòó€½Ob¸b¸À“@ ‡÷¸ûÃzÉæâÆ+®Ý¢*KTøÖlÛ˜ —3¬÷t]GYUÌGØ ñ.öx^Ö[NNŽb­®V±Qºˆ›™$¡©cÍ´šP]Ï<ýú‘nûÀ’ê<èÞ[²Â`;HgñoÇOݤÝ^д ²4 ‹Â;Ü¿KÓÔQ0öçlš­ã"¦·çEÞ¢¤¦)+Î.q´Š¥!ÖZêrCÓ4¬VkÒâÚŽÖ{ò,cS5c\z¾»€ËÏæÃNiDru uøû¡ñ7l⡤åøèˆiéÐ8&ënˆi*µ£w ´aS”e¹‡Ê±sY6c6› úð=O•àN° ìîvš&Î=lç•Dè¾qGÎÕ Ý40€¿zƒïqóUÅž°˜ÎGUU{÷¾›¦Ë(ÀôwûäjU IDATä-?¸äq8n:/BÄÄÉ$Iv5ÞÞ¡zå¯tdÈz´]ázò ‰ (ŠXæµwn”4ÑÜH|ãG+™ÕºXŸ$ Žˆ¨L r£cúLRiÇ't]ËñÑñH€MQ:!Ë¢A´åZõ÷ù§ÿ¥}õST.çèÚST×¢ÓY„ãÛ “jªíªO\s÷ðø0—1Þ|9Am¸Ç<7ý\ísOxï™AJàØtœm-I:ãTK¾vÿ=^7Ç\»ym|þ²kHŒáÆâ„fuŸW_y•òÏ~‹_üÌD»YqÑ,°mZ¼T“1KrG§eÃWÞ µñ’D€DÊ]¥Ì°n”eðȾ9ÎÕa‘é÷‡†å“®5­cHoø9ØVe/ïbµËt_L!ä¡Ž0~®Ú'Ûs‡Šy|v¥PZBœ¯íòB¥Èà¹X>Ä»–ã“—âßú°®å›Rà½Ýy·õ̇8ýùI6ëcq”ÏM?;Üw$¡Šñ%#Ÿìƒ,æs\"µbÛ¶¨ü‘Ø®Fø! Ç'×)f)ëåçRg¸®B'¶m±@csØ®× 'GÙÈàux_Oòl‡¿²{’|2ÀêbËqj¸sÖ°jkÒüI4uIÛ9×o dJÕ:Lª{a CòÔà]‹ ëÀÙšGË]Û”˜$Cš„®.Y­£PWINZäØÇ|1cs~Žk+ðŽ® ÑSÑ;ºÓ€ßõ8õ‘k½nzåݳDM Á0dòr9ö2ø³YíZæó9]SF/¤·n­mq®ïÆåJ…:„ºoŠîmCžÍA¼íèúæ Ð J$6ôqVê4f~h@J´ß”S}ë»áûìhcPÚhÓÇ {¡ÔEj…J½²Ÿ”âôš×s¾Ëw¾ë Hb“Š®ëÆ’2di2*ÿºÙy¡¿O£Æh\¯†„1)ÎF†µ¶ÏpB‡a†áû(¤â4MÓ³žÅ¶Góh@ÔMïÑFZD¥®k0YAÛE¾jå"አ»Ò1!ul*Áï Q!b‹Ìª\ã}@¥iß3„÷tM…Tf4¾bxc :«©$Cë cw¼£(2„½{Ûí ™ ¾ûèsü…Õœ—‰IX¯Ö$Y1¶Rmš)ï¾ÿ>E>ãƸGw%‹ž©r!X×%w?x€“S¤Ü:¹ÎüîïqÇÎx54|çý +æ‹“¸FÛ2ÖuÛ†Ú% U=æ|~=éOÛD„-Ø“HëmCšÍú½yécïí}Ž!Äž±rÕxœÂ !ì)ÚÁÈ !™lLòb˜Û¡BAïgk÷ç#®—µÃßåˆp>1x¤øAoʤ?U ›¤‹ëXkIÓhøey¾—8ïó>¤ï÷i!!²ß zVºíÕ »- Æq`Ñ´ø0²ßKÎÚçì Éàöïxúl¤‰1«R³»íGD¡±‡‡`Y®Ö;îÜ9Ãyσû-_|±!H,[Ö_|†švI³8cºìÙæž¹ºN¾Å"$MÜ)ÂDkʲ& éúH÷<ª(Ùl6(©BáìÈÕenàËǹÿæÛx(ë2‘Áò{¯ªÔÿ'Ó@ÀÅ€­"cLJQÄ#§2eõÇgum‡H“Ûy„L¢MU½%zGS•YÙÍ1ö~’yi"ÍѲHþÃròy>AýÚd7£Ów$èú‘$ów„íÒùâ1&a ¼G+ðQ¤D"‘ZSV5ã8&Âi«’à'Q”äü5 YäAeS•Ó&5#UU¦ÅN&¶¾Ö†ºhòfãY.[¶Ûí|¯ R¡LZüä‰Ñý÷ž¯VÄ`iVg¼xqsIvµ*HÃhÁyŒÒ•ØУ³ineYÌëÏ:Ý» ¦ aèÁáüÀԛ콥;äžt£ Î#D)ƒ‘à³&ú%¦mY–Ép#¯ 6xªÅ‚(Sg´8íò çMUbD«$ûèÝQ!jÒ5O܈ô®‹qôApgµÀ;Ï¢9ãÅÓϤà¬MܲÝìÐX˜2×WÓXi²(QŒ¹}.¤PlwÚr…V#¶ßÑ,–(%ñ>P©H©Xøûô?ñË÷~”8#zM\Ev¿Ï?ûð)wmÉž£¹ß°ë¤yûî]¼uƒÒ[ ‚û÷ÏØï÷TeÍ×>üºæþìcþùßø6ñù«ÂqÝÊsÐMzWq`y~7é¬K‰ˆÍæ*´:1‹}LÁèþ°ž»(¦’R±8{ Ö>-ß¼n}œöŠÛ’ÇáËóÌf¡¨ôÝ]5i F"Š²9ÆÉò¹ã\;®iSŸÎͬÕq²‡‰ 1¼ñsH*R ³†T‚#øÀÐp1©]<ÊùÝ{|úÓc‡4'LY2ÚñvBØidðó¯j·8…_uþ¯ºNúýW3ø^w‘7Àl†1d˜®ïû¹^BHÎ)‡žè=ÎÃþ0£ ©[6ë=ѨÂà¥d{Ø3tõòŒwîÕØ~àb3rwU0ÕX^Wß`˜Í¦O‘RQSÕ%W—/¸ÿëƒÅ¬Å†‚~p\]¨’åÙ’çë5»í–þÐaÊR)ÖId¡ ˆyáGKY5Hé2Â0b»Ž®p.0¸HŠ²®Xù9ÍòÞ¤©XžÝƒè°ãÛwtÝž²®±LQ£«jÎ>«ªJAAþŽ  ã@ OÈ“ºß±çïö@f2Þ¨›TókÛá«e›™×?8Ûý±ö­®û§ ¤Ê‹ÊuÔEJ™Pƒr Óç¦Èúô~uf¤ß,ýøÐÚ`‹âX4™$—×Ð¥D ÐEM̤§yΆ˜ü‘e*[øüÌÔLr¡“Ö‰õøad{uA `Ñ.E·cJÖ—¹½(¢Ê–¡íˆÐ¦(SYà°ƒx$_5u H¼GKˆ–]×3Ûæi™ÕÚò‹š; …Ÿ”žÒß«ºÆH®g¹XÌ“Ö9‡s©}b-* åßVF¸6±¢Ï›Œ¤Æù>¼÷4u9Þ{Ñ0 yHÜD”NÇaÚ`Sÿª ~¾¤lÊù³Þ{Œ 4Mª•ö=Î*Úe"Ö%"–;ØŸdô©§>“Ó}ÌðÀý»ËLxO^1Yj…ÍR—JDšZ³^¿`ÔšªªxþxÃÓÏ<Þû7›³ÞîXœHDºá°e<ìâØö£”!Ä11{OZ¦9–_+!F aFP ¸\ú(‹­ŒÎác¤’¹Ï8¦ze2‰ùžEÛíÈè’$¤ëwUMY\HŠoÖ'¢§ÍÜŠ±OµzGQ×T•aDòí¾Éè<ÿäû?@ OU6¬â'“(ÏwÞy¿ísP˜4 ‚ÈŸþ”¾ïyóÑ7h6þìjÏò~I¡_ûœ‹ç¼-‰r`t ²›ÒéZ­¤$xK°:»“~î-ð>­ý‰åÝÓg·ãø½M !f”E‰ã&¤È%¹¼Þã ^€Šx›$V¥ÒHcpÍYªe?„9ˆö)$‹6µÄ:?^CSç*µP×~~}͸¾ÑN])þîø7_ó$Ø"uUe²Œ´ÃQ.©Š–ru†’Š¡ïè÷Û4¯Š;:úÑR©¤¢ç¾eáyÕqÛûUóÍä濿곧LÖkøç¸ßS˜oúLߧ\”%Âì÷Û$=SÄn›ÈU»H>ÅnD×u¡ñnÈ ­£0-¦€à2¼:ZŒ©qÖ²ÝY¬Øn˜²æ0Z kG¤’]08u£D3Ž©MèùóçôÛ+šÕ=bð…¡0Šíf‹õ­ ÎïÜGšhsK·\^nЪ¢0†@j]ˆÑ3Ú‘Ú$ßgç=]×QÕ5J×(­‘Dœ“ŽnŽüêvÁè’®WQ·ó³OªŸaQ˜Y l6/GÓuû¤—;ùÖ*Ãaèæ,t~?$¢º®g"›Ò‚¦LÄ2­5ËåòZd:-rS&É-eÓcŽÆ'W <©¦:år¹Lä°<Ö¦ ™"ñ×#4׃EŠë.nÁ£´¦©&’W^˜|Ú´êZ3)—A’´Ð4 >ŽyQ”¼Ø”¥áòbó‘Awºc œ™Y.¥¥®+6—W˜¬Ô5û6“¤Ém|7¦¨4‘¾ëX´5Ui(ÀÙS”ÄèiÊ*)Ý…€uU—ôÝ8×ðÎIK{°kÞ|ˆÐ†2›wLÌv¡¦–¨HY§ÀéÞ½{h­ Þ²lœèï¿ÆO·ŸPÈû(“‚%YEž~±fólͪ­ªÂ ¤À»¤'ŸÞ»¤ßí9ãìkÆÀn7PWE\qGiV)Ìëó˜.ÁÏÞŽ¬?ù…³‰ÿñ?å_ÿ›ïà„Á©ßÿþŸcÎ5w›±¿bxúœi—gcØt#¿õÁ#jUQ芮兀âòâ9ƘŒ}ñ„§Û+¾öðŒÿóÓ9»ó9ß}øoÝQøP²³£½í¯±¥”³NuÛ¶XçpÖQÈÄÚ®šÅ±ÆÊq}>åœÎ!J$΂Ͳ–)Àtý¢¬óxŠ¹£Ä$¤sèh«k›â¾ÛQ5˪>ˆ)yH2±‰c4£dÇ Jê×~9k¾ ¶¾ùï·!i§{Ô4Çq@éÔæW4-DÇãŸý7ô”Fpï­w±ã™£1íySÿçZ€nþìµpv® „é Á«m^wÝW§ÈWC‰Pi#!5€e•`)¥óíºC‡DP6-Öy†®ÇyK¥‹J‚À‡H¹.^÷¿íú‘¦4z‹ui ÖÛ-e{Ž© °ßwxJkFÛa”ÁGðÁ±Ýmú‘÷ß{ˆ:?°î÷\]\uÉhŠ€’Ð>ÀÐ÷xg"ùÖ"â,O8(ë‹+ŒRìv[©[ŠØãÆ!™@–é”(#ÑbršÊ.DÚ¦¥Ð:1Ì)Ù®×Yk[ÐuJù]¥çsJ—L^ȉQ(‹QL ÎÔ TäÅsU/(Ëë]‰EŸ «Tvp„(2zâ:<Žû5-BH®®ÖH]CÄ ±˜7þ<Ä2ižO›ÎŒøà"i–.;Çä`Ã9˲^ DÊîëº`±¨óH ×î !“·-é|“–"µz 1K]B’ÚŒÖXë2œý0¢¥ÀÙžaÈYÓ˜Ênð\ˆ ýÀfs@§gg /¶;”Lâ3ûmŸÌLdÀ‡o]`Gk‰Q E‰È™ŠÄÐ÷Âh´2IÏè©„Gð.™½ëRpè:ª\wwãHi`ë{Œ^Q—ZKÊÒd1œˆ`±X µfâXíw;¤RTõ$D‘´”„2bûå%£u4íŠ1NÙŽ£]Õøˆ"²ºû€~×ãžqè“vtÛ-û·ÿÛ YÕ%Ám©TÉÐ 4EYrqqAU5”'-A"‚ÖE‘Ô”’LŠ‚“Á‚:o¥6XëißXpyèø·~ç?ä?ýƒÿŠõ›áà¸Û¶ ¶g¿«ùqxžèEÉj±bð–Ê;΃NJö¬e·ßbÊ’ÍÕ3´<[o BóàÁÏ_N{ÅÑ’õ¶ "ýyJF'ùÛtÞ‰q~ú¹›Y8$†¶µe Ö'KK#¦]®ìÀ—_<&.SÂ4Eúææv[î¶Íø«~gò­<ö©½¼1¿.c>=çéC¸þůk|ßöçãµR½NË\£T”…¢”Tí2½ ç1iLv{^<½ÂÃjµ¢,K´ŠI!&3õtH\H‹š)4WëA(ªªN‘[þZ—Åä\±Û¨ªšª)ž>çþÃ÷!â¬å‹Ï=HÒm E™ì §ºŠG¶Ûo?ºÜLH‡”’ËË5cP¬|Œ(eÜ(iúŽÝþ€Ï†ðD….s›@~ÎUU¢•¦Ûô©ÿIðžínÑ%EµÜÓ{ìNïÊ”êZ”CÊ–“¬g ⚶ÉOš¶ïPªœ?¼OuK‘6c)%McBÒ ©§WeÂÖµ2È´áÙï÷¸©”A(EtŽ“¹BêÄx‹vAß×ÆÚbÑÌü¥%>(û>1©s¶‡”ÔUÍÒ‘§cö8ÇJd†iœ‹£ëÐ$Ì2w—²ë¡O¨Îø¢`‚·ô‡=ÃP©¿We&­sŽý~)ZtQHYʪY¡ò¼½zBç<"¦ÏÛì C™-î”J6œvx²]ÏqÒ¶ú¤ IDATr‰s(Rà%x¹´c¤FP¡Ó†¾¾xÁÅ—˜ºåÞÝû(¥(ÊIòÑRÅ`³PE®m'G#™jÇ"Ágg …§=«²e,O¿ü‚ÎEʲž×ŸMSQÉà×´Õ‚³sÉã®8Ëxú=G?’äkå‹/¿d»ëбHšü>¢ŒA)…Öš»÷ï§M‰H!‘J²ÙðÁrçüŒInš“éÊ4æuÕ „`Ѧ1ðü›ÿ1ïþ ~óá’?Þ]°ï–ZaÊ‚ªÒØ1y_¿»âëo}Vjb°<ùâ3Þÿú×ÁóìéS‚0œÝ»Ï‹õYT¼ùÆ=>þø#~øã?æw¿õMÜàÐJ°¨+.w UˆR²Ù&â«”;Ž!ÑFPJÅå‹g˜¢bqvÆÕf“M$‘ªn¢«×%ÈÈšÜʲ¤(&^G–[%tûýžºªQE2#.¡1’y éÙF‘bjÑ÷…U¼sSôÝî*’¨‹³–èm†XS[Z?ÚT»‚ýa >1À;'Y,Î’ÓX&ïØë"E@¦ŽÜ®3Ëúžœ ÅÙ [œ¨n½b-™³ ¥P"¡D³„¡2Dy$"™P-~iª ã<Ǥ”èR³ëz¤2‰«±Þ1Ú§œ½õÿàþ3¬Uüê;ÿ6”iNVU5'KxrõŒ{î¿Á†šÿüï]ð¯ýÓqçö{±½'D‰u>¹w™’zU‚Ò„Z]&±óós&ŲSÇ¡T¢)‘hBHz§Ùä4æ¦yXEð‘¦,]ÄYÅÇû7ø -ˆý—¼}÷>ËûgØxöüJ*îݻǛvÇ/¼õ´ò(O.?ãÑ;o³»º`»ÝQÖ-Wë-Ã8ò“§#˜îKJÚš²t‡ŸË-1Fâh)JMÈ°s]Wì÷¢l.^0l.X>ú:ÎÙÔRã<æO7§éïÓ1 Ùt¬ !•rR¦:}æzëã±Lf¾ˆ¼áç= #íÒé¼þ‹ëûÅ„ôÜvÜLÓ8O·AÚ§(ßônçýKjêR!µ`ˆbîm‘,-1’äSc`*ΰöiæ{¼èôp¯×nû7áfdqíEM‘ÌéµnÛìo ¯j˺-‹Õ=žnÐBBoìÖWÈ¢¦( TÙPÕ-Ñe¯Öa@ÄÀ~ס5ûÃ!m]GÓ´4ËóìEæÌ%±zK”)Ü?ô DV«sBtxŸä#Ǿ1…¡2ADé’÷ÜY.yñâ9¸$°AU Œ¡”é÷ŽÏ+¿^S3ΆåP)‹ 1òøñ—`°ç%DÉÐw&UÄÛªP½ÈYÍQŽÒƒŒÇw0õA Yдn8à"¹ÇX#²‡qšI£0Ó»KõV]IªºÀY›ÌFŒAÆ€iÒ6‹*a•*âÉæœCâ©Ç ÁZÐ[6åÌ&?¾ÿ”±Iaf?à¨$1*”pDBr„ ©+BèÐJ̵*!‡ý–óÕ/%…)ñ.`ªÌ¬œÄëI¨ÑØøœñ;çf‘H¤ë“dß8öersÎásí8ú0×*ûѢ˩Z'E6ï=ÞŽh­p$­÷ËÕŒ©8t;¢Ï,¡hÏ–‰¨T”hÙQ(K@ÑžÝÅTm 6NªéÆqÌò’SÖsxô#hêKdƒ—¼¸02õߧrWÊvšå]úÃòüM¢€¾ßƒM×ÔJÒ{ªÅ‚¶¨²îµÃ4Š~½ÆÇãnIy7mì= ?ù„7îþ]>ýäS7‚«¤Ph¤6gÙozì~ä|ô´1šBEî/*žlŸ0 -²È–ªA dIˆ‚(ZjDšŠª™ƒýW¯U‚³e‰É"G’ÕÜåç“©ÕMpQ0xÇJLøàƒoÒí;´H,ûZ~áÁÞ+ ]˲Zðå§1 žM½8§.¶ìGG¹¸Ç¦Ûr¶\aíÀ3ïq¦à­f>$ÃûÀ®L&?A£5ëÃH[©ünË'Ìvs`yÿ!h…wIZX)}msºÉ:ýY’‰UîOcf‡#â–y,øÚåÎIªkÖ18‹ÐšxÒ÷cDäîã왢›¯­t’«1'™b^ÚhE¾„ºEÒ<’¼ ß|÷égGG´XäõÁj£1¹fG‚.@DDH>Õ…NŠˆz~'zwzÜüÙ«þ~Ûg§èûU›òWÓ=ž^ãUŸ¿í¾Œ1lw–¨4íÙyΈÒ¼^¯©‹âÈ* 1¦¶‚ÕÝ7!°¬‚w ÝIMÛ6Ä<É"yA#KÌm÷0:„ˆ¼qï ç"_\lSû’C7&é?]µ17æº^þ½xDY&8|:Ojcé°nÈ×è¢Ì U© ât.cØl6IVÑt³ >ÉzŠ²Äù£´áé¼JY±Ã3ig{”,¡ˆ9À›ú6Õ,ò!H‹ )ëäV•[ý6»*€Ð剛•NLð¦ªÑªz25¦á1RD`×íp6 Δe‰,’’V.¸\[P'g3¡ £÷,²ËTY–/-l«6)—m¶{Ú¶EÉn·£)K”<2—§ì)ÆÀn×Q(ɾ?d‘…Q%§õ@-wkÍÿðÿ=¿öèo06‚Ã.]ÛZi¯xïþ|úÉ3¼*hËëR«vq üÊ7~‹"þMþ£_Öôºæ'ÿ”üèOø¥oü-–bä0:ÊÕ]ª©­Í§9Ñu{šeK²~|=)5„ÄsH=¹/×aOÇðy›Zø—l,ËBð[ï½`ˆwLž?kŒaˆ=~-ý¾cÙ¶xg†çàÞÙ].w;\ב¼ûö;|ùüKºCÇ×ϱQòͯ‡]o ¤ÀÉÚ>éÜÈþΚ¬à#»ÍŽ®i—+¤ªðÎcL…uáÚš~³»æ&ª9ÍÇ›õég¦ßKY{ÍápÀ{G2Í×)}}S !pè´usí{LF=!¯Q)ö­gRëéõc&ÙÁ£ÔËš]Ówõ'ëâQYìåäpº­È×U„˜´¢3Rc&„ÝÌ`gœ^¼^Šò¶ãu¿óÅÍ5yšøªóLÿ~ÛŸ¿ê˜®ÓžÝ¥=»›`2pÃ!5e•?›„Ç)Ú|† EÉ8ô͢Ɔ™Mþ¼Ó U² ªkÑ ~ö£ó|¹L,q‘X}—ë¤&yžn¶— »=ïíì÷{ú~ĆÂø¼É8çs/eÑѧŒFI¢ˆ­‰BÐwì˜Hcû]7³K# ‹‚ªnSö¥ÆÄøÔ¾D‚—ª*‰þKql=˜j£BˆY¦ÏG¡T6Çàä}„$‹•ŠTÙY¨0£T†EOkÒq†ŸÒ¤ÈÍV§YóÉX:pREªBÓw¡'±Œt’Í4eœê^‚ÂT×Æ¢4ÙÔÂåO‹D|›¢à¾ïéÇ‘·ß¾Ã8ºLN¸0&äBW8Òâá3|+„À”%»}2·6)ƒUe 6à¶k¼OïÀ¹Àv»Ïð½c±¬(Š´!ºü¼ŠœQ"$Z›yn•e™žŠ/ª(ˆÑQè†E›t›ùIP%e³È‹T yÇÞ Ö2ž”el†Ð§5Âè#L©µ¦®ë¹Ür¶J}¯2xT h™¶ý .ûûC‡i{ßwèR§ R‹^pÉ£-ùèÇŸóí·~sh?â]I”z–VÕåhA]$DL)1Ùp*e¨š–ª”ؾ£ ççñÅòÎ7Gô½š|úŒ{g÷I`ÿž©g?0‰è¼j DJ%©Ëo%øô/~Æ£¿–%%OêÍÒ&yÑj)ð1Ò˜HMÁ :d,rP'Ñe‚Ë?î=»ïÿßჷñ§?û¿øÁ|ïÉó4‡œE[ɨa DENæU JM©R—F7Zg+´®è²[Uôg‡”@œ(r2ªo&{§Ä°¹œaŽã÷ôHk’€<ß}°gÑ™„°¢Á‚£É úí›Kr¦¨Sl“oú$ˆ×<Þ³JçÏu°‰’2ïÜ¡2ï_×÷±Óà  Ó<'¯‘HªÂ@8:mº!NüœO£ûÓÈæ/³ñ½î8]ü¦È`ú§ÿýyÎs —üUîã4:;FŠÇA)§I‰‡ŽªY&’CîÛ QgMìçF†”:ÂÁSûÄ0 t}0Kšå9»aÀ =Þzi Ü6g_.‰ÌÛ®C(ó—ZRB¤ÚÈdgWæÍ=Á5©¾= Pxë°Þã8$“÷èé 4¥Ô\\\P.V,WÉ…fªbL$¹ã,Å©8ŠXk¯m6$gw=EnE; ²ªªÂ˜ôJ¥Ðe –¶*¯ÉxÞw7›ãð6ÄeªE $ÆDL¡ØìRnȵA´mKwæHz‚§19-SF§3·,*Dκ ´e•ú|e>Û¼E–‹®gÛÃ0°X,R©Ä{êåŠq°,ª†¦M~Îvè8ô‰»vÛlØqX‘¦DÕü|'˜yF/²ðÂi¯¶”ཥl—Ç 'Ü8òù§?Ký•Õ’ó»çœzÚJ))M"E¹qD OS¶»ž¢®1úºlbÈYuÓ4™t¾£çš0µÀ9ç’‰¼ÖIô#„dz¡4ÑyŒI=»¦©œål¹`G†œµºþ€ŠPß…U³ HH4ºD›*müª¤©¦yrÒw:oŠ¡ óOTôx«¸x¾æËõÏ87 ¥ØÛU´sð¡”Jòž7j©7ÇmŒS¤:¬sŽ²*çgë­»&Óª¥ÂvcbA ó‘‡ ÁßÿÞó^)R#‚Ö†¢Òlö—ˆè ÍÝå9ï½óÛ'­gO>CØm_ðÖÃwyâ×|¾}Á¢2|vñ˜ó{g˜qLmL£å‡Ïîñ[úÔ»ŽDj9×Iƒlw#ÊxDScŒÂ1E1bÝ©ŽŠx)p?>ƒéyŸþýtþ¾ #¿Lè¼)Ó !Ъ0ózxŠ„㱿zRŠsŽÍvMQWy:Ö¯S.Z¶®oÏÇ#q¾ž’ Ûòšt$¾¦ï7=‹Àé¸þ}ûß´vM×›ö©KD¿üáë7øUÇÍMö«Ž›ïMxã«®sscþ«Óç¤L^ÎRé™ý쨲ž7/,n±Î#$Y&ÒúÎÒJÙ÷8‚1(­Y¶ 7ÄIX ! P‘xKþ¿ dHR’^>öI†rkîé‘%nô4EÍãÏ?¡Ûlyûý1Ý?øó¿ ¹·äãO?aõÖ†‹K>{”¸¢ózûoü˸ඡ02ŒFkÆ1•V´2ôCæ:„H¢ˆ˜8uje‹Ç íæ^rÖ=ϧë÷´Î% 7¦º²søq ˆdhRš"­‘RMk|"MJe@$+ÔõÅ%}·§( LµÀdtÉÙâ¬*‡ DõrÉAJ™› E‘ºHtymíy¾OB*§kÔ«ÈЧûßtžºÒ©n7¾øë̘OÏ9A‘7qø鸙Ý`ò 5*9þèºÆºäBr¹½ ¨’,eQl·[Ú¶[Yº®›7Œ) ¸¸¸Hâ¦$Û7¤ÄZ‡õ‘«ížÃv›jPCjùiÛ:Œ# Ûõýn(KŠªM*^!bÃQÙ©(ŠRM™óôýRëÎjÙ²¾Úb"„…’(RTÍ‚"÷yB®ÁĤxfŒ"FGet†2ל¡³Œ4üu1&2)×6ði MYPŒ}z¿YÅh…)"îžÏ$8¥$EvR"õÌúà8k .®ö3™nºŽË¾×û݆¡9úˆy‚I}ÌÓâÁ¥¬3FAtSTéýçLm»ÝæÚ}bÛŽC’z•*SΑ·÷–óós„©PZ£DBC «þ­+¤„¢,æŽSËÜTVPRRE¿·”M‹’Gt¨*K´‘t¶§2ÅÜò$¥äl‘”Þ¦éúâpÈ‹PšwÖZTΦ±7½Ÿ#;ÕrÅf³Kcfj3ÑQÕulIº‰¨ÌŠqB²ï­žQŸi~_n¶¬×=»í<ü¿÷Ýÿ„?L·Jyˆan“|]}ù”¦”¢.åüý‘¦*©Uäê0P‰´©¤æ})øßþŸïów)2­I‚g¿¤hR`æìžG‹;<|ç]ÜèÃÈöcÉ—Wà÷ïÝ£Ž7ÜA)Å•DV¾ÇÓõÿÜwþC1¬û‘®¼Ç‡Hï³½0óûX¯w釣 âcB@”|õ3º¹!O‡÷~žûS'Ã4¦ Þ9Çn³Ieðs€t“çá3ºR–1¤@W•%«²Ä”ÕÜ1­9Ó»­hºÏ4—|>o’ÁM€z9!àzò0íolyz²÷MßóUû–ÈÚò·_üe7ç¿Lö|3s¾ iN?DO~óº·Ö|NÂÍ¿¥ÌðÆ-÷i 6m~Î{šÊpØoQR&ˆ ÁryFU'Øc—/s¾ºÃv{ *zí¬½K‹ŒV g{„HD¥ÛÝ~†Æª*ˆJ§È\ß`2!R;LUUM‹P&Ëz$£$ï1hÖWkTa¸s~/AÓQà‰ˆ ¨5ý0ƒ ®Zˆ!ÕUIô?zÀ¢dKÓ4öv‘UI‘{ŠEVéšÚ¬–“¶8ë¸{VãCb/Îïf/í¤- R¤,A$tlêõ·Œ-!Òw::=’PIšôB¹V$ˆ¾§(ŠÙ¯‘%U¯-ò©–/PÔU‘þž3S¼EHI© Yh.®,ëÍ–ÃnÈžáRJö›5R@@Ð –ðWQV¨²E—2©P˜$²¡ã0Aiº®Á¢M’“uÝ&kgÃjµ¤* œ€T©L±:ƒaØsvÞr^ÂÅÕ%_~þ”á0 Š mê™Ì%TU‰ÒiÑ=ôuU±\–,jA·¹ 6’¢ªÏ‰@m$O×Ï0úM„Jéi“JСÍì÷,Q¨¡RaòµªªBæòÇ´ðk•5°c"pUuÁ~בÂIY6¯ã×׈3AKSWùs&—¯Þ×|íoS•Šÿò÷ÿ[ü®´EI”‚ÎúcëN¶VL\ʈ”ƒÈ¶<ÎÛÏBÔEÁn³FKÁj1dß³Ö2U$C Ö‚½ûS>zòŒófŲ^¢+ÂcT‰³_?;£÷…Óœ¯ÎùÙãÏÐ…æ£çŸâ¶Ÿ¡ Í/>xŸ¼Ñœóû?ùå™àko~‹½3üê·þ]F?âEdÛ;vCjÝ“@oAk| ®ÓZä²u¨$½»~´D!ˆÙŸ8GÈw=ÖAQUÄWØCz—Ú0‰~VÔ¦œÿ=Pɺ–,ü|²ý•'Ìðiøz‰¥Ò ÃU”3ŒO:…æ¶À˜M‰„È!7‹Ô.7NRJ¬sóg¾z¯KÁè¡KäMÝì0½÷W3©¿{–ïüªüu·}¡Ó ú”p:ù^uŽ×eÞ™{™þxú³Ó{’Yl (+Æ¡§¬R†)T‘½y“®” §B‚I=l£óó"8gåJ±Û^q/·®D‰ÛÝ ëŒãˆs–¦^ „H­O>©ïÌY½È¢D™ŠÉ£¹ë: -“ªl¶[¢T,î¼Iße¥Ÿ-ŠRP*EïSVDnš²g€²Rô}z?Zk‹kˆ(f-"J€91wˆÁÓ´ÎÛGæçÌq€Ïõ·Ò‚¯ E‘ìö×uz¤œêÔ×Çìôß©Iˆ¤.5ú€–¹ÆN")Mc-dñ€B«„ŠéF0¥!Ý^$úT·aø»e³½Èš‘•Ù|èYo_P˜¦(Q2¸$=„qDäL)•ü—oió*"-Z Æp4œ_¯×Äe‹jÐùYÞvQã}àg?û”««Kº!P·+‚PH“¸º®Q2qTE‰Rg$»®çjm‰¶G™šŽFã8òâÙBT)¸Ð"µ´´ËLYJU–Éš4YðÖÎÎÎf½€*³¿ofÁ©Þ;R• æ¿f«ùH0§,é4«™²¶ý~Ow´o>âÝ;ÿ+ÿóŸ<ç÷~㟡+"ãÎ!‹ ­§^ì„x„“ûU¡!:ˆàƒNõ®sw”HèÜÙý72¡,ÍqcÌ€9@ÚÀ.žóí{{^\vœ=|D=Ÿ~ú¥4c|ûÍûŒýJ6‡MÑOŸ?¦8k¸z´üð‹/ø¢ß1ìGVo7 ›\Uüî/ýjèðeÉåvHÂ$Òpè{ºÁQ·+gS[iŒ„ø“åªõçSÙj"TJmPº⌌ÔÍ*“0õk×éSóšÓw;CZ'_`¯¿ëé÷}?›v‘צô‹7’°£ìïͤðæ½ÝL8cK7%Ios'uðe[‘ÂóÒžöºó(%™óMˆø«àâ›_âçùÌ뎛$±—Î+²ó›êô³¯º÷›ç}Õùef˜¦’¢¬j¬(LÙpa¿Ýá†$Íwè6È(}O’~´”U:æ"IÛ‰)*Æq̶yID¿nÚù9˜Üã¬e† ‹T$1gË:˜e;û7ôt}Ïù;Q€,1ÆcE›Ä¨õ1põü)å¢Me»$†É‘ ŠRáÜѨb»¹bQ%¸hÊcÐL¹n2ÄHϬ®j¤ ®?o£%J ÖWûL²J½ÖJ@SiÃòDhÍn?2÷ ÆÈ¢ÕlvŽ“Ž…ì&æ¯MR)eò°– #“D(*ÁŠIpDÐ6é©HŠÔÚ$]Ç°K[§ã3Á°%B@ˆb ø‘²¬‰q«ñØ12ö’¢Ô”²(i›$¶ ´Á[Ç¢.غkúDÓl¤wP–%GÝÔ\=¿dÌLè!‹Ø(“jëX,–€@Ê´@J‘d*ÇqÄa*tÝPÕ \”Ô¥AˆÈ¢)ˆ1Á”Ñ;‚í©Œ&JÍf¿C™, ;駋ô¾•Tˆ²dh“Ô”a˜¼( ))Š’Á"ñêªb?t£yÓb9mà|‚§P Òœ2%„ 0šª¬Ø„[‚òù9ÆįhêšI~š×Ž®?Pšß~ç»üãï]ð êÇì×ßÁ"xðî‡l»>Aˆå²™mE!ט‚â†.Á'å-I`Q§2À~ÓÑ4u’;åXâñ1 #ü£ÿïòïÿrÁÿþ…à“O?âÑÃG©~ñoé”âÛïƒÃ`Ú€àÞ壧ŸPZÅÓ8²QÛhî¯îó§Ÿ^ðÁ/þ;ü ï¿;ìùÁãTň—­ !F¹óàa껯K ]fßäãüJ\Ëf·ÏZ育LšBJDœˆ–:×ÆõŒ|ΣéùO¬})Úh"Ç‹) IF<ǵúfvšóÓïÇs‚púÿãïN‰Æ¼¶ÇÓßIHËõt nƒ¢oîÓïÏŸ>ÄK¿sϽ˹ªO IDAT¹÷þ\–‘¯:^}üUŽSìÿ¶s¾ã?ýûWeÏ·Aãñ–?½)" ¼p9jÞ{T¬ùèGßcµhعe*ê:3OË ]T©-Jªz‘˜ª1rÈbîÞYLQ&e$=EgÛ'yÆ#Ri„Dq$Ñ "³p¥2¨+L³D%Ú³=R ”QÔuRKZ5-ã:IðɼH‰˜HOeiÐF$íq¡ñ9{ñÞd’™“y¡:µOƒÀrQæwèçù¸øœ ìmR¦Mt£(UzÆ!&†ó¤¼%½cµ¨ØîÇy!Û¬÷¸ gƒ˜ëÜÓ$šêÍi¢ ” 4*Ç޲¨ Œ–Œƒ…àè] Çv»Å;Ç¡ëRKÒH­fB\YzšºF⨛ñB£tµŽ²n‘ÚðüÉ—D A(Š¢¡ÔGýn£ó»Ó:iŽ+“ú<”cn“2R7)\µÞ¦û´}u>õ1ÏHLz–ÖGYÍÍ”è¶k‡åÝ7E‹©ãºV’àÆä<ôCŸÙî&¹åç(Dr̉aˆ1eãУ C‰€ƒ¸0ùçŠg*•Zddò—¶6‘ˆÆñ@]$ÚpÂƯª‚]¶L³ÅÝ0¢«šrv¥$Ú(¬í(JÃvßQ¨ã8 ! ô$úàhª–Éüæt­˜Z¢Ts®g»¿â·¾ñëì¶_ç+Œe/a"c? ´JúÍA"U^\ƒš!mB`Õ–,÷—’±¼ÃÁ!9pi%qîØl 4¥Úðb·ã»oóÓ¾çùÕ3¢q@c­l(/8¯<{òœ®ïxüì ÕªA6ôÃÀ£w¿Ë?úÉs~ó·ÿ=~ñ—FVØk…Äà¤BÛÝ(Íb•Ð·Ã³³3†a˜×ÜaèéûaÞà´Iû`SE…ˆÇu{&LݲaÝÿŸº7‹µí¸Ïü~5­qgº3/gŠ”D‘"eµÝ–eËíA°¶qàt£‘JFy ý”Ç @?´ dè4ݶ;¶Û²Ý‘-Y–,‰šL‘Ç;òÞsÏ°Ç5VUj­½÷9<—¤dw‚@éœ{ö°V­ªúOßÿûºìß «eS“¦ñªÝÌ9Çp8dr|®EJ”6¡<Ôm˜>ÚÞÌŠôgxÛ6Ýï=â{Í~2ãF8¯º_VÙN˜hz¾³²u›ëê¤]R'þ¶ÊØÝk³Î$s6 ìÝÆéúï_×8÷´ê>Uo>ýÚïv¼Stß{ZýÄmzïýëV-V褒Š8J; —fV4ÔE‰R‚XÇHã)Š ­"” (裣#.]¾ºŽ–¡µæCêr‰Ô1­W·@‹óe@·ÁÓk;`óÓÁúíÆcŒÁ M$B*êªÅY‰‰R¡Æ›$ ZXÒ4£*æ]j^£7"#OQ”¤þêbAG+pÔé¹ÄtVÿôèË“eÒM”µ-;y ïfgÎ2ÎïÅ6­Î°wxmp 6Z©ÞËß/$?+MüÝÑ>êÙ¼žÍü^oüÝ^wú:Ã?žüÛY?÷i°àÀ…T·Jr\½ (–àB¬R(­¢µ-‹é-¡(Š°¡ã˜(ŽQµb:="ÏÔM/X°Ö&6&"ŠY{Ï›G ‹y¨O›8EÂáì=‰6 Aœ÷Mý ×ÕÛÚ¶a8¢¼c9Ÿ“oíáÚš(Ïñ~ÓçÂ=žÍ0ÉFš¨ªER³"óè}ÌþôóÛoV)8O–e´mCdt }ll'f ‡%©ª†ÆÖ,–3d”RÕK°DŠ¾ž´q!DçM¯7ÞéÍØ·9×ÒÚ6€ç¤@M1 T€Î d4$Êr’LMQY"åp>ôê&I‚ÒgýÞb>åx2'Œ‰$YîIkÔÆZr ·J¯ ‡Cf³BÀ IÐ:ÚUUÅ8Ç ‹Ibð’ÉQ0ÜuÛÆÚÄAjÓ{yèÿpdy‚‚·n]£ª.>ò(­uˆ¶ $$^#%”Åç ˃.´îf)XÇr¾$͆X/PqBk4Ö“*R=8ÌGAI¬w”òxHYÍiª¢#@ôx'1Q y5F¯3Ýü8Ò“I¤ƒÑð–rØóZëžZé}pf½GH³–ñppõÍÆú;kôuñ~}H±¨K”¤Ûc´I(Ëçª[_=g»”AƒZZÀ”ÂujGZk†q(y\)^¾~Ͻù»|ãÖÿþ~‘ÔI¦Ó Ç”•£)ŒvÆ,|á‹¿Â]0DÒ RÞGHSv>'‘ŠÇ¯<‚h<û‡GEÉõ;×ÉÎí²(<4³½·ÇþrÉúì¿Ç×¾sm¶xéîœ$R0/j¼4äyÖ‰@HD—AÐ*èuO§sÊ¢ê²R!Ê„TÛZŠªE™/€à$~d3Ð:}œv”6Ï÷$2èn=‡¹VL'Gئeˆãˆªn‚2´Wµ5ŽŽ Ž1F…ŒcÛ⬥* ’AÇÐ}¿µ=÷~P¬ÛtHÛ¶éÎ,y⚥:Ûoªï5å}Vÿ÷æ¼õÁŒöþ¯ùž¾ ¿ÉÏ{¯†ù»ù¼ÍI“R®hëNßýŒu/ž@/à…"„¨#p4àJk-MY"¤&MãÀÁw‹¡®Kã€BT½0„\¿æóùŠç»×Î-«¢ ­[_w‘Ý=…Ãb•RÆ“ÆÙõèÚ¦& ‰tŒ”n®w$Ò,H–yïQRGi6”ÑPÒõ3ƒk×µmô÷žö ­µÄ©@ µ­®Å•ßƒêš¦Áµ!Ëзˆù6 8ûHóDÝg#Bßô‚Wé5¥w­sè… < 8žc›.U.y2ÀM+ÑQgxz‘µ‹Y^JˆÓÎU‡¡nù`teEhÑê×Gßò!¥d«“,Ë–|0À9KÖ*ÒÀÃ8 Žo:zP‹šº,q]Á|•R« “‰4`‰c á-“£)uQ±wù¡à E–hðáp›Ïç(ˆn´1'ž—s!C´wîHÉäèA2 š×(ç2?±g¼÷«Ô¯÷{½¼;ÜB‡”ÝE˜«=Ö¡Ÿ±‚,Óô$ Bxªå)5µSÎSž Œ$ݾx·rÖYã„„¡µ•ã} :^÷µœj!‚6°0H4{Bpx¶­µ×ø“/þÐlq{1àï<ós”ÄÈñˆ¿øêg¸tá&;w‡\ü0_yíë<õèÃà•õîSZÇ®> UÍÝý ·˜Õsâ(áÅý}Ì0£Y,qfJaþ/]?Äsëöâ8 êee‹P ÅL¦ËV–ŠeÑ 9‡wºÇÞ@§ Y¾PB[Ï¿VÑÛÎfßÖpܯ½aêŸÕšäcÝ!"áðól6 g€÷Ú1gó©¼ =9L”Ä+u+Ú–r> »¶^]7¯¯?76³V›k(ìÙ·ÛŠwrÖØ´gÙÀ÷jÃ6_÷]EΛãtT{–Aëoþtšø½Ž÷úúw‹Ößi¢ÎªÜ/Uqº¦!Dºˆ† B(b¨?Cz<°Ä„5ãñÈ@±)×ÞdœB%<¤8¡‚¬PHÕœX7ˋ΃×qwHdñ‰ë ‘ˆXlxÆ1Ê2ä ÁKM²B,†ÔP–¥µ~¦Î9´Qˆ¶E‰„È(Ó »{»Hð“R*ê:DÁs(<·(©°Î3J έ7d]ÕA|¢K/Kê”mÛb‹@gÙXKë·”'Î3⑆ÀCÒ=Ù§ü­bœ·¸é²|÷)?Ú*t)Äɉµ±ùóé3¶7zEQàz{âC¹Há}•:Er+œ+¢£²u8©ééJv}¶ ñv´¶‡P2´­MXúõ¹XäTwÚþÝÏ®œe—Ίªûõfmpn¾§šó&kÎ;ÝûÍÿ¦Ç_'²ö>зmnÞ~œNÁœöŒVÀ,±N븮Ÿw-¸úx«Ö2Îó5Y×4Ak×(<’l8†.št؆÷¾k¹'6Ã;ÍiF#œoש_Nn!yj:#åO|öæ‚Ah-ƒA„k,èµ|=Â[¢H‰êÓFДöÄFÐZÓ8K¬ óù"ˆXKÛZŽg³PÏ–Š4¬ 즷½¹!N;d=Z{óÙ5MCmj(áµë m-ÃáxOâgÆ`콇Ü}dò^ÆéÀ¦·rúsϺÁÍ×þM¦¶7ë’®ë{ØLåœumgý¼ùÀm°N!¶œ¿¢°8ï¾Eœ%ì(Ï•åàæ]¾YzÎí^$Hª¹ä¥WZ~üÙ+|ûà5DÕò蕇(ê‚áyîNïa¤c6Ù§.Köïï\âÊÕ÷QÕ¯±›¸¢¼.Žš’ºªØJÇ\?~?ÿþ#ñÅo¿ŽYP;¬ ªuùhÌôxJžçëÎÑáSÊE«`ª?#ûý„v½H¬„ŸÌ,Jo±@ŽâÄÙدÍRgÿ^ïýŠH¤/‹¬åDÃu4Mƒ’º©>p]/ÊïìŠÜé¬TñIgíì@ëÆ¿‹àÐ$ŸüÔÇWþðWi늟üÔÃç_òý?û6æþ]ÒÚ›î~Ÿ»9Þé³ß-wÿÝŽÓÞO_Û`ã³W‘ì)#s?0@îkÊ ¥ÂÁkº/Ž×\Åë›’] ´WC :º8/‘B`´Æt‡R¿!ú¹h»™&ñ*’ì*'gF1Þ6diPƒ=Æûî–ï3§Þƒ ’Þ5X«âwcƒ !Èc€+%Ö*´¿8Іªq$(꺥¬j´I@Æ,:oÔ÷÷&|@û–,pÖt3žºj‘jïiÚf%߸Jeû®É¿ûL%å ²5@‡ìzŸ]wË !©’Œ3Ø­¼åÎÔyK’hÆ㌃£9 ðôš4NXtÞºè l%ݔھ82´2°†¹Îyˆ€|U\Ç=-IÔ¡3"MsLw$Ž¶µÔÇ%MÀ‡Ãíâ¦Aak‰MżhA:´‰(ë†A–"dxرiÈÇ8«É¶b¢FÐzˆ•åF xùà.{WÎñÏÿäÓÌŽ_âýìÁ(͆TË9i>D(AQVdy‚m‚@|ïLö«Úû®EQ²jq;{ïô{*¬!ÔŠìE)×q¯QNàSB¬¾ÇãHÓi[Š:·àCë£-yš5-&Ìkw!s”ÇŠ¿øö¿æ·r~ñãŸD%Š4ó'±gÙXƉbRIÔHóÂW~…ç.DÔ „æÍ·Þ Î´c¥\p~ç2çd—®Ýd¿.ùþ÷ÿ(7o”l]òüäþ=Žÿ‰ÐmxóÚ5ž|ä1œ«ˆ£åêù ’’a"Ø¿{lg›EUq°˜!tŠ¬<]~œÏgO}âi¾uû6N%ÄI†Tëjš& ­§Ó"ðîw ÔþL›-–9Fjzet»ö¬sÖRÖ¶„ÓE¡]Í8)IŒÈ–I|tçûý/DiÛß6¸¶Á¹¢±©$Ëåm4UÓâ»:¯: èÆë\þõYÀûK÷å’¼œºÿn-÷Y˜wý{êb¾òWQ|·÷¥6hñWŸý=n¿ú"Oü§¹ýÚ‹üÙ¯ÿ3úÀGè3} î]#çïÅÛx·ÏÚ¬½SDºidþ¦œƒÓßݧ"¥Þ›¥£^ãýìæçõ‹p•ZAlÈ˽í}ÿK–eh±N³¬T›ØôÛ[£’omgdß^&èëKž¯õŠYa»Ï^¨½³â»ß1ht£8>1/Î9LZ¶’HSÔ#%BKŠ²¦µïÍ_”$A­«x8yh‡MàÈÓ8D=ªg²¤IÄl¾ )2­Bz_ˆ•ª—í¼ì¾{3Ûà;¥)‰)T–ØH´‘ÏB3H$ËÅ’›Ë–,‰ zÆ6GŸŸö®%M#æóùšHð´©ùÎyŒ«¾`Û´e…”¡èd#ŒÖXïQ dÜ8Ø@¾a"Z«¸swŠN‡¤Y†(CËO鹎xdnÔ nÜ9 ]"KÖmGˆ^+7 Ò…ì%1ÞÂœ9I’!+ÇåiE×^þc^½·`àoóÜûà¾ñ>ùäóĪÚ2ÚNi›†…µh%Éã”Éd®Åw@£@géÃ!+2Zƒ×N^ %ì“€Õˆã¸CâVÄqÔEN%hÕu;²¥Uàz—‚4NÐFT;ö3kK)¤P$‘çs/}†{úo¡DÅï|õ³|ÿ#sÞ¨ ¼¿ËœÏøÏßáGßÿãìŒvC»£’K‹ñ-ã=ÉŸ}ù×øÈ• ”4LX¸'MÅ%sל {[[ìß+ñu…cî½ñéÞ6óeà O.¦¬ƒÝŒ­½ƒ4çƯ’Fš81,—K–e‹1QpjÃlvÌÖ•GXÞöd*exõ2­üßùi^zó³YƒWQ0ZášNh͉NÚ®œ(ï=Ö¹pܧ–z"0ºÏóÛ̈ö".›=ükÝRä “ã9G]W(­®g>âËé¤Stó­im‹kܪs¥Hè3mBž8'×vãíQóf°ÕÛëu°è‚çÞZÚ:°9®:E”\ÑŸžÿ"ž¸ŽgQ÷oü¡Ÿæû)¤”\|ô«zùIäúFäÜ©ýðÇØ¿þ*åbÊùŸ`19àùŸü…ûn°ïu¼“Ñûk„‰‘äIJ1›aE PïSi›å;>]¹Šn7Ò2ïvBù€5u\§SÚÞ{²,¥©ÊwäxÝLÛG‘ì>÷ÝçyÕ*Ð/\ÀtÌë>áu&¥ÿ[¿˜ªÆÑÊ ¢#•A¹6x¶Jb½Gø“÷t²l ‰c¹áõ®Óf½–tO[Úózo¦ÌV)âSsÞÏEžö*E„=ë5Þ†¶7+b´2V–y)Ðʲ˜/XΗ´ÞS·#{pžÆ »Òìîïa4l^J:\°R„Al(ËÃÁðÛ´DQ†Ç.q¿ÃŒ3EÓˆP+61Q¸Ü#-ˆÇ#–EÍvâ°ÂòËŸû}R繜ð#—vùgo¼Iü˜á#õ—øÒµ]»ø÷ P‚·ŽöÙ;ÿ!Úh¢e8ˆ)ȲI@_® ª×T´ï4úÌTpæ‚¡ÞÞ ¬UÒƒ÷1Ö­ŸVl„·¤‘"•GóŠ­±¾•héÅð/þͯñ3O7|þË¿ÄÞÖ9o¹ýÖ—”æá”^|?³/|×j®Ý¼¶‡¿ýÜ?d/3ü¿ý[üðûg<±3¤öSŠEƒ01-yêÂ9b­iÚšåqÁSO8æáí«èFððù1/[¨@™u{™³/ÖÀÊ„ÙwFÄIÆfÆ­ݦÑ}§À¤'Z‰ólìëþ}kàg‹°ïZZÛä8ÛôNCÏÑ4 µo0±Xa` 6Ü,=ž&> ÷îºÚ³§.'î¡/UH‡¶iV½ÏRé³XšW Áþ¾Î›çÐ{§¿M[ÓŒºE]|ä|ã3¿K”æ(m˜Ü EjmÐQ|æœNŸÞoœ®a¾1ÀéñïÊx÷Ñ¥s–éôˆÅl‚šÁö6ÖÙÐü$UˆàÖˆž•¡èùcÕF´¶yX÷'xL±1+N/YS!®›;mF„”x'ñþdƒ?€u)‘*Cý^ƒ$ÖQzïu:ïQJ¯ÑýB³Ö® „g¦úö gG·^—ü¬³AUIè¾ã©Ck˜“A3ø¬™XÞÓÔ@Ž·k¯ i*¼4H·&iYÕ¬7R䧽b­%©†L9ªÆaŒ¤¬Z@á\ðÖ“DQ,§4uHÑ7–ápÈrvLÝXtœÒ×¼«&¦ ²„YQcmÃhá¬C«Ûnè„…Fšf“)m³þ›s!ð\ÍÑdAª5Þ[Ž¬d;‹ØŸÕ)I²„¼¿o)«˜XXÒD‘³ *_&»üCÌgsFú$`3âÒ•ÕÑŒ½ó²,J")ˆ¢œÅñãδ¡–Ä’Dyf‹c"šºâðpN–"D‘B…1ÎÑ"ˆÓ!ÖÙNÉùÆF+\YGدûàûýº•mó³ê¾›g m Š¢ ½Ë” íNˆÐáз-.º Š“Å” [Ì©«š(éôØ›AkcW˜8šº œOHã0ëŒ{ÿ_±˜§YPÖòŽùlJeè(àv” e7!%ê”áìmÇæ83ÓpÊ©Ù´ý™¦T¯®Ž®³¦ƒ9êþL’ñSÿù?æK¿ÿËضæ“ÿÙËçûåc?ÿ©õä¶-mS† ãº:m‰è(F›·{ÈßMÍø´Gô^£Öû³Þ{V]%Ž²á$φ'Zrú׆Ù $Q7íªÞÒ†¡Õ{¿–â{—Ì@øîx­Ç:Òƒp¨æIHI®¸kýÛ%Øú’%ru°õ5 ^ânõùR°‡öçU"Ã>쵞ájsX pžhºl}±èªÞÞ­ÛPúìÃ(‘TeMÙ¼3›\Y–4ËŠ¶mɳበšrÄŠ2›­V}ÏörYts¢ÐÎsy,ØŸ:„³OAÅ!ÅÔçàh2ÁIÒAˆ~… à½(ZDUÕbŒ ¥BI–%ôýÒý½¼¬ÀµÄZ²èî7ÏÂ+ðÕÊ¡SQŒpŽ²iŽ2šÆ#¤çÜNÂÑQ4AÆÓ{Ï0’HáÆE‚ÉrÀÏ\Þå—¾ð?ñãOÿ½·­{çyª‰(Sñµ»ÇÊ~þ‹¸±@ ÉH¬0ìînñÍ—¿OkîÕ‚ KDzªØ‰S\ë™/FØö.Æ)öòœ²Xpo9á™çŸcÿæ îí¿…E1>wã£c¼ÕT®Edš©]ríÞ]nxìÂc¼xÓÝ‚·Zö%žˆ$ £@™Ú DXk1Q„I3´Tè£QcxïquK[•˜$EŠ·ŸákÑŠ“B›k¿ÿ}>ŸS/Cûš {×DÎyª5ÚÚ–ºj©ŠEˆ¤Mà(oÊe r¦˜.P,‹EP2ë{óûÖ7È‚òp†ô8è³p¸”!³Ð/Ò‘Ól¤Á7Ság–›çko¿ÎêTÚl×í r_ ÝõJ 6ÒÚßúó?à­×¾ÅÓÿin|çüé¯ýWŸzþÄ(­Qzð¶‹h›šr9F˜/è@ â]Ç,7Ж!Ž’ü¾Fí~ÌY·ÿýtô´7Šð‡Â65õÑÛcbvvv‚È·6,KÅÑ[×H¶Î¡$$IÀH΃ `¡²,×tš§¯Ÿ¶M¸ŽAdïýªÛ_—’¥ëè7Ùõ„9v‘Æë³O_‡{=¹q<0Œd8»…–űõžR)‹º‹ª×µ¿U?·³äqo 2r=JCÛ´kAbøŽr6[œ…#Ø|6A@"|Ø´(V ¯ªª0Q¼Æd1{”&áß¹¢ª Ï \4AçÚ Š²æαÇÖwŽJZF ŠÖR.TUEš¥˜(´ƒyWSW>N°b˜¥xץ뚚Ö)ÒX“™ÍH!ü¿uŽ4Ö ÂY@A8dœ«iœc IÙ4DqÆ@H&ˬEi#ôœ+Ý u8O+L ÚA$Á ÇŽ–ü“Ïü1C•ñÜÃKb=â9õF牓6ОVd`ÒÒ8òÈ3NcÎ?xŽÿë‹K>qái6d'ð¾ËçrªEÅÍëû pD¶æõý?¥Ñç™Ïã¥ço¾Å«ËOóé/iþëŸÿûÜT´­ ­FZ¨•°&!sIXSÂRWSƒ‹F׌iCQ”Ýó® 2ˆ«8ç‘Þ’Æ %d*Þ3NUÀXI¥+V'ç[vóÀ¬†+á¾ñ¿ñð(!:ÚçCçÆ|áÞm>º{‰^¼ÂK·®±猲OÍc>J{ï&v/òÖ{<”™-ï±,k®îžãüî˜eSóÔÕÇ™M<ûÁbbÇV:âåë¯'†íd‡81ø¹áùG~‘ƒƒ’áh‹££cÆã?üôǹ~ë7yàÂET3ãÉÇŸbq8artÄt:çÂÕ'¹ùÚËd» èž~âqêzÉá¬d: ¥çù½ó|ýú·ñêCøf :¦(kb#X.˜h€Dàm‹í˜êd·>g•EÊ–4’«Œ¡ž²)©Ê‚8ËCæJGxëiš% ës»;ˆVλPÆpR`$´Mhkªëm mÓe„ˆðÒ#µ!êº)¤””eI[U!JWž|kŒutÀtD£ÚËOã ³Àuâ@½q†(Žiêâm©p¤R­Ý™6&Jq®E¸EìíOHÙŸ´/ïlnàÓã¬@bmÓXœÎFv;çHÒNûؾ]x»¦µZ¾Ÿ!:0Ú$²;[îóDExRu2ÝÒÙТPt‘t_C·€²5Ûãзþë…ÖÐöÚ®§uœ» VÖbN4þŸ5Béiê`äÃìD=?ŠóyM–wý˜^çß:Úª¤ Ûãá‰y©ZÉ­[‡èl@’d+zY"d˹ »”eµ—dqNíƒü] G ×g"…V ¥Ã¼÷·aÄÊ3Î4më±"”9¢N}©iâ¸Ó,¶5çG#%ÓeK¹¨‰³¬SþkAK‹Z/Hâ –G¢Pñõý.«/’+Ï×kšñ6?þìs|mñžÚy©=‘³=Q¨¶a˜Åa ˆĻ¿ù"œÛ¥™.0™a'h —¸ÈÝ—îòÆÁ-.o_ä‘ÝŠéô÷ùê+×:”SŒTÎãçæ(_q~3ÈàxQáZ‹É)Õ“jöF)UM1§© ”ŽI…ñžÏ8,DA(¼Ô(Ó9½B mË •Ð6  ®lÖ‡o?¤ÔÜ.øôW¿Ê“[˜Ü1ZŠùØÊIõ6U‚§®<Ìë·nñ±'žá«¯¼DU–lï\äů°—D!yúñ'ɳã9wØçÑïòÍ›/óæÛLxí•—9:œàUÆ=æŽmyåõ7(dà {—D eQb=ÌŽQÑé«©º g‰w )–%ÇÅŒ¦®ˆ“¼ô…Û¶«})Iקϡ~WU…IÚª"cÑawLìiÚª+A±Ò±îÏú®ñ}¶N)”ÎPÞÜÓ›,Ë÷¹³8¶í@[4ØÔëë<}Ö„’ +0­RAÐÆô`Ì3²ÿ¹?ãß­Ty¿±™þïç.ü·ÖfïϸUvâtôbNñì~/±ùóYÑìý>_JIÚI—õïy/ײyÛEõ¶©iªåÊ°÷ÃY»F(zO¹˜†(BÅa’ªrAY7ØbÊôà^H’Á˜ª*P*Âù€0ñZºìt:þtÚCzp¬Ú6ç&M"”:9W'ÛBà|K¤;‚T'Ò%ÀªII¹0(R¨5ŽÑ@b[ÉlcÝ( Wö†ìß;`çâ9\íÁµ‹"èHw–´mk–‹q2`2]ÒÈÌå²Ë4DQDÛ´h¥V‘xÿ 3¡¡/ߊà„%=Ùˆƒˆ k4•ŽØhÊ2 ³ëºAˆÐ_;Ja"i2"RtDnB`;(™±(k¬äy§OI†8„¸".üÞ×_!/$ ÞÛ¡±mÕrsºÏþíßà¹'þ1©m¨¶#¢Ž]Kg"<‡¦å‹oü6×FwD‹ÈÛËcžÎŸd1]ðí7ÞävUa3ÃŽj(—5îî=®{O[7ŒÎŸc9™P"EãðI¤µ%‰Âü[ö—µ ”çâ¹1e ^F)\Iš; .æšEÝÒ41¥-Ã\¤ŽD§Pj´128/ÐJ“;,ÀÔpýÆM~÷Ëÿ'Ÿ|ß6{î Ž*>8zˆ«–»ð$P³,æhÛÉ+àB6`4 #ÅÕ­‹Œ¶GL§SÎßáàhÆ«o¾Jǘ(£©ò8çÒ…s8íÙoqóæ=¶Æ[Ìö9œ0ò'oJ>òþÇ™·Žlc¸ ¯8hj>xEñê+ßáé÷½ÉÁœoß~…(M‘‘b(|ö«_Â7ž Ÿgz°@(Í¥mä ¾tí6O<ñ$¶óÇÞGq4§¬–Å’ÉtŽÐ9Ùp{`¤8:ØGæc¶·G‹9)È·’•#~:³xúŒ=ël?ÁüÕÉÛ*H™ÄFà$Ú€°o%SщÏë?ÃÚ†4ËÐqÛ­ªŠÖ†š¸ÐÁÚFIá‰$8dgÄ-2Ñ4H„»!>´¡¦É`uOùÍF*úäY½ >=›c32Þüûé9ëÂk¬RŸe};Åõ*r>+Oþ×›ý°÷+¦Ÿ§oæ»›F.€"Ä}Àlýëú÷Äéàmÿž†Œ8©PÂwt‡‚º,ÞR-ƒ¢P]–AEȇ:¯Ò†¶®P&ê” }‡mBPÏgäyŽT’¦®B­¾‹ö [¡Á¶ I6<ÑææÐ1Lð–>œëk²JH„ rv¡~ÜõÖ Á Bë„ ÙÕ”ðŒ3‰G£Ü;(˜-eËöî(¨@êýZ¤<Ô³Cm×ûªBÇH…– ))« ôcQxڎߦk!‡Íg¹I ¸¹¤ô,f $Ž¦jQT'¬Ð“”èÈmf¡À‰ §™IcC,=³ùTH½ ‡iG™zRMgs=Àšœ!ôcöpù h:;X¾šºáÜå]œƒÃI4¿›’ČȄõØÎ J5$6bQY†)äÆ…Þk)(,̹ö­_¦,'ì\ÞãÖÁ!²ñ¼|ã6æC¿ô Æiæö^xõ—¹µŸó‹ÿyjiÑÀdÑòé¯ý&OîÔ´‹)·«kœmùÈÅ«<¸½Çíƒ}÷©™óÔ…sDQÌC/0¯ îjÅ•zÎ[G ê ©=W3þÕ—~•Ÿxæï²CŽ3ž‘8‚^Û=N%B6`{Ë 54-ÔÚóŸÿ*U9c”|‡Å2â?úñÿ˜Ì6ù”?üË/ó3?ð,ºmq©Æù€Þã}„’_ûâ¿æÉ« ûÓÛè6Áªšï»â˜î÷ÍøÖ«¯0¢b8:Ï0‰Yê Ázþü9”Ö*ÚjF$v‰DD»¬‰EÌ?Îþ½CÇslåBS/k&‹9`(Ú·ß¼GªSîÝóêám~øéÄÃéh‡édJšXΧøJe)ßzõ“fܺ{‹'x‚ÑÞˆáö˜/¿ðžÿð3Xe¹Vó¾Ê4ó»OíŒø§®ò£Û !Ž1mÍQáŽwh¼aº¬ž?±‡æÓcv³óÉûw1É`%zr¿ ©ûþè~Ewc Š(ŠVµ]ïÜ C/„À+Ië-RÒž^ܧQ…ÌU×é}ë™Ífx©»v«Ð=RUFD”Å"ˆrtŽ½Ö:Ô‘[iOŸ÷=ª|õ-d í |bEj²™­;ë<Ø}†³?‹W}ù§Ææ¿ožqgÍýj¶O×o7Å÷ÁÞïÁ¾Óß¿›Ïz·×Ÿ>ÀÏšÀ³Þ×6åislRX !‚ü „$Ïs’hÝ7ì±è(A }b‘Çi~úë2ôÀ9öHi\Ûb¢˜¦®¨|CÛÔ˜(¢, ™rŒRƒ—Šãã)‡GÇ$[ç@1› £”H5X JRlk±ÍÚóƒþ~£AÌ¢ (kD Û¨‡÷¥Í‰ Àê… ^Ñô9ïQBàl…õÝæimh_jòÄ µ iBG vsh´Rx×R7q§ EQŠÎîÙ:"b#±Ö1) ª¢&Ĉ¿¹™Ï*¬Ö„­Ë¥ÃkHb o#Êe1Ò$c/¼öæ=²]ŽŒ†CZß22¡ÀÑÑ"ØJȆ{Ë)L‡¸\Ypç­ßá|f¨ ¯Þ¼…šr)â©‹Žk·n¢•¥¶ü@²Íå½ Ü{ó:—|ö<%—ÈÒ!‡GǸL£ÙŽùæ ·Z‡‰>²3æk“©=ä›oü¼p3å¿üäßGi•C ‡FRã¢%2eC$e_{ë·¸\¿ÁQUðüö%&íŒ?þì?áèè-vÏ]`rçñ—_£®&˜hˆˆ<~Ùà"Êc­"Uo‘¹7òlbiuÌs—Ÿä¾ðŽ« —û³iÁÑá1—†;x ”im)ÊŠ»wï0æ\»~$Ž˜/çx'˜½E[Í©|Ê¢r<öðã 㜭­mÞxå—.lQN [’ûw'He©–%wUÁöû>Ea#Æ»Ò|‹eÕd9Ææ˺©ÑÉqñŸͦüåK_¡n;wRðÚk¯E)ó©çµ»·©æǼy|Qžpoÿ ÚaÊáaÉ'â?@4s ‘°,+¼ ¥Ç8©ÀµØ¶F+Åb¹dç,K–$’¤Ãûží}4Üzµ5Îö*^Ž²kw2QÒ•kâ.À*câ“ò.œ“Âyf³µ LouY •¢,*”2жÔUЮšš¦©ŒG+`ëb>ÁVKoM‘B w‚Ó¯¢@JG˼ɳo››Jj„mVôÀ½"ŸNrÚº .ç¨|´áÔ¼ÝQ?k¾úàöt¶óô9ò¶N“¿þÜû’l¨ÍøÿÃx¯épÛT«Æñ³>6ùWÏö0O§±ï7VL:Þbu`¼GAFpŇݷPµ-»{[4uƒÖ;áuI`=r‘AE”@¢=ÃñΙug€xU3Ê -†¸C6ÖÂsxp„õ‚‹?ÉñlÊx¸ú”¥#‰òñþí›LÙÞÝ£mudœ&¸fÁáéh‹Ùñ%&N¨«bÞ°dcǦ©«.«Ðv)lA]U#1J¦Y§ôT`‰·žºL©¦2rvé‘Þ3÷žÅ|Fg,,Yµ³Ìf3"}2s¢¢ïZ¬m¾AIæ“£õ 6ŸãæsöõLÙÕ´&´•¤˜¶d‰á­éø ô®*C½œ`§-—¶‡ó#|SS,¦4^`jJ<ùh€¶iø_þø×ùŸÿ1TbÀ-™.Õê{?÷Ê¿bÀœƒRШœ,£•5E9ãû²þìÎ-ô8å‘aÌÌxôá>Ï>ðQ^|óÓ\P×oñÆuƒ7 ðEÍ”`^/(¸vû˜Ò]CáÙ}ìQ^øú7¸tùLJF£•Â½‹ãª0üÁ+×ø‰§ÞÇþcî}ëÛ\ÜÉùÌÿ9/\òŸüÔÏW-•$qBÛVÒóõkG¸Ã?";¶Ó]^›\Ñ ;»ÈÜŒL5|Ñîðà0áA.òå[¯ò±Ç®àmÅK‡Çh£yXgä"e1p›R£I²”YÙÐÔ-RÕ¤™!õªfí½g0Úb8Ú `=ò.$°.¤hµÒäãmDÇØc’”u×'Œ]G¤±ÁèïÐO׫èP“=<–äyÚ-àpýQú­óHáh[G6Ü:Ñ‘C©ÅÎcµmËÿÃÜ{üض¦ç}¿/¬¼Sí 'ßÜáöíÄf“6,Ñ X`HØ‚<ñH<6 Mýxâ`À†aC2̉¦Ešh5»)²»oßtbÅ];®ô¾µöÞUçÜ{›‚ÙͨS§ªö^{Å7>ïó8ïhË`<&Šz)çY$»ùvP;dö>ÌŽ7u$-a4±©<‘ÖŒ†õzŒ¡s8“GüÎ?›9ÿÞ·~‹çÚ%Al!’–b(èí£Œ4uµ$ bþøýùö[oa„gY–#¢hÊQ^à”àùÕS\Å·ïŸÐ¶-ßúê¯ð‡þ=IJäÉõGùW|5I(LÍ“áá½;$_ºóåê‡ü°Ù3(X­_ÐÒp'1>³Zn¸;™òøé3~齯³º\ ´æ É™_¼ Ïu=§\¿ Vš'½Ïøà„x˜SU ƒÁº.;¦(Ïñ×1Íóù5ÓãG¬ZƒHG,Vs®O×<|çÌeÃÃ÷ùx5çw?þ #•ñ[_þM~tF¢8£nËN³Ú$ UUçšzEl[Þ{ýïp9{Ì'툪åZræ8ãtVñ|yÎóÕ9û·F9 ×R;æ†?g]ÕÄIÒ1ëåe<Ö´$qBœÚܦ5X[m-]O¸sé©QôNBä IDATÛ¶E+ÊÔRé ‹î½ÛŽµ­AEQGäÑOùηa[ý©ë!$Öª¦êúÓg IšQU5eU€ùr‰V2H’*Ý7*ÊÍŠÕbÆÁôtBÛ!¹Û:èµÓ—ˆ÷lvo­ 7) ‰ãÀd&%‘ÊUmÛ⬠X¥ОÛ>c¿2û²_ù¼Öígµ >í=ê¯þê?xû—~k{"o;æÛsl·?ðgùŸÇê³åý¯ÛûöªeMƒŽ^îKßÎ@…àÙ*rmy·;ýæž#x÷ù¾ë7wÐ}A@YK…’jKw'¼ïDãw,>Q¤È³U÷%p=JI’8fED:ì×m€UïCûûk€"F®sX•’Äqø|!ÈŠA ©ŒwÇꜣ*×$r”ðatÊ{¨«ÕQYºŽLEx&Ÿ½Û‚ …#Ï#bFcöÉDÃß±´uËõ<ÈHÆqÔÅ>7y½¥„8’lÊš4M·ÇE¡¼©@ýÇÉ®F(»©(…DZ%ºû¿êö-Œ·i%H“HŠ#MšÆ,–«íÈ`˜sYG¢¢­b”løë_x‹Í³ÿ™G¿D:Ò±d½iq^!EM¦Ò‡Q§_þâ7ˆ:Íç;“ VxR+¸Ø,Yl~BèJð€q†Ùü’YU³Ú®×'C?{A’À›†eSòØUœ³,¼'"–n×Ç)ÓXs7*øÑzÃëŠ"çþôõªaZ È‹Œ4ÏD)y’òƒ~ÂñC ©P‘Fz‡Š7î½A¹¸&˧œ]]ðÅGÈÌ’ûjNZþ€‹ú§|ãµ!ÎZNÏ_pgœq?Ul6+¾ñÅwñóšïýøG¼úƒñ€…—x!YÕ–{y̽ƒ)÷ŽÙÔ F{„u|áÞ”ŠøðÙcò8§ˆRÆç˜=çþ½û¬KTS^}Bí~qÉã> Ò”Ï_¼`2=¡1–ª „óù­£æK2%QјզÁË–,KL™/´uËáÁå¦ä M˜¤ ÿäƒC2}—Ö8F£1eÕj;±“ЛmðHë-‹³k^;y—û[¿IΈo¿ñ.Ë«|rVrµ¬8¹—h³âë¯Ý'MJâHQ¶šW\ÎX/iœ£¬jœ‡ÑxBšvsÁ"d¼Ö¶KPÊp4M…iƒ ^˜´¦`¨Z¯–!©UÕ`˜¦EëÐó5Æж†ªjb³ëU·M»µ9¦jéñ@Ö:&“) ÐQD'$q‚NR¤Ödù ³‰Á9Ã@ˆå-åfƒÖš(IIÒtÛëîí\há%[°•"jEA†4ØÑÌ{‚()·¿=ŠÚKövúv¶»ïw~ýY ðO¿û;ç¼o¼ûyUª½¿Ñ¿JÎ>»ÏüiûeÛW;çýmn;Çߟ'ošÀ¥¬ã›'YìÎcÿu‘¦äf°£µºÑ*ôdú›§w<Î{Š<"!ZT{¥p!D ;íç}Gÿ`ôlfÞC[×!ðXëB4‰Îî"Á¶mQRnoxÓ9tA@1(R’ÆŠ4Ö$‘"‰#ÒXa\)äšT ¤áÅ–T~UUÅõìç´ÏúM[SÕ RF$™Bë$üIªð%$XG‘zòb¶¹ËÌż~P8…—PZä1 ï-ÿÃþ._}ó ¡ÁÜ:´”éñÖñÿãÁ‘Bh®’šÃÃcæË>ј8â(Ò´.p1Ç2âÜ;ãŒåfÍÑ ‡Æ*¢lj´Q+hË(•ã4ý®Etêrb/qÙ?ÇÖ´è¨C…³ë‡×íTwŸ±#é…@n:Ò0F¯l÷Y¾îößöË×ýÏ·ÉOuÎû/ÜÍýîJ²·³êýØßøg9óŸ—ãþ¬,úöÚ¿ˆ·×¾3 ýK’ÆÔu ÎÑÔY–bÂÐ:R;‡@Á‡ì5¢@ Ðmײ4£§×t8², BÛ{%ñQ¦IcE¬‚Cö"l¿/ËöˆJÓÜ>þ-â–á××3“ƒ€0®zRÇAEkvy()õ®"`LÃbSSµžb˜Å !4"Òèí :!·3çÖºÐCNt”H¼¿EîßgB²¼ Ͳ›72­<Ö˜Ž(¼”˜Úðè$#ó ‹ÆaÚP>Fêœg˜§¬×ë |ÕiÑ ¤š&ˆv€ÀYÃbÓÒx*¡HãîüîÎñzSâФYN%ÛÙÌ>ë—B`¼£¹¾äîtă£)Ó,B PÒÓ¢ƒüd—¥8¿b]ý Ÿÿ?üÎ÷>ä×¾ðµÀin`£¤û© £!Û{Ö[>üø'DQPê8ž4%o mÃQ>àƒ‹KVUKÝ4œ5×Ös0IHGEšÃaŽôYδ-y–1MSN¦ÇÌ®ç§1Ã$b¾Øæ¯=zÄùÕ9_~ã®®/¹¬€Œ2½Çö2 p¼×gÊ7o¬ÝŠ"Íj¹@ÉÀ¾U6–ªªðmIœâ…ïÉLJX×;z<çJBU[’8”ÇÊMETä/Ý`û%öçä÷Ä~`€]V.`b%hÃpœ`¼-玬5¤i̸5Ì›‰Ýµ«ë­ ÆE7TrÚÖз ¼‡Æ:¢$Euãûç°ÿ^ÛÐ/BP–å6úÞc¨VT"âbe¹{¡}¸&F"Kµ®¨|A‚ãÍé1wó¿ q·6íö×…ç¿ùÿ)ëë1íK÷£âõ×Þäôâ4T5ϯN§4U‹UA@ M5÷ÇG¬¤uÔ"PDR2ŽSV¶Å¶ ¢jIãh«žUU«÷î?"ÏrÊ2H $‹ùŠÚ4LŘ7ï¼F»iHÓ‚(žq­=ÿîƒ×QÁÅìŒ<‘%£ÉoMö8+´qøº¡.gÔÖ0P‚OV+‘òÕ£c´³<|ô€?ü“ïð|1cPäœpuqŽñŠ¬%Êž?þˆM¹b2™púb²ž$#E†`Ì{Ä8c~Ùð÷¾á˜µ ÿÝûùÏ¿Y²¬Zï<`bm¥)_ȦD‘äÁƒC´Œª¸i0Æðµ·ß¥,K¦Ç´þC~º¬—×|òÑ Në#ÒË5ÅÉò¼ *Û팮÷~«IH3`<³ÙlȲ !D³!±^“$ mÓ “4ØD¬«iE….&Ô« ùÁ´»^%ýè”êNä!MÃüòz½áòòŠÑhˆA„ÀwT•º«(oPZ!ãl+òÐÛ’ÆØ­sÜ·+·Ó¾­1­Ã;ƒÖ¹ßapvÏÒŽcÞvÏS”dÛd£_ûÄû6ãsmýgTQ_~íÞÌóÏ ßþì;ãÍßyﱦîØ£.º¤eGÿüië•™óîøvÌ%ûÑÄg}}ÚAýL'ô°LSÂóWË~†kš†Í&p¾j¥ºH8dq¶mQ]/Zˆp#ößûÈ(Šª›KöRĤÀt´ÆÚСŒž$Š,QÕ«Ï…¡®í6›…[ew±#èÿ¶ÿºð1~]!•Æy‰s§ù–¯——s.pîº.H ,_’"ÏÈã´²Ö û9ë[¼×=W÷þ Ø#(o—¢ö—'= Á ÜÍAxÃzcQ‰F{Ç4$± ,kfË%ëÊr½ªqB¢Ôn>q½\á#J"Z§‘hí¶¢®›íµ÷Þ±©ÂµÕÊ“¥:(`‰CµatNö%æ õÐË_ äìʲFxËt^«ƒ(4Ö J"´”ljG " I¢C‹€ÿâÿ/ü—ÿáßæãÓï¡ÄêÕZ”–”õŠªÚà½C ORUlPä±Fk‰ œ`ÖõüB„Œ8_,˜v—D«Pnìµ~£("IcN¦Çi#¼c8((²”ëåŠÇ×ÏyzqÆéÙ Ý}Hš .xüü=e^F£!¯ r<§÷˜_ÍX%š#)yíþ#Vç|ÿû?dxpH5¿ftpÀÂAl*òá´Žñшª®h*Çz5g8œ Ežs0žðôñSêªÅ#;éŒ,M‘Ra¬e¹XaÚІ(bÉ_{Í€uü×ß©ø/8DiFš¤äƒ”X Êå‚ùìœj³BKÉ(q½^ãT‘­ãÉê¹²kþ­oÿ}ž½˜Q '8먫’¦mI‹ñA¬T„Ö€XV5«Å '+ŠPfOÒ›iš‘çÆ4XkˆÒ$è€{‡Zgh¥©«:Ø­hMM]•4ƒ£8áêò‚¦ÜfEèãvŸ$hžoí)dÐß¿×Û Ðô•°};#P]…ðf+UðºÎ)ÀhÈL;nßé3¨À‰ u`â hï~Äéf2xÛV|–O1MƒŠz5)¹ 0nÜ!su7È‘nfÅ;ÛºËâo' ηà÷µÉƒ0‡w„FéèF»æèÕvð¥žóíõyuõŸeý,ŽùU½ëŸ×ú4@Øþ¾øî© ÂXGÛ¡†£8Bt}”ÐS–[§´ej­·Ü:Gž&Hohª ƒ<¥Èb„·q¬I(ßÒš€Ï„e˜KV‹ QGÙ¶ívð¿¿Vû=æýcnøÚzŒ—x¡À±Žç¥suU¢£˜$‹Y¯VL§h´–ûã‹ãè%z½ý ¡ÿ[ÿ÷Ûý¡W-é`˜7á[eW9s $uÝ2[”<½*iÅ€ÒŠÀǬ4qƒ•g»ñ&‘hIÓæ³uU’åA”¾©[êºÙï†Y´ÕŒîÏ[¿ß­õÛ× !À Y?VÒ·ij<’ëÅãuãÈrV‚Mµ£¢#Iç··Y<À$28œ°8û# Ú?J)jSq1;#ê¨E­P¼sç˜o|áK¼xöiž¿8£ˆ4—Æn÷É{OckLây˜¶Tš¦4M³­ 9ïxüä)ÃqÈÒÖ—slSquqÎã;¤:eÓ¬Œü䃟òñ“9˜Npæõ’§À×Ü'w†GGw¸x‡ÏΘ¯KÞœŽ(ñ|øÁ‡DzÌàà„ËË3Ù’àøûÿ·âï|%çù'Ÿpçä.‹Å†A‘q8ž2ÈS&£kj—,¯g¨8%.(#Šá˜‡÷ï±^ÏAJ¦G÷Éó!q’3=¼‹”1ÞIËÿÆ—‡Xî³Á ãâì)ëÅåzkJž|ü›Å ‰cU­Iãã,?yö «Õš™ñ<s?‘xÕ6úì¸më­óݵƒQ'7–zÛ·o_u Ÿêœ÷/ÚÏcÝî?þ<×ç d®RõHéàü´Ö$Q"CëB„«uè‹xOÚ Þ;gQJ£u´-Ø(f[g8š”TÓT bR-ÂyŒÒ bÆR6 † !wêž'Ü‚ªª_r†ûkÛ‡2 ½ÁëÀNv•/¥ •Bá $!‹ÅŠñdˆÜöMvÒgý5Ü/»ß.ÃßD]9y‡.÷x/°Â3) \—œ]­É²##"鈕Dš–ÆVµ¤öŠ8‰;pˆì„&ö‚”¦D·Ÿ——3’,g8>À;¿Cqw}rï=± û „~“(¢´-Ri™"ÕP‡èêJ†ìWŠ†ªµXÑ¿ePZ—a¸,Œ£A,\Yì ]$IÍ[“1ÿè÷ÿˆ{ùbÁó«gÌf3¦“@ºPµ%ÞzŒ7|ë`HÓ ^\|Be,¶Q–ñ|5g#Zõ¥xR•‚# ÿïå%GC¼”¸MƒŠug8ª¸H3FãƒáÐÔ&ˆ˜4­a::àlqÅh2f˜åX)‘ÎP®6´†B µäþôZA¤"æf‰m*Þ{ý®×+Ú¤åäÎ ÓÁóÅ‚‹kËüë÷Y-¯¸¼X2å¤É+ è—µí6`¾èì–$Šöl]†­Ô®â¼¯ju» ýªõÓïþ/ÝϼµÿY¿²÷_ð3û‹FZªõŠÍzIµÙ0»¼d;6ÐTHoI#½¿êW–e8çˆ;©I€õz BPÄíƶäED¡ÂM$cÍjíˆbôP»H¯ú·Ö²^—[ ÂWêî¡ bxÅ|6¼:º[¯kÆ㢋ÛYâ~pµ_1Ø_û}ñÛ Z²äQ!æžÈ[Úºe]òÉ”A"¹“yFIp\Iž°\[VÍNO»PnG¸=eh_š><šÇ cÚ"ûÕ‡eÕBWaØ¿æáÿ†"Ò8kƒ=Rã"E»ÓÔÁØùÀ&7Œ¡W¶ŽÅÆaPÈh§"6¯Á¸Ýs×hF°ôÛK¬ }`)%Y–oÙš¦ÁJÁPÆ,ƒÛÌikOb<¥kø°.Ù¤w’߶Œ’Œa–3ô’–|g±bš¸^—4«’'Õš8î‚¥Æ1ˆLÓ)…Å#"ͲÝ£:™(ëytrïo¿ö6MëøÂpÊ_{‡/>|‹a6 KRVMÅWßü"ßúÊ70ã[_x—©a[C’eÈ|ÂÉkÄiNëà+_ýçWsT¤ÐÒ4e2@,YT%ùpÊáÝ7¹{ÿm´ åK­5OÎ.)ò1_þÒ7(Š‚Æ´çБæ`azx¼}Îû{Îˈªµ¬Ëj뀚rƒ3ÍûuÀDz,·÷YlnÛv›UFQ„šª³ÁýµZnj« ‘’à …ÖÔMIc£ƒCʺ¥j eÝRV5åjNSm‚æ@[CÊêŸá]ÖºC3÷_aÿv¶dÿ™îƒõ}´ÿu»²Ö¿¯mBåoߦì?·3×}[öªŒúööoÿ®ßoc îxªÏÚÆþ±î'°}µr?ÁyU%ñ/êßÔëïýÊ?x뛿ñʃÿy®Ÿg¦¾¿l[n漿öoc ZväåRâDhªuxðÒ”ª,‰£)D‡Z V¸†,Ïp¶A 8çAq¨qlŒC*Eímãh Ì çÙÇ>ðkÿ†Ø1½\‘Øÿ¿iÛ€­êïx”ôdÚ#„d]‡ÞsS•Äý8˜”8!±a"ØEÀýgßfÍ hIAc›¬¦m $Êp-‘Ö¤EƘ5Ya­'R’LÁÓË5›Z ãä†óí?çöµ‚rX¤Q@ªPÖ5IQtHê]Dk|èq»ŽOø&ÿm@dÇJ •ÀˆÐ×Ô©ð*BbÁµäYÞÇÎCcµqiT€B˜Ê8"å‘B¢… –ž?úé˹¥É®ÏgßE1³ÅŒÁÁˆu¹Ä¶ ­œ—5Ï«š+ë8wŽu,iLËWÆ#~í ïb–K†iÌ!‚q¬‰à½Ã ?¾¾âÜ·¼==ìÄMñ„öð¥×ßaœijCÕ¬¹Z¬©|Å|yÅUµäzuÍ`8@hÁƒé1ãlÄ?ù1ù`@e*&é€,ÊJsµZ’¦1JAÛÖh ITà¬cX¤T¥áÞÑ ×ш×h­g02bg™ Æ´Æë[P# ch N9*Ûg)E’0;»fU–<¾<¥iEÁÅÙ ï$­Mù??¸âo|ýˆaêY\^àME¬2ÊÙ>ÞN^CÊ”÷ÿüϹ÷è!RJ“c^ÌžóᲢѿM]KÇwÉ‹„v³bÓT®s¡íUCÖë5­ ÊPª—µ´>”·Ýî¹BlÇCÖ¥Âý £­Ô‘ÆÖó«4²¡—n­¡\Ï1mÃåÅ)J@œiZJÕZÅ1‰ŽRÊÕŠ¦mC9Úyðï ζlV×$±¦©×·Ak]P e®îùç{²ž€(´Šb‡€¾ Ã:¤´mMm-HV׶øÎq–UEšƯ~údÿ™~Õ÷Û6‚ðÒÑK3¦e/Ê ïI‡²tg7:¼'T‚æáîk¿RøyYð«öíUk?1þéwÿõÚ{ßÞÂn´Ÿ÷úÅ8çÏ/k÷ëö !¥Ä¸Ð?Ìò k˜&qèóD'e(yxï±Þ3, ’,ÑA³9Mˆ£P Ï3‰êJ½‰ÖØ6”!sô Fu3v½óÛ?g·‘·Ë@ýªë:0]Y˜Œö\è=64݈Yš¨€œÆ£GÛ¶x©(ë–¦±´Ö%;Hò÷TÀ:㓧Ž$ò(!;E/Á°ˆB0Ôaì´Ð"RX(C²´«[ËóËó²EÅÙ é¹Û=¯ÛǾ¯0#…@u€!kL(eí=hJ„ö@Ô•áâXw¼Á;¡‘~ôMy…°A5ô-Y–„@&ŒP;Š`àêÖ'R°鸮œÞCæ“Ã_âùåÙy–°Ùl:óÙŒ$ ¤5J«®d®£Š%)‚/cê¦âÉù)«ù©5ƒó͆ËuI œ»–oFHÄ œ­e<¡¤¢ªæ8«Z00I¢˜Æ´(/xëÑh«8›Íxôà=ýˆ" =â««k’,c˜Ä‘€*㘌0& 7ÔµaîZþ×,ø•×†¬7ên®~³ÙP F<}ú>M}µ-Jç´¶%Ž4ëÕãÓé”zS%1qÓH‡Árrx Âóüü"VÔ¶&™Fü£?…߸{Ö9¼k‘D¬®/x~ºÄË”³gÏxãÍ ÇwN@ÔüóóÔRòbmù7ßû&CÍ“gg\^ω¢@vSÕ5uÓ²Zo‚s‰4QH~öïÉžör¿J¡Tl­AÉ »º­Fëåœ|0$Ír*_u]')BjZ ÆzÚjE[oH⇼ñ|#$ù`ˆ÷„yf¦#Öë Mk)«†MÝ°X®©ê†l0ÜŽJ6M³Í<­sÛg0dǾ»éc‚àÍ670 ™«ŠBpá;åÀ$I`›¾\¾¾|¿ÊFo?{ÖÛÂVûwí°ƒÞ‚Æœ½iSº×ï>Ósøñ÷‰uÆÕÕ5*ñŒ'cVåšb8âé“ç Ò ï§³+qÄÝÉ„å¦"Í2ÂðÑ“O°Îònú¿þpÆ'óš·-™WTu‹S5ë͆‡îðÃ÷Ÿ³Þ,ïP5%G'¯³¦¥N±ò¼7©Èª ¾ÿÁKJs=›Q•%"ŠQQ‚u¾#¼ñ[‚¶má9jŒi„̳(Š®•ÒÒ45D=)Fp~Hòbˆñž8UÈΉ ³5œ‡ûT`*‚ æ%BÏ8Š"D’b½€®ÏÛ¶¦++Cg ‡CZZ:ZH¼TúÁqoŸ¤¸>Q@a¿›ÆØídÓÍJ{kvØ­q°¸u©}–rÓÏb³¹a_àƒm|èµÿõòÈÓÍ„gß‘ïÿ®î–ÊpoÃ{*TõÆ×>­ýóZ‘lýÿoçüY™óí ¬w‚"Â^$\)Åf³ÆÔ%uUQ¢$&IÓÀélC¤¹^®ÐªDyÞQä Ò["[ã¥"’D9ÊÆcíدöäÍn•P /o°uI©¨Eí£,„ÕCÓ4ls ¥¢íÈ8²4&Žõ¦"Ë""˜~¼‡¶®ˆÓ48MôžG± Ö¯Fö7ki¤ou¡ðIÌP7¤‘¢é¤®5èˆÀöe=mÓ2ßjkYU ËZŽ¦Û²Z¤¡ˆ%‘„²¶7¼Þá¶uKUVTÆ’sVë*0ºIÁr]§ƒWF¾RT”EšD+–‹i’„ÙUç¥a„%œq(IQnò<£­k’´§_½ùK¢#™hŒG«0’eFPK‰E‘¾‰¯~ÝU,Ò‚¶ë¡ññ‡b½Ãxƒ0 «ƒ^ð&”u˜_ž/œËëI>¢HbVå†wòŒMY3äغáÞñIèÉ®VŒÒ!²¶©ùðƒðN ³„$Ž9(&TeE¦£ —³9ùx@ÝmïÙbÁóÙ%Û²6Gã iQ°©*ž½8e±^2<šP.Ö òœ,ËY¬–üW¿õVÎ|>#MLÛPn6H)˜ŒÆÌ.Î8½šAœPçƒ rq|B[Uœ¯®™­×NF¬d¤Y-JfW „TëšÁx„ׂ§§ùö;øî“ŠoÜ‚HðÎP55Yž³Zœ‘jÇÁaDY5ä£2Êy~}Ê4Óœ®Z®7_'ÇøTãõ «8š8¢u‚sµÓ륣óœðiZ²,Ýfau]#D:´Bö«døpŸ(#»öŠ”çÆ=¥8|¸‡þ«cl ÎXáw’ÐÞ  REÚíôà(÷ýw@H¤ÒÛÿãC›Gˆ`±AlÃv¤Kû Eßò ’ŸaD«n›]°Û=ƒm*Pá¼9LS#ÄŽ‘ë¶ýÿ¬¤Í´ RG[ƒßR(#Ä^9[Ýœ¾ ÛÚÁºTšÀ ¦ndØûÇx{nW5oW0?íX¤”Ÿ?JõWiýe•Û?Ë9ߎ zpFF{|ÒEž®hQ7-ÖX"o{ZkЊ$ ¨Ì¦.iê*d¬Þr`µ’;oZ¢8!’å,‘ÖDÝ\âíuû&µÖ±i=‰’ÄYŒ´žAªÞ Ǧ ¥{gáìrÅÓ«’ëÃøÐÇm $ J«-ËÚ8TÀp¾a¹ zžúŒ½ì]”’kÁÕl†q‚ùb˜¸n͸÷ç@)’œ#ŽCiÙ´-‘Ö¬JËáPw»@J×!kÃ,sÛç|û¾Ý', ,` ò®5Öz(R K/æß“­Ý¶ó8€Âž?&OH³“ÉÊfCm-Æ–¨¼ n[/yºª™Ž ~u<$•š9Ž±ŽÉ’ ¶ò¥‡o3-FŒÓÖC¤"KV›’Á° MF¬ÊJK"DR´T´µA{˜#ªÅŠ/Oyï _àd2ád4bJ½F§³\” NŠ!RÇlÖkÎ/®@(¾õš$‚Éá[7Ðq,$±f½h#î=8" ¤æôbÆ‹«K*kypç„÷?þsÖmCå<Ç£ ç——<^<çã³OXµ«r’8áñÓgL†Wå†Iž'Ì®žã¥B'›ºäøÁƒ€ q¢”µ)™[X7†×ü5KCå†äƒ [‡2o\LˆÒcm&'Ò4Ý^ûm€­Îb–(ŽÑJQ–%ÃÑçÎ Ò$ÙfR½íéõßogbb ß®‚z\çœuÇ'Ý/ B ž9¶óúB½ãyõQÿsp¼]¦Ü½v$ª·›}ÅÎtê\mÛÒ³åVèIŽ¢(BF1«Å5¶Zg» à_Ì9·MÝ9çn\jo¿Ãë_P8çèé<ƒϧ±‘õ×–[Û¿=¹rÛ1ZY~ëœ_ïWÿÁÛ¿ô›¿0@Ö¿îú,¤Þg­ÛYRÛÔ{é¯þœýòñ>¢²ÿY)…V°_Ê(ôž¨(ˆËÎ9+)B›þŒ2òxÀd‘Eýgt#5:Œ´( J+LàG*A{ Rƒ·÷#”¯HKu[kEÕz¢(F ¿ œ(´¤µ”]D,hÛ®* Ô¶ï꽧ܬ;g&·ÇüYçùvé=œ#O+ ÁéåZb„Ç´6!ƒ­J‚sSÝ~ªí9:À™t§J(ª ¢$z„&*I0Ƴ)[À3€Ô¤i¾ã”B§Ša"©ZϨÐDR¢DüI%ÑQDš¥r5×dÂD‚uë™f‚4‘(Õ¡Û7 Qo÷cwN$Ã\°i±ò M#¨%^@¦è)#þ¯ïü¯”TFc´CŠ„,ŠÉ£yZê”"â¥c]®^P;Éz¹bPŒøÉù5ã„wµ&8w‚Ó²!ðÕ7¿È ðøƒOxò✣ɈårÃ`2ÂaY×Ó“FÃ!‡ãƒÐߌb^¼ø­RfvÎÓZc›!«æ”‹ó©“x¥1.Üχ©žÎNÊs¶¼â`Ä=¤ÄIÌ8IùŸñ`¤9~Ž‹üäì}^¿÷çÏO)ÆòaŠ&ôx7užÑ à`<ÂÚ–;‡'Ì×x /®/¹Þ, ’$a4"¥`½ÙðÁz‰OÈ|Ì£“)Æ¡„Ñðë,Uµ!/Óã{Œî!”eí*ʶaxòø×iŒ£`¬c8ruyA’†êŠ1MhuE)tÙf2‘(Š©Ë ý­dÐ`î `ªªÚ4ûrvß–P½ŠÒ´S?óÔmƒÒ!ó Êk]͇ö™¼µ[2km—"8”4M1m*€RmE+¶ÙzÇ`¸Ëâ-¶“\ q€ß&,=-gŸD.{7MG ,X\ÑXƒíÆ• “xíŽis}…À#UÜQœt/—_嬃 ð-M©à¯à`õì÷öûÃk{ûÑ¿vàwR•·3çÏK"o·%?Ín~ð½Ö£µ}Ý_ô2¦ (Û[ò~‰aí?4ýÏ!2înÎc–w,RÞw¥%O–'h%U¬È“˜D8¤Y³±QÈZU7ÈŽ'–%‚óÐòD‘h0Îcœ“„Ÿs‘ûcÒ‘$MÂ~çb創Ç·Œè¹ï ©( ûÓeŸU¹!I³Çþºg< å …r,EƒD’(IÕtÎE…‡(Ö`*‹~˘UµŽX ¬i¨Šä¶ª±{!¨‹i[šºÂ#¶ASÿœ£\­‘Q‚;Ö¯ý€¬?Þ¡¶Œ t–$QÈ®ŸË0Óêm‹Š5MeÑQèÁ§Ê¢DèUëHiÁA­1Ä‘¢±–rm˜¡T™zøò[_åw¿÷]î]û Ê®©˜/¯1®Å»‘ªàùõŠ·Þx‹«Åw:MïÖ[$’µŒ´âô₦n™×% I1$%R‚Ò’<ïDšËÓç Æž©™Í×üÃÜáo>ð¨bA’ä¼Xm8[,x㻴놧秬ê Ã4絇8>8âüòŠùúš³«3EöÇdƒ O7-ÿâÉŒßxt‹õ%£dÂÑᔋ‹ œ‡Ùlɦ.I/®N9:š‚1x/Y.WÜ;¹ÇéÕ­m ””4MÃññ1«õšb8à@Eœ.g|´1\^?c}qA–' qœ298f2ž2O±Þ³ª×œÍ¯ðÞ1I þébÞºÿeÒÁ/BEi1»d=Ÿ£ã„jS"¼'Š“z³.àQºjŽ1&ü¼¿A’±Ÿ®V«wŸµÕå%δH½cÀ´kwkW– í±ô¹?šÔ÷ƒ“,Å :.‡]¹¶ª*¤€¶mP:ÞVçú×mkïo”€÷3NïÂ{\ÛP®W¬–œ¨dP¦]Vì eqcð2ìè8}ç'^fÓÚ|ûï¡¿ßÒÖ@ik#·Nñæ6ö¯Ý¶z4öË-»Wëç%·¯Êš?íõB´¶Þ/Þäþù­¿Hÿ_·Onÿ½ßÎm¾ÓOüÍ ¸‰zÞ/G¼êƈ”îF"º÷‹Àm¬€¦EHÒ;â(LäyJ¦R8F‰¤ir,’ÒB÷7™ì¢PÉHKæUw|x2-iM‹“­Þ§œ£ýãJðSå)š¢RJ P¬×ë-ˆ«gÓ:ôZÃ) FÅ‹º•-÷ÈìÛÜßû×Âû °5LçÉ(¦¼Ó`jŒŠ>Ìh×U`K²>%ÑŽÖZœW4“ø]` …`Y9Ú:hðZ#¶ô€ý>TÕ¡’N0C‘dâ8 Fªs̲Ë(ªrØبçÜíï'k-hÉ0x$ÎR£'ú ÈÓZϪ®™D N¤·V>ÌW÷L_Æ1L¦µŒbIå¦n©[Çå\p4Nh\ kü~û?!ˆ~ï{¿ÃqV¢UB ô(­ØTkŒ«‰U$¤"-r^œ?GkEc ƒS‚Í®ˆÓ!V-ïL8[!"làÇÏ~Ì7ïï|ð'¼}ð;÷ŽI}ÌógŸP¯Ö<þ‚(òå¯|‰O>ü}þ³_=Dk‰kKÒóß¿?ádò¶,«9i£O°eËåùŒ²2ŒF yšq8ž ÅéÕÃ4åpPðÏW.²´#.ËvÍh<Ä´{æ«—ϯ‘‘DzX•³9¥_³lÖˆH»k ecPRóÑ'OÈ2É—^{õ|AÛ´”nÃU|‡‰ºær¶æ¬½àí·ÞfÝ”øÆ’$ Ž"+øøì Å ã_ž]à‹!BE©0uCSW4­G'9ËÅ©#tœàU̦cž³.ŒæôÂqžXwÒ‡:ÝJÈÎ3t¸úùßàTƒ†yÙ —{NIvvÊZ $YtÐ…ì$;.y”Ü>'Z+Ü^ê;d·³mgÇ:1éqÞìzǯpn[2‘miÚª!MSZS¡"Ž#’l€Ž’í¾ )pÖbšš$M‘mÝôMâ›ãP½Ý¹ùÙfû3tعÛ٬رŽí¿öUŽÓû›@®ýã ÔÂ×n{¶ßJ˜FÐp¡_Úþí nÿ·þwÞíÿë–Šÿ*­ÛåŽÏ:¦‰*N¯zϾ£Ùÿ¼<¾ÔSxöÛï{/i¤I´$ÖlËA“kðÞå@J3Ÿ} œc”(Ö•¥ Ïòñ«‚œeSSt\ÝÞ…®®Ã¸T¦ìGú±­ýcuΪRq³Äß Hôïß?·ý’Râ¼áòº&‰M+ÑZ°ZW8ïä)·–ó«%ÆK²|L>„A$©›PÒ_uýñݵ“ÛÏíô}b‘0dÂm±;á ½}Àûr_œ8ç¨ëšQ‘cÛ¡JÿÞÄ )ÐZ޸ϔ€Úy¯ðD(³,[ŠaÎ(Æ"—–8UÖ1S!04A[z’,ã •ÅD¨•ãÐB eÄßøÆ¿Ï?ûá?âÀµ :â<ƒtÌp<ĶÁ©ÔM…ððøҨ8çOç×|yrD&¿vïMþåÕ)oñúñÝqu×éï¿Ïÿô'¿Ç¿ó•w™N±µãO~ò}â,Å©„&Öß9dU5¼ñî×ÈÄQÌj>ãìÉ &GšfÆZ&(exýÁ#‡#¤P¼x~ÎOÏž0™xûᛸª!Õ)=~Âáñ$Mͯß]ò{?ú¿òÎ;T×%rd*"Žcjgð*0@!à{ßÿ3JkÈ‹Œª ¸ ¥5Q§O܈ˆgקL‹ ±ŽøΟ}oƒ~qOù'Rð7¿âùÄÎøÚAÁ“ÓǼvÿ!­t4¾A'Š÷?ù€¢(ÐZ⤫ÂáyY¯×Ô•Áº"TQBZ ;iÑ.ìGï:{Ð×!#Lëp¶¦®ë­Ê™z—½vÙ?k,¥ØfÜ}•¨i†Ã!ËëyȆ“$8è4¥.Ëíç&IÈF÷“kƒ´ŠcÏ~vÏ¥#2ø&ÉÒ0ÓÜ}ö>SaŸ•oo[›"u¦Z‘Ž¦´uC’]ø¶­BuQJtt”µße­Ÿç“n‡sø®ÿmÌ­Q¨™óMµÅýí¼*+ßÚÞ.áÛ× Ø§ÿÜuµÙ ˆ´†®%áºQÛ—ç®_}LíÜMƧOÛÑ¿Ìõ¯û¹·›ìûÛè6Ô‡PŸþ^]ºþ¬ŸCÄQt¥Âýe›–$”šEóüéï>蜘%Obbi䨛]Yç@„3‘К¶“ùŽ cW]Ø؇yÄõ*2¼*’íÿïœ#’c%® %ÕÖ¶h-X,Kð’Hé­Óêy?ÐBtuý5Ú•¬µ¤i˜»uømÏÊwÑs Ô¨T³©Œ­äŠëuE–h­CÇõlM>>¤‚XB*ÿ?ÞÞäY’ì:óûÝѧˆ7å«Ì¬¬yPšd“lkIFI-ªÌÔšØ ™é?Ð;-µÐN »–d”¬ÛÚ$¶E‰MRl"ˆBU¨ÊªÊ9ß>ÜA‹ëáñ2«P¢©åfiYõ2^D¸ûõ{ÎùÎw¾/rM;QrÙE´÷D•zWãõHýó]¨i¼¿ZkŠb¶áÕm7nâ&‰1î¸ñ¸¾çþÃKöKE^”´m·Iäîž,Ø{~#åÎõ ¡aÙgX)/ ôäÕ5”ôR ¶¥‚@2pÛMA ÅL;–^¢•`?Æu)ˆ¢GÈGDÁÃÕ1Gó{xÑ!BA׶TeŽˆ ¥ÁuÑ:̼âµçÞä²^°¬OøéåY’‡tgü­gŸ¡vk¬´”ÊòølÁ‡ï@Åþ>Ï—Ô}ÏMý k:–.õ<•‘Ìç/Ñ-;?>çù뇼ûñ},ó½=>YÜ%Ë2t„Wo¾Li,wî?¢*JúÑ&òês¯BytvÉéÅ‚ RÐ:>>ÄÛÀrmøïþRñ+¯J~ððy¦xåÆó)@E‘TËʜן÷ÃûX<}ÓQy™Ú¼›åš¿^Õh]r¶j˜-ŠÌðâÁ®]3“-ÿù7óÝš$uÛsl5?¾wïZtGbák#黆¶½à_ÿæ¿CyŽžÅã4c~pÄÙù%™µØ¬dU¯ÓõR 5´ªªj†k[úˆÎã†$C©˜Zk®Ç‰Îr pvv¾Y#y)­û‘ùèGQø®ãüä„QU+Ó†}Ó°\\P”³íäÃ~R¿xÕ®7} ˆbÊu“\ɬÍPÖà‡ Rk½YûFg´á½Ç$éX% :+D‚Ž“¹Î'{J•ôì{çhÖ+fó½Oݯ7Á§Ò÷›€œ´¦pö‰×'ýbêuïBÒ£íí•À<üŽI°H+…‰lGH}|Ä`CÛ{ÖM¿y½””ÅÇmþ³ŽMÂÿòW¾ùí7¿þ›/~Õáèÿïão’L¿ë” ƒÛÌOß{p\ßmôW?ÿ1¼&ð7ɯ3·>xŠÒ¢eRD2V1+sÊÂ03‘yžÆoÌ0‚•$S‘‡ë5¹0ƒ°Äîù×ý“l?)uÛÃd!^½o#3 ÔuËéù‚Å¢gÝF|ØÊ "v¡ûijʽJºJU@Ú8*+( S‚™ä*R£#FEÚ.UÎÅeC^T˜Ì€PtMGÈöˆQrcOpq¶d±¸¤ ‚îœÐ…Ê2F•–§õx¦ç>][Ñ–’=½ÛÍþÇß 3©W­’ñ‡äEFŒ0ß+(UâL×Ѻt( !JT %©2‹À£df;O=m•„槛>ilK^Ž u=ëN`í–Øò¥ç^à‡wÿ€BÐ…5¥'gÜoV|ðxI-41´-¸ì:Œ²Ì²# `¥!/,w¼XÌ(uÁªmq2òÚk/pñð>ïŸ.9<ÚcÏ~üÁ‡”×K´Ð8çØ›Ï!À½ÓGܾû1^‚ <ÿüJi.W9çUøÊ­[<~¼äìämŸ= ÌKœp\/xtrÊ£å 'ËsfÚR·-ïÜ~ÃrŽˆ’wÔÙGX¥p.NιuãYœsîÏ9_-ùèÃÛdy†;T•|àØf„?:yL>+ØCÐņÖ]ÏýUË£ËK)òŠº[ðâñ‹ÜY.y¶,0“YöLKšïÞ¾Ã.ÖdÕoòL•óÑÝÇ\.V8PYÉÉÙy5G™Œ®ë“1ÅnFÓ4´M3¬ÍÄØ«Þp“p†¶6YufÙÿÅú®±YA$¦±DŸžéÚO&kœkéû›•­1™EL\È–õŠºY"ƒˆ‰"DˆŒµôÞcLòVžÎ[Ou„ÃHÕ6a%„¥R´m!)m5«‹t-†~x×uH@›Ô"Ȭ~7&/‚‰ ÅØzõ“ 9>¿é9 îaÜK*ï;ÌàC^¿kj1­t7ûø•jzH§Ïmß²§Áoî‘ÔšÕºAõÄ^=ªŸåÖøþ'X{|£n¿àtqýË<> †þYŸýÙ0Äø^qÏÍu ö)Õï§}·ÍÏB Ï‹ ¤#¥¤}€cdooFt-¦*9|湶T¹"ÓãRD£­²ÕÛïþ€ûcþäí5ÿáßûÄ™NDÄÇ3Á£•@zJéüû³Œ¦éé‚…BHçå¶_âœ#JÊ lfñ.-,Z°!­l R ¬®æ‡µá‡ùFF¨8zDì±jÌ¢%.&æ8Œ”¸ÞD¤˜•ÃND„.Ù—)<‹•ÂËœl>ç²m˜Ý@MúëOK²> þaÀÄø–ˆÈŒe±Z0ÛÛÃÇä·bÄ5+|dYFQVô1°Wå(ï¨×k²¢ ÷‚¬bó\‡HO–+Ö H‘¡TD™Ï2tôæ’³f˜áZ(ι$ë Ô놪ÈÉ„§‚†ˆU1¨Á•¹ÞE‚äÙãßáîÉ?å'·%_ûÒ¿Â/¾r‹¯ÆÔ&A¤ë‡ ©îÿèÿø_øÆëÇ}ŒÖ–w ç5«zMn%ïü$"¢!HÉOÞKÕV™Ñ\6ôÑscï³óKÚºå²^f¬ôÙ :'x|vÆÒ=ä¿ýNÁðædÀ²oð§ókœ.Nè|Ç©[Òˈ¶šÃ"ãÁÅ)F+Ž®ñÞÇèl…›£ö×tuϫϾÈܬ–Ë„Ì´û@9Klû æ±1ü‹“ûìÛ‚°?ã•"c†fÕY~z„1ÈС²àñéûeÆ?~{Í·^u¼½8' ùÚá1½|D×7ø 9zî§_å[¯¾Å‚ŒÃ# RòÉÝ{DšõešGž„DIžr)²Hf Y§Q ïÓ½5ƒ‡RI·×Z»Ýx- £¥”V \Ãþ¼ ´ÉM©Ðéû£s¡; IDATU… ”ƒEš )˜xG&¡ ’Üú¡¯iŒfÝ8ŒN)!:ŒÌKÉ¢^rq±Â “„dúŽS«àéÁÓHÓCâÄ<õºF¨$Ó½Kf:ÁS¯”Õ­ËÔMa$û3ÅåÅ2Áö3Aá=ÙS¯¹U4=“ËP×%ÍòÊ `µHýãáЃβC*‚QiLÌ£’X IèD 6çÎnU¯}‰ŸíkÜ:˜3N£ !H¤›Ÿià^“ßý³wyåH²¸¼ k:D&¹Û·ÔÚPg–rVrê;¬Vè²âÁjÍZôÀòò’b¶OªlðÇ‘™aj›f§ª•ÃÔeª„PH‘<àGAŒÑw8 ²—1„Í´lXàãÚJÀѵ-Î “ ®§¤Q×ëïÃÐføì-_c‡ø#¹Ívú«Óâ !ñ}ò–Õ›®Kº!°ªW¸±yA–—C2¡Óç‹Á×8EÄáíäÀ#º^°n[´Ö\^œÓ÷=E‘Ðv]§iïX¯–‰L&’°‹µ“´õ2¡tÑõc›jWpüì&úæç ß·´ÎãCýìz—&gœ§sÉó µÊÌF¶¹P„¸=m„kº‡ !xÿ/ÿ9êÅ/c3ç< jã†'{²ÿ_c [Þÿ›ª}šÉ !v7óO{…I€ä3 íO#X©a” ÆHQ iÏçs‚ë(sËÞÌpPHKÁ^ž‚W?l˜#¿z„š3›lÖ&UˆOIN"+"ë° x !(5̳ˆ5#$2 ÊLзÉ,B状õ;מ¬6¯~f™¥q€ÂAÓ¶è¢HU¨ $…ß{:¡yf:84I'ZHÁžñ´Ã ÖE¤õ för“ÞÃ5hrtV Öt´áI–ãÕµñY÷YJØ/]ˆä4cN¦%¹MB*—çg’4¢Æ*Š\!}À °v׉Ž½|»>×Ññþ]G.Ö“ª‚¡k®èáni‘È|J‰Íf(„@‰˜ÆbdB¬Œ–¬zhš–rðø†Ý‘H¤M¾ظO[ïãZ*€_x뫼÷à»׎Ž9_/yU®½øõ%Ë.âkøÒþœ7ª‚÷Pí=C¥#9jó9!jn²Ÿ¼ûÁ´î}ò‡Å]s‡¶ÊhR_,ø©¼:?$ËÒXspx¸"±Riº†·ž{™Yu“ÊFþò£%ïÿk ¯¼xý&Ñ{2kYö-×®rýè‡×8ªæ,./i£Gi­r„‹tß{!r³ª¸!5÷ç°º†Q†"+(Ëc¾w¯å—_?bqqAÛ,¹ví×öžE)An –ý<ÿÚ‹äÒsQ'[Ç($ÎœOD$m;ÚÃz rm’ëX¯×(!°ÃˆÔ¦j!c±%S)¥hÚ\Âp£®Y§ªÓnÛKÓýb$GŽÁ¹i[„HUµ‹!ùEKEYÍ“ü&ÉÞ6(£sŽÙl¶Ê·}åÁøBÀ²¶kl°¤TÉÎG™Tçp¾Ošƒm®”jç;{ï7Å ër«dÖPÌöð}‡ð“e8çXœýö³~o§ÙÛÓÞw %GnøÎ[µ™O;>í»LÕUÄ`sN>lõoE (2bˆTU1¸)yŠÂp0׳èñ;¤ÓßÏd‘è@(›aéBâÐ%ÀGBDó®%B‰$N3yÖ¦×k¤Wò.Οã½óKžö \63þt±„ÚòRf!p|ü,÷—øóû÷ Šg®Ñ×KÞéBA»¬é¬$‹–?n¸·¨Ù¯4ÊÌøòMÉÌ­ø½ÇÏòËÕ’SWóúÍ[¼Õ·,.N1Ö• ª2ö÷öxtï>o¾þNœrãÚ‹, oÿèÇyËË™á^÷/Ì.ðÑpY/¨²ŠÚ`µ%øT=.W «¦Ció=2@í/8sp½ªè´f©àîrI£,R>:ù€ç_H×Àoÿœà²Ü Á¢®‘R’gÙÆáJ©”t¯»Ti¶m‹Pš(YYà½OãZÓ4u’Õzh7m×Ìåå%!8”Jë jt}³!PN'’Ó”¢ó.±Ëãà„AÞVò¤‰(§u ˜®ïÈ2‹ëÛM¼Y-äyŽ2*µ ./ÒõËS\J‰-æC#“,§vHmQJÓuŽ»4þÙ7Ÿ³\¯6ûF·^%UÙAýKlö,­Òþ¢´N£¬Râ£,3ˆsBi £ž?•Æ)•¬×kú~Ÿ"bÇýµïˆ™Þ¹Öã~ìègÄȶç|N_´e¾êùoBèºúÙŸçý¯»Uáç;¦/ÆÓ’Š1“Ͳ|sQ­MðÿÑÞœe•Aè™å{&’‹¬â”ÙémL¿ÿxݧóåŸzbLà•À P˜Ô£ ^àCÒ‘=_uôì°1T™N¾ØŽM3€žY)q¤Üz·ŽÇ†åÈØŸ„‡3Mô»¯Ýfïž6È´a‰”x)˜•9.|l©[É1ðÒ5É»wVx ®Ýæº.>Æèá”qýŒ„‘toÒÂ8j⣤í#F+ éeHº¾Z| Çz½æPŒ–˜ù!ÚDœO‚/"H´„¤g¼g¥ŠÜ8š‘•{9¨è4¨Öq§÷gƒì‚H!¡7‚ÓÑ“kMeåïÓuÝS×üÕž|Œã"^ ~ó¡u‚Ê݆çºæ^ |ôîï"-¨èQNRd±ïÙW†1ð|ðüþÉ1_¾r`øÛÏå¬BÍ÷ÎVd²áýGzjùÏ~Ù‘uÇ ö¨—{û,côIÕMJÉ3Õ!³g3\݃ ‘‘w?þ€_ûµ¿ÍwÞù¿÷¶çïãå2œôäEAô‘‹‹‹4*Ö¶<{í:§——¬šŽ¢(Y,ÏÉòŒK¬å¤kyúÁv1Ò·y¡™›V«Õ&ÀHßcŒ ÷¿û“‚¿ÿE»$«¶_ã=+¬1ØÌ2Iüd|]ÒÙowmÙ-:¦í·È©&5µñ5ã~佧óÉúQi]OªZ)%ídÒ&xÒ×túb#8’%݈Œ6M³;ß'íIéûvÍ ­ ýf¯zbr$Nwa˜>qQÊca†½3ÛpšRKgÛ¢ÑÆVêl6£ï{šõ "H¥±Ö&éÏv›xc:í¯HBnF$‹”eIíûÍÞ1ò=ŒÑ(mîEJ2üfLkÍj•„®ë/ÇEŠ¢Ä¹.é‹“DŠÒˆß!Sšêž$3>£yžï<“1ÆÍ÷ºë÷^½ô•o|ûõ_üµ'ªã«ît¸Úß›þì*¤¼³ñ<%èLƒÖ§ýÞtÁ>í3bdÓWþ´Ï€'ÅNü`‹xõ|®¾¿Qk ˆÔèÏ2‹0+,)sË,V"ÌL2VPJoÂñ½×]GÑ!9ɤi/?<,Q*?T¿z˜eÕ.{Ó„Ýst§óq`[ m¡Ñ“óp>Ù$/Ù÷© ­¡Ìež(jŠÀ^¥± ´ŒX•$C‰¬c4E–æµ+Fºdð¸jz®càlÜÕj1bŒäbQs¹òÌæ3f&¢C`Õ8¼2›ÜôÞo“§]+9¡“ÌæÖ(>ÁxÖÚMfšºÕžÌ(|ô;>!‡‘Õ²&+g(•*YSõ°o%Â;º 6ZÛî‚Œ”yÆLŒ–DBÓw=™Í'×ãtÝ_…àÓ˜‰¤F$J3ôµR‰c1†Áú2 £Ï`9Šß$B›ë§&^µ1 Dú0ÌdÆoñÏþüÏ(â%Ï]£ý#´Š|rYù—‰ú17ŸÉx³H„FJžQ’窒¹^só°£pèøÒ‹op÷ä!=ð¾Çyñø1nß»ÃGîðøü”ÆõdÚóÓOîòƒ“þͯX´÷4uCðÜñM–ËU‚ ½cVà/ ë;ÎW—h¡è½ãÆÞœ÷Ú†[UÅEÝ`”F!ȳ’ëG7(ó’²(7ëJ* (cøÚqÍ™ÊùŸ¾»æËÀýUÆ«ŠÇ®ã«Ï½J ˺>õp…PÃHdš O|ÓŠM¦޻ឌýÚa‹ôß!xDH=í´± <ƒß°L¿o²"Ç0˜L "ŽÓ1©ƒmÖUØÎ#ë®ï”ÖH¬Nƒë Á³^'a”u]#cD[»iH•Ôë”6ô]šËî\? ‚C°3f³¶ÔXx1èv•¡÷´íßõX­ñ}Ÿ81&[ʾE …ViÔ4%IöS)™ÄLÊ 5ˆÁ(eRïzÚLI!†€ÉŠ ƒ;1Ïõ‰ð‰=>¢¼O=k’¯AD"•!„žúò’@¤ïÚ¡`ò¸Þ!Þ¥¾»š8)n3#ȸ,O’Ÿåä¼¥”ô}Ëßÿô´ÿõy ß«?»´ŸŸ¶ýMfý•„೎i`~Úw™& W…E6Õ­L™Î8»(e–¬Ï\ÄEçt{uÓ²vIƒ»©QŒ6kÖhz×#èèð‰'ƒ”0³’• ‡‹ÛŒ8ƈÐ/"µÚzëN3Mh¤”äD²=•8‡¯#öYaP¤ßJ†B‚T…‘ÄL²?3p+ÒøÏ$‘§›µàm©©*“fo×-Ÿ®q>þþxÞÓJÄû@½Zã½#/ iâüì„Ù|Ÿ<Ïh»ŽºîY®Œ5ìÏ223TòZ²¼\óÊ‹ÏóÁ‡\{æ&1Fzbê%)ˆ´8'¸ÝñÍVÈõgr^zùe ehêOàlqÁþÞ~:•ØÇ{yIyãEþÅ¿Ïü JÉhôh¿ÝפJlÅzÉAuðÔuZzO3üƒohJŸ³dÅÎ)lG¢T EzÎú>‘Ÿ„L(Zï]Ñ©/:êQ«ÉgMûÄRÊf°åùÄm’Û÷}j‰ÉÄÓJ¥¡êC‹EA»ÏÂ0}®>Âøïëõc4!J–u 1àB@Iàš­øÒ(䤴ÚdCð€Ú\«M,€'*æq¤5UÔ‰ƒ°³<­RÞœèÕšˆ žÞ»”å D|Ü*©\íAO>•{›.Ú«¿³€ž ^J™ö#)žø½¡ïÜY6ó¥"eO>Bt<.øt.CßEéôǵ™6àU6˜§‡ä¤¡n:pÿdŃӚ¦ëÑ2¢¥@„˜ˆQ>‚ $ZD$žÌdxÑ29¨¸(ƒô¡.ÚÀÚ DðøÈ@–˜Vù r ³Ó“kG$ºÁ1iðEª * •ŽVšýÒ$-ïBHÒ@LŒN‘Ærb„l!I–k1ì"-Ó5ä‹ÅÝAb¤jkˆ2!Rg}b»(0j ½?ñà_ùŒ“ƒ–Í,6˶‘ålXo)$yU$M©èºT%ô}Ç~¦8ÚÏÉ2=Q ”ÕEI©’¸@„ˆ4nHV†ïà©Qò¤#Ðîquí^MàD ¥Ð#ZÖµ*k¤&¢X4‹Ú¢¢é=t%‹~l‘F_³‚d„0 2ì>cB¬‘YòïþÒÂ?ùnàŸíø‡¿·ßæçöŽp^q¶î¸xxI_;lj“¢uÊöŸŸÏø…gŽh}ä­—ÞÀìha8}xNÄ ¨6R7=÷O Q»WQ¨ =«øʳ54+öÒLóG÷>懷‡'óñÉ=ên4ñ„àÁù)å|Fa,«å’7^•  Y¯yÉÜu 6—%x£*¸™ih×´®ÃûøÄ:õ$‡3{lPôt4_½ÙRÈ–YŒiô/øµé«ˆä®Ô5-FkÔÀB6Ê I®!>ùW³ÕϪ¶¦YÅÕ l̦s„Zkì 2ƒØ ¼_½àåPY @‘$cŒäYN‘etë&A$R“çiÎoìF6£GZ’øC‘kƒ5„ÒÔ­ÃÇä6´¨kuÏ¢ëQYNßb€N(Ö}L½1 3ƒ@¢ôvôk<ßS…轧ªÊ-QãSŽM ˆc`žI*+(t$W=mR |øtÙÏñ}_¥Ú…f®ЫGJIUê6•ê V´>"£HUˆ(¡h}‘ §Ïª.ŸÖ×ÑXa„±ÖìôܦÊE«UÍÉÙ%.Žö3"jÈôƒú(LäxnΡ•¤ àƒ'×z—°ð”£k[²§ŒéM§µq¢Hƒv^¦9åx­§ÏÀ¦÷G v#ÓÚwÎÓxÉÚA×9‡çBmà6âñ´k¼’ ³ü:?½w‡ë{‚‹ÚñJžÑ7¬.XšœG¢ãÀæ´k¸}qÂQQ!BŒTšL**±\­¸sùˆªšñÊ­—¸~pÄ퇟&–|!Dz# KÏñZþÕ×<—‹3rP­’ÔuMß{º¾§Ô) ³ÖòàÁÚ˜*Äî̬*©£ä“Å2Imf ï#«‹ š\\pëæ-t"ªJò‰}N).ç,kDfxíÆ/%™¡î³rƺn€€ëGHS¥`é'äK!6ûáXAÉQåk›ŠÒ‰ÀÕt-yžUeÒbˆ$‹[3Œ>Ʊ›eTj£Ï µww÷“éHéXeÏ…Réyi›uÚçú‘Ì–~g;ê$DÒèûçÑuIx$©j ë{’X§sI{“PÕlNè{šuM [#)·®\ã÷ž&é#Š I ?UŸÛkcÄ»~SÉoŸ¹a_ SaHh‡÷VJQ–D‡Fд±/íil‘\db4;iÛk FKš¶K ñáÚš,K-UÒŒ÷¸.FKÏ÷ÿò‡žó×=ɲ ÿ*…Q0MÿÑJÑõ y‘¡uºùZ%kD­5‚Äbά!ÆßEzS©dúÿ!³TjÀþ¥À‡°éOE±Ypã ÔjhÂo TÓ‹:fIvðFµÆYK×v™µäYŽ=i„#|‡ÉRˆÐ·-yY ¤`^ô]‡‰¥]”Å0zPè7³I³vÝt”™EDPR¡Œaµî8_v´AãeF”Î P†€"F 5Bh²\p¾´NкH‘§ q´g4Zí°•EL•Ð¸¡!>`c˼0T™ 0Éí)Æ€/ÓX@®UºÏ+°Qb˜Áƒ¾‹dQàÅ6¯VKʪÚ†ñpÎmü§U‚é!€ÂHDô¨}¤2¬¢”«Ö¥qR¿hºI>-8OTÎÑ?霦$Ã#­óˆ73 Æ&KJç— E‘!|`å¡šÍ!ÂÑžeß@2AøFÒµ«#cO÷Ó*á§çi0þ´DHRp±ìŸ Üq·ÚÛ"FI2ÔÇ4f%Õ û!ˆ±-i] íMŸü³–hᇶÄ$(Å­ÃCÞ|éküÁ÷ÞÁÇûéœ~÷ªêˆh’õ^UòÓÅŠ $Ö+^ïR,âôòœÖ÷h«yã•×8=?¡q-ïô!°…wëºÆ»€µ’Ì*n_’ëHïÓó7éÜ›—|åå7¸sùª¬p½ÃhMÛŒ$¡ŽÚ·ìYÉízÍ‘U¼¡sî´ /͹}yÊ—^û"÷Oîs¾^pzþ˜Y–s²ºÄ9¬8î/>$·ó½{•$/Þ"Ç…eo¿ÅŬ,©ëݺÆTû¿âàÊfH=BÒC¿SmÑ.Ä€2Š¤ Í(˜‘È̇ç4nþmqv‚¶ù0]3&¦j³Ÿnÿì&_Ó1­Ýu8JV¦ÁI×w0¼Î»!k]­èÚ–Þû$®á„6ôëM½Äõ-EuxŒˆŽàš„T RÒ2-–Co8 ì$ i4£SàïU2Ýôœ¦ç*¥Jh_H"Hp®Ý\‡Q\(‘ö çÀªi AÒvŽO„ŸÉhœ—©íÉùz¦øN}¯ÎY›öˆVáû·ßÃ*‘ú¢¾Ád'á“»³¨kööyçÁ)o<{̱¬ýšoòÑT½ß?¹O/?wt‹å’{—è¸ ¨²b'x`³´©:'øëÿWþê~Îô‚ó™âò|ÉÅù)yuó‹:/©æ{t]G¿ÓÆØeéŽ×Xk½‘»@ºfy¾…³ã¶?-¥Ü }S$å³Öâtý|Ú‘>gËÄYÄq¸ƘÄÎ2´÷¬ç(¥èš†®]¤¡Ì ŽŠ‚}“W˜ášò”}o<Æö¦R9R&­‡1IvŒyF‘!Äæ{MÅQ¤N- ¾ëpÞÑ· "W›stλ€±–¶i(çs”ò›`:¢¤ãþÑ»@5Û¥·=ö§$ ããÈãw*« ï“rØ&~NzöSVÿøÙé=#êåŸûæ·_ÿù_…¡ª0“„ÒÙæþÔ:é Ê¡ –"1šõøæ$x—2¦Àžf1Ež“eY’ŸSI±*Ï4SUF©$œ¡RU Á#Å6:ç7Ðt’Y”E‘¤í¤ÜœË”Íj3C2‹(PJ¦ªºY"%Ïs‚Ì«Š|¨¼¥ÄàÐZbTò ÎlA)Ëm$Öêá&Er£‡~ïPé=ˆ•l¶ñ§> È<ƒJU$ ‰÷‘ýJÕ£ÍÍA@ ê\•…Ê fF`…Ç"Ó,±o“ƒ”‡¨çë–»÷ïsº:Çõ?æ¹ÒQ¯.écK<ÞÕ¼±§xéÈs˜âÂ’[7ß*û!Ñé{Ì@¼˜Ž L3Øé1MBa£dû IDAT6hŒëñÖuÍy—˜èU•|Œ Ó™§› _½f!Ž÷ û&iz»ÞQwtMʸ×ë&=}‹Tf“Ô¥À6c-m營{Žf‚ûOY­;fEŽ¶ uÐEIçú:Z‚Ö#(ãÙŠÏk_=bL¬ÖEãPC7^ï«›À4p_v‚6H–m¤ ’u©û@ÝCÝÁbèº"HІu›þ_ˆ4‚cJc8Ã÷Ï$S¢ä×¾ü-þô‡kT÷ ‹ó%˨9--}Û"Ud¹¼äA»æºN y¡kyµªùðÃɲ,Í9„¥q¤FjÃbµÆÄŒô®à®xþšáF ê”û˜zu½ã­WÞHEƒ¶(©øéøøβyI1W<_죔æñÝ3Nº†»Œ± 7lÆ ”phsÕŽž{ßoçèµmxxz‡(}¿æly—/]ÏyðèûüÁÛÆ>yŸ/½ò:k…²§ï“W{Ø¡Øq­…iÚñÞm‘¾¦?œó­7F1a€—û.%&íHªò.)}5-YQ{ÉAü4d¦m۶帆Æ57MŠ}ð°©¢»ÚLZCÞ§ÊÚuk®q÷£Ù?:b~p !`¹¸HžÓJcl†2–0øÇÆt*Ö ûãˆ%¾‹`«œ6"a£JÃsÈpLÎ! DCé»&RZ#‰Ø¢J=q™G-9P9Æ&rš1:}Þp³Võ*1ù¥BÌ/ÒØå Ï9¹ÎÓÖZú;µ,2k6ÞKÓ6îôžr¯Æ÷úé÷þmµ¢*²=_Ùh§MüFeâô4òÇ€>B+RJÚ¶X-ˆ¤Õš4J³jž ä!pB$Ï5"HÊ<õ 꺦®kdР4Mß} È-Rš±ã31D"ãÂh£PBo˜­ZËíM{RRÙ 0¯eL .2Ý€Ð+ôàiœÙ wÐÁM¨B ,4rˆErâw<’r>-€‰AT@‚ó¨t d@¨©(à³R“œN™ÈXšFtXcQ]Në6öüé_ü>ÏÞôܬ®£´à|uɲíÙ«öXÖK\ëB¢4M»$ây㸤j‹­QÓ.‰%îö¨? zÞ<ø¾CiͪsÔN‚Ì9ÚKýü虢×p±’ žx«§!ËYŸ¯Ø+K´ÚÉ Q¡$èÿö7~™ÿò»Í¯ÜøˆÓº§l/±yÅÁlÕcG¾çxïä”—oñxå©bËÞÞ{ûóô‹¤ ? ÚÞyøˆKéøõ×漶Ÿñáù ­é†U¥4M½ÂË÷ôCŽööiËŠn±â|yÁÁõ£4:WUøfXöæ3þúÎ{ÜV-BXfÕ+ó\p­‹¬§”†Ëõ ¡iγ r2r÷äQ@S/ÐQ`eÆ£³»Ü8~‘·^ ôÆóÏ~ø?òw_þ÷xç‘c>ç¼^!•¡iÐ)ÆÊ.møÓjxœcN7àíum-u‘JYÅr¹ úž€$Ëó}ät]ŒÏèÕ 5Ä¡½lq.д ‚ ›eøÍ©ï[×uJ`I­"RëG ‰T’¶]Òœ[NÐÎó9$aó² 8›íiPžSƒ“1éÒZkÊ"Ûô5R&3Zp¥w½#3šuÓP–%›Ì:î´É{t(ÙC?°œõ`2èÝ–Bžç9R¢ïPF ¬2¹H¬æB¼N°]H}i›%VtbÒ_É87™,K:°™µ(k‡d ™Wz½µ:m"xˆ©‘‚G†DPRÙëêÂ63´³ÊlóÕczC¦Ç&¨ ~ªŠ&f/Ñ2®Ä;%`^iTð)qQr¤²Úðý÷þ™èP¢àøÀðÖMA%sÔgxç:²7ÛO(Bµ— ‘’ZÕ^uÄ÷?9¥5'Ü:º¶ýüê“ Ù TOƒé§?BpÖ)¤ƒ¶O¬N!“Ђú‡~WèØ«4«æg‹Â‡èÙÏ$V¦êùþ2R™¤Ïýb&¹³Œø(›uX£Ûq‹­ºÑr¹L•‰Dç°Cb% ÔuÃû·ï#uF6ÛcO¬šŒq b/Q™´¡é¡ˆÏ•a<õPŠ¡wÆæú}Öc$—ÅÊyô`L?n^*#hÛ4¢‡qñß{¡8»h)l²åœç`&ì†sàZ´5|û·'ñ&œã¤m¹³|Èíwÿ„/½ùèÁñÃó%Ïd% hÚ%ÕFYjêtcÄÕðÅ×ùï4ç…ãí:ã¹Ù]»Úa´½C °EŽ0Š‹vÉúQGß{yýè&«®áã‡÷©f%×Ê#þâýá‚Gd%A.;^™í!xÝñ¥—ßä?~—ÊžUÜÿˆ—žß<³w|Ìk{TÄøýÓ¤R%brSrªåû¯q|­â?|Ÿ·^x‡÷j\ÕEQbd½¸D[‹ˆJSŽL"† Ö‹ÑosœlÞÞ{g é±k3\ÓnîÍ´=8BÒÓŸëõj`_;¶ BHÉAßÖ ÏnÖQêÄ÷à{.M‰ÝŠ~yŽ6Ù”¬M"®kÙßߧs)è7«„ž²ÚÎa«1~5pðõH”JEâqhÚcì Ø8¼N[T ©/>0å§Im3‚O*iaP}ìûŽÅbµ9Ze@ØGI¿›îÝ_ÆkùiÏ©»ûã8Ê6Š”L¯/$„c* ¥¾üÍ_ûö/üÆ¿†Q’ÂjråÉM$× †²–˜ˆRÔ~DÛégÖ”–ØLo˜t‚4²b$Ë Y6Ì· (³‚Ì*´”¥E‘ ŒVX=ÌZ‹si ^) Jã¼#³éïÓ¼*%UU}ÇÞ|¶ÝS?8’UnÐ*õä$roN^X2³¾Éi`sá< VSxf•Åj‘t™B°:E!mëPzÔ?kƒõB²Ÿ¥,uó ©3›þ´%áŸüÙrã™›ìÓq¶ZrѬX»–ßÿÞr-?aOx:_£D‹1Škø¨m¾£(fÌŠy‚å ÔCêmû ˆÒówf8*^9zÈÛ?ý˜¿¸ýIÒ(öKÞ~ÿ=”ÿþôÇç|ñ…›€@z@G®ÎÕŽçc¤‹*ã„:Q¶«dg7<iñ' 9%U!‰¾GKI¦%‘Q€||DØË$릥 zã´5íõý¬Í)%½óô>¹Ýùä!(ÃÑñ3C•"©× ÒI¥l„ç’É0ì#ʨÄFo› ;ó³ŽÑ{ ]¯{¿C ù´#†€çÀ‰žÞÛ›™©ÿ\*Ïõ}Åz¹¢ %⎸¿ Ý:%®sH-Y­;l¦bÛÊRR#‡óT´QÌsËËó’W^û~ïíwyó…³cÖ«Kžç+n€R\žžïô¡­5„Î!áÎÃsä³’_90(|÷ÛäÖhÒŠ®ïȇä¢mZBhº–à?ýä.=$<¾<¥œ—,$z¾°Àan‘Bл–›ÇÏ¢|²l­û–£x®:à“ûÌæ%÷OðÕב] BÒ;ǽõk-ׯßÂÁG'ÿÖ×ÿ Þ88æÖÁ!R)î=xD4ÙÞ!Áut}b+ke0J£pq'ðŽäT„À…´¾šÕm,¾ë¨ëÊdجB+³±¹&PÞ÷H)6m´Ñ¡ê*ì:>SCä¢ëZ\×Ò· ~P¿²Eµç„;„”Äð.±ªµ„êèy^¦Vß|“ÈÍó=|Žh“#”"¸!5YQ Ïü¶=6=Ròì¥JzÜWÇû.Yo6­#˳ÍóMÜ"–‰ÜÚ`³l€ÅÓš2Æ ô}DMïÒŒºÍ2tV%‡:×|DVšH¹F&ý|×6 ²×zçZA “}™dY›Ö¥"ËÒÈØÅåe‚ÛÅ–!cÄõ-|ïѹ‚£"é‡jé(ò!ãégçKZ ™•IòL¦ì·÷q€¬Ã2" ¨‹8(] ÅjUƒè|›…›arn‘£6³€FC™i”Œ•W‚Ë6<œ.YVP¯G{sÖMCT u† >Ä$6ѶìÍR&·ý­Ì(|è6ã)LJaúJ ³¬Û q¼áór`³z‰­‡×–FrX&2NçàRh.Ö©¿yµª|¢ÊŒ‘Ø;ІMOZÀÌ 4ãœþ%WðýÞç«7k¸øsÎTŽÑ°X¦Ò¿óæ!¾ hkÐmZ(‹D}ÇÒy2“íyQpy~AUU‰d‚à¡™7Ÿ{–Þù=~ó­/òƒOÞã+×,_¾©‰â÷ïÝæÕã}šuη^³Ü»ÿzxÜñ•—¿Ìg…‘)iïg‘V¬tØ™! b*"¦–E "Ej}0^ÿ+ï½r‘f±¤ÔÅ@"ÑÃ&±«K=þ]U%MÓ¢€²È¨û€É ùõ‚³³Ó„ø8Ò$ƒÖœÕ-3 ¥~ºŽà¼ö\+>å<íƘÌæ½[˜Éš¹zíÒÆh»/òM`Ž1Rª$sj"ôa°±K‚!# âêƵåÑyÍ^©9_9ŒˆTö3‘ŒµÌ(‰üÇ¿úÛü7ÿûÿÀ¯%çÖøäñ¾ô œ tmƒÌKÏÍA‘ï~½âñeƒ/,붡aFk;ŠÙnÅBšÀpÎq¹\óaÝñÚ,‘¥B «Y†žÆ7ܘ£´æàà€ËÓ nÙ a3œð¼|íeQ¡\ ÆkŽÍ!/O©3E¿¾Àh̓“{¼\͉]ƒÒ†fÝ’e߸~“¿ºû€»í]^8¾ÅÏ1+ [(²BpûÎ T†-4ËÇ÷˜íQ¯»´' ±™j¥Ý:óâlH)òiLÂB²^.Y-Î)ö=Ûûd«lÜܽ›~þ85]?Ó{9Vjö© ñWæd6½CÛ• ìäúA¤i„œtï|B<ƪÞ9GY•å ÁáãÃÓÖü”T%„ ÷Še½þH{¯'É®;Ïïsì5™YYU]ÕÝh˜@€t »»œ531+…ô =èÁ¿¡g=J IZ­BÒL µœáÌ9ô@ø¶U]Ué®=FçÞ̬8;ʈŽn4²³nÞ{Îù¹¯AD˜L&{ß- c“Œ¾kR±Z­PJ1›–‰êÂÖdG ½­°K³ýÌŸÚ5ßC ˲ÁÙëú^OŠL½K j1»÷a!ê›ôoäÏhL÷.™:§kßçþã÷Ñå)‡‰0‘fsµJÑJ’YM‘[ŒNŠLbïÈR`­Æj…5Š¢°d…!Ë ZA¦!3Š\ÁT r#“¼™ƒi 3ÊÞ®mi£!WE*p…Ö–Þ÷(c°V£I ®(Ϭ̰F ù˜è:bW­u]‹6öÚMŒ1͵‚‰UÉ])&n÷þb’R T$W03cr#¨ÛˆÉ}‚˜’Â2 µK­áRŠTi#|!˜X!EjùÁŠÓ¿Å\'ãôHB&G<…)‘R¥¾’ô]‹”š¦é('ÌÊ9yžcµÁyÍÇ—ŠžÖ÷Øôeø»w/ùâígyýÅW9(yáæËØ鳜¯Þ'šÖ{É­jV6§´–yîytõ.¿úhÅó'³!s÷8'rh»êHó)Õà§"¥hÃ<'½!½'Ž•ª¸– H9¨„µ5U•Sù%]o°e áz{oÇŒ­íñP«Û†%“Lâ]Ïjµ!vmª”c¢ð%oO¾?¯{Ûþ“h軆¦Þ'Zhžõz1–NÖÕ†Ù´ãÎͯ" A±¨:ŽopõäŠ(’åhZo}Ò2×)0o“Ô˜ð®mìD;\×'žl×Ñõ=J[´IɉI«9Ù’ŽÕZÄ{7HÎþŽñÙSôöb  ¥•þ.Ñ{úkIoƒGD!QÚ`´"xOÛv4uE–ç -u)½÷(©±v§'-„œ°Ø ùŒ?#µµC²Ó1‰ªˆTîQ¯j…Hç¿ÌR¥¢±iŒt}É BסL–ºŸ¶¤ï;ª¦A¨TKeðÑ' ©wø¾'Ï‹ÝúöB*bI4„Úl›B$‘¨àRÅŸÙÀ£¯=íÉ妦,r,i‰»shüŽ]xçÍöµ—ÞøïþüÛûjÓ1+Å;!` Ü­ë%%m/)K¹UÃ{úºÇ뛈ÈËφÿé»ïbÌGå¼ýà!GFs¶Xr4-È„¤ižôž,ËøÍü³×^ć ·•@:…ï<¿Z]Òº€Ž’³ÍšPæaøéƒé¢ä¬mÑ™ááå%ÕdB/Ÿ=<¦h0yžo«U¥B ŽNŽi›6°¾¦oZNçÇ”EI³i¨›–/¼ø*åŒG7¸ÿè1®÷L'%EÎ%€4<ém";þ;­M¢2© ÒºÔ&±xÒXsÇŸß~oÊõýã‡}‰H¢ûÝ®qï~â bÓ;‡j7ª‘‰[¬ÅyOÓTô›$|Ç”¶¡8<˜¢”§i*”ïvç|×uˆXm“zïÝÀ4Ð× 6’z£Òšªªëgøÿ릥ºÖêMb{í'OZ >úùߢþù}ëûgÂ,›2+¦´ç£û˜ÝàδÂΞ§¯œˆ˜Ðt™Iq™ «GW©ñ8H‹*¦9df ¹µäÖ`I9IdžÃí2ð¿þ{b÷s.Ï?âó/–=à•£CDŒü‡Ÿþ=Ï?ó ¶°d)³óÞSf70Ï’ `bh³K&…æ9 Ì&Ù&Ohñ¾ëQ"2›–™&3PX‰Ñ H*8‘4·˜Pf FEr)ìH䇺ôAÒzÒ W¤‰CÞÇ)òH{*êqqª€ Š²ðx/*òþG?ÄÖoóÜtÅ­ãc{šª”É,o‰BÐõuSÓûßôLçG´ÍCäDI>|²`>+¹ûÜ—ÈTªh%Óƒ’WŽoòpùN ~öðŠS5%˜ˆ³‚ËG?dbŠÒ¹€±†Íf³¨ÙtkÞ[Üq‡JœšwÉfw9ÌKDôxŸ6·2'Tâe?µwàŠxŸ@c©“)5Øôœ #è}¢þx‘ô±‰`µBá0&Q„¼TÛŸc¼¶¶ Ó¹›åôž$M¨"³‰åÁý‡L§³„=pž(4]µ&Ë̵ÏÙföB\“8þ{ÕïÓ~úû*%©œ¤õŸœîß³#ëªK£ïŽC ¤JªwŽdFb Og‹.•$™±ôÀ9O­ô´†CL³dDHH`S·Hci6J«‡g]]lüåDbüÁç_EO¾Â›¿ü%¿÷¥çXöég=©ZúžŸ],ˆ&p®¾ÈÉá)ñê8¸køÁ“GÜo*ŒÍ©]ÏZ“‚˺沭™äsnÌN(tÁóÇÏ°îknÌø|^ÐTuÛ2;˜Ñ6í´cD(ÍÇÝãøÆ1±÷|xï—ë Žæs´±Xm9žÏ¹sã”åÕ’è®Î ÀEµâÁ¦BÕas¥qö€›åÿêŸý·”½db5ç‹ë^pÿþ=”)ÈŠY’nLƒP„2Û Ä kØÎÓþð½Û2 ¼÷[¹wéà÷½#Ë‹¡˜ƒ¬º¦¨øtpÞÇ\lW\¼®ÐøôšŸë†ºV™‹”‹Q"EH*ƒÒà|êêØÁAn7WN‰„TdćŽQÈgdK•wß÷CB£‡Àœ¢pN#`9ͦ!F‘:%Bc–u½C ªõ‚ÉtŠð»îO¤ª*ê: • Ñ!u†Ô:‰‰˜,)²Åt ÉŒD§qîP2hR0ðÐG1-"]×Ó;f÷ …)¡Ú%ÐOÿ.yçÇßC}í_zãÿà(©è\ÇÅæU”¸¾c¹ZqÙ]pxü,}+ðq‡ÚÝHב»#ÀåéVÊðD)”`’¥¹ªôpûø.jýw5ëú>Þ@ãÎhêxñ00›ÝŇÀ‘‘j ¯(…ó‘̦ìHÒV™IJC#?WDϤÌÐbpsŠýh€\9סmÁE]HÀÛBA™b”Ã&&2j·P÷ÕÊž®tÆ{2¾žæ«î*!1iÁåfÁjý#nÚ ¶\­kTnS¥RÆ™„ã%7槔لédŠÕ–¶­P™¡ˆ'6£®:>Z7?¡´'Ü-²yÀãË+^œÏ¨UCˆ7On2-§XSoÚÔ¶Ø}ç8š§Y®‘4Ë3îf:ñç•æýåeŽðûr®É”ÃhÃÅù9} ô¶ã³w_EÅȬHúFVëjË”¸ñ¡á ÏÑ2ç-Ñóh±â™IÁ{ggÌg€@¨ázTê|*|2ê;´¶[ê¯'©DƘ·nTvCÕZÓ»›í’jA$ô-]×#ƒ8ŒÞ^pê4¥ïØ÷ݧ&Ô1&ÇÀDUëÙl*\S{Ü¿ç¿ýñ÷Pü‡ß|ãOÿü;Xc¹Z,XojÖMÍÑd‚‹žR)ŠùKï‰Bpcª¨ëÄ·‹BlõI£L(…âȽ!¡ÛBäÆ$!ø$ë$7i5H{‡¿ó ¤rÜ´†YŒDyòøœ·Ÿœóý·s¯ñ¬–?æJr·„¬(©ëMÈu²ìú=€Ö¬†¢°H"!ôÌ E¦Ó\`L ÈÐs8ÍÉ5dZPAiÆ ¬‰‘RôLsEiRhšîš3ÑþBúÐ’CUŸ¨â´Ä8œ¤Ÿk²ˆÁsÿìoyÁjªªç¬í(§Ó„J 9ãðP¦«hºš®mY‡– IˆžceØx8¯ŽçG›ˆô*FŽŠ ±­XoÖdzƒi„’…å³Gw RI®ÖKªnCÛ7,—‹‘©‰V’6*¾ðì”zsåæC®–ïqëôEz§áü»Œæ^)˜ÏøèüŠ‡WUÝ%g)±FsTPL¦3Œ°”y¹ÕRˆÀºÞpVo8:ºÅÞ—éLs:)`ѧŸDLz±š¯¼ô9úÞñò—°À´8`µØ PÔ]ͦÚPN&|ôø>_zõssÎ.žÁ3儳®c=ÏÞyžûpë䀬{Œó¿a)^@nÒJVË¡³A !IËŽbÛ (e‘cM9Vu‹ºm“Ìñž¡ÍŠ­hN[W©-ktZ@O ÷ìWÉû‰áþZ“–-Ïz¯ŠÞׂ!ÐUËd¶Ñ'„´÷{ï„e¡h] Š€BâzOÛö黶Î\B*ªMKLœAŒÂ–,yÃ0BÙ¤4Z'䶴R*¤Ø̃Ã(A‘ÄpÞ#­Móo×#M†±ßCô Ì%ØLã}"u—DLeœë|å‰&SGuĤ-œØ:ËGË F ‹¶©ÐJnÑõ.²¢$,kÙ)]¦ª?m¹wò=Ô7¿ýÕ7~ÿ÷¿Npž¢(¨\ÅaYÚ–ÇMµÔòTª–æE²Š“r·³L2UɈŒŽ6J´HñA."ó\â†B^É4s[à¹ÑÞz…¹®¨ú†‡Õ†ªî°eÎ$ëùâqÇ—Ê+¦ÚËw³»—´M‹Ê ¤Ê`3An%JDtŒÌ& ;F>µA4I¸ªt–\GFq¤X%ÈTrSÉ­Àj½íÄZ£}ˆŒÖO«~ío‚Hˆè™X‰&Ò…óžÃ‰F„˜ŽÿçÍðÏo/Vô ¬1D’ϧV;å¶Ú1m¾“IÉ !p>2/ îU5Ü<9M’¦Ä­š(”²[d¨Ò’ª®Ðv z„$Ú²X-"ðB–s¶©ñ]àèèˆÌ&íÙ—p”''¥ ¿x\ò÷ïÞç ÏÜùDÏv!§–¾5 $¨tŸ‹l[<Û{'F$ÚÎÅjI‘１ÅðYbø›ñg„Ç"µ}¯ÐxUŠY–2a7Ì©Ä5)Xb²þÔZÓõmDïcØeðR)J»kËí‘DëR¡ÇdYr‘RƒZܧÌÜeðë6àÙQ/þ±Ö¿R‚ºM@¬ª®RÓöžbbS+ß)2å‘Þs¾ÜPytöPáÞ{º®c2Éý‡•’«ðQ໎®íÚ&ïÞ¾gµ\³©;‚H:yn÷*£ëë~ÿÏc PBóêÝ/ò×?{—‡ë†W_ÍèÍïó{w¾Í^ùS¾ðâwøÊ«ÿ‚»·¾ÉÙküðKl¾FÉTy(©¶{@JIÕm¨»ç›Å|ηæ7ùÕ£K¦§Ç较_–k¢’¡˜M“¼¦à"ëzÍ£³G˜A&ôüÉ9Ï>ÿ,¡ë!€Î-«Í†e×±ì#"ŠC¦å×{\püö¾â«w_çjÕ°¬ÖljG9;Üòd…Lݽñ΄’(LŸ4Ô}ïè¼CÚ¢Düà>§tò"îún0gi“òV5µ? ´ëþóø´V÷ø|žâcÀjë5‘ä/±¤Z©cì½hCðÌšDÉ“©m×Ñô-ÁG”6„à('J \ß ÏtLvÖ˜ ­ªÙ®ë¶x¢§Ý£¶ß®%µF›­F¸ªáÜêºIÿ®%#»Ï‰´m Ã÷tΡÍøµÝäûëA;A›],ˆcŸpE‘¡†î‡ï»T@Z5ñÖµ)€;Ïû?ý[Ô×^ÿâÿîßýk¬Ð\^^±\­éÜÛ,9=¼‰Î2Lÿ˜Ð?À» ™¡(,e®(µ`n#Š4³•I©#:S(9´iÓû8. ÷5µƒÂ&õ1´œk¡?CI‰ÉgÍY.¯(tN«¾g" ¥ˆô\q4¿³´˜d‚™c!ɼd r%Q"pXJJá™hÁ¦ÌKEX=áæ9#(d R'1 £dj‰*…Œ‰àcĹ!’´hÓù­­ã'ÚÙb é7!"Ç¥DFBnS‘!¤Žƒ·îßçîô#ÖMƒÔš‡'Tm"Ék¥ÑrfIU jW¨ÚŽ2¤ªðþæe JFšfCYLÓBƒA*>IÖÀÅâ‚€£íZr[°©*ªfC^æœdï^]au–ÐÙEIšGN ‡Š¯ ÷³'üù·¿ÎgïÜÆyû§·=…©kÓ!'”¢w1­ö–#¥žž|0o÷{#„ô¾tƒ«¶I\}pÄÞ±Ü4ômÃÁl Ã=O·D¤´©#4ªÈ/¡YmÈŠ‚MÝÒ…ÄË&2( ”XÔÖ \;aþ!©ã:~{€ .¤Î•¶$I×'n¥=«Npqµ¤ aòk¾À.˜–†ºNí8)B êf˜“>HªºEÈ@žM‘Y†Ðç’~q‘í}®H‰(b×%¯9ÆHPp(%¯<÷"_¼óu>wúU^¾}L×µL²£Ów 1a>ûÜKÜ=ùñóK&v™tïeÜ¢ù?~ø1QDl^&”³Ü¯:âDr‡ÈOç<î:ž¿u‚hZz“\£Pƒíj¤®[:z¦ó“¼DkÍd:!³–8 ¿Ï¯..Dm¹urM†B¢•N‘ó;¼óñoø̳Ÿá½?äðøëºM4ÀÒœs‹Ë¹0ÇÖ¨ó¥u°iâÐrMDŽ4Z3Æâ]G^”ƒ€ÈÎýé–ê>êi*á'‚Û¤ÓµŠ-/X„›— $e9ÙSk³A1¹_ ©’:¡Œ¸AlJHIT"-!ÑÆ AAŒÉémäS'|º†ºÚlƒºöÝúÛá©UŸªÍt ’¦©·{Ùšä'í½GjC½I–žìU£çõXèÄÐ'ÉM™Î¥$R[¶NVŸÒú—ãCÍ\ ¡­”âò✮m8˜YCV©ÓLbå¤D!í:k3~õw‰zýÛ_~ã«_ýRH..\áXáѦ©2Q‚õæ ï!Ü¿º÷·î½Ë“åûœÜxŽ¿úÙÿÍÏ>¼äõg_HF îBÄQŒ©5…mÍbÒ9Íg燉„$ÓŠ'—geÉ43L• ŽÜJ cq}Ŧ½ä§÷>÷ì)ÞõÏ¥ïÉ ÃÔzfJç*ÅBʼ£äZ@LªC&ËÓ B¤¬–á=éÊ䶢Žª®G+“(É„NYd|jS gJ$„$2ËÕ ->Ы†GTEè?|çWÜ=8gµXµ†ÎÓºŽ‡7Xo6X%i6kÈ,Yô8%ñÑácd–[N¬æÁ¦¦U#wŠVu²–ÕzE”;+8!ÄÞ‘ì)»6¡r›®¦ë[çǬk*ß"QN !&½nÙ㕆¨“¯ˆ|ñËßÁ9KŒz»ðÿ±™äØÚ¾/$k†gˈV!ÍG!Á ècXøŸ¿ÿ=^>~Àÿõóyõös UrÀC¶?€V™•”Z`´`]õ˜Ån«çÍf“ª™&9™õ>’Öu‹ÒŠÌ$0YÛ¶ôÛÒªÆ@´µ}‚Îõc Êdj7g‚ † ÄvÍ%ŽhœqÎ3J±þúKPÕ CÀ¹hb Ôõ/K:/ÁN®‰Œ¯6ÏéVW´}Ü"ŠE„¶O3úÑ¿WJIˆ2¹ÑY‹ï]blhA#ó¸èZG‘›D­ãNØK^£ €0ÉI%í}×{L– )Ë€4‰–Ñ|õå—¹súeVÄæc¤JÚ¦m8=9e³ZctŽ‹eÕåŠ'Që¤äTATšÐ9Ú®áÎÛh¥XmÖ”³‚\ç\.Ì&SÚ®Å;O×ö ¿|ûWD«‰1pRN¹W­PÒ’Ù¤ªbÀHÉ­ù%ÏÞT,ý‹(Y¬*ªA_]iK¾gô© Àiûn{Pk­“YO9I3X"Ƥ®•ï{”Ɇ "· ·ýÏu®Kç«Þ%Ëûí㧫èñ¿ëu¡c [¬‚”#gzÄ,$ákÊß ²°Z ²Ì¢µ$³«€XŠÝXJéÄ›d•ëØlÖt½'Ï‹€h;·¥3ï“J×6´]?èè×,®¸èÉËœMU!¥o*ŒÁ›l]c@L¿RÛ\Ù¡ "&ÊY|ÊMëéû•«¤ê'@[Ø·§îlè\µMGžg‰ž5ü»]Â$©ÚàÝŸü êßxíÿòßþË5M¨Y†È¤(Y×k&Å <Ë •âvžsµYâXóêÍæ67ïp(×ÌÔ’í1'¬H‘„92)˜CUw’mRÀ½åOÎ~È\Ù­Q„s‡YµÇEÎȵ&3–çŽN“ÜÞ‰bÝ>ÀºGTëø›_¿ËígŸã½ó ~ñÖ÷yñö]¢ˆ!(Ž‡RˆtŸjé÷‰@#.xÚhh;Iž;š\8<ÉÍfÿ`FŒCõž$&ìè¶/) ßýÙ_ñõ;‚§œbUÁt:CkÃåò’“ù)wÌð}Çíi†ï$³LSÕ-G…ED‰3’‚ÀIYC‡’šªw‰Ÿ]ßm½_wßS ¤"Ïr´¶Lò’édŠˆI¾mDH”‰à“@‡ë<ïŸË/Q8Êé I×YˆOlüü% z¬#½—[å¹QÄm+X!xÿê1ÿðÖ÷YmÞC¹G|î–aµØÜ}nÝøÒ¶i‘ Oã€BKz˜É{2“*§€¤ï’¹ÈØ~LÞÜIk=µȬF«,’2 Šë¾G¶n9ûIצq‹4Iªó ›±©u2Áv42Þ²¹õ䙢°Pwž]y}Ý&StýNaD¡ÇUÛL¶]`+G¸m ¨»Ô¢”{´Îíª«‘zÐQã…–Ÿ>°YÕÈ(‰Ap±j“) æú¡öô¾_M]ïx¥ŸúJmøgç‡Ü¸õ%î?x)%“rJ×öDG‡Çô]¢«d“-Q ‚ÜMéB ׆—Ÿ{ÒäHg—K_<`Z–|ðè.Ÿp01+'ô$>sG‡VｊôtmG1¢ñeà7ùãoü×üò£sŽ ÃÅåC4† s@ÊäK½õá–;Ž¯1†vð €AÉJkbL¼c„Ø¢Œ“§s–PÍz×õ¹^  ­ë®qŸ–¤ÿÝuÖêºÞ®“ñ³Ç :¶€è7=Û4æLݪt iF˜šDaTÇ$b5:3m6¼‰sm2:(ó"‰ç ô(kÍ5dwËË&/ zç0&#+KÚ¾'A”Šfµ¤('»ñÊÛ.Û–úVèpXŸ£ÉÎxoGǪýu=ú;‡0šçì :„¶):È­%„ô¼/..¶ržãýˆ"[?øÙ÷ÓÌùÏþì;,7K‚„6D&³ð0™N¸xòˆÓÓ›(ߣ¤ ׊£ƒÎ×Wt]ËÌXªÎsrr ÜÇDù,d† Œ Š 3o‘ŒŒ¨ÜãB$ˆÀ/>ü€Ûù=ò=êÕk-“h›Tmͦjñª®bjsn̹Ø,ÙT&ö¬ë /ß,ÑîVµüöqÏË·_JÒkŸ²8»®ÅfÙ'[ÒÑ¡…@¹6Í0•Â;—x¤q¸Ö(Qbt!u Ævä¼Z˜1É‘V±CiIŒ=RD„|ÿ7ï!üÏùìqFi½^_am†–)™ÎE`½¹àæ¤$4ežZ@¹U”h¼wL´!Ó‰ zO#"‡EÁ©- 8Z ÚTdÊ&©Ó¡Ú‹ÃBÒ* %Ƚóh¥É³‚¢(ÐÚ$Ax!PzÊ­Yƒ6ñ}…â»oþŒ—Ÿ}õÚ‚ý§¾„H•±U’Ò@™%dwê0ì o$é·>x“¯=7娰•ùÖfüâì6¯Ü<'™TDð ‹åŠ‹JrXª”Ùó¦>$‘ÃAäƒoiú.¡•«Š"ωÎ#Ø,#³†fSÓw-“I±•õ]a !Ôô+%ÕéÐÜæ4Ÿ˜d°ØDšÞÑGÅñdf“éÆÔD6}ÂJ é&Y&’È…ÜùÞŽJSY–-UŸZ*0µ‘UÕ¦dK€LíN‰^Aë>%ᨩ;GÓÖdF#” ê:ª®GjMã ë|òDÄU5Þyt€Æ{z8Ì3V]‹Žàz>¼|Ègn¿œnŒ lzÅßû u÷õâ,ž¼GÕ<Àµ÷9Îë¤IMH1ê÷¬ú–^¬HL1Ó¸A¬¤Ú4\Õ…e–kJ©ÈôÑ%©Êõ‚/ùOáwWqmÛüNK?'à׿ˢz‡µË˜O¦dæ:Ïow¸Œ\²&0x2«>Ò¨ÈOÞú9ï²\Þã>|½'÷íû¼8ßa aT+‚ˆÙH¿ Œ”c,y^ð`]±i=Ó,ƒè)Ðô" b"¿#%õºÁXËDDðÔ]C¦5UËÁô€Ö7X=ª¢ß#9ˆ­6 êfEžO×ë°R Γ•9¿üpÃé¡&†1öÜ9ÊÉŠç¶m£ÿܽÿŠ{™öþKOŸI—ïs˜kFÏ×"o?nøüó/l³òmèQ˜$uÚòÒrvvF%·¦šµS4uE0v˜OîŸ%Þ£i2&“)›ªÂà›ÙÄÃ& ¬¥È ‚QVÐ6I[{¿2ù´9ßø÷éZA„ˆ']í1Bp¾‰Lt²jmSá’*Ž¨ÛdˆÐwxè)®«r°tl9™³â$y†Ú¢Ë͆MÓ±©*”6Ì&I °"©mi;€÷vÝirzhºm3LV`•I–Ò8¯‘Æл@ÐoQö;óñP³YÆzµÄÖ±¿ë5Þ§>ž?ù&ÿñ7¿æöÔŒa±:GÚÝwß I—š@ ‚ÓÙ!— tn9[>¡4–õzÃÕr¾é¸uz3´=Ï/¤@³ÑJq¢JîŸUÝ:䇿|ëõÿÛÞ¼&cé™Õ<~|†6rhG›ÁX'ƈkê„Þ+¤”äY¶‰™AУ^-’TiC÷¦K*]ÆàœÿDàHc•ºß:½ŽÜ¹Â©}H'EÈk”[úb–m“65x§¹o:0vzÜ»k©Qû×8~æb]€ùl6Ø‹¤*©w çŽç,é:6ˆÄÆ0Z‘¬WPS_Í õ®41v¸¾tÈ™ýôuÁÞI/v—0)[‚P[•³1!ÇcBHÔßý}OŠ™@b:}¤õ"ÓTMm|ðÓ¿A}é+Ÿãõ?|‰Ép®§®+–>"­¢ˆ ºUÎP!rå:N¦ s“¡X­™8Ê .ÖwŽèš¬ëGtõÇØþ1§Së*|×3Ï4k™kC@r½²"!ÚŒ6X¥1ÆRd9Þ÷¸®ÃGOT<™¼tãr›q0;âѽ‡œWÇG·øù¯Üyùwnt7€)úè˜AÇoï¿O–Yúà°6ãÁƒûdyF¦-ç—ôу÷£’'¶ÄãcböGüëoü SÍqÓ{ÎW '‡,¡‡åzMQtnƒ¹„_ˆú½µlöR‡Áf 5.ˆ\œ=DC»Y“MÒ¸«o›ä¬4ÌnÓ+l[ï“û‘Ãlyï‰y¤ÖžÂuí.` 1˜Ó˜AEË aæm¶Oœí®k·4©-„@£€-°L¤ùîx½[„¶N FÛû$RõT'sÇá–È1©×ßWh›Pß&Kt%®SÈŒ1¸¾E ŒeRÒ´eÙDd 4"××p1’!È Ep!™YIðÙAAtÕV«mšm'H2Ø`nƒ¾! o’*Î2›Ô/‰TM‡”Š÷ÿá¯Q¯}óËoü›ï|›Ç7hÛ‡gSû¬©*®œ£o{LQPwó¡|8Ól6h%©š–û› AÁ$›&D_ì‘Bñx}†v·ó‚k(²’PwØ9߬È˯çñRné6ÆfYÎÔLiº ^ÂAf9ȸÿè1ï=~H¥%'·n!´àÕ—ÿ8y"ÿŽ*®k‡¶¶jé£â»¿~³ù9…^0Í ˲¾ °9G¦æ÷®È³ûèöc.VosÆMnš¢´ð¿þðGØøªÍ¯øÑÿþ—¼ÿ“_ò‡ßx"U¨(('¢€åú‚‹jɱ<^]p§È™*É£åŠbZR¯®˜eI¯[–n*E¦áØHN­æ²éQ2$.kL&à ‡ùÉtŠè#çžN9÷¥Çes?T¶M×’e–U½DËÈ<ËXojTVb ÈÊmu,d¤nž;že |;ǯôywæ‚øð]îÞzç®oÄÿ?/ï;z©¸¸ÿrã±dƶÝðù!buäïÜ繓;ÈAæÀhh]D I–iŒçQ$šÇºI ™ý‚¢wžÇ÷>àòü7î¼°m:çXoÖL§ÓdÚ®5¡wøÞ±ª+Ö˲œã…a³iRÇG&h­M“ÐþûÜÊOïé§ýENú¶'è ¡5UÕb:ð”ÑX˜ØÈÄD¦™ ÆÜy°èq/9èϧŸÝôŽ<ωBc³¾¨©ZÏz]±X5ä“’Æ;|ðGϼ„ŒŽ¥!Ià@—*îªi蜣íû­ìèzy‰¶E»ÑŠ¬HsÓàzÌÀ›U¦ ¿ÝšD?J¿ÂV3{T1ÐV›õr}nýtõ ;zÖÌû.ÝËq=$!™4¦/î($}=w¹ ä½wTuͤȑ"&§³}Ъ¸®¼—~¶ÃMž[¬Ö×`ãˆܼ”H3𑦖®³!+Êm'a_{ø‚„-§ü“ÊwÀ`O<ÚWò·RcL¤ošõ‚ªuŒ´4³õlÛ®B:Ïü¸ÁiûD /$ÉYSðÞO¾‡úò·¾üÆüÞWP1}Èb½¦6G C™•c”¦Sc$‡‡GD×óNU1ÍK&s¬¶4]1ËǼ8#:OÝÖ<ªj6ÎsÑÔ4ÀͼಮȋÔÎ’âé ½»A—Õˆ ™e"ðLn(Š ÷ŸƒpØÜâ…!Ï’ÔÚÛÿ–\ßH¾Íq¢ÅÂ#<ô¡ááꊟ\!Ú_óÒ¬#³&!¹»–uŸ$üŒ1dyN&!:Oï.uGÉ‚®¾Çº}¦yÈ ó@èzú}ô˜ÅÙ¯}õ÷Ei1"§Ð†«fƒî7&;JAJ IDAT¨8Ô–“Ù÷sptL™Åéì€êrÁ“¦¢n6>² =…ÒF§Y³VŠ^@O¤Ô†ÅjÃa1¥Y ÜšL™iI ŽRY6ÛvWRßiª–ʵœ(Ë•ë™Ï°ÊâCâQUlÛ§§û&ïI÷7’Ú47§†ßû57ŽžÅ 0|Î~m =ýî¯h—ïpT¦,4°ã#“înZ6c¯8:|éýNÇ;¦ Á“þ|Õ –‰@`§®4¶ð¤”ô]ÏÏÿêcùñ[¼øúw®oÔ(išžÖÇAŽ´O*$:Tf“ðÍêâ*/é] ª®–^ôÞã|Hs+’ûÓŠzû¯kmHiZGˆGÊDQ`Ë"72Á¼HLÀ(>ùõ’|q¥øÐS÷ž¦n >ÖŒ1£q}ˆ‘Ì|ﶳ·§E+ƶ% 3M‘ÂcÕôlª%ž ©fhOº¨ÛžÆG6.Ò:A°Ú4Ô!u‚(cp6½OêJ £ß¢Ú…ôÂ1—šÿð·÷xáhÃã«Zx¼ë˜äSTìxÎh¾úòç(µ¥wŽ,3ø˜¸Í‡“”Jô³ºïÑ,Iêh›Ç‰.òNSqÑô<¹Ú`nñÝû/ó_|íËHxp8»XѺÀ“«UÛ¡ó)e–³Þ¬9??ÇõŽåâ’br°µÛú$(­iÚ–4ÚÛÉþö}OÓvdyï´Í“ù‚Rtm›l¯u§Y–£uzF™-ˆ1Í‘ÃhÞu'²3¸ð1¢M<ì½ju?±N­ëpú¾ß š‚¶ƒCXJ‚O²»!ÊA¬)&ïmßCXvmÇt2…x= Ïþ}!•,%Ñ£µ¬RŠ"Ï°ÖR÷ÉžR k!P69F¹¾e¶ÖŸ©c%äÎ÷zK/ºnLlB@èAý06Õ†Õr‰ó[`ó›¸v“ô†ä !0*2É3rkÎc´FD± ú1‚Q’Ì(ÞùÑwQ_{ýKoüá}•Ó£SÞùà=®HþÌN „‹Î¹Z_ẎÙüíz¼wlê ]Ûóàj‰0\<˸Ú\°©kr“Ót Íê›Y²"çªóD¸}ã61F–¾Å˜Ä?˳ìÚ‚b`ðÞQW…‘’‹«+–UÏÇW—„LðøÉŠìà„²Ì’zÔÜ(ð€nñÿÃߦ<˜qó #“Šÿñûÿž[<â°ì81 Æx`àH ‡PôPu-.ôd&cjÒ!w¶¾É½ ÁÍ;7Ȭ×ò,yžQ”³“^}þõ´ZôådÆÙùŽKEˆ‚ùÔz¨ë–'‹ ᨂã$7\-7¸Þ±r=vZÐ Zœg>™‚÷¸A*OJIÔm4ͺf6™ð~}ÁófFçý«j[zY4 qðíšži9Ãùž©Éøx}E‘gLŠ)Þ%!)“-ŸP‘Ÿ¾½à¹“é6놤ª¼GíÉA‚Ð=D˜çPZ$Ôì§EßÿÄ+HÏÿùã7ùúiÃᤠ¨J+|pCk}w=FLñ Zî,…L5®ô>PZEצ&;4ö¾,­VŠûïü’úâ/~ó_n7ªR*ÑÉÔ`†â=uÛ¥M(’Ìå|V²\\±Zo˜Íéz7hV'J‡å%]ÐÒ‚׬ýö¦OPn¤ í=]×ÓøÔJ߬W(©Ð&ú¦F¤gðTE.E ˜ëºÅØlS ¬75®OkÉXK]×iö;ZI¸']ã8kÜGïÏK÷uËӽʑRbÒ:nºŽÕ¦Fj“lE¤ï®k٬ה³b4ôÚ.%}¹M÷µîÈÛ{±Qò­Ï¿ÊO?þ7˜‡ÌNX´K¾txBžËË NOO·@ Õ¦¢ =wŸ{Ž·?xMSAŒxÓ<ã㪡q÷W+ÖέÁIIšÃé!_yå_q:ŸâCäÑeETš¨’øFU5ƒ«TK´D·ááã náàø­“.ö¶™*‰O)ùò킹¸¤®îSm>æ3§º®ÇdK­>þ?Öޤɲó>óû½Ó™îsU¡€ÂH€H h”ØRw›’;¢í¶½ëWvøsð+8ÂáöÒöÂÑŽP¸ÕrØn‰-·,Š’Eq‚ 5ätç3¼“ï97oEyáQ•™7OžáÿÃóä)¤e˜TcÚº¡µ mÛ’åð꣯ò[¯?ä'Ätdz£+y"ND–Ësʲ@´ ÿâ¿ÿ#>øÍ·™[Kí×¼5°?ÚK LëÈM ž¢Ê8U¼÷àU*“³\ÍÈrM¡5óåšÃªä(3Œ…D¹?AÝh@£°­cÞÕ¼<Þ'HAt!én Åy×"´Æz‹w““„ØØÑ:‡B#•HÆF–#…$úR¡}`4‡Ó)a±ž÷I¤i®P¾Éª5D©xöÙ˜}¸†)Ø=´'„5ð ´Šü›þï|ðºÁHD­•@iÉb5§µ-ïh6MBETªJñãOW¼v|‚Û¦ÑĀт 'aJZ^mdaÇêž=ûŒ³_ýŒ×¾ñû[¡ùa’ eGI\E’UãÒ`­ãéó³>š pQ°©ÛDJÒ¶´M’«ÌËï;Æ•FHRTg)ºø}®-åÙæ;Æ”¬[¨?¥JaÃÇÐÑoëõ· X¬[Kç%Ú$°ÊjÓÒØ6«ÑÄ’isVZÑuvð;%$W`£«|pŒIê/ÕEG„P ’a¢¤BjC^T˜¬ m-Öº¤ËŽ@kC^ŽˆÂ!D@Iu ù+Dª‚B& €Lí%p1òùùˆ©:G¨ÄP0oçœd9:x¼œòè¥W¨[Ë_ýäo˜N'<}ö”WÞx•‹‹‹”“T 韔^B¿¨Ç­Ã>ä«„¦{ûÌ—3ªQ…wp~ö·<õðð¥œn³¡^ÕhmíUT¾åñÏOù‹¿ø)ÏŸ^¤ f“âÉØ,K¦ãÆYäÙjA*SäHZïy|yŠ÷SäH¡X¬æTyA!RHwS×LÆãTþc-eY"¤àpoŸON5.‡ãV·¸‘‰qIô¥B™Ê™Æ‡€’&Õ6-/ÝçbyÉþÞAÊ‚`4FX¡¹_­Q”,×K„ˆ¬6+œ·a¶›W YdTÜ;ÙãÿâOøgßømˆ·õÓ*“Èþð/ÿ¥±]Çجøàõ=Þ}ÔÁ!…§^®Hroo-Ũ!ÅU(ŠÆñæþ9M¸ KÅ8lh0Î4µKèzÓ>†’²!; ÷ŽïáÚš®^‘•£-s˜ì!¤J¨R¡mp]ýûhšš:nÐ}JÄ{OS¯q(ÖMKÕt8Ûñ´n8>:@I¶9üÐ3J #±ÁºÄ‚ïˆDËÄ£žå©äEk•ØÊ$8Qúj1”R&²©‘:n=§½IEÓ4d=Hˆ‘¢,VHˆ¬’RN¶ë®[vÃÛïûü#Bl•yˆÉ³Ú]ô/ÛÚˆÉ+„¬—sDÝQT9Z*è[æËM2TBɈЊˆ½AÓ¼ýÖ—^çÇ¿ü3)}äG§ÏøÊÑ!ѹ„_¯ùÁ_ü5÷_€÷ŽbTòÉÇo½E|Hð3­ Ñ"¼rïµ´ öå}fô.&Ä6b¤FÖ-x›J4mGôg§Ï°²`ïø˜à“¬§R*‘ˆôìXCÛ ‹òn(·®×ì? +Çi£ÈRXq%œÊ¢ÚÖnk}³¬¼fpÆÈVŠ1ïù´Ù-« h-ý|žk¸~×uTUµ¥¯Ý®˜âº×™Ø¾vYãRIä¶ÿûoV+Ü…)¸¢ìtý8ÛÁ]i “ñˆ¦iÒ¢Ãøî³{ï­1¾sÜ|Ž®÷œ‡Å#J$ƒpp&@RönL‘ÇÞxßb&BÏ4)IÂB =.Xt?‡ç”R¢ënƒÎOBDµ5Ê*É’9Ç«ã=ÚfC Yþ&ŸÐŠTp1¯i{¦¯{û‡´{³©Sî¨Ûc¢s|Ý ¼ç•“‡4=óŒ’{÷°Áòüâ'Ç'Iˆ`Û.¿>c"í?88HD#â lðëÿ.öhCÓwÄís’cšW›f4©TmÜ …âûÿòßñ‹¿ùfÓP”9m“8S¾rÌwÿ“ßæÍ×]àh”ñæÁ ^ V³—ë%E‘q¼Àóõ%mãPeÆ´¡„BgšŸøÓÉ”¶Þ¥a³©1:•¤F_)5çÏ.)Ë‚ ¶{iD`±^£”Iù !Ø/3&QÐùT yæ^K¦5R†ÔÁUÁ//#/iImWXÛÐ5–ƒ“#| gCžŸ<Ÿñ¥G<½¼ä÷ßý..z4woΗHâòßòÞº—ÆM4\®œWhXÎϹ?ñÙbIŒ­Öwí|Ê&§°ŸdZñ³ç ^ÏÕÆQQ0Ê‚8ª†RÆ4ÉÑ 1>8À­.Qº@™ëå([2‡¢¹È9)GXõj*2²L³X¬úZq½¥ìûìÓOÑJ³xÈå|–‚z3ãøø˜T®’q:÷xЦ`a#1 &*q Ïfs‚£Ì>1x“‘¤ú1 Wà Ö¦ü¶Ö)=§šöÕ"£é:²üº†ïî¢=~kU¸¶°íz@i‘J4¤ƒw³ªÛõ ·d½´ Î ‚¬ ¾M’´ý"ïˆ4N’›t­µ…©„Dö—ž59þä{ö„ `2áZ‡$µØ9ªÉˆÖ5œLÐ(<ðüì9>Fª¼$O™©Àþ¼^o-h%J€°žh4øˆžÆ*joYÏŸ_Þ}5ðÉ)¼<LKEt–wë•"S9Ù¤"Ž#†MìðúË<—|p(8=ÿ3Þø¿ò½dÞþ !à‚çÿùÉŸóÖñœƒò„³Å)R'…ªÀÙŽûûcæ—k‚ãÃ~ ‘袉t=-$µ°üä³–o}õw‘ÖaÅu"|×—J ›FòæÄÝzÊ«üÛøà·¹dtx‚ó ´ÚN¶‹NtÜŸ–!p¸'Xº@·,hÛ–:ÆÞÚdùˆÅºIuœ£}ŒÑ4!’‘Sì3[uÛUˤ*Y9K àÛ4a7^Aˆj„w¡LOÍñB‘ÅΔÁC?7.V*/جZ¤Î8˜$!£’…?©4ªƒM³Ù.–»!ÃÉîtîP²ãc@+h›e®‡ÓœëŸS©«Ò)çÖ·É:ïYx‡–Š"SØnC“eT™€¨Yv‘£R2èn4"òí7Þa³|B&5÷O^áógÙÈœŸž²ð‘éþ>*x~ºœóîþz#B+|ˆè"çÇ§Ï Â°Þ¬9Ú³‰h¦ë‰sžÿè7ßEøĉŸH^Ò6™Œ9;=çàá#¼³}=®a’ñ«h—ç”ã1ZÛötŽ£VZ‹½rŸ6¸•ˆ0h"{ÙI±ìâšNÒ‡˜c¾Vl)`DŠj\…¨%ƒBÙÍn¸Î³Ð§ä]__wsÞ»uö»ÑH 1)¯óxßÃùɱ}ª¥çÈ4Ö6$ìÚFd¸NÝZ’ÕºE ƒb0ä×6È·½ZS¦ç(B¤MØvIQL$2žàSsÓ4©\Pjbô)µ}^4n÷–²¬è‚G‘˜KbLÉÓºë1ar:©jÅb± ªÆ©­#©/(ªœGÇ÷!D>Í1UÅ©µh#¨”âéfΣ¬àÉfÍt4bY/™LƬ×köF{xïY5 Êl„Ì2ò¨ød±@”%Z).Wdy‰mkœw3MiÛn+–òyI™# ŠTùÿסdOÝØ£|­s‰&Ï|¾`ïˆJ+æËÖuLIÉ„´¹cå¸ä›ÿäTeÉr½æµ/¿Bº®ÅÁZž<ÀùÈë/¿Êùós¤É©¦/W'XŸJJ./çLG#:gùѯþŽéÁ¥$¥±Ž+´SÄ(¸1©kEÅçÏO! ¤NÞLžÄª?¯p蘘”Ö. MˆÖG´Œ”UFÛ¥ð×zÏ×K²ã78Î<¯L-¨œ/K¤r¸èAE”ÐÌædÅ=´4ý! Ž¦iyó~Iç4ÿó÷ÿ˜þÝÌj)‘úv¨*:G! _|Y²Yy\ᶓ5zXmV™¦9MQâ—‹‰)ƒu3ß´°5£—þ!ßÙiYGO®²k÷^¶‰Óú hrý‘v¯)¥¤œì#•f}yÆÃwÞãr¾"¨T ³ë‘8/øÕ§Ïx0©ø×ÿ×òå/YþÏ¿=ÂÄç|ãÝÿ˜®ëÈó’#{f«]@èPÂñäù…QäyIQda($ÔuÓ{,YWëšDg0¥±ŽMg9¨J„tDïñ&1Ÿ ¯÷`¿àñ¬e!w†"Xº6ðü¼fd ªöÆRŽ .æ”Rdy¢ÒÔJ«ˆ4}rÛ@–'v:5Ê9¿¨ .iŒ›ì‘ð¶éXÎçLö&˜,]ï®PøÍ`ëYõÏïB`Ýt)˜ÏkÖÜ›à„Le mäã‡üË^ᕓɬ"S¶qL^Ã7§ a-Úhf äý}ÇKÍÇ— :4¹‹¼ýúY5+DžžÇ{A:x¬’¨¢wJkŽ&ÔOθÿòC¢ôîSoZ6›–ËçOQÐùµ÷ÚaÈ#4µˆD9»8M·غ݂’ŒI"vg ÞÌÝ^ß]m ×5èoz®ÃgÃóÝUiqóºƒç¿ëÑ÷æJݶ Jõ¥Nª^ïü®#Ejòíu†œïZ¾2’±0„²¥¸$Œ†Ý0ý§—RREÊכּLjÃ=bH@¾!¼|èÉL$2¤üxÀÑ»¯;cÐùŽËå‚U½f²?EIAÛ¶‘<­d†"×¼ø ¡þ”ƒñS¦ò’ÓÙœ‡÷Þé ’Š˜í,Ap×9t_éeÒ¨qÞ•¡ÓxŽ‰eHéd­o:Rb½OÌgY6’®Þ dµ–Uãé\ÀydzEMÝ8¢O¥wË•¥µP–cÎ/,W+ó9Fi‚· «Ð{äO°McV¹ÍE{ïÐ&§éì6Œ=l”1FêfÃdï­³ë›îsZàYOÀ3ä&·aq.¤2UVxÛ‘iCmSŠ,“)­%”à«_ååã÷YÅ—xõ•ßÆNÞƺŸ3Ò#F2U…gç{pu+’ÁuOùæ×[›ËÎÆ:l½CÉwÀ‚£È¹‘uÓ“ɘô®ëÒ~(¯<~)%sä¦çõŽlk¨?ú«ï£ÞÿÆ×¾÷­oþŽîs<= ,Jš¶é_.RH›/§Í†J)PŠ{F³ÉbuÞQäÖu¨Øךc!¢gZ¦¦¤©[Îë‡EÎ^–qh2:ײ_”"£µÞt–ů&,{^cçÛ”×4,Bé&“ÈµÒ ;òР©ó® êç—Ÿã\äpÿ˜ÕjIÐ:yùÊãV Åä€ÑÁóÙio)Y‘éd%S)è\ÇÆu”YÉr½àñGOøÕO>ákßz/oŒ&<8:áâòœº®999Á:GY•ÄàÈe «h£É¤&39®µíï3*K&ÕˆùrÁ¹·ìõ|¥“eæ»–&&iÀãÑí-ë(Èezߧ› ã¼"‘ئâö\¤<°U‚‘.X¯k>[-Y¹ô2•ÎøñSŇï:ò¢Bl™¿Ò Œ1$t¯ Œ'š¦éîtŽ)Dú`¬yeBüåÏɣÇ)l¹sÄð1òéÙ9Gê gb„"/iÚ6¡ H%8Ñ] MAUU=y†è'g¯Nã=íþû‰·cMü°È·.àâ @„ŒH.Ü HïÅg±<{Æï!¹L¤ôÁ;èÉD:›8çë^9xë>â+“œwª#>ó³^‘‹•›> ¦ÒM¢tžñžcLŽ69Ic=!¦¹\%¥Ää9›Æ¥ßíäÏò¼ÄÚ@UÎæ«–ucY¯7xÌVýÇC×u‰+]J.gsÊñ>óÕ:‰ƒä%yQ"¥¤nZʪLtŠ™¹FL¡¤"Ê˜è ‰dZÒ¹>7j[Êj|Íû¸Þô·‰U\×¢³üJa)uĵó[ë1ÂÑu 4(-z¢—¤ÙcD*A-Ê’‰1W{¼zï]½Ç÷þÖ›eÊ]7X)G”Ñpïþ+ ˆñ}õ욌 "¿8û˜·|^Á1©!yÁ¤Ì1V³Kž<9e~qA×Y\ˆ‰ Ldž÷锿޽—ç=¶©)ƤL“v½"ÓšÅùS¦û'©~7zÔvûòwçÚ¶²àl}wåzïÚ ïú¤Zì!žeWÏ2x§£˜ÖŠ²ÌˆÁáÃÕ¼ÔJöÞt좰Ó8¼Ü«ûßôòw†ô}ìCĨˆ IDATçRA‰%o®Ëkn™eª ²ý\Þ}Ï+¯;U"dE±‹/z:õ€L¼ûÛèq«º%D’ÏÜ5Pó<ïå€ýÖÓ·ÖòË¿þ>êw¿óÁ÷~ÿ?øG<¿<ƒõzƒŠLgìì1Ò§ó ŒÖUÎXjŒˆePÎáQ#دö±í†ã°_Ñ:#qÆHšºa% *ÉzÓRI‰~[ƒwQ×l| ¨ Û ¢`d$ûB± 1•›(Á¦mÑÎS·-^8r]ô@‘”q¶•¯Fjº®fÞÌ9°]‹†joÊz~Áû¯¾ÂìbÆyg™ìí3›òJ‘sÚlˆ.rœeÌê5U¦É9È3–]‡“‚·&,5¿ñî›èRž=yÊ[¯½Æ¨ÑÔ-Þ>yú9ãQE.²ÄNb™¹8¿LV¶õÔë Ÿ='Ë !™*M”IâÀvHÉ¢mPBR· óβ‘p˜eäBa;˼µ¬Ed4*È£àpïëífÍb¾BM7Θè)Z)>^Þ¹¯X®L¦S¬ë Ê­‡½Á³ * 1±Y uèZ6­Ã…žÀ¡÷äcH<àZHB¿ÑE©¤BÂW_ÿMþø/ÿœG“£bÊýêˆûðzÌL½Ç{_þ'÷ßãßüôg<¬:Zc’f¹Ì Ê#é8T‚ýò c¶cFÄH¦—ó OžžÑºŽ¶õ4.‚P˜¬$Ë ‚µ[A‰íXc Õç’0N×Ö©P:cqö„¶ž³Y¯ňÉþB*‚·h“ã½%q[ïóúÍd&í²¹Ýì“!L¿róãæF|³ß†póVàa纻!åa#³]‡VšªÈÈ&7 £oƒ…† 6¥¯Rk%h¬M ä>$= ݯj “žm ›M Þ÷2•×¥q9ð.!¨¯N-e¯vý½}ÿp©3¤ÖW¡sz’¦w")Eg·àæ#:/²Þ‘2«Üôé OÝ6h™"¿üë?Cýƒï|ó{¿óÍ÷898$(« $V*ABËÎ6)¹ZÍy¸êG»6 ÖÇH”}Ò;8î¦L³Dna{ÐD×YړшuÛôÈhÁD¥ðÀA•#•¢òŠ£*CzϼK…ö]·a¶¸d<žàcR ’B"•bS¯È¥Çw-ª)›MÍå|Ítÿ€ÅüœC)8?_àMF'“¼¤±-3Û2Ñ]tTEÎÖ”yòì¤à2ZTÛQd%"ÿðw¾Áù|N<ã"co:¡é,Ÿ=¡u–M[#”ÀÚŽÙrÉùâ‚ÓÅŒº©™o\®çX™˜fŠQI".FrÝó÷†¢)i¾÷ à809Î{Î75&3Hu—r”Î ZçÖR)çÏ5Ó½‚ãJд5Öµt®¥k[ʲ"“j ï<&3DYÕËĽ=xØ€u£™f…âÑIÆùùÏùÑçg<N5PdWš-®%ž¯:¾ôÖïôd,W^ÃÍ¥ñ‚eãéÚp 庀ÎãܬÅB\ǃ·¾²­‘ 1&™þZJJ6«"ËðÖs0šòêkïóƒ—N¾‹Î,!dHS$oIÚ6ô›³ºZà´¡ij´LyHg[œ³oqÞ¦K(¬õ=¢óJ*P÷uÅ˺£ÞløüéSfóQHòñ>^(¤ÎÈŠ’H ã%¶$Ež[êÆ›¹Æm×Òø@¾“§Ûm¿!ªTRV;˜”øà°6ì´ãˆÎk^m²¢Üz[Ãóì[Cù T½Èˆˆ”…AIAã…J¼Ëwß/V¿úÖû¼ôà7yùÁ{|´¨ødVò¿þ{¼sÿ% gFñõ—¿Æÿýw?eª×_ãÉ…ãxÜBRòéåˆGÇGÛ¼x¡ŠÈ¦õœÏ×,–5^çŒÇ{ø(&c½^B ¨FÛ´ˆHá)œµ´›)“bRð“å¬.ž§ªÉ™î±¿”Òx2ÉFj“Ó¶MßFW(ëdð©I¬_87®¼Ð]oô6 û®~ÜÍGD>wõëÍ{ߕþyýD>üð#6§Ÿóî»oñÿ4§³-Qõ`%¡¸\\ö”¤¤La÷ ‰F°j ‹pÞl˜èŒu[S ÍBtضA!FQ"ð>&AÈLÅÚ®A |„ãJSª ÛXZÀ©^ÔMmÙ« :×à„æIÝ2ÃËÓ‚Œž2aélKk›ÞzŒä&ë'Ýìè½H’e\®.ŸmµŸˆí h‘ûO’wŽ=N8fË LQð•ž,.IŒÜ/¨w&å®c€ÙfEYŒQ3ŒúpOŸêdž£Cì…L Èô ßóh+u=T·[æ3ɳFlóNÿãGoqüè­k£¤¤Ð`¥LÄ:MM–'©È˜+æuÍÙùŒ“7!Ï ÎТ(B>ƒèJ§¸Ò€ÖôdFÛÚ•Úõy±DÚYKVŒ‘Z£tBÊÞÃ}Î2Ër¼äh"–¡k–ªÚßRt>’Ù!±ýçôFéj]£´!Ï+@p¾X2É"Ae-Ðy ‚ Û2ëj°‚2Ë‘±M½Ì¶óg¡{³g؈¯ÆÃíÐb–e)œe•#BDÊ>ù~«¨ºyg¡¼ … \NÈ"¾õÖ[×ÆJÔãÒ=ÿé7ÿ9¿Õ?Ãó/þ[¾ûÞ!7 >}ü1ÿÞÞBôHtßàñ(#)«1ÕÁ}ÎOŸ’å]¯nŒI4y‰µW‚eU±òKò¢`¹\RM÷Q*£x0Þ¾ûà) äîþ±Íéïn‚) Eq¸Ú#×½f€ÛõÍ>ØmÏ›¡ï¡i8¤$½ŸJœ»^îpìFQ†ß]=SÚ´†qµ^α֧´›Hã}µ®Ó¹FY†’à³UîÛ·1…Ü/3ôxš6힎Ódyâð•é[%m­m>"E¢#–Þ{-ˆ08 7Ú‡>¢3¼ßnm¶x5B ºMË(×[¾~%“Q%„@[ï88¼Çãg—“ã,8ëJ%½Ë(Y¯×TeÉñÑ=d„£r¬^¢•FŒ$_ÿoóÒ£×z]Ou§…4ÐÅíæ"ƒ÷ÉSpŽ²];ßY‹¾Ññ¶Kôƒ/ú,†^¹¤Óìžc¤Ù¬›‹¾²(ífA@ ]ÃKr}˃º’HKÏý¿ýiE½˜òî{o`CÇÞt‚‘£½=´Ê˜­æ * :!¸\7(­hDàQU¢úºÚ>ÊÊ™ë™Âôed&£s©¦Ð+ÉóÅšQÞQ“hE3c)BF׶4>2 ,¹ìÑ™âñz‰ó”!3°7ó‹3xóžà^™ØžRÞQlÛm4™cH–dú´á¤h†D‚y‘ôË‚5.±<óÖD‘Q€Zf—kŽQ(n™“;GÝÕ(£pÁŠ€»Fq¸{œ¯$o¿r€¿}™[G‘ œ½*»ºóiAùµçô‡1š2‚ípARUóË£ªÚz ­4›†ÅªaÓv˜²êSŠº©ñ>±)uåI ›SŒžõ¦Þ¢xcŒ“+µh ñê­Å. ǹ®§œÐum(ŠSJ!úMb7ì¸Íµ{˨*À;&ãë’ÊÎzÝR–%u[³¶-e¦ñ‹gÉÈ5Ù–qlooB»\cªEQ M`½I Ãsnóu;^:p Ÿ°{\ËF{JĘòò2&‚¦ñ”Åõê&¢ù×»˜ƒ›Ÿý—ÿéÁõGÿÿùïýgüÁÛ'Ä­ ÎèEf˜â‘¹¡³­RÍòjµb\¥°õ|È*zT“™kT²»)ë`©«çÛÞûíõ®=Ûn?ïä©ïlã6¸kS¿kÃÞ=º®Û>WŒWõÄwÝo÷:»5×ÃÏMÓÉë¹±Ù;>€µžjŽÁó¾v ÒàÜ´-óËSB·Æ43|³Sw ýI9Ù‡Í}[cÊ Qö›Sò;ò Wl/éwö˜ï|û ¼ñÚCÚ`‰Î²_íÓÚÀ³ÓgäEN$¢…$*Ii™aštÎa;˲m8m:‚Š¨°3ÉdÞñÌyVÖc}D(Ã…ñl鹬 ûcÅDÏ\øŠ*<™LË€Aè¤($E"¶×Zs4‰ä6²`tÆd2I<Ç>ÑÒm6Ú¶¦ijŒÎp}ƒ’YHZÑÅÚž^:N×’ãq= !•c"–®g:R[Mà»wè¦mÂã­CÉ ,‹j f½ÅYûÈñ[¿M">Þ \¹66DdÓ:艤`» _•Wx¸^[Ÿ¾ž~ü3þêýyõkl½K!ZDZ—ЧÄdì¤ ÏS7Ö:¢4•÷ß'ôjï噬؎Åá„HQ¤Dë m ²¼Àä%u“ºŠ²ØzGu#mÌÎâ–6?G’8̲*¦bÄdI`ÀÚb Ñ‹¸1’q•¥h™PåËÕŠÌd8ëPZ£ó©ub@ÊFt1¥§œóìíOˆ‘¤`×ç!cŒ”¥Á‡4o]O„1,¾»aò®©ÉŠòZÞ ¯öcdŠ¢+ˆ!T/Ÿ¹ÛèÚnuÇÍ åö8¹½1ï*:¾õö—ÐH´Ô ä-#¾( ÆdÌ7“)p©dÓYÏf³a±˜qptD[¯)ÊÑöBL`£<H3†!º»_µWZlR ÛyÞáûÝ æ./x×kÞÍ•îF3îÚtïj³Ýû‡à·%DhŒ×š/zHál%¯$„cOÉéC2ÂLQ&Ço¸žLT´Î:\_;°tŶáåTé¶b“e©v9ú>ôö,!rPœÚÉÇÄ5?81ièàîµGö‚3C !¶ä\WäE ,Ö{> Rê³(æãÃþ)º®6±¥mæ«åxĪY19œe %y0Z±Y¯pF°i6¨¶á“'ŸQ½ñÕô¹ínyµóå2y1¾pÓáð·ªçšm›† 0 L×Ë€ Ôh&Ë8»8G)C½šñjî¨|Ǫnx¼©sˆñ¹aЦLT„J\Ë}{ÊÓÈ£¥Pw[‚ÀÖ²Õ=‡±Qç"•.8<~Àjµáx:æp2æ—?A“’¸‹‚z½"/J»ô^CTŽŠÌ7D V4J#¤¡î"7«x÷¥†}U' ‹ÏøWÏ2Žó—x˜¯QÚs|(¶ùú¤ “Ú ã1Õs_r,× `æ"«õŒƒýC‘Ùb†µBö(Ò®I °>×"U/;G$7Ia÷§Oá{–=(3¶K#6a‘©­ 9Ñðùå‚üð˜Î÷˜F”αÎ&ï8ÀT"2hDyR™kcmX À1ß. É äyAëÚ4E—꧳É-Ï»kû\¶÷46EZ(}И \èÚ†¶ß˜ÛfC‘ñ(ÇP`Œf=_€JZ¾›ÆnÓ"FiŠà£Py…ˆ© ´¡5mÛm•­”‡2ÏÙ„"}Žu×H1dv=§k}Ø·‘ïkw#g-M”Œ+÷qÛË6¢EOxãïÝqÓS¼Ù/Q$âA&R‹›×Ž^:,ÙÔ‘¨4§ub¶‹ÁAtyN×—žzï±Ön©C‡TCZÌo£Ü_ô/2:oz—"t÷ë‹<çý¼[ûÛ¶m’Ýnª~ëL ‘Žé>WÏu³]wŸ#…¯S®ÝßÝ|2@´B+ÅèhÊfÓÒl6©X©T)¡@eÁºÞëLïƒ£Ì º®ë-J2v‰vz̆Éz£Xõ«„€Ð‡¸·Ja2•hÅAáî>¹=nÒú%âuãD ’î==5ô„S[Ã)¢[ M×Ò†ÀáÞAwIúëóÓççدö0Z'+]r$&ÓŒGĽ;€f†ãb>gÏÍé$(48owyÂCÏVã«Åg8LÌÑÆ0ÜÉZ˺µ1ã û¹Ê˜Ïkœ³ùè#ÞÜ;fÖΆÎ+¬<$/*Î6¡à{¾_{+‡²Ûèƒfê¦nÙ?ÜãxrÀürA1*øüé)µ¯{V¤´°<1FÆã1³ùBê+ëêy;%ºÈý‘àW—'xz/O,U)x·X#|$È’GUΓõ’ï<Ôi9k1D×"ó"å"eB„ !X¯8k_:î¸X.#“P I¬gÂ#D{ýæ„|„!äšPÍé{ ŽŸŸi¾t/Œ$ƒ’BZTbhÚGËÏødÝm=™~ŠÞjßÄ7ð>¢¤b:Ù‡(ØNY»†÷½†WÀ¿ DäÚ0"¢cÀ6å‡ù€è®kú5xHßøÙ¬–UjscL˜T¢äµqÙ¶í¶ì×.wØ žñÑáðÁoEb†R+Sä×ÎSßþà½ïýÞï~@^fh!qåÞÑ û£1ãrĤ(¿´LˤÖ:Y€Œ‚ÙlÃZÞcïàðVÞ¨ijTèÈ|í*…öº–¨²-â®PwúÜ¢õíÏ1€Óù×5¼©×4Ï>ÁÛn»9™>Ô7„Š†6«d`*-q3§1Sb1á¤}Ʋ×ñîpEêè?{ÌÉKIÊNÉÄ…ýìô‹PTDçqž{ÏTg¸ºãó‹9)¦¤óð—Oö¨Å«ŽÒ´È¨9mÐÊqXy´‰ÄÐ[lÞs<Aç)Ê’A<“ÌpÞ+þn6áþ¨¦¶‚º†O7{|ñ¡b?ÌW3rRùŒ–†@‚îU¢šŒ>B¼>Þ§©kÚžNU ɲ]¡…¦09—cÞ9é@&¦¢¶­¹Ü¬p]GkÛT#*m»äDi¶Cô¬RU>oµ+Ú®ÝašŠTå„D3xÕôWŽ/¿ñ&"òOϱ]ìú°Qú—~–1þZŸÚ¤óòiÊÍÐjˆ)42+šÜêÆ¢3CÓ¤¼êxy¡™I±´ HŒÑdÙ€ŠOR™Z)¢l6+êÆâé¨òqR{3©LICžçdYÒFÏ´b”KŒ–¬×›­!í¶ IŠrB1šàb"‰*C˜F›Ä:–j]ª³X›Sï,ÕhüÂ~û™”H!1¹NF•qeȈ¾½„”lº€V‘Ôì¯BŒý¿)‰WaJ®o0Ü8ÿE‹ôÍqDÒlZ֚Φt6aDd³ÙpptL[¯ÐJS¯fdÅz€àÍûžé®î·íÚ[ˆÃ†æœ½†ÒnmÒ»!ìm¤77àôÏÂ@ r½Î8á(ô­kÏ~%Ò’aHèÃÞºŸWÂ/ ØÊ$/µ², ò¼JBç ¤wvÎbmGYxïH”£ˆH¥ 1 ²b¡€¬AôºÍ1xbðió’.|Ÿç¾9vÛ=Æ}dHí¾ OÐ{ÉW׉@H¹t•Rã"Û^ëÃþ)ê·¾ñÕïý³ÿ🠜Í.1¤Áñìô”<+QBõ f˃››’LKêõ†³ó9}Ÿý£ã[ºŽ7²†"ZrÅžì˜ÒpÉh[|n$É·ëß{ﶹ\\¢Ú5UsIUU”eÊYM§Ómã5MÄìÃ`YÈŠQ;#OÑßj·4ä®CJÉ/>þ„é~"`¨Û —‹ÂH„‰¬A+<’SP2ri;6d•!•âã3ÃÉ^ËkÓŽýQHÊ]Âe—¼jaèB@FA÷G#­8ªÆ¬êF&)¿Uโ:JJ3æÙÌ ³=&Žƒlõ×5@ä¤È!D\”Ä^‚-åA=ª0Yd”Š2gS7%ˆ¶C!øżâÃá#(Ål}‰ž“jÄÊÖ‰ðÄw„M½aî,•É9Ê4ÞzfÍŠQ1º£U­mÞ„LDƒ'B°j=ßøo¢œxa®ç®ãÅçE|„Ö“ÊN¼Hjgw,ÌÝfÅ¿ýþkFûÇŒÉeÄÚŽÆ%­h¥4EYÑ4mo´Rm.Ø?Üß²Ô,—Ëí9yžÓ4 \C©!‡ˆ0—{ŒÝ’Ù\ñ7î4önXñ桤âÒY:ÛPôáãÌEZïy ­ôÈèx­š`C˳®FÍOŸ(„ã‹/9Z'H•Ùè© CEDÏ+&GóŽI1¢4¶íð>Òµ&ËȃàY×âD`RŒx)Ü‘`¹8%zI© ’u°Ü/KVMüsh©X,ö »jô(>»XnK« Ï*>:íxÿ5K‡£¹\œ'$³õ’±ÊX ‹r‚.ÖˆBc|à¨J}ÇÀÊZ.—NŽH„ÿ©W›ˆ¼{Æ(<ªÈüø ~÷¾Bˆ”úuÇ0‘vûðjR ’n‚¦óLÒSâÚ¿»9šjÌf¹à£þ ¯¼ÅEY_O”…ÆGO,y5%xÇâòS*Š"åÏ´J©ŸªÌY¯æŒÆ¤É Îoïs—7½~òœa(¤³©®x™‰¶säyx6›5MÝ" mX×+„´õ†r´Gç¡›³œ-J.Nôl±b:Ýc³^²wpL–)ÊÉ>! ªªB)A×¹$°1T.åP‘•”HÂ1A–IDð4ë¡.—mŽM+•ˆâ• °EÙÞlçy&6¥–Ø+oç^½”4¸6 q)º#Ë.,§‘Q}ø?¥wv¯µÛ߸+´ÆU•Qw†õ:•+F×’—YžÓmV,—sŠ* b·a5Ÿ1šìmY¤„¸ç×.Eæ]ÆQ*‹º½1¦6 }ÀÕæÍçQþMÛ IDAT¿y\ ¥“8Àw½á›çÞ•Ë”·¶Òœpë¼]C ˜«(J\›ÀZîÿåíÍbdÉòó¾ßÙb˵ªnÝêÛëtOÏ¢™áˆËHÜIq¸Z&`Ò ü`6 øÅ †=úÉö› Ë/ ›†ƒ e¦ Q$A‰œ±dŠs‡"géîéÛÝw©%×ØÎ⇑™U÷vÏÈðÜ©êÊÌȈ'Îûþß·© 2ʦ†.Ùa²\ì(èëÍý÷…sÓ×{ºÖaÒ: Q™¬SÚf¯¶›I14oîÏ÷Ø9þD yæ¤7þR€zv)!„@ã£ê 7ËGLLFUV´­©ÅîAëáÛ9•'YN‘DNíÕÍS$–õêú@$þxÈÑœG>§tpÓ žZÍû¾@¦±ÿ®÷lîÏÿ»mÞÔòÔx+ÃÓ;S™lY‹œzú ÕìÒù9aÀ¸4Zë;=¹ÁÉÓ£3Z•PKÍ&¤<Úä|}]QV!rO-(×%ï^K^mxõlmýsçÍ;HÒØû yNS7|psIbLìñž­@x4‚ÚV¬ÛïÞüþ;Sž4Š¬®8M^™Lxg}ÍuÇú=·nq±‡ÿ[ëÑ:A³«5"àZÀIVòd»b¹]°m6<Æ#2÷‹œ©‘¼œ¦Œ¥ÄA1ÍcŸrš¤˜$A' Á·lË%ÎB \hºæþAÙ–[„õ”~âóßol\ä2úôN/×Y¼€M+°A ‚£iìNÝèà>t›Šð]?òã¼ûÏÿ€ry³+2JÆõŽô‚ùtLpÛøÙà#aÆ eI*EšeœžÌ¨Ë ÛåõÁ~×æØáfÜs6J™IdÚíZ©*ÊÏÉ/ eÕuO(ƒ“ŽEÓ8Êõ%Ëë.Àf±¦i%ÅÉÔø£“—që†'ï½ÇÕån®/ñ®a:ɘO4ã\Q$Ó‘‰`œ©.=èÐÒl ÚìµqµŠ s»þÝ£ o_7<¼¯}×…µ‘ŒãØX>+2B`Ô"aÕÀ¢ ­ƒG"±VGâðÙïÏïY†yø}!¼Œ™žÄHfã™Qi‚ðžñhDyó„åÍ%Â{VË%u]³Z-h„×nìá|¹7šÇ@°Û©îx\۶ضÝÍá³ÖY‡5áÛD5Çßû¬:ö0¥~ :úïþóýß6e‹–¾3ÆbWÞÑZ¬›!¢¿ÖáyöurßáŠúóÞtçáµõ=ɽvû]súQÆ]×ø<ÇöuîîN ­ lÚ Œ ÉÒDDòlz‚D±ÝTTuCÝIËm6ùû<Á¨¶iHO_äzòÕüUìì%Ääü™¡?îêo^4@V]R®n˜L&ÀÞ£í1ýߪª PIÛ=åW.Y’Æ^ã;Æ1@àxüé¥áÝ¥äíÃ{k÷6{gž$,CÃo¾íùž^áfnf¼zj9)<Â(š ¢œYM„(ú@çzH·%Stó¤Q8ëIDBcŠœSÓàuë¸WÜðÝ«âZ6¾¡êhKuÏÛýO ‰“Ùqh[ð‚.Õ!Ä^Î÷ÞMI¥ÆÖR·5¯ŽÆ4MÍy–Gx(kÇ,“ë¶%„P4uCé^ l‰ã…ì‹„„#ﻹn‡ûþÒ7VȦ¤þCÒ§¯†$BD`- ËZÐJ#lÛ»kc‹èüÀ'¾÷‡Iò‚?ÿòoDôº=Hë©×i†.ÖšU¤“Ôiº{8û”cžçHÖ»H´##áÎqïqßÙ; mÛÒ4MTXê®3–N#ÖAéŽdƒ˜J=»wFšŽÈ’(*QÛ–ª±¸ ðBSm×,— ÚÖRË„Ù ¯rï…טÌÏIÒéh„H „2´2¥®=7×7ÜÜ,Îâ[>€‡Iš0N4¾µ(¢žŒTPCÙít4VE¢]‰£´h¬9Æ=d1Û.æ“RÜßøý¯Çz·ù ÙáeÄ.2ÞK‚CótéY;ôÍždâÃRÀ.Ë@ÙxÖ•årí±>Öã‹ÜðÂýÁnÉŒäñÄ{ìëëÇ(­˜¿øI–‘A‚8L•¤†×{¼^æ K€P{å¥ãçæ8Kp×ïǵcçò®ˆ¾7ªC#}<ŸC0H¼“ø Éóq”M"*Íy±7Þ=@¬ÿÆÚN{¹Ä{‹ ;û]ÜZšºd4™ß*‘<‹t×| kôÇó±RÖpzÀ1‘²)P9s3#„BV¼ýð[˜D±Þnå9xÁ¶¶h-¨ª:¦”Â6퇤o_PÛÄÔì]ã®›7e]ó •:Olàrü2õzÉëY$1F;öÌ®× ”6˜zÁëfÛÜ>ïþ¦;Î9lÛòñóšy¦ð2¶š¸`ñ>¦‹ðÝ/5´2QóÉs…©Z¾~5ããÓu¬1wžM‹ãLjÆyÒ¥u¶mxñì…b¹^’dY×ÎÕR—J¦£‚ÈéQÂ!4mCm/Œ-($B¢(æáðÁ#LӜŶī¸õ$$B6¬lÁ§_q”+Õ2z<<¼^r~2í@Š÷¶^žNØl^žM ¬kº"˜ ’ûê¦Æ™”åzÁÙü¬#¦ñDû$!DÇ|v !‚¿ÿµ¿Š“f–7˜c/^¡(4MÇTäm”Þ‘þ¼õæ<8¥ùÜÿð›ŸÏÿèO1™_PÝá»…ÈRƒeä&nú¶±ÔÃ÷vðd2¡¬-RI¼¨øÖºˆxîÚö†NbŽM‰FªªŠõb¥h:#¦´&ËDÄtOk='óœõò†§W׌ggÈ$é4¶%ÏOç1Êíœâ>ÃÒZI‘æ“qL½•®Ýru¹`½Xqz2e6›v‘ŒÙmr}àœÃ˜»Å ´ÖÂSE½mI²¡ÃÊ-ç¸Ï8ßS/F J› 8틾“BD®7­'ä&êLÈ^ÔŸ‡‚µ!Qì7v)E‘“­JVËJÅû¹^¯H&g̦óXk—š$‹èúªiqÁ1ÎöòˆÃ–¨þØÃyÙÍÛà\÷Q%ö5ê‹â†Ç:ŽP]·Á³­Þ äãh÷Y5é˜p»Ì@]×­«Þñ ÎÛá.Ø•éúsèëÒy^t†zß}2¼>!&ÍÚ윟þšïr\îZÃ÷9õœ•!›ß£é1™L¸¼¼Ü½çcâ†ysIŠýÐôuqï¿·®ëøýÆðúx¹1\$ Úp‘åXÏÒÛ|¼'Úb‚ã«ïjÞ˜­ H\ð8é±.¢üÆZrrßÔœNNxéìgáéÍ5H…‚D'(4i’’RqsÒób>æ"ÓØŠUiÀÃ+¹Æ(‰ûã1“ r@6€À»Àe¹Áëmy| „„€¸Z&oñ^B6öB·©ær±aíàýrCH y?´#=b³X±ÜlÈ…âr³å’À¢c¶Ò*²e-–ËèÜ(ò1ÓÑ=Æãs|ëÁñ°qoz~‡kq¸&Ad<‹ç¼®öÏÈN&o[2³¯GŽ@ÐQ ã3?úSŒ&sþøþ*™qÌ w±gºoùB ÈÐŒd‰f’kú5ìyµÇ£Œq‘1šŒ§#¦ãZÀSU[¬‹tžÞV»”^6cARŒðB°Ù¬iª%â´®áz±æé£ÇlÖ ”\/–¼þ±W¾&K MÕ¥ÐtF–h}$« ~_ÿ$E’“3‚.¨ZÇÇðͯ¿Å£÷Þ£i+Ö«åA$syôe€TkÆ™A&}olW/îº2Ä`c¦q½P(9ÜУ#°Ù@ßµfzC+Ô¾o÷Y›pÿÙ² 9!K3lÓ";âgmìD „¤v{þçáø°H~¸Ù~æq½íævV:SÃ1ŒrûÏô?‡‘á~-YBpo£Ô«mÁÝy±ÿ|hwÇßn·Ø¦!¸˜uˆ{«ï]ùÄyOÕÚÈö˜$»5£æ$I†R"FÐòÐáB€T„°nï2ÌÃèøx- _÷Þ#õíÒÌñØí_6Ò5Ç÷´³-J5<|ø>g÷€Ò<‰‰2q~¼C™¸ÑO&cœu¬×›ÝôÄ!¾Oµ=/ ô=·»†Ý.xÅTTËx<ÞýÝ{íàꦼ&W·Ñƒý˜¨çäâ£Zz:º¾S¡qÜp\_âÛÀ+YŠ$‹i%©ãºò|s]ð™ ^8.R ±øN½#q ¼õ𛜟߸Þ,©›†I1"KÓØì"1K’šƒsTN‚ Z|7µâbìP¤8ÛõÑ_VnpkTÇ91=4Ò†u[òjqÂÛ[ÐÆS•£Q¤ D@ðÑ¡¨%Tm…6%4ï,VèDñÞå muE“jTRáeLwòJ*”VßEÒÎ!œÇ -_RaÅ¡¦üµO¿IhN€úH´#‡é%çJx*Kä î^oƒd»tH©É” -BéÃB ¤÷H¢1iÁ÷ñ§ù­¿÷¿ñøkÂÙßÅ|"@jn¡£Ý·ôˆ®Í(’‚É8e¹*‘"ÎGß(„@zGèÀaiš0Öš'OžPÕïr6«§÷¢ço’QÕWï±­Úض$$AH²<‡ ±®Eªça³^q~ï ÛÖAó$I£™M¦,¯Jš¦F˜„[Žñ‘£’bN¨cæ!=Öc>X/wÔ¥ ¬jÊ&J·mZ¿£xh|4Јx㑆à6 (<óñùïå7ù—X/¯6V!îŽrÎϦãœ~o“*RFâÃ871² g+–ÔHš¦áììÞnÍK!X/–¼óî#d6â°ʦeµÚ°\­ãèŒÊEÐÑò披'9™OÉó=¤‰BG¢£aœ7y0!D×mx]ÖZœ÷•bŠ^}ƒlr“˶UskooF" äIŒ–¢¸GßÝúÀÕÕ k-mÛî8ÆJð®[ßa<+€Ðé3艽{øð¬á³Ž[7ž$É;²š‡ï~ ¼V@žGñ”›ÅMÂ-ƒ ¥Ü•Ú’4ÃÙfðìδúŽ…³NwÕû1Œ”û=sø¹ž¤ÏðŸþ¹ìc­ÝR£ìÿ6› Ûm ®ƒat?\G×å.€b‡ô7F㜥µ5Ö5;PX¯á½ßÕ¥{#ëœÛe~ú(xx=½³rl˜‡ãYëk÷Þnî×k¯á°sZ ÷¼ˆ4žÖ[ŒIH’„Ùì„ ºZ`Œ\dk›íö–g‘qÝõröÁ»†ò䶰Å-±‹¶Å¬ñZ¸ä~ÅâONNv¯¯œä¦x@’“úé-ÎÛ­°ç¡=þ¾ž=¦ï>W× ® ..î“2NNï¼õè!\=âáûï¡´Â$Š?zlÈd i\…Q:ê»:Ç«ãLÁsÝz¶å–'7WE½É)WOoB‘¦†ëÍ’4K£ÂW…ä|vƦ¬ðXž6-W~ÄL®‘‰æý͆¶õ<ºzÌûï=¤õ 'Æð Õ€B¨€KPNóx›PüÅcCÕ>6®ÄhÑ1bã|±,”ìtZ§¡ðR¦ãñŒ³É)¸È*v:;A Õ!Ð%ƒ‚ÐxFØüùÙ/üMlðhÛÓÝÉÈ5âÂÀð>kì7üÈ_]‰”–„›20J5Z>0R”Œ²(²}î@IÞ3Ê5>Ài@šÆñ3ÿÖ¿ƒTŠ/ýêÿLë­kÝ­Íb¸¹Å‡X „ ëðRïb”€¦ÜÐlئd¹Ú0O™N§ÔåšÆúœbžÉüŒûY–1*&ŒŠ)i:¤Åh†1)Z)ÆãÉø“Ÿ19y ç#ÉÈÙÙ)y–’¥Š““)ÂÖŒŠ|ƒRÑ9hÛ GˆÃˆÀûˆ puM蘎&£Œ“ùIìŸ&`”ÛIåõ÷çîð²´ãfÇ‚Û¥þmGÛ¹« & B(« Ö{|·kA$ÎQßYVîp-õE@x{ç”,jP!àÂa2@ð°X•\¯j¼°XçYÞ,yzù(¶º)3'Ý~'•!É ÚÆ¡;pP;hõÒ}B(ê IÓÔ;©Å~®ûy–“3LIß¾¼ÛoúZó³Óçwg=¼÷±··ëm6&¶æ¶mKkÛªb½Ý²ÙV C»xÌ@|²ý®ïû=><×>ò­ê²“]…4ɉ-jßQr üsp€Žd†)ýã¾ôþºï2Öó|TÚâ:‹ˆrØl¢|¨VFÒú©$J TGü`LBpŽ²mbk]zAQ·‘”`4*ÐúðApÖîjÍC²‚¶iþP¤wÕ¤àÍfE}ý˜—çg$Z6z‡—jŽÖ ÁÖŒïHY'I»—KôXPÈ»'mØÂpÜÂÑמ‡~:Ÿ0ålÖkRcX,H©¾%éÈÚ•Šõ¥—ïÕœ%)µ·èBd¨*ëj':¾!pb4&ÑÌÇ3‚șSʺæÉê’¤¯_Ád<¢ÀðÞ£Ç8ÞÜT-/D¬ûè>¬Vœæ#ÖÞ[iF²eœz’·ž8ëyóA ÞòÂÈÓÒò鳟ä^¨.Âîç"2æ¼”®Ë†µµmA0)¦ bw`°±á~2™°ÜDu™q1Ž¾ lµçêfÎ'^ù3 “Ž{Ø9²Da„%)FŸ| ‹§Èó1«ÕŠ m-2j¿WOÒƒ”eÉòúŠ"“(b ÙɽSj/Y¬ÆiÌ< ӈǎŒƒgš›¬XmíÝ™÷H“¢’ ï=«mK¦b}°‘™è('úŽZNr¹„2ÇÔ9A„ˆ¨î3QƒÏöÆ´nR嘴¤i6› z4c:ã˶ª)×—¬7[ŒIhšm²½C"µÀ«<ÏwÀ¦~û}i8—R’Û ÎqtÜ» ÌðÏ2Âwýþ¬ÑGý•¬*XF£"F¨¤ŽŠt˜IŒ×?ÛÉúHv(œìŒððÙ!RÂ&I‚êÄ,¼³hRó6®›$‰Ïƒk½ ä|×µßןgÓ4;LÔ]%ƒþ>ƒCcö¥ çZJEš$ÙÝHï‘R#½§´mwÃcrÇù@ð” ZnIN‹8¹}’ÇÔìr»‰´œÖîêm‡ãp$õ’×çŠáÛ†ëB $q¼Ni«€9z0—Ë%õô‚Ë⶛ÇÜS{ñŒaÏß³x}‡µ‘þ¥i(FD°8/xtõ¡#M¶¤q’j Ÿ>)È’”Ͷ-8!pÿälàá“Gx8Ñš\gˆài­£Ù4È<-Hz#®m1^ñµ‡ßB¥9ÛF3ËÆ6-µj¹8ù>æ“ظßø¨S«Uzà©»C‰.b«ª`bšÔGÑv 7"FsGk´¿·M+0… Ø€QùHtŠN6(Œ¬ZÁƒ7?Ç¿ùŸý—”!Ý!›khýϾ4âãz]’fE” ±]––\ ¤Nðu|o”aŒéÕ|4¢,ÁW$Ù ÑÕÝD\œ»º°÷ž<(¢ŒcÜÀe·™§»óé½ÿªiÁH¤‹Q[&%z2BkÅ´8›2Õʪ…ЫEGUjE–匊#Ñà½äñ“e§b&Ùz…*+FÙ³Ÿ/)u7ß=J;0. ›ÒÞŠDÆ…ÂÚÀ¶±1»"é('Ô–eÈ}t8>êØ­ØÎWdëË P‚´Ór;XkÁÓzu«&Ï]ÐØ@å$`ILÆåÓ÷ð:A›”r¹fµ^âlIv”âÑã§ã*Ñ4ñ†s'b& i,ÆÞ8<ÆÄ5ÛDJ̸ìî\zä»RÚÈøø¹ë_Û±[‰C Üé¹+B—R`Øñ;x©iZ‹’à-ÞIèif;I]ÙÆTšÚç=i92‚uh­:ТAš.2ï¯EÊ]¶­?ÅH$h«ì¥í"몊]=®Eg£[N͇]¦­cç³Î‘¦ÑÉÂu8,ÁAµ@":ö;eÏN,`=h!bofP5 AL–œG‰¸¡É.%D%YFU7˜d/è=lÅxÖÐÚì µw?Ø,¶UI:ø|ë<Ûºåë |b²<†5ⵓ»Ôx[–XhœŸl[Ú`xY•<)7˜¶¥q1Šï£ Ø Z<û¼ªT"¾¿¬+&ňËë ©†¤‚&œq­ßä‹·ùÉ ëvÃŽû!ñ–«USqïþ9O¯¯§i§„‰R,« $Še¹BÈŽß-šWï¿ÄŸ~í/™Í¦|P:H®¶žÓÔk©„&° Ž9€Ê(­àÍ{« ʶ&ˆŒµkˆIfÊýCÙ8Çë“ çp®asùèÖ;^?;ã‹ŒÖÈÓ×–|×Ë}6¿‡k¢Óàq|ýÑ'iÀd {ÇÆðQ óñ&` lš@#’N n_Ï H´·]ýé0ŧ´âfc»è.0ŸÈÎÉ9$þ8®ÿeŘºt·ŒG?úõ*E`]Ù({—d·Þg­eѸN‚rÏ’%„ˆ¬GJÑ„ßTq³b×Ø‹EôNfÓ4äyN»CJÇsèÛ®úóïÓì['I;žØc0Ú6nÀZÀùé u]s¹ð8ëÙ–­Ìº–/‡ÌSªr뤙F©}T'D,…eh¤úЉÙÏÕ!S€ðžY®¸é"èþ5$MS’éŒÖ:F“áÎ(2DDGc¸Þ´V‘9N‰(íl×7~toƒ¤jy Äž1ërY‘d9ÞÇý¢­j?þ€Ñì>ÕvƒsŽb4¥io!fòbRQ7Ž¤Ûw›¹’]`SÛã<§¯å+¥¨ëšÚÆEJðûú­º3ø¹{–_îî…>~}hØ¿ý!hÚ–QžPŒFlÊf—‘ñ:ÖÚØ.ÚeL›¦!Q1Ê Ä@Ë7]Ý;Q0Ù¢ºµÜ¯×6´uIØ kÄó>99ÁaífÁh4"„g·‰=kîúõžgyìv醔¥ÕSsüùáþ7Ê#[k©X,nò"C+¹£s>ÖQÕ#òƒŠ+DˆiNˆ†öÃØÎÚÙHyžŽ,Uûxb3þ«ÅáÃ6L;K<Õf…ÉFHï3å®ØØÀÊÌQ#CÛ6l¸ž0Ï pÛ«þÐÁцb„f”ælÊŠ¦©Ù´[¤VèÐò¤õé¸pø€'F9Ö±âïëFb]—™êžR)ëIµÂ£kËÂ+dGià½ÇúÐe kc_xø€”ÑÐH>ÄÒŽàz²–€# -̧‚åÖc€™È…lÑG†¹¿îàiñ¾EÐIŽ“šT+d‡¥?™„Ç SF¼Á“'Ҍ٠IDATд–“³‹Aßnê11f "´xkœ»ÔJh<›Æ#‰k÷idcÌ.bê΋÷ïQ–%7F±ZmPÒg"€1)ÖY‚C¥)Â÷`AÝØhx¼‹Ôˆw½î¾ÙÖ’¤Iì3îÔÊúýåñõšªªÈsvøAÄÄøu¶ÇiO¥øÑ Çn] IcJKÚ–(~пG„‚Öy¼P1ÂÎ@G‘)­kYm×\_=E¤9J*&Ó‹Åš gçX®l—WX­ÈÍ,:«Þã|¡C{wN›3†Ä¶eï±Ø:f:…p¬·Ó"ï®EÞz¦ž•’=~-³C±çô>6Ä}zý Î~ôž½ƒ¿+M²Dr³®"Š„ˆà‘Á:}vßF9ÒbFE"qD-ƒº®PBжu÷ìwupÕµ4ºz—1 “eOg@+ƒ@íi-„FKM@â­EOhÖKÏhvßâûî#I/åé¦qw½]†¢—ëé3Ñ!d8bOS2Šsp›4F"HŒF¶­#ÏF£<ÚngsΑg9Ye#"דHEj"ë22!u7êX•ê®…Ð?`«Å ¶­qåŠëõ&zéJFqù$‰í"Rlƒô uµ­Ù–%ÖÚ˜ª®k—ÃW—O¢Ns6æ[Ìi¦/RHGîKNªG|l–0MŸ}~Ƙ[ðç½GÍ“«+¬·¤y &öd–:çñΚ¯ }…ï_Ï™gYšòôæ*Îm–Ñ´¶«ÄóÓ:ÖªGº`»Ý7p±^2Ï0R"¤ãSóÛ¤;/ؤ´¼¿œ$ïMÝ2+&”¶E …l[.ŠŒ7òŒ‹4°ÂÒöD 2Þ!óÉœ'/!QŒó„¥mY Ïk“1Òµ­ÙVkZÛ°Ü,âzéÒñR_}ïPmX_þvGo¬\—ë"‰Äðø­õ(}ØQ÷£ýƒ¢¤Bµ×GË>¶¿çñž.6 8/iÛ¨nDðTnJÒŽqi:ä#–dy¶»Ö]ŸùÁ?C’䘼 Éò[µÄ!Ç·–ízƒÒ†ó‹cvÈTæ8¿\ÛfKSmpö6ºvW ›E… @'7Ô="¶¯gYŠ1 £"Å·Õ„¯K°ÝnÙ– õj³ JÂ(WZ²¬WQº‹!êÐQgpûÚ\ÞIš3?9#I³n.×EÒdÐöþsÄŽådpÌDüˆêH»aÅõÖƒÔÈÊZßÅÐ3=Ie0I††ÑdN3 ‹ì§ùü”ó‹W(— ªrMÒµÓgò„ç02–ŤŒâ}Öf”f£ü óð¬qÜ‹|ç\ŒáïÃï¸ëµþ|ûH±ß÷wr»ÛíÞˆ‡ÀÝn6Tåš›ë§4C£®ë(ÑNÁM%˜´@« Aêe2L×»JR¤HÈFSÚŽár¸þZkécšŽ\¥.×µ§ðm;ÚÓçããöY†>#pPúò-©‘ئ|FæM £‘hOõ•u°^m:&>¥ÒQ$ÞG>Z/\d”z†²Ô³Fë,Á¬zB…aZÜë.î\æ÷g9FFb­Ë©—O˜œœÑê„©lØ6ð­âÞùζH­iš†{åûdJpÙ6­àÞXž7¹6âäÂf³e|:Áw~XÕHâ1|ê¢ÂY0iÆÔ$YAZ% >p1;ÃWËkÒÄà$˜Ïk÷_âz¹äíG1FíjFmÛ"8ïQRòn•ñRÞî«a"Þ½¦Ó@í&‘‹‰à÷…'ÈÀÍr… \§ÄSI8ËKyëh²KG X¬Öä2çýG0žH”Â8ÏÇäYÆv³Å× *Oh…Å[ǽéYÔîÒ•²åÞüän¿ÓÚr?$žV(¶Nî28!ÄMH2A‘õwcw¬=hÚ"n¾ãB±ªAÙ–m@ûæJ³iBªÒA¬£T4¶m×vX·-ë:¡Hd`eý®M†°'{JE°—Ë›äjÛ º^/¯HÓ4:F"ƒé¢½á]}ÏtÏApëI:êæzßÜ·MI!ÐÆP·²®˜ŠmãpBá:„ð¤“mÎO¦<¾ HeiÚ’…2 ‰6´XêºbQÕh½f6™RœŸ2îÀ1"Å2ŽFŸÖVÚj/X EˆõÃZYÚÖQ®7d“S¬ \ß”ŒG)ZìYÄÒo3µÝ/ „¹›/[h'ĭ jº Dçâ‰ÝÇQJ0I=×[A’êÍ“ÊÍ'àúz‰R “f˜„N)Ëõœ¦\QnÈ|ŽN¢&øàðX®Ê˜Õ±ïWx³tر/P?[½A¾6,ÕÄTy\“{e¾c#Ý¿oÈUq bmÙÅnTìe/Š”›åŠ¢(bÄë×׫h¸¤ É'äJ³1‹ßÓvòµFeh¯AhƒVz· :”4]?´÷Ï“”àý@~p¾ñ ’$iŽI2Œ14mÍ“Gï“…L2Zë1É'><3tL²sæÀ¡MÕ{'Tel5•:í€s!Úû°ó~“$eµºÂyÉ(ŸQµe,”ûÓ¥¡Ú¦!xOšf1í‚Ä;ÿ¡QóPÊ(kJ&…£m¬žÀü…[ŸI¦-[ß²ÔS’ù­—Vp_:Р=ØyÏÖ¶˜ÐòÈœlq6R­ ÿH†àÃj(‘UÌÆÔ¢m>xú˜ZJZrž®=oL-A)ÚÖ’Œ ¥6Û’ª-É’¼ $¼pïç=ß|ïT^ ¥dS•<½¾Œò“jO½Ñ{åý>kd¨ÁËþä©›­#r˜îaõαZ¼2ohEàâôW×7XÁ¶´6}¥÷:ÃÞy¼‘šÕFÝà,K^ñÍå’ó$¥užºõà-mbÐÒ¡šH!úxuÉétNUVäiBpSz^™æÏíý¶†¬‚ÀÏ‹çP†0ȱcéZný®G5x' ;äæ|$^q½n»Hé°fÚ¯¥$>ž>]0J»2Ù×椔ÌFq³«GîØ$Ž¼îáRRŒ&]ôü=j•èEáÈ’Œ¢ÇïqôÀ;µæ¡?¼¥Ûë‘Jì"¼›:&ÕRéI;v½ê9ï=ëõ†ÑhÔß²;Ç0r>–ŠàxúÍ?ãüÏ¢MÊ×~ÿ7ùóßþe~î?ÿ;h­¹þàmþÑßùo™ž?àâÏ𛟥xý LòíÑyÊ'1üîYkÊ®gëFÒ‚—ÔA¬…þ§V¥¢ƒ[–%ëõ–ÆÂx2El+¬µ\>yÊl6£HÖë’ÑhLªWWOÉ 0Ù­6U!bçIÏÆã(½Ë\4MCëãïš½–ýðþ>ooëçjÈã}h¼a(­¸7ЇÙ×6´]Vk³©¢SÐ¥™Çãqw¾u8i^ CÄê„v’£».™¥^×%tß©P‡kDtivÉE‚÷ˆp¨a휋ÝHÏiêÿ–d£nï•lËuÔàùöáøxÏ¿ú|ã¾ÄËŸü<Ç£·þœOýÐÏqýÁ;¬®žð™û×¢Qÿ jÓVy>뼧–Ñ(‚½„—-¨ê(·FLÄV'9þð¨Ù{·«7[ç‘>¦‡ç&°9ª»ñÃ!…€Ù !Í’½íçCJBð;þë?y×ñ…eäö>>¼ÆDÁ…ÎC¶îëçL9)`µ^#‚¨Ë£TÜ€ í .Þ{‚¼rþ"ï»'8Û”ÀKÇë“1o¯–È$emk ¥JóZ1âÍ–$‰ºÕëÍç-E6Â{Ï[—‚^HÐÿYç@ä1N„§ 2zµÞ“ˆÀ8¸`ºN—èA·>Ö¥Lr°UDr÷Ñ£{d§R*J3Æð-Íu·ýÃ7élJc«uôˆà­þredÈ OÖúƒ­w¸öç{œÒ6I†k·˜$a4ÉÙl¶XJÆö½Iží1„ Í WSµ5#•uµ¼ÃÿP(FAãöô¢»tz÷¼6.Ãtœ³ ž¶õyÆv»Åuu9“¤@$n ÂSÖ-IbIŒÚ÷ß•Èz⢾T¡”¢Þ®ùêïý:o}å÷°mÃOÿ§ÿ ›Vð⧾‡ñÙ ïR29;ã3?þó\¿÷ßøÃÌW÷×Hò‚7¿ûøÜüÓÓó¶žú’ó°4(Þ…NcÜbÅM%qAÞŠPûÍ}±u]T0IÂxTÐúU*–Æ””Ü,–QŒ!p5Áµ`[ª¦a:–ã nð¼ønàf¹$-ÆÑaT<§ŒÜþ}$yÌ‚5<×áÚí‚Þ÷­ªÑ&ôµâýõí¥8…ˆABáäIä («(΢:úU!$ÚÄþúÍz‹îؽŨÆ;ÏÑø}o£ƒi]ñÞÇý-¦ÀðÎõ¿ús´QŸ¾'Ã’Bƾ÷>½. „˜åŠŒnñ:èp=P,„€2)ÁXÏ£š—ïÔŸaœ‡tŸ»rW·Jºr:‚À o|†?ûÇŸùù‹üñïüï¤YÎr¹ˆ%›Q”ªDtø‹A–`µ\EÃÐEÂÛ톀c½tÌæ3lÛ&)ÎY„T$Iö¡5Ãx²kꪕðÁÖóWÆðv¥ÉÎfÒû¿¾„r‹›cë½0õªñˆªBãB¢ë5~ÉÓ6EjÉt:e»ÝRUÕ·•zÞJá¼ûè}ªÚÓèk%Ÿ¾çi%xçÑB1ÊF¨ ¹YÜ€QŸÙº®­eSÅ:FZÒèí!v†èqí$22AµMÜ(_Ÿ´4Ö’)Å(+X•k´ÒdhNÏNbèrEãZΊ@]{Œ4l›Š²­HÓHu¨¥"XG>á­e¹}²çgçl6%——O˜\œr]ÕH8KæصmBRZ‡$`­Ã¶¥Îy¬³Œ²ÞGTþÓë†>‰ô/“Ò>üœ 7é¡i‰ä©"8v†9„Øà¿ÚFùS‹M fËb}¹m{øç_á+ÿçÿJSmyí{~ŒÏýŸ#e1ý7I9»¸?@vÊÉý,ÖnÞû&Oÿòù‹?ø2_ý§¿ÃëŸý^¾ç'ž“‹—>t]í’ø7ïcÎTt©Ô›m‹'rݯ„ìÒ­ª3JËÞçÝ÷Ÿðú›…Åâ†ëëk¶‹KF³9ë+Ë|>çÑÕ’"½ÛZ³-¾M“Ŭ_±Õß›ÞP„.;6*2´Ò8ïánpÖñµÆ¿GǾišò_)½Ë ¯-F¶ò uk‹Œ{uƒiRR½ÇÐôß»Y/q6O»Ãšø}$n¶Q•ud4ì:o-Ziz=ißí•‚áwY% $ÃÑ;ÏÁÈØý¢ºòJ¢ìýOÑK'‡X™»ÆqDÞ8=ˆLðQ“ú'þ½¿ÍŸüö¯ „äÿõ¿Å?ûµÿ‘ÏñÑIB¹ºD‹úøÞÿâ‹?ñCt[YG¦ »Z¡ Ml˜Î ´”Tå–ÅbI–e(­¸º¾a)Ï™ÌæÏ<馪vKýÁ[œ³ÆKÅù8e"ZNL`á"Y„ÖψX«5/²äªäÓ3Ú¦¦ÑÓþV©899A™$zR›kÂúŠÌWTUµóf‹El‚¯ªg²~õã°žr{|ó‡Lçžd”Rd9.I¸7r ®mxñü‚QV`[GÝ4(1·X£yxõ§,7Kl×nAˆ‡6&Ö|ûÚQy Á½ÑŒ§Ë›Ä$©ù·>~&8M9M)’Œ,+ºEt-?.xʪ$ ¹YßìREó{h©O§$(œ’TU7…`øàñ#œ†:xZïñÚ° 1Ý­¤Øµ=#qUK+¢#†€àašOÑ}ð½Ïp?3]ß¿\½9NIw á0*É€‘t$£‡Ç®ªšF¥è®*àBÜèœk‘B²lc»ÚÁfæA(\ˆÒ†úŽs>®Ýõö i–ljÃôâ¶,#F0ìS耑ÁõõÇØÕ¨Þ+ð([¶bd³—Í29KQ¤´8¬g› !ÜIõx|RJ„Öl7¶©°Îãýþ8ZIêªB™^¶5 „Ádïzáƒ=™„”’WO$®Ü²ª,IûÜÿüËÿ€?üµÿ…ÓW>Î÷üÂÈ«Ÿú.L6ŽŒn±`QôìÿõÜ“Bpïtʃ7?Ëgè‹Œg§|ýþoþäw׶\|ì̓úóÖV¼Û’””ÞÓ o™æýh¼§g‚ïÙÔ&³3æ÷ ñ± M1;C¥#„ÉxåõOdóÓ3ÖW¨1Y¬ŠŽ¨b‘ !ðÖ"Õ }ÉS¼'ôÙ¯Á=ÞããZ³É>zìÇÁ~è-½G]•äŨ;–¤u™˜Ý}8v "U§G+³3ÚÇ­ZÑY„¤(­†¾K×÷ªTÇiö>êï¿ÓdÚ¤¥Æ ´AeZ¥ئ&I‹n BŸ0àÅïöÜ»ÒúÃkóÎÑT[\[ãÚ6œÛ×6g©ËMŒäm‹síŽÛÿk¿ÿ[üå?ý Þøž%-Æ|õŸü:¯Šû¯–¦*1Ù„oüÑÿ%#Að¥/ý>¿óþ ?þcßBðå/ÿ3~ñ~–ñß`±Úðoÿ?Ãv³îäÕîšxçñn±Vk>‘l©§ 7«5䊭Ìx§q¼j*”³Xu7AAüGãAä±nå ,­äÚœpzohhVêjOç‹Å‚‹‹ V«Ûí–¢(¸kç|ˆ^}ˆ`°0[žâFàå ƒ:ÖÀqÜlÙ©¢ö· ¡QÚfKí3´IvLSCÃÜׇ€¡» µo#_»§‹{MëbiŠ(wª’$¶«…@¹m0J²¸YàmËhýÃÿ oüõŸŽvGsÚǪ¢û¿¡áic’B8"i‘6 Ÿþë?Æ'¿ï‡ùãßýüÙ—›ÏüàOPLç;b˜ç9á}Ú`Û8ª`ºïðþKÎ9FFrUz´ŠÙÛÖQfõ†T’õ¦f6³\/&áfuÃv½$ILtÛ–4F¢L¾#ÖÀù)vkuWSvžÖ ê¶e”%ÑéÜÍÙÞè¯÷Øàh­Qê…¬ÿ·¾p“SçHd½Ù`Ò2²,Ûe¬š¦ÆÙ®þëcf dW[>Dr÷¨hgAÖmÒØ%:ÍZc›&§c¸N‡H:(ýZQqíŠ>3¾¯c4Ív0'=Ž£¯§‹®ä:,gTš´?3¢6YqËI !ðéùWâç¸ÿñÏñÆ_ûÉø]. uŽN”6‘! àóŸÿ4¿ò÷~ù|Æ/ÿÊÿÁéÉ¥5/¿ü€üêc®¯hcxáÁKƒÅûüBÀ¢¨]dàJtN˜œ‘8ó-P1ñ+žøŒgUz×TÐ$ȤNç”Þá…!´É„¸ÞÖÌ«ÕŽî®®k&“Éî=išR×õGª-?kDÆÅ<4|áe‡1E™*MéZë%½„Ýü4ÃÒ=K"Öá<¶.¹?=C)IUÕœÍNADÙ0,ÍÆ–(©8Î"¥¤"áþÉ9®G ÓÆrrNDEÝ4dYŠðûHKwâí*5|põ˜ç÷Ćù¦jÙ”›ŽM'2ÔL'cR)¾ûoüM¾ëG~¥»Þ×ûƒŸw\cö ½&õ·<¶Øã,„À(‰ú\I¤Ò´.°ÚTÖ֛ˎ|cËt<¢.KWKŠbDÝñD£½1 ÝóÜ#Û­mÑGØD¡õ=JDKš¦¤‰¾“ãxôŽËñû|˜ŒžÀ;…Ôf·2#©·ë˜mµŽ¦ªAç¸|ÑïQUUÝ*oyæâ0Ú>>n[—øº=ò]þìèêí /"ªï[Òbrð¾¾Ìs¼þŽ#é»æè®Ìkÿ÷!õèÐùÚÏ7A_Šëß”¦ÿõõ·ù¥_ú”Rü'ÿñÀ÷ßÿOü­ÿèßGˆÀâú)ÅhÄùŃ®eØöÙìZW—OxIn:Ö.A)r‚¸õ5Yƒ€BzÚrCžÝnNò\}@©FŒôŒ²µdéÿËÛ›ÅZ·]w^¿Ù¬v·ç|çëocßk;±§wB*NRPT•„B‚7¨'^â ‰F<"Õ HDH%QBA‚B¢8 Iª\‰ÅqÇ÷^ßækN»ÛÕ͆‡¹ÖÚkï³Ïçë0¥ïžsÏÞ{íÕÌ9Çÿñÿ‘‘*ESnÉ› «PåŠOÇ5Æ„ùää„››žo}ÏT ‹4l¤¡ fd}v}ÎÉlF–fl«*´¿s¡g´Öšëu…Œ4P Å` #ã\ B!”àruÁÉä´7pÁ›îîy;)ƒÌÓchTŒˆÚï½{ãÎRŦÞÕ.¿jHå‰0T¦ƒŽÞ7äI¨ÿÏÆ —ËÿŠ¨ZÉ Q‹mÅ3À^‘+%I£°¬¶¡=c]…¼Wx=ÀlU]÷]E¡HãrßCrÖГ¿ëŽåàœs¬Ö%Ië<Ž²çƒÎ÷¶(w=m¥bµ©Hã­w‘Scßü½/³½¹ägÿÿø–Qî6Óq¨¯.èÀ ?„,?þ¼ÊFÞüÜ0¿»|Úí?4±Ñå+Ûópži*Q³ÜŒ5Ç«Úu:<®2èhGªËŠj³eqyÍ•Ü0Ÿ1Ýc»Ý2{0¡* I>E$FeL&3Œ5`}+|T‘¦ ×åCñmJ"¹aÚâ¨ÔØÝs®«ý>Úòàó°CHš&ýYÓ IDAT@Ó4ÅzI±Ý Ž*?šrKWn…”­N€D)…-·ACÝuz'&TW$ù¸ÿN[7G#xçöEzd~ð»yÜ*^"ØëçÐ¥å†÷í®qˆ½êýÝkÃàîØû‡Î®R×ÒÛZé)à_ùù/ò3?ýL§c”Rüý¿ÿ ýïJÏɽ{T冢ØpÿÁ“>ârn ×˶Æд°Àd<Æ)…$ˆf6Æ"V/™DÈY8¹OÉkžÝ /..ø|²æ|±âád"^Ú…àµíK¦ÙôèÅB`SüêT¾¼÷¬×kòãwNk÷šs®7öEmÙx‡ÄÒI‰Ð$Ǭ}þSJMmBMk¤Aµ\“ÇŸÿI¼þÓ³‡·¨qL&ÌšÓiŽ0‚Ëp5^DGŸÓ«†’áÿ­;_÷B(^õs'מUíQb‚JœE…ŠÒ:,-Nç’Ë›¯0×põ‘aU .ëû¼ñè-+(#OÜs{þj<€½ëó¡ÿ·dëåI3—`œ@YÃaé]wo.—¤Äù¬Y–%§ŸP;ÅfqÅüþS¢,Ç6uÈ/#0¦âùwÞáÁÓ×Ñ:‚JJbœe}uŽÎfTÞâ¡ÚnhÊm žIP-ß榣¨-ˆT]mq¨…î×t4ÝÙ­Gš%\¾xÆÆkæ'÷CÔk-HI:9iYº‘°Bk’[ð0Ð÷¦î†óØqÂg$]»"Ï» aö¡dÏí58\3ÔÁÇGÇšƒÜõÙÃuu µ¢àÞ½S"çi¿˜;H`¨HMôä.ö8(eh{Å¡Ä©©kŒsl—W´½èÖ(z„­Vvpˆ´ÒœLNpÖòìú%J74¥Eê Ú†³T’4NxñÁ‡x3?›à­ã|yÕ_KGÔÎón³áí|ÂóbM"4Ï·Û¾½[P鑘ڶMB9Ï$“š´-A {×Ðà¶qyëa``ÊAÄö×±™ݱ§™àbÝàÄNèš­‡mk˜C9’b6‚MŠmÙ`EÈí®kOš*6ëPWßo2.Ù PÞâü®)ÀpÁóÎC¹Mȧ ïÈ"ɺÜiùv뱫ñ´V°ÙT}‰]Xçp68[ÛªE jCPÎ Jje-Biš†Ûw7ºv‡Ñvw݇ïï>óÝìV7´’’GžÀÓ!êó‘Éï5ÃîSýI žï‚Ƥ” %JkV¡Æ'˜Õs¿!K®¯¯ûpGoŽsŽõzsŽív‹1†4MÖ- `ùÎÛëΧiš^ë÷•7§…Á;?J†¶ƒEY ¤$n¿Ãyßæ/÷7æ$‰{E¦O$£qŽµ–“ÓBJ” s–& ydyJÅÅ eYBŒ¥ó’|>æýjÁ÷½yÛ4ŽïÂ"®êŠ¢„ßÿ ³a”gEÑ’LuÓ`³”ÚÔ<»Ù§¡üºnð­#Uª o$2“É- ÍRÊ"”.t¿;ëÈFyP‚C¦ UUâ=èHòÅÇ’ÏIEÞ˜žÜcµ¸Ù»·£É”ífÝoòáúG=¯á{B„ˆ_ˆãÄï=y&ˆ‘Dg¥[;‚ð,½sd± ),·–sÖ{&cIrôó«3²înçñ˜÷-¤ìKGd‹D(¥CÙ•½Š_·ÁXk»ÅÙoP¶cl+Îë áELYY´ùõ‹‹kf“Ó–ay±–l—×)hL€>³ñ„r½ê/„ Mجn×!QmŽ°“î¬[ ä$qyy…óŽÆØVÙ.ÍrŠí¦Eæ4Ÿþù_"™žÑTë›K|ûþº תq‚/k„ˆøÌë?Áúæ§MÕðlñ‚?{ñœŸ{û3Ä£„'FX¯Y bOhb0ò°ö“4 ôÆöçìdŒ§•xÌÇTÆ1ÊG(±#2Jïh*ÙG‰ÝnŒLhHPèUS¤YFy³Ä”ßÿý_ ô…çþ“|øÁGháH³ /›–Q˜$Žx÷£w°M d)‘"DŸM±áêꊦ,¨ê†8‰©·[âH£FÓÀWé—¶ë’osËR„òµ(ü˜$›#¼cvï M;¿|ÏþWƒÒ*ÙC ÖÉ®8ü¡‡À}ÅÆІ ºoSw™Ö{‡w¢=\8æ°º«Nð»\ÉÑõuçºSŠ¦®ˆZÁ›î:R¯ÊÈõc¸‡XkûnmCÇ¡»û°ï°"R‡[wþ-èïè ²y\[8Þ³ï{­K6Û xC±½‚ÛÈïÑÑX‡¿|I$)ã÷#‹Þ¼„:ÚSyðàÛí–/^„î u”’²,ñÞs~~ΣG0&ÈÞÝÜÜ°X,X,œžžöÆ´o|}D ¬;î«:T]/–ù)Su¼LÌ:š±·“¥Û(#±Ž¹¼¾&I[v,]«BÓ“³ÃÉ, Û€]Èí6zú/Á[ ›„Öª—Q]–5ˆù±×Ç4¡H0*­ÆËí 5‰¹ßv>é†FBPã,çS³ Xø°,I¥d<žpÑöœžNs¤PÌâ³xw=qöº”$ID7â¤ísjCㄯ½Xó¥Ï¿ 8!˜Î÷Ó “éíIµÝ¬1’_œ¤€§nÅV •Ò”EÀ9µ#Ï{$gu´Ù#¿ÛÍ7ÃÐqLšåL3Åóë’ª,˜e‚ë"<'ëB´ú<ŪÍb‰·£ÅÃá4#•¤©+겑sm)Š)B*”Ú‰pxBÔ†÷dã >øêæ gB4¬â„$M)Š D¨.!ÒSmX<ÿ*1˜ÏfäÙ˜|”`,”•éÏ7ŸÎ÷6ï=£éþóB@¾#TFIp(¥”<|ü ¬W[âqÖGù$@­ó“gg?µžÅõ2ÎC'6©Ð“xqÏÇÊU¼þÖ[X/øþòOùätÉÓÓ×9GØ4ÃZAí6dQLQ;Ä+ꤽ8ëQXFI«IݦP:ID€·û§Øª°ÉnŸ<Ò//,J+"2E(Ãzú曤£˜Ô…ýÖZÇÉlÆåå%‘Öè(a4Q71‘Ö\?#ŽB3×®û¦,Y/$YÆhz(RÌžàUÐÈjŽsêªìkˆ»Ñ¥MhS‘¶ ÈÚfÆšàŒC%­Ñ°mjs§ÃÝ­»”gg?èçHgÌé¥Þ |ɳ·“ߤ…Ê‘°KÙt£KíìR®j/B}Uyæe“ŒºØ e¶;ÑÒ7¿‡ [gP;£ÜEã».Xƒ2Ö3r ‚?vlàˆêÂÞEf^ˆ;H ô3M²)Bx’|uësgr8"%©ó2¿à„hhŽä†ò<ç“Ÿü$Ëå’º®ÇAÀ$Žyüø1«ÕªÏÏçóÞH¯×kêºî£ë³³³½ã®V+¢V€ýUsmW£×¸/‚ò*xR*¹#mI…1žëå’Éd„Ò„ÇXCS7G l]ÞÄZG¤JiŒ1;ÑzïÉã´gL7M([Û”%QñÕá‡_©)BÙ»îœÒ4çæü™jd±‹îº à|ÛþÓ;¬—<[o‰\`¡êX“F §óûäy‚üÊUŽ N’ë÷pö“ð=/þ=Ín£&q‹v8kVõÊ`“Ö84Îw°¸<æ1B$àÁ±kRÑ-ÈÎ8ŸM>šìEÈǾ'”§8/I³Öá€q)”uCQÙ=ô§ßœÛÛxƳœi(ŠTLcQ<Õ•¬¢R”`G%y£][òqK`l&{‘ýwÙT†Æ{¸ I)ÁY&yÆf[ö°¨sŽ8ŽY.Wh\[Ãk)QØÊ0J<ž]óŽ¬Ç Þ;´–üO†åö˜Ë¹X|µ‘|í=Ëßú¡ÇxK¢¡öwçiä‰â»{AËïhÍLûŸP/éÈ÷!rÜ,öæI‡nh­{øó{§,‹Û´d¸6¥ggglÊ"0—#V°^¯ñÖ°^Þ¦ÄIŒ±æœäœ5Œ€º©©D¶B>áÚ“í±.ÏÙÍUEµä+ï-®ïÝ­ú2ÙŽ'PqœvW¹?_¥ZÛ „ÚÞèŽ{HÄêæÊ0u3œ[Ç"Sï}Ï‹yÕØ›‹ c¸ot§aƒ‘p¿â=»ûýã8]$.¦­gnÄÕÕ×WWÄIŠÝ*Áh­‰µB+‰Vª¯o>¸w^X<žó"~ȪÙ=œ»Æx<Þ{ Ý¥iÊG}Äõõ5Ëå’óósò<çÞ½{äy¾WöÔåYnnnÚHDr~~~gãì+«¸=!›Ì©,ý";OÎâÙ·­¡4ª± B‚oá/)Ù( žwÇÄu°‘¨ˆ:c/08Œê¼éÁóm7¸ï?›ñßùWP„±;ÇùWB2ÒE³»ïÏ!…« 1´paÓr;T)¤ÅÙ—ˆtl??…h¿Ó·;¾§{ã…ÔÚ¼©‰¤'Qpoš’% )<ÖØ_{ß – ‚ hœ$È8&JsÒlL’ÏHGy8wS‡ºÝºÆÕ[¼5,–«p2âf]"B,]žpxŸ¥=ï2Ü£14ÖR*â$b”'LrMœ)0Æðßû?ùý_þ/)«:DÆÞ†H»éjeM2l蜄PXã±YÄ7_lÉ„&R-4?ö†âæúŸò¿þîo1ÊI©Óù6ÆEpoä9M|(Cà¼d8…„Çy"C“ 702<‡ãOS „çÞDs:Þåf•RïIµBOšÅŒsÅ(•D‰"Jyž3ŸŒÈ"Ø.ÏùÎ7¾ÆÕåJ' ³Þºï¦)ƒˆŽñMMäÍÒy‰ò.È|ê(DÛJ£âÅHÙ5Ž†³.¶¸¦FŠA„q‘îœ"k=Q”o[Šuð¼»ÏÌNöÿßÕ‡×uÙïÃIÍZ‹1†ª.‘¢X‡þÕ}s‹¡S%Ñ:æpÿ94Ôõvø¯3„Î9\Ó€uHïÎâ[´éØ8t@†Ž¶ô.¤¶ÅA’8ÂÛŠ¦ÚÜúܱ54üé½Gú€ÔHïý¼ÛzFRçy€\ñ-¬Ì.Bh“mYš2¯Š2»‘$)†ÛyÙÃñüùsªªb¹\ö`Œa½^óäÉNNNÇ}¹Ôõõ5RJÆã1ãñ˜¢(X­VÔuÍ|>çì쌲,9;;ãææ†ÆÁ;UŒužµ÷¶‚ uŠŠ¦Þr/ÚÁ{{C@¹-‘àÁXC]WäI†B’')ZH°aòE² ?Ó(!Ói‘zO›Ãpý3€eÔuƒ”$,mͯ¿»åþØ’sFiLST4µ“4£.–üùŸ~‹(IÈ'9^ïˆ~ÝÄ0ÆðÁùsnÖKb¥)}Øô;5²(ÒHD¾Û‹ÎA¡„&±¯€™hø?ø€_ûÃßÀ)Tßžô=Žn~ÍÒ˜Yv¸©ˆ[ <ŽÓF1œŒ<ÃÜ%ÜWyï™e;¥°»Œó¡È‚÷KÏé4&óIL…òž<‚,ýæ6z¶fœdXçg:NÙ¬/1uÅx:©1UÑBÌ–íê“q¶AEQóZkZÈFÃ|ÛÎï ½pO‚c‘$9Æ9¬ {„”D*¦v%غ ]¶²2n›šx8©Œa³9çÊç Ø{Óû)ˆcAuþÏø‹ Ã}ò§(€ÊXNsÊ£„ºµ!:JûÃ÷üs«fþÞxï¹)ëöHѦ¦Ã:"”Yz¿sX Œa”e|øÑsF“1¥ó4:I‰´ %©¾M× ÖÒ4%ÛÍŠ±NH¢@,õj—ï<œ«»º}Õ;Ü{Ñ[÷nYï÷çð³Ã¿¿SˆPý TàŸH)ñ2ðf¼hË †µ¾>ˆué;×¢S^0kPQ®_ìar{ÏàUëS“!nÌ Õ½¡“¦vm`Ö]o+Э0×£4ÃxúvÔ1Gg˜¢9öwÑò|Kþ”Þ®/Ïb‡uC8@èójû\Ïð_U"òqFU7wÞDïñ+Žc^Þ\ã´æ|³äû>s“§cJW‡V•Ë%×××·>»Z­îl ©µf»Ý’ž>À&¡Qy–¦TzDå%µŒÉO1½wŸfú”õô|Ýç½UÇ7[®onƒI4ÎéÅNŽ³q–$KPZᤠ±)‚§·.zÚk¶¶ƒ<[#ç‚`J¬#—/®ac$o¾ù6i#Ü–ß~×óÆT¸š8K‰¥"OóöÙ¼µ4β­Ƴ YŒJPùÚ^y’q½¸áÙù3’éÛ6)è¤u¤Œ^ÄNTåp<^ŽXVŸà'?ýybWr2Êùã÷’>U‚ç- Û>lmÎI>¼¹äoÕ>¶msØÝw!ÓXp/m{ «]}m€Au/úqŒòpÁ)¥È5dj·éA ÜK<'™`>R¤‘e–p†i*qÎ#±` i6Ñ(Šˆ°8y#…ßK·ì8¼àìÞ˜$` MYà]CS¬X]]öä•ÆƒAp}}CUVx©HÒœù8Dx“\£•^D;†¥.·áÍ]4},ÏÞ½?Š"ò4a’§¡i}R)¶›4•AâqMÅv½ÁÔ ]ÔþxRñúýW ¥…úç=¼5·\ƒ–Y"‰Ú®F‡ßõÙ:Ú îÞã†÷EëèVàÑÌcùW§‹Õ†|2ãÉko mÓkü;¡P:B8G¬%ÂïxùdF:žì¡'‡Çþ8¥;ãóªç{,…1¬I?Œ0»÷ _Öùrð}Çîmè¹îÛ¶‘ÇK‘†ÇÿnÏÇ{×Ö«½ù| !ºë{:ûxO‡a~õœƒ[÷™žSÁîvÜÕÖ† )Æ8î?xÌÅÅu]÷/†Ÿá_}ˆW£9½¡òË—ÄËa}AYn¾÷DUwN!Ùtƪºäµ§o¾žñ·úÓœÌ2Þx2C%žñxL–eÌf3ªªbµZñòåK®¯¯o©ÏÜúî“Ö•Ùs8’|ÌEòb²Ø³ IDAT=¾wp.¥câo¡ž~–õì ¢8&Š#P‚/„G©›á JItÄ‹à5`WfÐclû¬6ë`lMÃûKÇ—¿yÉ{Kˇ Ç—^%5£|L,‚Cà­£Ø.¹¹ºž¨‡(ž\šŽZæi€Èw<:}€s>Ô\§ B·¤†¦óðÃB˜¤cf“y?w„½ R–î>?ú‰‡H‡ü”p<:ëŒ}˜ì7ÛÖÛeˆ9:9M«‹¯ƒw4ÎpÜþøß«Æn“¢Ýä=NxN’и‚V cøUBJ¤x)Qqoö™©‡cqt‹8‰!ö»œm¢ãD€wàÂ…ˆx–uÊ{ž³\á”æf]ö×?ʲÐeÈZâÑE­UUµƒçÑTñ÷þZªj‹’‚Õå Äó¬¶!Çœ&9:É©½d³¸ÁÕ%X‡jãÔq’b[ÈxÁ sË]´<üû0B|¨-“ª@¢tD½ i«°D4VâUÊææ†gÏ/Y•%©©C]d‹àa“jò |ëå ©4«b"Â!ñÂЈˆÌ+*W`c[7m»«Í~e¤%ƒÂY…Ç65V´r†F8dÛ¦sxý£XÖö±«Öíþ?I4Iš0›ähéI4˜¦DKI$a}ùŒÕâß4³ÛÈqá|h¯(oë?wD¥¡32\{Æ6ÐÊïAŠÐ½I„ˆûÐÉ:=wÏÜâûÏ¡$N„Š”Ni˜í÷ ­úïìòÛÂÙu)Z„ÍyŽtp ZÝÖìéôç䃠 ÖàMƒls,”Æ—ÝyëÿŽb„ŽZ÷ç×]ðLj¨Uལ®7x¿/=¼Wbe7ÿâ8îï{7¤l ©OOOÉóŒÝæ ÍïæP_]F¹¯8U†GbÃ'ì9ñòCìvAÕzÈU]1 w‘²Âã1|ß[g<º7æá½I ÷n4Ïõ[üÅ‹kë`ø;6bUUŒÇcF£«Õmy7¦Ó)föd§ÄÕŽ$Iï¼ÞNˆ@f3nÖ[„—ø–Ô6üT’H1üðÀö½ô`Œ›ÁäÞmxÎ9"°­=^D¼1öüÔ¯M#žÌ4^ ¼ ›·µŽº®Cù„kH3M]Õ}û5¥Öò8ç°EÍ“û¡±œŽ&ÔMBP7–‹zËÖ‡gãñœNïõÀôÇÆ·¯f|áþƒÁ5~ý¿Á“éŠM±ÆyËb³èUÁ:»æ[!ŒÇ³˜_û£ß%ª—yüÿcïC[¹#a{·ytzÛÃ4rÌSHÔ^üêïè µƒQ¾#(½ô4œä’Ó‘dšHf©à4Ë­ãrQµF¬‹îèåNÉÎ{¿§!o¥®k.— ?ÿ™×RC,?A*‰V¡Û—Ä`½ÓF~m BëàXY—`%É#ª²$Nâv’@žÈ]†šöµÔŠXh”XSS ÅÃé çÛM ¬`ÌÎ0w¢*w¿åYáøäDÒúì%oß_à|ŒuKV”Îʆq>íM¼@ ¼#’‚ñ-Ío}óOø¹Oý68cJ´LYP‘Å7ú–ñV.”¹$V4D­¼ejGà<ƒB ‡Ä1I£W2Å#åñG ‡Ð1Î8SB|\ÝýS®á^.˜¤º5 û‹løþÆzRa1"b]{b,Nè£%Y»Ÿz6š#‹[IÅzSSYEe—Ë’Eñlax¾m…"x±më­ÅIGí|ߧW)E)´(ü:…GŠˆ¦Dq„N5³‡I²œ,ŠxýéSÎf.žÈ$‹w‘œœžryyÁììq>#ΦlOå£ÑôV´p8^YõÆ\¦Aú<¾÷ˆd4eóâ’Hÿ´©Ãu)‰i@ÊeEšÒ@SU8åñÒÒ¸¡…³X%XD9ñôŒtþÒFX•Ò¸–èØmþV+ÇÖ„5©ÚçuäìÀ|®0&tœHÖeÐdïPÆaÔ&%Lólo.É ŒØç!£Q©‚#ÿ÷Ω뚓ù J(ò4£*K„EjÛrFq„T­¦º½Í=8œ÷@/–qølºq,Š=4öÝû^…zöû¢¨[‡¼ ×W{$Íw<”ÝÐZ·*kmd¨ð7 „Ñ*çÙ½EqÿycM:î˜ËÃÏïɱ{3|ïa5CO;½1éçuÇïAUmØn¯ðÎsy±àÑ“×صÙë°Â¹†›ës’dŒT°\,°Îç'˜ÆÐ4’>iV àæææVƒ‰n¤iÚ'Ô_¼xA–e\OÞ Ï(¼gS®‘㜼ëèRÔ\•³¤æÑTç|sý„(ɹò¯Q]>ãMY±hÉZ]W“N˜ÿPÚ³$j‰#PW%qëÍ'›Žã=ðtáàw( ­U›ø¯‰¢¸ŸÜJ+’4a[…XV£$£X¯˜ž>ye˜®®ÍoÅiB¹iXAFSJØ”cÉòœ`¤ççx-1"Dsy–£´¢ÚV¼qö˜gç/yýä„÷®—x,§'g,‹.ê¡ç7ðˆ'5Âzœ7D"0Ê$˜P.æqLÇÓÀ¦mËòÂäì&i˜k©p|îtÁ¯þîoð‹?÷óüã/ÿ&?ý™Œ•ŸðÚÃbJÄávà„`šH~ég¾„ñWî{Õ]g±á"j¢ÙzèR—Íë“ÔLbO]y^,콜–ÜIÌGU4Þ šì>£tBí`»ØKOn ð°-×X¡‰„Ãi q ^°Ú€sR+œí6@Ç(Kб (WÛJJ`Œ#²†§÷"¾ýl‹sž×ž¿ÇToId¼,$NÄha“1—ë‚G¢›Í†(Š¸¸¸àÞ½}‚×v»Ånz‚ŽÚö˜ÒíKÎÔíþϦiúÍ%ŽÃæðÁó¼ýæ«վ߀Ã&™ê˜¤-œï&Nø|è¦"„@ª (µ­Ê`„Û(YiMYÄqÖ2 ëå9‹å’4Két›µ pº³%u §IXÕ[›BK+‰–š›å’ùÉŒr]r¾¸FÅšº)Yy‡ÔšL%Ä*¡Scêï žúîÙíœáƒ—B·LlÑ!O§äI(s¹k ô \$Ž7îŘíKÞ~ªˆ²|ÉIþ©@:`œ+ïYm*?h ßGɃüPÿ@²óŠeÛ˜áð|†šG‚DZRé¨;!¿k@qø¹ÊI®Ö qš÷]„d‰BG‚¢lÚ†!áY£4•STVâeŒTQX"°º;´Ê+„$]·ñª])!"qÆÒváïYW—/oMR¼Ï‘$Ë3êzEca<cª¥‚¢™”CÅqŒ’ë‚\løÞýûÙݽ! óصåYuc(«Ù ] Ri¾óÏ¿ÌüéÛŒN„¿{À¡;ÃF(IÔJPÔ†ªÜ­dëX­KªF@‘FZéT- k®º†")až ’a®{)¨œ l<•“ÔUCìÛzEmÁø}ÅJÉ庢±û æª,ÙÜ\â¡Ž°.èð ©\%ß>÷ˆßù•ÿ…·~ôg¸xÿÛ<úô¥ 7WÏ*!Š"Æ£”Åâ’4h¶d‡–ŸÎ!´ÆÔ%’Ý#´b´¦&R*èî·‘šÔ·õ ŽEÊÐ!Ó!>\ʇRÁý_ÿ˜ÙÃ×X^=§®¶üÉoþšºä«¿òËXïøΟþßþ<óû¯ñÇ¿ñ?óúç¾ØK¶ R=ŸCçà˜Ñ>Þû~ÝxïÐCmíïaŒOR,¯ƒBÛü ¡BíùüÑ|ã+¿Âþ½—oý³ßä/üÔÞ=½5œ§ä•¢E¢]ÓßþÃßA6µ%Ž¢–9¶Ù#-‰“­%J „ìÚ~í¼PS78kx*ƒQìZ/6MCÓ4{´ñnXk¹tÏü”‹ü)i²/fÒ å él"æÏ–÷{xû³ó% p[FIÌÉã7±O>‹I'ý÷=}ú”ÅbÁjµâæ&”^]^^2ŸÍˆÊ×縋w¹¿y3`ÓžS–½AŽã¸w4BÞÄaÌ®—îánVk>zù’¢®;ýöÞKîT§¼€Ú4-´m\*`³Þ$9Ž®‚#‰§­Ã¤‘FqB$5McZH§#,hN&S²8Æ6 65:Ö<ûèãIΓ{9;¹‡ð‚<­í«¤ÒçºùqÜÙ.Ô¡d¸þmQôŸ;@£Â§%´vï=×…FŠæhú@JÁ4Ko=ƒÃˆáب[e»»Þ2ÜÄÃF¡ñR3ÉËø.–¯p¡sP·9a¯È9f£h¯ãTçDt N­5OžJ& ŒSMã,')d¾Ü_±;?è ?»û#%£û÷ñJ3K&#–0NgL²ˆë—Ïz’nìàVŠ3TœÒXŠwµ±Ý<îHKúHDݽ7À‰&<\¯b÷]B¼ý¦Þdsõ|ß tЯ1äI„Šª±(3ÏÍPGUnƒÑ©Ê¢æÅÒôD·Ãgz] áËuŠu µõ½<«‘¡…å‹rò QÁ¹Î‘=²¿ó¨Ãr]°ÚTlKæ4”Ç¢ÙV–›å†“‡Ox÷kÀhvB”&ÔU‰)K&“ MÓ°Y—D:g»nØn·ÔMÝ?C[W¸¦¦© „7íOK¬ƒ3¤µ&I’£|ŸCRÖÇÍI3ŽO>õƒ\¾ÿ—è(Á”[”ŽyëG¿Äøä>Ÿþâ/P®!¸xÿ[a<›ªaU8d¬¹¸¸ iD€Ò“nòv¿N9ËalÍ(é6õÁu ±'_ØC&ê]£sxËbC6šôŸéÿ¹N1OõðÐAž´¦-•ÒH÷OL­ÊླྀөºkxïÑ&I ]{Ǣ{÷¿Û?jEc w8ç‚R<êß ¡¶[´ëÒZK]•ÔeÁrS ã Z ._>çêêŠÉé:N‰³ÛÔ¬– ªª&?9Cx˜æ)e¹åêêŠùÉýKœ¦{ù滞ÇÿËÝ›Gkvå¿=œé›î½uoª*Í“maI–ÏNò˜ù>¨Ç »›º´ ëïø`:ܤÕÛ·ç¹æ¿“tgéÏùhÃ<ªÿ|¹ÞçjõqÛÆg:&šjqΗgÍ UÚ³4­6Ï°T6ŽBÓ/µÝ´ /´þ̧EÀo²?÷þ_Cû$q__&ÒÌ0_Ø@#ežÑU–­Á®P2Ì8„ιÙ;DYäk(ó+Iå=×Ò€ Á˜Â]§2Àg'"V‹ln¸¢;ähÇ°®ñÌ0dË,£qôz=677Ù¿?gÊgÇñÂ"ƒ|B¡®‘#DáÁhºÕj¤¿.¶m c PBR¥ýUÍ6“© mÛ±Ë*' ÚaLVädÆTõ«Fø—Ky4èââ2 šü³­$!E娋ëQ’2M9¸r€õñBH¤àôÙUŒq„í%Z]VÓ)Îù€t­¸3o¼8úκm3²>9Š’z–ó‘Â{ósoçñþ$þ÷CA›ûþ4ßvÕw` xµ­çÛ.&¿t¾V/Ʋr7Ð^׺àù¬@R lÐÈ­n ‘R´=ßó¼ô¤  IV'%:PÐ6g˜çéYçïe8¢B'ÄAÖAè}½.ÓIŠÓ1R×ï€f:õR„N…•á ±yÁ$s´;G/ÏÉÇZ;Ó_ÞÙo{…wö‘TÛkÔæ=ZÓxò%Ö‰†6·ÞHÏž´,ƒP…dcœ£ËB;Þ¾_Dzq½& Æ…g¬’nûÌ÷ÂCU†[£í%@ív›¬ w#f)cŒ÷ œ#Œ"”AÈéS§ž}ê1Ð1ݲGšgdiŠÍ§¬>õ‡_Aºú$Q§Çضo®JÉê©'¼ %[zN - ÓÑ€4Í|ù ›{¡2€µhÎ^ÆĹ´Ô„¶@¢¤Tz—qB’Žú{öëìüÛ¿S_Ï”E6m®3?nÛæÕsåŽyµ{àýµÓ„Ѭꕳr´šÉÌÿîH³)eQF-D4ÊxuÔ+ŠZ>²Ç½ììÇ Í½úªñLZá ö±¾l@)†ƒsha«ƒá\èqfæ›4Ë6jŸ×›˜Ý„#P’Ò Â Dšœ°1 AIždY”u˜„=®ìùÆi‰ "„Ùdœ;¶N¯rÙáýÞsVš¤·B’$ä:Àd)«&äxâæîçâ(ªò<'MSò,E Y…«Vxtl–åM=ö¬9¢0ª@~‘Q*@i Þ Ũ¿‰jÇ€ÏS+))Š‚Vœà°¸I"”$+JÒ<#PÚ{ÍRúMN%#¸5ÚjŒ‰çŠÆÀJA çB¡±ŽYî´ääp“vÒAAaK’EÆù^D2»2Osï7º È­ç7Ö6 <œ;¼6H[qŠÏO0gK._n1Øø"OÍxbó/¹‘$ÐJ‹ÑÏ_çùù4ïylduóÂu¡;?wÎ"¤$VÐ auh}ÙZ•&jšõP<ØOdãÆå”…b£p”´bAŽ˜÷êkׯ½ÌN» Z`ŒÀ8ÅdšãtHHAhl’ ¥ôŒa¥7€a†Þ‚+YnÑ"B šÆ0Ÿ¯íÕGÏÁp®*Iãüü¶b˜²TB;7»³’!)=ŽÃ ‘"ç©3Ê©+`RZZª¢‚çÚfyÍ’•’X9Jë0N2ƒÊή¿í™„ë´¤( -h))§"ŠÑsÇh­Ž!%A(9LøÞ×_æÏ÷ºËÎs‡Wïñ·Cç}ž|×¼æ¶ >ó iï}ï{yÇ÷¼ã[zÎ;ŸÿùŸÿ–ž³ÓéðôÓOKÏ ð‡÷œáÑÜíÿ|6‚uĶvd´‚N§ƒR’éxH–M tàI*òœ(p  çüt·)â6®s˜õÁ)–õÞ:È[&À´—€¨òVÃövìÚsÖN³:£öž”¥è²:-¹d1ã¬ñçZŽ- …Né(G\ZúEA„&îîc¯ãvtQ³4¶¼¶d4b¬—T‹ã.¥1` "¨kË=«WžçÄQ\!¼Ë†ïX+Õ\§&; _g'‰Ü(sU!ëæ=êVZ“;ƒ´'û뤕1ö Ÿ an³£¥8áÑÛÒ"Ý6»»­i¥)lµ#ëÀZZÊ«i®8Eö ²TñÌfŸ+¯zÑEì­.4r¡ceàz¾ç9óÔcÜý§ïç­?þ¿²´Ð!3’°bek…’8”…CIAŽc2µX©¡(âÐ1)RÂàÂU÷ X¹³yÎvËr[` Ò'b†©Ê÷œ”­%OPRL6Y8x„é4#Ï ”Ž«˜¥6÷7Ó¯{yÙP…x)ˆ‚‡ßÀd2±žÀH•o¬ï'ŠB¢pVÒ”¥–BA'–Hc<[ÈsžK2Ê-™p¸çxvÞ['„­ 5Hºí„IQ‚ؾ‰Ÿ7ðRJè~úôCÏyϧ={öyÇ1oxÃ.øƒ¾Ð[:o;~ü8·ß~û¶¿ÝsÏ=¬®®¾àsEÁûßÿþoöÖ8tèЮ>y¡bu›0Éjª³ÄaÄææz… Uä¹_$“v‡z×çujwî‚wj„€RŌ̘B„X,-›£•äŒè!’ê"óù…è±ZöP2;ïwr+±b&“BÐí-°žL³N’bÍsczˇG«Óe3ßd)¼ð¢rÚ¶(T‚(ÖXŽãytß™í0™óá½ášƒÄ³•Ô‹¥ªY'éÆÄ¡$Ë-J[’ÖBcl…ðÿ‘B€””¥Ï©YëÈ¡â IDAT¼rs9d4«¶ÞÓðÄ쳜¡³Ö“H¼Ç&$¹) óÜÊÓ”TyneegžkÆ '#\a‘ÎPâQÙ/ ¹>¶,·R–UˆKa%ÈÒðÌÖ>®>rˆC½JJî~øaŽôÎà\T‘‰Ì€‡‡)¼¬Ÿ'+ðŸ;‡'tÁáœiÈé…IÉ¥ûº¬¾“K¾®:×ùC×/Ô0û[¬R(ü†ÓZC ¹•õ©’”ø>5΋¡tö­°un•_»›ýoø.¤sRP r`Œó$X†_¯‹Rhç˜Xˆè”!",¶ž ¤;ÖûøˆCE-¨À/βÜQœ3´#Í`l¼¨¨Ùë Ëmcà³ñ˜_þ4/úŽï¦ÕîÑ 4“,§°5²z–ï}¡mÞËoÖZl™{̃4ñ~­( ãȲŒÌù(ß6ð[¥håð5­jáð©ŸÒ±à´Ÿ@Z\BÁ¼ÁTÖV• ®y·‚@VœÕ3Ô¹Küû˜e%ä æª  —„L‹!hŽwÔ¤Nþ9¾þå»ùwÿú_¼à~þVµ}ûöñ±}ìoýºï~÷»y÷»ß½íoïyÏ{øЇ>ô‚Ï™e?û³?ûÍÞoûÛy×»ÞÕü®ƒí›TçpUЇtÆ­JÔb;Ðó! ¶B4ÜÚ5zt4ÐîôBâu;|-Ö…šs^äà\x ‘“\7ž—8 Š<ÛÓ ¾p›]3tCBe(­DºŒIVíc~ãb¬¥!ûàJÆa›VÔ%ËRZ‰7°kiŠÍ3zÚwÌÈ*ÖÕ"¡Íè˜1cC{…P ÒtD+ÚùÜ¢áÄž_«žiMKË ?¤( z Kù†Dkï>tÉxH·×EH"Íx:ÙAžgL VPT¡m©ü9”öç¬ÃÚ*PPZ"#Y\XDJAñŒk÷O*ì7 5}©fï활èÅXËWŸÈ8rà…‹‹jBb¥û;qB O̳QUXçk§;]EPÂر˜É‡Ž_ÆûäGyÉ-¯¦Õí‚PWZÂÖ1ÉJJ[1’ɈµHBé¡¢­ Í“̇ȕ-q¹d¹­HKÁ´¨ÀfX: Š¶(pRãœd”¬{DŒêE"j÷¸ñ-ß×€‚Ž8IȆ^?¸Ö6¯Kó<^X½Z“K¢)Ÿ¼P‹ã˜¤ ê -©Ëëj`˜tá6ãoHgI*&Äþ„«s–ŸB¤-YŒ«þ’ŠÁ´ÄÝxÅJ £Ü§—€Ò9uó†Þÿ?©R¥õkÈx:ãf–RrÉu/å‡ú2¼"•1xi4ȳ©½(QYd:Œ« žÃ9‡) ¬¥4JûT™ ÄŒ\HË:µDSlMéÓÿöîÂIw­Óñ¤ªw×þz¢ÆÔ\táBFéBŸŸïû½Ëoâí?´ßÿMì´D:—Ûö/ß¼ªø»=¯î7IunÝÍÅ‹ýß—VòÛöe¯éœÉCP3€Ùóy&Ÿ-öÖr[¡AQø:GèÆ¥‘:@R°¹¹I¯·BO€TPd)s²Æ˜ñGå”Ó™c´âØ×ãVùFc-jÒG–©¯ù«XŠ‰J]‰Ab•W QùƒlBÝ%Š=æh×ðx?b"VØùJk¥‰ã€Á`Â~1ƈ˜¤2ÊEYhM˜ty|#ceå rz☸Õ:ŒY&/rÊþÉâ~dw™áÖ º­9:>kªÒ³šSÜT¿¿ê)/•&/ •a®=m![«LÓœÞÂQ¨X[;‹Ô1ÈYH»nRHDà=–€ÊS‡}¨æ\ƒ#Q%¡X\XB*¯bÛkw8°¸ÂÃO>IÜØÌ Rcè[ÏJ¤•®‚nõd©_Ôz\Eax*5Üp‰h‹ðyw Vº°ŸÐëÌŠ¾%¥™åõ,0˜J„5XtÃTç…¨QÚ³(„¯›v•®õ|«Â?Bð·ýÜøù|žosÕ}yºÁÊÓGá„e_5%šúßÂâ¤Æ:IQ!d¾÷ïý ïý¿~™¿üã÷ó¶ù)sŽ›hF©ÁFš WZ4W1@9chGŠl’ë© Y¡ô,qƤ$±$r†µaAÇÄÒ2ž€A"¥£öH…a”Rrö‰9xÅ‹æÈ<¶Ã/Ò…Ü…ø^®1bnîîå]×cþúMn\BY$÷êŸÕ‡2‡÷N¨ôÒ@ ½GúÍ#¡ƒXpîì lYÇb+lcÜŸ« )PÆâdà7œxÊMƒAÉٜͬ@ª)!¨6 B̨B ãËÞ””`,X0š„ò c7~;ÑÊqFÓ‚K¯z1y™S¦SÖ7Öƽì Nœx‚HKâîT$+q£¥ ËsƃM²tÊÂʤ ÐRòôã°xè(MT©2)é£R Æ[(`MIÜ[`síO—1q» ÎЖšsãgA…QË?˜©aÉ=¤%÷jÐœŸ+Â9–^þVTè+9¤¸¨sì<ŸsÞve“1q§»ë5Õ¼üé¬LNeRž,ýGjvîÚ½fS»îA£÷®%–ß}Ý´7ÆÒ¿YÕÂSïàLNèi8GÃ5ÀsË‚÷ŠÊŠ´0%n2à‚Ã:“²¹é†3 •§ô’hû=×}cgtžù´`2™²¸Ðc3slK«»€-žÉÖòZì×®›m-q:‹ çväAµ[ŠZ-VX¦'_րЊlÂRzŽA´Ï{tR%Óé´‘¢lŒ¨¨Ø»œ©¸Š„ó”za!µn6n¶Eµº+´<*º, Ó4¥ÝNæŒÐl¨Š¤@V¢A^ä %‘Ьon ã€ÂžwÖN¯ŸeÿÒ2„æégOQ×[MŠ Q)`5¼ÒvjåVYj¬Ó &S–÷Wùëª[Ô  ›–à±3†«+p³yýT$Â) ÆŸß ª…Íoø”TXç2]Õ~ÏÊ)vç«%äßdÈú"Ú EMõìµ›#ðonjfü껊ZÞô®àOïø-îûâçø¶W¾¶ù¾«€é ´¬ +¡pŠR+¨ÂÞ½D#­!Pž(CR"¯°F¦Î liI§–¨ EQ–´BPiå6&³ùR•SOòù?ø¿yÝÿc–] øP¹†£ :Œ›ïÎçÖ”Rþ{nVí0¯´Ó[œ7صaž…kC¹{,wyZMp© ÏÓ©RÍ]1;ÖXé3Ú®G¤ Ç87tâÝ*&ç›KÖ9Š*îå–´t U³Œ9ç(¬Gìz•ºê}©øZœ§n>Í$¼Ê’ôÄ­VÀ43|é/?Ìd<æÌÓ'xËü#¤’$:&3%K ‹(1ôY\è2 )󜤻@š¦„aD™M‰£ˆ"L°H´ö¥¢Eîq”’ò4±ÖbçG˜N'dyÁòÒ¾ gàȧ#‚vÖÐjE8g Ej¶oƒržëÏ3' › 9þ’WìêϳO÷,%Öx>íþdÈZÍáR+d€s¬mn°Þßà\0Pl 79=\çôæ*©*¿x^Úî5ž‘/ػדּ|mµÍê@IJM¦ùúžÀ‡ùõm5[bw%¤o—ìßG6Ç^×2×/ã`8 ?Zc0Z«ÂoÄv!4ýSOœØeþGlWßpßöªïà¯þøýœ~ú‰mŸ !(„° „ÂÑU–•øú÷^'$`!VtcÝxŸ0Û‘…e}+ÃYá` q¸ ¥nõ±û.¹Œ7þø?ãÀe×T‹…D…ã4#ˆ[^XBlÿ¿uÛ¶4èj×_ÍSSÖ㻳^µN¡yŽeOÊs>{¯±­к2a~c0ûŽ%Žb:½e„©v†dV2LÍs–Å5Í“›cÇÔêJbtö¾:çLó&'?O84ÿï²,IÓ”¢blžOj4(˳=À­o~'¦ÈqRšv²°°@«Õbyß’’PϤk)=Øp4ÜBÇ1½¥Æã1Bƃ>%PženfL«~´ŽîâÖ “§H¥H’„t¸‰5i–5}>‹hì­ñýØ—ÿŠã/yŸûÀopâž;ùËßý—<þ•Osï_~÷ÜÉñ—¼‚Ç¿ú™çìzYUéDñŒ±î·çÛv¦ræ£9ÍPÏý¾ï’+ÙÙµÍßC)Í`í4çžzˆk_ý¦ï¼ÖªUeYœ—̤~7D%ù“^¸NùõoDŠ¼„¯árÏ©¤"ˆBŸO3ŽÍµs Dz,çìÙ³äE±Ž¶vÄ(Àž!–ÏO–¾³ÕgŒa%°”“íÌ0ì¡4$Ë1íÓÊ6 ¼¶”‚hN(]dÓFPc2™ MYd”fÊ`k“§d阭­u”aEèj IQ1å8çýªƒ€$NˆcM¶pÖ“ò×5…ÎYŒõjVI³˜t9¼ÿ08uö4¥1>U µŸÄ•Ä’@êªnÎKX †’cÝ™³ë$UÞ×5!dW:YK@:n:’Óët¢+ +%¥)ØiÑýðzø5—lòäƦ_h+¸Tžñìæ€~•§ÎŽÉŒ£t9…ÊH‹ŒÜfÞ{’þhƒI6®¼ ít¢Uv ”cbŸ •'~…©Òæ¡oÅy^ÿ¶÷pä²+ùãßù ÖVŸÝRSB!q(ÐÑÂoöð!ð‰pöõÚhí¦R t iµbZIŒÀ†ÖdL§cÂPãŒEIE§»L+nÓŠc¢0¤Ès¢¤ƒ "” R“çe¥7ïï7Œ"¤Ò8[‚õ¥c­v—ñx@Øn‚I ëʵ%Nî®]¯ÇüðÕßÆÚÓ tÀ7¿Žöâ WÞréÐ×5¯|”—¿x Õv '$RGXSR¤#0Wšçõ~ÎóùÓN#:6ΰqê NÞÿ%œsžÌYÎ=ù+ǯåá»ÿœ¤r[”àD¥ìºf=ö¢Ò‹¶siÊóD½êU7ÿòËnzBjB)ØZ_!)¬%¼‹ŸeiáË*œsÄIL«ÝÁ9ǹ­!q¸H¯7«SÞÙ²,#Š"_®q‘’š´,KJ2 šPÑÎŽÞÙ¼hûöR„¨¨Q‡h/ªPwþºËÆ0Z Cž{Æ—ÀAhÏÑmm¥OJ#ýè7Å¢ÉãÊ*lh]ÉRƒ)šŠÍÌXRó̹ˆcûÇ!]AY˜†W[IÒžÅw›±˜ý.µDØuJ:<ôô*ñØi^tôÚÁú ' †´‚„—\óí¬,fuë ±P(©H’˜4KÇòÒ~´ ¶å]Cã,ûã„/qAé-íC«Æ–,¶4”´ÛŠ{þüƒÜóñÐ^ZaáàÑÏès|I轶8TD$Ò’@ ¢PF•¦p6-*d²b›8ÆNîñÏ9o°Œ)½ñSÛAEuþo1(g°N` ¯æã…$|_•eY)ÍLϺ2ÜqoÛÙBQä‚IZ(»-ïW_Û9GYÎÂðó÷ `qLóY(}þ¹çŸ¹~.­u趋±LÀ±+¯ãð×òâ—G ™Ðn…$q%æS–”EÁæÆJk” ˆ’qåYJQÑ… ϼ¦µ/•SAR£*¯­Óé4ý6ÃÔ”²šzýË8ö¢[Rrðòëw½_;£-ÍxƒÉ§YJµü÷ÄùmÁ¼w¼³™"GU¤;õ¸ÌùÚxG­.×¾ê-t–#„ »|}—\ÁÑë_Æʱ«X9vG®½É_£2¾u)Ô^s}ç½ìÄpÔüÉ{?ž J\éŽ0ò%CÓÌ“§÷××(¬£Õ]D _ƒ\ï³,»¨…«N¬_ì"7 E«±Ó ¢ƒDÏ áýüS¥õy‘äBøg]\\ÄãE)‚”$Jz$mJš¦)é4GAÒ!©”¨¤ )‹¢êxÑhÙ"ü.|s}4K™LR––Bt¤w¤Â¼*¤g;~ä0Æ Înž#Os´ Ϋ¹¤er»3Є¬åä dÃåd©àà‚#2—ïO}þÙ–xaI-¤ì¨ëÃ*yÉêß5ª¨”¨Ãá#,u%ßÑ1œ<ýUŒ=Ê-W¯pv«Ç8Í%’¤2ìÀ :­®÷8J5¨Ëw¬«Àc¢ÎQ{Ç°¤ ³x:P”¶þþ·Æ@_¨vñù„Öæô¸Õæþ¹_äþÿåCÿþ×ù‰þ«è`g˜I'‡„iÉ;^~=p=Ÿé³0€X­8ÂàpÓ+V84>ŠR8…–^ìYæÊ"ç¯þàN>|7×{‚þùtsÏMÚfï”+k T kJkÉ\­¶4£5½Pºaç¢åœ£, ¦e‚¨²» XH\™C$)‹‚,×ÛÂÅB&y†•ºt(爵©îÔ¯UR)Ÿg¬Þ¡ú8…à ‡ 4ƒÂ™aKÏ¥î I¤«4 {–¨ÑìÕO–YÜöBîØ ÌÏ™yjà=ê' ”/»kGÊwd¡“`²-´õ5ñEQ8GiJU sXçyš“$©Âê¦aÒè–¿(Ô ?»^j‘ ²l auèŸ{–îþãžÃʆÉÕÕ±s%AóÔœ;Û…>«ûgÞ  ¥ˆZ]Š²¤(²Êê]ý8®–scµ³ß÷RW›¯gÜú®!ŠÙ9nóF)àßsåÄçïaþ>çÑÓј°EI¯Ób2èc'ŠédÊ85´º ^2N)µÖíuPbwa»µ–fwXív{×÷Î×T%ᨵ&–áx«oÏÇ^ ½ðÅy—ÅA9\gii‰<Ï ÃîÂüú:?ð²%â8¼âp4aùÀ2R)´TH ýþXK{aÉ¿à§/YßX#IÚq‡Þ’'—ÈM±Ýc¬ž;ÀNΞÙ"Yh³ˆ@QV9ɲҦõž†¿–¬úcœå€t:å‹«+|ûñ 61'ÑÒ°#Âãlšc5‚±%“lÄBë|/˜§9çUGeŽ5Š#m‰ë&¬e)_{ì\±dqF#”_–4º‰®øÒ*¯ÞSuÞŽá8[pÝáËqb^æòo¾}3y¯V§Ë{~æç9{êäÞ†?Feip±ŒR^qÌÃK÷ÈLÔìø#i!„2`œ¦©EÄQ5ZùwòÔ£÷ó¹?ù=Š,åïüÈÏqôªëÙœl7ÏýLÎG¤Çd0JYì$ &ÅžÜÌÓšk+Å$7t¢-¨õ¼5öÅ}¢¬˜ô„N<ðSJc©$­@Ty½ºW9ï3*…‘8¢—QLKLiBûM‰ËYì$¾´´:Ǥ0͆{×çy7XÒ4¥×Nf¼Í€(-Yž³ÕpòÔI: û0Q›Ž}ˆ¹È0M¨¼ŽºÍ¼ø&7­£¡\ŸšßT)¥èv=š9 C†[[´ã˜2K ´¤ÓŽÖÉ„º×œ¯m™Óúßχ¨c¯ÃcalØí•7†™~õ¼ŸyâÏm<ëˆÍ ¹ÿóµúß{Ý¿”RÐê-àÂ¥$I;fmmƒþæ„scÒ\°|`?Rx”Ÿs®RBrH,ãÁ€<ÏDâx<¦ßï³°°À½^åååç5QÛí6ãñ€@Âñ°@œ{3éS¤#²,½àñ:H§SÜh =<­]Ôu­³LGäèkkç('ÔàYö‡®Ù\ÔžóÛ®J¸ç\€“F:Ò¬¤ÓI¼ö3PëFI„ñÀgånÔöÜ„t@°N^–ŒÓÎAºÕ ™ûæÌž 09Z­óÅGNP*°*çÉ3OpåŠÅ pÒ0žŽP/ÿBÎ —ÓæºV»¹7!É„£¥ìyÊßFkÂWÙv¾|QœpìÊkÈÒ)Ÿøƒ;fÃRj’€f‘gA E!4R·çÞ)I([Š£ûBVš)RÀÔ8ƃ!w~ð½|òÿý æÿË/qìš—`¬£ïí T¿ùŠ Wx/2qôbÁR[ÑM4­Pzµ:å#-ÒÌ\Îu¯Egg®o›§¢¢óiáÿo0k@( #Ió™Òá‚€"HªÍ‹ÿ»Ö¥„PŒJGZfec;=¦Ù=ú ‡…¯åByiY,H„­qÁÖÄ0˜Ö>ÒTW¹ìòöæ~ŸŸ/Î9~ý’_ÿ…Ÿ K§³þ°Sž~侊Q¯ŠY‹q–O}èt2Ùܤ½´ÄâB‚Ô`Ë)ZIlQTDG%Ö•>v ´Xq%½Vò§?ð›œyê‘ê^¶ïÈkç¨6ÌJ8V–ºäÓ!&g%ó9z Ši 6ÏPJ`LÁÉû¿L™Á”`Ê æ†ÿêgmœi~¯ûë+½£z~¿qøê•¥¥%Ú­l:äëŸúŒµÛ®3?¶÷|â}»6ÙdÈ7>ý'|íï㙾Â?ü»|õã¿Ïÿäw¸÷/>8îúÀoð…?úÈÓ1Ÿ}߯ñÉßþ%ÖOàÏþÍ?Þ6·…œ¸çÎæþs|íïÛ…YØù` ®,Pøèˆb{ Í9‡žLs”iµÚô×VI§)J…UUƒdß¡}ÄAˆR^l!Ïs¤V$QÀpsëþþß¡È3¦£!›«Ïpîä<~ßWqÖòò7½ƒ¿øÏ¿‰ŽZÜþ÷‘sgøʧ>ȡ˯ã²ßÊ—>þ~¶Î&¨­nzã÷²vê Â8á¯Þ÷o°ÖpË[þ.ùwÿ‚lIw‘"ÏxðÓˆ³%/zí[¹ó¿ü&ež±pð¥ýœyü|æŽ_åïø î¿óO1¦ä†7¾‹/üÑosɵ7±µúéh‹¤»Ôl }ÕŒ%ŸŽÉ&CúgŸáò›_Çշ܆sŽñÖùhkïXC IDAT“×¼û'°eÁdk Fœ}âAö_v]3'¦ƒMîýÔ8sâ~.}é«1EÎ%×ßÂƳO°úØ}¤£>§½—IS,º”ƒW¼Ø§’*)à¼R$TJm[~s¨×½î•¿ü¦Û^NmÕï lô‡¿ú*º‹-:aLÙˆ¬;‚À ¦YÉ©Õsœ^søà¥Ç´q6GèŠÂ39IU ‹øª²ÜiE‡ØŠ/;/ œ¦Q’Ê kD:ÄYÈ a  ó JªYn£^”vü^›ÖD<34é:ZaN«åYã·;lfÃ^ ]y–F3ÙIŠö§wÎ3Y2"Ü#<[Gf¿k¤„…–E:ïmlõ7=ʸ’Áz½ÅæzRî4³ü¶ÅòÙû$×?ºkQþïÝvÂö2~uk÷¸é5·W¥}Þ÷5îûâçX\9Ðüm¾íÌ™m÷Ô$8ØX;ËýW8}âa®¹å5¼ùûÿ>ûŽ_¦Bt; ¢SɊݨêz9JR8 “§˜g ÑJ3-¡-aHiöö ëVõ½>+ŠTJI•æ%a⬩'7}±ÒK©fÓ èÏ—¿Ýc•†:t0ËžÏÃÝÙ§çËgÖýTÿÔ¬Š;C•;C®õæâþ¯ÜÍ#÷~…þÆ?ô~™¾úßxëý'{"Ëyò‘ûYØ·‚ÒšgN<Â[è§(òŒW¼ù­œ}ú§Ÿz„ïþñÂÓ<@:ÜàE¯º­õs»öFî»ó£Üú–¿ËþK¯áëŸù(¯yûñùßÁwÿäÿÎÖÙgiu9~ýÍœøúxÅ[˜µg#Œè.íçõß÷˜·¸öÖÛNÜû‚0$Œ®zé+¹÷Îñòۀˮ})ŸûðÜð¦wsÿá ?ö¿1Ú8KYælœ:Á+ßõÓLyÊÑëoaíéGY?õ8J‡H¥8rÍKyàsåæïúA¦ƒM6ž=±í³gü*K‡/#¬“7IGlYrÃëÞÆtØçÚ[ßÀ#_þ4¯xû2Ú<ÇƳO¡ã%| Øõ¯¹éxÀ5¯x3}8ý轜9ñû]EQÜûÉ÷qÅ-·ñðç?Îâ¡ã\~ãkxøî?§orÙµ7pèÊë¹ë¿ü6ù¤ÏKn{'÷üùûˆ[]¶VŸæª[߈”’ïú3n¾ýyúþ/ÓÛ„l<$ˆ[\uëÙxöG¯»™{>ñûÜö£ÿ”ép‹ËnüvÊ|ÊâÁc>Ê£”ßìVÿ† f,Oþõç‘ùt̹ÕÓ¬o¥V³pà—\r˜tcaaš¥M˜£ž¼J)´Ò?vŒ}ûw-RJ¢(jP‰AeyžSY–yõ› Ô¯Ö-Ïó]ÚÐuë)C2:‰žÁMú@w„ŒÌÞ aEMÎÊ—7h,Êä>d¦h­ Ã¥NÂiá7%Šha õ[êCZúM×íc<Í™:0Å¡…ýKÈÓ1Ùd€‚$ŽQ"g«¿ÆÖÖ€4ËÉÊc½0•Ar΃z¤ó} €$ÑJù°¶ž•@ø£ön~q° ¬å`â­êb ­HJ,ÚYÌy Çîõösï[Z¦Ûéìøûó0ë+ ½Å&„½×9êP·s ¬æ¯xõ7•ÿýÛh{…vwTæBžÃ­ îûÂ]üÇ_ýçüÞ¯ýK>÷‰óäÃ÷3ÎûŒEžq×Çÿ„³^ÀÄ‹¼üÍ·óCÿä—yÝ;¿ŸƒË‹83cªª7NÎêmy°¡úšúÓ†2ÆÒik–º%JZ^–~ó~¡plG§Î_×9‡5³Ò˜y‘–ñ$#ÍËÆÖõ¼Z‚t‚} ]Bépîüùî:ìüͶyƒ¼Wˆ¼nç»V½ù?ùøCüØ/ü\ó+Y>x„îÂùO¿ÅÑ+¯cýÌ)®¾áfòtÊ‹^öj—÷ó±÷ý{ž~ôN>ök«Ïpùµ7ðÙý.½ú:6Öϲ¸r°Ñ¥; |ù`´¹FÜ]às~/IwîÊ~Â(`ýÔc\ö¢ocqe…/ü÷ØìJF›çpÎÑ[>ˆTšÓßÏá+_L{qãE·~EQÐ]ZáŸù0ÅtH·xðÎ?%nw‰{Ë `¸¾Êò%Wpï§>@žNÀ9žøë»È§c’Þ2E>åèõ/ n÷xøîO§Ú‹û)ó´ùlõñûyü«ŸáK½DDíýµU¢Î"RûûK: ÜÿÙ?£·|€öâÅtÌ‘kob¸q–öÒÒák'àÈ57rõËßèÇ(²)Kûö£”äů|#_ùðï¶8xô ¸û“|íSbÿñ+‘Bqï_|ˆ›¾óû9ö¢[¹ñÍïi6\q§ÇCŸÿO~í.tuHG[lœz¼yîgŸ ³t©kO=ÄÁ+^ÜØÒ:o¾³:¡Ù þȾÍýê¿úÀ„å ýÍ ÒÜÐnuQ¡¯Ç˲Œ$‰Éó’¤#…äÞGN²Ð¾”£G^pRE±g¨f/lýÐ5º{kk‹(Šfñ9ÚÄÖe—ˆ‚}fV]ó×ƸΥH)wyóõwëvÎF¤¥`A¤ ÂEÍ/}án¾ûõWÓî$8 /K”+È,Üõ¤åõW(°’( ô·ˆ”«˜¯|He<œ"uDwiÆ”Xž‘ÎUSÇ/¢í0a<#ƒ€þp@§Óá8³µµ‡2“#i¾MžF`¬Á Í(,D¡YnØ, 0–íˆÌHÎåý8ã”õm<ÓîîöÞœp^?@†´¢ÖÄù…ÉÍa¹f÷U¶5ÚåpZI›@z/i¯ˆsuÏÔG[>ûd‹ï¹éF¦å…•=ýM´á O·ççí Ù<”EÁ£÷ÝÃã÷ßËÝï½C #â¤EEyÆÛ~ô§9|ür¬µ¼÷_ÿ¯½ý\óÒ—‰¥´ŽajYNk©ð©)ÁY²Â’¦Wõõ^}n\Õ㮤©JêаÃfj½ÊÈx=_k™d%R{zž¾$©Ü¶Õ¡F€É°ß 5`çZƒ- $$qäÔác Â)ô§…§Ø+JáR:Z±ëØ«üg/D¯«òîÆZ_Ã=çiÏë^aìúæ7!õ³î…Ø8û,wò#Üþ?¹ Œ4ÿæü¦dœf¬olhÍhZ€Ðd¹§c¶BUúׇS—gÖ9æú~œ¤Y¢¢Ú­ÖYOÛNp¦&PÉ|Dc:fíÔÓ¸ ÀE]¸ÝdÀ78õð_sÕ­o¤Æ.Ô¿ÎTßµuUÆnAÁÌiUŽÞ|ÊÀUc:nÅ ÎÒ¼¼Šžª¡øœÀªkh%ùÔ3”Õi1ϸ‚³Ï<‰’0ΠÕî Â¤á¦pb6wg¡òÝeƒçk»ðnV „¯&ø¯ÿéÿDw:]‚Š!LXËÖÆÂA‘f´aßö8Âí?ð“{?C}Ou¸BjTš@ò"Ô%AP3‡éío…«@¦~§ëÙeMͪÂy'ÊZ„sM=»hÖT_ mÊÝjSZOç™DA³ñP¦Ó:Ä¡K¾k E^¦y•J‘`ýf ª±uTã¸{s¤ƒØPÍ—t4`ia‘þæ9’V~@Òê۳טê@So\µ™³Ö{³E>aíÔÓXgH­$jw âDÞà‹™ë2?W_æ¥Ýi!±EéEZêhŒh¥ÎJCUúR Úû8²|€õÕUÚÝ%¢$ôàñ”N·GV•Yë8²‰ïý®}”ñ>X’¤K%ÃÁZSmJ_gW‹´K1séÓ,ÅKF( q%FŸ¥^§,Ë*P½„b6ùËÂsüZkÈrʸ G#zÝήÃJv‡†ó“qm­Ï#=ÃÝ_|1Ýâ=ï¹édHÒY@Và?Ñ4·0¢`5Uêdkí,qÔ¡Û ¢*ë4†™Fñ«ÎåÎv˃ш¨•pz°ŽR²ùœZ¯jžx¤¾oA‘çH!¸g3æÖãÈl†pÒòôáså½Õìl·÷Á^aíúÞzKUkv³sÕ' G}‚0 ·Õð»æÅ…E S0žŽÉ²”¼È1¦d©»ªHƒsst1 wa¹áÒ˜§ú«\ºpâ`PØ7Ó„,.ïgqÙ+òÜüÚ7>ç1Î:2…Ž +‰p†–…#¯æ˜ÖÚËPλ4xYK3i›‘0*@È€`NæBÈÜžd½¨I)@Øùš”’É`œûͨ5ÄQ@j²´¤4Ž ÁZêub8)XHÔ¶Ðùüs××?‹{¡¯õïçnÛóÍ{K;ßÙv (l[{vÜßÅ,ôóÇeÉS&“Œ8éЋ[dÕûo­}Î~aü=xL‚¿‡$IJV^M1ç½ÔžÔ¦é/g˜N§Ä"ñãl ¿ Â’Äyž7˜„ùt\½9ÛéåÖ}†»‰«œ±lõdãÏ>ýa(hu)Šœ„ÙængªÆ§L|™â®~Q\c蛵þï++‹ìß¿ÈËo¹Ž¤ùl%‘¶DÒsÑ:HBÏ V”II:²”MõP­6ZZÏb弧ž•y5@3ÂW}æôGCT Éò)AÅI.>¤\#³W‡Õ*€O™&.`­ˆ¸åpêŸÛúų%I)<¹ƒÂÍíò휡­ëœç'•Ã²Ô[ÂQíxkÿi=Q3 'C„„¼ÌH·Æ€òyåjçëœc<!• +&~H…c4íSTÊ=­¨’»å,q%Z„ùƒqØõ2üÿ±Õ/ï^Ï9ÏãžHÈ2C\‹NãÃÙíX“OJ¿Á³³ãœœh¼˜m u'¤›§¡ÐtµÓŸ'‰CIávçbç°m¼Ò{„wÏ÷Ü *ĸÀIAV8² Cr>o}gB²51Ä¡$¬Ùõv‹8çs‹1Mg)H š­a¾-œ=ÝyúüFe>L½g}.ì]ÿ¾óùwþßXñ ƒ× Ñ¡/7‰’.ÓéÔ¯»Â“Õ(¶”ùówçp=ÎZŒðΖÆ{ºÕ÷£8dП`Kã1 ÆkXEÆÆ™Ó íN¯ú>¡|jÄ–Z†ÜZD]s§´“‰™!­×àN|6I%éõz$ñ¥…¥ÕñD- ±f8è³tà—Øukr¤¼®7þ^u6¡rk-E:Æ9I×MeÆ!T„šùë|ÿ¯ÕÏ1ÿ<ͱÖ`Íl¾YkAÊŠÃÃa‹¼ m;¤TŠ0ŒÒAç|¸º4%Å4/|‘¿* Ï&À"0âV—¼ð“±, œ¥$¦œ’N'¾\)/) O©9#áðÿ[_ÛªøŸ5Rí~è4MRš¼((ª];&·kÓI†s¶"„ŸñZ»*Zè×m'ß·«Îã,Ô=lÈç9'Ãu<ú0½_@Û‚<ÏÇÆ<‚€õ¹f1+¥†Öoîñl}ùÙ\¯RŠy‘SeÛJl *„ÁKI¨ï\WãCG$PT9³Å½áéýj-hhß÷[Îß@ŒšAÀê¢g:›ºc¾¿/­S4oTGWc­ˆÆ = Æs© còq‘9‰£·ÈÂÏw ŸuꆵsÞgÎÎÇ@¶þôBbŒØ¤½aï„°% ²l4NÑèí:™ømÝ°»»Ÿ<#ÍÞþ•t3CÞÓ65bh$‚µvð‚„˜Q¬W9f¹E¼zX÷X†‹ÌËŠÕj-ÌèåzGø%FEÓÔc(ŠüLt,£iZæ‹”ÜW Ò!*DÉU)%y¨aÞn¤ð o{¯úòG¹|°GHž¤4174ë%óK«Y-—ßÓwÊ–³È£E€hxÏ xÑžáÚ ‚K= u:_úï˜?ÖŠÂZ>yë:vÐ 긨·£gÇ¢øüƒ¤^%·2ÂÕQàMß¡LNf$úÐ1òžõ~:e²)yFØß»4j/ªSjM£f‰ªµQt¾A)-í‡?†tµJáSnßÒšÜô¾c„ Ñ÷{;Ã:›žf0Ò›‹Ý+w¸uøn:¾ˆ>²íóÓpÿlŽ³‘Ü9>ßqÑw¦¿P™é'uzdÁKÇ/­5:\çÈŒÁ*cà#x‚iÚa êQ©›œLK{Lõè}h÷ÜïYc5ý}˜”]^4/Ïù^tüó¾/a‚bݽc1ˉޑ…òÙ“&0·"ÿ)Á‡£n=>(Q Cõù†XDÉѤwµ"9£ƒ³¢[¯ˆZš!˜˜ö¨³9¦4” 4MÒ"·†¢*iŽ™Ígt}FŒ¢ÖÖµ5Yf©Û†<û¤dò¬˜NP0/s\¿qÖcŒDߣ|W)F‘¨€&/v±YN9¿42ƧÃCï“1Ž¤¬m¼Ÿ3HMa4™rhî«Á{ÇÎþ>UžK»^"Á9pëíÉ EQ°ªWäÅl<–6eØTÅX±+®÷ÄàˆºR£1Ü…‘! 9<ÿáo1 ìv Êñ;™ m©¥ÒØè[Bô"ß9àóJ)¬Ý4°Ö°\Ö”eFÛõØ,£íºôy1’1†5Âpt÷­2œëÓ1,¦ck–Ë) é˜$õ¬r‘EnƇµ†¦Y“åRÓHT£—£µ¦®×(¥È²LòЊd4¶_iO7èA«Y~×÷r_.‘¶1• îùۉżBr ~+r3ÆP¯¤aH×8NW+Œ-™/ Y­)ç(xíƒBuz÷õÈ«¯‚dß»ÑsH.×oßÜò&'«b$€ ‘¯Š‘ ÃJUÌèH!ë7 m;œVĤ¿Ý8G1À*žqÞÆ— ³ì-.O=¦,Ûü*påÒ‘à&ŽkFÍáÑ!Q ÛùÅáyĘœX,vÀìœãƒG[År¹d>_¤ZÚçCZ"·ŸÖmÆùÅwŸ½qns•ÏÐøtŒùèµ'ú%®E©¥ óÐG%¹é\[ŠBZÅ:§Y®;°ù6dX,¨Ž6ðp×wÀ9yÂA™Âå“aÎÈ2^Ÿ%ŸSVôýæcjNW FE̼"F—6X8êZK¥‡±Šèä­šÞ‡µÒò3¦|¦´Kí#ûÛª•ˆªë¥"aofX.WxeÉÑFÓôŽL «ø,ä?À°D)ÅQÆ’åwoK»Â®¢ìê¥ÅÒÆÐ51Ê>)­i7s:äœcŒÒ.Ô\ïX.—›(N“ØÚ5õj%«²’ª*$šŽq4ÌS”@)Ѽ0zÓ_¡, š¦–ôšÚFºb”N[1ö>Ûa†v™Î9p=u[œ¤åjMVÍ9<<¤ZìžÓR>›£ÄgïZ‚ë°ùŒºëÈ‹j«‰ÊÙµ³}Í›ëšþ„Ô;{)ΗwŽÌjà“±6¦D+‹Í1œE‘¼Çùˆëƒ”OÍ*úÞ³\Õìî]Á…cŒÉÒ„²ÂBôä&ãt½Æ÷5ZYêºFkEQ[cLÊD1Ša–\2‰d™ #°FØ!zŠ<e£.²^·ììTÂÌ«*´Šcª0t}›"õaYó¦î" ŸÙœÞuìî°ZHk8•T·´â㟸ÁoþöùöoýºÉõ/·žäwNXììsí´¶º›ü Oó5(¼Éy×ÇZ{aÀªŒ>¦::¼ÊQ¤~«£·š®4›ˆtÜh"<}¬xÉ¥aÞ„Âx6ÖÂD…Ó‘e]SÌgÒž°‹ØØp"y™¡uŠt—ÆîžÜe0æ[°‘‘nE!ñòB©)oÒ½îï\!Ê–FD˜·:ji~1:+[¯å¹/«\YÏÓ·vùâG÷(ÁŒÏåÈïÃ|¿Ÿa9%|:†xz¬áx&8Ze9ª#±[±t円ܵ1r0Ë&Çú6+¼w¬Zf²ÙøÈln¨—<ëô¾M§ê\?O¡Ôá:í¤éÌtã1ÔA›æóI_ {ÏÙrÍóòÜBlŒœ¬:ª"ÃèŽØ ¢ægRÄ*˜,Jk|´]„®ß:ž°”;¬Í°™%º8:J)ln0±GkEžç8mpêUV°®×Xc¨f:51 (•M:úQÑ…ˆÆK‹Yçж`yÚ¡TsyQ¢”åä䘪Ü!;æYøvøcŒÈü¢Xž®¨›UšÀŸw¢OüZ”3‚•·2Zè»ÃóOÊWÖZúÞ¡ƒ'¦fZŒ‚yU²^·ôÁK:CI²®° !‚š{žÏôYJœìPAºÊÚP(“aµÅfNeì\ÙE§}»Ê,º°ø$ellŽsÄ@_/±Ú°jŠrVZkŽ†•A_!¢ƒO1`JNzz b»]fÒö58‡Îòm>Ô&Õ::“ZaAÑwŽ²* Þ9‡sŽ¼x£i;vv÷ñ1’å•f£ÉŠ­Gwè´E5Ç@1’çÙHÞÚ¼Hâ±µm;QÔAŒªRc“µ×KŽ$Ër<ŠÝ]Ú¦f½^³·?çøø”ùbF KWäèî-bˆ©ßpzÁCRÚŠ›ž°!ÈKÒuRîá]C–´Î˜/v9=9Æšˆµ†_}Ç{ù•·¿—‡¼DÛu,fó-|6›³\Ÿ²^­éûÀÕ$Ï6â ÖÚ¤”¶åQjÐnÍcŸ§0Áð??ê)ûž—>¢y¤R„”NxàòUnÞ¹%½y7+5a“_?yš~;wvæ\v5&Dìà}K§AÇpæÈòýãCvwwé\OÛ·‚, Æ÷"ãÕÈB¼|°Otšˆl®ÁFîœVÜ:õ\ÛUÉ3‹‰¸"ðÖ†ójQÏðÌqÃË¿ø«ð}¼PPås=ž¡}.XöùŽ³9ÐVe,Gò²bèÞ5=ÈÅ^ —[kÙË"Îk–D~Q{ŽŽ=Ñx4v]¦ôÐyÇÙ>ç6|žÑØÂÁûD(ýÔæfÈñ-mºð8JQ7-*FL¦‘ÞÕj#N¿1RŽ&ÆíÀ¨*Lô¹¢i·™Ú1F© V%b*CM¤í¥µ®Òšºqè¤Ó¯uÏÂæ¤(ƒ,Ëè“–vVT ÍIÚ¼ î>DLV”Æ&nÊ ž<£µ”à¹×õâ,|i“xT›TÜ´1x‘Õ8dz²JÁU‹ï{ŒÖôu-çE|cŠd´nÖÁ´]4lÝtì]ºÂéÝ»”UÎÑñ’Ì©}6Š¬Ú£¨7²6IDAT$Rò^Ú°e Ìš£;Ïðñ¥á…UCT%YfìlĈ§ê!™é\ ®f³j“ï<’Ô·®[²Ì&ãî±ÆеŽ=Jš6põ‡QˆÇu|t$Þ¤—dº1v„¤ILêÎy¼wÄä©åy6aÒE¼ë1yÎÎþU–Ç7¹uã˜_yû{yì+^Ê7~ÃWR•Qmú½öÎÑŸÖTÕ.‹Åe!Ÿ)¤\Pb$Ïr:×SeŘ‹PZ:I6r\·|ÓK ®—ÏÏ®4»3Õ†Ðy®ì_âúÑmaZ&Ã<ä§aª“g‰eo®F"ƒ6Æ\Ëå)»³’;½Ã+ÅÇ—'¼¸*i<ì%'}7I#ËÜa«v‰w‰ä¥ ,¦zÅælþòÛÞ.\aÙT”ùvç»D È §õ »³Š“?‰Îd³éˆxŸ_ólœ±{åuàÿßÚçzœ…tï7.20S¯]GO§s–¬{‹Ô¬.2GÛKÈYSÄM7¨sG±£#{•âxÝRÔ¥RŠH+Í,Ïè£ë;A¶4¬× RAÎ9t.RÑK®õIÏÂM?e¹Åª>oL!Ä‹æõ~ùìô“Ô´½“2G¥ å¬ØÔû¦>*…rÝÿ¼JDJa³u½ÎEr½‰Bdþ‚÷ 6åáÈyA¥ •ØKe†ÒœžÔ#&¥HÒ+>ÄÔ»ÞúØI•Cˆ[÷ïƒ#EÛÊ1lž‘Ç€kkº¶¦Y“U ‰è£"¸–Û7ŸF™‚jg¥eÍòRj')ȨD´D¥i×Ô4ÍšÙ|AW×TÕ “œC:«Î w\¼î•REƬ6¥x0:/D\m FOâ(ÊáE‘‚£ÈJIÉO×6ß¾Nè;Z°¶b±»ÉJ™ãþöMJŠÎ†ÖSTcÍóykïìšRJ¡ÎÆ™ÏO›ŒLµR »³˜Óœž9m'„c3y±²è+Úf”¹EéŒã»×¹Ñd莇ª mì˜`7‰<Ñu3;Ç'%°å%Ífh³‘.&ó<Ï̉ֆuÓñàÞeîÜ9"ÆÈb±‹JÒ‘˜J(m0Ʀܲ@Km+Lê¾3yÎ@(Úä4u½b‘I.ÝÃÍÛÒ!èëßøåØÜÒ‡ž®q„™ÍØÛ¿J æn²\5\»ö°¯¸ÉÃVy±Éÿ*M׬¨›SjeX·Šj^20¯Ü)ið7½1ˆh¥è‡¾©j“3—¿ÁN–´ºû>‰©'¹’ä©¥°¤¼½‘‰gë5WçsnÔë´x¦´t»ŠaâìcžŽ 6§6ÒQËؾàÁkr¬9qžýâ  âäô˜}AMRïæ­r)¦/ívžGÙ–«5_ô¢7àƒKsþ§£Œê3ád(¥è£aYãº)¬!3’o¶:`ŒˆY¨ öÆ{3C×VNVˆÐ:5Jƒ+"„@‘edf(ÿƒù¬”Ô…Õ Þ•Íªi iû{˜ÚSfkŒq”ì|>ùæOe~Îýý–ŸF6S(Ý(y'bŒ,f9:Ú ò3:ñJ&bÀÇ(mLLzäÖzf`ÝôX›3ŸÔMO0ÒYËSŠÈ²Zw‰È·i‡8lê1FŒMQ–¨>D5¾«†°fU7)µ {E³Z⺚»wﲘ/ˆ.Ðû–[úvMëeYtj;™ç dòªä:BèM*p]'Qv9›Só¨’Ô¦?òð¼§ö`[‘½1I»$\GpNÒŒ©ÇZËþÁenܼIióñû„ÈîÎô®o!ÒÖKšz FÓùÎ>~è_?yÖ1Üß´e)å`h/ZOSžÍ='Ïͽ†õAaÊG‡7¼‹u =òšõ¢'j)t¿<›cˆœœÞàÖÝíV胊ÌÆá¬ÄiÚ†<˘Ïç4M7曦egg—zŒV ~„ÖŠÕjÍl^ &õ‘MSKôuíaîÞ½=ÞHž„àP–§Ç"l¢³DºØHê¤höÖŸþïœ.W¼äуRÞ9æÛ¿í·†ž&@Óv\¿qHUTUÆ|q™"³E !vDR´Ad½^Ó®[vw¯’ô¤÷,³ýfôÆú¾Ã¹šÛ7ÙÛ¿B9+ˆ*l Ÿ¨©²Ž'¯¸ÀœñbLyo³1Ìr¢ìæq„Ôcísx6 x`ÿ€=û $Í#‹¢Ñ£P5µë}ïú=ÞõŽwów~ü‡øõ_ú->ôø‡ù3ßðnß8äøî1ö[ÞLTCôž r"9€´v“è>²<º<ˆRŠ]¿CŸ!ë3”uxôĘK-¼XYãj“g¿«†(QœA…"ôJ¢¹Tj’ÅãøM~ãm?Ç÷ýãKŒ‘ÿðc¿ú£ÿœ?~âýÞâoùžÑ¸œÍW_4¶H8gàÆ ò}£éáçD#PUYRd„ˆBÀƒ2`pD Ei#¹ÍXÖ‰$fõüÍ®^¢$ï^¹–¹óÚà}dÝ¢&øÃw¿“ß}ûÏó×þÑ¿âÉ÷þøžßæå_ó¸õô³:>ä ßò=8Ÿ¢¾¾§ijÙTHÚ›û´Y†Šž~*/‰½ô?0ѽ¥\ì³å|ÍŠ”‰P}ØÿäHµmKžä.TapþV«ÕVŠB¦"ÕR 3ïHTeYƒHˆömÚ¶'«æãq]Ô\¾úÀèh­Él‰5W7¸ºæñ÷½‹'çWùê·ü >ø¿ÈjyÊÃ/y%hC}rÈËßô—Çy1¦<‹Ýù˜Æ»HKa ÉÚ,•s®çJ_ű1 Ia¾¸œ¼ŸHïG'wÑF“KQä4ZGŽŽîðÌÍ»®EÙHQ샓Æð@×9ööö$oá¥"Ú¦ürU8/½˜}·Qóñªª$0[b°»™®]%¸TcµâÖ­g¹tå*‘@ßöììîrzº$/gòY­°F©ʪä>ú¯ý«±VSUåäå•åcÇ…à‰Ñƒã=Ïd¼æ‘aãœD¡bP|òÙ,Qc ÁYT<µn%·¥4JE^õÚWðñ|€›×oñý?ò½üìOÿ^þ_F–B0l –È}&ˆ=¬±Ä—=}æwi} 0䆦oÑÊ â6 pÏH¤26FÚ+K" Ñ^”.ý¬×}í›øÈ“ðæo~ /ø¼/àÙ§ŸâÚƒý‰°·§èžœ§‚£FŒC–òg1Ft§Õ¹žòúQ©Mz$|ÔRJ¥„ÿcDc8í.(´Ä‹Œ»ë°ï—3ž¡Ïù@ø1^õú7ò‰=ŽÂóžwþ2_ôÊ×BààÚƒdE¹õ}:óy×ô©~wØ“ÊB§¾ÉåC2¾€2ÌòÈjզ瑡Ôa‰VQ´½Wë5!l´ºm±ƒ²~LéXDÉ*øÞcµfwf¨[GŸÒ?/{í×ñÔ=6†÷ÿæ¯R-öØÙ™ã®=D>›Ò˜¤©ªjŽ!£®kº”úë:ŸŒWÒ­¶*¬%Ï2tŒ4mÏb7í“IcÜlrÀ•Ž8ßÝëT*4¬)I¯‰V·ãÚµ«ß¾APeòTÞ¥Æèؤyó¡§iÊÙ¢çèÆuˆ›ak-Mt5Ä *Ëç+¢–õ|Ú5œqí…ò‰'ßZKnþäãÌvöÑyI–o$?•RÂ÷1ZXïz&Ÿ#ˆq$ì^ÒO!ì³Ç ·UJ±î;¬Ý§Ë%ÆZ\ç9^³gw(ȱ™åäî >zd0} Ë 6:V«‹Y‰Rçz|›çÔë•°ÿB$Ï }/z¯J‹~v×Ëï‡ÒÍÇ(¾÷8ç©æs–G·v^çÄJ±wù*Fö/•(™µ¬W'’×òò°ïÞ=áŸýÓá?þÔáÿæ·n (ÍÎÞ>Êùãødɇ?üßöWÞ,®^ê«|o^D~t=En)Ë\´À'×9ÈXNŸã”اB ·š"×8iSY–IBRþ»˜_ú™Ÿä-?øc(#[çV ù©õžÙlFsxe!SÁ£_ü¥¢ç=oCÑJq0“(@¤»M^¾Ê#¥…õ'³¡2 ‚ëh­˜çÏÇÃ^¡écä¸n¯ÒÜZ:ò!¿¬î-q:ûÿg¯÷#ð>>ð®_ã¯û:¾óoý(oÿ…ÿÊ‹¾ôUãg•RR/:\†ëPZJ™Ôäø÷ƒ¥?ݨ{ ‹kÀk|*§:{Π2¥1‰–ø®8§hÚ*/Rd,]½¶"µ‰ ê=×Æ&¿ßÅSù>ôž_ç5_û&^öØëxÛ[ÿ=¾òµô¾#Ó"@ä‚Ûz½Ä÷-ÆdTÕœårIÀ&z5–¾ï7ùp#‘kŒÙlFf ¢ß dL¤k bH=QPRÌØs ¬r´–Üûl6Ãõ5™Ñc`EO×® j²ÂÒ`0\hG®L»t!RìíK#/|¦"ªv@ͬë1yFŸæ­Yž’eš6ŠpÒÉ[4ÍtÆñͧxæÃä/{ÅÎ>ïûÅ·ò‚/yì\gR…´ñëI9à™*>«•’h=!NZ«T§ÆïÄàPʧ6Zó!|׊LÁ—úá¿û}ñïýýà`oß·tÃi8iÖdZñ‚«@4t]Ë“‡‡Í!Æf8ï°&£mÉD‰xòr‡Ý‚£;GØL‘åsšz…ÕPTsNN×\:Øåää˜:¢Ôu“ÄOÖf„³ù.ÚhŽŽîP];(Ì8»×ÐVL—e–ÓãÃÍ¡6ظؓòO$¼bgïR28éhÅ¿ø×?ÅÃ]áû¿÷›'àÞhX¥è\&Y®cDš£|vµZŠ‡ xß Ëp`8Ç”›EXæëºa1Ÿ¡”♓ëX­ñ^àù< „hùà­Œ+³È³^ꯇÍ÷>!dL’rÚpgÝ -̬en3ÑúŽ 4Gǧ,sžî[²8Ô;³qŽÕ}¢åé騳¿sÀéò” |"}m bªzèé£TzT«Gpm­‹ÔM¿EŒ:Ïø>—âØs©± ¾e1ßêm?À˜À<Ó ¤RA³Ù|²dÓ”Ž”VW½ô+Î1a™ÎÍýîo ¶O_‰cy^uëX®[\ß%©e#ºÛh´ÉèÓ¹¾—Ò°Qyq|¨sà¥ÜU%!¥ Hj[²~ŒVä™fgw†ë¤UïêôXÈ}Ásûð.õé’Ú9ªÝ]¼ ˜¼”R-ßo"R4.Š²¤k%ß<ÌÇP¤+ËØ x:oÁy–§G¬ÖKìü€ùî>>jLVHÏà°åâTeˆÞe6ºgó0ÆÀ,}~z†šçt½ƒ”tŒ¸^îG+!Ûa,ï|ë¿Áž®OiBGŒŽ"Ÿ;&xéTå1(e8Z.±yÆKœÑ79Eæ89:§ɈÁã•âàà2Mß $RUœße±sÀñÉÕÞ§«._EÈ’PÝ´d™¡mz;uÝŠÊÔ›\yàv{¬WGØ,cwwŸ®+D‰¨(ò1W±\žÒ÷Y&×½{p™»‡w x²¬ ï{B ©äCáÛrxZ+â£Ü¼yÈw}ÇŸãôär¾7 b o](é‚R•€¼l*ÉJ{JKUÍ‹žÎKù“…ƒE¡¶íR.ž¾}“eµèâZûðò«ƒf«á(-8öö¢J×:.¨ô³QpmQ%öµÂd1NOØÙ™s}]‹pBŠ’Ïæñ÷pßV¡9>=Nˆg§ÚÁhÃj½¢óݤd*RäÇË#”RìÏ6ׇîT‚v(4wŽyì•oÂ÷âpüi÷38çó¢Ó!UrÑ!$Ë™QÕ¢º¯a : ,ý™æ¤Ñ ƒRqRG¢‰˜3²‹g¡î³›à4ÚÖ ™*‹œ<-pQdô‹ƒXâèx8ç6 qÎó"x])…O| "´©²ÖŠ<Ë(ítmIõlø{3+%Z844+û¸+ BèÙ)¥£_TbLƒƒ.tdÊJ# +Üm@‘1z%Œ­H;6z#ïNdZQè€) blð!²X,X.O‰A±3ºë:i2¤5nØëÔÙõÆçàѳl•Ä^¢hY·}˪¯9¹­¨fóó³ŸxŠº9%`ˆ&'Ÿ-Xl™í'ˆÞ(Üb%@lV§D×aŠŠ¼œ‰B1½6ëSÖëõ8'Ã?&ËèˆÛd@N‘I'½ˆ"*»åÄM‡÷-&+@ ‹Ø›ŽqîÏyцÈ{|F&C±iÅB /›ktˆR¶øù_ø¢øƯ=ór¼ëA[šn F3Ë ŠeX”šè#¹5xÈrK aÃÌz/°¬÷¾«äÙZk©ë5EQ¢´¢­ka "yäY5§iÖ#y$Öæd™Å»>½€eúK2ré1JOR¥R„èP:ÕWÇH×6t}BÊ{†æ¢â´aª¢O<ñ1ž½q‡7|Õ— “åll¹²1]­R.:¬bÚ SÍ&gë½=Î>üé&¬Òf•Ù°uS„‰ç=bK¹ÎÓɲ¡, –«ƒj[КÚû ³÷l^pólÆ¿œ½®§¶|ë31ʼLÝå(jò·qÎb¤ÌK¦â£“­œ[§-]y±8iÂzûS7äåù>ö]Ú8~ççîÏùîðç˜ÈñS PSÀ%Gµs[ÍO·Î0ü{ãÔÝïú7Ÿ9ï†ëp! ó<­#鮶êpÅSçÍÐæ2FBk†ûJ‡ˆ¦6=νó’[°:â›mÎ3ÜïðsÔ$¤Jô!9ž!’å‰ùž¦¯éR5¯…m§Ls6^AJ8M۵Р‘ö”ŸõÖ„Ì«@«mÇW šäãT"ŒÎüPg不¼­Š!Âíê–bV‰Iˆh“רÒóˆ©{S:éàµ\Š¼š÷¤ïût-"ö1ÜÊ@VͲ|ìõ€ÍÉój\/CÔã,A–¼CÛ‹Ó…Ï9¦ ¶"êág£u|øÝ¿Âÿ5é£ÆZyfIEND®B`‚advancecomp-1.23/test/mappy.mng000066400000000000000000001637561301462770100165520ustar00rootroot00000000000000ŠMNG  MHDRà ègªîý‰ FRAM!V‚”Ð DEFIÿÿÿÄö2qX IHDR Q’<fPLTE!hÞ———¸hGÞÞ—ÿ——Þ—¸GÞ¸hÞ—G¸—ÞhÞÞÞÞÿÞÞÞÞ—G¸hGÞÞÿÞ—Þ—ÿ—Þ!hÞÞÞÞÿÿÿ“Ëy¬=IDATxÚìÝmoÚ0†á%¬”%âHó7ÿÿ9jHOë` øGÜO»x+‰}¸j’jrIÎñxÙºÍÑÅ¢û鎮կOùîFw›v´‰’ çèã¸ö.Ž·ç Òï_÷­ÇÆà¸MÇkßÇÅ…M_÷v¼Ž£¯¯"8åÏ9nBÕ}5YéÌqYtÎQ?ÿñ‹Ï*pü«‡Öœâj5éyý;ª®V5§~ó•Ë_¬¶Æ\íÐo׊cÌec\£íS8z¼×®G¿×ÒÔ>‡£Ø~»V÷²'lNÈFŸ•Ñöíg֮Dž«U†Å]~pÀpÀɈsü‘c™d7+Ž¸ÑÈ3nF1¦N¦qsàh¥tr›Gk,¦“mÜÔ8Zc9|ã¦ÇWãÉÏ“qÜÔ8Zb©É“sÜd8ZcY¬ã¦ÂÑËêä7ŽÖXV'ó¸‰pÄ«±Ði9÷¸Ip´Æ²:ÙÇMƒcn$›Žä7Ž1/Ð)0n<Ž1euÔ¦€N.Mz¥É<.8·’G\Šà7ŽˆØSD$]‘"œ'Ç]\L"W¢‹H"q á,W\Jãhó*Ež§±îS8 ÇÕþJâhZe<Žëñ²™ã,wÞ_I­Q«ŒÅ9÷8mg8‹Æ÷WÇz‰Å¹<ëïÆÇY6‚82/R"q¦nÎí gѸóþŠâØYâpÄ2âá,wÞßšq¼DãxY7ŽÕï´Kμ?pÀp¸Z1sÀp¸ZUuµ{#b֞șs ÇYy¢pä6Ž€Γ8案D<Žœ²ð€’ç}üö~‘ý„OyzàSuÄáÜíÁªâú‰GÕqÀ)ƒc«Î¿SøM=pÀpÀœ7ÇiœŸ8­íĶïŒs˜áôöGú÷Æ9À'Φ·£ûøóç´é7œs¬fôÂÕêÎÇn÷1Ž{÷ε™ÓŸuÀù…Óº0snà0s®ã4mÛ0s˜9‹qzfŽË‹Î1‰RÍ:Iˆ#‰RË:c*Ä©f) 8…pÒ¬£1wpbú]”´8q«ÂÇeè·üúœ¸¥"áãr÷ÞœáðfÑà€8à€8à€8 pDÀ á8àð²â„ 8à€8à€ÃúÖç°åÑ:vàëØíXŸ£™á°>Çß_mv,AÑx6ãNg»Ý®c‘vÍöô Ng·'Œs 8¡|é|€8w¦8à<³Ý¾ Îò·‰yÃKyû÷G^³÷²MnœfÊþë×N«Âé^³9§Ù÷'‚8"+ÁÇMñ™#"×qš §©dæŒ:s^Óì¿uêyY•Ÿ964s¦TvÎáj1sJàìë»”×3sº¾/5átwp†Ü8Ÿ^*ÀéÆ2ã´}ß~ÿi›¶¦òj†qÌãe=W«a›Ì8öÓûGýÿe¡8#ësu ]×±>'TÇ ‡%(~ÝlÀ ÔÑ ÃÀúœ`ÃÀúµX‚ÚèxÿœÐþ]7°H›ìà€8à€8à€NM8"àÜÀpÀáeÅ pÀpÀ‡÷Ïa}ïŸÃý­¸¿Õ8Sîo8Ì¡r«ð“åþV•ãÔ“Óy¸,8à€8à€8à€sÎœ8‡8à€ó¿½{Ûm†Á¼x¡Ó¤ ‰ƒ¸c~ÿ·œ`VZµ”ÃJþJdi½ù”WÊ î9X­€à8ÀÎë8ØŸƒý9ØŸƒý9ØŸÉïç`γ÷aÎkï߇ý9£œ1áèZÛµîä#c‡Ó²¿lÈþ8ž‡Že;]€sg%ŽÀc9bœ®=Ø&^œ8pºp$Q®VBãxÿouLŸC¤ã|ÎÕçÐåBlŒsÄ)ƒ,¶¹‘ȸ@'>§,ƬÄ)¬-’ÅéÚ9œ«{ä‚àÑbã“(NûŽè¸”ô-8KuÊ’ä¤ôpº×p®~꬘9Vt>JwÒ›4ú½ç83ÇÊ‹¦dØçè yÍÌ!þR,åAˆ†'ó¹ä‰ÃD^Š£aΰÏ!* w¸qŧÃãN&â ûg£:¼4fˆâäÔ磑¼Vêh™tŸ³ÿ£®>%ZeÕ瘛¬°‘à÷s°?çûs˜å²y|Ž£÷ßã®8ìÓnçqØç¿Gà$ˆS=É;qª ÜsæoÈo¹çĺarf)ßjÕ¢ÏAŸƒ>}Îé—rà$‡ƒ>}Î}ß›—îpêš5¾Ž¤–pÝ÷r‘0‡õÙqÄ¡þ»05p4G+àÔý‹¿zœ°N8MÓì€3½Çë¤m~š8lDg79Gë”q¶Ïœº(œ…`õÙqx§°N‡7㈆PL%¬ÓÖá­8úA,‚:åT;ô9Ó\Q ­SNãtªÍ8^C-´N=UÅ;àß1µÎ"¿¦{x$€‘:IEND®B`‚FRAM3{ô MOVEV&oµDHDRà :³kQrIDATxÚìÝ]kâ@€áã®ÞØ"ŠMüÿ?kMEð¢Ûˆˆ1ÙÓ=„`)Ú˜õì{(3ã0}LfÒq´Êb!—"I‚ L5‘D4´üEë"IN ‹‚fe½5,»Ñ‚5³_;~&.õŽ*@{ _E,­Ô[»sõký[Û†zoW­xXËXd ÖbõÖPoÖ€e{M~ò m` ZñâSÖW'W«GÐâ{c°´võ1(‰ ï´Y­zJÝ>‹Ú¡ªôo§h³¨ƒ¸¸ßk2Í,ÿVhÛZ•õcy{Àý~8,}E¹Ì¯Z?•¼% =çRBå¾hOX½¿€Æ=€.æ¯@›ÊqxίZ?µ¼E †"ýÍ¢·‡=?W¸Ð @€7Çó3@€ @€›¾8¾|ð˜N @€ @€ ¯lx¿˜²ùòà±ÈbT @€ ÀV @Æ @€ø/yéží3€lŸ±ù @€ @€ @€do‚í3€ŒAfцcâ8qœyÎôÇ7p2™õœ½Ï¢9z®EŽ¾›{ ÷1¸‘žo ô>xl6ÞkçÀ5@VôÐqŒÇþÎ÷&Æ#ç»KïÎóÑ»o ŒvÞ÷W\ý*еoÎߢr™à @€ @€ùü Ÿ>1È,  ÿ) @€àäëù2 @¾Ý%€Ùdw  Wà~»ÛîÒÔ90ó Üm³´›ùn¨¼Ì30ýÔ|X`1É8>E5œÏ¢wÆqZ~ï#˜fûÖýt–/£Îg¶2ÉtöIzÈE¶ìfMó,ï;í³¬+ óCQxš0ø•H$ý~K§h£À•ÌãßA÷OÐU úî¿\Êt6 ”8.o„¡¿õà*žâƒùÜ­ã8ÏåééãCËQäk=hÀ2Tès=¸Z{rìEY†.—KËe‘E@F‘ãõàÛ›Èë«Çõ ùÈÞ»Km ÈÈu#Èu @Æ @Þô·;Ö¢(z±° ßøÿ¿'ÐÂÊ„ ™z«ñ&·<Á¨ñ`))±fÚÿr†D—vPг¶ý?Ò².G*Ýô+€;hú À€A€Q'Ð6nW+1*t# @ÛŽ}B‹ñµÀZA¨¤¦@Óž0O0‹€0Fkó5aÚ?ðÊ]A0Ð+¶Õ÷‹XVL»ˆr]¿›².i¿»9A*‚}^¦½®Ò9äªh{L{Þ}Ÿ' ¤ØïêÝþ÷’&çôTÐLIEND®B`‚FRAM3{ô MOVEV&oµDHDRà 8É«"IDATxÚìÚñOÚ@Àñ“°Ås‰¡E ÿÿŸ5 !ñÇYBJ÷Ƶ¥câ6}û>µï€«ñÓë» œ2ËñpÎýÁmCŽDš:·=¤i~Ò¶á¤x>tô¿R¡[ù4ßx—ø+Е€EþPJÇðü^¿½‹‘_€]èûá@© Í#ÀRn0?¥|·: χŽú° ôý]þzÀkÐ7«#sÐY…«ÙÔxK V¡_µÕèÜçÈù€çÏ¢úre ·è{Ï¢6¢>pµÒC¿¿mh ù¤XI¹k8¿œ›®Výþö †oû\Xœ_ÉÍÃ5—*¸0\°êïk¨<Ñ4 >1 S@Q‡»\Xœ_É 5io=?Âõ©A`¡ @€ÏŽÁ @€ @€þ F @€ @€øŸïîA€©AþÛ @€ @€ @€ÜÙ›`w @jY @€ @€ @€do‚Ý%€©AfQ€ðXÜ›ÞÞZRƒíŽ¹~Ù> Œ¢5À§Sã"¢Áp0Œ¤-q:päc UØ ¼ x}=ò#h¨ÂÖàü·hÛFpn¼Xo-Þ¢y˜EËaxsæ€ñpï~âqlX{@¹)=`o‚Ý%€©A>Ù؆x`l4fŒ @€ž]€6ëÀï @ö&Ø]ä3€ @€ @€½ v—¤Y&¶¸\,6²—Ö€‹åpÓ•o–[´_ƒ/]€m.–e ë`ÍH’8ÙÞ:˜Ì/^î³É¨ó;Çö– õÉË:éõDTh˜m²Îk§iàåG³µ¦0‚Ö– º¯©¸4½¸° |H~¸îO×U ú¬­ƒ3J’ˆ86·ªð¡—¬};“Äà:8S×ÕÕó³ht“o—²<4 §ÓÉlòúEô;óEhlœªpâ›Ý©--8ñ¾©É÷ƒžõø¸Ñ–Ù÷ƒê{T*{ì.㈽ €©AfQÖAÖAfQ€©AfQnÑ_ÝÔ1à FáGWCö*÷¿^ kh ©,=€óHoüâ/PµlÖñW+Né/JQõø–Þ‘ûx=]?h±€ÖÏæ Œöú&ìZ#ç dm$&Ðw`ŸÐs~,°5’'©/ ul äL­" Ñ{)ª®ã÷z.c}šê;.pù. Š€ûÂÔuøO”}ÿ=Êv{\ÇÝÁ8E`÷å:ê'Û…¼€KdבwÛÆ¢ æq}÷Œ¾û”–ÑIEND®B`‚FRAM3{ô MOVEV&oµDHDRà 6v›¼szIDATxÚìÜAOÛ0`·£ê @ÐòÿÖH;\ªÒfN‹1M5 uÝÖ÷„òœÄA|qü‚jD¸¿§‰¦©ªí¦iºÝíN—C:ž;vgS#uË—½5N§†½m>þ®ß»›‘n@¾©ï'æ怽üU€Û´ŒÇªŽïuÌŽ Üõ¯^ÏþìL¯sè“ë <¢y{Ìýç`èðÄÀªh<}PEÓ#:l>N\.ãf:í]Jùƒ± ½®éú^¸\N§ÛMü1¶í”¦ëûy `¾çáø`¾a‡ßo`æ…8€E³/ Ì% Í÷|$0]ƈȪèÉ#ߟ#^ô€€€€€€——€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€å¯¯ ^]šƒþÚÐú  9¨ŠZ´ºhª¢€€€€€€€€€_?nÍÁAã д6au Ðú àñ¸pà¤øGt8d\\”^E«ÂÕÄA#h ÷ õA@@sЇN€€€€€€€€€€€€€€€€€€€€€€€ÖÍAUðŸG]Ïf)—¬ŸÎ^nÚ‡ù¨Ë³‚€Ù^Vm“IQX$°Ý´£õ¨X`»Š©ÀÌÂê{ª¦9;+êÕøW5ŽÀ‹Ìc¸Âúu¯¨×Dþ¬W»vF³òÑÇzÝžŸ??wíQ‰ÀP?´»Æ|^ä¯j‹ÅfÖߺ¯v~W$0l6éÿKÜÝ Œ¾P0 w¬‡E¡À >kV—> ô‘  9¨Šzzª¢€€æ *êýÝMã0 Â`~t5d`¯rÿëÅ°†¦ÊòÐ8ÿ€ôÆO þUKÁfµBá”þB¡Ußñoé¹WÑÓõ#€ hý `NÀ Áh_ o®5rž@ÖFb}ö =çÇ[!p’úZÇBÎÔ*’Ò½—¢ê:>p¯ç1Ö§©¾ã—ïª ¸/L]‡ÿDÙ÷ߣl·ÇuÜl0Sv_®£®q²]È ¸DæqyDZmL ª`×Ñ÷“5þ!Ë"IEND®B`‚FRAM3{ô MOVEV&oµDHDRà 4 [ï¿IDATxÚìÝßOâ@Àñ-Ç=¬¾èƒKùÿÿ,ºÚ»D ÉÙ—¡ŽK—•%&——Âøh§-[ã§Ã¶èøÃÌçæ4Q×ÖúE] ¿ñžMØúGýJÛ¯œ&N4˸ÿø'£;1Û0öÜ~ñ 0É—ôé(û¬‰ûã@Ù<vãm÷øùW0­L2ؤÀດ§h:Çl:.ƒÞhí‰C\Ec©â°à••Ó_EuD`ÓÈb:õ+’BþËhL24Ÿäá€M3ú…|~=äžÀp|šÆsn:¨ à>ÀxÂŽ?Þp@á) J`ô¥Àx ópŸ{ÃñGy@ „ 5^EûGz~z¸Ñ @€ÿ77 @€ @€ @€ @€êÞÝ)ÞÞÈä§ ¼pàw € @€ €™ƒà9éMÐ>Hæ @€ @€ @€ð«÷&hŸdr @€ð‹—Iè.B,Ÿ«çJ#°ÜÅbY‰P+pµ*•Wp¥¼‚ÌA*xö· _Anô—|JBÐU•Û¿»…ÓLBÐ<lЛ » sïÉ @€0F#åÀÉ„§(@€ƒ¯•¯µ'V9ÐN¨ ¤‚T r¤? s¯ä/¥ @€È¯È @€Òþ Í€ @€ÿ=œ›ÍBÖt¿Æ¯?Û²ÈÞóLP|æuÝî~eQ„*í¶Í6™Z`»–¤·‚"´?jcëz<Ö|áÂŽþØ‘½Oð^„®ÛÐx›xt÷¿Ý:ø !*:WnÚ««—Y/ À²UþR-ÏÌ曼Û,× Ün}.²,ÏUsú˜ëŠðAµ@ó°ŠÞÝ%€p s ÷A*È} @æ @ oÝÔ±ŽÄ EÑË´†ô+þÿ÷bhÃ*‘åv:çH·°Õó1±ƒ©ïÀ@óѪŠ€ç`ê:üO”Ö~e<®ãî`šÖ½\G]çd¿­Ý¢åqyDZïUX×Ñ÷§¯;ŸïYoIEND®B`‚FRAM3{ô MOVE†eDHDRß 1ä²XyxIDATxÚìÚßNAà5ܬ&FLZ"ðþ¯%4}¹¡"t\rªN½h -ròý²îáÏìÅÇììeV”eév»e©éŸô5^Ø¿v¥9,F ‡÷½Ù7¯Ç¸7ŸEø_kŒýÔ¾xø±¯©§âëÓ5§j¯¿Øýæ‹ññþgŸ¿v^ÚÁ­/X§r~¶ë«×¾¿#vöéúYºöú‡v¿~æÈþ¾ÕËnØ?¨%êŸfÕ ã›z<ߪ w»Õ°/Q÷ôÅñm=š/>ápFÝ×Ç·õx¾U~&õ/­/V¬Á¨ûúâø¶Ï×g˜àúyøÄdz‡ÀýoïÜòñññññññññññññññññññññññññññññññññp¾$÷øø¬?¿äããããããããããããããããããããã{ëÓÐ?âã³þ\?ùøøøøøøøøøøøøøøøøøøøøøôôøøŠþß|£&é|³Èèv|;Nè›î2+0©ïæfš{þnÏß.ÖŸùû”¾ÈnþÜßOËw×$›o2O~ýMf“t¾&Ù|åîÝýý#>>ý?>>>>>>>>>¾ÿ“Arߥó“ïå:¹¯s0æÏü™?ó÷A®õôøø¬?ßøøøøøøøøøøøøøøøøøøøøøøôôøøŠþßǙϣ¦ôÍ¿_”òðÐ×d¾à­·¥ÔšÒWYÛÁùEÿ“öõ$™ï[õ===­ŸŸ×ù|‘««³º¥õý(ËMY–º¿æóÍ7¥ –/[åe¼¾”˸ïmË<áù¹ÝþèºmŸ³I>ßbQwu7Nƒ—ÉW6ç¥ô[$™¯”çÝ6XäòE6eZSƒ’Ñ·(÷Wó²»O竦@eôµTýý#>ÿ_â³þøÜÿÌŸûŸõÇçüüKßc¹*‘xž#?»­ƒAŒÂ5àb.Àý¯'ºvJI¤7ø§5$oùcü}Vî>ÎL-ï3 Äa¾ÔèûÞq_j}_xÊ:–/µî\ÐÜ÷쥸/µ0¯Þ´¿õ]`Àí‹%|Ñâ>0×`Ì—ZÝ7¦{lÙוZÚ×0•%ŠëJ-þùd¼odpR«Îy€ûÁI­:W3 =cƒ~œÔÂsrà>ò¯t´þ|Ä¥™>2—IIEND®B`‚FRAM3{ô MOVE†eDHDRß 0ÙÒqÉIIDATxÚìÛÑjÛ0P%ËH)î^¶‡ÖÞÿÿVÜÒ½/ ²¤õTe—¥ƒ5ÒŠsq|e[~8±%ãÜ6}M'ŠuêÊ*r”’cÿAÇr4%U§•Æiâô¾ƒuµ?ú•O4¢9ú¾f_4ÿá«ò[ñ•èª[µ‹ýÏ;vù¢íׯ¾.uçÚ¬·rÖã«îWß»ûÎ4æÍzþŒûóäógq¼o“r,K#§Èÿ›ªkœ_åóù6i¹_m–%E>Òç×ùl¾ø†ÃùX_œ_çóù6åþlÔ¼f}1úc F>Öç×ù|¾ËæÏÓG|=G<ßùøøøøøŽŽ||||||||||||||||||||||||||||||||||o8>7îûÄÇgüùûA>>>>>>>>>>>>>>>>>>>>>¾CŸúƒúŸñgþäãããããããããããããããããããããSP?âãKê|||||||||||||||||||||||êêG|êæO>>>>>>>>>¾—Ƽqß{÷'ßÙâŸúƒúŸñçý–OýAýˆOýÏüÉÇÇÇÇÇÇ÷‚ÇÈMúÆûû1­V%·å Þ"­rä¼ôeÞ4¿[¤œÛ»?ïÒ¸Øn·ÓïÉÛõíø˜ÒÅÅÃååìIßõ]¿›®fy™eÞ—æ|éqìwëuÊKæíÚóßÒ|ý´¤í®Åçß4­ºn*‘R{×ïv6ýÜëú~èôݦwéû”×ÃЧö|‡ÔF߆ázHÓ<€ùn†}ÌÛ|?ºÉ¾§<Üäv“¾?­æ|5ÕïêêG~?ããã3zþyþññññ™?]¿g¾ïé*EÄvñ«Û:Æa‚(ú©mRä¾ÿõ0ÔÎÚx›¹Ád@–~ùB|³ž³']ÚÞÈ#|ÒøûÈ-Ÿ´¿ïóÓ'í»êò÷âX>ic^y¨ë»!€Û—¢ôe›û |–†à>iw_ëÛ3öçRÚÚW …)ÊÇ%mþù¤‘odr¤]w}˜k/’#íº»0î¶AÉAÚx–ý•ÎößÄJœÛ`ÇDCIEND®B`‚FRAM3{ô MOVE†eDHDRß /;bqš™IDATxÚìÝÁnÚ@€áÁ%"Šœ^ÚC£`÷ý op*…ˆC¬Jwa;AŒÚª²hŒGÿÈñ,öúð±Þµ’AA¾Ê™¢‘<퉑^ì³?v<œÕFJæ²Ô8Kœßwºë‹Íã±FýǬ}/Ù§Í?øL‰/¥Üܪ¹?혋õi=éãgÇÅv¶>eåþ´óËö³ç1?³o õSr»~¾ÝÏg_?}DßFbÌR#&ÍÿÓU¯7y8ßFfi·™’æž>½ÞæÁ|ú«Ss_Ÿ^oó >ÕÉLœú”çÖ§³_ç æ¾>½ÞæÁ|)Í®Ÿýþ==<ßñáǾÞñ >|øðáÇ>|øðáÇ>|øðáÇ>|øðáǾÇç¾Ïøð1ÿøü >|ãöíbàÇ>|øðáÃ÷nó>|øðá»8õêcø¨ÿQ_Á‡>|øðáÇ>|øðáÇ>|øþæ£þ@ý>æë'>|øðáÇ>|ãò­L¸ó-4VÏõsíÐW¥X¬êtê[¯+ßã·v<~)˜ŒßE?Òøñ|—ïÉ„7_¨ëðöÁÏ„7Ÿ<¼ þ@ý>êøðáÇ>|øð½GdÎ}WÜŸøðáûOñ>žïøðáûM\±~R ~„óßÿðáãÿ—ãÇ>|øðáãûãðácþáÇ>||ÿõ#|Býú >|øðáÒ‚f—¾ðø¤ªRvåSÞTª1OƒGßTºl9•˜ýÝŸK ÓívÛýúHm[øñ)Päúzws³›¸ôÝ/‹¶»Ä-úÚ;w>y EÛ4·ÈkýùÂë7Éšý&ÛÖãó¯ëª<ï!âoü&ݤ+Š²pè{òò]â¾, ñç;¡úòiìÊò¾”.S 3ß¼L‘‰xôÍ£oŸËyl»ô[î|–Êß'ðá£þÇý‰>|Ôß?æ>|øð±~:ò½È­hèkñ³Û:È‚(ú].æÜÿz‚k¦;&uƒ¶4$ù¢1þ€Òwi@¡I‡÷ü0Ÿô|ø–O:¾ïóÓ'wòò}q,Ÿt`^ºÉŸõu0àãs‘û¼ƒûÀ|$–ã`>éè¾ÚÏ`?.éоŒùHL‘?.éàŸO*þF:G:ꮓ¹ºAàé¨ëÙ€v× z9Òwq²|说wüý ¤sTÛIEND®B`‚FRAM3{ô MOVEV&oµDHDRà -a«àŠIDATxÚìÚÑNâ@ÐK‚› /ú ðÿ‹²ñ}í éU²É†%©Îž›f¦¶S“ÓéÜB.ñô—‰¦™Lº¦i"E÷Ç®ýñ<°;Ûíäaù²ËÄåqØÏãnÆÇ ˆ|,ã>3°kþ<ê¿ °ë~¦c“ÈÇfG¾Ÿ¼Ÿÿì3x:3Gƒã¸w}G4·§À<ît F“„ö”EÓé“,šÑ>³hÿqyàj•šñ¸ÛI]îÿ*Vq44_Ô÷\­Æã®YŸÛß÷g÷×÷=ó=whìÁçó ;ý=3/Ò ̾(˜SÀ~~ôg÷ןô=S$dYôâ‘ïÏ/z@@@@@ÀŽÛ[@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Àò÷÷…ïî­A¿6T´eQ@@@@@@@@@@@@@@@@@@@@@@õAÕ%@@kPT›P]´eQ@@@@@@@@À¯UU8p4òˆö ¼)xS:ðû•ô¢ìfÐgQYTmBu P}Ð÷A@@@@@@@@@@@@@@@@@@@@@@@µ Õ%@õAYð³ë:÷%ëçç˜-o}IÀìnÖí"FÏÃØÌJ£ÝVÃ‡YaÀ Ø®×ëÍëë (`>ÖëëÁõõ 8`n¯šŸ“¦7ëú±ŽªÙmñPd’©GQGmD”7ƒ±hÛñ¤í"æ³ò€Ëå"µ//ó³(¸D|Ûmóˆ(ÛxÝÖV%#·óQUULK.§ÓÄKQEL§åTËò€§VßèÕ&T—­AÀÿ(ÉxšA@YÐ{Ð#ú«›:Æ•„¡(z™Ö‚þ‹ýo/†6|2²¼ƒq^tË#Gùq j)جã¯V(\2>(”¢ê;>ðOÆ@žçSôrý  ÅZ¿˜0I0û ôMØõNÎ ÈÞL, ïÀ>aäüZ`ï $.ÒØ@ëØ@¸/XE@šsŒRT]Ƕzm“u0õ¸}´ª"$à9˜ºÿ¥µïGÙë¸;9`—ì^®£®sqÜÈÖ¶È<®#ï<ƒDÌã:úþ X;ï]³ê IEND®B`‚FRAM3{ô MOVEV&oµDHDRà +îëï@íIDATxÚìÝao¢@€á‘Ãà]´‰Ñ&Õ þÿ¿%^ü~å Qá68Š×z§^©“wbw.MÖ]JÆVY.å½È2ßú&«C>è=ÖïT?©²4ûµcõ]¿¡Ýô°ÃÆ]â`Öú|('­î?êwt2'@tŸâþ+Pnúæ`+? °N'@·o(ºÿ¨£:èû»æž¯Ð»ÏA¶G¦ÕYÚÀÆÕéŠüÛ<j¿ó9(Õ~PGÌgÞ¼ŠêPi·Æ+züý€¶ã20Ï]Eõ†Kšÿ*riuÕã[¹+`žGQÝäùmŸ¯6Ç·sG@=ç⡇]Ôvþó:*OÜšªOŒu hæá!_ lŽ?Ë]8¤½UôöÐós =@€xsL& @€ @€ @€ @€Ú¾¼N§2y·!@€V€… € @€; €™ƒàWR› |ú Å€ @€—ã@€ @€üóý µ ªK2YE @€´œ¶ÂpÙÄt2ŸÌ-ËéÜ ­ÇãÄøŽ- æ #øÕ/~¹Ð?ð¹æ€ñ|¾âelØ s@y>yBm‚ê@€Ô @€üüãÀ~Ÿ—(@€ŸŒŸ¬ßA.ô; FßEYE©MP]H}ûA€òŸÒ @€òéu2 @>ê@êƒ_ø8À4Õl˜n6¯V>[ª/ÜmË•ô7¡ìb‹ÀPÊ"ë78îf±1àO,·Ûín¿ï™ªð5 £ÞhÔ3Ta1È~ ³, w3ƒÀ4}M%Ȫ‡ÌL.2i_R¿YŠˆ½”UYFòIb{ÀõzåÚ·7‘ÄE,EOä[õHDÄ"P ÙKõ(‹@qÀ"q!AÈÂ"p½X8žÿs¢ÅÂðHµ¶l[¹£ @jT— ×AF @€rÃû»›:F•†¡(z=­ìî?Þÿö"»?‰„V0(¯Üò à_U[Ãç½Cã’õA¡5ÕØù²"öù4½B¿èa@ïwk6ö¼±I»9©õbÛ†NìV­¯Î BqàCZôÎ „û‚]¤”½×jM5t~àè—Øöhjì¼@ó1ºŠP;:ý#Êߟrš‡ÐywrÀ´›á÷ u“‹ãFŽa"÷„μó< ªàžÐÙ÷ 1Oܤq"uIEND®B`‚FRAM3{ô MOVEV&oµDHDRà )”+¼ žIDATxÚìÛÑNÛ0P'£*Bx`-ÿÿYk™xy©€vI \Ej»u˜sUÙ–ëFœØ×Q1¤ÛÛô^ÔuU½”m‘궯ª¶îŠºØ5ªÔ÷ÇÀîÝ®ÃâcoƒÄ`]§0~ÐíÀ”¢ôǸ·¾¸nWÇ›‹í3¸#0šïõçvÕØ.‚ý]Ä’ëº_«‡3>£ùîéûÀÞuÔŒøXŽ1nœƒ©ÀŒ]m¸¤ößEcª×%zè]4ƒØ ¸Z5ÅtÚ6Ú*êE3vÔ׉úxÀÕj:íŠUšví¾Þ×ÔGÆ=O¯ÐÔƒwÆ _ïÀà¥f³†/e Œ- Ï÷z'`\gTØDƒÌoÝ?âþì@ð Ü;./ó^_g¼º”ƒþÚÐù  ´‹~iàÙYæÀ‹ ÀÏåiæÀS@@@À¿€€Bø6áû óA@@9ht>(í¢€€€€€€€€€¹ËÌåmîÀ àÅÄ?)Xè9èlÂé  ô[5@@@@@@@@@@@@@@@@@@@@@@gN—å Ç àW.—³YÔù—÷'Oß7‹yÑÖ³Œ€áKO›”&“”B˜p³ÞÏE–À_i}¿ylÎ`«Ó:Uu}r’0„?«òwU6À<7™å,-_Û³æ•!p’_š›TÌò¦Å"Ÿ?<´Íbžá½»[¯_ZóySd ,Òó·öõcž'0õSX–77Yc¶«sqW¦Âœ€ªkå[}át6át ð«ç  ô4ƒ€€rÐýÓã@ Â@Ò(èWÜÿz1´°`²²|€-œ)~ùDEÊ_Ì)A§í¥ ƒú†ü¿³íø¡ÞAÏq%¦_Ô8@íwc8Í×Ñ6Ð6Ü®5Ä(@œÍÚvì#ô_ l  © ¶o °o°¬…9{O‰Ù´`-ã€0!ƶÅ·€L„Mz.ŒM»‰¢ÖßCÙi¿»‘ŠÐû2íu y#k="õ˜ö¼ûÎÛïjmÿû¹fÍÚ`mpIEND®B`‚FRAM3{ô MOVEV&oµDHDRà '+AÛIDATxÚìÚQoÚ0ÀñK1Ui_Ú‡¢‘ôû,c“JÅ~Ân.Æ"Q£) Q®ÿõ¹ÁAübìòò"…sYvhµ'ÚoíúN&áxèŸõ8,žvì\$Z€ÎÉ 0¾Ñv HlOŽÇqÇcñu}ŽO^,Úg°#0v?Öò­}:ê±Lâqñ#Ù:>«—3^~ †nË…ñÇëÀàºê 6£} 6q\s ŠSáÖ6ø4ÎÞEãTÅaÁ«Ëï¢6¢;p½Öf8ôM!ÿc¬¥1ÔŸ_Ï×®×áoômø~Èáüz¾0^s9@%€»ãk¾Þõ€Ê@“Àè£À¸„uxÌáüF¾"PC‘övÑó#^ŸnôàÙñø @€ @€ @€ @€ }àó³qàÓ@€¬A~m @€ @€ @€¤> k] @€ðKïîŒÞv¤Ö’Z~H|ê˜o|¤> k] @€ @€"‹ZØNB,Þæos‹Àé{LsZ.—Sã3¸4>ƒ¬AfðÓß&ü r£¿5àk-ÌËù¼<þ•“Ò°æ€òzòµ ªKR @€ @€ @€R› ºðË© @€ @€ @€©MP]H}] @€7ÌóMKr) Ÿ ˾lG{)’fZ–?¸Ùîv ”­A`¥À~¯×—Ià)Óé~³ZíW¿û}[À(\f©d©û ´·É¨Pª¥T™ˆs1¸É”¹lÂý0É-%Iâœ6’$ïƒÓªº¿?`Eìg³ª’è£ø^&•ôDE1ú)”©F*cZÊ;P‰J›ÀØ›6­|£ @jT—øˆ]”û 3È »(3ø§›:Ɔ¡ :¡uB‘~Åý¯‡“–,V‘O°2¿ˆ4å“ÿª–ÂÜìø« ‡ô…RT}Ç~¤wäy–¢‡ëWgÐõ€9ƒ£]@ß„]käl@î„}ö =ç×[!M ‘º]GÂuÁ*’Ò½—¢ê:>p«Ç b`Sßæ;*Bžƒ©ëð?Q¶í÷Q¶Çã:îvV0 ‰`ÞËuÔ5ÖyM4=®#oß×¢ Óã:ú¾-‚*üîS.;IEND®B`‚FRAM3{ô MOVEV&oµDHDRà %QÛQ!±IDATxÚìÝAOâ@àW„hõ¢Í þÿ¿%nvoìa Xw¶k²²èä{!ó&e@¿NgòŒÄÃCl‹¦©ë÷65ÑDŠºÞ5ºkš~`ש£?žvÏv<,¿ì£s”ØL?h˜ÑÝÀˆÜnÏã>Žå÷ír~òh±{÷æîà  `—6€éXùxù’›¦¿Vg<þÌÝ­'¦?¾ì]'Áaì^ƒC`7\ƒÑ$áæ]mó’:|ÍS•‡õÞÔ9þ.Z@\.S3v”rþ§XÆ`h÷úA>p¹œN»fÓ®ßç=ýëù4À|Îã=x`>aÃ÷;0ó"M`‘Àì‹By è×áGÞ ˜ßgOL‘åí¢‡G>?{ÜèŽëk@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Àò··…on­AmXpð$h ~f Ú„ò ú â à®8?/xu(>u\¼üÚqîýêÀIáÀÉÄ šA@Ÿ&|T›P>´í¢€€€€€€€€€€€€€€€€€€€€€€€jÊg€Ö ]P}д‹úO退€€€€€€€€¾½ÐôýƒªK€€êƒŠ/€€€€Ûb6˹@à"îîf1Ÿw¹@àbë»·˜W“”“°4àâG®Ö¯¯ ëmŽÏÎÆ1)ø=£Ç·ÕËËÛ˯ñ¸,`>×£¨GÍ`A›LFûm‘€³(p“YÌbÕß«Y‰ÀŸUU5Mj¢ªJ¼>¶íåå;6¢<àÓSÛÆk¤ÇüÛ¼P`ÕÆY¤Ç|~_ °›ÂxL1Šû$, ‰˜¨Q&0÷ž ­>ѪM¨.Zƒ€€6÷A3htt‰þq „a(ˆNhP¤_qÿëá¤% †Uä¬ùE¤)ŸŒøs j)ÌÍŽ¿Z¡pH_P(EÕw|àGzGžg)z¸~p†]¿˜0H0ÚôMصFÎäÞHÐw`ŸÐs~-°5Ò©Ðud \¬" Ñ{)ª®ã·zÜ v0õh¾¨"$à9˜ºÿeÛ~e{<®ãngšæ½\G]ã`=‘ÐDÓã:òö}]1 ª0=®£ï ½¡$™À¶°aIEND®B`‚FRAM3{ô MOVE†eDHDRß $L²@‹¦IDATxÚìÝakâ@ÆñIIzéháLÝøý¿V¢ÜË{a¸ÐxÉÚ±u ö¹³ÿ‡ºucùu³+v ••|˜Z2m»¦–>ÙÅÞ±9u¬cÕÇß:êËÔoÝÌiñ`”\ðÕræÓú©ï]k×~ñ¦öõµï?÷I=ا‡øL½_Lf.ÕL?õi}~œŒ?ÿôP­¶³õ)ëšãgrÑgç—ígŸ?³ÿå³Ë ~ÛQÖO(ûú8öúé#Ã}MßLâA,Zÿ.éªç›z=_#“cÓLbÑ:ЧçÛz5Ÿþ„Õ©u¨OÏ·õz¾&^ŸN}ÊsëÓÙ¯sPëPŸžoëõ|1ëçøib;@Àû;>|øðáÃ783|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øn8?œûæøð1ÿøûA|øðáÇ>|øðáÇ>|øðáÇï½ýöðácþ±~âÇ>|øð9ȃsßw|ä çë >Âüãú”{|Ì?Æõ…Ïì?°?†ùÇú‰>|øðáÇ>“¹‰;ßJ3Ÿå³Ü¡¯8f5Ï; SßtZø¿©çñ‹aþ1~_Ò§9Žïï·å{2ñæ yN·° î|&Þ|òtv‡ýöðácÿ>|øðáÇ>|øðáÇ>|øðáÃÇþûGø˜¬ŸøðáÇ>|øðáÇ>|øðáÇ>öØÃÇücýć>|Ÿ%­.}a±R±:ô…ÝnŠ.]U ³ù·Ë÷û<éª?ßs•Ê}¢ÿ2dçÎ'íÏT^~ß½lÓÔ¡o#Õ]yH¶‡$ú<­Ÿ ”ôW&YÖÕ4­ü]Ÿ› M&mô%ÁŸ¯ªŠ$©ë¤O!âÏwH“×”UåÏ'm+²—uŒ)ŠåÒ¡oÝ&"›²ÜȲ‹CŸ´å1kñåS`Yöµ\wT—>=êÎ|–Êï'ðácÿ>|øð±ÿÎøáǾ“Ï·|[yÞ÷‘?ÝÔ» Ä EÑK 8Øè¿=ƒcvø Át0<[–nxòÈ5òå dªi÷>¡€~ÄgúßÙöÝá =}øLû]ƒ4}}=„é3í˜?Òµ¾Ü>©OÛ¹ÄGdjâ3íÝWêötÖq™víKˆÈéq™vþû¤œ©Ó^÷>Œ•å˜öº–(oÙ Ã1íx/”âpL;ߛĜ_, IEND®B`‚FRAM3{ô MOVE†eDHDRß #þ’œ›hIDATxÚìÝÑJAà³²µ7íEµnúþ¯µée/ •@ŒÝlz°YQKˆ ßOœ3nf#_’™%Ž`|³Œ&Û¡YÆ6Í«£Ç&î:M8Þ›ötZvŽ’W|ËØóe}Ó·×îÏqãWv¦ŸcßÝ˃}Ù}Á7©Å7¦™¼U›<¾?°yæËñyÿqrüù—Ýl²NO}É:éë—yÛ÷l~MÇMïß›ÿå›.ƒùc²~æ 5}üxìõ³Œî[m›ÙØJÖÍj24ÏŸÔÓùV1Û5«ÙX²èËó§õd¾|†Ó™õP_ž?­'ñ¥.fQ¨/yÅúröçÌz¨/ÏŸÖÓùÆÌ X?Ÿ|z¸¾óñññññœÏ||||||||||||||||||||||||||||||||||8_ ÷}áã3ÿüý ßß>ûöøøÌ?ë'_¹(Ü÷‰ïCç,DDÞ'ç|||||>?Øÿ³ÄÇgþY?ùøøøøøøøøøøøøøøøøøøøøøì?Ø?âã3ÿ\øøøøøøøøøøøøøøøøøøøøøøì?Ø?â³ÿgýäãããããããããããããããããããããã³ÿ`ÿˆÏü³~òññññññµmÖ"}íÕUóùX ôµëõU;2Ô6ÿÖ××ÕPËó}ëë8¯ò_¾¬‹óÅæG÷¿Îîïêº@ßmôgÝcu7Ü꺬ëC£þÙDÓ µ®ûòÞŸ·m¬šØŒ¾ª-Ï×÷óªZ.«mæåùëêOº¾/Ï›M\\ÆC ·>Êó-¶À1óùÍM¾Å¦Š¸íºÛ¸R /6Ý.‹(Ë—À®ÛÖn1P‹ôeo ,Ì7¥úý„ýûG|||||®ÞŸ|||||>ßîûîâ22ù}ùÝmãPQ½Ô€Åßûßž`í×̆§!¹å‰ÆøjÏ<µ•î:¼Ï( Ã|®ð¡mÚ¾ð¦yLŸë¸P–ïý.Òò¹ÌËåXßnŸDò©ƒûÀ|d–ã`>×Ñ}­oÏ»?—®Cû æ#3Ez\®ƒ>ièÇuÔÝsí8®£nÚÝ6H\ÞÍÅòá¥Õñ÷Ʊ¯ÍƒÿGGIEND®B`‚FRAM3{ôDHDR’ýLÈ°}IDATxÚíÜAkÂ0‡ñ·Ø®0ðàQkÜ÷ÿX6]+¨xÛ†Ù[[…•<ìðw‚J’UÑÞÁ‡}y‘†¼³R°<7“hŠyž,9O*D’º¢(>?fyáLBœÍÆ’¢ë¢IH³ìuÞKMÃ:¥yÊÒ<˲õZ¦)Ë¢ËÒZ£)ÆKŠ»]tuJ"IÃǽèIê‘éx¯ëë0MS_5N’7™ÕVÒmjç¿ñ vä7A*Nã+IEND®B`‚FRAM3{ôDHDRW‡HYXFIDATxÚíÚ»nÃ0 @Q2V²9@Æ<ìÿÿ.)EÆJ¦À J¨5С[˜í ¬áN)o08ºtéÒý]Þ]º^¾]ºtÙÿeÿ—.]öx¿iZglöxœdžû ÍzovýÙu§óùtŒî.ËÜ-‹w#¥Ç¡Ý’$R¹¥ôЦwIéV"»6›!Åv%mS{>[k~8“lu”Ç8ªný'Pѱión‘X¦Ú¿Ðn)Öt·SÕf¥„vÍÆÏ,f‘]w1ËÎì"±ÔòGÎjdÿ£Ö¯®ÖýJ^Rk×ë5‹dî_-×ÞýͯW¼³v¥: T]\ó!{=Ö±±IEND®B`‚FRAM3{ôDHDR^ <az|$/IDATxÚíÜÁn‚@Fᚉ‹†.Œºxñý_ lÜ£©m Ø)¨IYÏMÚæ|¹°9¹áTÏé(Fʦ˜ç§™Í¿Êä¸}Nmo3Ý~µõLîüþn½*Weþ|5Ù¯ËÔ÷É/—•ëöK×íßoÿW·¿qÚ~Fymf”—•¥=nÛ[îüŒ2Ûü|@féÀ¶[SUÓ£ÞuV%Öu}뤮ìûò{š<„éðÐDÅ÷ËÓÛ%¦‡&þã)\Ãé㱑Cÿþ¯õèP7 *>>‡”fù*„ó9$ù¦©CX,BR7G¾×˳ÔË!Ÿì†<ì ×Z!å} u2ÈG+Õãu‡Ã¡UÒ¶­œúó ]Ç`x짻’IEND®B`‚FRAM3{ôDHDR~#õO.ÿ ÎIDATxÚÅÐÑŽÂ …á#ÔD˽xÿ×Zí^iR{¥ÄÙ‘¦>ÂÌÒ“pó§àSw˜ú…©¿ ,iÖ‰¾k€Æ‘PJ_ý¿§a©Yé®Þ_YV=I /†`HŸ´ßvû÷aßšE>½O6rL´4Ïé´¶³ƒ“< Ôæã‘?Š~=móóÉ"§d‘‡<<à¡›ŸºZ¥Öi !ô© œs>£Šõ^EXJ¹‹QòýJQ1Æ d™0MÚ>]!1®ßÕ?…Çr/jC"IEND®B`‚FRAM3{ôDHDR»Á#HŠPgšIDATxÚíÜËjƒ@€á3J I K‰úþ¯åxI!I…¸«c¦ã%-Í* ý?& º?Å݈R}@;í´ÓN;í´Ó®¹]h§w•vÚi§ö{;(r~ ª=¿;_êK­¬ÝNòsâ¶7Õ;÷FïÜžwæþtûlž;ߦuœˆ"E]?¿"/Tµ?MN/àl4Úi§vÚi§vÎP§w•vÚi§v΀åSs;ñO)Šû¾T{³ZúñXˆµã¾P{¾Zzh¶AØ—‰ïå£Z¯½®ªz¹v©ÖI¯B»÷vpÜl–i·²’aD¯Ûb·²7‹´¿…¹¯#ŠÝ×Öøq".Uömr±ëo·Þ8çbÑÔ~í/fä\çúÏÕâ}×ʶm½ï:—Š*¾ô¦–ãTt1ÆFÞ+•T[»ó³Èèj¿^£HÚ÷,Ë$ŠLyU~•D¢l"eYŽ·˜*“$;dÓ’Ðh¨ß’?K’ýD´Ú%È’@tù ÚÕZ¤ýéi âØ ÖIEND®B`‚FRAM3{ôDHDR#ñ¬XÞPýIDATxÚÅÐAk„0†á/AJÚ›óÿÿV£³ö”<,ÔÑÙ¸Úx(½N"sy¡iòy‰zùiÂqþxQ-Ÿº!™’YŒzýÑ-÷U/@©/vSQ\}1ˆ_P@^«¡®÷t‘ûõñlËß•‘Ú0À=²Ÿ Üòºm«aæ6/K€4òÀ/æ‰yad!@EYfTó,²,×ÿ¿—%4È(fÞGÚ¶GîÇÆ+òœ×û,'kr?´X‹ùÍ{Ÿ>̘·DÐá`ýã8Bs¾óÇàúΟœƒº¦ÙûH¼Kåxê]¯Nýc¥ãwɹs¯¡ÚþT=õÙ®_öƒ+IEND®B`‚FRAM3{ôDHDR»¹#HÁ+zª£IDATxÚíÜ»jÃ0€á#7”’!·Á7åý«voéà!P+Q•+4[Aý?dlo?_6‰Rç€vÚi§vÚi§]s»ÐN;ï*í´ÓN;ívPdýBUûöa½*V…²v{³]!^aûbaõÎ}¡wîÏ;sÿë7ò>wþMil^ˆ"uQÔÏ£ÞÖªÚ_ˆ&›ß7°7í´ÓN;í´ÓN;{¨ÓλJ;í´ÓN;û¿ü[mû¿dO¢´–’(>ËÝ÷Ìø¹q"®–8RÅ»ÜÎç“qÎå"ŠâËÐþn®œDáÅø/IïÇAfÃàý8Fzf¦“aþ) ø7Ãeù<”ŽÓ[— Ý˜&óþºj‰ßI’vçï2SK¤‘e2,¬µáÂì$†£LÓ̽’ÌÞÈn¥}zLõy¯*[ÚÛ’ÐEºöÊÞU•Ä°,åpèR ÞJÒãÄ—eÙu©ÚåîÒ®V”ö8Ÿ[PÁthŒIEND®B`‚FRAM3{ô MOVEV&oµDHDRà !¤[÷áðIDATxÚìÝ]oÚ0€áCAéíE+Høÿ?kŒ]¥‹†€”Ì6¢‡¥ª410Å{OµO>\©2ŸËe¢ªÆc×T•Ýu;6Ëñ¸vtϺ í¦§½o\$®”Óöô¸ö;¹ï@ô˜â¾2Ð5Ÿ[ù^€.ý4ÇÆ¢ÇO:ªC®¿m´û—ÁöÈ´:KxtÝÁ-ªíG öû8Å  ‡*jŸnWQ½E½TÑÛ‡7àfcšÁÀnØÖf»û—±‘VW=¿•ot,דìîy@=¿oÔk~ *ø, ž/­<¸PyÖ&P}µ.mäÜ9¨ç·ó 6b³±PE/z}Î ðB @€þs<> @€ @€ @€ @€>ðù9pàÓ@€ÌAþÚ @€ @€ @€Èú @€ÌAª(@€à ><¼ïˆB£ÐC€ÞØxßÑO|dm‚Õ%€ÌAª(@€ @€ @€µ V—2©¢ @€ @€ @Ö&X>ȤŠ @€ @€ @€Y9H @€ŸÄb¡9DàbµZHž»P}+iò<7¹(°×ì£ïÒ7¾: X`³ÛíšÃ?)©_Ò`€*ì ‡u<Ú¿…ÔØ&&étúÆçXN¤ô1÷"uU‰yÈKí(“²ô\tUöÑÔÞ‹ŒaÞ4¯ãÆ…¤âmñ$\.›fëxišf©7à`k~jGÊ×ëó®È¯ŸÒ•,ËRñ8‚q²–òÛõ²—CDKŸïd¶ÝXäM~Wà4˦5*ôœHl„E!×Îf™‹(’™/`2ÏL›çâ!ÐæÌnzÁi¼^ÇqQxê–?à$–uYŠçð$k} ó+‹¢”É$.‹p…L§R¬M°º/~¤Èð:ȤŠH‘áýÝMã@ ÂP¶5¤ _qÿëÅÐÂ*X+ä#8¿@šòÉQ¢UKáìtüÕ …)ãƒB)ª¾ã¿2"ö|ŠNׯž0àéws V€¾ »ÞÉy±­ÄúìFίöB:ÀM<Ï«HHkQŠªëøÀV§X샩ï¸@óѪŠ;ê:üO”Öþe7®ãîæ‚ Ü"8÷ruÉõ [3Ññ¸Ž¼û¾.6U8×Ñ÷ˆün:GÍIEND®B`‚FRAM3{ô MOVEV&oµDHDRà ºJñIDATxÚìÚmOâ@†á„`7ð¥úËÿÿgÑZ4Y…dmB—îÌœµî&´#Ž÷Iíië4ñêa¦Ñ£®¯õ1Q–ý¾Û•¥L¸›u¸îÚïú›T»Í|H4”üþÕu?î‡ñòä¯yÜ)ÝîÀZþ*@—^͵¾üuùÞán¼Ûɤӯ`½2µÁª.?ö ÌÁ·@?îí”-`ÀЫ¨/•vðÊß>‚×kI½ž=°{›íéÆZµ¡þþZþ$ c¹Ýáç0Éžô÷×sx`ý™?S=ø( ¿_µÜ ¬ó¬/N ÷E ôKÀèÒZÇÎA="ÐFO6kD«èûÃ?Ÿ#¼è ÀwÇÅ@€ @€ @€ @€ @€ñ‡ÃÈ——2ùoC€ @€ @€ ýA€™ƒ¬¢ @€ßø @€ @€Ò¤» sU @€ Ào¼¯E|ÀÙ!îæóÙsÌîçF+p¹Ì"¯à2ê º`RÁ“M¸ ò¢ÿjÀŸµˆ˜ÏçùËW>ËãÖ": ~¾:¡7Aw @úƒ @€ @€ @zt—Òd @€ @€ @€Ò› »þ «(@€ž0Ï}Ž˜ßÞj’eÏ9& ÷u¶›*S÷¶£í$F`GÕ¾ÝQ·+m¯&‘ ¬6›Ív·kE T1Ê;çƒÖ`Њè…ûóòW¿,;íU„À<åj—vÓUàE&ÕÂl»Ê墒²‚©Õ¥‹¦…YUõú• M'6ÞÜd’¥©‰€QçóÂû–tf·©¤€ÀáPOOUÕÒbÙ,P{íd·ª-…®`2Xi1S“a€û© µÛmM ŸÎi§»¢ÙŽÇ†g¢-Ƕ†‰… ¯º LrÏ5Ë.Bu§t”¬VIRqþF¿Pš&ZÙ—D”Àaz¦•¤hÒ(5<­Fñ ­ 7Aw‰¿‹ðo@VQÞƒT9 @VQ*ø»›:Æ„¡ :¤5¤ _qÿëÅІU°V7XçHS>9Ê_UKÁçµBá–q PŠêÞñ{Ž¢÷Ö¯zÐûÀœ€I‚ÙàÞ„]ïä¼€Øfb÷ìFίöBrà" zÇÂsÁ*’Òœc”¢ºu|`«·˜¬ƒéÞqæ£U!v0tëð?QZû}”Ý;k«èç…½?xÐ @€ÿww @€ @€ @€ @€ÆœÏ#ÞßÈä¯ Œxp @€àU @æ @€ø•ÿ}m‚ò@êƒ_ @€ @€ @€Ôd²Š @€ @€ @€Ô©.Èd @€ @€ @€©MP]9È*  ÿ) @€ @>ž s @€äó©.H}ê@€ß¢,-Ç,Ÿž´.Š·Ð|éaß?¥:¬c¦jOIªñX:,Ö‘+l÷ûýáxE Tµ,ÓÛÙh6E4áé¶ù5mš4=,"–å²TÒøM‹(™r¬R!ZIƒ`®Úmê1Š¶LÛÚ¬‡æ^—×=  I//ÒÆÅZÃ}˜°ài$Ýøm#i8 ùLØP'å·68ŸëõµmGªª¯pÀÓÆ…’$Ñê#˜Í¶ªôx®VŽç"‘V«!a_o2é¨çJ}…©†1Ìœ°ª4D ÌU+Ü`?CÿFwZÑãIEND®B`‚FRAM3{ô MOVEV&oµDHDRà OÊWÆIDATxÚìÚooÚ0ÇñŒŠ!Ñ*1hÂûY…FÝ£LZ#UýGÆÕÊNuÕn£dÞ÷>©Ÿ\ì¨2Z­ôVTUhCS=‡Þ=?7aÐóe5Ÿû@ûÖ;–ŸfƒÄ;À*†ük äí‹Ï}œ½›ŽBß/„m¨½Þ}åcÊ"ýnË?—t‡Ãxk¤ƒ>W&¬ظ:­ ôgsð5Ðǽžƒ²þ- W,d~xõRù°Æ+?¿`±ðîNÒphk-ÛáoÆ¢¡~~”;–5Íß±KºÐÏsW@¿æêཀ~¾¢<ìè<ó¥ t_¢@_`˜Úwúùqîh1”e³&°Š,üúìAàA @€~8¦S€ @€ @€ @€ @€ÓÎç‰g3€™ƒüÚ @€ @€ @€Èþ @€ÌAVQ€ @€ @€ýAv—d²Š @€øgQ¤\51›.¦‹yˆÕl±¦ <;˯àYÚ´`RÁý1*ȃþØ€çQ$Ì‹ìç;[eé£H¨óìM°» ûƒ @€ @€ @ö&Ø]Èþ «(@€ @€ @€½ v—2YEx ÀÍ&Ë<§Ü\¿Ôë¼g9Kè>=>ÔÒɉdÂõ¶î=õ’Ú^×’¬  ÇŸ+«j0H èÂËqÿû¸_ ]d6™6 ‘Ù+=à‰B·V/ë8)íÕV¬×:=½¹±n/ïäHåDm ¯®¶ÛÐËsI-ÊÖ€==}²×2ïh>¶TSÂ~ÿâ¢à\º·ù_kïµ»s}Õ—LØIGƒ›Ó˶€¦ ½N€šë~$í&I!Ö¬<&$IþÃkχÜ:k)Iàü«4éV£T+XZG·*­ æ÷;” УÐd©²,.—Ë¢(Ø›`w @€ò¤‚Ÿ‘üèÎŽq a(ˆi )èWÜÿzÚ°²¼+‹#˜_Dšò‰ˆ ì½|ÞñW+^™û·u|àGæD~«ôwë#€ô>˜°H°†÷&ìÆ gˆm% ¸u`Ÿ0s>8ɺ5 èz‚U$¤µæÔÏÄÖñ­¾bÙ¥Ù÷Ž 4­v”dFß:ü%Jkÿ—r˜‡­ãîሊÀÏË›¸¼ÜŠlÍDîÁ;öžç¾Q ŠÀ=Þì Ø£°d˜¤»IEND®B`‚FRAM3{ô MOVEV&oµDHDRà 5 ¦îIDATxÚìÚ]OÛ0Æñ'¥¨‹nÂ.:•†ïÿ±h‰à*“†¥ª¼4ã$ŠŽê„ ™5ïo×uªþâ7ÑõµŽ¥Š¢Ï-S°:«9ÞºËÂа+꽡½ë ßf…¯IÇ!è п蟒çoê½ý ?ßÛN T'½x8Šÿ ° o€6äõò†c ´ö–}å`zñøƒ±ú1ppEíAO›ƒïÞîý”uàßúb6RŸ_E½«ÆŸL8Á*šD:¸ßKZ,¬`¹E{ùÁ´×¨©ß?Š±€Æê²á{¼{yÐïÇX@æ=ÕÁ'ý~â"ÐyæKè¾D¾ À.ìuêôûÇ1"ÐÒBÍšÎ*úùäÏç=@€øéty  @€ @€ @€ @€`úÀå2qà÷ï2ùoC€ @€ @€ çƒ2YE @€ @€ @Î9]9È*  @€ @€ @€r6Áé@€ÌAVQ€ @€ @€³ N—d²M @€ @€ @€œMpº sm Àÿ ¸Ý®×ÓnïæÏ?ÚM•Y\'tŸžŸZéü\2aŠÀöÐf/Y’ÀZ‡»öIR‚=èÂâ[PÂ|žÐ…7ÅìW1 óD™íZ[õimWzÀs=õÅVÙ:°TóziŠ´ÙèââáÁŠYkˆ–¦+›)„··‡C_ª*Iñ€–L80ÓË™]«* Ð}&œ¨¡ g³««8ÀåRm›©ù9͵ѹ¹I&ŒÕƒùÅNÍÍ@Sõ¥H@ëÂdz\zÑ}í•SXc­ó\ªë$á-ÕTU¿c)EàR÷*Wùn—çiö`·É—¹vM“fjYži')Y ´*ë®›:Uમ_3Õ5gœ.äO÷²È°ÒƒYE²dˆþîÎŽq 0 ?l,è7Üÿz­l7“¹ÁŽaòÊ/5ñﵦ„NÛÿr†Ä-ý ²þßÙöüHïÈs9R½M¿¨±ÚïÆ Œ6¶q»ÖˆqÙ´íØ'ô_ l „ ÀEê¨íó³Hcô>_¦ýK¾7ˆÁ:°jÛ/pû(¹Š€çÀªi÷QJùÝ”íñ˜ö»‹p‰@ÏË´×5nΉ,e‹ÔcÚó®ëÿ¼Mö‹Ý<Ø4Ÿ[ùû›Ôº“@ü~ßQï~6ý]ò <ý!»ß·¿ ܺ¢VÐÅߌÁ°ÓïãWÀìL†~h<‹úRuŸ¿rÂð³¨8x¯Ípè6\ë²»û‡q/­®þøNŽt¬¦Ù¾Mîî~@|7Çú÷ü…êÁ{ýñÒÉÃx@å9ŸM ÷ú)` l’î“ý€þønŽt1—Õj` þýÙƒÀ… @€<8NN @€ @€ @€ @€´OOd ò׆ZþÐ @€0JÈ @€¿2õA€Ydñ @€ @€ @€Èú @€ŒAfQ€ @€ÿkàM'ìgÛ¸¹]Ü.,ç/1»Y¨Ð*pµš¯àÊx5ƒTðË_&š r¡ÿnÀëN˜‹EñöUÌ {ÀvØÊuëk¬.Èú @€ @€ @€µ V—²>È,  @þS:@€ @>½ @Æ @€È粺õA_øõÓ©Ï…œM%Ï›lX äél#yr¤Y…Ö€ÅO>>=?+P…ö€µýþ@ŽLK)zóÍãÝÝæî×`` è…«QOF½Ê N2¥H½’z$¢À©œdŠ©®f{ÑYÜïÁ@kÞöòÿ<§  ±ýç°!ÙVU7VÝÝÏAkÞ¾0ºÿع¼ö Åçæ`hÇõç hþ3àÕbhSÃÁ*ª/÷VQ¢®WÑ0b8p·k6³™6t«YŸ~2vrq¨ßËž€-K7Ýûh’>´ó{ÙЮyK5ð  /Wyæh<õ… 4_ @[:`;eà´ó{Ù#Pc&šÕÀ*ê,ìú p£ @€ÿ8 @€ @€ @€ @€ ¸X||9èȯSø×cÜ@€ @€^ @æ @€ø•Ô¤>H}ê@€ @€ @€H} @æ õAn @€ @€ú Õ%€™ƒÔ¹M @€ @€ @jT—dRä>¿” @€ ÿž s @€äÿR]ú õA€† \¯³ÌrxÀõëäã{¯"ÍY@@óÉÇ¡™NET"°>ÕÑ1 XÈéµ>h+¼4aò­’¤ª&“°€&|IF?“Q5 t‘Yg²–62}ø¦R6·À©Úf-Q昪.- ó\æó÷wmF«L¼5\ 7›Ó©m­V~¿T3Ÿ ]#9Žõ±\ù.²ß×u$å‡@éºp4zzú=Ï·R¾¸£::óÍHD…>€Ö…ûq,r”·Â!PUmË#Ðú0n„EÏçÈê˜JÙ®tyæ7¼ y“to·q\!Ï7ù4–mY†Ùƒ²HDzmrx@ í²€Ë¥®¡Ô&¨.ä'Ûdä>HdÈÈýÕ£@a~±h‘~Éý¯g’Ö,É° s‚eü á•ü'°µóÄf¥ÀÉ#ã ¡¿·\Ç~d Dôrœíqý  …­ßÌ ˜$˜}}v½“ó¢› ºìFίöB2à& ZÇÂ:Á"’Òœc¬×„ëøÀZ1õ¡Ù|ǪZš У¹ÿ¥ÖßMÙՃ븻¹`·ì¼\G]çáZÈZUdבwß×ÅÒüwµuü}ö ”# äPIEND®B`‚FRAM3{ô MOVEV&oµDHDRà ºGIDATxÚìÚQoÚ0Àñóš 1ч•(4æû¬¢î)}(jת„¨…%ªYKêþOà3!ióãÅÈr)§b³ö­6ú í°¶o6‡}g$‡åaE÷nè¸$Ñf¾“&NõÃŽ~  íÑò°Þû²ðw}o&‹+x&0tO£üY€>ÝA a¹pHÆ@¿¾oDÒÓŸƒ¡{òƒñËcàÁÕi]üÍ9£Á(>ÅðÃ`R)FQÿv<Š†C4õ(šGœ|yÑf0p׺ì^þa躅ß>Î=Ë7‡ýÐä^ž Ûǹ+`øÌ÷Ô> ¶—(º*Ïùò_¦À0€>¹Ý>¶s‡@qY­Œ¢é"|>g¸Ð @€ÿ“ @€ @€ @€ @€ @€ùg³ÌÓ)@€dä¿ @€ @€øeîl3» ƒ @€|“ @€ @€ @æ™]A @¾É @€ú˜F‘pyˆéd>™ç´ûXNç*Ìx}m3¯àuæÔं½¿Lø r¡ÿlÀ›(²–óyùþ,—e~À(²ÊÍÑ nü2?Èì@æä¶!@€ @€ @€rã—ùAf—2ÈÈ… @€ @€ @€¹ñËü ÓgdäB°S`Y†œ#°¼½-ÅZŸ³¾)ÌZk4«0;àªPáÛv±½Ôœ!°½/ĸÎå¥Ö2CàêÛ}±{zºxüUkYÝo«yÜÌoQa1zÑH¤P¡ô¡‚ãF …Ò¤õ@±e€c‘f,É„«•c6£aM)}úh’‹Ù‡ÃvT_ZaÕ¶WßE¶ú0ÒàLäUvbv’$Öë¶m}ÏZ{wד ‹Ç«©€•i墪êÊÞitÔ¾5m/êD@-aåc½îj脵$+aårµÖèè®ÖïŽH2`èi·càì§"‡ò¬5¬%yô8nô)Ãgir½e1{UH¾@ZÆ iš:càb±¨ëš¿Ì2»ài ƒ @®ƒTA @€üÊâw7uŒÂ0 ƒQø¹«ì ÙKî½È^ã¦EèEùÃ?òO jkø¼óoß¡qÉx¡ÐšjìüÀ·Œˆ=¯¦WèG= èý `-À¤Àì_`lÒ®wj]@l³°€±û„Qëc½ƒP¸HÀ޹ð½à.RÊœc´¦:?ðØ/1YÓØyæ»*Bì`hèô?QŽã÷Qvó:ïN6XÀ%¿Wè¬ë\l7òšÈ=¡3ï<·DÜãý€}”E¨ôVeµµIEND®B`‚FRAM3{ô MOVE†eDHDRß bÓ ­ÖIDATxÚìÚ]o›0€áCKU1Ѷ‹¤)ìÿÿ¬A¬õ*½("ÊÇl³îl–ÚNÌ”¾GÄÇuM”'`|q"ŸåÙh%Zß´~,q¶o~Nl}~׉nT;>§ùN”xÁ×Jàò«¾ß[×y:f_áûëÜì“v¤O»Ïø‚üV|>òàVÍuÜ‡Þ¡Ï D#Æ_Ú ¾—`rè{bMyý4^÷…ë+œþ æÿɧ±à~ŠðüÔ ¾¿F~.#Æûz×\»Žk}¶?>˜ªçyŸWùF?Žë^óéùažÄ§Æ'¤zÇùôü0OçëÅñéSÞb}ºú{eöcןžæé|>®û!-àù5zߎ°¿ãÇ>|£ã#>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|o8V ÷}‡õ‡ßGâÇ>|øðáÇ>|øðáǾ_}ÔW¨?àÇû>|øðáÇ>|øðáÇ>|øðá£þGý>|ìøðáÇ>|øðáÇ>|øðáÇõ?êøðácÀ‡>|øðáÇ>|øðáÇ>|ø¨ÿQ_Á‡û>|øðáÇ>|øðáÇ>|øðá{÷>êøðáÃÇþ€>|‹õ•¥æúÊõº”ªòy¾òpX—• ›¸¨õw¸=o›—çÛ4©\%®wå ‹óÉék*Ý·‹î1Mgã+dg‰Fš‹úœ<Ú#Mç²?Wì"%}È%ÏmNÓ¦œ‰ÏE$`)}.'ïKÊi}Ê‹lš*IÚ6qQÍâþ\­d¿?ŸÙ=ÄðÓäGÔM#s¹~ÙM'»/Q 'ùp#G±G#“úôî/3÷yîüulÐGUÝÝMìÓ+˜Y 1Á·=%"¦®ÜÙ˜ÞWÈ®ªl®k‘(>9ÕCle¾•ÜK±Éº.ËŒ‰¾©zk©ÓûüÞ^dÒ¹Ý!ŽO{Û¬¿Uq)î~1cRŸÆ¦0þîŒÄŽyø6ÆØFŒ¡þGý>|øø}>îO|øðác þ>¹ïQntHÿ^@öõ½›:È„¡ :¬¯Àý¯'¸ÖBƒMzƒò1$³|ÑX{橨t×á}B}‰Ïõ>›úlGøÀ›æ5}®ãn@Y¾Wiù\æå‡r¬o€Í·Dê³îñ‘Y„ƒø\G÷µ¾2S´_—ëà¿OÚÿEnŽë¨»/æš‚À8Ö7Šåi 2ŽëÀ»¹ )ãX°G˜ÛtùžiIEND®B`‚FRAM3{ô MOVE†eDHDRß %sw} IDATxÚìÝáO›@ÇñÅ4]ðÅØ^ -ìÿÿ³ ¥3QÛ’Œmww^`±.…Þ¾¿À=@Æ׃´1V~È›)$¨[Õ¢ímš×Ž…©õqÛQµ¦´N3½äˆ¯†¯®ïúš­=nûÙcjm?¿íûÁ>)ºøLó†¯QÏǧÓôé—@}¼Ù1øËW÷¯ï)ýÏ?Óý½˜ý¶¯f 9~6ïûÚó«Ý¯ýø|š¯¯öë©ûõÓTûù5°÷ë§éä«t31“úÀDþ5U£«=¿U‡ò•iì3Ñ»§ùìùí:ˆÏk¤õžæ³ç·ëp¾J4ÏIŸå9ë³³¿²ÌêÔùgÏo×á|&“êPܺ~vOeÚÜßñáǾ“ó >|øðáÇ>|øðáÇ>|øðáÇ>|øðáǾ3Nä¸ï;>|Ì?þ~>—}[|øðáÇ>|ø>-øð1ÿðáÇ>||¾‹>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ߇ùZqη¨óð¸z\9èKY<¬ÐQßf“º=~—ÇÏ„ùÇøûþ`Æûûyùî[qÍ—­VÙëš-2ç|Í8ç“ûÆïðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÃÇÿ/LJ>|øðáÃÇ÷ÇáÃÇõ>|øðáãûÿðáÇ>|øðáÃw6¾8¶ÕA_|sK’˜ê /~y¹‰UÐÅù÷r»ÝÞzªŽÇÊZ-Ò9³Ì—+OT®4t,¾PãÂuÀÝO_Ê_å“ï˧Ó0»H÷Þ“Z´oøë§åõH¨êûÙHÆ/Šäùy¿÷d½‘®‰¥ dg|^hü¦×¥¬Ò)¹ZÏ+ O'Íý/Šž/§"[¹[wÎ}ïOÒ,ÞgGpª€y.“ïwòåZ¶¢–±øµ$‰ªi*ݳßíÄ$IæóQø"¹“p6-Ëé´ûø-—;O$OÓ\d®Ãû̽=œJ©ïÝ}²KYÊ8|…—RªÚoYó–Ë}6³P餜IÀCÕ>‘±ø”,—^£x|>¾óÏW Å‘0~øðáÇ>|ÿïI®¥ŽÝw!¡ZwS9‚@E?kÐ+pÿë ®J¦ÓGh Cò—/¯Qy¯RØù}¢À¾ä }„Ïg>Ï3|í+è2_ì¼›ÐÌ÷­C1_ì̼úÒŽõMÐ}& >urÈGÅ4ˆƒ|¡óûú0ëuÅÎíkÈGyöë þ÷Iÿ‘›:ïžÌg pŽwâÍ& ž¾@Î z7ôÂ9ÞìVÃkå¿‹NsIEND®B`‚FRAM3{ô MOVEV&oµDHDRà Úªf„ÕIDATxÚìÚQkâ@†á/¶Å ¤M{‘ÅjÿÿÏZmÙ^,R¶aÝÔjÖà  •âÈ: ïAæLâ$øä83êáAE]Eh­Q-IEqp´5uh–µ=ïí]ïXÒþeÖ9IÖµv€þA%owÎû8~_ËþæÉâp#€¡ùØÉ_(‹ } äç}àæ° ã­‘Ng<ý ÝÃÆÎï·®³VÐãss° ôqÝ9(+àî-†>5¢WQ/Õþýkž~íAD›FÒphk-Ûá'£ÑÎP¿¾“Ï ,k¶Ÿc“ìð8 _ßÉgú3Tôëµ—‡g:Ï|ýº¯§@_¶À01Ãõ|F ÅP–ÍÚŸU4>üùA`£ @€£ãö @€ @€ @€ @€ Àþ«ªçÀ»;€™ƒüÛ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€*Äl6{îpöóòý{;d–ÇIKÍ7¯xŸÞ—­tu%™0`iºr>¶ë6[e)-æM$°]JJ­‚î“šE¤°øV«¨ëËË´€U¥··¶ÍÔüUœðG1ø] 6@ó%VÁüz¡æ—ŽŽ?Ùþ ‰mUõv‘K+½¾èèxÒèy¶ ýV™z ó\z™KÂÙª½¾~}µ~–жˆÉDÒt»N[Y„Û)`¥g•£|±Èó¸ >>®3­.ìÕN*X–¹¶Ñǵ^‡î`pŸ PUy¡…¤Sͧ$€VÂù“+ ¬éczÀÑHzra,tãã/@€û77T @€à¿nêÇb†¢èå·†ô#ö¿½ÚðeyF+9¯ˆtË#Gü'Pµ5bÑù×;4YZS=;?ðGÖB~?Ÿ¦ÏѯF80úÀZ€M= x6i7'µb@|»àÀ£û„Uëks‚PhÛËѹ`ì" ì½VkªGçŽþ8ˆí¦žè>FWŒäCNÿˆ2ÆßO9ÝÃÑywsô›÷Š&ï&—!ÇpQxˆÎ½û¾. h"Oô ö\Š“=×kIEND®B`‚FRAM3{ô MOVEV&oµDHDRà  j5äIDATxÚìÝÿOÚ@Æñ§ˆa,õ¾˜0°ðÿÿY³,š%#d6#±ëyénÖ¸9Žóö~‚÷)x—øêÇ£¢FµXè天í>F/¤(Òôq( Õy¼cªšÇÝDó^w`ŠÚËÌÁQòK`ÚÚú; äÆ'»y?Œæ¸áæþu <€vxتoØ,yòÙšÊ=.7Ñ9ÐÎ7ƒt4ãÑ÷ ¶;Óš¬6°q¸ƒÒŸìÁç@7ïù”i࿺ŽÙꀞϢ®UnZã•[<`ñ–¥¤^ϘÑTs÷•)Õžj×·ëÉ€–e†æ㨋¥tëÛõT@wÎ-ÕºõjÕÞ €Žg|q/Z`³õ Ýò؃vý³zB IO¦k<Ï¢þqççz€Ð;£@€ @€ @€ @€ @€ñ'Åñ @ö ¿màÿ|¨ @€àI { @€È7~ @€ @€ @€ @€ @€ 8n%>à¢Éx4McÎmãi-Œ8Ì#ïà æÚ°é`è— ÛA.ôo xÙJtÀl:Í~¼e‹,>`+Ñuùä/— @€ @€ @€ @€È @€È¯= @€ä;Û @€øæ€yže®ÆÌoº÷ªëybjp¸277]Ýï*éü\2°€Ci5Té ¬ªdŸ„ 4Ùø«¤;è|Ré³Ów…Ò¢èvÃN¤­*%ÕVÂiçkÚ©Æ`ûÝ»‹Ï:,;½—ò\6^&&Úö%íÏV:,Ínó=®”dYp— É×:4ßò}uqqw§:I`À¡Vš«Îy$¿®ìÁ|Ú—j“ÛÙ×F}&ˇDû3s«æWa‡+ÓÅþF¥äTó£‘Nçê*( &ÛZ'ù´>tù¤áLåfíÓB˺^ œÍfëõJÞY.k/xG: @€ð{7uŒÃ0ƒQøÑÕ½âþ׋a Up+‹TÎ?Dzã'Gü¨Z >ïø« —Œ ¥¨îø–1ïçUôÚú@z?˜0I0û Ü›°ëœÛLpëÀ>aäüX`ï $.Ò0 wl ܬ" Í9F)ª[Ƕzˆi¦îh>ZU`C·ÿˆÒÚï§ìæaë¸;9`—ü^ÞÄ]ç⸑­™È=xÇÞy ˆ*¸Çûû\ Ñ ²YIEND®B`‚FRAM3{ô MOVEV&oµDHDRà /*ÀDÄIDATxÚìÚqkÚ@Çñ_ªâÚ´d¨éûY«•™­f¹¨Üze0NÁ[ø>È=¹ä9ð“ó. êùY׉²L’®)KÓí:&ë|Þš«öÀ$¹ÃÌÁuâú@ɶïÎÛº?nÆéØœØÚ°]ó “ÿ`—ÞÛs‰ìyÙBë°Àc}rºþ º3ãËž\Nmàkð#ÐÖ}\ƒ2Ð5—Ý]Ô~DØE `]KÍiM6ÝŒZN©ïä[ «kÎï£M¦ë´ãÝ|+ ½çGª{íx9y| å_?Ö×S ÝÎÀ.Õò]ƒv¼›o41–É­µW»¨¸÷ǃÀƒ @€¼8 @€ @€ @€ @€ì?0Ëz|z5È¿  @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€à)‹ùÜæþ_‡oŸ›—<2y"0U‘ª’g”›¡Þv4I­0<`Ú5®ê €Í¡‰öQÀ@µï›¤gÐú.n’O¥’²ƒf™¶Û¦‰ToäwRù%¹û•Üµ@ã sãI¥ú»pdž§N˜‰,Ûbi¯uáÔ¡^ìξ¼%´s·Âb%(Ëõ¾™LÖkIy 0U‘ç’~ü”g4/MÀ_Õ2}S:«*Ž‹•¯0Ò~оòC4 ˜ªPšÆªªZò]Σh6 ¨,¨’t °9è¸g¥iº,4ŽãºðÎ^ÛBN—KÝßkå ÔëØúøÁ  À~ÄÃ3 @€ðw7vŒ!„Qøa;`A¿áþ×s •àf 6Ã_˜¼òË ÿ TM ›µÿå ‰[ÚBJªkû~¤5ä}I亮ZL õÀ€N€^àÚ¸]­Ä8€öc}×vìZŒÛk!pÚZûÂsÁ,Bï­¥¤º´`É÷ÑÓµý§’U„¼Ó¥ÝD)å÷RÖ׳´ß]œ0€Cv/kü®rs>ÈR¦Èß¿ýžñËn]Ç2Dý{,÷ÛyÇe?F0ü)jûOQ7D#xŠF˜p`×IšLìŠ]Új7ÿ0¼¦î|¯ hY«Åöw˜b7Àî|¿ è®ùšêÀA@w¾¼:9Ðñ¬/M ó% t€-pU:…Þƒî|¿h3‘­ÆšÔS4<þõ 0Ñ @€ós€ @€ @€ @€ @€Ó–¥ÒÎÅ@€Üƒü·!@€ @€ @€ @€ @€ @€ @€ @€ @€ÿ+pæ%=àí6³‡éÃ4EàÝ:·³©¦ ||¼K¼ÓîAîAz0òibÓƒLôǼ÷’°žNëŸßú¶Nè%9 î?lðº @€ @€ @€ @€ @€ @€ @€ @€ @€ X×××®¦¬¿Žß?÷wÕÀÖëX…ºL­Ò¼ŒõþÖK''’Æ , P“¶ öË~°D´éºà¸“o:Ÿ†ŒÒEþ©QÞ4ãq´À²ÔëkßÔ½hÇôZj™¿çC´¾x{0;mÕÎB€j´N¼ÓDY¾Ž2i¡çù®Àfy¢7ç‹vš(”áüI;¦iú^§§ÏÏ’ª*R`1_ÿ¶ûÄ×±Â(¥¾©¸ÌÚ6Ëžæ È°_Œ´UËø·Úx`¡¹Š"SÛv Ê{/›j`€QѲ©u³`à(­ªˆß&. b[(0ƒ/ÒÕUÌÀKéIÁe¼ð0™œÑƒ @€tSÇ8ƒ0D‡´†ô+î½Ú° deq‚•ùÒ”OŽòO jJجý/gHÜÒRR]Û?ð#­!ïs$½—Þh1Ö{c:z}€kãvµã2׸¶cŸÐbÜX+Á€ƒÔ&ÐÚ7ž f‘zo-%Õ¥ýK¾'ˆÎ8˜®í8}”¬"à=˜.íþ'J)¿²¾ž¥ýîâ„"°{Yãw•›óA–2EæÁÚ÷®ë<@TÁ<Öì ÇÆ|#oIEND®B`‚FRAM3{ô MOVEV&oµDHDRà êÚ-EõIDATxÚìÝKÛ@Æñ'ÉÉ6£ƒŒùçý¿­Õ1Á!¥ÆÔ6Ù]—pì:iÒø}Ðû]Ò;ðãåZŠêúZo“¢H’mS2Ùتî¼hu[ÔŸf;o“·J®}qÞ³ß]Gm_îœÃèºöê¡eóhÎ%rçÝ@sø ØŽOÚÇÇ¿‚ý•é Vعàuík ÷zÊ.àè€þÏ¢n©Ü°Î+7àøã¬*IQd;¶µÕþc*õ†ºù½: °eÙ¦û9Lé¨þ@7¿_:¤Z¥x' ›¯^:žõMè|“v[¯nK¥]÷ ›ß¯m"Ùj¬“zÝ=ýßÏnôàçì @€ @€ @€ @€ Àéó\ÓÎù9@€ìA>mà{®M @€$² @€¼ñ  @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ @€ H @€ ÿ½ @ö @€w¶ @€ð0€³Ù奫ÓÎ~†ë¯Í÷«ÀÖË1#U±*y¦x µ~n¤“ÉÇ Ì PQUÊ/› TS7Á&8 MYù›gIã_Á,k;Ué)|J>JŠ" G Ìs­VM¨ZÉ+AQ'G‹äÈ­oÜ+§¥Ê_³”º«zÜ·‰üÓê8–6Zν„Á‰ž»þLûJêT+6Âû{ùäѸÒt¹”I°G`*¯dº×ÙIwwòMÓÖ+“ÑsÝ*ÊⲌã¹ß ÖAó¸ÞË|5{Ü„aúÍ{£8Vé}£0Â¥¶9ºÙ#ÐwæÙ±¬ÍX?ÍzùÇw3òWq—sù&lÛ\ÔÚ'0 åŸÏ™4Ÿk—Ôõ…´GŸ®Ã¼àpÀ„Ó_Ám&~‰.S.,oªÀS«›pN¹M ÀwüÝMã@ ÂP¶5¤H¿Êý¯C ›8YYÁüiÊ'GQ-Ÿwüí;º´ ¥¨Îø•Ö÷ùíS/ôx€Þks F½svµ’³y6œ;°Oh9/ ¬„ä@#µè÷w‘Æh­Õ©ã½? v0;0Ð|PEHÀ{0:üO”ãø”õõLw'ÐDà÷ò&î*íBÞ@¹ïØ;ÏmÀ¨‚{¼Øb0;)åIEND®B`‚FRAM3{ô MOVEV&oµDHDRà ~%'IDATxÚìÚOÚ@Æñ§XÓ5iü0q ðÿÿ[S²eÉuX:ÏnÖ,á)åü>Á¾×r—ðéKÛhÔx¬ã$Ë’äu“e’ôºcª¶ÇíD󮘢ê238NŽ”ìöÍq;ﯓ±;²Ç,®¡@;ü°RÏ(“7À,S"{\v¢uX`9?ùó~ó;XíLe²ªÀ­ë ¾¢vûh罿eØ8 û]Ô¶ÊNÛze×èWÜË¥¤(2³5Õì*SíúJ=°d™Íîó(ÚRÝv}µž hÏyIµàƒ€v½*5:ÐòŒÏO õy ´·3Ú9íÇvÚõÕzB I$SÕƒ»èÑbÏÏôà§Û @€ @€ @€ @€Ðàí­üN¯ × ÿm @€ @€ @€ @€ @€ @€ @€ @€àGö*ñ8Þ¦×íwû>Geƽþ‹ÐW`»=ò¼ƒm¿;hÂ5H›þ˜(;ȃþÜ€7•xöûÃÝÏp<ôX‰w@ݼÙá×%€ @€ @€ @€ @€ @€ @€ @€ @€x6ÀûûáÐVÿ€÷_ÃçÏÅ—Q`ê°éÀha^.ÉžB=¯ éòR2ÂFcii)‡äA¨bSyp&@—þZkIçÑÁHræAò)S’eaØx`*­T((žäÒÃuÒú™´^€Æ×üÆá<ý®=S(òLešÿ˜HµŠ%å3a+_ïƵÇiGöÐg_Ð,/Òt>7ã >`švœ…-Õ5ƒrJQ”u4R}¹º’3ðö›ÅZ(ÖT{gó¸ ”_˜W1º«QË5©)^¸=è7ÚlÊa«uwW_ã©œ[¸zÑInÀÍ£–>Õ ÃÉTd¦øZ‹ÅLû'Ê‹°x¨¸è€LÕ¹¾žMgrOë¡FŸ‚@ƒ¤©@ëØ@@6؈’¼§½ç,…Ùu|`oKAØzh²ï¸@õ¡7&‚Þ…±ëð‡(zÿ>Êñz\Çx€º3ؾ\G…*ÈÞUdבç¾k…E˜Çú€ù«m6$¢IEND®B`‚FRAM3{ô MOVEV&oµDHDRà Z‹…kIDATxÚìÚýO›@Àñ‡ÃH öÅ%®¯ÿÿŸµ™f?l£Õ’žT[vG@³™¡r~Ÿ{8¸‹~úp‡eµ’÷‰8‚¬‰cÓÍ:&Kq½hî–'&Iuš9yŸx ¼hËëÏÆ=û0ò ÌA1ö£³æÀJî 0K/€úZ åõr î¾æãƒü~*X©Le°T…«+huÕq¯× ˜¶la5·«»hñˆ¶°‹ÚõI’èÖóÌ™iM6Ýš‘Heh>¿šÏ4,#,¾ j`1¿šÏ4áy^N5mÖ4–ó¥’½öexæ°˜}qkÙã™$ùYžiºËùÕ|¶ &yólÙ.Ú¤VŒF£øޕLJTäâBD ?<Ð3:/Qõ€ÓéÑq%=¥ÎÑéЄRõ€“ã!}‘3T0jö€zù‰JjµÐ ¾Äıë¶ WQ3àe(‡Cš:¢µ€÷“é>zwAOÛóÉ Ül¢ÆO¨*I~צ3-ÜçÝ_~ß4«axyèkäQn·µ€ÇYïøPø–­ÞƉ¯B_ ·Q­×DïŽiîvº·\¶t]¥Ö €ž$_':ÿú#µB{Ò4•öÕý^É›ãZnÅúJùþv[Ç·MGsGŽ}},Oμ5 ã8»±ZËc,J|ÏUóEo|Óùé”u–Ž3oM†i*ªÁ<¿ŸM«\,¦¦‚s4+pÞ&Ð÷gciC/JÄ÷}µ­Ìb>wt,m}iãa´•áX¢Àe=­PV«e?²ûÞ±(Ëc™Í,ŠìlŒFnx÷VVpö´+…Îðlr@ã/ÛðSÿvSÇ8ƒ0D‡m ô«Üÿz1´°‰•òœ_ Mùä(ª¥°·;þZƒÂ”ñA¡Ußñ_yžOÑéúÀtý`NÀ"Áê7Ð7a×;9l+a@ß}ÂÈùµÀÞAHh¤a@בp_°‰$€´Ö¥¨ºŽ<Ú4,ì`ê;0Ð|PEHÀs0uþ'Êqü?Êþx\ÇÝIšö½\G]gR/ä 4Ñö¸Ž¼ó¬¢ Ûã:ú~¬Œ§ ·MØ€IEND®B`‚FRAM3{ô MOVEV&oµDHDRà ešØåqIDATxÚìÝqoÓ8Æñ§,»\¤Ž0$P¡}ÿ/« í!mKG[-JÇN äêÓ‰ÌLfõ}mv›ÚR?ýÍñ’?6Íçzœì÷iÚ5û½Lº'm¯þø0°}µ{0 ³¦u'”†öèø0îÆ@Ã1œ`×üÐêOØuG@s,Uüh`ç°Ýøôûë'PA«2Ö`ÙÀÞu*?¢öKíqÿ^ƒj øè@ÿgÑ¡Tðޫa¾g ÿøÖµLâ¸}Ô¶mß>™ZÖÐ~¾Õÿ.àÀÞâö˜p˜o÷O¢‚}Û5NÀa¾¬>ö´ßÀ“Ú¶®Q×Õr]ƒÃ|»÷ ´a÷k1˜³¨{lM=@€øËyõ @€ @€ @€ËEðÀ …ùw¶²© @€9‹RA€ü?žEß¼¡‚²Ù& .˜ @€ø[ k @€È_€ @€ @€ @€ @€ @€Ÿ(ðÊJxÀEŸ«ëõõ:Dàò[Wk# ¸Ù,¯à&ð š°©à“ß&º ²ÑŸðÒJpÀb½.~|‹"< •à€ºÛ¦Ï ПOQt[ÝÞVîT’Uª®ÆUú³MøF;cÌåXÂÙAÞkWþXLÏ‹;ï>Í'»Ãn—W+9%‰•áÍ͈]¾i”e»¤ÙLÞ’eI›J‰+½~-éòZìâW8ÏCœÊ!/ôIqžTU’Ü”“ÕòþL÷g³/W˲Ԥœ:UŠÓÖµÆe¹ìºÙÄ'0Êó¼ÒÔin|¦ªßG =¯@)Ê P«•œ’Ç2Äê/͇Ò»w~/—ò6rZ)=Äç(iš+ؼ|¹Ýn£lúýÖ$d` 8>? wÕ @€~íÆŽq 0 ?l(è7Þÿz­¬ŒnÈ\`“ñ/L^ù£ÆÿkM‰µÕþW $Néý1kÛ?ð#½#ÏeKõ4ý à š~0``´ ´ÛµFŒ äÞ(жcŸÐc|-°5Â*©+дg Ì," ŒÑû|M˜öÜËyƒèUێ껀U„<VM»ˆ²ï¿›²=Ó~wA*‚u^¦½®q’/äªhyL{Þq䌩ö»zµÿ} aK [‘ËIEND®B`‚FRAM3{ô MOVE†eDHDRß xóÉOæIDATxÚìÝaKÛ@ÆñGê¸$ºÅ µí÷ÿZºÂ`[(kñ–jÌâI<˜)×zÚìÿpÞ%éúór—6/T (e¾jÚøßþ=Þw”²~Ã7Ái~ã09¼ïi­Àç7ûßEïïEØÒû|õ_ЋÏ' .Õ¬;þ´c¦Ð×õï^ëãŽKØ9ôu¬c¹>Ãùö _÷EY_‚õSY°~vÜþü´¾ôIå«|mü–éŽíš*èÚ´¯é3ÁÛ2þX¤¯??l_üºÚWq¾þü°Mí ß¾có…4_=6UìüëÏÛ´¾pšnŽkýÜ?•¯#ÜßñáǾè\àÇ>|øðáÇ>|øðá÷G>áãù'>|øX_¸>ñáÃÇúÉøáÇõó•ó…ñÇùÇý¾eÒ>|øðáǾdÁ‡ù‡>|øðáãù.>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>|øðáÇ>þ¾7>|øðáÇ>|ÿýÿÃÇüÇ>|øðñ|>|øðáÇ>|øÞ°¯”J¥Éµf}›(yYª-Ix§º›]iîÛt>•ûùŒ\[vâ鮑ôNòÀT>ùû€³•ÛÉ×4:¹Kê3Û¦9Q[â}¾qÕ°ïVRòñS“;5ëBq1V©Ü0ð½6™6:M;~7õÍÍÖ).ù¹¶þ¨~ëÙ,§º¾?Û´E)×—…µ~Š}.O›;¹ƒ>]w;3%óÕu}RO§Rôn'Vªµ^>ﻟ}»MÎÓ¢œdY6YÆ ­}(*WC7÷FʵV›¹’%—sRQÄñ¬œ.>Kúù]öù¤ž–j㖊ʹÖ2…uÎÚÕJƒYÖš´ešðZ®¢(ä EŪ’1VÎ9í+ùÌúÅTZN#}:7¹àö>œ+ažVì±€Ê[­´[¾Jº<²ïÅiµÚ™§K¾ßÐwö˜±?ŸðƱúzãˆ}>£~ü„çƒøðáÇ>|ø^Ü·V®.Ýþ8RHÊÿtS9‚0DÇ5è¸ÿõ×XJš&½Aù’Y¾hì…ïîÀMÞ'°K|¡ðùÔçy†ï˜ëžË:ïTõÍ}¸Ô:1¯|Ôc}è>™Ï:¹ÄGA5ñ…Îîk]=rد+tj_E|–È^Wèä¿OöE'tÖ½¨OAàïÄU€ò´ rNèÄ{y mÎñ>`??iÙFFâõIEND®B`‚FRAM3{ô MOVEÿÿÿÿ¶;CDHDRÞ ˜9zIDATxÚìÔmkÛ0…áã5ňÙ,d_:Òôÿÿ­&5Û—y-Öjœ¾dŽŒJgÓĨBÊ}ë‘e reí`m×vuô–L¶k2µÜ«/ã^æžúNWËduh¶ÏÕ½ñ^µ½q?Ï]¾ãû¯ÇEp<ß}#^¯žH<ÇöÞSëÇÿŸhñü|ÿü°ÂÏžk‡»ÒŸÜçSu÷46ÞàlõçõŸ»Ÿu|LJý˜/§ìðËé®WëñR×6®×ø‘füòþT¿~XãëBõþUãÆãùõƒzüÝó­kBãùõýª#JÕïèñ“ù¦+iðÙóëõ¨‡¯ñg0—ó”¤ê48˜Òý>«²,U~ê|.âá­´ð5j>EÉ·šèq±Ô•«Še½–’¤ü£p¦‘©G¤“6’É勧®t­`©T§jÆÄ{L´q5âöéþ¾¾ÿU(”‘Sïw~®­‡‡ˆñf’™Ô“ðt©ï”»ãýœÈÚL6Ëôø#Z¼ ûÔº˜+T.­µQ²Ù}|çm¾/.ÞsÄtš©6Æè蓮TùõîxZ­ÔY,¤BqdÙÙYVêr­¤§³B;à¼i#%%)ù~÷´Ç]ÃëÕD}(I‹]k볞=£­IvíĪþõûö©?°¢÷Óìàs%‰þ‹ç¿fS<É·oúý¸×>Ýmõ$-ãùÃâÕjâɼ‰g7€|ÿ–¿kñl¼5îÍv{ÏOÙÿ³X-ÞËåO¸zÞa{¯Ï«ï=ÙâŠ÷îè·ÄÑON¿Lï®oSý|áxqlmYÚ‘µVíô@±jC·ókõ$|(ÿmTZ_»x~~­ž~õ^[kZÅóóå«¿Þ —xŒçãXóÒ«åÞóókõ”›¯,ýìÀ“3ð“IœRa¯³Uö>ïÕ;ç| ’ïê*Ë| fµ’¢¨¸ûìt?ž?£é¬²š) ªZ>×j-ÖÒ©lL']\HÕã“Bæ[­Ü`9Èosµäb•ŠËâ€xÑ:ª6UÐx#çœÖÊÕ–s2EqÈê™Ç*d¼Åú™ŽMgùâ ‹E¢Å—$`:M“~Ry®–ÒK­VU©¸kX¾çx½ä¡—\g Çi¹tN­Å6×¥K× ´“eÒXy¸|:fõ”¦«¾“ÖºÍ÷…‹Tië1»µtÁŒFc—ë¨õ³åÏsíYÏÓ´Zg¹óöÙT~ÿ&é×LM¦SmU³L!ÕÚ¥~+:Û¾ ÷÷dZ©¿¶W´¹¹Q78•Šc{<Úk2éõ´µÙ¨3ñ”Æ}-%5Ç“åëV<3t÷¥b犼)ÞÍlwÔ¥tŽîï5ªiïMlÑÀaÒt>¯Ÿ‹¹z¾n”îþÉúö\]÷·»zIa†¡(z•©?û_§+M«b¬`´õ Bîð`°­5,>ßÏxr×çÝßÃKMõ©‚ƒôÍËMÙõŽ*h¤8‡—º°ÎhªÊë ¿<¼Û¥y Š™¸HkûaH]Ÿ÷r.Ê‘»4O†ÄaÔÕ/ÎãñÝ¡I]w“¯â¬r×]çaMVx®&uå͹Vx 4¹ëïòõ”äîƒsIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ m…Ÿº|IDATxÚìÝQOÚP†ñ·‚éNV¢aÙÅBåû-éšyU°4UK×;H#%4”•<¿è9¥¶‹‡ƒ‰NŸŠ¢Õê}´A‘jvfÏÕ6D› £ÈfmÎû í«þÀ&íÞf§EÚÊóßf[ž¶Çíóþ:ûÜh÷ß÷מº¯Kž ú$¯1!OæCž½äÏËøc3Ï®·A:Ua÷½ç?Zìünަꌫç¶÷šyþºæÞ“-^Oy;o€~Kt~çôËä/ÛÔjë~t†6…Ùh³=Ÿcœ²Fyä‘Gyä‘Gy'Eyì=òÈ#<òÈ#àÏn“Gyä‘Gyä‘ÇÿàFyì=òÈ#<òÈ#ÿ™Ì>.V–Ùçe¯Þ%÷é’û^^¤ ÈubwwIâçUUþœÝŸºîÇÛøW0_T6'}®žçãô!Õ±œŠPYkt}-U¯oê³oêœS©u¡ M³ì€¼  ªuÕoÞª¬éxa(c}í«g^«óæÑ(ʲ4í°xjï³¼ñxµŠ´úõX'§ëÒ–ëÛwI‹…U-,on´T8uöîÔ²}ã`=•ª?‚XCªsNy–i¯8‚¹Ìzk0n‘rIíy±í>Ë‹c Èm(åÊgíyÒÏÚ°êt{+=É´õÕyF Õd²\6_Š¥®~]kòþKÖ5tº«cB ¢ãm {ÿs»#äMàüiÊ'$pUü9Þ¯yÕîÏã·ä•¦û,!@ÆæÕ¦íÆÀ ŒœÉ+ÝXç¨ÙŸòÆ'D“wº7Ìp€QÝCéþ¼+9H>”³vkžLwx.k–îþp¦'v§¦vßÝ,øz@SS»ïkÓs4¥;ï¾×z~¯>çæ[.}àäìùd’ _´¯‹£}_öì]r>]r¾ÕJâ³.UÓÔ?ãƒNìþ¾(¼îqö¤ž”Oå‰Ó}üÍæÕ=æËCZ«CºD1WlM']_KÍË«úÌ—Wë?t¼(*ñ€x£õ¨ykz7KÇiŒeÙ%ž‰ñÙ3/Mñ‚ê:-I¤ö|o2©ªTÕ—ÔÒõ˜O]f/Ë´Z5ÍHñ¹íh™TWéÏ«ô¡˜ªToò|:®ÍÕŠ- Ú( õOù´Ë«eßVã ­õT”兩ž}Æ›ª“(©m}Ïf’‹,SÓ…!h©Û[Ió¹ÚÓm (^¦…’›`‡oY¶üMö6¯5^ÏK F¢ZIªc”Zâf’Ïó0da¬Ú?õZק¥˜‡XªÝÝôø¨¡¹™ú¹ÙÏò€VY¶XìÝ_Š…®~}}S¶ù'ëö½†îwwuŒ#ACA´Ü©¡ïNÖNÇ#dFÈGðþ E…OH´«âçóù›Oíþ¼{L^iºÏdl^mÚn ÌÀNJ¼ÒuŽšýSÞàÄåhòn÷æî"ªûÇPº?ïI’å¬ÝšgÓÎeÍÒÝÎôÄîÔÔî»—?hjj÷Ýàambz®¦tç½ïZÇGS»ÿ¾ï}Œ»n{j+IEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ ¨ur»eIDATxÚìÝaoš@‡ñ¿ÖÆ]ox·Ðúý¿VA²½ºfÓ†h«ìNæÎJZL ÌóKwœ lŸ§É^lúP­×õèErÜü³«ý/æy8f{g¤~=×ýx›ýœ,²ÊìKdŒTt¨K¬ûj¯“îï¥êõMCö-$e™¾n>:Ûò&»Iµ¯ÍKUʘ«gt`/Z=ïµ0Ϙ²´¶ÓâÕl[Þl¶^GZ‹¬S)uZ½XÚªÒ¤zVKŸË›F¦ÑSžúž¤¶ãkÓÌVñSÛƒjy®T*4˜´Ó7‹µõ‰»»BŸÉUéà5¿÷ßp4ɨu=ò‰œÕ*ŽU¦n®r2µX8ªU‹ø·”•2*Ú¶^¥»ûÊŠl¹Ô8˜RJüh¥–¼åT™«[j$â­ks¬Ú,ë¾,äC¡$•µEkžöÿf£ÊKÓ´( µpQ®\ ŽW«Æã[±Òôåû^qý—¬ïkìþvWÇ8„0DËúþçdítŸ¿ùÔîÏ»Ç䕦û,!@ÆæÕ¦íÆÀ ì¤É+ÝXç¨Ù?åN\ˆ&ïvo˜á!¢º ¥ûóžä ùPÎÚ­yf0Ý à\Ö,ÝýáLOìNMí¾{Yð󀦦vß Ö&¦çjJwÞû®u9œÑÿIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ Òµ!Û3IDATxÚìØáo¢0ÆñuñÈA–ðjÔÿÿßšŒÜ^õ’Ó q›rT·ýn#;D æû‰iKmÑgµ4™¾EÛí©ô…"UªöÿFû"zxllõÖoý»§† ³iïóŠ"ýϾfS<ÉÊý6î½Ïîk÷·±çÎ×1ž5¿ˆW«ÇOÞ‡xþ ë?²c-žï ~}÷ž5¿þ³øþZ¼×Û_põL»½Wgãê{O‘lì™}zÚ–èýä´eú|ÿªió…þæsUv;ßò¥¯ýeKÕXÉØüZ} ʾv¾¯[<›_«/¿zï¥/:ųù²ÚîwÁ%$ÞãY_¼vÌÕqïÙüZ}ÉÍ·ÛÙàÉ9²sE>`ü\"wÍñ”8§«F¾‘zz*Ë@î—®Ur÷:³å2ˬÌÓ4”özÌÏœîÇËìg°Z—¾0_¢0”ò¼Ç \õjN'ÝÜHåó‹†Ì·’´^«³$±£¥)^°ÊC9h¼T…Â0Ï{ÄóœkµzÞs9`¼0, çºOOìhiˆ7›m·‘¶ß¢Ó©ú¬Þí- ùªx“è÷$ºÏ†=ГÔåêhž´‚÷-*|B¢]?ŸÏß|j÷çÝcòJÓ}€ cójÓvc`vR‚ä•n¬sÔìŸòÆ'.D“w»7Ìp€QÝ?†ÒýyOr|(gíÖ<3˜îp.k–îþp¦'v§¦vß½,øy@SS»ïkÓs5¥;ï}×:8šÚý÷…-Ž„éáßIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ ]õÔ{hIDATxÚìØ]kÛ0…áã~ЉɻðU‡Òüÿ¿Õxf½Ò`ñi›x²Cª´¦µ‰‰ƒÃû`$E–LNe)P}Êڲܕu!« ,¿Ýv?°i”Ú÷ÇÍݦ‡ÅioÓ²Vñâ×슧Ãò°?Ž{ë‹Ïmêxs։ןÄkÕSˆ§Ú»x¡¯TìoÄ—±/ܪ‹¾›Ã÷^l~úgiú?ÆÛ§:ãêEýö^;^×Þ{²ŠcOì÷Äà“3.ÓÇç‡æÁ| ww§`½®[¡Üõ„FOa¬Äù­úb¨øm´®ûŽ‹ç·êó¯Þ¾lŠ£âÅùŠu|Þ—xŒã4Å®ãNGî½8¿UŸsó­×qNàäùdRè͹‹N®‹çÜ宣“Û™®3^6åt]ñ2Ÿe~Âéº_ÎLþ"ãE~šñ‚Γ³ªTy¯ËôülÒä‡ÿ£{xÈóXÇ£µy¦×|j÷çÝcòJÓ}€ ãðjÓvc`FN‚ä•n¬sÔìOyc€—¢É»Ý›f¸@ˆ¨žCéþ¼'9H>”³vkžLwÈËb–îþp¦'N§¦vß-6ü< ©©Ýwƒ‡}ˆé¹šÒ·ÖÞ¤®¦t÷½êÑ•pVIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ '5‡hIDATxÚìÝQošP†ñ×Ú¦#;ì‚+Z¿ÿתôd½:M&‹ÑÖ2ΈýÇ‚‡y~YéÁøx8¶ÝŦ/9W–Í6näT‹gŒ±q¥; t.îu8oãW›f—}œ—s²9‡³–(`"Þkä‘Gyä‘Gyä‘wVä‘ÇÚ#<òÈ#<òþÙmòÈ#<òÈ#<òøÜÈ#µGyä‘Gyäàÿ•]u\ȲpåÓtÕ®¹¯ªT…³÷=>…íG³Û%éìGx=wÝÏ÷Û_³åªŠû1û’$Ñ6y:eåֺ뤻;©z{—õ2{’ü‹ZÛ²úäÍö³ê£5oéœó5 Ï‹Bè5{Ñ[5b^^–å~¯ëb_WÞímY:•ß܈uÊ“B<{‹…v»ªš)¼ª£¯Î»q¿oÜS‘Ëk4›M’œ6{IºQxêúÆ FQhÄ<‚›½Ó·›'Ò^/¾_ß[q—£å… \Áë”ù‹³ßù-—’Öë4UU…Æ䇦)4/{µRºF“7 ½(Ë“¸z½ïú™ìc9ßk¾_ùIý®‘e‰6!H]y³¥d= ‹l®M³‚;Ùm<%qú‚WÒó³&&Ï%ï{æÅ>Ð)M×ëÖãk±ÖÍŸïJ›¿d=~¬©ûÛ]ã0ÂPokàþç$vGȉàübÅ”OH¬«âßÏû5ŸÚýy÷˜¼ÒtŸ È8¼Ú´Ý˜‘“ y¥ë5ûSÞàÄåhòn÷æî"ªçÇPº?ïI’å¬ÝšgÓò²˜¥»?œé‰Ó©©Ýw‹ ?hjj÷Ýàabz®¦tç­µ7é«)Ý}XuCå±øáYIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ øå®ø9IDATxÚìØ]oÚ0†á‡¶s—œäˆ‰¶ÿÿo•`­Gž42!hi×Tº D5Ý—¨_'8¨oLQõ©, c²7ÿ[]UoCXôvà«ÞÏÇ…þÙ8ñE‡—…É×Ê>Ä µ;žǃóqÝ?oEˆ¿¯ñÉÅ Ã'ñZõâÉ;ˆ×œ«Ïû›±/¬÷C‚{³ÿÞ ÓvW>,V+Þ>Õ »¿÷ÚñâºöÞ“o^šx±[¡Æxƒ?9c›â²÷´Š× ÃÝܨ±Ùø™}õ‡GjÖêP¸¾UO"†Š¿6þ\¿xñúV=}÷ÞÇ0ô‰¯W¬ñõNØBâ_¼' áÄzî½x}«žróm6qžÁ'gÚ7'¼/ऊËW\v¾âÒû—"ßý}YÆšP]«þút?^¦?G‹ÚפùL®Ü h¾óîtÒÕ•T?¿(e¾­1··×·CnmWÈo´Õ¯µÒ¶ÏèÅ<‰ç¹ãºç=× ã]g“‰µO¶ºÀuÆ›N«*Sõ-KÙ<#­%«žfÒVµFõ¯Îö5ñÆÙïqöXΕÌnWU‹_yÌt•?vþaPP–šKV‰¬%#«þíÛI»IÇK”ªÃä¹¼š§K笕ø­À¨»åHÕ*ÏUË*çœñ{FszPc¡. µÒqþǪŸÙ“T­ed;·^­É®y,ìb¹TJvÀ72k5µ+Þrf‹&ÝRça¶5k_:-C¾Eˆw6¬Š¹œ³Ýñôzw·ŸS¼ù|n­ínŸt×äGÈóÕªu|)Vÿùþª<ü“õðXçîowuŒ#ACA´Ü©¡ïNÖNÇ#dFÈGðþ E…OH´«âçóù›Oíþ¼{L^iºÏdl^mÚn ÌÀNJ¼ÒuŽšýSÞàÄåhòn÷æî"ªûÇPº?ïI’å¬ÝšgÓÎeÍÒÝÎôÄîÔÔî»—?hjj÷Ýàambz®¦tç½ïZÇGS»ÿ¾cvL0…”‡ëIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ ‚%ý˜!IDATxÚìØQOÛ0…á“”™%7¹b*ôÿÿ-Z¬õÊ“ÖLUÖ‹C‘G¤‘*™ÜfzEvâ~–8|¸‘Ð?RuÝE¡Fûf½­ÇÂði{˺ÛÂÍE)bŒ8¾[uü*Žñã\ÇÚKŽ×‰×™§OÁ»xÍZ­¸ÞŠŒxÇúúøù¥w¯Û•N±ºñÞRMã³{¶ên]÷ì…K±öLÆsÆ6Ų·´Šû…ñ®¯ÕØíÂ]ÃOÔÔJQÜßÏ"†Š?vamX¼¸¿;_H÷Â؃âÅýêÌ¡ìœ-$ÞãÅ8a8.\kèÙ‹û»ó9ßnÏ`‚oΉ½W`˜ê?—&ßýýjç”éªé¾½\}ÏKæ¤ùÂ5f»k®ÒIŸ>IþùEIóy/?ªùN•s'ÅËö™?ø´ñL©Ò=¹ÎÖ½àÙ'ŒgÌÍÍ监éB¾ÞxWWu]¨þR$={F/æAÝÞêéÉûLîGoûšxyñ3/R¦+f3k×vL÷L¹•{è}1èUx/Ìe•ÊV²Þ¾§™‘öZÛÃeòj=¯Ö Óíëz9ò½iŒd­zâejl6eé÷«¤½3²Ã_z‹…¤åRýBeà—+%c­ŒºÕZÕÜl·ÆX«Ý-¼fûpe‡ÇG¥âœqÖnžªÊhëœúÒÝå¹Z‡ƒB¼tœܾj¦­¤Sâ)ÏÏÏj¸yeÛ:ÛïqùzÒMÄ|nm3ÈÚþö5±ÀiÊr³ùàyÚ6Ê}=¨|ý'ëûgMÝïîê%b „¢è5ÓúìÕ:m›ˆP¸û Bîð $6–ïg=µûóîkðjÓ}ê€à óåÕ¦íæD4SœàÕn¬3†êŸòæÃ/d$ïvk¨bæ.2Æûc(ÝŸ÷„8֪ݚ§ Ë òX«tûgxüíÔ”î»ÍÒy«Ú}7y8A ÏՔÏI¤¦vÿýkÌL“^¿òRIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ  e8OIDATxÚìÝÑnÚ0Fá?@×YKv‘+& ïÿZ%Eë•'LmIfg ÓH+Q²Î'C°£™ ª›þ‘4-Ëö¦rÚ~Ôñ|˜èß Oü î2ÿäš„<Oχy'‡ü0–aî5絇¿äuÆÛÈ“÷.Ï+燱“w˜_Þ¿öÝëîJg²ºyǪÛøpvï­²;¯ó¾ÚÂ0÷BÆs†m ÓŽµ:Yñîïåìvþ™?úÑ¿ìÉÍÕ‰°¾;^Dˆ íü¹aya}w¼’ÝóÇö0(/¬WgôÓ.¹…äÝ`^Èñ‡Ã‰{ ½÷ÂúîxÉ›o· ÷àµsÆÿf’ÀÕûäGyä‘Gyä‘GÞEyÜ{ä‘Gyä‘GÀ?»Myä‘Gyä‘Gÿƒyäqï‘Gyä‘Gy€ËY.‹"ŒÑä‘꾽;'«uãÇ"b^nÇ­—uuÒÝÔ¼¾)nŸì˜Õ~ynm¯¼dŸ4uò"±£òH<ã<ÞBÊ›óçóN¼f~óþ]ï^wWÚ“ÛñšTñãì\[íyí÷Íν¡áwNåí;g³Ô®Çx–±=m›3ÛÏ/ïN5ë;ãmØPöÓl͹~ñìúÎxûݳ½ézųëÛ£nÇü{â=`<çÔ†çž×ž]ßozñmí58¡;çpÏ:Ù œ$‡c¢ :¬æ‰ÊXÉj•L0ã¬æeÇr&™Ou.9é¼’3½xá^Ò7IÕn·s¥Œ7+__Ë—i¼t¾²º +‘™vYøc/Íf^U·}˜#Æ“Ÿeƒ*|â ÷&_ž×m&ÏȲ¡t­Â~'åsÓ>‰F–eCÒ]ÏJÕÑbW•ÆSU5SöK=-¥B•fÕÅ a…auTT³wÈõ6Ê~Ú=×Y{—+„Q¤'éϺîßÇ‹·,ž\©ÔGÚû WRùt±ÂY¦ñâù¾\WJÓA÷“ïZºy¥(ˆ¢RcŠ"Iq<乩v½Â<:yÓˆüÀÝl\·ïî-?$ßÕFîåÝ{«[¤ZoÌ|¾ùp Yý'w£+Þl¨Qãi3쩾,\Sáz<Ý„Ÿff³T½¥òe¦Âý ÒTA0èÎi ÔeR€/ãiÝy=kï·¾¯=s$¯õúÑýí¦ra Š~Ö¥Üÿœ]S;Å70 é/Ÿ@1‰㥮ÏÓ‚§À[mùá¼Ôu×a:¯ÅÇ Þ«+ë~橼æÏAÁSçÅëäÆ`Œ—º:ïûpqY©Kó&÷u9(.+uù'ìçèšÜ…7.`{@uáõi>'†Guñ ®íAõû—žÍûð,%IEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ õõ̉CIDATxÚìÕQo¢@…á#jZv冫6(ÿÿoëÚ+z!»Fk™´™¶du "yÉ àÌÄÃ' o2›U•of3YþÀõz?ºoýNöešßé“O í§óa܇Kñ?ôUÛçx¾ùG¼Z ñä|ŠgÏU ç½ðg¬Åóã«·ïû]½zU¾ V-ÞÇ‹ãôÿÞ«Ç ãê÷ž\ñ.¯ý“3”) {O«0_hïæFÖnçö\ëzwøŸìX)óký%„Pá×hçÎ5‹æ×ú^TÏ·¾i/ÌWèÃz,!ñ®0^ˆãùîF ï½0¿Ö_òæÛíÂ=8¨'gû‹ã¸€ï´\†~xŽëõQE¡åz=Ä|“õ:*ŠÂh=À|ÑÁæ›êWt4“áÅ‹îÒt*™——cã­4$ ïõø#>ÜÞN\ºÅ³ù¦£QbFÉ^ÎЪw/U•ÝÒq©®¤¥ÛÚHUÚí\¾ÃÁ¨ŠÜ¶wúæó?®¹ÔMOËòt:û1ÞìÙ˜B+[ÅsNç[,òÅbaœ½1W‘/¤;Ÿ/Ïsµù#‹.ãíe42ÏjèîN{[‘Ê3KÊ枯λ›°D÷Š&ïýA.QxˆÎ½ûî%‚ðD±7Gw!)[ÞIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRà ýê‹Ö@IDATxÚìÙQkâ@†á/i¥HoæÊb“ÿÿ·j;´WSØÄVÍfäÐ,[ÄÃûÎÄ89ôó¨£R׫UêZ½ô Î:·…ñÙ´c˧¥‰©-ˆ_ŽÛºøwØQÚ·yek§0 ÿ 8˜¯% ¢/ûc+ÙñÄޒÀi}lù¤;8ìÌ`±†¹®à-jã¿mÝày¥Œ¶öbÆ‹Z«lÙ!¯ì|ágÜÝ©·ÙĽ8Æ9>TÊš÷ø eóü¬^ç 5ûííkÑ.»‡~Î0aó°•f3©ûÜÊæ°ØݾË8àLÑg÷º—W^ÊýV··«U­Õ¯ÚòåÕÂ>`Yÿ.ë§,ó¥-yVŽŠ¦)Ô)ùÔ켃SÐî˜M[¨÷çÏý½Îüce aL>wd‰¶U²ß¿¼\ÓBçŽ+Ñ.t³‹[a¯!¡sG•x|,ËCuÖ€]W(¼ëDó¹•ø.ŸT¾,¥¶=ÿ;´º_+<è •ø.`Š•vÏð㦒vzó§·ðû–ê2œªjÜÀÎJLQ+¸09µVbŠÕz]U§¾üs½ÉY‰)r•Ö!Œé ³S´wŸ»+1Ñ€‹±wB›ö­âÅBÞûQ¸ÀßîÌW‚†b†6dîN íòÿDJíVÁÅH.­‡ ˜ ºÖ—ßâ›|Püï]vêc"˜þ«–öìÔÇ ðÀìÔg q 70;eƒ½=œvðÀì…û ÙûÚÀ1À8HÐ$Ãk‚/hvNk"ï3‘ü†ÀîAÐðÁ4{ÝÀèCÍ8€š½þ%JÊá=d¯ËÈ"ˆ½’×eЙodEOòÚ<ÏœDxOö;ø­ƒ„ÿàÎàIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRà ‡*ض«IDATxÚìÜÝN£@†áþD'¡'ij{ÿ·ÕêÄÉJBZ­,C–L”Ô6àRvö}¢ Vhú:P¢$êyÞ,ý"¯é„4Íóz‘¦ªÔ_øQÍãaCÿÝ°â}Ýͯü}ù§Àf<(…å§ÇÃvþ³Y‘_ÿ3†o¤c`X=ØÿÀf—OGk®ðx-’íÀ4mŽÕ;žƒM`{f¾l¬¯Mוgлül†íÚç ü˜×š•&·ÿ»h˜ª°YÓ«°¿ð3nnTÙïýš_úÑy¡j[)û·ÆëYáõhïëöoc™A¿¬Ãþ cx¾«N#=¯Úª‡u<Ãþ­ñº'á~ÎÅ(ÞEû 5žO $@ $@ ¼  ä$@ $@ðÄ $@ $Àÿ>Ð)s1:—ÉEPxºO•x C”/NIYv»XÏÁS±0r.Ò@»ÓQ2Ó" ”µ’1Q_·[yñΠ1Eaâ¾ÐŠº*xëÑó_¢ø¡lÖCô¼\ /ß+x^•ñDz‘÷ÏÍuõD?ƒÕö~¯&k¹ÌòÅxûI©I¹Í0–!žT¶Ú¶’Ëî_¯XêâYËõzÜ'aCXù°½›¯(TÅ~šÍˆñÒ—ëÇÆåÖ{½ç-RUµíJãòƒâEï竵N [Û~ûöò¥tïç{|¬kM¶¶3ÞQgç­zšÏu<žÏ…üövºGMVbñF­ž™íª§AÕ3U#ÿt;žB¨•¤‘ÏÍ£‘tšºþå;NtÒÆÝŒ—J¦0QÌçÝ[Œ‘œÓ-)ÓøVCþôêúò@í>52}«7×Fv¦çî4_#? x²Ö¨ñ^÷Ë«¯¹ª‘t¿ñ¼oìB½-¬{­ w÷û,lH¼…s¡QhÀ¦ªv»«÷¹Øiò÷_­ª0ÚUU÷½>»ÝÕ1Ž! Ñr§†¾ÿ9Y;!Áûƒ>!Ñ®ŠŸÏço>µûóî1y¥é> @±yµi»10;)AòJ7Ö9jöOyc€—¢É»Ý›f¸@ˆ¨îCéþ¼'9H>”³vkžLw8—5Kw8Ó»SS»ï^ü< ©©Ýwƒ‡µ‰é¹šÒ÷¾kMíþûÞÿ²z>\ÙIEND®B`‚FRAM3{ô MOVEÿÿÿþ‹[5óDHDRÞ "dl®’IDATxÚìÙOoÚJÆá×ÅQä[ØÌŠÈÁßÿkÕ‰•¬& ¸õÓÓ韵RYö­ Óß#438ã^6 ô¦år·û>Ú ¥Œ­³; ËÃb§ÇãÆð×°ˆÛÎO ‹?ËþÍY¼ø2OŠãÙñ¸ïç±X7Ö{ÿt¾)ñÂðF¼Þ| ñÂtÏŽíñÃØ‹öÛ0Ãgsüµ—o¾-áx/Þ÷òì^4ìÚëÇ‹ûúמ¾6o¦xñNvþaš~çŒmúµ¾-ãùÂt··2û½le£Â[ d{¥(žß›/!†Š¯FûplT¼x~o~Ý cFÅ‹ç+αÞ[H¼+Œã„AaºÕÈk/žß›/yñí÷ñLêÎ9ýÍ ,À_Ê;{¤›NÎK.ÙtK6]Êù^N™N:Hk¥èÓj›Év¯Y%­•¤FR!9¥ª–©ä“ŒØ¨P«ÂIÏk¥È«-älv‰Æ3mqH²y÷*¥©iš²,Õ}›MœÓ³¹»Û¨ªÂœdº»×¬ªªÍJNHus,¯6çéÅ{•nnd2åO]‚ñòü¿íâóçSþô!½ö…xÙi›êãÓƒš´ÒÉÒåÒr©—e>c:ïä5…Rb³©âuºí¤fÖ_Ãü”tnP‰MVef·³Aš“÷Sâ +a‘²oN¹­¯$ŸsCKdGÉÿ¬º®Öl§S&ÿ¢‘Ök†”¸¿¯ªJ2]×=>j6Ū•ÿ4¾{ƒJÜ›ªnêz¡.«gŒ·(¤£ž›ñí; (aéëÀš7k÷ ©i4šsJX:SËÔ¡y3ªëñÙ¼ªjP‰Ø2ÍÚ¼¶-Š±Ý[ëY®TÂ2]B¡vÂׂ¼œQâJ¾Õ×n¡6–x\áMP:É«-õ>•Óî›*Kñcÿ»Õj»í=OÅVþýØie«íjuþ\×îKwõ’Â@BQôÚÓúìÆP"4.Á¼AÁ„nËçûYOíþ< ¼ÚtŸ: 8ȼ¼Ú´Ýœ¨‚fŠ¼ÚuÆPýSÞœ`øËÁ+Ý™ª˜9€‹Œq ¥ûóžà€ÇZµ[óTa™á@k•nÿá ßNMé¾Û =·ªÝw“‡Äð¼šÒ·÷9éÔÔî¿øQ¶‚u’ŽIEND®B`‚MEND! ÷Õadvancecomp-1.23/test/test.lst000066400000000000000000000347671301462770100164230ustar00rootroot00000000000000CRC SIZE 16091163 122225 2a6e7e27 70643 faa2edcc 1070 e5b395d3 33620 e6e31aa8 73627 6677f57c 11578 6677f57c 11361 82a64a04 28 0204146b 10 e10ca4ed 12 70761289 13 e16c3e4c 102 c4b899c3 1974 00000000 0 a505df1b 1 16a826f0 13 98f8d084 20 91f7680b 1173 00000000 0 a505df1b 1 16a826f0 13 e23883e4 20 a1a9057c 1189 00000000 0 a505df1b 1 16a826f0 13 5d083d85 20 f5d9524f 1014 00000000 0 a505df1b 1 16a826f0 13 27c86ee5 20 5ae4beef 1089 00000000 0 a505df1b 1 16a826f0 13 a8889b45 20 f71247a7 1021 00000000 0 a505df1b 1 51085c20 13 cf21d98f 20 4a149faf 1005 00000000 0 a505df1b 1 51085c20 13 f241f03f 20 cbdcef7f 952 00000000 0 a505df1b 1 51085c20 13 10f1f06c 20 29dfeba9 1044 00000000 0 a505df1b 1 16a826f0 13 4a389b16 20 cc1e50ba 1037 00000000 0 a505df1b 1 16a826f0 13 c5786eb6 20 449ac3fc 1138 00000000 0 a505df1b 1 16a826f0 13 bfb83dd6 20 e48bd6f1 1042 00000000 0 a505df1b 1 16a826f0 13 008883b7 20 e6c00dce 1116 00000000 0 a505df1b 1 16a826f0 13 7a48d0d7 20 215be68b 1073 00000000 0 a505df1b 1 51085c20 13 6721c17d 20 5a736799 1054 00000000 0 a505df1b 1 51085c20 13 d5011d6d 20 41c429f6 977 00000000 0 a505df1b 1 30934946 20 97e1dd5c 407 00000000 0 a505df1b 1 29cad9b0 20 139f29b4 266 00000000 0 a505df1b 1 4ae9fdd2 20 9ba44112 304 00000000 0 a505df1b 1 64bd7eff 20 fb04e099 207 00000000 0 a505df1b 1 a1c39a91 20 02b087c1 443 00000000 0 a505df1b 1 87cb5fa6 20 d72159f3 254 00000000 0 a505df1b 1 eab8fb5c 20 5ae55596 453 00000000 0 a505df1b 1 16a826f0 13 8fc87617 20 25644e91 1143 00000000 0 a505df1b 1 16a826f0 13 91d970f0 20 ba03a92e 1193 00000000 0 a505df1b 1 16a826f0 13 eb192390 20 731029b5 1146 00000000 0 a505df1b 1 16a826f0 13 6459d630 20 044e4593 1173 00000000 0 a505df1b 1 16a826f0 13 1e998550 20 aa81544c 1130 00000000 0 a505df1b 1 16a826f0 13 a1a93b31 20 cd0156ed 1231 00000000 0 a505df1b 1 16a826f0 13 db696851 20 8ca0f253 1142 00000000 0 a505df1b 1 16a826f0 13 54299df1 20 446416ed 1219 00000000 0 a505df1b 1 51085c20 13 49408c5b 20 87f7a37a 1083 00000000 0 a505df1b 1 51085c20 13 0ee0f68b 20 34f9ca2d 1130 00000000 0 a505df1b 1 16a826f0 13 f139e772 20 42402189 1086 00000000 0 a505df1b 1 16a826f0 13 8bf9b412 20 82a4c839 1156 00000000 0 a505df1b 1 16a826f0 13 04b941b2 20 4f965ad0 1068 00000000 0 a505df1b 1 16a826f0 13 7e7912d2 20 240bd796 1120 00000000 0 a505df1b 1 16a826f0 13 c149acb3 20 d9ef9687 1117 00000000 0 a505df1b 1 16a826f0 13 bb89ffd3 20 b49c060b 1169 00000000 0 a505df1b 1 16a826f0 13 34c90a73 20 e0b9b485 1236 00000000 0 a505df1b 1 16a826f0 13 4e095913 20 2b5dc662 1241 00000000 0 a505df1b 1 51085c20 13 536048b9 20 a2d563a1 1095 00000000 0 a505df1b 1 f6b55506 13 b396b88c 20 0eecf33a 809 00000000 0 a505df1b 1 cbd57cb6 13 c956ebec 20 a35953a4 878 00000000 0 a505df1b 1 cbd57cb6 13 46161e4c 20 e2f8f77c 942 00000000 0 a505df1b 1 cbd57cb6 13 3cd64d2c 20 08b2de71 857 00000000 0 a505df1b 1 cbd57cb6 13 83e6f34d 20 a94bc473 916 00000000 0 a505df1b 1 cbd57cb6 13 f926a02d 20 a784b20c 847 00000000 0 a505df1b 1 cbd57cb6 13 7666558d 20 c978a5f2 901 00000000 0 a505df1b 1 cbd57cb6 13 0ca606ed 20 ed549cf8 920 00000000 0 a505df1b 1 cbd57cb6 13 d3762f0e 20 da0686bc 855 00000000 0 a505df1b 1 cbd57cb6 13 a9b67c6e 20 2e384bce 836 00000000 0 a505df1b 1 cbd57cb6 13 26f689ce 20 ef1f0a12 899 00000000 0 a505df1b 1 090a6bf6 20 258f2698 447 00000000 0 a505df1b 1 f6b55506 13 6156f31e 20 5b1055a9 828 00000000 0 a505df1b 1 cbd57cb6 13 de664d7f 20 5d77dd50 877 00000000 0 a505df1b 1 cbd57cb6 13 5939ff80 20 674c6b78 942 00000000 0 a505df1b 1 cbd57cb6 13 d6790a20 20 e1dfa6a2 889 00000000 0 a505df1b 1 cbd57cb6 13 acb95940 20 b780182e 1004 00000000 0 a505df1b 1 cbd57cb6 13 4f37be38 20 0d32e306 980 00000000 0 a505df1b 1 cbd57cb6 13 35f7ed58 20 8432af1d 958 00000000 0 00000000 0 06ec9c86 28 a505df1b 1 e10ca4ed 12 47a8e2bb 13 ef091bc6 3670 00000000 0 a505df1b 1 16a826f0 13 98f8d084 20 949e7eae 2034 00000000 0 a505df1b 1 16a826f0 13 e23883e4 20 1dfa5a9a 1970 00000000 0 a505df1b 1 16a826f0 13 5d083d85 20 1e6cde8a 1779 00000000 0 a505df1b 1 16a826f0 13 27c86ee5 20 d50c820f 1903 00000000 0 a505df1b 1 16a826f0 13 a8889b45 20 31d3a6a7 1806 00000000 0 a505df1b 1 51085c20 13 cf21d98f 20 c820ed84 1743 00000000 0 a505df1b 1 51085c20 13 f241f03f 20 ef028110 1674 00000000 0 a505df1b 1 51085c20 13 10f1f06c 20 14e00d76 1827 00000000 0 a505df1b 1 16a826f0 13 4a389b16 20 96cbd17c 1802 00000000 0 a505df1b 1 16a826f0 13 c5786eb6 20 7baa399a 1980 00000000 0 a505df1b 1 16a826f0 13 bfb83dd6 20 cbf964df 1829 00000000 0 a505df1b 1 16a826f0 13 008883b7 20 a78f0a29 1933 00000000 0 a505df1b 1 16a826f0 13 7a48d0d7 20 1814edef 1878 00000000 0 a505df1b 1 51085c20 13 6721c17d 20 ce1ffb51 1811 00000000 0 a505df1b 1 51085c20 13 d5011d6d 20 e0e25ee3 1722 00000000 0 a505df1b 1 30934946 20 6461b244 694 00000000 0 a505df1b 1 29cad9b0 20 24324c98 502 00000000 0 a505df1b 1 4ae9fdd2 20 9dc354a3 521 00000000 0 a505df1b 1 64bd7eff 20 d719360a 341 00000000 0 a505df1b 1 a1c39a91 20 ec07403c 764 00000000 0 a505df1b 1 87cb5fa6 20 69daa640 413 00000000 0 a505df1b 1 eab8fb5c 20 9f1f5487 776 00000000 0 a505df1b 1 16a826f0 13 8fc87617 20 a02e104a 1943 00000000 0 a505df1b 1 16a826f0 13 91d970f0 20 c5f1b05f 2027 00000000 0 a505df1b 1 16a826f0 13 eb192390 20 70393d8d 1948 00000000 0 a505df1b 1 16a826f0 13 6459d630 20 7f7e139d 1993 00000000 0 a505df1b 1 16a826f0 13 1e998550 20 7629c162 1932 00000000 0 a505df1b 1 16a826f0 13 a1a93b31 20 53c578f5 2069 00000000 0 a505df1b 1 16a826f0 13 db696851 20 6e0c794e 1942 00000000 0 a505df1b 1 16a826f0 13 54299df1 20 df3afa67 2054 00000000 0 a505df1b 1 51085c20 13 49408c5b 20 9b6d9949 1862 00000000 0 a505df1b 1 51085c20 13 0ee0f68b 20 58f27d78 1948 00000000 0 a505df1b 1 16a826f0 13 f139e772 20 9c6e0fde 1921 00000000 0 a505df1b 1 16a826f0 13 8bf9b412 20 e2071a3a 2021 00000000 0 a505df1b 1 16a826f0 13 04b941b2 20 70699c02 1915 00000000 0 a505df1b 1 16a826f0 13 7e7912d2 20 19f73389 2002 00000000 0 a505df1b 1 16a826f0 13 c149acb3 20 d11782bf 1992 00000000 0 a505df1b 1 16a826f0 13 bb89ffd3 20 c4de07e8 2110 00000000 0 a505df1b 1 16a826f0 13 34c90a73 20 5f5f5989 2184 00000000 0 a505df1b 1 16a826f0 13 4e095913 20 11e5c81b 2172 00000000 0 a505df1b 1 51085c20 13 536048b9 20 2eb4d0ce 1924 00000000 0 a505df1b 1 f6b55506 13 b396b88c 20 55038d76 1338 00000000 0 a505df1b 1 cbd57cb6 13 c956ebec 20 663f6d84 1428 00000000 0 a505df1b 1 cbd57cb6 13 46161e4c 20 17756516 1524 00000000 0 a505df1b 1 cbd57cb6 13 3cd64d2c 20 ffa02752 1387 00000000 0 a505df1b 1 cbd57cb6 13 83e6f34d 20 167e1027 1474 00000000 0 a505df1b 1 cbd57cb6 13 f926a02d 20 24870349 1376 00000000 0 a505df1b 1 cbd57cb6 13 7666558d 20 2819d1b7 1438 00000000 0 a505df1b 1 cbd57cb6 13 0ca606ed 20 c86b117e 1464 00000000 0 a505df1b 1 cbd57cb6 13 d3762f0e 20 e281b413 1375 00000000 0 a505df1b 1 cbd57cb6 13 a9b67c6e 20 5fd4a14b 1354 00000000 0 a505df1b 1 cbd57cb6 13 26f689ce 20 de4007c0 1454 00000000 0 a505df1b 1 090a6bf6 20 b83d6408 771 00000000 0 a505df1b 1 f6b55506 13 6156f31e 20 3145e58e 1340 00000000 0 a505df1b 1 cbd57cb6 13 de664d7f 20 8df6b830 1381 00000000 0 a505df1b 1 cbd57cb6 13 5939ff80 20 8bab24ef 1490 00000000 0 a505df1b 1 cbd57cb6 13 d6790a20 20 38529543 1376 00000000 0 a505df1b 1 cbd57cb6 13 acb95940 20 cb28f23d 1591 00000000 0 a505df1b 1 cbd57cb6 13 4f37be38 20 47b9cc5a 1536 00000000 0 a505df1b 1 cbd57cb6 13 35f7ed58 20 84a5fe10 1510 00000000 0 00000000 0 112c25f5 28 a505df1b 1 e10ca4ed 12 c8ca75ec 13 802ccffd 2858 00000000 0 a505df1b 1 16a826f0 13 98f8d084 20 3df0827e 1634 00000000 0 a505df1b 1 16a826f0 13 e23883e4 20 842ea1a9 1540 00000000 0 a505df1b 1 16a826f0 13 5d083d85 20 639cb7ac 1298 00000000 0 a505df1b 1 16a826f0 13 27c86ee5 20 abf3526d 1502 00000000 0 a505df1b 1 16a826f0 13 a8889b45 20 8861af05 1400 00000000 0 a505df1b 1 51085c20 13 cf21d98f 20 6a38d467 1294 00000000 0 a505df1b 1 51085c20 13 f241f03f 20 d0ae6690 1216 00000000 0 a505df1b 1 51085c20 13 10f1f06c 20 3efd7556 1436 00000000 0 a505df1b 1 16a826f0 13 4a389b16 20 4ce21b28 1313 00000000 0 a505df1b 1 16a826f0 13 c5786eb6 20 1b2e40a1 1598 00000000 0 a505df1b 1 16a826f0 13 bfb83dd6 20 7ac4c951 1348 00000000 0 a505df1b 1 16a826f0 13 008883b7 20 aa053a62 1431 00000000 0 a505df1b 1 16a826f0 13 7a48d0d7 20 d424904d 1447 00000000 0 a505df1b 1 51085c20 13 6721c17d 20 d2d61ca7 1383 00000000 0 a505df1b 1 51085c20 13 d5011d6d 20 ce7996a9 1269 00000000 0 a505df1b 1 30934946 20 e36d0140 666 00000000 0 a505df1b 1 29cad9b0 20 65ba23cd 463 00000000 0 a505df1b 1 4ae9fdd2 20 29e4012c 488 00000000 0 a505df1b 1 64bd7eff 20 87c92c35 323 00000000 0 a505df1b 1 a1c39a91 20 13007b5f 678 00000000 0 a505df1b 1 87cb5fa6 20 5eb06457 391 00000000 0 a505df1b 1 eab8fb5c 20 c03e31d1 686 00000000 0 a505df1b 1 16a826f0 13 8fc87617 20 f62f8609 1449 00000000 0 a505df1b 1 16a826f0 13 91d970f0 20 9e840ec5 1547 00000000 0 a505df1b 1 16a826f0 13 eb192390 20 d7520e19 1533 00000000 0 a505df1b 1 16a826f0 13 6459d630 20 63264e7e 1508 00000000 0 a505df1b 1 16a826f0 13 1e998550 20 644e18fd 1422 00000000 0 a505df1b 1 16a826f0 13 a1a93b31 20 05c00bd2 1659 00000000 0 a505df1b 1 16a826f0 13 db696851 20 0622bc37 1541 00000000 0 a505df1b 1 16a826f0 13 54299df1 20 18102950 1603 00000000 0 a505df1b 1 51085c20 13 49408c5b 20 b7431822 1413 00000000 0 a505df1b 1 51085c20 13 0ee0f68b 20 320a8f85 1516 00000000 0 a505df1b 1 16a826f0 13 f139e772 20 b86adbdc 1342 00000000 0 a505df1b 1 16a826f0 13 8bf9b412 20 a3398cd0 1552 00000000 0 a505df1b 1 16a826f0 13 04b941b2 20 3911a377 1332 00000000 0 a505df1b 1 16a826f0 13 7e7912d2 20 51031613 1417 00000000 0 a505df1b 1 16a826f0 13 c149acb3 20 c2ae4dff 1518 00000000 0 a505df1b 1 16a826f0 13 bb89ffd3 20 6e48954e 1525 00000000 0 a505df1b 1 16a826f0 13 34c90a73 20 2060bfb8 1579 00000000 0 a505df1b 1 16a826f0 13 4e095913 20 40850206 1633 00000000 0 a505df1b 1 51085c20 13 536048b9 20 45153128 1454 00000000 0 a505df1b 1 f6b55506 13 b396b88c 20 e5aa63b4 1243 00000000 0 a505df1b 1 cbd57cb6 13 c956ebec 20 3870b5e7 1335 00000000 0 a505df1b 1 cbd57cb6 13 46161e4c 20 f9d288b2 1447 00000000 0 a505df1b 1 cbd57cb6 13 3cd64d2c 20 4d3c7d8d 1287 00000000 0 a505df1b 1 cbd57cb6 13 83e6f34d 20 97df24a8 1395 00000000 0 a505df1b 1 cbd57cb6 13 f926a02d 20 3bf04231 1270 00000000 0 a505df1b 1 cbd57cb6 13 7666558d 20 1669965d 1336 00000000 0 a505df1b 1 cbd57cb6 13 0ca606ed 20 458fd7e3 1387 00000000 0 a505df1b 1 cbd57cb6 13 d3762f0e 20 1cff3094 1274 00000000 0 a505df1b 1 cbd57cb6 13 a9b67c6e 20 5cc825ce 1255 00000000 0 a505df1b 1 cbd57cb6 13 26f689ce 20 6b579f35 1381 00000000 0 a505df1b 1 090a6bf6 20 0fe5f7c8 719 00000000 0 a505df1b 1 f6b55506 13 6156f31e 20 7e33584b 1242 00000000 0 a505df1b 1 cbd57cb6 13 de664d7f 20 36e9979e 1302 00000000 0 a505df1b 1 cbd57cb6 13 5939ff80 20 969ea405 1405 00000000 0 a505df1b 1 cbd57cb6 13 d6790a20 20 2ba2de8d 1289 00000000 0 a505df1b 1 cbd57cb6 13 acb95940 20 347f9853 1495 00000000 0 a505df1b 1 cbd57cb6 13 4f37be38 20 3921a7aa 1447 00000000 0 a505df1b 1 cbd57cb6 13 35f7ed58 20 cd0af20f 1423 00000000 0 00000000 0 112c25f5 28 a505df1b 1 e10ca4ed 12 70761289 13 d57e9fc6 768 aa4cba90 1871 00000000 0 a505df1b 1 16a826f0 13 98f8d084 20 92077b12 1035 00000000 0 a505df1b 1 16a826f0 13 e23883e4 20 2e876e1d 1006 00000000 0 a505df1b 1 16a826f0 13 5d083d85 20 246f8e04 826 00000000 0 a505df1b 1 16a826f0 13 27c86ee5 20 107711fc 935 00000000 0 a505df1b 1 16a826f0 13 a8889b45 20 2ad347d7 6 ca7f1183 875 00000000 0 a505df1b 1 51085c20 13 cf21d98f 20 77d00ed9 831 00000000 0 a505df1b 1 51085c20 13 f241f03f 20 85f36f81 763 00000000 0 a505df1b 1 51085c20 13 10f1f06c 20 8d48e8ea 895 00000000 0 a505df1b 1 16a826f0 13 4a389b16 20 b82b9f30 842 00000000 0 a505df1b 1 16a826f0 13 c5786eb6 20 b5f08776 6 2390d3a6 993 00000000 0 a505df1b 1 16a826f0 13 bfb83dd6 20 9bcf5ccc 871 00000000 0 a505df1b 1 16a826f0 13 008883b7 20 c5fca4da 921 00000000 0 a505df1b 1 16a826f0 13 7a48d0d7 20 dbf39b09 918 00000000 0 a505df1b 1 51085c20 13 6721c17d 20 b2ea5808 871 00000000 0 a505df1b 1 51085c20 13 d5011d6d 20 9d29895a 798 00000000 0 a505df1b 1 30934946 20 0232982b 388 00000000 0 a505df1b 1 29cad9b0 20 2ad347d7 6 f748f040 254 00000000 0 a505df1b 1 4ae9fdd2 20 36c54838 283 00000000 0 a505df1b 1 64bd7eff 20 c630360c 191 00000000 0 a505df1b 1 a1c39a91 20 2f34715a 425 00000000 0 a505df1b 1 87cb5fa6 20 3db20160 239 00000000 0 a505df1b 1 eab8fb5c 20 b5f08776 6 9a877bd8 431 00000000 0 a505df1b 1 16a826f0 13 8fc87617 20 5375f5d5 936 00000000 0 a505df1b 1 16a826f0 13 91d970f0 20 5b1bb117 983 00000000 0 a505df1b 1 16a826f0 13 eb192390 20 7c772ffa 963 00000000 0 a505df1b 1 16a826f0 13 6459d630 20 76228d20 965 00000000 0 a505df1b 1 16a826f0 13 1e998550 20 ce69f3de 917 00000000 0 a505df1b 1 16a826f0 13 a1a93b31 20 51a9adb5 1043 00000000 0 a505df1b 1 16a826f0 13 db696851 20 2ad347d7 6 02fd4115 979 00000000 0 a505df1b 1 16a826f0 13 54299df1 20 5fe368ac 1019 00000000 0 a505df1b 1 51085c20 13 49408c5b 20 e3d06d94 877 00000000 0 a505df1b 1 51085c20 13 0ee0f68b 20 93ba68de 941 00000000 0 a505df1b 1 16a826f0 13 f139e772 20 7336ec44 828 00000000 0 a505df1b 1 16a826f0 13 8bf9b412 20 b5f08776 6 829d13ca 953 00000000 0 a505df1b 1 16a826f0 13 04b941b2 20 2157568f 817 00000000 0 a505df1b 1 16a826f0 13 7e7912d2 20 baad6e9d 875 00000000 0 a505df1b 1 16a826f0 13 c149acb3 20 8b377bd7 916 00000000 0 a505df1b 1 16a826f0 13 bb89ffd3 20 929ffc5a 943 00000000 0 a505df1b 1 16a826f0 13 34c90a73 20 b08c634c 985 00000000 0 a505df1b 1 16a826f0 13 4e095913 20 c0f98db5 1014 00000000 0 a505df1b 1 51085c20 13 536048b9 20 2ad347d7 6 8fbe9d11 892 00000000 0 a505df1b 1 f6b55506 13 b396b88c 20 9902cae2 781 00000000 0 a505df1b 1 cbd57cb6 13 c956ebec 20 41f742e1 847 00000000 0 a505df1b 1 cbd57cb6 13 46161e4c 20 2dd797b7 909 00000000 0 a505df1b 1 cbd57cb6 13 3cd64d2c 20 b4bdfa3b 833 00000000 0 a505df1b 1 cbd57cb6 13 83e6f34d 20 b5f08776 6 f007f6df 889 00000000 0 a505df1b 1 cbd57cb6 13 f926a02d 20 70051db3 823 00000000 0 a505df1b 1 cbd57cb6 13 7666558d 20 607e97ec 872 00000000 0 a505df1b 1 cbd57cb6 13 0ca606ed 20 cd5ebb02 898 00000000 0 a505df1b 1 cbd57cb6 13 d3762f0e 20 ede0e40b 818 00000000 0 a505df1b 1 cbd57cb6 13 a9b67c6e 20 f309e76a 805 00000000 0 a505df1b 1 cbd57cb6 13 26f689ce 20 fbb48129 867 00000000 0 a505df1b 1 090a6bf6 20 2ad347d7 6 9454dd0f 429 00000000 0 a505df1b 1 f6b55506 13 6156f31e 20 50c961e0 798 00000000 0 a505df1b 1 cbd57cb6 13 de664d7f 20 cc75504f 848 00000000 0 a505df1b 1 cbd57cb6 13 5939ff80 20 72a331e1 914 00000000 0 a505df1b 1 cbd57cb6 13 d6790a20 20 879400be 859 00000000 0 a505df1b 1 cbd57cb6 13 acb95940 20 b5f08776 6 b3058026 970 00000000 0 a505df1b 1 cbd57cb6 13 4f37be38 20 0f80f3ee 943 00000000 0 a505df1b 1 cbd57cb6 13 35f7ed58 20 892719ce 922 00000000 0 00000000 0 799d00e4 13 29423a74 540122 00000000 0 ddfcc32e 13 aab4766e 1325 00000000 0 6540a44b 13 78bfca4a 6 ac9470c3 31 00000000 0 6540a44b 13 2b03da43 12 8db6b035 48 00000000 0 6540a44b 13 d590f627 45 5e12f723 63 00000000 0 6540a44b 13 ff1ed3ff 768 65a264da 414 00000000 0 529e5479 13 3dde8fa4 1172 00000000 0 529e5479 13 80b97c10 103 00000000 0 advancecomp-1.23/zip.cc000066400000000000000000001042611301462770100150350ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "zip.h" #include "siglock.h" #include "file.h" #include "data.h" #include "lib/endianrw.h" #include #include #include #include #include #include using namespace std; /** * Enable pendantic checks on the zip integrity. */ bool zip::pedantic = false; bool ecd_compare_sig(const unsigned char *buffer) { static char ecdsig[] = { 'P', 'K', 0x05, 0x06 }; return memcmp(buffer, ecdsig, 4) == 0; } /** * Locate end-of-central-dir sig in buffer and return offset * \param offset Resulting offset of cent dir start in buffer. * \reutn If the end-of-central-dir is found. */ bool ecd_find_sig (const unsigned char *buffer, unsigned buflen, unsigned& offset) { for (int i=buflen-22; i>=0; i--) { if (ecd_compare_sig(buffer+i)) { offset = i; return true; } } return false; } #define ECD_READ_BUFFER_SIZE 4096 /** * Read cent dir and end cent dir data * \param f File to read. * \param length Length of the file. */ bool cent_read(FILE* f, unsigned length, unsigned char*& data, unsigned& size) { unsigned buf_length; if (length <= ECD_READ_BUFFER_SIZE) { buf_length = length; } else { // align the read buf_length = length - ((length - ECD_READ_BUFFER_SIZE) & ~(ECD_READ_BUFFER_SIZE-1)); } while (true) { if (buf_length > length) buf_length = length; if (fseek(f, length - buf_length, SEEK_SET) != 0) { return false; } // allocate buffer unsigned char* buf = data_alloc(buf_length); assert(buf); if (fread(buf, buf_length, 1, f) != 1) { data_free(buf); return false; } unsigned offset = 0; if (ecd_find_sig(buf, buf_length, offset)) { unsigned start_of_cent_dir = le_uint32_read(buf + offset + ZIP_EO_offset_to_start_of_cent_dir); unsigned buf_pos = length - buf_length; if (start_of_cent_dir >= length) { data_free(buf); return false; } size = length - start_of_cent_dir; data = data_alloc(size); assert(data); if (buf_pos <= start_of_cent_dir) { memcpy(data, buf + (start_of_cent_dir - buf_pos), size); data_free(buf); } else { data_free(buf); if (fseek(f, start_of_cent_dir, SEEK_SET) != 0) { data_free(data); data = 0; return false; } if (fread(data, size, 1, f) != 1) { data_free(data); data = 0; return false; } } return true; } data_free(buf); if (buf_length < 8 * ECD_READ_BUFFER_SIZE && buf_length < length) { // grow buffer buf_length += ECD_READ_BUFFER_SIZE; } else { // aborting return false; } } } /** Code used for disk entry. */ #define ZIP_UNIQUE_DISK 0 /** Convert time_t to zip format. */ void time2zip(time_t tod, unsigned& date, unsigned& time) { struct tm* tm = gmtime(&tod); assert(tm); unsigned day = tm->tm_mday; // 1-31 unsigned mon = tm->tm_mon + 1; // 1-12 unsigned year = tm->tm_year - 80; // since 1980 date = (day & 0x1F) | ((mon & 0xF) << 5) | ((year & 0x7F) << 9); unsigned sec = tm->tm_sec / 2; // 0-29, double to get real seconds unsigned min = tm->tm_min; // 0-59 unsigned hour = tm->tm_hour; // 0-23 time = (sec & 0x1F) | ((min & 0x3F) << 5) | ((hour & 0x1F) << 11); } /** Convert zip time to to time_t. */ time_t zip2time(unsigned date, unsigned time) { struct tm tm; // reset all entry memset(&tm, 0, sizeof(tm)); // set know entry tm.tm_mday = date & 0x1F; // 1-31 tm.tm_mon = ((date >> 5) & 0xF) - 1; // 0-11 tm.tm_year = ((date >> 9) & 0x7f) + 80; // since 1900 tm.tm_sec = (time & 0x1F) * 2; // 0-59 tm.tm_min = (time >> 5) & 0x3F; // 0-59 tm.tm_hour = (time >> 11) & 0x1F; // 0-23 return mktime(&tm); } zip_entry::zip_entry(const zip& Aparent) { memset(&info, 0xFF, sizeof(info)); parent_name = Aparent.file_get(); info.filename_length = 0; file_name = 0; info.local_extra_field_length = 0; local_extra_field = 0; info.central_extra_field_length = 0; central_extra_field = 0; info.file_comment_length = 0; file_comment = 0; info.compressed_size = 0; data = 0; } zip_entry::zip_entry(const zip_entry& A) { info = A.info; parent_name = A.parent_name; file_name = data_dup(A.file_name, info.filename_length); local_extra_field = data_dup(A.local_extra_field, info.local_extra_field_length); central_extra_field = data_dup(A.central_extra_field, info.central_extra_field_length); file_comment = data_dup(A.file_comment, info.file_comment_length); data = data_dup(A.data, A.info.compressed_size); } zip_entry::~zip_entry() { data_free(file_name); data_free(local_extra_field); data_free(central_extra_field); data_free(file_comment); data_free(data); } zip_entry::method_t zip_entry::method_get() const { switch (info.compression_method) { case ZIP_METHOD_STORE : return store; case ZIP_METHOD_SHRUNK : return shrunk; case ZIP_METHOD_REDUCE1 : return reduce1; case ZIP_METHOD_REDUCE2 : return reduce2; case ZIP_METHOD_REDUCE3 : return reduce3; case ZIP_METHOD_REDUCE4 : return reduce4; case ZIP_METHOD_IMPLODE : switch (info.general_purpose_bit_flag & ZIP_GEN_FLAGS_IMPLODE_MASK) { case ZIP_GEN_FLAGS_IMPLODE_4KD2T : return implode_4kdict_2tree; case ZIP_GEN_FLAGS_IMPLODE_8KD2T : return implode_8kdict_2tree; case ZIP_GEN_FLAGS_IMPLODE_4KD3T : return implode_4kdict_3tree; case ZIP_GEN_FLAGS_IMPLODE_8KD3T : return implode_8kdict_3tree; } return unknown; case ZIP_METHOD_DEFLATE : switch (info.general_purpose_bit_flag & ZIP_GEN_FLAGS_DEFLATE_MASK) { case ZIP_GEN_FLAGS_DEFLATE_NORMAL : return deflate6; case ZIP_GEN_FLAGS_DEFLATE_MAXIMUM : return deflate9; case ZIP_GEN_FLAGS_DEFLATE_FAST : return deflate3; case ZIP_GEN_FLAGS_DEFLATE_SUPERFAST : return deflate1; } return unknown; case ZIP_METHOD_BZIP2 : return bzip2; case ZIP_METHOD_LZMA : return lzma; } return unknown; } bool zip_entry::is_text() const { return (info.internal_file_attrib & ZIP_INT_ATTR_TEXT) != 0; } void zip_entry::compressed_seek(FILE* f) const { // seek to local header if (fseek(f, offset_get(), SEEK_SET) != 0) { throw error_invalid() << "Failed seek " << parentname_get(); } // read local header unsigned char buf[ZIP_LO_FIXED]; if (fread(buf, ZIP_LO_FIXED, 1, f) != 1) { throw error() << "Failed read " << parentname_get(); } check_local(buf); // use the local extra_field_length. It may be different than the // central directory version in some zips. unsigned local_extra_field_length = le_uint16_read(buf+ZIP_LO_extra_field_length); // seek to data if (fseek(f, info.filename_length + local_extra_field_length, SEEK_CUR) != 0) { throw error_invalid() << "Failed seek " << parentname_get(); } } void zip_entry::compressed_read(unsigned char* outdata) const { if (data) { memcpy(outdata, data, compressed_size_get()); } else { FILE* f = fopen(parentname_get().c_str(), "rb"); if (!f) { throw error() << "Failed open for reading " << parentname_get(); } try { compressed_seek(f); if (compressed_size_get() > 0) { if (fread(outdata, compressed_size_get(), 1, f) != 1) { throw error() << "Failed read " << parentname_get(); } } } catch (...) { fclose(f); throw; } fclose(f); } } time_t zip_entry::time_get() const { return zip2time(info.last_mod_file_date, info.last_mod_file_time); } void zip_entry::time_set(time_t tod) { time2zip(tod, info.last_mod_file_date, info.last_mod_file_time); } void zip_entry::set(method_t method, const string& Aname, const unsigned char* compdata, unsigned compsize, unsigned size, unsigned crc, unsigned date, unsigned time, bool is_text) { info.version_needed_to_extract = 20; // version 2.0 info.os_needed_to_extract = 0; info.version_made_by = 20; // version 2.0 info.host_os = 0; info.general_purpose_bit_flag = 0; // default info.last_mod_file_date = date; info.last_mod_file_time = time; info.crc32 = crc; info.compressed_size = compsize; info.uncompressed_size = size; info.internal_file_attrib = is_text ? ZIP_INT_ATTR_TEXT : 0; info.external_file_attrib = 0; switch (method) { case store : if (size != compsize) { throw error_invalid() << "Zip entry size mismatch"; } info.compression_method = ZIP_METHOD_STORE; info.version_needed_to_extract = 10; // Version 1.0 break; case shrunk : info.compression_method = ZIP_METHOD_SHRUNK; break; case reduce1 : info.compression_method = ZIP_METHOD_REDUCE1; break; case reduce2 : info.compression_method = ZIP_METHOD_REDUCE2; break; case reduce3 : info.compression_method = ZIP_METHOD_REDUCE3; break; case reduce4 : info.compression_method = ZIP_METHOD_REDUCE4; break; case deflate1 : case deflate2 : info.compression_method = ZIP_METHOD_DEFLATE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_DEFLATE_SUPERFAST; break; case deflate3 : case deflate4 : case deflate5 : info.compression_method = ZIP_METHOD_DEFLATE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_DEFLATE_FAST; break; case deflate6 : case deflate7 : case deflate8 : info.compression_method = ZIP_METHOD_DEFLATE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_DEFLATE_NORMAL; break; case deflate9 : info.compression_method = ZIP_METHOD_DEFLATE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_DEFLATE_MAXIMUM; break; case implode_4kdict_2tree : info.compression_method = ZIP_METHOD_IMPLODE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_IMPLODE_4KD2T; break; case implode_8kdict_2tree : info.compression_method = ZIP_METHOD_IMPLODE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_IMPLODE_8KD2T; break; case implode_4kdict_3tree : info.compression_method = ZIP_METHOD_IMPLODE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_IMPLODE_4KD3T; break; case implode_8kdict_3tree : info.compression_method = ZIP_METHOD_IMPLODE; info.general_purpose_bit_flag |= ZIP_GEN_FLAGS_IMPLODE_8KD3T; break; case bzip2 : info.compression_method = ZIP_METHOD_BZIP2; break; case lzma : info.compression_method = ZIP_METHOD_LZMA; break; default : throw error_invalid() << "Compression method not supported"; } data_free(data); info.compressed_size = compsize; data = data_dup(compdata, info.compressed_size); name_set(Aname); data_free(local_extra_field); info.local_extra_field_length = 0; local_extra_field = 0; data_free(central_extra_field); info.central_extra_field_length = 0; central_extra_field = 0; data_free(file_comment); info.file_comment_length = 0; file_comment = 0; } void zip_entry::name_set(const string& Aname) { data_free(file_name); info.filename_length = Aname.length(); file_name = data_alloc(info.filename_length); memcpy(file_name, Aname.c_str(), info.filename_length); } string zip_entry::name_get() const { return string(file_name, file_name + info.filename_length); } /** Check central directory entry. */ void zip_entry::check_cent(const unsigned char* buf) const { // check signature if (le_uint32_read(buf+ZIP_CO_central_file_header_signature) != ZIP_C_signature) { throw error_invalid() << "Invalid central directory signature"; } // check filename_length > 0, can't exist a file without a name if (le_uint16_read(buf+ZIP_CO_filename_length) == 0) { throw error_invalid() << "Empty filename in central directory"; } } /** Check local file header comparing with internal information. */ void zip_entry::check_local(const unsigned char* buf) const { if (le_uint32_read(buf+ZIP_LO_local_file_header_signature) != ZIP_L_signature) { throw error_invalid() << "Invalid signature in local header"; } if (info.general_purpose_bit_flag != le_uint16_read(buf+ZIP_LO_general_purpose_bit_flag)) { throw error_invalid() << "Invalid local purpose bit flag " << info.general_purpose_bit_flag << "/" << le_uint16_read(buf+ZIP_LO_general_purpose_bit_flag); } if (info.compression_method != le_uint16_read(buf+ZIP_LO_compression_method)) { throw error_invalid() << "Invalid method on local header"; } if ((le_uint16_read(buf+ZIP_LO_general_purpose_bit_flag) & ZIP_GEN_FLAGS_DEFLATE_ZERO) != 0) { if (zip::pedantic) { if (le_uint32_read(buf+ZIP_LO_crc32) != 0) { throw error_invalid() << "Not zero crc on local header " << le_uint32_read(buf+ZIP_LO_crc32); } if (le_uint32_read(buf+ZIP_LO_compressed_size) != 0) { throw error_invalid() << "Not zero compressed size in local header " << le_uint32_read(buf+ZIP_LO_compressed_size); } if (le_uint32_read(buf+ZIP_LO_uncompressed_size) != 0) { throw error_invalid() << "Not zero uncompressed size in local header " << le_uint32_read(buf+ZIP_LO_uncompressed_size); } } else { // allow the entries to have the correct value instead of 0 if (le_uint32_read(buf+ZIP_LO_crc32) != 0 && info.crc32 != le_uint32_read(buf+ZIP_LO_crc32)) { throw error_invalid() << "Not zero crc on local header " << le_uint32_read(buf+ZIP_LO_crc32); } if (le_uint32_read(buf+ZIP_LO_compressed_size) != 0 && info.compressed_size != le_uint32_read(buf+ZIP_LO_compressed_size)) { throw error_invalid() << "Not zero compressed size in local header " << le_uint32_read(buf+ZIP_LO_compressed_size); } if (le_uint32_read(buf+ZIP_LO_uncompressed_size) != 0 && info.uncompressed_size != le_uint32_read(buf+ZIP_LO_uncompressed_size)) { throw error_invalid() << "Not zero uncompressed size in local header " << le_uint32_read(buf+ZIP_LO_uncompressed_size); } } } else { if (info.crc32 != le_uint32_read(buf+ZIP_LO_crc32)) { throw error_invalid() << "Invalid crc on local header " << info.crc32 << "/" << le_uint32_read(buf+ZIP_LO_crc32); } if (info.compressed_size != le_uint32_read(buf+ZIP_LO_compressed_size)) { throw error_invalid() << "Invalid compressed size in local header " << info.compressed_size << "/" << le_uint32_read(buf+ZIP_LO_compressed_size); } if (info.uncompressed_size != le_uint32_read(buf+ZIP_LO_uncompressed_size)) { throw error_invalid() << "Invalid uncompressed size in local header " << info.uncompressed_size << "/" << le_uint32_read(buf+ZIP_LO_uncompressed_size); } } if (info.filename_length != le_uint16_read(buf+ZIP_LO_filename_length)) { throw error_invalid() << "Invalid filename in local header"; } if (info.local_extra_field_length != le_uint16_read(buf+ZIP_LO_extra_field_length) && info.local_extra_field_length != 0 // the .zip generated with the info-zip program have the extra field only on the local header ) { throw error_invalid() << "Invalid extra field length in local header " << info.local_extra_field_length << "/" << le_uint16_read(buf+ZIP_LO_extra_field_length); } } void zip_entry::check_descriptor(const unsigned char* buf) const { if (info.crc32 != le_uint32_read(buf+ZIP_DO_crc32)) { throw error_invalid() << "Invalid crc on data descriptor " << info.crc32 << "/" << le_uint32_read(buf+ZIP_DO_crc32); } if (info.compressed_size != le_uint32_read(buf+ZIP_DO_compressed_size)) { throw error_invalid() << "Invalid compressed size in data descriptor " << info.compressed_size << "/" << le_uint32_read(buf+ZIP_DO_compressed_size); } if (info.uncompressed_size != le_uint32_read(buf+ZIP_DO_uncompressed_size)) { throw error_invalid() << "Invalid uncompressed size in data descriptor " << info.uncompressed_size << "/" << le_uint32_read(buf+ZIP_DO_uncompressed_size); } } /** Unload compressed/uncomressed data. */ void zip_entry::unload() { data_free(data); data = 0; } /** Skip local file header and data. */ void zip::skip_local(const unsigned char* buf, FILE* f) { unsigned local_extra_field_length = le_uint16_read(buf+ZIP_LO_extra_field_length); unsigned filename_length = le_uint16_read(buf+ZIP_LO_filename_length); unsigned compressed_size = le_uint32_read(buf+ZIP_LO_compressed_size); // skip filename and extra field if (fseek(f, filename_length + local_extra_field_length, SEEK_CUR) != 0) { throw error_invalid() << "Failed seek"; } // directory don't have data if (compressed_size) { if (fseek(f, compressed_size, SEEK_CUR) != 0) { throw error_invalid() << "Failed seek"; } } // data descriptor if ((le_uint16_read(buf+ZIP_LO_general_purpose_bit_flag) & ZIP_GEN_FLAGS_DEFLATE_ZERO) != 0) { if (fseek(f, ZIP_DO_FIXED, SEEK_CUR) != 0) { throw error_invalid() << "Failed seek"; } } } /** * Load local file header. * \param buf Fixed size local header. * \param f File seeked after the fixed size local header. */ void zip_entry::load_local(const unsigned char* buf, FILE* f, unsigned size) { check_local(buf); // use the local extra_field_length. It may be different than the // central directory version in some zips. unsigned local_extra_field_length = le_uint16_read(buf+ZIP_LO_extra_field_length); if (size < info.filename_length + local_extra_field_length) { throw error_invalid() << "Overflow of filename"; } size -= info.filename_length + local_extra_field_length; // skip filename and extra field if (fseek(f, info.filename_length + local_extra_field_length, SEEK_CUR) != 0) { throw error_invalid() << "Failed seek"; } data_free(data); data = data_alloc(info.compressed_size); if (size < info.compressed_size) { throw error_invalid() << "Overflow of compressed data"; } size -= info.compressed_size; try { if (info.compressed_size > 0) { if (fread(data, info.compressed_size, 1, f) != 1) { throw error() << "Failed read"; } } } catch (...) { data_free(data); data = 0; throw; } // load the data descriptor if ((le_uint16_read(buf+ZIP_LO_general_purpose_bit_flag) & ZIP_GEN_FLAGS_DEFLATE_ZERO) != 0) { unsigned char data_desc[ZIP_DO_FIXED]; if (size < ZIP_DO_FIXED) { throw error_invalid() << "Overflow of data descriptor"; } size -= ZIP_DO_FIXED; if (fread(data_desc, ZIP_DO_FIXED, 1, f) != 1) { throw error() << "Failed read"; } check_descriptor(data_desc); } } /** * Save local file header. * \param f File seeked at correct position. */ void zip_entry::save_local(FILE* f) { long offset = ftell(f); if (offset<0) throw error() << "Failed tell"; info.relative_offset_of_local_header = offset; // write header unsigned char buf[ZIP_LO_FIXED]; le_uint32_write(buf+ZIP_LO_local_file_header_signature, ZIP_L_signature); le_uint8_write(buf+ZIP_LO_version_needed_to_extract, info.version_needed_to_extract); le_uint8_write(buf+ZIP_LO_os_needed_to_extract, info.os_needed_to_extract); // clear the "data descriptor" bit le_uint16_write(buf+ZIP_LO_general_purpose_bit_flag, info.general_purpose_bit_flag & ~ZIP_GEN_FLAGS_DEFLATE_ZERO); le_uint16_write(buf+ZIP_LO_compression_method, info.compression_method); le_uint16_write(buf+ZIP_LO_last_mod_file_time, info.last_mod_file_time); le_uint16_write(buf+ZIP_LO_last_mod_file_date, info.last_mod_file_date); le_uint32_write(buf+ZIP_LO_crc32, info.crc32); le_uint32_write(buf+ZIP_LO_compressed_size, info.compressed_size); le_uint32_write(buf+ZIP_LO_uncompressed_size, info.uncompressed_size); le_uint16_write(buf+ZIP_LO_filename_length, info.filename_length); le_uint16_write(buf+ZIP_LO_extra_field_length, info.local_extra_field_length); if (fwrite(buf, ZIP_LO_FIXED, 1, f) != 1) { throw error() << "Failed write"; } // write filename if (fwrite(file_name, info.filename_length, 1, f) != 1) { throw error() << "Failed write"; } // write the extra field if (info.local_extra_field_length && fwrite(local_extra_field, info.local_extra_field_length, 1, f) != 1) { throw error() << "Failed write"; } // write data, directories don't have data if (info.compressed_size) { assert(data); if (fwrite(data, info.compressed_size, 1, f) != 1) { throw error() << "Failed write"; } } } /** * Load cent dir. * \param buf Fixed size cent dir. * \param f File seeked after the fixed size cent dir. */ void zip_entry::load_cent(const unsigned char* buf, unsigned& skip) { const unsigned char* o_buf = buf; check_cent(buf); // read header info.version_made_by = le_uint8_read(buf+ZIP_CO_version_made_by); info.host_os = le_uint8_read(buf+ZIP_CO_host_os); info.version_needed_to_extract = le_uint8_read(buf+ZIP_CO_version_needed_to_extract); info.os_needed_to_extract = le_uint8_read(buf+ZIP_CO_os_needed_to_extract); info.general_purpose_bit_flag = le_uint16_read(buf+ZIP_CO_general_purpose_bit_flag); info.compression_method = le_uint16_read(buf+ZIP_CO_compression_method); info.last_mod_file_time = le_uint16_read(buf+ZIP_CO_last_mod_file_time); info.last_mod_file_date = le_uint16_read(buf+ZIP_CO_last_mod_file_date); info.crc32 = le_uint32_read(buf+ZIP_CO_crc32); info.compressed_size = le_uint32_read(buf+ZIP_CO_compressed_size); info.uncompressed_size = le_uint32_read(buf+ZIP_CO_uncompressed_size); info.filename_length = le_uint16_read(buf+ZIP_CO_filename_length); info.central_extra_field_length = le_uint16_read(buf+ZIP_CO_extra_field_length); info.file_comment_length = le_uint16_read(buf+ZIP_CO_file_comment_length); info.internal_file_attrib = le_uint16_read(buf+ZIP_CO_internal_file_attrib); info.external_file_attrib = le_uint32_read(buf+ZIP_CO_external_file_attrib); info.relative_offset_of_local_header = le_uint32_read(buf+ZIP_CO_relative_offset_of_local_header); buf += ZIP_CO_FIXED; // read filename data_free(file_name); file_name = data_alloc(info.filename_length); memcpy(file_name, buf, info.filename_length); buf += info.filename_length; // read extra field data_free(central_extra_field); central_extra_field = data_dup(buf, info.central_extra_field_length); buf += info.central_extra_field_length; // read comment data_free(file_comment); file_comment = data_dup(buf, info.file_comment_length); buf += info.file_comment_length; skip = buf - o_buf; } /** * Save cent dir. * \param f File seeked at correct position. */ void zip_entry::save_cent(FILE* f) { unsigned char buf[ZIP_CO_FIXED]; le_uint32_write(buf+ZIP_CO_central_file_header_signature, ZIP_C_signature); le_uint8_write(buf+ZIP_CO_version_made_by, info.version_made_by); le_uint8_write(buf+ZIP_CO_host_os, info.host_os); le_uint8_write(buf+ZIP_CO_version_needed_to_extract, info.version_needed_to_extract); le_uint8_write(buf+ZIP_CO_os_needed_to_extract, info.os_needed_to_extract); // clear the "data descriptor" bit le_uint16_write(buf+ZIP_CO_general_purpose_bit_flag, info.general_purpose_bit_flag & ~ZIP_GEN_FLAGS_DEFLATE_ZERO); le_uint16_write(buf+ZIP_CO_compression_method, info.compression_method); le_uint16_write(buf+ZIP_CO_last_mod_file_time, info.last_mod_file_time); le_uint16_write(buf+ZIP_CO_last_mod_file_date, info.last_mod_file_date); le_uint32_write(buf+ZIP_CO_crc32, info.crc32); le_uint32_write(buf+ZIP_CO_compressed_size, info.compressed_size); le_uint32_write(buf+ZIP_CO_uncompressed_size, info.uncompressed_size); le_uint16_write(buf+ZIP_CO_filename_length, info.filename_length); le_uint16_write(buf+ZIP_CO_extra_field_length, info.central_extra_field_length); le_uint16_write(buf+ZIP_CO_file_comment_length, info.file_comment_length); le_uint16_write(buf+ZIP_CO_disk_number_start, ZIP_UNIQUE_DISK); le_uint16_write(buf+ZIP_CO_internal_file_attrib, info.internal_file_attrib); le_uint32_write(buf+ZIP_CO_external_file_attrib, info.external_file_attrib); le_uint32_write(buf+ZIP_CO_relative_offset_of_local_header, info.relative_offset_of_local_header); if (fwrite(buf, ZIP_CO_FIXED, 1, f) != 1) { throw error() << "Failed write"; } // write filename if (fwrite(file_name, info.filename_length, 1, f) != 1) { throw error() << "Failed write"; } // write extra field if (info.central_extra_field_length && fwrite(central_extra_field, info.central_extra_field_length, 1, f) != 1) { throw error() << "Failed write"; } // write comment if (info.file_comment_length && fwrite(file_comment, info.file_comment_length, 1, f) != 1) { throw error() << "Failed write"; } } zip::zip(const std::string& Apath) : path(Apath) { flag.open = false; flag.read = false; flag.modify = false; zipfile_comment = 0; } zip::zip(const zip& A) : map(A.map), path(A.path) { flag = A.flag; info = A.info; zipfile_comment = data_dup(A.zipfile_comment, A.info.zipfile_comment_length); } zip::~zip() { if (is_open()) close(); } void zip::create() { assert(!flag.open); info.offset_to_start_of_cent_dir = 0; info.zipfile_comment_length = 0; data_free(zipfile_comment); zipfile_comment = 0; flag.read = true; flag.open = true; flag.modify = false; } void zip::open() { assert(!flag.open); struct stat s; if (stat(path.c_str(), &s) != 0) { if (errno != ENOENT) throw error() << "Failed stat"; // create the file if it's missing create(); return; } unsigned length = s.st_size; // open file FILE* f = fopen(path.c_str(), "rb"); if (!f) throw error() << "Failed open for reading"; unsigned char* data = 0; unsigned data_size = 0; try { if (!cent_read(f, length, data, data_size)) throw error_invalid() << "Failed read end of central directory"; } catch (...) { fclose(f); throw; } fclose(f); // position in data unsigned data_pos = 0; try { // central dir while (le_uint32_read(data+data_pos) == ZIP_C_signature) { iterator i = map.insert(map.end(), zip_entry(path)); unsigned skip = 0; try { i->load_cent(data + data_pos, skip); } catch (...) { map.erase(i); throw; } data_pos += skip; } // end of central dir if (le_uint32_read(data+data_pos) != ZIP_E_signature) throw error_invalid() << "Invalid end of central dir signature"; info.offset_to_start_of_cent_dir = le_uint32_read(data+data_pos+ZIP_EO_offset_to_start_of_cent_dir); info.zipfile_comment_length = le_uint16_read(data+data_pos+ZIP_EO_zipfile_comment_length); data_pos += ZIP_EO_FIXED; if (info.offset_to_start_of_cent_dir != length - data_size) throw error_invalid() << "Invalid end of central directory start address"; // comment data_free(zipfile_comment); zipfile_comment = data_dup(data+data_pos, info.zipfile_comment_length); data_pos += info.zipfile_comment_length; } catch (...) { data_free(data); throw; } // delete cent data data_free(data); if (pedantic) { // don't accept garbage at the end of file if (data_pos != data_size) throw error_invalid() << data_size - data_pos << " unused bytes at the end of the central directory"; } flag.open = true; flag.read = false; flag.modify = false; } /** * Close a zip file. */ void zip::close() { // deinizialize flag.open = false; flag.read = false; flag.modify = false; data_free(zipfile_comment); zipfile_comment = 0; path = ""; map.erase(map.begin(), map.end()); } /** * Discarge compressed data read. * \note You cannot call unload() if zip is modified, you must call reopen(). */ void zip::unload() { assert(flag.open && flag.read && !flag.modify); for(iterator i=begin();i!=end();++i) i->unload(); flag.read = false; } /** * Reopen from zip on disk, lose any modify. * \note Equivalent close and open. */ void zip::reopen() { assert(flag.open); close(); open(); } /** * Load a zip file. */ void zip::load() { assert(flag.open && !flag.read); flag.modify = false; FILE* f = fopen(path.c_str(), "rb"); if (!f) throw error() << "Failed open for reading"; try { long offset = 0; unsigned count = 0; while (static_cast(offset) < info.offset_to_start_of_cent_dir) { unsigned char buf[ZIP_LO_FIXED]; // search the next item, assume entries in random order iterator next; bool next_set = false; for(iterator i=begin();i!=end();++i) { if (i->offset_get() >= static_cast(offset)) { if (!next_set || i->offset_get() < next->offset_get()) { next_set = true; next = i; } } } // if not found exit if (!next_set) { if (pedantic) throw error_invalid() << info.offset_to_start_of_cent_dir - static_cast(offset) << " unused bytes after the last local header at offset " << offset; else break; } // check for invalid start if (next->offset_get() >= info.offset_to_start_of_cent_dir) { throw error_invalid() << "Overflow in central directory"; } // check for a data hole if (next->offset_get() > static_cast(offset)) { if (pedantic) throw error_invalid() << next->offset_get() - static_cast(offset) << " unused bytes at offset " << offset; else { // set the correct position if (fseek(f, next->offset_get(), SEEK_SET) != 0) throw error() << "Failed fseek"; offset = next->offset_get(); } } // search the next item, assume entries in random order iterator next_next; bool next_next_set = false; for(iterator i=begin();i!=end();++i) { if (i->offset_get() > static_cast(offset)) { if (!next_next_set || i->offset_get() < next_next->offset_get()) { next_next_set = true; next_next = i; } } } unsigned long end_offset; if (next_next_set) end_offset = next_next->offset_get(); else end_offset = info.offset_to_start_of_cent_dir; if (end_offset < next->offset_get() + ZIP_LO_FIXED) { throw error_invalid() << "Invalid local header size at offset " << offset; } if (fread(buf, ZIP_LO_FIXED, 1, f) != 1) throw error() << "Failed read"; next->load_local(buf, f, end_offset - next->offset_get() - ZIP_LO_FIXED); ++count; offset = ftell(f); if (offset < 0) throw error() << "Failed tell"; } if (static_cast(offset) != info.offset_to_start_of_cent_dir) { if (pedantic) throw error_invalid() << "Invalid central directory start"; } if (count != size()) throw error_invalid() << "Invalid central directory, expected " << size() << " local headers, got " << count; } catch (...) { fclose(f); throw; } fclose(f); flag.read = true; } unsigned zip::size_not_zero() const { unsigned count = 0; // check if it contains at least one file with size > 0 (directories are excluded) for(const_iterator i=begin();i!=end();++i) { if (i->uncompressed_size_get() > 0) { ++count; } } return count; } /** * Save a zip file. */ void zip::save() { assert(flag.open && flag.read); flag.modify = false; if (!empty()) { // prevent external signal sig_auto_lock sal; // temp name of the saved file string save_path = file_temp(path); FILE* f = fopen(save_path.c_str(), "wb"); if (!f) throw error() << "Failed open for writing of " << save_path; try { // write local header for(iterator i=begin();i!=end();++i) i->save_local(f); long cent_offset = ftell(f); if (cent_offset<0) throw error() << "Failed tell"; // new cent start info.offset_to_start_of_cent_dir = cent_offset; // write cent dir for(iterator i=begin();i!=end();++i) i->save_cent(f); long end_cent_offset = ftell(f); if (end_cent_offset<0) throw error() << "Failed tell"; // write end of cent dir unsigned char buf[ZIP_EO_FIXED]; le_uint32_write(buf+ZIP_EO_end_of_central_dir_signature, ZIP_E_signature); le_uint16_write(buf+ZIP_EO_number_of_this_disk, ZIP_UNIQUE_DISK); le_uint16_write(buf+ZIP_EO_number_of_disk_start_cent_dir, ZIP_UNIQUE_DISK); le_uint16_write(buf+ZIP_EO_total_entries_cent_dir_this_disk, size()); le_uint16_write(buf+ZIP_EO_total_entries_cent_dir, size()); le_uint32_write(buf+ZIP_EO_size_of_cent_dir, end_cent_offset - cent_offset); le_uint32_write(buf+ZIP_EO_offset_to_start_of_cent_dir, cent_offset); le_uint16_write(buf+ZIP_EO_zipfile_comment_length, info.zipfile_comment_length); if (fwrite(buf, ZIP_EO_FIXED, 1, f) != 1) throw error() << "Failed write"; // write comment if (info.zipfile_comment_length && fwrite(zipfile_comment, info.zipfile_comment_length, 1, f) != 1) throw error() << "Failed write"; } catch (...) { fclose(f); remove(save_path.c_str()); throw; } fclose(f); // delete the file if exists if (access(path.c_str(), F_OK) == 0) { if (remove(path.c_str()) != 0) { remove(save_path.c_str()); throw error() << "Failed delete of " << path; } } // rename the new version with the correct name if (::rename(save_path.c_str(), path.c_str()) != 0) { throw error() << "Failed rename of " << save_path << " to " << path; } } else { // reset the cent start info.offset_to_start_of_cent_dir = 0; // delete the file if exists if (access(path.c_str(), F_OK) == 0) { if (remove(path.c_str()) != 0) throw error() << "Failed delete of " << path; } } } /** * Remove a compressed file. */ void zip::erase(iterator i) { assert(flag.read); flag.modify = true; map.erase(i); } /** * Rename a compressed file. * \note No filename overwrite check. */ void zip::rename(iterator i, const string& Aname) { assert(flag.read); flag.modify = true; i->name_set(Aname); } /** * Insert a zip entry. */ zip::iterator zip::insert(const zip_entry& A, const string& Aname) { iterator i; assert(flag.read); unsigned char* data = data_alloc(A.compressed_size_get()); assert(data); try { A.compressed_read(data); i = map.insert(map.end(), zip_entry(path)); try { i->set(A.method_get(), Aname, data, A.compressed_size_get(), A.uncompressed_size_get(), A.crc_get(), A.zipdate_get(), A.ziptime_get(), A.is_text()); } catch (...) { map.erase(i); throw; } flag.modify = true; } catch (...) { data_free(data); throw; } data_free(data); return i; } /** * Add data to a zip file. * The data is deflated or stored. No filename overwrite check. */ zip::iterator zip::insert_uncompressed(const string& Aname, const unsigned char* data, unsigned size, unsigned crc, time_t tod, bool is_text) { iterator i; assert(flag.read); assert(crc == crc32(0, (const unsigned char*)data, size)); unsigned date = 0; unsigned time = 0; time2zip(tod, date, time); i = map.insert(map.end(), zip_entry(path)); try { i->set(zip_entry::store, Aname, data, size, size, crc, date, time, is_text); } catch (...) { map.erase(i); throw; } flag.modify = true; return i; } advancecomp-1.23/zip.h000066400000000000000000000234561301462770100147050ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 1998, 1999, 2000, 2001, 2002 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __ZIP_H #define __ZIP_H #include "except.h" #ifdef USE_COMPRESS #include "compress.h" #endif #include #include // -------------------------------------------------------------------------- // Zip format // Methods #define ZIP_METHOD_STORE 0x00 #define ZIP_METHOD_SHRUNK 0x01 #define ZIP_METHOD_REDUCE1 0x02 #define ZIP_METHOD_REDUCE2 0x03 #define ZIP_METHOD_REDUCE3 0x04 #define ZIP_METHOD_REDUCE4 0x05 #define ZIP_METHOD_IMPLODE 0x06 #define ZIP_METHOD_TOKENIZE 0x07 #define ZIP_METHOD_DEFLATE 0x08 // Not standard methods #define ZIP_METHOD_ENHDEFLATE 0x09 #define ZIP_METHOD_BZIP2 0x0C #define ZIP_METHOD_LZMA 0x0F // Generic flags // If bit 0 is set, indicates that the file is encrypted. #define ZIP_GEN_FLAGS_ENCRYPTED 0x01 // Compression method for deflate #define ZIP_GEN_FLAGS_DEFLATE_NORMAL 0x00 #define ZIP_GEN_FLAGS_DEFLATE_MAXIMUM 0x02 #define ZIP_GEN_FLAGS_DEFLATE_FAST 0x04 #define ZIP_GEN_FLAGS_DEFLATE_SUPERFAST 0x06 #define ZIP_GEN_FLAGS_DEFLATE_MASK 0x06 // If bit 3 is set, the fields crc-32, compressed size // and uncompressed size are set to zero in the local // header. The correct values are put in the data descriptor // immediately following the compressed data and in the central directory. #define ZIP_GEN_FLAGS_DEFLATE_ZERO 0x08 // If bit 1 is set indicates an 8K sliding dictionary was used. // If clear, then a 4K sliding dictionary was used. // If bit 2 is set, indicates an 3 Shannon-Fano trees were used // to encode the sliding dictionary output. If clear, then 2 // Shannon-Fano trees were used. #define ZIP_GEN_FLAGS_IMPLODE_4KD2T 0x00 #define ZIP_GEN_FLAGS_IMPLODE_8KD2T 0x02 #define ZIP_GEN_FLAGS_IMPLODE_4KD3T 0x04 #define ZIP_GEN_FLAGS_IMPLODE_8KD3T 0x06 #define ZIP_GEN_FLAGS_IMPLODE_MASK 0x06 // if bit 11 is set filename and comment fields for this file // must be encoded using UTF-8 #define ZIP_GEN_FLAGS_EFS 0x800 // Internal file attributes // If set, that the file is apparently an ASCII or text file. #define ZIP_INT_ATTR_TEXT 0x01 // Signature #define ZIP_L_signature 0x04034b50 #define ZIP_C_signature 0x02014b50 #define ZIP_E_signature 0x06054b50 // Offsets in end of central directory structure #define ZIP_EO_end_of_central_dir_signature 0x00 #define ZIP_EO_number_of_this_disk 0x04 #define ZIP_EO_number_of_disk_start_cent_dir 0x06 #define ZIP_EO_total_entries_cent_dir_this_disk 0x08 #define ZIP_EO_total_entries_cent_dir 0x0A #define ZIP_EO_size_of_cent_dir 0x0C #define ZIP_EO_offset_to_start_of_cent_dir 0x10 #define ZIP_EO_zipfile_comment_length 0x14 #define ZIP_EO_FIXED 0x16 // size of fixed data structure #define ZIP_EO_zipfile_comment 0x16 // Offsets in central directory entry structure #define ZIP_CO_central_file_header_signature 0x00 #define ZIP_CO_version_made_by 0x04 #define ZIP_CO_host_os 0x05 #define ZIP_CO_version_needed_to_extract 0x06 #define ZIP_CO_os_needed_to_extract 0x07 #define ZIP_CO_general_purpose_bit_flag 0x08 #define ZIP_CO_compression_method 0x0A #define ZIP_CO_last_mod_file_time 0x0C #define ZIP_CO_last_mod_file_date 0x0E #define ZIP_CO_crc32 0x10 #define ZIP_CO_compressed_size 0x14 #define ZIP_CO_uncompressed_size 0x18 #define ZIP_CO_filename_length 0x1C #define ZIP_CO_extra_field_length 0x1E #define ZIP_CO_file_comment_length 0x20 #define ZIP_CO_disk_number_start 0x22 #define ZIP_CO_internal_file_attrib 0x24 #define ZIP_CO_external_file_attrib 0x26 #define ZIP_CO_relative_offset_of_local_header 0x2A #define ZIP_CO_FIXED 0x2E // size of fixed data structure #define ZIP_CO_filename 0x2E // Offsets in data descriptor structure #define ZIP_DO_crc32 0x00 #define ZIP_DO_compressed_size 0x04 #define ZIP_DO_uncompressed_size 0x08 #define ZIP_DO_FIXED 0x0C // size of fixed data structure // Offsets in local file header structure #define ZIP_LO_local_file_header_signature 0x00 #define ZIP_LO_version_needed_to_extract 0x04 #define ZIP_LO_os_needed_to_extract 0x05 #define ZIP_LO_general_purpose_bit_flag 0x06 #define ZIP_LO_compression_method 0x08 #define ZIP_LO_last_mod_file_time 0x0A #define ZIP_LO_last_mod_file_date 0x0C #define ZIP_LO_crc32 0x0E #define ZIP_LO_compressed_size 0x12 #define ZIP_LO_uncompressed_size 0x16 #define ZIP_LO_filename_length 0x1A #define ZIP_LO_extra_field_length 0x1C #define ZIP_LO_FIXED 0x1E // size of fixed data structure #define ZIP_LO_filename 0x1E void time2zip(time_t tod, unsigned& date, unsigned& time); time_t zip2time(unsigned date, unsigned time); class zip; class zip_entry { public: enum method_t { unknown, store, shrunk, reduce1, reduce2, reduce3, reduce4, implode_4kdict_2tree, implode_8kdict_2tree, implode_4kdict_3tree, implode_8kdict_3tree, deflate0, deflate1, deflate2, deflate3, deflate4, deflate5, deflate6, deflate7, deflate8, deflate9, bzip2, lzma }; private: struct { unsigned version_made_by; unsigned host_os; unsigned version_needed_to_extract; unsigned os_needed_to_extract; unsigned general_purpose_bit_flag; unsigned compression_method; unsigned last_mod_file_time; unsigned last_mod_file_date; unsigned crc32; unsigned compressed_size; unsigned uncompressed_size; unsigned filename_length; unsigned central_extra_field_length; unsigned local_extra_field_length; unsigned file_comment_length; unsigned internal_file_attrib; unsigned external_file_attrib; unsigned relative_offset_of_local_header; } info; std::string parent_name; // parent unsigned char* file_name; unsigned char* file_comment; unsigned char* local_extra_field; unsigned char* central_extra_field; unsigned char* data; void check_cent(const unsigned char* buf) const; void check_local(const unsigned char* buf) const; void check_descriptor(const unsigned char* buf) const; zip_entry(); zip_entry& operator=(const zip_entry&); bool operator==(const zip_entry&) const; bool operator!=(const zip_entry&) const; public: zip_entry(const zip& Aparent); zip_entry(const zip_entry& A); ~zip_entry(); void load_local(const unsigned char* buf, FILE* f, unsigned size); void save_local(FILE* f); void load_cent(const unsigned char* buf, unsigned& skip); void save_cent(FILE* f); void unload(); method_t method_get() const; void set(method_t method, const std::string& name, const unsigned char* compdata, unsigned compsize, unsigned size, unsigned crc, unsigned date, unsigned time, bool is_text); unsigned compressed_size_get() const { return info.compressed_size; } unsigned uncompressed_size_get() const { return info.uncompressed_size; } unsigned crc_get() const { return info.crc32; } bool is_text() const; void compressed_seek(FILE* f) const; void compressed_read(unsigned char* outdata) const; void uncompressed_read(unsigned char* outdata) const; const std::string& parentname_get() const { return parent_name; } void name_set(const std::string& Aname); std::string name_get() const; unsigned offset_get() const { return info.relative_offset_of_local_header; } unsigned zipdate_get() const { return info.last_mod_file_date; } unsigned ziptime_get() const { return info.last_mod_file_time; } time_t time_get() const; void time_set(time_t tod); #ifdef USE_COMPRESS bool shrink(bool standard, shrink_t level); #endif void test() const; }; typedef std::list zip_entry_list; class zip { struct { bool open; // zip is opened bool read; // zip is loaded (valid only if flag_open==true) bool modify; // zip is modified (valid only if flag_read==true) } flag; struct { unsigned offset_to_start_of_cent_dir; unsigned zipfile_comment_length; } info; unsigned char* zipfile_comment; zip_entry_list map; std::string path; zip& operator=(const zip&); bool operator==(const zip&) const; bool operator!=(const zip&) const; void skip_local(const unsigned char* buf, FILE* f); static bool pedantic; friend class zip_entry; public: static void pedantic_set(bool Apedantic) { pedantic = Apedantic; } zip(const std::string& Apath); zip(const zip& A); ~zip(); typedef zip_entry_list::const_iterator const_iterator; typedef zip_entry_list::iterator iterator; const_iterator begin() const { assert(flag.open); return map.begin(); } const_iterator end() const { assert(flag.open); return map.end(); } iterator begin() { assert(flag.open); return map.begin(); } iterator end() { assert(flag.open); return map.end(); } unsigned size() const { assert(flag.open); return map.size(); } unsigned size_not_zero() const; bool empty() const { return size_not_zero() == 0; } std::string file_get() const { return path; } void open(); void create(); void close(); void reopen(); void save(); void load(); void unload(); bool is_open() const { return flag.open; } bool is_load() const { assert(flag.open); return flag.read; } bool is_modify() const { assert(flag.open && flag.read); return flag.modify; } void erase(iterator i); void rename(iterator i, const std::string& Aname); iterator insert(const zip_entry& A, const std::string& Aname); iterator insert_uncompressed(const std::string& Aname, const unsigned char* data, unsigned size, unsigned crc, time_t tod, bool is_text); #ifdef USE_COMPRESS void shrink(bool standard, shrink_t level); #endif void test() const; }; #endif advancecomp-1.23/zipsh.cc000066400000000000000000000274461301462770100154010ustar00rootroot00000000000000/* * This file is part of the Advance project. * * Copyright (C) 2002, 2004, 2005 Andrea Mazzoleni * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "portable.h" #include "zip.h" #include "data.h" #include #include using namespace std; void zip_entry::uncompressed_read(unsigned char* uncompressed_data) const { assert(data); if (info.compression_method == ZIP_METHOD_DEFLATE) { if (!decompress_deflate_zlib(data, compressed_size_get(), uncompressed_data, uncompressed_size_get())) { throw error_invalid() << "Invalid compressed data on file " << name_get(); } #if USE_BZIP2 } else if (info.compression_method == ZIP_METHOD_BZIP2) { if (!decompress_bzip2(data, compressed_size_get(), uncompressed_data, uncompressed_size_get())) { throw error_invalid() << "Invalid compressed data on file " << name_get(); } #endif } else if (info.compression_method == ZIP_METHOD_LZMA) { if (!decompress_lzma_7z(data, compressed_size_get(), uncompressed_data, uncompressed_size_get())) { throw error_invalid() << "Invalid compressed data on file " << name_get(); } } else if (info.compression_method == ZIP_METHOD_STORE) { memcpy(uncompressed_data, data, uncompressed_size_get()); } else { throw error_unsupported() << "Unsupported compression method on file " << name_get(); } } void zip_entry::test() const { assert(data); unsigned char* uncompressed_data = data_alloc(uncompressed_size_get()); try { uncompressed_read(uncompressed_data); if (info.crc32 != crc32(0, uncompressed_data, uncompressed_size_get())) { throw error_invalid() << "Invalid crc on file " << name_get(); } } catch (...) { data_free(uncompressed_data); throw; } data_free(uncompressed_data); } static bool got(unsigned char* c0_data, unsigned c0_size, unsigned c0_met, unsigned char* c1_data, unsigned c1_size, unsigned c1_met, bool substitute_if_equal, bool standard, bool store) { bool c0_acceptable = c0_data!=0; bool c1_acceptable = c1_data!=0; if (standard) { c0_acceptable = c0_acceptable && (c0_met <= ZIP_METHOD_DEFLATE); c1_acceptable = c1_acceptable && (c1_met <= ZIP_METHOD_DEFLATE); } if (store) { c0_acceptable = c0_acceptable && (c0_met == ZIP_METHOD_STORE); c1_acceptable = c1_acceptable && (c1_met == ZIP_METHOD_STORE); } if (!c1_acceptable) return false; if (!c0_acceptable) return true; if (c0_size > c1_size) return true; if (substitute_if_equal && c0_size == c1_size) return true; return false; } bool zip_entry::shrink(bool standard, shrink_t level) { assert(data); bool modify = false; // remove unneeded data if (info.local_extra_field_length != 0) modify = true; data_free(local_extra_field); local_extra_field = 0; info.local_extra_field_length = 0; if (info.central_extra_field_length != 0) modify = true; data_free(central_extra_field); central_extra_field = 0; info.central_extra_field_length = 0; if (info.file_comment_length != 0) modify = true; data_free(file_comment); file_comment = 0; info.file_comment_length = 0; unsigned char* uncompressed_data = data_alloc(uncompressed_size_get()); try { uncompressed_read(uncompressed_data); if (info.crc32 != crc32(0, uncompressed_data, uncompressed_size_get())) { throw error_invalid() << "Invalid crc on file " << name_get(); } } catch (...) { data_free(uncompressed_data); throw; } unsigned char* c0_data; unsigned c0_size; unsigned c0_ver; unsigned c0_met; unsigned c0_fla; // previous compressed data c0_data = data; c0_size = info.compressed_size; c0_ver = info.version_needed_to_extract; c0_met = info.compression_method; c0_fla = info.general_purpose_bit_flag; if (level.level != shrink_none) { // test compressed data unsigned char* c1_data; unsigned c1_size; unsigned c1_ver; unsigned c1_met; unsigned c1_fla; if (level.level != shrink_fast && !standard) { unsigned lzma_algo; unsigned lzma_dictsize; unsigned lzma_fastbytes; switch (level.level) { case shrink_normal : lzma_algo = 1; lzma_dictsize = 1 << 20; lzma_fastbytes = 32; break; case shrink_extra : lzma_algo = 2; lzma_dictsize = 1 << 22; lzma_fastbytes = 64; break; case shrink_insane : lzma_algo = 2; lzma_dictsize = 1 << 24; lzma_fastbytes = 64; break; default: assert(0); } // compress with lzma c1_data = data_alloc(uncompressed_size_get()); c1_size = uncompressed_size_get(); c1_ver = 20; c1_met = ZIP_METHOD_LZMA; c1_fla = 0; if (!compress_lzma_7z(uncompressed_data, uncompressed_size_get(), c1_data, c1_size, lzma_algo, lzma_dictsize, lzma_fastbytes)) { data_free(c1_data); c1_data = 0; } if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { data_free(c1_data); } } #if USE_BZIP2 if (level.level != shrink_fast && !standard) { unsigned bzip2_level; unsigned bzip2_workfactor; switch (level.level) { case shrink_normal : bzip2_level = 6; bzip2_workfactor = 30; break; case shrink_extra : bzip2_level = 9; bzip2_workfactor = 60; break; case shrink_insane : bzip2_level = 9; bzip2_workfactor = 120; break; default: assert(0); } // compress with bzip2 c1_data = data_alloc(uncompressed_size_get()); c1_size = uncompressed_size_get(); c1_ver = 20; c1_met = ZIP_METHOD_BZIP2; c1_fla = 0; if (!compress_bzip2(uncompressed_data, uncompressed_size_get(), c1_data, c1_size, bzip2_level, bzip2_workfactor)) { data_free(c1_data); c1_data = 0; } if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { data_free(c1_data); } } #endif // try only for small files or if standard compression is required // otherwise assume that lzma is better if (level.level == shrink_insane && (standard || uncompressed_size_get() <= RETRY_FOR_SMALL_FILES)) { ZopfliOptions opt_zopfli; size_t size; ZopfliInitOptions(&opt_zopfli); opt_zopfli.numiterations = level.iter > 5 ? level.iter : 5; c1_data = 0; c1_size = 0; c1_ver = 20; c1_met = ZIP_METHOD_DEFLATE; c1_fla = ZIP_GEN_FLAGS_DEFLATE_MAXIMUM; size = c1_size; ZopfliCompress(&opt_zopfli, ZOPFLI_FORMAT_DEFLATE, uncompressed_data, uncompressed_size_get(), &c1_data, &size); c1_size = size; if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, false, standard, false)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { if (c1_data) data_free(c1_data); } } // try only for small files or if standard compression is required // otherwise assume that lzma is better if (level.level == shrink_extra && (standard || uncompressed_size_get() <= RETRY_FOR_SMALL_FILES)) { unsigned sz_passes; unsigned sz_fastbytes; switch (level.level) { case shrink_extra : sz_passes = level.iter > 15 ? level.iter : 15; sz_fastbytes = 255; break; default: assert(0); } // compress with 7z c1_data = data_alloc(uncompressed_size_get()); c1_size = uncompressed_size_get(); c1_ver = 20; c1_met = ZIP_METHOD_DEFLATE; c1_fla = ZIP_GEN_FLAGS_DEFLATE_MAXIMUM; if (!compress_deflate_7z(uncompressed_data, uncompressed_size_get(), c1_data, c1_size, sz_passes, sz_fastbytes)) { data_free(c1_data); c1_data = 0; } if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { data_free(c1_data); } } // try only for small files or if standard compression is required // otherwise assume that lzma is better if (level.level != shrink_fast && (standard || uncompressed_size_get() <= RETRY_FOR_SMALL_FILES)) { int compression_level; switch (level.level) { case shrink_normal : compression_level = 12; break; case shrink_extra : // assume that 7z is better, but does a fast try to cover some corner cases compression_level = 12; break; case shrink_insane : // assume that zopfli is better, but does a fast try to cover some corner cases compression_level = 12; break; default: assert(0); } // compress with 7z c1_data = data_alloc(uncompressed_size_get()); c1_size = uncompressed_size_get(); c1_ver = 20; c1_met = ZIP_METHOD_DEFLATE; c1_fla = ZIP_GEN_FLAGS_DEFLATE_MAXIMUM; if (!compress_deflate_libdeflate(uncompressed_data, uncompressed_size_get(), c1_data, c1_size, compression_level)) { data_free(c1_data); c1_data = 0; } if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { data_free(c1_data); } } if (level.level == shrink_fast) { // compress with zlib Z_BEST_COMPRESSION/Z_DEFAULT_STRATEGY/MAX_MEM_LEVEL c1_data = data_alloc(uncompressed_size_get()); c1_size = uncompressed_size_get(); c1_ver = 20; c1_met = ZIP_METHOD_DEFLATE; c1_fla = ZIP_GEN_FLAGS_DEFLATE_MAXIMUM; if (!compress_deflate_zlib(uncompressed_data, uncompressed_size_get(), c1_data, c1_size, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY, MAX_MEM_LEVEL)) { data_free(c1_data); c1_data = 0; } if (got(c0_data, c0_size, c0_met, c1_data, c1_size, c1_met, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = c1_data; c0_size = c1_size; c0_ver = c1_ver; c0_met = c1_met; c0_fla = c1_fla; modify = true; } else { data_free(c1_data); } } } // store if (got(c0_data, c0_size, c0_met, uncompressed_data, uncompressed_size_get(), ZIP_METHOD_STORE, true, standard, level.level == shrink_none)) { data_free(c0_data); c0_data = uncompressed_data; c0_size = uncompressed_size_get(); c0_ver = 10; c0_met = ZIP_METHOD_STORE; c0_fla = 0; modify = true; } else { data_free(uncompressed_data); } // set the best option found data = c0_data; info.compressed_size = c0_size; info.version_needed_to_extract = c0_ver; info.compression_method = c0_met; // preserve original EFS flag info.general_purpose_bit_flag = c0_fla | (info.general_purpose_bit_flag & ZIP_GEN_FLAGS_EFS); return modify; } void zip::test() const { assert(flag.read); for(const_iterator i = begin();i!=end();++i) i->test(); } void zip::shrink(bool standard, shrink_t level) { assert(flag.read); // remove unneeded data if (info.zipfile_comment_length != 0) flag.modify = true; data_free(zipfile_comment); zipfile_comment = 0; info.zipfile_comment_length = 0; for(iterator i=begin();i!=end();++i) if (i->shrink(standard, level)) flag.modify = true; } advancecomp-1.23/zopfli/000077500000000000000000000000001301462770100152235ustar00rootroot00000000000000advancecomp-1.23/zopfli/CONTRIBUTORS000066400000000000000000000002111301462770100170750ustar00rootroot00000000000000Mark Adler Jyrki Alakuijala Frédéric Kayser Jeffrey Lim Daniel Reed Huzaifa Sidhpurwala Péter Szabó Lode Vandevenne Derek Buitenhuis advancecomp-1.23/zopfli/COPYING000066400000000000000000000261151301462770100162630ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2011 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. advancecomp-1.23/zopfli/README000066400000000000000000000035011301462770100161020ustar00rootroot00000000000000Zopfli Compression Algorithm is a compression library programmed in C to perform very good, but slow, deflate or zlib compression. The basic function to compress data is ZopfliCompress in zopfli.h. Use the ZopfliOptions object to set parameters that affect the speed and compression. Use the ZopfliInitOptions function to place the default values in the ZopfliOptions first. ZopfliCompress supports deflate, gzip and zlib output format with a parameter. To support only one individual format, you can instead use ZopfliDeflate in deflate.h, ZopfliZlibCompress in zlib_container.h or ZopfliGzipCompress in gzip_container.h. ZopfliDeflate creates a valid deflate stream in memory, see: http://www.ietf.org/rfc/rfc1951.txt ZopfliZlibCompress creates a valid zlib stream in memory, see: http://www.ietf.org/rfc/rfc1950.txt ZopfliGzipCompress creates a valid gzip stream in memory, see: http://www.ietf.org/rfc/rfc1952.txt This library can only compress, not decompress. Existing zlib or deflate libraries can decompress the data. zopfli_bin.c is separate from the library and contains an example program to create very well compressed gzip files. Currently the makefile builds this program with the library statically linked in. The source code of Zopfli is under src/zopfli. Build instructions: To build zopfli, compile all .c source files under src/zopfli to a single binary with C, and link to the standard C math library, e.g.: gcc src/zopfli/*.c -O2 -W -Wall -Wextra -Wno-unused-function -ansi -pedantic -lm -o zopfli A makefile is provided as well, but only for linux. Use "make" to build the binary, "make libzopfli" to build it as a shared library. For other platforms, please use the build instructions above instead. Zopfli Compression Algorithm was created by Lode Vandevenne and Jyrki Alakuijala, based on an algorithm by Jyrki Alakuijala. advancecomp-1.23/zopfli/blocksplitter.c000066400000000000000000000221051301462770100202500ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "blocksplitter.h" #include #include #include #include "deflate.h" #include "squeeze.h" #include "tree.h" #include "util.h" /* The "f" for the FindMinimum function below. i: the current parameter of f(i) context: for your implementation */ typedef double FindMinimumFun(size_t i, void* context); /* Finds minimum of function f(i) where is is of type size_t, f(i) is of type double, i is in range start-end (excluding end). Outputs the minimum value in *smallest and returns the index of this value. */ static size_t FindMinimum(FindMinimumFun f, void* context, size_t start, size_t end, double* smallest) { if (end - start < 1024) { double best = ZOPFLI_LARGE_FLOAT; size_t result = start; size_t i; for (i = start; i < end; i++) { double v = f(i, context); if (v < best) { best = v; result = i; } } *smallest = best; return result; } else { /* Try to find minimum faster by recursively checking multiple points. */ #define NUM 9 /* Good value: 9. */ size_t i; size_t p[NUM]; double vp[NUM]; size_t besti; double best; double lastbest = ZOPFLI_LARGE_FLOAT; size_t pos = start; for (;;) { if (end - start <= NUM) break; for (i = 0; i < NUM; i++) { p[i] = start + (i + 1) * ((end - start) / (NUM + 1)); vp[i] = f(p[i], context); } besti = 0; best = vp[0]; for (i = 1; i < NUM; i++) { if (vp[i] < best) { best = vp[i]; besti = i; } } if (best > lastbest) break; start = besti == 0 ? start : p[besti - 1]; end = besti == NUM - 1 ? end : p[besti + 1]; pos = p[besti]; lastbest = best; } *smallest = lastbest; return pos; #undef NUM } } /* Returns estimated cost of a block in bits. It includes the size to encode the tree and the size to encode all literal, length and distance symbols and their extra bits. litlens: lz77 lit/lengths dists: ll77 distances lstart: start of block lend: end of block (not inclusive) */ static double EstimateCost(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { return ZopfliCalculateBlockSizeAutoType(lz77, lstart, lend); } typedef struct SplitCostContext { const ZopfliLZ77Store* lz77; size_t start; size_t end; } SplitCostContext; /* Gets the cost which is the sum of the cost of the left and the right section of the data. type: FindMinimumFun */ static double SplitCost(size_t i, void* context) { SplitCostContext* c = (SplitCostContext*)context; return EstimateCost(c->lz77, c->start, i) + EstimateCost(c->lz77, i, c->end); } static void AddSorted(size_t value, size_t** out, size_t* outsize) { size_t i; ZOPFLI_APPEND_DATA(value, out, outsize); for (i = 0; i + 1 < *outsize; i++) { if ((*out)[i] > value) { size_t j; for (j = *outsize - 1; j > i; j--) { (*out)[j] = (*out)[j - 1]; } (*out)[i] = value; break; } } } /* Prints the block split points as decimal and hex values in the terminal. */ static void PrintBlockSplitPoints(const ZopfliLZ77Store* lz77, const size_t* lz77splitpoints, size_t nlz77points) { size_t* splitpoints = 0; size_t npoints = 0; size_t i; /* The input is given as lz77 indices, but we want to see the uncompressed index values. */ size_t pos = 0; if (nlz77points > 0) { for (i = 0; i < lz77->size; i++) { size_t length = lz77->dists[i] == 0 ? 1 : lz77->litlens[i]; if (lz77splitpoints[npoints] == i) { ZOPFLI_APPEND_DATA(pos, &splitpoints, &npoints); if (npoints == nlz77points) break; } pos += length; } } assert(npoints == nlz77points); fprintf(stderr, "block split points: "); for (i = 0; i < npoints; i++) { fprintf(stderr, "%d ", (int)splitpoints[i]); } fprintf(stderr, "(hex:"); for (i = 0; i < npoints; i++) { fprintf(stderr, " %x", (int)splitpoints[i]); } fprintf(stderr, ")\n"); free(splitpoints); } /* Finds next block to try to split, the largest of the available ones. The largest is chosen to make sure that if only a limited amount of blocks is requested, their sizes are spread evenly. lz77size: the size of the LL77 data, which is the size of the done array here. done: array indicating which blocks starting at that position are no longer splittable (splitting them increases rather than decreases cost). splitpoints: the splitpoints found so far. npoints: the amount of splitpoints found so far. lstart: output variable, giving start of block. lend: output variable, giving end of block. returns 1 if a block was found, 0 if no block found (all are done). */ static int FindLargestSplittableBlock( size_t lz77size, const unsigned char* done, const size_t* splitpoints, size_t npoints, size_t* lstart, size_t* lend) { size_t longest = 0; int found = 0; size_t i; for (i = 0; i <= npoints; i++) { size_t start = i == 0 ? 0 : splitpoints[i - 1]; size_t end = i == npoints ? lz77size - 1 : splitpoints[i]; if (!done[start] && end - start > longest) { *lstart = start; *lend = end; found = 1; longest = end - start; } } return found; } void ZopfliBlockSplitLZ77(const ZopfliOptions* options, const ZopfliLZ77Store* lz77, size_t maxblocks, size_t** splitpoints, size_t* npoints) { size_t lstart, lend; size_t i; size_t llpos = 0; size_t numblocks = 1; unsigned char* done; double splitcost, origcost; if (lz77->size < 10) return; /* This code fails on tiny files. */ done = (unsigned char*)malloc(lz77->size); if (!done) exit(-1); /* Allocation failed. */ for (i = 0; i < lz77->size; i++) done[i] = 0; lstart = 0; lend = lz77->size; for (;;) { SplitCostContext c; if (maxblocks > 0 && numblocks >= maxblocks) { break; } c.lz77 = lz77; c.start = lstart; c.end = lend; assert(lstart < lend); llpos = FindMinimum(SplitCost, &c, lstart + 1, lend, &splitcost); assert(llpos > lstart); assert(llpos < lend); origcost = EstimateCost(lz77, lstart, lend); if (splitcost > origcost || llpos == lstart + 1 || llpos == lend) { done[lstart] = 1; } else { AddSorted(llpos, splitpoints, npoints); numblocks++; } if (!FindLargestSplittableBlock( lz77->size, done, *splitpoints, *npoints, &lstart, &lend)) { break; /* No further split will probably reduce compression. */ } if (lend - lstart < 10) { break; } } if (options->verbose) { PrintBlockSplitPoints(lz77, *splitpoints, *npoints); } free(done); } void ZopfliBlockSplit(const ZopfliOptions* options, const unsigned char* in, size_t instart, size_t inend, size_t maxblocks, size_t** splitpoints, size_t* npoints) { size_t pos = 0; size_t i; ZopfliBlockState s; size_t* lz77splitpoints = 0; size_t nlz77points = 0; ZopfliLZ77Store store; ZopfliHash hash; ZopfliHash* h = &hash; ZopfliInitLZ77Store(in, &store); ZopfliInitBlockState(options, instart, inend, 0, &s); ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h); *npoints = 0; *splitpoints = 0; /* Unintuitively, Using a simple LZ77 method here instead of ZopfliLZ77Optimal results in better blocks. */ ZopfliLZ77Greedy(&s, in, instart, inend, &store, h); ZopfliBlockSplitLZ77(options, &store, maxblocks, &lz77splitpoints, &nlz77points); /* Convert LZ77 positions to positions in the uncompressed input. */ pos = instart; if (nlz77points > 0) { for (i = 0; i < store.size; i++) { size_t length = store.dists[i] == 0 ? 1 : store.litlens[i]; if (lz77splitpoints[*npoints] == i) { ZOPFLI_APPEND_DATA(pos, splitpoints, npoints); if (*npoints == nlz77points) break; } pos += length; } } assert(*npoints == nlz77points); free(lz77splitpoints); ZopfliCleanBlockState(&s); ZopfliCleanLZ77Store(&store); ZopfliCleanHash(h); } void ZopfliBlockSplitSimple(const unsigned char* in, size_t instart, size_t inend, size_t blocksize, size_t** splitpoints, size_t* npoints) { size_t i = instart; while (i < inend) { ZOPFLI_APPEND_DATA(i, splitpoints, npoints); i += blocksize; } (void)in; } advancecomp-1.23/zopfli/blocksplitter.h000066400000000000000000000051401301462770100202550ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Functions to choose good boundaries for block splitting. Deflate allows encoding the data in multiple blocks, with a separate Huffman tree for each block. The Huffman tree itself requires some bytes to encode, so by choosing certain blocks, you can either hurt, or enhance compression. These functions choose good ones that enhance it. */ #ifndef ZOPFLI_BLOCKSPLITTER_H_ #define ZOPFLI_BLOCKSPLITTER_H_ #include #include "lz77.h" #include "zopfli.h" /* Does blocksplitting on LZ77 data. The output splitpoints are indices in the LZ77 data. maxblocks: set a limit to the amount of blocks. Set to 0 to mean no limit. */ void ZopfliBlockSplitLZ77(const ZopfliOptions* options, const ZopfliLZ77Store* lz77, size_t maxblocks, size_t** splitpoints, size_t* npoints); /* Does blocksplitting on uncompressed data. The output splitpoints are indices in the uncompressed bytes. options: general program options. in: uncompressed input data instart: where to start splitting inend: where to end splitting (not inclusive) maxblocks: maximum amount of blocks to split into, or 0 for no limit splitpoints: dynamic array to put the resulting split point coordinates into. The coordinates are indices in the input array. npoints: pointer to amount of splitpoints, for the dynamic array. The amount of blocks is the amount of splitpoitns + 1. */ void ZopfliBlockSplit(const ZopfliOptions* options, const unsigned char* in, size_t instart, size_t inend, size_t maxblocks, size_t** splitpoints, size_t* npoints); /* Divides the input into equal blocks, does not even take LZ77 lengths into account. */ void ZopfliBlockSplitSimple(const unsigned char* in, size_t instart, size_t inend, size_t blocksize, size_t** splitpoints, size_t* npoints); #endif /* ZOPFLI_BLOCKSPLITTER_H_ */ advancecomp-1.23/zopfli/cache.c000066400000000000000000000075111301462770100164360ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "cache.h" #include #include #include #ifdef ZOPFLI_LONGEST_MATCH_CACHE void ZopfliInitCache(size_t blocksize, ZopfliLongestMatchCache* lmc) { size_t i; lmc->length = (unsigned short*)malloc(sizeof(unsigned short) * blocksize); lmc->dist = (unsigned short*)malloc(sizeof(unsigned short) * blocksize); /* Rather large amount of memory. */ lmc->sublen = (unsigned char*)malloc(ZOPFLI_CACHE_LENGTH * 3 * blocksize); if(lmc->sublen == NULL) { fprintf(stderr, "Error: Out of memory. Tried allocating %lu bytes of memory.\n", ZOPFLI_CACHE_LENGTH * 3 * blocksize); exit (EXIT_FAILURE); } /* length > 0 and dist 0 is invalid combination, which indicates on purpose that this cache value is not filled in yet. */ for (i = 0; i < blocksize; i++) lmc->length[i] = 1; for (i = 0; i < blocksize; i++) lmc->dist[i] = 0; for (i = 0; i < ZOPFLI_CACHE_LENGTH * blocksize * 3; i++) lmc->sublen[i] = 0; } void ZopfliCleanCache(ZopfliLongestMatchCache* lmc) { free(lmc->length); free(lmc->dist); free(lmc->sublen); } void ZopfliSublenToCache(const unsigned short* sublen, size_t pos, size_t length, ZopfliLongestMatchCache* lmc) { size_t i; size_t j = 0; unsigned bestlength = 0; unsigned char* cache; #if ZOPFLI_CACHE_LENGTH == 0 return; #endif cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3]; if (length < 3) return; for (i = 3; i <= length; i++) { if (i == length || sublen[i] != sublen[i + 1]) { cache[j * 3] = i - 3; cache[j * 3 + 1] = sublen[i] % 256; cache[j * 3 + 2] = (sublen[i] >> 8) % 256; bestlength = i; j++; if (j >= ZOPFLI_CACHE_LENGTH) break; } } if (j < ZOPFLI_CACHE_LENGTH) { assert(bestlength == length); cache[(ZOPFLI_CACHE_LENGTH - 1) * 3] = bestlength - 3; } else { assert(bestlength <= length); } assert(bestlength == ZopfliMaxCachedSublen(lmc, pos, length)); } void ZopfliCacheToSublen(const ZopfliLongestMatchCache* lmc, size_t pos, size_t length, unsigned short* sublen) { size_t i, j; unsigned maxlength = ZopfliMaxCachedSublen(lmc, pos, length); unsigned prevlength = 0; unsigned char* cache; #if ZOPFLI_CACHE_LENGTH == 0 return; #endif if (length < 3) return; cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3]; for (j = 0; j < ZOPFLI_CACHE_LENGTH; j++) { unsigned length = cache[j * 3] + 3; unsigned dist = cache[j * 3 + 1] + 256 * cache[j * 3 + 2]; for (i = prevlength; i <= length; i++) { sublen[i] = dist; } if (length == maxlength) break; prevlength = length + 1; } } /* Returns the length up to which could be stored in the cache. */ unsigned ZopfliMaxCachedSublen(const ZopfliLongestMatchCache* lmc, size_t pos, size_t length) { unsigned char* cache; #if ZOPFLI_CACHE_LENGTH == 0 return 0; #endif cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3]; (void)length; if (cache[1] == 0 && cache[2] == 0) return 0; /* No sublen cached. */ return cache[(ZOPFLI_CACHE_LENGTH - 1) * 3] + 3; } #endif /* ZOPFLI_LONGEST_MATCH_CACHE */ advancecomp-1.23/zopfli/cache.h000066400000000000000000000043201301462770100164360ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* The cache that speeds up ZopfliFindLongestMatch of lz77.c. */ #ifndef ZOPFLI_CACHE_H_ #define ZOPFLI_CACHE_H_ #include "util.h" #ifdef ZOPFLI_LONGEST_MATCH_CACHE /* Cache used by ZopfliFindLongestMatch to remember previously found length/dist values. This is needed because the squeeze runs will ask these values multiple times for the same position. Uses large amounts of memory, since it has to remember the distance belonging to every possible shorter-than-the-best length (the so called "sublen" array). */ typedef struct ZopfliLongestMatchCache { unsigned short* length; unsigned short* dist; unsigned char* sublen; } ZopfliLongestMatchCache; /* Initializes the ZopfliLongestMatchCache. */ void ZopfliInitCache(size_t blocksize, ZopfliLongestMatchCache* lmc); /* Frees up the memory of the ZopfliLongestMatchCache. */ void ZopfliCleanCache(ZopfliLongestMatchCache* lmc); /* Stores sublen array in the cache. */ void ZopfliSublenToCache(const unsigned short* sublen, size_t pos, size_t length, ZopfliLongestMatchCache* lmc); /* Extracts sublen array from the cache. */ void ZopfliCacheToSublen(const ZopfliLongestMatchCache* lmc, size_t pos, size_t length, unsigned short* sublen); /* Returns the length up to which could be stored in the cache. */ unsigned ZopfliMaxCachedSublen(const ZopfliLongestMatchCache* lmc, size_t pos, size_t length); #endif /* ZOPFLI_LONGEST_MATCH_CACHE */ #endif /* ZOPFLI_CACHE_H_ */ advancecomp-1.23/zopfli/deflate.c000066400000000000000000001002541301462770100167750ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "deflate.h" #include #include #include #include "blocksplitter.h" #include "squeeze.h" #include "symbols.h" #include "tree.h" /* bp = bitpointer, always in range [0, 7]. The outsize is number of necessary bytes to encode the bits. Given the value of bp and the amount of bytes, the amount of bits represented is not simply bytesize * 8 + bp because even representing one bit requires a whole byte. It is: (bp == 0) ? (bytesize * 8) : ((bytesize - 1) * 8 + bp) */ static void AddBit(int bit, unsigned char* bp, unsigned char** out, size_t* outsize) { if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize); (*out)[*outsize - 1] |= bit << *bp; *bp = (*bp + 1) & 7; } static void AddBits(unsigned symbol, unsigned length, unsigned char* bp, unsigned char** out, size_t* outsize) { /* TODO(lode): make more efficient (add more bits at once). */ unsigned i; for (i = 0; i < length; i++) { unsigned bit = (symbol >> i) & 1; if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize); (*out)[*outsize - 1] |= bit << *bp; *bp = (*bp + 1) & 7; } } /* Adds bits, like AddBits, but the order is inverted. The deflate specification uses both orders in one standard. */ static void AddHuffmanBits(unsigned symbol, unsigned length, unsigned char* bp, unsigned char** out, size_t* outsize) { /* TODO(lode): make more efficient (add more bits at once). */ unsigned i; for (i = 0; i < length; i++) { unsigned bit = (symbol >> (length - i - 1)) & 1; if (*bp == 0) ZOPFLI_APPEND_DATA(0, out, outsize); (*out)[*outsize - 1] |= bit << *bp; *bp = (*bp + 1) & 7; } } /* Ensures there are at least 2 distance codes to support buggy decoders. Zlib 1.2.1 and below have a bug where it fails if there isn't at least 1 distance code (with length > 0), even though it's valid according to the deflate spec to have 0 distance codes. On top of that, some mobile phones require at least two distance codes. To support these decoders too (but potentially at the cost of a few bytes), add dummy code lengths of 1. References to this bug can be found in the changelog of Zlib 1.2.2 and here: http://www.jonof.id.au/forum/index.php?topic=515.0. d_lengths: the 32 lengths of the distance codes. */ static void PatchDistanceCodesForBuggyDecoders(unsigned* d_lengths) { int num_dist_codes = 0; /* Amount of non-zero distance codes */ int i; for (i = 0; i < 30 /* Ignore the two unused codes from the spec */; i++) { if (d_lengths[i]) num_dist_codes++; if (num_dist_codes >= 2) return; /* Two or more codes is fine. */ } if (num_dist_codes == 0) { d_lengths[0] = d_lengths[1] = 1; } else if (num_dist_codes == 1) { d_lengths[d_lengths[0] ? 1 : 0] = 1; } } /* Encodes the Huffman tree and returns how many bits its encoding takes. If out is a null pointer, only returns the size and runs faster. */ static size_t EncodeTree(const unsigned* ll_lengths, const unsigned* d_lengths, int use_16, int use_17, int use_18, unsigned char* bp, unsigned char** out, size_t* outsize) { unsigned lld_total; /* Total amount of literal, length, distance codes. */ /* Runlength encoded version of lengths of litlen and dist trees. */ unsigned* rle = 0; unsigned* rle_bits = 0; /* Extra bits for rle values 16, 17 and 18. */ size_t rle_size = 0; /* Size of rle array. */ size_t rle_bits_size = 0; /* Should have same value as rle_size. */ unsigned hlit = 29; /* 286 - 257 */ unsigned hdist = 29; /* 32 - 1, but gzip does not like hdist > 29.*/ unsigned hclen; unsigned hlit2; size_t i, j; size_t clcounts[19]; unsigned clcl[19]; /* Code length code lengths. */ unsigned clsymbols[19]; /* The order in which code length code lengths are encoded as per deflate. */ static const unsigned order[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; int size_only = !out; size_t result_size = 0; for(i = 0; i < 19; i++) clcounts[i] = 0; /* Trim zeros. */ while (hlit > 0 && ll_lengths[257 + hlit - 1] == 0) hlit--; while (hdist > 0 && d_lengths[1 + hdist - 1] == 0) hdist--; hlit2 = hlit + 257; lld_total = hlit2 + hdist + 1; for (i = 0; i < lld_total; i++) { /* This is an encoding of a huffman tree, so now the length is a symbol */ unsigned char symbol = i < hlit2 ? ll_lengths[i] : d_lengths[i - hlit2]; unsigned count = 1; if(use_16 || (symbol == 0 && (use_17 || use_18))) { for (j = i + 1; j < lld_total && symbol == (j < hlit2 ? ll_lengths[j] : d_lengths[j - hlit2]); j++) { count++; } } i += count - 1; /* Repetitions of zeroes */ if (symbol == 0 && count >= 3) { if (use_18) { while (count >= 11) { unsigned count2 = count > 138 ? 138 : count; if (!size_only) { ZOPFLI_APPEND_DATA(18, &rle, &rle_size); ZOPFLI_APPEND_DATA(count2 - 11, &rle_bits, &rle_bits_size); } clcounts[18]++; count -= count2; } } if (use_17) { while (count >= 3) { unsigned count2 = count > 10 ? 10 : count; if (!size_only) { ZOPFLI_APPEND_DATA(17, &rle, &rle_size); ZOPFLI_APPEND_DATA(count2 - 3, &rle_bits, &rle_bits_size); } clcounts[17]++; count -= count2; } } } /* Repetitions of any symbol */ if (use_16 && count >= 4) { count--; /* Since the first one is hardcoded. */ clcounts[symbol]++; if (!size_only) { ZOPFLI_APPEND_DATA(symbol, &rle, &rle_size); ZOPFLI_APPEND_DATA(0, &rle_bits, &rle_bits_size); } while (count >= 3) { unsigned count2 = count > 6 ? 6 : count; if (!size_only) { ZOPFLI_APPEND_DATA(16, &rle, &rle_size); ZOPFLI_APPEND_DATA(count2 - 3, &rle_bits, &rle_bits_size); } clcounts[16]++; count -= count2; } } /* No or insufficient repetition */ clcounts[symbol] += count; while (count > 0) { if (!size_only) { ZOPFLI_APPEND_DATA(symbol, &rle, &rle_size); ZOPFLI_APPEND_DATA(0, &rle_bits, &rle_bits_size); } count--; } } ZopfliCalculateBitLengths(clcounts, 19, 7, clcl); if (!size_only) ZopfliLengthsToSymbols(clcl, 19, 7, clsymbols); hclen = 15; /* Trim zeros. */ while (hclen > 0 && clcounts[order[hclen + 4 - 1]] == 0) hclen--; if (!size_only) { AddBits(hlit, 5, bp, out, outsize); AddBits(hdist, 5, bp, out, outsize); AddBits(hclen, 4, bp, out, outsize); for (i = 0; i < hclen + 4; i++) { AddBits(clcl[order[i]], 3, bp, out, outsize); } for (i = 0; i < rle_size; i++) { unsigned symbol = clsymbols[rle[i]]; AddHuffmanBits(symbol, clcl[rle[i]], bp, out, outsize); /* Extra bits. */ if (rle[i] == 16) AddBits(rle_bits[i], 2, bp, out, outsize); else if (rle[i] == 17) AddBits(rle_bits[i], 3, bp, out, outsize); else if (rle[i] == 18) AddBits(rle_bits[i], 7, bp, out, outsize); } } result_size += 14; /* hlit, hdist, hclen bits */ result_size += (hclen + 4) * 3; /* clcl bits */ for(i = 0; i < 19; i++) { result_size += clcl[i] * clcounts[i]; } /* Extra bits. */ result_size += clcounts[16] * 2; result_size += clcounts[17] * 3; result_size += clcounts[18] * 7; /* Note: in case of "size_only" these are null pointers so no effect. */ free(rle); free(rle_bits); return result_size; } static void AddDynamicTree(const unsigned* ll_lengths, const unsigned* d_lengths, unsigned char* bp, unsigned char** out, size_t* outsize) { int i; int best = 0; size_t bestsize = 0; for(i = 0; i < 8; i++) { size_t size = EncodeTree(ll_lengths, d_lengths, i & 1, i & 2, i & 4, 0, 0, 0); if (bestsize == 0 || size < bestsize) { bestsize = size; best = i; } } EncodeTree(ll_lengths, d_lengths, best & 1, best & 2, best & 4, bp, out, outsize); } /* Gives the exact size of the tree, in bits, as it will be encoded in DEFLATE. */ static size_t CalculateTreeSize(const unsigned* ll_lengths, const unsigned* d_lengths) { size_t result = 0; int i; for(i = 0; i < 8; i++) { size_t size = EncodeTree(ll_lengths, d_lengths, i & 1, i & 2, i & 4, 0, 0, 0); if (result == 0 || size < result) result = size; } return result; } /* Adds all lit/len and dist codes from the lists as huffman symbols. Does not add end code 256. expected_data_size is the uncompressed block size, used for assert, but you can set it to 0 to not do the assertion. */ static void AddLZ77Data(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, size_t expected_data_size, const unsigned* ll_symbols, const unsigned* ll_lengths, const unsigned* d_symbols, const unsigned* d_lengths, unsigned char* bp, unsigned char** out, size_t* outsize) { size_t testlength = 0; size_t i; for (i = lstart; i < lend; i++) { unsigned dist = lz77->dists[i]; unsigned litlen = lz77->litlens[i]; if (dist == 0) { assert(litlen < 256); assert(ll_lengths[litlen] > 0); AddHuffmanBits(ll_symbols[litlen], ll_lengths[litlen], bp, out, outsize); testlength++; } else { unsigned lls = ZopfliGetLengthSymbol(litlen); unsigned ds = ZopfliGetDistSymbol(dist); assert(litlen >= 3 && litlen <= 288); assert(ll_lengths[lls] > 0); assert(d_lengths[ds] > 0); AddHuffmanBits(ll_symbols[lls], ll_lengths[lls], bp, out, outsize); AddBits(ZopfliGetLengthExtraBitsValue(litlen), ZopfliGetLengthExtraBits(litlen), bp, out, outsize); AddHuffmanBits(d_symbols[ds], d_lengths[ds], bp, out, outsize); AddBits(ZopfliGetDistExtraBitsValue(dist), ZopfliGetDistExtraBits(dist), bp, out, outsize); testlength += litlen; } } assert(expected_data_size == 0 || testlength == expected_data_size); } static void GetFixedTree(unsigned* ll_lengths, unsigned* d_lengths) { size_t i; for (i = 0; i < 144; i++) ll_lengths[i] = 8; for (i = 144; i < 256; i++) ll_lengths[i] = 9; for (i = 256; i < 280; i++) ll_lengths[i] = 7; for (i = 280; i < 288; i++) ll_lengths[i] = 8; for (i = 0; i < 32; i++) d_lengths[i] = 5; } /* Same as CalculateBlockSymbolSize, but for block size smaller than histogram size. */ static size_t CalculateBlockSymbolSizeSmall(const unsigned* ll_lengths, const unsigned* d_lengths, const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { size_t result = 0; size_t i; for (i = lstart; i < lend; i++) { assert(i < lz77->size); assert(lz77->litlens[i] < 259); if (lz77->dists[i] == 0) { result += ll_lengths[lz77->litlens[i]]; } else { int ll_symbol = ZopfliGetLengthSymbol(lz77->litlens[i]); int d_symbol = ZopfliGetDistSymbol(lz77->dists[i]); result += ll_lengths[ll_symbol]; result += d_lengths[d_symbol]; result += ZopfliGetLengthSymbolExtraBits(ll_symbol); result += ZopfliGetDistSymbolExtraBits(d_symbol); } } result += ll_lengths[256]; /*end symbol*/ return result; } /* Same as CalculateBlockSymbolSize, but with the histogram provided by the caller. */ static size_t CalculateBlockSymbolSizeGivenCounts(const size_t* ll_counts, const size_t* d_counts, const unsigned* ll_lengths, const unsigned* d_lengths, const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { size_t result = 0; size_t i; if (lstart + ZOPFLI_NUM_LL * 3 > lend) { return CalculateBlockSymbolSizeSmall( ll_lengths, d_lengths, lz77, lstart, lend); } else { for (i = 0; i < 256; i++) { result += ll_lengths[i] * ll_counts[i]; } for (i = 257; i < 286; i++) { result += ll_lengths[i] * ll_counts[i]; result += ZopfliGetLengthSymbolExtraBits(i) * ll_counts[i]; } for (i = 0; i < 30; i++) { result += d_lengths[i] * d_counts[i]; result += ZopfliGetDistSymbolExtraBits(i) * d_counts[i]; } result += ll_lengths[256]; /*end symbol*/ return result; } } /* Calculates size of the part after the header and tree of an LZ77 block, in bits. */ static size_t CalculateBlockSymbolSize(const unsigned* ll_lengths, const unsigned* d_lengths, const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { if (lstart + ZOPFLI_NUM_LL * 3 > lend) { return CalculateBlockSymbolSizeSmall( ll_lengths, d_lengths, lz77, lstart, lend); } else { size_t ll_counts[ZOPFLI_NUM_LL]; size_t d_counts[ZOPFLI_NUM_D]; ZopfliLZ77GetHistogram(lz77, lstart, lend, ll_counts, d_counts); return CalculateBlockSymbolSizeGivenCounts( ll_counts, d_counts, ll_lengths, d_lengths, lz77, lstart, lend); } } static size_t AbsDiff(size_t x, size_t y) { if (x > y) return x - y; else return y - x; } /* Changes the population counts in a way that the consequent Huffman tree compression, especially its rle-part, will be more likely to compress this data more efficiently. length contains the size of the histogram. */ void OptimizeHuffmanForRle(int length, size_t* counts) { int i, k, stride; size_t symbol, sum, limit; int* good_for_rle; /* 1) We don't want to touch the trailing zeros. We may break the rules of the format by adding more data in the distance codes. */ for (; length >= 0; --length) { if (length == 0) { return; } if (counts[length - 1] != 0) { /* Now counts[0..length - 1] does not have trailing zeros. */ break; } } /* 2) Let's mark all population counts that already can be encoded with an rle code.*/ good_for_rle = (int*)malloc(length * sizeof(int)); for (i = 0; i < length; ++i) good_for_rle[i] = 0; /* Let's not spoil any of the existing good rle codes. Mark any seq of 0's that is longer than 5 as a good_for_rle. Mark any seq of non-0's that is longer than 7 as a good_for_rle.*/ symbol = counts[0]; stride = 0; for (i = 0; i < length + 1; ++i) { if (i == length || counts[i] != symbol) { if ((symbol == 0 && stride >= 5) || (symbol != 0 && stride >= 7)) { for (k = 0; k < stride; ++k) { good_for_rle[i - k - 1] = 1; } } stride = 1; if (i != length) { symbol = counts[i]; } } else { ++stride; } } /* 3) Let's replace those population counts that lead to more rle codes. */ stride = 0; limit = counts[0]; sum = 0; for (i = 0; i < length + 1; ++i) { if (i == length || good_for_rle[i] /* Heuristic for selecting the stride ranges to collapse. */ || AbsDiff(counts[i], limit) >= 4) { if (stride >= 4 || (stride >= 3 && sum == 0)) { /* The stride must end, collapse what we have, if we have enough (4). */ int count = (sum + stride / 2) / stride; if (count < 1) count = 1; if (sum == 0) { /* Don't make an all zeros stride to be upgraded to ones. */ count = 0; } for (k = 0; k < stride; ++k) { /* We don't want to change value at counts[i], that is already belonging to the next stride. Thus - 1. */ counts[i - k - 1] = count; } } stride = 0; sum = 0; if (i < length - 3) { /* All interesting strides have a count of at least 4, at least when non-zeros. */ limit = (counts[i] + counts[i + 1] + counts[i + 2] + counts[i + 3] + 2) / 4; } else if (i < length) { limit = counts[i]; } else { limit = 0; } } ++stride; if (i != length) { sum += counts[i]; } } free(good_for_rle); } /* Tries out OptimizeHuffmanForRle for this block, if the result is smaller, uses it, otherwise keeps the original. Returns size of encoded tree and data in bits, not including the 3-bit block header. */ static double TryOptimizeHuffmanForRle( const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, const size_t* ll_counts, const size_t* d_counts, unsigned* ll_lengths, unsigned* d_lengths) { size_t ll_counts2[ZOPFLI_NUM_LL]; size_t d_counts2[ZOPFLI_NUM_D]; unsigned ll_lengths2[ZOPFLI_NUM_LL]; unsigned d_lengths2[ZOPFLI_NUM_D]; double treesize; double datasize; double treesize2; double datasize2; treesize = CalculateTreeSize(ll_lengths, d_lengths); datasize = CalculateBlockSymbolSizeGivenCounts(ll_counts, d_counts, ll_lengths, d_lengths, lz77, lstart, lend); memcpy(ll_counts2, ll_counts, sizeof(ll_counts2)); memcpy(d_counts2, d_counts, sizeof(d_counts2)); OptimizeHuffmanForRle(ZOPFLI_NUM_LL, ll_counts2); OptimizeHuffmanForRle(ZOPFLI_NUM_D, d_counts2); ZopfliCalculateBitLengths(ll_counts2, ZOPFLI_NUM_LL, 15, ll_lengths2); ZopfliCalculateBitLengths(d_counts2, ZOPFLI_NUM_D, 15, d_lengths2); PatchDistanceCodesForBuggyDecoders(d_lengths2); treesize2 = CalculateTreeSize(ll_lengths2, d_lengths2); datasize2 = CalculateBlockSymbolSizeGivenCounts(ll_counts, d_counts, ll_lengths2, d_lengths2, lz77, lstart, lend); if (treesize2 + datasize2 < treesize + datasize) { memcpy(ll_lengths, ll_lengths2, sizeof(ll_lengths2)); memcpy(d_lengths, d_lengths2, sizeof(d_lengths2)); return treesize2 + datasize2; } return treesize + datasize; } /* Calculates the bit lengths for the symbols for dynamic blocks. Chooses bit lengths that give the smallest size of tree encoding + encoding of all the symbols to have smallest output size. This are not necessarily the ideal Huffman bit lengths. Returns size of encoded tree and data in bits, not including the 3-bit block header. */ static double GetDynamicLengths(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, unsigned* ll_lengths, unsigned* d_lengths) { size_t ll_counts[ZOPFLI_NUM_LL]; size_t d_counts[ZOPFLI_NUM_D]; ZopfliLZ77GetHistogram(lz77, lstart, lend, ll_counts, d_counts); ll_counts[256] = 1; /* End symbol. */ ZopfliCalculateBitLengths(ll_counts, ZOPFLI_NUM_LL, 15, ll_lengths); ZopfliCalculateBitLengths(d_counts, ZOPFLI_NUM_D, 15, d_lengths); PatchDistanceCodesForBuggyDecoders(d_lengths); return TryOptimizeHuffmanForRle( lz77, lstart, lend, ll_counts, d_counts, ll_lengths, d_lengths); } double ZopfliCalculateBlockSize(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, int btype) { unsigned ll_lengths[ZOPFLI_NUM_LL]; unsigned d_lengths[ZOPFLI_NUM_D]; double result = 3; /* bfinal and btype bits */ if (btype == 0) { size_t length = ZopfliLZ77GetByteRange(lz77, lstart, lend); size_t rem = length % 65535; size_t blocks = length / 65535 + (rem ? 1 : 0); /* An uncompressed block must actually be split into multiple blocks if it's larger than 65535 bytes long. Eeach block header is 5 bytes: 3 bits, padding, LEN and NLEN (potential less padding for first one ignored). */ return blocks * 5 * 8 + length * 8; } if (btype == 1) { GetFixedTree(ll_lengths, d_lengths); result += CalculateBlockSymbolSize( ll_lengths, d_lengths, lz77, lstart, lend); } else { result += GetDynamicLengths(lz77, lstart, lend, ll_lengths, d_lengths); } return result; } double ZopfliCalculateBlockSizeAutoType(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { double uncompressedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 0); /* Don't do the expensive fixed cost calculation for larger blocks that are unlikely to use it. */ double fixedcost = (lz77->size > 1000) ? uncompressedcost : ZopfliCalculateBlockSize(lz77, lstart, lend, 1); double dyncost = ZopfliCalculateBlockSize(lz77, lstart, lend, 2); return (uncompressedcost < fixedcost && uncompressedcost < dyncost) ? uncompressedcost : (fixedcost < dyncost ? fixedcost : dyncost); } /* Since an uncompressed block can be max 65535 in size, it actually adds multible blocks if needed. */ static void AddNonCompressedBlock(const ZopfliOptions* options, int final, const unsigned char* in, size_t instart, size_t inend, unsigned char* bp, unsigned char** out, size_t* outsize) { size_t pos = instart; (void)options; for (;;) { size_t i; unsigned short blocksize = 65535; unsigned short nlen; int currentfinal; if (pos + blocksize > inend) blocksize = inend - pos; currentfinal = pos + blocksize >= inend; nlen = ~blocksize; AddBit(final && currentfinal, bp, out, outsize); /* BTYPE 00 */ AddBit(0, bp, out, outsize); AddBit(0, bp, out, outsize); /* Any bits of input up to the next byte boundary are ignored. */ *bp = 0; ZOPFLI_APPEND_DATA(blocksize % 256, out, outsize); ZOPFLI_APPEND_DATA((blocksize / 256) % 256, out, outsize); ZOPFLI_APPEND_DATA(nlen % 256, out, outsize); ZOPFLI_APPEND_DATA((nlen / 256) % 256, out, outsize); for (i = 0; i < blocksize; i++) { ZOPFLI_APPEND_DATA(in[pos + i], out, outsize); } if (currentfinal) break; pos += blocksize; } } /* Adds a deflate block with the given LZ77 data to the output. options: global program options btype: the block type, must be 1 or 2 final: whether to set the "final" bit on this block, must be the last block litlens: literal/length array of the LZ77 data, in the same format as in ZopfliLZ77Store. dists: distance array of the LZ77 data, in the same format as in ZopfliLZ77Store. lstart: where to start in the LZ77 data lend: where to end in the LZ77 data (not inclusive) expected_data_size: the uncompressed block size, used for assert, but you can set it to 0 to not do the assertion. bp: output bit pointer out: dynamic output array to append to outsize: dynamic output array size */ static void AddLZ77Block(const ZopfliOptions* options, int btype, int final, const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, size_t expected_data_size, unsigned char* bp, unsigned char** out, size_t* outsize) { unsigned ll_lengths[ZOPFLI_NUM_LL]; unsigned d_lengths[ZOPFLI_NUM_D]; unsigned ll_symbols[ZOPFLI_NUM_LL]; unsigned d_symbols[ZOPFLI_NUM_D]; size_t detect_block_size = *outsize; size_t compressed_size; size_t uncompressed_size = 0; size_t i; if (btype == 0) { size_t length = ZopfliLZ77GetByteRange(lz77, lstart, lend); size_t pos = lstart == lend ? 0 : lz77->pos[lstart]; size_t end = pos + length; AddNonCompressedBlock(options, final, lz77->data, pos, end, bp, out, outsize); return; } AddBit(final, bp, out, outsize); AddBit(btype & 1, bp, out, outsize); AddBit((btype & 2) >> 1, bp, out, outsize); if (btype == 1) { /* Fixed block. */ GetFixedTree(ll_lengths, d_lengths); } else { /* Dynamic block. */ unsigned detect_tree_size; assert(btype == 2); GetDynamicLengths(lz77, lstart, lend, ll_lengths, d_lengths); detect_tree_size = *outsize; AddDynamicTree(ll_lengths, d_lengths, bp, out, outsize); if (options->verbose) { fprintf(stderr, "treesize: %d\n", (int)(*outsize - detect_tree_size)); } } ZopfliLengthsToSymbols(ll_lengths, ZOPFLI_NUM_LL, 15, ll_symbols); ZopfliLengthsToSymbols(d_lengths, ZOPFLI_NUM_D, 15, d_symbols); detect_block_size = *outsize; AddLZ77Data(lz77, lstart, lend, expected_data_size, ll_symbols, ll_lengths, d_symbols, d_lengths, bp, out, outsize); /* End symbol. */ AddHuffmanBits(ll_symbols[256], ll_lengths[256], bp, out, outsize); for (i = lstart; i < lend; i++) { uncompressed_size += lz77->dists[i] == 0 ? 1 : lz77->litlens[i]; } compressed_size = *outsize - detect_block_size; if (options->verbose) { fprintf(stderr, "compressed block size: %d (%dk) (unc: %d)\n", (int)compressed_size, (int)(compressed_size / 1024), (int)(uncompressed_size)); } } static void AddLZ77BlockAutoType(const ZopfliOptions* options, int final, const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, size_t expected_data_size, unsigned char* bp, unsigned char** out, size_t* outsize) { double uncompressedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 0); double fixedcost = ZopfliCalculateBlockSize(lz77, lstart, lend, 1); double dyncost = ZopfliCalculateBlockSize(lz77, lstart, lend, 2); /* Whether to perform the expensive calculation of creating an optimal block with fixed huffman tree to check if smaller. Only do this for small blocks or blocks which already are pretty good with fixed huffman tree. */ int expensivefixed = (lz77->size < 1000) || fixedcost <= dyncost * 1.1; ZopfliLZ77Store fixedstore; if (lstart == lend) { /* Smallest empty block is represented by fixed block */ AddBits(final, 1, bp, out, outsize); AddBits(1, 2, bp, out, outsize); /* btype 01 */ AddBits(0, 7, bp, out, outsize); /* end symbol has code 0000000 */ return; } ZopfliInitLZ77Store(lz77->data, &fixedstore); if (expensivefixed) { /* Recalculate the LZ77 with ZopfliLZ77OptimalFixed */ size_t instart = lz77->pos[lstart]; size_t inend = instart + ZopfliLZ77GetByteRange(lz77, lstart, lend); ZopfliBlockState s; ZopfliInitBlockState(options, instart, inend, 1, &s); ZopfliLZ77OptimalFixed(&s, lz77->data, instart, inend, &fixedstore); fixedcost = ZopfliCalculateBlockSize(&fixedstore, 0, fixedstore.size, 1); ZopfliCleanBlockState(&s); } if (uncompressedcost < fixedcost && uncompressedcost < dyncost) { AddLZ77Block(options, 0, final, lz77, lstart, lend, expected_data_size, bp, out, outsize); } else if (fixedcost < dyncost) { if (expensivefixed) { AddLZ77Block(options, 1, final, &fixedstore, 0, fixedstore.size, expected_data_size, bp, out, outsize); } else { AddLZ77Block(options, 1, final, lz77, lstart, lend, expected_data_size, bp, out, outsize); } } else { AddLZ77Block(options, 2, final, lz77, lstart, lend, expected_data_size, bp, out, outsize); } ZopfliCleanLZ77Store(&fixedstore); } /* Deflate a part, to allow ZopfliDeflate() to use multiple master blocks if needed. It is possible to call this function multiple times in a row, shifting instart and inend to next bytes of the data. If instart is larger than 0, then previous bytes are used as the initial dictionary for LZ77. This function will usually output multiple deflate blocks. If final is 1, then the final bit will be set on the last block. */ void ZopfliDeflatePart(const ZopfliOptions* options, int btype, int final, const unsigned char* in, size_t instart, size_t inend, unsigned char* bp, unsigned char** out, size_t* outsize) { size_t i; /* byte coordinates rather than lz77 index */ size_t* splitpoints_uncompressed = 0; size_t npoints = 0; size_t* splitpoints = 0; double totalcost = 0; ZopfliLZ77Store lz77; /* If btype=2 is specified, it tries all block types. If a lesser btype is given, then however it forces that one. Neither of the lesser types needs block splitting as they have no dynamic huffman trees. */ if (btype == 0) { AddNonCompressedBlock(options, final, in, instart, inend, bp, out, outsize); return; } else if (btype == 1) { ZopfliLZ77Store store; ZopfliBlockState s; ZopfliInitLZ77Store(in, &store); ZopfliInitBlockState(options, instart, inend, 1, &s); ZopfliLZ77OptimalFixed(&s, in, instart, inend, &store); AddLZ77Block(options, btype, final, &store, 0, store.size, 0, bp, out, outsize); ZopfliCleanBlockState(&s); ZopfliCleanLZ77Store(&store); return; } if (options->blocksplitting) { ZopfliBlockSplit(options, in, instart, inend, options->blocksplittingmax, &splitpoints_uncompressed, &npoints); splitpoints = (size_t*)malloc(sizeof(*splitpoints) * npoints); } ZopfliInitLZ77Store(in, &lz77); for (i = 0; i <= npoints; i++) { size_t start = i == 0 ? instart : splitpoints_uncompressed[i - 1]; size_t end = i == npoints ? inend : splitpoints_uncompressed[i]; ZopfliBlockState s; ZopfliLZ77Store store; ZopfliInitLZ77Store(in, &store); ZopfliInitBlockState(options, start, end, 1, &s); ZopfliLZ77Optimal(&s, in, start, end, options->numiterations, &store); totalcost += ZopfliCalculateBlockSizeAutoType(&store, 0, store.size); ZopfliAppendLZ77Store(&store, &lz77); if (i < npoints) splitpoints[i] = lz77.size; ZopfliCleanBlockState(&s); ZopfliCleanLZ77Store(&store); } /* Second block splitting attempt */ if (options->blocksplitting && npoints > 1) { size_t* splitpoints2 = 0; size_t npoints2 = 0; double totalcost2 = 0; ZopfliBlockSplitLZ77(options, &lz77, options->blocksplittingmax, &splitpoints2, &npoints2); for (i = 0; i <= npoints2; i++) { size_t start = i == 0 ? 0 : splitpoints2[i - 1]; size_t end = i == npoints2 ? lz77.size : splitpoints2[i]; totalcost2 += ZopfliCalculateBlockSizeAutoType(&lz77, start, end); } if (totalcost2 < totalcost) { free(splitpoints); splitpoints = splitpoints2; npoints = npoints2; } else { free(splitpoints2); } } for (i = 0; i <= npoints; i++) { size_t start = i == 0 ? 0 : splitpoints[i - 1]; size_t end = i == npoints ? lz77.size : splitpoints[i]; AddLZ77BlockAutoType(options, i == npoints && final, &lz77, start, end, 0, bp, out, outsize); } ZopfliCleanLZ77Store(&lz77); free(splitpoints); free(splitpoints_uncompressed); } void ZopfliDeflate(const ZopfliOptions* options, int btype, int final, const unsigned char* in, size_t insize, unsigned char* bp, unsigned char** out, size_t* outsize) { size_t offset = *outsize; #if ZOPFLI_MASTER_BLOCK_SIZE == 0 ZopfliDeflatePart(options, btype, final, in, 0, insize, bp, out, outsize); #else size_t i = 0; do { int masterfinal = (i + ZOPFLI_MASTER_BLOCK_SIZE >= insize); int final2 = final && masterfinal; size_t size = masterfinal ? insize - i : ZOPFLI_MASTER_BLOCK_SIZE; ZopfliDeflatePart(options, btype, final2, in, i, i + size, bp, out, outsize); i += size; } while (i < insize); #endif if (options->verbose) { fprintf(stderr, "Original Size: %lu, Deflate: %lu, Compression: %f%% Removed\n", (unsigned long)insize, (unsigned long)(*outsize - offset), 100.0 * (double)(insize - (*outsize - offset)) / (double)insize); } } advancecomp-1.23/zopfli/deflate.h000066400000000000000000000060331301462770100170020ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #ifndef ZOPFLI_DEFLATE_H_ #define ZOPFLI_DEFLATE_H_ /* Functions to compress according to the DEFLATE specification, using the "squeeze" LZ77 compression backend. */ #include "lz77.h" #include "zopfli.h" #ifdef __cplusplus extern "C" { #endif /* Compresses according to the deflate specification and append the compressed result to the output. This function will usually output multiple deflate blocks. If final is 1, then the final bit will be set on the last block. options: global program options btype: the deflate block type. Use 2 for best compression. -0: non compressed blocks (00) -1: blocks with fixed tree (01) -2: blocks with dynamic tree (10) final: whether this is the last section of the input, sets the final bit to the last deflate block. in: the input bytes insize: number of input bytes bp: bit pointer for the output array. This must initially be 0, and for consecutive calls must be reused (it can have values from 0-7). This is because deflate appends blocks as bit-based data, rather than on byte boundaries. out: pointer to the dynamic output array to which the result is appended. Must be freed after use. outsize: pointer to the dynamic output array size. */ void ZopfliDeflate(const ZopfliOptions* options, int btype, int final, const unsigned char* in, size_t insize, unsigned char* bp, unsigned char** out, size_t* outsize); /* Like ZopfliDeflate, but allows to specify start and end byte with instart and inend. Only that part is compressed, but earlier bytes are still used for the back window. */ void ZopfliDeflatePart(const ZopfliOptions* options, int btype, int final, const unsigned char* in, size_t instart, size_t inend, unsigned char* bp, unsigned char** out, size_t* outsize); /* Calculates block size in bits. litlens: lz77 lit/lengths dists: ll77 distances lstart: start of block lend: end of block (not inclusive) */ double ZopfliCalculateBlockSize(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, int btype); /* Calculates block size in bits, automatically using the best btype. */ double ZopfliCalculateBlockSizeAutoType(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend); #ifdef __cplusplus } // extern "C" #endif #endif /* ZOPFLI_DEFLATE_H_ */ advancecomp-1.23/zopfli/gzip_container.c000066400000000000000000000141001301462770100203760ustar00rootroot00000000000000/* Copyright 2013 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "gzip_container.h" #include "util.h" #include #include "deflate.h" /* CRC polynomial: 0xedb88320 */ static const unsigned long crc32_table[256] = { 0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u, 3915621685u, 2657392035u, 249268274u, 2044508324u, 3772115230u, 2547177864u, 162941995u, 2125561021u, 3887607047u, 2428444049u, 498536548u, 1789927666u, 4089016648u, 2227061214u, 450548861u, 1843258603u, 4107580753u, 2211677639u, 325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u, 4195302755u, 2366115317u, 997073096u, 1281953886u, 3579855332u, 2724688242u, 1006888145u, 1258607687u, 3524101629u, 2768942443u, 901097722u, 1119000684u, 3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u, 651767980u, 1373503546u, 3369554304u, 3218104598u, 565507253u, 1454621731u, 3485111705u, 3099436303u, 671266974u, 1594198024u, 3322730930u, 2970347812u, 795835527u, 1483230225u, 3244367275u, 3060149565u, 1994146192u, 31158534u, 2563907772u, 4023717930u, 1907459465u, 112637215u, 2680153253u, 3904427059u, 2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u, 2439277719u, 3865271297u, 1802195444u, 476864866u, 2238001368u, 4066508878u, 1812370925u, 453092731u, 2181625025u, 4111451223u, 1706088902u, 314042704u, 2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u, 1303535960u, 984961486u, 2747007092u, 3569037538u, 1256170817u, 1037604311u, 2765210733u, 3554079995u, 1131014506u, 879679996u, 2909243462u, 3663771856u, 1141124467u, 855842277u, 2852801631u, 3708648649u, 1342533948u, 654459306u, 3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u, 1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u, 3082640443u, 3233442989u, 3988292384u, 2596254646u, 62317068u, 1957810842u, 3939845945u, 2647816111u, 81470997u, 1943803523u, 3814918930u, 2489596804u, 225274430u, 2053790376u, 3826175755u, 2466906013u, 167816743u, 2097651377u, 4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u, 426522225u, 1852507879u, 4275313526u, 2312317920u, 282753626u, 1742555852u, 4189708143u, 2394877945u, 397917763u, 1622183637u, 3604390888u, 2714866558u, 953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u, 3624741850u, 2936675148u, 906185462u, 1090812512u, 3747672003u, 2825379669u, 829329135u, 1181335161u, 3412177804u, 3160834842u, 628085408u, 1382605366u, 3423369109u, 3138078467u, 570562233u, 1426400815u, 3317316542u, 2998733608u, 733239954u, 1555261956u, 3268935591u, 3050360625u, 752459403u, 1541320221u, 2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u, 1913087877u, 83908371u, 2512341634u, 3803740692u, 2075208622u, 213261112u, 2463272603u, 3855990285u, 2094854071u, 198958881u, 2262029012u, 4057260610u, 1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u, 2282248934u, 4279200368u, 1711684554u, 285281116u, 2405801727u, 4167216745u, 1634467795u, 376229701u, 2685067896u, 3608007406u, 1308918612u, 956543938u, 2808555105u, 3495958263u, 1231636301u, 1047427035u, 2932959818u, 3654703836u, 1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u, 3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u, 1423857449u, 601450431u, 3009837614u, 3294710456u, 1567103746u, 711928724u, 3020668471u, 3272380065u, 1510334235u, 755167117u }; /* Returns the CRC32 */ static unsigned long CRC(const unsigned char* data, size_t size) { unsigned long result = 0xffffffffu; for (; size > 0; size--) { result = crc32_table[(result ^ *(data++)) & 0xff] ^ (result >> 8); } return result ^ 0xffffffffu; } /* Compresses the data according to the gzip specification, RFC 1952. */ void ZopfliGzipCompress(const ZopfliOptions* options, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize) { unsigned long crcvalue = CRC(in, insize); unsigned char bp = 0; ZOPFLI_APPEND_DATA(31, out, outsize); /* ID1 */ ZOPFLI_APPEND_DATA(139, out, outsize); /* ID2 */ ZOPFLI_APPEND_DATA(8, out, outsize); /* CM */ ZOPFLI_APPEND_DATA(0, out, outsize); /* FLG */ /* MTIME */ ZOPFLI_APPEND_DATA(0, out, outsize); ZOPFLI_APPEND_DATA(0, out, outsize); ZOPFLI_APPEND_DATA(0, out, outsize); ZOPFLI_APPEND_DATA(0, out, outsize); ZOPFLI_APPEND_DATA(2, out, outsize); /* XFL, 2 indicates best compression. */ ZOPFLI_APPEND_DATA(3, out, outsize); /* OS follows Unix conventions. */ ZopfliDeflate(options, 2 /* Dynamic block */, 1, in, insize, &bp, out, outsize); /* CRC */ ZOPFLI_APPEND_DATA(crcvalue % 256, out, outsize); ZOPFLI_APPEND_DATA((crcvalue >> 8) % 256, out, outsize); ZOPFLI_APPEND_DATA((crcvalue >> 16) % 256, out, outsize); ZOPFLI_APPEND_DATA((crcvalue >> 24) % 256, out, outsize); /* ISIZE */ ZOPFLI_APPEND_DATA(insize % 256, out, outsize); ZOPFLI_APPEND_DATA((insize >> 8) % 256, out, outsize); ZOPFLI_APPEND_DATA((insize >> 16) % 256, out, outsize); ZOPFLI_APPEND_DATA((insize >> 24) % 256, out, outsize); if (options->verbose) { fprintf(stderr, "Original Size: %d, Gzip: %d, Compression: %f%% Removed\n", (int)insize, (int)*outsize, 100.0 * (double)(insize - *outsize) / (double)insize); } } advancecomp-1.23/zopfli/gzip_container.h000066400000000000000000000025721301462770100204150ustar00rootroot00000000000000/* Copyright 2013 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #ifndef ZOPFLI_GZIP_H_ #define ZOPFLI_GZIP_H_ /* Functions to compress according to the Gzip specification. */ #include "zopfli.h" #ifdef __cplusplus extern "C" { #endif /* Compresses according to the gzip specification and append the compressed result to the output. options: global program options out: pointer to the dynamic output array to which the result is appended. Must be freed after use. outsize: pointer to the dynamic output array size. */ void ZopfliGzipCompress(const ZopfliOptions* options, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize); #ifdef __cplusplus } // extern "C" #endif #endif /* ZOPFLI_GZIP_H_ */ advancecomp-1.23/zopfli/hash.c000066400000000000000000000075661301462770100163300ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "hash.h" #include #include #include #define HASH_SHIFT 5 #define HASH_MASK 32767 void ZopfliAllocHash(size_t window_size, ZopfliHash* h) { h->head = (int*)malloc(sizeof(*h->head) * 65536); h->prev = (unsigned short*)malloc(sizeof(*h->prev) * window_size); h->hashval = (int*)malloc(sizeof(*h->hashval) * window_size); #ifdef ZOPFLI_HASH_SAME h->same = (unsigned short*)malloc(sizeof(*h->same) * window_size); #endif #ifdef ZOPFLI_HASH_SAME_HASH h->head2 = (int*)malloc(sizeof(*h->head2) * 65536); h->prev2 = (unsigned short*)malloc(sizeof(*h->prev2) * window_size); h->hashval2 = (int*)malloc(sizeof(*h->hashval2) * window_size); #endif } void ZopfliResetHash(size_t window_size, ZopfliHash* h) { size_t i; h->val = 0; for (i = 0; i < 65536; i++) { h->head[i] = -1; /* -1 indicates no head so far. */ } for (i = 0; i < window_size; i++) { h->prev[i] = i; /* If prev[j] == j, then prev[j] is uninitialized. */ h->hashval[i] = -1; } #ifdef ZOPFLI_HASH_SAME for (i = 0; i < window_size; i++) { h->same[i] = 0; } #endif #ifdef ZOPFLI_HASH_SAME_HASH h->val2 = 0; for (i = 0; i < 65536; i++) { h->head2[i] = -1; } for (i = 0; i < window_size; i++) { h->prev2[i] = i; h->hashval2[i] = -1; } #endif } void ZopfliCleanHash(ZopfliHash* h) { free(h->head); free(h->prev); free(h->hashval); #ifdef ZOPFLI_HASH_SAME_HASH free(h->head2); free(h->prev2); free(h->hashval2); #endif #ifdef ZOPFLI_HASH_SAME free(h->same); #endif } /* Update the sliding hash value with the given byte. All calls to this function must be made on consecutive input characters. Since the hash value exists out of multiple input bytes, a few warmups with this function are needed initially. */ static void UpdateHashValue(ZopfliHash* h, unsigned char c) { h->val = (((h->val) << HASH_SHIFT) ^ (c)) & HASH_MASK; } void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end, ZopfliHash* h) { unsigned short hpos = pos & ZOPFLI_WINDOW_MASK; #ifdef ZOPFLI_HASH_SAME size_t amount = 0; #endif UpdateHashValue(h, pos + ZOPFLI_MIN_MATCH <= end ? array[pos + ZOPFLI_MIN_MATCH - 1] : 0); h->hashval[hpos] = h->val; if (h->head[h->val] != -1 && h->hashval[h->head[h->val]] == h->val) { h->prev[hpos] = h->head[h->val]; } else h->prev[hpos] = hpos; h->head[h->val] = hpos; #ifdef ZOPFLI_HASH_SAME /* Update "same". */ if (h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] > 1) { amount = h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] - 1; } while (pos + amount + 1 < end && array[pos] == array[pos + amount + 1] && amount < (unsigned short)(-1)) { amount++; } h->same[hpos] = amount; #endif #ifdef ZOPFLI_HASH_SAME_HASH h->val2 = ((h->same[hpos] - ZOPFLI_MIN_MATCH) & 255) ^ h->val; h->hashval2[hpos] = h->val2; if (h->head2[h->val2] != -1 && h->hashval2[h->head2[h->val2]] == h->val2) { h->prev2[hpos] = h->head2[h->val2]; } else h->prev2[hpos] = hpos; h->head2[h->val2] = hpos; #endif } void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end, ZopfliHash* h) { UpdateHashValue(h, array[pos + 0]); if (pos + 1 < end) UpdateHashValue(h, array[pos + 1]); } advancecomp-1.23/zopfli/hash.h000066400000000000000000000045111301462770100163200ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* The hash for ZopfliFindLongestMatch of lz77.c. */ #ifndef ZOPFLI_HASH_H_ #define ZOPFLI_HASH_H_ #include "util.h" typedef struct ZopfliHash { int* head; /* Hash value to index of its most recent occurrence. */ unsigned short* prev; /* Index to index of prev. occurrence of same hash. */ int* hashval; /* Index to hash value at this index. */ int val; /* Current hash value. */ #ifdef ZOPFLI_HASH_SAME_HASH /* Fields with similar purpose as the above hash, but for the second hash with a value that is calculated differently. */ int* head2; /* Hash value to index of its most recent occurrence. */ unsigned short* prev2; /* Index to index of prev. occurrence of same hash. */ int* hashval2; /* Index to hash value at this index. */ int val2; /* Current hash value. */ #endif #ifdef ZOPFLI_HASH_SAME unsigned short* same; /* Amount of repetitions of same byte after this .*/ #endif } ZopfliHash; /* Allocates ZopfliHash memory. */ void ZopfliAllocHash(size_t window_size, ZopfliHash* h); /* Resets all fields of ZopfliHash. */ void ZopfliResetHash(size_t window_size, ZopfliHash* h); /* Frees ZopfliHash memory. */ void ZopfliCleanHash(ZopfliHash* h); /* Updates the hash values based on the current position in the array. All calls to this must be made for consecutive bytes. */ void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end, ZopfliHash* h); /* Prepopulates hash: Fills in the initial values in the hash, before ZopfliUpdateHash can be used correctly. */ void ZopfliWarmupHash(const unsigned char* array, size_t pos, size_t end, ZopfliHash* h); #endif /* ZOPFLI_HASH_H_ */ advancecomp-1.23/zopfli/katajainen.c000066400000000000000000000174711301462770100175060ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Bounded package merge algorithm, based on the paper "A Fast and Space-Economical Algorithm for Length-Limited Coding Jyrki Katajainen, Alistair Moffat, Andrew Turpin". */ #include "katajainen.h" #include #include #include typedef struct Node Node; /* Nodes forming chains. Also used to represent leaves. */ struct Node { size_t weight; /* Total weight (symbol count) of this chain. */ Node* tail; /* Previous node(s) of this chain, or 0 if none. */ int count; /* Leaf symbol index, or number of leaves before this chain. */ }; /* Memory pool for nodes. */ typedef struct NodePool { Node* next; /* Pointer to a free node in the pool. */ } NodePool; /* Initializes a chain node with the given values and marks it as in use. */ static void InitNode(size_t weight, int count, Node* tail, Node* node) { node->weight = weight; node->count = count; node->tail = tail; } /* Performs a Boundary Package-Merge step. Puts a new chain in the given list. The new chain is, depending on the weights, a leaf or a combination of two chains from the previous list. lists: The lists of chains. maxbits: Number of lists. leaves: The leaves, one per symbol. numsymbols: Number of leaves. pool: the node memory pool. index: The index of the list in which a new chain or leaf is required. */ static void BoundaryPM(Node* (*lists)[2], Node* leaves, int numsymbols, NodePool* pool, int index) { Node* newchain; Node* oldchain; int lastcount = lists[index][1]->count; /* Count of last chain of list. */ if (index == 0 && lastcount >= numsymbols) return; newchain = pool->next++; oldchain = lists[index][1]; /* These are set up before the recursive calls below, so that there is a list pointing to the new node, to let the garbage collection know it's in use. */ lists[index][0] = oldchain; lists[index][1] = newchain; if (index == 0) { /* New leaf node in list 0. */ InitNode(leaves[lastcount].weight, lastcount + 1, 0, newchain); } else { size_t sum = lists[index - 1][0]->weight + lists[index - 1][1]->weight; if (lastcount < numsymbols && sum > leaves[lastcount].weight) { /* New leaf inserted in list, so count is incremented. */ InitNode(leaves[lastcount].weight, lastcount + 1, oldchain->tail, newchain); } else { InitNode(sum, lastcount, lists[index - 1][1], newchain); /* Two lookahead chains of previous list used up, create new ones. */ BoundaryPM(lists, leaves, numsymbols, pool, index - 1); BoundaryPM(lists, leaves, numsymbols, pool, index - 1); } } } static void BoundaryPMFinal(Node* (*lists)[2], Node* leaves, int numsymbols, NodePool* pool, int index) { int lastcount = lists[index][1]->count; /* Count of last chain of list. */ size_t sum = lists[index - 1][0]->weight + lists[index - 1][1]->weight; if (lastcount < numsymbols && sum > leaves[lastcount].weight) { Node* newchain = pool->next; Node* oldchain = lists[index][1]->tail; lists[index][1] = newchain; newchain->count = lastcount + 1; newchain->tail = oldchain; } else { lists[index][1]->tail = lists[index - 1][1]; } } /* Initializes each list with as lookahead chains the two leaves with lowest weights. */ static void InitLists( NodePool* pool, const Node* leaves, int maxbits, Node* (*lists)[2]) { int i; Node* node0 = pool->next++; Node* node1 = pool->next++; InitNode(leaves[0].weight, 1, 0, node0); InitNode(leaves[1].weight, 2, 0, node1); for (i = 0; i < maxbits; i++) { lists[i][0] = node0; lists[i][1] = node1; } } /* Converts result of boundary package-merge to the bitlengths. The result in the last chain of the last list contains the amount of active leaves in each list. chain: Chain to extract the bit length from (last chain from last list). */ static void ExtractBitLengths(Node* chain, Node* leaves, unsigned* bitlengths) { int counts[16] = {0}; unsigned end = 16; unsigned ptr = 15; unsigned value = 1; Node* node; int val; for (node = chain; node; node = node->tail) { counts[--end] = node->count; } val = counts[15]; while (ptr >= end) { for (; val > counts[ptr - 1]; val--) { bitlengths[leaves[val - 1].count] = value; } ptr--; value++; } } /* Comparator for sorting the leaves. Has the function signature for qsort. */ static int LeafComparator(const void* a, const void* b) { return ((const Node*)a)->weight - ((const Node*)b)->weight; } int ZopfliLengthLimitedCodeLengths( const size_t* frequencies, int n, int maxbits, unsigned* bitlengths) { NodePool pool; int i; int numsymbols = 0; /* Amount of symbols with frequency > 0. */ int numBoundaryPMRuns; Node* nodes; /* Array of lists of chains. Each list requires only two lookahead chains at a time, so each list is a array of two Node*'s. */ Node* (*lists)[2]; /* One leaf per symbol. Only numsymbols leaves will be used. */ Node* leaves = (Node*)malloc(n * sizeof(*leaves)); /* Initialize all bitlengths at 0. */ for (i = 0; i < n; i++) { bitlengths[i] = 0; } /* Count used symbols and place them in the leaves. */ for (i = 0; i < n; i++) { if (frequencies[i]) { leaves[numsymbols].weight = frequencies[i]; leaves[numsymbols].count = i; /* Index of symbol this leaf represents. */ numsymbols++; } } /* Check special cases and error conditions. */ if ((1 << maxbits) < numsymbols) { free(leaves); return 1; /* Error, too few maxbits to represent symbols. */ } if (numsymbols == 0) { free(leaves); return 0; /* No symbols at all. OK. */ } if (numsymbols == 1) { bitlengths[leaves[0].count] = 1; free(leaves); return 0; /* Only one symbol, give it bitlength 1, not 0. OK. */ } if (numsymbols == 2) { bitlengths[leaves[0].count]++; bitlengths[leaves[1].count]++; free(leaves); return 0; } /* Sort the leaves from lightest to heaviest. Add count into the same variable for stable sorting. */ for (i = 0; i < numsymbols; i++) { if (leaves[i].weight >= ((size_t)1 << (sizeof(leaves[0].weight) * CHAR_BIT - 9))) { free(leaves); return 1; /* Error, we need 9 bits for the count. */ } leaves[i].weight = (leaves[i].weight << 9) | leaves[i].count; } qsort(leaves, numsymbols, sizeof(Node), LeafComparator); for (i = 0; i < numsymbols; i++) { leaves[i].weight >>= 9; } if (numsymbols - 1 < maxbits) { maxbits = numsymbols - 1; } /* Initialize node memory pool. */ nodes = (Node*)malloc(maxbits * 2 * numsymbols * sizeof(Node)); pool.next = nodes; lists = (Node* (*)[2])malloc(maxbits * sizeof(*lists)); InitLists(&pool, leaves, maxbits, lists); /* In the last list, 2 * numsymbols - 2 active chains need to be created. Two are already created in the initialization. Each BoundaryPM run creates one. */ numBoundaryPMRuns = 2 * numsymbols - 4; for (i = 0; i < numBoundaryPMRuns - 1; i++) { BoundaryPM(lists, leaves, numsymbols, &pool, maxbits - 1); } BoundaryPMFinal(lists, leaves, numsymbols, &pool, maxbits - 1); ExtractBitLengths(lists[maxbits - 1][1], leaves, bitlengths); free(lists); free(leaves); free(nodes); return 0; /* OK. */ } advancecomp-1.23/zopfli/katajainen.h000066400000000000000000000027311301462770100175040ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #ifndef ZOPFLI_KATAJAINEN_H_ #define ZOPFLI_KATAJAINEN_H_ #include /* Outputs minimum-redundancy length-limited code bitlengths for symbols with the given counts. The bitlengths are limited by maxbits. The output is tailored for DEFLATE: symbols that never occur, get a bit length of 0, and if only a single symbol occurs at least once, its bitlength will be 1, and not 0 as would theoretically be needed for a single symbol. frequencies: The amount of occurrences of each symbol. n: The amount of symbols. maxbits: Maximum bit length, inclusive. bitlengths: Output, the bitlengths for the symbol prefix codes. return: 0 for OK, non-0 for error. */ int ZopfliLengthLimitedCodeLengths( const size_t* frequencies, int n, int maxbits, unsigned* bitlengths); #endif /* ZOPFLI_KATAJAINEN_H_ */ advancecomp-1.23/zopfli/lz77.c000066400000000000000000000501411301462770100161730ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "lz77.h" #include "symbols.h" #include "util.h" #include #include #include void ZopfliInitLZ77Store(const unsigned char* data, ZopfliLZ77Store* store) { store->size = 0; store->litlens = 0; store->dists = 0; store->pos = 0; store->data = data; store->ll_symbol = 0; store->d_symbol = 0; store->ll_counts = 0; store->d_counts = 0; } void ZopfliCleanLZ77Store(ZopfliLZ77Store* store) { free(store->litlens); free(store->dists); free(store->pos); free(store->ll_symbol); free(store->d_symbol); free(store->ll_counts); free(store->d_counts); } static size_t CeilDiv(size_t a, size_t b) { return (a + b - 1) / b; } void ZopfliCopyLZ77Store( const ZopfliLZ77Store* source, ZopfliLZ77Store* dest) { size_t i; size_t llsize = ZOPFLI_NUM_LL * CeilDiv(source->size, ZOPFLI_NUM_LL); size_t dsize = ZOPFLI_NUM_D * CeilDiv(source->size, ZOPFLI_NUM_D); ZopfliCleanLZ77Store(dest); ZopfliInitLZ77Store(source->data, dest); dest->litlens = (unsigned short*)malloc(sizeof(*dest->litlens) * source->size); dest->dists = (unsigned short*)malloc(sizeof(*dest->dists) * source->size); dest->pos = (size_t*)malloc(sizeof(*dest->pos) * source->size); dest->ll_symbol = (unsigned short*)malloc(sizeof(*dest->ll_symbol) * source->size); dest->d_symbol = (unsigned short*)malloc(sizeof(*dest->d_symbol) * source->size); dest->ll_counts = (size_t*)malloc(sizeof(*dest->ll_counts) * llsize); dest->d_counts = (size_t*)malloc(sizeof(*dest->d_counts) * dsize); /* Allocation failed. */ if (!dest->litlens || !dest->dists) exit(-1); if (!dest->pos) exit(-1); if (!dest->ll_symbol || !dest->d_symbol) exit(-1); if (!dest->ll_counts || !dest->d_counts) exit(-1); dest->size = source->size; for (i = 0; i < source->size; i++) { dest->litlens[i] = source->litlens[i]; dest->dists[i] = source->dists[i]; dest->pos[i] = source->pos[i]; dest->ll_symbol[i] = source->ll_symbol[i]; dest->d_symbol[i] = source->d_symbol[i]; } for (i = 0; i < llsize; i++) { dest->ll_counts[i] = source->ll_counts[i]; } for (i = 0; i < dsize; i++) { dest->d_counts[i] = source->d_counts[i]; } } /* Appends the length and distance to the LZ77 arrays of the ZopfliLZ77Store. context must be a ZopfliLZ77Store*. */ void ZopfliStoreLitLenDist(unsigned short length, unsigned short dist, size_t pos, ZopfliLZ77Store* store) { size_t i; /* Needed for using ZOPFLI_APPEND_DATA multiple times. */ size_t origsize = store->size; size_t llstart = ZOPFLI_NUM_LL * (origsize / ZOPFLI_NUM_LL); size_t dstart = ZOPFLI_NUM_D * (origsize / ZOPFLI_NUM_D); /* Everytime the index wraps around, a new cumulative histogram is made: we're keeping one histogram value per LZ77 symbol rather than a full histogram for each to save memory. */ if (origsize % ZOPFLI_NUM_LL == 0) { size_t llsize = origsize; for (i = 0; i < ZOPFLI_NUM_LL; i++) { ZOPFLI_APPEND_DATA( origsize == 0 ? 0 : store->ll_counts[origsize - ZOPFLI_NUM_LL + i], &store->ll_counts, &llsize); } } if (origsize % ZOPFLI_NUM_D == 0) { size_t dsize = origsize; for (i = 0; i < ZOPFLI_NUM_D; i++) { ZOPFLI_APPEND_DATA( origsize == 0 ? 0 : store->d_counts[origsize - ZOPFLI_NUM_D + i], &store->d_counts, &dsize); } } ZOPFLI_APPEND_DATA(length, &store->litlens, &store->size); store->size = origsize; ZOPFLI_APPEND_DATA(dist, &store->dists, &store->size); store->size = origsize; ZOPFLI_APPEND_DATA(pos, &store->pos, &store->size); assert(length < 259); if (dist == 0) { store->size = origsize; ZOPFLI_APPEND_DATA(length, &store->ll_symbol, &store->size); store->size = origsize; ZOPFLI_APPEND_DATA(0, &store->d_symbol, &store->size); store->ll_counts[llstart + length]++; } else { store->size = origsize; ZOPFLI_APPEND_DATA(ZopfliGetLengthSymbol(length), &store->ll_symbol, &store->size); store->size = origsize; ZOPFLI_APPEND_DATA(ZopfliGetDistSymbol(dist), &store->d_symbol, &store->size); store->ll_counts[llstart + ZopfliGetLengthSymbol(length)]++; store->d_counts[dstart + ZopfliGetDistSymbol(dist)]++; } } void ZopfliAppendLZ77Store(const ZopfliLZ77Store* store, ZopfliLZ77Store* target) { size_t i; for (i = 0; i < store->size; i++) { ZopfliStoreLitLenDist(store->litlens[i], store->dists[i], store->pos[i], target); } } size_t ZopfliLZ77GetByteRange(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend) { size_t l = lend - 1; if (lstart == lend) return 0; return lz77->pos[l] + ((lz77->dists[l] == 0) ? 1 : lz77->litlens[l]) - lz77->pos[lstart]; } static void ZopfliLZ77GetHistogramAt(const ZopfliLZ77Store* lz77, size_t lpos, size_t* ll_counts, size_t* d_counts) { /* The real histogram is created by using the histogram for this chunk, but all superfluous values of this chunk subtracted. */ size_t llpos = ZOPFLI_NUM_LL * (lpos / ZOPFLI_NUM_LL); size_t dpos = ZOPFLI_NUM_D * (lpos / ZOPFLI_NUM_D); size_t i; for (i = 0; i < ZOPFLI_NUM_LL; i++) { ll_counts[i] = lz77->ll_counts[llpos + i]; } for (i = lpos + 1; i < llpos + ZOPFLI_NUM_LL && i < lz77->size; i++) { ll_counts[lz77->ll_symbol[i]]--; } for (i = 0; i < ZOPFLI_NUM_D; i++) { d_counts[i] = lz77->d_counts[dpos + i]; } for (i = lpos + 1; i < dpos + ZOPFLI_NUM_D && i < lz77->size; i++) { if (lz77->dists[i] != 0) d_counts[lz77->d_symbol[i]]--; } } void ZopfliLZ77GetHistogram(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, size_t* ll_counts, size_t* d_counts) { size_t i; if (lstart + ZOPFLI_NUM_LL * 3 > lend) { memset(ll_counts, 0, sizeof(*ll_counts) * ZOPFLI_NUM_LL); memset(d_counts, 0, sizeof(*d_counts) * ZOPFLI_NUM_D); for (i = lstart; i < lend; i++) { ll_counts[lz77->ll_symbol[i]]++; if (lz77->dists[i] != 0) d_counts[lz77->d_symbol[i]]++; } } else { /* Subtract the cumulative histograms at the end and the start to get the histogram for this range. */ ZopfliLZ77GetHistogramAt(lz77, lend - 1, ll_counts, d_counts); if (lstart > 0) { size_t ll_counts2[ZOPFLI_NUM_LL]; size_t d_counts2[ZOPFLI_NUM_D]; ZopfliLZ77GetHistogramAt(lz77, lstart - 1, ll_counts2, d_counts2); for (i = 0; i < ZOPFLI_NUM_LL; i++) { ll_counts[i] -= ll_counts2[i]; } for (i = 0; i < ZOPFLI_NUM_D; i++) { d_counts[i] -= d_counts2[i]; } } } } void ZopfliInitBlockState(const ZopfliOptions* options, size_t blockstart, size_t blockend, int add_lmc, ZopfliBlockState* s) { s->options = options; s->blockstart = blockstart; s->blockend = blockend; #ifdef ZOPFLI_LONGEST_MATCH_CACHE if (add_lmc) { s->lmc = (ZopfliLongestMatchCache*)malloc(sizeof(ZopfliLongestMatchCache)); ZopfliInitCache(blockend - blockstart, s->lmc); } else { s->lmc = 0; } #endif } void ZopfliCleanBlockState(ZopfliBlockState* s) { #ifdef ZOPFLI_LONGEST_MATCH_CACHE if (s->lmc) { ZopfliCleanCache(s->lmc); free(s->lmc); } #endif } /* Gets a score of the length given the distance. Typically, the score of the length is the length itself, but if the distance is very long, decrease the score of the length a bit to make up for the fact that long distances use large amounts of extra bits. This is not an accurate score, it is a heuristic only for the greedy LZ77 implementation. More accurate cost models are employed later. Making this heuristic more accurate may hurt rather than improve compression. The two direct uses of this heuristic are: -avoid using a length of 3 in combination with a long distance. This only has an effect if length == 3. -make a slightly better choice between the two options of the lazy matching. Indirectly, this affects: -the block split points if the default of block splitting first is used, in a rather unpredictable way -the first zopfli run, so it affects the chance of the first run being closer to the optimal output */ static int GetLengthScore(int length, int distance) { /* At 1024, the distance uses 9+ extra bits and this seems to be the sweet spot on tested files. */ return distance > 1024 ? length - 1 : length; } void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos, unsigned short dist, unsigned short length) { /* TODO(lode): make this only run in a debug compile, it's for assert only. */ size_t i; assert(pos + length <= datasize); for (i = 0; i < length; i++) { if (data[pos - dist + i] != data[pos + i]) { assert(data[pos - dist + i] == data[pos + i]); break; } } } /* Finds how long the match of scan and match is. Can be used to find how many bytes starting from scan, and from match, are equal. Returns the last byte after scan, which is still equal to the correspondinb byte after match. scan is the position to compare match is the earlier position to compare. end is the last possible byte, beyond which to stop looking. safe_end is a few (8) bytes before end, for comparing multiple bytes at once. */ static const unsigned char* GetMatch(const unsigned char* scan, const unsigned char* match, const unsigned char* end, const unsigned char* safe_end) { if (sizeof(size_t) == 8) { /* 8 checks at once per array bounds check (size_t is 64-bit). */ while (scan < safe_end && *((size_t*)scan) == *((size_t*)match)) { scan += 8; match += 8; } } else if (sizeof(unsigned int) == 4) { /* 4 checks at once per array bounds check (unsigned int is 32-bit). */ while (scan < safe_end && *((unsigned int*)scan) == *((unsigned int*)match)) { scan += 4; match += 4; } } else { /* do 8 checks at once per array bounds check. */ while (scan < safe_end && *scan == *match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match) { scan++; match++; } } /* The remaining few bytes. */ while (scan != end && *scan == *match) { scan++; match++; } return scan; } #ifdef ZOPFLI_LONGEST_MATCH_CACHE /* Gets distance, length and sublen values from the cache if possible. Returns 1 if it got the values from the cache, 0 if not. Updates the limit value to a smaller one if possible with more limited information from the cache. */ static int TryGetFromLongestMatchCache(ZopfliBlockState* s, size_t pos, size_t* limit, unsigned short* sublen, unsigned short* distance, unsigned short* length) { /* The LMC cache starts at the beginning of the block rather than the beginning of the whole array. */ size_t lmcpos = pos - s->blockstart; /* Length > 0 and dist 0 is invalid combination, which indicates on purpose that this cache value is not filled in yet. */ unsigned char cache_available = s->lmc && (s->lmc->length[lmcpos] == 0 || s->lmc->dist[lmcpos] != 0); unsigned char limit_ok_for_cache = cache_available && (*limit == ZOPFLI_MAX_MATCH || s->lmc->length[lmcpos] <= *limit || (sublen && ZopfliMaxCachedSublen(s->lmc, lmcpos, s->lmc->length[lmcpos]) >= *limit)); if (s->lmc && limit_ok_for_cache && cache_available) { if (!sublen || s->lmc->length[lmcpos] <= ZopfliMaxCachedSublen(s->lmc, lmcpos, s->lmc->length[lmcpos])) { *length = s->lmc->length[lmcpos]; if (*length > *limit) *length = *limit; if (sublen) { ZopfliCacheToSublen(s->lmc, lmcpos, *length, sublen); *distance = sublen[*length]; if (*limit == ZOPFLI_MAX_MATCH && *length >= ZOPFLI_MIN_MATCH) { assert(sublen[*length] == s->lmc->dist[lmcpos]); } } else { *distance = s->lmc->dist[lmcpos]; } return 1; } /* Can't use much of the cache, since the "sublens" need to be calculated, but at least we already know when to stop. */ *limit = s->lmc->length[lmcpos]; } return 0; } /* Stores the found sublen, distance and length in the longest match cache, if possible. */ static void StoreInLongestMatchCache(ZopfliBlockState* s, size_t pos, size_t limit, const unsigned short* sublen, unsigned short distance, unsigned short length) { /* The LMC cache starts at the beginning of the block rather than the beginning of the whole array. */ size_t lmcpos = pos - s->blockstart; /* Length > 0 and dist 0 is invalid combination, which indicates on purpose that this cache value is not filled in yet. */ unsigned char cache_available = s->lmc && (s->lmc->length[lmcpos] == 0 || s->lmc->dist[lmcpos] != 0); if (s->lmc && limit == ZOPFLI_MAX_MATCH && sublen && !cache_available) { assert(s->lmc->length[lmcpos] == 1 && s->lmc->dist[lmcpos] == 0); s->lmc->dist[lmcpos] = length < ZOPFLI_MIN_MATCH ? 0 : distance; s->lmc->length[lmcpos] = length < ZOPFLI_MIN_MATCH ? 0 : length; assert(!(s->lmc->length[lmcpos] == 1 && s->lmc->dist[lmcpos] == 0)); ZopfliSublenToCache(sublen, lmcpos, length, s->lmc); } } #endif void ZopfliFindLongestMatch(ZopfliBlockState* s, const ZopfliHash* h, const unsigned char* array, size_t pos, size_t size, size_t limit, unsigned short* sublen, unsigned short* distance, unsigned short* length) { unsigned short hpos = pos & ZOPFLI_WINDOW_MASK, p, pp; unsigned short bestdist = 0; unsigned short bestlength = 1; const unsigned char* scan; const unsigned char* match; const unsigned char* arrayend; const unsigned char* arrayend_safe; #if ZOPFLI_MAX_CHAIN_HITS < ZOPFLI_WINDOW_SIZE int chain_counter = ZOPFLI_MAX_CHAIN_HITS; /* For quitting early. */ #endif unsigned dist = 0; /* Not unsigned short on purpose. */ int* hhead = h->head; unsigned short* hprev = h->prev; int* hhashval = h->hashval; int hval = h->val; #ifdef ZOPFLI_LONGEST_MATCH_CACHE if (TryGetFromLongestMatchCache(s, pos, &limit, sublen, distance, length)) { assert(pos + *length <= size); return; } #endif assert(limit <= ZOPFLI_MAX_MATCH); assert(limit >= ZOPFLI_MIN_MATCH); assert(pos < size); if (size - pos < ZOPFLI_MIN_MATCH) { /* The rest of the code assumes there are at least ZOPFLI_MIN_MATCH bytes to try. */ *length = 0; *distance = 0; return; } if (pos + limit > size) { limit = size - pos; } arrayend = &array[pos] + limit; arrayend_safe = arrayend - 8; assert(hval < 65536); pp = hhead[hval]; /* During the whole loop, p == hprev[pp]. */ p = hprev[pp]; assert(pp == hpos); dist = p < pp ? pp - p : ((ZOPFLI_WINDOW_SIZE - p) + pp); /* Go through all distances. */ while (dist < ZOPFLI_WINDOW_SIZE) { unsigned short currentlength = 0; assert(p < ZOPFLI_WINDOW_SIZE); assert(p == hprev[pp]); assert(hhashval[p] == hval); if (dist > 0) { assert(pos < size); assert(dist <= pos); scan = &array[pos]; match = &array[pos - dist]; /* Testing the byte at position bestlength first, goes slightly faster. */ if (pos + bestlength >= size || *(scan + bestlength) == *(match + bestlength)) { #ifdef ZOPFLI_HASH_SAME unsigned short same0 = h->same[pos & ZOPFLI_WINDOW_MASK]; if (same0 > 2 && *scan == *match) { unsigned short same1 = h->same[(pos - dist) & ZOPFLI_WINDOW_MASK]; unsigned short same = same0 < same1 ? same0 : same1; if (same > limit) same = limit; scan += same; match += same; } #endif scan = GetMatch(scan, match, arrayend, arrayend_safe); currentlength = scan - &array[pos]; /* The found length. */ } if (currentlength > bestlength) { if (sublen) { unsigned short j; for (j = bestlength + 1; j <= currentlength; j++) { sublen[j] = dist; } } bestdist = dist; bestlength = currentlength; if (currentlength >= limit) break; } } #ifdef ZOPFLI_HASH_SAME_HASH /* Switch to the other hash once this will be more efficient. */ if (hhead != h->head2 && bestlength >= h->same[hpos] && h->val2 == h->hashval2[p]) { /* Now use the hash that encodes the length and first byte. */ hhead = h->head2; hprev = h->prev2; hhashval = h->hashval2; hval = h->val2; } #endif pp = p; p = hprev[p]; if (p == pp) break; /* Uninited prev value. */ dist += p < pp ? pp - p : ((ZOPFLI_WINDOW_SIZE - p) + pp); #if ZOPFLI_MAX_CHAIN_HITS < ZOPFLI_WINDOW_SIZE chain_counter--; if (chain_counter <= 0) break; #endif } #ifdef ZOPFLI_LONGEST_MATCH_CACHE StoreInLongestMatchCache(s, pos, limit, sublen, bestdist, bestlength); #endif assert(bestlength <= limit); *distance = bestdist; *length = bestlength; assert(pos + *length <= size); } void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in, size_t instart, size_t inend, ZopfliLZ77Store* store, ZopfliHash* h) { size_t i = 0, j; unsigned short leng; unsigned short dist; int lengthscore; size_t windowstart = instart > ZOPFLI_WINDOW_SIZE ? instart - ZOPFLI_WINDOW_SIZE : 0; unsigned short dummysublen[259]; #ifdef ZOPFLI_LAZY_MATCHING /* Lazy matching. */ unsigned prev_length = 0; unsigned prev_match = 0; int prevlengthscore; int match_available = 0; #endif if (instart == inend) return; ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h); ZopfliWarmupHash(in, windowstart, inend, h); for (i = windowstart; i < instart; i++) { ZopfliUpdateHash(in, i, inend, h); } for (i = instart; i < inend; i++) { ZopfliUpdateHash(in, i, inend, h); ZopfliFindLongestMatch(s, h, in, i, inend, ZOPFLI_MAX_MATCH, dummysublen, &dist, &leng); lengthscore = GetLengthScore(leng, dist); #ifdef ZOPFLI_LAZY_MATCHING /* Lazy matching. */ prevlengthscore = GetLengthScore(prev_length, prev_match); if (match_available) { match_available = 0; if (lengthscore > prevlengthscore + 1) { ZopfliStoreLitLenDist(in[i - 1], 0, i - 1, store); if (lengthscore >= ZOPFLI_MIN_MATCH && leng < ZOPFLI_MAX_MATCH) { match_available = 1; prev_length = leng; prev_match = dist; continue; } } else { /* Add previous to output. */ leng = prev_length; dist = prev_match; lengthscore = prevlengthscore; /* Add to output. */ ZopfliVerifyLenDist(in, inend, i - 1, dist, leng); ZopfliStoreLitLenDist(leng, dist, i - 1, store); for (j = 2; j < leng; j++) { assert(i < inend); i++; ZopfliUpdateHash(in, i, inend, h); } continue; } } else if (lengthscore >= ZOPFLI_MIN_MATCH && leng < ZOPFLI_MAX_MATCH) { match_available = 1; prev_length = leng; prev_match = dist; continue; } /* End of lazy matching. */ #endif /* Add to output. */ if (lengthscore >= ZOPFLI_MIN_MATCH) { ZopfliVerifyLenDist(in, inend, i, dist, leng); ZopfliStoreLitLenDist(leng, dist, i, store); } else { leng = 1; ZopfliStoreLitLenDist(in[i], 0, i, store); } for (j = 1; j < leng; j++) { assert(i < inend); i++; ZopfliUpdateHash(in, i, inend, h); } } } advancecomp-1.23/zopfli/lz77.h000066400000000000000000000130151301462770100161770ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Functions for basic LZ77 compression and utilities for the "squeeze" LZ77 compression. */ #ifndef ZOPFLI_LZ77_H_ #define ZOPFLI_LZ77_H_ #include #include "cache.h" #include "hash.h" #include "zopfli.h" /* Stores lit/length and dist pairs for LZ77. Parameter litlens: Contains the literal symbols or length values. Parameter dists: Contains the distances. A value is 0 to indicate that there is no dist and the corresponding litlens value is a literal instead of a length. Parameter size: The size of both the litlens and dists arrays. The memory can best be managed by using ZopfliInitLZ77Store to initialize it, ZopfliCleanLZ77Store to destroy it, and ZopfliStoreLitLenDist to append values. */ typedef struct ZopfliLZ77Store { unsigned short* litlens; /* Lit or len. */ unsigned short* dists; /* If 0: indicates literal in corresponding litlens, if > 0: length in corresponding litlens, this is the distance. */ size_t size; const unsigned char* data; /* original data */ size_t* pos; /* position in data where this LZ77 command begins */ unsigned short* ll_symbol; unsigned short* d_symbol; /* Cumulative histograms wrapping around per chunk. Each chunk has the amount of distinct symbols as length, so using 1 value per LZ77 symbol, we have a precise histogram at every N symbols, and the rest can be calculated by looping through the actual symbols of this chunk. */ size_t* ll_counts; size_t* d_counts; } ZopfliLZ77Store; void ZopfliInitLZ77Store(const unsigned char* data, ZopfliLZ77Store* store); void ZopfliCleanLZ77Store(ZopfliLZ77Store* store); void ZopfliCopyLZ77Store(const ZopfliLZ77Store* source, ZopfliLZ77Store* dest); void ZopfliStoreLitLenDist(unsigned short length, unsigned short dist, size_t pos, ZopfliLZ77Store* store); void ZopfliAppendLZ77Store(const ZopfliLZ77Store* store, ZopfliLZ77Store* target); /* Gets the amount of raw bytes that this range of LZ77 symbols spans. */ size_t ZopfliLZ77GetByteRange(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend); /* Gets the histogram of lit/len and dist symbols in the given range, using the cumulative histograms, so faster than adding one by one for large range. Does not add the one end symbol of value 256. */ void ZopfliLZ77GetHistogram(const ZopfliLZ77Store* lz77, size_t lstart, size_t lend, size_t* ll_counts, size_t* d_counts); /* Some state information for compressing a block. This is currently a bit under-used (with mainly only the longest match cache), but is kept for easy future expansion. */ typedef struct ZopfliBlockState { const ZopfliOptions* options; #ifdef ZOPFLI_LONGEST_MATCH_CACHE /* Cache for length/distance pairs found so far. */ ZopfliLongestMatchCache* lmc; #endif /* The start (inclusive) and end (not inclusive) of the current block. */ size_t blockstart; size_t blockend; } ZopfliBlockState; void ZopfliInitBlockState(const ZopfliOptions* options, size_t blockstart, size_t blockend, int add_lmc, ZopfliBlockState* s); void ZopfliCleanBlockState(ZopfliBlockState* s); /* Finds the longest match (length and corresponding distance) for LZ77 compression. Even when not using "sublen", it can be more efficient to provide an array, because only then the caching is used. array: the data pos: position in the data to find the match for size: size of the data limit: limit length to maximum this value (default should be 258). This allows finding a shorter dist for that length (= less extra bits). Must be in the range [ZOPFLI_MIN_MATCH, ZOPFLI_MAX_MATCH]. sublen: output array of 259 elements, or null. Has, for each length, the smallest distance required to reach this length. Only 256 of its 259 values are used, the first 3 are ignored (the shortest length is 3. It is purely for convenience that the array is made 3 longer). */ void ZopfliFindLongestMatch( ZopfliBlockState *s, const ZopfliHash* h, const unsigned char* array, size_t pos, size_t size, size_t limit, unsigned short* sublen, unsigned short* distance, unsigned short* length); /* Verifies if length and dist are indeed valid, only used for assertion. */ void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos, unsigned short dist, unsigned short length); /* Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than with the slow but better "squeeze" implementation. The result is placed in the ZopfliLZ77Store. If instart is larger than 0, it uses values before instart as starting dictionary. */ void ZopfliLZ77Greedy(ZopfliBlockState* s, const unsigned char* in, size_t instart, size_t inend, ZopfliLZ77Store* store, ZopfliHash* h); #endif /* ZOPFLI_LZ77_H_ */ advancecomp-1.23/zopfli/squeeze.c000066400000000000000000000446341301462770100170630ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "squeeze.h" #include #include #include #include "blocksplitter.h" #include "deflate.h" #include "symbols.h" #include "tree.h" #include "util.h" typedef struct SymbolStats { /* The literal and length symbols. */ size_t litlens[ZOPFLI_NUM_LL]; /* The 32 unique dist symbols, not the 32768 possible dists. */ size_t dists[ZOPFLI_NUM_D]; /* Length of each lit/len symbol in bits. */ double ll_symbols[ZOPFLI_NUM_LL]; /* Length of each dist symbol in bits. */ double d_symbols[ZOPFLI_NUM_D]; } SymbolStats; /* Sets everything to 0. */ static void InitStats(SymbolStats* stats) { memset(stats->litlens, 0, ZOPFLI_NUM_LL * sizeof(stats->litlens[0])); memset(stats->dists, 0, ZOPFLI_NUM_D * sizeof(stats->dists[0])); memset(stats->ll_symbols, 0, ZOPFLI_NUM_LL * sizeof(stats->ll_symbols[0])); memset(stats->d_symbols, 0, ZOPFLI_NUM_D * sizeof(stats->d_symbols[0])); } static void CopyStats(SymbolStats* source, SymbolStats* dest) { memcpy(dest->litlens, source->litlens, ZOPFLI_NUM_LL * sizeof(dest->litlens[0])); memcpy(dest->dists, source->dists, ZOPFLI_NUM_D * sizeof(dest->dists[0])); memcpy(dest->ll_symbols, source->ll_symbols, ZOPFLI_NUM_LL * sizeof(dest->ll_symbols[0])); memcpy(dest->d_symbols, source->d_symbols, ZOPFLI_NUM_D * sizeof(dest->d_symbols[0])); } /* Adds the bit lengths. */ static void AddWeighedStatFreqs(const SymbolStats* stats1, double w1, const SymbolStats* stats2, double w2, SymbolStats* result) { size_t i; for (i = 0; i < ZOPFLI_NUM_LL; i++) { result->litlens[i] = (size_t) (stats1->litlens[i] * w1 + stats2->litlens[i] * w2); } for (i = 0; i < ZOPFLI_NUM_D; i++) { result->dists[i] = (size_t) (stats1->dists[i] * w1 + stats2->dists[i] * w2); } result->litlens[256] = 1; /* End symbol. */ } typedef struct RanState { unsigned int m_w, m_z; } RanState; static void InitRanState(RanState* state) { state->m_w = 1; state->m_z = 2; } /* Get random number: "Multiply-With-Carry" generator of G. Marsaglia */ static unsigned int Ran(RanState* state) { state->m_z = 36969 * (state->m_z & 65535) + (state->m_z >> 16); state->m_w = 18000 * (state->m_w & 65535) + (state->m_w >> 16); return (state->m_z << 16) + state->m_w; /* 32-bit result. */ } static void RandomizeFreqs(RanState* state, size_t* freqs, int n) { int i; for (i = 0; i < n; i++) { if ((Ran(state) >> 4) % 3 == 0) freqs[i] = freqs[Ran(state) % n]; } } static void RandomizeStatFreqs(RanState* state, SymbolStats* stats) { RandomizeFreqs(state, stats->litlens, ZOPFLI_NUM_LL); RandomizeFreqs(state, stats->dists, ZOPFLI_NUM_D); stats->litlens[256] = 1; /* End symbol. */ } static void ClearStatFreqs(SymbolStats* stats) { size_t i; for (i = 0; i < ZOPFLI_NUM_LL; i++) stats->litlens[i] = 0; for (i = 0; i < ZOPFLI_NUM_D; i++) stats->dists[i] = 0; } /* Function that calculates a cost based on a model for the given LZ77 symbol. litlen: means literal symbol if dist is 0, length otherwise. */ typedef double CostModelFun(unsigned litlen, unsigned dist, void* context); /* Cost model which should exactly match fixed tree. type: CostModelFun */ static double GetCostFixed(unsigned litlen, unsigned dist, void* unused) { (void)unused; if (dist == 0) { if (litlen <= 143) return 8; else return 9; } else { int dbits = ZopfliGetDistExtraBits(dist); int lbits = ZopfliGetLengthExtraBits(litlen); int lsym = ZopfliGetLengthSymbol(litlen); int cost = 0; if (lsym <= 279) cost += 7; else cost += 8; cost += 5; /* Every dist symbol has length 5. */ return cost + dbits + lbits; } } /* Cost model based on symbol statistics. type: CostModelFun */ static double GetCostStat(unsigned litlen, unsigned dist, void* context) { SymbolStats* stats = (SymbolStats*)context; if (dist == 0) { return stats->ll_symbols[litlen]; } else { int lsym = ZopfliGetLengthSymbol(litlen); int lbits = ZopfliGetLengthExtraBits(litlen); int dsym = ZopfliGetDistSymbol(dist); int dbits = ZopfliGetDistExtraBits(dist); return lbits + dbits + stats->ll_symbols[lsym] + stats->d_symbols[dsym]; } } /* Finds the minimum possible cost this cost model can return for valid length and distance symbols. */ static double GetCostModelMinCost(CostModelFun* costmodel, void* costcontext) { double mincost; int bestlength = 0; /* length that has lowest cost in the cost model */ int bestdist = 0; /* distance that has lowest cost in the cost model */ int i; /* Table of distances that have a different distance symbol in the deflate specification. Each value is the first distance that has a new symbol. Only different symbols affect the cost model so only these need to be checked. See RFC 1951 section 3.2.5. Compressed blocks (length and distance codes). */ static const int dsymbols[30] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 }; mincost = ZOPFLI_LARGE_FLOAT; for (i = 3; i < 259; i++) { double c = costmodel(i, 1, costcontext); if (c < mincost) { bestlength = i; mincost = c; } } mincost = ZOPFLI_LARGE_FLOAT; for (i = 0; i < 30; i++) { double c = costmodel(3, dsymbols[i], costcontext); if (c < mincost) { bestdist = dsymbols[i]; mincost = c; } } return costmodel(bestlength, bestdist, costcontext); } static size_t zopfli_min(size_t a, size_t b) { return a < b ? a : b; } /* Performs the forward pass for "squeeze". Gets the most optimal length to reach every byte from a previous byte, using cost calculations. s: the ZopfliBlockState in: the input data array instart: where to start inend: where to stop (not inclusive) costmodel: function to calculate the cost of some lit/len/dist pair. costcontext: abstract context for the costmodel function length_array: output array of size (inend - instart) which will receive the best length to reach this byte from a previous byte. returns the cost that was, according to the costmodel, needed to get to the end. */ static double GetBestLengths(ZopfliBlockState *s, const unsigned char* in, size_t instart, size_t inend, CostModelFun* costmodel, void* costcontext, unsigned short* length_array, ZopfliHash* h, float* costs) { /* Best cost to get here so far. */ size_t blocksize = inend - instart; size_t i = 0, k, kend; unsigned short leng; unsigned short dist; unsigned short sublen[259]; size_t windowstart = instart > ZOPFLI_WINDOW_SIZE ? instart - ZOPFLI_WINDOW_SIZE : 0; double result; double mincost = GetCostModelMinCost(costmodel, costcontext); double mincostaddcostj; if (instart == inend) return 0; ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h); ZopfliWarmupHash(in, windowstart, inend, h); for (i = windowstart; i < instart; i++) { ZopfliUpdateHash(in, i, inend, h); } for (i = 1; i < blocksize + 1; i++) costs[i] = ZOPFLI_LARGE_FLOAT; costs[0] = 0; /* Because it's the start. */ length_array[0] = 0; for (i = instart; i < inend; i++) { size_t j = i - instart; /* Index in the costs array and length_array. */ ZopfliUpdateHash(in, i, inend, h); #ifdef ZOPFLI_SHORTCUT_LONG_REPETITIONS /* If we're in a long repetition of the same character and have more than ZOPFLI_MAX_MATCH characters before and after our position. */ if (h->same[i & ZOPFLI_WINDOW_MASK] > ZOPFLI_MAX_MATCH * 2 && i > instart + ZOPFLI_MAX_MATCH + 1 && i + ZOPFLI_MAX_MATCH * 2 + 1 < inend && h->same[(i - ZOPFLI_MAX_MATCH) & ZOPFLI_WINDOW_MASK] > ZOPFLI_MAX_MATCH) { double symbolcost = costmodel(ZOPFLI_MAX_MATCH, 1, costcontext); /* Set the length to reach each one to ZOPFLI_MAX_MATCH, and the cost to the cost corresponding to that length. Doing this, we skip ZOPFLI_MAX_MATCH values to avoid calling ZopfliFindLongestMatch. */ for (k = 0; k < ZOPFLI_MAX_MATCH; k++) { costs[j + ZOPFLI_MAX_MATCH] = costs[j] + symbolcost; length_array[j + ZOPFLI_MAX_MATCH] = ZOPFLI_MAX_MATCH; i++; j++; ZopfliUpdateHash(in, i, inend, h); } } #endif ZopfliFindLongestMatch(s, h, in, i, inend, ZOPFLI_MAX_MATCH, sublen, &dist, &leng); /* Literal. */ if (i + 1 <= inend) { double newCost = costmodel(in[i], 0, costcontext) + costs[j]; assert(newCost >= 0); if (newCost < costs[j + 1]) { costs[j + 1] = newCost; length_array[j + 1] = 1; } } /* Lengths. */ kend = zopfli_min(leng, inend-i); mincostaddcostj = mincost + costs[j]; for (k = 3; k <= kend; k++) { double newCost; /* Calling the cost model is expensive, avoid this if we are already at the minimum possible cost that it can return. */ if (costs[j + k] <= mincostaddcostj) continue; newCost = costmodel(k, sublen[k], costcontext) + costs[j]; assert(newCost >= 0); if (newCost < costs[j + k]) { assert(k <= ZOPFLI_MAX_MATCH); costs[j + k] = newCost; length_array[j + k] = k; } } } assert(costs[blocksize] >= 0); result = costs[blocksize]; return result; } /* Calculates the optimal path of lz77 lengths to use, from the calculated length_array. The length_array must contain the optimal length to reach that byte. The path will be filled with the lengths to use, so its data size will be the amount of lz77 symbols. */ static void TraceBackwards(size_t size, const unsigned short* length_array, unsigned short** path, size_t* pathsize) { size_t index = size; if (size == 0) return; for (;;) { ZOPFLI_APPEND_DATA(length_array[index], path, pathsize); assert(length_array[index] <= index); assert(length_array[index] <= ZOPFLI_MAX_MATCH); assert(length_array[index] != 0); index -= length_array[index]; if (index == 0) break; } /* Mirror result. */ for (index = 0; index < *pathsize / 2; index++) { unsigned short temp = (*path)[index]; (*path)[index] = (*path)[*pathsize - index - 1]; (*path)[*pathsize - index - 1] = temp; } } static void FollowPath(ZopfliBlockState* s, const unsigned char* in, size_t instart, size_t inend, unsigned short* path, size_t pathsize, ZopfliLZ77Store* store, ZopfliHash *h) { size_t i, j, pos = 0; size_t windowstart = instart > ZOPFLI_WINDOW_SIZE ? instart - ZOPFLI_WINDOW_SIZE : 0; size_t total_length_test = 0; if (instart == inend) return; ZopfliResetHash(ZOPFLI_WINDOW_SIZE, h); ZopfliWarmupHash(in, windowstart, inend, h); for (i = windowstart; i < instart; i++) { ZopfliUpdateHash(in, i, inend, h); } pos = instart; for (i = 0; i < pathsize; i++) { unsigned short length = path[i]; unsigned short dummy_length; unsigned short dist; assert(pos < inend); ZopfliUpdateHash(in, pos, inend, h); /* Add to output. */ if (length >= ZOPFLI_MIN_MATCH) { /* Get the distance by recalculating longest match. The found length should match the length from the path. */ ZopfliFindLongestMatch(s, h, in, pos, inend, length, 0, &dist, &dummy_length); assert(!(dummy_length != length && length > 2 && dummy_length > 2)); ZopfliVerifyLenDist(in, inend, pos, dist, length); ZopfliStoreLitLenDist(length, dist, pos, store); total_length_test += length; } else { length = 1; ZopfliStoreLitLenDist(in[pos], 0, pos, store); total_length_test++; } assert(pos + length <= inend); for (j = 1; j < length; j++) { ZopfliUpdateHash(in, pos + j, inend, h); } pos += length; } } /* Calculates the entropy of the statistics */ static void CalculateStatistics(SymbolStats* stats) { ZopfliCalculateEntropy(stats->litlens, ZOPFLI_NUM_LL, stats->ll_symbols); ZopfliCalculateEntropy(stats->dists, ZOPFLI_NUM_D, stats->d_symbols); } /* Appends the symbol statistics from the store. */ static void GetStatistics(const ZopfliLZ77Store* store, SymbolStats* stats) { size_t i; for (i = 0; i < store->size; i++) { if (store->dists[i] == 0) { stats->litlens[store->litlens[i]]++; } else { stats->litlens[ZopfliGetLengthSymbol(store->litlens[i])]++; stats->dists[ZopfliGetDistSymbol(store->dists[i])]++; } } stats->litlens[256] = 1; /* End symbol. */ CalculateStatistics(stats); } /* Does a single run for ZopfliLZ77Optimal. For good compression, repeated runs with updated statistics should be performed. s: the block state in: the input data array instart: where to start inend: where to stop (not inclusive) path: pointer to dynamically allocated memory to store the path pathsize: pointer to the size of the dynamic path array length_array: array of size (inend - instart) used to store lengths costmodel: function to use as the cost model for this squeeze run costcontext: abstract context for the costmodel function store: place to output the LZ77 data returns the cost that was, according to the costmodel, needed to get to the end. This is not the actual cost. */ static double LZ77OptimalRun(ZopfliBlockState* s, const unsigned char* in, size_t instart, size_t inend, unsigned short** path, size_t* pathsize, unsigned short* length_array, CostModelFun* costmodel, void* costcontext, ZopfliLZ77Store* store, ZopfliHash* h, float* costs) { double cost = GetBestLengths(s, in, instart, inend, costmodel, costcontext, length_array, h, costs); free(*path); *path = 0; *pathsize = 0; TraceBackwards(inend - instart, length_array, path, pathsize); FollowPath(s, in, instart, inend, *path, *pathsize, store, h); assert(cost < ZOPFLI_LARGE_FLOAT); return cost; } void ZopfliLZ77Optimal(ZopfliBlockState *s, const unsigned char* in, size_t instart, size_t inend, int numiterations, ZopfliLZ77Store* store) { /* Dist to get to here with smallest cost. */ size_t blocksize = inend - instart; unsigned short* length_array = (unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1)); unsigned short* path = 0; size_t pathsize = 0; ZopfliLZ77Store currentstore; ZopfliHash hash; ZopfliHash* h = &hash; SymbolStats stats, beststats, laststats; int i; float* costs = (float*)malloc(sizeof(float) * (blocksize + 1)); double cost; double bestcost = ZOPFLI_LARGE_FLOAT; double lastcost = 0; /* Try randomizing the costs a bit once the size stabilizes. */ RanState ran_state; int lastrandomstep = -1; if (!costs) exit(-1); /* Allocation failed. */ if (!length_array) exit(-1); /* Allocation failed. */ InitRanState(&ran_state); InitStats(&stats); ZopfliInitLZ77Store(in, ¤tstore); ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h); /* Do regular deflate, then loop multiple shortest path runs, each time using the statistics of the previous run. */ /* Initial run. */ ZopfliLZ77Greedy(s, in, instart, inend, ¤tstore, h); GetStatistics(¤tstore, &stats); /* Repeat statistics with each time the cost model from the previous stat run. */ for (i = 0; i < numiterations; i++) { ZopfliCleanLZ77Store(¤tstore); ZopfliInitLZ77Store(in, ¤tstore); LZ77OptimalRun(s, in, instart, inend, &path, &pathsize, length_array, GetCostStat, (void*)&stats, ¤tstore, h, costs); cost = ZopfliCalculateBlockSize(¤tstore, 0, currentstore.size, 2); if (s->options->verbose_more || (s->options->verbose && cost < bestcost)) { fprintf(stderr, "Iteration %d: %d bit\n", i, (int) cost); } if (cost < bestcost) { /* Copy to the output store. */ ZopfliCopyLZ77Store(¤tstore, store); CopyStats(&stats, &beststats); bestcost = cost; } CopyStats(&stats, &laststats); ClearStatFreqs(&stats); GetStatistics(¤tstore, &stats); if (lastrandomstep != -1) { /* This makes it converge slower but better. Do it only once the randomness kicks in so that if the user does few iterations, it gives a better result sooner. */ AddWeighedStatFreqs(&stats, 1.0, &laststats, 0.5, &stats); CalculateStatistics(&stats); } if (i > 5 && cost == lastcost) { CopyStats(&beststats, &stats); RandomizeStatFreqs(&ran_state, &stats); CalculateStatistics(&stats); lastrandomstep = i; } lastcost = cost; } free(length_array); free(path); free(costs); ZopfliCleanLZ77Store(¤tstore); ZopfliCleanHash(h); } void ZopfliLZ77OptimalFixed(ZopfliBlockState *s, const unsigned char* in, size_t instart, size_t inend, ZopfliLZ77Store* store) { /* Dist to get to here with smallest cost. */ size_t blocksize = inend - instart; unsigned short* length_array = (unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1)); unsigned short* path = 0; size_t pathsize = 0; ZopfliHash hash; ZopfliHash* h = &hash; float* costs = (float*)malloc(sizeof(float) * (blocksize + 1)); if (!costs) exit(-1); /* Allocation failed. */ if (!length_array) exit(-1); /* Allocation failed. */ ZopfliAllocHash(ZOPFLI_WINDOW_SIZE, h); s->blockstart = instart; s->blockend = inend; /* Shortest path for fixed tree This one should give the shortest possible result for fixed tree, no repeated runs are needed since the tree is known. */ LZ77OptimalRun(s, in, instart, inend, &path, &pathsize, length_array, GetCostFixed, 0, store, h, costs); free(length_array); free(path); free(costs); ZopfliCleanHash(h); } advancecomp-1.23/zopfli/squeeze.h000066400000000000000000000042511301462770100170570ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* The squeeze functions do enhanced LZ77 compression by optimal parsing with a cost model, rather than greedily choosing the longest length or using a single step of lazy matching like regular implementations. Since the cost model is based on the Huffman tree that can only be calculated after the LZ77 data is generated, there is a chicken and egg problem, and multiple runs are done with updated cost models to converge to a better solution. */ #ifndef ZOPFLI_SQUEEZE_H_ #define ZOPFLI_SQUEEZE_H_ #include "lz77.h" /* Calculates lit/len and dist pairs for given data. If instart is larger than 0, it uses values before instart as starting dictionary. */ void ZopfliLZ77Optimal(ZopfliBlockState *s, const unsigned char* in, size_t instart, size_t inend, int numiterations, ZopfliLZ77Store* store); /* Does the same as ZopfliLZ77Optimal, but optimized for the fixed tree of the deflate standard. The fixed tree never gives the best compression. But this gives the best possible LZ77 encoding possible with the fixed tree. This does not create or output any fixed tree, only LZ77 data optimized for using with a fixed tree. If instart is larger than 0, it uses values before instart as starting dictionary. */ void ZopfliLZ77OptimalFixed(ZopfliBlockState *s, const unsigned char* in, size_t instart, size_t inend, ZopfliLZ77Store* store); #endif /* ZOPFLI_SQUEEZE_H_ */ advancecomp-1.23/zopfli/symbols.h000066400000000000000000000207161301462770100170720ustar00rootroot00000000000000/* Copyright 2016 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Utilities for using the lz77 symbols of the deflate spec. */ #ifndef ZOPFLI_SYMBOLS_H_ #define ZOPFLI_SYMBOLS_H_ /* __has_builtin available in clang */ #ifdef __has_builtin # if __has_builtin(__builtin_clz) # define ZOPFLI_HAS_BUILTIN_CLZ # endif /* __builtin_clz available beginning with GCC 3.4 */ #elif __GNUC__ * 100 + __GNUC_MINOR__ >= 304 # define ZOPFLI_HAS_BUILTIN_CLZ #endif /* Gets the amount of extra bits for the given dist, cfr. the DEFLATE spec. */ static int ZopfliGetDistExtraBits(int dist) { #ifdef ZOPFLI_HAS_BUILTIN_CLZ if (dist < 5) return 0; return (31 ^ __builtin_clz(dist - 1)) - 1; /* log2(dist - 1) - 1 */ #else if (dist < 5) return 0; else if (dist < 9) return 1; else if (dist < 17) return 2; else if (dist < 33) return 3; else if (dist < 65) return 4; else if (dist < 129) return 5; else if (dist < 257) return 6; else if (dist < 513) return 7; else if (dist < 1025) return 8; else if (dist < 2049) return 9; else if (dist < 4097) return 10; else if (dist < 8193) return 11; else if (dist < 16385) return 12; else return 13; #endif } /* Gets value of the extra bits for the given dist, cfr. the DEFLATE spec. */ static int ZopfliGetDistExtraBitsValue(int dist) { #ifdef ZOPFLI_HAS_BUILTIN_CLZ if (dist < 5) { return 0; } else { int l = 31 ^ __builtin_clz(dist - 1); /* log2(dist - 1) */ return (dist - (1 + (1 << l))) & ((1 << (l - 1)) - 1); } #else if (dist < 5) return 0; else if (dist < 9) return (dist - 5) & 1; else if (dist < 17) return (dist - 9) & 3; else if (dist < 33) return (dist - 17) & 7; else if (dist < 65) return (dist - 33) & 15; else if (dist < 129) return (dist - 65) & 31; else if (dist < 257) return (dist - 129) & 63; else if (dist < 513) return (dist - 257) & 127; else if (dist < 1025) return (dist - 513) & 255; else if (dist < 2049) return (dist - 1025) & 511; else if (dist < 4097) return (dist - 2049) & 1023; else if (dist < 8193) return (dist - 4097) & 2047; else if (dist < 16385) return (dist - 8193) & 4095; else return (dist - 16385) & 8191; #endif } /* Gets the symbol for the given dist, cfr. the DEFLATE spec. */ static int ZopfliGetDistSymbol(int dist) { #ifdef ZOPFLI_HAS_BUILTIN_CLZ if (dist < 5) { return dist - 1; } else { int l = (31 ^ __builtin_clz(dist - 1)); /* log2(dist - 1) */ int r = ((dist - 1) >> (l - 1)) & 1; return l * 2 + r; } #else if (dist < 193) { if (dist < 13) { /* dist 0..13. */ if (dist < 5) return dist - 1; else if (dist < 7) return 4; else if (dist < 9) return 5; else return 6; } else { /* dist 13..193. */ if (dist < 17) return 7; else if (dist < 25) return 8; else if (dist < 33) return 9; else if (dist < 49) return 10; else if (dist < 65) return 11; else if (dist < 97) return 12; else if (dist < 129) return 13; else return 14; } } else { if (dist < 2049) { /* dist 193..2049. */ if (dist < 257) return 15; else if (dist < 385) return 16; else if (dist < 513) return 17; else if (dist < 769) return 18; else if (dist < 1025) return 19; else if (dist < 1537) return 20; else return 21; } else { /* dist 2049..32768. */ if (dist < 3073) return 22; else if (dist < 4097) return 23; else if (dist < 6145) return 24; else if (dist < 8193) return 25; else if (dist < 12289) return 26; else if (dist < 16385) return 27; else if (dist < 24577) return 28; else return 29; } } #endif } /* Gets the amount of extra bits for the given length, cfr. the DEFLATE spec. */ static int ZopfliGetLengthExtraBits(int l) { static const int table[259] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0 }; return table[l]; } /* Gets value of the extra bits for the given length, cfr. the DEFLATE spec. */ static int ZopfliGetLengthExtraBitsValue(int l) { static const int table[259] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 0 }; return table[l]; } /* Gets the symbol for the given length, cfr. the DEFLATE spec. Returns the symbol in the range [257-285] (inclusive) */ static int ZopfliGetLengthSymbol(int l) { static const int table[259] = { 0, 0, 0, 257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272, 273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285 }; return table[l]; } /* Gets the amount of extra bits for the given length symbol. */ static int ZopfliGetLengthSymbolExtraBits(int s) { static const int table[29] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; return table[s - 257]; } /* Gets the amount of extra bits for the given distance symbol. */ static int ZopfliGetDistSymbolExtraBits(int s) { static const int table[30] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; return table[s]; } #endif /* ZOPFLI_SYMBOLS_H_ */ advancecomp-1.23/zopfli/tree.c000066400000000000000000000064571301462770100163420ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "tree.h" #include #include #include #include #include "katajainen.h" #include "util.h" void ZopfliLengthsToSymbols(const unsigned* lengths, size_t n, unsigned maxbits, unsigned* symbols) { size_t* bl_count = (size_t*)malloc(sizeof(size_t) * (maxbits + 1)); size_t* next_code = (size_t*)malloc(sizeof(size_t) * (maxbits + 1)); unsigned bits, i; unsigned code; for (i = 0; i < n; i++) { symbols[i] = 0; } /* 1) Count the number of codes for each code length. Let bl_count[N] be the number of codes of length N, N >= 1. */ for (bits = 0; bits <= maxbits; bits++) { bl_count[bits] = 0; } for (i = 0; i < n; i++) { assert(lengths[i] <= maxbits); bl_count[lengths[i]]++; } /* 2) Find the numerical value of the smallest code for each code length. */ code = 0; bl_count[0] = 0; for (bits = 1; bits <= maxbits; bits++) { code = (code + bl_count[bits-1]) << 1; next_code[bits] = code; } /* 3) Assign numerical values to all codes, using consecutive values for all codes of the same length with the base values determined at step 2. */ for (i = 0; i < n; i++) { unsigned len = lengths[i]; if (len != 0) { symbols[i] = next_code[len]; next_code[len]++; } } free(bl_count); free(next_code); } void ZopfliCalculateEntropy(const size_t* count, size_t n, double* bitlengths) { static const double kInvLog2 = 1.4426950408889; /* 1.0 / log(2.0) */ unsigned sum = 0; unsigned i; double log2sum; for (i = 0; i < n; ++i) { sum += count[i]; } log2sum = (sum == 0 ? log(n) : log(sum)) * kInvLog2; for (i = 0; i < n; ++i) { /* When the count of the symbol is 0, but its cost is requested anyway, it means the symbol will appear at least once anyway, so give it the cost as if its count is 1.*/ if (count[i] == 0) bitlengths[i] = log2sum; else bitlengths[i] = log2sum - log(count[i]) * kInvLog2; /* Depending on compiler and architecture, the above subtraction of two floating point numbers may give a negative result very close to zero instead of zero (e.g. -5.973954e-17 with gcc 4.1.2 on Ubuntu 11.4). Clamp it to zero. These floating point imprecisions do not affect the cost model significantly so this is ok. */ if (bitlengths[i] < 0 && bitlengths[i] > -1e-5) bitlengths[i] = 0; assert(bitlengths[i] >= 0); } } void ZopfliCalculateBitLengths(const size_t* count, size_t n, int maxbits, unsigned* bitlengths) { int error = ZopfliLengthLimitedCodeLengths(count, n, maxbits, bitlengths); (void) error; assert(!error); } advancecomp-1.23/zopfli/tree.h000066400000000000000000000032151301462770100163340ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Utilities for creating and using Huffman trees. */ #ifndef ZOPFLI_TREE_H_ #define ZOPFLI_TREE_H_ #include /* Calculates the bitlengths for the Huffman tree, based on the counts of each symbol. */ void ZopfliCalculateBitLengths(const size_t* count, size_t n, int maxbits, unsigned *bitlengths); /* Converts a series of Huffman tree bitlengths, to the bit values of the symbols. */ void ZopfliLengthsToSymbols(const unsigned* lengths, size_t n, unsigned maxbits, unsigned* symbols); /* Calculates the entropy of each symbol, based on the counts of each symbol. The result is similar to the result of ZopfliCalculateBitLengths, but with the actual theoritical bit lengths according to the entropy. Since the resulting values are fractional, they cannot be used to encode the tree specified by DEFLATE. */ void ZopfliCalculateEntropy(const size_t* count, size_t n, double* bitlengths); #endif /* ZOPFLI_TREE_H_ */ advancecomp-1.23/zopfli/util.c000066400000000000000000000017771301462770100163600ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "util.h" #include "zopfli.h" #include #include #include void ZopfliInitOptions(ZopfliOptions* options) { options->verbose = 0; options->verbose_more = 0; options->numiterations = 15; options->blocksplitting = 1; options->blocksplittinglast = 0; options->blocksplittingmax = 15; } advancecomp-1.23/zopfli/util.h000066400000000000000000000125521301462770100163560ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Several utilities, including: #defines to try different compression results, basic deflate specification values and generic program options. */ #ifndef ZOPFLI_UTIL_H_ #define ZOPFLI_UTIL_H_ #include #include /* Minimum and maximum length that can be encoded in deflate. */ #define ZOPFLI_MAX_MATCH 258 #define ZOPFLI_MIN_MATCH 3 /* Number of distinct literal/length and distance symbols in DEFLATE */ #define ZOPFLI_NUM_LL 288 #define ZOPFLI_NUM_D 32 /* The window size for deflate. Must be a power of two. This should be 32768, the maximum possible by the deflate spec. Anything less hurts compression more than speed. */ #define ZOPFLI_WINDOW_SIZE 32768 /* The window mask used to wrap indices into the window. This is why the window size must be a power of two. */ #define ZOPFLI_WINDOW_MASK (ZOPFLI_WINDOW_SIZE - 1) /* A block structure of huge, non-smart, blocks to divide the input into, to allow operating on huge files without exceeding memory, such as the 1GB wiki9 corpus. The whole compression algorithm, including the smarter block splitting, will be executed independently on each huge block. Dividing into huge blocks hurts compression, but not much relative to the size. Set it to 0 to disable master blocks. */ #define ZOPFLI_MASTER_BLOCK_SIZE 1000000 /* Used to initialize costs for example */ #define ZOPFLI_LARGE_FLOAT 1e30 /* For longest match cache. max 256. Uses huge amounts of memory but makes it faster. Uses this many times three bytes per single byte of the input data. This is so because longest match finding has to find the exact distance that belongs to each length for the best lz77 strategy. Good values: e.g. 5, 8. */ #define ZOPFLI_CACHE_LENGTH 8 /* limit the max hash chain hits for this hash value. This has an effect only on files where the hash value is the same very often. On these files, this gives worse compression (the value should ideally be 32768, which is the ZOPFLI_WINDOW_SIZE, while zlib uses 4096 even for best level), but makes it faster on some specific files. Good value: e.g. 8192. */ #define ZOPFLI_MAX_CHAIN_HITS 8192 /* Whether to use the longest match cache for ZopfliFindLongestMatch. This cache consumes a lot of memory but speeds it up. No effect on compression size. */ #define ZOPFLI_LONGEST_MATCH_CACHE /* Enable to remember amount of successive identical bytes in the hash chain for finding longest match required for ZOPFLI_HASH_SAME_HASH and ZOPFLI_SHORTCUT_LONG_REPETITIONS This has no effect on the compression result, and enabling it increases speed. */ #define ZOPFLI_HASH_SAME /* Switch to a faster hash based on the info from ZOPFLI_HASH_SAME once the best length so far is long enough. This is way faster for files with lots of identical bytes, on which the compressor is otherwise too slow. Regular files are unaffected or maybe a tiny bit slower. This has no effect on the compression result, only on speed. */ #define ZOPFLI_HASH_SAME_HASH /* Enable this, to avoid slowness for files which are a repetition of the same character more than a multiple of ZOPFLI_MAX_MATCH times. This should not affect the compression result. */ #define ZOPFLI_SHORTCUT_LONG_REPETITIONS /* Whether to use lazy matching in the greedy LZ77 implementation. This gives a better result of ZopfliLZ77Greedy, but the effect this has on the optimal LZ77 varies from file to file. */ #define ZOPFLI_LAZY_MATCHING /* Appends value to dynamically allocated memory, doubling its allocation size whenever needed. value: the value to append, type T data: pointer to the dynamic array to append to, type T** size: pointer to the size of the array to append to, type size_t*. This is the size that you consider the array to be, not the internal allocation size. Precondition: allocated size of data is at least a power of two greater than or equal than *size. */ #ifdef __cplusplus /* C++ cannot assign void* from malloc to *data */ #define ZOPFLI_APPEND_DATA(/* T */ value, /* T** */ data, /* size_t* */ size) {\ if (!((*size) & ((*size) - 1))) {\ /*double alloc size if it's a power of two*/\ void** data_void = reinterpret_cast(data);\ *data_void = (*size) == 0 ? malloc(sizeof(**data))\ : realloc((*data), (*size) * 2 * sizeof(**data));\ }\ (*data)[(*size)] = (value);\ (*size)++;\ } #else /* C gives problems with strict-aliasing rules for (void**) cast */ #define ZOPFLI_APPEND_DATA(/* T */ value, /* T** */ data, /* size_t* */ size) {\ if (!((*size) & ((*size) - 1))) {\ /*double alloc size if it's a power of two*/\ (*data) = (*size) == 0 ? malloc(sizeof(**data))\ : realloc((*data), (*size) * 2 * sizeof(**data));\ }\ (*data)[(*size)] = (value);\ (*size)++;\ } #endif #endif /* ZOPFLI_UTIL_H_ */ advancecomp-1.23/zopfli/zlib_container.c000066400000000000000000000045571301462770100204040ustar00rootroot00000000000000/* Copyright 2013 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "zlib_container.h" #include "util.h" #include #include "deflate.h" /* Calculates the adler32 checksum of the data */ static unsigned adler32(const unsigned char* data, size_t size) { static const unsigned sums_overflow = 5550; unsigned s1 = 1; unsigned s2 = 1 >> 16; while (size > 0) { size_t amount = size > sums_overflow ? sums_overflow : size; size -= amount; while (amount > 0) { s1 += (*data++); s2 += s1; amount--; } s1 %= 65521; s2 %= 65521; } return (s2 << 16) | s1; } void ZopfliZlibCompress(const ZopfliOptions* options, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize) { unsigned char bitpointer = 0; unsigned checksum = adler32(in, (unsigned)insize); unsigned cmf = 120; /* CM 8, CINFO 7. See zlib spec.*/ unsigned flevel = 3; unsigned fdict = 0; unsigned cmfflg = 256 * cmf + fdict * 32 + flevel * 64; unsigned fcheck = 31 - cmfflg % 31; cmfflg += fcheck; ZOPFLI_APPEND_DATA(cmfflg / 256, out, outsize); ZOPFLI_APPEND_DATA(cmfflg % 256, out, outsize); ZopfliDeflate(options, 2 /* dynamic block */, 1 /* final */, in, insize, &bitpointer, out, outsize); ZOPFLI_APPEND_DATA((checksum >> 24) % 256, out, outsize); ZOPFLI_APPEND_DATA((checksum >> 16) % 256, out, outsize); ZOPFLI_APPEND_DATA((checksum >> 8) % 256, out, outsize); ZOPFLI_APPEND_DATA(checksum % 256, out, outsize); if (options->verbose) { fprintf(stderr, "Original Size: %d, Zlib: %d, Compression: %f%% Removed\n", (int)insize, (int)*outsize, 100.0 * (double)(insize - *outsize) / (double)insize); } } advancecomp-1.23/zopfli/zlib_container.h000066400000000000000000000025721301462770100204040ustar00rootroot00000000000000/* Copyright 2013 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #ifndef ZOPFLI_ZLIB_H_ #define ZOPFLI_ZLIB_H_ /* Functions to compress according to the Zlib specification. */ #include "zopfli.h" #ifdef __cplusplus extern "C" { #endif /* Compresses according to the zlib specification and append the compressed result to the output. options: global program options out: pointer to the dynamic output array to which the result is appended. Must be freed after use. outsize: pointer to the dynamic output array size. */ void ZopfliZlibCompress(const ZopfliOptions* options, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize); #ifdef __cplusplus } // extern "C" #endif #endif /* ZOPFLI_ZLIB_H_ */ advancecomp-1.23/zopfli/zopfli.h000066400000000000000000000047501301462770100167050ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #ifndef ZOPFLI_ZOPFLI_H_ #define ZOPFLI_ZOPFLI_H_ #include #include /* for size_t */ #ifdef __cplusplus extern "C" { #endif /* Options used throughout the program. */ typedef struct ZopfliOptions { /* Whether to print output */ int verbose; /* Whether to print more detailed output */ int verbose_more; /* Maximum amount of times to rerun forward and backward pass to optimize LZ77 compression cost. Good values: 10, 15 for small files, 5 for files over several MB in size or it will be too slow. */ int numiterations; /* If true, splits the data in multiple deflate blocks with optimal choice for the block boundaries. Block splitting gives better compression. Default: true (1). */ int blocksplitting; /* No longer used, left for compatibility. */ int blocksplittinglast; /* Maximum amount of blocks to split into (0 for unlimited, but this can give extreme results that hurt compression on some files). Default value: 15. */ int blocksplittingmax; } ZopfliOptions; /* Initializes options with default values. */ void ZopfliInitOptions(ZopfliOptions* options); /* Output format */ typedef enum { ZOPFLI_FORMAT_GZIP, ZOPFLI_FORMAT_ZLIB, ZOPFLI_FORMAT_DEFLATE } ZopfliFormat; /* Compresses according to the given output format and appends the result to the output. options: global program options output_type: the output format to use out: pointer to the dynamic output array to which the result is appended. Must be freed after use outsize: pointer to the dynamic output array size */ void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize); #ifdef __cplusplus } // extern "C" #endif #endif /* ZOPFLI_ZOPFLI_H_ */ advancecomp-1.23/zopfli/zopfli_bin.c000066400000000000000000000144061301462770100175270ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ /* Zopfli compressor program. It can output gzip-, zlib- or deflate-compatible data. By default it creates a .gz file. This tool can only compress, not decompress. Decompression can be done by any standard gzip, zlib or deflate decompressor. */ #include #include #include #include #include "deflate.h" #include "gzip_container.h" #include "zlib_container.h" /* Windows workaround for stdout output. */ #if _WIN32 #include #endif /* Loads a file into a memory array. Returns 1 on success, 0 if file doesn't exist or couldn't be opened. */ static int LoadFile(const char* filename, unsigned char** out, size_t* outsize) { FILE* file; *out = 0; *outsize = 0; file = fopen(filename, "rb"); if (!file) return 0; fseek(file , 0 , SEEK_END); *outsize = ftell(file); if(*outsize > 2147483647) { fprintf(stderr,"Files larger than 2GB are not supported.\n"); exit(EXIT_FAILURE); } rewind(file); *out = (unsigned char*)malloc(*outsize); if (*outsize && (*out)) { size_t testsize = fread(*out, 1, *outsize, file); if (testsize != *outsize) { /* It could be a directory */ free(*out); *out = 0; *outsize = 0; fclose(file); return 0; } } assert(!(*outsize) || out); /* If size is not zero, out must be allocated. */ fclose(file); return 1; } /* Saves a file from a memory array, overwriting the file if it existed. */ static void SaveFile(const char* filename, const unsigned char* in, size_t insize) { FILE* file = fopen(filename, "wb" ); if (file == NULL) { fprintf(stderr,"Error: Cannot write to output file, terminating.\n"); exit (EXIT_FAILURE); } assert(file); fwrite((char*)in, 1, insize, file); fclose(file); } /* outfilename: filename to write output to, or 0 to write to stdout instead */ static void CompressFile(const ZopfliOptions* options, ZopfliFormat output_type, const char* infilename, const char* outfilename) { unsigned char* in; size_t insize; unsigned char* out = 0; size_t outsize = 0; if (!LoadFile(infilename, &in, &insize)) { fprintf(stderr, "Invalid filename: %s\n", infilename); return; } ZopfliCompress(options, output_type, in, insize, &out, &outsize); if (outfilename) { SaveFile(outfilename, out, outsize); } else { size_t i; #if _WIN32 /* Windows workaround for stdout output. */ _setmode(_fileno(stdout), _O_BINARY); #endif for (i = 0; i < outsize; i++) { printf("%c", out[i]); } } free(out); free(in); } /* Add two strings together. Size does not matter. Result must be freed. */ static char* AddStrings(const char* str1, const char* str2) { size_t len = strlen(str1) + strlen(str2); char* result = (char*)malloc(len + 1); if (!result) exit(-1); /* Allocation failed. */ strcpy(result, str1); strcat(result, str2); return result; } static char StringsEqual(const char* str1, const char* str2) { return strcmp(str1, str2) == 0; } int main(int argc, char* argv[]) { ZopfliOptions options; ZopfliFormat output_type = ZOPFLI_FORMAT_GZIP; const char* filename = 0; int output_to_stdout = 0; int i; ZopfliInitOptions(&options); for (i = 1; i < argc; i++) { const char* arg = argv[i]; if (StringsEqual(arg, "-v")) options.verbose = 1; else if (StringsEqual(arg, "-c")) output_to_stdout = 1; else if (StringsEqual(arg, "--deflate")) { output_type = ZOPFLI_FORMAT_DEFLATE; } else if (StringsEqual(arg, "--zlib")) output_type = ZOPFLI_FORMAT_ZLIB; else if (StringsEqual(arg, "--gzip")) output_type = ZOPFLI_FORMAT_GZIP; else if (StringsEqual(arg, "--splitlast")) /* Ignore */; else if (arg[0] == '-' && arg[1] == '-' && arg[2] == 'i' && arg[3] >= '0' && arg[3] <= '9') { options.numiterations = atoi(arg + 3); } else if (StringsEqual(arg, "-h")) { fprintf(stderr, "Usage: zopfli [OPTION]... FILE...\n" " -h gives this help\n" " -c write the result on standard output, instead of disk" " filename + '.gz'\n" " -v verbose mode\n" " --i# perform # iterations (default 15). More gives" " more compression but is slower." " Examples: --i10, --i50, --i1000\n"); fprintf(stderr, " --gzip output to gzip format (default)\n" " --zlib output to zlib format instead of gzip\n" " --deflate output to deflate format instead of gzip\n" " --splitlast ignored, left for backwards compatibility\n"); return 0; } } if (options.numiterations < 1) { fprintf(stderr, "Error: must have 1 or more iterations\n"); return 0; } for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { char* outfilename; filename = argv[i]; if (output_to_stdout) { outfilename = 0; } else if (output_type == ZOPFLI_FORMAT_GZIP) { outfilename = AddStrings(filename, ".gz"); } else if (output_type == ZOPFLI_FORMAT_ZLIB) { outfilename = AddStrings(filename, ".zlib"); } else { assert(output_type == ZOPFLI_FORMAT_DEFLATE); outfilename = AddStrings(filename, ".deflate"); } if (options.verbose && outfilename) { fprintf(stderr, "Saving to: %s\n", outfilename); } CompressFile(&options, output_type, filename, outfilename); free(outfilename); } } if (!filename) { fprintf(stderr, "Please provide filename\nFor help, type: %s -h\n", argv[0]); } return 0; } advancecomp-1.23/zopfli/zopfli_lib.c000066400000000000000000000026241301462770100175240ustar00rootroot00000000000000/* Copyright 2011 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Author: lode.vandevenne@gmail.com (Lode Vandevenne) Author: jyrki.alakuijala@gmail.com (Jyrki Alakuijala) */ #include "zopfli.h" #include "deflate.h" #include "gzip_container.h" #include "zlib_container.h" #include void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type, const unsigned char* in, size_t insize, unsigned char** out, size_t* outsize) { if (output_type == ZOPFLI_FORMAT_GZIP) { ZopfliGzipCompress(options, in, insize, out, outsize); } else if (output_type == ZOPFLI_FORMAT_ZLIB) { ZopfliZlibCompress(options, in, insize, out, outsize); } else if (output_type == ZOPFLI_FORMAT_DEFLATE) { unsigned char bp = 0; ZopfliDeflate(options, 2 /* Dynamic block */, 1, in, insize, &bp, out, outsize); } else { assert(0); } }