diff --git a/README.rst b/README.rst index 295a17b..a91b66c 100644 --- a/README.rst +++ b/README.rst @@ -77,6 +77,16 @@ More precisely: Contributions to fulfill uncomplete/unimplemented parts are welcome. +Developer notes +=============== + +The default Qt stylesheet is inspired by the excellent QDarkStyleSheet_ and +uses most of its icons through the *QResource* API made available +from the generated *rc_icons.py* module:: + + /lib/python3./site-packages/PySide2/rcc -g python icons.qrc > rc_icons.py + + Licence ======= @@ -86,6 +96,18 @@ Please see `LICENSE`_. Changelog ========= +- `v2.9.6`_ + + * merge Qt GUI ImageView + * improve Qt GUI binfmtview/HexView with entropy & InfoView + * add specific Mach-O view + * improve support for Qt ui dark mode + * add Tricore architecture + * add w65c02 architecture + * add wasm architecture + * add wasm binary format parser + * move system.structs module into a package + - `v2.9.5`_ * merge Qt GUI binfmtview/HexView @@ -361,7 +383,9 @@ Changelog .. _pyparsing: http://pyparsing.wikispaces.com/ .. _ply: http://www.dabeaz.com/ply/ .. _sqlalchemy: http://www.sqlalchemy.org +.. _QDarkStyleSheet: https://github.com/ColinDuquesnoy/QDarkStyleSheet .. _LICENSE: https://github.com/bdcht/amoco/blob/release/LICENSE +.. _v2.9.6: https://github.com/bdcht/amoco/releases/tag/v2.9.6 .. _v2.9.5: https://github.com/bdcht/amoco/releases/tag/v2.9.5 .. _v2.9.4: https://github.com/bdcht/amoco/releases/tag/v2.9.4 .. _v2.9.3: https://github.com/bdcht/amoco/releases/tag/v2.9.3 diff --git a/amoco/arch/core.py b/amoco/arch/core.py index 9104fce..50a75a8 100644 --- a/amoco/arch/core.py +++ b/amoco/arch/core.py @@ -124,7 +124,7 @@ class instruction(icore): methods. Attributes: - address (cst): the memory address where this instruction as been disassembled. + address (cst): the memory address where this instruction as been disassembled. """ def __init__(self, istr): @@ -132,7 +132,7 @@ def __init__(self, istr): self.address = None def __repr__(self): - s = inspect.getmodule(self.spec.hook).__name__ if self.spec else "" + s = self.__class__.__name__ if self.address is not None: s += " [%s] " % self.address s += " %s ( " % self.mnemonic @@ -204,7 +204,7 @@ class disassembler(object): Arguments: specmodules: list of python modules containing ispec decorated funcs - iclass: the specific instruction class based on :class:`instruction` + iclass: the specific instruction class based on :class:`instruction` iset: lambda used to select module (ispec list) endian: instruction fetch endianess (1: little, -1: big) @@ -255,13 +255,15 @@ def setup(self, ispecs): # self.indent -= 2 return (0, ispecs) # find separating mask: - adjust = lambda x: x.ival if self.endian() == -1: - # in bigendian cases (like ARM), bytes are supposed to be MSB-justified - # that means that a spec of length = 1 byte long needs to match the MSB of the - # encoded instruction. + # in bigendian cases where not all instructions have the same length (like ARM), + # then the MSB byte needs to be maxlen-justified. Hence, if a spec is shorter + # than maxlen*8 bits, its mask and fix values need to be shifted up to a + # maxlen bitsize. maxsize = self.maxlen * 8 adjust = lambda x: x.ival << (maxsize - x.size) + else: + adjust = lambda x: x.ival localmask = reduce(lambda x, y: x & y, [adjust(s.mask) for s in ispecs]) if localmask == 0: # logger.debug('%sno local mask',ind) @@ -286,10 +288,12 @@ def setup(self, ispecs): def __call__(self, bytestring, **kargs): e = self.endian(**kargs) adjust = lambda x: x.ival + bs = bytestring[0:self.maxlen] if e == -1: maxsize = self.maxlen * 8 adjust = lambda x: x.ival << (maxsize - x.size) - b = adjust(Bits(bytestring[::e], bitorder=1)) + bs = bytestring[self.maxlen-1::-1] + b = adjust(Bits(bs, bitorder=1)) # get organized/optimized tree of specs: fl = self.specs[self.iset(**kargs)] while True: @@ -307,8 +311,8 @@ def __call__(self, bytestring, **kargs): if self.__i is None: self.__i = i return self(bytestring[s.mask.size // 8 :], **kargs) - elif i.spec.pfx > 0: - i.misc["xsz"] = i.spec.pfx + elif i.spec.pfx == "xdata": + i.xdata(i,**kargs) self.__i = None if "address" in kargs: i.address = kargs["address"] @@ -338,12 +342,14 @@ class ispec(object): spec (str): a human-friendly *format* string that describes how the ispec object will - (on request) decode a given bytestring and how it will expose various - decoded entities to the decorated function in order to define an instruction. - **kargs: + (on request) decode a given bytestring and how it will expose various + decoded entities to the decorated "hook" function to define an instruction. + **kargs: additional arguments to ispec decorator **must** be provided with ``name=value`` - form and are declared as attributes/values within the instruction instance *before* - calling the decorated function. See below for conventions about names. + form and are declared as attributes/values within the instruction instance *before* + calling the hook function. If the provided value is a FunctionType, it is + called with the bytestring passed as a Bits instance argument to produce the final + value associated with name. See below for conventions about names. Attributes: @@ -357,7 +363,8 @@ class ispec(object): fargs (dict): the dictionary of keywords arguments to pass to the hook. These keywords are decoded from the format or given by the spec's kargs when name starts with an underscore. - precond (func): an optional function that takes the instruction object as argument + precond (func): If the spec's kargs contains a name '__obj=func', then the func is + used as a pre-condition function that takes the instruction object and returns a boolean to indicate wether the hook can be called or not. (This allows to avoid decoding when a prefix is missing for example.) size (int): the bit length of the format (``LEN`` value) @@ -387,7 +394,7 @@ def f(obj,imm24,_flag): Note: - The ``spec`` string format is ``LEN ('<' or '>') '[' FORMAT ']' ('+' or '&' NUMBER)`` + The ``spec`` string format is ``LEN ('<' or '>') '[' FORMAT ']' ('+' or '&')`` - ``LEN`` is either an integer that represents the bit length of the instruction or '*'. Length must be a multiple of 8, '*' is used for a variable length @@ -397,14 +404,16 @@ def f(obj,imm24,_flag): direction : '<' (default) means that directives are ordered from MSB (bit index LEN-1) to LSB (bit index 0) whereas '>' means LSB to MSB. - The spec string is optionally terminated with '+' to indicate that it - represents an instruction *prefix*, or by '&' NUMBER to indicate that the instruction - has a *suffix* of NUMBER more bytes to decode some of its operands. + The spec string is optionally terminated with '+' to indicate that it + represents an instruction *prefix*, or by '&' to indicate that the instruction + has a *suffix* of some more bytes to decode and that the disassembler needs to call its + 'xdata' method while passing all its kargs to this method. In the *prefix* case, the bytestring matching the ispec format is stacked temporarily until the rest of the bytestring matches a non prefix ispec. In the *suffix* case, only the spec bytestring is used to define the instruction - but the :meth:`read_instruction` fetcher will provide NUMBER more bytes to the - :meth:`xdata` method of the instruction. + but the :meth:`read_instruction` fetcher will provide additional arguments to the + :meth:`xdata` method of the instruction in order to finish its decoding. + (See wasm architecture for example.) The directives defining the ``FORMAT`` string are used to associate symbols to bits located at dedicated offsets within the bitstring to be decoded. A directive has the @@ -413,9 +422,9 @@ def f(obj,imm24,_flag): * ``-`` (indicates that current bit position is not decoded) * ``0`` (indicates that current bit position must be 0) * ``1`` (indicates that current bit position must be 1) - + or - + * ``type SYMBOL location`` where: * ``type`` is an *optional* modifier char with possible values: @@ -438,7 +447,7 @@ def f(obj,imm24,_flag): buffer input string are used. default location value is ``(1)``. - + The special directive ``{byte}`` is a shortcut for 8 fixed bits. For example ``8>[{2f}]`` is equivalent to ``8>[ 1111 0100 ]``, or ``8<[ 0010 1111 ]``. """ @@ -508,7 +517,7 @@ def buildspec(self): fmt = ast[1] self.pfx = ast[2] xsz = ast[3] - if self.pfx and xsz: + if xsz: self.pfx = xsz go = +1 chklen = True @@ -737,7 +746,7 @@ def __call__(self, i, toks=False): pp.Suppress("[") + pp.OneOrMore(directive | fixed) + pp.Suppress("]") ) specoption = pp.Optional(pp.Literal("+").setParseAction(lambda r: True), default=False) -specmore = pp.Optional(pp.Suppress("&") + number, default=0) +specmore = pp.Optional(pp.Literal("&").setParseAction(lambda r: "xdata"), default=False) specdecode = speclen + specformat + specoption + specmore diff --git a/amoco/arch/dwarf/spec.py b/amoco/arch/dwarf/spec.py index 196fae1..c7865ff 100644 --- a/amoco/arch/dwarf/spec.py +++ b/amoco/arch/dwarf/spec.py @@ -66,7 +66,7 @@ def dw_op_1(obj, offset): obj.type = type_data_processing -@ispec("*>[ {94} data(*) ]", mnemonic="DW_OP_plus_uconst") +@ispec("*>[ {94} ~data(*) ]", mnemonic="DW_OP_plus_uconst") def dw_op_leb128(obj, data): data = pack(data) result, blen = read_leb128(data) diff --git a/amoco/arch/superh/cpu_sh4.py b/amoco/arch/superh/cpu_sh4.py index e4bdadc..db24c0e 100644 --- a/amoco/arch/superh/cpu_sh4.py +++ b/amoco/arch/superh/cpu_sh4.py @@ -23,4 +23,4 @@ def PC(): - return PC + return pc diff --git a/amoco/arch/superh/sh4/env.py b/amoco/arch/superh/sh4/env.py index fa8481a..f3899a1 100644 --- a/amoco/arch/superh/sh4/env.py +++ b/amoco/arch/superh/sh4/env.py @@ -24,7 +24,7 @@ # status register: SR = reg("SR", 32) # program counter(s): -PC = reg("PC", 32) +pc = reg("PC", 32) npc = reg("PC'", 32) nnpc = reg('PC"', 32) # floating point status/control register: diff --git a/amoco/arch/tricore/__init__.py b/amoco/arch/tricore/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/amoco/arch/tricore/asm.py b/amoco/arch/tricore/asm.py new file mode 100644 index 0000000..a7d23e4 --- /dev/null +++ b/amoco/arch/tricore/asm.py @@ -0,0 +1,1058 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from .env import * +from .utils import * + +from amoco.cas.utils import * + +# ------------------------------------------------------------------------------ +# helpers and decorators : + +def __npc(i_xxx): + def npc(ins, fmap): + fmap[pc] = fmap(pc) + ins.length + i_xxx(ins, fmap) + + return npc + + +def trap(ins, fmap, trapname): + internals["trap"] = trapname + + +# i_xxx is the translation of TriCore instruction xxx. +# ------------------------------------------------------------------------------ + +@__npc +def i_MOV(ins, fmap): + dst, src = ins.operands + fmap[dst] = fmap(src) + +i_MOV_A = i_MOV_AA = i_MOV_D = i_MOV + +@__npc +def i_MOVH(ins, fmap): + dst, src = ins.operands + v = fmap(src).zeroextend(32) + fmap[dst] = v<<16 + +i_MOVH_A = i_MOVH + +@__npc +def i_CMOV(ins, fmap): + dst, cond, src = ins.operands + fmap[dst] = fmap(tst(cond!=0,src,dst)) + +@__npc +def i_CMOVN(ins, fmap): + dst, cond, src = ins.operands + fmap[dst] = fmap(tst(cond==0,src,dst)) + +@__npc +def i_LEA(ins, fmap): + dst = ins.operands[0] + if ins.mode=="Absolute": + src = ins.operands[1] + fmap[dst] = src + else: + base,off = ins.operands[1:3] + fmap[dst] = fmap(base+(off.signextend(32))) + +@__npc +def i_LHA(ins, fmap): + dst = ins.operands[0] + if ins.mode=="Absolute": + src = ins.operands[1] + fmap[dst] = src + +@__npc +def i_ABS(ins, fmap): + dst, src = ins.operands + v = fmap(src) + fmap[dst] = tst(v>=0,v,0-v) + +@__npc +def i_ABS_B(ins, fmap): + dst, src = ins.operands + v = fmap(src) + fmap[dst] = composer([tst(p>=0,p,0-p) for p in (v[0:8],v[8:16],v[16:24],v[24:32])]) + +@__npc +def i_ABS_H(ins, fmap): + dst, src = ins.operands + v = fmap(src) + fmap[dst] = composer([tst(p>=0,p,0-p) for p in (v[0:16],v[16:32])]) + +@__npc +def i_ABSS(ins, fmap): + dst, src = ins.operands + v = fmap(src) + fmap[dst] = ssov(tst(v>=0,v,0-v),32) + +@__npc +def i_ABSS_H(ins, fmap): + dst, src = ins.operands + v = fmap(src) + fmap[dst] = composer([ssov(tst(p>=0,p,0-p),32) for p in (v[0:16],v[16:32])]) + + +@__npc +def i_ADD(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + fmap[dst] = result + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +i_ADDI = i_ADDIH = i_ADD + +@__npc +def i_ADD_A(ins, fmap): + dst, src1, src2 = ins.operands + result = fmap(src1+src2) + fmap[dst] = result + +i_ADDIH_A = i_ADD_A + +@__npc +def i_ADD_B(ins, fmap): + dst, src1, src2 = ins.operands + result = [] + overflow = bit0 + advanced_overflow = bit0 + for i in (0,8,16,24): + s1 = fmap(src1[i:i+8]) + s2 = fmap(src2[i:i+8]) + _r,_c,_o = AddWithCarry(s1,s2) + result.append(_r) + overflow |= _o + advanced_overflow |= _r[7:8]^_r[6:7] + fmap[dst] = composer(result) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_ADD_H(ins, fmap): + dst, src1, src2 = ins.operands + result = [] + overflow = bit0 + advanced_overflow = bit0 + for i in (0,16): + s1 = fmap(src1[i:i+16]) + s2 = fmap(src2[i:i+16]) + _r,_c,_o = AddWithCarry(s1,s2) + result.append(_r) + overflow |= _o + advanced_overflow |= _r[15:16]^_r[14:15] + fmap[dst] = composer(result) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + + +@__npc +def i_ADDC(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2),fmap(C)) + fmap[dst] = result + fmap[C] = carry + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_ADDS(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + fmap[dst] = ssov(result,32) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_ADDS_U(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + fmap[dst] = suov(result,32) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_ADDX(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + fmap[dst] = result + fmap[C] = carry + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_CADD(ins, fmap): + dst, cond, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + cond = fmap(cond!=0) + fmap[dst] = tst(cond,result,fmap(dst)) + fmap[V] = tst(cond,overflow,fmap(V)) + fmap[SV] = tst(cond&overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = tst(cond,advanced_overflow,fmap(AV)) + fmap[SAV] = tst(cond&advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_CADDN(ins, fmap): + dst, cond, src1, src2 = ins.operands + result,carry,overflow = AddWithCarry(fmap(src1),fmap(src2)) + cond = fmap(cond==0) + fmap[dst] = tst(cond,result,fmap(dst)) + fmap[V] = tst(cond,overflow,fmap(V)) + fmap[SV] = tst(cond&overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = tst(cond,advanced_overflow,fmap(AV)) + fmap[SAV] = tst(cond&advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_ADDSC_A(ins, fmap): + dst, src1, src2, n = ins.operands + result = fmap(src1+(src2<>3))&0xfffffffc) + fmap[dst] = result + +@__npc +def i_SUB(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src1),fmap(src2)) + fmap[dst] = result + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +i_SUBI = i_SUBIH = i_SUB + +@__npc +def i_RSUB(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src2),fmap(src1)) + fmap[dst] = result + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_RSUBS(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src2),fmap(src1)) + fmap[dst] = ssov(result,32) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_RSUBS_U(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src2),fmap(src1)) + fmap[dst] = suov(result,32) + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_SUB_A(ins, fmap): + dst, src1, src2 = ins.operands + result = fmap(src1-src2) + fmap[dst] = result + +i_SUBIH_A = i_SUB_A + +@__npc +def i_SUBC(ins, fmap): + dst, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src1),fmap(src2),fmap(C)) + fmap[dst] = result + fmap[C] = carry + fmap[V] = overflow + fmap[SV] = tst(overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = advanced_overflow + fmap[SAV] = tst(advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_CSUB(ins, fmap): + dst, cond, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src1),fmap(src2)) + cond = fmap(cond!=0) + fmap[dst] = tst(cond,result,fmap(dst)) + fmap[V] = tst(cond,overflow,fmap(V)) + fmap[SV] = tst(cond&overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = tst(cond,advanced_overflow,fmap(AV)) + fmap[SAV] = tst(cond&advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_CSUBN(ins, fmap): + dst, cond, src1, src2 = ins.operands + result,carry,overflow = SubWithBorrow(fmap(src1),fmap(src2)) + cond = fmap(cond==0) + fmap[dst] = tst(cond,result,fmap(dst)) + fmap[V] = tst(cond,overflow,fmap(V)) + fmap[SV] = tst(cond&overflow,bit1,fmap(SV)) + advanced_overflow = result[31:32]^result[30:31] + fmap[AV] = tst(cond,advanced_overflow,fmap(AV)) + fmap[SAV] = tst(cond&advanced_overflow,bit1,fmap(SAV)) + +@__npc +def i_SH(ins, fmap): + dst, src1, src2 = ins.operands + result = fmap(tst(src2>=0,src1<>(-src2))) + fmap[dst] = result + +@__npc +def i_SHA(ins, fmap): + dst, src1, src2 = ins.operands + x = fmap(src1) + count = fmap(src2) + if count._is_cst: + n = count.value + result = x<=0 else op(OP_ASR,x,-n) + carry = bit0 + if n>0: + carry = x[32-n:32]!=0 + elif n<0: + carry = x[0:-n]!=0 + else: + result = fmap(tst(src2>=0,src1<=0 else op(OP_ASR,x,-n) + carry = bit0 + if n>0: + carry = x[32-n:32]!=0 + elif n<0: + carry = x[0:-n]!=0 + else: + result = fmap(tst(src2>=0,src1<=src2) + fmap[dst] = result.zeroextend(dst.size) + +i_GE_A = i_GE + +@__npc +def i_GE_U(ins, fmap): + dst, src1, src2 = ins.operands + result = fmap(op(OP_GEU,src1,src2)) + fmap[dst] = result.zeroextend(dst.size) + +@__npc +def i_LT(ins, fmap): + dst, src1, src2 = ins.operands + result = fmap(src1=src2)) + +@__npc +def i_OR_GE(ins, fmap): + dst, src1, src2 = ins.operands + fmap[dst[0:1]] = fmap(dst[0:1]|(src1>=src2)) + +@__npc +def i_XOR_GE(ins, fmap): + dst, src1, src2 = ins.operands + fmap[dst[0:1]] = fmap(dst[0:1]^(src1>=src2)) + +@__npc +def i_AND_LT(ins, fmap): + dst, src1, src2 = ins.operands + fmap[dst[0:1]] = fmap(dst[0:1]&(src1 0: + s.pop() + return s + + +def opers_adr(i): + s = opers(i) + if i.misc["imm_ref"] is None and i.address is not None: + imm_ref = i.address + i.operands[-1] + s[-1] = (Token.Address, "%s" % (imm_ref)) + return s + + +format_default = (mnemo, opers) + +tricore_full_formats = { + "tricore_branch": (mnemo, opers_adr), + "tricore_jcc": (mnemo, opers_adr), +} + +TriCore_full = Formatter(tricore_full_formats) +TriCore_full.default = format_default + diff --git a/amoco/arch/tricore/spec.py b/amoco/arch/tricore/spec.py new file mode 100644 index 0000000..4172f26 --- /dev/null +++ b/amoco/arch/tricore/spec.py @@ -0,0 +1,1465 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.arch.tricore import env + +from amoco.arch.core import * + +# ------------------------------------------------------- +# from TriCore TC1.6.2 core architecture manual V1.2.2 +# (32-bit Unified Processor Core), 2020-01-15 + +# define all except FPU instructions +# ------------------------------------------------------- + +ISPECS = [] + +@ispec("32<[ disp1(16) disp2(8) {6d} ]", mnemonic="CALL") +@ispec("32<[ disp1(16) disp2(8) {61} ]", mnemonic="FCALL") +@ispec("32<[ disp1(16) disp2(8) {1d} ]", mnemonic="J") +@ispec("32<[ disp1(16) disp2(8) {5d} ]", mnemonic="JL") +def tricore_branch(obj, disp1, disp2): + v = env.cst(((disp2<<16)+disp1)<<1,24) + obj.operands = [disp.signextend(32)] + obj.type = type_control_flow + +@ispec("32<[ disp1(16) disp2(8) {ed} ]", mnemonic="CALLA") +@ispec("32<[ disp1(16) disp2(8) {e1} ]", mnemonic="FCALLA") +@ispec("32<[ disp1(16) disp2(8) {9d} ]", mnemonic="JA") +@ispec("32<[ disp1(16) disp2(8) {dd} ]", mnemonic="JLA") +def tricore_branch(obj, disp1, disp2): + v = env.cst((disp2<<16)+disp1,24) + addr = composer([env.bit0,v[0:20],env.cst(0,7),v[20:24]]) + obj.operands = [addr] + obj.type = type_control_flow + +@ispec("32<[ ---- {00} ---- ---- a(4) {2d} ]", mnemonic="CALLI") +@ispec("32<[ ---- {01} ---- ---- a(4) {2d} ]", mnemonic="FCALLI") +@ispec("32<[ ---- {03} ---- ---- a(4) {2d} ]", mnemonic="JI") +@ispec("32<[ ---- {02} ---- ---- a(4) {2d} ]", mnemonic="JLI") +def tricore_branchI(obj, a): + src = env.A[a] + obj.operands = [src] + obj.type = type_control_flow + +@ispec("16<[ disp(8) {5c} ]", mnemonic="CALL") +@ispec("16<[ disp(8) {3c} ]", mnemonic="J") +@ispec("16<[ disp(8) {ee} ]", mnemonic="JNZ") +@ispec("16<[ disp(8) {6e} ]", mnemonic="JZ") +def tricore_branch(obj, disp): + disp = env.cst(disp<<1,8) + obj.operands = [disp.signextend(32)] + obj.type = type_control_flow + +@ispec("32<[ ---- 0000000 const9(9) ---- {ad} ]", mnemonic="BISR") +@ispec("32<[ ---- 0000100 const9(9) ---- {ad} ]", mnemonic="SYSCALL") +def tricore_system(obj, const9): + obj.operands = [env.cst(const9,9)] + obj.type = type_system + +@ispec("32<[ c(4) {1c} ---- b(4) ---- {0b} ]", mnemonic="ABS") +@ispec("32<[ c(4) {5c} ---- b(4) ---- {0b} ]", mnemonic="ABS_B") +@ispec("32<[ c(4) {7c} ---- b(4) ---- {0b} ]", mnemonic="ABS_H") +@ispec("32<[ c(4) {1d} ---- b(4) ---- {0b} ]", mnemonic="ABSS") +@ispec("32<[ c(4) {7d} ---- b(4) ---- {0b} ]", mnemonic="ABSS_H") +@ispec("32<[ c(4) {1f} ---- b(4) ---- {0b} ]", mnemonic="MOV") +def tricore_dd_arithmetic(obj, c, b): + src = env.D[b] + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) {80} ---- b(4) ---- {0b} ]", mnemonic="MOV") +def tricore_dd_arithmetic(obj, c, b): + src = env.D[b] + dst = env.E[c] + obj.operands = [dst, src.signextend(64)] + obj.type = type_data_processing + +@ispec("32<[ c(4) {81} ---- b(4) a(4) {0b} ]", mnemonic="MOV") +def tricore_dd_arithmetic(obj, c, b, a): + src2 = env.D[b] + dst = env.E[c] + obj.operands = [dst, composer([src2,src1])] + obj.type = type_data_processing + +@ispec("32<[ c(4) {0e} ---- b(4) a(4) {0b} ]", mnemonic="ABSDIF") +@ispec("32<[ c(4) {4e} ---- b(4) a(4) {0b} ]", mnemonic="ABSDIF_B") +@ispec("32<[ c(4) {6e} ---- b(4) a(4) {0b} ]", mnemonic="ABSDIF_H") +@ispec("32<[ c(4) {0f} ---- b(4) a(4) {0b} ]", mnemonic="ABSDIFS") +@ispec("32<[ c(4) {6f} ---- b(4) a(4) {0b} ]", mnemonic="ABSDIFS_H") +@ispec("32<[ c(4) {00} ---- b(4) a(4) {0b} ]", mnemonic="ADD") +@ispec("32<[ c(4) {40} ---- b(4) a(4) {0b} ]", mnemonic="ADD_B") +@ispec("32<[ c(4) {60} ---- b(4) a(4) {0b} ]", mnemonic="ADD_H") +@ispec("32<[ c(4) {05} ---- b(4) a(4) {0b} ]", mnemonic="ADDC") +@ispec("32<[ c(4) {02} ---- b(4) a(4) {0b} ]", mnemonic="ADDS") +@ispec("32<[ c(4) {62} ---- b(4) a(4) {0b} ]", mnemonic="ADDS_H") +@ispec("32<[ c(4) {63} ---- b(4) a(4) {0b} ]", mnemonic="ADDS_HU") +@ispec("32<[ c(4) {03} ---- b(4) a(4) {0b} ]", mnemonic="ADDS_U") +@ispec("32<[ c(4) {04} ---- b(4) a(4) {0b} ]", mnemonic="ADDX") +@ispec("32<[ c(4) {08} ---- b(4) a(4) {0f} ]", mnemonic="AND") +@ispec("32<[ c(4) {20} ---- b(4) a(4) {0b} ]", mnemonic="AND_EQ") +@ispec("32<[ c(4) {24} ---- b(4) a(4) {0b} ]", mnemonic="AND_GE") +@ispec("32<[ c(4) {25} ---- b(4) a(4) {0b} ]", mnemonic="AND_GE_U") +@ispec("32<[ c(4) {22} ---- b(4) a(4) {0b} ]", mnemonic="AND_LT") +@ispec("32<[ c(4) {23} ---- b(4) a(4) {0b} ]", mnemonic="AND_LT_U") +@ispec("32<[ c(4) {21} ---- b(4) a(4) {0b} ]", mnemonic="AND_NE") +@ispec("32<[ c(4) {0e} ---- b(4) a(4) {0f} ]", mnemonic="ANDN") +@ispec("32<[ c(4) {10} ---- b(4) a(4) {0b} ]", mnemonic="EQ") +@ispec("32<[ c(4) {50} ---- b(4) a(4) {0b} ]", mnemonic="EQ_B") +@ispec("32<[ c(4) {70} ---- b(4) a(4) {0b} ]", mnemonic="EQ_H") +@ispec("32<[ c(4) {90} ---- b(4) a(4) {0b} ]", mnemonic="EQ_W") +@ispec("32<[ c(4) {56} ---- b(4) a(4) {0b} ]", mnemonic="EQANY_B") +@ispec("32<[ c(4) {76} ---- b(4) a(4) {0b} ]", mnemonic="EQANY_H") +@ispec("32<[ c(4) {14} ---- b(4) a(4) {0b} ]", mnemonic="GE") +@ispec("32<[ c(4) {15} ---- b(4) a(4) {0b} ]", mnemonic="GE_U") +@ispec("32<[ c(4) {12} ---- b(4) a(4) {0b} ]", mnemonic="LT") +@ispec("32<[ c(4) {13} ---- b(4) a(4) {0b} ]", mnemonic="LT_U") +@ispec("32<[ c(4) {52} ---- b(4) a(4) {0b} ]", mnemonic="LT_B") +@ispec("32<[ c(4) {53} ---- b(4) a(4) {0b} ]", mnemonic="LT_BU") +@ispec("32<[ c(4) {72} ---- b(4) a(4) {0b} ]", mnemonic="LT_H") +@ispec("32<[ c(4) {73} ---- b(4) a(4) {0b} ]", mnemonic="LT_HU") +@ispec("32<[ c(4) {92} ---- b(4) a(4) {0b} ]", mnemonic="LT_W") +@ispec("32<[ c(4) {93} ---- b(4) a(4) {0b} ]", mnemonic="LT_WU") +@ispec("32<[ c(4) {1a} ---- b(4) a(4) {0b} ]", mnemonic="MAX") +@ispec("32<[ c(4) {1b} ---- b(4) a(4) {0b} ]", mnemonic="MAX_U") +@ispec("32<[ c(4) {5a} ---- b(4) a(4) {0b} ]", mnemonic="MAX_B") +@ispec("32<[ c(4) {5b} ---- b(4) a(4) {0b} ]", mnemonic="MAX_BU") +@ispec("32<[ c(4) {7a} ---- b(4) a(4) {0b} ]", mnemonic="MAX_H") +@ispec("32<[ c(4) {7b} ---- b(4) a(4) {0b} ]", mnemonic="MAX_HU") +@ispec("32<[ c(4) {18} ---- b(4) a(4) {0b} ]", mnemonic="MIN") +@ispec("32<[ c(4) {19} ---- b(4) a(4) {0b} ]", mnemonic="MIN_U") +@ispec("32<[ c(4) {58} ---- b(4) a(4) {0b} ]", mnemonic="MIN_B") +@ispec("32<[ c(4) {59} ---- b(4) a(4) {0b} ]", mnemonic="MIN_BU") +@ispec("32<[ c(4) {78} ---- b(4) a(4) {0b} ]", mnemonic="MIN_H") +@ispec("32<[ c(4) {79} ---- b(4) a(4) {0b} ]", mnemonic="MIN_HU") +@ispec("32<[ c(4) {09} ---- b(4) a(4) {0f} ]", mnemonic="NAND") +@ispec("32<[ c(4) {11} ---- b(4) a(4) {0b} ]", mnemonic="NE") +@ispec("32<[ c(4) {0b} ---- b(4) a(4) {0f} ]", mnemonic="NOR") +@ispec("32<[ c(4) {0a} ---- b(4) a(4) {0f} ]", mnemonic="OR") +@ispec("32<[ c(4) {27} ---- b(4) a(4) {0b} ]", mnemonic="OR_EQ") +@ispec("32<[ c(4) {2b} ---- b(4) a(4) {0b} ]", mnemonic="OR_GE") +@ispec("32<[ c(4) {2c} ---- b(4) a(4) {0b} ]", mnemonic="OR_GE_U") +@ispec("32<[ c(4) {29} ---- b(4) a(4) {0b} ]", mnemonic="OR_LT") +@ispec("32<[ c(4) {2a} ---- b(4) a(4) {0b} ]", mnemonic="OR_LT_U") +@ispec("32<[ c(4) {28} ---- b(4) a(4) {0b} ]", mnemonic="OR_NE") +@ispec("32<[ c(4) {0f} ---- b(4) a(4) {0f} ]", mnemonic="ORN") +@ispec("32<[ c(4) {00} ---- b(4) a(4) {0f} ]", mnemonic="SH") +@ispec("32<[ c(4) {37} ---- b(4) a(4) {0b} ]", mnemonic="SH_EQ") +@ispec("32<[ c(4) {3b} ---- b(4) a(4) {0b} ]", mnemonic="SH_GE") +@ispec("32<[ c(4) {3c} ---- b(4) a(4) {0b} ]", mnemonic="SH_GE_U") +@ispec("32<[ c(4) {40} ---- b(4) a(4) {0f} ]", mnemonic="SH_H") +@ispec("32<[ c(4) {39} ---- b(4) a(4) {0b} ]", mnemonic="SH_LT") +@ispec("32<[ c(4) {3a} ---- b(4) a(4) {0b} ]", mnemonic="SH_LT_U") +@ispec("32<[ c(4) {38} ---- b(4) a(4) {0b} ]", mnemonic="SH_NE") +@ispec("32<[ c(4) {01} ---- b(4) a(4) {0f} ]", mnemonic="SHA") +@ispec("32<[ c(4) {41} ---- b(4) a(4) {0f} ]", mnemonic="SHA_H") +@ispec("32<[ c(4) {02} ---- b(4) a(4) {0f} ]", mnemonic="SHAS") +@ispec("32<[ c(4) {08} ---- b(4) a(4) {0b} ]", mnemonic="SUB") +@ispec("32<[ c(4) {48} ---- b(4) a(4) {0b} ]", mnemonic="SUB_B") +@ispec("32<[ c(4) {68} ---- b(4) a(4) {0b} ]", mnemonic="SUB_H") +@ispec("32<[ c(4) {0d} ---- b(4) a(4) {0b} ]", mnemonic="SUBC") +@ispec("32<[ c(4) {0a} ---- b(4) a(4) {0b} ]", mnemonic="SUBS") +@ispec("32<[ c(4) {0b} ---- b(4) a(4) {0b} ]", mnemonic="SUBS_U") +@ispec("32<[ c(4) {6a} ---- b(4) a(4) {0b} ]", mnemonic="SUBS_H") +@ispec("32<[ c(4) {6b} ---- b(4) a(4) {0b} ]", mnemonic="SUBS_HU") +@ispec("32<[ c(4) {0c} ---- b(4) a(4) {0b} ]", mnemonic="SUBX") +@ispec("32<[ c(4) {0d} ---- b(4) a(4) {0f} ]", mnemonic="XNOR") +@ispec("32<[ c(4) {0c} ---- b(4) a(4) {0f} ]", mnemonic="XOR") +@ispec("32<[ c(4) {2f} ---- b(4) a(4) {0b} ]", mnemonic="XOR_EQ") +@ispec("32<[ c(4) {30} ---- b(4) a(4) {0b} ]", mnemonic="XOR_NE") +def tricore_ddd_arithmetic(obj, c, b, a): + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {40} ---- b(4) a(4) {01} ]", mnemonic="EQ_A") +@ispec("32<[ c(4) {43} ---- b(4) a(4) {01} ]", mnemonic="GE_A") +@ispec("32<[ c(4) {42} ---- b(4) a(4) {01} ]", mnemonic="LT_A") +@ispec("32<[ c(4) {41} ---- b(4) a(4) {01} ]", mnemonic="NE_A") +def tricore_daa_arithmetic(obj, c, b, a): + src1 = env.A[a] + src2 = env.A[b] + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {63} ---- b(4) ---- {01} ]", mnemonic="MOV_A", _dst=env.A, _src=env.D) +@ispec("32<[ c(4) {00} ---- b(4) ---- {01} ]", mnemonic="MOV_AA", _dst=env.A, _src=env.A) +@ispec("32<[ c(4) {4c} ---- b(4) ---- {01} ]", mnemonic="MOV_D", _dst=env.D, _src=env.A) +def tricore_daa_arithmetic(obj, c, b, _dst, _src): + dst = _dst[c] + src = _src[b] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) {48} ---- ---- a(4) {01} ]", mnemonic="EQZ_A") +@ispec("32<[ c(4) {49} ---- ---- a(4) {01} ]", mnemonic="NEZ_A") +def tricore_da_arithmetic(obj, c, a): + src1 = env.A[a] + dst = env.D[c] + obj.operands = [dst, src1] + obj.type = type_data_processing + +@ispec("32<[ c(4) {01} --00 b(4) a(4) {4b} ]", mnemonic="BMERGE") +def tricore_ddd_arithmetic(obj, c, b, a): + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {06} --00 b(4) a(4) {4b} ]", mnemonic="CRC32_B") +@ispec("32<[ c(4) {03} --00 b(4) a(4) {4b} ]", mnemonic="CRC32B_W") +@ispec("32<[ c(4) {03} --00 b(4) a(4) {4b} ]", mnemonic="CRC32L_W") +def tricore_crc32(obj, c, b, a): + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src2, src1] + obj.type = type_data_processing + +@ispec("32<[ c(4) {20} --01 b(4) a(4) {4b} ]", mnemonic="DIV") +@ispec("32<[ c(4) {21} --01 b(4) a(4) {4b} ]", mnemonic="DIV_U") +@ispec("32<[ c(4) {5a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT_B") +@ispec("32<[ c(4) {4a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT_BU") +@ispec("32<[ c(4) {3a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT_H") +@ispec("32<[ c(4) {2a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT_HU") +@ispec("32<[ c(4) {1a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT") +@ispec("32<[ c(4) {0a} --00 b(4) a(4) {4b} ]", mnemonic="DVINIT_U") +def tricore_edd_arithmetic(obj, c, b, a): + src1 = env.D[a] + src2 = env.D[b] + if c%2: + raise InstructionError(obj) + dst = env.E[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 100 ----- b(4) a(4) {17} ]", mnemonic="DEXTR") +def tricore_dddc(obj, c, d, b, a): + shift = env.D[d] + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src1, src2, shift] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 010 ----- ---- a(4) {17} ]", mnemonic="EXTR") +@ispec("32<[ c(4) d(4) 011 ----- ---- a(4) {17} ]", mnemonic="EXTR_U") +def tricore_extr(obj, c, d, a): + if d%2: + raise InstructionError(obj) + width = env.E[d][32:37] + src1 = env.D[a] + dst = env.D[c] + obj.operands = [dst, src1, width] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 0--00 ---- a(4) {6b} ]", mnemonic="PACK") +def tricore_extr(obj, c, d, a): + if d%2: + raise InstructionError(obj) + src1 = env.E[d] + src2 = env.D[a] + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {08} -- 00 ---- a(4) {4b} ]", mnemonic="UNPACK") +def tricore_extr(obj, c, d, a): + src = env.D[a] + dst = env.E[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) {02} -- 00 ---- a(4) {4b} ]", mnemonic="PARITY") +@ispec("32<[ c(4) {22} -- 00 ---- a(4) {4b} ]", mnemonic="POPCNT_W") +def tricore_extr(obj, c, d, a): + src = env.D[a] + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 00 ----- b(4) a(4) {77} ]", mnemonic="DEXTR") +def tricore_dextr(obj, c, pos, b, a): + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src1, src2, env.cst(pos,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 10 width(5) ---- a(4) {37} ]", mnemonic="EXTR") +@ispec("32<[ c(4) pos(5) 11 width(5) ---- a(4) {37} ]", mnemonic="EXTR_U") +def tricore_extr(obj, c, pos, width, a): + src1 = env.D[a] + dst = env.D[c] + obj.operands = [dst, src1, env.cst(pos,5), env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 01 width(5) const(4) ---- {b7} ]", mnemonic="IMASK") +def tricore_imask(obj, c, pos, width, const): + if c%2: + raise InstructionError(obj) + dst = env.E[c] + obj.operands = [dst, env.cst(const,4), env.cst(pos,5), env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 001 width(5) const(4) ---- {d7} ]", mnemonic="IMASK") +def tricore_imask(obj, c, d, width, const): + src2 = env.D[d] + if c%2: + raise InstructionError(obj) + dst = env.E[c] + obj.operands = [dst, env.cst(const,4), src2, env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 01 width(5) b(4) ---- {37} ]", mnemonic="IMASK") +def tricore_imask(obj, c, pos, width, b): + src1 = env.D[b] + if c%2: + raise InstructionError(obj) + dst = env.E[c] + obj.operands = [dst, src1, env.cst(pos,5), env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 001 width(5) b(4) ---- {57} ]", mnemonic="IMASK") +def tricore_imask(obj, c, d, width, b): + src1 = env.D[b] + src2 = env.D[d] + if c%2: + raise InstructionError(obj) + dst = env.E[c] + obj.operands = [dst, src1, src2, env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 00 width(5) const(4) a(4) {b7} ]", mnemonic="INSERT") +def tricore_imask(obj, c, pos, width, const, a): + dst = env.D[c] + src1 = env.D[a] + obj.operands = [dst, src1, env.cst(const,4), env.cst(pos,5), env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 ----- const(4) a(4) {97} ]", mnemonic="INSERT") +def tricore_imask(obj, c, d, const, a): + src1 = env.D[a] + if d%2: + raise InstructionError(obj) + src3 = env.E[d] + dst = env.D[c] + obj.operands = [dst, src1, env.cst(const,4), src3] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 width(5) const(4) a(4) {d7} ]", mnemonic="INSERT") +def tricore_imask(obj, c, d, width, const, a): + src1 = env.D[a] + src3 = env.D[d] + dst = env.D[c] + obj.operands = [dst, src1, env.cst(const,4), src3] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos(5) 00 width(5) b(4) a(4) {37} ]", mnemonic="INSERT") +def tricore_imask(obj, c, pos, width, b, a): + dst = env.D[c] + src1 = env.D[a] + src2 = env.D[b] + obj.operands = [dst, src1, src2, env.cst(pos,5), env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 ----- b(4) a(4) {17} ]", mnemonic="INSERT") +def tricore_imask(obj, c, d, b, a): + src1 = env.D[a] + src2 = env.D[b] + if d%2: + raise InstructionError(obj) + src3 = env.E[d] + dst = env.D[c] + obj.operands = [dst, src1, src2, src3] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 width(5) b(4) a(4) {57} ]", mnemonic="INSERT") +def tricore_imask(obj, c, d, width, b, a): + src1 = env.D[a] + src2 = env.D[b] + src3 = env.D[d] + dst = env.D[c] + obj.operands = [dst, src1, src2, src3, env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 010 width(5) ---- a(4) {57} ]", mnemonic="EXTR") +@ispec("32<[ c(4) d(4) 011 width(5) ---- a(4) {57} ]", mnemonic="EXTR_U") +def tricore_extr(obj, c, d, width, a): + src2 = env.D[d] + src1 = env.D[a] + dst = env.D[c] + obj.operands = [dst, src1, src2, env.cst(width,5)] + obj.type = type_data_processing + +@ispec("32<[ c(4) {09} --00 ---- a(4) {4b} ]", mnemonic="BSPLIT") +def tricore_edd_arithmetic(obj, c, a): + src1 = env.D[a] + dst = env.E[c] + obj.operands = [dst, src1] + obj.type = type_data_processing + +@ispec("32<[ c(4) 0001110 ~const9(9) a(4) {8b} ]", mnemonic="ABSDIF") +@ispec("32<[ c(4) 0001111 ~const9(9) a(4) {8b} ]", mnemonic="ABSDIFS") +@ispec("32<[ c(4) 0000000 ~const9(9) a(4) {8b} ]", mnemonic="ADD") +@ispec("32<[ c(4) 0000101 ~const9(9) a(4) {8b} ]", mnemonic="ADDC") +@ispec("32<[ c(4) 0000010 ~const9(9) a(4) {8b} ]", mnemonic="ADDS") +@ispec("32<[ c(4) 0000011 ~const9(9) a(4) {8b} ]", mnemonic="ADDS_U") #const9 is signed +@ispec("32<[ c(4) 0000100 ~const9(9) a(4) {8b} ]", mnemonic="ADDX") +@ispec("32<[ c(4) 0100000 ~const9(9) a(4) {8b} ]", mnemonic="AND_EQ") +@ispec("32<[ c(4) 0100100 ~const9(9) a(4) {8b} ]", mnemonic="AND_GE") +@ispec("32<[ c(4) 0100010 ~const9(9) a(4) {8b} ]", mnemonic="AND_LT") +@ispec("32<[ c(4) 0100001 ~const9(9) a(4) {8b} ]", mnemonic="AND_NE") +@ispec("32<[ c(4) 0010000 ~const9(9) a(4) {8b} ]", mnemonic="EQ") +@ispec("32<[ c(4) 1010110 ~const9(9) a(4) {8b} ]", mnemonic="EQANY_B") +@ispec("32<[ c(4) 1110110 ~const9(9) a(4) {8b} ]", mnemonic="EQANY_H") +@ispec("32<[ c(4) 0010100 ~const9(9) a(4) {8b} ]", mnemonic="GE") +@ispec("32<[ c(4) 0010010 ~const9(9) a(4) {8b} ]", mnemonic="LT") +@ispec("32<[ c(4) 0011010 ~const9(9) a(4) {8b} ]", mnemonic="MAX") +@ispec("32<[ c(4) 0010001 ~const9(9) a(4) {8b} ]", mnemonic="NE") +@ispec("32<[ c(4) 0100111 ~const9(9) a(4) {8b} ]", mnemonic="OR_EQ") +@ispec("32<[ c(4) 0101011 ~const9(9) a(4) {8b} ]", mnemonic="OR_GE") +@ispec("32<[ c(4) 0101001 ~const9(9) a(4) {8b} ]", mnemonic="OR_LT") +@ispec("32<[ c(4) 0001000 ~const9(9) a(4) {8b} ]", mnemonic="RSUB") +@ispec("32<[ c(4) 0001001 ~const9(9) a(4) {8b} ]", mnemonic="RSUBS") +@ispec("32<[ c(4) 0001011 ~const9(9) a(4) {8b} ]", mnemonic="RSUBS_U") #const9 is signed +@ispec("32<[ c(4) 0000000 ~const9(9) a(4) {8f} ]", mnemonic="SH") +@ispec("32<[ c(4) 1000000 ~const9(9) a(4) {8f} ]", mnemonic="SH_H") +@ispec("32<[ c(4) 0110111 ~const9(9) a(4) {8b} ]", mnemonic="SH_EQ") +@ispec("32<[ c(4) 0111011 ~const9(9) a(4) {8b} ]", mnemonic="SH_GE") +@ispec("32<[ c(4) 0111001 ~const9(9) a(4) {8b} ]", mnemonic="SH_LT") +@ispec("32<[ c(4) 0111000 ~const9(9) a(4) {8b} ]", mnemonic="SH_NE") +@ispec("32<[ c(4) 0000001 ~const9(9) a(4) {8f} ]", mnemonic="SHA") +@ispec("32<[ c(4) 1000001 ~const9(9) a(4) {8f} ]", mnemonic="SHA_H") +@ispec("32<[ c(4) 0000010 ~const9(9) a(4) {8f} ]", mnemonic="SHAS") +@ispec("32<[ c(4) 0101111 ~const9(9) a(4) {8b} ]", mnemonic="XOR_EQ") +@ispec("32<[ c(4) 0110011 ~const9(9) a(4) {8b} ]", mnemonic="XOR_GE") +@ispec("32<[ c(4) 0110001 ~const9(9) a(4) {8b} ]", mnemonic="XOR_LT") +@ispec("32<[ c(4) 0110000 ~const9(9) a(4) {8b} ]", mnemonic="XOR_NE") +def tricore_ddc_arithmetic(obj, c, const9, a): + src1 = env.D[a] + if obj.mnemonic in ("SH","SHA","SHAS"): + const9 = const9[0:6] + elif obj.mnemonic in ("SH_H","SHA_H"): + const9 = const9[0:5] + src2 = env.cst(const9.int(-1),32) + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {47} ]", mnemonic="AND_AND_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {47} ]", mnemonic="AND_ANDN_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {47} ]", mnemonic="AND_NOR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {47} ]", mnemonic="AND_OR_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {87} ]", mnemonic="AND_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {87} ]", mnemonic="ANDN_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {67} ]", mnemonic="INS_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {67} ]", mnemonic="INSN_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {07} ]", mnemonic="NAND_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {87} ]", mnemonic="NOR_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {c7} ]", mnemonic="OR_AND_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {c7} ]", mnemonic="OR_ANDN_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {c7} ]", mnemonic="OR_NOR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {c7} ]", mnemonic="OR_OR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {87} ]", mnemonic="OR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {07} ]", mnemonic="ORN_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {27} ]", mnemonic="SH_AND_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {27} ]", mnemonic="SH_ANDN_T") +@ispec("32<[ c(4) pos2(5) 00 pos1(5) b(4) a(4) {a7} ]", mnemonic="SH_NAND_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {27} ]", mnemonic="SH_NOR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {27} ]", mnemonic="SH_OR_T") +@ispec("32<[ c(4) pos2(5) 01 pos1(5) b(4) a(4) {a7} ]", mnemonic="SH_ORN_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {a7} ]", mnemonic="SH_XNOR_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {a7} ]", mnemonic="SH_XOR_T") +@ispec("32<[ c(4) pos2(5) 10 pos1(5) b(4) a(4) {07} ]", mnemonic="XNOR_T") +@ispec("32<[ c(4) pos2(5) 11 pos1(5) b(4) a(4) {07} ]", mnemonic="XOR_T") +def tricore_ddd_arithmetic(obj, c, pos2, pos1, b, a): + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, src1[pos1:pos1+1], src2[pos2:pos2+1]] + obj.type = type_data_processing + +@ispec("32<[ c(4) 0001000 const9(9) a(4) {8f} ]", mnemonic="AND") +@ispec("32<[ c(4) 0100101 const9(9) a(4) {8b} ]", mnemonic="AND_GE_U") +@ispec("32<[ c(4) 0100011 const9(9) a(4) {8b} ]", mnemonic="AND_LT_U") +@ispec("32<[ c(4) 0001110 const9(9) a(4) {8f} ]", mnemonic="ANDN") +@ispec("32<[ c(4) 0001001 const9(9) a(4) {8f} ]", mnemonic="NAND") +@ispec("32<[ c(4) 0001011 const9(9) a(4) {8f} ]", mnemonic="NOR") +@ispec("32<[ c(4) 0010101 const9(9) a(4) {8b} ]", mnemonic="GE_U") +@ispec("32<[ c(4) 0001010 const9(9) a(4) {8f} ]", mnemonic="OR") +@ispec("32<[ c(4) 0101100 const9(9) a(4) {8b} ]", mnemonic="OR_GE_U") +@ispec("32<[ c(4) 0101010 const9(9) a(4) {8b} ]", mnemonic="OR_LT_U") +@ispec("32<[ c(4) 0101000 const9(9) a(4) {8b} ]", mnemonic="OR_NE") +@ispec("32<[ c(4) 0001111 const9(9) a(4) {8f} ]", mnemonic="ORN") +@ispec("32<[ c(4) 0000111 const9(9) a(4) {8f} ]", mnemonic="SHUFFLE") +@ispec("32<[ c(4) 0001101 const9(9) a(4) {8f} ]", mnemonic="XNOR") +@ispec("32<[ c(4) 0001100 const9(9) a(4) {8f} ]", mnemonic="XOR") +@ispec("32<[ c(4) 0111100 const9(9) a(4) {8b} ]", mnemonic="SH_GE_U") +@ispec("32<[ c(4) 0111010 const9(9) a(4) {8b} ]", mnemonic="SH_LT_U") +@ispec("32<[ c(4) 0110100 const9(9) a(4) {8b} ]", mnemonic="XOR_GE_U") +@ispec("32<[ c(4) 0110011 const9(9) a(4) {8b} ]", mnemonic="XOR_LT_U") +@ispec("32<[ c(4) 0011011 const9(9) a(4) {8b} ]", mnemonic="MAX_U") +@ispec("32<[ c(4) 0010011 const9(9) a(4) {8b} ]", mnemonic="LT_U") +def tricore_ddc_arithmetic(obj, c, const9, a): + src1 = env.D[a] + src2 = env.cst(const9,32) + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) a(4) {c2} ]", mnemonic="ADD") +@ispec("16<[ ~const4(4) a(4) {06} ]", mnemonic="SH") +@ispec("16<[ ~const4(4) a(4) {86} ]", mnemonic="SHA") +def tricore_ddc_arithmetic(obj, const4, a): + dst = env.D[a] + src2 = env.cst(const4.int(-1),32) + src1 = env.D[a] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) a(4) {92} ]", mnemonic="ADD") +@ispec("16<[ ~const4(4) a(4) {8a} ]", mnemonic="CADD") +@ispec("16<[ ~const4(4) a(4) {ca} ]", mnemonic="CADDN") +@ispec("16<[ ~const4(4) a(4) {aa} ]", mnemonic="CMOV") +@ispec("16<[ ~const4(4) a(4) {ea} ]", mnemonic="CMOVN") +def tricore_ddc_arithmetic(obj, const4, a): + dst = env.D[a] + src2 = env.cst(const4.int(-1),32) + src1 = env.D[15] + obj.operands = [dst, src1, src2] + if "CADD" in obj.mnemonic: + obj.operands = [dst, src1, dst, src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) a(4) {9a} ]", mnemonic="ADD") +@ispec("16<[ ~const4(4) a(4) {ba} ]", mnemonic="EQ") +@ispec("16<[ ~const4(4) a(4) {fa} ]", mnemonic="LT") +@ispec("16<[ ~const4(4) a(4) {82} ]", mnemonic="MOV") +def tricore_ddc_arithmetic(obj, const4, a): + dst = env.D[15] + src2 = env.cst(const4.int(-1),32) + src1 = env.D[a] + obj.operands = [dst, src1, src2] + if obj.mnemonic=="MOV": + obj.operands = [src1,src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) a(4) {d2} ]", mnemonic="MOV") +def tricore_ec_arithmetic(obj, const4, a): + dst = env.E[a] + src = env.cst(const4.int(-1),64) + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("16<[ const4(4) a(4) {a0} ]", mnemonic="MOV_A") +def tricore_ec_arithmetic(obj, const4, a): + dst = env.A[a] + src = env.cst(const4,32) + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("16<[ const8(8) {16} ]", mnemonic="AND") +@ispec("16<[ const8(8) {da} ]", mnemonic="MOV") +@ispec("16<[ const8(8) {96} ]", mnemonic="OR") +def tricore_ddc_arithmetic(obj, const8): + dst = env.D[15] + src2 = env.cst(const8,32) + src1 = env.D[15] + obj.operands = [dst, src1, src2] + if obj.mnemonic=="MOV": + obj.operands = [src1,src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) {42} ]", mnemonic="ADD") +@ispec("16<[ b(4) a(4) {26} ]", mnemonic="AND") +@ispec("16<[ b(4) a(4) {a6} ]", mnemonic="OR") +@ispec("16<[ b(4) a(4) {a2} ]", mnemonic="SUB") +@ispec("16<[ b(4) a(4) {62} ]", mnemonic="SUBS") +@ispec("16<[ b(4) a(4) {c6} ]", mnemonic="XOR") +def tricore_dd_arithmetic(obj, b, a): + dst = env.D[a] + src1 = env.D[a] + src2 = env.D[b] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) {02} ]", mnemonic="MOV" , _dst=env.D, _src=env.D) +@ispec("16<[ b(4) a(4) {60} ]", mnemonic="MOV_A" , _dst=env.A, _src=env.D) +@ispec("16<[ b(4) a(4) {40} ]", mnemonic="MOV_AA" , _dst=env.A, _src=env.A) +@ispec("16<[ b(4) a(4) {80} ]", mnemonic="MOV_D" , _dst=env.D, _src=env.A) +def tricore_mov(obj, b, a, _dst, _src): + dst = _dst[a] + src = _src[b] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) {12} ]", mnemonic="ADD") +@ispec("16<[ b(4) a(4) {2a} ]", mnemonic="CMOV") +@ispec("16<[ b(4) a(4) {6a} ]", mnemonic="CMOVN") +@ispec("16<[ b(4) a(4) {52} ]", mnemonic="SUB") +def tricore_dd_arithmetic(obj, b, a): + dst = env.D[a] + src1 = env.D[15] + src2 = env.D[b] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) {1a} ]", mnemonic="ADD") +@ispec("16<[ b(4) a(4) {22} ]", mnemonic="ADDS") +@ispec("16<[ b(4) a(4) {3a} ]", mnemonic="EQ") +@ispec("16<[ b(4) a(4) {7a} ]", mnemonic="LT") +@ispec("16<[ b(4) a(4) {5a} ]", mnemonic="SUB") +def tricore_dd_arithmetic(obj, b, a): + dst = env.D[15] + src1 = env.D[a] + src2 = env.D[b] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {01} ---- b(4) a(4) {01} ]", mnemonic="ADD_A") +@ispec("32<[ c(4) {02} ---- b(4) a(4) {01} ]", mnemonic="SUB_A") +def tricore_aaa_arithmetic(obj, c, b, a): + src1 = env.A[a] + src2 = env.A[b] + dst = env.A[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) a(4) {b0} ]", mnemonic="ADD_A") +def tricore_aac_arithmetic(obj, const4, a): + dst = env.A[a] + src2 = env.cst(const4.int(-1),32) + src1 = env.A[a] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ const8(8) {20} ]", mnemonic="SUB_A") +def tricore_aac_arithmetic(obj, const8, a): + dst = env.A[10] + src2 = env.cst(const8,32) + src1 = env.A[10] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) {30} ]", mnemonic="ADD_A") +def tricore_aa_arithmetic(obj, b, a): + dst = env.A[a] + src1 = env.A[a] + src2 = env.A[b] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) ~const16(16) a(4) {1b} ]", mnemonic="ADDI") +@ispec("32<[ c(4) ~const16(16) a(4) {9b} ]", mnemonic="ADDIH") +def tricore_di_arithmetic(obj, c, const16, a): + src1 = env.D[a] + src2 = env.cst(const16.int(-1),32) + if self.mnemonic=="ADDIH": src2=src2<<16 + dst = env.D[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) ~const16(16) a(4) {11} ]", mnemonic="ADDIH_A") +def tricore_ai_arithmetic(obj, c, const16, a): + src1 = env.A[a] + src2 = env.cst(const16.int(-1),32)<<16 + dst = env.A[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {60} -- n(2) b(4) a(4) {01} ]", mnemonic="ADDSC_A") +def tricore_aaa_arithmetic(obj, c, n, b, a): + src1 = env.D[a] + src2 = env.A[b] + dst = env.A[c] + obj.operands = [dst, src2, src1, env.cst(n,2)] + obj.type = type_data_processing + +@ispec("32<[ c(4) {62} ---- b(4) a(4) {01} ]", mnemonic="ADDSC_AT") +def tricore_aaa_arithmetic(obj, c, b, a): + src1 = env.D[a] + src2 = env.A[b] + dst = env.A[c] + obj.operands = [dst, src2, src1] + obj.type = type_data_processing + +@ispec("16<[ b(4) a(4) n(2) 010000 ]", mnemonic="ADDSC_A") +def tricore_aa_arithmetic(obj, b, a, n): + dst = env.A[a] + src1 = env.D[15] + src2 = env.A[b] + obj.operands = [dst, src2, src1, env.cst(n,2)] + obj.type = type_data_processing + +@ispec("32<[ off2(4) 10 1110 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_I", mode="Short-offset") +@ispec("32<[ off2(4) 00 1110 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_I", mode="Bit-reverse") +@ispec("32<[ off2(4) 01 1110 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_I", mode="Circular") +@ispec("32<[ off2(4) 00 1110 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_I", mode="Post-increment") +@ispec("32<[ off2(4) 01 1110 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_I", mode="Pre-increment") +@ispec("32<[ off2(4) 10 1100 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_W", mode="Short-offset") +@ispec("32<[ off2(4) 00 1100 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_W", mode="Bit-reverse") +@ispec("32<[ off2(4) 01 1100 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_W", mode="Circular") +@ispec("32<[ off2(4) 00 1100 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_W", mode="Post-increment") +@ispec("32<[ off2(4) 01 1100 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_W", mode="Pre-increment") +@ispec("32<[ off2(4) 10 1101 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_WI", mode="Short-offset") +@ispec("32<[ off2(4) 00 1101 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_WI", mode="Bit-reverse") +@ispec("32<[ off2(4) 01 1101 off1(6) b(4) ---- {a9} ]", mnemonic="CACHEA_WI", mode="Circular") +@ispec("32<[ off2(4) 00 1101 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_WI", mode="Post-increment") +@ispec("32<[ off2(4) 01 1101 off1(6) b(4) ---- {89} ]", mnemonic="CACHEA_WI", mode="Pre-increment") +@ispec("32<[ off2(4) 10 1011 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_W", mode="Short-offset") +@ispec("32<[ off2(4) 00 1011 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_W", mode="Post-increment") +@ispec("32<[ off2(4) 01 1011 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_W", mode="Pre-increment") +@ispec("32<[ off2(4) 10 1010 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_I", mode="Short-offset") +@ispec("32<[ off2(4) 00 1010 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_I", mode="Post-increment") +@ispec("32<[ off2(4) 01 1010 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_I", mode="Pre-increment") +@ispec("32<[ off2(4) 10 1111 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_WI", mode="Short-offset") +@ispec("32<[ off2(4) 00 1111 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_WI", mode="Post-increment") +@ispec("32<[ off2(4) 01 1111 off1(6) b(4) ---- {89} ]", mnemonic="CACHEI_WI", mode="Pre-increment") +def tricore_cache(obj, off2, off1, b): + src2 = env.A[b] + src1 = env.cst((off2<<6)+off1,10) + obj.operands = [src2, src1] + obj.type = type_system + +@ispec("32<[ off2(4) 10 0011 off1(6) b(4) a(4) {49} ]", mnemonic="CMPSWAP_W", mode="Short-offset") +@ispec("32<[ off2(4) 00 0011 off1(6) b(4) a(4) {69} ]", mnemonic="CMPSWAP_W", mode="Bit-reverse") +@ispec("32<[ off2(4) 01 0011 off1(6) b(4) a(4) {69} ]", mnemonic="CMPSWAP_W", mode="Circular") +@ispec("32<[ off2(4) 00 0011 off1(6) b(4) a(4) {49} ]", mnemonic="CMPSWAP_W", mode="Post-increment") +@ispec("32<[ off2(4) 01 0011 off1(6) b(4) a(4) {49} ]", mnemonic="CMPSWAP_W", mode="Pre-increment") +@ispec("32<[ off2(4) 10 0010 off1(6) b(4) a(4) {49} ]", mnemonic="SWAPMSK_W", mode="Short-offset") +@ispec("32<[ off2(4) 00 0010 off1(6) b(4) a(4) {69} ]", mnemonic="SWAPMSK_W", mode="Bit-reverse") +@ispec("32<[ off2(4) 01 0010 off1(6) b(4) a(4) {69} ]", mnemonic="SWAPMSK_W", mode="Circular") +@ispec("32<[ off2(4) 00 0010 off1(6) b(4) a(4) {49} ]", mnemonic="SWAPMSK_W", mode="Post-increment") +@ispec("32<[ off2(4) 01 0010 off1(6) b(4) a(4) {49} ]", mnemonic="SWAPMSK_W", mode="Pre-increment") +def tricore_swap(obj, off2, off1, b, a): + if a%2: + raise InstructionError(obj) + dst = env.D[a] + src1 = env.A[b] + src2 = env.cst((off2<<6)+off1,10) + src3 = env.E[a] + obj.operands = [dst, src1, src2, src3] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 000 ~const9(9) a(4) {ab} ]", mnemonic="CADD") +@ispec("32<[ c(4) d(4) 001 ~const9(9) a(4) {ab} ]", mnemonic="CADDN") +@ispec("32<[ c(4) d(4) 001 ~const9(9) a(4) {13} ]", mnemonic="MADD", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 101 ~const9(9) a(4) {13} ]", mnemonic="MADDS", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 100 ~const9(9) a(4) {13} ]", mnemonic="MADDS_U", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 001 ~const9(9) a(4) {33} ]", mnemonic="MSUB", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 101 ~const9(9) a(4) {33} ]", mnemonic="MSUBS", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 100 ~const9(9) a(4) {33} ]", mnemonic="MSUBS_U", opt4="32+(32+K9)->32") +@ispec("32<[ c(4) d(4) 100 ~const9(9) a(4) {ab} ]", mnemonic="SEL") +@ispec("32<[ c(4) d(4) 101 ~const9(9) a(4) {ab} ]", mnemonic="SELN") +def tricore_cond_ddc(obj, c, d, const9, a): + cond = env.D[d] + src1 = env.D[a] + src2 = env.cst(const9.int(-1),32) + dst = env.D[c] + obj.operands = [dst, cond, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 011 ~const9(9) a(4) {13} ]", mnemonic="MADD", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 111 ~const9(9) a(4) {13} ]", mnemonic="MADDS", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 010 ~const9(9) a(4) {13} ]", mnemonic="MADD_U", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 111 ~const9(9) a(4) {13} ]", mnemonic="MADDS_U", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 011 ~const9(9) a(4) {33} ]", mnemonic="MSUB", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 111 ~const9(9) a(4) {33} ]", mnemonic="MSUBS", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 010 ~const9(9) a(4) {33} ]", mnemonic="MSUB_U", opt4="64+(32+K9)->64") +@ispec("32<[ c(4) d(4) 111 ~const9(9) a(4) {33} ]", mnemonic="MSUBS_U", opt4="64+(32+K9)->64") +def tricore_cond_eec(obj, c, d, const9, a): + cond = env.E[d] + src1 = env.D[a] + src2 = env.cst(const9.int(-1),32) + dst = env.E[c] + obj.operands = [dst, cond, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 011010 n(2) b(4) a(4) {83} ]", mnemonic="MADD_H", op4="LL") +@ispec("32<[ c(4) d(4) 011001 n(2) b(4) a(4) {83} ]", mnemonic="MADD_H", op4="LU") +@ispec("32<[ c(4) d(4) 011000 n(2) b(4) a(4) {83} ]", mnemonic="MADD_H", op4="UL") +@ispec("32<[ c(4) d(4) 011011 n(2) b(4) a(4) {83} ]", mnemonic="MADD_H", op4="UU") +@ispec("32<[ c(4) d(4) 111010 n(2) b(4) a(4) {83} ]", mnemonic="MADDS_H", op4="LL") +@ispec("32<[ c(4) d(4) 111001 n(2) b(4) a(4) {83} ]", mnemonic="MADDS_H", op4="LU") +@ispec("32<[ c(4) d(4) 111000 n(2) b(4) a(4) {83} ]", mnemonic="MADDS_H", op4="UL") +@ispec("32<[ c(4) d(4) 111011 n(2) b(4) a(4) {83} ]", mnemonic="MADDS_H", op4="UU") +@ispec("32<[ c(4) d(4) 000010 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="32+(32*32)Up->32") +@ispec("32<[ c(4) d(4) 011011 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) 000001 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="32+(16L*32)Up->32") +@ispec("32<[ c(4) d(4) 011001 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="64+(16L*32)->64") +@ispec("32<[ c(4) d(4) 000000 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="32+(16U*32)Up->32") +@ispec("32<[ c(4) d(4) 011000 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="64+(16U*32)->64") +@ispec("32<[ c(4) d(4) 000101 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="32+(16L*16L)->32") +@ispec("32<[ c(4) d(4) 011101 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="64+(16L*16L)->64") +@ispec("32<[ c(4) d(4) 000100 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="32+(16U*16U)->32") +@ispec("32<[ c(4) d(4) 011100 n(2) b(4) a(4) {43} ]", mnemonic="MADD_Q", op4="64+(16U*16U)->64") +@ispec("32<[ c(4) d(4) 100010 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="32+(32*32)Up->32") +@ispec("32<[ c(4) d(4) 111011 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) 100001 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="32+(16L*32)Up->32") +@ispec("32<[ c(4) d(4) 111001 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="64+(16L*32)->64") +@ispec("32<[ c(4) d(4) 100000 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="32+(16U*32)Up->32") +@ispec("32<[ c(4) d(4) 111000 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="64+(16U*32)->64") +@ispec("32<[ c(4) d(4) 100101 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="32+(16L*16L)->32") +@ispec("32<[ c(4) d(4) 111101 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="64+(16L*16L)->64") +@ispec("32<[ c(4) d(4) 100100 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="32+(16U*16U)->32") +@ispec("32<[ c(4) d(4) 111100 n(2) b(4) a(4) {43} ]", mnemonic="MADDS_Q", op4="64+(16U*16U)->64") +@ispec("32<[ c(4) d(4) 011010 n(2) b(4) a(4) {a3} ]", mnemonic="MSUB_H", op4="LL") +@ispec("32<[ c(4) d(4) 011001 n(2) b(4) a(4) {a3} ]", mnemonic="MSUB_H", op4="LU") +@ispec("32<[ c(4) d(4) 011000 n(2) b(4) a(4) {a3} ]", mnemonic="MSUB_H", op4="UL") +@ispec("32<[ c(4) d(4) 011011 n(2) b(4) a(4) {a3} ]", mnemonic="MSUB_H", op4="UU") +@ispec("32<[ c(4) d(4) 111010 n(2) b(4) a(4) {a3} ]", mnemonic="MSUBS_H", op4="LL") +@ispec("32<[ c(4) d(4) 111001 n(2) b(4) a(4) {a3} ]", mnemonic="MSUBS_H", op4="LU") +@ispec("32<[ c(4) d(4) 111000 n(2) b(4) a(4) {a3} ]", mnemonic="MSUBS_H", op4="UL") +@ispec("32<[ c(4) d(4) 111011 n(2) b(4) a(4) {a3} ]", mnemonic="MSUBS_H", op4="UU") +@ispec("32<[ c(4) d(4) 000010 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="32+(32*32)Up->32") +@ispec("32<[ c(4) d(4) 011011 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) 000001 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="32+(16L*32)Up->32") +@ispec("32<[ c(4) d(4) 011001 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="64+(16L*32)->64") +@ispec("32<[ c(4) d(4) 000000 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="32+(16U*32)Up->32") +@ispec("32<[ c(4) d(4) 011000 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="64+(16U*32)->64") +@ispec("32<[ c(4) d(4) 000101 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="32+(16L*16L)->32") +@ispec("32<[ c(4) d(4) 011101 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="64+(16L*16L)->64") +@ispec("32<[ c(4) d(4) 000100 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="32+(16U*16U)->32") +@ispec("32<[ c(4) d(4) 011100 n(2) b(4) a(4) {63} ]", mnemonic="MSUB_Q", op4="64+(16U*16U)->64") +@ispec("32<[ c(4) d(4) 100010 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="32+(32*32)Up->32") +@ispec("32<[ c(4) d(4) 111011 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) 100001 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="32+(16L*32)Up->32") +@ispec("32<[ c(4) d(4) 111001 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="64+(16L*32)->64") +@ispec("32<[ c(4) d(4) 100000 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="32+(16U*32)Up->32") +@ispec("32<[ c(4) d(4) 111000 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="64+(16U*32)->64") +@ispec("32<[ c(4) d(4) 100101 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="32+(16L*16L)->32") +@ispec("32<[ c(4) d(4) 111101 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="64+(16L*16L)->64") +@ispec("32<[ c(4) d(4) 100100 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="32+(16U*16U)->32") +@ispec("32<[ c(4) d(4) 111100 n(2) b(4) a(4) {63} ]", mnemonic="MSUBS_Q", op4="64+(16U*16U)->64") +def tricore_cond_eec(obj, c, d, n, b, a): + cond = env.E[d] + src1 = env.D[a] + src2 = env.D[b] + dst = env.E[c] + obj.operands = [dst, cond, src1, src2, env.cst(n,2)] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) 0000 ---- b(4) a(4) {2b} ]", mnemonic="CADD") +@ispec("32<[ c(4) d(4) 0001 ---- b(4) a(4) {2b} ]", mnemonic="CADDN") +@ispec("32<[ c(4) d(4) 0010 ---- b(4) a(4) {2b} ]", mnemonic="CSUB") +@ispec("32<[ c(4) d(4) 0011 ---- b(4) a(4) {2b} ]", mnemonic="CSUBN") +@ispec("32<[ c(4) d(4) {0a} b(4) a(4) {03} ]", mnemonic="MADD", opt4="32+(32*32)->32") +@ispec("32<[ c(4) d(4) {8a} b(4) a(4) {03} ]", mnemonic="MADDS", opt4="32+(32*32)->32") +@ispec("32<[ c(4) d(4) {88} b(4) a(4) {03} ]", mnemonic="MADDS_U", opt4="32+(32*32)->32") +@ispec("32<[ c(4) d(4) 0100 ---- b(4) a(4) {2b} ]", mnemonic="SEL") +@ispec("32<[ c(4) d(4) 0101 ---- b(4) a(4) {2b} ]", mnemonic="SELN") +def tricore_cond_ddd(obj, c, d, b, a): + cond = env.D[d] + src1 = env.D[a] + src2 = env.D[b] + dst = env.D[c] + obj.operands = [dst, cond, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) d(4) {6a} b(4) a(4) {03} ]", mnemonic="MADD", opt4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) {ea} b(4) a(4) {03} ]", mnemonic="MADDS", opt4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) {68} b(4) a(4) {03} ]", mnemonic="MADD_U", opt4="64+(32*32)->64") +@ispec("32<[ c(4) d(4) {e8} b(4) a(4) {03} ]", mnemonic="MADDS_U", opt4="64+(32*32)->64") +def tricore_cond_ddd(obj, c, d, b, a): + cond = env.E[d] + src1 = env.D[a] + src2 = env.D[b] + dst = env.E[c] + obj.operands = [dst, cond, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ c(4) {1c} ---- ---- a(4) {0f} ]", mnemonic="CLO") +@ispec("32<[ c(4) {7d} ---- ---- a(4) {0f} ]", mnemonic="CLO_H") +@ispec("32<[ c(4) {1d} ---- ---- a(4) {0f} ]", mnemonic="CLS") +@ispec("32<[ c(4) {7e} ---- ---- a(4) {0f} ]", mnemonic="CLS_H") +@ispec("32<[ c(4) {1b} ---- ---- a(4) {0f} ]", mnemonic="CLZ") +@ispec("32<[ c(4) {7c} ---- ---- a(4) {0f} ]", mnemonic="CLZ_H") +@ispec("32<[ c(4) {5e} ---- ---- a(4) {0b} ]", mnemonic="SAT_B") +@ispec("32<[ c(4) {5f} ---- ---- a(4) {0b} ]", mnemonic="SAT_BU") +@ispec("32<[ c(4) {7e} ---- ---- a(4) {0b} ]", mnemonic="SAT_H") +@ispec("32<[ c(4) {7f} ---- ---- a(4) {0b} ]", mnemonic="SAT_HU") +def tricore_dd_arithmetic(obj, c, a): + src = env.D[a] + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("16<[ 1010 ---- {00} ]", mnemonic="DEBUG") +@ispec("16<[ 0000 ---- {00} ]", mnemonic="NOP") +def tricore_system(obj): + obj.operands = [] + obj.type = type_system + +@ispec("16<[ 0111 ---- {00} ]", mnemonic="FRET") +@ispec("16<[ 1001 ---- {00} ]", mnemonic="RET") +@ispec("16<[ 1000 ---- {00} ]", mnemonic="RFE") +def tricore_ret(obj): + obj.operands = [] + obj.type = type_control_flow + +@ispec("32<[ ---- 000100 ---------- ---- {0d} ]", mnemonic="DEBUG") +@ispec("32<[ ---- 001101 ---------- ---- {0d} ]", mnemonic="DISABLE") +@ispec("32<[ ---- 010010 ---------- ---- {0d} ]", mnemonic="DSYNC") +@ispec("32<[ ---- 001100 ---------- ---- {0d} ]", mnemonic="ENABLE") +@ispec("32<[ ---- 010011 ---------- ---- {0d} ]", mnemonic="ISYNC") +@ispec("32<[ ---- 010101 ---------- ---- {0d} ]", mnemonic="TRAPSV") +@ispec("32<[ ---- 010100 ---------- ---- {0d} ]", mnemonic="TRAPV") +@ispec("32<[ ---- 000000 ---------- ---- {0d} ]", mnemonic="NOP") +@ispec("32<[ ---- 001001 ---------- ---- {0d} ]", mnemonic="RSLCX") +@ispec("32<[ ---- 000000 ---------- ---- {2f} ]", mnemonic="RSTV") +@ispec("32<[ ---- 001000 ---------- ---- {0d} ]", mnemonic="SVLCX") +@ispec("32<[ ---- 010110 ---------- ---- {0d} ]", mnemonic="WAIT") +def tricore_system(obj): + obj.operands = [] + obj.type = type_system + +@ispec("32<[ ---- 000011 ---------- ---- {0d} ]", mnemonic="FRET") +@ispec("32<[ ---- 000110 ---------- ---- {0d} ]", mnemonic="RET") +@ispec("32<[ ---- 000111 ---------- ---- {0d} ]", mnemonic="RFE") +@ispec("32<[ ---- 000101 ---------- ---- {0d} ]", mnemonic="RFM") +def tricore_ret(obj): + obj.operands = [] + obj.type = type_control_flow + +@ispec("32<[ ---- 001111 ---------- a(4) {0d} ]", mnemonic="DISABLE") +@ispec("32<[ ---- 001110 ---------- a(4) {0d} ]", mnemonic="RESTORE") +def tricore_system(obj, a): + obj.operands = [env.D[a]] + obj.type = type_system + +@ispec("32<[ c(4) d(4) 1101 -- 00 b(4) ---- {6b} ]", mnemonic="DVADJ") +@ispec("32<[ c(4) d(4) 1111 -- 00 b(4) ---- {6b} ]", mnemonic="DVSTEP") +@ispec("32<[ c(4) d(4) 1110 -- 00 b(4) ---- {6b} ]", mnemonic="DVSTEP_U") +@ispec("32<[ c(4) d(4) 1010 -- 00 b(4) ---- {6b} ]", mnemonic="IXMAX") +@ispec("32<[ c(4) d(4) 1011 -- 00 b(4) ---- {6b} ]", mnemonic="IXMAX_U") +@ispec("32<[ c(4) d(4) 1000 -- 00 b(4) ---- {6b} ]", mnemonic="IXMIN") +@ispec("32<[ c(4) d(4) 1001 -- 00 b(4) ---- {6b} ]", mnemonic="IXMIN_U") +def tricore_eee(obj, c, d, b): + if d%2 or b%2 or c%2: + raise InstructionError(obj) + src1 = env.E[d] + src2 = env.E[b] + dst = env.E[c] + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ ~const4(4) disp(4) {1e} ]", mnemonic="JEQ", _off=0) +@ispec("16<[ ~const4(4) disp(4) {9e} ]", mnemonic="JEQ", _off=16) +@ispec("16<[ ~const4(4) disp(4) {5e} ]", mnemonic="JNE", _off=0) +@ispec("16<[ ~const4(4) disp(4) {de} ]", mnemonic="JNE", _off=16) +def tricore_jcc(obj, const4, disp, _off): + dst = env.D[15] + src1 = env.cst(const4.int(-1),32) + src2 = env.cst(disp,32)+_off + obj.operands = [dst, src1, src2] + obj.type = type_control_flow + +@ispec("16<[ b(4) disp(4) {3e} ]", mnemonic="JEQ", _off=0) +@ispec("16<[ b(4) disp(4) {be} ]", mnemonic="JEQ", _off=16) +@ispec("16<[ b(4) disp(4) {7e} ]", mnemonic="JNE", _off=0) +@ispec("16<[ b(4) disp(4) {fe} ]", mnemonic="JNE", _off=16) +def tricore_jcc(obj, b, disp, _off): + dst = env.D[15] + src1 = env.D[b] + src2 = env.cst(disp,32)+_off + obj.operands = [dst, src1, src2] + obj.type = type_control_flow + +@ispec("16<[ b(4) disp(4) {ce} ]", mnemonic="JGEZ") +@ispec("16<[ b(4) disp(4) {4e} ]", mnemonic="JGTZ") +@ispec("16<[ b(4) disp(4) {8e} ]", mnemonic="JLEZ") +@ispec("16<[ b(4) disp(4) {0e} ]", mnemonic="JLTZ") +@ispec("16<[ b(4) disp(4) {f6} ]", mnemonic="JNZ") +@ispec("16<[ b(4) disp(4) {76} ]", mnemonic="JZ") +def tricore_jcc(obj, b, disp): + src1 = env.D[b] + src2 = env.cst(disp,32) + obj.operands = [src1, src2] + obj.type = type_control_flow + +@ispec("32<[ 0 ~disp(15) const(4) a(4) {df} ]", mnemonic="JEQ") +@ispec("32<[ 1 ~disp(15) const(4) a(4) {df} ]", mnemonic="JNE") +@ispec("32<[ 0 ~disp(15) const(4) a(4) {ff} ]", mnemonic="JGE") +@ispec("32<[ 1 ~disp(15) const(4) a(4) {ff} ]", mnemonic="JGE_U") +@ispec("32<[ 0 ~disp(15) const(4) a(4) {bf} ]", mnemonic="JLT") +@ispec("32<[ 1 ~disp(15) const(4) a(4) {bf} ]", mnemonic="JLT_U") +@ispec("32<[ 1 ~disp(15) const(4) a(4) {9f} ]", mnemonic="JNED") +@ispec("32<[ 0 ~disp(15) const(4) a(4) {9f} ]", mnemonic="JNEI") +def tricore_jcc(obj, disp, const, a): + src1 = env.D[a] + src2 = env.cst(const,4) + obj.operands = [src1, src2, env.cst(disp.int(-1),32)] + obj.type = type_control_flow + +@ispec("32<[ 0 ~disp(15) b(4) a(4) {5f} ]", mnemonic="JEQ") +@ispec("32<[ 1 ~disp(15) b(4) a(4) {5f} ]", mnemonic="JNE") +@ispec("32<[ 0 ~disp(15) b(4) a(4) {7f} ]", mnemonic="JGE") +@ispec("32<[ 1 ~disp(15) b(4) a(4) {7f} ]", mnemonic="JGE_U") +@ispec("32<[ 0 ~disp(15) b(4) a(4) {3f} ]", mnemonic="JLT") +@ispec("32<[ 1 ~disp(15) b(4) a(4) {3f} ]", mnemonic="JLT_U") +@ispec("32<[ 1 ~disp(15) b(4) a(4) {1f} ]", mnemonic="JNED") +@ispec("32<[ 0 ~disp(15) b(4) a(4) {1f} ]", mnemonic="JNEI") +def tricore_jcc(obj, disp, b, a): + src1 = env.D[a] + src2 = env.D[b] + obj.operands = [src1, src2, env.cst(disp.int(-1),32)] + obj.type = type_control_flow + +@ispec("32<[ 0 ~disp(15) b(4) a(4) {7d} ]", mnemonic="JEQ_A") +@ispec("32<[ 1 ~disp(15) b(4) a(4) {7d} ]", mnemonic="JNE_A") +def tricore_jcc(obj, disp, b, a): + src1 = env.A[a] + src2 = env.A[b] + obj.operands = [src1, src2, env.cst(disp.int(-1),32)] + obj.type = type_control_flow + +@ispec("32<[ 1 ~disp(15) ---- a(4) {bd} ]", mnemonic="JNZ_A") +@ispec("32<[ 0 ~disp(15) ---- a(4) {bd} ]", mnemonic="JZ_A") +def tricore_jcc(obj, disp, a): + src1 = env.A[a] + src2 = env.A[b] + obj.operands = [src1, src2, env.cst(disp.int(-1),32)] + obj.type = type_control_flow + +@ispec("32<[ 0 ~disp(15) b(4) ---- {fd} ]", mnemonic="LOOP") +@ispec("32<[ 1 ~disp(15) b(4) ---- {fd} ]", mnemonic="LOOPU") +def tricore_jcc(obj, disp, b): + src1 = env.A[b] + src2 = env.cst(disp.int(-1)*2,32) + obj.operands = [src1, src2] + if obj.mnemonic=="LOOPU": + obj.operands = [src2] + obj.type = type_control_flow + +@ispec("16<[ b(4) disp(4) {7c} ]", mnemonic="JNZ_A") +@ispec("16<[ b(4) disp(4) {bc} ]", mnemonic="JZ_A") +def tricore_jcc(obj, b, disp): + src1 = env.A[b] + src2 = env.cst(disp,32) + obj.operands = [src1, src2] + obj.type = type_control_flow + +@ispec("16<[ b(4) #disp(4) {fc} ]", mnemonic="LOOP") +def tricore_jcc(obj, b, disp): + src1 = env.A[b] + src2 = env.cst(int(("1"*27)+disp+"0",2),32) + obj.operands = [src1, src2] + obj.type = type_control_flow + +@ispec("16<[ 0000 a(4) {dc} ]", mnemonic="JI") +def tricore_ji(obj, a): + src = env.A[a] + obj.operands = [src] + obj.type = type_control_flow + +@ispec("16<[ 0000 a(4) {46} ]", mnemonic="NOT") +@ispec("16<[ 0101 a(4) {32} ]", mnemonic="RSUB") +@ispec("16<[ 0000 a(4) {32} ]", mnemonic="SAT_B") +@ispec("16<[ 0001 a(4) {32} ]", mnemonic="SAT_BU") +@ispec("16<[ 0010 a(4) {32} ]", mnemonic="SAT_H") +@ispec("16<[ 0011 a(4) {32} ]", mnemonic="SAT_HU") +def tricore_a(obj, a): + src = env.D[a] + obj.operands = [src] + obj.type = type_data_processing + +@ispec("16<[ n(4) disp(4) {ae} ]", mnemonic="JNZ_T") +@ispec("16<[ n(4) disp(4) {2e} ]", mnemonic="JZ_T") +def tricore_ji(obj, n, disp): + obj.operands = [env.D[15][n:n+1], env.cst(disp,32)] + obj.type = type_control_flow + +@ispec("32<[ 1 ~disp(15) n(4) a(4) h 1101111 ]", mnemonic="JNZ_T") +@ispec("32<[ 0 ~disp(15) n(4) a(4) h 1101111 ]", mnemonic="JZ_T") +def tricore_jcc(obj, disp, n, a, h): + i = n+(h<<4) + src = env.D[a][i:i+1] + obj.operands = [src, env.cst(disp.int(-1),32)] + obj.type = type_control_flow + +@ispec("32<[ ~off2(4) 10 ~off3(4) ~off1(6) ~off4(4) a(4) {85} ]", mnemonic="LD_A", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {05} ]", mnemonic="LD_B", mode="Absolute") +@ispec("32<[ ~off2(4) 01 ~off3(4) ~off1(6) ~off4(4) a(4) {05} ]", mnemonic="LD_BU", mode="Absolute") +@ispec("32<[ ~off2(4) 01 ~off3(4) ~off1(6) ~off4(4) a(4) {85} ]", mnemonic="LD_D", mode="Absolute") +@ispec("32<[ ~off2(4) 11 ~off3(4) ~off1(6) ~off4(4) a(4) {85} ]", mnemonic="LD_DA", mode="Absolute") +@ispec("32<[ ~off2(4) 10 ~off3(4) ~off1(6) ~off4(4) a(4) {05} ]", mnemonic="LD_H", mode="Absolute") +@ispec("32<[ ~off2(4) 11 ~off3(4) ~off1(6) ~off4(4) a(4) {05} ]", mnemonic="LD_HU", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {45} ]", mnemonic="LD_Q", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {85} ]", mnemonic="LD_W", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {c5} ]", mnemonic="LEA", mode="Absolute") +def tricore_ld(obj, off2, off3, off1, off4, a): + dst = env.D[a] + if obj.mnemonic in ("LD_A", "LEA") : dst = env.A[a] + if obj.mnemonic in ("LD_D","LDMST") : dst = env.E[a] + if obj.mnemonic=="LD_DA": dst = env.P[a] + src = off1//off2//off3 + obj.operands = [dst, composer([env.cst(src.int(),28),env.cst(off4,4)])] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 01 ~off3(4) ~off1(6) ~off4(4) a(4) {c5} ]", mnemonic="LHA", mode="Absolute") +def tricore_ld(obj, off2, off3, off1, off4, a): + dst = env.A[a] + src = off1//off2//off3//off4 + obj.operands = [dst, composer([env.cst(0,14),env.cst(src.int(),18)])] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 10 ~off3(4) ~off1(6) ~off4(4) a(4) {a5} ]", mnemonic="ST_A", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {25} ]", mnemonic="ST_B", mode="Absolute") +@ispec("32<[ ~off2(4) 01 ~off3(4) ~off1(6) ~off4(4) a(4) {a5} ]", mnemonic="ST_D", mode="Absolute") +@ispec("32<[ ~off2(4) 11 ~off3(4) ~off1(6) ~off4(4) a(4) {a5} ]", mnemonic="ST_DA", mode="Absolute") +@ispec("32<[ ~off2(4) 10 ~off3(4) ~off1(6) ~off4(4) a(4) {25} ]", mnemonic="ST_H", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {65} ]", mnemonic="ST_Q", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {a5} ]", mnemonic="ST_W", mode="Absolute") +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) a(4) {e5} ]", mnemonic="SWAP_W", mode="Absolute") +@ispec("32<[ ~off2(4) 01 ~off3(4) ~off1(6) ~off4(4) a(4) {e5} ]", mnemonic="LDMST", mode="Absolute") +def tricore_st(obj, off2, off3, off1, off4, a): + src = env.D[a] + if obj.mnemonic in ("ST_A",) : src = env.A[a] + if obj.mnemonic in ("ST_D","LDMST") : src = env.E[a] + if obj.mnemonic=="ST_DA": src = env.P[a] + addr = off1//off2//off3 + obj.operands = [composer([env.cst(addr.int(),28),env.cst(off4,4)]), src] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) b bpos(3) {d5} ]", mnemonic="ST_T", mode="Absolute") +def tricore_st(obj, off2, off3, off1, off4, b, bpos): + obj.operands = [composer([env.cst(src.int(),28),env.cst(off4,4)]), env.cst(bpos,3), env.cst(b,1)] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 00 ~off3(4) ~off1(6) ~off4(4) ---- {15} ]", mnemonic="STLCX", mode="Absolute") +def tricore_st(obj, off2, off3, off1, off4): + obj.operands = [composer([env.cst(src.int(),28),env.cst(off4,4)])] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 10 ~off3(4) ~off1(6) ~off4(4) a(4) {15} ]", mnemonic="LDLCX", mode="Absolute") +@ispec("32<[ ~off2(4) 11 ~off3(4) ~off1(6) ~off4(4) a(4) {15} ]", mnemonic="LDUCX", mode="Absolute") +def tricore_ld(obj, off2, off3, off1, off4, a): + src = off1//off2//off3 + obj.operands = [composer([env.cst(src.int(),28),env.cst(off4,4)])] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 10 0110 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_A", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0110 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_A", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0110 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_A", mode="Circular") +@ispec("32<[ ~off2(4) 00 0110 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_A", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0110 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_A", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_B", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0000 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_B", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0000 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_B", mode="Circular") +@ispec("32<[ ~off2(4) 00 0000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_B", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_B", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0001 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_BU", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0001 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_BU", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0001 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_BU", mode="Circular") +@ispec("32<[ ~off2(4) 00 0001 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_BU", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0001 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_BU", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0101 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_D", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0101 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_D", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0101 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_D", mode="Circular") +@ispec("32<[ ~off2(4) 00 0101 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_D", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0101 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_D", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0111 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_DA", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0111 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_DA", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0111 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_DA", mode="Circular") +@ispec("32<[ ~off2(4) 00 0111 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_DA", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0111 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_DA", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0010 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_H", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0010 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_H", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0010 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_H", mode="Circular") +@ispec("32<[ ~off2(4) 00 0010 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_H", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0010 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_H", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0011 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_HU", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0011 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_HU", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0011 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_HU", mode="Circular") +@ispec("32<[ ~off2(4) 00 0011 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_HU", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0011 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_HU", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 1000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_Q", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_Q", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_Q", mode="Circular") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_Q", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_Q", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0100 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_W", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0100 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_W", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0100 ~off1(6) b(4) a(4) {29} ]", mnemonic="LD_W", mode="Circular") +@ispec("32<[ ~off2(4) 00 0100 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_W", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0100 ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_W", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 1000 ~off1(6) b(4) a(4) {49} ]", mnemonic="LEA", mode="Short-offset") +def tricore_ld(obj, off2, off1, b, a): + dst = env.D[a] + if obj.mnemonic=="LD_A" : dst = env.A[a] + elif obj.mnemonic=="LEA" : dst = env.A[a] + elif obj.mnemonic=="LD_D" : dst = env.E[a] + elif obj.mnemonic=="LDMST" : dst = env.E[a] + elif obj.mnemonic=="LD_DA" : dst = env.P[a] + obj.b = b + src1 = env.A[b] + off10 = off1//off2 + src2 = env.cst(off10.int(-1),10) + obj.operands = [dst, src1, src2] + if obj.mode == "Bit-Reverse": + obj.operands.pop() + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 10 0110 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_A", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0110 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_A", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0110 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_A", mode="Circular") +@ispec("32<[ ~off2(4) 00 0110 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_A", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0110 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_A", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_B", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0000 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_B", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0000 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_B", mode="Circular") +@ispec("32<[ ~off2(4) 00 0000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_B", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_B", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0101 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_D", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0101 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_D", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0101 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_D", mode="Circular") +@ispec("32<[ ~off2(4) 00 0101 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_D", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0101 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_D", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0111 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_DA", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0111 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_DA", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0111 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_DA", mode="Circular") +@ispec("32<[ ~off2(4) 00 0111 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_DA", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0111 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_DA", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0010 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_H", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0010 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_H", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0010 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_H", mode="Circular") +@ispec("32<[ ~off2(4) 00 0010 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_H", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0010 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_H", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 1000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_Q", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_Q", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_Q", mode="Circular") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_Q", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_Q", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0100 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_W", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0100 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_W", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0100 ~off1(6) b(4) a(4) {a9} ]", mnemonic="ST_W", mode="Circular") +@ispec("32<[ ~off2(4) 00 0100 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_W", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0100 ~off1(6) b(4) a(4) {89} ]", mnemonic="ST_W", mode="Pre-increment") +@ispec("32<[ ~off2(4) 10 0001 ~off1(6) b(4) a(4) {49} ]", mnemonic="LDMST", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 0001 ~off1(6) b(4) a(4) {69} ]", mnemonic="LDMST", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 0001 ~off1(6) b(4) a(4) {69} ]", mnemonic="LDMST", mode="Circular") +@ispec("32<[ ~off2(4) 00 0001 ~off1(6) b(4) a(4) {49} ]", mnemonic="LDMST", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 0001 ~off1(6) b(4) a(4) {49} ]", mnemonic="LDMST", mode="Pre-increment") +def tricore_st(obj, off2, off1, b, a): + dst = env.D[a] + if obj.mnemonic=="ST_A" : dst = env.A[a] + elif obj.mnemonic=="ST_D" : dst = env.E[a] + elif obj.mnemonic=="ST_DA" : dst = env.P[a] + elif obj.mnemonic=="LDMST" : dst = env.E[a] + obj.b = b + src1 = env.A[b] + off10 = off1//off2 + src2 = env.cst(off10.int(-1),10) + obj.operands = [src1, src2, dst] + if obj.mode == "Bit-Reverse": + obj.operands.pop() + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) 10 1000 ~off1(6) b(4) a(4) {49} ]", mnemonic="SWAP_W", mode="Short-offset") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {69} ]", mnemonic="SWAP_W", mode="Bit-reverse") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {69} ]", mnemonic="SWAP_W", mode="Circular") +@ispec("32<[ ~off2(4) 00 1000 ~off1(6) b(4) a(4) {49} ]", mnemonic="SWAP_W", mode="Post-increment") +@ispec("32<[ ~off2(4) 01 1000 ~off1(6) b(4) a(4) {49} ]", mnemonic="SWAP_W", mode="Pre-increment") +def tricore_ld(obj, off2, off1, b, a): + dst = env.D[a] + src1 = env.P[b] + off10 = off1//off2 + src2 = env.cst(off10.int(-1),10) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + + +@ispec("32<[ ~off2(4) 10 0100 ~off1(6) b(4) ---- {49} ]", mnemonic="LDLCX", mode="Short-offset") +@ispec("32<[ ~off2(4) 10 0101 ~off1(6) b(4) ---- {49} ]", mnemonic="LDUCX", mode="Short-offset") +@ispec("32<[ ~off2(4) 10 0110 ~off1(6) b(4) ---- {49} ]", mnemonic="STLCX", mode="Short-offset") +@ispec("32<[ ~off2(4) 10 0111 ~off1(6) b(4) ---- {49} ]", mnemonic="STUCX", mode="Short-offset") +def tricore_ld(obj, off2, off1, b): + src1 = env.A[b] + off10 = off1//off2 + src2 = env.cst(off10.int(-1),10) + obj.operands = [src1, src2] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {99} ]", mnemonic="LD_A", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {79} ]", mnemonic="LD_B", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {39} ]", mnemonic="LD_BU", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {09} ]", mnemonic="LD_H", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {b9} ]", mnemonic="LD_HU", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {19} ]", mnemonic="LD_W", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {d9} ]", mnemonic="LEA", mode="Long-offset") +def tricore_ld(obj, off2, off3, off1, b, a): + dst = env.D[a] + if obj.mnemonic in ("LD_A", "LEA"): dst = env.A[a] + if obj.mnemonic=="LD_D": dst = env.E[a] + src1 = env.A[b] + off16 = off1//off2//off3 + src2 = env.cst(off16.int(-1),32) + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {b5} ]", mnemonic="ST_A", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {e9} ]", mnemonic="ST_B", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {f9} ]", mnemonic="ST_H", mode="Long-offset") +@ispec("32<[ ~off2(4) ~off3(6) ~off1(6) b(4) a(4) {59} ]", mnemonic="ST_W", mode="Long-offset") +def tricore_st(obj, off2, off3, off1, b, a): + dst = env.D[a] + if obj.mnemonic=="ST_A": dst = env.A[a] + if obj.mnemonic=="ST_D": dst = env.E[a] + src1 = env.A[b] + off16 = off1//off2//off3 + src2 = env.cst(off16.int(-1),32) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + +@ispec("16<[ const(8) {d8} ]", mnemonic="LD_A", mode="SC") +@ispec("16<[ const(8) {58} ]", mnemonic="LD_W", mode="SC") +def tricore_ld(obj, const): + dst = env.D[15] + if obj.mnemonic=="LD_A": dst=env.A[15] + src1 = env.A[10] + src2 = env.cst(4*const,32) + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ const(8) {f8} ]", mnemonic="ST_A", mode="SC") +@ispec("16<[ const(8) {78} ]", mnemonic="ST_W", mode="SC") +def tricore_st(obj, const): + dst = env.D[15] + if obj.mnemonic=="ST_A": dst=env.A[15] + src1 = env.A[10] + src2 = env.cst(4*const,32) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + +@ispec("16<[ b(4) c(4) {d4} ]", mnemonic="LD_A", mode="SLR") +@ispec("16<[ b(4) c(4) {c4} ]", mnemonic="LD_A", mode="Post-increment") +@ispec("16<[ b(4) c(4) {14} ]", mnemonic="LD_BU", mode="SLR") +@ispec("16<[ b(4) c(4) {04} ]", mnemonic="LD_BU", mode="Post-increment") +@ispec("16<[ b(4) c(4) {94} ]", mnemonic="LD_H", mode="SLR") +@ispec("16<[ b(4) c(4) {84} ]", mnemonic="LD_H", mode="Post-increment") +@ispec("16<[ b(4) c(4) {54} ]", mnemonic="LD_W", mode="SLR") +@ispec("16<[ b(4) c(4) {44} ]", mnemonic="LD_W", mode="Post-increment") +def tricore_ld(obj, b, c): + dst = env.D[c] + if obj.mnemonic=="LD_A": dst = env.A[c] + if obj.mnemonic=="LD_D": dst = env.E[c] + src1 = env.A[b] + src2 = env.cst(0,32) + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) c(4) {f4} ]", mnemonic="ST_A", mode="SSR") +@ispec("16<[ b(4) c(4) {e4} ]", mnemonic="ST_A", mode="Post-increment") +@ispec("16<[ b(4) c(4) {b4} ]", mnemonic="ST_H", mode="SSR") +@ispec("16<[ b(4) c(4) {a4} ]", mnemonic="ST_H", mode="Post-increment") +@ispec("16<[ b(4) c(4) {74} ]", mnemonic="ST_W", mode="SSR") +@ispec("16<[ b(4) c(4) {64} ]", mnemonic="ST_W", mode="Post-increment") +def tricore_st(obj, b, c): + dst = env.D[c] + if obj.mnemonic=="ST_A": dst = env.A[c] + if obj.mnemonic=="ST_D": dst = env.E[c] + src1 = env.A[b] + src2 = env.cst(0,32) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + +@ispec("16<[ off(4) c(4) {c8} ]", mnemonic="LD_A", mode="SLRO") +@ispec("16<[ off(4) c(4) {08} ]", mnemonic="LD_BU", mode="SLRO") +@ispec("16<[ off(4) c(4) {88} ]", mnemonic="LD_H", mode="SLRO") +@ispec("16<[ off(4) c(4) {48} ]", mnemonic="LD_W", mode="SLRO") +def tricore_ld(obj, off, c): + dst = env.A[c] if obj.mnemonic=="LD_A" else env.D[c] + src1 = env.A[15] + src2 = env.cst(4*off,32) + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ off(4) c(4) {e8} ]", mnemonic="ST_A", mode="SSRO") +@ispec("16<[ off(4) c(4) {a8} ]", mnemonic="ST_H", mode="SSRO") +@ispec("16<[ off(4) c(4) {68} ]", mnemonic="ST_W", mode="SSRO") +def tricore_st(obj, off, c): + dst = env.A[c] if obj.mnemonic=="ST_A" else env.D[c] + src1 = env.A[15] + src2 = env.cst(4*off,32) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + +@ispec("16<[ b(4) off(4) {cc} ]", mnemonic="LD_A", mode="SRO") +@ispec("16<[ b(4) off(4) {0c} ]", mnemonic="LD_BU", mode="SRO") +@ispec("16<[ b(4) off(4) {8c} ]", mnemonic="LD_H", mode="SRO") +@ispec("16<[ b(4) off(4) {4c} ]", mnemonic="LD_W", mode="SRO") +def tricore_ld(obj, b, off): + dst = env.A[15] if obj.mnemonic=="LD_A" else env.D[15] + src1 = env.A[b] + src2 = env.cst(4*off,32) + obj.operands = [dst, src1, src2] + obj.type = type_data_processing + +@ispec("16<[ b(4) off(4) {ec} ]", mnemonic="ST_A", mode="SRO") +@ispec("16<[ b(4) off(4) {ac} ]", mnemonic="ST_H", mode="SRO") +@ispec("16<[ b(4) off(4) {6c} ]", mnemonic="ST_W", mode="SRO") +def tricore_st(obj, b, off): + dst = env.A[15] if obj.mnemonic=="ST_A" else env.D[15] + src1 = env.A[b] + src2 = env.cst(4*off,32) + obj.operands = [src1, src2, dst] + obj.type = type_data_processing + +@ispec("32<[ c(4) const16(16) ---- {4d} ]", mnemonic="MFCR") +def tricore_mfcr(obj, c, const16): + src = env.cst(const16,16) + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_system + +@ispec("32<[ ---- const16(16) a(4) {cd} ]", mnemonic="MTCR") +def tricore_mtcr(obj, const16, a): + src1 = env.cst(const16,16) + src2 = env.D[a] + obj.operands = [src1, src2] + obj.type = type_system + +@ispec("32<[ c(4) const16(16) ---- {bb} ]", mnemonic="MOV_U") +def tricore_mov(obj, c, const16): + src = env.cst(const16,32) + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) ~const16(16) ---- {3b} ]", mnemonic="MOV") +def tricore_mov(obj, c, const16): + src = env.cst(const16.int(-1),32) + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) const16(16) ---- {7b} ]", mnemonic="MOVH") +def tricore_mov(obj, c, const16): + src = env.cst(const16,16) + dst = env.D[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) const16(16) ---- {91} ]", mnemonic="MOVH_A") +def tricore_mov(obj, c, const16): + src = env.cst(const16,16) + dst = env.A[c] + obj.operands = [dst, src] + obj.type = type_data_processing + +@ispec("32<[ c(4) ~const16(16) ---- {fb} ]", mnemonic="MOV") +def tricore_mov(obj, c, const16): + src = env.cst(const16.int(-1),64) + dst = env.E[c] + obj.operands = [dst, src] + obj.type = type_data_processing + diff --git a/amoco/arch/tricore/utils.py b/amoco/arch/tricore/utils.py new file mode 100644 index 0000000..60c9665 --- /dev/null +++ b/amoco/arch/tricore/utils.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- + + +def byte_select(x,s): + return x.bytes(s,s+1) + +def reflect(x,n): + L = [] + for b in range(n): + L.append(x[b:b+1]) + return composer(L) + +def reverse16(x): + return reflect(x,16) + +def reverse_and_invert(x): + L = [] + for b in range(32): + L.append(~(x[b:b+1])) + return composer(L) + +def cdc_decrement(): + pass + +def round16(x): + return composer([cst(0,16),(x+0x8000)[16:32]]) + +def ssov(x,y): + max_pos = cst((1<<(y-1))-1,y) + max_neg = cst(1,y)<<(y-1) + return tst(x>max_pos,max_pos,tst(xmax_pos,max_pos,tst(x<0,cst(0,x.size),x)) diff --git a/amoco/arch/w65c02/__init__.py b/amoco/arch/w65c02/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/amoco/arch/w65c02/asm.py b/amoco/arch/w65c02/asm.py new file mode 100644 index 0000000..dfce22f --- /dev/null +++ b/amoco/arch/w65c02/asm.py @@ -0,0 +1,515 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2017 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from .env import * +from amoco.cas.utils import * + +# ------------------------------------------------------------------------------ +# helpers and decorators : +def _push8(fmap, _x): + assert _x.size==8 + fmap[mem(sp_, 8)] = _x + fmap[sp] = fmap(sp - 1) + + +def _pop8(fmap, _l): + assert _l.size==8 + fmap[sp] = fmap(sp + 1) + fmap[_l] = fmap(mem(sp_, 8)) + +def _push16(fmap, _x): + assert _x.size==16 + fmap[sp] = fmap(sp - 1) + fmap[mem(sp_, 16)] = _x + fmap[sp] = fmap(sp - 1) + +def _pop16(fmap, _l): + assert _l.size==16 + fmap[sp] = fmap(sp + 1) + fmap[_l] = fmap(mem(sp_, 16)) + fmap[sp] = fmap(sp + 1) + +def __npc(i_xxx): + def npc(ins, fmap): + fmap[pc] = fmap(pc) + ins.length + i_xxx(ins, fmap) + return npc + +def overflow(res,a,v): + return ((res^a) & (res^v))[7:8] + +def get_op_16(i,fmap): + return fmap(i.operands[0]).zeroextend(16) + +# i_xxx is the translation of W65C02(S) instruction xxx. +# ------------------------------------------------------------------------------ + +@__npc +def i_ADC(i,fmap): + c = fmap(C).zeroextend(16) + a = fmap(A_) + v = get_op_16(i,fmap) + res = a+v+c + fmap[Z] = res==0 + fmap[V] = overflow(res,a,v) + fmap[N] = Sign(res) + c = ~D&((res&0xff00)!=0) + a = fmap(A) + cond = tst(a[0:4]>9, a+6, a)[4:8]>9 + fmap[C] = tst(D&cond,bit1,c) + fmap[A] = res[0:8] + +@__npc +def i_AND(i,fmap): + res = fmap(i.operands[0]&A) + fmap[N] = res[7:8] + fmap[Z] = res==0 + fmap[A] = res + +@__npc +def i_ASL(i,fmap): + dst = i.operands[0] + res = get_op_16(i,fmap)<<1 + fmap[C] = res[8:16]>0 + fmap[N] = res[7:8] + fmap[Z] = res[0:8]==0 + fmap[dst] = res[0:8] + +@__npc +def i_BCC(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(C==bit0,pc+reladdr,pc)) + +@__npc +def i_BCS(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(C==bit1,pc+reladdr,pc)) + +@__npc +def i_BEQ(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(Z==bit1,pc+reladdr,pc)) + +@__npc +def i_BIT(i,fmap): + val = fmap(i.operands[0]) + fmap[V] = val[6:7] + fmap[N] = Sign(val) + fmap[Z] = (fmap(A)&val)==0 + +@__npc +def i_BMI(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(N==bit1,pc+reladdr,pc)) + +@__npc +def i_BNE(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(Z==bit0,pc+reladdr,pc)) + +@__npc +def i_BPL(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(N==bit0,pc+reladdr,pc)) + +@__npc +def i_BRA(i,fmap): + reladdr = i.operands[0] + fmap[pc] = pc+reladdr + +def i_BRK(i,fmap): + _push16(fmap,fmap[pc]+1) + _push8(fmap,fmap(P|0x10)) + fmap[D] = bit0 + fmap[B] = bit1 + fmap[pc] = fmap(mem(IRQ_VECTOR,16)) + +@__npc +def i_BVC(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(V==bit0,pc+reladdr,pc)) + +@__npc +def i_BVS(i,fmap): + reladdr = i.operands[0] + fmap[pc] = fmap(tst(V==bit1,pc+reladdr,pc)) + +@__npc +def i_CLC(i,fmap): + fmap[C] = bit0 + +@__npc +def i_CLD(i,fmap): + fmap[D] = bit0 + +@__npc +def i_CLI(i,fmap): + fmap[I] = bit0 + +@__npc +def i_CLV(i,fmap): + fmap[V] = bit0 + +@__npc +def i_CMP(i,fmap): + v = get_op_16(i,fmap) + a = fmap(A) + fmap[S] = (a.zeroextend(16) - v)[7:8] + fmap[C] = (a>=v[0:8]) + fmap[Z] = (a==v[0:8]) + +@__npc +def i_CPX(i,fmap): + v = get_op_16(i,fmap) + a = fmap(X) + fmap[S] = (a.zeroextend(16) - v)[7:8] + fmap[C] = (a>=v[0:8]) + fmap[Z] = (a==v[0:8]) + +@__npc +def i_CPY(i,fmap): + v = get_op_16(i,fmap) + a = fmap(Y) + fmap[S] = (a.zeroextend(16) - v)[7:8] + fmap[C] = (a>=v[0:8]) + fmap[Z] = (a==v[0:8]) + +@__npc +def i_DEC(i,fmap): + dst = src = i.operands[0] + val = fmap(src) + res = val-1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_DEX(i,fmap): + dst = src = X + val = fmap(src) + res = val-1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_DEY(i,fmap): + dst = src = Y + val = fmap(src) + res = val-1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_EOR(i,fmap): + val = fmap(i.operands[0]) + res = val^fmap(A_) + fmap[Z] = res==0 + fmap[N] = Sign(res) + fmap[A] = res + +@__npc +def i_INC(i,fmap): + dst = src = i.operands[0] + val = fmap(src) + res = val+1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_INX(i,fmap): + dst = src = X + val = fmap(src) + res = val+1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_INY(i,fmap): + dst = src = X + val = fmap(src) + res = val+1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +def i_JMP(i,fmap): + fmap[pc] = fmap(i.operands[0]) + +@__npc +def i_JSR(i,fmap): + _push16(fmap,fmap(pc-1)) # not an error ;) + fmap[pc] = fmap(i.operands[0]) + +@__npc +def i_LDA(i,fmap): + res = fmap(i.operands[0]) + fmap[A] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_LDX(i,fmap): + res = fmap(i.operands[0]) + fmap[X] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_LDY(i,fmap): + res = fmap(i.operands[0]) + fmap[Y] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_LSR(i,fmap): + dst = src = i.operands[0] + val = fmap(src) + fmap[C] = val[0:1] + res = val>>1 + fmap[dst] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_NOP(i,fmap): + pass + +@__npc +def i_ORA(i,fmap): + res = fmap(A|i.operands[0]) + fmap[Z] = res==0 + fmap[N] = Sign(res) + fmap[A] = res + +@__npc +def i_PHA(i,fmap): + _push8(fmap,fmap(A)) + +@__npc +def i_PHP(i,fmap): + _push8(fmap,fmap(P|0x10)) + +@__npc +def i_PHY(i,fmap): + _push8(fmap,fmap(Y)) + +@__npc +def i_PHX(i,fmap): + _push8(fmap,fmap(X)) + +@__npc +def i_PLA(i,fmap): + _pop8(fmap,A) + a = fmap(A) + fmap[Z] = a==0 + fmap[N] = Sign(a) + +@__npc +def i_PLP(i,fmap): + _pop8(fmap,P) + fmap[P] = fmap(P)|0x20 + +@__npc +def i_PLX(i,fmap): + _pop8(fmap,X) + +@__npc +def i_PLY(i,fmap): + _pop8(fmap,Y) + +@__npc +def i_ROL(i,fmap): + dst = i.operands[0] + val = get_op_16(i,fmap)<<1 + res = val|(fmap(C).zeroextend(16)) + fmap[dst] = res[0:8] + fmap[C] = val[8:9] + fmap[Z] = res[0:8]==0 + fmap[N] = Sign(res) + +@__npc +def i_ROR(i,fmap): + dst = i.operands[0] + val = get_op_16(i,fmap) + res = (val>>1)|(fmap(C).zeroextend(16)<<7) + fmap[dst] = res[0:8] + fmap[C] = val[0:1] + fmap[Z] = res[0:8]==0 + fmap[N] = Sign(res) + +def i_RTI(i,fmap): + _pop8(fmap,P) + _pop16(fmap,pc) + +def i_RTS(i,fmap): + _pop16(fmap,pc) + fmap[pc] = fmap(pc)+1 + +@__npc +def i_SBC(i,fmap): + c = fmap(C).zeroextend(16) + a = fmap(A_) + v = get_op_16(i,fmap)^0x00ff + res = a+v+c + fmap[Z] = res==0 + fmap[V] = overflow(res,a,v) + fmap[N] = Sign(res) + c = ~D&((res&0xff00)!=0) + a = fmap(A)-0x66 + cond = tst(a[0:4]>9, a+6, a)[4:8]>9 + fmap[C] = tst(D&cond,bit1,c) + fmap[A] = res[0:8] + +@__npc +def i_SEC(i,fmap): + fmap[C] = bit1 + +@__npc +def i_SED(i,fmap): + fmap[D] = bit1 + +@__npc +def i_SEI(i,fmap): + fmap[I] = bit1 + +@__npc +def i_STA(i,fmap): + fmap[i.operands[0]] = fmap(A) + +@__npc +def i_STX(i,fmap): + fmap[i.operands[0]] = fmap(X) + +@__npc +def i_STY(i,fmap): + fmap[i.operands[0]] = fmap(Y) + +@__npc +def i_STZ(i,fmap): + fmap[i.operands[0]] = cst(0,8) + +@__npc +def i_TAX(i,fmap): + res = fmap(A) + fmap[X] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_TAY(i,fmap): + res = fmap(A) + fmap[Y] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_TRB(i,fmap): + raise NotImplementedError + +@__npc +def i_TSB(i,fmap): + raise NotImplementedError + +@__npc +def i_TSX(i,fmap): + res = fmap(sp) + fmap[X] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_TXA(i,fmap): + res = fmap(X) + fmap[A] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +@__npc +def i_TXS(i,fmap): + res = fmap(X) + fmap[sp] = res + # no update of Z & N + +@__npc +def i_TYA(i,fmap): + res = fmap(Y) + fmap[A] = res + fmap[Z] = res==0 + fmap[N] = Sign(res) + +def bbrx(n,i,fmap): + cond = i.operands[0] + reladdr = i.operands[1] + fmap[pc] = fmap(tst(cond[0:1]==bit0,pc+reladdr,pc)) + +@__npc +def i_BBR0(i,fmap): + bbrx(0,i,fmap) +@__npc +def i_BBR1(i,fmap): + bbrx(1,i,fmap) +@__npc +def i_BBR2(i,fmap): + bbrx(2,i,fmap) +@__npc +def i_BBR3(i,fmap): + bbrx(3,i,fmap) +@__npc +def i_BBR4(i,fmap): + bbrx(4,i,fmap) +@__npc +def i_BBR5(i,fmap): + bbrx(5,i,fmap) +@__npc +def i_BBR6(i,fmap): + bbrx(6,i,fmap) +@__npc +def i_BBR7(i,fmap): + bbrx(7,i,fmap) + +def bbsx(n,i,fmap): + cond = mem(i.operands[0],8) + reladdr = i.operands[1] + fmap[pc] = fmap(tst(cond[0:1]==bit1,pc+reladdr,pc)) + +@__npc +def i_BBS0(i,fmap): + bbsx(0,i,fmap) +@__npc +def i_BBS1(i,fmap): + bbsx(1,i,fmap) +@__npc +def i_BBS2(i,fmap): + bbsx(2,i,fmap) +@__npc +def i_BBS3(i,fmap): + bbsx(3,i,fmap) +@__npc +def i_BBS4(i,fmap): + bbsx(4,i,fmap) +@__npc +def i_BBS5(i,fmap): + bbsx(5,i,fmap) +@__npc +def i_BBS6(i,fmap): + bbsx(6,i,fmap) +@__npc +def i_BBS7(i,fmap): + bbsx(7,i,fmap) + +@__npc +def i_WAI(i,fmap): + raise NotImplementedError + +@__npc +def i_STP(i,fmap): + raise NotImplementedError + diff --git a/amoco/arch/w65c02/cpu.py b/amoco/arch/w65c02/cpu.py new file mode 100644 index 0000000..6a407d3 --- /dev/null +++ b/amoco/arch/w65c02/cpu.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- + +from amoco.arch.w65c02.asm import * + +# expose "microarchitecture" (instructions semantics) +uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items())) + +# import specifications: +from amoco.arch.core import instruction, disassembler + +instruction_w65c02 = type("instruction_w65c02", (instruction,), {}) +instruction_w65c02.set_uarch(uarch) + +from amoco.arch.w65c02.formats import w65c02_full + +instruction_w65c02.set_formatter(w65c02_full) + +# define disassembler: +from amoco.arch.w65c02 import spec + +disassemble = disassembler([spec], iclass=instruction_w65c02) + + +def PC(): + return pc + + +def get_data_endian(): + return 1 # LE diff --git a/amoco/arch/w65c02/env.py b/amoco/arch/w65c02/env.py new file mode 100644 index 0000000..8488b6b --- /dev/null +++ b/amoco/arch/w65c02/env.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +# import expressions: +from amoco.cas.expressions import * + + +# registers : +# ----------- + +A = reg("A", 8) +X = reg("X", 8) +Y = reg("Y", 8) + +sp_ = reg("sp",16) +sp = slc(sp_,0,8,"SP") +P = reg("P",8) + +pc = reg("PC",16) + +pcl = slc(pc,0,8,"PCL") +pch = slc(pc,8,8,"PCH") + + +C = slc(P,0,1,"C") # carry +Z = slc(P,1,1,"Z") # zero +I = slc(P,2,1,"I") # interrupt enable/disable(1) +D = slc(P,3,1,"D") # decimal mode +B = slc(P,4,1,"B") # brk command +V = slc(P,6,1,"V") # overflow +N = slc(P,7,1,"N") # negative + +is_reg_pc(pc) +is_reg_stack(sp_) +is_reg_flags(P) + +registers = [A,X,Y,sp_,P,pc] + +A_ = A.zeroextend(16) +X_ = A.zeroextend(16) +Y_ = A.zeroextend(16) + diff --git a/amoco/arch/w65c02/formats.py b/amoco/arch/w65c02/formats.py new file mode 100644 index 0000000..7c3e5b2 --- /dev/null +++ b/amoco/arch/w65c02/formats.py @@ -0,0 +1,54 @@ +# -*- coding: utf-8 -*- + +from .env import * +from amoco.cas.expressions import regtype +from amoco.arch.core import Formatter, Token + + +def mnemo(i): + mn = i.mnemonic.lower() + return [(Token.Mnemonic, "{: <6}".format(mn))] + + +def deref(opd): + return "+%d(%s)" % (opd.a.disp, opd.a.base) + + +def opers(i): + s = [] + for op in i.operands: + if op._is_mem: + s.append((Token.Memory, deref(op))) + elif op._is_cst: + if i.misc["ref"] is not None: + s.append((Token.Address, "%s" % (i.misc["ref"]))) + elif op.sf: + s.append((Token.Constant, "%+d" % op.value)) + else: + s.append((Token.Constant, op.__str__())) + elif op._is_reg: + s.append((Token.Register, op.__str__())) + s.append((Token.Literal, ", ")) + if len(s) > 0: + s.pop() + return s + + +def opers_pcr(i): + s = opers(i) + if i.misc["pc_ref"] is not None and i.address is not None: + adr = i.address + i.length + i.misc["pc_ref"].value + s[-1] = (Token.Address, "%s" % (adr)) + return s + + +format_default = (mnemo, opers) + +w65c02_full_formats = { + "w65c02_pcr": (mnemo, opers_pcr), + "w65c02_bb": (mnemo, opers_pcr), +} + +w65c02_full = Formatter(w65c02_full_formats) +w65c02_full.default = format_default + diff --git a/amoco/arch/w65c02/spec.py b/amoco/arch/w65c02/spec.py new file mode 100644 index 0000000..ab601ef --- /dev/null +++ b/amoco/arch/w65c02/spec.py @@ -0,0 +1,398 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.arch.w65c02 import env + +from amoco.arch.core import * + +# ------------------------------------------------------- +# W65C02(S) instruction decoders +# ------------------------------------------------------- + +ISPECS = [] + +# absolute addressing: a +# -------------------- +@ispec("24<[a(16) {0c}]", mnemonic="TSB") +@ispec("24<[a(16) {0d}]", mnemonic="ORA") +@ispec("24<[a(16) {0e}]", mnemonic="ASL") +@ispec("24<[a(16) {1c}]", mnemonic="TRB") +@ispec("24<[a(16) {20}]", mnemonic="JSR") +@ispec("24<[a(16) {2c}]", mnemonic="BIT") +@ispec("24<[a(16) {2d}]", mnemonic="AND") +@ispec("24<[a(16) {2e}]", mnemonic="ROL") +@ispec("24<[a(16) {4c}]", mnemonic="JMP") +@ispec("24<[a(16) {4d}]", mnemonic="EOL") +@ispec("24<[a(16) {4e}]", mnemonic="LSR") +@ispec("24<[a(16) {6d}]", mnemonic="ADC") +@ispec("24<[a(16) {6e}]", mnemonic="ROR") +@ispec("24<[a(16) {8c}]", mnemonic="STY") +@ispec("24<[a(16) {8d}]", mnemonic="STA") +@ispec("24<[a(16) {8e}]", mnemonic="STX") +@ispec("24<[a(16) {9c}]", mnemonic="STZ") +@ispec("24<[a(16) {ad}]", mnemonic="LDA") +@ispec("24<[a(16) {ae}]", mnemonic="LDX") +@ispec("24<[a(16) {cc}]", mnemonic="CPY") +@ispec("24<[a(16) {cd}]", mnemonic="CMP") +@ispec("24<[a(16) {ce}]", mnemonic="DEC") +@ispec("24<[a(16) {ec}]", mnemonic="CPX") +@ispec("24<[a(16) {ed}]", mnemonic="SBC") +@ispec("24<[a(16) {ee}]", mnemonic="INC") +def w65c02_absolute(obj, a): + adr = env.cst(a,16) + if obj.mnemonic in ("JMP","JSR"): + obj.operands = [adr] + obj.type = type_control_flow + obj.misc['ref'] = adr + else: + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# absolute indexed indirect : (a,x) +# --------------------------------- +@ispec("24<[a(16) {7c}]", mnemonic="JMP") +def w65c02_aiix(obj, a): + adr = env.cst(a,16) + env.X_ + obj.operands = [env.mem(adr,16)] + obj.type = type_control_flow + +# absolute indexed with X : a,x +# ----------------------------- +@ispec("24<[a(16) {1d}]", mnemonic="ORA") +@ispec("24<[a(16) {1e}]", mnemonic="ASL") +@ispec("24<[a(16) {3c}]", mnemonic="BIT") +@ispec("24<[a(16) {3d}]", mnemonic="AND") +@ispec("24<[a(16) {3e}]", mnemonic="ROL") +@ispec("24<[a(16) {5d}]", mnemonic="EOR") +@ispec("24<[a(16) {5e}]", mnemonic="LSR") +@ispec("24<[a(16) {7d}]", mnemonic="ADC") +@ispec("24<[a(16) {7e}]", mnemonic="ROR") +@ispec("24<[a(16) {9d}]", mnemonic="STA") +@ispec("24<[a(16) {9e}]", mnemonic="STZ") +@ispec("24<[a(16) {bc}]", mnemonic="LDY") +@ispec("24<[a(16) {bd}]", mnemonic="LDA") +@ispec("24<[a(16) {dd}]", mnemonic="CMP") +@ispec("24<[a(16) {de}]", mnemonic="DEC") +@ispec("24<[a(16) {fd}]", mnemonic="SBC") +@ispec("24<[a(16) {fe}]", mnemonic="INC") +def w65c02_aix(obj, a): + adr = env.cst(a,16) + env.X_ + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# absolute indexed with Y : a,y +# ------------------------- +@ispec("24<[a(16) {19}]", mnemonic="ORA") +@ispec("24<[a(16) {39}]", mnemonic="AND") +@ispec("24<[a(16) {59}]", mnemonic="EOR") +@ispec("24<[a(16) {79}]", mnemonic="ADC") +@ispec("24<[a(16) {99}]", mnemonic="STA") +@ispec("24<[a(16) {b9}]", mnemonic="LDA") +@ispec("24<[a(16) {be}]", mnemonic="LDX") +@ispec("24<[a(16) {d9}]", mnemonic="CMP") +@ispec("24<[a(16) {f9}]", mnemonic="SBC") +def w65c02_aiy(obj, a): + adr = env.cst(a,16) + env.Y_ + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# absolute indirect: (a) +# ------------------ +@ispec("24<[a(16) {6c}]", mnemonic="JMP") +def w65c02_ai(obj, a): + adr = env.cst(a,16) + obj.operands = [env.mem(adr,16)] + obj.type = type_control_flow + +# accumulator addressing : A +# ------------------------ +@ispec("8<[{0a}]", mnemonic="ASL") +@ispec("8<[{1a}]", mnemonic="INC") +@ispec("8<[{2a}]", mnemonic="ROL") +@ispec("8<[{3a}]", mnemonic="DEC") +@ispec("8<[{4a}]", mnemonic="LSR") +@ispec("8<[{6a}]", mnemonic="ROR") +@ispec("8<[{ac}]", mnemonic="LDY") +def w65c02_A(obj): + obj.operands = [env.A] + obj.type = type_data_processing + +# immediate addressing: # +# --------------------- +@ispec("16<[c(8) {09}]", mnemonic="ORA") +@ispec("16<[c(8) {29}]", mnemonic="AND") +@ispec("16<[c(8) {49}]", mnemonic="EOR") +@ispec("16<[c(8) {69}]", mnemonic="ADC") +@ispec("16<[c(8) {89}]", mnemonic="BIT") +@ispec("16<[c(8) {a0}]", mnemonic="LDY") +@ispec("16<[c(8) {a2}]", mnemonic="LDX") +@ispec("16<[c(8) {a9}]", mnemonic="LDA") +@ispec("16<[c(8) {c0}]", mnemonic="CPY") +@ispec("16<[c(8) {c9}]", mnemonic="CMP") +@ispec("16<[c(8) {e0}]", mnemonic="CPX") +@ispec("16<[c(8) {e9}]", mnemonic="SBC") +def w65c02_immediate(obj, c): + obj.operands = [env.cst(c,8)] + obj.type = type_data_processing + +# implied addressing : i +# -------------------- +@ispec("8<[{18}]", mnemonic="CLC", type=type_data_processing) +@ispec("8<[{38}]", mnemonic="SEC", type=type_data_processing) +@ispec("8<[{58}]", mnemonic="CLI", type=type_data_processing) +@ispec("8<[{78}]", mnemonic="SEI", type=type_data_processing) +@ispec("8<[{88}]", mnemonic="DEY", type=type_data_processing) +@ispec("8<[{8a}]", mnemonic="TXA", type=type_data_processing) +@ispec("8<[{98}]", mnemonic="TYA", type=type_data_processing) +@ispec("8<[{9a}]", mnemonic="TXS", type=type_data_processing) +@ispec("8<[{a8}]", mnemonic="TAY", type=type_data_processing) +@ispec("8<[{aa}]", mnemonic="TAX", type=type_data_processing) +@ispec("8<[{b8}]", mnemonic="CLV", type=type_data_processing) +@ispec("8<[{ba}]", mnemonic="TSX", type=type_data_processing) +@ispec("8<[{c8}]", mnemonic="INY", type=type_data_processing) +@ispec("8<[{ca}]", mnemonic="DEX", type=type_data_processing) +@ispec("8<[{cb}]", mnemonic="WAI", type=type_system) +@ispec("8<[{d8}]", mnemonic="CLD", type=type_data_processing) +@ispec("8<[{db}]", mnemonic="STP", type=type_system) +@ispec("8<[{e8}]", mnemonic="INX", type=type_data_processing) +@ispec("8<[{ea}]", mnemonic="NOP", type=type_data_processing) +@ispec("8<[{f8}]", mnemonic="SED", type=type_data_processing) +def w65c02_implied(obj): + obj.operands = [] + +# program counter relative: r +# ------------------------- +@ispec("16<[a(8) {10}]", mnemonic="BPL") +@ispec("16<[a(8) {30}]", mnemonic="BMI") +@ispec("16<[a(8) {50}]", mnemonic="BVC") +@ispec("16<[a(8) {70}]", mnemonic="BVS") +@ispec("16<[a(8) {80}]", mnemonic="BRA") +@ispec("16<[a(8) {90}]", mnemonic="BCC") +@ispec("16<[a(8) {b0}]", mnemonic="BCS") +@ispec("16<[a(8) {d0}]", mnemonic="BNE") +@ispec("16<[a(8) {f0}]", mnemonic="BEQ") +def w65c02_pcr(obj, a): + offset = env.cst(a,8).signextend(16) + obj.operands = [offset] + obj.misc["pc_ref"] = offset + obj.type = type_control_flow + +@ispec("24<[a(8) b(8) {0f}]", mnemonic="BBR0") +@ispec("24<[a(8) b(8) {1f}]", mnemonic="BBR1") +@ispec("24<[a(8) b(8) {2f}]", mnemonic="BBR2") +@ispec("24<[a(8) b(8) {3f}]", mnemonic="BBR3") +@ispec("24<[a(8) b(8) {4f}]", mnemonic="BBR4") +@ispec("24<[a(8) b(8) {5f}]", mnemonic="BBR5") +@ispec("24<[a(8) b(8) {6f}]", mnemonic="BBR6") +@ispec("24<[a(8) b(8) {7f}]", mnemonic="BBR7") +@ispec("24<[a(8) b(8) {8f}]", mnemonic="BBS0") +@ispec("24<[a(8) b(8) {9f}]", mnemonic="BBS1") +@ispec("24<[a(8) b(8) {af}]", mnemonic="BBS2") +@ispec("24<[a(8) b(8) {bf}]", mnemonic="BBS3") +@ispec("24<[a(8) b(8) {cf}]", mnemonic="BBS4") +@ispec("24<[a(8) b(8) {df}]", mnemonic="BBS5") +@ispec("24<[a(8) b(8) {ef}]", mnemonic="BBS6") +@ispec("24<[a(8) b(8) {ff}]", mnemonic="BBS7") +def w65c02_bb(obj, a, b): + offset = env.cst(a,8).signextend(16) + cond = env.cst(b,8) + obj.operands = [cond,offset] + obj.misc["pc_ref"] = offset + obj.type = type_control_flow + +# stack addressing: s +# ----------------- +@ispec("8<[{00}]", mnemonic="BRK", type=type_control_flow) +@ispec("8<[{08}]", mnemonic="PHP", type=type_data_processing) +@ispec("8<[{28}]", mnemonic="PLP", type=type_data_processing) +@ispec("8<[{40}]", mnemonic="RTI", type=type_control_flow) +@ispec("8<[{48}]", mnemonic="PHA", type=type_data_processing) +@ispec("8<[{5a}]", mnemonic="PHY", type=type_data_processing) +@ispec("8<[{60}]", mnemonic="RTS", type=type_control_flow) +@ispec("8<[{68}]", mnemonic="PLA", type=type_data_processing) +@ispec("8<[{7a}]", mnemonic="PLY", type=type_data_processing) +@ispec("8<[{da}]", mnemonic="PHX", type=type_data_processing) +@ispec("8<[{fa}]", mnemonic="PLX", type=type_data_processing) +def w65c02_stack(obj): + obj.operands = [] + +# zero page addressing: zp +# --------------------- +@ispec("16<[a(8) {04}]", mnemonic="TSB") +@ispec("16<[a(8) {05}]", mnemonic="ORA") +@ispec("16<[a(8) {06}]", mnemonic="ASL") +@ispec("16<[a(8) {14}]", mnemonic="TRB") +@ispec("16<[a(8) {24}]", mnemonic="BIT") +@ispec("16<[a(8) {25}]", mnemonic="AND") +@ispec("16<[a(8) {26}]", mnemonic="ROL") +@ispec("16<[a(8) {45}]", mnemonic="EOR") +@ispec("16<[a(8) {46}]", mnemonic="LSR") +@ispec("16<[a(8) {64}]", mnemonic="STZ") +@ispec("16<[a(8) {65}]", mnemonic="ADC") +@ispec("16<[a(8) {66}]", mnemonic="ROR") +@ispec("16<[a(8) {84}]", mnemonic="STY") +@ispec("16<[a(8) {85}]", mnemonic="STA") +@ispec("16<[a(8) {86}]", mnemonic="STX") +@ispec("16<[a(8) {a4}]", mnemonic="LDY") +@ispec("16<[a(8) {a5}]", mnemonic="LDA") +@ispec("16<[a(8) {a6}]", mnemonic="LDX") +@ispec("16<[a(8) {c4}]", mnemonic="CPY") +@ispec("16<[a(8) {c5}]", mnemonic="CMP") +@ispec("16<[a(8) {c6}]", mnemonic="DEC") +@ispec("16<[a(8) {e4}]", mnemonic="CPX") +@ispec("16<[a(8) {e5}]", mnemonic="SBC") +@ispec("16<[a(8) {e6}]", mnemonic="INC") +@ispec("16<[a(8) {07}]", mnemonic="RMB0") +@ispec("16<[a(8) {17}]", mnemonic="RMB1") +@ispec("16<[a(8) {27}]", mnemonic="RMB2") +@ispec("16<[a(8) {37}]", mnemonic="RMB3") +@ispec("16<[a(8) {47}]", mnemonic="RMB4") +@ispec("16<[a(8) {57}]", mnemonic="RMB5") +@ispec("16<[a(8) {67}]", mnemonic="RMB6") +@ispec("16<[a(8) {77}]", mnemonic="RMB7") +@ispec("16<[a(8) {87}]", mnemonic="SMB0") +@ispec("16<[a(8) {97}]", mnemonic="SMB1") +@ispec("16<[a(8) {a7}]", mnemonic="SMB2") +@ispec("16<[a(8) {b7}]", mnemonic="SMB3") +@ispec("16<[a(8) {c7}]", mnemonic="SMB4") +@ispec("16<[a(8) {d7}]", mnemonic="SMB5") +@ispec("16<[a(8) {e7}]", mnemonic="SMB6") +@ispec("16<[a(8) {f7}]", mnemonic="SMB7") +def w65c02_zp(obj, a): + adr = env.cst(a,16) + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# zero page indexed indirect addressing: (zp,x) +# -------------------------------------- +@ispec("16<[a(8) {01}]", mnemonic="ORA") +@ispec("16<[a(8) {21}]", mnemonic="AND") +@ispec("16<[a(8) {41}]", mnemonic="EOR") +@ispec("16<[a(8) {61}]", mnemonic="ADC") +@ispec("16<[a(8) {81}]", mnemonic="STA") +@ispec("16<[a(8) {a1}]", mnemonic="LDA") +@ispec("16<[a(8) {c1}]", mnemonic="CMP") +@ispec("16<[a(8) {e1}]", mnemonic="SBC") +def w65c02_zpii(obj, a): + off = env.cst(a,16) + env.X_ + adr = env.mem(off,8).zeroextend(16) + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# zero page indexed with X : zp,x +# -------------------------- +@ispec("16<[a(8) {15}]", mnemonic="ORA") +@ispec("16<[a(8) {16}]", mnemonic="ASL") +@ispec("16<[a(8) {34}]", mnemonic="BIT") +@ispec("16<[a(8) {35}]", mnemonic="AND") +@ispec("16<[a(8) {36}]", mnemonic="ROL") +@ispec("16<[a(8) {55}]", mnemonic="EOR") +@ispec("16<[a(8) {56}]", mnemonic="LSR") +@ispec("16<[a(8) {74}]", mnemonic="STZ") +@ispec("16<[a(8) {75}]", mnemonic="ADC") +@ispec("16<[a(8) {76}]", mnemonic="ROR") +@ispec("16<[a(8) {94}]", mnemonic="STY") +@ispec("16<[a(8) {95}]", mnemonic="STA") +@ispec("16<[a(8) {b4}]", mnemonic="LDY") +@ispec("16<[a(8) {b5}]", mnemonic="LDA") +@ispec("16<[a(8) {d5}]", mnemonic="CMP") +@ispec("16<[a(8) {d6}]", mnemonic="DEC") +@ispec("16<[a(8) {f5}]", mnemonic="SBC") +@ispec("16<[a(8) {f6}]", mnemonic="INC") +def w65c02_zpx(obj, a): + adr = env.cst(a,16) + env.X_ + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# zero page indexed with Y : zp,y +# -------------------------- +@ispec("16<[a(8) {96}]", mnemonic="STX") +@ispec("16<[a(8) {b6}]", mnemonic="LDX") +def w65c02_zpy(obj, a): + adr = env.cst(a,16) + env.Y_ + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# zero page indirect: (zp) +# ------------------- +@ispec("16<[a(8) {12}]", mnemonic="ORA") +@ispec("16<[a(8) {32}]", mnemonic="AND") +@ispec("16<[a(8) {52}]", mnemonic="EOR") +@ispec("16<[a(8) {72}]", mnemonic="ADC") +@ispec("16<[a(8) {92}]", mnemonic="STA") +@ispec("16<[a(8) {b2}]", mnemonic="LDA") +@ispec("16<[a(8) {d2}]", mnemonic="CMP") +@ispec("16<[a(8) {f2}]", mnemonic="SBC") +def w65c02_zpi(obj, a): + adr = env.mem(env.cst(a,16),16) + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# zero page indirect indexed with Y: (zp),y +# ---------------------------------- +@ispec("16<[a(8) {11}]", mnemonic="ORA") +@ispec("16<[a(8) {31}]", mnemonic="AND") +@ispec("16<[a(8) {51}]", mnemonic="EOR") +@ispec("16<[a(8) {71}]", mnemonic="ADC") +@ispec("16<[a(8) {91}]", mnemonic="STA") +@ispec("16<[a(8) {b1}]", mnemonic="LDA") +@ispec("16<[a(8) {d1}]", mnemonic="CMP") +@ispec("16<[a(8) {f1}]", mnemonic="SBC") +def w65c02_zpiy(obj, a): + adr = env.mem(env.cst(a,16),16) + env.Y_ + obj.operands = [env.mem(adr,8)] + obj.type = type_data_processing + +# no-op (ignored): +# ---------------- +@ispec("8<[{02}]", mnemonic="NOP") +@ispec("8<[{03}]", mnemonic="NOP") +@ispec("8<[{0b}]", mnemonic="NOP") +@ispec("8<[{13}]", mnemonic="NOP") +@ispec("8<[{1b}]", mnemonic="NOP") +@ispec("8<[{22}]", mnemonic="NOP") +@ispec("8<[{23}]", mnemonic="NOP") +@ispec("8<[{2b}]", mnemonic="NOP") +@ispec("8<[{33}]", mnemonic="NOP") +@ispec("8<[{3b}]", mnemonic="NOP") +@ispec("8<[{42}]", mnemonic="NOP") +@ispec("8<[{43}]", mnemonic="NOP") +@ispec("8<[{44}]", mnemonic="NOP") +@ispec("8<[{4b}]", mnemonic="NOP") +@ispec("8<[{53}]", mnemonic="NOP") +@ispec("8<[{54}]", mnemonic="NOP") +@ispec("8<[{5b}]", mnemonic="NOP") +@ispec("8<[{5c}]", mnemonic="NOP") +@ispec("8<[{62}]", mnemonic="NOP") +@ispec("8<[{63}]", mnemonic="NOP") +@ispec("8<[{6b}]", mnemonic="NOP") +@ispec("8<[{73}]", mnemonic="NOP") +@ispec("8<[{7b}]", mnemonic="NOP") +@ispec("8<[{82}]", mnemonic="NOP") +@ispec("8<[{83}]", mnemonic="NOP") +@ispec("8<[{8b}]", mnemonic="NOP") +@ispec("8<[{93}]", mnemonic="NOP") +@ispec("8<[{9b}]", mnemonic="NOP") +@ispec("8<[{a3}]", mnemonic="NOP") +@ispec("8<[{ab}]", mnemonic="NOP") +@ispec("8<[{b3}]", mnemonic="NOP") +@ispec("8<[{bb}]", mnemonic="NOP") +@ispec("8<[{c2}]", mnemonic="NOP") +@ispec("8<[{c3}]", mnemonic="NOP") +@ispec("8<[{d3}]", mnemonic="NOP") +@ispec("8<[{d4}]", mnemonic="NOP") +@ispec("8<[{dc}]", mnemonic="NOP") +@ispec("8<[{e2}]", mnemonic="NOP") +@ispec("8<[{e3}]", mnemonic="NOP") +@ispec("8<[{eb}]", mnemonic="NOP") +@ispec("8<[{f3}]", mnemonic="NOP") +@ispec("8<[{f4}]", mnemonic="NOP") +@ispec("8<[{fb}]", mnemonic="NOP") +@ispec("8<[{fc}]", mnemonic="NOP") +def w65c02_nop(obj): + obj.operands = [] + obj.type = type_data_processing + diff --git a/amoco/arch/wasm/__init__.py b/amoco/arch/wasm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/amoco/arch/wasm/asm.py b/amoco/arch/wasm/asm.py new file mode 100644 index 0000000..6ba7177 --- /dev/null +++ b/amoco/arch/wasm/asm.py @@ -0,0 +1,299 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.arch.wasm.env import * + +# ------------------------------------------------------------------------------ +# low level functions : +def _push_(fmap, x): + assert x.size == WORD + fmap[stack_elt] = fmap[stack_elt] + 1 + fmap[sp] = fmap[sp] - (WORD // 8) + fmap[mem(sp, x.size)] = x + + +def _pop_(fmap): + x = fmap(mem(sp, WORD)) + fmap[sp] = fmap[sp] + (WORD // 8) + fmap[stack_elt] = fmap[stack_elt] - 1 + return x + + +def __pc(f): + def pcnpc(i, fmap): + fmap[op_ptr] = fmap[op_ptr] + i.length + f(i, fmap) + + return pcnpc + + +# ixxx is the translation of DWARF instruction xxx. +# ------------------------------------------------------------------------------ + + +@__pc +def i_DW_OP_skip(i, fmap): + fmap[op_ptr] = fmap(op_ptr + i.operands[0]) + + +@__pc +def i_DW_OP_bra(i, fmap): + cond = _pop_(fmap) + fmap[op_ptr] = tst(cond != 0, fmap(op_ptr + i.operands[0]), fmap(op_ptr)) + + +@__pc +def i_DW_OP_nop(i, fmap): + pass + + +@__pc +def i_DW_OP_lit(i, fmap): + _push_(fmap, i.operands[0]) + + +@__pc +def i_DW_OP_addr(i, fmap): + _push_(fmap, i.operands[0]) + + +@__pc +def i_DW_OP_GNU_encoded_addr(i, fmap): + _push_(fmap, i.operands[0]) + + +@__pc +def i_DW_OP_const(i, fmap): + _push_(fmap, i.operands[0]) + + +@__pc +def i_DW_OP_reg(i, fmap): + _push_(fmap, fmap(i.operands[0])) + + +@__pc +def i_DW_OP_regx(i, fmap): + _push_(fmap, fmap(i.operands[0])) + + +@__pc +def i_DW_OP_breg(i, fmap): + _push_(fmap, fmap(i.operands[0])) + + +@__pc +def i_DW_OP_bregx(i, fmap): + _push_(fmap, fmap(i.operands[0])) + + +@__pc +def i_DW_OP_dup(i, fmap): + x = fmap(mem(sp, WORD)) + _push_(fmap, x) + + +@__pc +def i_DW_OP_drop(i, fmap): + _pop_(fmap) + + +@__pc +def i_DW_OP_pick(i, fmap): + index = i.operands[0] * (WORD // 8) + x = fmap(mem(sp + index, WORD)) + _push_(fmap, x) + + +@__pc +def i_DW_OP_over(i, fmap): + index = WORD // 8 + x = fmap(mem(sp + index, WORD)) + _push_(fmap, x) + + +@__pc +def i_DW_OP_swap(i, fmap): # [x,y,...] -> [y,x,...] + index = WORD // 8 + x = fmap(mem(sp, WORD)) + y = fmap(mem(sp + index, WORD)) + fmap[mem(sp, WORD)] = y + fmap[mem(sp + index, WORD)] = x + + +@__pc +def i_DW_OP_rot(i, fmap): # [x,y,z,...] -> [y,z,x,...] + index = WORD // 8 + x = fmap(mem(sp, WORD)) + y = fmap(mem(sp + index, WORD)) + z = fmap(mem(sp + index + index, WORD)) + fmap[mem(sp, WORD)] = y + fmap[mem(sp + index, WORD)] = z + fmap[mem(sp + index + index, WORD)] = x + + +@__pc +def i_DW_OP_deref(i, fmap): + x = _pop_(fmap) + _push_(fmap, fmap[mem(x, WORD)]) + + +@__pc +def i_DW_OP_deref_size(i, fmap): + x = _pop_(fmap) + size = i.operands[0] * 8 + result = fmap[mem(x, size)].zeroextend(WORD) + _push_(fmap, result) + + +@__pc +def i_DW_OP_abs(i, fmap): + x = _pop_(fmap) + result = tst(x[WORD - 1 : WORD] == 1, -x, x) + _push_(fmap, result) + + +@__pc +def i_DW_OP_abs(i, fmap): + x = _pop_(fmap) + _push_(fmap, -x) + + +@__pc +def i_DW_OP_not(i, fmap): + x = _pop_(fmap) + _push_(fmap, ~x) + + +@__pc +def i_DW_OP_plus_uconst(i, fmap): + x = _pop_(fmap) + _push_(fmap, x + i.operands[0]) + + +@__pc +def i_DW_OP_and(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x & y) + + +@__pc +def i_DW_OP_div(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x / y) + + +@__pc +def i_DW_OP_minus(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x - y) + + +@__pc +def i_DW_OP_mod(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x % y) + + +@__pc +def i_DW_OP_mul(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x * y) + + +@__pc +def i_DW_OP_or(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x | y) + + +@__pc +def i_DW_OP_plus(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x + y) + + +@__pc +def i_DW_OP_shl(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x << y) + + +@__pc +def i_DW_OP_shr(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x >> y) + + +@__pc +def i_DW_OP_shra(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x // y) + + +@__pc +def i_DW_OP_xor(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + _push_(fmap, x ^ y) + + +@__pc +def i_DW_OP_le(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x <= y).zeroextend(WORD) + _push_(fmap, t) + + +@__pc +def i_DW_OP_ge(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x >= y).zeroextend(WORD) + _push_(fmap, t) + + +@__pc +def i_DW_OP_eq(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x == y).zeroextend(WORD) + _push_(fmap, t) + + +@__pc +def i_DW_OP_lt(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x < y).zeroextend(WORD) + _push_(fmap, t) + + +@__pc +def i_DW_OP_gt(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x > y).zeroextend(WORD) + _push_(fmap, t) + + +@__pc +def i_DW_OP_neq(i, fmap): + y = _pop_(fmap) + x = _pop_(fmap) + t = (x != y).zeroextend(WORD) + _push_(fmap, t) diff --git a/amoco/arch/wasm/cpu.py b/amoco/arch/wasm/cpu.py new file mode 100644 index 0000000..bc6fea3 --- /dev/null +++ b/amoco/arch/wasm/cpu.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- + +from amoco.arch.wasm.asm import * + +uarch = dict(filter(lambda kv: kv[0].startswith("i_"), locals().items())) + +# import specifications: +from amoco.arch.core import instruction, disassembler + +instruction_wasm = type("instruction_wasm", (instruction,), {}) +instruction_wasm.set_uarch(uarch) + +from amoco.arch.wasm.formats import DW_full + +instruction_wasm.set_formatter(DW_full) + +# define disassembler: +from amoco.arch.wasm import spec + +disassemble = disassembler([spec], iclass=instruction_wasm) + +# wasm instructions are fully determined with 1 byte only, but the operands +# are encoded in leb128 form for 32 or 33 bits integers. Wasm enforces a leb128 +# encoding of ceil(N/7), leading to at most 5 bytes for one leb128 value. +# Since most instructions have not more than 3 operands we set the maxlen to 16. +# If an instruction needs more bytes in must rely on the xdata API (see arch.core.) +disassemble.maxlen = 16 + + +def PC(): + return op_ptr + + +def get_data_endian(): + return 1 diff --git a/amoco/arch/wasm/env.py b/amoco/arch/wasm/env.py new file mode 100644 index 0000000..8cfe8c7 --- /dev/null +++ b/amoco/arch/wasm/env.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +# import expressions: +from amoco.cas.expressions import * + +# symbols from libgcc/unwind-dw2.c : +# ----------------------------------- + +WORD = 64 + +with is_reg_pc: + op_ptr = reg("op_ptr", 64) + +with is_reg_stack: + sp = reg("sp", 64) + +stack_elt = reg("stack_elt", 6) + +registers = [op_ptr, sp, stack_elt] + +i32 = sym("i32",0x7f,8) +i64 = sym("i64",0x7e,8) +f32 = sym("f32",0x7d,8) +f64 = sym("f64",0x7c,8) + +numtype = { + 0x7f:i32, + 0x7e:i64, + 0x7d:f32, + 0x7c:f64, +} + +funcref = sym("funcref",0x70,8) +externref = sym("externref",0x6f,8) + +reftype = { + 0x70:funcref, + 0x6f:externref, +} + +valtype = dict(numtype).update(reftype) diff --git a/amoco/arch/wasm/formats.py b/amoco/arch/wasm/formats.py new file mode 100644 index 0000000..32395eb --- /dev/null +++ b/amoco/arch/wasm/formats.py @@ -0,0 +1,58 @@ +# -*- coding: utf-8 -*- + +from .env import * +from amoco.arch.core import Formatter +from amoco.ui.render import Token, TokenListJoin + + +def mnemo(i): + m = i.mnemonic.replace("DW_OP_", "") + return [(Token.Mnemonic, "%s" % (m.lower()).ljust(12))] + + +def mnemo_lit(i): + return [(Token.Mnemonic, "lit%d" % i.operands[0])] + + +def mnemo_reg(i): + return [(Token.Mnemonic, str(i.operands[0]))] + + +def mnemo_breg(i): + return [(Token.Mnemonic, "b%s" % (i.operands[0]))] + + +def hexarg(i): + if len(i.operands) > 0: + return [(Token.Constant, "%x" % (i.operands[0]))] + else: + return [] + + +def intarg(i): + return [(Token.Constant, str(i.operands[0]))] + + +def adrarg(i): + loc = i.operands[0] + return [(Token.Address, str(loc))] + + +def relarg(i): + off = i.operands[0] + loc = i.address + i.length + off + return [(Token.Address, str(loc))] + + +DW_full_formats = { + "dw_op_0": [mnemo], + "dw_op_jmp": [mnemo, relarg], + "dw_op_1": [mnemo, intarg], + "dw_op_addr": [mnemo, adrarg], + "dw_op_lit": [mnemo_lit], + "dw_op_reg": [mnemo_reg], + "dw_op_breg": [mnemo_breg], +} + +DW_full = Formatter(DW_full_formats) +DW_full.default = [mnemo, hexarg] diff --git a/amoco/arch/wasm/spec.py b/amoco/arch/wasm/spec.py new file mode 100644 index 0000000..891be27 --- /dev/null +++ b/amoco/arch/wasm/spec.py @@ -0,0 +1,371 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +# spec_xxx files are providers for instruction objects. +# These objects are wrapped and created by disasm.py. + +from amoco.logger import Log + +logger = Log(__name__) +logger.debug("loading module") +from amoco.arch.core import * +from amoco.arch.wasm import env +from amoco.system.utils import read_leb128, read_uleb128, read_sleb128 + +ISPECS = [] + + +@ispec("8>[ {00} ]", mnemonic="unreachable") +@ispec("8>[ {01} ]", mnemonic="nop") +@ispec("8>[ {d1} ]", mnemonic="ref",action="is_null") +@ispec("8>[ {1a} ]", mnemonic="drop") +@ispec("8>[ {1b} ]", mnemonic="select") +@ispec("8>[ {45} ]", mntype="i32", mnemonic="eqz") +@ispec("8>[ {46} ]", mntype="i32", mnemonic="eq") +@ispec("8>[ {47} ]", mntype="i32", mnemonic="ne") +@ispec("8>[ {48} ]", mntype="i32", mnemonic="lt_s") +@ispec("8>[ {49} ]", mntype="i32", mnemonic="lt_u") +@ispec("8>[ {4a} ]", mntype="i32", mnemonic="gt_s") +@ispec("8>[ {4b} ]", mntype="i32", mnemonic="gt_u") +@ispec("8>[ {4c} ]", mntype="i32", mnemonic="le_s") +@ispec("8>[ {4d} ]", mntype="i32", mnemonic="le_u") +@ispec("8>[ {4e} ]", mntype="i32", mnemonic="ge_s") +@ispec("8>[ {4f} ]", mntype="i32", mnemonic="ge_u") +@ispec("8>[ {50} ]", mntype="i64", mnemonic="eqz") +@ispec("8>[ {51} ]", mntype="i64", mnemonic="eq") +@ispec("8>[ {52} ]", mntype="i64", mnemonic="ne") +@ispec("8>[ {53} ]", mntype="i64", mnemonic="lt_s") +@ispec("8>[ {54} ]", mntype="i64", mnemonic="lt_u") +@ispec("8>[ {55} ]", mntype="i64", mnemonic="gt_s") +@ispec("8>[ {56} ]", mntype="i64", mnemonic="gt_u") +@ispec("8>[ {57} ]", mntype="i64", mnemonic="le_s") +@ispec("8>[ {58} ]", mntype="i64", mnemonic="le_u") +@ispec("8>[ {59} ]", mntype="i64", mnemonic="ge_s") +@ispec("8>[ {5a} ]", mntype="i64", mnemonic="ge_u") +@ispec("8>[ {5b} ]", mntype="f32", mnemonic="eq") +@ispec("8>[ {5c} ]", mntype="f32", mnemonic="ne") +@ispec("8>[ {5d} ]", mntype="f32", mnemonic="lt") +@ispec("8>[ {5e} ]", mntype="f32", mnemonic="gt") +@ispec("8>[ {5f} ]", mntype="f32", mnemonic="le") +@ispec("8>[ {60} ]", mntype="f32", mnemonic="ge") +@ispec("8>[ {61} ]", mntype="f64", mnemonic="eq") +@ispec("8>[ {62} ]", mntype="f64", mnemonic="ne") +@ispec("8>[ {63} ]", mntype="f64", mnemonic="lt") +@ispec("8>[ {64} ]", mntype="f64", mnemonic="gt") +@ispec("8>[ {65} ]", mntype="f64", mnemonic="le") +@ispec("8>[ {66} ]", mntype="f64", mnemonic="ge") +@ispec("8>[ {67} ]", mntype="i32", mnemonic="clz") +@ispec("8>[ {68} ]", mntype="i32", mnemonic="ctz") +@ispec("8>[ {69} ]", mntype="i32", mnemonic="popcnt") +@ispec("8>[ {6a} ]", mntype="i32", mnemonic="add") +@ispec("8>[ {6b} ]", mntype="i32", mnemonic="sub") +@ispec("8>[ {6c} ]", mntype="i32", mnemonic="mul") +@ispec("8>[ {6d} ]", mntype="i32", mnemonic="div_s") +@ispec("8>[ {6e} ]", mntype="i32", mnemonic="div_u") +@ispec("8>[ {6f} ]", mntype="i32", mnemonic="rem_s") +@ispec("8>[ {70} ]", mntype="i32", mnemonic="rem_u") +@ispec("8>[ {71} ]", mntype="i32", mnemonic="and") +@ispec("8>[ {72} ]", mntype="i32", mnemonic="or") +@ispec("8>[ {73} ]", mntype="i32", mnemonic="xor") +@ispec("8>[ {74} ]", mntype="i32", mnemonic="shl") +@ispec("8>[ {75} ]", mntype="i32", mnemonic="shr_s") +@ispec("8>[ {76} ]", mntype="i32", mnemonic="shr_u") +@ispec("8>[ {77} ]", mntype="i32", mnemonic="rotl") +@ispec("8>[ {78} ]", mntype="i32", mnemonic="rotr") +@ispec("8>[ {79} ]", mntype="i64", mnemonic="clz") +@ispec("8>[ {7a} ]", mntype="i64", mnemonic="ctz") +@ispec("8>[ {7b} ]", mntype="i64", mnemonic="popcnt") +@ispec("8>[ {7c} ]", mntype="i64", mnemonic="add") +@ispec("8>[ {7d} ]", mntype="i64", mnemonic="sub") +@ispec("8>[ {7e} ]", mntype="i64", mnemonic="mul") +@ispec("8>[ {7f} ]", mntype="i64", mnemonic="div_s") +@ispec("8>[ {80} ]", mntype="i64", mnemonic="div_u") +@ispec("8>[ {81} ]", mntype="i64", mnemonic="rem_s") +@ispec("8>[ {82} ]", mntype="i64", mnemonic="rem_u") +@ispec("8>[ {83} ]", mntype="i64", mnemonic="and") +@ispec("8>[ {84} ]", mntype="i64", mnemonic="or") +@ispec("8>[ {85} ]", mntype="i64", mnemonic="xor") +@ispec("8>[ {86} ]", mntype="i64", mnemonic="shl") +@ispec("8>[ {87} ]", mntype="i64", mnemonic="shr_s") +@ispec("8>[ {88} ]", mntype="i64", mnemonic="shr_u") +@ispec("8>[ {89} ]", mntype="i64", mnemonic="rotl") +@ispec("8>[ {8a} ]", mntype="i64", mnemonic="rotr") +@ispec("8>[ {8b} ]", mntype="f32", mnemonic="abs") +@ispec("8>[ {8c} ]", mntype="f32", mnemonic="neg") +@ispec("8>[ {8d} ]", mntype="f32", mnemonic="ceil") +@ispec("8>[ {8e} ]", mntype="f32", mnemonic="floor") +@ispec("8>[ {8f} ]", mntype="f32", mnemonic="trunc") +@ispec("8>[ {90} ]", mntype="f32", mnemonic="nearest") +@ispec("8>[ {91} ]", mntype="f32", mnemonic="sqrt") +@ispec("8>[ {92} ]", mntype="f32", mnemonic="add") +@ispec("8>[ {93} ]", mntype="f32", mnemonic="sub") +@ispec("8>[ {94} ]", mntype="f32", mnemonic="mul") +@ispec("8>[ {95} ]", mntype="f32", mnemonic="div") +@ispec("8>[ {96} ]", mntype="f32", mnemonic="min") +@ispec("8>[ {97} ]", mntype="f32", mnemonic="max") +@ispec("8>[ {98} ]", mntype="f32", mnemonic="copysign") +@ispec("8>[ {99} ]", mntype="f64", mnemonic="abs") +@ispec("8>[ {9a} ]", mntype="f64", mnemonic="neg") +@ispec("8>[ {9b} ]", mntype="f64", mnemonic="ceil") +@ispec("8>[ {9c} ]", mntype="f64", mnemonic="floor") +@ispec("8>[ {9d} ]", mntype="f64", mnemonic="trunc") +@ispec("8>[ {9e} ]", mntype="f64", mnemonic="nearest") +@ispec("8>[ {9f} ]", mntype="f64", mnemonic="sqrt") +@ispec("8>[ {a0} ]", mntype="f64", mnemonic="add") +@ispec("8>[ {a1} ]", mntype="f64", mnemonic="sub") +@ispec("8>[ {a2} ]", mntype="f64", mnemonic="mul") +@ispec("8>[ {a3} ]", mntype="f64", mnemonic="div") +@ispec("8>[ {a4} ]", mntype="f64", mnemonic="min") +@ispec("8>[ {a5} ]", mntype="f64", mnemonic="max") +@ispec("8>[ {a6} ]", mntype="f64", mnemonic="copysign") +@ispec("8>[ {a7} ]", mntype="i32", mnemonic="wrap_i64") +@ispec("8>[ {a8} ]", mntype="i32", mnemonic="trunc_f32_s") +@ispec("8>[ {a9} ]", mntype="i32", mnemonic="trunc_f32_u") +@ispec("8>[ {aa} ]", mntype="i32", mnemonic="trunc_f64_s") +@ispec("8>[ {ab} ]", mntype="i32", mnemonic="trunc_f64_u") +@ispec("8>[ {ac} ]", mntype="i64", mnemonic="extend_i32_s") +@ispec("8>[ {ad} ]", mntype="i64", mnemonic="extend_i32_u") +@ispec("8>[ {ae} ]", mntype="i64", mnemonic="trunc_f32_s") +@ispec("8>[ {af} ]", mntype="i64", mnemonic="trunc_f32_u") +@ispec("8>[ {b0} ]", mntype="i64", mnemonic="trunc_f64_s") +@ispec("8>[ {b1} ]", mntype="i64", mnemonic="trunc_f64_u") +@ispec("8>[ {b2} ]", mntype="f32", mnemonic="convert_i32_s") +@ispec("8>[ {b3} ]", mntype="f32", mnemonic="convert_i32_u") +@ispec("8>[ {b4} ]", mntype="f32", mnemonic="convert_i64_s") +@ispec("8>[ {b5} ]", mntype="f32", mnemonic="convert_i64_u") +@ispec("8>[ {b6} ]", mntype="f32", mnemonic="demote_f64") +@ispec("8>[ {b7} ]", mntype="f64", mnemonic="convert_i32_s") +@ispec("8>[ {b8} ]", mntype="f64", mnemonic="convert_i32_u") +@ispec("8>[ {b9} ]", mntype="f64", mnemonic="convert_i64_s") +@ispec("8>[ {ba} ]", mntype="f64", mnemonic="convert_i64_u") +@ispec("8>[ {bb} ]", mntype="f64", mnemonic="promote_f32") +@ispec("8>[ {bc} ]", mntype="i32", mnemonic="reinterpret_f32") +@ispec("8>[ {bd} ]", mntype="i64", mnemonic="reinterpret_f64") +@ispec("8>[ {be} ]", mntype="f32", mnemonic="reinterpret_i32") +@ispec("8>[ {bf} ]", mntype="f64", mnemonic="reinterpret_i64") +@ispec("8>[ {c0} ]", mntype="i32", mnemonic="extend8_s") +@ispec("8>[ {c1} ]", mntype="i32", mnemonic="extend16_s") +@ispec("8>[ {c2} ]", mntype="i64", mnemonic="extend8_s") +@ispec("8>[ {c3} ]", mntype="i64", mnemonic="extend16_s") +@ispec("8>[ {c4} ]", mntype="i64", mnemonic="extend32_s") +def dw_op_0(obj): + obj.operands = [] + obj.type = type_data_processing + +@ispec("8>[ {0b} ]", mnemonic="end") +@ispec("8>[ {0f} ]", mnemonic="return") +@ispec("8>[ {05} ]", mnemonic="else") +def dw_op_0(obj): + obj.operands = [] + obj.type = type_control_flow + +@ispec("16>[ {d0} t(8) ]", mnemonic="ref",action="null") +def dw_reftype(obj,t): + if t in env.reftype: + obj.operands = [env.reftype[t]] + else: + raise InstructionError(obj) + obj.type = type_data_processing + +@ispec("16>[ {3f} {00} ]", mnemonic="memory",action="size") +@ispec("16>[ {40} {00} ]", mnemonic="memory",action="grow") +def dw_memory(obj): + obj.operands = [] + obj.type = type_data_processing + +def xdata_select(obj,**kargs): + addr = kargs['address'] + code = kargs['code'] + obj.t = [] + addr = addr+len(obj.bytes) + off = 0 + for l in range(obj.x): + n, sz = read_leb128(code,1,addr+off) + obj.t.append(n) + off += sz + obj.operands[0] = obj.t + obj.bytes += code[addr:addr+off] + +@ispec("*>[ {d2} ~data(*) ]", mnemonic="ref",action="func") +@ispec("*>[ {1c} ~data(*) ] &", mnemonic="select") +@ispec("*>[ {20} ~data(*) ]", mnemonic="local", action="get") +@ispec("*>[ {21} ~data(*) ]", mnemonic="local", action="set") +@ispec("*>[ {22} ~data(*) ]", mnemonic="local", action="tee") +@ispec("*>[ {23} ~data(*) ]", mnemonic="global", action="get") +@ispec("*>[ {24} ~data(*) ]", mnemonic="global", action="set") +@ispec("*>[ {25} ~data(*) ]", mnemonic="table", action="get") +@ispec("*>[ {26} ~data(*) ]", mnemonic="table", action="set") +def dw_uleb128(obj, data): + data = pack(data) + obj.x,blen = read_uleb128(data) + obj.bytes += data[0:blen] + obj.operands = [obj.x] + obj.type = type_data_processing + if obj.mnemonic=="select": + obj.xdata = xdata_select + +@ispec("*>[ {41} ~data(*) ]", mnemonic="i32") +@ispec("*>[ {42} ~data(*) ]", mnemonic="i64") +@ispec("*>[ {43} ~data(*) ]", mnemonic="f32") +@ispec("*>[ {44} ~data(*) ]", mnemonic="f64") +def dw_uleb128(obj, data): + data = pack(data) + obj.n,blen = read_uleb128(data) + obj.bytes += data[0:blen] + obj.operands = [obj.n] + obj.action = "const" + obj.type = type_data_processing + +@ispec("*>[ {fc} ~data(*) ]", mnemonic="table") +def dw_table(obj, data): + data = pack(data) + v,blen = read_uleb128(data) + obj.bytes += data[0:blen] + obj.type = type_data_processing + if v>17: + raise InstructionError(obj) + if v<8: + obj.mntype = "i32" if v<4 else "i64" + post = "f32" if v in (0,2,4,5) else "f64" + su = "_s" if v%2==0 else "_u" + obj.mnemonic = "trunc_sat_"+post+su + if v==10: + obj.mnemonic = "memory" + obj.action = "copy" + if data[blen:blen+2]!=b'\x00\x00': + raise InstructionError(obj) + obj.bytes += data[blen:blen+2] + return + elif v==11: + obj.mnemonic = "memory" + obj.action = "fill" + if data[blen:blen+1]!=b'\x00': + raise InstructionError(obj) + obj.bytes += data[blen:blen+1] + return + data = data[blen:] + obj.x,blen1 = read_leb128(data,1,0) + obj.bytes += data[0:blen1] + if v==8: + obj.mnemonic = "memory" + obj.action = "init" + if data[blen1:blen1+1]!=b'\x00': + raise InstructionError(obj) + obj.bytes += data[blen1:blen1+1] + elif v==9: + obj.mnemonic = "data" + obj.action = "drop" + elif v==12: + obj.y = obj.x + obj.x,blen2 = read_leb128(data,1,blen1) + obj.bytes += data[blen1:blen1+blen2] + obj.action = "init" + elif v==13: + obj.mnemonic = "elem" + obj.action = "drop" + elif v==14: + obj.y,blen2 = read_leb128(data,1,blen1) + obj.bytes += data[blen1:blen1+blen2] + obj.action = "copy" + else: + obj.action = {15:"grow",16:"size",17:"fill"}[v] + +@ispec("*>[ {02} ~data(*) ]", mnemonic="block") +@ispec("*>[ {03} ~data(*) ]", mnemonic="loop") +@ispec("*>[ {04} ~data(*) ]", mnemonic="if") +def dw_op_block(obj, data): + data = pack(data) + bt = data[0] + if bt == 0x40: + obj.bt = 0x40 + obj.bytes += data[0:1] + elif bt in env.valtype: + obj.bt = env.valtype[bt] + obj.bytes += data[0:1] + else: + obj.bt,blen = read_sleb128(data) + obj.bytes += data[0:blen] + obj.operands = [obj.bt] + obj.type = type_control_flow + +def xdata_br_table(obj,**kargs): + addr = kargs['address'] + code = kargs['code'] + obj.labels = [] + addr += len(obj.bytes) + off = 0 + for l in range(obj.l): + n, sz = read_leb128(code,1,addr+off) + obj.labels.append(n) + off += sz + n, sz = read_leb128(code,1,addr+off) + obj.default = n + off += sz + obj.bytes += code[addr:addr+off] + +@ispec("*>[ {0c} ~data(*) ]", mnemonic="br") +@ispec("*>[ {0d} ~data(*) ]", mnemonic="br_if") +@ispec("*>[ {0e} ~data(*) ] &", mnemonic="br_table") +def dw_op_br(obj, data): + data = pack(data) + obj.l,blen = read_uleb128(data) + obj.bytes += data[0:blen] + obj.operands = [obj.l] + obj.type = type_control_flow + if obj.mnemonic=="br_table": + obj.xdata = xdata_br_table + +def xdata_call_indirect(obj,**kargs): + addr = kargs['address'] + code = kargs['code'] + off = 0 + n, sz = read_leb128(code,1,addr+off) + obj.y = n + obj.operands.append(obj.y) + off += sz + obj.bytes += code[addr:addr+off] + +@ispec("*>[ {10} ~data(*) ]", mnemonic="call") +@ispec("*>[ {11} ~data(*) ] &", mnemonic="call_indirect") +def dw_op_call(obj, data): + data = pack(data) + obj.x,blen = read_uleb128(data) + obj.bytes += data[0:blen] + obj.operands = [obj.x] + obj.type = type_control_flow + if obj.mnemonic=="call_indirect": + obj.xdata = xdata_call_indirect + +@ispec("*>[ {28} ~data(*) ]", mnemonic="i32", action="load") +@ispec("*>[ {29} ~data(*) ]", mnemonic="i64", action="load") +@ispec("*>[ {2a} ~data(*) ]", mnemonic="f32", action="load") +@ispec("*>[ {2b} ~data(*) ]", mnemonic="f64", action="load") +@ispec("*>[ {2c} ~data(*) ]", mnemonic="i32", action="load8_s") +@ispec("*>[ {2d} ~data(*) ]", mnemonic="i32", action="load8_u") +@ispec("*>[ {2e} ~data(*) ]", mnemonic="i32", action="load16_s") +@ispec("*>[ {2f} ~data(*) ]", mnemonic="i32", action="load16_u") +@ispec("*>[ {30} ~data(*) ]", mnemonic="i64", action="load8_s") +@ispec("*>[ {31} ~data(*) ]", mnemonic="i64", action="load8_u") +@ispec("*>[ {32} ~data(*) ]", mnemonic="i64", action="load16_s") +@ispec("*>[ {33} ~data(*) ]", mnemonic="i64", action="load16_u") +@ispec("*>[ {34} ~data(*) ]", mnemonic="i64", action="load32_s") +@ispec("*>[ {35} ~data(*) ]", mnemonic="i64", action="load32_u") +@ispec("*>[ {36} ~data(*) ]", mnemonic="i32", action="store") +@ispec("*>[ {37} ~data(*) ]", mnemonic="i64", action="store") +@ispec("*>[ {38} ~data(*) ]", mnemonic="f32", action="store") +@ispec("*>[ {39} ~data(*) ]", mnemonic="f64", action="store") +@ispec("*>[ {3a} ~data(*) ]", mnemonic="i32", action="store8") +@ispec("*>[ {3b} ~data(*) ]", mnemonic="i32", action="store16") +@ispec("*>[ {3c} ~data(*) ]", mnemonic="i64", action="store8") +@ispec("*>[ {3d} ~data(*) ]", mnemonic="i64", action="store16") +@ispec("*>[ {3e} ~data(*) ]", mnemonic="i64", action="store32") +def dw_memarg(obj, data): + data = pack(data) + obj.a,blen1 = read_leb128(data,1,0) + obj.bytes += data[0:blen] + obj.o,blen2 = read_leb128(data,1,blen1) + obj.bytes += data[blen:blen1+blen2] + obj.type = type_data_processing diff --git a/amoco/cas/mapper.py b/amoco/cas/mapper.py index cca3b94..d7964ce 100644 --- a/amoco/cas/mapper.py +++ b/amoco/cas/mapper.py @@ -33,8 +33,8 @@ class mapper(object): Args: instrlist (list[instruction]): a list of instructions that are symbolically executed within the mapper. - csi (Optional[object]): the optional csi attribute that provide - a *concrete* initial state + cur (Optional[object]): the optional cursor attribute that provide + a reference to the task associated with the mapper Attributes: __map : is an ordered list of mappings of expressions associated with a @@ -44,18 +44,18 @@ class mapper(object): __Mem : is a memory model where symbolic memory pointers are addressing separated memory zones. See MemoryMap and MemoryZone classes. conds : is the list of conditions that must be True for the mapper - csi : is the optional interface to a *concrete* state + cur : is the optional interface to a task. """ - __slots__ = ["__map", "__Mem", "conds", "csi", "view"] + __slots__ = ["__map", "__Mem", "conds", "cur", "view"] - def __init__(self, instrlist=None, csi=None): + def __init__(self, instrlist=None, cur=None): self.__map = generation() self.__map.lastw = 0 self.__map.delayed = None self.__Mem = MemoryMap() self.conds = [] - self.csi = csi + self.cur = cur icache = [] # if the __map needs to be inited before executing instructions # one solution is to prepend the instrlist with a function dedicated @@ -162,10 +162,7 @@ def __iter__(self): def R(self, x): "get the expression of register x" - if self.csi: - return self.__map.get(x, self.csi(x)) - else: - return self.__map.get(x, x) + return self.__map.get(x, x) def M(self, k): """get the expression of a memory location expression k""" @@ -217,14 +214,14 @@ def _Mem_read(self, a, l, endian=1): cur = 0 for p in res: plen = len(p) - if isinstance(p, exp) and (p._is_def == 0): - # p is "bottom": - if self.csi: - p = self.csi(mem(a, p.size, disp=cur, endian=endian)) - else: - p = mem(a, p.size, disp=cur) if isinstance(p, bytes): p = cst(Bits(p[::endian], bitorder=1).int(), plen * 8) + elif isinstance(p, exp): + if p._is_def == 0: + # p is "bottom": + p = mem(a, p.size, disp=cur) + elif p._is_ext and p._subrefs.get("mmio_r",None): + p = p.stub(self,mode="r") P.append(p) cur += plen return composer(P) @@ -236,7 +233,14 @@ def _Mem_write(self, a, v, endian=1): else: locs = (a,) for l in locs: - self.__Mem.write(l, v, endian) + try: + oldv = self.__Mem.read(l,len(v))[0] + except MemoryError: + oldv = l + if isinstance(oldv,ext) and oldv._subrefs.get("mmio_w",None): + oldv.stub(self,mode="w") + else: + self.__Mem.write(l, v, endian) if l in self.__map: del self.__map[l] @@ -255,6 +259,7 @@ def __setitem__(self, k, v): if k.size != v.size: raise ValueError("size mismatch") try: + # evaluate current location address: loc = k.addr(self) except TypeError: logger.error("setitem ignored (invalid left-value expression: %s)" % k) @@ -321,7 +326,7 @@ def eval(self, m): """return a new mapper instance where all input locations have been replaced by there corresponding values in m. """ - mm = mapper(csi=self.csi) + mm = mapper(cur=self.cur) mm.setmemory(self.mmap.copy()) for c in self.conds: cc = c.eval(m) @@ -378,7 +383,7 @@ def use(self, *args, **kargs): sizes for all arguments. if kargs is empty, a copy of the result is just a copy of current mapper. """ - m = mapper(csi=self.csi) + m = mapper(cur=self.cur) for loc, v in args: m[loc] = v if len(kargs) > 0: @@ -401,7 +406,7 @@ def usemmap(self, mmap): # attach/apply conditions to the output mapper def assume(self, conds): - m = mapper(csi=self.csi) + m = mapper(cur=self.cur) if conds is None: conds = [] for c in conds: diff --git a/amoco/config.py b/amoco/config.py index 8cff403..b9cd8bc 100644 --- a/amoco/config.py +++ b/amoco/config.py @@ -46,6 +46,7 @@ - 'graphics' one of 'term' (default), 'qt' or 'gtk' - 'console' one of 'python' (default), or 'ipython' - 'unicode' will use unicode symbols for drawing lines and icons if True + - 'qstylesheet' filename of a Qt Stylesheet or '' (default) - 'Server' which deals with amoco's server parameters: @@ -155,6 +156,7 @@ class UI(Configurable): console (str): default python console, either 'python' (default) or 'ipython'. completekey (str): client key for command completion (Tab). cli (str): client frontend. Currently only 'cmdcli' is supported. + qstylesheet (str): Qt stylesheet filename (default to ""). """ formatter = Unicode("Null", config=True) graphics = Unicode("term", config=True) @@ -162,6 +164,7 @@ class UI(Configurable): completekey = Unicode("tab", config=True) cli = Unicode("cmdcli", config=True) unicode = Bool(False, config=True) + qstylesheet = Unicode("", config=True) class Server(Configurable): @@ -223,10 +226,12 @@ class System(Configurable): pagesize (int): provides the default memory page size in bytes. aslr (Bool): simulates ASLR if True. (not supported yet.) nx (Bool): unused. + romfile (Unicode): path to ROM file. """ pagesize = Integer(4096, config=True) aslr = Bool(False, config=True) nx = Bool(False, config=True) + romfile = Unicode("apple2.rom",config=True) class Config(object): diff --git a/amoco/emu.py b/amoco/emu.py index d2bff88..75be938 100644 --- a/amoco/emu.py +++ b/amoco/emu.py @@ -24,6 +24,9 @@ logger = Log(__name__) logger.debug("loading emu") +class EmulError(Exception): + pass + class emul(object): def __init__(self, task): @@ -41,9 +44,14 @@ def __init__(self, task): self.sa = lsweep(task) self.hist = deque(maxlen=conf.Emu.hist) self.view = emulView(self) + self.handlers[EmulError] = self.stop + self.handlers[DecodeError] = self.stop def stepi(self,trace=False): - addr = self.task.getx(self.pc) + addr = self.task.state(self.pc) + if addr._is_top: + logger.warning("%s has reached top value") + raise EmulError() i = self.task.read_instruction(addr) if i is not None: if trace: @@ -70,7 +78,10 @@ def iterate(self,trace=False): logger.info("stop iteration due to %s"%reason.__doc__) break try: - addr = self.task.getx(self.pc) + addr = self.task.state(self.pc) + if addr._is_top: + raise EmulError() + print("%s: %s"%(type(addr),addr)) lasti = i = self.task.read_instruction(addr) if trace: ops_v = [(self.task.state(o),o) for o in i.operands] @@ -206,3 +217,5 @@ def check(e,prev,mnemo=mnemonic,xdest=dst,xsrc=src): check.__doc__ = doc self.hooks.append(check) + def stop(self,*args,**kargs): + return False diff --git a/amoco/logger.py b/amoco/logger.py index 93dde01..6ebb784 100644 --- a/amoco/logger.py +++ b/amoco/logger.py @@ -43,7 +43,7 @@ logging.addLevelName(VERBOSE, "VERBOSE") # logging.captureWarnings(True) -default_format = logging.Formatter("[%(levelname)-7s] %(name)-24s: %(message)s") +default_format = logging.Formatter("[%(levelname)-7s] %(name)-32s: %(message)s") from amoco.config import conf diff --git a/amoco/sa/ghidra.py b/amoco/sa/ghidra.py new file mode 100644 index 0000000..46d441e --- /dev/null +++ b/amoco/sa/ghidra.py @@ -0,0 +1,94 @@ +import ghidra_bridge + +b = ghidra_bridge.GhidraBridge(namespace=__module__.__dict__) + +def select_range(begin,end): + from ghidra.program.model.address import setCurrentSelection, AddressSet + setCurrentSelection(AddressSet(toAddr(begin),toAddr(end))) + +def add_memory_block(name,start,size,val=None,access="rw"): + mmap = currentProgram.memory + blk = mmap.createInitializedBlock(name, toAddr(start), size, + val, monitor, False) + if "w" in access: + blk.setWrite(True) + + if "x" in access: + blk.setExecute(True) + + return blk + +def setPointer(address,size=4): + from ghidra.program.model.data import PointerDataType + if isinstance(address,int): + address = toAddr(address) + ls = currentProgram.getListing() + ls.createData(address, PointerDataType.dataType, size) + +def setFunctionName(address,name): + from ghidra.program.model.symbol.SourceType import USER_DEFINED + if isinstance(address,int): + address = toAddr(address) + f = getFunctionAt(address) + f.setName(name, USER_DEFINED) + +def create_labels(labels): + from ghidra.program.model.symbol.SourceType import USER_DEFINED + sym = currentProgram.symbolTable + for a,r in labels.items(): + if isinstance(a,int): + a = toAddr(a) + sym.createLabel(a, r, USER_DEFINED) + +def get_decompiled(func_name): + from ghidra.app.decompiler import DecompileOptions + from ghidra.app.decompiler import DecompInterface + from ghidra.util.task import ConsoleTaskMonitor + func = getGlobalFunctions(func_name)[0] + options = DecompileOptions() + monitor = ConsoleTaskMonitor() + ifc = DecompInterface() + ifc.setOptions(options) + ifc.openProgram(func.getProgram()) + res = ifc.decompileFunction(func, 1000, monitor) + return res + +def get_decompiled_C(func_name): + res = get_decompiled(func_name) + # get decompiled C source from res: + src = res.getDecompiledFunction().getC() + return src + +def get_decompiled_symbols(func_name): + res = get_decompiled(func_name) + # get (decompiled) high-function object from res: + high_func = res.getHighFunction() + # get local variables' symbols: + lsm = high_func.getLocalSymbolMap() + symbols = lsm.getSymbols() + for i, symbol in enumerate(symbols): + print("\nSymbol {}:".format(i+1)) + print(" name: {}".format(symbol.name)) + print(" dataType: {}".format(symbol.dataType)) + print(" getPCAddress: 0x{}".format(symbol.getPCAddress())) + print(" size: {}".format(symbol.size)) + print(" storage: {}".format(symbol.storage)) + print(" parameter: {}".format(symbol.parameter)) + print(" readOnly: {}".format(symbol.readOnly)) + print(" typeLocked: {}".format(symbol.typeLocked)) + print(" nameLocked: {}".format(symbol.nameLocked)) + +def get_ast_nodes(func_name): + from ghidra.app.decompiler import ClangStatement + res = get_decompiled(func_name) + # get (decompiled) high-function object from res: + def walk(node,L): + if type(node) == ClangStatement: + L.append(node) + else: + for i in range(node.numChildren()): + walk(node.Child(i),L) + nodes = [] + walk(res.getCCodeMarkup(),nodes) + return nodes + diff --git a/amoco/system/baremetal/__init__.py b/amoco/system/baremetal/__init__.py index ac495a8..ae36f4a 100644 --- a/amoco/system/baremetal/__init__.py +++ b/amoco/system/baremetal/__init__.py @@ -21,3 +21,9 @@ def loader_riscv(p): from amoco.system.baremetal.riscv import ELF logger.info("baremetal/riscv firmware loading...") return ELF(p) + +@DefineLoader("elf-baremetal", elf.EM_TRICORE) +def loader_tricore(p): + from amoco.system.baremetal.tricore import SSW + logger.info("baremetal/tricore firmware loading...") + return SSW.loader(p) diff --git a/amoco/system/baremetal/apple2.py b/amoco/system/baremetal/apple2.py new file mode 100644 index 0000000..7883738 --- /dev/null +++ b/amoco/system/baremetal/apple2.py @@ -0,0 +1,193 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.system.structs import StructDefine,StructFormatter +from amoco.system.core import shellcode, DataIO, CoreExec, DefineStub +from amoco.system.memory import MemoryMap +from amoco.arch.w65c02 import cpu +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +IRQV = 0xfffe +RESETV = 0xfffc +SOFTEV = 0x03f2 +PWREDUP = 0x03f4 + +IOMAP = [ + ("IO_KBD/80STOREOFF", 0xc000), + ("80STOREON", 0xc001), + ("RAMRDOFF", 0xc002), + ("RAMRDON", 0xc003), + ("RAMWRTOFF", 0xc004), + ("RAMWRTON", 0xc005), + ("ALTZPOFF", 0xc008), + ("ALTZPON", 0xc009), + ("80COLOFF", 0xc00c), + ("80COLON", 0xc00d), + ("ALTCHARSETOFF", 0xc00e), + ("ALTCHARSETON", 0xc00f), + ("KBDSTRB", 0xc010), + ("RDBANK2", 0xc011), + ("RDLCRAM", 0xc012), + ("RAMRD", 0xc013), + ("RAMWRT", 0xc014), + ("MOUSEXINT", 0xc015), + ("ALTZP", 0xc016), + ("MOUSEYINT", 0xc017), + ("80STORE", 0xc018), + ("VBLINT", 0xc019), + ("TEXT", 0xc01a), + ("MIXED", 0xc01b), + ("PAGE2", 0xc01c), + ("HIRES", 0xc01d), + ("ALTCHARSET", 0xc01e), + ("80COL", 0xc01f), + *[("SPEAKER", 0xc030+i) for i in range(16)], + ("RDXYMSK", 0xc040), + ("RDVBLMSK", 0xc041), + ("RDX0EDGE", 0xc042), + ("RDY0EDGE", 0xc043), + ("RSTXY", 0xc048), + ("TEXTOFF", 0xc050), + ("TEXTON", 0xc051), + ("MIXEDOFF", 0xc052), + ("MIXEDON", 0xc053), + ("PAGE2OFF", 0xc054), + ("PAGE2ON", 0xc055), + ("HIRESOFF", 0xc056), + ("HIRESON", 0xc057), + ("DISXY", 0xc058), + ("ENBXY", 0xc059), + ("DISVBL", 0xc05a), + ("ENVBL", 0xc05b), + ("RX0EDGE", 0xc05c), + ("FX0EDGE", 0xc05d), + ("RY0EDGE", 0xc05e), + ("FY0EDGE", 0xc05f), + ("RD80SW", 0xc060), + ("PB0", 0xc061), + ("PB1", 0xc062), + ("RD63", 0xc063), + ("PDL0", 0xc064), + ("PDL1", 0xc065), + ("MOUX1", 0xc066), + ("MOUY1", 0xc067), + ("PTRIG", 0xc070), + *[("RDIOUDIS", i) for i in (0xc078, 0xc07a, 0xc07c, 0xc07e)], + *[("DHIRES", i) for i in (0xc079, 0xc07b, 0xc07d, 0xc07f)], + ("READBSR2", 0xc080), + ("WRITEBSR2", 0xc081), + ("OFFBSR2", 0xc082), + ("RDWRBSR2", 0xc083), + ("READBSR1", 0xc088), + ("WRITEBSR1", 0xc089), + ("OFFBSR1", 0xc08a), + ("RDWRBSR1", 0xc08b), + ("DATAREG1", 0xc098), + ("STATUS1", 0xc099), + ("COMMAND1", 0xc09a), + ("CONTROL1", 0xc09b), + ("DATAREG2", 0xc0a8), + ("STATUS2", 0xc0a9), + ("COMMAND2", 0xc0aa), + ("CONTROL2", 0xc0ab), + ] + +# ---------------------------------------------------------------------------- + +class AppleROM(CoreExec): + def __init__(self, romfile, cpu): + try: + f = open(romfile,"rb") + except (ValueError, TypeError, IOError): + print("romfile '%s' not found"%romfile) + else: + rom = DataIO(f) + super().__init__(shellcode(rom),cpu) + # setup memory space: + # ------------------- + # [0x0000-0x00FF] zero page: + self.state.mmap.write(0,b'\0'*0x100) + # [0x0100-0x01FF] stack: + self.state.mmap.write(0x100,b'\0'*0x100) + # [0x0200-0x02FF] input buffer (keyboard/floppy): + self.state.mmap.write(0x200,b'\0'*0x100) + # [0x0300-0x03FF] program space & system API: + self.state.mmap.write(0x300,b'\0'*0x100) + # [0x0400-0x07FF] video page1: + self.state.mmap.write(0x400,b'\0'*0x400) + # [0x0800-0x0BFF] video page2: + self.state.mmap.write(0x800,b'\0'*0x400) + # [0x0C00-0x1FFF] is free... + # [0x2000-0x3FFF] high-res video page1: + self.state.mmap.write(0x2000,b'\0'*0x2000) + # [0x4000-0x5FFF] high-res video page2: + self.state.mmap.write(0x4000,b'\0'*0x2000) + # [0x6000-0xBFFF] is free... + # [0xC000-0xC0FF] memory-mapped I/O: + for io,addr in IOMAP: + xf = cpu.ext(io,size=8) + xf.stub = Apple2c.stub(xf.ref) + self.state.mmap.write(addr,xf) + # [0xC100-0xFFFF] ROM memory: + self.setup_rom() + + def setup_rom(self): + # C100-CFFF contains extensions to the system monitor, and subroutines + # to support 80-column text displau, printer, modem, mouse and disk. + self.state.mmap.write(0x10000-self.bin.data.size(),self.bin.data[0:]) + # D000-F7FF contains the Applesoft ROM + # F800-FFFF contains the system monitor ROM + +# ---------------------------------------------------------------------------- + +class Apple2c(object): + stubs = {} + default_stub = DefineStub.warning + + def __init__(self, conf=None): + if conf is None: + from amoco.config import System + + conf = System() + self.romfile = conf.romfile + self.tasks = [] + self.abi = None + self.symbols = {} + + @classmethod + def loader(cls, bprm, conf=None): + return cls(conf).load_bin(bprm) + + def load_bin(self,bprm): + p = AppleROM(self.romfile, cpu) + p.OS = self + # define registers: + p.state[cpu.sp_] = cpu.cst(0x1ff,16) + p.state[cpu.A] = cpu.cst(0xff,8) + p.state[cpu.X] = cpu.cst(0xff,8) + p.state[cpu.Y] = cpu.cst(0xff,8) + p.state[cpu.P] = cpu.cst(0xff,8) + p.state[cpu.D] = cpu.bit0 + entry = p.state(cpu.mem(cpu.RESETV,16)) + p.state[cpu.pc] = entry + # map the stack area: + p.state.mmap.write(0x100,b'\0'*0x100) + self.tasks.append(p) + return p + + def stub(self, refname): + return self.stubs.get(refname, self.default_stub) + + +# ---------------------------------------------------------------------------- + +@DefineStub(Apple2c, "IO_KBD/80STOREOFF") +def io_kbd_80storeoff(m, mode): + m[cpu.pc] = m(cpu.mem(cpu.sp_,16)) + m[cpu.sp] = m(cpu.sp+2) + diff --git a/amoco/system/baremetal/tricore.py b/amoco/system/baremetal/tricore.py new file mode 100644 index 0000000..b6ed32d --- /dev/null +++ b/amoco/system/baremetal/tricore.py @@ -0,0 +1,150 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.system.structs import StructDefine,StructFormatter +from amoco.system.core import BinFormat, CoreExec, DefineStub +from amoco.system.memory import MemoryMap +from amoco.arch.tricore import cpu +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + + +class SSW(object): + stubs = {} + default_stub = DefineStub.warning + + def __init__(self, conf=None): + if conf is None: + from amoco.config import System + + conf = System() + self.tasks = [] + self.abi = None + self.symbols = {} + + def setup_mmio(self,p): + # Tricore memory address space is divided in 16 segments [0-F] of 256MB each. + # Segments 0 and 2 are marked as "reserved", + # segments [1,3-7] can be used as "virtual memory" and thus translated by the MMU + # if enabled, and segments [8-F] are mapped to physical memory. + # Segment F is always dedicated to peripheral space. + # In every segment, the first 4MB is available for storing CSAs (Context-Save-Area) + # A CSA holds either the lower-context or upper-context of registers and its PCXI + # corresponding to a task's state. + for addr, mmio, sz, access in MEMMAP: + xf = cpu.ext(mmio,size=sz*8, + mmio_r="r" in access, + mmio_w="w" in access) + xf.stub = self.stub(xf.ref) + p.state.mmap.write(addr,xf) + + def setup_UCB(self,p,ucb): + # The User Configuration Block contains information used for configuration + # and protection installation. + pass + + @classmethod + def loader(cls, bprm, conf=None, ucb=None): + if bprm.is_ELF: + obj = cls(conf).load_elf(bprm) + else: + obj = cls(conf).load_fw(bprm,ucb) + return obj + + def load_fw(self,bprm,ucb=None): + p = Task(bprm, cpu) + p.OS = self + # map the Program to the Program Flash 0 area: + p.state.mmap.write(0x80000000,p.bin.dataio[0:]) + # map mmio regs in memory: + self.setup_mmio(p) + # map User Configuration Block (UCB) in memory: + if ucb is not None: + self.setup_UCB(p,ucb) + _START = ucb["UCB_BMHD0_ORIG"]["STAD"] + else: + _START = 0x80000000 + # define registers: + p.state[cpu.pc] = cpu.cst(_START,32) + p.state[cpu.PSW] = cpu.cst(0x00000b80,32) + p.state[cpu.PCXI] = cpu.cst(0,32) + # map the stack area: + _STK = 0x70000000-8192 + p.state.mmap.write(_STK,b'\0'*8192) + p.state[cpu.sp] = cpu.cst(_STK+8192,32) + # map the SSW functions as external symbols: + self.load_ssw(p) + self.tasks.append(p) + return p + + def load_elf(self,bprm): + p = Task(bprm, cpu) + p.OS = self + self.setup_mmio(p) + # create text and data segments according to elf header: + for s in p.bin.Phdr: + ms = p.bin.loadsegment(s, 4096) + if ms != None: + vaddr, data = list(ms.items())[0] + p.state.mmap.write(vaddr, data) + # map the stack area: + p.state.mmap.write(0x70000000-8192,b'\0'*8192) + # map registers: + p.state[cpu.PSW] = cpu.cst(0x00000b80,32) + p.state[cpu.PCXI] = cpu.cst(0,32) + p.state[cpu.sp] = cpu.cst(0x70000000,32) + p.state[cpu.pc] = cpu.cst(p.bin.entrypoints[0],32) + self.tasks.append(p) + return p + + def load_ssw(self,mmap): + pass + + def stub(self, refname): + return self.stubs.get(refname, self.default_stub) + + +# ---------------------------------------------------------------------------- + +class Task(CoreExec): + pass + + +# ---------------------------------------------------------------------------- + +@DefineStub(SSW, "FCE0") +def Flexibe_CRC_Engine(m, **kargs): + pass + +@DefineStub(SSW, "ASCLIN0") +@DefineStub(SSW, "ASCLIN1") +@DefineStub(SSW, "ASCLIN2") +@DefineStub(SSW, "ASCLIN3") +@DefineStub(SSW, "ASCLIN4") +@DefineStub(SSW, "ASCLIN5") +@DefineStub(SSW, "ASCLIN6") +@DefineStub(SSW, "ASCLIN7") +@DefineStub(SSW, "ASCLIN8") +@DefineStub(SSW, "ASCLIN9") +def Async_Serial_Controller_LIN(m, **kargs): + pass + + +MEMMAP = [ + (0xF0000000, "FCE0" , 512, "rw"), + (0xF0000600, "ASCLIN0", 256, "rw"), + (0xF0000700, "ASCLIN1", 256, "rw"), + (0xF0000800, "ASCLIN2", 256, "rw"), + (0xF0000900, "ASCLIN3", 256, "rw"), + (0xF0000A00, "ASCLIN4", 256, "rw"), + (0xF0000B00, "ASCLIN5", 256, "rw"), + (0xF0000C00, "ASCLIN6", 256, "rw"), + (0xF0000D00, "ASCLIN7", 256, "rw"), + (0xF0000E00, "ASCLIN8", 256, "rw"), + (0xF0000F00, "ASCLIN9", 256, "rw"), +] + diff --git a/amoco/system/baremetal/w65c02.py b/amoco/system/baremetal/w65c02.py new file mode 100644 index 0000000..d60fe59 --- /dev/null +++ b/amoco/system/baremetal/w65c02.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.system.structs import StructDefine,StructFormatter +from amoco.system.core import BinFormat, CoreExec, DefineStub +from amoco.system.memory import MemoryMap +from amoco.arch.w65c02 import cpu +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +RESETV = 0xFFFC + +ROM = b'@\xad\xf9\xff\xf0\xfb0p\xc9a\x90\x078\xe9a\x18i\n`\xc9A\x90\x078\xe9A\x18i\n`8\xe90` \x01\x90\n\n\n\n\x85\x00 \x01\x90\x05\x00`\xad\xf9\xff\xf0\xfb0@\xc9\n\xf0\x04\xc9\r\xd0\xf1\xad\xf9\xff\xf0\xfb01\xc9S\xd0\xed\xad\xf9\xff\xf0\xfb0&\xc91\xd0\xdb "\x908\xe9\x03\x90\xd3\xf0\xd1\xaa\xa0\x00 "\x90\x85\x03 "\x90\x85\x02 "\x90\x91\x02\xc8\xca\xd0\xf7\x80\xb9L\x00\x10'+(b'\0'*28543)+b'\x00\x90@\x90\x00\x90' + +# ---------------------------------------------------------------------------- + +class OS(object): + stubs = {} + default_stub = DefineStub.warning + + def __init__(self, conf=None): + if conf is None: + from amoco.config import System + + conf = System() + self.tasks = [] + self.abi = None + self.symbols = {} + + @classmethod + def loader(cls, bprm, conf=None): + return cls(conf).load_bin(bprm) + + def load_bin(self,bprm): + p = Task(bprm, cpu) + # map a W65C02 generic BIOS ROM in range [0x9000,0xffff]: + p.state.mmap.write(0x9000,ROM) + p.OS = self + # define registers: + p.state[cpu.sp_] = cpu.cst(0x01ff,16) + p.state[cpu.A] = cpu.cst(0x0,8) + p.state[cpu.X] = cpu.cst(0x0,8) + p.state[cpu.Y] = cpu.cst(0x0,8) + p.state[cpu.P] = cpu.cst(0x36,8) + entry = p.getx(RESETV,size=16) + print(entry) + p.state[cpu.pc] = entry + # map the stack area: + p.state.mmap.write(0x100,b'\0'*0x100) + self.tasks.append(p) + return p + + def stub(self, refname): + return self.stubs.get(refname, self.default_stub) + + +# ---------------------------------------------------------------------------- + +class Task(CoreExec): + pass + +# ---------------------------------------------------------------------------- +@DefineStub(OS, "ret_0", default=True) +def nullstub(m, **kargs): + m[cpu.pc] = m(cpu.mem(cpu.sp_,16)) + m[cpu.sp] = m(cpu.sp+2) + diff --git a/amoco/system/core.py b/amoco/system/core.py index 3228bec..d033b67 100644 --- a/amoco/system/core.py +++ b/amoco/system/core.py @@ -36,7 +36,9 @@ class CoreExec(object): Attributes: bin: the program executable format object. Currently supported formats are provided in :mod:`system.elf` (Elf32/64), :mod:`system.pe` (PE) - and :mod:`system.utils` (HEX/SREC). + :mod:`system.macho` (Mach-O) :mod:`system.structs.HEX` (HEX), + :mod:`system.structs.SREC` (SREC), and raw "shellcode-like" format + in :class:`system.core.shellcode`. cpu: reference to the architecture cpu module, which provides a generic access to the PC() program counter and @@ -129,10 +131,6 @@ def read_instruction(self, vaddr, **kargs): else: if i.address is None: i.address = addr - xsz = i.misc["xsz"] or 0 - if xsz > 0: - xdata = self.state.mmap.read(vaddr + i.length, xsz) - i.xdata(i, xdata) return i def symbol_for(self,address): @@ -335,11 +333,12 @@ def filename(self): def dataio(self): return self.data + class DataIO(object): """ This class simply wraps a binary file or a bytes string and implements both the file and bytes interface. It allows an input to be provided as - files of bytes and manipulated as either a file or a bytes object. + files of bytes and manipulated indifferently as a file or a bytes object. """ def __init__(self, f): @@ -474,7 +473,7 @@ def read_program(filename): p = elf.Elf(f) logger.info("ELF format detected") return p - except elf.ElfError: + except (elf.StructureError,elf.ElfError): f.seek(0) logger.debug("ElfError raised for %s" % f.name) @@ -485,7 +484,7 @@ def read_program(filename): p = pe.PE(f) logger.info("PE format detected") return p - except pe.PEError: + except (pe.StructureError,pe.PEError): f.seek(0) logger.debug("PEError raised for %s" % f.name) @@ -496,27 +495,28 @@ def read_program(filename): p = macho.MachO(f) logger.info("Mach-O format detected") return p - except macho.MachOError: + except (macho.StructureError,macho.MachOError): f.seek(0) logger.debug("MachOError raised for %s" % f.name) try: - from amoco.system import utils + from amoco.system.structs.HEX import HEX,HEXError # open file as a HEX object: - p = utils.HEX(f) + p = HEX(f) logger.info("HEX format detected") return p - except utils.FormatError: + except HEXError: f.seek(0) logger.debug(" HEX FormatError raised for %s" % f.name) try: + from amoco.system.structs.SREC import SREC,SRECError # open file as a SREC object: - p = utils.SREC(f) + p = SREC(f) logger.info("SREC format detected") return p - except utils.FormatError: + except SRECError: f.seek(0) logger.debug(" SREC FormatError raised for %s" % f.name) @@ -569,7 +569,8 @@ def __call__(self, loader): def load_program(f, cpu=None): """ - Detects program format header (ELF/PE/Mach-O/HEX/SREC), + Detects program format header (ELF/PE/Mach-O/HEX/SREC), or consider + the input as a raw "shellcode" if no supported format is recognized, and *maps* the program in abstract memory, loading the associated "system" (linux/win) and "arch" (x86/arm), based header informations. diff --git a/amoco/system/elf.py b/amoco/system/elf.py index 5980057..ef6a88d 100644 --- a/amoco/system/elf.py +++ b/amoco/system/elf.py @@ -11,7 +11,7 @@ The system elf module implements Elf classes for both 32/64bits executable format. """ from amoco.system.core import BinFormat -from amoco.system.structs import Consts, StructDefine +from amoco.system.structs import Consts, StructDefine, StructureError from amoco.system.structs import StructFormatter, token_constant_fmt, token_address_fmt from amoco.logger import Log diff --git a/amoco/system/linux32/x86.py b/amoco/system/linux32/x86.py index 9503d2f..3436a94 100644 --- a/amoco/system/linux32/x86.py +++ b/amoco/system/linux32/x86.py @@ -176,32 +176,34 @@ def pop_eip(m, **kargs): def libc_start_main(m, **kargs): "tags: func_call" m[cpu.eip] = m(cpu.mem(cpu.esp + 4, 32)) - cpu.push(m, cpu.ext("exit", size=32)) + x = cpu.ext("exit",size=32) + x.stub = libc_exit + cpu.push(m, x) @DefineStub(OS, "exit") def libc_exit(m, **kargs): - m[cpu.eip] = top(32) + m[cpu.eip] = cpu.top(32) @DefineStub(OS, "abort") def libc_abort(m, **kargs): - m[cpu.eip] = top(32) + m[cpu.eip] = cpu.top(32) @DefineStub(OS, "__assert") def libc_assert(m, **kargs): - m[cpu.eip] = top(32) + m[cpu.eip] = cpu.top(32) @DefineStub(OS, "__assert_fail") def libc_assert_fail(m, **kargs): - m[cpu.eip] = top(32) + m[cpu.eip] = cpu.top(32) @DefineStub(OS, "_assert_perror_fail") def _assert_perror_fail(m, **kargs): - m[cpu.eip] = top(32) + m[cpu.eip] = cpu.top(32) # ---------------------------------------------------------------------------- diff --git a/amoco/system/macho.py b/amoco/system/macho.py index 0c6e61d..dcc28a0 100644 --- a/amoco/system/macho.py +++ b/amoco/system/macho.py @@ -13,9 +13,9 @@ from collections import defaultdict from amoco.system.core import BinFormat, DataIO -from amoco.system.utils import read_uleb128 +from amoco.system.structs.utils import read_uleb128 from amoco.system.structs import Consts, StructFormatter, default_formatter -from amoco.system.structs import StructDefine, UnionDefine +from amoco.system.structs import StructDefine, UnionDefine, StructureError from amoco.system.structs import token_name_fmt, token_flag_fmt, Token, highlight diff --git a/amoco/system/memory.py b/amoco/system/memory.py index a814e0a..601c3ba 100644 --- a/amoco/system/memory.py +++ b/amoco/system/memory.py @@ -15,9 +15,27 @@ located in the virtual memory space of a process. In order to allow addresses to be symbolic as well, the MemoryMap is organised as a collection of :class:`MemoryZone`. -A zone holds values located at addresses that are integer offsets +A zone holds "values" located at addresses that are integer offsets related to a symbolic expression. A default zone with related address set to ``None`` holds values at concrete (virtual) addresses in every MemoryMap. + +A MemoryZone is more complex than just an associative array between +an address offset and stored "values" because these values can be regular +bytes or any symbolic expression as well. Hence, the MemoryZone needs to deal +with reading an area described by several of these "values" or overwritting +such area with a new value. + +For example, imagine that memory offset 0x1000 +initially contains bytes b'01020304' and an instruction writes the symbolic +expression of register 'eax' to address 0x102. The resulting memory should be +described such that if an instruction fetches 2 bytes from offset +0x1001 the result is a compound expression with first byte '02' and second +byte eax[0:8] in little endian or eax[24:32] in big endian. + +In amoco's Memory model, a MemoryZone holds an ordered list of memory +objects (see class :class:`mo`) and provides method to locate objects +within an address range, or insert new objects at a given offset, +thus allowing the "read" or "write" of expressions of those "values". """ @@ -406,9 +424,10 @@ class mo(object): data and points current object to this offset. Note that a trim is generally the result of data being overwritten by another mo. - read(vaddr,l): returns the list of datadiv objects at given offset so - that the total length is at most l, and the number of bytes missing - if the total length is less than l. + read(vaddr,l): returns a tuple (L,nb) where L is the list of datadiv + objects at given offset so that the total length is at most l, + and nb is the number of bytes missing + if the total length of this object is less than l. write(vaddr,data): updates current mo to reflect the writing of data at given offset and returns the list of possibly new mo objects to be diff --git a/amoco/system/pe.py b/amoco/system/pe.py index 9564d75..a594f74 100644 --- a/amoco/system/pe.py +++ b/amoco/system/pe.py @@ -487,6 +487,7 @@ def unpack(self, data, offset=0): d = DataDirectory(data, offset=l) self.DataDirectories[dnames[dn]] = d l += len(d) + return self def __len__(self): baselen = StructFormatter.__len__(self) diff --git a/amoco/system/structs.py b/amoco/system/structs.py deleted file mode 100644 index 52ffae2..0000000 --- a/amoco/system/structs.py +++ /dev/null @@ -1,1035 +0,0 @@ -# -*- coding: utf-8 -*- - -# This code is part of Amoco -# Copyright (C) 2016 Axel Tillequin (bdcht3@gmail.com) -# published under GPLv2 license - -""" -system/structs.py -================= - -The system structs module implements classes that allow to easily define, -encode and decode C structures (or unions) as well as formatters to print -various fields according to given types like hex numbers, dates, defined -constants, etc. -This module extends capabilities of :mod:`struct` by allowing formats to -include more than just the basic types and add *named* fields. -It extends :mod:`ctypes` as well by allowing formatted printing and -"non-static" decoding where the way a field is decoded depends on -previously decoded fields. - -Module :mod:`system.imx6` uses these classes to decode HAB structures and -thus allow for precise verifications on how the boot stages are verified. -For example, the HAB Header class is defined with:: - - @StructDefine(\"\"\" - B : tag - H :> length - B : version - \"\"\") - class HAB_Header(StructFormatter): - def __init__(self,data="",offset=0): - self.name_formatter('tag') - self.func_formatter(version=self.token_ver_format) - if data: - self.unpack(data,offset) - @staticmethod - def token_ver_format(k,x,cls=None): - return highlight([(Token.Literal,"%d.%d"%(x>>4,x&0xf))]) - -Here, the :class:`StructDefine` decorator is used to provide the definition of -fields of the HAB Header structure to the HAB_Header class. - -The *tag* :class:`Field` is an unsigned byte and the :class:`StructFormatter` -utilities inherited by the class set it as a :meth:`name_formatter` allow -the decoded byte value from data to be represented by its constant name. -This name is obtained from constants defined with:: - - with Consts('tag'): - HAB_TAG_IVT = 0xd1 - HAB_TAG_DCD = 0xd2 - HAB_TAG_CSF = 0xd4 - HAB_TAG_CRT = 0xd7 - HAB_TAG_SIG = 0xd8 - HAB_TAG_EVT = 0xdb - HAB_TAG_RVT = 0xdd - HAB_TAG_WRP = 0x81 - HAB_TAG_MAC = 0xac - -The *length* field is a bigendian short integer with default formatter, -and the *version* field is an unsigned byte with a dedicated formatter -function that extracts major/minor versions from the byte nibbles. - -This allows to decode and print the structure from provided data:: - - In [3]: h = HAB_Header(\'\\xd1\\x00\\x0a\\x40\') - In [4]: print(h) - [HAB_Header] - tag :HAB_TAG_IVT - length :10 - version :4.0 -""" - -import struct -import pyparsing as pp -from collections import defaultdict - -from amoco.logger import Log - -logger = Log(__name__) -logger.debug("loading module") - -from amoco.ui.render import Token, highlight -from inspect import stack as _stack - -# ------------------------------------------------------------------------------ - - -class Consts(object): - """ - Provides a contextmanager to map constant values with their names in - order to build the associated reverse-dictionary. - - All revers-dict are stored inside the Consts class definition. - For example if you declare variables in a Consts('example') with-scope, - the reverse-dict will be stored in Consts.All['example']. - When StructFormatter will lookup a variable name matching a given value - for the attribute 'example', it will get Consts.All['example'][value]. - - Note: To avoid attribute name conflicts, the lookup is always prepended - the stucture class name (or the 'alt' field of the structure class). - Hence, the above 'tag' constants could have been defined as:: - - with Consts('HAB_header.tag'): - HAB_TAG_IVT = 0xd1 - HAB_TAG_DCD = 0xd2 - HAB_TAG_CSF = 0xd4 - HAB_TAG_CRT = 0xd7 - HAB_TAG_SIG = 0xd8 - HAB_TAG_EVT = 0xdb - HAB_TAG_RVT = 0xdd - HAB_TAG_WRP = 0x81 - HAB_TAG_MAC = 0xac - - Or the structure definition could have define an 'alt' attribute:: - - @StructDefine(\"\"\" - B : tag - H :> length - B : version - \"\"\") - class HAB_Header(StructFormatter): - alt = 'hab' - [...] - - in which case the variables could have been defined with:: - - with Consts('hab.tag'): - [...] - """ - - All = defaultdict(dict) - - def __init__(self, name): - self.name = name - - def __enter__(self): - where = _stack()[1][0].f_globals - self.globnames = set(where.keys()) - if not self.name in self.All: - self.All[self.name] = {} - - def __exit__(self, exc_type, exc_value, traceback): - where = _stack()[1][0] - G = where.f_globals - for k in set(G.keys()) - self.globnames: - self.All[self.name][G[k]] = k - - -# ------------------------------------------------------------------------------ - - -def default_formatter(): - return token_default_fmt - - -def token_default_fmt(k, x, cls=None, fmt=None): - """The default formatter just prints value 'x' of attribute 'k' - as a literal token python string - """ - try: - s = x.pp__() - except AttributeError: - s = str(x) - return highlight([(Token.Literal, s)],fmt) - - -def token_address_fmt(k, x, cls=None, fmt=None): - """The address formatter prints value 'x' of attribute 'k' - as a address token hexadecimal value - """ - return highlight([(Token.Address, hex(x))],fmt) - - -def token_constant_fmt(k, x, cls=None, fmt=None): - """The constant formatter prints value 'x' of attribute 'k' - as a constant token decimal value - """ - try: - s = x.pp__() - except AttributeError: - s = str(x) - return highlight([(Token.Constant, s)],fmt) - - -def token_mask_fmt(k, x, cls=None, fmt=None): - """The mask formatter prints value 'x' of attribute 'k' - as a constant token hexadecimal value - """ - return highlight([(Token.Constant, hex(x))],fmt) - - -def token_name_fmt(k, x, cls=None, fmt=None): - """The name formatter prints value 'x' of attribute 'k' - as a name token variable symbol matching the value - """ - pfx = "%s." % cls if cls != None else "" - if pfx + k in Consts.All: - k = pfx + k - ks = k - try: - return highlight([(Token.Name, Consts.All[ks][x])],fmt) - except KeyError: - return token_constant_fmt(k, x, cls, fmt) - - -def token_flag_fmt(k, x, cls, fmt=None): - """The flag formatter prints value 'x' of attribute 'k' - as a name token variable series of symbols matching - the flag value - """ - s = [] - pfx = "%s." % cls if cls != None else "" - if pfx + k in Consts.All: - k = pfx + k - ks = k - for v, name in Consts.All[ks].items(): - if x & v: - s.append(highlight([(Token.Name, name)],fmt)) - return ",".join(s) if len(s) > 0 else token_mask_fmt(k, x, cls, fmt) - - -def token_datetime_fmt(k, x, cls=None, fmt=None): - """The date formatter prints value 'x' of attribute 'k' - as a date token UTC datetime string from timestamp value - """ - from datetime import datetime - - return highlight([(Token.Date, str(datetime.utcfromtimestamp(x)))],fmt) - - -# ------------------------------------------------------------------------------ - - -class Field(object): - """ - A Field object defines an element of a structure, associating a name - to a structure typename and a count. A count of 0 means that the element - is an object of type typename, a count>0 means that the element is a list - of objects of type typename of length count. - - Attributes: - typename (str) : name of a Structure type for this field. - count (int=0) : A count of 0 means that the element - is an object of type typename, a count>0 means that the element is a list - of length count of objects of type typename - name (str) : the name associated to this field. - type (StructFormatter) : getter for the type associated with the field's typename. - comment (str) : comment, useful for pretty printing field usage - order (str) : forces the endianness of this field. - - Methods: - size () : number of bytes eaten by this field. - format (): format string that allows to struct.(un)pack the field as a - string of bytes. - unpack (data,offset=0) : unpacks a data from given offset using - the field internal byte ordering. Returns the object (if count is 0) or the - list of objects of type typename. - get (data,offset=0) : returns the field name and the unpacked value - for this field. - pack (value) : packs the value with the internal order and returns the - byte string according to type typename. - """ - - def __init__(self, ftype, fcount=0, fname=None, forder=None, falign=0, fcomment=""): - self.typename = ftype - self.type_private = isinstance(ftype, (StructCore)) - self.count = fcount - self.name = fname - self.order = forder or "<" - self._align_value = None - if falign: - self.align_value = falign - self.comment = fcomment - - @property - def type(self): - if self.type_private: - return self.typename - try: - cls = StructDefine.All[self.typename] - except KeyError: - return None - else: - return cls() - - def format(self): - "a (non-Raw)Field format is always returned as matching a finite-length string." - sz = self.size() - return "%ds" % sz - - def size(self): - sz = self.type.size() - if self.count > 0: - sz = sz * self.count - return sz - - @property - def source(self): - res = "%s" % self.typename - if self.count > 0: - res += "*%d" % self.count - res += ": %s" % self.name - if self.comment: - res += " ;%s" % self.comment - return res - - def __len__(self): - return self.size() - - def __eq__(self, other): - if ( - (self.typename == other.typename) - and (self.count == other.count) - and (self.order == other.order) - and (self._align_value == other._align_value) - ): - return True - else: - return False - - @property - def align_value(self): - if self._align_value: - return self._align_value - if isinstance(self.type, Field): - return self.type.align_value - return self.type.align_value() - - @align_value.setter - def align_value(self, val): - self._align_value = val - - def align(self, offset): - A = self.align_value - r = offset % A - if r == 0: - return offset - return offset + (A - r) - - def unpack(self, data, offset=0): - "returns a (sequence of count) element(s) of its self.type" - blob = self.type.unpack(data, offset) - sz = self.type.size() - count = self.count - if count > 0: - blob = [blob] - count -= 1 - offset += sz - while count > 0: - blob.append(self.type.unpack(data, offset)) - offset += sz - count -= 1 - return blob - - def get(self, data, offset=0): - return (self.name, self.unpack(data, offset)) - - def pack(self, value): - if self.count > 0: - return b"".join([self.type.pack(v) for v in value]) - return self.type.pack(value) - - def copy(self): - cls = self.__class__ - return cls( - self.typename, - self.count, - self.name, - self.order, - self._align_value, - self.comment, - ) - - def __call__(self): - return self.copy() - - def __repr__(self): - try: - fmt = self.type.format() - except KeyError: - fmt = "?" - r = " 0: - r += "*%d" % self.count - r += " (%s)>" % self.comment if self.comment else ">" - return r - - -# ------------------------------------------------------------------------------ - - -class RawField(Field): - """ - A RawField is a Field associated to a *raw* type, i.e. an internal type - matching a standard C type (u)int8/16/32/64, floats/double, (u)char. - Contrarily to a generic Field which essentially forward the unpack call to - its subtype, a RawField relies on the struct package to return the raw - unpacked value. - """ - - def format(self): - fmt = self.typename - if self.count == 0: - return fmt - sz = self.count - return "%d%s" % (sz, fmt) - - def size(self): - sz = struct.calcsize(self.typename) - if self.count > 0: - sz = sz * self.count - return sz - - def unpack(self, data, offset=0): - pfx = "%d" % self.count if self.count > 0 else "" - res = struct.unpack( - self.order + pfx + self.typename, data[offset : offset + self.size()] - ) - if self.count == 0 or self.typename == "s": - return res[0] - if self.typename == "c": - return b"".join(res) - return res - - def pack(self, value): - fmt = self.typename - pfx = "%d" % self.count if self.count > 0 else "" - order = self.ORDER if hasattr(self, "ORDER") else self.order - if fmt=='c' and isinstance(value,bytes): - fmt = 's' - res = struct.pack(order + pfx + fmt, value) - return res - - def __repr__(self): - fmt = self.typename - r = " 0: - r += "*%d" % self.count - r += " (%s)>" % self.comment if self.comment else ">" - return r - - -class BitField(RawField): - """ - A BitField is a 0-count RawField with additional subnames and subsizes to allow - unpack the raw type into several named values each of given bit sizes. - """ - - def __init__(self, ftype, fcount=0, fname=None, forder=None, falign=0, fcomment=""): - self.typename = ftype - self.type_private = isinstance(ftype, (StructCore)) - self.count = 0 - self.subsizes = fcount or [] - self.name = None - self.subnames = fname or [] - self.order = forder or "<" - self._align_value = None - if falign: - self.align_value = falign - self.comment = fcomment - - def unpack(self, data, offset=0): - value = super(BitField,self).unpack(data,offset) - D = {} - l = 0 - for name,sz in zip(self.subnames,self.subsizes): - mask = (1<>l)&mask - l += sz - return D - - def pack(self, D): - value = 0 - l = 0 - for x,sz in zip(self.subnames,self.subsizes): - mask = (1<" - return r - - @staticmethod - def __default_terminate(val): - if isinstance(val, bytes): - return val == b"\0" - else: - return val == 0 - - def terminate(self, val): - if hasattr(self, "_terminate"): - f = self._terminate - return f(val) - return self.__default_terminate(val) - - def set_terminate(self, func): - self._terminate = func - - -# ------------------------------------------------------------------------------ - - -class CntField(RawField): - """ - A CntField is a RawField where the amount of elements to unpack - is provided as first bytes, encoded as either a byte/word/dword. - """ - - def format(self): - fmt = self.typename - if hasattr(self, "fcount"): - cnt = "%s%d" % (self.fcount[1:], self.count) - else: - cnt = "#" - return "%s%s" % (cnt, fmt) - - def size(self): - try: - return struct.calcsize(self.format()) - except Exception: - return float("Infinity") - - def unpack(self, data, offset=0): - if hasattr(self, "fcount"): - self.count = self.fcount - sz = struct.calcsize(self.count[1:]) - nb = data[offset : offset + sz] - nb = struct.unpack(self.order + self.count[1:], nb)[0] - self.fcount = self.count - self.count = nb - res = struct.unpack( - self.order + self.format(), data[offset : offset + self.size()] - ) - if self.count == 0 or self.typename == "s": - return res[1] - if self.typename == "c": - return b"".join(res[1:]) - return res[1:] - - def pack(self, value): - res = struct.pack(self.order + self.format(), value) - return res - - def __repr__(self): - fmt = self.format() - r = "" - return r - - -# ------------------------------------------------------------------------------ - - -class StructDefine(object): - """ - StructDefine is a decorator class used for defining structures - by parsing a simple intermediate language input decorating - a StructFormatter class. - """ - - All = {} - rawtypes = ( - "x", - "c", - "b", - "B", - "h", - "H", - "i", - "I", - "l", - "L", - "f", - "d", - "s", - "n", - "N", - "p", - "P", - "q", - "Q", - ) - alignments = { - "x": 1, - "c": 1, - "b": 1, - "B": 1, - "s": 1, - "h": 2, - "H": 2, - "i": 4, - "I": 4, - "l": 4, - "L": 4, - "f": 4, - "q": 8, - "Q": 8, - "d": 8, - "P": 8, - } - integer = pp.Regex(r"[0-9][0-9]*") - integer.setParseAction(lambda r: int(r[0])) - bitslen = pp.Group(pp.Suppress("#") + pp.delimitedList(integer,delim='/')) - symbol = pp.Regex(r"[A-Za-z_][A-Za-z0-9_/]*") - comment = pp.Suppress(";") + pp.restOfLine - fieldname = pp.Suppress(":") + pp.Group( - pp.Optional(pp.Literal(">") | pp.Literal("<"), default=None) + symbol - ) - inf = pp.Regex(r"~[bBhHiI]?") - length = integer | symbol | inf | bitslen - typename = pp.Group(symbol + pp.Optional(pp.Suppress("*") + length, default=0)) - structfmt = pp.OneOrMore( - pp.Group(typename + fieldname + pp.Optional(comment, default="")) - ) - - def __init__(self, fmt, **kargs): - self.fields = [] - self.source = fmt - self.packed = kargs.get("packed", False) - if "alignments" in kargs: - self.alignments = kargs["alignments"] - for l in self.structfmt.parseString(fmt, True).asList(): - f_type, f_name, f_comment = l - f_order, f_name = f_name - f_type, f_count = f_type - if f_order is None and "order" in kargs: - f_order = kargs["order"] - if f_type in self.rawtypes: - f_cls = RawField - if isinstance(f_count, list): - f_cls = BitField - f_name = f_name.split('/') - elif isinstance(f_count, str) and f_count.startswith("~"): - f_cls = VarField - if f_count[1:] in "bBhHiI": - f_cls = CntField - f_align = self.alignments[f_type] - else: - f_cls = Field - f_type = kargs.get(f_type, f_type) - f_align = 0 - self.fields.append( - f_cls(f_type, f_count, f_name, f_order, f_align, f_comment) - ) - - def __call__(self, cls): - self.All[cls.__name__] = cls - cls.fields = self.fields - cls.source = self.source - cls.packed = self.packed - cls.fkeys = defaultdict(default_formatter) - return cls - - -# ------------------------------------------------------------------------------ - - -class UnionDefine(StructDefine): - """ - UnionDefine is a decorator class based on StructDefine, - used for defining unions. - """ - - def __call__(self, cls): - self.All[cls.__name__] = cls - cls.fields = self.fields - cls.source = self.source - s = [f.size() for f in cls.fields] - cls.union = s.index(max(s)) - return cls - - -# ------------------------------------------------------------------------------ - - -def TypeDefine(newname, typebase, typecount=0, align_value=0): - if typebase in StructDefine.rawtypes: - f_cls = RawField - f_align = align_value or StructDefine.alignments[typebase] - else: - f_cls = Field - f_align = 0 - StructDefine.All[newname] = f_cls( - typebase, fcount=typecount, falign=f_align, fname="typedef" - ) - - -#------------------------------------------------------------------------------ - -class StructCore(object): - """ - StructCore is a ParentClass for all user-defined structures based on a - StructDefine format. This class contains essentially the packing and unpacking - logic of the structure. - - Note: - It is mandatory that any class that inherits from StructCore can be - instanciated with no arguments. - """ - - packed = False - union = False - - def __new__(cls, *args, **kargs): - obj = super(StructCore, cls).__new__(cls) - obj.fields = [f.copy() for f in cls.fields] - t = type("container", (object,), {}) - obj._v = t() - return obj - - def __getitem__(self, fname): - return getattr(self._v, fname) - - def __setitem__(self, fname, x): - setattr(self._v, fname, x) - - def __getattr__(self, attr): - if attr not in self.__dict__: - return getattr(self._v, attr) - else: - return self.__dict__[attr] - - @classmethod - def format(cls): - if cls.union is False: - return "".join((f.format() for f in cls.fields)) - else: - return cls.fields[cls.union].format() - - @classmethod - def size(cls): - A = cls.align_value() - sz = 0 - for f in cls.fields: - if cls.union is False and not cls.packed: - sz = f.align(sz) - if cls.union is False: - sz += f.size() - elif f.size > sz: - sz = f.size() - r = sz % A - if (not cls.packed) and r > 0: - sz += A - r - return sz - - def __len__(self): - """size method is a class method, __len__ computes - the actual size of the instance""" - A = self.align_value() - sz = 0 - for f in self.fields: - if self.union is False and not self.packed: - sz = f.align(sz) - if self.union is False: - sz += f.size() - elif f.size > sz: - sz = f.size() - r = sz % A - if (not self.packed) and r > 0: - sz += A - r - return sz - - def __eq__(self, other): - if ( - (self.packed == other.packed) - and (self.union == other.union) - and len(self.fields) == len(other.fields) - and all((sf == of for sf, of in zip(self.fields, other.fields))) - ): - return True - else: - return False - - @classmethod - def align_value(cls): - return max([f.align_value for f in cls.fields]) - - def unpack(self, data, offset=0): - for f in self.fields: - if self.union is False and not self.packed: - offset = f.align(offset) - try: - value = f.unpack(data, offset) - except Exception: - name = self.__class__.__name__ - logger.error("error unpacking %s %s"%(name,str(f))) - raise StructureError(name) - else: - if f.name: - setattr(self._v, f.name, value) - elif hasattr(f,'subnames'): - self._v.__dict__.update(value) - if self.union is False: - offset += f.size() - return self - - def pack(self, data=None): - if data is None: - data = [] - for f in self.fields: - if f.name: - data.append(getattr(self._v, f.name)) - elif hasattr(f,'subnames'): - D = {} - for x in self.subnames: - D[x] = getattr(self._v,x) - data.append(D) - parts = [] - offset = 0 - for f, v in zip(self.fields, data): - p = f.pack(v) - if not self.packed: - pad = f.align(offset) - offset - p = b"\0" * pad + p - parts.append(p) - if self.union is False: - res = b"".join(parts) - if not self.packed: - res = res.ljust(self.size(), b"\0") - return res - else: - return parts[self.union] - - def offset_of(self, name): - if self.union is not False: - return 0 - o = 0 - for f in self.fields: - if f.name == name: - return o - o = f.align(o) + f.size() - raise AttributeError(name) - -# ------------------------------------------------------------------------------ - -class StructFormatter(StructCore): - """ - StructFormatter is the Parent Class for all user-defined structures - based on a StructDefine format. - It inherits the core logic from StructCore Parent and provides all - formatting facilities to pretty print the structures based on wether - the field is declared as a named constant, an integer of hex value, - a pointer address, a string or a date. - - Note: Since it inherits from StructCore, it is mandatory that any child - class can be instanciated with no arguments. - """ - - pfx = "" - alt = None - - @classmethod - def func_formatter(cls, **kargs): - for key, func in kargs.items(): - cls.fkeys[key] = func - - @classmethod - def address_formatter(cls, *keys): - for key in keys: - cls.fkeys[key] = token_address_fmt - - @classmethod - def name_formatter(cls, *keys): - for key in keys: - cls.fkeys[key] = token_name_fmt - - @classmethod - def flag_formatter(cls, *keys): - for key in keys: - cls.fkeys[key] = token_flag_fmt - - def strkey(self, k, cname, ksz=20, formatter=None): - fmt = "%%s%%-%ds:%%s" % ksz - if hasattr(self._v, k): - val = getattr(self._v, k) - if isinstance(val,StructFormatter): - val = val.pp__(formatter) - result = self.fkeys[k](k, val, cls=cname,fmt=formatter) - else: - result = "None" - return fmt % (self.pfx, k, result) - - def pp__(self,fmt=None): - cname = self.alt or self.__class__.__name__ - ksz = max((len(f.name) for f in self.fields)) - s = [] - for f in self.fields: - if f.name: - fs = self.strkey(f.name, cname, ksz, fmt) - if fs.count("\n") > 0: - fs = fs.replace("\n", "\n " + " " * ksz) - elif hasattr(f,'subnames'): - fs = "\n".join([self.strkey(n,cname,ksz,fmt) for n in f.subnames]) - s.append(fs) - s = "\n".join(s) - return "[%s]\n%s" % (self.__class__.__name__, s) - - def __str__(self): - return self.pp__() - - -# ------------------------------------------------------------------------------ - - -class StructMaker(StructFormatter): - """ - The StructMaker class is a StructFormatter equipped with methods that - allow to interactively define and adjust fields at some given offsets - or when some given sample bytes match a given value. - """ - - fields = [] - - @property - def source(cls): - return "\n".join((x.source for x in cls.fields)) - - @classmethod - def define(cls, fmt, offset=-1, atvalue=None, indata=b""): - d = StructDefine(fmt) - if len(d.fields) > 1: - logger.warning("can't define more than one field at a time...") - f = d.fields[0] - if atvalue != None: - s = f.pack(atvalue) - offset = indata.find(s) - logger.info("value found at offset %d" % offset) - if offset >= 0: - newf = [] - pos = 0 - for x in cls.fields: - lx = pos + len(x) - if pos <= offset < lx: - if x.name == "#undef": - count = offset - pos - if count > 0: - newf.append(RawField("s", count, "#undef")) - newf.append(f) - count = lx - (offset + len(f)) - if count > 0: - newf.append(RawField("s", count, "#undef")) - else: - logger.error("can't overlap existing field!") - return None - else: - newf.append(x) - pos = lx - if offset >= pos: - count = offset - pos - if count > 0: - newf.append(RawField("s", count, "#undef")) - newf.append(f) - cls.fields = newf - return f - else: - return None - - -# ------------------------------------------------------------------------------ - - -def StructFactory(name, fmt, **kargs): - "Returns a StructFormatter class build with name and format" - return StructDefine(fmt, **kargs)(type(name, (StructFormatter,), {})) - - -def UnionFactory(name, fmt, **kargs): - "Returns a StructFormatter (union) class build with name and format" - return UnionDefine(fmt, **kargs)(type(name, (StructFormatter,), {})) - - -# ------------------------------------------------------------------------------ - -# our data structures exception handler: -class StructureError(Exception): - def __init__(self, message): - self.message = message - - def __str__(self): - return str(self.message) diff --git a/amoco/system/structs/HEX.py b/amoco/system/structs/HEX.py new file mode 100644 index 0000000..b72189b --- /dev/null +++ b/amoco/system/structs/HEX.py @@ -0,0 +1,173 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2014 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.system.core import BinFormat, DataIO +from amoco.system.memory import MemoryMap + +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +from .formatters import * +import codecs + +# our exception handler: +class HEXError(Exception): + def __init__(self, message): + self.message = message + + def __str__(self): + return str(self.message) + + +# The HEX Constants. +# ------------------------------------------------------------------------------ + +with Consts("HEXcode"): + Data = 0 + EndOfFile = 1 + ExtendedSegmentAddress = 2 + StartSegmentAddress = 3 + ExtendedLinearAddress = 4 + StartLinearAddress = 5 + +# ------------------------------------------------------------------------------ + + +class HEX(BinFormat): + is_HEX = True + def __init__(self, f, offset=0): + self.L = [] + self._filename = f.name + self._entrypoint = 0 + for line in f.readlines(): + l = HEXline(line) + if l.HEXcode == StartSegmentAddress: + self._entrypoint = (l.cs, l.ip) + elif l.HEXcode == StartLinearAddress: + self.entrypoint = l.eip + self.L.append(l) + self.__lines = None + self.__dataio = None + + @property + def entrypoints(self): + return [self._entrypoint] + + @property + def filename(self): + return self._filename + + def load_binary(self, mmap=None): + if self.__lines is None: + self.decode() + if mmap is not None: + for k, v in self.__lines: + mmap.write(k, v) + + def decode(self): + seg = 0 + ela = 0 + lines = [] + for l in self.L: + if l.HEXcode == ExtendedSegmentAddress: + seg = l.base + elif l.HEXcode == ExtendedLinearAddress: + ela = l.ela + elif l.HEXcode == Data: + if ela: + address = (ela << 16) + l.address + elif seg: + address = (seg * 16) + l.address + else: + address = l.address + lines.append((address, l.data)) + m = MemoryMap() + self.__lines = lines + for k, v in lines: + m.write(k, v) + if len(m._zones)==1: + self.__dataio = DataIO(m._zones[None].dump()) + + @property + def dataio(self): + if self.__dataio is None: + self.decode() + return self.__dataio + + def __str__(self): + return "\n".join((str(l) for l in self.L)) + + +# ------------------------------------------------------------------------------ + + +class HEXline(object): + def __init__(self, data): + self.HEXcode = None + self.set(data.strip()) + + def set(self, line): + try: + assert line[0:1] == b":" + self.count = int(line[1:3], 16) + self.address = int(line[3:7], 16) + self.HEXcode = int(line[7:9], 16) + c = 9 + 2 * self.count + self.data = codecs.decode(line[9:c], "hex") + s = codecs.decode(line[1:-2], "hex") + if isinstance(s, str): + s = (ord(x) for x in s) + cksum = -(sum(s) & 0xFF) + self.cksum = cksum & 0xFF + assert self.cksum == int(line[-2:], 16) + except (AssertionError, ValueError): + raise HEXError(line) + v = codecs.encode(self.data, "hex") + if self.HEXcode == ExtendedSegmentAddress: + assert self.count == 2 + self.base = int(v, 16) + if self.HEXcode == StartSegmentAddress: + assert self.count == 4 + self.cs = int(v[:4], 16) + self.ip = int(v[4:], 16) + if self.HEXcode == ExtendedLinearAddress: + assert self.count == 2 + self.ela = int(v, 16) + if self.HEXcode == StartLinearAddress: + assert self.count == 4 + self.eip = int(v, 16) + + def pack(self): + s = ":%02X%04X%02X" % (self.count, self.address, self.HEXcode) + s += codecs.encode(self.data, "hex").upper() + s += "%02X" % self.cksum + return s + + def __str__(self): + h = token_name_fmt("HEXcode", self.HEXcode) + if self.HEXcode == Data: + return "[%s] %s: '%s'" % ( + h, + token_address_fmt(None, self.address), + codecs.encode(self.data, "hex"), + ) + if self.HEXcode == EndOfFile: + return "[%s]" % h + if self.HEXcode == ExtendedSegmentAddress: + return "[%s] %s" % (h, token_address_fmt(None, self.base)) + if self.HEXcode == StartSegmentAdress: + return "[%s] %s:%s" % ( + h, + token_address_fmt(None, self.cs), + token_address_fmt(None, self.ip), + ) + if self.HEXcode == ExtendedLinearAddress: + return "[%s] %s" % (h, token_address_fmt(None, self.ela)) + + +# ------------------------------------------------------------------------------ + diff --git a/amoco/system/structs/SREC.py b/amoco/system/structs/SREC.py new file mode 100644 index 0000000..16eff46 --- /dev/null +++ b/amoco/system/structs/SREC.py @@ -0,0 +1,162 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2014 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.system.core import BinFormat, DataIO +from amoco.system.memory import MemoryMap + +from .formatters import * + +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +import codecs + +# our exception handler: +class SRECError(Exception): + def __init__(self, message): + self.message = message + + def __str__(self): + return str(self.message) + +# The SREC Constants. +# ------------------------------------------------------------------------------ + +with Consts("SREC"): + Header = 0 + Data16 = 1 + Data24 = 2 + Data32 = 3 + + Count16 = 5 + Count24 = 6 + Start32 = 7 + Start24 = 8 + Start16 = 9 + +# ------------------------------------------------------------------------------ + + +class SREC(BinFormat): + is_SREC = True + def __init__(self, f, offset=0): + self.L = [] + self._entrypoint = 0 + self._filename = f.name + count = 0 + for line in f.readlines(): + l = SRECline(line) + if l.SRECtype == Header: + self.name = l.data + elif l.SRECtype in (Start16, Start24, Start32): + self.entrypoint = l.address + elif l.SRECtype in (Count16, Count24): + assert count == l.address + else: + count += 1 + self.L.append(l) + self.__dataio = None + + @property + def entrypoints(self): + return [self._entrypoint] + + @property + def filename(self): + return self._filename + + def load_binary(self, mmap=None): + mem = [] + for l in self.L: + if l.SRECtype in (Data16,Data24,Data32): + mem.append((l.address, l.data)) + if mmap is not None: + for (k, v) in mem: + mmap.write(k, v) + + def decode(self): + mem = [] + for l in self.L: + if l.SRECtype in (Data16,Data24,Data32): + mem.append((l.address, l.data)) + m = MemoryMap() + for (k, v) in mem: + m.write(k, v) + if len(m._zones)==1: + self.__dataio = DataIO(m._zones[None].dump()) + + @property + def dataio(self): + if self.__dataio is None: + self.decode() + return self.__dataio + + def __str__(self): + return "\n".join((str(l) for l in self.L)) + + +# ------------------------------------------------------------------------------ + + +class SRECline(object): + def __init__(self, data): + self.SRECtype = None + self.set(data.strip()) + + def set(self, line): + try: + assert line[0:1] == b"S" + # type: + self.SRECtype = int(line[1:2], 10) + # byte count: + self.count = int(line[2:4], 16) + # address: + l = [4, 4, 6, 8, 0, 4, 6, 8, 6, 4][self.SRECtype] + self.size = l + self.address = int(line[4 : 4 + l], 16) + # data: + # c = 4+l+2*self.count + self.data = codecs.decode(line[4 + l : -2], "hex") + assert self.count == (l / 2) + len(self.data) + 1 + # checksum: + s = codecs.decode(line[2:-2], "hex") + if isinstance(s, str): + s = (ord(x) for x in s) + cksum = sum(s) & 0xFF + self.cksum = cksum ^ 0xFF + assert self.cksum == int(line[-2:], 16) + except (AssertionError, ValueError): + raise SRECError(line) + + def pack(self): + s = "S%1d%02X" % (self.SRECtype, self.count) + fa = "%%0%dX" % self.size + s += fa % self.address + s += codecs.encode(self.data, "hex").upper() + s += "%02X" % self.cksum + return s + + def __str__(self): + h = token_name_fmt("SRECtype", self.SRECtype) + if self.SRECtype == Header: + return "[%s] %s: '%s'" % ( + h, + token_address_fmt(None, self.address), + self.data, + ) + if self.SRECtype in (Data16, Data24, Data32): + return "[%s] %s: '%s'" % ( + h, + token_address_fmt(None, self.address), + codecs.encode(self.data, "hex"), + ) + if self.SRECtype in (Count16, Count24): + return "[%s] %s" % (h, token_constant_fmt(None, self.address)) + if self.SRECtype in (Start16, Start24, Start32): + return "[%s] %s" % (h, token_address_fmt(None, self.address)) + + diff --git a/amoco/system/structs/__init__.py b/amoco/system/structs/__init__.py new file mode 100644 index 0000000..54a8e2b --- /dev/null +++ b/amoco/system/structs/__init__.py @@ -0,0 +1,350 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2016 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +""" +system/structs +============== + +The system structs package implements metaclasses that allow to easily define +Python classes that can encode and decode C structures (or unions). +It also provides formatters to print various fields according to given types +like hex numbers, dates, defined constants, etc. + +This package extends the capabilities of :mod:`struct` by allowing formats to +include more than just the basic types and by adding *named* fields. +It extends :mod:`ctypes` as well by allowing formatted printing and "non-static" +decoding where the way a field is decoded depends on a specific terminating +condition or on the value of previously decoded fields of the same structure. + +For example, module :mod:`system.imx6` uses these metaclasses to decode +HAB structures and thus allow for precise verifications on how the boot stages +are verified. The HAB Header class is thus defined by:: + + @StructDefine(\"\"\" + B : tag + H :> length + B : version + \"\"\") + class HAB_Header(StructFormatter): + def __init__(self,data="",offset=0): + self.name_formatter('tag') + self.func_formatter(version=self.token_ver_format) + if data: + self.unpack(data,offset) + @staticmethod + def token_ver_format(k,x,cls=None): + return highlight([(Token.Literal,"%d.%d"%(x>>4,x&0xf))]) + +Here, the :class:`StructDefine` decorator is used to provide the definition of +fields of the HAB Header structure to the HAB_Header class. + +The *tag* :class:`Field` is an unsigned byte and the :class:`StructFormatter` +utilities inherited by the class set it as a :meth:`name_formatter` allow +the decoded byte value from data to be represented by its constant name. +This name is obtained from constants defined with:: + + with Consts('tag'): + HAB_TAG_IVT = 0xd1 + HAB_TAG_DCD = 0xd2 + HAB_TAG_CSF = 0xd4 + HAB_TAG_CRT = 0xd7 + HAB_TAG_SIG = 0xd8 + HAB_TAG_EVT = 0xdb + HAB_TAG_RVT = 0xdd + HAB_TAG_WRP = 0x81 + HAB_TAG_MAC = 0xac + +The *length* field is a bigendian short integer with default formatter, +and the *version* field is an unsigned byte with a dedicated formatter +function that extracts major/minor versions from the byte nibbles. + +This allows to decode and print the structure from provided data:: + + In [3]: h = HAB_Header(\'\\xd1\\x00\\x0a\\x40\') + In [4]: print(h) + [HAB_Header] + tag :HAB_TAG_IVT + length :10 + version :4.0 +""" + +import pyparsing as pp +from collections import defaultdict + +from .core import * +from .fields import * +from .formatters import * + +# ------------------------------------------------------------------------------ + +class StructDefine(object): + """ + StructDefine is a decorator class used for defining structures + by parsing a simple intermediate language input decorating + a StructFormatter class. + + A decorator instance is created by parsing an input "format" + string that is ultimately used to define the fields the StructCore class + on which it is called. The overall idea is to write:: + + @StructDefine(fmt) + class Name(StructCore): + [...] + + The format string syntax is line-oriented. Each line defines a field. + The syntax for a field is divided in 3 parts: *T*:[*N*][;C] + + - *T* is the name of the type + - [*N*] is the name of the field + - [;C] is an optional comment + + The name of the field *N* can be prepended by a literal symbol '<' or '>' + to indicate that its encoding uses little or big endian (if relevant.) + + The name of the type *T* encodes several things in the form:: + + T := typename[*length] + + In most cases, *typename* is the struct package letter for decoding a "raw" + type ie. a byte, a string, an integer, etc. + For example:: + + "I :> x ; something" + + produces a field named 'x' of type uint32 encoded in big-endian. + (Anything that follows ';' is just a comment associated with the field.) + + The name of type can also be the name of a previously defined + class that inherits StructCore, in which case the previous class is used + for decoding the field value when unpacking occurs. + The length indicator [*length] is optional and is either + + - a numeric value: the field is an array of elements of type *T*, + - the string "%leb128" that indicates a Leb128Field, + - a string in the form ".name" that matches the name of a previous field + in the structure (see :class:`BindField`,) + - a special indicator that starts with symbol '#' followed by numeric + values separated by '/', in which case the field is a BitField + - a special indicator that starts with symbol '~', in which case the + field is a :class:`VarField` or a :class:`CntField` if the symbol + is followed by a counter size indicator, ie one of [bBhHiI]. + """ + + rawtypes = ( + "x", + "c", + "b", + "B", + "h", + "H", + "i", + "I", + "l", + "L", + "f", + "d", + "s", + "n", + "N", + "p", + "P", + "q", + "Q", + ) + alignments = { + "x": 1, + "c": 1, + "b": 1, + "B": 1, + "s": 1, + "h": 2, + "H": 2, + "i": 4, + "I": 4, + "l": 4, + "L": 4, + "f": 4, + "q": 8, + "Q": 8, + "d": 8, + "P": 8, + } + integer = pp.Regex(r"[0-9][0-9]*") + integer.setParseAction(lambda r: int(r[0])) + bitslen = pp.Group(pp.Suppress("#") + pp.delimitedList(integer,delim='/')) + symbol = pp.Regex(r"[A-Za-z_][A-Za-z0-9_/]*") + special = pp.Regex(r"[.%][A-Za-z_][A-Za-z0-9_/]*") + comment = pp.Suppress(";") + pp.restOfLine + fieldname = pp.Suppress(":") + pp.Group( + pp.Optional(pp.Literal(">") | pp.Literal("<"), default=None) + symbol + ) + inf = pp.Regex(r"~[bBhHiI]?") + length = integer | special | inf | bitslen + typename = pp.Group(symbol + pp.Optional(pp.Suppress("*") + length, default=0)) + structfmt = pp.OneOrMore( + pp.Group(typename + fieldname + pp.Optional(comment, default="")) + ) + + def __init__(self, fmt, **kargs): + self.fields = [] + self.source = fmt + self.packed = kargs.get("packed", False) + if "alignments" in kargs: + self.alignments = kargs["alignments"] + # lets parse the input format and add corresponding fields: + # the top-level definition is given by structfmt (see above): + for l in self.structfmt.parseString(fmt, True).asList(): + # we get a typename, a fieldname and optional comment: + f_type, f_name, f_comment = l + # the fieldname is a group of order literal and a symbol: + f_order, f_name = f_name + # the typename is a symbol and optional length: + f_type, f_count = f_type + if f_order is None and "order" in kargs: + f_order = kargs["order"] + # if the typename symbol is a raw type, then the field + # can be a RawField, a BitField, or one of the VarField(s): + if f_type in self.rawtypes: + f_cls = RawField + if isinstance(f_count, list): + # a BitField is defined from a 'bitlen' f_count length + # ie a string of values separated by '/'. + f_cls = BitField + # In that case, the name should also be a "list" of + # names spearated by '/': + f_name = f_name.split('/') + elif isinstance(f_count, str): + if f_count.startswith("~"): + f_cls = VarField + if len(f_count)==2 and (f_count[1:2] in "bBhHiI"): + f_cls = CntField + elif f_count.startswith("."): + f_cls = BindedField + elif f_count=="%leb128": + f_cls = Leb128Field + f_count = 0 + f_align = self.alignments[f_type] + else: + f_cls = Field + f_type = kargs.get(f_type, f_type) + f_align = 0 + self.fields.append( + f_cls(f_type, f_count, f_name,f_order, f_align, f_comment) + ) + + def __call__(self, cls): + # Alltypes is a global dict located in structs.core module + Alltypes[cls.__name__] = cls + cls.fields = self.fields + cls.source = self.source + cls.packed = self.packed + cls.fkeys = defaultdict(default_formatter) + return cls + + +# ------------------------------------------------------------------------------ + + +class UnionDefine(StructDefine): + """ + UnionDefine is a decorator class based on StructDefine, + used for defining unions. + """ + + def __call__(self, cls): + # Alltypes is a global dict located in structs.core module + Alltypes[cls.__name__] = cls + cls.fields = self.fields + cls.source = self.source + s = [f.size() for f in cls.fields] + cls.union = s.index(max(s)) + return cls + + +# ------------------------------------------------------------------------------ + + +def TypeDefine(newname, typebase, typecount=0, align_value=0): + t = StructFactory(newname, "%s : _"%typebase) + t.typedef = True + if typecount: + t.fields[0].count = typecount + if align_value: + t.fields[0].align_value = align_value + return t + +# ------------------------------------------------------------------------------ + + +class StructMaker(StructFormatter): + """ + The StructMaker class is a StructFormatter equipped with methods that + allow to interactively define and adjust fields at some given offsets + or when some given sample bytes match a given value. + """ + + fields = [] + + @property + def source(cls): + return "\n".join((x.source for x in cls.fields)) + + @classmethod + def define(cls, fmt, offset=-1, atvalue=None, indata=b""): + d = StructDefine(fmt) + if len(d.fields) > 1: + logger.warning("can't define more than one field at a time...") + f = d.fields[0] + if atvalue != None: + s = f.pack(atvalue) + offset = indata.find(s) + logger.info("value found at offset %d" % offset) + if offset >= 0: + newf = [] + pos = 0 + for x in cls.fields: + lx = pos + len(x) + if pos <= offset < lx: + if x.name == "#undef": + count = offset - pos + if count > 0: + newf.append(RawField("s", count, "#undef")) + newf.append(f) + count = lx - (offset + len(f)) + if count > 0: + newf.append(RawField("s", count, "#undef")) + else: + logger.error("can't overlap existing field!") + return None + else: + newf.append(x) + pos = lx + if offset >= pos: + count = offset - pos + if count > 0: + newf.append(RawField("s", count, "#undef")) + newf.append(f) + cls.fields = newf + return f + else: + return None + + +# ------------------------------------------------------------------------------ + + +def StructFactory(name, fmt, **kargs): + "Returns a StructFormatter class build with name and format" + return StructDefine(fmt, **kargs)(type(name, (StructFormatter,), {})) + + +def UnionFactory(name, fmt, **kargs): + "Returns a StructFormatter (union) class build with name and format" + return UnionDefine(fmt, **kargs)(type(name, (StructFormatter,), {})) + + +# ------------------------------------------------------------------------------ + diff --git a/amoco/system/structs/core.py b/amoco/system/structs/core.py new file mode 100644 index 0000000..3bab378 --- /dev/null +++ b/amoco/system/structs/core.py @@ -0,0 +1,231 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2016 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +#------------------------------------------------------------------------------ + +class StructCore(object): + """ + A StructCore child class represents a C struct or union declaration. It is + also used to represent a typedef declaration. It is the Parent class for all + user-defined structures based on a StructDefine format. + It contains essentially the packing and unpacking logic of the structure + allowing an instance of such class to be "unpacked" from given bytes (or + "packed" from given values.) + + Each instance of a StructCore child class has its own fields copy and a + new "container" for associated attributes' names & unpacked values. + + Attributes: + packed (Bool=False): Unless the "packed" attribute is set to True, + it will use usual padding rules from C. + union (False or int): is set to an int if it represents a C union, + in which case the int value is the index of + the largest of its fields. + typedef (Bool=False): indicates that the class represents a typedef. + fields (list): list of Field objects that define this structure. + _v (container): when a structure is unpacked, the resulting values + are stored in this generic object. + These values are accessed from the S structure instance + using S['fieldname'] or for convinience using + S.fieldname if the fieldname doesn't conflict with a + StructCore attribute or method name. + + Note: + It is mandatory that any class that inherits from StructCore can be + instanciated with no arguments. + """ + + packed = False + union = False + typedef = False + + def __new__(cls, *args, **kargs): + obj = super(StructCore, cls).__new__(cls) + obj.fields = [f.copy(obj) for f in cls.fields] + t = type("container", (object,), {}) + obj._v = t() + return obj + + def __getitem__(self, fname): + return getattr(self._v, fname) + + def __setitem__(self, fname, x): + setattr(self._v, fname, x) + + def update(self,kv): + k,v = kv + setattr(self._v,k,v) + + def __getattr__(self, attr): + if attr not in self.__dict__: + return getattr(self._v, attr) + else: + return self.__dict__[attr] + + @classmethod + def format(cls): + """ + The format of a StructCore is the join of its fields formats, + or its "largest" field if it's a union. + """ + if cls.union is False: + return "".join((f.format() for f in cls.fields)) + else: + return cls.fields[cls.union].format() + + @classmethod + def size(cls): + """ + This is a class method that basically computes the sum of + the sizes of fields (or the largest field if a union) while + taking into account the possible alignements constraints. + It uses the *class* fields instances so that the resulting + value is infinite if any of these field is a VarField. + """ + A = cls.align_value() + sz = 0 + for f in cls.fields: + if cls.union is False and not cls.packed: + sz = f.align(sz) + fsz = f.size() + if cls.union is False: + sz += fsz + elif fsz > sz: + sz = fsz + r = sz % A + if (not cls.packed) and r > 0: + sz += A - r + return sz + + def __len__(self): + """ + This is an instance method that computes the + the actual size of the structure instance using the + instance's fields. This makes a difference from size() + in the case of a structure with variable-length fields + that have been unpacked. + """ + A = self.align_value() + sz = 0 + for f in self.fields: + # adjust current size with alignment constraints: + # and add field size: + if self.union is False and not self.packed: + sz = f.align(sz) + if f.instance is None: + continue + fsz = f.size() + if fsz==float('Infinity'): + continue + if self.union is False: + sz += fsz + elif fsz > sz: + sz = fsz + r = sz % A + if (not self.packed) and r > 0: + sz += A - r + return sz + + def __eq__(self, other): + if ( + (self.packed == other.packed) + and (self.union == other.union) + and (self.typdef == other.typedef) + and len(self.fields) == len(other.fields) + and all((sf == of for sf, of in zip(self.fields, other.fields))) + ): + return True + else: + return False + + @classmethod + def align_value(cls): + return max([f.align_value for f in cls.fields]) + + def unpack(self, data, offset=0): + for f in self.fields: + if self.union is False and not self.packed: + offset = f.align(offset) + try: + value = f.unpack(data, offset) + except Exception: + name = self.__class__.__name__ + logger.error("error unpacking %s %s"%(name,str(f))) + raise StructureError(name) + else: + # if the structure is a typedef, it has only one field + # and unpacking returns its value: + if self.typedef: + return value + # otherwise, unless its a bitfield, it has a name: + if f.name: + setattr(self._v, f.name, value) + elif hasattr(f,'subnames'): + # its a bitfield so the unpacked value + # is a dict with subnames/subvalues: + self._v.__dict__.update(value) + if self.union is False: + offset += f.size() + return self + + def pack(self, data=None): + if data is None: + data = [] + for f in self.fields: + # unless its a bitfield, it has a name: + if f.name: + data.append(getattr(self._v, f.name)) + elif hasattr(f,'subnames'): + D = {} + for x in self.subnames: + D[x] = getattr(self._v,x) + data.append(D) + parts = [] + offset = 0 + for f, v in zip(self.fields, data): + p = f.pack(v) + if not self.packed: + pad = f.align(offset) - offset + p = b"\0" * pad + p + parts.append(p) + if self.union is False: + res = b"".join(parts) + if not self.packed: + res = res.ljust(self.size(), b"\0") + return res + else: + return parts[self.union] + + def offset_of(self, name): + if self.union is not False: + return 0 + o = 0 + for f in self.fields: + if f.name == name: + return o + o = f.align(o) + f.size() + raise AttributeError(name) + +# ------------------------------------------------------------------------------ + + +# our data structures exception handler: +class StructureError(Exception): + def __init__(self, message): + self.message = message + + def __str__(self): + return str(self.message) + + +# ------------------------------------------------------------------------------ + + +Alltypes = {} diff --git a/amoco/system/structs/fields.py b/amoco/system/structs/fields.py new file mode 100644 index 0000000..e07ffcb --- /dev/null +++ b/amoco/system/structs/fields.py @@ -0,0 +1,547 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2016 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +import struct + +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +from .core import StructCore,Alltypes +from .utils import read_leb128, write_uleb128, write_sleb128 + +# ------------------------------------------------------------------------------ + + +class Field(object): + """ + A Field object defines an element of a structure class, associating a name + to a structure type and a count. A count of 0 means that the element + is an object of type typename, a count>0 means that the element is a list + of objects of type typename of length count. + + Attributes: + typename (str) : name of a Structure type for this field. + count (int=0) : A count of 0 means that the element + is an object of type typename, a count>0 means that the element is a list + of length count of objects of type typename + name (str) : the name associated to this field. + type (StructCore) : getter for the type associated with the field's typename. + comment (str) : comment, useful for pretty printing field usage + order (str) : forces the endianness of this field. + + Methods: + size () : number of bytes eaten by this field. + format (): format string that allows to struct.(un)pack the field as a + string of bytes. + unpack (data,offset=0) : unpacks a data from given offset using + the field internal byte ordering. Returns the object (if count is 0) or the + list of objects of type typename. + get (data,offset=0) : returns the field name and the unpacked value + for this field. + pack (value) : packs the value with the internal order and returns the + byte string according to type typename. + """ + + def __init__(self, ftype, fcount=0, fname=None, forder=None, falign=1, fcomment=""): + self.__type = None + if isinstance(ftype,type): + self.__type = ftype + self.typename = ftype.__name__ + else: + self.typename = ftype + self.count = fcount + self.name = fname + self.order = forder or "<" + self.align_value = falign + self.comment = fcomment + self.instance = None + + @property + def type(self): + if self.__type is None: + try: + cls = Alltypes[self.typename] + except (KeyError): + logger.verbose("type %s is not defined"%self.typename) + else: + self.__type = cls + return self.__type + + def format(self): + """ + The format of a regular Field (ie. not derived from RawField) is always returned + as matching a finite-length string. + """ + sz = self.size() + return "%ds" % sz + + def size(self): + # if the field belongs to an instance and was unpacked already, + # we return the actual byte-length of the resulting struct: + try: + return len(self.instance[self.name]) + except: + # otherwise we return the natural size of the field's type, + # which may be infinite if the type contains a VarField... + sz = self.type.size() + if self.count > 0: + sz = sz * self.count + return sz + + @property + def source(self): + res = "%s" % self.typename + if self.count > 0: + res += "*%d" % self.count + res += ": %s" % self.name + if self.comment: + res += " ;%s" % self.comment + return res + + def __len__(self): + return self.size() + + def __eq__(self, other): + if ( + (self.typename == other.typename) + and (self.count == other.count) + and (self.order == other.order) + and (self._align_value == other._align_value) + ): + return True + else: + return False + + @property + def align_value(self): + if self._align_value: + return self._align_value + return self.type.align_value() + + @align_value.setter + def align_value(self, val): + self._align_value = val + + def align(self, offset): + A = self.align_value + r = offset % A + if r == 0: + return offset + return offset + (A - r) + + def unpack(self, data, offset=0): + "returns a (sequence of count) element(s) of its self.type" + blob = self.type().unpack(data, offset) + if self.count>0: + # since we are not a RawField, blob is normally a StructCore instance, + # but it can be a python raw type in case self is a typedef. + # Thus, we need to declare a 'sizeof' operator to correctly compute + # the size of each unpacked blob: + if isinstance(blob,(bytes,StructCore)): + sizeof = lambda b: len(b) + else: + sz = self.type.size() + if sz 0: + nextblob = self.type().unpack(data, offset) + blob.append(nextblob) + offset += sizeof(nextblob) + count -= 1 + return blob + + def get(self, data, offset=0): + return (self.name, self.unpack(data, offset)) + + def pack(self, value): + if self.count > 0: + return b"".join([self.type().pack(v) for v in value]) + return self.type.pack(value) + + def copy(self,obj=None): + cls = self.__class__ + newf = cls( + self.typename, + self.count, + self.name, + self.order, + self._align_value, + self.comment, + ) + newf.instance = obj + return newf + + def __call__(self): + return self.copy() + + def __repr__(self): + try: + fmt = self.type.format() + except KeyError: + fmt = "?" + r = " 0: + r += "*%d" % self.count + r += " (%s)>" % self.comment if self.comment else ">" + return r + + +# ------------------------------------------------------------------------------ + + +class RawField(Field): + """ + A RawField is a Field associated to a *raw* type, i.e. an internal type + matching a standard C type (u)int8/16/32/64, floats/double, (u)char. + Contrarily to a generic Field which essentially forward the unpack call to + its subtype, a RawField relies on the struct package to return the raw + unpacked value. + """ + + @property + def type(self): + return None + + def format(self): + fmt = self.typename + if self.count == 0: + return fmt + sz = self.count + return "%d%s" % (sz, fmt) + + def size(self): + sz = struct.calcsize(self.typename) + if self.count > 0: + sz = sz * self.count + return sz + + def unpack(self, data, offset=0): + pfx = "%d" % self.count if self.count > 0 else "" + res = struct.unpack( + self.order + pfx + self.typename, + data[offset : offset + self.size()] + ) + if self.count == 0 or self.typename == "s": + return res[0] + if self.typename == "c": + return b"".join(res) + return res + + def pack(self, value): + fmt = self.typename + pfx = "%d" % self.count if self.count > 0 else "" + order = self.ORDER if hasattr(self, "ORDER") else self.order + if fmt=='c' and isinstance(value,bytes): + fmt = 's' + res = struct.pack(order + pfx + fmt, value) + return res + + def __repr__(self): + fmt = self.typename + r = " 0: + r += "*%d" % self.count + r += " (%s)>" % self.comment if self.comment else ">" + return r + + +# ------------------------------------------------------------------------------ + + +class BitField(RawField): + """ + A BitField is a 0-count RawField with additional subnames and subsizes to allow + unpack the raw type into several named values each of given bit sizes. + + Arguments: + - The ftype argument is the one that gets "splitted" into parts of bits. + - The fcount argument is a list that defines the size of each splitted part + from least to most significant bit. + - The fname argument is a list that defines the name of each splitted part + according to fcount. + - the forder argument indicates the byte ordering (not the bit ordering.) + """ + + def __init__(self, ftype, fcount=0, fname=None, forder=None, falign=1, fcomment=""): + super().__init__(ftype,0,None,forder,falign,fcomment) + self.subsizes = fcount or [] + # names of each splitted part is provided here: + self.subnames = fname or [] + # other attributes are as usual... + + def unpack(self, data, offset=0): + value = super().unpack(data,offset) + D = {} + l = 0 + for name,sz in zip(self.subnames,self.subsizes): + mask = (1<>l)&mask + l += sz + return D + + def pack(self, D): + value = 0 + l = 0 + for x,sz in zip(self.subnames,self.subsizes): + mask = (1<" + return r + + @staticmethod + def __default_terminate(val, field=None): + if isinstance(val, bytes): + return val == b"\0" + else: + return val == 0 + + def terminate(self, val, field=None): + if hasattr(self, "_terminate"): + f = self._terminate + return f(val,field) + return self.__default_terminate(val,field) + + def set_terminate(self, func): + self._terminate = func + + +# ------------------------------------------------------------------------------ + + +class Leb128Field(VarField): + """ + A Leb128Field is a VarField associated with a + termination condition that decodes LEB128 integers. + """ + + def __init__(self, ftype, fcount=0, fname=None, forder=None, falign=1, fcomment=""): + self.__type = None + self.typename = 'c' + self.sign = -1 if ftype in "bhil" else 1 + self.N = struct.calcsize(ftype) + self.type_private = False + self.count = 0 + self.name = fname + self.order = "<" + self._align_value = falign + self.comment = fcomment + self._sz = None + self.instance = None + + def format(self): + if self._sz is None: + return "#c" + else: + return "%dc"%self._sz + + def _terminate(self,b,f): + return b&0x80==0 + + def unpack(self,data,offset=0): + val, sz = read_leb128(data,self.sign,offset) + self._sz = sz + return val + + def pack(self, value): + if self.sign==1: + return write_uleb128(value) + else: + return write_sleb128(value) + + +# ------------------------------------------------------------------------------ + + +class CntField(RawField): + """ + A CntField is a RawField where the amount of elements to unpack + is provided as first bytes, encoded as either a byte/word/dword. + + A CntField has infinite size until its format is legit, ie. it has + unpacked some data and thus decoded the actual count of elements + that define its value." + """ + + def format(self): + fmt = self.typename + # fcount is used as a placeholder for the initial fcount value + # that correspond to the formatting of the counter. For example + # for a CntField defined from s*~I, the typename is 's' and the + # count is initially set to '~I' to indicate that the counter is + # to be decoded as an uint32 from first 4 bytes. + if hasattr(self, "fcount"): + cnt = "%s"%self.fcount[1:] + if self.count==0: + return cnt + else: + cnt += "%d"%self.count + else: + cnt = "#" + return "%s%s" % (cnt, fmt) + + def size(self): + try: + return struct.calcsize(self.format()) + except Exception: + return float("Infinity") + + def unpack(self, data, offset=0): + if hasattr(self, "fcount"): + # the structure has been unpacked already, lets restore + # the count to its initial form. + self.count = self.fcount + # decode the actual count: + sz = struct.calcsize(self.count[1:]) + nb = data[offset : offset + sz] + nb = struct.unpack(self.order + self.count[1:], nb)[0] + # save the initial count form + self.fcount = self.count + # ...before overwritting with actual value: + self.count = nb + # now fully unpack the whole field: + res = struct.unpack( + self.order + self.format(), data[offset : offset + self.size()] + ) + if self.count == 0 or self.typename == "s": + return res[1] + if self.typename == "c": + return b"".join(res[1:]) + return res[1:] + + def pack(self, value): + if not hasattr(self,"fcount"): + self.fcount = self.count + self.count = len(value) + if isinstance(value,list): + res = struct.pack(self.order + self.format(), + self.count, *value) + else: + res = struct.pack(self.order + self.format(), + self.count, value) + return res + + def __repr__(self): + fmt = self.format() + r = "" + return r + + +# ------------------------------------------------------------------------------ + + +class BindedField(CntField): + """ + A BindField is a CntField where the counter is provided + by a (previously unpacked) field of the same structure. + """ + + def format(self): + fmt = self.typename + if hasattr(self, "fcount"): + cnt = self.count + else: + cnt = "#" + if self.count==0: + return "" + return "%s%s" % (cnt, fmt) + + def size(self): + try: + return struct.calcsize(self.format()) + except Exception: + return float("Infinity") + + def unpack(self, data, offset=0): + if hasattr(self, "fcount"): + self.count = self.fcount + self.fcount = self.count + boundname = self.count[1:] + self.count = self.instance[boundname] + if self.count==0: + return None + res = struct.unpack( + self.order + self.format(), data[offset : offset + self.size()] + ) + if self.typename=="s": + return res[0] + return res + diff --git a/amoco/system/structs/formatters.py b/amoco/system/structs/formatters.py new file mode 100644 index 0000000..822bdac --- /dev/null +++ b/amoco/system/structs/formatters.py @@ -0,0 +1,237 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2016 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +import struct +import pyparsing as pp +from collections import defaultdict + +from amoco.logger import Log +logger = Log(__name__) +logger.debug("loading module") + +from .core import StructCore + +from amoco.ui.render import Token, highlight +from inspect import stack as _stack + + +# ------------------------------------------------------------------------------ + + +class Consts(object): + """ + Provides a contextmanager to map constant values with their names in + order to build the associated reverse-dictionary. + + All revers-dict are stored inside the Consts class definition. + For example if you declare variables in a Consts('example') with-scope, + the reverse-dict will be stored in Consts.All['example']. + When StructFormatter will lookup a variable name matching a given value + for the attribute 'example', it will get Consts.All['example'][value]. + + Note: To avoid attribute name conflicts, the lookup is always prepended + the stucture class name (or the 'alt' field of the structure class). + Hence, the above 'tag' constants could have been defined as:: + + with Consts('HAB_header.tag'): + HAB_TAG_IVT = 0xd1 + HAB_TAG_DCD = 0xd2 + HAB_TAG_CSF = 0xd4 + HAB_TAG_CRT = 0xd7 + HAB_TAG_SIG = 0xd8 + HAB_TAG_EVT = 0xdb + HAB_TAG_RVT = 0xdd + HAB_TAG_WRP = 0x81 + HAB_TAG_MAC = 0xac + + Or the structure definition could have define an 'alt' attribute:: + + @StructDefine(\"\"\" + B : tag + H :> length + B : version + \"\"\") + class HAB_Header(StructFormatter): + alt = 'hab' + [...] + + in which case the variables could have been defined with:: + + with Consts('hab.tag'): + [...] + """ + + All = defaultdict(dict) + + def __init__(self, name): + self.name = name + + def __enter__(self): + where = _stack()[1][0].f_globals + self.globnames = set(where.keys()) + if not self.name in self.All: + self.All[self.name] = {} + + def __exit__(self, exc_type, exc_value, traceback): + where = _stack()[1][0] + G = where.f_globals + for k in set(G.keys()) - self.globnames: + self.All[self.name][G[k]] = k + + +# ------------------------------------------------------------------------------ + + +def default_formatter(): + return token_default_fmt + + +def token_default_fmt(k, x, cls=None, fmt=None): + """The default formatter just prints value 'x' of attribute 'k' + as a literal token python string + """ + try: + s = x.pp__() + except AttributeError: + s = str(x) + return highlight([(Token.Literal, s)],fmt) + + +def token_address_fmt(k, x, cls=None, fmt=None): + """The address formatter prints value 'x' of attribute 'k' + as a address token hexadecimal value + """ + return highlight([(Token.Address, hex(x))],fmt) + + +def token_constant_fmt(k, x, cls=None, fmt=None): + """The constant formatter prints value 'x' of attribute 'k' + as a constant token decimal value + """ + try: + s = x.pp__() + except AttributeError: + s = str(x) + return highlight([(Token.Constant, s)],fmt) + + +def token_mask_fmt(k, x, cls=None, fmt=None): + """The mask formatter prints value 'x' of attribute 'k' + as a constant token hexadecimal value + """ + return highlight([(Token.Constant, hex(x))],fmt) + + +def token_name_fmt(k, x, cls=None, fmt=None): + """The name formatter prints value 'x' of attribute 'k' + as a name token variable symbol matching the value + """ + pfx = "%s." % cls if cls != None else "" + if pfx + k in Consts.All: + k = pfx + k + ks = k + try: + return highlight([(Token.Name, Consts.All[ks][x])],fmt) + except KeyError: + return token_constant_fmt(k, x, cls, fmt) + + +def token_flag_fmt(k, x, cls, fmt=None): + """The flag formatter prints value 'x' of attribute 'k' + as a name token variable series of symbols matching + the flag value + """ + s = [] + pfx = "%s." % cls if cls != None else "" + if pfx + k in Consts.All: + k = pfx + k + ks = k + for v, name in Consts.All[ks].items(): + if x & v: + s.append(highlight([(Token.Name, name)],fmt)) + return ",".join(s) if len(s) > 0 else token_mask_fmt(k, x, cls, fmt) + + +def token_datetime_fmt(k, x, cls=None, fmt=None): + """The date formatter prints value 'x' of attribute 'k' + as a date token UTC datetime string from timestamp value + """ + from datetime import datetime + + return highlight([(Token.Date, str(datetime.utcfromtimestamp(x)))],fmt) + + +# ------------------------------------------------------------------------------ + + +class StructFormatter(StructCore): + """ + StructFormatter is the Parent Class for all user-defined structures. + For most of these structures, the fields are created using a StructDefine + decorator. + + This class inherits the core logic from StructCore Parent and provides all + formatting facilities to pretty print the structures based on wether + the field is declared as a named constant, an integer of hex value, + a pointer address, a string or a date. + + Note: Since it inherits from StructCore, it is mandatory that any child + class can be instanciated with no arguments. + """ + + pfx = "" + alt = None + + @classmethod + def func_formatter(cls, **kargs): + for key, func in kargs.items(): + cls.fkeys[key] = func + + @classmethod + def address_formatter(cls, *keys): + for key in keys: + cls.fkeys[key] = token_address_fmt + + @classmethod + def name_formatter(cls, *keys): + for key in keys: + cls.fkeys[key] = token_name_fmt + + @classmethod + def flag_formatter(cls, *keys): + for key in keys: + cls.fkeys[key] = token_flag_fmt + + def strkey(self, k, cname, ksz=20, formatter=None): + fmt = "%%s%%-%ds:%%s" % ksz + if hasattr(self._v, k): + val = getattr(self._v, k) + if isinstance(val,StructFormatter): + val = val.pp__(formatter) + result = self.fkeys[k](k, val, cls=cname,fmt=formatter) + else: + result = "None" + return fmt % (self.pfx, k, result) + + def pp__(self,fmt=None): + cname = self.alt or self.__class__.__name__ + ksz = max((len(f.name) for f in self.fields)) + s = [] + for f in self.fields: + if f.name: + fs = self.strkey(f.name, cname, ksz, fmt) + if fs.count("\n") > 0: + fs = fs.replace("\n", "\n " + " " * ksz) + elif hasattr(f,'subnames'): + fs = "\n".join([self.strkey(n,cname,ksz,fmt) for n in f.subnames]) + s.append(fs) + s = "\n".join(s) + return "[%s]\n%s" % (self.__class__.__name__, s) + + def __str__(self): + return self.pp__() + + diff --git a/amoco/system/structs/utils.py b/amoco/system/structs/utils.py new file mode 100644 index 0000000..f3f2ec1 --- /dev/null +++ b/amoco/system/structs/utils.py @@ -0,0 +1,55 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2014 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +def read_leb128(data, sign=1, offset=0): + result = 0 + shift = 0 + count = 0 + for b in data[offset:]: + if isinstance(b, bytes): + b = ord(b) + count += 1 + result |= (b & 0x7F) << shift + shift += 7 + if b & 0x80 == 0: + break + if sign < 0 and (b & 0x40): + result |= ~0 << shift + return result, count + + +def read_uleb128(data): + return read_leb128(data) + + +def read_sleb128(data): + return read_leb128(data, -1) + +def write_uleb128(val): + if val==0: + return b'\0' + res = [] + while val!=0: + x = val&0x7f + val = val>>7 + if val!=0: + x = 0x80|x + res.append(x) + return bytes(res) + +def write_sleb128(val): + more=True + neg=(val<0) + res = [] + while more: + x = val&0x7f + val = val>>7 + if ((val==0) and (x&0x40==0)) or ((val==-1) and (x&0x40)): + more=False + else: + x = 0x80|x + res.append(x) + return bytes(res) diff --git a/amoco/system/utils.py b/amoco/system/utils.py index f3befa8..0eaa02d 100644 --- a/amoco/system/utils.py +++ b/amoco/system/utils.py @@ -1,351 +1 @@ -# -*- coding: utf-8 -*- - -# This code is part of Amoco -# Copyright (C) 2014 Axel Tillequin (bdcht3@gmail.com) -# published under GPLv2 license - -""" -system/utils.py -=============== - -The system utils module implements various binary file format like -Intel HEX or Motorola SREC, commonly used for programming MCU, EEPROMs, etc. -""" - -import struct -from amoco.system.core import DataIO, BinFormat -from amoco.logger import Log - -logger = Log(__name__) -logger.debug("loading module") - -from amoco.ui.render import Token, highlight - -from collections import defaultdict -import codecs - -# our exception handler: -class FormatError(Exception): - def __init__(self, message): - self.message = message - - def __str__(self): - return str(self.message) - - -## - -# ------------------------------------------------------------------------------ -# formatting facilities: - -# init of reverse dict to get constant name from value. -# This dict is updated by using 'with' statement of Consts. -HEX_CONSTS = defaultdict(dict) - - -class Consts(object): - def __init__(self, name): - self.name = name - - def __enter__(self): - HEX_CONSTS[self.name] = {} - self.globnames = set(globals().keys()) - - def __exit__(self, exc_type, exc_value, traceback): - G = globals() - for k in set(G.keys()) - self.globnames: - HEX_CONSTS[self.name][G[k]] = k - - -def token_address_fmt(k, x, cls=None, fmt=None): - return highlight([(Token.Address, "0x%04x" % x)]) - - -def token_constant_fmt(k, x, cls=None, fmt=None): - try: - s = x.pp__() - except AttributeError: - s = str(x) - return highlight([(Token.Constant, s)],fmt) - - -def token_name_fmt(k, x, cls=None, fmt=None): - try: - return highlight([(Token.Name, HEX_CONSTS[k][x])],fmt) - except KeyError: - return token_constant_fmt(k, x, cls, fmt) - - -# The HEX Constants. -# ------------------------------------------------------------------------------ - -with Consts("HEXcode"): - Data = 0 - EndOfFile = 1 - ExtendedSegmentAddress = 2 - StartSegmentAddress = 3 - ExtendedLinearAddress = 4 - StartLinearAddress = 5 - -# ------------------------------------------------------------------------------ - - -class HEX(BinFormat): - is_HEX = True - def __init__(self, f, offset=0): - self.L = [] - self._filename = f.name - self._entrypoint = 0 - for line in f.readlines(): - l = HEXline(line) - if l.HEXcode == StartSegmentAddress: - self._entrypoint = (l.cs, l.ip) - elif l.HEXcode == StartLinearAddress: - self.entrypoint = l.eip - self.L.append(l) - - @property - def entrypoints(self): - return [self._entrypoint] - - @property - def filename(self): - return self._filename - - def load_binary(self, mmap=None): - seg = 0 - ela = 0 - mem = [] - for l in self.L: - if l.HEXcode == ExtendedSegmentAddress: - seg = l.base - elif l.HEXcode == ExtendedLinearAddress: - ela = l.ela - elif l.HEXcode == Data: - if ela: - address = (ela << 16) + l.address - elif seg: - address = (seg * 16) + l.address - else: - address = l.address - mem.append((address, l.data)) - if mmap is not None: - for k, v in mem: - mmap.write(k, v) - return mem - - def __str__(self): - return "\n".join((str(l) for l in self.L)) - - -# ------------------------------------------------------------------------------ - - -class HEXline(object): - def __init__(self, data): - self.HEXcode = None - self.set(data.strip()) - - def set(self, line): - try: - assert line[0:1] == b":" - self.count = int(line[1:3], 16) - self.address = int(line[3:7], 16) - self.HEXcode = int(line[7:9], 16) - c = 9 + 2 * self.count - self.data = codecs.decode(line[9:c], "hex") - s = codecs.decode(line[1:-2], "hex") - if isinstance(s, str): - s = (ord(x) for x in s) - cksum = -(sum(s) & 0xFF) - self.cksum = cksum & 0xFF - assert self.cksum == int(line[-2:], 16) - except (AssertionError, ValueError): - raise FormatError(line) - v = codecs.encode(self.data, "hex") - if self.HEXcode == ExtendedSegmentAddress: - assert self.count == 2 - self.base = int(v, 16) - if self.HEXcode == StartSegmentAddress: - assert self.count == 4 - self.cs = int(v[:4], 16) - self.ip = int(v[4:], 16) - if self.HEXcode == ExtendedLinearAddress: - assert self.count == 2 - self.ela = int(v, 16) - if self.HEXcode == StartLinearAddress: - assert self.count == 4 - self.eip = int(v, 16) - - def pack(self): - s = ":%02X%04X%02X" % (self.count, self.address, self.HEXcode) - s += codecs.encode(self.data, "hex").upper() - s += "%02X" % self.cksum - return s - - def __str__(self): - h = token_name_fmt("HEXcode", self.HEXcode) - if self.HEXcode == Data: - return "[%s] %s: '%s'" % ( - h, - token_address_fmt(None, self.address), - codecs.encode(self.data, "hex"), - ) - if self.HEXcode == EndOfFile: - return "[%s]" % h - if self.HEXcode == ExtendedSegmentAddress: - return "[%s] %s" % (h, token_address_fmt(None, self.base)) - if self.HEXcode == StartSegmentAdress: - return "[%s] %s:%s" % ( - h, - token_address_fmt(None, self.cs), - token_address_fmt(None, self.ip), - ) - if self.HEXcode == ExtendedLinearAddress: - return "[%s] %s" % (h, token_address_fmt(None, self.ela)) - - -# ------------------------------------------------------------------------------ - -# The SREC Constants. -# ------------------------------------------------------------------------------ - -with Consts("SREC"): - Header = 0 - Data16 = 1 - Data24 = 2 - Data32 = 3 - - Count16 = 5 - Count24 = 6 - Start32 = 7 - Start24 = 8 - Start16 = 9 - -# ------------------------------------------------------------------------------ - - -class SREC(BinFormat): - is_SREC = True - def __init__(self, f, offset=0): - self.L = [] - self._entrypoint = 0 - self._filename = f.name - for line in f.readlines(): - count = 0 - l = SRECline(line) - if l.SRECtype == Header: - self.name = l.data - elif l.SRECtype in (Start16, Start24, Start32): - self.entrypoint = l.address - elif l.SRECtype in (Count16, Count24): - assert count == l.address - else: - count += 1 - self.L.append(l) - - @property - def entrypoints(self): - return [self._entrypoint] - - @property - def filename(self): - return self._filename - - def load_binary(self, mmap=None): - mem = [] - for l in self.L: - mem.append((l.address, l.data)) - if mmap: - for (k, v) in mem: - mmap.write(k, v) - return mem - - def __str__(self): - return "\n".join((str(l) for l in self.L)) - - -# ------------------------------------------------------------------------------ - - -class SRECline(object): - def __init__(self, data): - self.SRECtype = None - self.set(data.strip()) - - def set(self, line): - try: - assert line[0:1] == b"S" - # type: - self.SRECtype = int(line[1:2], 10) - # byte count: - self.count = int(line[2:4], 16) - # address: - l = [4, 4, 6, 8, 0, 4, 6, 8, 6, 4][self.SRECtype] - self.size = l - self.address = int(line[4 : 4 + l], 16) - # data: - # c = 4+l+2*self.count - self.data = codecs.decode(line[4 + l : -2], "hex") - assert self.count == (l / 2) + len(self.data) + 1 - # checksum: - s = codecs.decode(line[2:-2], "hex") - if isinstance(s, str): - s = (ord(x) for x in s) - cksum = sum(s) & 0xFF - self.cksum = cksum ^ 0xFF - assert self.cksum == int(line[-2:], 16) - except (AssertionError, ValueError): - raise FormatError(line) - - def pack(self): - s = "S%1d%02X" % (self.SRECtype, self.count) - fa = "%%0%dX" % self.size - s += fa % self.address - s += codecs.encode(self.data, "hex").upper() - s += "%02X" % self.cksum - return s - - def __str__(self): - h = token_name_fmt("SRECtype", self.SRECtype) - if self.SRECtype == Header: - return "[%s] %s: '%s'" % ( - h, - token_address_fmt(None, self.address), - self.data, - ) - if self.SRECtype in (Data16, Data24, Data32): - return "[%s] %s: '%s'" % ( - h, - token_address_fmt(None, self.address), - codecs.encode(self.data, "hex"), - ) - if self.SRECtype in (Count16, Count24): - return "[%s] %s" % (h, token_constant_fmt(None, self.address)) - if self.SRECtype in (Start16, Start24, Start32): - return "[%s] %s" % (h, token_address_fmt(None, self.address)) - - -def read_leb128(data, sign=1): - result = 0 - shift = 0 - count = 0 - for b in data: - if isinstance(b, bytes): - b = ord(b) - count += 1 - result |= (b & 0x7F) << shift - shift += 7 - if b & 0x80 == 0: - break - if sign < 0 and (b & 0x40): - result |= ~0 << shift - return result, count - - -def read_uleb128(data): - return read_leb128(data) - - -def read_sleb128(data): - return read_leb128(data, -1) +from .structs.utils import * diff --git a/amoco/system/vm/wasm.py b/amoco/system/vm/wasm.py new file mode 100644 index 0000000..bd02643 --- /dev/null +++ b/amoco/system/vm/wasm.py @@ -0,0 +1,919 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2021 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +""" +system/wasm.py +============== + +The system wasm module implements both the Wasm class binary format +and a Wasm virtual machine. +""" +from amoco.system.structs import Consts, StructDefine +from amoco.system.structs import StructFormatter, StructCore +from amoco.system.structs import Field, VarField, RawField, Leb128Field +from amoco.system.utils import read_leb128, write_uleb128 + +from amoco.logger import Log + +logger = Log(__name__) +logger.debug("loading module") + +class WasmError(Exception): + """ + WasmError is raised whenever Wasm object instance fails + to decode required structures. + """ + def __init__(self, message): + self.message = message + + def __str__(self): + return str(self.message) + + +# ------------------------------------------------------------------------------ + + +class Wasm(object): + """ + This class takes a DataIO object (ie an opened file of BytesIO instance) + and decodes all Wasm structures found in it. + """ + def __init__(self,f): + from amoco.arch.wasm import cpu + self.__file = f + self.cpu = cpu + + @property + def filename(self): + return self.__file.name + + @property + def dataio(self): + return self.__file + + def __init__(self, f): + self.__file = f + self.module = Module(f) + + +# ------------------------------------------------------------------------------ + + +class VectorField(Field): + + def __init__(self, fmt): + f0 = StructDefine(fmt,packed=True).fields[0] + self.__type = f0.type or f0 + self.typename = f0.typename + self.count = 0 + self.order = f0.order + self.align_value = f0.align_value + self.comment = f0.comment + self.name = f0.name + self._sz = 0 + self.instance = None + + @property + def type(self): + return self.__type + + def size(self): + return self._sz + + @property + def source(self): + cnt = self.count if self.count>0 else '#' + return "vector(%s)[%s]: %s; %s"%(self.typename,cnt,self.name,self.comment) + + def unpack(self, data, offset=0): + "returns a vector of count element(s) of its self.type" + n,sz = read_leb128(data,1,offset) + offset += sz + vec = [] + for _ in range(n): + e = self.type() + blob = e.unpack(data, offset) + vec.append(blob) + if isinstance(blob,StructCore): + l = len(blob) + else: + l = e.size() + sz += l + offset += l + self.count = n + self._sz = sz + return vec + + def get(self, data, offset=0): + return (self.name, self.unpack(data, offset)) + + def pack(self, value): + assert self.count == len(value) + vec = b"".join([self.type().pack(v) for v in value]) + res = write_uleb128(self.count)+vec + assert self._sz == len(res) + return res + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +c*4 : magic +I : version +""", packed=True, +) +class Module(StructFormatter): + def __init__(self, data=None, offset=0): + if data: + self.unpack(data,offset) + + def unpack(self, data, offset=0): + super().unpack(data, offset) + if self.magic != b"\0asm": + raise WasmError("Wrong magic number, not a binary Wasm file ?") + self.sections = [] + offset += len(self) + end = data.size() + while offset<(end-1): + _id = ord(data[offset:offset+1]) + try: + s = SectionID[_id](data,offset) + offset += len(s) + self.sections.append(s) + except KeyError: + logger.warning("Wrong section id, aborting...") + break + except WasmError: + logger.warning("malformed section with id %d"%_id) + break + return self + + def size(self): + l = super().size() + for s in self.sections: + l += len(s) + return l + + def __str__(self): + ss = [] + ss.append(super().__str__()) + ss += ["\nSections:"] + for s in self.sections: + tmp = s.pfx + s.pfx = "\t" + ss.append(s.__str__()) + ss.append("---") + s.pfx = tmp + return "\n".join(ss) + +# ------------------------------------------------------------------------------ + +with Consts('Section.id'): + Custom = 0 + Type = 1 + Function = 2 + Table = 3 + Memory = 4 + Global = 5 + Export = 6 + Start = 7 + Element = 8 + Code = 9 + Data = 10 + DataCount = 11 + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class CustomSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class TypeSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + ft = VectorField("FunctionType : ft") + self.update(ft.get(self.content)) + return self + +@StructDefine( +""" +B : d +I*%leb128 : n1 +B*.n1 : rt1 +I*%leb128 : n2 +B*.n2 : rt2 +""", packed=True, +) +class FunctionType(StructFormatter): + alt = "Section" + + @staticmethod + def wat_formatter(k, x, cls=None, fmt=None): + L = [(Token.Literal,'(')] + for v in x: + if v in valtype: + L.append((Token.Register, str(cpu.valtype[v]))) + else: + L.append((Token.Constant, hex(x))) + L.append((Token.Literal,', ')) + L.pop() + L.append((Token.Literal,')')) + return highlight(L,fmt) + + def __init__(self, data=None, offset=0): + self.func_formatter(rt1=self.wat_formatter, + rt2=self.wat_formatter,) + if data: + self.unpack(data,offset) + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class ImportSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None,offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + im = VectorField("Import : im") + self.update(im.get(self.content)) + return self + + +with Consts("Import.d"): + typeidx = 0 + tabletype = 1 + memtype = 2 + globaltype = 3 + +@StructDefine( +""" +I*%leb128 : n1 +s*.n1 : mod +I*%leb128 : n2 +s*.n2 : nm +B : d +""", packed=True, +) +class Import(StructFormatter): + def __init__(self, data=None,offset=0): + self.name_formatter("d") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + from codecs import decode + super().unpack(data,offset) + self.mod = decode(self.mod,"UTF-8") + self.nm = decode(self.nm,"UTF-8") + offset += len(self) + if self.d==0x00: + f = Leb128Field("I",fname="x") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + if self.d==0x01: + f = Field(TableType,fname="tt") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + if self.d==0x02: + f = Field(MemType,fname="mt") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + if self.d==0x03: + f = Field(GlobalType,fname="gt") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + return self + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class FunctionSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + x = VectorField("I*%leb128 : x") + self.update(x.get(self.content)) + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class TableSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + tt = VectorField("TableType : tt") + self.update(tt.get(self.content)) + return self + + +@StructDefine( +""" +B : et +B : flags +I*%leb128 : n +""", packed=True, +) +class TableType(StructFormatter): + def __init__(self, data=None, offset=0): + self.flag_formatter("flags") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + if len(self.fields)==4: + self.fields.pop() + super().unpack(data,offset) + offset += len(self) + if self.flags&1: + self.has_max = True + f = Leb128Field("I",fname="m") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + if self.flags&2: + self.is_shared = True + else: + self.is_shared = False + if self.flags&4: + self.is_64 = True + else: + self.is_64 = False + return self + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class MemorySection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + mem = VectorField("MemType : mem") + self.update(mem.get(self.content)) + return self + +with Consts("flags"): + has_max = 0x01 + is_shared = 0x02 + is_64 = 0x04 + +@StructDefine( +""" +B : flags +I*%leb128 : n +""", packed=True, +) +class MemType(StructFormatter): + def __init__(self, data=None, offset=0): + self.flag_formatter("flags") + if data: + self.unpack(data,offset) + + def unpack(self,data,offset=0): + if len(self.fields)==3: + self.fields.pop() + super().unpack(data,offset) + offset += len(self) + if self.flags&1: + self.has_max = True + f = Leb128Field("I",fname="m") + f.instance = self + self.fields.append(f) + self.update(f.get(data,offset)) + if self.flags&2: + self.is_shared = True + else: + self.is_shared = False + if self.flags&4: + self.is_64 = True + else: + self.is_64 = False + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class GlobalSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + glob = VectorField("GlobalType : glob") + self.update(glob.get(self.content)) + return self + + +with Consts("GlobalType.mut"): + const = 0 + var = 1 + +@StructDefine( +""" +B : t +B : mut +""", packed=True, +) +class GlobalType(StructFormatter): + def __init__(self, data=None, offset=0): + self.name_formatter("mut") + if data: + self.unpack(data, offset) + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class ExportSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + ex = VectorField("Export : ex") + self.update(ex.get(self.content)) + return self + +with Consts("Export.desc"): + func = 0x00 + table = 0x01 + mem = 0x02 + glob = 0x03 + +@StructDefine( +""" +I*%leb128 : n +s*.n : name +B : desc +I*%leb128 : x +""", packed=True, +) +class Export(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("desc") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + from codecs import decode + super().unpack(data,offset) + self.name = decode(self.name,"UTF-8") + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class StartSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + n,sz = read_uleb128(self.content) + self.x = n + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class ElementSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + seg = VectorField("Elem : seg") + self.update(seg.get(self.content)) + return self + + +@StructDefine( +""" +B : d +""", packed=True, +) +class Elem(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + if data: + self.unpack(data, offset) + + def reset(self): + self.fields = self.fields[0:1] + t = type("container", (object,), {}) + self._v = t() + + def add_expr(self,data,offset): + expr = VarField("B","~","e") + expr.set_terminate(lambda b,f: b==0x0B) + self.fields.append(expr) + expr.instance = self + self.update(expr.get(data,offset)) + return expr + + def add_et(self,data,offset): + et = RawField("B",0,"et") + self.fields.append(et) + et.instance = self + self.update(et.get(data,offset)) + return et + + def add_vec(self,fmt,data,offset): + v = VectorField(fmt) + self.fields.append(v) + v.instance = self + self.update(v.get(data,offset)) + return v + + def unpack(self,data,offset=0): + self.reset() + super().unpack(data,offset) + offset += 1 + if self.d==0x00: + f = self.add_expr(data,offset) + offset += f.size() + self.add_vec("I*%leb128 : y", data, offset) + elif self.d in (0x01,0x03): + f = self.add_et(data,offset) + offset += f.size() + self.add_vec("I*%leb128 : y", data, offset) + elif self.d == 0x02: + f = Leb128Field("I",fname="x") + self.fields.append(f) + self.update(f.get(data,offset)) + offset += f.size() + f = self.add_expr(data,offset) + offset += f.size() + f = self.add_et(data,offset) + offset += f.size() + self.add_vec("I*%leb128 : y", data, offset) + elif self.d == 0x04: + f = self.add_expr(data,offset) + offset += f.size() + f = VectorField("B~ : el") + f.type.set_terminate(lambda b,f: b==0x0B) + self.fields.append(f) + self.update(f.get(data,offset)) + elif self.d in (0x05,0x07): + f = self.add_et(data,offset) + offset += f.size() + f = VectorField("B~ : el") + self.fields.append(f) + f.type.set_terminate(lambda b,f: b==0x0B) + self.update(f.get(data,offset)) + elif self.d == 0x06: + f = Leb128Field("I",fname="x") + self.fields.append(f) + self.update(f.get(data,offset)) + offset += f.size() + f = self.add_expr(data,offset) + offset += f.size() + f = self.add_et(data,offset) + offset += f.size() + f = VectorField("B~ : el") + f.type.set_terminate(lambda b,f: b==0x0B) + self.fields.append(f) + self.update(f.get(data,offset)) + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class CodeSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + seg = VectorField("Code : code") + self.update(seg.get(self.content)) + return self + + +@StructDefine( +""" +I*%leb128 : sz +""", packed=True, +) +class Code(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + if data: + self.unpack(data, offset) + + def reset(self): + self.fields = self.fields[0:1] + t = type("container", (object,), {}) + self._v = t() + + def unpack(self,data,offset=0): + self.reset() + super().unpack(data,offset) + offset += len(self) + func = data[offset:offset+self.sz] + locs = VectorField("Locs : t") + locs.instance = self + self.fields.append(locs) + self.update(locs.get(func)) + offset = locs.size() + body = func[offset:] + if body[-1]!=0x0B: + raise WasmError("func body has no END") + expr = RawField("s",len(body),"e") + self.fields.append(expr) + expr.instance = self + self.update(expr.get(body)) + return self + +@StructDefine( +""" +I*%leb128 : n +i*%leb128 : t +""", packed=True, +) +class Locs(StructFormatter): + alt = "Section" + + def __init__(self, data=None): + if data: + self.unpack(data) + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class DataSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + seg = VectorField("Data : code") + self.update(seg.get(self.content)) + return self + +@StructDefine( +""" +B : d +""", packed=True, +) +class Data(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + if data: + self.unpack(data, offset) + + def reset(self): + self.fields = self.fields[0:1] + t = type("container", (object,), {}) + self._v = t() + + def add_initexpr(self,data,offset): + expr = VarField("B","~","e") + expr.set_terminate(lambda b,f: b==0x0B) + expr.instance = self + self.fields.append(expr) + try: + self.update(expr.get(data,offset)) + except StandardError: + raise WasmError("malformed init expr") + return expr + + def add_vec(self,fmt,data,offset): + v = VectorField(fmt) + self.fields.append(v) + v.instance = self + self.update(v.get(data,offset)) + return v + + + def unpack(self,data,offset=0): + super().unpack(data,offset) + offset += 1 + if self.d&0x02: + f = Leb128Field("I",fname="x") + self.fields.append(f) + self.update(f.get(data,offset)) + offset += f.size() + if self.d&0x01==0: + f = self.add_initexpr(data,offset) + offset += f.size() + self.add_vec("B : b", data, offset) + return self + + +# ------------------------------------------------------------------------------ + + +@StructDefine( +""" +B : id +I*%leb128 : size +s*.size : content +""", packed=True, +) +class DataCountSection(StructFormatter): + alt = "Section" + + def __init__(self, data=None, offset=0): + self.name_formatter("id") + if data: + self.unpack(data, offset) + + def unpack(self,data,offset=0): + super().unpack(data,offset) + n,sz = read_uleb128(self.content) + self.n = n + return self + + +# ------------------------------------------------------------------------------ + + +SectionID = { + 0: CustomSection, + 1: TypeSection, + 2: ImportSection, + 3: FunctionSection, + 4: TableSection, + 5: MemorySection, + 6: GlobalSection, + 7: ExportSection, + 8: StartSection, + 9: ElementSection, + 10: CodeSection, + 11: DataSection, + 12: DataCountSection, +} + +# ------------------------------------------------------------------------------ + + diff --git a/amoco/ui/app.py b/amoco/ui/app.py index 2cb4215..ab08912 100644 --- a/amoco/ui/app.py +++ b/amoco/ui/app.py @@ -178,7 +178,7 @@ def bin_info(ctx, filename, header): p = amoco.load_program(filename) ctx.obj["p"] = p click.secho("file: ",fg='blue') - click.secho(str(p.view.title)) + click.secho(str(p.view.title())) click.secho("checksec: ",fg='blue') click.echo(str(p.view.checksec)) if header: diff --git a/amoco/ui/cli.py b/amoco/ui/cli.py index fcd9276..2512e46 100644 --- a/amoco/ui/cli.py +++ b/amoco/ui/cli.py @@ -8,7 +8,9 @@ cli.py ====== -This module... +This module allows to prompt for high-level "amoco" commands defined in the srv argument. +It provides a convinient way of emulating a binary from a gdb-like interface rather than +from the [i]python console. See :mod:`srv` module for details. """ import cmd diff --git a/amoco/ui/graphics/qt_/binfmtview.py b/amoco/ui/graphics/qt_/binfmtview.py index 0453956..ed9ea0a 100644 --- a/amoco/ui/graphics/qt_/binfmtview.py +++ b/amoco/ui/graphics/qt_/binfmtview.py @@ -6,7 +6,7 @@ from PySide2.QtCore import Qt from PySide2.QtWidgets import QTreeView, QHeaderView -from PySide2.QtGui import QStandardItemModel +from PySide2.QtGui import QStandardItemModel, QFont from .structview import StructItem @@ -21,43 +21,64 @@ def BinFmtView(task): v = None return v -# ------------------------------------------------------------------------------ - -class PEView(QTreeView): +class BinFmtView_core(QTreeView): def __init__(self, p): super().__init__() + # enforce monospaced font: + f = QFont("Monospace") + f.setPointSize(8) + self.setFont(f) self.setEditTriggers(QTreeView.NoEditTriggers) self.setSelectionMode(QTreeView.ExtendedSelection) m = QStandardItemModel() m.setColumnCount(3) m.setHorizontalHeaderLabels(["name","value","size"]) r = m.invisibleRootItem() - S = StructItem("PE") - S.appendRow(StructItem("DOS",p.DOS)) - S.appendRow(StructItem("NT",p.NT)) - S.appendRow(StructItem("Opt",p.Opt)) - for s in p.sections: - S.appendRow(StructItem(s.name,s)) - r.appendRow(S) + S = self.setup_(p) + if S: + r.appendRow(S) self.setModel(m) + self.m = m self.setUniformRowHeights(True) self.header().setSectionResizeMode(QHeaderView.ResizeToContents) + self.header().setFont(f) + + def setup_(self,p): + return None + +# ------------------------------------------------------------------------------ + +class PEView(BinFmtView_core): + def __init__(self,p): + super().__init__(p) #expand PE root structure: - x = m.index(0,0) + x = self.m.index(0,0) self.expand(x) #expand the DOS structure: self.expand(self.indexBelow(x)) + def setup_(self, p): + S = StructItem("PE") + S.appendRow(StructItem("DOS",p.DOS)) + S.appendRow(StructItem("NT",p.NT)) + S.appendRow(StructItem("Opt",p.Opt)) + for s in p.sections: + S.appendRow(StructItem(s.name,s)) + return S # ------------------------------------------------------------------------------ -class ELFView(QTreeView): +class ELFView(BinFmtView_core): def __init__(self, p=None): - super().__init__(None) - self.setEditTriggers(QTreeView.NoEditTriggers) - self.setSelectionMode(QTreeView.ExtendedSelection) - m = QStandardItemModel() - m.setHorizontalHeaderLabels(["name","value","size"]) - r = m.invisibleRootItem() + super().__init__(p) + #expand ELF root structure: + x = self.m.index(0,0) + self.expand(x) + h = self.indexBelow(x) + #expand the Ehdr structure: + self.expand(h) + #expand the Ehdr.e_ident structure: + self.expand(self.indexBelow(h)) + def setup_(self,p): S = StructItem("ELF") S.appendRow([StructItem("Ehdr",p.Ehdr,offset=0), StructItem(""), @@ -74,21 +95,11 @@ def __init__(self, p=None): StructItem(""), StructItem("%d"%len(s))]) offset += p.Ehdr.e_shentsize - r.appendRow(S) - self.setModel(m) - self.setUniformRowHeights(True) - self.header().setSectionResizeMode(QHeaderView.ResizeToContents) - #expand ELF root structure: - x = m.index(0,0) - self.expand(x) - h = self.indexBelow(x) - #expand the Ehdr structure: - self.expand(h) - #expand the Ehdr.e_ident structure: - self.expand(self.indexBelow(h)) + return S # ------------------------------------------------------------------------------ -class MachOView(QTreeView): +class MachOView(BinFmtView_core): def __init__(self, p=None): - super().__init__(None) + super().__init__(p) + diff --git a/amoco/ui/graphics/qt_/colors.py b/amoco/ui/graphics/qt_/colors.py index 5bcc705..974abea 100644 --- a/amoco/ui/graphics/qt_/colors.py +++ b/amoco/ui/graphics/qt_/colors.py @@ -7,25 +7,25 @@ from PySide2.QtGui import QColor palette_trbg = { - 'Inchworm': QColor(0xa1,0xe4,0x4d,64), - 'CornFlowerBlue': QColor(0x7b,0x8c,0xde,64), - 'SuperPink': QColor(0xdc,0x6b,0xad,64), - 'YellowOrange': QColor(0xff,0xb1,0x40,64), - 'MintGreen': QColor(0xa2,0xfa,0xa3,64), - 'Chartreuse': QColor(0xe4,0xff,0x1a,64), - 'GoldCrayola': QColor(0xed,0xb0,0x85,64), - 'TeaGreen': QColor(0xd6,0xff,0xb7,64), - 'OrangePeel': QColor(0xff,0x9f,0x1c,64), - 'DarkSlateBlue': QColor(0x40,0x37,0x6e,64), - 'LanguidLavender': QColor(0xd5,0xcf,0xe1,64), - 'Tuscany': QColor(0xbb,0x99,0x9c,64), - 'CopperCrayola': QColor(0xe8,0x8d,0x67,64), - 'LightGreen': QColor(0x81,0xf4,0x99,64), - 'KeyLime': QColor(0xe2,0xeb,0x98,64), - 'EggPlant': QColor(0x70,0x4c,0x5e,64), - 'Celadon': QColor(0xba,0xd9,0xa2,64), - 'CambridgeBlue': QColor(0x9d,0xc4,0xb5,64), - 'Salmon': QColor(0xf3,0x83,0x75,64), - 'SpanishPink': QColor(0xfb,0xc3,0xbc,64), - 'YaleBlue': QColor(0x08,0x48,0x87,64), + 'Inchworm': QColor(0xa1,0xe4,0x4d,128), + 'CornFlowerBlue': QColor(0x7b,0x8c,0xde,128), + 'SuperPink': QColor(0xdc,0x6b,0xad,128), + 'YellowOrange': QColor(0xff,0xb1,0x40,128), + 'MintGreen': QColor(0xa2,0xfa,0xa3,128), + 'Chartreuse': QColor(0xe4,0xff,0x1a,128), + 'GoldCrayola': QColor(0xed,0xb0,0x85,128), + 'TeaGreen': QColor(0xd6,0xff,0xb7,128), + 'OrangePeel': QColor(0xff,0x9f,0x1c,128), + 'DarkSlateBlue': QColor(0x40,0x37,0x6e,128), + 'LanguidLavender': QColor(0xd5,0xcf,0xe1,128), + 'Tuscany': QColor(0xbb,0x99,0x9c,128), + 'CopperCrayola': QColor(0xe8,0x8d,0x67,128), + 'LightGreen': QColor(0x81,0xf4,0x99,128), + 'KeyLime': QColor(0xe2,0xeb,0x98,128), + 'EggPlant': QColor(0x70,0x4c,0x5e,128), + 'Celadon': QColor(0xba,0xd9,0xa2,128), + 'CambridgeBlue': QColor(0x9d,0xc4,0xb5,128), + 'Salmon': QColor(0xf3,0x83,0x75,128), + 'SpanishPink': QColor(0xfb,0xc3,0xbc,128), + 'YaleBlue': QColor(0x08,0x48,0x87,128), } diff --git a/amoco/ui/graphics/qt_/engine.py b/amoco/ui/graphics/qt_/engine.py index 1cb32fe..b6db842 100644 --- a/amoco/ui/graphics/qt_/engine.py +++ b/amoco/ui/graphics/qt_/engine.py @@ -8,7 +8,7 @@ from PySide2.QtWidgets import QApplication from PySide2.QtCore import QPointF -from amoco.ui.render import Formats +from amoco.ui.render import Formats,conf #from . import rc_icons app = QApplication.instance() or QApplication([]) @@ -17,9 +17,18 @@ # set default styleSheet: current_path = path.abspath(path.dirname(__file__)) filename = path.join(current_path, 'style.qss') -with open(filename,'r') as f: - _style = f.read() - app.setStyleSheet(_style) +filename = conf.UI.qstylesheet or filename +if filename.startswith(":"): + if filename[1:]=="qdarkstyle": + try: + import qdarkstyle + app.setStyleSheet(qdarkstyle.load_stylesheet(qt_api='pyside2')) + except: + pass +else: + with open(filename,'r') as f: + _style = f.read() + app.setStyleSheet(_style) try: # integrate Qt mainloop into IPython console: diff --git a/amoco/ui/graphics/qt_/hexview.py b/amoco/ui/graphics/qt_/hexview.py index c5cd25f..c536bf5 100644 --- a/amoco/ui/graphics/qt_/hexview.py +++ b/amoco/ui/graphics/qt_/hexview.py @@ -6,8 +6,9 @@ from itertools import cycle -from PySide2.QtCore import Qt, QRect, Signal +from PySide2.QtCore import Qt, QRect, Signal, QPointF, QRectF, QSizeF from PySide2.QtGui import QFont, QColor, QPen, QPainter, QPolygon +from PySide2.QtGui import QPixmap, QImage from PySide2.QtWidgets import QAbstractScrollArea from . import brushes @@ -20,7 +21,7 @@ class HexView(QAbstractScrollArea): handle large list of hexlines to display. A QScrollArea would require that the viewport Widget associated to it be fully defined to handle the scrolling automatically. Here we really want to render the viewport - dynamically based on scrolling events, not the contrary.) + dynamically based on scrolling events, not the opposite.) """ clicked = Signal((int,int,QColor)) @@ -47,6 +48,9 @@ def __init__(self, parent=None, dataio=None): @property def select_color(self): + """ + get next color from (cycle) palette + """ self.lastcolor = next(self.palette) return self.lastcolor @@ -63,12 +67,17 @@ def setData(self,dataio): # the view needs updating whenever the model emits a # "UPDATED" signal: self.model.UPDATED.connect(self.update) + # since we are an "abstract" widget we need to compute the + # vertical bar minimum/maximum values. self.vb.setMinimum(0) nb, r = divmod(self.model.data.size(), self.model.linesize) if r>0: nb += 1 self.vb.setMaximum(nb) # set line definition (sizes): self.line = HexLine(self.fontMetrics(),self.model.linesize) + # prepare grayscale image of the full model data: + self.qimg = QImage(self.model.full,self.model.linesize,nb, + QImage.Format_Grayscale8) self.update() def update(self): @@ -94,6 +103,7 @@ def paintEvent(self,e): # update drawing: self.paintlines(w,first,count,line0) self.paintframes(w) + self.paintmap(w) def keyPressEvent(self,e): self.statusbar.showMessage("key: %d ('%s') [%08x]"%(e.key(), @@ -111,12 +121,20 @@ def addrToLine(self,addr): return l def xyToAddr(self,x,y): - h = self.line.height - l = y//h - # get base address - a = self.model.linesize*(self.model.cur+l) - # add byte index [0,16[ - return (a + self.line.index(x)) + if x4: + p.setWidth(2) + surface.drawLine(p1,p2) + surface.drawLine(p1,QPointF(self.line.x_map,l0)) + surface.drawLine(p2,QPointF(self.line.x_map,l1)) + else: + p.setWidth(4) + surface.drawLine(p1,p2) + surface.setPen(pen) + def move(self,cur,e): return None diff --git a/amoco/ui/graphics/qt_/icons.qrc b/amoco/ui/graphics/qt_/icons.qrc index 9153ab1..613dd5f 100644 --- a/amoco/ui/graphics/qt_/icons.qrc +++ b/amoco/ui/graphics/qt_/icons.qrc @@ -1,33 +1,212 @@ - - icons/checkbox_unchecked.png - icons/checkbox_unchecked_hover.png - icons/checkbox_unchecked_pressed.png + icons/arrow_down.png + icons/arrow_down@2x.png + icons/arrow_down_disabled.png + icons/arrow_down_disabled@2x.png + icons/arrow_down_focus.png + icons/arrow_down_focus@2x.png + icons/arrow_down_pressed.png + icons/arrow_down_pressed@2x.png + icons/arrow_left.png + icons/arrow_left@2x.png + icons/arrow_left_disabled.png + icons/arrow_left_disabled@2x.png + icons/arrow_left_focus.png + icons/arrow_left_focus@2x.png + icons/arrow_left_pressed.png + icons/arrow_left_pressed@2x.png + icons/arrow_right.png + icons/arrow_right@2x.png + icons/arrow_right_disabled.png + icons/arrow_right_disabled@2x.png + icons/arrow_right_focus.png + icons/arrow_right_focus@2x.png + icons/arrow_right_pressed.png + icons/arrow_right_pressed@2x.png + icons/arrow_up.png + icons/arrow_up@2x.png + icons/arrow_up_disabled.png + icons/arrow_up_disabled@2x.png + icons/arrow_up_focus.png + icons/arrow_up_focus@2x.png + icons/arrow_up_pressed.png + icons/arrow_up_pressed@2x.png + icons/base_icon.png + icons/base_icon@2x.png + icons/base_icon_disabled.png + icons/base_icon_disabled@2x.png + icons/base_icon_focus.png + icons/base_icon_focus@2x.png + icons/base_icon_pressed.png + icons/base_icon_pressed@2x.png + icons/branch_closed.png + icons/branch_closed@2x.png + icons/branch_closed_disabled.png + icons/branch_closed_disabled@2x.png + icons/branch_closed_focus.png + icons/branch_closed_focus@2x.png + icons/branch_closed_pressed.png + icons/branch_closed_pressed@2x.png + icons/branch_end.png + icons/branch_end@2x.png + icons/branch_end_disabled.png + icons/branch_end_disabled@2x.png + icons/branch_end_focus.png + icons/branch_end_focus@2x.png + icons/branch_end_pressed.png + icons/branch_end_pressed@2x.png + icons/branch_line.png + icons/branch_line@2x.png + icons/branch_line_disabled.png + icons/branch_line_disabled@2x.png + icons/branch_line_focus.png + icons/branch_line_focus@2x.png + icons/branch_line_pressed.png + icons/branch_line_pressed@2x.png + icons/branch_more.png + icons/branch_more@2x.png + icons/branch_more_disabled.png + icons/branch_more_disabled@2x.png + icons/branch_more_focus.png + icons/branch_more_focus@2x.png + icons/branch_more_pressed.png + icons/branch_more_pressed@2x.png + icons/branch_open.png + icons/branch_open@2x.png + icons/branch_open_disabled.png + icons/branch_open_disabled@2x.png + icons/branch_open_focus.png + icons/branch_open_focus@2x.png + icons/branch_open_pressed.png + icons/branch_open_pressed@2x.png icons/checkbox_checked.png - icons/checkbox_checked_hover.png + icons/checkbox_checked@2x.png + icons/checkbox_checked_disabled.png + icons/checkbox_checked_disabled@2x.png + icons/checkbox_checked_focus.png + icons/checkbox_checked_focus@2x.png icons/checkbox_checked_pressed.png + icons/checkbox_checked_pressed@2x.png icons/checkbox_indeterminate.png - icons/checkbox_indeterminate_hover.png + icons/checkbox_indeterminate@2x.png + icons/checkbox_indeterminate_disabled.png + icons/checkbox_indeterminate_disabled@2x.png + icons/checkbox_indeterminate_focus.png + icons/checkbox_indeterminate_focus@2x.png icons/checkbox_indeterminate_pressed.png - icons/spinup.png - icons/spinup_hover.png - icons/spinup_off.png - icons/spinup_pressed.png - icons/spindown.png - icons/spindown_hover.png - icons/spindown_off.png - icons/spindown_pressed.png - icons/triangle_vert.png - icons/radiobutton_unchecked.png - icons/radiobutton_unchecked_hover.png - icons/radiobutton_unchecked_pressed.png - icons/radiobutton_checked.png - icons/radiobutton_checked_hover.png - icons/radiobutton_checked_pressed.png - icons/down_arrow.png - icons/up_arrow.png - icons/triangle_horz.png - icons/sizegrip.png + icons/checkbox_indeterminate_pressed@2x.png + icons/checkbox_unchecked.png + icons/checkbox_unchecked@2x.png + icons/checkbox_unchecked_disabled.png + icons/checkbox_unchecked_disabled@2x.png + icons/checkbox_unchecked_focus.png + icons/checkbox_unchecked_focus@2x.png + icons/checkbox_unchecked_pressed.png + icons/checkbox_unchecked_pressed@2x.png + icons/line_horizontal.png + icons/line_horizontal@2x.png + icons/line_horizontal_disabled.png + icons/line_horizontal_disabled@2x.png + icons/line_horizontal_focus.png + icons/line_horizontal_focus@2x.png + icons/line_horizontal_pressed.png + icons/line_horizontal_pressed@2x.png + icons/line_vertical.png + icons/line_vertical@2x.png + icons/line_vertical_disabled.png + icons/line_vertical_disabled@2x.png + icons/line_vertical_focus.png + icons/line_vertical_focus@2x.png + icons/line_vertical_pressed.png + icons/line_vertical_pressed@2x.png + icons/radio_checked.png + icons/radio_checked@2x.png + icons/radio_checked_disabled.png + icons/radio_checked_disabled@2x.png + icons/radio_checked_focus.png + icons/radio_checked_focus@2x.png + icons/radio_checked_pressed.png + icons/radio_checked_pressed@2x.png + icons/radio_unchecked.png + icons/radio_unchecked@2x.png + icons/radio_unchecked_disabled.png + icons/radio_unchecked_disabled@2x.png + icons/radio_unchecked_focus.png + icons/radio_unchecked_focus@2x.png + icons/radio_unchecked_pressed.png + icons/radio_unchecked_pressed@2x.png + icons/toolbar_move_horizontal.png + icons/toolbar_move_horizontal@2x.png + icons/toolbar_move_horizontal_disabled.png + icons/toolbar_move_horizontal_disabled@2x.png + icons/toolbar_move_horizontal_focus.png + icons/toolbar_move_horizontal_focus@2x.png + icons/toolbar_move_horizontal_pressed.png + icons/toolbar_move_horizontal_pressed@2x.png + icons/toolbar_move_vertical.png + icons/toolbar_move_vertical@2x.png + icons/toolbar_move_vertical_disabled.png + icons/toolbar_move_vertical_disabled@2x.png + icons/toolbar_move_vertical_focus.png + icons/toolbar_move_vertical_focus@2x.png + icons/toolbar_move_vertical_pressed.png + icons/toolbar_move_vertical_pressed@2x.png + icons/toolbar_separator_horizontal.png + icons/toolbar_separator_horizontal@2x.png + icons/toolbar_separator_horizontal_disabled.png + icons/toolbar_separator_horizontal_disabled@2x.png + icons/toolbar_separator_horizontal_focus.png + icons/toolbar_separator_horizontal_focus@2x.png + icons/toolbar_separator_horizontal_pressed.png + icons/toolbar_separator_horizontal_pressed@2x.png + icons/toolbar_separator_vertical.png + icons/toolbar_separator_vertical@2x.png + icons/toolbar_separator_vertical_disabled.png + icons/toolbar_separator_vertical_disabled@2x.png + icons/toolbar_separator_vertical_focus.png + icons/toolbar_separator_vertical_focus@2x.png + icons/toolbar_separator_vertical_pressed.png + icons/toolbar_separator_vertical_pressed@2x.png + icons/transparent.png + icons/transparent@2x.png + icons/transparent_disabled.png + icons/transparent_disabled@2x.png + icons/transparent_focus.png + icons/transparent_focus@2x.png + icons/transparent_pressed.png + icons/transparent_pressed@2x.png + icons/window_close.png + icons/window_close@2x.png + icons/window_close_disabled.png + icons/window_close_disabled@2x.png + icons/window_close_focus.png + icons/window_close_focus@2x.png + icons/window_close_pressed.png + icons/window_close_pressed@2x.png + icons/window_grip.png + icons/window_grip@2x.png + icons/window_grip_disabled.png + icons/window_grip_disabled@2x.png + icons/window_grip_focus.png + icons/window_grip_focus@2x.png + icons/window_grip_pressed.png + icons/window_grip_pressed@2x.png + icons/window_minimize.png + icons/window_minimize@2x.png + icons/window_minimize_disabled.png + icons/window_minimize_disabled@2x.png + icons/window_minimize_focus.png + icons/window_minimize_focus@2x.png + icons/window_minimize_pressed.png + icons/window_minimize_pressed@2x.png + icons/window_undock.png + icons/window_undock@2x.png + icons/window_undock_disabled.png + icons/window_undock_disabled@2x.png + icons/window_undock_focus.png + icons/window_undock_focus@2x.png + icons/window_undock_pressed.png + icons/window_undock_pressed@2x.png diff --git a/amoco/ui/graphics/qt_/icons/arrow_down.png b/amoco/ui/graphics/qt_/icons/arrow_down.png new file mode 100644 index 0000000..5575ab5 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down@2x.png b/amoco/ui/graphics/qt_/icons/arrow_down@2x.png new file mode 100644 index 0000000..4596a5c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_disabled.png b/amoco/ui/graphics/qt_/icons/arrow_down_disabled.png new file mode 100644 index 0000000..bdf8c1a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_disabled@2x.png b/amoco/ui/graphics/qt_/icons/arrow_down_disabled@2x.png new file mode 100644 index 0000000..dc1bcb5 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_focus.png b/amoco/ui/graphics/qt_/icons/arrow_down_focus.png new file mode 100644 index 0000000..94fcdc3 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_focus@2x.png b/amoco/ui/graphics/qt_/icons/arrow_down_focus@2x.png new file mode 100644 index 0000000..2b12f74 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_pressed.png b/amoco/ui/graphics/qt_/icons/arrow_down_pressed.png new file mode 100644 index 0000000..4058c58 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_down_pressed@2x.png b/amoco/ui/graphics/qt_/icons/arrow_down_pressed@2x.png new file mode 100644 index 0000000..d43b0af Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_down_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left.png b/amoco/ui/graphics/qt_/icons/arrow_left.png new file mode 100644 index 0000000..7fbc350 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left@2x.png b/amoco/ui/graphics/qt_/icons/arrow_left@2x.png new file mode 100644 index 0000000..dc649ca Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_disabled.png b/amoco/ui/graphics/qt_/icons/arrow_left_disabled.png new file mode 100644 index 0000000..fa3b282 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_disabled@2x.png b/amoco/ui/graphics/qt_/icons/arrow_left_disabled@2x.png new file mode 100644 index 0000000..87c928e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_focus.png b/amoco/ui/graphics/qt_/icons/arrow_left_focus.png new file mode 100644 index 0000000..52a0d91 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_focus@2x.png b/amoco/ui/graphics/qt_/icons/arrow_left_focus@2x.png new file mode 100644 index 0000000..0ee7029 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_pressed.png b/amoco/ui/graphics/qt_/icons/arrow_left_pressed.png new file mode 100644 index 0000000..c04ce09 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_left_pressed@2x.png b/amoco/ui/graphics/qt_/icons/arrow_left_pressed@2x.png new file mode 100644 index 0000000..02218c8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_left_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right.png b/amoco/ui/graphics/qt_/icons/arrow_right.png new file mode 100644 index 0000000..fd31b4f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right@2x.png b/amoco/ui/graphics/qt_/icons/arrow_right@2x.png new file mode 100644 index 0000000..4dbc931 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_disabled.png b/amoco/ui/graphics/qt_/icons/arrow_right_disabled.png new file mode 100644 index 0000000..bb4cdb0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_disabled@2x.png b/amoco/ui/graphics/qt_/icons/arrow_right_disabled@2x.png new file mode 100644 index 0000000..50f1730 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_focus.png b/amoco/ui/graphics/qt_/icons/arrow_right_focus.png new file mode 100644 index 0000000..9dd8f0f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_focus@2x.png b/amoco/ui/graphics/qt_/icons/arrow_right_focus@2x.png new file mode 100644 index 0000000..1ac9d5c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_pressed.png b/amoco/ui/graphics/qt_/icons/arrow_right_pressed.png new file mode 100644 index 0000000..8ce10fc Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_right_pressed@2x.png b/amoco/ui/graphics/qt_/icons/arrow_right_pressed@2x.png new file mode 100644 index 0000000..86e3b92 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_right_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up.png b/amoco/ui/graphics/qt_/icons/arrow_up.png new file mode 100644 index 0000000..2ea571e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up@2x.png b/amoco/ui/graphics/qt_/icons/arrow_up@2x.png new file mode 100644 index 0000000..51b1d72 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_disabled.png b/amoco/ui/graphics/qt_/icons/arrow_up_disabled.png new file mode 100644 index 0000000..146b65f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_disabled@2x.png b/amoco/ui/graphics/qt_/icons/arrow_up_disabled@2x.png new file mode 100644 index 0000000..cacee7f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_focus.png b/amoco/ui/graphics/qt_/icons/arrow_up_focus.png new file mode 100644 index 0000000..ab33162 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_focus@2x.png b/amoco/ui/graphics/qt_/icons/arrow_up_focus@2x.png new file mode 100644 index 0000000..0c8ef33 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_pressed.png b/amoco/ui/graphics/qt_/icons/arrow_up_pressed.png new file mode 100644 index 0000000..c3368d0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/arrow_up_pressed@2x.png b/amoco/ui/graphics/qt_/icons/arrow_up_pressed@2x.png new file mode 100644 index 0000000..a638196 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/arrow_up_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon.png b/amoco/ui/graphics/qt_/icons/base_icon.png new file mode 100644 index 0000000..1aeed55 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon@2x.png b/amoco/ui/graphics/qt_/icons/base_icon@2x.png new file mode 100644 index 0000000..f42fc66 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_disabled.png b/amoco/ui/graphics/qt_/icons/base_icon_disabled.png new file mode 100644 index 0000000..1aeed55 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_disabled@2x.png b/amoco/ui/graphics/qt_/icons/base_icon_disabled@2x.png new file mode 100644 index 0000000..f42fc66 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_focus.png b/amoco/ui/graphics/qt_/icons/base_icon_focus.png new file mode 100644 index 0000000..1aeed55 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_focus@2x.png b/amoco/ui/graphics/qt_/icons/base_icon_focus@2x.png new file mode 100644 index 0000000..f42fc66 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_pressed.png b/amoco/ui/graphics/qt_/icons/base_icon_pressed.png new file mode 100644 index 0000000..1aeed55 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/base_icon_pressed@2x.png b/amoco/ui/graphics/qt_/icons/base_icon_pressed@2x.png new file mode 100644 index 0000000..f42fc66 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/base_icon_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed.png b/amoco/ui/graphics/qt_/icons/branch_closed.png new file mode 100644 index 0000000..d484c32 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed@2x.png b/amoco/ui/graphics/qt_/icons/branch_closed@2x.png new file mode 100644 index 0000000..f49651b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_disabled.png b/amoco/ui/graphics/qt_/icons/branch_closed_disabled.png new file mode 100644 index 0000000..aa62252 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_disabled@2x.png b/amoco/ui/graphics/qt_/icons/branch_closed_disabled@2x.png new file mode 100644 index 0000000..ac318f5 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_focus.png b/amoco/ui/graphics/qt_/icons/branch_closed_focus.png new file mode 100644 index 0000000..0a98eab Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_focus@2x.png b/amoco/ui/graphics/qt_/icons/branch_closed_focus@2x.png new file mode 100644 index 0000000..39fd0d0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_pressed.png b/amoco/ui/graphics/qt_/icons/branch_closed_pressed.png new file mode 100644 index 0000000..049f4bf Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_closed_pressed@2x.png b/amoco/ui/graphics/qt_/icons/branch_closed_pressed@2x.png new file mode 100644 index 0000000..f58ae22 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_closed_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end.png b/amoco/ui/graphics/qt_/icons/branch_end.png new file mode 100644 index 0000000..2109845 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end@2x.png b/amoco/ui/graphics/qt_/icons/branch_end@2x.png new file mode 100644 index 0000000..91f3bd0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_disabled.png b/amoco/ui/graphics/qt_/icons/branch_end_disabled.png new file mode 100644 index 0000000..fe819bc Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_disabled@2x.png b/amoco/ui/graphics/qt_/icons/branch_end_disabled@2x.png new file mode 100644 index 0000000..5802477 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_focus.png b/amoco/ui/graphics/qt_/icons/branch_end_focus.png new file mode 100644 index 0000000..9a978c0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_focus@2x.png b/amoco/ui/graphics/qt_/icons/branch_end_focus@2x.png new file mode 100644 index 0000000..ece9b82 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_pressed.png b/amoco/ui/graphics/qt_/icons/branch_end_pressed.png new file mode 100644 index 0000000..1d40509 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_end_pressed@2x.png b/amoco/ui/graphics/qt_/icons/branch_end_pressed@2x.png new file mode 100644 index 0000000..4822745 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_end_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line.png b/amoco/ui/graphics/qt_/icons/branch_line.png new file mode 100644 index 0000000..75cc027 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line@2x.png b/amoco/ui/graphics/qt_/icons/branch_line@2x.png new file mode 100644 index 0000000..7273705 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_disabled.png b/amoco/ui/graphics/qt_/icons/branch_line_disabled.png new file mode 100644 index 0000000..01c6cff Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_disabled@2x.png b/amoco/ui/graphics/qt_/icons/branch_line_disabled@2x.png new file mode 100644 index 0000000..57789e9 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_focus.png b/amoco/ui/graphics/qt_/icons/branch_line_focus.png new file mode 100644 index 0000000..5996262 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_focus@2x.png b/amoco/ui/graphics/qt_/icons/branch_line_focus@2x.png new file mode 100644 index 0000000..34e7d60 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_pressed.png b/amoco/ui/graphics/qt_/icons/branch_line_pressed.png new file mode 100644 index 0000000..6a54b09 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_line_pressed@2x.png b/amoco/ui/graphics/qt_/icons/branch_line_pressed@2x.png new file mode 100644 index 0000000..fb74fd3 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_line_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more.png b/amoco/ui/graphics/qt_/icons/branch_more.png new file mode 100644 index 0000000..045f963 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more@2x.png b/amoco/ui/graphics/qt_/icons/branch_more@2x.png new file mode 100644 index 0000000..ccde093 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_disabled.png b/amoco/ui/graphics/qt_/icons/branch_more_disabled.png new file mode 100644 index 0000000..8630b91 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_disabled@2x.png b/amoco/ui/graphics/qt_/icons/branch_more_disabled@2x.png new file mode 100644 index 0000000..37d2cdb Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_focus.png b/amoco/ui/graphics/qt_/icons/branch_more_focus.png new file mode 100644 index 0000000..3806736 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_focus@2x.png b/amoco/ui/graphics/qt_/icons/branch_more_focus@2x.png new file mode 100644 index 0000000..d80ccb8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_pressed.png b/amoco/ui/graphics/qt_/icons/branch_more_pressed.png new file mode 100644 index 0000000..a306eb2 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_more_pressed@2x.png b/amoco/ui/graphics/qt_/icons/branch_more_pressed@2x.png new file mode 100644 index 0000000..7044b28 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_more_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open.png b/amoco/ui/graphics/qt_/icons/branch_open.png new file mode 100644 index 0000000..445ec71 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open@2x.png b/amoco/ui/graphics/qt_/icons/branch_open@2x.png new file mode 100644 index 0000000..febb318 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_disabled.png b/amoco/ui/graphics/qt_/icons/branch_open_disabled.png new file mode 100644 index 0000000..3b840d7 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_disabled@2x.png b/amoco/ui/graphics/qt_/icons/branch_open_disabled@2x.png new file mode 100644 index 0000000..d6c5b40 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_focus.png b/amoco/ui/graphics/qt_/icons/branch_open_focus.png new file mode 100644 index 0000000..fecf873 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_focus@2x.png b/amoco/ui/graphics/qt_/icons/branch_open_focus@2x.png new file mode 100644 index 0000000..296d175 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_pressed.png b/amoco/ui/graphics/qt_/icons/branch_open_pressed.png new file mode 100644 index 0000000..8a7cffa Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/branch_open_pressed@2x.png b/amoco/ui/graphics/qt_/icons/branch_open_pressed@2x.png new file mode 100644 index 0000000..24e282c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/branch_open_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked.png b/amoco/ui/graphics/qt_/icons/checkbox_checked.png new file mode 100644 index 0000000..aa5f567 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_checked@2x.png new file mode 100644 index 0000000..60b4fb2 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled.png new file mode 100644 index 0000000..208f370 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled@2x.png new file mode 100644 index 0000000..7c8ad0c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_focus.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_focus.png new file mode 100644 index 0000000..a35def3 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_focus@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_focus@2x.png new file mode 100644 index 0000000..925cd36 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed.png new file mode 100644 index 0000000..f95dc13 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed@2x.png new file mode 100644 index 0000000..641c047 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_checked_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate.png new file mode 100644 index 0000000..02de1ad Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate@2x.png new file mode 100644 index 0000000..8fabf6e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled.png new file mode 100644 index 0000000..df99aff Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled@2x.png new file mode 100644 index 0000000..3102eaa Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus.png new file mode 100644 index 0000000..3704543 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus@2x.png new file mode 100644 index 0000000..8da0a8c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed.png new file mode 100644 index 0000000..b971d7f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed@2x.png new file mode 100644 index 0000000..9e37b84 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_indeterminate_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked.png new file mode 100644 index 0000000..80bcf2b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked@2x.png new file mode 100644 index 0000000..df0fa4d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled.png new file mode 100644 index 0000000..ede58c8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled@2x.png new file mode 100644 index 0000000..6721b38 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus.png new file mode 100644 index 0000000..3883d2d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus@2x.png new file mode 100644 index 0000000..35c061c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed.png new file mode 100644 index 0000000..d98639e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed@2x.png b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed@2x.png new file mode 100644 index 0000000..88a5246 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/checkbox_unchecked_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal.png b/amoco/ui/graphics/qt_/icons/line_horizontal.png new file mode 100644 index 0000000..bc858c8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal@2x.png b/amoco/ui/graphics/qt_/icons/line_horizontal@2x.png new file mode 100644 index 0000000..7ea4f9c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_disabled.png b/amoco/ui/graphics/qt_/icons/line_horizontal_disabled.png new file mode 100644 index 0000000..72e073a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_disabled@2x.png b/amoco/ui/graphics/qt_/icons/line_horizontal_disabled@2x.png new file mode 100644 index 0000000..09a439d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_focus.png b/amoco/ui/graphics/qt_/icons/line_horizontal_focus.png new file mode 100644 index 0000000..c84512b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_focus@2x.png b/amoco/ui/graphics/qt_/icons/line_horizontal_focus@2x.png new file mode 100644 index 0000000..8dd58f6 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_pressed.png b/amoco/ui/graphics/qt_/icons/line_horizontal_pressed.png new file mode 100644 index 0000000..7ca2605 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_horizontal_pressed@2x.png b/amoco/ui/graphics/qt_/icons/line_horizontal_pressed@2x.png new file mode 100644 index 0000000..bd96617 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_horizontal_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical.png b/amoco/ui/graphics/qt_/icons/line_vertical.png new file mode 100644 index 0000000..49a9105 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical@2x.png b/amoco/ui/graphics/qt_/icons/line_vertical@2x.png new file mode 100644 index 0000000..cbb017e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_disabled.png b/amoco/ui/graphics/qt_/icons/line_vertical_disabled.png new file mode 100644 index 0000000..9658546 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_disabled@2x.png b/amoco/ui/graphics/qt_/icons/line_vertical_disabled@2x.png new file mode 100644 index 0000000..7836a94 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_focus.png b/amoco/ui/graphics/qt_/icons/line_vertical_focus.png new file mode 100644 index 0000000..512ee7d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_focus@2x.png b/amoco/ui/graphics/qt_/icons/line_vertical_focus@2x.png new file mode 100644 index 0000000..af50325 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_pressed.png b/amoco/ui/graphics/qt_/icons/line_vertical_pressed.png new file mode 100644 index 0000000..b8dd215 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/line_vertical_pressed@2x.png b/amoco/ui/graphics/qt_/icons/line_vertical_pressed@2x.png new file mode 100644 index 0000000..e1d43a8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/line_vertical_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked.png b/amoco/ui/graphics/qt_/icons/radio_checked.png new file mode 100644 index 0000000..2a1d26a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked@2x.png b/amoco/ui/graphics/qt_/icons/radio_checked@2x.png new file mode 100644 index 0000000..eb2cbb4 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_disabled.png b/amoco/ui/graphics/qt_/icons/radio_checked_disabled.png new file mode 100644 index 0000000..f78c153 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_disabled@2x.png b/amoco/ui/graphics/qt_/icons/radio_checked_disabled@2x.png new file mode 100644 index 0000000..30168e8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_focus.png b/amoco/ui/graphics/qt_/icons/radio_checked_focus.png new file mode 100644 index 0000000..6d9c980 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_focus@2x.png b/amoco/ui/graphics/qt_/icons/radio_checked_focus@2x.png new file mode 100644 index 0000000..63476a0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_pressed.png b/amoco/ui/graphics/qt_/icons/radio_checked_pressed.png new file mode 100644 index 0000000..421ecb4 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_checked_pressed@2x.png b/amoco/ui/graphics/qt_/icons/radio_checked_pressed@2x.png new file mode 100644 index 0000000..9030e10 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_checked_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked.png b/amoco/ui/graphics/qt_/icons/radio_unchecked.png new file mode 100644 index 0000000..23b06ce Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked@2x.png b/amoco/ui/graphics/qt_/icons/radio_unchecked@2x.png new file mode 100644 index 0000000..41e790a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled.png new file mode 100644 index 0000000..075ca85 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled@2x.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled@2x.png new file mode 100644 index 0000000..61cd48f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_focus.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_focus.png new file mode 100644 index 0000000..d587580 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_focus@2x.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_focus@2x.png new file mode 100644 index 0000000..0f12c86 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed.png new file mode 100644 index 0000000..37c09a6 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed@2x.png b/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed@2x.png new file mode 100644 index 0000000..9e424e4 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/radio_unchecked_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal.png new file mode 100644 index 0000000..9d2f51f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal@2x.png new file mode 100644 index 0000000..c35b465 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled.png new file mode 100644 index 0000000..013ac45 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled@2x.png new file mode 100644 index 0000000..f713dd4 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus.png new file mode 100644 index 0000000..6d0d425 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus@2x.png new file mode 100644 index 0000000..0a5ca39 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed.png new file mode 100644 index 0000000..e414c0c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed@2x.png new file mode 100644 index 0000000..e8e8af2 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_horizontal_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical.png new file mode 100644 index 0000000..140846d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical@2x.png new file mode 100644 index 0000000..7edf454 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled.png new file mode 100644 index 0000000..5cd85dd Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled@2x.png new file mode 100644 index 0000000..07d5ae1 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus.png new file mode 100644 index 0000000..9aac036 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus@2x.png new file mode 100644 index 0000000..c3b1d18 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed.png new file mode 100644 index 0000000..30b3921 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed@2x.png new file mode 100644 index 0000000..bd01207 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_move_vertical_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal.png new file mode 100644 index 0000000..96e2689 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal@2x.png new file mode 100644 index 0000000..5944e44 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled.png new file mode 100644 index 0000000..941e145 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled@2x.png new file mode 100644 index 0000000..e44a33b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus.png new file mode 100644 index 0000000..590b314 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus@2x.png new file mode 100644 index 0000000..ca88313 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed.png new file mode 100644 index 0000000..3800468 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed@2x.png new file mode 100644 index 0000000..d4b88c0 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_horizontal_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical.png new file mode 100644 index 0000000..b503c80 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical@2x.png new file mode 100644 index 0000000..2725a7f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled.png new file mode 100644 index 0000000..6aa1fbd Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled@2x.png new file mode 100644 index 0000000..8e54cfa Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus.png new file mode 100644 index 0000000..fcdfc0f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus@2x.png new file mode 100644 index 0000000..51b0839 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed.png new file mode 100644 index 0000000..9d6f84d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed@2x.png b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed@2x.png new file mode 100644 index 0000000..3876a8e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/toolbar_separator_vertical_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent.png b/amoco/ui/graphics/qt_/icons/transparent.png new file mode 100644 index 0000000..3a95111 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent@2x.png b/amoco/ui/graphics/qt_/icons/transparent@2x.png new file mode 100644 index 0000000..4c4b952 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_disabled.png b/amoco/ui/graphics/qt_/icons/transparent_disabled.png new file mode 100644 index 0000000..3a95111 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_disabled@2x.png b/amoco/ui/graphics/qt_/icons/transparent_disabled@2x.png new file mode 100644 index 0000000..4c4b952 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_focus.png b/amoco/ui/graphics/qt_/icons/transparent_focus.png new file mode 100644 index 0000000..3a95111 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_focus@2x.png b/amoco/ui/graphics/qt_/icons/transparent_focus@2x.png new file mode 100644 index 0000000..4c4b952 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_pressed.png b/amoco/ui/graphics/qt_/icons/transparent_pressed.png new file mode 100644 index 0000000..3a95111 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/transparent_pressed@2x.png b/amoco/ui/graphics/qt_/icons/transparent_pressed@2x.png new file mode 100644 index 0000000..4c4b952 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/transparent_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close.png b/amoco/ui/graphics/qt_/icons/window_close.png new file mode 100644 index 0000000..0115ca3 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close@2x.png b/amoco/ui/graphics/qt_/icons/window_close@2x.png new file mode 100644 index 0000000..41dcd81 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_disabled.png b/amoco/ui/graphics/qt_/icons/window_close_disabled.png new file mode 100644 index 0000000..55144ff Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_disabled@2x.png b/amoco/ui/graphics/qt_/icons/window_close_disabled@2x.png new file mode 100644 index 0000000..766aef7 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_focus.png b/amoco/ui/graphics/qt_/icons/window_close_focus.png new file mode 100644 index 0000000..61df25f Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_focus@2x.png b/amoco/ui/graphics/qt_/icons/window_close_focus@2x.png new file mode 100644 index 0000000..2ea50b1 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_pressed.png b/amoco/ui/graphics/qt_/icons/window_close_pressed.png new file mode 100644 index 0000000..042311d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_close_pressed@2x.png b/amoco/ui/graphics/qt_/icons/window_close_pressed@2x.png new file mode 100644 index 0000000..b54d9a1 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_close_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip.png b/amoco/ui/graphics/qt_/icons/window_grip.png new file mode 100644 index 0000000..9ea1c43 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip@2x.png b/amoco/ui/graphics/qt_/icons/window_grip@2x.png new file mode 100644 index 0000000..b31309e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_disabled.png b/amoco/ui/graphics/qt_/icons/window_grip_disabled.png new file mode 100644 index 0000000..b66e23b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_disabled@2x.png b/amoco/ui/graphics/qt_/icons/window_grip_disabled@2x.png new file mode 100644 index 0000000..ee3d0ba Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_focus.png b/amoco/ui/graphics/qt_/icons/window_grip_focus.png new file mode 100644 index 0000000..400af15 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_focus@2x.png b/amoco/ui/graphics/qt_/icons/window_grip_focus@2x.png new file mode 100644 index 0000000..83c9ec6 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_pressed.png b/amoco/ui/graphics/qt_/icons/window_grip_pressed.png new file mode 100644 index 0000000..f71dd8c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_grip_pressed@2x.png b/amoco/ui/graphics/qt_/icons/window_grip_pressed@2x.png new file mode 100644 index 0000000..109878a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_grip_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize.png b/amoco/ui/graphics/qt_/icons/window_minimize.png new file mode 100644 index 0000000..07517b9 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize@2x.png b/amoco/ui/graphics/qt_/icons/window_minimize@2x.png new file mode 100644 index 0000000..434bb07 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_disabled.png b/amoco/ui/graphics/qt_/icons/window_minimize_disabled.png new file mode 100644 index 0000000..a1ee4ae Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_disabled@2x.png b/amoco/ui/graphics/qt_/icons/window_minimize_disabled@2x.png new file mode 100644 index 0000000..8454ad8 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_focus.png b/amoco/ui/graphics/qt_/icons/window_minimize_focus.png new file mode 100644 index 0000000..3b56123 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_focus@2x.png b/amoco/ui/graphics/qt_/icons/window_minimize_focus@2x.png new file mode 100644 index 0000000..a66fb71 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_pressed.png b/amoco/ui/graphics/qt_/icons/window_minimize_pressed.png new file mode 100644 index 0000000..9b70c0a Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_minimize_pressed@2x.png b/amoco/ui/graphics/qt_/icons/window_minimize_pressed@2x.png new file mode 100644 index 0000000..5750a8e Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_minimize_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock.png b/amoco/ui/graphics/qt_/icons/window_undock.png new file mode 100644 index 0000000..9be9cdf Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock@2x.png b/amoco/ui/graphics/qt_/icons/window_undock@2x.png new file mode 100644 index 0000000..40345ab Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_disabled.png b/amoco/ui/graphics/qt_/icons/window_undock_disabled.png new file mode 100644 index 0000000..ea92aee Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_disabled.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_disabled@2x.png b/amoco/ui/graphics/qt_/icons/window_undock_disabled@2x.png new file mode 100644 index 0000000..fb8d548 Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_disabled@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_focus.png b/amoco/ui/graphics/qt_/icons/window_undock_focus.png new file mode 100644 index 0000000..5b0338d Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_focus.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_focus@2x.png b/amoco/ui/graphics/qt_/icons/window_undock_focus@2x.png new file mode 100644 index 0000000..9fea75b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_focus@2x.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_pressed.png b/amoco/ui/graphics/qt_/icons/window_undock_pressed.png new file mode 100644 index 0000000..4bc657b Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_pressed.png differ diff --git a/amoco/ui/graphics/qt_/icons/window_undock_pressed@2x.png b/amoco/ui/graphics/qt_/icons/window_undock_pressed@2x.png new file mode 100644 index 0000000..2ea0c2c Binary files /dev/null and b/amoco/ui/graphics/qt_/icons/window_undock_pressed@2x.png differ diff --git a/amoco/ui/graphics/qt_/infoview.py b/amoco/ui/graphics/qt_/infoview.py new file mode 100644 index 0000000..9f4b400 --- /dev/null +++ b/amoco/ui/graphics/qt_/infoview.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- + +# This code is part of Amoco +# Copyright (C) 2020 Axel Tillequin (bdcht3@gmail.com) +# published under GPLv2 license + +from PySide2.QtCore import Qt + +from .structview import StructItem + +def InfoView(task): + v = None + return v + diff --git a/amoco/ui/graphics/qt_/models.py b/amoco/ui/graphics/qt_/models.py index e03e1e8..1672faf 100644 --- a/amoco/ui/graphics/qt_/models.py +++ b/amoco/ui/graphics/qt_/models.py @@ -11,6 +11,7 @@ class DataIOModel(QObject): def __init__(self,parent=None,data=None): super().__init__(parent) self.data = data + self.full = data[0:] self.cur = 0 self.linesize = 16 diff --git a/amoco/ui/graphics/qt_/rc_icons.py b/amoco/ui/graphics/qt_/rc_icons.py new file mode 100644 index 0000000..e804001 --- /dev/null +++ b/amoco/ui/graphics/qt_/rc_icons.py @@ -0,0 +1,10698 @@ +# Resource object code (Python 3) +# Created by: object code +# Created by: The Resource Compiler for Qt version 5.15.2 +# WARNING! All changes made in this file will be lost! + +from PySide2 import QtCore + +qt_resource_data = b"\ +\x00\x00\x00h\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x1aIDATX\x85\xed\ +\xc1\x01\x01\x00\x00\x00\x82 \xff\xafnH@\x01\x00\x00\ +\x00\xef\x06\x10 \x00\x01G\x01\xa0\x88\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00x\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00*IDATX\x85\xed\ +\xceA\x01\x00 \x0c\xc4\xb0\x0dMx\x9a\x1f\x0c\x83\x8c\ +\xe3\x91\x18h\xab\x00\x80\xb0\xdesnr`%\xe3\x00\ +\xc0\x17\x1e\xbe\x17\x020\xed\xb9[\x96\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00x\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00*IDATX\x85\xed\ +\xceA\x11\x00 \x0c\x04\xb1\x16\xff\x22\xe9 \x04d\x1c\ +\x8f\xc4\xc0n\x15\x00\x10\xd6{\xceM\x0e\xacd\x1c\x00\ +\xf8\xc2\x03H\xae\x03\xa7\xd4\xed\xa0G\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x04u\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04'IDATx\x9c\xed\ +\x9bOh\x5cU\x14\xc6\x7f\xe7\xcd\xb4Z\x8c\x08\xb6\xba\ +0\xa8+Q\xd4\x8dP\x84\x22Hl'\x89A\x0cv\ +\xc6\xd1\x95\xd8\xfc\x99P\x17\xa2\x05E\xf0\x0f\xe3\xd0\x8a\ +\x15\x04\x17\x22\xb6I\xa6\xc6E\x8a\x9a&\x0d\xa1\x1a;\ +Id\x0a\x8a (\x08\xc5\x85 \xe2\xa2A\x04\xad\x14\ +m\x0b\x93\xb9\xc7E\x1cy\xf3f\xc0\x14\xdf\xbd\xefb\ +\xe6[~\x1f\xdcs\xeew\xce\xfd\xf7\x98\x81\x0e:\xe8\ +`3C\x92N`\xa3\xc8dG\x8b\x22\xf22\x18Q\ +\xd5C\xcbs\xc7^\x8dc\xdc \x8eAl\xa3?;\ +\xfc\x00B\x114\x0d\x92\x12\x09^\x89k\xect\x5c\x03\ +\xd9Bonx\xa7!X\x90\xe6n\x8d\xadp^w\ +@_n\xec\x0e4X\x04\xba\x22\x92\x89+\x86\xb7\x06\ +d\xf2c\xb7(\xa6\x82\xb0\xa3\x8d\xacq\xc5\xf1\xd2\x80\ +\x81\xfc\xd0\x0d\x18S\x01n\xb6\x1d\xcb;\x03\x06\x07\x87\ +\xaf]3\xa9O\x04nw\x11\xcf+\x03z\xf6\xed\xbb\ +\xfa\xd2\xd6`\x1e\xd8\x19\x91bk\xf9(\xbc1\xa0\xa7\ +\xa7\x98\xde\xf2G\xfa8\xca\xee\x88\xa4\xc4\xb8\xe9E\xe1\ +\x8b\x01\x92\xde\xbez\x14eo\x13\xabju\xf2\xe0\x89\ +\x01\x99\xdc\xe8\x1b\x82\x0eGhE\xc4\xea\xe4\xc1\x03\x03\ +z\x1f-\xbc \xf0|\x1b\xc9\xfa\xe4!a\x032\xb9\ +B\x01\xd5\xc3m\xa4\xba\xab\x1c\x123 \x93+\xe4\x04\ +=\xd2D\xae\xef\xf5N*\xdf@\x22\x06\xec\xc9\x162\ +\x82\x1eo\x89\x1f`\xb0x\xe4\xb5\x83s\x03\xfa\xf3#\ +\xf7\x06\xa2\xf3\xc0\xd6\x88dP\xb7\x93\x07\xc7\x06\xec\xc9\ +\x0f\xddi\x8c,\x02\xd7\x84y\xc1}\xe5\x1bp\xf6\x1c\ +\xde\x9d\x1d\xb950R\x01\xae\x8fHF\x13\x9a<8\ +\xea\x80\xbe\xbd\xfboL\x09K@w\x98\x17$\xb1\xca\ +7`\xbd\x032\xf9\xb1\xeb\xd4\xac}\x0ar[\xb3\xa2\ +\x9ad\xe5\x1b\xb0\xda\x01\xbb\xf2\x07\xb6\x891\x0b\xc0=\ +\x11I\xc1\xfe-o#\xb0f@OO1\xdd\xa5\x17\ +>\x00\xee\x8fH\xd6\xef\xf7W\x02+\x06\x14\x8b\xc5`\ +\xcb\xf6s\x93\xa8\x0cF$o*\xdf\x80\x0d\x03\xe4\x8b\ +\xb3\xabo\x02O6\xb1\xda\xa8|\xe2\xcb\xbe\x09\xb1\x1b\ +\x90\xc9\x8d\xbe(\xe8\x81\x16A\xfci\xfb0b5\xa0\ +7W\xd8/p\xa8U\x11g\x8f\x9b+El\x06\xf4\ +fG\x0e\x83\xbe\x1b\xe5\xc5\xc3\xb6\x0f#\xbe\x0e\x10\x89\ +~\xd0\x00$\xd1[\xdeF\x10\x9b\x01\xd2\xf6\x0d\xef\xf5\ +\xdc\x81\x18\x0d0\xc83\xb4\xce8\xf1/N\xff\x86\xd8\ +\x12\x5c\x9e\x9d\xf8\x08x\xbaU\xd1T\x5c1l \xd6\ +\x0a-\xcdN\xbe\x03Zlf\x05\xc0[\x13bo\xd1\ +\xa5\xd9\xf2A\x11\xde\x8e\xf2\x8az\xb9\x1cl$\xa5\xbb\ +\xee\xea~V\x95\xe90)\x88X\x8a\xf7\x9f`%\xa1\ +R\xa9d\xce\xef\x08\x86\x10\xf98\x22\x09\x9eu\x82\xb5\ +d\xbe\x1e\x1f\xaf]uY\x1eC\xf5\xf3fED=\ +\xea\x04\xab\x89\x9c:5~\xb1f\xea\x0f\x83|\x1b\xe6\ +\x05\xc4\x97=\xc1z\x12\xd5\xf9\xa9\xdfkA\xedA\x81\ +\x1f\xc2\xbc \x22\x1e\xfcH\xcbI\x15\xaa3S?\x13\ +\xd0\x8b\xb0\x1a\xe6\x15\x02\x91dMp\xd6\x86\x95\x99\xc9\ +\x1f\xa5\xae\xfd(\xe7\xc3\xbc*\x01\xeb'D\x22p\xba\ +\x0e+'\xcbgM\xca<\x04\x5clV4 \xa1\xe5\ +\xe0|#Z\x999\xf6\xa5\x22Y\xa0\xd6&\x17\xe7&\ +$\xb2\x13/\xcfN\x9c\x16\xe5\x09\xa2\x8f'%p\xbd\ +1&v\x14U\xe6&?D\xf4\xa9&R\xd67F\ +\x97\x1e$z\x16/\x9d(\x1fEx\xa9Uq\xf7\x82\ +L\xfc2\xb2tb\xf2uE\xdej#9\xc9-q\ +\x03\x00\xbd\xef\xee\x9b\x9e\x03\xde\x8f\xf0N\xae\xcc>\x18\ +@\xa9T2\xb5_\xbbG\x11]\x08\xf3\x7fo\x88V\ +s\xf4\xc2\x00\x80j\xb5\xb4V\xeb\xaa?\x8er&\x22\ +Y5\xc1\x1b\x03\x00\xaaSS\x97\xd3\xdb.\x0d*|\ +\x13\x91\xac\x1d\x0b^\x19\x00\xb08=}!0\xe9\x01\ +\xe0{\x17\xf1\xbc3\x00\xa0r\xf2\xc8/u\xd5>\xe0\ +\x9c\xedX^\x1a\x00\xf0\xd9\x5c\xf9'\x13\xd4\xfb\x80\xdf\ +\xda\xc8\xb1-\x09o\x0d\x00X\x99y\xef\xbb \xd0\x01\ +\xe0\xcf\x88\xb49\xfe2\x03pz\xa6\xfc\x95Qy\x04\ +\xf4\x9fw\x83l\x86\xbf\xcc\x84\xb127\xb1\x0c\x1c\x04\ +\xad#\xd4Ex-\xe9\x9c:\xe8\xa0\x83\xff\x07\xfe\x02\ +\xec5-\x8c\x9b\x14\xe3m\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x00\xa4\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00VIDATX\x85c\ +`\xa0\x00X\xac\xfd\xdb`\xb1\xf6o\x03%f0Q\ +\xa2\x99\x1a`\xd4\x01\xa3\x0e\x18u\xc0\xa8\x03F\x1d0\ +\xea\x80\x01w\x00\x0b\xe5F\xfcw\xa0\xa4J\x1e\x0e!\ +\xc0x\xe0D0s\x03\xb9\xba\x07<\x04F\x1d0\xea\ +\x80Q\x07\x8c:`\xd4\x01\xa3\x0e\x18p\x07\x00\x000\ +\xcb\x0b\x07\x89(GG\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x04,\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xdeIDATx\x9c\xed\ +\x98\xcfk\x5cU\x14\xc7?\xe7\xbe44\x91\x8a`q\ +\x93\xb6.\xb2\xd0\x90\x22\xc6B\x17\xadY\xc4\xa6i\x0a\ +Z51\x0b\x17\x22M\x13\xf0\x1f\x10\x7f@\x91\xa0\x82\ +\xbaP\x0a.4\x9di\x04\x89\x053\x9dt\x84\x9a2\ +3)#\xe2\xaa6\xe9\xaa1]\x04m+\x88\xa6\x0b\ +\x9b\xd2@f\xe6\x1d\x17Ic\xdf\x9b7\xc9df\xde\ +4\xda\xfbY\xbe\xf3\xeey\xdfs\xef\xb9\xe7\xbe{\xc0\ +b\xb1X,\x16\x8b\xc5b\xb1X,\x16\x8b\xc5\xf2`\ +!\xfe\x07\x9d=\xfd\xef\x891\xc7Q\x1c\xc0\x05\xb4\xf6\ +\xb2\xaa\x8a\x00\x06!\xaf\xae\xfb~:~j\xe8^c\ +]\xc1\xdb\xb2\x1a<\x80\xa9\x85\xc2\x9a\xa08\x22\xe68\ +\xe0\x99\x80\xffO\x80eR0\x01\xaa\xee\x07\xa0\xff\xf5\ +\xb4\x0f@u96/\x055\x00\xe0PO\x7fG^\ +LB`\x9b\xc7\x05\xa8,\xd7\x85\xcd\x8b\xaaA\xc4\x13\ +\x97\xc2\x02\xc2\x91t,\x92\xf1\xbf\x1e8\x01\x00]}\ +\x03{4\xcfy\x84\xed\xfe/\x80q7_m\x14@\ +\x0d\xfe\x98\x94yq\xe8N\x8eE.\x15\x1bU\x94\xee\ +\xbe\xfe'\xf2\xaeI\x01;\xbdNU\x11\xd9l\x99P\ +\x18<\x5cs\x8c\xdbu~\xec\xd4l\xb1AkN\x00\ +@\xd7\x8bGwj\x9d\x93\x04\x9e\xf4\x99\x94\xcd\xb3\x1d\ +\x82\x82\xffEr\xf9\xaedb\xe4\xfaz\x03\xd7$\x99\ +\x18\xb9\x9e\xad7\xed\xc0\xcf>\x93\x80:Acj\x87\ +\xb0\xa2\xc1\x1f\xfc\xc5l\xbdi_/x(\xf1\x18\xcc\ +\x9c\x1e\x9eo\xc8\xba\xcf!\x5c(\x22\xa0\xe6\x08\x08\xb8\ +N@\x12O6d\xdd\x03\x99\xd3\xc3\xf3\xa5\xf8)Y\ +\xfc\xec\xec\xf4\xd2\xae\xbdO}\xebdM+\xd0\xe2\x91\ +\x02\xa6\x84\xddTED\x8a|3^w\xa7\xa1\xf7\xdc\ +\xb9/\xef\x94\xeaiC\xab\xf7\xeb\xe5\xcb\xb9]\x8f\xbd\ +p\xc6i\x5ch\x02\x9e\x09R\x156r\xf7\xd7\xb6\x90\ +\xe8#\xe6\xef\xd7\x13\x89\x91\xec\x06\xfd\x95\xa7\xa3\xb3w\ +\xe0c\x817\x03\x1c\xba\x1a\xd6\x19)\x08\x1a\x10\xbc\xc8\ +'\xa9\xd8\xc9\xb7)\xe3\xbbe\xef\xdf\xb9\x99\xa9Ts\ +K\xdb\x22\x22\x07\xfdr\xc2\xc8\x85\xa2+\xaf\xfaV\xea\ +Ld\xa8pDiTT\xc0\xe6f\xa6\x7fjnm\ +\xfb\x1d\xe4y\xbc\xd9T\xd5\x19\x10\x10-\x0c\xde\x15e\ +0\x15\x8f~^\xa1\xef\xca\xe9\xec\x1d\xec\x15\xf4\x1b\xa0\ +\xdeg\xaa\xf8_AQ\x13\x90RK*\xbc\x9a\x8eE\ +\xe2\x95\xf8\x86*\xae\xd4\x81\x9e\xc1N#z\x16x\xc8\ +kQ\x85\xf2\xfe\x1a\x15\x8c\x14j\xbc\x8d\xe8K\xa9X\ +t\xb2<\xa5^\xaa\x9a\xaa\x87\xfa\x8e\xedu]\xf9\x1e\ +x\xd4cP\x14\xd9`&(\x06)\xd0w\xd3U9\ +<\x19?y\xb12\xa5\xffR\xf5j\xd5\xf9\xf2@\x8b\ +\x18R@\x93\xcfT\xfav\x08\xb8\xd1\x017\xd4\xa5+\ +=\x1e\x99\xa9\x82\xccU\xaa\xde\x10I\x8fGf\xf2\xaa\ +\xfb\x81\xab>S\xf0\x11\xe6C\x09\x0c\xfe\xaa\x1a\xb3\xbf\ +\xda\xc1CH\x1d\xa1\x0b\xf1\xe8o\xe2\xd6\xb5+Ly\ +\x0c\xcb)\xbd\xd6\xc9\xe3\xf8\x0b\x9e\xc2T\x9d\xc9?\x9b\ +\x1e\x1b\xbe\x16\x82\xd4\xf0Zb\xc9\xf1/\xfe\xdc\xb2u\ +\xb1\x03\xe5\x07\xbfM\x03'!\xf0N\x91\xd9\xb2u\xb1\ +cbl\xe4\xaf\x10$\x02!\xf7\x04'FGoe\ +\x1f\xceu#\xfa\xdd\xbd\xcfW\x96\xd8\x11Ad5+\ +\xbcY/\x90\xc8n\xcb\x1d\x9e\x18\x1d\xbd\x15\xa6\xc6\xd0\ +or\xcb\xf7\x87#1\xa7q\xe1q\xe0i\x9fY\x08\ +,\xc4\xfaU\xf6\xe6\x8e\xd72gO,\x85\xad\xaf&\ +]\xe1Lf(\xb7owS\xbf\x22\x9f\xad\xff\xb6~\ +\xbao\xf7\x8ec\x99\xccP.|e\xb5\xbd\xc3\x02\xc8\ +\xc1W\x06\xdeA\xf90\xd0\xa8\xfan2\x1e\xfd\x88\x1a\ +6\x1ck\xde\xcc\x98\xbb2\xf5csk\xdb\x1f+\xf7\ +\x87\xbb\xa8(o$\xe3\xd1\x13\xb5\xd6s_\xba9s\ +W\xa6/5\xb7\xeeid\xb9\xcfx[\x94\xa3\xc9x\ +\xe4\xeb\xfb\xa1\xc5b\xb1X,\x16\x8b\xc5b\xb1X,\ +\x16\x8b\xc5\xf2\xa0\xf1\x0fdv7\x12o\xd4a\x03\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\x8f\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00AIDATX\x85\xed\ +\xd3\xa1\x11\xc0 \x14\x04\xd1\x85\x9a(\x00\x93Zp\x14\ +\x83J1\x99\xa1\x81\x14\x85\xc2\x22\xf9f\x9f:\xb7\xea\ +@\x92\x14,\xedQ\xda\x98@\xbdT\xfd\xfe\xb7?\x00\ +\xf9JP:\xf0\x05\x92$\x85[\x1c\x18\x0a\x07\xd4\x09\ +\xe9\x09\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x06\xf1\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x06\xa3IDATx\x9c\xed\ +\x9a\xcds[g\x15\x87\x9f\xf3\xca\xed$\x84:M\xbf\ +\x99\xae\xd86m\xda\xea\xc3!\x94\x81\xc6Im'\x8d\ +\xe3\xfe\x01\x85E\x07\xf9cjK\x86UY\xc0\x82\xc9\ +\x02\x86\x81\xda\x96\xa7\xb6lf\xd8\xf5\x1f\xa0\x09\x89\xbf\ +B\x816\xb1%\xab\x1f@7\x9dN\x17\x1d\x86\x19J\ +\x0bq\x9a&J\xf0{X\xc87\x88+\xd9z\xaft\ +om\x06?\xcb\xf7\x9e{\xde\xf3\xfb\xe9\x9cW\xd2\x95\ +`\x97]v\xf9\x7fF\xea-\x1e\xfa\xf6\xcf\xf6\xdd\xb1\ +w\xcf\xf7\xc5h/\xca\x1e\x90Kf\x9d\x9f\xac\xfcr\ +\xe4\xc3/\xba\xc0f\xe8\xf8n\xee\xab6\xc6K\xa0G\ +\x10n`\xe5\xec\xe7m\xe6\xe7\xef\xbd\xf2\xe2g\xfe\xd8\ +\x1a\x03\x9ez\xe1\xa7w\x95\xef\xd8\xfb:\xf0\xa4\xef\xd2\ +\x15U\xdb\xbd:3\xba\x1cU\xe1a\x90J\x8f\xa5\xd4\ +\x98y`\x7f\xf5\xba\xc2;mw\xf2\xcd\xe5\x5cf\xad\ +z\xdd\xf8\x13\x94\xef\xdc\xfb\x12\xb5\xe2\x01\xf6\x8b\x98\xb9\ +D\xff\xd8\xe1P+\x0e\x91\xcd\xc4\x03\x08\xffZ\xad\x01\xb0\xb7\xc1^\xed\x22f.\ +98\xd1\x11\xb0\xc6\xc8\xe8\x18\xc8%\x1b\x89\x07@t\ +\x8f\x7f\xa9\x9e\x01o8\xec\xd9\x8e2\xbf\x13L\xe8\x18\ +\xc8%-\xba@#\xf1\x00h\x8d\xb6\x1a\x03b\xe8\x19\ +\xe0\x8a\xc3\xde\xdbnB0\xf1\xac\xc5\xe0\xc7\xfe\xc5\x1a\ +\x03\x96\xf3\xd9\xf7\x11\xbap7a[\xc6aC|\xe3\ +\xb6\xaf\xb0f\x0d\xdd\xcb\xf9\xec\xfb\xfe\x0b\xf5F\x80\xe2\ +tfe\xc3\x84\xb5z\xd7}\xecG\x99K\xa5\xc7R\ +\x0e\xb1\xa1\x10\x1f\x1aOl\x88\xbf\xdb!\xfc\xaa5t\ +\x97\xa62\x97\xeb]\xac\xfbA\xc8#98\xd1\x812\ +\x0f\xb4;ltE\xac}\xa60;Zp\x88m\x9a\ +\xf8\xd0x\xc2XY\xc0]|\xd7f\xe2\xa1\x81\x01\xb0\ +\xb3L\x08[<8\x18\x00\x90\xe8\x1f;,b\xe6p\ +4\xc1 \xc7W\xf2#E\x97\xdc\xae$\xfa'\xe3\x22\ +v\x018\xe0\x10~\xd5`\xbaW\xf2\xc3\x97\x1a\x05:\ +\x19P)`\xfbL\x88J4v(h\xbd~Z\ +2 98\xfe(\x88\xf3\xcc[\x91S\xa5\xe9\x91\xa5\ +\xcd\x02\x8a\xd3#\xbf\x0dh\xc2b\xab&4=\x02\xb7\ +\xc5+\xf7;\x84_\x17\xb4\xb7\x90\xcf.\xba\xe5\xce=\ +\x8d\xea9\x1a\xff]\x07\xe0\xef\xaa\xd2\xb9:3\xf2G\ +\x97\xdc~\x9a\xea\x80Tz\xf2`\x00\xf17\x82\x88\x87\ +\xdb\x9dp\x12\xb8\xee\x10~\x9f\x88.%\xfas\x8f\xb9\ +\xe6\xaf&p\x07\xa4\xd2\x93\x075f/\x06\x10\x7f*\ +\x88\xf8j\x12\xfd\xe3GE\xe4,\x11vB \x03R\ +\xe9\xc9\x83\x18\xbb\xa4\xf0\x80CxK\xe2=\x82\x9a\x80\ +\xe8\xd1\xe2t\xf6O\xae\xf9\x9d\x0d\x08*\x1eKoq\ +6\xb3\xe0\x9a\x7f+\xe2\x83\xb9N\xa3\xfa\x1a\x11\x98\xe0\ +d\xc0\xe1\x81\x89G,\x5c\xdc\x0e\xf1\x1eQ\x99\xd0\xf0\ +\x10\x0c,\x1es:l\xf1\x00\xa5\xe9\x91%A{q\ +<\x18A\x96*\xefT[\xb3e\x074%>?<\ +\xef\x10\xdb4\xa9\x81\xf1c\x8a\xbc\x06\xd4\xfc\xeb\xb3\x06\ +\xe1c\xd0\xce\xad:a\xd3\x0e8<0\xf1\xc8:8\ +\xcf\xbc*}Q\x8b\x07(\xe4\xb3\x8b\x82\x9e\x02n4\ +\x0cV\xee\x07Y\xaa\xbcm\xd7\xa7n\x07x\xe2\x81\x07\ +\x1dj*\xabrzu&3\xe7\x10\x1b\x1aA;A\ +\xd6\xcd\xd1\xc2\xec\xf0\x9fk/\xf982\xf8\x8b\x87o\ +i[\x11x\xc8\xa1\x8em\x11\xef\x91LO\x1c\xc7\xf0\ +k\x1cL\x10\xf8\x1b\xb1X\xb2\xf0\xca\x8b\x1fU\xaf\xd7\ +\x8c\xc0-\xdb\xf6C\xfe\x07\xc4\x03\x14g3\x0bXz\ +q\x18\x07\x85\x07\xb0\xeb?\xf2\xaf\xd7\x9e\x01\xc2\xd3\x0e\ +{\x97\xadH\xdfv\x8a\xf7\xa8\xbc\xe3\x98\xd3\xb8\x98\xa0\ +\x1c\xf5\xaf\xd5\x18\xa0\xb0\xde O\xd9\x8a\xf4\x95\xa6G\ +.\xb8\x97\x19-\x95\xc3\xd7\xc9\x84\x1am5\x06\x08l\ +\xf5\xaa\x96\x05}n'\x89\xf7(\xe6\x87\xe7U\xe9c\ +\x0b\x13D8\xef_\xab1\xc0\xb4\x993\xc0\x07u\xee\ +/\x0b\xfa\x5c!\x9f\xadI\xb2SX\x9d\xc9\xccma\ +\xc2\x87\xff*s\xc6\xbf\x18\xf3/\xfc\xa5p\xee\xfaW\ +\x12\xc7^\x15\x89\xedCyP\x84\x9b(\x8b\x8a\xf9N\ +q&\xba_i\xc3\xe2\xaf\xab\xbf\xf9\xe0\xe1x\xd7Y\ +\xc4<\x04\x1c@\xf9DE_\xb57\xe5\xf9\xb7~\x95\ +\xf9x\xbb\xeb\xdbe\x97]v\x16\xff\x06^\xec\x1f\xa0\ +\xf6^&\xad\x00\x00\x00\x00IEND\xaeB`\x82\ +\ +\x00\x00\x02\x14\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xc6IDATX\x85\xed\ +\x94\xb1j\x14Q\x14\x86\xbf\xff\xee\xa0A\xd0h\x13\x8b\ +\xb4\xda\xd8\xac \xeen\xd4\xd4\x22\x06E\xb1\x11\x05K\ +\x0bQ\x1fA\xf3\x08\x06\x1f@P\x10Bv\xb3\x91\x88\ +\x98.\xe0\x82\x08\x01\xf5\x05\xb4\x12\xc4\xc6JX\xb3s\ +\x7f\x8b\x99\x84$\xbb\xd1\xec\xb0j3_u\x87{\xee\ +\xf9\xffs\xce\xbd\x03%%%%\xff\x19\x15=85\ +\xef\xc9\x98\xf8%PM*\x9a\xec\x5c\xd6\x97\x22yB\ +\x91C\xf5\x05\x1f\x8f\x89\xdf\x00U\x80^\xea\xce\xd4\x92\ +\x8f\x15\xc95t\x07N/\xfad\xb0_\x03\x13\xd8y\ +\x16\x01|5:\xff\xee\xaa>\x0c\x93o\xa8\x0e\xd4\xda\ +\x9e\x0e\xf6*0\x810A)A)`\xe0\xa8\xf0j\ +\xad\xed\xe9\xbfb\xa0\xd6\xf2\x8c\xa2W\x80C\x16\xc6D\ +\x9cKCt\xb6\x1aW\xf4J\xad\xe9\x8b#5P_\ +\xf4M\xe160\x06\xb6L\xdc\x19#\x88d3\x19\x93\ +\xbc\xd4h\xf9\xc6H\x0c4Z\xbe\x87\xfd\x14\xa8\x18\x1b\ +\xd4'\xbe\xc5F\xccb\xa8\x18?k4}\xb7\xb8\x01\ +[\xf5V:k\xfc(\xff\x8c\xfa\xadxn\x01E\xe7\ +q\x96\xe7\x1a\xcd\xf4!\xf6\xae\x97}\xf0\xc6\x03\x87z\ +5\xce\x81\xee\x00\x18\xa26\xa6\xbdG\x9c\xbd\x8d\x00 \ +\xfb\xf1\xdb\x8f\xe1>\xb3\xfd\x05\xf4\x1981\xef}\x07\ +\x93\xf8\x04t\xddY\xa6(\x0d'\xbei\xc2\x08\x112\ +\x11?\xef}\x0b\xb7\xd6nk}W\x03\xa7^\xf8@\ +\xd2\xf3\x02p!\x1b\xb7\x22CV>\x00\x81C.\xf5\ +\xaa\x97\xe8\xda\xda%\xfd\xe83pn\xd9G~v\xbd\ +,q\xc6\x80L\xa4`\xe5;\xd9\xde\x09:]i\xe6\ +\xfd\x15}\x07H6\x82\xd6\xbb\xfe$1\xbe\xe9J\xc5\ +~\xd3\x83\xd0\xf6A\x9f\xddo\x7f\x06\x0e\xc3\x96W\xe0\ +\xd1\x14\xbb'\xec\x7f\xa7URRR\xf2G~\x01Q\ +\xe3\xbar\x94/r\xc5\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x01&\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xd8IDATx\x9c\xed\ +\xd2\xb1M\xc3P\x18F\xd1\x1f\x86\xf0&,\x92\x15R\ + \x1a\x86\xa1\x89\xb2D\x16a\x8bTla\x0a,\xa5\ +\x88h}\x22\xe5\x1e\xc9\xd2s\xf5>_y&\xc93\ +{Q\x17\xbf\xbd\x7f\x1df\xe6\xb4\xbd~|\x9f?/\ +b\xc7\xab\xb8tsZg\x96uf\x99[\x88\xdd\xb1\ +\x00\xdb\x87\xdf\x9d\xf7&\xff\x80\x87P\x00=@+\x80\ +\x1e\xa0\x15@\x0f\xd0\x0a\xa0\x07h\x05\xd0\x03\xb4\x02\xe8\ +\x01Z\x01\xf4\x00\xad\x00z\x80V\x00=@+\x80\x1e\ +\xa0\x15@\x0f\xd0\x0a\xa0\x07h\x05\xd0\x03\xb4\x02\xe8\x01\ +Z\x01\xf4\x00\xad\x00z\x80V\x00=@+\x80\x1e\xa0\ +\x15@\x0f\xd0\x0a\xa0\x07h\x05\xd0\x03\xb4\x02\xe8\x01Z\ +\x01\xf4\x00\xad\x00z\x80V\x00=@\x93\x01~\xfe9\ +\xef\x0a\x06X\x8f3s\xfd{\xd6\xa3\xdb\x91\xe4\x99\xfd\ +\x02\xc9n\x11J\x9d\x22\x1c\x0a\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x02\xe8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\x9aIDATX\x85\xe5\ +\x96\xbbr\xd3@\x14\x86\xbf\xe3\xa4\x00\x9e#%T\xb1\ +R\xf0\x0a\x14\x90\x84\xc4!dr#Dj,7\x99\ +\xe1\x19(e5\x92'\x09\xd8!\xce\xc5\xc00\xc33\ +PY~\x05\xe8\xe0\x0d\x80\x02\xfbP\xc4Jd]l\ +\xcbq\xc3p*i\xb5\xfb\x7f\x9fV\xab\xd9\x85\xff\xbd\ +$\xbc0^:\x0f\xb5 \x1e\xca]\x11^\xb5}\xfb\ +\xe34A\x86Y]R\xe55\xc2oD\xac\xc0+\x7f\ +\x01(\x84\x1d\xb4 G\xc0\x03\x849\x85\x96a\xba\xa5\ +i\xc1\x8b\x96\xb3\xa6\xd0B\x98\x03\xee\xa3z\x18>\xbb\ +\x11\x80;\x911\x05E\x9b\xd3\x90(Z\xce\x1a*\xa7\ +Q\x16p/! \x22\x07@o\x9a\x12\x86\xe9\x96R\ +\xe0=U9H\x08\x04^\xf9\x03\xb0\x91\x22q:\x89\ +\x84a\xba%E\x9bq\xb8 [\x9dZ\xb9\x95\x10\x00\ +\x08|\xfb,Eb&\xafD\x1f\x9exsA\xb6\xda\ +~\xf9]\xb4\xaf\x90R\xf3\xfb\xee\xba\x88\x9e\xc4\x02\xba\ +\x22\xba\xde\xf6*\x97C\xe1\x96\xb3\xaa*M`f\x14\ +P\x9d\ +Z\xb9)\xc2&\xf1\xcf\xa1\xd24,g5Ex%\ +/\x1c\x86\xcc@X\x86U}\xaeJ#&\xdbU\x95\ +g\xe1b\x9a\xdfwWD\xf4,/|,\x01\x00\xc3\ +t7\x14\xad\xa7I\x00\xa4\xc1\x11\xdd\x0a\xbc\xca\xc9\xa8\ +\xec\xb1\x04\xb2$\xb4\xffydPllx.\x81\x88\ +Dc\xc8\xb8\x5c\xf0\xdc\x027\x124@\xe3c\x15\xd8\ +\x0e|\xbb\x91'/\xf3/\xc8*\x15~)\xaa\x89\xf6\ ++\x81\x9fy\xf3r\x09\x14-w\x19\xd5sI\x19\xd7\ +o;/\x9a\xd5\xa7y2s,\xc2\xea\x92\xc2\x050\ +\x1bi\x0eg\x22\x9a\xd3E\xa4\xd4\xdf[F\xd6X3\ +\x90\x05W\xd5\x1d`;\x22\x020\x83\xeaE\xd1r\x97\ +\xa7\x22\xb0`9\x8bY\xf0N\xadR\x0f|\xbb\xd1\x17\ +\x99Hb\xa8\xc0\x82\xe5,\xf6T.\xe3p\x11v;\ +\xb5J=l\xe8\xd4*\xf5\x0c\x89\xf3Q\x12\x99\x02\xc3\ +\xe0m\xcf~\x1b\xef\xdf\xa9U\xea\x22\xec\xc6$fG\ +Idm\xc7OD\xb45.\x85d\xe0\xd2\ +ITv\x0c\x0dt\x0f\x96\xb3_\xd97\x00 \x99k\ +_&\xce\x1d\x01V>\xd0\x05\xca\x15\x85\xc6c\x03=\ +\xa7\xca\xdb,\xa2\xd7\xe0\xfd\x1c\xf3\xbb~W\xcf[\x07\ +\x0c\xdf\xffl=\xeb\xc5tM%\x16\x0f\x11\xbf\x05\xfe\ +\xcb\xc4\xf8\xe9\xa9\xd7V\xd5~=\xa9\xf3\x96\x01\xaf\xdc\ +\xe3\xb4\x93\xd3\xd5\xb1\xd4\xf07=\x17+\xd5\xab\x22\x8f\ +@\xf03\xd3M\xf9\x0eU:\x02M\xfan\xc8\x82\x9d\ +?\xfa{oV\xb2L\xc5\xbe\x01\xa5\xce\x8f\x8f\x1d\xaf\ +}\xa9~)\xc2\xcb\x80Cu\xcf\xdaUKw}\xd9\ +\xb9;\xd4\xff\xfaGN\x22\xd1Q\x95hi\x99\xf7\xb0\ +{\x18c\x8c1\xc6\x18c\x8c1\xc6\x18c\x8c1\x8f\ +\x89\x7f\x01vC\xf4=P\xc3p\x12\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\x89\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00;IDATx\x9c\xed\ +\xd0\x01\x09\x00 \x10\x04\xc1\xd7R\xb66\xa2~\x0a9\ +\x90\x99\x04\xcbV\x01\x00\x00\x00\x00\x00\x00\xf0\xbf\xb1\xf6\ +\xb9\xe9\x88\xa4\x99\x0eH3 \x1d\x00\x00\x00\x00\x00\x00\ +\x00\x00\xef5\x86j\x02\xea\xd1C3b\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x01\x89\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01;IDATX\x85\xed\ +\x971N\x02A\x14\x86\xbf\xb7\x81\xa5tiV\x0aC\ +4\xd9f/\xe0\x09L\xe4\x0e\x9c\x02k\xb5\x90\x1eN\ +\xc1\x19\x8c\x89'\xe0\x02\xdbl\xc0\x80\xc5\x86\x06,Y\ +\xc8>\x0bg\x0d,b\xa1\xbb\xb1p\xfej23\xc9\ +\xf7e\xa6y?\xfc\xf7Hqc:\x9b];*7\ +\x0a\x97\x80W\x12g%0\xceD\x07\x17\xed\xf6\xd3Q\ +\x81\x97\xd9k\x1f\xd5[`\x0dD(o\xa5\xe0\x85\x13\ + \x04\x1a\x88\xf4\xcf\xdbg\xf7\x07\x02\xd3\xf9\xbc#\x19\ +\x8f\xa0\xcf\xdb\x8d\xdb\x0d\x82\xd6\xa2\x14\xb8I\x1c'~\ +\xad\x9e\x8e@\xaeT\xb4\x93\xbf\x84\x93_p2z\xc0\ +\xba\x0a8@\x10\xb4\x16\xdb\x8d\xdb\x05RG\xa5\xf7\xc9\ +\xcd\x17\xe6\xcf\xa3*\xe0\xbb\x12\x08\x91a\xed\x0b\x00^\ +i\x7f\xfe]2V@\xf3+\x81?\x89\x15\xb0\x02V\ +\xc0\x0aX\x01+`\x05\xac\xc0\xae\xc0\xcaL\xafU\x13\ +=`y 0\x06\xc28N\xfc\xaa\xd8q\x9c\xf8\ +(\xa1a\xed\x0bd\xa2\x03\xa0Q\xab\xa7\xa3*$&\ +\x93\xc9\xe9\xc7X\x8e\x9b\x89\x0e\xf3\xfdb1y@\xf5\ +\x0eH\x11\x223@\xfe>\x0e\x1eJ\x08\xb8G\x8bI\ +\x1eS\xcdzftn\x16\xcf\x7f\x98\xa5\xa9f\xc3b\ +5\xb3y\x07%\xbfn,:\x0bB\xe7\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x0a`\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x0a\x12IDATx\x9c\xed\ +[k\x90\x14\xd5\x19=\xe7\xce\xcc\xae\x83,\x88\xf8H\ +J(\x831\x96\xae\x01Lp\x99]\x82+\x98\xa4T\ +\x82,\xbb\x8b\x1b\x1f\xa5\xe2#*&\xc6\xc4$&Z\ +\xa5\x8bF\x8d\xc6\x08\x96U\x06\xb5\x82\xa5\x22\x95d`\ +w\x00-Q\xab\xc4\xb5\x10\xd9]^j\xf9\xc02Q\ +\x11B4*\xcaCy\xcc\xf4=\xf9\xb1\xa0\xdd=3\ +\xdd3;3\x94\x95p\xaa\xe6G\x7f\xf7\xdc\xef\x9e\xfb\ +M\xf7\xed\xfb\xf8\x1a8\x80\x038\x80\xffgp\x7f4\ +rJR\x87\xef\x89\xa1\x91\xd6\x8e\x94\xc1\xf1\x14\x8f\x11\ +p\x08\x80A\x00\x22\x00\xb6\xed\xfd\xbd'\xe8\x0d\xc0\xbc\ +\x8e(\x96\xf7N\xe1;\x95\xd6V\xb1\x00\x8cK\xe9\x9b\ +\x8e\xb5\xd3AN\x010\xaa_N\x84w`\xb4\xd4Z\ +\xf3\xf0\xaa\x16\xac\x06\xa9\xf2\xaa,w\x00$6\xa4p\ +\xba\x85\xae\x030\xb1\x9c\xae\x09\xbc*pV\xe6C<\ +\xb6\xe6\x0a\xa6\xcb\xe8\xb7\x1aV7\ +4\x00c;5\x94\xd0\xcb\x00\x8er\x99{\xe3[y\ +j\xd7\xc5\xdcU\x8c\xd0\xfaN\x9d`\x85f\x1a;\x0a\ +\xe20\x00\xc3\x008\x006\x91\xda$k\xd6*\x86\xce\ +\xa2\xd7\x00\x12\x13);\x17\xe0\xc5.\xeb\x1e\x8a\x0d\xdd\ +\xad\x5c\x1bT54\x00\x89Ng.\xc0K\x5c\xa6\xcd\ +\xd1\x08\xebV4qs!\xdaj\x93\xaa\xaa\x89a\x06\ +\xa4+\x01\x1c_H\x1d\x11\xeb\x0cx\xef\xf04\xe6-\ +h\xa3SH\x9d3\x9fT\xf5\xc7;\xb5\x8c\xc48\x97\ +ym|\x08\x13]\x13\x99\xc9W/0\x00\x89N\x8d\ +\x07\xb4\xdc\xad\x0d\xe2\xb8\x9eVv\x17\x22jlJS\ +iu\x17\x88c\x0b\xe1\xe7\xc0K\x02\x7f\xd5\xdb\xc2e\ +\x85\x90\x13\x8bu$\x1c\xbd\x0a\xe0\xb0}6\x82\xd7t\ +\xb7\xf0\xde|u\xf2\x0f\x82\x12\x01\xfd\xc1g\x9c_H\ +\xe7\xc7<\xa0X\x22\xe5\xdcG)UB\xe7\x01\xe0$\ +B\xcf\xd6w83\xd1\xae\xd0\x01\xbb\xa7\x89\x1f@\xbc\ +\xcd\xa3\x18\xbaq\xd4\xd3:8_\x9d\xbcN\x1bRh\ +\x040\xdeeJ;\xd6\xb4\x87\x89\x18\xff\x84\x86\xc4\x0e\ +\xd7R\x88W\x85q\x0b\x85\xc8\xf6\xc4h\xfd}\xcc\x12\ +\x0d\x08\xe3\xc6\xb7\xe1~\x12\xef\xb9L\x87\x0d\xf8\x0cW\ +\xe4\xe3\xe7\x0d\x80\x85~\xe3\xbe\xa6\xf4\xc0\xeai|;\ +\xa8\xf1\xda\xa4\xaa\xd2{\xb4H\xc0\xf7\xc3\x84\xf6\x03\xd3\ +\xa2i=\x1av'\xf4\x0d\xcc\xf4\xfcQ\x82\xae\xcd7\ +7\xc8\xe9\xac.\xa9\xaf\x018\xc3eJ+jn\x0d\ +\x94'q`\xd4\xde\x07\xa01\x90W\x0a\x88\xd6\xc4h\ +\x1bz\x17\x0eOc\x1e\x80\xb7\x5c\xa6\xa36\x18\xfc \ +\x177g\x00\x22Q\x9c\x87\xbe\xad\xaa}\x0d/\xebi\ +\xe2\x07A\x8d&\x16\xe1|\x82\x97\x85\x89+\x1d\xbc\xa9\ +~\xa1rvf\x1f\x16\xb4\xd1!\xb4\xc0S\xcb\xd8\x8b\ +rqs\x06@\xd0Y\x1e\x83\xe5\x92\xa0\x06\xc7,\xd1\ +\x00Hw\x04q\xca\x09\x19\xcd\x0a\x9d\xee\x1a\xe3\xd3\xcc\ +I\xb9\xead\x05`\xef\x88\xe9~\x97\x22\xe3\xe0\x89\xa0\ +\xb6b\x0e\xae\x85w\xa2Ti\x8c\xdc\x10\xc3\xf4 B\ +\xf7:\xac\x02\xe0\xbek\x07o\x8aa\x8c\x9f\x97\x15\x80\ +\xea\xcfQ\x0f\xa0\xcaeziM\x1b\xdf\xf3\xf3\xf6\xe1\ +\xec\xa4\x22V\xfay\xa8\xe42\x83\xd25\x81\x84\x9bi\ +)y\xfe8){\x9f2+\x00\x06\xf8\xb6\xa7\x12=\ +\x13\xa1,l\x8c\xe1\x14\x02\x87\x07\x8a\xa9\x0cF&\x16\ +\xea[A\x04K\xe3\xd1.\xda\x13\xfd\x9c\xec1@\xf6\ +\x04\x0f\xc1\x9a\xb7\xb28n\xba\xec\xb4@\x99\x95\x84A\ +kPq\xc4\xc0\xa7\x9d'\xf89\xd9\x01 \xbf\xe1\xbe\ +\xb4@\xe0\xbb\x1fb\xa5w\x81\x83\x1a\xcfz\xa6\xdd\xc8\ +\xec\xf1i\x17F\xf89Y\x01\x90E\x8d\x8f\xf0i\xa0\ +\x06\xee\xd7\xc1\xcf\x8faA\x85\x07\x7f\x96\xa5\xbd\xc6\xcf\ +\xc9\x0a\x00\xe9%Y\x22\xff\x1e[\xdf\xac,\xd7n\xed\ +\xfeB`\x00\xba\xa6c7\x00\xf7J\xb0\xaa6)\xf7\ +\x00\x9f#\x00\xbe\x15\x22-\xf2nxL\x98\x00\x93\xcb\ +\xc7~D\xacT\x07\xd9\x8f\x00\xb0\xdd}\xed\xbf#\xdc\ +\xd8\xbb\xce\x0e\x9c!V\x18\x81\xbb\xcf\x13\x1eF5\x80\ +\xa8\xcb\xb4\xe7\xf56\xeeqsr\x0c\x82\xf0\xec\xa8\xda\ +\xbeS\xdc \xfc+\xa4\xbc\x92\x08\x0c\xc0\xceC1\xd8\ +g\xda\xee\xe7d\x07\xc0j\x83\x8f\x915r\xbaA\xe8\ +\xd5\xa0\xf2JB!m\xcb\xc11>\xd3\xbb~N\x8e\ +\xe7\xd7\xbc\xe1\xbe\xa2l\xe0d\x032\x9d\x81\xe5\x15\x84\ +\x09o\xdb\xa3]\xd0\xfa,\x1fYU\x08\xdfa#\xc7\ +gq\x5c8h\x1b\x9e\x01\x02\xde\x14\x95\xc3\x86\xee\x16\ +\xac\x0b\x22\x10v\xbc\xf7\xdad\xdd1Y\x01\x88g\xb0\ +\x12\x80\xfb\xfc\xfd\xbb\x89\x0e\xe5}\xddt]\xcc]\x94\ +\x1e\x0e\x95[fH|0pK\xbe]\x06\xe0do\ +%t\xf9iY\x01\xd8{\xb6\xb6\xd2S\x8f\x98\xec\xe7\ +\xb9\x11s\xcc-\x00\xb6\x06*./6F\x1c\xcc\x0e\ +\x22\xd4\x8d\xc2\x18x\xe7(\xdb\xe2\x87b\xb5\x9f\x97g\ +?\x80\x9eU\x14\xa1)A\x8d-o\xe3\x87\x00\x83w\ +\x8c\xca\x09\xf2\x86\x95m\xdc\x19D1\xb0\x1e\xcd\x82\x9e\ +\xca\xb5=\x9e3\x00\xb1\x08\xe6\xa3/\xa9aoe\x9c\ +vJR\x81+\xbe\xf8\x10\xdc\x03\xe2\xe9@\xe1\xe5\x00\ +5\xafg*\xe6\x07r\xdae@z\x16i\xb4\xe6\x91\ +\x5c\xd4\x9c\x01X\xd1\xc4\xcd\x02\x9e\xf9\xa22P\x9d\x8e\ +Z\xffq\xb8\x07]\x13\x99\xd9\xddwp\xfaf\xa0\xb8\ +\xd2\xd0\x1d\xff\xd4\x5c\x1ev\x1cW?\x1a\xe7\xc2{\x08\ +\xf3~|\xe8\x97\xfdq#\xef4V\xe4\x9f<\xd7\xe0\ +O\xc7u\xe8\xe8\xa0\x86_j\xe6\xa7\x8e\xe5$T\x22\ +\x08\xc4jD85\xec8\xae6\xa9*I\xbfw\xdb\ +D\xce\xcew:\x947\x00\xab\xa6b\x19\xbc\x83a\x95\ +\x03;3L\xe7\xeai|{7Y\x0f\xe4\x8ex\xff\ +\xa0\xbf\x994\x1b\xc36f\x01``\x0c\x97\x83\x9e\xc9\ +\xdb\x96\x98\xc1\x9c|\xfc\xfc\x0b\x19R$o\xf0\xd9.\ +L\xa4\x82\xd7\xe0@\xdf\x9d\x10\x1f\xc2\x1f\x11\xfc\x1dr\ +L?\x8b\xc0G\x02g\xf44\x9b\xf3\xc2\x06=\x00\x18\ +\xb3D\x87Q\xf2\x1c\xe1C\xbc}E\x13\xf3j\x08\x5c\ +\xc9u7\xb3\x0b\xd4<\x0f_J%\x16\xeb\xc801\ +]\x13\x99\xe9n\xe1\x9d\x11\xf0XIs\x00|\x1eV\ +\xc7\x85\xad\x80\xee\xc8dxlo\x0b\xef/\xe4\x08\xbe\ +6\xa9\xaaHF\x0b\xe1\xcd!z%\xf3\x11\xf2\x9e\x0b\ +\x02\x05\x9c\x0e\x8f\xeb\xd4\x11\x0e\xf4\x0a\x80/:-\xe1\ +\xc5\xa1q\x9e\xb6t\x12w\x87\xd5\xdf\x871K4 \ +\x96\xc1\x19\xa0m\x958\x12}\xbb\xc8\x87\x02\x80\x80\x0f\ +\x09l\x06\xb4\x964\x0b\xb6\xa5\xf1\xac\x7f\xd5\x16\x86\xfa\ +Ng\x8e\xc0+]\xa6\xb4!\xc7\x87e\xae\x14\x94 \ +\x91\xe8P\xbd\xa8.oF\x98\x1e\xeai6\x97\x95\x92\ + \xd1\x90T\xfc\x90\x81\xb0\xc5\x042\x8f\xbe\xab@\xdd\ +\xe7\xb6\x89\xbc\xac\xb7\x99s\xc3\xea\x16\x9c$\x95\xe8\xd0\ +\x05\xa0\xbc\x19\x17\xd2\x83\xdb\x1dsu\xb1\xffV\xd9 \ +\xb1>\x85\xab\x05\xcd\x86\xfbq\xa6\xee\xe9i\x8e\xfc\xb2\ +\x10\x17Ee\x89\xd5w8w\x8a\xbc\xce\xa3\x01x\xde\ +\x89r\xda\x9a)\xfc\xa8\x18_\xa5\xa26\xa9\xaaA\x11\ +\xfbg\x91\x97z\x0a\x88\xa7\xe3\x87prPR\x84\x1b\ +Emg\x0dw\xcc\x0d\x04R\xde\xf6pj4\xa3U\ +\x0d\x8b4\xb2\x18_\xa5`\x5c\xa7\x8e\xa8\x89\xea\xd9\xac\ +\xce\x03\xaf\xed\x06\xcf)\xb4\xf3@?\x12%\xcfN*\ +\xb21j\xef\x12\xe8\xbf\xc5\xd2\x80\xe6D`n{\xb1\ +\x85\xff)\xd6o!hH*\xeeD\xf13B\xd7\x03\ +\x18\xe2+^\x9a\xc9\xf0\xdc5m,jQ\xd6\xffT\ +\xd9\x94.e\xdf\xeb\xcd\xbf1\xb9\x83\xd2\xdd\x8a\x9bY\ +\xc5$,\x06a\xc2s\x8a\xee\xda\x82\xe9\xa2f\x22\xc7\ +\x19\xa4\xa0YGg\xccu\x85\xe6\x13\xb9QR\xb2t\ +]\x87\x1a\x0d\xd5\x09`h\x8e\xe2O\x00=\x0e\x99\xc7\ +\x11\xc73\xc5\x06\xa36\xa9\xaaA\x06\x8d2\xf6,\x80\ +M\x00rM\xc3\xd3\x22g\x142\xda\xe7C\xc9\xe9\xf2\ +u\x8b4\xdcX\xdd\x03\xa0%\x80\x96\x06\xf1\xbc,\x9f\ +\xa3\xc1\x9b\x12\xfe!\x83-\xd5Q\xecH\x1b8f\x07\ +jl\x15\x06\xcb\xc1\x08\x10\xc7\x11\xb6\x01\xe0\xe9\xe8\xfb\ +\xa4&\x9f\xf0U\x22g\xf44sM)\xfa\xcb\xf6\xc1\ +D}JgJ\xba\x13@\xa5\x07\xc3\xcd\x12o9\xda\ +\xc1_\xfas\xcb\xfbQ\xdeOf\xdae\xc6\x8eB\x93\ +\xa1\xae\x17PWV\xdf\xc0\xdb\x00g\xc5\xb7bn\xb1\ +\x09\x9aA\xa8\xd8GSu\x0bu\xa21v\xfa\xde\x8f\ +\x1d\x8e\xeb\xa7\x9b\xf7\x01=ie\x1eY\xf5\x0a^\xe8\ +\xcf\xf7\x00a\xd8/\x9f\xcd\xd5-\xd2pZL4\xb2\ +'\x8a<\x1e\xc0\x08\x12\x83%\x0cB\xdf\xc9\xcdV\xf4\ +}6\xb7\x11\xd0z\xd2\xac\x17\xf1|O\x13\xde\xf8*\ +\xe4\x22\x1f\xc0\x01\x1c\xc0\xff.\xfe\x0b\x91Z\xc0\x8by\ +\xe5\x16m\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x05'\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\xd9IDATx\x9c\xed\ +\x9bOh\x14W\x1c\xc7\xbf\xbf\x99\xd1B\xd3\x22v\x85\ +\xdd\x90\xa2\x87\xc6CE\xb0$[\xf6\xe0e\xa1\xb5\x17\ +m.mjKU<\x84\xac\x8d6\xe6\xd2\x82\x81f\ +\xb2\x81bk/\xd9`\xc4\xb5\x81\x16\x1aZ4\xf6\x12\ +\x22\x94\xb4\x87\xa0\xbd,\xd9x\x90\xba\xbd\xd8\x83!\xd6\ +\xac\x10E0H\xc2\xce\xfczH^;\xbb;\xbb;\ +\x9b\xf9\x9bf?\xb0\x87y\xf3\x9by\xbf\xf9\xee\xf77\ +\xf3fx\x0fh\xd0\xa0\xc1V\x86\xac\x04\xc5UUY\ +^\x0cu\xe8\xc0Q\x02E\x01n\x01\xf0\x82\xcb\xb9\xd5\ +\xcb\x0a@\x0f\x18\x9c\x95\x80\xabM\x91\xa5\xc9\x99d\xb2\ +P\xeb\xa0\x9a\x02D\x13\x17\x0f\x819\x05\xe2\xd7\x9d\xc9\ +\xd3\x1b\x18\xc8\x11\xa4\xbel\xfa\xcc\xaf\xd5\xe2\xa4*\xa7\ +\xa0h\xf7H?\xa0Oo\xb6\x8b\x07\x00\x02\xf6\x01\xfa\ +\xf4\x9b\x89\xd49\x80+\xfe\xd1r\xa5\x1d\xd1\xeeP?\ +\x08_\xba\x93\x9e\x97\xd0[-\xd1\xcc\xca\xdfs\xbf\xfc\ +n\xba\xd7\xac1\x9a\xb8x\x08\xd0\xa7K\x9a\x9f\x800\ + \x15\xe8\xc6\x9e\xa7\xe1\xf9\x89\x89\x0f4\xc7s\xb5A\ +g\xe75\xf9\xfe\x8e\xfcn]\xe1\xc3`\x0c\x01\xd8Y\ +\x1c!\xbdcV\x0ee\x02\xc4UUy\xf6p\xd7\x9d\ +\x22\xdb\x13~\x93\x0b\xfa\xb1\xccX_\xde\xf9\xd4\x9d'\ +\xd65\x1c\xd6\x14i\x1c\x8c\xb7E\x1b\x03\xb9\x97#K\ +\x07Jo\x8ce\xf7\x80\xe5\xc5PGI\xcd?^\xc5\ +\xb6\x8f7\xcb\xc5\x03@f\xac//\x17\xf4c\x00\x9e\ +\x886\x02\xf6-/\x86:Jc\xcb\x04\xd0\x81\xa3E\ +\x0d\x04\xf5\xce\xe5O\x1e\xb9\x91\xa8\x9bd\xc6\xfa\xf2\x0c\ +V\x8dme\xd7\x06\x13\x01\xd6\x9e\xf3\x86\x80\x02\xddp\ +>=o\x905i\xca\xb8M@{i\x8c\xc9c\x90\ +[\x8c[{\x9e\x86\xe7\x9dN\xcc+Lr\x7f\xb54\ +\xc6l\x1cP4\xc2\x0b\xda\xdd\xbe\x1eLr/\x1b\xbd\ +V\x19\x08m\x0d\x14\xbf\x13\xb0B[\xcfh\xabT\xd0\ +\x06@xo\xbd\xe9:3\x86\xe6\xae\xf4\xfee\xf7\xdc\ +\x81w@,\x91\xda+i\xdaM\x10\x8e\x03xq\xfd\ +w\x82\x08\xb7\xdazF[\xed\x9e?\xd0\x02\xc4UU\ +\xd1\x98~\x02\xd0l\xb2\xbbY\xd2\xb4/\xec\xf6\x11h\ +\x01\x9e=\x0c}\x0e*\x7ft\x19x\xdfn\x1f\x81\x15\ + z*\xb5\x1f\x84A\xb7\xfb\x09\xa4\x00qUU\xa0\ +\xd3\xf7\x00\xb6U\x8b#\xa2\x09\xbb}\x05R\x00\x0b\xd6\ +\x07\x80U\x89\xf9\x82\xdd\xbe\x02'\x80U\xeb\x13x0\ +\x93\xee\xcd\xd9\xed/P\x02X\xb5>\x80lS\xe4\xf1\ +7N\xf4\x19(\x01\xacZ\x9ft\xe9\xa4\x95\x0f\x9eV\ +\x08\x8c\x00\xf5X\x7f\xf6\xdb3w\x9d\xea7\x10\x02\xf8\ +a}\x81#\xef\x02\xed\xdd#\xaf\x11a\x00b`\xc2\ +\xf8YW\xe4\xa1\xdb\x97N\xdf\xb3r\xbc\x1f\xd6\x17\xd8\ +v@[\xcfh+\x11n\x018\x011V'\x1c\x97\ +4\xedf,\x91\xda[\xebx\xbf\xac/\xb0-\x80T\ +\xd0\x06Pa\xac\xae\x81~\x8c\xabjE\x97\xf9i}\ +\x81\xfd{\xc0\x7f\xaf\xa8fD\x97\x17_\xf9\xac\xd2N\ +?\xad/p\xfd&\xc8\xa0\xc1\xe8\xa9\xd4\xfe\xd2v\xbf\ +\xad/pB\x80\xeb5\xf6o\x07\xd3w\xc6R\x08\x82\ +\xf5\x05\xb6\x05\x90\x81\xaf\x01\xac\xd6\x08+*\x85 X\ +_`[\x80L\xba7\x07F\xb2V\x9c(\x85\xa0X\ +_\xe0\xc8=\xe0\xa5\xe6\xa5\x0b`\xcc\xd5\x08\xdb\x0e\x96\ +~`\xa6q\x04\xc0\xfa\x02G\x04\x98I&\x0b\x90\xf8\ +$j\x96\x02\xbfA\xc0\x81\x1a\xa7\xf3\xc4\xfa\x02\xc7\x9e\ +\x02\xd9\xcbg\xff\xb0R\x0a\xb5\xf0\xca\xfa\x02G\x1f\x83\ +\x16K\xa1\x1a\x9eY_\xe0\xa8\x00\xd6K\xc1\x14O\xad\ +/p| \xb4\xd1R\xf0\xda\xfa\x02WF\x82\x1b(\ +\x05\xcf\xad/pE\x80:K\xc1\x17\xeb\x0b\x5c{\x17\ +\xb0Z\x0a~Y_\xe0\xea\xcb\x90\x85R\xf0\xcd\xfa\x02\ +W\x05\x98I&\x0b\xba\x22\x7f\x08\xc0l\x92\xc5\xbc.\ +\xcb\x1f\xf9e}\x81\xeb\xaf\xc3\xb7/\x9d\xbe'k8\ +H\xe0)\x00\xcf\x01<'\xf0\x94\xac\xe1\xa0\xd5Of\ +n\xe2\xc9\xfc\x80\xccX\xef\x02\x80w\xbd\xe8\xab^\x02\ +\xf1U\xd8O\xcc\x04X1ntv^\xab8\x9d6\ +\xe8\x98\xe4\xbeR\x1ac\x22\x00=0n\xdd\xdf\x91\xdf\ +\xedhV\x1eb\x92\xfbBiL\x99\x00\x0c\xce\x1a\xb7\ +u\x85\x0f;\x9c\x97gh\xb2~\xc4\xb8\xcd(\x7f$\ +\x97\x09 \x01W\x8b\x1a\x18C\xb1\xae\xe1\xb0\xe3\xd9\xb9\ +L\xack8L\xa0\xa2\x81X\xd9\xb5\xc1D\x80\xa6\xc8\ +\xd2$\x98\xfe44\xed\xd4\x14i|3\x89\xf0\xefd\ +i\xc3\x8cq\x06rM\x91\xa5\xc9\xd2\xd8\xba\xa6\xcb3\ +X\x955i*\xc8\xd3\xe55Y?\xb2\xfe\xcfol\ +\xba\xbc \xda=\xf2?Y0\x01\x10\xb8\x7f6}\xf6\ +\xbc\xd9\xbe\x8a\xe3\x80\xec\x95O\xcf\x13\xb8\xdf\xbd\xb4<\ +\x81\x99\xe9\xdcl\xba\xf7\xabJ\x01\x96\x16M1\xf4\xe1\ +\xb558\x9b\x07\xab\x8b\xa66\xb0l\x0e\xedX\x9bu\ +\x1d\xc0esX``\xae\x9ees\x0d\x1a4\xd8\xda\ +\xfc\x03\xf8\xad\xf2\xfb\x1aI6\xd6\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x04\xe8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x9aIDATX\x85\xc5\ +\x97\xd9v\xe2F\x10\x86\xbff\x11\x12`P\x9c\xc4\x9e\ +\xf1$9Y\xde\xff\x9dr1\x9eI\x1c\xcf\x18l#\ +\x19$\xa8\x5c\xd4\xdf\xa8\x91qr\x97\xd49\x1c\x89V\ +\xd7\xf6\xd7\xd6\x0dX\x09\x16\xf8\xcf\xc9\x02X\x19\xa4|\ +\x09\xac!X\xf7\x91K \x1a\x96%\xef\x93DJ\x5c\ +\xb3dm\x9b\xac\xed\xf4~\x00\x1ez\xf2\x97\xc0:\xf4\ +\x16\x0e\xc0\x050\x00\xaaDY\x90\x11\x13\xd8\x0d!\x8c\ +\x81q\xcf\xa5\x16\xac\x81\xac\x95\x11Q\xb9\x01\x0d\x90K\ +\xfe#0\x96\xf2\x1b\xe0\xde\x19\ +\xb2\xfbD\xf9\x04\x0f\x91q\x1a\xf7\xe8\xccL\xca\xf4\xcb\ +\xbe\xc2\xa6\x80\xd9\x18x\x07|\x94\x8eA\x0f\x01\xfbN\ +\xff+\x08\x15\xd8\xb5\xbe\xfd\x09\xcc\x1d\x8d\xd5\x0cJ\x5c\ +p\xa8\xcf\x03`s\xa0\xc5\xf3\xa5\xd2\xf3\x80'\xf4\x0e\ +x\xc2\xe3\xff\x0d\xb0\x82\xb0\x19%\xdcc)\xcf\xe5\xdd\ +\x1a\xb8\x92\xc59\x94O\x82q\x02f\x1d\x0f$\x08\xe5\ +\xc0\xb3\x94\x95B8\x03\xee\xf0\xf0d\x10\x9e\x12\x07;\ +(\xdcR\x9b\xc0\xcb\xb5\x18\x83\xa0\x5cHh\xa49\x1e\ +\x86\xb9\xf8\x07\xfa\x1f\xd7\x22m\xc4\xbb\x93\xac\x00\xdb\xf7\ +J\xccc\xee\xc5\x10\xbcsA\x150\xfd\x8c\xc7\xb2\x96\ +\xf5#\xc1VCu\x09\xd3\xb5#u\x8el!\x995\ +0\x95\x03S\xba\xd2\x1bI\xf6\x1c\x0f\xc1\x97\x14\x81\x09\ +\xb4/Im\x16\x8a\xb5\xe1\x96]\xc3t\xe5H\xbdI\ +\xb1\xce\xbf\x17\x8f\x09\x89X\xb6-<6x\xe8\xfa!\ +hJX\xe4x\xd2\xfc%\xc1\x85\ +\xfaA\xeeIg\xb3\xee?\x05\x9e7_as)\xde\ +<\x91\x09,\x9eIB\x15\x0d\xc8\xbc\x8b\x91\x0b\xc6R\ +\x1e\xb4b\x5c\xe1\x89\xf6 Hs=\x83\xa0\x9d\xba\x0c\ +\xa6\xae\x9c\x06f\x0f\xda\xd7\xe2=\xe5\x12\xef1Ch\ +L\xfbc\x1f @P\xd7\x0a\x8f\xde\xb9\x822\xdb\x0c\ +\x82\xfa\xbb5\x126\x06\xee{\xbd\xfd\xca\x8d\x8e|\xb4\ +`{\x7f\x86\x1d\xd83^\x86\x03\xba$?\xa9\x82a\ +R\xdfI\x93\xa9\xd3=\xda\xc7\xbd{c\xe90\xbbK\ +\x1c\x8a\x94NY\xc9\x0cU\xe7l\xc70\x82\xf1!\xf1\ +\x86\xe4\xbdM\x84\x8c\x80\xc6=\xb75\xeaLxF[\ +\xd2\x1fRJ\x1dx5=\x07\xc9s\x7f\x86\xb9O\x87\ +\x9e\xc0>\x9dk\xcf\x96\xbc\xbf\xda\x17\x85\xed\xa0QW\ +\x0b\xd6m\x0e\x06\xf5\xb0g\xc00\x81}\xa5\xdf2\x99\ +'}\x83OFn\xdf\x98\x94\xa1U)\xf5\xac-\xfa\ +u\xdf\xe2\x09\xa7y\x1eb\xdb\xbe\xa6;\x03D\x0a\xaf\ +\xdf\xad\x00;\xee\x8b9`\xcapS\x19\xce4X\xc0\ +K\xb3\x94\xe2\x02o\xb9j6\x96B\xdc\x00\xdfJ\xb8\ +I\xb6\x0e!\x16; 2v\x1f\xf9\xa2\x01;\x08C\ +\x95\xdb\xd6\x0f$4\xfe\xdf\xc03\x7f#!\x9f\xffa\ +\x1a\xee8\x9ev\xd6%,\xef:\x07y\xc0K8\xee\ +\xd9\xc1I\x08\xc6u\xe2\xf5\x165\x0aQ\x05/?\xc9\ +\xf3s\x99~\xb4@\x1e~\x80\xe5S\xb7\xbc*\xa4\x1c\ +7l\xbc\x89_\x06\x09\xe3\x06\xea\xb2c\xa2\xf6\x86\x14\ +\x0f\x1a\xf9->\xdd\xfag\xc1\x94\x22\xd4\x7f\xe0\xed6\ +\xf8\xb3L\x86W6\x931'!\xd8\xfb\xe6\xe2\x19\xec\ +\x86n\xe0\x14\xf8I\xe6w<\x9e{\xa0t\xa4\xeaA\ +\x97\xa0\xf5P\x02\xd5!\x8f{\x7f\xc6\xbb\x9f\x8ew,\ +\xa1\xb8\x95\xccmj\x00n@x\x06\x1b\xd0\xc5|$\ +o\x0e\x106`-\xf0\x0c\xe1\xe5<\x006w\x19\xa0\ +\x83\xebg|\x96l$s\xe5\xf9\xd3E1\x0dA\xe3\ +\x93-te}r\ +1\xf9\xed\xcc\xc5\xe4\xd8\xdb\xf7\x82m +3\x1c\xfe\ +\x81\x7fo2y0\x84qz\xf7\xcbu0n}\xd4\ +\x8ej\xbcg\xec\xc5\xdb\xd0\x0d\xa65\xc9\xd5\xec\x8d\xcb\ +i\xf4\xe2\x98p\xc3\xe4}\xa2\xf7\x09l5;&\x95\ +\x94\x18\xdd\xe5T\x06\xb9\xb0\x18\xf3\x9e\xc3k\xf8\x9f\xaf\ +\xe7\x7f\x03\x88|\xd3;\xed2O\xdf\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\x9a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00LIDATX\x85\xed\ +\xd7\xc1\x09\x00 \x0c\x04\xc1 \x16f\xe1\x82\xadHR\ +H\xec@=\xf1\xb9\xfb<\x08\xcc7f$6=\xc6\ +\xf4\x18\xb7\xfb\xa9*\x0b\xd2\x9a\xb4\x1f*/G?\x03\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd3\xb2\ +\xec\xdaN\xfb\x16\xbe{\x13\xbf0\xe2\x93\xe7\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x034\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\xe6IDATX\x85\xe5\ +\x96\xcbn\xd3@\x14@\xcf\x0d,\x80\xcfH\xb3i\x0a\ +\x8b$;\xd6i6H\xb4\xb5\xc3KB-\x10[\xf0\ +\x01H|\x03KvH$@\x05\xe5\xd5&\x1f\xd0v\ +\xcb6)\x8f\xda\xbcb^\x12\xfc\x01\xb0i.\x8b\xd4\ +\xc1\x8e\xed\xc4)\xd9 \xeejl\xcf\xdcs\xe6\xce\xe8\ +\xca\xf0\xbf\x87\xf8\x83J\xd5>\xa9\xaa\xb7\x81\xa3*\xdc\ +\xd8\xde\xa8\xb7\xa6\x09*W-C\x94\x9b\xc0/T\xaf\ +m\xb5\x1a\xcf\x012\xfe\x04Um\x00'\x80\x9c(\xeb\ +\x15\xc3:7-x\xa5j\x9f\x17e\x1d\xc8\x01\xc7\x11\ +\xa9\xfb\xdf2\x7f\xa6\xe9\x91\xc0\x9a\x8c\x0a\x8f\xa6!Q\ +\xa9\xda\xe7Uu-\xcc\xe2XD@\xc9\x5c\x07z\xd3\ +\x94\xa8\x18\xd6\xb9\x18x\x0f\xd1\xeb\xfe\xc3!\x7f\xe0\xb9\ +mw&_|\x0f,\xf1\xe7n\x08\xc2Rn\xb6\xf8\ +\xb6\xeb\xb6w'\x86\x0b\x8f\x22pX\xd9j6\x9eD\ +\x04\xf6%^\xc7Hd&\x95\xd8\x87\xaf\x0d\xe5\xdf\x87\ +\xd7\x1f\x06\xe7\x86\x04|\x89\xecl\xe1\x83\x88D$\xb2\ +\xf9\xd2\x1bo\x8cD\xd9\xb4\xcf\xd2\xdf\xf9Xx\xac@\ +_\xa2\xf3*NB\xc0\x18%Q6\xed\xb3\x82\x0e\xc3\ +5\x09\x9e(\xe0K\xe4\xe6J]`1\x8d\xc4|\xb5\ +vF\xe0q\x0c|9\x09>R\x00\xa0\xeb\xb4\x13%\ +f\xe6\x0a\xae\xe7t\x1c\x1f\x8e\xca\xc4p\x02IG\xc6\ +\xbci]\x04V\x09\xdf\xe8=D/\xf4Q1p\xd5\ +\x95\xadV\xe3\xc1\xb8\xdc\xa9\x04\x92$\x04z\xda\x1f\x06\ +\xc5R\xc3a\xcc\x11\x04\xc3s\xdb/g\xf2E\x8f\xe1\ +>\x11\xde\xc4D\xf0\x89\x04\x02\x12\xdd!\x89\x01\x5c\x85\ +K\xdb\xcd\xf4p\x08\x97.U(\xf2\x93\xfe\x05\x0b\x87\ +\x88fz\xfc\x984\xdfD\x15(\x9b\xb6)\xe8\x93\x84\ +u\x82`\xe6f\x8bN\xd7m;S\x17(W-C\ +\xe0)p8\xf0\xda\xafD\xb0c\x9a\xd9|i\xd7s\ +\xdbn\x9a\xbc\xa9\x8e`\xffg\x22\x02\x17\xf4\xb2\x0a\x97\ +\x08\x1f\xc9!A\x9f\x96M\xdbL\x93{l\x05\xe6\x0d\ +{I\xe0Y\x1c|\xb3\xd9X\xf5\x9c\xf6\x8b\x5c\xbe\xf0\ +\x09d\x81p\xb3JU\x89\x91\x02\xf3\x86\xbd\x84h\x04\ +\x8e\xca\x95\xadV}\xd5\x7f\xd1u;I\x12F6_\ +rFI$\x0a\x8c\x86\xdf\xb9?<\xbf\xebv^\xcc\ +\xcc\x96>#L$\x11+P1k\x8b\x08\xebi\xe1\ +~xn{'Qb\xae\xb8\xeb9Q\x89\x88@\xc5\ +\xac-*\x12\x81\xabP\xdbn\xd6\x13\xe1A\x89\xec\x5c\ +\xf1\x8b\xc0i\x86\xefD\x8cDH\xa0\x5c\xb5\x16@6\ +b\xe1\x1b\xf5{\xe3\xe0\x03\x09'\xbd\xc4@\xa0l\xd4\ +N\x09\xd2\xfa[xP\x22\x97/|\x05\x89H\xe4\xf2\ +\x85\x9d\xae\xdby\x07\x81>\x90\x11\xb95\x0c\x17\xd4:\ +\x08\xdc\x8f\xcdf\xe3\xae\xa0\x16\xe1>qX\x91[\x03\ +\xee\x80\x86\x06\x7f\xc9UPk\xb3\xd9\xb8{P\xf8\x18\ +\x89\xbd\x88@F\xf5*\xe0\x01\xdfQ]\x99\x06<(\ +\x01,#|\x03>J\x8f\xab\xd3\xca\xfd\xef\xc7o\xcf\ +\x0b\x86\xc1\xfd\xdf\x90\xb9\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x00\xee\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xa0IDATx\x9c\xed\ +\xd0A\x0d\x00 \x00\x031\x82\x7f\x91\x10\x84\x80\x8c\xf2\ +\xb8\x1a\xd8ec@k\x9f\xbb\xf6\xb9\xb2a\xca\xf1\x1f\ +t\x80\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\x01Z\ +\x07\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\x1d\xa0u\ +\x80\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\x01Z\x07\ +\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\x1d\xa0u\x80\ +\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\x01Z\x07\xe8\ +\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\x1d\xa0u\x80\x0e\ +\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\x01Z\x07\xe8\x00\ +\xad\x03t\x80\xd6\x01:@{\xd6\x8f\x07\xc5\x02\xeb\xa3\ +\x1e\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\xd0\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x82IDATx\x9c\xed\ +\xd71\x0e\x82P\x10\x04\xd0\x81C\x10\x1b\x13\xce\xe4\x15\ +\xa88\x117\xf1<$6\xc4C\x88\xad\xe1\xdb\x22\x86\ +\xff^9\xd9bv\xbbM\x00\x00\x00\x00\x00\xa8G\xb3\ +\x0d\xe6\xf9qK\x93)Iw@\x9f=-Y3\xf4\ +\xfd\xf5\xfe\x19\xb6\xc5\xd89\x97O\x92K\xdaL\xdb\xb0\ +<@e\xca\x03\xac\x19\x93<\x7f_ewK^\x19\ +\x8f.\x01\x00\xfc\x0f\xbf@1v\xce\xe5\x13\xbf\xc0w\ +~\x01\x00\x00\x00\x00\x00\x00*\xf1\x06t\xea\x1a\x0f\x1a\ +\xcd\x17B\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04\x8a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04a Y\xc0\xfe\xa1G\xdeZaS\xdb\x0b\ +\x03\x00@\x00\x85t&\x10\xb7\xcd\x95~}\xcf\xe6\xe5\ +\xc9\x1b\x03\x00\x00\x92a\x82\xe0\x9e\x13\xc7\xfa\xf7\xa0\xd1\ +\xb0\x12\xab_\x06\x00\x80\x88b\xea\x06I\xf2\xe1\xf0\xe8\ +\xca\x97l\xdc \xfd3\x00\x84\x80\x0a\xd4^1>\x11\ +\x96\x9bO\x99V\xf3\xd0\x80ED$\xd1\xca\xa2`{\ +X\x8d*&u\xbc5\x80\x002\xbaE\x80\x98\x0c+\ +\xd1\xfd\xa6t\xbc5\x00\x00$\xbbe\x16\x00MS\x1a\ +^\x1b\x00\xe0Lu\xcf\xd8c\xd1\x9b\x97\x93Y,-\ +=k\x93\xde4\xa5\xe1\xaf\x01\x02(\xa2\x90\xde\x7f\x81\ +lj\xb7jo\x98\x92\xf1\xd4\x00\x01Im\xf1\xa4<\ +7\x13\x9b[<\xe0o\x0d\x08\xb4\x9d\x17D\x9dx\xf3\ +6\xd3B\x1ef\x80\x04z\xe5\xe3\xdb\xed+~\xdc\x92\ +\xf1\x8d\xe1\xbc\xf1+\x03\x08m\xf1\x02~H\xaeX\x8f\ +\xf1q\xbd'0\x80G\x06H\x00Aj\xf18T\xbc\ +0y\xa0\x13W\x16l\xa9\xfaq\x04\x88\x00r\xfa\xce\ +\x13\xf8\x9c\x5c~\xf7\xa7;\xeb\xbf\xd9\x94\xf6!\x03$\ +\xbd\xf3 \xbe.&\xea\xceN\x5c\xf9\xd9\xb6x\xae\x06\ +p\xb1\xd7\x09R\x83\xdf\x17\x83d\xcdg{\xc6\x8e\xb9\ +\x88!\xcf# \xa2o\xc0O\xc2`\xed\xe1]\xf5o\ +\x5c\x05\x91K\x06P2v\x1e8\xa1\x02\xdc\xd5\xde\xbd\ +\xf9\x0b\x97\xb1\xe4a\x80\x085\xdd\x05\x12\xc3\xb3\x93\xf5\ +\xc3\xae\x83q\xfcq\x94Y;O\x11>\xd4\x89\xebS\ +.c\xf9\x0b\xa75@ \xba\xe1d\xb5\xdd\x1a}\xdf\ +e\x1c\xa7\xe22\x03\x0a\xe9\x01\x01\x9f\x9e\x89Gc\x87\ +1h81\x80Y;\x0f\xbc\xd2n\xd5s\xff\x99\x8c\ +\x83# \x81@\xeb\xf2\xf6vZ\xb5'm\x5cn\xba\ +\xc5v\x06d\xdc\xec\xf0A\xdf\x95\xc77\xf8\xb0x\xc0\ +b\x06\x90\x08$\xdd\xe2\x02\xd3\x17\xff\xd1\xf7\xe0\xf4x\ +\xfd\xa4-\xddn\xb1\xf9C\xc9\xf4\xe2g\x0b%\xdc;\ +\xbd\xf7\xd1\xdfmi\x9e\x0b\xae\x1e\x83_\xcd\xcb\xb2u\ +G\x9a#\xbf8\xd2;k\x5c\x18\xf0\x1d\xa9\xd6\x1ci\ +\x8d\xfc\xe0@\xabkL\xfea\x22\xeb\x05\xfeqUH\ +\xd6v\xe2\xb1oM\xe9\x98\xc6X\x06d\xdc\xec\xe6D\ +\xa9u\xb3\xad-_\x9a\xd2\xb0\x81\xc1\x0c\xf8\xe7\x13\x16\ +!\x14\xf0\xbe\xf6\xee\xb1\xb6\xa9\xf9ma\xf0_c\xc1\ +v!\x12@\x12\x80/\xb4[\xa3\x9f\x18\x9b\xbbG\x8f\ +\x1e=,\xf1'\x17\xafC\xaf^\x06\xce\xc3\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x02%\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xd7IDATX\x85\xed\ +\x95=h\x13Q\x1c\xc0\x7f\xffw\xfd\xc2\xc1(-:\ +t)\xda\x0e\xea\x10\xb1\x9b\xa5P\xc4$\x94\xc6\xc1\xe6\ +N\xf0\x0b\xc1&\xd6.\xdd\x9c\x83\x9b{\xb7\x0c\xd2\xcd\ +\xc5\xa1JD\xac\x8b\x07\xe9\x22\xd8Q'?&\xc7\xd2\ +I8\xcf{\x7f\x87\x5clB\xaaM\x0f\xab\x14\xee\xb7\ +\x1cw\xf7\xff\xf8\xbd{\xef\xde\x83\x94\x94\x94\x94\xff\x8c\ +$M\xbc\xe4\xdd\x1ful\xf4\x024KhG_?\ +\x7f\xfc5I\x1d\x93$)WZ\x9cpl\xd8\x00\xcd\ +\x02\xd0/\x1b\x05oa\xfc\x9f\x08\xe4\xbc\xcay\x88\x1a\ + c\x0a(\x002fU\x1a\x85\xabw\xb3\x07*P\ +p\xcb\xd3X|\xe0\x04\xa0\x02\x91@\x04(\xcaIk\ +\x8c_p\xcb\xd3\x07\x22\x90w+E\xab\xac\x83\x1e\xd5\ +\xe6\xc0m\xdbk\x0b\xaa@\xc6*\xeb\x97\xe7\x17\xe6\xfe\ +\xaa@\xaeT\xbe\xa5\xaak\xc0\x10\xaa*\x9d\xcdc\xc4\ +\xaa\xa2\xc0\x90\x88<\xcb\xbb\x95\x9b\xbd\xd4v\xf6\x0a\xc8\ +\x97\xca\xcb@\x0d0\x8a\xaa\x88\xec\xd2}\xd8|\x9bT@r\ +\xa5\xcaC\xe0Q|k\xa5\xb5\xe6\xfe\x8c\x8a\xc4>\xc2\ +\xec\xf8\xb9\x0b\xf2\xf1\xfd\xa6\xbf/\x81j\xb5j\x06F\ +&V\x80\x07q\xa9\xd6\x1c\xf7\x8c\xec\x5cfN\x9f\x9d\ +\x1c\xbe}\xed\xca+\xdf\xf7\xbbjtmD\x9e\xe7\x0d\ +l\xdb\xcc*p=\x0e\xd9w\xf3\xb6\xf2\x02\xdaZg\ +O\xb6\x86\xcd\x9dw\xb5Z\xf8[\x81b\xf1\xde\x91`\ +0z\x0a2\x8b\x02F,\x9a\xb4\xf9/\x07QU\xd3\ +l\xa4/\x07\x03\xc7\xad\xd7k\xdf\xba\x04\xe6n,\x1d\ +\xff\x1e\x84u\xe0b\xfc\xc8\xd2\xdb\x9c\xef\xed\x80\x88\xee\ +|\x89\x8d0\xfaQ|\xb3\xb6\xba\x0d\xd0\xd7\x0a\x0a\x82\ +\xf0\xb3@\xa6-/\xd16\xbd\x1b\xda9\x8e\xa9~\xa7\ +\xef\x0bp\xac\xa3I\xe2S)%%%\xe5\xb0\xf3\x13\ +\x19\xff\x9aX\xf07\x9f\x0a\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x04\xe7\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x99IDATx\x9c\xed\ +\x9b\xbdo\x1cE\x18\xc6\x9fw\xf7\x1c\xa4t\xa9Lt\ +\x1fc\x1fN\x91(R\x90\x92.m\xa0\x09P`\xa4\ +\x80D\xa2\xfc\x03\x11i@\xd8\x12N\xb0\x14\x02\xa1\x81\ +\xbf\x00$,PDB\x119\x8d\xa1JZ\xa7A`\ +7\xe1\xd8\x8f\xbb\x22\x14P\x22\x87\xdb}(\xce#\xf6\ +n\xf7\xbc{\xdeO\xe3\xfbI.v\xe6\xbd\x9bw\x1f\ +?\xef\xec\xeci\x06\x982e\xcaaF\x92\x04\x91\xac\ +\xd9v\xf7\x0d\x0a/\x09\xe4\x1c\x80:\x80\x17\xf2Mm\ +bv\x00\xf4\x08n\x0a\xe5\xaeR\x8d\x07\x22\xd2\x8f\xfb\ +P\xac\x00\xb6m\xbfB\xc8\x97\x80\x9c\xcc$\xcd\xe2\xd8\ +\x12\xf8\xd7\x95R?\xee\x15d\x8c\xeb )\x96\xd3]\ +&\x8c\x8d\x03x\xf3\x00p\x8a06~\xb7\xbbK$\ +\xc7\xfe\xa3\xc7\x0a`\xbb\xbd%\x90\xb7\xf2\xc9\xad8\x04\ +\xfc\xc4rz\x1f\x8e\xef\x8f``{cc\xa4\xf9/\ +\x10+\x80\xf7P)\xe5\x88\x88\x97i\xa6)!i\xda\ +\xb6\xdd\x02\xcc\x8b\x10\xac\x028\x16\xec\x17\xf8\xafF\x95\ +CH\x00\x925\xdbq\x7f\x1e\xb6=\x7f\xf2\xbd\xfe\xbb\ +\xedv\xfbY\x0e\xb9gN\xa7\xd3\x995\xcc\xda\x1a \ +\x17\x02\xcd[\xaa\xd583:1\x86\x04\xb0,\xf7M\ +\x08\xee\x07\x9a\xfe\xec\xff3sra\xe1\xc5?\xf2J\ +8\x0f\x06\x22\xccl#\xe8\x04bqn\xae\xf9C0\ +.4\x07Pxi\xb8\x017\x0e\xda\xcd\x03@\xbb\xdd\ +~&\xc0\x8d`[\xe8\xde\x10!\xc0\xees>\x80\xf7\ +0\xeb\xe4\x8a\x82\xf4\xd6\x83\xd7\x029;\x1a\x13\xf5\x14\ +\xa8\x07/\x94RN\xc6y\x15FD\xee\x8d\xd1\x98(\ +\x01\x86VxU\x9b\xed'!\x22\xf7\xd0\xeau\xec:\ +\xe0\xb0P+;\x81$\xb8\xae\xbb\xe0\xf9X\x01\xb0\x08\ +\x00\x04\xef\x99\x82\xd5V\xab\xf5[\xda\xef\xae\xbc\x03\x5c\ +\xd7=\xe1\xf9x\x04\xe02\x80\xa3\x00\x8e\x0a\xe4\x8aO\ +y\xec\xba\xeeB\xda\xef\xaf\xb4\x00$k\x9e\x8f\xef\x00\ +\x1c\x8f\xe8>\xde\xf7\xf9Q\xda1*-\x80\xed\xf6>\ +\x00\x10zti\x04\xf2V\xda1*+\x80\xe38\xa7\ +A\xde\xcc{\x9cJ\x0a@\xb2\xe6S\xbe\x060\xb3W\ +\x9c\x80\xdf\xa7\x1d\xab\x92\x02\xc4Y\x7f\x97\xe7\x00\xef\xa4\ +\x1d\xabr\x02$\xb5>!7\x95R[i\xc7\xab\x94\ +\x00I\xad\x0f`s\xaeU\xff<\x8b1+%@R\ +\xeb\x0b\xfc\xabI~\xf0LBe\x04\x98\xd0\xfa\xbff\ +5n%\x04(\xc3\xfa\x9aL\xde\x05\x1c\xc7y\xc9#\ +V\x02\x0b\x93\xfb\xa6\x81\xd5f\xb3\xf94\xc9\xe7\xcb\xb0\ +\xbe&\xb5\x03\x5c\xd7]\xf0)\x8f\x05r\x05\xbbku\ +\x00\x97=\x1f\x8f\x5c\xd7=\x11\xf7\xf9\xb2\xac\xafI-\ +\xc0\xee[Z\xe4Z\xdd\xf3\xf1-\xc9\xb1.+\xd3\xfa\ +\x9a,\xe6\x80\xc5=\xfa\xceYN\xef\xfdq\x9deZ\ +_\x93\xfb$(\xe0M\xc7qN\x8f\xb6\x97m}M\ +j\x01\x08\xde\x8b\x099\xe2S\xbe\x0a\x96B\x15\xac\xaf\ +I-\x80\x01~\x06\xe0yL\xd8P)T\xc1\xfa\x9a\ +\xd4\x02(\xa5\xb6 \xf2q\x5c\x9c.\x85\xaaX_\x93\ +\xc9\x1c\xa0\x9a\xf5;\x00\x9e\xc4\x84\x1d\xf1)\xdf\xf8\x90\ +5T\xc0\xfa\x9aL\x04\x10\x91\xbe!\xbc\x8a\xf8Rx\ +\x19\xc4\x99\x98\x98B\xac\xaf\xc9\xec)\xd0j\xb5~I\ +R\x0aq\x14e}M\xa6\x8f\xc1\x84\xa5\xb0\x17\x85Y\ +_\x93\xa9\x00\x13\x94B\x14\x85Z_\x93\xf9Bh\xbf\ +\xa5P\xb4\xf55\xb9\xac\x04\xf7Q\x0a\x85[_\x93\x8b\ +\x00\x13\x96B)\xd6\xd7\xe4\xf6.\x90\xb4\x14\xca\xb2\xbe\ +&\xd7\x97\xa1\x04\xa5P\x9a\xf55\xb9\x0a \x22}\xd3\ +\xc0\xdb\x10\x847Y\x08\x1c\xd3\xc0;eY_\x93\xfb\ +\xebp\xb3\xd9|Z3\xe4<\x80u\x00\x7f\xef\xfe\xad\ +\xd7\x0c9\x9f\xf4'\xb3<)d\x7f@\xa3\xd1\xe8\x02\ +x\xbd\x88\xb1&\xa5\x12\xbf\x0a\x97I\x94\x00;\xc1\x0b\ +\x92fA\xb9dND\xee;\xa31Q\x02\xf4\x82\x17\ +\x83\xed\xa7\x07\x93\x88\xdc\xbb\xa31\xe1\x8d\x92\xe0\xe6p\ +\x8by1\xd3\xac\x0aD\xc4|-xM0\xf4H\x0e\ +o\x94\xa4\xdc\x1dn\xc0j\xa7\xd3\x99\xcd<\xbb\x9c\xe9\ +t:\xb3\x04\x86\x16b\xa1{C\x84\x00J5\x1e\x00\ +\xdc\x0e4\x1d3\xcc\xda\xdaA\x12\xe1\xbf\xcd\xd2C;\ +\xc6\xb7\x06\xf76L\xd8\x01\x22}\x01\xdf\x1bi\xbd`\ +\x983\xdb\xb6\xed^\xb3,k\xbe\x8a\x13#I\xd3\xb2\ +\xacy\xdbv\xaf\x0d6I\x0f\xed\x14\x87\xc0\xbf\x1e\xb5\ +\xe8\x1a{\x92\xc2r\xba\xcb\xff\x87\x03\x13\x00@\xc8\xf2\ +\xbcj\xdc\x8e\xea\x1b\xbb\x0eP\xcd\xfamB\x96\xf3K\ +\xab\x10H`i\xaeU\xfft\x5c@\xc2CS\xc6\x17\ +\x00Ne\x9aZ\xfe$:4\xb5\x9fcsg1\xd8\ +u]\xc5cs]\x82O&967e\xca\x94\xc3\ +\xcd\xbf[?\xf6<\xa0\xff\x9c\x5c\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\x8b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00=IDATX\x85\xed\ +\xd3!\x12\x00\x10\x00\x05\xd1\xe5R\xaa\xe2\x00.\xea\x04\ +fd\x972\x92*R\xf6\xa5\xdf6}\x90$}\x16\ +\xceHm\x0d ?\xaa\xf6Yc\x01\x88O\x82\xd2\x85\ +/\x90$\xe9\xbb\x0d\xbbX\x0a\x07\x832e\x0f\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04\x15\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xc7IDATX\x85\xe5\ +\x97QH]e\x1c\xc0\x7f\xff\xef\xea]\xf3\xc1m!\ +\xccJ\xd9&+\xb6\xa8\x1eZ\x0c\x0aV+\xf5\x9a\x0c\ +\xa73\x0e\x11B6m\x16D/A\xe0\xe8\xe1 E\ +\x13z*\xc6bN-\x22\x9f\xaeWKk\xb6{u\ +\x5c_\x16\xc3BF+\x84\xc8F]\xb5\x88\x0d\x8dZ\ +\xea\xbd\xf7\xfb\xf7p\xafv\xbd\xd79/^{\xd9\xff\ +\xe9\x9c\xef\xfc\xbf\xff\xef\xf7\x1d\xce9\xdf\xff\xc0\x9d\x1e\ +\x92M\xb2\xaf\xf6x\xa9\xf5\xe4\xd5\x89\xb1\x15\xa8\x94\x02\ +%\x80\x11\x98R\x88\xa0:\x8a\xe4\xf5\x87\x02g\x7f\xcc\ +\xa9@\x95\xd3|0nM\xbb\xa0O\xaf\xb3\xee\x18\xa2\ +'C\xbd]#\x1b\x12\xa8pZ\xb6\x89\xb5\x1f\x02/\ +$\x87f\x14\x06\x0d:\x14G&\xbd&>\xb3\x18\x8b\ +\xdb<\xb3\xa58\xaev\xb7\x88\xf8\x80Z`W2\xff\ +\xbc\x8d\xd242\xd0\xf9{\xd6\x02UN\xf3^ke\ +\x00\xd8\x9f\x00\x8b\x1b\xbb~\xefG\xe1p[l-i\ +\xd7u\xcd\xa5\xabS\xcf\x03\xef\x00e\xc0/\xc6\xda\xa3\ +\x17\xfa\xbb\xaf\xac[\xa0\xbc\xfex\x99\xc1s\x19\xa1H\ +\xe0s\xcf]\xff\xbc8\xd4\xd3\xf3\xe7Z\xe0\xf4\xa8\xae\ +~}K\xb4`\xfe\x8c\xa0M\xc0\xdf\x8a\x1e\x1a\x0et\ +\x8d\xdfV\xa0\xba\xa1\xa106_\xf05\xe8\x83\xa0\xef\ +?\xf1P\xc9\x1bmmm6\x1bxj}_}s\ +\xab\x8a\xbc\x0bD\x8c\x9a\x83\x17\xfa:fR\x13L\xfa\ +\x8c\xd8|\xc1\xe9\x04\x9c\xc1\x0d\xc2\x014\xd8\xd7\xd5\x8e\ +\xd2\x09\x94Xc?%m\xd1+N*\x9fkz\x0c\ +\xcc\x18\xf0\x87\x1as\xff\xb0\xbfcn\x03\xf0\xe5p\x1c\ +\xc7;k\xb7]\x01\xf6\x01GB\x81\xce\xf3K\xd7V\ +\xdc\x01\xc1\x9c\x02P\x95\xb7s\x05\x07\xf0\xfb\xfd\x8b*\ +\xbc\x95\x00\xc4\x5c\xcc\ +\x14X\xd4\xc1\xa4\xdd\x91\x03--\xf9\x9b\xc0\x17E\x8e\ +&\xa9\xfd\x19\x02\xa1\x81\xeei\x84\x8b\x08E;\xae\xdb\ +\x97sM\xaf\xac?Q\x93\xdc\xe4\xbe\x0f\xf9\xcf-\xf7\ +\x06+\xde\x02k\xa5\x15@\x04\xb7\xba\xa1\xa10Wp\ +\xc7q\xbc\x08\xa7\x00\x04=\x09\xe8\xaa\x02#}\xe7\xc6\ +T\xe9A\xd9\x19\x9f\xdf\xfa\x89\xeb\xba\xb9xMe6\ +\xbe\xfd\x83\xe4\xea\xc3\xc1@\xd7\x17\xa9\x173\x01\x1e\xf3\ +\x1a0\xa1P{\xe9j\xe4\xbd\x0dJHe}\xf3\x9b\ +\x88\xbe\x820M\xd46\x90\xb2z\xb8EK\x96\xec\x07\ +/\x03w\x03}Q\xe3m\x0c\xfb\xcf\xfc\x95\x0d\xd9q\ +\x1c\xef\x9c-<\xad\xc8\x09\xe0&\xd8\xa7B\x81\xeeo\ +\xd2\xf3<\xabM\xfe\xe9\x87\xf1\x1b{\xf6\x1d\xf8\x0c\xc1\ +'p\xc8\xa3\xf1\xc6\xbd\xfb\x1f\x9d+\xddY\xf3\xdd\xb5\ +k\xa3kvH\xae\xeb\x9a\xfc\xa2\x07\x9c\x05\xf5\xf6\x82\ +T\x92h\xc5|\xc1\xbe\xceoW\xcb_\xb3-?\x5c\ +\xf7\xd2\xf6|\x93\xd7\x81\xe0$\x87\x22\x02\x83\xa0C\x82\ +\x99\xc4\xd8\x99\x85h\xdcz=\xdeb\x8b\xee\x02\xaa\x04\ +\xad%\xd1\x0d\x03\x12\x8c\x9ahc\xd8\xff\xf1o\xb7b\ +\xac\xeb\xc7\xa4\xdciz\xdcX\xd3\x0e<\xb9\x9e|`\ +\x1c\xb1\xad\xa1\xde\xee\xe0\xed\x12\xb3\xfa5{\xb6\xee\xd5\ +\xdd1\x13\xab\x13#\x15\xa2Z\xaa\x89m\xd5\x03D\x80\ +\x88\xa8\x8e\x22\x9e\xfe`\xa0c\x22\x9b\xbawv\xfc\x0b\ +\xeb2d\xd4T\xc2C\x07\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x01\xdc\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\x8eIDATX\x85\xed\ +\x97AJ\xc3P\x10\x86\xbfyq\xab\x0bE]\xd8\xd6\ +\x92K((^\xa0^A\x0f \xe8J\xd4#X\xc1\ +\x85\x15<\x88\xd0\x0b\x08\x82^\x22\xe6%\xcf\x85\x8a\x82\ +t\x9d\x8c\x0b\x1b\x916F\xac\xa9\x0a\xe6_\x0d\xf3\x86\ +7\x1f3\xc3\xe3\x0d\xfcw\xc9\xa0\xc3\xda\xdb\x95\x94d\ +_T\x96\x11fK\xc9\xa2<\xa8\xe8\x95\xc1k/.\ +.\x5c~\x08\x10\x86\xd1.\x22Gy`%)Eu\ +\xaf\xd9l\x1c\x0f\x01XkW\x15s\x01<\x0b\xb2c\ +\x8cv\xeb\xf5\xfaS\x19Y\xe38\x9eNSi)\xda\ +\x01\xa6\x04\xb36X\x09nlt\x1e\xdaX\xadu\x1b\ +e$\xcd\x93\xb5n3\xb4\xb1\xde\xd8\xe8<\xf3\x99\xcc\ +\x10\x95e\x00c\xb4;.\x00\xcf\xa3\x0b \xc8\xd2\x10\ +@6pe\x95=O\xb5Z\xed\xb1o\xce\x0d\x03\xfc\ +\x92*\x80\x0a\xe0\xd7\x01&>\x0b\x08\xa3h\x0b\x95C\ +`\xf2\x8bw\xf7\x10=h6\x1agEA\x85\x15\x08\ +\x82`\x1e\x95\xd3\x11\x92\x03L\xa2\xd2\x09\x82`~d\ +\x80\x9fP!\x80\xef\xfbw\x88n\x03\xbd\x11\xee\xee!\ +\xba\xe3\xfb\xfe]Q\xd0\xa73\xd0\xefaa\x1f\xbf\xa3\ +\xbf\xdd\x82\x0a\xa0\x02\xf8Y\x00\xe5\x01^?\x90\xe3J\ +\xe6\x9c\x9b\xe9\x9b\xf7C\x00*z\x05\x90\xa6\xd2\x1a\x17\ +@\x92\xd0\x02P\xf4:\xf3\xbd=D\x06\xaf\xad\xa4\xeb\ +\x8av\xacu\xe2yt\xdf\xfd\xe1\xbe%\xe7\xdcL\x92\ +\xd0R\xf4\x04H\x0d^;;\xcb[L\xda\x8co6\ +>^L2\xbd\xadf\xaf_\xe7\xb9\xc1\xf3\x11u\xaf\ +\xe8u\xdejV\xe9\x05r\xdf\x93\xde\xaf\x9f\x93L\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x06\xb5\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x06gIDATx\x9c\xed\ +\x9bMp[W\x15\xc7\x7f\xe7*\x85\x94\xd0\xa4M?\ +g\x18\x16\x0c\xbb4I\x936\xb4\x14\x18h\xac/\xa7\ +\x8d\xed\xda\x8avmgb\xd9\x1e\xd6\xac\xca\x02\x16L\ +\x16l\xd82S[vW\xedF\xb64\x0cM\x1b?\ +\xe9\xc9\xe5\xa3\x84\x0e\xe5\xa3-0\xcctJ\x17\xddQ\ +\x0a\xc4ij;\x13\xdd\xc3\xc2\x921\xfa\xbcOz\xcf\ +6\x83\xff\xcb{\xcf;\xe7\xfc\x7f\xbe\xf7>=\xe9\x19\ +\xf6\xb5\xaf}\xfd?K\xda\x0d\xa6\x9e}\xf6\x90\xae}\ +\xf6;(#\xc0A\x85\xab\xc6\xf0C\xaf\x90\xff`\x87\ +\xfb\xebK\xa9\xec\xd4\x97\xac\xe5y\x81\xc7\x81uU.\ +\xdf\x8a}\xe6G\xaf\x17~\xfcIsl\x0b\x80\xd1\xd1\ +\xc9;\xd6n3?\x03N7M]\x13L\xda[\x9a\ +}3\xa2\xbeCQ|b\xfa+F\xb4\x0c\x1c\xf9\xef\ +\x19y\xfb\xc0\xc1O\xbf\xf9\xdaK/\xadn\x1f5\xcd\ +\x09\xd6\x0e\x98\xe7i5\x0fpDQ/\x95\x99y,\ +\xc4~CUg\xf3\x00\xfaPm\xfd\xf6\xef6\x8f\xb6\ +\x00@\x18\xed\x5cB\x0f\xefU\x08\xdd\xcdoJa\xac\ +y\xac\x05\x80\xc0\xed\xddKmBHgs\x8f\xf6\xd1\ +g$Jf&\xcf\xf42_\xd7\xc1\xe6\x81\xd6\x15\xa0\ +\xbc\xd1\xbb\xa4\x1e\xb6\xd6\x94\xf7\x02\x84df\xf2\x0c\x98\ +\x0a\xbd\xcd\x03\xad\xdeZ\x00\xa8\xc4.\x01\xd7z\xe7\xda\ +}\x08\xc1\xcc\xcb*\xc4~\xd0<\xda\x02\xa0\xbc\xf4\xc2\ +{\xc6h\x0ag\x08\xb2+\xdb\xa1n\xdee\xd9\x03\xb2\ +\xaa\xaa\xe9\xf2\xd2\x0b\xef\xb5\xcct\xba$\x9d\xcd=j\ +\xad)\x83\x1ev\xe8\xe7\x9aUI\xfa\xc5\xb9\xdf8\xc4\ +\x0e\xacTv\xea\x11\xb5T\x80;{\xc5*\x5cGI\ +U\x8a\xf9_\xb7\x9b\xef\x08\x00\xf6&\x840\xcdC\x0f\ +\x00\xb0\xb7 \x84m\x1e\x1c\x00\x00\xa423\x8f)\xea\ +\xb9B\x00\x9b(/-\xbc\xe5\x92\xdbU\xe9\x89\x99\x87\ +-\xb6\x82pW\xafX\x85\xebjl\xda/,\x5c\xed\ +\x15\xeb\x04\x00v\x17BT\xe6\xa1\xdd\xe7\x80\x0e\xf2\x96\ +f\xdfT\xd5\xf4\xe6\xed\xa4\xa7\x8e\x80\xa9l\x9e\xd4\x83\ +)\xa8y#2\xecj\x1e\x02\xac\x80\x86\x12\x13S_\ +E\xf0\x04\xeep\x08\xff\x17\xd8d\xbf+!\x88y\xe0\ +\x13\x11I{\x8bs\xbf\x0aR#0\x00\x08\x0eA\x0c\ +\x09\xaf\x90\xffm\x90\x1a;a\x1e\xfa\x04\x00\xd1BH\ +dr\xa7E\xc5\x8f\xda<\x0c\x00\x00 \x9e\x9d|\x5c\ +\xacY\x0e\x13BP\xf3\xa8\x0e\x97\x8b\xf3\x0e\xcf/\xed\ +5\x10\x00\x08\x17\xc2N\x9b\x87\x00w\x81N\xf2\x0b\x0b\ +W\x8d\xc8\xb0\xc2u\x87\xf0;\xb5F9=1\xf3p\ +\xf3D\x22\x93;-\x88\xf3\x9eWc\xce\x0dj\x1eB\ +X\x01\x0d\xa5.L\x7fMU\x97\x81\xcf\xf7\x0cV\xfe\ +i0\x89\xe5\xe2\xec\xef\x00\x92\xd9\xe9SX\xf5\x81\xa3\ +\x0e\xa5n\xa81\xc3\x95\xc2\xec/\x07\xebxS\xa1\x01\ +\x80\xfe \xd8\x98\xda\xdd2\x0f!\x03\x80\x80\x10DW\ +Q\x00q\xf9t\x19\xbay\x88\x00\x00@r\x22\xf7u\ +D\xae\xe0\x02\xc1M7\x8cpny1\xff\x8b\x90\xf2\ +m)\x12\x00\x10*\x84\xc8\xccC\x08w\x81N*\x17\ +\xe7\xdfPc\xce\x01-?F\x04\xd0\x0dQ}2*\ +\xf3\x10\xe1\x0ah(\x91\x9d\xf9\x86X{\x058\x14\xf0\ +\xd2\x1b\xa2\xfa\xa4W\x9c\xffy\x14}5\x149\x00\xa8\ +C\xa8Y\x0f\xe9\xf5\x95{]\xc2\xbaXMGm\x1e\ +\x22\xdc\x02\xdb\xa5\xd6\xae\x22r\xd3\xfd\x02\xbd\xa91\xe3\ +\xf2\xd8=\xb0\x22\x07\x10\xcfL\x9d4P\x05u\xf9\xde\ +\xbe.9\x8cU?\x99\x9d>\x15]g\xf5JQ&\ +\xff\x8fy\xee\xee3\xc5?0\x12/\x17\xe6\xfe\x10f\ +_\xdb\x15\xd9\x0a\x88g\xa6N\x1a\xc5\xa7\x7f\xf3\x00G\ +\xb1\xea\xa7\xc7'\x1f\x0a\xab\xaffE\x02 \x91\x9d9\ +a\x14\x1f\xe1\x9e\x10\xd2\x1d\xb5\xc6T\xa3\x82\x10:\x80\ +Dv\xe6\x84\xd4l\xd5\xc5\xbc\xc0\x86\xc2\x86C\xda\xa3\ +\xd6\x98HVB\xa8\x00\x82\x98\x07\xd6\xac0lTS\ +\xc0\xa7\x0e\xf1wG\x01!\xbc\xc7\xe1\xf1\xdcq\x15Y\ +q5o\xd4>\xb5\x5c\x5cX\x01Hf\xa7\xbf\x85\xd5\ +W\x81\xcf9\x5c\xfb\xb1\x85!\x7f)\xff\xce@\x0d\xd7\ +\x15\x0a\x80A\xcc7\xb4[\x10\x06\x06\x10\xd4\xbcX\xce\ +{\xa5|\xb5\xddd\xe2\xc2\xd4\x13\xa2\x5cf\x07!\x0c\ +t\x06\xa4\xc6s\xc7\xd5\x88\xf3\x9e\xeff\x1e\xa0\xb2\x98\ +\x7f]\x85\xa7p<\x13\x8c\xe2\xc73S'\x9d\x1bn\ +\xa3\xbe\x01l\x99\x87{\x1d\xc2\xd7\x10\x1d\xe9f\xbe\xa1\ +m\x10\xd6zf\x15\xee1\x8a\x9f\xc8\xce\x9cp\xe8\xa1\ +C\x8a>\x94\xceL?h\xd1\x15\xdc\xcc\xaf#z\xbe\ +\xbc8\xef\x07\xa9Q\xdf\x0e\xaf\xd2\xf3\x9d%@\xf9\xbb\ +\xc6\xccP\xa50\xfbn\x90\x1a\xd0\x07\x80\x9d0\xbfU\ +kb\xf2\xac\x15s\x99\x08!\x04\x02P7_\x05\xee\ +s\x08\x1f\xc8\xfcV\xcd\x80\x10D\xf5\xacW\x9a\xff\xa3\ +k~g\x00A\xcd[\x95\x11\xbf8Wq\xcd\xdfM\ +\xa9\xf1\xa9!5\xbcB\x04\x10\x9c\x0e\xc1x\xf6\xe2\xb1\ +\xdd2\x0f\xe0\x95\xf2U\xb1\x9c\xc7\xf1`T\x91\x95\xd4\ +x\xee\xb8K\xee\x9e\x00\xe2\xd9\x8b\xc7\x8c\x8d\xad\xe0h\ +^,\xa3a\x9ao\xc8+\xe5\xab\x88\x8e\xe0\x0a\xc1H\ +\xd5\x05B\xd7-\xd0\x8fy\xaf\x94/;\xc4\xf6\xad\xe4\ +\x85\x5c\x1c\x95Wh\xf3\xd6g\x1b}$V\x87\xbam\ +\x87\x8e+ \x9e\xbdx\xcch,\xc0\x81g\xc7\xa26\ +\x0fP^\x9c\xf7\x11=\x0f\xac;\x84\xdf\xabF\xaa\xe9\ +\xcc\xf4\x83\x9d\x02\xda\xae\x80-\xf3\xca\xfd\x0eE6\x10\ +;Z^\x5c\xf0\x1cbCS\xd0\x95`\x90\xb3\xcbK\ +s\x7fj\x9eh\x010\x94\xfd\xf6\x17\x0e\xd8[o)\ +<\xe0\x90xW\xcc7\x14\x9f\x98N\x18\xd1\x9f\xe2\x06\ +\xe1or\xabv\xc6\xfb\xc9\x8b\x1fn\x1fl\xd9\x02\xb1\ +Z\xed{\xff\x0b\xe6\x01\xfc\xe2\x5c\xc5\xaa\x8c\xe0\xb6\x1d\ +\xee\xd3X\xec\xfb\xcd\x83m^\x96\xd6'\x1c\x92m(\ +2\xb6\x9b\xe6\x1b\xf2\x8bs\x15\xb1\x8c\xe2\x00A\x84\xb3\ +\xcdcm\xfe_@j=\xf2l(2VY\x9a[\ +vo3Zy\xa5|\xd9\x05\x82B\x8b\xb7V\x00\xa2\ +\xdd\xfe\xaa\x1b\xd6\xea\xd3{\xc9|C^)_F\xec\ +\x18\xdd!\x5ci\x1eh\x01P\xab\xdd\xbc$\xf0~\x9b\ +\x8b7\xac\xd5\xa7\xfd\xd2|K\x92\xbd\xa2\xf2\xe2\x82\xd7\ +\x05\xc2\x07\x07L\xedR\xf3`\xac%\xea/o\xaf}\ +\xf1\xd4\x99\x97c5=\x04\xdc\x0f\xdcD\xd47\x1a{\ +\xae\x5c\x8a\xeeW\xda\xb0\xf4\xd7?\xff\xfe\xfd/\x1f\x7f\ +\xe4\xb2\xaa< \x9b\xef\x1b}\xac\xaa/\xdf\x16\xb3\xcf\ +\xbcVx\xf1\xa3\xdd\xeeo_\xfb\xda\xd7\xde\xd2\xbf\x01\ +\xee\x83DR\xf4\x9c\x9a;\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x02\xeb\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\x9dIDATx\x9c\xed\ +\x9a\xbdn\x13A\x14F\xcfu\x08\xa1\x09]\xde\x807\ +\xb0]\xd1\xf0\x084X6\x09\x08\x1a{\x0blWt\ +\xb4<\x80m\x90l7\xfc\xe6GP \xde\x80\x1ap\ +\xc5s !\xd1@$|)\x22$3^\xc7\xb1w\ +fvf\xe3[\xee\xde\xfd4\xe7hvv5\x1a\xd8\ +\xd4\xa66u\x99K\xf2\x1e\x80\xeb*7\x07\xb7\x11}\ +*\xc2\x0f\x9dJ2\x19\xb7\xbf\xcd\xde\xbf\x92\xd7\xc0|\ +T%\xe9\xd5Q=\x04J(HI\x87\xc0\xcd\xd9\x9e\ +R>Cs_g\xf0r\x06\xff\xaf\x94\xebf_!\ +\x05\xa4\xc2\xc3\x1f\xd0'fo\xe1^\x81E\xf0\xaa\xd2\ +\x98\x8c;\x1f\xcd\xfeB-\x82\xe7\xc3\xb7\xdf\xa7=S\ +\x18\x01\xeb\xc0CA\x04\xac\x0b\x0f\x05\x10\x90\x05\x1e\x22\ +\x17\x90\x15\x1e\x22\x16`\x03\x1e\x22\x15`\x0b\x1e\x22\x14\ +`\x13\x1e\x22\x13`\x1b\x1e\x22\x12\xe0\x02\x1e\x22\x11\xe0\ +\x0a\x1e\x22\x10\xe0\x12\x1e\x02\x17\xe0\x1a\x1e\x02\x16\xe0\x03\ +\x1e\x02\x15\xe0\x0b\x1e\x02\x14`\x1b\xbe\xdc\x1c\xdc\x91\x92\ +>\x07(\xa1\xad\xcf\xc3\xee\x87\xd9\xfbA\xed\x08\xd9\x86\ +\xaf$\xbd\xba\x88\x9e\xa0\xec\xa1\xecM\x91\x91\xd9\x13\x8c\ +\x00\x17\xf0)ys\x15\x84\x00O\xf0SA\x1f\x99\xbd\ +\xb9\x0b\xf0\x06/\xdc\xff2\xec\xbe3\xfbs]\x04\xfd\ +\xc2w\x0e\xd3\x9e\xc9M@\x08\xf0\x90\x93\x80P\xe0!\ +\x07\x01!\xc1\x83g\x01\xa1\xc1\x83G\x01!\xc2\x83'\ +\x01\xbe\xe0U\xe5\xded\xdc>Z%\xcb\xb9\x80\x90\xe1\ +\xc1\xb1\x80\xd0\xe1\xc1\xa1\x80\x18\xe0\xc1\x91\x80X\xe0\xc1\ +\x81\x80\x98\xe0\xc1\xb2\x80\xd8\xe0\xc1\xa2\x80\x18\xe1\xc1\x92\ +\x80X\xe1\xc1\xc2\x19!_\xf0\xc0\xc1d\xdc>^5\ +\xaf\x9a\xf4j\x8a<\x03\x07{\x82>\xe1\xbf\x8e:\xab\ +\xc3\xb7\x06\x07\xaar\xecdO0\x0ax\xf4\x15K\x18\ +\xd7\x12\x10<|\xd2\xdfO\x81\xb7\xb3'\x18\x05\xbc\xf2\ +\xda\xcc\xb3\xb2'\x187|\xc6=\xc1\xd0\xe1\xcb\xcd\xc1\ +]\x11}c\xe6-\xfbt^H@Q\xe1\xe1\x02k\ +\x807x\xd1}\xdf\xf0\xb0d\x06x\x85\x1fvOV\ +\xcd\xcb\x0a\x0f\xe7\xfc\x09\x86\x0e_i\xf5\x1b0\x0f\xcf\ +\x8a\x7f\x8c\xa93 \x0ex\xde\xce\xe5\xad\xb1\x86l\x99\ +\x17\xaaI\xaf\x86\xca\x11\x96\xe0\x17\xe4\xad\x0d_Mz\ +5H\xc9[s\x01\xfdo\x06\x94\x9b\xa3m\x91\xdf\xdf\ +\x81\xdd\x99\xcb\x19\x0e'\xa4\xe6ex\xe7\xed\xe6\x81\xf1\ +\x15\xd8=\xbd\xba\x05\xec\xcc\x5c\xcat,%%/\xd3\ +`m\xe7\x81!\xe0\xd3\xcb\x87\xbfTy\x0c\x9c\x02?\ +\x81z\x9639f\x9e\x886\xb2\x0c\xd6v\xde\xc2\xba\ +\xd1\xee\xef\x94\x9b\xa3\xedP\xf3n=xq\xcdf\xde\ +\xa66u\x89\xeb/W>\x7f\x9e4a\xbc\xb4\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x01 \ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xd2IDATx\x9c\xed\ +\xd0\xb1\x15\x82P\x10D\xd1]\x8b\xa0\x16\xeb\xa0\x05\x22\ ++\xb2\x0b\xea\xb0\x0e\x22\xab\x00\x034\xd3\x94\xeb9\xcc\ +\x8d~\xf6g_UD\x9cY\xab\x8f\xaf\xf36n\xb5\ +\xdd\xf7\x11}{\x8c=\x8b\x1d\x17\xf1iU\xd5\xfb\xf8\ +\xa1\xaa\x86O\x08\x81\x05\xa8\xfd\xf8o\xefC\xc9\x00\x7f\ +!\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00-\x01\xf4\x00\ +-\x01\xf4\x00M\x06x\xfex\x1f\xca\x05X{\xea\xae\ +\xa5\xbb\x96Z{b;\x22\xe2\xd4^h\x08\x13N;\ +F\xe4\xd2\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x01\xaa\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\x5cIDATX\x85\xed\ +\x94?KBQ\x18\x87\x9fW\xadM\xac!\x8aZ\x0c\ +\xb7lrtp\x09mh\x08\xba\xda\x16\x05\x1aA\xdf\ +\xa0I\xce\xd0\xd2'\xa8Tp\x0a2\x8d\x86Z\x14\xa4\ +\xbe\x80\xd0\xe4\x94\xd4\x14\xd1\x90SC\xea=MZ\x8d\ +\xf7\x5c\xb8K\xf7\xd9^8\xe7\xf7>\xbc\xe7\x0f\xf8\xf8\ +\xf8\xfcw\xc4\xe9\xfa\xb4U\xb0\x01\x06\xa3\xe1\xec\xfdM\ +\xb5\xefV \xe0dq\xb1X\x9c\x08O\x05C\x1f\xb9\ +\x5c.\xe8\xa9\x80R\xcaF\xf4\xf6\xb8\xee\xdb\x91\xa1\xa7\ +\x02\x00\xadz\xe5J\xe0x\x5cg\xac\xc2\xa3\x1b\x01\xa3\ +\x11>u;\xedX<\x91\x02\x96\x81\xf9\xd8Jb\xa1\ +\xd7\xed\xdc\x99d9\xbd\x84\x7fH[\x05=\x09\xd2\x1c\ +4\xaf\xcb\xe7N3\x1c\x1f\xc1o\x92\xabK\x93\x09j\ +\xe1,\xb3\x95Oy*\xa0\x94\xb2\x07\x81\xe9\xf0\x8f\x84\ +\x09H\x97?S\ +\xacn\x00\x88A\xdf\x03K\x8d~\xe6\xcf\x83\xa4(.\ +\xf9B\x03\xc15\x95\x06\x1c\xff\xc9)}\x81v\xa2\x91\ +V?\x029\xf4\x06\xe7+\x0d\xf0]\x8d\x8dv\xd5]\ +\x84@\x0e\x15\xd7~\x98\x01\x97\x0ag\x80\xb5\x00k\x9c\ +\x01\xd6\x02\xacq\x06X\x0b\xb0\xc6\x19`-\xc0\x1ag\ +\x80\xb5\x00k\x9c\x01\xd6\x02\xacq\x06X\x0b\xb0\xc6\x19\ +`-\xc0\x1ag\x80\xb5\x00k\x9c\x01\xd6\x02\xacq\x06\ +X\x0b\xb0\xc6\x19`-\xc0\x1ag\x80\xb5\x00k\x9c\x01\ +\xd6\x02\xacq\x06X\x0b\xb0\xc6\x19`-\xc0\x1ag\x80\ +\xb5\x00k\xc2\x0c8,\x0fH6\xbdA\x81\x1c\x0e\x83\ +\xf3aer\xb9\xf2PbW4\xb2\xeaG \x87\xad\ +\xe0|X\x99\xdc\xea\xc9\x90\x1a\x91TSOA#\x22\ +\x89\xa2F|\xa1\xb5\xe0\x9a\x0a\x03D-\x96\xc7\x04\x86\ +\xbclv<\x22}\x91\xe3e\xb3\xf7NU\x8eS\x0b\ +\xc15\xd5\x8b\xa5\x85\xc2\xd1\xd1\xc1P\x7f\x7f\x7fS\x15\ +M\xae\xaf\xaf\xc7\xc9\xd6\x15\x10\xb1R\xa8\xb6b\xe9x\ +<\xbeGp\xe6$@\xc4ZZ\xda\xd2\x9e\x97\x9dh\ +\x86\xe3 \x89\x9e\x97\x9d\x08$\x0f\x82\xb3a-4\xa1\ +\x09Ib&\x93}\x1b\xec\x16)5L,\x91\xdai\ +\xb4*\xd2R\xc3D\x97\xa8\x11\xff\xb6\x07\x00Bs\x89\ +\xc4\xad'57L\x00\xffU\xcb\xcc\x5c\xa1\xb0;}\ +V\xcbL\xd5\xa6\xa9Lf\xeb\x81\xa0\x97h\xbe\xa6\xa9\ +\x1c\xc1\xd9\x0b7M\xf9)\xb5\xcd\x8d\x95\xea\xed\x07p\ +\x5cu\xddxms\xc7\xf7\xfc\x9a\xa8\x85\x8e\xf6\xf6\x85\ +Z\xda\xe6\x1c\x0e\xc7\xe5\xe67I\x9a\x11\x82(n\xc8\ +n\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x18\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xcaIDATX\x85\xed\ +\x96?H\xc3@\x14\xc6\xbf\x97\x0a)\x08\xd5]\xa9\x8b\ +\xb8v\x15A\x5c\x8c\xae\xd2X\xc4!.\xad.\xba\x14\ +D\x5c\x9c:8\x08.\xc5\xa5V\x1c\x5c\x94\x92\x82\xd0\ +E\xb3\x08\x228\xda\xd1\xc1\xa18\xb8\x08\xfe\x19\x0a\x85\ +\xe6\x9e\x8b\xa955i\xd2\xbf\x83\xfd\xa6w\xc9\xcb}\ +\xbf\xbc\xbb{\x1c\xf0\xdfEn/\x174mX\x94\x83\ +)\x02G\x01L\xb4\xe9U\x02X\x97+\x81\xbdB!\ +Sn\x0a\xb0\xa0i\xc3\x5c\x0e\xde\x01\x1ci\xd3\xd8&\ +*\xca\x15\x9a\xb1 $\xa74Q\x0e\xa6:o\x0e\x00\ +\x1c\xa9\xc8f\xca\x1a9\x02|\x97\xbdK\x22\xd5\x8a\x86\ +\x5c\xb2~\xad\xb9\xa1g]\xf7K3)j\x82\xff\x9a\ +\xdb\xb1\x02\xbd\xd2\x00\xa0a\x0f\xcc\xc76\xc2d\x9as\ +\x0d\xcf\xd5\xf8\x96\xd3$\x12I\x82\x85(\x8e\x06>\xef\ +s\xb9\x9c\xd92\xc0\xfcr|\x9b\x84\xd8\x07Q\x03\x18\ +\x81\xd2N\x9303@\x8471r\xbb\x18\xddX\xb9\ +\xcag^\xbc\x02\xd4\x96@Q\x13\xab\xc4t`\x87\xf2\ +#\x02fM\x12\x17\xb1X,\xe0\x1b\x00\xc0N\xab\xc6\ +v\x88w34\xed5\xbf\xfeo\xed]\xef\xc8\x87\xef\ +\x12\x80\xb1\x1a\x84$E\x00\xdc\xf9\x05\xf8\xd5h\x0c=\ +\xeb\xb8\xe9\xecR\xd4\x04\x00lZc\xc1\xc2\xf3\xe9\xea\ +\xfb1\x1c\x00\x0c\x00\xfa\x0e\xd0r\xd7s\x13\x81\xd2\x8a\ +\x9apl\xdd\x00JV\xd0\xa7\x0a\xb0nE]\xa9\x80\ +\xbb\xa8(W\xa4=k\xd4\xcb\x0a\x94\x00>\xac\xbf\x11\ +\x03u\xedWQ\xd7?\x00\x0eu\xc4\x8ay\xcd\xc8\x9f\ +\x9cyI\xadU\x80 \x8c\x8e\x98\x03U2\xc5\x8d\xd7\ +\xe4\x9f%\xa8\x8a$\x18\xafm\xdb3v\xaf/O\x9f\ +\xbd\xa6\xd7.\x0eO\x8f\x0f\x9f\x93S\x91s\x92(\x0c\ +H\xe3\x00d_\xb6@\x91\x88\x92\x86\x9e=\xf6\xf1\xdd\ +@\xf8\x02g\xdb\x80\xa5\xc9rZ\xc9\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x0a\xf4\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x0a\xa6IDATx\x9c\xed\ +[{pT\xd5\x19\xff}\xf7\xeen`\x93\x08d\x11\ +\x83\xd2\x91\xd8\x96\xd1X\x98!\xbb\x0bR5\x22\xda\xd1\ +Z\xc5\x07\xae\xf51(Q\xd8M\x80,\xc2T[\x9d\ +\xa9K\xacv\xb4j\x08\xbb`\xdc\x08\x18A\xa6\xad\x99\ +Q\xa7:\x8aL\xb5\xa1\xd4\x22d\x03\x96\xfa\xc0\xf1\x11\ +\x1f4\x90J\xc2#\x12\xb2\xd9\xdd\xf3\xf5\x8f \xdc{\ +\xf7\xee\xbdw\x93]\xa6\xd3\xf2\xfbo\xbf\xf3;\xdf\xf9\ +\x9d\xef\x9e=\xf7<\xbe\x0b\x9c\xc6i\x9c\xc6\xff3\xe8\ +T42\xb5*|\xa6\x5c@\x95\x80\x98\x0c\xa6\xf3A\ +8\x8f\x19\xa3\x098\x03\x80\x0c\xd0\x11\x00G\xc0\xfc\x15\ +\x08\x1f\x01\xf8PJ\xd1\xd6\x1dkj;\xf2\xad-o\ +\x01p\xfb\xc3\xdf\x97\x08\xf3\x981\x1b\x84)Ct\xd3\ +\xc1\xe07$\xc1\xcdm\xcf.\x89\x01\xc49\x15\x89\x9c\ +\x07\x80\xc9\x1b\x08_\xc5\xa0\xfb\x01\x5c\x9e[\xdfx\x9f\ +@\xf5\x82\x1d/\xb47\x05\x12\xb9r\x9a\xb3\x00\xb8\xfd\ ++/'\xa2\xdf\x01\xf0\xe4\xca\xa7\x1e\x18\xf8\x02\xcc\xcb\ +\xdb\x9b\x82\xebs1\x22\x86\x1d\x80\xe9\xf3\x1b\xceJ\xca\ +\xd2S\x04\xdca@\x13\x04\xbc\x03\xe2V!\xa4=@\ +\xea3\x1bQ\x8f\x90m\xbd\xc9c\xa9\x94<\x22Y\x0c\ +\xb6\x8d\x22F\x99`\x9aD\xe0\x19 \xfc\x04\xc0H\x03\ +\xe1[!\xa4\x9a\xb6g\x17\x7f0\x1c\xfd\xc3\x0a\x80\xa7\ +:<\x0d\x8cW\x00\x8c\xd7)\xee\x05\xf0:\x11^%\ +Y\xda\xb4c\xf5\xe2\xeel|\xcfXZ?r\xe0\xa8\ +m\x16\x01\xd7\x810;C\x1b\xfd\x00\xee\x8eE\x83\xbf\ +\xcf^\xfd \x86\x1c\x00\xb7?r;\x11\xaf\x03P\x90\ +&\x8a9\x1c\x97\xed\x8f\xfd\xb3q\xe1\xc1\xa1\xfaW\xa2\ +\xdc\x17r8\xc7\x94, \xa2\x87\x18\x18\x97F`z\ +46\xfe\xc0C\xa8\xab\x13\xd9\xfa\xce>\x00\xa1\x90\xe4\ +\xde?\xf6\x11\x02?\xa0)\x11DX'%Q\xb7}\ +Mpo\xd6~-\xe0\xe2\xbb\x1f/\x8e\xdb\x9c\xcb@\ +\xfc\x0b\x00E\x9a\xe2W\xfady\xee\x87O/\xfa6\ +\x1b\x9f\xd9\x05 \x14\x92<\xfb\xc6n\x04\xf1\xad*;\ +\xa3\x13\x12n\x8c=\x13\xdc\x91\x95\xbf!b\xfa\xfc\xf0\ +\x84\x94\x8c\x97\x91>\xe1\xee\x92\x1d\x98\xb9=\x127j\xbc\xdc\x17r\ +\x14\x88\xd4+\x00\xae0\x13:\x04\xdcL\xe8_\x8fP\ +\xc8\xf0o\xdb\xda\x5c\xd5O\x04\xcd\x83\x92\x96eZ\x1b\ +\xe8:\xf3.\x5c]\x0a\xe0j\x85)!\x0b\xf1\x88\xb1\ +>\xa6B\x97k5\xc0\x95\xc6\xbca\x80h\x8e{\xbf\ +\xcbt\x14N\xec.\xdd\xc0\xc0''\xaa\x81\xcf\xf9\xcc\ +\xd5u\xa5\x1eW7\x00\x22\x95\xbc\x1d\x8aE\x12\x01o\ +o_so\x97Q\xa3\xde\xc0\xaa;\x981\xdfL\xdc\ +pA\xc0C\x9e\x05a\xdd\xce|\x87\x96\x96[RD\ +hQ\xda$\xe6\xbb\xf4\xb8\xba\x01 \xd0u\x1a\xcb\x9f\ +\x8c\x1at\xfb\xa3N\x01\xfe`\x1b\x00\xe5\xa8\x1d\xd5\ +\xe1\xda\xef\xd6\xf2\xd2\x02P\xe0t\x5c\x04\xc0q\xd2B\ +\xef\xb57\xdd\xfb\x95\x96\xf7\x1d|\xbe\x17e\x22\x04\xcd\ +5\xe7\x1a\xbc\xc4\xb0\xb8\xaeN\x00\xaczp\xcc\xe9\xe7\ +\x94:\x7f\x01\xe9G\x1a\xc3V\xa3v:\x5c]\x97\x82\ +q\xa6\xa1\x98\xfc`\xf2\xf4\xc0\xca\x1f\x1a\x11\x98\xd5\xda\ +\x89q\xa1\x96\x93\x16\x00f\xbe@\xf5\x1b\xe2\x13-G\ +S\xe1f\xc3\xf2<\x22\xc9\xd2\x1c\xa3r\x89\xa1\xd6N\ +\xb8 \x8d\xa35\x10a\xa2\xca\xc0d\xf8\xee\x07(\xaf\ +\xa7\xc0\x86-\x13\xa7\xfd\xa7U\xb0\xdb\xb4\xda\xcb\xb4\x94\ +\xf4\x11@(V5\x22\x91\xc9^\xff\x94N~*\x10\ +0\xc1\xa8\xbc\xb0\xcf\xa9\xd5^\xac\xe5\xa4\xcf\x01\xac&\ +I\xcc\x99\xcf\xd8\x06Wez\xa7\xb5\xa7\x04l\x12\x80\ +\xd6\xe6yq\x00\xca\x9d\xa0\xa3\xdc\x17r(9z\xeb\ +\x00\xd5\x06))\x89\x8c\x07\x1e3\x07\xebgu\xac\x96\ +c\xd8\x87\xeb@O|\xaf\x8a\xc0r\xda\xb0\xf9\x0e\xc7\ +\xf7\xd9\x86+\xc4\xbc\x82ax\xfa\x09\x02\xaa\x13U\ +\x16<\xdaD\xc4\xbfL\x85\xe6\x0bd\x1c\x80c\xb6\xc3\ +\xa34\xa6^-'}\x12\x04}\xa9jCJ\x9f9\ +\xd5\xe5\xf4\xbeQy^\xc1\xc6m\xb3l;Om\xc0\ +\x17Z\x8e\xce$\xc8\x1f)\x7f\x12`\xbc\xd8 \xbcd\ +T\x9eO0\xc8\xb0m\x01\xa1\xd2\xce\x84=ZNz\ +\x00HR]62\xab\x0eE\xd2Pt\xach3\x80\ +\xacncr\x02\xc6\x97\xedM\x8bv\x19S4\xdau\ +FLZ\x00\xfad\xda\x06@y\xff^1}~8\ +\xe3\xeb\xa6\xb5\xb9\xaa\x1f\x8cf3\xbdy@\x93\xe1\x91\ +|($\x11p\xad\xd2\xc42\xb7jii\x01\x18\xbc\ +[\xa3mJ[R\xa6k\xb5<%R\x09<\x0c\xe0\ +\xb0\x89\xe0\x5c\xe2k{aR{\x0f\xa0\x82\xb7s\x8c\ +\x1b\xea5\xca\x913\xc6u\xc7\xb4<\xfdw8\xabw\ +QD<\xdb\xa8\xb1]\xcf\x05\xbf!\xb0\xc9\x89Q\xee\ +@\xa0\x07\xb7\xadXv\xcc\x90$I*\xcd\x0cl\xd2\ +;\x1e\xd7\x0d@\xcaA\x1b\x01\x9c<\x81e\xcc\x9aZ\ +\x156\xdc\xf1\x15\x96\xf64\x10\xf0\xa6\xa1\xa8\x5c\x80\xb1\ +\xa1-\xbaX{'\xa8F($1\xa0\xda\xa4\x11\xf8\ +y=\xaan\x00\x8e\x9f\xfboV\x98\x0ad{\xdau\ +\xb8\x0a\xaduu\xc9DE\xf0\x0b\xe0$\xc2\xa9\xbb\xfe+\x95\ +\x9a\x81\xd8\xf0'\x00cr\xb4\xfdg\x95\xbd\x82-\x80\ +\xb2\x1f\x98\xec\x00a_\x17\x81\x0fH\xa5c\xb2\x02\xbc\ +jk\x9b\xa8I\xe03FV>\x88\xd2F\xdd+z\ +\x17\xa5)`GF\xc6Y \x92L6[z\x13\xad\ +i\xe0\xbbP\x16\x88d\x83\xcdY\xbdTP\x1b\xe8\x0f\ + T\xeb\xb7\xaeR\x05\x1b\x97\xb5\x86u\x03@\x83.\ +T\x86\xa8\xdc\xc2\xee\xac\x96\x91\xe6\x87>\xae\x08Q\xeb\ +\x0e\xbb-\xdd\xc3^\x04PE\x88\xdaC\xd4\x9d\x09w\ +l?\x00\x90\x9d\x0cQ\x7f\x95$\x9f\xee\x87[\xc8\x8f\ +\x90\x90\xd36#\xcb.?n\xab\xffu/\xcc\x01\xcf\ +S\x97\x22\xdb\x8b\xf6\xb6\xad\xddo\xa3\x9a\x016\xfe\x0a\ +\x00\xc0\xd6\x94za_\x97\x90wl\xbe\xe4\xf4\xfew\ +\xf5\x03\x8b\xca\xad\x03IsB\xef\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x04r\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04$IDATx\x9c\xed\ +\x9bM\x88\x1cU\x14\x85\xbf[\xdd\x09\x8a\x8a *b\ +OWu\x0d\x19\x14w\xc2\xe0RP4\x1a\xc4\xe0\x0f\ +\xe8JDQ\xd0\x85\x18A\x11t\x11!\x8a\x11\x04\x17\ +\x22\x1ap\xe3\xc2\xa0\xae\xc2\x80FG]\x08\x82\xe0B\ +\x10D\x82f\xa6\xe7u\xcd$\xd1\x88\x8a`\x18\xec\xee\ +w]\xcc\x88U5C\x98!\xef\xbdz\x9a>\xcbs\ +\xa0\xee}\xa7\xee}?\xf5\x03\x13L0\xc1\x04\xff\x01\ +\x18\xb3\xb2\xdf\x0c\x8a\xe1\x92)F\xc6\x14/\xb8\xba\xae\ +\xb8\xba\x90O,--\xdf\x84\xe8\xe7\xfc\x9b\xaf\xede\ +\xdd\x96\x8bk'..\xe2\x13\x83\xc1`\x16\xd19J\ +7KU\x9d\xe5\x1d\xb5\x01\xfd\xfe\xca\xb5V\xe5(p\ +q\x99\x17\x11\xeb*F\xb4\x06,,\xac\xa4Ib\xe7\ +\x81\xcb7\x91\xd5U\x9c(\x0d\xf8\xf1\xe4\xc9+Zm\ +;\xaf\xd0\xf5\x1d+:\x03\x8e\x1d;}\xc9\x8e\xbfF\ +\x1f\x01\xd7\x84\x88\xd7\x0e\x11d\xab\xe8\xf7\xfb\x17H\xb2\ +z\x04\x98\xadI\x8a\xa7\x15+\x9a\x0aP\xd5\xb6\xb4\xda\ +\x87\x81\x9b\xeb\x12\xe0l\xd2\xab#\x0a\x03TUL\xb1\ +|\x08\xe5\xee\xaa\x22^\x07\x0f\x91\x18`\x06\xcb\xaf\xa0\ +<\x5c\xe6DPP\xaf\x83\x87\x08\xe6\x00c\x8ag\x15\ +\x9e)s\xba\xb6\xc8y\x1f<4\x5c\x01\xc6\x14\x8f*\ +\x1c\xac\xf3\x22\x8cC\xe5\xd0\x98\x01KK\xc5\xbd\x0ao\ +mT\xfc\x97}\x19\x8d\x18`\xcc\xca-\x08\x877\xc4\ +W\xec\xfa\xc4\x17\x0c\xc1\x0dX,\x8a\x1b\x14{\x04\xd8\ +Y\xe6\x15,\xe2n\x8b\xbbU\x04\x9d\x04\x8d1\xd7\xa9\ +\xe5(pQM\xb2\xe2p\x7f\xbf\x1d\x04\xab\x80\xc5\xc5\ +\x13\x99\x92\xcc\x03\x97U\x04\xc1\xd2\xd0\xe0!\x90\x01\xc7\ +\x8f\x9f\xbaRZ\xe3O\x81N\x99\x17\xb0hs\x83\x87\ +\x00-\xb0\xb0\xb0pi\xab=\xfc\x18\x98\xa9*\xaa\x1a\ +x\xc2\xdb\x0c^\x0d(\x8a\xe2Bk\x99S\xb8\xbe&\ +)\xb8{\xa8q.\xf0\xd6\x02\xaa\xda\x1eYyO\xe1\ +\xc6\xbaD\xa0]\xdeV\xe0\xc5\x00UM\x06\x83\xe2m\ +A\xf7\x96y\x89l\xf0\xe0\xc1\x00U\x15c\x8aW\x15\ +y\xb0\xcc\x8b\xa0\x1a\xd9\xe0\xc1\xc3\x1c`\x8a\xe29D\ +\x9e*s!\x0f7\xdb\x85\xd3\x0a\xe8\x0f\x96\x1fC\xe5\ +\xc5:\x1f\xf2p\xb3]83\xa0o\x8a\x83\xa2\xfa\xe6\ +F%\xec\xe1f\xbbpf\x80\xd4\x1eh\xc0\xfa\xfe>\ +\x82\xb5\xfelp\xd7\x02\x9b\x94y\x03g\x9bm\xc3]\ +\x05 OR\xdb\xd3+\x12\xc5#\xb7\xb3\xc1Y\x82Y\ +6\xf5\x01\xaaO\x949\x01\x14Z1\xbf\x83uz\x87\ +z\xbd\xf4\x0d\x81\xfdeN\x00\xd4Fk\x82\xf3\x12M\ +\xd3\xa9\x03\xc0\xeb\x15R\x04\xc4\xdd\x1b]\x97p\x9e\x94\ +\x88h\x96N\xed\x03\xde\xad\x08\x8a q<\x86/\xc3\ +KB\x22b\x7f9\xfd\xd3C\xc0\x87\x15A\x11\x90D\ +\x22\xea\x06owdvvv\xb8\xa3\x9d\xdc\x07\xf2e\ +UQq\xf9\x81\xc3\xb9\xc2k\x22\x9dN\xe7\x8c\xda\xe1\ +\x9d\x08\xdfV\x15\x114\x8ev\xf0\x9eD\x9e\xe7\xbf\xeb\ +xt;\xb0P\x11\x04A\x9ao\x86 w!\xcf\xf3\ +S\xe8\xf8V\xe0DEPM\xd6\x96\x88\xe6\x10\xac\x0c\ +{\xbd^?\x11\xbd\x0d\xf8\xad\xaahB\x83\x9b\x84\xa0\ +}\x98\xa6\xe9w\xa8\xdc\x01\x9c\xa9\xe7\xa1\x0d\x99\x10|\ +\x22\xea\xf5\xa6\xbeR\xd1{\x80a\x99\x17HT\xc3\x9b\ +\xd0\xc8L\x9c\xa7\xe9'*\xfa\x00\xb5\xc3\x93\x08\x09h\ +P\x13\x1a[\x8a\xf24}_\x91\xc77*aO\x90\ +\x8d\xae\xc5y6u\x08\x91\xe7\xeb\xbc*N>\x83\xdd\ +\x0a\x1a\xdf\x8cd\xdd\xce\xcb\xa8\xbeV\xe6D\xfei\x07\ +\xffh\xdc\x00\x11\xd1,\xeb>-\xe8;e^\xd7\xcf\ +\x0d\xbe\xe37n\x00\xac\x1d\x9e\xd2\xb4\xfb\x88\x22sU\ +E\x05\xcf9Fa\x00\x80\x88\x8c\xb0\xc3\xfbQ\xbe\xa8\ +Kx\xcc3\x1a\x03\x00\xf2<_\x1d\x0eW\xf7\x82~\ +S\x93\xbc-\x8dQ\x19\x00033\xf3\xc7h\xb8s\ +\x0f\xca\x0f!\xe2Eg\x00\xc0\xae]W\xfdlmk\ +7\xb0\xe2;V\x94\x06\x00LO_m\x04\xbb\x1b\xf8\ +u\x13\xd9YKDk\x00@\x96e\xdf\xdb\x84=\xc0\ +\x9fe\xfe\xbc\xf9e\x06`\xba\xdb\xfdZH\xee*\xbf\ +b;/~\x99)#\xcb:\x9f\x09r\x00\x18\x83\x8c\ +\x13\x91\x97\x9a\xcei\x82\x09&\xf8\x7f\xe0o>PN\ +\x18\x86\xf9p\xa3\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x00\xc5\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00wIDATx\x9c\xed\ +\xd0\xb1\x0d\xc2@\x10\x04\xc0=\xe8\x01Q\x0au :\ + rE\xee\x82\x90\x1e\xe8\xc4\xa2\x07xR\xf4\x8e\x8d\ +%<\x13\xae.\xd8\xdb\x04\x00\x00\x00\x00\x00\x00\xd8\x82\ +\xea\x83\xd3\xad\x9d[\xda\x98\xe4\xb0B\x9f%My\xd7\ +\xf5q\xa9\xfbw\xb8\xeb\xaf\xfe\xf4\xf9$9\xd6\xbe\x8d\ +}8\x1b`kf\x03TjH\xf2\x5c\xa1\xcb\xd2\xa6\ +\xf6\xaaa\xed\x12\x00\x00\x00\x00\x00\x00\x00\xc0\xef}\x00\ +N\xfe\x12\x08*?\xe7\x81\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x02\xda\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\x8cIDATx\x9c\xed\ +\x9a;o\x13A\x14F\xcf\xb5\x13B\x13\xba\xfc\x92H\ +\xb6%\x1aZ\xba\x0a\x84d6\xeb8\xde\x9d\x99\ +\x9dY\xfb\x96\xb3w?\xcd9\xda][W\x03\xcbZ\ +\xd6\xb2\x16\xb9\xac\xee\x0d\xf8\xaeN\xa6-\x93\x9eH\xfc\ +h\xb7\xed\xc1\xe7-\xfb6y}\xa5\xae\x8d\x85\xa8\xee\ +P}\xa4#\xa0e\x06\xe3\xb1\x9e\x03\xd7'{Z\xf5\ +l\xcd\x7fu\x87\xea\xc3_\xf8\x7fk-\xe3Z\xbe\xaf\ +\x91\x02\x8a\xe0\x81\xb1\xb0\xc7\xf9\xde\xc6\xbd\x02\x17\xc0\xef\ +\x8fv\xecC\xbe\xbfQ\x1f\xc1\x19\xf0\xef\x8a\xeei\x8c\ +\x802\xf0\xd0\x10\x01e\xe1\xa1\x01\x02\xaa\xc0C\xe2\x02\ +\xaa\xc2C\xc2\x02\x5c\xc0C\xa2\x02\x5c\xc1C\x82\x02\x5c\ +\xc2Cb\x02\x5c\xc3CB\x02|\xc0C\x22\x02|\xc1\ +C\x02\x02|\xc2C\xe4\x02|\xc3C\xc4\x02B\xc0C\ +\xa4\x02B\xc1C\x84\x02\x5c\xc3w\x86\xba\x05z\x06\x80\ +\xec\xfeh\xd7\xb2\xc9\xebQM\x84\x5c\xc3w\x87\xea\x1b\ +:5\xd80\xd8\xc04\xc8\xf7D#\xc0\x07|A\xde\ +\xb9\x8aB@ \xf8\xb3\x96\xd9\xc3|o\xed\x02B\xc1\ +\x1bv\xf7\xcb\xb6\xbd\xcd\xf7\xd7\xfa\x11\x0c\x0a\xbfcG\ +E\xf7\xd4& \x06x\xa8I@,\xf0P\x83\x80\x98\ +\xe0!\xb0\x80\xd8\xe0!\xa0\x80\x18\xe1!\x90\x80P\xf0\ +\x92\xdd\x19\xed\xda\xf1\xcf\xc9L0i\xf8\xaa\ +3\xc1\xd8\xe1;\xefu\xdbL\xaf\xcf\xe5\xcd\xf8\xe9\xbc\ +\x94\x80\xa6\xc2\xc3%\xce\x0a\x87\x82\x07;\x18m\xdb\xe9\ +\xbcyU\xe0a\xc6\x13\x10\x12\xfe\xebNxx\xb8@\ +@\xf4\xf0\x99\xf6Mz\x93\xcf\x9b\xf75*\x14\xb0(\ +\xf0\x00\xed\xfcB/\xd3\x1e\xe8\x18G\xf0S\xf2J\xc3\ +\xf72\xed\xa1\xf3ye?\xa0\xff=\x01\x9b\x03\xad\xae\ +l\xe8;\xb0>\xb1\x5c\x1a~J^ix\xd7y\x90\ +\xfb'\xb8~\x856\xb06\xb1T\xe9XJA^\xa5\ +\xcd\xba\xce\x83\x9c\x80O\xf7\xec\x97a\x8f\x80\xdf\xc0O\ +d\xfd*gr\xf2yf\xb6_e\xb3\xae\xf3\xa6\xd6\ +\xcd\x8fZ\xdb\x1ch5\xd6\xbc\x1b/t\xd5e\xde\xb2\ +\x96\xb5\xc0\xf5\x07\xd6AL+l\xde\x0f\x7f\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x01\xf7\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xa9IDATX\x85\xed\ +\x96\xb1J\xc3P\x14\x86\xff\x93d\xb1\x05_@\xd47\ +\xa8`\xa1\x11A|\x03)\x0d*]|\x01]\x04\x11\ +\x97N\x1d\x1cD\x97\xe2\x138YI:\x17\x17A\x0a\ +\x86R\xb0\x8fP;\xb8\xb8(\xd4\xa9\xb9\xc7\xa1&6\ +\xb5\xb7MLk\x86\xf6\x9fn\x92s\xcf\xff\xe5\xdc{\ +\x0f\x17\x98u\xd1\xa8\x8f\xa9*'\x13\x1dQdP\x0e\ +\xc0jD\xaf\x16\x83MGS\x0a\x8d\x1d\xfa\x1c\x0b\x90\ +\xaarr\xa1\xc35\x00k\x11\x8d\x07\xd5\xecj\xb4\xe9\ +B(\xb2\xa8DG\x14\xa7`\x0e\x00kjW\x14\xdd\ +\x07)\xc0w\xd9\xa7\x22\x02\x19\xeeX\x1b\x11\xe7[s\ +;\xa7\x8c\xdc/\xe3\xa4[\x82\x87\xe5\x96V\xe0\xbf4\ +\x07\xf8\xb5\x07\xd2e^\xd1Tl\x03\xec{\x9f\xa9\xf0\ +\x91,\x09\x09\x08\x02\x9a\xcb\x0e\x9e\xee\xf6\xc8\xf93\x80\ +n\xf1\x09\xc0\xe7\xc3\xc0\x88\xb9$\xcdB=\xdc\x17\x0d\ +\x8fi\x93\xf7\x1b\x06\xbd\x06\x05\xf0\x96 S\xe1<\xc0\ +\x17\xc3\xccChK#\xbe\xdd-\xb3\x1a\x1a\x80\x98O\ +#\x18\xfb \xda*6\x82\x06\xf7\xff\xed@\xd7\xe3\xeb\ +\xe0\x9e\x94\x05\xb0\xe4\xcd\xec\xe5\xaa\x85\x05\xf05\x1a;\ +\xa7J7\xdd\xa0t\xcb\x01@\x87\x1e\x80\x12\xfct\xc5\ +~\x0c\xe7\x00s\x80\xd8\x01\xa2t=\xa9\x88\xb9\xa4[\ +B\xde\xba\x81\x96;\x88\xa5\x02\x0c6\xe3\x04h:\x9a\ +R\x88\x03\xa0\xc5\xe0\xab\xfe\x1b1\xd0\xd7~uK\xbc\ +\x03X\x9c\x88\x15\xd3\x81m\xd0M\x90\xd0\x9f\x0a0\xee\ +'b\x0et\x85\x8a\x87\xa0\xc1\x1e\x80P\xe9\x18\xc0[\ +d{\xa6\xb3z\x96\xda\xa1\x01\xeaYj\x0b\x85\xd6\xc1\ +0\x01|\x84\xb5\x05\xf0\x0cP\xde6\xe82\xe4\xdc\x19\ +\xd7\x17\x91\x1d{2b\xe5k\x14\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x02\xca\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02|IDATX\x85\xed\ +\x97Kr\xd3@\x14E\xcfs2\x00\xb6\x10Y-\xcd\ +`\x0bl\x81\x01\x90\x00\x81\x90\x8a\xf3q\x15, U\ +\xac\x81af\x0c \xc4\xf9;!\x14U\xac\x815\xc0\ +\x08\xb7$\x03;\x00\x06\xc4\x8fA\xe4 \xebcI.\ +3\x82\x1eY\xaf\xba\xef9~j[-\xf8\xd7\x87\x0c\ +?X\xfb\xe5\xa6\xca\xe0\x85\xc0U\x94g\x9e\xd7|;\ +M\x90\xb5\xd1<\xc2s\xe0\xa7\xd0xj\xcc\xdc\x87Q\ +\x81 \xfa\x08\x5c\x8f/\x07*\xba\xe4\xbbnw\x1a\xf0\ +^\x18>\x14\x95\x03\xa0\x11\x97>y\xa6y\x83D\x01\ +\x90+\x895\x0dQ9\xec\x85\xe1\xe2_\x80\x83p\xed\ +\x12tYT\xdd\x04\x06\xd3\x94\xe8\x85\xe1b\x06\x0e\x03\ +Q\xd9\xcc\x08x^\xf3LE\x97s$\x0e&\x91\x88\ +\xe1\x87\x198\xb4\x8cqN3\x02\x00\xbe\xeb\x1e\xe5H\ +\xcc\xd4\x95(\xfc\xe6\xd02\xa6\xb9\x9f\x9c+\xe4\x0ck\ +\xa3%\x84\xbdT\xc0\xb9 K\xc68'\xe3\xe0A\xd0\ +\x7f\xa0\xe8!0S\x06/\x14\x98T\xa2\x00\xae\x02+\ +y\xf0\xb1\x02\xb1\xc4c\x84\xdd*\x12A\xd0\xbf\xaf\xe8\ +Q\x1dx\xa9@\x89\xc4\xa3\xe1f\x9a\x14^I\xe0\x02\ +\x10-+t\xf2$\x00\xf2\xe1\xd22\xc6\xd9+\xcb\xae\ +$0Fb\xf8kI\xd6*\xc3k\x09$$v\xc7\ +\xac\xab\x05\x87\xd4\xff@\xd90\xa6\xb9/\xb0\x02h\x01\ +|\xb5\x0e\xbc\xb6\x00\x80*?\xf2\x04\xe4\xa2\xf6\xbdn\ +^-\x01k\xa3\x05\x84\xe3\xbcu\x0a\x0dE\x8f\x83\xa0\ +\x7f\xafNf\xe5=\x10?\xcf\xbb\xc0\xec\x08W\x04T\ +\x939\xe7(\x8b\x9e\xd7<\xab\x92[\xa9\x03EpE\ +\xd6DYe\xf4\x96\xcc t\xad\x8d\x16\xa6\x22`m\ +t\xb7\x08\xee\x1b\xa7c\x8c\xb3\xab\xc8\xda\xa4\x12c\x05\ +b\xf8I\x06.\xba\xee\x1b\xa73,\xf8\xc6\xe9\x14H\ +\x1c\x97I\x14\x0a\x8c\x85\xbb\xeeNz\xbeo\x9c\x8e\x8a\ +\xae\xa7$f\xcb$r7a/\x0c\xef\x88\xcaiU\ +xj\xed\xaa\xa8l\xa7\xb2\x7f\xc5\x1b3s\xd0\xcdt\ +`\x0c|\xa3\x0c\x0e\xe0\xbb\xee\x8e\x8an\x90\xedD\xd7\ +\xdah>=\x7f\xa4\x03\xbd0\xbc-*o\x0a\xe0\xaf\ +\xcb\xe0\xa9\xac5QyEI'\x12\xef\x05\xfd[\x88\ +\xbe\x9b\x06\xfcOf\xb8\x8e\xc8\xcb\xb4\x84\xd0\x987f\ +\xee=\x8c\x1c\x95u+\x0dG\xb5=)\x1c\xc0\xf3\xdc\ +mT\xdb\xa4n\x872\xd8\x1a^\x5c\x0a\xe8\xe8AT\ +Qm{\x9e\xbb=)\xbcD\xe2<# *O\x80\ +\xcf\xc07AZ\xd3\x80'%\xe2\xa7\xe8W\xa0\xc7\x05\ +\xeb\xff\x00\xe07\x93\x02bX\xa29J9\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x00\x89\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00;IDATx\x9c\xed\ +\xd0\x01\x09\x00 \x10\x04\xc1\xd7\xfe!\x15\x83\xf8)\xe4\ +@f\x12,[\x05\x00\x00\x00\x00\x00\x00\xc0\xff\xc6\xda\ +\xe7\xa6#\x92f: \xcd\x80t\x00\x00\x00\x00\x00\x00\ +\x00\x00\xbc\xd7B\xd4\x03\xab\xc4y\xcd\x85\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x00\xd6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x88IDATx\x9c\xed\ +\xd7\xb1\x0d\xc2@\x10\x04\xc0}\x8a@\x14D\x05\x88\x0e\ + qENh\x81\x94\xc4\x0dY4\xf1\xa4\xc8/B\ +\xeb\x91=\x13\xae.\xd8\xbb\xec\x12\x00\x00\x00\x00\x00\xf6\ +\xa3,\x83\xf3\xf5~)5c\x92c\x87>\xab)\xc9\ +\x5c\x93\xdb\xf4|\xbc\xbe\xf3C3\xb8\xc1\xe5\x93\xa4&\ +\xa7$\xe32o\x0e\xb07\xcd\x01j\xc9\x90\xe4\xdd\xa1\ +\xcb\xaaJ2'\x19z\xf7\x00\x00\xfe\x87_\xa0\x19\xdc\ +\xe0\xf2\x89_\xe0'\xbf\x00\x00\x00\x00\x00\x00\x00;\xf1\ +\x01\xd7S\x1e\x0f\x14\xfc\xaf\x10\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00\xf6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xa8IDATx\x9c\xed\ +\xd01\x15\x800\x00\xc4PZS\xf5\x81P|`\x0a\ +\xba\xe2\xe03$\xdbM\x97\x97q \xd6\xf5\xbc\xdf}\ +\x9fs\x08\x8f)N\xffD\x01\xb4\x80\xa6\x00Z@S\ +\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\ +\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00\ +-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\ +\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00-\ +\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\ +\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00-\xa0\ +)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\x9a\ +\x0ddA\x04\x80\xc9\xe4\x92\xad\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x04g\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x19IDATx\x9c\xed\ +\x9bM\x88\x1cE\x18\x86\xdf\xb7g'Y\x91x1\x88\ +0;\xdd\xd3;\x89?W]\xbc\x0a\xc1D\x22\xf8\xc3\ +\x22\xe2A\x10\xfcA\xc1\x93\x22\x01=\xa8\xa0\x01E\xf0\ +\xa0\xe0\x1f\x0a\x1eD\xd1S\x0cbd\x83\x10\xf0\x22\x08\ +\x82\x0718\xcbl\xd7\xf4t0F\x11Eq\xcd\xf4\ +\xd4\xe7a&\xc6\xedj\xcd\x8e\xa9\xaa\xee\xc3<\xb7m\ +\x96z\xbfz\xa6\xba\xbb\xbe\xee\x19`\xce\x9c9s,\ +\xa0T\xfaL\xa2\xd2\x5c\x0d\xd2\x91R\xd9\xd3U\xd7\xb3\ +]hk\xa0D\xa5c\x00\xc1\xf4O\x11\x8d}q\xdc\ +>ak|W\x04\x17\xfe\x97\xed!\x22\xff\x1c\x8b\x0c\ +pT)u\xbd\xad\xf1]aM\x00I]8\xb4K\ +\x10|\xda\xefgW\xdb\xcap\x815\x01\x00\xa4\xe4\xd8\ +\xeeFC\x1f_\xcf\xb2\xb6\xc5\x1c\xab\xd8\x14P\x8a\x00\ +\xed\x85\x5c\xafeY\xb6\xdbu\xd6\xff\xc1\xb9\x80)\xd7\ +\x8cr}\xec\xe4\xc93\xbb<\xe5m\x1b\x97\x02\x8a\xa7\ +\xc4\xca\xe2%\x9bGz\xbd\xdeN\x87\x993\xe3R\x80\ +\x86)a_s\xe7\xe2{\x22\xb2\xe00w&\x5c\x9f\ +\x02\x1a\xe0V\x09\x82U\x95\x0e_\x17\x11k{\x90\x8b\ +\xc1\xc35@4\x8b+Ap\x7f2\x18>\xef>\xfb\ +\xc2x\xb9\x08\x0a\xa0\xa5p2\x108\xa4Tz\xc8G\ +\xfe\x7f\xe1\xeb.\x00\x12\xe3\xe21\x01^H\x92\xf4\x01\ +_5\x94\xe1M\xc0\x04)\xee\x16\x01\xe2\x8d$IW\ +\xfd\xd6q\x1e\xcf\x02(\x10\x14%\x04 \xdeW*\xbb\ +\xc9o-\xe7\xc2}C\x08`H\xd8!\xd0G\xfai\ +z\x83\xefr\xfc\x0b\x98P&\xe1\xd2@\xe3\x93$I\ +\xae\xf5YHU\x02\x00@@C\xc2\xe5`\xe3x\xbf\ +\x7f*\xf2UD\x95\x02\x00\x81\xd0\x5c\x09\xad \x18\xaf\ +\xad\xaf\x7f\x7f\x85\x8f\x12\xaa\x15\x00@\x00\x91\xe2F\x89\ +\xb8j\xa1y\xf6X\xaf\xd7\xbb\xccu~\xe5\x02\x00\x80\ +\xa5}\x03\xafk6\x17\x8fnll,\xba\xcc\xae\x85\ +\x80)\xa6\x04\xe2F\x04\xcd\x0f\x5c6Ou\x12\x00\x94\ +4O\x84\xdc6\x18\xa4o\x15\x9e9Z\xa3n\x02\x00\ +\x88&\xb7\xae\x04\x01\xefU*{\xd1E\x07YC\x01\ +\x80\x88\xd9<\x81\xf2\x98J\xb3'lg\xd5R\x00P\ +\xded3\xa7\xb6\x02&\x98\xcd\ +\x13!\xaf)5\xbc\xd3VB\xcd\x05P\xc4l\x9e(\ +\x90Wl%\xd4\x5c\x00\xfe\xed\xe5\x9d\xb5\xdbbm\x1e\ +N\x961\x9d\xbb\xf1!\x09\xf0\xb6\xad\x8c\x1a\x0b 4\ +\xa4a,\x00\xca#q\x18\xbej+\xa5\xa6\xa7\x00!\ +R2y\x91\xa7:\x16'\x0f\xd4U\x00%`a\xf6\ +\x02\xbc\x1cE\xed\xe7lG\xd5N\x00\x81\x00b\x5c\xfa\ +\xde\xed\x84K\x8f\x92,{\x01{Q\xd4F\xc0\xe4\x13\ +g \xe6u\xff\xe3\x1f\xcf\x9c\xbe\xaf\xe4\xf5\xbb\x15j\ +#`\xd2\xecl\xdd\xeb\x0b\xf0y#\xc0]+++\ +#W\xb9\xf5\x10 \x12\x9c[\x03\x7fC|\xad\xf3\xb3\ +\xb7\xb6\xdb\xed?\x5cFW\x7f\x1b$\x09s\xd9\xaf\xeb\ +|ts\xb7\xdb\xfd\xc5u|\xc5+\x80\x84\xd9\xe7\x9f\ +\x12\x9d\xef_^^>\xed\xa3\x82*W\x00\x01c\xf2\ +?\x13\xfa@'\x8e\x13_ET\xb2\x02\xa6W\xfab\ +\xf6\xef\xa2yK\x14E\xdf\xf8\xac\xc5\xbf\x00\x01i\xe6\ +\x8e4e5\x8e\x97\xbe\xf0]\x8e\xef\x97\xa3\x04\x8dL\ +!x\xcfr\x18\xae\xf9\xade\x82\xef\x97\xa3F\x1e\x81\ +\x87\xa3h\xe9C\xbfu\x9c\xc7\x9b\x00\x114\x8cc\xe0\ +\x93Q\xd4~\xd3W\x0dex\xb9\x0b\xd0\x5c\xf6\x80\xf0\ +\xa5N\xd4\xaa\xfck2\x1eV\x00\x03)47\x04\xdf\ +\x89\xa2\xd6\xe3.\x9a\x9bYq-\xc0\xd8\xdf\x13\xf8(\ +\x0c[\x0f\xd6a\xf2\x80[\x01\x01\x8a[\x5c\xe2\x84\xd6\ +\xf9\xdd$s\x87\xb93\xe1R@\xf1\x91\xc6W\xa3?\ +7o\x8f\xe3x\xd3a\xe6\xcc\xf8\xd9\x0a\x0b\xbe\xcb\xf3\ +\x1d\x07\xf7\xee\x0d\x7f\xf5\x927\x03>n\x83\xc3\xf18\ +\xd8\xbfg\xcf\x95?x\xc8\x9a\x19\x9b\x02\xca\x9e\xe0\xff\ +\x04\x19\x1f\xe8v[\x03\x8b9Vq\xf5\x93\x19\x00\xf8\ +-\xa0\x1c\xect:\xdf\xda\xcap\x81\xa3\x9f\xccP\x08\ +\xde\x11\x86\xe1\x97\xb6\xc6w\x855\x01\x01y\x18\xe0\x18\ +\xc0\x98\xe0\xb3Q\xb4\xf4\x99\xad\xb1\xe7\xcc\x993\xc7\x15\ +\x7f\x01I\x16KQi\x18\xd5R\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x04\xe8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x9aIDATX\x85\xc5\ +\x97\xd9v\xe2F\x10\x86\xbff\x11\x12`P\x9c\xc4\x9e\ +\xf1$9Y\xde\xff\x9dr1\x9eI\x1c\xcf\x18l#\ +\x19$\xa8\x5c\xd4\xdf\xa8\x91qr\x97\xd49\x1c\x89V\ +\xd7\xf6\xd7\xd6\x0dX\x09\x16\xf8\xcf\xc9\x02X\x19\xa4|\ +\x09\xac!X\xf7\x91K \x1a\x96%\xef\x93DJ\x5c\ +\xb3dm\x9b\xac\xed\xf4~\x00\x1ez\xf2\x97\xc0:\xf4\ +\x16\x0e\xc0\x050\x00\xaaDY\x90\x11\x13\xd8\x0d!\x8c\ +\x81q\xcf\xa5\x16\xac\x81\xac\x95\x11Q\xb9\x01\x0d\x90K\ +\xfe#0\x96\xf2\x1b\xe0\xde\x19\ +\xb2\xfbD\xf9\x04\x0f\x91q\x1a\xf7\xe8\xccL\xca\xf4\xcb\ +\xbe\xc2\xa6\x80\xd9\x18x\x07|\x94\x8eA\x0f\x01\xfbN\ +\xff+\x08\x15\xd8\xb5\xbe\xfd\x09\xcc\x1d\x8d\xd5\x0cJ\x5c\ +p\xa8\xcf\x03`s\xa0\xc5\xf3\xa5\xd2\xf3\x80'\xf4\x0e\ +x\xc2\xe3\xff\x0d\xb0\x82\xb0\x19%\xdcc)\xcf\xe5\xdd\ +\x1a\xb8\x92\xc59\x94O\x82q\x02f\x1d\x0f$\x08\xe5\ +\xc0\xb3\x94\x95B8\x03\xee\xf0\xf0d\x10\x9e\x12\x07;\ +(\xdcR\x9b\xc0\xcb\xb5\x18\x83\xa0\x5cHh\xa49\x1e\ +\x86\xb9\xf8\x07\xfa\x1f\xd7\x22m\xc4\xbb\x93\xac\x00\xdb\xf7\ +J\xccc\xee\xc5\x10\xbcsA\x150\xfd\x8c\xc7\xb2\x96\ +\xf5#\xc1VCu\x09\xd3\xb5#u\x8el!\x995\ +0\x95\x03S\xba\xd2\x1bI\xf6\x1c\x0f\xc1\x97\x14\x81\x09\ +\xb4/Im\x16\x8a\xb5\xe1\x96]\xc3t\xe5H\xbdI\ +\xb1\xce\xbf\x17\x8f\x09\x89X\xb6-<6x\xe8\xfa!\ +hJX\xe4x\xd2\xfc%\xc1\x85\ +\xfaA\xeeIg\xb3\xee?\x05\x9e7_as)\xde\ +<\x91\x09,\x9eIB\x15\x0d\xc8\xbc\x8b\x91\x0b\xc6R\ +\x1e\xb4b\x5c\xe1\x89\xf6 Hs=\x83\xa0\x9d\xba\x0c\ +\xa6\xae\x9c\x06f\x0f\xda\xd7\xe2=\xe5\x12\xef1Ch\ +L\xfbc\x1f @P\xd7\x0a\x8f\xde\xb9\x822\xdb\x0c\ +\x82\xfa\xbb5\x126\x06\xee{\xbd\xfd\xca\x8d\x8e|\xb4\ +`{\x7f\x86\x1d\xd83^\x86\x03\xba$?\xa9\x82a\ +R\xdfI\x93\xa9\xd3=\xda\xc7\xbd{c\xe90\xbbK\ +\x1c\x8a\x94NY\xc9\x0cU\xe7l\xc70\x82\xf1!\xf1\ +\x86\xe4\xbdM\x84\x8c\x80\xc6=\xb75\xeaLxF[\ +\xd2\x1fRJ\x1dx5=\x07\xc9s\x7f\x86\xb9O\x87\ +\x9e\xc0>\x9dk\xcf\x96\xbc\xbf\xda\x17\x85\xed\xa0QW\ +\x0b\xd6m\x0e\x06\xf5\xb0g\xc00\x81}\xa5\xdf2\x99\ +'}\x83OFn\xdf\x98\x94\xa1U)\xf5\xac-\xfa\ +u\xdf\xe2\x09\xa7y\x1eb\xdb\xbe\xa6;\x03D\x0a\xaf\ +\xdf\xad\x00;\xee\x8b9`\xcapS\x19\xce4X\xc0\ +K\xb3\x94\xe2\x02o\xb9j6\x96B\xdc\x00\xdfJ\xb8\ +I\xb6\x0e!\x16; 2v\x1f\xf9\xa2\x01;\x08C\ +\x95\xdb\xd6\x0f$4\xfe\xdf\xc03\x7f#!\x9f\xffa\ +\x1a\xee8\x9ev\xd6%,\xef:\x07y\xc0K8\xee\ +\xd9\xc1I\x08\xc6u\xe2\xf5\x165\x0aQ\x05/?\xc9\ +\xf3s\x99~\xb4@\x1e~\x80\xe5S\xb7\xbc*\xa4\x1c\ +7l\xbc\x89_\x06\x09\xe3\x06\xea\xb2c\xa2\xf6\x86\x14\ +\x0f\x1a\xf9->\xdd\xfag\xc1\x94\x22\xd4\x7f\xe0\xed6\ +\xf8\xb3L\x86W6\x931'!\xd8\xfb\xe6\xe2\x19\xec\ +\x86n\xe0\x14\xf8I\xe6w<\x9e{\xa0t\xa4\xeaA\ +\x97\xa0\xf5P\x02\xd5!\x8f{\x7f\xc6\xbb\x9f\x8ew,\ +\xa1\xb8\x95\xccmj\x00n@x\x06\x1b\xd0\xc5|$\ +o\x0e\x106`-\xf0\x0c\xe1\xe5<\x006w\x19\xa0\ +\x83\xebg|\x96l$s\xe5\xf9\xd3E1\x0dA\xe3\ +\x93-te}r\ +1\xf9\xed\xcc\xc5\xe4\xd8\xdb\xf7\x82m +3\x1c\xfe\ +\x81\x7fo2y0\x84qz\xf7\xcbu0n}\xd4\ +\x8ej\xbcg\xec\xc5\xdb\xd0\x0d\xa65\xc9\xd5\xec\x8d\xcb\ +i\xf4\xe2\x98p\xc3\xe4}\xa2\xf7\x09l5;&\x95\ +\x94\x18\xdd\xe5T\x06\xb9\xb0\x18\xf3\x9e\xc3k\xf8\x9f\xaf\ +\xe7\x7f\x03\x88|\xd3;\xed2O\xdf\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\x86\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x008IDATX\x85\xed\ +\xceA\x0d\x00@\x08\x03Ar\xaa\x90\x87!$\x92\x9c\ +\x08x\xce\xfe\xdbL\xc4\xa2\xec\xa9\xec\xa9\xcd\xc7\xdb\x8c\ +/\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\xf8\xacy\x05\x03\xdfV1\xc9\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x01\x98\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01JIDATX\x85\xe5\ +\xd6?J\xc4@\x14\xc7\xf1\xefK\x16\xbd\x81[x\x02\ +\xd7\xca*`\xb7\xf1\x00\x0b\xf1@z\x22!\xd8\x08\xc2\ +n'\xa4^\xff\x9c\xc0B+\x0f\xb0\xe1Y\x84(\xc4\ +\xc4\x99\x97\x9d\x89\x85S\xce<\xf8\xfc\x98y<\x06\xfe\ +\xfb\x92)\xb1\xac\xd49;-\x11^\xab\x22\xb9\x04H\ +&\xc5k\xdd d(\xc7\xed\xfe$\x01\xbep8\x01\ +^\x98\xc9\xaa=\x8b\xfe\x04?\xf0T\x96\xd5J\xde&\ +\x09\xe0\xc2\xa3\x06\xf0\xc1\xa3\x05\xf0\xc5\xa3\x04\xb0\xe0\xc1\ +\x03X\xf1\xa0\x01\xc6\xe0\xc1\x02\xf8\xe2\xe77z\xb4\x13\ +\xbd\x13\xe5\xa3*\x92\x1c\x02\x0c\x22\x0b^\xa3kQ\xce\ +\x80\x83v\x7f6%\x0e\x9c\x0a<&H\xd1\x9e\x8d~\ +\x82=\xf0\x8b\x87B\xde\xf7\x0a\x10\x0a\x1f\x15\xc0\x88o\ +\x80\x05\xf0\x94\x22y\x177\x07\x08\x8d\x9b\x02\xc4\xc0\x01\ +\xd2\x90xV\xea\x5c\xd5\x1f\x07\x8f\x1b\xb0\xe0\xd4\xba\xb6\ +\xe0\xce\x00#\xf1\xe7\x14Y\xf6\xe1\xa6I\x18\x03\xf7\x9e\ +\x84\x91\xf0\x0d\xb0pNB#\xde\xd6\x0d\xe2\xae\xde\x90\ +\x9eb3N*\xf9\xd8\xc6\x94Nqh\xdcyCM\ +\x13^iB\xad\xf7.\x1cU\x91Zo]x\xb7n\ +\x08\xff\x0e\xd0\xacC`\xfb\xebO\xe6\x1a\xd1\xa6\x83\xb7\ +\x83xO\x9d\xcfu\xd9<\xf9d\x00\x88H\xb3\xd1A\xd2\xf8\xc8\xd8\ +\xb9J\xb1Xt\x92\xabW\x06\x00\x0c\xea\x9d\x0c\xc1\x9a\ +\xf0\xd4\xb7\xa7\xcf\xbe\x0d\x07\x1d\xa4g\x06\x5c\xc1\xbc2\ +\x83^H\xe5\x0a/\xd9\x16\xf2\xd5\x00\x00d6O\x8c\ +\xa3\xa9\x5c\xfe\x19\x9b*\x1e\x1b\xc0\x00\xa0\x8d\xcd\xc0\xf4\ +~:[\xc8\xd9R\xf1\xd8\x00\x00\xbd\xa2\x10\xdc\x0e\x04\ +\xc2\xbb\xb6\x04|7\x00\x14R\xf6\x98a\xedX\xf4\xde\ +\x00\xe6\xb0\x1c\xb9j+\xbe7\xff\x9d\x0d\x87c\xc1\x93\ +\x8f\x88\x9em\xd4*\xef\xd9R\xf0x\x05\x98\x93\x07\xe1\ +\xb5\xc6\x5c\xd9\xda\xe4\x01\x7f\x0dP!w\x9e\xe3\xcd\xb9\ +\xca\x11\x07B>A\x00\xb3\x829\xfb\x8f\x1e\xb8w\xdb\ +\xf3\x08\xfb\x01v\x83xV\x03\xb4\x02]]\xf7\x19\xf8\ +\xf2\xc2\x98\x9a,\x95J!\xb7\xc3\x8d\xe3\xcd\x0a\xe0\xde\ +\xb2\x0fN\xfe\x9bKj\xf4\xb1\x1fgfV\x5c\xe9z\ +a\x003\x14\x99\x15\xefg(\xb5\xe7\xbb\xcf\x8f\xb5]\ +jG\xbf\x05\x88\x88\xc0\xc1=\xff\x9b^\xe1\xddK\x0b\ +\xe5\x7f\x5c\xcbG\xbb\x02\x88h\xb5\xe8\xf5\x8d\xe1\xcfX\ +7\x9eZZ\xa8\xfc%\x91Bd\x06\xf4\x1eR\x05&\ +\xcf\xb8\xa0\x98\xd2\xa7\xe6\xa7\x7f\x97\xca#*\x03\x88M\ +\xedK\x0c<\xf2u\xad|F2\x11y\x03\x08\x14\xa2\ +\xbb\x02\xd2\xd9V\xbd\xf2\xbdt:\xd2\x06\x10\xb4\xa1\xc9\ +\x0cz\xb29\xf7aC8\x17\x00\xf2\x06(\xe3\xb0c\ +\x1cj\xd5\xca\x9f\x09\xe7q\x05\xc9c0\x16\x1c \xe6\ +\x97\x1b\xf5\xea\x8c`\x0e\x06R+ \xac\xa7\x7f\xa7Q\ +\xafF\xfeL\xc6\xbd\x01\xa1\xcd\x0d\xcf6k\xd5\x17\xe1\ +\xa0\xb9\x19\x14\xd7\x06\x18\xcd\x0d\x01_\xac\x9c\xbf}\x0a\ +\x1eL\x1ep\xfbP2\xac\xad]\xbe<\xday|y\ +\xb9\xd4q\xa5;(.\x1fJ\x06;\xbb\x9f\xe2\x9b\xdb\ +{\x97gg\xffs\xa5y=H\x15\xc1_\x95\x8eg\ +\x16O\x9c\xf8WHo\xddH\x18p\x96\x95J5N\ +N\xff-\xa0506\xef\x01a?\x5c\x9eg\x8dt\ +\xab6\xf3\x87E\x1d\xab8\xf9df\x95\x8b\x9a)\xd3\ +:Y\xf9\xc5\xa2\x86u\xec}4\x85\xfeW_\xcc \ +~t\xa9^\xfe\xc1V|WX\xfcj\x8c\x8f\x82\xd0\ +\x05\xb8\x0b\xe0\x8d\xe6\x5cu\xc9V\xec!C\x86\x0cq\ +\xc5\xff\x03\xa12\xbd)\x9d\x1e\xd2\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x01\x06\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xb8IDATx\x9c\xed\ +\xd9\xc1\x0d\x83P\x10\xc4\xd0\x0d\xa2$z\xe2F1\xdc\ +\xe8)=\x912^\xa4o7\xb0\x965\xb7\x9d\x81\x1c\ +\xe7\xfd\x1e\xe7\xfdJ\x87M\x1e\xff\x07\x0a\xa0\x054\x05\ +\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00\ +-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\ +\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00-\ +\xa0Y>\xc0G\x1e\xd7\xaf\xf1\x99\x160\xbb\x16\x98\x99\ +\xf9>\x17[\xe2\xf2\x0b(\x80\x16\xd0\x14@\x0bh\x0a\ +\xa0\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00\ +Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\ +\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80f\xf9\x00\ +?\xfa\xaa\x08\xd8\xe7j,\xe4\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00\x8c\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00>IDATX\x85\xed\ +\xd3\xb1\x11\x00\x10\x00\x04\xc1\xa32\x89\x0a\xb4\xa0,-\ +h\xc0\x98\xd1\x9aH*$\xb9\x8d>\xbb\xe8A\x92\xf4\ +Y8#\x97\xba\x80\xf4(:Go\x19 \xbe\x08J\ +7\xbe@\x92\xa4\xef6\xf1)\x0a\x07{\xbei\xcc\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x0d\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xbfIDATX\x85\xed\ +\x94\xb1jTA\x14\x86\xbf\x7f6J\x90\xe0j\x13\x8b\ +\x8d\x91\x04\xadc\x91JI-bJ\x1bQ\xf0\x01D\ +}\x05}\x04\x83\x0f (\xd8X((b\xba\x80y\ +\x00a\xfb\xdd\xd9\xd9\x15\x02)\xacl\xc2\x9d\xdf\xe2\xee\ +&1\xbb\x01\xf7\xbabs\xbf\xe22p\xee\x9c\xff\x9b\ +s\x87\x0b5555\xff\x19U\xdd\x98Rj\x15\xe6\ +\x13f-\xc8\xad\xe5\xe5\xe5\xefU\xfa\x84\x8a\xe1\xd7\x8a\ +\xac\xaf\x985\x80\xec\xb0\x9bR\xbaZ\xa5\xd7\xd4\x13\xe8\ +t\xfa\xd7\x15\xfc\x05X\x04\x1fk\xa3\xbd\x5cpku\ +u\xe9\xdb4\xfd\xa6\x9a@\xaf\xd7\xdbP\xf0\x0e\xb0(\ +0\xa8\x00\x15\xe5\xda\x97B\xc3;\xbd^o\xe3\x9f\x08\ +\xc4\xd8\xdf\xcc\xd66p\x1e\xb0!\x8fj\xc3\xb5\x81f\ +\xb6\xb6\xbb\xdd\xfe\x9d\x99\x0a\xc4\x98\x1e\x18\xbf\x07\xe6\xcb\ +\xec\xa3\xf0c\xe4am\x1e\xf9C\xb7\x9b\xee\xcfD \ +\xc6\xf4\xc4\xf0\x1ah\xb8\x1c\xfb\xa4\xf0!\xca\x18\x03\x0d\ +\xc4\x9b\x18\xd3\xe3\xca\x02\xb6\xd5\x89\xe9\xb9\xe1\xc5\xa8\xb9\ +&\x9f\xfc\x84\x03\x19\x95\x92\x86\xadNL\xcfl\x9fz\ +\xd9'\x16l\x87\x98\xfa[\x98G\xb6\x09R\xf6\xd1\x95\ +\xffC$;\x07I ^^\xb9\xbc\xf4T\x1a\x9f\xde\ +\x98@\xbb\xdd>\xbb\xb0\xd0|\x85\xb87\xd4\xc9\xa0)\ +\xc3\x0f\x8f\x22P9e\xf3v\x7f\x7f\xef\xe1\xfa\xfa\xfa\ +\xc1\xa9\x02\x83\xc1\xe0\xdcA\x91\xdfan\x97{\xc8\x9a\ +\xfa\xe4'\x14@\xc2\x01\x04\xe2\xf3\x99F\xb8\xdbj\xb5\ +~\x8e\x09\xc4\x18/\x9a\xf0\x11\xb8Q^fe\xf4w\ +\xe1\xc7,\x04\x0eH\x80w\x9d\x8b\xcd\x95\x95\x95\x1f\x00\ +s\xa3w\xb2CG\xa2Yj\x09*\xfe\xa6'\xa2\xc3\ +\x07\xa0\x9b\x0as]\xe0\xc2\xef!U?s\x05<\xa3\ +\xc1\xd6\xd4\xd4\xd4\xcc\x84_0}\xb9\x9bK\x8f\xb2\x18\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04\x83\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x045IDATx\x9c\xed\ +\x9bK\x88\x1cU\x14\x86\xbfS\xdd\x931$A\x88\xf1\ +\x85\xa8+Q\x5c\x08C\xb7\x11\x11d\x14\x8d\x061\xf8\ +\x00]\x89N0\xd3\x1d\x92\x9ev@\x11|\xd06\x89\ +\x98\x80\xf8\xe86\xa6{\x0c\x18\x17\x06u\x15\x064:\ +\xbaH@\x90\xcct\xe2\x03q!\x88\xb8\xd0\xa8\x84(\ +\x9a\x09ff\xba~\x17m\xa0\xaa\x18\x83\xd1z\x5cL\ +\xff\xcb\xff@\xdds\xbf:}\xef=U\xd5\xd0W_\ +}\x9d\xcd\xb2\xac\x13\xf8\xa7*\x8e6kfzJ`\ +H[;\x13\xd5g\xe2\xb8\xae\x17\xc7E\x92Va\xf4\ +\xe5\x9b0j\x82<\x90\xc3\xec\xe9\xb8\xae\xed<\x80\xd5\ +\xa5f\xd1\xcc&A\xc1j\x8d-o\xa7\x01\x14F\x9b\ +W\xf9h\x1f\xb0<\xe8\x0b\xfc\xb8\xc6p\x16@a\xf4\ +\xa5\xcb\xcc4\x05\xac\x8a\xc6\x0c\x14\xd78\xf9\xb8.\x14\ +\xa7\x86F\x1a\xe7\x9b1\x05\x5c\x9a\xf4X\xceU\xc0\x0d\ +\xeb\xb7\xaf\xc8-\xe1=\xe0\xca4\xc6s\x0a\xc0\xf0C\ +\xaf\x9f37\xb0t/P\x0c\xfa\x8a\xb1\xe4\xa3r\x06\ +\xc0p\xad\x96\xff}\xf0\xf8\x1e\xc1\xcd\x91\x90,\xc6E\ +/*G\x00\xc8\x8e\x1f9\xafm\xe8\xee\xb0o\x22\xc1\ +\xc9\x83#\x00\x8a\xa5\xe6v\x8c\xf5AO\x98@\x89N\ +\x1e\x1c\x00P(5\x1e\x07\x1e\x8b\xfa\x96\xc2\xe4!c\ +\x00\xd7\x96\x1b\x1b\x0c\xb6-\x12\xea\xa6\x95Cf\x00\x8a\ +\xe5\xe6\xbd\x12\xad\xa8\xaf\x94\xee\xfc)e\x02\xa0\xb8\xa1\ +q\x0b\xd2\x9eE\xc6\xf7\xad\xb7\xf0\xa5\xa6\xd4\x01\x14\xcb\ +\x8d\xd5x\xec\x05\x96\x04}\x19>\x09\xee\xf7\x7f\xa7T\ +\x01\x5cWj\x5c\x8d\xd8\x07,\x8b\x84|S\xfa\x93\x87\ +\x14\x01\x0cmz\xe5\xf2\x05l\x0aX\x19\xf4\xff\xea\xec\ +2\x99<\xa4\x04\xe0\x9a\xf2\xce\x0b\xbc\x05\xffCC\x97\ +\x04}\x81\x1fgg\xf7o\x94x7X\x18m\x9fk\ +:\xf9>pE\xd0W\xef\x88\x9b\xe9\xe4!\xe1\x0a\xb8\ +~\xfc\x85\xa5fs\x93\xc0P( K\xf4|\x7f&\ +J\x0c\xc0p\xad\x96\x9f\x9f\xcd\xbf\x05\xba1\xe8\xabw\ +\xcaub\xf2\x90\x14\x80Z\xcd\x9b\xfdi\xd5.\x8cu\ +A[\xb8s\xe7O)\x01\x00\xb2\xe2\x91\x95\xcfKz\ +0\xec\xbb7yH`\x11,\x96\x1bO \x1b\x0f\x99\ +\x12\x98{\x93\x87\x98+\xa0Pj\x96\x91m\x0d\x99\x02\ +3K\xad\xb99S\xc5\x06\xa0Xjl3\xb43\xea\ +\xcb\xf03\xdf\xebN\xa3\xf8* \xf2@\x03z\x9d\x9d\ +\x0b{\xfd\xe9\x14\x1f\x00\xa5\xd7\xc3\xc7\xa9\xd8\x00\x98\xa9\ +J\xe4n\x1b\xe6\xb9\xfe\xfa56\x003\xad\xea;H\ +\x95\xa8/\x91s\x19B\xac\xbb@g\xa2\xba\xc3\xa0\x16\ +\xf4\x0c@\xca\xb9\xfa&>\xf6\x83\xd0L\xbb\xb2\x05\xac\ +\x19v\x0dP\xe6\x0f`\x17S\x02I\x99:\x17\x1d}\ +D\xf0f4\x90\xccx\xffM\xc9$T\xaf\xfbhp\ +\x04x7\x121\xe4\x16\x84\xc4\x9294Q\x9a\x97\x06\ +\xef\x03>\x0e\x05\x0c\x03s\x06B\xa2\x89\x1c\x9a(\x9d\ +X8\xd9\xbdS\xf0y8\x22g~\x0e\x89'\xf1\xd9\ +\xee\xf1_\xbd\x5c\xeev\xe0\x9bH\xc8z\xd5\x90\xadR\ +\xb9\x0b3\xafn\xfa\xd1\xeb\xda\xad\x88\x1fB\x01\xe1)\ +c\x08\xa9\x95\xe1\xf4\xae\xca\xb7x\xba\x0d\xf8%\xe8\x9b\ +\xf0z\x8f\x0a\xb2Q\xaa\xbf\xc3N\xab\xfa\xa5\x87w\x07\ +p\x22\x14\x90y\x22\x1b\x08\xa9/D\xd3\xed\xcd\x9f\xf8\ +f\xf7\x00\xf3A\xdf0O\x19TB&+\xf1\xe1V\ +\xe5\x03\xc3\x1e \xda<\xc9<\xa5|f\xcel+\x9a\ +iW\xde\xc6\xd8\x18\xf5Mxi\x12\xc8t/\xee\xb4\ +\xc6\xda\x88'C\xa6\x81\xa4\x5cZ9d~\x18\xe9L\ +T\x9eCz1d\x9a\xa1\x94N\x8b\x99\x03\x00S\xe7\ +\xe2c\x8f\x9a\xd9\x1b!\x17\xa5\xd278\x00\x00\xa8\xd7\ +\xfde\x17\x1e}\x181\x19\xf2-\xf9\x0e\xd2\x0d\x00\xc0\ +\xfez}a\xf9\xdc\x8a\xfb1\x0eDB\xa6\x04\xf3t\ +\x06\x00\xc0\xfe\xdd#\x7f\xe4\x06X\x07\x1c\x0e\xfa\x96\xe0\ +\xd6\xe8\x14\x00\x80\x83\xcd\xb1\xdf\xe6l`-\xf0u\x1a\ +\xe39\x07\x00\xe0\x8b\xd6\xc6\x9f\xbbyo\x8d\xb0\xef\x93\ +\x1e\xcbI\x00\x00\x9f\xee\xd8\xfc]\x1e\xad\x01\x8eEc\ +q\x9e\x16\x9d\x05\x00p\xb0=\xf6\x15\xc6Z`6\xe8\ +\xdb\xd9\xf2\x97\x19\x80Nkl\x1a\x9f\xbb\x14\xf8~0\ +\xce\x8f)\x9d\x07\x00\xd0ym\xec#\xd0\x16\xb0\xae\x89\ +.\xe6=\x9buN}\xf5\xd5\xd7\xffC\x7f\x02\x97v\ +>\x83b\x89\x8e\x83\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x02\x8a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\xeb\xdb\xfa\xbe\x1d\x8f\xa3\x0a4\x81\x8a\xef?\xf74\ +T\xfd\xf7%p\x04\x97\xa7P9\xf2mS\xa8 \x9d\ +\x9f\xff\xc4\xff\x9f\xf2m\x0eh\x01\xa7\xbe})\xe8{\ +\x01\xeeq1o\x85R\x92-\x90\x09\x90\x8f@V\x8d\ +1k \x0bF\xfb\x06\xc8\xbc\xff=\x05r\x0f\xe4\xae\ +\xff\xcc\x80\xdc\x01\x19\xb2#\xa4\xee\xc7,\xa8\xe0\xe5\xae\ +\xc71\xe1\xfb\xe7@6\xf3GU\x9a\x05\xed\x1b \xbf\ +\x06)_\xf3\x88\xcb\x04\xc8\x9f\xf5\xc1\x5c\xdf6H\xc5\ +h\x7f\xdb?\xb7\xe2'[\x8e\xf0\xdd\x1bsr<\xe3\ +%\xff\xdbyF\xb6\xa0uK\xdb\xe5-\x83\xd92\xc8\ +O\x8c\xf6\x09\x90?\xda\xbc\x14\x13\xf0\x91\x7f0\x92\x9a\ +\xac\x170\x7f\xc7\x7f\xb6\xed\x15\x96\xedkLN`\xa2\ +\xe2\xf6Y\x15N{I\xe7\xcb\xf5\x97\xb3\xcf\xa5\xbb\xb9\ +\x02\xf2\xabq'\xdf\x1el\xfbPc\xca\x14\xc8mc\ +\xfc*\xc8\x07\xba}M|\xf3^y^\x13dV\xb7\ +\xbc\xd97\x07\xf2\x00d\xd1\xe8k\xfag#\xcb&\x9b\ +\xfa\xc9\x82q&\xe4\x17\xe0>\x0d\xfe'\xca\xa3\x07\xec\ +\x01!\xa3\xabpy\x0b*_\x0e\xe1d\x0dxZ\xd0\ +\x97\xda\xe1\x1b<\x0b\xf0\x00\xbaO\xa0\xf6*h\xeb(\ +]\x94\xc9)\xbc\x987\x980\x90\xc6\xc44P\xe6\x1f\ +\xa0Z\xbd\xed\xc7l\x01/T\xa1\x0f\x05\xf1\xc4,\xf9\ +\xff\x89\xe9J4x\xd8F\xd0\xf6\xc2\xa0%\x86\x17 \ +\x822\xbc\xe7\x9f]\x02~\x06|\x0e\xcc\xa0\x16\x22\x81\ +\x9c\xd9\x8c\x04 \x0d\xd4\xcc$\xff7\x806\xb8]?\ +Q\x055]\x9b\xc0\xd7\xe0\xae\xf4|\xb9\x13r \xce\ +\x8f\x9bB}\x81oG\x98\x9f\xf8\xd9E`\x1a5\xa9\ +{\xf6\xb3\xd2\x86\xfa\x0b\xd4\x9fX\x01~\x00\x16\x80\xcf\ +\x80\xe7\x80\xb7<\xec\xf8\xe7{\xaa\xdb\xdcU\xd1\xc4[\ +\x03\xf3&[Y\xcd)\x1b^\x0f|\x1c)F\xcbL\ +.\xa1\xa6rF?7\x05Y\xf5\xcax=kU\xd2\ +\xfe\x99\x81~\x91\x09\x90\xdfx+\x11\xb6\x07\x8aQ\xee\ +\xaa\x8e\x18@\xc9\x98\xb5\xaf\x13\xb2\x0b\xae\x17\x8d]\x03\ +\xfe\x0e\xdc\x09\x84\x10\xac\xccaS\x19\xe7\x10\xdcS\xdf\ +7\xe6\xaa\x9b\xe0\x9fuO\x80\x03\xc5}\xd8\xcc\xf7\x8b\ +\x03\xd6\x81\xbf\x01\xf7\xb2s\xba\x9e\xf2\x22\xeb\x18G\xc0\ +\x12\xc0\x14p\x161\x0fz\xe6\xbf\xf3[\xe91Y!\ +\xa0\x1a\xb9\xd9W\xc6\xdd\xe5\xf8<\x8e\x0b\xeeRq7\ +\xfb\xd1n\x08=\xbc\x1e\xf0\x04=z\xe1\x90\x1e\xea)\ +N\xc7X-%8\xe7W/\x00\xd9F\x95L)0\ +w\x07\xc0}\xe0\xd2\x9b\xabW\xe8\xee\x09M\x9e\x9f\xd0\ +\xdc\x04%\xe8\xfa\xe3V;\xc4\xf6\xf7\xa7\x81.Hx\ +f\xfb:V\xee\x03G\xe8\xca\x7f\xadc\x05\xa0\x03\x9d\ +\x13\xa8/\x92\xd1g\xee\x08\xe4\xa7\xf1\x04cX\x01y\ +\x0b.*P\x9dF\x15\xd3)\x83\xad\xbd\x0b\xfc\x0e\xf8\ +K\x01\x03\x01t\xe6\xa1\x9e\x04?>N\xa8\x1d\xf9\xce\ +y\xd4R\xf8\x1d\xd59\x87\xfa\xe1\x10d]\xd4<\xfe\ +\x06\xf8$\xa0\xd9+\xcfz\x0d\xb8\x0dr\x1e-fn\ +%b\x01\xc4\xd1\xe1]`\x1a&\x1f\xaa\x12t\xfb\xd9\ +\xe1\xb2\x0e\xfc\x03\x0dp\x8c C\x80\xeem\xa8M@\ +\xfd%\xb8N\x01CG\xd9\xbfR\x07\x16\xe0\xa2\x06\xd5\ +\x93\xbc\xd6N}\x93\xbf\x02k\xe0\xf6\x82\xce6\xc8\x09\ +\xbac\xdf\xf6\x9ekB[\x9f\xe8\xd8\xc7:\xa0\x0a\x9c\ +\xfb\x09\xee\xa1\xab\xf2\x85M\xb3,\xa1\xdb\xbe\x87\xad\x13\ +\xa6\x81U\xa8\xb5U\x89\x152o\x80\xeb\xe83\xd5\xb6\ +2\x18\x1e\xab0\xaa\xa3\x87\xfa\x02+\x05\x88\xbe\xf1c\ +\xee\xf9\xe7:d\x1d\xb9\x22+\xc0\x06\xf0\x0c\xf5\x01\x8c\ +\x03|\xd8\x04\xba\xe0\xba\x9e\xe0H1\x1e\xcdC\xbb\x86\ +\xae\xc2\xf9X<\xdbp\x01<\x85\xf6$\x1c/`\x87\ +\xb4]\xe0L\xe7\x8c\xc1\x9d\xa1\x8b\xfa\x83\xe7)\xc7\x8b\ +%\x80\x06\xea=-\xe6\xb7|\x02\xcd)p\xadl[\ +\x22\x84\xcb\xf7a\xae\x07\xb3\xaf\xccGo\x04\xb3\xaf`\ +\xf6Rq[G\xcd\xb5`\xae \x16a\x075\xdf-\ +\xd4\xc2e\xc0\x12\xc04\xaa=\x0b\x94\x9a,\xa3n\xaa\ +\x01\xc7M\xa8|\x0f\xcc3~\xec=\x06\x88\x03\x16\xa0\ +\xf2\x9d\xcea\xc2s\xdbYr\x97@\x19\xdc1\xba\xb8\ +\x19\xb0\x04 \xa8i\xd9) d\xc2\xb6\xf32\x05\xa5\ +d\x22\x7f\x1c\xac`\xeb\xda\x10n\xfb\x16\x94J^\xbf\ +\xc4\xc3\xae\x946\xb1x:\xd4#4\xda\x0a\x94\x07\x83\ +L\xbf}\x13\xd5\xb2\xe1*\xcc\x82t\x81\x15\x98\xd9\x0f\ +\xfaZ\xc0\xbb\xc0\x13\xd2\x8cN\x06\x92\xd4\x19\xa8Oa\ +\xe5\x05\xe7\xd0@\xe7\x07\xfd-\xa0;s\x03\xe4\x19\x03\ +?#\xc1\x7f\xa6}\x1cd\xd1\xb8c\xef\x0e'\x81Y\ +\x0a1a5rIH\x99G\x83\x8deOd\x84\x9c\ +\x1etf\xa1~\x00\xc4A\xc6#O\xd0\xd7\xc1\xe4+\ +@\x1f:gP\xdf\x05\x1ctoA-\xc9/>\xf3\ +\xdf\xce\xcf\xf9\x05\x9a+\x0c\xe1\x15tf\xa0\x9e\x08-\ +\x9c\xb7\x89*\xbe\xbe\xee\x86TW%y\xcbL\xc2\xc6\ +Z\x99E\xe0K\x90\xaa'\xe0%\xb8C4\xd3s\x96\ +\x8f\xfc\xa4\x01\xf52\xb8\xe7yT\x82g~\x018F\ +W\xec\x1bcw\xb5\xfd\xf82\xba\xe2\x07\x9e\x8e\xffh\ +_.z;\xf1\xa6\xcfg\x7fC\x9ad\x1f\x15\x98\x17\ +\x9al\x02O\xe0\xa4\x03\x8d)\xb2\xe1\xb1\xa9\x03J\xa8\ +\x04o\x83\xdb\x09\xec\xf7-l\xe57\x0dG\x05ih\ +\xa5\x00\xcd\xf4n\x01O\x87\x87\xc4\xa9/\x7f\x1f\x0dg\ +\x87\x05R'\x18\xbe\xbd_\x08\x9f\xb9r'\xa8\xb7\xba\ +\x01\x8d\x03\xf4He\xa0H\x09.\xe5\xe3\x01( \xbe\ +\x01\xf3GF{\x02e%\xb4\xf2\x90\x9c\xb3\x94\x9b:\ +Qx\x9fa\xdf?\x84\xb4\x14\x08 7N|j|\ +\xcd\xea\xb5\x04\xb0\x00X\xf6\xdf\xba\x84\x18\x07V\x18$\ +4\x0c\x8f1\x81\x9c\x93\xf3\x12.\x8c\xd4{\x06\x8a\x84\ +i\xd1\xfa\x0aC`\x05G\xe0Z\xe1\xec(\xc1\xf4\x07\ +;\xa70\x946<<\xd7\x85\xea\xa8|\xdb5r\x0d\ +\xee\x0cU\xe6\x19\x88\x050AqTw\x13\x9b^\x83\ +nd\xdeb!\x0c\xbd\xb1\xb9\xa9\x1fQ\xf4\x5c\xae=\ +\xb6\x02\xcbpei\xf3\xc0?\xc8\xb4\x97\xec\xf6\x14\x9a\ +P{f\xd0! \x8f\xd1$\x0b\xc0\xa3\x02\xfd2b\ +\x85\xbb}\x8d4s\xd0\xc3\xce\xd6\x8e\x8a\x05z\x15\x98\ +\xb8\xce\xf6O\xecu\x11\xf4G\xf4\xbf&\xd4\x1c\xc5G\ +p\xacy#\x01\x94\x9f\xa1\xf67\xc6\xd5\xb3\x11\x8e\xcc\ +\xf2\x1e\x90\x9a\xa4\x10\xd2m\xff\xc8\x7fFX\x87B(\ +\x12@\x19\xdb\xb3\xcc\xcd\x11\xeb\x80.Q\xbc\x1c@\x11\ +\xb3\xc3\x08\xbf\xca\xcf\x11\x9f\xf9Q\xd6a(\x14\x8d\x1f\ +[9\xc6\x02Hr\xe79my\x03\x22\x12\xe8\x93\xde\ +'\x16)\x83\x9d\xf3Ib\x01t|\xdb2z\x1e\xd1\ +\x0b\x05\x8e<\xbd\x02\xecg\xb7\xb1\xa0\xb9CY\xcf\xe6\ +\x10\xd3s\xf7Op\xed`\x8e\x82<\xa3\x05\x02\x9a8\ +\xd9\x8d\xe6\x5c\xd3`-a<\x09\x87\xc5\xa1\xbb\xfa8\ +\xdb\x0e\x0c\x0a\xb62\xd9\xe9\xf8\x08\x84W\xd7\x16\xec\xa1\ +\xc1\x8d\x05\xcf\xc8\x14V\xe0oe_\xfbn0\xb6\x0e\ ++\x14\xe6$\x93\xc0\xcb\x84\xe4:>\xa38\x8b\x94\xe0\ +\x85m\x0a]_\x89\xb2\xeam\xdc\x15\xd0\xf2g0\xc9\ +\xdb\xbf\x0e\xf3\x09\x04Bh\xddF\x13$VN\xb2\x1c\ +\xd0\x18\xf7-\xa3\xd6h,%\xd8F\xed\xa5\x19?\xfb\ +mnd_\x018\x83\xc62\x9c\x9c\x8d\xe1%^\x03\ +\x9c(\xce\x99\x15\x06ew1,S|\xbc\x92\x1a\x85\ +\x9cY\xb5\x04p\x86*\x97rA\x86\x158\xee\x90\xbb\ +\xf7O\xb7\xfdW\xd08\xd3s\xfac\x81\xac*N\xbe\ +\xc2\xf4\x18\xa5\x01\xad\xae-t\x99\x83\xb3.\xcaSN\ +xE\xf9\x80\xc4f\xbem\x13\xd4\xab8\ +\x92\xeaO\xd3m\x9e\x04fa.N\xd6&\xb0\x02S\ +\xd3\x01O\x19\x88\x05pA\x9a4p\xdet\xc9\xba\x8d\ +\xd7\xed+rJ\xd8\xee\xed\x15\xb0\x07\xf5KU\x5c\xb2\ +8\x9e\xaf/\xce\x8f]\x81I\x8f#<\xf3\xa1\x10(\ +\x01\xabv\xfa\x0e\xd44_T\xc0}\xeb\x1b\xeaDV\ + 6\x83\xf1\x95\xd3'h9\x1a\xc02Z'\xd4\x0f\ +\xc6]\x02\xbfE\xaf\xc7\x97\x0d\x9d\x97\xa4\xa0N\xd1\xf8\ +\xfc=/\x84a\x89\x0f!\xad5\xa0\x81\xba\xd1VM\ +\xcf%\xf0{\xe0S\x06\x97\xa3\x89\x19L\xcak'\xf5\ +f;\x85\x12\xc3\xddg\xd9B\x0b\x0f\xc2\xb6\x86\xf7\x08\ +7\xa2\xf6\xa4\x0eo\xcd\x7f\x1bVC\x1a\xdc\xa8F0\ +}~\x05\xf3RE\xaah\x09\xed\x1c\xc8\xbb\xb6N\x90\ +\xf7\xf3\xd6J>d\x8c\x1a\xa1C\x90 #\xebN\xe0\ +\xa4\xab\xf5\x80)\xa2\xf0\x8a\xba\x0f\xee\x11\xea%\xbe\x06\ +\xb3\xe3\x82\xcc\xa0)\xfb\xef\xd1\xcc\xcf\x0ey\xc5\xb8\x81\ +\xa6\xe0\xc3\x0b\x9e\xe4n\x22\x03\x96\x00\xba@\x95LI\ +\xec\xcc\x0b\xa8Lz\xc9\x16\x85\xb4\xfb\xd0\xaa\xaa\xce\xb8\ +V]\xee\x98 e\xc5\xdd\xaa\x90\xaf\xfa\x08\x14c{\ +\x11\xba\x1d2\x1a_*\xa8n\xcb\xd5(X\xb1@\x09\ +\xdc\x9enyy\x16(\xa0\xa7\xa8F\xee\x01\xff\x0d\x98\ +\x0f$?w\xe0\x05\x94\x84\xbf\xa1\x0b|\x13H\xbc\xbf\ +U\x94\xd1\xa70'Q\xbf\x049\xc6\xfb\xd0h\x91\xb9\ +\xbe\x93\x8a\xd2\xe3v@\xee\x1a\xccf\xe0%i.\xc0\ +\xed\xa2u6\xc9\xd6\x17T\xf1T\xc8f\x8d\x22\x1cN\ +T\x80\xec\xa3\xb5?\xf7\xc6\x08\x97\x0dh\xddF\x9d\x9b\ +%\xe0\xb9\xee\xb0\x9c\x9d\x9f&]\xd5\xe3&\xba\xeae\ +Tyv\xd0\xda\xe6%e\x1e\xd0\xcb\xd8\x8c3\x14\xed\ +\x00w\x9a\x0dW\xdd\x1eZ\xc3\xbf\x81Ff\x9f\xa3B\ +x\x00\xe7'P=R\x22\x0b\xcd[_\xe7h$\x15\ +\x9bI\x1b\x80\x83\x0b\xbf\xbb\xaa\xc9\x0b\x14!\x1c{f\ +\xbc\xa93\x1d\xcbe\xc5/K\x1eo\x12#|\x00<\ +\x04\x0e\xc0\xbd\x0c\xc6\x97\xe3{F\xeb\x08\xc4\xcct=\ +!\x0f\xd1\x82E\xd0+\xefe\xdf\xbe\x1f\xb4\x1b b\ +\xf7\x8b\x83\xea\xa4g\xb0S\xe0\xc5\xad\x8f\xc0}\x05L\ +\xc1\xd1\xf7\xd9\xeb9q\x9e\xb6\xf8\xcc\x8f\x93B\x93;\ +\x03\xe7'S._\xcfZ\x07\xf0f\xe8}\xecDI\ +2\xe6\xffP.\x0f\xba\x00\xf2\xf3\xbc\xf9\x95\xa6Z\x8a\ +\x5c\xb9\xfc\x1d\xcc\xb2^\x1b\xf9\xc7\xd8/L\xac\x92{\ +aB\x1c\xfa\x82\x85\xf1\x02C:f{\xcc\x89C\x9c\ +\x05\xcf\x88C\xdf\x18\xf9\xa5\xd1W\xce\xfa+\xa9\x10\xaa\ +\x8c\xff\xc2D\x8a\xe8O\x05N\xc8F^\x08\x00\xf2\x1e\ +\xfa\xcaJ\xee\xa5\x04^\xeb\x95\x99\xb4\xad\xe4\x9d\x9f\xb7\ +@\xde1\x9c\x9f\xb2\xa5\xe5=\xf3\x7f\xc8\xe3+\x9e<\ +\x91ZY\xa5\x16{\x80\xe0w\x82q}-\x1b~k\ +\xde\xd3O+t\x9e*\x8c~ij\xca\x8f\x09\x04/\ ++\x0c^\xbe*z9j\x1e3f\x91-\xcfC)\ +\xbf\x9b\x15bD\x86\x93#\x9b\xa8\xb6\xf55\xba\xb4\xfc\ +\xef\x1aj\xe6\x1cz\x01r\xc1\xe0\xb5\xb9\x19@\xa07\ +\x0d\xe5\xc4)JJd{\xc1\xff\xe4\xf6&ym.\ +(\x97M\xe9\xeb\xfaq\x0e5a\xa7\xfe\xf7$\xaa\xc4\ +}\x01\x06\x1dT\xa1\xce\x06x\xf6\x06N\x93\xed\xc0\x8d\ +\xb8\xa2\x8eA&0J\xcd<\x9e:y-\x1b\xbf8\ +YB\xaf\xca\x92#Te\xe0_\xe0\x998$k\xf3\ +\xac\x17'\x85A\xe23\x06\xa3\xb46}\xac\x88\xc77\ +\xf7\xd5Y\xab\xe1\x0d\x80\x0c\xcfo\x1a\xf3\x09\xa8\x10\xfe\ +\x07\xb4\x0a\xfd~\xcf\x22[\xc2\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00\x87\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x009IDATX\x85\xed\ +\xcd\xa1\x15\x00\x10\x00\x00\xd1c)U1\x80EM\xe0\ +=\xd9R\x9e\xa4\x8a\x8a\xfb\xe9\xda\x81$I\xbf\x0b'\ +R[\x03\xc8\x8f\xae}\xd6X\x00\xe2\x93\xa1$I\xd2\ +\xc5\x06e\xbc\x05\x04\xc99\x8e\xf8\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\x98\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00JIDATX\x85\xed\ +\xceI\x0d\x001\x0c\x04\xc1\x5c\x90\x0c\xca,6\x14L\ +%\xfcr\x80\x98\x95\xfc\xe9\xfa\xcf\xa8K\x11\x98\xc74\ +\x8f\xa9|4e\xfc\x07\x02\x08 \x80\x00\x02\x08H\x0f\ +\x18\xf2\xc3\xad\x9fy\xe4\x04\xdc\xd3Wm[\xb9\x00\x00\ +\x00\xf9\x1e\xf2#\x09\xddd\x85\x0e\x0a\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x03\xa2\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03TIDATx\x9c\xed\ +\x9b\xbdOSQ\x18\x87\x9f\xb7\x85X\x07\x8d\x9d\x18$\ +:\xcb\xa0$\x926n\x98(\x0c\x1a\x91&\xc8 \x09\ +\xff\x81qS\x18$\x9a\xf8\x11'?\xfe\x02\x12\x171\ +\x82\x18\x1dD\x13\x9c4%\x98\xa0\x03\xce\x12\x1cp\xb0\ +\xc4\xc5\x1a\xa4\xaf\x83\x17s\xef\xed\xad\xd2\x9e{{@\ +\xce\xb3\x9d\xf7\x9e\x9e\xfe\xde\xdf=_i\xcf\x01\x87\xc3\ +\xb1\x93\x91\xcdT\xea\x9e\xd5\x96r\x893\x15*\x83\x82\ +t)\xec\x17\xd8\x95\xb4\xb8zP\xf8!\xf0Y\xd1\xf9\ +\x14\xa9\x87\x99,O_\x1f\x97\x9f\xff\xfa\xdc?\x0d\xc8\ +O\xeaI\xd0\xbb\xc0\xa1X\x946\x8fE\x90\x8b\xc5\x82\ +\xbc\xfc[\xa5T\xcd'\xaa\x92{\xac\xa3\xa03l\xbf\ +\xe4\x01:@g\xf2S:\x82j\xcd\x17]\xd3\x80\xdc\ +$#\x22z=\x19mMD\xf5F\xfe\x09\x97k=\ +\x8et\xc6\xeb\xf63\xa1pIE\xae\x90\xe6\xf9\xc12\ +K\x8f\xce\xc9z\xacB\x0d\x19\x98\xd0\xf4\xa7\x0c\x07X\ +\xe7\x94\xa8^\x03\xb2\xc1\x1a\xd2\x135\x1c\xaa\x0c\xe8\x9e\ +\xd5\x96\xef%\xfd\x80\xbf\xdb\x0b\xafH\xc9P\xb1OV\ +bW\x9e\x00\xf9im\xa3\xa2\x0fPN\xf8\xc2\x8b\xbb\ +\xb3r$<1V\x0d\x81r\x893\x04\xc7\xfc\xd7\xb4\ +\xca\xf9\xed\x92<@\xb1OVH\xc9\x10P\xf2\x85;\ +\xbc\xdc\x02T\x19P\xa12\xe8/\xab\xc8\xd8\x9b\x82|\ +\x89_f\xb2\x14\xfbdET\xc6\xfc\xb1pn\x10a\ +\x80 ]\x81@\x9a\xe7\xb1\xabk\x12\x95V\x9e\x05#\ +r4\x5c\xa7\xca\x00\x85\xfd\xfe\xf2\xc12Kq\x0bk\ +\x16\x11\xda\xdb\xc3u\x22z@p\x87\xb7\xd5f\xfbz\ +\x08k\x8f\xda\xbd\xd6\xde\x08\xed\x10\x9c\x01\xb6\x05\xd8\xc6\ +\x19`[\x80m\x9c\x01\xb6\x05\xd8\xc6\x19`[\x80m\ +\x9c\x01\xb6\x05\xd8\xc6\x19`[\x80mZ\xe2h$?\ +\xa5=\xa8\xde\x06\x0e\xb3\xc9\xff\x1a\x0cP\xe0=\x22\x97\ +\x8a\xfd\x12\xfe\xdd\xb2n\x8c{@nR\x87Q}\x01\ +\x1c!\xf9\xe4\xf1\xbe\xa3\x13\xd5\x17\xb9I\x1d6m\xcc\ +\xc8\x80\xce)\xdd'\xe8}S\x11\x8d\x22\xe8\xbd\xce)\ +\xddg\xd2\x86\x91\x01\x198\x06\xec1i\xc3\x90\xbd\x9e\ +\x86\x86\xd9\xf1\x93\xa0\x91\x01ex\x0b|\x8bIK#\ +|\xf344\x8c\x91\x01\x0b\xfd\xb2\xaa\xc8\x05\x936L\ +P\xe4\xc2B\xbf\xac\x9a\xb4a<\x04\xe6\x0a2\x8eH\ +/\xb0\xc0\xef%*i6\x96\xc1\xde\xb9\x82\x8c\x9b6\ +\x16\xcb>\xc0[\x8f\x8d\xd7d\x1b\xb8I\xd0\xb6\x00\xdb\ +8\x03l\x0b\xb0\x8d3\xc0\xb6\x00\xdb8\x03l\x0b\xb0\ +\x8d3\xc0\xb6\x00\xdb8\x03l\x0b\xb0\x8d3 \x1cP\ +\xf8\xe1/\x0fLh\xbayr\xe2%\xac=\x9c\x1bD\ +\x1f\x92\xfa\xec/\x7f\xcap ~i\xcd!B\xfbr\ +\xb8ND\x0f\xd0\xf9@`\x9dS\xf1\xcaj\x1e\xa95\ +N\x07#\xfa\xae\xaaNu \xf5\xd0_\x16\xd5k\xf9\ +im\x8b[\x5c\xd2\xe4\xa7\xb5ME\xaf\xfac\xe1\xdc\ +~\xc7Bd\xb2<\x05>\xfaBY*\xfa`;\x99\ +\xf0\xe7\xb0t\xf0\xc4\xf8\xa2\x97[\x80\xba\x8e\xcb\x8b\xca\ +X\xa5\x95g[\xf9\xb8|j\x8d\xd3\xde\x9bo\xec\xb8\ +\xfc\x06\xb9\xc7:\xfa_\x5c\x98\x00\x10\x19-\xf6\xcb\xcd\ +\xa8G5\xf7\x01s\x05n\x222\x9a\x9c\xaa\xa6\xa0 \ +#\xc5\xb3\xdc\xaaUa\xb3\x97\xa6\xee\x00\x1d\xb1JK\ +\x9eM]\x9a\xaa\xfb\xda\x9cw\xe4\xbc}+^\x9b\x03\ +\x96A\xdf\xd5sm\xce\xe1p\xecl~\x01C\x8d\x07\ +\x87\xbb\xe6?\x9a\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x00\xcf\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x81IDATX\x85\xed\ +\xd21\x0e\x82P\x10\x84\xe1\x7f\x9fw \xe16\xaf\xe0\ +\x08\xf6\x16Zp\x0b\xc2-(\xb0\xb5\xb5\xb51\xe16\ +&\xdc\x01\x96\x0a\x88\x98\xd8\xf1h\xe6\xebv\xb3\xc9L\ +\xb1 \x22\x22r0\xdb\xce1V\xa7=\x03\xbb\xae\x1e\ +\x00\xff)P\x9co\xd1\x9c\x07\x90\xefY\x00\xe8\xc7\xd1\ +/\xef\xe7\xfd\x05\x10\x96\xb5\xd3$\x08\x07\xc8B\xb0v\ +\x1e\xc2\xbf\xcb\x14\xd6\x02F\x09|\x12d\xf6\x8e]\xd7\ +\xd8o\xc9\x9fPDD\xe4p\x13jY\x1a\x0e\xce\xfb\ +>\xfc\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x1b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xcdIDATX\x85\xed\ +\x96\xb1J#Q\x14\x86\xbf\x93d\x13T\xb0p\x8b-\ +\x04\xc5\x170\xa0#,\x82\xec+,\x8a\x8a\x85\x96\x8e\ +\x10\x89\x08\x226V)\xb6\x08\xbb\xab#+\x9b\xb4V\ +*y\x02\x1bA\x04\xc1\x04\xf4\x09T,T\xd0B\x0b\ +AP\x8f\x85NL\xa23\xce$\xd1\x14\xe6\xaf\xee\x9d\ +9s\xffo\xce=s\xe6\xc2g\x97\xb8\xdd\xec\x1cM\ +6\x85\x1b\xc2\x09\x90~\x84\xf6\x8a\x9c\x94#\x84\x8cj\ +d>\x976\xaf\xdf\x04\xe8\x1cM6}i\x8cl\x0b\ +D+2~\xc1\xc1>\x1a\xe9\xb5!\x02N\x81\xe1\x86\ +p\xa2\xda\xe6\x00\x02Q\x91\x9b\x84=w\x04\x00\xe9\xaf\ +\xb6y^\xca\x80=\x0c9\xfb\x17\xefy6\x15w\xad\ +\x97\xb7d\x98\x96\xbe\xb6\xb6K\x06>Fu\x80\x175\ +\xd0=\xbe\xd0&\x01\xf9\x81\x16_7&\xacI\xa7E\ +D\xe5^\x85\xfd\x8e\x8bo;\xeb\xebCwe\x03\xf4\ +\x98\x8b3\x8a\xfcB_)Ne\xc9i\x11EA\xe1\ +\xb0\xe5t\xab{\xfc\xefp.=}\xe2\x15 \xbf\x05\ +\x86i\x8d(\x92,\x85\xf2#\x85\xbe\x80\x04W\x07\x07\ +\xd7\x82\xbe\x01@f\xcb5.\x858\xf8z\xf6\xddk\ +|\xc1\xdbji\xd7\xfb\xe7\xddT~\x0a\xdaj\xcfE\ +\x89\x02\xdb>\x01\x8a\xff\x0b\xd9T\xdc\xb1\xe8Je\x98\ +\x16@,\x0f$\xea\xf9\xeb\xaa\xf9gX\x07\xa8\x03\xd4\ +\x1c\xa0\xec\xae\xe7*e\xc90-\xc7\xd6\x8drd\x0f\ +k\x93\x01!c\x0f\xdf'\x03.z:\x94\xce\xdb\xf3\ +\x8f\xcb\xc0c\xda\xff\x14\x9e\x88\xa1\xa0\xfd\x1a\xa6u\x09\ +4W\xc5Lt,\xfb\x7fj\xc5K\xe8s\x06T7\ +\xaab\x0e\xb7\x12\x08mz\x0d\xce\x03H(4\x0d\x9c\ +W\xea\xae\xca\xdc\xeer\xec\xd87\xc0\xeer\xecX\x82\ +\xc1.T3\xc0\x95__\x90=DGr\xe9\xf8o\ +\x9f\xcf~r=\x00'\x99y\x91\xf6wY\xd9\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x0a\x8e\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x0a@IDATx\x9c\xed\ +[}\x8c\x1ce\x19\xff=\xb3\xb7\xd7\xbbr\xd7\x03)\ +\x07\xf5vvv\xaf=\x02\xa1%*\x05\x81\xd4\x13P\ +\x03\x12( $\xf2\x11\xa4\x02\x22\xa0\x88\xf2e\xd0\x00\ +\x15!\xf2!\x85\x90\xd4\x02\xb1\x0dP\x1a1(\x101\ +|4\xa1\x94T\x85@-\x88\x8b\x94\x5c\xbd\xdd\xf9\xd8\ +\xebQ\xcaG?\xb4\xd7\xdd\xd9\xf7\xe7\x1fwmgf\ +ggv\xef\xf6.F\xfb\xfbo\x9e\xf7\xf7|\xcc3\ +\xef\xce\xbc\xef\xf3\xbc\x0b\xec\xc7~\xec\xc7\xff3d*\ +\x9c\x0cl\xde|Hr\xb7\xdbO\xc1<\x0dr\x84\x02\ +{\x01\x1c(\x90\x19\x00\x13\x00\xb6\x03\xd8N\x88\x05\xf0\ +=\x0d\xf2\x0f\xd2]\x97\xc9d\xf2\x93\x1d\xdb\xa4%\xc0\ +\xb2\xac\xd9\x0a\xda\x22(.\x84\xe0\xe8q\x9a\xc9\x83\xf2\ +\x82\xa6\xa9Gu]_/\x22lj\x90hr\x02H\ +J\xc1qN\x15\x85\x9b\x00\x9c\xdcL\xdb\x00r\x14.\ +\xf9h\xcb\x96'\xe6\xcf\x9f_n\x96\xd1\xa6%\xa0P\ +pN\x86\xf0\x1e\x00\xf3\x9be3\x1cR \xb08\x93\ +\xeey\xbc\x193b\xc2\x09\x18\x1c\x1cF(\xbc4\x9bN\xfff<\xf1\ +\x03\x13H@\xa1`_\x08\xc1\x0a\x00\xd3\xaa\x82\x02\x1e\ +\xd4\xa0\xee2\x0c\xe3\x93\xf1\xda\xf7\x22\x97\xcb\xb5vt\ +\xcc\xf8\x0eDn\x05\xd0]E\xa0\xdci\x18=\xb7\x8a\ +\x88j\xd4v\xc3\x09 \xa9Y\x96}\x07!7\x07\x86\ +\x14\x80\x15-\x09\xf9Y*\x95r\x1a\xb5[\x0f6n\ +\xfc\xb0\xb3\xbd}\xe4:\x027\x00\xe8\xf0\x07\x86g\xa7\ +O\x9fvqww\xf7\xceFl6\x94\x00\x92\x9ai\ +\x16WAx~`hHi8\xa7W\xd7\xdfh\xc4\ +\xdex\xe18N\xca\xad\xf0\x19T\xbfp\xdf*\x97F\ +N\xea\xeb\xeb\xdb^\xaf-\xad\x11\xc7\xa6]\x5c\x5cu\ +\xf3\x82\xd7\xc1\xca\xfc\xa9\xbay\x00H\xa5RNBC\ +?\x80U\x81\xa1\xcf'[\xdbV\x91L\xd4k\xab\xee\ +\x19\x90\xb7\xaco\x0a\xe5I\xbf2\x1fS\xaare6\ +\x9b\x1d\xa9\xd7N3AR,\xcb\xb9\x91\xc0]\xf0\xdc\ +\x0b\x81{\xb2\x86\xfe\xe3zl\xd4\x95\x00\xcb\xb2\xe6+\ +\xca:\x00m\x1e\xf1\x13F:\xf5\xad\xc9X\x9d5\x8a\ +\xbc\xe9\xfcP\xc0\xfb\xbd2\x81\x5cb\x18\xa9\xc7\xe3t\ +c\x13\xe08\xce\xc1n\x85\x7f\x03\xd0\xe3QzC)\ +\xf7\xcb\x8d>\xf9B\xa1p$\xb4\x96s\x848\x9aP\ +)@R\x00*\x028\x148P\xdc\x00\xa8\xa7\x1b\xdd\ +\x03\x90\x14\xd3,.\x87\xf0\xdb\x1eq\x09L\x9c\x90\xc9\ +|vC\x94nl\x02\x0a\x96\xbd\x1c\xc4\xa5\x1e\xd1\x90\ +&<6\x9dN\x0f\xd5\x13\x5c.\x97k\xed\xec\xec\xba\ +\x8a\xc0\x95\x00\x8e\xa8G\x07\xc0[\x14>\x98\xd1\xf5\x95\ +\x22R\xa9Ga```Z\xb2\xb5m\x0d\x80\x13\xf7\ +I\xb9\xc1H\xeb_\x14\x11\xb7\x96^d\x02L\xd3\x5c\ +@h\xeb<\x22R\xc9\x89\xd9l\xea\xf5z\x82\xca[\ +\xd6\xd9B\xb9\x17\xc0\x9cz\xf8!x\x1b\x94\xeb3\x99\ +\xd4\x9az\xc8c\xab\xd2\x1c\x80\x99{d\x02\x5ck\x18\ +\xfa\x83\xb5tj~\x05H\x0a\x91\xf8E@\xbc\xaa\x9e\ +\x9b_\xbf~}\xb2Pp\x96\x0a\xe5\x19\x8c\xff\xe6\x01\ +\xe0s\x10\xbe\x9c7\xed\xc5$c\xbfX\xbd\xbd\xbd\x1f\ +\x10r\xa7WF\xe0\x96\xe1\xe1\xe1\x03j\xe9\xd44Z\ +p\x9c~\x80\x0b<\xa2\xb2@\xdd\x16\x17\x84i\x9a\x07\ +\xcd<\xe4\xd0\x17 \xbc:\x8e[/\x04\xb8\xcd\xb4\x9c\ +\xdf\x16\x8b\xc5\xe9\xb1dU~\x08\x02\xcb#\x999R\ +*}\xb7\x16\xbdf\x02D\xe1\xc6@\x14\x0f\x1b\x861\ +\x18\xe5;\x97\xcb\xb5\x02\xda\xb3\x00\xbe\x12\x1bh\xe38\ +\xaf\xec\xaa\xc7\xe3fB6\x9b\x1d!\xe8\x7fP\x94\xeb\ +j\xad\x0dB\x8d\xe5\xf3\xf9\xc3\x00\x9c\xe6\x11\x95\x95[\ +\xbe#\xca1I\xe9\xe8\xecZJ\xa0?\x8a7A\x9c\ +[\xb0\x9c\xd8Y\x98\xd1\xf5\x95\x04\x06<\xa2\x9e\x82m\ +\x7f5\x8c\x1b\x9a\x00I$.\x04\xb07c\x02\xac\xe9\ +\xed\xed\xfd \xca\xa9e9\x17\x01\xb8<.\xb8\x89B\ +\x80[M\xb3\x18z3{9\x22\x15!\x9f\xf2\xc9\x94\ +\x5c\x12\xc6\xad1\x9d\xe4L\xef\x15\x85\x7f\x88rX,\ +\x16\xa7\x8f\xad\xc6\xa6\x04\x0ajI\xdcr\x97\x09\xf1\xc7\ +,8=L\xa7*\x01\xc3\xc3\xc3\x07\x80\xdeo)P\ +)'\xfe\x18\xe5\xac\x5c\xae\x5c\x07\xcfBi\xb2!\xc0\ +<\xd3t\x16Eq2\xa9\xd4\x9b\x80xgmW\xde\ +q\x8e\x09\xf2\xaa\x12\xb0{\xb7{<\x80V\x8f\xe8\xed\ +\xd9\xb3{\xac o\x0fF\xb3*?\x88\x0f\xbb\xb9\xa0\ +\xe0\xda\xa8q\x11Q\x10\xfa\x1e\x5cBU\xd7)C~\ +\x02\x9c\x1b\x10\xac\xab\xe6\xecC\xa1\xe0|\x09\x82C\xa2\ +8\x93\x01\x01\xe6\xd9\xb6\xdd\x17\xc5\xe1\xe8\xfee\xdf5\ +pT\x90\x13\x96\x80#\x03\x8e\x06\xaa9\x9e\xf1\x04\xce\ +\x0b\xe8G\xd1\x9b\x0aW\xe1\xdc\xa8q\xa1\x04c?2\ +\xc8\x09I\x80d\xbcW\xa4D~\xfb\xa1\x82E\x89)\ +\xe9\xb5\xec\xf1T\xf5\x9b\xf6\x82,\x05c\xcf\x069U\ +\x09 \xd0\xe9s\x22\xf2iL\x14S\xf6\xf2\x0b\xf1\x9d\ +\x8aa\x04c\xef\x0c\x12b\x13P\xa9\xb0f\x8dml\ +U\x16V\xad\x9d\x1a0:\x01\x99Lf7\x00\xefN\ +\xb0ut\xb5\xba\x0fU\x09\x90\xe0\x1cN2\xeaG\xad\ +\x85\xd9\x98:Hr\xa2\x16\xc2\x82\xdf\xe1\xbdH(\xad\ +j\xda\xecu?\xba\xcf\x8e\x5c!N.\x18Y}.\ +\x14\x0a\xd3\x00\xb4xD\xa5\xb9s\xe7\x96\xbc\x9c\xb0\x19\ +\xe0\xab\xa8\x92<0&\x8ab\xcc\xf8\xa4A\x80\xc8\x04\ +\x90\xec\x0a\x88v\x049U\x09P\x80\x190S\xf5\xe6\ +\xf4\x07\xc1\x5c\xd4\xf8d\x82\x94H\xdf\x9a\xd6\xda\x1b\x10\ +\x15\xaa8\xd5j\xf2\x9e\xcf\x89 r\xb1!\x82\xa7\xa3\ +\xc6'\x17Z\xa4o\xa9\x8e}c\x95\x85jA\xc5\xd7\ +l\x14\x7fQ\xa4\x0a\x95Je5\x80\x86\xba1M\x82\ +i\x18\xb3\xde\x8a\x220\x10;\x81\xaa\x19S\x95\x80\xf6\ +\xf6\xf6\xd7\x00x\xfa\xef\xf2\x05\xc7qj~n\xb2\xd9\ +\xec\x08\x04\x8f\xc6\xc7\xdbd\x88<\x12U\x92\x1f\xfbD\ +\x9f\xe1\x13*Y\x1b\xe4U%\xa0\xbb\xbb{\xa7\x00\xaf\ +yee\x150\x14@9\xd9r;\x80m\xd1\x117\ +\x0f\x02\xd8\x09\xf1\xf7\x01\x82\xb0m\xfb\x18\xf8\xd7(\xdb\ +3\x99\x9e\xf5A^\xe87\x9c\x84o\x17%\xe0\xc2(\ +g}\xb3f}\x082\xb2b\xd4d\xfcD\xd7\xf5]\ +Q\x04\x05\xcd\x173\xc1\x17\xc3\xca\xe3\xa1\x09\xd04\xae\ +\xc2h\xb7w\x8f\xf6)\x03\x9b7G\xee\xf8\x0cC\x7f\ +@\x80\x97\xa28\x8d#t\x86\xafL\xa7S\xc1\x9e\xa0\ +_\x8b\xd4@\xfa6iBy,\x8c\x1b\x9a\x80t:\ +=\x04b\xb5G4-\xb9\xbb\x1cl\x87\xfb \x22\xae\ +R\xee\xf9\x00\xde\x8f\xe25\x06\x09^\xbeN\xe5^\x11\ +\xd7\x8e3M\xe7\x02\xf8\x9b0\xc3\x86\x91Z\x1d\xc6\xad\ +]\x15\x16\xf9e@\xf0\xbd\xc1\xc1!#\xcaq6\x9b\ +\xfdT\xa0NGS\x93\xb0\x17\xeb\x95[>;\xae\x1d\ +\x97\xcb\xe5Z!\xf8\xb9W&\xc0\xfd\xb5\xbaC5\x13\ +\x90N\xf7\xac\x81\xffe\xd8\x9aH\xa8\xc5qQ\x1a\x86\ +1H\xe5\x1e/@h\xc6\xc7\x05\xca\x93\x09\x0d\xfdq\ +\x85Y\x00\xe8\xe8\xe8\xba\x02\xfem\xef\xc7\xbbv\xb5-\ +\xab\xc5\x8f\xdc\xbc\xe7\xf3\xf6I\xa2\xe1\x15\x8fH\x09\xd4\ +q\x86a\xfc56f\xb2\xc5\xb2\x9c\xeb\x09\xfc\x14!\ +\xdb\xd0:\xb1\x95\x22\xb7d\xf4\x9e\x87\xeb\xe9B\x17\x8b\ +\xc5\x99eW\xbd\x0b\xef1\x1a\xf2\x86L&}_-\ +\x9d\x98&\x83\xbe\x16\xc0J?_{fpp\xf0\xd0\ +\xb8`D\xc45\x0c\xfdn\xb7\x9c\x9c\x03\xca2\x00\xff\ +\x8e\xd3\xf1`\x9b\x00wU\xdc\xd2\x9cl:\xf5P=\ +7\x9f\xcb\xe5Z\xcbe\xf5;\xf8n\x1e\xefl\xdd\xba\ +\xa5f_\x10\xa8\xa3|\xb3i\xd3pwK\xd2}\x07\ +\xa0\xf7\xa6\xffR.\x8d\x9c\xd2\xd7\xd7\xb7;N\x7f\x0f\ +\x8a\xc5\xe2\xf4rY\x9d\x06\x0d\xe7\x92\x98'\xa3U\xe4\ +\xcf\x8c\x05\xfa!4\x0cA\xc9\x06\x80O\xed\xdc\xb9\xed\ +\xe5\xe0\xae-\x0e\xa6i-#\xe4J\x8f\xa8\xac4,\ +\x88;\xb9RW\xfd*\x9fw\x8e\x17\x8dk\xe1=\x11\ +&Xa\xe8\xa9\xcb'r@\xc2\xb6\xed\xf6\x91\x91\x11\ +\xd5H\x22\xc3P\xb0\xac\xabAY\xea\x13\x12\x97g2\ +\xfa\xf28\xdd\xba\x0bx\xa6\xe9\x5cL\xd0w\xe2\x82\xc0\ +#\xff\xda\xb1\xed\x9aF\x9fV\xb30vD\xe6\x1a\x02\ +\xf7\xc3\xf3s\x16\xf0\x01\xc3H\xff\xa8\x1e\x1b\x0dU0\ +\xf3\xa6}\xb7\x007\xf9\xa3\xc0\xab\xc9\xa4v^OO\ +\xcf\xd6FlM\x14\xb9\x5c\xae\xb5cF\xd7\xaf@\x5c\ +\xe6\x95\x0b\xf0R:\x9d:#\xeaPD\x80_?H\ +&L\xdby\x0a\xc49\x013\x85\x84\xc6\x85\xba\xae\xff\ +\xbd\x11{\xe3\xc5\xd8{\xe9\xf7\xa8\xde\xa9\xbeK\xe5.\ +\xc8f\xb3\xd1\x85\x5c\x0f\xc6sP2a\x9a\xf6\xbd\x10\ +\x09N\xb12\x81e\x95r\xf2\xce9s\x0e\xdb\xd2\xa8\ +\xddz0z|\x16\xdf\x87\xe0f\x00\x07\xf9\x06\x05/\ +T\xca\xa5\x0bf\xcf\x9e\xdd\xd0\xa6l\x22Ge/\x83\ +`\x19\x80`ar'\x81\xfb\xdc\xd2\xc8\x92F\x0e,\ +F\x81d\x8bi:\x8b X\x8c\xb0\x1e$e\x89a\ +\xf4\xdcT\xefy\x22/&vX\xda\xb2\xfa5\xca\xd3\ +\x00\x0e\x0e\x19\xfe\x84\xe0s\x1a\xb4\xe7J\xa5]\xab\x1b\ +M\xc6\xe8\xe1\xaa\x83\xfa\x15\xd4\x99\x02\x9c\x05 l\x19\ +^\x06qU=o\xfbZ\x98p\x1bgS\xb1\xa8\xb7\ +T\xd4\x03 \xbe\x11A+\x03|\x15\xa2\xbd\x02\xc5\xf7\ +\x95\x92Mj\x9a|\x9ct\xdd\x9d\xa5R\xa9\xd2\xd6\xd6\ +\xd6\xa9\x94\xea\x22\x13Yj8\x1cT'\x08\xe4T\x00\ +3j\x19$\xf0\xe6\xd8q\xf9\xd8Ui\x14\x9a\xf8\x87\ +\x09\xfb\xeb\x14\xdc-\xc0\xbcf\xd9\xac\x81!Bn\xcf\ +\xa4{~=\x9e)\x1fD\xb3\xff2\xa3\x99\xa6s\x16\ +\x057\x0bpl3m\x03\x18\x04\xb9\x84\xac,o\xe6\ +\xd1\xdcI\xebd\x9a\xa6y\x14E[\x04\x85\x85\x10\x1c\ +>N3\xc3\x10<\xaf\xc0\xc7\xb2\xba\xfe\xa7\xf1\xfc\x1f\ + \x0eS\xd2\xca\xddT,\xeaI\x97'+\xf0(@\ +\x8e\x00\x98\x15A\x17\x88\x19\x18\xed\xdcl\x03\xb8] \ +\xb6\x026B\xb8Q#_M\xa7\xd3\xef\xfd7\x9cE\ +\xde\x8f\xfd\xd8\x8f\xff]\xfc\x07\xbb\x1b\xfe\xd4\xc42\xd9\ +\x11\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x015\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xe7IDATx\x9c\xed\ +\x9b\xb1\x11\xc20\x14\xc5\x9e\x19\x22\x131\x01\xc7\x06\xd0\ +0\x11\x0d#pL\xc04\xa9\xb2\x85)\x08]:\xdb\ +\x88;\xa4\xea\x17\xff\x12}\xf5ND\xe4\x9f)\xa3\x7f\ +\xb0?\x9e\x0f\xa5\xe6\x9a$\xb5\xe4\xf2\xbc\xdf\x1e=\xf7\ +[\xd9\x8d\xfcx\x92\xac\xc7LI\xa6\xcfa=\xf7[\ +\x19\x1e \xefc\xb6\xe6^\xfbM|#\xc0Oc\x00\ +Z\x80\xc6\x00\xb4\x00\x8d\x01h\x01\x1a\x03\xd0\x024\x06\ +\xa0\x05h\x0c@\x0b\xd0\x18\x80\x16\xa01\x00-@c\ +\x00Z\x80\xc6\x00\xb4\x00\x8d\x01h\x01\x1a\x03\xd0\x024\ +\x06\xa0\x05h\x0c@\x0b\xd0\x18\x80\x16\xa01\x00-@\ +c\x00Z\x80\xc6\x00\xb4\x00\x8d\x01h\x01\x1a\x03\xd0\x02\ +4\x06\xa0\x05h\x0c@\x0b\xd0\x18\x80\x16\xa01\x00-\ +@c\x00Z\x80f\xfc\xa3\xa9d\xd9\x9a{\xed\xb72\ +<@MNI\xe6$\xf3:w\xdd\x17\x11i\xe1\x05\ +,'\x220\x10\x9eB\xf3\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x03^\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x10IDATx\x9c\xed\ +\x99\xd1KSQ\x1c\xc7\xbf\xe7l:7\xca\xa2\x88\x1e\ +\xaa\x87F\x11$=T\x90\x91\x09\xd1\x9c1\x912/\ +#zJ\xe9j\x10H\x7f@\xd0\x1e\xea-\xa2\xde\x8a\ +\xb9-\x1f\xd2\x82\xb5\x19\x8b,\xb7R\x1f\xc2 \xb0\xa8\ +\xcc\x12\xb4\x1e\xca\x82\xc82W\x8e\x9c;\xa7'i^\ +\xaf\x0d\xc1s\xae\xd0\xf9<~\x7f\xb0\xef\xf7~\xef\xd9\ +\xce\xb9w\x80B\xa1P(\x14\x0a\x85B\xa1P(\x14\ +\x8a\xff\x0d\x22\xda\xc0\xab\xe9\x1d\x00\x8e\x03\x008iL\ +\xc5[\xdbD{.\x06\xa1\x05\x1chh()J\xdb\ +3\xf9\x1a\xe5\xec`w<\xd2+\xd2w1P\xa1\x9f\ +\xfe\xcbe7J\x8c\xd0\x1eO}\xa3[\xa8\xef\x22\x90\ +\xf1\x15\xe0f\xba3\xcbJ\x13\x89HZ\xb4\x7f!\xc4\ +\xae\x00\x00\xab\xe9\x8fy\xab\x00\x002Et2\x10\x08\ +\x08\xf7/\x84\xf0\x00\xd1h4g/\xc9\xac2\x9b\xf5\ +\x0f\x8e\xe5D\xfb\x17B\xca\x1d\xb8\xdf\xde>I)\xdf\ +j6\xf3j\xfac\x19\x19\x16B\xda\x12\xec\x8e\x86G\ +@x\x95\xc9\xa8\xa2Zk\xba(+\x87\x11\x9bL\xb3\ +wC\xcf\xdf\xbb\xb7\xef\x1c' 5\x86\xd1\xbe-e\ +\xbbGF\x87\x9e\xbd\x92\x99\x07\x90\xb0\x0b\x98\xe1\xd5\xf4\ +6\x00'\x8c:\xa5\xbc\xbc;\x1a~*3\x8b%\x05\ +\x00\x80W\xd3G\x01\xcc?\x0fd\xd9\x86T\x22\xf2I\ +V\x0e\xcb\x0a\x00\x16>#\xfc\xa4+]O\xa2\x973\ +f\xb3\xa5\xc6\xd2}\xf8\xdbZZl\xa6\xaf`\xe9)\ +H\xba9\x96\x160\x10\x0cf\xb3\xc5t\x9d\xd9\xcc\xab\ +\xe9\xdfed\xb0\xfc$\xd6w3\xf8\x950\xbe\xc3d\ +\xb4\xaaJ\xd3o\x89\xf6\xb7\xbc\x00\x00Hv\x86\x079\ +A\x9dQ'\xc01\xd1\xde\xcb\xa2\x00\x00\xa0\x9c\x0e[\ +\xe2k\x85\xa9\x11\xcfa}=\x07\xeb2\x19\xf5\x8b\xf6\ +\xb6\xbc\x80\xda\xdaf\x17\xb5#\x01`\xf3\x9c\x01\xc7\xf9\ +T,T!\xda\xdf\xd2\x02\xfc~\xbfm\xda\xc1:@\ +\xb0'_'\xe0\xad\xa9x( #\x83\xa5\x05L\xb0\ +\xd2K\x1c8\x92\xaf\x11\x82\x07\xd3\xe3\x1bO\x030=\ +$-5\x16\x1e\x85\x9b\xce\x00\xfc\xca\x5c\x95\xbcpf\ +s\x952\xdf\x14Y\xf30T\xdft\x14\x84\xc7\x0c\xfe\ +\x1fs\xd4\xbe\xb7'zmLf\x16\xe9\x05Tk\xcd\ +\xe5\x1c\xac\x17\x80sV\xe3@\x9a\x03\xfb\x1f\xc5B/\ +e\xe7\x91\xfa\x1b\xe0\xa9ots\xb0\xbb\xc8\xbbx\x00\ +3\x94A\xb3\xe2\xe2\x01\x89\x05\x1c\xf2\x9f\x5cC\x88\xad\ +\x0b\xc0\x9c\xb3?\x01?\x95\xec\x0c\xa5d\xe50\x22\xa5\ +\x00\x9f\xaf\xc5\x91c\xe4\x0e\x01\xb6\xe5\xeb\x9c\xf0\x0b\xc9\ +X8\x22#\xc3B\x08/ \x10\x08\xd0\x19W\xe6:\ +\x01*\x0d\xa3\x1b\x0fo\x87\xcf\x89\xf6/\x84\xf0\x02\xfa\ +_\x8f\x9d\xc5\xec\x7f\x83\x7f\xe9\xb3O9uH\xda\xeb\ +\xff\x85\xd0]\xc0\xe7kq\xcc\xb82\x13\x00J\xf2\xe4\ +7\xc5\x8e\xa2\x8a{\x1dW\xa5<\xef\x17B\xe8\x0a\xf8\ +\xb2\xe97\xe3@6_\xb2\xe5\xec5\xcb\xe5\xe2\x01\xc1\ +\xaf\xc5?\x0f\x0c0w\xd9\xaea\xc2\xe1\xe1\x04\x1f\x08\ +%u\xc9x\xf0\xadHO\x85B\xa1P(\x14\x0a\x85\ +B\xa1P(\x14\x8aB\xfc\x01\xea\x12\xddS\xe7\x12I\ +\xf2\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\x85\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x007IDATX\x85\xed\ +\xce\xc1\x0d\x000\x08\x031\xd4\xfd\x87\x041\x08\x1d\x02\ +\x9e\xbe\x7f\x22G,\xca\xea\xc9\xea\xd9|\xbc\xcd\xf8\x22\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x0f\ +~\x19\x07\x85\xa1\xbf\xac\xe9\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x00\x87\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x009IDATX\x85\xed\ +\xce1\x11\x000\x08\x04A&\xe2P\x80\x04\x84 =\ +\x22\xa0\xdc\xeb\xffg#\x16e\xf5d\xf5l>\xdef\ +|\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\xc0\x07e#\x03;X{\xaf\x09\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\x89\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00;IDATX\x85\xed\ +\xcd\xb1\x11\x00\x10\x10\x05\xd1O!(E\xa2k3Z\ +1\x14r\x22\xa1\xf4\x12\xfb\xa2\xcdV\x02\x00\xe0w\xe1\ +\xc6\x5c{\xc8T}\xb6\xd6KNM\x92\xa2\xcf\x10\x00\ +\x00\xe0\xed\x00Z6\x07\x04\x97\xc1\x22\x16\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x00\xa7\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00YIDATX\x85c\ +`\xa0\x00\xb8\x85\xa44\xb8\x85\xa44Pb\x06\x13%\ +\x9a\xa9\x01F\x1d0\xea\x80Q\x07\x8c:`\xd4\x01\xa3\ +\x0e\x18p\x07\xb0Pj\xc0\x7f\x06\x06\x07J\xaa\xe4\xa1\ +\x1f\x02\x8c\x0c\x0c\x07v\xad\x99\xd3@\xae\xfe\x01\x0f\x81\ +Q\x07\x8c:`\xd4\x01\xa3\x0e\x18u\xc0\xa8\x03\x06\xdc\ +\x01\x00\x05\x9e\x09?\xb6m\xc4\xbd\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x010\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xe2IDATx\x9c\xed\ +\xd0\xb1\x0d\xc20\x18\x05\xe1g\x86H\x87\x94\x99X!\ +\x15\x13\xb1\x053E\xa1a\x0bS\x80\xa8\xa0\xb2\x9dC\ +\xe2\xbe*\xc5/x\xbeD\xd2?+\xa3\xff`]o\ +\xa7\x94\x5c\x92$5\xe7y>^{\xde\xb7:\x8c\xfc\ +\xf1$y=fJ2\xbd\x1f\xd6\xf3\xbe\xd1\xf8\x00\xcf\ +\xc7|\xfa\xeeu\xdfd\x8f\x00?\xcd\x00\xf4\x00\x9a\x01\ +\xe8\x014\x03\xd0\x03h\x06\xa0\x07\xd0\x0c@\x0f\xa0\x19\ +\x80\x1e@3\x00=\x80f\x00z\x00\xcd\x00\xf4\x00\x9a\ +\x01\xe8\x014\x03\xd0\x03h\x06\xa0\x07\xd0\x0c@\x0f\xa0\ +\x19\x80\x1e@3\x00=\x80f\x00z\x00\xcd\x00\xf4\x00\ +\x9a\x01\xe8\x014\x03\xd0\x03h\x06\xa0\x07\xd0\x0c@\x0f\ +\xa0\x19\x80\x1e@3\x00=\x80f\x00z\x00\xcd\x00\xf4\ +\x00\xda\x1e\x01\xee_\xbe{\xdd7\x19\x1f\xa0fI\xc9\ +\x96\x92-5K\xf7{Ij\xf0\x00\xc5=\x1c4\xe1\ +\xa3\xf7o\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\x9c\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03NIDATx\x9c\xed\ +\x9b\xcdk\x13A\x18\xc6\x9fw\xd3\xa8\x85R\x0f\x22\x22\ +\xf6`m<\xa8\x05\xd1\x93\xde\x8a6\x89\x15\x14\x9b\x18\ +\x94\x16\x11\xd2T\xfb\xf1\x07\x14\xff\x02\xebQi\xfd\x22\ +\xed\xa5\xd4\x831U\x11ZM*\xb4\xe0\xc1\x8b\x1f\x87\ +\x22=X\x11\xcc\xa5\x8a\x87\x96\x8a\xa9If<\x18\x04\ +\xb3\x9bM\xb3\xbb\x931\xcd\xfc\x8e\xb3\xc3\xf3>\xfbd\ +23\xec\xce\x02\x0a\x85\xa2\x96!\xbb\x02m\xa1\x81\x06\ +7\xcf\x0c\x82\xf1\x10\x08\xad\x00\xb6:\xe0\xcb\x0e\xeb\xe0\ +X\x80F\xb1\x0c\xb9G\xe7b\xb7\xd7\xcc:\xdb\x0a\xc0\ +\xd7\x19\xf1r\x0d\xe3\x00\x9a\xec\xe8\x08$E\x0c\xe1\xc4\ +\xe3h\xb2X\x07\x97Ue_\xb0'\xcc\x89\x1e\x02\xd8\ +nU\xa3\x024\x82\xd0\xb5\xef\xd0\xd1/\x9f>\xbc}\ +o\xd4\xc1\xd2\x08\xf0\x9e\x0f\xfb\xc0\xb5\x19\x00\x9a-{\ +\x95#G\x0c\x1dF#\xa1\xec\x00\xdaB\x03\x0dn\xf6\ +k\x11\xc0\x1eG\xacU\x8eTF\xdbr\xa0pN(\ +\xfb\x17t\xf3\xcc \xaa\xef\xe6\x01\xa0)\xef\xfd\x1f\xca\ +\x1f\xc2\x8c\x87\x1c\xb1#\x03\x03\xef\xe5\x07\xf0g\xa9\xab\ +N\x0c\xbc\xd7Y\x901]\xe7\x93\xf1\xa8\xed\xbd\x85\x1d\ +\xbc\xc1\x087\xb9\xac\xf3^-\xb3\xb80T\x00\xb2\x0d\ +\xc8F\x05 \xdb\x80lT\x00\xb2\x0d\xc8\xa6\xe6\x03(\ +\xb9\x11\xf2\x07\xae\xecf`\xfd \x9c$`\x97\xd9.\ +\x03\x00|\xc1\xc8G\xabf8\xc0\x01\xa4\x08\x98vm\ +\xfbyofrr\xd5\xaa\xd6F1\x0d\xc0\x1b\xe8=\ +\xcb\x88\x8d\x03\xd8\x917X\x12\x0e\xb4\xd8\xf4\xe4\xe1@\ +[6]\xdf\xdf\x1e\x88t\xcdNE_\xdb\xd43\xa5\ +\xe8_\xc0\x1b\xe8\x19\x06\xf1\xa7\xc8\xdf\xbc\x04\x9a\x89\xf0\ +\xca\x1b\xec\xed\x13Y\xc40\x00_ r\x01DC\x22\ +\x0bo\x10\x17\xc0G\xda\x03\x91c\xa2\x0a\xe8\x028u\ +\xaeo/'\xba/\xaa\xa0\x05\x5cDx\xd0\xd1\xdd\xdd\ +(B\x5c\x17@\xd6\x95\xbd\x06p!\xc5l\xd0\x9cK\ +\xd7_\x15!\xac\x0b\x80\x80\xd3\x22\x0a\xd9\x85\x0b\xf2e\ +4\x07\xfc\xaf\x8f\xb8\x85\xf8*\xfb\x81\x88\xa6\xf1\xfd\x22\ +\x8cd\xb3\xf0h\x1a\xcd\x14\xbbN\x0e\xbc\xc41\xa2\xec\ +\x00^\xc4\xc6,ot\xcc\xf0\x87z\xc0\x98\x08es\ +j~+\xac\x02\x90m@6*\x00\xd9\x06d\xa3\x02\ +\x90m@6*\x00\xd9\x06d\xa3\x02\x90m@6*\ +\x00\xd9\x06dc\xe5|\x80\x148\xd0R\xe2\xdd\xffF\ +X/l\xa8\xad\x11\xc0\xb1P\xd8T[\x01h\x14\xd3\ +5\xc9\xf0!\x89T\x86\xdc\xa3\x85\x8dU3\x07\xd8$\ +G\x0c\xe1\xb9\xb8\xfe\xdcp-\x04\x90\xe3\x84\xded\x91\ +\xf3\xc2\x9b=\x80\x141\x84\x8b\xdd<\xb09\x03\xf8{\ +\x5c\x9e\xea\xd3#\x89\x89\x89\x1ff\x9du\x8f\x9a\x1dX\ +k\x85@\xc0R\x22\x1e\xf58\xadk\xb4\x0a|s\xba\ +\x88\x13p`Y\x84\xaeQ\x00\xb3\x22\x0a\xd9\x86\xe3\xa5\ +\x08Y]\x00\x1ac7\x00dD\x14\xb3\xc1w\x0d\xda\ +\x1d\x11\xc2\xba/F\x96\x16\xdf-{\x0e\x1eY\x03\xc8\ +/\xa2\xa0\x15\x08\xfcbb*\xfaF\x84\xb6\xe1N\xf0\ +xk\xd3M\x10\x1e\x89(X.\x04\x0c'\xe2c\xcf\ +D\xe9\x1b~34??\xcf/\x85\xce\xc4S_W\ +W\x00:Q\xac\x9f`V8\xe8r2\x1e\xbd%\xb2\ +H\xc97\xae\xfe\xce\xf0a\xa6iC\x00\xda\x01\xec\x14\ +i&O\x8a\x03\xd3u\xb9\xba\xeb\xcf\x9f\xdc\xfd\x5c\x81\ +z\x0a\x85\xa2\x86\xf9\x0d)\x0e\xd0\xf4\xc6l\xeb\x8f\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x027\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xe9IDATX\x85\xed\ +\x941h\x13a\x14\xc7\x7f\xef\x8eP\x8d uP\x8a\ +\x93)\xe2$\xa2\xa5q\x11\xdcD\x91\x8e\x8aSA\x87\ +\xda\xa0I\x8a\x83\x93\x08\xea\xea`M[k\xeb\xe0\xa0\ +\xa0X\xc4A\x07\xa5SqP\xa8\x8dZ\xc4\xc9\xc1E\ +\xa1\x88VEK\xb5\xb9\xfb;$g\xcf`\x9b\xbbX\ +\xecr?8\xf8\x8e{\xef\xff\xfe\xef\xde\xf7}\x90\x90\ +\x90\x90\xb0\xcaX\xb0\xe8<^\x9a\xc5h\xfd/U\xc5\ +\xe7g\xa3\xc5\x0d\x00N\xc8\x8a\xb3d\xc2J\x13\xaa\xf5\ +{\x91\xaaT2\x06O\x83w!\x1f\xf0V\xe2\x11\xf8\ +\xa1\xf2OR\x95Jf\xd1K\x88\x1d\xdd\x17\xd7\xb5\xa4\ +[\xee\x0a\xf6#\xc0\xe4\x83\xe9_\x9a\x152\xc3\x82F\ +\x1f\xfe\x9c\xfbqh\xfa\xc6\xe9\xef\xc1w7\x1c<3\ +=\xbe\xd0\xda\xbe\xfbNjmz\x1b\xc6\xf6\xaa\xc1?\ +<\xc6+n,\x16\x97\xdd\x9e\x9b\xfdx\xe4\xd5\xad3\ +\xf3\xe1\x18\xb7>\xe9\xc3\xeb\x09oO\xfb\xb1{_\xd2\ +\xdf6\x82e\x01\x93\x09\x8biD`V\x1b\xb1\x19\xc3\ +\x99Om=\x13c\xf9J}\xdc2\xaa\xb2l\xaet\ +^\xb2\xb3\xb5H\x1f\x11m\x1c\x86\xa1jq\xc1\x85\xa9\ +\x91\xc2\xb9\xa5F\xd9\xb0\xadl\xef@\x9fP?\x80\xaa\ +\x03\xf5\x1b\xa48\x81\xaeD\xdf\xd4h\xb1\xb4\xbc\xd7\x08\ +t\xe6.w#\xbb\x0e\xb8\x02\x19\x7f7!\xe1Xu\ +V\x9eaG'G\x0a7\x1biG\x1elGn\xb0\ +\xcb\x91?\x06\xac\x01D\xbd\x09\x99\x83\xc9\x80y\xdf\x9c\ +\xc3\xe5\xab\xf9\x07Qtc\xed\xaclo\xff^\xe1\xdc\ +\x07\xd6\xd7\x99\x08~\xfbW\xdf\xa1\xab<\x5c|\x1cU\ +3\xf6\x19\xcb\xf6\x5c\xda\x89\xe3>\x12l\x02T\xdb\xed\ +\x003\xe6{\x07&\xaf\x9dz\x11G\xaf\xa9C\xdeq\ +bh\xaby\xde\xb8\xc1\x16\x00\xc1[\xb9\xee\xbe\xf2\x95\ +\x93o\xe2j5}\xcb\xec\xca\x0flv\x17\xf4N\xf0\ +\xd2O\xd9\xc1\xe7\x83\x85\xf7\xcdj%$$$\xac*\ +\xbf\x00\xaf8\xac\x82\xe2Q\x10\x13\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x01#\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xd5IDATx\x9c\xed\ +\xdb1\x11\xc2@\x00\x05\xd1\x0d\x22\xa2\x08\x05\x0c\x0e\xa0\ +A\x11\x0d\x12\x18\x14\xa0&\x15.BA\xe8Rg\x99\ +a_u\xdd\xfd\xdb\xfe \xc9?\x1b\xac\x8b\xf7\xc7\xf3\ +a\x98\xb9\x02\xcc\x03\x97\xe7\xfd\xf60v\xec\x8cK\x01\ +\x96\xc7\x8f\xc0\xf8\x0da\xd0\x02\xf0y\xfc\xdaySf\ +\x80\x9fP\x00{\x80\xad\x00\xf6\x00[\x01\xec\x01\xb6\x02\ +\xd8\x03l\x05\xb0\x07\xd8\x0a`\x0f\xb0\x15\xc0\x1e`+\ +\x80=\xc0V\x00{\x80\xad\x00\xf6\x00[\x01\xec\x01\xb6\ +\x02\xd8\x03l\x05\xb0\x07\xd8\x0a`\x0f\xb0\x15\xc0\x1e`\ ++\x80=\xc0V\x00{\x80\xad\x00\xf6\x00[\x01\xec\x01\ +\xb6\x02\xd8\x03l\x05\xb0\x07\xd8\x0a`\x0f\xb0\x15\xc0\x1e\ +`+\x80=\xc0V\x00{\x80\xcd\xfb4\x05\xaf\xb5\xf3\ +\xd6\xb4\x003\x9c\x80\x09\x98\x96s\x92l\xee\x0d\xbb\x93\ +\x11P\xe7\xe7\xb7y\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x01\x07\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xb9IDATx\x9c\xed\ +\xd9Q\x0d\x83P\x10\x05\xd1\xa5\xc1\x1a\x0a\xb0\x80\xacZ\ +\xa8\x02\xc4\x81\x8c\xd3\xe4\xcd\x18\xd8\xc9\xe4\xfe\xed\x0c\xe4\ +8\xaf\xe78\xafG:|\xe4\xf1\x7f\xa0\x00Z@S\ +\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\ +\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00\ +-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\ +\x02\x9a\xe5\x03l\xf2\xb8~\x8d\xcf\xb4\x80\xd9\xb5\xc0\xcc\ +\xcc\xfd\xfb\xb2%.\xbf\x80\x02h\x01M\x01\xb4\x80\xa6\ +\x00Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\ +\xa0\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00\ +Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x96\x0f\ +\xf0\x02.V\x08v\x9db\x12\xf1\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\x85\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x007IDATX\x85\xed\ +\xce\xb1\x11\x000\x08\x031.K\xb15#B\x86\x80\ +R\xdf\xdb\xa7\x88EY=Y=\x9b\x8f\xb7\x19_\x04\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x01\ +\x8bi\x06\x03\x87|\xe1\xcd\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x01 \ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xd2IDATx\x9c\xed\ +\xd0\xb1\x0d\xc2@\x14D\xc15E8CrM\xb4\xe0\ +\x88\x8a\xe8\x82\x9a,\x93\xd0\x85\x09@D\x90z\x90\xd8\ +\x89.\xbb\xfd/\xa9\xaa\x7f6\xa8\x8f\x97\xe5v\xca\x90\ +K\x92d\xcby\x9a\x8eW\xb1\xe3 >M\x92\xd7\xf1\ +c\x92\xf1\x1d\x02p\x01\x9e\xc7\x7fz\xefJ\x06\xf8\x09\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\x0d\xa0\x07h\ +\x0d\xa0\x07h2\xc0\xfd\xcb{W.\xc0\x969C\xd6\ +\x0cY\xb3ef;\xaa\xea\xaf=\x00\x08-\x0eR)\ +l\xf3`\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04_\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x11IDATx\x9c\xed\ +\x9bMh\x1dU\x1c\xc5\x7fg\xf2\x90\x14\x95\xa2\xa8\x1b\ +QW\xa2\xb8\x11i\xc9GEIE\xabU\x0c\xcd{\ +\xa5\xaeD*\x8av!*(\x82\x0a\xb1\xb4b\x05\xc1\ +\x85\x88\x16\x04qa\xd1\x90/\x03Z\x8dJ+H\x9b\ +]\ +\xaf\x1d\xcf7zz\xf2\xb8v\x94\xc7E\x8aT\xdf\xb8\ +\xd7#\xcf\xfc\xddy\x00)\xb7\xba\x83\x0608\xee\xab\ +\x15y?p^\xd27\xc4y\xb5\x11,\x80uc\xbe\ +<\x8e<\x0b\x5c\x94\xcd\x04\xce\xab\x9d \x01\xdc0\xe6\ +\x8bk5\xcf\x02\x97\x15\xddV\xad\xe8\x06V\xab\xeb\xdf\ +\xf1\xf9\x7f\xc6~\x0fsU\x19\xed\x055\x03\x86^w\ +\xefR\xcb\xd3\x98\xf5I\xdf9N\xf9\xac\x82\x010t\ +\xc0\xb5\xc5\xb5\xde\x07\xdc\x94\x0a\x84\x95\xe3\xa2\x97U\x18\ +\x00l\xfd\xbe\x10\xef5\x8cd\x13\x5c\x5c\xe7!\x10\x00\ +\xfdS\xf1\xf3\xa0{S\xa60\x05\x8e\xfc\xb2*\x070\ +0\xe9'@\x8f'=\xb7\xef\xfa\xc2;\x0f\x15\x03\x18\ +\x98\xf4\xfd\xc6{\xb2\xbe\x14\xb5\xca\xaa\xa12\x00\xfdS\ +n\x18\xbf\x9a2\x0d61.l\xd1\xefP%\x00\x06\ +\xc6}3\xf6\xbel\xfb\x16\xb1T\xdc#\xefL*\x1d\ +\xc0\xe0\x94\xfb,O\x03\xe7$}\x9b8\xcf-\xeeJ\ +U*\x80\xfei_\x13\xdb\xfb\x11\xe7\xa6\x02\x97?\xf2\ +\xcb*\x0d\xc0\x86\x09_A\xecY\xe0\xc2t\xa2\x98\x8a\ +:\x0f%\x9d\x056L\xfa\x92\x16\xfe\x10\xb84\x9d(\ +\xa6\xcc\x15\xef\x0c*|\x06\xac\x1b\xf3\xda%\xf9}\xe0\ +\xcaT \xbb\xea\xceC\xc13`p\xcck\xe2\x9ag\ +0\xd7\xa5\x02a\xacR6:\xff\xa4\xc2f\xc0\xd0\x01\ +\xd7\xe2\x9a\xdf\x02nL\xfa.a\x7f\xbf\x1a\x15\x03`\ +\xd4\xd1\xe2B\xfc\x1a0\x9c\xf2\x0b>\xd9\xfd\x1b\xe5\x0f\ +\xc0\xd6\xc0\xb5\xf1\x0bF\xf7d\x93\x90F~Y\xb9\x03\ +\x18\x98\xe2I\xa3GSf{\xad\x0b\xae\xf3\x903\x80\ +\xbeI?h\xbc\xbb#\x90J;\xdc\xacV\xb9\x01\xe8\ +\x9bl\xed\x11~%\xeb;\xc0i\x9fT\x8e3 \xf3\ +B\x83\xf6\xfb\xfb\xaa\xb6\xb8+Un\x00\x04\x9d\xd3<\ +\xe8\xae\xb7\x95\x1f\x00\xe9a2]\x96\x88B\xff\xfc\x98\ +\x1b\x80\xb9\x11\x8d\x81\x1e\xeaL\x9c\xcbG\xcc\xa2\x94\xeb\ +S`\xbe\xae\x97A\xa3\x9dI\xb8\x10r\xdf\x07\xcc\x8f\ +\xb0\xcb\xf2KiW \xa2\x10\xef\x86\xfcw\x82\x92\x9b\ +\xc7\xa2G\x8c\xdfL\xf9F\xb8\xfa\xb7\xd0Y\x15S\xd0\ +N\xc5\xad\x1f\xa3\xed\xc0\xbb\x99D(,\x08\x85\x15s\ +\xe4\x01\x9dZ\xaai\x1b\xf0i*h\xff\xd0!\x18\x08\ +\x85\x16rdX'\xff\x90\xee\x04\x8eg\x22\x19\x07\x01\ +\xa1\xf0\x22\x8e\x8d\xe8\xe7xI\xb7\x19\xbeJ\xfaB2\ +\xaa|Y,e\x14>\xdb\xa6\xef\xa9\xe9\x16\xe0\xbb\xa4\ +/\x1cU\x0d\xa1\xb4i\xd8\x1c\xd6\xd7-t+\xb0\x90\ +\xf4\xd5\xbe\x15*\x83P\xea}\xf8y]_\x18\xdd\x01\ +\x9c\xcc\xd6\xe1\x8a \x94\xbe\x105\xeb:\xecXu\xe0\ +T\xd2\x17Dv\xf9\x10*Y\x89\x9b[\xf5\x81\xac\xbb\ +\xc9\x1e\x9e*\x80P\xd9\xa3h\xae\xa1\xb7m\xedH\x99\ +Z>A\x96\xa7J\x9f\xc5\xcd\x86\xf6\xdaz\xaa#p\ +y\x87\xa7\xca7#\xcd:\xcf\x09\xbf\x982u\xfa\xf0\ +T\x82*\x07\x80\xe4\xb9\xe3\xd1c\xc2o\xa4\xfc\x92\xb6\ +\xcc\xd5\x03\x00\xd8\xa9\xb8\xf7\x82\xe8>`&\x93\x14~\ +x\x0a\x03\x00pp\xa3\x96\xd6\xfc\xa2\xbb\x0c\x9f\xa4\x02\ +#\x17Xg0\x00\x00\x0en\xd7\xa2z5\x0c\x1cM\ +\xfa*p\x93\x14\x14\x00\x80\xf9\xdb\xf5k\x0f\xda\x0c\x9c\ +(\xa3\xbd\xe0\x00\x00\x1c\xaa\xeb\x87\x1ek\x13\xf0m\xd1\ +m\x05\x09\x00\xe0PC\xdf\x10i\x13\xf0S6\xcb\xf3\ +\xdc\x10,\x00\x80\xf9-\xfa2\x926c~K\xfa\xca\ +\xb1\xee\xa0\x01\x00\x1c\x1eQS\xd6\x96\xcc\x0f\xa9\xce\xfe\ +\xbf\xcc$5\xb7U\x1fa\xed\xa2\xfd\xf9\xad\x85\xf4l\ +\xd55u\xd5UWg\x87\xfe\x02\x8f\xb0QV\xec\xcd\ +\x17\x8d\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00u\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00'IDATx\x9c\xed\ +\xc1\x01\x0d\x00\x00\x00\xc2\xa0\xf7Om\x0e7\xa0\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80w\x03\ +@@\x00\x01\x8f\xf2\xc9Q\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x03\x17\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\xc9IDATx\x9c\xed\ +\xd6MHTQ\x18\x06\xe0\xf7\xbd^K\xb2 \x82\xa0\ +\x08\x8cVAAT\xd28\x1a\x84E\x04&)&\xcc\ +\x22\xca\x12\xa2\x9fE\x8b\x08\xa2\x82\x90\xa0E`\x05n\ +\x82(\x88j\x11\xf83W\xa4\xbfM\xf4\x03\xe680\ +\x81\x9b\x16\x19\x05\xad\xa2\xac\xb0 5\xaf\xf7m#\xe4\ +\x5c+\xcc\xb93A}\xcf\xf2|\xe7\xbc|\xe7\xbb\x1c\ +f\x00c\x8c1\xc6\x18c\x8c1\xc6\x18c\x8c1\xc6\ +\xfc/\x98k@E\xb7V!\xd0\x0d\x00\xcb\x04^L\ +7\xe0\xfb\x02\x22\xfc\x15\xf8\x9dL\x82o\ +|\x9f\x1b\x09<\x98\xc1\xf6A\xa7\x88\x95\x85\xb8\xb7\x13\xba\xfe\xab=\x12\ +\x9e\xfa.\xab\xfa\xea\xf9\xb2P}\x15\xe4\x09d\x91\x18\ +O\x06-\x22[B\x95N\xc7gS_\x82#\x85l\ +\xa7\xf0\x03\x98\x14KN\x5c!\xd8\x0c@\x82.\xa4\x07\ +\x9cS\xbf\xfb\x7f\xf0O\xaa~(\xb7\xfa\x9aJ\xfev\ +\x1f\xc6\x18c\x8c1\xc6\x18c\x8c1\xc6\x18c\xcc\x7f\ +\xe2;_z\xf2\xea\xb1n\xd0\x9c\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\xc8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00zIDATx\x9c\xed\ +\xd0\xb1m\xc2`\x14\x85\xd1\xefg\x88\x88\x812\x01b\ +\x83\xd0x\x22\x9a\xac\x906\x0d\x0bY,\xe1\xb4\x91]\ +\x83%8\xa7\xbcz\xc5}\xb7\x00\x00\x00\x00\x00\x00\x80\ +w0\xd6\xc1\xe7\xf9r\x1aK\xd7\xeac\x87>\x0f3\ +j^\xea\xeb\xf6\xf3\xfd\xfb??l\x0e_\xf0\xf9\xaa\ +\xa5\x8e\xd5u\x9do\x06x7\x9b\x01\x96\xd1T\xddw\ +\xe8\xf2P\xa3\xe6j\xda\xbb\x07\x00\x00\x00\x00\x00\x00\x00\ +\xf0|\x7f\x0b\xd1\x0f\x08 \x9f[\xc7\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x03\xe0\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x92IDATx\x9c\xed\ +\x98Mh\x5cU\x18\x86\x9f\xf7\xdeP\x12E\xa1\xda\x9d\ +\xe8V\x5c\xb7d\x22\xa9hTJ\x9bB\xd2I \xe0\ +J\xb4\xfe\x81k\x7fAD\xac`\xba\xd0\xad\x8a\x05W\ +\xae\x9a\x8c\xc9\xa2\x15J5\x9b\xcaL\xd2\x14t\xd3\x9f\ +\x9d\xc5eD\xd2\xb8\x88:s_\x17\xa12\xb9\xf7&\ +\x99\x99\xdc\x99Dz\x9e\xe5\xf9\xee9\xe7}\xbf\xf3s\ +\xcf9\x10\x08\x04\x02\x81@ \x10\x08\x04\x02\x81@ \ +\x10\xb8\xb7P\xba`p\xc6\x1fJ\xfe\x00\x88\x0d\x89\xc0\ +{\xa0\xab0\x0c\x12D@\xc3\xd6\xc7\x8b\x93\xfa\xa89\ +\x9eI@i6\xa9\x03q\xaf\x04\xf6\x98Fm\x22\xea\ +k.\x88\xf6J\xc9~!\x93\x00[g\xd0\xff{\xda\ +\xe7\x22l\xebL\xb68\x87\xd2\x8cG\x90\xe7\x80\x07R\ +!\x03I\x17\xe4\x15ID\xd6\xd7\x9a\xa4\xb1jY\x0b\ +\xe9\x8fs\x13\x00P\xaa\xf80\xf6\xf7\xc0\xa1T\x0d\xe3\ +\xfd\x99\x04C\xa4\xac\xa7\x15\xa4\xe3\xb5\xb2\x96\xf3\xeal\ +\x99\x00\x80#s~\xb4\xa3\ +\xc7\xdd\xf5\xc8|i\xe2+`\xac-\xaa\xdar\x07\x0c\ +\xe4\xf3\x0f\xdd\xfam\xe3\x19\x80#5\x0d\x10\x9c\xeb\xda\ +|#{el\xec\xef\x84\xa5%\x1f\xc0\xc0+\xe7\x1f\ +\xbe\xb5\xf6\xe6g\x00v\x87k\x021\x00A\xc0\x8a\xd6\ +\xf8\xe5\xfa;]{\xaf|<\xf2W\x92\xfa\x12\x0d\xe0\ +\x99\xd7\x8b\x1b\xfcE\x5c\x00\xb0=fe\x1fr_\x85\ +\x08\xec\xb0\x18\x02\x97Sw\x17v\xcf\x9c;|3)\ +\x8d\x89\x05\xf0\xf4H\xf1Q{\x0d&A8\xc1\x8a\x00\ +\xa0\x1f\xabD\xc4\x8e\x914\xe7/b\xe8\xbb\xf3\xa3\xbf\ +'\xa13\x91\x00\x9c\xcc\xc9-\xa45\x05`k\xa8$\ +\x00Lu9b\xc5\xe8\xbaN\xdb\xde1\xfb\xfek?\ +\xb5R'\x10s\xf6\x9a\xa5\xef\xe0{O\x91\xd6\x0c\xea\ +6\xbf\xf4\x11\x18\x80\x12*l\x15\xdf\x9fq2\xde\xb6\ +V\xe9\x5c\xa2\xa5\x01\xa4\x0f\x9cL[\xbe}\x15\xc0\x13\ +\xc1\x0ak0_\x89\x18\x08\xc2!\xf4\x92r\xad?\xeb\ +\xb9M\xca\x0c\xd0\xb2\x00\xd2\xd9\xc2\x0bbY\x97\x01l\ +\xaa|.\x02\x01\xa4\x0e\xf3e\x18\xbb\x136\x19\xc8t\ +_\xce{\xbe\x09\xa9\x01Z\x12@:[\xdc#\xe0\x04\ +\xee\xb5\xb5\x95\x08Y\xcf7\x1f&v'tY\x22\x93\ +\xfd\xb9\xc2p\xe3\xf3\xde\xa7\xe9\x00\xdc\xac\xb7_\x80q\ +\x00\xa9@\xe1\x9e\xf1&\xccW\x9d'e\x84\x9f\xbb\xb9\ +\xe2\xbef\xa7o\xaa\x15v3\xc5\xb7@x\x88\xdc\xda\ +\x12\xb7}\x9bB\x080\xb8\x0e\x01\xbc\xf4\xb8\xbb\xf3\xf6\ +|\xe9\xe2\xd7\x8d\xce\xdb`\x00B7\xb3\xf1\x18\xc8w\ +\x22\x15\xc0\xb0\xc5\xe6\x81\xb2s\x0a\x00\x86\xc2\xe6`\x8f\ +\xbbk\xdd|i\xe2R#\xef\x0fu\xf7\x01\xe5\xbe\xfe\ +4\xc0\xfd\xe1\x9a@\x121\x1fX\x83 %ztI\ +\x9c}\xf2\xc6c\xb9\xf1\xf1\x97\xa3MV\x15\xea\x0a\xa0\ +\xdc\xd7\x7f\x0a`OT\x98\x18J\xb2\xe6+\xd6\x22\x85\ +q\xf7\xd7\x17\x7f\xa6\xb0\xf7\x07o\xf4N\xads\xd5\x1c\ +\xc0\xb3\xfb\x8e\xad_\x5c\xb3\xee\x82\x00\xc1\x9f \x01\x84\ +0D\xe4\xb6N\x14\x81\x90\x88\x0d\xe1\xd2\xda\xbb\x0b\xc3\ +\xb5\xbe?\xd4\x14\x80\x939\xd1M\xa6&\x01\x04\x9b\x10\ +\x11\x90\xf4\xdb\xea<\x8c\x88\x1d\xbd\x160+fq\xa8\ +t\xe6\xd0\x1f+\x0d_1\x80\xf4\xc1S\xbd\xe2\xfbS\ +\x00Bm(\x1bkp\x12@@\x8b\x90\xa0\x17\xe1\xf7\ +\xb6\x91\xc1o\xce\x8e\xfe\x5cml\xd5\x00\x9c\x8c\xb7\x8d\ +\x94)\x00\xbd\xa1\x15\x05\xa4i\xf3\xae_\x01Z\x08\x87\ +\x00\xfc\x08\xcb\x0c\xce}\xf0\xe6\xf5\xe5F-\xdb\x08\xf5\ +g=\x97\x94\xab\x885\x8fUf\x1e(\xef\xc6\xb0\xa8\ +-0\xd6\xb5\xbeW\x0bN\xdc\x08`\x99\x00\x9cLa\ +\xbb\x81L\x03\xe8\x0e,\x81%\xf3\xab\x16#\xd1\x10\xba\ +-\xc3i7\xe7\x0d\xc4\x0d\x88\x1c\x81t\xaepD\xc4\ +\x1a\x8b\xd9N\xffq(\xa4\xc9\xcf\x9e~\xe3\xdd\xca\xa7\ +\xd1\xff\xe2\x0c\xf3\x0f\x9ey\xa0\xdc\xa9\xe4\xc3O\xa3G\ +\xe0\x01\xb4\xfe/1\xde\xa2;\x80<*\xadx\x8b[\ +e\x08`\x84<\xdai\x1d\x8a\xa2(\x8a\xa2(\x8a\xa2\ +(\x8a\xa2(J\xa7\xf9\x07\xees?\xf5\xa2\x1eW\x1f\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x042\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xe4IDATx\x9c\xed\ +\x99\xcbo[U\x10\xc6\xbf9\xb6K\x02\xa1B$l\ +\x10\xa9\xa0Aj\xd3v\xe3\xb4\xac\x90\x90K\xec\x8b\xda\ +EZ?\xb2\x80,\xc8\xc3\x0e\xfc\x03\x88U\x1b\xd8T\ +B\xac\x10BB\xa1$\x15,\xb20\x8f\xb6\x0b\x8c\xac\ +\xb6\x89ha\x01(\xde\xd5T*F\xa2\xcd\x0aXT\ +U\xd5\xa8\xb1\xcf\xb0H\x08\xd7\xf7\x1e;~\xdck\x17\ +1?\xc9\x9b\x99\xf3\x98\xf9\xb7\ +o`\x02V?\x7f\xbb\x03\x5c\xf6\xc6\x14\xc6\xfe\x8a\x80\ +h,\x11V\xd5{\x87\xc9e\xa9\xbb\xb3u\xf2\xd8\x05\ +\x94\xb0~\xcf\xb24\x9eJ\xa5L\xa5\xf9\x15\x17a\xa5\ +U]\xc2\xfa\x91\xdc\xec\xd4f5\x1fP\xd1\x01\x87\xbc\ +\x19hV\xd5\x99h,\x11.\x88;\x82\xf5.\xfcn\ +\xc3\x06c$\x93L&#\x00+\xeb\xdb5[_\xb5\ +\x00\x851\x81\x09\xf7]\xd0+\xcb\xeb\xdb\xb7-\x11\xe1\ +\x08\xd6\xbb\xa8\xd8\x82\xee\xce\xd6IE\x96\xbc1\x81\x09\ +U}x\x98\xdc\x9f\xf5U\x0bH\xa5R\xc6\xb24\x0e\ +\xec\x95I\xf3m}\xd5\x02\x00\x16f\xa76Ed\xb4\ +\xd4\xb8\xc2\xc8\x82O\xeb}\x09\x00\xb8p\xa6\xe5Qq\ ++\x0e\xc8k\xb3\xde\xb7\x80\x12\xad\xa8\xd9z\xdf\x02\xe0\ +\xa0\x15\xc6\xa8\x0d\xba\x05\xbae\x8c\xda\xb5Z\xef\xc2\xf7\ +\xefxq.\xf3\x06\x08WL\xac\x12^\x07v\xe1\xe0\ +\x00\x19T\xf1b\xf4\xf4\x0f4:\x8f;\x7f\x12\xb0\x06\ +`\xf2\xf4\x1e\x97\x00\x09\xd5\xbb\xb5?\xb8\xb1\xdf-P\ +M#\xd2\x87\xc8x\xc4N\x88\xe6\xf7\xe7=g\xb8#\ +\xa1\xa7\x7f\xa0QB\xf5\xbd\xa2<\x00\x0c\xaa\xe9\x82(\ +ob\xc4\x8e\x0f\x8bJ\x9a\x00\x0f*E0(\xa3\xb9\ +\xec\xd4}7p\xe8f\xb4\xf1\xe5\xd3J[\xc7\xd9E\ +D\x9a\x80\x93\x04w;\xda\x01\xde\xa1\x9a\xc8e3/\ +\x03\xaa\xf9\x8f\xe0\x17\xaf\x0f\x09\xa8\xe3\xe3p\xe1\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x056\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\xe8IDATx\x9c\xed\ +\x9bOL\x1cU\x1c\xc7\xbf\xbf\x99YLz!U\x1a\ +Rizq\x9b\x88!\xa9Ho\xbdl\x5c\x81C+\ +\x91\xc0F\x8d\xd04\xd9\x8d\xbdz\xb1\x07\x12Y 1\ +\xa6\xf5\xe4\xcd\xe8\x12\x1a%\x9af[0\x84\xc6\x00b\ +6-z\xa2\x92\x18].\xc5\x03a\x0f\x18l\xc3\xa9\ +Y\xd8\x99\x9f\x07\xf6\xc9\xec\xec\xec\xce,\xf3g\x07\xd9\ +\xcf\xed\xcd\xfcf\xdeo\xbe\xf9\xfe\xde{3y\x034\ +h\xd0\xe0$Cv\x82\x22\x91\xa4\xa2\xb4\xe4\xfa\x88\xf1\ +.\x80K\x00\xda\x00\xbc\xe0if\xb5\x93\x07\x90\x03\xb0\ +\xca\x84\xbb\x85\x9d\xb6\xb9Lf\xbc`u\x91\xa5\x00=\ +\xfd\x89n\x96\xf0\x05\x80v\x17\x92\xf4\x11\xca\x92\xc6\x1f\ +-\xce\xa6\x96\xaaE\xc9\xd5\xee\xd0=\x98\x18\x01\xe1\x0e\ +\x803\xae\xe6\xe6\x0fg@\x18\x0e\xb7w\xeem\xac\xaf\ +\xfdR)\xa8\xa2\x00\xdd\x83\x89\x110>\xf5&7\x1f\ +!\x8a\x86\xdb;\xf3\x1b\xebk+\xa6\xa7\xcd\x0e\x16m\ +\xbfXr\x90\xf1\x8c\x89G%\x89\x1e4cw3\x9d\ +N\xab\x1e\xa4{db\xb1\x98\xbc\x8b\xe6\xf3\x9a\xc6W\ +\x88i\x02\x84\xd3\xfa\xf3\xa4\xa1\xc7\xac\x1c\xca\x04\x88D\ +\x92J\xe8\xa5\xdc\xef\xd0\xd5<\x01?\xa9\xfb\x18Z\x9e\ +Km{\x92\xbd\xcbD\xfb\x12\xadr\x08\xd3\x0c\xbcu\ +x\x94\xb2\xfb\xff\xbc|\xd180J\xc6\x8b\x95\x96\x5c\ +\x1fJ\x07\xbc\xa7\xd0\x94\x0f\x8e\xcb\xc3\x03\xc0\xf2\x5cj\ +[\xdd\xc7\x10\x18\xcf\x0e\x8f\xf2k\xc5g+\xa1L\x80\ +\xe2Twx\x198\xb98\xfb\xe5\xdf^$\xea%\xcb\ +s\xa9m\x06%\xf5\xc7\x8c\xcf\x06\x98\x08\x80\x83y\xfe\ +0@\xa2\x07.\xe7\xe6\x1b\x92\xcc\xf3\xfa6\x01]e\ +1&\xd7\xb5\xe9\x1b\xcd\xd8\xddt9/\xdf0\xe6\xce\ +\xc09c\x8c\x99\x00%+\xbc\xa0\x8d\xf6\xb5`\x92{\ +\xd9\xea\xd5L\x80\x13\x85R\xef\x04\xec\xd0\x1b\x8b\x875\ +M\x1a\x05x\x00\x00\x88q\xaf\xa0I\x13?\xff\xf0\xd5\ +\x86\xd3{\x07\xde\x01\xdd\x037.h\x1a=\x04x\x18\ +\xc0)\x00\xa7\x98pM\x96\xb5G\xbd\xb1x\xd8\xe9\xfd\ +\x03-@$\x92T\xc0\xea\xf7\x00\xce\x9a\x9c>\xcb*\ +}\xe2\xb4\x8f@\x0b\x10j\xc9\xdd\x04\x95O]\x02&\ +\x0c:\xed#\xb0\x02\xf4\xf4\xc7;\xc0\x18\xf3\xba\x9f@\ +\x0a\x10\x89$\x15&\xba\x03 d\x11\x9av\xdaW \ +\x05\xb0\xb2~\x91=MRo;\xed+p\x02\xd8\xb5\ +>1\x8f-\xa7\xa7\xb2N\xfb\x0b\x94\x005X\x7fu\ +\xef\xe9\xb9\xcf\xdd\xe83P\x02\xd8\xb5\xbe\x04\xban\xe7\ +\x83\xa7\x1d\x02\xb3\x12\xec\xe9\x8fw\xb0M\xeb/\xcc\xa4\ +\xfet\xab\xdf@8\xa0\x1e\xd6\x17\xb8\xe2\x807\xdf\xf9\ +\xf0\x15E\xd2F\x0f\x17&t_\x92\xb4\x89\x85\xf4\xe4\ +\x13;\xd7\x87Zr7\xc1\xfeZ_\xe0\xd8\x01\xbd\xb1\ +xX\x96\xb5GL\xb8\x86\xe2Z\x1d\xe0aM\xa3\x87\ +\xdd\x037.X]_\xcb\xa8\xbfp\xffk\xd7\xac/\ +p,\xc0\xc1[\x9a\xf9Z\x1dP\xbf\x8bD\x92\x15]\ +VO\xeb\x0b\x5c\x18\x03\x0e^Q+p\xa9\xe9\xc5\xad\ +\x8f+\x9d\xac\xc7\xa8o\xc4\xf3A\x90\x89\xc6z\xfa\xe3\ +\x1d\xc6\xe3\xf5\xb6\xbe\xc0\xb1\x00\xc4\xb8g\x11\xd2\xc4\x12\ +M\xe9K!\x08\xd6\x178\x16@\x95\xd5[\x00\xf6,\ +\xc2JJ!\x08\xd6\x178\x16`9=\x95\x05a\xdc\ +*N\x94BP\xac/pe\x0c\xd8\xdfi\xbb\x0d\xc6\ +c\x8b\xb0&\x96\xe8[\x96\xa4i\x04\xc0\xfa\x02W\x04\ +\xc8d\xc6\x0b\xc4|\x1d\xd6\xa5\xf0:\xc0\x17-b|\ +\xb1\xbe\xc0\xb5Y`qv\xf2\x0f;\xa5`\x85_\xd6\ +\x17\xb8:\x0d\xda,\x85j\xf8f}\x81\xab\x02\xd4P\ +\x0af\xf8j}\x81\xeb\x0b\xa1\xa3\x96\x82\xdf\xd6\x17x\ +\xb2\x12Q\x18\x97\x19\x98\x07\xf0\x1c\xc0s\x06\xe6\x15\xc6e\ +\xbb\x9f\xcc\xbc\xc4\x97\xaf\xc2?\xce\xa4\xb6\x00\xbc\xedG\ +_\xb5\x12\x88\xaf\xc2\xf5\xc4L\x80\xbc\xbe\x11\x8b\xc5\xaa\ +\xed'\x0e4&\xb9\xe7\x8d1f\x02\xe4\xf4\x8d]4\ +\x9fw3)?1\xe6N\xc0\x961\xc6L\x80U}\ +C\xd3\xf8\x8a\xcby\xf9\x86\xa6\xd2U}\x9bQ>%\ +\x97\x09\xc0\x84\xbb\xfa61MD\xfb\x12\xad\xee\xa7\xe7\ +-\xd1\xbeD+\x81K\x16b\xc6g\x03L\x04(\xec\ +\xb4\xcd\x01X\xff\xef\x00\xe1\xb4\x1c\xc2\xf4q\x12Al\ +\x96.\xdd1N\xd9\xe2\xb3\x95P\xdbvyPR\x92\ +y>\xd0\xdb\xe5U\xbaJ\xe0\xf1#o\x97\x17\xfco\ +~\x98\x00@\xcc#\x8b3\x93\x9f\x99\x9d\xab8\xc5\xfd\ +\x95\xfdm%\xdc\xde\x99\x07Q\xd4\xbb\xd4<\x87\x19\x18\ +Y\x9a\x99\xbcU)\xa0\xea\x1c\xbf\xb1\xbe\xb6\x12~\xf5\ +\x8d_A\xd4\x85c\xf7\xdf\x10eI\xc3\xd0\xd2L\xea\ +\x9b\xaaQvn\xa5\xffm\x8e\x80\xae\xe2\xae\xeb\xc0\xfd\ +6G\xc0\x16\x03\x8fk\xf9m\xaeA\x83\x06'\x9b\x7f\ +\x01\x0f\x15\x0b\x99\x9e\x82\xdf\x92\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00\xf6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xa8IDATx\x9c\xed\ +\xd0\xb1\x0d\x800\x00\xc4@\xc2\x1e\x11\xec?\x15\x88A\ +B\xcb\x06Gaw_\xbd\xe5\xb1!\xae\xfbY\xdf}\ +\x1es\x08\x8f]\x9c\xfe\x89\x02h\x01M\x01\xb4\x80\xa6\ +\x00Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\ +\xa0\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00\ +Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\ +\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z\ +@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x05\ +4\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@\ +S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\ +/pQ\x04\x80fa\x99\xa8\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x06e\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x06\x17IDATx\x9c\xed\ +\x9a\xc9s\x5c\xd5\x15\x87\xbfs[12\x83LlP\ +\x00\xf5\x1bZ\x15o\xb01\x93\xc1\x98\xa4\x12,\x1c$\ +\x83m\xe5oa\x05\x8bd\x91\xf2\x82\x0d\xcb\xe4\xef\xa0\ +\x98\xca\xd6\x18FC\x85\xa4B\x80*\xaa(\xd4o\x90\ +)\x07\xc7\x0e\x96q,\x19\xeb\x1e\x16R;\xe2u\xab\ +\xfb\xbe\xee\xf7$Q\xe8[\xdew\xfa\xbe\xf3\xfb\xfa\xdc\ +\x1e\xa4\x86m\xb6\xd9\xe6\xa7\x8c\xb4Z<\x7f\xfe\xfcm\ +\x8b\x8b\xd7\x9fW\x91\x13@?pVt\xf9\xa50\x0c\ +\xeb\x1b\xdb^wDQTS\xa9\xbc\x00\x1c\x06\x16\x0d\ +\xbc\xb1s\xe7-/\x0f\x0e\x0e~\x9b\xadm\x12\xf0\xf9\ +\xe7\x17\xee\xe8\xdf\xb9\xf8\x16\xf0p\xe6\xd2e5\x8c\xd6\ +<\xef\xc3r\xda.\x86$I\x1e\xb3*\x93\xc0\xae\x1f\ +\x5c\x10>\xfeni\xf17{\xf7\xee]X\xbbl\xb2\ +\x1b\xf4\xf7_{\x81\xe6\xf0\x00\xbb\xc42QO\xd3C\ +E6\x5c$\xeb\x86\x07P\x1e\xdc\xb1\xa3\xff\xc5\xecr\ +\x93\x00DN\xb6\xb9\xc7\xc0V\x95\xd06\xfc*\x8a\x8e\ +g\xd7\x9a\x05\xc0\xce\x0e\xf7\x1a\x10\xcb\xc4\x5c\x9a>\x9e\ +\xb3\xc7\xd2H\x92\xe4`\xa7\xf0+H\x7fv\xa5I\x80\ +\xa2\xef9\xdcs\xc0X&\xb7\x82\x84\xd5\xf0St\x0c\ +\x0f@S\xb6&\x01}FN\x01\x97\x1d6\xdbt\x09\ +9\xc3/T\x0c\x7f\xca.6\x09\xf0<\xef\x0bkx\ +\x06w\x09\x9br\x1c\xdc\xc7\x1e\x80\x05\xb52\xeay\xde\ +\x17\xd9\x0b-?\x07\x00\xcc\xa5\xe9\xe3\xc62\x09\x0c8\ +\xdc\xe0\xb2\x11\xfd\x9d\xef\xfb\x7fs\xa8\xed\x998\x8e\x1f\ +U\xcc\x14p\xa7C\xf9\x15\xb5\xf2L\xadV\xfd\xa0\xd5\ +\xc5u\x05\xc0\xd6\x94Pdx\xe8 \x00\xb6\x96\x84\xa2\ +\xc3\x83\x83\x00\x80z\x9a\x1e\x12\xcb\x04\xee\x12\x8e\xfa\xbe\ +\xff\x91\xcb\xde\xaeD\xd1W\x8f \xcbS\xc0\xcf\x1d\xca\ +\xaf\xa02\x1a\x86\xd5\xb3\x9d\x0a\x9d\x04\xc0\xe6J(+\ +<\xb4\xfe \xd4\x92\x9a\xe7}\xa8VF\x81\x85\x8e\xc5\ +\xb0\xcb\xaaL%Ir\xd0u\xff\xf5\xc8\x1f\xde\x8c\xb9\ +\x86\x87\x1c\x13\xd0\xa0^\x9f\x7fB\x8cN\x00w8\x94\ +\x7f\xb3\xfa\x9a\xd0\xd5$\xe4\x0c\xff-jF\xc3p\xe8\ +\xfd<\xf7\xc8-\x00\xf2K\x10\xec\xd1 \x08\xfe\x9e\xe7\ +\x1e\x1b\x11\x1e\xba\x14\x00\xe5J\x88\xa2s\x0f#v\x9a\ +\x92\xc3C\x0f\x02\x00\xa2h\xfe0\xa2g(PB\xde\ +\xf0\x82\x19\x0b\x82!\x97\xef/-\xe9I\x00\x14+a\ +\xa3\xc3C\x8ew\x81\xf5\x08\xc3\xeaY\xd4\x8c\x01W\x1c\ +\xca\xefT\xccd\x14}\xf5H\xf6\xc2jx\xe73/\ +\xd8c\xbd\x86\x87\x02&\xa0A\x14\x9d{\x12\xb1g\x80\ +\xdb\x1d\xca\xff\x8bV\x8e\x86\xe1}\xff\x00\xa8\xd7\xe7\x1f\ +\x12\xa3\xd3\xc0n\x87\xc7^\x15\xecX\x10\x04\xef\xf6\xd2\ +o\x83\xc2\x04@w\x12T\xad\xdd\xac\xf0P\xb0\x00\xc8\ +)AYP\x14\x11q\xf9tYxx(A\x00@\ +\x1c\x9f\xfb\x95bO\xe36\x09.\x5c5\xa2\xc7|\xdf\ +\x7f\xa7\xa0\xfdnR\x8a\x00(TBi\xe1\xa1\x80w\ +\x81\xf5\x08\x82\xa1\xf7\x04{\x0ch\xfagD\x0e\xaeZ\ +\xd1g\xcb\x0a\x0f%N@\x838\x8e\x7f\xad\x98\xd3\xc0\ +m9\x1fz\xd5\x8a>;\xec\xfbo\x97\xd1W\x83\xd2\ +\x05\xc0\xaa\x045\x13H\xc7?\xb97X\xb4\xa2\xa3e\ +\x87\x87\x12\x8f\xc0Z\x96\x8dY@\xb8\xeeZ\xafp]\ +\x96\x8d\xcb\xd7\xee\x9e)]\xc0\x5c\x9a\x1e0\x96\x19\xdc\ +\xfez\x0b\x80\xc0\x80\x18\x9d\xae\xd7\xe7\x1f*\xb1\xb5\xc6\ +\xbd\xcacM\xf8=]nqI\xad<]\xabU\xff\ +Yd_k)m\x02V\xc3O\xd3}x\x80\xddb\ +tznn\xfe\xc1\xa2\xfa\xcaR\xca\x04\xa4i\xfa\xc0\ +\xf2\xca3\x7fWA[^\xb2\xcb22<\x5c\xfd\xb8\ +\xa0\xfdnR\xf8\x04\xe4\x0c\xbf\xa4\xaaK\x0eu\xbbM\ +\xa5\x9cI(T@\xce\xf0\xd7\xd42\xa6+\xff\x86\xfb\ +\x9fC\xfd\x9e2$\x14v\x04\x92$\xd9oUfq\ +\x0c\x8f\xcasaX\x9d\x05\xa8\xa7\xe9o\xc5\xf2&p\ +\xab\xc3c/Z\xc3\xc8\xb0\xe7\xfd\xab\x97~\x1b\x14\x22\ +\xa0\x97\xf0\x0d6KB\xcfG\xa0\x8b\xf0\xc7\xb3\xe1\x01\ +j\x9e\xf7\x96Z\x9e\xc3\xf58Xf\xe6\xd2\xf4@\xde\ +~\xb3\xf4$ I\x92\xfd\xd6\x8a\xf3\x99_\x0d?\xb3\ +^A\xad\xe6\xfd5\xa7\x84\xe9^%t}\x04n\x86\ +\x17\xeev(\xbf&\xc8\x89 \xa8N\xbb\xec]\xaf\xa7\ +O\x89\xe1M:\xff\x5c\x07\xe0?\x15\xc3\x88\xe7y\x9f\ +\xb8\xec\x9d\xa5+\x01q\x1c\xefS5\xb3\x8e\xe1\x17\x05\ +9\xee\x1a\xbe\xc1FI\xc8-`#\xc27\x88\xa2\xf9\ +#\x88\xbeA\x89\x12r\x09\x88\xe3x\x9fbf\x80A\ +\x87\xf2\x9e\xc27\xc8+\xc1\x88\x1e\xf1}\xffS\xd7\xfd\ +\x9d_\x04\xf3\x877\xceg\xbe\x1daX\x9dE\xe58\ +p\xcd\xa1\xfc.\xab2\x9b$\xc9~\xd7\xfd\x9d& \ +\x8e\xe3\xfb\x153K\xae\xf0CS\xaeM\xb8\x10E\xf3\ +#\x88\xbeN\xc1\x93\xd0q\x02\xf2\x87\xb7'\x8b\x0e\x0f\ +\x10\x86\xd5\x19AN\xe0:\x09Vf\x5c&\xa1\xed\x04\ +t\x17>\x98t\xa8\xed\x9a8\x9e\x7fZ\xd1\xd7Y\xf9\ +\x15{{\x94\x0b\xc6\xe8H\xbbIXw\x02V\xc2W\ +\x9c\xcf\xbc\x15\x1d/;<@\x10T\xa7\x059\x0e,\ +v,\x16\xee\xb6Vf\xe28\xde\xb7~I\x0b\xfe\x1f\ +^\x7f\xe1\xd0\xd3\x92\x15=9\xec\xfb\x13\x0e\xb5\x85\x91\ +w\x12D\xec\x91 \x08>\xcb^j\x12\x90\xa6\xe9\xd0\ +\xb2\xe5#\xe0\x1e\x87>6%|\x838>wT\xb1\ +\xaf\xe1\x22\x01\xbe\xbe\xd1g\x0e\xferh(]\xbb\xd8\ +t\x04\xac\xd5?\xf0#\x08\x0f\x10\x04CS\x829\x81\ +\xcbq\x80\xc1\xbe\x1b\xf6\x8f\xd9\xc5\x16\xbf\x16\x97\xa7\x1c\ +6[R\xd1\xf1\xcd\x0c\xdf`E\x82=\x89\x9b\x84#\ +\xd9\x85V/\x82\xcb\x1d6YR\xd1\xf1\x9a\xef\x9fq\ +ip#\x08\x82`\xd2I\x826gk\x12 h\xbb\ +guI\x0d\xbf\xdfJ\xe1\x1b\x04A0iE\xc7i\ +#A\x85\xd3\xd9\xb5&\x01\x95\x8a9\x05|\xd9\xe2\xf1\ ++\xe1=\xafi\x93\xad\xc2\xb0\xefO\xb4\x91P\xbf\xb1\ +\xa3\xefTv\xb1I@\xb5Z\xbd\xf8\xb3>\xf3\x04\xc2\ +\x9f\x81\x18\xf8Z\x91W\xd1\xca\x93[9|\x83a\xdf\ +\x9fP+\x87Q^\x01\xf97\x10\xa3\xf2\x97\xefv\xf4\ +\x1d\xda{\xef\xbd\x176\xbb\xbfm\xb6\xd9fk\xf1=\ +d)#\xc7\x02\xc7\xba\xcb\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x02!\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xd3IDATX\x85\xed\ +\xd5;\x8b\x13Q\x18\xc6\xf1\xff3\xf1\x86\x82\xd9NP\ +\x0b\x11[\xd1V\xc4r6\xcdjav\xb0qQ4\ +),d?\x81H\xf0\x0b\x88\x82\x8d\xd9 \xee\x16B\ +6.\xc8\x22\xce\xc6\xce\xc2\xda\xde\xc2J\xb0q\x89\xa0\ +x!\xe7\xb1\x98\x09\xd8\x99\xcb0)\xf4\xadN\xf1^\ +~\x9cs\xe6\x0c\xfc\xeb\xa1q\x92\xe2zc\x17P\x14\ +\xf9d\xda]\xfb\x5c$ \x1a3o\x01\xa8z\xa8\xed\ +\xc5\x95\x95C\xf3\x00\x00`q\xce\xdf\xf6\xf7\x92$\xd9\ +7\x17@\x1e\xb5\xddP}\x9a$I\xa5t\x80P0\ +Xpe\x10\xaa\x0f\x19\xf3\x0e\x15\x060\xb6$gk\ +n\xc5\x97\x1b\xadR\x01\x99\xc2\x06\x05\x00\xc4\x9d\xb8\xde\ +\x5c-\x17\x90+\x04!_\xdf\x8f\xeb\x8d\xab%\x03\xc0\ +`i\x84\xe0\xc9\xe2rs\xa9T\x00\x80\x8d3\x0b\x15\ +\xdb\xdd\xdar\xe3B\xa9\x80\ +\xe5\xfb\xcc\xfb\xdb\xe7}f_\x06\x8c1\xc6\x18c\x8c\ +1\xc6\x18c\x8c1\xc6\x18\xf3\xba\x90\xb2\x01i\x9a\xbe\ +\xadx\xc7\x81:\xcawQ\x14|+\x22ZAo\x0b\ +r.\xdf\x86p\x18\x00e_\x1c\x87g\xcb\xe4U0\ +\x80\xfc/\x85\xf7z\x96N\xdc\xbf7\xb3{lll\ +\xaelv/U\x95,k}\xa9p\xa8gyf\xfa\ +\xf6\xad7\xc6\xc7\xc7\xdb\x8b\xcd\xf5J7\x86\x143v\ +.\x1bY\xfeg\x92$+\xcaf\xff\xff\x1b\xaa\xb5,\ +\xcb\x8f\x16\x0e\x0f\x15\xbc\xc0\xd2\x01Y\x96\x8duU\xce\ +\x01o\x16J\x97\xbb\x1d\x7f\xcb\xea\xd5\xab\xd22\xf9S\ +SS\xcb\x1e<|t\x12\xd8Z(=\x12\xbc\xedQ\ +T\xff\xadL~\xe9\x01\x008\xe7\x1a\x88\x7f\x16XS\ +(\xddD\xfd\xadq\xbc\xea\xd2\x22sW\x22\xde\x19\x90\ +u\x85\xd2]\xc1\xfb(\x8a\xea\x13\x8bj\xb8G\xe9+\ +\x00\x10\xc7q\xe2{l\x108_(\xbd\x85t\xce;\ +\xd7*\xbe\xbd\xe7J\xd3t-\x9e\x7fa\x81\xc3_\xef\ +\xf8\xb2\xbe\x8a\xc3CE\x03\x00\x08\xc3\xf0\xee\xdc\xdc\xec\ +\x07(?\x15JK\x11\xfd5\xc9\xb2\xbd/\x9a\xe5\x5c\ +\xeb}\xc5\x9b@\x19\x9dWP.\xb6\x87k\xef6\x83\ +\xe0J\x15=CEW\xa0\x97\xaazY\x96\x7f\xa3\xc8\ +W\x0b\x94\x0fG\xa3\xc1~\x11\xe9>m\x7f\x9a\xb6v\ +)z\x0c\x18\x9aW\x10N\x0f\xf9\xde'\xf5z\xfdA\ +\x95\xfdV>\x80\xff\xa4i\xbeG\xe1(\xe0\xf7\xae+\ +\xfa3\xdd\xce\xa7\x8dFcv\xde\xfa\x93\xcf\xdc\x01\x85\ +\xaf\x8bY\x0aG\xe2\xd1\xe0\x0b\x11\xe9T\xddg\xdf\x06\ +\x00\xe0\x5c\xbe\x19\xe1\x17`\xe9\xfc\x8aN\xd4|\xef\xe3\ + \x08\xee\x00LNN\x0e\x8f\x8c\xac\xf8^\xd1\xcf\x0a\ +\x11*\xf0y\x14\x85G\xfa\xd5c_\x07\x00\xe0\xdc\x8d\ +w\x90\xee\xef\xc0\xca\xdeu\x85\xab\xbe\xe8\xe6v\xbb=\ +\xed\xd7\x86N\x81l*l\x9dE\xd9\x11\xc7\xe1\xe9~\ +\xf6\xd7\xf7\x01\x00\x5c\xbbvc\xd4\xafu\xff\x00\xd6\xbe\ +\xe0\x96i\xed\xca\x87\x8dFp\xa1\x9f}A\x85_\x81\ +gi6\xebY\xe7\xf1\xdcF\xe0\xdc\xf3\x9eU\xb8\xea\ +{\xac\x1f\xc4\xe1a@\x03\x00h6\x9b3\xf7\xef\xcd\ +l\x11\xf4\xc7g<\xf6\xf7p\xcd\xdb\x10\x86\xe1?\x83\ +\xeak W\xa0\x97\xaa\x8a\xcbZ\x07\x05\x0e\x16J\xa7\ +|\x8f]a\x18>\x1ctO/\x85K\xf3\x1f\x5c\x9a\ +?vi\xdeN\xd2\xfc\x90\xaa\x0e\xec\xdf\xf8\xcaP\xd5\ +Z\x92$K^v\x1f\xc6\x18c\x8c1\xc6\x18c\x8c\ +1\xc6\x18c\xcck\xe2_\xd1\x80\xf4\xd2\x90\x91\xe78\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03R\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x04IDATx\x9c\xed\ +\x9b\xbdO\x14Q\x14\xc5\xcf\x99\xac\x05l\xa9\x1b\xbez\ +\x1bY\x1a\xe2b!55\x9fF\x12\xb1\x93h\x02Z\ +\xc2_\xa05\x98\x08\xa5\x9aH\xc2g,\xa9\xb1 $\ +4,T\xd6,\x12\xb4\xdc\xa5`\x9dc\xe1\xb2;\xcc\ +\x0c\x1f\x22\xbbw7\xbc_\xb5\xf7\xdd;\xc9y'\xef\ +\xcdlq/\xe0p8n3\xbcJQ\xd7\xba\x92M\ +y\x8c\x80\x1a\x22\xd0)\xa1\x1d@\xa2\xca\xda\xfe\x95\x22\ +\x89\x9c\x80]\x88\xcb\xc7I,\xee\xf41\x7f\xd9C\x17\ +\x1b 1\xb3\x861Bo\x01\xb4\xdd\x94\xd2\x1aq \ +pj\xab\x1f\x9fA\xea\xbc\xa2s\x0d\xe8\x9e\xd7\x9dD\ +\xca\x9f\x058^\x1d}\xb5B\xf3\xc5#ob{\x9c\ +'q\xd9\xf8c,1\xb1\xea\xbf\x07\xf8\x22\x94\xc9J\ +\xfaFz?H\xf87-\xf5\x7f\x90\xe0I~+\xc9\ +\xc7\x00\xd2\x95\x0c\xc7\x13)\x1f\x90^\xc6\x9d\x84\xd8\x13\ +\x90Y\xd5\x18\xa1\x8f\x81\xa5_\x12'\xb7\x06\xb0p\xd1\ +q\xaa\x0b$fV\xf1\x94\xd4\x0c\x80\xbb\xe5e\xf0\xf9\ +\xd6\x00?\x85\xcb#\x06\xfc}\xe1\xe9;*w\xfeg\ +Q\xec\xda\x1e\xe4A\xd5DW\x81\xee\x15\xb5%\xa8\x1d\ +\x00\xf7JK\xb9\xe3$\xef\x87_\x8c^\xf8\xc1\xa6<\ +F\x10x\xe1I|\xddh\x9b\x07\x80\xedA\x1e\x10|\ +\x13Xjo.`8\x5c\x171\x00\xd4P \xcan\ +\x0d`\xa1\x0a\xfaj\xc2f?\xbe\x00\xc8\x9e\xc6\x82.\ +7\x80@g%\xd0F\xdd\xdf\xf9\x8b \x05j\xa3\x1c\ +\x0b\x0f\xc2%\x11\x03J\x7frJ\x81wX-m5\ +\xe3\xec\x1e:\xc2\xe9\xe8\x15\x08|\x1a\xeb\xedSw\x1d\ +B{\x88|\xf6\xe3\x0c\xb8U8\x03\xac\x05X\xe3\x0c\ +\xb0\x16`\x8d3\xc0Z\x805\xce\x00k\x01\xd68\x03\ +\xac\x05X\xe3\x0c\xb0\x16`\x8d3\xc0Z\x805\xce\x00\ +k\x01\xd68\x03\xac\x05X\xe3\x0c\xb0\x16`\x8d3\xc0\ +Z\x805\xce\x00k\x01\xd68\x03\xac\x05X\xe3\x0c\xb0\ +\x16`\x8d3\xc0Z\x805\xce\x00k\x01\xd68\x03\xac\ +\x05X\x13g@\xf1\xf4\x87\xd4\xf8\x06\x85\xf6P\x0c\xe7\ +\xa3mrD\xae\x12\xf8-\xd5\x91UC\xce\xeea?\ +\x9c\x8e\xb6\xc9\x01\xbb\x95\x80\xbd\x90\xae4SP\x97H\ +\x84\xd8[\x8e\x89\xbdpI\xf4\x88\x8b\xcb\x81(\xfdh\ +\x15#U\x11W\x03z\xd6\xf0\x04\x81\xceq\x82K\xe1\ +\x9a\x88\x01\xc7I,\x02(\xf7\x06\xfb\xd4l\xcfW5\ +\xdcUx\xb8\xa8VA3\x81\xa5\x5c\xa1\x19\x97\x1b\xb0\ +\xd3\xc7\xbc\xc0\xa9\xd3\x98@J\xbf\x95\xcd\xach\xb4!\ +\xae\x83\xc4\xcc\x8aF\x99\xd0\x0e\x81Ty\x19\x9c\x8e\x1b\ +\xa1\x89\xdf\x90\xc4\x9e5\xffC\xcc\xb4H\x16\xd4\x06\xe4\ +\x1d\xd6[\x17\xa9\x04\x0f\xf4[Jw>\x1d\xcc\x11\x9a\ +\xdb\xec\xf7^\xc5\xf5=\xc7O\x8c\x90*\xcek\x22\x91\ +\xf2\x112!\x0d1\x0d\x08\xaa\xc7\x16\xea\x98\x03Jh\ +\xee\xe4\xc8\x9b<\xaf\xe9\xfb*CS\xcf\x08\xbdC\xe3\ +\x0dM\xe5\x04N_{h*H\xd7\xba\x92\xcd\x05\x0c\ +\x0b\x1a.\xb5\x9cw\xa0\x0e\xc7\xe6\x00\xec\x83\xd8#\xb8\ +Th\xc6\xd2U\xc6\xe6\x1c\x0e\xc7\xed\xe6\x0f\xfd[\xf6\ +\x1a<\xff\xdaG\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x00\xf9\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xabIDATx\x9c\xed\ +\xd01\x15\x800\x00\xc4P\x8a\xb7*\xc0\x02\xb2\xb0\x80\ +\x02\xc4\x95\x15\x07\x9f!\xd9n\xba\xbc\x8c\x0d1\x8fs\ +}\xf7s_Cx\xec\xe2\xf4O\x14@\x0bh\x0a\xa0\ +\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z\ +@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x05\ +4\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@\ +S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\ +\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\ +\x00-\xa0)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\ +\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00\ +-\xa0y\x01U\xd1\x04\x80\x1e;\xba\xea\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x00\xa6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00XIDATX\x85c\ +`\xa0\x00\xdc\x7f\xf8\xb8\xe1\xfe\xc3\xc7\x0d\x94\x98\xc1D\ +\x89fj\x80Q\x07\x8c:`\xd4\x01\xa3\x0e\x18u\xc0\ +\xa8\x03\x06\xdc\x01,\x14\x9b\xf0\x9f\xc1\x81\x92*y\x18\ +\x84\x00#\xc3\x01Ey\xd9\x06r\xb5\x0fx\x08\x8c:\ +`\xd4\x01\xa3\x0e\x18u\xc0\xa8\x03F\x1d0\xe0\x0e\x00\ +\x00\xe6\xf7\x0c\x89pwv\x17\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00u\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00'IDATx\x9c\xed\ +\xc1\x01\x0d\x00\x00\x00\xc2\xa0\xf7Om\x0e7\xa0\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80w\x03\ +@@\x00\x01\x8f\xf2\xc9Q\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x00\x8d\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00?IDATX\x85\xed\ +\xd3\xb1\x11\x00\x10\x10D\xd1\xa5\x10\x94\x22\xd1\xb5\x19\xad\ +\x18\x0a9\x91P\xea\x92\xff\xa2\xcd~\xb4\x12\x00\xc0Y\ +\xb8c\xae=d\xaa\x7f\xb2\xd6KNM\x92\xe2\x9f \ +\xf0\xc6\x0b\x00\x00pw\x00\xa4L\x0e\x07\xff\x04Y\xb9\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00w\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00)IDATX\x85\xed\ +\xceA\x01\x00 \x0c\xc4\xb0\x0dS\xb8\x9eD@\xc6\xf1\ +H\x0c\xb4U\x00@X\xef979\xb0\x92q\x00\xe0\ +\x0b\x0f\xd3\xb2\x02\xe6j\x84F\x98\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\xce\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x80IDATX\x85\xed\ +\xd2!\x0e\xc2@\x14\x84\xe1\x7f\x96;\x90p\x13\xe4\x9e\ +\x81\x0b 0\x1c\x09\x81\xc6\xd6\x22\xeb8\x0aI\xef@\ +\x07\xd5&\x0d\x09\xae[3\x9f{o7\x99\x11\x0f\x22\ +\x22\x226\xa6\xc5d\xab\xf6\xec\xd6\x0c\xec+\x1f$\xff\ +\x148v\xae\xb6\x1f\xc0a\xcd\x02\xc0P\xd0\xf9u\xd2\ +\x13\xa0L[\xdb\xb7\x06\xe1\x00\xfb\x11\xdf\xa7\xa1\xfc\xfb\ +\xd9\xc2\x5c@\xd2\x15x7\xc8\x1c<\xea2\xe7.\x9e\ +68\xc2\x88\x88\x88\xcd}\x01^\x93 \x047\xe4\x99\ +\xec\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\xbb\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03mIDATx\x9c\xed\ +\x9b\xbdo\x131\x18\xc6\x9f\xf7.\x15\x13\x08\xa6\x225\ +\xc4\xbd\x88\x05\x06@\x82\x85\x1d\xca\x00b\x80\xa1\x0b\x12\ +\x7f\x01\x1f\x1b\xb4\x03\x08$>\xc4\xc4\xc7_\x80\xc4\xd2\ +\x01\x06\x04\x03\x85\x9d\x05$\xca\xd0nw\xe7$\x1d`\ +\x00\xc4V\x91\xe4aH$.w\x17h\xe3\xbb\xb8\xa5\ +\xfem~\xfd\xc6y\xfc\xc4g[9\x1bp8\x1c\xdb\ +\x19YO\x12\xc9\x8a\xd6\xad\xb3\x14\xce\x0a\xe4\x18\x80)\ +\x00;\xca\x95\xb6a\xd6\x00\xac\x12\xfc \x94\x05\xa5\xaa\ +/E\xa4\xfd\xaf\x0f\xfd\xd3\x00\xad\xf5IB\x1e\x01r\ +\xa0\x10\x99\xe3cY\xd0\xbd\xaa\x94z\xfb\xb7$oX\ +\x05I\x89\x1b\xady\xc2[\xdc\x82\x9d\x07\x80\x83\x84\xb7\ +\x18\xe9\xd6\x1c\xc9\xa1?\xf4P\x03tsu\x0e\xe4\x9d\ +r\xb4\x8d\x0f\x01\xef\xc6\x8d\xd5\xeb\xc3\xebs\xe8\x0d{\ +o1\x15\xfe\x0e\xe2\x06\xd0y\xad\x94j\x88H\xa7P\ +\xa5\x86\x90\xf4\xb5\xd65\xc0?\x0d\xc1m\x00{\x92\xf5\ +\x82\xeeL\xde\xe3\x901\x80dE7\x9a\x9f\x07\x87=\ +\xdfu;\xed\x0b\xf5z\xfdK\x09\xda\x0b'\x0c\xc3I\ +\xcf\xaf<\x03\xe4D\x22\xbc\xacj\xd5\xc3\xe9\x891c\ +@\x1c7\xcfA\xf0<\x11\xfa\xd6\xfe5q`\xff\xfe\ +\xbd_\xcb\x12\x5c\x06=\x13&V\x90\x1c\x09\xc4\xf9\xe9\ +\xe9}/\x92y\x999\x80\xc2\xd9\xc1\x00nn\xb5\xce\ +\x03@\xbd^\xff\x22\xc0\xcdd,\xd37\xe4\x18\xd0_\ +\xe7\x13t^\x17-n\x5c\x90\x9dW\xc9\xb2@\x8e\xa6\ +s\xf2V\x81\xa9dA)\xd5(X\xd7\xd8\xc8\xd1^\ +M\xe7\xe4\x190\xb0\xc3\xdbl\xb3\xfdF\xc8\xd1\x9e\xd9\ +\xbd\x0e\xdd\x07l\x17\x9c\x01\xb6\x05\xd8\xc6\x19`[\x80\ +m\x9c\x01\xb6\x05\xd8\xc6\x19`[\x80m\x9c\x01\xb6\x05\ +\xd8\xc6\x19`[\x80m*E4\x126\x1a3\x1e\xe4\ +\x01\x88CX\xe7\xbb\x06\x03\x08`\xa9+\xbcV\xaf\xd5\ +\xd2\xff[n\x18\xe3\x11\x10\xe9\xd6E\x8f\xf2\x06\xc4a\ +\x94\xdfy\xf4\xbf\xe3\x88Gy\x13\xe9\xd6E\xd3\xc6\x8c\ +\x0c\x88\xa2h\xb7\x80OLE\x8c\x8a\x80\x8f\xa3(\xda\ +m\xd2\x86\x91\x01\x22\x95\xe3\x00v\x9a\xb4a\xc8\xae\xbe\ +\x86\x91\xd9\xf6\x93\xa0\x91\x01d\xfb=\x80\x9f\x05i\x19\ +\x85\x9f}\x0d#cd@\x10\x04?\x08\xb9l\xd2\x86\ +\x09\x84\x5c\x0e\x82\xe0\x87I\x1b\xc6\x8f@\xa0\xaaO\xbb\ +\xc2S\x00>\xa1\xb7D\x95\x0d!X\xea\x0aO\x05\xaa\ +\xfa\xd4\xb4\xb1B\xf6\x01\xfd\xf5\xd8xM\xb6\x81\x9b\x04\ +m\x0b\xb0\x8d3\xc0\xb6\x00\xdb8\x03l\x0b\xb0\x8d3\ +\xc0\xb6\x00\xdb8\x03l\x0b\xb0\x8d3\xc0\xb6\x00\xdb8\ +\x03rbk\xc9\x02I\x7fLZ\x0a'G\xfbZ:\ +'\xcf\x80\xd5d\xa1w\xfctk\x92\xa3\xbd\x95\xce\xc9\ +\x1e\x94\x04?\x0cF\xfc\xd3\x85\xaa\x1a#\x22\xfe\x99d\ +\x99\xe0\xc7tN\xf6\xa0$ea0\x80\xdba\x18N\ +\x16\xae\xaed\xc20\x9c$p+\x19\xcb\xf4\x0d9\x06\ +(U}\x09p%\x11\xda\xe3\xf9\x95g[\xc9\x84?\ +\x87\xa5\x07N\x8c/\xf7\xfa6Hv\x04\x88\xb4\x05\xbc\ +\x92\x8a\x9e\xf0\xfc\x89\x15\xad\x9b\x97\xe28\x0e6\xe3\xc4\ +H\xd2\x8f\xe38\xd0\xbay\xa9wHz\xe0\xa48\x04\ +\xdd\xabyWh\x86\xbe\xca\x8a\x1b\xad\xf9\xff\xe1\xc2\x04\ +\x00\x102\x1f\xa8\xea\xbd\xbc\xba\xa1\xfb\x00\xb5o\xea\x1e\ +!\xf3\xe5\xc9\x1a\x0b$07]\x9b\xba?,a\x9d\ +\x97\xa6\xbc\x87\x00\x0e\x16*\xad|\xd6uij\x94k\ +sG\xd1;u\xbd\x19\xaf\xcd\xb5\x08~\xdc\xc8\xb59\ +\x87\xc3\xb1\xbd\xf9\x0d\x9c\xbe \xb7\xf5\xf6\x9b\x02\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\xcc\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00~IDATx\x9c\xed\ +\xd9A\x0d\xc0 \x14\x05AZMx\xc2Oe\xd5\x14\ +\x95\xb1M\x981\xf0_6\xdc\x18#4\xd7\xb3\xe7z\ +v\xb9\xe1.\x8f\xff\x81\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\xda\xf1\ +\x01\xae\xf2x\xfd5>F\xff\x02\xde\xf8>\x00\x00\x00\ +\x00\x00\x00\x00\x9c\xe0\x03\xda\xaf\x07\x8e\xa0\xaf\x15\x04\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02*\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xdcIDATX\x85\xed\ +\x95\xbfkSQ\x14\xc7?\xdf\x9bhJ\x07\xab\x06*\ +\xb5\xab.\x82T\x92\x06Q\xe9l\x8b\x9dD\x07Qp\ +2?\x14+\xfe\x05!\x9b\x93\xc5\x18\x85f\xea\xe6\xe2\ +\xa0\xa0T\xbb\x05\xecR\x1a\xd4\xbf@\xa7\xaa\x83\xe2$\ +\xb4M\xeeq\xc8\xb3\xa9i\xaa\xcdk\xc4\xe5}\xe0\x0d\ +\xef\xde{\xce\xf9p\xee\xbb\xefBDDD\xc4\x7fF\ +a\x03\xcf\xe4\xef\x8f\xae[\xfc\xa5`\xac\xb9O\xa3o\ ++\xb7W\xc3\xe4qa\x82N\xe7\x1e\x1c_\xb7\xf8\x1b\ +\xc1\x18\x80\xdb\xb0\xa5\xd4\xcdG\xc7\xc2\xe4\xea\xb9\x03\x99\ +\x1b\xb3\xa7p\xb1\xd7\x06\xc3\x1dS_\x1c\x9c_\x9e\x9b\ +y\xdfK\xbe\x9e:\x90*\x94'\xcc\xc5j\x06\xc3\x18\ +\x064[\x8f\x0c8\xe2\xa1\x96*\x94'\xfe\x89@*\ +_\x99v\x9eE\xe0\x80\x81!|{\xd6\xbc\x99\x0c\x18\ +r\x9e\xc5t\xb6|\xa1\xaf\x02\x99\xdc\xc3k\xce\xfc3\ +`\x000\xb1\xb5x\x0b\xc9|\xd0\x95\x01\x89\xe7\x99|\ +\xf9\xeanr\xc7\xfe\xb6 \x9d-\xcf \xaa\x81\xac\xd1\ +\xa5x\xdb\x02\xc3\x10\xc2\x01\x17G\xc6'\xbf}\xaa\xbf\ +Z\x0e)`J\xe7\x92%\x89{\xc1\x80\x0f\x04\xfe\x8c\ +0\x13\x08$4u43\xa9\xd5\x95\x85\x1a\x94vX\ +\xde\x8db\xd1\x8d\x7fN\x96\x81[\xb4\xaaz\xed\xa6\xf8\ +V}LB.x\xa9\xac\x8c|\xbdC\xa9\xb4}\xeb\ +:\x07N\x5c.\xee\x1f<\x9c\x9c\x07\xae\x00\x98\xf0\xb2\ +\xde\x8aoJ\x08\xc96\xbf\xb3'f\x89\xeb\xf5jn\ +cG\x81tvnPn\xed)\xc6\x14\x06&\xf3j\ +\x1d\xb1\xd0\xfc\xd6\x09\xb1`>q\xa9^\xcd\xfd\xd8&\ +p\xb2\xf0\xf8P\xc2\x1a/0\xce\x06\x81{.\xde\x96\ +@j\x9f\xb8\xa5\xc6Zs\xfa\xdd\xfc\xdd\xef\x00\xf1_\ +\x8b\x12\xbe\xf1\x01\x18j\x9b)\xd4o\xba\x1b\x1d\xfb|\ +.\x9e\x88\x7f\x04\x0eB\xc8\xbb`\xef\xf4\xa5\xb1\x11\x11\ +\x11\x11\xfd\xe1'h\xea\x98\xa0^nC\xde\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x02\x22\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xd4IDATX\x85\xed\ +\xd61k\x14A\x18\xc6\xf1\xff3\x17\x8d \xd1t\x1e\ +\xde\xed\xad\x1c\x96\x82\xb6\x16\x96\x92&V\x226\x82\xb6\ +\x16\x92O \x22~\x01Q\xb0\x16\xb1\x10\xc4\xee\x10\xc5\ +\xd2\xc2Z\xb8RHv7\x91\xb3Q\x03\x11\x8cr\xf3\ +X\xec]Zo\xef\x96M\xa1\xd3\xec.\xcc;\xcfo\ +\xdf\x9d\x81\x85\x7f}h\x96I[Y\xfe\x0d\xa4V\xa0\ +\x9f$\xc9\xd7:\x01a\xb6iZ\x05N\x8e#\x83\xd1\ +ht\xfc\x10\x00\x07\xe3\xe2\xfe\xfe\xefW\xc3\xe1\xf0\xe8\ +\xe1\x00l\x0ck++\xab\xcfl\xb7\x9a\x07\xa0(a\ +\xe3\xebY\xb6\xf3\xd8\xf6L{\xa8>\x80p4.\xef\ +};+v\xee7\x0b\x00\x04\x06G\xdb`\xdf\xcd\xb2\ +b\xa3Q\xc0\x84a)D\x00\xc3\xc3,+n4\x0c\ +\x00\xb0\x91\xa6\x88\xa7Y\xb6\xbd\xde0\x00\xb0M\xb9'\ +Z\xc6/\xf3<\xbf\xd4,\x00@D\xb0\x81c\xd1\x1a\ +lnn_h\x16P*\x22`\xe0\x84\x02o\x8a\xa2\ +8\xdb0\x00\x8089!\xa7\xc6Q\xef\xf2 \ +\xc8\xf2\x09\x83zd1p,\x19\x14\xf0\x05\x90B$\ +\xd2@4\x0e\x8c\x09D\x9c\x0b\xa6\x02\x00\xc9\xe1\x142\ +\xb0\xcd\x02Z\xdaX\xb7v\xdfH\xfc\x1fQ\x00fK\ +e7+\x0am\x06p\x85\xb6\x8d\x81c\x00\xde\x14D\ +[\x03\x81\x81\xb7Z7m8\x12\x8d\xee\x5ciY\xf2\ +\xa8@\xffL\x82\x98\x0b\xe2\x22=\x1b\x00N\x01X\xdc\ +\x5c\xe7~}X7\x80\x11\x04 \xdfQ\xb6\x80\x88\xd6\ +\x01H\x0cq\x8a\xe89\x9b\xcd\xfa\xcc_^[\xd3;\ +\x5c\xfdjH\x92d\xebS\xd2\xca\x01<\x0e\xe0Rm\ +;\x01O\xe7N\xcex\xbc\xb2\xb2R\x89Vw\xd4\x01\ +p\xb9\x5cb\xfb\xbe\xee\xa7\xc0\xfc\x98\xa6I\x01c\x9d\ +\x15\xa8l\xa8w\x1f\x8eV\xaf\x19\x14\x15-N9a\ +\x15\x8f\x10\xe1\xe7\x00.T\xb71h\xb3_$,\xf4\ +z^8\x1e\x8d\xce\xa8\x02\xe0r\xb9\xc4\xf6\x0f\x0f\xd7\ +\x82\xe8n\x8d\x96nA\x5c\xdc\xe8\xa9~?\x1a}\xc3\ +E\xa1\xc39\xd6O\xd8\x84\xd0\x09w\xb75\xe9\xe4\xf4\ +\x86\xda\xda~\xb3\xba,\xd1\x18\xb6\x8d\xbe\xae\x12D\x0f\ +i\xc4\xef\x09\x16\xb3\x1a\xeb\xdc\x07\xa3\xd15\x12|\xbc\ +\xbf\xbd\xff\xb2\xc9\xb7\xbd\x9a\xa0\xf8\xae!\x0aZc\x5c\ +\x11\xf0'd\xe7L\xce\xfcsGG\x87\xa9/\x84\xe9\ +\x00\xd8\x1d\xce\x1f\x82\xb0Z#~YN\xf1K\xad\xaf\ +W\xf7\x99\xd5\x13+\x1c\xeex\xcf\xdf\xb9\xbf}S\xe6\ +\xa4\x1bO\x80(\x1f\xa7G3\x01\x13N!9\xa9\xb3\ +\xa3\xbd\xc5\x8c\x1eS\xaf@A\xc9\xe2\xa9\x80\xd8\x06 \ +I%~\xb5\xb9\xce}\x1f\xe2\xb0:\x8b\x16\xf9\x0e\xe7\ +\xcf\x88\xb0R-c\xc2\xfd-\x1b\xdd\x1b\x22\xf5\x8d\x18\ +\x80Y\xc5\xf7\x8d\x16\xc2\xf6\x0f\x00\x19g\xb5\xe3}9\ +\xd5\x7f\x9b\xb7\xa6\xe6TT\x8e\x16;'\x91\x05\xc5\xcc\ +\xb8\x9e\x80\xb1\x18\xfc\x05\x00\x1c&\xe003\xda\xc9\x82\ +\xfaa\xec\x01\xa8\xc0\xe1\xac\x06a\x91J\xe6\x13,r\ +\x1b\xeb\xab\xda\x0d;Ft\xba\xa4\xbc\x9a\xc0\x8bU=\ +\xba\xe1Snj\xde\xb2\xae\xdb\x8cg\x83\x9f\xb0\xf4\xa5\ +\x00/\x010\xd1L\x1f\x00\xbb\xc1\xf4\x5c\xba\xa5\xef\x15\ +\x8f\xc7\x130\xd3\xa1\xb0\xf0\xe1D\xff\x05'\xdf\x06p\ +\xeb\x90\x8c\x81v\xff\x91\x8c\xefz\xbd\x95\xfep\xfd\x84\ +\x91\xd2|\xa9bZ\xd0\xcd\x03\xcc\x0aJ\xcc\xde\xbc\xbd\ +\xa4\xec\xae>%m\x1f\xc0\xab`\xfe\xe6\x01\xe0F\x10\ +\xaf\xefS\xd2v\xda\x8b\x9d3\xcdthhX=\xa0\ +\xc8p\x80\xf1\xf5\x90\x8c\x80)\xb6\xd1_\x92\xb5\xbe\x8f\ +\xd3r\xf4\xbe\x02)AF\x80\x08{}:\x97\x93_\ +0\x18c\x0d\xdbG\x85\xf8\x9e\xa2\xa5D\x0c\x80`\x0e\ +\x9bc;\xbd*\xd3\xcb\xd6\x9e+\x18\x06\xc0[S3\ +\x00@\xbd\x13\xb4I\x92\xa4\x9e\xe0u\x03\x10\xb4E\xf6\ +\x0b\x11v\x03\xd2\xd6\x06\x11F\xc7\xb9\x01!a\xa4*\ +B\x9c'\xc6\xb1 \x02s\xc8\xb0\x19\x82\xd7[\xe9'\ +\xc0p\x85\x18W(0\xcc>O/-M\x04`U\ +\x89|\x1e\x8f\xc7\xa7\xe6\x84\xae\x03\x06Oj\xcf^\x03\ +\xe9FF\x98\xf1EdO\xe3\x03\x22\xe3\x00Xz\xac\ +i\x1a\xd11-'4\x00\xc0\xa7\xc1VBgNM\ +\xfb^\xc3\xf6\xf8\xc2\xd8v\xa2rm\xd05\xa3KK\ +\xd1[\x07\xecW_\x12\xc8p\xb1\x01\xa6z\xc3\xf68\ +\x82X\x18\xda&\x16A\xbe3p@\xcb\x09\x09\x80`\ +\x04\x1d620M\xcbQCN\x95\x9b\x00Du\x1a\ +\x13#|\xdaX_\xb5\xdb\x88 \x98\x83}\xd7\x19\xad\ +!\x01\xf0Ym;\x00\x9cI\x1f\x110\xa5\xd0\xe1\x0c\ +\xfb\xb9\x19\xcc\x0cS\x8d\x09\x87c\x0bB\x15\x0cR\xf2\ +.\x97K0hN\x90\x90\xe1\xd5\xf2B\x02p\xfal\ +m\x87Z\xe6'\x8d\x22\x0d\xac\xc2\xff$\x80\xa3\x86\x0e\ +\xc7\x16\x9f\x1f\xa7\x94\x95F\x84w>\xec\xceA\xd0\x1a\ +\x85\xfa\xfd=\x19;\xb5<\xddo8\x01\x9a\xed\xafR\ +dd\xac\xc1\xb3\xfe+\xa6\x88\x19\xa3Xb\xf9\x0e\xcf\ +\xca\x93F\x04\x12Z\x9f\xf9-\xbd\xf4\xb8n\x00XV\ +j\x01\xa8\x8e\x9aif\xa1\xb4\xc8p\xc7\xe7\xffz\xec\ +*\x00\x8dF\x9c\xd8\x80^i\xaes\xd7\x1a1\x5c.\ +\x97 &\xed&\xede=\xaen\x00\x9a\xb7\xac\xeb&\ +B\x93J\x94(+V\xedqx\x10\xbc\xdeJ\xbf\x1c\ +\xf0\xdf\xcd@<\x0fI\xdf\x93S\xe4\x0aD8\x8e\xdb\ +\xb1\xaf\xfb\x1e\xa8\xce!\x08\xf8R>\x92\xd1\xa4\xc7\x0d\ +\xbb\x8ce\xf0\x1f\xd4\xd7\x04~h\xa6\xa3\xecj#\xc3\ +\xde\xcd5}\xcc\x81;\xe2\x14\x84\x9d\x8a\x8c\xbb\x22\x1d\ +\xc7I\x92dc\xe6_\xabe\xcc\xbc2\xdc\xe9P\xd8\ +\x004o\xac~\x9b8h2\xb4Y\x08OD\xf2\xb2\ +\xb5~}\xa7?\xe0\xbf\x05 \xdd\x88\x0f\x0b\xcc\x7f<\ +.R\xf2\x22%f\x01\xa0WI\xad@\xf0\xb6\xb7'\ +\xd9\xcfk\xc2\xf1\x8d62\xac\x08,\x0f\x16\xd1}v\ +\xc9i\xb8\x07\x07\x06G\x82|\xe4[w\x82\xe8\x97\xac\ +\xb3\xfc4\x0d\xc6\xd7\x00-m\xae\xaf^\x10i\xd2\x03\ +\x80\xe9\xf7T\x8c!\xd0\xaf4:~\xb3e\xcb\xba\xb0\ +>\x18fV;;\xda\xbb2\xbf\x9d\x93\x09\xe0;\xa7\ +E\x04F\xe1\xb8\xeb\xa6\xbcv\xe8`\xfb7F}\xbb\ +\xba\xda\x94\xce\x8e\xf6w\xc7O\xbc\xb9\x9aH\xb9\x10@\ +\x16`z\xf7v\x94\x80Ul\x11?h\xd9\xb8\xf6]\ +3\x1d$I\xb2\xc9r\xe2V\xd0\xd9\xb4\x17\x01{z\ +\xc6\x88\xb2\x7f\xee\xda\x15\xb6v(\xe2\xe9\xb0\xbdx\xc9\ +\xa5l\xf1\xef\x01\xe32\x95x\xbb\xf5D\xf2\xcc\x86\x86\ +\xd5\x03f\x9c\x03\x06S\xe7\xa7\x92\x94\xdb\x05\xa3\x84\x81\ +l\x0cf\x91\x87\xce\x0d\xbf\x02\xa8\x1b\xcc\xed$\xc8\x93\ +F}\xad\xda][$\x14\x948\xd7\x00X\xa2\x12\xc9\ +B\xf0\xb4He;\xa6\x0a$\xf2\x1d\xce[\x88\xe0\x85\ +\xaa\x22\x8cA\xebZ\xea\xd6:1\x82\x02\x89\x5ciY\ +r\xfaq\xbf\x12M \xf5`\x9f_\xfe 3?\xaf\ +\x96\x11\xc3\xd9T\xef\xae\x8e\xd4\xd7t\x91T\x81\xa3l\ +!\x88\x82*.\x18\xa8\xbaH\x1c}8\xda\xa7\x15C\ +\x90\xbd\xc4\xf90\x03+\xa1\x9a\xcf\x88\xb0\xaai\xa3{\ +\x99\x19\x05\xa6k\x84:\xf7\xef\xde\x93\x99\x95s\x01\x80\ +\xef\x9d1\x04\xe4\x9cR\x92\xf2\xae\xbaa\xea\x1b]{\ +w\x9d\x88\xc6\xf3\x91B\x92$[\xc6\xa4[_\x02\xb0\ +\x1c\xc1\x0f\xb2Q>\x92\xb1\xa8\xab\xab\xcdT\xcd`T\ +\xe9\xact\xea[\x8e\xc1\xf2\xb4\xb3 \xdc\x96\xe0\x0b|\ +\x90/UdG\xa3k$\xb0\x17/\xb9\xb4/\x90\xda\ +\x0a\xa0L\xd3\xb4O\x0e\xf8\xef6\xaa\x08\xd1\x22\xeaB\ +II\x92,\xbdJ\xfa\xef\x09\xac\x1db2\x805\xa4\ +X\x9fn\xda\xf4\xe2\xbf\xa3\xd5k\x06\xb9\xd2\xb2\xe4\x14\ +\xe5\xd8\x8f\x99\xf1\x18\x08\x17\x05\xb7r\x03\x0b\xcb=-\ +\x9e\xaa\xa86e\xc3.\x95\xb5;\x9ceLX\x83\xd0\ +O\xdbq\x22\xd9\x14m\ +0$I\xb2\xf5\x04\xd2\xf3\x04\xf1\x5c\x00\xf3\x00\xe8-\ +\xc3eb,53\xdb\x87\xc3\x88\xcb\xe5\xed\xf3\x16]\ +\xc9V\xcb*\x00\x0e\x03\x9aL@\x1b\x13\xfe\xcaL\x07\ +-J\xe0cV\xb8'aT\xd2q\x85\xfa\x03\x03\xbe\ +\x94\x14\xc2@\x1a\x05\xc48A\x98\xc0L\xb9 \x9a\x0d\ +p\xaa\x81\xce\x0fH`i\x93\xc7\xbdk$\xfe\xc7\xec\ +\x0f\x13\xf6\xf9\xe5\x85\xcc\xfc[\x0c.r\xe2\x07B7\ +\xc0O\xa6S\xbf{8C>T]\x0c1XL\xdd\ +=\x0f\xc4\x8f\x01\xb8)\x96\xba\x01t\x02X!\xa7\xf8\ +\xab\xa3-\xd04B\xdc\xfe45\xbb\xa4<\x8b\x81R\ +\x06\x17\x01\x980\x1c\x1d\x04|\xa9\x80\xde\x14\xac\xbc\x9c\ +\x9b=\xf6\x9d\xe1\xfc\x1f\xc0\x84\x8d\xf8\xc3>o\xd1\x95\ +J\x82e\x06\x81\xb2\x00e\x22\x98\xc6\x01H\x03\x90\x8a\ +\xc1\x93\x9b\xa3\x00\xfa\x01\xfa\x1c\xe0\x03\x0c\x1c`\x11h\ +k\xf5\xac\xdf\x8f\xff\x82Z\xe4\xf38\x8f\xf3\xf8\xdf\xc5\ +\x7f\x00\x80\x02\xea\x80\xb2\xb7\x05\xfa\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x01\xa5\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01WIDATX\x85\xed\ +\xd2\xcd+DQ\x1c\xc6\xf1\xef\xb9\x93\xd2()\xe5e\ +\xc7\x7f \xf7\x92\xb2\xb3\x9a0;e5V\x9a;\xc2\ +\x88\x8d\xdd\xacd\xa5\xa6\xb9w3#y\xa9YXX\ +)%\x1bE\x22\xae\xa2\xacm\x94l\x88\x14\xa9;\xf3\ +\xb30\x0b\xd4\xb83c%\xe7\xb3<===\xa7s\ +@\xd34M\xfb\xefTP\xc0\xb23+`\x98\xa8b\ +\xcc\xcb\xce\x5cUR\xda\x97Hw\xf8\x12\xca\x83z\xf2\ +rS\xc3\xa0\xa4\x5c\xd6\x08l\x13\x9a@\xba\x10u\xd4\ +\x9dp\x07\x82\xe2\xdd\x13\x19\xd3\x97\xd0\x09\xd0\x0f4\x07\ +\xe5\x03\x07\xd45\x14b\xc0\x16\xd0h\x88\xecZ\xb63\ +V.k\xc6\x9d!\xa3\xa8\x0e\x80V`\xdf\x7f\xf3#\ +?\xdd\xbe\xa2\x01\xc7\xe9\xb9W\xaf\xed~TPK@\ +\x1d\xb0\xd1c;)\x90/\xcfg\xdanB)\xb6\x81\ +0H\xfe\xe5\xe1>r\xb1>\xfb\x18\xd4\x1f\xf8\x07>\ +\xb3\xe2\x99I\x94r>\x86\xcb\x9aH\xbd}\xde~[\ +\xb0\xee\x9a\x17\x81\xf9R\xe1\xc2Yn:\x15t\xf3\x9a\ +\x06\x00\xf4\xd8NT`\x13\x08+8\x14\xd43\xc8 \ +\xe0\xa3\xb0\xbdlr\xb5\x9a\xbe\xaa\x07\x00\xf4\xda\xae%\ +\xc8\x8e@K\xe9\xe8Y\x84\x91\xf3\xe5\xe4^\xb5]5\ +\x0d\x00\xe8\x1dw;\x8b!\xb9\x06n\x0c\x88\x9e\xe6\x92\ +\x97\xb5v\xfd\x82\xa8\xef\x9fQ\xd34M\xfbs\xde\x01\ +W+iE\xc4tL\x85\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x00y\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00+IDATX\x85\xed\ +\xceA\x01\x00 \x0c\xc4\xb0\x0do(\x98\x05\xfc[\x00\ +\x19\xc7#1\xd0V\x01\x00a\xbd\xe7\xdc\xe4\xc0J\xc6\ +\x01\x80/<\x1a\xe8\x01\xff\xf7\xcdk%\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x02\xd8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\x8aIDATX\x85\xe5\ +\x96=r\xd3@\x18\x86\xdf\xd7I\x01\x9c\x83\x12ZK\ +p\x05\x0a\xa25\xc4!$q\xfef\xc2\x012\xc3\x19\ +(\xd3Q$\x01;\xe4\xd7H\xce\x0cg`\xc6\xd6!\ +\xa0\x83\x1b\x00\x05\xd6K\xe1(\xc8+\xc9\x92\x8fw%\xcf\x02\xff{1\xbex\ +t\xad\xc7Q\xa4\xb7\x10\xee\x92|=4\x0c\xea\x04\xb9\ +\x81\x8c\xa47$~A|5l\xf13\x004\xe2\x86\ +(\xd2\x11\x80\x87 \xee\x0b\xea\xbb\xbe\xdau\xc1\x9d@\ ++\x82\xfa\x93l<\x10u\x18?k$\xfa\xee$\xae\ +\x1b\xa2\xce\xea\x90p\x02\xad\x00:M\xb2H\xdcK\x0b\ +\x90\xfb\x00\xa2:%&s\xa7\xe1\x00\xa2H\xdcO\x09\ +\x8c<\xfa\x22\xd72$N\xe7\x91p}\xb5E\x9d\xd9\ +p\x90\x9d\xd0\xb0\x9f\x12\x00\x80\xd0\xe3y\x86\xc4BU\ +\x89\x1bx\xea\x97\x83\xec\x8c<~H\xf66`U\xe8\ +\xf1\x5c\xe2z\xa6\xc4@\xcb\x85\xf0\x81\x96o\xe0\x0bE\ +p \xf1\x19\xda\xd5\xf4\xb5J\xea\xc4\x92\x1c\x93\x5c\x1d\ +z\xbc\xca\x85Kg\x16\x5c 7\xb2\xe03\x05\x00\xc0\ +\x0d\xf4RP\xaf\x8cD3\xd0sB\xe7U\xe0\x85\x02\ +\xb3$\x04\xbe\x88_\xa6y\xe1\xa5\x04\x00\xc0\x19h\x0d\ +R7Kb\x12\x92\x01\x17;\xa3\x16O\x8a\xb2K\x09\ +\xe4IH\x88@\x80\xd3b\xa5\xe1\x95\x04\x12\x12\xbd\x19\ +\xf3*\xc1+\x0b\xdcJ\x00=H\xf6\x5c\x09\xdc\x0c\x0d\ +{U\xf2R\xff\x03%\xea\xa7$\xd9\x83\x02D\xe1G\ +\xd5\xb0J\x02\xce@-H\x17\xcc\x98G\xa0\x01\xea\xc2\ +\xf1\xf5\xacJf\xe9-p\x03\x19A\x97\x00\x16\x13\xc3\ +\x02\x09k;\xc6 \xdb#\x8f~\x99\xdcR+\x90\x07\ +\x17\xb8%a\x13@rK\x16 ]:\x03\xb5j\x11\ +h\xfa\xf2\xf2\xe0\xa1a74\xec\x09\xdc\x9aWb\xa6\ +@\xd3\x97G\xea\xca\x86\x93\xdc\x0e\x0d\xbb\xf1@h\xd8\ +\xcd\x91\xb8(\x92\xc8\x15\x98\x05\x1fz|o\xf7\x87\x86\ +]\x92\xdb\x96\xc4b\x91D\xe6K\xd8\x1ch\x89R\xbf\ +,\ +2|W\x04\xb7\xb2\xb6\x00\x1d\xa1`%n\x1f6}\ +=!u]\x07\xdf\xf2\ +\xae\x8a\xbc\x0f\x8c\xecc\xc5\xff\x08\xbcW[^\xfc\xa9\ +\x9b\xc4q\x1c\xdf-;\xe6\x1c\x90\x02\xac\x08\x96\x17\xd7\ +\xc4\xe6L\x5c\xbe0\xbb\x01Tegw\xf2S\x17\xae\ +\x7f\x1dMe_\xe4\x00\xa3\x15\xf6\xa4\xae\xcd\xdf\xe7^\ +\x5c \x10\xe8Pa{tX\xe8\x9e\xeb\x12\x90\x9e\xb5\ +\xe91\x85e\xc0\xcdq\x9e[\xfb\xdd\xa8\xa7.\xb4\xec\ +\x00\xd6\xdf[S?\x16\x89\xd9\x9c\xbav\xe3[n\xf7\ +\xf1\xb2\xe2J\xe0\x1207}M\xee\x93=\x04(v\ +eD\x99\x1c\x0e\x04\x02\x1d1\xff\xb2\xac\x9cd\x90\x1d\ +\xc0\xe0\x8e\xad\xae\x18\xfd0uU\xee\xa48i\x22U\ +\x00\xea1kz\x0a\x10\x96\x02\xa8\xda\xa3nw\x19\x09\x91\xd3l\xb86\xd5=\ +\x90\xf6\x84\x18\xf6\xe4(v|\x15t7\xbf\xdf/\x03\ +\xc5\x0c`\x9e\x01\xb0\xdd\xe0r\x1d dB\x13c\x9e\ +\x82\x82\x02+p\xf5>\x04\x5cs\x0f\xda\x1f\xba\x13\xc5\ +\xd6\xd6\xd8\x01\xe7\xde\x03\xbf\x01\x880=\x0eB\xa8a\ +\xb8\xa6\xf1\xef&\xa0\xc9Q\x7fK\xccwO\x80\xa1.\ +\xfa\x94\xee~),\xe1/\x80\xe1\xf4\x82\x0e\xf1P\x1c\ +\xa7GL\x1a\x00bN\xf6\x14\xd0\xa1\xd5Qu+\xe6\ +o\xda\xd4Uv'\x02\x07\x9aD\xf8$:7\xa0\xc5\ +BT\xd9U\x1b(vW\x94(\xb2*\xcaZ\xd9C\ +@\xb0\xaa\xb4\x15\xe1$\xc2\x84q7l\xbe\x1b\xf4\xc6\ +x\xf3\x0eP3\x98\x83H\x22*\x02\x8b\xe7N\xde\xe9\ +\xf6\xa7fm\x5c\x19mr?\x07\x03_v\xdd\x0d\xe2\ +v\xb8\xb5\xb2\x15@\x04\x7fFvvb\xcc\xdfPT\ +\xd4y\xf3a\x93\x09\xba\x87\xfe?G\x08e\xd7X\xcf\ +\xedu\xee.\xea8\x8e\x0fawD\xa0n\xc3\x95\xcb\ +\xb82\xb9|\xf1\xa7\xd6\xe4Y\xf3f\x0a,\xd4P\xc2\ +\xec\xf5\xaf\xacHz5\ +\xc7q|\xb7m\xe2^E6\x02w\xc0>\x17,/\ +\xfd\xb1{\x5c\xaf'\xd5\xafM\x8d7\xa7\xa7\xcc\xff\x0e\ +!M`\x89G\xc3\x1bf\xcc\x9aw;\xe9\xd1\x95\xe7\ +\xaf\x5c\xa9\xef\xb7$\xfd~\xbfI\x98\xf0\x84\xd3\xae\xbe\ +2\x90T\x22W\xb1\xb4\xda\x8a\xe2\x86\xde\xe2\xfb\xdd\xd7\ +K3_\x1f\x9b`\xbcE\x08N\xd4\xd5\x22P\x0dz\ +D0\xcd\x18\xdb\xd6\xde\x19\xb6>\x8fo\xa2E\xa7\x02\ +\xe9\x82\xae\xa6\xab\x7fHm\xa7\xe9\xdcP\x17\xf8\xea\xf7\ +\xbe8\x06\xf5c\xb2\xcc\xc9]h\xac)\x04\x9e\x1dL\ +<\xd0\x88\xd8\xad\xc1\xb2\xd2\xda\x81\x02\x87\xf4k\xf6b\ +\xe6\xe6i!\x13\xca\x14#\xcbE5I#m\xd5\x03\ +\xb4\x00-\xa2Z\x8fx*k\xcb\x8b.\x0d\x05\xf7\xc1\ +\xb6\xff\x00\xf7\x80\xda\xb0\x80\x19\xddB\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x01\x04\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xb6IDATx\x9c\xed\ +\xd9\xd1\x0d\x83P\x0c\xc5\xd0\x14u\x8d\x0a\xf6\x9f\x0a\xc4\ + t\x8c\x83\xf4\xec\x05bY\xf7/3\x90\xf3\xba\x9f\ +\xf3\xba\x1f\xe9\xb0\xc9\xe3o\xa0\x00Z@S\x00-\xa0\ +)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\x9a\ +\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00-\xa0)\ +\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\x9a\xe5\ +\x03|\xe4q\xfd\x1a\x9fi\x01\xf3\xd5\x0233\xc7\xfe\ +cK\x5c~\x01\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\ +\xa6\x00Z@S\x00-\xa0)\x80\x16\xd0\x14@\x0bh\ +\x0a\xa0\x054\x05\xd0\x02\x9a\x02h\x01M\x01\xb4\x80\xa6\ +\x00Z@S\x00-\xa0)\x80\x16\xd0,\x1f\xe0\x0f\xc7\ +\xa8\x0b\xc6\x03$Z\xc7\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x01\x94\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01FIDATX\x85\xed\ +\xd1!KCQ\x18\xc6\xf1\xff{\xc7\x8aA\x04A\xcb\ +v\xdd\xf6\x09\x04m6\x93\xa8k\x82I\xab\x82\xdf\xc1\ +b1\xf8\x11d \x18\x0c&A\x10\x8b\xa0\x08\x86\x15\ +\xc1\xec}\xcf=\xd7\xee\x98`q{-\x1a\x14\xb6\xbb\ +\xbb$x~\xf1\xf0\xf0\xf0\x1c^\x08\x82 \x08\xfe;\ +\xc9\x0bh\xea\x8f1\x16\x22\xb1\xad8\x8e\x9fF)M\ +\x92\xa4&Q\xe9\x14\xa43\x17W\xd6E\xc4\x06e\xa3\ +\xdc6c\x0a\x98\xef\x9b\xdc\xabf\xcbyq\xe7\xdc\x82\ +D\xe5\x07\x90%\x8c\xe9\xbc|\xee\x80R\xc4\x16p\x0e\ +L\x22v\xe5\x5c\xb6=(\xab\x9a\xad\x19\xd1-\xd8,\ +pc\xf6\xb12\xec\xf7#\x0d\xa8V\xab\xefsqe\ +\x13\xe1\x08(\x1bv\xe2\x9c\xdf7\xb3\x1f\xe7K\xd2l\ +\x17\xb1\x0b`\x028}\xebvV\xea\xf5\xfak^\x7f\ +!\xaa\xe9\x9e:\xdfS\xe7M5k\xb5\xdb\xed\xb2\x99\ +E\x89\xf3\x87\xea\xbc\xa9\xf3\xa6iv\xf0{\xdc0#\ +\x07\xbf9\xf7\xd24\xfag\xc0\x84\xc1\x9d@\x17X\x05\ +>0\xdb\xa9\xd5\xe2V\x91\xbe\xc2\x03\x00\xd24]\xec\ +\x9b\x5c\x023_O\xdd\xbe\xd8F#\x8e\xaf\x8bv\x8d\ +5\x00@U\xebH\xe9Y\xc0\xf7z\xd2l4*\x8f\ +\xe3v\x8d\xcd\xcc\xa4\xc8\xbd\x83 \x08\x82?\xe9\x13\xfa\ +\xca\x87I\xdf\x83:5\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x03d\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x16IDATx\x9c\xed\ +\x9b\xbfOSQ\x14\xc7\xbf\xdf\x17\x08\x90N\xf2#\x02\ +\xee.X\x17WML\xacus\xa8\x05#I\xd1\xa4\ +\xa5D\x13\xd0\x11\xfe\x02\x9d\xc1D\xac8h\x13M\xa0\ +\xb2\x83l\xb8\xbaP\x98\x9c)\x92\x14\xb6\x0aD\xf2\x8e\ +\x03}Ms\xfbj\x11iO\x1b\xeeg\xba=\xf7\xbe\ +\xf6{\xbe\xbd\xf7\xdd\xe5\x1c\xc0b\xb1\x5cdx\x9aE\ +\xe1X,\xe0\x1et\x8cP\x10\x05p\x0d\xc0 \x80\xb6\ +\xba*\xfbw\x8e\x01\xe4\x00l\x0a\x91q\xba\x8e\x16W\ +\xd3\xe9B\xad\x87j\x19\xc0\xf0\x83\xf8\x98\x80/\x01\x0c\ +\x9c\x87\xca\x06\xb2#\xc4\xf4Zf!\x0d@\xaa-\xaa\ +j\xc0\x8dd\xb2\xbd;/s\xa0L\xd4E^\xa3\x10\ +\xbe\xdd\xef\xe5\xe4\xf7T\xea\xb7\xdft\xb5m\xccK{\ +\xeek\x10I#\x9e%\xf0M ?)\x8e{\xbeJ\ +\xff\x0f\xa1\xeb\x10\xec\x17\xe0&\x80`i\x822\xd1\x9d\ +\x07\x00<\x85\xcfN\xf0\xdd\x01\xa1hb\x8c\x82\x0fe\ +\xa1=\x11\x99Z[~\xff\xd9\xefK\x9a\x0c\x86\x22\xf1\ +G$g\x01\xf4xA!\x1e\xafe\x16>V,6\ +\x03\xe1X, \xbf:~\xc0;\xf3\x82\xbc\x03\xe7\xfa\ +\xcarj\xa7\x8e\xa2\xcf\x9d{\x91\xe4\x80\x0bw\x03D\ +/\x00\x80\xc8\xb1\xeb\xe8\xaa\xf9bt\xcc\x07\xdd\x83\x8e\ +\x11\x94\xbd\xf0\x04\xf2\xbc\xd5\x92\x07\x80\x95\xe5\xd4\x0e\x1d\ +\xbe(\x05\x04\x83R\xe8\x1c6\xd7U\x18P\xbc\xea<\ +\xb2\xc5m\xdf\x92\xacf\xde}\x02\x90-\x05(\xb5\x0d\ +\xc0\xc9=\x0f\x00\x10\x91u4\xff\x99\xff\x1bR\xcc\xc1\ +c\xc8\x5c\xe0g\xc0\xa07 \xb1[\x0fU\x8d\xc4\xc8\ +\xe1\x8a9\xefg@\xe9jl\xb6\xab\xee,\x189T\ +\x5c\xfb~\x06\x5c(\xac\x01\xda\x02\xb4\xb1\x06h\x0b\xd0\ +\xc6\x1a\xa0-@\x1bk\x80\xb6\x00m\xac\x01\xda\x02\xb4\ +\xb1\x06h\x0b\xd0\xc6\x1a\xa0-@\x1bk\x80\xb6\x00m\ +\xac\x01\xda\x02\xb4\xb1\x06h\x0b\xd0\xc6\x1a\xa0-@\x1b\ +k\x80\xb6\x00m\xac\x01\xda\x02\xb4\xb1\x06h\x0b\xd0\xc6\ +\x1a\xa0-@\x1bk\x80\xb6\x00m\xac\x01\xda\x02\xb4\xf1\ +3\xe0\xd8\x1b\x08\xdd\x967\xc8\xc8\xe1\xd8\x9c\xf7K0\ +WzXp\xb9\x1e\xa2\x1a\x89\x91\xc3\xb69\xefg\xc0\ +\xa67 y\x0b\xa7\xec)hRX\xcc\xc1c\xcb\x5c\ +Pa\x80\x10\x99\xb2\x8f\xc1p$1R\x0fe\x8d \ +\x1c\x1d\x7f\x88\xf2\xcaq\xe1\x92\xb9\xa6\xc2\x00\xa7\xebh\ +\x11@\xa96X\x88\xb9;\xf7\x13-w\x14n\x0f?\ +\xe9\x17\x91\xd9R\x80\xc81pX\xdb\x80\xd5t\xba \ +\xc4tY\xa8\xcfiG6\x14\x89\x8f\xa25\x8e\x03C\ +\x91\xf8h\xbb\xdb\xb6\x01\xa0\xcf\x0b\x0a0\xe3\xd7BS\ +-!\xde\x8d\x8c\xbf\xf1\xe9\x16\xc9\x8a\xc8:\x89\xddf\ +\xab\x22\x15\xba\x8e\x08.\x17\xcf|\xd0\x98\x9e\xff\xfae\ +\xe1\x19|\xea\x9e\xabu\x8c\xc8~/'\xbb\xf3\x80a\ +B\x90d\xf0\xe4\x07\x9b\xad\x86\x9a\xa0\xff\xdf9\xbf\xdf\ +\xe3L\xa1J\xd1w\xcd\xa6\xa9P4\x11\xa3\xe0\x15Z\ +\xadi\x8a\xc8\x090s\xe6\xa6\xa9r\xc2\xb1X@\x0a\ +\x9d\xc3\xc5z\xfb!\x9cT]7c\xdb\xdc6\x80-\ +\x08\x97\x188\x5c:M\xdb\x9c\xc5b\xb9\xd8\xfc\x01\xdf\ +s\xe1\xb5\xcf3\xa6\xd1\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x0c\xd6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x0c\x88IDATx\x9c\xe5\ +\x9b[o[\xc7\x11\x80\xbf%E\x8a\x94(\x89\x92\xad\ +\xbbd\xc9N\x9a\xc2A\xe0&E\xd1\xa0H\x0a\xf4\xa9\ +}\xe9{\x81\x16\xfd\xa3}*P\xb4\x0fA\x906N\ +R i\x92\xc6\x96l\xc97]HI\xa4.\xe4\xf4\ +a\xf6\x1c\xee\xd93\x87\xa4\xe4\xf4\xc9\x03\x10$w\xf7\ +\xcc\xce\xcc\xee\xcem\xe7\x00\xb2\x05\xe2x\xe3@\x9c\xf2\ +\x9e\xfex\x93\x84\x90\xe3\xf9M\x12B\x96W\x97\xed\xe0\ +\x0e\xf0\x18\x9c\x14<\xdc\x00n\x19\x1d%`2\x8b/\ +m\xaf\x0d\xa1f\x12\x10\xe0b\xc8\x98s\xa0g\xb4w\ +\x81\xbe\xd1\xfe\x12\xdc\xa9\x8d*\xcf\xa3\x1b5\x00d\x1b\ +\xb8\xed\x09=\x01^\xf8\x89\xa7\x809\xdf.\xc0Y\xd0\ +>\xeb\xdb\xfa\xbe\x1d\x8f\xa3\x0a4\x81\x8a\xef?\xf74\ +T\xfd\xf7%p\x04\x97\xa7P9\xf2mS\xa8 \x9d\ +\x9f\xff\xc4\xff\x9f\xf2m\x0eh\x01\xa7\xbe})\xe8{\ +\x01\xeeq1o\x85R\x92-\x90\x09\x90\x8f@V\x8d\ +1k \x0bF\xfb\x06\xc8\xbc\xff=\x05r\x0f\xe4\xae\ +\xff\xcc\x80\xdc\x01\x19\xb2#\xa4\xee\xc7,\xa8\xe0\xe5\xae\ +\xc71\xe1\xfb\xe7@6\xf3GU\x9a\x05\xed\x1b \xbf\ +\x06)_\xf3\x88\xcb\x04\xc8\x9f\xf5\xc1\x5c\xdf6H\xc5\ +h\x7f\xdb?\xb7\xe2'[\x8e\xf0\xdd\x1bsr<\xe3\ +%\xff\xdbyF\xb6\xa0uK\xdb\xe5-\x83\xd92\xc8\ +O\x8c\xf6\x09\x90?\xda\xbc\x14\x13\xf0\x91\x7f0\x92\x9a\ +\xac\x170\x7f\xc7\x7f\xb6\xed\x15\x96\xedkLN`\xa2\ +\xe2\xf6Y\x15N{I\xe7\xcb\xf5\x97\xb3\xcf\xa5\xbb\xb9\ +\x02\xf2\xabq'\xdf\x1el\xfbPc\xca\x14\xc8mc\ +\xfc*\xc8\x07\xba}M|\xf3^y^\x13dV\xb7\ +\xbc\xd97\x07\xf2\x00d\xd1\xe8k\xfag#\xcb&\x9b\ +\xfa\xc9\x82q&\xe4\x17\xe0>\x0d\xfe'\xca\xa3\x07\xec\ +\x01!\xa3\xabpy\x0b*_\x0e\xe1d\x0dxZ\xd0\ +\x97\xda\xe1\x1b<\x0b\xf0\x00\xbaO\xa0\xf6*h\xeb(\ +]\x94\xc9)\xbc\x987\x980\x90\xc6\xc44P\xe6\x1f\ +\xa0Z\xbd\xed\xc7l\x01/T\xa1\x0f\x05\xf1\xc4,\xf9\ +\xff\x89\xe9J4x\xd8F\xd0\xf6\xc2\xa0%\x86\x17 \ +\x822\xbc\xe7\x9f]\x02~\x06|\x0e\xcc\xa0\x16\x22\x81\ +\x9c\xd9\x8c\x04 \x0d\xd4\xcc$\xff7\x806\xb8]?\ +Q\x055]\x9b\xc0\xd7\xe0\xae\xf4|\xb9\x13r \xce\ +\x8f\x9bB}\x81oG\x98\x9f\xf8\xd9E`\x1a5\xa9\ +{\xf6\xb3\xd2\x86\xfa\x0b\xd4\x9fX\x01~\x00\x16\x80\xcf\ +\x80\xe7\x80\xb7<\xec\xf8\xe7{\xaa\xdb\xdcU\xd1\xc4[\ +\x03\xf3&[Y\xcd)\x1b^\x0f|\x1c)F\xcbL\ +.\xa1\xa6rF?7\x05Y\xf5\xcax=kU\xd2\ +\xfe\x99\x81~\x91\x09\x90\xdfx+\x11\xb6\x07\x8aQ\xee\ +\xaa\x8e\x18@\xc9\x98\xb5\xaf\x13\xb2\x0b\xae\x17\x8d]\x03\ +\xfe\x0e\xdc\x09\x84\x10\xac\xccaS\x19\xe7\x10\xdcS\xdf\ +7\xe6\xaa\x9b\xe0\x9fuO\x80\x03\xc5}\xd8\xcc\xf7\x8b\ +\x03\xd6\x81\xbf\x01\xf7\xb2s\xba\x9e\xf2\x22\xeb\x18G\xc0\ +\x12\xc0\x14p\x161\x0fz\xe6\xbf\xf3[\xe91Y!\ +\xa0\x1a\xb9\xd9W\xc6\xdd\xe5\xf8<\x8e\x0b\xeeRq7\ +\xfb\xd1n\x08=\xbc\x1e\xf0\x04=z\xe1\x90\x1e\xea)\ +N\xc7X-%8\xe7W/\x00\xd9F\x95L)0\ +w\x07\xc0}\xe0\xd2\x9b\xabW\xe8\xee\x09M\x9e\x9f\xd0\ +\xdc\x04%\xe8\xfa\xe3V;\xc4\xf6\xf7\xa7\x81.Hx\ +f\xfb:V\xee\x03G\xe8\xca\x7f\xadc\x05\xa0\x03\x9d\ +\x13\xa8/\x92\xd1g\xee\x08\xe4\xa7\xf1\x04cX\x01y\ +\x0b.*P\x9dF\x15\xd3)\x83\xad\xbd\x0b\xfc\x0e\xf8\ +K\x01\x03\x01t\xe6\xa1\x9e\x04?>N\xa8\x1d\xf9\xce\ +y\xd4R\xf8\x1d\xd59\x87\xfa\xe1\x10d]\xd4<\xfe\ +\x06\xf8$\xa0\xd9+\xcfz\x0d\xb8\x0dr\x1e-fn\ +%b\x01\xc4\xd1\xe1]`\x1a&\x1f\xaa\x12t\xfb\xd9\ +\xe1\xb2\x0e\xfc\x03\x0dp\x8c C\x80\xeem\xa8M@\ +\xfd%\xb8N\x01CG\xd9\xbfR\x07\x16\xe0\xa2\x06\xd5\ +\x93\xbc\xd6N}\x93\xbf\x02k\xe0\xf6\x82\xce6\xc8\x09\ +\xbac\xdf\xf6\x9ekB[\x9f\xe8\xd8\xc7:\xa0\x0a\x9c\ +\xfb\x09\xee\xa1\xab\xf2\x85M\xb3,\xa1\xdb\xbe\x87\xad\x13\ +\xa6\x81U\xa8\xb5U\x89\x152o\x80\xeb\xe83\xd5\xb6\ +2\x18\x1e\xab0\xaa\xa3\x87\xfa\x02+\x05\x88\xbe\xf1c\ +\xee\xf9\xe7:d\x1d\xb9\x22+\xc0\x06\xf0\x0c\xf5\x01\x8c\ +\x03|\xd8\x04\xba\xe0\xba\x9e\xe0H1\x1e\xcdC\xbb\x86\ +\xae\xc2\xf9X<\xdbp\x01<\x85\xf6$\x1c/`\x87\ +\xb4]\xe0L\xe7\x8c\xc1\x9d\xa1\x8b\xfa\x83\xe7)\xc7\x8b\ +%\x80\x06\xea=-\xe6\xb7|\x02\xcd)p\xadl[\ +\x22\x84\xcb\xf7a\xae\x07\xb3\xaf\xccGo\x04\xb3\xaf`\ +\xf6Rq[G\xcd\xb5`\xae \x16a\x075\xdf-\ +\xd4\xc2e\xc0\x12\xc04\xaa=\x0b\x94\x9a,\xa3n\xaa\ +\x01\xc7M\xa8|\x0f\xcc3~\xec=\x06\x88\x03\x16\xa0\ +\xf2\x9d\xcea\xc2s\xdbYr\x97@\x19\xdc1\xba\xb8\ +\x19\xb0\x04 \xa8i\xd9) d\xc2\xb6\xf32\x05\xa5\ +d\x22\x7f\x1c\xac`\xeb\xda\x10n\xfb\x16\x94J^\xbf\ +\xc4\xc3\xae\x946\xb1x:\xd4#4\xda\x0a\x94\x07\x83\ +L\xbf}\x13\xd5\xb2\xe1*\xcc\x82t\x81\x15\x98\xd9\x0f\ +\xfaZ\xc0\xbb\xc0\x13\xd2\x8cN\x06\x92\xd4\x19\xa8Oa\ +\xe5\x05\xe7\xd0@\xe7\x07\xfd-\xa0;s\x03\xe4\x19\x03\ +?#\xc1\x7f\xa6}\x1cd\xd1\xb8c\xef\x0e'\x81Y\ +\x0a1a5rIH\x99G\x83\x8deOd\x84\x9c\ +\x1etf\xa1~\x00\xc4A\xc6#O\xd0\xd7\xc1\xe4+\ +@\x1f:gP\xdf\x05\x1ctoA-\xc9/>\xf3\ +\xdf\xce\xcf\xf9\x05\x9a+\x0c\xe1\x15tf\xa0\x9e\x08-\ +\x9c\xb7\x89*\xbe\xbe\xee\x86TW%y\xcbL\xc2\xc6\ +Z\x99E\xe0K\x90\xaa'\xe0%\xb8C4\xd3s\x96\ +\x8f\xfc\xa4\x01\xf52\xb8\xe7yT\x82g~\x018F\ +W\xec\x1bcw\xb5\xfd\xf82\xba\xe2\x07\x9e\x8e\xffh\ +_.z;\xf1\xa6\xcfg\x7fC\x9ad\x1f\x15\x98\x17\ +\x9al\x02O\xe0\xa4\x03\x8d)\xb2\xe1\xb1\xa9\x03J\xa8\ +\x04o\x83\xdb\x09\xec\xf7-l\xe57\x0dG\x05ih\ +\xa5\x00\xcd\xf4n\x01O\x87\x87\xc4\xa9/\x7f\x1f\x0dg\ +\x87\x05R'\x18\xbe\xbd_\x08\x9f\xb9r'\xa8\xb7\xba\ +\x01\x8d\x03\xf4He\xa0H\x09.\xe5\xe3\x01( \xbe\ +\x01\xf3GF{\x02e%\xb4\xf2\x90\x9c\xb3\x94\x9b:\ +Qx\x9fa\xdf?\x84\xb4\x14\x08 7N|j|\ +\xcd\xea\xb5\x04\xb0\x00X\xf6\xdf\xba\x84\x18\x07V\x18$\ +4\x0c\x8f1\x81\x9c\x93\xf3\x12.\x8c\xd4{\x06\x8a\x84\ +i\xd1\xfa\x0aC`\x05G\xe0Z\xe1\xec(\xc1\xf4\x07\ +;\xa70\x946<<\xd7\x85\xea\xa8|\xdb5r\x0d\ +\xee\x0cU\xe6\x19\x88\x050AqTw\x13\x9b^\x83\ +nd\xdeb!\x0c\xbd\xb1\xb9\xa9\x1fQ\xf4\x5c\xae=\ +\xb6\x02\xcbpei\xf3\xc0?\xc8\xb4\x97\xec\xf6\x14\x9a\ +P{f\xd0! \x8f\xd1$\x0b\xc0\xa3\x02\xfd2b\ +\x85\xbb}\x8d4s\xd0\xc3\xce\xd6\x8e\x8a\x05z\x15\x98\ +\xb8\xce\xf6O\xecu\x11\xf4G\xf4\xbf&\xd4\x1c\xc5G\ +p\xacy#\x01\x94\x9f\xa1\xf67\xc6\xd5\xb3\x11\x8e\xcc\ +\xf2\x1e\x90\x9a\xa4\x10\xd2m\xff\xc8\x7fFX\x87B(\ +\x12@\x19\xdb\xb3\xcc\xcd\x11\xeb\x80.Q\xbc\x1c@\x11\ +\xb3\xc3\x08\xbf\xca\xcf\x11\x9f\xf9Q\xd6a(\x14\x8d\x1f\ +[9\xc6\x02Hr\xe79my\x03\x22\x12\xe8\x93\xde\ +'\x16)\x83\x9d\xf3Ib\x01t|\xdb2z\x1e\xd1\ +\x0b\x05\x8e<\xbd\x02\xecg\xb7\xb1\xa0\xb9CY\xcf\xe6\ +\x10\xd3s\xf7Op\xed`\x8e\x82<\xa3\x05\x02\x9a8\ +\xd9\x8d\xe6\x5c\xd3`-a<\x09\x87\xc5\xa1\xbb\xfa8\ +\xdb\x0e\x0c\x0a\xb62\xd9\xe9\xf8\x08\x84W\xd7\x16\xec\xa1\ +\xc1\x8d\x05\xcf\xc8\x14V\xe0oe_\xfbn0\xb6\x0e\ ++\x14\xe6$\x93\xc0\xcb\x84\xe4:>\xa38\x8b\x94\xe0\ +\x85m\x0a]_\x89\xb2\xeam\xdc\x15\xd0\xf2g0\xc9\ +\xdb\xbf\x0e\xf3\x09\x04Bh\xddF\x13$VN\xb2\x1c\ +\xd0\x18\xf7-\xa3\xd6h,%\xd8F\xed\xa5\x19?\xfb\ +mnd_\x018\x83\xc62\x9c\x9c\x8d\xe1%^\x03\ +\x9c(\xce\x99\x15\x06ew1,S|\xbc\x92\x1a\x85\ +\x9cY\xb5\x04p\x86*\x97rA\x86\x158\xee\x90\xbb\ +\xf7O\xb7\xfdW\xd08\xd3s\xfac\x81\xac*N\xbe\ +\xc2\xf4\x18\xa5\x01\xad\xae-t\x99\x83\xb3.\xcaSN\ +xE\xf9\x80\xc4f\xbem\x13\xd4\xab8\ +\x92\xeaO\xd3m\x9e\x04fa.N\xd6&\xb0\x02S\ +\xd3\x01O\x19\x88\x05pA\x9a4p\xdet\xc9\xba\x8d\ +\xd7\xed+rJ\xd8\xee\xed\x15\xb0\x07\xf5KU\x5c\xb2\ +8\x9e\xaf/\xce\x8f]\x81I\x8f#<\xf3\xa1\x10(\ +\x01\xabv\xfa\x0e\xd44_T\xc0}\xeb\x1b\xeaDV\ + 6\x83\xf1\x95\xd3'h9\x1a\xc02Z'\xd4\x0f\ +\xc6]\x02\xbfE\xaf\xc7\x97\x0d\x9d\x97\xa4\xa0N\xd1\xf8\ +\xfc=/\x84a\x89\x0f!\xad5\xa0\x81\xba\xd1VM\ +\xcf%\xf0{\xe0S\x06\x97\xa3\x89\x19L\xcak'\xf5\ +f;\x85\x12\xc3\xddg\xd9B\x0b\x0f\xc2\xb6\x86\xf7\x08\ +7\xa2\xf6\xa4\x0eo\xcd\x7f\x1bVC\x1a\xdc\xa8F0\ +}~\x05\xf3RE\xaah\x09\xed\x1c\xc8\xbb\xb6N\x90\ +\xf7\xf3\xd6J>d\x8c\x1a\xa1C\x90 #\xebN\xe0\ +\xa4\xab\xf5\x80)\xa2\xf0\x8a\xba\x0f\xee\x11\xea%\xbe\x06\ +\xb3\xe3\x82\xcc\xa0)\xfb\xef\xd1\xcc\xcf\x0ey\xc5\xb8\x81\ +\xa6\xe0\xc3\x0b\x9e\xe4n\x22\x03\x96\x00\xba@\x95LI\ +\xec\xcc\x0b\xa8Lz\xc9\x16\x85\xb4\xfb\xd0\xaa\xaa\xce\xb8\ +V]\xee\x98 e\xc5\xdd\xaa\x90\xaf\xfa\x08\x14c{\ +\x11\xba\x1d2\x1a_*\xa8n\xcb\xd5(X\xb1@\x09\ +\xdc\x9enyy\x16(\xa0\xa7\xa8F\xee\x01\xff\x0d\x98\ +\x0f$?w\xe0\x05\x94\x84\xbf\xa1\x0b|\x13H\xbc\xbf\ +U\x94\xd1\xa70'Q\xbf\x049\xc6\xfb\xd0h\x91\xb9\ +\xbe\x93\x8a\xd2\xe3v@\xee\x1a\xccf\xe0%i.\xc0\ +\xed\xa2u6\xc9\xd6\x17T\xf1T\xc8f\x8d\x22\x1cN\ +T\x80\xec\xa3\xb5?\xf7\xc6\x08\x97\x0dh\xddF\x9d\x9b\ +%\xe0\xb9\xee\xb0\x9c\x9d\x9f&]\xd5\xe3&\xba\xeae\ +Tyv\xd0\xda\xe6%e\x1e\xd0\xcb\xd8\x8c3\x14\xed\ +\x00w\x9a\x0dW\xdd\x1eZ\xc3\xbf\x81Ff\x9f\xa3B\ +x\x00\xe7'P=R\x22\x0b\xcd[_\xe7h$\x15\ +\x9bI\x1b\x80\x83\x0b\xbf\xbb\xaa\xc9\x0b\x14!\x1c{f\ +\xbc\xa93\x1d\xcbe\xc5/K\x1eo\x12#|\x00<\ +\x04\x0e\xc0\xbd\x0c\xc6\x97\xe3{F\xeb\x08\xc4\xcct=\ +!\x0f\xd1\x82E\xd0+\xefe\xdf\xbe\x1f\xb4\x1b b\ +\xf7\x8b\x83\xea\xa4g\xb0S\xe0\xc5\xad\x8f\xc0}\x05L\ +\xc1\xd1\xf7\xd9\xeb9q\x9e\xb6\xf8\xcc\x8f\x93B\x93;\ +\x03\xe7'S._\xcfZ\x07\xf0f\xe8}\xecDI\ +2\xe6\xffP.\x0f\xba\x00\xf2\xf3\xbc\xf9\x95\xa6Z\x8a\ +\x5c\xb9\xfc\x1d\xcc\xb2^\x1b\xf9\xc7\xd8/L\xac\x92{\ +aB\x1c\xfa\x82\x85\xf1\x02C:f{\xcc\x89C\x9c\ +\x05\xcf\x88C\xdf\x18\xf9\xa5\xd1W\xce\xfa+\xa9\x10\xaa\ +\x8c\xff\xc2D\x8a\xe8O\x05N\xc8F^\x08\x00\xf2\x1e\ +\xfa\xcaJ\xee\xa5\x04^\xeb\x95\x99\xb4\xad\xe4\x9d\x9f\xb7\ +@\xde1\x9c\x9f\xb2\xa5\xe5=\xf3\x7f\xc8\xe3+\x9e<\ +\x91ZY\xa5\x16{\x80\xe0w\x82q}-\x1b~k\ +\xde\xd3O+t\x9e*\x8c~ij\xca\x8f\x09\x04/\ ++\x0c^\xbe*z9j\x1e3f\x91-\xcfC)\ +\xbf\x9b\x15bD\x86\x93#\x9b\xa8\xb6\xf55\xba\xb4\xfc\ +\xef\x1aj\xe6\x1cz\x01r\xc1\xe0\xb5\xb9\x19@\xa07\ +\x0d\xe5\xc4)JJd{\xc1\xff\xe4\xf6&ym.\ +(\x97M\xe9\xeb\xfaq\x0e5a\xa7\xfe\xf7$\xaa\xc4\ +}\x01\x06\x1dT\xa1\xce\x06x\xf6\x06N\x93\xed\xc0\x8d\ +\xb8\xa2\x8eA&0J\xcd<\x9e:y-\x1b\xbf8\ +YB\xaf\xca\x92#Te\xe0_\xe0\x998$k\xf3\ +\xac\x17'\x85A\xe23\x06\xa3\xb46}\xac\x88\xc77\ +\xf7\xd5Y\xab\xe1\x0d\x80\x0c\xcfo\x1a\xf3\x09\xa8\x10\xfe\ +\x07\xb4\x0a\xfd~\xcf\x22[\xc2\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x01\x93\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01EIDATX\x85\xed\ +\xd7\xb1N\xc2P\x14\xc6\xf1\xff)\xa1\x8c\x96\x05\x9f\xa1\ +\x0b\x03\x09\xf8\x02&\xf0\x0e\xac&\x94\xc1\x18\x9c\xd5A\ +v\x10\x19\xe8\x0b\xf0\x0c\xc6\xc4'\xa8\x89\x03K\xdf\x81\ +\x05\x1c)\x81\xe3\x005X\xc0A\xdb8x\xbf\xf1\xb4\ +\xc9\xf7Ko\x87{\xe0\xbfG\x92\x83\x8a7\xac[\xaa\ +\xd7@\x0dpR\xea\x99\x03\xc1Z\xa4\xf7\xe6_>\x1f\ +\x05T[\x8f]\x85\x1b`\x01\x12\x22\xfa\x9eJ\xbd\xca\ +\x09\xa8\x0b\x14D\xb4\xfb\xea_\xdd\xed\x01\xaa\xadAC\ +\x91'\x84\x97\x88|s\xe2\xb7\xa7\xa9\x94oS\xf6F\ +%\x9b\xe5\x18\xe5|-\xd2\x88\xbf\x84\xf5\x89D:\xc0\ +\x22\x8br\x80\x89\xdf\x9eF\xe4\x9b@\x94S\xed\xc4s\ +k\xe7\x9d\x1aH\x98E\xf9.B!\xd4\xcd\xff\xb5\x07\ +pR;\xf3o\x22\xc2\x1c(\x1e\x02\xfcI\x0c\xc0\x00\ +\x0c\xc0\x00\x0c\xc0\x00\x0c\xc0\x00v\x01\xf3\xcd\xed5\xdb\ +\xa8\xe2\x00\xb3C\x80\x00\xd4-{\xa3RV\xe5eo\ +T\x12p\x05\x82=\xc0Z\xa4\x07\x14l\x96\xe3,\x10\ +g\x17\x0f\xa76\xcb1`\xafD\xfa\xf1\xfc\xebb\xe2\ +\x0d\xeeU\xe5\x16\x88\x14\xc2\xed\x05\xf2\xd7Q\xc5\x11p\ +\x01\xfb\xe8b\x12\xa7\xe2\x0d\xeb9\xd5\xce\xf6\xea\x5cL\ +>\xffaf\x02\xc1J\xa4\x9f\x5c\xcdL>\x00\xa7|\ +n2\xdb\xbddE\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x06{\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x06-IDATx\x9c\xed\ +\x9b\xc9s\x5cW\x15\xc6\x7f\xdf\xb5I9\x09\x91\x833\ +@\x15+\xb6xH\x9cH=$\x14\xc4\x8ac\xc9\x93\ +,u\xab\xf2\x87\xb0\x0a\x0bXP^\xb0\xc9\x12\xfe\x88\ +T\xab%\x928ek4\x09\xa0\x1e\x0cE\x18V)\ +*\x95bE&\xb0lc)F\xf7\xb0\xe8n\xe8t\ +\xb7\xf4\xee\xeb~O\xea\x14\xfa\x96\xf7\x9e>\xf7|\xbf\ +:\xe7\xf5\xeb\xa7'8\xd0\x81\x0e\xf4\xff,\xf5Z<\ +u\xc3\x1e}\xf8.?\x94\xec\xb2\xc1\x11\xcc\xd6\xedk\ +\xeeg\xb5)}\xb8\xd7\x05\xf6\xa3\xcc\x9b\xf6\x1d=\xf0\ +\xaf!\xe5\x05\x9b^\xba\xf6\xc8\x03^\xbf\xf9\xaa\xeev\ +\xc6v\x01x\xf1\x97\xf6\xd8\x03o\xbf\x92q\xbac\xeb\ +\xb6\x9c&*\xd3\xaa\xa6Vy\x02\x1a\x9b\xb31'[\ +\x02\x8evl\xbd\xcf\x11}\xbfzA\x1b\xed\x8b\xae3\ +\xc1\xf6\xb6\x7f\xad\x87y\x80\xa3\xe6m1\xb7`\xd9\x04\ +\xebMT\xbb\x98\x07x\x86M\xff\xa3\xce\xc5.\x00\xa0\ +\xa9]\xce\x18\x19V\x08\x11\xe6\x9b\xd2\x95\xce\x95.\x00\ +\x1e\x1e\x8e8k\xc4\xbc-\xe6\xe7-\x13\xb7\xc8\xb4\x94\ +)\xd9h\xb4y\xc08\xd2\xb9\xd4\x05@\xd8o\x02\xce\ +\x1c\xf1fK\xc3\x00!S\xb2Q9[&\xca<\x80\ +\xba\xbdu\x8f\x80wW\x81\xdb\x01g\xef;\x84X\xe6\ +a\x03\xef~\xda\xb9\xd8\x05\xa0:\xab\x0f\x9ct\x8ep\ +\x08\xfb2\x0eM\xf3\xd1m\xdf\xd0\x06\xa6\x89\xea\xac>\ +\xe8\xdc\xe8y\x1f\x00\x90\x9f\xb7\x8c7[\x02F\x02\x0e\ +\xb8\xedM\xaf\xd4\x8b\xaa\x07\xc4\x0e\xac\xec\xbc=\x8f\xd9\ +2\xf0x@\xf8\x1dL\xe7\xaaEUzm\xee\x08\x00\ +\x86\x13B\x92\xe6!\x02\x00\x0c\x17\x84\xa4\xcdC\x00\x00\ +\x80\xdc\x82e\xcd\xdb\x22\x81\x10\xcc\xeblmV\xb7B\ +r\x87*7g\xcf\x99l\x19\xf8F@\xf8\x1dC\x13\ +\xb5\x82\xd6\xa3\x02\x83\x00\xc0\xfeBH\xcb<\xf4\xbc\x13\ +\xec\xad\xca\xb4\xaa\x98&\x80\x8d\xc8`8*g\xcb\x99\ +\x92\x8d\x86\xe6\xdfIq\xcd;\xa7\xc9P\xf3\x10\xa3\x03\ +Z\xca\xceY\x0e\xd9\x22\xf0X@\xf8?\xcd\xeb\x95~\ +;!\xa6\xf9\xbb\xceib}Z\xbf\x8dsFl\x00\ +\x10\x1f\x02\xd2\xd9\xea\x8c~\x17\xe7\x8c\xbd0\x0f1F\ +\xa0]\xd5\xa2*\x98\xce\x01w\x02\xc2\x1f\xc7l9;\ +o\xcf\x87\xe6\xcf\x97\xec\xf4^\x98\x87>\x01@\x03\x82\ +\xa1\x09\x12\x86\x90/\xd9i\xefl\x85@\xf32M\xf6\ +k\x1e\xfa\x1c\x81ve\xca\x96\x17v\x83\x04\xc6\xa1\x1f\ +\xf3\x95\xa2B~\xbc\xed\xa8\xbe;\xa0\xa5ZA\xeb\xce\ +i\x92\xf0NX\xca\xcd\xd9s\x9d\x1bM\xf3\xc1m\x0f\ +:?\xa8yH\xa0\x03Z\xca/\xd8\x0b\xde\xdb\x0d\xe0\ +\xeb\x01\xe1\xff\x90\xe9l\xa5\xa8\xdf\x03\x8c\xcd\xdb\xb3\xce\ +l\x058\x16\xf9I\xe3\x1e\xd2d\xb5\xa0_\x0fVq\ +C\x89\x01\x80\xfe l;\xfc~\x99\x87\x84\x01@<\ +\x08&6d@\xc8\xdde\x0a\xe6!\x05\x00\x00\xb99\ +{\xd1d\xd7\x09\xeb\x84h\x19\xf7\xec\x90\xce\xd7\xa6\xf5\ +^\x22\xf9\xda\x94\x0a\x00H\x10B\x8a\xe6!\x81o\x81\ +\x9d\xd4\xb8B\xeb<\xd0\xf5\xc7\x88`\x19\xf7<\xba\x90\ +\x96yH\xb1\x03Z\xca\x96\xed{\x98]G<\x1a\xeb\ +\x83M\xf3\xf5\xa2\xdeM\xa94`\x0f\x00\xc0\x7f!,\ +\xa2\xc8G\xee\x0d\x19\x9b\x1eM\xa4m\x1eR\x1c\x81/\ +\xc9\xb3\x81\xf8\x228\xde\xe9\x0b\x5c\xd0\xcf\xee\x81\x95:\ +\x80l\xc9N\xe1l\x95\xb0\xa7\xb7\x0d\x99\x8d8\xb3\x95\ +\xb1y{6\xbd\xca\x1aJu\x04\xda\xcc?\xd1g\x8a\ +\xcf\xbd\xf4r}F\x7fH\xb2\xaev\xa5\x06\xa0i~\ +\x05xr\xc0T\x9f\x1b\x1a\xaf\x15\xf4~\x12uu*\ +\x95\x11\xc8/\xd8\xc9\x84\xcc\x03\x1c\x13\xb6\x9a)\xdb3\ +\x09\xe4\xeaR\xe2\x00\xf2\x0bv\xd2{[%\xc0\xbc\xc1\ +\x96`+ \xed1a+i@H\x14@\x1c\xf3\xc0\ +}'Mn7\x9e,\xfd+ \xfe\x894 $\x06\ +`\xb4l'\xe2\x98\xc7t\xb12\xa3\x9b\xf5\xa2\xdeu\ +\xe8\x021 dKvj\xb0j\xff\xa7D.\x82\xa3\ +e;q\x08[#\x86\xf9jQk\xed\x8b\xf9\xb2\xfd\ +\xc0c\xef\x00\x8f\x04\xe4\xf8\x0c\xaf\xf1\xea\xac\xfe\xd8O\ +\xbd\xed\x1a\x18@\x5c\xf3\x86.\xd5\x0aZ\xed\xb5\x99\x9b\ +\xb7\x97\xcc\xec\x1a{\x08a\xa0\x11\x18-\xdb\x09Gx\ +\xdb\xeff\x1e\xa02\xa3\x9b\x92.\x128\x0e\xb8\xc1\xc7\ +\xa1\xef\x0eh\x99\x17<\x15\x10~\xdfK\x97\xeb3Z\ +\x09\xc9\xdd\xec\x84w\x88~]\x07\xe0S\xe74\xbe>\ +\xad?\x85\xe4\xeeT_\x00\xc6Jv\x5c\xce\xd6\x02\xcd\ +oz\xe9R\xa8\xf9\x96\xf6\x0aB\xec\x11\xd8\x0b\xf3\xd0\ +\x18\x07L\x17\x81\xfb\x01\xe1Ozo\xab\xf9\x05;\x19\ +\xf7\x9cX\x1d0V\xb2\xe3\xaeqo\xfft@x\xdf\ +\xe6\xdb\x95\x9d\xb33\xc8\xae\x11\xd8\x09\xdb\xe8\xcc\xad\x82\ +\xfe\x1c\x9a?\xb8\x03\xe2\x9a\x97\x0f\x9f\xf9\xddT-j\ +\xcd\xd0%\x02;\xe1\x10\xb66Z\xb6\x13\xa1\xf9\x83:\ + \xbb`\xdf\xc5\xdb\x1a1\xccWf\xb5\x1cZD\x88\ +2e\x1b\x17\xf66\x09wB$\x80\xb8\xe6AS\xd5\ +\x82\x96\x02bckl\xde^vfo\x11\x00\xc1\xe0\ +\x13\x8f\xc6\xa3 \xec\x0a`\x98\xcc\xb7\xd4\x84\xf06t\ +\xbf\xf5\xd9\xa9\x10\x08;^\x03\x9a\xe6\x83g\x1e\xe9J\ +\xda\xe6\x01\xea3Z\xf1\xd2%`3*V\xf0\x94\xc3\ +V\xc7Jv|\x97\x98n\xb5\x99\xfff\xd4!\x06[\ +\x92\xa6\xaa3Z\x8c\x8aMRq;\xc1\xbc\xce\xd4g\ +\xf5\x97\xce\xbd.\x00\xf97\xec\xdb\xfe\xb0\xdd\x02\xbe\x15\ +\x90x_\xcc\xb7\x94+\xd9Ys\xf6\x16\x01\x10\x80\x8f\ +\xbd\xd3h}Z\x7fk_\xec~[\xfc\xb0\xff1_\ +\x01\xf3\x00\x95Y-\xcb\xeb2\x01\xe3\x00<-\xef\x7f\ +\xd2\xb9\xd8\xeb\xff\x05^\x8a\xcad\xb0\x85\xd7\x95\xfd4\ +\xdfR\xe3\xebVS\x04A\xd0\x99\xce\x95^\x17\xc1\xed\ +\xddR\xb4\xcc\xd7fu#\xb4\xc8\xb4\xd5\xb8\xf8FC\ +P\x0fo\xdd\x00\x1ao\x7f\xf5\x94\xc1\xd6!4=L\ +\xe6[\xaa\x16\xb4\x84t\x85]!\xd8\xf5\xce\x95.\x00\ +f\xee\xaa\xc1_\xbb\xd6\x9b\xe6\xd7\x0b\xeaJ2,\xaa\ +\xcehqG\x08\xc6\x87\x0f\xfd\xdb]\xed\x5c\xee\x02P\ ++\xe8\xb3\xed\xc3\xca\x81\xfd\x1c\xf8\x08\xf8\x18x\xd3\x99\ +^\x18f\xf3-Ug\xb4\xe8\xa5<\xc6\x02\xf0w\xe0\ +#d\xbfxh[\xd9\xf7^\xd5'\xfb]\xdf\x81\x0e\ +t\xa0\xe1\xd2\x7f\x00r\xd2I0.\xe9\xad:\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x01Q\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\x03IDATx\x9c\xed\ +\xd6!N\xc4P\x14\x85\xe1s\xfb\x9a\x0a\x04\x0a<\x1b\ + !\x81\x04\x8b\x83\x05\xb0\x06\xdcLHX\xc0P\xcf\ +\x18@\xa2\xf0H\x12p\xd8Q\x84\x1d\xa0H\xc88\x04\ +\x99L\xda^,y\x0fp}\x93\xd0\xff\x93\xe7V\x9c\ +\x1e\xd3J\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0 \xd8\xdf\ +g\xb7\x83\xc9y\xc8S\xa5\x1fOR\xa7\xba\xee~\xbb\ +\xff8\xc0\xee\xc9\xc5\x86Y5\x95t,i\xad\xa7n\ +\xb9,\xe4~\xdfV\xc5\xf8\xf9z\xf4\x16\x1f\x93\x01\xf6\ +G\x97\xeb\xcdR/&me\xa9\x97\x8bi\x1e\x9an\ +{vs\xfa\xfe=.\xe2\xe7\xda\xa5\xea\x7f\xf7\xf2\x92\ +\xe4\xdalB1\x8d\xe3d\x00\xb9\x1df)\xb4\x02&\ +\x1d\xc5Y:\xc0\xc0\xa4\x03\x98?\xae\xa0G\x16.=\ +\xc4Y2@\xa84q\xe95K\xa3\x9cL\xf3\xb2\xed\ +\xce\xe28\x19`v5\xfe\x08e\xb1'\xe9V\xd2g\ +\x8en=[\xc8\xfd\xae-m'\xfe\x02H\xfc\x08\x01\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00C\xf1\x05\xad\xf1<5\ +6P\x8ei\x00\x00\x00\x00IEND\xaeB`\x82\ +\ +\x00\x00\x01\x8d\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01?IDATX\x85\xed\ +\x92\xb1J\x03Q\x10E\xcfM\x02\xa2\x18\x82\xad\xac\xd9\ +MZ\xc1_\xb0\xb0\xb4\xb0\xb3\x13\xed,\xfc\x02A\xb0\ +\xb2\xf1\x07\x14Ia\xabbg-\xe8\x1f\xf8\x03\xbao\ +\xb3 \xa6\xd1\xcaB\x937V\x09b\xb7oa\x1b\xf7\ +t\x033w\x0e\xef\x0d\xd4\xd4\xd4\xfcwT\xa4\xd9\xcc\ +\xe4\xb2\xdc\x03\x98\x1f/\xf5z\xbd\x8f\xb2\x02\x8d\x82\xfd\ +3a5Z\xeff\xd6\xacT@\x92\x17\xda\x9e\xd6.\ +\xcb\xc7\x95\x0a\x00\xc4qt\x83\xe9dZ\xa7\xe9\xf0\xa9\ +R\x01\x80$\x89\x8e\x80{\x00\xc4\x9as\xd9Y\xa8@\ +\xa1#\xfcK\xea\x86\xf6+h?\x8eW.*\x150\ +\xb3\x86\xcb\xf2\xc9\xb4\xf6\xb2\xf5~\xb7\xfbX$#\xe8\ +\x0b\xa6H\xf2\x0b\xf3s\xedY\x98\xe9\xa1hF)\x01\ +\x80\xd1h\xf4\x05JC\xe7K\x09\x98\x99\x16\xdb\x9d\x01\ +X\x02z\xf3\x93fR\xa9@\x9a\xe5\xc7\xc0\x0e\xf0)\ +&\x9b\xfd\xfe\xb2+\x9a\x11|\x84/.\xdf\x15v\x09\ +x\xa1\xad8\x8e\xeeBr\x82^\xc0\xb9|C\xd8\x00\ +\xc0\xa4\x83\xd0\xe5A\x02\xce\xb9U\xc3n\x81\x96\xc1i\ +\xaf\x1b\x9d\x87./,`f2\x1a\xd7@G\xe8*\ +\xe9F\x87e\x96\x03\xb4\x02f^\x81g\xef\xbf\xf7$\ +\xf9\xb2\x025555?n9f\xc8\x1a\xa6\xbcV\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\xde\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x90IDATx\x9c\xed\ +\x98\xcfoTU\x1c\xc5\xcf\xb9\xf3\xd2\xd4\x041J\xdd\ +\x89.\x81u\xdb\x991\xc6d\xaa\x81\x98.\xb4\xd3\x1a\ +\x16\xec\x90\x10\xfd\x03T\xe2\x82\x18bB\xfc\xb16!\ +P`EL\xa0\xf3\xa6\xb8`\x92&2$\xd8\xc8\x88\ +\xac\xd55\xee$\x1a\xe3\xa2U\xda{\x5c\xcc\x80\xd3w\ +o;\xbf\xde\x9b\xa9x?\xcb\xfb\xee\xfd~\xcf\xf7\xbc\ +\xef\xdcw\xef\x00\x81@ \x10\x08\x04\x02\x81@ \x10\ +\x08\x04\x02\x81\xff\x17\x1cU\xe2|EeR_\x020\ +\x90.4\x16r\xa7G\xa1c$\x06\x14c\x9d\x14t\ +\x0e\x80y,D\x94s$\x11?\x8c=\xe4\xec\xed\xa3\xfc5\x0b\ +\x9d\x99\x180yU/F\x91V\x00\x1cHd\x13\x05\ +\xbb\xe3\xeeF\x18\xc8\xd1\xf5\xb35<|w\x8e\xf7S\ +\x96\x9a\xbe\x01\xc5X\x87\x04\xad\x00x!\xf1H ,\ +:\xed\xed\x04$\x18\xba\xda\xee\x1b\xcb#\xdf\xbd\xcd\x9f\ +\xd2S\x9b\xf29`\xba\xa2iA\xb7\xe1+\x1e]\x14\ +\xdf\x9aI\xc0\x82\xce\xec\xfd\xd6\xe8\xdb\xfc\x92\xa6R\x11\ +\xdb\x225\x03\xa6\xabz\xddP7\x01\xeck\x1f\x17\xd4\ +,\xbeW\x04\x0b8&\xec\xa3Q=\x1f\xeb\xb5\xbe\x85\ +&H\xc5\x80b\xacy#\xdd\x00\xb0\xa7}\x5c\x90\x08\ +\xf6^\xfc\xbfX4\x0dlg\x0f\xa1Z\xbe\xa2\xf2\x00\ +q\x1f3\xb0\x01\xf9\xaaN\x08\xba\x06`\xac}\x5c\xa0\ +\x1d\xb0\xf8\x16\xb4r\xe3\x8c\x91Z*\xc4zg\xd0\xe8\ +\x03\x19\x90\x8f\xf5\x01\xa5\xc5d\x9cf\xf1\xce\x9b\xeb\x1b\ +B\xf2\x98`\x00],\xc4\xeap\xb4\xee\x14\xbb\x1f$\ +\x16c\xfb\xa9H\xe7\xf2\x22\xc0\xd2\xfd\xed\xa6\x05\xe1y\ +i\x82>\xfb\xbel>\xea\xe7\xfe\xd0\xb3\x01\xa5\xba\xa2\ +\xf5\xdf\xec9\x91'\x5c!\x99\x16\xdf\xcc!\x90\xf4\x9a\ +\xb0\xf8\xd2\x86y\xef\xda\xd1\xed\x0eY~z2\xa0t\ +Y\xe3k\xcf\xe8\x0a\x80\xf9D\xf6f\xf1\xee\xa7+\x13\ +$\x90\x80\xf1\xa8\x8f\x9f\x1b\xe7\xb1\xda,\xff\xea6V\ +\xd7\x06\xbcr]Oolj\x19\x80\xf3\x09j]j\ +\x86R|[No'\x10\xf8&\x97c\xb9\xdb\xfbC\ +W\x06L~\xad\x89hS5\x08[\x0f!\x12\xc0\xde\ +Z.UH\xc0\xda\x1c\xb8\xb5\x0c\x02w\x1fF\x9c\xbd\ +\xf7&\x1ft\x0c\xd1i\xc2\xf4\xb2\xf6\x1b\xab\x15\x00\x07\ +\x13\x8f\xfa;\xe0d\x81\xff\xfe\xf0#\xc4#\x8d\x05\xfe\ +\xb2\xd3\xd2\x1d?\x83//\xe9\xa0\xb1Z\xc5n.\x1e\ +\xd8\xee\xd4x\x88F\xabS\xd7u\xc0\xb7\xe4\x11\xdbv\ +@~IS4\xaa\x01\x98p\xd2\xed\xa6\xe2\xdb\xf1w\ +\xc2\x03\x90o4\xca\xbc\xe7[\xe2\xed\x80BE34\ +\xaa#Q\xbcvs\xf1\x00\xd0\xbcj';a\x02R\ +\xbdXU\xc9\xb7\xc4\xe9\x80BE\xa7at\xc6\xe3\xe4\ +p\xb7\xf9\x01q\xc4\x13\x82\xe5\xc7\x8d\x05~\xb2\xe3\xbc\ +bl7\x04\xf8\xfe\x9e\xfa\xcfC`\xf3\xce\xbc\x89\xda\ +\xc7<'\xaa'\x17_m\xee\x1e@\x9em\xed\xaaO\ +\x16\x82\x05yv\xd42\x02\x81@ \x10\x08\x04\x02\x81\ +@ \x10\x08\x04\x02\xa3\xe6\x1f<\x8fP};\xd7\xa3\ +\xf5\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x05\x08\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\xbaIDATX\x85\xe5\ +\x97[l\x94E\x14\xc7\x7fg\xbe\xd2*x!-\x89\ +\x8brm@\xb1Q\xa3t\xb7\xe8\x837$\x90\x80\x5c\ +4VC4b\x08tKa\x0b\x9a\xa0\xa0\xc4\xb5\x01\ +\xb1\xbe@\xba]ZvmbHx\xb2\x89\x0dT@\ +I4\xf0\xa4\xa5\xbb6<\xd8`L `iK\x84\ +&\x1a\x01\xbb\xec\xce\xf1a\xbb\xcb\xd7\xfbE\xdf\xf8\xbf\ +}g\xce9\xff\xff\xcc73\xe7\x0c\xdc\xe9\x90\xf18\ +\xfb*\x0e\xcc\xb4\xa9\xe4\x1aQY\x820\x13a\x06\x8a\ +A\xb9\x8cH\x07\xc2iGmSKd\xebo\xff\xab\ +\x00oy\xa8\x04\xa5\x1axq\x8cY[Eugk\ +d\xeb\xf7\xffI@qY\xe4~\x91\xdez`m\x9f\ +\xa9\x0b\xa4Y\x95\x13\xea\xa4\xce\xeb?\xa6k\xd2dc\ +5\x81\xc7\x8a\x9dc\x0cK\xd5\xb2\x1aav_\xfa\xe3\ +N*\xb5\xbe\xa5a\xdb\x95q\x0bXXq`\x9eI\ +\xda\xa3\x88>\x0at\x89\x10\x9c\xf2\xc0\xb5/OUU\ +%G\x9cR0h\xbc\xdd\x05o\x80\xec\x01-\x04.\ +\x19Xu&Ryv\xcc\x02\xbc\x9b\xf6\x15bsZ\ +\x80i\xc0\x11'\x97\xb7[j+\xff\x1a\x91x\x00\xe6\ +\x05ByS{\xa9CX\x0f\x5cGx6v\xb0\xb2\ +mT\x01\x8b\x02\xa1\xfb\x92\x09~\x14(R\xb4&\xee\ +\xe9y\x8f\xaa*;\x1e\xf2\xdbP\xf1\xf9C;\x14\xd9\ +\x0bt\xa8\xa6J\xe2\xd1w\xbb\xdc\x1e9\x03CR\xbd\ +\x84E(\x02\x9a\x87\x22O\x9f\x84\xd4\x06\x81\xe5\x02\xb3\ +\x14,\xc8EU\x8eA\xb2\xa1?\x81hkD\xab}\ +\xe5\xb5\x85\xaal0\xe2\x1c\x06]\x02\xa2C\xae@\x89\ +\xbf\xd6k\xd1V\x84?\xd4\xe6\xcd\x8fG\xfd\x7ff\x07\ +\x83A\xe3\xeb\xce\xff@\x91\x8f\x81\xbb\x86\x99\xf2uU\ +>\x8cG\x03\xb5n\x92\xa2\xd2`\xee\xe4\xfc\x82\xb3\xc0\ +\x02\xd0\x15\xb1\xc8\xd6\xe3\x991\xe3\x8e\xb6\xa2\x9f\x01\xa8\ +\xea\xee\x81\xe4\xde\xee\xfcC}K9\x1c9\xc0\x14\x11\ +j\xbc\xfeP\x1dhvr\xed\x8dU\x09\x81\x8f\xfa\xe6\ +\x5c\xed\x1e\xcb\x0a(.\xdb?\x1d\xe5%\xa0\xe7fO\ +O\xc4\x9d\xd5\xd7]\xb0\x0b\xe4\xad\x11\x88]P@\xca\ +}\xfep\xa5\xdb\xda\x1a\x094\x01\xe7\x80\xc7K\xfc\xb5\ +O\x0c\x12 \x98\x95\x80\xa0\x1cko\xacJd\xec\xde\ +M\xfb\x0a\x15v\x8d\x8d<\x9d)-C?}jK\ +\xed\x83.\xbb\xa2z\x14\xc0\x8a\xbe2H\x00\x22/\xa4\ +\x03\xe5\xdb~\xe94\xa7\x02\x984v\x01YLq\x12\ +lt\x1b\xac1\xdf\xa5s\xca\xe2\xc1\x02`&\x80#\ +r\xc1\x1d\xa4\xca\x8a\x09\x90\xa7!\xfa\xb2\xfb3\x97\xe4\ +y\x00\x85\x19\x83\x04d\x8cFn\xb9\x8e\x91\x0aP8\ +q\x01\x99+9\x8d\xab\x93\x9cL\xee\x872\x1b\xd1\x0c\ +\x0ar#\xf8\x89\x8c\xea3\x12\x14g\x94\xdc\xeeM\xc8\ +e\x80\x848\x9e\xacS\xfa\x12\xba8a\x01\xc8%\xf7\ +\xd7\xbd\xd6x\xd2\xba\xe8\xcc\x5cp\xb7g\xa7\xf2;\x80\ +\xb1\xcc\x1d\x90\xe48\x13\x85h\xbfXs+U\x08 \ +\xd0\x91\xb5\xdd\x1e\xd5S\x00\x22\xb2\xcc\x1d\xe4\xa0\x07\x81\ +\x89\xd4\x82\x84IJC?\x01\x86\xa5\x00\x0a?\x0c\x12\ +\x90\xca\x91f\x00U]Q\x5c\x16\xc9\x1e\xbb\x96He\ +;\x10\x1a7\xbd\xca\xde3\x0d\x81\x0bn\x83UY\x05\ +`l\xaai\x90\x80\xb6p\xa0S\xd2\xca\xa6A\xef\x86\ +~\xb94\xef\xfd\xf1\xfd\x0am\x8cM\xbf\xba\xdbm\xf1\ +n\x0a\xaf\x14(\x02~i\xfdb[\xb67\xe8\xbf\xc3\ +\xad\xdd\x01 BpQ t_\xc6\x1c\x8f\xfao\xa9\ +\xe6\xaeQ\xb4\x86\x91\x7fG\x12a\xef\xdc\x9e\xe9k\xdd\ +U\xb4\xa84\x98\xab6]g\x04v\x0e[\x0d\x01\x8a\ +\xfd\xa1\xc3\x02o\x02Gb\x9ek\xaf\x0e,\xc7\xde\xf2\ +\x9a\xc7P)\x07\x96\x03\xb3H_\xfe\x17\x15\xfdF\x8c\ +\xd6\xc7\xea\xb7\xfd:`5\xc4[V[\x8f\xe0\x07N\ +\xc5\x22\x81\xc5#\x0bH\xf7\x81?\x01\x0b\x80}1\xcf\ +\xb5\xed\xc35$\xa5\xa5_9\x00\x8d\x8d\xaf\xa7\x86^\ +\x10\x15oyx;\xaa\x9f\xa3t\xa6r\xc5\xd7\x16\x0e\ +t\xba=\x86l\xc9\x16V\x1c\x98gR\xa9\x16 \x1f\ +\xf8\xfa\x86\xe3\xack\xaf\xdb\xfc\xf7\xd0$C\xa3\xa84\ +\x98{w~AX`#p\xc3 \xcf\x9f\x89\x04b\ +\x03\xfd\x86mJK6\x86\x1f\xb6\xc6\x1e\x05\x1eQ\xe4\ +\xb2@\xf0\x1e\xcf\xd5CciJ}W\xf2_\xb3*\ +{\x04\xe6\x03\x1d\xaafu<\xba\xe5\xe7\xa1\xdcGl\ +\xcb\x9f|g\xff\xd4\x9c<\x13\x05)\xed3u\x88\xd0\ +\x8cr\x02k\xce\xe7\xd8D\xd7\xcd\x94X'7\xc7\xa3\ +\x86\xd9\xc6\xdae\x88Y\xdd\xd7\x0d\x03\x9c\x14\xc7Y\xd7\ +Z\xb7\xb9{8\x8e1=LJ\xfc\xe1g,Z\x0d\ +\xfa\xdcX\xfc\x816Uv\xc4\xa3\x95'Gs\x1c\xd7\ +\xd3\xec\xe9\xf2\xfds\x92\xd6Y\x83\xb0\x04\xed{\x9a\x81\ +\x03t\xa4\xafW=m\xd54\xc5\xa3\x81s\xe3\xc9{\ +g\xe3_^\xef\xd7=\x0b\xb2_B\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\xcd\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x7fIDATx\x9c\xed\ +\xd9Q\x0d\x800\x10\x05\xc1\x03oU\x80\x05\xd4b\xaa\ +\xc8X\x12f\x0c\xdc\xcb\xa6\x7f\x9d\x09\xad\xeb\xde\xeb\xba\ +w\xb9\xe1,\x8f\x7f\x81\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\ +\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\x9a\x00\xf5\x80\xda\xef\ +\x03\x1c\xe5\xf1\xfak|\xa6~\x01{\x9e\xf4>\x00\x00\ +\x00\x00\x00\x00\x00\xfc\xc3\x0b\xb7&\x07\xfa\x17\x1e*d\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x08\xe5\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x08\x97IDATx\x9c\xed\ +[ml\x14\xc7\x19~\xde\xb9\x0f\xdb\xa1\xfeh!\xa1\ +\xc8\xd0\x06\xac (\xa6*\x98V5E`\xc0\x9c\xeb\ +\xaa\x98\xf8`\xd5\x90\x0ab\xe3\x8f\x86\xa4\xadJ\x94F\ +\x02)9\xdc\x86~\xa4\x0d\x09\x89\x14\x08\x9c\x8d!\xd0\ +H=l#\x93\xc6\xe1l\xa7F\xa4\x80B U\x02\ +6QR\x87Pj%Q\xb1\x9d\x03\x81\xed\xbb\x9b\xb7\ +?\xf8\xda\xdd[\x9f\xef|\xbb\xaei\xfd\xfc\x9bg\xde\ +}\xf7\xd9\xe7fgfg\xe6\x801\x8ca\x0c\xff\xcf\ +\xa0\x91\xb8I\xa1RzwP\xda\x17\x0a\xe2\xd9\x921\ +\x83\x80i\x00g\x80(\x0d\x126\x10\x02\x00\x02 \xbe\ +\x00\x89\x0e\x16\xd4.\x08G\xfd>\xef\xc7Vk\xb3\xcc\ +\x80%\xf7Wf\x09{\xb8D0\x151\xf0\xcda\xa6\ +\xf9\x98\x99\x9b\x18\xa2\xb6\xb5~\xd7;\x00\xd8L\x8d\x80\ +\xf9\x06\xd0\xd2\xe2\xb2\x02\x12\xe2\x09\x02/69\xf7\x19\ +&l\xed\xf9\x8a\xd8wj\xe7\xce\xa0YIM3\xa0\ +\xc0\xbdn\xb1$\xf1\x0c\x80yf\xe54\x06\x9f'`\ +\xb3\xbf\xaez/Lh\x11\x09\x1b\xb0\xb4\xa8|\x22\xd9\ +\xf1,\x11~\x1c%L2\xf07b\xb41\xf8\x9c \ +\xdb?\x18\xd4\x1d\x14\xfd\x97S@\xe1\x810R\x89D\ +:\x88\xa6\x821\x9d\x88s\xc1\xb4\x0c@\xca`\x09\x19\ +8j\x03\xad?\x5c\xb7\xebl\x22\xfa\x132\xa0@)\ +\xfb\x8e\x94t\x10\xc0$}\x1d\x03\x97\x01\xbc.\x88\x0e\ +\x85\xc3\xfdo\xb46\xec\xbd\x14O\xee\x5ceC\xca\xb8\ +p`\x09A,\x07q\x91\xd1=\x00\xf4\x01X\xd7\x5c\ +\xe7}uX\x0f\x80\x04\x0c\xc8w\x97=HD5\x00\ +\x92\x22D\x11\xbd\xe0t\xda\x7f\xf7\x97?m\xef\x19n\ +~5\x14Eq\xf6\xca\xf4\x0a\x00O\x01\xb8G_O\ +\xc0\x96\xdc\xec\xcc\xa7\xaa\xaa\xaad\xbc\xb9\xe36\xc0\xe3\ +\xf1\x88cg\xbb\x9e\x06\xf3F]\x95\x04\xa3\xc6\x0eT\ +5\xd5{/\xc6\x9b7\x16\x14\x15\xadK\xbdj\x17\x8f\ +\x11\xe1q\x00_R\xd71\xe8`H8\xd6\xb4\xf9^\ +\xba\x12O\xce\xb8\x0c\xf0x<\xe2\xd8\xfb\x17\xf7\x83\xe8\ +\x01]\x96.A\x5c|\xd8W\xfdv<\xf9\x86\x8bB\ +w\xf9\xe4\x10\xa1\x01\x91\x1d\xee\xbb\xf6\xe4kyM\xfb\ +\xf7\x07b\xcde\x8b\xe7\xc6\xce\xf1\xf7U\x81\xe8Q\x1d\ +}B\xb0Xz\xb8\xce\xfbA<\xb9\x12\xc1G\x1d\xa7\ +\x03\x13\xb3\x17\xeds\xc8\x81{\x894s\x8cI\xe1\x90\ +cvNv\xd6\x9f\xdb\xdb\xdbc\x1a!b6\xc0\xe5\ +.\xff\x11\x08/\xea\xe8=\xc1\xd4\x90\xd2\xfajuo\ +\xacy\xcc\xc2\xc5\xf6\x13\xa1\xce\x8e\xd3\x0dY3\xe7\x5c\ +\x05Q>n\xb4f\x02\xa6\xf7!%\xb9\xb3\xfdtK\ +,ybz\x05\x96\xad\x5c7\x0f\x10G\x01$\xab\xe8\ +}\xcdu\xde\xb5\xb0`v\x16/\xf2\xdd\xe5\xbf \xc2\ +sj\x8e\x09\x0f\xb5\x1c\xf0\xee\x1d\xeaZ1T\xc0\xd2\ +\xe2\xb5\xe3\x01q\x10\xea\x87g\xbc\x1dL\x0dU`\x14\ +<<\x00\xb4\xd4{\xb7\x81\xb1[\xcd\x11cW\x81\xbb\ +r\xeeP\xd7\x0ei\x00\x89\xa4g\x00d\xde&\xd0\x85\ +\x90,n\xab\xad\xed\x1b\x8eX\x8b\xc0\xf6k)\xeb\x01\ +\x1cSq\xce0\xc9]yy\x1e{\xb4\x0b\xa3\x1a\x90\ +\xafT. \xf0:\xf5\x8dXbescMW\x02\ +b-AS\xd3\x8b\xfd2\x087\x18\xff\xbe\xc9\x110\ +\xd79\xfe_\x8fD\xbb.\x9a\x01D\xe1\xf0ou\xdc\ +\xfe\x96z\xef\x89D\x84Z\x89\xd6F\xefg\x0clQ\ +s\xccx\xd2\xb5f\xcd\xb8\xc1\xae\x19\xd4\x80eJ\xc5\ +B\x10-PQA\xc9a\x8f\x09:-E(-\xb4\ +\x03\xc0\x85[\x04a\x02_M\xfe\xc9`\xf1\x83\xb7\x00\ +\xc6/\xb5\x04\xbd\xdcZ\xbf\xbb3a\x85\x16\xa3\xad\xb6\ +\xb6\x0fL\xba\x1f\x8a\x1fS\x14\xc5p\xc874 O\ +)\xf9*\x98\xbf\xaf\xa2\x822\xc8O\x9b\xa6\xd2bd\ +\xd8z_\x01\xf8C\x15\x95\xd9#3\xf2\x8db\x0d\x0d\ +pH\xc7\x83\xd0N\x92\xdelm\xf4~f\xa2FK\ +\xe1\xf3\xf9\xc2`\xf2\xa99\x02?d\x14;\xc8+\xc0\ +\xcb5\x17\x135\x9a%n\xa4@$\xf4\x9a\x7f`\xf4\ +\x1aD\x18p\xa3\xc7\x9c\xaf\xe6$\xd1k\xe6\xca\xb3\x1e\ +\xb9\xd9\x93N\x82\xa0n\xb5\xe9\x01\xa4\xe5\xe8\xe3\x22\x0c\ +\xe0k\xce\xef\x02p\xaa\xa8\xbf\xb7\xf8v^\xd0\xc7\x8d\ +vTUUI04?\x9cd\x11\xb1N\x19\xf9\x0a\ +\xb0\xc8V\x17\x89p\xd4tu#\x04\x02k\xb53f\ +\xe9c\x0c\x0c\xc0LuQJ\xfa0\x22\xe6N\x01\x09\ +\x9dv\x9e\xa9\x0f\x894\x80\xf8^-!G\xfd\xd8?\ +\x18\x06(\xa8\xd7>U\x1fc4\x0a\xa4\xaa\x0b\x04\x8c\ +\xf8\xb7\xbei\x18\x17\xa1=U\x1f2\xa4\x01\x829\xae\ +5\xb6\xd1\x84\xb6\xda\xda~\x00!\x15\xe5T\x14E\xdd\ +\xc1\x1b\x1a\xa0Y$\x09\x091*\xbe\xf9\xadB\x84\x01\ +\xc4\xb8\xac\x09`\x8eh6w\x0a\xf2JJ\x92\x00\xa8\ +\xd7\x03\x06|>\xdf\x80:&r\x1ep}\xa7\xf6v\ +\x19\xc8\xb0F\x9e\xf5\xb0u\xdb\xd3u\xd4e}L\xa4\ +\x01\xc0'\x1a\x82\x22{\xce;\x06Ir\x9a\xa6\xcc8\ +\xaf\x0f1\x9a\x07t\xa8\x8b\x04\xba\xcfdY#\x06b\ +\xa1\xd1\xce\xc09}L\x84\x01\x82\xa1\xd9ld`\x81\ +>\xe6N\x81`\xd6j'\x9c\x89\x88\xd1\x13\x03v\xe7\ +q\x00\xb7\xf6\xdf\x09\x98[\xe8.\x9fl\x85@+\xe1\ +\xf1x\x04\x83~\xa8!\x19m\xfa\xb8\x08\x03n\xec\xad\ +\x1dWs!\xd2%\xba\x03\xf0\xd6\xfb]9\xd0\xec(\ +S \xd4\x9d\xf9\x8e>\xcep=\x80\x00\xdd\xe7\xaf,\ +2U\xdd\x08\x80\x84^3\xbf\xd1\xd6V\x15\xd2\xc7\x19\ +\x1a\xc0A\xb9\x1f\x80j\xab\x99\x96\x14*\xa5w\x9b\xaa\ +\xd0Bx<\x1eAL\xabt\xf4\x1e\xa3XC\x03\x9a\ +\x1bk\xba\x88\xe0WQIAi\xd7o\x87\x8fZ\x1c\ +?\xdb\xb5\x1a\xc0\x8c\x9be\x02>\x0d^\xca\xf4\x1b\xc5\ +\x0e\xba*\xcc\xe0?\xaa\xcb\x04~t\x89\xbb\xec\xeb\xa6\ +\xa9\xb4\x08\x8a\xa28\x99\xf9\xd7j\x8e\x99\x9f3j\xfe\ +@\x14\x03\x9a\x0fT\xbfI\xac\xe9\x0c\x9d6\xc2fs\ +dZ\x87\x1e\x99V\x09\xedgowJ\x88\xb7\x0f\x16\ +\x1fmg\x88\xa5\xc0&-Ek]Jy\xc4\xba\xda\ +hA\xde\xea\xca\x09\x04zRC2~\xd3\xd8X\x13\ +1\x05\xbe\x89\xa8{\x83-\x07\xbcm\x00\xbd\xa2\x8eg\ +\x89\x86\xa5E\xe5\x13\x13Rj\x01\x14Eq:\xfa\xe5\ +\x01\xa8\xce\x10\x11\xf0^\xf7\x04\xf1B\xb4\xeb\x86\xde\x1d\ +\x96\xb6\xc7u\xab\xabS\x84\x03\xf5\x85\x85?\xd3\x1f\x8e\ +\xfa\xaf\xa2W\xa6o\x03a\x91\x8a\x0a\x92\xe0\x8a\xa1\x0e\ +U\x0ei\x80\xbfa\xc7\xe7,q?\x80~\x15=?\ +xW\xdfK\x18\xa1\xb3\xc6C\xc1\xb5\xaa\xe2\x11\x00\x0f\ +\xab9b\xac\x8f\xe5\xccRLGd:;N_\xcc\ +\x9a9\xe7\x13\x10\x15\xdf\xba\x010g\xda7\xe6N\xca\ +\xc9\xce\xf2\xb7\xb7\xb7\x87\xe3Vm\x0e\xc8\xb5\xb2\xfc\xe7\ +\x0cl\x83\xea\xc7 \xc2\xf3\xfe:\xaf~g\xdb\x101\ +\x9f\x11\xea\xecx\xf7\xbd\xacY9w\x01\xf8\xde\xad\x1b\ +\x019}2y\xe1\xd7\xbe5\xef\xb5\xf3gN]\x8d\ +Gy\xa2P\x14\xc5\x999s\xfe\xcb\x006A\xdb\x12\ +\x0f\x07/e\x96\x9e?\x7f$\xa63\x83C\xbe\x02j\ +dP\xef&\x5c?\x9ev\x1b\x84E\x8e\x81\xf0\xc9|\ +\xa5rv<\xb9\x12\x81\xab\xf8\xe1{z\xc3i\xad\x00\ +\xcatUg\x83\xe1\xd0\x03\x83\x8d\xf9F\x88\xfb\x1dV\ +\x14\xc5\xd6#3\xfe@\xe0\x0d\xba\xaa \x80\xed$\xed\ +[\xfc\x0d;>\x8f7o,\xc8U6\xa4\xa4\xca\xcb\ +?e\xc6F\x10\xbe\xac\xad\xe5&\x16\xb6\xd5-\xbe\x9d\ +_\xc4\x93s\xd8\x9d\x98\xcb]^\xc6\x84\xed\x00\x1c\xba\ +\xaa+Dx\xd6\x96tmk<\x07\x16\xa3!/\xcf\ +cwL\xb8X\x02\xa6\xcdP\x9fW\xba\x05\xde\x9a!\ +\x02O\xf8|\xbe\xb8\xfb\xa2\x84zq\x97\xbbl!\x13\ +\xd5\x03\x18\x1f\xa9\x09=\x04\x1c\x02p\xc8\x96r\xcd\x1f\ +\xaf\x19\x8a\xa28\xbb\xc3\x19\x0b\x05\xf1r\x00+\x00\x18\ +M\xc3\x83\xc4X\xef\xaf\xf7V\x0fG?`\xc20\xe6\ +ZQ:\x85\xed\xb6\xe7\x01\xb8\xa3\x84\x05\x098\xc2\x84\ +\xbf2\xd3\x076\x19\xfe\x88%w;\xc6%_\x91\x14\ +\x08\xf7\x0f\xa4\xa6\x12\xfa\xd3),\xa6\x0a\xc2tf\xca\ +\x05Q\x01\xc0iQr\x9e$\x81\xf5~\x9f\xf7T\x22\ +\xfaM\x1b\xc7]\xab*\x0a\x99\xf9\xf7\x00\xac\xed\x0c\x09\ +]\x00\xff*\x83\x02\xde\xe14\xf9\xc8t&\xe2\xfaa\ +\xea\xae\x15 \xde\x08\xe0\xdbf\xe6\x06\xd0\x09`k0\ +5Tm\xe6\x19E\xcbfr\x05++f1P\xc2\ +\xe0\x22\x00\xd3\x87\x93\x83\x80O%\xe8u\xc1rO\xee\ +\xec\xc9o\x0d\xe7\xff\x001\xdc\xc3z\xb8V\x94N\x91\ +\x0e\xdbb\x02\xcd\x02\xe4\x0c0M\x05\x90\x0e \x0d\xd7\ +wn\xbe\x00\x10\x00\xe8\x9f\x00\x9fc\xe0\x1c\x8b\xf0\x91\ +V\xdf\xee\x0e\x8c\x92\xe3\xb8c\x18\xc3\x18\xfe7\xf1\x1f\ +8\xf1\xe0\xe7\x81\x02^b\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x08O\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x08\x01IDATx\x9c\xed\ +[}pT\xd5\x1d=\xe7\xee&a\xab\x01\x0b~\xb4\ +\xa3\x19\x8aN\x19\x0c\x15[ lB\x11\xc1i\xc7\xca\ +\x00q\x13L\xd5\x0eJu\xa8\xc5\xd6\x99\xd6\xb1tp\ +F\x03\xad\xd8j+\xa8\x7fH[?**\xd3\x99\x85\ +\xcd\x06\xe9\x80:S\x09\x83|lB\xc6\xd6Q\xa1c\ +\xeb\x070\xa9Z\x0a\xe5\xc3\x12\xd8\xdd{\xfaGP\xdf\ +{\xbb\x9b\xecf\xdf\xc6\xa4\xcd\x99\xd9?\xde\xef\x9e\xfb\ +{\xe7\x9e\xf7\xf6\xbe\xfb\xee\xbd\x0f\x18\xc60\x86\xf1\xff\ +\x0c\x0e\xc4I\xae\x88\xea\xbc\xd3e\x98Ik/\x93\xc1\ +\x04\x8a\x17\x0b8\x07\xc0H\x00\x01\x00\xc7\xce\xfc\xf6\x0b\ +\xda\x0b\x987\x11\xc4\xf6\xf6\xf9|\xa7\xd4\xdaJf\xc0\ +\xf4\xb8.I[\xbb\x08\xe4|\x00\x93\xfa\x95Dx\x07\ +F[\xac5Ow4`\x0fH\xf9\xab\xd2o\x03$\ +\xd6\xc5q\xb5\x85\x96\x02\x98\xedgj\x02\xaf\x0b\x5c\x95\ +\xfa'\x9e\xeb\xbc\x8dI\x1f\xf3\xfa\x83pL\xb3a\xf4\ + \x84\xa9~\xe5\xcc\x81w\x05.o\x8f\xe0\x19?\xee\ +\x88\xa2\x0d\x08o\xd4\x05J\xdb\x87\x08~\xa7\x17\x9a\x05\ +\xb0\x03T\x9b\xac\xd9g\x02\xf8\xbbR8l-\x8e\x8f\ +\x00\xd2'\x0d*\xcb\x80Q2\x18'`<\xa0:\x00\ +\xdf\x04\x10\xea%\xe7vk\xb9\xa4c\x01\xdf(F\x7f\ +Q\x06\xd4\xc55\xcdJ\xad\x00\xbe\x98\xa5\xf88\xa8\xcd\ +\x94\xd9d\x81\x17\xda\x1b\xf8\xaf\x82rG\x15J\x07p\ +\x15i\xe7\x01\x9c\x9f\xe3\x1c\xdd\x22oi\x8f\xf0\x0f\xfd\ +\xd1\x0f\x14a\xc0\xb4\x98n\x04\xf5\x14\x81\x0a\xaf(J\ +\x8f\x06+\xcc/_\x99\xcb#\xfd\xcd\xefDuT\xe5\ +\x95A,\x06t/\x80\xf3\xbd\xe5\x82V\xb6\xff\xc5\xdc\ +\x8b\x15\xb4\x85\xe6.\xdc\x80f\x99\xf0${\x1f\xc8e\ +\x9e\x12+\xe8)\xca\xacH4\xf2`\xc1y\xf3\xc0\xd7\ +7\xaa2iq'\xa5\xbb\x00\x9c\xed*\x14ZCi\ +.lk\xe2\x89Br\x16f@\xb3L\xf8r\xbb\x0e\ +\xe0\xf5\x9e\x92.CFvE\xd8^P\xbe~\x22\x1c\ +\xd3E0\x8a{;\x5c\x11\xaf\xb2\x82\xb3\x12sx,\ +\xdf\x5c\xa6\xa0\x13\x7f\xd5.\xcf\xd2\xf8\xdd)q\xea@\ +5\x1e\x00\x12\x8d\x0d \xec\x83\x00.t\x84\xba\x82\x01\ +F\xda\xbe\xcb\xee\xc2\xa5\x96\x08\xa4F\x8f0K$\xec\ +tD\xcbE=>k\xab\x82\xbdU\xed\xd5\x80p\x8b\ +f\x00\xbc\xc5\x11\x12\xc4\xc6\x1d\xf5\xec*Fo)\xb0\ +e\x0eO1\xc8\x06\x00\x87\x1c\xe1\xc9\xddGp{o\ +\xf5r\x1b \x11\xd0/<\xc1u\x89F\xee.Bg\ +I\x91\xa8\xe7\x07\x10W:c\x82\xee\x99\xf4\xa2\xce\xca\ +U'\xa7\x01uq\xcc\x040\xc3\x11J\xa6\xadi.\ +^fi\x11:\x86\xdf\x90\xd8\xef\x08\x9d\xfb\xb9\x8fp\ +[.~N\x03,\xf4\x13\xe71\xa5\xdf\xeeY\xc0\xb7\ +}\xd0XR\xf4\xf4Mt](Aw\xe6\x1a\x1bd\ +5\xa0&\xaa/\x00\xf8\x96#\x94T\xd0\xdc\xe7\x9f\xcc\ +\xd2\xa2*\x89g\x01\xbc\xe5\x08]\xf8\x9e\xc17\xb2q\ +\xb3\x1a\x10\x08\xe2F\xf4LU\xf5\x80x9Q\xcf\x0f\ +\xfc\x14YJ\xacob\x9a\xd0zg\x8c\xc6\xde\x9c\x8d\ +\x9b\xd5\x00A\xf3\x5c\x01\xcb\xe7}S7P0\xc6\xa3\ +\x99s\xb2\xfd\x0d2\x0c8\xd3cNw\xc6Ri\xfc\ +\xd1gy%\xc7\xeeW\xd1\x01\xc0y\xd7\x8e:X\x86\ +)^^\x86\x01\x15\xffA-\x80rG\xe8\xcf\x9dM\ +\xdc\xef\xe5\x0dz\xac\xa0\xa5\xe4\xbapR\xe6\x16\x1a\x8d\ +=^^\x8e\xf9\x00\xba\xde\xa2\x08\xcd\xf7W^\xe9a\ +`]\x9a\x05\xbd\xd06\x9b\xa9L^\x16\x94\x05\xb0\x0e\ +=\x9b\x1a\xceT\xc6UWDu\x9e\xef*K\x85f\ +\x19\x90\x0b\x9c!Z\xb36\x1b5\xab\x01;\xea\xd9%\ +\xe0\xa5O*\x03\x15\xc9\xa0\xf5.\x87\x0fZ\xd4^\x8e\ +\x1b\x00Lp\x84\xde\x0f\x8d\xf9\xb4=N\xe4\x9c\x15\x16\ +\xf9k\xd71\xf8\x83\xe91\x8d\xf5Gb\xe9P\x1dU\ +\xb9\xa4\x9f;c\x22Wg\xbb\xfd\x81^\x0c\xe8\xb8\x16\ +/\xc3\xdd\x19\x96\xa7a\x97\xfb\xa2\xb2\x848\xbb\x0c\xdf\ +\x03]\x83\xb7\xc3e\x06kr\xf1s\xaf\x0c\x91\x22y\ +\xb7'vS8\xae\x8cy\xb5\xc1\x82)\xcf\xeb\x5cJ\ +\xae%|\x88\xf7\xef\xa8g\xc6\x10\xf8c\xf4\xba6\xb8\ +;\xc26P\xcf\xba\xf8R<\xbcQ\x17\x14'\xd5\x7f\ +TGU\x1eHi\x03\xdc{\x88^K\x1d\xc2\xa3\xbd\ +\xd5\xebsu8 s\x17\xdc\xb3\xabUJ\xa9\xe5\x9a\ +\xcd\xf2n\x8e\xfaL12h\x1f!p\xa5#\x944\ +\xe4\xe2\xbe6U\xf6i\xc0\xce\x06~\x08\xf1Z\x01\xa7\ +>\x8e\x91\x98~\xb8\xdb>\xd6\xb3\x80\xfa\xd9#\x1c\xd3\ +\xed\x02\xbf\xef\x8c\x89\x5c\x92\xcf\xb6\x9d\xbc\x1b\x10\x8ei\ +!(\xf7\x8e\x0b\xe9w\xc7\xd3\xe6\x0e\xef;\xf6\x80A\ +bm\x1cw\x08Z\x0d\xe7\xc5\xa4\x1eND\x02?\xce\ +'EAW\xb06\x96~@\xe4R\x97\x06`[:\ +\xc8\x05\x9d\xf3y(W\xbdR\xa0:\xaa\xf2\x91\x01\xfb\ +\x98\xc8[]\x05\xc4\x8b\xa1s87\xd7c\xcf\x8b\x82\ +v\x89U\xa5\xcd\xdd\x04\xe2\xee\xf3\xe1\xca`J\x1du\ +\xad\xba\xac\x90\x5c\xc5`z\x8b\xce\xaf\x0c\xeaO\x19\x8d\ +\x07\xde8\x05^\x9fo\xe3\x81~l\x94\xbc.\xaa\xc0\ +\x81\xa0\xfd\x95@\xef-\x96\x04\xb4&\x00\xb3rg\x03\ +?,4o>\xa8\x8b*\x94\x0e\xe2\x87\x84\x96\x01\xf8\ +\xbc\xa7xK*\xc5\x1b:\x9bx\xb4\x90\x9c\xfd\xdf*\ +\x1b\xd7\xad\x94\xd6\x00(\xf3\x14\x9d\xa0\xf4\x90BfU\ +!\x1b\x16{\xc3\xac\xad\x0av\x1f\xc6\x22Q\xcb\xe1\xde\ +\xaf\x04\x00\x10\xb4jl\xca,]\xdf\xc4t\xa1\xb9\x8b\ +\xea\xc5kb\x9ai\xa8\x16\x00c\xb2\x14\x1f\x01\xb4\x09\ +2\x9b\x10\xc2K\x85\x9aQ\x1dU\xf9H\x83\x992v\ +\x1e\xc0z\x00\xd9\x86\xe1I\x91K\xda#|\xb2?\xfa\ +\x01\x1f\xb6\xcb\xd7\xb4\xaa\xcaX=\x0c\xa0\xa1\x17Z\x12\ +\xc46Yn\xa5\xc1_%\xfcM\x06\x87+\x828\x91\ +4H\x9b\x13\xa8\xb4\xe5\x18\xa54\xc6\x81\x18O\xd8:\ +\x80W\xa3\xe7\x93\x9a\x5c\xc2;D.ID\xd8Y\x8c\ +~\xdf\x9e\xe3\xb5q]#\xe9\x01\x00\xa5\xee\x0c\xbb$\ +\xfell\x1aO\xf4\xe7\x96\xf7\xc2\xdf\x81L\xb3\xcc\xb4\ +I\xa87\xd42\x015\xbe\xe6\x06\xde\x06\xb8*t\x14\ +O\xfa\xb9G\xb1d#\xb9\x9a\x0d\x9ah\x8c]t\xe6\ +c\x87\xf1\xfdL\xf3>\xa0\xcdVfm\xc7kx\xa5\ +?\xdf\x03\xf4\x85\x01\x19\xca\xd6\xb4\xaa\x8a\x16\xb3\x8d\xec\ +D\x91\x13\x00\x8c#1J\xc2H\xf4\xac\xdc\x1cE\xcf\ +gs\x07\x00\xed#\xcd>\x11\xdb\x12\xf5\xd8;X\xb6\ +\xe3\x0ec\x18\xc3\xf8\xdf\xc4\x7f\x01\x16\x1d\xd4S\x92/\ +\x1f\x88\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x0c\xd6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x0c\x88IDATx\x9c\xe5\ +\x9b[o[\xc7\x11\x80\xbf%E\x8a\x94(\x89\x92\xad\ +\xbbd\xc9N\x9a\xc2A\xe0&E\xd1\xa0H\x0a\xf4\xa9\ +}\xe9{\x81\x16\xfd\xa3}*P\xb4\x0fA\x906N\ +R i\x92\xc6\x96l\xc97]HI\xa4.\xe4\xf4\ +a\xf6\x1c\xee\xd93\x87\xa4\xe4\xf4\xc9\x03\x10$w\xf7\ +\xcc\xce\xcc\xee\xcem\xe7\x00\xb2\x05\xe2x\xe3@\x9c\xf2\ +\x9e\xfex\x93\x84\x90\xe3\xf9M\x12B\x96W\x97\xed\xe0\ +\x0e\xf0\x18\x9c\x14<\xdc\x00n\x19\x1d%`2\x8b/\ +m\xaf\x0d\xa1f\x12\x10\xe0b\xc8\x98s\xa0g\xb4w\ +\x81\xbe\xd1\xfe\x12\xdc\xa9\x8d*\xcf\xa3\x1b5\x00d\x1b\ +\xb8\xed\x09=\x01^\xf8\x89\xa7\x809\xdf.\xc0Y\xd0\ +>\xeb\xdb\xfa\xbe\x1d\x8f\xa3\x0a4\x81\x8a\xef?\xf74\ +T\xfd\xf7%p\x04\x97\xa7P9\xf2mS\xa8 \x9d\ +\x9f\xff\xc4\xff\x9f\xf2m\x0eh\x01\xa7\xbe})\xe8{\ +\x01\xeeq1o\x85R\x92-\x90\x09\x90\x8f@V\x8d\ +1k \x0bF\xfb\x06\xc8\xbc\xff=\x05r\x0f\xe4\xae\ +\xff\xcc\x80\xdc\x01\x19\xb2#\xa4\xee\xc7,\xa8\xe0\xe5\xae\ +\xc71\xe1\xfb\xe7@6\xf3GU\x9a\x05\xed\x1b \xbf\ +\x06)_\xf3\x88\xcb\x04\xc8\x9f\xf5\xc1\x5c\xdf6H\xc5\ +h\x7f\xdb?\xb7\xe2'[\x8e\xf0\xdd\x1bsr<\xe3\ +%\xff\xdbyF\xb6\xa0uK\xdb\xe5-\x83\xd92\xc8\ +O\x8c\xf6\x09\x90?\xda\xbc\x14\x13\xf0\x91\x7f0\x92\x9a\ +\xac\x170\x7f\xc7\x7f\xb6\xed\x15\x96\xedkLN`\xa2\ +\xe2\xf6Y\x15N{I\xe7\xcb\xf5\x97\xb3\xcf\xa5\xbb\xb9\ +\x02\xf2\xabq'\xdf\x1el\xfbPc\xca\x14\xc8mc\ +\xfc*\xc8\x07\xba}M|\xf3^y^\x13dV\xb7\ +\xbc\xd97\x07\xf2\x00d\xd1\xe8k\xfag#\xcb&\x9b\ +\xfa\xc9\x82q&\xe4\x17\xe0>\x0d\xfe'\xca\xa3\x07\xec\ +\x01!\xa3\xabpy\x0b*_\x0e\xe1d\x0dxZ\xd0\ +\x97\xda\xe1\x1b<\x0b\xf0\x00\xbaO\xa0\xf6*h\xeb(\ +]\x94\xc9)\xbc\x987\x980\x90\xc6\xc44P\xe6\x1f\ +\xa0Z\xbd\xed\xc7l\x01/T\xa1\x0f\x05\xf1\xc4,\xf9\ +\xff\x89\xe9J4x\xd8F\xd0\xf6\xc2\xa0%\x86\x17 \ +\x822\xbc\xe7\x9f]\x02~\x06|\x0e\xcc\xa0\x16\x22\x81\ +\x9c\xd9\x8c\x04 \x0d\xd4\xcc$\xff7\x806\xb8]?\ +Q\x055]\x9b\xc0\xd7\xe0\xae\xf4|\xb9\x13r \xce\ +\x8f\x9bB}\x81oG\x98\x9f\xf8\xd9E`\x1a5\xa9\ +{\xf6\xb3\xd2\x86\xfa\x0b\xd4\x9fX\x01~\x00\x16\x80\xcf\ +\x80\xe7\x80\xb7<\xec\xf8\xe7{\xaa\xdb\xdcU\xd1\xc4[\ +\x03\xf3&[Y\xcd)\x1b^\x0f|\x1c)F\xcbL\ +.\xa1\xa6rF?7\x05Y\xf5\xcax=kU\xd2\ +\xfe\x99\x81~\x91\x09\x90\xdfx+\x11\xb6\x07\x8aQ\xee\ +\xaa\x8e\x18@\xc9\x98\xb5\xaf\x13\xb2\x0b\xae\x17\x8d]\x03\ +\xfe\x0e\xdc\x09\x84\x10\xac\xccaS\x19\xe7\x10\xdcS\xdf\ +7\xe6\xaa\x9b\xe0\x9fuO\x80\x03\xc5}\xd8\xcc\xf7\x8b\ +\x03\xd6\x81\xbf\x01\xf7\xb2s\xba\x9e\xf2\x22\xeb\x18G\xc0\ +\x12\xc0\x14p\x161\x0fz\xe6\xbf\xf3[\xe91Y!\ +\xa0\x1a\xb9\xd9W\xc6\xdd\xe5\xf8<\x8e\x0b\xeeRq7\ +\xfb\xd1n\x08=\xbc\x1e\xf0\x04=z\xe1\x90\x1e\xea)\ +N\xc7X-%8\xe7W/\x00\xd9F\x95L)0\ +w\x07\xc0}\xe0\xd2\x9b\xabW\xe8\xee\x09M\x9e\x9f\xd0\ +\xdc\x04%\xe8\xfa\xe3V;\xc4\xf6\xf7\xa7\x81.Hx\ +f\xfb:V\xee\x03G\xe8\xca\x7f\xadc\x05\xa0\x03\x9d\ +\x13\xa8/\x92\xd1g\xee\x08\xe4\xa7\xf1\x04cX\x01y\ +\x0b.*P\x9dF\x15\xd3)\x83\xad\xbd\x0b\xfc\x0e\xf8\ +K\x01\x03\x01t\xe6\xa1\x9e\x04?>N\xa8\x1d\xf9\xce\ +y\xd4R\xf8\x1d\xd59\x87\xfa\xe1\x10d]\xd4<\xfe\ +\x06\xf8$\xa0\xd9+\xcfz\x0d\xb8\x0dr\x1e-fn\ +%b\x01\xc4\xd1\xe1]`\x1a&\x1f\xaa\x12t\xfb\xd9\ +\xe1\xb2\x0e\xfc\x03\x0dp\x8c C\x80\xeem\xa8M@\ +\xfd%\xb8N\x01CG\xd9\xbfR\x07\x16\xe0\xa2\x06\xd5\ +\x93\xbc\xd6N}\x93\xbf\x02k\xe0\xf6\x82\xce6\xc8\x09\ +\xbac\xdf\xf6\x9ekB[\x9f\xe8\xd8\xc7:\xa0\x0a\x9c\ +\xfb\x09\xee\xa1\xab\xf2\x85M\xb3,\xa1\xdb\xbe\x87\xad\x13\ +\xa6\x81U\xa8\xb5U\x89\x152o\x80\xeb\xe83\xd5\xb6\ +2\x18\x1e\xab0\xaa\xa3\x87\xfa\x02+\x05\x88\xbe\xf1c\ +\xee\xf9\xe7:d\x1d\xb9\x22+\xc0\x06\xf0\x0c\xf5\x01\x8c\ +\x03|\xd8\x04\xba\xe0\xba\x9e\xe0H1\x1e\xcdC\xbb\x86\ +\xae\xc2\xf9X<\xdbp\x01<\x85\xf6$\x1c/`\x87\ +\xb4]\xe0L\xe7\x8c\xc1\x9d\xa1\x8b\xfa\x83\xe7)\xc7\x8b\ +%\x80\x06\xea=-\xe6\xb7|\x02\xcd)p\xadl[\ +\x22\x84\xcb\xf7a\xae\x07\xb3\xaf\xccGo\x04\xb3\xaf`\ +\xf6Rq[G\xcd\xb5`\xae \x16a\x075\xdf-\ +\xd4\xc2e\xc0\x12\xc04\xaa=\x0b\x94\x9a,\xa3n\xaa\ +\x01\xc7M\xa8|\x0f\xcc3~\xec=\x06\x88\x03\x16\xa0\ +\xf2\x9d\xcea\xc2s\xdbYr\x97@\x19\xdc1\xba\xb8\ +\x19\xb0\x04 \xa8i\xd9) d\xc2\xb6\xf32\x05\xa5\ +d\x22\x7f\x1c\xac`\xeb\xda\x10n\xfb\x16\x94J^\xbf\ +\xc4\xc3\xae\x946\xb1x:\xd4#4\xda\x0a\x94\x07\x83\ +L\xbf}\x13\xd5\xb2\xe1*\xcc\x82t\x81\x15\x98\xd9\x0f\ +\xfaZ\xc0\xbb\xc0\x13\xd2\x8cN\x06\x92\xd4\x19\xa8Oa\ +\xe5\x05\xe7\xd0@\xe7\x07\xfd-\xa0;s\x03\xe4\x19\x03\ +?#\xc1\x7f\xa6}\x1cd\xd1\xb8c\xef\x0e'\x81Y\ +\x0a1a5rIH\x99G\x83\x8deOd\x84\x9c\ +\x1etf\xa1~\x00\xc4A\xc6#O\xd0\xd7\xc1\xe4+\ +@\x1f:gP\xdf\x05\x1ctoA-\xc9/>\xf3\ +\xdf\xce\xcf\xf9\x05\x9a+\x0c\xe1\x15tf\xa0\x9e\x08-\ +\x9c\xb7\x89*\xbe\xbe\xee\x86TW%y\xcbL\xc2\xc6\ +Z\x99E\xe0K\x90\xaa'\xe0%\xb8C4\xd3s\x96\ +\x8f\xfc\xa4\x01\xf52\xb8\xe7yT\x82g~\x018F\ +W\xec\x1bcw\xb5\xfd\xf82\xba\xe2\x07\x9e\x8e\xffh\ +_.z;\xf1\xa6\xcfg\x7fC\x9ad\x1f\x15\x98\x17\ +\x9al\x02O\xe0\xa4\x03\x8d)\xb2\xe1\xb1\xa9\x03J\xa8\ +\x04o\x83\xdb\x09\xec\xf7-l\xe57\x0dG\x05ih\ +\xa5\x00\xcd\xf4n\x01O\x87\x87\xc4\xa9/\x7f\x1f\x0dg\ +\x87\x05R'\x18\xbe\xbd_\x08\x9f\xb9r'\xa8\xb7\xba\ +\x01\x8d\x03\xf4He\xa0H\x09.\xe5\xe3\x01( \xbe\ +\x01\xf3GF{\x02e%\xb4\xf2\x90\x9c\xb3\x94\x9b:\ +Qx\x9fa\xdf?\x84\xb4\x14\x08 7N|j|\ +\xcd\xea\xb5\x04\xb0\x00X\xf6\xdf\xba\x84\x18\x07V\x18$\ +4\x0c\x8f1\x81\x9c\x93\xf3\x12.\x8c\xd4{\x06\x8a\x84\ +i\xd1\xfa\x0aC`\x05G\xe0Z\xe1\xec(\xc1\xf4\x07\ +;\xa70\x946<<\xd7\x85\xea\xa8|\xdb5r\x0d\ +\xee\x0cU\xe6\x19\x88\x050AqTw\x13\x9b^\x83\ +nd\xdeb!\x0c\xbd\xb1\xb9\xa9\x1fQ\xf4\x5c\xae=\ +\xb6\x02\xcbpei\xf3\xc0?\xc8\xb4\x97\xec\xf6\x14\x9a\ +P{f\xd0! \x8f\xd1$\x0b\xc0\xa3\x02\xfd2b\ +\x85\xbb}\x8d4s\xd0\xc3\xce\xd6\x8e\x8a\x05z\x15\x98\ +\xb8\xce\xf6O\xecu\x11\xf4G\xf4\xbf&\xd4\x1c\xc5G\ +p\xacy#\x01\x94\x9f\xa1\xf67\xc6\xd5\xb3\x11\x8e\xcc\ +\xf2\x1e\x90\x9a\xa4\x10\xd2m\xff\xc8\x7fFX\x87B(\ +\x12@\x19\xdb\xb3\xcc\xcd\x11\xeb\x80.Q\xbc\x1c@\x11\ +\xb3\xc3\x08\xbf\xca\xcf\x11\x9f\xf9Q\xd6a(\x14\x8d\x1f\ +[9\xc6\x02Hr\xe79my\x03\x22\x12\xe8\x93\xde\ +'\x16)\x83\x9d\xf3Ib\x01t|\xdb2z\x1e\xd1\ +\x0b\x05\x8e<\xbd\x02\xecg\xb7\xb1\xa0\xb9CY\xcf\xe6\ +\x10\xd3s\xf7Op\xed`\x8e\x82<\xa3\x05\x02\x9a8\ +\xd9\x8d\xe6\x5c\xd3`-a<\x09\x87\xc5\xa1\xbb\xfa8\ +\xdb\x0e\x0c\x0a\xb62\xd9\xe9\xf8\x08\x84W\xd7\x16\xec\xa1\ +\xc1\x8d\x05\xcf\xc8\x14V\xe0oe_\xfbn0\xb6\x0e\ ++\x14\xe6$\x93\xc0\xcb\x84\xe4:>\xa38\x8b\x94\xe0\ +\x85m\x0a]_\x89\xb2\xeam\xdc\x15\xd0\xf2g0\xc9\ +\xdb\xbf\x0e\xf3\x09\x04Bh\xddF\x13$VN\xb2\x1c\ +\xd0\x18\xf7-\xa3\xd6h,%\xd8F\xed\xa5\x19?\xfb\ +mnd_\x018\x83\xc62\x9c\x9c\x8d\xe1%^\x03\ +\x9c(\xce\x99\x15\x06ew1,S|\xbc\x92\x1a\x85\ +\x9cY\xb5\x04p\x86*\x97rA\x86\x158\xee\x90\xbb\ +\xf7O\xb7\xfdW\xd08\xd3s\xfac\x81\xac*N\xbe\ +\xc2\xf4\x18\xa5\x01\xad\xae-t\x99\x83\xb3.\xcaSN\ +xE\xf9\x80\xc4f\xbem\x13\xd4\xab8\ +\x92\xeaO\xd3m\x9e\x04fa.N\xd6&\xb0\x02S\ +\xd3\x01O\x19\x88\x05pA\x9a4p\xdet\xc9\xba\x8d\ +\xd7\xed+rJ\xd8\xee\xed\x15\xb0\x07\xf5KU\x5c\xb2\ +8\x9e\xaf/\xce\x8f]\x81I\x8f#<\xf3\xa1\x10(\ +\x01\xabv\xfa\x0e\xd44_T\xc0}\xeb\x1b\xeaDV\ + 6\x83\xf1\x95\xd3'h9\x1a\xc02Z'\xd4\x0f\ +\xc6]\x02\xbfE\xaf\xc7\x97\x0d\x9d\x97\xa4\xa0N\xd1\xf8\ +\xfc=/\x84a\x89\x0f!\xad5\xa0\x81\xba\xd1VM\ +\xcf%\xf0{\xe0S\x06\x97\xa3\x89\x19L\xcak'\xf5\ +f;\x85\x12\xc3\xddg\xd9B\x0b\x0f\xc2\xb6\x86\xf7\x08\ +7\xa2\xf6\xa4\x0eo\xcd\x7f\x1bVC\x1a\xdc\xa8F0\ +}~\x05\xf3RE\xaah\x09\xed\x1c\xc8\xbb\xb6N\x90\ +\xf7\xf3\xd6J>d\x8c\x1a\xa1C\x90 #\xebN\xe0\ +\xa4\xab\xf5\x80)\xa2\xf0\x8a\xba\x0f\xee\x11\xea%\xbe\x06\ +\xb3\xe3\x82\xcc\xa0)\xfb\xef\xd1\xcc\xcf\x0ey\xc5\xb8\x81\ +\xa6\xe0\xc3\x0b\x9e\xe4n\x22\x03\x96\x00\xba@\x95LI\ +\xec\xcc\x0b\xa8Lz\xc9\x16\x85\xb4\xfb\xd0\xaa\xaa\xce\xb8\ +V]\xee\x98 e\xc5\xdd\xaa\x90\xaf\xfa\x08\x14c{\ +\x11\xba\x1d2\x1a_*\xa8n\xcb\xd5(X\xb1@\x09\ +\xdc\x9enyy\x16(\xa0\xa7\xa8F\xee\x01\xff\x0d\x98\ +\x0f$?w\xe0\x05\x94\x84\xbf\xa1\x0b|\x13H\xbc\xbf\ +U\x94\xd1\xa70'Q\xbf\x049\xc6\xfb\xd0h\x91\xb9\ +\xbe\x93\x8a\xd2\xe3v@\xee\x1a\xccf\xe0%i.\xc0\ +\xed\xa2u6\xc9\xd6\x17T\xf1T\xc8f\x8d\x22\x1cN\ +T\x80\xec\xa3\xb5?\xf7\xc6\x08\x97\x0dh\xddF\x9d\x9b\ +%\xe0\xb9\xee\xb0\x9c\x9d\x9f&]\xd5\xe3&\xba\xeae\ +Tyv\xd0\xda\xe6%e\x1e\xd0\xcb\xd8\x8c3\x14\xed\ +\x00w\x9a\x0dW\xdd\x1eZ\xc3\xbf\x81Ff\x9f\xa3B\ +x\x00\xe7'P=R\x22\x0b\xcd[_\xe7h$\x15\ +\x9bI\x1b\x80\x83\x0b\xbf\xbb\xaa\xc9\x0b\x14!\x1c{f\ +\xbc\xa93\x1d\xcbe\xc5/K\x1eo\x12#|\x00<\ +\x04\x0e\xc0\xbd\x0c\xc6\x97\xe3{F\xeb\x08\xc4\xcct=\ +!\x0f\xd1\x82E\xd0+\xefe\xdf\xbe\x1f\xb4\x1b b\ +\xf7\x8b\x83\xea\xa4g\xb0S\xe0\xc5\xad\x8f\xc0}\x05L\ +\xc1\xd1\xf7\xd9\xeb9q\x9e\xb6\xf8\xcc\x8f\x93B\x93;\ +\x03\xe7'S._\xcfZ\x07\xf0f\xe8}\xecDI\ +2\xe6\xffP.\x0f\xba\x00\xf2\xf3\xbc\xf9\x95\xa6Z\x8a\ +\x5c\xb9\xfc\x1d\xcc\xb2^\x1b\xf9\xc7\xd8/L\xac\x92{\ +aB\x1c\xfa\x82\x85\xf1\x02C:f{\xcc\x89C\x9c\ +\x05\xcf\x88C\xdf\x18\xf9\xa5\xd1W\xce\xfa+\xa9\x10\xaa\ +\x8c\xff\xc2D\x8a\xe8O\x05N\xc8F^\x08\x00\xf2\x1e\ +\xfa\xcaJ\xee\xa5\x04^\xeb\x95\x99\xb4\xad\xe4\x9d\x9f\xb7\ +@\xde1\x9c\x9f\xb2\xa5\xe5=\xf3\x7f\xc8\xe3+\x9e<\ +\x91ZY\xa5\x16{\x80\xe0w\x82q}-\x1b~k\ +\xde\xd3O+t\x9e*\x8c~ij\xca\x8f\x09\x04/\ ++\x0c^\xbe*z9j\x1e3f\x91-\xcfC)\ +\xbf\x9b\x15bD\x86\x93#\x9b\xa8\xb6\xf55\xba\xb4\xfc\ +\xef\x1aj\xe6\x1cz\x01r\xc1\xe0\xb5\xb9\x19@\xa07\ +\x0d\xe5\xc4)JJd{\xc1\xff\xe4\xf6&ym.\ +(\x97M\xe9\xeb\xfaq\x0e5a\xa7\xfe\xf7$\xaa\xc4\ +}\x01\x06\x1dT\xa1\xce\x06x\xf6\x06N\x93\xed\xc0\x8d\ +\xb8\xa2\x8eA&0J\xcd<\x9e:y-\x1b\xbf8\ +YB\xaf\xca\x92#Te\xe0_\xe0\x998$k\xf3\ +\xac\x17'\x85A\xe23\x06\xa3\xb46}\xac\x88\xc77\ +\xf7\xd5Y\xab\xe1\x0d\x80\x0c\xcfo\x1a\xf3\x09\xa8\x10\xfe\ +\x07\xb4\x0a\xfd~\xcf\x22[\xc2\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x00\xd1\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x83IDATx\x9c\xed\ +\xd7\xb1\x0d\xc2@\x10\x04\xc0}\x8a@4B#\xb4@\ +\x80\x1c\xd1\x0b\x89E#T\xe1B,\x9axRd}\ +j\x8c\xfc3\xe1\xea\x82\xbd\xcb.\x01\x00\x00\x00\x00\xa0\ +\x1fe\x19\x9co\x8fK\x92\xb1&\xc7\x0d\xfa\xaciN\ +\xeauz\xde_\xdf\xe1\xa11\xb8\xc7\xe5\x93\xe4\x94\x94\ +q\x19\xb6\x0e\xd0\x95\xd6\x01\x86\x92\xbc\x7f\xded}s\ +R\x87\xadK\x00\x00\xff\xc3/\xd0\x18\xdc\xe3\xf2\x89_\ +\xa0\xcd/\x00\x00\x00\x00\x00\x00@'>\xec\xfd\x1c\x0f\ +:W\x98\xc9\x00\x00\x00\x00IEND\xaeB`\x82\ +\ +\x00\x00\x00\x8a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xee\x9d\ +;\x80\xc5b\xb1X,\x16\x8b\xc5b\xb1X,\x96\xff\ +\x0d\xea6\xf0ra\x1f\xc0S\x00@\xf2\xdcD\x86\xbd\ +\xba=W\x83\xd6\x02\x0e\xf6Hr\xa1A\x16J\x86\xc2\ +C~\x07Gu\xfa\xae\x06G\xeb\xa7\xaf\x87[1\xa3\ +\x8c\xec{ \xdb\xb5\xfa\xae\x02\x03\xaf\x80\x92\xa8\xb9\x9b\ +\xe0\x86\xf14\xe7u\xfbWC\xef\x0a\x00\xb05`\xe5\ +*\x00\x10\x842\x87n\xd1\xee_\x0d\xed\x01\xeew2\ +D\x92\x0dQ\x9a\xb7GB\xdd\xfe\xd50\xf2\x04\xfc6\ +\xce9\x09\xee\x88\xd2\xbc\x9c\x1a3\x91a%\x8c-\xc1\ +B\x9ao\x15y8Bj\xf6r\xe1\x0dS9\xca1\ +\xfa\x0e>\xcf\xf0\x89\x90\x17+\x15^N\xe5\xe4\xb4\xc9\ +,\x7f\x9c\xe30M\xe5\xc2^\x01\xcf\x94\xcf\x1d\xd2+\ +d8i2K,\x05\x00\x80\x97S\xef\x00T\x9c\x07\ +\xdc\x04\xb7\x8c\xa7\xf9\xc5T\x8e\xd8\x0a\x00V>#8\ +\x01\xeb\x0b\x9d\x5c\x88\xd2\xd6\x9aX\xf7\xe1\xe0\x1bk\xa2\ +\xe6\xca\x95\x9f\x101\xf2pb-`\xaa\x8bK\x81\xcb\ +MQ\x9a7(\xdfMd\x88\xfd$6u\x8c3!\ +\xb8+Bj\xf0\x06\xc3{\xba\xfdc/\x00\x00^d\ +\xf9\x1a`{\x85 <\xa9\xdb\xfb\x9f(\x00\x00\x1c\x85\ +\xe9X|\xe30-\xc7{(\x9b\x15%_>\x17\xc1\ +3\xdd\xde\xb1\x17\xb0wX\xea\x11\xca0\x88m%\x02\ +\xe5\xdad\x87\xd3\xac\xdb?\xd6\x02N\xf4K\xc2\x0d\xa4\ +\x0f@S\xa9\x22\xb7\xfdv\xa7\xdbD\x86X\x0b\xf8\xe0\ +\xaa\x9b\x00\xd2\xc53\x01\x1e\xd5mt.\x80\x8c<$\ +\xad5\xf1\x1d\x85\x07\xe5\x12Dn\x95\x8d_\xba\x09\xb6\ +\x98\xbc)\x8a\xa5\x80\xa6\x01\xc9\x902P\xe6\xff\xc9\x09\ +\x98*t\xf2\xb3\xc9,\xc6\x0bH\x0d\x89'JF\x01\ +\xd4\x15\x8d\xe7\xa1x\xc0?\xceW\xa6\xf3$L\x9a\xfd\ +\xbe\x0d\x96\x11\x02\xc5Wd\x01\xc0\xb4\xdf\xc1\x82\xc9,\ +\xcbD^X\xea`\x7f\xbf4*G\xf2\x00\xca\xce\xfe\ +\xec\xf2\xb3|l*G9Fv\x81\xd6\xbc\xd4*W\ +\x86\x00\xec,\x11D\xae\xfbY\xde1\x91a%\xf4\x17\ +\xd0-\xce\xec\xa2\xea\x01\xd0R*\xc8]?\xeb\x5c\xd5\ +\xee_\x05\xed\x05x\xbbqe\xf9\xbf\xc1\x22\x9e6&\ +\x9d\xf3\xa6\xf6\xfa\xbf\xa1u\x17h\xcdK\xed\xec\xa2\xfc\ +\x00\x90,\x1a\xbfYW\xc3\xe6\xb1\xa34\xf2{\xbf\x1a\ +ZW\xc0\xd7\x8fP\x00\x96\x8aG$\xdb\xfe\x95/\x0f\ +h.`\xaa\x8bK\x04\xcf\x02\x98\x010\xad\xc8#\x13\ +\x19\xbe\xd7\xe9i\xb1X,\x16\x8b\xc5b\xb1X,\x16\ +\x8b\xc5R\x8d_D\x94\xcc\xbe\xc4\xf9\xa0\xab\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x01G\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xf9IDATx\x9c\xed\ +\xd6!N\xc4P\x14\x85\xe1s[\xa6\x04\x04\x0alC\ +\x9aT\x92 \xd8\x03,\x80u`X\x00a\x01\xb3\x09\ +<\x92dX\x06\xba\x06S\x122\x0eA\x86\x0e\xf3.\ +\x96\xbc\x07\xb8\xbeI\xe8\xff\xc9s+N\x8fi%\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00`\x12\xec\xaf\xa3\xbb\x9b\xa4\ +2S\x97\xb1\x043\x0b\xbf\x1d\x7f\x1c\xa0\xef\xfb\xc3\xe1\ +s37\xd9\xa5\xa4\xfd\xd1\xaa\xe5\xb1\x92\xf4P\x98_\ +\xd5u\xfd\x12\x1f\x93\x01\xba\xae;\x98U{O\x92\x1f\ +\xe7h\x97\x8dk\x19\xc2\xfa\xa4i\x9a\xd7\xefq\x11?\ +WU\xbb\xb7\xff\xee\xe5%\xc9tT\x94\xb3y\x1c'\ +\x03\xb8t\x9e\xa7\xd1V\x5c\xc4A2\xc0\xd4$\x03\x98\ +\xf4\xb8\x8d\x22\x99,\xe2 \x19`\x18>n${\xce\ +R''\xd72l\xd6\xd7q\x9c\x0c\xd0\xb6\xed\xdbN\ +\xa93\x97\xdfIz\xcfRn\x5c+I\xf7E\xe1\xa7\ +\xf1\x17@\xe2G\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\ +\x8a/\xe6O8jt\xad\x97/\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\xc8\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00zIDATX\x85\xed\ +\xd2\xb1\x0d\x83@\x10D\xd1\xbfK\x0f\x96\x08\x08\xdc\x09\ +\x9d\x10\x90\xb8$\x02\xc7\xae\x81n\x08\x1c \xd1\x03\xb7\ +\x8e\x0eYB\x22\xe3.\x99\x97\x8d\xb4\xd2L\xb0 \x22\ +\x22R\x99\xfd\x87\x880\xa0\xb9\xb9s7\xb38\x0dX\ +\x96oo\xce\x07ho\x1e\xb0\x853<\xbbn\x06\xf0\ +c\x893\x15(\x07xX\xe2\x9d\x83_]\x96p\x0c\ +\x88\xc4\x0bX\x0btna1\xe6P\xfd\x09EDD\ +\xaa\xfb\x01\x02f\x1a\x07\xaf\xc1\xa8\xac\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00h\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x1aIDATX\x85\xed\ +\xc1\x01\x01\x00\x00\x00\x82 \xff\xafnH@\x01\x00\x00\ +\x00\xef\x06\x10 \x00\x01G\x01\xa0\x88\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x02\xc4\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02vIDATx\x9c\xed\ +\x9a=o\xd3@\x1c\x87\x9fK\xa8\xca\x02KxYj\ +\xe7\xfc9\xf8\x12,T\x0d-\xact`ec\xe5\x1b\ +\x80\xc4\xcaK\x0b\x82\x01\xf1=\xbc1fp\xedfC\ +HH,\xa8R{,\x112\x87\x9d6\xf6\xdd\xf9\xce\ +\xf1o\xb3\xfd\xcfO\xf7<\x8a\x9d\xe8d\x182d\xc8\ +&Gt\xbd\x00\xdb\xc9\x8a\xe2\xbeP\xe2\x05\xf0s<\ +\xe20\x8a\xa2o\xe5\xeb\xd7:Z\x97\x93dE\xb1'\ +\x948\x02F\x00\xe7\x17\xbc\x06\xee\x95gF],\xcc\ +Et\xf8en\xeas\xbd\x14P\x03\x7f\xae\x84z\xae\ +\xcf\xf6\xee\x16\xa8\x83\x17\x88\x99\x8c\xa3\xaf\xfa|\xaf\x1e\ +\x82\xab\xe0\xa7\xd3\x9d\xcfU\x9f\xe9\x8d\x80&\xf0\xd0\x13\ +\x01M\xe1\xa1\x07\x02\xda\xc0C\xe0\x02\xda\xc2C\xc0\x02\ +L\xc0C\xa0\x02L\xc1C\x80\x02L\xc2C`\x02L\ +\xc3C@\x02l\xc0C \x02l\xc1C\x00\x02l\xc2\ +\x83\xe7\x02l\xc3\x83\xc7\x02\x5c\xc0\x83\xa7\x02\x5c\xc1\x83\ +\x87\x02L\xc3\xe7\xf9\xe2\x81R\xea\xd5\xf2\xf0\x89\x94\xd1\ +\x97\xf2u\xaf\x04\x98\x86\xff\xafO\xf1]\xca\xe8Ny\ +\xc6\x9b-1\xeb\xf05\xf1B\x80#\xf8\x0b!\xc4S\ +}\xb6s\x01\xae\xe0Q<\x9eNw>\xe9\xf3\x9d>\ +\x03\x5c\xc2K\x19\x1dU}\xa63\x01>\xc0CG\x02\ +|\x81\x87\x0e\x04\xf8\x04\x0f\x8e\x05\xf8\x06\x0f\x0e\x05\xf8\ +\x08\x0f\x8e\x048\x84\x7f$et\xbcN\x97u\x01>\ +\xc3\x83e\x01\xbe\xc3\x83E\x01!\xc0\x83%\x01\xa1\xc0\ +\x83\x05\x01!\xc1\x83a\x01\xa1\xc1\x83A\x01!\xc2\x83\ +!\x01\xa1\xc2\x83\x01\x01\xae\xe0\x95P\x07I\x1c\x7fX\ +\xb7/\xcf\x17\xbbJ\xa9\x97\xcbC\xb3{\x82\xfe\xc3\x9f\ +\x1e(x\xf3\xb7\xcf\xe4\x9e`p\xf05i$\xc0w\ +\xf8\x93\x93\xd3\xfd\x0ax3{\x82!\xc0#x\xab\xf7\ +\x19\xd9\x13\x0c\x19\xbe\xf5\x9e`\x00\xf0\x0f\x11\xbc\xd3\xfb\ +.\xfb\xe9\xbc\x92\x80\xbe\xc2\xc3\x15\x048\x84\xdfO\xe2\ +\xf8\xe3\xba}m\xe0\xe1\x12\x01}\x87\x87\x15\x02|\x87\ +\xcf\x8ab&\x94x_\xd1\xb7\xd6mT)`S\xe0\ +\x01\xc6\xfa\x89<_\xec\x02\xc7\x18\x82\xaf\xe9k\x0c\xbf\ +\xa2\xaf\xd1\x03\xf4\x9fo@\x9a\xa6[\xb7n\xdf\xfd\x01\ +\xdc(\x9dn\x0c_\xd3\xd7\x18\xdet\x1fh\xff\x04'\ +\x93\xc9\x18\xd8.\x9dj\xf5ZJE_\xab\xc5\x9a\xee\ +\x03M@\x92$\xbf\x05<\x03\xce\x80_\x02\xb1\xd7\xe6\ +\x9d\x9c\x8a\xbeY\x9b\xc5\x9a\xee\xab\xcd|>\xdfN\xd3\ +t\xcb\xd7\xbe,\xcb\xae\x9b\xec\x1b2d\x83\xf3\x07\x17\ +\xa8\x1doY`\x0c\x9b\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x03\xe3\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x95IDATx\x9c\xed\ +\x9b=H[Q\x14\xc7\xff\xe7\xe5I\x07\xb1*\x16\x22\ +Xt\xaeC\x15\x92\x22\xdd\x84V\x1d\x147\xebPA\ +\x07\x89\x14Z?\xa6R\x87\x06\x85b\xe9\xe2G\x1d\xaa\ +8(\xb8\xa8\x9b(T\xdb\xa1C\xa1\x88\x06\xd4\xc1\xce\ +\x8a\xb6\xa6\x90\xfaA\x1dl\x93w:\xa8\xe5\xe5\xe5E\ +\x93\xdc\x97\x5c\xad\xf7\xb7\xdd\xf3NN\xfe\xf7\xff\xde\xbb\ +\xf7\x92\xdc\x0b(\x14\x8a\xeb\x0c%\x92T\xe9\xf7\xebG\ +\xbb\x05\xf5\x06\xd0H /\xc0E\x00n\xa4Y[\xb2\ +\x1c\x03\xb4\xc3\xe0\x15\x0d\x98\xca.\x0c\xcd~\xea\xe9\x09\ +_\xf4\xa1\x0b\x0d\xf0\xb6\x0dW\x81y\x10\xc4w\x9c\xd1\ +\x99\x19\x18\xd8 h\x9d+#O?\x9c\x97\xa7\x9dS\ +\x82\xbc\xbe\xa1n\xc0X\xbcj\x9d\x07\x00\x02J\x01c\ +\xf1^\xdb\xe0\x0b\x80\xe3\xdehW\xbc\x0b^_A7\ +\x08\xaf\xd2#/\x93\xd0\x83\x22\xef\xd2\xf1\xb7\xc0\xfb\xcf\ +\xb6W\xed\x82\xde\xb6\xe1*\xc0X\xb4\x84\xf7@x\xa9\ +\x85i\xbe\xe4\xc0\xbd53\xf3(\xe2\xb8V\x01\x1a\x1a\ +\xa6]\x9b\xb9\xc1bC\xe7Z0z\x01\xe4Ggh\ +\xd5v\xafC\x8c\x01\x95~\xbf\xfe\xeb\xfb\xad\xf5\xa8\xc7\ +\x9e\xf0\xd1\x156\x9a\x96\xc6:\x83\xceKw\x9e\x8a\xd6\ +\x01wD\xd7&\xc1xx\x16c`#\xa70Tf\ +\x1d\x18c\xc6\x80\xa3\xdd\x82z\xcb;\xff\xf37\xb2\x1e\ +_\x95\xce\x03\xc0\xd2Xg\xd0\x156\x9a\x00\xec\x9d\xc5\ +\x08(=\xda-\xa8\xb7\xe6\xc6\x18`\x00\x8dQ\x01\x82\ +\x7f\xfd\xdd\x93\x1f\xe9\x10\x9aN\x96\xc6:\x83\x0c\xf6\x9b\ +c1}\x83\x8d\x01'\xf3\xbc)!L\xf3\xce\xcb\xcb\ +\x0c\xae\x886gn\x13\xe0\xb1\xe6\xd8L\x83\x5cdn\ +\x95\x1c\xb8\xb7\x9c\x16\x96)l\xb4\xdf\xb6\xe6\xd8\xad\x03\ +\xa2Vx\x97m\xb4O\x06\x1b\xed1\xab\xd7s\x16B\ +\xd7\x03e\x80l\x01\xb2Q\x06\xc8\x16 \x1be\x80l\ +\x01\xb2Q\x06\xc8\x16 \x1be\x80l\x01\xb2Q\x06\xc8\ +\x16 \x1b\xdd\x89\x22\x1e\xdfP5\x08o\x08\xb8\x8b\x04\ +\xffk\x10\x80\x01Zc\xe6\xe7\x81\xd1v\xeb\xef\x96I\ +#\xfc\x04x|\x83\xcdDX \xa0\x0c\xe9\xef\x96\xf2\x1b\xe0\xde\x19\ +\xb2\xfbD\xf9\x04\x0f\x91q\x1a\xf7\xe8\xccL\xca\xf4\xcb\ +\xbe\xc2\xa6\x80\xd9\x18x\x07|\x94\x8eA\x0f\x01\xfbN\ +\xff+\x08\x15\xd8\xb5\xbe\xfd\x09\xcc\x1d\x8d\xd5\x0cJ\x5c\ +p\xa8\xcf\x03`s\xa0\xc5\xf3\xa5\xd2\xf3\x80'\xf4\x0e\ +x\xc2\xe3\xff\x0d\xb0\x82\xb0\x19%\xdcc)\xcf\xe5\xdd\ +\x1a\xb8\x92\xc59\x94O\x82q\x02f\x1d\x0f$\x08\xe5\ +\xc0\xb3\x94\x95B8\x03\xee\xf0\xf0d\x10\x9e\x12\x07;\ +(\xdcR\x9b\xc0\xcb\xb5\x18\x83\xa0\x5cHh\xa49\x1e\ +\x86\xb9\xf8\x07\xfa\x1f\xd7\x22m\xc4\xbb\x93\xac\x00\xdb\xf7\ +J\xccc\xee\xc5\x10\xbcsA\x150\xfd\x8c\xc7\xb2\x96\ +\xf5#\xc1VCu\x09\xd3\xb5#u\x8el!\x995\ +0\x95\x03S\xba\xd2\x1bI\xf6\x1c\x0f\xc1\x97\x14\x81\x09\ +\xb4/Im\x16\x8a\xb5\xe1\x96]\xc3t\xe5H\xbdI\ +\xb1\xce\xbf\x17\x8f\x09\x89X\xb6-<6x\xe8\xfa!\ +hJX\xe4x\xd2\xfc%\xc1\x85\ +\xfaA\xeeIg\xb3\xee?\x05\x9e7_as)\xde\ +<\x91\x09,\x9eIB\x15\x0d\xc8\xbc\x8b\x91\x0b\xc6R\ +\x1e\xb4b\x5c\xe1\x89\xf6 Hs=\x83\xa0\x9d\xba\x0c\ +\xa6\xae\x9c\x06f\x0f\xda\xd7\xe2=\xe5\x12\xef1Ch\ +L\xfbc\x1f @P\xd7\x0a\x8f\xde\xb9\x822\xdb\x0c\ +\x82\xfa\xbb5\x126\x06\xee{\xbd\xfd\xca\x8d\x8e|\xb4\ +`{\x7f\x86\x1d\xd83^\x86\x03\xba$?\xa9\x82a\ +R\xdfI\x93\xa9\xd3=\xda\xc7\xbd{c\xe90\xbbK\ +\x1c\x8a\x94NY\xc9\x0cU\xe7l\xc70\x82\xf1!\xf1\ +\x86\xe4\xbdM\x84\x8c\x80\xc6=\xb75\xeaLxF[\ +\xd2\x1fRJ\x1dx5=\x07\xc9s\x7f\x86\xb9O\x87\ +\x9e\xc0>\x9dk\xcf\x96\xbc\xbf\xda\x17\x85\xed\xa0QW\ +\x0b\xd6m\x0e\x06\xf5\xb0g\xc00\x81}\xa5\xdf2\x99\ +'}\x83OFn\xdf\x98\x94\xa1U)\xf5\xac-\xfa\ +u\xdf\xe2\x09\xa7y\x1eb\xdb\xbe\xa6;\x03D\x0a\xaf\ +\xdf\xad\x00;\xee\x8b9`\xcapS\x19\xce4X\xc0\ +K\xb3\x94\xe2\x02o\xb9j6\x96B\xdc\x00\xdfJ\xb8\ +I\xb6\x0e!\x16; 2v\x1f\xf9\xa2\x01;\x08C\ +\x95\xdb\xd6\x0f$4\xfe\xdf\xc03\x7f#!\x9f\xffa\ +\x1a\xee8\x9ev\xd6%,\xef:\x07y\xc0K8\xee\ +\xd9\xc1I\x08\xc6u\xe2\xf5\x165\x0aQ\x05/?\xc9\ +\xf3s\x99~\xb4@\x1e~\x80\xe5S\xb7\xbc*\xa4\x1c\ +7l\xbc\x89_\x06\x09\xe3\x06\xea\xb2c\xa2\xf6\x86\x14\ +\x0f\x1a\xf9->\xdd\xfag\xc1\x94\x22\xd4\x7f\xe0\xed6\ +\xf8\xb3L\x86W6\x931'!\xd8\xfb\xe6\xe2\x19\xec\ +\x86n\xe0\x14\xf8I\xe6w<\x9e{\xa0t\xa4\xeaA\ +\x97\xa0\xf5P\x02\xd5!\x8f{\x7f\xc6\xbb\x9f\x8ew,\ +\xa1\xb8\x95\xccmj\x00n@x\x06\x1b\xd0\xc5|$\ +o\x0e\x106`-\xf0\x0c\xe1\xe5<\x006w\x19\xa0\ +\x83\xebg|\x96l$s\xe5\xf9\xd3E1\x0dA\xe3\ +\x93-te}r\ +1\xf9\xed\xcc\xc5\xe4\xd8\xdb\xf7\x82m +3\x1c\xfe\ +\x81\x7fo2y0\x84qz\xf7\xcbu0n}\xd4\ +\x8ej\xbcg\xec\xc5\xdb\xd0\x0d\xa65\xc9\xd5\xec\x8d\xcb\ +i\xf4\xe2\x98p\xc3\xe4}\xa2\xf7\x09l5;&\x95\ +\x94\x18\xdd\xe5T\x06\xb9\xb0\x18\xf3\x9e\xc3k\xf8\x9f\xaf\ +\xe7\x7f\x03\x88|\xd3;\xed2O\xdf\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x02\xc0\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02rIDATX\x85\xe5\ +\x97\xcfN\x13a\x14\xc5\x7f\xf7k\xbb\x221Q\xc0\x08\ +\xbb\xbe\x82\xd0\x8a\xd1\x18L\x5c\x09q\xc5\x1b\xd0\xd0&\ +@I\x8c\xc2\xb2iX\x95D#-\x90B\xc0\xc4\xb0\ +\xc1\xbdM\xd8(\x89\x89\x8a@}\x05X)\x111q\ +\xc1\xaav\xae\x8b\xce\xd4\xb1\xd0?S\x06\x17z\x96\xe7\ +\xde\x99s\xe6\xdco2w\xe0\x7f\x87\xd4\x12\xfd\x89\xdc\ +-Tg\x10\x06P\xba}R9B\xd9F$\xb3\x97\ +\x9f|W\xd7@$>\xffH\x91\xb9\xb3\x8c\xf9\x04K\ +\x95\xe9\xe2J\xf2\xc9)\x03}c\xcfn\x8b\x98\xb7\xc0\ +\x0fD\x93\xa1R\xb9\xf0a\xed\xe1w?To\x8e>\ +\xbdR\x0a\x05\x86P\xc9\x02\x97\x10\xb9\xe3$\x11\xac:\ +\x113\x0d\x08\xa2\xc9\xbd\xfc\xd4\xba\x1f\xc2\x0e\xec\x07Y\ +\xef\x8fg\x05x\x81\xea\x0c\xf0\x00\xc0T\xbb\x84\x01\x80\ +P\xa9\x5c\xf0S\xdc\x0d\x134\x85\x8a\x147\xaa\x5c\xb5\ +j\x1f8\xbfb?\x0b;\x8b\x13\xc7\x15)\xae:\x5c\ +\xb0~{{\xb8\x9eX\x186j\xad\x00Xb\xc6>\ +\xe5'^5\xea\xf7\xd5@4\x96\x0b[jm\x00\x1d\ +\x00\xb6\x91\xdeF\xd7\x98FEOH\xa5\x8c\x15\xd0\xe7\ +\x8ex\xab\xf0\xcd@\xe4\xb0+\x01\x0c\xba9Uf\xff\ +\x8a\x81h,\x17Vt\xae\x86\xde*\xf6\x1c/_\xbc\ +\x81\xb3\xa3?1e\x19%\x9d\xb6\x9a]\xde\xf4\x106\ +;\xd5\x91\xc3\xae\x84\xa2\x83nN\x95\xc7;\xab\x93\xfb\ +\xad\xf8o\x9a\x80-\xde\x03\xf4\x18\xb56\xa2\xb1\x5c\xd8\ +\xa9\x9d'z\x07^_\xc3\x0e+\xa0k\xa4R\xf7\x00\ +\xac\xc3\xf6\xa3o\xd9\x80*\xb3\x22,\xb9\xa8\xbb}_\ +:\xe3FD\xce\x13\xbd\x83\xa6#\xb0\xe3\xdcrs\x22\ +,)\xbaX\xd3\xea)\xfa\x96\x0d\x90N[\xa6,\xa3\ +\xc0I\x83.\xcf\xd1\xb7n\x00\xd8Y\x9d\xdc\x17d\xba\ +^\xbd\x9d\xe8=\x19\x00\xd8\xbd\xf6-O\xcd(l\xb4\ +\x15\xbdg\x03uF\xd1v\xf4\xde\x0d\xe0\x8cBG\x14\ +\x0e\x14\x0e\x04\x1di7z\x07\x9e?\xc7\xbb\xcbS\x9b\ +@\xb8ic\x8bp\xafdGPY \xfd\xbay-\ +\xa2\xe3\x0b\x9d\x15)\xbe\x9e6\xa0l\x03\x94B\x81\xa1\ +\x8b2`\xfd\xb4\x86*R|t\xb8\xdf#\x10\xc9\xa0\ +:\x8cJ\xb6?\x9e\x15\x134\x05g\x87;/\xa2\xe3\ +\x0b\x9d\xb6\xf8<`!\x92\xa9\xca\xba\x1b\xed\x1f\x93\x0c\ +~nJ\x7f\xe2\xd4\x8fI\xc0]\xfd\x5c\xdc|\xdf\x1b\ +\xb9\xff\x1a\xe8\x16\xb8\x8c\xc7\xf5\xaa\x1e\xec\x99\xbfA$\ +V\x5cN\xbe\xf4\xe3\x9e\xff\x0e~\x01)r\x01/N\ +\xc0\xa2\xca\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x0b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xbdIDATX\x85\xed\ +\x94=k\x14Q\x18\x85\x9fs\xd7B\x09\x886\x16\x16\ +A\xc1Zl\x92E\x04;Y\x91\xe0\xba\x8b\xa6Q\xc1\ +\x7f\x90_ \xa8\xbf@lR\xdaX(\xb2\x89A\x0b\ +CJ\x91$k\xa3)RY\xd8(X%\xa8\x91\x90\ +\xdd\xbd\xc7bf\xdde\xa3\x9b\x99\xf5#\xcd<0\xf0\ +2\xdc9\xe7\xdc\xfb\xbew\xa0\xa0\xa0\xa0`\x9fQ\xb7\ +\x98\x9c\x8b\x1b\x82#\xff\xc3\xd4\xb0\xd9\xac\x87\xa3\x00\xe1\ +g\x12\xf5\xea\x7fM\xbfW\xafh\xe9$\xb0\x92&\x04\ +\x13\x81\xce\xdfxl\xa2{\xfe\xcb\xa9W\x12\xa6?\xd9\ +\xe9E\x8f\x1d\xfa\xee\x06\xa6\x82\x8dQ\x940\x7f\x86\xc0\ +\x01\x84\xe1\xe5\xf6\x98\xae\xaeU\xb4\xb5\xeb\x04\x00\xd6*\ +\xda\xfa\xda\xd2e\xe4'HH\x0e\x83!\xf3`#C\ +H$\xfc\xf8[[\xd5~\xf3]\x01\x00\xd6\xa7\xb53\ +\xde\x0a\xd7m\xcf\xa6\xde\xc1\xce\x1f\xc2 \x89 \xc0\xf6\ +\xecx;\xdcX\x9f\xd6\xce\xe0\xba\xdf\x0b\xdb*?\x8b\ +w\xb1n'\x82\x8a\xc2\x99\xdaa$\xe1ts\xbe\xb7\ +Z\x0bw\x90~\xf9\xed\x9e;+\xcf{\x06\xfb~7\ +\x15(\x0e7w\x10R\x22\xae\x99\x95\xba\x1e\x0c[\x9f\ +\xe9h\xcb\x0d\xdfD~\x08\x94\x86\x85\xe83\xef \xdd\ +Z\xad\xe9\xd1^\xda\x99{;9\xe7)\xe1\xa7\xc0A\ +\x92\x9b:\x18\xa2;\xb0\xdbF\xd7\x9au\xbd\xc8\xa2\x9b\ +k\xb8&\x1a>\x1f\xe4\xe7\xc0a\x83\x95\x860\x04%\ +Z_\x1c4\xd5\xbc\xa2WY5sO\xf7\xc4\xbc\xcf\ +\x04{\x118\x860\xd1\xdd\x96\x7f\x8e\xd2\xc575\xbd\ +\xcd\xa37\xd2\x1d?\xbb\xe0S\xb1\xe3%\xe0D\xfa\xea\ +C(\xe9\xc2rU\xef\xf3j\x8d\xfc\x939\xb7\xe0\xe3\ +\xed\x8e?\x02\xef\x0e\x94t\xe9uU\x9fF\xd5*(\ +((\xd8W~\x00\xa4\xf8\xb1\x06x\x8b\xc7\xb8\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04\xea\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\x9cIDATX\x85\xe5\ +\x97]l\x14U\x14\xc7\x7fg\xa6[\xaa\x15j\x944\ +hwf\xa7\x8bM\x90T\x9f*\x09\x0f\xf8\x81\x04\x12\ +\x91\x0fI\xd4\x10\x8d$\x08\x91\xf8\xe0\x83\x09\x0aJ\xe4\ +\x01\xc5\xfab\x82\x12PCbLx3\xb1\x81\x0a(\ +\x89\x04\x9e\x90\xd0\x84\x90T\x03Y\xda\xdd\x9d\xd9\xa5b\ +\x8d\x09\x22\xa8\xed\xce=>\xec\x07\xb3\xddn\xbb\xad\xbe\ +q^v\xe6\xdc\xff9\xff\xff\xbdw\xee=g\xe1N\ +7\x99\x09\xf8J>\xef\xc4\x0af\xbdAV\x08\xea\xa0\ +\xc4\x11,\x94\xcf\x8d\xbf)\ +\x22f&\xe4eSU\xc9\xf8\xf9\x1d\x82\xee\x05rh\ +\xb8\xc4\xf3\xbc\x91(\xa6ibP\xac\xb9e\x7f\x91\x5c\ +\xfb=\xd7\xa9!\xbf\x92\xcf;v\xc1l\x11x\x06p\ +\x01\x83\x92\x05=\x06\xe6P\x94@DTU{\xb3~\ +.\x09lA\xec\xc3\xaa\xbaBDt\xd2\x15\xf0}\xbf\ +\xc7\xa8\x9cG\x19\x0d\xc3\xb1\xae\x85\x0b\x17^\x8f\xcc\xc6\ +\xca\xf8\xf9\xb7\x05}\x0fh\xa93\xe9\x9b\x02\xef\xb8n\ +\xfc\xd3(\xc9\xe0\xe0`\xf3=s\xdb.\x02\x8bPV\ +{\x9es\xbc\ +\xe1\xba\xee\xc0D\xdc\xa4\xb7\x9c\xe38WB[\x96\x02\ +\x97Q6\xdc\xfa\xeb\x9fK\x99L\xf0\xaa\xaa\xd6tP\ +\x13MU\xadl6\xf7B\xeb\xdc\xb6\xc1\x12y\x0e\xb5\ +\x97MF\x0e\xd3\xb4\xe5\xe9t\xfa^,\xfb\x0bA\x9e\ +/\xb9r\xa8\xf4\x8b\xc8\x09(\x0c[\x965R(\x14\ +\x0c4/\xc0\x0e\x13bX\x85\xc8:J\xf5C\xe0\xa4\ +1\x85M\x9d\x9d\x9d\xbf\xd4\xe3h\xa8\xc2g2\xb9\xa5\ +\x22\xda\xab\xf0x#x\xe0\x82\x11\xdd\x91t\xdd\x93\xd3\ +\x01g\xf4\xd7,\x9dN{X\xb1\xf5\x82\xae@q\x10\ +\xe2\x80\x0d\xe4\x04r\x069\x83\x91\xbe\xce\xce\x8eK3\ +\xc9{g\xdb\xbf!\xb9\xe6\xce\xae\xea\xf6\xd6\x00\x00\x00\ +\x00IEND\xaeB`\x82\ +\x00\x00\x00\x98\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00JIDATX\x85\xed\ +\xce\xc1\x0d\xc00\x08\x04A\x82\x5c\x1b\x15P\x02}\x98\ +\x9aR\xa0\x9d\x22.\x12\x9f\x9d\xff\x9d\xd6L\x10Y\x1d\ +Y\xad|\xb82\xfe\x03\x01\x04\x10@\x00\x01\x04\x8c\x07\ +,\xf5\xe0^\xdb\x915\x13\xf0\x1c\x7f\xcd\x8fr\x01\x00\ +\x00\xe6}\x0c\xb6\x09O\xb2q\xd6\x0c\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\x9b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00MIDATX\x85\xed\ +\xd7\xc1\x09\x00 \x08Fa\x8bFr\x80\xb6q\x9f\xe6\ +\x09\x5c\xad\x0d2\xa5\xe3{\xc7\x1f\x84\xef\xaa\x08%S\ +[\xae\xb6\xfcu\x8f\x1a\x05\xc3L\xee\xd7z\xe5\xe8g\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\xff\x8c\ +\x9a\xec\xd4NA\x079\xb5\x09\xe59\xad\x0dN\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\xd3\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x85IDATX\x85\xe5\ +\x97Mh\x9cU\x14\x86\x9f\xf7f\xd2\x1f\xa1\xb5\x95\xa2\ +)6\xb4\x06\xad\x9a\x8d\x81\xd4I\xb2\xf0\xa7\xa5\xb4T\ +i\x93\x9a\x18\x11\xa9\x85\xa2\xb8p'\x08).\xa2(\ +\x1ap\xa5\x14E\x11D\xd1Mh3i\xa2\xa9\x16,\ +\xe9B\xdai\xac\xa5\x0bCA\x88\xa0\x93F\x11\x94j\ +\xb5?\xccw_\x173I\x93N\x92&d\xe2\xa6g\ +s?\xcew\xbe\xf3>\xf7~\xf7\xe7\x5c\xb8\xd9M\xf3\ +\x09~\xb0\xd7\xd5\x15\x09-\x96\xb7ZTc\xd6\x09\x02\ +0\x8a\xc8\x19\x1dWB&\xdb\xa6\x1f\xcb\x0a\xd0\x94q\ +:\xda]\xc0\xe69&\x1dJ\xa4\xfdC\xbb\xf5\xcd\x82\ +\x00\xea\xbb}k*\x15\xdf\x07=]t\x8da\xf7;\ +\x84#J\x18Y\x12\x19\xbb\x92\x22:R%\xb1A\x8a\ +\xdb@\xcd\xc0\xfab\xf6\x01\x82\xf6e\x9b\xf5\xdb\xbc\x01\ +\x9a\x0e\xfb\xee\x98\xb8\x0f\xb8\x1f\x18\x13\xea\x5c\xb6\x9a\x8f\ +\x077+?k\x97:\x1d\xd2u<%\xfb\x0d\xa0F\ +\xe2\xe7h\xed:\xf5\x84\xce\xce\x19`\xd3A\xd7T\x04\ +g\x815\xc0a\x96\xe9\xd9\xecc\xfakV\xe1\xebl\ +\xc7\x80\x97\xfeq9\xbe\x07\xda\x87\xf9'X\x0f\x9dh\ +\xd3\x99\x1b\x024\x0cx%\x97}\x02\xa8\x05\xbf\x93=\ +\x1b^\xe25\xc5\xf9\x88O\x98\xad\x86^:\xb0\xdf\x04\ +ry+}\xbaUc\x93CB\xc9GW\xe2\x01\xa0\ +\xd6\xa6\x7fA\xe2\x00\x92\xb3-t\x19\x7f\x04\xacK\xc9\ +\x9faO\xe9\xf4\x14\x80\xf4Ao\xc2\xdac\xf8=I\ +\xb4gA\xe2\x93 .\xe6\xc3\x8b\xc09`K\xc3!\ +v\xcc\x08\xa0\x0a\xbf\x05\x10\xac\xd7O\xb7\xeb\xc2\x82\xc5\ +\x8b6\xdc\xae\xabB\xaf\x14\x14\xdd5y\x14&\x1e\xea\ +\x0fymJ\x1e\x05\xfe\xfc;\xaf\xb5\xc3\xed\xbaZ.\ +\x00\xa00\x1f2\x1e\x06\xee3\xaa\x1b_\x15\x13#\x90\ +\x0a\xec\x04\x84\xfce\xd9\xc5\x01$\xcb\xee\x03\x08\x8e\xbb\ +\xc7\xdd\xd7~\x81\xe3\xa3\x85&|Uv\xf1\xa2E\x85\ +\xaf\x01,m)\x05@\xd5\x85\x86\x9f\x16\x0b \x88\x11\ +\x00\xcc\xbai\x00\x0a\xce \xc6X$[\xbd\xb4\x98[\ +\xdc9>\x11K\xf7\x81\xff\xcb^\xa5\x04`\x14\xc0\x91\ +\xaa\xc5\xd2\xbcpi\x22\xf7\xf9\xf1=f\x12\x80\x7f\x01\ +p\xe0\xae\xc5\x02H\xa0\xa6\xf8\x98\x1b\xf7M\x00\xd8a\ +\x10 8n_,\x00\x14\xb7\x15\xd5\x8e\x95\x00T\xa6\ +\xe8\x070z\xbc\xfe\x03W\x96]\xdc\x16h\x17@T\ +\xc8\x94\x00|\xdb\xac\xf3\xc01`M\xe5\xed\xe0^`\xd4R\xe7-\xab\xf8d.Eic\ +\x1dm.\x14\xa5\xf7\x009Y\xcd'[\xf5\xfdt\xe1\ +\xb3\x96\xe5u\x19\xafZ\xea\xf8!\xe8\xc9\xa2+g\xbb\ +?T\x84#I\x9e\x91Td\xecR%qyBU\ +\x02\xebC\x88\xdb](\xcb\xc77\x9c\xa31\xaf\xbdC\ +\xed\xfau&\x8d9]L\xd2=n\x12\xee\x02\x1e\x9e\ +K\xbc\xc5\x19\xa1\x8e\xecn\x1d\xbdQ\xec\xbc\xaef\x8d\ +\x19op\xa4\x05y+PM\xe1\x04\xad\x00r\x88\x1c\ +\xe8xH\xc8\x9ch\xd3\xb9\xf9\xe4\xbd\xb9\xed?\x89G\ +c\xa6\x91&\x12\xd0\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x03b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x14IDATx\x9c\xed\ +\x9a;h\x14Q\x18\x85\xcf\x99]0b\xb0\x11\x111\ +\x85\xc1X\x08\x01\x0baw\xed\x02\xbe0\x85\x8f\x0d1\ +`\x97\x80\xa8\xa4\xb3\x09)\xad\x8c\xa5\x90 ZXZ\ +$\xee\x86 $\x82\x0a\x16\x82\xd9\x80E$\x85\x85\xa2\ +\xc5\x82\x88X(>\x12\xdc\x9dc\x13Dwfw3\ +3{\xf7&\xce|\xe5\x9d\x9b\xf3\x9f9\x99\xc7\xbfw\ +.\x90\x90\x90\x10g\x18U\xa0oZ\x9d\xabi\x8c\x0a\ +\x1a\x14\xd0K`[+\x8c\x85E\xc0\x1a\x81\x15\x823\ +\x1d\x15L=\xbb\xc0o\x8d\xe6G\x0a [\xd4\x09@\ +\xf7\x00tE\xd11H\x19\xe0H)\xcf\xc7\xf5&8\ +a\x95\xb3E\x8d\x00z\x84\xcd{\xf2\x00\xd0\x05h!\ +[\xd4p\xbd\x09\xa1\xae\x80\xec\xacNBZ@\x84\x00\ +\xdbL\x15\xe0i\xbf+!p\x00}\xd3\xea\xfc\x99\xd6\ +k\x00\xfbZb\xad}\x94\xb7Wx\xa8\xf6\x99\x10\xf8\ +?\xb8\x9a\xc6(\xb6\xde\xc9\x03@\xd7\xba\xf7\x7f\x08\x1c\ +\x80\xa0\xc1\xd6\xf8i?~\xdeC\x04\x80\xde\xd6\xd8i\ +?~\xde\xd3AE\x9a\xbd\xe7Ky'ro\x11\x85\ +l\xd1U\xbdc~\xde\xb7\xcaS\xdc\x18I\x00\xb6\x0d\ +\xd8&\x09\xc0\xb6\x01\xdb$\x01\xd86`\x9b\xd8\x07\xd0\ +\xb4\x11:R\xd0\xde\xb4\xe3^\x95\xcbc \xf64\x9b\ +\x9f)\xbao\xc2\x9a\xa1 \x10e\x81\xf3\xec\xc0\x9dR\ +?\xbf\x86\xd5\xdap\xcdF\x07s\x05\x9d\x11u\x0f\xc0\ +.\xd3F<\x08\xef\x00^,\x0dp1\xc8\x9f5\xea\ +\x04\x01o\xa7Z\xf7\x16\xc8\x14\xab\x13\xa2\xe6`\xe3\xe4\ +\x01\x80\xe8\x06\xf55n\xb2H\xd3/\xae\x99\xa2\x0e\ +\x13\xee\x98\xc0\xe3\x04v\x9b4\xb3N\x19\xd2<\x1d\xe7\ +\xc6\xe2y\xbeoC\xbd\x84\x84\x84\x18\xf3\x1b\xe9\x0c\xd1\ +\x12\xec\xcb\x09\x01\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x04\x03\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xb5IDATX\x85\xe5\ +\x97]h\x9bU\x18\xc7\x7f\xcfy\xfb\x81S\xe7l\x07\ +\x8b\xd8\xb2Y\xaabA\x915\xcd\xf4\xc2\xaf96D\ +\xb6N\xb0\x88\xc8\x9c\x0c\xd7t\xad\xe9\xaa tx\x11\ +\x83C\x0b\x82\xc54\xad&\x1b\x88\xa2W\x03\x8b\xedt\ +:P\xba+\xe9\xb2X\xbc\xb0\x14\x84\x0a\x9a6\x1d\xae\ +\x05\xc5m6\xcb{\x1e/\x92~f\xedZ\x9az\xb3\ +\xff\xe5\xf3>\xe7\xfc\x7f\xcf\xe1=\xe7<\x07nv\xc9\ +j\x92\xeb\x9a\xbb+\xad\x9b\xd9/*\xbb\x10*\x11*\ +P\x0c\xca\x18\x22I\x84s\x8e\xda\xde\xc1\xe8\xd1_\x0b\ +\x0a\xe0m\x0a\xfbP:\x80\xa7V8k\x5cT\x8f\xc5\ +\xa3G\xbf_\x13@mc\xf4\x0e\x91\xe9\x8f\x80\x17s\ +\xa1\x14H\xbf*g\xd4qG\xf5_\x93*\xde`\xac\ +\xa6\xf1X\xb1\xdb\x8ca\xb7Z\xea\x11\xb6\xe6\xa6\xff\xc6\ +q\xddC\x83'\xdb.\xae\x1a`{sw\xb5\xc9\xd8\ +>D\x1f\x00R\x22\x04o\xdd2\xf9\xc9@(\x94Y\ +\xb6\xa4`\xd0x'\xca_\x009\x0eZ\x05\xfcn`\ +\xdf\xf9h\xeb\xcf+\x06\xf0\x1e\xf9\xa0\x0a[4\x08l\ +\x06\xberJxy\xb0\xab\xf5\xefe\x8d\x17\xa9:\x10\ +.\xdd4M\x0f\xc2!\xe02\xc2c\x17>n\x1d\xba\ +!\xc0\x8e@xc&\xcd\x8f\x025\x8a~\x98\xf0L\ +\xbdA(dWc>'\x95:\x7f\xb8]\x91w\x81\ +\xa4\xaa\xebK\xc4^O\xcd\xcf0\x8b\x87\xb8\xd3D\x04\ +j\x80\xfe\xb5\x99\x03\x88\xc6\xa3\xad\x1d\x22\x9c\x04*\x8c\ +8\x9f\x83.(z\x01\x80\xcf\xdf\xe5E8\x80\xf0\xa7\ +j\xe9\x81\xb5\x99\xcfA\x5c\x9e\x9cl\x01F\x14vz\ +\xfd\xe1g\x96\x04\xb0\xa2\xef\x01\xa8\xea;\x89\x98\xff\xaf\ +\xb5\x9bg5|*\x94\x16x+\x07\xd41\x7f\x15f\ +\x01j\x1b;\xefBy\x1a\x98\xba:5\x15-\x94\xf9\ +\x8c\xe2\xd1@/0\x02<\xe8\xf3w=\x94\x07 \x98\ +\xbd\x80\xa0|=|*\x94.4\x00\x88\xa2\xda\x07`\ +E\x9f\xcb\x03@\xe4I\x00E\xbe-\xbcyV\xd6\x98\ +\xef\xb2(\xb23\x1f\x00*\x01\x1c\x91\xdf\xd6\x0b\xa0\x84\ +\xcc(\x80BE\x1e\xc0L\xd0\xc8\xb5T\xfe\xd0\xc2\xe8\ +R\xb133\xf7\xdd3?b\xde9\xf0\xbf)\xf8\xf6\ +B\x00\x811\x80\xb48\x9e\xf5\xf2\xbc\xdd\x1a\x0f\x80\xc2\ +\xf8\xcc\x193\xb7\x02*\x7f\x00\x18\xcb=\xeb\x05`\xae\ +\xb9U\x00\x02\xc9\xd9\xd8\xdcW\x1d\x00\x10\x91=\xeb\x06\ +`\xd8\x0d\xa0\xf0C\x1e\x80[$\xfd\x00\xaa\xfalm\ +c\xb4\xb8\xf0\xf6*Ve\x1f\x80\xb1no\x1e\xc0P\ +$0.Y\xb2\xcd0\xfdj\xa1\xed\xbdG\x22{s\ +\x97\xdc/\xf1\x13m\xb3\xbd\xc1\xc2]`m;\x80\x08\ +\xc1\x1d\x81\xf0\xc6B\x99\xd74\x04K\xd4f\xef\x19\x81\ +c z]\x80\xf8\x89\xb6\xb8\xc2\x17\xc0\x167\xcdg\ +\x04\x83\x05\xd8\xa6*\x1b\xee,\x0f\xe7\xaa\x1f\x88G\x03\ +\xa7\xe7\x7f\xcd7\xd0\xd2\x16\xb2\x97F\xbdw\xa2\xfc\xfd\ +\xb5A\xa8x\x9b\x22o\x22\xf8Q\xc6\xddbyi~\ +\xf5\xb0DK\xb6\xbd\xb9\xbb\xda\xb8\xee P\x06|y\ +\xc5q\x0e\x0e\xf7\xb4\xfc\xb3\x1a\xeb\x9a\x86`\xc9-e\ +\xe5\x11\x81\xc3\xc0\x15\x83\x1a\xb8\xb08o\xc9\ +\xa6\xd4w8r\x9f5\xb6\x0f\xb8_\x911\x81\xe0m\ +\x9eK\x9f\xae\xa4)\xad\xbbX\xf6\xbcU9.p/\ +\x90T5\xf5\x89\xd8k?]/}\xd9\xb6\xfc\xe1W\ +:7\x15\x95\x9a\x18HC.\x94\x14\xa1\x1f\xe5\x0c\xd6\ +\x8c\x16\xd9t\xea\xaa+\xd6))\xf2\xa8a\xab\xb1v\ +\x0fb\xeas\xdd0\xc0Yq\x9c\x83\xf1\x9e\x96\x89\xa5\ +\x81\x93C\x9f\xc0E\x90\x82\xa3\ +}\x80b>P3\xb8\xe8 \xa1i{\x1clB\x13\ +\x9b4\xe9\xe7\xd0\xfe\xa7\xfbq\xee\xfd\xffr\xee\xb9\x97\ +\x00\xcb.J\x9at\x1c'\xe7\xba\xed*\x88\xf6\x01\x14\ +&\xf42\xc1TWU\xaa\x08!~F\x028\x8e\x93\ +s\xdb^\x03\x8c\xd2\x84\xc6a\x11\x9a\xaa,m\xfb\x10\ +R\x5c\x9c\xeb\xb6\xabS7\x07\x00F\xc9\xf3\xb8\xeaw\ +c\x01\xfai\x9f\x8d\x88\x0f\xfc\xa6\x92\x10\x16:s\xbd\ +\x90O\xac\x97Q2L\x9b\x87\xed\x1d\x9f\x819i\x05\ +\xf0\xaf\x06Z\xad7MQx\x97\xc1\xa1q\xc3\xb0O\ +bw\x91\xb8G,75m\xfd\x99\x88\xbaY\x00B\ +\x85e\x18\xd6\x19\x88.\x87\x81\xa5\x11\x03O\xc4\xddC\ +]\xd7?\xa2s\x91\x22\x0c\x8a:8\x82W\xcb*\x83\ +\xe8j\x5cs\x00 `\x87I\xbegf9\xed\x9a\x00\ +\x80\x98\xce\xc75\x8eBX\xd6\xfbV\xda\xf8\xc1\xaf\x0d\ +\xbfz\x84\xdb\xd4\xae\x8c=\x00\x22\xe8R\xb7\x04\xa0\x91\ +\x15 T\x0f\xba\x96\x8f/\xba\x88\x0c\xcb\x06\x18\xc7\xc1\ +@\x8fR\xdf\xae\x85_\xc3\x15\xc0\x0a`\xe1\x00c\xbf\ +z\x89\x22\xd4\x0c\xd3\xae%D\x98~c1\x19`\xaa\ +\xfb\xcd\xd9d I\x84\xa6\xaaP\xc5\xef\xce3\x03&\ +\x98n\x06\xff\x88\xffx\xfa2L\xfb\x0b\xc0\xda4\x9c\ +\x08tT(l\xdc\xa5\x89\x1d\xcc\xc0\xc34\xcc\x01t\ +<\x85\x1e\xd3\x06\x07\x00\x1dE:\x05\xf09\xb1=\xf3\ +EQ\x08;3@Q\x08\xbb\xa3H\x9b\x00\xea\x00\xbe\ +\xb3\xda\x02xa\xe2\xb2\xaek\xd7\x19\xd7.\xb9~\x01\ +\xf9\xaa{\xc5#\x95s\x7f\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x01\xb2\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01dIDATX\x85\xe5\ +\xd61N\xc30\x14\xc6\xf1\xffs\x93r\x03:p\x82\ +\x96\x89\x89\xb9\x8d\xc4X\x04\x5c\xa1\x03\xb7\xf05\x90\xe8\ +\x15*\x04,\x88B{\x08\xa0\x9c\x80\x01&\xf6\xd2\x98\ +\x81\x86\xa2\xa6!v\xe2\x84\x01\x8f\xf6\x93\x7f\x9fl\xe7\ +)\xf0\xdf\x87\xd4\x89E\xfdAK\x85\xe6\x12\xe4e<\ +\x1a\x9e\x00\xa8zq\xa6 \xfb`v\x92\xf9Z\x02\xac\ +p\xda\xc0s<\x97\xc3d\xad\xf2+H\xe3t\xef\xaf\ +\x86\xaf\xb5\x04\xc8\xc3+\x0d`\x83W\x16\xc0\x16\xaf$\ +\x80\x0b\xee=\x80+\xee5@\x11\xdc[\x00[\xfc\xe0\ +\xe8t\xdb\xa8\x8f\x1b\x83\xbc\xdf\x8d\xce{\xe0\xa1\x119\ +\xe2\x13`O0\xcdd\xbeT\x80\x02\xf8.\xf0(q\ +p\x9c\xac\x15\xbe\x82\x12xt{q\xf6V*\x80/\ +\xbcP\x007|1\x05\xd3\x01\x9e$\x0ez\xeb\xb8s\ +\x00\xdf\xb8S\x80*p\xb0\xfc\x0al\xf1\xa8?h\xb9\ +\xe0`q\x02.\xb8\x0ae\xe2\x82\xe7\x06(\x86\xcbL\ +\xe2Fw\x13\xee\xd4\x09+\xc2S\x9d0\xa8\x0f_L\ +\x81\x0ek\x9d\xb0Q\x0eg\xb9i6\x1e\xf5\x07-\x09\ +\xcc\xcf\x87\x99\xdd\x09\x0b\xe0m\x90Y<7\xbd\xa2\x0f\ +S6o\xea\x0b_\xd5e\x9d\x90\x02\xd0Z+\x152\ +\xce\xc3\x01Q!\xd7y\xf8z]\x16\xfe\x1d`9\xb6\ +\x80\x87\xdf\xfed\xb4\xd6\x02\xd2\xfc\xaa\xcb\xc4Su6\ +\xfd\x00\xad\xb5\xc2\xae5\x8b\xe7\xba\xbf\x1d\x9f\xf9\xbe\xa6\ +\x95\x85\xff\xbc\x8e\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x03\x5c\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x0eIDATx\x9c\xed\ +\xd5KlTu\x14\xc7\xf1\xef\xb9S\xa6\xda\x81\xd0\xd0\ +\x98PMJdcR6\xc0L\xc7G\xa2\xa9\xcf\xa4\ +\x16$,pA\x04K\x023\x03\xed\x80b\xe2\xc2\xc4\ +L\xba3\xf1Q;\x03\xa5\x0f\x89\x04\x16\x18\x0a)1\ +`\xdd\x98X\x92R\x18\xdaY\xb2\x00\xa2\x1b\x83\x84\xd0\ +\x0aI\x83\x9d\xda\xceqQ\xa3\xd3k%\xd8{g\xba\ +\xe0|\x96\xffs\xefo~\xf7\xcc\x0b\x8c1\xc6\x18c\ +\x8c1\xc6\x18c\x8c1\xc6\x18\xf3\xa8\x10\xaf\x01\xcf\xc6\ +\xd3\xf5\xb3\xcaq\x84\xa7P\xbe\x18\xedM~\x06\xa2~\ +\x94[H4\xd1\xb9\xb5\xa0\xf2)\x00\x05I\x8e\xf6%\ +\x07\xbd\xe4y^@$\x9e\x19\x02}\xe9\xef\x03\xe5\xc4\ +\xfd\xdf\xc6w_\xedo\x9f\xf6\x9a=\x9fJ8\x9e\xf9\ +P\xe0\x93\xa2\xc3{\xaa\x95O\x8c\xf5\xc6\xffXl\xaa\ +\xe3C\xb1\xf9\x19\xc2\x8e\xaaU5\xdf\xafo\xe9\xa8\xf6\ +\x9e=\xa71\x95\xaa\x88\xc4\xd3]\xae\x87\x9f{5\x8f\ +\xbc/@t\xaf\xc0m\xd7\xe9\xcb\x81\xca\xc0\xf0\x86\xd6\ +Ck\xbc\xc6\xd7\xef;\xbc|\xf2V\xcdY\x90\x84k\ +\x94\x17x\xc7\xcb\xbb\x0f>l\x10 \xba;\xf3t!\ +\xa0\x83\xc03\xae\xd1-U\xa7y\xac\xb7-\xb7\x98\xdc\ +p\xac\xa3V$p\x0e\xd8\xe8\x1aM \xf2\xd6hw\ +rx1\xb9\xc5|\xf8\x0a@\xf6\xab\xe4\xcf\xcbff\ +^\x00\xb9\xe0\x1a\xad\x16)\x5c\x08\xc7\xd2\xcd\xff7\xb3\ +a\xcf\xa1u\x22\x81K\xfc\xeb\xe1\xe5'\xa7\xe0<\xef\ +\xc7\xc3\x83O\x0b\x00\x189zp\xe2nP\xdf\x00N\ +\xbaF!\x11\xbe\x0d\xc7\xd2{\x1f6kc\x22\xf3\x8a\ +:\x85a\xa0n\xfeD.\xcfN\xebs\xd9\xbe\xb6k\ +\x9e\x0b\xff%\xe0W\x10\xc0Dvp\xf6\xe6\xa6\xe8@\ +\xedd((\xf0b\xd1HDh~2\xd2\x14\xba\xb9\ +)\xfa\x03CC\xff\xf97\x19\x89\xa7w\x0a\x9c\x02\xaa\ +\x8a\xcf\x15\x19@\x83[rG[\xef\xf9\xd9\xd9\x97\xdf\ +\x80\x85Db\x9d1D\xbap-Y\xe1\xd4\x8a\xfc\x8a\ +w\x7f<\xb6kj\xfe\x1d*\x0d\xf1\xcc\xc7\x0a\xed\xee\ +,E;\xd7N\xd4~\xd0\xdf\xff\xf6\xac\xdf=K\xb6\ +\x00\x80\xc8\x9eL\x13\x8e\xf6\x03!\xd7h\xd8\xa9p\xb6\ +d\x0f\xb7\x8d\x03\xd4oK\x05\x1f_U\xd3#\xd0\xe2\ +\xbaN\x05y\xffJO\xb2\xb3T\x1dK\xba\x00\x80H\ +\x22\xbd\x01\xe54Q\xd2tw\ +k\xdb\x88\x22A\x14\xa5\x8b.\x82JK\xda\xa22\xbb\ +\x09\xac\xd0\x8a \x04\xaf\xccvV\xcd\xed\x03\x0a\xbd\x08\ +\x9d]\xcd6H\x8a\xc0\xd0V\xb7\x0c\x04%\xd3l\xe6\ +=]\xcc\xec8\xe3\xce\xae;\xd6\x9d\xe7f\xf8?\xff\ +\xe7=\xe7\xbc_\xff\xe7\x19\xb8\xd4\xa1j\x92\xa7\xb7\xbb\ +&\x91\xa3\xd1\xf2\x1c\x8b\x1a\xcc\x04A\x00\x8e z\x8c\ +v)G:\xd3\xac\x9f\xffW\x033\xd3NE{-\ +0k\x88\xa4]9iUW\x93\xbe\xfaO\x06\xa6n\ +\xf6\x95\xc9d\xdc\x00z\xac\x10\xea\xc5\xde\xee\x10>S\ +\x8e\x83\xc3#\xbd\x7f'\x89\x8e\x8c\x97\xb8A\x8asA\ +\x0d\xc0\xf5\x05\xf6\x0e\x82\x96d\x1a\xf4{\xd5\x06fn\ +\xf5M1\xe7m\xc0m@\xafP\xeb\xc8\xb1|\xb4s\ +\x96\xb2\x83N\xa9\xd5!5\x85Ge\xbf\x06\xd4J\x1c\ +\x8e\xd6\xa2\xce\x87\xd4=d\x03\xd3\xb6\xb86\x11\x9c\x01\ +\xc6\x01[\x19\xa9'3\xf3urP\xe1\xf3\xf0@\x87\ +G\x1c?\x13\xd7\x83\x96`N\x05\xeb\xee\xdd\xcd\xda\x7f\ +A\x03\xf5\x1d\xbe\x823\xde\x0d\xd4\x81\xd7e\xba\xc33\ +\xbc\xa2X\x8dx\x11\xb6\xea\xdbY\x89\xbd\x06\xe8\xc9Z\ +\xa9}\x0f\xab\xb74%\xd9o\xd0\xdf\xf1]P\x9d\xcd\ +\xf6\xce\xef\xfb\x8bOowM\x88q)\xd2|\xccD\ + b\x0e\x81vd\xe1\xc32\x01\xc9\x19{m*\xed\ +Z\xa1\xa5Iy\x13\xf6\x1c$W\x5c\x81\xd4\x16OS\ +p\x97\xe1\x8f\x5cV\x93\xf6\xb5\xe8D\xf1e\xabC\xfd\ +\x14\x9e\xc7~\x09\x18Yy\xc6\x9c\x92\xf4\xc2\x9e&\xde\ +)\x15\xa9\xdb\xec\xe1\x97'\xdd\x0d\xdcJ\xd4\x82L\xb3\ +:\xfa\xde\x85\xd2\xf1J\xf8\x0d\x80`\xbd\xdaO|r\ +\xdcXX\xca\xca\xe2\xf9\xe9\x8c6^7#\x1d\xd7c\ +\x17'w\xa0Eg\x85^\xcc+zm\xe9\xbb\xa2\x81\ +\xa9\x9f\xf8\x1a\xcc\xfd\xc0\xf1\x939\xde/\xe5\xad\x9f\xcc\ +j\xd0\x13\x98!\xc1hE};O\x97\xc6\xf64\x91\ +\x06~\x04\xeeH\xa5\xb9\xb3\x9f\x81d`! \xe4\x1d\ +\x07Zt\xb6/>m\x8bk\xc1\xab\x0b3\x1c:\xa2\ +_\xbfk\xab\xaf->K\x96\xbd\x0d 86\xf53\ +\x80\xe3}\xf9\x9f\xf0y)O\x22\x11\x9f\x02\x86U!\ +]\x10d\xf4?\x91ee\x9e\x14\xbe\x00\xb04\xbb\xbf\ +\x01TS\x18\xf8K\x19\x91\xb5\xa0j\xf1\xa2\x07?X\ +\xfa\x1c\xc4\xc1<'\x13*\x18\xc8\x07\x838w\x8d\xf2\ +\x87\xa5\xf6b\x0d\xd8\x85Or\x01cG\x14\xb8\xc5u\ +}\x071T\x18w\x0e/\xa3\x0b\xe6\x0c\x02A\xe2\x02\ +\xdce\xe4G\x00\x1c\x19_\x8c\xbc\xa2h8t\xb1\x06\ +\x80\xc3\xa5\x0f'N\x17\xb9\x8f\xf6}\xe0J\x0c\xf8W\ +\x00\x07n,\xa3\x90;\xb8H\x88\xf2\xb1\xb9s\xdb\xd9\ +\xd3\x17+\x1a\xb0\xc3N\x80\xe08\xaf\x8cD\xe1=\xe0\ +bj\xc1\xd9\x98\x0c\x1f\x96;\x8as\x0bj_\xf73\ +0,\xc9v\x00\xa3\x05S\xdfw\xf1\xdae\x1au\x00\ +\xf9\xedj\xd5-\xad\xe9\x5c\xa4s7\xca\x16h\x11@\ +TH\xf73\xf0M\x83\x8e\x02_\x03\xe3\x86]\xcd\xd2\ +R\xb2\xec\xb1\xf0\x1c\xa2\x8a\xad\xf0\xc7\x9d\xdf\xf1ji\ +dF\x1b\x0b\x81:\xe0\x87\xaeF\x8a\xbdA\xd9\x09\x8f\ +\xd6\xca\xbcY\xb7\xd6w\xf8\x8a\xbe\xf8\xbe\xe5\xfa'{\ +L\x8d\xe0u\x0c\xbe\x1dY\xe15\x13\xb3\xe1\xb1\xd2*\ +Z\xb7\xd9\xc3\xad|\x9dQ\xd0\xaa\x01\xab!@\xaa-\ +\xb7I\xe8q`k\xa6[\x0f\x9d_\x8e\xa7\xb5\xf9\xf6\ +\x04q\x05\xd6|\xc4D\xc0\x86C\xc2\x9f\xe6\x12a\xc3\ +\xde\x06\xfdT\xbe\x18V}:n\x00-\x07vf\x9a\ +4{P\x03\xf9>\xd0{\x80[\x8d\xdf\xea\xec\x0e\xcf\ +\x0e\xd4\x90<\xb2\xd9\x09\x80\x8f[\x94\xab\xb8\x1e\xb6R\ +\xed<+\xfbM\xe0h2\xa1\xe9\x85\xad.\xa2by\ +)\xf4\x83\x19\xe0*\xa0mTV\x8bw\xb6\xe8\xcf\x8a\ +\x22\x03 \xdf\x03\xc4wA\xcb\x80\xbf\x1cuog\xb3\ +\xf6\x9e\x9f7`}K\xb5\xf9f\xe1m\xc0-\xc0\x11\ +K\xad\x97\x8da\xe3P\x9a\xd2\x19Shv\xbe)\x9d\ +\x04\xf4\xc8j\xd8\xf3\xb0\xbe\xad\x94>h\x81\x9d\x92\xf6\ +\x98\x11\x8e\x1f\x80\x1e)\x84zlo\x0f\x89\xf0Y.\ +\xcb\xc1d\xa4\xf7\xf40\xe2\xa8\x1c\xe3sp}\x08q\ +\x9e\xf3my\xdf\x07\xe7\xcb\x98\xd5\xe2\xae\x16\xfd6\x90\ +\xc6\x90*|\xaa\xcd3\x85\xd7\x02\xf7\x0c%\xdfb\xbf\ +\xd0\xcaL\x93\xbe\xbcPnU\x7f\xcdf\xa4}\x83#\ +\x8d\xc8s\x80\x1a\xf2\x154\x01\xf4 z@\xbbB\x8e\ +\xf4\xeef\xfdX\x0d\xef\xa5\x8d\x7f\x01S\xeb\xdbx\xb8\ +\xf8\xe06\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x8f\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02AIDATX\x85\xed\ +\x971k\x14Q\x14\x85\xbf3Y\xab\x80\x85b v\ +\xf9\x03b\xb5\xbb\xa2\x88\x82]B\x8a$\xf8\x07\x02j\ +\x95\xca$e\x08\xa9V\xb00`PAA\xd2\x04\xc1\ +-\x82\x0bv\x01A\xb2\xbb\x95\xf8\x07\x92:A\xc1\x22\ +\x95\xc9\x1c\x8b\x9d\xb7\xac\x9b\xd9\xecNv\xb4\xd1\xafz\ +\xdcwg\xee\x99s\xdf\xcc\xbc\x07\xff:\xea\x0e\x94\xdf\ +\xfbf\x8c\x97\x11e\xc1\x95<\x8a\x18\x0e1\xf5\x08U\ +\xea\xb3\xfa\xdcS@\xa9\xea\xc7\xe0'i\xc2r\x22\xc6\ +Zj\xcc\xea\xe9)\x01\xa5\xaao\x81?\x01?\xb0\x16\ +\xa2\x13j\xbb\xf7\xf5=\x8f\xaa7\xde\xf9R<\xc2$\ +\xf2:pQ\xd6\xed\xe0D!$\xd9^\x92\x10\xd6B\ +cV\x9by\x14\x0e$\x0f\xb2Y\xacZ\xc2oc\xbc\ +\x0cL\x03D\xed,Q\x06\x88N\xa8\xe5Y\xbc\x8b\x1a\ +\x80D)\x04\xda\x02\xc2\x82\xcb\xcb\xf64\x9a3\xfa\x96\ +\x0c\xc7B\xac\xd0#\xf7\xdc\x14\xab\x9e\x12~\x05`\xf4\ +\xa09\xa3\x0fg\xe5\xe7*\xa0\xb8\xed\x09\xfd\xf4\x16b\ +\x14 \x11r\xf5\xack\xa2\xb3&3\xb1\xe2H\xc7~\ +\x13\x8a\x0fJn\x02J\xd7x\x04\xdc\xe9\x8cIZ\xfb\ ++\x02\x8a\xdb\x9eH>`\x9d\xec\xd4\xbf\xf0\xf2\xcf\x0b\ +H\xb3\xde\x1c\xb9\xa0yV\x15\xf7\xbb\xbc\xef\x22\xec\xb7\ +\xaaS\xad\x8f\xb4\xd8\x98\xd6\xde \xfa\xfb:\x90\x14\x1f\ +\x07\xc6eo\xb5\xecN\xc4\x0da} \xdbk(F\ +u\xec\xd7\xac\xf8\x1e@\xaa\xf5\x17\x06\xb3~`\x01\x92\ +\xd6lot\x84\xee\x96\xaf\xf3\xd01b\x08\xeb\x03}\ +[\x90\xd8\xb9\xd3\x19\xb3\xbd\x81\xfc\xbc+5\x93\xf5\x03\ +\x0b`U\xb1\x0b\x9a\xc7\x1c\xf5\xcc\xc9\xb0\xea\xb3\x0b\x00\ +\x9a\xd3\xda\x03-\xf5\x9aW\xa4\xc5fF\xeb3\x09\x00\ +h|\xe5\x05]\xadH8\x97\xf5\x99\x05\xa4\xb6b\x08\ +\xeb\xb3\x0b\xa0\xd5\x8aH\x9a\x03\xf6\x81\xfdH\x9a;\xaf\ +\xf5\x81\xcc\xbf\xe3\xdd\x19}\x04&\xfa&\x0eH\xdb\x01\ +\xc3!\xb46\x90y\xdd\xbc\x9bb\xd5\x97\x93\xe1\xc1)\ +\x01\x98:@<\xc2\xe4\x9f\x12\x00\xad{\xdb4B\xa0\ +\xdd\x82\x08U\x8c\xa7\x90\xd7\x8bU\x0b\xa8u\xec\xe1\x86\ +\x22y\xf2I\xe1g@\x1c\xa1J\x98K;\x98T\xc8\ +s\xa7\xf4;\xbd\x0f&\x81p4K\xb6\xcec\xdd\xf3\ +\xe7\xe4\xc0\xa6\x91v4\xfb\xcf/\xa6N\xeb\xad\xb9m\ +\xcb\x1e\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\x89\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03;IDATx\x9c\xed\ +\x9a\xbdk\x14A\x18\xc6\x9f\xd9\x0d\x84\xa0\xd8\x88\x04c\ +\x0aCb\xa1\x08Br\xd1\x94\xe2'\x06\xb1\x0b\x8a\x8d\ +x`6\x97\xd3S\x0b\x09\xfe\x05\xc6*\xb8\x97Kr\ +)\xd2\x086\xd1B\x84\x9c\xa0\x16\x01\x8bH.)$\ +\x88\x85\x82\xc5)\x04\xb5\x88\xe4\x833\x99}-\x22\x16\ +\xb7{{\xb7\x1fs\x93s\xe7W\xce\x0d\xcf\xfb\xecs\ +\xf3\xc5\xee\x00\x0a\x85\x22\xca\xb0\xa0\x02G\x063\xbb\x9b\ +8O2B\x1f\x18\x8e\x02h\x0c\xc1W\x10\x8a ,\ +\x11\xc3\xf4\x86\xaeg>\x8c%W\xdd:\x07\x0a f\ +\x8c\x9e\x05\xac)\x00\xadAt\x04R\x00\xb4x>{\ +\xf3U\xb9\x0e\x9a_\xe5\xd8\x80\x19\x07\xac\x97\xd8\xb9\x0f\ +\x0f\x00\xad\x80\x95\xeb6\xd2\xd7\xcbu\xf05\x02\xba\xfa\ +\xcds\x8c!\x87\x00\x01\xd6\x18\x0eh\x17\x9cF\x82\xe7\ +\x00\xb6\xe7\xbc\xf5\x91\x81\x0e\x84\xe3\xadf\x14\xd6u\xfd\ +p\xe9\x9a\xe0\xf9\x1fl\xe2q\xf0\xde\xe0C\xc6u\x9f\xcfg\ +S\x81\xcf\x16A\x88\x19&\xb9\xfcl\xf3^/\xab\xb8\ +0T\x00\xb2\x0d\xc8F\x05 \xdb\x80lT\x00\xb2\x0d\ +\xc8&\xf2\x01T<\x08u\xf5\x8f\xec\xd74-A`\ +\xa7Ah\xae\xd4?f\x98\x9f|\xbb!\x10\x18\x0a \ +\xcc\xe8\x8d\xc8\xbeK\xa7~\xf9\xd6\xaa\x12\xd7\x00b\x89\ +\xf4%X4E\x84\xbd\x1e4\xdb}\xbb\xd9>Cv\ +\x80\xe1$\xff\x8dDg\xc2\xbc\xba8\x9e\x9a\xf3\xadW\ +\x05e\xa7@\xcc0\x87a\xd1s\xc0\xd3\xc3\x87I\x9b\ +f\xe1m\x97\x91\x1e\x10Y\xc41\x80n#}\x19\xc0\ +\x90\xc8\xc2U\xa23\xd0hg\xc2\xec\x11U\xc0\x16@\ +\xcf\xc0\xc8A\x02M\x8a*\xe8\x03]\xb3\xf0\xe4\xc4-\ +s\x8f\x08q[\x00[\xd4p\x1f\x80\x90b\x01h\xe3\ +E\x18\x22\x84\x1d\xa6\x00\xf5\x8a(\x14\x18\x06!\xbe\x9c\ +\xd6\x80\x9d\xf9\x96\x97\xc4\xf8\xf2\xfcB\xc4\xd2\xf5C\x22\ +\x8c\xe8|\xab\x83\xc0re;\xb0\xe0\x1fq\x9c\xf0\x1c\ +\xc0\xe2X\xd2\xffA\xc7\x85\xce\xc1\x0c4\xceEH\xbb\ +\x12\xf9\xa3\xb0\x0a@\xb6\x01\xd9\xa8\x00d\x1b\x90\x8d\x0a\ +@\xb6\x01\xd9\xa8\x00d\x1b\x90\x8d\x0a@\xb6\x01\xd9\xa8\ +\x00d\x1b\x90\x8d\x9f\xfb\x01\xb2h\xaf\xf0\xed\xbf\x1a\x8a\ +\xa5\x0d\xd1\x1a\x01\x84\xa5\xd2\xa6H\x05@\x0c\xd3\xa5m\ +Q\x0a\xa0\xb0\xa1\xeb\x99\xd2\xc6\xa8\x04\xc0\x01-\xeet\ +o8\x0a\x01p\x06v\xa3\xdc}\xe1z\xda\x05\xfcP\ +\x00\xb4\xf8\xbc\xcbe\xe9\xff1\x80\x7f\xd7\xe57\xd7\x8b\ +\xa3\xef\x1f\xdf[s\xebl{\xd5\x1c\xc2^+\x8a\xcf\ +\xf9l\xaa#lQ\xfb\x1a\xc0\xf0=\xec\x22\xa1\xc0\xb0\ +,B\xd6\x1e\x00\xe1\xb5\x88BAa\xa07\x22tm\ +\x01h\xc0C\x00\x9b\x22\x8a\x05\xe0\xa7eY\xe3\x22\x84\ +\xf5\xd2\x86\xaf\x0b\xb9\xe5\x96\xee\xdeU\x00\xe7E\x14\xf4\ +\x03\x03\xae\xe4'\xef,\x88\xd0v<\x07\xe4\x9b\x7f<\ +\x02\xf0TDA\xaf0F\xc3\xf3\xd9\xd4\x0bQ\xfa\xb6\ +\x11\x00\x00\x98\x9d\xa5o\x17\x8f?kY\xdb\xb5\x02\xe0\ +T\xd9~bYa\x8c\xae\xcdO\xdc6E\x16\xa9\xf8\ +\xc5\xf5\xb8a\x1e\xb3\x80!0\x9c\x01a\x9fH3\x7f\ +)\x00l\xa6\x81m=\x98\x9b\xb8\xfb\xa5\x06\xf5\x14\x0a\ +E\x84\xf9\x03:\xde\xd01K\x144j\x00\x00\x00\x00\ +IEND\xaeB`\x82\ +\x00\x00\x00\x87\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x009IDATX\x85\xed\ +\xce1\x11\x000\x08\x04A&\xdeP\x80\x05\xfc[ \ +\x22\xa0\xdc\xeb\xffg#\x16e\xf5d\xf5l>\xdef\ +|\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\xc0\x07\xe4\xc6\x045\x1a\x89\x95.\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x01\x83\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x015IDATX\x85\xed\ +\x971N\x02Q\x14E\xcfe\x12(\x91\x06\xd70\x1b\ +\x18\x22\xb5\x09\xb4\x1a;V\x81\xb5ZH/\xab\xa0S\ +\x8c\x951\xb16q6\xc0\x1eh\xc0R\x93\x99k\x01\ +\x93 \x82\x85\x99\x89\x85\xff\x96\xef\xbf\xfc{\xf2\xfe/\ +\xde\x85\xff.m\x17\x92[\xf7T\xf39\x90\x00\x07%\ +\xf9,\x81\xd4\xb9n\xd23=\xed\x05\xe8\xdce#\xa4\ +\x0b\xc3\xbb`fx+\xc3]\xd04\xc4\x82\x06\xf2\xe8\ +\xf5$\xba\xfa\x06p4u?\xc7\x8f\x88\xe7\xc8\x1a\xbc\ +\x9cj^\x86y\xa1\xee\xd4\xedL\x9e`\x8e\x9d\xab_\ +L\xa2V4\xe4xhx\xaf\xc2\x1c\xe0\xe5T\xf3\xc8\ +\x1a\x00\x1f\x8a<,\xea\xb5\x8d\x9eD0\xab\xc2|\x13\ +\x02\x98a\x92]\x00\x07e\xbd\xf9O\xf2\xeaC\xb6v\ +\x01\xfc\x89\x02@\x00\x08\x00\x01 \x00\x04\x80\x00\x10\x00\ +6\x01\x96\x82f\xd5\x86Z\xad\xfa\x8b]\x00\xa9!\xee\ +N\xdd\xae\xca|}w\x8cH\xbf\x018\xd7\x8d\xa0\x91\ +\xc9\x93* :\x0f>\xcc\xe4\x09Pw\xa6qQ\xff\ +\x1aL\xee\xb3k\xacK\xe0\x83U0Y\x96a\xbe\x1e\ +{\x0c\xd4\xf7\x06\x93B\xc9\xad{\x8a<\x5c\xaf\xce\xad\ +\xed\xf3_j\x81H\x9di\xbc\x1d\xcd\x82>\x01h\xb1\ +o/|A'>\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x01\x8b\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01=IDATX\x85\xed\ +\x93?/Ca\x14\x87\x9fs[\xc1\xd0\x88o\xd0]\ +b\xbb\xda\xc9b4H+l\xc2f\xf0\x09$\x12:\ +X|\x01\x7f\xd2\xc1\xaa\xf4v1K,\xa2\x9d\xd4\x07\ +\x10,\xc2\xa2\x93\x84\xd4\xfb3PMl\xf7\xbd\xc9]\ +\xdcg;\xc9{~\xe7\xc9\xc9y!##\xe3\xbfc\ +\xb1^KVj\xc9\x01\xbc\x9bM\xdeT\xac\x97T \ +\x88\xf5zg(<*\xbd.5\x94KW\xa0fN\ +\xd8\xf2\xa0|\xcc\xab\x9f\xae\x00\xd0\xa9\xda\xa9\xd0\xee\xa0\ +.E\xae\x9b\xaa\xc0\xb7Dn\x0b\xb8\xf8)\xa7\xcb\xd1\ +\xe7\xbe\xaf@\xbc#\xfcC)r\x1a&\xd9z\xbbb\ +Gq3\xbc60\xa0\xdd\xb5\xe1\x11J\x87aS\xb3\ +\xa9\x0aP37\xde\xb7\xc2o\x98\xe92]\x01\xe0\x05\ +>\x80{\xdf\xfed\x02\x92\x15F\x5c\x1d(\x02\xcf9\ +Y1U\x81r\xe4\xb6\x91\xad\x00o\x98\xcd_-\xda\ +C\xdc\x0c\xef_0\x13i\xd5\xd01\xe0\x84-t\xaa\ +v\xee\x93\xe3\xb5\x81\xb0\xa59Cu\x00a\x1b\xbe\xc3\ +\xbd\x04\xc23M\x05R\x13\xc8\x9b\xb4\xd7\xa9\xda\x81\xef\ +\xf0\xf8\x02\x92\x05\x81\x1a\xc0\x04\xa6\x93\xeb\xdb`3\xc9\ +p\x80|\xdc\x06\x83'\xe0n\xac\x17\xacQ3\x97T\ + ###\xe3\x0bFpb\xa1\x9b\x7fSj\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04\x01\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xb3IDATx\x9c\xed\ +\x99Oh\x5cE\x1c\xc7\xbf\xdf\xd9M\x08\x88'[\xb1\ +\xbc\xbc\x9d\x8d\x8d\xb2g\x15O\xed!\xfe\xa3Z(\x82\ +\x17=\x09\xc6X\xc1\xa3\xa2\xa0\x88\x94zi\x05\xbdV\ +\xb1\xe0I\x10\xa4\xda\x8b\x95B\xa5^-\xf5,\x12\x92\ +}yY\x11\x8d\xa7\x08M6\xfb\xe6\xeba7t\xf7\ +\xbd\xb7d\x93}\xbb\x1b\xe9|N\xcb\xfcf\xe6\xf7\xfd\ +\xce\x9byof\x16\xf0x<\x1e\x8f\xc7\xe3\xf1x<\ +\x1e\x8f\xc7\xe3\xf1\xdc[0]\x10E\x8d\x8fD}(\ +\xe7J$\x1d\x00M@W\x91P\x92\xa11\x09\xc5\xf3\ +\xd6\x06\xe7z\x82\xe9\xda\xf5(n\x01(\x8dM\xdex\ +I\xaa6,w\x17\x98I)9,d\x06\x80\xc0\xc7\ +\xf8\xffO\xfb<\xd4\xf1\xd6Cf\x09\x00@\xbd\xbe\xbe\ +\x00\xea*\x80\xfbS}\x88\xa4\xd3!\x1e\x1e\x01\x86Y\ +_\x9br837\x17\xdeL\xd7\xcf\x1d\x00\x00\x88\xa2\ +\xe8q\xc1\xfc\x08\xe0H\xaa\x89\x00\xb9\x02\xb4\x8e\x02\x83\ +\xac\xa7\x0d\xc2\x9d\xb2\xd6\xde\xee\xd7 \x17k\xedm\x97\ +\x98\x13\x04\xe2\xde\x88\xc8C\xf8\xee`\x9eyb\xcd%\ +\xe6D?\xf3\xc84\xc8a\xb9\xd1\x08\xcb-w\x1d@\ +-\xd5R\x10\xdd\xe4_\x17\x04(\x03e\xbc\xfc\xd6*\ +\x9b\xe7\xe6\x83 \xcemv\xb7\xf5\xde4\x1a\x8d#;\ +-w\x0d\xc0\x13\xdd\xe5\x12@2\x99\xe4 H(1\ +\xe5B\xc0\xad\xe9\xb2y!\x08\x82\x8d\xbd\xda\x0f4\x95\ +\x83 \xd8\xd8\xba3\xf3\x14\x80\x9f\xba\xcbI@Pi\ +\xa0Q,\x1cQ\xc8\x9a\x07pc\xfb\xce\xcc\xd3\x83\x98\ +\x07\xf6\xb1\x96k\xb5\xa3\x9br\xad\xd3 \xbe\xeb.'\ +\x00\x01%\x0d8\x9b\x8a\xa0\x9d\x8b&\x93\x90\xb8\xb2\xd3\ +\xdc:]\xab\x1d\xdd\x1c\xb4\xaf}\x8b\x96T\x8e\xe2\xf5\ +K\x10\x16s\xa2\xae\xfd\x95\x18%\x22\xc0\xec\x83#.\ +\xdbp\xf6l{I\x0e\xce\xbe\xdf\xe6$[6\x9c]\ +\x02\xf0IN4\xef3T$\xb9\xe6\x05\x5c\xb4\xe1\xec\ +\xd2~\xcdw:<8Q\x14\xbf+\xe0BN\xa8\xf0\ +C\x14\xdbS+o\xe7\xfa\x9e\xb5\xe1\xc5!\xfa\x1d\x8e\ +z=~\x1d\xc4\xe7H\x8b#\x1dT\xd0\x9e\x91$\xa4\ +\xb4y\x07\xe1\x8dj5\xbc\xd6\x13\x90\x00\x9a\x9c\ +\xf3\x03\x01\xb9Rv\xc9\xeb\xd7\x9d\xe9\xa9S\x8f\x1c;\ +\xf6\xf7(t\x8e\xecX;?\xff\xd0_;\xcd\xed\x05\ +\x08?\xf7\x04HH\xea\xb9slo\xa7\x955O\xdc\ +\xdcin/\x8c\xca\xfcn\xee\x91\xb2\xba\xba:\x033\ +\xf5\x0d\xa13\xdd\xe5\x9d\xe7\xef:\x22\xf268W\x9d\ +k\xbd<77\xb75J}c9\xc0H*\xaf\xad\ +\xc5_\x0a|u\x90\xfa\x04\xbf\xaaT\x82%\x92\xadQ\ +k\x1b\xcb\xcd\x0e\xc9V\xa5\x12\xbe\x06\xe9\xb3=+\x8b\ +\x9fV*\xc1\xe28\xcc\x03c\xbc\xda\x22\xe9\xac\x0d\xdf\ +\x06\xf9A\xbf:\x02\xdf\xb76x\xa7\xf3\x87\xccxt\ +\x8d+Q7\xab\xd1\xfaYB\x97\xba\x8aD\xe0Mk\ +\xc3/\xc6\xade2\x979\x00V\xa3\xf8\x02\x81E\x00\ +\x09\xc1\xb7\xac\x9d\xfdvRZ<\x1e\x8f\xc7\xe3\xf1x\ +<\x1e\x8f\xc7\xe3\xf1x<\xf7\x12\xff\x01\x83\xc1*\x8b\ +\xb6I\x04\xca\x00\x00\x00\x00IEND\xaeB`\x82\ +\ +\x00\x00\x00\xd3\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x85IDATx\x9c\xed\ +\xd7\xb1\x0d\xc2@\x10\x04\xc0}\xe8\x01Q\x0au :\ + rE\xee\x82\x90\x1e\xe8\xc4\xa2\x07xR\xf4&\xb5\ +\x1e\xd93\xe1\xea\x82\xbd\xcb.\x01\x00\x00\x00\x00`;\ +J\x1b\x9cn\xf5\x5cS\xc7$\x87\x0e}\x964\xe5]\ +\xae\x8fK\xb9\x7f\x87\xbbvj\xa5\xcb'\xc9\xb1\xec\xeb\ +\xd8\x86\xb3\x03l\xcd\xec\x00%eH\xf2\xec\xd0ei\ +S}\x95\xa1w\x09\x00\xe0\x7f\xf8\x05\xda\xa9\x95.\x9f\ +\xf8\x05~\xf3\x0b\x00\x00\x00\x00\x00\x00\xb0\x11\x1f]\xbc\ +$\x0fl\x9f\x83A\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x00\x95\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00GIDATX\x85\xed\ +\xd7\xb1\x0d\x00 \x0c\x03A\x83\xd8)-\x13g\x02\xa4\ +l\x161\x84\xe9\xf8\xefc]\x1b\x89\x8c\x22\xbb\x22\xbb\ +\x9c\x8de\x1a\xb6y\xaf\xe9\x0e\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x00\x80\x9b\xf7\x19\x0d\x9dG\x8e\x8f\xbb\ +\xb2\xd3\x06|\x18c\x85~\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x02\xfc\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\xaeIDATx\x9c\xed\ +\x9a?n\x13A\x14\x87\xbf\xd9\x10\x85&H\x14\xb9\x01\ +\x15%)i\x90\x88-\xa5C\xd8\xa0\x84$\x10\xc9\xb1\ +\xa1\x80\x1b\xd0r\x03\x90\x00\xc7\x05\x7f\x82\x03\xb1\x8dh\ +\xb3>D$.\xc0\x05\x22!\x0a\x8a\x08\xfch\x90p\ +\xc6\xde\x18\xef\xce\xcc\xcel\xfc\xca\xf5\xdb\x9f\xe6\xfb\xb4\ +\x9e\x1d=-\xccjV\xb3:\xcf\xa5\xf2^\x80\xed*\ +Wj\xb7\x84\xe8\x19\xc8w\x89\xa2G\xfd\x83\xd7_\x87\ +\x7f\xbf\x90\xd7\xc2\x5cT\xb9Z_\x13\x91=\x90\x08@\ +\x0d\x06/\x81\xeb\xc3=Q.+sP\xff\xe0O1\ +^\xd2\xfb\x0a) \x01\xfe\xb7(\x9e\xea\xbd\x85\xfb\x0b\ +$\xc1\xa3d\xbd\xdfi}\xd1\xfb\x0b\xb5\x09\x9e\x05\x1f\ +wZ\x07\xe3\xee)\x8c\x804\xf0P\x10\x01i\xe1\xa1\ +\x00\x02\xb2\xc0C\xe0\x02\xb2\xc2C\xc0\x02L\xc0C\xa0\ +\x02L\xc1C\x80\x02L\xc2C`\x02L\xc3C@\x02\ +l\xc0C \x02l\xc1C\x00\x02l\xc2\x83\xe7\x02l\ +\xc3\x83\xc7\x02\x5c\xc0\x83\xa7\x02\x5c\xc1\x83\x87\x02L\xc3\ +\x97\xaa\xb5;\x88z\x01\x80\xa8\x87q\xaf\xf9y\xf8w\ +\xaf&B\xa6\xe1\xcb\xd5\xfa\x1a\xa2\xf6\x81%`\x09%\ +\xaf\xf4\x1eo\x04\xd8\x80\x1f\x937R^\x08p\x04?\ +\x10\xd4c\xbd7w\x01\xae\xe0\x95R\xf7\xfb\xdd\xe6'\ +\xbd?\xd7M\xd0%\xfca\xa7\xb97\xee\x9e\xdc\x04\xf8\ +\x00\x0f9\x09\xf0\x05\x1er\x10\xe0\x13<8\x16\xe0\x1b\ +<8\x14\xe0#<8\x12\xe0\xec=/\xb2\xd5\xef\xb5\ +>L\x93e]\x80\xcf\xf0`Y\x80\xef\xf0`Q@\ +\x08\xf0`I@(\xf0`A@H\xf0`X@h\ +\xf0`P@\x88\xf0`H@\xa8\xf0`\xe0\x1b!W\ +\xf0\xc0f\xbf\xd7jO\x9b\xb7R\xa9\xdfU\xc8s\xc0\ +\xfcL\xd0%|\xdc\xdd\x9d\x1a\xbeT\xd9\xd9TH\x1b\ +\x1b3\xc1\x10\xe0\x817L`L%\xc0w\xf8r\xb5\ +\xbe\xc1(\xbc\x99\x99`\x08\xf0\x22\xf2V\xcf32\x13\ +\x0c\x19>\xf3L\xd0w\xf8\x95\xdb\xb5{J\xa9wz\ +\xde\xa4W\xe7\x7f\x09(*<\xc0\x5c\xca\xc5\xda\x98\xe4\ +l\xc4\xdd\xdd\xfdi\xf3\xb2\xc0\xc3\x84'\xc0%\xfca\ +\xa7\xe9\x1c\x1e\xce8\x09\xfa\x0e_\xaa\xec\xac\x03#\xf0\ +Lyb\x1c\xfb\x04\x04\x02\xff^\xcf#\xc5\x1e2\x22\ +\xe0\xef\xd9\xb9\x8d!\xf8\x84\xbc\xf4\x8f}B\x1e)7\ +\xd0S\x02\x96\x1b\x8d\xf9\xcb\xc7\x83c\x05\x8bC\x97S\ +\xc3'\xe4\xa5\x867\x9d\x07\xdaIp\xf1\xe4dN\xc1\ +\xc2\xd0\xa5L\x9f\xa5\x8c\xc9\xcb\xb4X\xd3y\xa0\xbd\x06\ +\xbf\x1d\x1d\xfd\xbar\xf5\xda\x0f\xe0\xa6\xc0\xcfH\xd8\x8a\ +\xbb\xadN\xdap=\x0f\xd4\x83\xb8\xdb\xfc\xe8K^b\ +\xad\xae>YXn4\xe6}\xcd\xbb\xb1\xbd}\xd1d\ +\xde\xacfu\x8e\xeb\x0f\x00}\xea\x19\xbf\xa0\x8fY\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03\xf4\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xa6IDATX\x85\xe5\ +\x97Oh\x1cU\x18\xc0\x7f\xdf\x9b\xec&Z\x93\x88\x96\ +\x98\x9a\xdd\xc9\xee\xc6\x80\x86=x\x90B\x0f\xf5O)\ +-\x22m\xaa\xa0\x22R\x0bU\xf1\xd0\x9b \xa4x\xe8\ +A\xd1\x80'\xa5(\x88 \x88^\x0d6j\xb5`i\ +OR\x1a(\xc2*\x91m\xb2\x7ff\xb6\xabx\x90\xd8\ +X5\x99y\x9f\x87\x9d]\x93l\xd2d\xd9\x8d\x97~\ +\x97\xf9\xf8\xe6\x9b\xf7\xfb\xbda\xde\xcc\x1b\xb8\xd5CZ\ +i\xbeZ\xa9$c\x81=b\x91\xfd\x82&Q\x12\x08\ +\x06\xa5\x82\xe0\x0b\x5c4\x86\xa9d2\x99\xef\xa8\xc0\xbc\ +\xe7\xed6\x96I\xe0\xb1\xad\xf4+\x5c6\xc8\xc9\xe1\xe1\ +\xc4wm\x09\xcc\xcd\xcd\xf5;N\xfc\x03\x84\xe7\xa2R\ +Ua\x1a\xd1\xb3*2\x1fvuUo\x0bC\x1b\x86\ +\xe1\xa0\xaa\x93R\xd1\x03\x02\xe3\xc0p\xd4\xff\xb5\x0d\x97\ +\x8fg2\x99_[\x16\xf0<\xef\xbe\xd0\xea\x19\x90\x07\ +\x80\xaa\xc0)\xd7M|,\x22\xc1\xcd\xa4U\xd5\x14=\ +\xefYQy\x13\xc8 \x94m \x873\x99\xc4\x0f[\ +\x16(\x95J\x19\xc5\x5c\x02v\x0a|\xb1\xb4\xf4\xf7\x0b\ +\xa3\xa3\xa3\x7f\xdc\x0c\xbc6\xf2\xf9|w\xac\xbb\xe7}\ +\x94\xe3\xc0\x9f\xa8\xd9\x9bJ\x0d]\xd9T \x9f\xcf\xf7\ +\xc5\xe2=\xdf\x03c\x0a\xef\xa6\xdc\xc4\xab\x22b[\x81\ +\xd7CU\xa5X\xaeL\x08\xfa\x16\xe0\xa3\xe1\xeeT*\ +U]\xd9c\xd6^\x14\x8b\xf7\x9c\xae\xc1u\xba\x1d8\ +\x80\x88h\xca\x1d\x9a\x04>\x02\x12\x88\xf3\xa9\xaa\xae\x9a\ +\xf4*\x81r\xb9\xfc\x10p\x14\xe57\x1b,\x1fm\x07\ +\xbeRb\xf1\xfa\xc2\x09`\x16\xd8W*\xf9\x8fo(\ +`\x95\xb7k\x17\xf1\xc6\xc8\xc8\xc8B\xbb\xf0zd\xb3\ +\xd9%\x94\xd7\x01T\x98\x5cy\x17\x1aI\xb1X\xdc\x85\ +8\x15\xe0\xf7\xc5\xeb\x0b\xbb\xb2\xd9\xecR\xa7\x04\xa0\xf6\ +<\x94\xca\xfeO\xc0\xfd6\x94\x07\xeb\xab\xa2q\x07D\ +\x9cC\x91\xd0W\x9d\x86\xd7\xc6\x17U8\x03 \x8e>\ +Y\xaf7\x04Ty\xb4\x96\xf0M\xa7\xe1\x0d\x09\x95o\ +\xa3t_\x93\x00\x22\xc9()l\x97\x80\xea\xf2<\x80\ +@\xa2Y *\xaa.W\xd9\xa6\x08\x82\xa0>\xf6P\ +\xfdAlz\x0f\xfc\x8f\xb1V\xc0Vj\xc7\xd8\xe0v\ +\x11\x1dgG4\xb6\x5c\xab\xbfc\xfe\x13P\xe3\xd5\xba\ +lz\xbb\x04\x8c\xb1\x99(\xf5\x1b\xb5\x06_\xb8\x00`\ +\x94\x83\xdb% \xa2\x07\x00\x14=\xdf$\xe0\x88\x9d\xae\ +\x9d\x94'fffb\x9d\x86\xab\xaa(\x1c\x06\xc0\xca\ +T\x93\x80\xeb\xba\xd7\x80\xf3\xc0\xce\xbb\x07\x06^\xea\xb4\ +\x80\xe7y\x87\x801\xe0\xc7Tj\xa8\xb17X\xb5\x0a\ +\x8c\xe8\x04\x80\xa89\x95\xcf\xe7\xfb:\x05\xcf\xe5rq\ +\xabR\xfb\xce`N\x8a\x88\xae+\xe0\xba\xeee\xe03\ +\xd0{\xe2\xf1\x9eOT\xb5\xede\xaa\xaa\xd2\xdb\xdb\xf7\ +\x1e0\x86p\xc1u\xef\xfdr\xe5\xf9&@\x18,\x9d\ +\x00f\x15\xc6K\xa5\xca;\xedH\xa8\xaa\x94\xcb\xfek\ +\x8a\xbc\x02\x5c3\xe8\xf3+g\x0f\x1bl\xc9j\xfbA\ +.\x01w!|~{O\xf7\xb1\x81\x81\x81\xc5V\xe0\ +\xb9\x5c.~Go\xffi\xe0e\xe0\x86\x11}\xc4u\ +\xdd\x99\xb5}\xeb\xce.\x99L^\x0d\x1d\xd9\x03\xfc\x8c\ +\xf2\xd4\x8d\xbf\xfe\x99-\x16\xbd\x17U\xb5k3\xb0\xaa\ +\x9aR\xc9\x7ffGo\x7f.\x82\xfb\xa8\xb3w=8\ +l\xb2-/\x14\x0awb\x9c\x0f\x05y:*\xf9\xa8\ +L\x8b\xc8Y\x08\xe6\x8d1\xd5 \x08,\xc4\x07q\xc2\ +a\xb1\x1cDd\x1c\xc8D\x83\x9f\xb368\x96N\xa7\ +\x7f\xd9\x88\xb1\xa5\x1f\x93b\xd1\xdf#\xa2\x93\x0a\x0fo\ +\xa5\x1f\xb8bE'2\xae{n\xb3\xc6\x96~\xcd\x0a\ +\x85B\x0a\x13;\x22\xe8~\x94$B\x02p\x00_\xc0\ +\xb7\xc8E\xacL\xa5\xd3C\xb3\xad\x8c{k\xc7\xbf\xc1\ +\x7fl\x10\x0e\xdc\xa9\xdc\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x03^\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x10IDATx\x9c\xed\ +\x9bMO\x13Q\x14\x86\xdfS\xd1!t\xa9\x84\x0f\xf7\ +n\xb0\xdd\xb4\xc4\x8d\xfe\x0b\xc1HR\xdc\x98V\x89\xad\ +\xb20\x81_\xa0\x09\x0bM[#\xedNI4\x01\xfe\ +\x05\xee\xa4\x1b\x0a+\xd7\x14It\x092\x0a}]\xb4\ +\x94afJ+2=m\xb8\xcfj:\xe7N\xf2\xde\ +'\xf7\xf6n\xee\x01\x0c\x06\xc3eF\xda\x19\x14M,\ +\x84\xad\x81\xfeI\x02\xf7\x01\xde\x060\x0a\xa0/\xd8h\ +\xff\xcc!\x80\x0a \x9b\x02\xac\xda\xfb\x07\xcb\x1bK/\ +\xf7Z}\xd4B\x00%\x96\xccN\x8b\xc8+\x00#\x17\ +\x93\xb3c\xec\x00\x98[/\xa4\x97\x00a\xb3AM\x05\ +\xc4\x92\x85\xab\x02;\x07A*\x90x\x9d\x82(\x10V\ +\xbaTL\xfd\xf1+7Y\xc6\x14\x91|\x1e@\xd2U\ +(\x8b\xe0\x0b\x88\xefU\xa0z\xb1I\xff\x8f\x10\x10\x82\ +`\x98\xc4]\x00\x91FA\x90\x12\xda\x00\xf8\xd4o%\ +\xf8\xae\x80x*;\x0d\xe0\x83\xe3\xd5OR2\xa5\xe2\ +\xb3\xcfg-\xa7\xee\x80\x12K\xe6\x1f\x8a0\x0b\xe0\xba\ +\xa3\xf0h\xbd\x90\xf9\xe8\x1e\xed\x11\x10M,\x84\xaf\x0d\ +X\xdfp\xb2\xe7\x7f\x90G\xd1Rqv'\x98\xc0\xc1\ +\x10K\xbe\x19\x11\xb9\xb2\x01\xe0\x06\x00\x80\xa8\xfc\xfee\ +\xdfr\xff1\x86\xdc\x1fZ\x03\xfd\x93p\xfc\xe1\x91\xf2\ +\xbc\xd7&\x0f\x00\xa5\xe2\xec\x8e\x08^4^\x08F\xad\ +\xb05\xe1\x1e\xe7\x11P;\xea\x1a\x94k\xcb\xbe7\xf9\ +\xba\x98\xfe\x04\xa0|\xfc\x9b\x94\xd6\x02\xea\xe7|\xed\x09\ +\x5c\xeb\xfe=\x7f\x16\xc2\xda\x1c\xea\x90c\xee\x11>\x02\ +0zR\x94\xdd`\x82u\x8eSs\x10\xdc\xf4\xd6\xbd\ +4\x8e\xc6n;\xea\xce\x83k\x0e\x9ec\xdfO\xc0\xa5\ +\xc2\x08\xd0\x0e\xa0\x8d\x11\xa0\x1d@\x1b#@;\x806\ +F\x80v\x00m\x8c\x00\xed\x00\xda\x18\x01\xda\x01\xb41\ +\x02\xb4\x03hc\x04h\x07\xd0\xc6\x08\xd0\x0e\xa0\x8d\x11\ +\xa0\x1d@\x1b#@;\x806F\x80v\x00m\x8c\x00\ +\xed\x00\xda\x18\x01\xda\x01\xb41\x02\xb4\x03hc\x04h\ +\x07\xd0\xc6\x08\xd0\x0e\xa0\x8d\x9f\x80CG\xb1\xe7\x05\xb9\ +\xe6p\xe8S\xf7P9~\xa8\x82CA\x84\xea$\xa7\ +\xe6@l\xbb\xeb>\x02d\xb3\xf1\x04\xb9\x07\xb0\xad\x9e\ +\x82\xee\x84R\x9bC\x1d\x91-\xf7\x08\x8f\x00\x01V\x1d\ +?#\xe3\xa9\xfcd0\xe1\x82'\xfe$\xfb\x00\x8e\x9b\ +\xe3\x22\x5cq\x8f\xf1\x08\xb0\xf7\x0f\x96Qk6\x00\x00\ +P\x98\xbb\xf3\xf8m\xcfm\x85\xf1\x99w\xc3\x80d\x1b\ +/\x88\x8a\xbdg\xb7\x16P\xbfM=\xe7\xf8p\xf0\xa8\ +/T\x8e%sS\xbd\xb1\x1d(\xb1dn\x8a\xd5\xa3\ +\x0d\x10\x83\x8d\xd7\x82y\xbf\x16\x9a&\x13\xa2\xc4\x93\xb9\ +\xf7>\xdd\x22e\x82k!\xc8n\xb7\xdd\x22\x0d\x01\xa1\ +*8T\xdf\xf3\x91\xd3U.\xae\x1723~\xf7\x9e\ +\x9bt\x8c\x08\x89BZh\xc3%!\x22\x90\x08\xd1f\ +\xb7U\x07\xa9e\xf2K\xc5E\xb2?\xd3\xec\xd2w\xcb\ +\xa6\xa9x*\x97\x00\xf0\x1a\xbd\xd64ET \x98?\ +w\xd3\x94\x93hb!l\x85\xad\x09R&@\x8e\xd5\ +o]w_\xdb\x1c\xb1\x0d\x91-\x11\xae\xd8{\xf6J\ +;ms\x06\x83\xe1r\xf3\x17\xf4\xb0\xe5&a\x1e\x11\ +E\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x01\xb2\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01dIDATX\x85\xe5\ +\xd6\xb1J\x031\x1c\xc7\xf1or\x97\xfa\x06V\x90j\ +)]\xaa\x93\x93s\xeb\x03\x08\xfa\xa4\xe2R\x10\xda\x87\ +P\xebRn\x13\xd4\xc9\xfd\xae\xf7w\x90\x13\xda^\xbd\ +$M\xce\xc1\x8c\xc9\x1f>?\x92?\x7f\x02\xff}\xa9\ +6\xb1,\xcb\xbaZ\x9b;4\xaf\xfd\x93\xde-\x80n\ +\x15O\xd29\x8aKJ\x8e\xab\xfd\xb4U\x1c5\x02y\ +)\xcb\xe2\xba:\x8b\xfe\x04[\xf8\xaa\x18\x0f\x06\x83\xf7\ +V\x024\xe1Q\x03\xd8\xe0\xd1\x02\xd8\xe2Q\x02\xb8\xe0\ +\xc1\x03\xb8\xe2A\x03\xf8\xe0\xc1\x02\xd8\xe2\xcb\xe5\xdba\ +j\xf2)\xf0\xd9?\xedM \xc0$t\xc4g\xc0\x05\ +H\xa7\xda\xdf+\x80\x07~\x0e<\x15y\xe7\xa6:\xf3\ +~\x02\x7f\xdc\x5c\x0d\x87G\x1f{\x05\x08\x85{\x05p\ +\xc4\xe7\xc0\x19\xf0\x5c\xe4f\xb2\x89;\x07\x08\x8d;\x05\ +\x88\x81\x03$!\xf1,\xcb\xbaI\x8a5\x0e\x167\xe0\ +\x82\xeb\xc4\xcc\x5c\xf0\xc6\x00\x9e\xf8\xa2\xc8\xcd\xb8\x0ew\ +\x9a\x84\x91\xf0\xadIX\xfb'\x8c\x84W\xbd\xb16\x09\ +\xb7\x9a\xd0\x0dO\xe7\xa0~\xc5k\x1asm\x18\xe9\xcd\ +bG|\x04,\xcaU^\xdbp6\x8d\xa9\xd6\x8b\xfd\ +p\x9b\xba]7\xa4\x01DD\xab\xc4<4\xe1\x22\xa2\ +Tb\xee\x9b\xf0\xcd\xba]\xf8O\x00\x00%\x1c\x08<\ +6\xfcd\x94Rt\xbe\xeb\xea\xf1\xba:\x9by\x80\x88\ +h\x11i\x1cL\x22\xa2B\xd6\xfd\xf9\xfa\x02SB\xe8\ +\x88a\x1aN\x81\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x00\xc0\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00rIDATx\x9c\xed\ +\xd0\xb1\x09\x83`\x14\x04\xe0\xd3!\xc4&\xe0LY\xc1\ +\xca\x89\xdc$\xf3\x08i\xc4!4\xad\xf8\xd7*\xc4\xef\ ++\x8fW\xdc\xbb\x04\x00\x00\x00\x00\x00\x00x\x82\xea\x18\ +L\xd3\xf7\x9d*c\x92\xe6\x86>g\x9a\xb3\xa5\xef\xba\ +\xd7g\x1f\xd6\xc5\xd9\x7f>\x9f$m\xea\x8c\xc7\xb0\x1c\ +\xe0a\xca\x01\xb6\x0cI\x96\xeb\xab\x9cn\xce\x9a\xe1\xee\ +\x12\x00\x00\x00\x00\x00\x00\x00\xc0\xf5~Z\x95\x0d\x08\xf2\ +\x12[\xad\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x1d\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xcfIDATX\x85\xed\ +\xd6=\x8bSA\x18\xc5\xf1\xff\x99D\xf1\x05_:A\ +\x1b\x11+\x0b\xb51a\x11KI\xb3\xb2Ye\xd7F\ +\xd0\xd6B\xf6\x13\x88,~\x01Q\xb0\x16\xb1\x90\x15\xcd\ +.\x04q\xb1\x14\x89I\xa5\x16V\x16k#\xd8(\x8b\ +\xf8\x82&s,\xe6F,s\x930\x16\xfa\x14\x97[\ +\xcc\xcc\xf9\xcd\xdcg\xe0\xc2\xbf^\x1aeP\xad\x15?\ +\xc9(\xf4u\xa8\xb3\xa8\x8f\xd3\x04\x84Q\x06\xc9\xec\x05\ +\xf6\xc4\xaa\xdbG\xd7\xbd3;\xe0\x8f\x9a\xd9\xfe\xd5\x0f\ +\x8f\xacx\xeb_\x018=\x1a\xbb\xb6\xc4\xbb\x0b+\xae\ +d\x07`\x22\xc2X\xe7\xdfU\xe2-\xec\x91zhj\ +\x00\x09cl\x83\xa4\xcb\xf5\xd5\xb8\x9c\x15P\x94\x81\x98\ +\xdet\xb5\xde\xf2Rn\x00\x12\xf6o\x84o\xd4[\xbe\ +\x90\x15\x00 \xb0\xd1\x10q\xa7\xf6\xc8\xb3Y\x01\x09a\ +\x1b\x1b\xa8\x08?\xa8\xad\xfaTV@B(\x92\x10\xdb\ +\x14\xdd>\xd1\xf2\xf1\xac\x80\x82\x11\x9d\x9asw\xb0\x9f\ +\xcc\xac\xf9pf\x00(5\xa5\x81}q\xe0\xa7'\xd7\ +\xbc?+\xa0P\xc4\xf458\xd8\x1f\xf8q~@B\ +\x0c\xebX~\x80\x09\x85`\xa3Z\xd1\x81\xac\x00\x8b@\ +J\xff\x10*:\xfd|N\xef3\x02\x1cd\x04l\x1a\ +5:sz;\xea\xcc\xea\xc4\xd18\x08\x09\xf8\xee\xa0\ +3\xbd\xa6^\x95\x99?\xd1\x09\xd8R\x11>0Z\xe8\ +5\xf5\xac\xec\x1ac\x9f\x80\x8d$\xa7\x0dH\x97z\xf3\ +j\x8f\xb3\xce\xb8' \xa5\xa6Ch\xa9;\xaf{c\ +\xaeS\x1e`#\x18\xee\xdc\xd7_\x9c\xd5\xcdq\xc3K\ +\x03\x9c~\x05\xd2]\x97ow\x9b\xe1\xda$\xe1\xa5\x01\ +\xc2!\xf5\x9c\xefw_\x86+H\xce\x0aH;g\xfd\ +s?\x5cd\xb9\xf8\x19\x99\xb0\xca\xde\x82\xce\xb7\x1d:\ +\xf7\xa6\xa1\x1f\xd3\x08/\x03\xd8DV\xf8\x19f_7\ +\xf4eZ\xe1\xff\x0b\xe0\x17\x0f\x9e\xa4@\x97\xf1\x9c\xea\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x011\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xe3IDATx\x9c\xed\ +\xd0\xb1\x11\x82@\x18\x05\xe1\xf7[\x04\xb5X\x07-\x18\ +Y\x91]P\x87u\x10Y\x05\x18\xa0\x99Fw\xb0\xce\ +\xb8_t\xc1\x0d\xbc\xdbD\xd2?\xab\xbd\x7fp\x9e\xd6\ +q\xcdz\xdb~V\xd7\xfbXS\xcf\xfb\xadN{~\ +\xeb\xdb\xfa\xbe\x1d\x8f\xa3\x0a4\x81\x8a\xef?\xf74\ +T\xfd\xf7%p\x04\x97\xa7P9\xf2mS\xa8 \x9d\ +\x9f\xff\xc4\xff\x9f\xf2m\x0eh\x01\xa7\xbe})\xe8{\ +\x01\xeeq1o\x85R\x92-\x90\x09\x90\x8f@V\x8d\ +1k \x0bF\xfb\x06\xc8\xbc\xff=\x05r\x0f\xe4\xae\ +\xff\xcc\x80\xdc\x01\x19\xb2#\xa4\xee\xc7,\xa8\xe0\xe5\xae\ +\xc71\xe1\xfb\xe7@6\xf3GU\x9a\x05\xed\x1b \xbf\ +\x06)_\xf3\x88\xcb\x04\xc8\x9f\xf5\xc1\x5c\xdf6H\xc5\ +h\x7f\xdb?\xb7\xe2'[\x8e\xf0\xdd\x1bsr<\xe3\ +%\xff\xdbyF\xb6\xa0uK\xdb\xe5-\x83\xd92\xc8\ +O\x8c\xf6\x09\x90?\xda\xbc\x14\x13\xf0\x91\x7f0\x92\x9a\ +\xac\x170\x7f\xc7\x7f\xb6\xed\x15\x96\xedkLN`\xa2\ +\xe2\xf6Y\x15N{I\xe7\xcb\xf5\x97\xb3\xcf\xa5\xbb\xb9\ +\x02\xf2\xabq'\xdf\x1el\xfbPc\xca\x14\xc8mc\ +\xfc*\xc8\x07\xba}M|\xf3^y^\x13dV\xb7\ +\xbc\xd97\x07\xf2\x00d\xd1\xe8k\xfag#\xcb&\x9b\ +\xfa\xc9\x82q&\xe4\x17\xe0>\x0d\xfe'\xca\xa3\x07\xec\ +\x01!\xa3\xabpy\x0b*_\x0e\xe1d\x0dxZ\xd0\ +\x97\xda\xe1\x1b<\x0b\xf0\x00\xbaO\xa0\xf6*h\xeb(\ +]\x94\xc9)\xbc\x987\x980\x90\xc6\xc44P\xe6\x1f\ +\xa0Z\xbd\xed\xc7l\x01/T\xa1\x0f\x05\xf1\xc4,\xf9\ +\xff\x89\xe9J4x\xd8F\xd0\xf6\xc2\xa0%\x86\x17 \ +\x822\xbc\xe7\x9f]\x02~\x06|\x0e\xcc\xa0\x16\x22\x81\ +\x9c\xd9\x8c\x04 \x0d\xd4\xcc$\xff7\x806\xb8]?\ +Q\x055]\x9b\xc0\xd7\xe0\xae\xf4|\xb9\x13r \xce\ +\x8f\x9bB}\x81oG\x98\x9f\xf8\xd9E`\x1a5\xa9\ +{\xf6\xb3\xd2\x86\xfa\x0b\xd4\x9fX\x01~\x00\x16\x80\xcf\ +\x80\xe7\x80\xb7<\xec\xf8\xe7{\xaa\xdb\xdcU\xd1\xc4[\ +\x03\xf3&[Y\xcd)\x1b^\x0f|\x1c)F\xcbL\ +.\xa1\xa6rF?7\x05Y\xf5\xcax=kU\xd2\ +\xfe\x99\x81~\x91\x09\x90\xdfx+\x11\xb6\x07\x8aQ\xee\ +\xaa\x8e\x18@\xc9\x98\xb5\xaf\x13\xb2\x0b\xae\x17\x8d]\x03\ +\xfe\x0e\xdc\x09\x84\x10\xac\xccaS\x19\xe7\x10\xdcS\xdf\ +7\xe6\xaa\x9b\xe0\x9fuO\x80\x03\xc5}\xd8\xcc\xf7\x8b\ +\x03\xd6\x81\xbf\x01\xf7\xb2s\xba\x9e\xf2\x22\xeb\x18G\xc0\ +\x12\xc0\x14p\x161\x0fz\xe6\xbf\xf3[\xe91Y!\ +\xa0\x1a\xb9\xd9W\xc6\xdd\xe5\xf8<\x8e\x0b\xeeRq7\ +\xfb\xd1n\x08=\xbc\x1e\xf0\x04=z\xe1\x90\x1e\xea)\ +N\xc7X-%8\xe7W/\x00\xd9F\x95L)0\ +w\x07\xc0}\xe0\xd2\x9b\xabW\xe8\xee\x09M\x9e\x9f\xd0\ +\xdc\x04%\xe8\xfa\xe3V;\xc4\xf6\xf7\xa7\x81.Hx\ +f\xfb:V\xee\x03G\xe8\xca\x7f\xadc\x05\xa0\x03\x9d\ +\x13\xa8/\x92\xd1g\xee\x08\xe4\xa7\xf1\x04cX\x01y\ +\x0b.*P\x9dF\x15\xd3)\x83\xad\xbd\x0b\xfc\x0e\xf8\ +K\x01\x03\x01t\xe6\xa1\x9e\x04?>N\xa8\x1d\xf9\xce\ +y\xd4R\xf8\x1d\xd59\x87\xfa\xe1\x10d]\xd4<\xfe\ +\x06\xf8$\xa0\xd9+\xcfz\x0d\xb8\x0dr\x1e-fn\ +%b\x01\xc4\xd1\xe1]`\x1a&\x1f\xaa\x12t\xfb\xd9\ +\xe1\xb2\x0e\xfc\x03\x0dp\x8c C\x80\xeem\xa8M@\ +\xfd%\xb8N\x01CG\xd9\xbfR\x07\x16\xe0\xa2\x06\xd5\ +\x93\xbc\xd6N}\x93\xbf\x02k\xe0\xf6\x82\xce6\xc8\x09\ +\xbac\xdf\xf6\x9ekB[\x9f\xe8\xd8\xc7:\xa0\x0a\x9c\ +\xfb\x09\xee\xa1\xab\xf2\x85M\xb3,\xa1\xdb\xbe\x87\xad\x13\ +\xa6\x81U\xa8\xb5U\x89\x152o\x80\xeb\xe83\xd5\xb6\ +2\x18\x1e\xab0\xaa\xa3\x87\xfa\x02+\x05\x88\xbe\xf1c\ +\xee\xf9\xe7:d\x1d\xb9\x22+\xc0\x06\xf0\x0c\xf5\x01\x8c\ +\x03|\xd8\x04\xba\xe0\xba\x9e\xe0H1\x1e\xcdC\xbb\x86\ +\xae\xc2\xf9X<\xdbp\x01<\x85\xf6$\x1c/`\x87\ +\xb4]\xe0L\xe7\x8c\xc1\x9d\xa1\x8b\xfa\x83\xe7)\xc7\x8b\ +%\x80\x06\xea=-\xe6\xb7|\x02\xcd)p\xadl[\ +\x22\x84\xcb\xf7a\xae\x07\xb3\xaf\xccGo\x04\xb3\xaf`\ +\xf6Rq[G\xcd\xb5`\xae \x16a\x075\xdf-\ +\xd4\xc2e\xc0\x12\xc04\xaa=\x0b\x94\x9a,\xa3n\xaa\ +\x01\xc7M\xa8|\x0f\xcc3~\xec=\x06\x88\x03\x16\xa0\ +\xf2\x9d\xcea\xc2s\xdbYr\x97@\x19\xdc1\xba\xb8\ +\x19\xb0\x04 \xa8i\xd9) d\xc2\xb6\xf32\x05\xa5\ +d\x22\x7f\x1c\xac`\xeb\xda\x10n\xfb\x16\x94J^\xbf\ +\xc4\xc3\xae\x946\xb1x:\xd4#4\xda\x0a\x94\x07\x83\ +L\xbf}\x13\xd5\xb2\xe1*\xcc\x82t\x81\x15\x98\xd9\x0f\ +\xfaZ\xc0\xbb\xc0\x13\xd2\x8cN\x06\x92\xd4\x19\xa8Oa\ +\xe5\x05\xe7\xd0@\xe7\x07\xfd-\xa0;s\x03\xe4\x19\x03\ +?#\xc1\x7f\xa6}\x1cd\xd1\xb8c\xef\x0e'\x81Y\ +\x0a1a5rIH\x99G\x83\x8deOd\x84\x9c\ +\x1etf\xa1~\x00\xc4A\xc6#O\xd0\xd7\xc1\xe4+\ +@\x1f:gP\xdf\x05\x1ctoA-\xc9/>\xf3\ +\xdf\xce\xcf\xf9\x05\x9a+\x0c\xe1\x15tf\xa0\x9e\x08-\ +\x9c\xb7\x89*\xbe\xbe\xee\x86TW%y\xcbL\xc2\xc6\ +Z\x99E\xe0K\x90\xaa'\xe0%\xb8C4\xd3s\x96\ +\x8f\xfc\xa4\x01\xf52\xb8\xe7yT\x82g~\x018F\ +W\xec\x1bcw\xb5\xfd\xf82\xba\xe2\x07\x9e\x8e\xffh\ +_.z;\xf1\xa6\xcfg\x7fC\x9ad\x1f\x15\x98\x17\ +\x9al\x02O\xe0\xa4\x03\x8d)\xb2\xe1\xb1\xa9\x03J\xa8\ +\x04o\x83\xdb\x09\xec\xf7-l\xe57\x0dG\x05ih\ +\xa5\x00\xcd\xf4n\x01O\x87\x87\xc4\xa9/\x7f\x1f\x0dg\ +\x87\x05R'\x18\xbe\xbd_\x08\x9f\xb9r'\xa8\xb7\xba\ +\x01\x8d\x03\xf4He\xa0H\x09.\xe5\xe3\x01( \xbe\ +\x01\xf3GF{\x02e%\xb4\xf2\x90\x9c\xb3\x94\x9b:\ +Qx\x9fa\xdf?\x84\xb4\x14\x08 7N|j|\ +\xcd\xea\xb5\x04\xb0\x00X\xf6\xdf\xba\x84\x18\x07V\x18$\ +4\x0c\x8f1\x81\x9c\x93\xf3\x12.\x8c\xd4{\x06\x8a\x84\ +i\xd1\xfa\x0aC`\x05G\xe0Z\xe1\xec(\xc1\xf4\x07\ +;\xa70\x946<<\xd7\x85\xea\xa8|\xdb5r\x0d\ +\xee\x0cU\xe6\x19\x88\x050AqTw\x13\x9b^\x83\ +nd\xdeb!\x0c\xbd\xb1\xb9\xa9\x1fQ\xf4\x5c\xae=\ +\xb6\x02\xcbpei\xf3\xc0?\xc8\xb4\x97\xec\xf6\x14\x9a\ +P{f\xd0! \x8f\xd1$\x0b\xc0\xa3\x02\xfd2b\ +\x85\xbb}\x8d4s\xd0\xc3\xce\xd6\x8e\x8a\x05z\x15\x98\ +\xb8\xce\xf6O\xecu\x11\xf4G\xf4\xbf&\xd4\x1c\xc5G\ +p\xacy#\x01\x94\x9f\xa1\xf67\xc6\xd5\xb3\x11\x8e\xcc\ +\xf2\x1e\x90\x9a\xa4\x10\xd2m\xff\xc8\x7fFX\x87B(\ +\x12@\x19\xdb\xb3\xcc\xcd\x11\xeb\x80.Q\xbc\x1c@\x11\ +\xb3\xc3\x08\xbf\xca\xcf\x11\x9f\xf9Q\xd6a(\x14\x8d\x1f\ +[9\xc6\x02Hr\xe79my\x03\x22\x12\xe8\x93\xde\ +'\x16)\x83\x9d\xf3Ib\x01t|\xdb2z\x1e\xd1\ +\x0b\x05\x8e<\xbd\x02\xecg\xb7\xb1\xa0\xb9CY\xcf\xe6\ +\x10\xd3s\xf7Op\xed`\x8e\x82<\xa3\x05\x02\x9a8\ +\xd9\x8d\xe6\x5c\xd3`-a<\x09\x87\xc5\xa1\xbb\xfa8\ +\xdb\x0e\x0c\x0a\xb62\xd9\xe9\xf8\x08\x84W\xd7\x16\xec\xa1\ +\xc1\x8d\x05\xcf\xc8\x14V\xe0oe_\xfbn0\xb6\x0e\ ++\x14\xe6$\x93\xc0\xcb\x84\xe4:>\xa38\x8b\x94\xe0\ +\x85m\x0a]_\x89\xb2\xeam\xdc\x15\xd0\xf2g0\xc9\ +\xdb\xbf\x0e\xf3\x09\x04Bh\xddF\x13$VN\xb2\x1c\ +\xd0\x18\xf7-\xa3\xd6h,%\xd8F\xed\xa5\x19?\xfb\ +mnd_\x018\x83\xc62\x9c\x9c\x8d\xe1%^\x03\ +\x9c(\xce\x99\x15\x06ew1,S|\xbc\x92\x1a\x85\ +\x9cY\xb5\x04p\x86*\x97rA\x86\x158\xee\x90\xbb\ +\xf7O\xb7\xfdW\xd08\xd3s\xfac\x81\xac*N\xbe\ +\xc2\xf4\x18\xa5\x01\xad\xae-t\x99\x83\xb3.\xcaSN\ +xE\xf9\x80\xc4f\xbem\x13\xd4\xab8\ +\x92\xeaO\xd3m\x9e\x04fa.N\xd6&\xb0\x02S\ +\xd3\x01O\x19\x88\x05pA\x9a4p\xdet\xc9\xba\x8d\ +\xd7\xed+rJ\xd8\xee\xed\x15\xb0\x07\xf5KU\x5c\xb2\ +8\x9e\xaf/\xce\x8f]\x81I\x8f#<\xf3\xa1\x10(\ +\x01\xabv\xfa\x0e\xd44_T\xc0}\xeb\x1b\xeaDV\ + 6\x83\xf1\x95\xd3'h9\x1a\xc02Z'\xd4\x0f\ +\xc6]\x02\xbfE\xaf\xc7\x97\x0d\x9d\x97\xa4\xa0N\xd1\xf8\ +\xfc=/\x84a\x89\x0f!\xad5\xa0\x81\xba\xd1VM\ +\xcf%\xf0{\xe0S\x06\x97\xa3\x89\x19L\xcak'\xf5\ +f;\x85\x12\xc3\xddg\xd9B\x0b\x0f\xc2\xb6\x86\xf7\x08\ +7\xa2\xf6\xa4\x0eo\xcd\x7f\x1bVC\x1a\xdc\xa8F0\ +}~\x05\xf3RE\xaah\x09\xed\x1c\xc8\xbb\xb6N\x90\ +\xf7\xf3\xd6J>d\x8c\x1a\xa1C\x90 #\xebN\xe0\ +\xa4\xab\xf5\x80)\xa2\xf0\x8a\xba\x0f\xee\x11\xea%\xbe\x06\ +\xb3\xe3\x82\xcc\xa0)\xfb\xef\xd1\xcc\xcf\x0ey\xc5\xb8\x81\ +\xa6\xe0\xc3\x0b\x9e\xe4n\x22\x03\x96\x00\xba@\x95LI\ +\xec\xcc\x0b\xa8Lz\xc9\x16\x85\xb4\xfb\xd0\xaa\xaa\xce\xb8\ +V]\xee\x98 e\xc5\xdd\xaa\x90\xaf\xfa\x08\x14c{\ +\x11\xba\x1d2\x1a_*\xa8n\xcb\xd5(X\xb1@\x09\ +\xdc\x9enyy\x16(\xa0\xa7\xa8F\xee\x01\xff\x0d\x98\ +\x0f$?w\xe0\x05\x94\x84\xbf\xa1\x0b|\x13H\xbc\xbf\ +U\x94\xd1\xa70'Q\xbf\x049\xc6\xfb\xd0h\x91\xb9\ +\xbe\x93\x8a\xd2\xe3v@\xee\x1a\xccf\xe0%i.\xc0\ +\xed\xa2u6\xc9\xd6\x17T\xf1T\xc8f\x8d\x22\x1cN\ +T\x80\xec\xa3\xb5?\xf7\xc6\x08\x97\x0dh\xddF\x9d\x9b\ +%\xe0\xb9\xee\xb0\x9c\x9d\x9f&]\xd5\xe3&\xba\xeae\ +Tyv\xd0\xda\xe6%e\x1e\xd0\xcb\xd8\x8c3\x14\xed\ +\x00w\x9a\x0dW\xdd\x1eZ\xc3\xbf\x81Ff\x9f\xa3B\ +x\x00\xe7'P=R\x22\x0b\xcd[_\xe7h$\x15\ +\x9bI\x1b\x80\x83\x0b\xbf\xbb\xaa\xc9\x0b\x14!\x1c{f\ +\xbc\xa93\x1d\xcbe\xc5/K\x1eo\x12#|\x00<\ +\x04\x0e\xc0\xbd\x0c\xc6\x97\xe3{F\xeb\x08\xc4\xcct=\ +!\x0f\xd1\x82E\xd0+\xefe\xdf\xbe\x1f\xb4\x1b b\ +\xf7\x8b\x83\xea\xa4g\xb0S\xe0\xc5\xad\x8f\xc0}\x05L\ +\xc1\xd1\xf7\xd9\xeb9q\x9e\xb6\xf8\xcc\x8f\x93B\x93;\ +\x03\xe7'S._\xcfZ\x07\xf0f\xe8}\xecDI\ +2\xe6\xffP.\x0f\xba\x00\xf2\xf3\xbc\xf9\x95\xa6Z\x8a\ +\x5c\xb9\xfc\x1d\xcc\xb2^\x1b\xf9\xc7\xd8/L\xac\x92{\ +aB\x1c\xfa\x82\x85\xf1\x02C:f{\xcc\x89C\x9c\ +\x05\xcf\x88C\xdf\x18\xf9\xa5\xd1W\xce\xfa+\xa9\x10\xaa\ +\x8c\xff\xc2D\x8a\xe8O\x05N\xc8F^\x08\x00\xf2\x1e\ +\xfa\xcaJ\xee\xa5\x04^\xeb\x95\x99\xb4\xad\xe4\x9d\x9f\xb7\ +@\xde1\x9c\x9f\xb2\xa5\xe5=\xf3\x7f\xc8\xe3+\x9e<\ +\x91ZY\xa5\x16{\x80\xe0w\x82q}-\x1b~k\ +\xde\xd3O+t\x9e*\x8c~ij\xca\x8f\x09\x04/\ ++\x0c^\xbe*z9j\x1e3f\x91-\xcfC)\ +\xbf\x9b\x15bD\x86\x93#\x9b\xa8\xb6\xf55\xba\xb4\xfc\ +\xef\x1aj\xe6\x1cz\x01r\xc1\xe0\xb5\xb9\x19@\xa07\ +\x0d\xe5\xc4)JJd{\xc1\xff\xe4\xf6&ym.\ +(\x97M\xe9\xeb\xfaq\x0e5a\xa7\xfe\xf7$\xaa\xc4\ +}\x01\x06\x1dT\xa1\xce\x06x\xf6\x06N\x93\xed\xc0\x8d\ +\xb8\xa2\x8eA&0J\xcd<\x9e:y-\x1b\xbf8\ +YB\xaf\xca\x92#Te\xe0_\xe0\x998$k\xf3\ +\xac\x17'\x85A\xe23\x06\xa3\xb46}\xac\x88\xc77\ +\xf7\xd5Y\xab\xe1\x0d\x80\x0c\xcfo\x1a\xf3\x09\xa8\x10\xfe\ +\x07\xb4\x0a\xfd~\xcf\x22[\xc2\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x01\xc7\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01yIDATX\x85\xe5\ +\xd61N\xc30\x14\xc6\xf1\xff\xb3\x9br\x03:p\x82\ +\x82\x84\xc4\xd4\xb9\xe5\x00Hp\x85\x0e\xb0T\xdc \x1c\ +\xa1\x1bT\xe2\x12\x88\x05\x09\xa9\x99\x91:Q('`\ +\x80\x89\xb9!5C\x15\xa1\xb6ic\xa7N\x18\xf0h\ +?\xf9\xf7\xc9\xb6\x9e\x0c\xff}H\x95X\xab\xdbo$\ +Z\xdf\x81y\x1f\x0dzg\x00\xaaR\x5c\xe9\x08L\x0b\ +d/\x9d\xafU\x8a\x8bib\xe4M\xcf\x92\x93t\xad\ +\xf4+\xc8\xc0\xdbO\xb7\x97\x1f\x95\x04\xc8\xc3K\x0d`\ +\x83\x97\x16\xc0\x16/%\x80\x0b\xee=\x80+\xee5@\ +\x11\xdc[\x00[\xfc\xf0\xfcz\xb7n\xe2\x07\xe0k4\ +\xe8u\xc0C't\xc4\x87\xc0\x11PO\xe7\xb7\x0aP\ +\x00?\x00^\xa6\x12\x9c\xa6k\x85\xaf`\x0b\xfc\xf8\xf9\ +\xe6\xe2s\xab\x00\xbe\xf0B\x01\x5c\xf0\xc0\xc4\x91\xc0>\ +\xf0:\x95\xa0\xb3\x8c;\x07\xf0\x8d;\x05(\x03\x07\xd0\ +>\xf1V\xb7\xdf\x101\xd68X\x9c\x80\x0b\xfe\xad\xd5\ +\xd0\x05\xcf\x0dP\x0470\x89%hg\xe1N\x9d\xb0\ +$|\xa5\x13f\xfe\x09\xcb\xc0\x03\x13G\xcc\xafg\xa1\ +\x13\xae\x96\xf2\x1b\xe0\xde\x19\ +\xb2\xfbD\xf9\x04\x0f\x91q\x1a\xf7\xe8\xccL\xca\xf4\xcb\ +\xbe\xc2\xa6\x80\xd9\x18x\x07|\x94\x8eA\x0f\x01\xfbN\ +\xff+\x08\x15\xd8\xb5\xbe\xfd\x09\xcc\x1d\x8d\xd5\x0cJ\x5c\ +p\xa8\xcf\x03`s\xa0\xc5\xf3\xa5\xd2\xf3\x80'\xf4\x0e\ +x\xc2\xe3\xff\x0d\xb0\x82\xb0\x19%\xdcc)\xcf\xe5\xdd\ +\x1a\xb8\x92\xc59\x94O\x82q\x02f\x1d\x0f$\x08\xe5\ +\xc0\xb3\x94\x95B8\x03\xee\xf0\xf0d\x10\x9e\x12\x07;\ +(\xdcR\x9b\xc0\xcb\xb5\x18\x83\xa0\x5cHh\xa49\x1e\ +\x86\xb9\xf8\x07\xfa\x1f\xd7\x22m\xc4\xbb\x93\xac\x00\xdb\xf7\ +J\xccc\xee\xc5\x10\xbcsA\x150\xfd\x8c\xc7\xb2\x96\ +\xf5#\xc1VCu\x09\xd3\xb5#u\x8el!\x995\ +0\x95\x03S\xba\xd2\x1bI\xf6\x1c\x0f\xc1\x97\x14\x81\x09\ +\xb4/Im\x16\x8a\xb5\xe1\x96]\xc3t\xe5H\xbdI\ +\xb1\xce\xbf\x17\x8f\x09\x89X\xb6-<6x\xe8\xfa!\ +hJX\xe4x\xd2\xfc%\xc1\x85\ +\xfaA\xeeIg\xb3\xee?\x05\x9e7_as)\xde\ +<\x91\x09,\x9eIB\x15\x0d\xc8\xbc\x8b\x91\x0b\xc6R\ +\x1e\xb4b\x5c\xe1\x89\xf6 Hs=\x83\xa0\x9d\xba\x0c\ +\xa6\xae\x9c\x06f\x0f\xda\xd7\xe2=\xe5\x12\xef1Ch\ +L\xfbc\x1f @P\xd7\x0a\x8f\xde\xb9\x822\xdb\x0c\ +\x82\xfa\xbb5\x126\x06\xee{\xbd\xfd\xca\x8d\x8e|\xb4\ +`{\x7f\x86\x1d\xd83^\x86\x03\xba$?\xa9\x82a\ +R\xdfI\x93\xa9\xd3=\xda\xc7\xbd{c\xe90\xbbK\ +\x1c\x8a\x94NY\xc9\x0cU\xe7l\xc70\x82\xf1!\xf1\ +\x86\xe4\xbdM\x84\x8c\x80\xc6=\xb75\xeaLxF[\ +\xd2\x1fRJ\x1dx5=\x07\xc9s\x7f\x86\xb9O\x87\ +\x9e\xc0>\x9dk\xcf\x96\xbc\xbf\xda\x17\x85\xed\xa0QW\ +\x0b\xd6m\x0e\x06\xf5\xb0g\xc00\x81}\xa5\xdf2\x99\ +'}\x83OFn\xdf\x98\x94\xa1U)\xf5\xac-\xfa\ +u\xdf\xe2\x09\xa7y\x1eb\xdb\xbe\xa6;\x03D\x0a\xaf\ +\xdf\xad\x00;\xee\x8b9`\xcapS\x19\xce4X\xc0\ +K\xb3\x94\xe2\x02o\xb9j6\x96B\xdc\x00\xdfJ\xb8\ +I\xb6\x0e!\x16; 2v\x1f\xf9\xa2\x01;\x08C\ +\x95\xdb\xd6\x0f$4\xfe\xdf\xc03\x7f#!\x9f\xffa\ +\x1a\xee8\x9ev\xd6%,\xef:\x07y\xc0K8\xee\ +\xd9\xc1I\x08\xc6u\xe2\xf5\x165\x0aQ\x05/?\xc9\ +\xf3s\x99~\xb4@\x1e~\x80\xe5S\xb7\xbc*\xa4\x1c\ +7l\xbc\x89_\x06\x09\xe3\x06\xea\xb2c\xa2\xf6\x86\x14\ +\x0f\x1a\xf9->\xdd\xfag\xc1\x94\x22\xd4\x7f\xe0\xed6\ +\xf8\xb3L\x86W6\x931'!\xd8\xfb\xe6\xe2\x19\xec\ +\x86n\xe0\x14\xf8I\xe6w<\x9e{\xa0t\xa4\xeaA\ +\x97\xa0\xf5P\x02\xd5!\x8f{\x7f\xc6\xbb\x9f\x8ew,\ +\xa1\xb8\x95\xccmj\x00n@x\x06\x1b\xd0\xc5|$\ +o\x0e\x106`-\xf0\x0c\xe1\xe5<\x006w\x19\xa0\ +\x83\xebg|\x96l$s\xe5\xf9\xd3E1\x0dA\xe3\ +\x93-te}r\ +1\xf9\xed\xcc\xc5\xe4\xd8\xdb\xf7\x82m +3\x1c\xfe\ +\x81\x7fo2y0\x84qz\xf7\xcbu0n}\xd4\ +\x8ej\xbcg\xec\xc5\xdb\xd0\x0d\xa65\xc9\xd5\xec\x8d\xcb\ +i\xf4\xe2\x98p\xc3\xe4}\xa2\xf7\x09l5;&\x95\ +\x94\x18\xdd\xe5T\x06\xb9\xb0\x18\xf3\x9e\xc3k\xf8\x9f\xaf\ +\xe7\x7f\x03\x88|\xd3;\xed2O\xdf\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00u\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00'IDATx\x9c\xed\ +\xc1\x01\x0d\x00\x00\x00\xc2\xa0\xf7Om\x0e7\xa0\x00\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80w\x03\ +@@\x00\x01\x8f\xf2\xc9Q\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x03\xf0\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xa2IDATx\x9c\xed\ +\x97\xbdo\x1cE\x18\xc6\x9fgn\xb1\x8c\x94\xd0\xc4)\ +\xa2\xfb\x8e\xb005\xa1\x87 ,\x94\x0a\xa7L\x07Q\ +\x04\x7f\x00\x10QD\x08!!>j\xa4(1\xe9\x10\ +\x05\x08h\x88%K\xe0\x02:\xa0\xc6\x91\x89vv\xf7\ +N)\x9c\x8e\x02\x07\xdf\xcdCq2\xba\xdb\xdd\xf3}\ +\xf8\xf6\x9c\x8f\xf9\x95\xf3\xee;\xf3\xbc\xcf\xbe\xbb3\x03\ +x<\x1e\x8f\xc7\xe3\xf1x<\x1e\x8f\xc7\xe3\xf1x\x9e\ +,x\x5c\x0b[\x9b\xac\x81\xf8\x02\xa0\x01q\xb3Q\xab\ +\x5c;\x0e\x1d\xc7b@\x14%W\x04\x5c\x07`\xfe\x1f\ +\x14\xae4\x1a\xd5\xf5yk1\xa3\x1f\x99-Q\x94\x5c\ +\x15p#\xb36q3\x8a\x92\xf7\xe6\xadgn\x1d \ +\x89Q\xd2\xfa\x0c\xc2;#\x1e\xfd\xbc^\xab\x5c%\xa9\ +y\xe8\x9a\x8b\x01\x92\x82(j\xdf\x00\xf5\xc6X\x09\xc4\ +\xadz\xb5\xf2\x16\xc9N\xc1\xd2\x8a7 \x0c\xc3E2\ +\xf8\x1a\xc4\xeb\xfd\xe3\x02@\xc8\xa9'\xc1d\x84\x10\xdf\ +\xab\xdb\xb9\xd4l6\xf7\x8a\xd4W\xe8?`gg\xe7\ +\x19\x9a\xe0v\xa6x\x01\x04\xba\x00E@\x04\xba\x99~\ +\x17\xd6h\x82\x1f\xb7\xb7wO\x16\xa9\xb1\xb0\x0e\xd8\xb9\ +w\xef\xf4S\xffv6\x00\xbc0\x10\x90\x00\x9an\xaf\ +\x07RR\xe4J`F\xd2\xef\xfb\x0b\xc1\x85\xe53g\ +v\x8b\xd0Y\x88\x01w\xef\xb6k\xa5\xc0m\x02x.\ +\xb5\x9a\x00:h\xd8\xff\x8d\x00e\xa0\x8c\xae;\x9d\xc0\ +\xbc\xfal\xb9\x9c\xccZ\xeb\xcc\x0d\xb0\xd6>\x0f\x966\ +\x01TR+\x09\x82\x1bS\x94QJ\x1b\x81\xc49\xb3\ +\xdal\x96\xb7g\xa7v\xc6\xff\x808\x8e_\x04K\xbf\ + ]<\xc6/\xbe\xf70\x1c0\xb8\x0d\x0a\xa8\xd2\xb8\ +_\xe38>7\x0b\xad\x07\xcc\xcc\x80(j\xbd\xe2\xc4\ +\x9f\x01\x9cJ\x85D\x8e_\xfc\x01\xa4\x1c\xb2\xdf\xca)\ +'nY\xdb:?\xb5\xd0\x1431\xc0\xda\xe4\xa2\xa0\ +\xdb\x00N\x0c\x04\x04\x01pC?\xf9C\xe8\xe5\xd0A\ +\x99\xec\x13\xa06\xacM\xd6\xa6S;\xc8\x91\x0d\xb06\ +\xb9\x0c\xe2\x1b\x00\x0b\x03\x01\xd2a\x8a7\x9f\x81t \ +\xd3\xf3,\x80\xf8\xd6\xda\xf8\xcd\xa3N\x7f$\x03\xacM\ +\xde\x05\xb1\x9e\x9e\x87@\xde\x9b\x9b\x1e\xa9\xb7{\x0cb\ +@~im<\xeah}(S\xed\x02\x92h\xe3\xd6\ +'\x04\xf2./\x0e\xd9M~V\x109/M\xc0\xa7\ +\x8dZ\xe5\xfdi\xee\x0f\x13\x1b )\x88\x92\xd6u\x08\ +\x97s\x848\x16W\xfc\xc1\x1ad~\xe7\xae\xd7k\x95\ +\xb7Iv'\x99o\x22\x03\xc20\x5cd)\xf8\x0a\xc2\ +\xc5\x8c0\xc1\x91\xc5\x16\xdf\xb7\x16\xc9\x1c\x13\x88\xef\xf6\ +\x1f\xec]Z^^~0\xee\x5cc\x1b\xb0\xbd\xbd{\ +r\xf1\xe9\xbd\x1f\x00\xe4lA\xca\xec\xdb\xc5#\x02\xcc\ +\xeb\x84\x9f\xf6\xfeY\x5c[Y9\xfd\xf78\xb3\x8ce\ +@\xbb\xdd^\xda\xef\xb8\x0d\x00\x03\x87\x10\xf5\xfaq\xa2\ +\x96\x9b5\x12J\xe9\xeb\x83\x80\xdf\x16\x02s\xa1\x5c.\ +\xdf\x1f\x95?\xd2\x80\xbf\xda\xedj\xd0q\x9b\x00V\x06\ +\x12\x09i\x82\xd3]\x91\x900\xca\xdc\x1f\xf4gP2\ +\xab\x95J\xa5uh\xeea\xc10l\xaf\x18\xe36\x05\ +TSi\xea\xb5\xfd\xc3\x04M\xef\xb3\xe8\x1fB\xec:\ +f\xf5\xec\xd9\xf2\x9d\xa1Y\xc3\x02q\x1c\x9fs\xe2\x06\ +\x80\xa5TH\xc0\xc3\xf1\xe6s0\xc8\xd6t\x9fp\xaf\ +\xd5\xeb\xf5?\x86%d\xb0\xb6\xf5\xb2\x13\xb7\xf0h\x15\ +\x0f\xe4\x9fA\x96\x04\xb3\x15\x86\xc9Ky\x09\x99\x0e\xb0\ +q|\x0d\xe2\x87y\xb1G\x1c\x81\xfa\xa0Q\xab}\xd4\ +?\x98)2\x8a\x92\x8e\x80\xd2\xfct\xcd\x0f\x02\xddz\ +\xbd\x1a\xf4\x8f\xe5\x1d+\x1f[\xf2j\xcb\x18`\xc8\x8f\ +s.\x1e\x8f\x01t\xbd\xda<\x1e\x8f\xc7\xe3\xf1x<\ +\x1e\x8f\xc7\xe3\xf1x\x96\xdb\xe5?|y\ +I\xda\xb7u\x8d\xe20\x19\xc0]\xfd<}\xf23\xd3\ +q\x9c%\x03\xb4M2\x80\x99\xe6\x7fQ$\x07w\xdd\ +\xc5Y2@g\xf3}(\xf9S\x96Fy-|\xa5\ +\xcb8L\x06\xb8\x9dN_C\xa8\x8f\xccu%\xe9-\ +K\xb5fU&\xbfV\x1d\xba\xf1\x17@\xe2G\x08\x00\ +\x00\x00\x00\x00\x00\x00\x00\x00h\x8bO\xc6\xe5B\x89\xb1\ +\xed\x97\x86\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02!\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xd3IDATX\x85\xed\ +\x97\xb1kSQ\x14\xc6\x7f_^\xe9\x22\x15\xb4\xc4\xfe\ +\x01\x1dJG],(.y\xea\x10\x09T^\xd7\x22\ +\xe4\xe9 \x98\xa9T\xff\x0438\x18\xc1\xc5d\xd0\x0e\ +E\x94\x08\x85\x0c\x1a\xe2 \xa8u\xd1M\xb7\xeemQ\ +\x90\xe0R\xc8=\x0e\xbe\x17\x9fR^\x89}iE\xf3\ +M\xf7\x9d{8\xdf\xef\xdesy\xdc\x0b\xff\xbb\xf4{\ +\xe0\xfc\xe5\xf2\x19\xa4\x9b\xc0\x1c\x90\xcf\xc8g\x1bX\xc7\ +\xac\xdan6^''\xbc\xe4\x87\x1f\x94\x97\x84V\x81\ +\x19\xe0HF\xe6D\xb5f\x90\xaeL\xcf\x9e\xfa\xb6\xf1\ +\xe9\xfd\xdbx\xa2\xbf\x03\xfe\xc2\xb5\xb3r\xee\x15\xf0\x15\ +\xb3J\xce\xa3\xf5\xfcI\xe3K\x16\xee\x17\x17\xca\xc7]\ +\x8f\x22R\x0d8\x8a\xd9\xb9x'\xc6\xfa$\xce-\x03\ +\xc2\xac\xd2n6V\xb20\x8e\x15-d\xc5\x0fB\xc9\ +x\x18\xb5\xb8\x04\x90K\xe4\xcd\x01\xe4\x80\xec\x03\xec\ +K\xd8-\xc2\x8a\xb6)\x86\x8d\xbe\x81iAl\x06\x19\ +A\xef1X\xe4^\xb5\xcdYp\xfe\xbfx\xce\x84\xef\ +~\xe1\xce\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80A\xb0\ +?\xb7\xeev\xdc\xaa\x0e\xca\xd2\x8b\xb6U\xd2\xcc\xd2o\ +\xfb\x1f\x0b8\xb8\xf6Q\xf3\x9e\xe6\x92\x9dJ\xda\xea-\ +]\x8cN\xaeE\xd3\xd8\xd9\xfd\xd4V\xf9\xb2(\xe0\xe8\ +\xc6\xb7\xd5\xf9\x83\xa4\xdd\x88tQ\x5cz\xb6\xda\xf6\x96\ +S{\xfa>\xaf\x8a/\xdf\xd2L\xff\xec\xf0\x92d\xd2\ +\x8e\x7f\xa4y>/\x0bp;\x09I\xb4\x06&\x1b\xe7\ +\xb3\xb2\x80\x81)\x0b0\xbf[C\x8e\x10.\xbf\xcdg\ +e\x01\x9b\xd5\x85\xa4\xc7\x80<\xa1\xbe.\xc1\xea<\x9f\ +\x17\x05,'\xf6\xe2\xb2C\xc9/%\xbd\x86\xa4\xebW\ +'\xd7\xd5Fm\xfb\xf9\x1f@\xe2!\x04\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x0c\xc5'\x17\xb6;\xc1\x0d|P\x9f\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x03a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x13IDATx\x9c\xed\ +\x9a\xbfk\x14A\x14\xc7\xbfo\x93p\x9e\x04\x1b1F\ +r\x9b\xdd\x8d\xb9B\x08\xd8\xda\xfb\x03\xb4\xb0\x93\x80]\ +\x0eD%\x9dM\xc8_`,\x85\x04\xd1\x22\xa5Ml\ +DH\x04\xb5\xb3\xb0\x15R\x08\xd1\xec\xde\xde\x82xb\ +\xa1\xa8\xe7\x91\xdc\x8cM\x08x\xbbw\x97\xdd\xb9\x97\xc9\ +\xb9\xf3)\xe7\xe6\xbe\xef\xbb\xdf\xdb\x9d}\xcc\x0d`0\ +\x18\xf2\x0c\xa9\x0a\xd4\xeb\xf5\xd1F\xa39/\x81\x1b\x00\ +f\x00\x14\xd4m)\xd1\x04\xb0I\xc0Z\xb1XX\x19\ +\x1b\x1b\xfb\xd9m\xb2R\x00\xd5j\xf5\xb2\x84\xb5\x0a\xa0\ +\xa4\xa2\xc3HD\x10\x15\xc7q^u\x9a`eU\x0e\ +\x82\xb0\x22a\xbd\xc4\xd1\xbdx\x00(IX\x1b~\x18\ +\xceu\x9a\x90\xe9\x0e\xd8\x0e\xc3+\x96\xa4\x0d(\x04x\ +\xc8\xb4\x08\xe2j\xd2\x9d\x90:\x80z\xbd>\xfa\xbb\xd1\ +\xfc\x00`\xa2/\xd6\x0e\x8f\xe8x\xb1p\xae}MH\ +\xfd\x0b6\x1a\xcdy\x0c\xde\xc5\x03@i\xcf\xfb?\xa4\ +\x0e`o\xb5\x1fH\x92\xbcgy\x86g\xfa\xe0E\x17\ +1\xef\xc3\x19D\xba\xbe\xe7]\xc7V\xee-T\x08\xaa\ +5\xd9\xe5\xe3\x98\xf7AY\xc5\xd90\x01\xe86\xa0\x1b\ +\x13\x80n\x03\xba1\x01\xe86\xa0\x9b\xdc\x07\xd0\xb3\x11\ +\x0a\x82\xe0\x0c\xac\xe1\xbb\x90\xf2\x22\x80\xd3=\xe7Wk\ +\x1f\x15\xfcH\x10\x22\x08\xac\xef\xec\xfcy\x5c.\x97\x7f\ +(h\x1d\x88\xae][\x18\x86\xd7\x85\xa4U\x00'\xb9\ +\x8d$\xe0KA7=\xaf\xf4.\xcd\x97zt\x82\xb1\ +N\xb5\xe3#\xe0WkKB\xd2s\xe8\xb9x\x00\xf0\ +\xc8\x92o\xfd0\xba\xc3Y$1\x00?\x0cg\x09X\ +\xe0,|@\x86H\xcae\xdf\x8f.p\x15\x88\x05\xe0\ +\xfb\xbeK\x92\x9ep\x15\xcc\xc0\x10Y\xf2\xe9\xd6\xd6\xd6\ +\x09\x0e\xf1\xf8\x1d`\x0d/\x02`)\xa6\x8072r\ +\xec6\x87p,\x00\x02\xaeq\x14R\xc6\xe2\xf1\x95\xb4\ +\x06\x1c\xcd]^\xc9\xe3+\xf5\x86\xc8\x90\x852\x87\x91\ +]`\x9a\x046\xbaLa\xd9hI\x1d\x80m\xdb*\ +\x8dNGj\xb5\x1aZ\x1c\xc2=\xc8}+l\x02\xd0\ +m@7&\x00\xdd\x06tc\x02\xd0m@7&\x00\ +\xdd\x06tc\x02\xd0m@7&\x00\xdd\x06t\x93\xe5\ +|\x80.\xce\xf6\xda\xf1=\x00\xcd\xf6\x81\xbc\xdd\x01\x9b\ +\xed\x03\xb9\x0a\x80\x80\xb5\xf6\xb1<\x05\x10\x15\x8b\x85\x95\ +\xf6\xc1\xbc\x04\xd0\x22\x88J\xd2\xb9\xe1<\x04\xd0\x92$\ +ou:/\x1e\x0fZ\ +z\xdf\xe3\xb6r\x7f\xdb=\xef\xdc\xc3w\xbf\xbcw\xef\ +M\xb8\x17P(\x14\xed\x0c\xad%)\x10H\xe8\xfa\xae\ +B\x84\x18g\x00\x1c\x05\xe0\x07\xb0\xd5Ue\xcdS\x02\ +P\x000\xcb\x84\xc7K_\xfd\xe9lvxi\xb5N\ +\xab\x1a\x10>\x1d\x0b\xb1\x86\xdb\x00\xba\x1d\x10\xd9B(\ +G\x06_\xceL$\xa7\x1aey\x1aU\x08\x0d\xc4\xe2\ + \x8c\x00\xd8\xed\xa8\xb6\xd6\xb0\x1b\x84s]\xdd=\xbf\ +\xe7\xf3s/\xeb%\xd55 4\x10\x8b\x83q\xdd\x1d\ +m-\x84(\xd8\xd5\xddS\x9a\xcf\xcf\xcd\xd8>\xb6\x0b\ +V^\xfbLU\x90\xf1\x83\x89\xafj\x1a=\xf3\xa1\xf8\ +itt\xb4\xec\x82\xdcu\x13\x8dF=E\xf8\xf6\x19\ +\x06\x9f$\xa6k t\x98\x9f\x93\x81\xb0\xdd\xe7Pc\ +@ \x90\xd0\xbd;\x0b\x1f`\xfa\xe6\x09xQ^\xc4\ +\xe0t:\xb9\xe0\x8az\x87\x09Fb\x9d\x1e/\x1e1\ +p|%J\xb9\xc5o{\x0eY'F\xcd\xdaY\xdf\ +U\x88\xa0z\xc2\xfb\x0eC?\xbbY\x06\x0f\x00\xd3\xe9\ +\xe4By\x11\x83`\xfcX\x89\xf2\x81\xca\xd8\xaa\xa81\ +\xa0\xb2\xd4\xadt\x03'2\x13\xf7\xbe\xb8!\xd4M\xa6\ +\xd3\xc9\x05\x06%\xcc1\xeb\xd8\x00\x1b\x03\xb0\xbc\xce\xaf\ +$h\xf4\xccam-C\xf3\xf0Ss\x9b\x80\xde\x9a\ +\x1c\x9b~~s\xc3\x87\xe2'\x87u\xb5\x0c\xabv\x06\ +\xf6Zs\xec\x0c\xa8\xda\xe1m\xb4\xd9\xbe\x19l\xb4\xd7\ +\xec^\xed\x0ch+\x94\x01\xb2\x05\xc8F\x19 [\x80\ +l\x94\x01\xb2\x05\xc8F\x19 [\x80l\x94\x01\xb2\x05\ +\xc8F\x19 [\x80lt'\x8a\x84\x06.\x84\xc1\x9e\ +[\x00\x1f\xc4\x1a\xffk\x10\x80\x01\xbc\x07\x19W\xa6\x9e\ +\xdc\xcf\xac\x9a\xbd\x0a\xc2o@\xb8\xff\xe2y\xb0\xf6\x1c\ +\xe0Cp\x7f\xf0\xa8\xfc\xc6a\xb0\xf6<\xdc\x7f\xf1\xbc\ +h1!\x03\x02}C;\x0c\xd0]Q\x11\xeb\x85\xa1\ +\xdd\x09\xf4\x0d\xed\x10\xa9!d\xc0\x16\xdd{\x8c\x80m\ +\x225\xc4\xe0\xed[t\xef1\x91\x0am?\x09\x0a\x19\ +\xf0{i\xf15@\xbf\x9c\x12\xd3<\xf4kY\xc3\xfa\ +\x112 ;9\xf2\x93`\x5c\x12\xa9!\x02\xc1\xb8\x94\ +\x9d\x1c\xf9)RC\xf8\x13\xc8\x8c\xa5\x1e\x80\x8c\x13\x00\ +\xdeay\x89r\x1b\x06\xe8=\xc88\x91\x19K=\x10\ +-\xe6\xc8>\xa0\xb2\x1e\x0b\xaf\xc92P\x93\xa0l\x01\ +\xb2Q\x06\xc8\x16 \x1be\x80l\x01\xb2Q\x06\xc8\x16\ + \x1be\x80l\x01\xb2Q\x06\xc8\x16 \x1be\x80M\ +\xacdnD\xa3\xd1F\xe7\x89746\xdaK\xd6\x1c\ +;\x03\x0a\xe6F\x11\xbe}N\x8aj%V\xed\x04|\ +\xb6\xe6\xd8\x190kn\x18\x06\x9ftXW\xcb0\xca\ +t\xca\xdcf\xe0\x8d5\xa7\xc6\x00&<6\xb7\x89\xe9\ +Z0\x12\xebt^\x9e\xbb\x04#\xb1N\x02\x0f\x9bc\ +\xd6\xb1\x016\x06,}\xf5\xa7\x01\xe4\xff\x05\x08\x1d\x1e\ +/\x1em&\x13\xfe\x1e\x96\xae>1N\xb9\xca\xd8\xaa\ +h\xee\xb8<(\xa1y\xf8\xe9\x86>._\xa6S\x04\ +\x1e^\xf7q\xf9\xbf\xfc7\x17&\x00\x10s<3\x9e\ +\xbaa\xf7\xac\xee\x12\xf71\xf7v\xa6\xab\xbb\xa7\x04\xa2\ +\xa0{\xd2\x5c\x87\x19\x88O\x8d\xa7n\xd6Kh\xb8\xc6\ +\xcf\xe7\xe7f\xba\xf6\x1fy\x05\xa2^l\xba{C\x94\ +#\x03\x83S\xe3\xc9\x87\x0d\xb3\xd6R\xca|m\x8e\x80\ +\xde\xca\xa9\xeb\x0dwm\x8e\x80\xcf\x0c\xbci\xe6\xda\x9c\ +B\xa1ho\xfe\x00\x06\x14\x1b\x10A\x9dX\x08\x00\x00\ +\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\xef\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xa1IDATx\x9c\xed\ +\xd0A\x11\x00 \x00\xc30\x0eMx\xc2\x0f\x86AF\ +x4\x06\xd6\xdb\x18\xd0\xda\xe7\xae}\xael\x98r\xfc\ +\x07\x1d\xa0\x03\xb4\x0e\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\ +\xd6\x01:@\xeb\x00\x1d\xa0u\x80\x0e\xd0:@\x07h\ +\x1d\xa0\x03\xb4\x0e\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\ +\x01:@\xeb\x00\x1d\xa0u\x80\x0e\xd0:@\x07h\x1d\ +\xa0\x03\xb4\x0e\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\x01\ +:@\xeb\x00\x1d\xa0u\x80\x0e\xd0:@\x07h\x1d\xa0\ +\x03\xb4\x0e\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\x01:\ +@\xeb\x00\x1d\xa0u\x80\x0e\xd0\x1e\x06s\x04\xd7(\x98\ +\xcdg\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\xee\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xa0IDATx\x9c\xed\ +\xd0A\x11\x00 \x00\xc30\x0eS\xb8F\x22 #<\ +\x1a\x03\xebm\x0ch\xeds\xd7>W6L9\xfe\x83\ +\x0e\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\ +\x00\x1d\xa0u\x80\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\ +\xd0\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\ +\x1d\xa0u\x80\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\ +\x01Z\x07\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\x1d\ +\xa0u\x80\x0e\xd0:@\x07h\x1d\xa0\x03\xb4\x0e\xd0\x01\ +Z\x07\xe8\x00\xad\x03t\x80\xd6\x01:@\xeb\x00\x1d\xa0\ +u\x80\x0e\xd0:@\x07h\x0f\xaf\xe7\x06C\x97\x92Y\ +\xbc\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\x87\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x009IDATX\x85\xed\ +\xce1\x11\x000\x08\x04A&\x9a\x10\x85\x0c,\xe08\ +\x22\xa0\xdc\xeb\xffg#\x16eMgMo>\xdef\ +|\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\ +\xc0\x079?\x03\x999;&\x1f\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\xd2\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x84IDATX\x85\xed\ +\xd2\xb1\x0d\x82P\x18\xc4\xf1\xff\xf7\xdc\x81\xc4=\x18\x80\ +M,l\xe8\x1cA\x98\x81\x06\x13kg\xb0\xb4w\x10\ +\x13v\xd0\xb3R!$v\x0f\x9a\xfbu\x97\xf7%w\ +\xc5\x0333\xb3\x95\xc54*\xaac\xb3\xc9Yxk\ +\x9b'\x84f\x03\xca\xba\xab\x90.\xc06\xe7\x80\x80\x01\ +\xb4\xbb\x9f\x0eW\x80\xf4}\x91\xfa\xdc\xe5\x00\x82\xe2E\ +:\x7fr\xfaw\xbc\x84\xdf\x80\x88\x1ax\xe4.\x0c\x18\ +\x14\xecGyl\xf9Ohff\xb6\xba7\x95y\x1e\ +\x09\xc0\xb2g/\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x08l\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x08\x1eIDATx\x9c\xed\ +[}\x8c\x1ce\x1d~~3\xb7{wp\x1f\x10\xe8\ +Q\xb3\x1f\xb3{\xd7kJZL,\xa7\x11\xd2TK\ +4\xa8\xa1\x87E\x12\x05\x034\x90*EI\x94@M\ +M\xc0\xaaT\xa1J\x0b\xfcAU\x04-\xd0H\x02B\ +c\x0d`\xff\xc06U!\x80\xd1\xe8b\xcf\x5c\xdd\xdb\ +\xd9\x9d\xbb\x1e\xb5\x14\xfbaz\xb7\xb3\xfb>\xfe\xd1\x22\ +\xf3\xb5w\xbb\xb73\xc7U\xef\xf9o\x9e\xf7\xf7\xfe\xe6\ +\x99g\xde\x99}\xe7}\x7f\x0b\xccc\x1e\xf3\xf8\x7f\x86\ +\xcc\xc6I\x86\x0f\x1dZ\x10\x9b\xac\xac\xa4\xe0\x12\x0d\xb2\ +D\x81\xbd\x00\xce\x13H\x17@\x1d\xc0q\x00\xc7\x09)\ +\x02<\xa0A\xfeFV\xf6g2\x99\x91\xa8\xb5Ef\ +@\xb1X\xecS\xd0\xd6Bq\x10\x82\x0f\xce0\xcd\x08\ +(/j\x9a\xfay*\x95zCD\x18\xaaH\x84l\ +\x00I)X\xd6\x95\xa2\xb0\x01\xc0\xaa0s\x03\xc8Q\ +\xb8\xf5\xed\xc3\x87\x9f\x1a\x18\x18\xb0\xc3J\x1a\x9a\x01\x85\ +\x82\xb5\x0a\xc2-\x00\x06\xc2\xca\x19\x0c)\x10\xd8\x94I\ +'\x9e\x08cD4m@>\x9f\xbfH\xd3c\x0f\x00\ +\xf8\xe2\x14a\x8a\xc0\xefEd/\x14\x87\xa8\xe3\x1f-\ +\xc0\xd1J\xa5r\xa2\xd2\xd6V\x8d\x97\xcb\x9ddK7\ +\xa0\xb2\x14,\x06\xe42\x01?\x09\xa0\xbdVB\x02\xfb\ +5\xa8\xf5\x86a\xbc\xd9\x8c\xfe\xa6\x0c\xc8\x97J\x1f\xd1\ +\x14v\x01\xf8@@\xf3\x09\x81\xbc@rwK\x8b\xbc\ +\x94L&\xdfn$w\xa9Tj\xafV\xe5\x0a\x11\xb5\ +\x9a\x90\xc1\x1a\xe7\x98\xa0\xf0\xe6l:\xfd\x8b\x99\xe8\x07\ +\x9a0\xa0P(]\x0f\xc1\xe3\x00Z}\xa2\x80\x875\ +\xa8\xfb\x0c\xc3xg\xa6\xf9\x9d\xc8\xe5r\xf1\x8e\x8e\xae\ +u\x10\xb9\x07@\x8f/\x80\xb2\xd90\x12\xf7\x88\x88j\ +4w\xc3\x06\x90\xd4\x8a\xc5\xd2\xbd\x84l\xf44)\x00\ +\x8f\xb7\xe8\xf2\xedd2i5\x9a\xb7\x1e\x0c\x0d\xfd\xb3\ +\xb3\xbd}\xe2\x0e\x02w\x02\xe8p\x0b\xc3\xaes\xcei\ +\xbd\xa1\xa7\xa7\xe7d#9\x1b2\x80\xa4f\x9a\xa3;\ +!\xfc\x82\xa7iLiX\xd3\x9bJ\xbd\xd6H\xbe\x99\ +\xc2\xb2\xacd\xa5\xca\xe7\xe1\x7f\xe1\xfe\xc9.O|\xbc\ +\xbf\xbf\xffx\xbd\xb9\xb4FNl\x96F7\xf9.^\ +\xf0*X\x1d\x98\xad\x8b\x07\x80d2i\xe9\x1aV\x02\ +\xd8\xe9i\xfaP,\xde\xb6\x93\xa4^o\xae\xbaG\xc0\ +H\xb1\xf8y\xa1<\xed\xee\xcc\x1dJUo\xcdf\xb3\ +\x13\xf5\xe6\x09\x13$\xa5X\xb4\xee\x22p\x1f\x1c\xd7B\ +`K\xd6H}\xa3\x9e\x1cu\x19P,\x16\x07\x14e\ +?\x806\x07\xfd\x94\x91N\xde\x18\xc5\xec\xacQ\x8c\x98\ +\xd6\xd7\x04\xdc\xe6\xe4\x04r\x93a$\x9f\x98\xae\xef\xb4\ +\x8f\x80eY\x17(\xca.8.^\x80\xd7\xa8*\xeb\ +\xe6\xc2\xc5\x03@&\x9dx\x08\x94\x9f99\x82\x8f\x16\ +\x0ac\xcb\xa7\xeb;\xad\x01\x15\xc5-\x00\x12\x0ejL\ +\x84k\xde\xafa\x1f\x04\x11\xa1m\x9fZ\x0f\xe0\x0f\x0e\ +:\x0e\xa9\x11\x14\ +\x1bh\x80\xe8\xfa\xf5\x00\xfe\xeb\x98\x00/\xf7\xf6\xf6\xbe\ +\x15\xae\xcc\xe8 \x22U!\x9fqqJn\x0a\x8a\xad\ +\xf1\x08\xc8j\xe7\x11\x85\xbf\x0aK\xdcl\x81\xba\xb85\ +\x0b>\x13\xf4\x18\xf8\x0c\x18\x1f\x1f?\x17\xc4\xe5N\xae\ +j\xeb\xbf\x0e]a\xc4\xc8$\x93\xaf\x03\xe2\x1c\xb5\xdd\ +#\x96u\xa97\xceg\xc0\xe4d\xe5\xa3\x00\xe2\x0e\xea\ +\xcf}}\x89\xa27n\xaeCD\x14\x84\xae\x1b\xa7+\ +\xff:e\xc0#\xc0e\x1eb\x7f\xa8\xcaf\x11<\xfd\ +\xfd\xf2\xde1\xb0\xd4\x1b\x13d\xc0\xc5\xce#q\xbfM\ +\xcf*\x08\xc5\xab\xfdboL\x80\x01\x92q\x1e\x912\ +\xe7\x7f\xfbk\x81,{\xb5g\xbd1>\x03\x08t:\ +\x8fE\xe4_!\xeb\x9aMx\xb5wz\x03\xa65\xa0\ +ZeCkls\x09\x99Lf\x12@\xc5A\xc5s\ +\xb9\x9c\xf3\x05\xef7@\xbc\x8b$1\xce\x89o\xfe\xa8\ +\x104\x11:\xe1<\xd0\x95\xe6\x1b6g\x0b\x0a\x85B\ ++\x00\xe7z@y\xd9\xb2eegL\xd0\x08p\xad\ +\xa8\x92thA\xd8\x22\xa3\x02I\x0d\xe4\ +\xb5NN(;\x82b\x03\x0dH\xa7\xd3c \xf68\ +\xa8\xd6\xd8\xa4\xed\xdd\x0e\x9f\xb30M\xeb:\x00K\x1c\ +\xd4\xb8a$\xf7\x04\xc5\xd6^\x15\x16\xf9\xa1\x87\xf8J\ +>?f\x84\xa20B\xe4r\xb98\x04\xdfur\x02\ +l\x0b\x1a\xfe\xc0\x14\x06\xa4\xd3\x89\x97\xe1~\x19\xc6u\ +]m\x0aEe\x84\xe8\xe8\xe8\xfe\x12\xdc\x9f\xbdGO\ +\x9dj\xdb^+~\xaa\x11@*|\xd3\xc9\x11\xbc\xd1\ +4M\xdf\xba\xda\x5c\xc1\xe8\xe8\xe8\x85\x10\xdc\xed\x22\xc9\ +\xef-Y\xb2\xc07\x05~\x17S\xee\x0df\xb3\xa9\xbd\ +\x00\x9et\xc7k\xcf\xe7\xf3\xf9\x8b\x9a\x11\x1a\x05r\xb9\ +\x5c\xdc\xb6\xd5\xb3p\xd6\x10\x11\x7f9r\xe4\xf0\xc3S\ +\xf5\x9b~w\xd8\x8e\xdd\xe9\x5c]%\x90\xd2\xf4\xd8s\ +\xc3\xc3\xc3\xde\xe2\xa8\xf7\x15\x9d\x9d]\x0fA\xf01\x07\ +e+\x1d\xeb\xa6+\xaa\x9c\xd6\x80E\x8b\x16\x1e\xa6\xc2\ +g\x01L:\xe8\xcbc\xadm\x8f\x90\x9c\x95Z\xe3\xe9\ +P(\x16o#\xe4V\x17I\xac\xaf\xa7l\xa7\xee\x0b\ +0M\xeb\x06\x82\xae\x8a\x0b\x02?\xf9\xf7\x89c\xb7{\ +\xbf\xb1g\x0bgJdn'\xb0\x0d\x8e\x9b)\xe0\x83\ +\x86\x91\xfez=9\x1a\xba\x83#f\xe9~\x016\xb8\ +U`_,\xa6]\x9bH$\x8e\xd4\xe8\x16\x09r\xb9\ +\x5c\xbc\xa3\xab\xfb\x11\x10\xb78y\x01~\x93N'\xaf\ +\xaa\xf5\xb3\xe7E\xa3er\xbaY\xb2\x9e\x01\xb1\xc6\x93\ +\xa6\xa0k\x1cL\xa5R\x7fm$\xdfLq\xf0\xe0x\ +OK\xac\xf2K\xf8\xbfT\xdf\xa4\xaa\xac\xc8f\xb3u\ +/\xe4\xce\xa4PR7\xcd\xd2\x0f \xe2\x1db6\x81\ +\xedU;\xb6y\xd1\xa2\x85\x87\x1b\xcd[\x0fN\x97\xcf\ +\xe2\xab\x10l\x04p\xbe\xabQ\xf0b\xd5._\xd7\xd7\ +\xd7w\xac\x91\x9c\xcd\x94\xca\xde\x02\xc1v\x001O\xd3\ +I\x02\x0fT\xca\x13[\x1b)X\x9c\x0a$[L\xd3\ +Z\x0b\xc1&\xb8\xeb\x95\xce\x04\xc8V\xc3Hl\x10\x91\ +j\xa3\xb9\x9b+\x96.\x16Wj\x94\xe7\x00\x5c\x10\xd0\ +\xfc\x0e\xc1\xdd\x1a\xb4\xdd\xe5\xf2\xa9=\x8d\x9a\x91\xcb\xe5\ +\xe2\x9d\x9d\xe7\xafTP\xab\x05\xb8\x1a@\xd04\xdc\x06\ +\xb1>\x93I=6\x13\xfd@\x08\xe5\xf2\x07GGS\ +-U\xf5 \x88k\xa6\x08\xb3\x01\xee\x83h\xbf\x85\xe2\ +\xdf\x95\x92\x83\xaaU\x8e\xc6*\x95\x93\xe5r\xb9\xda\xd6\ +\xd6\xd6\xa9\x94\xea&\xf5,5,\x06\xd5e\x02\xb9\x12\ +@W\xad\x84\x04^?S.\xff\xc7f\xf4\x87\xf8\x87\ +\x89\xd2\xa7)\xb8_\x80K\xc2\xcaY\x03c\x84|'\ +\x93N\xfct&C\xde\x8b\xb0\xff2\xa3\x99\xa6u5\ +\x05\x1b\x05\xf8p\x98\xb9\x01\xe4An%\xab\x8f\x85Y\ +\xa3\x18\xd9L\xce4\xcd\xa5\x14m-\x14\x06!X<\ +\xc34\xe3\x10\xbc\xa0\xc0\x1d\xd9T\xeaw3\xf9?\xc0\ +t\x98\x95\xa9\xec\xc1\xd1\xd1T\xac\xc2U\x0a\x5c\x0a\xc8\ +\x12\x80Y\x11t\x83\xe8\xc2\xe9\x9d\x9bc\x00\x8f\x0b\xa4\ +\xa4\x80!\x08\x874r_:\x9d>0W\xcaq\xe7\ +1\x8fy\xfco\xe2?!{\x09)\x0d\x19\xbe\x1d\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x01\xd2\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\x84IDATX\x85\xed\ +\x97\xcdJ#A\x14\x85\xbf\xd3\xba\xd5\x852\xfa&\xe9\ +\x0c\x8a/\x90a\x04\x03>\x84`Vb\xe6\x11&\x82\ +\x0b#\xb8\x1f\xdc\x0d\xd8\xe0\x22/0 \xa6}\x13\x15\ +\x07$k\xfb\xcc\xc2\xae Il1vt\xc0>\xab\ +\xe2\xd6\xa5\xceW?\x14\xf7\xc2g\x97F\x03\xf53\xaf\ +e\xb8\x8d\xa8\x0b\xbe\x94ab\xb8\xc5\xf4#\xd4\xe97\ +u\xf1,@\x9cx\x0f|0\x09\xac$eX\xfbi\ +S\x87c\x00q\xe2u\xf0\x1f\xe0\x1e\xab\x15=\xd0\xbb\ +\xdc\xd6\xdf2\x5c\xbf\xfe\xf6R6G\x03\xb9\x0b,\xca\ +\xda\x08'1\x1f\x92l\xefK\x08\xab\x956uZ\x86\ +qP\xbe\x91\xd3Zb\x09\xff\xcap\x1b\xf8\x0e\x10\x0d\ +\xb3D\x1d z\xa0W\xa6\xf9\x88z\x00\x12q\x08\x0c\ +\x01\xc2\x83+\xeb\xd8'\xe9jKw\xf9pe\x0c\xe0\ +\xa3T\x01T\x00\x1f\x0e0\xffRB|\xe6\x1d\xe4\x9f\ +\xc0\xc2+\xd7\x1e`\xfdH\x9b:)J*<\x81\xf8\ +\xdc\xab\xc8\xc7S\x98\x03, w\xe3s\xafN\x0d\xf0\ +\x1e*\x04H7u\x8d\xb5\x0b\x0c\xa6X{\x80\xd5J\ +7u]\x94\xf4\xe2\x1b\xc8\xef\xb0\xf0\x1e\xdf\xa2\xff\xfb\ +\x0a*\x80\x0a\xe0]\x01\x0c\xb7\xf0X@\xce\xca\xac\x96\ +x9\x1f\xde\x8c\x01`\xfa\x00\xd9\x1c\x8dY\x01\xc0\xe3\ +\xda6i\x08\x0c?\xa2\x08u\x8c\xbf!wk\x89\x05\ +\xf4\x9e\xd4poR\xbe\xf3\x86\xf0\x11\x90E\xa8\x13\xe6\ +&5&\x1df\xf76\x9eoL\x82Bk\x96\x97\xce\ ++\xa3\xf3S\xea\xc6&\x9d\xd4\x9aU\xfa\x07\xf1\xe4\x84\ +\x86\xea\x09W\xf9\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x03c\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\x15IDATx\x9c\xed\ +\x99_HSa\x18\xc6\x9f\xef\x9c\xcd\xe9\xa0\x14+\x92\ +\xbcR\x8c\xae\xba\xda\x99V&D\x04\xa17\x15a\xd1\ +UF\xe2Qk\xb3$\xe8\x22h\x17u\x17\x99m\x91\ +s\x81z\x11\x12I\x10\x05&\x04\xd9Ee\xe5f\x94\ +A\x08\xf6\xe7\xa24DK4\x1c\xfb\xfbvc1\xb7\ +cC\xf0\xfb\x8e\xd0\xf7\xbb\xdb\xfb\xc2\x9e\xe7{\xce\xbb\ +\x9dwg\x80D\x22\x91H$\x12\x89D\x22\x91H$\ +\x92\xff\x0d\xc6[@\xd3\xbd\xbd\x00\x8e\x01\x00c81\ +\xecw\xf7\xf0\xd6\x5c\x09\x5c\x03\xd8S\xd7\x9d\xfb\xcb6\ +\x1fN\xad\x11\xd1\xdeP\xa0e\x90\xa7\xeeJPx\xbe\ +\xf9\x94}\xc1\x92^c\x8c=\xd1\x9a\xdaJy\xea\xae\ +\x04\x11\x1f\x012\xaa\xdbb\xe1\xf5\xcf\xbb\xce\xcf\xf3\xd6\ +\xcf\x06\xd7\x09\x00\x80\x92\x1fE\x19S\x00\x00\x11k\xde\ +\x1c<\x1e\xee\xfa\xd9\xe0n\xa0\xaf\xefHB\xcdA\xbe\ +QO\xfb\xbe!\xc1[?\x1bB\xae\xc0+\x9f{.\ +\xa9\xaa[\x8dz\x9a\xee}&\xc2\xc3r\x08\x1b\xc1\x91\ +\x9b\xa7\xc6\x19h\x9fA\xab\xd2\xa1\xfb\xae\x88\xf2\x91\x8e\ +*Rl\x224\xf0y\x8b\xb3z\x06@Mj\x9d\x01\ +\xbb\x8a\x9d\xd5\xe3\x13\xc1G\xa3\x22\xfd,j\x8b\xc7\xd9\ +\xe8\xeb!\xa2\xe3\x19\x0d\x86\x8a\xa0\xdf\xfdZ\xa4\x17S\ +\x02\x00\x00M\xf7}\x04(c\x1fHXY\xf1\x9b\x1b\ +\xae\x09Q>L\x0b\x00X~G\xb0\xda\xe3\xf6\xa1k\ +\xada\xa3\xdejc\xea}\x98\xc8\x96cT\x8f-X\ +\x16\x00\x12rqL\x0d \x14\xd0cD\xd1MF=\ +M\xf7\xfd\x14\xe1\xc1\xf4M,\x1487\x0dF\xdb\x0d\ +Z\xf9\x9a\xee\xbd\xc3[\xdf\xf4\x00\x00 \xe8oy\x0f\ +\xd0A\x83\xd6Q\xde\xdak\x22\x00\x00 R\xc6\xcc\xd0\ +]\x13\x01T\xd4\xb7of\x8c\xfa3\x1a\x0c/xk\ +\x9b\x1e\x80\xa3\xa1\xd3\x9eP\x95\x07\x00JR\xeb\x8c\xd1\ +\xa5\xa0\xdf]\xc9[\xdf\xd4\x00jk\xef\xaa\x8cEz\ +\x01\x94\xa7\xd6\x09\xb85\xecw{Dx05\x80O\ +\x85\x93W\x01\x1cH+\x0f\xac+\x9ai\x06\x98\xe1\x92\ +\xb4\xda\x98\xb6\x09:u_\x0b\x81\xdaSk\x04\xbc\xcd\ +\x8d\x85\xabD>)2%\x80\xf2\xc6\xeb\x87\x92\xc4\xee\ +\xa5\xe9\x7f\xb5\xb2\xf8\x8e!\x7f\xeb7\x91^\x84\x07\xe0\ +hh\xaf`L\x19\x04\x90\x97R\x9eO*\xc9\xdd#\ +\x1dg\xde\x89\xf6c\xf8\xbc\x8e\x17ZS[)Hy\ +\x08Zr\xf88\xa0\x1c\x1e\xe9p\x0b?< \xf0K\ +p\xe7\xc9\xb6B$-\xfd ,\xdd\xfd\x19\xf4`\xe7\ +\xe9\xc7\xa2|\xa4#d\x02\xca\x5c^[<\x8a\xfb\x00\ +\xb6\xa5\xd6\x19py\xd8\xef\xee\x12\xe1a9\xf8O\x80\ +\xc7\xa3\x14D\xd1M@\xd5\xd2\x06\xdd\x1e\xeet]\xe4\ +\xae\x9f\x05\xee\x018&7^\xc0\xe2\x7f\x83)<\x9d\ +\xcda\xf5\xa2\xee\xf5\xff\x82\xeb]\xa0\xcc\xe5\xb5\x15D\ +1\x0b \xf7o\x91\xd8\x87\x88\xaaV\x8ev4\x0b\xf9\ +\xbd\x9f\x0d\xae\x13\x90\x1f\xb1%\x01\xc4\xfe\xbcf\xc0\x94\ +E\x89\xd7\xac\x95\xc3\x03\x9c\x03\x08\x05\xf4\x18\x03\xea\x00\ +L\x03\x18C2\xb1\xff\xa5\xff\xec\x17\x9e\x9a\x12\x89D\ +\x22\x91H$\x12\x89D\x22\x91H$\xd9\xf8\x0dY\x9b\ +\xda\x0c\x1f\xf1\x22O\x00\x00\x00\x00IEND\xaeB\ +`\x82\ +\x00\x00\x02.\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xe0IDATX\x85\xe5\ +\x96\xbdk\x14Q\x14\xc5\x7fgF\x8d \xf1\xab\x90\x85\ +\xcd\xec\x18\xc1.\x85\xa5\x95e\x04%\x8d\x85V\x0av\ +6B\xfe\x00\xb1\x10{\x11\x04KA+-l\x82\x85\ +\xa6\xb3\xb2\x14\xd9N\xc8:;\xbb\xb0Xi\x82\x90\x0f\ +v\x8e\xc5\xac\xb5\xfbf\x1e\x0az\xaby\xc3\xbcs~\ +\xf7\xbe\xfb\xde\x1b\xf8\xdfC\xb1\x05\xcb\xb2<=\xad\xd8\ +\x02\xfbl\xde;\xf5\xbb\xef\x0f\xc54\x9fL&\xc7v\ +\xf7\x0f\xde\x00'\xe6\xcd-\x1a@\xbf\xdf?\xb2\xb7w\ +\xf0\x1a\xb8\x182/\x89an;]\x5c<\xf9\xdc\xb0\ +\x8a\x1d4\xb75\x80m\x0d\x87\xe5\x13\xe3\x1b\xf5\x1bU\ +\x7f\x14\xa0(\xc7\x0f\x8c\xee\x00\x18*DP\x09Z\x01\ +\x0c\x8a\xd1:\xf6=\xdb\x80+\x11f\xde\x0a\xa0(F\ +7\x85\x1f\x01$R\x05\x0a6o\x0cP\x14\xe35\xe3\ +g\xf5H\x95\x1bd\xde\x18`k8\xbcd\xaaW@\ +Z\x1b\x07\xb6}\x1b\x80\xc1`t!\xb16\x80\xa3`\ +\x0b\x82:\xbe\x15@Y\x96\xe7\x95\xf8-p\x1cp\xe8\ +vk\x05P\x96ewZ\xb1\x09\x9c\x99uz\x14s\ +\x98\xf3(\x9eV\x8c\xea'\xe3H\x99\xff\x8a\xf9\x96\xc0\ +|\x8ai\x1a\x0c\x90\xa6\x5c\x01}\x01\xa1H\xf7G\x10\ +@\x96e\xe34\xf1*\xf0\xd5\xf5=\x1b\x0dbn\xa1\ +,\xcb>\xbb\xd2e`\x1b\x10\x8e\x03\x11$\xb2\xbc\xbc\ +\xf4\xb1\x92\xd7\x80]\x84\x1c\xa1\x12\xc1\x02\xe7z\xbd\xf7\ +\x22\xb9\x0eL\x05R\xcb\xdf\xbaF\x19\xe4ywC\xe8\ +6\xc0\xac\x0a\x8d!\x1a\x970\xcf\x97^\x08\xd6\x01l\ +7\x86h\xb5\x86y\x9e=Fz(i\xa6\xe5`\x88\ +\xd6M\x94g\xdd\xfbXO\xeb\x91\x12;\xac\x12\xad\x01\ +$9\xcf\xbbw\x85^\xd6\xe30\xcd({Y\xd2t\ +g\xe7\xdb-\xc1\xbb\xd0\xb9\xd1N\xb4\x95\x95\x95\xfd\x85\ +\x85\xc3\xd7\x10\x1f\xfe\x0a\x00@\xa7\xd3\xf9\x91\x8a\xab\xb6\ +\xb7\xc1\xdfcj\xff\xbb\xf1\x13\xb6\x0b\xa1\x01a\x9e\xcd\ +K\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00\xc4\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00vIDATx\x9c\xed\ +\xd0\xc1\x0d\x82@\x14\x04\xd0Y\x8b06b#\xb6\xc0\ +\xc1p\xb2\x17/\x84F\xa8\x82B\x88M\xacWC\xf6\ +\x0a$\xf2\xdeq\xf2\x0f\xf3'\x01\x00\x00\x00\x00\x00\x00\ +\xce\xa0\xac\x83\xfb\xf3\xfdH2\xd4\xe4z@\x9f--\ +I\xed\xe6\xf15\xfd\x86\x97\xc6\xe1?>\x9f$\xb7\xa4\ +\x0c\xeb\xb05\xc0\xa9\xb4\x06\xe8K\xf2\xd9\xbd\xc9\xf6\x96\ +\xa4\xf6G\x97\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xf7\x05\x16\ +\xa6\x0e\x08p\x11\x84\x99\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x01\x04\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\xb6IDATx\x9c\xed\ +\xd9A\x0d\xc3@\x10\xc5\xd0i\x14N\xe1Q\xa0\xe1\x11\ +R\x9b\xc2x\x95\xd6&0\x96\xf5o3\x03\xb9\xee\xf5\ +^\xf7z\xa5\xc3!\x8f\xff\x03\x05\xd0\x02\x9a\x02h\x01\ +M\x01\xb4\x80\xa6\x00Z@S\x00-\xa0)\x80\x16\xd0\ +\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\x9a\x02h\x01M\ +\x01\xb4\x80\xa6\x00Z@S\x00-\xa0)\x80\x16\xd0l\ +\x1f\xe0#\x8f\xeb\xd7\xf8L\x0b\x98S\x0b\xcc\xcc<\xdf\ +\x83-q\xfb\x05\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\ +\x9a\x02h\x01M\x01\xb4\x80\xa6\x00Z@S\x00-\xa0\ +)\x80\x16\xd0\x14@\x0bh\x0a\xa0\x054\x05\xd0\x02\x9a\ +\x02h\x01M\x01\xb4\x80\xa6\x00Z@\xb3}\x80\x1f\x17\ +g\x0aD\xf8\xee\xebL\x00\x00\x00\x00IEND\xae\ +B`\x82\ +\x00\x00\x00\x8a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xf0IDATX\x85\xed\ +\xd6?h\x13a\x18\xc7\xf1\xef\xf3^b\xa5\x82\x8a\x1d\ +\x14]D\x9c\x1c\xfc\x13\xcc\xe0\xe0(]\xea$\xc1E\ +\xd1E\xd2\xda4\x05\xc1QJptP\x92Zk@\ +\x10u\x10\x8b[\x10\xc5\xd1\xa1\xa0m\xc4\xc5\xc9\xa1\x93\ +(HK\x87\x8a5\xc9\xfd\x1c\xee\xb28\xdd]\x8e\xcb\ +\xa0\x0f\xdcv\xcf\xfb\xfb\xf0\xdc\xfb\xde\x1d\xfc\xebeQ\ +n:]\xaeo\x80Y\xbe\xdb9\xb2\xfc\xe8\xc6z\x9a\ +\x00\x17\xf1\xbe\xbd\xa0=\x9d\x5c\xaeu\xfc\xf2\x9d]\xc3\ +\x00\xf4\xeb\xcc\xc8\xe8\xc8\xcbc\xa5\xb9\x1d\xc3\x02 \x18\ +\x1f\xdd7\xf6\xa4Tz\xe1e\x0e\x10\xf8`\x02.\xae\ +\x8d}k\x80\x22\xed\xa1\xd4\x00\x06\x12\xbe\x00$\xa6\x8a\ +\x93\xf5Z\xa6\x80\x00a\x92\xe1\x07\x08\xbbU,7f\ +3\x05\x00\x98\x90P\x80@\xf7\x8a\xe5\xc6\xa5L\x01\xf0\ +\xd7$\xd0\xe3\xc2\xe4\xfcD\xa6\x00\x08&\x81\x10\xe09\ +\xf9K\x85\xa9\xfa\xd9L\x01\x81\x02?D\xect>\xad\ +\xe2\xb5\xbb'\xb3\x05\x84\x08\xc9\x04\xec\x96\xf3^\x17\xae\ +\xdf?\x9a-\x000S\xff\x1d\xb1\xdfz\xbd\xb7\xa7*\ +\x8d\x83\x99\x02\x82\x0aN\x86\xc1a\xd7\xd1\xab!\x00\x00\ +D\x8881\x04\x8090\x04k\xbd\xbc\x1d\x8a\xd2\x91\ +K+Z\xe0,\xf86|\x97\xe7\x9d\xfb8?\xfd5\ +J_Z\x13p\x16\xfc\xdcl:\x18o/L\x7f\x89\ +\xdc\x98F8A\xf8/\xdfq\xfe\xfd\xc3\xea\xa78\xcd\ +\x83>\x02\x0b\xaf\x9eo\xae\xd4~Py\x17w\x81\xc4\ +\x13\x90\xc9\xfa\xfd\x86]m/VZI\xd6I:\x01\ +3\x99\x03\x90\x98]i\xce,V\xe7\x06\x09\x8f\x0d0p\x18 {\xbez\ +`}&|\xf7\x0fT1\xf7\x80a\xf0fk\xe3\xc7\ +\x15\x9a5\x7f\xd0p\x88\xbf\x07\x96\xb7\x7fn_\xf8\xbc\ +T\xfb\x9dF8D\x9c\x80`\xd3\xc0\xf2\xdd\xee\xc4\xca\ +\xd3\x9b[i\x85\xff/\x80?\x94\x18\xa2c\x8f\xc5\xfb\ +\x89\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x04.\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x03\xe0IDATx\x9c\xed\ +\x98Mh\x5cU\x14\xc7\x7f\xe7\xbd2\xa9\x9a\xb8\xb1\x94\ +\xb4R\xc4\x8d\xd6\x8d`2\x16\xba(4~\x84\x88R\ +\x94JQW\xcd\xa2\xe9\xa4i&\x11\xea'\x04\x09V\ +\xb0]\xa8\xcd\xd4|\x8c\x94D\x84\x82\x9bb]\x18i\ +\xa9L\x16\xae\xe6M\x0an\xfc\xc0Ei5\x0b\x9bH\ +!\x81\xa6S\xe7\x1d\x17\xc9h\xe6\xbd\x97Nf\xe6\xbd\ +IJ\xefoy\xcf\xbb\xe7\xfe\xcf\xb9\xef\xde{\xee\x05\ +\x83\xc1`0\x18\x0c\x06\x83\xc1`0\x18\x0c\x06\xc3\xbd\ +\x85x\x1b\xe2]\xa9\x0f\x04\x1dP\xc1Vp\x05t=\ +\x84\x85\x85\x82\x08X\xa2\x14\x14\xf9\xd0I\xf7\x0e\xae\xb4\ +o\xf2\xf5\x10\x1dP\xb0\x01\x04\xac:\xe9\x8c\x8c\xe2\x0c\ +\xab`\x83\x0e\x00%\x09\xb8\xeb\x03\xac\x15\x7f\x02T\x8f\ ++rW\xff\xf6A(\xa2\xa8\x1e\xf7\xb6\xfb\xf6\x00\x80\ +\xd6\xaeSm\x22r\x1eh\xf2|\xae\xa0n$\x0a\xc3\ +\xc3\xc2\x1f\xd7<\x22\xfb\x9c\xd1\xde\x8c\xf7\xe3\xc0\x04\x00\ +\xb4t\x9fj\xb5\x5c\xf9\x1e\xd8RbP\x14aC&\ +A\xc1\x12\x7fL\xb3\xae\xa5\x1d\xd3#}\xb9\xa0>\xab\ +&\x00 \xde\xfd\xd9\xe3\xb8\xd6E`\x87\xa7\x9b\x02\xee\ +\xc69 d9x\xf5\xc6s\x15\xcbmwF\xfa\x7f\ +]\xbdg\x19\x9e>\xf2\xf9\x0e-\x14.\x00;=]\ +7H\x12\x04\xc0\xc2\x1f\xfc/b\xdb\xed\xd9\xe1\x9ek\ +w\xea]\xf6\x14\xc8\x0e\xf7\x5cS\xcd\xef\x01\x9cR\x8b\ +\x8a\xa2v\xf9\x14F\x87\x00\x8a\xda\xbe\xe0\x85\xacj~\ +O\xb9\xe0a\x8d\xc7`.}l\xb6\xe1\xf6\xcdg\x04\ +~\xf0\x09P\xec\xf5\xc8\x81\x82\xb8\x04\x8e}\xa9!\x7f\ +\xf3\xd9\x5c\xfa\xd8\xecZ\xfcT\xa4}\xef\xc1\xf1\xcd\xf3\ +\x0d\x0bg\x05}\xc5/H]\xa9\xd3\xf1\xa9\xa8\x08\x12\ +4y\xe7n\xc4x\xe3\xf7T\xf2\xd6Z}UT\x08\ +e&:\x17\x9b\x9ag\x0f\x80\x9e\xf1\xda\x04\xb1\xb4\xc2\ +\x84V\xc3Ri\x1b\x14\xbc\x9ey\xf4\xef\xe6\x03\x95\x04\ +\x0fU\x0bV\x89\x1fN\x9d\x00\xde\x0a\x10\x18\xd9\xfd\xa1\ +X\xd7\xfb\x0dz\xd2I'\xdf\xa5\x8a?\xb0\xa6\x19\x8b\ +'Ro\xa3z\x22\xc0\xab\x8b\x86\x9d\x04\x15\x82f^\ +\xe4\x1dg\xb4\xf7d\xb5^\xedZ$\xcd8\x93?n\ +k\xed\xf8SD^\xa24\x99\xa2\x84\xb8\x1e\x84\xa0\xe0\ +]\x90C\xceX\xef\xe9\xda\x5c\x87@<\x91\xda\x8f\xea\ +Y \xe61-\xd7\x0a5\x11T\xda\xe6\x05^\xcf\x8e\ +%\xcf\xd5\xe8;\xbcI\x8a\x1f\x1az\x0e\x8bo\x80\x07\ +V\xb6\xeb\xd2\x96]e\x12$\xa8\xc0Y\x10\xf4\xe5\xec\ +X\xdf\xa5\xea|zF\x08\xc3I\x91xbh\x17\xca\ +w\xc0C\x9ea\xaa\xb8D\x05\x06?'\xae\xfbB\xf6\ +\x8b\xfel-:KF\x09\xcbQ\x91\x96#\x9f>!\ +\x85M\x17\x05}\xd8c\xaa`9\x04\x06\xff\x87k\x17\ +\xda\xa7\x87\xdf\xfc9\x04\x99\xff\x8f\x14\xa6\xb3\x22O\xf5\ +\x9c~\xc4\xfe\xc7\xbd\x00\ +\xee\x02\x8e\xc2\x05\x10a\x1a\xbe\x91\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x038\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x02\xeaIDATx\x9c\xed\ +\x98\xc1k\x13A\x18\xc5\xdf\xb7i\xda\xb4E*\xa2\xf5\ +\x90L6\x09\x04O\xde\x8a\x15\xaa\x17\x11\x04/*\x82\ +\x22\x1e\xecA\x10\x04\xe9\xc5\x9b\xa0\x07\xbd\x89\x7f\x81\xa0\ +\x1e\xa4x\x11D\xa1\x08\xa2\xf5 \x1e\xbc)\x82-\xb1\ +\xcdN6\x11\xb4\x05M\x15\x1b\x9ad?Ob\x93l\ +M\x0b\x99\xd9\x1e\xbe\xdf\xf1}\xb0\xef\xcd\xdbYfX\ +@\x10\x04A\x10\x04A\x10\x04A\x10\x04\xa1\xc7x\x9e\ +?\xedi\x9f=\xeds\xb1T\x9a\x8c:O;d\xf2\ +\xe1\xc5b1AN\xdfj\x8b\xc8t$\x93I\xcd\x9a\ +\xf4\xdd\x0a\x8e\xc9\x87\x0f\x0f\x0f\xf7u\x88\xc4\xaf\xb4\xd6\ +9\x93\xbe[\xc1h\x01\xa3\xa3\xa3\xbf\xc2t\x86\xb30\ +7\xb7\xb4\xc3\xa4\xf7f1Z\x00\x00\xb8\xe9T\xe7.\ +\x00\x90\x18\xac\xad0\xb3q\xffn\x18\x0f@D\xcd\xfa\ +Zm$l\xa6K\xe5\xa6i\xffnXy\x03\xf9|\ +~%\xe6 \x1f6\xf3t\xe9\x8d\x8d\x0c\x1bam\x0b\ +*\xa5>\x13\xe8h\xe7\x84&\xbc\x92\x7f\xdbV\x8ev\ +\xac~\x83\xae\x9bz\x09\xc6\x95\x8e\x01\xe3\xaa\xe7\xf9\xe7\ +mf\xf9\x8b\xd1{\xc0Fh]z\xc0\xa0\x0b\xedz\ +\xe0`<\xa7\xd4;\x9bY\x22)\x00\x00<\xed/\x00\ +\xe8\xb8\x0f8\xc4\xc9t:\xfd\xc5V\x8e\xc8\x0a\x00\x00\ +O\xfb\x1c\xa6\xc7\x1c\x0c)\xa5V\xc3f\xbd&\xd2s\ +xy\xe9k\x7f\x98\xde\x0c\xf0\x9b\x99\xad\xbc\x9cHw\ +\x00\x00T*\x95\xdd\xf5F\xb0\x142\xaaf\x5c\xb5\xd3\ +\xb4\x7f\xe47\xb1d2\xb9\xec\x10\xef\x0f\x19\x8dh]\ +~d\xda?\xf2\x02\x00 \x9dN\x7fd\xe2\x93\xed:\ +\x83\xcf\x9a\xf6\xde\x16\x05\x00\x00\x9a\xb1\xf9(l\xb7E\ +\x01\x8b\x8b\x8b{\xc9\x09fBFoM{G^@\ +\xa5R\x19\x8a\xc5\xe2O\x01d[\x06D73\xae\x9a\ +0\xed\x1fi\x01\xcc\x1ck4\x82i\x06\x0e\xb4\x8d\xee\ +\xba*y\xc3F\x86H\x0b\xf0J\xe5;\x0c\x9ch\x11\ +\x19\xcf\xddt\xea2\x11\x85^\x92zMd\x05h\xed\ +O\x110\xd5\x22\x12\xde\xd7j\x893D\xd4\xb0\x95#\ +\x92\x8b\x90\xe7\xf9\xa7@x\xdc\xe6_\x8e98\xa8\x94\ +\xaa\xd8\xccb\xbd\x80\xa2\xef\x8fS\x80Y\x00\x83\xeb\xe4\ +\x9f\x81\x83C9\xa5>\xd8\xcec\xf5\x13\xd0Z\xe7\xa8\ +\x89gh]|\x83\x10\x9c\x8eb\xf1\x80\xc5\x02|\xdf\ +\xdf\xc5pf@\xd8\xd32`\xbe\xe4\xba\xee\x0b[9\ +\xda\x09\xfdc\xdbk\x0a\x85\xc2@#\xc0\x13\x02\xf6\xb5\ +\x0c\x88ne\x5cu\xcfF\x86\x8d0\xbe\x03\x98\xd9\x89\ +\xc7\x13\xf7\x098\xdc6z\xe8\xaa\xe4u\xd3\xfe\xdd0\ +^\x80\xd6\xfe5\x10\xce\xb5\x88\x84\xd7\xf5\xb5\xdaE[\ +g\xfd\xff0z\x0a\x14\x0a\x85\x81x\x7f\xe2\x07\x80\xc4\ +?\x95?\x11x\xc2u\xdd\xef&\xbd7\x8b\xd1\x1dP\ +\xadV\x03\x00\xf5u\xd27\x0e\x9a\xc7\xb7\xcb\xe2\x01\xc3\ +\x05\x8c\x8d\x8d\xd5\xc1\x98\x04\xb0\x0c`\x9e\x03:\x96\xcd\ +f=\x93\x9e\x82 \x08\x82 \x08\x82 \x08\x82 \x08\ +\xdd\xf8\x03je\xdcE1P\xc4}\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x00\xcd\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x7fIDATx\x9c\xed\ +\xd9Q\x0d\x800\x10\x05\xc1\x03\xff\xcaPA\x83\x10\x90\ +\xb1$\x9d1p/\x9b\xfeu&t\xaf\xe7\xbd\xd7\xf3\ +\x96\x1b\xce\xf2\xf8\x1f\x08P\x0f\xa8\x09P\x0f\xa8\x09P\ +\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8\x09P\ +\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8\x09P\ +\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8\x09P\x0f\xa8m\x1f\ +\xe0(\x8f\xd7_\xe33\xf1\x0b8f\xae\xf2>\x00\x00\ +\x00\x00\x00\x00\x00l\xe2\x03\x9cm\x0b\xf4\x94;\x8dK\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02-\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xdfIDATX\x85\xe5\ +\x96\xb1k\x14Q\x10\x87\xbf\xdf\xbbC\x82\x82G,l\ +\xac\xed-\xad,$\xb7\x01%\xcd\xc5\x8d\xd5\x05d\x15\ +\xd3\x08\xf9\x03\xc4B\xecE\x10T\xe2!x\x95\xaew\ +M\xb0\xf06XXY\x8a\xad \x16\xda\xd8\xe8\x05\x0c\ +Aro,V\xc5J\xf7\xed>\x22\xe8t\x03;3\ +\xdf\xfcv\xe61\xf0\xbf\x9bb'\x5cL\xb3#\xde\xeb\ +-`\xc5\xe8\xfe\xfc\x9f\xbeo\xc7,\x9e\xf4\xfb\x87\xfc\ +\x8e\x9e\x02\x9d\xaa1.V\xf14M\x0f\xd8\xce\xdc\x18\ +8\x19\x12\x17\x05 M\xd3\xd6'\xdfy\x08\x96\x84\xc6\ +\xc6\x00\xd0g\xdf\xb9-8\x8f\x01\xe0\xf7\x15`\xe1\x5c\ +v\x1dX\xc3\x00'\x0f\xdf1*Z\xa3!\x5c\xe8]\ +\x5c\x97q\x15\x00\xc9c\x16T\x1c\x1a(\xd0\xede}\ +\x89\x9b?\x8b\x13^\xbc6@\xb2\x9c-!=(\xbd\ +z\x9d\xd7\x06Hz\xd9)C\x8f\x81\x96aV\xb7\xf3\ +Z\x00\xdd\xf4\xd2\x09\x93\xdb\x04\xe603\xa1\xa0\x89o\ +\x04\xd0]\xbe|\x1co\xcf\xc0\x0e\x1bX\xf9\xdf\x9b[\ +%\x80\xd3\xe9\xda1\x98\x15\xc0Q\xc0\x14\xb8\xeb\xbf\xb3\ +Jk\xd8\xf2{\xef\x7fq\xa3\x15\x87\x8a\x0a\x08^C\ +\xe0\x0b\x13\x13`\xcf\xb5\xcf\x80\xbdS@LT\x80\xe7\ +\xf9\xdd\x0f\xd0N\x80\x8f\x80,\x22D\xe5D\xc5\xe8\xde\ +\x1b\x9c\x16A\xdb*\x0f\x99(\x10AI\x8a|\xe3\x95\ +\xcc/\x01\xbb\x80\xcc\x9aC\x04'\x98\x8c\x07/\x84\xad\ +\x003\x09\x81\x1a\x9du\xb5:\x98\x8c\x06\x9b\x98](\ +=s4\xb8-kKX\x8c\x07C\xd0\xfa\x8f<\xa5\ +\x1a\xfb\x08\x00P\x8c6n\x99\xec\x06\x80y\x9cj(\ +\xd1x\x88\xb6\x9e\x0c\xae\x09\xee 0\xc3\x11\xa8D\x8c\ +U\xb2\x8e\x9b^1x\x84\x80\xc0\xcd\x88\xb2\xcby\x9e\ +\xcf\xe6\xddt\x154\x09\x8d\x8d\xf6\xa2\xe5y\xfeU\x07\ +w{\xc0\xcb\xbf\x02\x000\x19\x0e\xbf8gg\x91\xb6\ +\x81i\xcc\xdc\xff\xae}\x03hG\x95\x0a\x88\x7fI\xe0\ +\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x00h\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00\x1aIDATX\x85\xed\ +\xc1\x01\x01\x00\x00\x00\x82 \xff\xafnH@\x01\x00\x00\ +\x00\xef\x06\x10 \x00\x01G\x01\xa0\x88\x00\x00\x00\x00I\ +END\xaeB`\x82\ +\x00\x00\x01\xa6\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01XIDATX\x85\xed\ +\xd21/CQ\x18\xc6\xf1\xff9\x15\x03\x89\x10B\xba\ +\x11\x9b\x89\xb0\x89E\xb4i\xd0D\xb5\xb5\xd5\xc0\x15\x12\ +\x1f\xc0f\x12\x1f\xc0\xac\xb54bh\x99\x08\xadDB\ +H7\x11\xc2\xd6E'\x83D\xca\xe4\xde\xfbZ\x198\ +\xda.\x12\xe77?y\xce\xf3&\x07,\xcb\xb2\xac\xff\ +N\x99\x02\xa1\xb8\xb3\x0d\x0c+_R\x85\x83\xf4\xddo\ +J#3+\xbd^\xc0\xcd\x02/\xc5\xfc\xf64 \xdf\ +e\xb5y\xa1\xb4\x03\x83\xa2\xf5e8\xe6\x8c\x9b\xf2\xe1\ +\xa43\xec5\xb9%`\x14\xa4\xd3\x947\x0e\xa8\xea\xb6\ +\x14\x8a\x1cH\x9bh\x8e'\x12\xce\xfcw\xd9\x89\xd9\xc5\ +)\xf19G\xe8\x11\xd4\xd9\xbb\xe7E\xf8\xe1z\x80\x80\ +i@\xe5\xbe\xe4\xa6\x92\xd1|\xe5\xe9\xb5\x15\x18S\x10\ +\xeb\x1f\x18\x92\xf2\xc3\xf5\xf9\xe7\x5c(\xbe\xb4\xa2\x14Y\ +\xa0\x19\xc8v\xe8\x97\xb9\xa3\xfd\xdd7S\xbf\xf1\x0f|\ +}\xc4Y\x05\xb6\x00\x8d\xb0\xf3\xdc\xa5\x97\xa7\x83A\xef\ +\xea\xb6\xb2\x89Rk\x00\xa2d\xe34\x97^\xc7py\ +]\x03\x00\xc2\xf1\xc5\xa8\xa0\xf6\x80\x16\x81\x0b\x05U`\ +\x12p\x15\xb2\x5c\xc8\xa73\xb5\xf4\xd5<\x00 \x14_\ +\x18\x01}\x08t\x03\x08T\x95\xf2\x13\xc5\x5c\xa6Pk\ +W]\x03\x00\xc2I\xa7O|\xca\xc0\xa3\xf6\xfd\xe8\xc9\ +A\xe6\xa6\xde\xaeF(\x1a8\xc2\xb2,\xcb\xfa\x13>\ +\x00w\x85k0\xd4\xa0\xe5g\x00\x00\x00\x00IEN\ +D\xaeB`\x82\ +\x00\x00\x01\x8c\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01>IDATX\x85\xed\ +\xd2\xbf+\x85Q\x00\xc6\xf1\xef\xf3\xcab\x90R\xac\xfc\ +\x05\x14\xbd\xf7\x96\xcd$?\x8a\x9b\x98X)\x7f\x80\xcd\ +$\x93\xc9,R\x06\x03/)%\x8b\x22\xf1\x8a\xa2\xcc\ +\x16e\xb1\xd0\x1d\xa4\xee\xbd\x8f\x81\x01\xc5\xeb\xdeM\xce\ +g<===\xa7s \x08\x82 \xf8\xef\x94\x15\xc8\ +o\x95\x97-u\x95\xd1\xc4EA7\xbf)\xcdo\xbb\ +\xcd\xf6:\xe2)\x1d\xd6 \x92\xbf\xcbFYeFM\ +@g\x1d>\x89\x13\xf7f\xe5s\xdb\xee\xb2}\x06\xf4\ +P\xa19+\x9f9 *k\x02\xd8\x04\x1a\x85\xf7\xe3\ +\xc4\x93\xdfe\xe3-\x0f`\x1f\x01\xad\xc0\xe1K\xa4\xbe\ +\x9fn\xff\xab\x01\xa7czN\xaf5\x0e^\x04\xea\x85\ +\xd7r\x89\xe7\xb0?=_\x9cxZ\xf2.\xd0\x00^\ +/\x96\xd4w5\xa2\xc7\xac\xfe\xcc?\xf0Q.\xf1\x0c\ +x\xe9m\xb8WK\x0f\xd1\xd4\xe5=\xe5\xb8\xa3\xb2 \ +4\x0b\x80=\x9f\x16\xa2\xb9\xac\x9b\xd74\x00 \xbf\xe3\ +!W\xbc\x014\x00\xc7\x88\x22\xa6\x1f(\x81\xa6\xd2\x82\ +V\xaa\xe9\xabz\x00@\xbc\xe9nE\xde\x03Z\xde\x8f\ +\x8aH\xa3\xe9\x88\x0e\xaa\xed\xaai\x00@\xbc\xebv\x95\ +|\x0b\xdc\x19\x0d\x9d\x17t]kW\xedl}\xfd\x8c\ +A\x10\x04\xc1\x9f\xf3\x0a\x0d+r\x05\x90\xf4\xef\x82\x00\ +\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x22\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xd4IDATX\x85\xed\ +\x94\xb1k\x13Q\x1c\xc7?\xdf\x17\x84\xa0 q\xd0\xc1\ +I\x89\x08J\x06%\xb8:y\xb5H\xe9P\x0d\x8e\x82\ +mf\xff\x02A\xdd\xfc\x0b\x1c\x92\xb8V\xbc\x06\xa1u\ +\xf0zC\x07\x07u\x11\xed\x10\x17-.\x0a.\xb5d\ +\xb1\xa1\xe6~\x0e\x973\xa7mc\x92\x16\xbb\xdc\x17\x0e\ +\xde\xdd\xfb\xbe\xef\xf7\xfb~\xef\xf7\x0e2d\xc8\x90\xe1\ +\x80\xa1d\xe0]\x9f\xfb\x0e\x14\xfe\x93\xefF\xd8\xac\x1f\ +\x03p\xfd(r\xbb\xd2\xf7\x1b)\xaf\xfe@\xd1i\xe0\ +u\x8a\x16\x01\xdd\xfdx\x84\xa2\xdf\xde\xc6\xab\x9e\xd7\x9f\ +\x01\x02\xbf\xb1\xae\xc3\x9d+@\x00\x80\xe1H\x1d\xd1\x1e\ +v\xab\x08s\xf1\x90\x17\x1c\xe9x\x81\xdfXO\xa6s\ +i\xee\xa7\xd5\xd5\xadr\xa9\xf8\xf4\x87\xe5\xcfJ\x940\ +\xb4\xb7\x08\x12\x98\x13\x80\xd9\x93\x82k\xdf\x5c\x9a\x9f\xdf\ +L3r\x7f/i\xb5Z\xddr\xa9\xf8\xacc\xf9\xe3\ +\x88K\x8c[\x05\xc5\xe6\xc4\x02\x8f\x0a\xb9v\xd5\xf7\xfd\ +\x9f\xdbh\x83$\xbc\x99\xb9\xfb\x88\xbb\xbd\xd7\x08\xcc\x86\ +uO\xccA\x0f\xc2f\xed\x1e\xb0\xe3\xdam\x15Hc\ +\xed\xc3\xdb\x95\xe2\xf9\xf2\x060\xd9\x0b\xab\xdd\x84\x12\x98\ +\xe1$\x92\x9d\xdf\x09\x9b\xf5\x87\x83\xf8\x03\x03\xf4B\xbc\ +)\x9e\xbb\xb8\x864\x0d\xb8^_\xec\x18\xc2\xcc\x9c$\ +\x11w\xff\xad\xb0Y\xaf\xfdK\x7f\xe8\xf3\x9d\xb8Q\x9d\ +23\x1f\xc8\x13W!J\xcf\xa7\xcc7%U\x96\x17\ +j\xcf\x87\xd1\x1d\xa9\xc1&ff/\x9b\xdc\x12\xd8Q\ +33)\xbe\xdf}s\xb5\x9dl*X\xa8\xbf\x1cV\ +s\xe4\x0e\xf7*\xd5\x0bD\x16\x00'\x0cL\x89\x86\xf8\ +\x864\x19\xfa\xb5w\xa3\xe8\x8du\xc5\xaeVf\xcfD\ +\x11!\xe8T\xfc\xc5>;\x87\x17\xf8\x8d\x8f\xa3j\x8d\ +\xfd\x9b\xf1\xa6o\x9f\xe4\x90\xfb\x02z\xcfV\xf7Z\xb8\ +\xf8\xf8\xeb\xb8Z\x192d\xc8p\xa0\xf8\x05\xa4\xf1\xa4\ +\x8eD\xc6Q^\x00\x00\x00\x00IEND\xaeB`\ +\x82\ +\x00\x00\x08\xd7\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x08\x89IDATx\x9c\xed\ +[mpT\xd5\x19~\xdesw7\xb0$|d\x11\ +\x13\xd4\xd1\xa0e0Tf`\xb3P\xd4F\xb0v\xa4\ +\x1d\xc1b\xbbV\xed\xa8\x80$!@V`\xac\x1d\x9c\ +\xd1KZ\xa9\xf5+&\xbb`\x08\x04\x0a*\xd3\x19\xd3\ +\x11\xa68\x80Lk\xc3P\x0b!\x1b\xedP\x05:~\ +\x80\x94I\x88\x95\xcf`$\xd9\xdd\xf3\xf6G\x10\xee\xc7\ +\xeefor7\x866\xcf\xbf\xfb\x9c\xe7\xbc\xfb\xdcw\ +\xcf={\xee9\xef\x02\x03\x18\xc0\x00\xfe\x9fA}\xf1\ +!\x13\xe7\x06\xafR2\xa8\x10\x90\xb7\x80i\x1c\x08c\ +\x981\x9c\x80\xa1\x00\x14\x80\xce\x018\x07\xe6c \x1c\ +\x02pP\xc4h\xcf\xfe\xda\xb2#\xe9\xf6\x96\xb6\x04x\ +\x8b\x837\x0a\xc2\x1cf\xcc\x02aB\x0f\xc3\x1ca\xf0\ +\x0e!yc\xe3\xba\xc7\xc3\x00\xb1\xad&a{\x02\x98\ +|%\xc1\xbb\x19\xf4$\x80\xe9\xf6\xc6\xc6\x87\x04\xaa\x90\ +\xecz\xa3imI\xc4\xae\xa0\xb6%\xc0[\x5c5\x9d\ +\x88^\x00P`W\xccx`\xe0(\x98W4\xad\x0d\ +\xbcf\xc7\x88\xe8u\x02\xa6\xcc\xaf\xbc:\xaa\x88\x97\x09\ +\xf8E\x12\x99$\xe0=\x10\xd7K)\x0e\x03\xb1O\x1d\ +D\xa7\xa4\xe2h\x8b~\x1d\x8b)\x83\xa2Y`\xc70\ +b\xe4I\xa6\xb1\x04\x9e\x0a\xc2\x0f\x01\x0cNb|\x0f\ +\xa4(m\x5c\xb7\xf8\xa3\xde\xf8\xefU\x02\x0a\x16\x04'\ +\x83\xb1\x15@n\x9c\xe66\x00\xdb\x89\xb0\x8d\x14\xb1s\ +\xff\xea\xc5'\xad\xc4\x9e\xba\xb4bp\xe7W\x8e;\x09\ +\x98\x09\xc2\xac\x04\x9fq\x01\xc0\xbcpM\xe0\x0f\xd6\xdd\ +w\xa1\xc7\x09\xf0\x16\x87\x1e\x22\xe2\x0d\x002L\xa6\x98\ +\x83\x1d\x8a\xf3w\xff\xac^x\xba\xa7\xf1\xb5\xc8\xf7\xab\ +.\xf7\x88\xec\x22\x22z\x86\x81Q&\x01\xd3\xcap\xee\ +\x97\xcf\xa0\xbc\x5cZ\x8dm=\x01\xaa*\xbc'F>\ +K\xe0\xe5\x86\x16I\x84\x0d\x22\x8a\xf2\x86\xda\xc0q\xcb\ +qS\xc0m\xf3\x9e\xcf\xeap\xb8\x97\x81\xf8\x09\x00\x99\ +\x86\xe6\xad\xed\x8a\xf2\xf0\xc1W\x17\x9d\xb7\x12\xd3Z\x02\ +TU\x14\xb4\x8c\xdc\x0c\xe2\x07t<\xa3\x19\x02\xb3\xc3\ +k\x02\xfb-\xc5\xeb!\xa6\xcc\x0f^\x1bS\xb0\x05\xe6\ +\x09\xf7\x03\xc5\x85i\x0d\xa1\xc0\xb9Tc\x09+\x1f\xec\ +k\xcd^a\xbcy\x02\xf61b\x05}u\xf3\x00\xd0\ +P\x1b8\xeetG\x0b\x19\xd8lh\x9a(;y\xb3\ +\xdf\xff\xa6\x92j\xac\x94\x85\xbe\x92\xd0\xcf\x19\x08i9\ +\x22\xda4\xa4#\xcb\xbfw}\xe9\x99T\xe3\xd8\x85\xe3\ +\xfb\xde\x89\xb64m\xdf2\xda\xd7\xd8\x0e\xe0.\x5c\x1a\ +\xcd4\xf6\xcc\xa0\xb6A\xcdM;\xff\x9cJ\x9c\x94\x1e\ +\x81\xc9%\xa1\x02\x09\xde\x03`\xd0e\x96\xdf\x08\xd7\x04\ +\x1eI\xc7\xea\xcc*\x0a\x8a\x83K@x\xc5@?\x1a\ +\xae\x09\xbc\xd6]\xdfn\x1f\x81\xc9\x8bVyb\xc0V\ +\xe8n\x1e\xfb3;\x86\x16\xf5\x87\x9b\x07\x80\xf0\xda\xb2\ +*\x80\x7fo\xa0\xd7y\x8bWM\xea\xaeo\xb7\x09\x90\ +\x11\xf9\x02\x81\xaf\xb9D0\x9acN\x9a]\xbfq\xee\ +\x05\xebV\xd3\x05\xe23.*\x05\xe1\xef\x1a\xd2E$\ +\xd7MSUG\xb2\x9eI\x13\xe0-\xae\xbc\x1d\x84y\ +\x1a\x8a\xa5\x82\x9f~\xb0\xaa\xac\xb97v\xd3\x81OB\ +\x81\x0e%*\xef\x03\xf0\xa5\x86\x9e\xd4\xd6\xe2Y\x98\xac\ +_\x92\x040\x11\x89\xe7\x0c\xdc\xe6\xf7\xab\x03\xfbzn\ +3\xbdh\xa8]\xd2\x0a\xc6J-G\x84\xa7'<\xfc\ +\xe2\x90D}\x12&\xc0W\x14*\x04p\xbb\x86\x8a@\ +\xc4\xd4\xde\xdbL/2;\xb3\xd6\x008\xa6\xa1F:\ +\xdd\xae\x92D\xfa\x84\x09`\x81_\xea\x09\xd4\x84\xab\x97\ +}\xd6k\x87iF\xfd\xc6\xb9\x17\x88`\xf8\xa2\xc4\xb2\ +Dk\x83\xb8\x09\xf0-\x5c\x9d\x03`\x86\x86\x8a(R\ +>k\x97\xc9t\xe3\x86\x939\xaf3\xf0\xf17\xd7\x04\ +\xbe\xe6SO\xeb]\xf1\xb4q\x13 c\xd1\x87\xa0Y\ +$\x11\xf0nC\xed\x92V\xdb\x9d\xa6\x09uu\xf7\xc7\ +\x88P\xa7\xe5\x04\xf3\xa3\xf1\xb4q\x13@\xa0\x99\x06\xe6\ +Ov\x99\xeb+\xb0\x94F\xcf?\x8e\xf7\x18\x98\x12p\ +q\xc6\xbcU\xcbI\x8e\xbdm\xaf\xbd\xf4\xa3)\xf7t\ +#\x00\xed\xa8\x1dv\xc4s\xc2k\xd4\x99\x12\x90\xe1v\ +}\x0f\x80\xeb2C\xffhZ\xbb\xe4\x98Q\xd7\xefQ\ +^.\x01\xd6}q\xcc\xe6}\xca8\x8f\x80\xf8\xae\x81\ +\xd8c\xab\xb1>\x04\xb3\xde;1\xc6\x1b5\xa6\x040\ +\xf3\xcd\xbak\xc8\x8f\x8d\x9a+\x05\x82\xa1\xf7N\xb8\xd9\ +\xa41\x12D\xb8AG0\xf5\xfb\xdf\xfe\x84p:\x8c\ +\xde\xf3\x8c\x12\xf3\x08 di\xafIP\x9f\xbf\xeb\xdb\ +\x85!\xedn\xa3\xf7,\xa3\xc6<\x07\xb0^$\x98-\ +\xed\xb1\xf5'\xd4o\x9c\xd3\x01 \xaa\xa1\x5c\xf9~\xd5\ +\xa5\xd5\xc4[\x07\xe86I\xa2B\xf6\x8bw\xfet!\ +^\x02\xdat\x02VL\xc3\xe6J\xc1\xb49\x1b3\x00\ +h\xf7\x03:\x0f\xd6\x95wj5\xe6I\x10\xd0\xed\xa8\ +\xb2\xe4\xe1\xe9\xb1\x97~|\xed8;\xcc@\xb5\x195\ +\xe6I\x10\xf4\xb9\xf6\x9a\x84y\xe6\xbcR\xc0\x8ac\x8c\ +\x9e\xc0Q\xa3&\xce$\xc8\x87\xb4\x97\x04|\xc7f_\ +}\x06\x09\xa9\xf3\xce\x84\xc3F\x8d9\x01$t\x87\x8d\ +\xcc\xbaM\x91+\x0a\x0c\x83w\xa6\x0f\x8d\x1aS\x02\xda\ +\x15\xda\x0b@{\xfe>i\xca\xfc\xe0\xb5\xb6\xbbK7\ +TU\x10p\x8f\x96b\x85\xeb\x8d2S\x02\xba\xce\xd6\ +h\xaf\x96\x8b*t\x8fQ\xd7\xdf\xe1k\x1e\xe1\x85\xfe\ +D\xf9\xdc\xd0Q'\xc3F]\xfc-1\xd6\xbfE\x11\ +\xf1,[\xdd\xf5\x05\x84\xd0yf`g}yy\xd4\ +$\x8b\xd77\xe6\xa2\xcd\x00.\x1f53\xee\x9c87\ +x\x95\xdd\x1e\xd3\x06U\x15\x0c\xfcLK\x11xS<\ +i\xdc\x04\x5c\xdc\xf7\xdf\xa5\xa12\x14\xa7\xe98\xbc\xdf\ +\xc2\xd7\xeay\x10\xc08\x0du\x223\xe7\xd4\xaex\xda\ +\x84\xbb\xc2\x04~IO\xd0\xa2\x89\x8bV]o\x8b\xc3\ +4\x22\xdf\xaf\xba\x98\xf1\x1b\x1dI\xf4J\xbc\xe1\x0f$\ +I@cM\xe0]\x00\xda\xc9\xd0%\xa2r\x85\x1d&\ +\xd3\x09\xb7\xc7S\x0c\xfdk\xef\xa9\x8c\xce\xf6\xeaD\xfa\ +$'C\xc4 zJ\xc7\x00\x8fL*\xad2\xed\xab\ +\xf5\x17x\x8b_\x1aI\x8c\xa7\xb5\x1c3~\xfb\xde\x86\ +_\x99\x96\xc0\xdf \xe9\xd9`xMY=\x18\xafk\ +\xf5B\xd2\x96)\xf3+\xaf\xee\xa5W\xdb\x91\xefW]\ +$\x5c\x7f\xd4\xd5\x101\x0e\x00\x19\xc1d\xfd\xba=\x1d\ +\xee\x14\xce'\xa0\xdf]\xbd.\xe6\x10o\xddT\x164\ +\x16G}\xabpggW\x81q\x87\x86\x8a@\xa0\xa8\ +\xbb\xa2\xcan\x13p`M\xe9\x17R\xe0'\x00:.\ +\x91\x8c[\x87w\xe0U\x80\xfb\xa4\xd6\xb8;\xf8JB\ +\x0b\x01Z\xa0g\xa94\x95\xb2\x9d\x94JdZ\xc2;\ +\x8e\x8f\xf6\xcd\xf8\x1c\xa0\xd9\x97\xe3c\xe2\xe8\x82\xc6\xdc\ +\xe1c&\xef\xfa\xcf\xc1\xdd1\x8b\x9em\x02\x93\xb7\xd8\ +\x13\x00\xa1\x0a\xfa\x8d\x9c\xcapM\xe0\xb9D\xbd\xb4H\ +\xb9F\xa89\xbc\xf3\xc0h\xef\x0c7\x88n\xd3\xd0^\ +\xa7\xdb]\x98;\xe9\x07o\xb74\xedjO5\x96\x1d\ +\xc8\xf7\xab\xae\xeb\xbf\x7f\xa0\x86\xba&\xeaK7O\xc0\ +;\x999'\xe7\x1e\xdd\xbd;\xa5\x9aAKUby\ +\xa7s\x9fb\xd0\x16\x1d\xc9\xb8\x03\xe4j\xf4\x16\x87n\ +\xb1\x12\xab7\x98\xb0\xa0z\x94;\xdb\xf3\x17\x80\x1e3\ +4}\x14\xe9\x88=\x90\xe87?\x1e,?\xc3~\xff\ +\x9b\xca\x91\x11-/\x82h\xa9\xa1)B\x84\xea\x0e8\ +W\x1eXS\xfa\x85\xd5\xb8\xa9`\xea\xd2\x8a\xc1\x91\xaf\ +\x1c\x8bAX\x0e`\x84\xae\x91\xb0\x83e\xc6\x83Mk\ +K\xceZ\x89\xd9\xe3I\xac\xa0$\xf4\x18\xc0\xd5\x00\x9c\ +\x86\xa6\xf3 ~YqR\x85\x95\x82\xc5d\x98\xa6\xaa\ +\x8e\xb6\x96\xec9 \xb1BW\xaft\x19\x15y\xa7r\ +\x9e\xac\xab\xbb\xdf\xf2\x5c\xd4\xabY\xdcWRY\xc8\x10\ +o\x01\xf0\xc4i>\x0d`\x1b\x80m\x8a\x0b\xbb\xac&\ +#\xdf\xaf\xba\xdc\xc3=\x85\xa4`&K\xdc\x0bB\xbc\ +ex\x04\xa0\xd2pM\xd9\xfa\x1e\xd8\x07`C\xb9\xbc\ +o\xe1\xea\xeb8\x16\xab\x04p_\x12Y\x04\x84\xdd\x90\ +\xf8+\x04\xfdK0\x7f\xc2\x8ar\xea\x02\xd3y\xb7#\ +\x1a\x13\x91h\x96d\xc7\xb0(#\x8f\x04\x8d\x05\xcb\xa9\ +\x00\xdd\x8d\xae\xbf\xd4$r\xde(\x89K\xdf\xaf~\xbc\ +\xa97\xfem\xfb\x1d/(\x0a\xfd\x08\x82\x9f\x07\x90\xde\ +\xc9\xb0\xab.\xf9\xd7y'sj{2\xe4\x8d\xb0w\ +!\xa3\xaabrk\xf6\xbd\x12\xb4\x1c\x0c\x9f\xad\xb1A\ +\x9f\x81eEf\xe7\xd0\xf5v\xd6(\xa6m%\xe7+\ +Z5^\x0a\x9eC\xe0Y\x00\xc6\xf60\xcc\x090\xb6\ +\x13\xc9M\x8d9\xa7\xff\xd6\x93\xff\x03t\x87>Y\xca\ +^\x9c'\xa6\x83y<@\xe3@\xc8\x030\x0c]\xcf\ +\xb8\x83Ag\x89q\x0e\xc4\xff&\xc2a)q\xd8A\ +\xd8\xddPSv\xa8\xbf\x94\xe3\x0e`\x00\x03\xf8\xdf\xc4\ +\x7f\x013A\xc7\xceav\x81\xea\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x00\x97\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x00IIDATX\x85\xed\ +\xce\xc1\x09\xc00\x0c\x04A\xc9I\xdfqMnH\x08\ +\xd5\x11\xec\x22\xce\xa0\xcf\xce\xff\x8e5\x13D\xd6\x8c\xac\ +\xa9|\x0ce|\x03\x01\x04\x10@\x00\x01\x04\xb4\x07\xbc\ +\xea\x81\x9b}\x91\xd5\x13\xe0\xfbY\xdb\x7f\xe5\x02\x00\x00\ +\xf4;+\x9a\x0d@M\xe0\x05\x89\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x01\x87\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x019IDATX\x85\xed\ +\xd7\xbfN\xc2P\x14\xc7\xf1\xef\xb9!0Z\x17|\x86\ +\xbe@_\x80\x8aL&\xa8\x1b#\x98\xb0\xd6Y\x1dd\ +\x87\x95DWFe4\x22O\xd0\x17\xe8;\xb0PG\ +\x08\xe18\x94*\x7f]l\xe3\xe0\xfd\x8d77\xfd}\ +\xd2\xbb\x9c\x03\xff=\xb2}\xe0_^\x9f\x09\xdc\x80z\ +\x80\x93QO\x0c\x12*t\xc7\xcf\x8fo\x07\x01\xfeU\ +\xb3#*\xb7\xc0\x0c\x88P>2\xa9\x17\x8e\x00\x17(\ +\xa1t\xde_\x9e\xeew\x00\x95z\xb3f\x8c\xbc\x0a\x8c\ +Y\x16\x1a\xa3a\x7f\x92I\xf9*\xd5z\xbb\x8cY\x0c\ +\x14|Ej\xe9\x9f0\xe9\x05cL\x00\xcc\xf2(\x07\ +\x18\x0d\xfb\x13\x96\x85\x060\x174\xf8\xea\xfd\xbe\xa2\x1e\ +\x10\xe5Q\xbe\x81@\x22\x14o\x0f\x00'\xb37\xff)\ +\xaa1\xc2\xf1>\xc0\x9f\xc4\x02,\xc0\x02,\xc0\x02,\ +\xc0\x02,`\x1d\x10\xaf\xa6\xd7|#\xe2\xa0L\xf7\x00\ +$\x04\xdcj\xbd]\xce\xab;\xf9\xb6\xba\x08\xe1\x0e@\ +\xa1\x0b\x940\x8bA\x1e\x88\xcay\xeb\x04\xb3\x18\x00E\ +Ez\xe9\xf9\xc6brz\xd1z@\xb8\x03\xe6\xc9\xf4\ +\xaaq&\xed\x22\x0e\xa8\x0b\x14\x0f.&i\x92\xd5L\ +\x03\x14o}z\xfdU\x94)B\xa8Ho{5\xb3\ +\xf9\x04\xc3%f/\xe5\x8f+=\x00\x00\x00\x00IE\ +ND\xaeB`\x82\ +\x00\x00\x04\xf5\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00@\x00\x00\x00@\x08\x06\x00\x00\x00\xaaiq\xde\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x04\xa7IDATx\x9c\xed\ +\x9b\xcfo\x15U\x14\xc7\xbfg\xa6\x85\xc2\xca\xe7\xa6!\ +\x10XX\x166M0\xf1\xa5/\x95M\x9b\xa8\x1b\x90\ +\x96\x02\xa2\x11\x08\x7f\x82\x1b\x89mb[\x9b(\x8a\x1b\ +\xfd\x0b4\xb1\xd1\x00m\xf1\x91\xb2\xa9&m \x81<\ +-\x1b\xa3u\x83\x0b\x9a\xb2\xa8\x8b\xd6\x15-\xd0\xb9_\ +\x17}Sf\xe6\xcdt\xe61w~\xd4\xbeO\xf2\x16\ +s\xeey\xef\x9e{\xde\xf7\xdc\xb93\xb9\x17h\xd0\xa0\ +\xc1NF\xa28u\xcf\xb0im\x05'\x14\xd4Y\x81\ +\x14\x09\xec\x17`w\xd2\xc1\xd5\x03\x81'\x02<\x228\ +g\xc0\xb8\xdaR\xc0\xcd\xd9\x1eY\x0f\xfb^h\x02J\ +\x93|\x0b\xe07\x00^\xd5\x12iz\xcc\x03\xf2a\xa5\ +_~\xde\xca\xc9\x08l!\xa5s\x82\x83\x00\xa7\xb1\xfd\ +\x06\x0f\x00\xed\x00\xa7K78\x002\xf0\x8f\x0eL@\ +\xe7$\x06D\xf8Y2\xb1\xa5\x08\xf9y\xe9'|\x1c\ +\xd4\xec\x9b\x99\xaa\xec\xa7=\xe6\x15\x8a\x0c\xc1\xc4\xadC\ +kX\xb8\xfe\xaeXZ\x03\x8d\xc9\x99k4\x1f\xb6\xe0\ + ,\x1c\x13r\x14@\xc1\xed!o\xfb\x95CM\x02\ +\xbag\xd8\xb4\xba\xc2\xdf\xe1\x94\xbd\xe0\x17\x18r\xae\xd2\ ++K\xda#O\x80R\x99\xadP\x1c\x03\xf1\xa6\xc3<\ +\xbf\xa7 G\xbc\x13cM\x09\xac\xad\xe0\x04\xdc5\xbf\ +lR>\xd8.\x83\x07\x80J\xaf,\xc1\x90s\x00V\ +\x1c\xe6\xf6\xea\xd8\x5c\xd4$@A\x9du^Sd\xf8\ +n\xbf\xfc\xa3?\xccd\xa9\xf4\xca\x92P\x86\x9d6\xef\ +\xd8\x00\x9f\x04\x08\xa4\xe82\x98\xb8\xa5=\xba\x94P\xcd\ +\x98r[\xe4u\xafOM\x02\x08\xecw^\x1fZ\xc3\ +\x82\xee\xc0\xd2\xc2'\xf6\x03^\x1f\x1f\x05\xb8Wxy\ +\x9b\xed\xeb\xc1\x1b\xbb\xdf\xea5x!\xb4Ch\xca:\ +\x80(t\x95\xd9\xa6\x94\x1a\x02\xe5\xd4\x86\x85\xe3\xa6\x18\ +\xa3wO\xca\xdfq\x7f;\xf7\x0a(\x8d\xf3\xb0\xb2x\ +\x1b\x94\xf3\x00\xf6n|\xe4\x82E\xde\xe9*\xb3-\xee\ +\xef\xe7:\x01\xdd3l\x82\xc1\x1f\x01\xec\xf3i\xde\xa7\ +,\xf5I\xdc>r\x9d\x80\xc7\xcb\xb8\x04\xa0\xe6\xd6\xf5\ +\x1c9\x1d\xb7\x8f\xdc\xce\x01\xc5Iv\x088\x92t?\ +\xb9T@\xf7\x0c\x9bL\xf0;\x00\xcd[\xf9\x09x=\ +n_\xb9L@\xb8\xf4\x01\x00Oi\x18W\xe2\xf6\x95\ +\xbb\x12\x88,}\x91\x91J\x9f\xcc\xc7\xed/W\x0a\x88\ +*}\x08\xe6\xf6\xbc\x84\xaft\xf4\x99\xab\x04D\x95\xbe\ +\xb2\xe4b\x94\x17\x9eQ\xc8M\x09\xd4#\xfd\xdfN\xcb\ +\x9f\xba\xfa\xcd\x85\x02\xb2\x90\xbe\x8d\x16\x05\xbcq\x83\xaf\ +XTC\x9b\x0b\x13\xe1\x84a\x18\xa3\xf7z\xe5A\x94\ +\xef?^\xc6%\x91t\xa5o\x13[\x01]e\xb6Y\ +\xe4\x1d@.\xc0^\xabS\xce+\x8b\xb7K\xe3<\x1c\ +\xf6\xfd\xe2$;D\xd2\x97\xbeM\xec\x04(\xa5\x86\x10\ +\xb0V\x87\xc9\x1f\xbag\x18\xa8\xb2,\xa5o\x13\x7f\x0e\ +\xd8|D\xf5kCq\xf5_|\x14\xd4\x9c\xc5\xac\xef\ +%\xf9I\x90\x1c)N\xb2\xc3k\xceZ\xfa6\x1a\x12\ +\xc0\xf1\x10\x87]\xa6\xf0[g)\xe4A\xfa6\xf1\x13\ +`\x18_\x02x\xba\xa5\x8f\xa7\x14\xf2 }\x9b\xd8\x09\ +\xa8\xf4\xc9<)\x9f\x86:VK!/\xd2\xb7\xd12\ +\x07\xec}\x19W\x00\xdc\x0fq\xdbe\x82\xdf\x9b\xe0\x18\ +r }\x1b-\x09\x98\xed\x91u\x0br\x11a\xa5\x00\ +\xbc\x06\xe0H\x88O*\xd2\xb7\xd1v\x17\x98\xeb\x97?\ +\x22\x95B\x18)I\xdfF\xebm0b)\x04\x93\xa2\ +\xf4m\xb4&\xa0\x8eR\xf0#U\xe9\xdbh_\x08\xbd\ +p)\xa4,}\x9bDV\x82u\x97B\x06\xd2\xb7I\ +$\x01u\x96B&\xd2\xb7I\xecY r)d$\ +}\x9bD\x1f\x86BK!C\xe9\xdb$\x9a\x80\xd9\x1e\ +Y7LyO\xa4v\x93\x85\x08\x16\x0cC\xde\xcfJ\ +\xfa6\x89?\x0e\xdf\xeb\x95\x07TrT\x80)\x00\xab\ +\x00V\x05\x98\xa2\x92\xa3Q_\x99%I*o\x85+\ +\xa7d\x11\xc0;i\xf4U/\xb9x+\x9c%~\x9b\ +\xa4\x9e8\xaf\xcf\x5c\xa3\x99^8z\xf1\xc6\xee\x1d\x1b\ +\xe0\xbfI\xea\x91\xf3\xfaa\x0b\x0e\xea\x0f-\x1d|b\ +_\xf4\xfa\xf8(\x80s.\x83\x85cz\xc3J\x0f\xe3\ +\x19\x8e\xbb-\xac\xb9%\xd7$\xc0\x80q\xd5y-\xe4\ +h\xa9\xccV\xdd\xc1%M\xa9\xccV\x0a]\x0b1\xef\ +\xd86l\x1eZ\x0a\xb8\x09\xe0/\x87\xa9\x00\xc5\xb1\xed\ +\x94\x84\xcd\xcd\xd2\xee\x1d\xe3\xf3\xd5\xb1\xb9\xa8k\xbb\xbc\ +P\x86U3\xa6\xf2\xbc]\xdex\x86\xe3\xd5\x7f\xfe\xc5\ +\xb6\xcb\xdbtNp\xf0\x7fq`\x02\x00D\x06+'\ +\xe5\xb2_S\xe0:\xe0\xd7~\x5c\x86\xc8`rQ\xa5\ +\x02\x01\x19\xa8\xf4\xe1\x8b \x87\xa8\x87\xa6\xbe\x06\xd0\xae\ +5\xb4\xe4\x89th\xaa\xeecs\xd5-\xe7\x07\xf2x\ +l\x0e\xc0\x22\xc0\xfb\xf5\x1c\x9bk\xd0\xa0\xc1\xce\xe6?\ +\xb77\xe9\x8b\xf9]V\x0e\x00\x00\x00\x00IEND\ +\xaeB`\x82\ +\x00\x00\x02>\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xf0IDATX\x85\xe5\ +\x961hSQ\x14\x86\xbf?}\xadRA1\x82\x08\ +...\x0e\xe2\xd0\xa0]\x1c+T\xba\x08\xa9S\x05\ +\x11M\x96\xb4\xa9\xe0&\x8a\xe2&\xb4M+\xd8\x87\x83\ +`'\x1bp)\x0e\xea\xe6\xa2\xf2:H\x07\x17A\x1d\ +\x14A\xa8`\xa1E\xdb\xe4\x1d\x87\xa4N\x82\xef\xde\x5c\ +\x22\xe8\xd9\x1e\xdc\xf3\xff\xdf=\xef\xdcs/\xfc\xef\xa1\ +\xd0\x82\x83\x17\xa6\xf2[Q\xef;0[\x8e\xc7\xf7\xfe\ +i}\x14\xd2\xfc\xe8\xd8\xed]\x8d(z\x0c\xb6'k\ +N.\x94\xf9\x91\xe2\xf5\xbe\xbe\xfe\x1d\x8f\x0cN\xb8\xe4\ +\x05\x01(\x16\x17{\xfa\xf3\xfb\x1e\x00C\xae\xb9\x01\x00\ +L\xef\xf3\x9f\xef\x00g10,\xed*@\xa14w\ +\x13T\x06\xc3d\xa9\x90u\x0d`\xe0\xd2l\xd5\xe0*\ +\x80I\xce\xe6\x1d\x01\x0c\x94kc\x88i\x00\x83T\x86\ +\xb3\xb97@\xa14;\x82\xe9~\xfb3\x15~\xe6^\ +\x00\x85\xd2\xccI\x83E\xa0\x87\x96\xb1\xb7\xb93@\xe1\ +\xe2\xf41#\xb7\x04\xecl\x1b;u\xfc\xef\x22\xf3$\ +<^\xaa\x1dN\xd1\x13`\xb7\x81)\x809d\xac\xc0\ +`y\xea`\xd3\xf4\xcc`?\x16\xce\x1c2V`\xcb\ +\xa2\x8f\xbf\xae-\x853\x87\xac=`\xac\x844u\x06\ +\xe8\xcd5\x86\x0d>\xb4a\x82]`\x99\x01^\xcc_\ +\xfe\x14aC\x82/\xb4\xc6]0\x88\xccB\xaf\xe2\x89\ +\xb7\xa4\xcdS\xc0\x9aZ\x0f\x99 \x10N\x22\xc9\xbd\xc9\ +\xd7\x22\x1d\x01\xbe\x13\x08\xc2Y \x89\xab\xcf\x05\xa3@\ +\x13\x10\xea\xecY\xe7\xb5\x83$\x1e_Bv\x1e\xd8n\ +Jo\x08\xef\x12.\xcfO,\x08U\xb7u\xcc\xb3\x12\ +\x1d\xfd\xc3$\xae\xd4\x04\xb7\x00d\xe6\x05\xd1q\x13%\ +q\xe5\x9a\xc4]\x10J\xc9\xb5&u\x17\x01@vh\ +\xf5@\x05x\x88@\xc8I3\xc8Y\xae\xd7G\x9b\x1b\ +_W\xcf\x01O]s\x83M\xb47\xf5\x1b\x9b\x9b\x1b\ +?\xce\x08^\xfe\x15\x00\x80\x95\x85+\xebQ\xa3q\x1a\ +X\x03}\x0b\xa9\xfd\xef\xc6O\x112\x94\x0cok \ +\xde\x00\x00\x00\x00IEND\xaeB`\x82\ +\x00\x00\x02\x0a\ +\x89\ +PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\ +\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\ +\x00\x00\x00\x09pHYs\x00\x00\x10M\x00\x00\x10M\ +\x01g\x8c\x01\xe0\x00\x00\x01\xbcIDATX\x85\xed\ +\x94=k\x14a\x14\x85\x9f\xf3n\x84\x85\x80h#\x83\ +\x9b\x9d7\x0b\xfe\x00\x7f\x81\x9d(\x12\xb4\xd1RH+\ +A\xf2\x1f\xf4\x0f\x88\x16\x966\x16\x8aXi\xa1XZ\ +h\xa9\xbd\x98\xcc\xecF\xd6Jc\x120\xc8\xce\xb1\xd8\ +\x0f\x96|\xed\xce\xfa\x91f\x1e\x18\xb83\x5c\xce9\xdc\ +y\xef\x0b\x15\x15\x15\x15\xc7\x8c\x86\xc5z\x96\x7f\x03\x9d\ +\xfa?\xb6\xfe\xbe\x18\xd3\xd3\x00a\xf4i\xac\xfe\xe7\xf6\ +c^\xa3b.\xa8\x85x\xdf\xef0\x98\x02\xe8\xfd\x95\ +\xc7\x14\xd8C\xabwsA\xad\xe1\xcb\xe8\x17\x00t\xbb\ +\xdd\xf9\xdd\xdd_\xcf\x0d\x97\x06I\x0b\x81\xf9\x03\x0c\x12\ +\x0e 0\xaf\xea\xf5\x13\xd7\x93$\xd9\xd97\x01\x80$\ +Iv\xb6\xb66\xaf\x0a=\x1d\xa4\x0b{C\x96\xb4W\ +_C`=\xd9\xde\xde\xbc6n\xcea\xe2\xb6kY\ +\xb6\xf1\x00\xf9\x96m$\x15\x94\x9c\x84@\x85\x1d$\x81\ +\xf50\xc6\xc6mI\xbd\xbd}\x07\x1e\xab\x0d\x89\xf4.\x98h\x06\xa8\xbc$\ +\x84\xad\xbdB3\x93\xf3\xba<\x96\xe6\xc5\x10\xcd\x00\x02\ +\x16t\xea\xc2\x8e\xd3]\xbd\xbf\xfds\x8d\xc7\xd2\x1d\x94\ +\xb8K@\xb0p\x8bc\xbd{\xda\xbe\x0e)\xd8\x19\xe4\ +RHQ\x03\x9c\x99 \xf2\xa1j\xcb>\x9f@\xfb?\ +IS\x04\x05\xabrI \x0fT\xa6u \x89\xfe\xbf\ +\x90j\x17\x00i\x0a\xe7\x9a\xf4B\xb5\xa9\x87S\xc5\xe0\ +#\x99\x01\x90|\xa7E\x88z\xa3\xdaR=Y\x1c%\ +\xd2\x19\x80\xfei\xd1c\x82\x11\xf4A\xf5c\xdd\x952\ +\x96?\xc5S\x0b\x12\xd0\xea\xee\xf0w.\x135s\xdb\ +\xb4*\xa9\xe3In\x00\x00\x80\x9e\x99@\x5ca\xa5\xf9\ +jK7\xa5\x0ce8\x06`\xadyby&\x5c#\ +\xe8\xf8\xb6\xa6\xaeK\x15\xc7\xd0\x0c\xe8#\x9f\x09\xd7\x16\ +\xd4\xc2\xb6\x966\xa5\x88`\xc8\x06\x00}\x13T>-\ +^_@\xc7&\xe6uel\xf5\x0c\x0c\x00\x00Z\xa7\ +y\x02nQWs\xdb\xdf\xd1\xba\x98\xca\x99\x18\xb0\xda\ +<\x95L p\xc7\xb9\xab\xf4a\xcc\xe6)\x1b\x03V\ +\xf15O\xf7v\xcf\xd8\xb7\xf0\x8c\xa2\xc4\x9a\x9b\x01\x80\ +\xafy\x02\x1f\xa8\xdcl_\x8c\xd1A\xe6h@\xbf\x8d\ +.\xd5E\x82OTZ8\x18Z*O\x03\x00\x80t\ +\x9b'\xeah\xa5\xa9\xfd!e\xf25\x00\x80\x04[\xae\ +\x08\xa4^\x9bhj_(\x8d\xac\x0d\xa0\xef\xc8\x0c\x10\ +\xd4+\xa14\xb26\x00\x00\xe8/{\xc1\xb6\xc5\xbc\x0d\ +\xe8g\xef\xc4(\xe8\xedP\x12\xd9<\x9d\xf5\x22\x8d\xb9\ +\xd7\xf8\xd8r\xc3\xbc\x1aJ\x22\xe3\x19\xe0M\xfe\xe9v\ +\x83\xc1\x92\x07r4\x80\x80\x08\xe3\xbe\xb9\xd7\xcb\xed:\ +\x8e\x84\x96\xcb\xce\x00\x09\x86*g\xaf\xf7\xda'\xcc\xe3\ + }/`/\x89\xbc\x0c \x0cK\xb7\x9e\xc0'\xbd\ +S\xe6A\x1cv\x9e\x1b\x04!'\x03\x0c\x9c;\x8f/\ +\xd8\xe3\xd4\xca~\x9e\x8f%\x9a\xc9. \xe3\xd9\xf1O\ +\xf4z\xbcge\x8a\xe7b*\x0f\xdd\x00\x81,O{\ +\x08\xdfa\x9cw\xaf\xd4y6\xb6\xfeP\x97@?y\ +\xa7\xcf\xff\x91\x86;\xdb{\xf8S\x8a\x18\x86g\x80\xe0\ +K\xfe\x8c\xb5\xdc\xb5T\xe3\xc9Ta\x0c\xc5\x00\x09\x04\ +K\xda\xc2\xef\x10ww\xf6\xf1\xeb\x94\xb1$\xaf\x01\x02\ +\xc8r\xf2\xc0y\x18\xd6\xdb5.\xa5\x8e'\xe9\x0c\x90\ +@\xca\xd1\x14\xc9\xfb\xdb5.\xa4\x8ce\x8dt3\x80\ +\x84g\xcd\x03\xe4\xa3K5~\x94,\x8e\x12\xc9f\x80\ +d\xdd\xe6\x86<\xd4\xae\xf1\xcdT1\xf8Hc\x00a\ +\xe8l\xf5z\xa9\xbd\x17C\xffL&\x85\x01\xee\x11W\ +zw\xb9f\x9e\x8c\xd1\xdc\x0cJ\x5c\x03\xfa\xd5\xbe|\ +\xc4\x9d]\x7f\xb5y$\x87\xe4\x81\xb8\x1fJ\xfa\x9a\x9b\ +\xc5\xf5gy\xdf\xe2\x9d\xec\xc5\xd2\x1d\x94h\xbb\x80s\ +\xbe\x07\xbe\xc2:\xeeY\xac\xb3\x1bK\xf3bH\xb5\x0b\ +|;\x06N\xb6w\xf3\xd7Dz\x17L\x0a\x03~\xe8\ +\xf5\xb8\xf3\xcb:\x7fN\xa050!\x7f\x98\xf0=\xc1\ +\xff\x85\xe0\xae\x95)~\x1fJ'4\xc1j\x00]3\ +\x7f\xb3\xe2d\xa7\xc1oBi\xc4 \xe4\x12\xf8\xeb\x99\ +\x1d!K\xee\xed4\xd8\x098~\x14B\xfe4u\x14\ +@\x01\xa0\x80\xf8\x5c\xa7\xc6\xcf\x82\x8d=b\xc4\x88\x11\ +\x91\xf8\x03n\xfeN~\xe0\xc6%S\x00\x00\x00\x00I\ +END\xaeB`\x82\ +" + +qt_resource_name = b"\ +\x00\x05\ +\x00o\xa6S\ +\x00i\ +\x00c\x00o\x00n\x00s\ +\x00\x0f\ +\x0c\xe2hg\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x0fy\xa3\xc7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x13\ +\x0bNW\xa7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00.\x00p\ +\x00n\x00g\ +\x00\x1a\ +\x02\xb6\xb5\xa7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x15\ +\x06\xf8\x08\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x09.\xa9G\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00!\ +\x0e\xf17g\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\ +\x00\x1b\ +\x0a\x19\xf4\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00p\x00r\x00e\x00s\ +\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x0dx\xb6\x87\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\ +\x00g\ +\x00+\ +\x03\xd2\xba\xc7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\x00r\x00e\x00s\ +\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x05\x12\xcfg\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00p\x00r\x00e\x00s\ +\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x08!\xa7\xc7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x08.\xd3g\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x01u\xcc\x87\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0fZ\xb4\xa7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x03\xf7\x18\x07\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x04\x9c\xa4\xa7\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x07\xac9\xa7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0f~o\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00d\x00i\x00s\x00a\ +\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x04\xb3L'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x1c\ +\x0f\xd0\x9cg\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x01\xc7%G\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x15\ +\x0c`\x8e'\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\ +\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0b\xf3\xab'\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x06ud\x87\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x01\xe0J\x07\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x01\x87\xaeg\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x00\x10\xb9g\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00d\x00i\x00s\x00a\ +\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0a\x14\xedG\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00)\ +\x09\x81\xd3g\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\x00o\x00c\x00u\ +\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x05(\x8d\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x0f\ +\x00\xd6%\xc7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00.\x00p\x00n\x00g\ +\x00\x22\ +\x08\x8a\x08'\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\ +\x00g\ +\x00\x15\ +\x03\x1c\x93\x87\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00 \ +\x07NZ\xc7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x00D\xa0G\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00f\x00o\x00c\x00u\x00s\x00.\ +\x00p\x00n\x00g\ +\x00\x19\ +\x0a'x\x07\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0a\xa0\x05G\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x08\xb5wg\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0c\xeb_g\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00f\x00o\x00c\x00u\x00s\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00!\ +\x05p0'\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\ +\x00\x14\ +\x0b-\x81\x07\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00f\x00o\x00c\x00u\x00s\x00.\ +\x00p\x00n\x00g\ +\x00\x11\ +\x08\xfcI\xe7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\ +\x00'\ +\x0c\xeb\xe5g\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x02H\x15'\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x09/\xda\x87\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x10\ +\x00Ub\x07\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x03\x949g\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00%\ +\x08\x07~\x87\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\ +\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0c\xd5Zg\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x04\xa2\xb3'\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x15\ +\x0f\xac\xe3\xc7\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\ +\x00.\x00p\x00n\x00g\ +\x00\x15\ +\x0bx\x08\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00\x15\ +\x0a\x12Jg\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x0d\xfd\xa2\x07\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x07\x88%\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x22\ +\x01A\xee\x87\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\ +\x00g\ +\x00\x0c\ +\x0b\xd0z\xe7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0c3\x94'\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x07\xec\xd1\xc7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00.\ +\x00p\x00n\x00g\ +\x00$\ +\x04\x0b\x8d'\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\ +\x00p\x00n\x00g\ +\x00\x19\ +\x076\x1bG\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x08\xd2\xa3'\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00$\ +\x05\x94\xa0G\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00.\ +\x00p\x00n\x00g\ +\x00\x16\ +\x0f5\xfb\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00#\ +\x07\x14m\x87\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\ +\x00n\x00g\ +\x00\x1c\ +\x00\xf3&'\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x00O)\xc7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x00.\x0a\x07\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00'\ +\x0e=\xd7\xc7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x0e5\xf3\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x11\ +\x05*pg\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00.\x00p\x00n\x00g\ +\ +\x00\x18\ +\x07\x86N'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x0f\x96q\x87\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x07\x83\xfe'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x05u\xad'\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x06\xba\x02\xa7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x0a\x1a\xd6G\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00,\ +\x0c\xa4ZG\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\x00i\x00s\x00a\ +\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x09\x0d\xa6\xc7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x00l\xa3\xa7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00#\ +\x03C\xb9g\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00@\x002\x00x\x00.\x00p\ +\x00n\x00g\ +\x00\x17\ +\x0e\xfe2G\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00f\x00o\x00c\x00u\x00s\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x0f\xd74g\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x06m\x9b'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00*\ +\x0f\xc4\xf7\x07\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0e\x19\x8b\xc7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00f\x00o\x00c\x00u\x00s\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x04\xf82\xc7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\ +\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x0e\x0c\xda\xa7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x09\x07\x81\x07\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00 \ +\x0e\xfevG\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x01\xe9\xfd\xe7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00\x13\ +\x00\xcf\x5c\xc7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00@\x002\x00x\x00.\x00p\ +\x00n\x00g\ +\x00\x18\ +\x07\xa5\xb1'\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x04\xb5\x9dG\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x1f\ +\x0bHP\x87\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x044\xf0\xc7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x0f\ +\x06\x16%\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x055\xb6g\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0e&\x93\xe7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0c$\xec\x07\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x008\x7f\xa7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x0c\x09f\x07\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x09^\xb0\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x0b#!g\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\ +\x00p\x00n\x00g\ +\x00\x0f\ +\x0f,$\xc7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x0a\xd8\x81'\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0d\x9d\x97G\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x09\xc8\xa4\xa7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x0az\x87g\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00f\x00o\x00c\x00u\ +\x00s\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0e\xbc\xc3g\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x04\xb1\x94'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x0f\ +\x06S%\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00.\x00p\x00n\x00g\ +\x00\x22\ +\x04\x9a\x03g\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x16\ +\x05z\xd3g\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x00O\xcb\xe7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0e\x98\x18'\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00c\x00l\x00o\x00s\x00e\x00_\x00f\x00o\x00c\x00u\ +\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x07P+\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x11\ +\x0b\xda0\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\ +\x00\x15\ +\x0d\x86\xf9\xe7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\ +\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x01\x0e\xe5\xa7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x04d\xf7\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x02Oj\xa7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x00\x06=\xc7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x10\ +\x05>9g\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00$\ +\x05\x98\x88\x87\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00&\ +\x0f5\xf0\xa7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00)\ +\x08g\xa4\xa7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\x00i\x00s\x00a\ +\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x02\x0d\xa6g\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x07\xb7\xa1G\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x04\xce\xfag\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x07\x09\xf8'\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00\x13\ +\x05v\x1eg\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00.\x00p\ +\x00n\x00g\ +\x00\x17\ +\x07\x06=\xa7\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x06\xa7ZG\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00%\ +\x06lG\xe7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\ +\x00.\x00p\x00n\x00g\ +\x00\x13\ +\x0c$9G\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\ +\x00n\x00g\ +\x00\x1c\ +\x02uQ\x87\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x06\xe9\x8fg\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00f\x00o\x00c\x00u\x00s\x00.\ +\x00p\x00n\x00g\ +\x00\x11\ +\x0a\xe5l\x07\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00.\x00p\x00n\x00g\ +\ +\x00\x17\ +\x0d\x0d(\xa7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00#\ +\x03\xa5\x91G\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\ +\x00n\x00g\ +\x00\x19\ +\x0bYn\x87\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0bFr\x87\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x0a\xfb-'\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00'\ +\x0d\x0d\x92\xa7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x11\ +\x09\xcb\xcc\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00.\x00p\x00n\x00g\ +\ +\x00\x18\ +\x03\xaeb\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0f\x9a\xe5\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0f\x1e\x9bG\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x05\x11\xe0\xe7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x04s_G\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x0d3-\xa7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00d\x00i\x00s\ +\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x08?\xdag\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0dl\x22\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00f\x00o\x00c\ +\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x11\ +\x08\x8f\x96\xa7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\ +\x00\x22\ +\x00\xa7\x99G\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00v\x00e\x00r\x00t\ +\x00i\x00c\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00&\ +\x04$\xf6\xe7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\x00o\x00c\x00u\ +\x00s\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x00\xc1#g\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x13\ +\x08\xc8\x96\xe7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00.\x00p\ +\x00n\x00g\ +\x00!\ +\x0aQ_G\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\ +\x00\x0f\ +\x00o\x04\x87\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00.\x00p\x00n\x00g\ +\x00!\ +\x01\xf6\xa2g\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\ +\x00\x15\ +\x04\x90\x0a\xc7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00$\ +\x05\xed\xfa\xe7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00\x1b\ +\x02\xd4\x90\x87\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0c\xa5\xc5'\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0d\xdf\xcf\xa7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00g\x00r\x00i\x00p\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x0d\ +\x0br=\x07\ +\x00b\ +\x00a\x00s\x00e\x00_\x00i\x00c\x00o\x00n\x00.\x00p\x00n\x00g\ +\x00\x12\ +\x00h\xca\xe7\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00@\x002\x00x\x00.\x00p\x00n\ +\x00g\ +\x00\x0f\ +\x01@-\xa7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00u\x00p\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x07[\xb0g\ +\x00l\ +\x00i\x00n\x00e\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x0c\xa4o\xa7\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x04\x8dH\xc7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00d\ +\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00#\ +\x06\xf2\x1aG\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\ +\x00n\x00g\ +\x00\x1c\ +\x01\x15Q\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00f\ +\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x0a n\x07\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00u\x00n\x00d\x00o\x00c\x00k\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00&\ +\x07K\x88\xe7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00\x1a\ +\x028%\x07\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x06`9\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0b\x9dMg\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00l\x00i\x00n\x00e\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1b\ +\x0b\xea\x1b\xe7\ +\x00w\ +\x00i\x00n\x00d\x00o\x00w\x00_\x00m\x00i\x00n\x00i\x00m\x00i\x00z\x00e\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x0f\x80O\xa7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00 \ +\x09\xd7\x1f\xa7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00i\x00n\x00d\x00e\x00t\x00e\x00r\x00m\ +\x00i\x00n\x00a\x00t\x00e\x00_\x00f\x00o\x00c\x00u\x00s\x00.\x00p\x00n\x00g\ +\x00\x1c\ +\x0c\xfb\xa0G\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00_\x00p\x00r\x00e\ +\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x0e\ +\x08\xfa\xe1'\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00.\x00p\x00n\x00g\ +\x00)\ +\x09\xe4\xb0\x07\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00v\x00e\x00r\x00t\x00i\x00c\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x06e\x89\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x0c\xd2\xb9\x87\ +\x00l\ +\x00i\x00n\x00e\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0b\x9d\x16g\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00m\x00o\x00r\x00e\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x03\x9fr\x87\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00p\x00r\x00e\x00s\x00s\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x19\ +\x0b\x8a\x15\xe7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00(\ +\x0fcS\xc7\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00s\x00e\x00p\x00a\x00r\x00a\x00t\x00o\x00r\ +\x00_\x00h\x00o\x00r\x00i\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\x00r\x00e\x00s\ +\x00s\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x14\ +\x05\xe4-\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00c\x00l\x00o\x00s\x00e\x00d\x00@\x002\x00x\x00.\ +\x00p\x00n\x00g\ +\x00\x11\ +\x01\xf6\xffg\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\ +\x00\x17\ +\x0f\x18E\x87\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x0e1C\xa7\ +\x00t\ +\x00r\x00a\x00n\x00s\x00p\x00a\x00r\x00e\x00n\x00t\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x07\x8b\xec\xe7\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00d\x00i\x00s\x00a\x00b\ +\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x15\ +\x06b\x08'\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00o\x00p\x00e\x00n\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00.\x00p\x00n\x00g\ +\x00\x17\ +\x0f\xff\xfc\x07\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00_\x00d\x00i\x00s\x00a\x00b\x00l\ +\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1e\ +\x04<\x09\xc7\ +\x00r\ +\x00a\x00d\x00i\x00o\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\x00p\ +\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x0e\ +\x0dNq\x87\ +\x00b\ +\x00r\x00a\x00n\x00c\x00h\x00_\x00e\x00n\x00d\x00.\x00p\x00n\x00g\ +\x00\x1f\ +\x0a\xae'G\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00u\x00n\x00c\x00h\x00e\x00c\x00k\x00e\ +\x00d\x00_\x00d\x00i\x00s\x00a\x00b\x00l\x00e\x00d\x00.\x00p\x00n\x00g\ +\x00\x1d\ +\x08\xe1\xf6\xc7\ +\x00c\ +\x00h\x00e\x00c\x00k\x00b\x00o\x00x\x00_\x00c\x00h\x00e\x00c\x00k\x00e\x00d\x00_\ +\x00f\x00o\x00c\x00u\x00s\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +\x00\x16\ +\x06\x14\xad\xc7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00l\x00e\x00f\x00t\x00_\x00p\x00r\x00e\x00s\x00s\x00e\ +\x00d\x00.\x00p\x00n\x00g\ +\x00\x0e\ +\x06\x0c\xe6\x07\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00d\x00o\x00w\x00n\x00.\x00p\x00n\x00g\ +\x00&\ +\x0f\xfb\x22\x07\ +\x00t\ +\x00o\x00o\x00l\x00b\x00a\x00r\x00_\x00m\x00o\x00v\x00e\x00_\x00h\x00o\x00r\x00i\ +\x00z\x00o\x00n\x00t\x00a\x00l\x00_\x00p\x00r\x00e\x00s\x00s\x00e\x00d\x00@\x002\ +\x00x\x00.\x00p\x00n\x00g\ +\x00\x18\ +\x06C\xc6\xe7\ +\x00a\ +\x00r\x00r\x00o\x00w\x00_\x00r\x00i\x00g\x00h\x00t\x00_\x00f\x00o\x00c\x00u\x00s\ +\x00@\x002\x00x\x00.\x00p\x00n\x00g\ +" + +qt_resource_struct = b"\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\ +\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x00\x00\x00\x02\x00\x00\x00\xd0\x00\x00\x00\x02\ +\x00\x00\x00\x00\x00\x00\x00\x00\ +\x00\x00\x1b\x90\x00\x00\x00\x00\x00\x01\x00\x01K\x0b\ +\x00\x00\x01zwURm\ +\x00\x00\x06\x12\x00\x00\x00\x00\x00\x01\x00\x00J2\ +\x00\x00\x01zwUR}\ +\x00\x00\x0fL\x00\x00\x00\x00\x00\x01\x00\x00\xae\x9e\ +\x00\x00\x01zwURi\ +\x00\x00\x16\xdc\x00\x00\x00\x00\x00\x01\x00\x00\xfbW\ +\x00\x00\x01zwUR\x81\ +\x00\x00\x08\x00\x00\x00\x00\x00\x00\x01\x00\x00ZF\ +\x00\x00\x01zwURQ\ +\x00\x00\x0f\x14\x00\x00\x00\x00\x00\x01\x00\x00\xac\x7f\ +\x00\x00\x01zwUR\x85\ +\x00\x00\x19\xc6\x00\x00\x00\x00\x00\x01\x00\x01-g\ +\x00\x00\x01zwURe\ +\x00\x00\x0an\x00\x00\x00\x00\x00\x01\x00\x00x\xf5\ +\x00\x00\x01zwUR}\ +\x00\x00%\xfe\x00\x00\x00\x00\x00\x01\x00\x01\xccB\ +\x00\x00\x01zwURy\ +\x00\x00\x122\x00\x00\x00\x00\x00\x01\x00\x00\xc9X\ +\x00\x00\x01zwURi\ +\x00\x00$L\x00\x00\x00\x00\x00\x01\x00\x01\xb2h\ +\x00\x00\x01zwUR}\ +\x00\x00#\x00\x00\x00\x00\x00\x00\x01\x00\x01\xa6\x9e\ +\x00\x00\x01zwURq\ +\x00\x00#\x9c\x00\x00\x00\x00\x00\x01\x00\x01\xa8\x0e\ +\x00\x00\x01zwUR}\ +\x00\x00\x14\xfe\x00\x00\x00\x00\x00\x01\x00\x00\xe9\x16\ +\x00\x00\x01zwURy\ +\x00\x00\x07\x1c\x00\x00\x00\x00\x00\x01\x00\x00V\xac\ +\x00\x00\x01zwURU\ +\x00\x00\x0e\xd6\x00\x00\x00\x00\x00\x01\x00\x00\xab\xac\ +\x00\x00\x01zwUR\x81\ +\x00\x00\x1a\xda\x00\x00\x00\x00\x00\x01\x00\x01\x00\x00\x00\x00\x00\x01\x00\x01z\xec\ +\x00\x00\x01zwURi\ +\x00\x00 X\x00\x00\x00\x00\x00\x01\x00\x01\x88R\ +\x00\x00\x01zwURm\ +\x00\x00\x17\x8c\x00\x00\x00\x00\x00\x01\x00\x01\x00\xb8\ +\x00\x00\x01zwURM\ +\x00\x00\x09Z\x00\x00\x00\x00\x00\x01\x00\x00l\xb2\ +\x00\x00\x01zwURE\ +\x00\x00 \x1e\x00\x00\x00\x00\x00\x01\x00\x01\x84\xec\ +\x00\x00\x01zwUR\x81\ +\x00\x00\x15\x8a\x00\x00\x00\x00\x00\x01\x00\x00\xf4\xd5\ +\x00\x00\x01zwURa\ +\x00\x00\x00p\x00\x00\x00\x00\x00\x01\x00\x00\x00\xe8\ +\x00\x00\x01zwURe\ +\x00\x00\x1f\xe6\x00\x00\x00\x00\x00\x01\x00\x01\x81\x15\ +\x00\x00\x01zwURm\ +\x00\x00%\xde\x00\x00\x00\x00\x00\x01\x00\x01\xc7V\ +\x00\x00\x01zwURM\ +\x00\x00\x0b\xaa\x00\x00\x00\x00\x00\x01\x00\x00\x87{\ +\x00\x00\x01zwURU\ +\x00\x00+\x0c\x00\x00\x00\x00\x00\x01\x00\x01\xf6\xc2\ +\x00\x00\x01zwURA\ +\x00\x00*\xa4\x00\x00\x00\x00\x00\x01\x00\x01\xf3\xdb\ +\x00\x00\x01zwURY\ +\x00\x00(\x8c\x00\x00\x00\x00\x00\x01\x00\x01\xe0=\ +\x00\x00\x01zwURU\ +\x00\x00\x0c\xca\x00\x00\x00\x00\x00\x01\x00\x00\x8f\xb6\ +\x00\x00\x01zwURI\ +\x00\x00\x1a\x82\x00\x00\x00\x00\x00\x01\x00\x016\xd2\ +\x00\x00\x01zwURQ\ +\x00\x00(\xc0\x00\x00\x00\x00\x00\x01\x00\x01\xe0\xc8\ +\x00\x00\x01zwUR\x81\ +\x00\x00\x05\x22\x00\x00\x00\x00\x00\x01\x00\x00>\xbf\ +\x00\x00\x01zwUR]\ +\x00\x00\x17\x14\x00\x00\x00\x00\x00\x01\x00\x00\xfc)\ +\x00\x00\x01zwUR]\ +\x00\x00\x1e\xa6\x00\x00\x00\x00\x00\x01\x00\x01q-\ +\x00\x00\x01zwURM\ +\x00\x00\x16\xa4\x00\x00\x00\x00\x00\x01\x00\x00\xfa\xdc\ +\x00\x00\x01zwURe\ +\x00\x00\x0c\xe8\x00\x00\x00\x00\x00\x01\x00\x00\x91\xc7\ +\x00\x00\x01zwURE\ +\x00\x00\x04\xf2\x00\x00\x00\x00\x00\x01\x00\x00<\x96\ +\x00\x00\x01zwURI\ +\x00\x00\x11\x98\x00\x00\x00\x00\x00\x01\x00\x00\xc7&\ +\x00\x00\x01zwURu\ +\x00\x00&\x8a\x00\x00\x00\x00\x00\x01\x00\x01\xd1\xab\ +\x00\x00\x01zwURe\ +\x00\x00%r\x00\x00\x00\x00\x00\x01\x00\x01\xb8\xb1\ +\x00\x00\x01zwURM\ +\x00\x00*b\x00\x00\x00\x00\x00\x01\x00\x01\xf3M\ +\x00\x00\x01zwURe\ +\x00\x00\x0b\x16\x00\x00\x00\x00\x00\x01\x00\x00}*\ +\x00\x00\x01zwURi\ +\x00\x00\x00\x10\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ +\x00\x00\x01zwURy\ +\x00\x00\x08\xde\x00\x00\x00\x00\x00\x01\x00\x00kE\ +\x00\x00\x01zwURQ\ +\x00\x00\x09\xb0\x00\x00\x00\x00\x00\x01\x00\x00sS\ +\x00\x00\x01zwURy\ +\x00\x00)t\x00\x00\x00\x00\x00\x01\x00\x01\xeb\xe4\ +\x00\x00\x01zwURQ\ +\x00\x00\x1ff\x00\x00\x00\x00\x00\x01\x00\x01\x7f\xda\ +\x00\x00\x01zwURQ\ +\x00\x00 \x94\x00\x00\x00\x00\x00\x01\x00\x01\x8cY\ +\x00\x00\x01zwURu\ +\x00\x00\x22,\x00\x00\x00\x00\x00\x01\x00\x01\x9e\xf8\ +\x00\x00\x01zwURe\ +\x00\x00-6\x00\x00\x00\x00\x00\x01\x00\x02\x10t\ +\x00\x00\x01zwURQ\ +\x00\x00\x22\xa4\x00\x00\x00\x00\x00\x01\x00\x01\xa1\x0a\ +\x00\x00\x01zwURM\ +\x00\x00\x01\xc4\x00\x00\x00\x00\x00\x01\x00\x00\x12=\ +\x00\x00\x01zwURI\ +\x00\x00\x1a\xaa\x00\x00\x00\x00\x00\x01\x00\x018c\ +\x00\x00\x01zwURI\ +\x00\x00\x18\x1e\x00\x00\x00\x00\x00\x01\x00\x01\x10G\ +\x00\x00\x01zwUR]\ +\x00\x00%\xaa\x00\x00\x00\x00\x00\x01\x00\x01\xc5\x8b\ +\x00\x00\x01zwUR\x81\ +\x00\x00\x0c\x0a\x00\x00\x00\x00\x00\x01\x00\x00\x89\xa1\ +\x00\x00\x01zwURE\ +\x00\x00\x14\x14\x00\x00\x00\x00\x00\x01\x00\x00\xdb\xcd\ +\x00\x00\x01zwURI\ +\x00\x00\x13\xac\x00\x00\x00\x00\x00\x01\x00\x00\xd3\xc8\ +\x00\x00\x01zwURA\ +\x00\x00\x16l\x00\x00\x00\x00\x00\x01\x00\x00\xfaK\ +\x00\x00\x01zwURq\ +\x00\x00,$\x00\x00\x00\x00\x00\x01\x00\x02\x01\xcd\ +\x00\x00\x01zwURy\ +\x00\x00\x0f\xce\x00\x00\x00\x00\x00\x01\x00\x00\xbai\ +\x00\x00\x01zwURM\ +\x00\x00\x0fz\x00\x00\x00\x00\x00\x01\x00\x00\xb90\ +\x00\x00\x01zwURm\ +\x00\x00\x1a\x08\x00\x00\x00\x00\x00\x01\x00\x01.\xfe\ +\x00\x00\x01zwUR}\ +\x00\x00\x18\xc2\x00\x00\x00\x00\x00\x01\x00\x01\x15I\ +\x00\x00\x01zwURi\ +\x00\x00\x01@\x00\x00\x00\x00\x00\x01\x00\x00\x0a\xb5\ +\x00\x00\x01zwURq\ +\x00\x00\x12\xb2\x00\x00\x00\x00\x00\x01\x00\x00\xcb\x05\ +\x00\x00\x01zwURE\ +\x00\x00\x14\x8a\x00\x00\x00\x00\x00\x01\x00\x00\xe2\xe2\ +\x00\x00\x01zwUR]\ +\x00\x00+\xf0\x00\x00\x00\x00\x00\x01\x00\x01\xff\x9c\ +\x00\x00\x01zwURE\ +\x00\x00!\x80\x00\x00\x00\x00\x00\x01\x00\x01\x94\x04\ +\x00\x00\x01zwURi\ +\x00\x00\x17\xba\x00\x00\x00\x00\x00\x01\x00\x01\x02\xe6\ +\x00\x00\x01zwURI\ +\x00\x00\x1cB\x00\x00\x00\x00\x00\x01\x00\x01a\x0d\ +\x00\x00\x01zwURy\ +\x00\x00\x0eX\x00\x00\x00\x00\x00\x01\x00\x00\xa7j\ +\x00\x00\x01zwURU\ +\x00\x00\x03,\x00\x00\x00\x00\x00\x01\x00\x00\x1d\xf1\ +\x00\x00\x01zwURi\ +\x00\x00+D\x00\x00\x00\x00\x00\x01\x00\x01\xfa\xf4\ +\x00\x00\x01zwURu\ +\x00\x00\x004\x00\x00\x00\x00\x00\x01\x00\x00\x00l\ +\x00\x00\x01zwURe\ +\x00\x00\x04\x18\x00\x00\x00\x00\x00\x01\x00\x003\x0a\ +\x00\x00\x01zwUR}\ +\x00\x00(\xfc\x00\x00\x00\x00\x00\x01\x00\x01\xe1\x9e\ +\x00\x00\x01zwURm\ +\x00\x00\x10l\x00\x00\x00\x00\x00\x01\x00\x00\xbe\xdf\ +\x00\x00\x01zwURy\ +\x00\x00!F\x00\x00\x00\x00\x00\x01\x00\x01\x90\xa4\ +\x00\x00\x01zwUR]\ +\x00\x00\x0bz\x00\x00\x00\x00\x00\x01\x00\x00\x82\x8f\ +\x00\x00\x01zwURM\ +\x00\x00\x13R\x00\x00\x00\x00\x00\x01\x00\x00\xd2\xfc\ +\x00\x00\x01zwURu\ +\x00\x00\x04z\x00\x00\x00\x00\x00\x01\x00\x0074\ +\x00\x00\x01zwURq\ +\x00\x00\x12\xe6\x00\x00\x00\x00\x00\x01\x00\x00\xcfh\ +\x00\x00\x01zwURy\ +\x00\x00.0\x00\x00\x00\x00\x00\x01\x00\x02\x1b\xe3\ +\x00\x00\x01zwURq\ +\x00\x00,\xc0\x00\x00\x00\x00\x00\x01\x00\x02\x05s\ +\x00\x00\x01zwUR=\ +" + +def qInitResources(): + QtCore.qRegisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data) + +def qCleanupResources(): + QtCore.qUnregisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data) + +qInitResources() diff --git a/amoco/ui/graphics/qt_/style.qss b/amoco/ui/graphics/qt_/style.qss index 27d1399..dc9089f 100644 --- a/amoco/ui/graphics/qt_/style.qss +++ b/amoco/ui/graphics/qt_/style.qss @@ -1,9 +1,32 @@ +/* --------------------------------------------------------------------------*/ +/* | default amoco Qt style |*/ +/* --------------------------------------------------------------------------*/ + +* { + padding: 0px; + margin: 0px; + border: 0px; + border-style: none; + border-image: none; + outline: 0; +} + +QToolBar * { + margin: 0px; + padding: 0px; +} + +/* --------------------------------------------------------------------------*/ +/* All widgets defaults to transparent background: */ QWidget, QStackedWidget, QScrollArea, QAbstractScrollArea { background-color: transparent; } +/* --------------------------------------------------------------------------*/ +/* set background & foreground for all "main" widgets: */ + QApplication, QMainWindow, QFrame, QDockWidget, QDialog, QFileDialog, QMessageBox, QRadioButton, QStatusBar, @@ -14,15 +37,23 @@ QTreeView, QListWidget, QListView, QTableWidget, QTableView, QTextEdit, QTextBrowser { background-color: #3c3f41; color: #bbbbbb; + selection-background-color: #4c4f51; + selection-color: #dddddd; } +/* --------------------------------------------------------------------------*/ +/* set background/foreground & select colors for other common widgets: */ + QLabel, QTabBar::tab, QMenuBar::item, QCheckBox, QGroupBox { background-color: transparent; color: #bbbbbb; - selection-color: #bbbbbb; + selection-color: #dddddd; } +/* --------------------------------------------------------------------------*/ +/* set border/margin params for groupbox/checkbox widgets: */ + QGroupBox { border-top: 1px solid #2d2d2d; margin-top: 0.5em; @@ -32,10 +63,14 @@ QGroupBox::title { subcontrol-position: top left; padding: 0 3px; } + +/* --------------------------------------------------------------------------*/ +/* set indicator size and icons for groupbox/checkbox widgets: */ + QCheckBox::indicator, QGroupBox::indicator { - width: 13px; - height: 13px; + width: 12px; + height: 12px; } QCheckBox::indicator:unchecked, QGroupBox::indicator:unchecked { @@ -92,30 +127,8 @@ QLineEdit, QAbstractSpinBox, QComboBox, QPushButton { border-width: 0; } -QAbstractSpinBox::up-button { - image: url(:/icons/spinup.png); -} -QAbstractSpinBox::up-button:hover { - image: url(:/icons/spinup_hover.png); -} -QAbstractSpinBox::up-button:off { - image: url(:/icons/spinup_off.png); -} -QAbstractSpinBox::up-button:pressed { - image: url(:/icons/spinup_pressed.png); -} -QAbstractSpinBox::down-button { - image: url(:/icons/spindown.png); -} -QAbstractSpinBox::down-button:hover { - image: url(:/icons/spindown_hover.png); -} -QAbstractSpinBox::down-button:off { - image: url(:/icons/spindown_off.png); -} -QAbstractSpinBox::down-button:pressed { - image: url(:/icons/spindown_pressed.png); -} +/* --------------------------------------------------------------------------*/ +/* set parameters for PushButton widgets: */ QPushButton { min-height: 1.33em; @@ -149,6 +162,9 @@ QPushButton::menu-indicator { subcontrol-position: bottom right; } +/* --------------------------------------------------------------------------*/ +/* set parameters for ComboBox widgets: */ + QComboBox { border-radius: 2px; min-width: 3em; @@ -183,29 +199,34 @@ QComboBox QAbstractItemView { } +/* --------------------------------------------------------------------------*/ +/* set parameters for RadioButton widgets: */ + QRadioButton::indicator { width: 13px; height: 13px; } QRadioButton::indicator:unchecked { - image: url(:/icons/radiobutton_unchecked.png); + image: url(:/icons/radio_unchecked.png); } QRadioButton::indicator:unchecked:hover { - image: url(:/icons/radiobutton_unchecked_hover.png); + image: url(:/icons/radio_unchecked_focus.png); } QRadioButton::indicator:unchecked:pressed { - image: url(:/icons/radiobutton_unchecked_pressed.png); + image: url(:/icons/radio_unchecked_pressed.png); } QRadioButton::indicator:checked { - image: url(:/icons/radiobutton_checked.png); + image: url(:/icons/radio_checked.png); } QRadioButton::indicator:checked:hover { - image: url(:/icons/radiobutton_checked_hover.png); + image: url(:/icons/radio_checked_focus.png); } QRadioButton::indicator:checked:pressed { - image: url(:/icons/radiobutton_checked_pressed.png); + image: url(:/icons/radio_checked_pressed.png); } +/* --------------------------------------------------------------------------*/ +/* set parameters for TabWidget/TabBar panes: */ QTabWidget::tab-bar { /*position: relative; @@ -279,6 +300,9 @@ QTabBar::tab:left:!selected { margin-left: 2px; } +/* --------------------------------------------------------------------------*/ +/* set parameters for TableWidget/TableView & HeaderView : */ + QTableWidget, QTableView { border: 1px solid #323232; @@ -312,20 +336,24 @@ QHeaderView::section:checked { background-color: red; } QHeaderView::down-arrow { - image: url(:/icons/down_arrow.png); + image: url(:/icons/arrow_down.png); right: 7px; } QHeaderView::up-arrow { - image: url(:/icons/up_arrow.png); + image: url(:/icons/arrow_up.png); height: 7px; width: 7px; } +/* --------------------------------------------------------------------------*/ +/* set parameters for MenuBar/Menu : */ + QMenuBar { border-bottom: 2px solid qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop:0 #282828, stop:1 #555555); } QMenuBar::item:pressed { - background-color: #4b6eaf; + color: #ffffff; + background-color: #2c2f31; } QMenuBar::item:selected:!pressed { background-color: #585b5d; @@ -340,7 +368,7 @@ QMenu::item:disabled { color: #999999; } QMenu::item:selected { - background-color: #4b6eaf; + background-color: #ffffaf; } QMenu::icon { border: 0px solid transparent; @@ -367,41 +395,49 @@ QMenu::separator { }*/ -/* - * Scroll bar modifications - */ +/* --------------------------------------------------------------------------*/ +/* set parameters for ScrollBar : */ + QScrollBar { background-color: transparent; margin: 0; height: 12px; /* for horizontal */ width: 12px; /* for vertical */ } + QScrollBar::handle { border: 1px solid #555555; border-radius: 4px; margin: 1px; } + QScrollBar::handle:vertical { background-color: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0, stop:0 #5c5c5c, stop:1 #515151); min-height: 20px; min-width: 8px; } + QScrollBar::handle:vertical:hover { background-color: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0, stop:0 #666666, stop:1 #5b5b5b); } + QScrollBar::handle:horizontal { background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop:0 #5c5c5c, stop:1 #515151); min-height: 8px; min-width: 20px; } + QScrollBar::handle:horizontal:hover { background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop:0 #666666, stop:1 #5b5b5b); } + QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical, QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal { background-color: transparent; } -/*QScrollBar::sub-page:vertical { + +/* +QScrollBar::sub-page:vertical { max-height: 8px; margin-top: auto; margin-bottom: 0; @@ -416,16 +452,18 @@ QScrollBar::add-page:vertical { background-color: darkblue; border-bottom-left-radius: 4px; border-bottom-right-radius: 4px; -}*/ +} +*/ + QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical, QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal { height: 0; width: 0; } -/* - * Status bar - */ +/* --------------------------------------------------------------------------*/ +/* set parameters for StatusBar : */ + /* QStatusBar { background-color: brown; @@ -442,6 +480,8 @@ QStatusBar QLabel { } */ +/* --------------------------------------------------------------------------*/ +/* set parameters for AbstractItemView : */ QAbstractItemView { border: 1px solid #323232; @@ -452,88 +492,104 @@ QAbstractItemView { outline: 0; } -/* QAbstractItemView:!focus { - selection-background-color: #0d293e; + selection-background-color: #fd293e; } + QTreeView::branch, QAbstractItemView::item { border-width: 0; } -*/ QAbstractItemView::item:alternate { - background-color: #414547; + background-color: #4145b7; } + +/* --------------------------------------------------------------------------*/ +/* set parameters for List/Tree Item widget : */ + QListWidgetItem, QTreeWidgetItem { background-color: red; color: yellow; border: 1px solid purple; } + QAbstractItemView::text { color: #bbbbbb; } + +/* color of item line when mouse passes over: */ QTreeView::branch:hover, QAbstractItemView::item:hover { background-color: rgba(255, 255, 255, 0.05); } -QTreeView::branch:selected:active, -QAbstractItemView::item:selected { - background-color: #4b6ebf; - color: #ffffff; -} + +/* color of item line when mouse click + window has focus : */ QTreeView::branch:selected:active, QAbstractItemView::item:selected:active { - background-color: #4b6ebf; + background-color: #2c2f31; color: #ffffff; } + +/* color of last selected item line + window has no focus : */ QTreeView::branch:selected:!active, QAbstractItemView::item:selected:!active { - background-color: #0d293e; + background-color: #2c2f31; } -/* If we want to modify the QTreeView items' icons -QTreeView::branch:has-siblings:adjoins-item, -QTreeView::branch:has-siblings:!adjoins-item, -QTreeView::branch:!has-children:!has-siblings:adjoins-item { - border-image: none; - image: none; +QTreeView:branch:selected, QTreeView:branch:hover { + background: url(":/icons/transparent.png"); } -QTreeView::branch:has-children:!has-siblings:closed, -QTreeView::branch:closed:has-children:has-siblings { - border-image: none; - image: url(:/icons/triangle_horz.png); + +QTreeView:branch:has-siblings:!adjoins-item { + border-image: url(":/icons/branch_line.png") 0; } -QTreeView::branch:open:has-children:!has-siblings, -QTreeView::branch:open:has-children:has-siblings { - border-image: none; - image: url(:/icons/triangle_vert.png); + +QTreeView:branch:has-siblings:adjoins-item { + border-image: url(":/icons/branch_more.png") 0; } -*/ -/* - * Tool bar - */ +QTreeView:branch:!has-children:!has-siblings:adjoins-item { + border-image: url(":/icons/branch_end.png") 0; +} + +QTreeView:branch:has-children:!has-siblings:closed, +QTreeView:branch:closed:has-children:has-siblings { + border-image: none; + image: url(":/icons/branch_closed.png"); +} + +QTreeView:branch:open:has-children:!has-siblings, +QTreeView:branch:open:has-children:has-siblings { + border-image: none; + image: url(":/icons/branch_open.png"); +} + +QTreeView:branch:has-children:!has-siblings:closed:hover, +QTreeView:branch:closed:has-children:has-siblings:hover { + image: url(":/icons/branch_closed_focus.png"); +} + +QTreeView:branch:open:has-children:!has-siblings:hover, +QTreeView:branch:open:has-children:has-siblings:hover { + image: url(":/icons/branch_open_focus.png"); +} + + +/* --------------------------------------------------------------------------*/ +/* set parameters for ToolBar widget : */ QToolBar { border-width: 0; } -/* - * Resizing widget (bottom right in Qt Creator, inside status bar) - */ - QSizeGrip { - image: url(:/icons/sizegrip.png); + image: url(:/icons/window_grip.png); width: 16px; height: 16px; } -/* - * ToolTip - */ - QToolTip, QTipLabel { border: 1px solid #9a9a66; border-radius: 3px; @@ -543,7 +599,6 @@ QToolTip, QTipLabel { padding: 0; } - QWizard > QWidget { background-color: #3c3f41; } @@ -553,6 +608,9 @@ Core--Internal--NewDialog > QFrame#frame { border: 1px solid #323232; } +/* --------------------------------------------------------------------------*/ +/* set parameters for text Editor widget : */ + QPlainTextEdit { background-color: #2b2b2b; selection-background-color: #214283; @@ -567,3 +625,44 @@ TextEditor--TextEditorWidget > QWidget { color: #bbbbbb; } +/* --------------------------------------------------------------------------*/ +/* set dock widget parameters : */ + +QDockWidget::close-button { + icon-size: 10px; + border: none; + background: transparent; + background-image: transparent; + border: 0; + margin: 0; + padding: 0; + image: url(":/icons/window_close.png"); +} + +QDockWidget::close-button:hover { + image: url(":/icons/window_close_focus.png"); +} + +QDockWidget::close-button:pressed { + image: url(":/icons/window_close_pressed.png"); +} + +QDockWidget::float-button { + icon-size: 10px; + border: none; + background: transparent; + background-image: transparent; + border: 0; + margin: 0; + padding: 0; + image: url(":/icons/window_undock.png"); +} + +QDockWidget::float-button:hover { + image: url(":/icons/window_undock_focus.png"); +} + +QDockWidget::float-button:pressed { + image: url(":/icons/window_undock_pressed.png"); +} + diff --git a/amoco/ui/graphics/qt_/taskwin.py b/amoco/ui/graphics/qt_/taskwin.py index cc20a96..2043d9b 100644 --- a/amoco/ui/graphics/qt_/taskwin.py +++ b/amoco/ui/graphics/qt_/taskwin.py @@ -15,7 +15,10 @@ from PySide2.QtQuickWidgets import QQuickWidget +from . import rc_icons + from .binfmtview import BinFmtView +from .infoview import InfoView from .hexview import HexView __all__ = ['TaskWindow','HexView'] @@ -38,30 +41,46 @@ def createMenus(self): def createDocks(self,task): self.createDockBin(task) - self.createDockMap(task) + self.createDockInfo(task) def createDockBin(self,task): # TreeView for ELF/PE/Mach-O structure - dock = QDockWidget(task.bin.filename, self) + dock = QDockWidget("[task].view.obj.binfmt", self) #dock.setAllowedAreas(Qt.TopDockWidgetArea) dock.setFeatures(dock.DockWidgetClosable|\ dock.DockWidgetMovable|\ dock.DockWidgetFloatable) dock.setMinimumWidth(364) + self.addDockWidget(Qt.LeftDockWidgetArea, dock) + a = dock.toggleViewAction() + self.viewMenu.addAction(a) self.binfmt = BinFmtView(task) if self.binfmt is not None: dock.setWidget(self.binfmt) enabled = True else: + dock.hide() enabled = False - self.addDockWidget(Qt.LeftDockWidgetArea, dock) + a.setEnabled(enabled) + a.setChecked(enabled) + + def createDockInfo(self,task): + dock = QDockWidget("[task].view.obj.info", self) + dock.setFeatures(dock.DockWidgetClosable|\ + dock.DockWidgetMovable|\ + dock.DockWidgetFloatable) + self.addDockWidget(Qt.RightDockWidgetArea, dock) a = dock.toggleViewAction() self.viewMenu.addAction(a) + self.info = InfoView(task) + if self.info is not None: + dock.setWidget(self.info) + enabled = True + else: + dock.hide() + enabled = False a.setEnabled(enabled) - - def createDockMap(self,data): - # various stuff like entropy or view of the MemoryMap - pass + a.setChecked(enabled) def createCentral(self,v): self.hexview = HexView(self) @@ -82,6 +101,7 @@ def binfmt_clicked(self,index): size = len(item.struct) else: parent = item.parent() + if parent is None: return offset = parent.offset + parent.struct.offset_of(item.text()) size = int(m.data(index.siblingAtColumn(2))) self.statusBar().showMessage("%d bytes @ %+08x"%(size,offset)) diff --git a/amoco/ui/render.py b/amoco/ui/render.py index d8a1687..3653b88 100644 --- a/amoco/ui/render.py +++ b/amoco/ui/render.py @@ -102,32 +102,6 @@ def format(self, tokensource, outfile): S[getattr(k,'Hide')] = "noinherit #222" dark.update(S) - dark = { - Token.Literal : "#fff", - Token.Address : "#fb0", - Token.Orange : "#fb0", - Token.Constant : "#f30", - Token.Red : "#f30", - Token.Prefix : "#fff", - Token.Mnemonic : "bold", - Token.Register : "#33f", - Token.Memory : "#3ff", - Token.String : "#3f3", - Token.Segment : "#888", - Token.Comment : "#f8f", - Token.Green : "#8f8", - Token.Good : "bold #8f8", - Token.Name : "bold", - Token.Alert : "bold #f00", - Token.Column : "#000", - } - S = {} - for k in dark.keys(): - S[getattr(k,'Mark')] = "bg:#224" - S[getattr(k,'Taint')] = "bg:#422" - S[getattr(k,'Hide')] = "noinherit #222" - dark.update(S) - class DarkStyle(Style): default_style = "" styles = dark diff --git a/amoco/ui/srv.py b/amoco/ui/srv.py index 4fa43f5..da069bd 100644 --- a/amoco/ui/srv.py +++ b/amoco/ui/srv.py @@ -8,7 +8,8 @@ srv.py ====== -This module ... +This module defines a set of high-level commands that allow +to use amoco from a dedicated command-line interface. """ import ctypes diff --git a/amoco/ui/views.py b/amoco/ui/views.py index 85dfe76..b84d367 100644 --- a/amoco/ui/views.py +++ b/amoco/ui/views.py @@ -436,7 +436,7 @@ def code(self,blk): tn = tn[1] if tn == Token.Memory: tn = Token.Address - tv = re.findall('\[(0x[0-9a-zA-Z]+)\]',tv) + tv = re.findall(r'\[(0x[0-9a-zA-Z]+)\]',tv) if len(tv)==1: tv = tv[0] else: diff --git a/doc/_static/images/binfmtview.png b/doc/_static/images/binfmtview.png new file mode 100755 index 0000000..59c2f51 Binary files /dev/null and b/doc/_static/images/binfmtview.png differ diff --git a/doc/_static/images/gui_load.png b/doc/_static/images/gui_load.png new file mode 100755 index 0000000..5c8ea2e Binary files /dev/null and b/doc/_static/images/gui_load.png differ diff --git a/doc/ui.rst b/doc/ui.rst index 15000d8..91d0e99 100644 --- a/doc/ui.rst +++ b/doc/ui.rst @@ -8,9 +8,16 @@ in a much more useful way than what can be shown on a simple terminal. Ideally, we want to allow rich graphic display without losing the ability to develop programs that access all parts of the framework API. -One approach is to have a GUI application that has the ability to run +One common approach is to have a GUI application that has the ability to run "scripts" when required, either loaded from a file or from a dedicated -GUI widget that provides interactive input/output from/to the user. +GUI widget that provides interactive input/output from/to the user. This +approach favors user interaction based on the predefined fonctionalities +available from the graphical interface. Tools like IDA Pro and Ghidra both +follow this approach efficiently. In amoco we wanted the graphical interface +to be just a way of displaying information obtained from programming the analysis +of a binary. + + Running the framework inside a graphical user interface is to limit possible actions to a very small set of predefined diff --git a/setup.py b/setup.py index 65bdb8e..878b28e 100644 --- a/setup.py +++ b/setup.py @@ -30,7 +30,7 @@ setup( name = 'amoco', - version = '2.9.5', + version = '2.9.6', description = 'yet another binary analysis framework', long_description = long_descr, # Metadata @@ -67,7 +67,7 @@ 'pygments', 'z3-solver', 'tqdm', - 'ccrawl>=1.3', + 'ccrawl>=1.5', 'PySide2', 'IPython'], }, diff --git a/tests/conftest.py b/tests/conftest.py index 4495e9d..d685737 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -8,7 +8,7 @@ def m(): return mapper() @pytest.fixture(scope='module') -def map(): +def amap(): '''return a no_aliasing mapper with module scope''' from amoco.cas.mapper import conf,mapper conf.Cas.noaliasing = True diff --git a/tests/samples/wasm/change.wasm b/tests/samples/wasm/change.wasm new file mode 100644 index 0000000..7b4ef9c Binary files /dev/null and b/tests/samples/wasm/change.wasm differ diff --git a/tests/samples/wasm/license.txt b/tests/samples/wasm/license.txt new file mode 100644 index 0000000..410d31d --- /dev/null +++ b/tests/samples/wasm/license.txt @@ -0,0 +1,22 @@ +MIT license + +Copyright (C) 2015 Miguel Mota + +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. + diff --git a/tests/samples/x86/blocks.raw b/tests/samples/x86/blocks.raw index 2f9b846..864cc3f 100644 Binary files a/tests/samples/x86/blocks.raw and b/tests/samples/x86/blocks.raw differ diff --git a/tests/test_arch_armv8.py b/tests/test_arch_armv8.py index c2eb19d..77198a7 100644 --- a/tests/test_arch_armv8.py +++ b/tests/test_arch_armv8.py @@ -40,11 +40,11 @@ def test_decoder_00x(): #------------------------------------------------------------------------------ -def test_asm_000(map): +def test_asm_000(amap): c = b'\x67\x0a\x00\xd0' i = cpu.disassemble(c) # fake eip cst: - map[pc] = cst(0x400924,64) - i(map) - assert map(r7)==0x54e000 + amap[pc] = cst(0x400924,64) + i(amap) + assert amap(r7)==0x54e000 diff --git a/tests/test_arch_tricore.py b/tests/test_arch_tricore.py new file mode 100644 index 0000000..5bfc25a --- /dev/null +++ b/tests/test_arch_tricore.py @@ -0,0 +1,39 @@ +import pytest + +from amoco.config import conf +conf.UI.formatter = 'Null' +conf.Cas.unicode = False +conf.UI.unicode = False + +from amoco.arch.tricore import cpu + +def test_decoder_START(): + c = b'\x91\x00\x00\xf8' + i = cpu.disassemble(c) + assert i.mnemonic=='MOVH_A' + assert i.operands[0] is cpu.A[15] + assert i.operands[1]==0x8000 + c = b'\xd9\xff\x14\x02' + i = cpu.disassemble(c) + assert i.mnemonic=="LEA" + assert i.mode=="Long-offset" + assert i.operands[2]==0x2014 + c = b'\xdc\x0f' + i = cpu.disassemble(c) + assert i.mnemonic=="JI" + assert i.operands[0]==cpu.A[15] + c = b'\x00\x90' + i = cpu.disassemble(c) + assert i.mnemonic=="RET" + c = b'\x00\x00' + i = cpu.disassemble(c) + assert i.mnemonic=="NOP" + +def test_decoder_ldw(): + c = b'\x19\xf0\x10\x16' + i = cpu.disassemble(c) + assert str(i)=="ld.w d0 , a15, 0x6050" + +def test_movh(): + c = b'\x7b\xd0\x38\xf1' + i = cpu.disassemble(c) diff --git a/tests/test_arch_wasm.py b/tests/test_arch_wasm.py new file mode 100644 index 0000000..55e7863 --- /dev/null +++ b/tests/test_arch_wasm.py @@ -0,0 +1,42 @@ +import pytest + +from amoco.config import conf +conf.UI.formatter = 'Null' +conf.Cas.unicode = False +conf.UI.unicode = False + +from amoco.arch.wasm import cpu + +def test_decoder_000(): + c = b'\x00' + i = cpu.disassemble(c) + assert i.mnemonic=='unreachable' + +def test_refnull(): + c = b'\xd0\x70' + i = cpu.disassemble(c) + op1 = i.operands[0] + assert str(op1)=='#funcref' + c = b'\xd0\x6f' + i = cpu.disassemble(c) + op1 = i.operands[0] + assert str(op1)=='#externref' + +def test_ref_func(): + c = b'\xd2\x81\x02' + i = cpu.disassemble(c) + assert i.mnemonic=="ref" and i.action=="func" + op1 = i.operands[0] + assert i.bytes==c + assert op1==0x0101 + +def test_xdata_select(): + c = b'\x1c\x03\x41\xe5\x8e\x26\x81\x02' + i = cpu.disassemble(c,address=0,code=c) + assert i.mnemonic=="select" + op1 = i.operands[0] + assert i.bytes==c + assert len(op1)==i.x==3 + assert op1[0] == 0x41 + assert op1[1] == 624485 + assert op1[2] == 0x0101 diff --git a/tests/test_arch_x86.py b/tests/test_arch_x86.py index 2ba6f7d..d6c1f11 100644 --- a/tests/test_arch_x86.py +++ b/tests/test_arch_x86.py @@ -260,274 +260,274 @@ def test_pickle_instruction(): #------------------------------------------------------------------------------ -def test_asm_000(map): +def test_asm_000(amap): c = b'\x90' i = cpu.disassemble(c,address=0) # fake eip cst: - map[eip] = cst(0,32) - i(map) - assert str(map(eip))=='0x1' + amap[eip] = cst(0,32) + i(amap) + assert str(amap(eip))=='0x1' # wait -def test_asm_001(map): +def test_asm_001(amap): c = b'\x9b' i = cpu.disassemble(c,address=0) - i(map) + i(amap) assert i.mnemonic=='WAIT' - assert str(map(eip))=='0x2' + assert str(amap(eip))=='0x2' # leave -def test_asm_002(map): +def test_asm_002(amap): c = b'\xc9' i = cpu.disassemble(c,address=0) - i(map) - assert str(map)=='''\ + i(amap) + assert str(amap)=='''\ eip <- { | [0:32]->0x3 | } esp <- { | [0:32]->(ebp+0x4) | } ebp <- { | [0:32]->M32(ebp) | }''' # ret -def test_asm_003(map): +def test_asm_003(amap): c = b'\xc3' i = cpu.disassemble(c,address=0) - i(map) - assert str(map(eip))=='M32(ebp+4)' - assert str(map(esp))=='(ebp+0x8)' - assert str(map(ebp))=='M32(ebp)' + i(amap) + assert str(amap(eip))=='M32(ebp+4)' + assert str(amap(esp))=='(ebp+0x8)' + assert str(amap(ebp))=='M32(ebp)' # hlt -def test_asm_004(map): +def test_asm_004(amap): c = b'\xf4' i = cpu.disassemble(c,address=0) - i(map) + i(amap) assert i.mnemonic=='HLT' - assert map(eip)==top(32) + assert amap(eip)==top(32) # int3 -def test_asm_005(map): +def test_asm_005(amap): c = b'\xcc' i = cpu.disassemble(c,address=0) assert i.mnemonic=='INT3' - i(map) + i(amap) # push eax -def test_asm_006(map): +def test_asm_006(amap): c = b'\x50' i = cpu.disassemble(c,address=0) - map.clear() - map[eip] = cst(0) - map[esp] = cst(0) - i(map) - assert map(mem(esp))==eax - assert map(esp)==cst(-4) + amap.clear() + amap[eip] = cst(0) + amap[esp] = cst(0) + i(amap) + assert amap(mem(esp))==eax + assert amap(esp)==cst(-4) # pop eax -def test_asm_007(map): +def test_asm_007(amap): c = b'\x58' i = cpu.disassemble(c,address=0) - i(map) - assert map(eax)==eax - assert map(esp)==0 + i(amap) + assert amap(eax)==eax + assert amap(esp)==0 # call edx -def test_asm_008(map): +def test_asm_008(amap): c = b'\xff\xd2' i = cpu.disassemble(c,address=0) - i(map) - assert map(eip)==edx - assert map(mem(esp))==0x4 + i(amap) + assert amap(eip)==edx + assert amap(mem(esp))==0x4 # call eip+0x00000000 (eip+0) -def test_asm_009(map): +def test_asm_009(amap): c = b'\xe8\x00\x00\x00\x00' i = cpu.disassemble(c,address=0) i.address = 0x08040000 - map.clear() - i(map) - assert map(mem(esp,32))==map(eip) + amap.clear() + i(amap) + assert amap(mem(esp,32))==amap(eip) # call eip+0xffffff9b (eip-101) -def test_asm_010(map): +def test_asm_010(amap): c = b'\xe8\x9b\xff\xff\xff' i = cpu.disassemble(c,address=0) - map.clear() + amap.clear() i.address = 0x08040005 - map[eip] = cst(i.address,32) - i(map) + amap[eip] = cst(i.address,32) + i(amap) assert str(i)=='call 0x803ffa5' - assert map(mem(esp))==i.address+5 - assert map(eip)==(i.address+5-101) + assert amap(mem(esp))==i.address+5 + assert amap(eip)==(i.address+5-101) # jmp eip+12 -def test_asm_011(map): +def test_asm_011(amap): c = b'\xeb\x0c' i = cpu.disassemble(c,address=0) - i.address = map(eip).v - i(map) - assert map(mem(esp))==i.address+101 - assert map(eip)==i.address+i.length+12 + i.address = amap(eip).v + i(amap) + assert amap(mem(esp))==i.address+101 + assert amap(eip)==i.address+i.length+12 # jmp eip-32 -def test_asm_012(map): +def test_asm_012(amap): c = b'\xe9\xe0\xff\xff\xff' i = cpu.disassemble(c,address=0) - i.address = map(eip).v - i(map) - assert map(eip)==i.address+i.length-32 + i.address = amap(eip).v + i(amap) + assert amap(eip)==i.address+i.length-32 # jmp [0x0805b0e8] -def test_asm_013(map): +def test_asm_013(amap): c = b'\xff\x25\xe8\xb0\x05\x08' i = cpu.disassemble(c,address=0) - i(map) - assert map(eip)==mem(cst(0x805b0e8)) + i(amap) + assert amap(eip)==mem(cst(0x805b0e8)) # retn 0xc -def test_asm_014(map): +def test_asm_014(amap): c = b'\xc2\x0c\x00' i = cpu.disassemble(c,address=0) - i(map) - assert map(eip)==0x804000a - assert str(map(esp))=='(esp+0xc)' + i(amap) + assert amap(eip)==0x804000a + assert str(amap(esp))=='(esp+0xc)' # int 0x80 -def test_asm_015(map): +def test_asm_015(amap): c = b'\xcd\x80' i = cpu.disassemble(c,address=0) - i(map) + i(amap) # inc eax -def test_asm_016(map): +def test_asm_016(amap): c = b'\x40' i = cpu.disassemble(c,address=0) - i(map) - assert map(eax)==(eax+1) + i(amap) + assert amap(eax)==(eax+1) # dec esi -def test_asm_017(map): +def test_asm_017(amap): c = b'\x4e' i = cpu.disassemble(c,address=0) - i(map) - assert map(esi)==(esi-1) + i(amap) + assert amap(esi)==(esi-1) # mov eax,[eax+0x10] -def test_asm_018(map): +def test_asm_018(amap): c = b'\x8b\x40\x10' i = cpu.disassemble(c,address=0) - map.clear() - i(map) - assert str(map(eax))=='M32(eax+16)' + amap.clear() + i(amap) + assert str(amap(eax))=='M32(eax+16)' # movsx edx,al -def test_asm_019(map): +def test_asm_019(amap): c = b'\x0f\xbe\xd0' i = cpu.disassemble(c,address=0) - i(map) - assert map(edx)[0:8]==map(al) - assert str(map(edx)[8:32])=='(M8(eax+16)[7:8] ? -0x1 : 0x0)' + i(amap) + assert amap(edx)[0:8]==amap(al) + assert str(amap(edx)[8:32])=='(M8(eax+16)[7:8] ? -0x1 : 0x0)' # movzx edx,[eax+0x0805b13c] -def test_asm_020(map): +def test_asm_020(amap): c = b'\x0f\xb6\x90\x3c\xb1\x05\x08' i = cpu.disassemble(c,address=0) - i(map) - assert map(edx)[8:32]==0 + i(amap) + assert amap(edx)[8:32]==0 # add [eax],al -def test_asm_021(map): +def test_asm_021(amap): c = b'\x00\x00' i = cpu.disassemble(c,address=0) - i(map) - assert str(map(mem(eax,8)))=='(M8(M32(eax+16))+M8(eax+16))' + i(amap) + assert str(amap(mem(eax,8)))=='(M8(M32(eax+16))+M8(eax+16))' # sub [edx+esi-0x43aa74b0], cl -def test_asm_022(map): +def test_asm_022(amap): c = b'\x28\x8c\x32\x50\x8b\x55\xbc' i = cpu.disassemble(c,address=0) - i(map) - loc = ptr(map(edx)+esi,disp=-0x43aa74b0) - assert str(map[mem(loc,8)])=='((-cl)+M8(({ | [0:8]->M8(M32(eax+16)+134590780) | [8:32]->0x0 | }+esi)-1135244464))' + i(amap) + loc = ptr(amap(edx)+esi,disp=-0x43aa74b0) + assert str(amap[mem(loc,8)])=='((-cl)+M8(({ | [0:8]->M8(M32(eax+16)+134590780) | [8:32]->0x0 | }+esi)-1135244464))' # and ebp,[edi-0x18] -def test_asm_023(map): +def test_asm_023(amap): c = b'\x23\x6f\xe8' i = cpu.disassemble(c,address=0) - map.clear() - i(map) - assert map(ebp)==ebp&mem(edi,32,disp=-0x18) + amap.clear() + i(amap) + assert amap(ebp)==ebp&mem(edi,32,disp=-0x18) # and esp,0xfffffff0 -def test_asm_024(map): +def test_asm_024(amap): c = b'\x83\xe4\xf0' i = cpu.disassemble(c,address=0) - map[esp] = cst(0xc0000004) - i(map) - assert map[esp]==0xc0000000 + amap[esp] = cst(0xc0000004) + i(amap) + assert amap[esp]==0xc0000000 # or al,0 -def test_asm_025(map): +def test_asm_025(amap): c = b'\x0c\x00' i = cpu.disassemble(c,address=0) - i(map) - assert map(al)==al|0 - assert map(ah)==ah + i(amap) + assert amap(al)==al|0 + assert amap(ah)==ah # xor edx,[ebp-0x1c] -def test_asm_026(map): +def test_asm_026(amap): c = b'\x33\x55\xe4' i = cpu.disassemble(c,address=0) - i(map) - assert map(edx)==edx^map(mem(ebp,32,disp=-0x1c)) + i(amap) + assert amap(edx)==edx^amap(mem(ebp,32,disp=-0x1c)) # cmp edx,0 -def test_asm_027(map): +def test_asm_027(amap): c = b'\x83\xfa\x00' i = cpu.disassemble(c,address=0) - map.clear() - i(map) - assert str(map(zf))=='(edx==0x0)' + amap.clear() + i(amap) + assert str(amap(zf))=='(edx==0x0)' # sal al,2 -def test_asm_028(map): +def test_asm_028(amap): c = b'\xc0\xf0\x02' i = cpu.disassemble(c,address=0) - i(map) + i(amap) # sal esi,0 -def test_asm_029(map): +def test_asm_029(amap): c = b'\xc1\xf6\x20' i = cpu.disassemble(c,address=0) - i(map) + i(amap) # mov byte ptr [edx], al -def test_asm_030(map): +def test_asm_030(amap): c = b'\x88\x02' i = cpu.disassemble(c,address=0) - i(map) + i(amap) # lea eax, [edx] -def test_asm_031(map): +def test_asm_031(amap): c = b'\x8d\x02\xc3' i = cpu.disassemble(c,address=0) - i(map) - assert str(map(eax))=='(edx)' + i(amap) + assert str(amap(eax))=='(edx)' # pop esp -def test_asm_032(map): +def test_asm_032(amap): c = b'\x5c' i = cpu.disassemble(c,address=0) - map.clear() - map[esp] = cst(0x1000,32) - map[mem(esp,32)] = cst(0x67452301,32) - i(map) - assert map(esp)==cst(0x67452301,32) + amap.clear() + amap[esp] = cst(0x1000,32) + amap[mem(esp,32)] = cst(0x67452301,32) + i(amap) + assert amap(esp)==cst(0x67452301,32) # push esp -def test_asm_033(map): +def test_asm_033(amap): c = b'\x54' i = cpu.disassemble(c,address=0) - i(map) - assert map(esp)==0x67452301-4 - assert map(mem(esp,32))==cst(0x67452301,32) + i(amap) + assert amap(esp)==0x67452301-4 + assert amap(mem(esp,32))==cst(0x67452301,32) diff --git a/tests/test_system_structs.py b/tests/test_system_structs.py index d183f4d..9cbfb30 100644 --- a/tests/test_system_structs.py +++ b/tests/test_system_structs.py @@ -12,6 +12,8 @@ def test_varfield(): assert f.format()=='#s' assert f.size()==float('Infinity') assert f.unpack(b'abcdef\0dzdfoihzdofh') == b'abcdef\x00' + # once unpacked, a variable-length field instance + # updates its size and format assert f.size()==7 assert f.format()=='7s' @@ -20,6 +22,8 @@ def test_cntfield(): assert f.format()=='#s' assert f.size()==float('Infinity') assert f.unpack(b'\x04abcdefgh') == b'abcd' + # once unpacked, a variable-length field instance + # updates its size and format assert f.size()==5 assert f.format()=='b4s' @@ -27,7 +31,12 @@ def test_StructDefine(): S = StructDefine("B : v")(type('S',(StructCore,),{})) a = S() b = S() + # make sure fields lists are NOT the same object: assert not (a.fields is b.fields) + # but have "identical" content: + assert a.fields==b.fields + # make sure that a struct instance can be mutated without + # impact on the class (or other instance of this class...) a.packed = True assert S.packed == False assert b.packed == False @@ -37,20 +46,43 @@ def test_StructDefine(): assert a.v == 1 assert b.v == 2 +def test_embed_varfield(): + inf = float('Infinity') + S1 = StructDefine("B*~ : v1")(type('S1',(StructCore,),{})) + assert S1.size() == inf + S2 = StructDefine("S1 : v2")(type('S2',(StructCore,),{})) + assert S2.fields[0].type is S1 + assert S2.size() == inf + a = S2() + assert S2.size() == a.size() == inf + assert len(a) == 0 + a.unpack(b"aoijzfoijzdf\0zofijzdfoij") + assert bytes(a.v2.v1) == b"aoijzfoijzdf\0" + assert a.size() == inf + assert len(a) == len(a.v2.v1) + + def test_UnionDefine(): - pass + U = UnionDefine("B : v\nI : w")(type('U',(StructCore,),{})) + u = U() + assert u.size()==4 + u.unpack(b'\x01\0\0\x01') + assert u.v == 1 + assert u.w == 0x01000001 def test_TypeDefine(): @StructDefine("myinteger*1 : z") - class S1(StructFormatter): pass - TypeDefine('myinteger', 'xxx', 2) - TypeDefine('xxx', 'h') + class S1(StructFormatter): + pass + + myint = TypeDefine('myinteger', 'xxx', 2) + xxx = TypeDefine('xxx', 'h') s = S1() - xxx = StructDefine.All['xxx'] - myint = StructDefine.All['myinteger'] - assert xxx.unpack(b'\x01\x00') == 1 - assert xxx == myint.type - assert myint.unpack(b'\x01\x00\x02\x00') == [1,2] + assert xxx is Alltypes['xxx'] + assert myint is Alltypes['myinteger'] + assert xxx().unpack(b'\x01\x00') == 1 + assert myint.size() == 2*xxx.size() == 4 + assert myint().unpack(b'\x01\x00\x02\x00') == [1,2] assert s.unpack(b'\x03\x00\x04\x00\x05\x00\x06\x00') assert s.z == [[3,4]] @@ -61,8 +93,15 @@ class S2(StructFormatter): pass @StructDefine("S1 : y") class S3(StructFormatter): pass s = S2() + # s uses type S1 to decode its field 'x', + # which by default is little-endian: s.unpack(b'\x00\x00\x00\x01') assert s.x.i == 0x01000000 + # an S3 instance q, would do the same but + # if we modify the S1 type to change its + # field into big-endian for example, then + # any further decoding that uses this type + # will indeed use the current definition: q = S3() S1.fields[0].order = '>' q.unpack(b'\x01\x00\x00\x00') @@ -71,9 +110,12 @@ class S3(StructFormatter): pass def test_Struct_slop(): S1 = StructFactory("S1","c: a\nI : b") + # padding occurs between a and b due to field alignement rules: assert S1.size()==8 + # padding occurs at end of structure due to structure alignment rules: S2 = StructFactory("S2","I: a\nc : b") assert S2.size()==8 + # if "packed", no padding should be present: S3 = StructFactory("S3","c: a\nI : b",packed=True) assert S3.size()==5 s1 = S1().unpack(b'\x41\xff\xff\xff\xef\xcd\xab\x89') @@ -89,6 +131,7 @@ def test_Struct_slop(): assert s3.pack() == b'\x43\x01\x00\x00\x00' def test_Struct_CntFields(): + # we test StructDefine ability to declare CntField: @StructDefine(""" s*16 : uuidDesigner I : cbStructSize @@ -105,9 +148,12 @@ class DesignerInfo(StructFormatter): def __init__(self,data="",offset=0): if data: self.unpack(data,offset) + # instance of this class should have infinite length until + # some unpacking is performed: d = DesignerInfo() assert d.format() == '16sI#s#s#sI#s#sI' assert d.size() == float('Infinity') + # lets unpack the structure from some bytes... d.unpack(b'A'*16+ b'\x01\0\0\0'+ b'\x04\0\0\0abcd'+ @@ -120,4 +166,92 @@ def __init__(self,data="",offset=0): assert d.uuidDesigner == b'A'*16 assert d.bstrAddinRegKey == b'abcd' assert d.dwCommandLineSafe == 3 + # a StructCore format and size is not updated even + # when an instance is unpacked: + assert d.format() == '16sI#s#s#sI#s#sI' + assert d.size() == float('Infinity') + # but the actual byte-length of the structure is + # obtained with len: + assert len(d)==68 + # and field offsets are known for this instance: + assert d.offset_of("dwLoadBehaviour")==44 + +def test_bitfield1(): + f = BitField('B',fcount=[2,4,1,1],fname=['a','b','c','d']) + assert f.format()=='B' + assert f.size()==1 + assert f.name is None + assert str(f)=="" + v = f.unpack(b"\x93") + # values are splitted from low to high order bits... + assert v['a'] == 3 + assert v['b'] == 4 + assert v['c'] == 0 + assert v['d'] == 1 + +def test_bitfield2(): + f = BitField('H',fcount=[2,4,1,1],fname=['a','b','c','d']) + assert f.format()=='H' + assert f.size()==2 + assert f.name is None + assert str(f)=="" + v = f.unpack(b"\x40\x93") + # values are splitted from low to high order bits... + assert v['a'] == 0 + assert v['b'] == 0 + assert v['c'] == 1 + assert v['d'] == 0 + # if we change to big-endian: + f.order = '>' + v = f.unpack(b"\x40\x93") + assert v['a'] == 3 + assert v['b'] == 4 + assert v['c'] == 0 + assert v['d'] == 1 + + +def test_bindedfield(): + @StructDefine(""" + I : counter + H : unused + s*.counter : data + """) + class bindit(StructFormatter): + order = '<' + def __init__(self,data="",offset=0): + if data: + self.unpack(data,offset) + s = bindit() + s.unpack(b"\x05\0\0\0\x99\xffabcdef") + assert s.counter == 5 + assert s.unused == 0xff99 + assert s.fields[2].instance is s + assert isinstance(s.fields[2],BindedField) + assert s.data == b"abcde" + +def test_wasm_(): + @StructDefine( + """ + I*%leb128 : n1 + s*.n1 : mod + I*%leb128 : n2 + s*.n2 : nm + B : d + """, packed=True, + ) + class Import(StructFormatter): + def __init__(self, data=None): + if data: + self.unpack(data) + def unpack(self,data,offset=0): + from codecs import decode + super().unpack(data,offset) + self.mod = decode(self.mod,"UTF-8") + self.nm = decode(self.nm,"UTF-8") + return self + i = Import(b"\x05AAAAA\x07BBBBBBBxxx") + assert i.n1 == 5 + assert i.mod == "AAAAA" + assert i.n2 == 7 + assert i.nm == "BBBBBBB" diff --git a/tests/test_system_utils.py b/tests/test_system_utils.py index 569d1a3..1a73396 100644 --- a/tests/test_system_utils.py +++ b/tests/test_system_utils.py @@ -1,6 +1,8 @@ import pytest -from amoco.system.utils import * +from amoco.system.core import DataIO +from amoco.system.structs.HEX import HEX, HEXline, EndOfFile +from amoco.system.structs.SREC import SREC def test_parser_hex(samples): for filename in samples: