/* deflate.c -- compress data using the deflation algorithm * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler * For conditions of distribution and use, see copyright notice in zlib.h */ /* * ALGORITHM * * The "deflation" process depends on being able to identify portions * of the input text which are identical to earlier input (within a * sliding window trailing behind the input currently being processed). * * The most straightforward technique turns out to be the fastest for * most input files: try all possible matches and select the longest. * The key feature of this algorithm is that insertions into the string * dictionary are very simple and thus fast, and deletions are avoided * completely. Insertions are performed at each input character, whereas * string matches are performed only when the previous match ends. So it * is preferable to spend more time in matches to allow very fast string * insertions and avoid deletions. The matching algorithm for small * strings is inspired from that of Rabin & Karp. A brute force approach * is used to find longer strings when a small match has been found. * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze * (by Leonid Broukhis). * A previous version of this file used a more sophisticated algorithm * (by Fiala and Greene) which is guaranteed to run in linear amortized * time, but has a larger average cost, uses more memory and is patented. * However the F&G algorithm may be faster for some highly redundant * files if the parameter max_chain_length (described below) is too large. * * ACKNOWLEDGEMENTS * * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and * I found it in 'freeze' written by Leonid Broukhis. * Thanks to many people for bug reports and testing. * * REFERENCES * * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". * Available in http://www.ietf.org/rfc/rfc1951.txt * * A description of the Rabin and Karp algorithm is given in the book * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. * * Fiala,E.R., and Greene,D.H. * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 * */ /* @(#) $Id$ */ #include "deflate.h" const char deflate_copyright[] = " deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot include such an acknowledgment, I would appreciate that you keep this copyright string in the executable of your product. */ /* =========================================================================== * Function prototypes. */ typedef enum { need_more, /* block not completed, need more input or more output */ block_done, /* block flush performed */ finish_started, /* finish started, need only more output at next deflate */ finish_done /* finish done, accept no more input or output */ } block_state; typedef block_state (*compress_func) OF((deflate_state *s, int flush)); /* Compression function. Returns the block state after the call. */ local void fill_window OF((deflate_state *s)); local block_state deflate_stored OF((deflate_state *s, int flush)); local block_state deflate_fast OF((deflate_state *s, int flush)); #ifndef FASTEST local block_state deflate_slow OF((deflate_state *s, int flush)); #endif local block_state deflate_rle OF((deflate_state *s, int flush)); local block_state deflate_huff OF((deflate_state *s, int flush)); local void lm_init OF((deflate_state *s)); local void putShortMSB OF((deflate_state *s, uInt b)); local void flush_pending OF((z_streamp strm)); local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); #ifdef ASMV void match_init OF((void)); /* asm code initialization */ uInt longest_match OF((deflate_state *s, IPos cur_match)); #else local uInt longest_match OF((deflate_state *s, IPos cur_match)); #endif #ifdef DEBUG local void check_match OF((deflate_state *s, IPos start, IPos match, int length)); #endif /* =========================================================================== * Local data */ #define NIL 0 /* Tail of hash chains */ #ifndef TOO_FAR # define TOO_FAR 4096 #endif /* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ /* Values for max_lazy_match, good_match and max_chain_length, depending on * the desired pack level (0..9). The values given below have been tuned to * exclude worst case performance for pathological files. Better values may be * found for specific files. */ typedef struct config_s { ush good_length; /* reduce lazy search above this match length */ ush max_lazy; /* do not perform lazy search above this match length */ ush nice_length; /* quit search above this match length */ ush max_chain; compress_func func; } config; #ifdef FASTEST local const config configuration_table[2] = { /* good lazy nice chain */ /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ /* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ #else local const config configuration_table[10] = { /* good lazy nice chain */ /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ /* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ /* 2 */ {4, 5, 16, 8, deflate_fast}, /* 3 */ {4, 6, 32, 32, deflate_fast}, /* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ /* 5 */ {8, 16, 32, 32, deflate_slow}, /* 6 */ {8, 16, 128, 128, deflate_slow}, /* 7 */ {8, 32, 128, 256, deflate_slow}, /* 8 */ {32, 128, 258, 1024, deflate_slow}, /* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ #endif /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different * meaning. */ #define EQUAL 0 /* result of memcmp for equal strings */ #ifndef NO_DUMMY_DECL struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ #endif /* =========================================================================== * Update a hash value with the given input byte * IN assertion: all calls to to UPDATE_HASH are made with consecutive * input characters, so that a running hash key can be computed from the * previous key instead of complete recalculation each time. */ #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) /* =========================================================================== * Insert string str in the dictionary and set match_head to the previous head * of the hash chain (the most recent string with same hash key). Return * the previous length of the hash chain. * If this file is compiled with -DFASTEST, the compression level is forced * to 1, and no hash chains are maintained. * IN assertion: all calls to to INSERT_STRING are made with consecutive * input characters and the first MIN_MATCH bytes of str are valid * (except for the last MIN_MATCH-1 bytes of the input file). */ #ifdef FASTEST #define INSERT_STRING(s, str, match_head) \ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ match_head = s->head[s->ins_h], \ s->head[s->ins_h] = (Pos)(str)) #else #define INSERT_STRING(s, str, match_head) \ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ s->head[s->ins_h] = (Pos)(str)) #endif /* =========================================================================== * Initialize the hash table (avoiding 64K overflow for 16 bit systems). * prev[] will be initialized on the fly. */ #define CLEAR_HASH(s) \ s->head[s->hash_size-1] = NIL; \ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); /* ========================================================================= */ int ZEXPORT deflateInit_(strm, level, version, stream_size) z_streamp strm; int level; const char *version; int stream_size; { return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size); /* To do: ignore strm->next_in if we use it as window */ } /* ========================================================================= */ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, version, stream_size) z_streamp strm; int level; int method; int windowBits; int memLevel; int strategy; const char *version; int stream_size; { deflate_state *s; int wrap = 1; static const char my_version[] = ZLIB_VERSION; ushf *overlay; /* We overlay pending_buf and d_buf+l_buf. This works since the average * output size for (length,distance) codes is <= 24 bits. */ if (version == Z_NULL || version[0] != my_version[0] || stream_size != sizeof(z_stream)) { return Z_VERSION_ERROR; } if (strm == Z_NULL) return Z_STREAM_ERROR; strm->msg = Z_NULL; if (strm->zalloc == (alloc_func)0) { strm->zalloc = zcalloc; strm->opaque = (voidpf)0; } if (strm->zfree == (free_func)0) strm->zfree = zcfree; #ifdef FASTEST if (level != 0) level = 1; #else if (level == Z_DEFAULT_COMPRESSION) level = 6; #endif if (windowBits < 0) { /* suppress zlib wrapper */ wrap = 0; windowBits = -windowBits; } #ifdef GZIP else if (windowBits > 15) { wrap = 2; /* write gzip wrapper instead */ windowBits -= 16; } #endif if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { return Z_STREAM_ERROR; } if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); if (s == Z_NULL) return Z_MEM_ERROR; strm->state = (struct internal_state FAR *)s; s->strm = strm; s->wrap = wrap; s->gzhead = Z_NULL; s->w_bits = windowBits; s->w_size = 1 << s->w_bits; s->w_mask = s->w_size - 1; s->hash_bits = memLevel + 7; s->hash_size = 1 << s->hash_bits; s->hash_mask = s->hash_size - 1; s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); s->high_water = 0; /* nothing written to s->window yet */ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); s->pending_buf = (uchf *) overlay; s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || s->pending_buf == Z_NULL) { s->status = FINISH_STATE; strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); deflateEnd (strm); return Z_MEM_ERROR; } s->d_buf = overlay + s->lit_bufsize/sizeof(ush); s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; s->level = level; s->strategy = strategy; s->method = (Byte)method; return deflateReset(strm); } /* ========================================================================= */ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) z_streamp strm; const Bytef *dictionary; uInt dictLength; { deflate_state *s; uInt length = dictLength; uInt n; IPos hash_head = 0; if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || strm->state->wrap == 2 || (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) return Z_STREAM_ERROR; s = strm->state; if (s->wrap) strm->adler = adler32(strm->adler, dictionary, dictLength); if (length < MIN_MATCH) return Z_OK; if (length > s->w_size) { length = s->w_size; dictionary += dictLength - length; /* use the tail of the dictionary */ } zmemcpy(s->window, dictionary, length); s->strstart = length; s->block_start = (long)length; /* Insert all strings in the hash table (except for the last two bytes). * s->lookahead stays null, so s->ins_h will be recomputed at the next * call of fill_window. */ s->ins_h = s->window[0]; UPDATE_HASH(s, s->ins_h, s->window[1]); for (n = 0; n <= length - MIN_MATCH; n++) { INSERT_STRING(s, n, hash_head); } if (hash_head) hash_head = 0; /* to make compiler happy */ return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateReset (strm) z_streamp strm; { deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { return Z_STREAM_ERROR; } strm->total_in = strm->total_out = 0; strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ strm->data_type = Z_UNKNOWN; s = (deflate_state *)strm->state; s->pending = 0; s->pending_out = s->pending_buf; if (s->wrap < 0) { s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ } s->status = s->wrap ? INIT_STATE : BUSY_STATE; strm->adler = #ifdef GZIP s->wrap == 2 ? crc32(0L, Z_NULL, 0) : #endif adler32(0L, Z_NULL, 0); s->last_flush = Z_NO_FLUSH; _tr_init(s); lm_init(s); return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateSetHeader (strm, head) z_streamp strm; gz_headerp head; { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; if (strm->state->wrap != 2) return Z_STREAM_ERROR; strm->state->gzhead = head; return Z_OK; } /* ========================================================================= */ int ZEXPORT deflatePrime (strm, bits, value) z_streamp strm; int bits; int value; { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; strm->state->bi_valid = bits; strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); return Z_OK; } /* ========================================================================= */ int ZEXPORT deflateParams(strm, level, strategy) z_streamp strm; int level; int strategy; { deflate_state *s; compress_func func; int err = Z_OK; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; s = strm->state; #ifdef FASTEST if (level != 0) level = 1; #else if (level == Z_DEFAULT_COMPRESSION) level = 6; #endif if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { return Z_STREAM_ERROR; } func = configuration_table[s->level].func; if ((strategy != s->strategy || func != configuration_table[level].func) && strm->total_in != 0) { /* Flush the last buffer: */ err = deflate(strm, Z_BLOCK); } if (s->level != level) { s->level = level; s->max_lazy_match = configuration_table[level].max_lazy; s->good_match = configuration_table[level].good_length; s->nice_match = configuration_table[level].nice_length; s->max_chain_length = configuration_table[level].max_chain; } s->strategy = strategy; return err; } /* ========================================================================= */ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) z_streamp strm; int good_length; int max_lazy; int nice_length; int max_chain; { deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; s = strm->state; s->good_match = good_length; s->max_lazy_match = max_lazy; s->nice_match = nice_length; s->max_chain_length = max_chain; return Z_OK; } /* ========================================================================= * For the default windowBits of 15 and memLevel of 8, this function returns * a close to exact, as well as small, upper bound on the compressed size. * They are coded as constants here for a reason--if the #define's are * changed, then this function needs to be changed as well. The return * value for 15 and 8 only works for those exact settings. * * For any setting other than those defaults for windowBits and memLevel, * the value returned is a conservative worst case for the maximum expansion * resulting from using fixed blocks instead of stored blocks, which deflate * can emit on compressed data for some combinations of the parameters. * * This function could be more sophisticated to provide closer upper bounds for * every combination of windowBits and memLevel. But even the conservative * upper bound of about 14% expansion does not seem onerous for output buffer * allocation. */ uLong ZEXPORT deflateBound(strm, sourceLen) z_streamp strm; uLong sourceLen; { deflate_state *s; uLong complen, wraplen; Bytef *str; /* conservative upper bound for compressed data */ complen = sourceLen + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; /* if can't get parameters, return conservative bound plus zlib wrapper */ if (strm == Z_NULL || strm->state == Z_NULL) return complen + 6; /* compute wrapper length */ s = strm->state; switch (s->wrap) { case 0: /* raw deflate */ wraplen = 0; break; case 1: /* zlib wrapper */ wraplen = 6 + (s->strstart ? 4 : 0); break; case 2: /* gzip wrapper */ wraplen = 18; if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ if (s->gzhead->extra != Z_NULL) wraplen += 2 + s->gzhead->extra_len; str = s->gzhead->name; if (str != Z_NULL) do { wraplen++; } while (*str++); str = s->gzhead->comment; if (str != Z_NULL) do { wraplen++; } while (*str++); if (s->gzhead->hcrc) wraplen += 2; } break; default: /* for compiler happiness */ wraplen = 6; } /* if not default parameters, return conservative bound */ if (s->w_bits != 15 || s->hash_bits != 8 + 7) return complen + wraplen; /* default settings: return tight bound for that case */ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen; } /* ========================================================================= * Put a short in the pending buffer. The 16-bit value is put in MSB order. * IN assertion: the stream state is correct and there is enough room in * pending_buf. */ local void putShortMSB (s, b) deflate_state *s; uInt b; { put_byte(s, (Byte)(b >> 8)); put_byte(s, (Byte)(b & 0xff)); } /* ========================================================================= * Flush as much pending output as possible. All deflate() output goes * through this function so some applications may wish to modify it * to avoid allocating a large strm->next_out buffer and copying into it. * (See also read_buf()). */ local void flush_pending(strm) z_streamp strm; { unsigned len = strm->state->pending; if (len > strm->avail_out) len = strm->avail_out; if (len == 0) return; zmemcpy(strm->next_out, strm->state->pending_out, len); strm->next_out += len; strm->state->pending_out += len; strm->total_out += len; strm->avail_out -= len; strm->state->pending -= len; if (strm->state->pending == 0) { strm->state->pending_out = strm->state->pending_buf; } } /* ========================================================================= */ int ZEXPORT deflate (strm, flush) z_streamp strm; int flush; { int old_flush; /* value of flush param for previous deflate call */ deflate_state *s; if (strm == Z_NULL || strm->state == Z_NULL || flush > Z_BLOCK || flush < 0) { return Z_STREAM_ERROR; } s = strm->state; if (strm->next_out == Z_NULL || (strm->next_in == Z_NULL && strm->avail_in != 0) || (s->status == FINISH_STATE && flush != Z_FINISH)) { ERR_RETURN(strm, Z_STREAM_ERROR); } if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); s->strm = strm; /* just in case */ old_flush = s->last_flush; s->last_flush = flush; /* Write the header */ if (s->status == INIT_STATE) { #ifdef GZIP if (s->wrap == 2) { strm->adler = crc32(0L, Z_NULL, 0); put_byte(s, 31); put_byte(s, 139); put_byte(s, 8); if (s->gzhead == Z_NULL) { put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); put_byte(s, OS_CODE); s->status = BUSY_STATE; } else { put_byte(s, (s->gzhead->text ? 1 : 0) + (s->gzhead->hcrc ? 2 : 0) + (s->gzhead->extra == Z_NULL ? 0 : 4) + (s->gzhead->name == Z_NULL ? 0 : 8) + (s->gzhead->comment == Z_NULL ? 0 : 16) ); put_byte(s, (Byte)(s->gzhead->time & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); put_byte(s, s->gzhead->os & 0xff); if (s->gzhead->extra != Z_NULL) { put_byte(s, s->gzhead->extra_len & 0xff); put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); } if (s->gzhead->hcrc) strm->adler = crc32(strm->adler, s->pending_buf, s->pending); s->gzindex = 0; s->status = EXTRA_STATE; } } else #endif { uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; uInt level_flags; if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) level_flags = 0; else if (s->level < 6) level_flags = 1; else if (s->level == 6) level_flags = 2; else level_flags = 3; header |= (level_flags << 6); if (s->strstart != 0) header |= PRESET_DICT; header += 31 - (header % 31); s->status = BUSY_STATE; putShortMSB(s, header); /* Save the adler32 of the preset dictionary: */ if (s->strstart != 0) { putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } strm->adler = adler32(0L, Z_NULL, 0); } } #ifdef GZIP if (s->status == EXTRA_STATE) { if (s->gzhead->extra != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) break; } put_byte(s, s->gzhead->extra[s->gzindex]); s->gzindex++; } if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (s->gzindex == s->gzhead->extra_len) { s->gzindex = 0; s->status = NAME_STATE; } } else s->status = NAME_STATE; } if (s->status == NAME_STATE) { if (s->gzhead->name != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ int val; do { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) { val = 1; break; } } val = s->gzhead->name[s->gzindex++]; put_byte(s, val); } while (val != 0); if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (val == 0) { s->gzindex = 0; s->status = COMMENT_STATE; } } else s->status = COMMENT_STATE; } if (s->status == COMMENT_STATE) { if (s->gzhead->comment != Z_NULL) { uInt beg = s->pending; /* start of bytes to update crc */ int val; do { if (s->pending == s->pending_buf_size) { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); flush_pending(strm); beg = s->pending; if (s->pending == s->pending_buf_size) { val = 1; break; } } val = s->gzhead->comment[s->gzindex++]; put_byte(s, val); } while (val != 0); if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); if (val == 0) s->status = HCRC_STATE; } else s->status = HCRC_STATE; } if (s->status == HCRC_STATE) { if (s->gzhead->hcrc) { if (s->pending + 2 > s->pending_buf_size) flush_pending(strm); if (s->pending + 2 <= s->pending_buf_size) { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); strm->adler = crc32(0L, Z_NULL, 0); s->status = BUSY_STATE; } } else s->status = BUSY_STATE; } #endif /* Flush as much pending output as possible */ if (s->pending != 0) { flush_pending(strm); if (strm->avail_out == 0) { /* Since avail_out is 0, deflate will be called again with * more output space, but possibly with both pending and * avail_in equal to zero. There won't be anything to do, * but this is not an error situation so make sure we * return OK instead of BUF_ERROR at next call of deflate: */ s->last_flush = -1; return Z_OK; } /* Make sure there is something to do and avoid duplicate consecutive * flushes. For repeated and useless calls with Z_FINISH, we keep * returning Z_STREAM_END instead of Z_BUF_ERROR. */ } else if (strm->avail_in == 0 && flush <= old_flush && flush != Z_FINISH) { ERR_RETURN(strm, Z_BUF_ERROR); } /* User must not provide more input after the first FINISH: */ if (s->status == FINISH_STATE && strm->avail_in != 0) { ERR_RETURN(strm, Z_BUF_ERROR); } /* Start a new block or continue the current one. */ if (strm->avail_in != 0 || s->lookahead != 0 || (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { block_state bstate; bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : (s->strategy == Z_RLE ? deflate_rle(s, flush) : (*(configuration_table[s->level].func))(s, flush)); if (bstate == finish_started || bstate == finish_done) { s->status = FINISH_STATE; } if (bstate == need_more || bstate == finish_started) { if (strm->avail_out == 0) { s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ } return Z_OK; /* If flush != Z_NO_FLUSH && avail_out == 0, the next call * of deflate should use the same flush parameter to make sure * that the flush is complete. So we don't have to output an * empty block here, this will be done at next call. This also * ensures that for a very small output buffer, we emit at most * one empty block. */ } if (bstate == block_done) { if (flush == Z_PARTIAL_FLUSH) { _tr_align(s); } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ _tr_stored_block(s, (char*)0, 0L, 0); /* For a full flush, this empty block will be recognized * as a special marker by inflate_sync(). */ if (flush == Z_FULL_FLUSH) { CLEAR_HASH(s); /* forget history */ if (s->lookahead == 0) { s->strstart = 0; s->block_start = 0L; } } } flush_pending(strm); if (strm->avail_out == 0) { s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ return Z_OK; } } } Assert(strm->avail_out > 0, "bug2"); if (flush != Z_FINISH) return Z_OK; if (s->wrap <= 0) return Z_STREAM_END; /* Write the trailer */ #ifdef GZIP if (s->wrap == 2) { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); put_byte(s, (Byte)(strm->total_in & 0xff)); put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); } else #endif { putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } flush_pending(strm); /* If avail_out is zero, the application will call deflate again * to flush the rest. */ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ return s->pending != 0 ? Z_OK : Z_STREAM_END; } /* ========================================================================= */ int ZEXPORT deflateEnd (strm) z_streamp strm; { int status; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; status = strm->state->status; if (status != INIT_STATE && status != EXTRA_STATE && status != NAME_STATE && status != COMMENT_STATE && status != HCRC_STATE && status != BUSY_STATE && status != FINISH_STATE) { return Z_STREAM_ERROR; } /* Deallocate in reverse order of allocations: */ TRY_FREE(strm, strm->state->pending_buf); TRY_FREE(strm, strm->state->head); TRY_FREE(strm, strm->state->prev); TRY_FREE(strm, strm->state->window); ZFREE(strm, strm->state); strm->state = Z_NULL; return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; } /* ========================================================================= * Copy the source state to the destination state. * To simplify the source, this is not supported for 16-bit MSDOS (which * doesn't have enough memory anyway to duplicate compression states). */ int ZEXPORT deflateCopy (dest, source) z_streamp dest; z_streamp source; { #ifdef MAXSEG_64K return Z_STREAM_ERROR; #else deflate_state *ds; deflate_state *ss; ushf *overlay; if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { return Z_STREAM_ERROR; } ss = source->state; zmemcpy(dest, source, sizeof(z_stream)); ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); if (ds == Z_NULL) return Z_MEM_ERROR; dest->state = (struct internal_state FAR *) ds; zmemcpy(ds, ss, sizeof(deflate_state)); ds->strm = dest; ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); ds->pending_buf = (uchf *) overlay; if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || ds->pending_buf == Z_NULL) { deflateEnd (dest); return Z_MEM_ERROR; } /* following zmemcpy do not work for 16-bit MSDOS */ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; ds->l_desc.dyn_tree = ds->dyn_ltree; ds->d_desc.dyn_tree = ds->dyn_dtree; ds->bl_desc.dyn_tree = ds->bl_tree; return Z_OK; #endif /* MAXSEG_64K */ } /* =========================================================================== * Read a new buffer from the current input stream, update the adler32 * and total number of bytes read. All deflate() input goes through * this function so some applications may wish to modify it to avoid * allocating a large strm->next_in buffer and copying from it. * (See also flush_pending()). */ local int read_buf(strm, buf, size) z_streamp strm; Bytef *buf; unsigned size; { unsigned len = strm->avail_in; if (len > size) len = size; if (len == 0) return 0; strm->avail_in -= len; if (strm->state->wrap == 1) { strm->adler = adler32(strm->adler, strm->next_in, len); } #ifdef GZIP else if (strm->state->wrap == 2) { strm->adler = crc32(strm->adler, strm->next_in, len); } #endif zmemcpy(buf, strm->next_in, len); strm->next_in += len; strm->total_in += len; return (int)len; } /* =========================================================================== * Initialize the "longest match" routines for a new zlib stream */ local void lm_init (s) deflate_state *s; { s->window_size = (ulg)2L*s->w_size; CLEAR_HASH(s); /* Set the default configuration parameters: */ s->max_lazy_match = configuration_table[s->level].max_lazy; s->good_match = configuration_table[s->level].good_length; s->nice_match = configuration_table[s->level].nice_length; s->max_chain_length = configuration_table[s->level].max_chain; s->strstart = 0; s->block_start = 0L; s->lookahead = 0; s->match_length = s->prev_length = MIN_MATCH-1; s->match_available = 0; s->ins_h = 0; #ifndef FASTEST #ifdef ASMV match_init(); /* initialize the asm code */ #endif #endif } #ifndef FASTEST /* =========================================================================== * Set match_start to the longest match starting at the given string and * return its length. Matches shorter or equal to prev_length are discarded, * in which case the result is equal to prev_length and match_start is * garbage. * IN assertions: cur_match is the head of the hash chain for the current * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 * OUT assertion: the match length is not greater than s->lookahead. */ #ifndef ASMV /* For 80x86 and 680x0, an optimized version will be provided in match.asm or * match.S. The code will be functionally equivalent. */ local uInt longest_match(s, cur_match) deflate_state *s; IPos cur_match; /* current match */ { unsigned chain_length = s->max_chain_length;/* max hash chain length */ register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ register int len; /* length of current match */ int best_len = s->prev_length; /* best match length so far */ int nice_match = s->nice_match; /* stop if match long enough */ IPos limit = s->strstart > (IPos)MAX_DIST(s) ? s->strstart - (IPos)MAX_DIST(s) : NIL; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. */ Posf *prev = s->prev; uInt wmask = s->w_mask; #ifdef UNALIGNED_OK /* Compare two bytes at a time. Note: this is not always beneficial. * Try with and without -DUNALIGNED_OK to check. */ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; register ush scan_start = *(ushf*)scan; register ush scan_end = *(ushf*)(scan+best_len-1); #else register Bytef *strend = s->window + s->strstart + MAX_MATCH; register Byte scan_end1 = scan[best_len-1]; register Byte scan_end = scan[best_len]; #endif /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); /* Do not waste too much time if we already have a good match: */ if (s->prev_length >= s->good_match) { chain_length >>= 2; } /* Do not look for matches beyond the end of the input. This is necessary * to make deflate deterministic. */ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); do { Assert(cur_match < s->strstart, "no future"); match = s->window + cur_match; /* Skip to next match if the match length cannot increase * or if the match length is less than 2. Note that the checks below * for insufficient lookahead only occur occasionally for performance * reasons. Therefore uninitialized memory will be accessed, and * conditional jumps will be made that depend on those values. * However the length of the match is limited to the lookahead, so * the output of deflate is not affected by the uninitialized values. */ #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) /* This code assumes sizeof(unsigned short) == 2. Do not use * UNALIGNED_OK if your compiler uses a different size. */ if (*(ushf*)(match+best_len-1) != scan_end || *(ushf*)match != scan_start) continue; /* It is not necessary to compare scan[2] and match[2] since they are * always equal when the other bytes match, given that the hash keys * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at * strstart+3, +5, ... up to strstart+257. We check for insufficient * lookahead only every 4th comparison; the 128th check will be made * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is * necessary to put more guard bytes at the end of the window, or * to check more often for insufficient lookahead. */ Assert(scan[2] == match[2], "scan[2]?"); scan++, match++; do { } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan+=2) == *(ushf*)(match+=2) && scan < strend); /* The funny "do {}" generates better code on most compilers */ /* Here, scan <= window+strstart+257 */ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); if (*scan == *match) scan++; len = (MAX_MATCH - 1) - (int)(strend-scan); scan = strend - (MAX_MATCH-1); #else /* UNALIGNED_OK */ if (match[best_len] != scan_end || match[best_len-1] != scan_end1 || *match != *scan || *++match != scan[1]) continue; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scan += 2, match++; Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && scan < strend); Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); scan = strend - MAX_MATCH; #endif /* UNALIGNED_OK */ if (len > best_len) { s->match_start = cur_match; best_len = len; if (len >= nice_match) break; #ifdef UNALIGNED_OK scan_end = *(ushf*)(scan+best_len-1); #else scan_end1 = scan[best_len-1]; scan_end = scan[best_len]; #endif } } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length != 0); if ((uInt)best_len <= s->lookahead) return (uInt)best_len; return s->lookahead; } #endif /* ASMV */ #else /* FASTEST */ /* --------------------------------------------------------------------------- * Optimized version for FASTEST only */ local uInt longest_match(s, cur_match) deflate_state *s; IPos cur_match; /* current match */ { register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ register int len; /* length of current match */ register Bytef *strend = s->window + s->strstart + MAX_MATCH; /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); Assert(cur_match < s->strstart, "no future"); match = s->window + cur_match; /* Return failure if the match length is less than 2: */ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scan += 2, match += 2; Assert(*scan == *match, "match[2]?"); /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while (*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && scan < strend); Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); if (len < MIN_MATCH) return MIN_MATCH - 1; s->match_start = cur_match; return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; } #endif /* FASTEST */ #ifdef DEBUG /* =========================================================================== * Check that the match at match_start is indeed a match. */ local void check_match(s, start, match, length) deflate_state *s; IPos start, match; int length; { /* check that the match is indeed a match */ if (zmemcmp(s->window + match, s->window + start, length) != EQUAL) { fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); do { fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); } while (--length != 0); z_error("invalid match"); } if (z_verbose > 1) { fprintf(stderr,"\\[%d,%d]", start-match, length); do { putc(s->window[start++], stderr); } while (--length != 0); } } #else # define check_match(s, start, match, length) #endif /* DEBUG */ /* =========================================================================== * Fill the window when the lookahead becomes insufficient. * Updates strstart and lookahead. * * IN assertion: lookahead < MIN_LOOKAHEAD * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD * At least one byte has been read, or avail_in == 0; reads are * performed for at least two bytes (required for the zip translate_eol * option -- not supported here). */ local void fill_window(s) deflate_state *s; { register unsigned n, m; register Posf *p; unsigned more; /* Amount of free space at the end of the window. */ uInt wsize = s->w_size; do { more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); /* Deal with !@#$% 64K limit: */ if (sizeof(int) <= 2) { if (more == 0 && s->strstart == 0 && s->lookahead == 0) { more = wsize; } else if (more == (unsigned)(-1)) { /* Very unlikely, but possible on 16 bit machine if * strstart == 0 && lookahead == 1 (input done a byte at time) */ more--; } } /* If the window is almost full and there is insufficient lookahead, * move the upper half to the lower one to make room in the upper half. */ if (s->strstart >= wsize+MAX_DIST(s)) { zmemcpy(s->window, s->window+wsize, (unsigned)wsize); s->match_start -= wsize; s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ s->block_start -= (long) wsize; /* Slide the hash table (could be avoided with 32 bit values at the expense of memory usage). We slide even when level == 0 to keep the hash table consistent if we switch back to level > 0 later. (Using level 0 permanently is not an optimal usage of zlib, so we don't care about this pathological case.) */ n = s->hash_size; p = &s->head[n]; do { m = *--p; *p = (Pos)(m >= wsize ? m-wsize : NIL); } while (--n); n = wsize; #ifndef FASTEST p = &s->prev[n]; do { m = *--p; *p = (Pos)(m >= wsize ? m-wsize : NIL); /* If n is not on any hash chain, prev[n] is garbage but * its value will never be used. */ } while (--n); #endif more += wsize; } if (s->strm->avail_in == 0) return; /* If there was no sliding: * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && * more == window_size - lookahead - strstart * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) * => more >= window_size - 2*WSIZE + 2 * In the BIG_MEM or MMAP case (not yet supported), * window_size == input_size + MIN_LOOKAHEAD && * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. * Otherwise, window_size == 2*WSIZE so more >= 2. * If there was sliding, more >= WSIZE. So in all cases, more >= 2. */ Assert(more >= 2, "more < 2"); n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); s->lookahead += n; /* Initialize the hash value now that we have some input: */ if (s->lookahead >= MIN_MATCH) { s->ins_h = s->window[s->strstart]; UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); #if MIN_MATCH != 3 Call UPDATE_HASH() MIN_MATCH-3 more times #endif } /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, * but this is not important since only literal bytes will be emitted. */ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); /* If the WIN_INIT bytes after the end of the current data have never been * written, then zero those bytes in order to avoid memory check reports of * the use of uninitialized (or uninitialised as Julian writes) bytes by * the longest match routines. Update the high water mark for the next * time through here. WIN_INIT is set to MAX_MATCH since the longest match * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. */ if (s->high_water < s->window_size) { ulg curr = s->strstart + (ulg)(s->lookahead); ulg init; if (s->high_water < curr) { /* Previous high water mark below current data -- zero WIN_INIT * bytes or up to end of window, whichever is less. */ init = s->window_size - curr; if (init > WIN_INIT) init = WIN_INIT; zmemzero(s->window + curr, (unsigned)init); s->high_water = curr + init; } else if (s->high_water < (ulg)curr + WIN_INIT) { /* High water mark at or above current data, but below current data * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up * to end of window, whichever is less. */ init = (ulg)curr + WIN_INIT - s->high_water; if (init > s->window_size - s->high_water) init = s->window_size - s->high_water; zmemzero(s->window + s->high_water, (unsigned)init); s->high_water += init; } } } /* =========================================================================== * Flush the current block, with given end-of-file flag. * IN assertion: strstart is set to the end of the current match. */ #define FLUSH_BLOCK_ONLY(s, last) { \ _tr_flush_block(s, (s->block_start >= 0L ? \ (charf *)&s->window[(unsigned)s->block_start] : \ (charf *)Z_NULL), \ (ulg)((long)s->strstart - s->block_start), \ (last)); \ s->block_start = s->strstart; \ flush_pending(s->strm); \ Tracev((stderr,"[FLUSH]")); \ } /* Same but force premature exit if necessary. */ #define FLUSH_BLOCK(s, last) { \ FLUSH_BLOCK_ONLY(s, last); \ if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ } /* =========================================================================== * Copy without compression as much as possible from the input stream, return * the current block state. * This function does not insert new strings in the dictionary since * uncompressible data is probably not useful. This function is used * only for the level=0 compression option. * NOTE: this function should be optimized to avoid extra copying from * window to pending_buf. */ local block_state deflate_stored(s, flush) deflate_state *s; int flush; { /* Stored blocks are limited to 0xffff bytes, pending_buf is limited * to pending_buf_size, and each stored block has a 5 byte header: */ ulg max_block_size = 0xffff; ulg max_start; if (max_block_size > s->pending_buf_size - 5) { max_block_size = s->pending_buf_size - 5; } /* Copy as much as possible from input to output: */ for (;;) { /* Fill the window as much as possible: */ if (s->lookahead <= 1) { Assert(s->strstart < s->w_size+MAX_DIST(s) || s->block_start >= (long)s->w_size, "slide too late"); fill_window(s); if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; if (s->lookahead == 0) break; /* flush the current block */ } Assert(s->block_start >= 0L, "block gone"); s->strstart += s->lookahead; s->lookahead = 0; /* Emit a stored block if pending_buf will be full: */ max_start = s->block_start + max_block_size; if (s->strstart == 0 || (ulg)s->strstart >= max_start) { /* strstart == 0 is possible when wraparound on 16-bit machine */ s->lookahead = (uInt)(s->strstart - max_start); s->strstart = (uInt)max_start; FLUSH_BLOCK(s, 0); } /* Flush if we may have to slide, otherwise block_start may become * negative and the data will be gone: */ if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { FLUSH_BLOCK(s, 0); } } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } /* =========================================================================== * Compress as much as possible from the input stream, return the current * block state. * This function does not perform lazy evaluation of matches and inserts * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ local block_state deflate_fast(s, flush) deflate_state *s; int flush; { IPos hash_head; /* head of the hash chain */ int bflush; /* set if current block must be flushed */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; if (s->lookahead >= MIN_MATCH) { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ s->match_length = longest_match (s, hash_head); /* longest_match() sets match_start */ } if (s->match_length >= MIN_MATCH) { check_match(s, s->strstart, s->match_start, s->match_length); _tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH, bflush); s->lookahead -= s->match_length; /* Insert new strings in the hash table only if the match length * is not too large. This saves time but degrades compression. */ #ifndef FASTEST if (s->match_length <= s->max_insert_length && s->lookahead >= MIN_MATCH) { s->match_length--; /* string at strstart already in table */ do { s->strstart++; INSERT_STRING(s, s->strstart, hash_head); /* strstart never exceeds WSIZE-MAX_MATCH, so there are * always MIN_MATCH bytes ahead. */ } while (--s->match_length != 0); s->strstart++; } else #endif { s->strstart += s->match_length; s->match_length = 0; s->ins_h = s->window[s->strstart]; UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); #if MIN_MATCH != 3 Call UPDATE_HASH() MIN_MATCH-3 more times #endif /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not * matter since it will be recomputed at next deflate call. */ } } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } #ifndef FASTEST /* =========================================================================== * Same as above, but achieves better compression. We use a lazy * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ local block_state deflate_slow(s, flush) deflate_state *s; int flush; { IPos hash_head; /* head of hash chain */ int bflush; /* set if current block must be flushed */ /* Process the input block. */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { fill_window(s); if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; if (s->lookahead >= MIN_MATCH) { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. */ s->prev_length = s->match_length, s->prev_match = s->match_start; s->match_length = MIN_MATCH-1; if (hash_head != NIL && s->prev_length < s->max_lazy_match && s->strstart - hash_head <= MAX_DIST(s)) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ s->match_length = longest_match (s, hash_head); /* longest_match() sets match_start */ if (s->match_length <= 5 && (s->strategy == Z_FILTERED #if TOO_FAR <= 32767 || (s->match_length == MIN_MATCH && s->strstart - s->match_start > TOO_FAR) #endif )) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ s->match_length = MIN_MATCH-1; } } /* If there was a match at the previous step and the current * match is not better, output the previous match: */ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ check_match(s, s->strstart-1, s->prev_match, s->prev_length); _tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - MIN_MATCH, bflush); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. If there is not * enough lookahead, the last two strings are not inserted in * the hash table. */ s->lookahead -= s->prev_length-1; s->prev_length -= 2; do { if (++s->strstart <= max_insert) { INSERT_STRING(s, s->strstart, hash_head); } } while (--s->prev_length != 0); s->match_available = 0; s->match_length = MIN_MATCH-1; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); } else if (s->match_available) { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ Tracevv((stderr,"%c", s->window[s->strstart-1])); _tr_tally_lit(s, s->window[s->strstart-1], bflush); if (bflush) { FLUSH_BLOCK_ONLY(s, 0); } s->strstart++; s->lookahead--; if (s->strm->avail_out == 0) return need_more; } else { /* There is no previous match to compare with, wait for * the next step to decide. */ s->match_available = 1; s->strstart++; s->lookahead--; } } Assert (flush != Z_NO_FLUSH, "no flush?"); if (s->match_available) { Tracevv((stderr,"%c", s->window[s->strstart-1])); _tr_tally_lit(s, s->window[s->strstart-1], bflush); s->match_available = 0; } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } #endif /* FASTEST */ /* =========================================================================== * For Z_RLE, simply look for runs of bytes, generate matches only of distance * one. Do not maintain a hash table. (It will be regenerated if this run of * deflate switches away from Z_RLE.) */ local block_state deflate_rle(s, flush) deflate_state *s; int flush; { int bflush; /* set if current block must be flushed */ uInt prev; /* byte at distance one to match */ Bytef *scan, *strend; /* scan goes up to strend for length of run */ for (;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the longest encodable run. */ if (s->lookahead < MAX_MATCH) { fill_window(s); if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { return need_more; } if (s->lookahead == 0) break; /* flush the current block */ } /* See how many times the previous byte repeats */ s->match_length = 0; if (s->lookahead >= MIN_MATCH && s->strstart > 0) { scan = s->window + s->strstart - 1; prev = *scan; if (prev == *++scan && prev == *++scan && prev == *++scan) { strend = s->window + s->strstart + MAX_MATCH; do { } while (prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && scan < strend); s->match_length = MAX_MATCH - (int)(strend - scan); if (s->match_length > s->lookahead) s->match_length = s->lookahead; } } /* Emit match if have run of MIN_MATCH or longer, else emit literal */ if (s->match_length >= MIN_MATCH) { check_match(s, s->strstart, s->strstart - 1, s->match_length); _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); s->lookahead -= s->match_length; s->strstart += s->match_length; s->match_length = 0; } else { /* No match, output a literal byte */ Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } /* =========================================================================== * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. * (It will be regenerated if this run of deflate switches away from Huffman.) */ local block_state deflate_huff(s, flush) deflate_state *s; int flush; { int bflush; /* set if current block must be flushed */ for (;;) { /* Make sure that we have a literal to write. */ if (s->lookahead == 0) { fill_window(s); if (s->lookahead == 0) { if (flush == Z_NO_FLUSH) return need_more; break; /* flush the current block */ } } /* Output a literal byte */ s->match_length = 0; Tracevv((stderr,"%c", s->window[s->strstart])); _tr_tally_lit (s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); } FLUSH_BLOCK(s, flush == Z_FINISH); return flush == Z_FINISH ? finish_done : block_done; } /a> <a id='n1745' href='#n1745'>1745</a> <a id='n1746' href='#n1746'>1746</a> <a id='n1747' href='#n1747'>1747</a> <a id='n1748' href='#n1748'>1748</a> <a id='n1749' href='#n1749'>1749</a> <a id='n1750' href='#n1750'>1750</a> <a id='n1751' href='#n1751'>1751</a> <a id='n1752' href='#n1752'>1752</a> <a id='n1753' href='#n1753'>1753</a> <a id='n1754' href='#n1754'>1754</a> <a id='n1755' href='#n1755'>1755</a> <a id='n1756' href='#n1756'>1756</a> <a id='n1757' href='#n1757'>1757</a> <a id='n1758' href='#n1758'>1758</a> <a id='n1759' href='#n1759'>1759</a> <a id='n1760' href='#n1760'>1760</a> <a id='n1761' href='#n1761'>1761</a> <a id='n1762' href='#n1762'>1762</a> <a id='n1763' href='#n1763'>1763</a> <a id='n1764' href='#n1764'>1764</a> <a id='n1765' href='#n1765'>1765</a> <a id='n1766' href='#n1766'>1766</a> <a id='n1767' href='#n1767'>1767</a> <a id='n1768' href='#n1768'>1768</a> <a id='n1769' href='#n1769'>1769</a> <a id='n1770' href='#n1770'>1770</a> <a id='n1771' href='#n1771'>1771</a> <a id='n1772' href='#n1772'>1772</a> <a id='n1773' href='#n1773'>1773</a> <a id='n1774' href='#n1774'>1774</a> <a id='n1775' href='#n1775'>1775</a> <a id='n1776' href='#n1776'>1776</a> <a id='n1777' href='#n1777'>1777</a> <a id='n1778' href='#n1778'>1778</a> <a id='n1779' href='#n1779'>1779</a> <a id='n1780' href='#n1780'>1780</a> <a id='n1781' href='#n1781'>1781</a> <a id='n1782' href='#n1782'>1782</a> <a id='n1783' href='#n1783'>1783</a> <a id='n1784' href='#n1784'>1784</a> <a id='n1785' href='#n1785'>1785</a> <a id='n1786' href='#n1786'>1786</a> <a id='n1787' href='#n1787'>1787</a> <a id='n1788' href='#n1788'>1788</a> <a id='n1789' href='#n1789'>1789</a> <a id='n1790' href='#n1790'>1790</a> <a id='n1791' href='#n1791'>1791</a> <a id='n1792' href='#n1792'>1792</a> <a id='n1793' href='#n1793'>1793</a> <a id='n1794' href='#n1794'>1794</a> <a id='n1795' href='#n1795'>1795</a> <a id='n1796' href='#n1796'>1796</a> <a id='n1797' href='#n1797'>1797</a> <a id='n1798' href='#n1798'>1798</a> <a id='n1799' href='#n1799'>1799</a> <a id='n1800' href='#n1800'>1800</a> <a id='n1801' href='#n1801'>1801</a> <a id='n1802' href='#n1802'>1802</a> <a id='n1803' href='#n1803'>1803</a> <a id='n1804' href='#n1804'>1804</a> <a id='n1805' href='#n1805'>1805</a> <a id='n1806' href='#n1806'>1806</a> <a id='n1807' href='#n1807'>1807</a> <a id='n1808' href='#n1808'>1808</a> <a id='n1809' href='#n1809'>1809</a> <a id='n1810' href='#n1810'>1810</a> <a id='n1811' href='#n1811'>1811</a> <a id='n1812' href='#n1812'>1812</a> <a id='n1813' href='#n1813'>1813</a> <a id='n1814' href='#n1814'>1814</a> <a id='n1815' href='#n1815'>1815</a> <a id='n1816' href='#n1816'>1816</a> <a id='n1817' href='#n1817'>1817</a> <a id='n1818' href='#n1818'>1818</a> <a id='n1819' href='#n1819'>1819</a> <a id='n1820' href='#n1820'>1820</a> <a id='n1821' href='#n1821'>1821</a> <a id='n1822' href='#n1822'>1822</a> <a id='n1823' href='#n1823'>1823</a> <a id='n1824' href='#n1824'>1824</a> <a id='n1825' href='#n1825'>1825</a> <a id='n1826' href='#n1826'>1826</a> <a id='n1827' href='#n1827'>1827</a> <a id='n1828' href='#n1828'>1828</a> <a id='n1829' href='#n1829'>1829</a> <a id='n1830' href='#n1830'>1830</a> <a id='n1831' href='#n1831'>1831</a> <a id='n1832' href='#n1832'>1832</a> <a id='n1833' href='#n1833'>1833</a> <a id='n1834' href='#n1834'>1834</a> <a id='n1835' href='#n1835'>1835</a> <a id='n1836' href='#n1836'>1836</a> <a id='n1837' href='#n1837'>1837</a> <a id='n1838' href='#n1838'>1838</a> <a id='n1839' href='#n1839'>1839</a> <a id='n1840' href='#n1840'>1840</a> <a id='n1841' href='#n1841'>1841</a> <a id='n1842' href='#n1842'>1842</a> <a id='n1843' href='#n1843'>1843</a> <a id='n1844' href='#n1844'>1844</a> <a id='n1845' href='#n1845'>1845</a> <a id='n1846' href='#n1846'>1846</a> <a id='n1847' href='#n1847'>1847</a> <a id='n1848' href='#n1848'>1848</a> <a id='n1849' href='#n1849'>1849</a> <a id='n1850' href='#n1850'>1850</a> <a id='n1851' href='#n1851'>1851</a> <a id='n1852' href='#n1852'>1852</a> <a id='n1853' href='#n1853'>1853</a> <a id='n1854' href='#n1854'>1854</a> <a id='n1855' href='#n1855'>1855</a> <a id='n1856' href='#n1856'>1856</a> <a id='n1857' href='#n1857'>1857</a> <a id='n1858' href='#n1858'>1858</a> <a id='n1859' href='#n1859'>1859</a> <a id='n1860' href='#n1860'>1860</a> <a id='n1861' href='#n1861'>1861</a> <a id='n1862' href='#n1862'>1862</a> <a id='n1863' href='#n1863'>1863</a> <a id='n1864' href='#n1864'>1864</a> <a id='n1865' href='#n1865'>1865</a> <a id='n1866' href='#n1866'>1866</a> <a id='n1867' href='#n1867'>1867</a> <a id='n1868' href='#n1868'>1868</a> <a id='n1869' href='#n1869'>1869</a> <a id='n1870' href='#n1870'>1870</a> <a id='n1871' href='#n1871'>1871</a> <a id='n1872' href='#n1872'>1872</a> <a id='n1873' href='#n1873'>1873</a> <a id='n1874' href='#n1874'>1874</a> <a id='n1875' href='#n1875'>1875</a> <a id='n1876' href='#n1876'>1876</a> <a id='n1877' href='#n1877'>1877</a> <a id='n1878' href='#n1878'>1878</a> <a id='n1879' href='#n1879'>1879</a> <a id='n1880' href='#n1880'>1880</a> <a id='n1881' href='#n1881'>1881</a> <a id='n1882' href='#n1882'>1882</a> <a id='n1883' href='#n1883'>1883</a> <a id='n1884' href='#n1884'>1884</a> <a id='n1885' href='#n1885'>1885</a> <a id='n1886' href='#n1886'>1886</a> <a id='n1887' href='#n1887'>1887</a> <a id='n1888' href='#n1888'>1888</a> <a id='n1889' href='#n1889'>1889</a> <a id='n1890' href='#n1890'>1890</a> <a id='n1891' href='#n1891'>1891</a> <a id='n1892' href='#n1892'>1892</a> <a id='n1893' href='#n1893'>1893</a> <a id='n1894' href='#n1894'>1894</a> <a id='n1895' href='#n1895'>1895</a> <a id='n1896' href='#n1896'>1896</a> <a id='n1897' href='#n1897'>1897</a> <a id='n1898' href='#n1898'>1898</a> <a id='n1899' href='#n1899'>1899</a> <a id='n1900' href='#n1900'>1900</a> <a id='n1901' href='#n1901'>1901</a> <a id='n1902' href='#n1902'>1902</a> <a id='n1903' href='#n1903'>1903</a> <a id='n1904' href='#n1904'>1904</a> <a id='n1905' href='#n1905'>1905</a> <a id='n1906' href='#n1906'>1906</a> <a id='n1907' href='#n1907'>1907</a> <a id='n1908' href='#n1908'>1908</a> <a id='n1909' href='#n1909'>1909</a> <a id='n1910' href='#n1910'>1910</a> <a id='n1911' href='#n1911'>1911</a> <a id='n1912' href='#n1912'>1912</a> <a id='n1913' href='#n1913'>1913</a> <a id='n1914' href='#n1914'>1914</a> <a id='n1915' href='#n1915'>1915</a> <a id='n1916' href='#n1916'>1916</a> <a id='n1917' href='#n1917'>1917</a> <a id='n1918' href='#n1918'>1918</a> <a id='n1919' href='#n1919'>1919</a> <a id='n1920' href='#n1920'>1920</a> <a id='n1921' href='#n1921'>1921</a> <a id='n1922' href='#n1922'>1922</a> <a id='n1923' href='#n1923'>1923</a> <a id='n1924' href='#n1924'>1924</a> <a id='n1925' href='#n1925'>1925</a> <a id='n1926' href='#n1926'>1926</a> <a id='n1927' href='#n1927'>1927</a> <a id='n1928' href='#n1928'>1928</a> <a id='n1929' href='#n1929'>1929</a> <a id='n1930' href='#n1930'>1930</a> <a id='n1931' href='#n1931'>1931</a> <a id='n1932' href='#n1932'>1932</a> <a id='n1933' href='#n1933'>1933</a> <a id='n1934' href='#n1934'>1934</a> <a id='n1935' href='#n1935'>1935</a> <a id='n1936' href='#n1936'>1936</a> <a id='n1937' href='#n1937'>1937</a> <a id='n1938' href='#n1938'>1938</a> <a id='n1939' href='#n1939'>1939</a> <a id='n1940' href='#n1940'>1940</a> <a id='n1941' href='#n1941'>1941</a> <a id='n1942' href='#n1942'>1942</a> <a id='n1943' href='#n1943'>1943</a> <a id='n1944' href='#n1944'>1944</a> <a id='n1945' href='#n1945'>1945</a> <a id='n1946' href='#n1946'>1946</a> <a id='n1947' href='#n1947'>1947</a> <a id='n1948' href='#n1948'>1948</a> <a id='n1949' href='#n1949'>1949</a> <a id='n1950' href='#n1950'>1950</a> <a id='n1951' href='#n1951'>1951</a> <a id='n1952' href='#n1952'>1952</a> <a id='n1953' href='#n1953'>1953</a> <a id='n1954' href='#n1954'>1954</a> <a id='n1955' href='#n1955'>1955</a> <a id='n1956' href='#n1956'>1956</a> <a id='n1957' href='#n1957'>1957</a> <a id='n1958' href='#n1958'>1958</a> <a id='n1959' href='#n1959'>1959</a> <a id='n1960' href='#n1960'>1960</a> <a id='n1961' href='#n1961'>1961</a> <a id='n1962' href='#n1962'>1962</a> <a id='n1963' href='#n1963'>1963</a> <a id='n1964' href='#n1964'>1964</a> <a id='n1965' href='#n1965'>1965</a> <a id='n1966' href='#n1966'>1966</a> <a id='n1967' href='#n1967'>1967</a> <a id='n1968' href='#n1968'>1968</a> <a id='n1969' href='#n1969'>1969</a> <a id='n1970' href='#n1970'>1970</a> <a id='n1971' href='#n1971'>1971</a> <a id='n1972' href='#n1972'>1972</a> <a id='n1973' href='#n1973'>1973</a> <a id='n1974' href='#n1974'>1974</a> <a id='n1975' href='#n1975'>1975</a> <a id='n1976' href='#n1976'>1976</a> <a id='n1977' href='#n1977'>1977</a> <a id='n1978' href='#n1978'>1978</a> <a id='n1979' href='#n1979'>1979</a> <a id='n1980' href='#n1980'>1980</a> <a id='n1981' href='#n1981'>1981</a> <a id='n1982' href='#n1982'>1982</a> <a id='n1983' href='#n1983'>1983</a> <a id='n1984' href='#n1984'>1984</a> <a id='n1985' href='#n1985'>1985</a> <a id='n1986' href='#n1986'>1986</a> <a id='n1987' href='#n1987'>1987</a> <a id='n1988' href='#n1988'>1988</a> <a id='n1989' href='#n1989'>1989</a> <a id='n1990' href='#n1990'>1990</a> <a id='n1991' href='#n1991'>1991</a> <a id='n1992' href='#n1992'>1992</a> <a id='n1993' href='#n1993'>1993</a> <a id='n1994' href='#n1994'>1994</a> <a id='n1995' href='#n1995'>1995</a> <a id='n1996' href='#n1996'>1996</a> <a id='n1997' href='#n1997'>1997</a> <a id='n1998' href='#n1998'>1998</a> <a id='n1999' href='#n1999'>1999</a> <a id='n2000' href='#n2000'>2000</a> <a id='n2001' href='#n2001'>2001</a> <a id='n2002' href='#n2002'>2002</a> <a id='n2003' href='#n2003'>2003</a> <a id='n2004' href='#n2004'>2004</a> <a id='n2005' href='#n2005'>2005</a> <a id='n2006' href='#n2006'>2006</a> <a id='n2007' href='#n2007'>2007</a> <a id='n2008' href='#n2008'>2008</a> <a id='n2009' href='#n2009'>2009</a> <a id='n2010' href='#n2010'>2010</a> <a id='n2011' href='#n2011'>2011</a> <a id='n2012' href='#n2012'>2012</a> <a id='n2013' href='#n2013'>2013</a> <a id='n2014' href='#n2014'>2014</a> <a id='n2015' href='#n2015'>2015</a> <a id='n2016' href='#n2016'>2016</a> <a id='n2017' href='#n2017'>2017</a> <a id='n2018' href='#n2018'>2018</a> <a id='n2019' href='#n2019'>2019</a> <a id='n2020' href='#n2020'>2020</a> <a id='n2021' href='#n2021'>2021</a> <a id='n2022' href='#n2022'>2022</a> <a id='n2023' href='#n2023'>2023</a> <a id='n2024' href='#n2024'>2024</a> <a id='n2025' href='#n2025'>2025</a> <a id='n2026' href='#n2026'>2026</a> <a id='n2027' href='#n2027'>2027</a> <a id='n2028' href='#n2028'>2028</a> <a id='n2029' href='#n2029'>2029</a> <a id='n2030' href='#n2030'>2030</a> <a id='n2031' href='#n2031'>2031</a> <a id='n2032' href='#n2032'>2032</a> <a id='n2033' href='#n2033'>2033</a> <a id='n2034' href='#n2034'>2034</a> <a id='n2035' href='#n2035'>2035</a> <a id='n2036' href='#n2036'>2036</a> <a id='n2037' href='#n2037'>2037</a> <a id='n2038' href='#n2038'>2038</a> <a id='n2039' href='#n2039'>2039</a> <a id='n2040' href='#n2040'>2040</a> <a id='n2041' href='#n2041'>2041</a> <a id='n2042' href='#n2042'>2042</a> <a id='n2043' href='#n2043'>2043</a> <a id='n2044' href='#n2044'>2044</a> <a id='n2045' href='#n2045'>2045</a> <a id='n2046' href='#n2046'>2046</a> <a id='n2047' href='#n2047'>2047</a> <a id='n2048' href='#n2048'>2048</a> <a id='n2049' href='#n2049'>2049</a> <a id='n2050' href='#n2050'>2050</a> <a id='n2051' href='#n2051'>2051</a> <a id='n2052' href='#n2052'>2052</a> <a id='n2053' href='#n2053'>2053</a> <a id='n2054' href='#n2054'>2054</a> <a id='n2055' href='#n2055'>2055</a> <a id='n2056' href='#n2056'>2056</a> <a id='n2057' href='#n2057'>2057</a> <a id='n2058' href='#n2058'>2058</a> <a id='n2059' href='#n2059'>2059</a> <a id='n2060' href='#n2060'>2060</a> <a id='n2061' href='#n2061'>2061</a> <a id='n2062' href='#n2062'>2062</a> <a id='n2063' href='#n2063'>2063</a> <a id='n2064' href='#n2064'>2064</a> <a id='n2065' href='#n2065'>2065</a> <a id='n2066' href='#n2066'>2066</a> <a id='n2067' href='#n2067'>2067</a> <a id='n2068' href='#n2068'>2068</a> <a id='n2069' href='#n2069'>2069</a> <a id='n2070' href='#n2070'>2070</a> <a id='n2071' href='#n2071'>2071</a> <a id='n2072' href='#n2072'>2072</a> <a id='n2073' href='#n2073'>2073</a> <a id='n2074' href='#n2074'>2074</a> <a id='n2075' href='#n2075'>2075</a> <a id='n2076' href='#n2076'>2076</a> <a id='n2077' href='#n2077'>2077</a> <a id='n2078' href='#n2078'>2078</a> <a id='n2079' href='#n2079'>2079</a> <a id='n2080' href='#n2080'>2080</a> <a id='n2081' href='#n2081'>2081</a> <a id='n2082' href='#n2082'>2082</a> <a id='n2083' href='#n2083'>2083</a> <a id='n2084' href='#n2084'>2084</a> <a id='n2085' href='#n2085'>2085</a> <a id='n2086' href='#n2086'>2086</a> <a id='n2087' href='#n2087'>2087</a> <a id='n2088' href='#n2088'>2088</a> <a id='n2089' href='#n2089'>2089</a> <a id='n2090' href='#n2090'>2090</a> <a id='n2091' href='#n2091'>2091</a> <a id='n2092' href='#n2092'>2092</a> <a id='n2093' href='#n2093'>2093</a> <a id='n2094' href='#n2094'>2094</a> <a id='n2095' href='#n2095'>2095</a> <a id='n2096' href='#n2096'>2096</a> <a id='n2097' href='#n2097'>2097</a> <a id='n2098' href='#n2098'>2098</a> <a id='n2099' href='#n2099'>2099</a> <a id='n2100' href='#n2100'>2100</a> <a id='n2101' href='#n2101'>2101</a> <a id='n2102' href='#n2102'>2102</a> <a id='n2103' href='#n2103'>2103</a> <a id='n2104' href='#n2104'>2104</a> <a id='n2105' href='#n2105'>2105</a> <a id='n2106' href='#n2106'>2106</a> <a id='n2107' href='#n2107'>2107</a> <a id='n2108' href='#n2108'>2108</a> <a id='n2109' href='#n2109'>2109</a> <a id='n2110' href='#n2110'>2110</a> <a id='n2111' href='#n2111'>2111</a> <a id='n2112' href='#n2112'>2112</a> <a id='n2113' href='#n2113'>2113</a> <a id='n2114' href='#n2114'>2114</a> <a id='n2115' href='#n2115'>2115</a> <a id='n2116' href='#n2116'>2116</a> <a id='n2117' href='#n2117'>2117</a> <a id='n2118' href='#n2118'>2118</a> <a id='n2119' href='#n2119'>2119</a> <a id='n2120' href='#n2120'>2120</a> <a id='n2121' href='#n2121'>2121</a> <a id='n2122' href='#n2122'>2122</a> <a id='n2123' href='#n2123'>2123</a> <a id='n2124' href='#n2124'>2124</a> <a id='n2125' href='#n2125'>2125</a> <a id='n2126' href='#n2126'>2126</a> <a id='n2127' href='#n2127'>2127</a> <a id='n2128' href='#n2128'>2128</a> <a id='n2129' href='#n2129'>2129</a> <a id='n2130' href='#n2130'>2130</a> <a id='n2131' href='#n2131'>2131</a> <a id='n2132' href='#n2132'>2132</a> <a id='n2133' href='#n2133'>2133</a> <a id='n2134' href='#n2134'>2134</a> <a id='n2135' href='#n2135'>2135</a> <a id='n2136' href='#n2136'>2136</a> <a id='n2137' href='#n2137'>2137</a> <a id='n2138' href='#n2138'>2138</a> <a id='n2139' href='#n2139'>2139</a> <a id='n2140' href='#n2140'>2140</a> <a id='n2141' href='#n2141'>2141</a> <a id='n2142' href='#n2142'>2142</a> <a id='n2143' href='#n2143'>2143</a> <a id='n2144' href='#n2144'>2144</a> <a id='n2145' href='#n2145'>2145</a> <a id='n2146' href='#n2146'>2146</a> <a id='n2147' href='#n2147'>2147</a> <a id='n2148' href='#n2148'>2148</a> <a id='n2149' href='#n2149'>2149</a> <a id='n2150' href='#n2150'>2150</a> <a id='n2151' href='#n2151'>2151</a> <a id='n2152' href='#n2152'>2152</a> <a id='n2153' href='#n2153'>2153</a> <a id='n2154' href='#n2154'>2154</a> <a id='n2155' href='#n2155'>2155</a> <a id='n2156' href='#n2156'>2156</a> <a id='n2157' href='#n2157'>2157</a> <a id='n2158' href='#n2158'>2158</a> <a id='n2159' href='#n2159'>2159</a> <a id='n2160' href='#n2160'>2160</a> <a id='n2161' href='#n2161'>2161</a> <a id='n2162' href='#n2162'>2162</a> <a id='n2163' href='#n2163'>2163</a> <a id='n2164' href='#n2164'>2164</a> <a id='n2165' href='#n2165'>2165</a> <a id='n2166' href='#n2166'>2166</a> <a id='n2167' href='#n2167'>2167</a> <a id='n2168' href='#n2168'>2168</a> <a id='n2169' href='#n2169'>2169</a> <a id='n2170' href='#n2170'>2170</a> <a id='n2171' href='#n2171'>2171</a> <a id='n2172' href='#n2172'>2172</a> <a id='n2173' href='#n2173'>2173</a> <a id='n2174' href='#n2174'>2174</a> <a id='n2175' href='#n2175'>2175</a> <a id='n2176' href='#n2176'>2176</a> <a id='n2177' href='#n2177'>2177</a> <a id='n2178' href='#n2178'>2178</a> <a id='n2179' href='#n2179'>2179</a> <a id='n2180' href='#n2180'>2180</a> <a id='n2181' href='#n2181'>2181</a> <a id='n2182' href='#n2182'>2182</a> <a id='n2183' href='#n2183'>2183</a> <a id='n2184' href='#n2184'>2184</a> <a id='n2185' href='#n2185'>2185</a> <a id='n2186' href='#n2186'>2186</a> <a id='n2187' href='#n2187'>2187</a> <a id='n2188' href='#n2188'>2188</a> <a id='n2189' href='#n2189'>2189</a> <a id='n2190' href='#n2190'>2190</a> <a id='n2191' href='#n2191'>2191</a> <a id='n2192' href='#n2192'>2192</a> <a id='n2193' href='#n2193'>2193</a> <a id='n2194' href='#n2194'>2194</a> <a id='n2195' href='#n2195'>2195</a> <a id='n2196' href='#n2196'>2196</a> <a id='n2197' href='#n2197'>2197</a> <a id='n2198' href='#n2198'>2198</a> <a id='n2199' href='#n2199'>2199</a> <a id='n2200' href='#n2200'>2200</a> <a id='n2201' href='#n2201'>2201</a> <a id='n2202' href='#n2202'>2202</a> <a id='n2203' href='#n2203'>2203</a> <a id='n2204' href='#n2204'>2204</a> <a id='n2205' href='#n2205'>2205</a> <a id='n2206' href='#n2206'>2206</a> <a id='n2207' href='#n2207'>2207</a> <a id='n2208' href='#n2208'>2208</a> <a id='n2209' href='#n2209'>2209</a> <a id='n2210' href='#n2210'>2210</a> <a id='n2211' href='#n2211'>2211</a> <a id='n2212' href='#n2212'>2212</a> <a id='n2213' href='#n2213'>2213</a> <a id='n2214' href='#n2214'>2214</a> <a id='n2215' href='#n2215'>2215</a> <a id='n2216' href='#n2216'>2216</a> <a id='n2217' href='#n2217'>2217</a> <a id='n2218' href='#n2218'>2218</a> <a id='n2219' href='#n2219'>2219</a> <a id='n2220' href='#n2220'>2220</a> <a id='n2221' href='#n2221'>2221</a> <a id='n2222' href='#n2222'>2222</a> <a id='n2223' href='#n2223'>2223</a> <a id='n2224' href='#n2224'>2224</a> <a id='n2225' href='#n2225'>2225</a> <a id='n2226' href='#n2226'>2226</a> <a id='n2227' href='#n2227'>2227</a> <a id='n2228' href='#n2228'>2228</a> <a id='n2229' href='#n2229'>2229</a> <a id='n2230' href='#n2230'>2230</a> <a id='n2231' href='#n2231'>2231</a> <a id='n2232' href='#n2232'>2232</a> <a id='n2233' href='#n2233'>2233</a> <a id='n2234' href='#n2234'>2234</a> <a id='n2235' href='#n2235'>2235</a> <a id='n2236' href='#n2236'>2236</a> <a id='n2237' href='#n2237'>2237</a> <a id='n2238' href='#n2238'>2238</a> <a id='n2239' href='#n2239'>2239</a> <a id='n2240' href='#n2240'>2240</a> <a id='n2241' href='#n2241'>2241</a> <a id='n2242' href='#n2242'>2242</a> <a id='n2243' href='#n2243'>2243</a> <a id='n2244' href='#n2244'>2244</a> <a id='n2245' href='#n2245'>2245</a> <a id='n2246' href='#n2246'>2246</a> <a id='n2247' href='#n2247'>2247</a> <a id='n2248' href='#n2248'>2248</a> <a id='n2249' href='#n2249'>2249</a> <a id='n2250' href='#n2250'>2250</a> <a id='n2251' href='#n2251'>2251</a> <a id='n2252' href='#n2252'>2252</a> <a id='n2253' href='#n2253'>2253</a> <a id='n2254' href='#n2254'>2254</a> <a id='n2255' href='#n2255'>2255</a> <a id='n2256' href='#n2256'>2256</a> <a id='n2257' href='#n2257'>2257</a> <a id='n2258' href='#n2258'>2258</a> <a id='n2259' href='#n2259'>2259</a> <a id='n2260' href='#n2260'>2260</a> <a id='n2261' href='#n2261'>2261</a> <a id='n2262' href='#n2262'>2262</a> <a id='n2263' href='#n2263'>2263</a> <a id='n2264' href='#n2264'>2264</a> <a id='n2265' href='#n2265'>2265</a> <a id='n2266' href='#n2266'>2266</a> <a id='n2267' href='#n2267'>2267</a> <a id='n2268' href='#n2268'>2268</a> <a id='n2269' href='#n2269'>2269</a> <a id='n2270' href='#n2270'>2270</a> <a id='n2271' href='#n2271'>2271</a> <a id='n2272' href='#n2272'>2272</a> <a id='n2273' href='#n2273'>2273</a> <a id='n2274' href='#n2274'>2274</a> <a id='n2275' href='#n2275'>2275</a> <a id='n2276' href='#n2276'>2276</a> <a id='n2277' href='#n2277'>2277</a> <a id='n2278' href='#n2278'>2278</a> <a id='n2279' href='#n2279'>2279</a> <a id='n2280' href='#n2280'>2280</a> <a id='n2281' href='#n2281'>2281</a> <a id='n2282' href='#n2282'>2282</a> <a id='n2283' href='#n2283'>2283</a> <a id='n2284' href='#n2284'>2284</a> <a id='n2285' href='#n2285'>2285</a> <a id='n2286' href='#n2286'>2286</a> <a id='n2287' href='#n2287'>2287</a> <a id='n2288' href='#n2288'>2288</a> <a id='n2289' href='#n2289'>2289</a> <a id='n2290' href='#n2290'>2290</a> <a id='n2291' href='#n2291'>2291</a> <a id='n2292' href='#n2292'>2292</a> <a id='n2293' href='#n2293'>2293</a> <a id='n2294' href='#n2294'>2294</a> <a id='n2295' href='#n2295'>2295</a> <a id='n2296' href='#n2296'>2296</a> <a id='n2297' href='#n2297'>2297</a> <a id='n2298' href='#n2298'>2298</a> <a id='n2299' href='#n2299'>2299</a> <a id='n2300' href='#n2300'>2300</a> <a id='n2301' href='#n2301'>2301</a> <a id='n2302' href='#n2302'>2302</a> <a id='n2303' href='#n2303'>2303</a> <a id='n2304' href='#n2304'>2304</a> <a id='n2305' href='#n2305'>2305</a> <a id='n2306' href='#n2306'>2306</a> <a id='n2307' href='#n2307'>2307</a> <a id='n2308' href='#n2308'>2308</a> <a id='n2309' href='#n2309'>2309</a> <a id='n2310' href='#n2310'>2310</a> <a id='n2311' href='#n2311'>2311</a> <a id='n2312' href='#n2312'>2312</a> <a id='n2313' href='#n2313'>2313</a> <a id='n2314' href='#n2314'>2314</a> <a id='n2315' href='#n2315'>2315</a> <a id='n2316' href='#n2316'>2316</a> <a id='n2317' href='#n2317'>2317</a> <a id='n2318' href='#n2318'>2318</a> <a id='n2319' href='#n2319'>2319</a> <a id='n2320' href='#n2320'>2320</a> <a id='n2321' href='#n2321'>2321</a> <a id='n2322' href='#n2322'>2322</a> <a id='n2323' href='#n2323'>2323</a> <a id='n2324' href='#n2324'>2324</a> <a id='n2325' href='#n2325'>2325</a> <a id='n2326' href='#n2326'>2326</a> <a id='n2327' href='#n2327'>2327</a> <a id='n2328' href='#n2328'>2328</a> <a id='n2329' href='#n2329'>2329</a> <a id='n2330' href='#n2330'>2330</a> <a id='n2331' href='#n2331'>2331</a> <a id='n2332' href='#n2332'>2332</a> <a id='n2333' href='#n2333'>2333</a> <a id='n2334' href='#n2334'>2334</a> <a id='n2335' href='#n2335'>2335</a> <a id='n2336' href='#n2336'>2336</a> <a id='n2337' href='#n2337'>2337</a> <a id='n2338' href='#n2338'>2338</a> <a id='n2339' href='#n2339'>2339</a> <a id='n2340' href='#n2340'>2340</a> <a id='n2341' href='#n2341'>2341</a> <a id='n2342' href='#n2342'>2342</a> <a id='n2343' href='#n2343'>2343</a> <a id='n2344' href='#n2344'>2344</a> <a id='n2345' href='#n2345'>2345</a> <a id='n2346' href='#n2346'>2346</a> <a id='n2347' href='#n2347'>2347</a> <a id='n2348' href='#n2348'>2348</a> <a id='n2349' href='#n2349'>2349</a> <a id='n2350' href='#n2350'>2350</a> <a id='n2351' href='#n2351'>2351</a> <a id='n2352' href='#n2352'>2352</a> <a id='n2353' href='#n2353'>2353</a> <a id='n2354' href='#n2354'>2354</a> <a id='n2355' href='#n2355'>2355</a> <a id='n2356' href='#n2356'>2356</a> <a id='n2357' href='#n2357'>2357</a> <a id='n2358' href='#n2358'>2358</a> <a id='n2359' href='#n2359'>2359</a> <a id='n2360' href='#n2360'>2360</a> <a id='n2361' href='#n2361'>2361</a> <a id='n2362' href='#n2362'>2362</a> <a id='n2363' href='#n2363'>2363</a> <a id='n2364' href='#n2364'>2364</a> <a id='n2365' href='#n2365'>2365</a> <a id='n2366' href='#n2366'>2366</a> <a id='n2367' href='#n2367'>2367</a> <a id='n2368' href='#n2368'>2368</a> <a id='n2369' href='#n2369'>2369</a> <a id='n2370' href='#n2370'>2370</a> <a id='n2371' href='#n2371'>2371</a> <a id='n2372' href='#n2372'>2372</a> <a id='n2373' href='#n2373'>2373</a> <a id='n2374' href='#n2374'>2374</a> <a id='n2375' href='#n2375'>2375</a> <a id='n2376' href='#n2376'>2376</a> <a id='n2377' href='#n2377'>2377</a> <a id='n2378' href='#n2378'>2378</a> <a id='n2379' href='#n2379'>2379</a> <a id='n2380' href='#n2380'>2380</a> <a id='n2381' href='#n2381'>2381</a> <a id='n2382' href='#n2382'>2382</a> <a id='n2383' href='#n2383'>2383</a> <a id='n2384' href='#n2384'>2384</a> <a id='n2385' href='#n2385'>2385</a> <a id='n2386' href='#n2386'>2386</a> <a id='n2387' href='#n2387'>2387</a> <a id='n2388' href='#n2388'>2388</a> <a id='n2389' href='#n2389'>2389</a> <a id='n2390' href='#n2390'>2390</a> <a id='n2391' href='#n2391'>2391</a> <a id='n2392' href='#n2392'>2392</a> <a id='n2393' href='#n2393'>2393</a> <a id='n2394' href='#n2394'>2394</a> <a id='n2395' href='#n2395'>2395</a> <a id='n2396' href='#n2396'>2396</a> <a id='n2397' href='#n2397'>2397</a> <a id='n2398' href='#n2398'>2398</a> <a id='n2399' href='#n2399'>2399</a> <a id='n2400' href='#n2400'>2400</a> <a id='n2401' href='#n2401'>2401</a> <a id='n2402' href='#n2402'>2402</a> <a id='n2403' href='#n2403'>2403</a> <a id='n2404' href='#n2404'>2404</a> <a id='n2405' href='#n2405'>2405</a> <a id='n2406' href='#n2406'>2406</a> <a id='n2407' href='#n2407'>2407</a> <a id='n2408' href='#n2408'>2408</a> <a id='n2409' href='#n2409'>2409</a> <a id='n2410' href='#n2410'>2410</a> <a id='n2411' href='#n2411'>2411</a> <a id='n2412' href='#n2412'>2412</a> <a id='n2413' href='#n2413'>2413</a> <a id='n2414' href='#n2414'>2414</a> <a id='n2415' href='#n2415'>2415</a> <a id='n2416' href='#n2416'>2416</a> <a id='n2417' href='#n2417'>2417</a> <a id='n2418' href='#n2418'>2418</a> <a id='n2419' href='#n2419'>2419</a> <a id='n2420' href='#n2420'>2420</a> <a id='n2421' href='#n2421'>2421</a> <a id='n2422' href='#n2422'>2422</a> <a id='n2423' href='#n2423'>2423</a> <a id='n2424' href='#n2424'>2424</a> <a id='n2425' href='#n2425'>2425</a> <a id='n2426' href='#n2426'>2426</a> <a id='n2427' href='#n2427'>2427</a> <a id='n2428' href='#n2428'>2428</a> <a id='n2429' href='#n2429'>2429</a> <a id='n2430' href='#n2430'>2430</a> <a id='n2431' href='#n2431'>2431</a> <a id='n2432' href='#n2432'>2432</a> <a id='n2433' href='#n2433'>2433</a> <a id='n2434' href='#n2434'>2434</a> <a id='n2435' href='#n2435'>2435</a> <a id='n2436' href='#n2436'>2436</a> <a id='n2437' href='#n2437'>2437</a> <a id='n2438' href='#n2438'>2438</a> <a id='n2439' href='#n2439'>2439</a> <a id='n2440' href='#n2440'>2440</a> <a id='n2441' href='#n2441'>2441</a> <a id='n2442' href='#n2442'>2442</a> <a id='n2443' href='#n2443'>2443</a> <a id='n2444' href='#n2444'>2444</a> <a id='n2445' href='#n2445'>2445</a> <a id='n2446' href='#n2446'>2446</a> <a id='n2447' href='#n2447'>2447</a> <a id='n2448' href='#n2448'>2448</a> <a id='n2449' href='#n2449'>2449</a> <a id='n2450' href='#n2450'>2450</a> <a id='n2451' href='#n2451'>2451</a> <a id='n2452' href='#n2452'>2452</a> <a id='n2453' href='#n2453'>2453</a> <a id='n2454' href='#n2454'>2454</a> <a id='n2455' href='#n2455'>2455</a> <a id='n2456' href='#n2456'>2456</a> <a id='n2457' href='#n2457'>2457</a> <a id='n2458' href='#n2458'>2458</a> <a id='n2459' href='#n2459'>2459</a> <a id='n2460' href='#n2460'>2460</a> <a id='n2461' href='#n2461'>2461</a> <a id='n2462' href='#n2462'>2462</a> <a id='n2463' href='#n2463'>2463</a> <a id='n2464' href='#n2464'>2464</a> <a id='n2465' href='#n2465'>2465</a> <a id='n2466' href='#n2466'>2466</a> <a id='n2467' href='#n2467'>2467</a> <a id='n2468' href='#n2468'>2468</a> <a id='n2469' href='#n2469'>2469</a> <a id='n2470' href='#n2470'>2470</a> <a id='n2471' href='#n2471'>2471</a> <a id='n2472' href='#n2472'>2472</a> <a id='n2473' href='#n2473'>2473</a> <a id='n2474' href='#n2474'>2474</a> <a id='n2475' href='#n2475'>2475</a> <a id='n2476' href='#n2476'>2476</a> <a id='n2477' href='#n2477'>2477</a> <a id='n2478' href='#n2478'>2478</a> <a id='n2479' href='#n2479'>2479</a> <a id='n2480' href='#n2480'>2480</a> <a id='n2481' href='#n2481'>2481</a> <a id='n2482' href='#n2482'>2482</a> <a id='n2483' href='#n2483'>2483</a> <a id='n2484' href='#n2484'>2484</a> <a id='n2485' href='#n2485'>2485</a> <a id='n2486' href='#n2486'>2486</a> <a id='n2487' href='#n2487'>2487</a> <a id='n2488' href='#n2488'>2488</a> <a id='n2489' href='#n2489'>2489</a> <a id='n2490' href='#n2490'>2490</a> <a id='n2491' href='#n2491'>2491</a> <a id='n2492' href='#n2492'>2492</a> <a id='n2493' href='#n2493'>2493</a> <a id='n2494' href='#n2494'>2494</a> <a id='n2495' href='#n2495'>2495</a> <a id='n2496' href='#n2496'>2496</a> <a id='n2497' href='#n2497'>2497</a> <a id='n2498' href='#n2498'>2498</a> <a id='n2499' href='#n2499'>2499</a> <a id='n2500' href='#n2500'>2500</a> <a id='n2501' href='#n2501'>2501</a> <a id='n2502' href='#n2502'>2502</a> <a id='n2503' href='#n2503'>2503</a> <a id='n2504' href='#n2504'>2504</a> <a id='n2505' href='#n2505'>2505</a> <a id='n2506' href='#n2506'>2506</a> <a id='n2507' href='#n2507'>2507</a> <a id='n2508' href='#n2508'>2508</a> <a id='n2509' href='#n2509'>2509</a> <a id='n2510' href='#n2510'>2510</a> <a id='n2511' href='#n2511'>2511</a> <a id='n2512' href='#n2512'>2512</a> <a id='n2513' href='#n2513'>2513</a> <a id='n2514' href='#n2514'>2514</a> <a id='n2515' href='#n2515'>2515</a> <a id='n2516' href='#n2516'>2516</a> <a id='n2517' href='#n2517'>2517</a> <a id='n2518' href='#n2518'>2518</a> <a id='n2519' href='#n2519'>2519</a> <a id='n2520' href='#n2520'>2520</a> <a id='n2521' href='#n2521'>2521</a> <a id='n2522' href='#n2522'>2522</a> <a id='n2523' href='#n2523'>2523</a> <a id='n2524' href='#n2524'>2524</a> <a id='n2525' href='#n2525'>2525</a> <a id='n2526' href='#n2526'>2526</a> <a id='n2527' href='#n2527'>2527</a> <a id='n2528' href='#n2528'>2528</a> <a id='n2529' href='#n2529'>2529</a> <a id='n2530' href='#n2530'>2530</a> <a id='n2531' href='#n2531'>2531</a> <a id='n2532' href='#n2532'>2532</a> <a id='n2533' href='#n2533'>2533</a> <a id='n2534' href='#n2534'>2534</a> <a id='n2535' href='#n2535'>2535</a> <a id='n2536' href='#n2536'>2536</a> <a id='n2537' href='#n2537'>2537</a> <a id='n2538' href='#n2538'>2538</a> <a id='n2539' href='#n2539'>2539</a> <a id='n2540' href='#n2540'>2540</a> <a id='n2541' href='#n2541'>2541</a> <a id='n2542' href='#n2542'>2542</a> <a id='n2543' href='#n2543'>2543</a> <a id='n2544' href='#n2544'>2544</a> <a id='n2545' href='#n2545'>2545</a> <a id='n2546' href='#n2546'>2546</a> <a id='n2547' href='#n2547'>2547</a> <a id='n2548' href='#n2548'>2548</a> <a id='n2549' href='#n2549'>2549</a> <a id='n2550' href='#n2550'>2550</a> <a id='n2551' href='#n2551'>2551</a> <a id='n2552' href='#n2552'>2552</a> <a id='n2553' href='#n2553'>2553</a> <a id='n2554' href='#n2554'>2554</a> <a id='n2555' href='#n2555'>2555</a> <a id='n2556' href='#n2556'>2556</a> <a id='n2557' href='#n2557'>2557</a> <a id='n2558' href='#n2558'>2558</a> <a id='n2559' href='#n2559'>2559</a> <a id='n2560' href='#n2560'>2560</a> <a id='n2561' href='#n2561'>2561</a> <a id='n2562' href='#n2562'>2562</a> <a id='n2563' href='#n2563'>2563</a> <a id='n2564' href='#n2564'>2564</a> <a id='n2565' href='#n2565'>2565</a> <a id='n2566' href='#n2566'>2566</a> <a id='n2567' href='#n2567'>2567</a> <a id='n2568' href='#n2568'>2568</a> <a id='n2569' href='#n2569'>2569</a> <a id='n2570' href='#n2570'>2570</a> <a id='n2571' href='#n2571'>2571</a> <a id='n2572' href='#n2572'>2572</a> <a id='n2573' href='#n2573'>2573</a> <a id='n2574' href='#n2574'>2574</a> <a id='n2575' href='#n2575'>2575</a> <a id='n2576' href='#n2576'>2576</a> <a id='n2577' href='#n2577'>2577</a> <a id='n2578' href='#n2578'>2578</a> <a id='n2579' href='#n2579'>2579</a> <a id='n2580' href='#n2580'>2580</a> <a id='n2581' href='#n2581'>2581</a> <a id='n2582' href='#n2582'>2582</a> <a id='n2583' href='#n2583'>2583</a> <a id='n2584' href='#n2584'>2584</a> <a id='n2585' href='#n2585'>2585</a> <a id='n2586' href='#n2586'>2586</a> <a id='n2587' href='#n2587'>2587</a> <a id='n2588' href='#n2588'>2588</a> <a id='n2589' href='#n2589'>2589</a> <a id='n2590' href='#n2590'>2590</a> <a id='n2591' href='#n2591'>2591</a> <a id='n2592' href='#n2592'>2592</a> <a id='n2593' href='#n2593'>2593</a> <a id='n2594' href='#n2594'>2594</a> <a id='n2595' href='#n2595'>2595</a> <a id='n2596' href='#n2596'>2596</a> <a id='n2597' href='#n2597'>2597</a> <a id='n2598' href='#n2598'>2598</a> <a id='n2599' href='#n2599'>2599</a> <a id='n2600' href='#n2600'>2600</a> <a id='n2601' href='#n2601'>2601</a> <a id='n2602' href='#n2602'>2602</a> <a id='n2603' href='#n2603'>2603</a> <a id='n2604' href='#n2604'>2604</a> <a id='n2605' href='#n2605'>2605</a> <a id='n2606' href='#n2606'>2606</a> <a id='n2607' href='#n2607'>2607</a> <a id='n2608' href='#n2608'>2608</a> <a id='n2609' href='#n2609'>2609</a> <a id='n2610' href='#n2610'>2610</a> <a id='n2611' href='#n2611'>2611</a> <a id='n2612' href='#n2612'>2612</a> <a id='n2613' href='#n2613'>2613</a> <a id='n2614' href='#n2614'>2614</a> <a id='n2615' href='#n2615'>2615</a> <a id='n2616' href='#n2616'>2616</a> <a id='n2617' href='#n2617'>2617</a> <a id='n2618' href='#n2618'>2618</a> <a id='n2619' href='#n2619'>2619</a> <a id='n2620' href='#n2620'>2620</a> <a id='n2621' href='#n2621'>2621</a> <a id='n2622' href='#n2622'>2622</a> <a id='n2623' href='#n2623'>2623</a> <a id='n2624' href='#n2624'>2624</a> <a id='n2625' href='#n2625'>2625</a> <a id='n2626' href='#n2626'>2626</a> <a id='n2627' href='#n2627'>2627</a> <a id='n2628' href='#n2628'>2628</a> <a id='n2629' href='#n2629'>2629</a> <a id='n2630' href='#n2630'>2630</a> <a id='n2631' href='#n2631'>2631</a> <a id='n2632' href='#n2632'>2632</a> <a id='n2633' href='#n2633'>2633</a> <a id='n2634' href='#n2634'>2634</a> <a id='n2635' href='#n2635'>2635</a> <a id='n2636' href='#n2636'>2636</a> <a id='n2637' href='#n2637'>2637</a> <a id='n2638' href='#n2638'>2638</a> <a id='n2639' href='#n2639'>2639</a> <a id='n2640' href='#n2640'>2640</a> <a id='n2641' href='#n2641'>2641</a> <a id='n2642' href='#n2642'>2642</a> <a id='n2643' href='#n2643'>2643</a> <a id='n2644' href='#n2644'>2644</a> <a id='n2645' href='#n2645'>2645</a> <a id='n2646' href='#n2646'>2646</a> <a id='n2647' href='#n2647'>2647</a> <a id='n2648' href='#n2648'>2648</a> <a id='n2649' href='#n2649'>2649</a> <a id='n2650' href='#n2650'>2650</a> <a id='n2651' href='#n2651'>2651</a> <a id='n2652' href='#n2652'>2652</a> <a id='n2653' href='#n2653'>2653</a> <a id='n2654' href='#n2654'>2654</a> <a id='n2655' href='#n2655'>2655</a> <a id='n2656' href='#n2656'>2656</a> <a id='n2657' href='#n2657'>2657</a> <a id='n2658' href='#n2658'>2658</a> <a id='n2659' href='#n2659'>2659</a> <a id='n2660' href='#n2660'>2660</a> <a id='n2661' href='#n2661'>2661</a> <a id='n2662' href='#n2662'>2662</a> <a id='n2663' href='#n2663'>2663</a> <a id='n2664' href='#n2664'>2664</a> <a id='n2665' href='#n2665'>2665</a> <a id='n2666' href='#n2666'>2666</a> <a id='n2667' href='#n2667'>2667</a> <a id='n2668' href='#n2668'>2668</a> <a id='n2669' href='#n2669'>2669</a> <a id='n2670' href='#n2670'>2670</a> <a id='n2671' href='#n2671'>2671</a> <a id='n2672' href='#n2672'>2672</a> <a id='n2673' href='#n2673'>2673</a> <a id='n2674' href='#n2674'>2674</a> <a id='n2675' href='#n2675'>2675</a> <a id='n2676' href='#n2676'>2676</a> <a id='n2677' href='#n2677'>2677</a> <a id='n2678' href='#n2678'>2678</a> <a id='n2679' href='#n2679'>2679</a> <a id='n2680' href='#n2680'>2680</a> <a id='n2681' href='#n2681'>2681</a> <a id='n2682' href='#n2682'>2682</a> <a id='n2683' href='#n2683'>2683</a> <a id='n2684' href='#n2684'>2684</a> <a id='n2685' href='#n2685'>2685</a> <a id='n2686' href='#n2686'>2686</a> <a id='n2687' href='#n2687'>2687</a> <a id='n2688' href='#n2688'>2688</a> <a id='n2689' href='#n2689'>2689</a> <a id='n2690' href='#n2690'>2690</a> <a id='n2691' href='#n2691'>2691</a> <a id='n2692' href='#n2692'>2692</a> <a id='n2693' href='#n2693'>2693</a> <a id='n2694' href='#n2694'>2694</a> <a id='n2695' href='#n2695'>2695</a> <a id='n2696' href='#n2696'>2696</a> <a id='n2697' href='#n2697'>2697</a> <a id='n2698' href='#n2698'>2698</a> <a id='n2699' href='#n2699'>2699</a> <a id='n2700' href='#n2700'>2700</a> <a id='n2701' href='#n2701'>2701</a> <a id='n2702' href='#n2702'>2702</a> <a id='n2703' href='#n2703'>2703</a> <a id='n2704' href='#n2704'>2704</a> <a id='n2705' href='#n2705'>2705</a> <a id='n2706' href='#n2706'>2706</a> <a id='n2707' href='#n2707'>2707</a> <a id='n2708' href='#n2708'>2708</a> <a id='n2709' href='#n2709'>2709</a> <a id='n2710' href='#n2710'>2710</a> <a id='n2711' href='#n2711'>2711</a> <a id='n2712' href='#n2712'>2712</a> <a id='n2713' href='#n2713'>2713</a> <a id='n2714' href='#n2714'>2714</a> <a id='n2715' href='#n2715'>2715</a> <a id='n2716' href='#n2716'>2716</a> <a id='n2717' href='#n2717'>2717</a> <a id='n2718' href='#n2718'>2718</a> <a id='n2719' href='#n2719'>2719</a> <a id='n2720' href='#n2720'>2720</a> <a id='n2721' href='#n2721'>2721</a> <a id='n2722' href='#n2722'>2722</a> <a id='n2723' href='#n2723'>2723</a> <a id='n2724' href='#n2724'>2724</a> <a id='n2725' href='#n2725'>2725</a> <a id='n2726' href='#n2726'>2726</a> <a id='n2727' href='#n2727'>2727</a> <a id='n2728' href='#n2728'>2728</a> <a id='n2729' href='#n2729'>2729</a> <a id='n2730' href='#n2730'>2730</a> <a id='n2731' href='#n2731'>2731</a> <a id='n2732' href='#n2732'>2732</a> <a id='n2733' href='#n2733'>2733</a> <a id='n2734' href='#n2734'>2734</a> <a id='n2735' href='#n2735'>2735</a> <a id='n2736' href='#n2736'>2736</a> <a id='n2737' href='#n2737'>2737</a> <a id='n2738' href='#n2738'>2738</a> <a id='n2739' href='#n2739'>2739</a> <a id='n2740' href='#n2740'>2740</a> <a id='n2741' href='#n2741'>2741</a> <a id='n2742' href='#n2742'>2742</a> <a id='n2743' href='#n2743'>2743</a> <a id='n2744' href='#n2744'>2744</a> <a id='n2745' href='#n2745'>2745</a> <a id='n2746' href='#n2746'>2746</a> <a id='n2747' href='#n2747'>2747</a> <a id='n2748' href='#n2748'>2748</a> <a id='n2749' href='#n2749'>2749</a> <a id='n2750' href='#n2750'>2750</a> <a id='n2751' href='#n2751'>2751</a> <a id='n2752' href='#n2752'>2752</a> <a id='n2753' href='#n2753'>2753</a> <a id='n2754' href='#n2754'>2754</a> <a id='n2755' href='#n2755'>2755</a> <a id='n2756' href='#n2756'>2756</a> <a id='n2757' href='#n2757'>2757</a> <a id='n2758' href='#n2758'>2758</a> <a id='n2759' href='#n2759'>2759</a> <a id='n2760' href='#n2760'>2760</a> <a id='n2761' href='#n2761'>2761</a> <a id='n2762' href='#n2762'>2762</a> <a id='n2763' href='#n2763'>2763</a> <a id='n2764' href='#n2764'>2764</a> <a id='n2765' href='#n2765'>2765</a> <a id='n2766' href='#n2766'>2766</a> <a id='n2767' href='#n2767'>2767</a> <a id='n2768' href='#n2768'>2768</a> <a id='n2769' href='#n2769'>2769</a> <a id='n2770' href='#n2770'>2770</a> <a id='n2771' href='#n2771'>2771</a> <a id='n2772' href='#n2772'>2772</a> <a id='n2773' href='#n2773'>2773</a> <a id='n2774' href='#n2774'>2774</a> <a id='n2775' href='#n2775'>2775</a> <a id='n2776' href='#n2776'>2776</a> <a id='n2777' href='#n2777'>2777</a> <a id='n2778' href='#n2778'>2778</a> <a id='n2779' href='#n2779'>2779</a> <a id='n2780' href='#n2780'>2780</a> <a id='n2781' href='#n2781'>2781</a> <a id='n2782' href='#n2782'>2782</a> <a id='n2783' href='#n2783'>2783</a> <a id='n2784' href='#n2784'>2784</a> <a id='n2785' href='#n2785'>2785</a> <a id='n2786' href='#n2786'>2786</a> <a id='n2787' href='#n2787'>2787</a> <a id='n2788' href='#n2788'>2788</a> <a id='n2789' href='#n2789'>2789</a> <a id='n2790' href='#n2790'>2790</a> <a id='n2791' href='#n2791'>2791</a> <a id='n2792' href='#n2792'>2792</a> <a id='n2793' href='#n2793'>2793</a> <a id='n2794' href='#n2794'>2794</a> <a id='n2795' href='#n2795'>2795</a> <a id='n2796' href='#n2796'>2796</a> <a id='n2797' href='#n2797'>2797</a> <a id='n2798' href='#n2798'>2798</a> <a id='n2799' href='#n2799'>2799</a> <a id='n2800' href='#n2800'>2800</a> <a id='n2801' href='#n2801'>2801</a> <a id='n2802' href='#n2802'>2802</a> <a id='n2803' href='#n2803'>2803</a> <a id='n2804' href='#n2804'>2804</a> <a id='n2805' href='#n2805'>2805</a> <a id='n2806' href='#n2806'>2806</a> <a id='n2807' href='#n2807'>2807</a> <a id='n2808' href='#n2808'>2808</a> <a id='n2809' href='#n2809'>2809</a> <a id='n2810' href='#n2810'>2810</a> <a id='n2811' href='#n2811'>2811</a> <a id='n2812' href='#n2812'>2812</a> <a id='n2813' href='#n2813'>2813</a> <a id='n2814' href='#n2814'>2814</a> <a id='n2815' href='#n2815'>2815</a> <a id='n2816' href='#n2816'>2816</a> <a id='n2817' href='#n2817'>2817</a> <a id='n2818' href='#n2818'>2818</a> <a id='n2819' href='#n2819'>2819</a> <a id='n2820' href='#n2820'>2820</a> <a id='n2821' href='#n2821'>2821</a> <a id='n2822' href='#n2822'>2822</a> <a id='n2823' href='#n2823'>2823</a> <a id='n2824' href='#n2824'>2824</a> <a id='n2825' href='#n2825'>2825</a> <a id='n2826' href='#n2826'>2826</a> <a id='n2827' href='#n2827'>2827</a> <a id='n2828' href='#n2828'>2828</a> <a id='n2829' href='#n2829'>2829</a> <a id='n2830' href='#n2830'>2830</a> <a id='n2831' href='#n2831'>2831</a> <a id='n2832' href='#n2832'>2832</a> <a id='n2833' href='#n2833'>2833</a> <a id='n2834' href='#n2834'>2834</a> <a id='n2835' href='#n2835'>2835</a> <a id='n2836' href='#n2836'>2836</a> <a id='n2837' href='#n2837'>2837</a> <a id='n2838' href='#n2838'>2838</a> <a id='n2839' href='#n2839'>2839</a> <a id='n2840' href='#n2840'>2840</a> <a id='n2841' href='#n2841'>2841</a> <a id='n2842' href='#n2842'>2842</a> <a id='n2843' href='#n2843'>2843</a> <a id='n2844' href='#n2844'>2844</a> <a id='n2845' href='#n2845'>2845</a> <a id='n2846' href='#n2846'>2846</a> <a id='n2847' href='#n2847'>2847</a> <a id='n2848' href='#n2848'>2848</a> <a id='n2849' href='#n2849'>2849</a> <a id='n2850' href='#n2850'>2850</a> <a id='n2851' href='#n2851'>2851</a> <a id='n2852' href='#n2852'>2852</a> <a id='n2853' href='#n2853'>2853</a> <a id='n2854' href='#n2854'>2854</a> <a id='n2855' href='#n2855'>2855</a> <a id='n2856' href='#n2856'>2856</a> <a id='n2857' href='#n2857'>2857</a> <a id='n2858' href='#n2858'>2858</a> <a id='n2859' href='#n2859'>2859</a> <a id='n2860' href='#n2860'>2860</a> <a id='n2861' href='#n2861'>2861</a> <a id='n2862' href='#n2862'>2862</a> <a id='n2863' href='#n2863'>2863</a> <a id='n2864' href='#n2864'>2864</a> <a id='n2865' href='#n2865'>2865</a> <a id='n2866' href='#n2866'>2866</a> <a id='n2867' href='#n2867'>2867</a> <a id='n2868' href='#n2868'>2868</a> <a id='n2869' href='#n2869'>2869</a> <a id='n2870' href='#n2870'>2870</a> <a id='n2871' href='#n2871'>2871</a> <a id='n2872' href='#n2872'>2872</a> <a id='n2873' href='#n2873'>2873</a> <a id='n2874' href='#n2874'>2874</a> <a id='n2875' href='#n2875'>2875</a> <a id='n2876' href='#n2876'>2876</a> <a id='n2877' href='#n2877'>2877</a> <a id='n2878' href='#n2878'>2878</a> <a id='n2879' href='#n2879'>2879</a> <a id='n2880' href='#n2880'>2880</a> <a id='n2881' href='#n2881'>2881</a> <a id='n2882' href='#n2882'>2882</a> <a id='n2883' href='#n2883'>2883</a> <a id='n2884' href='#n2884'>2884</a> <a id='n2885' href='#n2885'>2885</a> <a id='n2886' href='#n2886'>2886</a> <a id='n2887' href='#n2887'>2887</a> <a id='n2888' href='#n2888'>2888</a> <a id='n2889' href='#n2889'>2889</a> <a id='n2890' href='#n2890'>2890</a> <a id='n2891' href='#n2891'>2891</a> <a id='n2892' href='#n2892'>2892</a> <a id='n2893' href='#n2893'>2893</a> <a id='n2894' href='#n2894'>2894</a> <a id='n2895' href='#n2895'>2895</a> <a id='n2896' href='#n2896'>2896</a> <a id='n2897' href='#n2897'>2897</a> <a id='n2898' href='#n2898'>2898</a> <a id='n2899' href='#n2899'>2899</a> <a id='n2900' href='#n2900'>2900</a> <a id='n2901' href='#n2901'>2901</a> <a id='n2902' href='#n2902'>2902</a> <a id='n2903' href='#n2903'>2903</a> <a id='n2904' href='#n2904'>2904</a> <a id='n2905' href='#n2905'>2905</a> <a id='n2906' href='#n2906'>2906</a> <a id='n2907' href='#n2907'>2907</a> <a id='n2908' href='#n2908'>2908</a> <a id='n2909' href='#n2909'>2909</a> <a id='n2910' href='#n2910'>2910</a> <a id='n2911' href='#n2911'>2911</a> <a id='n2912' href='#n2912'>2912</a> <a id='n2913' href='#n2913'>2913</a> <a id='n2914' href='#n2914'>2914</a> <a id='n2915' href='#n2915'>2915</a> <a id='n2916' href='#n2916'>2916</a> <a id='n2917' href='#n2917'>2917</a> <a id='n2918' href='#n2918'>2918</a> <a id='n2919' href='#n2919'>2919</a> <a id='n2920' href='#n2920'>2920</a> <a id='n2921' href='#n2921'>2921</a> <a id='n2922' href='#n2922'>2922</a> <a id='n2923' href='#n2923'>2923</a> <a id='n2924' href='#n2924'>2924</a> <a id='n2925' href='#n2925'>2925</a> <a id='n2926' href='#n2926'>2926</a> <a id='n2927' href='#n2927'>2927</a> <a id='n2928' href='#n2928'>2928</a> <a id='n2929' href='#n2929'>2929</a> <a id='n2930' href='#n2930'>2930</a> <a id='n2931' href='#n2931'>2931</a> <a id='n2932' href='#n2932'>2932</a> <a id='n2933' href='#n2933'>2933</a> <a id='n2934' href='#n2934'>2934</a> <a id='n2935' href='#n2935'>2935</a> <a id='n2936' href='#n2936'>2936</a> <a id='n2937' href='#n2937'>2937</a> <a id='n2938' href='#n2938'>2938</a> <a id='n2939' href='#n2939'>2939</a> <a id='n2940' href='#n2940'>2940</a> <a id='n2941' href='#n2941'>2941</a> <a id='n2942' href='#n2942'>2942</a> <a id='n2943' href='#n2943'>2943</a> <a id='n2944' href='#n2944'>2944</a> <a id='n2945' href='#n2945'>2945</a> <a id='n2946' href='#n2946'>2946</a> <a id='n2947' href='#n2947'>2947</a> <a id='n2948' href='#n2948'>2948</a> <a id='n2949' href='#n2949'>2949</a> <a id='n2950' href='#n2950'>2950</a> <a id='n2951' href='#n2951'>2951</a> <a id='n2952' href='#n2952'>2952</a> <a id='n2953' href='#n2953'>2953</a> <a id='n2954' href='#n2954'>2954</a> <a id='n2955' href='#n2955'>2955</a> <a id='n2956' href='#n2956'>2956</a> <a id='n2957' href='#n2957'>2957</a> <a id='n2958' href='#n2958'>2958</a> <a id='n2959' href='#n2959'>2959</a> <a id='n2960' href='#n2960'>2960</a> <a id='n2961' href='#n2961'>2961</a> <a id='n2962' href='#n2962'>2962</a> <a id='n2963' href='#n2963'>2963</a> <a id='n2964' href='#n2964'>2964</a> <a id='n2965' href='#n2965'>2965</a> <a id='n2966' href='#n2966'>2966</a> <a id='n2967' href='#n2967'>2967</a> <a id='n2968' href='#n2968'>2968</a> <a id='n2969' href='#n2969'>2969</a> <a id='n2970' href='#n2970'>2970</a> <a id='n2971' href='#n2971'>2971</a> <a id='n2972' href='#n2972'>2972</a> <a id='n2973' href='#n2973'>2973</a> <a id='n2974' href='#n2974'>2974</a> <a id='n2975' href='#n2975'>2975</a> <a id='n2976' href='#n2976'>2976</a> <a id='n2977' href='#n2977'>2977</a> <a id='n2978' href='#n2978'>2978</a> <a id='n2979' href='#n2979'>2979</a> <a id='n2980' href='#n2980'>2980</a> <a id='n2981' href='#n2981'>2981</a> <a id='n2982' href='#n2982'>2982</a> <a id='n2983' href='#n2983'>2983</a> <a id='n2984' href='#n2984'>2984</a> <a id='n2985' href='#n2985'>2985</a> <a id='n2986' href='#n2986'>2986</a> <a id='n2987' href='#n2987'>2987</a> <a id='n2988' href='#n2988'>2988</a> <a id='n2989' href='#n2989'>2989</a> <a id='n2990' href='#n2990'>2990</a> <a id='n2991' href='#n2991'>2991</a> <a id='n2992' href='#n2992'>2992</a> <a id='n2993' href='#n2993'>2993</a> <a id='n2994' href='#n2994'>2994</a> <a id='n2995' href='#n2995'>2995</a> <a id='n2996' href='#n2996'>2996</a> <a id='n2997' href='#n2997'>2997</a> <a id='n2998' href='#n2998'>2998</a> <a id='n2999' href='#n2999'>2999</a> <a id='n3000' href='#n3000'>3000</a> <a id='n3001' href='#n3001'>3001</a> <a id='n3002' href='#n3002'>3002</a> <a id='n3003' href='#n3003'>3003</a> <a id='n3004' href='#n3004'>3004</a> <a id='n3005' href='#n3005'>3005</a> <a id='n3006' href='#n3006'>3006</a> <a id='n3007' href='#n3007'>3007</a> <a id='n3008' href='#n3008'>3008</a> <a id='n3009' href='#n3009'>3009</a> <a id='n3010' href='#n3010'>3010</a> <a id='n3011' href='#n3011'>3011</a> <a id='n3012' href='#n3012'>3012</a> <a id='n3013' href='#n3013'>3013</a> <a id='n3014' href='#n3014'>3014</a> <a id='n3015' href='#n3015'>3015</a> <a id='n3016' href='#n3016'>3016</a> <a id='n3017' href='#n3017'>3017</a> <a id='n3018' href='#n3018'>3018</a> <a id='n3019' href='#n3019'>3019</a> <a id='n3020' href='#n3020'>3020</a> <a id='n3021' href='#n3021'>3021</a> <a id='n3022' href='#n3022'>3022</a> <a id='n3023' href='#n3023'>3023</a> <a id='n3024' href='#n3024'>3024</a> <a id='n3025' href='#n3025'>3025</a> <a id='n3026' href='#n3026'>3026</a> <a id='n3027' href='#n3027'>3027</a> <a id='n3028' href='#n3028'>3028</a> <a id='n3029' href='#n3029'>3029</a> <a id='n3030' href='#n3030'>3030</a> <a id='n3031' href='#n3031'>3031</a> <a id='n3032' href='#n3032'>3032</a> <a id='n3033' href='#n3033'>3033</a> <a id='n3034' href='#n3034'>3034</a> <a id='n3035' href='#n3035'>3035</a> <a id='n3036' href='#n3036'>3036</a> <a id='n3037' href='#n3037'>3037</a> <a id='n3038' href='#n3038'>3038</a> <a id='n3039' href='#n3039'>3039</a> <a id='n3040' href='#n3040'>3040</a> <a id='n3041' href='#n3041'>3041</a> <a id='n3042' href='#n3042'>3042</a> <a id='n3043' href='#n3043'>3043</a> <a id='n3044' href='#n3044'>3044</a> <a id='n3045' href='#n3045'>3045</a> <a id='n3046' href='#n3046'>3046</a> <a id='n3047' href='#n3047'>3047</a> <a id='n3048' href='#n3048'>3048</a> <a id='n3049' href='#n3049'>3049</a> <a id='n3050' href='#n3050'>3050</a> <a id='n3051' href='#n3051'>3051</a> <a id='n3052' href='#n3052'>3052</a> <a id='n3053' href='#n3053'>3053</a> <a id='n3054' href='#n3054'>3054</a> <a id='n3055' href='#n3055'>3055</a> <a id='n3056' href='#n3056'>3056</a> <a id='n3057' href='#n3057'>3057</a> <a id='n3058' href='#n3058'>3058</a> <a id='n3059' href='#n3059'>3059</a> <a id='n3060' href='#n3060'>3060</a> <a id='n3061' href='#n3061'>3061</a> <a id='n3062' href='#n3062'>3062</a> <a id='n3063' href='#n3063'>3063</a> <a id='n3064' href='#n3064'>3064</a> <a id='n3065' href='#n3065'>3065</a> <a id='n3066' href='#n3066'>3066</a> <a id='n3067' href='#n3067'>3067</a> <a id='n3068' href='#n3068'>3068</a> <a id='n3069' href='#n3069'>3069</a> <a id='n3070' href='#n3070'>3070</a> <a id='n3071' href='#n3071'>3071</a> <a id='n3072' href='#n3072'>3072</a> <a id='n3073' href='#n3073'>3073</a> <a id='n3074' href='#n3074'>3074</a> <a id='n3075' href='#n3075'>3075</a> <a id='n3076' href='#n3076'>3076</a> <a id='n3077' href='#n3077'>3077</a> <a id='n3078' href='#n3078'>3078</a> <a id='n3079' href='#n3079'>3079</a> <a id='n3080' href='#n3080'>3080</a> <a id='n3081' href='#n3081'>3081</a> <a id='n3082' href='#n3082'>3082</a> <a id='n3083' href='#n3083'>3083</a> <a id='n3084' href='#n3084'>3084</a> <a id='n3085' href='#n3085'>3085</a> <a id='n3086' href='#n3086'>3086</a> <a id='n3087' href='#n3087'>3087</a> <a id='n3088' href='#n3088'>3088</a> <a id='n3089' href='#n3089'>3089</a> <a id='n3090' href='#n3090'>3090</a> <a id='n3091' href='#n3091'>3091</a> <a id='n3092' href='#n3092'>3092</a> <a id='n3093' href='#n3093'>3093</a> <a id='n3094' href='#n3094'>3094</a> <a id='n3095' href='#n3095'>3095</a> <a id='n3096' href='#n3096'>3096</a> <a id='n3097' href='#n3097'>3097</a> <a id='n3098' href='#n3098'>3098</a> <a id='n3099' href='#n3099'>3099</a> <a id='n3100' href='#n3100'>3100</a> <a id='n3101' href='#n3101'>3101</a> <a id='n3102' href='#n3102'>3102</a> <a id='n3103' href='#n3103'>3103</a> <a id='n3104' href='#n3104'>3104</a> <a id='n3105' href='#n3105'>3105</a> <a id='n3106' href='#n3106'>3106</a> <a id='n3107' href='#n3107'>3107</a> <a id='n3108' href='#n3108'>3108</a> <a id='n3109' href='#n3109'>3109</a> <a id='n3110' href='#n3110'>3110</a> <a id='n3111' href='#n3111'>3111</a> <a id='n3112' href='#n3112'>3112</a> <a id='n3113' href='#n3113'>3113</a> <a id='n3114' href='#n3114'>3114</a> <a id='n3115' href='#n3115'>3115</a> <a id='n3116' href='#n3116'>3116</a> <a id='n3117' href='#n3117'>3117</a> <a id='n3118' href='#n3118'>3118</a> <a id='n3119' href='#n3119'>3119</a> <a id='n3120' href='#n3120'>3120</a> <a id='n3121' href='#n3121'>3121</a> <a id='n3122' href='#n3122'>3122</a> <a id='n3123' href='#n3123'>3123</a> <a id='n3124' href='#n3124'>3124</a> <a id='n3125' href='#n3125'>3125</a> <a id='n3126' href='#n3126'>3126</a> <a id='n3127' href='#n3127'>3127</a> <a id='n3128' href='#n3128'>3128</a> <a id='n3129' href='#n3129'>3129</a> <a id='n3130' href='#n3130'>3130</a> <a id='n3131' href='#n3131'>3131</a> <a id='n3132' href='#n3132'>3132</a> <a id='n3133' href='#n3133'>3133</a> <a id='n3134' href='#n3134'>3134</a> <a id='n3135' href='#n3135'>3135</a> <a id='n3136' href='#n3136'>3136</a> <a id='n3137' href='#n3137'>3137</a> <a id='n3138' href='#n3138'>3138</a> <a id='n3139' href='#n3139'>3139</a> <a id='n3140' href='#n3140'>3140</a> <a id='n3141' href='#n3141'>3141</a> <a id='n3142' href='#n3142'>3142</a> <a id='n3143' href='#n3143'>3143</a> <a id='n3144' href='#n3144'>3144</a> <a id='n3145' href='#n3145'>3145</a> <a id='n3146' href='#n3146'>3146</a> <a id='n3147' href='#n3147'>3147</a> <a id='n3148' href='#n3148'>3148</a> <a id='n3149' href='#n3149'>3149</a> <a id='n3150' href='#n3150'>3150</a> <a id='n3151' href='#n3151'>3151</a> <a id='n3152' href='#n3152'>3152</a> <a id='n3153' href='#n3153'>3153</a> <a id='n3154' href='#n3154'>3154</a> <a id='n3155' href='#n3155'>3155</a> <a id='n3156' href='#n3156'>3156</a> <a id='n3157' href='#n3157'>3157</a> <a id='n3158' href='#n3158'>3158</a> <a id='n3159' href='#n3159'>3159</a> <a id='n3160' href='#n3160'>3160</a> <a id='n3161' href='#n3161'>3161</a> <a id='n3162' href='#n3162'>3162</a> <a id='n3163' href='#n3163'>3163</a> <a id='n3164' href='#n3164'>3164</a> <a id='n3165' href='#n3165'>3165</a> <a id='n3166' href='#n3166'>3166</a> <a id='n3167' href='#n3167'>3167</a> <a id='n3168' href='#n3168'>3168</a> <a id='n3169' href='#n3169'>3169</a> <a id='n3170' href='#n3170'>3170</a> <a id='n3171' href='#n3171'>3171</a> <a id='n3172' href='#n3172'>3172</a> <a id='n3173' href='#n3173'>3173</a> <a id='n3174' href='#n3174'>3174</a> <a id='n3175' href='#n3175'>3175</a> <a id='n3176' href='#n3176'>3176</a> <a id='n3177' href='#n3177'>3177</a> <a id='n3178' href='#n3178'>3178</a> <a id='n3179' href='#n3179'>3179</a> <a id='n3180' href='#n3180'>3180</a> <a id='n3181' href='#n3181'>3181</a> <a id='n3182' href='#n3182'>3182</a> <a id='n3183' href='#n3183'>3183</a> <a id='n3184' href='#n3184'>3184</a> <a id='n3185' href='#n3185'>3185</a> <a id='n3186' href='#n3186'>3186</a> <a id='n3187' href='#n3187'>3187</a> <a id='n3188' href='#n3188'>3188</a> <a id='n3189' href='#n3189'>3189</a> <a id='n3190' href='#n3190'>3190</a> <a id='n3191' href='#n3191'>3191</a> <a id='n3192' href='#n3192'>3192</a> <a id='n3193' href='#n3193'>3193</a> <a id='n3194' href='#n3194'>3194</a> <a id='n3195' href='#n3195'>3195</a> <a id='n3196' href='#n3196'>3196</a> <a id='n3197' href='#n3197'>3197</a> <a id='n3198' href='#n3198'>3198</a> <a id='n3199' href='#n3199'>3199</a> <a id='n3200' href='#n3200'>3200</a> <a id='n3201' href='#n3201'>3201</a> <a id='n3202' href='#n3202'>3202</a> <a id='n3203' href='#n3203'>3203</a> <a id='n3204' href='#n3204'>3204</a> <a id='n3205' href='#n3205'>3205</a> <a id='n3206' href='#n3206'>3206</a> <a id='n3207' href='#n3207'>3207</a> <a id='n3208' href='#n3208'>3208</a> <a id='n3209' href='#n3209'>3209</a> <a id='n3210' href='#n3210'>3210</a> <a id='n3211' href='#n3211'>3211</a> <a id='n3212' href='#n3212'>3212</a> <a id='n3213' href='#n3213'>3213</a> <a id='n3214' href='#n3214'>3214</a> <a id='n3215' href='#n3215'>3215</a> <a id='n3216' href='#n3216'>3216</a> <a id='n3217' href='#n3217'>3217</a> <a id='n3218' href='#n3218'>3218</a> <a id='n3219' href='#n3219'>3219</a> <a id='n3220' href='#n3220'>3220</a> <a id='n3221' href='#n3221'>3221</a> <a id='n3222' href='#n3222'>3222</a> <a id='n3223' href='#n3223'>3223</a> <a id='n3224' href='#n3224'>3224</a> <a id='n3225' href='#n3225'>3225</a> <a id='n3226' href='#n3226'>3226</a> <a id='n3227' href='#n3227'>3227</a> <a id='n3228' href='#n3228'>3228</a> <a id='n3229' href='#n3229'>3229</a> <a id='n3230' href='#n3230'>3230</a> <a id='n3231' href='#n3231'>3231</a> <a id='n3232' href='#n3232'>3232</a> <a id='n3233' href='#n3233'>3233</a> <a id='n3234' href='#n3234'>3234</a> <a id='n3235' href='#n3235'>3235</a> <a id='n3236' href='#n3236'>3236</a> <a id='n3237' href='#n3237'>3237</a> <a id='n3238' href='#n3238'>3238</a> <a id='n3239' href='#n3239'>3239</a> <a id='n3240' href='#n3240'>3240</a> <a id='n3241' href='#n3241'>3241</a> <a id='n3242' href='#n3242'>3242</a> <a id='n3243' href='#n3243'>3243</a> <a id='n3244' href='#n3244'>3244</a> <a id='n3245' href='#n3245'>3245</a> <a id='n3246' href='#n3246'>3246</a> <a id='n3247' href='#n3247'>3247</a> <a id='n3248' href='#n3248'>3248</a> <a id='n3249' href='#n3249'>3249</a> <a id='n3250' href='#n3250'>3250</a> <a id='n3251' href='#n3251'>3251</a> <a id='n3252' href='#n3252'>3252</a> <a id='n3253' href='#n3253'>3253</a> <a id='n3254' href='#n3254'>3254</a> <a id='n3255' href='#n3255'>3255</a> <a id='n3256' href='#n3256'>3256</a> <a id='n3257' href='#n3257'>3257</a> <a id='n3258' href='#n3258'>3258</a> <a id='n3259' href='#n3259'>3259</a> <a id='n3260' href='#n3260'>3260</a> <a id='n3261' href='#n3261'>3261</a> <a id='n3262' href='#n3262'>3262</a> <a id='n3263' href='#n3263'>3263</a> <a id='n3264' href='#n3264'>3264</a> <a id='n3265' href='#n3265'>3265</a> <a id='n3266' href='#n3266'>3266</a> <a id='n3267' href='#n3267'>3267</a> <a id='n3268' href='#n3268'>3268</a> <a id='n3269' href='#n3269'>3269</a> <a id='n3270' href='#n3270'>3270</a> <a id='n3271' href='#n3271'>3271</a> <a id='n3272' href='#n3272'>3272</a> <a id='n3273' href='#n3273'>3273</a> <a id='n3274' href='#n3274'>3274</a> <a id='n3275' href='#n3275'>3275</a> <a id='n3276' href='#n3276'>3276</a> <a id='n3277' href='#n3277'>3277</a> <a id='n3278' href='#n3278'>3278</a> <a id='n3279' href='#n3279'>3279</a> <a id='n3280' href='#n3280'>3280</a> <a id='n3281' href='#n3281'>3281</a> <a id='n3282' href='#n3282'>3282</a> <a id='n3283' href='#n3283'>3283</a> <a id='n3284' href='#n3284'>3284</a> <a id='n3285' href='#n3285'>3285</a> <a id='n3286' href='#n3286'>3286</a> <a id='n3287' href='#n3287'>3287</a> <a id='n3288' href='#n3288'>3288</a> <a id='n3289' href='#n3289'>3289</a> <a id='n3290' href='#n3290'>3290</a> <a id='n3291' href='#n3291'>3291</a> <a id='n3292' href='#n3292'>3292</a> <a id='n3293' href='#n3293'>3293</a> <a id='n3294' href='#n3294'>3294</a> <a id='n3295' href='#n3295'>3295</a> <a id='n3296' href='#n3296'>3296</a> <a id='n3297' href='#n3297'>3297</a> <a id='n3298' href='#n3298'>3298</a> <a id='n3299' href='#n3299'>3299</a> <a id='n3300' href='#n3300'>3300</a> <a id='n3301' href='#n3301'>3301</a> <a id='n3302' href='#n3302'>3302</a> <a id='n3303' href='#n3303'>3303</a> <a id='n3304' href='#n3304'>3304</a> <a id='n3305' href='#n3305'>3305</a> <a id='n3306' href='#n3306'>3306</a> <a id='n3307' href='#n3307'>3307</a> <a id='n3308' href='#n3308'>3308</a> <a id='n3309' href='#n3309'>3309</a> <a id='n3310' href='#n3310'>3310</a> <a id='n3311' href='#n3311'>3311</a> <a id='n3312' href='#n3312'>3312</a> <a id='n3313' href='#n3313'>3313</a> <a id='n3314' href='#n3314'>3314</a> <a id='n3315' href='#n3315'>3315</a> <a id='n3316' href='#n3316'>3316</a> <a id='n3317' href='#n3317'>3317</a> <a id='n3318' href='#n3318'>3318</a> <a id='n3319' href='#n3319'>3319</a> <a id='n3320' href='#n3320'>3320</a> <a id='n3321' href='#n3321'>3321</a> <a id='n3322' href='#n3322'>3322</a> <a id='n3323' href='#n3323'>3323</a> <a id='n3324' href='#n3324'>3324</a> <a id='n3325' href='#n3325'>3325</a> <a id='n3326' href='#n3326'>3326</a> <a id='n3327' href='#n3327'>3327</a> <a id='n3328' href='#n3328'>3328</a> <a id='n3329' href='#n3329'>3329</a> <a id='n3330' href='#n3330'>3330</a> <a id='n3331' href='#n3331'>3331</a> <a id='n3332' href='#n3332'>3332</a> <a id='n3333' href='#n3333'>3333</a> <a id='n3334' href='#n3334'>3334</a> <a id='n3335' href='#n3335'>3335</a> <a id='n3336' href='#n3336'>3336</a> <a id='n3337' href='#n3337'>3337</a> <a id='n3338' href='#n3338'>3338</a> <a id='n3339' href='#n3339'>3339</a> <a id='n3340' href='#n3340'>3340</a> <a id='n3341' href='#n3341'>3341</a> <a id='n3342' href='#n3342'>3342</a> <a id='n3343' href='#n3343'>3343</a> <a id='n3344' href='#n3344'>3344</a> <a id='n3345' href='#n3345'>3345</a> <a id='n3346' href='#n3346'>3346</a> <a id='n3347' href='#n3347'>3347</a> <a id='n3348' href='#n3348'>3348</a> <a id='n3349' href='#n3349'>3349</a> <a id='n3350' href='#n3350'>3350</a> <a id='n3351' href='#n3351'>3351</a> <a id='n3352' href='#n3352'>3352</a> <a id='n3353' href='#n3353'>3353</a> <a id='n3354' href='#n3354'>3354</a> <a id='n3355' href='#n3355'>3355</a> <a id='n3356' href='#n3356'>3356</a> <a id='n3357' href='#n3357'>3357</a> <a id='n3358' href='#n3358'>3358</a> <a id='n3359' href='#n3359'>3359</a> <a id='n3360' href='#n3360'>3360</a> <a id='n3361' href='#n3361'>3361</a> <a id='n3362' href='#n3362'>3362</a> <a id='n3363' href='#n3363'>3363</a> <a id='n3364' href='#n3364'>3364</a> <a id='n3365' href='#n3365'>3365</a> <a id='n3366' href='#n3366'>3366</a> <a id='n3367' href='#n3367'>3367</a> <a id='n3368' href='#n3368'>3368</a> <a id='n3369' href='#n3369'>3369</a> <a id='n3370' href='#n3370'>3370</a> <a id='n3371' href='#n3371'>3371</a> <a id='n3372' href='#n3372'>3372</a> <a id='n3373' href='#n3373'>3373</a> <a id='n3374' href='#n3374'>3374</a> <a id='n3375' href='#n3375'>3375</a> <a id='n3376' href='#n3376'>3376</a> <a id='n3377' href='#n3377'>3377</a> <a id='n3378' href='#n3378'>3378</a> <a id='n3379' href='#n3379'>3379</a> <a id='n3380' href='#n3380'>3380</a> <a id='n3381' href='#n3381'>3381</a> <a id='n3382' href='#n3382'>3382</a> <a id='n3383' href='#n3383'>3383</a> <a id='n3384' href='#n3384'>3384</a> <a id='n3385' href='#n3385'>3385</a> <a id='n3386' href='#n3386'>3386</a> <a id='n3387' href='#n3387'>3387</a> <a id='n3388' href='#n3388'>3388</a> <a id='n3389' href='#n3389'>3389</a> <a id='n3390' href='#n3390'>3390</a> <a id='n3391' href='#n3391'>3391</a> <a id='n3392' href='#n3392'>3392</a> <a id='n3393' href='#n3393'>3393</a> <a id='n3394' href='#n3394'>3394</a> <a id='n3395' href='#n3395'>3395</a> <a id='n3396' href='#n3396'>3396</a> <a id='n3397' href='#n3397'>3397</a> <a id='n3398' href='#n3398'>3398</a> <a id='n3399' href='#n3399'>3399</a> <a id='n3400' href='#n3400'>3400</a> <a id='n3401' href='#n3401'>3401</a> <a id='n3402' href='#n3402'>3402</a> <a id='n3403' href='#n3403'>3403</a> <a id='n3404' href='#n3404'>3404</a> <a id='n3405' href='#n3405'>3405</a> <a id='n3406' href='#n3406'>3406</a> <a id='n3407' href='#n3407'>3407</a> <a id='n3408' href='#n3408'>3408</a> <a id='n3409' href='#n3409'>3409</a> <a id='n3410' href='#n3410'>3410</a> <a id='n3411' href='#n3411'>3411</a> <a id='n3412' href='#n3412'>3412</a> <a id='n3413' href='#n3413'>3413</a> <a id='n3414' href='#n3414'>3414</a> <a id='n3415' href='#n3415'>3415</a> <a id='n3416' href='#n3416'>3416</a> <a id='n3417' href='#n3417'>3417</a> <a id='n3418' href='#n3418'>3418</a> <a id='n3419' href='#n3419'>3419</a> <a id='n3420' href='#n3420'>3420</a> <a id='n3421' href='#n3421'>3421</a> <a id='n3422' href='#n3422'>3422</a> <a id='n3423' href='#n3423'>3423</a> <a id='n3424' href='#n3424'>3424</a> <a id='n3425' href='#n3425'>3425</a> <a id='n3426' href='#n3426'>3426</a> <a id='n3427' href='#n3427'>3427</a> <a id='n3428' href='#n3428'>3428</a> <a id='n3429' href='#n3429'>3429</a> <a id='n3430' href='#n3430'>3430</a> <a id='n3431' href='#n3431'>3431</a> <a id='n3432' href='#n3432'>3432</a> <a id='n3433' href='#n3433'>3433</a> <a id='n3434' href='#n3434'>3434</a> <a id='n3435' href='#n3435'>3435</a> <a id='n3436' href='#n3436'>3436</a> <a id='n3437' href='#n3437'>3437</a> <a id='n3438' href='#n3438'>3438</a> <a id='n3439' href='#n3439'>3439</a> <a id='n3440' href='#n3440'>3440</a> <a id='n3441' href='#n3441'>3441</a> <a id='n3442' href='#n3442'>3442</a> <a id='n3443' href='#n3443'>3443</a> <a id='n3444' href='#n3444'>3444</a> <a id='n3445' href='#n3445'>3445</a> <a id='n3446' href='#n3446'>3446</a> <a id='n3447' href='#n3447'>3447</a> <a id='n3448' href='#n3448'>3448</a> <a id='n3449' href='#n3449'>3449</a> <a id='n3450' href='#n3450'>3450</a> <a id='n3451' href='#n3451'>3451</a> <a id='n3452' href='#n3452'>3452</a> <a id='n3453' href='#n3453'>3453</a> <a id='n3454' href='#n3454'>3454</a> <a id='n3455' href='#n3455'>3455</a> <a id='n3456' href='#n3456'>3456</a> <a id='n3457' href='#n3457'>3457</a> <a id='n3458' href='#n3458'>3458</a> <a id='n3459' href='#n3459'>3459</a> <a id='n3460' href='#n3460'>3460</a> <a id='n3461' href='#n3461'>3461</a> <a id='n3462' href='#n3462'>3462</a> <a id='n3463' href='#n3463'>3463</a> <a id='n3464' href='#n3464'>3464</a> <a id='n3465' href='#n3465'>3465</a> <a id='n3466' href='#n3466'>3466</a> <a id='n3467' href='#n3467'>3467</a> <a id='n3468' href='#n3468'>3468</a> <a id='n3469' href='#n3469'>3469</a> <a id='n3470' href='#n3470'>3470</a> <a id='n3471' href='#n3471'>3471</a> <a id='n3472' href='#n3472'>3472</a> <a id='n3473' href='#n3473'>3473</a> <a id='n3474' href='#n3474'>3474</a> <a id='n3475' href='#n3475'>3475</a> <a id='n3476' href='#n3476'>3476</a> <a id='n3477' href='#n3477'>3477</a> <a id='n3478' href='#n3478'>3478</a> <a id='n3479' href='#n3479'>3479</a> <a id='n3480' href='#n3480'>3480</a> <a id='n3481' href='#n3481'>3481</a> <a id='n3482' href='#n3482'>3482</a> <a id='n3483' href='#n3483'>3483</a> <a id='n3484' href='#n3484'>3484</a> <a id='n3485' href='#n3485'>3485</a> <a id='n3486' href='#n3486'>3486</a> <a id='n3487' href='#n3487'>3487</a> <a id='n3488' href='#n3488'>3488</a> <a id='n3489' href='#n3489'>3489</a> <a id='n3490' href='#n3490'>3490</a> <a id='n3491' href='#n3491'>3491</a> <a id='n3492' href='#n3492'>3492</a> <a id='n3493' href='#n3493'>3493</a> <a id='n3494' href='#n3494'>3494</a> <a id='n3495' href='#n3495'>3495</a> <a id='n3496' href='#n3496'>3496</a> <a id='n3497' href='#n3497'>3497</a> <a id='n3498' href='#n3498'>3498</a> <a id='n3499' href='#n3499'>3499</a> <a id='n3500' href='#n3500'>3500</a> <a id='n3501' href='#n3501'>3501</a> <a id='n3502' href='#n3502'>3502</a> <a id='n3503' href='#n3503'>3503</a> <a id='n3504' href='#n3504'>3504</a> <a id='n3505' href='#n3505'>3505</a> <a id='n3506' href='#n3506'>3506</a> <a id='n3507' href='#n3507'>3507</a> <a id='n3508' href='#n3508'>3508</a> <a id='n3509' href='#n3509'>3509</a> <a id='n3510' href='#n3510'>3510</a> <a id='n3511' href='#n3511'>3511</a> <a id='n3512' href='#n3512'>3512</a> <a id='n3513' href='#n3513'>3513</a> <a id='n3514' href='#n3514'>3514</a> <a id='n3515' href='#n3515'>3515</a> <a id='n3516' href='#n3516'>3516</a> <a id='n3517' href='#n3517'>3517</a> <a id='n3518' href='#n3518'>3518</a> <a id='n3519' href='#n3519'>3519</a> <a id='n3520' href='#n3520'>3520</a> <a id='n3521' href='#n3521'>3521</a> <a id='n3522' href='#n3522'>3522</a> <a id='n3523' href='#n3523'>3523</a> <a id='n3524' href='#n3524'>3524</a> <a id='n3525' href='#n3525'>3525</a> <a id='n3526' href='#n3526'>3526</a> <a id='n3527' href='#n3527'>3527</a> <a id='n3528' href='#n3528'>3528</a> <a id='n3529' href='#n3529'>3529</a> <a id='n3530' href='#n3530'>3530</a> <a id='n3531' href='#n3531'>3531</a> <a id='n3532' href='#n3532'>3532</a> <a id='n3533' href='#n3533'>3533</a> <a id='n3534' href='#n3534'>3534</a> <a id='n3535' href='#n3535'>3535</a> <a id='n3536' href='#n3536'>3536</a> <a id='n3537' href='#n3537'>3537</a> <a id='n3538' href='#n3538'>3538</a> <a id='n3539' href='#n3539'>3539</a> <a id='n3540' href='#n3540'>3540</a> <a id='n3541' href='#n3541'>3541</a> <a id='n3542' href='#n3542'>3542</a> <a id='n3543' href='#n3543'>3543</a> <a id='n3544' href='#n3544'>3544</a> <a id='n3545' href='#n3545'>3545</a> <a id='n3546' href='#n3546'>3546</a> <a id='n3547' href='#n3547'>3547</a> <a id='n3548' href='#n3548'>3548</a> <a id='n3549' href='#n3549'>3549</a> <a id='n3550' href='#n3550'>3550</a> <a id='n3551' href='#n3551'>3551</a> <a id='n3552' href='#n3552'>3552</a> <a id='n3553' href='#n3553'>3553</a> <a id='n3554' href='#n3554'>3554</a> <a id='n3555' href='#n3555'>3555</a> <a id='n3556' href='#n3556'>3556</a> <a id='n3557' href='#n3557'>3557</a> <a id='n3558' href='#n3558'>3558</a> <a id='n3559' href='#n3559'>3559</a> <a id='n3560' href='#n3560'>3560</a> <a id='n3561' href='#n3561'>3561</a> <a id='n3562' href='#n3562'>3562</a> <a id='n3563' href='#n3563'>3563</a> <a id='n3564' href='#n3564'>3564</a> <a id='n3565' href='#n3565'>3565</a> <a id='n3566' href='#n3566'>3566</a> <a id='n3567' href='#n3567'>3567</a> <a id='n3568' href='#n3568'>3568</a> <a id='n3569' href='#n3569'>3569</a> <a id='n3570' href='#n3570'>3570</a> <a id='n3571' href='#n3571'>3571</a> <a id='n3572' href='#n3572'>3572</a> <a id='n3573' href='#n3573'>3573</a> <a id='n3574' href='#n3574'>3574</a> <a id='n3575' href='#n3575'>3575</a> <a id='n3576' href='#n3576'>3576</a> <a id='n3577' href='#n3577'>3577</a> <a id='n3578' href='#n3578'>3578</a> <a id='n3579' href='#n3579'>3579</a> <a id='n3580' href='#n3580'>3580</a> <a id='n3581' href='#n3581'>3581</a> <a id='n3582' href='#n3582'>3582</a> <a id='n3583' href='#n3583'>3583</a> <a id='n3584' href='#n3584'>3584</a> <a id='n3585' href='#n3585'>3585</a> <a id='n3586' href='#n3586'>3586</a> <a id='n3587' href='#n3587'>3587</a> <a id='n3588' href='#n3588'>3588</a> <a id='n3589' href='#n3589'>3589</a> <a id='n3590' href='#n3590'>3590</a> <a id='n3591' href='#n3591'>3591</a> <a id='n3592' href='#n3592'>3592</a> <a id='n3593' href='#n3593'>3593</a> <a id='n3594' href='#n3594'>3594</a> <a id='n3595' href='#n3595'>3595</a> <a id='n3596' href='#n3596'>3596</a> <a id='n3597' href='#n3597'>3597</a> <a id='n3598' href='#n3598'>3598</a> <a id='n3599' href='#n3599'>3599</a> <a id='n3600' href='#n3600'>3600</a> <a id='n3601' href='#n3601'>3601</a> <a id='n3602' href='#n3602'>3602</a> <a id='n3603' href='#n3603'>3603</a> <a id='n3604' href='#n3604'>3604</a> <a id='n3605' href='#n3605'>3605</a> <a id='n3606' href='#n3606'>3606</a> <a id='n3607' href='#n3607'>3607</a> <a id='n3608' href='#n3608'>3608</a> <a id='n3609' href='#n3609'>3609</a> <a id='n3610' href='#n3610'>3610</a> <a id='n3611' href='#n3611'>3611</a> <a id='n3612' href='#n3612'>3612</a> <a id='n3613' href='#n3613'>3613</a> <a id='n3614' href='#n3614'>3614</a> <a id='n3615' href='#n3615'>3615</a> <a id='n3616' href='#n3616'>3616</a> <a id='n3617' href='#n3617'>3617</a> <a id='n3618' href='#n3618'>3618</a> <a id='n3619' href='#n3619'>3619</a> <a id='n3620' href='#n3620'>3620</a> <a id='n3621' href='#n3621'>3621</a> <a id='n3622' href='#n3622'>3622</a> <a id='n3623' href='#n3623'>3623</a> <a id='n3624' href='#n3624'>3624</a> <a id='n3625' href='#n3625'>3625</a> <a id='n3626' href='#n3626'>3626</a> <a id='n3627' href='#n3627'>3627</a> <a id='n3628' href='#n3628'>3628</a> <a id='n3629' href='#n3629'>3629</a> <a id='n3630' href='#n3630'>3630</a> <a id='n3631' href='#n3631'>3631</a> <a id='n3632' href='#n3632'>3632</a> <a id='n3633' href='#n3633'>3633</a> <a id='n3634' href='#n3634'>3634</a> <a id='n3635' href='#n3635'>3635</a> <a id='n3636' href='#n3636'>3636</a> <a id='n3637' href='#n3637'>3637</a> <a id='n3638' href='#n3638'>3638</a> <a id='n3639' href='#n3639'>3639</a> <a id='n3640' href='#n3640'>3640</a> <a id='n3641' href='#n3641'>3641</a> <a id='n3642' href='#n3642'>3642</a> <a id='n3643' href='#n3643'>3643</a> <a id='n3644' href='#n3644'>3644</a> <a id='n3645' href='#n3645'>3645</a> <a id='n3646' href='#n3646'>3646</a> <a id='n3647' href='#n3647'>3647</a> <a id='n3648' href='#n3648'>3648</a> <a id='n3649' href='#n3649'>3649</a> <a id='n3650' href='#n3650'>3650</a> <a id='n3651' href='#n3651'>3651</a> <a id='n3652' href='#n3652'>3652</a> <a id='n3653' href='#n3653'>3653</a> <a id='n3654' href='#n3654'>3654</a> <a id='n3655' href='#n3655'>3655</a> <a id='n3656' href='#n3656'>3656</a> <a id='n3657' href='#n3657'>3657</a> <a id='n3658' href='#n3658'>3658</a> <a id='n3659' href='#n3659'>3659</a> <a id='n3660' href='#n3660'>3660</a> <a id='n3661' href='#n3661'>3661</a> <a id='n3662' href='#n3662'>3662</a> <a id='n3663' href='#n3663'>3663</a> <a id='n3664' href='#n3664'>3664</a> <a id='n3665' href='#n3665'>3665</a> <a id='n3666' href='#n3666'>3666</a> <a id='n3667' href='#n3667'>3667</a> <a id='n3668' href='#n3668'>3668</a> <a id='n3669' href='#n3669'>3669</a> <a id='n3670' href='#n3670'>3670</a> <a id='n3671' href='#n3671'>3671</a> <a id='n3672' href='#n3672'>3672</a> <a id='n3673' href='#n3673'>3673</a> <a id='n3674' href='#n3674'>3674</a> <a id='n3675' href='#n3675'>3675</a> <a id='n3676' href='#n3676'>3676</a> <a id='n3677' href='#n3677'>3677</a> <a id='n3678' href='#n3678'>3678</a> <a id='n3679' href='#n3679'>3679</a> <a id='n3680' href='#n3680'>3680</a> <a id='n3681' href='#n3681'>3681</a> <a id='n3682' href='#n3682'>3682</a> <a id='n3683' href='#n3683'>3683</a> <a id='n3684' href='#n3684'>3684</a> <a id='n3685' href='#n3685'>3685</a> <a id='n3686' href='#n3686'>3686</a> <a id='n3687' href='#n3687'>3687</a> <a id='n3688' href='#n3688'>3688</a> <a id='n3689' href='#n3689'>3689</a> <a id='n3690' href='#n3690'>3690</a> <a id='n3691' href='#n3691'>3691</a> <a id='n3692' href='#n3692'>3692</a> <a id='n3693' href='#n3693'>3693</a> <a id='n3694' href='#n3694'>3694</a> <a id='n3695' href='#n3695'>3695</a> <a id='n3696' href='#n3696'>3696</a> <a id='n3697' href='#n3697'>3697</a> <a id='n3698' href='#n3698'>3698</a> <a id='n3699' href='#n3699'>3699</a> <a id='n3700' href='#n3700'>3700</a> <a id='n3701' href='#n3701'>3701</a> <a id='n3702' href='#n3702'>3702</a> <a id='n3703' href='#n3703'>3703</a> <a id='n3704' href='#n3704'>3704</a> <a id='n3705' href='#n3705'>3705</a> <a id='n3706' href='#n3706'>3706</a> <a id='n3707' href='#n3707'>3707</a> <a id='n3708' href='#n3708'>3708</a> <a id='n3709' href='#n3709'>3709</a> <a id='n3710' href='#n3710'>3710</a> <a id='n3711' href='#n3711'>3711</a> <a id='n3712' href='#n3712'>3712</a> <a id='n3713' href='#n3713'>3713</a> <a id='n3714' href='#n3714'>3714</a> <a id='n3715' href='#n3715'>3715</a> <a id='n3716' href='#n3716'>3716</a> <a id='n3717' href='#n3717'>3717</a> <a id='n3718' href='#n3718'>3718</a> <a id='n3719' href='#n3719'>3719</a> <a id='n3720' href='#n3720'>3720</a> <a id='n3721' href='#n3721'>3721</a> <a id='n3722' href='#n3722'>3722</a> <a id='n3723' href='#n3723'>3723</a> <a id='n3724' href='#n3724'>3724</a> <a id='n3725' href='#n3725'>3725</a> <a id='n3726' href='#n3726'>3726</a> <a id='n3727' href='#n3727'>3727</a> <a id='n3728' href='#n3728'>3728</a> <a id='n3729' href='#n3729'>3729</a> <a id='n3730' href='#n3730'>3730</a> <a id='n3731' href='#n3731'>3731</a> <a id='n3732' href='#n3732'>3732</a> <a id='n3733' href='#n3733'>3733</a> <a id='n3734' href='#n3734'>3734</a> <a id='n3735' href='#n3735'>3735</a> <a id='n3736' href='#n3736'>3736</a> <a id='n3737' href='#n3737'>3737</a> <a id='n3738' href='#n3738'>3738</a> <a id='n3739' href='#n3739'>3739</a> <a id='n3740' href='#n3740'>3740</a> <a id='n3741' href='#n3741'>3741</a> <a id='n3742' href='#n3742'>3742</a> <a id='n3743' href='#n3743'>3743</a> <a id='n3744' href='#n3744'>3744</a> <a id='n3745' href='#n3745'>3745</a> <a id='n3746' href='#n3746'>3746</a> <a id='n3747' href='#n3747'>3747</a> <a id='n3748' href='#n3748'>3748</a> <a id='n3749' href='#n3749'>3749</a> <a id='n3750' href='#n3750'>3750</a> <a id='n3751' href='#n3751'>3751</a> <a id='n3752' href='#n3752'>3752</a> <a id='n3753' href='#n3753'>3753</a> <a id='n3754' href='#n3754'>3754</a> <a id='n3755' href='#n3755'>3755</a> <a id='n3756' href='#n3756'>3756</a> <a id='n3757' href='#n3757'>3757</a> <a id='n3758' href='#n3758'>3758</a> <a id='n3759' href='#n3759'>3759</a> <a id='n3760' href='#n3760'>3760</a> <a id='n3761' href='#n3761'>3761</a> <a id='n3762' href='#n3762'>3762</a> <a id='n3763' href='#n3763'>3763</a> <a id='n3764' href='#n3764'>3764</a> <a id='n3765' href='#n3765'>3765</a> <a id='n3766' href='#n3766'>3766</a> <a id='n3767' href='#n3767'>3767</a> <a id='n3768' href='#n3768'>3768</a> <a id='n3769' href='#n3769'>3769</a> <a id='n3770' href='#n3770'>3770</a> <a id='n3771' href='#n3771'>3771</a> <a id='n3772' href='#n3772'>3772</a> <a id='n3773' href='#n3773'>3773</a> <a id='n3774' href='#n3774'>3774</a> <a id='n3775' href='#n3775'>3775</a> <a id='n3776' href='#n3776'>3776</a> <a id='n3777' href='#n3777'>3777</a> <a id='n3778' href='#n3778'>3778</a> <a id='n3779' href='#n3779'>3779</a> <a id='n3780' href='#n3780'>3780</a> <a id='n3781' href='#n3781'>3781</a> <a id='n3782' href='#n3782'>3782</a> <a id='n3783' href='#n3783'>3783</a> <a id='n3784' href='#n3784'>3784</a> <a id='n3785' href='#n3785'>3785</a> <a id='n3786' href='#n3786'>3786</a> <a id='n3787' href='#n3787'>3787</a> <a id='n3788' href='#n3788'>3788</a> <a id='n3789' href='#n3789'>3789</a> <a id='n3790' href='#n3790'>3790</a> <a id='n3791' href='#n3791'>3791</a> <a id='n3792' href='#n3792'>3792</a> <a id='n3793' href='#n3793'>3793</a> <a id='n3794' href='#n3794'>3794</a> <a id='n3795' href='#n3795'>3795</a> <a id='n3796' href='#n3796'>3796</a> <a id='n3797' href='#n3797'>3797</a> <a id='n3798' href='#n3798'>3798</a> <a id='n3799' href='#n3799'>3799</a> <a id='n3800' href='#n3800'>3800</a> <a id='n3801' href='#n3801'>3801</a> <a id='n3802' href='#n3802'>3802</a> <a id='n3803' href='#n3803'>3803</a> <a id='n3804' href='#n3804'>3804</a> <a id='n3805' href='#n3805'>3805</a> <a id='n3806' href='#n3806'>3806</a> <a id='n3807' href='#n3807'>3807</a> <a id='n3808' href='#n3808'>3808</a> <a id='n3809' href='#n3809'>3809</a> <a id='n3810' href='#n3810'>3810</a> <a id='n3811' href='#n3811'>3811</a> <a id='n3812' href='#n3812'>3812</a> <a id='n3813' href='#n3813'>3813</a> <a id='n3814' href='#n3814'>3814</a> <a id='n3815' href='#n3815'>3815</a> <a id='n3816' href='#n3816'>3816</a> <a id='n3817' href='#n3817'>3817</a> <a id='n3818' href='#n3818'>3818</a> <a id='n3819' href='#n3819'>3819</a> <a id='n3820' href='#n3820'>3820</a> <a id='n3821' href='#n3821'>3821</a> <a id='n3822' href='#n3822'>3822</a> <a id='n3823' href='#n3823'>3823</a> <a id='n3824' href='#n3824'>3824</a> <a id='n3825' href='#n3825'>3825</a> <a id='n3826' href='#n3826'>3826</a> <a id='n3827' href='#n3827'>3827</a> <a id='n3828' href='#n3828'>3828</a> <a id='n3829' href='#n3829'>3829</a> <a id='n3830' href='#n3830'>3830</a> <a id='n3831' href='#n3831'>3831</a> <a id='n3832' href='#n3832'>3832</a> <a id='n3833' href='#n3833'>3833</a> <a id='n3834' href='#n3834'>3834</a> <a id='n3835' href='#n3835'>3835</a> <a id='n3836' href='#n3836'>3836</a> <a id='n3837' href='#n3837'>3837</a> <a id='n3838' href='#n3838'>3838</a> <a id='n3839' href='#n3839'>3839</a> <a id='n3840' href='#n3840'>3840</a> <a id='n3841' href='#n3841'>3841</a> <a id='n3842' href='#n3842'>3842</a> <a id='n3843' href='#n3843'>3843</a> <a id='n3844' href='#n3844'>3844</a> <a id='n3845' href='#n3845'>3845</a> <a id='n3846' href='#n3846'>3846</a> <a id='n3847' href='#n3847'>3847</a> <a id='n3848' href='#n3848'>3848</a> <a id='n3849' href='#n3849'>3849</a> <a id='n3850' href='#n3850'>3850</a> <a id='n3851' href='#n3851'>3851</a> <a id='n3852' href='#n3852'>3852</a> <a id='n3853' href='#n3853'>3853</a> <a id='n3854' href='#n3854'>3854</a> <a id='n3855' href='#n3855'>3855</a> <a id='n3856' href='#n3856'>3856</a> <a id='n3857' href='#n3857'>3857</a> <a id='n3858' href='#n3858'>3858</a> <a id='n3859' href='#n3859'>3859</a> <a id='n3860' href='#n3860'>3860</a> <a id='n3861' href='#n3861'>3861</a> <a id='n3862' href='#n3862'>3862</a> <a id='n3863' href='#n3863'>3863</a> <a id='n3864' href='#n3864'>3864</a> <a id='n3865' href='#n3865'>3865</a> <a id='n3866' href='#n3866'>3866</a> <a id='n3867' href='#n3867'>3867</a> <a id='n3868' href='#n3868'>3868</a> <a id='n3869' href='#n3869'>3869</a> <a id='n3870' href='#n3870'>3870</a> <a id='n3871' href='#n3871'>3871</a> <a id='n3872' href='#n3872'>3872</a> <a id='n3873' href='#n3873'>3873</a> <a id='n3874' href='#n3874'>3874</a> <a id='n3875' href='#n3875'>3875</a> <a id='n3876' href='#n3876'>3876</a> <a id='n3877' href='#n3877'>3877</a> <a id='n3878' href='#n3878'>3878</a> <a id='n3879' href='#n3879'>3879</a> <a id='n3880' href='#n3880'>3880</a> <a id='n3881' href='#n3881'>3881</a> <a id='n3882' href='#n3882'>3882</a> <a id='n3883' href='#n3883'>3883</a> <a id='n3884' href='#n3884'>3884</a> <a id='n3885' href='#n3885'>3885</a> <a id='n3886' href='#n3886'>3886</a> <a id='n3887' href='#n3887'>3887</a> <a id='n3888' href='#n3888'>3888</a> <a id='n3889' href='#n3889'>3889</a> <a id='n3890' href='#n3890'>3890</a> <a id='n3891' href='#n3891'>3891</a> <a id='n3892' href='#n3892'>3892</a> <a id='n3893' href='#n3893'>3893</a> <a id='n3894' href='#n3894'>3894</a> <a id='n3895' href='#n3895'>3895</a> <a id='n3896' href='#n3896'>3896</a> <a id='n3897' href='#n3897'>3897</a> <a id='n3898' href='#n3898'>3898</a> <a id='n3899' href='#n3899'>3899</a> <a id='n3900' href='#n3900'>3900</a> <a id='n3901' href='#n3901'>3901</a> <a id='n3902' href='#n3902'>3902</a> <a id='n3903' href='#n3903'>3903</a> <a id='n3904' href='#n3904'>3904</a> <a id='n3905' href='#n3905'>3905</a> <a id='n3906' href='#n3906'>3906</a> <a id='n3907' href='#n3907'>3907</a> <a id='n3908' href='#n3908'>3908</a> <a id='n3909' href='#n3909'>3909</a> <a id='n3910' href='#n3910'>3910</a> <a id='n3911' href='#n3911'>3911</a> <a id='n3912' href='#n3912'>3912</a> <a id='n3913' href='#n3913'>3913</a> <a id='n3914' href='#n3914'>3914</a> <a id='n3915' href='#n3915'>3915</a> <a id='n3916' href='#n3916'>3916</a> <a id='n3917' href='#n3917'>3917</a> <a id='n3918' href='#n3918'>3918</a> <a id='n3919' href='#n3919'>3919</a> <a id='n3920' href='#n3920'>3920</a> <a id='n3921' href='#n3921'>3921</a> <a id='n3922' href='#n3922'>3922</a> <a id='n3923' href='#n3923'>3923</a> <a id='n3924' href='#n3924'>3924</a> <a id='n3925' href='#n3925'>3925</a> <a id='n3926' href='#n3926'>3926</a> <a id='n3927' href='#n3927'>3927</a> <a id='n3928' href='#n3928'>3928</a> <a id='n3929' href='#n3929'>3929</a> <a id='n3930' href='#n3930'>3930</a> <a id='n3931' href='#n3931'>3931</a> <a id='n3932' href='#n3932'>3932</a> <a id='n3933' href='#n3933'>3933</a> <a id='n3934' href='#n3934'>3934</a> <a id='n3935' href='#n3935'>3935</a> <a id='n3936' href='#n3936'>3936</a> <a id='n3937' href='#n3937'>3937</a> <a id='n3938' href='#n3938'>3938</a> <a id='n3939' href='#n3939'>3939</a> <a id='n3940' href='#n3940'>3940</a> <a id='n3941' href='#n3941'>3941</a> <a id='n3942' href='#n3942'>3942</a> <a id='n3943' href='#n3943'>3943</a> <a id='n3944' href='#n3944'>3944</a> <a id='n3945' href='#n3945'>3945</a> <a id='n3946' href='#n3946'>3946</a> <a id='n3947' href='#n3947'>3947</a> <a id='n3948' href='#n3948'>3948</a> <a id='n3949' href='#n3949'>3949</a> <a id='n3950' href='#n3950'>3950</a> <a id='n3951' href='#n3951'>3951</a> <a id='n3952' href='#n3952'>3952</a> <a id='n3953' href='#n3953'>3953</a> <a id='n3954' href='#n3954'>3954</a> <a id='n3955' href='#n3955'>3955</a> <a id='n3956' href='#n3956'>3956</a> <a id='n3957' href='#n3957'>3957</a> <a id='n3958' href='#n3958'>3958</a> <a id='n3959' href='#n3959'>3959</a> <a id='n3960' href='#n3960'>3960</a> <a id='n3961' href='#n3961'>3961</a> <a id='n3962' href='#n3962'>3962</a> <a id='n3963' href='#n3963'>3963</a> <a id='n3964' href='#n3964'>3964</a> <a id='n3965' href='#n3965'>3965</a> <a id='n3966' href='#n3966'>3966</a> <a id='n3967' href='#n3967'>3967</a> <a id='n3968' href='#n3968'>3968</a> <a id='n3969' href='#n3969'>3969</a> <a id='n3970' href='#n3970'>3970</a> <a id='n3971' href='#n3971'>3971</a> <a id='n3972' href='#n3972'>3972</a> <a id='n3973' href='#n3973'>3973</a> <a id='n3974' href='#n3974'>3974</a> <a id='n3975' href='#n3975'>3975</a> <a id='n3976' href='#n3976'>3976</a> <a id='n3977' href='#n3977'>3977</a> <a id='n3978' href='#n3978'>3978</a> <a id='n3979' href='#n3979'>3979</a> <a id='n3980' href='#n3980'>3980</a> <a id='n3981' href='#n3981'>3981</a> <a id='n3982' href='#n3982'>3982</a> <a id='n3983' href='#n3983'>3983</a> <a id='n3984' href='#n3984'>3984</a> <a id='n3985' href='#n3985'>3985</a> <a id='n3986' href='#n3986'>3986</a> <a id='n3987' href='#n3987'>3987</a> <a id='n3988' href='#n3988'>3988</a> <a id='n3989' href='#n3989'>3989</a> <a id='n3990' href='#n3990'>3990</a> <a id='n3991' href='#n3991'>3991</a> <a id='n3992' href='#n3992'>3992</a> <a id='n3993' href='#n3993'>3993</a> <a id='n3994' href='#n3994'>3994</a> <a id='n3995' href='#n3995'>3995</a> <a id='n3996' href='#n3996'>3996</a> <a id='n3997' href='#n3997'>3997</a> <a id='n3998' href='#n3998'>3998</a> <a id='n3999' href='#n3999'>3999</a> <a id='n4000' href='#n4000'>4000</a> <a id='n4001' href='#n4001'>4001</a> <a id='n4002' href='#n4002'>4002</a> <a id='n4003' href='#n4003'>4003</a> <a id='n4004' href='#n4004'>4004</a> <a id='n4005' href='#n4005'>4005</a> <a id='n4006' href='#n4006'>4006</a> <a id='n4007' href='#n4007'>4007</a> <a id='n4008' href='#n4008'>4008</a> <a id='n4009' href='#n4009'>4009</a> <a id='n4010' href='#n4010'>4010</a> <a id='n4011' href='#n4011'>4011</a> <a id='n4012' href='#n4012'>4012</a> <a id='n4013' href='#n4013'>4013</a> <a id='n4014' href='#n4014'>4014</a> <a id='n4015' href='#n4015'>4015</a> <a id='n4016' href='#n4016'>4016</a> <a id='n4017' href='#n4017'>4017</a> <a id='n4018' href='#n4018'>4018</a> <a id='n4019' href='#n4019'>4019</a> <a id='n4020' href='#n4020'>4020</a> <a id='n4021' href='#n4021'>4021</a> <a id='n4022' href='#n4022'>4022</a> <a id='n4023' href='#n4023'>4023</a> <a id='n4024' href='#n4024'>4024</a> <a id='n4025' href='#n4025'>4025</a> <a id='n4026' href='#n4026'>4026</a> <a id='n4027' href='#n4027'>4027</a> <a id='n4028' href='#n4028'>4028</a> <a id='n4029' href='#n4029'>4029</a> <a id='n4030' href='#n4030'>4030</a> <a id='n4031' href='#n4031'>4031</a> <a id='n4032' href='#n4032'>4032</a> <a id='n4033' href='#n4033'>4033</a> <a id='n4034' href='#n4034'>4034</a> <a id='n4035' href='#n4035'>4035</a> <a id='n4036' href='#n4036'>4036</a> <a id='n4037' href='#n4037'>4037</a> <a id='n4038' href='#n4038'>4038</a> <a id='n4039' href='#n4039'>4039</a> <a id='n4040' href='#n4040'>4040</a> <a id='n4041' href='#n4041'>4041</a> <a id='n4042' href='#n4042'>4042</a> <a id='n4043' href='#n4043'>4043</a> <a id='n4044' href='#n4044'>4044</a> <a id='n4045' href='#n4045'>4045</a> <a id='n4046' href='#n4046'>4046</a> <a id='n4047' href='#n4047'>4047</a> <a id='n4048' href='#n4048'>4048</a> <a id='n4049' href='#n4049'>4049</a> <a id='n4050' href='#n4050'>4050</a> <a id='n4051' href='#n4051'>4051</a> <a id='n4052' href='#n4052'>4052</a> <a id='n4053' href='#n4053'>4053</a> <a id='n4054' href='#n4054'>4054</a> <a id='n4055' href='#n4055'>4055</a> <a id='n4056' href='#n4056'>4056</a> <a id='n4057' href='#n4057'>4057</a> <a id='n4058' href='#n4058'>4058</a> <a id='n4059' href='#n4059'>4059</a> <a id='n4060' href='#n4060'>4060</a> <a id='n4061' href='#n4061'>4061</a> <a id='n4062' href='#n4062'>4062</a> <a id='n4063' href='#n4063'>4063</a> <a id='n4064' href='#n4064'>4064</a> <a id='n4065' href='#n4065'>4065</a> <a id='n4066' href='#n4066'>4066</a> <a id='n4067' href='#n4067'>4067</a> <a id='n4068' href='#n4068'>4068</a> <a id='n4069' href='#n4069'>4069</a> <a id='n4070' href='#n4070'>4070</a> <a id='n4071' href='#n4071'>4071</a> <a id='n4072' href='#n4072'>4072</a> <a id='n4073' href='#n4073'>4073</a> <a id='n4074' href='#n4074'>4074</a> <a id='n4075' href='#n4075'>4075</a> <a id='n4076' href='#n4076'>4076</a> <a id='n4077' href='#n4077'>4077</a> <a id='n4078' href='#n4078'>4078</a> <a id='n4079' href='#n4079'>4079</a> <a id='n4080' href='#n4080'>4080</a> <a id='n4081' href='#n4081'>4081</a> <a id='n4082' href='#n4082'>4082</a> <a id='n4083' href='#n4083'>4083</a> <a id='n4084' href='#n4084'>4084</a> <a id='n4085' href='#n4085'>4085</a> <a id='n4086' href='#n4086'>4086</a> <a id='n4087' href='#n4087'>4087</a> <a id='n4088' href='#n4088'>4088</a> <a id='n4089' href='#n4089'>4089</a> <a id='n4090' href='#n4090'>4090</a> <a id='n4091' href='#n4091'>4091</a> <a id='n4092' href='#n4092'>4092</a> <a id='n4093' href='#n4093'>4093</a> <a id='n4094' href='#n4094'>4094</a> <a id='n4095' href='#n4095'>4095</a> <a id='n4096' href='#n4096'>4096</a> <a id='n4097' href='#n4097'>4097</a> <a id='n4098' href='#n4098'>4098</a> <a id='n4099' href='#n4099'>4099</a> <a id='n4100' href='#n4100'>4100</a> <a id='n4101' href='#n4101'>4101</a> <a id='n4102' href='#n4102'>4102</a> <a id='n4103' href='#n4103'>4103</a> <a id='n4104' href='#n4104'>4104</a> <a id='n4105' href='#n4105'>4105</a> <a id='n4106' href='#n4106'>4106</a> <a id='n4107' href='#n4107'>4107</a> <a id='n4108' href='#n4108'>4108</a> <a id='n4109' href='#n4109'>4109</a> <a id='n4110' href='#n4110'>4110</a> <a id='n4111' href='#n4111'>4111</a> <a id='n4112' href='#n4112'>4112</a> <a id='n4113' href='#n4113'>4113</a> <a id='n4114' href='#n4114'>4114</a> <a id='n4115' href='#n4115'>4115</a> <a id='n4116' href='#n4116'>4116</a> <a id='n4117' href='#n4117'>4117</a> <a id='n4118' href='#n4118'>4118</a> <a id='n4119' href='#n4119'>4119</a> <a id='n4120' href='#n4120'>4120</a> <a id='n4121' href='#n4121'>4121</a> <a id='n4122' href='#n4122'>4122</a> <a id='n4123' href='#n4123'>4123</a> <a id='n4124' href='#n4124'>4124</a> <a id='n4125' href='#n4125'>4125</a> <a id='n4126' href='#n4126'>4126</a> <a id='n4127' href='#n4127'>4127</a> <a id='n4128' href='#n4128'>4128</a> <a id='n4129' href='#n4129'>4129</a> <a id='n4130' href='#n4130'>4130</a> <a id='n4131' href='#n4131'>4131</a> <a id='n4132' href='#n4132'>4132</a> <a id='n4133' href='#n4133'>4133</a> <a id='n4134' href='#n4134'>4134</a> <a id='n4135' href='#n4135'>4135</a> <a id='n4136' href='#n4136'>4136</a> <a id='n4137' href='#n4137'>4137</a> <a id='n4138' href='#n4138'>4138</a> <a id='n4139' href='#n4139'>4139</a> <a id='n4140' href='#n4140'>4140</a> <a id='n4141' href='#n4141'>4141</a> <a id='n4142' href='#n4142'>4142</a> <a id='n4143' href='#n4143'>4143</a> <a id='n4144' href='#n4144'>4144</a> <a id='n4145' href='#n4145'>4145</a> <a id='n4146' href='#n4146'>4146</a> <a id='n4147' href='#n4147'>4147</a> <a id='n4148' href='#n4148'>4148</a> <a id='n4149' href='#n4149'>4149</a> <a id='n4150' href='#n4150'>4150</a> <a id='n4151' href='#n4151'>4151</a> <a id='n4152' href='#n4152'>4152</a> <a id='n4153' href='#n4153'>4153</a> <a id='n4154' href='#n4154'>4154</a> <a id='n4155' href='#n4155'>4155</a> <a id='n4156' href='#n4156'>4156</a> <a id='n4157' href='#n4157'>4157</a> <a id='n4158' href='#n4158'>4158</a> <a id='n4159' href='#n4159'>4159</a> <a id='n4160' href='#n4160'>4160</a> <a id='n4161' href='#n4161'>4161</a> <a id='n4162' href='#n4162'>4162</a> <a id='n4163' href='#n4163'>4163</a> <a id='n4164' href='#n4164'>4164</a> <a id='n4165' href='#n4165'>4165</a> <a id='n4166' href='#n4166'>4166</a> <a id='n4167' href='#n4167'>4167</a> <a id='n4168' href='#n4168'>4168</a> <a id='n4169' href='#n4169'>4169</a> <a id='n4170' href='#n4170'>4170</a> <a id='n4171' href='#n4171'>4171</a> <a id='n4172' href='#n4172'>4172</a> <a id='n4173' href='#n4173'>4173</a> <a id='n4174' href='#n4174'>4174</a> <a id='n4175' href='#n4175'>4175</a> <a id='n4176' href='#n4176'>4176</a> <a id='n4177' href='#n4177'>4177</a> <a id='n4178' href='#n4178'>4178</a> <a id='n4179' href='#n4179'>4179</a> <a id='n4180' href='#n4180'>4180</a> <a id='n4181' href='#n4181'>4181</a> <a id='n4182' href='#n4182'>4182</a> <a id='n4183' href='#n4183'>4183</a> <a id='n4184' href='#n4184'>4184</a> <a id='n4185' href='#n4185'>4185</a> <a id='n4186' href='#n4186'>4186</a> <a id='n4187' href='#n4187'>4187</a> <a id='n4188' href='#n4188'>4188</a> <a id='n4189' href='#n4189'>4189</a> <a id='n4190' href='#n4190'>4190</a> <a id='n4191' href='#n4191'>4191</a> <a id='n4192' href='#n4192'>4192</a> <a id='n4193' href='#n4193'>4193</a> <a id='n4194' href='#n4194'>4194</a> <a id='n4195' href='#n4195'>4195</a> <a id='n4196' href='#n4196'>4196</a> <a id='n4197' href='#n4197'>4197</a> <a id='n4198' href='#n4198'>4198</a> <a id='n4199' href='#n4199'>4199</a> <a id='n4200' href='#n4200'>4200</a> <a id='n4201' href='#n4201'>4201</a> <a id='n4202' href='#n4202'>4202</a> <a id='n4203' href='#n4203'>4203</a> <a id='n4204' href='#n4204'>4204</a> <a id='n4205' href='#n4205'>4205</a> <a id='n4206' href='#n4206'>4206</a> <a id='n4207' href='#n4207'>4207</a> <a id='n4208' href='#n4208'>4208</a> <a id='n4209' href='#n4209'>4209</a> <a id='n4210' href='#n4210'>4210</a> <a id='n4211' href='#n4211'>4211</a> <a id='n4212' href='#n4212'>4212</a> <a id='n4213' href='#n4213'>4213</a> <a id='n4214' href='#n4214'>4214</a> <a id='n4215' href='#n4215'>4215</a> <a id='n4216' href='#n4216'>4216</a> <a id='n4217' href='#n4217'>4217</a> <a id='n4218' href='#n4218'>4218</a> <a id='n4219' href='#n4219'>4219</a> <a id='n4220' href='#n4220'>4220</a> <a id='n4221' href='#n4221'>4221</a> <a id='n4222' href='#n4222'>4222</a> <a id='n4223' href='#n4223'>4223</a> <a id='n4224' href='#n4224'>4224</a> <a id='n4225' href='#n4225'>4225</a> <a id='n4226' href='#n4226'>4226</a> <a id='n4227' href='#n4227'>4227</a> <a id='n4228' href='#n4228'>4228</a> <a id='n4229' href='#n4229'>4229</a> <a id='n4230' href='#n4230'>4230</a> <a id='n4231' href='#n4231'>4231</a> <a id='n4232' href='#n4232'>4232</a> <a id='n4233' href='#n4233'>4233</a> <a id='n4234' href='#n4234'>4234</a> <a id='n4235' href='#n4235'>4235</a> <a id='n4236' href='#n4236'>4236</a> <a id='n4237' href='#n4237'>4237</a> <a id='n4238' href='#n4238'>4238</a> <a id='n4239' href='#n4239'>4239</a> <a id='n4240' href='#n4240'>4240</a> <a id='n4241' href='#n4241'>4241</a> <a id='n4242' href='#n4242'>4242</a> <a id='n4243' href='#n4243'>4243</a> <a id='n4244' href='#n4244'>4244</a> <a id='n4245' href='#n4245'>4245</a> <a id='n4246' href='#n4246'>4246</a> <a id='n4247' href='#n4247'>4247</a> <a id='n4248' href='#n4248'>4248</a> <a id='n4249' href='#n4249'>4249</a> <a id='n4250' href='#n4250'>4250</a> <a id='n4251' href='#n4251'>4251</a> <a id='n4252' href='#n4252'>4252</a> <a id='n4253' href='#n4253'>4253</a> <a id='n4254' href='#n4254'>4254</a> <a id='n4255' href='#n4255'>4255</a> <a id='n4256' href='#n4256'>4256</a> <a id='n4257' href='#n4257'>4257</a> <a id='n4258' href='#n4258'>4258</a> <a id='n4259' href='#n4259'>4259</a> <a id='n4260' href='#n4260'>4260</a> <a id='n4261' href='#n4261'>4261</a> <a id='n4262' href='#n4262'>4262</a> <a id='n4263' href='#n4263'>4263</a> <a id='n4264' href='#n4264'>4264</a> <a id='n4265' href='#n4265'>4265</a> <a id='n4266' href='#n4266'>4266</a> <a id='n4267' href='#n4267'>4267</a> <a id='n4268' href='#n4268'>4268</a> </pre></td> <td class='lines'><pre><code>