pax_global_header00006660000000000000000000000064136543433770014531gustar00rootroot0000000000000052 comment=2643ac3ac0cf8eb457aa71026952c91c4c862dfd bitstring-bitstring-3.1.7/000077500000000000000000000000001365434337700155515ustar00rootroot00000000000000bitstring-bitstring-3.1.7/.travis.yml000066400000000000000000000001741365434337700176640ustar00rootroot00000000000000language: python python: - "2.7" - "3.4" - "3.5" - "3.6" install: - pip install . script: - cd test; py.test bitstring-bitstring-3.1.7/LICENSE000066400000000000000000000021271365434337700165600ustar00rootroot00000000000000The MIT License Copyright (c) 2006-2016 Scott Griffiths (dr.scottgriffiths@gmail.com) 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. bitstring-bitstring-3.1.7/MANIFEST.in000066400000000000000000000001701365434337700173050ustar00rootroot00000000000000include test/test.m1v include test/smalltestfile include release_notes.txt include README.rst prune doc include LICENSE bitstring-bitstring-3.1.7/README.rst000066400000000000000000000050671365434337700172500ustar00rootroot00000000000000 .. image:: /doc/bitstring_logo_small.png **bitstring** is a pure Python module designed to help make the creation and analysis of binary data as simple and natural as possible. Bitstrings can be constructed from integers (big and little endian), hex, octal, binary, strings or files. They can be sliced, joined, reversed, inserted into, overwritten, etc. with simple functions or slice notation. They can also be read from, searched and replaced, and navigated in, similar to a file or stream. bitstring is open source software, and has been released under the MIT licence. This module works in both Python 2.7 and Python 3. Installation ------------ Probably all you need to do is:: pip install bitstring Alternatively if you have downloaded and unzipped the package then you need to run the ``setup.py`` script with the 'install' argument:: python setup.py install You may need to run this with root privileges on Unix-like systems. Documentation ------------- The manual for the bitstring module is available here . It contains a walk-through of all the features and a complete reference section. It is also available as a PDF at . Simple Examples --------------- Creation:: >>> a = BitArray(bin='00101') >>> b = Bits(a_file_object) >>> c = BitArray('0xff, 0b101, 0o65, uint:6=22') >>> d = pack('intle:16, hex=a, 0b1', 100, a='0x34f') >>> e = pack('<16h', *range(16)) Different interpretations, slicing and concatenation:: >>> a = BitArray('0x1af') >>> a.hex, a.bin, a.uint ('1af', '000110101111', 431) >>> a[10:3:-1].bin '1110101' >>> 3*a + '0b100' BitArray('0o0657056705674') Reading data sequentially:: >>> b = BitStream('0x160120f') >>> b.read(12).hex '160' >>> b.pos = 0 >>> b.read('uint:12') 352 >>> b.readlist('uint:12, bin:3') [288, '111'] Searching, inserting and deleting:: >>> c = BitArray('0b00010010010010001111') # c.hex == '0x1248f' >>> c.find('0x48') (8,) >>> c.replace('0b001', '0xabc') >>> c.insert('0b0000') >>> del c[12:16] Unit Tests ---------- The 500+ unit tests should all pass for Python 2.7 and later. To run them, from the `test` directory run:: python -m unittest discover ---- The bitstring module has been released as open source under the MIT License. Copyright (c) 2008-2020 Scott Griffiths For more information see the project's homepage on GitHub: bitstring-bitstring-3.1.7/bitstring.py000066400000000000000000005177561365434337700201550ustar00rootroot00000000000000#!/usr/bin/env python """ This package defines classes that simplify bit-wise creation, manipulation and interpretation of data. Classes: Bits -- An immutable container for binary data. BitArray -- A mutable container for binary data. ConstBitStream -- An immutable container with streaming methods. BitStream -- A mutable container with streaming methods. Bits (base class) / \ + mutating methods / \ + streaming methods / \ BitArray ConstBitStream \ / \ / \ / BitStream Functions: pack -- Create a BitStream from a format string. Exceptions: Error -- Module exception base class. CreationError -- Error during creation. InterpretError -- Inappropriate interpretation of binary data. ByteAlignError -- Whole byte position or length needed. ReadError -- Reading or peeking past the end of a bitstring. https://github.com/scott-griffiths/bitstring """ __licence__ = """ The MIT License Copyright (c) 2006-2020 Scott Griffiths (dr.scottgriffiths@gmail.com) 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. """ __version__ = "3.1.7" __author__ = "Scott Griffiths" import numbers import copy import sys import re import binascii import mmap import os import struct import operator import array import io import collections try: collectionsAbc = collections.abc except AttributeError: # Python 2.7 collectionsAbc = collections byteorder = sys.byteorder bytealigned = False """Determines whether a number of methods default to working only on byte boundaries.""" # Maximum number of digits to use in __str__ and __repr__. MAX_CHARS = 250 # Maximum size of caches used for speed optimisations. CACHE_SIZE = 1000 class Error(Exception): """Base class for errors in the bitstring module.""" def __init__(self, *params): self.msg = params[0] if params else '' self.params = params[1:] def __str__(self): if self.params: return self.msg.format(*self.params) return self.msg class ReadError(Error, IndexError): """Reading or peeking past the end of a bitstring.""" def __init__(self, *params): Error.__init__(self, *params) class InterpretError(Error, ValueError): """Inappropriate interpretation of binary data.""" def __init__(self, *params): Error.__init__(self, *params) class ByteAlignError(Error): """Whole-byte position or length needed.""" def __init__(self, *params): Error.__init__(self, *params) class CreationError(Error, ValueError): """Inappropriate argument during bitstring creation.""" def __init__(self, *params): Error.__init__(self, *params) class ConstByteStore(object): """Stores raw bytes together with a bit offset and length. Used internally - not part of public interface. """ __slots__ = ('offset', '_rawarray', 'bitlength') def __init__(self, data, bitlength=None, offset=None): """data is either a bytearray or a MmapByteArray""" self._rawarray = data if offset is None: offset = 0 if bitlength is None: bitlength = 8 * len(data) - offset self.offset = offset self.bitlength = bitlength def __iter__(self): start_byte, start_bit = divmod(self.offset, 8) end_byte, end_bit = divmod(self.offset + self.bitlength, 8) for byte_index in xrange(start_byte, end_byte): byte = self._rawarray[byte_index] for bit in range(start_bit, 8): yield bool(byte & (128 >> bit)) start_bit = 0 if end_bit: byte = self._rawarray[end_byte] for bit in range(start_bit, end_bit): yield bool(byte & (128 >> bit)) def _getbit_lsb0(self, pos): assert 0 <= pos < self.bitlength pos = self.bitlength - pos - 1 byte, bit = divmod(self.offset + pos, 8) return bool(self._rawarray[byte] & (128 >> bit)) def _getbit_msb0(self, pos): assert 0 <= pos < self.bitlength byte, bit = divmod(self.offset + pos, 8) return bool(self._rawarray[byte] & (128 >> bit)) def getbyte(self, pos): """Direct access to byte data.""" return self._rawarray[pos] def getbyteslice(self, start, end): """Direct access to byte data.""" c = self._rawarray[start:end] return c @property def bytelength(self): if not self.bitlength: return 0 sb = self.offset // 8 eb = (self.offset + self.bitlength - 1) // 8 return eb - sb + 1 def __copy__(self): return ByteStore(self._rawarray[:], self.bitlength, self.offset) def _appendstore(self, store): """Join another store on to the end of this one.""" if not store.bitlength: return # Set new array offset to the number of bits in the final byte of current array. store = offsetcopy(store, (self.offset + self.bitlength) % 8) if store.offset: # first do the byte with the join. joinval = (self._rawarray.pop() & (255 ^ (255 >> store.offset)) | (store.getbyte(0) & (255 >> store.offset))) self._rawarray.append(joinval) self._rawarray.extend(store._rawarray[1:]) else: self._rawarray.extend(store._rawarray) self.bitlength += store.bitlength def _prependstore(self, store): """Join another store on to the start of this one.""" if not store.bitlength: return # Set the offset of copy of store so that it's final byte # ends in a position that matches the offset of self, # then join self on to the end of it. store = offsetcopy(store, (self.offset - store.bitlength) % 8) assert (store.offset + store.bitlength) % 8 == self.offset % 8 bit_offset = self.offset % 8 if bit_offset: # first do the byte with the join. joinval = (store.getbyte(-1) & (255 ^ (255 >> bit_offset)) | (self._rawarray[self.byteoffset] & (255 >> bit_offset))) store._rawarray[-1] = joinval store._rawarray.extend(self._rawarray[self.byteoffset + 1: self.byteoffset + self.bytelength]) else: store._rawarray.extend(self._rawarray[self.byteoffset: self.byteoffset + self.bytelength]) self._rawarray = store._rawarray self.offset = store.offset self.bitlength += store.bitlength @property def byteoffset(self): return self.offset // 8 @property def rawbytes(self): return self._rawarray class ByteStore(ConstByteStore): """Adding mutating methods to ConstByteStore Used internally - not part of public interface. """ __slots__ = () def _setbit_lsb0(self, pos): assert 0 <= pos < self.bitlength pos = self.bitlength - pos - 1 byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] |= (128 >> bit) def _setbit_msb0(self, pos): assert 0 <= pos < self.bitlength byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] |= (128 >> bit) def _unsetbit_lsb0(self, pos): assert 0 <= pos < self.bitlength pos = self.bitlength - pos - 1 byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] &= ~(128 >> bit) def _unsetbit_msb0(self, pos): assert 0 <= pos < self.bitlength byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] &= ~(128 >> bit) def _invertbit_lsb0(self, pos): assert 0 <= pos < self.bitlength pos = self.bitlength - pos - 1 byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] ^= (128 >> bit) def _invertbit_msb0(self, pos): assert 0 <= pos < self.bitlength byte, bit = divmod(self.offset + pos, 8) self._rawarray[byte] ^= (128 >> bit) def setbyte(self, pos, value): self._rawarray[pos] = value def setbyteslice(self, start, end, value): self._rawarray[start:end] = value def offsetcopy(s, newoffset): """Return a copy of a ByteStore with the newoffset. Not part of public interface. """ assert 0 <= newoffset < 8 if not s.bitlength: return copy.copy(s) else: if newoffset == s.offset % 8: return type(s)(s.getbyteslice(s.byteoffset, s.byteoffset + s.bytelength), s.bitlength, newoffset) newdata = [] d = s._rawarray assert newoffset != s.offset % 8 if newoffset < s.offset % 8: # We need to shift everything left shiftleft = s.offset % 8 - newoffset # First deal with everything except for the final byte for x in range(s.byteoffset, s.byteoffset + s.bytelength - 1): newdata.append(((d[x] << shiftleft) & 0xff) +\ (d[x + 1] >> (8 - shiftleft))) bits_in_last_byte = (s.offset + s.bitlength) % 8 if not bits_in_last_byte: bits_in_last_byte = 8 if bits_in_last_byte > shiftleft: newdata.append((d[s.byteoffset + s.bytelength - 1] << shiftleft) & 0xff) else: # newoffset > s._offset % 8 shiftright = newoffset - s.offset % 8 newdata.append(s.getbyte(0) >> shiftright) for x in range(s.byteoffset + 1, s.byteoffset + s.bytelength): newdata.append(((d[x - 1] << (8 - shiftright)) & 0xff) +\ (d[x] >> shiftright)) bits_in_last_byte = (s.offset + s.bitlength) % 8 if not bits_in_last_byte: bits_in_last_byte = 8 if bits_in_last_byte + shiftright > 8: newdata.append((d[s.byteoffset + s.bytelength - 1] << (8 - shiftright)) & 0xff) new_s = type(s)(bytearray(newdata), s.bitlength, newoffset) assert new_s.offset == newoffset return new_s def equal(a, b): """Return True if ByteStores a == b. Not part of public interface. """ # We want to return False for inequality as soon as possible, which # means we get lots of special cases. # First the easy one - compare lengths: a_bitlength = a.bitlength b_bitlength = b.bitlength if a_bitlength != b_bitlength: return False if not a_bitlength: assert b_bitlength == 0 return True # Make 'a' the one with the smaller offset if (a.offset % 8) > (b.offset % 8): a, b = b, a # and create some aliases a_bitoff = a.offset % 8 b_bitoff = b.offset % 8 a_byteoffset = a.byteoffset b_byteoffset = b.byteoffset a_bytelength = a.bytelength b_bytelength = b.bytelength da = a._rawarray db = b._rawarray # If they are pointing to the same data, they must be equal if da is db and a.offset == b.offset: return True if a_bitoff == b_bitoff: bits_spare_in_last_byte = 8 - (a_bitoff + a_bitlength) % 8 if bits_spare_in_last_byte == 8: bits_spare_in_last_byte = 0 # Special case for a, b contained in a single byte if a_bytelength == 1: a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength) b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength) return a_val == b_val # Otherwise check first byte if da[a_byteoffset] & (0xff >> a_bitoff) != db[b_byteoffset] & (0xff >> b_bitoff): return False # then everything up to the last b_a_offset = b_byteoffset - a_byteoffset for x in range(1 + a_byteoffset, a_byteoffset + a_bytelength - 1): if da[x] != db[b_a_offset + x]: return False # and finally the last byte return (da[a_byteoffset + a_bytelength - 1] >> bits_spare_in_last_byte == db[b_byteoffset + b_bytelength - 1] >> bits_spare_in_last_byte) assert a_bitoff != b_bitoff # This is how much we need to shift a to the right to compare with b: shift = b_bitoff - a_bitoff # Special case for b only one byte long if b_bytelength == 1: assert a_bytelength == 1 a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength) b_val = ((db[b_byteoffset] << b_bitoff) & 0xff) >> (8 - b_bitlength) return a_val == b_val # Special case for a only one byte long if a_bytelength == 1: assert b_bytelength == 2 a_val = ((da[a_byteoffset] << a_bitoff) & 0xff) >> (8 - a_bitlength) b_val = ((db[b_byteoffset] << 8) + db[b_byteoffset + 1]) << b_bitoff b_val &= 0xffff b_val >>= 16 - b_bitlength return a_val == b_val # Compare first byte of b with bits from first byte of a if (da[a_byteoffset] & (0xff >> a_bitoff)) >> shift != db[b_byteoffset] & (0xff >> b_bitoff): return False # Now compare every full byte of b with bits from 2 bytes of a for x in range(1, b_bytelength - 1): # Construct byte from 2 bytes in a to compare to byte in b b_val = db[b_byteoffset + x] a_val = ((da[a_byteoffset + x - 1] << 8) + da[a_byteoffset + x]) >> shift a_val &= 0xff if a_val != b_val: return False # Now check bits in final byte of b final_b_bits = (b.offset + b_bitlength) % 8 if not final_b_bits: final_b_bits = 8 b_val = db[b_byteoffset + b_bytelength - 1] >> (8 - final_b_bits) final_a_bits = (a.offset + a_bitlength) % 8 if not final_a_bits: final_a_bits = 8 if b.bytelength > a_bytelength: assert b_bytelength == a_bytelength + 1 a_val = da[a_byteoffset + a_bytelength - 1] >> (8 - final_a_bits) a_val &= 0xff >> (8 - final_b_bits) return a_val == b_val assert a_bytelength == b_bytelength a_val = da[a_byteoffset + a_bytelength - 2] << 8 a_val += da[a_byteoffset + a_bytelength - 1] a_val >>= (8 - final_a_bits) a_val &= 0xff >> (8 - final_b_bits) return a_val == b_val class MmapByteArray(object): """Looks like a bytearray, but from an mmap. Not part of public interface. """ __slots__ = ('filemap', 'filelength', 'source', 'byteoffset', 'bytelength') def __init__(self, source, bytelength=None, byteoffset=None): self.source = source source.seek(0, os.SEEK_END) self.filelength = source.tell() if byteoffset is None: byteoffset = 0 if bytelength is None: bytelength = self.filelength - byteoffset self.byteoffset = byteoffset self.bytelength = bytelength self.filemap = mmap.mmap(source.fileno(), 0, access=mmap.ACCESS_READ) def __getitem__(self, key): try: start = key.start stop = key.stop except AttributeError: try: assert 0 <= key < self.bytelength return ord(self.filemap[key + self.byteoffset]) except TypeError: # for Python 3 return self.filemap[key + self.byteoffset] else: if start is None: start = 0 if stop is None: stop = self.bytelength assert key.step is None assert 0 <= start < self.bytelength assert 0 <= stop <= self.bytelength s = slice(start + self.byteoffset, stop + self.byteoffset) return bytearray(self.filemap.__getitem__(s)) def __len__(self): return self.bytelength # This creates a dictionary for every possible byte with the value being # the key with its bits reversed. BYTE_REVERSAL_DICT = dict() # For Python 2.7/ 3.x coexistence # Yes this is very very hacky. if sys.version_info[0] == 2: for i in range(256): BYTE_REVERSAL_DICT[i] = chr(int("{0:08b}".format(i)[::-1], 2)) else: for i in range(256): BYTE_REVERSAL_DICT[i] = bytes([int("{0:08b}".format(i)[::-1], 2)]) from io import IOBase as file xrange = range basestring = str # Python 2.x octals start with '0', in Python 3 it's '0o' LEADING_OCT_CHARS = len(oct(1)) - 1 def tidy_input_string(s): """Return string made lowercase and with all whitespace removed.""" s = ''.join(s.split()).lower() return s INIT_NAMES = ('uint', 'int', 'ue', 'se', 'sie', 'uie', 'hex', 'oct', 'bin', 'bits', 'uintbe', 'intbe', 'uintle', 'intle', 'uintne', 'intne', 'float', 'floatbe', 'floatle', 'floatne', 'bytes', 'bool', 'pad') TOKEN_RE = re.compile(r'(?P' + '|'.join(INIT_NAMES) + r')((:(?P[^=]+)))?(=(?P.*))?$', re.IGNORECASE) DEFAULT_UINT = re.compile(r'(?P[^=]+)?(=(?P.*))?$', re.IGNORECASE) MULTIPLICATIVE_RE = re.compile(r'(?P.*)\*(?P.+)') # Hex, oct or binary literals LITERAL_RE = re.compile(r'(?P0(x|o|b))(?P.+)', re.IGNORECASE) # An endianness indicator followed by one or more struct.pack codes STRUCT_PACK_RE = re.compile(r'(?P<|>|@)?(?P(?:\d*[bBhHlLqQfd])+)$') # A number followed by a single character struct.pack code STRUCT_SPLIT_RE = re.compile(r'\d*[bBhHlLqQfd]') # These replicate the struct.pack codes # Big-endian REPLACEMENTS_BE = {'b': 'intbe:8', 'B': 'uintbe:8', 'h': 'intbe:16', 'H': 'uintbe:16', 'l': 'intbe:32', 'L': 'uintbe:32', 'q': 'intbe:64', 'Q': 'uintbe:64', 'f': 'floatbe:32', 'd': 'floatbe:64'} # Little-endian REPLACEMENTS_LE = {'b': 'intle:8', 'B': 'uintle:8', 'h': 'intle:16', 'H': 'uintle:16', 'l': 'intle:32', 'L': 'uintle:32', 'q': 'intle:64', 'Q': 'uintle:64', 'f': 'floatle:32', 'd': 'floatle:64'} # Size in bytes of all the pack codes. PACK_CODE_SIZE = {'b': 1, 'B': 1, 'h': 2, 'H': 2, 'l': 4, 'L': 4, 'q': 8, 'Q': 8, 'f': 4, 'd': 8} _tokenname_to_initialiser = {'hex': 'hex', '0x': 'hex', '0X': 'hex', 'oct': 'oct', '0o': 'oct', '0O': 'oct', 'bin': 'bin', '0b': 'bin', '0B': 'bin', 'bits': 'auto', 'bytes': 'bytes', 'pad': 'pad'} def structparser(token): """Parse struct-like format string token into sub-token list.""" m = STRUCT_PACK_RE.match(token) if not m: return [token] else: endian = m.group('endian') if endian is None: return [token] # Split the format string into a list of 'q', '4h' etc. formatlist = re.findall(STRUCT_SPLIT_RE, m.group('fmt')) # Now deal with mulitiplicative factors, 4h -> hhhh etc. fmt = ''.join([f[-1] * int(f[:-1]) if len(f) != 1 else f for f in formatlist]) if endian == '@': # Native endianness if byteorder == 'little': endian = '<' else: assert byteorder == 'big' endian = '>' if endian == '<': tokens = [REPLACEMENTS_LE[c] for c in fmt] else: assert endian == '>' tokens = [REPLACEMENTS_BE[c] for c in fmt] return tokens def tokenparser(fmt, keys=None, token_cache={}): """Divide the format string into tokens and parse them. Return stretchy token and list of [initialiser, length, value] initialiser is one of: hex, oct, bin, uint, int, se, ue, 0x, 0o, 0b etc. length is None if not known, as is value. If the token is in the keyword dictionary (keys) then it counts as a special case and isn't messed with. tokens must be of the form: [factor*][initialiser][:][length][=value] """ try: return token_cache[(fmt, keys)] except KeyError: token_key = (fmt, keys) # Very inefficient expanding of brackets. fmt = expand_brackets(fmt) # Split tokens by ',' and remove whitespace # The meta_tokens can either be ordinary single tokens or multiple # struct-format token strings. meta_tokens = (''.join(f.split()) for f in fmt.split(',')) return_values = [] stretchy_token = False for meta_token in meta_tokens: # See if it has a multiplicative factor m = MULTIPLICATIVE_RE.match(meta_token) if not m: factor = 1 else: factor = int(m.group('factor')) meta_token = m.group('token') # See if it's a struct-like format tokens = structparser(meta_token) ret_vals = [] for token in tokens: if keys and token in keys: # Don't bother parsing it, it's a keyword argument ret_vals.append([token, None, None]) continue value = length = None if token == '': continue # Match literal tokens of the form 0x... 0o... and 0b... m = LITERAL_RE.match(token) if m: name = m.group('name') value = m.group('value') ret_vals.append([name, length, value]) continue # Match everything else: m1 = TOKEN_RE.match(token) if not m1: # and if you don't specify a 'name' then the default is 'uint': m2 = DEFAULT_UINT.match(token) if not m2: raise ValueError("Don't understand token '{0}'.".format(token)) if m1: name = m1.group('name') length = m1.group('len') if m1.group('value'): value = m1.group('value') else: assert m2 name = 'uint' length = m2.group('len') if m2.group('value'): value = m2.group('value') if name == 'bool': if length is not None and length != '1': raise ValueError("You can only specify one bit sized bool tokens or leave unspecified.") length = 1 if length is None and name not in ('se', 'ue', 'sie', 'uie'): stretchy_token = True if length is not None: # Try converting length to int, otherwise check it's a key. try: length = int(length) if length < 0: raise Error # For the 'bytes' token convert length to bits. if name == 'bytes': length *= 8 except Error: raise ValueError("Can't read a token with a negative length.") except ValueError: if not keys or length not in keys: raise ValueError("Don't understand length '{0}' of token.".format(length)) ret_vals.append([name, length, value]) # This multiplies by the multiplicative factor, but this means that # we can't allow keyword values as multipliers (e.g. n*uint:8). # The only way to do this would be to return the factor in some fashion # (we can't use the key's value here as it would mean that we couldn't # sensibly continue to cache the function's results. (TODO). return_values.extend(ret_vals * factor) return_values = [tuple(x) for x in return_values] if len(token_cache) < CACHE_SIZE: token_cache[token_key] = stretchy_token, return_values return stretchy_token, return_values # Looks for first number*( BRACKET_RE = re.compile(r'(?P\d+)\*\(') def expand_brackets(s): """Remove whitespace and expand all brackets.""" s = ''.join(s.split()) while True: start = s.find('(') if start == -1: break count = 1 # Number of hanging open brackets p = start + 1 while p < len(s): if s[p] == '(': count += 1 if s[p] == ')': count -= 1 if not count: break p += 1 if count: raise ValueError("Unbalanced parenthesis in '{0}'.".format(s)) if start == 0 or s[start - 1] != '*': s = s[0:start] + s[start + 1:p] + s[p + 1:] else: m = BRACKET_RE.search(s) if m: factor = int(m.group('factor')) matchstart = m.start('factor') s = s[0:matchstart] + (factor - 1) * (s[start + 1:p] + ',') + s[start + 1:p] + s[p + 1:] else: raise ValueError("Failed to parse '{0}'.".format(s)) return s # This converts a single octal digit to 3 bits. OCT_TO_BITS = ['{0:03b}'.format(i) for i in xrange(8)] # A dictionary of number of 1 bits contained in binary representation of any byte BIT_COUNT = dict(zip(xrange(256), [bin(i).count('1') for i in xrange(256)])) class Bits(object): """A container holding an immutable sequence of bits. For a mutable container use the BitArray class instead. Methods: all() -- Check if all specified bits are set to 1 or 0. any() -- Check if any of specified bits are set to 1 or 0. count() -- Count the number of bits set to 1 or 0. cut() -- Create generator of constant sized chunks. endswith() -- Return whether the bitstring ends with a sub-string. find() -- Find a sub-bitstring in the current bitstring. findall() -- Find all occurrences of a sub-bitstring in the current bitstring. join() -- Join bitstrings together using current bitstring. rfind() -- Seek backwards to find a sub-bitstring. split() -- Create generator of chunks split by a delimiter. startswith() -- Return whether the bitstring starts with a sub-bitstring. tobytes() -- Return bitstring as bytes, padding if needed. tofile() -- Write bitstring to file, padding if needed. unpack() -- Interpret bits using format string. Special methods: Also available are the operators [], ==, !=, +, *, ~, <<, >>, &, |, ^. Properties: bin -- The bitstring as a binary string. bool -- For single bit bitstrings, interpret as True or False. bytes -- The bitstring as a bytes object. float -- Interpret as a floating point number. floatbe -- Interpret as a big-endian floating point number. floatle -- Interpret as a little-endian floating point number. floatne -- Interpret as a native-endian floating point number. hex -- The bitstring as a hexadecimal string. int -- Interpret as a two's complement signed integer. intbe -- Interpret as a big-endian signed integer. intle -- Interpret as a little-endian signed integer. intne -- Interpret as a native-endian signed integer. len -- Length of the bitstring in bits. oct -- The bitstring as an octal string. se -- Interpret as a signed exponential-Golomb code. ue -- Interpret as an unsigned exponential-Golomb code. sie -- Interpret as a signed interleaved exponential-Golomb code. uie -- Interpret as an unsigned interleaved exponential-Golomb code. uint -- Interpret as a two's complement unsigned integer. uintbe -- Interpret as a big-endian unsigned integer. uintle -- Interpret as a little-endian unsigned integer. uintne -- Interpret as a native-endian unsigned integer. """ __slots__ = ('_datastore') def __init__(self, auto=None, length=None, offset=None, **kwargs): """Either specify an 'auto' initialiser: auto -- a string of comma separated tokens, an integer, a file object, a bytearray, a boolean iterable, an array or another bitstring. Or initialise via **kwargs with one (and only one) of: bytes -- raw data as a string, for example read from a binary file. bin -- binary string representation, e.g. '0b001010'. hex -- hexadecimal string representation, e.g. '0x2ef' oct -- octal string representation, e.g. '0o777'. uint -- an unsigned integer. int -- a signed integer. float -- a floating point number. uintbe -- an unsigned big-endian whole byte integer. intbe -- a signed big-endian whole byte integer. floatbe - a big-endian floating point number. uintle -- an unsigned little-endian whole byte integer. intle -- a signed little-endian whole byte integer. floatle -- a little-endian floating point number. uintne -- an unsigned native-endian whole byte integer. intne -- a signed native-endian whole byte integer. floatne -- a native-endian floating point number. se -- a signed exponential-Golomb code. ue -- an unsigned exponential-Golomb code. sie -- a signed interleaved exponential-Golomb code. uie -- an unsigned interleaved exponential-Golomb code. bool -- a boolean (True or False). filename -- a file which will be opened in binary read-only mode. Other keyword arguments: length -- length of the bitstring in bits, if needed and appropriate. It must be supplied for all integer and float initialisers. offset -- bit offset to the data. These offset bits are ignored and this is mainly intended for use when initialising using 'bytes' or 'filename'. """ pass def __new__(cls, auto=None, length=None, offset=None, _cache={}, **kwargs): # For instances auto-initialised with a string we intern the # instance for re-use. try: if isinstance(auto, basestring): try: return _cache[auto] except KeyError: x = object.__new__(Bits) try: _, tokens = tokenparser(auto) except ValueError as e: raise CreationError(*e.args) x._datastore = ConstByteStore(bytearray(0), 0, 0) for token in tokens: x._datastore._appendstore(Bits._init_with_token(*token)._datastore) assert x._assertsanity() if len(_cache) < CACHE_SIZE: _cache[auto] = x return x if type(auto) == Bits: return auto except TypeError: pass x = super(Bits, cls).__new__(cls) x._datastore = ConstByteStore(b'') x._initialise(auto, length, offset, **kwargs) return x def _initialise(self, auto, length, offset, **kwargs): if length is not None and length < 0: raise CreationError("bitstring length cannot be negative.") if offset is not None and offset < 0: raise CreationError("offset must be >= 0.") if auto is not None: self._initialise_from_auto(auto, length, offset) return if not kwargs: # No initialisers, so initialise with nothing or zero bits if length is not None and length != 0: data = bytearray((length + 7) // 8) self._setbytes_unsafe(data, length, 0) return self._setbytes_unsafe(bytearray(0), 0, 0) return k, v = kwargs.popitem() try: init_without_length_or_offset[k](self, v) if length is not None or offset is not None: raise CreationError("Cannot use length or offset with this initialiser.") except KeyError: try: init_with_length_only[k](self, v, length) if offset is not None: raise CreationError("Cannot use offset with this initialiser.") except KeyError: if offset is None: offset = 0 try: init_with_length_and_offset[k](self, v, length, offset) except KeyError: raise CreationError("Unrecognised keyword '{0}' used to initialise.", k) def _initialise_from_auto(self, auto, length, offset): if offset is None: offset = 0 self._setauto(auto, length, offset) return def __iter__(self): return iter(self._datastore) def __copy__(self): """Return a new copy of the Bits for the copy module.""" # Note that if you want a new copy (different ID), use _copy instead. # The copy can return self as it's immutable. return self def __lt__(self, other): raise TypeError("unorderable type: {0}".format(type(self).__name__)) def __gt__(self, other): raise TypeError("unorderable type: {0}".format(type(self).__name__)) def __le__(self, other): raise TypeError("unorderable type: {0}".format(type(self).__name__)) def __ge__(self, other): raise TypeError("unorderable type: {0}".format(type(self).__name__)) def __add__(self, bs): """Concatenate bitstrings and return new bitstring. bs -- the bitstring to append. """ bs = Bits(bs) if bs.len <= self.len: s = self._copy() s._append(bs) else: s = bs._copy() s = self.__class__(s) s._prepend(self) return s def __radd__(self, bs): """Append current bitstring to bs and return new bitstring. bs -- the string for the 'auto' initialiser that will be appended to. """ bs = self._converttobitstring(bs) return bs.__add__(self) def __getitem__(self, key): """Return a new bitstring representing a slice of the current bitstring. Indices are in units of the step parameter (default 1 bit). Stepping is used to specify the number of bits in each item. >>> print BitArray('0b00110')[1:4] '0b011' >>> print BitArray('0x00112233')[1:3:8] '0x1122' """ length = self.len if isinstance(key, slice): step = key.step if key.step is not None else 1 if step != 1: # convert to binary string and use string slicing bs = self.__class__() if _lsb0: start = length - key.start - 1 if key.start is not None else None stop = length - key.stop - 1 if key.stop is not None else None bs._setbin_unsafe(self._getbin().__getitem__(slice(start, stop, -step))[::-1]) else: bs._setbin_unsafe(self._getbin().__getitem__(key)) return bs start, stop = 0, length if key.start is not None: start = key.start if key.start < 0: start += stop if key.stop is not None: stop = key.stop if key.stop < 0: stop += length start = max(start, 0) stop = min(stop, length) if start < stop: return self._slice(start, stop) else: return self.__class__() else: # single element if key < 0: key += length if not 0 <= key < length: raise IndexError("Slice index out of range.") # Single bit, return True or False return self._datastore.getbit(key) def __len__(self): """Return the length of the bitstring in bits.""" return self._getlength() def __str__(self): """Return approximate string representation of bitstring for printing. Short strings will be given wholly in hexadecimal or binary. Longer strings may be part hexadecimal and part binary. Very long strings will be truncated with '...'. """ length = self.len if not length: return '' if length > MAX_CHARS * 4: # Too long for hex. Truncate... return ''.join(('0x', self._readhex(MAX_CHARS * 4, 0), '...')) # If it's quite short and we can't do hex then use bin if length < 32 and length % 4 != 0: return '0b' + self.bin # If we can use hex then do so if not length % 4: return '0x' + self.hex # Otherwise first we do as much as we can in hex # then add on 1, 2 or 3 bits on at the end bits_at_end = length % 4 return ''.join(('0x', self._readhex(length - bits_at_end, 0), ', ', '0b', self._readbin(bits_at_end, length - bits_at_end))) def __repr__(self): """Return representation that could be used to recreate the bitstring. If the returned string is too long it will be truncated. See __str__(). """ length = self.len if isinstance(self._datastore._rawarray, MmapByteArray): offsetstring = '' if self._datastore.byteoffset or self._offset: offsetstring = ", offset=%d" % (self._datastore._rawarray.byteoffset * 8 + self._offset) lengthstring = ", length=%d" % length return "{0}(filename='{1}'{2}{3})".format(self.__class__.__name__, self._datastore._rawarray.source.name, lengthstring, offsetstring) else: s = self.__str__() lengthstring = '' if s.endswith('...'): lengthstring = " # length={0}".format(length) return "{0}('{1}'){2}".format(self.__class__.__name__, s, lengthstring) def __eq__(self, bs): """Return True if two bitstrings have the same binary representation. >>> BitArray('0b1110') == '0xe' True """ try: bs = Bits(bs) except TypeError: return False return equal(self._datastore, bs._datastore) def __ne__(self, bs): """Return False if two bitstrings have the same binary representation. >>> BitArray('0b111') == '0x7' False """ return not self.__eq__(bs) def __invert__(self): """Return bitstring with every bit inverted. Raises Error if the bitstring is empty. """ if not self.len: raise Error("Cannot invert empty bitstring.") s = self._copy() s._invert_all() return s def __lshift__(self, n): """Return bitstring with bits shifted by n to the left. n -- the number of bits to shift. Must be >= 0. """ if n < 0: raise ValueError("Cannot shift by a negative amount.") if not self.len: raise ValueError("Cannot shift an empty bitstring.") n = min(n, self.len) s = self._slice(n, self.len) s._append(Bits(n)) return s def __rshift__(self, n): """Return bitstring with bits shifted by n to the right. n -- the number of bits to shift. Must be >= 0. """ if n < 0: raise ValueError("Cannot shift by a negative amount.") if not self.len: raise ValueError("Cannot shift an empty bitstring.") if not n: return self._copy() s = self.__class__(length=min(n, self.len)) s._append(self[:-n]) return s def __mul__(self, n): """Return bitstring consisting of n concatenations of self. Called for expression of the form 'a = b*3'. n -- The number of concatenations. Must be >= 0. """ if n < 0: raise ValueError("Cannot multiply by a negative integer.") if not n: return self.__class__() s = self._copy() s._imul(n) return s def __rmul__(self, n): """Return bitstring consisting of n concatenations of self. Called for expressions of the form 'a = 3*b'. n -- The number of concatenations. Must be >= 0. """ return self.__mul__(n) def __and__(self, bs): """Bit-wise 'and' between two bitstrings. Returns new bitstring. bs -- The bitstring to '&' with. Raises ValueError if the two bitstrings have differing lengths. """ bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for & operator.") s = self._copy() s._iand(bs) return s def __rand__(self, bs): """Bit-wise 'and' between two bitstrings. Returns new bitstring. bs -- the bitstring to '&' with. Raises ValueError if the two bitstrings have differing lengths. """ return self.__and__(bs) def __or__(self, bs): """Bit-wise 'or' between two bitstrings. Returns new bitstring. bs -- The bitstring to '|' with. Raises ValueError if the two bitstrings have differing lengths. """ bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for | operator.") s = self._copy() s._ior(bs) return s def __ror__(self, bs): """Bit-wise 'or' between two bitstrings. Returns new bitstring. bs -- The bitstring to '|' with. Raises ValueError if the two bitstrings have differing lengths. """ return self.__or__(bs) def __xor__(self, bs): """Bit-wise 'xor' between two bitstrings. Returns new bitstring. bs -- The bitstring to '^' with. Raises ValueError if the two bitstrings have differing lengths. """ bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for ^ operator.") s = self._copy() s._ixor(bs) return s def __rxor__(self, bs): """Bit-wise 'xor' between two bitstrings. Returns new bitstring. bs -- The bitstring to '^' with. Raises ValueError if the two bitstrings have differing lengths. """ return self.__xor__(bs) def __contains__(self, bs): """Return whether bs is contained in the current bitstring. bs -- The bitstring to search for. """ # Don't want to change pos try: pos = self._pos except AttributeError: pass found = Bits.find(self, bs, bytealigned=False) try: self._pos = pos except UnboundLocalError: pass return bool(found) def __hash__(self): """Return an integer hash of the object.""" # We can't in general hash the whole bitstring (it could take hours!) # So instead take some bits from the start and end. if self.len <= 160: # Use the whole bitstring. shorter = self else: # Take 10 bytes from start and end shorter = self[:80] + self[-80:] h = 0 for byte in shorter.tobytes(): try: h = (h << 4) + ord(byte) except TypeError: # Python 3 h = (h << 4) + byte g = h & 0xf0000000 if g & (1 << 31): h ^= (g >> 24) h ^= g return h % 1442968193 # This is only used in Python 2.x... def __nonzero__(self): """Return True if any bits are set to 1, otherwise return False.""" return self.any(True) # ...whereas this is used in Python 3.x __bool__ = __nonzero__ def _assertsanity(self): """Check internal self consistency as a debugging aid.""" assert self.len >= 0 assert 0 <= self._offset, "offset={0}".format(self._offset) assert (self.len + self._offset + 7) // 8 == self._datastore.bytelength + self._datastore.byteoffset, "len={0}, offset={1}, bytelength={2}, byteoffset={3}".format(self.len, self._offset, self._datastore.bytelength, self._datastore.byteoffset) return True @classmethod def _init_with_token(cls, name, token_length, value): if token_length is not None: token_length = int(token_length) if token_length == 0: return cls() # For pad token just return the length in zero bits if name == 'pad': return cls(token_length) if value is None: if token_length is None: error = "Token has no value ({0}=???).".format(name) else: error = "Token has no value ({0}:{1}=???).".format(name, token_length) raise ValueError(error) try: b = cls(**{_tokenname_to_initialiser[name]: value}) except KeyError: if name in ('se', 'ue', 'sie', 'uie'): b = cls(**{name: int(value)}) elif name in ('uint', 'int', 'uintbe', 'intbe', 'uintle', 'intle', 'uintne', 'intne'): b = cls(**{name: int(value), 'length': token_length}) elif name in ('float', 'floatbe', 'floatle', 'floatne'): b = cls(**{name: float(value), 'length': token_length}) elif name == 'bool': if value in (1, 'True', '1'): b = cls(bool=True) elif value in (0, 'False', '0'): b = cls(bool=False) else: raise CreationError("bool token can only be 'True' or 'False'.") else: raise CreationError("Can't parse token name {0}.", name) if token_length is not None and b.len != token_length: msg = "Token with length {0} packed with value of length {1} ({2}:{3}={4})." raise CreationError(msg, token_length, b.len, name, token_length, value) return b def _clear(self): """Reset the bitstring to an empty state.""" self._datastore = ByteStore(bytearray(0)) def _setauto(self, s, length, offset): """Set bitstring from a bitstring, file, bool, integer, array, iterable or string.""" # As s can be so many different things it's important to do the checks # in the correct order, as some types are also other allowed types. # So basestring must be checked before Iterable # and bytes/bytearray before Iterable but after basestring! if isinstance(s, Bits): if length is None: length = s.len - offset self._setbytes_unsafe(s._datastore.rawbytes, length, s._offset + offset) return if isinstance(s, io.BytesIO): if offset is None: offset = 0 if length is None: length = s.seek(0, 2) * 8 - offset byteoffset, offset = divmod(offset, 8) bytelength = (length + byteoffset * 8 + offset + 7) // 8 - byteoffset if length + byteoffset * 8 + offset > s.seek(0, 2) * 8: raise CreationError("BytesIO object is not long enough for specified " "length and offset.") self._datastore = ConstByteStore(bytearray(s.getvalue()[byteoffset: byteoffset + bytelength]), length, offset) return if isinstance(s, file): if offset is None: offset = 0 if length is None: length = os.path.getsize(s.name) * 8 - offset byteoffset, offset = divmod(offset, 8) bytelength = (length + byteoffset * 8 + offset + 7) // 8 - byteoffset m = MmapByteArray(s, bytelength, byteoffset) if length + byteoffset * 8 + offset > m.filelength * 8: raise CreationError("File is not long enough for specified " "length and offset.") self._datastore = ConstByteStore(m, length, offset) return if length is not None: raise CreationError("The length keyword isn't applicable to this initialiser.") if offset: raise CreationError("The offset keyword isn't applicable to this initialiser.") if isinstance(s, basestring): bs = self._converttobitstring(s) assert bs._offset == 0 self._setbytes_unsafe(bs._datastore.rawbytes, bs.length, 0) return if isinstance(s, (bytes, bytearray)): self._setbytes_unsafe(bytearray(s), len(s) * 8, 0) return if isinstance(s, array.array): try: b = s.tobytes() except AttributeError: b = s.tostring() # Python 2.7 self._setbytes_unsafe(bytearray(b), len(b) * 8, 0) return if isinstance(s, numbers.Integral): # Initialise with s zero bits. if s < 0: msg = "Can't create bitstring of negative length {0}." raise CreationError(msg, s) data = bytearray((s + 7) // 8) self._datastore = ByteStore(data, s, 0) return if isinstance(s, collectionsAbc.Iterable): # Evaluate each item as True or False and set bits to 1 or 0. self._setbin_unsafe(''.join(str(int(bool(x))) for x in s)) return raise TypeError("Cannot initialise bitstring from {0}.".format(type(s))) def _setfile(self, filename, length, offset): """Use file as source of bits.""" with open(filename, 'rb') as source: if offset is None: offset = 0 if length is None: length = os.path.getsize(source.name) * 8 - offset byteoffset, offset = divmod(offset, 8) bytelength = (length + byteoffset * 8 + offset + 7) // 8 - byteoffset m = MmapByteArray(source, bytelength, byteoffset) if length + byteoffset * 8 + offset > m.filelength * 8: raise CreationError("File is not long enough for specified " "length and offset.") self._datastore = ConstByteStore(m, length, offset) def _setbytes_safe(self, data, length=None, offset=0): """Set the data from a string.""" data = bytearray(data) if length is None: # Use to the end of the data length = len(data)*8 - offset self._datastore = ByteStore(data, length, offset) else: if length + offset > len(data) * 8: msg = "Not enough data present. Need {0} bits, have {1}." raise CreationError(msg, length + offset, len(data) * 8) if length == 0: self._datastore = ByteStore(bytearray(0)) else: self._datastore = ByteStore(data, length, offset) def _setbytes_unsafe(self, data, length, offset): """Unchecked version of _setbytes_safe.""" self._datastore = type(self._datastore)(data[:], length, offset) assert self._assertsanity() def _readbytes(self, length, start): """Read bytes and return them. Note that length is in bits.""" assert length % 8 == 0 assert start + length <= self.len if not (start + self._offset) % 8: return bytes(self._datastore.getbyteslice((start + self._offset) // 8, (start + self._offset + length) // 8)) return self._slice(start, start + length).tobytes() def _getbytes(self): """Return the data as an ordinary string.""" if self.len % 8: raise InterpretError("Cannot interpret as bytes unambiguously - " "not multiple of 8 bits.") return self._readbytes(self.len, 0) def _setuint(self, uint, length=None): """Reset the bitstring to have given unsigned int interpretation.""" try: if length is None: # Use the whole length. Deliberately not using .len here. length = self._datastore.bitlength except AttributeError: # bitstring doesn't have a _datastore as it hasn't been created! pass if length is None or length == 0: raise CreationError("A non-zero length must be specified with a " "uint initialiser.") if uint >= (1 << length): msg = "{0} is too large an unsigned integer for a bitstring of length {1}. "\ "The allowed range is [0, {2}]." raise CreationError(msg, uint, length, (1 << length) - 1) if uint < 0: raise CreationError("uint cannot be initialsed by a negative number.") s = hex(uint)[2:] s = s.rstrip('L') if len(s) & 1: s = '0' + s try: data = bytes.fromhex(s) except AttributeError: # the Python 2.x way data = binascii.unhexlify(s) # Now add bytes as needed to get the right length. extrabytes = ((length + 7) // 8) - len(data) if extrabytes > 0: data = b'\x00' * extrabytes + data offset = 8 - (length % 8) if offset == 8: offset = 0 self._setbytes_unsafe(bytearray(data), length, offset) def _readuint(self, length, start): """Read bits and interpret as an unsigned int.""" if not length: raise InterpretError("Cannot interpret a zero length bitstring " "as an integer.") offset = self._offset startbyte = (start + offset) // 8 endbyte = (start + offset + length - 1) // 8 b = binascii.hexlify(bytes(self._datastore.getbyteslice(startbyte, endbyte + 1))) assert b i = int(b, 16) final_bits = 8 - ((start + offset + length) % 8) if final_bits != 8: i >>= final_bits i &= (1 << length) - 1 return i def _getuint(self): """Return data as an unsigned int.""" return self._readuint(self.len, 0) def _setint(self, int_, length=None): """Reset the bitstring to have given signed int interpretation.""" # If no length given, and we've previously been given a length, use it. if length is None and hasattr(self, 'len') and self.len != 0: length = self.len if length is None or length == 0: raise CreationError("A non-zero length must be specified with an int initialiser.") if int_ >= (1 << (length - 1)) or int_ < -(1 << (length - 1)): raise CreationError("{0} is too large a signed integer for a bitstring of length {1}. " "The allowed range is [{2}, {3}].", int_, length, -(1 << (length - 1)), (1 << (length - 1)) - 1) if int_ >= 0: self._setuint(int_, length) return # Do the 2's complement thing. Add one, set to minus number, then flip bits. self._setuint((-int_ - 1) ^ ((1 << length) - 1), length) def _readint(self, length, start): """Read bits and interpret as a signed int""" ui = self._readuint(length, start) if not ui >> (length - 1): # Top bit not set, number is positive return ui # Top bit is set, so number is negative tmp = (~(ui - 1)) & ((1 << length) - 1) return -tmp def _getint(self): """Return data as a two's complement signed int.""" return self._readint(self.len, 0) def _setuintbe(self, uintbe, length=None): """Set the bitstring to a big-endian unsigned int interpretation.""" if length is not None and length % 8 != 0: raise CreationError("Big-endian integers must be whole-byte. " "Length = {0} bits.", length) self._setuint(uintbe, length) def _readuintbe(self, length, start): """Read bits and interpret as a big-endian unsigned int.""" if length % 8: raise InterpretError("Big-endian integers must be whole-byte. " "Length = {0} bits.", length) return self._readuint(length, start) def _getuintbe(self): """Return data as a big-endian two's complement unsigned int.""" return self._readuintbe(self.len, 0) def _setintbe(self, intbe, length=None): """Set bitstring to a big-endian signed int interpretation.""" if length is not None and length % 8 != 0: raise CreationError("Big-endian integers must be whole-byte. " "Length = {0} bits.", length) self._setint(intbe, length) def _readintbe(self, length, start): """Read bits and interpret as a big-endian signed int.""" if length % 8: raise InterpretError("Big-endian integers must be whole-byte. " "Length = {0} bits.", length) return self._readint(length, start) def _getintbe(self): """Return data as a big-endian two's complement signed int.""" return self._readintbe(self.len, 0) def _setuintle(self, uintle, length=None): if length is not None and length % 8 != 0: raise CreationError("Little-endian integers must be whole-byte. " "Length = {0} bits.", length) self._setuint(uintle, length) self._datastore._rawarray = self._datastore._rawarray[::-1] def _readuintle(self, length, start): """Read bits and interpret as a little-endian unsigned int.""" if length % 8: raise InterpretError("Little-endian integers must be whole-byte. " "Length = {0} bits.", length) assert start + length <= self.len absolute_pos = start + self._offset startbyte, offset = divmod(absolute_pos, 8) val = 0 if not offset: endbyte = (absolute_pos + length - 1) // 8 chunksize = 4 # for 'L' format while endbyte - chunksize + 1 >= startbyte: val <<= 8 * chunksize val += struct.unpack('> (length - 1): # Top bit not set, number is positive return ui # Top bit is set, so number is negative tmp = (~(ui - 1)) & ((1 << length) - 1) return -tmp def _getintle(self): return self._readintle(self.len, 0) def _setfloat(self, f, length=None): # If no length given, and we've previously been given a length, use it. if length is None and hasattr(self, 'len') and self.len != 0: length = self.len if length is None or length == 0: raise CreationError("A non-zero length must be specified with a " "float initialiser.") if length == 32: b = struct.pack('>f', f) elif length == 64: b = struct.pack('>d', f) else: raise CreationError("floats can only be 32 or 64 bits long, " "not {0} bits", length) self._setbytes_unsafe(bytearray(b), length, 0) def _readfloat(self, length, start): """Read bits and interpret as a float.""" if not (start + self._offset) % 8: startbyte = (start + self._offset) // 8 if length == 32: f, = struct.unpack('>f', bytes(self._datastore.getbyteslice(startbyte, startbyte + 4))) elif length == 64: f, = struct.unpack('>d', bytes(self._datastore.getbyteslice(startbyte, startbyte + 8))) else: if length == 32: f, = struct.unpack('>f', self._readbytes(32, start)) elif length == 64: f, = struct.unpack('>d', self._readbytes(64, start)) try: return f except NameError: raise InterpretError("floats can only be 32 or 64 bits long, not {0} bits", length) def _getfloat(self): """Interpret the whole bitstring as a float.""" return self._readfloat(self.len, 0) def _setfloatle(self, f, length=None): # If no length given, and we've previously been given a length, use it. if length is None and hasattr(self, 'len') and self.len != 0: length = self.len if length is None or length == 0: raise CreationError("A non-zero length must be specified with a " "float initialiser.") if length == 32: b = struct.pack(' 0: tmp >>= 1 leadingzeros += 1 remainingpart = i + 1 - (1 << leadingzeros) binstring = '0' * leadingzeros + '1' + Bits(uint=remainingpart, length=leadingzeros).bin self._setbin_unsafe(binstring) def _readue(self, pos): """Return interpretation of next bits as unsigned exponential-Golomb code. Raises ReadError if the end of the bitstring is encountered while reading the code. """ oldpos = pos try: while not self[pos]: pos += 1 except IndexError: raise ReadError("Read off end of bitstring trying to read code.") leadingzeros = pos - oldpos codenum = (1 << leadingzeros) - 1 if leadingzeros > 0: if pos + leadingzeros + 1 > self.len: raise ReadError("Read off end of bitstring trying to read code.") codenum += self._readuint(leadingzeros, pos + 1) pos += leadingzeros + 1 else: assert codenum == 0 pos += 1 return codenum, pos def _getue(self): """Return data as unsigned exponential-Golomb code. Raises InterpretError if bitstring is not a single exponential-Golomb code. """ try: value, newpos = self._readue(0) if value is None or newpos != self.len: raise ReadError except ReadError: raise InterpretError("Bitstring is not a single exponential-Golomb code.") return value def _setse(self, i): """Initialise bitstring with signed exponential-Golomb code for integer i.""" if i > 0: u = (i * 2) - 1 else: u = -2 * i self._setue(u) def _getse(self): """Return data as signed exponential-Golomb code. Raises InterpretError if bitstring is not a single exponential-Golomb code. """ try: value, newpos = self._readse(0) if value is None or newpos != self.len: raise ReadError except ReadError: raise InterpretError("Bitstring is not a single exponential-Golomb code.") return value def _readse(self, pos): """Return interpretation of next bits as a signed exponential-Golomb code. Advances position to after the read code. Raises ReadError if the end of the bitstring is encountered while reading the code. """ codenum, pos = self._readue(pos) m = (codenum + 1) // 2 if not codenum % 2: return -m, pos else: return m, pos def _setuie(self, i): """Initialise bitstring with unsigned interleaved exponential-Golomb code for integer i. Raises CreationError if i < 0. """ if i < 0: raise CreationError("Cannot use negative initialiser for unsigned " "interleaved exponential-Golomb.") self._setbin_unsafe('1' if i == 0 else '0' + '0'.join(bin(i + 1)[3:]) + '1') def _readuie(self, pos): """Return interpretation of next bits as unsigned interleaved exponential-Golomb code. Raises ReadError if the end of the bitstring is encountered while reading the code. """ try: codenum = 1 while not self[pos]: pos += 1 codenum <<= 1 codenum += self[pos] pos += 1 pos += 1 except IndexError: raise ReadError("Read off end of bitstring trying to read code.") codenum -= 1 return codenum, pos def _getuie(self): """Return data as unsigned interleaved exponential-Golomb code. Raises InterpretError if bitstring is not a single exponential-Golomb code. """ try: value, newpos = self._readuie(0) if value is None or newpos != self.len: raise ReadError except ReadError: raise InterpretError("Bitstring is not a single interleaved exponential-Golomb code.") return value def _setsie(self, i): """Initialise bitstring with signed interleaved exponential-Golomb code for integer i.""" if not i: self._setbin_unsafe('1') else: self._setuie(abs(i)) self._append(Bits([i < 0])) def _getsie(self): """Return data as signed interleaved exponential-Golomb code. Raises InterpretError if bitstring is not a single exponential-Golomb code. """ try: value, newpos = self._readsie(0) if value is None or newpos != self.len: raise ReadError except ReadError: raise InterpretError("Bitstring is not a single interleaved exponential-Golomb code.") return value def _readsie(self, pos): """Return interpretation of next bits as a signed interleaved exponential-Golomb code. Advances position to after the read code. Raises ReadError if the end of the bitstring is encountered while reading the code. """ codenum, pos = self._readuie(pos) if not codenum: return 0, pos try: if self[pos]: return -codenum, pos + 1 else: return codenum, pos + 1 except IndexError: raise ReadError("Read off end of bitstring trying to read code.") def _setbool(self, value): # We deliberately don't want to have implicit conversions to bool here. # If we did then it would be difficult to deal with the 'False' string. if value in (1, 'True'): self._setbytes_unsafe(bytearray(b'\x80'), 1, 0) elif value in (0, 'False'): self._setbytes_unsafe(bytearray(b'\x00'), 1, 0) else: raise CreationError('Cannot initialise boolean with {0}.', value) def _getbool(self): if self.length != 1: msg = "For a bool interpretation a bitstring must be 1 bit long, not {0} bits." raise InterpretError(msg, self.length) return self[0] def _readbool(self, pos): return self[pos], pos + 1 def _setbin_safe(self, binstring): """Reset the bitstring to the value given in binstring.""" binstring = tidy_input_string(binstring) # remove any 0b if present binstring = binstring.replace('0b', '') self._setbin_unsafe(binstring) def _setbin_unsafe(self, binstring): """Same as _setbin_safe, but input isn't sanity checked. binstring mustn't start with '0b'.""" length = len(binstring) # pad with zeros up to byte boundary if needed boundary = ((length + 7) // 8) * 8 padded_binstring = binstring + '0' * (boundary - length)\ if len(binstring) < boundary else binstring try: bytelist = [int(padded_binstring[x:x + 8], 2) for x in xrange(0, len(padded_binstring), 8)] except ValueError: raise CreationError("Invalid character in bin initialiser {0}.", binstring) self._setbytes_unsafe(bytearray(bytelist), length, 0) def _readbin(self, length, start): """Read bits and interpret as a binary string.""" if not length: return '' # Get the byte slice containing our bit slice startbyte, startoffset = divmod(start + self._offset, 8) endbyte = (start + self._offset + length - 1) // 8 b = self._datastore.getbyteslice(startbyte, endbyte + 1) # Convert to a string of '0' and '1's (via a hex string an and int!) c = "{:0{}b}".format(int(binascii.hexlify(b), 16), 8*len(b)) # Finally chop off any extra bits. return c[startoffset:startoffset + length] def _getbin(self): """Return interpretation as a binary string.""" return self._readbin(self.len, 0) def _setoct(self, octstring): """Reset the bitstring to have the value given in octstring.""" octstring = tidy_input_string(octstring) # remove any 0o if present octstring = octstring.replace('0o', '') binlist = [] for i in octstring: try: binlist.append(OCT_TO_BITS[int(i)]) except (ValueError, IndexError): raise CreationError("Invalid symbol '{0}' in oct initialiser.", i) self._setbin_unsafe(''.join(binlist)) def _readoct(self, length, start): """Read bits and interpret as an octal string.""" if length % 3: raise InterpretError("Cannot convert to octal unambiguously - " "not multiple of 3 bits.") if not length: return '' # Get main octal bit by converting from int. # Strip starting 0 or 0o depending on Python version. end = oct(self._readuint(length, start))[LEADING_OCT_CHARS:] if end.endswith('L'): end = end[:-1] middle = '0' * (length // 3 - len(end)) return middle + end def _getoct(self): """Return interpretation as an octal string.""" return self._readoct(self.len, 0) def _sethex(self, hexstring): """Reset the bitstring to have the value given in hexstring.""" hexstring = tidy_input_string(hexstring) # remove any 0x if present hexstring = hexstring.replace('0x', '') length = len(hexstring) if length % 2: hexstring += '0' try: data = bytearray.fromhex(hexstring) except ValueError: raise CreationError("Invalid symbol in hex initialiser.") self._setbytes_unsafe(data, length * 4, 0) def _readhex(self, length, start): """Read bits and interpret as a hex string.""" if length % 4: raise InterpretError("Cannot convert to hex unambiguously - " "not multiple of 4 bits.") if not length: return '' s = self._slice(start, start + length).tobytes() try: s = s.hex() # Available in Python 3.5+ except AttributeError: # This monstrosity is the only thing I could get to work for both 2.6 and 3.1. s = str(binascii.hexlify(s).decode('utf-8')) # If there's one nibble too many then cut it off return s[:-1] if (length // 4) % 2 else s def _gethex(self): """Return the hexadecimal representation as a string prefixed with '0x'. Raises an InterpretError if the bitstring's length is not a multiple of 4. """ return self._readhex(self.len, 0) def _getoffset(self): return self._datastore.offset def _getlength(self): """Return the length of the bitstring in bits.""" return self._datastore.bitlength def _ensureinmemory(self): """Ensure the data is held in memory, not in a file.""" self._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength), self.len, self._offset) @classmethod def _converttobitstring(cls, bs, offset=0, cache={}): """Convert bs to a bitstring and return it. offset gives the suggested bit offset of first significant bit, to optimise append etc. """ if isinstance(bs, Bits): return bs try: return cache[(bs, offset)] except KeyError: if isinstance(bs, basestring): b = cls() try: _, tokens = tokenparser(bs) except ValueError as e: raise CreationError(*e.args) if tokens: b._append(Bits._init_with_token(*tokens[0])) b._datastore = offsetcopy(b._datastore, offset) for token in tokens[1:]: b._append(Bits._init_with_token(*token)) assert b._assertsanity() assert b.len == 0 or b._offset == offset if len(cache) < CACHE_SIZE: cache[(bs, offset)] = b return b except TypeError: # Unhashable type pass return cls(bs) def _copy(self): """Create and return a new copy of the Bits (always in memory).""" s_copy = self.__class__() s_copy._setbytes_unsafe(self._datastore.getbyteslice(0, self._datastore.bytelength), self.len, self._offset) return s_copy def _slice_lsb0(self, start, end): """Used internally to get a slice, without error checking (LSB0).""" return self._slice_msb0(self.length - end, self.length - start) def _slice_msb0(self, start, end): """Used internally to get a slice, without error checking.""" if end == start: return self.__class__() assert start < end, "start={0}, end={1}".format(start, end) offset = self._offset startbyte, newoffset = divmod(start + offset, 8) endbyte = (end + offset - 1) // 8 bs = self.__class__() bs._setbytes_unsafe(self._datastore.getbyteslice(startbyte, endbyte + 1), end - start, newoffset) return bs def _readtoken(self, name, pos, length): """Reads a token from the bitstring and returns the result.""" if length is not None and int(length) > self.length - pos: raise ReadError("Reading off the end of the data. " "Tried to read {0} bits when only {1} available.".format(int(length), self.length - pos)) try: val = name_to_read[name](self, length, pos) return val, pos + length except KeyError: if name == 'pad': return None, pos + length raise ValueError("Can't parse token {0}:{1}".format(name, length)) except TypeError: # This is for the 'ue', 'se' and 'bool' tokens. They will also return the new pos. return name_to_read[name](self, pos) def _append(self, bs): """Append a bitstring to the current bitstring.""" self._datastore._appendstore(bs._datastore) def _prepend(self, bs): """Prepend a bitstring to the current bitstring.""" self._datastore._prependstore(bs._datastore) def _reverse(self): """Reverse all bits in-place.""" # Reverse the contents of each byte n = [BYTE_REVERSAL_DICT[b] for b in self._datastore.rawbytes] # Then reverse the order of the bytes n.reverse() # The new offset is the number of bits that were unused at the end. newoffset = 8 - (self._offset + self.len) % 8 if newoffset == 8: newoffset = 0 self._setbytes_unsafe(bytearray().join(n), self.length, newoffset) def _truncateleft(self, bits): """Truncate bits from the LHS of the bitstring.""" assert 0 <= bits <= self.len if not bits: return if bits == self.len: self._clear() return bytepos, offset = divmod(self._offset + bits, 8) self._setbytes_unsafe(self._datastore.getbyteslice(bytepos, self._datastore.bytelength), self.len - bits, offset) assert self._assertsanity() def _truncateright(self, bits): """Truncate bits from the RHS of the bitstring.""" assert 0 <= bits <= self.len if not bits: return if bits == self.len: self._clear() return newlength_in_bytes = (self._offset + self.len - bits + 7) // 8 self._setbytes_unsafe(self._datastore.getbyteslice(0, newlength_in_bytes), self.len - bits, self._offset) assert self._assertsanity() def _insert_lsb0(self, bs, pos): """Insert bs at pos (LSB0).""" self._insert_msb0(bs, self.len - pos) def _insert_msb0(self, bs, pos): """Insert bs at pos.""" assert 0 <= pos <= self.len if pos > self.len // 2: # Inserting nearer end, so cut off end. end = self._slice(pos, self.len) self._truncateright(self.len - pos) self._append(bs) self._append(end) else: # Inserting nearer start, so cut off start. start = self._slice(0, pos) self._truncateleft(pos) self._prepend(bs) self._prepend(start) try: self._pos = pos + bs.len except AttributeError: pass assert self._assertsanity() def _overwrite_lsb0(self, bs, pos): """Overwrite with bs at pos (LSB0).""" self._overwrite_msb0(bs, self.len - pos - bs.len) def _overwrite_msb0(self, bs, pos): """Overwrite with bs at pos.""" assert 0 <= pos < self.len if bs is self: # Just overwriting with self, so do nothing. assert pos == 0 return firstbytepos = (self._offset + pos) // 8 lastbytepos = (self._offset + pos + bs.len - 1) // 8 bytepos, bitoffset = divmod(self._offset + pos, 8) if firstbytepos == lastbytepos: mask = ((1 << bs.len) - 1) << (8 - bs.len - bitoffset) self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) & (~mask)) d = offsetcopy(bs._datastore, bitoffset) self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) | (d.getbyte(0) & mask)) else: # Do first byte mask = (1 << (8 - bitoffset)) - 1 self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) & (~mask)) d = offsetcopy(bs._datastore, bitoffset) self._datastore.setbyte(bytepos, self._datastore.getbyte(bytepos) | (d.getbyte(0) & mask)) # Now do all the full bytes self._datastore.setbyteslice(firstbytepos + 1, lastbytepos, d.getbyteslice(1, lastbytepos - firstbytepos)) # and finally the last byte bitsleft = (self._offset + pos + bs.len) % 8 if not bitsleft: bitsleft = 8 mask = (1 << (8 - bitsleft)) - 1 self._datastore.setbyte(lastbytepos, self._datastore.getbyte(lastbytepos) & mask) self._datastore.setbyte(lastbytepos, self._datastore.getbyte(lastbytepos) | (d.getbyte(d.bytelength - 1) & ~mask)) assert self._assertsanity() def _delete_lsb0(self, bits, pos): """Delete bits at pos (LSB0).""" self._delete_msb0(bits, self.len - pos - bits) def _delete_msb0(self, bits, pos): """Delete bits at pos.""" assert 0 <= pos <= self.len assert pos + bits <= self.len, "pos={}, bits={}, len={}".format(pos, bits, self.len) if not pos: # Cutting bits off at the start. self._truncateleft(bits) return if pos + bits == self.len: # Cutting bits off at the end. self._truncateright(bits) return if pos > self.len - pos - bits: # More bits before cut point than after it, so do bit shifting # on the final bits. end = self._slice_msb0(pos + bits, self.len) assert self.len - pos > 0 self._truncateright(self.len - pos) self._append(end) return # More bits after the cut point than before it. start = self._slice_msb0(0, pos) self._truncateleft(pos + bits) self._prepend(start) return def _reversebytes(self, start, end): """Reverse bytes in-place.""" # Make the start occur on a byte boundary # TODO: We could be cleverer here to avoid changing the offset. newoffset = 8 - (start % 8) if newoffset == 8: newoffset = 0 self._datastore = offsetcopy(self._datastore, newoffset) # Now just reverse the byte data toreverse = bytearray(self._datastore.getbyteslice((newoffset + start) // 8, (newoffset + end) // 8)) toreverse.reverse() self._datastore.setbyteslice((newoffset + start) // 8, (newoffset + end) // 8, toreverse) def _set(self, pos): """Set bit at pos to 1.""" assert 0 <= pos < self.len self._datastore.setbit(pos) def _unset(self, pos): """Set bit at pos to 0.""" assert 0 <= pos < self.len self._datastore.unsetbit(pos) def _invert(self, pos): """Flip bit at pos 1<->0.""" assert 0 <= pos < self.len self._datastore.invertbit(pos) def _invert_all(self): """Invert every bit.""" for p in xrange(self._datastore.byteoffset, self._datastore.byteoffset + self._datastore.bytelength): self._datastore._rawarray[p] = 256 + ~self._datastore._rawarray[p] def _ilshift(self, n): """Shift bits by n to the left in place. Return self.""" assert 0 < n <= self.len self._append(Bits(n)) self._truncateleft(n) return self def _irshift(self, n): """Shift bits by n to the right in place. Return self.""" assert 0 < n <= self.len self._prepend(Bits(n)) self._truncateright(n) return self def _imul(self, n): """Concatenate n copies of self in place. Return self.""" assert n >= 0 if not n: self._clear() return self m = 1 old_len = self.len while m * 2 < n: self._append(self) m *= 2 self._append(self[0:(n - m) * old_len]) return self def _inplace_logical_helper(self, bs, f): """Helper function containing most of the __ior__, __iand__, __ixor__ code.""" # Give the two bitstrings the same offset (modulo 8) self_byteoffset, self_bitoffset = divmod(self._offset, 8) bs_byteoffset, bs_bitoffset = divmod(bs._offset, 8) if bs_bitoffset != self_bitoffset: if not self_bitoffset: bs._datastore = offsetcopy(bs._datastore, 0) else: self._datastore = offsetcopy(self._datastore, bs_bitoffset) a = self._datastore.rawbytes b = bs._datastore.rawbytes for i in xrange(len(a)): a[i] = f(a[i + self_byteoffset], b[i + bs_byteoffset]) return self def _ior(self, bs): return self._inplace_logical_helper(bs, operator.ior) def _iand(self, bs): return self._inplace_logical_helper(bs, operator.iand) def _ixor(self, bs): return self._inplace_logical_helper(bs, operator.xor) def _readbits(self, length, start): """Read some bits from the bitstring and return newly constructed bitstring.""" return self._slice(start, start + length) def _validate_slice(self, start, end): """Validate start and end and return them as positive bit positions.""" if start is None: start = 0 elif start < 0: start += self.len if end is None: end = self.len elif end < 0: end += self.len if not 0 <= end <= self.len: raise ValueError("end is not a valid position in the bitstring.") if not 0 <= start <= self.len: raise ValueError("start is not a valid position in the bitstring.") if end < start: raise ValueError("end must not be less than start.") return start, end def unpack(self, fmt, **kwargs): """Interpret the whole bitstring using fmt and return list. fmt -- A single string or a list of strings with comma separated tokens describing how to interpret the bits in the bitstring. Items can also be integers, for reading new bitstring of the given length. kwargs -- A dictionary or keyword-value pairs - the keywords used in the format string will be replaced with their given value. Raises ValueError if the format is not understood. If not enough bits are available then all bits to the end of the bitstring will be used. See the docstring for 'read' for token examples. """ return self._readlist(fmt, 0, **kwargs)[0] def _readlist(self, fmt, pos, **kwargs): tokens = [] stretchy_token = None if isinstance(fmt, basestring): fmt = [fmt] # Replace integers with 'bits' tokens for i, f in enumerate(fmt): if isinstance(f, numbers.Integral): fmt[i] = "bits:{0}".format(f) for f_item in fmt: stretchy, tkns = tokenparser(f_item, tuple(sorted(kwargs.keys()))) if stretchy: if stretchy_token: raise Error("It's not possible to have more than one 'filler' token.") stretchy_token = stretchy tokens.extend(tkns) if not stretchy_token: lst = [] for name, length, _ in tokens: if length in kwargs: length = kwargs[length] if name == 'bytes': length *= 8 if name in kwargs and length is None: # Using default 'uint' - the name is really the length. value, pos = self._readtoken('uint', pos, kwargs[name]) lst.append(value) continue value, pos = self._readtoken(name, pos, length) if value is not None: # Don't append pad tokens lst.append(value) return lst, pos stretchy_token = False bits_after_stretchy_token = 0 for token in tokens: name, length, _ = token if length in kwargs: length = kwargs[length] if name == 'bytes': length *= 8 if name in kwargs and length is None: # Default 'uint'. length = kwargs[name] if stretchy_token: if name in ('se', 'ue', 'sie', 'uie'): raise Error("It's not possible to parse a variable" "length token after a 'filler' token.") else: if length is None: raise Error("It's not possible to have more than " "one 'filler' token.") bits_after_stretchy_token += length if length is None and name not in ('se', 'ue', 'sie', 'uie'): assert not stretchy_token stretchy_token = token bits_left = self.len - pos return_values = [] for token in tokens: name, length, _ = token if token is stretchy_token: # Set length to the remaining bits length = max(bits_left - bits_after_stretchy_token, 0) if length in kwargs: length = kwargs[length] if name == 'bytes': length *= 8 if name in kwargs and length is None: # Default 'uint' length = kwargs[name] if length is not None: bits_left -= length value, pos = self._readtoken(name, pos, length) if value is not None: return_values.append(value) return return_values, pos def _findbytes(self, bytes_, start, end, bytealigned): """Quicker version of find when everything's whole byte and byte aligned. """ assert self._datastore.offset == 0 assert bytealigned is True # Extract data bytes from bitstring to be found. bytepos = (start + 7) // 8 found = False p = bytepos finalpos = end // 8 increment = max(1024, len(bytes_) * 10) buffersize = increment + len(bytes_) while p < finalpos: # Read in file or from memory in overlapping chunks and search the chunks. buf = bytearray(self._datastore.getbyteslice(p, min(p + buffersize, finalpos))) pos = buf.find(bytes_) if pos != -1: found = True p += pos break p += increment if not found: return () return (p * 8,) def _findregex(self, reg_ex, start, end, bytealigned): """Find first occurrence of a compiled regular expression. Note that this doesn't support arbitrary regexes, in particular they must match a known length. """ p = start length = len(reg_ex.pattern) # We grab overlapping chunks of the binary representation and # do an ordinary string search within that. increment = max(4096, length * 10) buffersize = increment + length while p < end: buf = self._readbin(min(buffersize, end - p), p) # Test using regular expressions... m = reg_ex.search(buf) if m: pos = m.start() # pos = buf.find(targetbin) # if pos != -1: # if bytealigned then we only accept byte aligned positions. if not bytealigned or (p + pos) % 8 == 0: return (p + pos,) if bytealigned: # Advance to just beyond the non-byte-aligned match and try again... p += pos + 1 continue p += increment # Not found, return empty tuple return () def _find_lsb0(self, bs, start=None, end=None, bytealigned=None): bs = Bits(bs) p = self.rfind(bs, start, end, bytealigned) if p: return (self.len - p[0] - bs.length,) def _find_msb0(self, bs, start=None, end=None, bytealigned=None): """Find first occurrence of substring bs. Returns a single item tuple with the bit position if found, or an empty tuple if not found. The bit position (pos property) will also be set to the start of the substring if it is found. bs -- The bitstring to find. start -- The bit position to start the search. Defaults to 0. end -- The bit position one past the last bit to search. Defaults to self.len. bytealigned -- If True the bitstring will only be found on byte boundaries. Raises ValueError if bs is empty, if start < 0, if end > self.len or if end < start. >>> BitArray('0xc3e').find('0b1111') (6,) """ bs = Bits(bs) if not bs.len: raise ValueError("Cannot find an empty bitstring.") start, end = self._validate_slice(start, end) if bytealigned is None: bytealigned = globals()['bytealigned'] if bytealigned and not bs.len % 8 and not self._datastore.offset: p = self._findbytes(bs.bytes, start, end, bytealigned) else: p = self._findregex(re.compile(bs._getbin()), start, end, bytealigned) # If called from a class that has a pos, set it try: self._pos = p[0] except (AttributeError, IndexError): pass return p def findall(self, bs, start=None, end=None, count=None, bytealigned=None): """Find all occurrences of bs. Return generator of bit positions. bs -- The bitstring to find. start -- The bit position to start the search. Defaults to 0. end -- The bit position one past the last bit to search. Defaults to self.len. count -- The maximum number of occurrences to find. bytealigned -- If True the bitstring will only be found on byte boundaries. Raises ValueError if bs is empty, if start < 0, if end > self.len or if end < start. Note that all occurrences of bs are found, even if they overlap. """ if count is not None and count < 0: raise ValueError("In findall, count must be >= 0.") bs = Bits(bs) start, end = self._validate_slice(start, end) if bytealigned is None: bytealigned = globals()['bytealigned'] c = 0 if bytealigned and not bs.len % 8 and not self._datastore.offset: # Use the quick find method f = self._findbytes x = bs._getbytes() else: f = self._findregex x = re.compile(bs._getbin()) while True: p = f(x, start, end, bytealigned) if not p: break if count is not None and c >= count: return c += 1 try: self._pos = p[0] except AttributeError: pass yield p[0] if bytealigned: start = p[0] + 8 else: start = p[0] + 1 if start >= end: break return def rfind(self, bs, start=None, end=None, bytealigned=None): """Find final occurrence of substring bs. Returns a single item tuple with the bit position if found, or an empty tuple if not found. The bit position (pos property) will also be set to the start of the substring if it is found. bs -- The bitstring to find. start -- The bit position to end the reverse search. Defaults to 0. end -- The bit position one past the first bit to reverse search. Defaults to self.len. bytealigned -- If True the bitstring will only be found on byte boundaries. Raises ValueError if bs is empty, if start < 0, if end > self.len or if end < start. """ bs = Bits(bs) start, end = self._validate_slice(start, end) if bytealigned is None: bytealigned = globals()['bytealigned'] if not bs.len: raise ValueError("Cannot find an empty bitstring.") # Search chunks starting near the end and then moving back # until we find bs. increment = max(8192, bs.len * 80) buffersize = min(increment + bs.len, end - start) pos = max(start, end - buffersize) while True: found = list(self.findall(bs, start=pos, end=pos + buffersize, bytealigned=bytealigned)) if not found: if pos == start: return () pos = max(start, pos - increment) continue return (found[-1],) def cut(self, bits, start=None, end=None, count=None): """Return bitstring generator by cutting into bits sized chunks. bits -- The size in bits of the bitstring chunks to generate. start -- The bit position to start the first cut. Defaults to 0. end -- The bit position one past the last bit to use in the cut. Defaults to self.len. count -- If specified then at most count items are generated. Default is to cut as many times as possible. """ start, end = self._validate_slice(start, end) if count is not None and count < 0: raise ValueError("Cannot cut - count must be >= 0.") if bits <= 0: raise ValueError("Cannot cut - bits must be >= 0.") c = 0 while count is None or c < count: c += 1 nextchunk = self._slice(start, min(start + bits, end)) if nextchunk.len != bits: return assert nextchunk._assertsanity() yield nextchunk start += bits return def split(self, delimiter, start=None, end=None, count=None, bytealigned=None): """Return bitstring generator by splittling using a delimiter. The first item returned is the initial bitstring before the delimiter, which may be an empty bitstring. delimiter -- The bitstring used as the divider. start -- The bit position to start the split. Defaults to 0. end -- The bit position one past the last bit to use in the split. Defaults to self.len. count -- If specified then at most count items are generated. Default is to split as many times as possible. bytealigned -- If True splits will only occur on byte boundaries. Raises ValueError if the delimiter is empty. """ delimiter = Bits(delimiter) if not delimiter.len: raise ValueError("split delimiter cannot be empty.") start, end = self._validate_slice(start, end) if bytealigned is None: bytealigned = globals()['bytealigned'] if count is not None and count < 0: raise ValueError("Cannot split - count must be >= 0.") if count == 0: return if bytealigned and not delimiter.len % 8 and not self._datastore.offset: # Use the quick find method f = self._findbytes x = delimiter._getbytes() else: f = self._findregex x = re.compile(delimiter._getbin()) found = f(x, start, end, bytealigned) if not found: # Initial bits are the whole bitstring being searched yield self._slice(start, end) return # yield the bytes before the first occurrence of the delimiter, even if empty yield self._slice(start, found[0]) startpos = pos = found[0] c = 1 while count is None or c < count: pos += delimiter.len found = f(x, pos, end, bytealigned) if not found: # No more occurrences, so return the rest of the bitstring yield self._slice(startpos, end) return c += 1 yield self._slice(startpos, found[0]) startpos = pos = found[0] # Have generated count bitstrings, so time to quit. return def join(self, sequence): """Return concatenation of bitstrings joined by self. sequence -- A sequence of bitstrings. """ s = self.__class__() i = iter(sequence) try: s._append(Bits(next(i))) while True: n = next(i) s._append(self) s._append(Bits(n)) except StopIteration: pass return s def tobytes(self): """Return the bitstring as bytes, padding with zero bits if needed. Up to seven zero bits will be added at the end to byte align. """ d = offsetcopy(self._datastore, 0).rawbytes # Need to ensure that unused bits at end are set to zero unusedbits = 8 - self.len % 8 if unusedbits != 8: d[-1] &= (0xff << unusedbits) return bytes(d) def tofile(self, f): """Write the bitstring to a file object, padding with zero bits if needed. Up to seven zero bits will be added at the end to byte align. """ # If the bitstring is file based then we don't want to read it all # in to memory. chunksize = 1024 * 1024 # 1 MB chunks if not self._offset: a = 0 bytelen = self._datastore.bytelength p = self._datastore.getbyteslice(a, min(a + chunksize, bytelen - 1)) while len(p) == chunksize: f.write(p) a += chunksize p = self._datastore.getbyteslice(a, min(a + chunksize, bytelen - 1)) f.write(p) # Now the final byte, ensuring that unused bits at end are set to 0. bits_in_final_byte = self.len % 8 if not bits_in_final_byte: bits_in_final_byte = 8 f.write(self[-bits_in_final_byte:].tobytes()) else: # Really quite inefficient... a = 0 b = a + chunksize * 8 while b <= self.len: f.write(self._slice(a, b)._getbytes()) a += chunksize * 8 b += chunksize * 8 if a != self.len: f.write(self._slice(a, self.len).tobytes()) def startswith(self, prefix, start=None, end=None): """Return whether the current bitstring starts with prefix. prefix -- The bitstring to search for. start -- The bit position to start from. Defaults to 0. end -- The bit position to end at. Defaults to self.len. """ prefix = Bits(prefix) start, end = self._validate_slice(start, end) if end < start + prefix.len: return False end = start + prefix.len return self._slice(start, end) == prefix def endswith(self, suffix, start=None, end=None): """Return whether the current bitstring ends with suffix. suffix -- The bitstring to search for. start -- The bit position to start from. Defaults to 0. end -- The bit position to end at. Defaults to self.len. """ suffix = Bits(suffix) start, end = self._validate_slice(start, end) if start + suffix.len > end: return False start = end - suffix.len return self._slice(start, end) == suffix def all(self, value, pos=None): """Return True if one or many bits are all set to value. value -- If value is True then checks for bits set to 1, otherwise checks for bits set to 0. pos -- An iterable of bit positions. Negative numbers are treated in the same way as slice indices. Defaults to the whole bitstring. """ value = bool(value) length = self.len if pos is None: pos = xrange(self.len) for p in pos: if p < 0: p += length if not 0 <= p < length: raise IndexError("Bit position {0} out of range.".format(p)) if not self._datastore.getbit(p) is value: return False return True def any(self, value, pos=None): """Return True if any of one or many bits are set to value. value -- If value is True then checks for bits set to 1, otherwise checks for bits set to 0. pos -- An iterable of bit positions. Negative numbers are treated in the same way as slice indices. Defaults to the whole bitstring. """ value = bool(value) length = self.len if pos is None: pos = xrange(self.len) for p in pos: if p < 0: p += length if not 0 <= p < length: raise IndexError("Bit position {0} out of range.".format(p)) if self._datastore.getbit(p) is value: return True return False def count(self, value): """Return count of total number of either zero or one bits. value -- If True then bits set to 1 are counted, otherwise bits set to 0 are counted. >>> Bits('0xef').count(1) 7 """ if not self.len: return 0 # count the number of 1s (from which it's easy to work out the 0s). # Don't count the final byte yet. count = sum(BIT_COUNT[self._datastore.getbyte(i)] for i in xrange(self._datastore.bytelength - 1)) # adjust for bits at start that aren't part of the bitstring if self._offset: count -= BIT_COUNT[self._datastore.getbyte(0) >> (8 - self._offset)] # and count the last 1 - 8 bits at the end. endbits = self._datastore.bytelength * 8 - (self._offset + self.len) count += BIT_COUNT[self._datastore.getbyte(self._datastore.bytelength - 1) >> endbits] return count if value else self.len - count # Create native-endian functions as aliases depending on the byteorder if byteorder == 'little': _setfloatne = _setfloatle _readfloatne = _readfloatle _getfloatne = _getfloatle _setuintne = _setuintle _readuintne = _readuintle _getuintne = _getuintle _setintne = _setintle _readintne = _readintle _getintne = _getintle else: _setfloatne = _setfloat _readfloatne = _readfloat _getfloatne = _getfloat _setuintne = _setuintbe _readuintne = _readuintbe _getuintne = _getuintbe _setintne = _setintbe _readintne = _readintbe _getintne = _getintbe _offset = property(_getoffset) len = property(_getlength, doc="""The length of the bitstring in bits. Read only. """) length = property(_getlength, doc="""The length of the bitstring in bits. Read only. """) bool = property(_getbool, doc="""The bitstring as a bool (True or False). Read only. """) hex = property(_gethex, doc="""The bitstring as a hexadecimal string. Read only. """) bin = property(_getbin, doc="""The bitstring as a binary string. Read only. """) oct = property(_getoct, doc="""The bitstring as an octal string. Read only. """) bytes = property(_getbytes, doc="""The bitstring as a bytes object. Read only. """) int = property(_getint, doc="""The bitstring as a two's complement signed int. Read only. """) uint = property(_getuint, doc="""The bitstring as a two's complement unsigned int. Read only. """) float = property(_getfloat, doc="""The bitstring as a floating point number. Read only. """) intbe = property(_getintbe, doc="""The bitstring as a two's complement big-endian signed int. Read only. """) uintbe = property(_getuintbe, doc="""The bitstring as a two's complement big-endian unsigned int. Read only. """) floatbe = property(_getfloat, doc="""The bitstring as a big-endian floating point number. Read only. """) intle = property(_getintle, doc="""The bitstring as a two's complement little-endian signed int. Read only. """) uintle = property(_getuintle, doc="""The bitstring as a two's complement little-endian unsigned int. Read only. """) floatle = property(_getfloatle, doc="""The bitstring as a little-endian floating point number. Read only. """) intne = property(_getintne, doc="""The bitstring as a two's complement native-endian signed int. Read only. """) uintne = property(_getuintne, doc="""The bitstring as a two's complement native-endian unsigned int. Read only. """) floatne = property(_getfloatne, doc="""The bitstring as a native-endian floating point number. Read only. """) ue = property(_getue, doc="""The bitstring as an unsigned exponential-Golomb code. Read only. """) se = property(_getse, doc="""The bitstring as a signed exponential-Golomb code. Read only. """) uie = property(_getuie, doc="""The bitstring as an unsigned interleaved exponential-Golomb code. Read only. """) sie = property(_getsie, doc="""The bitstring as a signed interleaved exponential-Golomb code. Read only. """) # Dictionary that maps token names to the function that reads them. name_to_read = {'uint': Bits._readuint, 'uintle': Bits._readuintle, 'uintbe': Bits._readuintbe, 'uintne': Bits._readuintne, 'int': Bits._readint, 'intle': Bits._readintle, 'intbe': Bits._readintbe, 'intne': Bits._readintne, 'float': Bits._readfloat, 'floatbe': Bits._readfloat, # floatbe is a synonym for float 'floatle': Bits._readfloatle, 'floatne': Bits._readfloatne, 'hex': Bits._readhex, 'oct': Bits._readoct, 'bin': Bits._readbin, 'bits': Bits._readbits, 'bytes': Bits._readbytes, 'ue': Bits._readue, 'se': Bits._readse, 'uie': Bits._readuie, 'sie': Bits._readsie, 'bool': Bits._readbool, } # Dictionaries for mapping init keywords with init functions. init_with_length_and_offset = {'bytes': Bits._setbytes_safe, 'filename': Bits._setfile, } init_with_length_only = {'uint': Bits._setuint, 'int': Bits._setint, 'float': Bits._setfloat, 'uintbe': Bits._setuintbe, 'intbe': Bits._setintbe, 'floatbe': Bits._setfloat, 'uintle': Bits._setuintle, 'intle': Bits._setintle, 'floatle': Bits._setfloatle, 'uintne': Bits._setuintne, 'intne': Bits._setintne, 'floatne': Bits._setfloatne, } init_without_length_or_offset = {'bin': Bits._setbin_safe, 'hex': Bits._sethex, 'oct': Bits._setoct, 'ue': Bits._setue, 'se': Bits._setse, 'uie': Bits._setuie, 'sie': Bits._setsie, 'bool': Bits._setbool, } class BitArray(Bits): """A container holding a mutable sequence of bits. Subclass of the immutable Bits class. Inherits all of its methods (except __hash__) and adds mutating methods. Mutating methods: append() -- Append a bitstring. byteswap() -- Change byte endianness in-place. insert() -- Insert a bitstring. invert() -- Flip bit(s) between one and zero. overwrite() -- Overwrite a section with a new bitstring. prepend() -- Prepend a bitstring. replace() -- Replace occurrences of one bitstring with another. reverse() -- Reverse bits in-place. rol() -- Rotate bits to the left. ror() -- Rotate bits to the right. set() -- Set bit(s) to 1 or 0. Methods inherited from Bits: all() -- Check if all specified bits are set to 1 or 0. any() -- Check if any of specified bits are set to 1 or 0. count() -- Count the number of bits set to 1 or 0. cut() -- Create generator of constant sized chunks. endswith() -- Return whether the bitstring ends with a sub-string. find() -- Find a sub-bitstring in the current bitstring. findall() -- Find all occurrences of a sub-bitstring in the current bitstring. join() -- Join bitstrings together using current bitstring. rfind() -- Seek backwards to find a sub-bitstring. split() -- Create generator of chunks split by a delimiter. startswith() -- Return whether the bitstring starts with a sub-bitstring. tobytes() -- Return bitstring as bytes, padding if needed. tofile() -- Write bitstring to file, padding if needed. unpack() -- Interpret bits using format string. Special methods: Mutating operators are available: [], <<=, >>=, +=, *=, &=, |= and ^= in addition to the inherited [], ==, !=, +, *, ~, <<, >>, &, | and ^. Properties: bin -- The bitstring as a binary string. bool -- For single bit bitstrings, interpret as True or False. bytepos -- The current byte position in the bitstring. bytes -- The bitstring as a bytes object. float -- Interpret as a floating point number. floatbe -- Interpret as a big-endian floating point number. floatle -- Interpret as a little-endian floating point number. floatne -- Interpret as a native-endian floating point number. hex -- The bitstring as a hexadecimal string. int -- Interpret as a two's complement signed integer. intbe -- Interpret as a big-endian signed integer. intle -- Interpret as a little-endian signed integer. intne -- Interpret as a native-endian signed integer. len -- Length of the bitstring in bits. oct -- The bitstring as an octal string. pos -- The current bit position in the bitstring. se -- Interpret as a signed exponential-Golomb code. ue -- Interpret as an unsigned exponential-Golomb code. sie -- Interpret as a signed interleaved exponential-Golomb code. uie -- Interpret as an unsigned interleaved exponential-Golomb code. uint -- Interpret as a two's complement unsigned integer. uintbe -- Interpret as a big-endian unsigned integer. uintle -- Interpret as a little-endian unsigned integer. uintne -- Interpret as a native-endian unsigned integer. """ __slots__ = () # As BitArray objects are mutable, we shouldn't allow them to be hashed. __hash__ = None def __init__(self, auto=None, length=None, offset=None, **kwargs): """Either specify an 'auto' initialiser: auto -- a string of comma separated tokens, an integer, a file object, a bytearray, a boolean iterable or another bitstring. Or initialise via **kwargs with one (and only one) of: bytes -- raw data as a string, for example read from a binary file. bin -- binary string representation, e.g. '0b001010'. hex -- hexadecimal string representation, e.g. '0x2ef' oct -- octal string representation, e.g. '0o777'. uint -- an unsigned integer. int -- a signed integer. float -- a floating point number. uintbe -- an unsigned big-endian whole byte integer. intbe -- a signed big-endian whole byte integer. floatbe - a big-endian floating point number. uintle -- an unsigned little-endian whole byte integer. intle -- a signed little-endian whole byte integer. floatle -- a little-endian floating point number. uintne -- an unsigned native-endian whole byte integer. intne -- a signed native-endian whole byte integer. floatne -- a native-endian floating point number. se -- a signed exponential-Golomb code. ue -- an unsigned exponential-Golomb code. sie -- a signed interleaved exponential-Golomb code. uie -- an unsigned interleaved exponential-Golomb code. bool -- a boolean (True or False). filename -- a file which will be opened in binary read-only mode. Other keyword arguments: length -- length of the bitstring in bits, if needed and appropriate. It must be supplied for all integer and float initialisers. offset -- bit offset to the data. These offset bits are ignored and this is intended for use when initialising using 'bytes' or 'filename'. """ # For mutable BitArrays we always read in files to memory: if not isinstance(self._datastore, ByteStore): self._ensureinmemory() def __new__(cls, auto=None, length=None, offset=None, **kwargs): x = super(BitArray, cls).__new__(cls) y = Bits.__new__(BitArray, auto, length, offset, **kwargs) x._datastore = ByteStore(y._datastore._rawarray[:], y._datastore.bitlength, y._datastore.offset) return x def __iadd__(self, bs): """Append bs to current bitstring. Return self. bs -- the bitstring to append. """ self.append(bs) return self def __copy__(self): """Return a new copy of the BitArray.""" s_copy = BitArray() if not isinstance(self._datastore, ByteStore): # Let them both point to the same (invariant) array. # If either gets modified then at that point they'll be read into memory. s_copy._datastore = self._datastore else: s_copy._datastore = copy.copy(self._datastore) return s_copy def __setitem__(self, key, value): try: # A slice start, step = 0, 1 if key.step is not None: step = key.step except AttributeError: # single element if key < 0: key += self.len if not 0 <= key < self.len: raise IndexError("Slice index out of range.") if isinstance(value, numbers.Integral): if not value: self._unset(key) return if value in (1, -1): self._set(key) return raise ValueError("Cannot set a single bit with integer {0}.".format(value)) value = Bits(value) if value.len == 1: # TODO: this can't be optimal if value[0]: self._set(key) else: self._unset(key) else: self._delete(1, key) self._insert(value, key) return else: if step != 1: # convert to binary string and use string slicing # TODO: Horribly inefficient temp = list(self._getbin()) v = list(Bits(value)._getbin()) temp.__setitem__(key, v) self._setbin_unsafe(''.join(temp)) return # If value is an integer then we want to set the slice to that # value rather than initialise a new bitstring of that length. if not isinstance(value, numbers.Integral): try: # TODO: Better way than calling constructor here? value = Bits(value) except TypeError: raise TypeError("Bitstring, integer or string expected. " "Got {0}.".format(type(value))) if key.start is not None: start = key.start if key.start < 0: start += self.len if start < 0: start = 0 stop = self.len if key.stop is not None: stop = key.stop if key.stop < 0: stop += self.len if start > stop: # The standard behaviour for lists is to just insert at the # start position if stop < start and step == 1. stop = start if isinstance(value, numbers.Integral): if value >= 0: value = self.__class__(uint=value, length=stop - start) else: value = self.__class__(int=value, length=stop - start) stop = min(stop, self.len) start = max(start, 0) start = min(start, stop) if (stop - start) == value.len: if not value.len: return if step >= 0: self._overwrite(value, start) else: self._overwrite(value.__getitem__(slice(None, None, 1)), start) else: # TODO: A delete then insert is wasteful - it could do unneeded shifts. # Could be either overwrite + insert or overwrite + delete. self._delete(stop - start, start) if step >= 0: self._insert(value, start) else: self._insert(value.__getitem__(slice(None, None, 1)), start) # pos is now after the inserted piece. return def __delitem__(self, key): """Delete item or range. Indices are in units of the step parameter (default 1 bit). Stepping is used to specify the number of bits in each item. >>> a = BitArray('0x001122') >>> del a[1:2:8] >>> print a 0x0022 """ try: # A slice start = 0 step = key.step if key.step is not None else 1 except AttributeError: # single element if key < 0: key += self.len if not 0 <= key < self.len: raise IndexError("Slice index out of range.") self._delete(1, key) return else: if step != 1: # convert to binary string and use string slicing # TODO: Horribly inefficient temp = list(self._getbin()) temp.__delitem__(key) self._setbin_unsafe(''.join(temp)) return stop = key.stop if key.start is not None: start = key.start if key.start < 0: start += self.len if start < 0: start = 0 stop = self.len if key.stop is not None: stop = key.stop if key.stop < 0: stop += self.len if start > stop: return stop = min(stop, self.len) start = max(start, 0) start = min(start, stop) self._delete(stop - start, start) return def __ilshift__(self, n): """Shift bits by n to the left in place. Return self. n -- the number of bits to shift. Must be >= 0. """ if n < 0: raise ValueError("Cannot shift by a negative amount.") if not self.len: raise ValueError("Cannot shift an empty bitstring.") if not n: return self n = min(n, self.len) return self._ilshift(n) def __irshift__(self, n): """Shift bits by n to the right in place. Return self. n -- the number of bits to shift. Must be >= 0. """ if n < 0: raise ValueError("Cannot shift by a negative amount.") if not self.len: raise ValueError("Cannot shift an empty bitstring.") if not n: return self n = min(n, self.len) return self._irshift(n) def __imul__(self, n): """Concatenate n copies of self in place. Return self. Called for expressions of the form 'a *= 3'. n -- The number of concatenations. Must be >= 0. """ if n < 0: raise ValueError("Cannot multiply by a negative integer.") return self._imul(n) def __ior__(self, bs): bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for |= operator.") return self._ior(bs) def __iand__(self, bs): bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for &= operator.") return self._iand(bs) def __ixor__(self, bs): bs = Bits(bs) if self.len != bs.len: raise ValueError("Bitstrings must have the same length " "for ^= operator.") return self._ixor(bs) def replace(self, old, new, start=None, end=None, count=None, bytealigned=None): """Replace all occurrences of old with new in place. Returns number of replacements made. old -- The bitstring to replace. new -- The replacement bitstring. start -- Any occurrences that start before this will not be replaced. Defaults to 0. end -- Any occurrences that finish after this will not be replaced. Defaults to self.len. count -- The maximum number of replacements to make. Defaults to replace all occurrences. bytealigned -- If True replacements will only be made on byte boundaries. Raises ValueError if old is empty or if start or end are out of range. """ old = Bits(old) new = Bits(new) if not old.len: raise ValueError("Empty bitstring cannot be replaced.") start, end = self._validate_slice(start, end) if bytealigned is None: bytealigned = globals()['bytealigned'] # Adjust count for use in split() if count is not None: count += 1 sections = self.split(old, start, end, count, bytealigned) lengths = [s.len for s in sections] if len(lengths) == 1: # Didn't find anything to replace. return 0 # no replacements done if new is self: # Prevent self assignment woes new = copy.copy(self) positions = [lengths[0] + start] for l in lengths[1:-1]: # Next position is the previous one plus the length of the next section. positions.append(positions[-1] + l) # We have all the positions that need replacements. We do them # in reverse order so that they won't move around as we replace. positions.reverse() try: # Need to calculate new pos, if this is a bitstream newpos = self._pos for p in positions: self[p:p + old.len] = new if old.len != new.len: diff = new.len - old.len for p in positions: if p >= newpos: continue if p + old.len <= newpos: newpos += diff else: newpos = p self._pos = newpos except AttributeError: for p in positions: self[p:p + old.len] = new assert self._assertsanity() return len(lengths) - 1 def insert(self, bs, pos=None): """Insert bs at bit position pos. bs -- The bitstring to insert. pos -- The bit position to insert at. Raises ValueError if pos < 0 or pos > self.len. """ bs = Bits(bs) if not bs.len: return self if bs is self: bs = self.__copy__() if pos is None: try: pos = self._pos except AttributeError: raise TypeError("insert require a bit position for this type.") if pos < 0: pos += self.len if not 0 <= pos <= self.len: raise ValueError("Invalid insert position.") self._insert(bs, pos) def overwrite(self, bs, pos=None): """Overwrite with bs at bit position pos. bs -- The bitstring to overwrite with. pos -- The bit position to begin overwriting from. Raises ValueError if pos < 0 or pos + bs.len > self.len """ bs = Bits(bs) if not bs.len: return if pos is None: try: pos = self._pos except AttributeError: raise TypeError("overwrite require a bit position for this type.") if pos < 0: pos += self.len if pos < 0 or pos + bs.len > self.len: raise ValueError("Overwrite exceeds boundary of bitstring.") self._overwrite(bs, pos) try: self._pos = pos + bs.len except AttributeError: pass def append(self, bs): """Append a bitstring to the current bitstring. bs -- The bitstring to append. """ # The offset is a hint to make bs easily appendable. bs = self._converttobitstring(bs, offset=(self.len + self._offset) % 8) self._append(bs) def prepend(self, bs): """Prepend a bitstring to the current bitstring. bs -- The bitstring to prepend. """ bs = Bits(bs) self._prepend(bs) def reverse(self, start=None, end=None): """Reverse bits in-place. start -- Position of first bit to reverse. Defaults to 0. end -- One past the position of the last bit to reverse. Defaults to self.len. Using on an empty bitstring will have no effect. Raises ValueError if start < 0, end > self.len or end < start. """ start, end = self._validate_slice(start, end) if start == 0 and end == self.len: self._reverse() return s = self._slice(start, end) s._reverse() self[start:end] = s def set(self, value, pos=None): """Set one or many bits to 1 or 0. value -- If True bits are set to 1, otherwise they are set to 0. pos -- Either a single bit position or an iterable of bit positions. Negative numbers are treated in the same way as slice indices. Defaults to the entire bitstring. Raises IndexError if pos < -self.len or pos >= self.len. """ f = self._set if value else self._unset if pos is None: pos = xrange(self.len) try: length = self.len for p in pos: if p < 0: p += length if not 0 <= p < length: raise IndexError("Bit position {0} out of range.".format(p)) f(p) except TypeError: # Single pos if pos < 0: pos += self.len if not 0 <= pos < length: raise IndexError("Bit position {0} out of range.".format(pos)) f(pos) def invert(self, pos=None): """Invert one or many bits from 0 to 1 or vice versa. pos -- Either a single bit position or an iterable of bit positions. Negative numbers are treated in the same way as slice indices. Raises IndexError if pos < -self.len or pos >= self.len. """ if pos is None: self._invert_all() return if not isinstance(pos, collectionsAbc.Iterable): pos = (pos,) length = self.len for p in pos: if p < 0: p += length if not 0 <= p < length: raise IndexError("Bit position {0} out of range.".format(p)) self._invert(p) def ror(self, bits, start=None, end=None): """Rotate bits to the right in-place. bits -- The number of bits to rotate by. start -- Start of slice to rotate. Defaults to 0. end -- End of slice to rotate. Defaults to self.len. Raises ValueError if bits < 0. """ if not self.len: raise Error("Cannot rotate an empty bitstring.") if bits < 0: raise ValueError("Cannot rotate right by negative amount.") start, end = self._validate_slice(start, end) bits %= (end - start) if not bits: return rhs = self._slice(end - bits, end) self._delete(bits, end - bits) self._insert(rhs, start) def rol(self, bits, start=None, end=None): """Rotate bits to the left in-place. bits -- The number of bits to rotate by. start -- Start of slice to rotate. Defaults to 0. end -- End of slice to rotate. Defaults to self.len. Raises ValueError if bits < 0. """ if not self.len: raise Error("Cannot rotate an empty bitstring.") if bits < 0: raise ValueError("Cannot rotate left by negative amount.") start, end = self._validate_slice(start, end) bits %= (end - start) if not bits: return lhs = self._slice(start, start + bits) self._delete(bits, start) self._insert(lhs, end - bits) def byteswap(self, fmt=None, start=None, end=None, repeat=True): """Change the endianness in-place. Return number of repeats of fmt done. fmt -- A compact structure string, an integer number of bytes or an iterable of integers. Defaults to 0, which byte reverses the whole bitstring. start -- Start bit position, defaults to 0. end -- End bit position, defaults to self.len. repeat -- If True (the default) the byte swapping pattern is repeated as much as possible. """ start, end = self._validate_slice(start, end) if fmt is None or fmt == 0: # reverse all of the whole bytes. bytesizes = [(end - start) // 8] elif isinstance(fmt, numbers.Integral): if fmt < 0: raise ValueError("Improper byte length {0}.".format(fmt)) bytesizes = [fmt] elif isinstance(fmt, basestring): m = STRUCT_PACK_RE.match(fmt) if not m: raise ValueError("Cannot parse format string {0}.".format(fmt)) # Split the format string into a list of 'q', '4h' etc. formatlist = re.findall(STRUCT_SPLIT_RE, m.group('fmt')) # Now deal with multiplicative factors, 4h -> hhhh etc. bytesizes = [] for f in formatlist: if len(f) == 1: bytesizes.append(PACK_CODE_SIZE[f]) else: bytesizes.extend([PACK_CODE_SIZE[f[-1]]] * int(f[:-1])) elif isinstance(fmt, collectionsAbc.Iterable): bytesizes = fmt for bytesize in bytesizes: if not isinstance(bytesize, numbers.Integral) or bytesize < 0: raise ValueError("Improper byte length {0}.".format(bytesize)) else: raise TypeError("Format must be an integer, string or iterable.") repeats = 0 totalbitsize = 8 * sum(bytesizes) if not totalbitsize: return 0 if repeat: # Try to repeat up to the end of the bitstring. finalbit = end else: # Just try one (set of) byteswap(s). finalbit = start + totalbitsize for patternend in xrange(start + totalbitsize, finalbit + 1, totalbitsize): bytestart = patternend - totalbitsize for bytesize in bytesizes: byteend = bytestart + bytesize * 8 self._reversebytes(bytestart, byteend) bytestart += bytesize * 8 repeats += 1 return repeats def clear(self): """Remove all bits, reset to zero length.""" self._clear() def copy(self): """Return a copy of the bitstring.""" return self._copy() int = property(Bits._getint, Bits._setint, doc="""The bitstring as a two's complement signed int. Read and write. """) uint = property(Bits._getuint, Bits._setuint, doc="""The bitstring as a two's complement unsigned int. Read and write. """) float = property(Bits._getfloat, Bits._setfloat, doc="""The bitstring as a floating point number. Read and write. """) intbe = property(Bits._getintbe, Bits._setintbe, doc="""The bitstring as a two's complement big-endian signed int. Read and write. """) uintbe = property(Bits._getuintbe, Bits._setuintbe, doc="""The bitstring as a two's complement big-endian unsigned int. Read and write. """) floatbe = property(Bits._getfloat, Bits._setfloat, doc="""The bitstring as a big-endian floating point number. Read and write. """) intle = property(Bits._getintle, Bits._setintle, doc="""The bitstring as a two's complement little-endian signed int. Read and write. """) uintle = property(Bits._getuintle, Bits._setuintle, doc="""The bitstring as a two's complement little-endian unsigned int. Read and write. """) floatle = property(Bits._getfloatle, Bits._setfloatle, doc="""The bitstring as a little-endian floating point number. Read and write. """) intne = property(Bits._getintne, Bits._setintne, doc="""The bitstring as a two's complement native-endian signed int. Read and write. """) uintne = property(Bits._getuintne, Bits._setuintne, doc="""The bitstring as a two's complement native-endian unsigned int. Read and write. """) floatne = property(Bits._getfloatne, Bits._setfloatne, doc="""The bitstring as a native-endian floating point number. Read and write. """) ue = property(Bits._getue, Bits._setue, doc="""The bitstring as an unsigned exponential-Golomb code. Read and write. """) se = property(Bits._getse, Bits._setse, doc="""The bitstring as a signed exponential-Golomb code. Read and write. """) uie = property(Bits._getuie, Bits._setuie, doc="""The bitstring as an unsigned interleaved exponential-Golomb code. Read and write. """) sie = property(Bits._getsie, Bits._setsie, doc="""The bitstring as a signed interleaved exponential-Golomb code. Read and write. """) hex = property(Bits._gethex, Bits._sethex, doc="""The bitstring as a hexadecimal string. Read and write. """) bin = property(Bits._getbin, Bits._setbin_safe, doc="""The bitstring as a binary string. Read and write. """) oct = property(Bits._getoct, Bits._setoct, doc="""The bitstring as an octal string. Read and write. """) bool = property(Bits._getbool, Bits._setbool, doc="""The bitstring as a bool (True or False). Read and write. """) bytes = property(Bits._getbytes, Bits._setbytes_safe, doc="""The bitstring as a ordinary string. Read and write. """) class ConstBitStream(Bits): """A container or stream holding an immutable sequence of bits. For a mutable container use the BitStream class instead. Methods inherited from Bits: all() -- Check if all specified bits are set to 1 or 0. any() -- Check if any of specified bits are set to 1 or 0. count() -- Count the number of bits set to 1 or 0. cut() -- Create generator of constant sized chunks. endswith() -- Return whether the bitstring ends with a sub-string. find() -- Find a sub-bitstring in the current bitstring. findall() -- Find all occurrences of a sub-bitstring in the current bitstring. join() -- Join bitstrings together using current bitstring. rfind() -- Seek backwards to find a sub-bitstring. split() -- Create generator of chunks split by a delimiter. startswith() -- Return whether the bitstring starts with a sub-bitstring. tobytes() -- Return bitstring as bytes, padding if needed. tofile() -- Write bitstring to file, padding if needed. unpack() -- Interpret bits using format string. Other methods: bytealign() -- Align to next byte boundary. peek() -- Peek at and interpret next bits as a single item. peeklist() -- Peek at and interpret next bits as a list of items. read() -- Read and interpret next bits as a single item. readlist() -- Read and interpret next bits as a list of items. Special methods: Also available are the operators [], ==, !=, +, *, ~, <<, >>, &, |, ^. Properties: bin -- The bitstring as a binary string. bool -- For single bit bitstrings, interpret as True or False. bytepos -- The current byte position in the bitstring. bytes -- The bitstring as a bytes object. float -- Interpret as a floating point number. floatbe -- Interpret as a big-endian floating point number. floatle -- Interpret as a little-endian floating point number. floatne -- Interpret as a native-endian floating point number. hex -- The bitstring as a hexadecimal string. int -- Interpret as a two's complement signed integer. intbe -- Interpret as a big-endian signed integer. intle -- Interpret as a little-endian signed integer. intne -- Interpret as a native-endian signed integer. len -- Length of the bitstring in bits. oct -- The bitstring as an octal string. pos -- The current bit position in the bitstring. se -- Interpret as a signed exponential-Golomb code. ue -- Interpret as an unsigned exponential-Golomb code. sie -- Interpret as a signed interleaved exponential-Golomb code. uie -- Interpret as an unsigned interleaved exponential-Golomb code. uint -- Interpret as a two's complement unsigned integer. uintbe -- Interpret as a big-endian unsigned integer. uintle -- Interpret as a little-endian unsigned integer. uintne -- Interpret as a native-endian unsigned integer. """ __slots__ = ('_pos') def __init__(self, auto=None, length=None, offset=None, **kwargs): """Either specify an 'auto' initialiser: auto -- a string of comma separated tokens, an integer, a file object, a bytearray, a boolean iterable or another bitstring. Or initialise via **kwargs with one (and only one) of: bytes -- raw data as a string, for example read from a binary file. bin -- binary string representation, e.g. '0b001010'. hex -- hexadecimal string representation, e.g. '0x2ef' oct -- octal string representation, e.g. '0o777'. uint -- an unsigned integer. int -- a signed integer. float -- a floating point number. uintbe -- an unsigned big-endian whole byte integer. intbe -- a signed big-endian whole byte integer. floatbe - a big-endian floating point number. uintle -- an unsigned little-endian whole byte integer. intle -- a signed little-endian whole byte integer. floatle -- a little-endian floating point number. uintne -- an unsigned native-endian whole byte integer. intne -- a signed native-endian whole byte integer. floatne -- a native-endian floating point number. se -- a signed exponential-Golomb code. ue -- an unsigned exponential-Golomb code. sie -- a signed interleaved exponential-Golomb code. uie -- an unsigned interleaved exponential-Golomb code. bool -- a boolean (True or False). filename -- a file which will be opened in binary read-only mode. Other keyword arguments: length -- length of the bitstring in bits, if needed and appropriate. It must be supplied for all integer and float initialisers. offset -- bit offset to the data. These offset bits are ignored and this is intended for use when initialising using 'bytes' or 'filename'. """ self._pos = 0 def __new__(cls, auto=None, length=None, offset=None, **kwargs): x = super(ConstBitStream, cls).__new__(cls) x._initialise(auto, length, offset, **kwargs) return x def _setbytepos(self, bytepos): """Move to absolute byte-aligned position in stream.""" self._setbitpos(bytepos * 8) def _getbytepos(self): """Return the current position in the stream in bytes. Must be byte aligned.""" if self._pos % 8: raise ByteAlignError("Not byte aligned in _getbytepos().") return self._pos // 8 def _setbitpos(self, pos): """Move to absolute postion bit in bitstream.""" if pos < 0: raise ValueError("Bit position cannot be negative.") if pos > self.len: raise ValueError("Cannot seek past the end of the data.") self._pos = pos def _getbitpos(self): """Return the current position in the stream in bits.""" return self._pos def _clear(self): Bits._clear(self) self._pos = 0 def __copy__(self): """Return a new copy of the ConstBitStream for the copy module.""" # Note that if you want a new copy (different ID), use _copy instead. # The copy can use the same datastore as it's immutable. s = ConstBitStream() s._datastore = self._datastore # Reset the bit position, don't copy it. s._pos = 0 return s def __add__(self, bs): """Concatenate bitstrings and return new bitstring. bs -- the bitstring to append. """ s = Bits.__add__(self, bs) s._pos = 0 return s def read(self, fmt): """Interpret next bits according to the format string and return result. fmt -- Token string describing how to interpret the next bits. Token examples: 'int:12' : 12 bits as a signed integer 'uint:8' : 8 bits as an unsigned integer 'float:64' : 8 bytes as a big-endian float 'intbe:16' : 2 bytes as a big-endian signed integer 'uintbe:16' : 2 bytes as a big-endian unsigned integer 'intle:32' : 4 bytes as a little-endian signed integer 'uintle:32' : 4 bytes as a little-endian unsigned integer 'floatle:64': 8 bytes as a little-endian float 'intne:24' : 3 bytes as a native-endian signed integer 'uintne:24' : 3 bytes as a native-endian unsigned integer 'floatne:32': 4 bytes as a native-endian float 'hex:80' : 80 bits as a hex string 'oct:9' : 9 bits as an octal string 'bin:1' : single bit binary string 'ue' : next bits as unsigned exp-Golomb code 'se' : next bits as signed exp-Golomb code 'uie' : next bits as unsigned interleaved exp-Golomb code 'sie' : next bits as signed interleaved exp-Golomb code 'bits:5' : 5 bits as a bitstring 'bytes:10' : 10 bytes as a bytes object 'bool' : 1 bit as a bool 'pad:3' : 3 bits of padding to ignore - returns None fmt may also be an integer, which will be treated like the 'bits' token. The position in the bitstring is advanced to after the read items. Raises ReadError if not enough bits are available. Raises ValueError if the format is not understood. """ if isinstance(fmt, numbers.Integral): if fmt < 0: raise ValueError("Cannot read negative amount.") if fmt > self.len - self._pos: raise ReadError("Cannot read {0} bits, only {1} available.", fmt, self.len - self._pos) bs = self._slice(self._pos, self._pos + fmt) self._pos += fmt return bs p = self._pos _, token = tokenparser(fmt) if len(token) != 1: self._pos = p raise ValueError("Format string should be a single token, not {0} " "tokens - use readlist() instead.".format(len(token))) name, length, _ = token[0] if length is None: length = self.len - self._pos value, self._pos = self._readtoken(name, self._pos, length) return value def readlist(self, fmt, **kwargs): """Interpret next bits according to format string(s) and return list. fmt -- A single string or list of strings with comma separated tokens describing how to interpret the next bits in the bitstring. Items can also be integers, for reading new bitstring of the given length. kwargs -- A dictionary or keyword-value pairs - the keywords used in the format string will be replaced with their given value. The position in the bitstring is advanced to after the read items. Raises ReadError is not enough bits are available. Raises ValueError if the format is not understood. See the docstring for 'read' for token examples. 'pad' tokens are skipped and not added to the returned list. >>> h, b1, b2 = s.readlist('hex:20, bin:5, bin:3') >>> i, bs1, bs2 = s.readlist(['uint:12', 10, 10]) """ value, self._pos = self._readlist(fmt, self._pos, **kwargs) return value def readto(self, bs, bytealigned=None): """Read up to and including next occurrence of bs and return result. bs -- The bitstring to find. An integer is not permitted. bytealigned -- If True the bitstring will only be found on byte boundaries. Raises ValueError if bs is empty. Raises ReadError if bs is not found. """ if isinstance(bs, numbers.Integral): raise ValueError("Integers cannot be searched for") bs = Bits(bs) oldpos = self._pos p = self.find(bs, self._pos, bytealigned=bytealigned) if not p: raise ReadError("Substring not found") self._pos += bs.len return self._slice(oldpos, self._pos) def peek(self, fmt): """Interpret next bits according to format string and return result. fmt -- Token string describing how to interpret the next bits. The position in the bitstring is not changed. If not enough bits are available then all bits to the end of the bitstring will be used. Raises ReadError if not enough bits are available. Raises ValueError if the format is not understood. See the docstring for 'read' for token examples. """ pos_before = self._pos value = self.read(fmt) self._pos = pos_before return value def peeklist(self, fmt, **kwargs): """Interpret next bits according to format string(s) and return list. fmt -- One or more strings with comma separated tokens describing how to interpret the next bits in the bitstring. kwargs -- A dictionary or keyword-value pairs - the keywords used in the format string will be replaced with their given value. The position in the bitstring is not changed. If not enough bits are available then all bits to the end of the bitstring will be used. Raises ReadError if not enough bits are available. Raises ValueError if the format is not understood. See the docstring for 'read' for token examples. """ pos = self._pos return_values = self.readlist(fmt, **kwargs) self._pos = pos return return_values def bytealign(self): """Align to next byte and return number of skipped bits. Raises ValueError if the end of the bitstring is reached before aligning to the next byte. """ skipped = (8 - (self._pos % 8)) % 8 self.pos += self._offset + skipped assert self._assertsanity() return skipped pos = property(_getbitpos, _setbitpos, doc="""The position in the bitstring in bits. Read and write. """) bitpos = property(_getbitpos, _setbitpos, doc="""The position in the bitstring in bits. Read and write. """) bytepos = property(_getbytepos, _setbytepos, doc="""The position in the bitstring in bytes. Read and write. """) class BitStream(ConstBitStream, BitArray): """A container or stream holding a mutable sequence of bits Subclass of the ConstBitStream and BitArray classes. Inherits all of their methods. Methods: all() -- Check if all specified bits are set to 1 or 0. any() -- Check if any of specified bits are set to 1 or 0. append() -- Append a bitstring. bytealign() -- Align to next byte boundary. byteswap() -- Change byte endianness in-place. count() -- Count the number of bits set to 1 or 0. cut() -- Create generator of constant sized chunks. endswith() -- Return whether the bitstring ends with a sub-string. find() -- Find a sub-bitstring in the current bitstring. findall() -- Find all occurrences of a sub-bitstring in the current bitstring. insert() -- Insert a bitstring. invert() -- Flip bit(s) between one and zero. join() -- Join bitstrings together using current bitstring. overwrite() -- Overwrite a section with a new bitstring. peek() -- Peek at and interpret next bits as a single item. peeklist() -- Peek at and interpret next bits as a list of items. prepend() -- Prepend a bitstring. read() -- Read and interpret next bits as a single item. readlist() -- Read and interpret next bits as a list of items. replace() -- Replace occurrences of one bitstring with another. reverse() -- Reverse bits in-place. rfind() -- Seek backwards to find a sub-bitstring. rol() -- Rotate bits to the left. ror() -- Rotate bits to the right. set() -- Set bit(s) to 1 or 0. split() -- Create generator of chunks split by a delimiter. startswith() -- Return whether the bitstring starts with a sub-bitstring. tobytes() -- Return bitstring as bytes, padding if needed. tofile() -- Write bitstring to file, padding if needed. unpack() -- Interpret bits using format string. Special methods: Mutating operators are available: [], <<=, >>=, +=, *=, &=, |= and ^= in addition to [], ==, !=, +, *, ~, <<, >>, &, | and ^. Properties: bin -- The bitstring as a binary string. bool -- For single bit bitstrings, interpret as True or False. bytepos -- The current byte position in the bitstring. bytes -- The bitstring as a bytes object. float -- Interpret as a floating point number. floatbe -- Interpret as a big-endian floating point number. floatle -- Interpret as a little-endian floating point number. floatne -- Interpret as a native-endian floating point number. hex -- The bitstring as a hexadecimal string. int -- Interpret as a two's complement signed integer. intbe -- Interpret as a big-endian signed integer. intle -- Interpret as a little-endian signed integer. intne -- Interpret as a native-endian signed integer. len -- Length of the bitstring in bits. oct -- The bitstring as an octal string. pos -- The current bit position in the bitstring. se -- Interpret as a signed exponential-Golomb code. ue -- Interpret as an unsigned exponential-Golomb code. sie -- Interpret as a signed interleaved exponential-Golomb code. uie -- Interpret as an unsigned interleaved exponential-Golomb code. uint -- Interpret as a two's complement unsigned integer. uintbe -- Interpret as a big-endian unsigned integer. uintle -- Interpret as a little-endian unsigned integer. uintne -- Interpret as a native-endian unsigned integer. """ __slots__ = () # As BitStream objects are mutable, we shouldn't allow them to be hashed. __hash__ = None def __init__(self, auto=None, length=None, offset=None, **kwargs): """Either specify an 'auto' initialiser: auto -- a string of comma separated tokens, an integer, a file object, a bytearray, a boolean iterable or another bitstring. Or initialise via **kwargs with one (and only one) of: bytes -- raw data as a string, for example read from a binary file. bin -- binary string representation, e.g. '0b001010'. hex -- hexadecimal string representation, e.g. '0x2ef' oct -- octal string representation, e.g. '0o777'. uint -- an unsigned integer. int -- a signed integer. float -- a floating point number. uintbe -- an unsigned big-endian whole byte integer. intbe -- a signed big-endian whole byte integer. floatbe - a big-endian floating point number. uintle -- an unsigned little-endian whole byte integer. intle -- a signed little-endian whole byte integer. floatle -- a little-endian floating point number. uintne -- an unsigned native-endian whole byte integer. intne -- a signed native-endian whole byte integer. floatne -- a native-endian floating point number. se -- a signed exponential-Golomb code. ue -- an unsigned exponential-Golomb code. sie -- a signed interleaved exponential-Golomb code. uie -- an unsigned interleaved exponential-Golomb code. bool -- a boolean (True or False). filename -- a file which will be opened in binary read-only mode. Other keyword arguments: length -- length of the bitstring in bits, if needed and appropriate. It must be supplied for all integer and float initialisers. offset -- bit offset to the data. These offset bits are ignored and this is intended for use when initialising using 'bytes' or 'filename'. """ self._pos = 0 # For mutable BitStreams we always read in files to memory: if not isinstance(self._datastore, (ByteStore, ConstByteStore)): self._ensureinmemory() def __new__(cls, auto=None, length=None, offset=None, **kwargs): x = super(BitStream, cls).__new__(cls) y = ConstBitStream.__new__(BitStream, auto, length, offset, **kwargs) x._datastore = ByteStore(y._datastore._rawarray[:], y._datastore.bitlength, y._datastore.offset) return x def __copy__(self): """Return a new copy of the BitStream.""" s_copy = BitStream() s_copy._pos = 0 if not isinstance(self._datastore, ByteStore): # Let them both point to the same (invariant) array. # If either gets modified then at that point they'll be read into memory. s_copy._datastore = self._datastore else: s_copy._datastore = ByteStore(self._datastore._rawarray[:], self._datastore.bitlength, self._datastore.offset) return s_copy def prepend(self, bs): """Prepend a bitstring to the current bitstring. bs -- The bitstring to prepend. """ bs = self._converttobitstring(bs) self._prepend(bs) self._pos += bs.len def pack(fmt, *values, **kwargs): """Pack the values according to the format string and return a new BitStream. fmt -- A single string or a list of strings with comma separated tokens describing how to create the BitStream. values -- Zero or more values to pack according to the format. kwargs -- A dictionary or keyword-value pairs - the keywords used in the format string will be replaced with their given value. Token examples: 'int:12' : 12 bits as a signed integer 'uint:8' : 8 bits as an unsigned integer 'float:64' : 8 bytes as a big-endian float 'intbe:16' : 2 bytes as a big-endian signed integer 'uintbe:16' : 2 bytes as a big-endian unsigned integer 'intle:32' : 4 bytes as a little-endian signed integer 'uintle:32' : 4 bytes as a little-endian unsigned integer 'floatle:64': 8 bytes as a little-endian float 'intne:24' : 3 bytes as a native-endian signed integer 'uintne:24' : 3 bytes as a native-endian unsigned integer 'floatne:32': 4 bytes as a native-endian float 'hex:80' : 80 bits as a hex string 'oct:9' : 9 bits as an octal string 'bin:1' : single bit binary string 'ue' / 'uie': next bits as unsigned exp-Golomb code 'se' / 'sie': next bits as signed exp-Golomb code 'bits:5' : 5 bits as a bitstring object 'bytes:10' : 10 bytes as a bytes object 'bool' : 1 bit as a bool 'pad:3' : 3 zero bits as padding >>> s = pack('uint:12, bits', 100, '0xffe') >>> t = pack(['bits', 'bin:3'], s, '111') >>> u = pack('uint:8=a, uint:8=b, uint:55=a', a=6, b=44) """ tokens = [] if isinstance(fmt, basestring): fmt = [fmt] try: for f_item in fmt: _, tkns = tokenparser(f_item, tuple(sorted(kwargs.keys()))) tokens.extend(tkns) except ValueError as e: raise CreationError(*e.args) value_iter = iter(values) s = BitStream() try: for name, length, value in tokens: # If the value is in the kwd dictionary then it takes precedence. if value in kwargs: value = kwargs[value] # If the length is in the kwd dictionary then use that too. if length in kwargs: length = kwargs[length] # Also if we just have a dictionary name then we want to use it if name in kwargs and length is None and value is None: s.append(kwargs[name]) continue if length is not None: length = int(length) if value is None and name != 'pad': # Take the next value from the ones provided value = next(value_iter) s._append(BitStream._init_with_token(name, length, value)) except StopIteration: raise CreationError("Not enough parameters present to pack according to the " "format. {0} values are needed.", len(tokens)) try: next(value_iter) except StopIteration: # Good, we've used up all the *values. return s raise CreationError("Too many parameters present to pack according to the format.") # Whether to label the Least Significant Bit as bit 0. Default is False. Experimental feature. _lsb0 = False def _switch_lsb0_methods(): if _lsb0: ConstByteStore.getbit = ConstByteStore._getbit_lsb0 Bits.find = Bits._find_lsb0 Bits._slice = Bits._slice_lsb0 BitArray._overwrite = BitArray._overwrite_lsb0 BitArray._insert = BitArray._insert_lsb0 BitArray._delete = BitArray._delete_lsb0 ByteStore.setbit = ByteStore._setbit_lsb0 ByteStore.unsetbit = ByteStore._unsetbit_lsb0 ByteStore.invertbit = ByteStore._invertbit_lsb0 else: ConstByteStore.getbit = ConstByteStore._getbit_msb0 Bits.find = Bits._find_msb0 Bits._slice = Bits._slice_msb0 BitArray._overwrite = BitArray._overwrite_msb0 BitArray._insert = BitArray._insert_msb0 BitArray._delete = BitArray._delete_msb0 ByteStore.setbit = ByteStore._setbit_msb0 ByteStore.unsetbit = ByteStore._unsetbit_msb0 ByteStore.invertbit = ByteStore._invertbit_msb0 def set_lsb0(v=True): """Experimental method changing the bit numbering so that the least significant bit is bit 0""" global _lsb0 _lsb0 = bool(v) _switch_lsb0_methods() def set_msb0(v=True): """Experimental method to reset the bit numbering so that the most significant bit is bit 0""" global _lsb0 _lsb0 = not bool(v) _switch_lsb0_methods() _switch_lsb0_methods() # Aliases for backward compatibility ConstBitArray = Bits BitString = BitStream __all__ = ['ConstBitArray', 'ConstBitStream', 'BitStream', 'BitArray', 'Bits', 'BitString', 'pack', 'Error', 'ReadError', 'InterpretError', 'ByteAlignError', 'CreationError', 'bytealigned', 'set_lsb0', 'set_msb0'] if __name__ == '__main__': """Create and interpret a bitstring from command-line parameters. Command-line parameters are concatenated and a bitstring created from them. If the final parameter is either an interpretation string or ends with a '.' followed by an interpretation string then that interpretation of the bitstring will be used when printing it. Typical usage might be invoking the Python module from a console as a one-off calculation: $ python -m bitstring int:16=-400 0xfe70 $ python -m bitstring float:32=0.2 bin 00111110010011001100110011001101 $ python -m bitstring 0xff 3*0b01,0b11 uint 65367 $ python -m bitstring hex=01, uint:12=352.hex 01160 This feature is experimental and is subject to change or removal. """ # check if final parameter is an interpretation string fp = sys.argv[-1] if fp in name_to_read.keys(): # concatenate all other parameters and interpret using the final one b1 = Bits(','.join(sys.argv[1: -1])) print(b1._readtoken(fp, 0, b1.__len__())[0]) else: # does final parameter end with a dot then an interpretation string? interp = fp[fp.rfind('.') + 1:] if interp in name_to_read.keys(): sys.argv[-1] = fp[:fp.rfind('.')] b1 = Bits(','.join(sys.argv[1:])) print(b1._readtoken(interp, 0, b1.__len__())[0]) else: # No interpretation - just use default print b1 = Bits(','.join(sys.argv[1:])) print(b1) bitstring-bitstring-3.1.7/doc/000077500000000000000000000000001365434337700163165ustar00rootroot00000000000000bitstring-bitstring-3.1.7/doc/appendices.rst000066400000000000000000000006041365434337700211630ustar00rootroot00000000000000########### Appendices ########### Gathered together here are a few odds and ends that didn't fit well into either the user manual or the reference section. The only unifying theme is that none of them provide any vital knowledge about :mod:`bitstring`, and so they can all be safely ignored. .. toctree:: :maxdepth: 2 examples exp-golomb optimisation release_notes bitstring-bitstring-3.1.7/doc/bitarray.rst000066400000000000000000000302741365434337700206730ustar00rootroot00000000000000.. currentmodule:: bitstring The BitArray class ------------------ .. class:: BitArray([auto, length, offset, **kwargs]) The :class:`Bits` class is the base class for :class:`BitArray` and so (with the exception of :meth:`~Bits.__hash__`) all of its methods are also available for :class:`BitArray` objects. The initialiser is also the same as for :class:`Bits` and so won't be repeated here. A :class:`BitArray` is a mutable :class:`Bits`, and so the one thing all of the methods listed here have in common is that they can modify the contents of the bitstring. .. method:: append(bs) Join a :class:`BitArray` to the end of the current :class:`BitArray`. :: >>> s = BitArray('0xbad') >>> s.append('0xf00d') >>> s BitArray('0xbadf00d') .. method:: byteswap([fmt, start, end, repeat=True]) Change the endianness of the :class:`BitArray` in-place according to *fmt*. Return the number of swaps done. The *fmt* can be an integer, an iterable of integers or a compact format string similar to those used in :func:`pack` (described in :ref:`compact_format`). It defaults to 0, which means reverse as many bytes as possible. The *fmt* gives a pattern of byte sizes to use to swap the endianness of the :class:`BitArray`. Note that if you use a compact format string then the endianness identifier (``<``, ``>`` or ``@``) is not needed, and if present it will be ignored. *start* and *end* optionally give a slice to apply the transformation to (it defaults to the whole :class:`BitArray`). If *repeat* is ``True`` then the byte swapping pattern given by the *fmt* is repeated in its entirety as many times as possible. >>> s = BitArray('0x00112233445566') >>> s.byteswap(2) 3 >>> s BitArray('0x11003322554466') >>> s.byteswap('h') 3 >>> s BitArray('0x00112233445566') >>> s.byteswap([2, 5]) 1 >>> s BitArray('0x11006655443322') It can also be used to swap the endianness of the whole :class:`BitArray`. :: >>> s = BitArray('uintle:32=1234') >>> s.byteswap() >>> print(s.uintbe) 1234 .. method:: clear() Removes all bits from the bitstring. ``s.clear()`` is equivalent to ``del s[:]`` and simply makes the bitstring empty. .. method:: copy() Returns a copy of the bitstring. ``s.copy()`` is equivalent to the shallow copy ``s[:]`` and creates a new copy of the bitstring in memory. .. method:: insert(bs, pos) Inserts *bs* at *pos*. When used with the :class:`BitStream` class the *pos* is optional, and if not present the current bit position will be used. After insertion the property :attr:`~ConstBitStream.pos` will be immediately after the inserted bitstring. :: >>> s = BitStream('0xccee') >>> s.insert('0xd', 8) >>> s BitStream('0xccdee') >>> s.insert('0x00') >>> s BitStream('0xccd00ee') .. method:: invert([pos]) Inverts one or many bits from ``1`` to ``0`` or vice versa. *pos* can be either a single bit position or an iterable of bit positions. Negative numbers are treated in the same way as slice indices and it will raise :exc:`IndexError` if ``pos < -s.len`` or ``pos > s.len``. The default is to invert the entire :class:`BitArray`. :: >>> s = BitArray('0b111001') >>> s.invert(0) >>> s.bin '011001' >>> s.invert([-2, -1]) >>> s.bin '011010' >>> s.invert() >>> s.bin '100101' .. method:: overwrite(bs, pos) Replaces the contents of the current :class:`BitArray` with *bs* at *pos*. When used with the :class:`BitStream` class the *pos* is optional, and if not present the current bit position will be used. After insertion the property :attr:`~ConstBitStream.pos` will be immediately after the overwritten bitstring. :: >>> s = BitArray(length=10) >>> s.overwrite('0b111', 3) >>> s BitArray('0b0001110000') >>> s.pos 6 .. method:: prepend(bs) Inserts *bs* at the beginning of the current :class:`BitArray`. :: >>> s = BitArray('0b0') >>> s.prepend('0xf') >>> s BitArray('0b11110') .. method:: replace(old, new[, start, end, count, bytealigned]) Finds occurrences of *old* and replaces them with *new*. Returns the number of replacements made. If *bytealigned* is ``True`` then replacements will only be made on byte boundaries. *start* and *end* give the search range and default to ``0`` and :attr:`~Bits.len` respectively. If *count* is specified then no more than this many replacements will be made. :: >>> s = BitArray('0b0011001') >>> s.replace('0b1', '0xf') 3 >>> print(s.bin) 0011111111001111 >>> s.replace('0b1', '', count=6) 6 >>> print(s.bin) 0011001111 .. method:: reverse([start, end]) Reverses bits in the :class:`BitArray` in-place. *start* and *end* give the range and default to ``0`` and :attr:`~Bits.len` respectively. :: >>> a = BitArray('0b10111') >>> a.reverse() >>> a.bin '11101' .. method:: rol(bits[, start, end]) Rotates the contents of the :class:`BitArray` in-place by *bits* bits to the left. *start* and *end* define the slice to use and default to ``0`` and :attr:`~Bits.len` respectively. Raises :exc:`ValueError` if ``bits < 0``. :: >>> s = BitArray('0b01000001') >>> s.rol(2) >>> s.bin '00000101' .. method:: ror(bits[, start, end]) Rotates the contents of the :class:`BitArray` in-place by *bits* bits to the right. *start* and *end* define the slice to use and default to ``0`` and :attr:`~Bits.len` respectively. Raises :exc:`ValueError` if ``bits < 0``. .. method:: set(value[, pos]) Sets one or many bits to either ``1`` (if *value* is ``True``) or ``0`` (if *value* isn't ``True``). *pos* can be either a single bit position or an iterable of bit positions. Negative numbers are treated in the same way as slice indices and it will raise :exc:`IndexError` if ``pos < -s.len`` or ``pos > s.len``. The default is to set every bit in the :class:`BitArray`. Using ``s.set(True, x)`` can be more efficient than other equivalent methods such as ``s[x] = 1``, ``s[x] = "0b1"`` or ``s.overwrite('0b1', x)``, especially if many bits are being set. :: >>> s = BitArray('0x0000') >>> s.set(True, -1) >>> print(s) 0x0001 >>> s.set(1, (0, 4, 5, 7, 9)) >>> s.bin '1000110101000001' >>> s.set(0) >>> s.bin '0000000000000000' .. attribute:: bin Writable version of :attr:`Bits.bin`. .. attribute:: bool Writable version of :attr:`Bits.bool`. .. attribute:: bytes Writable version of :attr:`Bits.bytes`. .. attribute:: hex Writable version of :attr:`Bits.hex`. .. attribute:: int Writable version of :attr:`Bits.int`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. :: >>> s = BitArray('0xf3') >>> s.int -13 >>> s.int = 1232 ValueError: int 1232 is too large for a BitArray of length 8. .. attribute:: intbe Writable version of :attr:`Bits.intbe`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: intle Writable version of :attr:`Bits.intle`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: intne Writable version of :attr:`Bits.intne`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: float .. attribute:: floatbe Writable version of :attr:`Bits.float`. .. attribute:: floatle Writable version of :attr:`Bits.floatle`. .. attribute:: floatne Writable version of :attr:`Bits.floatne`. .. attribute:: oct Writable version of :attr:`Bits.oct`. .. attribute:: se Writable version of :attr:`Bits.se`. .. attribute:: ue Writable version of :attr:`Bits.uie`. .. attribute:: sie Writable version of :attr:`Bits.sie`. .. attribute:: uie Writable version of :attr:`Bits.ue`. .. attribute:: uint Writable version of :attr:`Bits.uint`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: uintbe Writable version of :attr:`Bits.uintbe`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: uintle Writable version of :attr:`Bits.uintle`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. attribute:: uintne Writable version of :attr:`Bits.uintne`. When used as a setter the value must fit into the current length of the :class:`BitArray`, else a :exc:`ValueError` will be raised. .. method:: __delitem__(key) ``del s[start:end:step]`` Deletes the slice specified. .. method:: __iadd__(bs) ``s1 += s2`` Appends *bs* to the current bitstring. Note that for :class:`BitArray` objects this will be an in-place change, whereas for :class:`Bits` objects using ``+=`` will not call this method - instead a new object will be created (it is equivalent to a copy and an :meth:`~Bits.__add__`). :: >>> s = BitArray(ue=423) >>> s += BitArray(ue=12) >>> s.read('ue') 423 >>> s.read('ue') 12 .. method:: __iand__(bs) ``s &= bs`` In-place bit-wise AND between two bitstrings. If the two bitstrings are not the same length then a :exc:`ValueError` is raised. .. method:: __ilshift__(n) ``s <<= n`` Shifts the bits in-place *n* bits to the left. The *n* right-most bits will become zeros and bits shifted off the left will be lost. .. method:: __imul__(n) ``s *= n`` In-place concatenation of *n* copies of the current bitstring. >>> s = BitArray('0xbad') >>> s *= 3 >>> s.hex 'badbadbad' .. method:: __ior__(bs) ``s |= bs`` In-place bit-wise OR between two bitstrings. If the two bitstrings are not the same length then a :exc:`ValueError` is raised. .. method:: __irshift__(n) ``s >>= n`` Shifts the bits in-place *n* bits to the right. The *n* left-most bits will become zeros and bits shifted off the right will be lost. .. method:: __ixor__(bs) ``s ^= bs`` In-place bit-wise XOR between two bitstrings. If the two bitstrings are not the same length then a :exc:`ValueError` is raised. .. method:: __setitem__(key, value) ``s1[start:end:step] = s2`` Replaces the slice specified with a new value. :: >>> s = BitArray('0x00000000') >>> s[::8] = '0xf' >>> print(s) 0x80808080 >>> s[-12:] = '0xf' >>> print(s) 0x80808f bitstring-bitstring-3.1.7/doc/bitstream.rst000066400000000000000000000012671365434337700210500ustar00rootroot00000000000000.. currentmodule:: bitstring The BitStream class ------------------- .. class:: BitStream([auto, length, offset, **kwargs]) Both the :class:`BitArray` and the :class:`ConstBitStream` classes are base classes for :class:`BitStream` and so all of their methods are also available for :class:`BitStream` objects. The initialiser is also the same as for :class:`Bits` and so won't be repeated here. A :class:`BitStream` is a mutable container of bits with methods and properties that allow it to be parsed as a stream of bits. There are no additional methods or properties in this class - see its base classes (:class:`Bits`, :class:`BitArray` and :class:`ConstBitStream`) for details. bitstring-bitstring-3.1.7/doc/bitstring_classes.rst000066400000000000000000000132251365434337700225750ustar00rootroot00000000000000.. module:: bitstring .. moduleauthor:: Scott Griffiths The bitstring module -------------------- The bitstring module provides four classes, :class:`Bits`, :class:`BitArray`, :class:`ConstBitStream` and :class:`BitStream`. :class:`Bits` is the simplest, and represents an immutable sequence of bits, while :class:`BitArray` adds various methods that modify the contents (these classes are intended to loosely mirror ``bytes`` and ``bytearray`` in Python 3). The 'Stream' classes have additional methods to treat the bits as a file or stream. If you need to change the contents of a bitstring after creation then you must use either the :class:`BitArray` or :class:`BitStream` classes. If you need to use bitstrings as keys in a dictionary or members of a set then you must use either a :class:`Bits` or a :class:`ConstBitStream`. In this section the generic term 'bitstring' is used to refer to an object of any of these classes. Note that for the bitstream classes the bit position within the bitstream (the position from which reads occur) can change without affecting the equality operation. This means that the :attr:`~ConstBitStream.pos` and :attr:`~ConstBitStream.bytepos` properties can change even for a :class:`ConstBitStream` object. The public methods, special methods and properties of both classes are detailed in this section. .. _auto_init: The auto initialiser ^^^^^^^^^^^^^^^^^^^^ Note that in places where a bitstring can be used as a parameter, any other valid input to the ``auto`` initialiser can also be used. This means that the parameter can also be a format string which consists of tokens: * Starting with ``hex=``, or simply starting with ``0x`` implies hexadecimal. e.g. ``0x013ff``, ``hex=013ff`` * Starting with ``oct=``, or simply starting with ``0o`` implies octal. e.g. ``0o755``, ``oct=755`` * Starting with ``bin=``, or simply starting with ``0b`` implies binary. e.g. ``0b0011010``, ``bin=0011010`` * Starting with ``int:`` or ``uint:`` followed by a length in bits and ``=`` gives base-2 integers. e.g. ``uint:8=255``, ``int:4=-7`` * To get big, little and native-endian whole-byte integers append ``be``, ``le`` or ``ne`` respectively to the ``uint`` or ``int`` identifier. e.g. ``uintle:32=1``, ``intne:16=-23`` * For floating point numbers use ``float:`` followed by the length in bits and ``=`` and the number. The default is big-endian, but you can also append ``be``, ``le`` or ``ne`` as with integers. e.g. ``float:64=0.2``, ``floatle:32=-0.3e12`` * Starting with ``ue=``, ``uie=``, ``se=`` or ``sie=`` implies an exponential-Golomb coded integer. e.g. ``ue=12``, ``sie=-4`` Multiples tokens can be joined by separating them with commas, so for example ``se=4, 0b1, se=-1`` represents the concatenation of three elements. Parentheses and multiplicative factors can also be used, for example ``2*(0b10, 0xf)`` is equivalent to ``0b10, 0xf, 0b10, 0xf``. The multiplying factor must come before the thing it is being used to repeat. The ``auto`` parameter also accepts other types: * A list or tuple, whose elements will be evaluated as booleans (imagine calling ``bool()`` on each item) and the bits set to ``1`` for ``True`` items and ``0`` for ``False`` items. * A positive integer, used to create a bitstring of that many zero bits. * A file object, presumably opened in read-binary mode, from which the bitstring will be formed. * A ``bytearray`` object. * An ``array`` object. This is used after being converted to it's constituent byte data via its ``tostring`` method. * In Python 3 only, a ``bytes`` object. Note this won't work for Python 2.7 as ``bytes`` is just a synonym for ``str``. Compact format strings ^^^^^^^^^^^^^^^^^^^^^^ For the :meth:`~ConstBitStream.read`, :meth:`~Bits.unpack`, :meth:`~ConstBitStream.peek` methods and :func:`pack` function you can use compact format strings similar to those used in the :mod:`struct` and :mod:`array` modules. These start with an endian identifier: ``>`` for big-endian, ``<`` for little-endian or ``@`` for native-endian. This must be followed by at least one of these codes: +------+------------------------------------+ |Code | Interpretation | +======+====================================+ |``b`` | 8 bit signed integer | +------+------------------------------------+ |``B`` | 8 bit unsigned integer | +------+------------------------------------+ |``h`` | 16 bit signed integer | +------+------------------------------------+ |``H`` | 16 bit unsigned integer | +------+------------------------------------+ |``l`` | 32 bit signed integer | +------+------------------------------------+ |``L`` | 32 bit unsigned integer | +------+------------------------------------+ |``q`` | 64 bit signed integer | +------+------------------------------------+ |``Q`` | 64 bit unsigned integer | +------+------------------------------------+ |``f`` | 32 bit floating point number | +------+------------------------------------+ |``d`` | 64 bit floating point number | +------+------------------------------------+ For more detail see :ref:`compact_format`. Class properties ^^^^^^^^^^^^^^^^ Bitstrings use a wide range of properties for getting and setting different interpretations on the binary data, as well as accessing bit lengths and positions. For the mutable :class:`BitStream` and :class:`BitArray` objects the properties are all read and write (with the exception of the :attr:`~Bits.len`), whereas for immutable objects the only write enabled properties are for the position in the bitstream (:attr:`~ConstBitStream.pos`/:attr:`~ConstBitStream.bitpos` and :attr:`~ConstBitStream.bytepos`). bitstring-bitstring-3.1.7/doc/bitstring_logo.png000066400000000000000000001504021365434337700220530ustar00rootroot00000000000000‰PNG  IHDR üdÀ¡RiCCPICC ProfilexÕYuXT_·ÞçLÃPCw§H·tIH‡ RC ÝJ)! " ‚ˆ !  &¢ ¨`‚pÆïûîóÝûßýçîç9{ÞYkíµ÷œµÏÚg½Û²[p°?L@@`x¨•¡ïAG^Ü € E.57RX°¶……)ø_Û÷ Äic’»¾þW³ÿYAïáF²@Ôîa¤_Ö!‡†€ZGäÃQáÁF?@0c(²@¿ÜÅÞ¿ñÊ.vÿ…1è_66Vº`X  vs õ€ ˆÈy#IÞˆ‚X†@r ăÖ ù¸yÀV„Øì ÚÅ}uÿ7?Þÿ†ÝÜÜÿñéææýþý[‘ÈÄzä°`·˜__þ/»ÿä~ýj HOèo¶fäZðpÓ3A>9‘k;ØÿẄÝ3ÐÖ‘íâ=îfæ°†W¨‚‘±Ep¸Î.FîänaóGžë£k†`jDžï¦ÿ×O…¯›ñnÌhysh„•-‚Üi­`dGAob}lìÿØ|õðÔû#‡a/²Ño˜n´;#s~¿ “Ý5 sÁŠÀøOB‘>HS  ôþô’À ¸!šHDüÀ[ #‚1Aæýc§ûƒ_㼑qÿÝ#/ !¶ÿÌù{6^dο>ÉÀÁånÈ»ºÝÕ…¹“ÿ5ç_‹]¿V#]/½(½õwMha´,Z­ƒVGk U/šÍ$Ñòhe´6Z­†èT€xƒxöþ»Æ]ÿÍ^‘EA1ªv>ˆv÷·»ÿÕ»_Öä¾ÿÇ yh¹eùï ÷ŒFžtƒ‚cBÉÞ>á¼Úȓ빇×(´w¯¬´ŒÌ®úÿMÛÍY¿ûÅêW.‚˜ÿKЀ2ÙÎÿ’¹Ÿ ]yöëÿ%.@rƒ/‚¤ˆÐÈßþл@…äBFÀ¸Eî³,Pj@ èc`l€pFö²CAˆGA:ȧÀP ÊA¨  ´€pÜ`Œƒ`̃%°¾ƒM‚p"Bl$I@²2¤éC¦ä¹BÞP ÅC)P”Cç¡:è*ÔÝB#Ð3hZ„>C?`L 3Â\°0,+ÃÚ° l†½á8N…sà"¸¾ ß„ïÀð8< /ÁßP…G1£øP’(e”.ÊåˆòB…¢Q™¨T%ê ªu5†šF-£6ÐX4Í‹–Döé~´-š„A'¢³ÑÅèZôMtz =ƒ^AocNŒFc„9ˆñÆDaÒ1˜Ì Ì]Ì8fó‹Å2cE°JØýX¬/6›=‡mÄvcG°sØo8Ž 'SÇ™ãÜpá¸tÜYÜeÜmÜ(n·N§à¡¥0 p¤¤H¦( ¸DÑE1JñŽb“’ŽRˆR•ÒœÒƒ2†ò$e5e;åcÊyÊM*z**u**_ª£TETW¨îR½¤ú‚Çãùñ*xK<_„oÂ?ÀÏà7¨¨Å©u©¨#¨s¨/RwS?£þB „ ZGB8!‡PGè%LÖiˆ4{iŒh€>›þýCúƒ0ƒ>ƒC*CC/ÃE êIÄb5ñ.qžË(ÂhÄè˘ÅØÀ8ĸÂÄÀ$ÏdÇÍTÂÔÉ4ÍŒbf6bög>ÉÜÌ<Áüƒ…‹E›Å“%ƒå Ë(Ë+««'k&k#ë8ë6^6}6?¶\¶¶WìhvqvKö(ö2ö»ìËŒj$ŽLŽfŽçœ0§8§ggç ç7.n.C®`®³\½\ËÜÌÜZܾÜùÜ]Ü‹Ïmž÷¼L¼Ú¼þ¼E¼}¼+|œ|ûù"øÎó ñmò‹ðÛò'ó7ò¿ PðÈèXä< /X/ø\ˆRHYÈG¨Pè¾Ðš°ˆ°½ð1ááV#‘X‘z‘—¢QMÑÑJÑ'bX1e1?±sbÃâ°¸‚¸x‰øc XBQ‚,qNbdfÊžÀ=•{&%©%µ%#%ë%gö2ï5Ý›¼·eïG)A)G©\©ûRÛÒ ÒþÒÕÒ/ddŒe’eÚe>ËŠË’dKdŸÈä ä’äZåVå%ä=åËäŸ*(SèQø©¨¤ªxEqQIPÉU©TiR™QÙB9[ù FEG%I¥CeCUQ5\µYõ“š¤šŸÚ%µ…}"û<÷Uï›SçWwS?¯>­Á«áªQ¡1­É§é¦Y©9«% å¡U£õN[LÛWû²öGiP:kºªº ºÝz(=C½L½!}}[ýbý)~oƒzƒCÃ8Ãîý˜ý&ûs÷Oq‘ŒêŒVŒ•ŒŒûL¨M¬MŠMfMÅMCMÛÀŒœ>ðÒLÈ,ЬŘ™Ÿ6e!bbqËkiaYbùÖJÆ*Þê¾5ÑÚÅú’õw›“6/lEm#l{ìhíœìêìÖìõìóì§JL88àÀî@vhuÄ9Ú9Ö8~;¤èÌ¡y'§t§‰Ã"‡£?tfwöwît¡uqs¹æŠqµw½äºåfîVéöÍÝȽÔ}…¤K*$-yhyä{,zª{æy¾óR÷ÊóZðV÷>í½è£éSà³LÖ%“W}÷û–û®ù™û]ôÛñ·÷o  p h dô ì ⊠–NžQ 9²jZ…k gD^#D#Ò"f"5"K"ף좮EÓGFƈÇdļ‹5ˆ½‡Ž#ÅõÄóÅŸIÐN8Ÿ%º'ö$ $¥&Í1Åã%:%¥œ¥¥kç<Ζi•])ç*Ï*ÿQA®xzÞðüÍJáÊ‚*lUdÕÛj»êû”/ÔÕ°×dÕü¼xqºÖª¶¯N©®î祓õp}Dýâe§Ëà z ­W$¯œodnÌjMMﯺ^h6i|íÊu¡ë¥7ˆ72oB7cn®´ø´L·:´Ž´·õ´«µß¸µ÷ÖžŽ’N¦Î“]T]©];·coëî^¾ã}g®Ç¥çEïÁÞ'}–}CwMî>¸gp¯÷¾öýÛÔtVzÜ:¬2Ü>²o¤kTsôΘÞؽ'FOÆÍÆG&l'žN:MN?õxºðÌÿÙêóÈç›/Ž¼Ä¼Ì|E÷ª`ŠsªòµØëÆiÅéν™ÁYëÙs¤¹¥7ao¶æSßÞ¼ãyW· »Ð±h°8üþÐûù¥à¥ÍåôôJ?Š~¼þIëÓàÊÁ•ùÕÐÕÏÙ_ؾ\ü*ÿµç›Å·©ïß7×2×ÙÖk7”7îÿ°ÿñn3j ·UôSìgû¶ÉöË€`·P·_ï(¤‡½¼ø|yOp@j‡a¨h~׿,rBllí…–às(g´ú=¦[„ ¦°¢Ô§RÄKQï%HÐ(ӚйÒG0œ!¶1Î0S³h³†²5°/qŠqùr7ñ¬óéñŸ˜’>&òJLAü”IJ¤þÞ*©m'Ùvyv…hÅqe9•Õå}†ê?´¬´/èlè™è,ì—7Š3î2…h™Åš7YÌYÑ[«ÛxئÙUØ_;xÛ¡×±ûP›SãáçR—S®Én!îÎ$S%O~/‚ך÷ŒO?¹Ù·Ø/ÙŸ`¨Ä´<RšfÎþ)¢+2'Ê)Z"úGLlq9^9›0–XžäDç¨`2c m*]}:Ý1ÂqÊ tÆNæFÖç쥳9ÏOŽžÈíÉk;}%¿êÌÙ‚œÂ”¢¸³1ÅÉ%E¥7Î —Í–/W¬œ_©\©úTýñ‡š¥‹ µoêf.ÍÕ¯6Ð_ÑmLlj¹úºyý:îñ&O‹x«B›f»Ñ-ë÷Î订ÛwºzнÄ>ö»¼÷Äï+=Ðy¨Ó/Úÿi smðü#ÍGËC C‡UF ‘G£ec!OôÇÙÆ?NôN>õy¦ølçy÷‹Ø—r/—_5L…½Þ7)õš“™Û|so>ÿ­ç;Õ†…÷‹]ï³—ì—ù–?\ýûIg¿2¾Úð¹ìËõ¯kß½ÖžohýÈßœþ)·¿³ó+þPì€b@=@§cL°LØW¸kÙ”þT¶x=j9‚­(½ƒÑŽ1)•¹Š¥u‰žCƒ“ÌUÌ=ȳçÌ.pEð½°„ˆh­Ø’„äžPÉ{7¤5eŽÊÞ—Ç+˜*æ(¨U-Ôröõk`55µ"µku^èáõU Ü 3ö× /šÂXÌDÌå,T-U­ä¬mhl¾Ù>·ë¶¯>˜éèh}HɉÃiçð¬sŸKkº›‡»‰“´æ1âYï•æíì£D¦#/øÞö+ô Ðdüt;8'Ä1”?t1¬)<*B5âgdWTR´V :æAì‰8‹xbüxBaâ!$³®é=Zžœ’˜ê˜f˜.Œï8õñµŒÙÌÁ¬›Ù'Žç„ž<|Ê4W3OáôÞ|Ñ3üœ…,Eôg©ŠÑÅ[%_K—ÎM—M–T Ÿ¯|]µT½^ƒºHSËV'xIº~ßeƒó+žM‘W³›k¯õ]Ÿº±ÚµÒµñµËÝ2è8ÔÜ•~»¤»îNCOu奄ð»6÷dïÓß_}ðÉMåiƒ~,‡”ó ã‡×GæF5?)O˜ Mš<•Æõó|ùÅ“—·^UMx?<ã70þ&a>ýmî»’… ‹MïÛ—z—}xñq}Eeµú‹Î7ü÷¯ë ?F·*·þÄŸ:‹Â¨4z“ŒÕÀ®ã:)ŽQ:PÉáið Ô ×hÊhOÐ¥ÐÇ2Dcc˜˜ÓYN²žckdïãxÊù‘›À#È«ÃçÊŸ"P%xWhQ„FTFÌVdÞÉÊÏö:¡”C•3}²õT^nhžõi…|¶üí3o ú ‹NŸ,v(Q-eGNËñ²å%'ΧW¦V¥U»p¬&íbBm@ÝÁKúõj—ÕL®¸5Æ7]½ÞüèÚüõÍ›ô-­ûÚ,Û½o%vœé¼ÔÕqû~wÿ‡=w{ïôuÞm½wí~ËËûÏä f?JJyœ6œ;R;úpluœkÂh2òi峡ç/_YO|==Cžc}óíf1q¹wõôºànüsK»gV€„÷°;€%¢©µ@(¡8Ú° `£`¿4Ó/¨TôŸóh@‰p(lH½)ÔfãÂ%$‚n”‚žÂ’â4Å8%¥ e åG*eªªa<7>ßMÍHíK}‡ÀAˆ"ŒÓ(Òœ¥Ù¡õ¦¥Ó¦»F/N_à ÂÐHT#2º0~e:Á,Î<ÀÌÊÂÚËÂÎÏ>Áq‚s?–ëw&%/'ï¾>þ*,ÁX¡aQg1WqO‰€=1’{ˤڥ'eÞË~”{#ÿD¡Wñ¦ÒåK*uª—Ôšöµª÷iŒiÎkmèÐêŠéè{d^ÝÿÂg"kj Ô,Åü¤E™e‹Õ J[ »(ä¼ûì((ÚéŽ3ÁÅɵÎm™Äå¡éiïà}ܧ™üÁOÉ?#àubð©ÈùÖÉÝËç_›°“äsd&Ù-åušCúøq‡Œ­¬…œœÜsùìÆEÁÅE¥­eC3•ß/Ð\«3©nhoân®¼!ÑRÖ¶ÓáÔuëooæÝ>ýcägÌ=901ôÌõÅÆTáŒòÜë·© ›KüËÛ«WWË¿°}­ü®±ön£hSgkj;ôWþ€Îˆ€ ˆ%„ï±d„UÈA˜Ÿ *„#Ð\ D¨ ꂦ‘Ø ÃÆp0\wÁoQt(U”'*uõ͉>€TèWÑo0l3L¦©¾¥±þHÜßâ„p^¸ZÜ…EE'%–Ò‚òå{*Uª,ª×xy|þ µ&õ9êŸWÂ]IšBZ m$í‰nšÞþ=C ‘–x‰Ñq)‹Y†ù9K:«<ë[¶v:ŽQÎ".wn)À3ÎÛÀ—Áï-`,(#Ä!L!¼)òUô«Ø–a€¤Æ^W© é6™÷rœò YŠƒÊô*öªgÕÆÔ! aM-/íã: ºãú°¬¡×þsF“&̦v ÌÆ,h, ­’¬ÛmÖìí£v:bY8•þìbìZíö“d‰ä©÷Þr> ä?.ÿ€{A\Á‘!caòá…[Q.Ñ]±¬qñ÷’2¬'û¦¼J³Hï=®”ÑÅŸ]œÃr²Â!ݳ`â‚öA‡‘ØŸ‡î!o™ °*L‚OÀ­ð<ŠˆÒF˜›*Ôša#ЗÑóÌ!Lfa\ì±ÅØ)œÎw ·MaLQD±€0&'(ç˜çS­àÍñMÔDêêY‚¡“Fšæ-m)7]5Â[ô1¸a$ÞöL8¦[Ìá,Ò,+¬×ÙØ8X9–9û¸*¸“xH¼¦|*üâ|‚?¯´‡?|öåóŠÈW^&¯zq­ûò*SŸWûÌgO^u7âs_^Õ)_mÝ™WjZžyi_Õ#  9 }D\ä¦ ‚€ ”€€Î­ÙJ¤f–uÌ,þîüd~bÑ®13É‚€ Pˆ VUt£4BA@ˆ b/”šë÷B"Ij@j¡—¥‚€ ‚@¥`Ž˜bUŠI)W’„€ Iê áEA@H!­%¦‰$}}/ V„4iXÕ-D‚€ ‚€ vˆÂÑ€¨+DIûXþ¤D $› ‚€ Œ€»û€0+ÄÄÁ¿’A &¤&ºY)‚€ T ÄEûQ¡î‘b$" H{ExA@Rƒ@&X„ó@$ ‚@Í HÍtµ4TA@¨!˜`)&Ñ€T k¤HA ©ˆ’Ôž¾A@ @Da¬%DIA_ ‹‚@X„1i„Å‹”#‚€ )B€èÂp"`‘ø€¤¨Û…UAÀ@œ!”A@ZEà¸p1ÁªÕ$í®QD©ÑŽ—f ‚€ ÎäT8ëÑ€8w… ¤ p&Ž4µXxA@pØÛ’D‰H8="¥©@@Tt“0)‚€ $Þîp%Q°ػ’ P1D©´R° ‚€ På47„#€È9 U>P¤y‚ÀPDŠ‡|A@RèÛŽÂb‚U*ä’O¨2ÕÐiƒ ‚€ Ä€ÀÖ»ü¶‰*ÓÐÙÇ>ƒk.^³î™Ã )81ŸÅßWkC£4+õt ÜK•‚€ ÄŒÇ^’ ‚€ ‚€  @–*A@ˆ œJMªíÊg)ß›®24ß¹ðcÅ ©  G€È^"g GS¾ ‚€ DŒ€ ^MÕQ벩Š&§ 7ZòT»¬ç*O3´¹ÔþÉó¿” æ…Ét"À8 „¨lãSÂð¦³ÇGäšè *Ûúr"ýªo~ „ÒºÁµÖgã{Ej[ýFÒz9êñqc,±‰O\+|¾\3Ž±Á=…ߊyˆÕ­ù®Ëó-ׂ€ P݈RÝýëØ:º×±€€¼`²FIñ•S2R­+arF2èU2Ô\Vêó©uÌŠ +ø¾Ü‰o"€ôc"Ÿá#@A$¬ö² &ðÑ*›¶ h敇ªFjR}^Ò~=Ðõ*¯qO¢:å›O|']øÍÇ=“Çü¦ü§yÃÂïÇ µ¬:Zgô»)Ûv1¦§óÏ0f0¤²I«&Ìs •`ÄÿAÂÍ4pÝÿ{ñ7ÜgâÞ|r!5€ 5ÑÍ–ìÝw¯ªo´$DÆdL°R™¼\Ç*/¡lÇ\¼'' 4¢ÿÝ9pcØÊ°›òUVЀX”'! QCÝÏ¡é=SoÃbdúÁoFopvd)ÏlÒD&€]R§ÚŽ| Žwëzï<ÃY Cà É Hßà–„zMÐa8$àŸê %ÈÓo ; œîô}D©3>Îë1ë¨o§êÍ#pDßNÞ²tTB*T ƒ§Ùªi”4$xËå›lí̇rÀs¨õÃxÓgö½ŸŠo­xÙ—mB†EÁd³³ÊÛ–<‘ŠV “©Cc ›ÄÏ‚TcAêÛP»Ð˜y@ñŒiªg‘øðE1ñZOS½»¯ÅÂ̲=.ZÚg] 5w².g‚oG3´G½!‚ŒCg~ÆüÕij'œ‚Ë[KÈn™z–RD¡ÑJgÞ?ÚO©¸Oúh<ç é"×^ÿ”eõË8Ýޱ㾠 ÀŒý³Ógþ w.¸>ζbŒMTzb‹òüC!e? ýÙ]¾iÞÛôO•ß¿QmîÛǼ'.Rwå¤rØVGÉÌ÷á v¦Kc0Ájöfƒ2îp)'Z~ÔúÅÚè3-@âé¸ê¯Õò,àyœ¥¦ §?ÍèhRD½A„¹Æ#A˜ß ÒOêþ&0ù2¡‘GgZ&tLÿÚ 7üºÆ»\ù(·ì 6 ¬²©Võv„¥QQv%ÎRò>HõMo‡öêhÏ3fX•@|ø~ êÏÒZ78Wº5 š|øb•´=n-h} Þ­EüŸF£’× ‘i„@ªŸ£IŸˆgôXhmŽÔõÍ©uƒ§ã²€‡t¥þZdJDÀ‡¹û–i‚ñ@‚PÛMZ ž$ Ú ]ð™ŽÓ4ìqãÂDð abRAÂÒÏÇÕ¹Xl ¾Y¼f/N¿Í,UDIÏÙäé˵Μo‚ãðw ôÿ‚â€aaal•6°yaÖŒÿ#æ† ÍÀäì;¼öŽ_#²ÀTç¢ß3’B\3ˆR3]m×PŸý{±KbG<ˆ “Õñƒ¾¦ç2¯Ö˜ªËc¨™‰Z’ PöåCv+K¯†ê¼ïc'6!F;a¢Ù+,¤½âºÄ¬G†­Iä‡àþ°K¯zäœ:¾È\h‰½B\°«¹UeßEèó€ŸiOÏ+›xl#€T.Qæ|űcS ¥[‚gÅMñÔã6°FC¹Õ§@àx+z eêž‹g7x‰Û¼¬û(Ûh9/ÖøãìêuÃ_R½Ý__—²`¬ÉÌ"€Ôd·—Óh'–ÂA†©L¼ÎšmqD·†NñJGR³¯@t£‰´f¡Îzö›§Ã²ñ´áBB©¸¡äç0B&Jebp>£q‰-9ø€p8j_}±þ6jΪ f‘H¹UÇpç¢*Q>a·]oæT;¡C³0ÅiqŸgg„ZW®=z½›†AøüàÉŽðñÆ”5խẦùD>®ºný¦˜gU扫†RE©†^¬dt`‚å^Cpzº{1‘—°iñ6ìêìÁÄzÀv½D&°û$±ª¥lÁ¹ ­m`͘3ᜆà¡H æMF+ß D^; ÇÛÊø$ó¿â·Â½”ÿ‹…7vQcKöå¦A¿ æie/L–Œ~ •@ÈÑ ]¥ÝËQ²iï€9dÉý‰ŒXä·CÓq1¢±½Yg¼9†6 óÞ—³ÀÇ×8wú;©uõ›yÓÂG o’Áˆ2 ¹>ĸßS ©Ãi‡»CmÆÎœŸX´ë J|Ãس¢ýëÁbù&dÄG$¸iÂZ\LŸ]ÊŸ ‘""ø'.®â­Îë±1@.&Xåk@0—’Êv¼§_|Lk:9ªvkbc†õÕÊÔ熧¦Z¿¨É¶+ˆnO!²TÉí§öeÊoz=×wà½zúÓŒ¨D&ðw¶Pî¤öŽ÷ó†ßH$“ÂTlˆô)ª˜”qD7[jÌ°Òç” Gt4¼l“ïatزf~|én7à„ºšˆ™ÙÊËŽ¸™ø3æMj:ŒIÁba(ÕØ•À¶›Œ}÷!Ü›oYô+/FGxë^¬Bõpå+Nzà£ÄG^;?·rú0<ÚV¿ZcÁ“ÔhWÐÈžgY7«’àc–Ûdæ »D\’úÀÁ“Ôü&Š]ÔCȪ}÷MéW{ÙŽ#ý /7›zV QÕ! HÕuiø ÂÞÖ½xWº 8¢§NuÁ£Â%–‰o}£1ú»L*ÉÒâ©ÖÓrØ;AB„™ÏQxó­Ôl¼¹gé\¶ðdå¬ ­ ]c›SAë,€M ,+ï<‡ InÆü,¦äà ÝNü(0ld¾jÌ“¼)»úù0—ù ÆÓé15ÓLa9š½j6o^´9tòXTzƒŸ–2kÐ)×€¨`âÌF³óèèæ¼Õ6ñ¥¤õû8âŘŸ’ªì¿íš–èÜêYHÞ&BÈøpÕB@j¡—Ûõø}./èþêuJODw Å› BñŠÒ?*ôpG3OÅ úL¼àž‡Ïc)wÆ,‰Š§*vX"aœà¸­¾N¬hf8eUA)&´olÉÁ Ýð|ø‘&‚؈eWÌAäÒ•ðóy}lÍCż{ñÏM8í}REøp< ¼í¯_ !¡^çš'ØWupÞàŒFõ6Ê6‡Ù4I…¶c| -+Ûñ ò}`ü¼’£‚ó]hÂTåy“qÈë$¼°Ì³ŽqÉ—®qöŒ_‡sš<œ×äáyÃë Ü}Âþ ¶˜5÷b“s>=øcåÍÙHã·ïÒnüÒ­hw·ÒOw‡y ´ åôp­æõ¡9à [ ØéÀÀU÷“O÷ùÄ7•Eœ”Ì¡xñ ‹#zúÑì䪌>‚ñ™0-9“¼Y'Að¨è|†zŒV²r: «òÄ•ƒsFâãÉQ™Ð})ìôŸ¥yâGIgÞM늜2^ˆÌ´ K‹_béǪ;ÿ‡dûßùé5ÁšQï‚Æ@,Ê-Ÿ©¹á8açÌg‡Œ×Ç©üÔûõm+üKW¤’ÿ˜´ùm§dÕ yáhlæMdÉ- f`1I‚™à@ê¿ÆÛ²ÿ2øÄ÷eÜ®‹†¯÷LiÍÁ|bв‚ÍnÜ0ë»nÔßm®A½!ß¹à]¸.)Uô…]’)ùø=÷á £1ùÄÃ`v°4æZ4îƒ4m̶îU] ;S¯n¥ü£ƒžÔ1qþ#v>EŠåwÊ®y.iÛ^½B×yλ…)³8qZ–]Y¨ÃЀH@€ÕT,¸`í‡}¸½HÀÿަɻá˜Ìü?˜½/…±Ì´(F冸|{ ðüܧüµØ¼üß¹þ-Q$Óo­M³H&cïÿaº†ù DŠ:)5¼06 £è´Øê@ÈéOQÛš¿ðÆù7ÆÆDB+.Ì!Í')åŸeÂrãÁ:Ú|Þ8‚ç _ #¤8NŠQ4 Ó´U ‘H ©X?æŸûûo•òYq„f^y¨ªÏÌZ>w.üq)LIžd!À›—ì„Ô»oX¸{×÷úáߧzqVÈÖ¿?:r¼ïÉjŒ 7÷oäl¦m.ûy^GØT)4`‚]@ï?€ý»1èx3íF8×éìTN¥–•m¼eñÆ!?X|AY;,ÈRI‚¥)Þ¡ü:nLŒàµ¢ÆN,¼vø„ï>î›Ou…éZä:9j@êöj[õJÊ5¯F#ŽŠ²˜cÌŽä Àù;jo÷ý4½H³i'šÕ·Â(f ž!ûÖQŽ¡¨ëÂüS õ=œÒ~’Y_D]’êû ç=­< ‡¾œákKÙ¦Ópaÿ•Dlï;+ŒH•å´ìÕxLa@MS™úsµâóð&™G õÇL³³uhEÀ„þŽ¾üwîë{BmÞ÷P9!Úœ²ØB{û €u¨|m†FXÖý™±˜›¥µ÷˜°¼ÓlX’<Ϙa9 ÁB<.IÊÊâb÷IÌè ‚´ž¦x§"$"¿Si‡Ú§vªíw>9òæ„#a’æaç<Üä œòuã™:·æ=ÚóÎ+‡Ì5/ŽGqvÌÕªÏÿNEË],‡>Å> xL¤¼rZ;$/ÖGÆŒfȽZøbÚMuuŸF[ß] íÜÆB(å‰/„†ã•ˆŠ÷r`ø£ ÍC#@‚JÎœõ!>2õ'L@xÐNåÉ4uå~rñÓƒ;B®Ów.¸>œVˆËB(ÞòV­ÆI±Ö„6Û^0º®þcäéKPFãA³ˆmÁ!ÑiÏœ ®~îZì(ìo¹–dOa¢Óô“$vâ3ÐN`â†1‚0Ña‚zv¨ÍÁ™Øq¯¦”‡™’ý^œÖê£B}†CQÕü>¾‡»ý)ªz#¨'½> Ê!oÀ¯›‰ûñÌoÂ}øžð3Ø4è6Òhñ&cÝfü pˆ`4~K¢ß ¯Àä®á|Vãw˜AÓaÎoiú7è»&™6¦YÞ¡*«1B„š¤Ï†äƒÎƒUÊI2x—åŽxÈP/òdÏ„ôë3ÈMA Á`—¡xÕ‹Ëe1÷³&´ƒî¡rik-?^DoÅÆj´{zÒþ¾Àœg÷äûÐÄ+‚pž•ŠÑ•¬#ò“°6X4Þ¿¯¨]Ýßów.5Q„ª+qŠÐ’Ôe$6…ƒû-;ƒÖõ.Õ»æÒÝ A·FNxg·®šƒùé$X²<_„ö!ÈGøkeó~DÙÆý‚‘¹IÿÝ3bMïÀFý‰¦E€2@aŒTNñrߧə7 ’@a]ÜJ—ß0ÒÎJ"€$b¨å €-ßuÖËÅ:2š“ÈÀÿª¡îìvÍïs1ë™Èpf£ûòóßYNû+™—Z>ÝJu ßÆ>Ƽð_q¡sŽ2†ú;”0qê×JŸ0o ÌœŒ¹ü%´ù®NÖJ_ißB³p’¤2;™ÀdÆl—ÿ×Wù/sçâ¿$ÅðXòS|HáÐÒð°p( Ç>Ì÷7@¼øæ‰?rׂœ‚/³†¢pbß5?1™©}EŽüÌÅðQx7„†æ^X +Èó)»ò8îZl<®šd"5¯c>6éß Ìšª¦ac5„©r†áýÂÇX<ŒöD’ >|LÆØmÁz…Bñ´K«Y³UW2´š‹vŽÀâu®n¬T¼ƒõf» 8¸%#QnÍK ||ô´dp46À¯Õ˜‰9;Nöñ?|Ïÿ@ÁgÂøN舵¾CõíÞÉ%:SnÕþÁ};6ç#üJ"€PqtBZ—[XnÀßWTßž«ý-K YýÉK¯¢Yâô:ö.ÆJ7æÏ_Á뇪·û÷¼e)B¤†›xÃG:Qâ2œ·´ŠõÌ÷CqqÖ‚¾:V‡£)>„"ÞáXL"ÈiÖš¬®ç¥88ò?ÀPyçÖLª¤ˆïçÿG»÷[ƒÉ| ¶¬¹Ô¬u=B(„@Š×ÎNÑ›Ž°eÇø(cÂe´(ˆý «¢As)ׄƒöŠ¶ºÅY/…ñS…¢ñ+>/LÂTŸ»KÌõ_RpåÕ-È]8-: ÿ—K8,j‡ƒë‚‹y¢ : &XõN]1v¯ÿŒ „Ϫ®îŸÃg,e~6ŽÏ0§WÁ–ž£h§0£ƒ–ô×/?T}Ý¿‚ ºÐ1Ò˜.B· ›0?Suõ?B«O)_¹÷ Y¹èïeþB"µ‘¥´‡Z—MÕ^ÓåÔ@ïÅx@(åÚK8×°‚Ýü'ž¬ò˜j¬ö‚±ÎÈpcãóÑ-¿¯½®‘§ÿ±õL-Pâ•ÿ¦)j%Fm>ºj’j6´øƒU`*…šæ"$œØ >Vý5xÕÛMq o¦Ã—Î]öبLUðs¨’έ¾U¼Å®d®”¢)pDw@J©fÜN N}…3gÒ¦Í;U.ëÀ‰˜`à±ïfÊfÑwOÁ¿ãË8Âã‹þÆE[-Š¨.’û€@(¨è¢30±Rê{~ÞÿoZtkR:ž7,} ïµW©ÆºÛ @¸LDA“pÊkp‘*SNÆÙ?Wá5}zÿ»;)ý •õÁúˆaz@ÊZ?X†…T„HXJ•-€`1ûlj¬7ÑHŒa—ÁO‘þÃ#€DêØŠ2‚©ð—·YÜ=Œ>xÈgzD©üvD=zLùùÇp~Âvµ½ggúÌ] #Ř+àü‰ÝF£e3vtʇڴ±$«R‚þ0 xlÁ‚õ³ª;ÿUÿ‰Ee™+ +*Y_ Á‰¡:^ ˆ‚HÆÉ&öý/bÎú¿ë#ÿ¬@ÎEò¶%OPvÕÛI{Îa´÷g†"*ÀhñUöŒ%¼–bþ-k#?"㩦’Q°L‹|å_§•7v…±šN|*™&m ÇÊ)¿ ‰BÂ÷:,TR3IŽžÖlhS[ÇÇPaÅ4Å0E?­…°qƒÚ›¿“«i‘7Ro™Y (Îéç‘ØIå=ÿñ}J·T”uŒMàÊ«TמkªóL Xñ»Hqùý)@ÂõÁXùBdVmÚócŒ•¾ŠÌ ç®E×Á2æçXŒ¿Ê¥8ìOÍ¥–eÓáDŸèÀ ”ëh§ì×@ð8ËiÌ»€5ˆ›0ÅÃF©­ä>Ū]xî‚ŸÑèï†|ÜÃòóÊç>5à~=îá3¸ž T„À— ƒPÁƒª(ý’óemª”/¹umþ g³{Ñ«h\={³ŒÍàõ¥·Jr Ñ 0–?8hh£´ò…C{å+9Pµ¯z5‘wÅ;á\aòÝ‹>ùœß¾­:7Ýf'F+D ‡f­h‹b€ÛàóìáÛŸNĘ•R¶Ãé9ÂXùþ>Å] o¶0^JM·À¼ö~ q¬'ìGº1V¯èçÅhßr¼ÇÜÌ K¬cÂh-ncŸ~ĵŠ·ÜVqË¡@#R"ƒ#eÓ=¤P#ìÿHZ[ 8MØ ’HÀ®Å bú/T6æù‘0“”J(:,M ŸG³§„ÑtLÊ[±pþ¸êºõ›Ì×¼¶™q`¡­\'Q°F#¬)¹ ŸkYùŸàÎE7 ”] ìÁ¥È¡¡M¥Óë“ñø9H^¼Ìï\p…r‰!Åùé?‚9ÏÇ]‚PÖ…¾´AÔÆìéÿƒpúo«DùƒËĻ̈́Wþ 3ýᕃ9Zã`~ʾîÛWa¬€#}]ÙŒ %81ŸjÎ\b(ò-*žÙ³‡&7¿>ªêÒP”‡Ò´e“yçÒ²T¦å¶Í4ˆ—Š³ßTü02÷?Çùm—W|¨ÜFÆš§¢Û'§[ûj“HØIÛúÒ`ƒ’ÿ/Ðxt-6Ö5˜ŒÄacxóæt “½©.í+ît¡O­ŸW8'›C ›Ó‰@j¸‘rgüMz¥C³Æ$ 4° î{êéüOL´Ù1 *ø# ·óKöfÊZOd¬Ú²q÷œm~’¿ÕÇÅO#·fM$­­ê"A  Ì"Ñ‚v`¼N/ƒ¬j³vYÔÕÜ`ð(kÂ(cµõgÊ¡)/wOãï"¿sáoFú½¦ï‘Ävá'> ÆŽÃY >_áw-Xv ¬¼rˆ‚e6R«Ídróÿ`UˆŽX CÆÛs«f7SF¢P4åaÀ ‡ø‰T×ôk¬æ…QÞð20èwâ ùu¦¾/Ošž%†ïä¦ùçí»ËaÚJ lfs7@Ýöºr*’W~ "€ E¾TB·fæ‹u˜<Eì‹upÒ^®uª·÷Qµµo‹y†+ˆu¡èìê—¢þg»ÔƒµÉãø;Ÿ;ÞåRNµÒú¾zRÛÊâ2xX RŒ]ÂÞYfvµ$œŠ!Ûš`‘J§ö#è’<6a,°|ýDÂ{¶döp.È>lô=Œqp\ÉDÃ32O~+ŽïÆB‡rm?Åfù¼°ëÞiL«To÷—£:Á¾ä607ØšôB ÚSîF‚•bÃÄסs¬О‹b>Y20’±j ÙWNS[:Ÿa¾ÊDuˆ$á݈¸z^$•ET „ŒÇ!Ã6 d<ŠÉêÙûh ¶£µ˜ø ›eÜ&´¾ü‹yóâ»Ë «±¬ö&X˜ƒë%$zÿp L°ú¿”÷Élý-¯¢D綃9ˆî“èÆʜр¸¤¾*Ò€8ðÃؘ¶@”]tU—.Nk|>`vu-Þ_/þ›ËwûPæJîé^…÷ó—²*Gë¤)ÛšÂ~âìí»NÕÕ;àÀgšS‘£\„:0+¤5©é8,Ž‡×qPµÑõ8]W?Ão=êty›E±v$ÀþiW©à& Æ&HûB“°Î÷¡Å ý¨ê냱o?¾´,u§7åQS˪£u½÷‚ò¨†æÆ&Ç;DøŠÉAߢ`eyÓÈރʭ¹&Xš¶À«h†«+Ë”^ ˆgg†>€í® ˆi>-ö%¸Àêr¡³§ô¡ú|à]þ[˜Z½Çßð‘NÞ" Å¹ –ÉBl-€ðæ%#tá&Œ–Vvaû6‘³sLÌç¿ØÐ Mr0¶’*Ó| 8:!–ÃÎüñ˜GŽ×“› c£8¥¦–þ/iNdˆïëGLU*6°BÔ øc(5LÈèY§¶ôtÂT*/çzýÐ ¬^³«ï»”Q´y:•qyggŒ²­&°»‘Ö&XØ ÄÁ›RéœãÌxrðÁ¢´;¹;ác?,£ýê=á¶ÍDZjpÈàû4Ñ{Fk_¹÷->ñ¼Ë¾\.m<ù> –ï.ßÕZ1ààlÅë`ùùVk È;´"€X!eW¿œ4½Ãh7à¨Õá¢8ïÀ°£¶ÉÉ7 „*†f!h ”ÓpZžÅ7,ªïÃ)Ý¿<àÓ©­û6GâaÁ¯ Úùâ’Â(•0å?:ÊOr{}pBw9¾BK$,ƒ'Ù›`if@œ|@(2SÜ!N_´âiÖ 6EU¥ýàôaê"Å&€P{Ç<¬^>°ŠÀû~=l^ÅÞV™•/ÇœŠn"4Á>åÿ¨•÷V\Z¥¢È•VÄB/¤f ÿ^e»È„=d´ÈÞü:51^qÒoÏw.XoÇU¾vcZIÙ#Íæ‚U‚VèÞ°è¯VĵF¤•K^ %g‡Œ½D³Ë’«JF¬Á ”­§šËÜ7ÂÝtÜ"ª6ÿÓeþ>û¨| gŽÅ¬Øø¥R¦þl¤†²™€õÍÜ×ûZX 9ÎÏQ? ,lj³Ïñ4s>‹hY¼«Â¨û·Zêc}§cS"@ø±ËÃŽ„õäfü10©t¡ k{y,¬Û1Ky[{«1±´e‡ëýÌ–¶æè6îÚŒMûvó!ö´UEi/€ˆ ŽûÞ”^ ŒƒÄ21WŸD““9DØ'-Ñt"£ºú«!|´8R$Æ|ü[îÛzAú„Ó{'tX=” ÐIáÎ˶ìûm; ;è“Ôì §ØÒ ]ŒèÝ÷¡ïíw®Ha¢MDÚ!jŒa?ŒÑ®_#ÛçáôýŸý—ù½=GsW÷ÂÞ´·ŒQÄØ?q ¾gåÖ0ÿsÿµ|Ž@Ñ|Ïáà*@„ÍIè¶I³ém¿–Hs,eï„ŽÅvõœÒÿìøúî’Híp!·¡…9ù[С8cíð¬^âÃr'Ø`ÐXh@œµè8£9ÖšiÎí­ÖôB Řß¡òãl€ðYϳO›ÚGlè­h˜×1Q;vë ˆð:Bt©þ¥ñn„˜XÕ¯Ô,hüêSëX^j£59 PãŒ%•Ž€Ù5´Ôdˆ –ó‘½Bâh@09Ú%N­|‡ì}@ªÒËɇ@ùÌ‘ 8éüY¤›VÛÛ¡TØÀ¼•÷© Sþ~oÚª2¾Yh@œ,ஃÈûÊ`sHVø.Ÿ‹CnÊ—T €{0Ãrˆù­É˜aE&€0uÿ»œ\À…Ö:8Ð[%˜%ižÝÐbs(b'³«n ’AE{±9"¦²S(0[˜kÃ;¶­§ÚÐU!½ât]µ éàB)>Äáùñ¹ Ðɇ³½2 Ñ3#õ™ÐÜ´uæúBó±™÷÷¾œ·/év-+.zcšš­_ÜÏÑš`€Ú»à݈۫ÏÆ®°Ãˆ«»¤^Rq— GÂr> m%·ÝyÉ9a– b‡3Lûzû&§¢™‰a’\ì¦-5'‰i|HŒ˜(X–‰$ ¯S(bVö¦¼–]6”°çà„ÎUh‚Åö¾AŸøÑ™`QëŠ#XÑ»\ÇÖ¿}¬òoämKÒíÓã7Ø›_uÄ> ¦N,êžÂÇæÚ&Aõ=EeN²¡š˜༓‚“«"uD-êu@ˆs¡ð‘ìB¬õƒfyõ'&»yÉâÎÖ^À"€˜îtò‰9¾w†£‹¥SQ¹+¦@±÷cÔ~º¬#;¢É#Ý.ùå#Ó€h/óq§þ+6ŠI}œ;§ÿ8 Önûqh@`lA8Ä%QƘaIJ}{ïva6“é@víw@ ê˺`– ZÇXîZóÙ©hgr˜´@`Ã.&X¦]¢÷°o¿MÎrãÄÅGD»UµßàöìT¡D+ÿYN½‘בeÔºúHl¾\äÄ+ˆ´æNÕÙŠ‰+/Îôì[G® êöcЀ˜Šý<_ïÒx8‹â`L´8ÅuÀ-Õ§NáKŸA›å(ç€W:HýüFFÚò"ã¬ïRFmÑúÿ´n¯KQëJHÈb‚åÔ+NaxSê„Îup@wH½=‘,¶8´ ÕS,ˆè¼Ã»õ@1ã]iO¿ßUûa\Xùï€Óy:èƒ@"7 ˆ¦²9Ç÷"¿ç&œ‘àÿÙø`8HJ!l­AO¥Î`‘ƒF8ÁÜ2a×%gIš²üÞû!¤AÁe—0.¦«\Ó{ì¨k ¾XöHp’sía6¼Åpb´÷Qâ­¥ýZ"¥> Jõ¹i@êûªNÁ´o­1¾jãcÒ_ÑD-Ë&âåôf×J𞺆;ÞáZNrè?'t¨¡¶,5Qk¬ÏG€ì1MÍ^q|r:B8)ØŸ[ AõéóA›­<-¹R±Mk¾â|°Á…hE?IÙs\ʨZRö6j§±j¿FìMrlÖRð+;„"&•OA fQ{ÖlÐì'(ÊÁlÅ{Çɧ @¦Ò©¾é¬%ØÜï÷ìÿh¥Y¶|GDû1i@L‡øäd†¥<ïÜhÁ–ÚÂ@;‡w9•q$,'^; æ,KêU­W&D³} ¢™(óÔ¾z†})µBio‚eÎã¡CWMª¤Fm§“ºh@àDS{6g€Ø¦*<½…ËÂ>ó+ÌyÿfÛkýtØ„üo¹|Sÿ÷ªøÌ(7¬|L> ðýë\:öW"€¸mŸï¤Ñä§ÎÄ'^o 7´}Zµµ·ÚÒ§…Ž‰åÊ+°šK¬o¦ÜŠç¸–UÕô}.&X@¦IO¯j|Jkœƒ –Ãîi¼%?—ÛaŒ©Ô€h Ë ÛDUxH‹Cl!A8£Š›¤™ƒÁß<{±Ù;3ŸzÖ¸”‘HZvÔ€dâ@6>z«Q+ZKêkZ!Œ­{ÖÔúà8øD¤NÁ€‹ól œÒÛ÷KÌÎ hBæÕÝBÙ5ÎñÚã{H*]³£âûö ©J7-ªòµ²6Á‚9F h4Çé¶G‹çybî*ó3+û熫Ub¡µKD`Â^†Ín×çõzÞ°äA»V&™Ê1 V÷ž²×ÿöjÓa82_Õ ÙðÏÃn—üj±Ã(·ê˜’ $c"@øÀÒ½öÌPúúœ{¬5 œ8gW:(yóÄs·Ÿ·/Œx\嵯ùµ|ºuðor üýö> @Dâb‚EržuûPÄ©uB·×€ÀÇ­â»ýQÏÅ¥§X×AXbMúEÖü üêÛ®e$’žµu^£RO\Qö)ð¡ Pìf_ç,kÑ‚81±}$,Œš6jý°›íaÔÍÞüÑ­xÞöÙV«©Î8Lþçm1…îTßøˆ—ëXC³¯´ß}¥ðÔÞÎ7ØŸbídËžZÔ†2Îd­Á‹ÏuGu(/iüF> °hIc“afj?Gâï)®m 8˜&Æ– ƒàqKÒ’Éâýù%g!cðÞßO?á§*¸ÅÖßm@Àz°ŒŒvïõ#ß/í®&9¤4¤’• Ç?l9 &,>ü([ú8è‚Õûº)gO›"ÊÎÅ?ÇÎÈ}arl´!и}˜êê×{ÙŽå¢ü°}A7Ì€ ¶L, hïAK䫇Ì% §ÖË:‚œ_&XÖæWÁƒPa¿:|ùá0é=Âé¡cµÖÌ·Ne$•˜T“k»lhÃ@º–Ü…‡õn¤KqD·éŸi|²@ÖµNŸˆRëmaÇb1gK›&:#¨á™^^ ž!ˆLÆéÕK¨®a½ÎuüˆÚV¿Â,n×jbk3,lüØïäV ÜœwЀ° 0ä³ ÄéôQ‚;¹fkte Y[ dc•6Áj¬;ͼÐ~ëZFRéµ"' ˆM»B@‚õ†âµ6Œ¬fQë 7 Õ¶r¡³GÀÛí$€h/}~ XꮳŒÚíiÓEÉ ¾ë•âsF¯Ãɶ¿§lÇzÊu|ŒÚWä*U_‚˵@Ð&ñÑ&Xˆ*‘àq käŠJô&,¿ M°9 }•5Á"}´ó(Ó|£s‰-ÀÅ‹Ëv@70„*€˜±ãy½ù´N^&-¨êiÚ²É4uå”àÏ\Ó²Ðñ±Æ%Á„8Pé)ôûF{Ó Ë÷íCñÂæ¾¥6Î)ŒîÍÿ'ÆÇÓöã£4J…9ì悸n½nïXK¹ÕÿY »XZiÎÅ‘°È!šOš1Ì»‹Üà¢jòÚÉ+}3#pŽýù9º ÏQñõc•|v´b'ì{T燀;•l]e“‹„¬ ìܸ Xñäë!À©°øhT<¡ª•¬ò)‹²³Ð³Ì„óØa(ÿ0EøcšŒÏ&köiV8§é‹„¥hýà6”s{Í…³@¬Ë(§¾¸óòæE›q àÿà û{QðA¦Xt.p>—Uó—tnÍoñòø¾ò·þ’7}fo<—‡â]y)æ•K¡½¼‹‰®R»óßå'YíäT‚Ç2ËtЀ8œgP&“‰Íž÷{UÆ2SCbÛc.&Xœ>åéiöÐÒ“©Òö—ÚPrñ¡í¥Vc“Ϭ%)Ûä&ØßlSwjh\Âð’²zoZ‹«ã€zý8¿ù3N¤¿§\ÓSX¨Ý‰Ó+¿³§‹ eH…ð1Rã°P=Ð}R×Õ?ÍÈõ0G¹`¤|©½·q÷ÃLÎtúü@œÌ°xNjûÚq)/ßµà2ÄÁÆ‹ýÙ< 'żr2&Â/C“ºÕkïø<"i¥N8ôÉÞ Ýh iF‡K øá¦ï»/—NÃcí²™™>,­!ñN¬“J‹ùÜÚ ꉊú¨C'ažw[ïúT•ý60žŒˆmb; ˆ[‡ŒÂ,BonÀnç(?{å¼_Œ?û(ãÖ_˜‚œÁê·²î¦Üª‡tî2yÇ×A5öôÌ ºUÖ%bêΩáú²9(3vÜç úZs—˜#¾Î}þ‹`¢Ø•”ÆM´>€yÇœ¶þUj[eÌ*S’|{ ˆi¡—wØÑM Dc±Yïà„®HL°\Âð¥OÑZC®Ò…,Û ÄTYd¢Â‹íÍ\Çš{ó›},ŸìœÐ+"€< ~ ‰A6‘Œ`¡s¢&都ìj[îÄ´ Zž{l™Ig$,ŸV5-€˜q›þ‰wû'ÀÄòk¶ã¦tDàPKï$­!ˆ¬ù´ Ï]‰zB-3o¯ ø¨ƒM{-§Þ>{m)@\4 ~úL°1Å^`¯R ¦äj@ê2âœZLvÌõEMâf‚eåR1Ägåd†5öqÖO»Öú—°Eÿ1µ~º%N^\êÆ6–µ‘5u&Xh¯µÏ ¹ÓS±°u%П‹|çüwú~þÅPá#’ZržË‰ØI¹Œ&5=³¬—%‡³‘8qÜsYPÄNÚîíí±@Œ¿_­'Ø\§>²?ªÕ”ÇáîŤ:7$Ÿ0¬ Á}»×:í*‹Zõg€Zs2þ~!Äþ`Ça‚ÖëÛê0VÒ¥ ÊÖíUJÁã KŸâÎ…ÿíoXð<¿Ï? FžËðB±û\bµ£f ÌnX}‰²k.5SÔ?8…÷tˆêu;+U;œKãyµ-€¸h@Œ­DŠR1l¾‹ytõi@TÞ:æq_mÄ,m»ã0Ë:Ò'—<¯Ý¤ù€¤yËÒ˜[¬¤a÷¸»ñ· ³ÝÃôw`ÇðOøü5þ~„{¿ÀßðûMø»÷á÷.|ڛ؄ԘcÁBB} BÈkB*²bÅ ´µ$‘°Ð/¬Á$%&Xà!|ï#ù ®À©êÇÂ}õ8¨Z¯0Ï«EQN$Bêë”[óZ§‚B#¶ßYŹ4n;˜¡µ!Ö‚ì£Üoo?k“CªÜÅD¥Ì ý°ºiæÙ·GÎ1d¶}Å•£Ô'ÓÚiüÿ*Ç\ÉngÀ\¨½¿¤ªûÌxnþ-ÚNbo·YbÀºóz¥Õ‰%fwÊA¢î€À’w´º Ø,ñçoP}û6@ ÚSnD—ÔqK®]y™£`çv$âɤNEÏ5‚A¹åÙæG]è+þ;¯æÎù¿µ-§ât¾p²ª“z‹ MË;—>cU@ D˜57صÌ2·çUæ/Tw|ñ ö wÍ¿Å/38Ôó˜µ]ˆçóB6Dø±B¨£¥ŸPëê Ì!nªÆ­X½azb“ñ‰ÝοdŒkýÞ%͹™í¨ëÁ’ë“Œ£"€ZÆ$k¡pŽó IDAT™ù£ÜêS:÷bfº/·è5~Às9IQÝwašqvÑ/hŠÊüLÌ;­ŠgV†«•ÊÔkû,c“«¶<Ö=í§, –C;]kÔm¨Åä 24 –ïA¬ivT˜»bñ>¢²:t©ã1Ç×cŽ·ÙMC˯…M„/l¸×Ê¿¦âˆòöÞÈÜÁM[í†QÑÝeNX‡fc­êÛó×ÀÄ«|¨C¡(Öý]fš[›ÿËÉâû«]Û:ƒXì4Bl¼–rËOæÎ˶•7ŽßŒ­¾Î­Ù‚EŸÝŠ™À$=ˆ2gVØμè!?sþ$äÁ ‘;Päx6r¶éõè¡÷á¹<3äjŠÃx·5ÍÇ•7£¿p±-?,Ðö6\¢ç< 54è¶Ï2qm ºí<ˆ­Ä4%Ï~C#XÇt]ñ´RKÓÔâqyuŠ¢Ç* È–ؘ¨žÛ&ž0n´eÐ7'”•Ä¥?J‚Ø,H1©ßYRæ2Á£ÇÏ󫙺§Áæû¹ùÎ… ¢óWq ÃÙ4ö‹¼qþàïu˜I€Múçœ"Ò ¯`Øw<‡‘ªÿž|†ý”¯ö~?0q;.!( v>4OÑKCÚ*—Ù­âÎßóy–ŸÏŸ†çòçXîTdÁ!d¡‰‡oÅh8DÖg›&¹v»Mƒpx¿£±N4Áš´]œÐÓf‚å1Žž‚R‘ù'æad­eƼ‰¢úÈÙOZõócƹ2Õ;œ‚Ž×é>³¶a,’¬ÑZØ0ghŒÔ©òþƒAƶ”èè°ØÙïZð!~¦{6¶·?™¦"öýX0ÌÓ¹‰K£kYé5a fXv‰U4¶ûvÜ@µi± j`ÝÇš$ï¨VäGý;¢h½šûúžƒ5ÀîÏä4Õ¬ßv¹¥–ç,—äë#]ÈÓOˈ ˆõHÙ‚Üͤ²Õ—°µ7AwŠÞW–›»ïŸ»Ê 8(+Þõ/;èf5ÜЇ,"F¾-‘ ¾ƒ4,£çÙ60.:ãHß°p)÷äOÂôzC%ø€}ûGë•(Û¥Lœÿb-€@âŒÄyØ¥}ƒi »Y.¡xY4 ƒàš7/¾‘aÁþZ<›aV áûRsªl˜e–QÖÖ2òœ•ôÉ߬¡;D0Á²M5n‚墱…<&:ì‚Û/¶•ª>ÿB?Xk@°>tÛ8)q»ô a‡„M¦S¨ýÊg;‘LR&ø€X&"+ó+S[$ˆêæ?c¡f=¹Ã¾pž%4±“ñ–EáDç Ðà[±Ø UÕhÌ& ¾üŠ±ÝŽ½¡ƒ D²MLm4£ÃÍѶn[ºB´5;j"ã") ­ü)ÓîcPõª°ª7æ‘*{ê9a•WV9>m,+ÿ°ÌZÑs†Ýª­¯¬¬ßQª¶M°"Ä2Ë)Jì°Û¯¸Zì{0* ÄìFk>‹„Ú¯¿ØµŒ¤Ñkb{$é~bÑ.ìlßn :Ìrε¥M Â…~‹÷÷ Aìú0y‚çH•=òýa–é\V~Ûh§•M *¸·¤Ë »Þì1ã\r}yì[•J˜vîËo˜¿Ø÷ù³Ö;9ƒÛ‹Èxñœ B¾[˜IÅgnGÍ]“ÃA„ªÆM°”rØò0E Q/­wûÑ̪4ÁÂ[ۓÓÿ+ס†þ¢ Nt-'Qô.eÿÞŒF¤É§lÇ¢t&µ¬:Ú–>)t¼mÉÜuë‹!†&Lž€ÏÇMXà0Ët)+…LjužŸ*Gt˜òtÚ¶5ðqÊ5´ÙÒ ]8pׂk¹/–BΑåð‚ze8\•Yʦ½Û±’³öc€Fu6µu_f­Õ“ÝIâ׶„Âð¦m±½ 6«ªNBSWN ÞcÖý¡ÒµèNl49™ªb½5]Õ5ý§us“HH.&X ÷1x›ó@œpÏxç:Ñ'„˜ùÚ|¾sÁ|ß÷‡Åþ):3ñ“a•J9l™R%€¯ N˜ùâˆî„_HÄÆ7„ýü+!„8%„ç±f_ùÉâçàÌ"{D¨J,KA$Ã[JÆòèÚ5Á‚àŠd䬕äb‚U…&'<0htdB„ÆXý‘ëHÅYêLÅÇj4;˜`©¤û€˜†ç÷Üä²;—f?‘ú¡„WA¹t¤ßlî1éwbÑs” m%hÜ"a©t Ρx½¹•è)³|L¤,DJ¹²|Êaº>–1Œˆ¦Ö¦®¦x9_<¬%µóÕAS‚Ö€¼«òç‰%i:8¡ÃáºúL°¼Œ‹S>äßåü¢²G†ß›¿ºl¢a˜'gêFþÈ°Û©ý ­ý$kæ6ì"3Á¹{}ÿo¶„ð2Ï–6©tB>ÞBq€5;P:S—_y¯5î”2ÄÏ;i@´V"€X– öv¯ÁF™Û®œV±˜2Á—åï.ˆ`+ûÊ®ü—2RKKNèLÕe^N'ΚåàÿQNEñç5çü`s­Áž]}ˆ¯ìÐ ›ÜæÚ2;#Ðt3ßQ&ÙAÙ¡JYP5±|@p̆µïddˆé=§ó@ŒH‚vø–7ô#XìüÄ’|¤Ø‹c>m?ùû})ë20a™¶lrYD1fæÍKvbקÛÚ%ô¿D²ƒ®"Tf³cð§.…kÅ9zkZò4 ¦^ÒÞ"ëúÓLÈ*oÏ~ D¸·±f5ÑwÛí¯F ˆ¶7Á2æ®Ì_°>GËöyeåÆ–¶ŸïˆFRuߌ1ìz?+!|²½DÙ›,G*€øÊÑÄ«ŸÒ‰*‹O%v¿ Ø®Œá˜¤&Ò[]Ë …~ãú‡]LîÔ¤¦XLX¬Ûδޚ–H4 ÖàU†~ïXr“#½y×>cBætØæ‘WÔ¤ÄERË&XöÕŽ¢µÛn5 ÊIF¨kï±òr²\04æÊ3tö´+ì&ë$Q98¡§ÂÄ`M{oÁ¢ÔZÚE¬âs“ÔeañbNyç<½„ïZ&iý¾À%е Gzæ«zíë!ëb8k~ÛGýb1Á²Ç½B”º÷N%“ŠE#zL]ÿωwyŸOÜùB®žÉARÃ> uuŽ ˆÓ’|í¨ñãYpW_qÀÄÑÔÕ²]˜'û°Q³Ü’|+}9åV¿tÈÍô}±×€PJ4 &æ>¥·Øö „—y¶´I§ãóo„4íî¥ÔQªmå ’Ð^Gt­Ó BŸµ¯ßf:|ùáIè3ᡈ@O£F2>Ÿldüµ1žOÑmG}µœtѳµ‚wSí:¡÷zŽˆŸ„œvûq^¦ê¨´B]·}&`Ö¦âýsÞߘ.õ÷©µãÄþ{©ûtqBWl5RG ìn°­½<‹ZWiKŸt:Ïe.¾ýíÓ佦ÿ:ÎO_‘õÉ!'^[¼pÒ½½ÄT:A"aÙb_º­WXOª?ÌÏT„¯R íÛó!.§zš@¼ˆ²«ßPJ•Õ kD×®º§i@œÛxJü}Ö¾‚I}Æ |; ñE3G"0ù ÂÀôdòè7Ô²²-Œò"/Ã! /Ÿì±å7rD¹žâ©sm›tºà Bfç¨XLüŠD´•ò.‘°R%€`kËZôgÄ$ƒ¶Ÿ‰7h7“Hz¬¿¤¨?áD¿›5NNô†g³­‡ÿ®¡öÕD݆XêƒgªC½µ«ñúÜìJ:à)©vøÔÛߎ¥rKŒŽÞ°ðw˜ç4£[¨Î[K³ÖdÃ(/ª2Ìy&f®w¨Ïz³Î¥R;~7íù›ËA_Zéyv§„êÿ¿±£à´{ ` 'ÇÞâ>{ &¦Ã“tºû¸XºœüŽÂ5ù‰9ÃeܶÖB†Y'Ír™”áÄ›bºÇÏ«/†ÑM˜KêIé_PnÍ{Â(/Ùe8ø€ÔrÞ¾ºz·~M“„¬MeV’·/èvÃ*Ô좉W1h²êy–'¦,¼3Ú©oLUxÞÆ·ˆ£”†ƒMï N’Jý¥ð­ü±8ŸW>Uz(øÉÅOcñýWŽµO¯r-Ù~ómëñ`ï³.§¾)=Z®îM.f/pdKO[­;4E„™ºg»që¨s«1õæ߈gïŽÅä˜êpì{¹ŽïcccFe&³ — \»Mnì*&s<ÌÖæFªê̯°àÆ…š~0R%Þáø1áÎ˶a®¼´DŽÇÍlsý-”[uÞ¸™“¡ÑSÝRŠ4 h(:ûÛöj®ÖU}n‚Ÿ÷¿j‹O?”گ쿎ëÓØX¢³´®?E~ &ªö?6Z·Uñ ö´B6šè|Û2¡á…1ÏëMÛz‡ÓA þÄð{N߉ބ—ëƒð YD):§§ä6ã ª’ó”1¾ ±õ w@°û5Ëöõ±µ@TÛ•Ï2¶x&ådx˜b}+ÓkmÛ1œëTà¢ÿѱBÚð IúîÕ» ä§ÈÄÏ¼Ö Ï›çDŸpbÞ¸pÖ0vc“žCíËžåV†;5,ÖŽèX¦kQîf†Õ^•‹:÷!y DË2X½Î¡âûyÓÒ'èC!åÎ…?ÆhdFË`yß"0xþ°ö¼Ût®c½×ÞñÊ®y3A; ÎiGÛœ,l^Ø”[ñÊ®úWK#&«á(XTàÄkVÓÖS´É$õÈÅ$ ÎÉÊ ç±å_ƒµi¨~:x·¿ŒTý}0_}k"µ!¾v@TÆÚ+Ǩ6‡Ôéö57£îÙÔmªy6t©¢áü¯”òœXF8Þç¡€ß;âJì«{­씲P¼J=è²ò‚ÆÇØŒ¢ß%Å…eW‚«O»Ôïûþ·\èäå®ù·MÌ?„Yîà²ðRmÇ÷K´V—(Ddå\Ý~#”àÞzr; ñ~Ògý”"¿B‹‰5åã9iDèÚIŠô$ü>™3#>43({úô@ Çhp¶â£•OØ-±ž«¸†5 ä¦Ñ*%Q°²'Ö?.-cõ™`i'ŸÀ_Þ‘ú7-¾‡roÆœô#ǾR<Ê:›6ßàlÇ%8/äRÞ´àoC2ÄùÅé €qkÄe½ä^,Ö»„èÌÙÔ¶z® '拶B¿Ë…MLëF‰71ßoË™ØÚiŠ«ÍÊÉé‚um„;µ¦Ã¼‚”ù*þ™m[´ wâÙý»-}%èü®G._­DÙ#•‰ç¶ƒ¿—Að¹BƇ œ,ƒ9§µ¢å8dt¾]ûóAÿ.%o‚ ò¯xAŸˆ¿a‹<úçHuTä%ËdŽ1ݳ$O7™ï¨ÑÛ:¤<àµSÈÞÕ'€ãÉðì;Eü,¯ÿJËÍ ~Š ‘÷—–»¼\˜çž‡óBnѹ5?…Æø¹åQW(7‘£$m&XŽ¾µkšW¡îHL±x‘ÿÑ‘™éÝÉ7íـ׺µ„Œø;鉵¿÷À°ˆ9–f¯<É¥ ¡µG@çV}ðzûŒ{_åB_ Z£qæõ&<‡OV¢ü —âÚ©ª6#tÔ€@Í•¤ÎI0^}&X®ç¢$ ÖH=wÎÿB©|¤ß\ïAÁkF½›2‡¦ø×ÔÞ1ϵL'zòkPéÜûw¼wÛ‡+ÞN³e¼ :œ0é´“ŠQ>‹[Ö\F•¡gEt(…>h]0§Ç=8HR)§ót]æ"k¬„Ð ³síåÖ| „XP$Â|¶^mìþ†K•¢å­ó»ØÏŸÍsÚvaÓ³hËÔÕf(^âÚpB'ÿp·çÓOÛ³7nsžÛÍ$Ÿ'ôá…&ä“B>:ü~˜ß±F{)´Â7@¹¦_ï‹# nQ°tï[LbÛy–’2~ V ºòyV„i"bu‡3»šv.ñ8åZ;¢§.«Û\àÂúÛqcmgI‹S`£lÓËþ½–E ¡ï–Ï9¸—¤ c!é%.?Q·sG„ø€¸¤‰ZüR£QN_ÁªÚ’«²?9Nè#u „O#Tð‡0·›ÔŠ%"Ç`­ó_4©i›×¾æˆ.øJlŒ9 ö¥²Ëng¼ô öÅdÌ!²yÑ£x#ºÙHêøOØöIÝ?f;Çø‘)]çc€ßëÆhθ?a"š¦2ß9nFÉàŒ@µ©QÝÌ繆Ô-ܵ ´8ò®üŒFê-œç‚_ãÜ‚”"³®QÄ׎ %¤¤ á¼D' žªÓ€@£z˜m׋ú‹­­`lë-—Ž7,ø3½mÝW.m¹ùñ.2›oDtÁŸccl;¢ ~ï©×WT3âê„þÏ}Ö&ö±i@‚ŽñÕÚr;hHþ*÷Á ùÃÍ]±ž5³8¾ä}k Ø}vªœ;óÎ~;0Õ‹éÐUnjÑ8ú9%uRûªçÁ ðzØà~;øùÆcÚEýÅŽÅDFn"°@P~.f—›"«Ô¶"ò#Ô€˜ùÖ%Qmj@”ßà‚<@â]‡”Ê<»Bh*©B “½Y©]…5N©_>Düçý³!„lŒŠ ¼›1A<ðžú_šÜ¼fZ×Q¶c1åVž¦v³žµ´y­¼þæîÛÑ¡»l;Ìϳ¥M ùnfXºÚ2Þæ²o­¿V½jkŒÝŒ¬Tyã‚{1©n/5ÿHù°8S7ëOô›Ü³CÀ±8•öu˜Äÿ •w 0>Ï®¤ƒ©0‡}€7-|äà_’{'ÿn箇_¯ùObÕ½?©œFk¶âh‚U«¡xI¹ Ø^NêøÌžG H¾ê4 ÀÇZ‚ŵ›uÇàΉà:0aíé~.ÆAäG੃@òAPSæfÊ6?…wÙ ^vÍ•8_äß(»ò8‡Z—ÍNkí‡é²XÃ?€xì¯_b3~0æÙÐ¥‰¡é·ÀIÉžeF|ý¸Óæýë9—Ùa¢ÑŠí:-ŠUµ¶Dè­_‚ÖÉŒ ïä÷RëêŸ`aû'[>j.À0aâ<„} &lØÔªé¡cÂüœ8~uèåFP ‰Ž…j>N³¯¼Feêþ/¸FPm™UD­q˜kU­j@ÈMš¾ÌAWvûÝþ€c¯ª|@‚Ml3vé-§. †â-Kw`ž| gWÍÇ秃 RËæ»á]m+L‡IÍ ˆP“p®©G·w<ˆr7`ëòYu!O'LÿÃKO´⟪sÏ“i,\L°Èþ@qÓþXÃv‹×š5×å&ÐçðÆ…ëÊ¥MM~s—C‚©Å4òPH1à}<ù ³ 1« ‘°~ 3âsþÛØ¥p@0Áx*Cÿ‹sPNå-‹7FÀvê« Yk²ªÎ?Î|§aOõšØô\ÌÁ粬 ³Æ]¼}´ßÓrŸ7/y¼¾;iÓb`6/1¼ç£<G$:%¶Û`qª3~bHŽ¦g˜íÒ‘Ü4 ~oui@Z'àÌ—ÝÑd; 6$‹fc”[ÏÌÕ˜/O-o”÷‹ÂЉ¨Óüᨥbí4H¾Ï5+˜ï…@²çv#þhŽu/²¡·O± Êçµj>e7¥àR½ˆO;ðaUW6¦ €qÃýäVHêÑ»ßÍÞ:LLs] Ä„r¨ªó~K¹å/äÎ˶¹”U-´ØuÓªeÂ,Ì®íØÑy6L Á¡Qf\¤àÀ_|X‚¹·®@ã!|ÜÊ{ùuE-Bjˆ¾H˜eýµþŽZW'ÈKaZ­5EÏÉ 9º“’±cø0†Ì ˜§zp6´C܃ö÷b—¬á÷bÜ>Ÿš{}ói~#“?omj:¨Å©»ôóêZœr°ñ°¨ñÐ(íýÂupoø5~/æÕÌž¯ùoIo4æzsØí7 ô÷W•Dyä`~ôxªL°†Qîüȧq[´!Ð$ȇgKÜwðj´'0gêÎíq)#~dóßoçÜ黰ز²Cƒì2|Ý„DÓ:j@Ð6ñ.4h°µx¿#D3„ê·°˜ù„kU˜ÔŽU\ÿgj]qoúÈ£®åÅIOtI:tVƒª¯oÀ¥î=Ø1ÆDèùÍØ{ž¤È›uq3&F\ÓdÍÉÔaL£ãaXSªC1šEN1aæè¿Œè}û~f÷ëyçR§ÝŸˆØ-»Þ´èV]dÂA³7ñ¤õ›°cfN*·š£Ëf`AtDû ª6’Ê@A þìæ¯zSË×ŶR[·V—$sQ<û·:æíÔãaÜ0èWÒìUߥŒ·ð~Šú•ßs—~¬kóâ2ÆøÉó˜âŒ‘aœŸ°‚'GT?[ïâyÎÒÔ•SøÉÅé™°úz¿Ä™úE@ßù Htá\åÕÝ ™÷c—ú›QuXXõ rÇ…hÃtî¨QÆ"ä‰þ÷Ø`uq1÷Q†2ó7¸«û]ÅOX%²Ø;›Ý­š?¢ =n=õ9ÊóÎ&æ³ñŠ=Z‚vôkè›Xˆ¬‚bîD½*îÝ‚OI‚@¼lY÷˜?ûÈ“°õ1!Ó”ÖÓÌg°IBjžÓ°iRøMM¬š2x! ³=Õ¤- :ƒ´›O ¥_锼yÑf\ÿµ­ù<4£ŸÀ¼xAÿoUþ™r zÇÙ¤uÅiß}æ1·õ¯ÎFÏ5ê/ÌùQ‹òêâ.~’>ìÞ%Ë.uÁ®~'bxÿ7vø»”ÓOkRúÖ/fò—ð†Eíÿ-ñŸšaÚ’éÁ)˜#íÃÂx!vÉqbzí%ækÍ<ò÷âßg F£ÅÙ¹G(_¥<žó›éð¿ÁÂLM‡Ùäd|ÍqŒiŽ™ÄŒI“Ú…|»!ÀàÓßå“~RqþqÌqÛT¯¿EõîÝÂ/MüÙ¦ý’j¢ðP²–Ç8hóáMSU£*Xœ7¢‡vA3mÏ;žqf_sÅ(yã|sñKL¨wbSÔ饃ÑŠUWÁ©÷1À±¾Á ?Ï›úT›§ŒÚ~Ï›<êo%ü€ÝãdØvö<ʹº,Dí¤8V¥F1]ã÷twP]Óû°š=Êš ¤[ ˆ¬eåMå·#RÖgö–0ÊÎbìžUvÂ\….Æ´¶ìú zö<ÌuÍ°¤J§j;w³O!¼µ¯Šjú,.Ê@›ÌŸ$A@("PÔB°Væ¯*vœœòa–‹†2{°¸AørjYu4eèR¼üÞæ: Lv*–mr2C]}nÕÒM»ƒsg<ƒÅ²Õboç¡Þ¯YÕt¢<ìáÝzéÉ$4ÑLȈ¾ð– ÇÙð£ýBdÚ¸h‚}¹Že׫Âæ¡(ˆÌc¯e/"ŒÝÈìÿ’üíjŸ¾·/(ù¥m ³•Î´ÁãHDÎ8¤ž›£qëÔ“ÁÎÿ}àßh ¬’1åFEÝjU@LDh÷^ü­Pw¯Àø5ÎÆ’A@ 8 (¢jþÂ[™èŸÿ /â‰úM°0~;öáÎèÿ=õŸ~Ú£`¡Œz¿àB/µéìPγ¡K†â’Lüç„$쀛d+;V´boz×­ŸáìéÆâÔJðLMÌóqzúùAùøA}ŽÃI=s—âºõ¦x0w4NÞFП‚¿E§nÈHHEK¿Â|Gá…„e¸{zE¤Hák¹wÿÞrù&÷¦K ‚€ Tˆ>8³ÿ aÕ2¦ª@úqá'íÂõÿ˜?”9¾tfMðF#'öçIågÚÐûAÇ g-³•‚Žœ…ôŽ*Ƴï/²:> È¥!-™ ”Sâ*·ìFÑ ègø¿†².»v[#\SkÇÛ¡Åú;Æw$!‘!7L…ô€?¤à qà5‡6eØס?¿öï—q÷š•AKV ¯ß ±Ÿ‚¯Ç-±0 • ‚€ àçõ Ì•ß)8ãÃ)gŽáût¼sà÷bñᬟ0¼bF~ïqUž ?nÏý•—#ãrj_‘Sœy90z¾Ÿƒ÷óÄq HV†*0Á2€ú´6pY´׫ŸRs V•%šãÔ _'Ä‹¿_·T‹„us3·®2X¬³ •Ä„©D$¨÷’¦¯ÆʈuåîBì}²=­Ù.‘­ËCÆú±ß›_Λß]"™dA f(ú®š¶l²šÔ4 k¼é¹^pÊg,ž_²Sÿxu¤õwÞð‘Nðn›|±ÔãÈS!È‹aÏ… ÷|hHÜ,`* Œ¯è—*ܼ \jNëêB|ŠLéo8¾“âSŠÛØn–sµ¿±ALFb&XËP¨+S'€ð¹kÁÿx¹ÕGá{~2:£.Ü5 ˆ¥_K, IDAT‚ô`ASN½•Í Ác=¢[]­òû¿éoº|Kek“ÒA@¨=p^’Y¤š¿ µ×úÒ[\ êa4ïæoÅ@ès¢çãäΓY«çàþ±£j”J¯*Äœ>L¼íSbñ¥IA±K0'ù'?vÙcvÔ Ú¼åaÎf±Ûl§ë‚ƒ´ñùi8‹¤H¿kÏ"œ¦Û†ÊÞI…aU†Ù[asî`Ì &ÁìÐÈü@u-¼MÃ-I‚€ ‚@r0kbpÓú<`ÌálÃqŠ2'#øÒIx{ÍÅö&,C¨ë*ãqr;(61ˆA +µîlý@fPnÕ1ܹ¨jBBR벩:ÓœuQ‰:+‚ù ûu{Çz<,GÚ´‰9¥ŽèÅÆ"’’]ÓÙÓŸ‚mì;m0ˆ‡& ÈÖnæìê=QÛ¸b‚6ÆýÐ$þÆWùŸ©®}õÑħÔ*‚€ ”‰@1ã 3C*ž³•aD‘w˜f*ÖZðÃÁA™OŽñ ÅùLJ5á^ÞŒMx;˜¤˜ê«HqöQž1êDÑD§ÈIX{Ýd†H²™þ±@@wr²ÚR>7Å]wÁë1˜cá ¢4$w-Ñ4 ÒñGªhBÚèÅÄz/vƒnD†UïîM8ä4 ,< ‚€ 6ð†…ÛAgþþR*=eWPký¹Ró”ÏÏ?qн2n$J¢?ÓwÙ:Þ`—Ó _*£ý‰Î “£×81èëÄ ä#¯V¯´i•9šºr ?¹8õáûò ?†‹›qZêÕh×L<ÒFƒÝãŠy¦»/±“³Ž|¾Îpw)íß­:÷Ü/gv¤md¿‚€ Q# ¥Ì©Îý}NQV%€ðQ/±…Ô¹Xä¤.TëHm5({Ô…0I³JØ ~FmÚ(,Ó_ùÀ¡ÊªMQsÆøÜh_@r(±cñ;„>êê 4Ó…Éál8'!˜`Eú@îû@˜ µš „ô£=*ðÉ{ðýIgãó ØLá“G„MŠúÖ«®;6µIÙ•ï‚€ ‚€ 0>Ö‡I¦G=~ùãJ]6~-£äH”bxÄbd-d+š“Cyö sbó=£´7=·ÛŽ¼‹/ØìÙ%, [÷;ê R±v3‘#6;èU!€”qvÍN|¼‘ÚW}Ú+1öç™ûÉJî&X¦=~ç¦åªmÖçÔ.èÁ&ìëU[´Wôâ™7~’A@A "ðâk»É ÁÍ®ïîÄ ðùÓ›¤¥w‡öŒVê­éßKoôÁ9¡iøñÁwpgßîTS³5#0K Å„Çš ò†EF[uÎ y!„÷B4y9>“ñ|¶1Œf› (Çü JK]Ë¥ ‚€ Dƒm_# [:Ø­A@A@H6”]q¬lZl¹ÄZû>[Ú~ºdì°ösƒO8öéö57ãòüA·Ë¸Ä)’´L›§e%*«ÖÞ20Ôh˱¿}!ìè“šfXÔjÅñqÁ‰¡|U¯}JˆŠ-V€ÝÔ²l:×O|‘fýBÈ"§ „ï1P›6„Õ}(s=Äœ‡!l<às0±Ü«ü-÷ó¦Ïì «)GF@`ÆŒÃÔDº@mØ~ ^€å¿·f΂¿¸ÐÚÄ †)VþZRÚJTvg'š]ò;LYiKÔ~å³IÕ¿ Lëäçý¯XG@_ãòb›ª@[Ï-sŽíÝ6ôi¤)†‘ý>x7–e8;¡Œ 8ÐL­øp|ΤÃÃcó\ã/0áêÅBa|‚váÉz×Ï`…³ †M*O›aµYmîÛ–fÝ`"I¼0Þí´ˆÆ 2{ø9Jë—!lö1x†²xÆÌóµ]Šð7ÕÇ?W]ÛîµþÑ~0|µÏz»š˜Y…çò5gÖ%jîì·©u›M¸êñSvæq*ƒPÞô…˜ Ö (rhÂ÷º_Ímù¹Ê«OªÎ-04ÿ o--1›¼w>„òÛ1Ÿÿÿ9qάgÔœ–k`\¹BmÙR¾v»ý°Šê^\ÏD=s)Î(€Ÿ˜Ñ”cSD‘ÿ[µaÛ_Їæ`6I‚€ ˆ€u¦S1”w@LÄ('*AL¹Ž3NɱŒ‡ó೿;v ¿Ÿ†ï8+á'x/Y‡ßEÞâw.8+Ém¥ìšwi­®²åÑ÷Õ[¹kþ·lé…NR„QŸv϶Y§ª:}5èïP=4_mÞl‚>ŒŸŒàÑ>óm:–"s)f ×+îýZÿØ?Æ/9æ´…üUXÓŸ;$?›hpþeªsÛçÇšæ´¼‹õÏ‚¶ný˜_ ¥ðÕGÕ†-+ÇÌf~lŸ}2¢h>JNû•ïPmØZÚÜÞ:½EÕ5®&`ý8µlFÙŸ._.åk[Z§LUuÍ—¢ý¿ƒf½¶‡GùYH :·æfìWX­Õ÷vOÁæ¨Ùˆ±NÉó1Mézäïh µ vÉϳF$FBj]mÂ[ †uö}c¶“ìľрX'ìøWµˆ50B(Ts[.‚f`+ì_Ts§N)¹yFh™Óò UG·€æ,¤/V ü š3ó-ã–a«í-€ðñUä-Eø0E¾»ø·¡N#5@qø¹û áÑšmËgUËÔÑë-йË>‚Â30ÓZáb¹ù6jʵœ>þR¦ðaŠkï_«F-»ÿ‡9-¯€ðqêùÜOø0T³ eϺAÍ9ßÓ¡‡NB_.UõÍО)@?ë%RÍÖÞòlÕ>ãyCoÊ7A }ÿp}†5ç¤ît>L݉@ØØ÷;h@0‹ŸcÌT¬ÁçAL#®q©ʬ;yã¢_¸” mo߃.õ°VÏq¡ZA@ˆö–Âû^5wÖ¿—U£æ̾sùwñ7ïƒ÷*žð ʺhÜræ~L›n œ3Ä"‰)Çû kF-cÚ´ÉØ)¿ ãy£æý‡zÔùE,ðß=b–ÜÌóÀ4$d´*ÆTrôTW?òûkÎì7é¦eøÖ±ZMÁ¥ØŠZMÁÈó¬VKFű}fBÊ/AèàzPæÿáïðw-þ;8 î-„bL·FN¹™/Ež£³*3Ñ¿@лY™ñ1V2æcí-‹Ô¤ú hÏ`jr1;ú‚åÜY_¥ pm3ŽG{  R÷)¹×ï«jùMH<”y-´ž-Ÿ0¼Ù–v0]"à |ñÖf´œkÛ¬²M§•Cg^h= ð¯ûÿí]|ÅÕ³w'Ë ›b[º“-݉5 $!j !„Ð „’ TÓ!@è†Ò€„ÞCï%¡·@ ôP­b«¹Ð .’îv¾ÿÛ½²³3WTlKòÌÏòͼy3»û¿½ÝyóÚõø¿n çås2~Y•'σ†«2SÓII±‰li‹@?`‚iS©>±è[P}ü4yrÿãe³¶¢1q3·`ñ·.öºnÂÂíj¬Y¯ì6ÔþbãßÁ‚‹í@¢sÝŒE<؆â™M%Îð4¢D´iBõ X˜Â×#T$-ÁKér,ð÷DÏN¨Ÿ€¿C\~Ó‘Ä.ýúù¾Db5S×S$ò$æ^3O/UIgtdª LØìJ/Ò=¦OPSÛ©øüÍl?ŸÀ]ž¥3ƒ"ÅÅTS3Vës"—àúâ^Ò+”q7¤¦öíñw0þöÄüÓ0ÑÙÚLâ£P·*k2 X´7H< þ¹˜sor寀/˜¤é¥Bâí:”¤¨†pq B¸°àq!ΣH¦gçPjˆïnœ#GdA6UwE#oažœŸM õ¿AȼŸ•¯Ÿ’+OÄ\§âïeª¯…ïž-凼¹XóØïâŠÁÉŦ?äú}JƒÌQxÇÿøË ™°+‚Ö×±“|`¡ù«@¯^åE`câ|,ØžÆ|õ:S°8wu1ÉdÖºŒ‹ñNsiáÛ"oNÃ-,M±ãÍþºðÁ ä/<õ?}ì÷ë‹Ioß»kHøð¹yÞÔ±?„˜U… [S'¯áQýÈS)pȹp†>cÖ¾¦’q ›ƒâÇ:+;–÷ž­Ó”žîÓ¡M0ER…-Ç |xÓ`1>ÓC7t®ãÓ É¯‡„9Ö Ò’³hQf×ðáO1{îÇDé] Àñb_-Bœ˜'L«]ßÿŸ0¿.|[G8¤jáÙ÷¥±îa-à{é'ø3Hù#â”XÐ,R8È@*ñ7ŠŒbß“pßû³c Böc¸çYd´JfM õì»Ã™TâEœç“ø¼ôs𹓧ùQGÙ–EÀˆ€C±£qg—¾·#óħå¼éêfD¾«o•!+€ ,(^²ÿ Aßɳ°33t‹˜:cSø}<„;!6³Äø+‘7â̱¬ÇºDïä˜Yd øÙ±#6UŠTÁ™Y`1“xŒØV½’â ÎX ag¼Ââ™åˆ«}Ã0†ÍJ’ñcΓp>¥ß+R¨¶ÿ‰ 0î)ŒK*3Kú çE ÍkÈ Íu>C»J¡‘|š› @{^¥£%„®ñÌ›ÄæÞG!|¼©ÑsŽÎ%¥y)ÃÂ9[¾Xrjmàý3¹‹Ö¢æ¶ëPG^Õ"›lW×€øfnºÀçËÔ<·+ÐÖ«^ñ­CØä&•«ý$´·ówôPäÕ­¯¨‚éšâ““!iuu-ÔÆç3»ÞÆbÿž\³ð‰ó­ŸèßK­¯Ï }^ ã`2'éØÝoöf B›£EÄÃèø¡‘×H4øÀ$k6Åoän°ÿ÷Ùøeê½óÅ9Eú ädb/ü®š°Qð,8¶ô‹"ȹê¸Ðgú{X,ÊG‘;z³þŽ_ÚãŠöØ?y ‚hag¤…:l–» sr?†.ç!ž V¿ÏAY H¿Ñ³—9BD<ÛovDfÁ¡1ñ=âüý)ìëÀ‹vÇÁ¢OLò¦`-F4òvF¯À‚$´¤1qÆœ ¨UÏ7 ùbŠŒ ú`ð.q*q$vt_Ãq7R†Ûy&×_4æ˜yZ$ÝI‹Òkƒ>3ÇVø i@üÅüc~¿ÄÎœü5´ [À<ç},>Y8Q‹$]ó|SôÅ¢ëþSlh}Õó0¿ØSÑÊZyÊ'Ÿ, …¸ž¦ö#¨ù³‚é”Ýyž`Ūã,Èÿ®>ú Ø,Z&3òwù"MiŽìÍr‰FÖR×1OO´pέ­ cB7Ýk¤‰B>lzu¾g"_OážíÑ¥|þ*ÐZµ³OÌ?°p×µ{cwAaÈ¥¿„ŽÑûç*’™=BôlS¨Nø©ÄmpRg!|í~6M +ìË’ª»ÚÇ[1Wmb`°€C?›…U{σ¦,Àk«+,N4z–·6î'žùUºÇìÕ9‡´‚ÿÓý¸¦üì’o“o ¡Š¨»p¼NÇeÂ@N ûgl}µ¿üôÄ/2Ïò[$BKå'£.v*g9-ËÞUg3‹Æº'`¯þ%„w±PØiÏÁ6¼‹÷&O«0m’n:b:K¶çOÆŸÅø•Å#ó²CtÕM2/XØŒC"D¸°yŽ+ 3˜ÉX´­æ ”‘ãéòx˜Õk ç|\ÓšÙ> ã=ñWâ}’Üôº˜caˆŽfHÒÜyÎ+»€…y/øšÚöÀ®8ê!3o2¹’6§ ƒÁ{ÌÖÅùÿ…ŸŒ>,,ösƒ„Ô5 䘟ÅÉË6O¢Ccìû(Æ]þ"HD3ÁBôq© %<µ#zG(UÕ…‰%« 3üò|_•š4ß'„á{Fo´*ˆµ®qc W%É ]·),¥"&æ›3;ÿƒ{î;¸‡7¦–Ž{ò÷€+õM>Û¨÷Æâôe¸‡`ö͸¼ˆ2ÝI܇‡à~›?F°"3ª"ä›Án¯Î÷¡”,›ÍÙ?xƒÁI<ŒßÔnÆþ’D1ç~ž)¿(ÉfêäðÆ„‚Í3YˆáÃìóy!&Ü¡-8K±Ág¿…æŽbñôm.OØpýseá¥7½øü(/(¥<‹Àm©¥«צ.Òx2Þ­ ö¥påþXü!›¶X‡š:ï tÏÔýª i@˜:³}‹?Ó³Ĥ1-îy^Ç°ègz¸˜%–wI¦Æ†’vT-–çÃaÀ¡ £u’48¯ šï*“g–"èž#OÊUJÊc¿ì.|ÿÒð.”6ŽÓ‰Y2Üáª85wA.Æ>6ïSµV,ð’Ü™hñ4ÜO'R˼No¦°É`~z§pmLK/ºã}Í×þ]‰{züŽvıt3kYD’d-%L¬Ìe&æ<¡–EÄ°ßåm}SÄuˆÄ¶Þ¢xyiꎅÀ f¬ Î÷Ïã¦çßßÐæ¼DbÌ'Ðļ ”35 Â-䥨8…§úüï㟙ôÕ}R’}@'SræAè”Ígb*_î÷T’¾1”©¢þâ}zùi«õûš²±xÎmýè¤Î³¼ÆÃÇñQ_ŽÍ¤¼…þ‰ïï‘íþÿh‘SéË«/‡±¼+üP®¯]6ÔûãE|´¿ƒ0p2^º{QC „>vuĽ¸¿+[zÓ³_‚s)ŽËù Ôç2/8_Ĺ[[¼›NMºúbÃß ƒ‰¿ÓÌ·LÓx 4¹è|v¼ÄÞ˜Ï7Yš5‹"q<žÕ/Po/Ì^Úÿ„1¹£¾{,Cœž¦¶_2•Ìdò'iЀäûÂÝìPá(LaŒI´„¸ü¦¾#¹±3KôLÞ8Dp¸ˆÏ­qÍ ‘ñ± F¿¹ÍòßC7XçïIˆïI^]Šÿ©4iz¯Euu«ª|†–¤-5* ¥­ó»òt!TwHD†âÜ+åŠpV/ÂÒZ„^ ;RßÅÂp_aHSû?iæ§_£Vì} W< õs5â"O@è`8³íPÏ °aÒ$ý~¿”m!ðD¯ ´õ*~HÅ?DÇ%¸ÈuPøw"h<Ï΢±ÑYx>þ4]˜2¶Ä¡‚€Ó0örë ä|ð@SÎ:ñ±Ì †Z[øáx·èÏy±´')º%ÆÞÓŸñƒ5!Ä#Ný&8Žƒ—ôÀ n„Ùr1íî%løtËoŽ£/ÄzáÀÒ»žòHìï¸B hú´ß•­'•¡‡'³m‹@1Rñz܇ã%¼?Þ´ÙÝ=ÜuØ!ðŠ'àÉ»ƒ9šÚî(6UžÎ;…Ž89ßV¼E¹èÄ»¶HŠg,ÈOª…®ó½nv²M&à E@°x»·È±!Lñ܃$ú½àð|Ý•×çë¦ û+4Ö݈®£Õnø®ÕÇù…öºGoncßØˇv•IbW=‹g~‚ Vžn¨Ö`hãõ¥a¨G’æQ†Î†‰¼èÅÜÙÒÒÑ œ—€7d†ä…G÷¿‹oø3ßãF‡Éøž »ñ!.7ÒëB…ȸf]q彸·¶ ±NÀýr8h¿Ñ ͆ÚÃИP äkæk\‘p$t Bc‘˜<´³z°Á9c"Fáö‘€ JÐr½ŒóŽÄebþ•ª·ñ^µCkí¤Qø÷´Èý@£ëý~‘ï^çW)†¡Óö®«í]¸nj;GÌ­*ƒp ²$Ý«j4W†u™{Žsy6­4µÏÀE°üµÒÇ>YÉÚ-òúi…Î 6Ñ (ªIcT¸'‘D3™ØÁvÐ5…Õ6† ¢áâá2ÐóA¬Õó:Gx¼÷Š ‡R;ÝÏ ä| ¾o3ñ‹ çkŠ†M^ÀÃap„ì*á¿‹ì:^ø ôd—ñxR¯ãò"{•ëºG¹Rnã.–SÜ–ã&¹-Ço•i9þHÙ|ܲõÄç­ð±Œ¿œát8ß÷¡ò3æ]½T¿GÞæü9á£ØâX€üÃóåÈEÝ1±²Í´å=ðø8Tª<‰ä¢U Ä$`Þ1‰Ò™¯£ëÓ48Ÿ³ó­xWUÈ&•Obá"·ÂX,0鈔뺳5^Àe:|BëTO(­\Ñ| …¢ èb3ŸpT~G=?Æ`BEˆ‚¥i0òÔŠã~©²-1Z]{Îàò~Wlæ Ð;|Š¿C|ºÖÍØö¦ËïfÒE´¸pB—Å™Ûð½®Ç¹À³Ùós;ß MƒS!Ùs³2$ÝñÅ Ž@=äH1­œó%¼DÇ©"L°,áÜÆpº§`¼aÑÌ'ÔËóžŸNW)F*©j9ÔjËäüOÐæ˜ÍîÔ±^Ë ‘dºcЀùÃ=´Hža H‹2gã|2B¶&Ý$U» ~˜%„ÜcœûÆó ú6É1â;Ó…díB„dbmïž ‘msé €4{ r®èìxš½K³Þ9ÐyÂㇼBéÅ/a¡jVS‡¯ÆÐÆØå"€ày, yþÎ_‡¿Â¦†Së3 fW=¸~*[{­Ïƒ‡à$N<ÂÆf™æã‘­'üí'G‚`5¡™§Ä‰ë8òL2þ.ì”9S±¾ _9 +ÉÄõà½cÂÝeÚ[#êÎ °­Öøe Å1…æ5deŽ&“.’õÊ|©Z¼¶Bóm”éù6„qniÿ°øl†VlAÏwÐ~[ƒàœÕTØ/ª!¾+L½î¡ªñ0;õ’D~Ëcå !¯Áïh/ÓPKp8w"õ3ÎCØkueÏÙÒ‡¼}i;Œ“+}êƒÐ ?gñpýn¿§Û˜ÞÔïñ„¹ÕªN$ú;Œ_Ø  w Ÿ&›¿»ÂS±l¡‡@}M /"ø] ä©# èM½s?¬h>x5µ;"jÿžÕE$Û<óîZ¡jM¡=ÙZ8G§ÊÖ¿ Êì­8c³&£¡öHÌ7ê’ÛaGœ…˜ÂÈ¡Í ób¡‘)ýÜáü)ÖÈj¢É»ÖÉÞ }Å›×dÇí5#ùÕÜÿB_ˆ°Ãq–×s z,7Òø)ܯÃ^DïJWƒBÊOŸ:– “X Ò¥vZŽ»€LxQgUpl¡’-T Ù–Ñ,}=_ýšbã×Á÷±¾6Nи–=4zÀf0®»'µt~$­÷öf(fXs:Ÿž„çŸ*ö¢Xüvœ‹É,©è¡²w“ìØ;¿È s³é˜²âãú7?‡QNoG³ç~žÚk·}ÒFõu{P”ózh‹£5€û OÆ¡b;ÌÛöÅ5àÕXA‘ˆ8ºñüÁ}Ua¤ d¬‹Ì'ܸá÷œB&S‘H“&çSÅ”ÿG„"IM±a.‘ërQ¿ÂÝfº>q˜!Ké¬B(ñ½A™‘§r6ùˆü¥'¤‡£Ýå™PñZy#ž±_à·òH°«l½¶vRYPÙIF&' cñ^[ Æâ6G.–G Æ\¦9 oÛò¥¹ÎÐö“.s«S`nõv ÅûuÐpÅ#v1þv†ð¡ïÌ-߯ÅÝ"P~!±iHcbE£3±¸x/ÿ{0ð좾…Ô|,ÀïE´©­ËNÆ WŽÂ"Œ ÁÁÕTlæë"ò[¼øÔׯDæÙ»…"|ð^4w\†Ú¡ùñJE«4Iè>ÌÐyKå3´¤|Â@Å;ÄÁ¿\1基B™W3 ñ+#=H4Ù‘ãÊÈíøoÍ\‡b*¢œßMv,²P”‚ò%SD¡@þˆà,¬mZ„t´î’>Å}óc,¨NY²î×Ø/‘C¦XaS©¦öŸÀ\æ`°´cSé0¯!ùˆš´[ÙÄ‚lÚ×ܱ3´O¿Áõ|¢ÎS¢%é.Z˜Y™ãKßó­mO`ùÞ(qt}L==[VdÞÆópB?Žz.ÒäKfʶ¥)ÂY“„¨S;ZUÌ) >2n…&‹RšLáÂ_;.û{´tܧу„Ööp/4IÙúöyGÕŠˆ lŠçóÊyzÑ P1?«ÃcRSÖdzÿ|¼+šh´ÓB uß ³¬Èmtä™üWEÞÂæ÷ Œ'Öž,M³øA[(/Õ/ÿ+ù€(¯î/rÒ‘å7EÆ–"‹U.œ€ä.§‹±N+Ì­ÎÅÚ¦‚]©Õ>\ó§Ð†þ@¶×·uÛ²,{8|-'à㛆sôfE!v¦Hô ¼\î/šøŠM…R‰1Ï™š¡]]Èì€û§MiÄyè/_Á&R%LMíÇSø%íBlèÍ™ë@¬ \5ÿÉ;´íí‹òíb!L/vpWàä)Œ¦bµÀH}¶s’6£-7vDS‰â;élFAôCíÔ%Ìtx!\®ƒQÓ®²>›tÌ>N…;ÇP6öà‘Ù×¢¹ý;X ï¾¼–†…1’¥t÷zX¸cg¿¥[ÀÚy&))/Çß ˜Ü•îš:þA$‰q»ãˆœsâ-ŒƒOÕÞç›Þœw7˜Ö4"øŽQaá{·¹ýr$§äâᘿ=úBÍfDÒó;¸ AÖ…ßÀî9…ó$ŒSÏâ 0þ*´z•y vš—Ó¹´+å5_¹9zWaM›©,05oX“ V‘0¾ÚaªFB¿¯üŒóºæ̑唜óCˆí80_gŸ%aðÚßwùò®eõ<­¹óy|Ÿùv¡Ò‹ùõëå~'óZ-Tc£dâLïb³ ÷2L¾„Hâo ²‡·…DýŒmEý&¯z&ÿLn­À‰ßÛÒ^{F•цœ7ýK'9dáÛöñ<ñ™&¦^°ºœ}Rå®ÇÉ Š&VŠŒÇ“jRb\_ºð1Ué”eªLI÷|EUÙb¹´3pU!É3{VE8Àƒ}ó˜K€Í`ŽÄØæøÛ`ñó~Ž9ølPû4̶%Öœô§°c6ñÕ¨d>ß^ÿ.°òßà?{û_11ÿMš4žÆFVƒˆ³æÌáHP•=¼Á¡ÿüßø!ph?ƒdôGÀrpðo¼˜—µ_B½@_õÜIl Ô×­žd"!øUR¦LÁxÍT ¤>iotÄ¿ô3’î×Q:$ÌÏSñÍñ ~N¡+è9J3×ôd®JÑ^l–|®Q³‘V¨ˆîB=W $e4¿ Rű¸/2ààðá·Rzá={ ÚäFùŸÐö4u½¥ÐØ·/ýæ`ß¾õ1Þ\XÃ"#S}ÍfÔÚµB®‘<ÁCˆ3Çà [¥T¬?–­ Oª”¿¿|†»±¿S-ÝqBJøôOñÎ̉mÏ ÞîÐBFwÂà s øòï–‹î'çžYÙCrÐŽl'²hL|Â60—IÆÏÀËå\Ä”¿/—â;–ÉšM!|ÀDªXð¶'^"áVÈ·‚Í’U£ïÀçÞq8éU*þzÔ—¸¤ÃåçxQaw,|,ƒ„h ž^+2ýF zzŸ3.‚¥h̳ ù?^•hetä» •r"‘uµqLˆ0T¶ð΢ḙh†ªìÇ°ChÚQ !*XüDô¿ù¢ØyÜÓòb[/®{q¯JŠLn ¸C&Gyı@+ÿ¾ù;ÒŸÁ!‘['±£/鷺= ¨'¶ "TpÏ÷ÿÙâ }J!×4‡…¹k³¥8ûÞ—³p¿à9ÁÑOHˆ{Ú«¿SÑdcŠdxEL ÓN…)]UbÕ0mõ·™cèé¾’FžŽfAêæ )n£†Ìû°3\Rñs Pï&£ÝÓª‚`s¶žlÚzÖ„±Œ¼> Ðè¦ï€f™¿W¿4&ÖËUóŸ9¾¼H~Y ‡®ªz9ß_®"`çD~ ¶³Ê±Ž”~1ù¬q4vÜ>ð‹>‚‡ù½1À‹…*ìmùåŸ/¨WáS6ˆ+Å3Èat\ø*m;ŽäÝ•«*åÏñ±SBbþÏ€}ñ…¯éÑC¿Áï@?fw ’½L§YÓÿ!¤•è@iǯ$Wž¨DNªäšS‰±(ý X}Ó"v'$šK"Cø´)Ûm°={ëø º@€Y$Ý€„’¿¥–.¼œP84clì1˜“s¨{øg>çßúž’D¸OÁIÒò|—ÁØ,€è~ÝØm%–Ùý:’# ÚV§(lÔÜñ‡¥t5ùBÁŽwF½ÈXáŒtE¦iž;Ï‹´Ó2Y¦9ìp‹¿ûaGYö‘‚@[Û'¸”Ûú9¸]$rîÛÕ0Ï$<Ë&Ád®³¢9cñiF>×Ó é]¬j„Ù‰ó•NAqh:ŸÃsñJû l¼|ŽØ kC09 «Ћt97Ha³ÈK*š€ÆM‹\æ¯kô y>¾êB¶&e‹BkíäMþ+~n'ë?µÈPt¯æ®×p}sq~“UF´x=Ä‚˜VÜr„DµB´ÂqÛ9$÷cÆî `J·t.kÐð÷ùÉ™•™(ð4†‰úy)£HŒ_„ôéÒ±úØ c¡H)¿°gßšÙK–}E,ú}ÜöKéë.\ÎïMéföFÒ=ì,žPè°5‹@`íA2ñ'c÷Å.ðß(ÝsÍš×Qr:Û—Œÿû#Œ|lƒë›3ÍÔúb½ 2¼Ìä°U?Yá÷MVNGç`u½ÒÇ ‰ÌÛIAC.ñìÅlbp4L~…]=6Çò‹ð´šå‰„t¦G‡Œ±É‡y72w Ç“«*ŸB,Ì·Ù„µì¢–᥺g¦ÒýV2±3„”Ÿê]ð±¨ÄäD¦!€ãÈ”¡Ï J{û|ZuÕ-iB5‡þ‰‘ÇDdgd‰Ssûµ¦î¢´®®O©aÊ·)í~ùÔòùÞb¢è€P›u”û~BClÓ"0h4u´b®Sú=Ÿt¡5p\üÖÔM*²qÀjê¸ϒ£r\ÏÜÁ/"tlž^le" ˆ}ÕM²í™ÏIYÀ˜;·¸†d|”7R`z.ò©0Ek'ãÝl´Fwè5…Æ›u äÎÎñ“4—îÁ9Ú!~‰œH#RSÏMPdÔøz(Æn‹Ï ¼IUìëVpégKãfÙÛ½l?µôû°Ÿó›†Þ\&¶åOãLØNò’·q&fi¿Ì)â«›$ë.f5 js˜'¦œ7…ªGí e1!²5ø«–ê·=.¾t7Õ¥°·;*¯ž2—a»-•!ÀŠ“ñ»poáGRtÔAx±]E½_e´Y÷Æ$îÀ˜-KDLFDÙ ÿh¤|Äi [°ÑÔyvü°»ÉxaO!QÃZˇ)g‚W!a.î£4kÁÇx14Ú¬ßT ¹–ËÏ£Bt17¹š¸׸:r~\Jv— çøHÆ‹õ¼Wà³ vž«|é&D3°@˜Õ?‡qüµï(¼ä·Ã ™fáÇÐw3²¸ÿ±ÏZ4>–¯‘‹¾<[,%àðÙü[¯[u UÅâˆàW ­E¾gÅ,t lJ¤â ¹ÏEÞ.<‹åPU„5"ccÀ14npörGœ¥ÍÆ›¹I"Ë ß©ð#šÇ¸t7}"cA ’¾ &\oæ§nL˜´®PëçŸåy†iEˆCb4mMöwÙÔrSlFoêD«×Z–—ƒ/ò-I=;@øè\–Ç5¿t–åôáXÙ| ý@¼ÃD½Å†'€°6„ê/Ú? íPý±]õ]P°Kaú¥ôá$ûÀŠßï«ÒusgM×M%ú0eax/¬•ÆRÛ6;Áó¨eZÍ×iœÀY[,^Fd¨ì£ãÿ òõÁ./{ò(˜ áW¡ÐM !5òÔÕTUý5.‘ Ð_„j]y‚”—á\UÄëtxÐ@üpUø`)š´Ÿ,ï¶q‚¬`\ûÅò?P\³€_ÅÃòEȃà(~)Å ÚŒ|g¶â8‡IÐ,¡ÌbUp™Ù~ =ð Q5¾¯Ë™4±úôóóÇÁâ›!b¼6/¤<>ªƒ‘D>ïTÝb`0:ÄbÂB~ĦG½d„b4 bMppØÒ4þZ±@x>?-¡Q¶i°ôߨCø¯²âù6 nÇ&oFðæiéâEš’g5¹‘œµ±îI4·Î‘¼Oá¸9÷Kä£óÏMÏÿ®ög>.3?«ÄÔÜö¾2©á„ó‰ß iCôÁ殣—ÿ Å;ƒ‰ — LC»&¦žµ 9ãjoªßç4,4×Bbir-Ñ°F#VÙ÷ÒÒÕr˜P ã)¹ ³‹üô”/LýK“6¬—ÜgÝñÈþf'¤§ÿÌ‘Î3j-Hþyy#_éïôÚò3$<•Z]¹,}*>1˸|à(O2¶'œ$·À l-Å8ïDRãÒxY´àa ›}D™Ùþ|ÙLB›‹Üˆ†?‡i€p×PÈœÙYÐ5Xtª¦F’žÁrèI…_’.€Db¼xÕ‹#ßщ!Jsç‹xù-ÄqƆzÖµ M·™×óZ‘U)Ð »9¼PoLÜ\öWyÅTDõùŽýK£ ”¬;/àÕ1h dÌ6í¾¥þ »Àó[Úò"Æ°PU¢È³a®öç z—àìí,4Ș+tàZy8S~a›É¿Ž§Ðä?[,¡‚g"çD¡~plÒxxøY›Û¼À¦ ž±.ÝO‹3÷—ÜHÉ]S:}Ìh_Ã3jbŽä}"™ îŽç$?;>Ã& Èð 3/?Œ<ÁÔ¥Ñ$}yUyÚiµëcÎQú¼RT4†Ê ¼!íL»ø\œgþÆi¼‹:˜x#& |%p@ ~Ñ°ÁJ®.FÁ“ ç%«Aó?÷J8òx°ñ'0–Sœè¸*ÿl"ù“Â,(:0y†eQ‘îïeë¢éX‡â:—}Vu§Ÿ¥êì÷جð…o%ÇVü/{9Ó»3¸‹¯ƒUû)²ë¨mY¡ðb·Ç.EŒó­ýçPøaä™Å¬ŽÙêÀép&!òÓ¡Æ]iÖè%§bž³qw‡' ÁìÍW 9´1ƨÂÉ‹`:u 漌É3׌&XáøìÜíå ïö¥³À¦jP$tåJ:ÝdŒPqYHzAžÁ5EÄ/@ =DÄÏ!5àÎÄ5óî KÓjÖ¡ˆs4„•9¼†\@™ p6^Ì×ÔlEc¢×ã»ØÍÀa&IKR‹ÛÍ %¨3Ûùšl±XF*Í]/ãÒøoà…ÃÖ6$¶ÁršƒQ¬ªLèûª¬£Ð ŽFçf~†€"­á.c[4 ÂËcd׈ŽcØÌ—p_ÒxûIÀ¦°Dª‡Ã±.œà‡ÇÀ+4ÿÍV¼È \ò}Á†OÔß¾ ³7|yÿ!ésXß*gÐ÷÷Í ž|ÍAœq)N%;Ož‡ûä½¥xˆ¥25¾lHÐt‡ìͬ›i9þÀ¥™Yr©\€tðHƆàñ &ÞºâÉ…ØêÛWðòø®2&‘Aáv<Ž1øøÃÂ…—"’¶ ‚†”ÿòù8C0›Íl?ÑÓÓï á9¼d°8p©Aº9 p#WןÒB°ÉTéÒ6oΓ_jŽ®¥iéxdÌ»vB|Ø=!d1þº‘—ã´uáƒåÒÁùh^êQýk[8)[&½ à¯øupò8Bt¿/»×ê—ðáÑþo°X*G ¥ý¿Ô³dC x¸òAàdÇpÎKÒÒÅ5å ç‘Ò£nñ¸7ËÎr8r‰)›æ¼«Ó@‘bÞF›¡xƒ=!Ó™õ–·ðÁ€ / NË«gññ5>ùáP°^yòÇ©nó lwoËpG€}œª줯‚…úÔÓÓ¡$Í«äúRuÇA˜Q «Î³A‡D¦oæ0UËKðËØCáåõ íˆ)ƒ¾¯ÒGÄ•Ba{ܺº½ L¾‹ëc¡šïÀ 9TXÈqjR ^™¦P„|åÂ_û±ò“¡£°Ê°üf‡fMÕualmh¼z¹NÎîœJLŃäø)ô µMt$>•íù/é'uj%Z©j#à“‚ðÇš&Ö ÍF–é7Ê&) ÝV-‹À !à'‚ܦVxF;GÀ„ó‡x3Ýý‰Qÿ«Ö+óÉJ+9‘Xõ7Œl—7^*-›jŒR¼Š÷ƒ«ÑD@BÖšoh Æ:”7ðO¢Öé×âSß´[§;ì—$ü@Ä!Ë«Š‰ï–wcY7CÎ>þåŠZÆ¡‰€ÿ€F^ Ú ŽÖØÑÉØsŽMXó®Ð}”^r Íž_ÚÑЛ Iß0Y¨ÀæT^‡ü=øl…ÿ¤ÈîX(³ÏìK…³ÀF¢·€òmºHžAc䎘3›¬O¾€Äk{Pë¼NhF¾ÇR»Z`›ÎÐíÇËÿ‘ʇVQ¢áñ ;û‘N:ÕX‡º!í ‰]©¶vùŸÑm(±Z6UR¯‘Ù8re¥lª"K¼HšÚO€ÁJ\ˆ¯‚dÅK|(ƒ–â ¸U?êÔ3 òŸ-‹€E`è ÐÔÁ›ºÏâ=¥TÍFäz%xÿˆ žÏÙïùÍ®¾žµß4¼ëð^é©LáÍ› Õkë¯Kì"F¦’F/òOÀß8}G“Ji†‚÷YŠÂçg‹`Cx-’ þê-=OÂ~¦oŠ¹vÀnü£Þâ¾>¾ ´2ÏcÕ~ hGCˆéõ˜‹eÓ®Ž°†`naÂ"µ¯º?¢‰²ô²¦F’pÌât…ÎÑ™F;ÀPì†s‚!TüèY燨¬ýèB¾5º‘ g_+ô³€T¼4µÿ’+ß ×—CáÀ çNù-ý{ Hô4^À×ÂïÆ ÅÑ´=‹ÀpGÀ>óÂ~÷žÓ¼ŠŒ„ƒ»¯}Qé¦ÖÄj˜_Ὡ1ˆçèOŽEú<¼´# Wt¤•¸ Ÿg¹-Ç7Åë0|±Cñ4 ç$gŸÚŽ…þZÜã n‚fæ™î–i9î+|¾¯a[KÖíO±è«ÞB¿Ò‹ðÃÜž!äf<ÈôßV*¾5è_Ó¦cµ¨*|XZÚ_„&àØ!Psœƒò­ÖŽ×i|DPúu^øàN!t*Ÿ^zž›ØÛ½—º bJ8ØM—ãØ sCóŸœð.„Øé>XÛBh{¤€V)Ë åoKp|¡$TXKTW§:X†X¼¼,,6µmŠ¸ùcнÉ̦”Î|yÈW– øÛß aàlÛ"`°T„4 á"ßSŠ¶%|óLÅM¿j"ˆ6B|@°.‚ÉÕ™æã÷—CTøàïjøi@pÒQŸÅ‡îdÊW´Œ ¾Üh;îqÝÌßhÖ‰OB(6uËèò‡Ïa¦NX…ªÆßé/Ê幈‘Î÷Né’ªûìa¯6ï¼`(/²Y]m2òfF¤¥d-ï8œæ5óÿ‰ÝóÕB¥‡ö^ShjÍ×a:ŽY¯ôJù}ÐX-{ïµtñ1ÕÒÔÞs#Ö†ÄÔ,¶+/lZ5Ya´¶ÒægÙN&ŽÄT¿!¶Å)¼3­w ²aã÷+D ÿ˜µ"åÐâ\©Ñ‹$ü)¼y°ƒåå‘0‰ÍÀÅ4»yθN?[,‹€E`pH¯Knd#DÜÏ|vzç¿ÊÐ鈤OKéç‰#Àî|}×°Ÿ“-‡aX¼„•À_hÖ¬;\yy÷r8…>rX ®ÏÂä€>_í À—ü†âêí½Ám;ùÊéƒ0³bИ:y aÞ5°ØŇøãÏ¡ò;ìl?n<GíU­ ì×#è"„_½Ê{øñ¿>þøj\€¹7×ça[ljš >‹öð’XÊÿÑܹ_éãvO%î…ýA …C(¦âSAÐ59.?Ä-g WGªí¿éSÒÇ8ïÍB]f¦¹ýZ\÷zÀ嘮ùuo !ŒC®WÊǨ·cÏ\³¢O_€»¦,ŽMf™,‹€E`P`ß@¢G³}›’߱ɢ†‡É×”AiK&XÃKÁFø°2¹ ÖwÉÙ'}<(8,ÃI†¥‚ÔÏ v™Á¡ã=$1¼ÝM»·Éöé,³ÛõvöŽU݃ T'c_Xx ò1Ø!ÏhU}Èj$>$í¡åÖ<¿¯uxól!àvŒA ðÃÓ×€´rŠ·ø°a<œÂ**f§=™žˆÑÅjÞÙWÙ‡HrzQ{ A›8ùÎëê4· é‹ÑÖ¼¨¼…V70þ4â{aM奜WùL–Ó"`°X†œ‹)œ,‘ÏKÐÒ@„3o(\v©s€†c1ú_„nÿ!êÐÑ~b¹w©é–{ß°@àÉßc¹®3/IDATä4\ÒŽ%^bi!ˆ/úc8%Ýáºt"Y™Këà+ê¼ 5Ir"ð“€ÆBR ž4>çÃê]Ðþ çîÊ~lì¿á8lÂSUÊ*hØ„O5¹©Ÿ¸2EÇqD&µº^>‚½¼XN®ü+rÆ@ Ê+h'âíí‹ü!bAp¨W—TÚO!7@PvŽ!û)c•HâêuòPd‚BÄ*Zì;ìs¥I DO‹òBèŒüfsÇ`†v¾ÂS1vW WÁ 6|Ç7à;¾WöýÆÚšEÀ"`°ŒD¥gÑ8{bd&ߟßÄeN€yíÒIiàfæQ$2¤”oD˜VaüidhŠfõod-ïR'9€“–_/–CÏâãç¸ve(6´:W¼ˆìŽËdËô÷ÛX:QE ñ½a²sBË®›?Hn½ë}fœ \¸§ÓÌNs Ö:¤âçÁÞô¤ü<Å*Ò[<« sgìö`×…×½¡Ø4½ù³ÏŠ÷*Ü”§„øª\ö{ =îÓe§w癄\‡&MOóæ}$ëu ÿ(Þ‹9ZVé"%L¨´±1ª¯]Ëßç§ ‘¸ôñ´(f„¹›;[ðÿA8ö¡ï¸1ÉHþ“A[ì –½^±P‰A¶X,‹À ‚€ÿN¼WËxýá%Ö_‹œÅx.…’Ž@Y óV8%Ö ¼Éø&ÞÔ¯»’Þ@ôÅ×ivÛÛr˜øsTx™ Û°@à0? .@º|_ü”^ô°l?“£ز¬h¬Yšˆ[p8øTP8¸t¶ƒ]èÉÈÇS©@aMC*q#(»¨¨rèWÏa«ñÞÛ]F°aÍoøHöÂ\(dXXÀÞƒ¦R$–`m²Ú‹/ñn\€uÇdâøŒ˜veà_]4O¶œùyv¼ýÆ%Ó°@fÖñïÉúó¡”[­ÔùBèøxþåºòŸ´H>#çM/cêRj¶¼ÿSk7¦ˆóMü¸°û-&+ñCÔLæ©ŠCãq‚¿X„Õªºð!©&pOcî¹øÃd‘«ŒB ̬âÿA²º»Á× Ó+ÌçØLâ‘°‡·¨OqèW‚ i ÈPT(¯«ˆC¸Ó˾FØ¥(Q¢ áÐnÚ=ñ»ú[;ÿ- ;Àï¤Ì$Å»ö©Äîðƒø@éãÀ$®WhÜàP„Ô[Fk’ÕÜÙ†¹{ÑRÂ…\7ËQúÃßy:¬4“íµX,‹ÀðE93ξg?üÎ|Ø XI8¢?È„Rê‡HŒð”›‘OQwïÓrÎ)s‚ý¶Þ|çpD6Jì a »£KE.Nö3‚[©1ñ_ìœó(.ÌÅ÷Ó¸‹êñƒt©ólO Èuúaqoÿws¤ü'GYâ~ð§‘ßã< jäàò/ˆ¦ôî1sâ#8²‹0Er[š‚Xl --€8Õlj¥7”43ãž nM#㛡±€ò00~ ç><[âoc}RP¤<‚š½‡Æn…È&P‰ ´°äÌÏBÎä.%g>åà¶a°X,‹€E@EÖHX²Ó"’—ƒè‡c ü4léž‚iÈÓrÖôŽaz9Cï´…ˆ@³p:®§a!œS=–?OIwТôÔÕ¥gÅö͉Tß žQÒyÈH}ªqröï…Ey8—3»r/<PP’¢šÌ•šÚîðÚ¹ÿ’ñß *Öe¹fþ3Ó§–y‡¶©«%¨ªº-ߟ«Hzs~;×4~¦3p~Ç)}¼ð—½uÔ<·K¡'{Ap»U¡õ©ážB3;ÎïÓü†ó½Ok™-‹€EÀ"`Ê oDœå¬hN;Ëìfbr9<ˆEõ¶ý:&/Úeû–äg˜.LјÀÂ[ìU  ÆæD²=¡ñ™’ñí!D<$yuáÚÔ¶ŸFê붱ῂ$¿.·ƒ‰JOÕ½ AÁ”+7È•¿ sy®©|&ë6Ę—ð6){˜f¶í¨ðæ©Zäq®¾cs¤²Ÿ’>‡³Úo¨©ó†²¼–Á"`°X,‹ÀEÀà™:DÏÔpZVø0€ÂšŠ†ÄF0—ú)ˆC•z?j¬Ý‘jj&¸‹“’‰›Âï¢Kz »éÿÀà‡!=˜}jmJ"S«p1e §§J ÙÂ9,VŠ!$®shŽ¤~f6Éçíð¢UÅ)ÎìÁâÒg—+©ºq û(lœ´©Mp¥0d©ºO1¶‘ŠÉR^ §ï5öTâ~œ£ê(žcâ0zDÏ£Ÿ³£o€9ã¹.åÓ•gBcr¶B+Ö˜6)N‘QÛÁù‰–ÄœØ(Ìû ¢o4“›Á±º^*+ ›ÛÒ-‹€EÀ"`° 1à9lË°F YÛ@"Sçû%¯ƒwë‰àÐ,n‚vä7ûº"DÍÖÆ°pŠ_¨Ñ¥l&JŸf†ŸýdA‡ÁÉÎDâ0mENm·<=,|p‡UùþR!áß“uzÏñ „Ê«$£·Èwvdëç¦Q>¿ìÙ›Võ"hº†Ä7™ÚÞãJ`Ž?T,|ð Yóp]ȶîÿ1Å‹€EÀ"`°X,#u'zÄ^æ½°ÆĶäDÞÀš¼´ð¾|öq¨†SwcÝšá.j¨&ELÕè$Ï ¦ðdZBÇcç~^ä×%Âè"O—ëù1ø=ùÿ…øZ¾^º¢GÎ"9ß›·ô8Û”pahM UŸ/Þ ó>PnZ¥Ÿ¯MföƒßÇÑ Ý6,‹€EÀ"`°XòX$År®¤'ÀÇà)j¨ýaEg2-sº4~?Ú‡]…¯L”ŒELÂû~ZuÕ•”n!¶QÚÜðü>?¨Ñƒ„ööE8ï⇊G S¾Q rHÜP‘ô]ªŸ¨šG…X²M5”®OüÐ̪Qß×(œœ°nRJ£33Œ7w k¹»;xÍÈ“#rÂCBdªZÝúhä@±Ÿ‹€EÀ"`°XÌX,3.ËŽê…ºMü;ñ‡xD¶„ ò&ý ÉÞøÔ}5|_Š¡©0e¾û-Êœ‡¸s½ù8„m5…:œ«9£g ±M5”Ó TgZ¡ž«!A_ógˆÀT¦¸î“‰@*Ž“(PÄã¨o^h£ÆÑ£"cØät…l$k6Eæô€ “í”âî [ѺºÂÌ‘(›a}lç rw¡ï.â½ÑQ›ã{µ¸aòöBwBãñïŠ0b‰‹€EÀ"`°XV,ÔéŠu탵œ‡"v¶ÔQ&O‡Äs·ƒåG ›`çf䉨¯™úSJ7⇡mÎù:šÚÔLž¬™ ºÑšHOpä%µq´ y;þ^ u?‹ˆ:¨HË•³ÉÄ)EÁ)ÞMߌEÿ˜AÍÊMâdø¦¼ ߉û´ÙëkRެѥ„Ö¥W§kŒ ôô|@UUzODlby!föüvðݦO`)‹€EÀ"`°X,}AÀš`õ­R¼©ºãvv>Š?Ã"YŠÕëãÈGãbÏ¢® ÁŽ³n°™¯ : _ÏU¤|‹÷órMísfvòå-3’µm€îkNT'TÆ7&F«Ãò­Âœ-]pfw¯Î÷ä*¬ R‰ëˆµl’•J¬…PÂGS4òØs¬ùO)OÕ’üå;C•¶y8.e}Pä 0»  dKO—>BSÙ¦EÀ"`°X,‹@ÿ°þcçä…s2~94‡g5‡Ã1üD…º2™ÓŒæ9©)PlûTÔ•<¼€“t¸4LªEÈÖ ÃdO»á› é]yŠ{lŽ~‘oæ*Žç÷á/Ä™M•FGÙ7Åàã‘›ŸRlVžx½®TMœ>ï>‘&V³³û:Ñhzáy÷ƒ¥Ø~äd­Ë¼à] —ß0‹jé4'4°Ã”- !ª.ošfâ±4‹€EÀ"`°X,¥Ž€Õ€ âšš±>îñ…ÀD,”ø| Pý*;™‹èsh”>˜[ ]‘z¢ðÿ™Â­ÝÔõ*âŸht! söô²†^ƒë,.°za~ÿÓJù!|Y7PØÁ;Ù ”™jåUI7BÛós\‹[ù pæübú4È2[,‹€EÀ"`° &Å”ƒy”¡6×´š¯Ãá{$\b2ÖH.çÎ…I΋ÐX¼„…mOÙSfMÄØ*„iºct~pHƒ‘ŠDŽóWŒ€’-¬µt6Zp†»äÈþ§QYIåɶ¤“6ÒƒD>Vc‚M‘V ’q½«äÛ³ç~ 'øWpNjÄ)öKIÆ/V0[Â<á’Š³ù—:†y$]fõÚ­]MÈ*þMrƲ9Ö®Fž0ÑËE"N„ŸËá.Û¶X,‹€EÀ"`¬8ÈÔ «Plü¯ñµF±h­ÿõ@¨s3™ø —Ñ‚%—³C_fcÍz©zÃÔPÚaBtA䙼¹‚óFÜEÿièQA«PrrâçàÒ|££·#Ëûø^´Oˆr¥yNSׄq$„¯Q}Ý4«ý) q¼»N‘´„.DH$ÿké€ÙW‘âGÖÚ#óú!¸þmÀÙ¨rËYÐ=M®{/µvÞ×g­‡:™mY,‹€EÀ"`°,g„i3{9ŸÓà>™Ø Ü+0±ž3£øÑfRoú§4«ë…%•@b=¼P5R.„v`¬ÂË&B½ãh¶,äâðœÕiøÚ)íîL­¯yckw„û…¨%MÛRkÛy¢'H›‡c…‰‡!È`Ž…Ã÷¦â0Á‚ãy°Hùgjj?"H‚@t%®ó`…løáœGA  ö}A¹µ´¿®’Ë´8l0khFI‡dçœ>E+3µí¶X,‹€EÀ"`Xþ„±ËÿŒû çCø¸ÓöEøà³h¤XäEbmG®° ˆ5áÓàäÙXˆŸc˲‰«ár›Ú.©×‰ÔÛ½I^øàÝ=oæÇ+NÈŒköŸâþdñêRî`ÌldLÕþD>¸_¸Ù¼z³'àZ‹/jUáCÊ9䦷ï³ðÁ‡â°Áíí³©©£Õ E°·d‹€EÀ"`°X,Ñ-€$ã¿Áêú$ã÷ÃÎÑ––š½º‰ š¹¯-¼ûyð#ŸF¶ø&T{ÑÌö3±àÖ…f Lkn¿ˆfÍëàj¾´}Ò†¹?Ë·sÁ¾!¡â’)Ÿ4t"=©Z˜ÜÐÆÄ4˜2±æE-,,4u=¦Ñ’²Z‘Ÿt‡FyÿžÀs —·R7}š»^Öæ´‹€EÀ"`°X,‘+€p.á\ ÃrÂãîˆÅõZö†Có¾^Ü}°€æ¤}j"I+Uãg~ ³¢Ì±ÒžÅ~L¨¶Àøx}é9oa|FŒ–æ¢qòí@#[º²°÷Ï8‡¹¯ MiLôøilŸ7bMEcÎY¼Zƒ6F"º‡¨5(š:N‡ÿÅàá·356ÖIâÌíS:½&0ý4ó5>K°X,‹€EÀ"`°‘ë’ª»¦Jû„¾å^h*6/º;ßPû#D©z0¿xÏ –ô9´S°Èö£c¥j7¡ÞÞvò³c縉óÞÃXÕäJÊ!àìT`*QK%þ„ñ¿V8XËÒÜMLH¸IÕý BÈmÚ¹æKÙ…>!vC>9‚¶‚†¾”ššÉ4FÖP&:ÎðóéËžš7ï˾Lay-‹€EÀ"`°XV\Ff¬©ÈÈ‹#¢TÈ?ZÊŠ |´t> çë;QÛC¹%M¤úšÍ@ãÈODM¯xŸúo¤ &*}œO‘Ѐ„Ý*¦úÚ5Á æÒ`ÍKªŽé秢tü…0È1K˜q5wì›kVüéçÒе/O`-‹€EÀ"`°XVdF¦ V´f,äu_WwªÎÝnš£eé%â|_'†)ÂdB5 ù.&†9mG¼k¤ ±‘ÞÔö;øhüÚÝtÌ8€‰òKrŠ¸©mŒ3›^k;,‹€EÀ"`°X,C`d ¢X~ÑZ®Ö9/€§Wã“"›;Dë)Xƒa,Õf"ÌÛóÕÿÂ$¯íІF:›:nBD­5!TüÞèÂ<ìË!åëø;hñTjn3 YÌk‹EÀ"`°X,‹€E`)"02M°„¨2bæ¸å¯WÊn˜6!ÏÅÕ9äµmheÒï3t8,€n"H8’ ÚXéâ\ BÄ Lè¾% #éžs)Su¦Í¥ƶ-‹€EÀ"`°XF#wWÝ•7é_ˆB¸‰Õô>Pâ»ÂêhCßcfè:I¸&íK5$ÖÕ™ Înù€±$‹€EÀ"`°X,‘€ÀÈMD8iÒx_Õ Íêú%g#{÷EÔ#nÅbÿKJN†oHd?Oø›:q"ÀÞžõiö\Ö¨”/ÉÄOqÌkàαÞÂ'2¤»oSËŽBÕ]~Ëa°X,‹€EÀ"`¹Œ\„¿³T‚3ßÛoÿ 6½"w$¼¡â[€ö±Å"`°X,‹€EÀ"`й&X|©Míàÿ£ú%HZ‚P¶¿ê“ðÁǴ£`‹EÀ"`°X,‹€EÀˆÀÈÖ€ä.9•ØÕ  QÃÛæúß9;2™ÃÉiîµm‹€EÀ"`°X,‹€E Ÿ¬ƒ3UŒ¦ªøðýØ‚Ȧ ŒR0“’Ãç>A½žfvþGé³ ‹€EÀ"`°X,‹€E`PXq \BŒ¢dm Ige„½ýŠzNêêZd±u‹€EÀ"`°X,‹€E`ðX1ÁÇÑÎh°X,‹€EÀ"`°T€ÀÈvB¯Ëb°X,‹€EÀ"`°,;¬²ì°¶G²X,‹€EÀ"`°¬ðXd…¿,‹€EÀ"`°X,e‡€@–ÖöH‹€EÀ"`°X,+€¬ð·€À"`°X,‹€EÀ"°ì°ȲÃÚÉ"`°X,‹€EÀ"°Â#`þ°X,‹€EÀ"`°X–VYvXÛ#Y,‹€EÀ"`°XVxþKîœ>ÞØ®IEND®B`‚bitstring-bitstring-3.1.7/doc/bitstring_logo_small.png000066400000000000000000000363711365434337700232530ustar00rootroot00000000000000‰PNG  IHDRÈ?¥Ï‡?RiCCPICC ProfilexÕYuXT_·ÞçLÃPCw§H·tIH‡ RC ÝJ)! " ‚ˆ !  &¢ ¨`‚pÆïûîóÝûßýçîç9{ÞYkíµ÷œµÏÚg½Û²[p°?L@@`x¨•¡ïAG^Ü € E.57RX°¶……)ø_Û÷ Äic’»¾þW³ÿYAïáF²@Ôîa¤_Ö!‡†€ZGäÃQáÁF?@0c(²@¿ÜÅÞ¿ñÊ.vÿ…1è_66Vº`X  vs õ€ ˆÈy#IÞˆ‚X†@r ăÖ ù¸yÀV„Øì ÚÅ}uÿ7?Þÿ†ÝÜÜÿñéææýþý[‘ÈÄzä°`·˜__þ/»ÿä~ýj HOèo¶fäZðpÓ3A>9‘k;ØÿẄÝ3ÐÖ‘íâ=îfæ°†W¨‚‘±Ep¸Î.FîänaóGžë£k†`jDžï¦ÿ×O…¯›ñnÌhysh„•-‚Üi­`dGAob}lìÿØ|õðÔû#‡a/²Ño˜n´;#s~¿ “Ý5 sÁŠÀøOB‘>HS  ôþô’À ¸!šHDüÀ[ #‚1Aæýc§ûƒ_㼑qÿÝ#/ !¶ÿÌù{6^dο>ÉÀÁånÈ»ºÝÕ…¹“ÿ5ç_‹]¿V#]/½(½õwMha´,Z­ƒVGk U/šÍ$Ñòhe´6Z­†èT€xƒxöþ»Æ]ÿÍ^‘EA1ªv>ˆv÷·»ÿÕ»_Öä¾ÿÇ yh¹eùï ÷ŒFžtƒ‚cBÉÞ>á¼Úȓ빇×(´w¯¬´ŒÌ®úÿMÛÍY¿ûÅêW.‚˜ÿKЀ2ÙÎÿ’¹Ÿ ]yöëÿ%.@rƒ/‚¤ˆÐÈßþл@…äBFÀ¸Eî³,Pj@ èc`l€pFö²CAˆGA:ȧÀP ÊA¨  ´€pÜ`Œƒ`̃%°¾ƒM‚p"Bl$I@²2¤éC¦ä¹BÞP ÅC)P”Cç¡:è*ÔÝB#Ð3hZ„>C?`L 3Â\°0,+ÃÚ° l†½á8N…sà"¸¾ ß„ïÀð8< /ÁßP…G1£øP’(e”.ÊåˆòB…¢Q™¨T%ê ªu5†šF-£6ÐX4Í‹–Döé~´-š„A'¢³ÑÅèZôMtz =ƒ^AocNŒFc„9ˆñÆDaÒ1˜Ì Ì]Ì8fó‹Å2cE°JØýX¬/6›=‡mÄvcG°sØo8Ž 'SÇ™ãÜpá¸tÜYÜeÜmÜ(n·N§à¡¥0 p¤¤H¦( ¸DÑE1JñŽb“’ŽRˆR•ÒœÒƒ2†ò$e5e;åcÊyÊM*z**u**_ª£TETW¨îR½¤ú‚Çãùñ*xK<_„oÂ?ÀÏà7¨¨Å©u©¨#¨s¨/RwS?£þB „ ZGB8!‡PGè%LÖiˆ4{iŒh€>›þýCúƒ0ƒ>ƒC*CC/ÃE êIÄb5ñ.qžË(ÂhÄè˘ÅØÀ8ĸÂÄÀ$ÏdÇÍTÂÔÉ4ÍŒbf6bög>ÉÜÌ<Áüƒ…‹E›Å“%ƒå Ë(Ë+««'k&k#ë8ë6^6}6?¶\¶¶WìhvqvKö(ö2ö»ìËŒj$ŽLŽfŽçœ0§8§ggç ç7.n.C®`®³\½\ËÜÌÜZܾÜùÜ]Ü‹Ïmž÷¼L¼Ú¼þ¼E¼}¼+|œ|ûù"øÎó ñmò‹ðÛò'ó7ò¿ PðÈèXä< /X/ø\ˆRHYÈG¨Pè¾Ðš°ˆ°½ð1ááV#‘X‘z‘—¢QMÑÑJÑ'bX1e1?±sbÃâ°¸‚¸x‰øc XBQ‚,qNbdfÊžÀ=•{&%©%µ%#%ë%gö2ï5Ý›¼·eïG)A)G©\©ûRÛÒ ÒþÒÕÒ/ddŒe’eÚe>ËŠË’dKdŸÈä ä’äZåVå%ä=åËäŸ*(SèQø©¨¤ªxEqQIPÉU©TiR™QÙB9[ù FEG%I¥CeCUQ5\µYõ“š¤šŸÚ%µ…}"û<÷Uï›SçWwS?¯>­Á«áªQ¡1­É§é¦Y©9«% å¡U£õN[LÛWû²öGiP:kºªº ºÝz(=C½L½!}}[ýbý)~oƒzƒCÃ8Ãîý˜ý&ûs÷Oq‘ŒêŒVŒ•ŒŒûL¨M¬MŠMfMÅMCMÛÀŒœ>ðÒLÈ,ЬŘ™Ÿ6e!bbqËkiaYbùÖJÆ*Þê¾5ÑÚÅú’õw›“6/lEm#l{ìhíœìêìÖìõìóì§JL88àÀî@vhuÄ9Ú9Ö8~;¤èÌ¡y'§t§‰Ã"‡£?tfwöwît¡uqs¹æŠqµw½äºåfîVéöÍÝȽÔ}…¤K*$-yhyä{,zª{æy¾óR÷ÊóZðV÷>í½è£éSà³LÖ%“W}÷û–û®ù™û]ôÛñ·÷o  p h dô ì ⊠–NžQ 9²jZ…k gD^#D#Ò"f"5"K"ף좮EÓGFƈÇdļ‹5ˆ½‡Ž#ÅõÄóÅŸIÐN8Ÿ%º'ö$ $¥&Í1Åã%:%¥œ¥¥kç<Ζi•])ç*Ï*ÿQA®xzÞðüÍJáÊ‚*lUdÕÛj»êû”/ÔÕ°×dÕü¼xqºÖª¶¯N©®î祓õp}Dýâe§Ëà z ­W$¯œodnÌjMMﯺ^h6i|íÊu¡ë¥7ˆ72oB7cn®´ø´L·:´Ž´·õ´«µß¸µ÷ÖžŽ’N¦Î“]T]©];·coëî^¾ã}g®Ç¥çEïÁÞ'}–}CwMî>¸gp¯÷¾öýÛÔtVzÜ:¬2Ü>²o¤kTsôΘÞؽ'FOÆÍÆG&l'žN:MN?õxºðÌÿÙêóÈç›/Ž¼Ä¼Ì|E÷ª`ŠsªòµØëÆiÅéν™ÁYëÙs¤¹¥7ao¶æSßÞ¼ãyW· »Ð±h°8üþÐûù¥à¥ÍåôôJ?Š~¼þIëÓàÊÁ•ùÕÐÕÏÙ_ؾ\ü*ÿµç›Å·©ïß7×2×ÙÖk7”7îÿ°ÿñn3j ·UôSìgû¶ÉöË€`·P·_ï(¤‡½¼ø|yOp@j‡a¨h~׿,rBllí…–às(g´ú=¦[„ ¦°¢Ô§RÄKQï%HÐ(ӚйÒG0œ!¶1Î0S³h³†²5°/qŠqùr7ñ¬óéñŸ˜’>&òJLAü”IJ¤þÞ*©m'Ùvyv…hÅqe9•Õå}†ê?´¬´/èlè™è,ì—7Š3î2…h™Åš7YÌYÑ[«ÛxئÙUØ_;xÛ¡×±ûP›SãáçR—S®Én!îÎ$S%O~/‚ך÷ŒO?¹Ù·Ø/ÙŸ`¨Ä´<RšfÎþ)¢+2'Ê)Z"úGLlq9^9›0–XžäDç¨`2c m*]}:Ý1ÂqÊ tÆNæFÖç쥳9ÏOŽžÈíÉk;}%¿êÌÙ‚œÂ”¢¸³1ÅÉ%E¥7Î —Í–/W¬œ_©\©úTýñ‡š¥‹ µoêf.ÍÕ¯6Ð_ÑmLlj¹úºyý:îñ&O‹x«B›f»Ñ-ë÷Î订ÛwºzнÄ>ö»¼÷Äï+=Ðy¨Ó/Úÿi smðü#ÍGËC C‡UF ‘G£ec!OôÇÙÆ?NôN>õy¦ølçy÷‹Ø—r/—_5L…½Þ7)õš“™Û|so>ÿ­ç;Õ†…÷‹]ï³—ì—ù–?\ýûIg¿2¾Úð¹ìËõ¯kß½ÖžohýÈßœþ)·¿³ó+þPì€b@=@§cL°LØW¸kÙ”þT¶x=j9‚­(½ƒÑŽ1)•¹Š¥u‰žCƒ“ÌUÌ=ȳçÌ.pEð½°„ˆh­Ø’„äžPÉ{7¤5eŽÊÞ—Ç+˜*æ(¨U-Ôröõk`55µ"µku^èáõU Ü 3ö× /šÂXÌDÌå,T-U­ä¬mhl¾Ù>·ë¶¯>˜éèh}HɉÃiçð¬sŸKkº›‡»‰“´æ1âYï•æíì£D¦#/øÞö+ô Ðdüt;8'Ä1”?t1¬)<*B5âgdWTR´V :æAì‰8‹xbüxBaâ!$³®é=Zžœ’˜ê˜f˜.Œï8õñµŒÙÌÁ¬›Ù'Žç„ž<|Ê4W3OáôÞ|Ñ3üœ…,Eôg©ŠÑÅ[%_K—ÎM—M–T Ÿ¯|]µT½^ƒºHSËV'xIº~ßeƒó+žM‘W³›k¯õ]Ÿº±ÚµÒµñµËÝ2è8ÔÜ•~»¤»îNCOu奄ð»6÷dïÓß_}ðÉMåiƒ~,‡”ó ã‡×GæF5?)O˜ Mš<•Æõó|ùÅ“—·^UMx?<ã70þ&a>ýmî»’… ‹MïÛ—z—}xñq}Eeµú‹Î7ü÷¯ë ?F·*·þÄŸ:‹Â¨4z“ŒÕÀ®ã:)ŽQ:PÉáið Ô ×hÊhOÐ¥ÐÇ2Dcc˜˜ÓYN²žckdïãxÊù‘›À#È«ÃçÊŸ"P%xWhQ„FTFÌVdÞÉÊÏö:¡”C•3}²õT^nhžõi…|¶üí3o ú ‹NŸ,v(Q-eGNËñ²å%'ΧW¦V¥U»p¬&íbBm@ÝÁKúõj—ÕL®¸5Æ7]½ÞüèÚüõÍ›ô-­ûÚ,Û½o%vœé¼ÔÕqû~wÿ‡=w{ïôuÞm½wí~ËËûÏä f?JJyœ6œ;R;úpluœkÂh2òi峡ç/_YO|==Cžc}óíf1q¹wõôºànüsK»gV€„÷°;€%¢©µ@(¡8Ú° `£`¿4Ó/¨TôŸóh@‰p(lH½)ÔfãÂ%$‚n”‚žÂ’â4Å8%¥ e åG*eªªa<7>ßMÍHíK}‡ÀAˆ"ŒÓ(Òœ¥Ù¡õ¦¥Ó¦»F/N_à ÂÐHT#2º0~e:Á,Î<ÀÌÊÂÚËÂÎÏ>Áq‚s?–ëw&%/'ï¾>þ*,ÁX¡aQg1WqO‰€=1’{ˤڥ'eÞË~”{#ÿD¡Wñ¦ÒåK*uª—Ôšöµª÷iŒiÎkmèÐêŠéè{d^ÝÿÂg"kj Ô,Åü¤E™e‹Õ J[ »(ä¼ûì((ÚéŽ3ÁÅɵÎm™Äå¡éiïà}ܧ™üÁOÉ?#àubð©ÈùÖÉÝËç_›°“äsd&Ù-åušCúøq‡Œ­¬…œœÜsùìÆEÁÅE¥­eC3•ß/Ð\«3©nhoân®¼!ÑRÖ¶ÓáÔuëooæÝ>ýcägÌ=901ôÌõÅÆTáŒòÜë·© ›KüËÛ«WWË¿°}­ü®±ön£hSgkj;ôWþ€Îˆ€ ˆ%„ï±d„UÈA˜Ÿ *„#Ð\ D¨ ꂦ‘Ø ÃÆp0\wÁoQt(U”'*uõ͉>€TèWÑo0l3L¦©¾¥±þHÜßâ„p^¸ZÜ…EE'%–Ò‚òå{*Uª,ª×xy|þ µ&õ9êŸWÂ]IšBZ m$í‰nšÞþ=C ‘–x‰Ñq)‹Y†ù9K:«<ë[¶v:ŽQÎ".wn)À3ÎÛÀ—Áï-`,(#Ä!L!¼)òUô«Ø–a€¤Æ^W© é6™÷rœò YŠƒÊô*öªgÕÆÔ! aM-/íã: ºãú°¬¡×þsF“&̦v ÌÆ,h, ­’¬ÛmÖìí£v:bY8•þìbìZíö“d‰ä©÷Þr> ä?.ÿ€{A\Á‘!caòá…[Q.Ñ]±¬qñ÷’2¬'û¦¼J³Hï=®”ÑÅŸ]œÃr²Â!ݳ`â‚öA‡‘ØŸ‡î!o™ °*L‚OÀ­ð<ŠˆÒF˜›*Ôša#ЗÑóÌ!Lfa\ì±ÅØ)œÎw ·MaLQD±€0&'(ç˜çS­àÍñMÔDêêY‚¡“Fšæ-m)7]5Â[ô1¸a$ÞöL8¦[Ìá,Ò,+¬×ÙØ8X9–9û¸*¸“xH¼¦|*üâ|‚+)||ÕN)=ô8”¤vàÃÁ³ózrÊ*ÖÎÍ…½—j-~Í÷°A$ŠKîÔnN¹O…ısdrî~Þß[–Ì}ˆî¼Bµ]ºfW[F߇(K> ^ÉE¥üŠ%åuŽáëÁÖÏÁQf’rû(Û Ûo¬…°Åj_u9Ä—.'v¸Ø!D]#åE;ÜhõµAR¤…5¸¯(Ëå·íì*–tã@k`äR¥äžtw/YU“P£ª'þh©Ý—rvTÔÆîº}Æ^#¢Æœ$·¿‘©Ù»Uu"ãºD5O__9jö !k„egDšK‰OTûÌÖ ÜÎ’Þ!D|Ò¾Y HL“Rx>xe)Í,¡$’š?‡ýd¢:ÁÚÖK”¼Ã½DËFÅ2D`¬‚<{€¨©"Tl0 C„´W¨¦é€yIú}#NØ#ésbŽ©Lú$µlæ_<€\DŽžs€eYIYsã\,¶(`aUeYâ×N;c–öñþ8ÍP¡‚LÌÓåO¥àj[KÌŒzQµN¡Xa9|^µˆËñxËF¢âP¶šEÛ«oíH«ö;ƒ(uË+5ïCŒ×=Ü´„µ—sçE¦¤” –¸sSn[Â8K@j@ð¨SVdŒYvúiôûHíÑ¢Õƒ…”ƒ­51†g·‘>Û—çO$ øý,â˜ío>–ÉyG}¹‰LÖùÄ ¤:4 ܤmf¿ÅL÷·ïMžF_²S¥Âc™¸qOKF¾¥„*¤ýÜ%\ž $6‡I-¾B… plÙÖÐÕHŽ5 ]­¤üC!¤‘c«MÂ2ÈMÉñVrÞ…VÄ:Á€r¢HV›™ýY~ïÖúG ˜#X@§-‘ïO±ç…y»˜Y¼ŠcErô¥Ü‡šù=Åéûî êãrÔ÷÷WË~´©'øbÏ¥ünLŒn8 ‰uóÆt,c[kU¤t´Æ)θ1>bƒê̪Úf¾¡3=‘u׶¢ñP¿dÅû5pÿ€çc’Ûᇙâß©F_½ 0Õ‡–Ë!GÍ*`ˆ}ˆˆWêÁG “ï3TÍ0KÆkn†‡eó b4É©D•–zy½^ÉVÆQÛ«aª5Ô¹&žéƒ!Þ‡XO0DzýµêÊõî³ÐwËò©@ðÊOƒó36Ê )íÛT§}{É·*QÅ2À âËf{`ÒO«'‘S ™ß{½°¬aVD‚“ælÆi¸Ûwâã”5âBÒsܼ0w=Á[±ŠïÉĘÓÀ¡¥;ÃN­Å_‡Xm öWÂöÒcÑÞ±N%b'TC8Ãn¤j±Üð#G2¨XY5Öi%„r +×Ã,eá‘ Éî Pƒ¯àdK|ž ý‹¤æÝÀL<3í$Á·šÈ2p®Õg¬qlÀÎ0ZÀëožö80úr‚žÑ¬äXAÕ2íu÷yïîË@1. ç‹–°ÕvJˆÚ%Iœ+»:ÄhÔÀXÑ õ“ÁmbÙOtÑ–ßãA»YDk2ž{»Å¥%õx…b­V[võ2Þïû”©èÜ* ïQåÙ>ƒhÕóÐG{%"ÖaÄxé("“×` &eïŽw¦AZŠA5†DÊs‰’ËBdh÷‚Ì\†LÍ?‡ò>æà=ÿQÙòV\ ¿Cò¬ìªlWù "µRó?£)Y&Â7ÛvU®‡ü;‹v.R¶}­j™ñte +¦s¬J´A@¸«©ºKeÔ5jÙt­‘tÔ²+×ÊÔܘ÷Oº€0Û2qîªeÖ'n^±;0õÒªy„Öïm6_Ã2­ä=iÛ¨«Væ=Ô÷Ub³½ÁÁTÈXd‰+iœ¼… ’Cô, òIJÕáän B£õ^1fŸ"AÅ¿ƒ;ñ¾]pZÈŸ•ÉÄr,”¥’8^ôCdSz­@Šjf­½X˜•Ì'ÂÇleÃhù€%4ÓÙ£”ÏêK̯KG]‰×K”A#§/1e‹Y¶¿¼mû»C.+=õ* ¦z©y(ÏyÁœ½¡+µayžÙ`ŸÂyò„™×cÜ®¨ôÁȼKç0Ôž5 lo;„9àÏfý"íRŠøàœ„ZêÏ‹$ýé°©Ì3ØÌÙ€Ê9NF«—Èäüˆ›³ RÂ]úÄîë†E-AŒ XîKÐ^,3H+c&»û÷–1PEgþîp°Øgˆ¥†\Q&ÓïA ñUïì§f:TÜÎTùà*–0€Ôî8*Ê‹|Œåb³§¶MpÉM£æîì÷5g¢LÝ”ò$ÿ 䫽ç½~Ó%Å8_º››ãü "e²ð.áR\ Üf õ%°M~#s? ¿—q¥Ìça㶰ý RdÃbX\œX§Òðþ”„) ø&WPx‰F‚Ò¾tkhÌï&f©h/F_Ÿ‚Ge‹ôÝšØ4ž°¯Ó›&×/AÒH(mÊÊöŠˆuq»¹õb™à%íâÓwÒ Ôp Ñkð²ýÕß;ÅuŽ \ƒaB@‚ F†)Õ%ŒV±ò]¦ávßÄÒÈ@¨ÏÆ ôž4Æ ¶Ð‰Ce4 ¦uÁ *VÀÜÒ«-)QaJ+ˆ]ùĤE¯>T4ƒx…¸[°Üî`ྠ¿LâÊ»@=¨l„gˆHqûƒ®Â‹ùA$9ïn9ì:Ÿ:Pğ̤ÿbf°ë3´v‡1ØêM\¥ÄõcÕ²ákØ#—áMó š‹f9˜µ˜ÿ”•¢I&æëmyêp î~aCypÖ-(ÑmFБxdú |;4:½=ß ì'3“¡âJúWýGÅËÙyg€ »ôt/ŸËU¶_‚vD¡(ƒˆôfƒð%E¡øJž*«âo¢šªpÛ–¥ˆËlxYžnGÂuzesÛß½t‰½™£ï:•îH: pJ¼U “Ân£$æÞïl+äæé¦|¡6ˆíwÃòBûÆ l·õ7M4aƒÞÒï ½`ág”þâ R°GLUúª›P>{‡R!$ˆj¿lDÚhÖÁ,šázôg¶­Î±3é£ùÞl¢Q{Û™Ì\ÇADW0kÿÑ,§ãÐP˜åwÚ-|LçÖ-ŒM†2ÉŽÎPwÊ*ÕêáTªvk|º«¿NÔ«ÓvóÔ½l[ì‰s5ýÌד«>žh%Æô`(Úz¡Ð 0ôn^¢7‘ˆŸ²åûÆ A#£)l³°ÑüDdöVLúÄ#@S]Ù1=‚2Õ+û—ý)Fu:ê“ þÙ€„¨Ÿ'Ùàf±]øT¶Z,pÓ]Ü#ÿ‡¨û£lÜÄõ÷.Äà ‡õÿ¾zÏ›_쎞¢Õ¬ô3pH1Žèš€qÚM–JŽH‘¿hÔCªeªfÞ+yW«Ñ“NÅ—rõ w‹¡žÅGA7³½¡¨´áã©À —I·l¯î™öì@ _Ÿ‚†15ENê  b•~u2š Ñ…j{m©JLZ}8νRÕ¨émQ¨z\ %kÌ6ãè1µ—€KÏ-ÄK3ˆÝ{‰"ÑëìR=Œ„ט R©¹ÊÌ+gÊú«/Ÿo|én¼Í ù`GwÏ'¶^LJ?¥6uL€‚Þw1k†2ê[ÀtŸ9÷æ!}6y{”d£hÑÛ&z,Õ{/“h@–Î –´ü8 ºÈö-ûY®zÚì©ŒÈ Ít¨¸å7Ò!|Ÿî» >&wY,Meš§_ŽJv«ùœ ‚gË×ûÁÐq[ùý~¯ HWi¾ YxæIÁ@þVIª~ðK&7šÈ0¼Çši3®Ç…½ž4Ô eõ‹Ÿc”×Äú&A¤¹Iиǔ’þ÷ªÒ¥ζê«Gv­¦Á?7a™€¿‰ûýͼãJN›Ì2]2ˆjþÁ ^e^5Qrïbë!&²bq{³˜M¬tŸ1ÃWðµâÉnºøÝÏ ¹ÓNŠƒsmécf¤mÊ NõJµšA7»0Ô£æSeÉKõz’™:nE}nXT¼ W&4*°oë(~ân]òYi•c"H¡L—LÆaOA£¾‰œ ççËÃ~‘v8Kãç»Õ…n=Žê©.ù%êõÜ'EØ)ë[uëpïú#-:ž©¿õ”íc$_h鲆B0iíkfòÝæ{fº noü…Ù?=iȨõ4ûànr_ålßÄ¥¿×W!3tÑèâFªô¨­âB¾¶žù“q#&×õêt JýÍ_‰?Å^ʳ¨ËƒA D’,dÝîÛ~È.R*À "N‚htÙÏ"óˆ9 dqJÛé‡óXœØ¤@ºH’ïÒÝ äh¹Û?§»Ï‚÷Mâ=ˆÏ$šƒœÓE‚p[)Í'¹ L³\tHK[tfpÓÅîÚIAÏ7ŸÁ$zïbNsù“LÖläêV\›XŒ\-5"Qµ ïŃ ¡WÞ³ÞD‚Äbé6DÐÚÄ™g.%<¢ QÜñK¡ÎÎnñè…hFüD^¸·å†vôg}á>ÆîY™˜s¤‰¼ .½osÜGáDlé\è–Òw1ÙL‡Ž·mfkºòŒF|3åðîÊó¶ûÜ‘^ÕáŽÊmx4Ërz…ø×Öºëõf©3†ä…xº7³×/TûŒî%Àm|/.L=ûm¶‰¾ëÏEGÑï$ø;ýW]¨s2Ð/©o$¸ŽÜ›l¬›ŽTs£Ù»ì–°ý°FJåw€fÒªýJŸÊc@zQBϨ´ý&ÆÕ^&ÆîËŠ<ÃDÓÈ‚õ\&³ÐÙ0Œÿ3Í7ò¾úŠ‹í\ m€Â…ïPÑ8'K‰}ôLÑ“›ÖW! ½>žV¢Y<À¶µ¿Û³Mt–˜·ÞöÉvl žÿÁ„é*Î#0<{ºÏY®¼†\ÜÝl.¬ywýv­¯•é"ÁÇÕÛçÇC¼ebìÜ}_Ïñ‚^Vë/1qt‡Inç¥-¤}3±¦À¾—([|M!"PeÔC¼£Nº·sS \IIv¼€¦À‰ŠzW0OÙ|k.&<•W‘Õgµlv 'Ž˜ šÉØC¸ˆ3öå8¦[y/_7«d\롇iVDNx…‘Î1‘´ó)>G¿ú.­ð ¢+¡²…ÜÂÖ3™ÊÚ!A•IƒöüþeˆÍ?óKg8ñÂø,øSÜLÛ™-·ÊhÅTšë¸<¹÷g@^↹vgç½¢ýzC¦S¿sFRUÅaG>ã@oqÔ9°!9vfo·óHD©_ªÎ „™ñ̶æêd›ÊIçªä{óuGÓ°ºž]°ÛĈ¯Ù&Ú.…àf†Õºù•V,~¥JÎÓ'9~ÆV2cÕhÛ²§s›§ã:°ô®ÿË¡l¾ù ±d#~Ǧ¿d>+5ž3hÿL9} L~;pÐÛrhÞŠÜÕ»–F6®±EÕúJ‹|já#Ö°HUëÔÅÀ.ÖëKª2ö5ì:}.Ö!L”£{ÄÑ]oÂô<5n‘‹L­UàK&‚0q}8µM¹°Ôòž—ÖD8$4ƒèz Ø›#©¹ƒø‚ôr-ùܺõÛ1°|¹c…'Ê÷\«Šš!d31ŽÓa§AÚ~LµÍТº¶ÂðaRRܹP9(´‰@ä¹K8Ë‘ê=x¯ u- ÌM"n£mƒ…þ©húèMÑPû+ðÝ.RC÷¦Î}Y8V4¯x†Ã·þ ¦êG{Ÿ Íä#Dí ”?žö¶?Æ‘:5ñ7Á½™ô `þÆ>^ôÝÞ¿qòí®Ô=K,mÿ ÏXí:FDcãEºóm±lÕNÞvøѯä‚<{à˜ÉNúùé¹›F±~°â~ßéXY7§ÎMïúÃ{fæÞN¯a°qÏS­Ó ÄX°¼—ŽèÞÕ]Ø3XÕ?V¥·xR̃ٞ”U`”We}í—yÙ‹D}]#ׯ˜Íw‰]vÅùö:Ds ³¯ÍLû Lq1×MÈh‡„gÕç¤ÅÆãQgP$+Ï‚ìæ“ÖDÿ)õì*–¶]1]AüòÌ!X)׿¿H«åÙöÈ}ÀÍ Á+NlúäS±r%ç#[Ø7©wÈß,¢Ñ“‘C!Þã¸þ,äFÍ ØX‘ãÈ×êÆ׸Eçæ6–V¯ãc¢e«–цÛÉÐ^ÁODÛš6Ô·ˆ¯¢«D{ûj‘Y¿'éßrqv1m²œ­FŠÆ6­^HþMH¢ZÆî|‹½ÃÍ`Þë¤çð,FŒØM$Fh<[=húäk×ÿ¢eC\äh6/àýzÍM»÷ph¬ùEtv¬[-E˜müAŽžwœLVßH‰=Ü'Ža/ÅTŒà;ܼ0wÕ4«¸ÓÂÀnU˜†A…Ýïtú‹N®^KWÜ+† ©Aåø%Dr¼Hÿ23k«ˆÇ Ñ]Ìóô÷>!ªo‘ jŒð馽}½¾b”g";ím!‚Õ´u8ªÒ‡ÌÈDß¿^«ÏÑÖ¾ÆéKC> ~7'îü0û*¥gälÐßNK5P´.ÿpÞB¿Az`ðe]F«?^XEl̲ŠöŸ ±ÎEªLîUðŸ"Z>ý„ò'óògqÿ«è´¿-–ým-ùSÁ;G4Ô]àôÉæ”Kmóè a^%›xöG·U÷MdqÖéÿMÑÌãÚøËúm{—õ- ƨ cG½m—P×שëQ˜âN±®Gí;š2b·ÝFˆÕ«7ˆÄ°Éäï*±»úœcJÕwÀ·»h”ÖlÒ‚>†Ð ‚=°ˆCºþÕEÁ}AÜa¬û¬êd¦Šs±U|\s| wžÉÇV»ewˆû¨¡»3B¤„†Ú£ ½(xPË[„É!ÇÌŽ6.nÁ?<¥œ¶*Â<ø·"ãùæCK’¸Xßñc±jÕzÔ¦ ØoPægiªà,tõƒ70³n$­ "µ0ÝMì+Ä"}Øš¢&Š´üºq‚CPÆ÷ضýïÌ2÷1Î…óP™*„¥í3#ÏÑ~»‰æv$…qÐÒö£½2Mí×—?h©$Äch”²iï¡Vƒêêî™z‘Þô¡CøîÃŒ}›·%”|>è¾¹a4Ý–Æü{©ö3Æõ|òZÄúÌÛ¢¤˜¬fbÛë˜t³*Ðunf|ßb¬Î†9¶ }Cµcqoðà]Ûú °.‹:ô5Vó Ñ $Ü(ìVl,5ݳŸYNÇy˜¼OC³éR*u‰›Öß©³Ò#8 ä>Rêÿž(¨ô÷ðåÕ}]].‚ºx–v1&G~‹8€Y°QØËïM‰©‘¸Aõ.õ83×mîá hed6‘¿Â߇g÷ •žÈ_q=Íà6°¤þºS‰tV]›yiÀ¬×£™Ëo"ÝÀL½„q&xoýã?§ìBѱå<àXiÞ4 VIDAT7a×sjäÓ5ïÄŠ•;eõOSûÕ^<;[ÿÎKÿŠd=uN—²Ò3ßo·ŸK—_ÀöïáPÆmH¯ÓRB'HñEâ:ñƵCÍ;€ô«NÚÿ3f¸SÈ^ù›ÎÒ¹î¯Íýð:‡F/6·™ÏÝxhÑM‹¹¥ÜÂæ WrèÛ¾…¸Ý•o›Ï¶z\p•ÖµÌâ·B¨‚ðïaÖ˜D=»ü7T¤£!ÞèÛÇq²ûµÏ3óãeá%íöóÔ×> üX6ë)k¨ûÀI·.ØÇyi2Ãif9ܧpÏ›¯ØôÏ:4µÏçtL´lXl÷â$uWÑ»ö¶TEç3 L†ê´±9“AkÀÃC¢†2{ Q?ìrfÿo3[ë…³‡H¶ˆXwa ^ƒŽG²ž 圞ÍÂÕ±Ñ}å!^½J !ùCz%û‰á‡£B!¦Ó§z‹a8«Ç{Å€·Iä™#ÿ¤ëË4µ/ðŠk©’ª…A:µgÏÚ>Z­’‰eÐm&Á ã=bï±,år‰¶²ÞéÌ+a>Cð#ÏŸ‹Ìï"Íþ#š`”…ôÜV³-œE¤Øut{F±‰PÌF×| ¯Êât:},¶ m5Éð=c *Õ8m3‹[òêœFë¿AÓ‹[rË{8†€ÕªöDÊþ#¸¯ÈÍîÚ›r/¶Çb¯£KÛ®õâY¢ÞK—#Ÿÿ¸’>Ð}ÀYÚ!°MBh#}«Ô®Ò‹DB—w‚ŸÛýdwCÀ Ú3±³N…¨ÏÅXÌRò/ÄÏþ3ÜãE4òù‡³N°ØQ¡¤dÁ©mªÐÀ^ > aþÿ[©ëÑ g‰úáÇàYÂÿžùƒXÊBX9”G „(IÅ …·~Ø0±·¦v}f½¿¦Ü‡H„ p—^Eü ®Ó‘ _b¦¿‰™>v$„}[-^í¸”ý?¡M$‚–'²øvŸ°ª¿J™Mb£µ$þt}nl]Ý`ÖfŠÔð‡Y]ÆÈ–ßÇ“”…ÉJì‰r(@ïF ÷d”¬ä»¯°‡h¶ß;zzªn Ño™Á;ÅF¶6TG_¨µûm DÛû@/N-Yô^# ¯Z½Ò;¦I1D¤7Åÿ‘ÌݨR{ñ‡‹1üá÷Á$ãù ó=o¿n4Êf=K½ë{¹TyzÞ1Hj(›ëâ/1ƒ¯¥íLÛãÛ@‰f¿Äìfë>D7´wa]á9ÑÙ¹;ÛfÓxv§ŽÅ†~“™}I-"LûBô+±/.e“Û^ëƒ XÞƒr¤<Ûvz§bÉèù0G =ÿ š'±ÞÃà=›ô~l>K°uúgs\ÓŠEŽ „3 oÒ¾¢có,QÑïQT(½âŠq-/-mÏæº8}NUÞŠs.Ó¹™«»f~9^m<½d‡/ð.¡ eW=W!Ap³iï‘lb‘ 7.S}Nj[ÛŒèGÝällb1jà ÑöÙ:ൡžîvŒ|N9VÏuz§bé]–ëU˜a!,Â5u"»Jw6Îéî¤êNVúuѸò/ŸkïÊ•—G #Ð;Ñ•&GŽc!í[0ǾÍþµ³·¦)/ÀŽ6½g­'åö”G`Œ€¶#Ê¡<åèbþ¡*âøÿ3IEND®B`‚bitstring-bitstring-3.1.7/doc/conf.py000066400000000000000000000162061365434337700176220ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # bitstring documentation build configuration file, created by # sphinx-quickstart on Mon Dec 7 14:17:11 2009. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.append(os.path.abspath('../')) # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc']#, 'sphinxjp.themecore'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # General information about the project. project = u'bitstring' copyright = u'2020, Scott Griffiths' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '3.1' # The full version, including alpha/beta/rc tags. release = '3.1.7' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. language = 'en' # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. #unused_docs = [] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = ['_build'] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :meth: etc. cross-reference text. add_function_parentheses = False # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'bizstyle' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. main_colour = "#ffbbbb" html_theme_options = { # "rightsidebar": "true", } # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". html_title = "bitstring documentation" # A shorter title for the navigation bar. Default is the same as html_title. html_short_title = 'bitstring' # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = 'bitstring_logo_small.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_use_modindex = False # If false, no index is generated. html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'bitstringdoc' html_show_sphinx = False html_show_copyright = False # Epub stuff epub_author = 'Scott Griffiths' epub_publisher = 'Broken Symmetry Publishing' # -- Options for LaTeX output -------------------------------------------------- # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'bitstring.tex', u'bitstring Documentation', u'Scott Griffiths', 'manual', 'True'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. latex_logo = "bitstring_logo.png" # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. latex_use_parts = True latex_toplevel_sectioning = 'part' # Additional stuff for the LaTeX preamble. latex_preamble = """ """ titlepage = """ \\begin{titlepage} \\begin{center} \\vspace*{2cm} \\includegraphics[width=0.60\\textwidth]{bitstring_logo.png} \\emph{A Python module to help you manage your bits}\\\\[3cm] {\\large by Scott Griffiths }\\\\[3cm] {version %s}\\\\[0.5cm] {\\today}\\\\[1.5cm] \\vfill \\includegraphics[width=0.3\\textwidth]{python-logo.png} {github.com/scott-griffiths/bitstring} \\end{center} \\end{titlepage} \\cleardoublepage """ % release latex_elements = {'preamble': '\setcounter{tocdepth}{2}\definecolor{VerbatimBorderColor}{rgb}{1,1,1}', 'fncychap': '\\usepackage[Sonny]{fncychap}', 'maketitle': titlepage, 'papersize': 'a4paper', 'pointsize': '10pt', } # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. latex_use_modindex = False latex_use_index = True bitstring-bitstring-3.1.7/doc/constbitarray.rst000066400000000000000000000520021365434337700217330ustar00rootroot00000000000000.. currentmodule:: bitstring The Bits class ----------------------- .. class:: Bits([auto, length, offset, **kwargs]) Creates a new bitstring. You must specify either no initialiser, just an ``auto`` value, or one of the keyword arguments ``bytes``, ``bin``, ``hex``, ``oct``, ``uint``, ``int``, ``uintbe``, ``intbe``, ``uintle``, ``intle``, ``uintne``, ``intne``, ``se``, ``ue``, ``sie``, ``uie``, ``float``, ``floatbe``, ``floatle``, ``floatne``, ``bool`` or ``filename``. If no initialiser is given then a zeroed bitstring of ``length`` bits is created. The initialiser for the :class:`Bits` class is precisely the same as for :class:`BitArray`, :class:`BitStream` and :class:`ConstBitStream`. ``offset`` is available when using the ``bytes`` or ``filename`` initialisers. It gives a number of bits to ignore at the start of the bitstring. Specifying ``length`` is mandatory when using the various integer initialisers. It must be large enough that a bitstring can contain the integer in ``length`` bits. It must also be specified for the float initialisers (the only valid values are 32 and 64). It is optional for the ``bytes`` and ``filename`` initialisers and can be used to truncate data from the end of the input value. :: >>> s1 = Bits(hex='0x934') >>> s2 = Bits(oct='0o4464') >>> s3 = Bits(bin='0b001000110100') >>> s4 = Bits(int=-1740, length=12) >>> s5 = Bits(uint=2356, length=12) >>> s6 = Bits(bytes=b'\x93@', length=12) >>> s1 == s2 == s3 == s4 == s5 == s6 True For information on the use of ``auto`` see :ref:`auto_init`. :: >>> s = Bits('uint:12=32, 0b110') >>> t = Bits('0o755, ue:12, int:3=-1') .. method:: all(value[, pos]) Returns ``True`` if all of the specified bits are all set to *value*, otherwise returns ``False``. If *value* is ``True`` then ``1`` bits are checked for, otherwise ``0`` bits are checked for. *pos* should be an iterable of bit positions. Negative numbers are treated in the same way as slice indices and it will raise an :exc:`IndexError` if ``pos < -s.len`` or ``pos > s.len``. It defaults to the whole bitstring. >>> s = Bits('int:15=-1') >>> s.all(True, [3, 4, 12, 13]) True >>> s.all(1) True .. method:: any(value[, pos]) Returns ``True`` if any of the specified bits are set to *value*, otherwise returns ``False``. If *value* is ``True`` then ``1`` bits are checked for, otherwise ``0`` bits are checked for. *pos* should be an iterable of bit positions. Negative numbers are treated in the same way as slice indices and it will raise an :exc:`IndexError` if ``pos < -s.len`` or ``pos > s.len``. It defaults to the whole bitstring. >>> s = Bits('0b11011100') >>> s.any(False, range(6)) True >>> s.any(1) True .. method:: count(value) Returns the number of bits set to *value*. *value* can be ``True`` or ``False`` or anything that can be cast to a bool, so you could equally use ``1`` or ``0``. >>> s = BitString(1000000) >>> s.set(1, [4, 44, 444444]) >>> s.count(1) 3 >>> s.count(False) 999997 .. method:: cut(bits[, start, end, count]) Returns a generator for slices of the bitstring of length *bits*. At most *count* items are returned and the range is given by the slice *[start:end]*, which defaults to the whole bitstring. :: >>> s = BitString('0x1234') >>> for nibble in s.cut(4): ... s.prepend(nibble) >>> print(s) 0x43211234 .. method:: endswith(bs[, start, end]) Returns ``True`` if the bitstring ends with the sub-string *bs*, otherwise returns ``False``. A slice can be given using the *start* and *end* bit positions and defaults to the whole bitstring. :: >>> s = Bits('0x35e22') >>> s.endswith('0b10, 0x22') True >>> s.endswith('0x22', start=13) False .. method:: find(bs[, start, end, bytealigned]) Searches for *bs* in the current bitstring and sets :attr:`pos` to the start of *bs* and returns it in a tuple if found, otherwise it returns an empty tuple. The reason for returning the bit position in a tuple is so that it evaluates as True even if the bit position is zero. This allows constructs such as ``if s.find('0xb3'):`` to work as expected. If *bytealigned* is ``True`` then it will look for *bs* only at byte aligned positions (which is generally much faster than searching for it in every possible bit position). *start* and *end* give the search range and default to the whole bitstring. :: >>> s = Bits('0x0023122') >>> s.find('0b000100', bytealigned=True) (16,) .. method:: findall(bs[, start, end, count, bytealigned]) Searches for all occurrences of *bs* (even overlapping ones) and returns a generator of their bit positions. If *bytealigned* is ``True`` then *bs* will only be looked for at byte aligned positions. *start* and *end* optionally define a search range and default to the whole bitstring. The *count* parameter limits the number of items that will be found - the default is to find all occurrences. :: >>> s = Bits('0xab220101')*5 >>> list(s.findall('0x22', bytealigned=True)) [8, 40, 72, 104, 136] .. method:: join(sequence) Returns the concatenation of the bitstrings in the iterable *sequence* joined with ``self`` as a separator. :: >>> s = Bits().join(['0x0001ee', 'uint:24=13', '0b0111']) >>> print(s) 0x0001ee00000d7 >>> s = Bits('0b1').join(['0b0']*5) >>> print(s.bin) 010101010 .. method:: rfind(bs[, start, end, bytealigned]) Searches backwards for *bs* in the current bitstring and sets :attr:`pos` to the start of *bs* and returns it in a tuple if found, otherwise it returns an empty tuple. The reason for returning the bit position in a tuple is so that it evaluates as True even if the bit position is zero. This allows constructs such as ``if s.rfind('0xb3'):`` to work as expected. If *bytealigned* is ``True`` then it will look for *bs* only at byte aligned positions. *start* and *end* give the search range and default to ``0`` and :attr:`len` respectively. Note that as it's a reverse search it will start at *end* and finish at *start*. :: >>> s = Bits('0o031544') >>> s.rfind('0b100') (15,) >>> s.rfind('0b100', end=17) (12,) .. method:: split(delimiter[, start, end, count, bytealigned]) Splits the bitstring into sections that start with *delimiter*. Returns a generator for bitstring objects. The first item generated is always the bits before the first occurrence of delimiter (even if empty). A slice can be optionally specified with *start* and *end*, while *count* specifies the maximum number of items generated. If *bytealigned* is ``True`` then the delimiter will only be found if it starts at a byte aligned position. :: >>> s = Bits('0x42423') >>> [bs.bin for bs in s.split('0x4')] ['', '01000', '01001000', '0100011'] .. method:: startswith(bs[, start, end]) Returns ``True`` if the bitstring starts with the sub-string *bs*, otherwise returns ``False``. A slice can be given using the *start* and *end* bit positions and defaults to the whole bitstring. .. method:: tobytes() Returns the bitstring as a ``bytes`` object (equivalent to a ``str`` in Python 2.7). The returned value will be padded at the end with between zero and seven ``0`` bits to make it byte aligned. This method can also be used to output your bitstring to a file - just open a file in binary write mode and write the function's output. :: >>> s = Bits(bytes=b'hello') >>> s += '0b01' >>> s.tobytes() b'hello@' .. method:: tofile(f) Writes the bitstring to the file object *f*, which should have been opened in binary write mode. The data written will be padded at the end with between zero and seven ``0`` bits to make it byte aligned. :: >>> f = open('newfile', 'wb') >>> Bits('0x1234').tofile(f) .. method:: unpack(fmt, **kwargs) Interprets the whole bitstring according to the *fmt* string or iterable and returns a list of bitstring objects. A dictionary or keyword arguments can also be provided. These will replace length identifiers in the format string. *fmt* is an iterable or a string with comma separated tokens that describe how to interpret the next bits in the bitstring. See the entry for :meth:`read` for details. :: >>> s = Bits('int:4=-1, 0b1110') >>> i, b = s.unpack('int:4, bin') If a token doesn't supply a length (as with ``bin`` above) then it will try to consume the rest of the bitstring. Only one such token is allowed. .. attribute:: bin Property for the representation of the bitstring as a binary string. .. attribute:: bool Property for representing the bitstring as a boolean (``True`` or ``False``). If the bitstring is not a single bit then the getter will raise an :exc:`InterpretError`. .. attribute:: bytes Property representing the underlying byte data that contains the bitstring. When used as a getter the bitstring must be a whole number of byte long or a :exc:`InterpretError` will be raised. An alternative is to use the :meth:`tobytes` method, which will pad with between zero and seven ``0`` bits to make it byte aligned if needed. :: >>> s = Bits('0x12345678') >>> s.bytes b'\x124Vx' .. attribute:: hex Property representing the hexadecimal value of the bitstring. If the bitstring is not a multiple of four bits long then getting its hex value will raise an :exc:`InterpretError`. :: >>> s = Bits(bin='1111 0000') >>> s.hex 'f0' .. attribute:: int Property for the signed two’s complement integer representation of the bitstring. .. attribute:: intbe Property for the byte-wise big-endian signed two's complement integer representation of the bitstring. Only valid for whole-byte bitstrings, in which case it is equal to ``s.int``, otherwise an :exc:`InterpretError` is raised. .. attribute:: intle Property for the byte-wise little-endian signed two's complement integer representation of the bitstring. Only valid for whole-byte bitstring, in which case it is equal to ``s[::-8].int``, i.e. the integer representation of the byte-reversed bitstring. .. attribute:: intne Property for the byte-wise native-endian signed two's complement integer representation of the bitstring. Only valid for whole-byte bitstrings, and will equal either the big-endian or the little-endian integer representation depending on the platform being used. .. attribute:: float .. attribute:: floatbe Property for the floating point representation of the bitstring. The bitstring must be either 32 or 64 bits long to support the floating point interpretations, otherwise an :exc:`InterpretError` will be raised. If the underlying floating point methods on your machine are not IEEE 754 compliant then using the float interpretations is undefined (this is unlikely unless you're on some very unusual hardware). The :attr:`float` property is bit-wise big-endian, which as all floats must be whole-byte is exactly equivalent to the byte-wise big-endian :attr:`floatbe`. .. attribute:: floatle Property for the byte-wise little-endian floating point representation of the bitstring. .. attribute:: floatne Property for the byte-wise native-endian floating point representation of the bitstring. .. attribute:: len .. attribute:: length Read-only property that give the length of the bitstring in bits (:attr:`len` and :attr:`length` are equivalent). This is almost equivalent to using the ``len()`` built-in function, except that for large bitstrings ``len()`` may fail with an :exc:`OverflowError`, whereas the :attr:`len` property continues to work. .. attribute:: oct Property for the octal representation of the bitstring. If the bitstring is not a multiple of three bits long then getting its octal value will raise a :exc:`InterpretError`. :: >>> s = BitString('0b111101101') >>> s.oct '755' >>> s.oct = '01234567' >>> s.oct '01234567' .. attribute:: se Property for the signed exponential-Golomb code representation of the bitstring. When used as a getter an :exc:`InterpretError` will be raised if the bitstring is not a single code. :: >>> s = BitString(se=-40) >>> s.bin 0000001010001 >>> s += '0b1' >>> s.se Error: BitString is not a single exponential-Golomb code. .. attribute:: ue Property for the unsigned exponential-Golomb code representation of the bitstring. When used as a getter an :exc:`InterpretError` will be raised if the bitstring is not a single code. .. attribute:: sie Property for the signed interleaved exponential-Golomb code representation of the bitstring. When used as a getter an :exc:`InterpretError` will be raised if the bitstring is not a single code. .. attribute:: uie Property for the unsigned interleaved exponential-Golomb code representation of the bitstring. When used as a getter an :exc:`InterpretError` will be raised if the bitstring is not a single code. .. attribute:: uint Property for the unsigned base-2 integer representation of the bitstring. .. attribute:: uintbe Property for the byte-wise big-endian unsigned base-2 integer representation of the bitstring. .. attribute:: uintle Property for the byte-wise little-endian unsigned base-2 integer representation of the bitstring. .. attribute:: uintne Property for the byte-wise native-endian unsigned base-2 integer representation of the bitstring. .. method:: __add__(bs) .. method:: __radd__(bs) ``s1 + s2`` Concatenate two bitstring objects and return the result. Either bitstring can be 'auto' initialised. :: s = Bits(ue=132) + '0xff' s2 = '0b101' + s .. method:: __and__(bs) .. method:: __rand__(bs) ``s1 & s2`` Returns the bit-wise AND between two bitstrings, which must have the same length otherwise a :exc:`ValueError` is raised. :: >>> print(Bits('0x33') & '0x0f') 0x03 .. method:: __bool__() ``if s:`` Returns ``True`` if at least one bit is set to 1, otherwise returns ``False``. This special method is used in Python 3 only; for Python 2.7 the equivalent is called ``__nonzero__``, but the details are exactly the same. :: >>> bool(Bits()) False >>> bool(Bits('0b0000010000')) True >>> bool(Bits('0b0000000000')) False .. method:: __contains__(bs) ``bs in s`` Returns ``True`` if *bs* can be found in the bitstring, otherwise returns ``False``. Similar to using :meth:`~Bits.find`, except that you are only told if it is found, and not where it was found. :: >>> '0b11' in Bits('0x06') True >>> '0b111' in Bits('0x06') False .. method:: __copy__() ``s2 = copy.copy(s1)`` This allows the :mod:`copy` module to correctly copy bitstrings. Other equivalent methods are to initialise a new bitstring with the old one or to take a complete slice. :: >>> import copy >>> s = Bits('0o775') >>> s_copy1 = copy.copy(s) >>> s_copy2 = Bits(s) >>> s_copy3 = s[:] >>> s == s_copy1 == s_copy2 == s_copy3 True .. method:: __eq__(bs) ``s1 == s2`` Compares two bitstring objects for equality, returning ``True`` if they have the same binary representation, otherwise returning ``False``. :: >>> Bits('0o7777') == '0xfff' True >>> a = Bits(uint=13, length=8) >>> b = Bits(uint=13, length=10) >>> a == b False .. method:: __getitem__(key) ``s[start:end:step]`` Returns a slice of the bitstring. The usual slice behaviour applies. :: >>> s = Bits('0x0123456') >>> s[4:8] Bits('0x1') >>> s[1::8] # 1st, 9th, 17th and 25th bits Bits('0x3') If a single element is asked for then either ``True`` or ``False`` will be returned. :: >>> s[0] False >>> s[-1] True .. method:: __hash__() ``hash(s)`` Returns an integer hash of the :class:`Bits`. This method is not available for the :class:`BitArray` or :class:`BitStream` classes, as only immutable objects should be hashed. You typically won't need to call it directly, instead it is used for dictionary keys and in sets. .. method:: __invert__() ``~s`` Returns the bitstring with every bit inverted, that is all zeros replaced with ones, and all ones replaced with zeros. If the bitstring is empty then an :exc:`Error` will be raised. :: >>> s = ConstBitStream(‘0b1110010’) >>> print(~s) 0b0001101 >>> print(~s & s) 0b0000000 .. method:: __len__() ``len(s)`` Returns the length of the bitstring in bits if it is less than ``sys.maxsize``, otherwise raises :exc:`OverflowError`. It's recommended that you use the :attr:`len` property rather than the :func:`len` function because of the function's behaviour for large bitstring objects, although calling the special function directly will always work. :: >>> s = Bits(filename='11GB.mkv') >>> s.len 93944160032 >>> len(s) OverflowError: long int too large to convert to int >>> s.__len__() 93944160032 .. method:: __lshift__(n) ``s << n`` Returns the bitstring with its bits shifted *n* places to the left. The *n* right-most bits will become zeros. :: >>> s = Bits('0xff') >>> s << 4 Bits('0xf0') .. method:: __mul__(n) .. method:: __rmul__(n) ``s * n / n * s`` Return bitstring consisting of *n* concatenations of another. :: >>> a = Bits('0x34') >>> b = a*5 >>> print(b) 0x3434343434 .. method:: __ne__(bs) ``s1 != s2`` Compares two bitstring objects for inequality, returning ``False`` if they have the same binary representation, otherwise returning ``True``. .. method:: __nonzero__() See :meth:`__bool__`. .. method:: __or__(bs) .. method:: __ror__(bs) ``s1 | s2`` Returns the bit-wise OR between two bitstring, which must have the same length otherwise a :exc:`ValueError` is raised. :: >>> print(Bits('0x33') | '0x0f') 0x3f .. method:: __repr__() ``repr(s)`` A representation of the bitstring that could be used to create it (which will often not be the form used to create it). If the result is too long then it will be truncated with ``...`` and the length of the whole will be given. :: >>> Bits(‘0b11100011’) Bits(‘0xe3’) .. method:: __rshift__(n) ``s >> n`` Returns the bitstring with its bits shifted *n* places to the right. The *n* left-most bits will become zeros. :: >>> s = Bits(‘0xff’) >>> s >> 4 Bits(‘0x0f’) .. method:: __str__() ``print(s)`` Used to print a representation of the bitstring, trying to be as brief as possible. If the bitstring is a multiple of 4 bits long then hex will be used, otherwise either binary or a mix of hex and binary will be used. Very long strings will be truncated with ``...``. :: >>> s = Bits('0b1')*7 >>> print(s) 0b1111111 >>> print(s + '0b1') 0xff .. method:: __xor__(bs) .. method:: __rxor__(bs) ``s1 ^ s2`` Returns the bit-wise XOR between two bitstrings, which must have the same length otherwise a :exc:`ValueError` is raised. :: >>> print(Bits('0x33') ^ '0x0f') 0x3c bitstring-bitstring-3.1.7/doc/constbitstream.rst000066400000000000000000000153201365434337700221120ustar00rootroot00000000000000.. currentmodule:: bitstring The ConstBitStream class ------------------------ .. class:: ConstBitStream([auto, length, offset, **kwargs]) The :class:`Bits` class is the base class for :class:`ConstBitStream` and so all of its methods are also available for :class:`ConstBitStream` objects. The initialiser is also the same as for :class:`Bits` and so won't be repeated here. A :class:`ConstBitStream` is a :class:`Bits` with added methods and properties that allow it to be parsed as a stream of bits. .. method:: bytealign() Aligns to the start of the next byte (so that :attr:`pos` is a multiple of 8) and returns the number of bits skipped. If the current position is already byte aligned then it is unchanged. :: >>> s = ConstBitStream('0xabcdef') >>> s.pos += 3 >>> s.bytealign() 5 >>> s.pos 8 .. method:: peek(fmt) Reads from the current bit position :attr:`pos` in the bitstring according to the *fmt* string or integer and returns the result. The bit position is unchanged. For information on the format string see the entry for the :meth:`read` method. :: >>> s = ConstBitStream('0x123456') >>> s.peek(16) ConstBitStream('0x1234') >>> s.peek('hex:8') '12' .. method:: peeklist(fmt, **kwargs) Reads from current bit position :attr:`pos` in the bitstring according to the *fmt* string or iterable and returns a list of results. A dictionary or keyword arguments can also be provided. These will replace length identifiers in the format string. The position is not advanced to after the read items. See the entries for :meth:`read` and :meth:`readlist` for more information. .. method:: read(fmt) Reads from current bit position :attr:`pos` in the bitstring according the format string and returns a single result. If not enough bits are available then a :exc:`ReadError` is raised. *fmt* is either a token string that describes how to interpret the next bits in the bitstring or an integer. If it's an integer then that number of bits will be read, and returned as a new bitstring. Otherwise the tokens are: ============== ================================================= ``int:n`` ``n`` bits as a signed integer. ``uint:n`` ``n`` bits as an unsigned integer. ``float:n`` ``n`` bits as a floating point number. ``intbe:n`` ``n`` bits as a big-endian signed integer. ``uintbe:n`` ``n`` bits as a big-endian unsigned integer. ``floatbe:n`` ``n`` bits as a big-endian float. ``intle:n`` ``n`` bits as a little-endian signed int. ``uintle:n`` ``n`` bits as a little-endian unsigned int. ``floatle:n`` ``n`` bits as a little-endian float. ``intne:n`` ``n`` bits as a native-endian signed int. ``uintne:n`` ``n`` bits as a native-endian unsigned int. ``floatne:n`` ``n`` bits as a native-endian float. ``hex:n`` ``n`` bits as a hexadecimal string. ``oct:n`` ``n`` bits as an octal string. ``bin:n`` ``n`` bits as a binary string. ``ue`` next bits as an unsigned exp-Golomb. ``se`` next bits as a signed exp-Golomb. ``uie`` next bits as an interleaved unsigned exp-Golomb. ``sie`` next bits as an interleaved signed exp-Golomb. ``bits:n`` ``n`` bits as a new bitstring. ``bytes:n`` ``n`` bytes as ``bytes`` object. ``bool[:1]`` next bit as a boolean (True or False). ``pad:n`` next ``n`` bits will be skipped. ============== ================================================= For example:: >>> s = ConstBitStream('0x23ef55302') >>> s.read('hex:12') '23e' >>> s.read('bin:4') '1111' >>> s.read('uint:5') 10 >>> s.read('bits:4') ConstBitStream('0xa') The :meth:`~ConstBitStream.read` method is useful for reading exponential-Golomb codes. :: >>> s = ConstBitStream('se=-9, ue=4') >>> s.read('se') -9 >>> s.read('ue') 4 The ``pad`` token is not very useful when used in :meth:`~ConstBitStream.read` as it just skips a number of bits and returns ``None``. However when used within :meth:`~ConstBitStream.readlist` or :meth:`~Bits.unpack` it allows unimportant part of the bitstring to be simply ignored. .. method:: readlist(fmt, **kwargs) Reads from current bit position :attr:`pos` in the bitstring according to the *fmt* string or iterable and returns a list of results. If not enough bits are available then a :exc:`ReadError` is raised. A dictionary or keyword arguments can also be provided. These will replace length identifiers in the format string. The position is advanced to after the read items. See the entry for :meth:`read` for information on the format strings. For multiple items you can separate using commas or given multiple parameters:: >>> s = ConstBitStream('0x43fe01ff21') >>> s.readlist('hex:8, uint:6') ['43', 63] >>> s.readlist(['bin:3', 'intle:16']) ['100', -509] >>> s.pos = 0 >>> s.readlist('hex:b, uint:d', b=8, d=6) ['43', 63] .. method:: readto(bs, bytealigned) Reads up to and including the next occurrence of the bitstring *bs* and returns the results. If *bytealigned* is `True` it will look for the bitstring starting only at whole-byte positions. Raises a :exc:`ReadError` if *bs* is not found, and :exc:`ValueError` if *bs* is empty. >>> s = ConstBitStream('0x47000102034704050647') >>> s.readto('0x47', bytealigned=True) BitStream('0x47') >>> s.readto('0x47', bytealigned=True) BitStream('0x0001020347') >>> s.readto('0x47', bytealigned=True) BitStream('0x04050647') .. attribute:: bytepos Property for setting and getting the current byte position in the bitstring. When used as a getter will raise a :exc:`ByteAlignError` if the current position in not byte aligned. .. attribute:: pos .. attribute:: bitpos Read and write property for setting and getting the current bit position in the bitstring. Can be set to any value from ``0`` to :attr:`len`. The :attr:`pos` and :attr:`bitpos` properties are exactly equivalent - you can use whichever you prefer. :: if s.pos < 100: s.pos += 10 bitstring-bitstring-3.1.7/doc/contents.rst000066400000000000000000000002701365434337700207040ustar00rootroot00000000000000 .. _manual: ########### User Manual ########### .. toctree:: :maxdepth: 2 walkthrough introduction creation packing interpretation slicing reading misc bitstring-bitstring-3.1.7/doc/creation.rst000066400000000000000000000342411365434337700206600ustar00rootroot00000000000000.. currentmodule:: bitstring .. _creation: Creation ======== You can create bitstrings in a variety of ways. Internally they are stored as byte arrays, which means that no space is wasted, and a bitstring containing 10MB of binary data will only take up 10MB of memory. The bitstring classes --------------------- Four classes are provided by the bitstring module: :class:`BitStream` and :class:`BitArray` together with their immutable versions :class:`ConstBitStream` and :class:`Bits`: * :class:`Bits` ``(object)``: This is the most basic class. It is immutable and so its contents can't be changed after creation. * :class:`BitArray` ``(Bits)``: This adds mutating methods to its base class. * :class:`ConstBitStream` ``(Bits)``: This adds methods and properties to allow the bits to be treated as a stream of bits, with a bit position and reading/parsing methods. * :class:`BitStream` ``(BitArray, ConstBitStream)``: This is the most versatile class, having both the bitstream methods and the mutating methods. Before version 3.0 ``Bits`` was known as ``ConstBitArray``. The old name is still available for backward compatibility. The term 'bitstring' is used in this manual to refer generically to any of these classes. Most of the examples in this manual use the :class:`BitArray` class, with :class:`BitStream` used when necessary. For most uses the non-const classes are more versatile and so probably your best choice when starting to use the module. To summarise when to use each class: * If you need to change the contents of the bitstring then you must use :class:`BitArray` or :class:`BitStream`. Truncating, replacing, inserting, appending etc. are not available for the const classes. * If you need to use a bitstring as the key in a dictionary or as a member of a ``set`` then you must use :class:`Bits` or a :class:`ConstBitStream`. As :class:`BitArray` and :class:`BitStream` objects are mutable they do not support hashing and so cannot be used in these ways. * If you are creating directly from a file then a :class:`BitArray` or :class:`BitStream` will read the file into memory whereas a :class:`Bits` or :class:`ConstBitStream` will not, so using the const classes allows extremely large files to be examined. * If you don't need the extra functionality of a particular class then the simpler ones might be faster and more memory efficient. The fastest and most memory efficient class is :class:`Bits`. The :class:`Bits` class is the base class of the other three class. This means that ``isinstance(s, Bits)`` will be true if ``s`` is an instance of any of the four classes. Using the constructor --------------------- When initialising a bitstring you need to specify at most one initialiser. These will be explained in full below, but briefly they are: * ``auto`` : Either a specially formatted string, a list or tuple, a file object, integer, bytearray, array, bytes or another bitstring. * ``bytes`` : A ``bytes`` object (a ``str`` in Python 2), for example read from a binary file. * ``hex``, ``oct``, ``bin``: Hexadecimal, octal or binary strings. * ``int``, ``uint``: Signed or unsigned bit-wise big-endian binary integers. * ``intle``, ``uintle``: Signed or unsigned byte-wise little-endian binary integers. * ``intbe``, ``uintbe``: Signed or unsigned byte-wise big-endian binary integers. * ``intne``, ``uintne``: Signed or unsigned byte-wise native-endian binary integers. * ``float`` / ``floatbe``, ``floatle``, ``floatne``: Big, little and native endian floating point numbers. * ``se``, ``ue`` : Signed or unsigned exponential-Golomb coded integers. * ``sie``, ``uie`` : Signed or unsigned interleaved exponential-Golomb coded integers. * ``bool`` : A boolean (i.e. True or False). * ``filename`` : Directly from a file, without reading into memory. From a hexadecimal string ^^^^^^^^^^^^^^^^^^^^^^^^^ >>> c = BitArray(hex='0x000001b3') >>> c.hex '000001b3' The initial ``0x`` or ``0X`` is optional. Whitespace is also allowed and is ignored. Note that the leading zeros are significant, so the length of ``c`` will be 32. If you include the initial ``0x`` then you can use the ``auto`` initialiser instead. As it is the first parameter in :class:`__init__` this will work equally well:: c = BitArray('0x000001b3') From a binary string ^^^^^^^^^^^^^^^^^^^^ >>> d = BitArray(bin='0011 00') >>> d.bin '001100' An initial ``0b`` or ``0B`` is optional and whitespace will be ignored. As with ``hex``, the ``auto`` initialiser will work if the binary string is prefixed by ``0b``:: >>> d = BitArray('0b001100') From an octal string ^^^^^^^^^^^^^^^^^^^^ >>> o = BitArray(oct='34100') >>> o.oct '34100' An initial ``0o`` or ``0O`` is optional, but ``0o`` (a zero and lower-case 'o') is preferred as it is slightly more readable. As with ``hex`` and ``bin``, the ``auto`` initialiser will work if the octal string is prefixed by ``0o``:: >>> o = BitArray('0o34100') From an integer ^^^^^^^^^^^^^^^ >>> e = BitArray(uint=45, length=12) >>> f = BitArray(int=-1, length=7) >>> e.bin '000000101101' >>> f.bin '1111111' For initialisation with signed and unsigned binary integers (``int`` and ``uint`` respectively) the ``length`` parameter is mandatory, and must be large enough to contain the integer. So for example if ``length`` is 8 then ``uint`` can be in the range 0 to 255, while ``int`` can range from -128 to 127. Two's complement is used to represent negative numbers. The auto initialise can be used by giving a colon and the length in bits immediately after the ``int`` or ``uint`` token, followed by an equals sign then the value:: >>> e = BitArray('uint:12=45') >>> f = BitArray('int:7=-1') The plain ``int`` and ``uint`` initialisers are bit-wise big-endian. That is to say that the most significant bit comes first and the least significant bit comes last, so the unsigned number one will have a ``1`` as its final bit with all other bits set to ``0``. These can be any number of bits long. For whole-byte bitstring objects there are more options available with different endiannesses. Big and little-endian integers ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >>> big_endian = BitArray(uintbe=1, length=16) >>> little_endian = BitArray(uintle=1, length=16) >>> native_endian = BitArray(uintne=1, length=16) There are unsigned and signed versions of three additional 'endian' types. The unsigned versions are used above to create three bitstrings. The first of these, ``big_endian``, is equivalent to just using the plain bit-wise big-endian ``uint`` initialiser, except that all ``intbe`` or ``uintbe`` interpretations must be of whole-byte bitstrings, otherwise a :exc:`ValueError` is raised. The second, ``little_endian``, is interpreted as least significant byte first, i.e. it is a byte reversal of ``big_endian``. So we have:: >>> big_endian.hex '0001' >>> little_endian.hex '0100' Finally we have ``native_endian``, which will equal either ``big_endian`` or ``little_endian``, depending on whether you are running on a big or little-endian machine (if you really need to check then use ``import sys; sys.byteorder``). From a floating point number ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >>> f1 = BitArray(float=10.3, length=32) >>> f2 = BitArray('float:64=5.4e31') Floating point numbers can be used for initialisation provided that the bitstring is 32 or 64 bits long. Standard Python floating point numbers are 64 bits long, so if you use 32 bits then some accuracy could be lost. Note that the exact bits used to represent the floating point number could be platform dependent. Most PCs will conform to the IEEE 754 standard, and presently other floating point representations are not supported (although they should work on a single platform - it just might get confusing if you try to interpret a generated bitstring on another platform). Similar to the situation with integers there are big and little endian versions. The plain ``float`` is big endian and so ``floatbe`` is just an alias. As with other initialisers you can also auto initialise, as demonstrated with the second example below:: >>> little_endian = BitArray(floatle=0.0, length=64) >>> native_endian = BitArray('floatne:32=-6.3') Exponential-Golomb codes ^^^^^^^^^^^^^^^^^^^^^^^^ Initialisation with integers represented by exponential-Golomb codes is also possible. ``ue`` is an unsigned code while ``se`` is a signed code. Interleaved exponential-Golomb codes are also supported via ``uie`` and ``sie``:: >>> g = BitArray(ue=12) >>> h = BitArray(se=-402) >>> g.bin '0001101' >>> h.bin '0000000001100100101' For these initialisers the length of the bitstring is fixed by the value it is initialised with, so the length parameter must not be supplied and it is an error to do so. If you don't know what exponential-Golomb codes are then you are in good company, but they are quite interesting, so I’ve included a section on them (see :ref:`exp-golomb`). The ``auto`` initialiser may also be used by giving an equals sign and the value immediately after a ``ue`` or ``se`` token:: >>> g = BitArray('ue=12') >>> h = BitArray('se=-402') You may wonder why you would bother with ``auto`` in this case as the syntax is slightly longer. Hopefully all will become clear in the next section. From raw byte data ^^^^^^^^^^^^^^^^^^ Using the length and offset parameters to specify the length in bits and an offset at the start to be ignored is particularly useful when initialising from raw data or from a file. :: a = BitArray(bytes=b'\x00\x01\x02\xff', length=28, offset=1) b = BitArray(bytes=open("somefile", 'rb').read()) The ``length`` parameter is optional; it defaults to the length of the data in bits (and so will be a multiple of 8). You can use it to truncate some bits from the end of the bitstring. The ``offset`` parameter is also optional and is used to truncate bits at the start of the data. You can also use a ``bytearray`` object, either explicitly with a ``bytes=some_bytearray`` keyword or via the ``auto`` initialiser:: c = BitArray(a_bytearray_object) If you are using Python 3.x you can use this trick with ``bytes`` objects too. This should be used with caution as in Python 2.7 it will instead be interpreted as a string (it's not possible to distinguish between ``str`` and ``bytes`` in Python 2) and so your code won't work the same between Python versions. :: d = BitArray(b'\x23g$5') # Use with caution! Only works correctly in Python 3. From a file ^^^^^^^^^^^ Using the ``filename`` initialiser allows a file to be analysed without the need to read it all into memory. The way to create a file-based bitstring is:: p = Bits(filename="my2GBfile") This will open the file in binary read-only mode. The file will only be read as and when other operations require it, and the contents of the file will not be changed by any operations. If only a portion of the file is needed then the ``offset`` and ``length`` parameters (specified in bits) can be used. Note that we created a :class:`Bits` here rather than a :class:`BitArray`, as they have quite different behaviour in this case. The immutable :class:`Bits` will never read the file into memory (except as needed by other operations), whereas if we had created a :class:`BitArray` then the whole of the file would immediately have been read into memory. This is because in creating a :class:`BitArray` you are implicitly saying that you want to modify it, and so it needs to be in memory. It's also possible to use the ``auto`` initialiser for file objects. It's as simple as:: f = open('my2GBfile', 'rb') p = Bits(f) The auto initialiser -------------------- The ``auto`` parameter is the first parameter in the :class:`__init__` function and so the ``auto=`` can be omitted when using it. It accepts either a string, an iterable, another bitstring, an integer, a bytearray or a file object. Strings starting with ``0x`` or ``hex:`` are interpreted as hexadecimal, ``0o`` or ``oct:`` implies octal, and strings starting with ``0b`` or ``bin:`` are interpreted as binary. You can also initialise with the various integer initialisers as described above. If given another bitstring it will create a copy of it, (non string) iterables are interpreted as boolean arrays and file objects acts a source of binary data. An ``array`` object will be converted into its constituent bytes. Finally you can use an integer to create a zeroed bitstring of that number of bits. :: >>> fromhex = BitArray('0x01ffc9') >>> frombin = BitArray('0b01') >>> fromoct = BitArray('0o7550') >>> fromint = BitArray('int:32=10') >>> fromfloat = BitArray('float:64=0.2') >>> acopy = BitArray(fromoct) >>> fromlist = BitArray([1, 0, 0]) >>> f = open('somefile', 'rb') >>> fromfile = BitArray(f) >>> zeroed = BitArray(1000) >>> frombytes = BitArray(bytearray(b'xyz')) >>> fromarray = BitArray(array.array('h', [3, 17, 10])) It can also be used to convert between the :class:`BitArray` and :class:`Bits` classes:: >>> immutable = Bits('0xabc') >>> mutable = BitArray(immutable) >>> mutable += '0xdef' >>> immutable = Bits(mutable) As always the bitstring doesn't know how it was created; initialising with octal or hex might be more convenient or natural for a particular example but it is exactly equivalent to initialising with the corresponding binary string. :: >>> fromoct.oct '7550' >>> fromoct.hex 'f68' >>> fromoct.bin '111101101000' >>> fromoct.uint 3994 >>> fromoct.int -152 >>> BitArray('0o7777') == '0xfff' True >>> BitArray('0xf') == '0b1111' True >>> frombin[::-1] + '0b0' == fromlist True Note how in the final examples above only one half of the ``==`` needs to be a bitstring, the other half gets ``auto`` initialised before the comparison is made. This is in common with many other functions and operators. You can also chain together string initialisers with commas, which causes the individual bitstrings to be concatenated. :: >>> s = BitArray('0x12, 0b1, uint:5=2, ue=5, se=-1, se=4') >>> s.find('uint:5=2, ue=5') True >>> s.insert('0o332, 0b11, int:23=300', 4) Again, note how the format used in the ``auto`` initialiser can be used in many other places where a bitstring is needed. bitstring-bitstring-3.1.7/doc/examples.rst000066400000000000000000000057261365434337700207000ustar00rootroot00000000000000 Examples ======== Creation -------- There are lots of ways of creating new bitstrings. The most flexible is via the ``auto`` parameter, which is used in this example. :: # Multiple parts can be joined with a single expression... s = BitArray('0x000001b3, uint:12=352, uint:12=288, 0x1, 0x3') # and extended just as easily s += 'uint:18=48000, 0b1, uint:10=4000, 0b100' # To covert to an ordinary string use the bytes property open('video.m2v', 'wb').write(s.bytes) # The information can be read back with a similar syntax start_code, width, height = s.readlist('hex:32, uint:12, uint:12') aspect_ratio, frame_rate = s.readlist('2*bin:4') Manipulation ------------ :: s = BitArray('0x0123456789abcdef') del s[4:8] # deletes the '1' s.insert('0xcc', 12) # inserts 'cc' between the '3' and '4' s.overwrite('0b01', 30) # changes the '6' to a '5' # This replaces every '1' bit with a 5 byte Ascii string! s.replace('0b1', BitArray(bytes='hello')) del s[-1001:] # deletes final 1001 bits s.reverse() # reverses whole BitString s.prepend('uint:12=44') # prepend a 12 bit integer Parsing ------- This example creates a class that parses a structure that is part of the H.264 video standard. :: class seq_parameter_set_data(object): def __init__(self, s): """Interpret next bits in BitString s as an SPS.""" # Read and interpret bits in a single expression: self.profile_idc = s.read('uint:8') # Multiple reads in one go returns a list: self.constraint_flags = s.readlist('4*uint:1') self.reserved_zero_4bits = s.read('bin:4') self.level_idc = s.read('uint:8') self.seq_parameter_set_id = s.read('ue') if self.profile_idc in [100, 110, 122, 244, 44, 83, 86]: self.chroma_format_idc = s.read('ue') if self.chroma_format_idc == 3: self.separate_colour_plane_flag = s.read('uint:1') self.bit_depth_luma_minus8 = s.read('ue') self.bit_depth_chroma_minus8 = s.read('ue') # etc. :: >>> s = BitStream('0x6410281bc0') >>> sps = seq_parameter_set_data(s) >>> print(sps.profile_idc) 100 >>> print(sps.level_idc) 40 >>> print(sps.reserved_zero_4bits) 0b0000 >>> print(sps.constraint_flags) [0, 0, 0, 1] Sieve of Eratosthenes --------------------- This classic (though inefficient) method of calculating prime numbers uses a bitstring to store whether each bit position represents a prime number. This takes much less memory than an ordinary array. :: def prime_sieve(top=1000000): b = BitArray(top) # bitstring of '0' bits for i in xrange(2, top): if not b[i]: yield i # i is prime, so set all its multiples to '1'. b.set(True, xrange(i*i, top, i)) bitstring-bitstring-3.1.7/doc/exp-golomb.rst000066400000000000000000000063141365434337700211250ustar00rootroot00000000000000 .. _exp-golomb: Exponential-Golomb Codes ======================== As this type of representation of integers isn't as well known as the standard base-2 representation I thought that a short explanation of them might be welcome. This section can be safely skipped if you're not interested. Exponential-Golomb codes represent integers using bit patterns that get longer for larger numbers. For unsigned and signed numbers (the bitstring properties :attr:`ue` and :attr:`se` respectively) the patterns start like this: ============= =========== =========== Bit pattern Unsigned Signed ============= =========== =========== ``1`` 0 0 ``010`` 1 1 ``011`` 2 -1 ``00100`` 3 2 ``00101`` 4 -2 ``00110`` 5 3 ``00111`` 6 -3 ``0001000`` 7 4 ``0001001`` 8 -4 ``0001010`` 9 5 ``0001011`` 10 -5 ``0001100`` 11 6 ``...`` ... ... ============= =========== =========== They consist of a sequence of n '0' bits, followed by a '1' bit, followed by n more bits. The bits after the first '1' bit count upwards as ordinary base-2 binary numbers until they run out of space and an extra '0' bit needs to get included at the start. The advantage of this method of representing integers over many other methods is that it can be quite efficient at representing small numbers without imposing a limit on the maximum number that can be represented. Exercise: Using the table above decode this sequence of unsigned Exponential Golomb codes: ``001001101101101011000100100101`` The answer is that it decodes to 3, 0, 0, 2, 2, 1, 0, 0, 8, 4. Note how you don’t need to know how many bits are used for each code in advance - there’s only one way to decode it. To create this bitstring you could have written something like:: a = BitStream().join([BitArray(ue=i) for i in [3,0,0,2,2,1,0,0,8,4]]) and to read it back:: while a.pos != a.len: print(a.read('ue')) The notation ``ue`` and ``se`` for the exponential-Golomb code properties comes from the H.264 video standard, which uses these types of code a lot. There are other ways to map the bitstrings to integers: Interleaved exponential-Golomb codes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This type of code is used in the Dirac video standard, and is represented by the attributes :attr:`uie` and :attr:`sie`. For the interleaved codes the pattern is very similar to before for the unsigned case: ============= =========== Bit pattern Unsigned ============= =========== ``1`` 0 ``001`` 1 ``011`` 2 ``00001`` 3 ``00011`` 4 ``01001`` 5 ``01011`` 6 ``0000001`` 7 ``0000011`` 8 ``0001001`` 9 ``...`` ... ============= =========== For the signed code it looks a little different: ============= =========== Bit pattern Signed ============= =========== ``1`` 0 ``0010`` 1 ``0011`` -1 ``0110`` 2 ``0111`` -2 ``000010`` 3 ``000011`` -3 ``000110`` 4 ``000111`` -4 ``010010`` 5 ``010011`` -5 ``...`` ... ============= =========== I'm sure you can work out the pattern yourself from here!bitstring-bitstring-3.1.7/doc/functions.rst000066400000000000000000000042561365434337700210670ustar00rootroot00000000000000.. currentmodule:: bitstring Functions --------- .. function:: pack(format[, *values, **kwargs]) Packs the values and keyword arguments according to the *format* string and returns a new :class:`BitStream`. :param format: string with comma separated tokens :param values: extra values used to construct the :class:`BitStream` :param kwargs: a dictionary of token replacements :rtype: BitStream The format string consists of comma separated tokens of the form ``name:length=value``. See the entry for :meth:`~ConstBitStream.read` for more details. The tokens can be 'literals', like ``0xef``, ``0b110``, ``uint:8=55``, etc. which just represent a set sequence of bits. They can also have the value missing, in which case the values contained in ``*values`` will be used. :: >>> a = pack('bin:3, hex:4', '001', 'f') >>> b = pack('uint:10', 33) A dictionary or keyword arguments can also be provided. These will replace items in the format string. :: >>> c = pack('int:a=b', a=10, b=20) >>> d = pack('int:8=a, bin=b, int:4=a', a=7, b='0b110') Plain names can also be used as follows:: >>> e = pack('a, b, b, a', a='0b11', b='0o2') Tokens starting with an endianness identifier (``<``, ``>`` or ``@``) implies a struct-like compact format string (see :ref:`compact_format`). For example this packs three little-endian 16-bit integers:: >>> f = pack('<3h', 12, 3, 108) And of course you can combine the different methods in a single pack. A :exc:`ValueError` will be raised if the ``*values`` are not all used up by the format string, and if a value provided doesn't match the length specified by a token. Exceptions ---------- .. exception:: Error(Exception) Base class for all module exceptions. .. exception:: InterpretError(Error, ValueError) Inappropriate interpretation of binary data. For example using the 'bytes' property on a bitstring that isn't a whole number of bytes long. .. exception:: ByteAlignError(Error) Whole-byte position or length needed. .. exception:: CreationError(Error, ValueError) Inappropriate argument during bitstring creation. .. exception:: ReadError(Error, IndexError) Reading or peeking past the end of a bitstring. bitstring-bitstring-3.1.7/doc/index.rst000066400000000000000000000033511365434337700201610ustar00rootroot00000000000000 .. currentmodule:: bitstring **bitstring** is a pure Python module that makes the creation, manipulation and analysis of binary data as simple and natural as possible. Features -------- * Supports Python 2.7 and Python 3. * Rich API - chances are that whatever you want to do there's a simple and elegant way of doing it. * Bit level slicing, joining, searching, replacing and more. * Create bitstrings from hex, octal, binary, files, formatted strings, bytes, integers and floats of different endiannesses. * Powerful binary packing and unpacking functions. * Read from and interpret bitstrings as streams of binary data. Installation and Download ------------------------- To install just ``pip install bitstring``. To download the module, as well as for defect reports, enhancement requests and Git repository browsing go to the project's home on GitHub: http://scott-griffiths.github.io/bitstring/ Documentation ------------- The manual provides an introduction to the module and details most its capabilities. The reference section has a complete list of all the classes, methods, attributes and functions of the :mod:`bitstring` module, together with short examples for many items. .. toctree:: :maxdepth: 2 contents reference appendices The manual is also available as a PDF: * `Latest manual (PDF) `_ Index and search ---------------- * :ref:`genindex` * :ref:`search` Credits ------- Written by Scott Griffiths . If you have any questions, suggestions or criticisms (about this module!) then please email me. Also if you use bitstring in your own project then I'd be interested to hear how it's being used. bitstring-bitstring-3.1.7/doc/interpretation.rst000066400000000000000000000151421365434337700221220ustar00rootroot00000000000000.. currentmodule:: bitstring Interpreting Bitstrings ----------------------- Bitstrings don't know or care how they were created; they are just collections of bits. This means that you are quite free to interpret them in any way that makes sense. Several Python properties are used to create interpretations for the bitstring. These properties call private functions which will calculate and return the appropriate interpretation. These don’t change the bitstring in any way and it remains just a collection of bits. If you use the property again then the calculation will be repeated. Note that these properties can potentially be very expensive in terms of both computation and memory requirements. For example if you have initialised a bitstring from a 10 GB file object and ask for its binary string representation then that string will be around 80 GB in size! For the properties described below we will use these:: >>> a = BitArray('0x123') >>> b = BitArray('0b111') bin ^^^ The most fundamental interpretation is perhaps as a binary string (a ‘bitstring’). The :attr:`~Bits.bin` property returns a string of the binary representation of the bitstring. All bitstrings can use this property and it is used to test equality between bitstrings. :: >>> a.bin '000100100011' >>> b.bin '111' Note that the initial zeros are significant; for bitstrings the zeros are just as important as the ones! hex ^^^ For whole-byte bitstrings the most natural interpretation is often as hexadecimal, with each byte represented by two hex digits. If the bitstring does not have a length that is a multiple of four bits then an :exc:`InterpretError` exception will be raised. This is done in preference to truncating or padding the value, which could hide errors in user code. :: >>> a.hex '123' >>> b.hex ValueError: Cannot convert to hex unambiguously - not multiple of 4 bits. oct ^^^ For an octal interpretation use the :attr:`~Bits.oct` property. If the bitstring does not have a length that is a multiple of three then an :exc:`InterpretError` exception will be raised. :: >>> a.oct '0443' >>> b.oct '7' >>> (b + '0b0').oct ValueError: Cannot convert to octal unambiguously - not multiple of 3 bits. uint / uintbe / uintle / uintne ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To interpret the bitstring as a binary (base-2) bit-wise big-endian unsigned integer (i.e. a non-negative integer) use the :attr:`~Bits.uint` property. >>> a.uint 283 >>> b.uint 7 For byte-wise big-endian, little-endian and native-endian interpretations use :attr:`~Bits.uintbe`, :attr:`~Bits.uintle` and :attr:`~Bits.uintne` respectively. These will raise a :exc:`ValueError` if the bitstring is not a whole number of bytes long. :: >>> s = BitArray('0x000001') >>> s.uint # bit-wise big-endian 1 >>> s.uintbe # byte-wise big-endian 1 >>> s.uintle # byte-wise little-endian 65536 >>> s.uintne # byte-wise native-endian (will be 1 on a big-endian platform!) 65536 int / intbe / intle / intne ^^^^^^^^^^^^^^^^^^^^^^^^^^^ For a two's complement interpretation as a base-2 signed integer use the :attr:`~Bits.int` property. If the first bit of the bitstring is zero then the :attr:`~Bits.int` and :attr:`~Bits.uint` interpretations will be equal, otherwise the :attr:`~Bits.int` will represent a negative number. :: >>> a.int 283 >>> b.int -1 For byte-wise big, little and native endian signed integer interpretations use :attr:`~Bits.intbe`, :attr:`~Bits.intle` and :attr:`~Bits.intne` respectively. These work in the same manner as their unsigned counterparts described above. float / floatbe / floatle / floatne ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ For a floating point interpretation use the :attr:`~Bits.float` property. This uses your machine's underlying floating point representation and will only work if the bitstring is 32 or 64 bits long. Different endiannesses are provided via :attr:`~Bits.floatle` and :attr:`~Bits.floatne`. Note that as floating point interpretations are only valid on whole-byte bitstrings there is no difference between the bit-wise big-endian :attr:`~Bits.float` and the byte-wise big-endian :attr:`~Bits.floatbe`. Note also that standard floating point numbers in Python are stored in 64 bits, so use this size if you wish to avoid rounding errors. bytes ^^^^^ A common need is to retrieve the raw bytes from a bitstring for further processing or for writing to a file. For this use the :attr:`~Bits.bytes` interpretation, which returns a ``bytes`` object (which is equivalent to an ordinary ``str`` in Python 2.6/2.7). If the length of the bitstring isn't a multiple of eight then a :exc:`ValueError` will be raised. This is because there isn't an unequivocal representation as ``bytes``. You may prefer to use the method :meth:`~Bits.tobytes` as this will be pad with between one and seven zero bits up to a byte boundary if necessary. :: >>> open('somefile', 'wb').write(a.tobytes()) >>> open('anotherfile', 'wb').write(('0x0'+a).bytes) >>> a1 = BitArray(filename='somefile') >>> a1.hex '1230' >>> a2 = BitArray(filename='anotherfile') >>> a2.hex '0123' Note that the :meth:`~Bits.tobytes` method automatically padded with four zero bits at the end, whereas for the other example we explicitly padded at the start to byte align before using the :attr:`~Bits.bytes` property. ue ^^ The :attr:`~Bits.ue` property interprets the bitstring as a single unsigned exponential-Golomb code and returns an integer. If the bitstring is not exactly one code then an :exc:`InterpretError` is raised instead. If you instead wish to read the next bits in the stream and interpret them as a code use the read function with a ``ue`` format string. See :ref:`exp-golomb` for a short explanation of this type of integer representation. :: >>> s = BitArray(ue=12) >>> s.bin '0001101' >>> s.append(BitArray(ue=3)) >>> print(s.readlist('2*ue')) [12, 3] se ^^ The :attr:`~Bits.se` property does much the same as ``ue`` and the provisos there all apply. The obvious difference is that it interprets the bitstring as a signed exponential-Golomb rather than unsigned - see :ref:`exp-golomb` for more information. :: >>> s = BitArray('0x164b') >>> s.se InterpretError: BitArray, is not a single exponential-Golomb code. >>> while s.pos < s.length: ... print(s.read('se')) -5 2 0 -1 uie / sie ^^^^^^^^^ A slightly different type, interleaved exponential-Golomb codes are also supported. The principles are the same as with ``ue`` and ``se`` - see :ref:`exp-golomb` for detail of the differences. bitstring-bitstring-3.1.7/doc/introduction.rst000066400000000000000000000101341365434337700215700ustar00rootroot00000000000000.. currentmodule:: bitstring ************ Introduction ************ While it is not difficult to manipulate binary data in Python, for example using the :mod:`struct` and :mod:`array` modules, it can be quite fiddly and time consuming even for quite small tasks, especially if you are not dealing only with whole-byte data. The bitstring module provides four classes, :class:`BitStream`, :class:`BitArray`, :class:`ConstBitStream` and :class:`Bits`, instances of which can be constructed from integers, floats, hex, octal, binary, strings or files, but they all just represent a string of binary digits. I shall use the general term 'bitstring' when referring generically to any of the classes, and use the class names for parts that apply to only one or another. :class:`BitArray` objects can be sliced, joined, reversed, inserted into, overwritten, packed, unpacked etc. with simple functions or slice notation. :class:`BitStream` objects can also be read from, searched in, and navigated in, similar to a file or stream. Bitstrings are designed to be as lightweight as possible and can be considered to be just a list of binary digits. They are however stored efficiently - although there are a variety of ways of creating and viewing the binary data, the bitstring itself just stores the byte data, and all views are calculated as needed, and are not stored as part of the object. The different views or interpretations on the data are accessed through properties such as :attr:`~Bits.hex`, :attr:`~Bits.bin` and :attr:`~Bits.int`, and an extensive set of functions is supplied for modifying, navigating and analysing the binary data. A complete reference for the module is given in the :ref:`reference` section, while the rest of this manual acts more like a tutorial or guided tour. Below are just a few examples to whet your appetite; everything here will be covered in greater detail in the rest of this manual. :: from bitstring import BitArray Just some of the ways to create bitstrings:: # from a binary string a = BitArray('0b001') # from a hexadecimal string b = BitArray('0xff470001') # straight from a file c = BitArray(filename='somefile.ext') # from an integer d = BitArray(int=540, length=11) # using a format string d = BitArray('int:11=540') Easily construct new bitstrings:: # 5 copies of 'a' followed by two new bytes e = 5*a + '0xcdcd' # put a single bit on the front e.prepend('0b1') # take a slice of the first 7 bits f = e[7:] # replace 3 bits with 9 bits from octal string f[1:4] = '0o775' # find and replace 2 bit string with 16 bit string f.replace('0b01', '0xee34') Interpret the bitstring however you want:: >>> print(e.hex) '9249cdcd' >>> print(e.int) -1840656947 >>> print(e.uint) 2454310349 Getting Started --------------- The easiest way to install :mod:`bitstring` is to use ``pip`` via:: pip install bitstring or similar. If you want an earlier version, or need other files in the full package, you can download it from the project's website. If you then extract the contents of the zip file you should find files organised in these directories * ``bitstring/`` : The bitstring module files. * ``test/`` : Unit tests for the module, plus some example files for testing purposes. * ``doc/`` : This manual as a PDF and as HTML. If you downloaded the source and want to install, run:: python setup.py install You might need to add a 'sudo' to the start of that command, depending on your system. This will copy the source files to your Python installation's ``site-packages`` directory. The module comes with comprehensive unit tests. To run them yourself use your favourite unit test running method, mine is:: python -m unittest discover which when run in the `test` folder should run all the tests (almost 500) and say OK. If tests fail then either your version of Python isn't supported (you need Python 2.7 or 3.x) or something unexpected has happened - in which case please tell me about it. bitstring-bitstring-3.1.7/doc/misc.rst000066400000000000000000000137471365434337700200170ustar00rootroot00000000000000.. currentmodule:: bitstring Miscellany ========== Other Functions --------------- ``bytealign`` ^^^^^^^^^^^^^ :meth:`~ConstBitStream.bytealign` advances between zero and seven bits to make the :attr:`~ConstBitStream.pos` a multiple of eight. It returns the number of bits advanced. :: >>> a = BitStream('0x11223344') >>> a.pos = 1 >>> skipped = a.bytealign() >>> print(skipped, a.pos) 7 8 >>> skipped = a.bytealign() >>> print(skipped, a.pos) 0 8 ``reverse`` ^^^^^^^^^^^ This simply reverses the bits of the :class:`BitArray` in place. You can optionally specify a range of bits to reverse. :: >>> a = BitArray('0b000001101') >>> a.reverse() >>> a.bin '101100000' >>> a.reverse(0, 4) >>> a.bin '110100000' ``tobytes`` ^^^^^^^^^^^ Returns the byte data contained in the bitstring as a ``bytes`` object (equivalent to a ``str`` if you're using Python 2.7). This differs from using the plain :attr:`~Bits.bytes` property in that if the bitstring isn't a whole number of bytes long then it will be made so by appending up to seven zero bits. :: >>> BitArray('0b1').tobytes() '\x80' ``tofile`` ^^^^^^^^^^ Writes the byte data contained in the bitstring to a file. The file should have been opened in a binary write mode, for example:: >>> f = open('newfile', 'wb') >>> BitArray('0xffee3241fed').tofile(f) In exactly the same manner as with :meth:`~Bits.tobytes`, up to seven zero bits will be appended to make the file a whole number of bytes long. ``startswith / endswith`` ^^^^^^^^^^^^^^^^^^^^^^^^^ These act like the same named functions on strings, that is they return ``True`` if the bitstring starts or ends with the parameter given. Optionally you can specify a range of bits to use. :: >>> s = BitArray('0xef133') >>> s.startswith('0b111011') True >>> s.endswith('0x4') False ``ror / rol`` ^^^^^^^^^^^^^ To rotate the bits in a :class:`BitArray` use :meth:`~BitArray.ror` and :meth:`~BitArray.rol` for right and left rotations respectively. The changes are done in-place. :: >>> s = BitArray('0x00001') >>> s.rol(6) >>> s.hex '00040' Special Methods --------------- A few of the special methods have already been covered, for example :meth:`~Bits.__add__` and :meth:`~BitArray.__iadd__` (the ``+`` and ``+=`` operators) and :meth:`~Bits.__getitem__` and :meth:`~BitArray.__setitem__` (reading and setting slices via ``[]``). Here are some more: ``__len__`` ^^^^^^^^^^^^^^^ This implements the :func:`len` function and returns the length of the bitstring in bits. It's recommended that you use the :attr:`~Bits.len` property instead of the function as a limitation of Python means that the function will raise an :exc:`OverflowError` if the bitstring has more than ``sys.maxsize`` elements (that's typically 256MB of data with 32-bit Python). There's not much more to say really, except to emphasise that it is always in bits and never bytes. :: >>> len(BitArray('0x00')) 8 ``__str__ / __repr__`` ^^^^^^^^^^^^^^^^^^^^^^ These get called when you try to print a bitstring. As bitstrings have no preferred interpretation the form printed might not be what you want - if not then use the :attr:`~Bits.hex`, :attr:`~Bits.bin`, :attr:`~Bits.int` etc. properties. The main use here is in interactive sessions when you just want a quick look at the bitstring. The :meth:`~Bits.__repr__` tries to give a code fragment which if evaluated would give an equal bitstring. The form used for the bitstring is generally the one which gives it the shortest representation. If the resulting string is too long then it will be truncated with ``...`` - this prevents very long bitstrings from tying up your interactive session while they print themselves. :: >>> a = BitArray('0b1111 111') >>> print(a) 0b1111111 >>> a BitArray('0b1111111') >>> a += '0b1' >>> print(a) 0xff >>> print(a.bin) 11111111 ``__eq__ / __ne__`` ^^^^^^^^^^^^^^^^^^^ The equality of two bitstring objects is determined by their binary representations being equal. If you have a different criterion you wish to use then code it explicitly, for example ``a.int == b.int`` could be true even if ``a == b`` wasn't (as they could be different lengths). :: >>> BitArray('0b0010') == '0x2' True >>> BitArray('0x2') != '0o2' True ``__invert__`` ^^^^^^^^^^^^^^ To get a bit-inverted copy of a bitstring use the ``~`` operator:: >>> a = BitArray('0b0001100111') >>> print(a) 0b0001100111 >>> print(~a) 0b1110011000 >>> ~~a == a True ``__lshift__ / __rshift__ / __ilshift__ / __irshift__`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Bitwise shifts can be achieved using ``<<``, ``>>``, ``<<=`` and ``>>=``. Bits shifted off the left or right are replaced with zero bits. If you need special behaviour, such as keeping the sign of two's complement integers then do the shift on the property instead, for example use ``a.int >>= 2``. :: >>> a = BitArray('0b10011001') >>> b = a << 2 >>> print(b) 0b01100100 >>> a >>= 2 >>> print(a) 0b00100110 ``__mul__ / __imul__ / __rmul__`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Multiplication of a bitstring by an integer means the same as it does for ordinary strings: concatenation of multiple copies of the bitstring. :: >>> a = BitArray('0b10')*8 >>> print(a.bin) 1010101010101010 ``__copy__`` ^^^^^^^^^^^^ This allows the bitstring to be copied via the :mod:`copy` module. :: >>> import copy >>> a = Bits('0x4223fbddec2231') >>> b = copy.copy(a) >>> b == a True >>> b is a False It's not terribly exciting, and isn't the only method of making a copy. Using ``b = BitArray(a)`` is another option, but ``b = a[:]`` may be more familiar to some. ``__and__ / __or__ / __xor__ / __iand__ / __ior__ / __ixor__`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Bit-wise AND, OR and XOR are provided for bitstring objects of equal length only (otherwise a :exc:`ValueError` is raised). :: >>> a = BitArray('0b00001111') >>> b = BitArray('0b01010101') >>> print((a&b).bin) 00000101 >>> print((a|b).bin) 01011111 >>> print((a^b).bin) 01011010 >>> b &= '0x1f' >>> print(b.bin) 00010101 bitstring-bitstring-3.1.7/doc/optimisation.rst000066400000000000000000000066041365434337700215750ustar00rootroot00000000000000.. currentmodule:: bitstring Optimisation Techniques ======================= The :mod:`bitstring` module aims to be as fast as reasonably possible, and although there is more work to be done optimising some operations it is currently quite well optimised without resorting to C extensions. There are however some pointers you should follow to make your code efficient, so if you need things to run faster then this is the section for you. Use combined read and interpretation ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ When parsing a bitstring one way to write code is in the following style:: width = s.read(12).uint height = s.read(12).uint flags = s.read(4).bin This works fine, but is not very quick. The problem is that the call to :meth:`~Bits.read` constructs and returns a new bitstring, which then has to be interpreted. The new bitstring isn't used for anything else and so creating it is wasted effort. Instead it is better to use a string parameter that does the read and interpretation together:: width = s.read('uint:12') height = s.read('uint:12') flags = s.read('bin:4') This is much faster, although probably not as fast as the combined call:: width, height, flags = s.readlist('uint:12, uint:12, bin:4') Choose the simplest class you can ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you don't need to modify your bitstring after creation then prefer the immutable :class:`Bits` over the mutable :class:`BitArray`. This is typically the case when parsing, or when creating directly from files. The speed difference between the classes is noticeable, and there are also memory usage optimisations that are made if objects are known to be immutable. You should also prefer :class:`ConstBitStream` to :class:`BitStream` if you won't need to modify any bits. One anti-pattern to watch out for is using ``+=`` on a :class:`Bits` object. For example, don't do this:: s = Bits() for i in range(1000): s += '0xab' Now this is inefficient for a few reasons, but the one I'm highlighting is that as the immutable bitstring doesn't have an ``__iadd__`` special method the ordinary ``__add__`` gets used instead. In other words ``s += '0xab'`` gets converted to ``s = s + '0xab'``, which creates a new :class:`Bits` from the old on every iteration. This isn't what you'd want or possibly expect. If ``s`` had been a :class:`BitArray` then the addition would have been done in-place, and have been much more efficient. Use dedicated functions for bit setting and checking ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you need to set or check individual bits then there are special functions for this. For example one way to set bits would be:: s = BitArray(1000) for p in [14, 34, 501]: s[p] = '0b1' This creates a 1000 bit bitstring and sets three of the bits to '1'. Unfortunately the crucial line spends most of its time creating a new bitstring from the '0b1' string. You could make it slightly quicker by using ``s[p] = True``, but it is much faster (and I mean at least an order of magnitude) to use the :meth:`~BitArray.set` method:: s = BitArray(1000) s.set(True, [14, 34, 501]) As well as :meth:`~BitArray.set` and :meth:`~BitArray.invert` there are also checking methods :meth:`~Bits.all` and :meth:`~Bits.any`. So rather than using :: if s[100] and s[200]: do_something() it's better to say :: if s.all(True, (100, 200)): do_something() bitstring-bitstring-3.1.7/doc/packing.rst000066400000000000000000000214251365434337700204700ustar00rootroot00000000000000.. currentmodule:: bitstring Packing ------- Another method of creating :class:`BitStream` objects is to use the :func:`pack` function. This takes a format specifier which is a string with comma separated tokens, and a number of items to pack according to it. It's signature is ``bitstring.pack(format, *values, **kwargs)``. For example using just the ``*values`` arguments we can say:: s = bitstring.pack('hex:32, uint:12, uint:12', '0x000001b3', 352, 288) which is equivalent to initialising as:: s = BitStream('0x0000001b3, uint:12=352, uint:12=288') The advantage of the pack function is if you want to write more general code for creation. :: def foo(a, b, c, d): return bitstring.pack('uint:8, 0b110, int:6, bin, bits', a, b, c, d) s1 = foo(12, 5, '0b00000', '') s2 = foo(101, 3, '0b11011', s1) Note how you can use some tokens without sizes (such as ``bin`` and ``bits`` in the above example), and use values of any length to fill them. If the size had been specified then a :exc:`ValueError` would be raised if the parameter given was the wrong length. Note also how bitstring literals can be used (the ``0b110`` in the bitstring returned by ``foo``) and these don't consume any of the items in ``*values``. You can also include keyword, value pairs (or an equivalent dictionary) as the final parameter(s). The values are then packed according to the positions of the keywords in the format string. This is most easily explained with some examples. Firstly the format string needs to contain parameter names:: format = 'hex:32=start_code, uint:12=width, uint:12=height' Then we can make a dictionary with these parameters as keys and pass it to pack:: d = {'start_code': '0x000001b3', 'width': 352, 'height': 288} s = bitstring.pack(format, **d) Another method is to pass the same information as keywords at the end of pack's parameter list:: s = bitstring.pack(format, width=352, height=288, start_code='0x000001b3') The tokens in the format string that you must provide values for are: ============= ================================================================ ``int:n`` ``n`` bits as a signed integer. ``uint:n`` ``n`` bits as an unsigned integer. ``intbe:n`` ``n`` bits as a big-endian whole byte signed integer. ``uintbe:n`` ``n`` bits as a big-endian whole byte unsigned integer. ``intle:n`` ``n`` bits as a little-endian whole byte signed integer. ``uintle:n`` ``n`` bits as a little-endian whole byte unsigned integer. ``intne:n`` ``n`` bits as a native-endian whole byte signed integer. ``uintne:n`` ``n`` bits as a native-endian whole byte unsigned integer. ``float:n`` ``n`` bits as a big-endian floating point number (same as ``floatbe``). ``floatbe:n`` ``n`` bits as a big-endian floating point number (same as ``float``). ``floatle:n`` ``n`` bits as a little-endian floating point number. ``floatne:n`` ``n`` bits as a native-endian floating point number. ``hex[:n]`` [``n`` bits as] a hexadecimal string. ``oct[:n]`` [``n`` bits as] an octal string. ``bin[:n]`` [``n`` bits as] a binary string. ``bits[:n]`` [``n`` bits as] a new bitstring. ``bool[:1]`` single bit as a boolean (True or False). ``ue`` an unsigned integer as an exponential-Golomb code. ``se`` a signed integer as an exponential-Golomb code. ``uie`` an unsigned integer as an interleaved exponential-Golomb code. ``sie`` a signed integer as an interleaved exponential-Golomb code. ============= ================================================================ and you can also include constant bitstring tokens constructed from any of the following: ================ =============================================================== ``0b...`` binary literal. ``0o...`` octal literal. ``0x...`` hexadecimal literal. ``int:n=m`` signed integer ``m`` in ``n`` bits. ``uint:n=m`` unsigned integer ``m`` in ``n`` bits. ``intbe:n=m`` big-endian whole byte signed integer ``m`` in ``n`` bits. ``uintbe:n=m`` big-endian whole byte unsigned integer ``m`` in ``n`` bits. ``intle:n=m`` little-endian whole byte signed integer ``m`` in ``n`` bits. ``uintle:n=m`` little-endian whole byte unsigned integer ``m`` in ``n`` bits. ``intne:n=m`` native-endian whole byte signed integer ``m`` in ``n`` bits. ``uintne:n=m`` native-endian whole byte unsigned integer ``m`` in ``n`` bits. ``float:n=f`` big-endian floating point number ``f`` in ``n`` bits. ``floatbe:n=f`` big-endian floating point number ``f`` in ``n`` bits. ``floatle:n=f`` little-endian floating point number ``f`` in ``n`` bits. ``floatne:n=f`` native-endian floating point number ``f`` in ``n`` bits. ``ue=m`` exponential-Golomb code for unsigned integer ``m``. ``se=m`` exponential-Golomb code for signed integer ``m``. ``uie=m`` interleaved exponential-Golomb code for unsigned integer ``m``. ``sie=m`` interleaved exponential-Golomb code for signed integer ``m``. ``bool=b`` a single bit, either True or False. ``pad:n`` ``n`` zero bits (for use as padding). ================ =============================================================== You can also use a keyword for the length specifier in the token, for example:: s = bitstring.pack('int:n=-1', n=100) And finally it is also possible just to use a keyword as a token:: s = bitstring.pack('hello, world', world='0x123', hello='0b110') As you would expect, there is also an :meth:`~Bits.unpack` function that takes a bitstring and unpacks it according to a very similar format string. This is covered later in more detail, but a quick example is:: >>> s = bitstring.pack('ue, oct:3, hex:8, uint:14', 3, '0o7', '0xff', 90) >>> s.unpack('ue, oct:3, hex:8, uint:14') [3, '7', 'ff', 90] .. _compact_format: Compact format strings ^^^^^^^^^^^^^^^^^^^^^^ Another option when using :func:`pack`, as well as other methods such as :meth:`~ConstBitStream.read` and :meth:`~BitArray.byteswap`, is to use a format specifier similar to those used in the :mod:`struct` and :mod:`array` modules. These consist of a character to give the endianness, followed by more single characters to give the format. The endianness character must start the format string and unlike in the struct module it is not optional (except when used with :meth:`~BitArray.byteswap`): ===== ============= ``>`` Big-endian ``<`` Little-endian ``@`` Native-endian ===== ============= For 'network' endianness use ``>`` as network and big-endian are equivalent. This is followed by at least one of these format characters: ===== =============================== ``b`` 8 bit signed integer ``B`` 8 bit unsigned integer ``h`` 16 bit signed integer ``H`` 16 bit unsigned integer ``l`` 32 bit signed integer ``L`` 32 bit unsigned integer ``q`` 64 bit signed integer ``Q`` 64 bit unsigned integer ``f`` 32 bit floating point number ``d`` 64 bit floating point number ===== =============================== The exact type is determined by combining the endianness character with the format character, but rather than give an exhaustive list a single example should explain: ====== ====================================== ============ ``>h`` Big-endian 16 bit signed integer ``intbe:16`` ``h`` on big-endian systems, and equal the little-endian ``qqqq', 10, 11, 12, 13) is equivalent to :: s = bitstring.pack('intbe:64, intbe:64, intbe:64, intbe:64', 10, 11, 12, 13) Just as in the struct module you can also give a multiplicative factor before the format character, so the previous example could be written even more concisely as :: s = bitstring.pack('>4q', 10, 11, 12, 13) You can of course combine these format strings with other initialisers, even mixing endiannesses (although I'm not sure why you'd want to):: s = bitstring.pack('>6h3b, 0b1, <9L', *range(18)) This rather contrived example takes the numbers 0 to 17 and packs the first 6 as signed big-endian 2-byte integers, the next 3 as single bytes, then inserts a single 1 bit, before packing the remaining 9 as little-endian 4-byte unsigned integers. bitstring-bitstring-3.1.7/doc/python-logo.png000066400000000000000000002431541365434337700213140ustar00rootroot00000000000000‰PNG  IHDRYË]Ɇ&sBIT|dˆ pHYs ð ðB¬4˜tEXtCreation Time06/05/04M¾æq%tEXtSoftwareMacromedia Fireworks MX 2004‡v¬ÏprVWxœí—¿oÓ@ÇŸÍÕä\'9÷`Ab1 lLH ˜"2‚… ‰ õ?`érü1ld@þ:VŒüïÎw‰ã¤q\EB¢ïcÙ9Û¯÷}¿|vþùþŽá¶6”Z+­ ­s]–ºTº,t‰cÀ“ÒîªÔ J+…GU¨²ÀcQäªÌ•Ê‹2/TžçP( ®#CÜOÏ¿?¹÷#8={pöKÍÞ´} ŸàœÀkøø<%®3ÇØ}Dñ ÆÛZó”ïT&Gr"¥Œ·´Ï¶×¿óu¶XŸäÅÅ:›$DŽíÒF¹%~´é–Ÿ$á ª¥´™¦)´ÇÏy7ýáH&ã ÊËý6SaõSÑbÖA€½‡Ü:DyɃ`ñöàB;‘ Gå/™üsî|ðF5û.`àÒöž…ï1øÙRœ/ópMÖê s·Ôv¹º¤˜Q33SÜOà3î_pôª) 'èÀØßêG,rqe^ªr £çòo†Ö-'º‘û«áË‘Ñ»øÆ"—«„ÓŠyüFÔéY‡pìFƵÊHt\1õ#Ÿ}÷"Æú)Ô§µþDZ“3^Mßvý$æ–}Tï1Öoè» yοXÕçÍü?„Ãc¬þK<{ÞÔ·ùça‰°öÌÄ®Ÿ¯‰ßÌÏ%ñOá¼¹<þÃOÂêùÛ5ÿµþ÷õ«·jNv ¶úF¼W,"sÑ¥þ÷ñ»[öIXŸÿ6¤x´W>‚+¯à ‰6áêqôîx1=Øy|¥nÝ…á¡|ÎŽ²éÖÎYÖÞ”8=œnõïÉ›ú»òZÿ¾Ï“éÖ@](ꃾ*dOÑS‡w±–°Vñtç19>Ïà@‘ÌÎc&»p’ªÃôgþÉÇ™h#º gOá÷&|{ÇatWÆ«äYgä¢xö±æÙ×Ñ[àË›è9\;Žfò†+ÞÍàMìåÍhdñ&žÁ›Q¦xÃhgî®Ø3Tì*ödŠ=™bO6íï¥Nû}}Ü \C8¡¿´cào4·£× \¯ Z tÕ;«ÌÂ’›TÌâæ°7M›ÅMGӆ˵NÉÂ$ñ°°¿¿¥®ôÕ±ÊÒ_h–nI{<ŽFš¡¿Ò í3' ‹Ñ|{çÆA«õò’Lørí–æ´ÛaW»mâÑ'5=„«¯æ±[—;­tízpç>œ+qnî´Aµ^²oâ‹áͯj¼Yк–G¬ŽCÒw$‡žËÖÛ<ª\±89‹GôŠ"Y:—~íåÒŽÔ¦Cp…³­íªò‰.OŸzù¤í¯;.‘fi’PŠCb!{»Çaô>:»–ŸØ±¨PlŠMCŦ¡b“?ÒlkpP£cܯ«Á±¥Ü­‚O¯!4:]aÐ83ñ9ã¢X±&V¬‰kbÅšX±&¶Xó‰fÍ]PŒ·àá·àï;d’fÐ/4ƒÚy4i…? W ’׃ Êø ɾ]…Eã}?U¢ŠC\qˆ+qÕáC±Z=>l†ì®À‰.<4ýæ¨×P²wªã7›“^œÍH’kVÒÃYg—•ºÏs3“æí˜ù©fæ6(Ü ™‚ù±H7œ9V‹Jù¾¿Ž^ÏNÐh³%¬u8JbÞÝnE¬8)99™Õ{¶-—f­yÉ2ÝfdÜ™w³ :+Öe#Ź£%…ñ¬°‚Î víXÖ•A?Ó úlôÔËœÔQ+ÇÌê#ã£hX«æî$·U©-ÜÚšËBýàÚ1ÞeñŒ Å3rè0ÍdKcŵÑ,`C3 Û¢t ¾%Ú‰J#¼ƹ¶XÛ¼€vW% ½ši–$_®]^†ÞUyôqÁ£ç²¯3 ‹´©áζô›ù³ã|Ç. y-ÓütÔE\çJ‡šGlÌ[ûÎù•lËdNµ«iÏÉŸÛ¹À.\” v%¯%1˜hÉÅäH»M|Ù(SÐKåâ0Á—­º…ÎæÙ<Ñ›ß3È4~3ëF´»±› ŠuŠ‡íxGŽZû­¡âMæ0Ü}kœ†ÃðÚ„Ï¡qÆ5h»•l\¾Ù¢µöMð‹¾AEÁæ‹ÅXùåÀcÑ· £×8“¾až¾™Ý5“]„9s²m8K3íue§¤%oõñ6Q¼MoÅ[€øåpâðc™ƒû5U óq G4GÑŸº(i+F¶ `üœ”º‰¾åpé¨(•T* aäAU[•þÎÃÑŸñÌ0úS Ù”)væŠ2ˆ«°3^T/¹â¦ÂE¯bâ(+2”Î`¨Ð‰¼TÒ)׺©yšh¦&¼I=‹±NÃÌÉЋ¤»r"Ó 0WçI ¿–nD{úÛQô¶ {»h+GmR2þPhIÑbR‚ß2™z7e6ï~n™÷«å[µÌ¹ÄË™ÌÑWRñú[õé íí¾ì§<×ý•çÒy¿õNNq‹ÆزdíÔ,ÙÛ-‘N¼m’ex¡ÌkÏ*3ñ°`Q³Uº©ƒ‘7»GgtàÊÈzŽþÉ…)ZØÊΉQ=’Yüü™æçcϵ-96Qbhtb8ïÐ2:Ðã˜ã.Œ÷5¢”QÍYq5ž•#š}4SîVúƒ»ÒH~âô2 òð7büCõ}9Î3Ô£³}ÄÐÛÓkÁRìRÍHÈŒ†Š©T3uDŽÞXwVT¤j5[3Í×L1v¤§k4cG™ëƒñËùRŸxtP|1qøþƒLdÞ¯÷}¢ø¸èa¯€ýlÜŠýN_±àþÌìtCüÃuüÃïÙHñ^™ø5ìtqBèqP¡BáhM©ŽÏbhÿ@C³þŒ&/$ÿR3ú;iïG: "'xÎÕä™7{$C÷Æb¨c“™Ô†ý u0™¯ƒ)§t6MúìÆÆ.‘üDÛýĶûÉpI¢Ѩ?H >ªxªê¿Šž¹;Ø^ÛM™q†¡‹˜¾Ý”‡ÊhºD…s’¾m¡D¦ww‘“+óF²Si¾<®àk¬ÌÞ™ŒlÒÚÿ¼Ž^:Îçw¿Š&8€ˆ‹ |&‚+'¶ž;¨iâeoìc¯JvÌ3_ÂXº=CžjS—G&Še‰æ™«˜ÍLûyT‚3Û™30:C‡Þ&‹Ûû©äu^òpš¨ðäNšµZòK}aê‹ò>ÐGRÞ¿ìöM`t`Su Úñ´ “þ\üP:ùÙœó(v°qåÌ+ªã<àø½œÅó»úü®:/{Sfš Iµq§Š¹Æ¥KÞÞW>¿›ž>“üœí|lÞjÃð³Íº­¨‡ÞYbNˆäu>MgS:Ó€D¾I>ök™¸fö™i»sú˜wÈ­ÞÄ.Ý¡™¼“fíËûvÍ>æSÆQæ0s ÉõXEž”Êx`R¿[¥šTpÃ|²'À°WÒ‘¿“ÄÿT³’E;sŒB¦mæâµÉ11;Œ´Ùöæ ÔÛu*iæÉ”ÜW.» Ÿ>*ùœ¯eôçÙó:˜vÓ ËHØpG^CŽ|šGVʲOŠ湜hyÏ£Út—mɼ9Ò>í[ˆ,é>°hÄÐ2¿û¦{r¿Þ= ±î—Eç䵌džGoÌ°÷l[ÞlëYfšygÙaW³¢s´Kz¢Iç”è×cÀ?­pðƒì'oÈŽLgÊ©æË|äáHzîÅË*·ÐAÙ7¥ž1m9&O˜/&7±¯26Qe++ÚM«…¤ðZ ßÊtÐH®Ñ9‘+£q,ªnÈ ¸Jnö "ï ‡šÕV±YX±0•ÙŒz¢¾“bºÎôj8Ê0H‹G'îUÀ®…cu ¥´*y¤ÌN#ut÷¿)"§rŠe×쾬iqŸ&'»UÒûCo*Äxµ6 P7žò"ŒáüA‘£¯÷ŒÚFáü©ÔëЊÏeD¢}ÞÓáaéÍܧŸ¾¤¸Àè`aø¯ƒµ93^,`yf1M¼á¨ØΙ}4ò£/ªw7(G—tX_M+u…¦BA2&”¦»wÞŸïVWáN¤ú2aw\Y¢4‘¬$7 x)…ò¤ñŠ®bÁ® vUÓwïI7¶{°#o98P×î«ÃS™•ÌÆk™ÍãÕ¾““äŽj^­<ÿ¤áü|Ò:RÒ:ZKkžÎö~™Ž.büŠè°zíÉŒkóIn¢$7±*öI¡FGÑa´#Eñ\fËÍx»Q÷ú“Àõù*It¦;¤ÂÑÝjýbÖ/ný Õéôk™À^«él5‹A¿©0èÜõLNÄóW̹ £Xµv½²‡1§ÖEQ4r<ËöÅÜ}ÒåäEtY¬þT³¯Ê-ZNåj—ɉ¿^,CU©6ŽfåUšSû*åÕÃÄ}6™õh:ãQâÖÈÝõ«þe)Ä­ŠB`ä…`[ª÷Õ&OyB`…Ž³‘°/fÅÕdDHâmÈÑd|8×Ey9U¸,qüZ‹ãžœ&Ç¤å ˆ¯å¤fx*d£4f#»nU%'‡yJ›”œñ  Jž F1iRò:aâÖ¨•^éê_–R|¤•¢²± \ (49I’&Nfq»xVr2ITLàå$>˜Nš8© nˆ4Rø¯¥"\éê_¶"ÈUŒu¯í­*Ö_ŸœmC¶£sY¬ù•Åš.Cñcsã*A]ãÿÕö UÈe‡ }¹éá{'LðZpÎrЋ& æ?M|(Ù!i°à$©CCiÁã#üx™€¨‘µõDWºú—¥jðFO¹À½_†}Q]ñiõb ËË ÓጸÛ5ôªHÞØåÕ\h爮jÝ/jqÊôk¹bâ4z¬÷'ø1ìhEÞäb½¡ât.‹I&éS¤zÊôOØa»áK½Vív:—ÝÓ1Iå¸+©ŸË6A‡?Ó¬À?¯’]T!ËHþÞÛÝy~o·2®y$Ùü@N`ÆŽâü}/·œ4ãbGÅ4úat:½·ß¾³}ÿ|×ÿ:˜Šáú±4aÔÔ·ZSÓ/¢³Hmœñ°þµç[8w/šÈ¥ÞˆýOàþGjáÔtgû[éÊmTê4­”ü+‹ÆèѨµÇúÝ(ŠÒßißrd=û±õìžÜþçA´£Ÿù?Ñy”Ê«IDàG4Ú„ï#8ƒßðÜX¾/ƒs)\‰åGÈ;SøKà þšZ¥Þ*[9CߧKü›(¶îü¨rçwrñÂiô\ßû¬‘u÷/+w›iSoU¯x&„óÌ=  0+·…+á(ç4Ôé—ò-?J)›·b½’ÏO0ë‰OäÆ^' M÷»%”›‚íèmU†rnŠáÓßJi¸¼*Ÿ*jX¹Ÿ9-¿µy!³TG)üªrçžœzª_r,WóqžRë#,k*K?õóèÿ'Zsìr?•«úÿ¬{hãÚó·àù¸òaÑÄáå}i…³)L*—ÂÇ’Â m˾úWžvžìË…cÙ ß“•š×lZ½š´0e(m.ÔöºFô¥.ÿ$qý?eåúÙŸBm1vRC„-)µSi?}©y§šñ³.Vßù¶QcÝ'oOºv-ïDˆžä®×è¼FçŒÎbÎkt¾Fè|«@çwR¨ùk„^#ôÍEèdÐk„¾†Ý®éýGÖ½FèŒÐ.Ö®zÐW¡ÿ¾ŽÐú~9x©—Ï®1{Ù7³é³×˜}0û#ÙßK øÊþtxÑkŒ¾¹Í×½Æèk„Ñ&óQÁè5B¯ú#4[#ô¡¯B{ôé’gÞ•5úë@g²Fç+€Îë™wkt¾Žè¼ê™wkt^£ózæÝ×è< /sæݡ׽žy·Fè5B·Aè˘y·Fè5B¯gÞ­zгújͼ[cö³×3ïÖ˜½ÆìY˜}¹3ïÖ½ÆèõÌ»5F¯1ºMæã2fÞ­zÐë™wk„^#ô@ù­Ô W‹)B—/ÚøÁºkUhmj¸a•¾:´¾å‡ÏèeKAëÙZìêàÐéd=šg]½WmY¢ w°¡zo“Î¥3ZRÇHuÏÌ+Òؾֵ•éZ⌡.Oײκ†Ñ]XÛ>ÕÚVE7ý…Ö7Ìëz¯Lã>)K«ÔðG£ÌÑ™æhÔÍ<^ßXÔmÇeÇ¢ëyÆ×1%Žmß”X´ B@¹Ç²U«Aè_–%Fã¿ŒvãÍ5F¯1zÑÍù‚_Y|ܔիÔ^TúmY«šÍµÕ µ¿ìÕa4•¯€Ìݠ׌xLáçðä¢Ñ–L¢úDöø©§Ñ4q0%ŒtîXQ[ŒhÒñ‹Ñ@>—~biÁêóUÍå¯N…Ž&ÒûcŒÂ‡Ãýókb׌•ð àõÍX}÷½ßIú•öÜ+_ɲ¡5êÅÊpÏWöê´m ZƒI´ʸ3w´-‡³C+6•~^fºŽmûi£÷áÏÏ{o¤F^žÍˆÏnUbœÏ7¶µ°“ÌoÁÐLõÆö¨‡ŸIÜWr7™1‰J»?’’ʵ×*e†×C’ãGRb¹ä)Ê;«õ'>‚ýOü [r,}ÕÉôk|Ÿù×ûƒ÷çOnã«zž©Ã´–>ŒÊhJù;Ôš©•œHI½•=Æt„ûƒÂÇF‰ÛÏ<×zc?õ·P²¨Åûc©Y§-Kúeåþö¥Ü‚ëÈù—ð×¥OZ¶þ¨1Ÿ3«õåSí[ß\RSëg—ⶾJßný¯Z_øœÆ^|Ü'}õûÔÃ…P‰¿òr¢Mi[ܨ—ãæ üÑÞ²¡v.ËÚÏùê÷K7f—ö©—á’>²8á–A®: ×ßÉ\ÒF-W6¦î/}”&Jó5J¯QzÒk”¾ö(ý›è¾ì;~õe¶ÿÄW,û«Œ©ÛÔd‘¾Õ¸è[Ñ…² Ïu_;Ü/B«­·¤Í“¿–cNÝûoŸÀ/ä½£"7gë‰äç²´ïgÕ­+Ò3»Ì®ñ•9G¢µdSfºÇQâ‰â–ñÀEñþ§À#\5|Tpû×:caVoèøè.P~ƒ¹éI \nRAY0ø‹;”Ö=‚#—ó«Rr¤¡Ý,…ÕIå#ÉÝWz–‡š°ª(Ù_v7îOäìXÊ`"9=ï¢2êKîc¶½mŒ|QÜÿ»b\Gñ¾ü½~—åuå1kíð¢b2èóõCVÅã[æ7ܽ'9µª9T¾’á;½V|ÿuô5Ô挎åØäFÁUÆuáz,Ò'‹>9[@&ÿKFêÕ:šxý­ìÑáã1^×õø{ Ö“˜×üI.EêŸDßG¸_ÈËK’vsùݤœëµ[%EœN¥åá:…CxzSFY‰>„ã‘ÕËH€Iï~a–gÅêÑ-®êL=Vÿ ÔÉíøžüo8£Ö˜òOP“’ÿTòÑô2.Gú³ëÐMð+“ñY"¥»)ïW±6—(<‘cþÑàî\öß™mÈäÃÈß¿ ø”uÙ¿«j=Ëã'XKyšžEÄñ¯M kÂF,Ô£ËÒ„YuèŠøè…™œ!£¼0•´3© 8V*¤& ®O¤.Œe4Ê¥˜HÌ­Dþ¾ðØê®xðO·Å„Ÿë9Foå|ÝWÅŠÊ'rµ¹²QÌÔ[¥F„j±HdƯZdfIõÕîd>ðD®k]Fd1‹¾Oë„£uÿ8ãùÓYóâ[hž{v5šæ–ÚM³FR_°‹3kUV­o¨÷gÓKŽùý\ÿÄ>»ò~WsùÝ$³B©ü_èl[.c´fãf>éefÛɹW˜Y5R¸+£ÑòÊŠ#ñ¦òíèu(ïúÊ1wµÃ°üŽ¤$b9·÷PæƒFRFLúí‘î³á_!ר˜yë¹ÉøýùÔA;_}ßéc‘õ¾¤|÷ßË<Ú<ƒ¹n5Sü ¾suıè{Z?ªsì1>Rë=V©!³jÐ5BËd~$e¨03“q{3™e26Ç¿ê7sÙ£_¥v‘Ñ-£¼Uó•W<ì^òje2–箞L~åô1’£Xâj£ÙÙµXµ¬pTj5²ú9Ns¬={x{¬¿áªÀ¡Ï)¥õ‹r\a¥ò©—{IA©ì•¦²wŠ+ Ù+YD~íÿ÷¡U;ÅÈjõÜúÝ¢—ýnQw]px…oÉŬX¶W _¿ÎÖ{»Wmä*¯X®Öü¦®Xþy¤v•°×‡š¥îËv¼^Ùxóê×#¯ƒyk žo—Éd &1s¹]WS»³/…×ûF\¾>ûFd­QØ]µïGa³ûï#‰ ˜ç^Õjé5/‰»ïßsñH\ß-pÅk,¾yXÜ>"–kɧ{}ãéþÝÁûó­í‡Çç“ÉHþ›îª_êßtw¿Àì_È‘6µû*Êk\ ö¤†ÚO¯ì<><§»ƒ­c<ÜÛ•‡þÞñ9…_ƒãs2Ý=Ø‘·¨k÷Õá)¦ƒ§[ïÏUÁ?…Fª´Þ+hÎ7ïÏ¿Û‡{²xz_ýï^ _@+vŽÏÓɘOdŸ`ðtw9„¦÷žî¿?ßÝ`¶àaÿ¡lÉþ]É䇰êûx ˆíôO`™Þݨ}lóÝ»Ûò×Ýyè•#¸søiÆÓ?îÿÇñ¹Àc_ý|¬ûøü×»ððÇ>Þ3„ã=õs€äþØß’|}¸/úê¶ûhÿèجé·úxótúuÿ!Þþ°ÿ;êð°/eóèY_ýêc3ïöÀýÁàÄl—{$ÝëŸåQN$Ÿ>Ý…{ó都Ì(O´ÿþ]ô¥ü ¢ÿ¿;»ÿ$íãÍôáÓö÷>Ý“LìªaýžîÜÅýݧÒOõPÊð{ ~ÿ3`ì™CG[Ü”öò#ü¿©GضbfQåM7õL…M(oúh¿?‡?ÇçÉT&ê@Ô!vpÜÅûAÝÅT€Åƒ»e÷¿“·ì=‚[öa›Á­?|òyx÷Øç7_c+ž(yèëC¨Ô™Næ14g¼¸·-µiGÉpû!ï=¤³ýdÄC÷×ûøG*“<±?¸*H`l_ýJ8~ÖHÐ ¶ö¥õTí°öÒ®!²q:<~:9œÂ—g“s–M÷·wQTû}}~¿¯Ïß3'îé»æÄ®>±5Øßa>èKÔØê?ÄDö÷·Q÷·Ì>"‚³!yžëíDWuÊŽRÐÏþÎ䜧|ºõ=PÜú~+¿u÷{€®é 2œöDšhR“”hR=‘'TÐ 1ÞKIByV'–Ç)ÕÄâ^šÆ,SËzIJRÁt ZÎR¡é‘”•ôžÆYˆHÐó45§)ïÖTÁ{4ÎâØ×T¬d8¤Œ$suâ,‹ ò«D.ÒTÊ{T­)¡†éIš)Jq/fx:L ªžr­4Í &ÚR‡¼G²4åÜi]– 61’gmôŠuåéaY!ÊX®HYdžæ ÓQ'VqG¡ª´Óqò}¥G-ô Hm#¡gÐ$Á‡ Í@Ÿýƒ>Pž~{ñJÖ}ç‰Dø–?’äfÐÑf …¸ä£åEŸÙ´$,ùh5`O€‚’‡šy´’|´¼À …UÓ JQB’NGmˆ¦£m @ 1ÉOË=ZˆI>m¨AO€b’_«ä ÐAHòkºw´hÕq'@ )L+Ü>„¤0*tCè3î"”­CàU…À‰ó‡ÀpÞñ„ã‰6!pVutŒör z’jÕe=ó8¦F)’Øxàœ‚V’ãtéY±pBŒ ŽÅBB^˜ôò”ûbá„v«™KÌniN ³^ž´›PKÓ^žC+¸ŸMx ñ\äy0¶v1KD·–%½:¹œñ$éZ%›’ÛF‘¤-xÖ åU¸jÔÃj%ޘȯ†¡˜(ñÇD^- ÅD‰?&jRÂPP”xƒ¢F ÅE‰7.ªk`(&J¼1Q]C1Qâ‰Õ/%ÞÐh:VxFËCÊÜ`Îo•Žò–œ[þC´/Çp/^ó+èq”kΈÔLç»rtéΪ™ŒC9{|¬Ýè'µûÍÛÀ´3ݺ+Ó«[wûÇçìLç´Ò½=ÌŠlíÁé!ø‰{ò¦¾LÄm¡W…ÖLÇmm}#Û4å–·¤GÛÚÝRɸ­Gêd£Ëé–rä[E}ÐW…ì)zêðà.2øÖ*žî<&è¨vS$³ó˜ÉÃ.Aº³KÕá¡MðñÓÊ™'µ3W1ØøXŽªáˆÝ¦ÙÀwroD¤BT(šÂO°}\†Ävpša*ìà\‡›Œ&VàA2Þ:ÍQñÇ&TE Õ+÷Š+»Î•Ýâʬ˜„W¼;$SºnfªÂI:1.šA'€°„§!–ÆØëH(­‘2™´œöó`ŠÉ!…mÔ’¤cí܆zHÆ­jÙäaEý<\ {’Ý­³4HÇë ›ù¤çsÓ3˜¤ç !ã×Ú=¬Ýà r›,mp›YÇI–¸Î¡¯0ƒ›Az>¯ÐÌÊ 9ŸSXˆ[@èàˆc¹Ö³7xúþ|/Ž±xèÌƧ{1AûÙ‹©Øéã½w8—ìC|Ý¡ƒp&TÙz _2NJ'‡ÑµÇë0šÞ~^M{¸fCj6¹Y€Û€ŒÆ‡bh;kl&¤˜`6J—À‰8OS­{•î¹7ì:7ìº7´McJ$OAB,a:Ùw8r«9DcXÿ%‚‡‡¢£ !WKè{„<&à¨h…?û>þŒ‡i+ 4yenõÖšÌ#àoÐN<^îŒO.±ž`D¦æ’ï#ÌÞfÒà;â /M@÷m29¡ybÈ·@HÐÔ f‘!8à ‹M?”°œgAŸœ€"WéОàà7‰¡è–2š’0a‡.½$a˜ž×t€=<ÍâõI,:¼—CˆAM¿,]˜$-è¤(šaª\§ á´E³2‹ „cy¤¤zr‡N5Õ:š ‡Œ?' ƒÉ9o^lá,[9!ì nm¶Þ¾¡¶ÝFÇÍh홋ؼÁÝV"¼Ž[Fh놟ঔ7dㆦÖ7üuneVAá}€ÕÝeY‘Ú _“ˆJhÔ*_oñÇþ·ïÏÿØ¿úIôeôEôÕü|5û%ë·Ñá³-MðLºeæÑm`Àçp¤ZùÕÛ Fp¾ÏåH¿Å¡×©œyëW~pÂNI+kz"É)lo%Œ;ÖÊ_¿Ë–å,ù^‡:¶•q à(¹/Sütó¹ T&z£†šiFê튯%äÜcýŒ¬ò}Š’'®ÊQ*½wyñ\†Ñ©~f"9£ñXÞ÷;ª åM¸c7z­ß!7*B›×ÒÊ0|<–g¢ÚùH¢Às}÷[½nORCþÞ†{_jÀVN {OKø%|³KÙ¯”ñŸ€4ÿý¨,BƒH¦>‹Ñ¢K¨ŸõQ²<‘²™Ío”¶ r^êAÚénÈýTÞÊà²I"ÒY–réË7;Oä.,#tŒôÎÖ8¿èÏ2Á:¼Ö]ˆ éÄO5-£M'ºÍ#yeܨÛPçWÚ~±}/¥*NTß—ú¼àPÙ¢SLFæ}ªCÉ¥cÝÍx+ðS݆*gL­0¸|)¯ËûŽ%ŸËzß1h´²'²ü·ò>Ü Gí>ÔûÙ3¨C$]ëª×©¼nc_õ:“×m,46lK÷NgÞ—o’B©4y¬y߬ÛFz†z5êP;ãoÈwÏ(¾/ YxÍ ô›ëYZÀ‰Å ¹k¹äÜÄj‡‹Æ¿Õ|V;$½Ó4ËNq©SHÁÔ­ÊÛyö&úýÙŸöèª;ØƯß¿ÿ^jøèÅ>peCê¢þ]¸òVnZutù÷…N¨{•÷TO|¶o,ÞØÛ‰Öź¯8ûoQ"Jw¥¾Ë~#5x"ŸTñ¢ï{ÙÍRïo Ñ¥ºE•-}ViÍU—Ð<®º¤‡šGJÆÇ…·8š ‡L÷öt¿.nkù6ðá­ôO˜†Ø/:ùe»P[b@w!ßXö{ëù?É72Kœ@Þ–T§Áôóês¿¯•]êê ˆ-6œ² ƒˆS=sË:ß÷”{~•þŸ8д͎¾n7ØK•Î¡Þ¶òO4·[Ѧn‹µ%\‡:'·âÆjMÚ?Õµ>÷$jt©K»'ÚÔÃÎ(ü®ñîiñŒkÏ­eTÕlƒÁ#9H¥pÖo##™›0}»=‰²XÚ¾LaÿÞ¡÷]·Uæҽ㾅ìÂsǨrÇyô¸¢jÙƒïˆëg•3gÀ÷ù·•çï"„}TU"e-bYÚj©ŽT™>rë¹ùûF==€ñ£ì‡¨z G[ã–Ý,ÇöùŸßWJEž·+u$ï½TíçÏ:<æ<ûJ ‘Ÿõ#£MËä(²G3‹VËÏ¢ ÞdžñýIŠ‚Œ­=í‹oêåæ`ÂgŽ&i±ÚOæЄï¢MKÈÚ@–¨ dm¨sc~m KÔº"m Vûé´vÖ†;€æöóËÒº0>Ô)tѺD`+ÒfµŸ-è)Ø‚ÚÀ–¨ la|¨Sè¢ l‰ÚÀW¤ Üj?Ÿ îÈiH6•î:á£ÒV3>+øgžìª´Æ‡ùõ€/MTîd¨ÇRFj⇔ø=¥Ì*–Yv£íâ[óíÈŠ%íüé¾,ù¹££ª§ƒ5ª-ã,Œ¶¿“ïË¿oåßÙ½áYý¥v½íÓ†ÓyD}2¹-?g¾ŽpôÐÎÆ`ïé½ì;áýH¡ÚG,{od^Weá°„Ûú½¬³òu8W¥Ü­·SmMOêÐ Éÿ§RoŸÎÔ¹¸’Ók¦ôLRz¶JjÊÓ[)µÉícyu é«e7.¸¥½,$ô6R#m³êíÚl­ÓtºÑêÃ=£¢‡ÜD«˜VP›ÏzKÌW3Êó¯àÌXrÒœq­ªjM[òÝï ý¿mµîóV9KúO ;9•y@ 4ÿ½fI¿s¬·=õeh¦©YjÝž-Eëú²ˆ&·¥ÖN—]»¸þš|Ý°ÕX×¢ØÚÍ^fÕû2µ{™8½JÝ&KÕíEsŒWË_,“—ë/–ëË–ã/–÷,×[¬6òY®M-â/Èô›ÑõõW?²¿xí¦WÆc¬ÆÎæñ›WÚg\-¯±îe\„]Ý4¯qó@놺Z(M¯4J“+‰ÒëØ~•Ú¼Z”nGiu(½ŒÂM‹ëW¡Û|Ôs!õ²j·Ž§¯Ÿ6_W¤¾ÎY˜u\gÄ•Éì¦çzóò0WËo¬#ü‹°««1Ú»<¿q]}Æ:ÂÇ3É•ñW/+´ì¼Ë_ƒÏX÷5.®nšÏ¸®Y¡u?ϤW©—=Žù×ZG÷­Í³Ú¸¬µm<Ã|§ÐSÇrµÄÛ ßUŠÖO<«=±èÚ¢eHrÖšn» w]bÀàù‡ 6Ø+ê›Êy©½L>xÖ‡Ä-õ®ûšï² ²Ô2ˆ· ºÔ2¨· ¶Ô2˜· ¾Ô2¸·Œ*âµ+£zº%~gµÉ¬²«>é/ý©ømÖ±¾Ó-ñ~ÇU,~Ö¢D¢ïtK{,)Lg‘6Ž=vµ®ÒÆëV6‹o]¢h,±nsa9¶)1m,Ñm¨ýÑp×ä€Ú¾=ÜÆz±Þãc¬÷øÀ|îY™7Ö;1WËQTþM?óï…VýNÓñÑ 4ˆ‡ñjõÐ ’-h‚õJÉGƒ94Ø ¸ÃÝËï¢?€-«ç¿ƒ^ÕîËï~?X4 ]Ü«yÅc5>ó­ÎDIË¿§Zªô2øíÌzÞÞ›ïvÅ›®ï0þ¾ºwP\Ù±§çîŠä£Hj7=7;P¤K§È–ÒêiMá^Ê2û(õ2ý=•¯Š¶¶{²ì­Ø9%ßSjg槵6vñÍ~ºè5棻Ý)0Ì.CY”Û“iÓÿ¼*òõå"|Y‡ÙÏžZõíòl5ÓàÏ)tÑÊÙº5ŸFºe™§ª>çúèr¸¾Ï:Ñu#ñæúÎGw–í…Z»»l¶‘vºÚd%Ýžví¤5Y‰›UXþœ7±Û—úÆ ¿›ÛBܼª²˜Yå´±)W÷ïxÛt»eÌÙ®…u Þô¶pÑRW¥ÓWË×,fG‹x›E¬h]ÒÞÂü«—í5‰¬ó‹ÅV>4Ÿí5ºXˆßsÐÖž£ ~Wuÿbð;¤µã«–­ÓŠªÛ½˜\™;—QÝAtU¹ _ž`±\†/O°X.cQŠõ\Æ<­^ç2æóäöø@ÛÝ«3o´ ,ê&Æ—×3—qQZÙäso’./•Ò ŠJýtÃO¬s×1*Ýœ+KxÇÛ²››.S³¯–ǹžëŸ=oç þz¼Ì|Ùsÿ uä&dÏ]›Ú¼Ô¿zÙóytZQ]M„Ω¾7ã2ó ]r íò ]2+íò ](¶Ëƒ„Z½ÎƒÌçÉù úŽ¼!BohTz=ó ×?*õëÙEéïâQ©°æa·µ½ùÊhïÁý«FÖyuT:oTêZÆÅä]V¥ÓWË×\Ï È:Z®¹|¯áßf˸Ùó®6µš¼¹k ã«–­ÓŠêjrlî\»„\Æ¢ó%Ú­OY,—±(ÅvëSÖ¹Œ‹ñäî*Çeyï´ˆš³üì†Æ—×3—qýçt\ž./•&•ú醟Xç2nbTz93/?*]¦N_-_s=s×?o~Ѿæ¢üËEæÍ»ûÿ¾Yë ÈMÈ›_ÎZÈËϛϣӊê´òÝíçš+e¿™[»y¬ÞC-Ž¡ö >³ßú®öœÁï"Xê"«·Í9ê;k(wÝš§¾”»‹bÞF¯ä“˜á(¯Ï¿’è²¥ÞÎS_¤¦ÜöìEdv3º-ÏmFc½’Ë–è"+Jæ÷;óÇe‹xœ‹›é¼H”ºˆž?F7SZôEg_q9?¿ÎÃ÷ÅýE[¾/6‡ø¢m}o÷lÛ Ë×øÅ8ïó£´¥=õ²ýèEøDjíñWõ‰DúDZó‰[Ùz²È\Æë†~7àæáQ³¦sàѼÙÈùJ»¾r^v̹Z‘ØUÅSæÁSÖ€§7»îæEÝ˵Ây³BË·ùÅäì‹xXˈgö|•ËŽxÚ ¬:"YdFÂuÃç‹/»èÔ.F`KÆ‹«Îù‹Ï ,×k³@fuòÚ‹WÝŒH½]¶],Æù¦Ñ”±åÃ~7ã 3:3ë½.÷"|À2ÞéÒì{}ŸË8zi錿”—R¨ fF-Ò>©Qµ¢f×y¯ í§Y}¿ÒÄw*œ5œï{(ã ,µ\}0Ö¿l©cä¤f—mÙ€– e¼ƒšu*5õ8êÉ:n–åJDy©·¾mÈò‡Rƈ.oà©2~ù\îð"ÇßÀï3ù«:¸»èº™™ÍÕ9€H­âÿÂGYÐœýçªtPÒ©÷%¬É¿4H`ÖLéß;zý%XîWWðóÔÌÔϱÎþ<‰Nt­¬þXJe,±Ï¶äæ·nÍúTëwÙ¼šÅ?UGìW¼•qü;©Ÿ'’/ Y‡’GÒðŽ?Ãß#©ý·AÏðí%gR77äc}žÊóTkl uCcCRÁãý&”òiƒÕÞ® ÁIôßRÇ«çÞHVÔ2ºTÖõŽ…%æî³âî³ÊÝŸ{íâKÙâ1|Nä· IE!Îç]64bŒ5ŠlÈ’§OM\Rô÷u=«^ÃöŽŠoŠk6Ïš(à[Çþ2“NÓ÷î¼pÛZåΉĤ‘DÁcmU^)J'ÑqÅ»ñª]Kßè¸ë©õë™Ft=µ~=kðÜXúQô¨ˆVBQ«ë§6¢ò­vfv‡¢©|Ð+ˆ&ïN¥f©v+®›7 •ÜWtÝ:õ,JwàS¯ÅÒÚʲ›h›v›™¸Õ.ñ?u0ï^-ßV­K?X—•œ~/}Û;I_=oj¥"„j$QFCå=gÎ=gž{JM1Ùó»ùÞgνÏ<÷–Zf¢'ó»ùÞgνÏlÓÅvÃG5/ ã•w2v{-c‘IdÞõöJž?¬Ä+u»sßv5l°‹—ÑWúWÇ–¶MdL¤¢¯¯dïø¨¦x¿ŠõȺú–ׯ$µ.ï¨ZîûúT Œ n{k¾º·6#«‹0ÕŒ¢yÖd O Íî¾d$Æ|;k<çfÔ=w¢ú{|˧ݵ¢æ{÷¯ºòy…7fÄÄnŸi÷æ…´ÛWßõýÐÈ—³F¾øùÛÔîÛ §›Pß/$õÕɘÌ!ãYíŸG£Ù~-n'á¶Z–ðYEÂÏ/E‹·¿YÃë2v­u52^\‹‘qÙî«aÅó X¤n’ñÅ"õâÞh>¤ö{p¤± ¾ûµìýŒ#_&|VlÖ&7V½ç.”õbF¶Ý8h»7,—µ¸ oZDµÖùFßDõÑã’ ö&ò‰Ó¢¿ë{ç­ŠþË¿¾oæoy¾~Ö¾¦êÒ5?‡OnÊŒ“ú«è«¼M‘R¿ˆþßÔa³òË\Ÿ¯.Äi=±¾mzJ5eÚ5Ü,ê;VöÑ•WÅ[‡Ë7Õž€NÆúÛ™þö¦Èν‘¹±*ÍAdú\è­˜wÿÚ±vS?ÏìÙ•Ùñc‰:Õ}4Ê]=|Ö\æÊKj·t+mßßèLáWE[}3^UìäXz"{ÄêÍR0â¸b©f^GwëTõ‹'g§©vý—ó,iùì+oãÖØ/¥+fü}J©C§–Ù-W(ûÆ‚ÞTÆ‚fÕÚèS,ËĽVJSžYçTÝp•U*uë¿ô(S»^x]÷Œ±è1гñô?å½_@­¸÷Ž¬Ñr|莅骄³%—àJ¶j'Ë)ÖJ8[r ¬(Á¶Œz.OýP³¡z&O=óÜéæñ M5æ t ù)—¾yê¬öñÖŸTÊR²j~ê™õÔYñÔ™÷©z»ˆ‡WÄÛRá•—%r™(¯¤gV@ºcíW}L­ë˜$fÐëoAgúß½¾<€Z쟧“1ŸÄȇÁÓ]Cèãè¡ž ²)C8œº´ Q¡h ?É<ÏÆ’·[ûØ€ýdëîã¶ãàÜÄ“ÑøP §ƒÇOÁ˜X_žášL÷·wQ6û}¼Â{‚0Ôöýþ3‰¤'Ò<Îà¶{öõ{îõ]ûú®{} *¼¿ÂÐßÆ·úšö÷·YpÙèÍzY,ž+uˆY"åë# ' @›l×a2Œ§ú;`.¤Gò,ålºõ=”´õý6²bëî÷ïÏ3%yÁÁ¬â”¤XHÞˆ+Ùôé>üfiÐŒf\ÓO‡DчR{K%¡ˆ‘Qæ)› Ò¬(œSD6¤V(•%½ì1K\íûX”™¢O`m³ ‹ú$å=Ê(§Z$‡ŠB Y®K¹Õ":òˆä9<ÿR%…‡¢«l9WKè{ä<&VXˆIŽšVy´ïãÑx˜¶‘±†‚8§ EZp ™ÈþA½ø·÷в }bºóD‚Xi+Iš6±OR§¡$³¡Dd1ÍK™µ…¶ÌÆ‘Ñا±6³ÁDd²YÖú3LDA5c% ´õC™ &"=NAeXG·˜9`Ñ!!qÙmtæ` §²Bîmc†ì0v逾$—ì¸4¼u€ FÖjŸô0ŽöÓ«´€åQ0´ Ç„8 ‡oh±yäÖÐ[À!¥ iѼt–BøMA#y‹–e³,ðp?æaܺb[,ÉÀ´1ÙálÁÎ8rÚ†Õ‡³@䬨%i˜ÐhÊ’\%¢l BãY¸Or-g":šáˆHJŽŽ¨…MfyFè‡@×QjUˆ$Ž¯†^`¯a-rÐĉPÑC„¶á!ÏÈ>,Æ3a:N8ÓØÛÂn·»ÖrØÉö³£ÓÖ­ÙpâËí¹>²ÑÄ ÞÛ«ÁÈ»/Ñ^-G3»6ííddC‰ÓÕjo·#Iœž_{ Ù@âôDÛ#ÛÈƧgÜjG6ŽØÝôÖÈ?²AÄÉ´÷D#CœF{×8:œ•Qiï«G6„8 žö±ÃèÐê9ɦֱÌèP8d’o:˜…ó¦ÀͧM§;ƒ»2ƒwo·¢øYô$zÿ÷£{ÑŽž°ÏÝÃñ¶í{øç¸ú¯ÑËèOÑa´ËY?DßÉqO\ññ8z%×÷þ ä|ž7rügæœ-œ— V„<û©ñíéÎö·@õåÌÆ?C-˲~e=õ :‰¾•óGŽ¡ü•gõHëÙ­gq=õ(ìègþOt¥òjøÄr§ƒ$ÂTÎ#‘Ú.ƒs)\‰åGÈ;S¹ƒB&M­RoÉ™¦ïåŒ&=ÇR—ø7·îü¨rçwrÔë4zÞpï/+÷–«ÙqÜ©~âoebç©{@׫ ¢çz4ú¹få牻ÅZ¾œIr*}N¢ýÄO°ë™Oäü è„ÿ‰¿‰„SÆÃb”ÜÌÒki‹2X”9¼*Ÿ)jXi9sʸuy!gÕ¤;VÞ¹§w88–«ÔqÕåÛ>ý 4ý]¤vW°%ƒ´ÌS?þ·œï¡?…O‹µå[z5θöü-x>®|X4q8y_ÚÝl “ÊÇ¥ð±¤ðB[¯¯þ•§'Õü½±l…ïÉJÍk6kç^Ë]våìzÙnÍ]*Éò±ìÇ@ëÿ)+×Ïþ´Ü§Ã©ó–”Ú©´ ¾Ô»ÓFÍøA$}çÛF}uŸ¼U<éµkƒÃú¬»ʲäl<µÎå«­›þ±ÿíûó?öû'ç¯~rÕ§‚¬§úÜì©>×¢Žme\8JîKÇ¿Ý|.C•I¤6ƨ/kU“h^Kȹ92ÆúYôÂh{+ ¥÷./žëícÌbê‰äŒÄcyßï ¬2”qBòn±´Ãžþ]]ÈŽå„ì#‰î4¥ž¤†ümzf»Iæ8uXMöŸŸ‘4L}£E—PœèûyQ%KµÂl~å$bäîK=ûgC;]Ürkó£<ç—Ȇt–¥\°ÞÇ2@Ü”ÂÕ4¥jë …¬¯u'bCoÈsTÙ>bCÖû…Ö:å*ýZ° u~¥íÛ÷"PªâÄ{I¥º¥‚Ý¢S½lªÜdBmÙ2Ñè –©6T9cju*78’¼9ÕÚ¨ÔËøŽA£í”uP[Š¼•÷ åR–c)Ù5*lÌ ‘tm¬«^§òº}ÕëL^·±ÐØ°-Ý;y_J¼I m¤nÐä±æ}³néêÕ¨ÃlÖs(KD¾/ YxÍ ô›ëYZÀ‰Å 9u12S”ípÑø·Q¹©Ìkü"Ͳ[\êR0u«oÇuýþìÏ@{tÕœo³«ëé÷Í¢¸f1›oÙbu)º·º ÆgÝ&Ãý¿·(‘ ¥& ×èÒ ÝÊ4àâ¾ë ¡y4\uI5”Œ oq4™îíé:]4ÜÖò¦%je»Ô‚Ç^$àc–6šçÿ$ªm¸·¥Õi0ý<¾+vžUÛ_]±Å†S6.;2[>ÅpÆöâjîWŽïV›´}Õ౯º„Áp{Ëíem\xý4¼Š¶M‘‹J|¾•‰0Å{¹ù"½Ï¤Öý(1×lÞú@rSÅjŸU6†­žï{ʽ:Ÿ»[ÖúJ¸Ý`/U:þ-l«­hS·ÅÚ®C“M[ÔVkÒþ©®õi·%oµ.í7ñ Õ£isa÷îY[´•‘#‹—ryú²6æý®‚Û*séÞqßBvá¹cT¹ã<ú\Qµ4›…œUÎœgÜçßVž¿ˆöQ¾MFz³ƒ‘Þê`¤·þĨ#ï´™ZsßÈ·!™p´5n‰Ð‹n2`o¡f–(·)ÕlóÖyþ¬Ãógγå"àÙÏú‘Ѧer”Ù£™E«ŒågQHëÇøþ¤@ÿæìæi_|S/ÿ3>s4¬HˆÕ~2‡&|'7f²iÌ« d‰Ú@æІ:7æײDm +ÒjµŸ.Ahgm¸hn?¿,  ãCB KÔ¶"`VûÙ‚ž‚-¨ l‰ÚÀƇ:….ÚÀ–¨ |EÚÀ­öó¹ð᎜ÄcSé®>*m5㳂æÉ®z@k|˜_øÒôÀlÅ®ÆRFjâG¤¶YWPʬb™e7:Ð.¾õo9gçOÍÆ„¶Ž¶Ù2ù;ù÷~eËäÙ½áYý¥v½í¦-™í—¢5ÛM÷ 5oë|»xÁì×å ”»õvÂ/\kÖ¹¸’ÓkóÒ÷E)©)Oo¥ÔN$·åÕAT¾TžtäB›.5×ÛµÙð+˜¥U}%S3­ú‹š–»a¤ïœ®UU­i >¯åÛ¼Šié›Í§ê—º›ÎG}šYß uu{¶=®ëË"šÜ–Z;]víâúkòuÃVc]‹bk7{™UïËÔîeâô*u›,U·Í1^-±\L^®¿X®/[Ž¿Xfܳ\o±ÚÈg¹6µˆ¿ WÐ_¨W7]OŸqõ#û‹×nze<Æjìlá{‰ÃÕñWËk¬{aW7Ík\Ç<к‡aF„®JÓ+ÒäJ¢ô:¶_¥6¯¥ÛQZJ/£‡pÓâúUè6_#õ\H½¬Ú­ãéë§Íש¯sfWãqeò0«é¹Þ¼<ÌÕòëÿ"ìêjŒö.Ïo\WŸ±ŽðñLre|ÆÕË -;ïò×à3Ö}‹°«›æ3®kVhÝÏÀ3é•Cêecþ5d…ÖÑýEkó¬6.k-@Ï0_Æ)ôÔ±\-ñ¶Âwc•¢õÏjO,º¶h’œµ&¤ÛîHÃ]R¾‚>¤ öŠú¦rDj/“òUÊÕ•éíô®ûšï² ²Ô2ˆ· ºÔ2¨· ¶Ô2˜· ¾Ô2¸·Œ*âµ+£zº%~gµÉ¬²«>é/ý©ømÖ±¾Ó-ñ~ÇU,~Ö¢D¢ïtK{,)Lg‘6Ž=vµ®ÒÆëV6‹o]¢h,±nsa9¶)1m,Ñm¨ýÑp×ä€Ú¾=ÜÆz±Þãc¬÷øÀ|îY™7Ö;1WËQTþM?óï…VýNÓñÑ 4ˆ‡ñjõÐ ’-h‚õJÉGƒ94Ø ¸ÃÝËï¢?€-«ç¿ƒ^ÕîËï~?X4 ]Ü«yÅc5>ó­ÎDIË¿§Zªô2øíÌzÞÞ›ïvÅ›®ï0þ¾ºwP\Ù±§çîŠä£Hj7=7;P¤K§È–ÒêiMá^Ê2û(õ2ý=•¯Š¶¶{²ì­Ø9%ßSjg槵6vñÍ~ºè5棻Ý)0Ì.CY”Û“iÓÿ¼*òõå"|Y‡ÙÏžZõíòl5ÓàÏ)tÑÊÙº5ŸFºe™§ª>çúèr¸¾Ï:Ñu#ñæúÎGw–í…Z»»l¶‘vºÚd%Ýžví¤5Y‰›UXþœ7±Û—úÆ ¿›ÛBܼª²˜Yå´±)W÷ïxÛt»eÌÙ®…u Þô¶pÑRW¥ÓWË×,fG‹x›E¬h]ÒÞÂü«—í5‰¬ó‹ÅV>4Ÿí5ºXˆßsÐÖž£ ~Wuÿbð;¤µã«–­ÓŠªÛ½˜\™;—QÝAtU¹ _ž`±\†/O°X.cQŠõ\Æ<­^ç2æóäöø@ÛÝ«3o´ ,ê&Æ—×3—qQZÙäso’./•Ò ŠJýtÃO¬s×1*Ýœ+KxÇÛ²››.S³¯–ǹžëŸ=oç þz¼Ì|Ùsÿ uä&dÏ]›Ú¼Ô¿zÙóytZQ]M„Ω¾7ã2ó ]r íò ]2+íò ](¶Ëƒ„Z½ÎƒÌçÉù úŽ¼!BohTz=ó ×?*õëÙEéïâQ©°æa·µ½ùÊhïÁý«FÖyuT:oTêZÆÅä]V¥ÓWË×\Ï È:Z®¹|¯áßf˸Ùó®6µš¼¹k ã«–­ÓŠêjrlî\»„\Æ¢ó%Ú­OY,—±(ÅvëSÖ¹Œ‹ñäî*Çeyï´ˆš³üì†Æ—×3—qýçt\ž./•&•ú醟Xç2nbTz93/?*]¦N_-_s=s×?o~Ѿæ¢üËEæÍ»ûÿ¾Yë ÈMÈ›_ÎZÈËϛϣӊê´òÝíçš+e¿™[»y¬ÞC-Ž¡ö >³ßú®öœÁï"Xê"«·Í9ê;k(wÝš§¾”»‹bÞF¯ä“˜á(¯Ï¿’è²¥ÞÎS_¤¦ÜöìEdv3º-ÏmFc½’Ë–è"+Jæ÷;óÇe‹xœ‹›é¼H”ºˆž?F7SZôEg_q9?¿ÎÃ÷ÅýE[¾/6‡ø¢m}o÷lÛ Ë×øÅ8ïó£´¥=õ²ýèEøDjíñWõ‰DúDZó‰[Ùz²È\Æë†~7àæáQ³¦sàѼÙÈùJ»¾r^v̹Z‘ØUÅSæÁSÖ€§7»îæEÝ˵Ây³BË·ùÅäì‹xXˈgö|•ËŽxÚ ¬:"YdFÂuÃç‹/»èÔ.F`KÆ‹«Îù‹Ï ,×k³@fuòÚ‹WÝŒH½]¶],Æù¦Ñ”±åÃ~7ã 3:3ë½.÷"|À2ÞéÒì{}ŸË8zi錿”—R¨ fF-Ò>©Qµ¢f×y¯ í§Y}¿ÒÄw*œ5œï{(ã ,µ\}0Ö¿l©cä¤f—mÙ€– e¼ƒšu*5õ8êÉ:n–åJDy©·¾mÈò‡Rƈ.oà©2~ù\îð"ÇßÀï3ù«:¸»èº™™ÍÕ9€H­âÿÂGYÐœýçªtPÒ©÷%¬É¿4H`ÖLéß;zý%XîWWðóÔÌÔϱÎþ<‰Nt­¬þXJe,±Ï¶äæ·nÍúTëwÙ¼šÅ?UGìW¼•qü;©Ÿ'’/ Y‡’GÒðŽ?Ãß#©ý·AÏðí%gR77äc}žÊóTkl uCcCRÁãý&”òiƒÕÞ® ÁIôßRÇ«çÞHVÔ2ºTÖõŽ…%æî³âî³ÊÝŸ{íâKÙâ1|Nä· IE!Îç]64bŒ5ŠlÈ’§OM\Rô÷u=«^ÃöŽŠoŠk6Ïš(à[Çþ2“NÓ÷î¼pÛZåΉĤ‘DÁcmU^)J'ÑqÅ»ñª]Kßè¸ë©õë™Ft=µ~=kðÜXúQô¨ˆVBQ«ë§6¢ò­vfv‡¢©|Ð+ˆ&ïN¥f©v+®›7 •ÜWtÝ:õ,JwàS¯ÅÒÚʲ›h›v›™¸Õ.ñ?u0ï^-ßV­K?X—•œ~/}Û;I_=oj¥"„j$QFCå=gÎ=gž{JM1Ùó»ùÞgνÏ<÷–Zf¢'ó»ùÞgνÏlÓÅvÃG5/ ã•w2v{-c‘IdÞõöJž?¬Ä+u»sßv5l°‹—ÑWúWÇ–¶MdL¤¢¯¯dïø¨¦x¿ŠõȺú–ׯ$µ.ï¨ZîûúT Œ n{k¾º·6#«‹0ÕŒ¢yÖd O Íî¾d$Æ|;k<çfÔ=w¢ú{|˧ݵ¢æ{÷¯ºòy…7fÄÄnŸi÷æ…´ÛWßõýÐÈ—³F¾øùÛÔîÛ §›Pß/$õÕɘÌ!ãYíŸG£Ù~-n'á¶Z–ðYEÂÏ/E‹·¿YÃë2v­u52^\‹‘qÙî«aÅó X¤n’ñÅ"õâÞh>¤ö{p¤± ¾ûµìýŒ#_&|VlÖ&7V½ç.”õbF¶Ý8h»7,—µ¸ oZDµÖùFßDõÑã’ ö&ò‰Ó¢¿ë{ç­ŠþË¿¾oæoy¾~Ö¾¦êÒ5?‡OnÊŒ“ú«è«¼M‘R¿ˆþßÔa³òË\Ÿ¯.Äi=±¾mzJ5eÚ5Ü,ê;VöÑ•WÅ[‡Ë7Õž€NÆúÛ™þö¦Èν‘¹±*ÍAdú\è­˜wÿÚ±vS?ÏìÙ•Ùñc‰:Õ}4Ê]=|Ö\æÊKj·t+mßßèLáWE[}3^UìäXz"{ÄêÍR0â¸b©f^GwëTõ‹'g§©vý—ó,iùì+oãÖØ/¥+fü}J©C§–Ù-W(ûÆ‚ÞTÆ‚fÕÚèS,ËĽVJSžYçTÝp•U*uë¿ô(S»^x]÷Œ±è1гñô?å½_@­¸÷Ž¬Ñr|莅骄³%—àJ¶j'Ë)ÖJ8[r ¬(Á¶Œz.OýP³¡z&O=óÜéæñ M5æ t ù)—¾yê¬öñÖŸTÊR²j~ê™õÔYñÔ™÷©z»ˆ‡WÄÛRá•—%r™(¯¤gV@ºcíW}L­ë˜$fÐëoAgß›$ï‰þeÓíÁ³c ûxëÑÉyô7™ûðíŸdêtæO‘+š1žÚ9„r¿}Ð?TÅ%'¤ÇHFYë¢ÿY*Ê)°KM2Ø(‚?5Tp Šr Çwr¸fîŠ<ï¬Hzñ<°¹.ù¢Xe½\U“‰ENŠDº?“ƒ8|ú—èÈ%«þ}û`÷ýyqêáÝgïÏ·¾ùúH=9xˆ‡‡ö€ÒÏ£‡²§,O÷úòâÞöC|pG=¿ýð!èì=øópû¼|ïáÞûó¯öñÏàØœØ܇?w¡Q[ÛÏ'úßtWýJ8~¦»ûHìî ÿpoý±ôk)Ïñô¬ö*^ÁùG’{q¿˜>i¼r°óë´;ØšìÞÛ•‡þÞñ9…_P=2Ý=Ø‘·¨k÷Õá)¦ƒ§[ïÏUÁ?¾–ÝZ&pâ›÷çßíÃ=Y<½¯ƒþ÷@/†/ ƒ;ÇçédÌ'1²|ðtw9„¦[ûXûýªýãÖþàÜDØä(NÇétðø)(,É@3?›œ36ÝßÞEaí÷á#½¨ƒ>í÷á*îÙg侀»öÙ]uv ª´¿Ò}ÐßF’[ý‡qûûÛÇçGp¹P[J{€’41öC„±YÙô(§ú;“ó¼S‘¥ùtë{ ½õý6¶këî÷ïÏ¡µ‚„õò$fYÖ@p’E%½ŒÑ€µÅ4ë±$¥1›>ëãOÞc® E°€*ú$îq–pBƒôÁšú 2!i–OŸîËË´—ržÐ|ú §`×i Žcú‹qÚË2Âx¦ª“$½„ƒÃ>ø9¯jERVÔJÄyJE¨VqÜK׸L"z KÐUµŠ9”“€ö¨ZÁe!xëZñ<®ÄYNu­D/% ¼Ä®M¹®ë–€2jÅ3d~’ĆW9ÈèU+žÓå ¦k•öÙ$º<– U@†P¸Ð­)A -‰  ÆRj$Á{9eyIši$=Êx.BæÀsÖK2Fr£èzcõT"È :„ .´h ;ŽMurPט ÐUJÍiÌmÅHÁÎU­òU P(¨ö~"ï¥14³ÐV¶H”ª&ëÐôÔ.6K‡ªØ¤ç M ÓM( +À)I +D¬Dal*qð^W‚ðI¨¹f6xYU&Ojˆ8h±}Ñ4ÉSc¼—å<-x@Ò^ e V&Id¬¦jC ÀLža ÓW¦ܬáÈ0•ŠNƒrqð=e½4g9¬3àc´0ÐÃt¬µ'qƒB Ûè`0ÐFz–Á±…kÙ?èc$ýí=tJ=`¸óDúõÒç<~$ÉVé5{–=t9az¥_™MNz˜r1ãœjr Š?¡-È1—NÊ(§† { ªœ‡ép—ç© š (;HDŒpÉÄl‘k: T *ZT'±éPÀA‘ .=Tn4cP=¦“Út°9K…aOÜKÓ”µ¨Næ’!@iéÈb‡T Èä6™¦Ø!@ãÅÞ ãŒä€Zœ…FÙò1–‰D3 À„ƒJ‰`óˆ#|n(9: Ó½}Œ-{€û8¡Y, 2,KÉÂtlÙƒ“Á{^‰ `Ј#û,˜“•¡D¡)0+HÇ~L{qÆQÑ‹ âPÖ¢YC›NS¨ ƒá[]‰8tã §lE¿¦&l2¨4$ÎIA'ç.ÂœL°0Q[ö<‡8ŸQÆ’‚N Ñaµ…!*èPnpý,Y´Xj Ÿç2îÊ Lƒ©Æs±™.°ÓX è`5aÒä}CÁ[âŠAr¬Bh‘ä1§419‡ô'@~¦_’CŒÉ9&"ƒt¨K“«’pD¡.3бbf¶»4ÚE€*Q°¶`7èp›À6á™É(Ìðæ1hq˜„`†î#&c!LÇN¢éç V@ÓA ¥²Ó°ÍqUh.ñ ¡#‚ž5Ùj´N v„­ÐÕ`f¢¨XÞãò’„‡Cif²ú„€é°³üAB¶€ƒB€[à½Ó5²•€"çyœ]/À™¤mxdkÀÉY‘-Á>°H$A;™8Z~'§I1b„Rn¹EìlS’Ãd’šÌ0Û®µ:êÐááqtêÊž¡u$»¡O=¬xD]Ùsèàç¤ÈxâÌP°Ú Ð¨+{cÂÜô)ÈžRÛueí-6YnèSg©Ï/¢‰=Š×˜·í&Þ±]÷₉r@ 2({æb?& Â5ã8¡3Mƒî–¹Ð@³"ÚJÀ^YÞ<<9¨–ëÂùå,å&“ÉȧŒÕr] ÐÓÌP0(áι®¸±I’d…†1’³¸Eî»tbŒWݤ½$†®D :N–ì†ÅÄð'=èžÐp¶ÄMu 2I«Q ‡Ð²EuR—Œ`¾<—-ÌóÔ8ºDdÁɵ,—ÀY˜¼˜ªÖ9€ fÖ’\à/pt…¿ÌÐ=à|Ò®9.†ëG²bþMÚËpRÈ?ÕS\ûŸ¼ô,qBò°.Ö\Ûæie¢1À:ô,ºæ·8?O‹ù)à.q|«wœìVÓèÍœ9)PeáH%rO²¸ÅÜw7%E!ªÁáÉ’K±ˆy‹Ô–-|ˆq1XË+³Ãsž´I¹9 )Fè–J$ ›ž€WËGe=Ahe2-Ã¥Pá%nŸ$ÅÀ$Mò"0¡i†£h³QÐ'!„ˆ´\ªÀÒL„ƒ77Å܃Ë ìHXÜbòlìD&Ð×¢j଄4k‚tìØ„±@Ž±X‘ïyH;4Á!õ$‰MÖB%C7³…Ž]: l£p.ëbmÄnÇ&²K›¥…ƒ†G kAfâ’Ix–S/`í0¤“Æ.ŽápZD\žf-–‘ïí|™L$—aúëY. tOd29r Ö¡lð“²sîÜD&ÐÉ-L“³^JrÒb-‡‹ÐmÈY1/5— fóðÔm7 t 6KMo$Oq¶k^5áæ1æU+F4‘Ï1t–ºæ1Nûãq\Œ¯á 4®|êšÉl…Ÿ/•  Z”–#’ ßâôÙ:á¢lŠ]3.ƒÓå`ÿ-òl5÷®šób¬dGb$7Ÿ þ ÚAhQ#\ž@H‹ e®¸Ôr4œGÌZÐÉkþžð<)F4%²Ñð”›Ñä8~(Šl„œ²1qxâ®›Òlž:1_Nâ5Êq{¥b\TPtnZ“çà fÈJBKy8›àæ5! 8‘•ÂPàa§í&6í嵊ÀÿqÖ¢iNj ¼Ø$J­„€?I[¤HÜ–ÀQd^ê%„K"£Y ÙZ :§IVZ.`ÖbÕ’I´T–›À –¤y,™I@ŸgI°áèÄ·$œbN(CÿàšJ¡á'hC ^O\BÐe`¬âxZ¤ãÐIç˜|dŽ«Þ ûæM`òCêr˜.æi^ƒÖ×’!±fž $ fsZ›ªL5Ù‹ä³aÄRî’Y8a´žÙ¾ú™íBÍlÇô¼wb;Ç“bw»:±½<[Ø^ží¸ƒÇéÒ°Ç2µtDu4¸©q¥+8~Ö@p"Ì:³-$¸ƒŽKz6¸úºØAúí8 3=AM…\„&18 • ÂTqž•;’ÄØ]¤”fÅ,ÑTHÏ(§A2À´œC9¤˜3 ×ê8T0SÙñMàeЀ˜‰Š2K}ºbãÐGq¦ƒž# ñT;³ölPafƒbÞŽ„XÀäæ"18 mä7](n“¦Œ™ùÔ9艋6b b¶ÝÀAºà¦3nyõ}q„µ/ r ª½rêLm_¡çtg¸: ÁuàÝ(bG ×(r‰ÈJ©Òœve0EÆiQ=\ ¬l"Åeê8ɶAP“÷†F-x¼¥(§û§yeÉC&†Å w ~4¸kT;ˆ‘Š8œoSÕJðϸlÐÌ°Ç­p½^n«e.ôž4¢Â$Á˜+d›Y´=.3‚Ðrž, ÜMS‹yþ4Ïqò¥ª!h;<Ï ÓÔˬí=iĨÜE*&AÍp3MqêO^Ì"^ãêbCþPŒ Ñ&9ŽªvÛ“&¯ºúf°ùzájÆêPªXx‡ ‘:”õÞŒqŒ1?Á.¬ã‰YŽwséTR`)†]-ÈØx„˜”?‘¤´Å4?!\:8ïÈ ‚ˆmãVLJ\2¸-™T悃dì®^Œƒû`Š%öÓ8É[L§™K‡FÓ©(ðœj8¯*ìŽ^£;e|„7ãäâ¼&ÄÜm¨9²¤LS^,ÖïŒLÃyH[ö.0èååÈ•H(m±—Œ-|€^,`Y¹EN.ÚÌô ¶ôØ¡m\T¶ÚÉÚì@lé3ܱ/& +‡À0O¶ bKÐ4¬ÃU¿á´C›NSJõ_ºá΀`±I¹wOž¶Ùs‡ºâí--Э’pVœ:ÒÏäüœbn>.³È[LÇ¥Žð³·aY¹]¼µ˜é¢œàä“Â8p»¼àø'б…ŸÑ®ÚËË'ˆÛh &Û²ÏpÎz"He¯®,ÍÂ6F…•àiŽŠCtáËòÍzC™„oÛŒ˜74«Eø&45E¼b ‡[¼r ‡É•án€FºrjçfHRÆ•™'%3GC2Xs ÷#aœ‰‘MGà$”bÂ>ît#pûÎ0±M'Å­m˜Émb@œd´ ›Žl:y/#´H&¸‰x–…·ËĤ›8ìRîtg Ï̒ئÃ{)ǧE÷#Í[ì)˜%Äuvþ^L€ö[|NãQèí—³?q­3 V+·¥Ïåê…ŒÒA¹YÎJæ¶ô1Ñ~Rr›¥q‹ÍdláËð4eyV’ÉÀÙ…‡\s[øØ;ƒX‹&å$R‘ Þµ%·…Ïã÷.ÿqpœrn—3ƒ-N‹-Jµ±BG£ù ;ùÛÔ' Á~¦/>Åüԣܼ+þ†÷Kq„Oâ^&h1ü‡ºAw3®Ê‚˜ÀGŠ«¥EP‡Žôq#Pˆ×Ór~l TZì’ãHŸàj$©ÌóKyÑ:“˜“:˜NðhÑRëA€Õp5€1®v'o–ù=‘õ’,ÏD©>9'‰Ù1ƒÉJÙ Ñ‹ý“^Lyeƒn6¸éA)œ½¸«'-â/I/Ôì=ÀäÐjN¨)>Æ–Ao×ÊÜ¥NŠt"tY) íGÁ8N'!1)¦š˜Åz³|Æ¡\Æq£y½çïáZ\o£p|Iqæ…ÞŒ7xÆI¿ÇÜlâCs1 š@ÜÝT°rA#•Ûs²Ôì’à¦~À2ÓÝåzXç¡$8W c 夺ïùٻœà2Ý  ð¼2{ҢǸrß½®ÔæiA —žt«ÓZ‡ÖšÝ2 W‚Š× ¸x$.²¼ /DgÁÝ|‡¾6Ä Æ=Ê9­1/èÖÌ0ñ…+èt[œñañÿ†Mm!Á¥—óÃ.òuˆ9Ê2䣎•s[ë<äãÂ< @ÏhЂ¤ÁЖŽ;,æibFGüH•€‰·œ7b‚@pN+&gà jèÁ@ À©ØÑ+Å4(¦!5bnB Vî·‚S³s£1àrL…RÌuw‰Z´Î(1c~9˸t__Üë@—WŒ C× €*붽 V;RÞ'¼pß¨Æ ïÕà¾Q †ÛV‰œ”‰›÷É ïI ô¨MH.îŠE%JÙWÁ h@ˆÙ„bÜ3ˆ²Jêµ7¼cÌ„[imTû<Æ%^•¸QpÖÙ‰MžâZ–Sâ a ‡á-5¸Úä¸{±œÿXŠãœ_D„ìä&Ǥd,ŠiŒDî°’Ó‰@ÈÎn6 ¡‘ îÕbˆõÛT6há‚Å-Æ%ซ /¶¥Wˆ‰ \%À!’ˆ 2Ð…n\ÀÜ6I‹}^p§*@´pŸ&vU@ÞƒI1±.Å1ñ5²UWfä¤ÈK#ˆÖ¤-vøpT½?¾f¦²oE–f-vìŽy^#äóBãÜ7ºÕÕ…RÝÜ;ÌÑÔ…2ÞÜ›ñnŒêB oîMx7u¡|7÷æ»CºPÆ›{3Þ](ãͽïÆx.”óäÞŒwS4Ê}qoæ³)œ %A¸/ÖÌ…r!Ü— ™ÊèaL×@/gI–—ÆO³¤Å˜äˆO\B)/]Àǵ-<Á:¡¹ú„&S M\¢åMhâKE ˜avB³<[Mh–gÛ$4yµwKqs·\d•à˜0ÊÍ4]‚¯È-wÚeåÝú¹i08™û%øS/Ìc¸-?ËÍN»`›=èW•34I&§}¥&Á€³¡ì '#Ež `Z°`¯.ÃE(&v†X÷7S&nÝËÓÿ¿½ok²ãHÎ;,[Öjüä'G¬­WãDÝ/~#ˆŠ&H",ÅðËÌ™™C”V¡¥ÖV0ðß_uWuWu÷É>n“±;zNžêîʬ¼|ùeª§epŠ¦îŒ'䎖­2­«AȪ]Áú‚*-¯ˆ2š©¯H%$èóŠèø´^呵ǟE~Ntœ\1§rréMÁ§>9îûžY[z è­—…]ÅÔäòÜD™¹ 1dBµ)É[O¶Yr3c5pô 2ÞD"édÜðÌXK‚Ë™úBAnšˆù‘‡T•vù‘“×\Ñ;×Ú–YÌ\d·&àµhšÌ1´+T¶¦L£¬(›€Go‡½‰NëBQ–Ä 0À•v…ÚÐYÁÎ-…Ä(é1Қܲv¤–T™ÓÇØÞEÙ²¦[©¹é Ðíû½c ðÁòì½îÆB¼é×åéA¤4Æd¤4í=£¸Í ":;ð\"e|¦«×(Ò;KÿæíHfƒv+¢z„©ŽCmCÓ2¸—®‚¦GFß,§·šô,µN‹„ÅxUßj·w‘N\g¢é¨½-ŠômÁIcj›ôUžÜ7¯eY‘ÍqRæ§E ^Zl軕¶Þo|ä7´8÷[]ÆbÔ[6À3¢ß*0¿f¬8ô€å*Ù”ã’í±p¶Ô0‹Àv“{÷S? ÓŸz.ØíwMŠBe+0ãÐÅܺ¡Ž²@Ù¼¦ÞBmò¤eXg'#¨ÆJEK`tjSѺ×ea° þ _ű§Kf¯lÇ—¶¹¸ˆ²@÷5FiÛÛѲè1-ëy©;žáæ;]`±”öeL©“•3½ðD{÷ª×MF({ ¡Tç¹¢O£ù¾¦ŒK¥pm£Kã×´òJ]"2z\ZÞ‰± ¾ìCq>¸žué!HŽQFÖ[Ï·9“¼‰ Eç£-VZ¦øðŽ©Vák>'SùIIžx]׫Â5ø8ôgrÁ$O¹ó M+HQœšaæ\žNhvæ ª×Dk]Ùç*±ÒœF‚\+H’‡SRŸà(VÚ±t;$¨NÆ.ûË\>^ÏVe$ø¼È05‰9 ´®UžfH`ðËXV¸_Þ§øêN³ hjo¼¹d— ¿½›M€ú’´nJµ†OªÙ0>´8¸Âô„X É©÷@bÆ–®Ør0¥" /¨ÞdA¢æÝIº!PôdÕ ùå0‡KÈëÙš **qôòäŽ,ߊñg¢Ùðõi[f†@ÄOf˜/ÊÔ› …)`§Tƒ è× Âõ&8q%=Wr8_q5=Ws€# £)“q!v¿á½jo4懲çMjclX rí;¤97RäØùP¬ z»/†\=EÏÖSç¥X¢d¶µAóoä'¢êöÑVc M0‘!u¬bÂT«‡Š‚—2Ô>U||äS¿ºUhPCx™c`Í-…x+GtlM ÐÃöL|V†çÓѺî"A]Ö„aˆ°)ŠçËZßµÖ®]nÄ êìšQÔZï[A a=WOÓ³õ´Èé‚O>i6_Ø0­Y'CA¬/ £ í@+ÚKÞ[²nb:ßaÚ]иùàù§#‹uÈHÐm+>Eá BzЦMÇ ºkùhœ/ {Lð#ãÌs3·»`1•Â•Aõlt9EÂÕAõl”v© Ζ]…]ëå ¹›j²R¾Ì5E¸0b/Ð6ï0A©FÀ„.ªxzm×¼CØ_B›ZFÉ#\óÑsHÐd1±Ž%­ë†¦(éGÓYúÁ6¬œ‡úì äŒ{?B8I$wÙ=åôc-g1ûÅUÁõ\<9/ä— aõÂ|½àµ(WÏZ÷¤|½ÈËÜ‘‹/dzà×½:_ïRíÕyìfòõ@ŽÉÓÁ¤í±ÛÛ7›  ú‹yÏÇ*œovÚÙ¬G[oD-g1¥É ôB´¨{7f“¯èQÍ&( «!\·@\¬1í&@Üb ÿÜ)ø84[Àcv»SĽ·ãÍ›-àÁ>MZ\°`ÃTWP.„f xô§'G  ·æwwhö@âCU…t!¡9Cò=F¶‚²ÑFÏa`–sÏFÏ`–SÏFÏ`–ÏBÏa`RñÀ ‘Qt\ĸ¢_vß@˜ñvôh£ò¨…}k<É2 a·_Ѷo6EÀKt±äÛhw%SºBj9 EŠ ¶Ê÷—íkTg:béŸ0ää³ðÞ˜ö˜ÑH?ÊsGr?ùý´7MT½X`àð!zƒƒXС2¦_täæñÃ÷͈`7DKßÈv¥x¶ÃûfD× #EZøùFÕûfócÈ3ž*ð½òàžfD—èÆ‚œÒ:4µZ¡/ ¼›Ã:ð¯ÛÒ›SHPNÆ è$q£ýMçç †Ÿ‡àì-™ë0bV6âbMòÉàïw#›BvFòV÷¡x/Uó1 }‹µºÃââαTLj[€z_¤·!â><"Nuˆ8«x>ß"în pàKÖ!ó ˜€&tf­£8ÄKkËìs‡~ß‚Kð*×Ù#ˆå5ÛO§02 ñƒ©@¿DFÁ(NŸæ½Ê~]ŽcA­!Å€Ò;¼Œe½’eAèŽdázÊÐ7cä(3a( (a5ØÜlAiÑuòçTÆIŒU¶  .ÐôáÂ9ª2*ÎL·Ë-G“ç+m(\ÍÈ6G% <"ÕèDŠZ'Z5`eЈ×AQ€IšÅ%µ_h@k ó\»PfÜÁjY¬ 2¡Q`~K[‚ë³×ª‡­y2|ìóh¤ah‰ê`‹éñ+tSx—9_ASFW n†"ÔÜüH¾äa3*¡OD¦t˜úÙ»§¯€’ .ä0ùƨ ”ÂÀ >òVÍJL#)ú4«ò2FÞ׊­Iß–}!ôë·B24Ž¼ê/‡Ä}Ô§àTQ#ÓïÉKc_}Fºáë=³‚#Eð*¤éoú¯3fDUªâ y>Ýí S`´W˘ñqÀÒH Tì@â‰a:±GGª4úÝÃgíØ~5œsUÞ|P··K>rX 2}·d#Ýx¥Öïºdeg"ˆuÙ(å´Ì6r nl¤ h 6¼J °G(c£, Œt‹^„ àÊï Fx+‘9`‘@ºfz pÆ×øáb&ágãnX3aÁh;ÐÈ1àüx/:“üõ²&Ýaž³jV <3®Ò™#£nͤE‚(û8£…yaØú1¯œL°±ð“ÃnC˜ØH‹ñšpê&O§ xyV¤ l+‡<{YæÝ×ðC '銆).Syx£OM€bM£v.­¡0Ÿök¦^–`Üæ羓œÐžOdÿmT#Àæ£Ø9¹$§ö¾º©ù?(fè­x>“s7’Ç+†ùñj35‰iŽ]8éxD ÌŸyh¯H–߉✂ÕÉïNrç‹î5µlŠ–hÙxœäLœ/`"‹s °TkžOmx³ö§%¯Lb:( cçüŠìe›¼28H0 <&¡ƒ`ÁIî ­íðr9ÖKÉgeÛÜÕb!á´´ º2É“/TrŽ)·*wÑÜf$¸2x˜ wdVFc9ùµCàl(¤ãCIRf©Âq™|ÃPÀ8-߀Z§a`äB5.Ñðòšû¯ Å”#Š0Òâh&5M>Qçe¢…ÔqÆ;>ªM>ÁÒCåÌJ¬Hõ¨6 G炃Áé˜Z1è¼9Ðt*U0£kVªæ$‡Ž‘ò¨¨$]³¢ú,X®N–n20ÞVé8m¡|·`³ ŒOS2J3ª^A[~7é™4´M)Š²›bˆ+fêÖÀL-”oK±fXTë PôLve Mû+:htëÐÁ"}h]Sòaň8=ñ ƒI1–ñÙÝâ˜"倳E¤¸¢ ²ÃAâŠ/Û‰F‚b-(uZŠØ( ‚ñl3 ɹ­å,*3+h.Î%g”ÔŽYsôºt-G¢mR[süƒªw¥¾X]9âÍÙVŽ·rhy?b/Õ›’ÜQ¸ê„Ýí[A>ÆŠ»VßêMI†UÒ†*½åGX€Ø šµÐ¬˜¹ÌÒdYá–e§¤­yèA‘ H[¯žnÊæÕÑCŽ»gyËç6eµ™PÀvÆ°Y³¹]9Þ݃⟤œnÊFÝ0‹Íûzô¦lô_#[Žá3G[ÊÅs—4W-™Ì#&šð#•:x¨ñòôÁcîˆÝd¼Gìo{Ð8BãÜAçäà[AçúL[Ôõ¡¢.©û¨ cÀÆQÆŒbäD?NR{ðk$Óu}õº¾zS_½©¯®Ž·À+ üMŸRÀ¨'ã0"'… ˜j¡Lô}Áaá1'éP¸ÅbúA´D_ê3†Ñn&±ßç>/ƒ©÷}¿ âHTcÄ$þ¨£-ŽhŽ ";ùÛ{-7×Ýk¹õCÁÖ‘wŠ3ɧ€ôûWõ}ÿ¦¾óC‘–˜ðÖEZ‹/ü´P TWRô±cNêu8ÒN°*¬Êì ó ,¡ÈÄHcv¤#w¦Ï×á•ê4\üH-qü¸JüYA²H艉NHeË"™f“®DjÇ-ŒÎé중+bXq„Õ¾,W"±>¨zØÆüI€µ¨¾§ÅW þ•°YzIJjŸ´¸6*yìCª7¢R¨§”\öúWf[1d—sÆ÷ˆ ToD…oTe Öú í[9A THŽS¯z*„/ÒçrÁÊ[9ó†ø´¨ª]V"Æ‘l5d⽶)ì¤0–M¯O7bóÒRó¡ZVO¶âx%h*›]ŸÛ‰ã mQŽzì¨W‚¤€ ðèXk»E'r*Ôk—NÖÓb©Æ6±,yÈTñ˜Ô¡“㈷¦žd«7‘9x°®ßÒöà1¿^ÅÜA·c½ÊûVÎÙÞÐÚ êÁßY-ÆAÔ—>®(ù—>Œúõøï®~C!Ô?Rõ‡«Ÿ®þ¾«ýÆia–êÂ,úñEYá¡õa…]ˆtOßø@ßùÓÕç)¤‰ÈËŠ÷‰Zä9ýý-ý÷?\ýÝÕßÓïÿtõ@¿ûÓÏ7ß|Þ ÿ’þû‹WGn¾ø¼{L÷Ž¢©Ñ%0cG]~ãn¢<ýùwøq1qò$‘þ9$)ÿFS>éàTÔÁ© {÷°oJ‚24%A '@X ?*ÕÉzvÅ?«~ø•Tîs ˜˜Ôqx(˜HNìBTaGŽAÂt¿ésdщ2yÉ=îE¡r0*†Õ.ÉQ”ž]ƒ1 –¾¯vkL¤™£]1î‚ôV÷Mý ?7ݨÉ79DA·©§±x±ïãBåé)9Ê£tã>\Öí²T¤aÒXÂW9Û#\Èœ‰ T›ÜÖU»hE3Å˽˜/<ÈŽ¸u EÜÉ yÕ¿ƒÈ\88éõ8W‡¬^íûœ€ÂøêäúùÅBÓ‰.ARÚì½ ·Ùq¤¡Ñ~P¯Þ›rÃÆù¬@ý"Z•µ‰¹ôKÏÙ†Ä_Ò'#@ÆâÑ]}¯Ùç¦~·£‡,õqû²ý^° x!T}É©U+š$ˆ·{W¾WZòYØïM-ãÞd·Òƒ÷Xöä|Eô–ö3~ìõŠÜ ú;ÝÞãØ i<«ƒÍw: ñŒÀÞîú}qbHÁ²P,ˆa­Àîá¡óÆ‘Vç‡Rž…bÔúFÂ>–͂ᤑݤ^šM•­ œw–|ëž„VDrL¹žØ/ÒÜ„ s"+&ß·§M¡ß¥H.6ï3îo‹QÚ°T.튙Ôöô øN­¥Îo8êÔó\rkÁìxõ@VaµR²ZÖíþ®<)«)"fí[ó†[yµåá•8p­wëðr§ÑºÕL[¼ÛïË„3M掷_íÒ~/m P<‡n@ã§' ¯¿xoöGê3à´Òåð½½À}T¬ùöÇÊ ,ÈwÎ%Ä#8y2D>ŠÒI± ÖKiF÷8v¬—ÏuγÞÏÆgG‡N©0Ç„=ç…M¤ºŠZ”^(j\QçÚ«VŽRAÜ$ ìÉÇCû¦üš¨œDádÆ°Œå™½iÑë‡I+†¼£Øy@$¨)¿|p4{‰Î{ Á$AMý,²Þg¿hŠ‹WÔ÷MýÕíèSexùcÒ;½æ¥5˜€®-¤-mn5>Æ š`È!°£ÑKŽN¶ïäÔyT‹æp2ÕåQƒ)5:½âåßÕ‚HaM(Oš\ŠÍyu’SÁ¸Ê ¢Þï\š|T:‡K‡ø7È5¶,BT4úÖuÒXUœe .§`äÕú†É²ô¹œÇ€ Æp¶•J4ú†‚tÀüÃA¡+Û²&}C{ˆÓ£¡R$8Ë÷¬‰Fߺ ÞŽ‡JÑ#²u™*Ú¡;,…äÈVNp¤¶™îIïòÙÆ~€ÌÂ=ðEAv€ßÌýp˜|g lÅ#“H‡k‡ì}5€Iù’ÌBÙEÅ öÞ¶ræ2ùŒdïçlK)zFr÷3âôŒ8¤äçÄÙS¶°I‚àô>ìÉ;â1e·d\0bfE¸3’& ‘Ç0È¡‰g $9µ¡f¹õbÀfŽ¹G¼˜ÚŒ€±Šb˜L1µ¡@‹Grj3dêÏ‘ô†üô°BNmF`7Œ.Ètl-…ÆŽ`ÍrìŽN>ƒHrd+‡>W°B bQ^)Ö„Æ}¶Ú†Ì½€òf òÛ§1$t\Œ‡@ïËÆÈÇC¡1$M 1 í&zè, †äÔ†$$" “§ìx‰¶nϦ×IN-VÇ9(zÍ(=¼ò_ãÀšeA…ÊÞ^l´5 ÄC',§štÈŒñrö­k]}‡ÝÀúh±U×rÐÅ犔•wBb«®`5ðå<Š¸/ïyV±Øª+yž‚ÂÎ짧“‚φÅV]é}¹!‰EÑ«É:¿žV]KšŒ T)çö‘ÃƉÃàKƒ‡Æ¯·oõÍ(ÌlÈ‚è4 »nÛž )Ë̵4‘LóþÚm»t=Y£¢\aÙn§›<ÏPêk ìD‹Ê j÷€Lc”‡iÃÈŠÑñÍ?ëvȆÍïä'±Z{Ûmz&B Ò¨g­àº»mŒ¶G|¦”äDÚíü+kl6f”’"FuqÝSfÙ‰+äÍh„¶s~®xÒµÕ†oEçpƒ @úÆ2 ‘ :ö\.ù3‚På_¨ùΗòy(ÞÏÈ[¬Ðsâösó\— ôœ¹ ³.îryžsèÍl>á"øµØVMš͆m@H5XtAHûG·Ûz”¸ Û |ªÉØVQc[áGÚ Ë› ­ ´Ywc0Ý!\ñ{ ߪ‹BomjµL­ë› üòþFªWFg  þqèE²I(É Hœ+*S ý¥A%lõÐYÀD%2¸3 ·¸„muà­•GcnÛUi2EAšš(‡QQ}xÚ´ç8Ôè]¼êÞ…³‰3ÍXÃ1M_Î…µ6_ZÁ-) E»gßua<¹oKVÀ•„?Zêv:Fáå€xŽ]\ptà Г imìÍ÷*n,`÷f ²—­–žœÂ\-9ŒƒXÊ1“+Yè!‰tCçqÑ{¶-âo@µ*ôþÄã¿·…üX+ªqž{zsÅé„žJû>Ϻó1æé—#©àµwKˆVÌ¡° b>ü­!a(þ>šâ_ÞáÙiòA±b z96ƉLï ‚¬×Þsý)õÆÉ¢'V`—è<˯ 礲n­ÕLå]™¨Q;Œ†y3°¢ÝB”4¦¦`E¶o‚^M‰«3µ&‡ÑÃaëFôªL0 1èäX<+ž]w^•6eUs$áC`FðªU+EªøœQZ¹‚õ­uÐ[ÆväçÔšç\çæ=óÓ°´hN·bØÓ³u?j¾…Ò¦¹YJå$6ÉQäçò#&HZAÛO¨L&OrÈ ¶#xH‹Á—¹ñr„ˆ<ÙþGë1?qÐU 4ž`‰º'0Ú4ÛOÙa9ÊgØ\X ¢5¬ñ£§CÁ‚çó²-„v1: Ak0·š\0WÄiC{ad±i[@NU”9±:ºÀkñ³–¼MGçÄ ûäY¶[~Ÿµ–c´c‘ãešŸt$zpzÜyòZ0Çr ·Aáñ1¡Ô™5 …Vñª<‹i£¾üÝË ˜'µâ}50”½É2åò¤|a®Ï’«åiAat°¶â½70œ4÷Rd”R:è­].n`8ZÞ™*(ððÄ8‹1m2ˆ\G5*uóDÖ-pmA34¸e1Éã e áç!|‡ƒñ&¤\|™I¶8œ³¹†YwBðn"É9˜J^ë/áR"§Ó=ÚRtð0iiÄ‘X`¤ã'µH`  CX Ñ*«Ö¥ï[C-”Ñ æ}AÑ"Ó€Åàr©:µa#Ž l¬Žœß|_€O Íô-8 —6¢à@é`zÅ@­ ‡ÁJg†Ì }D­Pú¦˜›Xù¤´£ £¢ç|,x1Azx1ïyÔFBå¹%$Íø›l¡ÀYçeF=u ŸèÉ6ê´)©—¥€i'X~g·H`‰8Š‚WUäx# ðdv"@ ÛÊO'€›~E·EK uÁ¡ßËOHÞEk‘ÀÛ“XÎj´ø;4I FË’i»(Þ (`‹FF‡"„ìYEè¼agkNÀá”°ûCå5ï™·P`‘Æ =`‹GCf¦‘_{t‰Pïh(°H\ð%.C©sÄVÜ–nåXëlNZÄxªáL¶P`”ÈT ó¥€»Ñ<5ß ¼\9 ¼\Û8 ¼\Ü8 ‘ýp± ÄdÅE>ÚoðÀwëí±â¬|3`Æ P5z( à=íœZ[¬ðcù|`Ý ‚<íG˜'í×lÏŒ6 «½+ËA}xE›lƒ¦“‡L¢*DÕ1™¸¦ŽÂÃûp¦ð3BŽÔŽçükñÀäU!Yá r'e3Vä®<0P|&ªÒq îñœÄ“×i …,£AeÂ'jÃãðÀäAŸ.¨B4»ËJQÛ ·•ñºÀ%sMÝrÇÁɹ÷±¾‘ˆÏý ”|+[.Qž+ K ¨8Ÿäˆhtî‰*F3 \ã~U‘ì%é;»¥L1@…(Wºrê“Ú®€]6bÞo58i¤¥<¥|‹(Æj0®>»ÅdU¡+Îí£!s\¼kò´d|pÖà‰ñ¢\ðbˆ€Éä‡øºûö}Ï“O£E‚âûÒK”Æ:ZÞ$6P∽ÍýZž¢,Š®ùF‹GLšj £9g!ÐÊ.Y"’FLö(û<åÎ Ñɬ­XÍck•†&ãððšïÖ¸Xyò‡Li²pif17bLM§Ã¡t Yˆ‘üîiàÈwyBy5i÷¬èamÐÃt +­MVÐÔI–…Ç¡‡ø§8:[x‡Fz%× u+ OA EP1 ýB6Ø5û¦6ð^!w-£éâ;>9ÝÀ†1ÅPÄò€éÐP^ð¯·÷U˜Jö×…àÜÐ0ÖÞ5¸½¯ÂÔ˜h.œV£PW_:¯ýÊ%¸Èi@èEÈ%pÐ륭A0Æi è%hÇièK 7N‘òë}}õcòÏW?Ñÿï¯n¯~ìqÅ5{í·®†~Žú9¾Oô³ž?Xü[ƒŒµ`€Ê¿q‡2zóT!ëõîÑMñÑâ GP$}Ðézf··áá¶ZóŒÑ„~†ãwÌ ¬ZU ÌtjØXÁ\– Ô1³Ó|,Aª Fà¥Éá«'ÖÀçQ&–¬ò @‘\) 1 Ñ¿Ë³+•hGW><ä‰5ûÖÂVVÞ}­FÇ?Eµ‰‡|”v…Î’Üâ”Ø~¯ª¿—•COrö>Ë}ýîM}ÛÍ÷Éêû"; µ½OòzÞÌrG=ƱÜqó¢¾ÃyØëú• Wì«>l¾ÓÛñ܈ÕBNÙ¥Z¶%y…¸i”MÎ\ÎB`Ôt†ÍÑÛxÝte=h.tlÁ‘ĸFŒ#‡eX2ŠÂ±>!Éñ÷Ž±+>“*Yø–&° 9’9Ñ€^!ËI”Âl{‰‰Mà)‚-ÌjÈ Bd'¨œÛ& ðƇ’„0‘|VÉr?˜»& ס3¥:”YQ. 9m‚Oêõ"—$ýÆ‹¹oˆ¾£×lž‡ÆköÑ™_:HÆIeÙô<É©B¿ˆØÜÈ2DZòÔC¡)tÔÂ$hMý‘ Æõs ³&Û'Vw«V<éÐQ¬d¼/ÉÂÄö)x.-4!ÔÆd˜ÃÜɸ­ÔŒ…Â@™r¹]”šÏ:’œf0ŒE{½6#Š?,­ñ ò ¼Uå4Â&ò‚êŠåâ!ËîÆy´i Îöã×ÕN£ô;Õ@¸úAMg¤*“@’ǾºvF*8p£SÙ®ÜKÍ0—x/‡W·zw7ƒT@«-†Q”«µ­™êãÉ]7¦Œr:Bÿ›S>Muð!m‘šagÞ§šG<ÁD6,‚ŽeËÜÏ#lvÃB€¦SØ•N=C@BàÁÏŽ?Ó‹&!yô ÛP€æ9–ž†#Nüæ }D0Rí4GH´¥”ìX¨9B@ðA‚ Wðz­9BR@ßGqŠÖºŒÍ ‚~%…N†£]Øæ!AQÓ[*w¶Ú§nŽi˜ÃîžY”|» —>*Yø]:B=¢” t,ünrt´¯Ì©Æ3ƒNŽŽv9 ÊW0àMŽŽvW;XÒ™gДìg¬fØ0§Öxúþ âÓQ‚)§ì<ûÉáQÛ!çQ;gÉ&'Gkv¤ã F““£µÓ.íÍÈbzØ“üLäû³×ÉÉÑže^gìÙºÓäèhOWoɱ±†-MŽŽö¼÷‰ë?¬9¦ø Yq’g‡žœ­?äcŠŠY âäðh=4z‡’Wª Që3‚LÑi¾Ò<9<'Ð[-yˆêäðh½êTÊ\Q?˜3©&ö¥ÏvU¶ñÇú5ÃÛˆhý3j'‰Ö!Úúw6ÞXÅŒëwQ;¿±‰b×ïëæøhãêõšÖm¤„æ×åÃ&õp„)j ˆU*äÛXW›ÔÌƺN\5™¢SO6suÄqVg®šDÚú㵆,4y½#û³Ð¤ð>ZÐB•ö\ïÕ'G›†]ïŸÕG›^í/ÖÇF›¤^í¾Ö‡F›3_ïN‡6g~v&¿béŸï¾¼ùÓÏß}ù¦»ðò³ßýéçç_}*Öo_¿Ä—©LöŸ®^^Ý^ýÛÕCb‘Rï¾~“.~ýùK|ð>/Þ}þ5Ñë—½@úìç_áÇõ˯ÿôó¤è»Oÿ4EßçcÚ«»TV}•Ê©û«J±÷¿Ò”QåÕ3ºúÃÕÿ£ßø‘–õY*»þ@ûY*÷Þ^ý‘®Ü÷eà¿žüþ›«?\=^ý”KÁÏ?ûæ‡ôãÍ?ë‡ðîù‹/S¡åë¯iôƒþúöÝó7×é—Þܤk¨ Óç/Ó_>ÿ*ýøü›^@WT~þ:Ÿß<ï~¤·òü›î/ß¼úágpueèço;éoßt_òu'¯ûñågxÖß`UâÝ‹oå?ú¡ æÅ·:ý¸‘¨°¾¸QÝï¥lú«Â+öìêEzÔ¿§*GBm'Ó΋Œ1Ü3ÜS=œä`§úiÏ<õ 9ŒqõT€ÉÅÆž€ê™ND™ø›ëúòusù¦¾|Ó\®k¨¢ª¡ªQ•Oa^&7–|GÇ xÃÒM„;Û× Ùy{Q ¡­E‰uÀa¯V¬ó°áH70õ,–•·R‡˜þùøÆAʇÍ<|TB:#Åã=y¤¨B‡Þ,€²llž…ÔÚ„l² HZçíy]_¿n¯ßÔ×oÚëkMCt;§‚É¢úºþ}½EÒ@‘ƒÂ›$Çܬ8‘tºA˜®î°Þ¦eÏ5 OÖÆÊ9öÑõsžŽsp'¢¹ë‰)U6ÍÌu•Ý×û*;®÷T>úÝzű‰2Z¹öôOè–Ý‹ b%œ®Ø˲+fZö\é÷dq›žoz~¾žßÞ+òº>Šž4adÉ°``÷HK•~èr‰¦7HqˆÀFžDøÇ6Ë;Cë×zXMÓMÌ%‚—–ÊŠ›Ñú·ß“Ü—7oSVÒ;|õø³uô‘/ߦT1)É·oñW6Å_è´] î þƒÃÿ²‡¿IpëHÕ»Ý ÚlˆoûG€ð¹+§ÁÁEO׋VsØdãµØ Õi•ÍN´sï¾}ìÊX¹Œ»héÊ1õ² :’®P•j‹ikPytý¦ù|B*wœp¥¿~ûýŸ~þZˆ÷Æ,Sú+!¡‹_ •~HÑýéWúOÉîš@ScŒ¢½©é/$œ¼ê†‡~­¶ê»ïo’é|ûÙgxo?#ó¸ÇÉ>úùíØÐÏÞ^ã–?{›2V7ß~“’^ߥ„×=½ƒºº¥'I{Ÿö(m×”ýúòmúñÛoÒ¾ø[€yÓ*ß}õú,ñõWéÇó—oðãå5LÅ»—/Òjþ÷›dë^}™~åÕ›çÝÏðãíÍz›¯±„GÛ¹û¯¿¡¥ü‘¶Âï“Á½'C{wõoôÿ¯Ò¶ÿ1·éäûý×o®¾Lç –ßÿ‰þæ%ýÿ}VÊ/¿þ‚týÛ|ßïºIóM©Öÿ.í7ÿÐí·Øm·ÐØðý£ò‰\’ïîÑßßoçûv¾Käü^=æxÞ”x^Õ'ü30I‹ |>éSûáusåº\¹i®Ü”+k«õ.zk LDÊ*§eãmÈöîðñ?‘ˆ&SHôEâéçÿå>±Ó}L€‹eåq€ë<)Böðì¾Mÿ¥É•êüŒE#bhÏÐa²ygyúAÛ½îýj-z½ó~ÁP8Ã1]¡óL>ûA»ìÀ‘Óý&ŸùÃïCõlvF‡_î„ó‚6sâƒÆ§:ñ=*^ tý‰Žp¯=šÏ>ñ•šöþ•žù}©ëúùóÉ/|wôË¥£?\ôèÿÛþèÿW×WßÓZþfùkëïë¿¡V˜ùïK_ð¯Ü•Éÿ»Ø£Xñ V¯ð¿]ýúê5)Ãs@W‚þýŸÍÏ_Ó©ÿ­ñíÕ·ôÿ×ô{&ÝÏoX'w:›ÎßÑvI?ëðÜJó°Úáqÿ®±U1ú›ßNþæ—j›f;'Þß_†ÎÈl›@¦>2J8Ÿ»à_ÚÃAÜ'FׯÛë7õõ›öúÚJcÁá]†ù]Ï{ÿÐ÷EJG^ˆÕ†ËvÖª˜3òcQj$jE¢¡•NÕô¹,P¹¶æ6§Åš.¶*Ž¹'zØãHzêÁÌ=OVÐ\óËòÓdÅÍyVËÏ’7Ù;óy‘¨×_Ò+ù0z5ø ݲ>ð×±~/×æ@bˉÿúsz ¯_t' üÌèUçfbˆkçf¦ù7p3ƒñs®iœz¦èJß<Óç™>óŒgª£Í+@*Ç”6‡Àˆ];¦£_¿´_êx=ES›[z!·ôo®^\Yrê^#§F "—O'ÇϧŸŽþºž>%èó¬¨Cãî:€ñÞÜ à`>|Ú«É|ÄÎ|€Š»·f³ÈzÜk8;ë¡\6VùYó!h³…Êì¦Âit_ŠÁˆTè±ñgaLÜIV$4ùlo(6#r§µs›9ÙŒü÷>ôWÌÁ`Fý¹‹;c¢éß©±ôÙÀšÙ—ÇmoBî›ødkcÈ{{{oÔCžC>³q!†|F‹é«Ïúº£ë³¾îèúÉ1$ù;«ešÀï!=§é@& 3JÕTÔ‘1d+ª ùîå‘kkns*ðb1äÜeb"<êip5÷ŠY/x– ¯ò„ºNt·bÚuÒ¢TÚ®“RiÛM F¥í39¢¢¤Çè°ÒÒ*ìˆÒé³ ¥õL€ßr&dïwv ÐŸxFÚâb«¤ð)KKeÅß~¶©ùŸ‹š‡G‘Š@[Íe£•¬½êX[i¥w+]ªAô+^4Ç.§JôÅkº—/^§§º¦ã{Óª?­RÒ=ªÇ̃Áæà»Ww>0ªêöx4942#‘]äú¹¥ 3I‹P ”ç4y--ö°â¦»˜£÷_Z*+nkæÞ,ÃéÍÜRÅÛÞ­6º·5C¾BÙÍ`øf>nEÕ€2º~Ý^¿©¯ß´×WáwBK4¹ôô }—ã>ûØŠPŠ k ØS¥ž7 $ï £0]$Ó£¹Ÿïé^\#+n³›58Ã$¬OШ*éi•¿¨Q y4 j]Z1ÝÄålCº‡OÕ6ÏIà9Š¾¸Zf‚™§]^^,+oÓôMÓ—5]Fó‰iº¼3cM—Ž‹Í!0î„"ж?‚¦§Û˜«¨/.–•·iú¦é‹šîõþ©u¬¤iŽÚ駗iWS >” y7d\±¥0&ÐçÔÈ——Ë >,ëNŠÒ]lª¾©ú¼ª[½÷2HÐ ªnÝÎHUhU}t¡VõÑ…T½ dt.ʦEïcÎÆ©¾”Ã4¥¯¦'À3}q±‡õ2Ý?iX*+nSóMÍW¨¹Q Z® Ïœ-]¨µ|tá-oæ„X¹ åF®ÔòF`¼ ’/®õ4%_Zé¦ã›Ž_BÇŸŽ×Þt‡-åZ¯TòFà%•|q­§)ùÒJ7%ß”üd%×Ê«‡§¦ä–vºñ®$œm¨io2i¸Ã ]¹.Wnš+7åÊê@¼óÎø2¡†¤U}¾Âx2¬B²º TÞ.Ê;#X^,Óç+æ)×ÊŠ;H¢+•”‹®¢wÑÍÁT&v4ºJõ­q£Ñý4ºÂÔŸÕs<º&š]tköG­íUÏ :ÖŒµªÏÞÛ^ñÆ¿Å318㙫QkÚ±ŸÎsåò{>jl…læUr¹É}÷ªWON|IáÂ/K=×Ì«Æë;í¼=è^ù8hç'’ß’b9)&£wý$ åý‰êaS-uÆ×WÊÉO#ld®•®_7×ošë7ÍõÕi2$m¼¡O¹z2”%ÈŽGCò„Ñöþ©­9õIÞY²Åµ2-÷avèÅòRYqŸnul3 Ý4KÛâ1 TÙ>ìkÓÀ"i@ÑéE³6¦†ägNÑåts¦ai©¬¸Í4l¦á^ÃPJkÆæ´¥4ídiG›+¨¯Ï•ÕÆ×××,ÒBùÁ—ž÷"gH’p&ÄLf­j ïyÃÌ2Os–W¹ù ›Aø ¾Â“7‡Ôxâ,ðv¡©ˆ+ 7áT=^òfV¹y›Aø°y 0Ï0à8oó¹è¡ú…¹ð¡ú…SS RÖPüã}…ÆÉ—Ò]ÐWX^íE² £Ån.Ãf!>lzá [ˆC Ýz –Ï>Öq{kr.šcX­Ñ+“ «-ÎæClâ aµUO°ÛøæÍ8^íÕ0q{Õ8Þ‰DZߘ[ˆ$^0”X;7ÝÇŠðXVÞñÖ@§ÆÖà/{kð•w9=_{ §›àõüq[»Ýæ½/hù¸ÝîÉŒq´Óe†¼›yãwÚFÉ q® h§âN×ñÅ•žÔf·¸ÐóºìÈö¨|Ñ£ò•Í=vb3²h òŸ>8òWüR‘¿¡tعYP¾DHª5¦Ïvvª&½QËÉeïD.ß4ŸNývfÒhG;âØö$ä"6sûFÔÐ×ê¨fQ¿âlÔ¯Ù©ƒ¨_O»ö’¨_3jßáP¿²?ÕéÙv;¤ß s ßûGïÕ$ØᤘRû¾û‡ì[»Ì‡‡äç ·ÑfN1ƒÝ9e¼égØ*[p\ÐËhɵF÷£«7õg¿CÐ 9Å⻣»`S®×[/³nÊd×Mð¿D¾YÈ/sì{<~ì¶Èí<_ßïgU3ƾ[Æå3Sø¾[ÆÅ­[æ#t²eÎy)fÏÌ(v¤9ªoc“ÖUì/ÑﬠH(·¼Ž.ßTNªiÂ%^qL{:)bix•F=˜_JŸÌZE¯•ôlÇj9ß&³ w1£–Ú÷'¦ ²SKúÓ·©åG81e>2é Ϲ²@Y¡bÌ]躮 “5•Z›`r3º® ãÏw=é¥Çí¬6C,¤tªÙ aPó¾ì§§™úˆ6§òÌI»B5ï”{˜=1}eê˜YßG™F¨M5?¼jæ ýŸ3šéÙ —›KU¬`ž0§Â:õrtù¦þt×ZZàµßñq<íSsÔ† yÁ^®z0]â%¼a…›7°‚ì ƒè½¸Í»•éû‰Dª>I<Ãå?Ú›îcÜX,+o3›)8Ñ('Ý£‚ûäaS`–LY2æ¨È߃ºÃ¹>ifr§´½ ÀTã¢â,€Š˜þb NP3IZÚsbþÉ"Ü V?£ø‹kdÅmz¿éýeõþcgüj•Ò—Ò{ýõžïï[§÷zÓûMï?€Þ‹‡»ðäÎ{·s:XÝ罚.ÿ‡ûP©`{ùHµ„ŽZ÷¾´‘™Û:Ë;Gý—ÖzXmÓMÌ[ù¥²â6+°YËZ}úך¥/lô{´ú²V@oV`³ïß ØǽrV@B³¬ÌšP#îö1‰"ƒ1ܼEhVÐy€áTÚ&`i¡‡U6ÝÁ¼˜['+lÓÿMÿOב†U<)ý§ð:èu¯ ÊT¥; ÆèŠ=‚—OÔòl]Z4ú¼LÀüRk-îaÎ,-”“¶™€Íœj´R<5 %¬ÚÄÌNŸý(z­Ø©>#HzÖ™»‹Vƒã›±"îÝVÈ#—\V®ï_åo 4¼ø£‰ø¢ïߤºȼ\·cv´.$é>ýžO?Y2"¡r#&7{Xßqë3Öb-$‹Áh+í-g‹”˜ˆ±ô ù9á‘ké¸éï ‡j¤h«dN‘ÄsÊ°™ME¯£‘"\ÔÆ1 k8§ê*1bçŒ,¤I&¬‹­”°­ ÑL̉:¬l—%ßc1‹‘›Ï'7+¿Yù­¼zØ?>µN-) l ¶þœcv/3æK'Ûì%Ÿï©s2¨¯Œò=$ð Woq± 8C΢¾–—ÊŠ;ÁÙ»{ô÷÷›øDÌÀ¯2†–é‹ô¨OTŽ„ÚN¦IÎÉ=kn£rw½A0Âþç†Ó) J²NøŒ ®"ZýÂuó 7í/Ü4¿°ÚRÐg”“QçC²ž¾«Â]6Öî$ý¢åð¡–X© Új*ò c±¼^ÆWÀL­ÅŲò6s±™‹÷e.´âÌ9ÕÅ©½ÿƼÁÿÆ©ÉKŒ©ÄËÙ‹AöEÌÅ⎷ýH§ÍZ|ÖâýÅÚ«ýÝ /ÔG1”Ò;áE´Ùm¯{>÷÷™ÊЗHÍV“”D"º<¹{*ït+°¼V¦t?˵¼TVÜf6+pº0ä<>m+Ð:ûæñ>·—‰ìj0và°]!—³«½ýt3†àD»’nbbèŸï¾¤ôÝ—o°úwï^~ö;ºÍ¯¾Hóô^¿Äo¿ì»BÿŽ4õ.õ„Þ^ýæñÑfK¿ðõçiüÞ Èï> «qMÿ÷òó4Ãïúå×髆/J+øâõ‹?ýüv–x÷öýH‹í¶ô'´5¾û¢cô£|¸£½xC{‘¾ñ‹_á’øý‰Œýÿwø¶—ß¿ EÿÕÕÛ«ÿuõÈ“~ óódþpõÏt톮ý«¦Ûøéêïéïþ‰ŒÑôó÷ô¿gi åé F>#£ô#ýù'ú/u%èßg$óë«}úŸ®~ÿîÛ7ÉV|ûæ3üx÷ÿ6(“]]3ØÖ¾mkBSxœ]ŽÍ‚0„{ó5|ÀðãQÊ_ÃV ÔÞÀØ„«&MÌfßÝЃ{ù&;;›‘uj°hø„>uÀ5zÔ/¸ŠLcFT ¥ÑjòV£c{™ìAZÚ”^‡ ƒpè ¦u9ZûÒ€å ن؛=Ø“m™O²M6Äs—äµ[ä YìNÅ\fÁ_µsgûzUN wRímÂÄ#%ì+%² c½ŸVÆãðÕC°‹~:LB¢L Ò:‘\õ:¡m¾mkBTúÎÊþ}÷rxœíÔ± 0 °ü[~JéPè¢AàÑàš™V›î¾^N÷!ÿédnþo;ùzMüK¬@? µmkBTúÎÊþWºxœí‘Û8 FSHI!)$¤’FRHn›wóî HÉY¯Ûx3žÕꇤ¢úùs†a†a†a†axI¾ÿþÛïÇÿ»'UŽ{—áÙùðáÃo¿¯_¿þª÷Ú¾gýW9ª Ãû¼Ïâöð–þ¹»¶ŽÕo'®GW {>~üØÖÕJþîÿlúôé×ßoß¾ýüòåËú¢öµ¯ò)*/Îåç‘Ný\®ÚϱÚoù“v[iZ_Õ±aÏJÎþ/:ùþüù×6õOÿ-¹” 92b?çTþÈ™×þlôkÎ%?·Úåöìä_2òø¯èäÏ1äBµ ‘sµ÷YäÇ5à>¾:†>Êc=1ìÙÉÿ¬þOùwï èyä^«- ×Ú¶,ýÌXÉßzèû•žuÃÐsMù#×’U]ë>H_÷˜ÀyøY’Çvº!Û‰õŒå_mÄi ÿRuâþs´]ÍXœm§_gû)YYÞ)úmæ]×y,—²¬mÚ z†1Éêša†a†axEÇß“G°×§ÿóo/ïYòÝú\êkº6õ®x„ËèíjÏægHð–ö¾»–÷óüÏØñ|†yž÷u¾Ä.½•üÿ†þó\þô³aÏæŽM&ýwéÛÃäké#Ïú$?Î]ùMço¤Œ\ýȾ,Û/íßÚ¥—ò·âQÛ@Êß~6s?)}‰Î,¹ l¾ìçœô ØgX #ìvçQç´“ög·Ú ÷Bž™òîìÙ™^Êßuô¨ã®ÿuh½à¾m?Ž}{]ŒÐ.~È}Ðv_÷ÿJ;ëxçoÌgJöëôY]’Þ³ë@¶é.ì«)™áoqC–ü¿“?}ß>@ÇûXŸÀÎߘò'-üäÓÉÿ(½W‘?Ïöú›²±¼‹ôÅÛçúÞéô‰Û ºÅºvþÆ”¿ÏëäOœÊ™ôRþœ×ùÃþvì[K?[A}¥?-ýwöíåµÔmÑÕ‘ý}¿g\=ö€c¿¶}ñ³M¾‹ ½ÃüÃgggÓêüàÖ èÇ„çÜÀô-B^ëók_g?Ìò ¯F?œ£³« ÿ•Ý×v0||ØŽÐØ=ǧH¿PÆîÛgçsì·ã/ÇhØ‘ñI ÇtýÜ~×{‘òçún^§}¶ïZæøºyDžë—óÏì·ó5èˆéÿçXÉ¥ÿWvðô¥§O)í"û±c0ÎËvYà“ØÅ ÿçZòï|~à¹_%/Ï,Îôp\€ËɹyΰçZò/ÐÉé;/x†ÖáÎsõü_é·9?ÿ«PÌܯ5Ý»\í[½ãy|ÞÙÃçõÄ8ÔÏÝøŸgäû¿ËʱL{ä? Ã0 Ã0 ç_àk3¾Àç†>´’ãøŸÛÜÆøzä«Éø_ƒüÇøü\Sþã |<®)ÿb|ÅÊç7¾Àa†a†axn.µ•të†a?lÄ÷^Cã•ßvk­¬Ø½#®àýÜ~eûî)ÿ´3<3^×Û¶¹Âkð¬dlùcÁ&·jK+›œåo"eòú<.ãÊž`›Áê^(3zÌòÏöèu ŸÁ¦lÛ+6»úßv´î›<™†×ï‡ ¾k7]ÿ/lÓc[`ýOÚöùÐn}½×çòš„«ï ‘GÊß뎱š×Äzt¸^vßä2)?;WmÆrõ5üoäcö³ŸþIzì?ú¾˜‘Oî÷zx÷Œ{¹&ØÇ!û…e¹z.þ©ü»ýüÓÔÅ"ѯÑí¤ô ¹Ý1üÖóäÁñGg×ÿí{+Ò·’×lûw<ý=}GݽìÚFƨ^ú)õ¶ìzIpäG¿•ü ¯ãKì¬ÖœÎ{Í{ÙÉßeÈï ûšG•‘12éÇÛ­¯Ïq¯§™iumf—“>¿.¿ÕþÝ}¬®Íëòœ®~žaì? Ã0 Ã0 °š[u´¿›+ð7øSvq¬ÃïìæÖ­öyÎ…ç ½?Þ‚‘}¶¡åœXùçwíŶ‘ÚvÌ?ßå°ß©ð÷DðÿùZÛ“ð-q/–?ß³ñ=¿ê<ËÌ~¶Œ›‡#ýßÙæ­ÿÙæ»>¶ÓÙFkÿŒÛ"qþøz°r­¿Qèo 9ÆÄr¦,øˆî­§nÍY[;í§oæ:)@¸-`ק-Ø7‹ü({α߯›SÒí§Ýú»@¯ÂµåßõŸKäï9èîüÖ ¿É¸“>:ŸnÁ3éç _[ÿ_*ëmt°cmìÃC>äq¤ÿSþ´L“øÇ<²?ç=÷çÝ<ò¼6Ç;ùãÇ«ôsü÷èþÜa†a†a†{àxËŒ™\ÅÞŠÝûêpxç¶?0׋¼#ÿ5žßàøzæÇÑ™ƒc¿]¦³²¡x^úêl‡ò¼ •ÐÇ(×fù±ÿ:~Ÿ¦ËÓÙ£^l iÅnç59¯³©žWÇÏ~·\;Û?vþnŽ—í»öç’6eÌr¥ßÑý¿óUbS~vù§þ£^¹÷U O7O(é|;+ùSÏéGôü4|?Øfí´ÿÐ÷¶*?ÇrŽ—÷W~Ï2ÏoÅNþ–ÙŸÊ¥ÿSþ9ÿ×~dŽa«ç˜çòîÖ‡ÜÉßmH‹6öìmÀXÿ[ÿÝJþ…ý~Îs.ãÚyœÑÿmƒ4Ù¶OÜíï|Bÿ­düžò÷ø/çøÙ˜þÁb5þÛÉ¿ÈyþÝøïUä? Ã0 Ã0 Ã0 Ã0 Ã0 Ã0 Ã0¼.ÄP—~þ*ÖÎ1@G\⟿äÜKÊðÞßrKXÿ˜µs2â±(ߥò纎Jëì·º8”ŽŒ'>â’X@â–¼ÎQ¬ûQýb£àÚqôŽòwx‰ ìb÷)“¿ëî¸_ÊK|•‘vÎ ÞÜ1çŽÕM¼6keŸe-2Ç›ïú5ùŸ9—ó?K^ŽEº¤~‰9òϱQï±®Y®×F¹8–ëN?å~;:=J<—ïÛßþ¡-ìtñºÄ’yNAÞÇég»þCþŽ \áûNýâXÊKê—s)'é^Kÿg\~âç2}›6í}Ô³¿·áï)¹Ün]O»ûrÞ^Ì÷³j‡~†"·î{pæ¹âù29w€6”Õ/Ð.Ÿz-ví:û+ýÇÿ£ó²M{ÞW—ýûJY¹¯Z÷­Êêµ¢`%·Œ íÒ¤l9…¼ç•íž¶™Õ¯Ï#OÏUz+èÁUÿ?;îýùsŽçÜdš~vñàN·›‡Dç7*.Yç«+v:Óye;ôø8Ë}¦~éÿÝ|…·²+ÑޅNþ9£àÝÀ}•{BÆž#t¯é˜×xîãÕ­sXÉ¿k¯ŒS¬Ví›ü/Õç»uJ=oê Gý¿ð<‹Õ»L'ÿ£²óL¬ò:äD]²6Üj¬f™ògL˜ëz/¯+ؽ[{Ž™ßºrðÝCôM®Y×q¦~áè[»{y‹¼£®òÍy cÈzA¿§Þô»ô‘Þ;Óîwï„«±€Ç9—¬zÉszW¿”ûH®œóìóV‡ax3ÿ ‚ú à¿%£mkBTúÎÊþ‹4xœíÔ± Â0ÐŒÀŒ6{ÑPÂ$ }6aF3gÉ–Pz„ä¼âɧ»ÆÒ×]—RêؼÃéú<»U]çÿþ#¿7EÎCQ{÷¨_òo^Þ÷1ìÃ#,!ïý9ÌòoÞT2®7ÿï%äþ{uhKÞù¾ä;”;0~å-{Øžw×ͱjYmkBTúÎÊþ‘%xœíØÁÓ@`:Èv­€äÎ!{ðqÉ^9e%@“ H.ˆ#é é:XJØ ôžò0AH€ÈJ|‡OgâÈ¿=σÃáðŠi÷òõeïª÷0¶µ< Ã~«¾î&ê§Ñ¶•/J}+oâئ”§QÎsoJþ­EÝç½]ïilßöõnc6Ȧeõ1ŽµýÖ~å]©ßÅo·ò8ònç[Æ}p¿ÝÚ]Ëÿ,òúg·‘Ïelßõ.Ù´¬?Dæ-Ï÷ѯå{ÇZ»Cä¿,÷IÛ.£®ízã(ŸûZü–åùQžÿg‘ý¼<ÛõžyUÆ…«òÌ_Fù"îmoDZŘŸcÏæÄ9¸¿FñÜžûðç®Ë¼¬í·w{›Û=‰úÕ‰ñ¿Y•cÛ(Ÿj“ïõöûûî8×ÜŸxçç|1ç››øíœSî»ÓsQ~߬ÌÅ1¦Oâ¼<–ƒk¾ˆ1~m7å?”ãúÛȱí"ûScþ¬¼WFqžIôYø/üyþ»xׯËó|õ‹s³e?tÇùüí/òß–üÛþÏæ|5ÿ)ó þŽœƒMbÌ_G.£¼î~üþÅ3?yÀ¶;~çÍKûeôŸ”qbTî©ì³Žú‹rÎZ®}&üï³ßÉG¦ç“ks«î¸—ëy×á¦;®ßÝtÇõ»ì›ýž—v—ƒL·Ý÷s»\?lí¾Æ±s_‹ÿUæ?‹16ß±_"¯\çÉ9bÏïö]yOäœa<ȳÍ/rþÞ2Ïõ£IÔßÉÿl2׫Èá.2ªÙf»¶ýÛ}Éðó ÿáwZ~CæZñ§h;{ïüÏbyŒ»ãz\Û¾)õ9'ÏýqyÞó›q^Úd»zžÅ ~}GQ?—?À½÷ Ü>M¢©-Ñ×mkBTúÎÊþ’xœí‘) …ˆq ĉ8âDÈ^éê>×»gI@ÏÏþX¯jjg»iЃž——Á`0 ƒÁ`0 ƒÁà?üúõëåçÏŸ|â:÷ªçâs¥¬eø÷ÁÿQéùŠþ3|ÿþýåÓ§O|â:÷2|ùòåßÏ.¾}ûö;ï°7eôûGFÔû´ž•žOõ¿6Ñþ®ö_õQúv•¦“×íßù]Tò¬ä]½^¥Ë®gí¼{>pjç«zëìåkßu¹´o{šyªþ¯yeõŽûŸ?þ÷{è-Òýøñã÷½x†º¨/ D:½é3Dþž&òˆ¼¹e«^H×õyê i#/OGôzüϪÿÇ߯_¿þ~î :ûsMeÑò#M”Ï3YŸ#=÷2û» QžÛ›ÇßЙ¦‰ïŒ[\s=Eó8´}E>¤GÈ©éTîø  Ú²Ê×Tªg-Ÿñ}×þú̬üVfÖÿé¼Ìþêo¨SVwìzV}Ñ.âƒ/Ð>¨~Ê!?÷UýùÏËßÿï1¸Åþè<ú#õîä¥þ•ý}âÀ¶Ø=þF[ þ÷~†¬ôQÚ‹Bó¡N™.ð·.+푹^edÔç½üLo+[\Å-ö§k»ïä döW‡ïÍú(}Ýýê6îqÝý$¾#³?zÐ6–éBÓ©ÍiÈïöÇ?òLüåÍ7®!ã3ìO_Q}Пuõïêoßš™é[ú=ž¥tk¥È‹ûøMÀÿ‘Æï!'}/õƇdºÐr2ùÉ_ÇCú‡ÿﲨü:—©ôéº ƒÁ`0 :8÷—ÝÍòoÁ=¸„+8-ó4}ÅÛžÂcåÄ¥XÏdq{bUþêÙŸÖq˜Â©Î®è¸âmï!«Æ¶«g*ΪòU\z·ü[ù´GAåÖ=^§+ruñü{µëLVåÕüþ çU¥?)ÿV>­Ò“ó†Î)úçx…|œYé¬ÒÆ»giôãœ\ÅyiÜ^cæUúÓòoáÓ*=£ À³Âó!óÊþÄíT•³ÓY¥µ?rfògþÿÊšûWœ—sÖʽVÙnùÔõ*ŸVÙîXù#å=ÿÌFÈÜýªÏ«’—+[¡«àFô~ÅyH«\L—~·ü[ù´ÎOÒ‡£Œhô5žÝµ¿ŽžöT§ö¿êoà”w¯|Sf®ûÜÁÓŸ”+ŸÖé)³·Î;´ìÌFå³´;:x ûëØÉÇ÷â)/ˆOSÎ y²ëUú“òoáÓ2ÞÎeÊ)Ve3'w®”ç‘gGg™Ž=ïJþ®^ƒÁ`0 ƒÁ ľˆùœ‚u k˜U,ªKsÛþçØ‘5€nYæ®,÷çbXw{ ⬿wÖ&Ýúõ™û3®Q×”øN¬ðQev× ]¨¯Æ·ºö¯gcH¯úËžçîi½÷Š{î—ôÌA¦3žéôIó8†Çh³òwòÊdÌÒu×wËÈô¸ƒUI÷äWçq”ƒð8­îÕ×çI£>+—£ñ@åì”p™ôQÅŸáóÈGcþZ—ªüò\ƪÌêúŽ¼ÄUƬìß·]ÌÒù/ø:íÿèÊÏ3dç;É«:gB9ÈRÈôï|GW~•—î×w«2«ë;òfz†áŸt|éø+—i5þ«Ünÿ€žá«ÎŸgºZÍY|<õ1NyŬ|E7þkúªÌêúŽ¼÷°?õ®Öÿz/k›Ü×>ä<šÏÿ=Α}NŸÍå»Î…ùžü>åuåWy­d¬Ê¬®¯Òdz ƒÁ`0 *èÜ\?W8ÀG£’Ë×ÏâY»ûÌÕ:‚ýÒÏDg«öc¾g<‹ Ìö2+²¸€îÙÕýÿ'ëWµ±6½žqnØŸ{žrèuç"w¸<ÒTkôÎ.™ô\ r¤•¾nåOàûïÕ>Uì˜~c‡#T?£ñ+®ëžyöï{¼QùÂ,,^qF/XÅûv8º.Ö©gá×3}íȸâOPùì ~n%ãhUÞG4§çø(_û…sn|W}Tg&x^cëô“,Fíý…¶Çù°ÃÑ­¸ò«ôµ+㊠<ÁÊÿ#+}/ãUw8BÎRh_ÏÊïäÑ|»33!m–r\7U9Œmêß({ÅÑp™¾veÜåwÐé[û¬úx¯ëG¨ïµÌú¿Žß]ÿß±?g;õ,çnßÒ½Úow8º]®³Òוþ¯Ïßb÷ÿÈîã?úÇOVé¼=ù¸ZÙ_óÎÆÿû£#¿veü?áèv¹ÎN_WÆÿ³Žªõ¿rÞYL€ëÚo;Žù°ŸÎ1³g²9pV^•Gµ~>™[_áèv¸NO·S÷Ÿ3 ƒÁ`0¼ÀçèÚïQ¸’·¾[ãï¾×ØÀ veO\k^8Ö”¨v<ëZbzº¯²Û\ŽáOìp¥Ž¯b¾n$~ð}¬¾Çoèz•3ñј mKã è«ãvUÆÎþ]^»i´NºÞå¸WAö»#´÷xŽë”«é‘æjßÊtÄõì q ³:£¿ÏE=Ð z%Ö…ßqù)CcñÕYµEÅÑí¤q™´®ÊyRGý-¡+u (K\ûh¬PÓ'¥Ü*^Ø¡²¿^¯ì¯ñqÚ=m=y|KóòøvÅ«eü‰Û\ý˜rÈŠ4µŸÇ=Ž›ñ{Wê¸úÝ1Òûû;=Ý·åòxÚëpû;o@>ú›”ȘéT\ÔŽý+C±“=*ï™É«|˜¿GðJO¸CÊåW]ù–xŽ1.³™ïµ 9_EŸÐ±©â ½ýVýqÇþõÊã)vÒ(ç¨ã Ê‘}Ïì¿[Gåñùw¨œŸîǺÛôã{-âƒoô½ÜSdו_ËžïÎ׃Êþø2åÔ;iT&Ÿw*ßÎwú‡·™“:Ôº§ÇÇg×­¶“SþO¡ãsÌìÞjÝêºï%Z[~_˯déÖ®·¤ñ²+œÖñô¹Ìw]Ùÿ7 ƒÁ`0ø» ë]ÏÜkÙíIŒu¾+e§L]«ïÎÖ‚ïoA^ç°î;=GR¡³?œév쯱Ö;<÷ôy‚· o$Nî1ç´ˆ=:ߥPîVãžuŸ£<´Ç <&«ü¿ê3K«yC©¸/ù4–£rÇ)i=µþ*/|ÎŽ^]ËQ¹NÐ1qŽG¹¥w>ù{å•á ?ÓKvÏå:A¶þó}E:·ÈÎ_«n+{ÑþuÿÃ=ì¯ó¿êÜr ³›÷qÍ“¾Ì³]>>ÿËdÑ}+½øüÏå|L¼…õâàõ0öÿ»1üþ`0 î…lý·Še€·ô®ùŽg:…®×ºñ¶Šž`W×÷,3ËOã?«½‘]—¾\9ûPø×î~Í[°£kOÿûWùiìGc~Æ)ãÄ-<žw¦¼.ý3qÌ}•ãž'vªuðw$V±’¬n“Ñváò(²r²ºÂÿ¸®5Žï2©½ˆS;W¸‹ÊÿkŒ_ÏKÑÏ”ó­8B/ÝÁhùèEÏÕ —'‹9êw?K;Òx:òxðº<–ì|@¶Ûc³ÄϽ®‡§ùVúàyâÆ»c÷ÿ@Û–ŽSwÍ8B•òq®Ãîÿ]û£=é2ôlBÓe6V}eö÷¹ˆž­«òRý(·ØéÃËáÞ VþßeÊöZT¡ë„4Ýûïad¢­e2Þ’ý+nñYöÏæøBõ—ºŸTq„®Sü×ÿ»þß”é<›Ãïø­[&Ï=üfÿŽ[|†ÿ÷õ÷s°zîPç)GèåèÙÁª}{Z×…Î3«³™n7ÅjþpûWó¿Îwfåtöï¸E¿wÏùß[ǽ×;ƒ÷…±ÿ`l? ƒÁ`0 ƒÁ`0 ƒÁ`ð÷á{ÑÙûô‘Á~ÿ¬ö½³ÇÒßi`oLöy„>uo©Ãßi\q‰ìKó|}ÿïÒû7žÉSvu9ÍG÷íñ©ì¯¿c¾#öÙé>·,Ïjoð­òw{õÕ†ú‡Öݲ‡Lûù=«mWèêòÈ2u_¤ö¬ÿ8د–åéŸjož?»Ú²kÞËDúøßß±¡öm¼†ýýwÔ>ôÃì#® }©ÛË×õ·E:¬ìOÛ¡O;<ÿ¬ÿsüy—›î¡Ô}›Ú›¾k‰}~úŒî±Õ|µM’†ï'8CTþ®¡¬o+¨[Wžú‚ÌöŒ½ø†U™ä©ïïQ™õýr'ö÷½î\ç­'ç’tœTY¸ÏwôŠÌz.Dó¥=¨ÜW|ÓÉ~q=_¡¾yª¾M»ÜñçÙÙÍÇ÷–¯äÇkþt§ïbS=2æû|¥Ò±Ïy´NÚ_}O¯îe×ù”摽ÛöàýðtLàœS6Ÿq`CÿíÌjfý´3–#ËéÜ°³?zÕ1 ÿéíHí¯þ]÷š“ç‰ýõ\"íWËÌÞ]åó¬ÊþüO;¾2'@¾ìã@~tGÎü:º«üªç{åÝuÊþê7m1‹è™Q]ßPWVç2ûS®Žåz]Ï¥zŸÒsý‘ÉÛ×3ÐÅ]vç‘îªÜÝxwÒžôÝ:Ú—>ÚyŠÁ`ð¡ñˆ$j¢ëw½³mkBTúÎÊþ™xœíÓA ±ù7Ͳç4Ð:8’dŠ]~ó—_Ý?PÝÀ³(Âí«Z™!ymkBTúÎÊþœóxœíÔÍmA`w@–kNø”«Q t°î€t`:ˆÜãR\‚; ;Òåi²8ˆHAQ¾Ã§ß7óf÷ît:ÝÁØÇsm«wÚ.™o9”—¿™ãqh/¦W¬u.ÞKãžýÚý—ºù±´kæ÷¶í½3ÿ[JL_ý –ëyì¢\ã.9|¶U´o"·eÜ}䯔¿¥½uCyõËèSŸ9ÿå}ýžÏÜ…UÜ“e¬·‹X6©þ)êr܇è_ûîš¹û´ï2Ï:b™ÆØçè¿Kãóù”˜g±v¾ë}*׶z^O7Îÿ4ÝûçKì½ØîS[y¾Å³ö©mßcÜ[ÚÓc“ÿUÌ÷iðÆW/1þcºGÛ‘óÉ1æV‘£¶¾žûXÜmþ»Prÿ%½B½Çµÿ$æ‹i,ÿµ¼?þzF·0‰¸ç)祾þû¶±ç>Å»Š³ÈçØG¾æ©|Éÿ.¾‘}ܱsšE¿åHŸœËyÃkZ¿Æã®ÿ¥Kò_|Ž{°8þüLGÆ÷éNäý×y÷±÷å™xn™ÿš›.ò2‹3ŸÅÞ×)'õ¹Ž}äºI:«IÌñ!í­¶wÍ·“㘥÷EZ»•cÌ1tMý:µOÒ{“çì"¦ì!ž‹TnÇ·ëÕ¹ò^º˜#¯“ãûWÔo¡ÍÝ5wîÖ{øŸüÿ ¥(¦ü‡mkBTúÎÊþKxœíÙ1nA`nà\Ù@$=ERlOn`¤”vKe7(e¨hMC ¹#Ñ“#$œn`v¤´£•S%$ ¾âÓÎnæ­}3³Ï›g»Ýî<€ƒîíûâ©¿÷3ësø©wÚ{—öº÷!íeïrO®7ýùEï¨w›˜ÒgÛ[õ3æU®¯%þ(}K»ŒSÆ›™OOb›ûœã:ù›ô¾§ÝöŸö绘6¹_5JîOò·E®•ØeæÌ®™ uLåÿÑ$ç¯c“|-cíúŸfí^'guÿX$ç'MÜEú}ÌõÒ÷E®ß$~›XÏ“Ç7ɺ/yx•öqÖ|9¾Ìq2ÊM]ÓÓ&¦\¯qÏ›¸ãfìºÆ'£~û>ø³f©ß~å¹¼ÎÞ¼Ղ㘲·Íž}Ñ<ßë¾°Å´õÞab¶ÙVïhSŸMu¬Mó9<œ«äùuîoÉÃ<í’ûË=÷¼ÎzÞæe“øqÌ8w5~–¹0®3ë¼øçÃÍž¹Èý´kl™5½Èq“šmœÿš¯yÖ­÷fÝP÷×Üž¦Ï¬¯Ž±húÌGçåxœyyÕ uæ'ùPµ+íiS¯Õc[³cÆý&ÝPÖ¾5§m¿z^ë½Ã;bêߦÍ÷óñß4ë†ß†õZ}Þ×ý¡í÷Ôß÷Qîý.õØ›<ó¯sÿo’‹rü–=¿ìágé‘öuj‡ÏÝðþo3Êá¼Þ/•óÓë̳Uó9êüdzÍÚŸ%/óäüGÖõÏnx·ÿ&9ºŒ³fÍŸ§]ßç?§Œ[ß+Ï»áý_ý_Ãa7¼w”ÿ¿[[¿=Ôxµm×o˜rQ ˜—Q&mkBTúÎÊþ¡NxœíØ=nG`߀¼Áò‘zT±½U%% ¸HIÝ`ÙN'Ý€jÒF¾sËð¤87 wàwÀÉF@Š"<ŃÝoVÚoþ¸o‡Ãøæý¯¿§þ;øc?Ž®G¿îGÛ(å›Ü_Lrý0žïrír<ÞŽ–9ߧ›Ô¹H{¥¼lÊ]“ãn’ï¶ð:™ŸÿÎú½Îœ¿Íú\mÌ<ëz¿»Ìí‹Ì %þz³hö~5æ¡Yÿwy~sÕ¬5þ¶yf?õ;>>~Úsm£®+ŒvÁu…Õ‘øνYšuÌ8³´ú³uNÒ?¤WP>Ê1Js¤ŠWiVÿçü‘ý_uKðEÿ‰Ï¸ˆ/rœÌù£Âˆ_âšgK•W]×±ž™ÍEYòclÊó,[¦ŸTœYH»T¾Ïàÿ¶›ùÿíííðŽˆ}x¦÷ÇL#}A› ¼ÒâœöGüžVË7¼—‘^÷}>“iÒžº²-çøèþŸiæÿì;}žLJø°ìXí&ÇTÊP÷3ýTÞ#¯ôߨgÿ®ðJÖùl eäý'ï=ŠÖø?…͘oéçùn€í±aöëì›ô½|7ù>šý?ÇôU–%Ë;«ï¢­ü/ñmöµžN/èãIŽµÙ÷fóQÖƒüz{Èñ<ÓdÌé6éd™nù;è¯ÚÊÿ¥²Q¾–mû{{÷5í$ýÀûiѦxæÿg<Æ$ò"Í^¾%=êü¯”RJ)¥žS—ÚçÍtïe/ùÖ”ë —°a};kú÷Ô_µöyµ?¬9ÔšÉlÍzÒÿ}m#¿óGßüKk!¬›ôók(Ë9êGüã1»¿”Þèz–×,­Q¿&îlÍiVæ¿Šý²Üû#_Ö<òœöÂ3¹Îžm$÷^9g —{9&°w³&¼Û:Ë™ë‰uõfÖšúºR…÷:Ö½L+mWÇôW^£§Äz%÷I—½î¥2Ÿ£î—lo£þÏZ¶f?¾k4öW¼ÜÇ-è#¬ó­ ?V/ì—c^ÿ·!÷!{u̵ʴU¦ÙóÙ·ÿAœÑý‘ÿGe>G}þ?Åÿöþv✽Žø3ÿÉX~j½úœ—{øzT§ôA·O^ÏòÊ°Ñ>÷³?syÊ|®¶ðßG)ŸP¦r*gÚ°FßGéüŽÃî 4åëÿü%mлòüÏs?ÿ–ð”Pû^@=/;B/f_C ðmkBTúÎÊþ²nxœíÒ± ÂP EÑl@6øŒÀ‘hRÑ0BJÆ 5lQíãH.2>Å‘žëë¡÷>PÞe~¼vû>6ÿ¯Eë{X³û7ïÅ”1Fë-Lá™ÝWýK¹Fï›þå´lþ§ÜŸÐô€Ò~]'#« ¤‚æòmkBTúÎÊþ³ÜxœíÑ1Â@EÑ8 pD¤ t”à iÒã$à HÀÉòvfU°§8óþ¯ïPJ€®óe{E½ë®±o?ÿï‘ÖŸ8Ä­u_ôïÂ5ïñzŸôïÒ»õ~fÏqÔ¿+Së½ËNÚ?›+ýÚ¾`rmkBTúÎÊþ¶ÅxœíÔ±MÃPÐll6ˆ7p z{ƒÐÑ6 µÙÀlÂhÆ_:K§/E‚àOþºû÷åî{3MÓ*ÇÇç÷âavmMóƒ~§·•#Vž}¬û´ï2¯w³!be}‰yXÖ}ÌHÉç9i"¿ÌPîý?üW_©wõL”çi6ζ)ÿ5O¢—Cš‰’_ÎiSí>öŽ‘o«³¹­µûÿ’úßGOwÕ|lS¯ëï@Y¤þw©vL߈µws[íJº¸÷mºŸ‡´o©)±}äNá}b}Ž3–Ú{uUœ¿¡MspïßÀõ¾v'¼ŽÊ¢6óñmkBTúÎÊþ¸xœíÔ± ƒ0EQ6 d6 IO¶È¤¡†‘ØÄù–ì†âS]»³ô$w)¥ÂûõYr‡èêÿ÷Œ­×²wíaÿ¦Ìeï若¡î¿Eá´3òÿ?†Ü>Lå|÷»€ûüY-6­&~GãmkBTúÎÊþÎ#xœíÓ¡€0EÁ”B'<-à¡0hè„Öè 3©DV¬¿™÷/•Rмc˜÷>,a Wøû&¾‘£õTûoµû©ºè|‡·wÖ¿Y}ýÿ±n`Óšör/.לÑkÇ*mkBTúÎÊþÔðxœí}+¸ì(Öö’H,‰Ä"‘H$‰Ä"#‘X$‰ŒŒŒ,™QûœîžžéùÔÿÔˆZsé>U{× °.ï».Tæç}6žÚ³‘-Æ×F`‡£Ãp]Åkß…~Ãóbà ¶ О$ÁwÝ“Ù±„ÁñÍ|süñCo•›ÝA+Õq3¶¾lOàx@á(é0ða¹¯+?÷  ÜT,¤_¯7¸s\ÛÞϘ^Bl1)üCó•Ò+ÔkÛ(îFyN"8õ–dPCÌ_9ÈÒ>O0&l«4¸Im+þîënwîÛGrÅ°ø™à»ø)/tih“f˜õÕ Ñ¸X†>ÊʨËEËÅòã)–Ô<,é6ös4ÅáÀÖ5›zàbð?¤¢Jðàö\<OM%O#(7ä6à:§= ªêýÓ‹YA£÷ƒH ¶«L s6›ÎMƒXêÈùBcX&ǘJ½te».Êöü¨Ï 3.je(”Ï?Ô?õèÉLÚjï³=€ÝÚ%wƒZˆizFTxô„$¯kPö8›E·mòø jAO™ñÔ×úÞ€«ž>~þ’†åÜà؆‘ºéB9úµâ † Ö¤8U­«KCÃv´jbëL èåçC¼ï€y¯¡ ç;¤mj P.Ô —øãïDkñÂêwþ¡UÿE€3ôܨÁ”‘•’8xëUÀ…JÊü¹s£‰ž\„³èÉŸŽ+;}s­FãQ(KI­î÷¦XÝ›„ƨ ¹1 Ëúþ+Kú¨èdXŒ];JÄ£Žïcˆx$§DÑ×·Þž¢X`i× ì¨ëÑ@lÌûrn°m$¨Æ^×9΄ïzBGÏž Q=Ænfäk„Dêö¬e; <¨ýøaÓü>,µâ¢ž›jÆïk‡0BŸ[p(õâ$¿º‡Ç ‘ÛöÌpý4 nËËq`”XÆ“ù úvϵöèÙ.xõHnŒûorŸJ¾€Ï5¬ñÁàÿHàu©‰ñê뇗 fৠí××a앆‰[Z:><ÇM@J£9óý¬â$Óq]¡}=H… kÐþ3Æʺã¯ù鲺t¿Q“=‚, 7Æǵ߻ýìêçs Ä>ã¢3ø¶ïÞÜ6[¦Ñg•¨— RLت¨ù­?·( &wÝ.7C#~B{‚]¯Ó ×â—UÔW² 7™Ò1jk~‚e”cG»¿rËÇùÐãDØ.=ôËK´ÜîëÅ@ÝWÝDZMû0å€ãûíèä¼0Î\Úòxó®vÏqßNZ¢ >#Æ ƒ„ŒàBE— ™¥)•‚º&yØA}tå?Bûê Yìm(ÂWIpáɱò€ñ ¸|½2—+èýà\2·ö íÞ)lÜ8·ÖtlÁ@Z.B½€£ï•eñ…‹ƒRSßôƃm>d˜Iéþlþôò'N a†dÄ¢G3¹%†¼#«)?è¼Ï$sß _5=²íYÇBR#-k"qGP-Ðeþ"çf­ÁÂá%Ö©-Ï“37êÐäÌÈ8ÔM9™ÏŠŠ,¬èä_*n;H‚ÁúÆEBƱ†Öcl¿~øÎî±ç Ë[ƒŽ/saŸg¸IE2å,zÒ1Út:’kLÆÓçÎÁ¡ÍíÈ™壋G)æÔ{7ÊoðËÅnd¨ø¤è·ðá•{@rõP˜>ÆkÂwŒk×½¾¡ #¸kXfy‘ÖEÇ÷šÈA©ÍBÂ9ÂuM°ÛÞ4P=¹_Ól’ÆgW®Ø‡ÝN•Õ#–_n™‡Gï¤pp ,Z…ÿUu›6È“÷ÃV¦›Ó°¸å0EK‘7*|·ý]¯{ü75F\éÔ¶»úzQØ z!á‚Ç uH€>îÿó¦upš²ÚöõTÙ£»o3P)ˆø´[à^Õ6ãÖÚóã` -šd&á*=¶%ÄÀÊfY’<¿^’ƒØ·`_6¨ßÈ|h¸Ìë3Ø¡>€„2 Pºúqÿ×7ÏŽ³ ýÕü,Ns¾j»F™=BµŠü` ¨í³•C§òöiŽU’)Ré@LÅßÒ®„‹ÿ‰·Ç§mb<2FH“Rq°²ùF½åãø÷Xºi䎲õOm¬GAýÝ·ôÒ}:¶*¾Ëu ÄfØ:@Ê«RH™.òÙ6Âñ¼±Ã6Žjå§cæGOpO- ú­6HÒýúÜÊKÉJæÛUÀÎì:ºJǃ¾ŠýÉvÆ,¡•¸¯3ÿ‹DìZ‹¹EñÊÆ®ÒqqðìØ7p?¸ƒÈŒÞK¬÷Å%ȧ$;â¼?ýQ¬r6³pP7`¼a™†¸é^=„„ýÉRç¶_†õ™³)m£„Ç>ÀD3#£ ¼_' çIþÂÉ­uÍ‹CÁÊ-Rne㯄³²Ïóss•ÀîLÏÌ<È­/µàR)|Lt_1»éòÁ¨L¿kÇ=‹rr 4ùìê§ü/gýšEÀrþÀ~P†¦nBß[ ®\g[{¡«‡’g£ãYÛvRŸW'†‡ {Fe°m1ïÞŒ{ Ýw¾LÿÕ;7¨&$‘çþxúcÚøÃÐ0Ÿ ŽžnÝö‰óí&úÚuÅ@5sCèCÕ±mœñ8Hƒãefñï¹Æt ’Îx{q(a¿²ÛÑ‚a¡?€ŽÐþQ“%ò§ÌlÁ¬ö4ô‚¤Ï‚xmWI׆€Gí¯¦CèÒôì1ê’Ûk×QÖýŒ3iJhÜ,Çÿ€úãú‰KºšRˆ÷ÅÄð¢ÄÂÈöÈO`úÈç…ʲ»†½þ4á)ú%ˆùÔb6îB8ý\ ³pµõšÉì«e<êºíS鹂ØìÚ+ÓjsðÄpŒ„¸ß%<&t{3?Œ£¬|N)p7b™Ôîãé?Ôa¤iäDµWl’¡½ðˆX—ŸÀZÚ>;uø)¤ko)#WáÈÍSšn®cR½xô”{[ÀsXv1¤¬95‰_¬¬0KéõÁŠ¶Õ™7Ú>žTp¡5‡‹¸Ù´¤l3¥Sü"ØêLXê…ç«[á5mö¡ø º¿Q="u}ö‘ÆpϘ*xböÕ‰ºîã—ã#iM+³ù@»Z! þ·Ï®~jàÒY”ݬ‘¡´Ò$?5Š• mtêuˆ] ‡%Ž@Ž÷Ý…:4h8Ûƒ¸˜¡»tuì3À;ú ΑO¤1A/r‹¿¾™ ÆÏR*5ÀÇûÿËìiÜ&j#Y2:º$Z(a­dæ@ß>'z ž„×L¬¯³¬Û뇶©½6ZÑÀ8|`Æ6Ý"åŒX1ß_€z' îF-©÷»Ñû?°úX^ò A:?1¢;ØÌh/KžVB'õ üvOnÏFSò‚¼É õƤê°ïÌÞQ{=kh7™ÀMå¯ÀwXQùpü\vïÍ“ÎO/ÿ¶.ÅöÚñ¹ ôN3·ÍHKRðÉlŠK–"›qò”‰^Wܳh¼1wtùã  h@§¬Ñ3ðe6þN|–’¶Á©‹I;yîó?8t[ƒ[é!‘ ú¥µ$,ήL­·e–"z¦å%IÞ†AêkÜÌRäl!3uú8àÚyßë?_žWÅé½)ƒAbCÒõéõOù!rz¿„a¢¤5S±ÍnÖ—£³ˆ#Â<ý43yÜ6"ª ÒRýêÑô߃C‚Qå¿&>¸[¼# BHÍǽß{v¡eà×kOÃ×TÉlq(UHð͵h »Ý”8º,@t°µöÈÃÕ‚LÛ{p´•ü‰/Ø*ËL"d_y ïŸk,4î GÌ–ýÑbD>,ÁÏ.ok"ýD;†|7–[.µDÖCíAœŸä#‰iÇæélÿü¯‰ÏŸ¡IÖ¬ÐòâóÞD¿q½]+ÞeE •ò–_«-- ™ƒ¦ Ú°c©›³èç€^ø¿¥Lô˜q±1~ëCßC“ÿ”øžC“9¡ŽgNäóýÿû“õHÈ8Bkhêç«JÁŽ#Z¤-`úVo§™MËa 9r$îÕºZ-¼hókhò ?C“$· û^–ñtÄ÷¿9d(‘8PÝ…]Ú¶š£×w[¢wléÏ;µŒd•Ôn—׆ôoÎK«èdù H¦Þ„(Dú¯…¯Ÿ¡InüIÌ Mïãü_(ù¼ðœ’îð5)6H/öõÌYÍ1‡¸ ±QRæŒk,nËÖûXH½­ʉð‘ƒÊË?>ÿšdf“ç&6³üü½^EJ–m‹ªétÞÈ{¥C—µ›½ÌC¬c`½îÙ0Ê…v5ÃÂx<äƒó\9Y·Ýÿcáû×Ðä}1Ú06"×´!ÖóŸë9êdl:'– û1H"Áz'7ùQ‡q›„¹Ž¾¹ÉŒí#KâR.ò/C“»VÖÜgÇQ×Ȭ¨åéãó\ âì`¸·?dÜÛ1y³”åuMÛ6Ƶ8ZX]8Ãø^p…ªwQëE¾ç &­1frRšÁKiûñçÐ$G¤ÎÓðÔÝœÛÇЕŒ¯ðh3'À®Âø”·“Ç{¼±š;;Ö~F öKî37Ðkš–Ìu<pöµdÊŽåèˆ+C¨š¤™ Rá‘÷Mz¹Æç¿7)nÒ€©æöÔ lEGyÍl½‡:Ì‘ÿIÞí’o±BìÞÿ—S%|ë‚ÎЕïsTuÆleÁõ’bšA}A¸ëæížÍ´þ1ãý0ÀA{ÉKù“ʘÓº¼tjÑòÇÐdLI=rž ¢PRgóûÇó_Lb¸R³£é Åžël?«â”ž)!°Ö[«‰FÂæoÖç wi&k^”CV(t@püW2Ó÷²ó{hÒxH—GRn²͉ŒeCbúxÔ‰°ªé6GÁ³©÷‘¬Q…Öd27\ÌØ«dœS‘É=\»F§f*¼0é‘Û£ÜOPúÇ5(r„Zß™xQ‘Z>¥~G AeN-õãùÿjYôÜ7—Ò¾n;ún?Ó¹"P·¯xÒ}‡·•/àNäöÞW:ÝŠ&´—×¾†Ù:x" ꭥу;†ÄRç펔¹ ®cä›…Ñ™õ±ñÜýüýElmG§a= hò¨BG_æu…³×YnZì«­FYs ôUéµ"zM&Ë:ËÝGn¸Ïuí.õDX‰ƒÉ5XnšÁ¡ö›;Þ}¶Ô«%XO?½~2&ùÝØî¸Frjj¢¢…8ˆ› yAÊÆä*±W ¡³‰€©ÒIÒ˜÷“9/¹§u‚b)õZ³l:ë sá¼¹ 8²5ÀÀJõš>~ÿi´œÐó˜I¿þ3YÏÔ•;ç:#hEL¬×[ROd‹Ê^GéšAË©fß~Y!ýËÐäEåêñn·ôü0¯~Åà/«AÝò –Kåm÷‚±>^ÿÝWY¢q†"µ¥â<цFŠ²Îë*c¹½:xÛw„|¤Ížw­—%ýehRg°åØúæÜæd¿9ç´üÌ•ªËÃvž3Àv Dg™hç>>?ÿò3é‰hŸYDkgCã(ʹƒªÔ•ô×SÉ·†¬Ôœ|è 2QÁü94©(ñ½?OG•Q34… fëcc³¶PopT€Yaƒ–W(£>Çÿ@­tãX4ˆ`ðLG¦Ùžp•‹É„ãaïãšÅ°l\¤[9‚cû26óâU M6f,ºŠò¼Ë'›¤…žCÐÖñ4øi¥?W~p¯sÏ ?žÿk³ÞA÷×KÃrŵÄÅÎk@–Ið|>^xðs¸?ý\Õð`,DèäõÌ’©Œ°Žû5¯éWÛüÉ^£èøçw €DÓµMˆáøXf_8<%|8_왉pPó1†…ãî„WþÀlm߃˜“Šf?4žý¼»:½òÌ“_£Ô”v ûûMà;kž:pÍÖ²â_ÖùásjØŽqw]$F‡£}ÿ¢»y« ××û,b'Õè°N‡Îþ=Ôo¹öÖôÔ0, õ¨Çÿº»â~–ÆM‹ƒÄû Y•R´‰¥4â6+!”}@~u‡j°ctCÔúàõP.ÅY(ýxÿ׎ ½×zµ?70ÆWXFÜ£¾oŒ½·¯‹3z‹Š€0°®Ác8¨R£êG±¢g›0àö ¦T—Uëøò„½»‹w­"/4³ÞÖ÷¿¾îC¾Q`[{O³“ºcÈn¯]•¶+•{Û{­ç¼ÞÕÎ N!3•<®ÞÇVí‚ìyxé,!C æ™b². êlfÖ×åÁø'„ÒÁ\ ןÎÏíãëgu,μ·¸šw-/ôß3Û¥ùºñíN°íâX(›c ƒŽÓâoõMDð‘sÊ¢a·#ü#0{c ÁÈÀð%µuDWCB¥Z€AéÍZ6»,Øçûxý (Z%‡±µØçw€ÑÀáŠHbhTb2ùþ<$÷Æ*cÀ¼ænk÷³”_÷וð«Ð÷¿#{D+B<™!âÇüS/¼gÿÃ`ø9”­.^]ŸÃŸ™ÆCíÌ+>™ì3ïƒ+•ý5Æë]¤q‡„Äp¦j' r¯9µ¼FDȬ)~: ã躟—9GmÜì“x2’¥ù-?s–raG"yvU³pa;R«çãø÷ăœ ÌAŸ\&ú¹“ ÿ?#Äìn Ûí0Úee½´“d~o’q嶭¯!!DzP^H)>¾oµëÈ‘.®Ä¼‘Ô¶=Hy»7´S´-M½ á?Þÿô8y£c¶Î™ß§q„|Ü#Þ5"ù2Б ‡lµm#—ýU‰ÑÊ»ìýeüΤÎV†ÎÈbMƒ¤Í˜÷jAÌc7¾Z ä]> 4½gbö Äýñõs 2WRsKgí6Þæç 's8qzñTT[”R›[wÄÍ)I‹—9ø5x¥ŽÜWjýÚ #”!nN+zP’ÄÚ”â ÁKgâ²ÁÞTEŒ,ÂÁùÇë?³¥{é^R¨DÝ¥=´R¥u^zîc¯’§³Ì¥&D¼‰'i74øSËJ½ß”í&H¥æU©Gà»[û‚ácrÃͦŠ<ú’‹¡׿~þ‰4}Ú…žíh¢°Î;¯üòlpAZð´%’XÔZ;t®Q?„±÷÷žóy™ïk1+Ƴu6Â[«©ÌÖè† áDõ™c4¿ÆœÚóÐÝ*d„•B#!}Þÿe>Çsamh¡¹ÿêG3c^çæ—8u9󼵕⸈߂ÏUéy‡‡B;f "Yi=ÖD§ =Êâ‚Á4‘íŠ&¡Ž’Þ×|¾Cý“Ò3»Ä÷šg]Ø~üþ›WgjhSIXU“‘"1A5Fr4×{üáÜëAä—éljŸw¸TðÎá–Ýt6<ï/NÁ  \û¤õó«R¥tÇû˜a| Æi¨ÌÍ>‰T.šWo>>ÿxŒ•Ï¯¼Y¼æÈ{ç··m,J²{gg}Év~)ê]Ñæs!?wøè÷X›‰æè˜G—F°¥l!7Ž†UœÖ|Cnáfï³…:.@mq%®Á臔±ÜÿÓRu?.–:¯èaBë¼ÖºÌÌE#Gƒg'yX«Dåÿu‡SWºä™ÇŠD)Œ˜21×ѵ‰VµˆagW¬àPŽ³²q½ç«ÏÈ’Ï Ís”?¶•@åg")ªíªç©s\ÖTòâô{Þê«f3g÷‰oÑþÏ^w:^ë¼"•Ý{¹ªd#³!φtà}©,nÆyWFKv„X”4–ƒ|<ûB+ è®Â8ˆi=-;´³X 5l=/xlêóŽw•–å÷n³]ì à+SÛÓ¼,{Õž¯/ДâV¡û»+<< Ø̤®Ào ŸâÞçèÔ‡eNpù^Oÿþ¼ÙùŽOv qR¶ £wHF3ûÝß=oý;ü`~k’RÏwCßÏí²”u¦ãk¡jE˜|û‰qÏ©ŽÔ‚KV,Ï àÏ*?ÞÿþxkáÜ}QxÁU¹éœ/MÛüÞÄÂá= ¤Õ°pý¾Êæ=çŠÎ^xúBË÷ÞÚKx«§Ó@ð[òÎI™¾ÔYB]Tª¦âž™çÿúÑKqÉ.á½€PÖÛwÿ¼ÃÓAG\ôšWÂÏ‹Øâ9ùãÏ2S³—åA\è“Y\œßy=ǨðGj÷¾ÌéÇõÕ¢ÂMî@âŒtÔ‚¶„vD¾üƒzÎ+²ÙÌBĺ\·Ÿ¬ü¼ÃÕ¬…÷Ùë6ËÛk™6Lþ¸Ê¦ÚRß_rýnl|UAϯ< ¢¹Ë|¦²!‚¸;ºÁ8™_1ÜgésÞùÆCŸ‡ÿ¿ä >êVB‰~æ,¶¹® Ë˜_ÿ&f™äÕjpñ/WÙÔÊwaùO ¼š°H 3ÉÛûþ¾I`˜ÈòuØù»õ¸1êͤÉû·ÈÏ÷ÿå+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò•¯|å+_ùÊW¾ò€ÿÝš™w)¦÷ IDATxœíÝŒ×ð¯Ù2G?,™ÛkkÔ³q\Òr’ž)ÔÎET‚ÂÙ½Ü×URàö․AWW£@6rEÕó¢¹¢X]Z;¡€¶WïmRnUäâÝ4u¢q~4"sqÌÊ¿"Ú^ÅÙѯ•HY²5ýƒ;Üáp~¼!g†î÷Øä ß¼yÜ]-¿ûÞ›7 Ã0@DDDD¡ÚØï #†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDC¨^¯CUUÌÌÌ V«õ»9DëÒ¦~7€ˆˆÂ¡ë:*• 4MCµZmí?pà@[E´~1d%˜¬TUeÑ€aÈ""J°R©MÓúÝ "rÀµNœ9wKX<·ÀÀ™¥¬4®Î]¬ãõ‹ À0,G€±ú`tG wïZÛÞ7ÀÀèÎ-ݙžÑØ–º%ÆwDDD4ز†Ð™s+8ýòyœ~å<Îœ[ÁÒÅz[`Ð T†¹Ïè| –×–.Ô±tájk»òÒo×ʬֽ-u Þ5z;¼ïxøwïAæž‘¼?""¢$`Ègέàéþ•W.`éBèO.Ë%|¹ïÑÛµÒ¸ŽÊ‹¿EåÅßâ©ù_ sÏLìÛƒG?ð;½¿A""¢„aÈJ¸Ó¯\À׿÷"N¿rÞ’•º X†ÿñËéøÅ×.à+ýc<õÌóøâ?üö>pgWˆ(‰¸NV‚ýÅ·5>ñÿÄ–aÄ° Çã—.\Å¡¯}O}çùîÞ(Q1d%ÔŸ}ë˜ýáYøœöí^–ÎòÆÚöSÏ<¯Ìþ(è[%""J$&Ð׿÷NV_‡oÀiÛö XA—×ñè X¶²'ò_œø=Ñ·KDD”HìÉJ˜¥‹ <õ½,`Ñ,Ëp¤_Ý'òf¿ÿ+á÷LDD”DìÉJ˜¯¯ÙäbFw܆‰‡~™Ñíغy–.6ðôs/ãôKºCy—€e ðž“pB< _ýÖOñðïîÂè[~ˆˆˆ’!+aÖ&¹w†˜=woÃñü!l½mmQÐ=£Ûñð{îÂÉÓ5|åü î!È¥· hQ]Oˆï<þ©ïü_<øà;'J¾z½I’úÝ ¢È”Ëeß2ããã(—ËA>Ÿw-§i4Mþ}ûN§Ãlfl8\˜ Kík`YÖÖÛ6u,«G÷ÊøÌGö8 ñY·-Ï,Aœüñ X:ÅûM%œ®ë(—ËxüñDZ°°ÐïæEjÆ mÿÍÍÍu쀹¹9”J%èºîZ×ÜÜæææ<Ë :öd%ȹ‹×à6 ÷hî^×€ešÈߧVïqhB{óµË7Ÿ}¾†‰‡ßãÙn¢¤©×ëPU•7m¦ugll¬m»\.wì3ŒŒ Z­bÿþý¯éº>ÿv²dåÚÕg!æáwû/ô¹í¶[½‹¯_\«èjNUû¶Sy±°Ó/žcÈ¢¡P¯×Q­VQ©TP­VûÝ¢W(ðÌ3Ï8†¬ùùyäóyÌÏÏ÷¡eáápa‚œ9·Ò9ÄØB’·-›Í\GÀ2¼‡ `¥~]¸íDƒlaa¥R‰‹H,Ë$ š¦u¼¦ª* …BZ.†¬$ñ¸MÎâÒe¡**//#¼€e8”<~µì•CÑzU( ªjÛ¾jµ Y–;ÙÝŠ!+q¬“ÖÕ=Nž~Õ÷È“§Ï"XÀ2Ê»Lˆ÷ Xkh-¾–Ü DDÔ›\.UUQ¯×[ûTUõ¼ê0I²’Èa÷3ç.á«'ázÈâÒ%|õýÜvüjˆ 2§Ê@gÀ‚µ¼-  ÷–Ñz“J¥ÏçñÜsÏhNx×4!‹úÄã69³Ï½„?ýÏ?ÁÒ…µ¿V®ÝÀÉÓgqèÉàʵ½MZ™oeض-­u:3Ñú¶oß><óÌ3†« àÕ… ã°ÌÄòì/—ðì/—°õ¶MÝ!áÌÒ%t†€Ê|-ïã F,"¢u/“Éh.>zêÔ)>|¸Ï- CVâ–¼âÞËt¥qg—_k>x„ Ð–{˜cÀ"""ÓpâÄ H’Y–ûÝœÐp¸0aDVûœ(Ûk@眪ÀËp(ßeÀ °ü §|>ååå¡X¶ÁŠ=Y â°üN[§ò†»<Þpj ¥'Ÿ|Rh*•r,ëv|R0d%‰×ºTr›¯1ç€Å°EDDÉ!+‰º8} X–µ¼ÜÛFDD4|²’¦¯Käøö€ex–µÖMDD4\²ä3Éà3ÉÄr®C_[ÀéÞ€pÀrœåR¶õÀ€EDDË!‹œyõ` /2*Ø[F¡°ßdu/…Öu}(îKFÉQ«ÕÚnÝbªŸE]×±¼¼Ü± 3†,òá6ÁÞáµn3V µZ µZ gÏžE­Vƒ®ëÐuÿû?¦ÓiȲ EQËåúò¡R¯×Q­V¡ª*4MKüUCë‰=Àƒý¡mÞšEÓ´Ö¿?™L¦õoDQH’CK»g¾Çååehš–¨ßëÉÃàµôqºríN¿|‹ç.céB£í8FÇ3§!:û¶WϤuÃVÖòü…×/b¥þ¦Ë¹œê XÎÇÿèßÿ“µÝ—N×_i¯ß©f]›ß Ür' ý=`ã #3”T«UÇ¿Ä»¡( öïß\.J}nÌ`U©TP­VÛ^‹3dÍÍÍ¡\.{–ÇØؘo]ÓÓÓŽ¡#LŠ¢`rrR¨¬H{Ž9ÒZUÛK½^o '‹‹‹¾ÇȲŒL&ƒ}ûöõ=t©ªêø³Ö|>|>EQBhYïÌïMµZm…ª0(ŠÒz¯>ödÅädå5<ûËßàÙ_Yæ9y܇0ôIëqß&'Ðñ× ¼ù [À²Õa}l<¿¶½õ÷;>lº³³Þ„Ñ4 ªª†¬ìõkšEQ011ú‡c˜v-¯ ,Âì)ZXX€¢(‹=˜¨ªŠr¹Zð0ëTUµoïÉ×ï‚r¹Œb±80¡rX0dEìô+çñgß|ÞÒcÕbÖr„`ÀršÓ4H·É ÐÚØ{°‚–ù¸ò]àêôcÀöýH"MÓ077yO‰õ|GE±X õ/ÙR©Z] ]×Q.—Cýð6?°÷ï߃†R§—z½ŽãÇGúïÅúžÆÇÇcFŒûw®ë˜žžŽí{·^0dEäʵ·ðßþNV^õ 1âË%à´Õ×^wÇk} XÇ;Tw°Ìƒß¾ ¼ñUàÆo€ô§:ëPµZ ³³³±ýBµ+•JÐ4 Åb±/ç§øÔëuÌÎÎBUÕÈα°°€ÅÅELNNFJ4MÃñãÇ#éÝq²°°€jµŠÃ‡G:,w¸²‹ã{·ž0dEàʵ·p¨ôcœ9w¹·€Úmrêv² í69AVˆ=YÖãÏÿ—æ\­íƒ¬r¹Œ¹¹¹®wš€ìv%•óC—AkxÍÏÏcnn.–`R«Õ0==ɇµªª}é-5{{:ú°š®ë˜E¥R |¬[[º jQ~ïÖ†¬ X!(†û;¾³­Â˯·¬CË|<÷oÍ÷7ÿ@º®cffFèÊ'«\.EQZŽÝد桪*FFF„&€¯Wn½ËË˾s‚Òé4FFFº>G·–——Q.—»úЕ$©ëPV«ÕpüøqáIü"‚,Y–[ÿfvíÚÕ¬W!Š›ÖëuLOO‡:Ä4üær9d³Y(Šâ{uàââ"*• TU ô}4{×ùGWo²BöÏÿkÅ°:CŒc0é) „˜0–ßmrìÇû¶-¢ž,óñÿÈÿƒÆüKQô—žyP6›þËR’¤ÖUCš¦¡T* M .—ËÈd2œëbbbÂq¿ÈŒûöíëK€ %étºui¿,ËàµZ­5!\ôgWÓ4,,,`ÿþÞçI X¹\û÷ï÷ü9N§Ó­#õz ˜ŸŸzo³³³e¹§@¬ëzk¨Þ$I( ( H¥RÂçÈd2Èd2Çüü¼ïϨ•ªªÈf³‘_…<̲B4ûÃ_ãôËæ‡XXË£·«ç€0 ݇°›0×^Mh põoKÏ·è—[ÛàRÞЬì)pO–­M€k/×^Ä ù…\,#¹‚I’$>|Xèìüü|¨ëÑàPGŽé9Ä‹Eá^Ž s‚¬Nœ8áû³hþÖ%¢s®Ì5¢F/¶Y–͵âzwÝcÈ ÁÒÅNV^ƒSÀé-`…ÐKÔ1ÉÜÐÂ\÷Ëðh›ÑöЦ£'Ëž¬¶ý¯YŽ?ÿM‡­OétZx^P/½4x$IB±XÄää¤Ð ð"ŠÅ¢p¯ÈsÏ=¸~MÓ„†%:úð¶èB½år9ð,ýd®UÒÞÛ aÈ Á³¿ ºŠ»¹O4„,þíP·SÏcÝ"Ëè(/&[‡ÚR–S@²¿×¶2¶vtôd­n_>ZS(„þBVU•½YC"—Ëáرc¡ß>%•J¹^ `×Íò"ó°ü&¸wK’$á÷6;;úù£&úÞ²ºÇ‚“•W›O„–±öŸWi=¸„!>ïºE–Cx p|ÛsǶÈìr¸œ½#`ùôRÙÏáÔËõö•2…‚Øbóóó·„¢vðàA:t(´y=vù|^¨)臵HÈ—$ ãããê ¼²×¹D’˜7‹öׂ¯Ãˆ!«GW®ÝX]²a-¾¡=„ðì% eB¼¹í°às¼×ùÝë¶4[¥Íhóöt,k;¬Ë¡N¯y[ìÍj#Ú£åÊà8nÜ,:QçºÜ¶;¿MŽCÛÚ¶½¾M÷ܱ­m×_vX¶«n\áäM+I’„®(35%ò":\'²4M*{à@ô˳¤Ói¡+¢m$\/Z Y=:³tyõ™àmr¼BˆYÆÙ‡Ë>éw|йd«öfî]Ûp X>Öó{=^ýYÇù×;Ñ_°ÝÌ¥¡õ%È"DzPLŠhÏo҆ףB¦&†¬~ù<Ö–%ฅ¯"°zœBŒo@êlk UÜCXð 5d5žï<&¬€eÖÛ0×2#@`‰„IÛ{±ÉìÁ_~á±5uksÇÍ«ÀòSí©Œl_/ëþn–ùøö×ö­G¢½\â"ò³w/V YdbÈêÁÒ…«¶€4„ø,þíPwëxëëNu‹,ãm>a²u¨{ÀÚ›¹·=`Àò“ks±œÞ«SÀj5ÃÖn¡ fp^– ‡@hˆþœõëª8‘9Œüƒ„L›úÝ€$»Ò¸áÒzp 1¡Ì×ò>¾÷UÜ]Î﮶¥6㱿ÿþöÞø àÒ|{ýÖ ×´ÚÚ¢ìír9žˆV£ÑèwBQ«Õ¸<1dõ¢}NÖžÁBLhË=Ì…s›çºÝVf×>þлñèｧ½÷ ˆ `ùÕcy\©[Ã]8q½à‘˜a ‹Ô†¬žù„À!¸¼RÀÚû®»¹÷lMÝâl;{wŒ¶çe8î6WpÏìé V@sÖÒ¿ê t$—ð)<ïÊ|Mà8ê ?8ˆˆÄ1dõ¯©­ŒSù=HžÇØû®»ñèÀ#õ6‡p3.þÏæR o_Eø+`=Ô2Ȉ‰ˆ’Œ!«g‚ÃhaNˆ·lï}×]xìcïGî»z{Q¹yX™.–¿é- ZžÇ‡øþ†‡ÿˆˆ¢ÁÕ‘€$2äçu¼SyÛR·â3û»˜xø=îÍ{ë,`\u †ç¦ãA†Ïëæî·~Üx¨ÿxóEÿ`vÀbOV ¼jˆ( Y½êyN•Syïã·¥nÅñÃÅž{vÚÚR®}xóûÀ³è:€„dŽïKÀbвâåæDác1 Y=ÉܽÝá à +x@s XF¨¸öƒæ𜽾¨’×ña×vp#¢$z‚Aÿã •Jõ» 4²z°5uËê3·€dù@÷ X=,Ö[g•¼½ñ!Ëf½ÙƒUÀ «>· dÝïx¼!Økh²÷z·ç@kD{²E‰¸%DM¢?kq­ååe¡r YdbÈêAs¸p ž kÏÍò®Ûýà¸{ç–µ_ý«–[° lí·!{@rl‡e¿k;lÇtïPÆ°yÔNôƒŠC…—A½i¹¦iBåø ™²z°gôöö ´‡‡žVóáà#–µ°Þ^n.ÓÐdÜzz|•=Øxõ $‡ é~üÊ8¶Ãákíø5pØÏùXD?¨vïÞqKˆš²Y±{‹Š†ž°ˆ ¦ÓiþAB- Y=Ú{ÿ;,`9€5zÇì¹çŽµj¯ýKH±C´§ÈÞ.¯^ ×ðãTÆqi‡µ}žáÐZÆ#dZ¿R´¦V« O ÎdÂýÚq.yÉåü‡õãY"çc/Y1dõ(sÏíÍ'¶!>÷€‡ònÛyŸ­÷ ñý¶×Ûžî)²µË5ÈØêõ jÖÇ°R˜óÇv> Z#ú!%IRèóLx³iò"Ò›¥ëzla]×u¡ž¬B¡Ck()²z´÷;’åy׫iÔ:«u›§bžK´§È)`¹=:,¯€$Z¯ËqAëñ;Þü:måœ,Ñ%:|„è$bZŸDz²àÔ©S·¤©R©ø–I§ÓœôNm²zԼ X¶°x,2÷Z† ß^ö A{Š,~A(H °‚¤^Û;­ÑuÕjU¨ì¾}ûÕ-òA÷P%K*•B>Ÿ÷-§ªj ­;Ïbh % CVîÞ)Ù† ½Öž·Ê[^³,km€·~ÈH?VXí jï­íH§Óçc‰¬x-ðhý÷-Óh4"Zš¦ùKJ’$ i}aÈ Aû!Ú?ø±úè°l½]†µ,ÐY6ìâUO?VXíÛ< lÙjª×똟Ÿ*ÛÍ_ç"WWÕëõØz!‡HƒI§ÓBÆår9Ò{–Ëeß2…B÷+¤ Y!xôÁûÖ6ìÃö€eŒîÒÛå°ÐyLXÄëxÑ UÀ «}£Ÿ´!×µR©$4ñ¼Û¿ÎE¯°ŠúÃ1N"ïYtÅpZ311á[F×uá?‚Ò4 ‹‹‹žeÒé4ÆÆØSN²B°çžÍ ê®Ë@+`µ¬¶òÖªC q 9FÕ3&RÏÉú¨ªjdáCUU᡺‰‰‰®þ:´¬ë:fggׄ¦iB“–{%òuâ²Á¥Ói¡aù¹¹Ð¿¾õz333¾å<êyix0d…ä3}ïê3‡€cn·¸,Ã¥¼µêˆ_=aµ~NžçÇwlE’¨ªŠÇ<ôá´Z­†R©$TV–å®ç˜ˆNZšïU´MA躎R©„éééXÂ,˾sÑêõ:ç¢uallLèbŠ'žx"´?Nêõ:¦§§}{| …B$WßÒp`È É£¸£w¬þ‚õ¼‚Ð+`ÁùøµÂ ¢)Œ@äÙ‡¯MkŸS}†x½»?‹$j4(•J¡…-UUqôèQáòÅb±§ó‰ô>˜TUÅôôt(ÃiõzårG}ΗȇmTÃZîX,ú†ØF£ÊÏQ½^G©Tò ç²,ú9§õ‡!+DSù,´‡¡€å´¬åz ¢õ™å —z‚a+ß°àÐk_—ý^AÍ0šÃ„ _Ëì‘ùÜç>‡r¹øD×u<ñÄz‹ŠÅbÏëýˆó˜4MÃÑ£G»zæñ¥R Ÿÿüç177×—¹^"K]hš†¹¹¹Z3\dY þµZ _þò—»^"DÓ4LOOûö8J’„b±ÈÉîäiS¿0Lr܉G?x?NþäÅæŽ^–Ó¡u¿k°it2öý^õ˜Û=ïÖ‡÷êæö;ÖcÙÞ´ ¸oâÑh`nnssse™LŠ¢`÷îÝmWóÕëuÔj5Ôj5¨ªx¨,ŸÏ‡v)úØØ4MþÀ«×ë­÷˜Íf¡( dYvŠÓ4 º®CÓ4T«Õ˜@ŸÉdËå|瀕ËeÔj5|úÓŸZî‚š²Ù,ŠÅ¢ï fV&“Áøø¸ÐE •JEx¾¢$I˜œœä£ä‹!+d_øÄpæõóX|õüê€eŸ¯Õ±Ïú²O ¶ý"õ¶•±× uœ+àñžïÏöø® lJÖ\,QfˆZXXµÞ|>ßó0¡ÝáÇñÄO{Õj5‘ó—ŠÅ"4Mó }•J•Jù|Ùl¶#,“3ó‘žÙÅÅELOO·Vbw EæX¢·ybÀ¢ ²B¶õ¶[püÐGqhæ;X|muÈÃ!̈,[Ðê)`¹ì÷ªÇþØѧ÷ÖeÀ {xsô“@úÃH*EQb_=Š€4'Á9r333ëb•÷T*…ÉÉILOO õ®©ªÚ6w,N#›ÍòŠ5ù|’$¡T* }ÍûöÚÍ!K,Å9YØzÛ-8~ø>üž`Ë€CØ°qœÏä@b X†C;œÚWÀºïŸ÷'{˜p||SSSÂëMõêàÁƒ‘,“<â¾y®¹Î×±cÇb=¯,˘œœìªgJ×u¼úê«´j¸d³YLMMÅx …B¬ç£áÀž¬ˆl½íVüÓO|¼o7žüv§Ï,ÁŒXÍ[o•5DØCE›H@¤ÞA¨çöù³ÍÇ!`~P/..¢\.GÒ ¤( &&&bûà˜˜˜@.—Ã7¾ñHæÌårÈf³Èår}›˜,Ë2¾ô¥/á駟^w+ÛÇ%Ncjj ªªbvv6’yyqÿ¡á±ÜwáøááÜù+ø¿??‹Ÿ¾°„•úuœyMÇJãÍf¡0VØA&ªàæñÛ÷®>>Üña`K°ûë%E&“Áää$jµæççC™ä­(J¨܃Èd28vìTUíúJB»t: EQ (J×Á*ŠùP©T Åbããã(—Ë3AØäóùÖóó󡬋–Ïç±oß¾À÷í$²Ú`n3¬ià\þoÀå¿Ž'`íþs@z_´ïgšžžöí•:räˆç/÷jµÚºjOôE–åVÏ ýUn½ R¤·NQH’ÔšÈ,˲P@zì±Ç<_÷ûš‡¡^뾕 ÖIDATÑh´¾gš¦ayyÙ1d*Š‚ÉI±!o‘IÛ²,ÇÒ£7(m1ç_iš†³gÏ yEQZ÷JT%ò6Ê× €ïmƒ0lv‰=YIç ¬l6Û¶ð¥ùK²V«µzJÒé4FFFJ¥*TÙɲÜq:û/ý^Á‹|ˆÄ!•Jµ¾waÝën¾·ƒÒ–t:ýû÷cÿþý­}n?étº/WuÊ× `€ŠCVâÄ°´’Äü%9,¿,‡å}ÐààÏõCV¢Ä0'Ë,÷›¯¤µòmõ8´§mÎõÂv¼Yß»ýoÀJ5®ÜMDacÈJ’8‡ /ô^O võ× ßÑp`ÈJšÐ‚–µW)Ì f«·uœµ—˶Ÿˆˆh1d%NÉåx‡…S]’c=],f,ŠÁòò²çëìÅ"¢(0d%Jɾ‚ïÖ‡á?ÇUàöEÌï~Þ¤™ˆ¢À•$½A«ÿ +` HçrxdÀ¢Áž,"ꆬ¤q XA&È°¢ëñ–ý^Çw»z;Q„üz²FFFbj ­' Y‰âhàV/·ÇÙ–ÞùGÀŽ¿ßÜ÷æ ÿo൯ûO1¿•äÙ“EDQ`ÈJšA¸¡½|úç_´·só(pÏŸ4Ã×/û×C‘jµê[† UQ6ö»@[oÕꎸ–a+ëÝÀ®Ï¹·yÛ^àÞ?aÀ¢¾©T*ž¯+ŠSKˆh½aÈJš~,{}wþðŽ­Þm¾{¢³óø[GÅÞ7QêõºoOV.—‹©5D´Þ0d%ÉÆ-ÍG£ËÞ“•Úãßîwlköh9µë6†,ŠÎ‰'Z7Ìvc½Ñ6Q˜8'+In½¯û§°V×C}.õøõ‚uIUUß¡Â|>t:S‹ˆh½aOV’¤ÞÛ|íÉŠ:`P_ôo÷[+À¥ÓÎõlÿ€à›'§ª*J¥’o¹ñññZCDëCVÒlÛ¿ú$¤ž,Ïz ÿúÎÍú·yééÎzÍãÓxÓDâÊå²pÀb/E‰Ã…I³ã€KϬnXŠc@2‹u°à°ŒÖ& ¸~xé+Àý_tnïÕEàÕÿèÜ®;ÇšK=…@Ó4ÌÎ΢V«ù–Uccc1´ŠˆÖ3†¬¤Ù|°ó€ ßê"`Ùlå;–½‡ã X> ¼ù:p÷A`ç#Íýo.o̯>é\ï¦mÀîÏöô¥ šájnnÎwÁQ“,Ë8|øpÄ­""bÈJ¦ô?®þ xó¥ÞRWË^ÏêöåÓÍÿÜê±?Þ?É^,ꚦi¨T*¨V«¾·Ì±’eGŽA*•Š°uDDM YI´q °ûϳ \{±·€d-ßóÚY.í°?f¾Ü*$ it]ÇÙ³gQ«Õ°¸(p±…ƒ|>ƒ2`Ql²’Ê Z¯O+j€€„ˆ–Àã¦mÍ,,raöPÕj5躨—Ê$I(‹\‹ˆbÇ•d·»¾œÿ&ðÛÿÔ\*? …°nÿ@3`má=âÈ]£ÑÀÂÂBhõ Œ³÷Šˆú‚!kÜñ‡ÀíÎ.üMs_X©× ¶y´9Á½W$ ŒûJ’„|>B¡À%ˆ¨¯²†Å;¶÷îüãfÐZþïÀÛ+Ñ÷d¹ÕsûƒÀ觸–ƒB¡I’|W#_R©dYZ†ÁN–e är9ö\Ñ@`È6·ÜÕ Zwþ1pùpéÍÿœnÀºýA`燛ÁŠWºÊf³Èf³h4PU§Nê*T +EQ„¾’$AQ(Š‚l6Ë^+"8 #ðMè(‰/W*ÀJh,ožCOAëÛi°ýÁf¸Ú¾7®w2”t]o.]×qäÈd2ësþZµZÅÌÌLÛ¾t:‘‘ȲŒ‘‘d2Ȳܧ‰aÈZ¯Þ¾ 4Î4 ½¾Ô O+§[¹Ër)"Ê›¶®«Í£ì©ŠP­Vƒ$Ië¶g¦Ñh V«µ†‰ˆ’Š!‹ˆˆˆ(¼A4Q²ˆˆˆˆ"À« ׃Õá¸Ç…7À† 1Ÿ•ˆˆh00d%aˆ…§˜ƒÖÁs1ˆÑ°bÈJ ¯0%´â¾¾ÁÀj€ò°€±aƒe©Ûë _DD”` YÊ5¹*·ò^á*Ìà刚Kj®¯»ÖÕ< £}ìõ""¢$áƒÂ)< *§o¡è>¯ý"¼Â“Ókö}Û;ûüÎMDDÔo Yý$¬¼B•_àjÛörÄçlùõ*y…)ß e-ëpÇ} \DD4`²ú ãKî¬DCVë¹½>Û¶WÝÝè:@}ÞÜáºí¶ˆˆ¨²bä®Âo¨² \neý¶íÇ8m»í²ïsÛ¶¤ AÌþ\d›ˆˆ( Yˆ$LÙ÷‰†« ¡ÌþºÛ•‚nH4\Ù·ýýöìÑ""¢ÁÀu²¢ä0«mÓñ÷õ±ìeü•HØòÚçÆ E†a´ÂËÆ;Îg-gg=—5ø´ê2ŒÖYí_«Ö¾Õã€Õ…P-ÛDDDýÀ¡ŽyXnå&¦['¶»Õáµ–HÀºyó¦k30ÙC“tnÞ¼‰Ýï7¯m°$×ZÜùÇÐEDD1cÈŠýþ}n÷ó³û>û#\nCcï%r{ÍÞ+dÝgïò"´¾nXNó¢Ü†ì:†úºÐqœý\ XDD3†¬(Ù‘mÛ)t9.{y§ dkn[{œ†î¬ç3ݼySxî’Û|,·×„ç\ ÌÉr:'<‚ãõ'¾GÍ~5!‚M~·>n¸/Ý r5a·WŠ.­äjC‘¥¸Œ% CVLü‚ŒhÀrÜçÔ‚„©^~ü–RðÛ'®\Ë57Ööûlʼn!+Nö^-Ÿ^®n‚—HY¿c‚ð YÖ}®ÁHp‰¯s±÷ŠˆˆCV?ø !úl}ÞͶ(Ïž¬æNÇm‘¡¿ õ;•!""ꆬ>ëøò;0û¾n™×>ûù<ù¯ dßRp Vm"""ŠCÖqüV„.·cƒ¬ ? ~=F¾Wºìs,Ó|ÁwÑ aÈTNáÊk?ÜC’ß·8¬‰ïAʸ…$¯ðÄ¡@""J†¬$ñXž¯)¿ž¦Ö+nÊçx""¢AÇ5 DÓy¥a„Mñ O夈ˆhHqÅ÷a°aƒðªæÝÞ0ˆ A‹ˆˆh1d­'Âõf£"""" Š!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ÀEDDD†,"""¢0dE€!‹ˆˆˆ( YDDDD`È""""ŠCQ²ˆˆˆˆ"ðÿÅ…w¡I¬ÉIEND®B`‚bitstring-bitstring-3.1.7/doc/quick_ref.rst000066400000000000000000000132251365434337700210230ustar00rootroot00000000000000.. currentmodule:: bitstring .. _quick_reference: ****************** Quick Reference ****************** This section lists the bitstring module's classes together with all their methods and attributes. The next section goes into full detail with examples. Bits ------------- ``Bits(object)`` A ``Bits`` is the most basic class. It is immutable, so once created its value cannot change. It is a base class for all the other classes in the `bitstring` module. Methods ^^^^^^^ * :meth:`~Bits.all` -- Check if all specified bits are set to 1 or 0. * :meth:`~Bits.any` -- Check if any of specified bits are set to 1 or 0. * :meth:`~Bits.count` -- Count the number of bits set to 1 or 0. * :meth:`~Bits.cut` -- Create generator of constant sized chunks. * :meth:`~Bits.endswith` -- Return whether the bitstring ends with a sub-bitstring. * :meth:`~Bits.find` -- Find a sub-bitstring in the current bitstring. * :meth:`~Bits.findall` -- Find all occurrences of a sub-bitstring in the current bitstring. * :meth:`~Bits.join` -- Join bitstrings together using current bitstring. * :meth:`~Bits.rfind` -- Seek backwards to find a sub-bitstring. * :meth:`~Bits.split` -- Create generator of chunks split by a delimiter. * :meth:`~Bits.startswith` -- Return whether the bitstring starts with a sub-bitstring. * :meth:`~Bits.tobytes` -- Return bitstring as bytes, padding if needed. * :meth:`~Bits.tofile` -- Write bitstring to file, padding if needed. * :meth:`~Bits.unpack` -- Interpret bits using format string. Special methods ^^^^^^^^^^^^^^^ Also available are the operators ``[]``, ``==``, ``!=``, ``+``, ``*``, ``~``, ``<<``, ``>>``, ``&``, ``|`` and ``^``. Properties ^^^^^^^^^^ * :attr:`~Bits.bin` -- The bitstring as a binary string. * :attr:`~Bits.bool` -- For single bit bitstrings, interpret as True or False. * :attr:`~Bits.bytes` -- The bitstring as a bytes object. * :attr:`~Bits.float` -- Interpret as a floating point number. * :attr:`~Bits.floatbe` -- Interpret as a big-endian floating point number. * :attr:`~Bits.floatle` -- Interpret as a little-endian floating point number. * :attr:`~Bits.floatne` -- Interpret as a native-endian floating point number. * :attr:`~Bits.hex` -- The bitstring as a hexadecimal string. * :attr:`~Bits.int` -- Interpret as a two's complement signed integer. * :attr:`~Bits.intbe` -- Interpret as a big-endian signed integer. * :attr:`~Bits.intle` -- Interpret as a little-endian signed integer. * :attr:`~Bits.intne` -- Interpret as a native-endian signed integer. * :attr:`~Bits.len` -- Length of the bitstring in bits. * :attr:`~Bits.oct` -- The bitstring as an octal string. * :attr:`~Bits.se` -- Interpret as a signed exponential-Golomb code. * :attr:`~Bits.ue` -- Interpret as an unsigned exponential-Golomb code. * :attr:`~Bits.sie` -- Interpret as a signed interleaved exponential-Golomb code. * :attr:`~Bits.uie` -- Interpret as an unsigned interleaved exponential-Golomb code. * :attr:`~Bits.uint` -- Interpret as a two's complement unsigned integer. * :attr:`~Bits.uintbe` -- Interpret as a big-endian unsigned integer. * :attr:`~Bits.uintle` -- Interpret as a little-endian unsigned integer. * :attr:`~Bits.uintne` -- Interpret as a native-endian unsigned integer. BitArray -------- ``BitArray(Bits)`` This class adds mutating methods to `Bits`. Additional methods ^^^^^^^^^^^^^^^^^^ * :meth:`~BitArray.append` -- Append a bitstring. * :meth:`~BitArray.byteswap` -- Change byte endianness in-place. * :meth:`~BitArray.clear` -- Remove all bits from the bitstring. * :meth:`~BitArray.copy` -- Return a copy of the bitstring. * :meth:`~BitArray.insert` -- Insert a bitstring. * :meth:`~BitArray.invert` -- Flip bit(s) between one and zero. * :meth:`~BitArray.overwrite` -- Overwrite a section with a new bitstring. * :meth:`~BitArray.prepend` -- Prepend a bitstring. * :meth:`~BitArray.replace` -- Replace occurrences of one bitstring with another. * :meth:`~BitArray.reverse` -- Reverse bits in-place. * :meth:`~BitArray.rol` -- Rotate bits to the left. * :meth:`~BitArray.ror` -- Rotate bits to the right. * :meth:`~BitArray.set` -- Set bit(s) to 1 or 0. Additional special methods ^^^^^^^^^^^^^^^^^^^^^^^^^^ Mutating operators are available: ``[]``, ``<<=``, ``>>=``, ``*=``, ``&=``, ``|=`` and ``^=``. Attributes ^^^^^^^^^^ The same as ``Bits``, except that they are all (with the exception of ``len``) writable as well as readable. ConstBitStream -------------- ``ConstBitStream(Bits)`` This class, previously known as just ``Bits`` (which is an alias for backward-compatibility), adds a bit position and methods to read and navigate in the bitstream. Additional methods ^^^^^^^^^^^^^^^^^^ * :meth:`~ConstBitStream.bytealign` -- Align to next byte boundary. * :meth:`~ConstBitStream.peek` -- Peek at and interpret next bits as a single item. * :meth:`~ConstBitStream.peeklist` -- Peek at and interpret next bits as a list of items. * :meth:`~ConstBitStream.read` -- Read and interpret next bits as a single item. * :meth:`~ConstBitStream.readlist` -- Read and interpret next bits as a list of items. * :meth:`~ConstBitStream.readto` -- Read up to and including next occurrence of a bitstring. Additional attributes ^^^^^^^^^^^^^^^^^^^^^ * :attr:`~ConstBitStream.bytepos` -- The current byte position in the bitstring. * :attr:`~ConstBitStream.pos` -- The current bit position in the bitstring. BitStream --------- ``BitStream(BitArray, ConstBitStream)`` This class, also known as ``BitString``, contains all of the 'stream' elements of ``ConstBitStream`` and adds all of the mutating methods of ``BitArray``. bitstring-bitstring-3.1.7/doc/reading.rst000066400000000000000000000265361365434337700204750ustar00rootroot00000000000000.. currentmodule:: bitstring .. _reading: ****************************** Reading, Parsing and Unpacking ****************************** Reading and parsing --------------------- The :class:`BitStream` and :class:`ConstBitStream` classes contain number of methods for reading the bitstring as if it were a file or stream. Depending on how it was constructed the bitstream might actually be contained in a file rather than stored in memory, but these methods work for either case. In order to behave like a file or stream, every bitstream has a property :attr:`~ConstBitStream.pos` which is the current position from which reads occur. :attr:`~ConstBitStream.pos` can range from zero (its value on construction) to the length of the bitstream, a position from which all reads will fail as it is past the last bit. Note that the :attr:`~ConstBitStream.pos` property isn't considered a part of the bitstream's identity; this allows it to vary for immutable :class:`ConstBitStream` objects and means that it doesn't affect equality or hash values. The property :attr:`~ConstBitStream.bytepos` is also available, and is useful if you are only dealing with byte data and don't want to always have to divide the bit position by eight. Note that if you try to use :attr:`~ConstBitStream.bytepos` and the bitstring isn't byte aligned (i.e. :attr:`~ConstBitStream.pos` isn't a multiple of 8) then a :exc:`ByteAlignError` exception will be raised. ``read / readlist`` ^^^^^^^^^^^^^^^^^^^ For simple reading of a number of bits you can use :meth:`~ConstBitStream.read` with an integer argument. A new bitstring object gets returned, which can be interpreted using one of its properties or used for further reads. The following example does some simple parsing of an MPEG-1 video stream (the stream is provided in the ``test`` directory if you downloaded the source archive). :: >>> s = ConstBitStream(filename='test/test.m1v') >>> print(s.pos) 0 >>> start_code = s.read(32).hex >>> width = s.read(12).uint >>> height = s.read(12).uint >>> print(start_code, width, height, s.pos) 000001b3 352 288 56 >>> s.pos += 37 >>> flags = s.read(2) >>> constrained_parameters_flag = flags.read(1) >>> load_intra_quantiser_matrix = flags.read(1) >>> print(s.pos, flags.pos) 95 2 If you want to read multiple items in one go you can use :meth:`~ConstBitStream.readlist`. This can take an iterable of bit lengths and return a list of bitstring objects. So for example instead of writing:: a = s.read(32) b = s.read(8) c = s.read(24) you can equivalently use just:: a, b, c = s.readlist([32, 8, 24]) Reading using format strings ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The :meth:`~ConstBitStream.read` / :meth:`~ConstBitStream.readlist` methods can also take a format string similar to that used in the auto initialiser. Only one token should be provided to :meth:`~ConstBitStream.read` and a single value is returned. To read multiple tokens use :meth:`~ConstBitStream.readlist`, which unsurprisingly returns a list. The format string consists of comma separated tokens that describe how to interpret the next bits in the bitstring. The tokens are: ============== =================================================================== ``int:n`` ``n`` bits as a signed integer. ``uint:n`` ``n`` bits as an unsigned integer. ``intbe:n`` ``n`` bits as a byte-wise big-endian signed integer. ``uintbe:n`` ``n`` bits as a byte-wise big-endian unsigned integer. ``intle:n`` ``n`` bits as a byte-wise little-endian signed integer. ``uintle:n`` ``n`` bits as a byte-wise little-endian unsigned integer. ``intne:n`` ``n`` bits as a byte-wise native-endian signed integer. ``uintne:n`` ``n`` bits as a byte-wise native-endian unsigned integer. ``float:n`` ``n`` bits as a big-endian floating point number (same as ``floatbe``). ``floatbe:n`` ``n`` bits as a big-endian floating point number (same as ``float``). ``floatle:n`` ``n`` bits as a little-endian floating point number. ``floatne:n`` ``n`` bits as a native-endian floating point number. ``hex:n`` ``n`` bits as a hexadecimal string. ``oct:n`` ``n`` bits as an octal string. ``bin:n`` ``n`` bits as a binary string. ``bits:n`` ``n`` bits as a new bitstring. ``bytes:n`` ``n`` bytes as a ``bytes`` object. ``ue`` next bits as an unsigned exponential-Golomb code. ``se`` next bits as a signed exponential-Golomb code. ``uie`` next bits as an interleaved unsigned exponential-Golomb code. ``sie`` next bits as an interleaved signed exponential-Golomb code. ``bool[:1]`` next bit as a boolean (True or False). ``pad:n`` next ``n`` bits will be ignored (padding). ============== =================================================================== So in the earlier example we could have written:: start_code = s.read('hex:32') width = s.read('uint:12') height = s.read('uint:12') and we also could have combined the three reads as:: start_code, width, height = s.readlist('hex:32, 12, 12') where here we are also taking advantage of the default :attr:`~Bits.uint` interpretation for the second and third tokens. You are allowed to use one 'stretchy' token in a :meth:`~ConstBitStream.readlist`. This is a token without a length specified which will stretch to fill encompass as many bits as possible. This is often useful when you just want to assign something to 'the rest' of the bitstring:: a, b, everything_else = s.readlist('intle:16, intle:24, bits') In this example the ``bits`` token will consist of everything left after the first two tokens are read, and could be empty. It is an error to use more than one stretchy token, or to use a ``ue``, ``se``, ``uie`` or ``se`` token after a stretchy token (the reason you can't use exponential-Golomb codes after a stretchy token is that the codes can only be read forwards; that is you can't ask "if this code ends here, where did it begin?" as there could be many possible answers). The ``pad`` token is a special case in that it just causes bits to be skipped over without anything being returned. This can be useful for example if parts of a binary format are uninteresting:: a, b = s.readlist('pad:12, uint:4, pad:4, uint:8') Peeking ^^^^^^^^ In addition to the read methods there are matching peek methods. These are identical to the read except that they do not advance the position in the bitstring to after the read elements. :: s = ConstBitStream('0x4732aa34') if s.peek(8) == '0x47': t = s.read(16) # t is first 2 bytes '0x4732' else: s.find('0x47') Unpacking --------- The :meth:`~Bits.unpack` method works in a very similar way to :meth:`~ConstBitStream.readlist`. The major difference is that it interprets the whole bitstring from the start, and takes no account of the current :attr:`~ConstBitStream.pos`. It's a natural complement of the :func:`pack` function. :: s = pack('uint:10, hex, int:13, 0b11', 130, '3d', -23) a, b, c, d = s.unpack('uint:10, hex, int:13, bin:2') Seeking ------- The properties :attr:`~ConstBitStream.pos` and :attr:`~ConstBitStream.bytepos` are available for getting and setting the position, which is zero on creation of the bitstring. Note that you can only use :attr:`~ConstBitStream.bytepos` if the position is byte aligned, i.e. the bit position is a multiple of 8. Otherwise a :exc:`ByteAlignError` exception is raised. For example:: >>> s = BitStream('0x123456') >>> s.pos 0 >>> s.bytepos += 2 >>> s.pos # note pos verses bytepos 16 >>> s.pos += 4 >>> print(s.read('bin:4')) # the final nibble '0x6' 0110 Finding and replacing --------------------- ``find / rfind`` ^^^^^^^^^^^^^^^^ To search for a sub-string use the :meth:`~Bits.find` method. If the find succeeds it will set the position to the start of the next occurrence of the searched for string and return a tuple containing that position, otherwise it will return an empty tuple. By default the sub-string will be found at any bit position - to allow it to only be found on byte boundaries set ``bytealigned=True``. >>> s = ConstBitStream('0x00123400001234') >>> found = s.find('0x1234', bytealigned=True) >>> print(found, s.bytepos) (8,) 1 >>> found = s.find('0xff', bytealigned=True) >>> print(found, s.bytepos) () 1 The reason for returning the bit position in a tuple is so that the return value is ``True`` in a boolean sense if the sub-string is found, and ``False`` if it is not (if just the bit position were returned there would be a problem with finding at position 0). The effect is that you can use ``if s.find(...):`` and have it behave as you'd expect. :meth:`~Bits.rfind` does much the same as :meth:`~Bits.find`, except that it will find the last occurrence, rather than the first. :: >>> t = BitArray('0x0f231443e8') >>> found = t.rfind('0xf') # Search all bit positions in reverse >>> print(found) (31,) # Found within the 0x3e near the end For all of these finding functions you can optionally specify a ``start`` and / or ``end`` to narrow the search range. Note though that because it's searching backwards :meth:`~Bits.rfind` will start at ``end`` and end at ``start`` (so you always need ``start`` < ``end``). ``findall`` ^^^^^^^^^^^ To find all occurrences of a bitstring inside another (even overlapping ones), use :meth:`~Bits.findall`. This returns a generator for the bit positions of the found strings. :: >>> r = BitArray('0b011101011001') >>> ones = r.findall([1]) >>> print(list(ones)) [1, 2, 3, 5, 7, 8, 11] ``replace`` ^^^^^^^^^^^ To replace all occurrences of one :class:`BitArray` with another use :meth:`~BitArray.replace`. The replacements are done in-place, and the number of replacements made is returned. This methods changes the contents of the bitstring and so isn't available for the :class:`Bits` or :class:`ConstBitStream` classes. :: >>> s = BitArray('0b110000110110') >>> s.replace('0b110', '0b1111') 3 # The number of replacements made >>> s.bin '111100011111111' Working with byte aligned data ------------------------------ The emphasis with the bitstring module is always towards not worrying if things are a whole number of bytes long or are aligned on byte boundaries. Internally the module has to worry about this quite a lot, but the user shouldn't have to care. To this end methods such as :meth:`~Bits.find`, :meth:`~Bits.findall`, :meth:`~Bits.split` and :meth:`~BitArray.replace` by default aren't concerned with looking for things only on byte boundaries and provide a parameter ``bytealigned`` which can be set to ``True`` to change this behaviour. This works fine, but it's not uncommon to be working only with whole-byte data and all the ``bytealigned=True`` can get a bit repetitive. To solve this it is possible to change the default throughout the module by setting ``bitstring.bytealigned``. For example:: >>> s = BitArray('0xabbb') >>> s.find('0xbb') # look for the byte 0xbb (4,) # found, but not on byte boundary >>> s.find('0xbb', bytealigned=True) # try again... (8,) # not found on any byte boundaries >>> bitstring.bytealigned = True # change the default behaviour >>> s.find('0xbb') (8,) # now only finds byte aligned bitstring-bitstring-3.1.7/doc/reference.rst000066400000000000000000000002741365434337700210110ustar00rootroot00000000000000 .. _reference: ********* Reference ********* .. toctree:: :maxdepth: 3 quick_ref bitstring_classes constbitarray bitarray constbitstream bitstream functions bitstring-bitstring-3.1.7/doc/release_notes.rst000066400000000000000000001560311365434337700217060ustar00rootroot00000000000000 .. currentmodule:: bitstring ************* Release Notes ************* Full Version History ==================== May 5th 2020: version 3.1.7 released ------------------------------------- This is a maintenance release with a few bug fixes plus an experimental feature to allow bits to be indexed in the opposite direction. * Fixing del not working correctly when stop value negative (Issue 201) * Removed deprecated direct import of ABC from collections module (Issue 196) * Tested and added explicit support for Python 3.7 and 3.8. (Issue 193) * Fixing a few stale links to documentation. (Issue 194) * Allowing initialisation with an io.BytesIO object. (Issue 189) Experimental LSB0 mode ---------------------- This feature allows bitstring to use Least Significant Bit Zero (LSB0) bit numbering; that is the final bit in the bitstring will be bit 0, and the first bit will be bit (n-1), rather than the other way around. LSB0 is a more natural numbering system in many fields, but is the opposite to Most Significant Bit Zero (MSB0) numbering which is the natural option when thinking of bitstrings as standard Python containers. To switch from the default MSB0, use the module level function >>> bitstring.set_lsb0(True) Getting and setting bits should work in this release, as will some other methods. Many other methods are not tested yet and might not work as expected. This is mostly a release to get feedback before finalising the interface. Slicing is still done with the start bit smaller than the end bit. For example: >>> s = Bits('0b000000111') >>> s[0:5] Bits('0b00111') >>> s[0] True Negative indices work as (hopefully) you'd expect, with the first stored bit being `s[-1]` and the final stored bit being `s[-n]`. See https://github.com/scott-griffiths/bitstring/issues/156 for discussions and to add any further comments. July 9th 2019: version 3.1.6 released ------------------------------------- A long overdue maintenace release with some fixes. * Fixed immutability bug. Bug 176. * Fixed failure of `__contains__` in some circumstances. Bug 180. * Better handling of open files. Bug 186. * Better Python 2/3 check. * Making unit tests easier to run. * Allowing length of 1 to be specified for bools. (Thanks to LemonPi) * Documentation fixes. * Added experimental (and undocumented) command-line mode. May 17th 2016: version 3.1.5 released ------------------------------------- * Support initialisation from an array. * Added a separate LICENSE file. March 19th 2016: version 3.1.4 released --------------------------------------- This is another bug fix release. * Fix for bitstring types when created directly from other bitstring types. * Updating contact, website details. March 4th 2014: version 3.1.3 released -------------------------------------- This is another bug fix release. * Fix for problem with prepend for bitstrings with byte offsets in their data store. April 18th 2013: version 3.1.2 released --------------------------------------- This is another bug fix release. * Fix for problem where unpacking bytes would by eight times too long March 21st 2013: version 3.1.1 released --------------------------------------- This is a bug fix release. * Fix for problem where concatenating bitstrings sometimes modified method's arguments February 26th 2013: version 3.1.0 released ------------------------------------------ This is a minor release with a couple of new features and some bug fixes. New 'pad' token ^^^^^^^^^^^^^^^ This token can be used in reads and when packing/unpacking to indicate that you don't care about the contents of these bits. Any padding bits will just be skipped over when reading/unpacking or zero-filled when packing. :: >>> a, b = s.readlist('pad:5, uint:3, pad:1, uint:3') Here only two items are returned in the list - the padding bits are ignored. New clear and copy convenience methods ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ These methods have been introduced in Python 3.3 for lists and bytearrays, as more obvious ways of clearing and copying, and we mirror that change here. ``t = s.copy()`` is equivalent to ``t = s[:]``, and ``s.clear()`` is equivalent to ``del s[:]``. Other changes ^^^^^^^^^^^^^ * Some bug fixes. November 21st 2011: version 3.0.0 released ------------------------------------------ This is a major release which breaks backward compatibility in a few places. Backwardly incompatible changes ------------------------------- Hex, oct and bin properties don't have leading 0x, 0o and 0b ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you ask for the hex, octal or binary representations of a bitstring then they will no longer be prefixed with ``0x``, ``0o`` or ``0b``. This was done as it was noticed that the first thing a lot of user code does after getting these representations was to cut off the first two characters before further processing. :: >>> a = BitArray('0x123') >>> a.hex, a.oct, a.bin ('123', '0443', '000100100011') Previously this would have returned ``('0x123', '0o0443', '0b000100100011')`` This change might require some recoding, but it should all be simplifications. ConstBitArray renamed to Bits ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously Bits was an alias for ConstBitStream (for backward compatibility). This has now changed so that Bits and BitArray loosely correspond to the built-in types bytes and bytearray. If you were using streaming/reading methods on a Bits object then you will have to change it to a ConstBitStream. The ConstBitArray name is kept as an alias for Bits. Stepping in slices has conventional meaning ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The step parameter in ``__getitem__``, ``__setitem__`` and ``__delitem__`` used to act as a multiplier for the start and stop parameters. No one seemed to use it though and so it has now reverted to the conventional meaning for containers. If you are using step then recoding is simple: ``s[a:b:c]`` becomes ``s[a*c:b*c]``. Some examples of the new usage:: >>> s = BitArray('0x0000') s[::4] = [1, 1, 1, 1] >>> s.hex '8888' >>> del s[8::2] >>> s.hex '880' New features ------------ New readto method ^^^^^^^^^^^^^^^^^ This method is a mix between a find and a read - it searches for a bitstring and then reads up to and including it. For example:: >>> s = ConstBitStream('0x47000102034704050647') >>> s.readto('0x47', bytealigned=True) BitStream('0x47') >>> s.readto('0x47', bytealigned=True) BitStream('0x0001020347') >>> s.readto('0x47', bytealigned=True) BitStream('0x04050647') pack function accepts an iterable as its format ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously only a string was accepted as the format in the pack function. This was an oversight as it broke the symmetry between pack and unpack. Now you can use formats like this:: fmt = ['hex:8', 'bin:3'] a = pack(fmt, '47', '001') a.unpack(fmt) June 18th 2011: version 2.2.0 released -------------------------------------- This is a minor upgrade with a couple of new features. New interleaved exponential-Golomb interpretations ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ New bit interpretations for interleaved exponential-Golomb (as used in the Dirac video codec) are supplied via ``uie`` and ``sie``:: >>> s = BitArray(uie=41) >>> s.uie 41 >>> s.bin '0b00010001001' These are pretty similar to the non-interleaved versions - see the manual for more details. Credit goes to Paul Sargent for the patch. New package-level bytealigned variable ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ A number of methods take a ``bytealigned`` parameter to indicate that they should only work on byte boundaries (e.g. ``find``, ``replace``, ``split``). Previously this parameter defaulted to ``False``. Instead it now defaults to ``bitstring.bytealigned``, which itself defaults to ``False``, but can be changed to modify the default behaviour of the methods. For example:: >>> a = BitArray('0x00 ff 0f ff') >>> a.find('0x0f') (4,) # found first not on a byte boundary >>> a.find('0x0f', bytealigned=True) (16,) # forced looking only on byte boundaries >>> bitstring.bytealigned = True # Change default behaviour >>> a.find('0x0f') (16,) >>> a.find('0x0f', bytealigned=False) (4,) If you're only working with bytes then this can help avoid some errors and save some typing! Other changes ^^^^^^^^^^^^^ * Fix for Python 3.2, correcting for a change to the binascii module. * Fix for bool initialisation from ``0`` or ``1``. * Efficiency improvements, including interning strategy. February 23rd 2011: version 2.1.1 released ------------------------------------------ This is a release to fix a couple of bugs that were introduced in 2.1.0. * Bug fix: Reading using the 'bytes' token had been broken (Issue 102). * Fixed problem using some methods on ``ConstBitArray`` objects. * Better exception handling for tokens missing values. * Some performance improvements. January 23rd 2011: version 2.1.0 released ----------------------------------------- New class hierarchy introduced with simpler classes --------------------------------------------------- Previously there were just two classes, the immutable ``Bits`` which was the base class for the mutable ``BitString`` class. Both of these classes have the concept of a bit position, from which reads etc. take place so that the bitstring could be treated as if it were a file or stream. Two simpler classes have now been added which are purely bit containers and don't have a bit position. These are called ``ConstBitArray`` and ``BitArray``. As you can guess the former is an immutable version of the latter. The other classes have also been renamed to better reflect their capabilities. Instead of ``BitString`` you should use ``BitStream``, and instead of ``Bits`` you can use ``ConstBitStream``. The old names are kept as aliases for backward compatibility. The classes hierarchy is:: ConstBitArray / \ / \ BitArray ConstBitStream (formerly Bits) \ / \ / BitStream (formerly BitString) Other changes ^^^^^^^^^^^^^ A lot of internal reorganisation has taken place since the previous version, most of which won't be noticed by the end user. Some things you might see are: * New package structure. Previous versions have been a single file for the module and another for the unit tests. The module is now split into many more files so it can't be used just by copying bitstring.py any more. * To run the unit tests there is now a script called ``runtests.py`` in the ``test`` directory. * File based bitstring are now implemented in terms of an mmap. This should be just an implementation detail, but unfortunately for 32-bit versions of Python this creates a limit of 4GB on the files that can be used. The work around is either to get a 64-bit Python, or just stick with version 2.0. * The ``ConstBitArray`` and ``ConstBitStream`` classes no longer copy byte data when a slice or a read takes place, they just take a reference. This is mostly a very nice optimisation, but there are occasions where it could have an adverse effect. For example if a very large bitstring is created, a small slice taken and the original deleted. The byte data from the large bitstring would still be retained in memory. * Optimisations. Once again this version should be faster than the last. The module is still pure Python but some of the reorganisation was to make it more feasible to put some of the code into Cython or similar, so hopefully more speed will be on the way. July 26th 2010: version 2.0.3 released -------------------------------------- 1. **Bug fix**: Using peek and read for a single bit now returns a new bitstring as was intended, rather than the old behaviour of returning a bool. 2. Removed HTML docs from source archive - better to use the online version. July 25th 2010: version 2.0.2 released -------------------------------------- This is a major release, with a number of backwardly incompatible changes. The main change is the removal of many methods, all of which have simple alternatives. Other changes are quite minor but may need some recoding. There are a few new features, most of which have been made to help the stream-lining of the API. As always there are performance improvements and some API changes were made purely with future performance in mind. The backwardly incompatible changes are: ---------------------------------------- Methods removed ^^^^^^^^^^^^^^^ About half of the class methods have been removed from the API. They all have simple alternatives, so what remains is more powerful and easier to remember. The removed methods are listed here on the left, with their equivalent replacements on the right:: s.advancebit() -> s.pos += 1 s.advancebits(bits) -> s.pos += bits s.advancebyte() -> s.pos += 8 s.advancebytes(bytes) -> s.pos += 8*bytes s.allunset([a, b]) -> s.all(False, [a, b]) s.anyunset([a, b]) -> s.any(False, [a, b]) s.delete(bits, pos) -> del s[pos:pos+bits] s.peekbit() -> s.peek(1) s.peekbitlist(a, b) -> s.peeklist([a, b]) s.peekbits(bits) -> s.peek(bits) s.peekbyte() -> s.peek(8) s.peekbytelist(a, b) -> s.peeklist([8*a, 8*b]) s.peekbytes(bytes) -> s.peek(8*bytes) s.readbit() -> s.read(1) s.readbitlist(a, b) -> s.readlist([a, b]) s.readbits(bits) -> s.read(bits) s.readbyte() -> s.read(8) s.readbytelist(a, b) -> s.readlist([8*a, 8*b]) s.readbytes(bytes) -> s.read(8*bytes) s.retreatbit() -> s.pos -= 1 s.retreatbits(bits) -> s.pos -= bits s.retreatbyte() -> s.pos -= 8 s.retreatbytes(bytes) -> s.pos -= 8*bytes s.reversebytes(start, end) -> s.byteswap(0, start, end) s.seek(pos) -> s.pos = pos s.seekbyte(bytepos) -> s.bytepos = bytepos s.slice(start, end, step) -> s[start:end:step] s.tell() -> s.pos s.tellbyte() -> s.bytepos s.truncateend(bits) -> del s[-bits:] s.truncatestart(bits) -> del s[:bits] s.unset([a, b]) -> s.set(False, [a, b]) Many of these methods have been deprecated for the last few releases, but there are some new removals too. Any recoding needed should be quite straightforward, so while I apologise for the hassle, I had to take the opportunity to streamline and rationalise what was becoming a bit of an overblown API. set / unset methods combined ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``set``/``unset`` methods have been combined in a single method, which now takes a boolean as its first argument:: s.set([a, b]) -> s.set(1, [a, b]) s.unset([a, b]) -> s.set(0, [a, b]) s.allset([a, b]) -> s.all(1, [a, b]) s.allunset([a, b]) -> s.all(0, [a, b]) s.anyset([a, b]) -> s.any(1, [a, b]) s.anyunset([a, b]) -> s.any(0, [a, b]) all / any only accept iterables ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``all`` and ``any`` methods (previously called ``allset``, ``allunset``, ``anyset`` and ``anyunset``) no longer accept a single bit position. The recommended way of testing a single bit is just to index it, for example instead of:: >>> if s.all(True, i): just use :: >>> if s[i]: If you really want to you can of course use an iterable with a single element, such as ``s.any(False, [i])``, but it's clearer just to write ``not s[i]``. Exception raised on reading off end of bitstring ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If a read or peek goes beyond the end of the bitstring then a ``ReadError`` will be raised. The previous behaviour was that the rest of the bitstring would be returned and no exception raised. ``BitStringError`` renamed to ``Error`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The base class for errors in the bitstring module is now just ``Error``, so it will likely appears in your code as ``bitstring.Error`` instead of the rather repetitive ``bitstring.BitStringError``. Single bit slices and reads return a bool ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ A single index slice (such as ``s[5]``) will now return a bool (i.e. ``True`` or ``False``) rather than a single bit bitstring. This is partly to reflect the style of the ``bytearray`` type, which returns an integer for single items, but mostly to avoid common errors like:: >>> if s[0]: ... do_something() While the intent of this code snippet is quite clear (i.e. do_something if the first bit of s is set) under the old rules ``s[0]`` would be true as long as ``s`` wasn't empty. That's because any one-bit bitstring was true as it was a non-empty container. Under the new rule ``s[0]`` is ``True`` if ``s`` starts with a ``1`` bit and ``False`` if ``s`` starts with a ``0`` bit. The change does not affect reads and peeks, so ``s.peek(1)`` will still return a single bit bitstring, which leads on to the next item... Empty bitstrings or bitstrings with only zero bits are considered False ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously a bitstring was False if it had no elements, otherwise it was True. This is standard behaviour for containers, but wasn't very useful for a container of just 0s and 1s. The new behaviour means that the bitstring is False if it has no 1 bits. This means that code like this:: >>> if s.peek(1): ... do_something() should work as you'd expect. It also means that ``Bits(1000)``, ``Bits(0x00)`` and ``Bits('uint:12=0')`` are all also ``False``. If you need to check for the emptiness of a bitstring then instead check the ``len`` property:: if s -> if s.len if not s -> if not s.len Length and offset disallowed for some initialisers ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously you could create bitstring using expressions like:: >>> s = Bits(hex='0xabcde', offset=4, length=13) This has now been disallowed, and the offset and length parameters may only be used when initialising with bytes or a file. To replace the old behaviour you could instead use :: >>> s = Bits(hex='0xabcde')[4:17] Renamed ``format`` parameter ``fmt`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Methods with a ``format`` parameter have had it renamed to ``fmt``, to prevent hiding the built-in ``format``. Affects methods ``unpack``, ``read``, ``peek``, ``readlist``, ``peeklist`` and ``byteswap`` and the ``pack`` function. Iterables instead of ``*`` format accepted for some methods ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This means that for the affected methods (``unpack``, ``readlist`` and ``peeklist``) you will need to use an iterable to specify multiple items. This is easier to show than to describe, so instead of :: >>> a, b, c, d = s.readlist('uint:12', 'hex:4', 'bin:7') you would instead write :: >>> a, b, c, d = s.readlist(['uint:12', 'hex:4', 'bin:7']) Note that you could still use the single string ``'uint:12, hex:4, bin:7'`` if you preferred. Bool auto-initialisation removed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ You can no longer use ``True`` and ``False`` to initialise single bit bitstrings. The reasoning behind this is that as bool is a subclass of int, it really is bad practice to have ``Bits(False)`` be different to ``Bits(0)`` and to have ``Bits(True)`` different to ``Bits(1)``. If you have used bool auto-initialisation then you will have to be careful to replace it as the bools will now be interpreted as ints, so ``Bits(False)`` will be empty (a bitstring of length 0), and ``Bits(True)`` will be a single zero bit (a bitstring of length 1). Sorry for the confusion, but I think this will prevent bigger problems in the future. There are a few alternatives for creating a single bit bitstring. My favourite is to use a list with a single item:: Bits(False) -> Bits([0]) Bits(True) -> Bits([1]) New creation from file strategy ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously if you created a bitstring from a file, either by auto-initialising with a file object or using the filename parameter, the file would not be read into memory unless you tried to modify it, at which point the whole file would be read. The new behaviour depends on whether you create a Bits or a BitString from the file. If you create a Bits (which is immutable) then the file will never be read into memory. This allows very large files to be opened for examination even if they could never fit in memory. If however you create a BitString, the whole of the referenced file will be read to store in memory. If the file is very big this could take a long time, or fail, but the idea is that in saying you want the mutable BitString you are implicitly saying that you want to make changes and so (for now) we need to load it into memory. The new strategy is a bit more predictable in terms of performance than the old. The main point to remember is that if you want to open a file and don't plan to alter the bitstring then use the Bits class rather than BitString. Just to be clear, in neither case will the contents of the file ever be changed - if you want to output the modified BitString then use the ``tofile`` method, for example. find and rfind return a tuple instead of a bool ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If a find is unsuccessful then an empty tuple is returned (which is False in a boolean sense) otherwise a single item tuple with the bit position is returned (which is True in a boolean sense). You shouldn't need to recode unless you explicitly compared the result of a find to True or False, for example this snippet doesn't need to be altered:: >>> if s.find('0x23'): ... print(s.bitpos) but you could now instead use :: >>> found = s.find('0x23') >>> if found: ... print(found[0]) The reason for returning the bit position in a tuple is so that finding at position zero can still be True - it's the tuple ``(0,)`` - whereas not found can be False - the empty tuple ``()``. The new features in this release are: ------------------------------------- New count method ^^^^^^^^^^^^^^^^ This method just counts the number of 1 or 0 bits in the bitstring. :: >>> s = Bits('0x31fff4') >>> s.count(1) 16 ``read`` and ``peek`` methods accept integers ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``read``, ``readlist``, ``peek`` and ``peeklist`` methods now accept integers as parameters to mean "read this many bits and return a bitstring". This has allowed a number of methods to be removed from this release, so for example instead of:: >>> a, b, c = s.readbits(5, 6, 7) >>> if s.peekbit(): ... do_something() you should write:: >>> a, b, c = s.readlist([5, 6, 7]) >>> if s.peek(1): ... do_something() ``byteswap`` used to reverse all bytes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``byteswap`` method now allows a format specifier of 0 (the default) to signify that all of the whole bytes should be reversed. This means that calling just ``byteswap()`` is almost equivalent to the now removed ``bytereverse()`` method (a small difference is that byteswap won't raise an exception if the bitstring isn't a whole number of bytes long). Auto initialise with bytearray or (for Python 3 only) bytes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ So rather than writing:: >>> a = Bits(bytes=some_bytearray) you can just write :: >>> a = Bits(some_bytearray) This also works for the bytes type, but only if you're using Python 3. For Python 2.7 it's not possible to distinguish between a bytes object and a str. For this reason this method should be used with some caution as it will make you code behave differently with the different major Python versions. :: >>> b = Bits(b'abcd\x23\x00') # Only Python 3! ``set``, ``invert``, ``all`` and ``any`` default to whole bitstring ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This means that you can for example write:: >>> a = BitString(100) # 100 zero bits >>> a.set(1) # set all bits to 1 >>> a.all(1) # are all bits set to 1? True >>> a.any(0) # are any set to 0? False >>> a.invert() # invert every bit New exception types ^^^^^^^^^^^^^^^^^^^ As well as renaming ``BitStringError`` to just ``Error`` there are also new exceptions which use ``Error`` as a base class. These can be caught in preference to ``Error`` if you need finer control. The new exceptions sometimes also derive from built-in exceptions: 3. ``ByteAlignError(Error)`` - whole byte position or length needed. 4. ``ReadError(Error, IndexError)`` - reading or peeking off the end of the bitstring. 5. ``CreationError(Error, ValueError)`` - inappropriate argument during bitstring creation. 6. ``InterpretError(Error, ValueError)`` - inappropriate interpretation of binary data. March 18th 2010: version 1.3.0 for Python 2.6 and 3.x released -------------------------------------------------------------- New features ------------ byteswap method for changing endianness ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Changes the endianness in-place according to a format string or integer(s) giving the byte pattern. See the manual for details. :: >>> s = BitString('0x00112233445566') >>> s.byteswap(2) 3 >>> s BitString('0x11003322554466') >>> s.byteswap('h') 3 >>> s BitString('0x00112233445566') >>> s.byteswap([2, 5]) 1 >>> s BitString('0x11006655443322') Multiplicative factors in bitstring creation and reading ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ For example:: >>> s = Bits('100*0x123') Token grouping using parenthesis ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ For example:: >>> s = Bits('3*(uint:6=3, 0b1)') Negative slice indices allowed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The start and end parameters of many methods may now be negative, with the same meaning as for negative slice indices. Affects all methods with these parameters. Sequence ABCs used ^^^^^^^^^^^^^^^^^^ The Bits class now derives from ``collections.Sequence``, while the BitString class derives from ``collections.MutableSequence``. Keywords allowed in ``readlist``, ``peeklist`` and ``unpack`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Keywords for token lengths are now permitted when reading. So for example, you can write :: >>> s = bitstring.pack('4*(uint:n)', 2, 3, 4, 5, n=7) >>> s.unpack('4*(uint:n)', n=7) [2, 3, 4, 5] start and end parameters added to ``rol`` and ``ror`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ join function accepts other iterables ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Also its parameter has changed from 'bitstringlist' to 'sequence'. This is technically a backward incompatibility in the unlikely event that you are referring to the parameter by name. ``__init__`` method accepts keywords ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Rather than a long list of initialisers the ``__init__`` methods now use a ``**kwargs`` dictionary for all initialisers except 'auto'. This should have no effect, except that this is a small backward incompatibility if you use positional arguments when initialising with anything other than auto (which would be rather unusual). More optimisations ^^^^^^^^^^^^^^^^^^ A number of methods have been speeded up. Bug fixed in replace method ^^^^^^^^^^^^^^^^^^^^^^^^^^^ (it could fail if start != 0). January 19th 2010: version 1.2.0 for Python 2.6 and 3.x released ---------------------------------------------------------------- New 'Bits' class ---------------- Introducing a brand new class, Bits, representing an immutable sequence of bits. The Bits class is the base class for the mutable BitString. The differences between Bits and BitStrings are: * Bits are immutable, so once they have been created their value cannot change. This of course means that mutating methods (append, replace, del etc.) are not available for Bits. * Bits are hashable, so they can be used in sets and as keys in dictionaries. * Bits are potentially more efficient than BitStrings, both in terms of computation and memory. The current implementation is only marginally more efficient though - this should improve in future versions. You can switch from Bits to a BitString or vice versa by constructing a new object from the old. :: >>> s = Bits('0xabcd') >>> t = BitString(s) >>> t.append('0xe') >>> u = Bits(t) The relationship between Bits and BitString is supposed to loosely mirror that between bytes and bytearray in Python 3. Deprecation messages turned on ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ A number of methods have been flagged for removal in version 2. Deprecation warnings will now be given, which include an alternative way to do the same thing. All of the deprecated methods have simpler equivalent alternatives. :: >>> t = s.slice(0, 2) __main__:1: DeprecationWarning: Call to deprecated function slice. Instead of 's.slice(a, b, c)' use 's[a:b:c]'. The deprecated methods are: ``advancebit``, ``advancebits``, ``advancebyte``, ``advancebytes``, ``retreatbit``, ``retreatbits``, ``retreatbyte``, ``retreatbytes``, ``tell``, ``seek``, ``slice``, ``delete``, ``tellbyte``, ``seekbyte``, ``truncatestart`` and ``truncateend``. Initialise from bool ^^^^^^^^^^^^^^^^^^^^ Booleans have been added to the list of types that can 'auto' initialise a bitstring. :: >>> zerobit = BitString(False) >>> onebit = BitString(True) Improved efficiency ^^^^^^^^^^^^^^^^^^^ More methods have been speeded up, in particular some deletions and insertions. Bug fixes ^^^^^^^^^ A rare problem with truncating the start of bitstrings was fixed. A possible problem outputting the final byte in ``tofile()`` was fixed. December 22nd 2009: version 1.1.3 for Python 2.6 and 3.x released ----------------------------------------------------------------- This version hopefully fixes an installation problem for platforms with case-sensitive file systems. There are no new features or other bug fixes. December 18th 2009: version 1.1.2 for Python 2.6 and 3.x released ----------------------------------------------------------------- This is a minor update with (almost) no new features. Improved efficiency ^^^^^^^^^^^^^^^^^^^ The speed of many typical operations has been increased, some substantially. Initialise from integer A BitString of '0' bits can be created using just an integer to give the length in bits. So instead of :: >>> s = BitString(length=100) you can write just :: >>> s = BitString(100) This matches the behaviour of bytearrays and (in Python 3) bytes. * A defect related to using the set / unset functions on !BitStrings initialised from a file has been fixed. November 24th 2009: version 1.1.0 for Python 2.6 and 3.x released ----------------------------------------------------------------- Note that this version will not work for Python 2.4 or 2.5. There may be an update for these Python versions some time next year, but it's not a priority quite yet. Also note that only one version is now provided, which works for Python 2.6 and 3.x (done with the minimum of hackery!) New features ------------ Improved efficiency ^^^^^^^^^^^^^^^^^^^ A fair number of functions have improved efficiency, some quite dramatically. New bit setting and checking functions ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Although these functions don't do anything that couldn't be done before, they do make some common use cases much more efficient. If you need to set or check single bits then these are the functions you need. * ``set`` / ``unset`` : Set bit(s) to 1 or 0 respectively. * ``allset`` / ``allunset`` : Check if all bits are 1 or all 0. * ``anyset`` / ``anyunset`` : Check if any bits are 1 or any 0. >>> s = BitString(length=1000) >>> s.set((10, 100, 44, 12, 1)) >>> s.allunset((2, 22, 222)) True >>> s.anyset(range(7, 77)) True New rotate functions ^^^^^^^^^^^^^^^^^^^^ ``ror`` / ``rol`` : Rotate bits to the right or left respectively. :: >>> s = BitString('0b100000000') >>> s.ror(2) >>> s.bin '0b001000000' >>> s.rol(5) >>> s.bin '0b000000100' Floating point interpretations ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ New float initialisations and interpretations are available. These only work for BitStrings of length 32 or 64 bits. :: >>> s = BitString(float=0.2, length=64) >>> s.float 0.200000000000000001 >>> t = bitstring.pack('<3f', -0.4, 1e34, 17.0) >>> t.hex '0xcdccccbedf84f67700008841' 'bytes' token reintroduced ^^^^^^^^^^^^^^^^^^^^^^^^^^ This token returns a bytes object (equivalent to a str in Python 2.7). :: >>> s = BitString('0x010203') >>> s.unpack('bytes:2, bytes:1') ['\x01\x02', '\x03'] 'uint' is now the default token type ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ So for example these are equivalent:: a, b = s.readlist('uint:12, uint:12') a, b = s.readlist('12, 12') October 10th 2009: version 1.0.1 for Python 3.x released -------------------------------------------------------- This is a straight port of version 1.0.0 to Python 3. For changes since the last Python 3 release read all the way down in this document to version 0.4.3. This version will also work for Python 2.6, but there's no advantage to using it over the 1.0.0 release. It won't work for anything before 2.6. October 9th 2009: version 1.0.0 for Python 2.x released ------------------------------------------------------- Version 1 is here! This is the first release not to carry the 'beta' tag. It contains a couple of minor new features but is principally a release to fix the API. If you've been using an older version then you almost certainly will have to recode a bit. If you're not ready to do that then you may wish to delay updating. So the bad news is that there are lots of small changes to the API. The good news is that all the changes are pretty trivial, the new API is cleaner and more 'Pythonic', and that by making it version 1.0 I'm promising not to tweak it again for some time. API Changes ----------- New read / peek functions for returning multiple items ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The functions read, readbits, readbytes, peek, peekbits and peekbytes now only ever return a single item, never a list. The new functions readlist, readbitlist, readbytelist, peeklist, peekbitlist and peekbytelist can be used to read multiple items and will always return a list. So a line like:: >>> a, b = s.read('uint:12, hex:32') becomes >>> a, b = s.readlist('uint:12, hex:32') Renaming / removing functions ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Functions have been renamed as follows:: ``seekbit`` -> ``seek`` ``tellbit`` -> ``tell`` ``reversebits`` -> ``reverse`` ``deletebits`` -> ``delete`` ``tostring`` -> ``tobytes`` and a couple have been removed altogether: * ``deletebytes`` - use ``delete`` instead. * ``empty`` - use ``not s`` rather than ``s.empty()``. Renaming parameters ^^^^^^^^^^^^^^^^^^^ The parameters 'startbit' and 'endbit' have been renamed 'start' and 'end'. This affects the methods ``slice``, ``find``, ``findall``, ``rfind``, ``reverse``, ``cut`` and ``split``. The parameter 'bitpos' has been renamed to 'pos'. The affects the methods ``seek``, ``tell``, ``insert``, ``overwrite`` and ``delete``. Mutating methods return None rather than self ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This means that you can't chain functions together so :: >>> s.append('0x00').prepend('0xff') >>> t = s.reverse() Needs to be rewritten :: >>> s.append('0x00') >>> s.prepend('0xff') >>> s.reverse() >>> t = s Affects ``truncatestart``, ``truncateend``, ``insert``, ``overwrite``, ``delete``, ``append``, ``prepend``, ``reverse`` and ``reversebytes``. Properties renamed ^^^^^^^^^^^^^^^^^^ The 'data' property has been renamed to 'bytes'. Also if the BitString is not a whole number of bytes then a ValueError exception will be raised when using 'bytes' as a 'getter'. Properties 'len' and 'pos' have been added to replace 'length' and 'bitpos', although the longer names have not been removed so you can continue to use them if you prefer. Other changes ^^^^^^^^^^^^^ * The ``unpack`` method now always returns a list, never a single item. * BitStrings are now 'unhashable', so calling hash on one or making a set will fail. * The colon separating the token name from its length is now mandatory. So for example ``BitString('uint12=100')`` becomes ``BitString('uint:12=100')``. * Removed support for the 'bytes' token in format strings. Instead of ``s.read('bytes:4')`` use ``s.read('bits:32')``. New features ------------ Added endswith and startswith functions ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ These do much as you'd expect; they return True or False depending on whether the BitString starts or ends with the parameter. :: >>> BitString('0xef342').startswith('0b11101') True September 11th 2009: version 0.5.2 for Python 2.x released ---------------------------------------------------------- Finally some tools for dealing with endianness! ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ New interpretations are now available for whole-byte BitStrings that treat them as big, little, or native-endian :: >>> big = BitString(intbe=1, length=16) # or BitString('intbe:16=1') if you prefer. >>> little = BitString(intle=1, length=16) >>> print big.hex, little.hex 0x0001 0x0100 >>> print big.intbe, little.intle 1 1 'Struct'-like compact format codes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To save some typing when using ``pack``, ``unpack``, ``read`` and ``peek``, compact format codes based on those used in the struct and array modules have been added. These must start with a character indicating the endianness (``>``, ``<`` or ``@`` for big, little and native-endian), followed by characters giving the format:: b 1-byte signed int B 1-byte unsigned int h 2-byte signed int H 2-byte unsigned int l 4-byte signed int L 4-byte unsigned int q 8-byte signed int Q 8-byte unsigned int For example:: >>> s = bitstring.pack('<4h', 0, 1, 2, 3) creates a BitString with four little-endian 2-byte integers. While :: >>> x, y, z = s.read('>hhl') reads them back as two big-endian two-byte integers and one four-byte big endian integer. Of course you can combine this new format with the old ones however you like:: >>> s.unpack('>> from bitstring import BitString, pack >>> a = pack('0b11, 0xff, 0o77, int:5=-1, se=33') You can also leave placeholders in the format, which will be filled in by the values provided. :: >>> b = pack('uint:10, hex:4', 33, 'f') Finally you can use a dictionary or keywords. :: >>> c = pack('bin=a, hex=b, bin=a', a='010', b='ef') The ``unpack`` method is similar to the ``read`` method except that it always unpacks from the start of the BitString. :: >>> x, y = b.unpack('uint:10, hex') If a token is given without a length (as above) then it will expand to fill the remaining bits in the BitString. This also now works with ``read`` and ``peek``. New tostring() and tofile() methods ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``tostring`` method just returns the data as a string, with up to seven zero bits appended to byte align. The ``tofile`` method does the same except writes to a file object. :: >>> f = open('myfile', 'wb') >>> BitString('0x1234ff').tofile(f) Other changes ^^^^^^^^^^^^^ The use of ``=`` is now mandatory in 'auto' initialisers. Tokens like ``uint12 100`` will no longer work. Also the use of a ``:`` before the length is encouraged, but not yet mandated. So the previous example should be written as ``uint:12=100``. The 'auto' initialiser will now take a file object. :: >>> f = open('myfile', 'rb') >>> s = BitString(f) July 19th 2009: version 0.5.0 for Python 2.x released ------------------------------------------------------- This update breaks backward compatibility in a couple of areas. The only one you probably need to be concerned about is the change to the default for bytealigned in ``find``, ``replace``, ``split``, etc. See the user manual for more details on each of these items. Expanded abilities of 'auto' initialiser ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ More types can be initialised through the 'auto' initialiser. For example instead of :: >>> a = BitString(uint=44, length=16) you can write :: >>> a = BitString('uint16=44') Also, different comma-separated tokens will be joined together, e.g. :: >>> b = BitString('0xff') + 'int8=-5' can be written :: >>> b = BitString('0xff, int8=-5') New formatted read and peek methods ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ These takes a format string similar to that used in the auto initialiser. If only one token is provided then a single value is returned, otherwise a list of values is returned. :: >>> start_code, width, height = s.read('hex32, uint12, uint12') is equivalent to :: >>> start_code = s.readbits(32).hex >>> width = s.readbits(12).uint >>> height = s.readbits(12).uint The tokens are:: int n : n bits as an unsigned integer. uint n : n bits as a signed integer. hex n : n bits as a hexadecimal string. oct n : n bits as an octal string. bin n : n bits as a binary string. ue : next bits as an unsigned exp-Golomb. se : next bits as a signed exp-Golomb. bits n : n bits as a new BitString. bytes n : n bytes as a new BitString. See the user manual for more details. ``hex`` and ``oct`` methods removed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The special methods for ``hex`` and ``oct`` have been removed. Please use the ``hex`` and ``oct`` properties instead. :: >>> hex(s) becomes :: >>> s.hex ``join`` made a method ^^^^^^^^^^^^^^^^^^^^^^ The ``join`` function must now be called on a BitString object, which will be used to join the list together. You may need to recode slightly:: >>> s = bitstring.join('0x34', '0b1001', '0b1') becomes :: >>> s = BitString().join('0x34', '0b1001', '0b1') More than one value allowed in readbits, readbytes, peekbits and peekbytes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ If you specify more than one bit or byte length then a list of BitStrings will be returned. :: >>> a, b, c = s.readbits(10, 5, 5) is equivalent to :: >>> a = readbits(10) >>> b = readbits(5) >>> c = readbits(5) bytealigned defaults to False, and is at the end of the parameter list ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Functions that have a bytealigned parameter have changed so that it now defaults to False rather than True. Also its position in the parameter list has changed to be at the end. You may need to recode slightly (sorry!) readue and readse methods have been removed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Instead you should use the new read function with a 'ue' or 'se' token:: >>> i = s.readue() becomes :: >>> i = s.read('ue') This is more flexible as you can read multiple items in one go, plus you can now also use the peek method with ue and se. Minor bugs fixed ^^^^^^^^^^^^^^^^ See the issue tracker for more details. June 15th 2009: version 0.4.3 for Python 2.x released ----------------------------------------------------- This is a minor update. This release is the first to bundle the bitstring manual. This is a PDF and you can find it in the docs directory. New 'cut' method ^^^^^^^^^^^^^^^^ This method returns a generator for constant sized chunks of a BitString. :: >>> for byte in s.cut(8): ... do_something_with(byte) You can also specify a startbit and endbit, as well as a count, which limits the number of items generated:: >>> first100TSPackets = list(s.cut(188*8, count=100)) 'slice' method now equivalent to ``__getitem__`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This means that a step can also be given to the slice method so that the following are now the same thing, and it's just a personal preference which to use:: >>> s1 = s[a:b:c] >>> s2 = s.slice(a, b, c) findall gets a 'count' parameter ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ So now :: >>> list(a.findall(s, count=n)) is equivalent to :: >>> list(a.findall(s))[:n] except that it won't need to generate the whole list and so is much more efficient. Changes to 'split' ^^^^^^^^^^^^^^^^^^ The split method now has a 'count' parameter rather than 'maxsplit'. This makes the interface closer to that for cut, replace and findall. The final item generated is now no longer the whole of the rest of the BitString. * A couple of minor bugs were fixed. See the issue tracker for details. May 25th 2009: version 0.4.2 for Python 2.x released ---------------------------------------------------- This is a minor update, and almost doesn't break compatibility with version 0.4.0, but with the slight exception of findall() returning a generator, detailed below. Stepping in slices ^^^^^^^^^^^^^^^^^^ The use of the step parameter (also known as the stride) in slices has been added. Its use is a little non-standard as it effectively gives a multiplicative factor to apply to the start and stop parameters, rather than skipping over bits. For example this makes it much more convenient if you want to give slices in terms of bytes instead of bits. Instead of writing ``s[a*8:b*8]`` you can use ``s[a:b:8]``. When using a step the BitString is effectively truncated to a multiple of the step, so ``s[::8]`` is equal to ``s`` if ``s`` is an integer number of bytes, otherwise it is truncated by up to 7 bits. So the final seven complete 16-bit words could be written as ``s[-7::16]``. Negative slices are also allowed, and should do what you'd expect. So for example ``s[::-1]`` returns a bit-reversed copy of ``s`` (which is similar to ``s.reversebits()``, which does the same operation on ``s`` in-place). As another example, to get the first 10 bytes in reverse byte order you could use ``s_bytereversed = s[0:10:-8]``. Removed restrictions on offset ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ You can now specify an offset of greater than 7 bits when creating a BitString, and the use of offset is also now permitted when using the filename initialiser. This is useful when you want to create a BitString from the middle of a file without having to read the file into memory. :: >>> f = BitString(filename='reallybigfile', offset=8000000, length=32) Integers can be assigned to slices ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ You can now assign an integer to a slice of a BitString. If the integer doesn't fit in the size of slice given then a ValueError exception is raised. So this is now allowed and works as expected:: >>> s[8:16] = 106 and is equivalent to :: >>> s[8:16] = BitString(uint=106, length=8) Less exceptions raised ^^^^^^^^^^^^^^^^^^^^^^ Some changes have been made to slicing so that less exceptions are raised, bringing the interface closer to that for lists. So for example trying to delete past the end of the BitString will now just delete to the end, rather than raising a ValueError. Initialisation from lists and tuples ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ A new option for the auto initialiser is to pass it a list or tuple. The items in the list or tuple are evaluated as booleans and the bits in the BitString are set to 1 for True items and 0 for False items. This can be used anywhere the auto initialiser can currently be used. For example:: >>> a = BitString([True, 7, False, 0, ()]) # 0b11000 >>> b = a + ['Yes', ''] # Adds '0b10' >>> (True, True, False) in a True Miscellany ^^^^^^^^^^ * ``reversebits`` now has optional startbit and endbit parameters. * As an optimisation ``findall`` will return a generator, rather than a list. If you still want the whole list then of course you can just call ``list()`` on the generator. * Improved efficiency of ``rfind``. * A couple of minor bugs were fixed. See the issue tracker for details. April 23rd 2009: Python 3 only version 0.4.1 released ----------------------------------------------------- This version is just a port of version 0.4.0 to Python 3. All the unit tests pass, but beyond that only limited ad hoc testing has been done and so it should be considered an experimental release. That said, the unit test coverage is very good - I'm just not sure if anyone even wants a Python 3 version! April 11th 2009: version 0.4.0 released --------------------------------------- New methods ^^^^^^^^^^^ Added ``rfind``, ``findall`` and ``replace``. These do pretty much what you'd expect - see the docstrings or the wiki for more information. More special methods ^^^^^^^^^^^^^^^^^^^^ Some missing methods were added: ``__repr__``, ``__contains__``, ``__rand__``, ``__ror__``, ``__rxor__`` and ``__delitem__``. Miscellany ^^^^^^^^^^ A couple of small bugs were fixed (see the issue tracker). There are some small backward incompatibilities relative to version 0.3.2: Combined ``find`` and ``findbytealigned`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``findbytealigned`` has been removed, and becomes part of ``find``. The default start position has changed on both ``find`` and ``split`` to be the start of the BitString. You may need to recode:: >>> s1.find(bs) >>> s2.findbytealigned(bs) >>> s2.split(bs) becomes :: >>> s1.find(bs, bytealigned=False, startbit=s1.bitpos) >>> s2.find(bs, startbit=s1.bitpos) # bytealigned defaults to True >>> s2.split(bs, startbit=s2.bitpos) Reading off end of BitString no longer raises exception ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Previously a read or peek function that encountered the end of the BitString would raise a ValueError. It will now instead return the remainder of the BitString, which could be an empty BitString. This is closer to the file object interface. Removed visibility of offset ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The offset property was previously read-only, and has now been removed from public view altogether. As it is used internally for efficiency reasons you shouldn't really have needed to use it. If you do then use the ``_offset`` parameter instead (with caution). March 11th 2009: version 0.3.2 released --------------------------------------- Better performance ^^^^^^^^^^^^^^^^^^ A number of methods (especially ``find`` and ``findbytealigned``) have been sped up considerably. Bit-wise operations ^^^^^^^^^^^^^^^^^^^ Added support for bit-wise AND (``&``), OR (``|``) and XOR (``^``). For example:: >>> a = BitString('0b00111') >>> print a & '0b10101' 0b00101 Miscellany ^^^^^^^^^^ Added ``seekbit`` and ``seekbyte`` methods. These complement the 'advance' and 'retreat' functions, although you can still just use bitpos and bytepos properties directly. :: >>> a.seekbit(100) # Equivalent to a.bitpos = 100 Allowed comparisons between BitString objects and strings. For example this will now work:: >>> a = BitString('0b00001111') >>> a == '0x0f' True February 26th 2009: version 0.3.1 released ------------------------------------------ This version only adds features and fixes bugs relative to 0.3.0, and doesn't break backwards compatibility. Octal interpretation and initialisation ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The oct property now joins bin and hex. Just prefix octal numbers with '0o':: >>> a = BitString('0o755') >>> print a.bin 0b111101101 Simpler copying ^^^^^^^^^^^^^^^ Rather than using ``b = copy.copy(a)`` to create a copy of a BitString, now you can just use ``b = BitString(a)``. More special methods ^^^^^^^^^^^^^^^^^^^^ Lots of new special methods added, for example bit-shifting via ``<<`` and ``>>``, equality testing via ``==`` and ``!=``, bit inversion (``~``) and concatenation using ``*``. Also ``__setitem__`` is now supported so BitString objects can be modified using standard index notation. Proper installer ^^^^^^^^^^^^^^^^ Finally got round to writing the distutils script. To install just ``python setup.py install``. February 15th 2009: version 0.3.0 released ------------------------------------------ Simpler initialisation from binary and hexadecimal ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The first argument in the BitString constructor is now called 'auto' and will attempt to interpret the type of a string. Prefix binary numbers with '0b' and hexadecimals with '0x':: >>> a = BitString('0b0') # single zero bit >>> b = BitString('0xffff') # two bytes Previously the first argument was 'data', so if you relied on this then you will need to recode:: >>> a = BitString('\x00\x00\x01\xb3') # Don't do this any more! becomes :: >>> a = BitString(data='\x00\x00\x01\xb3') or just :: >>> a = BitString('0x000001b3') This new notation can also be used in functions that take a BitString as an argument. For example:: >>> a = BitString('0x0011') + '0xff' >>> a.insert('0b001', 6) >>> a.find('0b1111') BitString made more mutable ^^^^^^^^^^^^^^^^^^^^^^^^^^^ The methods ``append``, ``deletebits``, ``insert``, ``overwrite``, ``truncatestart`` and ``truncateend`` now modify the BitString that they act upon. This allows for cleaner and more efficient code, but you may need to rewrite slightly if you depended upon the old behaviour:: >>> a = BitString(hex='0xffff') >>> a = a.append(BitString(hex='0x00')) >>> b = a.deletebits(10, 10) becomes :: >>> a = BitString('0xffff') >>> a.append('0x00') >>> b = copy.copy(a) >>> b.deletebits(10, 10) Thanks to Frank Aune for suggestions in this and other areas. Changes to printing ^^^^^^^^^^^^^^^^^^^ The binary interpretation of a BitString is now prepended with '0b'. This is in keeping with the Python 2.6 (and 3.0) bin function. The prefix is optional when initialising using `bin=`. Also, if you just print a BitString with no interpretation it will pick something appropriate - hex if it is an integer number of bytes, otherwise binary. If the BitString representation is very long it will be truncated by '...' so it is only an approximate interpretation. :: >>> a = BitString('0b0011111') >>> print a 0b0011111 >>> a += '0b0' >>> print a 0x3e More convenience functions ^^^^^^^^^^^^^^^^^^^^^^^^^^ Some missing methods such as ``advancebit`` and ``deletebytes`` have been added. Also a number of 'peek' methods make an appearance as have ``prepend`` and ``reversebits``. See the Tutorial for more details. January 13th 2009: version 0.2.0 released ----------------------------------------- Some fairly minor updates, not really deserving of a whole version point update. December 29th 2008: version 0.1.0 released ------------------------------------------ First release! bitstring-bitstring-3.1.7/doc/slicing.rst000066400000000000000000000142611365434337700205040ustar00rootroot00000000000000.. currentmodule:: bitstring Slicing, Dicing and Splicing ============================ Manipulating binary data can be a bit of a challenge in Python. One of its strengths is that you don't have to worry about the low level data, but this can make life difficult when what you care about is precisely the thing that is safely hidden by high level abstractions. In this section some more methods are described that treat data as a series of bits, rather than bytes. Slicing ------- Slicing takes three arguments: the first position you want, one past the last position you want and a multiplicative factor which defaults to 1. The third argument (the 'step') will be described shortly, but most of the time you'll probably just need the bit-wise slice, where for example ``a[10:12]`` will return a 2-bit bitstring of the 10th and 11th bits in ``a``, and ``a[32]`` will return just the 32nd bit. :: >>> a = BitArray('0b00011110') >>> b = a[3:7] >>> print(a, b) 0x1e 0xf For single bit indices (as opposed to slices) a boolean is returned; that is ``True`` for '1' bits and ``False`` for '0' bits:: >>> a[0] False >>> a[4] True If you want a single bit as a new bitstring then use a one-bit slice instead:: >>> a[0:1] BitArray('0b0') Indexing also works for missing and negative arguments, just as it does for other containers. :: >>> a = BitArray('0b00011110') >>> print(a[:5]) # first 5 bits 0b00011 >>> print(a[3:]) # everything except first 3 bits 0b11110 >>> print(a[-4:]) # final 4 bits 0xe >>> print(a[:-1]) # everything except last bit 0b0001111 >>> print(a[-6:-4]) # from 6 from the end to 4 from the end 0b01 Stepping in slices ^^^^^^^^^^^^^^^^^^ The step parameter (also known as the stride) can be used in slices and has the same meaning as in the built-in containers: >>> s = BitArray(16) >>> s[::2] = [1]*8 >>> s.bin '1010101010101010' >>> del s[8::2] >>> s.bin '101010100000' >>> s[::3].bin '1010' Negative slices are also allowed, and should do what you'd expect. So for example ``s[::-1]`` returns a bit-reversed copy of ``s`` (which is similar to using ``s.reverse()``, which does the same operation on ``s`` in-place). Joining ------- To join together a couple of bitstring objects use the ``+`` or ``+=`` operators, or the :meth:`~BitArray.append` and :meth:`~BitArray.prepend` methods. :: # Six ways of creating the same BitArray: a1 = BitArray(bin='000') + BitArray(hex='f') a2 = BitArray('0b000') + BitArray('0xf') a3 = BitArray('0b000') + '0xf' a4 = BitArray('0b000') a4.append('0xf') a5 = BitArray('0xf') a5.prepend('0b000') a6 = BitArray('0b000') a6 += '0xf' Note that the final three methods all modify a bitstring, and so will only work with :class:`BitArray` objects, not the immutable :class:`Bits` objects. If you want to join a large number of bitstrings then the method :meth:`~Bits.join` can be used to improve efficiency and readability. It works like the ordinary string join function in that it uses the bitstring that it is called on as a separator when joining the list of bitstring objects it is given. If you don't want a separator then it can be called on an empty bitstring. :: bslist = [BitArray(uint=n, length=12) for n in xrange(1000)] s = BitArray('0b1111').join(bslist) Truncating, inserting, deleting and overwriting ----------------------------------------------- The functions in this section all modify the bitstring that they operate on and so are not available for :class:`Bits` objects. Deleting and truncating ^^^^^^^^^^^^^^^^^^^^^^^ To delete bits just use ``del`` as you would with any other container:: >>> a = BitArray('0b00011000') >>> del a[3:5] # remove 2 bits at pos 3 >>> a.bin ‘000000’ >>> b = BitArray('0x112233445566') >>> del b[24:40] >>> b.hex '11223366' You can of course use this to truncate the start or end bits just as easily:: >>> a = BitArray('0x001122') >>> del a[-8:] # remove last 8 bits >>> del a[:8] # remove first 8 bits >>> a == '0x11' True ``insert`` ^^^^^^^^^^ As you might expect, :meth:`~BitArray.insert` takes one :class:`BitArray` and inserts it into another. A bit position must be specified for :class:`BitArray` and :class:`Bits`, but for BitStreams if not present then the current :attr:`~ConstBitStream.pos` is used. :: >>> a = BitArray('0x00112233') >>> a.insert('0xffff', 16) >>> a.hex '0011ffff2233' ``overwrite`` ^^^^^^^^^^^^^ :meth:`~BitArray.overwrite` does much the same as :meth:`~BitArray.insert`, but predictably the :class:`BitArray` object's data is overwritten by the new data. :: >>> a = BitStream('0x00112233') >>> a.pos = 4 >>> a.overwrite('0b1111') # Uses current pos as default >>> a.hex '0f112233' The bitstring as a list ----------------------- If you treat a bitstring object as a list whose elements are all either '1' or '0' then you won't go far wrong. The table below gives some of the equivalent ways of using methods and the standard slice notation. =========================== ====================================== Using functions Using slices =========================== ====================================== ``s.insert(bs, pos)`` ``s[pos:pos] = bs`` ``s.overwrite(bs, pos)`` ``s[pos:pos + bs.len] = bs`` ``s.append(bs)`` ``s[s.len:s.len] = bs`` ``s.prepend(bs)`` ``s[0:0] = bs`` =========================== ====================================== Splitting --------- ``split`` ^^^^^^^^^ Sometimes it can be very useful to use a delimiter to split a bitstring into sections. The :meth:`~Bits.split` method returns a generator for the sections. :: >>> a = BitArray('0x4700004711472222') >>> for s in a.split('0x47', bytealigned=True): ... print(s.hex) 470000 4711 472222 Note that the first item returned is always the bitstring before the first occurrence of the delimiter, even if it is empty. ``cut`` ^^^^^^^ If you just want to split into equal parts then use the :meth:`~Bits.cut` method. This takes a number of bits as its first argument and returns a generator for chunks of that size. :: >>> a = BitArray('0x47001243') >>> for byte in a.cut(8): ... print(byte.hex) 47 00 12 43 bitstring-bitstring-3.1.7/doc/walkthrough.rst000066400000000000000000000332141365434337700214120ustar00rootroot00000000000000.. currentmodule:: bitstring .. _walkthrough: *********** Walkthrough *********** A Brief Introduction ==================== The aim of the :mod:`bitstring` module is make dealing with binary data in Python as easy as possible. In this section I will take you through some of the features of the module to help you get started using it. Only a few of the module's features will be covered in this walkthrough; the :ref:`manual` and :ref:`reference` provide a more thorough guide. The whole of this section can be safely skipped or skimmed over if you prefer to start with the manual. If however you'd like a gentler introduction then you might like to follow along the examples with a Python interpreter. Prerequisites ------------- * Python 2.7 or 3.x. * An installed bitstring module. * A rudimentary knowledge of binary concepts. * A little free time. If you haven't yet downloaded and installed :mod:`bitstring` then please do so (it should be as easy as typing "``pip install bitstring``"). I'll be going through some examples using the interactive Python interpreter, so feel free to start up a Python session and follow along. Getting started --------------- :: >>> from bitstring import BitArray, BitStream First things first, we're going to be typing 'bitstring' a lot, so importing directly saves us a lot of ``bitstring.BitStream`` nonsense. The classes we have imported are :class:`BitArray` which is just a container for our binary data and :class:`BitStream` which adds a bit position and reading methods to treat the data as a stream. There are also immutable versions of both these classes that we won't be using here. We can now create a couple of bitstrings:: >>> a = BitArray('0xff01') >>> b = BitArray('0b110') The first of these we made from the hexadecimal string ``0xff01`` - the ``0x`` prefix makes it hexadecimal just as ``0b`` means binary and ``0o`` means octal. Each hex digit represents four bits, so we have a bitstring of length 16 bits. The second was created from a binary string. In this case it is just three bits long. Don't worry about it not being a whole number of bytes long, that's all been taken care of internally. .. note:: Be sure to remember the quotes around the hex and binary strings. If you forget them you would just have an ordinary Python integer, which would instead create a bitstring of that many '0' bits. For example ``0xff01`` is the same as the base-10 number 65281, so ``BitArray(0xff01)`` would consist of 65281 zero bits! There are lots of things we can do with our new bitstrings, the simplest of which is just to print them:: >>> print(a) 0xff01 >>> print(b) 0b110 Now you would be forgiven for thinking that the strings that we used to create the two bitstrings had just been stored to be given back when printed, but that's not the case. Every bitstring should be considered just as a sequence of bits. As we'll see there are lots of ways to create and manipulate them, but they have no memory of how they were created. When they are printed they just pick the simplest hex or binary representation of themselves. If you prefer you can pick the representation that you want:: >>> a.bin '1111111100000001' >>> b.oct '6' >>> b.int -2 >>> a.bytes '\xff\x01' There are a few things to note here: * To get the different interpretations of the binary data we use properties such as :attr:`~Bits.bin`, :attr:`~Bits.hex`, :attr:`~Bits.oct`, :attr:`~Bits.int` and :attr:`~Bits.bytes`. You can probably guess what these all mean, but you don't need to know quite yet. The properties are calculated when you ask for them rather than being stored as part of the object itself. * The :attr:`~Bits.bytes` property returns a ``bytes`` object. This is slightly different in Python 2.7 to Python 3 - in Python 3 you would get ``b'\xff\x01'`` returned instead. Great - let's try some more:: >>> b.hex bitstring.InterpretError: Cannot convert to hex unambiguously - not multiple of 4 bits. Oh dear. The problem we have here is that ``b`` is 3 bits long, whereas each hex digit represents 4 bits. This means that there is no unambiguous way to represent it in hexadecimal. There are similar restrictions on other interpretations (octal must be a multiple of 3 bits, bytes a multiple of 8 bits etc.) An exception is raised rather than trying to guess the best hex representation as there are a multitude of ways to convert to hex. I occasionally get asked why it doesn't just do the 'obvious' conversion, which is invariably what that person expects from his own field of work. This could be truncating bits at the start or end, or padding at the start or end with either zeros or ones. Rather than try to guess what is meant we just raise an exception - if you want a particular behaviour then write it explicitly:: >>> (b + [0]).hex 'c' >>> ([0] + b).hex '6' Here we've added a zero bit first to the end and then to the start. Don't worry too much about how it all works, but just to give you a taster the zero bit ``[0]`` could also have been written as ``BitArray([0])``, ``BitArray([0])``, ``BitArray('0b0')``, ``BitArray(bin='0')``, ``'0b0'`` or just ``1`` (this final method isn't a typo, it means construct a bitstring of length one, with all the bits initialised to zero - it does look a bit confusing though which is why I prefer [0] and [1] to represent single bits). Take a look at :ref:`auto_init` for more details. Modifying bitstrings -------------------- A :class:`BitArray` can be treated just like a list of bits. You can slice it, delete sections, insert new bits and more using standard index notation:: >>> print(a[3:9]) 0b111110 >>> del a[-6:] >>> print(a) 0b1111111100 The slicing works just as it does for other containers, so the deletion above removes the final six bits. If you ask for a single item, rather than a slice, a boolean is returned. Naturally enough ``1`` bits are ``True`` whereas ``0`` bits are ``False``. :: >>> a[0] True >>> a[-1] False To join together bitstrings you can use a variety of methods, including :meth:`~BitArray.append`, :meth:`~BitArray.prepend`, :meth:`~BitArray.insert`, and plain :meth:`+` or :meth:`+=` operations:: >>> a.prepend('0b01') >>> a.append('0o7') >>> a += '0x06' Here we first put two bits at the start of ``a``, then three bits on the end (a single octal digit) and finally another byte (two hex digits) on the end. Note how we are just using ordinary strings to specify the new bitstrings we are adding. These get converted automatically to the right sequence of bits. .. note:: The length in bits of bitstrings specified with strings depends on the number of characters, including leading zeros. So each hex character is four bits, each octal character three bits and each binary character one bit. Finding and Replacing --------------------- A :meth:`~Bits.find` is provided to search for bit patterns within a bitstring. You can choose whether to search only on byte boundaries or at any bit position:: >>> a = BitArray('0xa9f') >>> a.find('0x4f') (3,) Here we have found the ``0x4f`` byte in our bitstring, though it wasn't obvious from the hexadecimal as it was at bit position 3. To see this clearer consider this equality:: >>> a == '0b101, 0x4f, 0b1' True in which we've broken the bitstring into three parts to show the found byte. This also illustrates using commas to join bitstring sections. Constructing a bitstring ------------------------ Let's say you have a specification for a binary file type (or maybe a packet specification etc.) and you want to create a bitstring quickly and easily in Python. For this example I'm going to use a header from the MPEG-2 video standard. Here's how the header is described in the standard: ==================================== =============== ============ sequence_header() No. of bits Mnemonic ==================================== =============== ============ sequence_header_code 32 bslbf horizontal_size_value 12 uimsbf vertical_size_value 12 uimsbf aspect_ratio_information 4 uimsbf frame_rate_code 4 uimsbf bit_rate_value 18 uimsbf marker_bit 1 bslbf vbv_buffer_size_value 10 uimsbf constrained_parameters_flag 1 bslbf load_intra_quantiser_matrix 1 uimsbf if (load_intra_quantiser_matrix) { intra_quantiser_matrix[64] } 8*64 uimsbf load_non_intra_quantiser_matrix 1 uimsbf if (load_non_intra_quantiser_matrix) { non_intra_quantiser_matrix[64] } 8*64 uimsbf next_start_code() ==================================== =============== ============ The mnemonics mean things like uimsbf = 'Unsigned integer, most significant bit first'. So to create a sequence_header for your particular stream with width of 352 and height of 288 you could start like this:: s = BitArray() s.append('0x000001b3') # the sequence_header_code s.append('uint:12=352') # 12 bit unsigned integer s.append('uint:12=288') ... which is fine, but if you wanted to be a bit more concise you could just write :: s = BitArray('0x000001b3, uint:12=352, uint:12=288') This is better, but it might not be a good idea to have the width and height hard-wired in like that. We can make it more flexible by using a format string and the :func:`pack` function:: width, height = 352, 288 s = bitstring.pack('0x000001b3, 2*uint:12', width, height) where we have also used ``2*uint:12`` as shorthand for ``uint:12, uint:12``. The :func:`pack` function can also take a dictionary as a parameter which can replace the tokens in the format string. For example:: fmt = 'sequence_header_code, uint:12=horizontal_size_value, uint:12=vertical_size_value, uint:4=aspect_ratio_information, ... ' d = {'sequence_header_code': '0x000001b3', 'horizontal_size_value': 352, 'vertical_size_value': 288, 'aspect_ratio_information': 1, ... } s = bitstring.pack(fmt, **d) Parsing bitstreams ------------------ You might have noticed that :func:`pack` returned a :class:`BitStream` rather than a :class:`BitArray`. This isn't a problem as the :class:`BitStream` class just adds a few stream-like qualities to :class:`BitArray` which we'll take a quick look at here. First, let's look at the stream we've just created:: >>> s BitStream('0x000001b31601201') The stream-ness of this object is via its bit position, and various reading and peeking methods. First let's try a read or two, and see how this affects the bit position:: >>> s.pos 0 >>> s.read(24) BitStream('0x000001') >>> s.pos 24 >>> s.read('hex:8') 'b3' >>> s.pos 32 First we read 24 bits, which returned a new :class:`BitStream` object, then we used a format string to read 8 bits interpreted as a hexadecimal string. We know that the next two sets of 12 bits were created from integers, so to read them back we can say >>> s.readlist('2*uint:12') [352, 288] If you don't want to use a bitstream then you can always use :meth:`~Bits.unpack`. This takes much the same form as :meth:`~ConstBitStream.readlist` except it just unpacks from the start of the bitstring. For example:: >>> s.unpack('bytes:4, 2*uint:12, uint:4') ['\x00\x00\x01\xb3', 352, 288, 1] Worked examples =============== Below are a few examples of using the bitstring module, as I always find that a good example can help more than a lengthy reference manual. Hamming distance ---------------- The Hamming distance between two bitstrings is the number of bit positions in which the two bitstrings differ. So for example the distance between 0b00110 and 0b01100 is 2 as the second and fourth bits are different. Write a function that calculates the Hamming weight of two bitstrings. :: def hamming_weight(a, b): return (a^b).count(True) Er, that's it. The :meth:`^` is a bit-wise exclusive or, which means that the bits in ``a^b`` are only set if they differ in ``a`` and ``b``. The :meth:`~Bits.count` method just counts the number of 1 (or True) bits. :: >>> a = Bits('0b00110') >>> hamming_weight(a, '0b01100') 2 Sieve of Eratosthenes --------------------- The sieve of Eratosthenes is an ancient (and very inefficient) method of finding prime numbers. The algorithm starts with the number 2 (which is prime) and marks all of its multiples as not prime, it then continues with the next unmarked integer (which will also be prime) and marks all of its multiples as not prime. So to print all primes under a million you could write:: from bitstring import BitArray # create a BitArray with a million zero bits. # The bits will be set to indicate that the bit position isn't prime. has_factors = BitArray(1000000) for i in xrange(2, 1000000): if not has_factors[i]: print(i) # Set all multiples of our prime to 1. has_factors.set(True, xrange(i*2, 1000000, i)) I'll leave optimising the algorithm as an exercise for the reader, but it illustrates both bit checking and setting. One reason you might want to use a bitstring for this purpose (instead of a plain list for example) is that the million bits only take up a million bits in memory, whereas for a list of integers it would be much more. Try asking for a billion elements in a list - unless you've got some really nice hardware it will fail, whereas a billion element bitstring only takes 125MB. bitstring-bitstring-3.1.7/release_notes.txt000066400000000000000000001506261365434337700211540ustar00rootroot00000000000000-------------------------------- bitstring module version history -------------------------------- --------------------------------------- May 5th 2020: version 3.1.7 released --------------------------------------- This is a maintenance release with a few bug fixes plus an experimental feature to allow bits to be indexed in the opposite direction. * Fixing del not working correctly when stop value negative (Issue 201) * Removed deprecated direct import of ABC from collections module (Issue 196) * Tested and added explicit support for Python 3.7 and 3.8. (Issue 193) * Fixing a few stale links to documentation. (Issue 194) * Allowing initialisation with an io.BytesIO object. (Issue 189) Experimental LSB0 mode ---------------------- This feature allows bitstring to use Least Significant Bit Zero (LSB0) bit numbering; that is the final bit in the bitstring will be bit 0, and the first bit will be bit (n-1), rather than the other way around. LSB0 is a more natural numbering system in many fields, but is the opposite to Most Significant Bit Zero (MSB0) numbering which is the natural option when thinking of bitstrings as standard Python containers. To switch from the default MSB0, use the module level function >>> bitstring.set_lsb0(True) Getting and setting bits should work in this release, as will some other methods. Many other methods are not tested yet and might not work as expected. This is mostly a release to get feedback before finalising the interface. Slicing is still done with the start bit smaller than the end bit. For example: >>> s = Bits('0b000000111') >>> s[0:5] Bits('0b00111') >>> s[0] True Negative indices work as (hopefully) you'd expect, with the first stored bit being `s[-1]` and the final stored bit being `s[-n]`. See https://github.com/scott-griffiths/bitstring/issues/156 for discussions and to add any further comments. --------------------------------------- July 9th 2019: version 3.1.6 released --------------------------------------- A long overdue maintenance release with some fixes. * Fixed immutability bug. Bug 176. * Fixed failure of `__contains__` in some circumstances. Bug 180. * Better handling of open files. Bug 186. * Better Python 2/3 check. * Making unit tests easier to run. * Allowing length of 1 to be specified for bools. (Thanks to LemonPi) --------------------------------------- May 17th 2016: version 3.1.5 released --------------------------------------- * Support initialisation from an array. * Added a separate LICENSE file. --------------------------------------- March 19th 2016: version 3.1.4 released --------------------------------------- This is another bug fix release. * Fix for bitstring types when created directly from other bitstring types. * Updating contact, website details. --------------------------------------- March 4th 2014: version 3.1.3 released --------------------------------------- This is another bug fix release. * Fix for problem with prepend for bitstrings with byte offsets in their data store. --------------------------------------- April 18th 2013: version 3.1.2 released --------------------------------------- This is another bug fix release. * Fix for problem where unpacking bytes would by eight times too long --------------------------------------- March 21st 2013: version 3.1.1 released --------------------------------------- This is a bug fix release. * Fix for problem where concatenating bitstrings sometimes modified method's arguments ------------------------------------------ February 26th 2013: version 3.1.0 released ------------------------------------------ This is a minor release with a couple of new features and some bug fixes. New 'pad' token --------------- This token can be used in reads and when packing/unpacking to indicate that you don't care about the contents of these bits. Any padding bits will just be skipped over when reading/unpacking or zero-filled when packing. >>> a, b = s.readlist('pad:5, uint:3, pad:1, uint:3') Here only two items are returned in the list - the padding bits are ignored. New clear and copy convenience methods -------------------------------------- These methods have been introduced in Python 3.3 for lists and bytearrays, as more obvious ways of clearing and copying, and we mirror that change here. t = s.copy() is equivalent to t = s[:], and s.clear() is equivalent to del s[:]. Other changes ------------- * Some bug fixes. ----------------------------------------- February 7th 2012: version 3.0.2 released ----------------------------------------- This is a minor update that fixes a few bugs. * Fix for subclasses of bitstring classes behaving strangely (Issue 121). * Fix for excessive memory usage in rare cases (Issue 120). * Fixes for slicing edge cases. There has also been a reorganisation of the code to return it to a single 'bitstring.py' file rather than the package that has been used for the past several releases. This change shouldn't affect users directly. ------------------------------------------ November 21st 2011: version 3.0.1 released ------------------------------------------ This release fixed a small but very visible bug in bitstring printing. ------------------------------------------ November 21st 2011: version 3.0.0 released ------------------------------------------ This is a major release which breaks backward compatibility in a few places. Backwardly incompatible changes =============================== Hex, oct and bin properties don't have leading 0x, 0o and 0b ------------------------------------------------------------ If you ask for the hex, octal or binary representations of a bitstring then they will no longer be prefixed with '0x', 0o' or '0b'. This was done as it was noticed that the first thing a lot of user code does after getting these representations was to cut off the first two characters before further processing. >>> a = BitArray('0x123') >>> a.hex, a.oct, a.bin ('123', '0443', '000100100011') Previously this would have returned ('0x123', '0o0443', '0b000100100011') This change might require some recoding, but it should all be simplifications. ConstBitArray renamed to Bits ----------------------------- Previously Bits was an alias for ConstBitStream (for backward compatibility). This has now changed so that Bits and BitArray loosely correspond to the built-in types bytes and bytearray. If you were using streaming/reading methods on a Bits object then you will have to change it to a ConstBitStream. The ConstBitArray name is kept as an alias for Bits. Stepping in slices has conventional meaning ------------------------------------------- The step parameter in __getitem__, __setitem__ and __delitem__ used to act as a multiplier for the start and stop parameters. No one seemed to use it though and so it has now reverted to the conventional meaning for containers. If you are using step then recoding is simple: s[a:b:c] becomes s[a*c:b*c]. Some examples of the new usage: >>> s = BitArray('0x0000') s[::4] = [1, 1, 1, 1] >>> s.hex '8888' >>> del s[8::2] >>> s.hex '880' New features ============ New readto method ----------------- This method is a mix between a find and a read - it searches for a bitstring and then reads up to and including it. For example: >>> s = ConstBitStream('0x47000102034704050647') >>> s.readto('0x47', bytealigned=True) BitStream('0x47') >>> s.readto('0x47', bytealigned=True) BitStream('0x0001020347') >>> s.readto('0x47', bytealigned=True) BitStream('0x04050647') pack function accepts an iterable as its format ----------------------------------------------- Previously only a string was accepted as the format in the pack function. This was an oversight as it broke the symmetry between pack and unpack. Now you can use formats like this: fmt = ['hex:8', 'bin:3'] a = pack(fmt, '47', '001') a.unpack(fmt) -------------------------------------- June 18th 2011: version 2.2.0 released -------------------------------------- This is a minor upgrade with a couple of new features. New interleaved exponential-Golomb interpretations -------------------------------------------------- New bit interpretations for interleaved exponential-Golomb (as used in the Dirac video codec) are supplied via 'uie' and 'sie': >>> s = BitArray(uie=41) >>> s.uie 41 >>> s.bin '0b00010001001' These are pretty similar to the non-interleaved versions - see the manual for more details. Credit goes to Paul Sargent for the patch. New package-level bytealigned variable -------------------------------------- A number of methods take a 'bytealigned' parameter to indicate that they should only work on byte boundaries (e.g. find, replace, split). Previously this parameter defaulted to 'False'. Instead it now defaults to 'bitstring.bytealigned', which itself defaults to 'False', but can be changed to modify the default behaviour of the methods. For example: >>> a = BitArray('0x00 ff 0f ff') >>> a.find('0x0f') (4,) # found first not on a byte boundary >>> a.find('0x0f', bytealigned=True) (16,) # forced looking only on byte boundaries >>> bitstring.bytealigned = True # Change default behaviour >>> a.find('0x0f') (16,) >>> a.find('0x0f', bytealigned=False) (4,) If you're only working with bytes then this can help avoid some errors and save some typing! Other changes ------------- * Fix for Python 3.2, correcting for a change to the binascii module. * Fix for bool initialisation from 0 or 1. * Efficiency improvements, including interning strategy. ------------------------------------------ February 23rd 2011: version 2.1.1 released ------------------------------------------ This is a release to fix a couple of bugs that were introduced in 2.1.0. * Bug fix: Reading using the 'bytes' token had been broken (Issue 102). * Fixed problem using some methods on ConstBitArrays. * Better exception handling for tokens missing values. * Some performance improvements. ----------------------------------------- January 23rd 2011: version 2.1.0 released ----------------------------------------- New class hierarchy introduced with simpler classes --------------------------------------------------- Previously there were just two classes, the immutable Bits which was the base class for the mutable BitString class. Both of these classes have the concept of a bit position, from which reads etc. take place so that the bitstring could be treated as if it were a file or stream. Two simpler classes have now been added which are purely bit containers and don't have a bit position. These are called ConstBitArray and BitArray. As you can guess the former is an immutable version of the latter. The other classes have also been renamed to better reflect their capabilities. Instead of BitString you can use BitStream, and instead of Bits you can use ConstBitStream. The old names are kept as aliases for backward compatibility. The classes hierarchy is: ConstBitArray / \ / \ BitArray ConstBitStream (formerly Bits) \ / \ / BitStream (formerly BitString) Other changes ------------- A lot of internal reorganisation has taken place since the previous version, most of which won't be noticed by the end user. Some things you might see are: * New package structure. Previous versions have been a single file for the module and another for the unit tests. The module is now split into many more files so it can't be used just by copying bitstring.py any more. * To run the unit tests there is now a script called runtests.py in the test directory. * File based bitstring are now implemented in terms of an mmap. This should be just an implementation detail, but unfortunately for 32-bit versions of Python this creates a limit of 4GB on the files that can be used. The work around is either to get a 64-bit Python, or just stick with version 2.0. * The ConstBitArray and ConstBitStream classes no longer copy byte data when a slice or a read takes place, they just take a reference. This is mostly a very nice optimisation, but there are occasions where it could have an adverse effect. For example if a very large bitstring is created, a small slice taken and the original deleted. The byte data from the large bitstring would still be retained in memory. * Optimisations. Once again this version should be faster than the last. The module is still pure Python but some of the reorganisation was to make it more feasible to put some of the code into Cython or similar, so hopefully more speed will be on the way. -------------------------------------- July 26th 2010: version 2.0.3 released -------------------------------------- * Bug fix: Using peek and read for a single bit now returns a new bitstring as was intended, rather than the old behaviour of returning a bool. * Removed HTML docs from source archive - better to use the online version. -------------------------------------- July 25th 2010: version 2.0.2 released -------------------------------------- This is a major release, with a number of backwardly incompatible changes. The main change is the removal of many methods, all of which have simple alternatives. Other changes are quite minor but may need some recoding. There are a few new features, most of which have been made to help the stream-lining of the API. As always there are performance improvements and some API changes were made purely with future performance in mind. The backwardly incompatible changes are: ----------------------------------------- * Methods removed. About half of the class methods have been removed from the API. They all have simple alternatives, so what remains is more powerful and easier to remember. The removed methods are listed here on the left, with their equivalent replacements on the right: s.advancebit() -> s.pos += 1 s.advancebits(bits) -> s.pos += bits s.advancebyte() -> s.pos += 8 s.advancebytes(bytes) -> s.pos += 8*bytes s.allunset([a, b]) -> s.all(False, [a, b]) s.anyunset([a, b]) -> s.any(False, [a, b]) s.delete(bits, pos) -> del s[pos:pos+bits] s.peekbit() -> s.peek(1) s.peekbitlist(a, b) -> s.peeklist([a, b]) s.peekbits(bits) -> s.peek(bits) s.peekbyte() -> s.peek(8) s.peekbytelist(a, b) -> s.peeklist([8*a, 8*b]) s.peekbytes(bytes) -> s.peek(8*bytes) s.readbit() -> s.read(1) s.readbitlist(a, b) -> s.readlist([a, b]) s.readbits(bits) -> s.read(bits) s.readbyte() -> s.read(8) s.readbytelist(a, b) -> s.readlist([8*a, 8*b]) s.readbytes(bytes) -> s.read(8*bytes) s.retreatbit() -> s.pos -= 1 s.retreatbits(bits) -> s.pos -= bits s.retreatbyte() -> s.pos -= 8 s.retreatbytes(bytes) -> s.pos -= 8*bytes s.reversebytes(start, end) -> s.byteswap(0, start, end) s.seek(pos) -> s.pos = pos s.seekbyte(bytepos) -> s.bytepos = bytepos s.slice(start, end, step) -> s[start:end:step] s.tell() -> s.pos s.tellbyte() -> s.bytepos s.truncateend(bits) -> del s[-bits:] s.truncatestart(bits) -> del s[:bits] s.unset([a, b]) -> s.set(False, [a, b]) Many of these methods have been deprecated for the last few releases, but there are some new removals too. Any recoding needed should be quite straightforward, so while I apologise for the hassle, I had to take the opportunity to streamline and rationalise what was becoming a bit of an overblown API. * set / unset methods combined. The set/unset methods have been combined in a single method, which now takes a boolean as its first argument: s.set([a, b]) -> s.set(1, [a, b]) s.unset([a, b]) -> s.set(0, [a, b]) s.allset([a, b]) -> s.all(1, [a, b]) s.allunset([a, b]) -> s.all(0, [a, b]) s.anyset([a, b]) -> s.any(1, [a, b]) s.anyunset([a, b]) -> s.any(0, [a, b]) * all / any only accept iterables. The all and any methods (previously called allset, allunset, anyset and anyunset) no longer accept a single bit position. The recommended way of testing a single bit is just to index it, for example instead of: >>> if s.all(True, i): just use >>> if s[i]: If you really want to you can of course use an iterable with a single element, such as 's.any(False, [i])', but it's clearer just to write 'not s[i]'. * Exception raised on reading off end of bitstring. If a read or peek goes beyond the end of the bitstring then a ReadError will be raised. The previous behaviour was that the rest of the bitstring would be returned and no exception raised. * BitStringError renamed to Error. The base class for errors in the bitstring module is now just Error, so it will likely appears in your code as bitstring.Error instead of the rather repetitive bitstring.BitStringError. * Single bit slices and reads return a bool. A single index slice (such as s[5]) will now return a bool (i.e. True or False) rather than a single bit bitstring. This is partly to reflect the style of the bytearray type, which returns an integer for single items, but mostly to avoid common errors like: >>> if s[0]: ... do_something() While the intent of this code snippet is quite clear (i.e. do_something if the first bit of s is set) under the old rules s[0] would be true as long as s wasn't empty. That's because any one-bit bitstring was true as it was a non-empty container. Under the new rule s[0] is True if s starts with a '1' bit and False if s starts with a '0' bit. The change does not affect reads and peeks, so s.peek(1) will still return a single bit bitstring, which leads on to the next item... * Empty bitstrings or bitstrings with only zero bits are considered False. Previously a bitstring was False if it had no elements, otherwise it was True. This is standard behaviour for containers, but wasn't very useful for a container of just 0s and 1s. The new behaviour means that the bitstring is False if it has no 1 bits. This means that code like this: >>> if s.peek(1): ... do_something() should work as you'd expect. It also means that Bits(1000), Bits(0x00) and Bits('uint:12=0') are all also False. If you need to check for the emptiness of a bitstring then instead check the len property: if s -> if s.len if not s -> if not s.len * Length and offset disallowed for some initialisers. Previously you could create bitstring using expressions like: >>> s = Bits(hex='0xabcde', offset=4, length=13) This has now been disallowed, and the offset and length parameters may only be used when initialising with bytes or a file. To replace the old behaviour you could instead use >>> s = Bits(hex='0xabcde')[4:17] * Renamed 'format' parameter 'fmt'. Methods with a 'format' parameter have had it renamed to 'fmt', to prevent hiding the built-in 'format'. Affects methods unpack, read, peek, readlist, peeklist and byteswap and the pack function. * Iterables instead of *format accepted for some methods. This means that for the affected methods (unpack, readlist and peeklist) you will need to use an iterable to specify multiple items. This is easier to show than to describe, so instead of >>> a, b, c, d = s.readlist('uint:12', 'hex:4', 'bin:7') you would instead write >>> a, b, c, d = s.readlist(['uint:12', 'hex:4', 'bin:7']) Note that you could still use the single string 'uint:12, hex:4, bin:7' if you preferred. * Bool auto-initialisation removed. You can no longer use True and False to initialise single bit bitstrings. The reasoning behind this is that as bool is a subclass of int, it really is bad practice to have Bits(False) be different to Bits(0) and to have Bits(True) different to Bits(1). If you have used bool auto-initialisation then you will have to be careful to replace it as the bools will now be interpreted as ints, so Bits(False) will be empty (a bitstring of length 0), and Bits(True) will be a single zero bit (a bitstring of length 1). Sorry for the confusion, but I think this will prevent bigger problems in the future. There are a few alternatives for creating a single bit bitstring. My favourite it to use a list with a single item: Bits(False) -> Bits([0]) Bits(True) -> Bits([1]) * New creation from file strategy Previously if you created a bitstring from a file, either by auto-initialising with a file object or using the filename parameter, the file would not be read into memory unless you tried to modify it, at which point the whole file would be read. The new behaviour depends on whether you create a Bits or a BitString from the file. If you create a Bits (which is immutable) then the file will never be read into memory. This allows very large files to be opened for examination even if they could never fit in memory. If however you create a BitString, the whole of the referenced file will be read to store in memory. If the file is very big this could take a long time, or fail, but the idea is that in saying you want the mutable BitString you are implicitly saying that you want to make changes and so (for now) we need to load it into memory. The new strategy is a bit more predictable in terms of performance than the old. The main point to remember is that if you want to open a file and don't plan to alter the bitstring then use the Bits class rather than BitString. Just to be clear, in neither case will the contents of the file ever be changed - if you want to output the modified BitString then use the tofile method, for example. * find and rfind return a tuple instead of a bool. If a find is unsuccessful then an empty tuple is returned (which is False in a boolean sense) otherwise a single item tuple with the bit position is returned (which is True in a boolean sense). You shouldn't need to recode unless you explicitly compared the result of a find to True or False, for example this snippet doesn't need to be altered: >>> if s.find('0x23'): ... print(s.bitpos) but you could now instead use >>> found = s.find('0x23') >>> if found: ... print(found[0]) The reason for returning the bit position in a tuple is so that finding at position zero can still be True - it's the tuple (0,) - whereas not found can be False - the empty tuple (). The new features in this release are: ------------------------------------- * New count method. This method just counts the number of 1 or 0 bits in the bitstring. >>> s = Bits('0x31fff4') >>> s.count(1) 16 * read and peek methods accept integers. The read, readlist, peek and peeklist methods now accept integers as parameters to mean "read this many bits and return a bitstring". This has allowed a number of methods to be removed from this release, so for example instead of: >>> a, b, c = s.readbits(5, 6, 7) >>> if s.peekbit(): ... do_something() you should write: >>> a, b, c = s.readlist([5, 6, 7]) >>> if s.peek(1): ... do_something() * byteswap used to reverse all bytes. The byteswap method now allows a format specifier of 0 (the default) to signify that all of the whole bytes should be reversed. This means that calling just byteswap() is almost equivalent to the now removed bytereverse() method (a small difference is that byteswap won't raise an exception if the bitstring isn't a whole number of bytes long). * Auto initialise with bytearray or (for Python 3 only) bytes. So rather than writing: >>> a = Bits(bytes=some_bytearray) you can just write >>> a = Bits(some_bytearray) This also works for the bytes type, but only if you're using Python 3. For Python 2 it's not possible to distinguish between a bytes object and a str. For this reason this method should be used with some caution as it will make you code behave differently with the different major Python versions. >>> b = Bits(b'abcd\x23\x00') # Only Python 3! * set, invert, all and any default to whole bitstring. This means that you can for example write: >>> a = BitString(100) # 100 zero bits >>> a.set(1) # set all bits to 1 >>> a.all(1) # are all bits set to 1? True >>> a.any(0) # are any set to 0? False >>> a.invert() # invert every bit * New exception types. As well as renaming BitStringError to just Error there are also new exceptions which use Error as a base class. These can be caught in preference to Error if you need finer control. The new exceptions sometimes also derive from built-in exceptions: ByteAlignError(Error) - whole byte position or length needed. ReadError(Error, IndexError) - reading or peeking off the end of the bitstring. CreationError(Error, ValueError) - inappropriate argument during bitstring creation. InterpretError(Error, ValueError) - inappropriate interpretation of binary data. -------------------------------------------------------------- March 18th 2010: version 1.3.0 for Python 2.6 and 3.x released -------------------------------------------------------------- New features: * byteswap method for changing endianness. Changes the endianness in-place according to a format string or integer(s) giving the byte pattern. See the manual for details. >>> s = BitString('0x00112233445566') >>> s.byteswap(2) 3 >>> s BitString('0x11003322554466') >>> s.byteswap('h') 3 >>> s BitString('0x00112233445566') >>> s.byteswap([2, 5]) 1 >>> s BitString('0x11006655443322') * Multiplicative factors in bitstring creation and reading. For example: >>> s = Bits('100*0x123') * Token grouping using parenthesis. For example: >>> s = Bits('3*(uint:6=3, 0b1)') * Negative slice indices allowed. The start and end parameters of many methods may now be negative, with the same meaning as for negative slice indices. Affects all methods with these parameters. * Sequence ABCs used. The Bits class now derives from collections.Sequence, while the BitString class derives from collections.MutableSequence. * Keywords allowed in readlist, peeklist and unpack. Keywords for token lengths are now permitted when reading. So for example, you can write >>> s = bitstring.pack('4*(uint:n)', 2, 3, 4, 5, n=7) >>> s.unpack('4*(uint:n)', n=7) [2, 3, 4, 5] * start and end parameters added to rol and ror. * join function accepts other iterables. Also its parameter has changed from 'bitstringlist' to 'sequence'. This is technically a backward incompatibility in the unlikely event that you are referring to the parameter by name. * __init__ method accepts keywords. Rather than a long list of initialisers the __init__ methods now use a **kwargs dictionary for all initialisers except 'auto'. This should have no effect, except that this is a small backward incompatibility if you use positional arguments when initialising with anything other than auto (which would be rather unusual). * More optimisations. * Bug fixed in replace method (it could fail if start != 0). ---------------------------------------------------------------- January 19th 2010: version 1.2.0 for Python 2.6 and 3.x released ---------------------------------------------------------------- * New 'Bits' class. Introducing a brand new class, Bits, representing an immutable sequence of bits. The Bits class is the base class for the mutable BitString. The differences between Bits and BitStrings are: 1) Bits are immutable, so once they have been created their value cannot change. This of course means that mutating methods (append, replace, del etc.) are not available for Bits. 2) Bits are hashable, so they can be used in sets and as keys in dictionaries. 3) Bits are potentially more efficient than BitStrings, both in terms of computation and memory. The current implementation is only marginally more efficient though - this should improve in future versions. You can switch from Bits to a BitString or vice versa by constructing a new object from the old. >>> s = Bits('0xabcd') >>> t = BitString(s) >>> t.append('0xe') >>> u = Bits(t) The relationship between Bits and BitString is supposed to loosely mirror that between bytes and bytearray in Python 3. * Deprecation messages turned on. A number of methods have been flagged for removal in version 2. Deprecation warnings will now be given, which include an alternative way to do the same thing. All of the deprecated methods have simpler equivalent alternatives. >>> t = s.slice(0, 2) __main__:1: DeprecationWarning: Call to deprecated function slice. Instead of 's.slice(a, b, c)' use 's[a:b:c]'. The deprecated methods are: advancebit, advancebits, advancebyte, advancebytes, retreatbit, retreatbits, retreatbyte, retreatbytes, tell, seek, slice, delete, tellbyte, seekbyte, truncatestart and truncateend. * Initialise from bool. Booleans have been added to the list of types that can 'auto' initialise a bitstring. >>> zerobit = BitString(False) >>> onebit = BitString(True) * Improved efficiency. More methods have been speeded up, in particular some deletions and insertions. * Bug fixes. A rare problem with truncating the start of bitstrings was fixed. A possible problem outputting the final byte in tofile() was fixed. ----------------------------------------------------------------- December 22nd 2009: version 1.1.3 for Python 2.6 and 3.x released ----------------------------------------------------------------- This version hopefully fixes an installation problem for platforms with case-sensitive file systems. There are no new features or other bug fixes. ----------------------------------------------------------------- December 18th 2009: version 1.1.2 for Python 2.6 and 3.x released ----------------------------------------------------------------- This is a minor update with (almost) no new features. * Improved efficiency. The speed of many typical operations has been increased, some substantially. * Initialise from integer. A BitString of '0' bits can be created using just an integer to give the length in bits. So instead of >>> s = BitString(length=100) you can write just >>> s = BitString(100) This matches the behaviour of bytearrays and (in Python 3) bytes. * A defect related to using the set / unset functions on BitStrings initialised from a file has been fixed. ----------------------------------------------------------------- November 24th 2009: version 1.1.0 for Python 2.6 and 3.x released ----------------------------------------------------------------- Note that this version will not work for Python 2.4 or 2.5. There may be an update for these Python versions some time next year, but it's not a priority quite yet. Also note that only one version is now provided, which works for Python 2.6 and 3.x (done with the minimum of hackery!) * Improved efficiency. A fair number of functions have improved efficiency, some quite dramatically. * New bit setting and checking functions. Although these functions don't do anything that couldn't be done before, they do make some common use cases much more efficient. If you need to set or check single bits then these are the functions you need. set / unset : Set bit(s) to 1 or 0 respectively. allset / allunset : Check if all bits are 1 or all 0. anyset / anyunset : Check if any bits are 1 or any 0. >>> s = BitString(length=1000) >>> s.set((10, 100, 44, 12, 1)) >>> s.allunset((2, 22, 222)) True >>> s.anyset(range(7, 77)) True * New rotate functions. ror / rol : Rotate bits to the right or left respectively. >>> s = BitString('0b100000000') >>> s.ror(2) >>> s.bin '0b001000000' >>> s.rol(5) >>> s.bin '0b000000100' * Floating point interpretations. New float initialisations and interpretations are available. These only work for BitStrings of length 32 or 64 bits. >>> s = BitString(float=0.2, length=64) >>> s.float 0.200000000000000001 >>> t = bitstring.pack('<3f', -0.4, 1e34, 17.0) >>> t.hex '0xcdccccbedf84f67700008841' * 'bytes' token reintroduced. This token returns a bytes object (equivalent to a str in Python 2.6). >>> s = BitString('0x010203') >>> s.unpack('bytes:2, bytes:1') ['\x01\x02', '\x03'] * 'uint' is now the default token type. So for example these are equivalent: a, b = s.readlist('uint:12, uint:12') a, b = s.readlist('12, 12') -------------------------------------------------------- October 10th 2009: version 1.0.1 for Python 3.x released -------------------------------------------------------- This is a straight port of version 1.0.0 to Python 3. For changes since the last Python 3 release read all the way down in this document to version 0.4.3. This version will also work for Python 2.6, but there's no advantage to using it over the 1.0.0 release. It won't work for anything before 2.6. ------------------------------------------------------- October 9th 2009: version 1.0.0 for Python 2.x released ------------------------------------------------------- Version 1 is here! This is the first release not to carry the 'beta' tag. It contains a couple of minor new features but is principally a release to fix the API. If you've been using an older version then you almost certainly will have to recode a bit. If you're not ready to do that then you may wish to delay updating. So the bad news is that there are lots of small changes to the API. The good news is that all the changes are pretty trivial, the new API is cleaner and more 'Pythonic', and that by making it version 1.0 I'm promising not to tweak it again for some time. ** API Changes ** * New read / peek functions for returning multiple items. The functions read, readbits, readbytes, peek, peekbits and peekbytes now only ever return a single item, never a list. The new functions readlist, readbitlist, readbytelist, peeklist, peekbitlist and peekbytelist can be used to read multiple items and will always return a list. So a line like: >>> a, b = s.read('uint:12, hex:32') becomes >>> a, b = s.readlist('uint:12, hex:32') * Renaming / removing functions. Functions have been renamed as follows: seekbit -> seek tellbit -> tell reversebits -> reverse deletebits -> delete tostring -> tobytes and a couple have been removed altogether: deletebytes - use delete instead. empty - use 'not s' rather than 's.empty()'. * Renaming parameters. The parameters 'startbit' and 'endbit' have been renamed 'start' and 'end'. This affects the functions slice, find, findall, rfind, reverse, cut and split. The parameter 'bitpos' has been renamed to 'pos'. The affects the functions seek, tell, insert, overwrite and delete. * Mutating methods return None rather than self. This means that you can't chain functions together so >>> s.append('0x00').prepend('0xff') >>> t = s.reverse() Needs to be rewritten >>> s.append('0x00') >>> s.prepend('0xff) >>> s.reverse() >>> t = s Affects truncatestart, truncateend, insert, overwrite, delete, append, prepend, reverse and reversebytes. * Properties renamed. The 'data' property has been renamed to 'bytes'. Also if the BitString is not a whole number of bytes then a ValueError exception will be raised when using 'bytes' as a 'getter'. Properties 'len' and 'pos' have been added to replace 'length' and 'bitpos', although the longer names have not been removed so you can continue to use them if you prefer. * Other changes. The unpack function now always returns a list, never a single item. BitStrings are now 'unhashable', so calling hash on one or making a set will fail. The colon separating the token name from its length is now mandatory. So for example BitString('uint12=100') becomes BitString('uint:12=100'). Removed support for the 'bytes' token in format strings. Instead of s.read('bytes:4') use s.read('bits:32'). ** New features ** * Added endswith and startswith functions. These do much as you'd expect; they return True or False depending on whether the BitString starts or ends with the parameter. >>> BitString('0xef342').startswith('0b11101') True ---------------------------------------------------------- September 11th 2009: version 0.5.2 for Python 2.x released ---------------------------------------------------------- Finally some tools for dealing with endianness! * New interpretations are now available for whole-byte BitStrings that treat them as big, little, or native-endian. >>> big = BitString(intbe=1, length=16) # or BitString('intbe:16=1') if you prefer. >>> little = BitString(intle=1, length=16) >>> print big.hex, little.hex 0x0001 0x0100 >>> print big.intbe, little.intle 1 1 * 'Struct'-like compact format codes To save some typing when using pack, unpack, read and peek, compact format codes based on those used in the struct and array modules have been added. These must start with a character indicating the endianness (>, < or @ for big, little and native-endian), followed by characters giving the format: b 1-byte signed int B 1-byte unsigned int h 2-byte signed int H 2-byte unsigned int l 4-byte signed int L 4-byte unsigned int q 8-byte signed int Q 8-byte unsigned int For example: >>> s = bitstring.pack('<4h', 0, 1, 2, 3) creates a BitString with four little-endian 2-byte integers. While >>> x, y, z = s.read('>hhl') reads them back as two big-endian two-byte integers and one four-byte big endian integer. Of course you can combine this new format with the old ones however you like: >>> s.unpack('>> from bitstring import BitString, pack >>> a = pack('0b11, 0xff, 0o77, int:5=-1, se=33') You can also leave placeholders in the format, which will be filled in by the values provided. >>> b = pack('uint:10, hex:4', 33, 'f') Finally you can use a dictionary or keywords. >>> c = pack('bin=a, hex=b, bin=a', a='010', b='ef') The unpack function is similar to the read function except that it always unpacks from the start of the BitString. >>> x, y = b.unpack('uint:10, hex') If a token is given without a length (as above) then it will expand to fill the remaining bits in the BitString. This also now works with read() and peek(). * New tostring() and tofile() functions. The tostring() function just returns the data as a string, with up to seven zero bits appended to byte align. The tofile() function does the same except writes to a file object. >>> f = open('myfile', 'wb') >>> BitString('0x1234ff').tofile(f) * Other changes. The use of '=' is now mandatory in 'auto' initialisers. Tokens like 'uint12 100' will no longer work. Also the use of a ':' before the length is encouraged, but not yet mandated. So the previous example should be written as 'uint:12=100'. The 'auto' initialiser will now take a file object. >>> f = open('myfile', 'rb') >>> s = BitString(f) ----------------------------------------------------- July 19th 2009: version 0.5.0 for Python 2.x released ----------------------------------------------------- This update breaks backward compatibility in a couple of areas. The only one you probably need to be concerned about is the change to the default for bytealigned in find, replace, split, etc. See the user manual for more details on each of these items. * Expanded abilities of 'auto' initialiser. More types can be initialised through the 'auto' initialiser. For example instead of >>> a = BitString(uint=44, length=16) you can write >>> a = BitString('uint16=44') Also, different comma-separated tokens will be joined together, e.g. >>> b = BitString('0xff') + 'int8=-5' can be written >>> b = BitString('0xff, int8=-5') * New formatted read() and peek() functions. These takes a format string similar to that used in the auto initialiser. If only one token is provided then a single value is returned, otherwise a list of values is returned. >>> start_code, width, height = s.read('hex32, uint12, uint12') is equivalent to >>> start_code = s.readbits(32).hex >>> width = s.readbits(12).uint >>> height = s.readbits(12).uint The tokens are: int n : n bits as an unsigned integer. uint n : n bits as a signed integer. hex n : n bits as a hexadecimal string. oct n : n bits as an octal string. bin n : n bits as a binary string. ue : next bits as an unsigned exp-Golomb. se : next bits as a signed exp-Golomb. bits n : n bits as a new BitString. bytes n : n bytes as a new BitString. See the user manual for more details. * hex() and oct() functions removed. The special functions for hex() and oct() have been removed. Please use the hex and oct properties instead. >>> hex(s) becomes >>> s.hex * join made a member function. The join function must now be called on a BitString object, which will be used to join the list together. You may need to recode slightly: >>> s = bitstring.join('0x34', '0b1001', '0b1') becomes >>> s = BitString().join('0x34', '0b1001', '0b1') * More than one value allowed in readbits, readbytes, peekbits and peekbytes If you specify more than one bit or byte length then a list of BitStrings will be returned. >>> a, b, c = s.readbits(10, 5, 5) is equivalent to >>> a = readbits(10) >>> b = readbits(5) >>> c = readbits(5) * bytealigned defaults to False, and is at the end of the parameter list Functions that have a bytealigned parameter have changed so that it now defaults to False rather than True. Also its position in the parameter list has changed to be at the end. You may need to recode slightly (sorry!) * readue and readse functions have been removed Instead you should use the new read function with a 'ue' or 'se' token: >>> i = s.readue() becomes >>> i = s.read('ue') This is more flexible as you can read multiple items in one go, plus you can now also use the peek function with ue and se. * Minor bugs fixed. See the issue tracker for more details. ----------------------------------------------------- June 15th 2009: version 0.4.3 for Python 2.x released ----------------------------------------------------- This is a minor update. This release is the first to bundle the bitstring manual. This is a PDF and you can find it in the docs directory. Changes in version 0.4.3 * New 'cut' function This function returns a generator for constant sized chunks of a BitString. >>> for byte in s.cut(8): ... do_something_with(byte) You can also specify a startbit and endbit, as well as a count, which limits the number of items generated: >>> first100TSPackets = list(s.cut(188*8, count=100)) * 'slice' function now equivalent to __getitem__. This means that a step can also be given to the slice function so that the following are now the same thing, and it's just a personal preference which to use: >>> s1 = s[a:b:c] >>> s2 = s.slice(a, b, c) * findall gets a 'count' parameter. So now >>> list(a.findall(s, count=n)) is equivalent to >>> list(a.findall(s))[:n] except that it won't need to generate the whole list and so is much more efficient. * Changes to 'split'. The split function now has a 'count' parameter rather than 'maxsplit'. This makes the interface closer to that for cut, replace and findall. The final item generated is now no longer the whole of the rest of the BitString. * A couple of minor bugs were fixed. See the issue tracker for details. ---------------------------------------------------- May 25th 2009: version 0.4.2 for Python 2.x released ---------------------------------------------------- This is a minor update, and almost doesn't break compatibility with version 0.4.0, but with the slight exception of findall() returning a generator, detailed below. Changes in version 0.4.2 * Stepping in slices The use of the step parameter (also known as the stride) in slices has been added. Its use is a little non-standard as it effectively gives a multiplicative factor to apply to the start and stop parameters, rather than skipping over bits. For example this makes it much more convenient if you want to give slices in terms of bytes instead of bits. Instead of writing s[a*8:b*8] you can use s[a:b:8]. When using a step the BitString is effectively truncated to a multiple of the step, so s[::8] is equal to s if s is an integer number of bytes, otherwise it is truncated by up to 7 bits. So the final seven complete 16-bit words could be written as s[-7::16] Negative slices are also allowed, and should do what you'd expect. So for example s[::-1] returns a bit-reversed copy of s (which is similar to s.reversebits(), which does the same operation on s in-place). As another example, to get the first 10 bytes in reverse byte order you could use s_bytereversed = s[0:10:-8]. * Removed restrictions on offset You can now specify an offset of greater than 7 bits when creating a BitString, and the use of offset is also now permitted when using the filename initialiser. This is useful when you want to create a BitString from the middle of a file without having to read the file into memory. >>> f = BitString(filename='reallybigfile', offset=8000000, length=32) * Integers can be assigned to slices You can now assign an integer to a slice of a BitString. If the integer doesn't fit in the size of slice given then a ValueError exception is raised. So this is now allowed and works as expected: >>> s[8:16] = 106 and is equivalent to >>> s[8:16] = BitString(uint=106, length=8) * Less exceptions raised Some changes have been made to slicing so that less exceptions are raised, bringing the interface closer to that for lists. So for example trying to delete past the end of the BitString will now just delete to the end, rather than raising a ValueError. * Initialisation from lists and tuples A new option for the auto initialiser is to pass it a list or tuple. The items in the list or tuple are evaluated as booleans and the bits in the BitString are set to 1 for True items and 0 for False items. This can be used anywhere the auto initialiser can currently be used. For example: >>> a = BitString([True, 7, False, 0, ()]) # 0b11000 >>> b = a + ['Yes', ''] # Adds '0b10' >>> (True, True, False) in a True * Miscellany reversebits() now has optional startbit and endbit parameters. As an optimisation findall() will return a generator, rather than a list. If you still want the whole list then of course you can just call list() on the generator. Improved efficiency of rfind(). A couple of minor bugs were fixed. See the issue tracker for details. ----------------------------------------------------- April 23rd 2009: Python 3 only version 0.4.1 released ----------------------------------------------------- This version is just a port of version 0.4.0 to Python 3. All the unit tests pass, but beyond that only limited ad hoc testing has been done and so it should be considered an experimental release. That said, the unit test coverage is very good - I'm just not sure if anyone even wants a Python 3 version! --------------------------------------- April 11th 2009: version 0.4.0 released --------------------------------------- Changes in version 0.4.0 * New functions Added rfind(), findall(), replace(). These do pretty much what you'd expect - see the docstrings or the wiki for more information. * More special functions Some missing functions were added: __repr__, __contains__, __rand__, __ror__, _rxor__ and __delitem__. * Miscellany A couple of small bugs were fixed (see the issue tracker). ---- There are some small backward incompatibilities relative to version 0.3.2: * Combined find() and findbytealigned() findbytealigned() has been removed, and becomes part of find(). The default start position has changed on both find() and split() to be the start of the BitString. You may need to recode: >>> s1.find(bs) >>> s2.findbytealigned(bs) >>> s2.split(bs) becomes >>> s1.find(bs, bytealigned=False, startbit=s1.bitpos) >>> s2.find(bs, startbit=s1.bitpos) # bytealigned defaults to True >>> s2.split(bs, startbit=s2.bitpos) * Reading off end of BitString no longer raises exception. Previously a read or peek function that encountered the end of the BitString would raise a ValueError. It will now instead return the remainder of the BitString, which could be an empty BitString. This is closer to the file object interface. * Removed visibility of offset. The offset property was previously read-only, and has now been removed from public view altogether. As it is used internally for efficiency reasons you shouldn't really have needed to use it. If you do then use the _offset parameter instead (with caution). --------------------------------------- March 11th 2009: version 0.3.2 released --------------------------------------- Changes in version 0.3.2 * Better performance A number of functions (especially find() and findbytealigned()) have been sped up considerably. * Bit-wise operations Added support for bit-wise AND (&), OR (|) and XOR (^). For example: >>> a = BitString('0b00111') >>> print a & '0b10101' 0b00101 * Miscellany Added seekbit() and seekbyte() functions. These complement the 'advance' and 'retreat' functions, although you can still just use bitpos and bytepos properties directly. >>> a.seekbit(100) # Equivalent to a.bitpos = 100 Allowed comparisons between BitString objects and strings. For example this will now work: >>> a = BitString('0b00001111') >>> a == '0x0f' True ------------------------------------------ February 26th 2009: version 0.3.1 released ------------------------------------------ Changes in version 0.3.1 This version only adds features and fixes bugs relative to 0.3.0, and doesn't break backwards compatibility. * Octal interpretation and initialisation The oct property now joins bin and hex. Just prefix octal numbers with '0o'. >>> a = BitString('0o755') >>> print a.bin 0b111101101 * Simpler copying Rather than using b = copy.copy(a) to create a copy of a BitString, now you can just use b = BitString(a). * More special methods Lots of new special methods added, for example bit-shifting via << and >>, equality testing via == and !=, bit inversion (~) and concatenation using *. Also __setitem__ is now supported so BitString objects can be modified using standard index notation. * Proper installer Finally got round to writing the distutils script. To install just python setup.py install. ------------------------------------------ February 15th 2009: version 0.3.0 released ------------------------------------------ Changes in version 0.3.0 * Simpler initialisation from binary and hexadecimal The first argument in the BitString constructor is now called auto and will attempt to interpret the type of a string. Prefix binary numbers with '0b' and hexadecimals with '0x'. >>> a = BitString('0b0') # single zero bit >>> b = BitString('0xffff') # two bytes Previously the first argument was data, so if you relied on this then you will need to recode: >>> a = BitString('\x00\x00\x01\xb3') # Don't do this any more! becomes >>> a = BitString(data='\x00\x00\x01\xb3') or just >>> a = BitString('0x000001b3') This new notation can also be used in functions that take a BitString as an argument. For example: >>> a = BitString('0x0011') + '0xff' >>> a.insert('0b001', 6) >>> a.find('0b1111') * BitString made more mutable The functions append, deletebits, insert, overwrite, truncatestart and truncateend now modify the BitString that they act upon. This allows for cleaner and more efficient code, but you may need to rewrite slightly if you depended upon the old behaviour: >>> a = BitString(hex='0xffff') >>> a = a.append(BitString(hex='0x00')) >>> b = a.deletebits(10, 10) becomes: >>> a = BitString('0xffff') >>> a.append('0x00') >>> b = copy.copy(a) >>> b.deletebits(10, 10) Thanks to Frank Aune for suggestions in this and other areas. * Changes to printing The binary interpretation of a BitString is now prepended with '0b'. This is in keeping with the Python 2.6 (and 3.0) bin function. The prefix is optional when initialising using 'bin='. Also, if you just print a BitString with no interpretation it will pick something appropriate - hex if it is an integer number of bytes, otherwise binary. If the BitString representation is very long it will be truncated by '...' so it is only an approximate interpretation. >>> a = BitString('0b0011111') >>> print a 0b0011111 >>> a += '0b0' >>> print a 0x3e * More convenience functions Some missing functions such as advancebit and deletebytes have been added. Also a number of peek functions make an appearance as have prepend and reversebits. See the Tutorial for more details. ----------------------------------------- January 13th 2009: version 0.2.0 released ----------------------------------------- Some fairly minor updates, not really deserving of a whole version point update. ------------------------------------------ December 29th 2008: version 0.1.0 released ------------------------------------------ First release! bitstring-bitstring-3.1.7/setup.py000066400000000000000000000026711365434337700172710ustar00rootroot00000000000000#!/usr/bin/env python from distutils.core import setup import sys kwds = {'long_description': open('README.rst').read()} if sys.version_info[:2] < (2, 7): raise Exception('This version of bitstring needs Python 2.7 or later.') setup(name='bitstring', version='3.1.7', description='Simple construction, analysis and modification of binary data.', author='Scott Griffiths', author_email='dr.scottgriffiths@gmail.com', url='https://github.com/scott-griffiths/bitstring', download_url='https://pypi.python.org/pypi/bitstring/', license='The MIT License: http://www.opensource.org/licenses/mit-license.php', py_modules=['bitstring'], platforms='all', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Operating System :: OS Independent', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Topic :: Software Development :: Libraries :: Python Modules', ], **kwds ) bitstring-bitstring-3.1.7/test/000077500000000000000000000000001365434337700165305ustar00rootroot00000000000000bitstring-bitstring-3.1.7/test/smalltestfile000066400000000000000000000000101365434337700213120ustar00rootroot00000000000000#Eg‰«Íïbitstring-bitstring-3.1.7/test/stress_test.py000066400000000000000000000032241365434337700214650ustar00rootroot00000000000000#!/usr/bin/env python import sys sys.path.insert(0, '..') from bitstring import Bits, BitStream import bitstring import time import random import cProfile import pstats # Some performance tests. Each is a task - it is permissible to rewrite # to do it in a different way. # TEST 1: Create a bitstring, read every 3 bits and count how many equal '001'. def perf1(): s = bitstring.Bits('0xef1356a6200b3, 0b0') s *= 10000 c = 0 for triplet in s.cut(3): if triplet == '0b001': c += 1 assert c == 20003 def perf2(): s = bitstring.BitArray(10000000) s.set(1, [10, 100, 1000, 100000]) count = 0 for bit in s: if bit: count += 1 assert count == 4 def perf3(): s = bitstring.BitArray() for i in range(50000): s += 'uint:12=244, float:32=0.4' s += '0x3e44f, 0b11011, 0o75523' s += [0,1,2,0,0,1,2,0,-1,0,'hello'] s += 104 def perf4(): random.seed(999) i = random.randrange(0, 2**80000000) s = bitstring.BitArray(uint=i, length=80000000) for ss in ['0b11010010101', '0xabcdef1234, 0b000101111010101010011010100100101010101', '0x4321']: print(len(list(s.findall(ss)))) def run(f): start_time= time.time() print("Running {0}".format(str(f))) f() print("Took {0} s".format(time.time() - start_time)) def main(): start_time = time.time() run(perf1) run(perf2) run(perf3) run(perf4) print("Total time {0} s".format(time.time() - start_time)) if __name__ == '__main__': cProfile.run('main()', 'stats') p = pstats.Stats('stats') p.sort_stats('time').print_stats(50) bitstring-bitstring-3.1.7/test/test.m1v000066400000000000000000003645641365434337700201560ustar00rootroot00000000000000³ ƒÐ ¤²MPEG-1 Test Sequence, 25 frames/sec ¸@ ºÀR—áô¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹HÒ"Å&¤JÖ“B'b”¤EÊR‘)JD\¥)r”¤EÊR‘)JD\¥)r”¤D+ø})H‹”¥".R”ˆ¹JR"å)H‹”¥"*9JR"å)H‹”¥".R”ˆ¹JR"å)H‹”¥".R#P?Â"å)H‹”¤Z"ãÂ4ˆ±JR"å)H‹”¥".R”ˆ¹JR"ø})H‹”¥".R”ˆ¨¥)H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JR"å)H‹ŸíŸ®ØP´›t!,Âî`r@ ,v¾°!¨,7!,¾mÊà ÑZHÏ~xš[§ß<ÜpÀ¬oF延=ï»ìœ €VI缘 €“RVJv6ó@B“±Ôò•!ÐJÅ ï%Ô"Ø ·1·¹w´Q(´ w®å)J¢å)H‹”¥ê%  †¡U· K3ã”â©€  1ìL ,±°\mýò)zðàÒ  »ƒH] ßáŽA khBcâPBp—rxåØ““sà)Ø[¨J¥ƒïÁǾ½àò (¢i4 ¤ÿñ{ GËr° !H``o ,´Œq£Î48èØ0P i`0,f7ã†'QsHx 8 ÷`í}Ø3@3I`T5ù¼Ûä`„œ˜MÃâbsŒsÇßn%ˆ¥ñ|ÛË$×ÛÿæÒV¨{\ùco, É,40(J6ïó.õ@#Àw›-ï€8@/€BÆ£‹ëƼ°ÒiD ¦G#R_m @â’¿ÈÙùûçâÌ×Ú "ºCú6mb¾´øn!€„ –<5$vµOîR”®.R”ˆ¹OŸR‘t¥".R”ˆ¹JR"å)Hˆ ø})H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JV€5bP²ËÈÈGK>~ÄB9!ÿÎØÿXhiDÄt–”Œ¿ÓÛ`ÿvA)@Ð0²g-—ß¾ÁG‹»€LÀ:¸ P(bò2öù#°œÆ_K @›ˆ2ÃXe„ôÿ²yÿñwžTÀ1v”T%”Çát†:zïËÀ @7€„´ 0) é9?„s÷°% @ À1_ÿÿêH½Ð@Õˆa©Üš”¯›íœ`T —ߧ½á€4Ð 0)()ñ­©@b¯¨ [bMÿ`*Y®ÖOµ€ì23 ýˆe€Gía€ˆa½Û®bhÂbÆ{˜0 vÈ@V–Û^là ± 7-Äû` Y=|C @ËÃ>XÞK´’¹Ô))+ï"h0!•Ð’ÝGhèß_Œzà€3Á"hËHCwIí™—ïHBßfC,5Üoÿ­ía€–Ro ˜4<5+ZêÈ¡þR¹™Q‘±×˜Àà1+d;§_1 p@+á €€šJ²QÛ~qú €hP@3&Ç¥/Š‚è à(¢`IO±H/%c–²5ÜàÀ0 Îßï¶'L†–×á€2&`À„BÊÅ„l¥K’ñèþ›}}?Oÿþ?ñ6–£uèìðèÞYqpúSo©r”¤EÊR‘)J%öŽ¨¹I± bFsˆÒﾌœ“¢å)Hˆ ø})H‹”¥".R”ˆ¹JR"å)H‹”¥".R“€=¼„è T›Û„¥‡¶þº~Ù«h»€ À ÀLˆ¤ÐÔ jÒ߶VS‰÷ÐÁp!€cаÂ`ÉYhd%J|`t(' ®¨&ìb;gÙ›˜Ü‰}D2 €?ØnI5?Í÷Ž`€gÈc¨Êß«íó¶>’a3õÝ !n„ú_ð?îðàH`'&÷ÿ¿ˆË!€j7Þʘˆ`CJØ1)ÿã=á€è@0xLÍ°Š6Û^4&€„7}¿r-Ê* €=J˜”¸9à‚@ 4Ĉhc€Àµ° ?Î-WÍÁH$`¡˜CÔ˜ºj;ô+óc.ì1 °8)8—ºr¶Ç‡L²nF¿¢€ø°áœè´âÎä¯òð€û8°@ ^ e€7îßØå˜eñP€€f Q0 À(`9=N곆€<Кâ+˜ ^¡ -@1ä1¡ooõ\}Õ¥Á\€. /€˜šPÇ<¯•½Øv€`~K)(<ü×æ`@Îp a€˜˜Po)(PaGó¾ê[ßVà@i€€dЛíÒfm÷ç Ï" ò`0Ò€tŽPo3ò7aÚþ˜^åv•Õ5ÐD2ÐÇ]²ï(¤äç3ç£w×Ê À*v¨n?¨ðß ðàÄ€0§F£‡†Ä[ôPðœ1;·ß{å`€"dÐA€0!$ Œ+Œß Ãö7ã1·¨ @€dᇣä…TJÿ_È:>ÿs«@ €@à@“¿,¤”{ª·¾”41!…¥ t%﹟ZuYBsÃwÔµ6mÚ.R‰íŸô>‹¦ï©r”¤EÊ$êS»Ä]€;+³ãÞ@)ÿ Î"% n€b:ÓA]þgÑb”¤¢ ø})H‹”¥".R”ˆ¹JR"å)H‹”¥".¶½P BæXh €¡c1;§$þ”wãf¼ØP Êtè ;OÀX1??g÷×ÁÄ1€v€ì`k`¶ÿla· €0à@/(nrŠøóžDÄ ÷ëAÀ2€vˆ ;Cétõ»Š½ ‡À1 ?ÿù¨¼Ú@BÆÿßó\Ø8à!Ù[!ÆüO¾X@€ Û!;cµžÛkÈ Ð$ÐÄ!¿Øç?ß?@@yˆpÐò'd„ãö?“½¤ÁT°à'Ñ, %(OËÈs–:øø ‚ˆÀtB&ŠÁ¨ Û¥³ç[}ë‚P g¤ :‰rûåcú‰¤ÖV½`€| À¤‰ &$4b Go²Ì6ã¡+d#dl­²¶¥/l '!€„¾M/–ŸÍ"Wÿþå)BËÁˆJR¬ÿ—V\]  @@ ,d2ÐVFì7²ÚúØ @0‚J•Ãqx% êc²žò€øD €0,ÄÀ*ÙK£}ø‰—}ˆ-<° !¼–”ïÒ¼€@A(,²j5 GÜ>;9’gýï¶[Ê,%¥Èö”t™UËHI£>ýú¬ P*PÔ„*ùü€ŒžvÆѿ״ 8/$]Â@Ò&€: S 7¡’ƒN^º`À€›•Â«@0Ï€hCC>oP I€’‚NûÇdßÂ*0 PÀ® ÉÈGܵ¨àûÁB@; @i]о÷è0@i bÀOˆ} G$ó8›â €ÀøâaDÔ –Œ×ß,Þøuô€Ž]ÀÅ T1 „ð–ÌY ¡ï‹JRôj¸œúdo¼½z#3ÇÛýÇEŒ½JR"å)H‹”ùéH‹ƒ5)ÿÞ)OÑÓ´tí¬RˆNN¤o¾÷Ð ø})H‹”¥".R”ˆ¹JR"å)H‹”¥"/¬€x ˆy[$1<öî¶Xu÷@@”JMØ ;Géa©5Íâ/Š14†›ß—nq÷ÜÁ{tbwBòRëwïÀ}x €œB+î–ßôðæ [{ô…—€vC^6áxNˆ :A(hÔì³–×x„œYÆÞTI¥ìÃS°A§¯^8°Ô€@Ða]‚©OmP@;&.\5 žV­·teõ:·¼ÅÑ @* X3 + ÛºÛ,>ç_\Ìa 1Ä –øÐ2œÜÍ»lEµOÿñ7)JZE˨àš €;pÑ© ä·Û“óç°€'b`C9 ´#öýŸßR@¢àÀ©0 ÖC% »ã„ÜÀ ƒ@€jR2? BwO3·va]>ý0 I‚É` @b½ƒzBS‰=ÛþÆÞÔ¨äÐT÷wä{ j% ~oý?š&ØøÄÐöoßß,ÀàÀ€0B6Ȉ–hFF¼À€ ‹¼!›ý?x@R€€€ …ÿ“·Çæ?qL.ì !@€Ä\ 8J?ëâ €¾À0(XK )%–¶tax=W à­ÀIÀeÛgî¢hhÍh Ð@F (&–BI0bQ¿ê^<{  :à&&¥Kß‘ï‹x b†!'§£1‹#ï°  8€bºO#û˜ Àð`žÿ£8“B¤LHÝu¸0Є1’0'Æß À@Ö,²` ¡a 9å3ýÅ(K®ûpp圣qùh P€3NÄ´âS”yÆ3 ´  Š RËÈüYÆAn‹ù"¢ÀÉ0·q¥!.=Ѽ/§ù½¥ÊR‘)Oö¤EÊR‘)JDYOûÄ7æ‚sú'>šr½IÝ“lÉI10¦OòÁ3|…È…¾)cü ø})H‹”¥".R”ˆ¹JR"å)H‹”¥"/¤@ ¸ðÀ;JËè NlssG›}Ä#€ ’ Àv’PJƒÅߟÀ€˜  À@@¡xjJèúú¨ @5‚1a€1Ùa…qŸ~ß/>s‹y €„ט<„”Œß¤ %½ýxå`^¦]É0ø HIéfNêìm¬5@p Ãw)†h`Š@LP“›ß8M)€ÁKÝOÔvúþ€nB ÀšCC% Ò·™–+eÞ% ÉÙ;¾ù÷ï¿X Y†€(8HaŸ3ð:eñ @R ` Xàƒ À7²ú¹Œâ•}( e@„°*Wá‰ÿ¥±Ü}dÐÎŽ÷Ƨûjo¾¶PH*hM¥–„ÑÆn+/ÝäÂbHe ¢³¥?m„Õ·þý( @?‚¹À€;107%Ÿ+ü;âBﲂ  f€7‰5Ëé#ûÎ8 [À€ft–GIy\Çì«Þ€)Í RÂ_ôûæÁàÀ  €`Qe£ û'ñ'Ù“ ®ÐÜrîïÈ÷A´°`!!#”IøÏÞÞD°° He `×øÁwÍA ð€˜7†ì”8Aœãî`°¡€L_éfGh-9üà EÐ` ƒvC!' B;ô6?sE ¼˜‚aAˆÌ‚‘‘°­š¼¨€`PˆEb•†°­g¾ hpР!,†_ÿ?¹˜ÖZz{߶P ‘À@Y $1ñ¿–Þûx a†b€3!³yÂo‹hh 0 ¤•ÉAŒ¾év¦¾Ö@T¢hI©GÜ'Þ %”Z.+§vç8â% QÆ^ÐEü(Ý|à%€Bœx¬¨ß‡â5ôpX Q˜ÜG¾n @NlR0Ýж=x—( fô` ƒ\ påyöEü\|4ð ’îäÄ,V͉ÛUÖ€&G(ÀÏÄÄnU}XnزÀWÈþÓŸr”§:qÕqŸÒ˜êF:1×)JD\¥)sçôèÔ¤6†×6Ú”¤D ø})H‹”¥".R”ˆ¹JR"å(ôx‹”¥".]À@žÒ(Âi  Äœ[ñy»pâC!CŒ”'}÷;ïšœ4@*Q 3ü”wQ¸Ýýïô Q0À„)áŠGJÙJ½xЀdMû!—| "Œ  Àtp€è3$k§l•Üò/{ë@vÀ;lC à|ÉN8uó@€^FB~¢’ðÖֳٜ É×Ú@”†pi_Ðß׌p@—ˆ‚/rёЬ_Ø@æ{° @0 0!÷ÉÍÄHøY4"ÐÉûáw @:nBJ B7s7=ä”dëüö@ê¸è ƒü £¾^éÈm•…þí‚à F€<¼¤ À!FÛônÌÇdšË>ú¸À@¶ÄâAD2ÑÙ”žAµ€) p @þ@©ežz>ô2pèü‘’ù¡ÅoR¦É{ÎÀ)nÒÀÈ×Ou¹¼ Ý@p]Üô‘k¨ Ë©ý=ÃêÀðahã½å€u€LBÅŽÌu,Úü¨ /€5Ì ß!¹hÂ]…_À¬p`i †ÀÔä ^éã¾scÅ_t€@Êà ’Z Å eÜ,€@Ä€§#>ØhY¤ûÕ 0À– / 1ÖƱڠÐÎ_kø42Lå€jR2Öè0wP2A0`  1(47†1*WnÆÂï±f I¥ ;-»þuÓF€_¾H CS¾8oæ ÷P€œXBHe¥(ÝØÎ%SÀ:Zï† PM)‰ ´“P^ONQ8æ{`ðÒ“ß‘jÀ€!!€bY|—û¹¶€  h¤<Ž‡x  é¶ÈÂ(B25åàœP“2Óžù0 MqeÄÉ@fïÐc+³¬EîA\ƒ@€Ä’•ÓŒ¾, à€pˆà€ªC1, nKûîâ°½@¾NQ0“—J] ‡ÔC/l×çÀLBÀ:!eb‘°rÒ—Ðÿÿ®å>Þ”ˆ¹JR"å)H‹”¥".R”ˆ¹JR" ø})H‹”¥".R”ˆ¹FzR"ãj6¥".6¥)r”¤EØäÀ €À4@T¬”Žyïr@€ôB †@tSì7€áÿs—³Ÿx)€b(¨bC¨bJNo“žÈ 0€4!àÒbRÏ¿C«´_G¿Ñ z Tho²Uҹפn\@2-)å'0«ó  \‚ˆ (M,:Ü´ô¥¶Î·ç3“ï©  (“ 14 0‚‹BS¸BÔ,ˆ×€ ”L{Š&'ð2­÷?RMÉUý›ËB~ï›Ì’ý”HX4¡™Zº?íydÂñhÉB>³ŸùI‰èê`1û„÷æ=€  €^žÉÄ$ü= †a tä ú:s^Ò`d2³oà%Ú{ MÌ(À1ÿlà*ò,üÀQ.¯iÀ€ƒòœN›ëëà€í<’š*CHÀŸpÀ` @†¥©;ðv ²6pá¡¥I}ÀyØ0Ðàoùe`ý;_£¸PÀbMÁïÇ^|8àHd$âcøÁx}çÌ €v¨hB@t—ýevÄ^AÀ0 ¥VÃBl³ñ˸Ä1ÀLÄâ‹Ã[«,2É»kè€ 6ðLCØfC'%¾Ét6#x 2&\À(LFB¬ÎØù€0(QEdd#!Û?b Uï€/fCf´††§³ñ˜sÖ”ôû”¥-§r‡RŸ>ˆ¹¾ô¦Í©r”¤EÊR‘)JD\¥) ø})H‹”¥".R”ˆ¹JR"å)H‹”£jD\¥)r”ˆ&â0°ÞrúÅFßø½@žJ ` Tš['£ŒÛç8ûì@ü$ `!>7Kó¹æ/  ”MA4¤ý„’;ãùúø ^% ÔR%õþ˼P@B,Cà†àž±s¨…c兀ø$Ôôó0hXäÔ#!};LD0VoßÞpèšÌ$ÍŠwJ7Š”pºzvÈǽ?äkçð :€ì” :ÛbÒ‡±Üò=ó@À@¯xp,”€ÏΗf9MfÀ@M!,À@'&†#üP¬Ç‹»Ém¶¾ˆ5Á8€jÀú ÿv7ÖMÿªý~ ˆèûœÒCU€À%Àtt”Løc yJ]i+nœ°¦`e#ïÒè# ™ HØ¥ 0Ë(À@iPwCL-ºÿ)l)C…ÜZT´ù72@vð˜å§›z@pàH@€& ŽOBð…ÙR Ì„daÛ5)hXia½ËJSÇÿüÿþå)IÅÊR‘)JD\¥)r”¤EÊR‘)JD\¥) ø})H‹”¥".R”ˆ¹J5".R”ˆ¹N½)öñ:v/jržœ¯p êÀ©%€`´!†vØó “•ÝQ,™ËBQÎNû‡ªHùqßp¨ÇßÒ$°À3 ŠR_ ãžú° g=@òÀP[ æq÷ÀAàøø4²Š„¿vuqbOÞö@A¼  @NZRëp÷ˆÀ :È d'æ`ª Û_ÑAÀ@v‰ „41+øý8 0Y ˜C!“3mÜ`ìkê°@:P(L!’bUÑÛ”~LJ+Þ ¨@À 0„ŠJQKb!•‚ˆ fà“B‰û¥ò”Øy ¡¯•ydBtb`‰ˆÙˆÙL¾?V7NɦBuì'ôÿÿ×ù¯_Âíêo¿Š ðÈiÅÊS¼{è‹‹ú?ˆ±HðÝüEÊR‘)ûjtí¦,7õi¥9i/#Xü"¾ÚC´!þ¹J~Ú›¾‰\¥)þѦûÌݼÿˆ±Jgú‘ ø})H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹FÔ¤EÒa ¡ G?|õäÐ „2ùiÒŽf k=$€ÒÊ$%(þ‡k° 2Ë` HCÛ9î:¬f¥&”ô÷Oÿ닃56Ú”ˆ¹JR"å)H‹”¥".R”ˆ¹¶Ô¥".tdÄ máHûxèÜýsm©H¤½ Ña?Dxm´EÈ––ôéñØoŽíJ+ÿ.GÚÙ‘³EÍ›R”ˆ€ ø})H‹”}D—ŠÏçÀ;Byñ‘þ::vëö½OÈy•1`'èçK%>i B5ÔïJÔfýrñpÄ ø@jÕkJgú“•ÊPn¦Nˆ¹Jo½".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JR"áñê…6Ñs”ˆ¹JR"å)H‹‰ÿh¡‰_¦_·‹m©ûQ¶NÛÄ\í°}÷¬, þ^FõaôdäþÆEŠR‘)JD@ ø})H‹bi]:´°(”Qöñ,3}"ƒyB&“vBÆuËPo] ‹U>òÿuåyä|£õÌb¿:B‰ˆ+*…!¡4§ó|VÆ\¢W½"Ÿöœ­É©!ç%V$ 1 ìJr):§ï¿^Ü:H--ñnPá¿,3Ãb¥¡ K‰›rA:œ„Wäˆé àxŸâÛ€?F=À:Š@†#-åH O^TÉxLK©B$€ P¼˜ži>¨„Cä=“« xLG;U ÅfÇL4À$pø±³jR“‹”ý½)Έ²7ê chþŠ¸–Fk® ¢†Þ;øŸÍîRµ:vÑ(úbÈh+/Ί­"‰…–r=Ô6›½i@!I}Z¬™úsøûè,™Ã2¬R”‰ÙûÿmF‰}¢.Šwõ¤>_d@š„—èBÖ+¼Óú{c¢É ~XÔ½R3j! I!.R”ˆ¹JR" ø})H‹ŽÔJsSîñJ?Œ|ö¸ûø!h ¦ë„\¥)rŸoJD\¨3R‘j Ô¤EÁšƒ5)pe6jR"å)H‹”îÔ¤E–ôúˆßë-õ6ðlôÞ?þæB¢’†ãáHþ·,ÈHø€9Õt‡òÄÒöR~¶(#.ÛjR'ÓÓ×ÿ¹JR"ä~ DYÅhmµ)þÑ)B^¦ÿø‹”¦¤EÊR‘ ø})H‹”¥".R”ˆ¹JRCk”¥#F¹þÔ}FztoqõD•…ðømî>£ïAš›m îR”Ž¨r”¤Cû”¥"Ü¥)þå)H‡÷)JD?¹JR!ýÊR‘îR”ˆr”¤Cû%þÊ®ÄÀu¸G¨ˆi0›˜²‘:e¡)Ì„Œðâ¯h€Ë ÊK9:Æ¢o Fãè€ tŽ¢b0t¨)`ŒÓ&Q$±¡Í¹—)JSîR”ˆxÒ‡QRt ~JV–M(0ÿGU.€™2ÈQ4 Ó¼DÇðúZI 1 !gJuè€vœ01Ù1~R—ÐÒRµ&æÀ: ¼“¢(ü}-@Peò¾²ÄQÊRÔMˆa3/ËoΖÝ=¶z<±ÿcý逨4![ÝÒÔóndÀ´˜×`DÒÌj <Ý9/¾¡È~Òo¹ÀÅÄg£ù1/U>÷Ö±à”C¯”Öœ™õ¿?¥´;Ä4b»¾û·½d££·ƒœ*v?‡Ò¸4†Q3:Sµë@€#(™¾+åDPcç ÅkédÐÞ°†ï~’ÿˆ »æ¸+¼8¯~Œß½ó€Þ"óÚ;ë¢M&âµbÅ_L95~"‚›@5½ÿ]!üÛ¨C é÷Q~"”z‘÷<˜î}éFD‘AĈ@T]ò‚‹¯Õ!…ýï‰Àšñ~´µïƒCo0M¾˜÷’V¾p˜AM¥ÿ¶òýcWŠ¼vÚù¶£µü_ØðdéCIôŸPM¤o°BoGË·}—Ϥ¾¢P-0€ Ða@:cI/ïà€ï2`çRx(ø‡íwÀbšYVP†’‘}˜ø {õÄQáÔ¯O뾂C KýwTšMéöõøŠ k&“y~Ó Éþˆ ©}óP…t§^ü˜‡÷ÃÀŽñxr󯱀Ç{à‰CëèDÒÄQýñ»Ü‚‰ŸÞ ñw‘!ê"êi×ØëÔ–†¿-“C1(ëïÀ;)¼E>Ä®ÞùÐâÉ×Ò:½ç€@ÉÑ~sÊõ%“óà0HÔ5çù[ܨK^z Gõ@OÐ×ÏKC_A!ûÌGx%'—A/H4›±ÖòɯhJ¬¼ÜV׆€Í¨ëýêHHtëF°FÉÒJµ%«z$ Ã@¡°ä2j6­ü°ÿÓH8 pBx/ù€ʾؽùé(¯pMGú•ìx2ù0ÂídÒ+DPOõ€ÐÁ—E—q€Nž×T¬þ"ƒ>BCûóÐ Úû ¯ƒ!ŠFˆ —•^ ?^à C Ê»ƒÀû¥¢(-ñ€6Em¯TPw¼Ò É:"ŽŸŸ5÷p PÉ÷Ë/Ÿß|Ì7%>"é)>ÄLë·¦ÂLˈ —áÁ¿íïš_M& î×Ì¢(÷€„˜KEô`t¿kæ?=¼†¢ »Ü¤"÷ž`€Uõ_qHgÖ¡—ÈÃ@2{ºX_xÈ!ï|ÊbA?ÐZ©½Ç :e9®=òo1 ÅåQ8@`,Ñ ¸1=q°I¨¤*¢8rxKwFçê >(Û}xùk÷ÉC{#ßÌ·þ"è!½ý3úôŸrˆYüEÿ+ ¸@;!ŒÒ€é SÞôé>"‚^ð@¥)ë»\ùcO÷P›ÿO¬gˆ£ò P¹heÞ@“2ÒO¾°ÿIˆiÆÄPQñà€1á¨g¾’²/ûª}kÿ`€8(2&€hB^ˆA…<Ì@Æ\©~E<È0b5å¿Ú°¤b‘µÚ!†µ=’7Ñ8RŠë< +‘Ÿ®ê>GÞÞD j ±€f¼MÿÞ‘>œ¿ëï’)3_œ`ÌÔKcBŸA©€N\ó¦hèJ¨H†ãV>ìé7\âq-N"v ¾P¾Å_¢@c×ï…j–C_¡È}qwÏ÷•tS—¯R…ûÀ. rШŠ ¾*L@ÖÀB†þøXfÛ_@ øŠ @“Qò|uÆÄܤõ]–FS]U×;xŠ6²³ýif¨ íâ(.ù2~¾"L)kô˜a •x Àññ|0ýzà Ñ×iȸeÞt²°CëÄŒ÷1²Rh)û ®÷Lg¾fM3™v8œuà ›šù€ªÚŒòŒ÷6㪗@ õ—ÚÐYí1^çLþñ(0«„P¶ºy7]ÉÞ¢ %#^‘,†ÂȱQ"›@€c‘€v^Ø‘ÚâÀÏ-œ ',}gR@Ok®ñ¨ ×Ϲîœ" >)Ó‘tøѯ@²=ôòh ûŸGðì²¹¶,ŽmúH繨Ïãb(üòϾîMë¼é <³o`žñaß*¹õõB¾N5ùâ(þŒÛZƒC1zÜ€•îbP˜Š?¯€œË꾊¯Œ¿.–‹×ª,™Gú SÜìó/Œ ,÷(Fˆ£ý*|eÜJ>¿4P 7:úq4O¿TEÿL¬È&ô\`Ð “¹ÕˆÉ?DàBA „`øê€Lã ŸÄ"Š¢ Ž5tdŸžB„-kGñ0-.)Í-$ò~?ÑÆ¥)9ÑÊR‘‚I±MÆïN" 8À!ÝwÙÉ»½ù¨ A·ÔÈ` ïÕA?Õú„¿¯.rw:è¤ ÆDPIÙHoõ¿Ø@4-{W!'A;#µÈ&Ç”mÖà3ÄQø²ôãož€\K.ûŽÉ¼¯ˆ “óØ1¬2Ãz0Î3¼äE‚!o—Úâdæë·€ìЀvî…ÜúDQúЀƒ\fÖ⯗ùï H‹²hé,vÏ[6jÈÈÍ©8±ü>”¤E¥)A¥)G)JDW4©?äX“9:îäÔ@5'I÷ïŸ ?ˆ%9¾}l  L·%•—b¤E¡ €X¡5ÙÂu×8 Bߣ#…^‘Z¼¾ÿ’Ÿ סØ ¿ø¯°‹à‡Ö$DÄžR”¤E¥)G)JDQÊR‘r”¤E"g qV?‡Ò”ˆ£”¥"(å)HŠ9JR"ŽR”ˆ£”¥"(å)H‹@¤–žZzy´" ÐÔ’ËJ@Ÿ†p qp,áô¥"(å)HŠ9JR"ŽR”ˆ£”¥"(å)HŠA`,À q:B ¹4¢a©J2…Ñü>”¤E¥)H wEÍH]äÇp rmUê‹%A£`Ò]‚!nÞáô¥",X`7[‘`€Þ›SJí¼Ó-롵˜l\-´Ñ5@;APnßø7õ ƒKž ê“0âž íN pä03jqúÖþ4¶ƒIr롹c=óàÚ¼5- *uXªS»Îºp z&Èà @*ú\ªA¤JÙíåAÛ ­Éíÿ•×CZ¨-dè7ªn‚éƒK”Ç›3€ y [‚°ÁÂjC^›kÿú€–ÐjCz`Ôø1 é¬YMë @—¼MÉÖ ÁH¸h ’fƒ@lXï`o ±fh4ÅŽòðú@Ô¥E³Á¬æAºßñOWÅõÊ®ª€#HUÚpl‹@ ”¤lë¨ ri Dóùÿþg {Ðnõ`lþ/¦L·öþ²ßÛúËoëKO“ Ø6² ƒk'ðn-©ÊPiÙi”Ól6´K®iœ ruu˜i. ®oà¨!5úVìàZ¿°ˆr\­— ©¶@„*P¸g÷¤²yÄX:W'®š¤þÜ‚’5 ˜† ’„ ¥² IH 4 ÈÈ)„È)…IÑ`:W[MRpMñ€ ”LFfŽT")7# "cø})HŠ9JR"®MÈ0ie 8d „2À2WZ žû= p™ pÒ('ߥ)G)JDQÊR‘r”¤EAArmpò)„²À2WUWW\0à€ vRˆI €,! o°@&uÒ©\‚Bcø})HŠ9JR"ŽR”ˆ£”¥"(å)HŠ9JR"  º P<‚B„à9' \ *W'«ªˆøÀ×€0C¼ôÄØ Å´”$g¥È$&?‡Ò”ˆ£”¥"(å)HŠ9JR"ŽR”ˆ£”¥"*@j€è04€è$AÊA!4g `€:ºzV~ V€B¤ &;›zMÇðúR‘r”¤E¥)H@„¡Tè8蜂ŠŒ¤,ƒä"¹*¶ž•&¨8-@t"MÐutíTƒƒŠ®V×R *´ž•+¥£Hc, H$%p‰€ *W'Dg"*n–œjTY ‘ƒÈÉ *W'dE ’AÈÝ6“XyG „X *W'D<ƒi³R¢ÑåR±– *W'pòŽA! „«ªm–‡T{÷Œ‚/-ÓÖTªa!+üÑä  W'SVFúAƒH,&M2,*2¢ÑïƬ¶>Ä Wmšèò  –@™H0b#:Ù6ZÇÕ+3KŠ¤²p WMÔ¬'Tz"³¤êæ’p\È(&@„Wd·(!«£È "»*Z³""£š—, Pªm“ @R C È$&A!4Z=I’ÁzJ‘ÈŽF@ W&¥h‚Bii䞉˖› ˜ˆ \¿dô³†Œ(S®¾a!# `}€'@öTŽ–pÁ…ŠuÒS¤ b‰Hû¥ÙÇì&øÿ`,ŠK¡™£>o‹S;}Ù½Ý;a¡¸`×Ç?>µÂŠ&–ùøk:P‚÷ÂÎüê@˜)0ஆÓÆÃ`ÈM1ð6ò1 W'¾o³%ÑÛ”¯ö–ÖK(¯ÐÜéÁ¹)ÉÉý•¿üpí[\ Ä.”ÀNCJ00b[(#þÍ‚Õ? @ 9``š¢PgR>_FéYyoÏ㎀vCA òÃ8iyó(iM†cŽ6N,„Piá¿ddcØ#lªÓãa€1AA„ÒB94ð2c‡Pi@7H &œ ”žP \õ‡0ö®°À0Ze’q¼Ÿ!ÃÀ € i4š’ºJS§ãÂ…×ù%â@!Ç–Œâ@èú è &´ „§íÙ›4Àçx B @ÈHÐÒƒ _˜á‰ 4`1IDÄ–Ù!­†ó³©œÂ}ÐMÅB!`ÔlŸ˜ ¨k³ögËìæ@7!¤Òh¸ÀögqáÖMûÓˆiK§óøñ"æù.5ÿõÿA('’ƒ[€õ&ú‰Ÿ#†%É»dç ãÀ]d¢Ý×$¤†§Ï¾õ·ÀtÀ° ‹ÈI-3„šç»À; : HÉ0¿úqNÊÆ%Ñ Òf(4¢¸£‚jÿëß%mÈ ÀlC , MHaeÙ)ëÃSÀþ¦@î ¤ ´ ´wBvûŠô€à@iÎŽzA ‚@tHɘlÚ’tX W‚¹I NAHÏÿ2HÞC ,˜^B‹éßáê;× û¤¢ƒI\•Òœ·^P¢,I©@jJ3$½³ºŸ©ÜáäJÿ£íƒ±@]Ž1mñ„EXihAE'I/÷ (Øa`X†ôºy®E®YE»»Ö× ,’ŸÖp­]øÿ;Œ0T3üeiù%$²ŠÛ@²`aE>±:;·=D{“K˜gYh;?>ñA˜4Ø t„†pÐчlƘ&¿Á(Ýq§’\±Â bˆd0“Iˆ&ð™Ø,ƒÜ´Ã8ˆw dcßd33.Ai-Р°t¡$½À³©|pjÿ€UÀvPha4˜ZËù{°Ô“ ,¤`Æ¥n· ú&$ Ð‹À:èë :‰ :€ P4`Qg0WûžëC quþ&$ ºB’i7: d´†vøWhb &ÃC èèýÔrÚ€lQ7†€˜T˜@4C h&?Pd?<è™’L7À6ÛÐ ì¦ _ÐY5º(bp£½0 0OƒC•3ã ¥mÂ6Ih!”POÀ)(ä·=XÒ5Àð c5àÐÐw›³|Ž¬3oºà@|ä¤>&õ,`ܶ0O`@€€dL×èÅðÁ¥çü¿†?ÁXøš‚jPÃ?Áð@'À0 ÷ë€ì¡+ ¤@ã0:I–L&$†‚aNåüGjÿcÕ¨þJR"˜$ çϤÁI 2 H$ ° WËà;¤ÒË (jḆÈn©€ 1940™Û²¿!bË…£pщ%8³@`¬KŠ Ð £ VùLi:¿–dð*ZL/¬æáuÉ€1 !Ð'cÝ™‚ÉÖM´˜„“A¸ÔÊfÙc›…$ —ÀtÜpÂa €tû?HÃ2›Î¯ò~ÃsúRÛàzJ@bNŧ`îʯ˲@™¿èH8Ü0´¹e8Ì{ü&%€˜ ƒïpÌX %>=ÆÏk(šŒY5 !XÐÒ†)ÔØ€¯ !†„7 °â’ÇÛ•–¯ŒSò={ÉÉy?|7lõ÷ÉíËJq/–ÆŒ*¸À,1}?}‰o‚@F.¿€Ø„J, 8ÄîÀ6Fv „’a@`ÄÄaæ…Èœ5 ÀÊ Xj Çœ8Ÿ$hƒI„ÐС d¤$gùÂVÏ_âo) d0Ô ( “WÀl]ð(LA0 d $ß÷ëÍø:P²‰„2Šå á…'à”ä•Xš¹41*äÒku%ÿ l¬"»ùh…ô¯ä4°Î;8 Py«ÇɵÒ§Gç‚ñ5 P :ÊõÔ4u”ƒr Ù* Ûuˆ½˜gÅu⟹ٱ½Nõ0P¥ÔyôÁjW¨þJR"ŽR”ˆ¨(.M²@pHÙ` Wuhb‹Ý /utyç×|ÉŸ$  4„Ž„¥ò òh¥0o+“8iX3s¶|aÌ:@°˜­Ð¤ä0õIJ#@-JzCC_9ÝùEwÉY(ÄÞÎû8‘jʶNÓŽ_<  Ô“JOA¥ø4˜œ¤´€¥?4оk®| €’Lø° 0¼ZsÃÕƒÜëÜi4!˜k)™€Ö`üw̾8ÉÄ`€b0˜’€lþùœ°%Ÿõ*ƒ@¨&n”£’Ôæ¿9dúÿt¿,c€å#¿3žx[ÃJöÝ.¢ú„,tÜ‘ù|“Í´+¯îž‚[Z€KÖO’ŠÝ·(ahBw1”yÇ_|ÑþØp2\Äbðùpëù,–MÉéNù!‰C>´ q©?±ÐHoåÃFJM_rq8!)å g&–À+äNBI¨_ïÁ§þ¶ŒÜ˜„†lyí–ðÜ°ßÓŠÈB:¤ãàà.S åÿŒØ\CJJ a›’ùëÝ&|iòJ @hk„§þãk.`hhYnœ€ ÿ£©‘ó#9ñ5˜›òN”§ä;§©-  @©4š  b„\ü¯ÒCR›¹‡h)A¸ ËwÈ_$—ÃC L… åá‹1mÀ €„0ðÓ¶~#g€.zÜ@LH{:Óÿ<#9áô¥"(å)HŠ9JR"ŽR”ˆ¬(,ÜkIç¸ eÂéÀ;›R ˆäAp^@tä ‚@ W'„;ëa #ÄêÝÓ„ú=ùƒ+¬–ÃýUÏpùD…~‚<¯’6~î”P‡ñˆ5@9FPw†äöQ¾dd üÜDÐÑ©J9)÷zRá©ò‡Ö&Oý)N)ðOÊàÈÅœkÖì¤Ã~ZF!ñ=Dxg%çb5kÛþ>léJ:Ý$[ çèÉbWsL¡û²ò~ÓefJ?¡Ž¡¥œäzAØüØ°À3&¤´¹4j9eðÝÍ|ï˜ÆÊp ! 4W è|YFlvš0à2À ᥆âßbÀ«7I¨%º~WîHâ€v¸ à†~JtrÕ¾)”nç‹\ ÐÂÀv·ãX÷î|àˆ‹DÒ‘û·9ÇQü>”¤E¥)G)JDQÊR‘¥†S@®~HL‚Aƒ”!áÙƒ”®N‹}äô¾H  >ç:|<À¹ÝK:~~ØŸ[öklgDÎa÷âÂë^Hû#$|ë&~ëûùúëûg”Ì:[3ËmøãkøბˆÓŽùüw4Ÿ¡‰>¿©Ž:rOoçc’ç<Êßšeˆp«þ8Ù!}»Ö½òsÿÙ¡ó·ÝJ\4ÅЇ½¿}(HT(úórWÛ–OÑÒ‚^$sGOÒc¹Ó3rÃR[ü|ŽŒØ²â¶¤8AP–#ÂTâ$µ?à$×:_¨8蜂Š@l È™È8E™·óiR© >9X|ûçÏÔ–Êóóˆ!üøñqëW ‰ô!;‚ý,DúÕƒæs(U ™jl?3Ìîºx!$®žå”R8Óßré9–4–ÝÆ€H.¶‰º“þ~ÙÇVœ ŸÉHÅsŸJd#¥“˜–Œ†QÊëå÷ÿ'VOBºIKì-˜qÒÐÃQ[c FN=Õóà;^¸ÔbƒRÉNÉd÷Q#0…ÍŠßr°óÿ7ƯŸ7$21HFc‚å2¦®ª‡ â”Ê 7f5óæU›1“êä « øxÓœˆ° ùÜhÇçäçÓýödq¨Ì53Þ¾ZvçvOC!9id1öÔ–0ßoÍa­ÎsBÓŽ¾ ÈOU¯Ïã‡AZµããÖ¨ìt¨Aé'6݇i«µYµl‰3€sHc ¤ ‚ì J@˜p W'Dg"*n–œnD50·zFÙc¶jËG‡Ò #‘’, W'dE B H¤@Õ6" j@l È,<€àL0I W'D<€éÈ„Sf¥E£Ê¥c, W'pòÁ9À9 :mªÃê›e¡ÕG­“ …=0æ¿ê`°BÿHŠ`¸/ª¤ W'SVFúAƒH,&M2,)‚Õ*QᙂR1eä8¹ò“Ñ™(æÓ·/ è +·ÝPs€ vÍödº;c•þòÃÚÉeú87%99?²·ÿŽ«ô” HØ @5€è ü Â^WcýäB€BtèR’„¶)8=|ñ!C¨°Â€bY0×ñ© Ø”XÅÑs- O¥¤oà›ëÆÃb‚ƒ ¤>„riàdÇ Ò€nL8)< ¹ëaí\a€`0´Ë$ãy>C†€@Òi5%t”§OÇ… ¯’^!€TyhÎ$ Þ€ÀÐÒa`;B¨J~Ý™±ÃLw€* ”„ (0•ùŽ—ò@v”L@ém’Øo;:™Ì'×è&⊠!°j6OÌT5Ùû3åös Òi4 Ü` û3¸ðë &ýˆiÄ4¥Óùüx‘s|—ÿúý žJ nÔ˜ê&|Ž—&í“œ'u’ˆhGw\’’ž7>û×À:&€Å€ ‰ÈIdÇøR»õ¯Ž°é$Ò`nN¿ (±%¼(| …†ÁˆiC•É,wÆ‘à0Pi04 솀Ғ€Â€¹}#;2»°©€)ÄÀJ)#R;÷e´ŽC©ØØ ¤’–ßä요ǔŸ’‚Ư»X¤,¨a¿Ó…À`„¢ÂËÛ§äuÈ%Àb0šMAI/äp‘k4Õ2a„2ø©_à€yCP¾ZyæÐ 3>î㧴šØg²¸B3#5$¢`a[ @ÁXÊ™†† °>¿ %6ZBü’òs ÀjIEf8Î`1ÿà Œ@΃]8¢†q SC2xw’å÷BpN6Y(ÿíÃqe zp0éGÙ{™`2€Ò’„7BLÕ000 ``:@å–‚^GÈýcÅg‰€0&à@Â*7â¢ù`T°Ô$†ÑÔ†dv *žX`a1€·ßãñ˜|€Ð‰d!ƒ{­ ³ÌÚ(1P½ÃI›a¼b±$ò5I”‚a\²ûmž~Ëçj?‰j™0@ÎY|:è? ”BÆ ¼¿4*èø dra¡£6|ψ—¨Z Wþt’GÞ˜X d€RL I#·ûãò¤‚¿£ðà%T±‰/' ¹àfLÔ3W¾‚@”XɨBCtão$À ÒCÁ›§ýöè" D3ù HÜžÂô%"8 {Æ ®RCCSR3ÿÌ€R7PÂË&W¢úwøzŽÁõÃ~é( ÒW%t§-×”(‹’jP’ŒÉ/lî§êw8y¿F Û'b€»!bÛãŠ°ÒЂŠO’_î,Q°ÂÀ± 7étó\‹\²‹ww¯å·å–î.’ÿ’œ^ËÜŸ{ýÙ«ä”’Ê+liÉ…øÅüèîÜõì M, ae ìüûÅ`Ð`)ÐZÃCF³`šø%@`‚[ 4òK–8TlQ †ri1Þ“;`–‚gÑጌ{ì†feÈ-% š´”$—¸u/ŽM_€UÀvPha4˜ZËù{°Ô“ ,¤`Æ¥n· ú&$ Ð‹À:èë :‰ :€ P4`Qg0WûžëC quñ1 UГI¸™ÐK%¤3·Â»CY0†XgGGÔb‰¼4À0¤À2 KA01ú€û!ùæDÌ’`¾¶Ü †€àOe0XêôMnŠœ(ïE +†pö@hcà2¦|a¡ô­¸BÆÉ-2ŠÉø%–ç«F©™`Q!) dâ³³#8[‡@7å †Yh!:y}ðÅL (¢h ØħA¼o9¢˜˜ÄËü%èé )³ðƒ¾"À„0*‘ˆœ1[çï‡qÕ0þÀt’Ï€9²`a0 È+m·0rì`0DÄôb¸ß1Xpÿ .H@; !a…l¬…c‡Y`1Ø`iHBY ?¸áÐÙ00 “1c Z{ó³p©„´¡JJr·’®ûya)éþHÞ>%t¶uül3 Fu¤ÕÔÌhéúY'­8á$ú4ø”—C§ô8]»aÜCX¤ ËÚ¦ìLØ”LÛoÒãuðÄ€(Gp0È'@)Å`”Q/¹ÝÆš(9í$ÔúI¥|’‹ý;áÝtJ@Ü´'‡æ­dì PhÂbPQI þRxÒ&#Ñü?ý³ó®° `‚xt®B ÎÝþæR¨èšR Ä´#ºÙ}W¶ p@ÐHa¥±|ÿ²ÇÝàžäÀ€0,„L-5;ï÷^•$#ÿG¤3À Ã@B²o=/ù·X†¾²Ûþ|/Õ T7ÿÿÀp“PÛ¯ßNˆd0 1Oÿ¤jz„úvÛQâðÈet9'^ÀLbR­¶_פ0@*!€Ä†PìøËÇ“`PPò è~ù{3Þ( €4 1 ' BPRÿÕ”eE÷íGœØX€0ÿo¿Û­í€’’Ñ¿C~³¯DàÀt^AcÍsn €z£pÓV`ô0ƒ`bö[6§Ô=xÄ ^Œ1;~cÕ^˜W€‡†1kRžó`ðÀ¡E»¾X›€P2€LZ>vÝFâ þo#€ {òøÀ©4²Ã „³,rª@``è @NM &vã{ ià,€oÈX²À¡hÜ4bIN,Ç+Àb‚À4(ã@HÕ¾SN¯,0ÉàT´$˜_YÍÂë“bB! :NÇ»3“¬0ši1 &ƒq©;”ͲÇ7 :H/€é!¸á„Âè#ö~‘†d 7_'ì71ÁÑ/¥-±Î7¡„¤$ìZvìªü±»$ ‘kô$ nZ\²œf=þÀLP A€wƒ8f,Ÿã çµ”MF,š„‹,hiCê‚l@W†ÃBXñIHcíÊËWÆ)ù¯$w%ätýðÝ°×Ük'·-)ľXO0ªã°Åôýö%¾ ºð€ÀiE‡ØÈÎÀ#´’L( ˜˜€Ì<йS€Ã „r@AK A˜ó‡äÐi00š´$ ”„Œÿ8JÙëâo) d0Ô ( “WÀl]ð(LA0 d $ß÷ëÍø:P²‰„2Šå á…'à”ä•Xš¹41*äÒku%ÿ l¬"¼hb …¾94„¤„(”cƒPGÒ@-A`U<÷ðÀФA€2…V:ÊA¹lŽ•íºƒÄ^Ì3âºñOÜìØÞ§ú¦{t §ã>üÑR:’‚Wÿ²@ðëÝ9Eá¨Iú¾(j0 .vû+š±Äx•ú ]$ÉÞF-$´ô¸)'˜3Ÿ½LI5^²ptRC?r’!„ÂÀÊC …e8Ô7w1±§Ã@Æp–XÍÆ€ +ª‹Ä$!I7bÇ{&pÄ”‚ÀvŒò÷ìOU1Š (ý¨0²öB{¶úö-–Q4˜µ|µfOöO¬MHWt•Å@)ß’Ã~IA¹I1c½˜ÆÀ¨Á¿ná6Æ€€7€@ÜeCJý+Xžïì@ZY?Œ¦ÀÀ€| &A0à“KF,1œ”ý[2Žáð €ààÓð ËÏœí¹­>vp“ùymû pú?€”“Hx–I¼]耀bXËOß÷ò€'nX É¥ñ§ÿi ý)Zï³J´†äeô§ýÓÖ'Ò„5À Švk €RM8&oßãÛ œ4¡»uâ%äô €4Ë‹¤¬§ûŸÇX` ;+“CP¾ÿ§æg„¥T|€@?Ò€M (gÙJË€ ZkÀL†ÈûlWQ®cYÀ4 ðܤ!â±Ìùî° U€`tPœ1¶;»»À~CÀàbh`ˆaŠe'?ärtöÿÑû@Ðv’ ÃMæÝürF›PZ¼M¥üœÏÈö€ ‘ù7 ûê@€í$0 z]ÂTJ6ÚÌ‚@¥€ZBÛ›¯©øÄ/ÍFäí{ @SRSžð`ƒLBFÌÅb ó€€’‚øE¥.Ͷ Ô|Ž {l÷C†wW°“ϯ rgɨ !#†!)|Bü€Â©A„ÌÊäÎV ÜíŸs@,&$+té9 =RR†ˆÐ RžÐ×Îw~G_ –V!ýÿý<þ,oe(ÛïÝ8ì³éÒÈe~‡Y|wA„.€Ð+ð¡[ 4žkÀ€¡00ÂIŸ‹Nc˜z°{{&€„3íe#“2ÌŽù—Ç ˜ŒP FP €Aÿß3–d³þ£ÅP`è¤ÍÒ”`2Zœ×ç,Ÿ_t¿,c€å#¿3žx[ÃJöÝ.¢ú„,tÜ‘ù|“Í´+¯tôزÐÌ^²|œVè%¹C B¹Œ£Î8*ûäîöÀ9’æ#€GÈÛ€^K%“rzS¾HbPφ­jOìtùEðÑ£R“WÜœN'HJyhÉ¥° ùÓ’jûðiÿ©›@ÀÐÀÀ Ò ÓÓ‰˜f >p*LŽ,fÏŽ´r`À*Å 1’’Z”ù›‡4’ƒá)ÿ‡øÚ™†d€í!‰Ý9-Y Èdega¤0Òa3†Ó²Ÿg ÀÀÐ y¬bfHk‘‹'c¨4¢Ò^Áª+$å6ÖLÉHA3 p»BKÙ:Aφ°¾­S œ¢4`€`€{{h´L@é %a«ùr‹ !dZ2 ˜ñÆ…Ñ4¢``aNƒñ‚h4 S†`0S eï÷Ò6 @`Q`T3J7?¹Òa˜B)ŠI(i¿äËY %”€0É¡8–3l„ºÛcŠ @(fI[á¦á5(˜RÅ> À”’Jqœ-r@`l“ÉŽÂê`JÊ C»Ü}–,5-ÍàÛÿa©Ü’ŸïŽœÎx}òŠ(bP¤›Z”ŠP`bg¬a f¸7 ¹ÿÜs@P.€B€(‰E)((šý)ltxâi1$Ò‹ý’ÌÌÇȨ1¸h @ÄÌÌMGdÜð ,‚°1 90–QmŠA-·WÂÚÀ  0 À5!PRR¢’ÐR{$þÿaüMPƒC ãwœ¤·¸€ €fM‰OÁŸeÓˆb €á&™}° bjP’’¯ÏÆQ“½Èþ>û³YL ;!dl_R[Ò¡4®w˜Á¨ç|=˜Ì &R:P#íèøà: 0•Ðž• ¯R;~ãCzCýÑÜ5Ø–Z]$0à††pĆ–ÜýÿŒ¨Ôà1ä4ÿý@Š/quŸÿ“Ñí°o%ç»Ã*Î k ± 0oGCãÀ…ä@` (1©)Ûe6;ké@;,_|Ÿ¾³˜5€vД¨]æ0À@ ò¸©¤§£ùˆà@ËxˆÌ7#þÄœÖP(` P419:úP`@Á‰ %159”xUÄ@µ!ä“›úñ£¯,p ]€ÀT‮۫>l|ÒWÔ~:–À0À!… Ntì±6=÷ך †œ3†$j<þúœ vü¢&$e¿Àe4>SbV_Q(`“IŒZKÜšjðÆ,¢Èd´”à:JÝ–¡jZX©>Ò’Ùø±uîKÅšÃE1[€Ûò’^¸cìq'8ø ´ç;§,>©îYeä“C1ƾ ¯ˆ@Q,Q‰‰/p(LÌÌ€0[öË “©i&!ÄäbÃqÌøÀ:( ZYnÅ“>K‹(¢0|~*CÙš€É…òÒ„³¾ëGp#_ìHìK牤-B`’ÃvPÀÔ˜ÃÄe|ZáM^œHM¤}òûÅ %{w›a©Ée¤Ñ2~O=‘„¤õg¯)!ƒCBM„Á£?J~P–Xqò œ B€  À@C!¤¤%ðhflÁ¸‡@:àU)&pT“ Ù”%ºˆÔZPXaD<_lŽMîÆæp8£*džË%% r“°Ï¾êøý$°Ä–5 `Ö5k€’±,¼_ddâ[ää÷$ |ñ-œ £!<´8jµò3Öè(-$ŽË‰I) (šÃ?BùŸz™—‹%†„rO8O’Mû6’|K(´“K IãR¤HéHi`Xi $ò6GHbVúMˆH !“1ÿ•S2Z>$&„¶%$+Ð`bKlÆ÷ÜiãIE$nOÀD¼BFp P Ĥ7ã Šî©Žc0O¤ƒnVä"À"ð„À£†É®ê°‘Þ`‰˜¤P#%ó˜Û•@U) )(&æ 뢥蛃Rß w©Ÿfû ´ì1?|~؈Çh@TA€T¤ † Fß|c5»¥˜b‹t§òÐ_~d×; Ã\$gûî£þ9w¾ý%/„žxç£ùp@AÀêJ Ïßã »@ Ád5ÓŠŸÎP]äâXaA¹’Œ‘:éz €ïË& ¤óQ²ã'ê?~ü© Áþ¶ÛZÀv€'FüIJÀ÷¾pØ"o ŸeÖÀ É Sn)˜)®À‚påŒ;}ð\°mÓ@‚ ÎZC>aWDPr~c}óÀ@³*|)ñ0¤!‘÷Ͳ×{€0 Š€T¼†g÷® ˜A”„¡-—ô×GÐèï)0„’ú´¤ pÒÛ-w4 `ÃJB wøÅ]€\CÌ7R:ì¥ËýµEìíãÀ`Wv÷”H ,€ì À,ý?>ÛšÖìÀb¤ ä$ìÿ.`‚€ð o&sç‹Ô~€˜Y4¤ºì` –B!”©<}H AÀaœ ÁÐdàU 1)$¤°ÑÂí`ðÊÈB\n>_ï¨üÀ - &“ñò | €˜0¾{5êä@hÁˆd©¯.ð…À  ƒ ç³ß2x  Û]E#wQlôà ð ÷I “@b§o²÷ÄÒД±EòÃVp˜ €ßX_C0f/ñ‰RœDÒiEr0™ÐŒ5 ƒGq$úôBÊ-80°ÂƒËû£•ƒúGOˆA€Á=8nA-løŸA„ÐÂð -Ø4uDT¶Á£PVdðޡ쳺ëô Ò0@P.‚€ÈÂRI'åa#øDÑ U ;øoàe'ñ~¸j@©,4 †“Kèe—ú™š T° K/¥iOäúø„BI4¢²@%ÄzI`ÀÀ ’å–Ld·QË"¼œPPbCLN'zH¡¥bŠÄ.RxoOßìaø󎯜 Ö@@ð úKņHE†â¾ FÿáBQ|˜MåQ7-’€Ô e ¤”°`àÐá¹ö¹ N¾AÂQdÂËû†§¨1²û¾Rñ²IiØh&“Xo8¯A¼„’ÒpƒKe'£©K;È éAü€Î‚ËIÅ 8Ü{WÁ¥MH‹we£¬œø à1Ë&MN7`1Ü I¡¡˜¼¤!®Ã†‹e€¡Eò &ùy0¬¬Í×ö_uý^*°(‚hi 4°Ìî5 ä”R1•ŠNù€F¹dÂi0†žBF&'§9NI9{sU÷:€wÊBYÔ©Î+‰Wú¼$gFÃl04šC>JBø|„|5s;n qÊ¿öÁˆI-ÕÉ*¦¸ &X B³”ë2(´B,`:,!ÈE° _¹Hÿ)Í€É4†Ÿ°a-ÞœVFJw É&‡‰…€œR qIÜ”‚Ã{rX®Î£ ( œ(l¤£|€LLP-Æd’ÿ@Óœµ½üÅíÜ—»î2ÔmK1-;¯ì@‘›+°ì”±¢L»ämÀUM€ñL häþò8ÞyiâSë÷?#‰J}jÝ$# FØ7ßÌ& à ‰A¸b¾ÿ{Üppñ 5Šç󯜀€è À¢IlKØëÒ€€dd“KG)lÿk× 0Ä ô–XnC…ˆâí1NpD ‰  ?‘èý`ÀÀ¤†¥~±×“BÐLé ̧|A¶è„¾(­Ï{žÈ5Êu1(Í•v€@@ ªHd×ÈùÙ‡‹ºÀ¨ Y &v·¤^úˆ€„‚aEp‚±#Øu`@<ÕB—ºö9Í»`ƒpðÁó‚¹7‚'çfy! ˜¡(^ÉÌÍò=i à` Ò¨ñ€1` SÒ‘ö~vÄZðèa´ )gªÐdÓ€ÏX¹ø ^÷Q7€GtP` %â`Î+âue‚ b¸N^z>`âÙ HÇÆ>2Æ™L¯J@à I{òo ¹À [Ç î=cîP` €®A0 bV¿,@ð a¸¢¸Ïǧz@(C@+ËÕ¾NÉG}×¾„ ´d£îŸ|l sJãÎH¨–‚ÀÉ|$þ>€Þ„:¹Ž|KI!¿4P‡Ì_û‰”_å¯-s ¾€ÜJ Vàˆ ùT5\–û9#…_I©O|>=) ÉÉãv̲GCOgJ…s_¥ _w6´tÙ )±‰øBÞ`ÏÀIÀ"¶Œ„àà;_¸ÀÐÌ”–`"~w|ÀnŠI/rb_üJ`¸ Û8—\Üaa€6Á¦ðAd·/ ìììk $•ÓܲŠG{î@'2Æ’Àû¸Ð Ôœ1‰_Zv óöÎ:²t2%#ÌN})Ž”VNbZ2G(g¬¾ÿäâŠÉèWI)}…³:Zb +laHÉǺ¾|j¸ÔbƒRÉNÉd÷Q#0…ÍŠßr°óÿ7ƯŸ7$21HFc‚å2¡áñ&—ƒ Jz²7ð¯FpÀ VÎ0“p!ÎB? Õ„  À:&ÒqE%!YDú>  i€àœ„œæµè@€–CRýßû8 h€5å“CPæñw\ —ÃKýï¨ °€œ%”€Þ3'«}öà|À€fˆh`a7ŒÉNmÅú:É  ËOs£À†ð?Âç( pÙPpjq#ÝØšÞû¥c¯Sì+ÿBKK¬Ú9À†>Nü7cø]A¼p¨`A¼p¨`ð IðÀð EFÉÄ4 ¸hÿ"xáPÀ ‰¼‰ € CñÉ'Ëèô­‹'ѱé43åð» É¥–Œý®€CS€·¹€Zˆ²bPžWÇ\€@0¼Ü®Æ>p°€ @dÎÆ>Gç€ €©a¡›$qÉi.Ñ3¾Ušùp- &bÏkâPà)ƒ\hŹð ÈîãF??'>Ÿï³#Fa¨˜põ–¹Ý“ÐÈNZCÙ }€õ%Œ$7ÛóXksœÅWü#vÙÆ:ÙÅì~s$¥òÉNâ1¾Ìßo¹oJÿ¥9}Iýá Õþ(†BHÀÄ~È$Ž°œ¢>€Èb K15Æ8ÜŽÍñÂ<40˜Ð’|ÜHÅ”1( &¶ù˜¬ŒÂ?GäúsKF Šq¡ (î£&„¹_ [Ǩ”Rñ´!¤dœÛtf¤–xØCø}¼1ÀcÀ PÎö ª€WâbP¦Okp²!6Ú]¸Æº@| B^íùM¸5Gê€ ÀwƒHe°ÿm)K³€'-Èe‰´O±yï®vÉ !/óSÈ÷è I €? JM/‘èñ$\Xe¡Cÿî @€ŽM&B‹ç:é‚PR€2 )=³}ýÂ!þ&„²ʼÀ@-È1`:I`—ƶm˜-wˆà€@@Xh°ÞKm¿Gx ¤ðD;@€Ž_ì±ídÐ _“ äú²ú¬€€ÀUnÆ{€À €€NƒwüÎË·’€ bˆDÔ%<Î1t}2` %% $0öT˜óã+¸ÄÂiD4 +¾…Î ¶|Bæ¾ \„À@E,Èßènø÷ÍðU`€„dç+6±:( C£f ²RÌ€2ãC ‹ÃÀÕˆÀ€ZÈârH@So‡±£ˆ(¤Œ„fÚ1Zm¶l­  pt†¬ÌxßÂédmŽÙ¨þvAëôâÐ+µÆº@”û€Åü…±:è!!@Ê(þFov@ƒ@b a›ÿÌÆæê£ö€ Qñ ¼.¼¯Ñìà ¤Âaóí©eï}hH@' Ý ß'‘ï¿R¡ @Ð’“¾/Ÿ¸ÿF¤ Ë&ev«À É»ç…× Eüw€Ñlw¨0 €Ä¬È‚ê!œPÄ1\´`ýGœ@É¥%É|.ÄÀ4HdÀÔ—º¼ V¡šY »Ù€€h ‹/7sýà° ‰¨N - ÷?ã¨üp g$5(Ae¾ì¸à09@'+%ïx˜8i5=_y@2'ä>QE¥÷mx@€hø<€Rÿÿí¿ç=ò €’xÞ@N7ÿ²žwâë–ûçÇzp paü>°èÔ3©lWI“CC)%Ÿ'7™ „PÃ^„æú¸^=)ÜuÓˆ —Óö î"ò%“ $¡ ¦,à ïÈHqû]ÀÁì Ãyn„~{¢õ‚˜À¤Ô“rPWIû ð­GëI€€xCu†pª¼@;Nd©Œ¼²À®ø1ûr$¸˜VÊ)bdÀ@HxŒËáÚÔ (`– b7#µµ^Ä0 2F†|uÒÌÜ„Ÿ™—x€@Ä0‰OAH _SnÍ{¨F!¥‡ûÖ €€(  ’ƒ Éß Ì~s8»Ý @2€ ÀÁ7’ŒœÍ¾ÜÏŒúH |˜^Y· À—ˆa›¤ÝwÄ°û–€Ü¦w}tì4„ˆ`Îò„s®À@8 HD¤«•¸ïGã^@`„ˆ5ê­Ž&(k˜x‹=ò@Ã@`B/ž’‘øUðy “Ò©À q:|¥:r2þÂk@B¼@oË BŒy†ÃHYh+cSö™ d #–M (1þ”ìG£©Ú´èP\ÒYhs3ë ´1 „$$•Ð£›Û´b¡ 'é`Þv€)   ‰‰@hk)jÂÅÞ( Z€8\L @-2k2¬.8 e‚¦? FOgø÷Ußvp KOwàô¹`;J]?¬}~rjo¢/JCb–”þÿµö¤àT¼%†–žžŸØ.@tL¹xMÅp ä0Ï÷?] !–†ÜüeæAÈA@0Á¤4â¶n°åÎà  !a|®Ù;ÿÕ²î@@N"!€?zL ²PŸÙG›èù €§€0BÕS†jdü‚‰¥ Ï&ûçË×ÌŠ@`b Gß#l¡WÄBf„ƒ1Å# *œ rl,ŸZ 'Éê|1ü>$ÐÔ éIÚ  ËI@0HÎÇÌ †€Ø˜Y`IÔo„ ÐÐ$ÃõàÐ~‹–c–×tH i†F ýÿ6 3@NMBÜßwÀBÐÐÔîçßB `'À;I1§nùOµõ r  éˆ,´nùO²èèÔ4†á<þm¤†ÃRŽ&ZMªÐ`ÒoÜg0ËÓ !€œTžž±w¸Mˆ Ë_-=Åú;² I¶` ‹!§qŠ7ÔdYÉ@d4!—Õ` ÀL¸„1¹;‡(x›€„0*œMGAYoÀíÀà€Šô( Jrax1÷åü­œ]@ b`„"ZyCqÏöYàv°è T ”Pj6ÊS‡5éT1~åÕ…Ý  À@bCJ@SùæÞy©0pf!é_mºs|` ‚x€ (01!£1,¿–ãµ€\ˆÔ†ŒkqÃOpûÏh i”‰EYo»eð˜»ë€€ !@J I'x @Nv@vP“Ò;søá÷(Pi !¹ ÿ‘n@Ð͵E¾|w€L’y`&‰Jÿ+Vï·ž pÊCááó€^À¢PÏÙRRa¥`Ò’ŽrwÜ>dÐÌM)%$äï¸}|”@©/ v@BdÔ%sÇ^00„ ­¶üûBA°„_ B:Å^˜p@:ÀÈd´mÖûol”PÄ|4¤n¿òTO£õ€i 9ŠçŽ¹Àßè„p*PÄ# ÿá× €›?+vY†,uÙ @ÉÐ@À¡ 8¯·Êã·<Ù€À €.`BH8ÄýŸ#¨.Ð €0N,ã àIÈ”}0@ÉBð€’L&'œq‚¯^@ŸÀN’ñIìü×€ e‚q`†—‰}š÷là! !“zÿß‘nÀ Êéá€Q(¬­‘¯ð`: @`ˆE³a›:”}Ôù`; ûþ¿0 2 !–­×äÐ Ëʸ €d8ÈiH¾Áëph¨nÇÿìÿÛQÜ€RC¤2’ ÃÇÞA¤4 @(41™¹Ì8p˜ÁÂa†MB2;û…}æ@.Ðbb FtmšñÀ A45¸¿PhkÖƒE‚aA˜#h z>:tøÝ 'Á#øÀr€>&†¥9ROíÎç_H ð@Ðà;ØBûôŸÄÞ8'@¤ Á!ˆáBr¸›é ’÷P†²OO6ôÁ$ÊJàÕ”$}$$cè÷€;Ô°†õ›0 \5~bbCCVob|аÐÇȽ`‹!—úý=µ€€%˜´pÁØ5È@ŸÊß|(ë¾Ôñ4E¿tL ’ÀtZ6OW –7s›ª>ßQüˆðÈEè4†RöŽùK¸E€Ôd£ä£çß_[@Ê&€dC8 ú¾xà›€€hPicY³þçâp}†ðÄü7ew'zÃJÞ¸Ýóã¼ vÓT€øêÙ³RuIüÄภ'×BÉñçÀ"C/bi1™†šjï¤à1-`ß1À]!„Òj²Æ»é`ª¢ÊØkï‚}í‚HbPÝÏì ÊGQépÃP4~¼Ð €3 B @ÔžÊâB¯N¡|0¼ãî x PÂßm¾?¨uÔ¨4„‚1~Ü|‹v£@@À"hÁ¥€££l8ü}è@5Ðj_3{Å0 e<Vq]8jJÙ)Ì5ò6Çï\œ4 Òi}Π tCü„^-jÇ<ÊÿåÑظøh¨þ^6ñ €ÀBC!$„Ž¯ÐzÈ÷»Ñ|¢y`@X&–Mˆ(¨`¸(‰d ••ÿˆð·Ô,h €¡7wV:®ÔÉOp„òB°~]–ùâ|²aIŒÕõx p†M*iC ¦˜þL€ 8Ð ‰h+§â¾íœ}ôÀ@º0&€˜! (ù|Ëä À0@à:Hbsöízð@±|Xj]{ÿö[¼4€™\šŸ²Õ"ac=ÓCHA¤"Ò7såòÈ]_æ¸À`€vCjF’Ë2逜 [ám{ T *bþ•qÔo½, 4¡œ¿óýp @CÉ¿÷ € ïÂ9>P.¤ÒÆ ë©<†öù0­F@¸ÈhQºñà€´ ¾@¢P…þ…µØÐ@9Ø Ha€(wøx@P¤\P ,3>ÈìÌĈ €È`U¥mòþ˜i{j?>ˆ@ ˆHù¿B? ©¢‘²1Ûm„eRðÊF)F;m‚«€ rt(áó€jð”’€¨b Éß;/<”„£'7Ûîg‡ô} p@W¸ÉEò1OAÏøã®øˆ 7úKBtÇæ<]ᢠ„ÜÅ”„‰Öà€`¯ý%d~;i`Ôê?¥P@c!Bú8éPê³€*Âie”žBRºó ¼@džüAœN€`&&}Ê!†9µ©@€d¡Eÿ|ç1n–T}ð@0ÀÀ ’Pi B6ß×™•p0|B¸3›lì:M¶Í•©shp€2@ÂaYù³éÿÓ€Îpˆ \¿@aÂëç@°ñT–ùçÈñBÖ__08µ@5 €þ¿Pñ2?tàÔxñaÀ>.¼/Ÿ°ˆNÁÐr  ^$GŒCç#aPuèþ ž +Ç€d°èv€?ý'` W'¾dâq sW´8à€ú€;”<*Ÿû4 W˜hˆ Äcà5m¾¼Â $c@`Àa¨‹^aÇ›üà5Þð1:ü(8èÎÐ…Ëoú웪#~°êè ""ÂG,Ÿ$¯Þ«Ì"Ább}¯¾_"Xà²|ô–N‹ Wû6‰ër8°4àiDb€5æ1GÄ1 -`¡qc€ìD'.¼ 9P Àˆ‡€|ÅC™ÀgÈ•á¬8PÆßè:ˆîõy‚„@Ùÿ?òoóabÔ8AÕæCϳd Ï`rÍ*ž¼ÈG–Ù\èN’´ÚUyð:ÌO4tO‘ÄjjÚ¤ ýN­3%9¢$ ƒ s@2¥f‡þ½ ð¸ŠO«X°½ŽQõä 6Ϭp]' W'½À? <('ø «ÞîF¡PŒç¯ç‘ àtN‚ÌY<;‰‡ ,ˆOÁDúþ°9 P(õ(.4Pæ½ÔN"èp¯a“‡¨júþGn±íÐa$ ]y€DÑFÖ"¨Æ7`7âüx2Êàhõæ²0Y„XéÇÁÁCÌ™ÕàQZ>P9Äó×p>« ª j׳ÀiŇ=x,Œ>Íà`#P’ ñp kÀ£”øU…Niöõèöc`DàèåãàµèãÌ¥Þ0@}ÙëÌ > ³–y®:C J®¼ÌÓ@•¡B!æ טÂ@ÒäadñM [ ‘…“ŵ7*£þ’€ ÷‡ Q>xb| `#¯àÀ.˜ðÄîïň¯à5oøA€pq žÜq˜Àdÿ ¯çDÀÀ,_ÀèyüŸÜwœ ÿàÂø¯î;ƒ Ô@n! ²,ÀÅšúþ à,ˆÂªë‘Àip ¸9«øq8°x¨Àgÿ#@>.¿“ ä=qŸ×^a<9Gu±i„C€|A‚‡´Ä%«À ÄCEp¸‰x|:ÔXá,lÙ„¦O"r=¹‡uÊÄ€B @Oج®l`P €B¼¤÷â` @ À'?À¹böP€€\¨è~JÐ $±gb5` #1'&ì I-´À4ÀvpÒ]A‰Nq[uÀb^é I`6€Þ{äuQ`€'à!µ 0쇶6Äà€1 š¢Ñ I‰~°èø ø"PIMÄC@BA0¢¸aAØ‘‡l:° jƒ@¡Kß>ÃÍ©¤Ë„ÀÔ IE'37FäH½°³¸  d²7;©È0`H)% Ø$póÌ€ p4\a€ˆh8lI€A¨ 8 2ÝšV€€Ò€ü>°LP ˆDÀïöt%Û1“ ˆdЖ”††äºyº )-<¢€ÆJ]¼žŽ…% Ü^jÁ ,‰ »0ú~Øœx0€Â˜œ£p€`ÿ¯€Dðó;¯’Óþ6½Âø#@BµðØ‘áÄãÀ•´OXu2ÄÖœ‡@áÿ_!`/'€ÎPÿÉàp}x!†@@X8è‹K•ÉÙU0G;"L,„L Èb'O·=biä¢`¢» ˜Vâ+mŽÛT1¯Ÿ2¬ÙŒ˜S‚¬jƒáàNpv"À ùü ªùà×´‰¦e:À8'B0–'rt¯BC"©r¹ªÍ¤q°>Í{9—*•¶:õГXŸ@GÀ W'•"NO%“5`t ›Þ"Ò”‘ÉÑ` W'Ȳ:, W' )H²<¦"À W'3•ôúÃéM™hu#ÏÞ#ËtôÊ5Hè° W'Tªdi¤e)›AU¾N¥)GŸL¶> P W74Ð äE¶÷¥ÈáfZÇÒ”ÌÒâ¦X W'¦¦THò"™Òu9¤œ2"‘›d{‡V}éGFTµ3""£š’98 W'E)#“²”¦È²=%)YÖJl¥$ry` W'3÷¤JO&ÂʤNG–[ pˆ \¿@aÂëç@°ñT–ùçÈñBÖ__08µ@5 €þ¿Pñ2?tàÔxñaÀ>.¼/Ÿ°ˆNÁÐr  ^$GŒCç#aPuèþ ž +Ç€d°èv€?ý'` W'¾dâq sW´8à€ú€;”<*Ÿû4 W˜hˆ Äcà5m¾¼Â $c@`Àa¨‹^aÇ›üà5Þð1:ü(8èÎÐ…Ëoú웪#~°êè ""ÂG,Ÿ$¯Þ«Ì"Ább}¯¾_"Xà²|ô–N‹ Wû6‰ër8°4àiDb€5æ1GÄ1 -`¡qc€ìD'.¼ 9P Àˆ‡€|ÅC™ÀgÈ•á¬8PÆßè:ˆîõy‚„@Ùÿ?òoóabÔ8AÕæCϳd Ï`rÍ*ž¼ÈG–Ù\èN’´ÚUyð:ÌO4tO‘ÄjjÚ¤ ýN­3%9¢$ ƒ s@2¥f‡þ½ ð¸ŠO«X°½ŽQõä 6Ϭp]' W'½À? <('ø «ÞîF¡PŒç¯ç‘ àtN‚ÌY<;‰‡ ,ˆOÁDúþ°9 P(õ(.4Pæ½ÔN"èp¯a“‡¨júþGn±íÐa$ ]y€DÑFÖ"¨Æ7`7âüx2Êàhõæ²0Y„XéÇÁÁCÌ™ÕàQZ>P9Äó×p>« ª j׳ÀiŇ=x,Œ>Íà`#P’ ñp kÀ£”øU…Niöõèöc`DàèåãàµèãÌ¥Þ0@}ÙëÌ > ³–y®:C J®¼ÌÓ@•¡B!æ טÂ@ÒäadñM [ ‘…“ŵ7*£þ’€ ÷‡ Q>xb| `#¯àÀ.˜ðÄîïň¯à5oøA€pq žÜq˜Àdÿ ¯çDÀÀ,_ÀèyüŸÜwœ ÿàÂø¯î;ƒ Ô@n! ²,ÀÅšúþ à,ˆÂªë‘Àip ¸9«øq8°x¨Àgÿ#@>.¿“ ä=qŸ×^a<9Gu±i„C€|A‚‡´Ä%«À ÄCEp¸‰x|:ÔXá,lÙ„¦O"r=¹‡uÊÄŽcä-À_0ÚãŽ`!^a ÈjN£)–¹¸É:¥1‡Š2¼Ä)jXþ˜SPñWűxHãŒ0*¼Ã…¸å49v;“Œ’N#s+ߟ«l{øT¼O<9  þÛlëÌ${LI;p¥Ú¶8óLe‘Y]é[n–ÿ8êþØœx0€Â˜œ£p€`ÿ¯€Dðó;¯’Óþ6½Âø#@BµðØ‘áÄãÀ•´OXu2ÄÖœ‡@áÿ_!`/'€ÎPÿÉàp}x!†@@X8è‹K•ÉÙUâ!ö°¡î~rÁ˜¼Â(š@že“èƒ$ XYõ¹€rGqtÞÚîÃÞÅó5‹‚øU®–.×$w^ǬÈ2IäJõ©ƒóp5 UŽ<ŸAf™f¾"CÝ{Wˆ(Þã¡ÒE ùü ªùà×´‰¦e:À8'B0–'ru€>õ^`cÿˆà×ÿnëëSŸÛ¹Ç[“Ï0IÄKS… V'CG¶êSí…»`WÐãÈ„ê\®j³ioö€p±Æß;˜ÕÑŸ`Ù²hH}×fdõP‘TÇL#‡št8ÜZóÂhpò•à:t’xú9Ú¼xà;AGŸ½€Ê8ý^%‰¢p:ÍJu)uѧ0í©n,å@ W'•"NO%“5iˆŸ!løê'±ÉãÏ ¯t·äy 9ä fµžÍ…V¦e,ìöp[hšÜùìÑ—c °±`?¯0õ1Ï µ <à9{è,yZxjé` W'iŽŽøt° +lÈQõÏç´p¡dx_ßÒ‰ãŽ'רŸDXë/ù&²=yˆáøœâdõ¨:ø£€ì“¨áÄp6.¼ÌtƒY½^ЃëÄ1Õ”ï$óÂä¿Pqãé` W' )H²<¦Þ'(|8ÄN,<Ñ„ðWÂ×u 5µŠu$>^`p,v“ÇûXë>ÖäqÕæ ‹{z5XøšB &¨ ÎžÌ?¦Y¢›;!jw?`Õd R \±k‹/¿ü‡F(t¡ŠÝØïK W'3•ôúÃéM™hu#ÏÞ7Ž‹2åYƒÛ(‰^bE»BaÞÅ,Ÿ„Â\Ÿ^c›œu˜ó¤?žm,ŸbIõæf͆üÎî­HD Ð*‚a0®”§³À`€–ˆ204š§Bz=c„@;Ð ˆ`1& ˜LBKJ~;Ä@PšPB?9|â°ðê?šˆ †ä'†Ð~kÏ>¸  H){m@@R2ö_«º@ €éÙÃFa¼p«° A¬ (¤#roFÔ®;RnX W'Tªdi¤e)›Ç`:ökxî W˜ )PµQÄXvãì+ÖF ŽƒÀ?B¤!( ÿ°ÐaH Íœœ@( ÀÄ(èFÅ’‰l¸†(’ih ÙË/çÈ^¢crO?n¢5Lj4BåáV@(b`³¥¥`&¸# „L(­‡e…Ú`Ð …b€t Û3ì°ºmcS-¤Ø W74Ð äE¶÷¥ÈáfZÇÒ”ÌÒâ¦X W'¦¦THò"™Òu9¤œ2"‘›d{‡V}éGFTµ3""£š’98 W'E)#“²”¦È²=%)YÖJl¥$ry` W'3÷¤JO&ÂʤNG–S;9 tèì8]g@°ñSgœx#ÄU X }fǨ¤×P‰‘ø³ £Çˆp;ðáu‹ÁgÁAl"“°t¨TH‡ÎF êÐáаà9²£À2Xt;@€þp vÌœN"ÀDj´8à€ú€;Í¢zÜŽ, 8ÚQ€O^8Ypû€¶08êÀÈ°˜•àø< úê¤%Ï.¯!G0w[…“í8<8ë¯X8ÿаdÂbqp:¼J ÀDà×^O €§GÀú˜öðØŒØdb(qƒ€[p* #TÂ+ˆòˆ ÀÌÌø#Ô ‰á Âð¸•0ÈãX@n°ŽtD€jÀ‰Ÿ(‚Di€d|`x ÃÃàWªaÑË" ])`4|àj€T}LX2ǯ—!f`Éãß™G.¦FÚØp]ÙKô¥/‡¸ &²8‹z ^}È6(@ dØP©ÏWjƒ BÜÚun BÄÈà {Á‡þ¸|ü9¯q£  @•À?#"@4'ªð؃ `` ÈÑ^$nd°ñøq(,(ÑK @.R…Õâ@f8ŸÀÁüyÊ•x ‰áXˆŠðføÊð"EÐâ‡KÀBê¹|ŽÐæʇÎÈãuLut>" ú„.á`2€=©‚€|㎀€ Jˆñ l@gª¸ Ëp8a⡬"¦0ˆl<<+¬w–Ðñ!gˆ€ŽÕL"TnO±b —ÝfÉaÕD·8ar$¾l À¾¡OBÀ7©†„ßËl)èx€7c亘³-o­Klê%oÍ_]S1ǽê±Ã”@‡-ˆðòG {dc@]^ ñ¨€_^ tÁ^'K'€Ð/W€xŒ>à@á0€<€j+À7F”FŒAÐáuì~ÑãLò4b8Qª¸l+ÊÌÀ50eCˆ¡k'àØ4øÁ S€W”µˆ°ƒàÍLbˆ$c ZÀBâ"Ç؈N]@ Â•ÌˆxÀlT9œpü‰PƒÖ(ãaÏôDwú¦ güDü@È¿Í…‹Pá`TÈyáölyìY¢…SÔÈG–Ù\èN’´ÚUL‡Ðàby£¢|ˆö#STYü|Þ£ÉÕ2Sš"Aâ24*VhêˆPx\E'Õ¬X ÞÇ(ú’€Û>±Átà v¸ä… dÿ•^îF¡PŒç¯<ˆo¢tbÉáÜL8@adB~ '×…,BA” =CÇ 9«¨œEÐà!V8z€6 gÿ¯#Ž·Øö€è°’†®¦EXˆ Ý€Üx‹ñàÉÿ+ ÔàF 0‹8ø8(y€3: QZ>P9Ę¾¸ðYPX V¸žN,9ê #³xØÔ$ˆ<\ZG(ð« œÓíêƒÅ¨ 4m.;œÄZ<ïT³öFû1° ¢ptrñŠðÚ£2—xÁô;g©GÁVrÏ5ÇH`ãd UÔÌÓ@•¡B!æ ÔÆ—# 'ŠiØTŒ,ž-©¸±T ôà ¼8R‰ðÃÀÛàc}xp ‡Áf¼ñ;»ñb+Àj ßðƒà â0<¸ã1€Éþ^t@páðœÁAÕàt<þO€î;€Îða| W¸î 3Q¸†‚ȳh ëÁü‘A]b`ò8 n75xq8°x¨Àgÿ#@>.¼ 舄þº˜OQÝlA€Zp¡à`¡Ämq j@8ˆ†Šáq ðøu ppù„¢L;¨V |s!nøy†×s ˜hòÚ‡¨Êe\öî €ú QÀt}sp’uJceLB–¥€é…5|Pë„€þ8êa€Ürš»ÉÆI'¹•ŒoÏÕ óÀ°ñ<ðæ€ öÛg^a#Ú`‚IÛ….ձǚc,ŠÊïJÛp4·øÁÇW€¶' 0¦'(ç\ ?ë:.‰áæwY(?àójá|  !ÚÀ`G‡T™à3:™bk!Ð8ÖBÀ^Oœ¡ÿ“Ààú‚`€d„Ñ5ƒŽˆ°ÑûØP÷?¹`ÌS >iy”O¢ 5agÔ>BÅà¤.îÃÞÅ™¬\­r.×$wP6ArIäJõ0~n¤ ±Ç“è,Ó,×ÄH{¯jˆ(Þã¡ÒE È¿åVDxµiLÊ u€pN„a,NäêøàUæ?ñPX>­·uõ©ÏíÜã­Éç˜$Šâ%©Â‡…«¡£Ûu)öÂÝ°«C"¤–äd$DÚÂÇ|îcTÄ|`»0úu3'ª„Š ¦:`à9<Ó¡ÆàÔÄ0š<…ex$ž>Žv¨ñÀv‚> {”qú¢Xš'ìÑAÔ§R—SNaÛRÜYÊ€ pdDù gÇQ=ˆöOx]@Ý-ùBÎyY­g³aAÕ3|¦ ¶°à»‚Û@ÔùìÑ—c °±`?©‡¨ÙŒn}¬èQçËÜ€wA`Êà£}8 {·û/ý°¾Õ ´˜¿a€“ú‚ V êÅ•ø¤îE•ÇSáúGP¥åú ò€ïþÂü€€ì˜[êpÁâÃ:0bR³Ýä @¼¼¢nHJøÿGò `@«ÐòPa %7Äž–ç(ÿr2z ÊÉ!¡/²wá[ßcT 'ÑeSÔÎï0@RLÅ€íŸmÝ<}适0h ²C@`£øÆÿ'Þ`` \CÐL‹s¶K·­Gà)l"#€ ÈEt'¥ﻹìw¬@ h RŽ„î˼ì0!ˆ NJŸ}'Oƒ"r‡ÃˆüDâÃÀOõ@ákƒº€…šÚÅ:Ž’©ÀF@±ÚOíc¬û[IÇTÄcÏoF«[eQ® ÈZÏ Àª°;cµhTG'Óe0pU8 ?ˆÃq00²øG÷¯ Ð4“ ܳ²M̼èé1` ? _'kè :C !“@ª9,y˸Aè@À€=G/ãà¯w‚¡ &uñN÷8~£õ€®¤° @©a'¹¢mè(°Ô›ßÕ€1+à¥ù¾€#t¡×|   €‘ŠÊÈÂŒ¾°!¥€Ä)åõôú0BlŸ#÷¢i p®0€R¸ ÉJA¬|àà0Y c!˜üÍk€§€Ç‰Ie—\Œ IxF>´„–BîþÈ)4D4üßhÍdöjÂa7“ ß± &Ï’Œ½lL!–bnèOW£ùè +‚Q  :@}†fþð€3(ÑðJûþßß]À¤ÐÀ‚{ A¢ï—‚<Pˆã_b›_J Ðh!”—ݱï;d€–˜¹´ô¶Ìüv?TTÑ €ì˜`ÎM&—ŠB óoÕ—ýÃÿÛW?FèÁ] ;ˆaJvé_ »Àv@ °( @@ÜŸÒµ¯¯~àæM8ɨ@³í_í³õ¯Ü@à辄’’W[²þ0,>¨þhÄ'8v&“UÔK[àýoÀìØ4†JÉ&gû÷ßfÿ‘ï³€‚À 1!¥8)û§òO Û@¨ R€_ú å8ð?Öä~.ò€4"¸fá½)OÇ÷PqÞ8mÀ € ÒR@¨bFòJ¶;¹@€ @3)€Àe'%[·qÇûô8 O€fL Å€ì°ôò áÁˆ&ˆ`; &´¥þWÿ„˜Ü*é-h Ä“HIHFÜ z?”îô·‚¨@ ÀLR:F§!÷=Cœƒ`½€* ÐjC Ì”vòÝôÇðúRpàTø %.ݼmÿ‘EpÔ¡ÿöÁôl˜R1ûüzí`' ‚»:?ÜUÐ `i˜¿‹cÍ]Ð À ÃK- _ž>Ì ƒŸÞh @6@ᘰÝÒGå  rOC¹!@ˆ—Á#ÌàvöœÄ‡’ä¿VvÏq4ðÈúæ,À`“ŸþÆ€l1Ü}  f€¯mÐx«ÚðÐþä¾Rð5À¨`j7ž>8í´É €”L ýŸ³¯÷£ðÀ5!„ݽXhj …rÒv×| € x PRIns®ã€ìé&€>Åä­–l®à0(²À’?½`°E€(ÄÔ²ŠÉW3ãªbE»BaÞÅ,Ÿ„Â\ŸSÜã¬|Ç qüóhñdûO©™°® #f)…‘áíùby:¦BÔq@rBŽ8ƒCóÉP³(s‘N°¢uQ võ¬IæÒÍ µà6ïQEpY ?ˆPK -º‚÷׶ à€ßÀ¨j PIËZït PÜC¿ûÿ˜K¨Œ×0|Øò‹ýžÇt€€4À ‹+gJŸ˜ó¨þÆ^èšL¥GÍý¤˜gy@@¢0²q oú`ûÑ€?0Ùš-óq×Ê.b/Ò9-co­Z¸`Ä°,“ùŸQÀ%&€éŸ„D É T¤¡)w\M|C+¯uLBJ=’t¤¤nÈü}²@b´ g±ÍFI¤4–Ÿ'ÂiÐÒ€€™É¡¨C:õä!ÌÚ¼éNÆÿGÆŒ”€Ä31éF|¸À¡`P°I¥#á ¾† `4† Æ=ó @1»€dà„5t•‚°«è¼0ÀÒðb>~’0 o›@ CÃS»d(>%èAˆ1РU7ÅdXÆNò:ÀƒÞy?#ÎÛþ}8 € Hx ! Cí¹{7S,Û¼  ¸’ƒHC~x‰í¨ý  TA à!¨A5ߤÑ8Ä^¼h8 @5&¥$¾¿Í2¬2@BY 2hH Rk›m3“~Ýk¾,@>0a(¤)«OÿÑ‚Ë 1Û¿§ (Ê÷, À0RiAŒ…‹Öà€~PB97X±TÀ€è q CLÃã#ÑúÀЀ› ”5^ó€Ð„$ @tR²QÄ·ÃîÐ`€`XNB¿ÁW01Ñ!™#s{@| €`MÀaÝf,¯Gñ @r~”: ½;Œ|ãðëÊÞä"ðbJQ÷B2ÙÖnànðü½Š%º™Ã¯´ @)À rjFq½(ϨÇûeö›€Ä…¸è ¶€'C€ Ô!-„Ý ‚n!œK~ãíâK×8À€'Ä¡¨ß9Ûg£óÈ-ชÐ¥$°$fvr5Øx818iy¬&  €† /ìùºñð’aÙà €"¼á5¤„’ЄîèÎpª>Ø ghM- lo»à!À†Q5?î¼h€_’J,¤"Ý€ „ tðŽÿñ>ÈWl2ò¨¼¢1Q(èO3æäñÔ}âɉG™9;Ù€€éÄ¥V€ÜßÙ¡#uå€è â2q´lýä\²ÐÓ8o:ÆQ4$Ò™¿ÆAiÈÏ0 @bbR”ìÛõÑòð„Mù¹—›0 ’MyÑòÏÁW@ @ „¥6ÇëŽL A0¬„µÒA¤®w}Ãï¦   È@@bC&!ºþOÀ3©‚• U,E‡n>½L±Š³#QX ˜€ôn#8ªf)^=þÓ›œÀhñ®aM(‚Ph÷<è(ðmY$ñÂêd{Ê"‹pŽUŽ3H¢8‡/œäªÐ| Ü”dîŸ|ßQü5Aèqe „‚ÆîrqG*ôଠ€ Ã@,ÈFÿœ:ð €jBȘÒjP±¿g½` W‚© d"`h`Æûm±}ÚàÀ  Ã@©D  I[ìŸÝ¶v ½@ÓxÀ0 $†¼„ßämŸö#Qû@@×0(ä¤ d7æºà”VJvkž )Ô4°—ýÔÙ °*[á÷Ì€0&í$r eßN¼š¤ÓˆX!èÙ$²Æl}΂À3!”ï÷­@¸° É¥a‹ÿc¯ @€ŽX Èa%3õÖ€`È@ €`Zyy#›fL€†Ü!›”îœGÍÀ@9Á„ÀÒÊ3¡³(yê>ñàP™€¡0 ÄfÈFÛc«À €€€01A-³ý˜Ë?í}P0e€1Ô²oÿ£'Œ ß&`À ÀLÛdôa¬@û3ã„N@€j@0!'†n‚³‡­ØËŸ}8 kÀT¡¤Ûüµß.€ :Ae”€ý¸ ”G£•ÀÀ1@À€;©HÌ„uŽ}È7T)–à*‚“Ñú9˜Û}t€`@NB&JÄ:î.­Gô@@€~ ÒЀ*L êIx¤qB—}<5A@†ä †¡!©îžkÜ@“1,š¨Êåô.ö ;/À¯H×]ñ`€n@\1œfK²×ª/÷£…‰ ;/üýâXâŒHU„¸Ä"iX¼ûüê2áAÔàdvP%÷=Øü>å€2,¢’ŽÉùì§1Gë‹!$®½B—µ€B€`^CfþØVÄÂnQ¶DÀ+ˆe A¸è^ô|@@IA€/8BJ4´ 7_0@\Á€@~¤ èG-ÎÃŒ|¯«Ÿ) @`K )8j“4|  £@„¬L+ì¶u¾ˆ(À€œYÀÄò·ýþý{©•HfÞ¤L @è0Q( ÌÛ#6¿ÿÿõÿßñ~â`€:!f“³õu‚æ&’ùHßwn«0ÃPL JRva4²º¸uÀ`!¸´X_?(ýh@2àbùhØöºà@4Äħ¼¸ d5 ON‹Ò€-Ú ,`ûYyÓx€Zx XwNÜVG¬5;" äÔ³T€d †¿†#÷¨éÈ˸@b¤9iÈQ´z1_ÓrÀ@à1&£'“ß Á¼†7„¨TÀ+)Ùíxˆ±€7Gø^£é 4²¹µ@0¼4˜^_2ÎM*!£±+…@ K-[ŸŒŽWËhð )Ò”|Üu4 À“Kè_0ÛÍÒMÐHíîø ",X§Gß±—žTn (·Ï¶Gê½à@Ê!€À4š00“™¦™)Žn `2{®€Ø²…ãÍ2 ©„A09@.hGÇßfŠb……ÕÑrW bpxpë"®@½Éâ*Œ<ÿáë 8±¤m€[¨ ãÝÈú<*ì ?‡Ö€+ÐÔBÊÙûˆµTa|0´'¾˜iX4¤•ÎNû‡Ñû@@€‡†£†nÇ=é@B àT÷¥.I.ùxP ;ßô!ž¥[„5Æxýy€ °ÀP•ÓÑÙ¾îר¤J~Icç}ñô~Ä H†M!†dG^ÀÞ$ È€@ÒB)¿oó:ÙGŽ¨hT[|„'㔫5Ò^à1[ÉCz oÖ.`À@+0¤Æd†˜û*cø}Û Z I@|¤¡YøþG¸–à@¾m€€(&”¬“óŸ›Y€4&à(ˆ‹IÈ CˆŽuè0@—дfKî²Ò¦a÷ªJ1DÞ³o›0 $„0²eðÒûäv±Ü*÷à @€B I'™ïˆð Pàƒ2QÂ60pµ'w£p€x ’º÷ÖÁ|X59ÀíÔàì¢Ö„Óh´¤›˜†_’XIJó´÷ûQÖôº@N”þ—ÿúÐ#Àª0Ç]XXyŠIìw¹ €b€!zC HŽé‰óØ@` =%¡aìd7þ†` ƒH`1ÒJCñ¨ÎÎûáÀ€¬è° €uËFÉJ20 ¶Ü{Ð@~¾`À(M&+ìLJŽ2ù˜ p („d FV;v×Ö‚ˆR`ЀXLHÝ‹ÿü(ÒVm1ü>¸ZzMÛ±äj™À3˜d$”*öú@:N(†RRvNþÔX/§çuÝàâid>ŽŽ}ä€ À$›ËÄ¥,˨M>Y5ò .À@T¤!w€LŒ:Bz ã¨ú@KC#Ü@2Ô“r’³:Áp04âÊtf¸@ >ˆ+l5—Ú €ó"è 0@Ð%•È@P·üw;£ PP„Â9®Û?i€¨0Ww+gµž–˜´î½df“Ò‚nÿ»ô{ÀN@ïÊÈßÕ€€pQ1?↎Ṳb{lÊJü¤ ­)Âý€ ‡Ý;)¬ÈFFÛ+jRiOO] Ù4)žžNšfDå9¢N¦Üã¬8¤,z‰æتƒ¤ÕP°õ/ð ÀåQ…ž}.'“£øû=@B¦AÁðú6”w`ð9f*¢s(Fn'’a sH“d"€vL,˜œ¢óy‡»QüÌ.Á`0Ha7LÅâݾÎÄ;Þð3$<44`ôöb™n+_û|¹Àvà æ&€è„X’ámq(  à 6B9-ûª}Ñýä0@ˆ¼0´ô€˜´ o'ÄAk@€ý!¹€L_@ÖÀ±÷Â@¨ &ˆà BVëbI€€nˆ…™³¹Øaq (€5Å7 Kœz„Á*ì`À€&p–P!¤õîŽ{kÈ‚ JpÉ0¤ ®¿³aáFµá@t`È€ E-Ô…‘êŠ (31HB0íšéf À£”„ðÍß/¿a:26Ñë$ €tL)•™öÛ8òŽ”½ 4 —Ë O-)ïÿ‘ÆH8Ä àœºàA#Žá¹ÖjFJvW¤0 T™†Zvôn` ˆ@&ÁrR‘ÿþe†–Ƨôñþ$Œ(@¥Ãùú UY¸àg¡&ÁDz/ú =ð‘§kQ«â¬(€JP!Îã”G‘™YTqT`£éÀÚù8ˆ \šèì8]>t;?ç€ Ç@ˆ¿Í@DD*~  5â`2€ø€oàsÈ€¸{`Ø À8°`ÿ¿‰uÌŸàÓÐ:ü:< SÇ€d°èv€?ý'` W'šS'ˆ°šþЮ 7`ÎOäR éúòÀXûÿΰ¾ ßñ,‹`àïò¨0ÿÄê{ÉÁ@Bø2ÁÀjŸÈàˆŽÞŽ `ˆÓéÁWó2x#ìY€ØÐèÀlûù»4> [ßÃYÞžaÇ›üà5Þø`àn¢ì¿ïm$àÖ˜H â$p«Ö€gÿ¸Ÿ`Ý+“¢À WëøYárDX2Âoü äÀ0 ¬ŸÀSøþè>º€i sÇ‹¿¿Xö&X0Ø žD÷ÿƒ >ØÀlˆ ‘`ßþ àFà€ÒÔ:ö€…àä}ü ËÁö:»ùƒüì¢|6)áO þG€}À<§˜dq¬ 7X G:"Àµü @6 @#á@XŠ Ýýo`GÀ âí`QÄ[²™®ž`àÜxÖ@=v@;·¿ŠðêÜó˜xuüœÐ `0t±â)\žX Wëh Udû¿üoÁÏþ?0 €?€~ÄKsnFˆ$ ÿÁƒü`°n@/v:þ~ b8r–}ýØ À…ƒGù:0x¯ÿ#ÁãαK@ìÂéî_#´9…€²ÿ x "1€3 ó@ˆ‚€>„á €„øX  oà`½¸üŸvE ‡‡êz¸ Ëp8a⡬"þfKƒÀ8€à ­`‘`ç”ð3טà¬ö¨Ÿ²àD‰×óð¹7ô` «>Á›þ8XòÇ׈œÐ°â0CF_€èñÐ A§þ' yƒŒQñŒdKXè\DXà; ˧A„*˜ð€Ø¨s8 àùþ5ž"<}ƒ0 ©æ güDü@È¿Í…‹Pá`_Ð>͈, غóì!lp\ ßââuqkõý\O“'Ý®\œ}ÓÛš€Âuš@0ÝX8€ØUü4ÿتM€ W'énÛŽúÝ=à>äjxÀ.{ÿÿ“ìÎÿ`€l×þK°raT÷Q8‹¡ÀBžÃ'PÔ ÿ÷ÿœF°v¸œ@îþf:€~Å‹Oû¸8_Ì:eƒH u‘G€mbÀ÷ñÿ€}Ö 6°mÅßÀÙw7ú¬{`Ætð(Y}›ÀÀF¡$Aâà×r°Â„Z …Äúz¢4$дp¸îshó½z Ž5`D‹Î"Àc¯í@?€<„…3YûyÁ—ü|E0ŸÅ ºñê'D[ú¢{ÊQ'°TêM€ ÷¹…â%€ü…=?€w¸|` À»¿"þü((ÿæÀáþ*Á·þŸÎˆ<>€3€X(:ÿû`v Ÿö<¿ü€Ýv$8›ÀÄb¯ÿuÙ<ì ñœ )¯ïàöG8wx@iü 舄þ»ù˜8ÿØàâ!Ûuƒ8 Å€}O€p Ââ$áð 騱ÂXس'LÏÌÊU50î XñÌ`…¸ áæ\qÌ/àaà4»4‘Á€Àjûø°0ÿÀÆט(Ò\O€.]ü ?ò@ÑÒ`¸ nÝk¤à þ³mÔ& r:¶±{ƒ'ýÿ€¶¨…~EU¬<¿ÃP7ÝþG‹°`¿¸¡ãˆ±ð¿Ãïò ÖÑ0«)d|‡@áÿ}9`ÂA°âÉôðC  €0€: °qÑ“É9:ÒÄ{/Y 3¥ü ÀÇÿÉ jÂϯ²¼N¥þã ç­KaR¯¹œO°ÙºÀwO6Q½ÇC¤Š6 |‹þPU>Dx·ö›dB pQÖ`7ÿØ4‘îÀ^F¯ãƒ„¡' Ü€)÷ú8‚¼±ÇÑ`?§ÐãÈ„é“všÍ¶e,šb À€`90"…WfwüÄY`?Œ\{Ø  `kî9‰¸Å§FœÃ¶¥¸³• W'•JåR¶K'K§ˆŸwGýƒ¸ üC€^ ‘^î¸où /¸Àיɘ‰®høˆ`2€Ýó˜£?àX €6²|bÿ€å4ðÕÒ8 W'2!ÑÑ߃öey€uL `6À>ˆ#"Áìvxªm¨ŸDXë/ù&²=y˜y;B¼ ?ñÆÃÅG+‡/æc p«X¸±êuüs`€qaÆRl W' )H¸íÊoI"dp´Ûøœb,,ñÐ1ÿßhÌqô‰ònϱ5¦aÑs  ‘,EýØ·–8ÓO¤Ø W'3«u;¬:LiÅÔ ‚ L¼êúQ§‡W™ŸDðº[Wý‡Ä{ªÝB4qÁÖ _óŠx9óÖ¦JŽ3´“]üàÏÿDxX°¥W™³ çÒÕ E°°âxuÒÀ¹< Ç€¶ìááo{d»ãx·36¶8»èv°a¿˜8w äéÈ'°Ô; 'W ( bÿ4ØðM8};6Ìd W'TªÀÐ&êߎ‡oXF%FؘáàÒì;¯1 =Þ@è/x8y:ƒ®¼ÈÅ`ôE°ðk¡g“¤©Èμ Ž÷Ç ª… jó7ñæ µ‹’©k£+Ìõ‰ÇÀlèVŽ¨/r#Ý<¨b.€Õæ¶@¨‰o€Ùò€|kÌäHì`6;€Y @ìãëÁÔ@×ÿ2»ø ®Ã‰æ¨ÕÕ@ W75RäE™÷¤Yáó€?O(ü{I0 I˜†LICôo·‘3äÎÉÎ^b }Aãä #˜䃡ÒómÌzð$ñçoäw> £ õæ¶1`ÛñqOAÑÆ^y¦ÙQ² f?W˜"8õ˜?Ü!ÅÄhðÕx,9•r(t*–w ±Är}'ë£ lQæÀÏþObÇb0yÕèbÀ?ˆ¤ø€H gpx’z¤Ùµ^‚x„Ê€høðõîðÀ W'”¦F“«`y/JS:N§<æDV€ø3æü%BjŽ2<ǯ2³A³þGæQtfZ€9¯ƒ‚¿®Æßµy’íc©‡Òè<¿á ãÇVêßÛ‰<|ƒa‡×jÔÈQU…Ö;>!…PözF},Ì}$AVÜOœ8>þÀ¨,˜@5µ8š½øàÄpÌ@P{Š€fhêðP !1àl> Y8ëø¦|D#lˆ€ W'E)#“²”§xˆ¶³ìÛR„טzðöµ™F[œey•‡P’5c•¥˜A¡çpçzñ-@È=L*@·²q®¼Jöú4pêÓÒÁxŸk>`RúM…Ïdò-€Ðt;?ç€ Ç@ˆ¿Í@DD*~  5â`2€ø€oàsÈ€¸{`Ø À8°`ÿ¿‰uÌŸàÓÐ:ü:< SÇ€d°èv€?ý'` W'šS'ˆ°šþЮ 7`ÎOäR éúòÀXûÿΰ¾ ßñ,‹`àïò¨0ÿÄê{ÉÁ@Bø2ÁÀjŸÈàˆŽÞŽ `ˆÓéÁWó2x#ìY€ØÐèÀlûù»4> [ßÃYÞžaÇ›üà5Þø`àn¢ì¿ïm$àÖ˜H â$p«Ö€gÿ¸Ÿ`Ý+“¢À WëøYárDX2Âoü äÀ0 ¬ŸÀSøþè>º€i sÇ‹¿¿Xö&X0Ø žD÷ÿƒ >ØÀlˆ ‘`ßþ àFà€ÒÔ:ö€…àä}ü ËÁö:»ùƒüì¢|6)áO þG€}À<§˜dq¬ 7X G:"Àµü @6 @#á@XŠ Ýýo`GÀ âí`QÄ[²™®ž`àÜxÖ@=v@;·¿ŠðêÜó˜xuüœÐ `0t±â)\žX Wëh Udû¿üoÁÏþ?0 €?€~ÄKsnFˆ$ ÿÁƒü`°n@/v:þ~ b8r–}ýØ À…ƒGù:0x¯ÿ#ÁãαK@ìÂéî_#´9…€²ÿ x "1€3 ó@ˆ‚€>„á €„øX  oà`½¸üŸvE ‡‡êz¸ Ëp8a⡬"þfKƒÀ8€à ­`‘`ç”ð3טà¬ö¨Ÿ²àD‰×óð¹7ô` «>Á›þ8XòÇ׈œÐ°â0CF_€èñÐ A§þ' yƒŒQñŒdKXè\DXà; ˧A„*˜ð€Ø¨s8 àùþ5ž"<}ƒ0 ©æ güDü@È¿Í…‹Pá`_Ð>͈, غóì!lp\ ßââuqkõý\O“'Ý®\œ}ÓÛš€Âuš@0ÝX8€ØUü4ÿتM€ W'énÛŽúÝ=à>äjxÀ.{ÿÿ“ìÎÿ`€l×þK°raT÷Q8‹¡ÀBžÃ'PÔ ÿ÷ÿœF°v¸œ@îþf:€~Å‹Oû¸8_Ì:eƒH u‘G€mbÀ÷ñÿ€}Ö 6°mÅßÀÙw7ú¬{`Ætð(Y}›ÀÀF¡$Aâà×r°Â„Z …Äúz¢4$дp¸îshó½z Ž5`D‹Î"Àc¯í@?€<„…3YûyÁ—ü|E0ŸÅ ºñê'D[ú¢{ÊQ'°TêM€ ÷¹…â%€ü…=?€w¸|` À»¿"þü((ÿæÀáþ*Á·þŸÎˆ<>€3€X(:ÿû`v Ÿö<¿ü€Ýv$8›ÀÄb¯ÿuÙ<ì ñœ )¯ïàöG8wx@iü 舄þ»ù˜8ÿØàâ!Ûuƒ8 Å€}O€p Ââ$áð 騱ÂXس'LÏÌÊU50î XñÌ`…¸ áæ\qÌ/àaà4»4‘Á€Àjûø°0ÿÀÆט(Ò\O€.]ü ?ò@ÑÒ`¸ nÝk¤à þ³mÔ& r:¶±{ƒ'ýÿ€¶¨…~EU¬<¿ÃP7ÝþG‹°`¿¸¡ãˆ±ð¿Ãïò ÖÑ0«)d|‡@áÿ}9`ÂA°âÉôðC  €0€: °qÑ“É9:ÒÄ{/Y 3¥ü ÀÇÿÉ jÂϯ²¼N¥þã ç­KaR¯¹œO°ÙºÀwO6Q½ÇC¤Š6 |‹þPU>Dx·ö›dB pQÖ`7ÿØ4‘îÀ^F¯ãƒ„¡' Ü€)÷ú8‚¼±ÇÑ`?§ÐãÈ„é“všÍ¶e,šb À€`90"…WfwüÄY`?Œ\{Ø  `kî9‰¸Å§FœÃ¶¥¸³• W'•JåR¶K'K§ˆŸwGýƒ¸ üC€^ ‘^î¸où /¸Àיɘ‰®høˆ`2€Ýó˜£?àX €6²|bÿ€å4ðÕÒ8 W'2!ÑÑ߃öey€uL `6À>ˆ#"Áìvxªm¨ŸDXë/ù&²=y˜y;B¼ ?ñÆÃÅG+‡/æc p«X¸±êuüs`€qaÆRl W' )H¸íÊoI"dp´Ûøœb,,ñÐ1ÿßhÌqô‰ònϱ5¦aÑs  ‘,EýØ·–8ÓO¤Ø W'6˜ª­|㣂Ž­ >%²ÔÖ?š<\…€zaZÇ d½yˆåf¢%ŽçBÀd:AAàW¢|ä¾<„Ÿ,\{˜(Áš¼yê`2±*MZeçP§Ôj<:¼È<ú'…ÒØ¿ì>#ØåV꣎°bÿœSÁÏžµ2Tq¤šïà÷ú#ÂÅ…*¼È=œèX—>–©,}…‡î–È¡àn<·g xÛø ØøÀлù™°°ÅØCµƒ üÁÀ¸Àcÿ'NA8}€ ØQ:½D ù¦Ç€²iÃéØ ¶`ë À W'7ॖsèÏÍ”"$‚}zó3G¯‡X\“ín¸ž»¯0JãÅÇ)RV{ˆ N܉uæ$>0RÀd¥Cº…ÐÃÙØ€lžëW·5`-c¸ðíjr)>ÈÄA¯0É*6ÄÇæ—aÜ}yˆQîòAxpûÁÃÉÔuæF+ ò-‡ƒX <ž íN@8uàdw¾8MT(SW™¿0U¬\µH;X•^`¬N>gB´p•A{‘é`uDëv>¯0°úô @tH |Ï”à;^`"@`À°ÜÈyŠ`^  0¿øpy…ßÁ]vO4 @>®¨: W75RäE¼Èžôc°6,€ àQâOÎE°Ýט•ðkÿ‡‡ÄCáðQŒ×ëÑ-ßoü•-ø“1Ëu slëÌIJ²zÌ¢!4x¼^ƒ2‡0üEÍ!gf„«¶'ÞëÌA¨<|Aäs3#°“ƒê¼ä sv>¼ ó þ¡ µGc×™Y Ùÿ#Žs(Œº3€ ­@׉ÁÆÁ_×caÏÚ¼Év±ÔÃét ßð…qã«uoíÄž>A°Ãëµjd(€ªÂëŸH¨{=#ô³0ô9Xq<pàûø8 °`ÖÔà>jôp`ã€À1Aî*™£«Á@\ €0 „Ç°ø)dã¯â˜ñŒA°"" W'Oz@Q²ò¼õæ _0•ÔòMüñLàD‹X€ý/x値W™‹uC”p š¹L>Äp ®¼ÍnþI­B,,Žö½× Š $üñö±Î ¿â$9Xƒfˆ¥Þ"-¬À»6Ô¡5æ ^…¼=­fQ–ç^eaÔ$XåifhyÜ9Þ¼KPòS -ìœA믇ýŸþ#Ü:´Ç4°^'ÚϧXÔ¾“FasÙ<‹`4l16*¼™: ¿£ŽýÙ>À—óþˆàrÍ UüS€5ü>ÌP  W'M²!ð€ð+H ŠPy§Ò: ®ÀÄ©L•<²Z½ñÇ€×,RG3“Á”Bˆ>„Ø÷'Êó1ÂEgÊ£Ô°h(ã̼å™ÁˆØwê¼s9Í…õ…ÁT¶ñ(9R±:Ü*8:¼¤©š±`v–z]œ=ü ò#Î>ˆÄ`Ùò¸ì²½Šà™ÄI@-xÜeü ‡£â0|¡Æt€1ô°¸‹S˜ ø})H‹”¥".R”ˆ¹JR"å(üu".R”ˆ¹JSïâ.RÚâ.R™ér”§ÿD\£íý>þ6xÙì Ôšn„Ó¡0Ø|²76Ônjo¼Û'xoãæŸFÆë¢;Ò"å)H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JR" ø})H‹”¥".R”ˆ¹JR"å(7ccËFˆ±H¤5Îö€ `]Ø4š„|?è‹ÍK` @à {C+ðë9ȈyÐŽ¢.ºM€NÀúñ€¡€Mq´˜ì™ù%z!”ž¯‚â,R;D—¢Ø£j Ô¡¢ãj Ô}GÑj Ô}H‹©JD\¥)söÔéU#ÐñÃ}ãÑ÷¢xÏ)JD\¥)r”¤EÊR‘)JD@ ø})H‹”¢Ôˆ¹ËÅgþ¶º ^``€…! `  KˆGñÈ i€4i¸`'&ñ(Ä[¢¼%À €d HY”ãsb}÷0@¡@`€3Ì Ù %ò93„8àžeëÀ Á,3@¤½€€œ1æn^ì±Áqù¼x @0‚Xá£1!$c;ƒG7sÕ@) @¦®Ð gÿ˜[öVëâoÒÀÀ€!Ä3€ìødÞZsà†£|æ¡Pÿ¯‹( pÐÐì´¤½Ê_J~Ù¹é;9 0² A€1B Ia¤ÎZ„ü°§¾¤@€‰¤2À0(š·e«7<óøœ×É À ˜ŽQLŒ?lÌ.ú V‚ñ`†Ð)ÒŽ5ÂKš"þŒ Aà K(4U.ZÂ_6ì­Ó˜:ò@€h ààrlQÓЀžâM º @Ž(šª Ä.‡-Ö€£µäAh"t¢0²1€HÿsÍÌ-ÜØ‹` ôJÐ,t€<ØÎŒ‘¿)±íÿÚPÀPh rso+ü|à,AÑ4 ËÐ0`ÐN¸¢Ÿ¨ÖCóï¿0 ¤ ðà1³Y OeÇD_”@ @”ž„@Ò_ûmÒ€ð?p< ° k€fB! Ø7”±»ìÿ3óëïÀ1ØÀ;á E¼ð 0“@4¼D¤üÐr[ž¡ñù„Ð j‚@B`à:ÃPZ²ÙNE®8 eôtwvº €*RPpÀ cù0o~éqŽiª¼ø`€h ˆBÿ^"Ì0#1 ®'…Ø€<ˆa€' ü¨4K^ÀÀ@¾ Fáw€h Z€`¤tÃPVÃþÖ@Ê*&4 O)9ò7Í–pÿ{à@¦ ` RÃDÔ¡+oÈÛëŒP€ €–„¶çþe怈À¬M( )ÀÆKÿù˜P]üë…‚Àbdâ ¡€L·/pÅ÷oµP@ÈF”§€—–,ƒÀ@ÁNVXÓøüŸŽ»‚3å[ÌH >N‡À!Yþ€ ^€0ϱ@T3œñ«±€dÔ@ç - ï¹@p B U8¤üû¼ 0‚z@ 0¢ ÿ>ù¬iêFd0‰ )$´lê]Þ €ºà$ †tlê_¿ ’ô­pü02E¡;¾sê½£•þù¾½°ÐÄ“Ðœßv÷)Gj<çr”¤EÊ6¥".Sÿ½(“¢.o½#»xD\¥)r”¤EÊR‘ ø})H‹Ÿ?¥=".Û{ÚxrÀ`àÊAcɉÙóïþìrïí{@€E !@¢he”R GÛ$ôÿŒÛž%Qú5@r` À©5+å–ŸùËê"]2ɉIm”÷.€5 À!!”B;'ì.¨‚`T;$ ‘b/Ï‚,à:ܤ¥Ò‡l{ü&üô€€TPÀX‡Šåd3|{°óﱂ˜  ð`!$Ä–4´2”ê‚oƒìà@4*@;/! 6Gå>ÝjøÅD_*¼È`À»€VBGOß Û*ô€š à$šB× Ü¯ðÑ«ìF»  ¤Òøh ÀÇÿ}‰j ~0˜À … ²SŒû±)Ø>Æp€:(” Ä‡›z @.À–€À“qx! -c÷a!÷šTà“ 1 %¡ Èÿ>¢.` (𠨋@ÔC€?¾î ÄÀ €€f3!\·ß¯7àß!'Èá à1 (®‚“ÊGëéÈÿ(u÷À@€Y p#Z‰a‰W -‚Ußõ¶PsÄ_Ò@† ˜¾9ãô„À rƒPâuô€‚Òˆ’ùîù?¨EPÀ@¤ˆgÄ°ÐÑ®·ý¯¥  °pÞQhœÿš÷¹3ß΃pAx.B‰¸¼¥ÞÜ SreÈgü§¼ðP c€`rŠI4†RãR»ˆ€ h\Õ²JGãþÄXèúù¾¥`€˜R²I¨Nâêòw¹ -¸j“¹ßwÓ¹OŸR?÷”XÛ=(ƒ©r”¤EÊR‘)JD@ ø})H‹”¥".%¶q×ÕA`4ÐŽPÈ&·(¤þV}ñ¯–jMÄ —Àò? ×ßÌ5À  P‚o/Ìß©—òÅñÑô°@ÒÕ ;oßðž@@-@vÍ÷îœv~y•à É¥Àbž‡Zxîå`®p À£ä÷-afÄ_ÊÁ´˜00À'HgÉ!! ÉNc›š¬ç\ @‰ \˜À;+ÖÊÙ³(~;©|t €üa€x½‰A( ~ÌÎ’Wgü{Ð@€nB°ÀCºRŒKJœ×ç."ûÀ '@®A7’{ñçž÷h ‚xô€íÀ-/oÝIê±×P‰ šrÿO$óEÖ ™Ëãb/Ê€Ðð 9LKGÌúÉ÷`@€`ÔP·,å¹LœŽñç}a$Ò ;£ý°é €@NBÃX_"x‹øð ^‚@@ @$ $ûîWC)Ö†wëê:úH `‚q` ÀbC/–4jSÏ_~uRZÐ3†¥„úÔÈ`! C~—ñ’rÁŽýW˜ @4!€=ÌIÁŠ%¡l.é˜ €ìˆ C2 ‰KýÕ¸y—ÊTÈ`1,„£ñ¨ùOŽäè‹ð`€&8pÒRwBiÙ[6Ê^¼°à@ àÎXjvSìõ€À € p (baX¬¹loe‘®Ð ]¹`0·`Õ#$ïóm@à ™aNd¸Á` @b‚Ÿ; ç^@ `Iá%fÝJëÂí…‚@„ı``ÑÆ^ô1Áì†zZ1³óx» ' €†¥Àn“M÷”p ˆdÄ$5x]óÀ Œ'ÑEÊî¹·ò°Ð@È­€&îã•lV: )(¡;ï¿V8@ëé|3€OòÉ©a5€T5Àb»†§»›ìH@€„ bwåÅÜÀ&"òxc°¾A¾ Y‚pFÒ¹ËkÒ?&àÒÓ÷7Ðà É W§úÌ~g>àxø  ‰ˆ B²3kÇT¸˜¸EŠQE!³­ZéAƒx P'ï4¸A¥€`ŽÝH"]€@5@M8 É€[÷øËÅH Ä`d€X[dÊ:ú@†x` áÀ¶ßcŸ{@.I…€ÁIB¶vøÂ}ú ƒC ãwœ¤·¸€ €fM‰OÁŸeÓˆb €á&™~†ˆ@€€š”$¤«óñ—Õdïd øûîÍd hì d ù•›ýoH„Ò¹Þ`£ðö`P0€™Et BŽ·¿(€h²€¨a†CJpÖ_ýƒßÞ0 °À¤"‹Éßýº¸ûë Àjé7 #^,8¤â\7·Ù]$ëÆ@Ñ O:ˆoíöÃzÛŽs*,­¯Èä­¸Ù0$Ä''uUó¾¼ ÂiA¨ÉGÝça<& ÉòîúHNNT\¥(—Ú:¢å&Ä1‰Î#K¾ú2rN‹”¥"  ø})H‹”¥"/@ k€‡h¸RjR3 „ߘ×~–üðÐḴ—‹‰ ko±"üî€ ð€@1n’ñXø5|xΠûôè P€7à!n¿ãI¡©Ò €” `;Éí·Ã_}ûœ?>{΀5l@ÕÀì d'¥Z2ÛüE±Xš2ŽJNìG¹€€”Ø[ ý æ}ï쎘 %„|ÎtÉ ª6Ã=ó0@ÐÒÀNMIeGq½H»' †–€t“@÷¼@ªB’ІÃõò ðâ@LLAdÒ1ÿ¯Ú€ ˆ)@ ©{a‰¼i0B^Øù#{î@¨¸b_B¤ïÇ ŽªAP³”ë" ]2&oÀ+)BðY÷íLT°+ѱIá×8 Àv¨i[“aœëÄ€"Ð*ŽQ,Nê$+ î0 2`ó!$27uåfÊVUÒä0ÀLL)( ,o0g]ÜŒ(0…  âû}‰]ïÑ‚€ -` I¡¤$¶n¼®?^0d‚! %|Æ5P @4& 0 ˜’ÙýUë€)RC^ž[’¸Jß Ç_HB€!+©,5)ÁŽ¤~xç×ÒN =BIA™ûüqáWh8 ,†ºq@SãùÊ ¼œK (72Q’'^€Ð@)t÷~Y1'š—uäý~üø (R‚7ým¶µ€ìNø‰eï|à4°DÞ?ˬ!€8!’@¦ÜS0S]€'àÿÊ-vûà¹`Ûúh@0 9i+æ8@$0'+rÒVÉgqg¬Eą̂ð §Ä†Gß6Ë]î @2( RòŸÞ¨8BÀ O’B/ )–Ždœ~L Á䤃Æåû™ø@c0kÿ}ð€€7b‹/£ulž«ˆD@3vY­‹ÿô;¿×8 @Ç̆R ÎKR H¥BJÏ~¸xŒ¤¹à2°£¾º €hð À™‰»îÎ~¹efEá2 &“@`RI»¡?o÷"®Ïb‰:”îöQvì®Ïy§ü38ˆ–ºˆèCMtùŸEŠR’ˆ øûhâÞ!¥ŒË¡0¼kJDšœ„~¤ Àà äú c„_g_û+kô¸ _€j*‰ †þKJø}ð€@€ t€h †`ݘ1-Ÿïÿß*ý œÉ`Ò_ëÿò|E€D$ÀbVHÄ{å@€bˆôÈ…„ºRSv8åÛê€ÀUÀ”’ÌN'{äà€J  쀟 ¬О_ëìÊ?:"þИ…€HB Áã3Ú, €LF‘e“ ,¼—³ü*ÜÐ!Á¤ïAH ËÙ“‹@Á ¶P»˜Ð51ÅTCC—ŸgÜÖ?D_×Á(¹P¤0ÅýËO|Se­òŽ¾Š€€Àˆ ©x ÏÙ‘ïË  €\ð” ( @ÂËe~Œµ;Þ¨„ €Lrøº”œSœn=¢/ô`@WÄ›òB,önŽ²p‹œø €jWH` ƒS†>خ㈗Ɖ ;Åâ F-ÂJfeç@È€pÂiA½;n1foŸì¾æD_éP €ÈìÂK ‚JÅ;ºî5P ‰½ Ã8î«óH S`à¡„Ô€€˜ŒRq9$åíÎêû¯§è GÄ€ï I5™J¿Ã¢/造T ³:#•òRî0°@_¼D4 ð¼ÎÁÅ9U€È¤ÒiHH’êäŽ@ˆ¿*À˜ˆØGJz>Æ°€¡÷Å ¹ P  Öù!‹ëýYñ÷ÖÜ€bø°(XN$3ï`ß°À`‚ËAhø­³ß7SzRÎÆàÍJ÷ŠSôtí;k¢“©ï£}ô ø˜ ÿA^` {öpÕ€Ä3¤¯i ,°þ1ȱ“wÓ€bMÄÂi¹€PšKF­JMå˜4]‚¢/ëÀ §ð“:Pܤ£gîýóì@¾äY})ïŒpÀ'zB””èÙ#Ï[ußb!€0ˆgbRT*"Ø@ð(^îmÈ" €.è%҆Ɖïu° ð=¼8;@ÆBp\Eø°@*ð @`VH R`îø=€ÝóÐ@l RÜB) Wÿ†|â[8—¾â¢%PÅŸŽ{Á‚I@p @§N&ƒÅÄ_ç°@:+ÀÀ.GOt¡¹ïˆê°ÞŒI`… 7wp%yÈ‹”¥",“HA€T®PjZ9ûçÖð@I0B‚ù È@js Û2²”×>‘ë@ Áp€Ô–ˆ[ü¯Æ/°¶aÇ[À  SÀÐo!à åŸý·ÃÕÎ'Þí‚ c@@)|’€nŒJÿ¡Ö¼¥Çûhÿm} €,ÐL@Ƴ¾IÌ ~¹€ ˆâbCtP °fÌÛ#:ÿ_P @@…!“bqD4lµ;³»­úwº@€ZÁ €bQESvýŸRªá¹çË]ü@x“’ahóô8[V‚@@) é9 slœçN½ø J`À €Ð´tðÇGIjÊ9KUìÁT À€99 (Õ?wØaj4æòá»håí¯å€Ah¸ñ %%Q·e–—'%‰ÖP@@€tÀÞ‚X ‹O` Ð1݇8ûôð@«n°*”ð—Ý?’xñ6` @nø†RJÙhoŸdüh™âx-–€+Àª€è†‚Üåå©Ô>ªûp ,‚ø@L€ €…?•Ð 3ÖÀß5@@‚\JB…ì5‹/-=(ÿq‹’ ÉŒïÍÒp 3Ð$Ä@ j Bvûîg’R¹JR"äI¥àÂ’ž¬ü+À€œð@Õ³£ÌdÜE†óµ@!¨0‰¤4œQIHVQ>ú€¦G€trsš×¡^RX K÷ìà¢×–M C›ÅÝp*_ /÷¾ 4@ Àvp–RxÌž¬q÷Û‚ð gj˜!¡„Þ3%9·î²hrÓÜèða¼ð¹Êœ6T\œH÷v&€Ä›ßt‡^¦Ø W¾I}Ö§¾ /Ë 1HßÌäÿy@ÇÈ×¥ É!9iß~ÁW™Fm¯˜baa€€§-Ƨ§¬_Uñ€Æ ¤ @*7&¸Ôô¥g·ê¹JRóï&ÊÞ!¿4»Ñ9ôÓ»z“»&Ø '’þ’baLŸå‚fù ‘ |RÇø øÛéƒ@LL ïйilQ ‚&Ä,rbP{ïªé~Ø$ÁÅ ª*@Àe VCõ‹z¯¢€- pjK@ AL!؃|(ÉÍóîg¬!€.|Hh ‰…þ®è<8è‹ý @¨~0  ~È$’ºÅœ¡Z€1 0 :K»?ÜŽË+ßœÒL°½Ð €u÷ÍÀ±u 'ð ¡(,à;fFÙ„¿'Ä_èP€ ªHe#€À·SîWRÄ^ Á´4 @„œž1ÂI‚B¯œ àÄÂÉdÀ ¡ÀY áj#Y@X€ƒ9„Ž”e'ís¢.Ð@:*À€.FNd¥1͈ë°Ómµ".R”ˆ¹JR"ØP À:&ËNB éÿ˜x}õP@€] 7 ;(07'd'8Ö;|¬¾÷€ à@Ï!Åeš@u¯½x bÀ€f±¡¸’“\Ò<É©lÓ--~ˆ3@Ã@€Ä7$³ÿ8]h  šŠ ¸¾®ìç›mÌ´€œ þ5ûÜðÀ(Y¤'1ÇŽ•¿þ¬¿| Á0d I€7à8ù·ã±:õ  É TOëæØ€€=Ha3£¤|x«®SÀbÏ_„÷òO÷bzSÞRbK);ç¨È0ÀNH)Ë•¦13Œf–ù0 ¦€ AÈFÁZø €&@€&&‘›V@V¹JRš.R”ˆ¹JR" ø})H‹”¥".RŸìnŽ +öÉGã·ÎG¿ö±JR"å)H‹”¥".R”ˆ¹uÁxøh €©A‰J”töÇí¾a÷"ê‚hàÐ @rS|JJ>î³ù9Ñο¾‚A °*˜ KJWÒ—P¾<Ÿ{@Ð)€¨ ~Ü‘o™` $€œ T –RS¿Olƒ¿çÎö`Üô$˜[ÔèãÄVZ;Ôÿ¼`€ÄLX@1Ót¹hÄÍׂ @BI J,È !l¤,‘¸â=¨P(Ø Y0ctú0 oš‚° "@ €X (d%(&}Ó·rFÙJ"ŠW’úÿHè$€< 5Ê;ó;º` P4s{ç@ ä0^”LS¤Æ;ó^ì¼ ` ‰¡¨ Gß™4£ï4ï½óÁ¤/@b«¡!„4•Ðß}Øë–@‰nH@a ' øc|7°zïa€+ Ü’O¢¨þä’|ò~˜ß¯ŽN 1kË$Ô¥ÜÿýÕ½ ËtwÿÄ@P €k¾dÜÐ@.@€jßã9¾Ÿ Mç°* @¦.œc›|H&4;!†#!+R•ÕzÐ@s"8Àa—Ê_G=\s ¾@`ÀÀ ˆE€Ü„vÙL€}I0¦ô”‹Ä„dm²¶Í©JS+•€@0@¡K`ººLš‚I(¼ù9¼Èd"€vÂðÔ'7×Ü/ ”‡î:é€Ä ËéûwyÉ…’P„‰Óð÷ä$8ý®à`€vá¼·B?=Ñz€ ALàRjI¹(+¤ýÐxV¿ZBÒíÃ:þËÃï>€ °À ”1¶0Qö$>]ðböäI222¶Â)L@ TCä2»§í²‡w>€@F|P€ì3ä—öFQ›¹÷›R”¸²¯7*å)H‹”¥".R”ˆ€ ø})O×r”¤EèN^ìÛòué@‚Vhí P²k·û°ñk¼ø gôàÁ£—#_R À$0#/#Œ_ÊçŸ×y€€xˆ )I40šŒÌWz€„Œ €&(˜LO@NÜ]üè˜*À4¼”CIMñ'¥¹Ê?Ü€ €€Àò²HA¨KçløV÷ØÀ( ÀtY@õ3„ûÌÐ T††“1`;gÛwOf^Á &É ‚ãü<9í à˜‚` [²]¸kð¶@d"€ºÒ÷ÝÜ‚ö;Ö P4© GBweÞH€vĆ'% Ͼ¹JRtÜ¥)rp @2&^ !çÉß/;y)~¬0ÁwbXie±{î1ócÞ퀱@1) ~“C1¡×Î’Œœßo‡|ñÀ:!nø˜¾7‚ú7šû €€ ¤ÀÈ(443ÊÎÂŽ>á$ L²Q¹L0g9¡¶Ô–ÛhÛm~”)Á À Pš°(„tô,¦Ù¸÷},,ADá¡¡¨Š~ra×ÃÒŒòsÞÖÔ 1ÉÄ2{¥[¸wšJÉŸF÷ú@8 7€bd§ I?h€ 3€?&þ€ ’€u¸å_ž/p@ KJ@Â8Þ¼’³a9¢«Ë ä–5`¬ûíŠ9ƒ§È]à _ÛÀìé ¡ÀL[ FY_¨~UâT"I¥€Ä˜Y4'B'þfíö·ÎÀð ß &}¶Ê+~øãõ̸°b€tB Û3 ¤oöö’ ›F+kèØ `H N…†l…îÂßæ:åÒ’Ù¤uÊR‘)JD\¥:r2þÂk@B¼@oË BŒy†ÃHZ ØÔý¦CÙHå“CJ F?¥;î§j ÏoÀ|›|ìû€ºÈ žVéw¬È@ôâ%¡ºLh0?-8\ ¡¹`{ñCͺéJYÙ\¥)r”¤EÊR‘ øyÑ~ðùô~ú"ÆûÓö‡íz€ @aÀNÒ¶wG¾Š€€Œ@bpЊNN—Û÷ëQÊ{æ@; @nèg{¨BD Ãp ²zw1î @/-, PZý¾¹ïwxQ@ÀMÊIøã[ã¯ìÀ;€ @RQ5•÷ìûç³€$JMÑ ?7ÆÞD0'(†YD΄¿o‘±®:õ Áô¨¢å ,¬³…œeó`€ @'ÓÊA7Gù¿c=ô À €€$ßø¢Ò»äíÝ…ëñÀ€®D4€éeö›ûÂ<Ì  @`CGÁ(Gìgû}l€5Ô@ Ɉ Ae|”>æ.ùˆ !cÀ5xŽ5ö)yµîÐÀTÃ6oûüw~*ðA$hh Q P7§¶Í¹ù°»çÒ“ìdÀpÐÔä#ýêíÿl¿ï*×ýµpð`€Ò°†§n•ð«¼`$ð €P´ Éý+Qªú÷à~dЀ욄Q›>ÙþÛ?ZýĈ€+èI)!…u»/ãÈÓéÚþhÄ'8v&“UÔK[àýoÀìØ4†JÉ&gû÷ßfÿ‘ï³€‚À 1!¥8)û§òO Û@¨ R€_ú å8ð?Öä~.ò€4"¸fá½)OÇ÷PqÞ8mü€ J(Í% 4 †$o$¡›c±¸Û”è´À2X vRrU·ûw¿C€ødÀÐÌXËO Þh†°Òa1 ;J_åøI®Ð@P&€: I4„”„gc÷ B^þS»ÒÞ e'1H震Üõr ‚ö¨,A© /2QÛËw×)JN.R“€? ÀQ)víãoüŠ+†¥Çÿ¶¶Ì©ýþ=v°‚A]î*è°4L_ű怮èàᥖ/ÏfA‹Ïï4  ðÌXné ¿(P `Ã’zÌi  @ ¾ îg·´à$<—%øp°+°{‰§€>G×1`€–œøG÷ã  @ ¶î>€P3H@W¶è:õ€€ðXij¶» €!8ÐÔ””§:ûÙ€\ Kßïü €U”Ãçó¯`Ïr´0Ë(˜íú×}8”€)-vPbCC£·á+s0 ¯0 .,¢A¡«ü$×ïrƒ Å#iÀ€ „m›j»Ìdø À& & ô#?7ó^ñ2 d ô#dþì¿ø›”§í©»ë+ ”¥?Ú"áÔßy’·‚?ñ)LÿR" ø})H‹O»R‘vx–BAx%-#¼}¾kШ …„¸ýo^ €¡8°(RÖv<*äQµ˜€€„ßra ²˜æOÖ€1p"‹Üz7¿FP 7€2Ñ4–L&dwWgìy· €ˆI!wÛY:7¦ÛH0`€^© °Ô(“ÜãªÈ@ƒ@ȈE%dŒÇܺ ƒ€€ÄÒ€0AÅ'!ºÿûܨ–B(¼·«0À0& 4”‚Æœø*Ç翯‚ˆ "‚˜p*K€ÑúVéu©[n«Ø€%@´!†–’À.-?;Äü÷ç"h`ðI0®,@®Ø €6Ù$ÄÀIAò@8 @€Ä\o¶Ùò>íƒçÃ76ÿJÁì0‰»Ð·Éf—üQ„ùø =GÌ »î1e%b~mH €(/‚Y÷ÂH !&N0Âð s #@c°!†“ ÚÿH0 eƒfК’À8Iâ¶þ󠀺`¨à2ˆ&•^w(¼íðûâe‚H$°!p ` !€*€8 ÷Åg jÀ‚ï~ !`Nù÷^xÁ›{ê!0$,BÄÔ–²Qß5æ­ €À²rHE!6³þÚö€€j€ @b’3$ÉlÚçûeö›€Ä…¸è ¬Å$2÷Èvh Ð ÷ÿ <]h+|}˜ÑÜé Å UáAh/}ÄV€-)%€™#3³‘«€@¹¡FTbo¥ (ü°@ÎŽ>|…ÀLMAy(/#î¯B¯Ò‚p„ÒЖÆû¾ eSþçûÁ€?"€ù$´e™ðûxà€¢‘7ÿ¿ÝGY@ J+7¼€ @ÇÈâ&F B×ìK&%däïy A\˜Ž‘ˆýgŽÕüÐ>sÙk³@IŸp@@ËdM@ÜMîÇ6×è3þ§õ`  š…xïyÐ 0¤ý¹1NÖ€Žt%$Äs¹Ó,Äaö€‚€‘ŽZYYõôø°©Èé J26ó` È‚ðbrÕÉÑx°@ŒQHCÕdk`†à¾ù\ûÝ'W€ÃxÈ Oê<.ôðÁ/ѪÀ`D,­‚ª›Q³Z†hL HÔ#8‹°˜ð ’5#q¶Ô¦ÛE%ê2µžV°ŸŽ¢‹<6Ú"äKKztøì7Çv‹%ÿ—#ílHÙ¢æÍ©JD@ ø})H‹”ÿj$¼V>ÚÏŒñÑÓ·µåµÎ˜47üZC!†¡ÕäQ3—QdÜUÑ‹Þ½¨  I»­ê@tC,³ô‹œ¬ê€À+‹íuÒˆv¥TÜ¥:vñ%è‹¡/G†£Cx±H€ÝÜ@£‚á¼X¤@nú˜7xoŸ>¦ï©g•¹ú€ hR7ú2~6Î ÀKS°èRÜ£ÊÞˆßë`Ð^Z4àBëF>«®™FÿI2Ñ›'ëpÀ ÁÒ ¬Œu)ÿ -)ëÿ‰¹JR'r”¤EÄÿ´PD¯Ó/ÇÛŶÔý¨ÛG§mâ.vØ>ˆûÖ/#z°Çú2rc"Å)H‹”¥"  ø})H‹bi]:´°(”Qöñ,3}"ƒyB&“vBÆuËŠ(›×BÀ¢Õ@Àϼ¿Ýy^y(ýs˜1<é ˆ ÊÔ) ¤¿Íí$±šå½éÿ´åv\MûŒõ¤ÒC#=Ÿï¿^Ü:’ƒr2Ð¥ 1͉`ЀgŸ· Y13nH'SB¿$¥€©Xˆ‹Ü˜(ï÷'Ö€3Ä®ã®.ç$@Äõ 2@“øF ¤ ±áˆ‹Ü  †§:³šö ÜšC) I«@HäŒTL+›PÀ¨`nÅdE„fÔ¥+‹”ý½)Έ²7êÅÑ;ý!q,ŒÖ7\E ¼2wñ?›Ü¥jtí¢.QôÅÐV_œ4!Z6þE ,ä{¨m7zÒ€B’úµY3ôçñ÷ÐY3†e…X¥)³÷þ ÚûD\,7ïëH|¾È5 /Є¬Wy§ôöÇE’ü±©z¤fÔB’B24\¥)r”¤D ø})H‹ŽÔJsSîñJ?Œ|ö¸ûø!h ¦ë„\¥)rŸoJD\¨3R‘j Ô¤EÁšƒ5)pe6jR"å)H‹”îÔ¤E–ôúˆßë-õ6ðlôÞ?þæB¢’†ãáHþ·,ÈHø€9Õt‡òÄÒöR~¶(#.ÛjR'ÓÓ×ÿ¹JR"ä~ DYÅhmµ)þÑ)B^¦ÿø‹”¦¤EÊR‘ ø})H‹”¥".R”ˆ¹JRCk”¥#F¹þÔ}FztoqõD•…ðømî>£ïAš›m îR”Ž¨r”¤Cû”¥"Ü¥)þå)H‡÷)JD?¹JR!ýÊR‘îR”ˆr”¤Cû%þÊ®ÄÀu¸G¨ˆi0›˜²‘:e¡)Ì„Œðâ¯h€Ë ÊK9:Æ¢o Fãè€ tŽ¢b0t¨)`ŒÓ&Q$±¡Í¹—)JSîR”ˆx¬ˆ \šîGb©ó¬,Œ…Ìýøò2é󘀱æ@ÀOÀÓÄÀeþ8ðÓÂÅpèv>`³àaÿ] ¸¤Dêž`ˆ<€ãƒàa¢êD2ŸðÓÀÄè?Àgv ßð•ÄÐ3Ói'þša /ˆqÀr©è"@/‰ð¢"Ï€X;¥rtX W:àŸ À,èžaM?€ gY:XàÚ{à,„@,§ðü(€ÊáÌ 4Ô÷…‰'ØX;,Ž¥¹æ‡îÔ÷( OÿrA§ðgÿ6t>„€rO§°œl(?#éàpÀƒD. '“ l~ž`ñAg@åÿ{\àx:" Ôð‚)‹Ô `þù‹O0ÑnO1Ížð0:ÿÄR}<â° ÇB€è€:ô8OOA>""@ØÁ`SÀŠ#ã DUG̺yƒ€[  y<òÀ}â Ì\ªx9æK"ž Ni`m€Ð˜\±âjM²À W:à5X €þˆ³€Nd/ù>?ôþl €03Æ€³ßú@ÖÔF úÌ°Ðýýàæ{À~üÛÿÀ9qÀlÛÿÁƒþÃP4 ¿óæþò¹ -¾&ÿ £¬äþD¿™€ÒaGBcà ¯êÀ쨠#kØ §«œh°àFƒoøtOúž` @|:-`Jô:<vðp `Béæø+=……*'ÁÀ,€8âu?ˆ¯ú “@í=AaÀEàñË72À}‘<@B§ˆœÐ°â’ëú0;`ÜÒV$@û6 |°7`réæØBØ<฿ÅÄêâÖêz<[€Ö'Ƀéà sÆppÿ¨‹§@j¨œp•@Áÿ¸ =СàÊ :žHwÈÊM€ W'šPP¡ #²¢}ÿæDW ýÀ,».ÿ ÀnH‚1€ÓÝ@t:çÂ3O“ïÿ4œ ç@>‰ÀèÃ/àéh lÿ7mØù ø,ˆ 6Ëú¸tK"Y€?Wó0€`èÀ7ÍwÛøè€7 ò=¬qOä`5„´ ‰õèX[€²Éðë¯QÄ`‘cŸȶjÜ,>ñ‡àóè€kÀÑŠ0ñOÃÃø‰Œ<ð¡qÂ"Þ¿5‰ÁÔ›éb=‹—¬Ð€Òþàcÿ€ä5agÓÁÇG@,§ÉÔ ÜtôÔ¶*›˜Hñ>h~…ØŽ 4ñ€1àÃþÌ: @ |¼"Ê|Œ'p}=¦‰PÅña@?8áPìb@<Ѐ>'XUÿáÆÒH³ˆ„áöNñ.ÿ@¨õ‘ênMÚJ;-@@F˜$G,^øyÃÉäHEy‰s@Då ‡ó\]âÍ“^fNéc¡æ»^w6ÇßB«ù<úŽRƒþ ¯0ür„<ÂœaÔÝl¢tyç[µ½z5¨àÅó¡ Ç‹þ ý ­,FãvøÖátÒösÉ€á*˜ ßóe€þ1pò5Ó£ÐOø€ºDp @h.ž>4 R…œ|À:a ÌM@€, ˜>[¸þ n$Nöæ"Æ.Grtt W'•"ºnÒŽGQœ<^Œ<€(*<îôx÷"P×^f¿Dmc'Ñ8¿è\ÕêKÂx‹7ª8P|“kÌÂÖÙêŽ^0ðc2B…(ˆ0[гÔ9ĪL­^eÏÜœ$‹Ï0‚Ü-¼tõþZ½,ãáDèzľ¾·‰ÀB`"5ÒÄO€;£þÁÜþ!À/P ȯtõ(øŠÀÀ-¸šyœ™ˆ‘aÐ戆( <Àf"W5XÇð\ÀÁÿÀÀršxË]#€ W@yN‰O‰áT›6؈|¹GÌ Tó×üе`!aëôyì? ^fp ™k€Ñœ¥-K‡UyšÝˆ¶µzÀ4G= ¯0~váêÆ€ £Ö$Tµ[Øuz¯òépƒèq¤÷²uz%œéáù¸PQ>ÇØ€øAŠ=b.´èåm\‡GG|:Ø”Ò0n©¬ØÑqäX=ƒ ÏOQ> @ cŽ8ÐSÌÃÈ¡ÚàiÿŽ6*9X<8Hy´øÆÁÔó,Ñ 4 8NX°»ÆuÐ2ÿÈ)æ ºäÀùgÐòêH‘©ãóp#dL¶#É#ºM¶Ýºó|ZHÇŽ’¥iFç0üÄúp™-_!JØ{…+i]Aã«ÌŒ%ý°ô¦cÍ‚«’ÕèH¢q8q:Íæœfˆ+aÖ¥¨RúxxPðõ÷4ƒsÁu_ZÛ5-édÈàh´ñ€¾7Ô¡@ÓhJû(ðjÿ¦b4`ÿèv}4Ì:"@naIJ%ˆ§…ÒÄudqkˆÓR° yŽ¬³¬I›ZÇ€}ºcÝ^Çâ=<Á≵ڨ9c¡ÇO0rœé"׃¨ƒ¡À,ô·ˆ”ólx°#fý¤ˆ…Äúy“‡ áã¡L*Œ:£œÂ% W“ÇØôð>%²ÔÖ?š<\…€zaZÇ d½<ÈDr³ÑÇs¡`2 Š ð)èŸ9/€!'ËæÊ0@¦§’=@lV%@3©ç—BŸQª4ðêyyôO ¥°5Ø|G±Ê¦ê£Ž°bÿœSÁÏžš™*8ÎÒMwð{ƒ?ýáb•}LƒÙÎ…‰séj Õ°°êyðŠ°’ñÖA€tð Pø~œXƒ=<ÈÀÀ4€Ðî° ža˜À`oœŽðöO@Q@Åþi±à,špúv(³Âí€Ø_¢ xX½b€ŒtƒÇvÞ„ø]<Ç=Jr]pr‚è,ŸJðèÌ6§™¡FÙ§z]°«0ò<Àþ|<:xõ‡Çi$Jy‚gskxQ‚ …-N°8D‡8 êx Q9g0qŒüØñy@2"H'ק™š=|:ÂäŸkuÄõÝ<Á+¥IYì 1;r%ÓÌ0H|`¥€ÉJ‡u  3‡³°1Ù< Ö§·5`-c¸ðíjr)>ÈÄA§˜d•bc‡€sK°î>žb{¼Ð^>ðpòu]<ÈÅ`ôE°ðk¡g“¤©ÈΞG{ã„ÕB…5<Íüy‚­bä…ªAÚĨÊy‚>±8ø ÑÂUîDzy€?”tN€=‰â€>  y€-€Ð j¢@[à6| Úy€‰ýƒ Àp !ä(€|}<@`4 ðàó! §…ŸNÚ‘>§T uaôìÏœq qÖ/³ :OAŽ;w'Ç€s+@ 2ždlkXR å½“ýŠØBˆóÇè@ƒ¡–*pŒéàIC‡R‡lÄé `qœ×ï¹Â?¦Vl³iæDóÿ£€9±d_~r-€îžbWÁ¯þ‡ÁF3_§¢[¾ßù*[ñ&c– êæ؇SÌIJ²zÌ¢!4x¼OÁÆ™C˜~"泇³BUÛïôócê PyÀ$—›ncÓÀ“Ç¿iÜø*Œ3ÓÌ=mbÀ=·â➃£Œ<>žy¦ÙQ² f?SÌz‰Ìîââ4xêžKeAÜŠ ¥Âä,qŸ3Ð<È{ˆ K¨ö€^d § ‹þ" àb"@4=\õH€Ñ©è'L¨€/^ÛÀ# xê 0t(ë¡gÊyZÔA‡Ÿúá. À0W[X3Áôóz'‡]Ø–ØH<çôð –="Èú@ŸfÊXºx©˜F#WVÒÔó#1à€ÒÖ$é*[‹"Ž’¥‡Äâ SÀÄuÉÌ¥QŠG°°(*éàÒÍÆ€ÔÆy©æaÔ¶Y /QŸÃÖ?°à|f4Ga'Õ<ä sv>žŒù…ÿ P…‡Z£Œ1éæVh6ÈãœÊ#.ŒÀàkP4ñ88Ø+úìl9ûSÌ—kL>—AàÍÿW:›«n$ñò †]©© ¢« ¬v} C ¡ìô®taâ@„ÁæBO0: pqÀ?‡ÓÌ_ýÊ râO@þ8ñsâ š:ž àd€d&< ‡ÁK'O'p¸àâ4,žD€ xêævcëQ¢©æb¸<Ú}Ù¤òx˜AàrÍsiàH€O¡`l<óÈ÷4G°¡Ê0Ôššb oH 6^Wžž`ðµðãi]O$ßÏÎH°õˆÒñ§ŽXêE<Ì[ª£€\ÕÈÂaôn#€mtó5»ù&µ°²;Ø÷OA@H1ùãícœÄHr±ÍJçB"ÚÌ ³mJO1ô-áík2Œ·8Êy•‡P’5c•¥˜A¡çpçzx– ä¦ [Ù8ƒ×O‡ýŸþ#Ü:šcšX/ígÓ¬jGšH'@t¶è¹ÀÓ*8¢iäÈÁÐ]=áÀ?OŒFΞ` 8‡Ã£àýSÅ08Pø8>¤ W&¥lò!ð€ð)¤Å(<ÓÀéPW`bÔ¦J‡Ù-OAZIŽ'` ‰ ',£€¢B¹d°¤2Œ€oa^ç €b`*‚C>4ßÀ°$äò‹)˜åE€^C!ß3Í€¡ÏGÜD` bžWBD&ì B»ç]ߤÁQ W'à„$ oöL z3†§VéO0‚A€ì©1 |”…a/Ðð €@ŒM¼ —ŠJI¼ˆêà@êeà p` ú††’¿êÊ€/à€h霤2ñë€Bô3@@bY5ðÎVZÒa‹€v`ЀĆX&†“HIa…äpú`À·Šä¼/¾è ë€jq3~ŒøoÙf+`À4€Ø †L yEî1‰H,—øƒšÐÀ ATœ²ò]Æq©sðqŽÔÄ ð<Ð x ÿÁ„,–g íÏt@P€É!’+”Wß;sÏDÐxYDÌP ŠQæ»s]}dè /+n /bÝ€pYffÎß›L Pø:&†É¨%!HNC2üaæ@ €/ ðD.M„Ćö`1†ñAy|Üãà€7&“À '¥££dï¶ØSlOx •À¼´  ã~X[‘iàAÁ̤3@2Zr Ü—ùÑ÷Xà°ö’ÑÓÉ[¡`ð¬îtÀع`/,S³,•¡ð0p#!€Ã 3åcÙˆ¦Š3sœ,‰@6æA…“ ,;pÒ¢h!ó náêÀ?¦Ì&¤Ä©1? fG1݃ÍêÔ˜Rµ ß,¼€F€®€JÐ)ppÀ 2xíÁ™É‚Ôh0a`Œ°Ee„G  @§/ÄÔ¥Ø÷ÀÈ  ÈA#CSÔÁ#ƒíD dæ€Ôà€2À:Ç|˜À Þ0¢g¯Î¸À„4’€¢D!©Œ ˜¸˜^ª–®†Û32ž @pFrÃJ ç Qü ´C3$†€Ä¢ª@PŒ9‹È`õÄÄÐÀÀ ¼Áxê>P¦ôÑ'&””€VLHÔ(ãÏï ¤âÑ“Žð8ˆ+àÒZCà9~¶ìÞŠ2@`‚““{pè|‚ÉlHHükˆ¨b€P€Ð3·d%ÖœAA´È+qÁ@B…´WH›(†•æh PàŽã6eñ n-GÝÃP ÉÿL01X½ì04"ĤíøæÚ û“Fîu§ eä z9椀ä W0B ¾OÈ”Œ\lYK!Ó± ç~ìîFLð#P*‘€P˜”žéfF‰@@’@–4±˜ :³À  øa04€: à;Ol](9þ)ƒ›À€®ð0¡ àÀNCOO|VÊØ(,‰©ƒ‹€˜ €8ÃR4…ñ{âb3wÛ+‰üp%@/à”@Èè%¡iî®)ÂżˆàLQI,¡©C/¿e€z¨€Ã!œÄ@Óÿÿô§¿ëüßß“á@@,W`å æ§¼,I>ÂÄÙdu(=Ï4?v§¸@bxàø’ ?ƒ?ù°   ô$’}=„à#aAøyO€¶!pY<s`3ôóŠ :/øÚç³ÁÑXð8F§„H$X¤hKÈðÈäZy†‹r|yŽlð€9×þ"“éàp %€n:@ÔСÀ2zzÑà3ˆ‚ö‚À8§P‚AiAÆóÜŸbP É„€†àõwºJKA!=kßcZž`´#r„Â~ãÅøé4Ù ¸ïùäW”y<òÀ}â@¨NÃKèÓù¦¸úmL 2N,ÌoË9DÔPpè €1(šË+ÜÓÜt ròa5(éfêlIA€dÉ‚Ô1Îë'ÍL˜¥»Ä %·R]¡cñôS, W0FÀ`¾Û Ä}@`ð,ø˜K)$¥$¡ÈeÊøÓ"bP%65û6Nç¬!÷½0D À€#^ ÀNx ÃR”Ã@ßÛ#ÿ¶Y>péÀ,…ã@?'ÃÇþŸÍ‚ÁoøÐ{ÿHñ ÚˆÁ@?Y–:ÿ¿¼|Ïb8à›ø"î"8 €{ø0ØqàÊF—þqàßÞA$·ÃÄßဴu€¼ŸÈ—ó0Bì(èL|µýX•tm`›tõs€mvÈÐmÿ€éàSÌh‡Cƒ…¬é@‡G€Þl è]<Àg°°¥Dø8 ¼N§ñÕÿAR`ȧ¨,8¼9fæX¢ ò'€ÈAÔñ°@å€>~B_ NÉÚ O(5îHN#Á P›ÈDÐÀÔ'¡%% W³£@èŠam&`Ð#°Ä¡Œ˜‘¼Çp ÷øн  Ç£HBP”ñä¥Ò ’y` W:· u=Äp8@‰ÑßúAÏþă  €6D¿´Œ@³;Ú#ßøÄX_BÅ€¶ïÿ’'€IÏdQ÷o/ý«ú3A¯þHx°èñû¿0hÿ°:áÑÒ@6°/àlÿá`Ø0‘,€d€þþ;€rdPŒ²;ßÌÂà5v!vé >¿£¶½Í%bH÷ô³bËv.ž`„-ƒÎ ›ü\N -`>§ À`…¸ b|˜>ž ‰ÀèÃ/àéh lÿ7mØù ø,ˆ 6Ëú¸tK"Y€?Wó0€`èÀ7ÍwÛøè€7 ò=¬qOä`5„´ ‰õèz?“‚\c¤ý®Q0´”çÞ¨Àv 00·VÚó@ €¨ CŽºÀ €¤ &(–îÛw$æõ¨!XÙ#œ 80 @4,â&õî!››Œ'À  „€%Ì¢‚PCJoœoqP9³D‘©üa'‚À|ì)ÀØ @åÿ“Ö 4 2@ÜÑ`nÿû'€xx˜¿Ö|Åý€"|AúÿÀY`Áþ[– à-é$€À?°dÿ À?'ßÛÉ€4°f¿™€´Ë”#€wZ‰p¨KHXƒ ×Sp n—#ur«Hú€ebÇ1€rà/‡˜mqÇ0ºàaà4»4‘Ì"Ø @O8v=¸Ð¡a÷LÄÀ@øhƒpÃÛ @±ñh y7çg)/pö5pÀÀ”‰Y’ç@`üÀ!!ò` 8éXÌw(DØÐÐ €ìø “7eˆ¼ Èe’ÒXó„D"èߊ¯Út 殜#vùñ¸@Æ{}ŸÁ“ü ." mÿ² ÿ*§úË°aÿ¯n¡Y—þÇœ"8F<Ñ v½£Ž` Øáäù"·aÀ>sèÜ£Ìpé!õæd,-ÀYdøuרâ0 ȱπä[5nxÃðyô @5àhÅx§aáÁüDƒ ÆxP¸áo_šÄàêMô±ÅËÖh Àip1ÿÀrH°³éàƒã£ SÀäêPî:z?2 CGû”€Cy7#§©-°}Ò@boÜ*æ‚èàÒ`ߣì4p»ëÀ r€€é¼ÃñÊó p‡Su²‰ÑçnÖõèÖ£€;΄(w,ø,pô&´±Ûã[…ÓHDØpÌ&„Pªv`7ÌE–øÅÃÈ×NŒ#@l?à"ètyÀ\.<  ºxøÐ5Jqð 脃0 <À ` € ÿ9 àÒ °(YDÐIJJ^=‰Ñ @;&€€šQ ™Ø43¹\w ¦„Š , Œ”™µ4î’JSÌZÕnžØ²Ò^Ê ïQ° W'•"ºnÒŽGQœ<^Œ<€(*<îôx÷"P×^f¿Dmc'Ñ8¿è\ÕêKÂx‹7ª8P|“kÌÂÖÙêŽ^0ðc2B…(ˆ0[гÔ9ĪL­^eÏÜœ$‹Ï0‚Ü-¼tõþZ½,ãáDèzľ¾·‰ÀB`"5ÒÄO€;£þÁÜþ!À/P ȯtõ(øŠÀÀ-¸šyœ™ˆ‘aÐ戆( 4ŒOH¢ç‡‡Cz'DÒÊ€©9{e©AÒJG/ä#/¡XòuMÈÌ W5Õæ"Óh˜ñDøžI³xˆ|¹GÌ Tó×üе`!aëôyì? ^fp ™k€Ñœ¥-K‡UyšÝˆ¶µzÀ4G= ¯0~váêÆ€ £Ö$Tµ[Øuz¯òépƒèq¤÷²uz%œéáù¸PQ>ÇØ€øAŠ=b.´èåm\‡GG|:Ø”Ò0n©¬ØÑqäX=ƒ ÏOQ> @ cŽ8ÐSÌÃÈ¡ÚàiÿŽ6*9X< ° À¸l€ÞŽœS’Q°€tû$®VܯÑÌ;ÄÂÐ Ã §¡;t¹‚ƒÇDÒ` (a¨ÿnWùù¦ ˜f‰¥ÂrÀÝ…Þ3®—þ@à!O0åÕ× ÿË8ø€—RD€üO›"e±IåÒm¶vëÍð}i ;:J”A¥œÃóèYÂdµ|…+`î­¤uŽ¯20x—ôhÀÒ™6 8` ìBÛ„ˆž&Ñä ù ;áTÀØÌnP ¨„Ôòfý“÷%-à@+À ÁLù4˜Xcq§1éð @'$&r9hGpÇ$9‹œ4dìÔ’XÛ¸ ÀXi `1Onì³qÌ,ó`0`Ä€L®F|ÎÛ“ÿ¦„`å9ÒE¯P C€Xén:')æ$Øñ`FÍûI ‰ôó':@ÃÇB˜U<uG9„K@®‰ãìúxÙjkÍ.BÀ=0­c€á€²^žd"9Y€è‰c¹Ð°Ž…EPxôOœ€À“å‹så SSÉž 6+ ÔóËΡO¨Õxu<È<ú'…ÒØ¿ì>#ØåSuÑÇX1Î)àçÏML•gi&»ø=ÁŸþˆð±aJ¾¦AìçBĹôµPêÇØXu<ÀøEØIøÀáË Àºx(|?ÎG‡¬Aƒž˜ G Y: @`É~C Ih@ܳ;, @0ÓÙ=Šß8±P A‚È©d À¹+`=€€ Р€ÅÐ*ÀßfΗ;ð|„°@& !ð À—ŠÀ…Ʊ¤2ÑÔ„9ŠXUÇ €D!l¬`ëY´I™_ò+ЀL FB¶Û¬à € À¡X¢ŠÛm¶ÊÂ*zÀ ÂÀ¢Ä@QÏÐbPmé˜F°`à*‚a ¿”37> °@Ô~Q43”_Ùßö ðDÜ^Ø43Œ- ß@À@€Ÿ€Á%pß¾À|ÿÀ\"˜Ü “-’ƒ€‚WÀ Ñ½A ?xÀ„„™¢NNNÉûƒ[À€f‘ `P £££üýHNO0?Ÿž=añÚIž`€ÀÚÞ`…Ã!KS¬!Î(:ž‚”NYÌG£?6<^P ˆ’ õéæf_°¹'ÚÝq=wO0JãÅÇ)RV{ˆ N܉tó )`2R¡ÝBÀè áìì @6Ou©àmÍX EXî<;ZœŠO²1Eiæ%FؘáàÒì;§˜…ï t‡¼gB´p•A{‘ž`å IÑ! D2ɉáÑÒ?Û³ ÞžaëhóìܘÈù5X `(€Hg ¼/gËl5Ôm€4 K,dÄqÃ_“© >`ä0 ˯ù²Rú è~w/àýÉÐ g€„ À©1 ã?nþ Á¤Ç$›4 fÃJ@Ê` 9~™Ì&¤†¤e§à)À‰¼:Öý¼PpÀ€è  ˜B/±™óx ‰€ Ä®ä<^î·w½‘ÂIbð2`°À I€!F|¤ C“°¸X@X8c! *¸ÄCêÑJUÉ#_þôpk BV¡ñ3mp÷­ãp5=eÞðª©éÀ ®Ú5×ʬÝ :·¥Òù«µa5³Î“ëƒ ˜€Oºà@2¼ @Ç|X 鈻RŸ¾q&“© „°ÂÒÍþ]Ì€b  ^ŸÀ¢?PÄ @A˜àoJ@ŠüYW—Ä͹ N üN¹Ã À1 8šX_Žèý˜Ð@vxzSÀ`W9€¶8(nz ªSø Še>%eájY:ùú@4 OZ Ó$Á ?„`«0(ÀH_0-Büú7¸ €€jÀ€²\ “C ŠNý¤7b70ð % ¥TdBÝA ™]F@¤dÎXòjSóþ`ÿ‚0¨ &by4ŽpßÒŒëN<Ãç>˜ˆ6Û3dlvFÛhàèšpàP(XA|‘–||B€8 F¨4¬7í™RwJ8J~÷0DF 0 À4 ~’f Ø ÀS˜3¶´€-NDà !B¬°*–_ñ4èp“ ‰J@vÓÀ{èþP@4!f* @€T00Uƒ Üí J@©|ßsÀ€jCw JÅú=dÀYEc « \L@Äꌞ<›óå§Ú$†õ–žèÜ0â‘ŽÒ E#ÌX r&Hu§í¦J~ꈣQº<½´zSâßÄQ®/ÿ Š+ï,E-ôÁ¥¥†o¡o$'n½Gf©Ð@ —MãÀ¢NS"XgÇQÄÞT%æ¶G‚ЖçM9ëBžJµwˆ`Û·i$¤±ÁW‹–Jö3Û}zvö Á©OÚºXM|ù vA #øÏé¶Ú”ˆ£”¥"(å>þ”ˆ£9Ãf¥"(çÏ¢ÛøR"ŒŒï”}GÞ"ŽlÚ”£èŠ9ûhðýã›ó¢(ÆLþ}èÚ"Œ§xòþòôG£xݤŽj3ƒi‹ÔÅoÚ˜§d'6T'acL—G:›}<Ÿ:5¨7Gg‡FòË‹Bö{ID®Ïh¶áCìàþÓæòu±µ úÙa§Í]G©!ïÀÝjp vA£ø})HŠ9JR"ŽRTßG)JDQÈ“I¸3Îк€n¥6!€)l‚“Ïc³ÄX-U a1 @ À¨h°œ¢Š/•¶ÁºÆ÷áç™x¢À`Y@ •ÑÑþKnbOl@h€€€Ó’3Ã…ü†dï‰Æ> €@Ñ à P*hƒ;¶%óò¿9G „Ï°F @N©4°*M,–”ÿÏzà@©p :¡ˆ J7ÅšÃÇE€`Ë& %!¶ ÅsÜä³:z~€À€2&à€èh ’–'+À& 0@tY Ùú‚üÐ 0Ѐ뤕ù#…ê?Š†3!ö€º°ÂEà®Ù4Ì7ؽP« `1/ nH{ÙÀ.È@Ô'' ¹ÀNÃK - Ìçê>nê£Î¢ Fy]­Sº;[¥®ÞÁ€;ˆ À¨ ûÃyb`ÎK¤lR‘¶Ã¤QA› ¤dlvÙ¬.×ß÷îæÈFU6··SX. *>‰÷[‘¥Px±ÈVN¬°ª¦|mÃéD¥´P[è}¼QŠSwÔˆ¤ ìmd ö§ ¿žF:º6@…£öÆýÄ@ÎXÐÔ`ÿèþJmµ"(å)HŠ2Z[P®ðJ2tP†ˆ£¥",& Ù`!ŠC@-H&¤š4i/§ôÈ CxP@0` ù0à;BI„$âºRÇæÏh&A ƒ@ @ 32ZIdÂÛ!oþ;¸P¯RZ˜hà @€ì5)Jx I¨t’Y§1Ç|N€ÁD÷¸h͉DÔ¤¼0îéÿˆëµ¾õy`hö3šA¥„éÀ[Q(×#D4ì ”€ÒÐ#ÈÂM¸8` M€ AU§Oä”ÿ#Æ?ˆ_ö˜ ü»}B‘·:9{Ãç£z”¤¢Á‹üÑä==>>¸ ³À_<ù‚¬8ÿ2ä?çC]ÃéóêR"ŽeÒ˜êDQʵ‘š|rºY×`Ä…¼R¹ÁQ¥¿˜#¨(ýì4(4p S‹!”Lº!â³°¼ à ‹tø R[¡l_({»djÀ0,2h` ƒÒY4´¶ù:ç@ä@+è˜3·ï¸æ?\Ð@ŽX 8`A¬Œ½‘°eÙÀ€$,}-ðáâí%rƒIíø],°°Ì”ÙÐ@¬- 0À„ÎXI-;p„N­Ð"h€(RYAWL5@ €B½%òÒ”ôî Øÿíý¨ÔÀ è €! ÛwOíÇ„±:ã€21€2bC3 2õ @š`à7ÖߨÇsÄÞh @q0¤wR2¦ÿÿ°X † …f¿¬&˜‰J?ˆuø#6¦ÛR6\d7£”§KzFûÆûØ ÿ4&6^O¨àˆp]  Ü&É"S•›& û¾=Av²´Du”:èþ ŸZÀw€©@'@̯ò¬o¦> éóülE„TQK ÿ ò‚°Lô_ÄÇ~ËР¢9ÔJ7Ñä¾;<:w Ï¢(Ï&ñÓ¼´g“áŠhŠ;JpÆ’³mVBAY‘´2<6mG6ÚŸíOÚ?®"ÁH!r†Öñ «°êÕÁ¸gJ Gû‰Ék(ýûC¤â)ôÿh–MØÚЀc‰›ÎLßÚua '+$•»ûBhåbÀÂ;¦9\o„Iˆda¤§j q™Ï°RŸ÷š%5J•N qF>—Gðþ‡ñáÍ‚½"(Ê!‘JDQÆÔ¥"(å)HŠ3ûøýÿ”úm´Ed}àá¶Ôˆ± FX/Q‹Sqx_><(:÷fø~á^ã! _ÙêÀL¦&mT58Ee€ Ä?ö¡€ƒ …ðÞ¾îþŒ!š‘G 7}d¾¤À vèi(°$^ÃúÄh¡áHBi7†›;“CN¢^Þ†n{+ïœUÅ4ˆË>¯%ã€`R;£0ˆbš"ŒQôvôû´E}GÑï©¿ˆ£½xíé·ˆ£¦ßM›DRiû‰ýý…‚‹ ²„CxpŠmë»pŽŠNÿ|ì$âuÈH@¢ZC{¤ÿ[5÷ÓÆþhø“ÿéãSÏãýiäp w@„dôú }Ÿ@ Ñ<†BHÕö¶JLF~2Ój~ØO°;x­þìœÁq§{k †ý~Pâ_GðúR‘‹k²•0<ûݬå#A¨!“J^&†á§½ÿGðúR‘‚«›l`PøŠcìBéüg ß\õ‡±ŽÞA[”C(R÷¼›{¾øýGñ"g Í"§FôÙ´ÓÞ²3X qõ&°(  1 ±1SÌÚ0F°L †QÓµ6½žâ)Ž@óGÒr‘éÉ…s%º0'Å 2¹ê” *^RbœÍ£€4)"·Æî$„n…²4Òà€\B¬  £A‰I+% {oøuÄ[iƒ@CÊÇIÑšbɈN^ŒÒ+£pœôn%îH`è ?Àô8 ôÀP­¡ôºH_)ÿ`€Fƒïó‘!)ùv ¡™dϤmŸáÆKÜë$ÂÀ&n#½‚6±¡ïSújp z=vµZêg>@ #Þ’õj‡Õ.8]r­g<–¬á‘`cÖa cð5ÀÕfXði*hÐhÑph ø#JzÈ4 €ö,—YoâÉv0C¡t5µMQ ¤ä4ž™ÒðfFÀrK.꺶 !8ú¢»ô*¦p z4k®€B‰4 « Ë#Åšoºo6çj–„P}kÞ»=Bçƒã ê©ÄêУ#ÍTÚÚ¨£×Kö.§™À rmz½rä¨|…  ” ®Œ6"YULñà-.„HQßm`-‚¦pÚ¿ðˆ \?évû€¾¾`-€[UH—´ç®À?¿A›K¶sJ'[Ø}‡ÔyX‹ W'dg3{íWM¢1Ñ,W#Ô­:'RY:, W$©»%§3½`ƒ4Ð>@Ýë!çx€bL„Ÿ³Qü=ö£ëPhx‘Øi¬é@ÿ€,…»D\$>`T @’1$"÷g: A2n¡œäˆ"A,Cp @tB&‘À¹Üfߊ€vÔ (G=@‹èá%# k;Üa<0É €lô¤ A7€€bÀà%ˆdÄ”cýb€€R€Ë!„¤Lá£5(ÜÞØLC/tBìXÊ@’ó‘àÔK$! +&á(õÈ—`!¨š€¸¢a ˜MYIÜG’”'¸T_ - IIØ^¨pÒ!4$¤Í– WWr¼Ú?ˆ—Šßó±÷l/x` ƒR†toÂS²ó‹Q×( x €0¡¸Â’F¾ø šüP T T1db Adº~ã[íÔÍŒˆºlà0Nà 1@h` €b‚K¶&W .ãÕÄàœC +ÀCùx˜ÃP4×ü@4&€ìP(‚ÒCF–‚Ie€ y¬³`@,d0Ö©àc~ÖƒÏs”äZm<P(ü :0R{e³ó ¾+€üÔÓ˜Oà KVü7,!½À?°¨šM !÷ JSÖzä`°°tXtÿk,Ås”³'ôð'Ô¥€Ði·àiÈô,Õšiü[‡RÀŒ“Tp\i:Ÿºy½‡/œÂÅŽk³Ãý6Ì,0š@¡cHI%ûÁð h€0 `ðÜ(i+7èÉ”¤¨q‘4¢Q¼P¡`v!@Ânàd1îѼ`*vB &îaed˜a·I…P&À À.è(dÒÍß’Áøð`@K€ @=;FÅHiFIHÜ¡yÞ€`€~‚Þ„a9|ÀÁô41Æ:[,  „€ûÀ`Lɶ  ˆö¸P¢Ày‘›8L,À@€-v`PH‹€T‡¸io²\#¸ÿ΀ Á ”˜P ÃI'$5+GvÎ?@X”³€:éÅ”JÿËÐ @˜,¢ùy\gÉê€ €6xP¡¥Ø#^ ÀðЖBOÀ[38ô|e0t` c+€Å)&’ŒýÜüE€©d!‰lÉ A 09IB žKC‘Éðd€7Œå ›ƒÐ•²@¸ fƒ#–|ÏÂp|B!Àù æÊNø´ u¬U0¦`À*-‰&Ž;À8á‰ØdÁ™ß²:U„c¢à`& 4 Âà +–•@ÌOhå ÄÞ0ÞRR¬‚Ð3¹>ä`|ƒm\¨ĘPi0½òqâjs<^Ù(Å£Br¾4]=)íP3è‰He€ W'¦øHH&x @€èLð Ò”; ÄòSžÈ @8f`ÈCCxÀŒåÌ’Ìl ™À€dÐø` ‹ù”¬WÀ€¸À'à ÁÀëpÒЙÛê¦ ÙCñÝÜ€Dcì{pÀrÌ (ÞiäCŸà³À; Y€2‡ÿÈÖ8ÿOà>XX ¤Ž~E'ùì[ý$؉OæŽ ppˆó@hê1gðÂûŠ§ñãà5ÍLçDDb}<ÌÀ4}9OJx;Y¹€i`?§˜q­J:–°µšâ-Al _öÍ<ÉPàк£#ëP Ì…:øŠxíaÜ@lÕ-ÁŒáF@Õ<Ïf2C¿NPÞÖ$Ž8ŸAâ€Zôó!ç‡Å”_ Ahÿtw /=Ë;¾RÝð÷§¸08q˜ €ˆäÐB,áˆe* ¨ yœc€o  ìšØòÆ`2îð _ Üa0¤¥ θÀ€r©0$$˜ø$­ƒ@%:â<½Î‚½h@1(šVîõ{2æPi/dîï@ê‹x·¡@3“¯Ž¬ÚGÚ }¿>“` W' °=ͼp€ñ©C“¿ÜÎŽäï}è €a€‚P WâÃPXig‹œ/ßÀ´6$,˜’ÒV/ ã }ÔA¾¤ ¸ð¤¤–@cúðòû®¡qÿ9KQЄâDn}?‹0P5kvÄ@ñÒ»êÇ€ºél?<&Ÿ×í‡É] ôþ=¸åÓR Ç Öwqt$Œ :GY”ó"‹.JϤ_øéBˆÔ8°éæl¾xõ‡…Éî.¤iré\qžaêÊ ªF¼#h?C@SÌ¢|#‹ qàæŒ,¢iéKáôð$¥2õÄsä ØTêãáêQcéàQÇÊü*§4ûzz4t£¾ýÑ÷q@R ”@J@hoPÌxèárwo’ŽÌw6€ìà+€¨ yIÝmÏ£ù@¥àÄÕ`Ð q5kxy@0`” 3ŒÛ/º,RRzKÜãnŸ€€4ø4½Ò†ß¹þ>|õÐ4‚Ï…HÐÀÔJ›ª´ŒÆwÕà;©?¤Ì\Äk1©L î<*[«x˜CìR@Uèù ÜšC0E$¶(jR„3~Æ8ŽO½ W&à!jl’“ÒXj8Ö^ÿ¿äW:à‚x 8`'HÜ_%oØ~u‰SÝ@ž €“Ђ±5iÿîÈK1øsOàˆŽ¬7£L!CÂÀè]?ÀhXAaBE ¡CÀÖÇœx÷§ôÁ‹þ°ÀW6";ñÖs‹YØYЪJä“Œâȱ ý,wOãÀÝŽøFš M­ð¯ÿ?<:À8Pø @5'SQ!î i qáZ™Äƒ‚ô Í!~ΧU6Ç0v¥r¹WI0Xb{ý–~ü@ÀÀe€\²a0šZPŲÿ0¸ C ,1l5º…@€¤~@a7§3£“Ï"@ BK¸h8a{}ׇãÚ€À5€ 0!}âƒÖÝÇA¨ßÔ êÄk ;ë´€”I„¤fùB”«ŒWß["Ô`nNKãð¥Z>vä$P‹ IÉÆÔÜžÉ*šX& ßð¡áðY„ù@ñÿZÌšï«·“¨ÅÈ´ú„Þ’#Ñù°@€LtQ '/ä·Ær2ï¶8 @ @B0iaœ¢j[?ÎëZÇûàæ³^€ SÊJpI‚‡µú)€Äà8Ø¢ñ-%¥û¯d¨œOà/Z²øx[!J?øK¾Ÿ wl<| ù“Íd-D~.žÝB³/ý8DpŒy¢@í=£Ž` Øáäù"·aÀ>sèÜ£Ìpé!ôó2wÌÒ–à,²|:éê8Œ2,sàùÍ[…‡Þ0ü} < £ñì<8?ˆa˜ÃÏ "-éù¬N¤ÜÒ°ý€åsð– À4ó >iy”O¥ñó$­ag¨Gó@@\©!¡)^ý.*óa„z@^¸°(©Bqß8ëΣ6×p Z›–ïÐýÅÞ˜ +†J Ë“\o)ûžº““vpŽ ˜úi‡Ð! }Âkj@3¤ïõ`trCõ 6!%š˜¸ @,8 @1P`&,0²ÈcÁxhOÇp`@ @@Á8ð á…P‚ƺRìÉ~®s+1Í΃I„Ô ,¬œ."z  ÷@@. /|ÊÛ|ã»L`ÿ5x Ø1…‰ˆÔGõ>)™ðáÔ›f’ŽËP Q¦ ÑË€þpòyO1.cè€|¡pþk‹¡Y²iædà–:hµçsl}ñÔ*ŸÉçÔr” ðP}<ÃñÊó p‡Su²‰ÑçnÖôôkQÀ‹çB;ü8úM,FãvøÖátÛö€8Àû3˜ÀÚ?N@É ¶ç(0!€9ˆbzåT°4ȽО‡3{„ €RlÀÆ|ÏÙwÔ€2*!€'vCQñ3æ­b#ßr€ @bF´Òi_Lëp–Hƒˆõ‚àh@¨¨q@2!„7ÈØáÍjÅ#c¶ DÀB` `& aAˆB6 dÀ0&hB@ÀÀ(„…m«i8ÊMâÜ W'•"¶iG#€¨ÎN§£ ;€}=È”µÓÌ×è¬q¤ú'7ý šž¤¼!±§ˆ³z£…É6žf°ÏTrñ‡ƒ ’)@tA‚Þ…ž¡Î%Rejz®xäà¹$Xîy„ámç§F%UàÐ3Ð¥qŠ“@!Ѐ^MÄÀ à<ßíœØ4H`€XDÀªÈB½Ð=öV»§Á<~ñ‰ñiÌŸ±Û¶¸Âs=*Ôä€b¨›y €h11½ÅN ‹@qËC'0``` ø 8nå€÷c+HÀ@3TTBÐ'•·}ûrÌÑH!Vd)PÍ°ÄÀ€ (‘3 Åm”Ä À@ðX 蘂²~ÙÃë1.¨ÎD ²À W'¦ée£‚Ñ€!Å BøfI/ ýÜ­“˜|üÒ` CQ¹1,ŽŽßušôÔÂ`ð KäßË(jûï±=‡\I SÓˆxãŸ< À€X €jä¤À`BO HJj”;;@F¬ÿ€À44¢û$cº€ðæ i$®(¿ìg§ 0 %8œ¨,xÆ)küÑ0 @,‚Ð +p+À0(1†ñ™ ™»Ÿ‚„@C0Ð4€é9 ‹Û$j}·•L‚ h @ÄžZçš €€%ËĬ¨4€(à( J’5¾ßㆊ'¼€z -I —уœ5˜hÏŽÆL29íGîÁ¬0@5`”$ —’†ø”î¡r€`Ã10 pѨ¶AmÏ "ð €hà 2Åp*LÜÔmÛ±ÿmÉ÷›. À@-pQH,ac:†•¹¤V+ûƒ°8` {€f¸2@ Ü`€ xrWä Ô»)F¼àp `ÐÐ vL‚RÓɉ)oÒçãø C, @!‰€€@Œû`Äa @!€€ÄÀ€bJ0!{!Ë°c|žU<€ A €T’@3&#€ÄbJ I4aa=nÍ„@ .ÈÀÃ@©A… GdtØ÷X+øšRxiEüBÉä¶"IK;TÛr)¼GYMèàjF “e€ W!ââ!ÁÆQÀ.­$õ™­Ž¤DÈ$5ÐNDèX 4V)KG|͚ͣø  ÀÀ=Ë) ´Ä À&!wÁˆq¢‘ð±¢` R¶Œ3U@¶ƒ“mãä lE€<¨ŠK'e€ u}wƒƒëh DиæY1Í€ÜôÕºEVéRVèžÜM‡qº”<?ë(!‡¸U9¸>è-‚µW&ìë"ÖD®[P}‰Ž[`)v±Ö«Ui…MÚå°|ZαUÈO."Îþ´bx¡ñTp}$å)3• ]5Dw%õ¦‰.)ët°ºÈÒ<¨÷¬úȈš&'U:=Jñ!7Î0Õ=}–"¬u\¯¥€ Wm íl)@?»V!ýé/YB¢xT 20ˆœN¥tnÉf:²ªMNýê"py¶g×[)Bn´Ñ\xš©,œ W6†uÇ€²©’b`û¥q›ˆÒéc×jÂkj/®Ð|x…ÇÂÈÈ•ìÔe©kºÔähÿå."V „ ¹àDD¡çDðúH÷s×ÔeÙzªì¹/ú׃ çÍe&wt>ºE«85AwTÅ;ÜÁ´žX Wm´û»""b)\‰Èé—"S5sXŸÍU ­; #T²tjÈôú\° W&¥i7e™Ã­T‰HØY¤×F,È*ûDØ i7,Ɉˆ \?évû€¾¾`-€[UH—´ç®À?¿A›K¶sJ'[Ø}‡ÔyX‹ W'dg Br zm!Rš"£r•\R´èœIdè° W$¤@Ý7R¥´ó¯¹už¥Žªè•›ÕÔE0䚤BhòJLÙ` WWr¼ÚÞªîáuÏ2a`;&INÂx‰ˆ¤ÂÉ Ü?\ ˆ#ÃK ,7¹§‹ð @4!ð(j÷@j `À.&€{†;¥;îØRŒÐ *–à@Pò‰ ² Ü´?ÜçuGðþ¢Y ¢²þ×·zà€f­ò†„€—6cÞé„ À €NMA0@Tk§ j;ç0çsƒž"˜, ˜Z¤"€.#vB -Ð~žWf|§`øð €vP@¢RM,f ÃBRqÇ< „À@±  €@ÈåLMH¹4šåýѲ^Ö=‰×‡ã÷ËzJ2wÃóH/d””}—¾8z«fa¼fÞp°ø„î[3î½àÀp¡ `¶ÿ+;.!“ðj…Ä0ba/bol<ƒGñä‚  ì”í(` i€€¶pÔÛÀ‚¸ŸÒÎsýò_w1µÒvÀ8Ïþ(šXÍÆáœ;ïs@ÀÇlQ Ì}®,pžÄ •“ÌéØp4ÁÙ€2  Ãn’gCwc¢Àb’ƒ~x` €0- ¿”úB Æ,<P ô˜^€ÐÂýœÀ&¸*1/%%rAgîÀ¨ð@€€äÜYdÄà,zÓ}Æcw.x ;l·8Øù0âi4¬€c€`MNt–¤®€;^>ˆCzÛÀS 4žmð€’JøÏ­©‚à²SÚ¦vZXª@¸C, W'¦ìµQãø}`à'@ ˆE–ž¤oªÿmv5I€À €N²ËÅ Oq»â)¡ð@€4°@:Hˆ)(˜B á§qŽX÷\L@ ð`XhHàU „àgdd1Ç+|`Ú) ° @t`*M0€bPê% ²ZQØ`ì¬â`@)€ ƒ`Ë)Âxú`l\ˆ õHI–ÀQÉîI8v€–¤yd`àG¥•²¸NôbÏà5…÷Oà!àÀ/, €„¼ë°+Ö#¦&òi4µ$šœ®Å–ZqÂý3œA‰ôó3ÐYö<å=(QàHíf楀þžaƵ(êZÀÖkˆµ°1Ø4ó%C€^Bꌎ?­@/2ëâ)æ,H[@x œÄÐÄV’™†wQîm‡pq³T°e‰€T PÎPnts:Ø.€ À4!fBàP £r’¦ÃÅS€Ù€Áð唀–WîÌøwÇ@~PLPž(šÈû›†3 \Ð,å¸j¡‰øÞ£ÅÀú` €€dà3ÐŒk™‡À&àdÀj Q4ŠOGÈì[.ZL(xø€Ø ‰»rR¥+Ñü€ra7ìK<]”ÀÃy]ï`¼ðÁ¨ gl•ž×8 3+èG-Ÿæ~"ô©A¡ 6!¹I•ytQù°Ääç…¨€”줻Ùwß\ :!”C+%ÉÖ‚g‰™/!^$ æëaKzÇBÒ@oÐ2gÛñcé6 W'¦éiø"¸ @$` H„,sl `h``B`ÀlK W)(ét«vâGˆ€ À!!€0ï‹ùjð ‚à I$ €3¸@º‰½°(7 ä”›øl.˜|†I¥€ì†CÙ5=!¤0ÒÉ¥¥+éHo%§ð¿t¶žOëŽvÃä®…zÜr€éÇ©c…€ë;¸ºFP#¬Êy‘Å%g‰R¯üt¡DjXHtó6_ŅǸðóF Q4ô¥púxRˆ™zŒb9òì*uqðõ(ˆ±ôð(ãÀäìÐp€<¥“ ¥í¾;ó±ê2¢ÐÄàÒ’”%}þkz?’€À :(¤ä¾g¹€0Oåg†0G|Œ"¤ ë@ €2àŠ%ÙQûúàÈ!Ç4BBä% ¤.BÆŠ©‚õ-Iý&bæ#YJ` î<*Z:06ÁA°P@+ „þ(1²§œ TBÀ’°@Ï _‹IÛº3Œg4ÝÜ/x²ÃtL-y{àè¸0šz¤œ!†dý’Ý/±ËZÅSA]pbÿ……¬°͈ŽüuœâÖvF4*ŸÒ¹$ã8²,F@ÿG Óøð7c¾'Q¦ˆk|ëé|HüðëáCà8$ÔMD‡¸T%¤,AÇ…jg Ó'4…øG:TÛÁÚ•ÊåW@W:i—4Î]’$>U4°L ßð¡áðY„ù@ñÿZ̘ú®žÑL}üÆÖg‹¤ÔÖBÔA€âéíÔ+02ÿØó„GÇš$ÓÑŠ8æ }ŽO’+vç>Ê<Ç’O3'|Í xùanË'ˆÀ3"Ç>‘lÕ¸X}ãÁçÐ1ÓÀÑŠ0ñOÃÃø‹A059Eq8Ü=X|t—¦,XîçqmH$=w›0úêEHåÙÂ8\*cé¤8"B@„ }Âkj@3ºË~¯½ëm£¼RwnG°àêÚ¦¤Û25·ÿ³oÿ?c YðâúKJÈNféHGê`põ÷@ À€BV~ЃÂ?úÀÀàˆ =€1À&HiH, ”WID Á£yìs¾4U²©±—1ô@>P¸1€¨ "‚™0^b€„‡ùd¬^&âœõþ…@ˆÁ<Ï&rhÂHJBUÎÏøé-ÜسDQúp A4!€ 8°o~WÙýÎ×xÈà  ; 0¾5úù£°]ó€@* P\Ph @¡}9A=<ñ_o:à€6}É  +­–QGed¤¦¡Ÿë‚ÀhÀ@ÿt ¢ˆHÔâ“ÿãÐ4ÆQ> €À€ÌÉa€òiî4 çÃÂcÅ5dP@ð@ Ųö4ñ SØ€š(Qe`ßöîO€´ÈGp ‚É`ˉ+ vøoÃÅ ¼` ‚` @`ÍŠHGP­¯@7†11ÛTÀÀ O±)éàͧŠÚŽÐ@,@@LB AoöÛ,uÎG« Š!6F«C2¥•*›¼ÑÔ=¬ t=ñU–a:¨-Åa5¸ñ’L²5m$ã)7‹r4 W'•"¶Ø4GNHz?Šb rºnø.ê)ðÀ Ëé!†!;»îÝǪ倮&äÈßGÛÇÛÑú0A@TéÐ…û»ðÄo:ç€2°@ ¶@`ƒ·vÅl Ë—‘µhÈØÈÛj=@P¨ (à ˆÌͪI€‰˜ ¤`ê¶ÔmX0TˆX1´ŒŒÕ„‡”2Um˱u'fC·ŽkÃÚ´À†»ÉŽÍy'¨?V‘­FR@¤€È&Ë W'¦ée¬$"‰ »–”r}žÂ«ø@NRRÀ'66ifÖO]Ö]Õ lô¢WæX! Ê%è3—‡À:Å ˆ@b¶|I!íh~æ@S·2€mX0K¦ éY¾FñX¦©ÜŠoÄVSEú8Ú 2 6X W!ââ!ÁÆQÀ.­$ôÁ.oõú@˜$Ùú¤­¥‹¨ŽÌ–}Héå·%±ò¢),– u}wƒƒëh DиæY1Í€ÜôÕºEVéRVèžÜM‡qº”<?ë(!‡¸U9¸>è-‚µW&ìë"×J àªÄÇ­@GÚÇZ­U¦I7k–Áð k:ÅW!<|¸ˆ8úшà‡ÄqQÁô“”¤ÎT ]5Dw%õ¦‰.)ët°ºÈÒ<¨÷¬úȈš&'U:=Jñ!7Î0Õ=}–"¬u\¯¥€ Wm íl)@?»V!ýé/YB¢xT 20ˆœN¥tnÉf:²zA ¥S¿zˆ¤@üÛ3ë­”¡7Zh®<ÍT–N W6†uÇ€²©’b`û¥q›ˆÒéc×jÂkj/®Ð|x…ÇÂÈÈ•ìÔe©kºÔähÿå."V „ ¹àDD¡çDðúH÷s×ÔeÙzªì¹/ú׃ çÍe&wt>ºE«85AwTÅ;ÜÁ´žX Wm´û»""b)\‰Èé—"S5sXŸÍU ­; #T²tjÈôú\° W&¥i7e™Ã­T‰HØY¤×F,È*ûDØ i7,ò© sp.nà/¬À[¶LÏ°êú£€P5Vø²…btúå8 sfdpðd?‡ÒŸägý°ÿZ 0ÉàTá… _߬=[ñ‘ÓÕ¿GU.˜0@­@ã%ˆe~Ϙ½‰Ì÷L˜ @<47JE†d²·öâM  ˜ɤ€Ä…5€ìšH HU™¥ì`¤ÀÆ$š„nj>Ø;\€@@°€ @Æ,4¢òqîµõA4à HYÒT@ì™%W@:Ø` Iˆ&“5 Ï&€_6!ñ«D਎ {”Ý]v£ø}(”äoÿm—ÿ» ˆ  ¥ hÝ;ýñøu‘„XNAHÿùEÓR?üu,èð €ÒHaˆû8ÎZ7 þí° I6\CE†'£FïÎs;*÷ zÄÐÀvN“»a¡ÃÃ̽xh UfÐÜZ{¾$þïÄÜ€€ &²I¦ãŽ¹@0(,›²C\CQüô5£†¤5€W•›’¥(yêz @€x~K-ÀNŸ›¨ocv4A׸r@1Ùiü5+í ;f²o$§¹¯î@À…°ÁW è…€pŠ?2Ä&À1ÙiN‰kÜóCÚè€^ÀRÆòa|ƒv ¤ß¸Já€4¤?•ÜE`P™‰ ²("f$bu@@¸ 0²¿!¤Ão  v@3,„RHiç3ÿǯ \`–VÈHUã´ €BB!’19SˆV€ H@0ÀQ$‡ µnBÖ!$ç£ù %+HÐb‹éà[|çf×*삨⠀a’Z¶)™»¯5ÆéÚõ€C‚c{Ô>؆‘‡MÂ5SFÚ£8 vج¯êáýÚ%–Q1²ÓŸÿ§#ûl¿ýèA¨+À``L, ‹CäwãV4@¤@P°—Š+?ô@(XËÅŸÑ€@° P €@²-5ûÿÛ~ÌbÕ}H,Á†ü†½ƒzú[dóx¿æ Ð@©Ø°*w!ôÿ.õà @À3,´äþÿ›y  €¢²K@Ooÿ¼à€ ’”/³½+%Ø Èeñ©ãxûPh 1Nøoy@0À44çGX«Œ €„°%”„ÿe0û”°ÐÀ ÌÇÜņ†ë-³QõÀt  €Çà,že¸ €B†&ó9#Þ A ärÀL^VoÊwgcï. €6‚E$ Šœkfa^èh€£â^q^Üàà:Ÿâ^ôQd €€Ÿdà(_Í€÷6å*P ÀNŒœú°ïÿ¾N €:ÅÊB¶tdnÿ :æ€\À €.È%€1=·èØ®€‚§ÿàÄtì5ÿà[Gõ@) qeÀLœû(”`ó¯ €Ã€ ˜4„3¶ÿŒfacÔ»Ê@€&!|J„Ä¢ì'ïÉõhB Ì„daÛm‰Öà!N°ﺷnp`;Žû« £´Ð ÀÀ:A3elÿiCKJ$>) ß[ ~ý~×·JÇÔ+^=q×TF>Î¥GTøTèʤ>j@Y6—äp t?‡üþ›m©0 Àbi 7² GOÛ~Ø*6ÿÆßú>€ ]‘Ñiåì”~ÂŒ ÷ÖÁ`+Àvˆ`U‰½¿K7Qä ΂  ZHi!“ ¿ŒZÇUõ@ÑBxËJKýÿ6óÀ d‰¥¡=ÀXÓb^_£¸HС¥ñ¯ÿæÎÐÁ %ä0×õ€é ;! ×âo0 €zXðŠè1KçÜ@;!”`ÎfÚãÙ  s¶Ôj€€¢p¤2À$±¿ïÈ×ÌÁh@ b¨²6)9;;í”u”A @br¶á Ûfý™œH«Ë@À¬Œ„c5é€-JXËH`b~Ù÷úô@€), ¥%'ì½þôv>Ppbbt +#6퟉õm¿….®žžÿ¿žÿ¿Y¤Žlâ5ª°@#j™T×BjäºUÒƒê½4ÛÇŽ©ÁURARêIj„ ¨¡õ®µpp°iÀ t?‡Ý`@§%(Ѹ,0¾Im•òÇÜ›ÞP iraDÒ`aiÃ2QÛ¸ó‡k0@:=‰EïìÀë€ì%-ýÐÁx4€¨à€ï$¾œ5!np½` I¼ä>¾ïsÁ š@BÔ§÷éáöÐ@:À;¨lïï"Ñ ™±—¡3BS6£Ààx IˆÅtºqƒýò`@‹òbp€NCˆ†ü—Èn8;.ö`€æÅ€;Äߺw- c—ˆ*¾2àÄÀ@P !Ñ¿ϲ‰Ïv€€9å` Jøîa·`8¾Œ JÒ¡´L!ƒtL(„LF( Äd!6U‚àOhÿاˆ–Sr,V)g…ØÂÉžÒ†¡‹Œ°;:Š#vŸSK¨Ð T˜< ƒ7%ÔòÏ’ø€Z0sTø¾î¶E•Ä'GV@?1œ Ç€ìÝX'QüH*|bh…'Ž'ßZôð ÀB’Ÿ†¤=}nF¾TBÃj1Ý! =k"_c€Âi4 1å’ß%&üŸr€d€ï§˜Úæ( ɽ °@ ˆY Óá"‰õÓÀ:­½Å@€Ã€„à Aý¬ý[¨Ÿ} &4ú@©h)=?¥M|Çíóñ:邘 €âË +%)1³®ÈÀ|Bh×mdè^×£ûÀP@WÌJžam’¸ûÍ‚À )Ä *”gG^c¸ïx€‚ä2ÓÀ¡ß¬`ã®p ðiI )lŽv<@]ÊÐ2B7Ds„ÇBæ1öp@À@AD#€ 1 n€Œ…¡›¹:,´”ùÄ )BÔÄh°Òøii/þña¥ðÒÒ_ýæF ÃÁn£ø})H‹@B-%%bwBqû©¢Ê &ñ…$¾ìÈÃHÖ¨.ÁŸÍX$³Þ¸$vÃé‡Ð¿\ˆÒF³[˜úŽ mŽƒ€Œ Þ"²€='ÄEÖÈ¡Õ¾­ä1û­ Ë“ââpê¼5À!Ä4Uˆ’þÁ>öðd…Ø!5%ë¯ZÀg4ÑÔ=¨ ±sÃÕ¸¬&¢$Ë#U'4v‚ÉðY>œ q1s U”‰ÖHðdß÷õ—bëFÔÓ€Zðö¨×y1À9 $àµêŽSQ‘œ vëÄÄrù×Â{IÔƳQÕž»¬åÐ k½q3*Oˆâ*8D…ú8Ú´(:G v‹ˆ‡Gº¤€ÝÕlt›æ¬X}lÓ‰õ#€uº>$|-ˆ°‘ ß\Q€Œ­ª9­€SÓU"ªLŸš„ÉÒ\M‡qº”<?ê F£Îh>‚Ø+IYª à¨¶&8u@GÚÇZ­U ŽŒY>­K"Bª&.üDœýDœâ ˆâ£ƒäçN vÙ«ãR➤DL.©MYõQ¦Çxœ;À3Œ5 úᕺ·Ó€ z*ª¥þ¦p Àä8ƒ<¯P¨Ðú‰ÄêàòÜÀg º²l<Ò%lù,ªêÚü"¨®<ÍS8 z4*ê¦ü"îÂÁ°j b” 7h«Pb3ÇÐ ¯‘+Ǫ;ºÅƒp Yuy¿ùKˆ• xlÃæÙµ,yºª‡G@Åÿ^ `3Ÿ4<“iuE«85Au"€!q°xÌà zÓî>²ÄÈÿàcÿ­Óm«kõ¥Ö…VˆÒl}N<ÐUtùœ rlñ@Ö`.¸%løDPês£ÅŠ›þg›@ˆ \à]'¦§Ì° iT®ÉÏ\ 5ñ \‘¡ýÅ@/N¤yX‹ W'I¹%&Ú€í‚T²ê0;*‘9”¦‚©\ W$¤n›¢)"šyÓî]3Ô±Ô®D¨ò©™¦‘Tª–Se€ VÎW›gjwpºE‘ç[Ó›ÿVÞ‘͉t°pº8^¬œÎºÝgV‘5@S´‡Ìô€²fZXªGe€ W'fZ¤y–å½)Jï¢uM]èUÍ’?þ=îKîæöØ€[a÷q[býûPòu¤³šWZ’T$QÄêgHùü°àRÀ W'd²yJS¦ì‰ÿ€ìmg*|me)…AUæ¼efi Õ)âÇÜÝ2*Údg)M=t“gzÌjLÀ w–GF]ΤôÝ%IÙÍd}e[ÙO#£P.`7P™t¥&r®R’k¦ø {¸š=>(ŸMfÌ}­¹<ÑL}°¹‘œ‚Aj"¦vã‹¥Ëú‹ 8d „#͘} ô‘Im Fç8,M!Á -±ÁÐp€ û„Ö”•tÒ¿Sï{¶ÜDƒ ‡]4鎤v}Ÿ\ ¨‹T镾Š¨Ž\óGPöåh~¸Ö,àt¦ãÆI2ÈÔÚIÆR¹æ…“à²}* W'ERNOIòÈþZƒìü–G³;f­)p€Ôœä;xà¼=«hdˆÀby=p¹[XðR3E€ W'¦ä²uÒ[¹ÃëÏsåÖÖ÷I9ê€eIoÀ¢u#Ȳ3œŠoÄS)¢€}íMèPu&l° W'édÀ÷M$ôÌÖÇHûõ$¦ÒŇÒ#™’ϤŽN›F©Î€<¨²Ñ` u}9ààû´”;ªæšEStŽ¤•œl>˜eüG —Uäü%š&â}+‘笋[„üèTëR‡ÒÀ}ZaD‘ÚÕ. lµ9 ãåÄ@ÀÓF G€jÅGÌ¥&r  \š‘侑šÑZ@gMÒÂ鑤yHóÖ}h¤(>©Ë”®C¿€‰Jtg2ÄU€©ÊúLÀ W6B»[ÊPëp7rÀ?…P1ÖP­p:€ÈÑâÉôÓÁä MÕKE&SŸ½")3“ÍO®›)BnéÌ7p9=R¹8 WnWªÉGiî>pX}Ò°…aAwp3ÿÓ5‡ÞÝÇÚÄ.>ìZõkQÄ@Õž@€]YÐN—¥…ÂÌ ˆ ŸL „ ¹àDD¡çDðúVÍ¢ÁðW¤ÔýU;.E‹þšðcœù¡à,¥sè}dÐ*V– ôÔSg ËÜÁ´, W7i÷ZT"’RNGdŠMÊå+=3èUÓ'XÔ–FäJF¦G§Òy8 W&¥i'2ÌáÖªU#af“`Àp:"€w} À퀾ú•ÉÀÛyhˆ \à]'¦§Ì° iT®ÉÏ\ 5ñ \‘¡ýÅ@/N¤yX‹ W'I¹%&í!8_ ®Ìç)€kk^'©²|ê.@ kÄÀh<¡Æ¬ Ú™ìYÕ¥Ÿ"Ò©‘ÙJiÑ8*•ÉÑ` W$¤n›¢+lNéÌ8ŽF‡‡¯0åŸb-âs‰ñUÜYÎ~Q:`lUxxU£ð©$Qbp äט’x"\@ ¾õ€Î”)B½y‘«’)\8ðpñpõ¨y$À6exê[€w r(ŸMfÌ}­¹<ÑL}°¹‘œƒ‚ÔELíÇK– õ@€ÈG›0úé"’9Ú‡NpYšC‚@[cƒ à# û„Ö”•tÒ¿Sï{¶ÜDƒ ‡]4鎤v}Ÿ\ ¨‹T镾Š¨Ž\óGPöåh~¸Ö,àt¦ãÆI2ÈÔÚIÆR¹æ…“à²}* W'ERNOIòÈþZƒìü–G³;f­)p€Ôœä;xà¼=«hdˆÀby=p¹[XðR3E€ W'¦ä²uÒ[¹ÃëÏsåÖÖ÷I9ê€eIoÀ¢u#Ȳ3œŠoÄS)¢€}íMèPu&l° W'édÀ÷M$ôÌÖÇHûõ$¦ÒŇÒ#™’ϤŽN›F©Î€<¨²Ñ` u}9ààû´”;ªæšEStŽ¤•œl>˜eüG —Uäü%š&â}+‘笋[„üèTëR‡ÒÀ}ZaD‘ÚÕ. lµ9 ãåÄ@ÀÓF G€jÅGÌ¥&r  \š‘侑šÑZ@gMÒÂ鑤yHóÖ}h¤(>©Ë”®C¿€‰Jtg2ÄU€©ÊúLÀ W6B»[ÊPëp7rÀ?…P1ÖP­p:€ÈÑâÉôÓÁä MÕKE&SŸ½")3“ÍO®›)BnéÌ7p9=R¹8 WnWªÉGiî>pX}Ò°…aAwp3ÿÓ5‡ÞÝÇÚÄ.>ìZõkQÄ@Õž@€]YÐN—¥…ÂÌ ˆ ŸL „ ¹àDD¡çDðúVÍ¢ÁðW¤ÔýU;.E‹þšðcœù¡à,¥sè}dÐ*V– ôÔSg ËÜÁ´, W7i÷ZT"’RNGdŠMÊå+=3èUÓ'XÔ–FäJF¦G§Òy8 W&¥i'2ÌáÖªU#af“`Àp:"€w} À퀾ú•ÉÀÓÉy sq`Áÿ7eV`-€[&gÐÕ}P *ª‘®4ƒuYÕ>J€<ªC¦¤“hÿäp tœŽ|9Çn ML9™ö·Z…‰³Tâ ãÍ„Y¸)yϱê Ô h;ÖÝÇØ :¦ ÃŒ`-‡ ¡Ü»Gý‡TI d«î±5¢tœê%UÁÀÔ€[ÝAÕ.ÔËG)-ÇDšÈú”¸\ñ ^»„‰ÐQ:5!dúàp ±d`ãH0ð¢< ]uغؠëŒ1p`Ð €/_B²PÇòVqŒk¼¨40 ô™Æõ6Ë€BX䥕²R”¬ô°¨ Vø €Ç§Q‚WŸÈE²z2ˆ4€© ü[cìy€ Š ÀQz1Ð rÛŸà@6H¬ðhÀn…aøt°`&HJBI¨ÅÏ|A€cÐ[–èêx ðÂ÷K áö‚`Ò€4%¿ÅtàÅœ[„žsaoñ`:‰0 €0äÀp‘j)œ¿U;¿1}…2£Ýbäèù¢`¼aä¥Ëù8Ä’¯w5œà²=GÀT>€| 0 Ü&²Ï0ƒà4[äŽuÊ` XqiC÷BQØͳ¿á÷܈ d^YÉ)p¿|-`zT|ß²>lxJ:Úûx K2H 3ßù$”ò¸A´7nœÛˆ ƒvßÑúÒºC¼Ð /^PДð½!7 0 ‡‘n (€^xˆK÷ÉCâ=Âz9`Q8~"\ £–BHaะ À @N¬ˆZKÄÄ#p“ؼ¬Äû燑 @Tà0zLL&â`b[ó6fÃ'@T$ÌB¤Ð͆l_P{ÀT%Ø “JfbúƒÞL@Ĉ Ÿõpò< @1‰ÕÓ€Z>º*´ M4uå@çÁõÀ a€.Ú¢”l>ª@[4v€\ Êp t?Š€!˜ ‡£ögv܃}€  &frò0jH¼á÷Æ~ß7;Ÿ{à@€k^œM&ŠJIcSÛ1îs€œ Œý†ÜàbP r?lš?´€3†ÐË|ÌžG²°à““ó'sÅÀ2€$' BQÔŸ–&Úà8U þoy;âN"^[â{ê?‹¸ eî‚4¾œ‘ˆËØö kÀo¾|w:û˜ 7‚h˜ †”!£üçœ.øÐ   @Bh`jŠÙ8kþ¬¾-wªZ‚@t¾“ùõ @0H¼7 !'͈öUY\sV‡ü&€*FÄ *¸4ä2ñM¸ÏǵíÓöÇþÚöéûcúµÄÀNx A¿!“PR¿oÖ¡U¨)pœŒOíŽ4[ÞÌ0X@0!†£ÿË^K)y®¸ @!Ä%~œØ%ΰ!&!†”Kù#ΰ!,!†”5“Gòð(M ¨Z @ýÞTozp@F ¾¯ Ü4jÆžO¼ÀˆhÙ0 ÔZ7Áö ;Ñ`0,bm@v¢ÀtXÄÖŒ©£àóÔdˆÀby=p¨å ‡€²3€ vèª?‡Ý`@§$((Ó°(0½”û«õÜ™€NÀƒHA¹ÐZ:8~ùð\ˆA¼„‚ñèï"o&‚ñû½ßx €¨À€í%•Ñ²R`¿zÀ£€Àš‘^ù @2‚ù`$a¤ÀÄŒ_q;ó¶õõP 8bZ›óï@¸à:GwUä*ˆ‘ÝÕGP0Y4Ñ ¤ ´¡¾6ù  C‚ö&@`bhÙÆoÒ“;f<(ËëE¤¤ï¹·T €.Ì„ZR‰Üö;¼€€<(RQòÛ´€€>(RwËaÇ£üÜ ¨` ¥'%öŽýªox €ÀbF¡()~ã;íùùmx°À •‹ÐÊç+ý»ó½p À0&€€š”$®Û«·kÖÔ"h ©BP–Ý]•W€æûçËÃàýOsåÖr€už¨@;Ô@ GHÈh& _j?‡¤´Ž”ý¶Ïÿ;m{@@€| ÀP°‰¿œÙ-ºûÇ\ð@°   4&@Ttô'%/œï³g ¾° pCVC …ô’Ý)æw÷(@ T†€ÒÑò1ÛÜÀ €I¸4´|ŒvøŸG¼1 €f°Ñ½cM÷L0xøô'•¤­@À5 97÷ývP@-x“Æ ¼Äƒ¡ ™My¨…ˆ_6:ç€ìœ !àP0²Ò»‹Q·Ì I` €§OéìÏÄkè € äÐЀ™ a,èç(Ã\   „-¶»fY·ªbY\lî"ôÀ–W£=ÄI*O€gQÂ,,Teh Èà v‹‰l17RNµÑü´%½ Y]!Ÿn1óì§ãï´‚ !€„ Ð£†%²RvÅ_žÀ1Ș‰ $ÀÜûî{@Ÿ+(š²Éß8Ô#~ÿ­Çšr€1Àƒ áç¹@3À'_dz?¼€œàÐœ”uxdÀtÜc{É 3€fàäÜWC%,ÈëÑ€-€\ZQÊûîǼÀjBŠ0Ä£¾¼à(`Ñ™;¾£Â ˆ°\3”CJ:>fíyp@/ À2,0h ˾|7Ž×¿I0 €ÃåÐp*­¸Ôæ: €:!Çq¨Gw2`;xBÞîÜG£øÐ  ed@ª>Z~K±‹9î(`@€m`¤ß»wû(~o—}Ø@@Ò9 ¾ Nn=¬À: À ÉD4«; `€T Þè@Î)@?º¨/¾C£øH` @@çr™Ø$óå €„ÒòJïÙÉdþ»îh P  ÒÎýX œ)ÔR{¸Þõð@-+e~ZA¬­”4.à` à Õ’ÊÛý·ÉÆfˆ k*1 Ã@3!!õ¿×Þ`p(øô½ÀsðƒlÀ1 ä0(Y0°†§'7røá5†‚a7¤¶ õ†‚PnHB[>倞 €M>&£’º ߤö0=¯bî@bQ5À—¿üâÝõî@ AÐ0 Ix²ø×üƒu1'Ø Ó÷ IÿŸ`p!…·NÇû „&éÃ~cèø@œ 'fYd²Rÿš±× jÌ° ÃKtÿÿæÖ¤`T †¯§½P €¨ ÃQò÷ø˘„¢` Ûm¶UÌLÑ0Mš€>&€œ†Œß¿y@\bÀÀtžÒÐá›…ZAÈ`ÃI‰I1=úó‹¾X `€² À€© ™ºÐþc±uФy@: J•œÚÜX2€tœ„¬ê>H +±˜Àƒ@ÀÂÀÆÁ9oÀåLjaH&‚‘™Ûl;eBõdÔËIiïÿ{Ó!“RC-%¤ÿ䚧8:ò#€ ß\D¨À‘à@ˆøœóH”YEP’‹FJ:¾ðð¨þR€€°ø¬0²haH@o_ß —{°@½RÈD0ÐÐÂÔØa]ÔyúùU`  €2¼¢PÀ `næÙdÄ`|Éé@ç2È `;ÌžŒ£ûð .„"hÀP¶É`|xrîÈ0@7:PÄåŽ÷çÀ°@`P´¤ðÂ``a}ÿtç:ô€¤Åùa¤ÂfKÿÙiÇ{Œ @× NØ7Œâî@ ö/ŒâèþÔ1!f%'77V$ *Va‰¾d^à䧆-’'W5ÔOº€Aø0Ïò`_ã[±\(á÷908 vø/\äÀ`: À9@]ºà:¹&d†Pƒo¨ ;€^Q1?À·ÆdtÀ‚°à Åä@Ý÷ìõ€À oRPxúCƒz’Š?@LÙdÎÏåHdßÏö‚à!„ß¹¼Ü z°a©ÎBH^ž²8ÜN§Rc?J(úIÀTšœIj €ÀN^ø¤ž;Ü€€¼ˆmÐ ëØ‘È™€@„8pg,çøs‚„ZĈÒ;¥€Ä¨ˆá;ÑúðÀ@Gô£ „”¯,gf ¼¨ ‚ @C‰‰ 2xÔà|pœD¼ ‚8ŠH ñHï»t-•Îk΀0  ‘± >fü¤)ƒ®Àà$¿ÐL =w`àãA0%jú¾ €ÊÂa² 2S~7mº‡6v2ó€S“.!B!bŠ+6ÛT3l©‹&!9zì ' ‰cCâ@,º‰ 'HËMtŠz”>–ê…GB qU°ÕÀ>G¡â ª@üœéÀ vÙ«ã‚/“  0Ñ þ€¡04N"h@ î$!o×Æ#/‡’qÜŸÀ䜔ã“ð`fp(€ •€ú@;÷^@ÂÀP@Y$w‹&@Aœ´¬c!÷ã‚Ðq>& šM ãqeîÿ¼ƒà*PÈaœjKÑøp € ††ô›!#Uú(FT°%§îHA™ ûñ˜xÊYp !èKøYþË€3?@Ì_Áþ´ À6Èýí²±XóV÷,ð@ d`(LFûm»SJÃ@vM!ð.ZR'Ú€ìšMà\´¤OªÏ¬–¶ÑÞ$huh:¸mn­ôà z*O«]@Ü  !ñРê …k‡Ôx²}pqLÜP¢t6êÈ°àÖÏ’Ê®­ rt$µ®S8 z4<º©€?HMÜ à0°ú…˸ñrucÃê G`g6>>jñÑûT œÄꃸŽN€~Ä:"€v}C@=i@ÀÈà7$°pYn…“ê6Õìw#øX| Óh(TQë€Zõ,?ê ?óH±‚šÿùœ zÓî>²Kø™à¢}n›bÃë`ÇÿZuhy[“cêp eøWO™À q³UÁ+uú¡àȉPÀìqø ¶g[؈ \?K•NæØ´ªW2Ï\ 4øÐ )š¥Äð¿.eb, W'2JMô±=ù«kµŽµŽ¿‰äqDè,JâüO0@2ÉaWRRy]rÚnK'E€ W$¤m¤ºMànÉöO¯Fü(Ò ð  ÷7€ë ùˆKø ~àvH6û‰ÕæŽ<€qŸ ÇAdý0Ÿ`,"° hÿhrB¯ã™÷ÚMH³3M2¦U%“6X VÛwŽ¤Ë¦¹ÍbˆÄiÍE¯ô‹ÃÀþD¿˜p.á$ ñb,ÐW˜.Þ á`?‰ÀÒ =Dà/êÈ„èŽ@üà ô,{ú±ÀvÀXÀJ„šÔ/â ÒqCÀÚé¬Îºn³©¤MP”ÌÒ3Òɶèê[, W'zYØëŸúó »Äc Æ„€ql@€<`,:þÈ$xû ‰Ö=dëø"p4GJ',ëù|€®.þ8e€bjjMNô*™#ø÷§÷sM°~ltÛïÚ‡“©,ÑP¸(Nd• q:™Ò>œ·¨²˜ W'zX¨puÀî^a`DÈ,£áàn/æ`{$ˆ ßòTÎ?³€=€fN€[ZtD #RndOüciœ©ñ´ÊS ‚«Íêfi Ò•ÈXùþ8ÿŸLµµfxq“rjièêÑHP2Ø4Ò° w–gÕ^a?ˆ B€60?Æœ8¦€‡ˆ5à¢x b ¡à€-Sâ:OõŠ‚œô–O$¤œÎh #é•oHæðp’x5ÿÀ/¤ŠLå\š’k¦|Ï^h üëþÀ::´±z“vÙ€Ì <  @1€Êᮀ…x(þLJWˆp <‰…¬z ;Ki),Üqt¹`ÁÿH²<‹#³",¨ºFr,4†£aÓœG¾Øæ*b óÀ }Âi¥%]i[VÙ„óBÀÖqœðP¥ñb<•ºÇø@±n{W™›%g¬Å¶4û à4ÖÊô`UxEô`P!¥?|ZãÀeŽŒl¨`„ÐÒÃ@R¤‡s1æ@(H´•‹åvø r$7 ?|©“Q¹ù«31)HoGÙà@À4½ `°)¸îÀ[-,ðÐM(¬•¤æ ÁüšÌN’g @8DR@b€)†ÿ†2ÜDQ`'A3 ã5`Ä ÐpÔ9Р+‰8 ±0€„ÀÒ@j1ËGû³‰òy+ÿÊ^1¾“ù_þ„ïŒjiDwï°ý6·¦œõ@2¤”ÛÀ¢u&¤YÎE7€gZFšÑ 3ôÊl° W'édÁÛþî©'¬€ðhaDÒbC>n•¡?¨n;ø¸¢ie$0„ZIg?ß2;ŽŽlP €¹- á‰|ý¡ØDü# É]xÎN÷6€€þ@€r°„¤R†‹ÊNf:È@E™!@[°‚s×H £€\‚I¡‰ C¤næm!p€˜³†Ý<¬VÃÀ€5Å ' ä¯ÝŽ€1rš@büUÆA¨–hqEtlŸ±Ù¬´ÛmHJyiéçþò-<´ôóÿ¦Ýú’Si`j‘ÌŠì">’rmSœyH²3E€ u}wƒƒé©[®'=+í‚€pÞéºGRJn ¶L 2ƒþ #…Êj O€ÜÄEpÀÝ$äyë"S €bÿ€]ʃý5(},ÔÓ $ŽÖ©p 8¦u°Ôäìže‰ŽCÅ@_Á Ô.’9JLå@ ]5Dw%ô›jST‡“é2™XÐêGž³é‘H>P})Èò”Ê;øH‘¡Õy̱`ªr¾“0 Wn*à9©@?¦Ð¹`ƒ¨€i”+\ 24x²}k˜ ˆ‘ºj[Dr“)Ù÷¤E&ry©õ×&Ân­da»ÏT¹8 W6ŠõL‘„vžãàg…‡×B,`g¦x¼>¶Ðxˆñ ±ðºdúŒµ¨Àâ êÏ @.¦t“¥éAáp³â(gÖPBÜŠƒø0´‰Ï°úylÕAdzFMœ¹ ÕîxYPðRGmi”Õq²¥`ù`Áÿ^(Ç÷¸<<ŠG– W7i÷LŠ„RnIÈôÝU+¶¬ )ÊΙõ“•Lœ°òù‘¹‘XúªÑéô™ÉÀ W&¥h‹iϪ•HØ[i° à8@;¦`ö8ƒ|€[Jäàœ @ˆ \?K•NæØ´ªW2Ï\ 4øÐ )š¥Äð¿.eb, W'2JMô±=ù«kµŽµŽ¿‰äqDè,JâüO0@2ÉaWRRy]rÚnK'E€ W$¤m¤ºMànÉöO¯Fü(Ò ð  ÷7€ë ùˆKø ~àvH6û‰ÕæŽ<€qŸ ÇAdý0Ÿ`,"° hÿhrB¯ã™÷ÚMH³3M2¦U%“6X VÛwŽ¤Ë¦¹ÍbˆÄiÍE¯ô‹ÃÀþD¿˜p.á$ ñb,ÐW˜.Þ á`?‰ÀÒ =Dà/êÈ„èŽ@üà ô,{ú±ÀvÀXÀJ„šÔ/â ÒqCÀÚé¬Îºn³©¤MP”ÌÒ3Òɶèê[, W'zYØëŸúó »Äc Æ„€ql@€<`,:þÈ$xû ‰Ö=dëø"p4GJ',ëù|€®.þ8e€bjjMNô*™#ø÷§÷sM°~ltÛïÚ‡“©,ÑP¸(Nd• q:™Ò>œ·¨²˜ W'zX¨puÀî^a`DÈ,£áàn/æ`{$ˆ ßòTÎ?³€=€fN€[ZtD #RndOüciœ©ñ´ÊS ‚«Íêfi Ò•ÈXùþ8ÿŸLµµfxq“rjièêÑHP2Ø4Ò° w–gÕ^a?ˆ B€60?Æœ8¦€‡ˆ5à¢x b ¡à€-Sâ:OõŠ‚œô–O$¤œÎh #é•oHæðp’x5ÿÀ/¤ŠLå\š’k¦|Ï^h üëþÀ::´±z“vÙ€Ì <  @1€Êᮀ…x(þLJWˆp <‰…¬z ;Ki),Üqt¹`ÁÿH²<‹#³",¨ºFr,4†£aÓœG¾Øæ*b óÀ }Âi¥%]i[VÙ„óBÀÖqœðP¥ñb<•ºÇø@±n{W™›%g¬Å¶4û à4ÖÊô`UxEôÙ`lœÞJÎX°ë¥¼D°ý6·¦œõ@2¤”ÛÀ¢u&¤YÎE7€gZFšÑ 3ôÊl° W'édÁÛþî©'­³S‚¡î,×ès6Z­@iXâwB]‡´ƒYÄÊól·‡¹<å‘„}…ég Í^f,!dæ'¤º°y‘å\˜‰¥”ÅnïŽqPpŒÎ4voƒÇx1A°@À¥5‰cPÎÄi©Åg5ÌÒ~(¡· 02AH€ À§è/€¥N<= @€iÜY3€™Ð•–y>€@EÔ!„2Ã}ð¥`@€s°à&P`ÂhjZ0Fv hxÈx º ÃL  ຠ•H9ë"S €bÿ€]ʃý5(},ÔÓ $ŽÖ©p 8¦u°Ôäìže‰ŽCÅ@_ÂHv¡t‘ÊRg* ]5Dw%ô›f@šw­°P „ÄF €]X<ÄPbyhËâzÃÈ€ É B€¡k݇1¸Ap´“››_dî³z`d8 8|äÀg^ݘr´ž0Í{nçûÿóÿô€àž³é‘H>P})Èò”Ê;øH‘¡Õ9̱`ªr¾“0 Wn*à9©@?¦Ð¹`ƒ¨€i”+\ 24x²}k˜ ˆ‘ºj[Dr“)Ù÷¤E&ry©õ×&Ân­da»ÏT¹8 W6ŠõL‘„vžãàg…‡×B,`g¦x¼>¶Ðxˆñ ±ðºdúŒµ¨Àâ êÏ @.¦t“¥éAáp³â(gÖPBÜŠƒø0´‰Ï°úylÕAdzFMœ¹ ÕîxYPðRGmi”Õq²¥`ù`Áÿ^(Ç÷¸<<ŠG– W7i÷LŠ„RnIÈôÝU+¶¬ )ÊΙõ“•Lœ°òù‘¹‘XúªÑéô™ÉÀ W&¥h‹iϪ•HØ[i° à8@;¦`ö8ƒ|€[JäภŒd¸ ø})H‹”¥".R”ˆ¹JR"å(üu".R”ˆ¹JSïâ.RÚâ.R™ér”§ÿD\£íý>þ6xÙì Ôšn„Ó¡0Ø|²76Ônjo¼Û'xoãæŸFÆë¢;Ò"å)H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹JR" ø})H‹”¥".R”ˆ¹JR"å)H‹”¥".R”ˆ¹J‘ŸöÃýh@€<Ã'P†1~²tdtõoÄFGOVüEÕK¦Ì+@8ÉbDß³æ/bs=Óf MÒ‚a™,­Æ}¸“B¨&`i 1!M@`@;&’~f—°€ @:“NC’j¹¨û`ír À 5°Ò‹ÉǺ×ÕЀ1!gIPM|²ft•|j6˜@; 8bC5 Ï-}ëûïqµjR"àÍAš”ˆ¸Ú”¤EÊR‘?mN•R=pl7Þ=z!÷Œñb”¤EÊR‘)JD\¥)r”¤D ø})H‹”¢Ôˆ¹JR"å)H‹”¥üEÊQ)ÈßþÛ/ÿvA,@J@Ѻ2wûãðþê"°*œ‚‘ÿò&‹!§ ¤øëå€=^‚º@© 1gËFá_Ý @Ö À €Èa°ÄôbHÝùÎge^ä/Aš²ÀÀ Òwl48xy—¯-   Àb€+OwÄŸÝø›ð!dÖI4Üq×(“vHkˆkùè kG Hj¯+7$%JPóÔ>ô@ ðü –[€?7PÞÆìhƒ¯pä4€b²ÓøjV/Ú@vÌdÞIOs_Ü€0. `-‚®@ Ñ áæ@‚Ð$4¤¼²ú¸渶º€AÔø Kü²Ö/Ýbi4†Ýkœ7'bL¸„LÊ)VDÀ A‡#_ @@¸¼„Rx-J$ûÇ8 V“@1&€¡ ¿S?稜%o} ¯úuÅe€4Ä„^OÛ': à ¤$ì»6  À0&HIÙvR¿Ïà€”­ @AŠJSÀ¶ùÎÍ®Uì0€@üÄ À*Z_(fZÎe¹ëyÂiDÔd•òQ×¾½€ À§€;-zÀ¸¥£¡–b”©Óµu³\£Óý©»è‹”¥".R”ˆ¹JR"åR‘)ÿÞ”IÑ7ޑݼ".R”ˆ¹JR"å)Hˆ ø})H‹Ÿ?¥=".R”ˆ¹ýÿŠO‚ˆ¹Ý¢YeË-9ÙÿðJr7ÿ¶ËÿÞ„*¼ÂÀ¡´>G~5cDº@t Ùx¢³ÿH…€ì¼QYý€@° P €@²-5ûÿÛ~ÌbÕ}H,Á†ü†½ƒzú[dóx¿æ Ð@©Ø°*w!ôÿ.õà @À3,´äþÿ›y  €¢²K@Ooÿ¼à€ ’”/³½ °P€œ†_ž7µ€Zï†÷” @3NtuŠ¸À€R@;rYHA1?öS¹K ‚ Ì}ÌXh`²Û5õÀt  €Çà,že¸ €B†&ó9#Þ A ärÀL^VoÊwgcï. €6‚E$ Šœkfa^èh€£â^q^Üàà:Ÿâ^÷õ`À@NIJa-"þà8ês­€ AÌ  ray€yï€: @0!bƒJA!¾Åd¬IÍz@©LI  Q)= B÷sö4]  X˜M&’¹Æ~­h Âi4g|;ó¯í@T€™}JD\eÒ”ˆ¹JR"å)H‹”¥"  ø})H‹”¥".R”ˆ¹óúm¶¤À'ˆ`A¤0ÞÈ)<mû`¨Ûÿï @¤B$tZy{¥°£ýõ°@˜ ð€b˜booÒÍÔyó è„ÒHdÂ`oÅ#ƒÅñÕ}D4@†€^²Ò’ÿͼð€Ybih_Ïp4ؤ——îà C@†—Æ¿ÿ›8@0—Ã_Ö`¤€ì†ƒ_‰¼À (‚é` ÀBB( ~7 Å/Ÿqì†P ƒ9›kŒd2€LÎÛZ‚ (€œ© „0I,oÀ{ò5ó0@Z€ƒ@€j¬ŠGNNÎûeeÐ@d€@@€œ­¸BvÙ¿fg*òÀPA€0+#!Íz` @–²ÒŸ¶}þ½ K©IA‰û/½Øø@À ‰ˆ Ð(¬ŒÛ¶~'Õ¶þººz{þüººz{þü]‘æÌâäĆÑ“¸£¤}GÞ7ûÆÿu_­ @s&5&È`0B ‹IÙó¬RÚúH [‚ @MJH_¥¸ÁÜV¾’^èNÉÜý×®Ø Z€€ ‰¡¡€SÝüb;埽ÌÐ)4Å ¢ÒèsîpÀ C@LZ /þ‡Ùïô0°€dœ’“›óÅV€`ì° hB?ÍÅÞ (A\†È$4 'lÿ+ºÖ;^ÌXÀ˾ÿ^`€!(!›»¾¼Ð„ †nîø}ù°@R âh`“ÀªPÌËRÔ>ù8 2 €\L„Ð*WaˆÛõ¿Âøu÷ðÀ É &¨ïÑ·¼` .‚b€ëCJPës¸°;t%\€””¡'æÖà @ et¡'á÷ð÷ÉÛ£¾ëÌ.œ¿½Õ°@¼p ¡EĤñ[2~߶8(zîOF÷¦’|¢Ñ÷Ê^kÑ I¾QhoŸ/YÁ´Åêb·íLS€²iÍ•4ì"Æ.™/Žu6úy>v£uèìðèÞYqpúSo©r”¤EÊR‘)J%öŽ¨¹I± bFsˆÒﾌœ“¢å)Hˆ ø})H‹”¥".R”ˆ¹uœ” @ Fà\°Âù%¶WËrox @¥É…I…§ ÉGnãάÀèô%c¿³x®°”P·÷ô0@ž *x ;É/§ H[œ/Xo9¯»Üð@Èf€„5)ýúx}´Ð°Àª;ûÆÈ„€(BFÙ”eähLÀP…”ͯ € Hà1&#ÒéÆ÷É,ɉÀ:9 bò^?!¸àì»Ù‚˜ ì|BéÜ´-Ž^ ªøÈ € @(„l_Fü c>Ê'=ÚBç•€,)+㹆݀àú0)+J„kÆEè0 ÀÄd ­¶Û6T+€€-€€°*œŒþÞö`~a ÃCtIEdý²Âqh €2!€j–+ þì0D0 RÅgýøh§ý},p @7€‡€„ BõIûp.-fÞ8A¬À¬L(0†Žöd¾ø¤à €b JÆRp€12¥kãÿ‚S#'o–æÓ£#?çý­­‡TÅì÷Ϲ‡½¸4ô@ €é%€ìe$5»»|=x*õ`A€ À’€ ðb7ø#änµ×fÀ1ŽQ]‡ýÚ€\á¥ØݯŒ€€’LBÐ*ÒJHÜj‘ÙŒ¾¸ €‚°T ¥$ÄæJLc}ó`@)r€†€TÒˆa©ñwGWgk ð@9¸Œ¡4èÃKBSзÏl`}ÌÐ 1tMA0 áˆÿd$Á0`€ìá5„<ÈÿmÌïí HE€€›Ñ³72¬€²h¥$—ó|m„1‰ NMt|ÉN8uØ Å”Ÿ—›Þq1(¥c¾÷œ”R·Wß_‚p@ž!€,ÌRò2P¢Z#«ß!p@Æ0 h€< JF†äg߯«mú@ ™`PÄôüÉÜû怀à:|C„0–V啾ýòÃók°¬bJI41n®À´riH ÙÕ¯å®ð+6®D¼ @2 Ø Ay;;}ÖÎE¨½ï¿GÍ÷^½ß¡*ù_Yèú?ýΖŸo?¿çÎÊž¾ Í©³hÎÑr”J[E¾‡ÛÅŠSwÔˆ¹JR"åu)Ýâ.À•Ùñï ÿ†gÐ7@1i ®‚ÿ3è±JRQ øûhâÞ!¥ŒË¡0¼kJR"å?jQ*ˆ·Ä à˜ “@$)<ö'ß_°@Ñȼ P¢ÓÂS¿uõõ‡| 2€OÀ2.zMÎø„œû·Î:ûÈ F€) Päô¨5,ýÍ狹¬†´—óŒmrë@ªKçf×é@€jz²ÓÿîŸP%! ! À=Äÿm!–K/ñv0@-/ð ɇ’qÂo,58‚%憣 3ˆ¿‘ `àP ô6IÛ·FuŽ|è1¶Ì*öÀ€lLøácPžCïÎÊe ]âP†½%òÀ1 ß’¯`Y|° Ã\Åkõ€æa  €2,1(NÌ–Ê|ì}0P€„†’Û§›Çß,ì†RQ,fGÊʾÆ P²€B4i'ž&â p!-¿÷ àQ mý¤©(H,ñü}àAô1bK/ñ¨PÖr=ô€ § !¡œó/ bä¬[Ê; Ö HDÄ€è·Ûvö HDΤ¾Çr5ü@À<00!§}ÒRûó·<>Ú`¤€@: (¤ŒèGüÅíýŒ À €@—p#÷ÍÖŒ«Ô‚È @ªq…¥H-±æs/T$Àb3’ò=ꘄ‚þç "ß¾ @£8@/ÙH¡­‹NÛõcÔØÛÙ= ° @©¤ÒÏæñõb@b ;%ôð¤{uÒéë¼pÀD"²‚F#^Hà „"[#¯† |˜ NLAd2þ%ãÿ¾V@% H|´–Q ¬Sm¾tæ4H«í…¤პ¾N@&‰`@M¿d:ÝlÖà :&  /m“³î/lZ^ÙgÜ^½  Å€dC¤ ÀÓóÍ"ûèÀàÁ e¡%|ÉøëóP €\F€h€NLBÜb[;·Æß[0@\!,Ø,„„í’_$w?òu p^±7ñ¹[´0SÃX„ûãL÷ôË&9½Ë @Ö,  ø5(dã»[À€hËFÝIøêàK - ù÷ e ”³¾¸‹ A ¥õüX!Á‹PÂ` ‹½9=’“N;š|ôà JÄ„2ŽN'ß A ”šà:F&¥]ýÏÆß``ƒÒ˜®’ùiFAëWÞõ@ À ÄÐ2Œ¤õÞ˜häÀšQ›~»åÒ”º®«”¥"-€¯ûL?þ@ݾ¡HÛ?œ½áóØËÔ¥%)JD\§ÏJD\©OþñJ~Ž£§mb”Bru#}ôo¾€ ø˜ ÿA^` {öpÕ€Ä3¤¯i ,°þ1ȱ“wÔÝç„ÒZ4»·ˆ±OŸR‘Ò ²o( €1Fý°Ä÷Ç„gf5Þûà O¥!  ÀcÖ”ž&øP LÒPqhCí”ö7|ͯ¹(° U(p¥Âî@/à |¸A· Åñþý!hÜ»œ` ÈHn´ á6ô’Mawàˆ°ò‰h=‡á÷¤Ð0BOx¯ A "ºrvÅ! B¸ÜgÇ^Ré‚Èâ`À @fmÑËã–O¹—¶‰7ÀbM,z{^È$ÞC‰4±éäëô`,xHˆhJ:qhÿ1ï­¨ /frI„"Ò‚_^G"5lBnL F^W÷ %²Ò”†£¥•·|ë€ xgêì@1àaŸ¨w¿´È²J@E’pãïš‚è *ðDÐRgBpÆÉ#Ü€À€ÁÈ@;p ›fä†;Þx  (!!‘‰mŽÙ^€`)ˆg)/HPiˆg)üʼ¤Â°`aE`<„ +mwÀ Rô„C (§%¡,Ø~÷ `*B Ù\05(ãî°(CH/ŒºˆD4‹Åëû¨ Q x@¨iDÀ‘©vGÜåÞ¨@3¼ É@îÄ~z  @bx… &“Œ_Óºµ©²ÃïHü!@¡@1rÀt„ç|…³œ½yàÃLÈ,ýŽ÷à’“ö;ŸN`@KzôRBØ–Â?#o ðÂ5(F ¿S}¶>p@0€0,¬P R2Yñ[/þÙk¼°@DÀÀ0@b6ËöÀ @ð ÷)s1ÔHÞª9H;©°áwEèAT €` NCÁ˜²ñ];²÷eåcI÷žœð(PÀ@C Ù9$Âó|à{·ëº@tR¢j G^úéÑ P5£¯}¢Á¼ AXø(gà IùŽþïÊäÀÖ|Ø € €``à'è@ÎKOÿeÿà3¾ˆÄ™ˆ@U;÷ŒÈà :)#õä6ˆøBEkç@ ÒB¼ q£( {â €ÌôÐ`I}< ¤/º¨ø`IÛÀBøà Q€;ý ÂË~^FÄP°« 5I„°(”Ž· r`Òã—~”¥éÞ•ÊR‘zü›Sm©.2Ü¥:[Ò7Þ7Þå)H‹”¥",§ýâóA9ýŸM9^¤îɶ‰ä¿¤˜˜S'ù`™¾BäBß±þ øÛéƒ@LL ïйilQ ‚ 3ï D\Ýõ)H‹ì‚À,°â҇±›gÃï¸ȼ ³’Rá~ø0 ZÀô¨ù¿d|Øð”u‡5öð@–df¿òI)äÿp‚hnÝ8· ì5¿¿ZWBa÷šà+ÊzÀr‚>¤&äPò- À1‰~ù(`¼G¸@/G, 'ÄK„rÈIïà`€¦CÄÐ ÙÇž²ƒ˜Ÿsnð <€-@ÐäÆä!-ù›2‚É×ö€BW Øj8÷²¹@T5 ò}ÊR•Ur”¤EÊ'ç§NÓ$½â,nÞ‰ &Ý%ž?£r>NýPÏ¡Ú¬ ¢ŠÁBmˆÔŽ¦þ"Å·ßs¾ûˆ¤@b^ „Ôœ00¾âüeøË÷õP@€^B ÀOY%·9WÔ쀖ÀO‘ïš‚0ÜCÄü–¯ÒÃñï},XhÐ¥—Ÿ¬>ò ‘Ð`ÇZò@# Äk¤ ‹N` ó{ä@€>”¤ ~–û!•}l ‰œ°“Ä{ãÀ€D‡&ð(_8¬÷ÇáÉõ§`ãª'NÀ:H~”¥êÞ¥ÊR‰NFöÑþÚçûD²nÆÖ€„LÞr`øÓ« 9Y$­ßÚ@/+Ý7œ®7Â$Ä20ˆRSµ8ÌçÜ¥))\¥)sçôèÔ¤6†×6Ú”¤D ø})H‹”¥".R”ˆ»€€€ÌÐÈCÑû3»nA¾À€“39y 5$^pûã?o›Ï½ð @5‚¯N&“HE%$±©í˜÷ ¹À €NP Æ~Ãnp1¨9¶Mý¤˜ 0€v[ædò= €€„˜œŸ™;ž.”Á 8jŽ¤ü±6Ð1À0¨oó{ÉßÈBqòßÈCß_Å\2÷A„_NHÄeì{µà7ß>;}ÌÁ€4ÌCJ‚ÑþsÎ|hP  €¡405 Ålœ5ÿV_»Õ-Á :ß ÈIüz€ $ ^“ï )K¦è¹JSý´E·ñáÍ‚½", 2¤EÆÔ¥".W€€j€ „†žÃ>Á꨺à4bL0"!“K,•Ãqh@‘™c”N äÒiE`>‰òœšM(¬¾”ì×õ€@€}[‰ @N4šîZ~ÊÌ2÷`ɤ°+Ùyî S€¤Ø°ð3Ó¹inÀYzM冸»Äl8Ñ[ŽÄkÆt9 ¸ìF¾H €›À3!p ì.ø¨ J€4¨ ÂRÇWË0ˆ}ö@@TJ0°9Ä´; ×ÂAÈâtTB¨Øae1Móîë}ÖDÞ‚`À'Úê Ro@`Áý¯‡JRôoBäH{ò»BŸo¡9÷Ðœ7|>õ€hXi}ÿg«0˜™µPÔᔃ4þ?Ú†> &Ãzû»ûf¤QßÂßY#ï®R”ˆ¹JR"å)H‹”¥"  ø})H‹”¥".R”ˆ¹uœ   NÀ\ ÂöSî¯×rf8 BB !çAhèáûçÁr!òj Ç£¼ˆA¼˜Z Çî÷÷à@žà*p ;Ietl”˜/Þ°(à0&¤W¾F  €~XIØi01#ÜNüí€}}T¤–„£æüûÇP®8‘ÝÕy €C€b¤wu]@ÀdÐD2’‚Ò†øÛ怀ؘM€ ‰ ;g¿JLí˜ð£/­’“¾æÜp@@ P*¸2h J'sØîòfð  HIGËnÒnø  HIß-‡:ÿ7(jÄB€©IÉ}Ÿã¿j›Þ¨ D€€à0Q¨J F߸Îû~~[^,°@%bÀt²¹Êÿnüão\0   &¥ +¶êíÚõ€5ÈšjP”%·We^yÀ1!¤˜PFãäß|ùx|K+—«®ìÐ g,ú¼—ŽHîŒÂ!Šh‹}½>íaõG¾˜`@#¤†€ÌÞÂãoümÿ´Ih))ûmŸþvÚú @'ù1 ‰¿bŠJ²B?º·m @špBh0GOBrRùÎû6p«ë@BäФ‡Ë Iýûû\€À C@vQ ´|„u:ƒîP ‹ ¥ËGÈGSâyý0é8 ÃSû¿ä{aOÓ„Õ^*ž{ù@6,$2‘ïñ—–…ט…×à ’p :BÀrƒ„ß $€\Iî•…d!°sð»ê € D0 À€€° —,®ý³ñk〠€`€tm‘¸a[%³a¬µkÓ @”M& 1Û¹ôAXè&† 1Û½ÕJRì».R”ˆ¹ÞÚèÞ¿Ó/tæÖÁ™RÓm©Í ¤ ×)JD®R”ˆ¹JR"å)Hˆ ø})O×r”¤EÏöô}oû>­@| Ñ‰Ò@bKÊšCq_9·M"MÅí Þ}å¾úûÀ,è-xÈé ûqŸe?}¤(Á  €í1-’“°¾*üöˆDÀ HI&çßpëØø 8 YDЀ¦NùÆ¡÷ýn<л”ÀŽÈ¼_ç=ʈžÑ8¢û#ßÞ@Nph NJ:¼2‰`:Nî1½äÀ3prn«¡’–äuèÀ‚H @.-(å}÷c‡^`€5!ÅbQß^p 0hÌß^@) @€2ᜢQÑó7kË‚x Af‘aƒ@NXÍóá¼v½úI€Tï(€PmƧ0±ÕÄÑ;B;¹“ØÂ÷tnâ=üh „²²  U-?%ØÅœ÷° @6€0ŠRoÝ»ý”?7˾ì  iœ„ߧ7Ö`àd΢UÀа@*Ðot g ÝTˆ ß!„_ÂC¸7;”ÎÀ9'Ÿ(` D$&—‚W~ÎK'õßs@ Yb…V–p'êÀ`àN *“ÝÆ÷¯‚i[+ðºÒel¡¡wð0ÀpÐêÉemþÛäãG¿³Ä5€˜…Èa Œzßëï 0¸|z^Îà9øA¶`‚r,˜X ÃS“›¹|pšÃA°›‹R[úÃA¨7$!-, ð@ˆdТhñ5”íÐ^ý'±í{@Èp*‰¨&œ½ÿçìh¯rb€€jKÀ—Ƹ䨈8ÀNŸ¸jOüû € D-ºpÞ?Ø€`PL!7Nó| @ΠЀ3,²Y )ÍXëÐ5fXa¥ºÿókR°*CWÓÞ¨ÀTá¨ù ûüeÌBÑ0m¶Û*æ&è˜ ¦ÍnèÑ4$<†ýû÷”`@U,hÒRSâZ?Ã?4E` "‚Y øi1)&'¿@qwˬ@tØB!“7Z¿Ìv Ž·Vµ0 NBBNU¸Ð(€br³˜]ó€€2ðPš‚xaéF}øà渑 )ÂR3!m‡l¨^¨!–CRY}ÿ÷¦C!–KIe÷éïr”¤çr”¤EÊRŸí´µÊS}éñ¾÷)JD\¥)r”¤EÊR‘ øyÑ~ðùô~ú"ÆûÒ;íÚ"âsêÒ1eÕ[ïFÒA|®©¤¬^]¹3†f‘S£zlÚô÷’6Fk‘ (š„”Z2QÕ÷…"/´€€°ø¬0²haH@o_ß —{°@½RÈD0ÐÐÂÔØa]ÔyúùU`  €2¼¢PÀ `næÙdÄ`|Éé@ç2È `;ÌžŒ¿¿‚à@2!–Œ l–ÇLJ.ì€3p€ƒ¥ NXï~|+ JO &ß÷Aîpó¯H@€,Q–L&d¿ýÆœw¸À2 pÄíƒxÎ.äÐŒ1;bøÎ.þÔ1!f%'77V$ *Va‰¾d^à䧆-’'W5ÔOº€Aø0Ïò`_ã[±\(á÷908 vø/\äÀ`: À9@]û® +rfHa56ñ€‚¸åð |fG÷L¨ +^ ^H ß~ÁPì õ%¤0é7©(¿@LÙdÎÏåHdßÏö‚à!„ß¹¼Ü z°a©ÎBH^ž²8ÜN§Rc?J/¤œI©Ä–©¸! åïŠIã½ÁH À€fÝP¾½‰y@8@€‡rÀ`^€÷8(E  @@#ºQX @@(Ž°}úðÀ@Gô£ „”¯,gf ¼¨ ‚ @C‰‰ 2xÔà|pœD¼ ‚8ŠH ñHï»t-•Îk΀0  ‘± >fü¤)ƒ®Àà$¿ÐL =w`àãA0%júûà€Š  ,&‹!€Ã!%7ãvÛ¨sgc/890âD"f(¢³m°áC6ʘ²b—®À*pЖ47þ)Ô˨št€ì±¤×H§·÷$0tŸàzz`(VÕ>ŸI å Ÿî`ôœ‰P”ü¸àÄc £ý2ú>Ö3µ)HÎÍ1eä@5?jÀÞ’û.a¥ôTC åeeÚž™f! fÒÁNËcŒÎ}ÊSöÔÝô¥r”§ûD\:›ï2CvðGþ"Å)ŸêD@ ø})H‹O»R‘s¼5)r”¤EÊR‘)JD\¥)nCÀÀ;œ„X”­&‚PÂo~¡1߶Ëáïg¤±iAÉøGòÅ¥'áõð@8@ŸÿÈ®ýױ耂0 y! PB†õ¶g߇\:H0$0Ä@jwäg‚ÒïÜ9`ì47 Ù ¯ÐùB0ê €€(?p*B ÈWߌÄëÆRŽÄ=  ?ÑÀ€Ÿ f/àÿ} €Öˆ¶GèGm•ŠÇš·¹`€`ã#Bb7ÛmØpªšV²irÒ‘>Ð4dÒoå¥"}ÊR•NåzR"çFô©GÑj Ô¤EͶ¥)q(ɈÏ GFñÑ’~¹¶Ô¤R^…h:Â~:ˆ:,ðÛh‹‘--éÓã°ßÚ,”Wþ\´²5#f‹›6¥) ø})H‹”ÿj$¼V>ÚÏŒñÑÓ·µåµÎ˜47üZC!†¡ÕäQ3—QdÜUÑ‹Þ½¨  I»­ê@tC,³ô‹œ¬ê€À+‹íuÒˆv¥TÜ¥:vôÉÞ"å)¾ôˆ¹JR"å)H‹”¥".R”ˆ¹JR"å;Ò‘?ñxuÓ#h‹9áJD\¥)r”¤EÄÿ´PD¯Ó/ÇÛŶÔý¨ÛG§mâ.vØ>ˆûÖ/#z°Çú2rc"Å)H‹”¥"  ø})H‹bi]:´°(”Qöñ,3}"ƒyB&“vBÆuËŠ(›×BÀ¢Õ@Àϼ¿Ýy^y(ýs˜1<é ˆ ÊÔ) ¤¿Íí$±šå½éÿ´åv\MîJó¤ '&rCÔýãƒ7ëÛ‡R‚öËB<]…^Cáž\bG—6ä‚u9¯Éé+òA?Å·¶˜°(D‰IëÊ™  ‰u(D‘ÈXýâÙ Ð_m½P!ò2XùÊxLG;U ÅfÇA7“ n6mJR¨¹OÛÒœè‹#~ Ö6‰ßè¡ ‰df±ºàÚ(má“¿‰üÞå(ûS§mr¦,†‚²üá ¡ Ñ·ò(˜Yg#ÝCi»Ö”—ժɟ§?¾‚Éœ3,*Å)HŸ¿ðVÔh—Ú"áa¸§XCåöD ¨I~„ b»Í?§¶:,€§åKÕ#6¢Ô’‘¢å)H‹”¥"  ø})H‹ŽÔJsSîñJ?Œ|ö¸ûø!h ¦ë„\¥)rŸoJD\¨3R‘j Ô¤EÁšƒ5)pe6jR"å)H‹”îÔ¤E–ôúˆßë-õ6ðlôÞ?þæB¢’†ãáHþ·,ÈHø€9Õt‡òÄÒöR~¶(#.ÛjR'ÓÓ×ÿ¹JR"ä~ DYÅhmµ)þÑ)B^¦ÿø‹”¦¤EÊR‘ ø})H‹”¥".R”ˆ¹JRCk”¥#F¹þÔ}FztoqõD•…ðømî>£ïAš›m îR”Ž¨r”¤Cû”¥"Ü¥)þå)H‡÷)JD?¹JR!ýÊR‘îR”ˆr”¤Cû%þÊ®ÄÀu¸G¨ˆi0›˜²‘:e¡)Ì„Œðâ¯h€Ë ÊK9:Æ¢o Fãè€ tŽ¢b0t¨)`ŒÓ&Q$±¡Í¹—)JSîR”ˆxþˆ \â©<ýÀ]O˜ `ÒªK§s×`ÓXÐ .hÐ.Ãä°©XrÀ W'I¶_I!=ù«kµŽµŽ¿‰äqDè,@>xqþ'ƒ d°«¤”Òr%#9ÊðÒNW'E€ W$¤n›‘m!ü Ù>Éôô`Â"rq`x±Ê˜€D¿€Àîdƒgÿ¸O0Œqäûˆ$øPþ: 'êxðð Àp,pããÉââu”) ð@ÊÀ ƒ ,`ÇÝmøð^È”' È?¶ïó ·<%PÄ´ŸÂv4}õp@À-~X!£Ka½oÇÜ €ì§ìq>âTØ £~Õ‚ tÀ@Ñ °Bï  0î5%ïö$¹ïð   ÀÃK- À- $'ü9Í\¬ –JÀ¤óÍ#îF€`À|° K Kž3t,RPi1°`e ’|Y 1@cç½ÈÕ‚€p²¬w<,QBÍ® ÚÚ·]5Dy¹I)5“7é) OûúS w—tMÒt`çÿ$€´ŠÖè2ÿÝ™BaC­ì˜E<ª|@'B¡àÉþ±PS€þ•Éä”›ž:û}÷70\ÈúÁ`4` d€1‚8€W¤4¥ ¤¬£ÀðRð=Ëól³ÃèÁ„ß±n+ãñ €tø ºSþZ”$÷íúÂ…Á˜0­ÿÈnøá`>ƒ0a[ÿ0@°V ³i/âúþ±½ÜŽ&/¿äûu¹ÔØv¡ ?¯20_nÊá~HààPµ¾cXŸlB©lÒw 'ƒ_üúU&r©”øÀrºÁ0 ÷ø ƒOü`êP<Ö®i¸ë©ç˜ÌÀpØÓÀÑÀÄ  >zè_¨¤€ÉwñþuÀv“lˆ¤Îl„Àg­R€}^#˜¡$CHÌb™\8êYà3°kÌŒpdÿ„hN<$PMF¶‰öfÙ`lœÞJÎX°ëéL‚eßä='SKs.ß9qy^b­‰ÖbœâT8[s=€Ù@^ëP0ÿ×™.ÖáÔké#€Ýƒ7ýƒ7ýy’Å…YÀd¡R¦Í…`ð«'Òªº{)´–Un8¢}kSɶX W'éfö(MÒI=6Ì9LN ‡¸³\P¡ÌÙjµ¥c‰Üa vÒ g)æÙor yË#4û ÒÎ6šžf,!dæâpªy‘8ààÍ»œG:'DzȆP…3Ñ¡áÔó1aÌ·±ÂUadFðÈ9l$8Ö-‡ÓÌu,.<ëáÊWf)³á«lÄŽíÂä‡Øé,ü}ƒwüŽÇíGëÄ"që ¶"›g­ÜØçsÄÒm¥£ËE€ u}9ààúÜE°éT³íT’$pu6À³88ú1ƒÀ7ŽsaaDhàêy’Àƒ¬Ýgò0úÍ0ðá …oO2cKH[‡Š0󜞀Ò]O2â$…Âsš~ô–çàãÿ0«U<Ì?ÃÙøt-áëœ{kQë'Ș8}$w=C²‰õŽsƒ£…ÐU<Áî?#È0ylj‘™JÊô;c‰Ô=‡èYçSÌ'rÀAFHc,Lâ]g°tO§”>ÕZ‡rðê®èW8 W"›D9b©#”¤ÎT \š¤èò›UÒPT‡¬«'@,¿`=Â)âY pök€d!jƒ¨œO„Ìpé\‘djºY'Fꬫ»Q¼u™b*ÀTå}&` WÚLTÀríwÍ»—zKÓ(Tø@da8UÈÝUXü»Ò"“9<ÔúîÈí#]Ó# Þz¤òp Wn4k®<•Y &&ºQñçéÈ@"åƒ à4Þ/§hÃëMp}#+e°u;.Eˆš½Ï "@jÊW6Ze24 {>P\¬(ÕÌPó*„R<° W7i÷r&ˆªÄRnIÈõ9F¥tJÍ\×¢t«Q©§a|IdndV>“ÍŸIäà W&¥h‹>x íTªFÂÞ×F,È*éd;m+“€\9øˆ \â©<ýÀ]O˜ `ÒªK§s×`ÓXÐ .hÐ.Ãä°©XrÀ W'I¶_I!=ù«kµŽµŽ¿‰äqDè,@>xqþ'ƒ d‡]$¤n“‘)ÎW€¶’r¹:, W$¤n›‘m!ü Ù>Éôô`Â"rq`x±Ê˜€D¿€Àîdƒgÿ¸^fiÿ¸±Í,þx°µ µ‹Ž1ƒ«ÌâxÀ<‚è@z¼²¬w<,QBÍ® ÚÚ·]5DxÎRJMdÍúJB“þÁ£þ”À w—tMÒt`çÿ$€´ŠÖè2ÿÝ™BaC­ì˜E<ª|@'B¡àÉþ±PS€þ•Éä”›áõà@@à@LCFNJ>Ê߯1µ„'£ï•òô!=|~^¯3ZÏ`—Y8ŸFóÇ… €='VYÆel(Yò`d"½–·#‰’j­ÖçP×™/·åp¿$pp¨Zß1¬O¶¡T›f ¸I<ÿàÒ©3•L¤‡À.•Ö € ÷ø ƒOü`êP<Ö®i¸ë©ç˜ÌÀpØÓÀÑÀÄ  >zè_¨¤€ÉwñþuÀv“lˆ¤Îl„Àg­R€}^#˜¡$CHÌb™\8êYà3°kÌŒpdÿ„hN<$PMF¶‰öfÙ`lœÞJÎX°ëéL‚eßä='SKs.ß9qy^b­‰ÖbœâT8[s=€Ù@^ëP0ÿ×™.ÖáÔké#€Ýƒ7ýƒ7ýy’Å…YÀd¡R¦Í…`ð«'Òªº{)´–Un8¢}kSɶX W'éfö(MÒI=6Ì9LN ‡¸³\P¡ÌÙjµ¥c‰Üa vÒ g)æÙor yË#4û ÒÎ6šžf,!dæâpªy‘8ààÍ»œG:'DzȆP…3Ñ¡áÔó1aÌ·±ÂUadFðÈ9l$8Ö-‡ÓÌu,.<ëáÊWf)³á«lÄŽíÂä‡Øé,ü}ƒwüŽÇíGëÄ"që ¶"›g­ÜØçsÄÒm¥£ËE€ u}9ààúÜE°éT³íT’$pu6À³88ú1ƒÀ7ŽsaaDhàêy’Àƒ¬Ýgò0úÍ0ðá …oO2cKH[‡Š0󜞀Ò]O2â$…Âsš~ô–çàãÿ0«U<Ì?ÃÙøt-áëœ{kQë'Ș8}$w=C²‰õŽsƒ£…ÐU<Áî?#È0ylj‘™JÊô;c‰Ô=‡èYçSÌ'rÀAFHc,Lâ]g°tO§”>ÕZ‡rðê®èW8 W"›D9b©#”¤ÎT \š¤èò›UÒPT‡¬«'@,¿`=Â)âY pök€d!jƒ¨œO„Ìpé\‘djºY'Fꬫ»Q¼u™b*ÀTå}&` WÚLTÀríwÍ»—zKÓ(Tø@da8UÈÝUXü»Ò"“9<ÔúîÈí#]Ó# Þz¤òp Wn4k®<•Y &&ºQñçéÈ@"åƒ à4Þ/§hÃëMp}#+e°u;.Eˆš½Ï "@jÊW6Ze24 {>P\¬(ÕÌPó*„R<° W7i÷r&ˆªÄRnIÈõ9F¥tJÍ\×¢t«Q©§a|IdndV>“ÍŸIäà W&¥h‹>x íTªFÂÞ×F,È*éd;m+“€Ôw) sr›²ë9t¹»zÌùêªBí…Ð}@ÕHÏaö\ ç q"p¾]™ÎSþÖ:Ö:¢z˜ð; GÀ.¡ù5¨˜ ’8Õ»SX³«™8íZ›M¥MŠIau¬:#€ {”ª' ôæG#CÇÃÇÔÖ}ˆP·‰Î$ÅWqg9ùDèU±U  4~$Š LNœ€º™šî,sK?‡l-Bíb「`ê˜+Äð€yЀ4ôx¨Š—Û÷™„ù8èv\x¸÷E7'‰´ôÓo:§UrÙ¤ê=I~ëS€ tˆ¡mÀŠíxT£*dë?»ðµ%cøXº'È"JÍ…ÔÉjg<ÖfçÓÀeböã˜:ñ¸'< ìlÝ@ÐS!dÕ`£Ý¶¡[TcÈ ?¡Æ°[T€ *¿aðœøJ‚ªÅ N€Ý‡åˆ¡Òvö*¦‚ÈäJS²3j{‡€Ëг¡ÂÕ/DlÞ¦ e ‰úìÐëQ:”£j«~^9KPº@ÀŸfºôÇeÔÇ2‡Ô²¬w<,QBÍ® Ú‹[ýé«“j⓱µtƒÚœ ¿žF:nǵLø k'¯ü$ÿ‡Ë3ƒø 7žñÌ°ÈaU1.gˆ€rÞÅaä|õ …ÔÄub Æõ>³©f¶º™óÎ Ø}pDÐøfJ'ÔƒpptZ®-v%¡jÕ2Y@yÁâ£ÈÁÇ <÷¥HQêdHô>Kž·WèÃC æ©ž` (b€[}˜BaÊ Áu3ZÏ`—Y8ŸFóÇ… €='VYÆel(Yòn `2ÄU–·#‰’j­ÖçPÔÈÁ}¸+…ù#ƒ€}BÖùb}°u ’ìLˆL¸Ñä==>>¸ ³À_<ù‚«<@ëzÛÕ açÁîi‘ùÏ48X d° d€íL¤­]g#mNÌÝÀÕ(åÔC'På2ˆþˆ+D?j™}²q¢ÈãÅ(‹@/¼còŒ•1\X…X•œ8x ­g€Ô[Z°à¸Zä€Î RÁÑæ-^Ç€øEŽkªbMõÚP0ÇEÂÖt(‰ •LÍpó‡›d`ð èœ@ f­°ìêV#<;å`H"®¢9ŠD4ŒÁ)•Ã€>¥ž9 ö¦Æ82Â4'(¦£[Dû3<>¦bÏY°ÿ‘×K°èjôgáÒGl>˜} õÈ$&6^O¨àˆp]  Ü&µœ©¦Í YÆsÀeB—ňòVëáFŹíS3d¬õ˜ ѦŸdšÙBŒ ¨³”µ©Z– _ò N(¤—ÎB:B¬‚Exxyèþ"€@W,š^+e®Øˆ `€,»¤ “s#;ÙÃ®È Y‚@0Ä1…ôb²Tìp —}1ÁdxäÔ §3âHçÁV€€g{X\°° s÷Â(þRL  ¢olvS¬´mT`@¾0:qH:2~v}ð[â5÷0*`â©{¯j@p$-¶ÙyYc}‰`€X^Ï’›$‚Jv|”Ñü$ @‡`0gý{rѸSÕâММ?}È×ÙÀ°à:BåÛ2zxy·(€ @0€„1å€)NFË-L~´!€œ3„/Z@ €NWXw£ùníèYD.Z ìjQˆÿ_E!¨(¬0l¼5K7Z‚à @c¾À;ã>XJÇ;î"¤ ÏòC škû ØZèþkÀ/À ~P¤"¾?fÄm!$ +· A{œÜßUÐ ¨i °ôïŽé>óÀ€xØ’€*5Ø`5;P°(©#*`T`ˆ•‡TûŠð€À C€Ô|KÈÃCÍ-Ív¿º;u}}۫Ꙩ,‚ä‘ì°5Ja¨Àži„sÈê`>Í~Ýf=À=¥R¦ì/Ô…X‰9áê‚ÜVQ Ž’e‘¤‰MR¥S€ t™0òqÿØש aX~¸Pã$UšÃ˜Ð¦'Ç?€:¢ yµ0ÜÀ3Ï>r°€'cÀ,çQ íÿP)%s“¾ç"gÁg1NRCÇèü° KV`¤ 2r]œ}õ@@Ì3†€å†ñãï…‚˜ $CWN/%lç€ÍWÐwÀbMJ¢{¿qƒÜS^p¤ ™,a÷žù0¦ìuÐ@¯ÞùÆÇ€ì •òÒO¼Ð €º‰E§ ÀEí@!à H[¹³€—{Dô :ä(2q%ê>À`P*Bø%!r€Ä˜qi8²€j@“?rbU‡}^A¤åu†'y`ÒxÉ`ÒxôQÄ€Åt¯± 'à¥büÉ,;€á8:PÀ †ü‚¼|BËQ:>!aÔ`˜R©E•ÐZL6ñà€ØV˜&”¥»ýèÀà @5,§&'ås½â”À¨ƒI©&%[å,à5lÌ €éQ(v¶jCÒIÁÕ0` Tš ´º91aÙõ¨Žp €@BIÀa‹,¡œ•²:Ýyj±ë‹þˆ S’SÊZÂÕì?$ §£9øÕÔÄ<ð`ÿ–ïÉñîÀ· Qµ‡U\$dUmj4(ö¬`Êgb|Aš;r%„ÑP!®òc‡s@IÁjÕ¦£#8 tˆ¡mÛèv4ðáDédHzŽ©‰4î·€?’h¸ñ8¸?­bÇ qSå‘“þÀÒÉÀl,t'VsÇ6#k0áÁfPÔÀìÀP!€`†‚ÐrÏÙÏÞp Áøü° HY‹ÌĤv„vX'ÄwƒPXha!)@½âË(‘Æ8ïèþHMBnî͸Ä*Übà ¥$°(QD±†¡œ;oyÍ÷Ï—‡Ä²±yz‚€3‰]DÒÂé@ ;+¾ ,.Ü^à0?JC ˆ-;vÙ â;]à€@¼”–|­–‹Â› }|ãÀ¤wFaÅ5€ @5 +‰ 0XC0\MÔ‰ €4Ô¨ß65 Dªx2ih) &èV %)WÌù¤÷åøþù?CŠÛ!F³©Hx~g'ÓÀ€‡ær}µ& R€MÊé +!·éã1Æ7¼è %\ˆ01 Ù{l¿…ÜÎú`€j@Ž’j0{ ´ Àb_îf´!€^ð’ÿªa0 Â‰…bƒ6(¤+l£ ³à?j¡ÂÛ˜ìÈÒ=ÀÜoZ‡þ¦Kµ¸uúHà7`Íÿ`ÍÿS%‹ ² 3€È0)B¤)M› <ÁáVO¥I¥T–UG5¬Tg v*}Tj;˜G®Xy•0å0Q8*âÍq@>‡3eªÔ•Ž'p„%Ø{H5œ@©ƒ¶[Ã܃rÈ >Âô³„橘°ü…“˜ñ,lçïoÙζ®?Ð÷j˜€à" 6"~u›ãÔÝ^ÖñÎ¥ªŨ"ôøO‰ÂªdN88sGnçʼnñì°â!”!AÌôhxuL8Ň0ZÞBÄ U…uÀg å°àX¶S#Ýd :Çør•ÅYŠlø@ª˜‘ݸ\ãÛ%Ÿ°nÿ‘Øâ=¨â}D"që ¶"›g­ÜØçsÄÁÎ ß\õDvr<ªYöªŽk`ÔôÕ¼Êf'¤º¦\D¸NsOÀ>’Üãœæj©˜‡³ðè[Ã×8öÖ£ÖN©‘£ãÔÁ礎ç¨vQ>±Îptpº ©ƒÜ~G`ó#2•”èvƨ{гΩ„â.Xè(É e‰œK¬öî‚ÉõkjµT8û—‡MãÎUĨ†-•¬Èò4œéÀ {w†‰bt=ÏE’c“¤aNQ'g~Ç-¬ðS…Q»Q,Ð8û5ÎÀ2µAÔN ¨”&c‡Hâä‹#CJUØÙ°BÃãkõ?¦§ z=vµZêg>@ #Þ’õj‡Õ.8]r­g=<‚;Ñõ¯<–\Õum@BqõEvèULà z4k®µï]ž¡sÁñÐuT€âuh Q‘æªmmTQë¥û: ’Ì:iP‰œ {ç‘Bô}D§yÚÿ­¢dÖHM»Öæ­L:´'Ô[<mlëR o¹³oú§j—Y¡@>§™À rmz½rä¨|…  ” ®Œ6"YULñà-.„HQßm`-‚¦p·bitstring-bitstring-3.1.7/test/test_bitarray.py000066400000000000000000000312731365434337700217640ustar00rootroot00000000000000#!/usr/bin/env python """ Unit tests for the bitarray module. """ import unittest import sys sys.path.insert(0, '..') import bitstring from bitstring import BitArray class All(unittest.TestCase): def testCreationFromUint(self): s = BitArray(uint=15, length=6) self.assertEqual(s.bin, '001111') s = BitArray(uint=0, length=1) self.assertEqual(s.bin, '0') s.uint = 1 self.assertEqual(s.uint, 1) s = BitArray(length=8) s.uint = 0 self.assertEqual(s.uint, 0) s.uint = 255 self.assertEqual(s.uint, 255) self.assertEqual(s.len, 8) with self.assertRaises(bitstring.CreationError): s.uint = 256 def testCreationFromOct(self): s = BitArray(oct='7') self.assertEqual(s.oct, '7') self.assertEqual(s.bin, '111') s.append('0o1') self.assertEqual(s.bin, '111001') s.oct = '12345670' self.assertEqual(s.length, 24) self.assertEqual(s.bin, '001010011100101110111000') s = BitArray('0o123') self.assertEqual(s.oct, '123') class NoPosAttribute(unittest.TestCase): def testReplace(self): s = BitArray('0b01') s.replace('0b1', '0b11') self.assertEqual(s, '0b011') def testDelete(self): s = BitArray('0b000000001') del s[-1:] self.assertEqual(s, '0b00000000') def testInsert(self): s = BitArray('0b00') s.insert('0xf', 1) self.assertEqual(s, '0b011110') def testInsertParameters(self): s = BitArray('0b111') with self.assertRaises(TypeError): s.insert('0x4') def testOverwrite(self): s = BitArray('0b01110') s.overwrite('0b000', 1) self.assertEqual(s, '0b00000') def testOverwriteParameters(self): s = BitArray('0b0000') with self.assertRaises(TypeError): s.overwrite('0b111') def testPrepend(self): s = BitArray('0b0') s.prepend([1]) self.assertEqual(s, [1, 0]) def testRol(self): s = BitArray('0b0001') s.rol(1) self.assertEqual(s, '0b0010') def testRor(self): s = BitArray('0b1000') s.ror(1) self.assertEqual(s, '0b0100') def testSetItem(self): s = BitArray('0b000100') s[4:5] = '0xf' self.assertEqual(s, '0b000111110') s[0:1] = [1] self.assertEqual(s, '0b100111110') class Bugs(unittest.TestCase): def testAddingNonsense(self): a = BitArray([0]) a += '0' # a uint of length 0 - so nothing gets added. self.assertEqual(a, [0]) with self.assertRaises(ValueError): a += '3' with self.assertRaises(ValueError): a += 'se' with self.assertRaises(ValueError): a += 'float:32' def testPrependAfterCreationFromDataWithOffset(self): s1 = BitArray(bytes=b'\x00\x00\x07\xff\xf0\x00', offset=21, length=15) self.assertFalse(s1.any(0)) s1.prepend('0b0') self.assertEqual(s1.bin, '0111111111111111') s1.prepend('0b0') self.assertEqual(s1.bin, '00111111111111111') class ByteAligned(unittest.TestCase): def testDefault(self, defaultbytealigned=bitstring.bytealigned): self.assertFalse(defaultbytealigned) def testChangingIt(self): bitstring.bytealigned = True self.assertTrue(bitstring.bytealigned) bitstring.bytealigned = False def testNotByteAligned(self): bitstring.bytealigned = False a = BitArray('0x00 ff 0f f') l = list(a.findall('0xff')) self.assertEqual(l, [8, 20]) p = a.find('0x0f')[0] self.assertEqual(p, 4) p = a.rfind('0xff')[0] self.assertEqual(p, 20) s = list(a.split('0xff')) self.assertEqual(s, ['0x00', '0xff0', '0xff']) a.replace('0xff', '') self.assertEqual(a, '0x000') def testByteAligned(self): bitstring.bytealigned = True a = BitArray('0x00 ff 0f f') l = list(a.findall('0xff')) self.assertEqual(l, [8]) p = a.find('0x0f')[0] self.assertEqual(p, 16) p = a.rfind('0xff')[0] self.assertEqual(p, 8) s = list(a.split('0xff')) self.assertEqual(s, ['0x00', '0xff0ff']) a.replace('0xff', '') self.assertEqual(a, '0x000ff') class SliceAssignment(unittest.TestCase): def testSliceAssignmentSingleBit(self): a = BitArray('0b000') a[2] = '0b1' self.assertEqual(a.bin, '001') a[0] = BitArray(bin='1') self.assertEqual(a.bin, '101') a[-1] = '0b0' self.assertEqual(a.bin, '100') a[-3] = '0b0' self.assertEqual(a.bin, '000') def testSliceAssignmentSingleBitErrors(self): a = BitArray('0b000') with self.assertRaises(IndexError): a[-4] = '0b1' with self.assertRaises(IndexError): a[3] = '0b1' with self.assertRaises(TypeError): a[1] = 1.3 def testSliceAssignmentMulipleBits(self): a = BitArray('0b0') a[0] = '0b110' self.assertEqual(a.bin, '110') a[0] = '0b000' self.assertEqual(a.bin, '00010') a[0:3] = '0b111' self.assertEqual(a.bin, '11110') a[-2:] = '0b011' self.assertEqual(a.bin, '111011') a[:] = '0x12345' self.assertEqual(a.hex, '12345') a[:] = '' self.assertFalse(a) def testSliceAssignmentMultipleBitsErrors(self): a = BitArray() with self.assertRaises(IndexError): a[0] = '0b00' a += '0b1' a[0:2] = '0b11' self.assertEqual(a, '0b11') def testDelSliceStep(self): a = BitArray(bin='100111101001001110110100101') del a[::2] self.assertEqual(a.bin, '0110010101100') del a[3:9:3] self.assertEqual(a.bin, '01101101100') del a[2:7:1] self.assertEqual(a.bin, '011100') del a[::99] self.assertEqual(a.bin, '11100') del a[::1] self.assertEqual(a.bin, '') def testDelSliceNegativeStep(self): a = BitArray('0b0001011101101100100110000001') del a[5:23:-3] self.assertEqual(a.bin, '0001011101101100100110000001') del a[25:3:-3] self.assertEqual(a.bin, '00011101010000100001') del a[:6:-7] self.assertEqual(a.bin, '000111010100010000') del a[15::-2] self.assertEqual(a.bin, '0010000000') del a[::-1] self.assertEqual(a.bin, '') def testDelSliceNegativeEnd(self): a = BitArray('0b01001000100001') del a[:-5] self.assertEqual(a, '0b00001') a = BitArray('0b01001000100001') del a[-11:-5] self.assertEqual(a, '0b01000001') def testDelSliceErrors(self): a = BitArray(10) del a[5:3] self.assertEqual(a, 10) del a[3:5:-1] self.assertEqual(a, 10) def testDelSingleElement(self): a = BitArray('0b0010011') del a[-1] self.assertEqual(a.bin, '001001') del a[2] self.assertEqual(a.bin, '00001') with self.assertRaises(IndexError): del a[5] def testSetSliceStep(self): a = BitArray(bin='0000000000') a[::2] = '0b11111' self.assertEqual(a.bin, '1010101010') a[4:9:3] = [0, 0] self.assertEqual(a.bin, '1010001010') a[7:3:-1] = [1, 1, 1, 0] self.assertEqual(a.bin, '1010011110') a[7:1:-2] = [0, 0, 1] self.assertEqual(a.bin, '1011001010') a[::-5] = [1, 1] self.assertEqual(a.bin, '1011101011') a[::-1] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1] self.assertEqual(a.bin, '1000000000') def testSetSliceErrors(self): a = BitArray(8) try: a[::3] = [1] self.assertTrue(False) except ValueError: pass class A(object): pass try: a[1:2] = A() self.assertTrue(False) except TypeError: pass try: a[1:4:-1] = [1, 2] self.assertTrue(False) except ValueError: pass class Subclassing(unittest.TestCase): def testIsInstance(self): class SubBits(BitArray): pass a = SubBits() self.assertTrue(isinstance(a, SubBits)) def testClassType(self): class SubBits(BitArray): pass self.assertEqual(SubBits().__class__, SubBits) class Clear(unittest.TestCase): def testClear(self): s = BitArray('0xfff') s.clear() self.assertEqual(s.len, 0) class Copy(unittest.TestCase): def testCopyMethod(self): s = BitArray(9) t = s.copy() self.assertEqual(s, t) t[0] = True self.assertEqual(t.bin, '100000000') self.assertEqual(s.bin, '000000000') class ModifiedByAddingBug(unittest.TestCase): def testAdding(self): a = BitArray('0b0') b = BitArray('0b11') c = a + b self.assertEqual(c, '0b011') self.assertEqual(a, '0b0') self.assertEqual(b, '0b11') class Lsb0Setting(unittest.TestCase): @classmethod def setUpClass(cls): bitstring.set_lsb0(True) @classmethod def tearDownClass(cls): bitstring.set_lsb0(False) def testSetSingleBit(self): a = BitArray(10) a[0] = True self.assertEqual(a, '0b0000000001') a[1] = True self.assertEqual(a, '0b0000000011') a[0] = False self.assertEqual(a, '0b0000000010') a[9] = True self.assertEqual(a, '0b1000000010') with self.assertRaises(IndexError): a[10] = True def testSetSingleNegativeBit(self): a = BitArray('0o000') a[-1] = True self.assertEqual(a, '0b100000000') a[-2] = True self.assertEqual(a, '0o600') a[-9] = True self.assertEqual(a, '0o601') with self.assertRaises(IndexError): a[-10] = True def testInvertBit(self): a = BitArray('0b11110000') a.invert() self.assertEqual(a, '0x0f') a.invert(0) self.assertEqual(a, '0b00001110') a.invert(-1) self.assertEqual(a, '0b10001110') def testDeletingBits(self): a = BitArray('0b11110') del a[0] self.assertEqual(a, '0xf') def testDeletingRange(self): a = BitArray('0b101111000') del a[0:1] self.assertEqual(a, '0b10111100') del a[2:6] self.assertEqual(a, '0b1000') a = BitArray('0xabcdef') del a[:8] self.assertEqual(a, '0xabcd') del a[-4:] self.assertEqual(a, '0xbcd') del a[:-4] self.assertEqual(a, '0xb') def testAppendingBits(self): a = BitArray('0b111') a.append('0b000') self.assertEqual(a.bin, '111000') a += '0xabc' self.assertEqual(a, '0b111000, 0xabc') def testSettingSlice(self): a = BitArray('0x012345678') a[4:12] = '0xfe' self.assertEqual(a, '0x012345fe8') a[0:4] = '0xbeef' self.assertEqual(a, '0x012345febeef') def testTruncatingStart(self): a = BitArray('0b1110000') a = a[4:] self.assertEqual(a, '0b111') def testTruncatingEnd(self): a = BitArray('0x123456') a = a[:16] self.assertEqual(a, '0x3456') def testAll(self): a = BitArray('0b0000101') self.assertTrue(a.all(1, [0, 2])) self.assertTrue(a.all(False, [-1, -2, -3, -4])) def testAny(self): a = BitArray('0b0001') self.assertTrue(a.any(1, [0, 1, 2])) def testEndswith(self): a = BitArray('0xdeadbeef') self.assertTrue(a.endswith('0xdead')) def testStartswith(self): a = BitArray('0xdeadbeef') self.assertTrue(a.startswith('0xbeef')) def testCut(self): a = BitArray('0xff00ff1111ff2222') l = list(a.cut(16)) self.assertEqual(l, ['0x2222', '0x11ff', '0xff11', '0xff00']) def testFind(self): pass # a = BitArray('0b10101010, 0xabcd, 0b10101010, 0x0') # p, = a.find('0b10101010', bytealigned=False) # self.assertEqual(p, 4) # p, = a.find('0b10101010', start=4, bytealigned=False) # self.assertEqual(p, 4) # p, = a.find('0b10101010', start=5, bytealigned=False) # self.assertEqual(p, 28) def testRfind(self): pass def testFindall(self): pass def testSplit(self): pass def testByteSwap(self): pass def testInsert(self): pass def testOverwrite(self): pass def testReplace(self): pass def testReverse(self): pass def testRor(self): pass def testRol(self): pass def testSet(self): pass bitstring-bitstring-3.1.7/test/test_bits.py000066400000000000000000000434151365434337700211110ustar00rootroot00000000000000#!/usr/bin/env python import unittest import sys sys.path.insert(0, '..') import bitstring import array from bitstring import MmapByteArray from bitstring import Bits, BitArray, ConstByteStore class Creation(unittest.TestCase): def testCreationFromBytes(self): s = Bits(bytes=b'\xa0\xff') self.assertEqual((s.len, s.hex), (16, 'a0ff')) s = Bits(bytes=b'abc', length=0) self.assertEqual(s, '') def testCreationFromBytesErrors(self): with self.assertRaises(bitstring.CreationError): Bits(bytes=b'abc', length=25) def testCreationFromDataWithOffset(self): s1 = Bits(bytes=b'\x0b\x1c\x2f', offset=0, length=20) s2 = Bits(bytes=b'\xa0\xb1\xC2', offset=4) self.assertEqual((s2.len, s2.hex), (20, '0b1c2')) self.assertEqual((s1.len, s1.hex), (20, '0b1c2')) self.assertTrue(s1 == s2) def testCreationFromHex(self): s = Bits(hex='0xA0ff') self.assertEqual((s.len, s.hex), (16, 'a0ff')) s = Bits(hex='0x0x0X') self.assertEqual((s.length, s.hex), (0, '')) def testCreationFromHexWithWhitespace(self): s = Bits(hex=' \n0 X a 4e \r3 \n') self.assertEqual(s.hex, 'a4e3') def testCreationFromHexErrors(self): with self.assertRaises(bitstring.CreationError): Bits(hex='0xx0') with self.assertRaises(bitstring.CreationError): Bits(hex='0xX0') with self.assertRaises(bitstring.CreationError): Bits(hex='0Xx0') with self.assertRaises(bitstring.CreationError): Bits(hex='-2e') # These really should fail, but it's awkward and not a big deal... # with self.assertRaises(bitstring.CreationError): # Bits('0x2', length=2) # with self.assertRaises(bitstring.CreationError): # Bits('0x3', offset=1) def testCreationFromBin(self): s = Bits(bin='1010000011111111') self.assertEqual((s.length, s.hex), (16, 'a0ff')) s = Bits(bin='00')[:1] self.assertEqual(s.bin, '0') s = Bits(bin=' 0000 \n 0001\r ') self.assertEqual(s.bin, '00000001') def testCreationFromBinWithWhitespace(self): s = Bits(bin=' \r\r\n0 B 00 1 1 \t0 ') self.assertEqual(s.bin, '00110') def testCreationFromOctErrors(self): s = Bits('0b00011') with self.assertRaises(bitstring.InterpretError): s.oct with self.assertRaises(bitstring.CreationError): Bits('oct=8') def testCreationFromUintWithOffset(self): with self.assertRaises(bitstring.CreationError): Bits(uint=12, length=8, offset=1) def testCreationFromUintErrors(self): with self.assertRaises(bitstring.CreationError): Bits(uint=-1, length=10) with self.assertRaises(bitstring.CreationError): Bits(uint=12) with self.assertRaises(bitstring.CreationError): Bits(uint=4, length=2) with self.assertRaises(bitstring.CreationError): Bits(uint=0, length=0) with self.assertRaises(bitstring.CreationError): Bits(uint=12, length=-12) def testCreationFromInt(self): s = Bits(int=0, length=4) self.assertEqual(s.bin, '0000') s = Bits(int=1, length=2) self.assertEqual(s.bin, '01') s = Bits(int=-1, length=11) self.assertEqual(s.bin, '11111111111') s = Bits(int=12, length=7) self.assertEqual(s.int, 12) s = Bits(int=-243, length=108) self.assertEqual((s.int, s.length), (-243, 108)) for length in range(6, 10): for value in range(-17, 17): s = Bits(int=value, length=length) self.assertEqual((s.int, s.length), (value, length)) s = Bits(int=10, length=8) def testCreationFromIntErrors(self): with self.assertRaises(bitstring.CreationError): Bits(int=-1, length=0) with self.assertRaises(bitstring.CreationError): Bits(int=12) with self.assertRaises(bitstring.CreationError): Bits(int=4, length=3) with self.assertRaises(bitstring.CreationError): Bits(int=-5, length=3) def testCreationFromSe(self): for i in range(-100, 10): s = Bits(se=i) self.assertEqual(s.se, i) def testCreationFromSeWithOffset(self): with self.assertRaises(bitstring.CreationError): Bits(se=-13, offset=1) def testCreationFromSeErrors(self): with self.assertRaises(bitstring.CreationError): Bits(se=-5, length=33) s = Bits(bin='001000') with self.assertRaises(bitstring.InterpretError): s.se def testCreationFromUe(self): [self.assertEqual(Bits(ue=i).ue, i) for i in range(0, 20)] def testCreationFromUeWithOffset(self): with self.assertRaises(bitstring.CreationError): Bits(ue=104, offset=2) def testCreationFromUeErrors(self): with self.assertRaises(bitstring.CreationError): Bits(ue=-1) with self.assertRaises(bitstring.CreationError): Bits(ue=1, length=12) s = Bits(bin='10') with self.assertRaises(bitstring.InterpretError): s.ue def testCreationFromBool(self): a = Bits('bool=1') self.assertEqual(a, 'bool=1') b = Bits('bool:1=0') self.assertEqual(b, [0]) c = bitstring.pack('bool=1, 2*bool', 0, 1) self.assertEqual(c, '0b101') d = bitstring.pack('bool:1=1, 2*bool:1', 1, 0) self.assertEqual(d, '0b110') def testCreationKeywordError(self): with self.assertRaises(bitstring.CreationError): Bits(squirrel=5) def testDataStoreType(self): a = Bits('0xf') self.assertEqual(type(a._datastore), bitstring.ConstByteStore) class Initialisation(unittest.TestCase): def testEmptyInit(self): a = Bits() self.assertEqual(a, '') def testNoPos(self): a = Bits('0xabcdef') try: a.pos except AttributeError: pass else: assert False def testFind(self): a = Bits('0xabcd') r = a.find('0xbc') self.assertEqual(r[0], 4) r = a.find('0x23462346246', bytealigned=True) self.assertFalse(r) def testRfind(self): a = Bits('0b11101010010010') b = a.rfind('0b010') self.assertEqual(b[0], 11) def testFindAll(self): a = Bits('0b0010011') b = list(a.findall([1])) self.assertEqual(b, [2, 5, 6]) class Cut(unittest.TestCase): def testCut(self): s = Bits(30) for t in s.cut(3): self.assertEqual(t, [0] * 3) class InterleavedExpGolomb(unittest.TestCase): def testCreation(self): s1 = Bits(uie=0) s2 = Bits(uie=1) self.assertEqual(s1, [1]) self.assertEqual(s2, [0, 0, 1]) s1 = Bits(sie=0) s2 = Bits(sie=-1) s3 = Bits(sie=1) self.assertEqual(s1, [1]) self.assertEqual(s2, [0, 0, 1, 1]) self.assertEqual(s3, [0, 0, 1, 0]) def testCreationFromProperty(self): s = BitArray() s.uie = 45 self.assertEqual(s.uie, 45) s.sie = -45 self.assertEqual(s.sie, -45) def testInterpretation(self): for x in range(101): self.assertEqual(Bits(uie=x).uie, x) for x in range(-100, 100): self.assertEqual(Bits(sie=x).sie, x) def testErrors(self): for f in ['sie=100, 0b1001', '0b00', 'uie=100, 0b1001']: s = Bits(f) with self.assertRaises(bitstring.InterpretError): s.sie with self.assertRaises(bitstring.InterpretError): s.uie with self.assertRaises(ValueError): Bits(uie=-10) class FileBased(unittest.TestCase): def setUp(self): self.a = Bits(filename='smalltestfile') self.b = Bits(filename='smalltestfile', offset=16) self.c = Bits(filename='smalltestfile', offset=20, length=16) self.d = Bits(filename='smalltestfile', offset=20, length=4) def testCreationWithOffset(self): self.assertEqual(self.a, '0x0123456789abcdef') self.assertEqual(self.b, '0x456789abcdef') self.assertEqual(self.c, '0x5678') def testBitOperators(self): x = self.b[4:20] self.assertEqual(x, '0x5678') self.assertEqual((x & self.c).hex, self.c.hex) self.assertEqual(self.c ^ self.b[4:20], 16) self.assertEqual(self.a[23:36] | self.c[3:], self.c[3:]) def testAddition(self): h = self.d + '0x1' x = self.a[20:24] + self.c[-4:] + self.c[8:12] self.assertEqual(x, '0x587') x = self.b + x self.assertEqual(x.hex, '456789abcdef587') x = BitArray(x) del x[12:24] self.assertEqual(x, '0x456abcdef587') class Mmap(unittest.TestCase): def setUp(self): self.f = open('smalltestfile', 'rb') def tearDown(self): self.f.close() def testByteArrayEquivalence(self): a = MmapByteArray(self.f) self.assertEqual(a.bytelength, 8) self.assertEqual(len(a), 8) self.assertEqual(a[0], 0x01) self.assertEqual(a[1], 0x23) self.assertEqual(a[7], 0xef) self.assertEqual(a[0:1], bytearray([1])) self.assertEqual(a[:], bytearray([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef])) self.assertEqual(a[2:4], bytearray([0x45, 0x67])) def testWithLength(self): a = MmapByteArray(self.f, 3) self.assertEqual(a[0], 0x01) self.assertEqual(len(a), 3) def testWithOffset(self): a = MmapByteArray(self.f, None, 5) self.assertEqual(len(a), 3) self.assertEqual(a[0], 0xab) def testWithLengthAndOffset(self): a = MmapByteArray(self.f, 3, 3) self.assertEqual(len(a), 3) self.assertEqual(a[0], 0x67) self.assertEqual(a[:], bytearray([0x67, 0x89, 0xab])) class Comparisons(unittest.TestCase): def testUnorderable(self): a = Bits(5) b = Bits(5) with self.assertRaises(TypeError): a < b with self.assertRaises(TypeError): a > b with self.assertRaises(TypeError): a <= b with self.assertRaises(TypeError): a >= b class Subclassing(unittest.TestCase): def testIsInstance(self): class SubBits(bitstring.Bits): pass a = SubBits() self.assertTrue(isinstance(a, SubBits)) def testClassType(self): class SubBits(bitstring.Bits): pass self.assertEqual(SubBits().__class__, SubBits) class LongBoolConversion(unittest.TestCase): def testLongBool(self): a = Bits(1000) b = bool(a) self.assertTrue(b is False) # Some basic tests for the private ByteStore classes class ConstByteStoreCreation(unittest.TestCase): def testProperties(self): a = ConstByteStore(bytearray(b'abc')) self.assertEqual(a.bytelength, 3) self.assertEqual(a.offset, 0) self.assertEqual(a.bitlength, 24) self.assertEqual(a._rawarray, b'abc') def testGetBit(self): a = ConstByteStore(bytearray([0x0f])) self.assertEqual(a.getbit(0), False) self.assertEqual(a.getbit(3), False) self.assertEqual(a.getbit(4), True) self.assertEqual(a.getbit(7), True) b = ConstByteStore(bytearray([0x0f]), 7, 1) self.assertEqual(b.getbit(2), False) self.assertEqual(b.getbit(3), True) def testGetByte(self): a = ConstByteStore(bytearray(b'abcde'), 1, 13) self.assertEqual(a.getbyte(0), 97) self.assertEqual(a.getbyte(1), 98) self.assertEqual(a.getbyte(4), 101) class PadToken(unittest.TestCase): def testCreation(self): a = Bits('pad:10') self.assertEqual(a, Bits(10)) b = Bits('pad:0') self.assertEqual(b, Bits()) c = Bits('0b11, pad:1, 0b111') self.assertEqual(c, Bits('0b110111')) def testPack(self): s = bitstring.pack('0b11, pad:3=5, 0b1') self.assertEqual(s.bin, '110001') d = bitstring.pack('pad:c', c=12) self.assertEqual(d, Bits(12)) e = bitstring.pack('0xf, uint:12, pad:1, bin, pad:4, 0b10', 0, '111') self.assertEqual(e.bin, '11110000000000000111000010') def testUnpack(self): s = Bits('0b111000111') x, y = s.unpack('3, pad:3, 3') self.assertEqual((x, y), (7, 7)) x, y = s.unpack('2, pad:2, bin') self.assertEqual((x, y), (3, '00111')) x = s.unpack('pad:1, pad:2, pad:3') self.assertEqual(x, []) class ModifiedByAddingBug(unittest.TestCase): def testAdding(self): a = Bits('0b0') b = Bits('0b11') c = a + b self.assertEqual(c, '0b011') self.assertEqual(a, '0b0') self.assertEqual(b, '0b11') def testAdding2(self): a = Bits(100) b = Bits(101) c = a + b self.assertEqual(a, 100) self.assertEqual(b, 101) self.assertEqual(c, 201) class WrongTypeBug(unittest.TestCase): def testAppendToBits(self): a = Bits(BitArray()) with self.assertRaises(AttributeError): a.append('0b1') self.assertEqual(type(a), Bits) b = bitstring.ConstBitStream(bitstring.BitStream()) self.assertEqual(type(b), bitstring.ConstBitStream) class InitFromArray(unittest.TestCase): def testEmptyArray(self): a = array.array('B') b = Bits(a) self.assertEqual(b.length, 0) def testSingleByte(self): a = array.array('B', b'\xff') b = Bits(a) self.assertEqual(b.length, 8) self.assertEqual(b.hex, 'ff') def testSignedShort(self): a = array.array('h') a.append(10) a.append(-1) b = Bits(a) self.assertEqual(b.length, 32) try: self.assertEqual(b.bytes, a.tobytes()) except AttributeError: self.assertEqual(b.bytes, a.tostring()) # Python 2.7 def testDouble(self): a = array.array('d', [0.0, 1.0, 2.5]) b = Bits(a) self.assertEqual(b.length, 192) c, d, e = b.unpack('3*floatne:64') self.assertEqual((c, d, e), (0.0, 1.0, 2.5)) class Iteration(unittest.TestCase): def testIterateEmptyBits(self): self.assertEqual(list(Bits([])), []) self.assertEqual(list(Bits([1, 0])[1:1]), []) def testIterateNonEmptyBits(self): self.assertEqual(list(Bits([1, 0])), [True, False]) self.assertEqual(list(Bits([1, 0, 0, 1])[1:3]), [False, False]) def testIterateLongBits(self): self.assertEqual( list(Bits([1, 0]) * 1024), [True, False] * 1024 ) class ContainsBug(unittest.TestCase): def testContains(self): a = Bits('0b1, 0x0001dead0001') self.assertTrue('0xdead' in a) self.assertFalse('0xfeed' in a) self.assertTrue('0b1' in Bits('0xf')) self.assertFalse('0b0' in Bits('0xf')) class ByteStoreImmutablity(unittest.TestCase): def testBitsDataStoreType(self): a = Bits('0b1') b = Bits('0b111') c = a + b self.assertEqual(type(a._datastore), ConstByteStore) self.assertEqual(type(b._datastore), ConstByteStore) self.assertEqual(type(c._datastore), ConstByteStore) def testImmutabilityBugAppend(self): a = Bits('0b111') b = a + '0b000' c = BitArray(b) c[1] = 0 self.assertEqual(c.bin, '101000') self.assertEqual(a.bin, '111') self.assertEqual(b.bin, '111000') self.assertEqual(type(b._datastore), ConstByteStore) def testImmutabilityBugPrepend(self): a = Bits('0b111') b = '0b000' + a c = BitArray(b) c[1] = 1 self.assertEqual(b.bin, '000111') self.assertEqual(c.bin, '010111') def testImmutabilityBugCreation(self): a = Bits() self.assertEqual(type(a._datastore), ConstByteStore) class Lsb0Indexing(unittest.TestCase): @classmethod def setUpClass(cls): bitstring.set_lsb0(True) @classmethod def tearDownClass(cls): bitstring.set_lsb0(False) def testGetSingleBit(self): a = Bits('0b000001111') self.assertEqual(a[0], True) self.assertEqual(a[3], True) self.assertEqual(a[4], False) self.assertEqual(a[8], False) with self.assertRaises(IndexError): a[9] self.assertEqual(a[-1], False) self.assertEqual(a[-5], False) self.assertEqual(a[-6], True) self.assertEqual(a[-9], True) with self.assertRaises(IndexError): a[-10] def testSimpleSlicing(self): a = Bits('0xabcdef') self.assertEqual(a[0:4], '0xf') self.assertEqual(a[4:8], '0xe') self.assertEqual(a[:], '0xabcdef') self.assertEqual(a[4:], '0xabcde') self.assertEqual(a[-4:], '0xa') self.assertEqual(a[-8:-4], '0xb') self.assertEqual(a[:-8], '0xcdef') def testExtendedSlicing(self): a = Bits('0b100000100100100') self.assertEqual(a[2::3], '0b10111') def testAll(self): a = Bits('0b000111') self.assertTrue(a.all(1, [0, 1, 2])) self.assertTrue(a.all(0, [3, 4, 5])) def testAny(self): a = Bits('0b00000110') self.assertTrue(a.any(1, [0, 1])) self.assertTrue(a.any(0, [5, 6])) def testStartswith(self): a = Bits('0b0000000111') self.assertTrue(a.startswith('0b111')) self.assertFalse(a.startswith(1)) self.assertTrue(a.startswith('0b011', start=1)) self.assertFalse(a.startswith('0b0111', end=3)) self.assertTrue(a.startswith('0b0111', end=4)) def testEndsWith(self): a = Bits('0x1234abcd') self.assertTrue(a.endswith('0x123')) self.assertFalse(a.endswith('0xabcd')) bitstring-bitstring-3.1.7/test/test_bitstore.py000066400000000000000000000021551365434337700217770ustar00rootroot00000000000000#!/usr/bin/env python import unittest import sys sys.path.insert(0, '..') from bitstring import ByteStore, ConstByteStore, equal, offsetcopy class OffsetCopy(unittest.TestCase): def testStraightCopy(self): s = ByteStore(bytearray([10, 5, 1]), 24, 0) t = offsetcopy(s, 0) self.assertEqual(t._rawarray, bytearray([10, 5, 1])) def testOffsetIncrease(self): s = ByteStore(bytearray([1, 1, 1]), 24, 0) t = offsetcopy(s, 4) self.assertEqual(t.bitlength, 24) self.assertEqual(t.offset, 4) self.assertEqual(t._rawarray, bytearray([0, 16, 16, 16])) class Equals(unittest.TestCase): def testBothSingleByte(self): s = ByteStore(bytearray([128]), 3, 0) t = ByteStore(bytearray([64]), 3, 1) u = ByteStore(bytearray([32]), 3, 2) self.assertTrue(equal(s, t)) self.assertTrue(equal(s, u)) self.assertTrue(equal(u, t)) def testOneSingleByte(self): s = ByteStore(bytearray([1, 0]), 2, 7) t = ByteStore(bytearray([64]), 2, 1) self.assertTrue(equal(s, t)) self.assertTrue(equal(t, s)) bitstring-bitstring-3.1.7/test/test_bitstream.py000066400000000000000000004200141365434337700221340ustar00rootroot00000000000000#!/usr/bin/env python import unittest import sys sys.path.insert(0, '..') import bitstring import copy import os import collections from bitstring import BitStream, ConstBitStream, pack from bitstring import offsetcopy try: collectionsAbc = collections.abc except AttributeError: # Python 2.7 collectionsAbc = collections class FlexibleInitialisation(unittest.TestCase): def testFlexibleInitialisation(self): a = BitStream('uint:8=12') c = BitStream(' uint : 8 = 12') self.assertTrue(a == c == BitStream(uint=12, length=8)) self.assertEqual(a.uint, 12) a = BitStream(' int:2= -1') b = BitStream('int :2 = -1') c = BitStream(' int: 2 =-1 ') self.assertTrue(a == b == c == BitStream(int=-1, length=2)) def testFlexibleInitialisation2(self): h = BitStream('hex=12') o = BitStream('oct=33') b = BitStream('bin=10') self.assertEqual(h, '0x12') self.assertEqual(o, '0o33') self.assertEqual(b, '0b10') def testFlexibleInitialisation3(self): for s in ['se=-1', ' se = -1 ', 'se = -1']: a = BitStream(s) self.assertEqual(a.se, -1) for s in ['ue=23', 'ue =23', 'ue = 23']: a = BitStream(s) self.assertEqual(a.ue, 23) def testMultipleStringInitialisation(self): a = BitStream('0b1 , 0x1') self.assertEqual(a, '0b10001') a = BitStream('ue=5, ue=1, se=-2') self.assertEqual(a.read('ue'), 5) self.assertEqual(a.read('ue'), 1) self.assertEqual(a.read('se'), -2) b = BitStream('uint:32 = 12, 0b11') + 'int:100=-100, 0o44' self.assertEqual(b.read(32).uint, 12) self.assertEqual(b.read(2).bin, '11') self.assertEqual(b.read(100).int, -100) class Reading(unittest.TestCase): def testReadBits(self): s = BitStream(bytes=b'\x4d\x55') self.assertEqual(s.read(4).hex, '4') self.assertEqual(s.read(8).hex, 'd5') self.assertEqual(s.read(1), [0]) self.assertEqual(s.read(3).bin, '101') self.assertFalse(s.read(0)) def testReadByte(self): s = BitStream(hex='4d55') self.assertEqual(s.read(8).hex, '4d') self.assertEqual(s.read(8).hex, '55') def testReadBytes(self): s = BitStream(hex='0x112233448811') self.assertEqual(s.read(3 * 8).hex, '112233') with self.assertRaises(ValueError): s.read(-16) s.bitpos += 1 self.assertEqual(s.read(2 * 8).bin, '1000100100010000') def testReadUE(self): with self.assertRaises(bitstring.InterpretError): BitStream('').ue # The numbers 0 to 8 as unsigned Exponential-Golomb codes s = BitStream(bin='1 010 011 00100 00101 00110 00111 0001000 0001001') self.assertEqual(s.pos, 0) for i in range(9): self.assertEqual(s.read('ue'), i) with self.assertRaises(bitstring.ReadError): s.read('ue') def testReadSE(self): s = BitStream(bin='010 00110 0001010 0001000 00111') self.assertEqual(s.read('se'), 1) self.assertEqual(s.read('se'), 3) self.assertEqual(s.readlist(3 * ['se']), [5, 4, -3]) class Find(unittest.TestCase): def testFind1(self): s = ConstBitStream(bin='0b0000110110000') self.assertTrue(s.find(BitStream(bin='11011'))) self.assertEqual(s.bitpos, 4) self.assertEqual(s.read(5).bin, '11011') s.bitpos = 0 self.assertFalse(s.find('0b11001', False)) def testFind2(self): s = BitStream(bin='0') self.assertTrue(s.find(s, False)) self.assertEqual(s.pos, 0) self.assertFalse(s.find('0b00', False)) with self.assertRaises(ValueError): s.find(BitStream()) def testFindWithOffset(self): s = BitStream(hex='0x112233')[4:] self.assertTrue(s.find('0x23', False)) self.assertEqual(s.pos, 8) def testFindCornerCases(self): s = BitStream(bin='000111000111') self.assertTrue(s.find('0b000')) self.assertEqual(s.pos, 0) self.assertTrue(s.find('0b000')) self.assertEqual(s.pos, 0) self.assertTrue(s.find('0b0111000111')) self.assertEqual(s.pos, 2) self.assertTrue(s.find('0b000', start=2)) self.assertEqual(s.pos, 6) self.assertTrue(s.find('0b111', start=6)) self.assertEqual(s.pos, 9) s.pos += 2 self.assertTrue(s.find('0b1', start=s.pos)) def testFindBytes(self): s = BitStream('0x010203040102ff') self.assertFalse(s.find('0x05', bytealigned=True)) self.assertTrue(s.find('0x02', bytealigned=True)) self.assertEqual(s.read(16).hex, '0203') self.assertTrue(s.find('0x02', start=s.bitpos, bytealigned=True)) s.read(1) self.assertFalse(s.find('0x02', start=s.bitpos, bytealigned=True)) def testFindBytesAlignedCornerCases(self): s = BitStream('0xff') self.assertTrue(s.find(s)) self.assertFalse(s.find(BitStream(hex='0x12'))) self.assertFalse(s.find(BitStream(hex='0xffff'))) def testFindBytesBitpos(self): s = BitStream(hex='0x1122334455') s.pos = 2 s.find('0x66', bytealigned=True) self.assertEqual(s.pos, 2) s.pos = 38 s.find('0x66', bytealigned=True) self.assertEqual(s.pos, 38) def testFindByteAligned(self): s = BitStream(hex='0x12345678') self.assertTrue(s.find(BitStream(hex='0x56'), bytealigned=True)) self.assertEqual(s.bytepos, 2) s.pos = 0 self.assertFalse(s.find(BitStream(hex='0x45'), bytealigned=True)) s = BitStream('0x1234') s.find('0x1234') self.assertTrue(s.find('0x1234')) s += '0b111' s.pos = 3 s.find('0b1', start=17, bytealigned=True) self.assertFalse(s.find('0b1', start=17, bytealigned=True)) self.assertEqual(s.pos, 3) def testFindByteAlignedWithOffset(self): s = BitStream(hex='0x112233')[4:] self.assertTrue(s.find(BitStream(hex='0x23'))) def testFindByteAlignedErrors(self): s = BitStream(hex='0xffff') with self.assertRaises(ValueError): s.find('') with self.assertRaises(ValueError): s.find(BitStream()) class Rfind(unittest.TestCase): def testRfind(self): a = BitStream('0b001001001') b = a.rfind('0b001') self.assertEqual(b, (6,)) self.assertEqual(a.pos, 6) big = BitStream(length=100000) + '0x12' + BitStream(length=10000) found = big.rfind('0x12', bytealigned=True) self.assertEqual(found, (100000,)) self.assertEqual(big.pos, 100000) def testRfindByteAligned(self): a = BitStream('0x8888') b = a.rfind('0b1', bytealigned=True) self.assertEqual(b, (8,)) self.assertEqual(a.pos, 8) def testRfindStartbit(self): a = BitStream('0x0000ffffff') b = a.rfind('0x0000', start=1, bytealigned=True) self.assertEqual(b, ()) self.assertEqual(a.pos, 0) b = a.rfind('0x00', start=1, bytealigned=True) self.assertEqual(b, (8,)) self.assertEqual(a.pos, 8) def testRfindEndbit(self): a = BitStream('0x000fff') b = a.rfind('0b011', bytealigned=False, start=0, end=14) self.assertEqual(bool(b), True) b = a.rfind('0b011', False, 0, 13) self.assertEqual(b, ()) def testRfindErrors(self): a = BitStream('0x43234234') with self.assertRaises(ValueError): a.rfind('', bytealigned=True) with self.assertRaises(ValueError): a.rfind('0b1', start=-99, bytealigned=True) with self.assertRaises(ValueError): a.rfind('0b1', end=33, bytealigned=True) with self.assertRaises(ValueError): a.rfind('0b1', start=10, end=9, bytealigned=True) class Shift(unittest.TestCase): def testShiftLeft(self): s = BitStream('0b1010') t = s << 1 self.assertEqual(s.bin, '1010') self.assertEqual(t.bin, '0100') t = t << 0 self.assertEqual(t, '0b0100') t = t << 100 self.assertEqual(t.bin, '0000') def testShiftLeftErrors(self): s = BitStream() with self.assertRaises(ValueError): s << 1 s = BitStream('0xf') with self.assertRaises(ValueError): s << -1 def testShiftRight(self): s = BitStream('0b1010') t = s >> 1 self.assertEqual(s.bin, '1010') self.assertEqual(t.bin, '0101') q = s >> 0 self.assertEqual(q, '0b1010') q.replace('0b1010', '') s = s >> 100 self.assertEqual(s.bin, '0000') def testShiftRightErrors(self): s = BitStream() with self.assertRaises(ValueError): s >> 1 s = BitStream('0xf') with self.assertRaises(ValueError): s >> -1 def testShiftRightInPlace(self): s = BitStream('0xffff')[4:12] s >>= 1 self.assertEqual(s, '0b01111111') s = BitStream('0b11011') s >>= 2 self.assertEqual(s.bin, '00110') s >>= 100000000000000 self.assertEqual(s.bin, '00000') s = BitStream('0xff') s >>= 1 self.assertEqual(s, '0x7f') s >>= 0 self.assertEqual(s, '0x7f') def testShiftRightInPlaceErrors(self): s = BitStream() with self.assertRaises(ValueError): s >>= 1 s += '0b11' with self.assertRaises(ValueError): s >>= -1 def testShiftLeftInPlace(self): s = BitStream('0xffff') t = s[4:12] t <<= 2 self.assertEqual(t, '0b11111100') s = BitStream('0b11011') s <<= 2 self.assertEqual(s.bin, '01100') s <<= 100000000000000000000 self.assertEqual(s.bin, '00000') s = BitStream('0xff') s <<= 1 self.assertEqual(s, '0xfe') s <<= 0 self.assertEqual(s, '0xfe') def testShiftLeftInPlaceErrors(self): s = BitStream() with self.assertRaises(ValueError): s <<= 1 s += '0b11' with self.assertRaises(ValueError): s <<= -1 class Replace(unittest.TestCase): def testReplace1(self): a = BitStream('0b1') n = a.replace('0b1', '0b0', bytealigned=True) self.assertEqual(a.bin, '0') self.assertEqual(n, 1) n = a.replace('0b1', '0b0', bytealigned=True) self.assertEqual(n, 0) def testReplace2(self): a = BitStream('0b00001111111') n = a.replace('0b1', '0b0', bytealigned=True) self.assertEqual(a.bin, '00001111011') self.assertEqual(n, 1) n = a.replace('0b1', '0b0', bytealigned=False) self.assertEqual(a.bin, '00000000000') self.assertEqual(n, 6) def testReplace3(self): a = BitStream('0b0') n = a.replace('0b0', '0b110011111', bytealigned=True) self.assertEqual(n, 1) self.assertEqual(a.bin, '110011111') n = a.replace('0b11', '', bytealigned=False) self.assertEqual(n, 3) self.assertEqual(a.bin, '001') def testReplace4(self): a = BitStream('0x00114723ef4732344700') n = a.replace('0x47', '0x00', bytealigned=True) self.assertEqual(n, 3) self.assertEqual(a.hex, '00110023ef0032340000') a.replace('0x00', '', bytealigned=True) self.assertEqual(a.hex, '1123ef3234') a.replace('0x11', '', start=1, bytealigned=True) self.assertEqual(a.hex, '1123ef3234') a.replace('0x11', '0xfff', end=7, bytealigned=True) self.assertEqual(a.hex, '1123ef3234') a.replace('0x11', '0xfff', end=8, bytealigned=True) self.assertEqual(a.hex, 'fff23ef3234') def testReplace5(self): a = BitStream('0xab') b = BitStream('0xcd') c = BitStream('0xabef') c.replace(a, b) self.assertEqual(c, '0xcdef') self.assertEqual(a, '0xab') self.assertEqual(b, '0xcd') a = BitStream('0x0011223344') a.pos = 12 a.replace('0x11', '0xfff', bytealigned=True) self.assertEqual(a.pos, 8) self.assertEqual(a, '0x00fff223344') def testReplaceWithSelf(self): a = BitStream('0b11') a.replace('0b1', a) self.assertEqual(a, '0xf') a.replace(a, a) self.assertEqual(a, '0xf') def testReplaceCount(self): a = BitStream('0x223344223344223344') n = a.replace('0x2', '0x0', count=0, bytealigned=True) self.assertEqual(n, 0) self.assertEqual(a.hex, '223344223344223344') n = a.replace('0x2', '0x0', count=1, bytealigned=True) self.assertEqual(n, 1) self.assertEqual(a.hex, '023344223344223344') n = a.replace('0x33', '', count=2, bytealigned=True) self.assertEqual(n, 2) self.assertEqual(a.hex, '02442244223344') n = a.replace('0x44', '0x4444', count=1435, bytealigned=True) self.assertEqual(n, 3) self.assertEqual(a.hex, '02444422444422334444') def testReplaceBitpos(self): a = BitStream('0xff') a.bitpos = 8 a.replace('0xff', '', bytealigned=True) self.assertEqual(a.bitpos, 0) a = BitStream('0b0011110001') a.bitpos = 4 a.replace('0b1', '0b000') self.assertEqual(a.bitpos, 8) a = BitStream('0b1') a.bitpos = 1 a.replace('0b1', '0b11111', bytealigned=True) self.assertEqual(a.bitpos, 5) a.replace('0b11', '0b0', False) self.assertEqual(a.bitpos, 3) a.append('0b00') a.replace('0b00', '0xffff') self.assertEqual(a.bitpos, 17) def testReplaceErrors(self): a = BitStream('0o123415') with self.assertRaises(ValueError): a.replace('', 0o7, bytealigned=True) with self.assertRaises(ValueError): a.replace('0b1', '0b1', start=-100, bytealigned=True) with self.assertRaises(ValueError): a.replace('0b1', '0b1', end=19, bytealigned=True) class SliceAssignment(unittest.TestCase): # TODO: Move this to another class def testSetSlice(self): a = BitStream() a[0:0] = '0xabcdef' self.assertEqual(a.bytepos, 3) a[4:16] = '' self.assertEqual(a, '0xaef') self.assertEqual(a.bitpos, 4) a[8:] = '0x00' self.assertEqual(a, '0xae00') self.assertEqual(a.bytepos, 2) a += '0xf' a[8:] = '0xe' self.assertEqual(a, '0xaee') self.assertEqual(a.bitpos, 12) b = BitStream() b[0:800] = '0xffee' self.assertEqual(b, '0xffee') b[4:48] = '0xeed123' self.assertEqual(b, '0xfeed123') b[-800:8] = '0x0000' self.assertEqual(b, '0x0000ed123') a = BitStream('0xabcde') self.assertEqual(a[-100:-90], '') self.assertEqual(a[-100:-16], '0xa') a[-100:-16] = '0x0' self.assertEqual(a, '0x0bcde') def testInsertingUsingSetItem(self): a = BitStream() a[0:0] = '0xdeadbeef' self.assertEqual(a, '0xdeadbeef') self.assertEqual(a.bytepos, 4) a[16:16] = '0xfeed' self.assertEqual(a, '0xdeadfeedbeef') self.assertEqual(a.bytepos, 4) a[0:0] = '0xa' self.assertEqual(a, '0xadeadfeedbeef') self.assertEqual(a.bitpos, 4) a.bytepos = 6 a[0:0] = '0xff' self.assertEqual(a.bytepos, 1) a[8:0] = '0x00000' self.assertTrue(a.startswith('0xff00000adead')) def testSliceAssignmentBitPos(self): a = BitStream('int:64=-1') a.pos = 64 a[0:8] = '' self.assertEqual(a.pos, 0) a.pos = 52 a[48:56] = '0x0000' self.assertEqual(a.pos, 64) a[10:10] = '0x0' self.assertEqual(a.pos, 14) a[56:68] = '0x000' self.assertEqual(a.pos, 14) class Pack(unittest.TestCase): def testPack1(self): s = bitstring.pack('uint:6, bin, hex, int:6, se, ue, oct', 10, '0b110', 'ff', -1, -6, 6, '54') t = BitStream('uint:6=10, 0b110, 0xff, int:6=-1, se=-6, ue=6, oct=54') self.assertEqual(s, t) with self.assertRaises(bitstring.CreationError): pack('tomato', '0') with self.assertRaises(bitstring.CreationError): pack('uint', 12) with self.assertRaises(bitstring.CreationError): pack('hex', 'penguin') with self.assertRaises(bitstring.CreationError): pack('hex12', '0x12') def testPackWithLiterals(self): s = bitstring.pack('0xf') self.assertEqual(s, '0xf') self.assertTrue(type(s), BitStream) s = pack('0b1') self.assertEqual(s, '0b1') s = pack('0o7') self.assertEqual(s, '0o7') s = pack('int:10=-1') self.assertEqual(s, '0b1111111111') s = pack('uint:10=1') self.assertEqual(s, '0b0000000001') s = pack('ue=12') self.assertEqual(s.ue, 12) s = pack('se=-12') self.assertEqual(s.se, -12) s = pack('bin=01') self.assertEqual(s.bin, '01') s = pack('hex=01') self.assertEqual(s.hex, '01') s = pack('oct=01') self.assertEqual(s.oct, '01') def testPackWithDict(self): a = pack('uint:6=width, se=height', height=100, width=12) w, h = a.unpack('uint:6, se') self.assertEqual(w, 12) self.assertEqual(h, 100) d = {} d['w'] = '0xf' d['300'] = 423 d['e'] = '0b1101' a = pack('int:100=300, bin=e, uint:12=300', **d) x, y, z = a.unpack('int:100, bin, uint:12') self.assertEqual(x, 423) self.assertEqual(y, '1101') self.assertEqual(z, 423) def testPackWithDict2(self): a = pack('int:5, bin:3=b, 0x3, bin=c, se=12', 10, b='0b111', c='0b1') b = BitStream('int:5=10, 0b111, 0x3, 0b1, se=12') self.assertEqual(a, b) a = pack('bits:3=b', b=BitStream('0b101')) self.assertEqual(a, '0b101') a = pack('bits:24=b', b=BitStream('0x001122')) self.assertEqual(a, '0x001122') def testPackWithDict3(self): s = pack('hex:4=e, hex:4=0xe, hex:4=e', e='f') self.assertEqual(s, '0xfef') s = pack('sep', sep='0b00') self.assertEqual(s, '0b00') def testPackWithDict4(self): s = pack('hello', hello='0xf') self.assertEqual(s, '0xf') s = pack('x, y, x, y, x', x='0b10', y='uint:12=100') t = BitStream('0b10, uint:12=100, 0b10, uint:12=100, 0b10') self.assertEqual(s, t) a = [1, 2, 3, 4, 5] s = pack('int:8, div,' * 5, *a, **{'div': '0b1'}) t = BitStream('int:8=1, 0b1, int:8=2, 0b1, int:8=3, 0b1, int:8=4, 0b1, int:8=5, 0b1') self.assertEqual(s, t) def testPackWithLocals(self): width = 352 height = 288 s = pack('uint:12=width, uint:12=height', **locals()) self.assertEqual(s, '0x160120') def testPackWithLengthRestriction(self): s = pack('bin:3', '0b000') self.assertRaises(bitstring.CreationError, pack, 'bin:3', '0b0011') self.assertRaises(bitstring.CreationError, pack, 'bin:3', '0b11') self.assertRaises(bitstring.CreationError, pack, 'bin:3=0b0011') self.assertRaises(bitstring.CreationError, pack, 'bin:3=0b11') s = pack('hex:4', '0xf') self.assertRaises(bitstring.CreationError, pack, 'hex:4', '0b111') self.assertRaises(bitstring.CreationError, pack, 'hex:4', '0b11111') self.assertRaises(bitstring.CreationError, pack, 'hex:8=0xf') s = pack('oct:6', '0o77') self.assertRaises(bitstring.CreationError, pack, 'oct:6', '0o1') self.assertRaises(bitstring.CreationError, pack, 'oct:6', '0o111') self.assertRaises(bitstring.CreationError, pack, 'oct:3', '0b1') self.assertRaises(bitstring.CreationError, pack, 'oct:3=hello', hello='0o12') s = pack('bits:3', BitStream('0b111')) self.assertRaises(bitstring.CreationError, pack, 'bits:3', BitStream('0b11')) self.assertRaises(bitstring.CreationError, pack, 'bits:3', BitStream('0b1111')) self.assertRaises(bitstring.CreationError, pack, 'bits:12=b', b=BitStream('0b11')) def testPackNull(self): s = pack('') self.assertFalse(s) s = pack(',') self.assertFalse(s) s = pack(',,,,,0b1,,,,,,,,,,,,,0b1,,,,,,,,,,') self.assertEqual(s, '0b11') s = pack(',,uint:12,,bin:3,', 100, '100') a, b = s.unpack(',,,uint:12,,,,bin:3,,,') self.assertEqual(a, 100) self.assertEqual(b, '100') def testPackDefaultUint(self): s = pack('10, 5', 1, 2) a, b = s.unpack('10, 5') self.assertEqual((a, b), (1, 2)) s = pack('10=150, 12=qee', qee=3) self.assertEqual(s, 'uint:10=150, uint:12=3') t = BitStream('100=5') self.assertEqual(t, 'uint:100=5') def testPackDefualtUintErrors(self): self.assertRaises(bitstring.CreationError, BitStream, '5=-1') def testPackingLongKeywordBitstring(self): s = pack('bits=b', b=BitStream(128000)) self.assertEqual(s, BitStream(128000)) def testPackingWithListFormat(self): f = ['bin', 'hex', 'uint:10'] a = pack(','.join(f), '00', '234', 100) b = pack(f, '00', '234', 100) self.assertEqual(a, b) class Unpack(unittest.TestCase): def testUnpack1(self): s = BitStream('uint:13=23, hex=e, bin=010, int:41=-554, 0o44332, se=-12, ue=4') s.pos = 11 a, b, c, d, e, f, g = s.unpack('uint:13, hex:4, bin:3, int:41, oct:15, se, ue') self.assertEqual(a, 23) self.assertEqual(b, 'e') self.assertEqual(c, '010') self.assertEqual(d, -554) self.assertEqual(e, '44332') self.assertEqual(f, -12) self.assertEqual(g, 4) self.assertEqual(s.pos, 11) def testUnpack2(self): s = BitStream('0xff, 0b000, uint:12=100') a, b, c = s.unpack('bits:8, bits, uint:12') self.assertEqual(type(s), BitStream) self.assertEqual(a, '0xff') self.assertEqual(type(s), BitStream) self.assertEqual(b, '0b000') self.assertEqual(c, 100) a, b = s.unpack(['bits:11', 'uint']) self.assertEqual(a, '0xff, 0b000') self.assertEqual(b, 100) def testUnpackNull(self): s = pack('0b1, , , 0xf,') a, b = s.unpack('bin:1,,,hex:4,') self.assertEqual(a, '1') self.assertEqual(b, 'f') class FromFile(unittest.TestCase): def testCreationFromFileOperations(self): s = BitStream(filename='smalltestfile') s.append('0xff') self.assertEqual(s.hex, '0123456789abcdefff') s = ConstBitStream(filename='smalltestfile') t = BitStream('0xff') + s self.assertEqual(t.hex, 'ff0123456789abcdef') s = BitStream(filename='smalltestfile') del s[:1] self.assertEqual((BitStream('0b0') + s).hex, '0123456789abcdef') s = BitStream(filename='smalltestfile') del s[:7 * 8] self.assertEqual(s.hex, 'ef') s = BitStream(filename='smalltestfile') s.insert('0xc', 4) self.assertEqual(s.hex, '0c123456789abcdef') s = BitStream(filename='smalltestfile') s.prepend('0xf') self.assertEqual(s.hex, 'f0123456789abcdef') s = BitStream(filename='smalltestfile') s.overwrite('0xaaa', 12) self.assertEqual(s.hex, '012aaa6789abcdef') s = BitStream(filename='smalltestfile') s.reverse() self.assertEqual(s.hex, 'f7b3d591e6a2c480') s = BitStream(filename='smalltestfile') del s[-60:] self.assertEqual(s.hex, '0') s = BitStream(filename='smalltestfile') del s[:60] self.assertEqual(s.hex, 'f') def testFileProperties(self): s = ConstBitStream(filename='smalltestfile') self.assertEqual(s.hex, '0123456789abcdef') self.assertEqual(s.uint, 81985529216486895) self.assertEqual(s.int, 81985529216486895) self.assertEqual(s.bin, '0000000100100011010001010110011110001001101010111100110111101111') self.assertEqual(s[:-1].oct, '002215053170465363367') s.bitpos = 0 self.assertEqual(s.read('se'), -72) s.bitpos = 0 self.assertEqual(s.read('ue'), 144) self.assertEqual(s.bytes, b'\x01\x23\x45\x67\x89\xab\xcd\xef') self.assertEqual(s.tobytes(), b'\x01\x23\x45\x67\x89\xab\xcd\xef') def testCreationFromFileWithLength(self): s = ConstBitStream(filename='test.m1v', length=32) self.assertEqual(s.length, 32) self.assertEqual(s.hex, '000001b3') s = ConstBitStream(filename='test.m1v', length=0) self.assertFalse(s) self.assertRaises(bitstring.CreationError, BitStream, filename='smalltestfile', length=65) self.assertRaises(bitstring.CreationError, ConstBitStream, filename='smalltestfile', length=64, offset=1) # self.assertRaises(bitstring.CreationError, ConstBitStream, filename='smalltestfile', offset=65) with open('smalltestfile', 'rb') as f: # self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, offset=65) self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, length=65) self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, offset=60, length=5) def testCreationFromFileWithOffset(self): a = BitStream(filename='test.m1v', offset=4) self.assertEqual(a.peek(4 * 8).hex, '00001b31') b = BitStream(filename='test.m1v', offset=28) self.assertEqual(b.peek(8).hex, '31') def testFileSlices(self): s = BitStream(filename='smalltestfile') self.assertEqual(s[-16:].hex, 'cdef') def testCreataionFromFileErrors(self): self.assertRaises(IOError, BitStream, filename='Idonotexist') def testFindInFile(self): s = BitStream(filename='test.m1v') self.assertTrue(s.find('0x160120')) self.assertEqual(s.bytepos, 4) s3 = s.read(24) self.assertEqual(s3.hex, '160120') s.bytepos = 0 self.assertTrue(s._pos == 0) self.assertTrue(s.find('0x0001b2')) self.assertEqual(s.bytepos, 13) def testHexFromFile(self): s = BitStream(filename='test.m1v') self.assertEqual(s[0:32].hex, '000001b3') self.assertEqual(s[-32:].hex, '000001b7') s.hex = '0x11' self.assertEqual(s.hex, '11') def testFileOperations(self): s1 = BitStream(filename='test.m1v') s2 = BitStream(filename='test.m1v') self.assertEqual(s1.read(32).hex, '000001b3') self.assertEqual(s2.read(32).hex, '000001b3') s1.bytepos += 4 self.assertEqual(s1.read(8).hex, '02') self.assertEqual(s2.read(5 * 8).hex, '1601208302') s1.pos = s1.len try: s1.pos += 1 self.assertTrue(False) except ValueError: pass def testFileBitGetting(self): s = ConstBitStream(filename='smalltestfile', offset=16, length=8) # 0x45 b = s[1] self.assertTrue(b) b = s.any(0, [-1, -2, -3]) self.assertTrue(b) b = s.all(0, [0, 1, 2]) self.assertFalse(b) def testVeryLargeFiles(self): # This uses an 11GB file which isn't distributed for obvious reasons # and so this test won't work for anyone except me! try: s = ConstBitStream(filename='11GB.mkv') except IOError: return self.assertEqual(s.len, 11743020505 * 8) self.assertEqual(s[1000000000:1000000100].hex, 'bdef7335d4545f680d669ce24') self.assertEqual(s[-4::8].hex, 'bbebf7a1') class CreationErrors(unittest.TestCase): def testIncorrectBinAssignment(self): s = BitStream() with self.assertRaises(bitstring.CreationError): s._setbin_safe('0010020') def testIncorrectHexAssignment(self): s = BitStream() with self.assertRaises(bitstring.CreationError): s.hex= '0xabcdefg' class Length(unittest.TestCase): def testLengthZero(self): self.assertEqual(BitStream('').len, 0) def testLength(self): self.assertEqual(BitStream('0x80').len, 8) def testOffsetLengthError(self): with self.assertRaises(bitstring.CreationError): BitStream(hex='0xffff', offset=-1) class SimpleConversions(unittest.TestCase): def testConvertToUint(self): self.assertEqual(BitStream('0x10').uint, 16) self.assertEqual(BitStream('0b000111').uint, 7) def testConvertToInt(self): self.assertEqual(BitStream('0x10').int, 16) self.assertEqual(BitStream('0b11110').int, -2) def testConvertToHex(self): self.assertEqual(BitStream(bytes=b'\x00\x12\x23\xff').hex, '001223ff') s = BitStream('0b11111') with self.assertRaises(bitstring.InterpretError): s.hex class Empty(unittest.TestCase): def testEmptyBitstring(self): s = BitStream() self.assertRaises(bitstring.ReadError, s.read, 1) self.assertEqual(s.bin, '') self.assertEqual(s.hex, '') self.assertRaises(bitstring.InterpretError, s._getint) self.assertRaises(bitstring.InterpretError, s._getuint) self.assertFalse(s) def testNonEmptyBitStream(self): s = BitStream(bin='0') self.assertFalse(not s.len) class Position(unittest.TestCase): def testBitPosition(self): s = BitStream(bytes=b'\x00\x00\x00') self.assertEqual(s.bitpos, 0) s.read(5) self.assertEqual(s.pos, 5) s.pos = s.len self.assertRaises(bitstring.ReadError, s.read, 1) def testBytePosition(self): s = BitStream(bytes=b'\x00\x00\x00') self.assertEqual(s.bytepos, 0) s.read(10) self.assertRaises(bitstring.ByteAlignError, s._getbytepos) s.read(6) self.assertEqual(s.bytepos, 2) def testSeekToBit(self): s = BitStream(bytes=b'\x00\x00\x00\x00\x00\x00') s.bitpos = 0 self.assertEqual(s.bitpos, 0) self.assertRaises(ValueError, s._setbitpos, -1) self.assertRaises(ValueError, s._setbitpos, 6 * 8 + 1) s.bitpos = 6 * 8 self.assertEqual(s.bitpos, 6 * 8) def testSeekToByte(self): s = BitStream(bytes=b'\x00\x00\x00\x00\x00\xab') s.bytepos = 5 self.assertEqual(s.read(8).hex, 'ab') def testAdvanceBitsAndBytes(self): s = BitStream(bytes=b'\x00\x00\x00\x00\x00\x00\x00\x00') s.pos += 5 self.assertEqual(s.pos, 5) s.bitpos += 16 self.assertEqual(s.pos, 2 * 8 + 5) s.pos -= 8 self.assertEqual(s.pos, 8 + 5) def testRetreatBitsAndBytes(self): a = BitStream(length=100) a.pos = 80 a.bytepos -= 5 self.assertEqual(a.bytepos, 5) a.pos -= 5 self.assertEqual(a.pos, 35) class Offset(unittest.TestCase): def testOffset1(self): s = BitStream(bytes=b'\x00\x1b\x3f', offset=4) self.assertEqual(s.read(8).bin, '00000001') self.assertEqual(s.length, 20) def testOffset2(self): s1 = BitStream(bytes=b'\xf1\x02\x04') s2 = BitStream(bytes=b'\xf1\x02\x04', length=23) for i in [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, 7, 3, 5, 1, 4]: s1._datastore = offsetcopy(s1._datastore, i) self.assertEqual(s1.hex, 'f10204') s2._datastore = offsetcopy(s2._datastore, i) self.assertEqual(s2.bin, '11110001000000100000010') class Append(unittest.TestCase): def testAppend(self): s1 = BitStream('0b00000') s1.append(BitStream(bool=True)) self.assertEqual(s1.bin, '000001') self.assertEqual((BitStream('0x0102') + BitStream('0x0304')).hex, '01020304') def testAppendSameBitstring(self): s1 = BitStream('0xf0')[:6] s1.append(s1) self.assertEqual(s1.bin, '111100111100') def testAppendWithOffset(self): s = BitStream(bytes=b'\x28\x28', offset=1) s.append('0b0') self.assertEqual(s.hex, '5050') class ByteAlign(unittest.TestCase): def testByteAlign(self): s = BitStream(hex='0001ff23') s.bytealign() self.assertEqual(s.bytepos, 0) s.pos += 11 s.bytealign() self.assertEqual(s.bytepos, 2) s.pos -= 10 s.bytealign() self.assertEqual(s.bytepos, 1) def testByteAlignWithOffset(self): s = BitStream(hex='0112233') s._datastore = offsetcopy(s._datastore, 3) bitstoalign = s.bytealign() self.assertEqual(bitstoalign, 0) self.assertEqual(s.read(5).bin, '00001') def testInsertByteAligned(self): s = BitStream('0x0011') s.insert(BitStream('0x22'), 8) self.assertEqual(s.hex, '002211') s = BitStream(0) s.insert(BitStream(bin='101'), 0) self.assertEqual(s.bin, '101') class Truncate(unittest.TestCase): def testTruncateStart(self): s = BitStream('0b1') del s[:1] self.assertFalse(s) s = BitStream(hex='1234') self.assertEqual(s.hex, '1234') del s[:4] self.assertEqual(s.hex, '234') del s[:9] self.assertEqual(s.bin, '100') del s[:2] self.assertEqual(s.bin, '0') self.assertEqual(s.len, 1) del s[:1] self.assertFalse(s) def testTruncateEnd(self): s = BitStream('0b1') del s[-1:] self.assertFalse(s) s = BitStream(bytes=b'\x12\x34') self.assertEqual(s.hex, '1234') del s[-4:] self.assertEqual(s.hex, '123') del s[-9:] self.assertEqual(s.bin, '000') del s[-3:] self.assertFalse(s) s = BitStream('0b001') del s[:2] del s[-1:] self.assertFalse(s) class Slice(unittest.TestCase): def testByteAlignedSlice(self): s = BitStream(hex='0x123456') self.assertEqual(s[8:16].hex, '34') s = s[8:24] self.assertEqual(s.len, 16) self.assertEqual(s.hex, '3456') s = s[0:8] self.assertEqual(s.hex, '34') s.hex = '0x123456' self.assertEqual(s[8:24][0:8].hex, '34') def testSlice(self): s = BitStream(bin='000001111100000') s1 = s[0:5] s2 = s[5:10] s3 = s[10:15] self.assertEqual(s1.bin, '00000') self.assertEqual(s2.bin, '11111') self.assertEqual(s3.bin, '00000') class Insert(unittest.TestCase): def testInsert(self): s1 = BitStream(hex='0x123456') s2 = BitStream(hex='0xff') s1.bytepos = 1 s1.insert(s2) self.assertEqual(s1.bytepos, 2) self.assertEqual(s1.hex, '12ff3456') s1.insert('0xee', 24) self.assertEqual(s1.hex, '12ff34ee56') self.assertEqual(s1.bitpos, 32) self.assertRaises(ValueError, s1.insert, '0b1', -1000) self.assertRaises(ValueError, s1.insert, '0b1', 1000) def testInsertNull(self): s = BitStream(hex='0x123').insert(BitStream(), 3) self.assertEqual(s.hex, '123') def testInsertBits(self): one = BitStream(bin='1') zero = BitStream(bin='0') s = BitStream(bin='00') s.insert(one, 0) self.assertEqual(s.bin, '100') s.insert(zero, 0) self.assertEqual(s.bin, '0100') s.insert(one, s.len) self.assertEqual(s.bin, '01001') s.insert(s, 2) self.assertEqual(s.bin, '0101001001') class Resetting(unittest.TestCase): def testSetHex(self): s = BitStream() s.hex = '0' self.assertEqual(s.hex, '0') s.hex = '0x010203045' self.assertEqual(s.hex, '010203045') self.assertRaises(bitstring.CreationError, s._sethex, '0x002g') def testSetBin(self): s = BitStream(bin="000101101") self.assertEqual(s.bin, '000101101') self.assertEqual(s.len, 9) s.bin = '0' self.assertEqual(s.bin, '0') self.assertEqual(s.len, 1) def testSetEmptyBin(self): s = BitStream(hex='0x000001b3') s.bin = '' self.assertEqual(s.len, 0) self.assertEqual(s.bin, '') def testSetInvalidBin(self): s = BitStream() self.assertRaises(bitstring.CreationError, s._setbin_safe, '00102') class Overwriting(unittest.TestCase): def testOverwriteBit(self): s = BitStream(bin='0') s.overwrite(BitStream(bin='1'), 0) self.assertEqual(s.bin, '1') def testOverwriteLimits(self): s = BitStream(bin='0b11111') s.overwrite(BitStream(bin='000'), 0) self.assertEqual(s.bin, '00011') s.overwrite('0b000', 2) self.assertEqual(s.bin, '00000') def testOverwriteNull(self): s = BitStream(hex='342563fedec') s2 = BitStream(s) s.overwrite(BitStream(bin=''), 23) self.assertEqual(s.bin, s2.bin) def testOverwritePosition(self): s1 = BitStream(hex='0123456') s2 = BitStream(hex='ff') s1.bytepos = 1 s1.overwrite(s2) self.assertEqual((s1.hex, s1.bytepos), ('01ff456', 2)) s1.overwrite('0xff', 0) self.assertEqual((s1.hex, s1.bytepos), ('ffff456', 1)) def testOverwriteWithSelf(self): s = BitStream('0x123') s.overwrite(s) self.assertEqual(s, '0x123') class Split(unittest.TestCase): def testSplitByteAlignedCornerCases(self): s = BitStream() bsl = s.split(BitStream(hex='0xff')) self.assertEqual(next(bsl).hex, '') self.assertRaises(StopIteration, next, bsl) s = BitStream(hex='aabbcceeddff') delimiter = BitStream() bsl = s.split(delimiter) self.assertRaises(ValueError, next, bsl) delimiter = BitStream(hex='11') bsl = s.split(delimiter) self.assertEqual(next(bsl).hex, s.hex) def testSplitByteAligned(self): s = BitStream(hex='0x1234aa1234bbcc1234ffff') delimiter = BitStream(hex='1234') bsl = s.split(delimiter) self.assertEqual([b.hex for b in bsl], ['', '1234aa', '1234bbcc', '1234ffff']) self.assertEqual(s.pos, 0) def testSplitByteAlignedWithIntialBytes(self): s = BitStream(hex='aa471234fedc43 47112233 47 4723 472314') delimiter = BitStream(hex='47') s.find(delimiter) self.assertEqual(s.bytepos, 1) bsl = s.split(delimiter, start=0) self.assertEqual([b.hex for b in bsl], ['aa', '471234fedc43', '47112233', '47', '4723', '472314']) self.assertEqual(s.bytepos, 1) def testSplitByteAlignedWithOverlappingDelimiter(self): s = BitStream(hex='aaffaaffaaffaaffaaff') bsl = s.split(BitStream(hex='aaffaa')) self.assertEqual([b.hex for b in bsl], ['', 'aaffaaff', 'aaffaaffaaff']) class Adding(unittest.TestCase): def testAdding(self): s1 = BitStream(hex='0x0102') s2 = BitStream(hex='0x0304') s3 = s1 + s2 self.assertEqual(s1.hex, '0102') self.assertEqual(s2.hex, '0304') self.assertEqual(s3.hex, '01020304') s3 += s1 self.assertEqual(s3.hex, '010203040102') self.assertEqual(s2[9:16].bin, '0000100') self.assertEqual(s1[0:9].bin, '000000010') s4 = BitStream(bin='000000010') +\ BitStream(bin='0000100') self.assertEqual(s4.bin, '0000000100000100') s2p = s2[9:16] s1p = s1[0:9] s5p = s1p + s2p s5 = s1[0:9] + s2[9:16] self.assertEqual(s5.bin, '0000000100000100') def testMoreAdding(self): s = BitStream(bin='00') + BitStream(bin='') + BitStream(bin='11') self.assertEqual(s.bin, '0011') s = '0b01' s += BitStream('0b11') self.assertEqual(s.bin, '0111') s = BitStream('0x00') t = BitStream('0x11') s += t self.assertEqual(s.hex, '0011') self.assertEqual(t.hex, '11') s += s self.assertEqual(s.hex, '00110011') def testRadd(self): s = '0xff' + BitStream('0xee') self.assertEqual(s.hex, 'ffee') def testTruncateAsserts(self): s = BitStream('0x001122') s.bytepos = 2 del s[-s.len:] self.assertEqual(s.bytepos, 0) s.append('0x00') s.append('0x1122') s.bytepos = 2 del s[:s.len] self.assertEqual(s.bytepos, 0) s.append('0x00') def testOverwriteErrors(self): s = BitStream(bin='11111') self.assertRaises(ValueError, s.overwrite, BitStream(bin='1'), -10) self.assertRaises(ValueError, s.overwrite, BitStream(bin='1'), 6) self.assertRaises(ValueError, s.overwrite, BitStream(bin='11111'), 1) def testDeleteBits(self): s = BitStream(bin='000111100000') s.bitpos = 4 del s[4:8] self.assertEqual(s.bin, '00010000') del s[4:1004] self.assertTrue(s.bin, '0001') def testDeleteBitsWithPosition(self): s = BitStream(bin='000111100000') del s[4:8] self.assertEqual(s.bin, '00010000') def testDeleteBytes(self): s = BitStream('0x00112233') del s[8:8] self.assertEqual(s.hex, '00112233') self.assertEqual(s.pos, 0) del s[8:16] self.assertEqual(s.hex, '002233') self.assertEqual(s.bytepos, 0) del s[:24] self.assertFalse(s) self.assertEqual(s.pos, 0) def testGetItemWithPositivePosition(self): s = BitStream(bin='0b1011') self.assertEqual(s[0], True) self.assertEqual(s[1], False) self.assertEqual(s[2], True) self.assertEqual(s[3], True) self.assertRaises(IndexError, s.__getitem__, 4) def testGetItemWithNegativePosition(self): s = BitStream(bin='1011') self.assertEqual(s[-1], True) self.assertEqual(s[-2], True) self.assertEqual(s[-3], False) self.assertEqual(s[-4], True) self.assertRaises(IndexError, s.__getitem__, -5) def testSlicing(self): s = ConstBitStream(hex='0123456789') self.assertEqual(s[0:8].hex, '01') self.assertFalse(s[0:0]) self.assertFalse(s[23:20]) self.assertEqual(s[8:12].bin, '0010') self.assertEqual(s[32:80], '0x89') def testNegativeSlicing(self): s = ConstBitStream(hex='012345678') self.assertEqual(s[:-8].hex, '0123456') self.assertEqual(s[-16:-8].hex, '56') self.assertEqual(s[-24:].hex, '345678') self.assertEqual(s[-1000:-24], '0x012') def testLen(self): s = BitStream() self.assertEqual(len(s), 0) s.append(BitStream(bin='001')) self.assertEqual(len(s), 3) def testJoin(self): s1 = BitStream(bin='0') s2 = BitStream(bin='1') s3 = BitStream(bin='000') s4 = BitStream(bin='111') strings = [s1, s2, s1, s3, s4] s = BitStream().join(strings) self.assertEqual(s.bin, '010000111') def testJoin2(self): s1 = BitStream(hex='00112233445566778899aabbccddeeff') s2 = BitStream(bin='0b000011') bsl = [s1[0:32], s1[4:12], s2, s2, s2, s2] s = ConstBitStream().join(bsl) self.assertEqual(s.hex, '00112233010c30c3') bsl = [BitStream(uint=j, length=12) for j in range(10) for i in range(10)] s = BitStream().join(bsl) self.assertEqual(s.length, 1200) def testPos(self): s = BitStream(bin='1') self.assertEqual(s.bitpos, 0) s.read(1) self.assertEqual(s.bitpos, 1) def testWritingData(self): strings = [BitStream(bin=x) for x in ['0', '001', '0011010010', '010010', '1011']] s = BitStream().join(strings) s2 = BitStream(bytes=s.bytes) self.assertEqual(s2.bin, '000100110100100100101011') s2.append(BitStream(bin='1')) s3 = BitStream(bytes=s2.tobytes()) self.assertEqual(s3.bin, '00010011010010010010101110000000') def testWritingDataWithOffsets(self): s1 = BitStream(bytes=b'\x10') s2 = BitStream(bytes=b'\x08\x00', length=8, offset=1) s3 = BitStream(bytes=b'\x04\x00', length=8, offset=2) self.assertTrue(s1 == s2) self.assertTrue(s2 == s3) self.assertTrue(s1.bytes == s2.bytes) self.assertTrue(s2.bytes == s3.bytes) def testVariousThings1(self): hexes = ['12345678', '87654321', 'ffffffffff', 'ed', '12ec'] bins = ['001010', '1101011', '0010000100101110110110', '11', '011'] bsl = [] for (hex, bin) in list(zip(hexes, bins)) * 5: bsl.append(BitStream(hex=hex)) bsl.append(BitStream(bin=bin)) s = BitStream().join(bsl) for (hex, bin) in list(zip(hexes, bins)) * 5: h = s.read(4 * len(hex)) b = s.read(len(bin)) self.assertEqual(h.hex, hex) self.assertEqual(b.bin, bin) def testVariousThings2(self): s1 = BitStream(hex="0x1f08")[:13] self.assertEqual(s1.bin, '0001111100001') s2 = BitStream(bin='0101') self.assertEqual(s2.bin, '0101') s1.append(s2) self.assertEqual(s1.length, 17) self.assertEqual(s1.bin, '00011111000010101') s1 = s1[3:8] self.assertEqual(s1.bin, '11111') def testVariousThings3(self): s1 = BitStream(hex='0x012480ff')[2:27] s2 = s1 + s1 self.assertEqual(s2.length, 50) s3 = s2[0:25] s4 = s2[25:50] self.assertEqual(s3.bin, s4.bin) def testPeekBit(self): s = BitStream(bin='01') self.assertEqual(s.peek(1), [0]) self.assertEqual(s.peek(1), [0]) self.assertEqual(s.read(1), [0]) self.assertEqual(s.peek(1), [1]) self.assertEqual(s.peek(1), [1]) s = BitStream(bytes=b'\x1f', offset=3) self.assertEqual(s.len, 5) self.assertEqual(s.peek(5).bin, '11111') self.assertEqual(s.peek(5).bin, '11111') s.pos += 1 self.assertRaises(bitstring.ReadError, s.peek, 5) s = BitStream(hex='001122334455') self.assertEqual(s.peek(8).hex, '00') self.assertEqual(s.read(8).hex, '00') s.pos += 33 self.assertRaises(bitstring.ReadError, s.peek, 8) s = BitStream(hex='001122334455') self.assertEqual(s.peek(8 * 2).hex, '0011') self.assertEqual(s.read(8 * 3).hex, '001122') self.assertEqual(s.peek(8 * 3).hex, '334455') self.assertRaises(bitstring.ReadError, s.peek, 25) def testAdvanceBit(self): s = BitStream(hex='0xff') s.bitpos = 6 s.pos += 1 self.assertEqual(s.bitpos, 7) s.bitpos += 1 try: s.pos += 1 self.assertTrue(False) except ValueError: pass def testAdvanceByte(self): s = BitStream(hex='0x010203') s.bytepos += 1 self.assertEqual(s.bytepos, 1) s.bytepos += 1 self.assertEqual(s.bytepos, 2) s.bytepos += 1 try: s.bytepos += 1 self.assertTrue(False) except ValueError: pass def testRetreatBit(self): s = BitStream(hex='0xff') try: s.pos -= 1 self.assertTrue(False) except ValueError: pass s.pos = 5 s.pos -= 1 self.assertEqual(s.pos, 4) def testRetreatByte(self): s = BitStream(hex='0x010203') try: s.bytepos -= 1 self.assertTrue(False) except ValueError: pass s.bytepos = 3 s.bytepos -= 1 self.assertEqual(s.bytepos, 2) self.assertEqual(s.read(8).hex, '03') def testCreationByAuto(self): s = BitStream('0xff') self.assertEqual(s.hex, 'ff') s = BitStream('0b00011') self.assertEqual(s.bin, '00011') self.assertRaises(bitstring.CreationError, BitStream, 'hello') s1 = BitStream(bytes=b'\xf5', length=3, offset=5) s2 = BitStream(s1, length=1, offset=1) self.assertEqual(s2, '0b0') s = BitStream(bytes=b'\xff', offset=2) t = BitStream(s, offset=2) self.assertEqual(t, '0b1111') self.assertRaises(TypeError, BitStream, auto=1.2) def testCreationByAuto2(self): s = BitStream('bin=001') self.assertEqual(s.bin, '001') s = BitStream('oct=0o007') self.assertEqual(s.oct, '007') s = BitStream('hex=123abc') self.assertEqual(s, '0x123abc') s = BitStream('bin:2=01') self.assertEqual(s, '0b01') for s in ['bin:1=01', 'bits:4=0b1', 'oct:3=000', 'hex:4=0x1234']: self.assertRaises(bitstring.CreationError, BitStream, s) def testInsertUsingAuto(self): s = BitStream('0xff') s.insert('0x00', 4) self.assertEqual(s.hex, 'f00f') self.assertRaises(ValueError, s.insert, 'ff') def testOverwriteUsingAuto(self): s = BitStream('0x0110') s.overwrite('0b1') self.assertEqual(s.hex, '8110') s.overwrite('') self.assertEqual(s.hex, '8110') self.assertRaises(ValueError, s.overwrite, '0bf') def testFindUsingAuto(self): s = BitStream('0b000000010100011000') self.assertTrue(s.find('0b101')) self.assertEqual(s.pos, 7) def testFindbytealignedUsingAuto(self): s = BitStream('0x00004700') self.assertTrue(s.find('0b01000111', bytealigned=True)) self.assertEqual(s.bytepos, 2) def testAppendUsingAuto(self): s = BitStream('0b000') s.append('0b111') self.assertEqual(s.bin, '000111') s.append('0b0') self.assertEqual(s.bin, '0001110') def testSplitByteAlignedUsingAuto(self): s = BitStream('0x000143563200015533000123') sections = s.split('0x0001') self.assertEqual(next(sections).hex, '') self.assertEqual(next(sections).hex, '0001435632') self.assertEqual(next(sections).hex, '00015533') self.assertEqual(next(sections).hex, '000123') self.assertRaises(StopIteration, next, sections) def testSplitByteAlignedWithSelf(self): s = BitStream('0x1234') sections = s.split(s) self.assertEqual(next(sections).hex, '') self.assertEqual(next(sections).hex, '1234') self.assertRaises(StopIteration, next, sections) def testPrepend(self): s = BitStream('0b000') s.prepend('0b11') self.assertEqual(s.bin, '11000') s.prepend(s) self.assertEqual(s.bin, '1100011000') s.prepend('') self.assertEqual(s.bin, '1100011000') def testNullSlice(self): s = BitStream('0x111') t = s[1:1] self.assertEqual(t._datastore.bytelength, 0) def testMultipleAutos(self): s = BitStream('0xa') s.prepend('0xf') s.append('0xb') self.assertEqual(s, '0xfab') s.prepend(s) s.append('0x100') s.overwrite('0x5', 4) self.assertEqual(s, '0xf5bfab100') def testReverse(self): s = BitStream('0b0011') s.reverse() self.assertEqual(s.bin, '1100') s = BitStream('0b10') s.reverse() self.assertEqual(s.bin, '01') s = BitStream() s.reverse() self.assertEqual(s.bin, '') def testInitWithConcatenatedStrings(self): s = BitStream('0xff 0Xee 0xd 0xcc') self.assertEqual(s.hex, 'ffeedcc') s = BitStream('0b0 0B111 0b001') self.assertEqual(s.bin, '0111001') s += '0b1' + '0B1' self.assertEqual(s.bin, '011100111') s = BitStream(hex='ff0xee') self.assertEqual(s.hex, 'ffee') s = BitStream(bin='000b0b11') self.assertEqual(s.bin, '0011') s = BitStream(' 0o123 0O 7 0 o1') self.assertEqual(s.oct, '12371') s += ' 0 o 332' self.assertEqual(s.oct, '12371332') def testEquals(self): s1 = BitStream('0b01010101') s2 = BitStream('0b01010101') self.assertTrue(s1 == s2) s3 = BitStream() s4 = BitStream() self.assertTrue(s3 == s4) self.assertFalse(s3 != s4) s5 = BitStream(bytes=b'\xff', offset=2, length=3) s6 = BitStream('0b111') self.assertTrue(s5 == s6) class A(object): pass self.assertFalse(s5 == A()) def testLargeEquals(self): s1 = BitStream(1000000) s2 = BitStream(1000000) s1.set(True, [-1, 55, 53214, 534211, 999999]) s2.set(True, [-1, 55, 53214, 534211, 999999]) self.assertEqual(s1, s2) s1.set(True, 800000) self.assertNotEqual(s1, s2) def testNotEquals(self): s1 = BitStream('0b0') s2 = BitStream('0b1') self.assertTrue(s1 != s2) self.assertFalse(s1 != BitStream('0b0')) def testEqualityWithAutoInitialised(self): a = BitStream('0b00110111') self.assertTrue(a == '0b00110111') self.assertTrue(a == '0x37') self.assertTrue('0b0011 0111' == a) self.assertTrue('0x3 0x7' == a) self.assertFalse(a == '0b11001000') self.assertFalse('0x3737' == a) def testInvertSpecialMethod(self): s = BitStream('0b00011001') self.assertEqual((~s).bin, '11100110') self.assertEqual((~BitStream('0b0')).bin, '1') self.assertEqual((~BitStream('0b1')).bin, '0') self.assertTrue(~~s == s) def testInvertBitPosition(self): s = ConstBitStream('0xefef') s.pos = 8 t = ~s self.assertEqual(s.pos, 8) self.assertEqual(t.pos, 0) def testInvertSpecialMethodErrors(self): s = BitStream() self.assertRaises(bitstring.Error, s.__invert__) def testJoinWithAuto(self): s = BitStream().join(['0xf', '0b00', BitStream(bin='11')]) self.assertEqual(s, '0b11110011') def testAutoBitStringCopy(self): s = BitStream('0xabcdef') t = BitStream(s) self.assertEqual(t.hex, 'abcdef') del s[-8:] self.assertEqual(t.hex, 'abcdef') class Multiplication(unittest.TestCase): def testMultiplication(self): a = BitStream('0xff') b = a * 8 self.assertEqual(b, '0xffffffffffffffff') b = 4 * a self.assertEqual(b, '0xffffffff') self.assertTrue(1 * a == a * 1 == a) c = a * 0 self.assertFalse(c) a *= 3 self.assertEqual(a, '0xffffff') a *= 0 self.assertFalse(a) one = BitStream('0b1') zero = BitStream('0b0') mix = one * 2 + 3 * zero + 2 * one * 2 self.assertEqual(mix, '0b110001111') q = BitStream() q *= 143 self.assertFalse(q) q += [True, True, False] q.pos += 2 q *= 0 self.assertFalse(q) self.assertEqual(q.bitpos, 0) def testMultiplicationWithFiles(self): a = BitStream(filename='test.m1v') b = a.len a *= 3 self.assertEqual(a.len, 3 * b) def testMultiplicationErrors(self): a = BitStream('0b1') b = BitStream('0b0') self.assertRaises(ValueError, a.__mul__, -1) self.assertRaises(ValueError, a.__imul__, -1) self.assertRaises(ValueError, a.__rmul__, -1) self.assertRaises(TypeError, a.__mul__, 1.2) self.assertRaises(TypeError, a.__rmul__, b) self.assertRaises(TypeError, a.__imul__, b) def testFileAndMemEquivalence(self): a = ConstBitStream(filename='smalltestfile') b = BitStream(filename='smalltestfile') self.assertTrue(isinstance(a._datastore._rawarray, bitstring.MmapByteArray)) self.assertTrue(isinstance(b._datastore._rawarray, bytearray)) self.assertEqual(a._datastore.getbyte(0), b._datastore.getbyte(0)) self.assertEqual(a._datastore.getbyteslice(1, 5), bytearray(b._datastore.getbyteslice(1, 5))) class BitWise(unittest.TestCase): def testBitwiseAnd(self): a = BitStream('0b01101') b = BitStream('0b00110') self.assertEqual((a & b).bin, '00100') self.assertEqual((a & '0b11111'), a) self.assertRaises(ValueError, a.__and__, '0b1') self.assertRaises(ValueError, b.__and__, '0b110111111') c = BitStream('0b0011011') c.pos = 4 d = c & '0b1111000' self.assertEqual(d.pos, 0) self.assertEqual(d.bin, '0011000') d = '0b1111000' & c self.assertEqual(d.bin, '0011000') def testBitwiseOr(self): a = BitStream('0b111001001') b = BitStream('0b011100011') self.assertEqual((a | b).bin, '111101011') self.assertEqual((a | '0b000000000'), a) self.assertRaises(ValueError, a.__or__, '0b0000') self.assertRaises(ValueError, b.__or__, a + '0b1') a = '0xff00' | BitStream('0x00f0') self.assertEqual(a.hex, 'fff0') def testBitwiseXor(self): a = BitStream('0b111001001') b = BitStream('0b011100011') self.assertEqual((a ^ b).bin, '100101010') self.assertEqual((a ^ '0b111100000').bin, '000101001') self.assertRaises(ValueError, a.__xor__, '0b0000') self.assertRaises(ValueError, b.__xor__, a + '0b1') a = '0o707' ^ BitStream('0o777') self.assertEqual(a.oct, '070') class Split(unittest.TestCase): def testSplit(self): a = BitStream('0b0 010100111 010100 0101 010') a.pos = 20 subs = [i.bin for i in a.split('0b010')] self.assertEqual(subs, ['0', '010100111', '010100', '0101', '010']) self.assertEqual(a.pos, 20) def testSplitCornerCases(self): a = BitStream('0b000000') bsl = a.split('0b1', False) self.assertEqual(next(bsl), a) self.assertRaises(StopIteration, next, bsl) b = BitStream() bsl = b.split('0b001', False) self.assertFalse(next(bsl)) self.assertRaises(StopIteration, next, bsl) def testSplitErrors(self): a = BitStream('0b0') b = a.split('', False) self.assertRaises(ValueError, next, b) def testSliceWithOffset(self): a = BitStream(bytes=b'\x00\xff\x00', offset=7) b = a[7:12] self.assertEqual(b.bin, '11000') def testSplitWithMaxsplit(self): a = BitStream('0xaabbccbbccddbbccddee') self.assertEqual(len(list(a.split('0xbb', bytealigned=True))), 4) bsl = list(a.split('0xbb', count=1, bytealigned=True)) self.assertEqual((len(bsl), bsl[0]), (1, '0xaa')) bsl = list(a.split('0xbb', count=2, bytealigned=True)) self.assertEqual(len(bsl), 2) self.assertEqual(bsl[0], '0xaa') self.assertEqual(bsl[1], '0xbbcc') def testSplitMore(self): s = BitStream('0b1100011001110110') for i in range(10): a = list(s.split('0b11', False, count=i)) b = list(s.split('0b11', False))[:i] self.assertEqual(a, b) b = s.split('0b11', count=-1) self.assertRaises(ValueError, next, b) def testSplitStartbit(self): a = BitStream('0b0010101001000000001111') bsl = a.split('0b001', bytealigned=False, start=1) self.assertEqual([x.bin for x in bsl], ['010101', '001000000', '001111']) b = a.split('0b001', start=-100) self.assertRaises(ValueError, next, b) b = a.split('0b001', start=23) self.assertRaises(ValueError, next, b) b = a.split('0b1', start=10, end=9) self.assertRaises(ValueError, next, b) def testSplitStartbitByteAligned(self): a = BitStream('0x00ffffee') bsl = list(a.split('0b111', start=9, bytealigned=True)) self.assertEqual([x.bin for x in bsl], ['1111111', '11111111', '11101110']) def testSplitEndbit(self): a = BitStream('0b000010001001011') bsl = list(a.split('0b1', bytealigned=False, end=14)) self.assertEqual([x.bin for x in bsl], ['0000', '1000', '100', '10', '1']) self.assertEqual(list(a[4:12].split('0b0', False)), list(a.split('0b0', start=4, end=12))) # Shouldn't raise ValueError bsl = list(a.split('0xffee', end=15)) # Whereas this one will when we call next() bsl = a.split('0xffee', end=16) self.assertRaises(ValueError, next, bsl) def testSplitEndbitByteAligned(self): a = BitStream('0xff00ff')[:22] bsl = list(a.split('0b 0000 0000 111', end=19)) self.assertEqual([x.bin for x in bsl], ['11111111', '00000000111']) bsl = list(a.split('0b 0000 0000 111', end=18)) self.assertEqual([x.bin for x in bsl], ['111111110000000011']) def testSplitMaxSplit(self): a = BitStream('0b1' * 20) for i in range(10): bsl = list(a.split('0b1', count=i)) self.assertEqual(len(bsl), i) ####################### def testPositionInSlice(self): a = BitStream('0x00ffff00') a.bytepos = 2 b = a[8:24] self.assertEqual(b.bytepos, 0) def testFindByteAlignedWithBits(self): a = BitStream('0x00112233445566778899') a.find('0b0001', bytealigned=True) self.assertEqual(a.bitpos, 8) def testFindStartbitNotByteAligned(self): a = BitStream('0b0010000100') found = a.find('0b1', start=4) self.assertEqual((found, a.bitpos), ((7,), 7)) found = a.find('0b1', start=2) self.assertEqual((found, a.bitpos), ((2,), 2)) found = a.find('0b1', bytealigned=False, start=8) self.assertEqual((found, a.bitpos), ((), 2)) def testFindEndbitNotByteAligned(self): a = BitStream('0b0010010000') found = a.find('0b1', bytealigned=False, end=2) self.assertEqual((found, a.bitpos), ((), 0)) found = a.find('0b1', end=3) self.assertEqual((found, a.bitpos), ((2,), 2)) found = a.find('0b1', bytealigned=False, start=3, end=5) self.assertEqual((found, a.bitpos), ((), 2)) found = a.find('0b1', start=3, end=6) self.assertEqual((found[0], a.bitpos), (5, 5)) def testFindStartbitByteAligned(self): a = BitStream('0xff001122ff0011ff') a.pos = 40 found = a.find('0x22', start=23, bytealigned=True) self.assertEqual((found, a.bytepos), ((24,), 3)) a.bytepos = 4 found = a.find('0x22', start=24, bytealigned=True) self.assertEqual((found, a.bytepos), ((24,), 3)) found = a.find('0x22', start=25, bytealigned=True) self.assertEqual((found, a.pos), ((), 24)) found = a.find('0b111', start=40, bytealigned=True) self.assertEqual((found, a.pos), ((56,), 56)) def testFindEndbitByteAligned(self): a = BitStream('0xff001122ff0011ff') found = a.find('0x22', end=31, bytealigned=True) self.assertFalse(found) self.assertEqual(a.pos, 0) found = a.find('0x22', end=32, bytealigned=True) self.assertTrue(found) self.assertEqual(a.pos, 24) self.assertEqual(found[0], 24) def testFindStartEndbitErrors(self): a = BitStream('0b00100') self.assertRaises(ValueError, a.find, '0b1', bytealigned=False, start=-100) self.assertRaises(ValueError, a.find, '0b1', end=6) self.assertRaises(ValueError, a.find, '0b1', start=4, end=3) b = BitStream('0x0011223344') self.assertRaises(ValueError, a.find, '0x22', bytealigned=True, start=-100) self.assertRaises(ValueError, a.find, '0x22', end=41, bytealigned=True) def testPrependAndAppendAgain(self): c = BitStream('0x1122334455667788') c.bitpos = 40 c.prepend('0b1') self.assertEqual(c.bitpos, 41) c = BitStream() c.prepend('0x1234') self.assertEqual(c.bytepos, 2) c = BitStream() c.append('0x1234') self.assertEqual(c.bytepos, 0) s = BitStream(bytes=b'\xff\xff', offset=2) self.assertEqual(s.length, 14) t = BitStream(bytes=b'\x80', offset=1, length=2) s.prepend(t) self.assertEqual(s, '0x3fff') def testFindAll(self): a = BitStream('0b11111') p = a.findall('0b1') self.assertEqual(list(p), [0, 1, 2, 3, 4]) p = a.findall('0b11') self.assertEqual(list(p), [0, 1, 2, 3]) p = a.findall('0b10') self.assertEqual(list(p), []) a = BitStream('0x4733eeff66554747335832434547') p = a.findall('0x47', bytealigned=True) self.assertEqual(list(p), [0, 6 * 8, 7 * 8, 13 * 8]) p = a.findall('0x4733', bytealigned=True) self.assertEqual(list(p), [0, 7 * 8]) a = BitStream('0b1001001001001001001') p = a.findall('0b1001', bytealigned=False) self.assertEqual(list(p), [0, 3, 6, 9, 12, 15]) self.assertEqual(a.pos, 15) def testFindAllGenerator(self): a = BitStream('0xff1234512345ff1234ff12ff') p = a.findall('0xff', bytealigned=True) self.assertEqual(next(p), 0) self.assertEqual(next(p), 6 * 8) self.assertEqual(next(p), 9 * 8) self.assertEqual(next(p), 11 * 8) self.assertRaises(StopIteration, next, p) def testFindAllCount(self): s = BitStream('0b1') * 100 for i in [0, 1, 23]: self.assertEqual(len(list(s.findall('0b1', count=i))), i) b = s.findall('0b1', bytealigned=True, count=-1) self.assertRaises(ValueError, next, b) def testContains(self): a = BitStream('0b1') + '0x0001dead0001' self.assertTrue('0xdead' in a) self.assertEqual(a.pos, 0) self.assertFalse('0xfeed' in a) def testRepr(self): max = bitstring.MAX_CHARS bls = ['', '0b1', '0o5', '0x43412424f41', '0b00101001010101'] for bs in bls: a = BitStream(bs) b = eval(a.__repr__()) self.assertTrue(a == b) for f in [ConstBitStream(filename='test.m1v'), ConstBitStream(filename='test.m1v', length=17), ConstBitStream(filename='test.m1v', length=23, offset=23102)]: f2 = eval(f.__repr__()) self.assertEqual(f._datastore._rawarray.source.name, f2._datastore._rawarray.source.name) self.assertTrue(f2.tobytes() == f.tobytes()) a = BitStream('0b1') self.assertEqual(repr(a), "BitStream('0b1')") a += '0b11' self.assertEqual(repr(a), "BitStream('0b111')") a += '0b1' self.assertEqual(repr(a), "BitStream('0xf')") a *= max self.assertEqual(repr(a), "BitStream('0x" + "f" * max + "')") a += '0xf' self.assertEqual(repr(a), "BitStream('0x" + "f" * max + "...') # length=%d" % (max * 4 + 4)) def testPrint(self): s = BitStream(hex='0x00') self.assertEqual('0x' + s.hex, s.__str__()) s = BitStream(filename='test.m1v') self.assertEqual('0x' + s[0:bitstring.MAX_CHARS * 4].hex + '...', s.__str__()) self.assertEqual(BitStream().__str__(), '') s = BitStream('0b11010') self.assertEqual('0b' + s.bin, s.__str__()) s = BitStream('0x12345678901234567890,0b1') self.assertEqual('0x12345678901234567890, 0b1', s.__str__()) def testIter(self): a = BitStream('0b001010') b = BitStream() for bit in a: b.append(ConstBitStream(bool=bit)) self.assertEqual(a, b) def testDelitem(self): a = BitStream('0xffee') del a[0:8] self.assertEqual(a.hex, 'ee') del a[0:8] self.assertFalse(a) del a[10:12] self.assertFalse(a) def testNonZeroBitsAtStart(self): a = BitStream(bytes=b'\xff', offset=2) b = BitStream('0b00') b += a self.assertTrue(b == '0b0011 1111') #self.assertEqual(a._datastore.rawbytes, b'\xff') self.assertEqual(a.tobytes(), b'\xfc') def testNonZeroBitsAtEnd(self): a = BitStream(bytes=b'\xff', length=5) #self.assertEqual(a._datastore.rawbytes, b'\xff') b = BitStream('0b00') a += b self.assertTrue(a == '0b1111100') self.assertEqual(a.tobytes(), b'\xf8') with self.assertRaises(ValueError): a.bytes def testNewOffsetErrors(self): self.assertRaises(bitstring.CreationError, BitStream, hex='ff', offset=-1) self.assertRaises(bitstring.CreationError, BitStream, '0xffffffff', offset=33) def testSliceStep(self): a = BitStream('0x3') b = a[::1] self.assertEqual(a, b) self.assertEqual(a[2:4:1], '0b11') self.assertEqual(a[0:2:1], '0b00') self.assertEqual(a[:3], '0o1') a = BitStream('0x0011223344556677') self.assertEqual(a[-8:], '0x77') self.assertEqual(a[:-24], '0x0011223344') self.assertEqual(a[-1000:-24], '0x0011223344') def testInterestingSliceStep(self): a = BitStream('0b0011000111') self.assertEqual(a[7:3:-1], '0b1000') self.assertEqual(a[9:2:-1], '0b1110001') self.assertEqual(a[8:2:-2], '0b100') self.assertEqual(a[100:-20:-3], '0b1010') self.assertEqual(a[100:-20:-1], '0b1110001100') self.assertEqual(a[10:2:-1], '0b1110001') self.assertEqual(a[100:2:-1], '0b1110001') def testInsertionOrderAndBitpos(self): b = BitStream() b[0:0] = '0b0' b[0:0] = '0b1' self.assertEqual(b, '0b10') self.assertEqual(b.bitpos, 1) a = BitStream() a.insert('0b0') a.insert('0b1') self.assertEqual(a, '0b01') self.assertEqual(a.bitpos, 2) def testOverwriteOrderAndBitpos(self): a = BitStream('0xff') a.overwrite('0xa') self.assertEqual(a, '0xaf') self.assertEqual(a.bitpos, 4) a.overwrite('0xb') self.assertEqual(a, '0xab') self.assertEqual(a.bitpos, 8) self.assertRaises(ValueError, a.overwrite, '0b1') a.overwrite('0xa', 4) self.assertEqual(a, '0xaa') self.assertEqual(a.bitpos, 8) a.overwrite(a, 0) self.assertEqual(a, '0xaa') def testInitSliceWithInt(self): a = BitStream(length=8) a[:] = 100 self.assertEqual(a.uint, 100) a[0] = 1 self.assertEqual(a.bin, '11100100') a[1] = 0 self.assertEqual(a.bin, '10100100') a[-1] = -1 self.assertEqual(a.bin, '10100101') a[-3:] = -2 self.assertEqual(a.bin, '10100110') def testInitSliceWithIntErrors(self): a = BitStream('0b0000') self.assertRaises(ValueError, a.__setitem__, slice(0, 4), 16) self.assertRaises(ValueError, a.__setitem__, slice(0, 4), -9) self.assertRaises(ValueError, a.__setitem__, 0, 2) self.assertRaises(ValueError, a.__setitem__, 0, -2) def testReverseWithSlice(self): a = BitStream('0x0012ff') a.reverse() self.assertEqual(a, '0xff4800') a.reverse(8, 16) self.assertEqual(a, '0xff1200') b = a[8:16] b.reverse() a[8:16] = b self.assertEqual(a, '0xff4800') def testReverseWithSliceErrors(self): a = BitStream('0x123') self.assertRaises(ValueError, a.reverse, -1, 4) self.assertRaises(ValueError, a.reverse, 10, 9) self.assertRaises(ValueError, a.reverse, 1, 10000) def testInitialiseFromList(self): a = BitStream([]) self.assertFalse(a) a = BitStream([True, False, [], [0], 'hello']) self.assertEqual(a, '0b10011') a += [] self.assertEqual(a, '0b10011') a += [True, False, True] self.assertEqual(a, '0b10011101') a.find([12, 23]) self.assertEqual(a.pos, 3) self.assertEqual([1, 0, False, True], BitStream('0b1001')) a = [True] + BitStream('0b1') self.assertEqual(a, '0b11') def testInitialiseFromTuple(self): a = BitStream(()) self.assertFalse(a) a = BitStream((0, 1, '0', '1')) self.assertEqual('0b0111', a) a.replace((True, True), []) self.assertEqual(a, (False, True)) def testCut(self): a = BitStream('0x00112233445') b = list(a.cut(8)) self.assertEqual(b, ['0x00', '0x11', '0x22', '0x33', '0x44']) b = list(a.cut(4, 8, 16)) self.assertEqual(b, ['0x1', '0x1']) b = list(a.cut(4, 0, 44, 4)) self.assertEqual(b, ['0x0', '0x0', '0x1', '0x1']) a = BitStream() b = list(a.cut(10)) self.assertTrue(not b) def testCutErrors(self): a = BitStream('0b1') b = a.cut(1, 1, 2) self.assertRaises(ValueError, next, b) b = a.cut(1, -2, 1) self.assertRaises(ValueError, next, b) b = a.cut(0) self.assertRaises(ValueError, next, b) b = a.cut(1, count=-1) self.assertRaises(ValueError, next, b) def testCutProblem(self): s = BitStream('0x1234') for n in list(s.cut(4)): s.prepend(n) self.assertEqual(s, '0x43211234') def testJoinFunctions(self): a = BitStream().join(['0xa', '0xb', '0b1111']) self.assertEqual(a, '0xabf') a = BitStream('0b1').join(['0b0' for i in range(10)]) self.assertEqual(a, '0b0101010101010101010') a = BitStream('0xff').join([]) self.assertFalse(a) def testAddingBitpos(self): a = BitStream('0xff') b = BitStream('0x00') a.bitpos = b.bitpos = 8 c = a + b self.assertEqual(c.bitpos, 0) def testIntelligentRead1(self): a = BitStream(uint=123, length=23) u = a.read('uint:23') self.assertEqual(u, 123) self.assertEqual(a.pos, a.len) b = BitStream(int=-12, length=44) i = b.read('int:44') self.assertEqual(i, -12) self.assertEqual(b.pos, b.len) u2, i2 = (a + b).readlist('uint:23, int:44') self.assertEqual((u2, i2), (123, -12)) def testIntelligentRead2(self): a = BitStream(ue=822) u = a.read('ue') self.assertEqual(u, 822) self.assertEqual(a.pos, a.len) b = BitStream(se=-1001) s = b.read('se') self.assertEqual(s, -1001) self.assertEqual(b.pos, b.len) s, u1, u2 = (b + 2 * a).readlist('se, ue, ue') self.assertEqual((s, u1, u2), (-1001, 822, 822)) def testIntelligentRead3(self): a = BitStream('0x123') + '0b11101' h = a.read('hex:12') self.assertEqual(h, '123') b = a.read('bin: 5') self.assertEqual(b, '11101') c = '0b' + b + a b, h = c.readlist('bin:5, hex:12') self.assertEqual((b, h), ('11101', '123')) def testIntelligentRead4(self): a = BitStream('0o007') o = a.read('oct:9') self.assertEqual(o, '007') self.assertEqual(a.pos, a.len) def testIntelligentRead5(self): a = BitStream('0x00112233') c0, c1, c2 = a.readlist('bits:8, bits:8, bits:16') self.assertEqual((c0, c1, c2), (BitStream('0x00'), BitStream('0x11'), BitStream('0x2233'))) a.pos = 0 c = a.read('bits:16') self.assertEqual(c, BitStream('0x0011')) def testIntelligentRead6(self): a = BitStream('0b000111000') b1, b2, b3 = a.readlist('bin :3, int: 3, int:3') self.assertEqual(b1, '000') self.assertEqual(b2, -1) self.assertEqual(b3, 0) def testIntelligentRead7(self): a = BitStream('0x1234') a1, a2, a3, a4 = a.readlist('bin:0, oct:0, hex:0, bits:0') self.assertTrue(a1 == a2 == a3 == '') self.assertFalse(a4) self.assertRaises(ValueError, a.read, 'int:0') self.assertRaises(ValueError, a.read, 'uint:0') self.assertEqual(a.pos, 0) def testIntelligentRead8(self): a = BitStream('0x123456') for t in ['hex:1', 'oct:1', 'hex4', '-5', 'fred', 'bin:-2', 'uint:p', 'uint:-2', 'int:u', 'int:-3', 'ses', 'uee', '-14']: self.assertRaises(ValueError, a.read, t) def testIntelligentRead9(self): a = BitStream('0xff') self.assertEqual(a.read('intle'), -1) def testFillerReads1(self): s = BitStream('0x012345') t = s.read('bits') self.assertEqual(s, t) s.pos = 0 a, b = s.readlist('hex:8, hex') self.assertEqual(a, '01') self.assertEqual(b, '2345') self.assertTrue(isinstance(b, str)) s.bytepos = 0 a, b = s.readlist('bin, hex:20') self.assertEqual(a, '0000') self.assertEqual(b, '12345') self.assertTrue(isinstance(a, str)) def testFillerReads2(self): s = BitStream('0xabcdef') self.assertRaises(bitstring.Error, s.readlist, 'bits, se') self.assertRaises(bitstring.Error, s.readlist, 'hex:4, bits, ue, bin:4') s.pos = 0 self.assertRaises(bitstring.Error, s.readlist, 'bin, bin') def testIntelligentPeek(self): a = BitStream('0b01, 0x43, 0o4, uint:23=2, se=5, ue=3') b, c, e = a.peeklist('bin:2, hex:8, oct:3') self.assertEqual((b, c, e), ('01', '43', '4')) self.assertEqual(a.pos, 0) a.pos = 13 f, g, h = a.peeklist('uint:23, se, ue') self.assertEqual((f, g, h), (2, 5, 3)) self.assertEqual(a.pos, 13) def testReadMultipleBits(self): s = BitStream('0x123456789abcdef') a, b = s.readlist([4, 4]) self.assertEqual(a, '0x1') self.assertEqual(b, '0x2') c, d, e = s.readlist([8, 16, 8]) self.assertEqual(c, '0x34') self.assertEqual(d, '0x5678') self.assertEqual(e, '0x9a') def testPeekMultipleBits(self): s = BitStream('0b1101, 0o721, 0x2234567') a, b, c, d = s.peeklist([2, 1, 1, 9]) self.assertEqual(a, '0b11') self.assertEqual(bool(b), False) self.assertEqual(bool(c), True) self.assertEqual(d, '0o721') self.assertEqual(s.pos, 0) a, b = s.peeklist([4, 9]) self.assertEqual(a, '0b1101') self.assertEqual(b, '0o721') s.pos = 13 a, b = s.peeklist([16, 8]) self.assertEqual(a, '0x2234') self.assertEqual(b, '0x56') self.assertEqual(s.pos, 13) def testDifficultPrepends(self): a = BitStream('0b1101011') b = BitStream() for i in range(10): b.prepend(a) self.assertEqual(b, a * 10) def testPackingWrongNumberOfThings(self): self.assertRaises(bitstring.CreationError, pack, 'bin:1') self.assertRaises(bitstring.CreationError, pack, '', 100) def testPackWithVariousKeys(self): a = pack('uint10', uint10='0b1') self.assertEqual(a, '0b1') b = pack('0b110', **{'0b110': '0xfff'}) self.assertEqual(b, '0xfff') def testPackWithVariableLength(self): for i in range(1, 11): a = pack('uint:n', 0, n=i) self.assertEqual(a.bin, '0' * i) def testToBytes(self): a = BitStream(bytes=b'\xab\x00') b = a.tobytes() self.assertEqual(a.bytes, b) for i in range(7): del a[-1:] self.assertEqual(a.tobytes(), b'\xab\x00') del a[-1:] self.assertEqual(a.tobytes(), b'\xab') def testToFile(self): a = BitStream('0x0000ff')[:17] f = open('temp_bitstring_unit_testing_file', 'wb') a.tofile(f) f.close() b = BitStream(filename='temp_bitstring_unit_testing_file') self.assertEqual(b, '0x000080') a = BitStream('0x911111') del a[:1] self.assertEqual(a + '0b0', '0x222222') f = open('temp_bitstring_unit_testing_file', 'wb') a.tofile(f) f.close() b = BitStream(filename='temp_bitstring_unit_testing_file') self.assertEqual(b, '0x222222') os.remove('temp_bitstring_unit_testing_file') #def testToFileWithLargerFile(self): # a = BitStream(length=16000000) # a[1] = '0b1' # a[-2] = '0b1' # f = open('temp_bitstring_unit_testing_file' ,'wb') # a.tofile(f) # f.close() # b = BitStream(filename='temp_bitstring_unit_testing_file') # self.assertEqual(b.len, 16000000) # self.assertEqual(b[1], True) # # f = open('temp_bitstring_unit_testing_file' ,'wb') # a[1:].tofile(f) # f.close() # b = BitStream(filename='temp_bitstring_unit_testing_file') # self.assertEqual(b.len, 16000000) # self.assertEqual(b[0], True) # os.remove('temp_bitstring_unit_testing_file') def testTokenParser(self): tp = bitstring.tokenparser self.assertEqual(tp('hex'), (True, [('hex', None, None)])) self.assertEqual(tp('hex=14'), (True, [('hex', None, '14')])) self.assertEqual(tp('se'), (False, [('se', None, None)])) self.assertEqual(tp('ue=12'), (False, [('ue', None, '12')])) self.assertEqual(tp('0xef'), (False, [('0x', None, 'ef')])) self.assertEqual(tp('uint:12'), (False, [('uint', 12, None)])) self.assertEqual(tp('int:30=-1'), (False, [('int', 30, '-1')])) self.assertEqual(tp('bits:10'), (False, [('bits', 10, None)])) self.assertEqual(tp('bits:10'), (False, [('bits', 10, None)])) self.assertEqual(tp('123'), (False, [('uint', 123, None)])) self.assertEqual(tp('123'), (False, [('uint', 123, None)])) self.assertRaises(ValueError, tp, 'hex12') self.assertEqual(tp('hex12', ('hex12',)), (False, [('hex12', None, None)])) self.assertEqual(tp('2*bits:6'), (False, [('bits', 6, None), ('bits', 6, None)])) def testAutoFromFileObject(self): with open('test.m1v', 'rb') as f: s = ConstBitStream(f, offset=32, length=12) self.assertEqual(s.uint, 352) t = ConstBitStream('0xf') + f self.assertTrue(t.startswith('0xf000001b3160')) s2 = ConstBitStream(f) t2 = BitStream('0xc') t2.prepend(s2) self.assertTrue(t2.startswith('0x000001b3')) self.assertTrue(t2.endswith('0xc')) with open('test.m1v', 'rb') as b: u = BitStream(bytes=b.read()) # TODO: u == s2 is much slower than u.bytes == s2.bytes self.assertEqual(u.bytes, s2.bytes) def testFileBasedCopy(self): with open('smalltestfile', 'rb') as f: s = BitStream(f) t = BitStream(s) s.prepend('0b1') self.assertEqual(s[1:], t) s = BitStream(f) t = copy.copy(s) t.append('0b1') self.assertEqual(s, t[:-1]) def testBigEndianSynonyms(self): s = BitStream('0x12318276ef') self.assertEqual(s.int, s.intbe) self.assertEqual(s.uint, s.uintbe) s = BitStream(intbe=-100, length=16) self.assertEqual(s, 'int:16=-100') s = BitStream(uintbe=13, length=24) self.assertEqual(s, 'int:24=13') s = BitStream('uintbe:32=1000') self.assertEqual(s, 'uint:32=1000') s = BitStream('intbe:8=2') self.assertEqual(s, 'int:8=2') self.assertEqual(s.read('intbe'), 2) s.pos = 0 self.assertEqual(s.read('uintbe'), 2) def testBigEndianSynonymErrors(self): self.assertRaises(bitstring.CreationError, BitStream, uintbe=100, length=15) self.assertRaises(bitstring.CreationError, BitStream, intbe=100, length=15) self.assertRaises(bitstring.CreationError, BitStream, 'uintbe:17=100') self.assertRaises(bitstring.CreationError, BitStream, 'intbe:7=2') s = BitStream('0b1') self.assertRaises(bitstring.InterpretError, s._getintbe) self.assertRaises(bitstring.InterpretError, s._getuintbe) self.assertRaises(ValueError, s.read, 'uintbe') self.assertRaises(ValueError, s.read, 'intbe') def testLittleEndianUint(self): s = BitStream(uint=100, length=16) self.assertEqual(s.uintle, 25600) s = BitStream(uintle=100, length=16) self.assertEqual(s.uint, 25600) self.assertEqual(s.uintle, 100) s.uintle += 5 self.assertEqual(s.uintle, 105) s = BitStream('uintle:32=999') self.assertEqual(s.uintle, 999) s.byteswap() self.assertEqual(s.uint, 999) s = pack('uintle:24', 1001) self.assertEqual(s.uintle, 1001) self.assertEqual(s.length, 24) self.assertEqual(s.read('uintle'), 1001) def testLittleEndianInt(self): s = BitStream(int=100, length=16) self.assertEqual(s.intle, 25600) s = BitStream(intle=100, length=16) self.assertEqual(s.int, 25600) self.assertEqual(s.intle, 100) s.intle += 5 self.assertEqual(s.intle, 105) s = BitStream('intle:32=999') self.assertEqual(s.intle, 999) s.byteswap() self.assertEqual(s.int, 999) s = pack('intle:24', 1001) self.assertEqual(s.intle, 1001) self.assertEqual(s.length, 24) self.assertEqual(s.read('intle'), 1001) def testLittleEndianErrors(self): self.assertRaises(bitstring.CreationError, BitStream, 'uintle:15=10') self.assertRaises(bitstring.CreationError, BitStream, 'intle:31=-999') self.assertRaises(bitstring.CreationError, BitStream, uintle=100, length=15) self.assertRaises(bitstring.CreationError, BitStream, intle=100, length=15) s = BitStream('0xfff') self.assertRaises(bitstring.InterpretError, s._getintle) self.assertRaises(bitstring.InterpretError, s._getuintle) self.assertRaises(ValueError, s.read, 'uintle') self.assertRaises(ValueError, s.read, 'intle') def testStructTokens1(self): self.assertEqual(pack('b', 23), BitStream('intbe:8=23')) self.assertEqual(pack('>B', 23), BitStream('uintbe:8=23')) self.assertEqual(pack('>h', 23), BitStream('intbe:16=23')) self.assertEqual(pack('>H', 23), BitStream('uintbe:16=23')) self.assertEqual(pack('>l', 23), BitStream('intbe:32=23')) self.assertEqual(pack('>L', 23), BitStream('uintbe:32=23')) self.assertEqual(pack('>q', 23), BitStream('intbe:64=23')) self.assertEqual(pack('>Q', 23), BitStream('uintbe:64=23')) self.assertRaises(bitstring.CreationError, pack, '2L', 40, 40)) def testStructTokens3(self): s = pack('>hhl', 1, 2, 3) a, b, c = s.unpack('>hhl') self.assertEqual((a, b, c), (1, 2, 3)) s = pack('Q \tL', 1001, 43, 21, 9999) self.assertEqual(s.unpack('QL'), [1001, 43, 21, 9999]) def testStructTokensMultiplicativeFactors(self): s = pack('<2h', 1, 2) a, b = s.unpack('<2h') self.assertEqual((a, b), (1, 2)) s = pack('<100q', *range(100)) self.assertEqual(s.len, 100 * 64) self.assertEqual(s[44*64:45*64].uintle, 44) s = pack('@L0B2h', 5, 5, 5) self.assertEqual(s.unpack('@Lhh'), [5, 5, 5]) def testStructTokensErrors(self): for f in ['>>q', '<>q', 'q>', '2q', 'q', '>-2q', '@a', '>int:8', '>q2']: self.assertRaises(bitstring.CreationError, pack, f, 100) def testImmutableBitStreams(self): a = ConstBitStream('0x012345') self.assertEqual(a, '0x012345') b = BitStream('0xf') + a self.assertEqual(b, '0xf012345') try: a.append(b) self.assertTrue(False) except AttributeError: pass try: a.prepend(b) self.assertTrue(False) except AttributeError: pass try: a[0] = '0b1' self.assertTrue(False) except TypeError: pass try: del a[5] self.assertTrue(False) except TypeError: pass try: a.replace('0b1', '0b0') self.assertTrue(False) except AttributeError: pass try: a.insert('0b11', 4) self.assertTrue(False) except AttributeError: pass try: a.reverse() self.assertTrue(False) except AttributeError: pass try: a.reversebytes() self.assertTrue(False) except AttributeError: pass self.assertEqual(a, '0x012345') self.assertTrue(isinstance(a, ConstBitStream)) def testReverseBytes(self): a = BitStream('0x123456') a.byteswap() self.assertEqual(a, '0x563412') b = a + '0b1' b.byteswap() self.assertEqual('0x123456, 0b1', b) a = BitStream('0x54') a.byteswap() self.assertEqual(a, '0x54') a = BitStream() a.byteswap() self.assertFalse(a) def testReverseBytes2(self): a = BitStream() a.byteswap() self.assertFalse(a) a = BitStream('0x00112233') a.byteswap(0, 0, 16) self.assertEqual(a, '0x11002233') a.byteswap(0, 4, 28) self.assertEqual(a, '0x12302103') a.byteswap(start=0, end=18) self.assertEqual(a, '0x30122103') self.assertRaises(ValueError, a.byteswap, 0, 10, 2) self.assertRaises(ValueError, a.byteswap, 0, -4, 4) self.assertRaises(ValueError, a.byteswap, 0, 24, 48) a.byteswap(0, 24) self.assertEqual(a, '0x30122103') a.byteswap(0, 11, 11) self.assertEqual(a, '0x30122103') def testCapitalsInPack(self): a = pack('A', A='0b1') self.assertEqual(a, '0b1') format = 'bits:4=BL_OFFT, uint:12=width, uint:12=height' d = {'BL_OFFT': '0b1011', 'width': 352, 'height': 288} s = bitstring.pack(format, **d) self.assertEqual(s, '0b1011, uint:12=352, uint:12=288') a = pack('0X0, uint:8, hex', 45, '0XABcD') self.assertEqual(a, '0x0, uint:8=45, 0xabCD') def testOtherCapitals(self): a = ConstBitStream('0XABC, 0O0, 0B11') self.assertEqual(a, 'hex=0Xabc, oct=0, bin=0B11') def testEfficientOverwrite(self): a = BitStream(1000000000) a.overwrite([1], 123456) self.assertEqual(a[123456], True) a.overwrite('0xff', 1) self.assertEqual(a[0:32:1], '0x7f800000') b = BitStream('0xffff') b.overwrite('0x0000') self.assertEqual(b, '0x0000') self.assertEqual(b.pos, 16) c = BitStream(length=1000) c.overwrite('0xaaaaaaaaaaaa', 81) self.assertEqual(c[81:81 + 6 * 8], '0xaaaaaaaaaaaa') self.assertEqual(len(list(c.findall('0b1'))), 24) s = BitStream(length=1000) s = s[5:] s.overwrite('0xffffff', 500) s.pos = 500 self.assertEqual(s.read(4 * 8), '0xffffff00') s.overwrite('0xff', 502) self.assertEqual(s[502:518], '0xffff') def testPeekAndReadListErrors(self): a = BitStream('0x123456') self.assertRaises(ValueError, a.read, 'hex:8, hex:8') self.assertRaises(ValueError, a.peek, 'hex:8, hex:8') self.assertRaises(TypeError, a.read, 10, 12) self.assertRaises(TypeError, a.peek, 12, 14) self.assertRaises(TypeError, a.read, 8, 8) self.assertRaises(TypeError, a.peek, 80, 80) def testStartswith(self): a = BitStream() self.assertTrue(a.startswith(BitStream())) self.assertFalse(a.startswith('0b0')) a = BitStream('0x12ff') self.assertTrue(a.startswith('0x1')) self.assertTrue(a.startswith('0b0001001')) self.assertTrue(a.startswith('0x12ff')) self.assertFalse(a.startswith('0x12ff, 0b1')) self.assertFalse(a.startswith('0x2')) def testStartswithStartEnd(self): s = BitStream('0x123456') self.assertTrue(s.startswith('0x234', 4)) self.assertFalse(s.startswith('0x123', end=11)) self.assertTrue(s.startswith('0x123', end=12)) self.assertTrue(s.startswith('0x34', 8, 16)) self.assertFalse(s.startswith('0x34', 7, 16)) self.assertFalse(s.startswith('0x34', 9, 16)) self.assertFalse(s.startswith('0x34', 8, 15)) def testEndswith(self): a = BitStream() self.assertTrue(a.endswith('')) self.assertFalse(a.endswith(BitStream('0b1'))) a = BitStream('0xf2341') self.assertTrue(a.endswith('0x41')) self.assertTrue(a.endswith('0b001')) self.assertTrue(a.endswith('0xf2341')) self.assertFalse(a.endswith('0x1f2341')) self.assertFalse(a.endswith('0o34')) def testEndswithStartEnd(self): s = BitStream('0x123456') self.assertTrue(s.endswith('0x234', end=16)) self.assertFalse(s.endswith('0x456', start=13)) self.assertTrue(s.endswith('0x456', start=12)) self.assertTrue(s.endswith('0x34', 8, 16)) self.assertTrue(s.endswith('0x34', 7, 16)) self.assertFalse(s.endswith('0x34', 9, 16)) self.assertFalse(s.endswith('0x34', 8, 15)) def testUnhashability(self): s = BitStream('0xf') self.assertRaises(TypeError, set, [s]) self.assertRaises(TypeError, hash, [s]) def testConstBitStreamSetCreation(self): sl = [ConstBitStream(uint=i, length=7) for i in range(15)] s = set(sl) self.assertEqual(len(s), 15) s.add(ConstBitStream('0b0000011')) self.assertEqual(len(s), 15) self.assertRaises(TypeError, s.add, BitStream('0b0000011')) def testConstBitStreamFunctions(self): s = ConstBitStream('0xf, 0b1') self.assertEqual(type(s), ConstBitStream) t = copy.copy(s) self.assertEqual(type(t), ConstBitStream) a = s + '0o3' self.assertEqual(type(a), ConstBitStream) b = a[0:4] self.assertEqual(type(b), ConstBitStream) b = a[4:3] self.assertEqual(type(b), ConstBitStream) b = a[5:2:-1] self.assertEqual(type(b), ConstBitStream) b = ~a self.assertEqual(type(b), ConstBitStream) b = a << 2 self.assertEqual(type(b), ConstBitStream) b = a >> 2 self.assertEqual(type(b), ConstBitStream) b = a * 2 self.assertEqual(type(b), ConstBitStream) b = a * 0 self.assertEqual(type(b), ConstBitStream) b = a & ~a self.assertEqual(type(b), ConstBitStream) b = a | ~a self.assertEqual(type(b), ConstBitStream) b = a ^ ~a self.assertEqual(type(b), ConstBitStream) b = a._slice(4, 4) self.assertEqual(type(b), ConstBitStream) b = a.read(4) self.assertEqual(type(b), ConstBitStream) def testConstBitStreamProperties(self): a = ConstBitStream('0x123123') try: a.hex = '0x234' self.assertTrue(False) except AttributeError: pass try: a.oct = '0o234' self.assertTrue(False) except AttributeError: pass try: a.bin = '0b101' self.assertTrue(False) except AttributeError: pass try: a.ue = 3453 self.assertTrue(False) except AttributeError: pass try: a.se = -123 self.assertTrue(False) except AttributeError: pass try: a.int = 432 self.assertTrue(False) except AttributeError: pass try: a.uint = 4412 self.assertTrue(False) except AttributeError: pass try: a.intle = 123 self.assertTrue(False) except AttributeError: pass try: a.uintle = 4412 self.assertTrue(False) except AttributeError: pass try: a.intbe = 123 self.assertTrue(False) except AttributeError: pass try: a.uintbe = 4412 self.assertTrue(False) except AttributeError: pass try: a.intne = 123 self.assertTrue(False) except AttributeError: pass try: a.uintne = 4412 self.assertTrue(False) except AttributeError: pass try: a.bytes = b'hello' self.assertTrue(False) except AttributeError: pass def testConstBitStreamMisc(self): a = ConstBitStream('0xf') b = a a += '0xe' self.assertEqual(b, '0xf') self.assertEqual(a, '0xfe') c = BitStream(a) self.assertEqual(a, c) a = ConstBitStream('0b1') a._append(a) self.assertEqual(a, '0b11') self.assertEqual(type(a), ConstBitStream) a._prepend(a) self.assertEqual(a, '0b1111') self.assertEqual(type(a), ConstBitStream) def testConstBitStreamHashibility(self): a = ConstBitStream('0x1') b = ConstBitStream('0x2') c = ConstBitStream('0x1') c.pos = 3 s = set((a, b, c)) self.assertEqual(len(s), 2) self.assertEqual(hash(a), hash(c)) def testConstBitStreamCopy(self): a = ConstBitStream('0xabc') a.pos = 11 b = copy.copy(a) b.pos = 4 self.assertEqual(id(a._datastore), id(b._datastore)) self.assertEqual(a.pos, 11) self.assertEqual(b.pos, 4) def testPython26stuff(self): s = BitStream('0xff') self.assertTrue(isinstance(s.tobytes(), bytes)) self.assertTrue(isinstance(s.bytes, bytes)) def testReadFromBits(self): a = ConstBitStream('0xaabbccdd') b = a.read(8) self.assertEqual(b, '0xaa') self.assertEqual(a[0:8], '0xaa') self.assertEqual(a[-1], True) a.pos = 0 self.assertEqual(a.read(4).uint, 10) class Set(unittest.TestCase): def testSet(self): a = BitStream(length=16) a.set(True, 0) self.assertEqual(a, '0b10000000 00000000') a.set(1, 15) self.assertEqual(a, '0b10000000 00000001') b = a[4:12] b.set(True, 1) self.assertEqual(b, '0b01000000') b.set(True, -1) self.assertEqual(b, '0b01000001') b.set(1, -8) self.assertEqual(b, '0b11000001') self.assertRaises(IndexError, b.set, True, -9) self.assertRaises(IndexError, b.set, True, 8) def testSetNegativeIndex(self): a = BitStream(10) a.set(1, -1) self.assertEqual(a.bin, '0000000001') a.set(1, [-1, -10]) self.assertEqual(a.bin, '1000000001') self.assertRaises(IndexError, a.set, 1, [-11]) def testFileBasedSetUnset(self): a = BitStream(filename='test.m1v') a.set(True, (0, 1, 2, 3, 4)) self.assertEqual(a[0:32], '0xf80001b3') a = BitStream(filename='test.m1v') a.set(False, (28, 29, 30, 31)) self.assertTrue(a.startswith('0x000001b0')) def testSetList(self): a = BitStream(length=18) a.set(True, range(18)) self.assertEqual(a.int, -1) a.set(False, range(18)) self.assertEqual(a.int, 0) def testUnset(self): a = BitStream(length=16, int=-1) a.set(False, 0) self.assertEqual(~a, '0b10000000 00000000') a.set(0, 15) self.assertEqual(~a, '0b10000000 00000001') b = a[4:12] b.set(False, 1) self.assertEqual(~b, '0b01000000') b.set(False, -1) self.assertEqual(~b, '0b01000001') b.set(False, -8) self.assertEqual(~b, '0b11000001') self.assertRaises(IndexError, b.set, False, -9) self.assertRaises(IndexError, b.set, False, 8) def testSetWholeBitStream(self): a = BitStream(14) a.set(1) self.assertTrue(a.all(1)) a.set(0) self.assertTrue(a.all(0)) class Invert(unittest.TestCase): def testInvertBits(self): a = BitStream('0b111000') a.invert(range(a.len)) self.assertEqual(a, '0b000111') a.invert([0, 1, -1]) self.assertEqual(a, '0b110110') def testInvertWholeBitStream(self): a = BitStream('0b11011') a.invert() self.assertEqual(a, '0b00100') def testInvertSingleBit(self): a = BitStream('0b000001') a.invert(0) self.assertEqual(a.bin, '100001') a.invert(-1) self.assertEqual(a.bin, '100000') def testInvertErrors(self): a = BitStream(10) self.assertRaises(IndexError, a.invert, 10) self.assertRaises(IndexError, a.invert, -11) self.assertRaises(IndexError, a.invert, [1, 2, 10]) ####################### def testIor(self): a = BitStream('0b1101001') a |= '0b1110000' self.assertEqual(a, '0b1111001') b = a[2:] c = a[1:-1] b |= c self.assertEqual(c, '0b11100') self.assertEqual(b, '0b11101') def testIand(self): a = BitStream('0b0101010101000') a &= '0b1111110000000' self.assertEqual(a, '0b0101010000000') s = BitStream(filename='test.m1v', offset=26, length=24) s &= '0xff00ff' self.assertEqual(s, '0xcc0004') def testIxor(self): a = BitStream('0b11001100110011') a ^= '0b11111100000010' self.assertEqual(a, '0b00110000110001') def testLogicalInplaceErrors(self): a = BitStream(4) self.assertRaises(ValueError, a.__ior__, '0b111') self.assertRaises(ValueError, a.__iand__, '0b111') self.assertRaises(ValueError, a.__ixor__, '0b111') class AllAndAny(unittest.TestCase): def testAll(self): a = BitStream('0b0111') self.assertTrue(a.all(True, (1, 3))) self.assertFalse(a.all(True, (0, 1, 2))) self.assertTrue(a.all(True, [-1])) self.assertFalse(a.all(True, [0])) def testFileBasedAll(self): a = BitStream(filename='test.m1v') self.assertTrue(a.all(True, [31])) a = BitStream(filename='test.m1v') self.assertTrue(a.all(False, (0, 1, 2, 3, 4))) def testFileBasedAny(self): a = BitStream(filename='test.m1v') self.assertTrue(a.any(True, (31, 12))) a = BitStream(filename='test.m1v') self.assertTrue(a.any(False, (0, 1, 2, 3, 4))) def testAny(self): a = BitStream('0b10011011') self.assertTrue(a.any(True, (1, 2, 3, 5))) self.assertFalse(a.any(True, (1, 2, 5))) self.assertTrue(a.any(True, (-1,))) self.assertFalse(a.any(True, (1,))) def testAllFalse(self): a = BitStream('0b0010011101') self.assertTrue(a.all(False, (0, 1, 3, 4))) self.assertFalse(a.all(False, (0, 1, 2, 3, 4))) def testAnyFalse(self): a = BitStream('0b01001110110111111111111111111') self.assertTrue(a.any(False, (4, 5, 6, 2))) self.assertFalse(a.any(False, (1, 15, 20))) def testAnyEmptyBitstring(self): a = ConstBitStream() self.assertFalse(a.any(True)) self.assertFalse(a.any(False)) def testAllEmptyBitStream(self): a = ConstBitStream() self.assertTrue(a.all(True)) self.assertTrue(a.all(False)) def testAnyWholeBitstring(self): a = ConstBitStream('0xfff') self.assertTrue(a.any(True)) self.assertFalse(a.any(False)) def testAllWholeBitstring(self): a = ConstBitStream('0xfff') self.assertTrue(a.all(True)) self.assertFalse(a.all(False)) def testErrors(self): a = BitStream('0xf') self.assertRaises(IndexError, a.all, True, [5]) self.assertRaises(IndexError, a.all, True, [-5]) self.assertRaises(IndexError, a.any, True, [5]) self.assertRaises(IndexError, a.any, True, [-5]) ################### def testFloatInitialisation(self): for f in (0.0000001, -1.0, 1.0, 0.2, -3.1415265, 1.331e32): a = BitStream(float=f, length=64) a.pos = 6 self.assertEqual(a.float, f) a = BitStream('float:64=%s' % str(f)) a.pos = 6 self.assertEqual(a.float, f) a = BitStream('floatbe:64=%s' % str(f)) a.pos = 6 self.assertEqual(a.floatbe, f) a = BitStream('floatle:64=%s' % str(f)) a.pos = 6 self.assertEqual(a.floatle, f) a = BitStream('floatne:64=%s' % str(f)) a.pos = 6 self.assertEqual(a.floatne, f) b = BitStream(float=f, length=32) b.pos = 6 self.assertAlmostEqual(b.float / f, 1.0) b = BitStream('float:32=%s' % str(f)) b.pos = 6 self.assertAlmostEqual(b.float / f, 1.0) b = BitStream('floatbe:32=%s' % str(f)) b.pos = 6 self.assertAlmostEqual(b.floatbe / f, 1.0) b = BitStream('floatle:32=%s' % str(f)) b.pos = 6 self.assertAlmostEqual(b.floatle / f, 1.0) b = BitStream('floatne:32=%s' % str(f)) b.pos = 6 self.assertAlmostEqual(b.floatne / f, 1.0) a = BitStream('0x12345678') a.pos = 6 a.float = 23 self.assertEqual(a.float, 23.0) def testFloatInitStrings(self): for s in ('5', '+0.0001', '-1e101', '4.', '.2', '-.65', '43.21E+32'): a = BitStream('float:64=%s' % s) self.assertEqual(a.float, float(s)) def testFloatPacking(self): a = pack('>d', 0.01) self.assertEqual(a.float, 0.01) self.assertEqual(a.floatbe, 0.01) a.byteswap() self.assertEqual(a.floatle, 0.01) b = pack('>f', 1e10) self.assertAlmostEqual(b.float / 1e10, 1.0) c = pack('5d', 10.0, 5.0, 2.5, 1.25, 0.1) self.assertEqual(d.unpack('>5d'), [10.0, 5.0, 2.5, 1.25, 0.1]) def testFloatReading(self): a = BitStream('floatle:64=12, floatbe:64=-0.01, floatne:64=3e33') x, y, z = a.readlist('floatle:64, floatbe:64, floatne:64') self.assertEqual(x, 12.0) self.assertEqual(y, -0.01) self.assertEqual(z, 3e33) a = BitStream('floatle:32=12, floatbe:32=-0.01, floatne:32=3e33') x, y, z = a.readlist('floatle:32, floatbe:32, floatne:32') self.assertAlmostEqual(x / 12.0, 1.0) self.assertAlmostEqual(y / -0.01, 1.0) self.assertAlmostEqual(z / 3e33, 1.0) a = BitStream('0b11, floatle:64=12, 0xfffff') a.pos = 2 self.assertEqual(a.read('floatle:64'), 12.0) b = BitStream(floatle=20, length=32) b.floatle = 10.0 b = [0] + b self.assertEqual(b[1:].floatle, 10.0) def testNonAlignedFloatReading(self): s = BitStream('0b1, float:32 = 10.0') x, y = s.readlist('1, float:32') self.assertEqual(y, 10.0) s[1:] = 'floatle:32=20.0' x, y = s.unpack('1, floatle:32') self.assertEqual(y, 20.0) def testFloatErrors(self): a = BitStream('0x3') self.assertRaises(bitstring.InterpretError, a._getfloat) self.assertRaises(bitstring.CreationError, a._setfloat, -0.2) for l in (8, 10, 12, 18, 30, 128, 200): self.assertRaises(ValueError, BitStream, float=1.0, length=l) self.assertRaises(bitstring.CreationError, BitStream, floatle=0.3, length=0) self.assertRaises(bitstring.CreationError, BitStream, floatle=0.3, length=1) self.assertRaises(bitstring.CreationError, BitStream, float=2) self.assertRaises(bitstring.InterpretError, a.read, 'floatle:2') def testReadErrorChangesPos(self): a = BitStream('0x123123') try: a.read('10, 5') except ValueError: pass self.assertEqual(a.pos, 0) def testRor(self): a = BitStream('0b11001') a.ror(0) self.assertEqual(a, '0b11001') a.ror(1) self.assertEqual(a, '0b11100') a.ror(5) self.assertEqual(a, '0b11100') a.ror(101) self.assertEqual(a, '0b01110') a = BitStream('0b1') a.ror(1000000) self.assertEqual(a, '0b1') def testRorErrors(self): a = BitStream() self.assertRaises(bitstring.Error, a.ror, 0) a += '0b001' self.assertRaises(ValueError, a.ror, -1) def testRol(self): a = BitStream('0b11001') a.rol(0) self.assertEqual(a, '0b11001') a.rol(1) self.assertEqual(a, '0b10011') a.rol(5) self.assertEqual(a, '0b10011') a.rol(101) self.assertEqual(a, '0b00111') a = BitStream('0b1') a.rol(1000000) self.assertEqual(a, '0b1') def testRolFromFile(self): a = BitStream(filename='test.m1v') l = a.len a.rol(1) self.assertTrue(a.startswith('0x000003')) self.assertEqual(a.len, l) self.assertTrue(a.endswith('0x0036e')) def testRorFromFile(self): a = BitStream(filename='test.m1v') l = a.len a.ror(1) self.assertTrue(a.startswith('0x800000')) self.assertEqual(a.len, l) self.assertTrue(a.endswith('0x000db')) def testRolErrors(self): a = BitStream() self.assertRaises(bitstring.Error, a.rol, 0) a += '0b001' self.assertRaises(ValueError, a.rol, -1) def testBytesToken(self): a = BitStream('0x010203') b = a.read('bytes:1') self.assertTrue(isinstance(b, bytes)) self.assertEqual(b, b'\x01') x, y, z = a.unpack('4, bytes:2, uint') self.assertEqual(x, 0) self.assertEqual(y, b'\x10\x20') self.assertEqual(z, 3) s = pack('bytes:4', b'abcd') self.assertEqual(s.bytes, b'abcd') def testBytesTokenMoreThoroughly(self): a = BitStream('0x0123456789abcdef') a.pos += 16 self.assertEqual(a.read('bytes:1'), b'\x45') self.assertEqual(a.read('bytes:3'), b'\x67\x89\xab') x, y, z = a.unpack('bits:28, bytes, bits:12') self.assertEqual(y, b'\x78\x9a\xbc') def testDedicatedReadFunctions(self): a = BitStream('0b11, uint:43=98798798172, 0b11111') x = a._readuint(43, 2) self.assertEqual(x, 98798798172) self.assertEqual(a.pos, 0) x = a._readint(43, 2) self.assertEqual(x, 98798798172) self.assertEqual(a.pos, 0) a = BitStream('0b11, uintbe:48=98798798172, 0b11111') x = a._readuintbe(48, 2) self.assertEqual(x, 98798798172) self.assertEqual(a.pos, 0) x = a._readintbe(48, 2) self.assertEqual(x, 98798798172) self.assertEqual(a.pos, 0) a = BitStream('0b111, uintle:40=123516, 0b111') self.assertEqual(a._readuintle(40, 3), 123516) b = BitStream('0xff, uintle:800=999, 0xffff') self.assertEqual(b._readuintle(800, 8), 999) a = BitStream('0b111, intle:48=999999999, 0b111111111111') self.assertEqual(a._readintle(48, 3), 999999999) b = BitStream('0xff, intle:200=918019283740918263512351235, 0xfffffff') self.assertEqual(b._readintle(200, 8), 918019283740918263512351235) a = BitStream('0b111, floatbe:64=-5.32, 0xffffffff') self.assertEqual(a._readfloat(64, 3), -5.32) a = BitStream('0b111, floatle:64=9.9998, 0b111') self.assertEqual(a._readfloatle(64, 3), 9.9998) def testAutoInitWithInt(self): a = BitStream(0) self.assertFalse(a) a = BitStream(1) self.assertEqual(a, '0b0') a = BitStream(1007) self.assertEqual(a, BitStream(length=1007)) self.assertRaises(bitstring.CreationError, BitStream, -1) a = 6 + ConstBitStream('0b1') + 3 self.assertEqual(a, '0b0000001000') a += 1 self.assertEqual(a, '0b00000010000') self.assertEqual(ConstBitStream(13), 13) def testReadingProblems(self): a = BitStream('0x000001') b = a.read('uint:24') self.assertEqual(b, 1) a.pos = 0 self.assertRaises(bitstring.ReadError, a.read, 'bytes:4') def testAddVersesInPlaceAdd(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 += '0xdef' self.assertEqual(a1, '0xabcdef') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 + '0x0' a2 += '0xdef' self.assertEqual(a2, '0xabcdef') self.assertEqual(b2, '0xabcdef') self.assertEqual(c2, '0xabc0') def testAndVersesInPlaceAnd(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 &= '0xf0f' self.assertEqual(a1, '0xa0c') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 & '0x00f' a2 &= '0xf0f' self.assertEqual(a2, '0xa0c') self.assertEqual(b2, '0xa0c') self.assertEqual(c2, '0x00c') def testOrVersesInPlaceOr(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 |= '0xf0f' self.assertEqual(a1, '0xfbf') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 | '0x00f' a2 |= '0xf0f' self.assertEqual(a2, '0xfbf') self.assertEqual(b2, '0xfbf') self.assertEqual(c2, '0xabf') def testXorVersesInPlaceXor(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 ^= '0xf0f' self.assertEqual(a1, '0x5b3') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 ^ '0x00f' a2 ^= '0xf0f' self.assertEqual(a2, '0x5b3') self.assertEqual(b2, '0x5b3') self.assertEqual(c2, '0xab3') def testMulVersesInPlaceMul(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 *= 3 self.assertEqual(a1, '0xabcabcabc') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 * 2 a2 *= 3 self.assertEqual(a2, '0xabcabcabc') self.assertEqual(b2, '0xabcabcabc') self.assertEqual(c2, '0xabcabc') def testLshiftVersesInPlaceLshift(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 <<= 4 self.assertEqual(a1, '0xbc0') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 << 8 a2 <<= 4 self.assertEqual(a2, '0xbc0') self.assertEqual(b2, '0xbc0') self.assertEqual(c2, '0xc00') def testRshiftVersesInPlaceRshift(self): a1 = ConstBitStream('0xabc') b1 = a1 a1 >>= 4 self.assertEqual(a1, '0x0ab') self.assertEqual(b1, '0xabc') a2 = BitStream('0xabc') b2 = a2 c2 = a2 >> 8 a2 >>= 4 self.assertEqual(a2, '0x0ab') self.assertEqual(b2, '0x0ab') self.assertEqual(c2, '0x00a') def testAutoFromBool(self): a = ConstBitStream() + True + False + True self.assertEqual(a, '0b00') # self.assertEqual(a, '0b101') # b = ConstBitStream(False) # self.assertEqual(b, '0b0') # c = ConstBitStream(True) # self.assertEqual(c, '0b1') # self.assertEqual(b, False) # self.assertEqual(c, True) # self.assertEqual(b & True, False) class Bugs(unittest.TestCase): def testBugInReplace(self): s = BitStream('0x00112233') l = list(s.split('0x22', start=8, bytealigned=True)) self.assertEqual(l, ['0x11', '0x2233']) s = BitStream('0x00112233') s.replace('0x22', '0xffff', start=8, bytealigned=True) self.assertEqual(s, '0x0011ffff33') s = BitStream('0x0123412341234') s.replace('0x23', '0xf', start=9, bytealigned=True) self.assertEqual(s, '0x012341f41f4') def testTruncateleftBug(self): a = BitStream('0b000000111')[2:] a._truncateleft(6) self.assertEqual(a, '0b1') def testNullBits(self): s = ConstBitStream(bin='') t = ConstBitStream(oct='') u = ConstBitStream(hex='') v = ConstBitStream(bytes=b'') self.assertFalse(s) self.assertFalse(t) self.assertFalse(u) self.assertFalse(v) def testMultiplicativeFactorsCreation(self): s = BitStream('1*0b1') self.assertEqual(s, '0b1') s = BitStream('4*0xc') self.assertEqual(s, '0xcccc') s = BitStream('0b1, 0*0b0') self.assertEqual(s, '0b1') s = BitStream('0b1, 3*uint:8=34, 2*0o755') self.assertEqual(s, '0b1, uint:8=34, uint:8=34, uint:8=34, 0o755755') s = BitStream('0*0b1001010') self.assertFalse(s) def testMultiplicativeFactorsReading(self): s = BitStream('0xc') * 5 a, b, c, d, e = s.readlist('5*4') self.assertTrue(a == b == c == d == e == 12) s = ConstBitStream('2*0b101, 4*uint:7=3') a, b, c, d, e = s.readlist('2*bin:3, 3*uint:7') self.assertTrue(a == b == '101') self.assertTrue(c == d == e == 3) def testMultiplicativeFactorsPacking(self): s = pack('3*bin', '1', '001', '101') self.assertEqual(s, '0b1001101') s = pack('hex, 2*se=-56, 3*uint:37', '34', 1, 2, 3) a, b, c, d, e, f = s.unpack('hex:8, 2*se, 3*uint:37') self.assertEqual(a, '34') self.assertEqual(b, -56) self.assertEqual(c, -56) self.assertEqual((d, e, f), (1, 2, 3)) # This isn't allowed yet. See comment in tokenparser. #s = pack('fluffy*uint:8', *range(3), fluffy=3) #a, b, c = s.readlist('2*uint:8, 1*uint:8, 0*uint:8') #self.assertEqual((a, b, c), (0, 1, 2)) def testMultiplicativeFactorsUnpacking(self): s = ConstBitStream('0b10111') a, b, c, d = s.unpack('3*bool, bin') self.assertEqual((a, b, c), (True, False, True)) self.assertEqual(d, '11') def testPackingDefaultIntWithKeyword(self): s = pack('12', 100) self.assertEqual(s.unpack('12')[0], 100) s = pack('oh_no_not_the_eyes=33', oh_no_not_the_eyes=17) self.assertEqual(s.uint, 33) self.assertEqual(s.len, 17) def testInitFromIterable(self): self.assertTrue(isinstance(range(10), collectionsAbc.Iterable)) s = ConstBitStream(range(12)) self.assertEqual(s, '0x7ff') def testFunctionNegativeIndices(self): # insert s = BitStream('0b0111') s.insert('0b0', -1) self.assertEqual(s, '0b01101') with self.assertRaises(ValueError): s.insert('0b0', -1000) # reverse s.reverse(-2) self.assertEqual(s, '0b01110') t = BitStream('0x778899abcdef') t.reverse(-12, -4) self.assertEqual(t, '0x778899abc7bf') # reversebytes t.byteswap(0, -40, -16) self.assertEqual(t, '0x77ab9988c7bf') # overwrite t.overwrite('0x666', -20) self.assertEqual(t, '0x77ab998666bf') # find found = t.find('0x998', bytealigned=True, start=-31) self.assertFalse(found) found = t.find('0x998', bytealigned=True, start=-32) self.assertTrue(found) self.assertEqual(t.pos, 16) t.pos = 0 found = t.find('0x988', bytealigned=True, end=-21) self.assertFalse(found) found = t.find('0x998', bytealigned=True, end=-20) self.assertTrue(found) self.assertEqual(t.pos, 16) #findall s = BitStream('0x1234151f') l = list(s.findall('0x1', bytealigned=True, start=-15)) self.assertEqual(l, [24]) l = list(s.findall('0x1', bytealigned=True, start=-16)) self.assertEqual(l, [16, 24]) l = list(s.findall('0x1', bytealigned=True, end=-5)) self.assertEqual(l, [0, 16]) l = list(s.findall('0x1', bytealigned=True, end=-4)) self.assertEqual(l, [0, 16, 24]) # rfind found = s.rfind('0x1f', end=-1) self.assertFalse(found) found = s.rfind('0x12', start=-31) self.assertFalse(found) # cut s = BitStream('0x12345') l = list(s.cut(4, start=-12, end=-4)) self.assertEqual(l, ['0x3', '0x4']) # split s = BitStream('0xfe0012fe1200fe') l = list(s.split('0xfe', bytealigned=True, end=-1)) self.assertEqual(l, ['', '0xfe0012', '0xfe1200f, 0b111']) l = list(s.split('0xfe', bytealigned=True, start=-8)) self.assertEqual(l, ['', '0xfe']) # startswith self.assertTrue(s.startswith('0x00f', start=-16)) self.assertTrue(s.startswith('0xfe00', end=-40)) self.assertFalse(s.startswith('0xfe00', end=-41)) # endswith self.assertTrue(s.endswith('0x00fe', start=-16)) self.assertFalse(s.endswith('0x00fe', start=-15)) self.assertFalse(s.endswith('0x00fe', end=-1)) self.assertTrue(s.endswith('0x00f', end=-4)) # replace s.replace('0xfe', '', end=-1) self.assertEqual(s, '0x00121200fe') s.replace('0x00', '', start=-24) self.assertEqual(s, '0x001212fe') def testRotateStartAndEnd(self): a = BitStream('0b110100001') a.rol(1, 3, 6) self.assertEqual(a, '0b110001001') a.ror(1, start=-4) self.assertEqual(a, '0b110001100') a.rol(202, end=-5) self.assertEqual(a, '0b001101100') a.ror(3, end=4) self.assertEqual(a, '0b011001100') with self.assertRaises(ValueError): a.rol(5, start=-4, end=-6) def testByteSwapInt(self): s = pack('5*uintle:16', *range(10, 15)) self.assertEqual(list(range(10, 15)), s.unpack('5*uintle:16')) swaps = s.byteswap(2) self.assertEqual(list(range(10, 15)), s.unpack('5*uintbe:16')) self.assertEqual(swaps, 5) s = BitStream('0xf234567f') swaps = s.byteswap(1, start=4) self.assertEqual(swaps, 3) self.assertEqual(s, '0xf234567f') s.byteswap(2, start=4) self.assertEqual(s, '0xf452367f') s.byteswap(2, start=4, end=-4) self.assertEqual(s, '0xf234567f') s.byteswap(3) self.assertEqual(s, '0x5634f27f') s.byteswap(2, repeat=False) self.assertEqual(s, '0x3456f27f') swaps = s.byteswap(5) self.assertEqual(swaps, 0) swaps = s.byteswap(4, repeat=False) self.assertEqual(swaps, 1) self.assertEqual(s, '0x7ff25634') def testByteSwapPackCode(self): s = BitStream('0x0011223344556677') swaps = s.byteswap('b') self.assertEqual(s, '0x0011223344556677') self.assertEqual(swaps, 8) swaps = s.byteswap('>3h', repeat=False) self.assertEqual(s, '0x1100332255446677') self.assertEqual(swaps, 1) def testByteSwapIterable(self): s = BitStream('0x0011223344556677') swaps = s.byteswap(range(1, 4), repeat=False) self.assertEqual(swaps, 1) self.assertEqual(s, '0x0022115544336677') swaps = s.byteswap([2], start=8) self.assertEqual(s, '0x0011224455663377') self.assertEqual(3, swaps) swaps = s.byteswap([2, 3], start=4) self.assertEqual(swaps, 1) self.assertEqual(s, '0x0120156452463377') def testByteSwapErrors(self): s = BitStream('0x0011223344556677') with self.assertRaises(ValueError): s.byteswap('z') with self.assertRaises(ValueError): s.byteswap(-1) with self.assertRaises(ValueError): s.byteswap([-1]) with self.assertRaises(ValueError): s.byteswap([1, 'e']) with self.assertRaises(ValueError): s.byteswap('!h') with self.assertRaises(ValueError): s.byteswap(2, start=-1000) with self.assertRaises(TypeError): s.byteswap(5.4) def testByteSwapFromFile(self): s = BitStream(filename='smalltestfile') swaps = s.byteswap('2bh') self.assertEqual(s, '0x0123674589abefcd') self.assertEqual(swaps, 2) def testBracketExpander(self): be = bitstring.expand_brackets self.assertEqual(be('hello'), 'hello') self.assertEqual(be('(hello)'), 'hello') self.assertEqual(be('1*(hello)'), 'hello') self.assertEqual(be('2*(hello)'), 'hello,hello') self.assertEqual(be('1*(a, b)'), 'a,b') self.assertEqual(be('2*(a, b)'), 'a,b,a,b') self.assertEqual(be('2*(a), 3*(b)'), 'a,a,b,b,b') self.assertEqual(be('2*(a, b, 3*(c, d), e)'), 'a,b,c,d,c,d,c,d,e,a,b,c,d,c,d,c,d,e') def testBracketTokens(self): s = BitStream('3*(0x0, 0b1)') self.assertEqual(s, '0x0, 0b1, 0x0, 0b1, 0x0, 0b1') s = pack('2*(uint:12, 3*(7, 6))', *range(3, 17)) a = s.unpack('12, 7, 6, 7, 6, 7, 6, 12, 7, 6, 7, 6, 7, 6') self.assertEqual(a, list(range(3, 17))) b = s.unpack('2*(12,3*(7,6))') self.assertEqual(a, b) def testPackCodeDicts(self): self.assertEqual(sorted(bitstring.REPLACEMENTS_BE.keys()), sorted(bitstring.REPLACEMENTS_LE.keys())) self.assertEqual(sorted(bitstring.REPLACEMENTS_BE.keys()), sorted(bitstring.PACK_CODE_SIZE.keys())) for key in bitstring.PACK_CODE_SIZE: be = pack(bitstring.REPLACEMENTS_BE[key], 0) le = pack(bitstring.REPLACEMENTS_LE[key], 0) self.assertEqual(be.len, bitstring.PACK_CODE_SIZE[key] * 8) self.assertEqual(le.len, be.len) # These tests don't compile for Python 3, so they're commented out to save me stress. #def testUnicode(self): #a = ConstBitStream(u'uint:12=34') #self.assertEqual(a.uint, 34) #a += u'0xfe' #self.assertEqual(a[12:], '0xfe') #a = BitStream('0x1122') #c = a.byteswap(u'h') #self.assertEqual(c, 1) #self.assertEqual(a, u'0x2211') #def testLongInt(self): #a = BitStream(4L) #self.assertEqual(a, '0b0000') #a[1:3] = -1L #self.assertEqual(a, '0b0110') #a[0] = 1L #self.assertEqual(a, '0b1110') #a *= 4L #self.assertEqual(a, '0xeeee') #c = a.byteswap(2L) #self.assertEqual(c, 1) #a = BitStream('0x11223344') #a.byteswap([1, 2L]) #self.assertEqual(a, '0x11332244') #b = a*2L #self.assertEqual(b, '0x1133224411332244') #s = pack('uint:12', 46L) #self.assertEqual(s.uint, 46) class UnpackWithDict(unittest.TestCase): def testLengthKeywords(self): a = ConstBitStream('2*13=100, 0b111') x, y, z = a.unpack('n, uint:m, bin:q', n=13, m=13, q=3) self.assertEqual(x, 100) self.assertEqual(y, 100) self.assertEqual(z, '111') def testLengthKeywordsWithStretch(self): a = ConstBitStream('0xff, 0b000, 0xf') x, y, z = a.unpack('hex:a, bin, hex:b', a=8, b=4) self.assertEqual(y, '000') def testUnusedKeyword(self): a = ConstBitStream('0b110') x, = a.unpack('bin:3', notused=33) self.assertEqual(x, '110') def testLengthKeywordErrors(self): a = pack('uint:p=33', p=12) with self.assertRaises(ValueError): a.unpack('uint:p') with self.assertRaises(ValueError): a.unpack('uint:p', p='a_string') class ReadWithDict(unittest.TestCase): def testLengthKeywords(self): s = BitStream('0x0102') x, y = s.readlist('a, hex:b', a=8, b=4) self.assertEqual((x, y), (1, '0')) self.assertEqual(s.pos, 12) def testBytesKeywordProblem(self): s = BitStream('0x01') x, = s.unpack('bytes:a', a=1) self.assertEqual(x, b'\x01') s = BitStream('0x000ff00a') x, y, z = s.unpack('12, bytes:x, bits', x=2) self.assertEqual((x, y, z), (0, b'\xff\x00', '0xa')) class PeekWithDict(unittest.TestCase): def testLengthKeywords(self): s = BitStream('0x0102') x, y = s.peeklist('a, hex:b', a=8, b=4) self.assertEqual((x, y), (1, '0')) self.assertEqual(s.pos, 0) ##class Miscellany(unittest.TestCase): ## ## def testNumpyInt(self): ## try: ## import numpy ## a = ConstBitStream(uint=numpy.uint8(5), length=3) ## self.assertEqual(a.uint, 5) ## except ImportError: ## # Not to worry ## pass class BoolToken(unittest.TestCase): def testInterpretation(self): a = ConstBitStream('0b1') self.assertEqual(a.bool, True) self.assertEqual(a.read('bool'), True) self.assertEqual(a.unpack('bool')[0], True) b = ConstBitStream('0b0') self.assertEqual(b.bool, False) self.assertEqual(b.peek('bool'), False) self.assertEqual(b.unpack('bool')[0], False) def testPack(self): a = pack('bool=True') b = pack('bool=False') self.assertEqual(a.bool, True) self.assertEqual(b.bool, False) c = pack('4*bool', False, True, 'False', 'True') self.assertEqual(c, '0b0101') def testAssignment(self): a = BitStream() a.bool = True self.assertEqual(a.bool, True) a.hex = 'ee' a.bool = False self.assertEqual(a.bool, False) a.bool = 'False' self.assertEqual(a.bool, False) a.bool = 'True' self.assertEqual(a.bool, True) a.bool = 0 self.assertEqual(a.bool, False) a.bool = 1 self.assertEqual(a.bool, True) def testErrors(self): with self.assertRaises(bitstring.CreationError): pack('bool', 'hello') with self.assertRaises(bitstring.CreationError): pack('bool=true') with self.assertRaises(bitstring.CreationError): pack('True') with self.assertRaises(bitstring.CreationError): pack('bool', 2) self.assertRaises(bitstring.CreationError, pack, 'bool', 'hello') self.assertRaises(bitstring.CreationError, pack, 'bool=true') self.assertRaises(bitstring.CreationError, pack, 'True') self.assertRaises(bitstring.CreationError, pack, 'bool', 2) a = BitStream('0b11') with self.assertRaises(bitstring.InterpretError): a.bool b = BitStream() with self.assertRaises(bitstring.InterpretError): b.bool with self.assertRaises(bitstring.CreationError): b.bool = 'false' def testLengthWithBoolRead(self): a = ConstBitStream('0xf') self.assertRaises(ValueError, a.read, 'bool:0') self.assertRaises(ValueError, a.read, 'bool:2') class ReadWithIntegers(unittest.TestCase): def testReadInt(self): a = ConstBitStream('0xffeedd') b = a.read(8) self.assertEqual(b.hex, 'ff') self.assertEqual(a.pos, 8) b = a.peek(8) self.assertEqual(b.hex, 'ee') self.assertEqual(a.pos, 8) b = a.peek(1) self.assertEqual(b, '0b1') b = a.read(1) self.assertEqual(b, '0b1') def testReadIntList(self): a = ConstBitStream('0xab, 0b110') b, c = a.readlist([8, 3]) self.assertEqual(b.hex, 'ab') self.assertEqual(c.bin, '110') class FileReadingStrategy(unittest.TestCase): def testBitStreamIsAlwaysRead(self): a = BitStream(filename='smalltestfile') self.assertTrue(isinstance(a._datastore, bitstring.ByteStore)) with open('smalltestfile', 'rb') as f: b = BitStream(f) self.assertTrue(isinstance(b._datastore, bitstring.ByteStore)) def testBitsIsNeverRead(self): a = ConstBitStream(filename='smalltestfile') self.assertTrue(isinstance(a._datastore._rawarray, bitstring.MmapByteArray)) with open('smalltestfile', 'rb') as f: b = ConstBitStream(f) self.assertTrue(isinstance(b._datastore._rawarray, bitstring.MmapByteArray)) class Count(unittest.TestCase): def testCount(self): a = ConstBitStream('0xf0f') self.assertEqual(a.count(True), 8) self.assertEqual(a.count(False), 4) b = BitStream() self.assertEqual(b.count(True), 0) self.assertEqual(b.count(False), 0) def testCountWithOffsetData(self): a = ConstBitStream('0xff0120ff') b = a[1:-1] self.assertEqual(b.count(1), 16) self.assertEqual(b.count(0), 14) class ZeroBitReads(unittest.TestCase): def testInteger(self): a = ConstBitStream('0x123456') self.assertRaises(bitstring.InterpretError, a.read, 'uint:0') self.assertRaises(bitstring.InterpretError, a.read, 'float:0') class InitialiseFromBytes(unittest.TestCase): def testBytesBehaviour(self): a = ConstBitStream(b'uint:5=2') b = ConstBitStream(b'') c = ConstBitStream(bytes=b'uint:5=2') if b'' == '': # Python 2 self.assertEqual(a, 'uint:5=2') self.assertFalse(b) self.assertEqual(c.bytes, b'uint:5=2') else: self.assertEqual(a.bytes, b'uint:5=2') self.assertFalse(b) self.assertEqual(c, b'uint:5=2') def testBytearrayBehaviour(self): a = ConstBitStream(bytearray(b'uint:5=2')) b = ConstBitStream(bytearray(4)) c = ConstBitStream(bytes=bytearray(b'uint:5=2')) self.assertEqual(a.bytes, b'uint:5=2') self.assertEqual(b, '0x00000000') self.assertEqual(c.bytes, b'uint:5=2') class CoverageCompletionTests(unittest.TestCase): def testUeReadError(self): s = ConstBitStream('0b000000001') self.assertRaises(bitstring.ReadError, s.read, 'ue') def testOverwriteWithSelf(self): s = BitStream('0b1101') s.overwrite(s) self.assertEqual(s, '0b1101') class Subclassing(unittest.TestCase): def testIsInstance(self): class SubBits(BitStream): pass a = SubBits() self.assertTrue(isinstance(a, SubBits)) def testClassType(self): class SubBits(BitStream): pass self.assertEqual(SubBits().__class__, SubBits) class BytesProblems(unittest.TestCase): def testOffsetButNoLength(self): b = BitStream(bytes=b'\x00\xaa', offset=8) self.assertEqual(b.hex, 'aa') b = BitStream(bytes=b'\x00\xaa', offset=4) self.assertEqual(b.hex, '0aa') def testInvert(self): b = BitStream(bytes=b'\x00\xaa', offset=8, length=8) self.assertEqual(b.hex, 'aa') b.invert() self.assertEqual(b.hex, '55') def testPrepend(self): b = BitStream(bytes=b'\xaa\xbb', offset=8, length=4) self.assertEqual(b.hex, 'b') b.prepend('0xe') self.assertEqual(b.hex, 'eb') b = BitStream(bytes=b'\x00\xaa', offset=8, length=8) b.prepend('0xee') self.assertEqual(b.hex, 'eeaa') def testByteSwap(self): b = BitStream(bytes=b'\x01\x02\x03\x04', offset=8) b.byteswap() self.assertEqual(b, '0x040302') def testBinProperty(self): b = BitStream(bytes=b'\x00\xaa', offset=8, length=4) self.assertEqual(b.bin, '1010') class Lsb0Streaming(unittest.TestCase): @classmethod def setUpClass(cls): bitstring.set_lsb0() @classmethod def tearDownClass(cls): bitstring.set_msb0() def testSimpleBitPositions(self): pass def testBitPosAfterFind(self): pass def testBitPosAfterRfind(self): pass def testBitPosAfterFindall(self): pass def testBitPosAfterInsert(self): pass def testBitPosAfterOverwrite(self): pass def testBitPosAfterReplace(self): passbitstring-bitstring-3.1.7/test/test_bitstring.py000066400000000000000000000066171365434337700221600ustar00rootroot00000000000000#!/usr/bin/env python """ Module-level unit tests. """ import unittest import sys sys.path.insert(0, '..') import bitstring import copy class ModuleData(unittest.TestCase): def testVersion(self): self.assertEqual(bitstring.__version__, '3.1.7') def testAll(self): exported = ['ConstBitArray', 'ConstBitStream', 'BitStream', 'BitArray', 'Bits', 'BitString', 'pack', 'Error', 'ReadError', 'InterpretError', 'ByteAlignError', 'CreationError', 'bytealigned', 'set_lsb0', 'set_msb0'] self.assertEqual(set(bitstring.__all__), set(exported)) def testReverseDict(self): d = bitstring.BYTE_REVERSAL_DICT for i in range(256): a = bitstring.Bits(uint=i, length=8) b = d[i] self.assertEqual(a.bin[::-1], bitstring.Bits(bytes=b).bin) def testAliases(self): self.assertTrue(bitstring.Bits is bitstring.ConstBitArray) self.assertTrue(bitstring.BitStream is bitstring.BitString) class MemoryUsage(unittest.TestCase): def testBaselineMemory(self): try: import pympler.asizeof.asizeof as size except ImportError: return # These values might be platform dependent, so don't fret too much. self.assertEqual(size(bitstring.ConstBitStream([0])), 64) self.assertEqual(size(bitstring.Bits([0])), 64) self.assertEqual(size(bitstring.BitStream([0])), 64) self.assertEqual(size(bitstring.BitArray([0])), 64) from bitstring.bitstore import ByteStore self.assertEqual(size(ByteStore(bytearray())), 100) class Copy(unittest.TestCase): def testConstBitArrayCopy(self): import copy cba = bitstring.Bits(100) cba_copy = copy.copy(cba) self.assertTrue(cba is cba_copy) def testBitArrayCopy(self): ba = bitstring.BitArray(100) ba_copy = copy.copy(ba) self.assertFalse(ba is ba_copy) self.assertFalse(ba._datastore is ba_copy._datastore) self.assertTrue(ba == ba_copy) def testConstBitStreamCopy(self): cbs = bitstring.ConstBitStream(100) cbs.pos = 50 cbs_copy = copy.copy(cbs) self.assertEqual(cbs_copy.pos, 0) self.assertTrue(cbs._datastore is cbs_copy._datastore) self.assertTrue(cbs == cbs_copy) def testBitStreamCopy(self): bs = bitstring.BitStream(100) bs.pos = 50 bs_copy = copy.copy(bs) self.assertEqual(bs_copy.pos, 0) self.assertFalse(bs._datastore is bs_copy._datastore) self.assertTrue(bs == bs_copy) class Interning(unittest.TestCase): def testBits(self): a = bitstring.Bits('0xf') b = bitstring.Bits('0xf') self.assertTrue(a is b) c = bitstring.Bits('0b1111') self.assertFalse(a is c) def testCBS(self): a = bitstring.ConstBitStream('0b11000') b = bitstring.ConstBitStream('0b11000') self.assertFalse(a is b) class LSB0(unittest.TestCase): def testGettingAndSetting(self): self.assertEqual(bitstring._lsb0, False) bitstring.set_lsb0(True) self.assertEqual(bitstring._lsb0, True) bitstring.set_lsb0(False) self.assertEqual(bitstring._lsb0, False) bitstring.set_msb0(False) self.assertEqual(bitstring._lsb0, True) bitstring.set_msb0(True) self.assertEqual(bitstring._lsb0, False) bitstring-bitstring-3.1.7/test/test_constbitstream.py000066400000000000000000000114311365434337700232020ustar00rootroot00000000000000#!/usr/bin/env python import unittest import sys sys.path.insert(0, '..') import bitstring import io from bitstring import ConstBitStream as CBS class All(unittest.TestCase): def testFromFile(self): s = CBS(filename='test.m1v') self.assertEqual(s[0:32].hex, '000001b3') self.assertEqual(s.read(8 * 4).hex, '000001b3') width = s.read(12).uint height = s.read(12).uint self.assertEqual((width, height), (352, 288)) class InterleavedExpGolomb(unittest.TestCase): def testReading(self): s = CBS(uie=333) a = s.read('uie') self.assertEqual(a, 333) s = CBS('uie=12, sie=-9, sie=9, uie=1000000') u = s.unpack('uie, 2*sie, uie') self.assertEqual(u, [12, -9, 9, 1000000]) def testReadingErrors(self): s = CBS(10) with self.assertRaises(bitstring.ReadError): s.read('uie') self.assertEqual(s.pos, 0) with self.assertRaises(bitstring.ReadError): s.read('sie') self.assertEqual(s.pos, 0) class ReadTo(unittest.TestCase): def testByteAligned(self): a = CBS('0xaabb00aa00bb') b = a.readto('0x00', bytealigned=True) self.assertEqual(b, '0xaabb00') self.assertEqual(a.bytepos, 3) b = a.readto('0xaa', bytealigned=True) self.assertEqual(b, '0xaa') with self.assertRaises(bitstring.ReadError): b.readto('0xcc', bytealigned=True) def testNotAligned(self): a = CBS('0b00111001001010011011') a.pos = 1 self.assertEqual(a.readto('0b00'), '0b011100') self.assertEqual(a.readto('0b110'), '0b10010100110') with self.assertRaises(ValueError): a.readto('') def testDisallowIntegers(self): a = CBS('0x0f') with self.assertRaises(ValueError): a.readto(4) def testReadingLines(self): s = b"This is a test\nof reading lines\nof text\n" b = CBS(bytes=s) n = bitstring.Bits(bytes=b'\n') self.assertEqual(b.readto(n).bytes, b'This is a test\n') self.assertEqual(b.readto(n).bytes, b'of reading lines\n') self.assertEqual(b.readto(n).bytes, b'of text\n') class Subclassing(unittest.TestCase): def testIsInstance(self): class SubBits(CBS): pass a = SubBits() self.assertTrue(isinstance(a, SubBits)) def testClassType(self): class SubBits(CBS): pass self.assertEqual(SubBits().__class__, SubBits) class PadToken(unittest.TestCase): def testRead(self): s = CBS('0b100011110001') a = s.read('pad:1') self.assertEqual(a, None) self.assertEqual(s.pos, 1) a = s.read(3) self.assertEqual(a, CBS('0b000')) a = s.read('pad:0') self.assertEqual(a, None) self.assertEqual(s.pos, 4) def testReadList(self): s = CBS('0b10001111001') t = s.readlist('pad:1, uint:3, pad:4, uint:3') self.assertEqual(t, [0, 1]) s.pos = 0 t = s.readlist('pad:1, pad:5') self.assertEqual(t, []) self.assertEqual(s.pos, 6) s.pos = 0 t = s.readlist('pad:1, bin, pad:4, uint:3') self.assertEqual(t, ['000', 1]) s.pos = 0 t = s.readlist('pad, bin:3, pad:4, uint:3') self.assertEqual(t, ['000', 1]) class ReadingBytes(unittest.TestCase): def testUnpackingBytes(self): s = CBS(80) t = s.unpack('bytes:1') self.assertEqual(t[0], b'\x00') a, b, c = s.unpack('bytes:1, bytes, bytes:2') self.assertEqual(a, b'\x00') self.assertEqual(b, b'\x00'*7) self.assertEqual(c, b'\x00'*2) def testUnpackingBytesWithKeywords(self): s = CBS('0x55'*10) t = s.unpack('pad:a, bytes:b, bytes, pad:a', a=4, b=6) self.assertEqual(t, [b'\x55'*6, b'\x55'*3]) class Lsb0Reading(unittest.TestCase): @classmethod def setUpClass(cls): bitstring.set_lsb0(True) @classmethod def tearDownClass(cls): bitstring.set_lsb0(False) def testReadingHex(self): s = CBS('0xabcdef') self.assertEqual(s.read(4), '0xf') self.assertEqual(s.read(4), '0xe') self.assertEqual(s.pos, 8) # TODO: Add more tests class BytesIOCreation(unittest.TestCase): def testSimpleCreation(self): f = io.BytesIO(b"\x12\xff\x77helloworld") s = CBS(f) self.assertEqual(s[0:8], '0x12') self.assertEqual(s.len, 13 * 8) s = CBS(f, offset=8, length=12) self.assertEqual(s, '0xff7') def testExceptions(self): f = io.BytesIO(b"123456789") s = CBS(f, length=9*8) with self.assertRaises(bitstring.CreationError): s = CBS(f, length=9*8 + 1) with self.assertRaises(bitstring.CreationError): s = CBS(f, length=9*8, offset=1)