From 69a32ecc1a06d23260834cc15bc4ab16eb70bdf5 Mon Sep 17 00:00:00 2001 From: Andy Balholm Date: Wed, 6 Mar 2019 14:55:38 -0800 Subject: [PATCH] Initial commit. This is the output of c2go, except for util.go. --- backward_references.go | 87 + backward_references_h2.go | 148 + backward_references_h3.go | 148 + backward_references_h35.go | 148 + backward_references_h4.go | 148 + backward_references_h40.go | 148 + backward_references_h41.go | 148 + backward_references_h42.go | 148 + backward_references_h5.go | 148 + backward_references_h54.go | 148 + backward_references_h55.go | 148 + backward_references_h6.go | 148 + backward_references_h65.go | 148 + backward_references_hq.go | 792 + bit_cost.go | 453 + bit_reader.go | 263 + block_splitter.go | 176 + block_splitter_command.go | 431 + block_splitter_distance.go | 431 + block_splitter_literal.go | 431 + brotli_bit_stream.go | 1265 + cluster.go | 43 + cluster_command.go | 325 + cluster_distance.go | 325 + cluster_literal.go | 325 + command.go | 252 + compress_fragment.go | 846 + compress_fragment_common.go | 24 + compress_fragment_two_pass.go | 744 + constants.go | 77 + context.go | 2351 + decode.go | 2812 + dictionary.go | 122910 +++++++++++++++++++++++++++++++ dictionary_hash.go | 32786 +++++++++ encode.go | 2236 + encoder_dict.go | 22 + entropy_encode.go | 615 + entropy_encode_static.go | 4394 ++ fast_log.go | 315 + find_match_length.go | 24 + h10.go | 290 + h2.go | 211 + h3.go | 204 + h35.go | 111 + h4.go | 209 + h40.go | 245 + h41.go | 245 + h42.go | 245 + h5.go | 232 + h54.go | 201 + h55.go | 109 + h6.go | 234 + h65.go | 109 + hash.go | 370 + histogram.go | 225 + hrolling.go | 177 + hrolling_fast.go | 175 + huffman.go | 657 + literal_cost.go | 182 + memory.go | 58 + metablock.go | 585 + metablock_command.go | 163 + metablock_distance.go | 163 + metablock_literal.go | 163 + params.go | 229 + platform.go | 167 + prefix.go | 51 + prefix_dec.go | 843 + quality.go | 196 + ringbuffer.go | 146 + state.go | 301 + static_dict.go | 663 + static_dict_lut.go | 75103 +++++++++++++++++++ symbol_list.go | 21 + transform.go | 662 + types.go | 15 + utf8_util.go | 77 + util.go | 15 + version.go | 23 + write_bits.go | 93 + 80 files changed, 261699 insertions(+) create mode 100644 backward_references.go create mode 100644 backward_references_h2.go create mode 100644 backward_references_h3.go create mode 100644 backward_references_h35.go create mode 100644 backward_references_h4.go create mode 100644 backward_references_h40.go create mode 100644 backward_references_h41.go create mode 100644 backward_references_h42.go create mode 100644 backward_references_h5.go create mode 100644 backward_references_h54.go create mode 100644 backward_references_h55.go create mode 100644 backward_references_h6.go create mode 100644 backward_references_h65.go create mode 100644 backward_references_hq.go create mode 100644 bit_cost.go create mode 100644 bit_reader.go create mode 100644 block_splitter.go create mode 100644 block_splitter_command.go create mode 100644 block_splitter_distance.go create mode 100644 block_splitter_literal.go create mode 100644 brotli_bit_stream.go create mode 100644 cluster.go create mode 100644 cluster_command.go create mode 100644 cluster_distance.go create mode 100644 cluster_literal.go create mode 100644 command.go create mode 100644 compress_fragment.go create mode 100644 compress_fragment_common.go create mode 100644 compress_fragment_two_pass.go create mode 100644 constants.go create mode 100644 context.go create mode 100644 decode.go create mode 100644 dictionary.go create mode 100644 dictionary_hash.go create mode 100644 encode.go create mode 100644 encoder_dict.go create mode 100644 entropy_encode.go create mode 100644 entropy_encode_static.go create mode 100644 fast_log.go create mode 100644 find_match_length.go create mode 100644 h10.go create mode 100644 h2.go create mode 100644 h3.go create mode 100644 h35.go create mode 100644 h4.go create mode 100644 h40.go create mode 100644 h41.go create mode 100644 h42.go create mode 100644 h5.go create mode 100644 h54.go create mode 100644 h55.go create mode 100644 h6.go create mode 100644 h65.go create mode 100644 hash.go create mode 100644 histogram.go create mode 100644 hrolling.go create mode 100644 hrolling_fast.go create mode 100644 huffman.go create mode 100644 literal_cost.go create mode 100644 memory.go create mode 100644 metablock.go create mode 100644 metablock_command.go create mode 100644 metablock_distance.go create mode 100644 metablock_literal.go create mode 100644 params.go create mode 100644 platform.go create mode 100644 prefix.go create mode 100644 prefix_dec.go create mode 100644 quality.go create mode 100644 ringbuffer.go create mode 100644 state.go create mode 100644 static_dict.go create mode 100644 static_dict_lut.go create mode 100644 symbol_list.go create mode 100644 transform.go create mode 100644 types.go create mode 100644 utf8_util.go create mode 100644 util.go create mode 100644 version.go create mode 100644 write_bits.go diff --git a/backward_references.go b/backward_references.go new file mode 100644 index 0000000..2b1c9b9 --- /dev/null +++ b/backward_references.go @@ -0,0 +1,87 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function to find backward reference copies. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function to find backward reference copies. */ + +/* "commands" points to the next output command to write to, "*num_commands" is + initially the total amount of commands output by previous + CreateBackwardReferences calls, and must be incremented by the amount written + by this call. */ +func ComputeDistanceCode(distance uint, max_distance uint, dist_cache []int) uint { + if distance <= max_distance { + var distance_plus_3 uint = distance + 3 + var offset0 uint = distance_plus_3 - uint(dist_cache[0]) + var offset1 uint = distance_plus_3 - uint(dist_cache[1]) + if distance == uint(dist_cache[0]) { + return 0 + } else if distance == uint(dist_cache[1]) { + return 1 + } else if offset0 < 7 { + return (0x9750468 >> (4 * offset0)) & 0xF + } else if offset1 < 7 { + return (0xFDB1ACE >> (4 * offset1)) & 0xF + } else if distance == uint(dist_cache[2]) { + return 2 + } else if distance == uint(dist_cache[3]) { + return 3 + } + } + + return distance + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 +} + +func BrotliCreateBackwardReferences(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + switch params.hasher.type_ { + case 2: + CreateBackwardReferencesNH2(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 3: + CreateBackwardReferencesNH3(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 4: + CreateBackwardReferencesNH4(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 5: + CreateBackwardReferencesNH5(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 6: + CreateBackwardReferencesNH6(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 40: + CreateBackwardReferencesNH40(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 41: + CreateBackwardReferencesNH41(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 42: + CreateBackwardReferencesNH42(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 54: + CreateBackwardReferencesNH54(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 35: + CreateBackwardReferencesNH35(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 55: + CreateBackwardReferencesNH55(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + case 65: + CreateBackwardReferencesNH65(num_bytes, position, ringbuffer, ringbuffer_mask, params, hasher, dist_cache, last_insert_len, commands, num_commands, num_literals) + return + + default: + break + } +} diff --git a/backward_references_h2.go b/backward_references_h2.go new file mode 100644 index 0000000..9129f50 --- /dev/null +++ b/backward_references_h2.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH2(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH2() { + store_end = position + num_bytes - StoreLookaheadH2() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH2(hasher, dist_cache) + + for position+HashTypeLengthH2() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH2(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH2(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH2() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH2(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH2(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH2()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH2(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH2()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH2(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h3.go b/backward_references_h3.go new file mode 100644 index 0000000..22beb6e --- /dev/null +++ b/backward_references_h3.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH3(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH3() { + store_end = position + num_bytes - StoreLookaheadH3() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH3(hasher, dist_cache) + + for position+HashTypeLengthH3() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH3(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH3(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH3() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH3(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH3(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH3()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH3(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH3()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH3(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h35.go b/backward_references_h35.go new file mode 100644 index 0000000..ab6246f --- /dev/null +++ b/backward_references_h35.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH35(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH35() { + store_end = position + num_bytes - StoreLookaheadH35() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH35(hasher, dist_cache) + + for position+HashTypeLengthH35() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH35(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH35(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH35() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH35(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH35(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH35()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH35(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH35()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH35(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h4.go b/backward_references_h4.go new file mode 100644 index 0000000..bde9360 --- /dev/null +++ b/backward_references_h4.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH4(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH4() { + store_end = position + num_bytes - StoreLookaheadH4() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH4(hasher, dist_cache) + + for position+HashTypeLengthH4() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH4(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH4(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH4() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH4(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH4(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH4()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH4(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH4()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH4(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h40.go b/backward_references_h40.go new file mode 100644 index 0000000..c4eeeaa --- /dev/null +++ b/backward_references_h40.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH40(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH40() { + store_end = position + num_bytes - StoreLookaheadH40() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH40(hasher, dist_cache) + + for position+HashTypeLengthH40() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH40(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH40(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH40() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH40(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH40(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH40()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH40(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH40()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH40(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h41.go b/backward_references_h41.go new file mode 100644 index 0000000..b40b46d --- /dev/null +++ b/backward_references_h41.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH41(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH41() { + store_end = position + num_bytes - StoreLookaheadH41() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH41(hasher, dist_cache) + + for position+HashTypeLengthH41() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH41(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH41(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH41() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH41(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH41(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH41()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH41(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH41()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH41(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h42.go b/backward_references_h42.go new file mode 100644 index 0000000..27104e5 --- /dev/null +++ b/backward_references_h42.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH42(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH42() { + store_end = position + num_bytes - StoreLookaheadH42() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH42(hasher, dist_cache) + + for position+HashTypeLengthH42() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH42(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH42(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH42() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH42(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH42(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH42()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH42(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH42()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH42(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h5.go b/backward_references_h5.go new file mode 100644 index 0000000..999bafe --- /dev/null +++ b/backward_references_h5.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH5(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH5() { + store_end = position + num_bytes - StoreLookaheadH5() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH5(hasher, dist_cache) + + for position+HashTypeLengthH5() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH5(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH5(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH5() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH5(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH5(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH5()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH5(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH5()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH5(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h54.go b/backward_references_h54.go new file mode 100644 index 0000000..e9d53ab --- /dev/null +++ b/backward_references_h54.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH54(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH54() { + store_end = position + num_bytes - StoreLookaheadH54() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH54(hasher, dist_cache) + + for position+HashTypeLengthH54() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH54(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH54(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH54() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH54(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH54(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH54()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH54(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH54()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH54(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h55.go b/backward_references_h55.go new file mode 100644 index 0000000..44b38b8 --- /dev/null +++ b/backward_references_h55.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH55(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH55() { + store_end = position + num_bytes - StoreLookaheadH55() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH55(hasher, dist_cache) + + for position+HashTypeLengthH55() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH55(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH55(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH55() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH55(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH55(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH55()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH55(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH55()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH55(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h6.go b/backward_references_h6.go new file mode 100644 index 0000000..ffa5f0f --- /dev/null +++ b/backward_references_h6.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH6(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH6() { + store_end = position + num_bytes - StoreLookaheadH6() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH6(hasher, dist_cache) + + for position+HashTypeLengthH6() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH6(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH6(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH6() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH6(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH6(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH6()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH6(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH6()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH6(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_h65.go b/backward_references_h65.go new file mode 100644 index 0000000..a3a55d8 --- /dev/null +++ b/backward_references_h65.go @@ -0,0 +1,148 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func CreateBackwardReferencesNH65(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var orig_commands []Command = commands + var insert_length uint = *last_insert_len + var pos_end uint = position + num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH65() { + store_end = position + num_bytes - StoreLookaheadH65() + 1 + } else { + store_end = position + } + var random_heuristics_window_size uint = LiteralSpreeLengthForSparseSearch(params) + var apply_random_heuristics uint = position + random_heuristics_window_size + var gap uint = 0 + /* Set maximum distance, see section 9.1. of the spec. */ + + var kMinScore uint = BROTLI_SCORE_BASE + 100 + + /* For speed up heuristics for random data. */ + + /* Minimum score to accept a backward reference. */ + PrepareDistanceCacheH65(hasher, dist_cache) + + for position+HashTypeLengthH65() < pos_end { + var max_length uint = pos_end - position + var max_distance uint = brotli_min_size_t(position, max_backward_limit) + var sr HasherSearchResult + sr.len = 0 + sr.len_code_delta = 0 + sr.distance = 0 + sr.score = kMinScore + FindLongestMatchH65(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position, max_length, max_distance, gap, params.dist.max_distance, &sr) + if sr.score > kMinScore { + /* Found a match. Let's look for something even better ahead. */ + var delayed_backward_references_in_row int = 0 + max_length-- + for ; ; max_length-- { + var cost_diff_lazy uint = 175 + var sr2 HasherSearchResult + if params.quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH { + sr2.len = brotli_min_size_t(sr.len-1, max_length) + } else { + sr2.len = 0 + } + sr2.len_code_delta = 0 + sr2.distance = 0 + sr2.score = kMinScore + max_distance = brotli_min_size_t(position+1, max_backward_limit) + FindLongestMatchH65(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, dist_cache, position+1, max_length, max_distance, gap, params.dist.max_distance, &sr2) + if sr2.score >= sr.score+cost_diff_lazy { + /* Ok, let's just write one byte for now and start a match from the + next byte. */ + position++ + + insert_length++ + sr = sr2 + delayed_backward_references_in_row++ + if delayed_backward_references_in_row < 4 && position+HashTypeLengthH65() < pos_end { + continue + } + } + + break + } + + apply_random_heuristics = position + 2*sr.len + random_heuristics_window_size + max_distance = brotli_min_size_t(position, max_backward_limit) + { + /* The first 16 codes are special short-codes, + and the minimum offset is 1. */ + var distance_code uint = ComputeDistanceCode(sr.distance, max_distance+gap, dist_cache) + if (sr.distance <= (max_distance + gap)) && distance_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(sr.distance) + PrepareDistanceCacheH65(hasher, dist_cache) + } + + InitCommand(&commands[0], ¶ms.dist, insert_length, sr.len, sr.len_code_delta, distance_code) + commands = commands[1:] + } + + *num_literals += insert_length + insert_length = 0 + /* Put the hash keys into the table, if there are enough bytes left. + Depending on the hasher implementation, it can push all positions + in the given range or only a subset of them. + Avoid hash poisoning with RLE data. */ + { + var range_start uint = position + 2 + var range_end uint = brotli_min_size_t(position+sr.len, store_end) + if sr.distance < sr.len>>2 { + range_start = brotli_min_size_t(range_end, brotli_max_size_t(range_start, position+sr.len-(sr.distance<<2))) + } + + StoreRangeH65(hasher, ringbuffer, ringbuffer_mask, range_start, range_end) + } + + position += sr.len + } else { + insert_length++ + position++ + + /* If we have not seen matches for a long time, we can skip some + match lookups. Unsuccessful match lookups are very very expensive + and this kind of a heuristic speeds up compression quite + a lot. */ + if position > apply_random_heuristics { + /* Going through uncompressible data, jump. */ + if position > apply_random_heuristics+4*random_heuristics_window_size { + var kMargin uint = brotli_max_size_t(StoreLookaheadH65()-1, 4) + /* It is quite a long time since we saw a copy, so we assume + that this data is not compressible, and store hashes less + often. Hashes of non compressible data are less likely to + turn out to be useful in the future, too, so we store less of + them to not to flood out the hash table of good compressible + data. */ + + var pos_jump uint = brotli_min_size_t(position+16, pos_end-kMargin) + for ; position < pos_jump; position += 4 { + StoreH65(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 4 + } + } else { + var kMargin uint = brotli_max_size_t(StoreLookaheadH65()-1, 2) + var pos_jump uint = brotli_min_size_t(position+8, pos_end-kMargin) + for ; position < pos_jump; position += 2 { + StoreH65(hasher, ringbuffer, ringbuffer_mask, position) + insert_length += 2 + } + } + } + } + } + + insert_length += pos_end - position + *last_insert_len = insert_length + *num_commands += uint(-cap(commands) + cap(orig_commands)) +} diff --git a/backward_references_hq.go b/backward_references_hq.go new file mode 100644 index 0000000..5fa94b8 --- /dev/null +++ b/backward_references_hq.go @@ -0,0 +1,792 @@ +package brotli + +type ZopfliNode struct { + length uint32 + distance uint32 + dcode_insert_length uint32 + u struct { + cost float32 + next uint32 + shortcut uint32 + } +} + +/* Computes the shortest path of commands from position to at most + position + num_bytes. + + On return, path->size() is the number of commands found and path[i] is the + length of the i-th command (copy length plus insert length). + Note that the sum of the lengths of all commands can be less than num_bytes. + + On return, the nodes[0..num_bytes] array will have the following + "ZopfliNode array invariant": + For each i in [1..num_bytes], if nodes[i].cost < kInfinity, then + (1) nodes[i].copy_length() >= 2 + (2) nodes[i].command_length() <= i and + (3) nodes[i - nodes[i].command_length()].cost < kInfinity */ +const BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE = 544 + +var kInfinity float32 = 1.7e38 /* ~= 2 ^ 127 */ + +var kDistanceCacheIndex = []uint32{0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1} + +var kDistanceCacheOffset = []int{0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3} + +func BrotliInitZopfliNodes(array []ZopfliNode, length uint) { + var stub ZopfliNode + var i uint + stub.length = 1 + stub.distance = 0 + stub.dcode_insert_length = 0 + stub.u.cost = kInfinity + for i = 0; i < length; i++ { + array[i] = stub + } +} + +func ZopfliNodeCopyLength(self *ZopfliNode) uint32 { + return self.length & 0x1FFFFFF +} + +func ZopfliNodeLengthCode(self *ZopfliNode) uint32 { + var modifier uint32 = self.length >> 25 + return ZopfliNodeCopyLength(self) + 9 - modifier +} + +func ZopfliNodeCopyDistance(self *ZopfliNode) uint32 { + return self.distance +} + +func ZopfliNodeDistanceCode(self *ZopfliNode) uint32 { + var short_code uint32 = self.dcode_insert_length >> 27 + if short_code == 0 { + return ZopfliNodeCopyDistance(self) + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 + } else { + return short_code - 1 + } +} + +func ZopfliNodeCommandLength(self *ZopfliNode) uint32 { + return ZopfliNodeCopyLength(self) + (self.dcode_insert_length & 0x7FFFFFF) +} + +/* Histogram based cost model for zopflification. */ +type ZopfliCostModel struct { + cost_cmd_ [BROTLI_NUM_COMMAND_SYMBOLS]float32 + cost_dist_ []float32 + distance_histogram_size uint32 + literal_costs_ []float32 + min_cost_cmd_ float32 + num_bytes_ uint +} + +func InitZopfliCostModel(self *ZopfliCostModel, dist *BrotliDistanceParams, num_bytes uint) { + var distance_histogram_size uint32 = dist.alphabet_size + if distance_histogram_size > BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE { + distance_histogram_size = BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE + } + + self.num_bytes_ = num_bytes + self.literal_costs_ = make([]float32, (num_bytes + 2)) + self.cost_dist_ = make([]float32, (dist.alphabet_size)) + self.distance_histogram_size = distance_histogram_size +} + +func CleanupZopfliCostModel(self *ZopfliCostModel) { + self.literal_costs_ = nil + self.cost_dist_ = nil +} + +func SetCost(histogram []uint32, histogram_size uint, literal_histogram bool, cost []float32) { + var sum uint = 0 + var missing_symbol_sum uint + var log2sum float32 + var missing_symbol_cost float32 + var i uint + for i = 0; i < histogram_size; i++ { + sum += uint(histogram[i]) + } + + log2sum = float32(FastLog2(sum)) + missing_symbol_sum = sum + if !literal_histogram { + for i = 0; i < histogram_size; i++ { + if histogram[i] == 0 { + missing_symbol_sum++ + } + } + } + + missing_symbol_cost = float32(FastLog2(missing_symbol_sum)) + 2 + for i = 0; i < histogram_size; i++ { + if histogram[i] == 0 { + cost[i] = missing_symbol_cost + continue + } + + /* Shannon bits for this symbol. */ + cost[i] = log2sum - float32(FastLog2(uint(histogram[i]))) + + /* Cannot be coded with less than 1 bit */ + if cost[i] < 1 { + cost[i] = 1 + } + } +} + +func ZopfliCostModelSetFromCommands(self *ZopfliCostModel, position uint, ringbuffer []byte, ringbuffer_mask uint, commands []Command, num_commands uint, last_insert_len uint) { + var histogram_literal [BROTLI_NUM_LITERAL_SYMBOLS]uint32 + var histogram_cmd [BROTLI_NUM_COMMAND_SYMBOLS]uint32 + var histogram_dist [BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE]uint32 + var cost_literal [BROTLI_NUM_LITERAL_SYMBOLS]float32 + var pos uint = position - last_insert_len + var min_cost_cmd float32 = kInfinity + var i uint + var cost_cmd []float32 = self.cost_cmd_[:] + var literal_costs []float32 + + histogram_literal = [BROTLI_NUM_LITERAL_SYMBOLS]uint32{} + histogram_cmd = [BROTLI_NUM_COMMAND_SYMBOLS]uint32{} + histogram_dist = [BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE]uint32{} + + for i = 0; i < num_commands; i++ { + var inslength uint = uint(commands[i].insert_len_) + var copylength uint = uint(CommandCopyLen(&commands[i])) + var distcode uint = uint(commands[i].dist_prefix_) & 0x3FF + var cmdcode uint = uint(commands[i].cmd_prefix_) + var j uint + + histogram_cmd[cmdcode]++ + if cmdcode >= 128 { + histogram_dist[distcode]++ + } + + for j = 0; j < inslength; j++ { + histogram_literal[ringbuffer[(pos+j)&ringbuffer_mask]]++ + } + + pos += inslength + copylength + } + + SetCost(histogram_literal[:], BROTLI_NUM_LITERAL_SYMBOLS, true, cost_literal[:]) + SetCost(histogram_cmd[:], BROTLI_NUM_COMMAND_SYMBOLS, false, cost_cmd) + SetCost(histogram_dist[:], uint(self.distance_histogram_size), false, self.cost_dist_) + + for i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; i++ { + min_cost_cmd = brotli_min_float(min_cost_cmd, cost_cmd[i]) + } + + self.min_cost_cmd_ = min_cost_cmd + { + literal_costs = self.literal_costs_ + var literal_carry float32 = 0.0 + var num_bytes uint = self.num_bytes_ + literal_costs[0] = 0.0 + for i = 0; i < num_bytes; i++ { + literal_carry += cost_literal[ringbuffer[(position+i)&ringbuffer_mask]] + literal_costs[i+1] = literal_costs[i] + literal_carry + literal_carry -= literal_costs[i+1] - literal_costs[i] + } + } +} + +func ZopfliCostModelSetFromLiteralCosts(self *ZopfliCostModel, position uint, ringbuffer []byte, ringbuffer_mask uint) { + var literal_costs []float32 = self.literal_costs_ + var literal_carry float32 = 0.0 + var cost_dist []float32 = self.cost_dist_ + var cost_cmd []float32 = self.cost_cmd_[:] + var num_bytes uint = self.num_bytes_ + var i uint + BrotliEstimateBitCostsForLiterals(position, num_bytes, ringbuffer_mask, ringbuffer, literal_costs[1:]) + literal_costs[0] = 0.0 + for i = 0; i < num_bytes; i++ { + literal_carry += literal_costs[i+1] + literal_costs[i+1] = literal_costs[i] + literal_carry + literal_carry -= literal_costs[i+1] - literal_costs[i] + } + + for i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; i++ { + cost_cmd[i] = float32(FastLog2(uint(11 + uint32(i)))) + } + + for i = 0; uint32(i) < self.distance_histogram_size; i++ { + cost_dist[i] = float32(FastLog2(uint(20 + uint32(i)))) + } + + self.min_cost_cmd_ = float32(FastLog2(11)) +} + +func ZopfliCostModelGetCommandCost(self *ZopfliCostModel, cmdcode uint16) float32 { + return self.cost_cmd_[cmdcode] +} + +func ZopfliCostModelGetDistanceCost(self *ZopfliCostModel, distcode uint) float32 { + return self.cost_dist_[distcode] +} + +func ZopfliCostModelGetLiteralCosts(self *ZopfliCostModel, from uint, to uint) float32 { + return self.literal_costs_[to] - self.literal_costs_[from] +} + +func ZopfliCostModelGetMinCostCmd(self *ZopfliCostModel) float32 { + return self.min_cost_cmd_ +} + +/* REQUIRES: len >= 2, start_pos <= pos */ +/* REQUIRES: cost < kInfinity, nodes[start_pos].cost < kInfinity */ +/* Maintains the "ZopfliNode array invariant". */ +func UpdateZopfliNode(nodes []ZopfliNode, pos uint, start_pos uint, len uint, len_code uint, dist uint, short_code uint, cost float32) { + var next *ZopfliNode = &nodes[pos+len] + next.length = uint32(len | (len+9-len_code)<<25) + next.distance = uint32(dist) + next.dcode_insert_length = uint32(short_code<<27 | (pos - start_pos)) + next.u.cost = cost +} + +type PosData struct { + pos uint + distance_cache [4]int + costdiff float32 + cost float32 +} + +/* Maintains the smallest 8 cost difference together with their positions */ +type StartPosQueue struct { + q_ [8]PosData + idx_ uint +} + +func InitStartPosQueue(self *StartPosQueue) { + self.idx_ = 0 +} + +func StartPosQueueSize(self *StartPosQueue) uint { + return brotli_min_size_t(self.idx_, 8) +} + +func StartPosQueuePush(self *StartPosQueue, posdata *PosData) { + var offset uint = ^(self.idx_) & 7 + self.idx_++ + var len uint = StartPosQueueSize(self) + var i uint + var q []PosData = self.q_[:] + q[offset] = *posdata + + /* Restore the sorted order. In the list of |len| items at most |len - 1| + adjacent element comparisons / swaps are required. */ + for i = 1; i < len; i++ { + if q[offset&7].costdiff > q[(offset+1)&7].costdiff { + var tmp PosData = q[offset&7] + q[offset&7] = q[(offset+1)&7] + q[(offset+1)&7] = tmp + } + + offset++ + } +} + +func StartPosQueueAt(self *StartPosQueue, k uint) *PosData { + return &self.q_[(k-self.idx_)&7] +} + +/* Returns the minimum possible copy length that can improve the cost of any */ +/* future position. */ +func ComputeMinimumCopyLength(start_cost float32, nodes []ZopfliNode, num_bytes uint, pos uint) uint { + var min_cost float32 = start_cost + var len uint = 2 + var next_len_bucket uint = 4 + /* Compute the minimum possible cost of reaching any future position. */ + + var next_len_offset uint = 10 + for pos+len <= num_bytes && nodes[pos+len].u.cost <= min_cost { + /* We already reached (pos + len) with no more cost than the minimum + possible cost of reaching anything from this pos, so there is no point in + looking for lengths <= len. */ + len++ + + if len == next_len_offset { + /* We reached the next copy length code bucket, so we add one more + extra bit to the minimum cost. */ + min_cost += 1.0 + + next_len_offset += next_len_bucket + next_len_bucket *= 2 + } + } + + return uint(len) +} + +/* REQUIRES: nodes[pos].cost < kInfinity + REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */ +func ComputeDistanceShortcut(block_start uint, pos uint, max_backward_limit uint, gap uint, nodes []ZopfliNode) uint32 { + var clen uint = uint(ZopfliNodeCopyLength(&nodes[pos])) + var ilen uint = uint(nodes[pos].dcode_insert_length & 0x7FFFFFF) + var dist uint = uint(ZopfliNodeCopyDistance(&nodes[pos])) + + /* Since |block_start + pos| is the end position of the command, the copy part + starts from |block_start + pos - clen|. Distances that are greater than + this or greater than |max_backward_limit| + |gap| are static dictionary + references, and do not update the last distances. + Also distance code 0 (last distance) does not update the last distances. */ + if pos == 0 { + return 0 + } else if dist+clen <= block_start+pos+gap && dist <= max_backward_limit+gap && ZopfliNodeDistanceCode(&nodes[pos]) > 0 { + return uint32(pos) + } else { + return nodes[pos-clen-ilen].u.shortcut + } +} + +/* Fills in dist_cache[0..3] with the last four distances (as defined by + Section 4. of the Spec) that would be used at (block_start + pos) if we + used the shortest path of commands from block_start, computed from + nodes[0..pos]. The last four distances at block_start are in + starting_dist_cache[0..3]. + REQUIRES: nodes[pos].cost < kInfinity + REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */ +func ComputeDistanceCache(pos uint, starting_dist_cache []int, nodes []ZopfliNode, dist_cache []int) { + var idx int = 0 + var p uint = uint(nodes[pos].u.shortcut) + for idx < 4 && p > 0 { + var ilen uint = uint(nodes[p].dcode_insert_length & 0x7FFFFFF) + var clen uint = uint(ZopfliNodeCopyLength(&nodes[p])) + var dist uint = uint(ZopfliNodeCopyDistance(&nodes[p])) + dist_cache[idx] = int(dist) + idx++ + + /* Because of prerequisite, p >= clen + ilen >= 2. */ + p = uint(nodes[p-clen-ilen].u.shortcut) + } + + for ; idx < 4; idx++ { + dist_cache[idx] = starting_dist_cache[0] + starting_dist_cache = starting_dist_cache[1:] + } +} + +/* Maintains "ZopfliNode array invariant" and pushes node to the queue, if it + is eligible. */ +func EvaluateNode(block_start uint, pos uint, max_backward_limit uint, gap uint, starting_dist_cache []int, model *ZopfliCostModel, queue *StartPosQueue, nodes []ZopfliNode) { + /* Save cost, because ComputeDistanceCache invalidates it. */ + var node_cost float32 = nodes[pos].u.cost + nodes[pos].u.shortcut = ComputeDistanceShortcut(block_start, pos, max_backward_limit, gap, nodes) + if node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos) { + var posdata PosData + posdata.pos = pos + posdata.cost = node_cost + posdata.costdiff = node_cost - ZopfliCostModelGetLiteralCosts(model, 0, pos) + ComputeDistanceCache(pos, starting_dist_cache, nodes, posdata.distance_cache[:]) + StartPosQueuePush(queue, &posdata) + } +} + +/* Returns longest copy length. */ +func UpdateNodes(num_bytes uint, block_start uint, pos uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, max_backward_limit uint, starting_dist_cache []int, num_matches uint, matches []BackwardMatch, model *ZopfliCostModel, queue *StartPosQueue, nodes []ZopfliNode) uint { + var cur_ix uint = block_start + pos + var cur_ix_masked uint = cur_ix & ringbuffer_mask + var max_distance uint = brotli_min_size_t(cur_ix, max_backward_limit) + var max_len uint = num_bytes - pos + var max_zopfli_len uint = MaxZopfliLen(params) + var max_iters uint = MaxZopfliCandidates(params) + var min_len uint + var result uint = 0 + var k uint + var gap uint = 0 + + EvaluateNode(block_start, pos, max_backward_limit, gap, starting_dist_cache, model, queue, nodes) + { + var posdata *PosData = StartPosQueueAt(queue, 0) + var min_cost float32 = (posdata.cost + ZopfliCostModelGetMinCostCmd(model) + ZopfliCostModelGetLiteralCosts(model, posdata.pos, pos)) + min_len = ComputeMinimumCopyLength(min_cost, nodes, num_bytes, pos) + } + + /* Go over the command starting positions in order of increasing cost + difference. */ + for k = 0; k < max_iters && k < StartPosQueueSize(queue); k++ { + var posdata *PosData = StartPosQueueAt(queue, k) + var start uint = posdata.pos + var inscode uint16 = GetInsertLengthCode(pos - start) + var start_costdiff float32 = posdata.costdiff + var base_cost float32 = start_costdiff + float32(GetInsertExtra(inscode)) + ZopfliCostModelGetLiteralCosts(model, 0, pos) + var best_len uint = min_len - 1 + var j uint = 0 + /* Look for last distance matches using the distance cache from this + starting position. */ + for ; j < BROTLI_NUM_DISTANCE_SHORT_CODES && best_len < max_len; j++ { + var idx uint = uint(kDistanceCacheIndex[j]) + var backward uint = uint(posdata.distance_cache[idx] + kDistanceCacheOffset[j]) + var prev_ix uint = cur_ix - backward + var len uint = 0 + var continuation byte = ringbuffer[cur_ix_masked+best_len] + if cur_ix_masked+best_len > ringbuffer_mask { + break + } + + if backward > max_distance+gap { + /* Word dictionary -> ignore. */ + continue + } + + if backward <= max_distance { + /* Regular backward reference. */ + if prev_ix >= cur_ix { + continue + } + + prev_ix &= ringbuffer_mask + if prev_ix+best_len > ringbuffer_mask || continuation != ringbuffer[prev_ix+best_len] { + continue + } + + len = FindMatchLengthWithLimit(ringbuffer[prev_ix:], ringbuffer[cur_ix_masked:], max_len) + } else { + continue + } + { + var dist_cost float32 = base_cost + ZopfliCostModelGetDistanceCost(model, j) + var l uint + for l = best_len + 1; l <= len; l++ { + var copycode uint16 = GetCopyLengthCode(l) + var cmdcode uint16 = CombineLengthCodes(inscode, copycode, j == 0) + var tmp float32 + if cmdcode < 128 { + tmp = base_cost + } else { + tmp = dist_cost + } + var cost float32 = tmp + float32(GetCopyExtra(copycode)) + ZopfliCostModelGetCommandCost(model, cmdcode) + if cost < nodes[pos+l].u.cost { + UpdateZopfliNode(nodes, pos, start, l, l, backward, j+1, cost) + result = brotli_max_size_t(result, l) + } + + best_len = l + } + } + } + + /* At higher iterations look only for new last distance matches, since + looking only for new command start positions with the same distances + does not help much. */ + if k >= 2 { + continue + } + { + /* Loop through all possible copy lengths at this position. */ + var len uint = min_len + for j = 0; j < num_matches; j++ { + var match BackwardMatch = matches[j] + var dist uint = uint(match.distance) + var is_dictionary_match bool = (dist > max_distance+gap) + var dist_code uint = dist + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 + var dist_symbol uint16 + var distextra uint32 + var distnumextra uint32 + var dist_cost float32 + var max_match_len uint + /* We already tried all possible last distance matches, so we can use + normal distance code here. */ + PrefixEncodeCopyDistance(dist_code, uint(params.dist.num_direct_distance_codes), uint(params.dist.distance_postfix_bits), &dist_symbol, &distextra) + + distnumextra = uint32(dist_symbol) >> 10 + dist_cost = base_cost + float32(distnumextra) + ZopfliCostModelGetDistanceCost(model, uint(dist_symbol)&0x3FF) + + /* Try all copy lengths up until the maximum copy length corresponding + to this distance. If the distance refers to the static dictionary, or + the maximum length is long enough, try only one maximum length. */ + max_match_len = BackwardMatchLength(&match) + + if len < max_match_len && (is_dictionary_match || max_match_len > max_zopfli_len) { + len = max_match_len + } + + for ; len <= max_match_len; len++ { + var len_code uint + if is_dictionary_match { + len_code = BackwardMatchLengthCode(&match) + } else { + len_code = len + } + var copycode uint16 = GetCopyLengthCode(len_code) + var cmdcode uint16 = CombineLengthCodes(inscode, copycode, false) + var cost float32 = dist_cost + float32(GetCopyExtra(copycode)) + ZopfliCostModelGetCommandCost(model, cmdcode) + if cost < nodes[pos+len].u.cost { + UpdateZopfliNode(nodes, pos, start, uint(len), len_code, dist, 0, cost) + result = brotli_max_size_t(result, uint(len)) + } + } + } + } + } + + return result +} + +func ComputeShortestPathFromNodes(num_bytes uint, nodes []ZopfliNode) uint { + var index uint = num_bytes + var num_commands uint = 0 + for nodes[index].dcode_insert_length&0x7FFFFFF == 0 && nodes[index].length == 1 { + index-- + } + nodes[index].u.next = BROTLI_UINT32_MAX + for index != 0 { + var len uint = uint(ZopfliNodeCommandLength(&nodes[index])) + index -= uint(len) + nodes[index].u.next = uint32(len) + num_commands++ + } + + return num_commands +} + +/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */ +func BrotliZopfliCreateCommands(num_bytes uint, block_start uint, nodes []ZopfliNode, dist_cache []int, last_insert_len *uint, params *BrotliEncoderParams, commands []Command, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var pos uint = 0 + var offset uint32 = nodes[0].u.next + var i uint + var gap uint = 0 + for i = 0; offset != BROTLI_UINT32_MAX; i++ { + var next *ZopfliNode = &nodes[uint32(pos)+offset] + var copy_length uint = uint(ZopfliNodeCopyLength(next)) + var insert_length uint = uint(next.dcode_insert_length & 0x7FFFFFF) + pos += insert_length + offset = next.u.next + if i == 0 { + insert_length += *last_insert_len + *last_insert_len = 0 + } + { + var distance uint = uint(ZopfliNodeCopyDistance(next)) + var len_code uint = uint(ZopfliNodeLengthCode(next)) + var max_distance uint = brotli_min_size_t(block_start+pos, max_backward_limit) + var is_dictionary bool = (distance > max_distance+gap) + var dist_code uint = uint(ZopfliNodeDistanceCode(next)) + InitCommand(&commands[i], ¶ms.dist, insert_length, copy_length, int(len_code)-int(copy_length), dist_code) + + if !is_dictionary && dist_code > 0 { + dist_cache[3] = dist_cache[2] + dist_cache[2] = dist_cache[1] + dist_cache[1] = dist_cache[0] + dist_cache[0] = int(distance) + } + } + + *num_literals += insert_length + pos += copy_length + } + + *last_insert_len += num_bytes - pos +} + +func ZopfliIterate(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, gap uint, dist_cache []int, model *ZopfliCostModel, num_matches []uint32, matches []BackwardMatch, nodes []ZopfliNode) uint { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var max_zopfli_len uint = MaxZopfliLen(params) + var queue StartPosQueue + var cur_match_pos uint = 0 + var i uint + nodes[0].length = 0 + nodes[0].u.cost = 0 + InitStartPosQueue(&queue) + for i = 0; i+3 < num_bytes; i++ { + var skip uint = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask, params, max_backward_limit, dist_cache, uint(num_matches[i]), matches[cur_match_pos:], model, &queue, nodes) + if skip < BROTLI_LONG_COPY_QUICK_STEP { + skip = 0 + } + cur_match_pos += uint(num_matches[i]) + if num_matches[i] == 1 && BackwardMatchLength(&matches[cur_match_pos-1]) > max_zopfli_len { + skip = brotli_max_size_t(BackwardMatchLength(&matches[cur_match_pos-1]), skip) + } + + if skip > 1 { + skip-- + for skip != 0 { + i++ + if i+3 >= num_bytes { + break + } + EvaluateNode(position, i, max_backward_limit, gap, dist_cache, model, &queue, nodes) + cur_match_pos += uint(num_matches[i]) + skip-- + } + } + } + + return ComputeShortestPathFromNodes(num_bytes, nodes) +} + +/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */ +func BrotliZopfliComputeShortestPath(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, dist_cache []int, hasher HasherHandle, nodes []ZopfliNode) uint { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var max_zopfli_len uint = MaxZopfliLen(params) + var model ZopfliCostModel + var queue StartPosQueue + var matches [2 * (MAX_NUM_MATCHES_H10 + 64)]BackwardMatch + var store_end uint + if num_bytes >= StoreLookaheadH10() { + store_end = position + num_bytes - StoreLookaheadH10() + 1 + } else { + store_end = position + } + var i uint + var gap uint = 0 + var lz_matches_offset uint = 0 + nodes[0].length = 0 + nodes[0].u.cost = 0 + InitZopfliCostModel(&model, ¶ms.dist, num_bytes) + ZopfliCostModelSetFromLiteralCosts(&model, position, ringbuffer, ringbuffer_mask) + InitStartPosQueue(&queue) + for i = 0; i+HashTypeLengthH10()-1 < num_bytes; i++ { + var pos uint = position + i + var max_distance uint = brotli_min_size_t(pos, max_backward_limit) + var skip uint + var num_matches uint + num_matches = FindAllMatchesH10(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, pos, num_bytes-i, max_distance, gap, params, matches[lz_matches_offset:]) + if num_matches > 0 && BackwardMatchLength(&matches[num_matches-1]) > max_zopfli_len { + matches[0] = matches[num_matches-1] + num_matches = 1 + } + + skip = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask, params, max_backward_limit, dist_cache, num_matches, matches[:], &model, &queue, nodes) + if skip < BROTLI_LONG_COPY_QUICK_STEP { + skip = 0 + } + if num_matches == 1 && BackwardMatchLength(&matches[0]) > max_zopfli_len { + skip = brotli_max_size_t(BackwardMatchLength(&matches[0]), skip) + } + + if skip > 1 { + /* Add the tail of the copy to the hasher. */ + StoreRangeH10(hasher, ringbuffer, ringbuffer_mask, pos+1, brotli_min_size_t(pos+skip, store_end)) + + skip-- + for skip != 0 { + i++ + if i+HashTypeLengthH10()-1 >= num_bytes { + break + } + EvaluateNode(position, i, max_backward_limit, gap, dist_cache, &model, &queue, nodes) + skip-- + } + } + } + + CleanupZopfliCostModel(&model) + return ComputeShortestPathFromNodes(num_bytes, nodes) +} + +func BrotliCreateZopfliBackwardReferences(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var nodes []ZopfliNode + nodes = make([]ZopfliNode, (num_bytes + 1)) + BrotliInitZopfliNodes(nodes, num_bytes+1) + *num_commands += BrotliZopfliComputeShortestPath(num_bytes, position, ringbuffer, ringbuffer_mask, params, dist_cache, hasher, nodes) + BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache, last_insert_len, params, commands, num_literals) + nodes = nil +} + +func BrotliCreateHqZopfliBackwardReferences(num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint, params *BrotliEncoderParams, hasher HasherHandle, dist_cache []int, last_insert_len *uint, commands []Command, num_commands *uint, num_literals *uint) { + var max_backward_limit uint = BROTLI_MAX_BACKWARD_LIMIT(params.lgwin) + var num_matches []uint32 = make([]uint32, num_bytes) + var matches_size uint = 4 * num_bytes + var store_end uint + if num_bytes >= StoreLookaheadH10() { + store_end = position + num_bytes - StoreLookaheadH10() + 1 + } else { + store_end = position + } + var cur_match_pos uint = 0 + var i uint + var orig_num_literals uint + var orig_last_insert_len uint + var orig_dist_cache [4]int + var orig_num_commands uint + var model ZopfliCostModel + var nodes []ZopfliNode + var matches []BackwardMatch = make([]BackwardMatch, matches_size) + var gap uint = 0 + var shadow_matches uint = 0 + var new_array []BackwardMatch + for i = 0; i+HashTypeLengthH10()-1 < num_bytes; i++ { + var pos uint = position + i + var max_distance uint = brotli_min_size_t(pos, max_backward_limit) + var max_length uint = num_bytes - i + var num_found_matches uint + var cur_match_end uint + var j uint + + /* Ensure that we have enough free slots. */ + if matches_size < cur_match_pos+MAX_NUM_MATCHES_H10+shadow_matches { + var new_size uint = matches_size + if new_size == 0 { + new_size = cur_match_pos + MAX_NUM_MATCHES_H10 + shadow_matches + } + + for new_size < cur_match_pos+MAX_NUM_MATCHES_H10+shadow_matches { + new_size *= 2 + } + + new_array = make([]BackwardMatch, new_size) + if matches_size != 0 { + copy(new_array, matches[:matches_size]) + } + + matches = new_array + matches_size = new_size + } + + num_found_matches = FindAllMatchesH10(hasher, ¶ms.dictionary, ringbuffer, ringbuffer_mask, pos, max_length, max_distance, gap, params, matches[cur_match_pos+shadow_matches:]) + cur_match_end = cur_match_pos + num_found_matches + for j = cur_match_pos; j+1 < cur_match_end; j++ { + assert(BackwardMatchLength(&matches[j]) <= BackwardMatchLength(&matches[j+1])) + } + + num_matches[i] = uint32(num_found_matches) + if num_found_matches > 0 { + var match_len uint = BackwardMatchLength(&matches[cur_match_end-1]) + if match_len > MAX_ZOPFLI_LEN_QUALITY_11 { + var skip uint = match_len - 1 + matches[cur_match_pos] = matches[cur_match_end-1] + cur_match_pos++ + num_matches[i] = 1 + + /* Add the tail of the copy to the hasher. */ + StoreRangeH10(hasher, ringbuffer, ringbuffer_mask, pos+1, brotli_min_size_t(pos+match_len, store_end)) + var pos uint = i + for i := 0; i < int(skip); i++ { + num_matches[pos+1:][i] = 0 + } + i += skip + } else { + cur_match_pos = cur_match_end + } + } + } + + orig_num_literals = *num_literals + orig_last_insert_len = *last_insert_len + copy(orig_dist_cache[:], dist_cache[:4]) + orig_num_commands = *num_commands + nodes = make([]ZopfliNode, (num_bytes + 1)) + InitZopfliCostModel(&model, ¶ms.dist, num_bytes) + for i = 0; i < 2; i++ { + BrotliInitZopfliNodes(nodes, num_bytes+1) + if i == 0 { + ZopfliCostModelSetFromLiteralCosts(&model, position, ringbuffer, ringbuffer_mask) + } else { + ZopfliCostModelSetFromCommands(&model, position, ringbuffer, ringbuffer_mask, commands, *num_commands-orig_num_commands, orig_last_insert_len) + } + + *num_commands = orig_num_commands + *num_literals = orig_num_literals + *last_insert_len = orig_last_insert_len + copy(dist_cache, orig_dist_cache[:4]) + *num_commands += ZopfliIterate(num_bytes, position, ringbuffer, ringbuffer_mask, params, gap, dist_cache, &model, num_matches, matches, nodes) + BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache, last_insert_len, params, commands, num_literals) + } + + CleanupZopfliCostModel(&model) + nodes = nil + matches = nil + num_matches = nil +} diff --git a/bit_cost.go b/bit_cost.go new file mode 100644 index 0000000..d97dc5c --- /dev/null +++ b/bit_cost.go @@ -0,0 +1,453 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions to estimate the bit cost of Huffman trees. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions to estimate the bit cost of Huffman trees. */ +func ShannonEntropy(population []uint32, size uint, total *uint) float64 { + var sum uint = 0 + var retval float64 = 0 + var population_end []uint32 = population[size:] + var p uint + for -cap(population) < -cap(population_end) { + p = uint(population[0]) + population = population[1:] + sum += p + retval -= float64(p) * FastLog2(p) + } + + if sum != 0 { + retval += float64(sum) * FastLog2(sum) + } + *total = sum + return retval +} + +func BitsEntropy(population []uint32, size uint) float64 { + var sum uint + var retval float64 = ShannonEntropy(population, size, &sum) + if retval < float64(sum) { + /* At least one bit per literal is needed. */ + retval = float64(sum) + } + + return retval +} + +var BrotliPopulationCostLiteral_kOneSymbolHistogramCost float64 = 12 +var BrotliPopulationCostLiteral_kTwoSymbolHistogramCost float64 = 20 +var BrotliPopulationCostLiteral_kThreeSymbolHistogramCost float64 = 28 +var BrotliPopulationCostLiteral_kFourSymbolHistogramCost float64 = 37 + +func BrotliPopulationCostLiteral(histogram *HistogramLiteral) float64 { + var data_size uint = HistogramDataSizeLiteral() + var count int = 0 + var s [5]uint + var bits float64 = 0.0 + var i uint + if histogram.total_count_ == 0 { + return BrotliPopulationCostLiteral_kOneSymbolHistogramCost + } + + for i = 0; i < data_size; i++ { + if histogram.data_[i] > 0 { + s[count] = i + count++ + if count > 4 { + break + } + } + } + + if count == 1 { + return BrotliPopulationCostLiteral_kOneSymbolHistogramCost + } + + if count == 2 { + return BrotliPopulationCostLiteral_kTwoSymbolHistogramCost + float64(histogram.total_count_) + } + + if count == 3 { + var histo0 uint32 = histogram.data_[s[0]] + var histo1 uint32 = histogram.data_[s[1]] + var histo2 uint32 = histogram.data_[s[2]] + var histomax uint32 = brotli_max_uint32_t(histo0, brotli_max_uint32_t(histo1, histo2)) + return BrotliPopulationCostLiteral_kThreeSymbolHistogramCost + 2*(float64(histo0)+float64(histo1)+float64(histo2)) - float64(histomax) + } + + if count == 4 { + var histo [4]uint32 + var h23 uint32 + var histomax uint32 + for i = 0; i < 4; i++ { + histo[i] = histogram.data_[s[i]] + } + + /* Sort */ + for i = 0; i < 4; i++ { + var j uint + for j = i + 1; j < 4; j++ { + if histo[j] > histo[i] { + var tmp uint32 = histo[j] + histo[j] = histo[i] + histo[i] = tmp + } + } + } + + h23 = histo[2] + histo[3] + histomax = brotli_max_uint32_t(h23, histo[0]) + return BrotliPopulationCostLiteral_kFourSymbolHistogramCost + 3*float64(h23) + 2*(float64(histo[0])+float64(histo[1])) - float64(histomax) + } + { + var max_depth uint = 1 + var depth_histo = [BROTLI_CODE_LENGTH_CODES]uint32{0} + /* In this loop we compute the entropy of the histogram and simultaneously + build a simplified histogram of the code length codes where we use the + zero repeat code 17, but we don't use the non-zero repeat code 16. */ + + var log2total float64 = FastLog2(histogram.total_count_) + for i = 0; i < data_size; { + if histogram.data_[i] > 0 { + var log2p float64 = log2total - FastLog2(uint(histogram.data_[i])) + /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) = + = log2(total_count) - log2(count(symbol)) */ + + var depth uint = uint(log2p + 0.5) + /* Approximate the bit depth by round(-log2(P(symbol))) */ + bits += float64(histogram.data_[i]) * log2p + + if depth > 15 { + depth = 15 + } + + if depth > max_depth { + max_depth = depth + } + + depth_histo[depth]++ + i++ + } else { + var reps uint32 = 1 + /* Compute the run length of zeros and add the appropriate number of 0 + and 17 code length codes to the code length code histogram. */ + + var k uint + for k = i + 1; k < data_size && histogram.data_[k] == 0; k++ { + reps++ + } + + i += uint(reps) + if i == data_size { + /* Don't add any cost for the last zero run, since these are encoded + only implicitly. */ + break + } + + if reps < 3 { + depth_histo[0] += reps + } else { + reps -= 2 + for reps > 0 { + depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH]++ + + /* Add the 3 extra bits for the 17 code length code. */ + bits += 3 + + reps >>= 3 + } + } + } + } + + /* Add the estimated encoding cost of the code length code histogram. */ + bits += float64(18 + 2*max_depth) + + /* Add the entropy of the code length code histogram. */ + bits += BitsEntropy(depth_histo[:], BROTLI_CODE_LENGTH_CODES) + } + + return bits +} + +var BrotliPopulationCostCommand_kOneSymbolHistogramCost float64 = 12 +var BrotliPopulationCostCommand_kTwoSymbolHistogramCost float64 = 20 +var BrotliPopulationCostCommand_kThreeSymbolHistogramCost float64 = 28 +var BrotliPopulationCostCommand_kFourSymbolHistogramCost float64 = 37 + +func BrotliPopulationCostCommand(histogram *HistogramCommand) float64 { + var data_size uint = HistogramDataSizeCommand() + var count int = 0 + var s [5]uint + var bits float64 = 0.0 + var i uint + if histogram.total_count_ == 0 { + return BrotliPopulationCostCommand_kOneSymbolHistogramCost + } + + for i = 0; i < data_size; i++ { + if histogram.data_[i] > 0 { + s[count] = i + count++ + if count > 4 { + break + } + } + } + + if count == 1 { + return BrotliPopulationCostCommand_kOneSymbolHistogramCost + } + + if count == 2 { + return BrotliPopulationCostCommand_kTwoSymbolHistogramCost + float64(histogram.total_count_) + } + + if count == 3 { + var histo0 uint32 = histogram.data_[s[0]] + var histo1 uint32 = histogram.data_[s[1]] + var histo2 uint32 = histogram.data_[s[2]] + var histomax uint32 = brotli_max_uint32_t(histo0, brotli_max_uint32_t(histo1, histo2)) + return BrotliPopulationCostCommand_kThreeSymbolHistogramCost + 2*(float64(histo0)+float64(histo1)+float64(histo2)) - float64(histomax) + } + + if count == 4 { + var histo [4]uint32 + var h23 uint32 + var histomax uint32 + for i = 0; i < 4; i++ { + histo[i] = histogram.data_[s[i]] + } + + /* Sort */ + for i = 0; i < 4; i++ { + var j uint + for j = i + 1; j < 4; j++ { + if histo[j] > histo[i] { + var tmp uint32 = histo[j] + histo[j] = histo[i] + histo[i] = tmp + } + } + } + + h23 = histo[2] + histo[3] + histomax = brotli_max_uint32_t(h23, histo[0]) + return BrotliPopulationCostCommand_kFourSymbolHistogramCost + 3*float64(h23) + 2*(float64(histo[0])+float64(histo[1])) - float64(histomax) + } + { + var max_depth uint = 1 + var depth_histo = [BROTLI_CODE_LENGTH_CODES]uint32{0} + /* In this loop we compute the entropy of the histogram and simultaneously + build a simplified histogram of the code length codes where we use the + zero repeat code 17, but we don't use the non-zero repeat code 16. */ + + var log2total float64 = FastLog2(histogram.total_count_) + for i = 0; i < data_size; { + if histogram.data_[i] > 0 { + var log2p float64 = log2total - FastLog2(uint(histogram.data_[i])) + /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) = + = log2(total_count) - log2(count(symbol)) */ + + var depth uint = uint(log2p + 0.5) + /* Approximate the bit depth by round(-log2(P(symbol))) */ + bits += float64(histogram.data_[i]) * log2p + + if depth > 15 { + depth = 15 + } + + if depth > max_depth { + max_depth = depth + } + + depth_histo[depth]++ + i++ + } else { + var reps uint32 = 1 + /* Compute the run length of zeros and add the appropriate number of 0 + and 17 code length codes to the code length code histogram. */ + + var k uint + for k = i + 1; k < data_size && histogram.data_[k] == 0; k++ { + reps++ + } + + i += uint(reps) + if i == data_size { + /* Don't add any cost for the last zero run, since these are encoded + only implicitly. */ + break + } + + if reps < 3 { + depth_histo[0] += reps + } else { + reps -= 2 + for reps > 0 { + depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH]++ + + /* Add the 3 extra bits for the 17 code length code. */ + bits += 3 + + reps >>= 3 + } + } + } + } + + /* Add the estimated encoding cost of the code length code histogram. */ + bits += float64(18 + 2*max_depth) + + /* Add the entropy of the code length code histogram. */ + bits += BitsEntropy(depth_histo[:], BROTLI_CODE_LENGTH_CODES) + } + + return bits +} + +var BrotliPopulationCostDistance_kOneSymbolHistogramCost float64 = 12 +var BrotliPopulationCostDistance_kTwoSymbolHistogramCost float64 = 20 +var BrotliPopulationCostDistance_kThreeSymbolHistogramCost float64 = 28 +var BrotliPopulationCostDistance_kFourSymbolHistogramCost float64 = 37 + +func BrotliPopulationCostDistance(histogram *HistogramDistance) float64 { + var data_size uint = HistogramDataSizeDistance() + var count int = 0 + var s [5]uint + var bits float64 = 0.0 + var i uint + if histogram.total_count_ == 0 { + return BrotliPopulationCostDistance_kOneSymbolHistogramCost + } + + for i = 0; i < data_size; i++ { + if histogram.data_[i] > 0 { + s[count] = i + count++ + if count > 4 { + break + } + } + } + + if count == 1 { + return BrotliPopulationCostDistance_kOneSymbolHistogramCost + } + + if count == 2 { + return BrotliPopulationCostDistance_kTwoSymbolHistogramCost + float64(histogram.total_count_) + } + + if count == 3 { + var histo0 uint32 = histogram.data_[s[0]] + var histo1 uint32 = histogram.data_[s[1]] + var histo2 uint32 = histogram.data_[s[2]] + var histomax uint32 = brotli_max_uint32_t(histo0, brotli_max_uint32_t(histo1, histo2)) + return BrotliPopulationCostDistance_kThreeSymbolHistogramCost + 2*(float64(histo0)+float64(histo1)+float64(histo2)) - float64(histomax) + } + + if count == 4 { + var histo [4]uint32 + var h23 uint32 + var histomax uint32 + for i = 0; i < 4; i++ { + histo[i] = histogram.data_[s[i]] + } + + /* Sort */ + for i = 0; i < 4; i++ { + var j uint + for j = i + 1; j < 4; j++ { + if histo[j] > histo[i] { + var tmp uint32 = histo[j] + histo[j] = histo[i] + histo[i] = tmp + } + } + } + + h23 = histo[2] + histo[3] + histomax = brotli_max_uint32_t(h23, histo[0]) + return BrotliPopulationCostDistance_kFourSymbolHistogramCost + 3*float64(h23) + 2*(float64(histo[0])+float64(histo[1])) - float64(histomax) + } + { + var max_depth uint = 1 + var depth_histo = [BROTLI_CODE_LENGTH_CODES]uint32{0} + /* In this loop we compute the entropy of the histogram and simultaneously + build a simplified histogram of the code length codes where we use the + zero repeat code 17, but we don't use the non-zero repeat code 16. */ + + var log2total float64 = FastLog2(histogram.total_count_) + for i = 0; i < data_size; { + if histogram.data_[i] > 0 { + var log2p float64 = log2total - FastLog2(uint(histogram.data_[i])) + /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) = + = log2(total_count) - log2(count(symbol)) */ + + var depth uint = uint(log2p + 0.5) + /* Approximate the bit depth by round(-log2(P(symbol))) */ + bits += float64(histogram.data_[i]) * log2p + + if depth > 15 { + depth = 15 + } + + if depth > max_depth { + max_depth = depth + } + + depth_histo[depth]++ + i++ + } else { + var reps uint32 = 1 + /* Compute the run length of zeros and add the appropriate number of 0 + and 17 code length codes to the code length code histogram. */ + + var k uint + for k = i + 1; k < data_size && histogram.data_[k] == 0; k++ { + reps++ + } + + i += uint(reps) + if i == data_size { + /* Don't add any cost for the last zero run, since these are encoded + only implicitly. */ + break + } + + if reps < 3 { + depth_histo[0] += reps + } else { + reps -= 2 + for reps > 0 { + depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH]++ + + /* Add the 3 extra bits for the 17 code length code. */ + bits += 3 + + reps >>= 3 + } + } + } + } + + /* Add the estimated encoding cost of the code length code histogram. */ + bits += float64(18 + 2*max_depth) + + /* Add the entropy of the code length code histogram. */ + bits += BitsEntropy(depth_histo[:], BROTLI_CODE_LENGTH_CODES) + } + + return bits +} diff --git a/bit_reader.go b/bit_reader.go new file mode 100644 index 0000000..b5a208a --- /dev/null +++ b/bit_reader.go @@ -0,0 +1,263 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Bit reading helpers */ +const BROTLI_SHORT_FILL_BIT_WINDOW_READ = (8 >> 1) + +var kBitMask = [33]uint32{ + 0x00000000, + 0x00000001, + 0x00000003, + 0x00000007, + 0x0000000F, + 0x0000001F, + 0x0000003F, + 0x0000007F, + 0x000000FF, + 0x000001FF, + 0x000003FF, + 0x000007FF, + 0x00000FFF, + 0x00001FFF, + 0x00003FFF, + 0x00007FFF, + 0x0000FFFF, + 0x0001FFFF, + 0x0003FFFF, + 0x0007FFFF, + 0x000FFFFF, + 0x001FFFFF, + 0x003FFFFF, + 0x007FFFFF, + 0x00FFFFFF, + 0x01FFFFFF, + 0x03FFFFFF, + 0x07FFFFFF, + 0x0FFFFFFF, + 0x1FFFFFFF, + 0x3FFFFFFF, + 0x7FFFFFFF, + 0xFFFFFFFF, +} + +func BitMask(n uint32) uint32 { + return kBitMask[n] +} + +type BrotliBitReader struct { + val_ uint64 + bit_pos_ uint32 + input []byte + input_len uint + byte_pos uint +} + +type BrotliBitReaderState struct { + val_ uint64 + bit_pos_ uint32 + input []byte + input_len uint + byte_pos uint +} + +/* Initializes the BrotliBitReader fields. */ + +/* Ensures that accumulator is not empty. + May consume up to sizeof(brotli_reg_t) - 1 bytes of input. + Returns false if data is required but there is no input available. + For BROTLI_ALIGNED_READ this function also prepares bit reader for aligned + reading. */ +func BrotliBitReaderSaveState(from *BrotliBitReader, to *BrotliBitReaderState) { + to.val_ = from.val_ + to.bit_pos_ = from.bit_pos_ + to.input = from.input + to.input_len = from.input_len + to.byte_pos = from.byte_pos +} + +func BrotliBitReaderRestoreState(to *BrotliBitReader, from *BrotliBitReaderState) { + to.val_ = from.val_ + to.bit_pos_ = from.bit_pos_ + to.input = from.input + to.input_len = from.input_len + to.byte_pos = from.byte_pos +} + +func BrotliGetAvailableBits(br *BrotliBitReader) uint32 { + return 64 - br.bit_pos_ +} + +/* Returns amount of unread bytes the bit reader still has buffered from the + BrotliInput, including whole bytes in br->val_. */ +func BrotliGetRemainingBytes(br *BrotliBitReader) uint { + return uint(uint32(br.input_len-br.byte_pos) + (BrotliGetAvailableBits(br) >> 3)) +} + +/* Checks if there is at least |num| bytes left in the input ring-buffer + (excluding the bits remaining in br->val_). */ +func BrotliCheckInputAmount(br *BrotliBitReader, num uint) bool { + return br.input_len-br.byte_pos >= num +} + +/* Guarantees that there are at least |n_bits| + 1 bits in accumulator. + Precondition: accumulator contains at least 1 bit. + |n_bits| should be in the range [1..24] for regular build. For portable + non-64-bit little-endian build only 16 bits are safe to request. */ +func BrotliFillBitWindow(br *BrotliBitReader, n_bits uint32) { + if br.bit_pos_ >= 32 { + br.val_ >>= 32 + br.bit_pos_ ^= 32 /* here same as -= 32 because of the if condition */ + br.val_ |= (uint64(BROTLI_UNALIGNED_LOAD32LE(br.input[br.byte_pos:]))) << 32 + br.byte_pos += 4 + } +} + +/* Mostly like BrotliFillBitWindow, but guarantees only 16 bits and reads no + more than BROTLI_SHORT_FILL_BIT_WINDOW_READ bytes of input. */ +func BrotliFillBitWindow16(br *BrotliBitReader) { + BrotliFillBitWindow(br, 17) +} + +/* Tries to pull one byte of input to accumulator. + Returns false if there is no input available. */ +func BrotliPullByte(br *BrotliBitReader) bool { + if br.byte_pos == br.input_len { + return false + } + + br.val_ >>= 8 + br.val_ |= (uint64(br.input[br.byte_pos])) << 56 + br.bit_pos_ -= 8 + br.byte_pos++ + return true +} + +/* Returns currently available bits. + The number of valid bits could be calculated by BrotliGetAvailableBits. */ +func BrotliGetBitsUnmasked(br *BrotliBitReader) uint64 { + return br.val_ >> br.bit_pos_ +} + +/* Like BrotliGetBits, but does not mask the result. + The result contains at least 16 valid bits. */ +func BrotliGet16BitsUnmasked(br *BrotliBitReader) uint32 { + BrotliFillBitWindow(br, 16) + return uint32(BrotliGetBitsUnmasked(br)) +} + +/* Returns the specified number of bits from |br| without advancing bit + position. */ +func BrotliGetBits(br *BrotliBitReader, n_bits uint32) uint32 { + BrotliFillBitWindow(br, n_bits) + return uint32(BrotliGetBitsUnmasked(br)) & BitMask(n_bits) +} + +/* Tries to peek the specified amount of bits. Returns false, if there + is not enough input. */ +func BrotliSafeGetBits(br *BrotliBitReader, n_bits uint32, val *uint32) bool { + for BrotliGetAvailableBits(br) < n_bits { + if !BrotliPullByte(br) { + return false + } + } + + *val = uint32(BrotliGetBitsUnmasked(br)) & BitMask(n_bits) + return true +} + +/* Advances the bit pos by |n_bits|. */ +func BrotliDropBits(br *BrotliBitReader, n_bits uint32) { + br.bit_pos_ += n_bits +} + +func BrotliBitReaderUnload(br *BrotliBitReader) { + var unused_bytes uint32 = BrotliGetAvailableBits(br) >> 3 + var unused_bits uint32 = unused_bytes << 3 + br.byte_pos -= uint(unused_bytes) + if unused_bits == 64 { + br.val_ = 0 + } else { + br.val_ <<= unused_bits + } + + br.bit_pos_ += unused_bits +} + +/* Reads the specified number of bits from |br| and advances the bit pos. + Precondition: accumulator MUST contain at least |n_bits|. */ +func BrotliTakeBits(br *BrotliBitReader, n_bits uint32, val *uint32) { + *val = uint32(BrotliGetBitsUnmasked(br)) & BitMask(n_bits) + BrotliDropBits(br, n_bits) +} + +/* Reads the specified number of bits from |br| and advances the bit pos. + Assumes that there is enough input to perform BrotliFillBitWindow. */ +func BrotliReadBits(br *BrotliBitReader, n_bits uint32) uint32 { + var val uint32 + BrotliFillBitWindow(br, n_bits) + BrotliTakeBits(br, n_bits, &val) + return val +} + +/* Tries to read the specified amount of bits. Returns false, if there + is not enough input. |n_bits| MUST be positive. */ +func BrotliSafeReadBits(br *BrotliBitReader, n_bits uint32, val *uint32) bool { + for BrotliGetAvailableBits(br) < n_bits { + if !BrotliPullByte(br) { + return false + } + } + + BrotliTakeBits(br, n_bits, val) + return true +} + +/* Advances the bit reader position to the next byte boundary and verifies + that any skipped bits are set to zero. */ +func BrotliJumpToByteBoundary(br *BrotliBitReader) bool { + var pad_bits_count uint32 = BrotliGetAvailableBits(br) & 0x7 + var pad_bits uint32 = 0 + if pad_bits_count != 0 { + BrotliTakeBits(br, pad_bits_count, &pad_bits) + } + + return pad_bits == 0 +} + +/* Copies remaining input bytes stored in the bit reader to the output. Value + |num| may not be larger than BrotliGetRemainingBytes. The bit reader must be + warmed up again after this. */ +func BrotliCopyBytes(dest []byte, br *BrotliBitReader, num uint) { + for BrotliGetAvailableBits(br) >= 8 && num > 0 { + dest[0] = byte(BrotliGetBitsUnmasked(br)) + BrotliDropBits(br, 8) + dest = dest[1:] + num-- + } + + copy(dest, br.input[br.byte_pos:][:num]) + br.byte_pos += num +} + +func BrotliInitBitReader(br *BrotliBitReader) { + br.val_ = 0 + br.bit_pos_ = 64 +} + +func BrotliWarmupBitReader(br *BrotliBitReader) bool { + /* Fixing alignment after unaligned BrotliFillWindow would result accumulator + overflow. If unalignment is caused by BrotliSafeReadBits, then there is + enough space in accumulator to fix alignment. */ + if BrotliGetAvailableBits(br) == 0 { + if !BrotliPullByte(br) { + return false + } + } + + return true +} diff --git a/block_splitter.go b/block_splitter.go new file mode 100644 index 0000000..3426291 --- /dev/null +++ b/block_splitter.go @@ -0,0 +1,176 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Build per-context histograms of literals, commands and distance codes. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Models the histograms of literals, commands and distance codes. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Block split point selection utilities. */ +type BlockSplit struct { + num_types uint + num_blocks uint + types []byte + lengths []uint32 + types_alloc_size uint + lengths_alloc_size uint +} + +var kMaxLiteralHistograms uint = 100 + +var kMaxCommandHistograms uint = 50 + +var kLiteralBlockSwitchCost float64 = 28.1 + +var kCommandBlockSwitchCost float64 = 13.5 + +var kDistanceBlockSwitchCost float64 = 14.6 + +var kLiteralStrideLength uint = 70 + +var kCommandStrideLength uint = 40 + +var kSymbolsPerLiteralHistogram uint = 544 + +var kSymbolsPerCommandHistogram uint = 530 + +var kSymbolsPerDistanceHistogram uint = 544 + +var kMinLengthForBlockSplitting uint = 128 + +var kIterMulForRefining uint = 2 + +var kMinItersForRefining uint = 100 + +func CountLiterals(cmds []Command, num_commands uint) uint { + var total_length uint = 0 + /* Count how many we have. */ + + var i uint + for i = 0; i < num_commands; i++ { + total_length += uint(cmds[i].insert_len_) + } + + return total_length +} + +func CopyLiteralsToByteArray(cmds []Command, num_commands uint, data []byte, offset uint, mask uint, literals []byte) { + var pos uint = 0 + var from_pos uint = offset & mask + var i uint + for i = 0; i < num_commands; i++ { + var insert_len uint = uint(cmds[i].insert_len_) + if from_pos+insert_len > mask { + var head_size uint = mask + 1 - from_pos + copy(literals[pos:], data[from_pos:][:head_size]) + from_pos = 0 + pos += head_size + insert_len -= head_size + } + + if insert_len > 0 { + copy(literals[pos:], data[from_pos:][:insert_len]) + pos += insert_len + } + + from_pos = uint((uint32(from_pos+insert_len) + CommandCopyLen(&cmds[i])) & uint32(mask)) + } +} + +func MyRand(seed *uint32) uint32 { + /* Initial seed should be 7. In this case, loop length is (1 << 29). */ + *seed *= 16807 + + return *seed +} + +func BitCost(count uint) float64 { + if count == 0 { + return -2.0 + } else { + return FastLog2(count) + } +} + +const HISTOGRAMS_PER_BATCH = 64 + +const CLUSTERS_PER_BATCH = 16 + +func BrotliInitBlockSplit(self *BlockSplit) { + self.num_types = 0 + self.num_blocks = 0 + self.types = nil + self.lengths = nil + self.types_alloc_size = 0 + self.lengths_alloc_size = 0 +} + +func BrotliDestroyBlockSplit(self *BlockSplit) { + self.types = nil + self.lengths = nil +} + +func BrotliSplitBlock(cmds []Command, num_commands uint, data []byte, pos uint, mask uint, params *BrotliEncoderParams, literal_split *BlockSplit, insert_and_copy_split *BlockSplit, dist_split *BlockSplit) { + { + var literals_count uint = CountLiterals(cmds, num_commands) + var literals []byte = make([]byte, literals_count) + + /* Create a continuous array of literals. */ + CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, literals) + + /* Create the block split on the array of literals. + Literal histograms have alphabet size 256. */ + SplitByteVectorLiteral(literals, literals_count, kSymbolsPerLiteralHistogram, kMaxLiteralHistograms, kLiteralStrideLength, kLiteralBlockSwitchCost, params, literal_split) + + literals = nil + } + { + var insert_and_copy_codes []uint16 = make([]uint16, num_commands) + /* Compute prefix codes for commands. */ + + var i uint + for i = 0; i < num_commands; i++ { + insert_and_copy_codes[i] = cmds[i].cmd_prefix_ + } + + /* Create the block split on the array of command prefixes. */ + SplitByteVectorCommand(insert_and_copy_codes, num_commands, kSymbolsPerCommandHistogram, kMaxCommandHistograms, kCommandStrideLength, kCommandBlockSwitchCost, params, insert_and_copy_split) + + /* TODO: reuse for distances? */ + + insert_and_copy_codes = nil + } + { + var distance_prefixes []uint16 = make([]uint16, num_commands) + var j uint = 0 + /* Create a continuous array of distance prefixes. */ + + var i uint + for i = 0; i < num_commands; i++ { + var cmd *Command = &cmds[i] + if CommandCopyLen(cmd) != 0 && cmd.cmd_prefix_ >= 128 { + distance_prefixes[j] = cmd.dist_prefix_ & 0x3FF + j++ + } + } + + /* Create the block split on the array of distance prefixes. */ + SplitByteVectorDistance(distance_prefixes, j, kSymbolsPerDistanceHistogram, kMaxCommandHistograms, kCommandStrideLength, kDistanceBlockSwitchCost, params, dist_split) + + distance_prefixes = nil + } +} diff --git a/block_splitter_command.go b/block_splitter_command.go new file mode 100644 index 0000000..0cb0f13 --- /dev/null +++ b/block_splitter_command.go @@ -0,0 +1,431 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func InitialEntropyCodesCommand(data []uint16, length uint, stride uint, num_histograms uint, histograms []HistogramCommand) { + var seed uint32 = 7 + var block_length uint = length / num_histograms + var i uint + ClearHistogramsCommand(histograms, num_histograms) + for i = 0; i < num_histograms; i++ { + var pos uint = length * i / num_histograms + if i != 0 { + pos += uint(MyRand(&seed) % uint32(block_length)) + } + + if pos+stride >= length { + pos = length - stride - 1 + } + + HistogramAddVectorCommand(&histograms[i], data[pos:], stride) + } +} + +func RandomSampleCommand(seed *uint32, data []uint16, length uint, stride uint, sample *HistogramCommand) { + var pos uint = 0 + if stride >= length { + stride = length + } else { + pos = uint(MyRand(seed) % uint32(length-stride+1)) + } + + HistogramAddVectorCommand(sample, data[pos:], stride) +} + +func RefineEntropyCodesCommand(data []uint16, length uint, stride uint, num_histograms uint, histograms []HistogramCommand) { + var iters uint = kIterMulForRefining*length/stride + kMinItersForRefining + var seed uint32 = 7 + var iter uint + iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms + for iter = 0; iter < iters; iter++ { + var sample HistogramCommand + HistogramClearCommand(&sample) + RandomSampleCommand(&seed, data, length, stride, &sample) + HistogramAddHistogramCommand(&histograms[iter%num_histograms], &sample) + } +} + +/* Assigns a block id from the range [0, num_histograms) to each data element + in data[0..length) and fills in block_id[0..length) with the assigned values. + Returns the number of blocks, i.e. one plus the number of block switches. */ +func FindBlocksCommand(data []uint16, length uint, block_switch_bitcost float64, num_histograms uint, histograms []HistogramCommand, insert_cost []float64, cost []float64, switch_signal []byte, block_id []byte) uint { + var data_size uint = HistogramDataSizeCommand() + var bitmaplen uint = (num_histograms + 7) >> 3 + var num_blocks uint = 1 + var i uint + var j uint + assert(num_histograms <= 256) + if num_histograms <= 1 { + for i = 0; i < length; i++ { + block_id[i] = 0 + } + + return 1 + } + + for i := 0; i < int(data_size*num_histograms); i++ { + insert_cost[i] = 0 + } + for i = 0; i < num_histograms; i++ { + insert_cost[i] = FastLog2(uint(uint32(histograms[i].total_count_))) + } + + for i = data_size; i != 0; { + i-- + for j = 0; j < num_histograms; j++ { + insert_cost[i*num_histograms+j] = insert_cost[j] - BitCost(uint(histograms[j].data_[i])) + } + } + + for i := 0; i < int(num_histograms); i++ { + cost[i] = 0 + } + for i := 0; i < int(length*bitmaplen); i++ { + switch_signal[i] = 0 + } + + /* After each iteration of this loop, cost[k] will contain the difference + between the minimum cost of arriving at the current byte position using + entropy code k, and the minimum cost of arriving at the current byte + position. This difference is capped at the block switch cost, and if it + reaches block switch cost, it means that when we trace back from the last + position, we need to switch here. */ + for i = 0; i < length; i++ { + var byte_ix uint = i + var ix uint = byte_ix * bitmaplen + var insert_cost_ix uint = uint(data[byte_ix]) * num_histograms + var min_cost float64 = 1e99 + var block_switch_cost float64 = block_switch_bitcost + var k uint + for k = 0; k < num_histograms; k++ { + /* We are coding the symbol in data[byte_ix] with entropy code k. */ + cost[k] += insert_cost[insert_cost_ix+k] + + if cost[k] < min_cost { + min_cost = cost[k] + block_id[byte_ix] = byte(k) + } + } + + /* More blocks for the beginning. */ + if byte_ix < 2000 { + block_switch_cost *= 0.77 + 0.07*float64(byte_ix)/2000 + } + + for k = 0; k < num_histograms; k++ { + cost[k] -= min_cost + if cost[k] >= block_switch_cost { + var mask byte = byte(1 << (k & 7)) + cost[k] = block_switch_cost + assert(k>>3 < bitmaplen) + switch_signal[ix+(k>>3)] |= mask + /* Trace back from the last position and switch at the marked places. */ + } + } + } + { + var byte_ix uint = length - 1 + var ix uint = byte_ix * bitmaplen + var cur_id byte = block_id[byte_ix] + for byte_ix > 0 { + var mask byte = byte(1 << (cur_id & 7)) + assert(uint(cur_id)>>3 < bitmaplen) + byte_ix-- + ix -= bitmaplen + if switch_signal[ix+uint(cur_id>>3)]&mask != 0 { + if cur_id != block_id[byte_ix] { + cur_id = block_id[byte_ix] + num_blocks++ + } + } + + block_id[byte_ix] = cur_id + } + } + + return num_blocks +} + +var RemapBlockIdsCommand_kInvalidId uint16 = 256 + +func RemapBlockIdsCommand(block_ids []byte, length uint, new_id []uint16, num_histograms uint) uint { + var next_id uint16 = 0 + var i uint + for i = 0; i < num_histograms; i++ { + new_id[i] = RemapBlockIdsCommand_kInvalidId + } + + for i = 0; i < length; i++ { + assert(uint(block_ids[i]) < num_histograms) + if new_id[block_ids[i]] == RemapBlockIdsCommand_kInvalidId { + new_id[block_ids[i]] = next_id + next_id++ + } + } + + for i = 0; i < length; i++ { + block_ids[i] = byte(new_id[block_ids[i]]) + assert(uint(block_ids[i]) < num_histograms) + } + + assert(uint(next_id) <= num_histograms) + return uint(next_id) +} + +func BuildBlockHistogramsCommand(data []uint16, length uint, block_ids []byte, num_histograms uint, histograms []HistogramCommand) { + var i uint + ClearHistogramsCommand(histograms, num_histograms) + for i = 0; i < length; i++ { + HistogramAddCommand(&histograms[block_ids[i]], uint(data[i])) + } +} + +var ClusterBlocksCommand_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func ClusterBlocksCommand(data []uint16, length uint, num_blocks uint, block_ids []byte, split *BlockSplit) { + var histogram_symbols []uint32 = make([]uint32, num_blocks) + var block_lengths []uint32 = make([]uint32, num_blocks) + var expected_num_clusters uint = CLUSTERS_PER_BATCH * (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH + var all_histograms_size uint = 0 + var all_histograms_capacity uint = expected_num_clusters + var all_histograms []HistogramCommand = make([]HistogramCommand, all_histograms_capacity) + var cluster_size_size uint = 0 + var cluster_size_capacity uint = expected_num_clusters + var cluster_size []uint32 = make([]uint32, cluster_size_capacity) + var num_clusters uint = 0 + var histograms []HistogramCommand = make([]HistogramCommand, brotli_min_size_t(num_blocks, HISTOGRAMS_PER_BATCH)) + var max_num_pairs uint = HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2 + var pairs_capacity uint = max_num_pairs + 1 + var pairs []HistogramPair = make([]HistogramPair, pairs_capacity) + var pos uint = 0 + var clusters []uint32 + var num_final_clusters uint + var new_index []uint32 + var i uint + var sizes = [HISTOGRAMS_PER_BATCH]uint32{0} + var new_clusters = [HISTOGRAMS_PER_BATCH]uint32{0} + var symbols = [HISTOGRAMS_PER_BATCH]uint32{0} + var remap = [HISTOGRAMS_PER_BATCH]uint32{0} + + for i := 0; i < int(num_blocks); i++ { + block_lengths[i] = 0 + } + { + var block_idx uint = 0 + for i = 0; i < length; i++ { + assert(block_idx < num_blocks) + block_lengths[block_idx]++ + if i+1 == length || block_ids[i] != block_ids[i+1] { + block_idx++ + } + } + + assert(block_idx == num_blocks) + } + + for i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH { + var num_to_combine uint = brotli_min_size_t(num_blocks-i, HISTOGRAMS_PER_BATCH) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + var k uint + HistogramClearCommand(&histograms[j]) + for k = 0; uint32(k) < block_lengths[i+j]; k++ { + HistogramAddCommand(&histograms[j], uint(data[pos])) + pos++ + } + + histograms[j].bit_cost_ = BrotliPopulationCostCommand(&histograms[j]) + new_clusters[j] = uint32(j) + symbols[j] = uint32(j) + sizes[j] = 1 + } + + num_new_clusters = BrotliHistogramCombineCommand(histograms, sizes[:], symbols[:], new_clusters[:], []HistogramPair(pairs), num_to_combine, num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs) + if all_histograms_capacity < (all_histograms_size + num_new_clusters) { + var _new_size uint + if all_histograms_capacity == 0 { + _new_size = all_histograms_size + num_new_clusters + } else { + _new_size = all_histograms_capacity + } + var new_array []HistogramCommand + for _new_size < (all_histograms_size + num_new_clusters) { + _new_size *= 2 + } + new_array = make([]HistogramCommand, _new_size) + if all_histograms_capacity != 0 { + copy(new_array, all_histograms[:all_histograms_capacity]) + } + + all_histograms = new_array + all_histograms_capacity = _new_size + } + + brotli_ensure_capacity_uint32_t(&cluster_size, &cluster_size_capacity, cluster_size_size+num_new_clusters) + for j = 0; j < num_new_clusters; j++ { + all_histograms[all_histograms_size] = histograms[new_clusters[j]] + all_histograms_size++ + cluster_size[cluster_size_size] = sizes[new_clusters[j]] + cluster_size_size++ + remap[new_clusters[j]] = uint32(j) + } + + for j = 0; j < num_to_combine; j++ { + histogram_symbols[i+j] = uint32(num_clusters) + remap[symbols[j]] + } + + num_clusters += num_new_clusters + assert(num_clusters == cluster_size_size) + assert(num_clusters == all_histograms_size) + } + + histograms = nil + + max_num_pairs = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < max_num_pairs+1 { + pairs = nil + pairs = make([]HistogramPair, (max_num_pairs + 1)) + } + + clusters = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + clusters[i] = uint32(i) + } + + num_final_clusters = BrotliHistogramCombineCommand(all_histograms, cluster_size, histogram_symbols, clusters, pairs, num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES, max_num_pairs) + pairs = nil + cluster_size = nil + + new_index = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + new_index[i] = ClusterBlocksCommand_kInvalidIndex + } + pos = 0 + { + var next_index uint32 = 0 + for i = 0; i < num_blocks; i++ { + var histo HistogramCommand + var j uint + var best_out uint32 + var best_bits float64 + HistogramClearCommand(&histo) + for j = 0; uint32(j) < block_lengths[i]; j++ { + HistogramAddCommand(&histo, uint(data[pos])) + pos++ + } + + if i == 0 { + best_out = histogram_symbols[0] + } else { + best_out = histogram_symbols[i-1] + } + best_bits = BrotliHistogramBitCostDistanceCommand(&histo, &all_histograms[best_out]) + for j = 0; j < num_final_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceCommand(&histo, &all_histograms[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + histogram_symbols[i] = best_out + if new_index[best_out] == ClusterBlocksCommand_kInvalidIndex { + new_index[best_out] = next_index + next_index++ + } + } + } + + clusters = nil + all_histograms = nil + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, num_blocks) + { + var cur_length uint32 = 0 + var block_idx uint = 0 + var max_type byte = 0 + for i = 0; i < num_blocks; i++ { + cur_length += block_lengths[i] + if i+1 == num_blocks || histogram_symbols[i] != histogram_symbols[i+1] { + var id byte = byte(new_index[histogram_symbols[i]]) + split.types[block_idx] = id + split.lengths[block_idx] = cur_length + max_type = brotli_max_uint8_t(max_type, id) + cur_length = 0 + block_idx++ + } + } + + split.num_blocks = block_idx + split.num_types = uint(max_type) + 1 + } + + new_index = nil + block_lengths = nil + histogram_symbols = nil +} + +func SplitByteVectorCommand(data []uint16, length uint, literals_per_histogram uint, max_histograms uint, sampling_stride_length uint, block_switch_cost float64, params *BrotliEncoderParams, split *BlockSplit) { + var data_size uint = HistogramDataSizeCommand() + var num_histograms uint = length/literals_per_histogram + 1 + var histograms []HistogramCommand + if num_histograms > max_histograms { + num_histograms = max_histograms + } + + if length == 0 { + split.num_types = 1 + return + } else if length < kMinLengthForBlockSplitting { + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, split.num_blocks+1) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, split.num_blocks+1) + split.num_types = 1 + split.types[split.num_blocks] = 0 + split.lengths[split.num_blocks] = uint32(length) + split.num_blocks++ + return + } + + histograms = make([]HistogramCommand, num_histograms) + + /* Find good entropy codes. */ + InitialEntropyCodesCommand(data, length, sampling_stride_length, num_histograms, histograms) + + RefineEntropyCodesCommand(data, length, sampling_stride_length, num_histograms, histograms) + { + var block_ids []byte = make([]byte, length) + var num_blocks uint = 0 + var bitmaplen uint = (num_histograms + 7) >> 3 + var insert_cost []float64 = make([]float64, (data_size * num_histograms)) + var cost []float64 = make([]float64, num_histograms) + var switch_signal []byte = make([]byte, (length * bitmaplen)) + var new_id []uint16 = make([]uint16, num_histograms) + var iters uint + if params.quality < HQ_ZOPFLIFICATION_QUALITY { + iters = 3 + } else { + iters = 10 + } + /* Find a good path through literals with the good entropy codes. */ + + var i uint + for i = 0; i < iters; i++ { + num_blocks = FindBlocksCommand(data, length, block_switch_cost, num_histograms, histograms, insert_cost, cost, switch_signal, block_ids) + num_histograms = RemapBlockIdsCommand(block_ids, length, new_id, num_histograms) + BuildBlockHistogramsCommand(data, length, block_ids, num_histograms, histograms) + } + + insert_cost = nil + cost = nil + switch_signal = nil + new_id = nil + histograms = nil + ClusterBlocksCommand(data, length, num_blocks, block_ids, split) + block_ids = nil + } +} diff --git a/block_splitter_distance.go b/block_splitter_distance.go new file mode 100644 index 0000000..a7c51b3 --- /dev/null +++ b/block_splitter_distance.go @@ -0,0 +1,431 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func InitialEntropyCodesDistance(data []uint16, length uint, stride uint, num_histograms uint, histograms []HistogramDistance) { + var seed uint32 = 7 + var block_length uint = length / num_histograms + var i uint + ClearHistogramsDistance(histograms, num_histograms) + for i = 0; i < num_histograms; i++ { + var pos uint = length * i / num_histograms + if i != 0 { + pos += uint(MyRand(&seed) % uint32(block_length)) + } + + if pos+stride >= length { + pos = length - stride - 1 + } + + HistogramAddVectorDistance(&histograms[i], data[pos:], stride) + } +} + +func RandomSampleDistance(seed *uint32, data []uint16, length uint, stride uint, sample *HistogramDistance) { + var pos uint = 0 + if stride >= length { + stride = length + } else { + pos = uint(MyRand(seed) % uint32(length-stride+1)) + } + + HistogramAddVectorDistance(sample, data[pos:], stride) +} + +func RefineEntropyCodesDistance(data []uint16, length uint, stride uint, num_histograms uint, histograms []HistogramDistance) { + var iters uint = kIterMulForRefining*length/stride + kMinItersForRefining + var seed uint32 = 7 + var iter uint + iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms + for iter = 0; iter < iters; iter++ { + var sample HistogramDistance + HistogramClearDistance(&sample) + RandomSampleDistance(&seed, data, length, stride, &sample) + HistogramAddHistogramDistance(&histograms[iter%num_histograms], &sample) + } +} + +/* Assigns a block id from the range [0, num_histograms) to each data element + in data[0..length) and fills in block_id[0..length) with the assigned values. + Returns the number of blocks, i.e. one plus the number of block switches. */ +func FindBlocksDistance(data []uint16, length uint, block_switch_bitcost float64, num_histograms uint, histograms []HistogramDistance, insert_cost []float64, cost []float64, switch_signal []byte, block_id []byte) uint { + var data_size uint = HistogramDataSizeDistance() + var bitmaplen uint = (num_histograms + 7) >> 3 + var num_blocks uint = 1 + var i uint + var j uint + assert(num_histograms <= 256) + if num_histograms <= 1 { + for i = 0; i < length; i++ { + block_id[i] = 0 + } + + return 1 + } + + for i := 0; i < int(data_size*num_histograms); i++ { + insert_cost[i] = 0 + } + for i = 0; i < num_histograms; i++ { + insert_cost[i] = FastLog2(uint(uint32(histograms[i].total_count_))) + } + + for i = data_size; i != 0; { + i-- + for j = 0; j < num_histograms; j++ { + insert_cost[i*num_histograms+j] = insert_cost[j] - BitCost(uint(histograms[j].data_[i])) + } + } + + for i := 0; i < int(num_histograms); i++ { + cost[i] = 0 + } + for i := 0; i < int(length*bitmaplen); i++ { + switch_signal[i] = 0 + } + + /* After each iteration of this loop, cost[k] will contain the difference + between the minimum cost of arriving at the current byte position using + entropy code k, and the minimum cost of arriving at the current byte + position. This difference is capped at the block switch cost, and if it + reaches block switch cost, it means that when we trace back from the last + position, we need to switch here. */ + for i = 0; i < length; i++ { + var byte_ix uint = i + var ix uint = byte_ix * bitmaplen + var insert_cost_ix uint = uint(data[byte_ix]) * num_histograms + var min_cost float64 = 1e99 + var block_switch_cost float64 = block_switch_bitcost + var k uint + for k = 0; k < num_histograms; k++ { + /* We are coding the symbol in data[byte_ix] with entropy code k. */ + cost[k] += insert_cost[insert_cost_ix+k] + + if cost[k] < min_cost { + min_cost = cost[k] + block_id[byte_ix] = byte(k) + } + } + + /* More blocks for the beginning. */ + if byte_ix < 2000 { + block_switch_cost *= 0.77 + 0.07*float64(byte_ix)/2000 + } + + for k = 0; k < num_histograms; k++ { + cost[k] -= min_cost + if cost[k] >= block_switch_cost { + var mask byte = byte(1 << (k & 7)) + cost[k] = block_switch_cost + assert(k>>3 < bitmaplen) + switch_signal[ix+(k>>3)] |= mask + /* Trace back from the last position and switch at the marked places. */ + } + } + } + { + var byte_ix uint = length - 1 + var ix uint = byte_ix * bitmaplen + var cur_id byte = block_id[byte_ix] + for byte_ix > 0 { + var mask byte = byte(1 << (cur_id & 7)) + assert(uint(cur_id)>>3 < bitmaplen) + byte_ix-- + ix -= bitmaplen + if switch_signal[ix+uint(cur_id>>3)]&mask != 0 { + if cur_id != block_id[byte_ix] { + cur_id = block_id[byte_ix] + num_blocks++ + } + } + + block_id[byte_ix] = cur_id + } + } + + return num_blocks +} + +var RemapBlockIdsDistance_kInvalidId uint16 = 256 + +func RemapBlockIdsDistance(block_ids []byte, length uint, new_id []uint16, num_histograms uint) uint { + var next_id uint16 = 0 + var i uint + for i = 0; i < num_histograms; i++ { + new_id[i] = RemapBlockIdsDistance_kInvalidId + } + + for i = 0; i < length; i++ { + assert(uint(block_ids[i]) < num_histograms) + if new_id[block_ids[i]] == RemapBlockIdsDistance_kInvalidId { + new_id[block_ids[i]] = next_id + next_id++ + } + } + + for i = 0; i < length; i++ { + block_ids[i] = byte(new_id[block_ids[i]]) + assert(uint(block_ids[i]) < num_histograms) + } + + assert(uint(next_id) <= num_histograms) + return uint(next_id) +} + +func BuildBlockHistogramsDistance(data []uint16, length uint, block_ids []byte, num_histograms uint, histograms []HistogramDistance) { + var i uint + ClearHistogramsDistance(histograms, num_histograms) + for i = 0; i < length; i++ { + HistogramAddDistance(&histograms[block_ids[i]], uint(data[i])) + } +} + +var ClusterBlocksDistance_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func ClusterBlocksDistance(data []uint16, length uint, num_blocks uint, block_ids []byte, split *BlockSplit) { + var histogram_symbols []uint32 = make([]uint32, num_blocks) + var block_lengths []uint32 = make([]uint32, num_blocks) + var expected_num_clusters uint = CLUSTERS_PER_BATCH * (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH + var all_histograms_size uint = 0 + var all_histograms_capacity uint = expected_num_clusters + var all_histograms []HistogramDistance = make([]HistogramDistance, all_histograms_capacity) + var cluster_size_size uint = 0 + var cluster_size_capacity uint = expected_num_clusters + var cluster_size []uint32 = make([]uint32, cluster_size_capacity) + var num_clusters uint = 0 + var histograms []HistogramDistance = make([]HistogramDistance, brotli_min_size_t(num_blocks, HISTOGRAMS_PER_BATCH)) + var max_num_pairs uint = HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2 + var pairs_capacity uint = max_num_pairs + 1 + var pairs []HistogramPair = make([]HistogramPair, pairs_capacity) + var pos uint = 0 + var clusters []uint32 + var num_final_clusters uint + var new_index []uint32 + var i uint + var sizes = [HISTOGRAMS_PER_BATCH]uint32{0} + var new_clusters = [HISTOGRAMS_PER_BATCH]uint32{0} + var symbols = [HISTOGRAMS_PER_BATCH]uint32{0} + var remap = [HISTOGRAMS_PER_BATCH]uint32{0} + + for i := 0; i < int(num_blocks); i++ { + block_lengths[i] = 0 + } + { + var block_idx uint = 0 + for i = 0; i < length; i++ { + assert(block_idx < num_blocks) + block_lengths[block_idx]++ + if i+1 == length || block_ids[i] != block_ids[i+1] { + block_idx++ + } + } + + assert(block_idx == num_blocks) + } + + for i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH { + var num_to_combine uint = brotli_min_size_t(num_blocks-i, HISTOGRAMS_PER_BATCH) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + var k uint + HistogramClearDistance(&histograms[j]) + for k = 0; uint32(k) < block_lengths[i+j]; k++ { + HistogramAddDistance(&histograms[j], uint(data[pos])) + pos++ + } + + histograms[j].bit_cost_ = BrotliPopulationCostDistance(&histograms[j]) + new_clusters[j] = uint32(j) + symbols[j] = uint32(j) + sizes[j] = 1 + } + + num_new_clusters = BrotliHistogramCombineDistance(histograms, sizes[:], symbols[:], new_clusters[:], []HistogramPair(pairs), num_to_combine, num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs) + if all_histograms_capacity < (all_histograms_size + num_new_clusters) { + var _new_size uint + if all_histograms_capacity == 0 { + _new_size = all_histograms_size + num_new_clusters + } else { + _new_size = all_histograms_capacity + } + var new_array []HistogramDistance + for _new_size < (all_histograms_size + num_new_clusters) { + _new_size *= 2 + } + new_array = make([]HistogramDistance, _new_size) + if all_histograms_capacity != 0 { + copy(new_array, all_histograms[:all_histograms_capacity]) + } + + all_histograms = new_array + all_histograms_capacity = _new_size + } + + brotli_ensure_capacity_uint32_t(&cluster_size, &cluster_size_capacity, cluster_size_size+num_new_clusters) + for j = 0; j < num_new_clusters; j++ { + all_histograms[all_histograms_size] = histograms[new_clusters[j]] + all_histograms_size++ + cluster_size[cluster_size_size] = sizes[new_clusters[j]] + cluster_size_size++ + remap[new_clusters[j]] = uint32(j) + } + + for j = 0; j < num_to_combine; j++ { + histogram_symbols[i+j] = uint32(num_clusters) + remap[symbols[j]] + } + + num_clusters += num_new_clusters + assert(num_clusters == cluster_size_size) + assert(num_clusters == all_histograms_size) + } + + histograms = nil + + max_num_pairs = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < max_num_pairs+1 { + pairs = nil + pairs = make([]HistogramPair, (max_num_pairs + 1)) + } + + clusters = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + clusters[i] = uint32(i) + } + + num_final_clusters = BrotliHistogramCombineDistance(all_histograms, cluster_size, histogram_symbols, clusters, pairs, num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES, max_num_pairs) + pairs = nil + cluster_size = nil + + new_index = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + new_index[i] = ClusterBlocksDistance_kInvalidIndex + } + pos = 0 + { + var next_index uint32 = 0 + for i = 0; i < num_blocks; i++ { + var histo HistogramDistance + var j uint + var best_out uint32 + var best_bits float64 + HistogramClearDistance(&histo) + for j = 0; uint32(j) < block_lengths[i]; j++ { + HistogramAddDistance(&histo, uint(data[pos])) + pos++ + } + + if i == 0 { + best_out = histogram_symbols[0] + } else { + best_out = histogram_symbols[i-1] + } + best_bits = BrotliHistogramBitCostDistanceDistance(&histo, &all_histograms[best_out]) + for j = 0; j < num_final_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceDistance(&histo, &all_histograms[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + histogram_symbols[i] = best_out + if new_index[best_out] == ClusterBlocksDistance_kInvalidIndex { + new_index[best_out] = next_index + next_index++ + } + } + } + + clusters = nil + all_histograms = nil + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, num_blocks) + { + var cur_length uint32 = 0 + var block_idx uint = 0 + var max_type byte = 0 + for i = 0; i < num_blocks; i++ { + cur_length += block_lengths[i] + if i+1 == num_blocks || histogram_symbols[i] != histogram_symbols[i+1] { + var id byte = byte(new_index[histogram_symbols[i]]) + split.types[block_idx] = id + split.lengths[block_idx] = cur_length + max_type = brotli_max_uint8_t(max_type, id) + cur_length = 0 + block_idx++ + } + } + + split.num_blocks = block_idx + split.num_types = uint(max_type) + 1 + } + + new_index = nil + block_lengths = nil + histogram_symbols = nil +} + +func SplitByteVectorDistance(data []uint16, length uint, literals_per_histogram uint, max_histograms uint, sampling_stride_length uint, block_switch_cost float64, params *BrotliEncoderParams, split *BlockSplit) { + var data_size uint = HistogramDataSizeDistance() + var num_histograms uint = length/literals_per_histogram + 1 + var histograms []HistogramDistance + if num_histograms > max_histograms { + num_histograms = max_histograms + } + + if length == 0 { + split.num_types = 1 + return + } else if length < kMinLengthForBlockSplitting { + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, split.num_blocks+1) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, split.num_blocks+1) + split.num_types = 1 + split.types[split.num_blocks] = 0 + split.lengths[split.num_blocks] = uint32(length) + split.num_blocks++ + return + } + + histograms = make([]HistogramDistance, num_histograms) + + /* Find good entropy codes. */ + InitialEntropyCodesDistance(data, length, sampling_stride_length, num_histograms, histograms) + + RefineEntropyCodesDistance(data, length, sampling_stride_length, num_histograms, histograms) + { + var block_ids []byte = make([]byte, length) + var num_blocks uint = 0 + var bitmaplen uint = (num_histograms + 7) >> 3 + var insert_cost []float64 = make([]float64, (data_size * num_histograms)) + var cost []float64 = make([]float64, num_histograms) + var switch_signal []byte = make([]byte, (length * bitmaplen)) + var new_id []uint16 = make([]uint16, num_histograms) + var iters uint + if params.quality < HQ_ZOPFLIFICATION_QUALITY { + iters = 3 + } else { + iters = 10 + } + /* Find a good path through literals with the good entropy codes. */ + + var i uint + for i = 0; i < iters; i++ { + num_blocks = FindBlocksDistance(data, length, block_switch_cost, num_histograms, histograms, insert_cost, cost, switch_signal, block_ids) + num_histograms = RemapBlockIdsDistance(block_ids, length, new_id, num_histograms) + BuildBlockHistogramsDistance(data, length, block_ids, num_histograms, histograms) + } + + insert_cost = nil + cost = nil + switch_signal = nil + new_id = nil + histograms = nil + ClusterBlocksDistance(data, length, num_blocks, block_ids, split) + block_ids = nil + } +} diff --git a/block_splitter_literal.go b/block_splitter_literal.go new file mode 100644 index 0000000..fba2d69 --- /dev/null +++ b/block_splitter_literal.go @@ -0,0 +1,431 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func InitialEntropyCodesLiteral(data []byte, length uint, stride uint, num_histograms uint, histograms []HistogramLiteral) { + var seed uint32 = 7 + var block_length uint = length / num_histograms + var i uint + ClearHistogramsLiteral(histograms, num_histograms) + for i = 0; i < num_histograms; i++ { + var pos uint = length * i / num_histograms + if i != 0 { + pos += uint(MyRand(&seed) % uint32(block_length)) + } + + if pos+stride >= length { + pos = length - stride - 1 + } + + HistogramAddVectorLiteral(&histograms[i], data[pos:], stride) + } +} + +func RandomSampleLiteral(seed *uint32, data []byte, length uint, stride uint, sample *HistogramLiteral) { + var pos uint = 0 + if stride >= length { + stride = length + } else { + pos = uint(MyRand(seed) % uint32(length-stride+1)) + } + + HistogramAddVectorLiteral(sample, data[pos:], stride) +} + +func RefineEntropyCodesLiteral(data []byte, length uint, stride uint, num_histograms uint, histograms []HistogramLiteral) { + var iters uint = kIterMulForRefining*length/stride + kMinItersForRefining + var seed uint32 = 7 + var iter uint + iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms + for iter = 0; iter < iters; iter++ { + var sample HistogramLiteral + HistogramClearLiteral(&sample) + RandomSampleLiteral(&seed, data, length, stride, &sample) + HistogramAddHistogramLiteral(&histograms[iter%num_histograms], &sample) + } +} + +/* Assigns a block id from the range [0, num_histograms) to each data element + in data[0..length) and fills in block_id[0..length) with the assigned values. + Returns the number of blocks, i.e. one plus the number of block switches. */ +func FindBlocksLiteral(data []byte, length uint, block_switch_bitcost float64, num_histograms uint, histograms []HistogramLiteral, insert_cost []float64, cost []float64, switch_signal []byte, block_id []byte) uint { + var data_size uint = HistogramDataSizeLiteral() + var bitmaplen uint = (num_histograms + 7) >> 3 + var num_blocks uint = 1 + var i uint + var j uint + assert(num_histograms <= 256) + if num_histograms <= 1 { + for i = 0; i < length; i++ { + block_id[i] = 0 + } + + return 1 + } + + for i := 0; i < int(data_size*num_histograms); i++ { + insert_cost[i] = 0 + } + for i = 0; i < num_histograms; i++ { + insert_cost[i] = FastLog2(uint(uint32(histograms[i].total_count_))) + } + + for i = data_size; i != 0; { + i-- + for j = 0; j < num_histograms; j++ { + insert_cost[i*num_histograms+j] = insert_cost[j] - BitCost(uint(histograms[j].data_[i])) + } + } + + for i := 0; i < int(num_histograms); i++ { + cost[i] = 0 + } + for i := 0; i < int(length*bitmaplen); i++ { + switch_signal[i] = 0 + } + + /* After each iteration of this loop, cost[k] will contain the difference + between the minimum cost of arriving at the current byte position using + entropy code k, and the minimum cost of arriving at the current byte + position. This difference is capped at the block switch cost, and if it + reaches block switch cost, it means that when we trace back from the last + position, we need to switch here. */ + for i = 0; i < length; i++ { + var byte_ix uint = i + var ix uint = byte_ix * bitmaplen + var insert_cost_ix uint = uint(data[byte_ix]) * num_histograms + var min_cost float64 = 1e99 + var block_switch_cost float64 = block_switch_bitcost + var k uint + for k = 0; k < num_histograms; k++ { + /* We are coding the symbol in data[byte_ix] with entropy code k. */ + cost[k] += insert_cost[insert_cost_ix+k] + + if cost[k] < min_cost { + min_cost = cost[k] + block_id[byte_ix] = byte(k) + } + } + + /* More blocks for the beginning. */ + if byte_ix < 2000 { + block_switch_cost *= 0.77 + 0.07*float64(byte_ix)/2000 + } + + for k = 0; k < num_histograms; k++ { + cost[k] -= min_cost + if cost[k] >= block_switch_cost { + var mask byte = byte(1 << (k & 7)) + cost[k] = block_switch_cost + assert(k>>3 < bitmaplen) + switch_signal[ix+(k>>3)] |= mask + /* Trace back from the last position and switch at the marked places. */ + } + } + } + { + var byte_ix uint = length - 1 + var ix uint = byte_ix * bitmaplen + var cur_id byte = block_id[byte_ix] + for byte_ix > 0 { + var mask byte = byte(1 << (cur_id & 7)) + assert(uint(cur_id)>>3 < bitmaplen) + byte_ix-- + ix -= bitmaplen + if switch_signal[ix+uint(cur_id>>3)]&mask != 0 { + if cur_id != block_id[byte_ix] { + cur_id = block_id[byte_ix] + num_blocks++ + } + } + + block_id[byte_ix] = cur_id + } + } + + return num_blocks +} + +var RemapBlockIdsLiteral_kInvalidId uint16 = 256 + +func RemapBlockIdsLiteral(block_ids []byte, length uint, new_id []uint16, num_histograms uint) uint { + var next_id uint16 = 0 + var i uint + for i = 0; i < num_histograms; i++ { + new_id[i] = RemapBlockIdsLiteral_kInvalidId + } + + for i = 0; i < length; i++ { + assert(uint(block_ids[i]) < num_histograms) + if new_id[block_ids[i]] == RemapBlockIdsLiteral_kInvalidId { + new_id[block_ids[i]] = next_id + next_id++ + } + } + + for i = 0; i < length; i++ { + block_ids[i] = byte(new_id[block_ids[i]]) + assert(uint(block_ids[i]) < num_histograms) + } + + assert(uint(next_id) <= num_histograms) + return uint(next_id) +} + +func BuildBlockHistogramsLiteral(data []byte, length uint, block_ids []byte, num_histograms uint, histograms []HistogramLiteral) { + var i uint + ClearHistogramsLiteral(histograms, num_histograms) + for i = 0; i < length; i++ { + HistogramAddLiteral(&histograms[block_ids[i]], uint(data[i])) + } +} + +var ClusterBlocksLiteral_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func ClusterBlocksLiteral(data []byte, length uint, num_blocks uint, block_ids []byte, split *BlockSplit) { + var histogram_symbols []uint32 = make([]uint32, num_blocks) + var block_lengths []uint32 = make([]uint32, num_blocks) + var expected_num_clusters uint = CLUSTERS_PER_BATCH * (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH + var all_histograms_size uint = 0 + var all_histograms_capacity uint = expected_num_clusters + var all_histograms []HistogramLiteral = make([]HistogramLiteral, all_histograms_capacity) + var cluster_size_size uint = 0 + var cluster_size_capacity uint = expected_num_clusters + var cluster_size []uint32 = make([]uint32, cluster_size_capacity) + var num_clusters uint = 0 + var histograms []HistogramLiteral = make([]HistogramLiteral, brotli_min_size_t(num_blocks, HISTOGRAMS_PER_BATCH)) + var max_num_pairs uint = HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2 + var pairs_capacity uint = max_num_pairs + 1 + var pairs []HistogramPair = make([]HistogramPair, pairs_capacity) + var pos uint = 0 + var clusters []uint32 + var num_final_clusters uint + var new_index []uint32 + var i uint + var sizes = [HISTOGRAMS_PER_BATCH]uint32{0} + var new_clusters = [HISTOGRAMS_PER_BATCH]uint32{0} + var symbols = [HISTOGRAMS_PER_BATCH]uint32{0} + var remap = [HISTOGRAMS_PER_BATCH]uint32{0} + + for i := 0; i < int(num_blocks); i++ { + block_lengths[i] = 0 + } + { + var block_idx uint = 0 + for i = 0; i < length; i++ { + assert(block_idx < num_blocks) + block_lengths[block_idx]++ + if i+1 == length || block_ids[i] != block_ids[i+1] { + block_idx++ + } + } + + assert(block_idx == num_blocks) + } + + for i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH { + var num_to_combine uint = brotli_min_size_t(num_blocks-i, HISTOGRAMS_PER_BATCH) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + var k uint + HistogramClearLiteral(&histograms[j]) + for k = 0; uint32(k) < block_lengths[i+j]; k++ { + HistogramAddLiteral(&histograms[j], uint(data[pos])) + pos++ + } + + histograms[j].bit_cost_ = BrotliPopulationCostLiteral(&histograms[j]) + new_clusters[j] = uint32(j) + symbols[j] = uint32(j) + sizes[j] = 1 + } + + num_new_clusters = BrotliHistogramCombineLiteral(histograms, sizes[:], symbols[:], new_clusters[:], []HistogramPair(pairs), num_to_combine, num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs) + if all_histograms_capacity < (all_histograms_size + num_new_clusters) { + var _new_size uint + if all_histograms_capacity == 0 { + _new_size = all_histograms_size + num_new_clusters + } else { + _new_size = all_histograms_capacity + } + var new_array []HistogramLiteral + for _new_size < (all_histograms_size + num_new_clusters) { + _new_size *= 2 + } + new_array = make([]HistogramLiteral, _new_size) + if all_histograms_capacity != 0 { + copy(new_array, all_histograms[:all_histograms_capacity]) + } + + all_histograms = new_array + all_histograms_capacity = _new_size + } + + brotli_ensure_capacity_uint32_t(&cluster_size, &cluster_size_capacity, cluster_size_size+num_new_clusters) + for j = 0; j < num_new_clusters; j++ { + all_histograms[all_histograms_size] = histograms[new_clusters[j]] + all_histograms_size++ + cluster_size[cluster_size_size] = sizes[new_clusters[j]] + cluster_size_size++ + remap[new_clusters[j]] = uint32(j) + } + + for j = 0; j < num_to_combine; j++ { + histogram_symbols[i+j] = uint32(num_clusters) + remap[symbols[j]] + } + + num_clusters += num_new_clusters + assert(num_clusters == cluster_size_size) + assert(num_clusters == all_histograms_size) + } + + histograms = nil + + max_num_pairs = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < max_num_pairs+1 { + pairs = nil + pairs = make([]HistogramPair, (max_num_pairs + 1)) + } + + clusters = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + clusters[i] = uint32(i) + } + + num_final_clusters = BrotliHistogramCombineLiteral(all_histograms, cluster_size, histogram_symbols, clusters, pairs, num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES, max_num_pairs) + pairs = nil + cluster_size = nil + + new_index = make([]uint32, num_clusters) + for i = 0; i < num_clusters; i++ { + new_index[i] = ClusterBlocksLiteral_kInvalidIndex + } + pos = 0 + { + var next_index uint32 = 0 + for i = 0; i < num_blocks; i++ { + var histo HistogramLiteral + var j uint + var best_out uint32 + var best_bits float64 + HistogramClearLiteral(&histo) + for j = 0; uint32(j) < block_lengths[i]; j++ { + HistogramAddLiteral(&histo, uint(data[pos])) + pos++ + } + + if i == 0 { + best_out = histogram_symbols[0] + } else { + best_out = histogram_symbols[i-1] + } + best_bits = BrotliHistogramBitCostDistanceLiteral(&histo, &all_histograms[best_out]) + for j = 0; j < num_final_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceLiteral(&histo, &all_histograms[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + histogram_symbols[i] = best_out + if new_index[best_out] == ClusterBlocksLiteral_kInvalidIndex { + new_index[best_out] = next_index + next_index++ + } + } + } + + clusters = nil + all_histograms = nil + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, num_blocks) + { + var cur_length uint32 = 0 + var block_idx uint = 0 + var max_type byte = 0 + for i = 0; i < num_blocks; i++ { + cur_length += block_lengths[i] + if i+1 == num_blocks || histogram_symbols[i] != histogram_symbols[i+1] { + var id byte = byte(new_index[histogram_symbols[i]]) + split.types[block_idx] = id + split.lengths[block_idx] = cur_length + max_type = brotli_max_uint8_t(max_type, id) + cur_length = 0 + block_idx++ + } + } + + split.num_blocks = block_idx + split.num_types = uint(max_type) + 1 + } + + new_index = nil + block_lengths = nil + histogram_symbols = nil +} + +func SplitByteVectorLiteral(data []byte, length uint, literals_per_histogram uint, max_histograms uint, sampling_stride_length uint, block_switch_cost float64, params *BrotliEncoderParams, split *BlockSplit) { + var data_size uint = HistogramDataSizeLiteral() + var num_histograms uint = length/literals_per_histogram + 1 + var histograms []HistogramLiteral + if num_histograms > max_histograms { + num_histograms = max_histograms + } + + if length == 0 { + split.num_types = 1 + return + } else if length < kMinLengthForBlockSplitting { + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, split.num_blocks+1) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, split.num_blocks+1) + split.num_types = 1 + split.types[split.num_blocks] = 0 + split.lengths[split.num_blocks] = uint32(length) + split.num_blocks++ + return + } + + histograms = make([]HistogramLiteral, num_histograms) + + /* Find good entropy codes. */ + InitialEntropyCodesLiteral(data, length, sampling_stride_length, num_histograms, histograms) + + RefineEntropyCodesLiteral(data, length, sampling_stride_length, num_histograms, histograms) + { + var block_ids []byte = make([]byte, length) + var num_blocks uint = 0 + var bitmaplen uint = (num_histograms + 7) >> 3 + var insert_cost []float64 = make([]float64, (data_size * num_histograms)) + var cost []float64 = make([]float64, num_histograms) + var switch_signal []byte = make([]byte, (length * bitmaplen)) + var new_id []uint16 = make([]uint16, num_histograms) + var iters uint + if params.quality < HQ_ZOPFLIFICATION_QUALITY { + iters = 3 + } else { + iters = 10 + } + /* Find a good path through literals with the good entropy codes. */ + + var i uint + for i = 0; i < iters; i++ { + num_blocks = FindBlocksLiteral(data, length, block_switch_cost, num_histograms, histograms, insert_cost, cost, switch_signal, block_ids) + num_histograms = RemapBlockIdsLiteral(block_ids, length, new_id, num_histograms) + BuildBlockHistogramsLiteral(data, length, block_ids, num_histograms, histograms) + } + + insert_cost = nil + cost = nil + switch_signal = nil + new_id = nil + histograms = nil + ClusterBlocksLiteral(data, length, num_blocks, block_ids, split) + block_ids = nil + } +} diff --git a/brotli_bit_stream.go b/brotli_bit_stream.go new file mode 100644 index 0000000..f6a29c2 --- /dev/null +++ b/brotli_bit_stream.go @@ -0,0 +1,1265 @@ +package brotli + +const MAX_HUFFMAN_TREE_SIZE = (2*BROTLI_NUM_COMMAND_SYMBOLS + 1) + +/* The maximum size of Huffman dictionary for distances assuming that + NPOSTFIX = 0 and NDIRECT = 0. */ +const MAX_SIMPLE_DISTANCE_ALPHABET_SIZE = 140 + +/* MAX_SIMPLE_DISTANCE_ALPHABET_SIZE == 140 */ + +/* Represents the range of values belonging to a prefix code: + [offset, offset + 2^nbits) */ +type PrefixCodeRange struct { + offset uint32 + nbits uint32 +} + +var kBlockLengthPrefixCode = [BROTLI_NUM_BLOCK_LEN_SYMBOLS]PrefixCodeRange{ + PrefixCodeRange{1, 2}, + PrefixCodeRange{5, 2}, + PrefixCodeRange{9, 2}, + PrefixCodeRange{13, 2}, + PrefixCodeRange{17, 3}, + PrefixCodeRange{25, 3}, + PrefixCodeRange{33, 3}, + PrefixCodeRange{41, 3}, + PrefixCodeRange{49, 4}, + PrefixCodeRange{65, 4}, + PrefixCodeRange{81, 4}, + PrefixCodeRange{97, 4}, + PrefixCodeRange{113, 5}, + PrefixCodeRange{145, 5}, + PrefixCodeRange{177, 5}, + PrefixCodeRange{209, 5}, + PrefixCodeRange{241, 6}, + PrefixCodeRange{305, 6}, + PrefixCodeRange{369, 7}, + PrefixCodeRange{497, 8}, + PrefixCodeRange{753, 9}, + PrefixCodeRange{1265, 10}, + PrefixCodeRange{2289, 11}, + PrefixCodeRange{4337, 12}, + PrefixCodeRange{8433, 13}, + PrefixCodeRange{16625, 24}, +} + +func BlockLengthPrefixCode(len uint32) uint32 { + var code uint32 + if len >= 177 { + if len >= 753 { + code = 20 + } else { + code = 14 + } + } else if len >= 41 { + code = 7 + } else { + code = 0 + } + for code < (BROTLI_NUM_BLOCK_LEN_SYMBOLS-1) && len >= kBlockLengthPrefixCode[code+1].offset { + code++ + } + return code +} + +func GetBlockLengthPrefixCode(len uint32, code *uint, n_extra *uint32, extra *uint32) { + *code = uint(BlockLengthPrefixCode(uint32(len))) + *n_extra = kBlockLengthPrefixCode[*code].nbits + *extra = len - kBlockLengthPrefixCode[*code].offset +} + +type BlockTypeCodeCalculator struct { + last_type uint + second_last_type uint +} + +func InitBlockTypeCodeCalculator(self *BlockTypeCodeCalculator) { + self.last_type = 1 + self.second_last_type = 0 +} + +func NextBlockTypeCode(calculator *BlockTypeCodeCalculator, type_ byte) uint { + var type_code uint + if uint(type_) == calculator.last_type+1 { + type_code = 1 + } else if uint(type_) == calculator.second_last_type { + type_code = 0 + } else { + type_code = uint(type_) + 2 + } + calculator.second_last_type = calculator.last_type + calculator.last_type = uint(type_) + return type_code +} + +/* |nibblesbits| represents the 2 bits to encode MNIBBLES (0-3) + REQUIRES: length > 0 + REQUIRES: length <= (1 << 24) */ +func BrotliEncodeMlen(length uint, bits *uint64, numbits *uint, nibblesbits *uint64) { + var lg uint + if length == 1 { + lg = 1 + } else { + lg = uint(Log2FloorNonZero(uint(uint32(length-1)))) + 1 + } + var tmp uint + if lg < 16 { + tmp = 16 + } else { + tmp = (lg + 3) + } + var mnibbles uint = tmp / 4 + assert(length > 0) + assert(length <= 1<<24) + assert(lg <= 24) + *nibblesbits = uint64(mnibbles) - 4 + *numbits = mnibbles * 4 + *bits = uint64(length) - 1 +} + +func StoreCommandExtra(cmd *Command, storage_ix *uint, storage []byte) { + var copylen_code uint32 = CommandCopyLenCode(cmd) + var inscode uint16 = GetInsertLengthCode(uint(cmd.insert_len_)) + var copycode uint16 = GetCopyLengthCode(uint(copylen_code)) + var insnumextra uint32 = GetInsertExtra(inscode) + var insextraval uint64 = uint64(cmd.insert_len_) - uint64(GetInsertBase(inscode)) + var copyextraval uint64 = uint64(copylen_code) - uint64(GetCopyBase(copycode)) + var bits uint64 = copyextraval< 0 + REQUIRES: length <= (1 << 24) */ +func StoreCompressedMetaBlockHeader(is_final_block bool, length uint, storage_ix *uint, storage []byte) { + var lenbits uint64 + var nlenbits uint + var nibblesbits uint64 + var is_final uint64 + if is_final_block { + is_final = 1 + } else { + is_final = 0 + } + + /* Write ISLAST bit. */ + BrotliWriteBits(1, is_final, storage_ix, storage) + + /* Write ISEMPTY bit. */ + if is_final_block { + BrotliWriteBits(1, 0, storage_ix, storage) + } + + BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits) + BrotliWriteBits(2, nibblesbits, storage_ix, storage) + BrotliWriteBits(nlenbits, lenbits, storage_ix, storage) + + if !is_final_block { + /* Write ISUNCOMPRESSED bit. */ + BrotliWriteBits(1, 0, storage_ix, storage) + } +} + +/* Stores the uncompressed meta-block header. + REQUIRES: length > 0 + REQUIRES: length <= (1 << 24) */ +func BrotliStoreUncompressedMetaBlockHeader(length uint, storage_ix *uint, storage []byte) { + var lenbits uint64 + var nlenbits uint + var nibblesbits uint64 + + /* Write ISLAST bit. + Uncompressed block cannot be the last one, so set to 0. */ + BrotliWriteBits(1, 0, storage_ix, storage) + + BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits) + BrotliWriteBits(2, nibblesbits, storage_ix, storage) + BrotliWriteBits(nlenbits, lenbits, storage_ix, storage) + + /* Write ISUNCOMPRESSED bit. */ + BrotliWriteBits(1, 1, storage_ix, storage) +} + +var BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder = [BROTLI_CODE_LENGTH_CODES]byte{1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15} + +var BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kHuffmanBitLengthHuffmanCodeSymbols = [6]byte{0, 7, 3, 2, 1, 15} +var BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kHuffmanBitLengthHuffmanCodeBitLengths = [6]byte{2, 4, 3, 2, 2, 4} + +func BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(num_codes int, code_length_bitdepth []byte, storage_ix *uint, storage []byte) { + var skip_some uint = 0 + var codes_to_store uint = BROTLI_CODE_LENGTH_CODES + /* The bit lengths of the Huffman code over the code length alphabet + are compressed with the following static Huffman code: + Symbol Code + ------ ---- + 0 00 + 1 1110 + 2 110 + 3 01 + 4 10 + 5 1111 */ + + /* Throw away trailing zeros: */ + if num_codes > 1 { + for ; codes_to_store > 0; codes_to_store-- { + if code_length_bitdepth[BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder[codes_to_store-1]] != 0 { + break + } + } + } + + if code_length_bitdepth[BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder[0]] == 0 && code_length_bitdepth[BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder[1]] == 0 { + skip_some = 2 /* skips two. */ + if code_length_bitdepth[BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder[2]] == 0 { + skip_some = 3 /* skips three. */ + } + } + + BrotliWriteBits(2, uint64(skip_some), storage_ix, storage) + { + var i uint + for i = skip_some; i < codes_to_store; i++ { + var l uint = uint(code_length_bitdepth[BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kStorageOrder[i]]) + BrotliWriteBits(uint(BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kHuffmanBitLengthHuffmanCodeBitLengths[l]), uint64(BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask_kHuffmanBitLengthHuffmanCodeSymbols[l]), storage_ix, storage) + } + } +} + +func BrotliStoreHuffmanTreeToBitMask(huffman_tree_size uint, huffman_tree []byte, huffman_tree_extra_bits []byte, code_length_bitdepth []byte, code_length_bitdepth_symbols []uint16, storage_ix *uint, storage []byte) { + var i uint + for i = 0; i < huffman_tree_size; i++ { + var ix uint = uint(huffman_tree[i]) + BrotliWriteBits(uint(code_length_bitdepth[ix]), uint64(code_length_bitdepth_symbols[ix]), storage_ix, storage) + + /* Extra bits */ + switch ix { + case BROTLI_REPEAT_PREVIOUS_CODE_LENGTH: + BrotliWriteBits(2, uint64(huffman_tree_extra_bits[i]), storage_ix, storage) + + case BROTLI_REPEAT_ZERO_CODE_LENGTH: + BrotliWriteBits(3, uint64(huffman_tree_extra_bits[i]), storage_ix, storage) + } + } +} + +func StoreSimpleHuffmanTree(depths []byte, symbols []uint, num_symbols uint, max_bits uint, storage_ix *uint, storage []byte) { + /* value of 1 indicates a simple Huffman code */ + BrotliWriteBits(2, 1, storage_ix, storage) + + BrotliWriteBits(2, uint64(num_symbols)-1, storage_ix, storage) /* NSYM - 1 */ + { + /* Sort */ + var i uint + for i = 0; i < num_symbols; i++ { + var j uint + for j = i + 1; j < num_symbols; j++ { + if depths[symbols[j]] < depths[symbols[i]] { + var tmp uint = symbols[j] + symbols[j] = symbols[i] + symbols[i] = tmp + } + } + } + } + + if num_symbols == 2 { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + } else if num_symbols == 3 { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[2]), storage_ix, storage) + } else { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[2]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[3]), storage_ix, storage) + + /* tree-select */ + var tmp int + if depths[symbols[0]] == 1 { + tmp = 1 + } else { + tmp = 0 + } + BrotliWriteBits(1, uint64(tmp), storage_ix, storage) + } +} + +/* num = alphabet size + depths = symbol depths */ +func BrotliStoreHuffmanTree(depths []byte, num uint, tree []HuffmanTree, storage_ix *uint, storage []byte) { + var huffman_tree [BROTLI_NUM_COMMAND_SYMBOLS]byte + var huffman_tree_extra_bits [BROTLI_NUM_COMMAND_SYMBOLS]byte + var huffman_tree_size uint = 0 + var code_length_bitdepth = [BROTLI_CODE_LENGTH_CODES]byte{0} + var code_length_bitdepth_symbols [BROTLI_CODE_LENGTH_CODES]uint16 + var huffman_tree_histogram = [BROTLI_CODE_LENGTH_CODES]uint32{0} + var i uint + var num_codes int = 0 + /* Write the Huffman tree into the brotli-representation. + The command alphabet is the largest, so this allocation will fit all + alphabets. */ + + var code uint = 0 + + assert(num <= BROTLI_NUM_COMMAND_SYMBOLS) + + BrotliWriteHuffmanTree(depths, num, &huffman_tree_size, huffman_tree[:], huffman_tree_extra_bits[:]) + + /* Calculate the statistics of the Huffman tree in brotli-representation. */ + for i = 0; i < huffman_tree_size; i++ { + huffman_tree_histogram[huffman_tree[i]]++ + } + + for i = 0; i < BROTLI_CODE_LENGTH_CODES; i++ { + if huffman_tree_histogram[i] != 0 { + if num_codes == 0 { + code = i + num_codes = 1 + } else if num_codes == 1 { + num_codes = 2 + break + } + } + } + + /* Calculate another Huffman tree to use for compressing both the + earlier Huffman tree with. */ + BrotliCreateHuffmanTree(huffman_tree_histogram[:], BROTLI_CODE_LENGTH_CODES, 5, tree, code_length_bitdepth[:]) + + BrotliConvertBitDepthsToSymbols(code_length_bitdepth[:], BROTLI_CODE_LENGTH_CODES, code_length_bitdepth_symbols[:]) + + /* Now, we have all the data, let's start storing it */ + BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(num_codes, code_length_bitdepth[:], storage_ix, storage) + + if num_codes == 1 { + code_length_bitdepth[code] = 0 + } + + /* Store the real Huffman tree now. */ + BrotliStoreHuffmanTreeToBitMask(huffman_tree_size, huffman_tree[:], huffman_tree_extra_bits[:], code_length_bitdepth[:], code_length_bitdepth_symbols[:], storage_ix, storage) +} + +/* Builds a Huffman tree from histogram[0:length] into depth[0:length] and + bits[0:length] and stores the encoded tree to the bit stream. */ +func BuildAndStoreHuffmanTree(histogram []uint32, histogram_length uint, alphabet_size uint, tree []HuffmanTree, depth []byte, bits []uint16, storage_ix *uint, storage []byte) { + var count uint = 0 + var s4 = [4]uint{0} + var i uint + var max_bits uint = 0 + for i = 0; i < histogram_length; i++ { + if histogram[i] != 0 { + if count < 4 { + s4[count] = i + } else if count > 4 { + break + } + + count++ + } + } + { + var max_bits_counter uint = alphabet_size - 1 + for max_bits_counter != 0 { + max_bits_counter >>= 1 + max_bits++ + } + } + + if count <= 1 { + BrotliWriteBits(4, 1, storage_ix, storage) + BrotliWriteBits(max_bits, uint64(s4[0]), storage_ix, storage) + depth[s4[0]] = 0 + bits[s4[0]] = 0 + return + } + + for i := 0; i < int(histogram_length); i++ { + depth[i] = 0 + } + BrotliCreateHuffmanTree(histogram, histogram_length, 15, tree, depth) + BrotliConvertBitDepthsToSymbols(depth, histogram_length, bits) + + if count <= 4 { + StoreSimpleHuffmanTree(depth, s4[:], count, max_bits, storage_ix, storage) + } else { + BrotliStoreHuffmanTree(depth, histogram_length, tree, storage_ix, storage) + } +} + +func SortHuffmanTree1(v0 *HuffmanTree, v1 *HuffmanTree) bool { + return v0.total_count_ < v1.total_count_ +} + +func BrotliBuildAndStoreHuffmanTreeFast(histogram []uint32, histogram_total uint, max_bits uint, depth []byte, bits []uint16, storage_ix *uint, storage []byte) { + var count uint = 0 + var symbols = [4]uint{0} + var length uint = 0 + var total uint = histogram_total + for total != 0 { + if histogram[length] != 0 { + if count < 4 { + symbols[count] = length + } + + count++ + total -= uint(histogram[length]) + } + + length++ + } + + if count <= 1 { + BrotliWriteBits(4, 1, storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + depth[symbols[0]] = 0 + bits[symbols[0]] = 0 + return + } + + for i := 0; i < int(length); i++ { + depth[i] = 0 + } + { + var max_tree_size uint = 2*length + 1 + var tree []HuffmanTree = make([]HuffmanTree, max_tree_size) + var count_limit uint32 + for count_limit = 1; ; count_limit *= 2 { + var node int = 0 + var l uint + for l = length; l != 0; { + l-- + if histogram[l] != 0 { + if histogram[l] >= count_limit { + InitHuffmanTree(&tree[node:][0], histogram[l], -1, int16(l)) + } else { + InitHuffmanTree(&tree[node:][0], count_limit, -1, int16(l)) + } + + node++ + } + } + { + var n int = node + /* Points to the next leaf node. */ /* Points to the next non-leaf node. */ + var sentinel HuffmanTree + var i int = 0 + var j int = n + 1 + var k int + + SortHuffmanTreeItems(tree, uint(n), HuffmanTreeComparator(SortHuffmanTree1)) + + /* The nodes are: + [0, n): the sorted leaf nodes that we start with. + [n]: we add a sentinel here. + [n + 1, 2n): new parent nodes are added here, starting from + (n+1). These are naturally in ascending order. + [2n]: we add a sentinel at the end as well. + There will be (2n+1) elements at the end. */ + InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1) + + tree[node] = sentinel + node++ + tree[node] = sentinel + node++ + + for k = n - 1; k > 0; k-- { + var left int + var right int + if tree[i].total_count_ <= tree[j].total_count_ { + left = i + i++ + } else { + left = j + j++ + } + + if tree[i].total_count_ <= tree[j].total_count_ { + right = i + i++ + } else { + right = j + j++ + } + + /* The sentinel node becomes the parent node. */ + tree[node-1].total_count_ = tree[left].total_count_ + tree[right].total_count_ + + tree[node-1].index_left_ = int16(left) + tree[node-1].index_right_or_value_ = int16(right) + + /* Add back the last sentinel node. */ + tree[node] = sentinel + node++ + } + + if BrotliSetDepth(2*n-1, tree, depth, 14) { + /* We need to pack the Huffman tree in 14 bits. If this was not + successful, add fake entities to the lowest values and retry. */ + break + } + } + } + + tree = nil + } + + BrotliConvertBitDepthsToSymbols(depth, length, bits) + if count <= 4 { + var i uint + + /* value of 1 indicates a simple Huffman code */ + BrotliWriteBits(2, 1, storage_ix, storage) + + BrotliWriteBits(2, uint64(count)-1, storage_ix, storage) /* NSYM - 1 */ + + /* Sort */ + for i = 0; i < count; i++ { + var j uint + for j = i + 1; j < count; j++ { + if depth[symbols[j]] < depth[symbols[i]] { + var tmp uint = symbols[j] + symbols[j] = symbols[i] + symbols[i] = tmp + } + } + } + + if count == 2 { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + } else if count == 3 { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[2]), storage_ix, storage) + } else { + BrotliWriteBits(max_bits, uint64(symbols[0]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[1]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[2]), storage_ix, storage) + BrotliWriteBits(max_bits, uint64(symbols[3]), storage_ix, storage) + + /* tree-select */ + var tmp int + if depth[symbols[0]] == 1 { + tmp = 1 + } else { + tmp = 0 + } + BrotliWriteBits(1, uint64(tmp), storage_ix, storage) + } + } else { + var previous_value byte = 8 + var i uint + + /* Complex Huffman Tree */ + StoreStaticCodeLengthCode(storage_ix, storage) + + /* Actual RLE coding. */ + for i = 0; i < length; { + var value byte = depth[i] + var reps uint = 1 + var k uint + for k = i + 1; k < length && depth[k] == value; k++ { + reps++ + } + + i += reps + if value == 0 { + BrotliWriteBits(uint(kZeroRepsDepth[reps]), kZeroRepsBits[reps], storage_ix, storage) + } else { + if previous_value != value { + BrotliWriteBits(uint(kCodeLengthDepth[value]), uint64(kCodeLengthBits[value]), storage_ix, storage) + reps-- + } + + if reps < 3 { + for reps != 0 { + reps-- + BrotliWriteBits(uint(kCodeLengthDepth[value]), uint64(kCodeLengthBits[value]), storage_ix, storage) + } + } else { + reps -= 3 + BrotliWriteBits(uint(kNonZeroRepsDepth[reps]), kNonZeroRepsBits[reps], storage_ix, storage) + } + + previous_value = value + } + } + } +} + +func IndexOf(v []byte, v_size uint, value byte) uint { + var i uint = 0 + for ; i < v_size; i++ { + if v[i] == value { + return i + } + } + + return i +} + +func MoveToFront(v []byte, index uint) { + var value byte = v[index] + var i uint + for i = index; i != 0; i-- { + v[i] = v[i-1] + } + + v[0] = value +} + +func MoveToFrontTransform(v_in []uint32, v_size uint, v_out []uint32) { + var i uint + var mtf [256]byte + var max_value uint32 + if v_size == 0 { + return + } + + max_value = v_in[0] + for i = 1; i < v_size; i++ { + if v_in[i] > max_value { + max_value = v_in[i] + } + } + + assert(max_value < 256) + for i = 0; uint32(i) <= max_value; i++ { + mtf[i] = byte(i) + } + { + var mtf_size uint = uint(max_value + 1) + for i = 0; i < v_size; i++ { + var index uint = IndexOf(mtf[:], mtf_size, byte(v_in[i])) + assert(index < mtf_size) + v_out[i] = uint32(index) + MoveToFront(mtf[:], index) + } + } +} + +/* Finds runs of zeros in v[0..in_size) and replaces them with a prefix code of + the run length plus extra bits (lower 9 bits is the prefix code and the rest + are the extra bits). Non-zero values in v[] are shifted by + *max_length_prefix. Will not create prefix codes bigger than the initial + value of *max_run_length_prefix. The prefix code of run length L is simply + Log2Floor(L) and the number of extra bits is the same as the prefix code. */ +func RunLengthCodeZeros(in_size uint, v []uint32, out_size *uint, max_run_length_prefix *uint32) { + var max_reps uint32 = 0 + var i uint + var max_prefix uint32 + for i = 0; i < in_size; { + var reps uint32 = 0 + for ; i < in_size && v[i] != 0; i++ { + } + for ; i < in_size && v[i] == 0; i++ { + reps++ + } + + max_reps = brotli_max_uint32_t(reps, max_reps) + } + + if max_reps > 0 { + max_prefix = Log2FloorNonZero(uint(max_reps)) + } else { + max_prefix = 0 + } + max_prefix = brotli_min_uint32_t(max_prefix, *max_run_length_prefix) + *max_run_length_prefix = max_prefix + *out_size = 0 + for i = 0; i < in_size; { + assert(*out_size <= i) + if v[i] != 0 { + v[*out_size] = v[i] + *max_run_length_prefix + i++ + (*out_size)++ + } else { + var reps uint32 = 1 + var k uint + for k = i + 1; k < in_size && v[k] == 0; k++ { + reps++ + } + + i += uint(reps) + for reps != 0 { + if reps < 2< 0) + BrotliWriteSingleBit(use_rle, storage_ix, storage) + if use_rle { + BrotliWriteBits(4, uint64(max_run_length_prefix)-1, storage_ix, storage) + } + } + + BuildAndStoreHuffmanTree(histogram[:], uint(uint32(num_clusters)+max_run_length_prefix), uint(uint32(num_clusters)+max_run_length_prefix), tree, depths[:], bits[:], storage_ix, storage) + for i = 0; i < num_rle_symbols; i++ { + var rle_symbol uint32 = rle_symbols[i] & EncodeContextMap_kSymbolMask + var extra_bits_val uint32 = rle_symbols[i] >> SYMBOL_BITS + BrotliWriteBits(uint(depths[rle_symbol]), uint64(bits[rle_symbol]), storage_ix, storage) + if rle_symbol > 0 && rle_symbol <= max_run_length_prefix { + BrotliWriteBits(uint(rle_symbol), uint64(extra_bits_val), storage_ix, storage) + } + } + + BrotliWriteBits(1, 1, storage_ix, storage) /* use move-to-front */ + rle_symbols = nil +} + +/* Stores the block switch command with index block_ix to the bit stream. */ +func StoreBlockSwitch(code *BlockSplitCode, block_len uint32, block_type byte, is_first_block bool, storage_ix *uint, storage []byte) { + var typecode uint = NextBlockTypeCode(&code.type_code_calculator, block_type) + var lencode uint + var len_nextra uint32 + var len_extra uint32 + if !is_first_block { + BrotliWriteBits(uint(code.type_depths[typecode]), uint64(code.type_bits[typecode]), storage_ix, storage) + } + + GetBlockLengthPrefixCode(block_len, &lencode, &len_nextra, &len_extra) + + BrotliWriteBits(uint(code.length_depths[lencode]), uint64(code.length_bits[lencode]), storage_ix, storage) + BrotliWriteBits(uint(len_nextra), uint64(len_extra), storage_ix, storage) +} + +/* Builds a BlockSplitCode data structure from the block split given by the + vector of block types and block lengths and stores it to the bit stream. */ +func BuildAndStoreBlockSplitCode(types []byte, lengths []uint32, num_blocks uint, num_types uint, tree []HuffmanTree, code *BlockSplitCode, storage_ix *uint, storage []byte) { + var type_histo [BROTLI_MAX_BLOCK_TYPE_SYMBOLS]uint32 + var length_histo [BROTLI_NUM_BLOCK_LEN_SYMBOLS]uint32 + var i uint + var type_code_calculator BlockTypeCodeCalculator + for i := 0; i < int(num_types+2); i++ { + type_histo[i] = 0 + } + length_histo = [BROTLI_NUM_BLOCK_LEN_SYMBOLS]uint32{} + InitBlockTypeCodeCalculator(&type_code_calculator) + for i = 0; i < num_blocks; i++ { + var type_code uint = NextBlockTypeCode(&type_code_calculator, types[i]) + if i != 0 { + type_histo[type_code]++ + } + length_histo[BlockLengthPrefixCode(lengths[i])]++ + } + + StoreVarLenUint8(num_types-1, storage_ix, storage) + if num_types > 1 { /* TODO: else? could StoreBlockSwitch occur? */ + BuildAndStoreHuffmanTree(type_histo[0:], num_types+2, num_types+2, tree, code.type_depths[0:], code.type_bits[0:], storage_ix, storage) + BuildAndStoreHuffmanTree(length_histo[0:], BROTLI_NUM_BLOCK_LEN_SYMBOLS, BROTLI_NUM_BLOCK_LEN_SYMBOLS, tree, code.length_depths[0:], code.length_bits[0:], storage_ix, storage) + StoreBlockSwitch(code, lengths[0], types[0], true, storage_ix, storage) + } +} + +/* Stores a context map where the histogram type is always the block type. */ +func StoreTrivialContextMap(num_types uint, context_bits uint, tree []HuffmanTree, storage_ix *uint, storage []byte) { + StoreVarLenUint8(num_types-1, storage_ix, storage) + if num_types > 1 { + var repeat_code uint = context_bits - 1 + var repeat_bits uint = (1 << repeat_code) - 1 + var alphabet_size uint = num_types + repeat_code + var histogram [BROTLI_MAX_CONTEXT_MAP_SYMBOLS]uint32 + var depths [BROTLI_MAX_CONTEXT_MAP_SYMBOLS]byte + var bits [BROTLI_MAX_CONTEXT_MAP_SYMBOLS]uint16 + var i uint + for i := 0; i < int(alphabet_size); i++ { + histogram[i] = 0 + } + + /* Write RLEMAX. */ + BrotliWriteBits(1, 1, storage_ix, storage) + + BrotliWriteBits(4, uint64(repeat_code)-1, storage_ix, storage) + histogram[repeat_code] = uint32(num_types) + histogram[0] = 1 + for i = context_bits; i < alphabet_size; i++ { + histogram[i] = 1 + } + + BuildAndStoreHuffmanTree(histogram[:], alphabet_size, alphabet_size, tree, depths[:], bits[:], storage_ix, storage) + for i = 0; i < num_types; i++ { + var tmp uint + if i == 0 { + tmp = 0 + } else { + tmp = i + context_bits - 1 + } + var code uint = tmp + BrotliWriteBits(uint(depths[code]), uint64(bits[code]), storage_ix, storage) + BrotliWriteBits(uint(depths[repeat_code]), uint64(bits[repeat_code]), storage_ix, storage) + BrotliWriteBits(repeat_code, uint64(repeat_bits), storage_ix, storage) + } + + /* Write IMTF (inverse-move-to-front) bit. */ + BrotliWriteBits(1, 1, storage_ix, storage) + } +} + +/* Manages the encoding of one block category (literal, command or distance). */ +type BlockEncoder struct { + histogram_length_ uint + num_block_types_ uint + block_types_ []byte + block_lengths_ []uint32 + num_blocks_ uint + block_split_code_ BlockSplitCode + block_ix_ uint + block_len_ uint + entropy_ix_ uint + depths_ []byte + bits_ []uint16 +} + +func InitBlockEncoder(self *BlockEncoder, histogram_length uint, num_block_types uint, block_types []byte, block_lengths []uint32, num_blocks uint) { + self.histogram_length_ = histogram_length + self.num_block_types_ = num_block_types + self.block_types_ = block_types + self.block_lengths_ = block_lengths + self.num_blocks_ = num_blocks + InitBlockTypeCodeCalculator(&self.block_split_code_.type_code_calculator) + self.block_ix_ = 0 + if num_blocks == 0 { + self.block_len_ = 0 + } else { + self.block_len_ = uint(block_lengths[0]) + } + self.entropy_ix_ = 0 + self.depths_ = nil + self.bits_ = nil +} + +func CleanupBlockEncoder(self *BlockEncoder) { + self.depths_ = nil + self.bits_ = nil +} + +/* Creates entropy codes of block lengths and block types and stores them + to the bit stream. */ +func BuildAndStoreBlockSwitchEntropyCodes(self *BlockEncoder, tree []HuffmanTree, storage_ix *uint, storage []byte) { + BuildAndStoreBlockSplitCode(self.block_types_, self.block_lengths_, self.num_blocks_, self.num_block_types_, tree, &self.block_split_code_, storage_ix, storage) +} + +/* Stores the next symbol with the entropy code of the current block type. + Updates the block type and block length at block boundaries. */ +func StoreSymbol(self *BlockEncoder, symbol uint, storage_ix *uint, storage []byte) { + if self.block_len_ == 0 { + self.block_ix_++ + var block_ix uint = self.block_ix_ + var block_len uint32 = self.block_lengths_[block_ix] + var block_type byte = self.block_types_[block_ix] + self.block_len_ = uint(block_len) + self.entropy_ix_ = uint(block_type) * self.histogram_length_ + StoreBlockSwitch(&self.block_split_code_, block_len, block_type, false, storage_ix, storage) + } + + self.block_len_-- + { + var ix uint = self.entropy_ix_ + symbol + BrotliWriteBits(uint(self.depths_[ix]), uint64(self.bits_[ix]), storage_ix, storage) + } +} + +/* Stores the next symbol with the entropy code of the current block type and + context value. + Updates the block type and block length at block boundaries. */ +func StoreSymbolWithContext(self *BlockEncoder, symbol uint, context uint, context_map []uint32, storage_ix *uint, storage []byte, context_bits uint) { + if self.block_len_ == 0 { + self.block_ix_++ + var block_ix uint = self.block_ix_ + var block_len uint32 = self.block_lengths_[block_ix] + var block_type byte = self.block_types_[block_ix] + self.block_len_ = uint(block_len) + self.entropy_ix_ = uint(block_type) << context_bits + StoreBlockSwitch(&self.block_split_code_, block_len, block_type, false, storage_ix, storage) + } + + self.block_len_-- + { + var histo_ix uint = uint(context_map[self.entropy_ix_+context]) + var ix uint = histo_ix*self.histogram_length_ + symbol + BrotliWriteBits(uint(self.depths_[ix]), uint64(self.bits_[ix]), storage_ix, storage) + } +} + +func BuildAndStoreEntropyCodesLiteral(self *BlockEncoder, histograms []HistogramLiteral, histograms_size uint, alphabet_size uint, tree []HuffmanTree, storage_ix *uint, storage []byte) { + var table_size uint = histograms_size * self.histogram_length_ + self.depths_ = make([]byte, table_size) + self.bits_ = make([]uint16, table_size) + { + var i uint + for i = 0; i < histograms_size; i++ { + var ix uint = i * self.histogram_length_ + BuildAndStoreHuffmanTree(histograms[i].data_[0:], self.histogram_length_, alphabet_size, tree, self.depths_[ix:], self.bits_[ix:], storage_ix, storage) + } + } +} + +func BuildAndStoreEntropyCodesCommand(self *BlockEncoder, histograms []HistogramCommand, histograms_size uint, alphabet_size uint, tree []HuffmanTree, storage_ix *uint, storage []byte) { + var table_size uint = histograms_size * self.histogram_length_ + self.depths_ = make([]byte, table_size) + self.bits_ = make([]uint16, table_size) + { + var i uint + for i = 0; i < histograms_size; i++ { + var ix uint = i * self.histogram_length_ + BuildAndStoreHuffmanTree(histograms[i].data_[0:], self.histogram_length_, alphabet_size, tree, self.depths_[ix:], self.bits_[ix:], storage_ix, storage) + } + } +} + +func BuildAndStoreEntropyCodesDistance(self *BlockEncoder, histograms []HistogramDistance, histograms_size uint, alphabet_size uint, tree []HuffmanTree, storage_ix *uint, storage []byte) { + var table_size uint = histograms_size * self.histogram_length_ + self.depths_ = make([]byte, table_size) + self.bits_ = make([]uint16, table_size) + { + var i uint + for i = 0; i < histograms_size; i++ { + var ix uint = i * self.histogram_length_ + BuildAndStoreHuffmanTree(histograms[i].data_[0:], self.histogram_length_, alphabet_size, tree, self.depths_[ix:], self.bits_[ix:], storage_ix, storage) + } + } +} + +func JumpToByteBoundary(storage_ix *uint, storage []byte) { + *storage_ix = (*storage_ix + 7) &^ 7 + storage[*storage_ix>>3] = 0 +} + +func BrotliStoreMetaBlock(input []byte, start_pos uint, length uint, mask uint, prev_byte byte, prev_byte2 byte, is_last bool, params *BrotliEncoderParams, literal_context_mode int, commands []Command, n_commands uint, mb *MetaBlockSplit, storage_ix *uint, storage []byte) { + var pos uint = start_pos + var i uint + var num_distance_symbols uint32 = params.dist.alphabet_size + var num_effective_distance_symbols uint32 = num_distance_symbols + var tree []HuffmanTree + var literal_context_lut ContextLut = BROTLI_CONTEXT_LUT(literal_context_mode) + var literal_enc BlockEncoder + var command_enc BlockEncoder + var distance_enc BlockEncoder + var dist *BrotliDistanceParams = ¶ms.dist + if params.large_window && num_effective_distance_symbols > BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS { + num_effective_distance_symbols = BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS + } + + StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage) + + tree = make([]HuffmanTree, MAX_HUFFMAN_TREE_SIZE) + InitBlockEncoder(&literal_enc, BROTLI_NUM_LITERAL_SYMBOLS, mb.literal_split.num_types, mb.literal_split.types, mb.literal_split.lengths, mb.literal_split.num_blocks) + InitBlockEncoder(&command_enc, BROTLI_NUM_COMMAND_SYMBOLS, mb.command_split.num_types, mb.command_split.types, mb.command_split.lengths, mb.command_split.num_blocks) + InitBlockEncoder(&distance_enc, uint(num_effective_distance_symbols), mb.distance_split.num_types, mb.distance_split.types, mb.distance_split.lengths, mb.distance_split.num_blocks) + + BuildAndStoreBlockSwitchEntropyCodes(&literal_enc, tree, storage_ix, storage) + BuildAndStoreBlockSwitchEntropyCodes(&command_enc, tree, storage_ix, storage) + BuildAndStoreBlockSwitchEntropyCodes(&distance_enc, tree, storage_ix, storage) + + BrotliWriteBits(2, uint64(dist.distance_postfix_bits), storage_ix, storage) + BrotliWriteBits(4, uint64(dist.num_direct_distance_codes)>>dist.distance_postfix_bits, storage_ix, storage) + for i = 0; i < mb.literal_split.num_types; i++ { + BrotliWriteBits(2, uint64(literal_context_mode), storage_ix, storage) + } + + if mb.literal_context_map_size == 0 { + StoreTrivialContextMap(mb.literal_histograms_size, BROTLI_LITERAL_CONTEXT_BITS, tree, storage_ix, storage) + } else { + EncodeContextMap(mb.literal_context_map, mb.literal_context_map_size, mb.literal_histograms_size, tree, storage_ix, storage) + } + + if mb.distance_context_map_size == 0 { + StoreTrivialContextMap(mb.distance_histograms_size, BROTLI_DISTANCE_CONTEXT_BITS, tree, storage_ix, storage) + } else { + EncodeContextMap(mb.distance_context_map, mb.distance_context_map_size, mb.distance_histograms_size, tree, storage_ix, storage) + } + + BuildAndStoreEntropyCodesLiteral(&literal_enc, mb.literal_histograms, mb.literal_histograms_size, BROTLI_NUM_LITERAL_SYMBOLS, tree, storage_ix, storage) + BuildAndStoreEntropyCodesCommand(&command_enc, mb.command_histograms, mb.command_histograms_size, BROTLI_NUM_COMMAND_SYMBOLS, tree, storage_ix, storage) + BuildAndStoreEntropyCodesDistance(&distance_enc, mb.distance_histograms, mb.distance_histograms_size, uint(num_distance_symbols), tree, storage_ix, storage) + tree = nil + + for i = 0; i < n_commands; i++ { + var cmd Command = commands[i] + var cmd_code uint = uint(cmd.cmd_prefix_) + StoreSymbol(&command_enc, cmd_code, storage_ix, storage) + StoreCommandExtra(&cmd, storage_ix, storage) + if mb.literal_context_map_size == 0 { + var j uint + for j = uint(cmd.insert_len_); j != 0; j-- { + StoreSymbol(&literal_enc, uint(input[pos&mask]), storage_ix, storage) + pos++ + } + } else { + var j uint + for j = uint(cmd.insert_len_); j != 0; j-- { + var context uint = uint(BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut)) + var literal byte = input[pos&mask] + StoreSymbolWithContext(&literal_enc, uint(literal), context, mb.literal_context_map, storage_ix, storage, BROTLI_LITERAL_CONTEXT_BITS) + prev_byte2 = prev_byte + prev_byte = literal + pos++ + } + } + + pos += uint(CommandCopyLen(&cmd)) + if CommandCopyLen(&cmd) != 0 { + prev_byte2 = input[(pos-2)&mask] + prev_byte = input[(pos-1)&mask] + if cmd.cmd_prefix_ >= 128 { + var dist_code uint = uint(cmd.dist_prefix_) & 0x3FF + var distnumextra uint32 = uint32(cmd.dist_prefix_) >> 10 + var distextra uint64 = uint64(cmd.dist_extra_) + if mb.distance_context_map_size == 0 { + StoreSymbol(&distance_enc, dist_code, storage_ix, storage) + } else { + var context uint = uint(CommandDistanceContext(&cmd)) + StoreSymbolWithContext(&distance_enc, dist_code, context, mb.distance_context_map, storage_ix, storage, BROTLI_DISTANCE_CONTEXT_BITS) + } + + BrotliWriteBits(uint(distnumextra), distextra, storage_ix, storage) + } + } + } + + CleanupBlockEncoder(&distance_enc) + CleanupBlockEncoder(&command_enc) + CleanupBlockEncoder(&literal_enc) + if is_last { + JumpToByteBoundary(storage_ix, storage) + } +} + +func BuildHistograms(input []byte, start_pos uint, mask uint, commands []Command, n_commands uint, lit_histo *HistogramLiteral, cmd_histo *HistogramCommand, dist_histo *HistogramDistance) { + var pos uint = start_pos + var i uint + for i = 0; i < n_commands; i++ { + var cmd Command = commands[i] + var j uint + HistogramAddCommand(cmd_histo, uint(cmd.cmd_prefix_)) + for j = uint(cmd.insert_len_); j != 0; j-- { + HistogramAddLiteral(lit_histo, uint(input[pos&mask])) + pos++ + } + + pos += uint(CommandCopyLen(&cmd)) + if CommandCopyLen(&cmd) != 0 && cmd.cmd_prefix_ >= 128 { + HistogramAddDistance(dist_histo, uint(cmd.dist_prefix_)&0x3FF) + } + } +} + +func StoreDataWithHuffmanCodes(input []byte, start_pos uint, mask uint, commands []Command, n_commands uint, lit_depth []byte, lit_bits []uint16, cmd_depth []byte, cmd_bits []uint16, dist_depth []byte, dist_bits []uint16, storage_ix *uint, storage []byte) { + var pos uint = start_pos + var i uint + for i = 0; i < n_commands; i++ { + var cmd Command = commands[i] + var cmd_code uint = uint(cmd.cmd_prefix_) + var j uint + BrotliWriteBits(uint(cmd_depth[cmd_code]), uint64(cmd_bits[cmd_code]), storage_ix, storage) + StoreCommandExtra(&cmd, storage_ix, storage) + for j = uint(cmd.insert_len_); j != 0; j-- { + var literal byte = input[pos&mask] + BrotliWriteBits(uint(lit_depth[literal]), uint64(lit_bits[literal]), storage_ix, storage) + pos++ + } + + pos += uint(CommandCopyLen(&cmd)) + if CommandCopyLen(&cmd) != 0 && cmd.cmd_prefix_ >= 128 { + var dist_code uint = uint(cmd.dist_prefix_) & 0x3FF + var distnumextra uint32 = uint32(cmd.dist_prefix_) >> 10 + var distextra uint32 = cmd.dist_extra_ + BrotliWriteBits(uint(dist_depth[dist_code]), uint64(dist_bits[dist_code]), storage_ix, storage) + BrotliWriteBits(uint(distnumextra), uint64(distextra), storage_ix, storage) + } + } +} + +func BrotliStoreMetaBlockTrivial(input []byte, start_pos uint, length uint, mask uint, is_last bool, params *BrotliEncoderParams, commands []Command, n_commands uint, storage_ix *uint, storage []byte) { + var lit_histo HistogramLiteral + var cmd_histo HistogramCommand + var dist_histo HistogramDistance + var lit_depth [BROTLI_NUM_LITERAL_SYMBOLS]byte + var lit_bits [BROTLI_NUM_LITERAL_SYMBOLS]uint16 + var cmd_depth [BROTLI_NUM_COMMAND_SYMBOLS]byte + var cmd_bits [BROTLI_NUM_COMMAND_SYMBOLS]uint16 + var dist_depth [MAX_SIMPLE_DISTANCE_ALPHABET_SIZE]byte + var dist_bits [MAX_SIMPLE_DISTANCE_ALPHABET_SIZE]uint16 + var tree []HuffmanTree + var num_distance_symbols uint32 = params.dist.alphabet_size + + StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage) + + HistogramClearLiteral(&lit_histo) + HistogramClearCommand(&cmd_histo) + HistogramClearDistance(&dist_histo) + + BuildHistograms(input, start_pos, mask, commands, n_commands, &lit_histo, &cmd_histo, &dist_histo) + + BrotliWriteBits(13, 0, storage_ix, storage) + + tree = make([]HuffmanTree, MAX_HUFFMAN_TREE_SIZE) + BuildAndStoreHuffmanTree(lit_histo.data_[:], BROTLI_NUM_LITERAL_SYMBOLS, BROTLI_NUM_LITERAL_SYMBOLS, tree, lit_depth[:], lit_bits[:], storage_ix, storage) + BuildAndStoreHuffmanTree(cmd_histo.data_[:], BROTLI_NUM_COMMAND_SYMBOLS, BROTLI_NUM_COMMAND_SYMBOLS, tree, cmd_depth[:], cmd_bits[:], storage_ix, storage) + BuildAndStoreHuffmanTree(dist_histo.data_[:], MAX_SIMPLE_DISTANCE_ALPHABET_SIZE, uint(num_distance_symbols), tree, dist_depth[:], dist_bits[:], storage_ix, storage) + tree = nil + StoreDataWithHuffmanCodes(input, start_pos, mask, commands, n_commands, lit_depth[:], lit_bits[:], cmd_depth[:], cmd_bits[:], dist_depth[:], dist_bits[:], storage_ix, storage) + if is_last { + JumpToByteBoundary(storage_ix, storage) + } +} + +func BrotliStoreMetaBlockFast(input []byte, start_pos uint, length uint, mask uint, is_last bool, params *BrotliEncoderParams, commands []Command, n_commands uint, storage_ix *uint, storage []byte) { + var num_distance_symbols uint32 = params.dist.alphabet_size + var distance_alphabet_bits uint32 = Log2FloorNonZero(uint(num_distance_symbols-1)) + 1 + + StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage) + + BrotliWriteBits(13, 0, storage_ix, storage) + + if n_commands <= 128 { + var histogram = [BROTLI_NUM_LITERAL_SYMBOLS]uint32{0} + var pos uint = start_pos + var num_literals uint = 0 + var i uint + var lit_depth [BROTLI_NUM_LITERAL_SYMBOLS]byte + var lit_bits [BROTLI_NUM_LITERAL_SYMBOLS]uint16 + for i = 0; i < n_commands; i++ { + var cmd Command = commands[i] + var j uint + for j = uint(cmd.insert_len_); j != 0; j-- { + histogram[input[pos&mask]]++ + pos++ + } + + num_literals += uint(cmd.insert_len_) + pos += uint(CommandCopyLen(&cmd)) + } + + BrotliBuildAndStoreHuffmanTreeFast(histogram[:], num_literals, /* max_bits = */ + 8, lit_depth[:], lit_bits[:], storage_ix, storage) + + StoreStaticCommandHuffmanTree(storage_ix, storage) + StoreStaticDistanceHuffmanTree(storage_ix, storage) + StoreDataWithHuffmanCodes(input, start_pos, mask, commands, n_commands, lit_depth[:], lit_bits[:], kStaticCommandCodeDepth[:], kStaticCommandCodeBits[:], kStaticDistanceCodeDepth[:], kStaticDistanceCodeBits[:], storage_ix, storage) + } else { + var lit_histo HistogramLiteral + var cmd_histo HistogramCommand + var dist_histo HistogramDistance + var lit_depth [BROTLI_NUM_LITERAL_SYMBOLS]byte + var lit_bits [BROTLI_NUM_LITERAL_SYMBOLS]uint16 + var cmd_depth [BROTLI_NUM_COMMAND_SYMBOLS]byte + var cmd_bits [BROTLI_NUM_COMMAND_SYMBOLS]uint16 + var dist_depth [MAX_SIMPLE_DISTANCE_ALPHABET_SIZE]byte + var dist_bits [MAX_SIMPLE_DISTANCE_ALPHABET_SIZE]uint16 + HistogramClearLiteral(&lit_histo) + HistogramClearCommand(&cmd_histo) + HistogramClearDistance(&dist_histo) + BuildHistograms(input, start_pos, mask, commands, n_commands, &lit_histo, &cmd_histo, &dist_histo) + BrotliBuildAndStoreHuffmanTreeFast(lit_histo.data_[:], lit_histo.total_count_, /* max_bits = */ + 8, lit_depth[:], lit_bits[:], storage_ix, storage) + + BrotliBuildAndStoreHuffmanTreeFast(cmd_histo.data_[:], cmd_histo.total_count_, /* max_bits = */ + 10, cmd_depth[:], cmd_bits[:], storage_ix, storage) + + BrotliBuildAndStoreHuffmanTreeFast(dist_histo.data_[:], dist_histo.total_count_, /* max_bits = */ + uint(distance_alphabet_bits), dist_depth[:], dist_bits[:], storage_ix, storage) + + StoreDataWithHuffmanCodes(input, start_pos, mask, commands, n_commands, lit_depth[:], lit_bits[:], cmd_depth[:], cmd_bits[:], dist_depth[:], dist_bits[:], storage_ix, storage) + } + + if is_last { + JumpToByteBoundary(storage_ix, storage) + } +} + +/* This is for storing uncompressed blocks (simple raw storage of + bytes-as-bytes). */ +func BrotliStoreUncompressedMetaBlock(is_final_block bool, input []byte, position uint, mask uint, len uint, storage_ix *uint, storage []byte) { + var masked_pos uint = position & mask + BrotliStoreUncompressedMetaBlockHeader(uint(len), storage_ix, storage) + JumpToByteBoundary(storage_ix, storage) + + if masked_pos+len > mask+1 { + var len1 uint = mask + 1 - masked_pos + copy(storage[*storage_ix>>3:], input[masked_pos:][:len1]) + *storage_ix += len1 << 3 + len -= len1 + masked_pos = 0 + } + + copy(storage[*storage_ix>>3:], input[masked_pos:][:len]) + *storage_ix += uint(len << 3) + + /* We need to clear the next 4 bytes to continue to be + compatible with BrotliWriteBits. */ + BrotliWriteBitsPrepareStorage(*storage_ix, storage) + + /* Since the uncompressed block itself may not be the final block, add an + empty one after this. */ + if is_final_block { + BrotliWriteBits(1, 1, storage_ix, storage) /* islast */ + BrotliWriteBits(1, 1, storage_ix, storage) /* isempty */ + JumpToByteBoundary(storage_ix, storage) + } +} diff --git a/cluster.go b/cluster.go new file mode 100644 index 0000000..40957b6 --- /dev/null +++ b/cluster.go @@ -0,0 +1,43 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Block split point selection utilities. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions for clustering similar histograms together. */ +type HistogramPair struct { + idx1 uint32 + idx2 uint32 + cost_combo float64 + cost_diff float64 +} + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions for clustering similar histograms together. */ +func HistogramPairIsLess(p1 *HistogramPair, p2 *HistogramPair) bool { + if p1.cost_diff != p2.cost_diff { + return p1.cost_diff > p2.cost_diff + } + + return (p1.idx2 - p1.idx1) > (p2.idx2 - p2.idx1) +} + +/* Returns entropy reduction of the context map when we combine two clusters. */ +func ClusterCostDiff(size_a uint, size_b uint) float64 { + var size_c uint = size_a + size_b + return float64(size_a)*FastLog2(size_a) + float64(size_b)*FastLog2(size_b) - float64(size_c)*FastLog2(size_c) +} diff --git a/cluster_command.go b/cluster_command.go new file mode 100644 index 0000000..2abbfb4 --- /dev/null +++ b/cluster_command.go @@ -0,0 +1,325 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if + it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */ +func BrotliCompareAndPushToQueueCommand(out []HistogramCommand, cluster_size []uint32, idx1 uint32, idx2 uint32, max_num_pairs uint, pairs []HistogramPair, num_pairs *uint) { + var is_good_pair bool = false + var p HistogramPair + p.idx2 = 0 + p.idx1 = p.idx2 + p.cost_combo = 0 + p.cost_diff = p.cost_combo + if idx1 == idx2 { + return + } + + if idx2 < idx1 { + var t uint32 = idx2 + idx2 = idx1 + idx1 = t + } + + p.idx1 = idx1 + p.idx2 = idx2 + p.cost_diff = 0.5 * ClusterCostDiff(uint(cluster_size[idx1]), uint(cluster_size[idx2])) + p.cost_diff -= out[idx1].bit_cost_ + p.cost_diff -= out[idx2].bit_cost_ + + if out[idx1].total_count_ == 0 { + p.cost_combo = out[idx2].bit_cost_ + is_good_pair = true + } else if out[idx2].total_count_ == 0 { + p.cost_combo = out[idx1].bit_cost_ + is_good_pair = true + } else { + var threshold float64 + if *num_pairs == 0 { + threshold = 1e99 + } else { + threshold = brotli_max_double(0.0, pairs[0].cost_diff) + } + var combo HistogramCommand = out[idx1] + var cost_combo float64 + HistogramAddHistogramCommand(&combo, &out[idx2]) + cost_combo = BrotliPopulationCostCommand(&combo) + if cost_combo < threshold-p.cost_diff { + p.cost_combo = cost_combo + is_good_pair = true + } + } + + if is_good_pair { + p.cost_diff += p.cost_combo + if *num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p) { + /* Replace the top of the queue if needed. */ + if *num_pairs < max_num_pairs { + pairs[*num_pairs] = pairs[0] + (*num_pairs)++ + } + + pairs[0] = p + } else if *num_pairs < max_num_pairs { + pairs[*num_pairs] = p + (*num_pairs)++ + } + } +} + +func BrotliHistogramCombineCommand(out []HistogramCommand, cluster_size []uint32, symbols []uint32, clusters []uint32, pairs []HistogramPair, num_clusters uint, symbols_size uint, max_clusters uint, max_num_pairs uint) uint { + var cost_diff_threshold float64 = 0.0 + var min_cluster_size uint = 1 + var num_pairs uint = 0 + { + /* We maintain a vector of histogram pairs, with the property that the pair + with the maximum bit cost reduction is the first. */ + var idx1 uint + for idx1 = 0; idx1 < num_clusters; idx1++ { + var idx2 uint + for idx2 = idx1 + 1; idx2 < num_clusters; idx2++ { + BrotliCompareAndPushToQueueCommand(out, cluster_size, clusters[idx1], clusters[idx2], max_num_pairs, pairs[0:], &num_pairs) + } + } + } + + for num_clusters > min_cluster_size { + var best_idx1 uint32 + var best_idx2 uint32 + var i uint + if pairs[0].cost_diff >= cost_diff_threshold { + cost_diff_threshold = 1e99 + min_cluster_size = max_clusters + continue + } + + /* Take the best pair from the top of heap. */ + best_idx1 = pairs[0].idx1 + + best_idx2 = pairs[0].idx2 + HistogramAddHistogramCommand(&out[best_idx1], &out[best_idx2]) + out[best_idx1].bit_cost_ = pairs[0].cost_combo + cluster_size[best_idx1] += cluster_size[best_idx2] + for i = 0; i < symbols_size; i++ { + if symbols[i] == best_idx2 { + symbols[i] = best_idx1 + } + } + + for i = 0; i < num_clusters; i++ { + if clusters[i] == best_idx2 { + copy(clusters[i:], clusters[i+1:][:num_clusters-i-1]) + break + } + } + + num_clusters-- + { + /* Remove pairs intersecting the just combined best pair. */ + var copy_to_idx uint = 0 + for i = 0; i < num_pairs; i++ { + var p *HistogramPair = &pairs[i] + if p.idx1 == best_idx1 || p.idx2 == best_idx1 || p.idx1 == best_idx2 || p.idx2 == best_idx2 { + /* Remove invalid pair from the queue. */ + continue + } + + if HistogramPairIsLess(&pairs[0], p) { + /* Replace the top of the queue if needed. */ + var front HistogramPair = pairs[0] + pairs[0] = *p + pairs[copy_to_idx] = front + } else { + pairs[copy_to_idx] = *p + } + + copy_to_idx++ + } + + num_pairs = copy_to_idx + } + + /* Push new pairs formed with the combined histogram to the heap. */ + for i = 0; i < num_clusters; i++ { + BrotliCompareAndPushToQueueCommand(out, cluster_size, best_idx1, clusters[i], max_num_pairs, pairs[0:], &num_pairs) + } + } + + return num_clusters +} + +/* What is the bit cost of moving histogram from cur_symbol to candidate. */ +func BrotliHistogramBitCostDistanceCommand(histogram *HistogramCommand, candidate *HistogramCommand) float64 { + if histogram.total_count_ == 0 { + return 0.0 + } else { + var tmp HistogramCommand = *histogram + HistogramAddHistogramCommand(&tmp, candidate) + return BrotliPopulationCostCommand(&tmp) - candidate.bit_cost_ + } +} + +/* Find the best 'out' histogram for each of the 'in' histograms. + When called, clusters[0..num_clusters) contains the unique values from + symbols[0..in_size), but this property is not preserved in this function. + Note: we assume that out[]->bit_cost_ is already up-to-date. */ +func BrotliHistogramRemapCommand(in []HistogramCommand, in_size uint, clusters []uint32, num_clusters uint, out []HistogramCommand, symbols []uint32) { + var i uint + for i = 0; i < in_size; i++ { + var best_out uint32 + if i == 0 { + best_out = symbols[0] + } else { + best_out = symbols[i-1] + } + var best_bits float64 = BrotliHistogramBitCostDistanceCommand(&in[i], &out[best_out]) + var j uint + for j = 0; j < num_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceCommand(&in[i], &out[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + symbols[i] = best_out + } + + /* Recompute each out based on raw and symbols. */ + for i = 0; i < num_clusters; i++ { + HistogramClearCommand(&out[clusters[i]]) + } + + for i = 0; i < in_size; i++ { + HistogramAddHistogramCommand(&out[symbols[i]], &in[i]) + } +} + +/* Reorders elements of the out[0..length) array and changes values in + symbols[0..length) array in the following way: + * when called, symbols[] contains indexes into out[], and has N unique + values (possibly N < length) + * on return, symbols'[i] = f(symbols[i]) and + out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length, + where f is a bijection between the range of symbols[] and [0..N), and + the first occurrences of values in symbols'[i] come in consecutive + increasing order. + Returns N, the number of unique values in symbols[]. */ + +var BrotliHistogramReindexCommand_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func BrotliHistogramReindexCommand(out []HistogramCommand, symbols []uint32, length uint) uint { + var new_index []uint32 = make([]uint32, length) + var next_index uint32 + var tmp []HistogramCommand + var i uint + for i = 0; i < length; i++ { + new_index[i] = BrotliHistogramReindexCommand_kInvalidIndex + } + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == BrotliHistogramReindexCommand_kInvalidIndex { + new_index[symbols[i]] = next_index + next_index++ + } + } + + /* TODO: by using idea of "cycle-sort" we can avoid allocation of + tmp and reduce the number of copying by the factor of 2. */ + tmp = make([]HistogramCommand, next_index) + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == next_index { + tmp[next_index] = out[symbols[i]] + next_index++ + } + + symbols[i] = new_index[symbols[i]] + } + + new_index = nil + for i = 0; uint32(i) < next_index; i++ { + out[i] = tmp[i] + } + + tmp = nil + return uint(next_index) +} + +func BrotliClusterHistogramsCommand(in []HistogramCommand, in_size uint, max_histograms uint, out []HistogramCommand, out_size *uint, histogram_symbols []uint32) { + var cluster_size []uint32 = make([]uint32, in_size) + var clusters []uint32 = make([]uint32, in_size) + var num_clusters uint = 0 + var max_input_histograms uint = 64 + var pairs_capacity uint = max_input_histograms * max_input_histograms / 2 + var pairs []HistogramPair = make([]HistogramPair, (pairs_capacity + 1)) + var i uint + + /* For the first pass of clustering, we allow all pairs. */ + for i = 0; i < in_size; i++ { + cluster_size[i] = 1 + } + + for i = 0; i < in_size; i++ { + out[i] = in[i] + out[i].bit_cost_ = BrotliPopulationCostCommand(&in[i]) + histogram_symbols[i] = uint32(i) + } + + for i = 0; i < in_size; i += max_input_histograms { + var num_to_combine uint = brotli_min_size_t(in_size-i, max_input_histograms) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + clusters[num_clusters+j] = uint32(i + j) + } + + num_new_clusters = BrotliHistogramCombineCommand(out, cluster_size, histogram_symbols[i:], clusters[num_clusters:], pairs, num_to_combine, num_to_combine, max_histograms, pairs_capacity) + num_clusters += num_new_clusters + } + { + /* For the second pass, we limit the total number of histogram pairs. + After this limit is reached, we only keep searching for the best pair. */ + var max_num_pairs uint = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < (max_num_pairs + 1) { + var _new_size uint + if pairs_capacity == 0 { + _new_size = max_num_pairs + 1 + } else { + _new_size = pairs_capacity + } + var new_array []HistogramPair + for _new_size < (max_num_pairs + 1) { + _new_size *= 2 + } + new_array = make([]HistogramPair, _new_size) + if pairs_capacity != 0 { + copy(new_array, pairs[:pairs_capacity]) + } + + pairs = new_array + pairs_capacity = _new_size + } + + /* Collapse similar histograms. */ + num_clusters = BrotliHistogramCombineCommand(out, cluster_size, histogram_symbols, clusters, pairs, num_clusters, in_size, max_histograms, max_num_pairs) + } + + pairs = nil + cluster_size = nil + + /* Find the optimal map from original histograms to the final ones. */ + BrotliHistogramRemapCommand(in, in_size, clusters, num_clusters, out, histogram_symbols) + + clusters = nil + + /* Convert the context map to a canonical form. */ + *out_size = BrotliHistogramReindexCommand(out, histogram_symbols, in_size) +} diff --git a/cluster_distance.go b/cluster_distance.go new file mode 100644 index 0000000..71382ed --- /dev/null +++ b/cluster_distance.go @@ -0,0 +1,325 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if + it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */ +func BrotliCompareAndPushToQueueDistance(out []HistogramDistance, cluster_size []uint32, idx1 uint32, idx2 uint32, max_num_pairs uint, pairs []HistogramPair, num_pairs *uint) { + var is_good_pair bool = false + var p HistogramPair + p.idx2 = 0 + p.idx1 = p.idx2 + p.cost_combo = 0 + p.cost_diff = p.cost_combo + if idx1 == idx2 { + return + } + + if idx2 < idx1 { + var t uint32 = idx2 + idx2 = idx1 + idx1 = t + } + + p.idx1 = idx1 + p.idx2 = idx2 + p.cost_diff = 0.5 * ClusterCostDiff(uint(cluster_size[idx1]), uint(cluster_size[idx2])) + p.cost_diff -= out[idx1].bit_cost_ + p.cost_diff -= out[idx2].bit_cost_ + + if out[idx1].total_count_ == 0 { + p.cost_combo = out[idx2].bit_cost_ + is_good_pair = true + } else if out[idx2].total_count_ == 0 { + p.cost_combo = out[idx1].bit_cost_ + is_good_pair = true + } else { + var threshold float64 + if *num_pairs == 0 { + threshold = 1e99 + } else { + threshold = brotli_max_double(0.0, pairs[0].cost_diff) + } + var combo HistogramDistance = out[idx1] + var cost_combo float64 + HistogramAddHistogramDistance(&combo, &out[idx2]) + cost_combo = BrotliPopulationCostDistance(&combo) + if cost_combo < threshold-p.cost_diff { + p.cost_combo = cost_combo + is_good_pair = true + } + } + + if is_good_pair { + p.cost_diff += p.cost_combo + if *num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p) { + /* Replace the top of the queue if needed. */ + if *num_pairs < max_num_pairs { + pairs[*num_pairs] = pairs[0] + (*num_pairs)++ + } + + pairs[0] = p + } else if *num_pairs < max_num_pairs { + pairs[*num_pairs] = p + (*num_pairs)++ + } + } +} + +func BrotliHistogramCombineDistance(out []HistogramDistance, cluster_size []uint32, symbols []uint32, clusters []uint32, pairs []HistogramPair, num_clusters uint, symbols_size uint, max_clusters uint, max_num_pairs uint) uint { + var cost_diff_threshold float64 = 0.0 + var min_cluster_size uint = 1 + var num_pairs uint = 0 + { + /* We maintain a vector of histogram pairs, with the property that the pair + with the maximum bit cost reduction is the first. */ + var idx1 uint + for idx1 = 0; idx1 < num_clusters; idx1++ { + var idx2 uint + for idx2 = idx1 + 1; idx2 < num_clusters; idx2++ { + BrotliCompareAndPushToQueueDistance(out, cluster_size, clusters[idx1], clusters[idx2], max_num_pairs, pairs[0:], &num_pairs) + } + } + } + + for num_clusters > min_cluster_size { + var best_idx1 uint32 + var best_idx2 uint32 + var i uint + if pairs[0].cost_diff >= cost_diff_threshold { + cost_diff_threshold = 1e99 + min_cluster_size = max_clusters + continue + } + + /* Take the best pair from the top of heap. */ + best_idx1 = pairs[0].idx1 + + best_idx2 = pairs[0].idx2 + HistogramAddHistogramDistance(&out[best_idx1], &out[best_idx2]) + out[best_idx1].bit_cost_ = pairs[0].cost_combo + cluster_size[best_idx1] += cluster_size[best_idx2] + for i = 0; i < symbols_size; i++ { + if symbols[i] == best_idx2 { + symbols[i] = best_idx1 + } + } + + for i = 0; i < num_clusters; i++ { + if clusters[i] == best_idx2 { + copy(clusters[i:], clusters[i+1:][:num_clusters-i-1]) + break + } + } + + num_clusters-- + { + /* Remove pairs intersecting the just combined best pair. */ + var copy_to_idx uint = 0 + for i = 0; i < num_pairs; i++ { + var p *HistogramPair = &pairs[i] + if p.idx1 == best_idx1 || p.idx2 == best_idx1 || p.idx1 == best_idx2 || p.idx2 == best_idx2 { + /* Remove invalid pair from the queue. */ + continue + } + + if HistogramPairIsLess(&pairs[0], p) { + /* Replace the top of the queue if needed. */ + var front HistogramPair = pairs[0] + pairs[0] = *p + pairs[copy_to_idx] = front + } else { + pairs[copy_to_idx] = *p + } + + copy_to_idx++ + } + + num_pairs = copy_to_idx + } + + /* Push new pairs formed with the combined histogram to the heap. */ + for i = 0; i < num_clusters; i++ { + BrotliCompareAndPushToQueueDistance(out, cluster_size, best_idx1, clusters[i], max_num_pairs, pairs[0:], &num_pairs) + } + } + + return num_clusters +} + +/* What is the bit cost of moving histogram from cur_symbol to candidate. */ +func BrotliHistogramBitCostDistanceDistance(histogram *HistogramDistance, candidate *HistogramDistance) float64 { + if histogram.total_count_ == 0 { + return 0.0 + } else { + var tmp HistogramDistance = *histogram + HistogramAddHistogramDistance(&tmp, candidate) + return BrotliPopulationCostDistance(&tmp) - candidate.bit_cost_ + } +} + +/* Find the best 'out' histogram for each of the 'in' histograms. + When called, clusters[0..num_clusters) contains the unique values from + symbols[0..in_size), but this property is not preserved in this function. + Note: we assume that out[]->bit_cost_ is already up-to-date. */ +func BrotliHistogramRemapDistance(in []HistogramDistance, in_size uint, clusters []uint32, num_clusters uint, out []HistogramDistance, symbols []uint32) { + var i uint + for i = 0; i < in_size; i++ { + var best_out uint32 + if i == 0 { + best_out = symbols[0] + } else { + best_out = symbols[i-1] + } + var best_bits float64 = BrotliHistogramBitCostDistanceDistance(&in[i], &out[best_out]) + var j uint + for j = 0; j < num_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceDistance(&in[i], &out[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + symbols[i] = best_out + } + + /* Recompute each out based on raw and symbols. */ + for i = 0; i < num_clusters; i++ { + HistogramClearDistance(&out[clusters[i]]) + } + + for i = 0; i < in_size; i++ { + HistogramAddHistogramDistance(&out[symbols[i]], &in[i]) + } +} + +/* Reorders elements of the out[0..length) array and changes values in + symbols[0..length) array in the following way: + * when called, symbols[] contains indexes into out[], and has N unique + values (possibly N < length) + * on return, symbols'[i] = f(symbols[i]) and + out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length, + where f is a bijection between the range of symbols[] and [0..N), and + the first occurrences of values in symbols'[i] come in consecutive + increasing order. + Returns N, the number of unique values in symbols[]. */ + +var BrotliHistogramReindexDistance_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func BrotliHistogramReindexDistance(out []HistogramDistance, symbols []uint32, length uint) uint { + var new_index []uint32 = make([]uint32, length) + var next_index uint32 + var tmp []HistogramDistance + var i uint + for i = 0; i < length; i++ { + new_index[i] = BrotliHistogramReindexDistance_kInvalidIndex + } + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == BrotliHistogramReindexDistance_kInvalidIndex { + new_index[symbols[i]] = next_index + next_index++ + } + } + + /* TODO: by using idea of "cycle-sort" we can avoid allocation of + tmp and reduce the number of copying by the factor of 2. */ + tmp = make([]HistogramDistance, next_index) + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == next_index { + tmp[next_index] = out[symbols[i]] + next_index++ + } + + symbols[i] = new_index[symbols[i]] + } + + new_index = nil + for i = 0; uint32(i) < next_index; i++ { + out[i] = tmp[i] + } + + tmp = nil + return uint(next_index) +} + +func BrotliClusterHistogramsDistance(in []HistogramDistance, in_size uint, max_histograms uint, out []HistogramDistance, out_size *uint, histogram_symbols []uint32) { + var cluster_size []uint32 = make([]uint32, in_size) + var clusters []uint32 = make([]uint32, in_size) + var num_clusters uint = 0 + var max_input_histograms uint = 64 + var pairs_capacity uint = max_input_histograms * max_input_histograms / 2 + var pairs []HistogramPair = make([]HistogramPair, (pairs_capacity + 1)) + var i uint + + /* For the first pass of clustering, we allow all pairs. */ + for i = 0; i < in_size; i++ { + cluster_size[i] = 1 + } + + for i = 0; i < in_size; i++ { + out[i] = in[i] + out[i].bit_cost_ = BrotliPopulationCostDistance(&in[i]) + histogram_symbols[i] = uint32(i) + } + + for i = 0; i < in_size; i += max_input_histograms { + var num_to_combine uint = brotli_min_size_t(in_size-i, max_input_histograms) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + clusters[num_clusters+j] = uint32(i + j) + } + + num_new_clusters = BrotliHistogramCombineDistance(out, cluster_size, histogram_symbols[i:], clusters[num_clusters:], pairs, num_to_combine, num_to_combine, max_histograms, pairs_capacity) + num_clusters += num_new_clusters + } + { + /* For the second pass, we limit the total number of histogram pairs. + After this limit is reached, we only keep searching for the best pair. */ + var max_num_pairs uint = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < (max_num_pairs + 1) { + var _new_size uint + if pairs_capacity == 0 { + _new_size = max_num_pairs + 1 + } else { + _new_size = pairs_capacity + } + var new_array []HistogramPair + for _new_size < (max_num_pairs + 1) { + _new_size *= 2 + } + new_array = make([]HistogramPair, _new_size) + if pairs_capacity != 0 { + copy(new_array, pairs[:pairs_capacity]) + } + + pairs = new_array + pairs_capacity = _new_size + } + + /* Collapse similar histograms. */ + num_clusters = BrotliHistogramCombineDistance(out, cluster_size, histogram_symbols, clusters, pairs, num_clusters, in_size, max_histograms, max_num_pairs) + } + + pairs = nil + cluster_size = nil + + /* Find the optimal map from original histograms to the final ones. */ + BrotliHistogramRemapDistance(in, in_size, clusters, num_clusters, out, histogram_symbols) + + clusters = nil + + /* Convert the context map to a canonical form. */ + *out_size = BrotliHistogramReindexDistance(out, histogram_symbols, in_size) +} diff --git a/cluster_literal.go b/cluster_literal.go new file mode 100644 index 0000000..cd580f0 --- /dev/null +++ b/cluster_literal.go @@ -0,0 +1,325 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if + it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */ +func BrotliCompareAndPushToQueueLiteral(out []HistogramLiteral, cluster_size []uint32, idx1 uint32, idx2 uint32, max_num_pairs uint, pairs []HistogramPair, num_pairs *uint) { + var is_good_pair bool = false + var p HistogramPair + p.idx2 = 0 + p.idx1 = p.idx2 + p.cost_combo = 0 + p.cost_diff = p.cost_combo + if idx1 == idx2 { + return + } + + if idx2 < idx1 { + var t uint32 = idx2 + idx2 = idx1 + idx1 = t + } + + p.idx1 = idx1 + p.idx2 = idx2 + p.cost_diff = 0.5 * ClusterCostDiff(uint(cluster_size[idx1]), uint(cluster_size[idx2])) + p.cost_diff -= out[idx1].bit_cost_ + p.cost_diff -= out[idx2].bit_cost_ + + if out[idx1].total_count_ == 0 { + p.cost_combo = out[idx2].bit_cost_ + is_good_pair = true + } else if out[idx2].total_count_ == 0 { + p.cost_combo = out[idx1].bit_cost_ + is_good_pair = true + } else { + var threshold float64 + if *num_pairs == 0 { + threshold = 1e99 + } else { + threshold = brotli_max_double(0.0, pairs[0].cost_diff) + } + var combo HistogramLiteral = out[idx1] + var cost_combo float64 + HistogramAddHistogramLiteral(&combo, &out[idx2]) + cost_combo = BrotliPopulationCostLiteral(&combo) + if cost_combo < threshold-p.cost_diff { + p.cost_combo = cost_combo + is_good_pair = true + } + } + + if is_good_pair { + p.cost_diff += p.cost_combo + if *num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p) { + /* Replace the top of the queue if needed. */ + if *num_pairs < max_num_pairs { + pairs[*num_pairs] = pairs[0] + (*num_pairs)++ + } + + pairs[0] = p + } else if *num_pairs < max_num_pairs { + pairs[*num_pairs] = p + (*num_pairs)++ + } + } +} + +func BrotliHistogramCombineLiteral(out []HistogramLiteral, cluster_size []uint32, symbols []uint32, clusters []uint32, pairs []HistogramPair, num_clusters uint, symbols_size uint, max_clusters uint, max_num_pairs uint) uint { + var cost_diff_threshold float64 = 0.0 + var min_cluster_size uint = 1 + var num_pairs uint = 0 + { + /* We maintain a vector of histogram pairs, with the property that the pair + with the maximum bit cost reduction is the first. */ + var idx1 uint + for idx1 = 0; idx1 < num_clusters; idx1++ { + var idx2 uint + for idx2 = idx1 + 1; idx2 < num_clusters; idx2++ { + BrotliCompareAndPushToQueueLiteral(out, cluster_size, clusters[idx1], clusters[idx2], max_num_pairs, pairs[0:], &num_pairs) + } + } + } + + for num_clusters > min_cluster_size { + var best_idx1 uint32 + var best_idx2 uint32 + var i uint + if pairs[0].cost_diff >= cost_diff_threshold { + cost_diff_threshold = 1e99 + min_cluster_size = max_clusters + continue + } + + /* Take the best pair from the top of heap. */ + best_idx1 = pairs[0].idx1 + + best_idx2 = pairs[0].idx2 + HistogramAddHistogramLiteral(&out[best_idx1], &out[best_idx2]) + out[best_idx1].bit_cost_ = pairs[0].cost_combo + cluster_size[best_idx1] += cluster_size[best_idx2] + for i = 0; i < symbols_size; i++ { + if symbols[i] == best_idx2 { + symbols[i] = best_idx1 + } + } + + for i = 0; i < num_clusters; i++ { + if clusters[i] == best_idx2 { + copy(clusters[i:], clusters[i+1:][:num_clusters-i-1]) + break + } + } + + num_clusters-- + { + /* Remove pairs intersecting the just combined best pair. */ + var copy_to_idx uint = 0 + for i = 0; i < num_pairs; i++ { + var p *HistogramPair = &pairs[i] + if p.idx1 == best_idx1 || p.idx2 == best_idx1 || p.idx1 == best_idx2 || p.idx2 == best_idx2 { + /* Remove invalid pair from the queue. */ + continue + } + + if HistogramPairIsLess(&pairs[0], p) { + /* Replace the top of the queue if needed. */ + var front HistogramPair = pairs[0] + pairs[0] = *p + pairs[copy_to_idx] = front + } else { + pairs[copy_to_idx] = *p + } + + copy_to_idx++ + } + + num_pairs = copy_to_idx + } + + /* Push new pairs formed with the combined histogram to the heap. */ + for i = 0; i < num_clusters; i++ { + BrotliCompareAndPushToQueueLiteral(out, cluster_size, best_idx1, clusters[i], max_num_pairs, pairs[0:], &num_pairs) + } + } + + return num_clusters +} + +/* What is the bit cost of moving histogram from cur_symbol to candidate. */ +func BrotliHistogramBitCostDistanceLiteral(histogram *HistogramLiteral, candidate *HistogramLiteral) float64 { + if histogram.total_count_ == 0 { + return 0.0 + } else { + var tmp HistogramLiteral = *histogram + HistogramAddHistogramLiteral(&tmp, candidate) + return BrotliPopulationCostLiteral(&tmp) - candidate.bit_cost_ + } +} + +/* Find the best 'out' histogram for each of the 'in' histograms. + When called, clusters[0..num_clusters) contains the unique values from + symbols[0..in_size), but this property is not preserved in this function. + Note: we assume that out[]->bit_cost_ is already up-to-date. */ +func BrotliHistogramRemapLiteral(in []HistogramLiteral, in_size uint, clusters []uint32, num_clusters uint, out []HistogramLiteral, symbols []uint32) { + var i uint + for i = 0; i < in_size; i++ { + var best_out uint32 + if i == 0 { + best_out = symbols[0] + } else { + best_out = symbols[i-1] + } + var best_bits float64 = BrotliHistogramBitCostDistanceLiteral(&in[i], &out[best_out]) + var j uint + for j = 0; j < num_clusters; j++ { + var cur_bits float64 = BrotliHistogramBitCostDistanceLiteral(&in[i], &out[clusters[j]]) + if cur_bits < best_bits { + best_bits = cur_bits + best_out = clusters[j] + } + } + + symbols[i] = best_out + } + + /* Recompute each out based on raw and symbols. */ + for i = 0; i < num_clusters; i++ { + HistogramClearLiteral(&out[clusters[i]]) + } + + for i = 0; i < in_size; i++ { + HistogramAddHistogramLiteral(&out[symbols[i]], &in[i]) + } +} + +/* Reorders elements of the out[0..length) array and changes values in + symbols[0..length) array in the following way: + * when called, symbols[] contains indexes into out[], and has N unique + values (possibly N < length) + * on return, symbols'[i] = f(symbols[i]) and + out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length, + where f is a bijection between the range of symbols[] and [0..N), and + the first occurrences of values in symbols'[i] come in consecutive + increasing order. + Returns N, the number of unique values in symbols[]. */ + +var BrotliHistogramReindexLiteral_kInvalidIndex uint32 = BROTLI_UINT32_MAX + +func BrotliHistogramReindexLiteral(out []HistogramLiteral, symbols []uint32, length uint) uint { + var new_index []uint32 = make([]uint32, length) + var next_index uint32 + var tmp []HistogramLiteral + var i uint + for i = 0; i < length; i++ { + new_index[i] = BrotliHistogramReindexLiteral_kInvalidIndex + } + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == BrotliHistogramReindexLiteral_kInvalidIndex { + new_index[symbols[i]] = next_index + next_index++ + } + } + + /* TODO: by using idea of "cycle-sort" we can avoid allocation of + tmp and reduce the number of copying by the factor of 2. */ + tmp = make([]HistogramLiteral, next_index) + + next_index = 0 + for i = 0; i < length; i++ { + if new_index[symbols[i]] == next_index { + tmp[next_index] = out[symbols[i]] + next_index++ + } + + symbols[i] = new_index[symbols[i]] + } + + new_index = nil + for i = 0; uint32(i) < next_index; i++ { + out[i] = tmp[i] + } + + tmp = nil + return uint(next_index) +} + +func BrotliClusterHistogramsLiteral(in []HistogramLiteral, in_size uint, max_histograms uint, out []HistogramLiteral, out_size *uint, histogram_symbols []uint32) { + var cluster_size []uint32 = make([]uint32, in_size) + var clusters []uint32 = make([]uint32, in_size) + var num_clusters uint = 0 + var max_input_histograms uint = 64 + var pairs_capacity uint = max_input_histograms * max_input_histograms / 2 + var pairs []HistogramPair = make([]HistogramPair, (pairs_capacity + 1)) + var i uint + + /* For the first pass of clustering, we allow all pairs. */ + for i = 0; i < in_size; i++ { + cluster_size[i] = 1 + } + + for i = 0; i < in_size; i++ { + out[i] = in[i] + out[i].bit_cost_ = BrotliPopulationCostLiteral(&in[i]) + histogram_symbols[i] = uint32(i) + } + + for i = 0; i < in_size; i += max_input_histograms { + var num_to_combine uint = brotli_min_size_t(in_size-i, max_input_histograms) + var num_new_clusters uint + var j uint + for j = 0; j < num_to_combine; j++ { + clusters[num_clusters+j] = uint32(i + j) + } + + num_new_clusters = BrotliHistogramCombineLiteral(out, cluster_size, histogram_symbols[i:], clusters[num_clusters:], pairs, num_to_combine, num_to_combine, max_histograms, pairs_capacity) + num_clusters += num_new_clusters + } + { + /* For the second pass, we limit the total number of histogram pairs. + After this limit is reached, we only keep searching for the best pair. */ + var max_num_pairs uint = brotli_min_size_t(64*num_clusters, (num_clusters/2)*num_clusters) + if pairs_capacity < (max_num_pairs + 1) { + var _new_size uint + if pairs_capacity == 0 { + _new_size = max_num_pairs + 1 + } else { + _new_size = pairs_capacity + } + var new_array []HistogramPair + for _new_size < (max_num_pairs + 1) { + _new_size *= 2 + } + new_array = make([]HistogramPair, _new_size) + if pairs_capacity != 0 { + copy(new_array, pairs[:pairs_capacity]) + } + + pairs = new_array + pairs_capacity = _new_size + } + + /* Collapse similar histograms. */ + num_clusters = BrotliHistogramCombineLiteral(out, cluster_size, histogram_symbols, clusters, pairs, num_clusters, in_size, max_histograms, max_num_pairs) + } + + pairs = nil + cluster_size = nil + + /* Find the optimal map from original histograms to the final ones. */ + BrotliHistogramRemapLiteral(in, in_size, clusters, num_clusters, out, histogram_symbols) + + clusters = nil + + /* Convert the context map to a canonical form. */ + *out_size = BrotliHistogramReindexLiteral(out, histogram_symbols, in_size) +} diff --git a/command.go b/command.go new file mode 100644 index 0000000..6a5616c --- /dev/null +++ b/command.go @@ -0,0 +1,252 @@ +package brotli + +var kInsBase = []uint32{ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 10, + 14, + 18, + 26, + 34, + 50, + 66, + 98, + 130, + 194, + 322, + 578, + 1090, + 2114, + 6210, + 22594, +} + +var kInsExtra = []uint32{ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 14, + 24, +} + +var kCopyBase = []uint32{ + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 14, + 18, + 22, + 30, + 38, + 54, + 70, + 102, + 134, + 198, + 326, + 582, + 1094, + 2118, +} + +var kCopyExtra = []uint32{ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 7, + 8, + 9, + 10, + 24, +} + +func GetInsertLengthCode(insertlen uint) uint16 { + if insertlen < 6 { + return uint16(insertlen) + } else if insertlen < 130 { + var nbits uint32 = Log2FloorNonZero(insertlen-2) - 1 + return uint16((nbits << 1) + uint32((insertlen-2)>>nbits) + 2) + } else if insertlen < 2114 { + return uint16(Log2FloorNonZero(insertlen-66) + 10) + } else if insertlen < 6210 { + return 21 + } else if insertlen < 22594 { + return 22 + } else { + return 23 + } +} + +func GetCopyLengthCode(copylen uint) uint16 { + if copylen < 10 { + return uint16(copylen - 2) + } else if copylen < 134 { + var nbits uint32 = Log2FloorNonZero(copylen-6) - 1 + return uint16((nbits << 1) + uint32((copylen-6)>>nbits) + 4) + } else if copylen < 2118 { + return uint16(Log2FloorNonZero(copylen-70) + 12) + } else { + return 23 + } +} + +func CombineLengthCodes(inscode uint16, copycode uint16, use_last_distance bool) uint16 { + var bits64 uint16 = uint16(copycode&0x7 | (inscode&0x7)<<3) + if use_last_distance && inscode < 8 && copycode < 16 { + if copycode < 8 { + return bits64 + } else { + return bits64 | 64 + } + } else { + /* Specification: 5 Encoding of ... (last table) */ + /* offset = 2 * index, where index is in range [0..8] */ + var offset uint32 = 2 * ((uint32(copycode) >> 3) + 3*(uint32(inscode)>>3)) + + /* All values in specification are K * 64, + where K = [2, 3, 6, 4, 5, 8, 7, 9, 10], + i + 1 = [1, 2, 3, 4, 5, 6, 7, 8, 9], + K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1, 2] = D. + All values in D require only 2 bits to encode. + Magic constant is shifted 6 bits left, to avoid final multiplication. */ + offset = (offset << 5) + 0x40 + ((0x520D40 >> offset) & 0xC0) + + return uint16(offset | uint32(bits64)) + } +} + +func GetLengthCode(insertlen uint, copylen uint, use_last_distance bool, code *uint16) { + var inscode uint16 = GetInsertLengthCode(insertlen) + var copycode uint16 = GetCopyLengthCode(copylen) + *code = CombineLengthCodes(inscode, copycode, use_last_distance) +} + +func GetInsertBase(inscode uint16) uint32 { + return kInsBase[inscode] +} + +func GetInsertExtra(inscode uint16) uint32 { + return kInsExtra[inscode] +} + +func GetCopyBase(copycode uint16) uint32 { + return kCopyBase[copycode] +} + +func GetCopyExtra(copycode uint16) uint32 { + return kCopyExtra[copycode] +} + +type Command struct { + insert_len_ uint32 + copy_len_ uint32 + dist_extra_ uint32 + cmd_prefix_ uint16 + dist_prefix_ uint16 +} + +/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */ +func InitCommand(self *Command, dist *BrotliDistanceParams, insertlen uint, copylen uint, copylen_code_delta int, distance_code uint) { + /* Don't rely on signed int representation, use honest casts. */ + var delta uint32 = uint32(byte(int8(copylen_code_delta))) + self.insert_len_ = uint32(insertlen) + self.copy_len_ = uint32(uint32(copylen) | delta<<25) + + /* The distance prefix and extra bits are stored in this Command as if + npostfix and ndirect were 0, they are only recomputed later after the + clustering if needed. */ + PrefixEncodeCopyDistance(distance_code, uint(dist.num_direct_distance_codes), uint(dist.distance_postfix_bits), &self.dist_prefix_, &self.dist_extra_) + + GetLengthCode(insertlen, uint(int(copylen)+copylen_code_delta), (self.dist_prefix_&0x3FF == 0), &self.cmd_prefix_) +} + +func InitInsertCommand(self *Command, insertlen uint) { + self.insert_len_ = uint32(insertlen) + self.copy_len_ = 4 << 25 + self.dist_extra_ = 0 + self.dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES + GetLengthCode(insertlen, 4, false, &self.cmd_prefix_) +} + +func CommandRestoreDistanceCode(self *Command, dist *BrotliDistanceParams) uint32 { + if uint32(self.dist_prefix_&0x3FF) < BROTLI_NUM_DISTANCE_SHORT_CODES+dist.num_direct_distance_codes { + return uint32(self.dist_prefix_) & 0x3FF + } else { + var dcode uint32 = uint32(self.dist_prefix_) & 0x3FF + var nbits uint32 = uint32(self.dist_prefix_) >> 10 + var extra uint32 = self.dist_extra_ + var postfix_mask uint32 = (1 << dist.distance_postfix_bits) - 1 + var hcode uint32 = (dcode - dist.num_direct_distance_codes - BROTLI_NUM_DISTANCE_SHORT_CODES) >> dist.distance_postfix_bits + var lcode uint32 = (dcode - dist.num_direct_distance_codes - BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask + var offset uint32 = ((2 + (hcode & 1)) << nbits) - 4 + return ((offset + extra) << dist.distance_postfix_bits) + lcode + dist.num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES + } +} + +func CommandDistanceContext(self *Command) uint32 { + var r uint32 = uint32(self.cmd_prefix_) >> 6 + var c uint32 = uint32(self.cmd_prefix_) & 7 + if (r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2) { + return c + } + + return 3 +} + +func CommandCopyLen(self *Command) uint32 { + return self.copy_len_ & 0x1FFFFFF +} + +func CommandCopyLenCode(self *Command) uint32 { + var modifier uint32 = self.copy_len_ >> 25 + var delta int32 = int32(int8(byte(modifier | (modifier&0x40)<<1))) + return uint32(int32(self.copy_len_&0x1FFFFFF) + delta) +} diff --git a/compress_fragment.go b/compress_fragment.go new file mode 100644 index 0000000..6569dff --- /dev/null +++ b/compress_fragment.go @@ -0,0 +1,846 @@ +package brotli + +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function for fast encoding of an input fragment, independently from the input + history. This function uses one-pass processing: when we find a backward + match, we immediately emit the corresponding command and literal codes to + the bit stream. + + Adapted from the CompressFragment() function in + https://github.com/google/snappy/blob/master/snappy.cc */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function for fast encoding of an input fragment, independently from the input + history. This function uses one-pass processing: when we find a backward + match, we immediately emit the corresponding command and literal codes to + the bit stream. */ + +/* Compresses "input" string to the "*storage" buffer as one or more complete + meta-blocks, and updates the "*storage_ix" bit position. + + If "is_last" is 1, emits an additional empty last meta-block. + + "cmd_depth" and "cmd_bits" contain the command and distance prefix codes + (see comment in encode.h) used for the encoding of this input fragment. + If "is_last" is 0, they are updated to reflect the statistics + of this input fragment, to be used for the encoding of the next fragment. + + "*cmd_code_numbits" is the number of bits of the compressed representation + of the command and distance prefix codes, and "cmd_code" is an array of + at least "(*cmd_code_numbits + 7) >> 3" size that contains the compressed + command and distance prefix codes. If "is_last" is 0, these are also + updated to represent the updated "cmd_depth" and "cmd_bits". + + REQUIRES: "input_size" is greater than zero, or "is_last" is 1. + REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24). + REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. + REQUIRES: "table_size" is an odd (9, 11, 13, 15) power of two + OUTPUT: maximal copy distance <= |input_size| + OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */ +func Hash5(p []byte, shift uint) uint32 { + var h uint64 = (BROTLI_UNALIGNED_LOAD64LE(p) << 24) * uint64(kHashMul32_a) + return uint32(h >> shift) +} + +func HashBytesAtOffset5(v uint64, offset int, shift uint) uint32 { + assert(offset >= 0) + assert(offset <= 3) + { + var h uint64 = ((v >> uint(8*offset)) << 24) * uint64(kHashMul32_a) + return uint32(h >> shift) + } +} + +func IsMatch5(p1 []byte, p2 []byte) bool { + var i int + for i = 0; i < 5; i++ { + if p1[i] != p2[i] { + return false + } + } + + return true +} + +/* Builds a literal prefix code into "depths" and "bits" based on the statistics + of the "input" string and stores it into the bit stream. + Note that the prefix code here is built from the pre-LZ77 input, therefore + we can only approximate the statistics of the actual literal stream. + Moreover, for long inputs we build a histogram from a sample of the input + and thus have to assign a non-zero depth for each literal. + Returns estimated compression ratio millibytes/char for encoding given input + with generated code. */ +func BuildAndStoreLiteralPrefixCode(input []byte, input_size uint, depths []byte, bits []uint16, storage_ix *uint, storage []byte) uint { + var histogram = [256]uint32{0} + var histogram_total uint + var i uint + if input_size < 1<<15 { + for i = 0; i < input_size; i++ { + histogram[input[i]]++ + } + + histogram_total = input_size + for i = 0; i < 256; i++ { + /* We weigh the first 11 samples with weight 3 to account for the + balancing effect of the LZ77 phase on the histogram. */ + var adjust uint32 = 2 * brotli_min_uint32_t(histogram[i], 11) + histogram[i] += adjust + histogram_total += uint(adjust) + } + } else { + var kSampleRate uint = 29 + for i = 0; i < input_size; i += kSampleRate { + histogram[input[i]]++ + } + + histogram_total = (input_size + kSampleRate - 1) / kSampleRate + for i = 0; i < 256; i++ { + /* We add 1 to each population count to avoid 0 bit depths (since this is + only a sample and we don't know if the symbol appears or not), and we + weigh the first 11 samples with weight 3 to account for the balancing + effect of the LZ77 phase on the histogram (more frequent symbols are + more likely to be in backward references instead as literals). */ + var adjust uint32 = 1 + 2*brotli_min_uint32_t(histogram[i], 11) + histogram[i] += adjust + histogram_total += uint(adjust) + } + } + + BrotliBuildAndStoreHuffmanTreeFast(histogram[:], histogram_total, /* max_bits = */ + 8, depths, bits, storage_ix, storage) + { + var literal_ratio uint = 0 + for i = 0; i < 256; i++ { + if histogram[i] != 0 { + literal_ratio += uint(histogram[i] * uint32(depths[i])) + } + } + + /* Estimated encoding ratio, millibytes per symbol. */ + return (literal_ratio * 125) / histogram_total + } +} + +/* Builds a command and distance prefix code (each 64 symbols) into "depth" and + "bits" based on "histogram" and stores it into the bit stream. */ +func BuildAndStoreCommandPrefixCode1(histogram []uint32, depth []byte, bits []uint16, storage_ix *uint, storage []byte) { + var tree [129]HuffmanTree + var cmd_depth = [BROTLI_NUM_COMMAND_SYMBOLS]byte{0} + /* Tree size for building a tree over 64 symbols is 2 * 64 + 1. */ + + var cmd_bits [64]uint16 + + BrotliCreateHuffmanTree(histogram, 64, 15, tree[:], depth) + BrotliCreateHuffmanTree(histogram[64:], 64, 14, tree[:], depth[64:]) + + /* We have to jump through a few hoops here in order to compute + the command bits because the symbols are in a different order than in + the full alphabet. This looks complicated, but having the symbols + in this order in the command bits saves a few branches in the Emit* + functions. */ + copy(cmd_depth[:], depth[:24]) + + copy(cmd_depth[24:][:], depth[40:][:8]) + copy(cmd_depth[32:][:], depth[24:][:8]) + copy(cmd_depth[40:][:], depth[48:][:8]) + copy(cmd_depth[48:][:], depth[32:][:8]) + copy(cmd_depth[56:][:], depth[56:][:8]) + BrotliConvertBitDepthsToSymbols(cmd_depth[:], 64, cmd_bits[:]) + copy(bits, cmd_bits[:24]) + copy(bits[24:], cmd_bits[32:][:8]) + copy(bits[32:], cmd_bits[48:][:8]) + copy(bits[40:], cmd_bits[24:][:8]) + copy(bits[48:], cmd_bits[40:][:8]) + copy(bits[56:], cmd_bits[56:][:8]) + BrotliConvertBitDepthsToSymbols(depth[64:], 64, bits[64:]) + { + /* Create the bit length array for the full command alphabet. */ + var i uint + for i := 0; i < int(64); i++ { + cmd_depth[i] = 0 + } /* only 64 first values were used */ + copy(cmd_depth[:], depth[:8]) + copy(cmd_depth[64:][:], depth[8:][:8]) + copy(cmd_depth[128:][:], depth[16:][:8]) + copy(cmd_depth[192:][:], depth[24:][:8]) + copy(cmd_depth[384:][:], depth[32:][:8]) + for i = 0; i < 8; i++ { + cmd_depth[128+8*i] = depth[40+i] + cmd_depth[256+8*i] = depth[48+i] + cmd_depth[448+8*i] = depth[56+i] + } + + BrotliStoreHuffmanTree(cmd_depth[:], BROTLI_NUM_COMMAND_SYMBOLS, tree[:], storage_ix, storage) + } + + BrotliStoreHuffmanTree(depth[64:], 64, tree[:], storage_ix, storage) +} + +/* REQUIRES: insertlen < 6210 */ +func EmitInsertLen1(insertlen uint, depth []byte, bits []uint16, histo []uint32, storage_ix *uint, storage []byte) { + if insertlen < 6 { + var code uint = insertlen + 40 + BrotliWriteBits(uint(depth[code]), uint64(bits[code]), storage_ix, storage) + histo[code]++ + } else if insertlen < 130 { + var tail uint = insertlen - 2 + var nbits uint32 = Log2FloorNonZero(tail) - 1 + var prefix uint = tail >> nbits + var inscode uint = uint((nbits << 1) + uint32(prefix) + 42) + BrotliWriteBits(uint(depth[inscode]), uint64(bits[inscode]), storage_ix, storage) + BrotliWriteBits(uint(nbits), uint64(tail)-(uint64(prefix)<> nbits + var code uint = uint((nbits << 1) + uint32(prefix) + 20) + BrotliWriteBits(uint(depth[code]), uint64(bits[code]), storage_ix, storage) + BrotliWriteBits(uint(nbits), uint64(tail)-(uint64(prefix)<> nbits + var code uint = uint((nbits << 1) + uint32(prefix) + 4) + BrotliWriteBits(uint(depth[code]), uint64(bits[code]), storage_ix, storage) + BrotliWriteBits(uint(nbits), uint64(tail)-(uint64(prefix)<> 5) + 30 + BrotliWriteBits(uint(depth[code]), uint64(bits[code]), storage_ix, storage) + BrotliWriteBits(5, uint64(tail)&31, storage_ix, storage) + BrotliWriteBits(uint(depth[64]), uint64(bits[64]), storage_ix, storage) + histo[code]++ + histo[64]++ + } else if copylen < 2120 { + var tail uint = copylen - 72 + var nbits uint32 = Log2FloorNonZero(tail) + var code uint = uint(nbits + 28) + BrotliWriteBits(uint(depth[code]), uint64(bits[code]), storage_ix, storage) + BrotliWriteBits(uint(nbits), uint64(tail)-(uint64(uint(1))<> nbits) & 1 + var offset uint = (2 + prefix) << nbits + var distcode uint = uint(2*(nbits-1) + uint32(prefix) + 80) + BrotliWriteBits(uint(depth[distcode]), uint64(bits[distcode]), storage_ix, storage) + BrotliWriteBits(uint(nbits), uint64(d)-uint64(offset), storage_ix, storage) + histo[distcode]++ +} + +func EmitLiterals(input []byte, len uint, depth []byte, bits []uint16, storage_ix *uint, storage []byte) { + var j uint + for j = 0; j < len; j++ { + var lit byte = input[j] + BrotliWriteBits(uint(depth[lit]), uint64(bits[lit]), storage_ix, storage) + } +} + +/* REQUIRES: len <= 1 << 24. */ +func BrotliStoreMetaBlockHeader1(len uint, is_uncompressed bool, storage_ix *uint, storage []byte) { + var nibbles uint = 6 + + /* ISLAST */ + BrotliWriteBits(1, 0, storage_ix, storage) + + if len <= 1<<16 { + nibbles = 4 + } else if len <= 1<<20 { + nibbles = 5 + } + + BrotliWriteBits(2, uint64(nibbles)-4, storage_ix, storage) + BrotliWriteBits(nibbles*4, uint64(len)-1, storage_ix, storage) + + /* ISUNCOMPRESSED */ + BrotliWriteSingleBit(is_uncompressed, storage_ix, storage) +} + +func UpdateBits(n_bits uint, bits uint32, pos uint, array []byte) { + for n_bits > 0 { + var byte_pos uint = pos >> 3 + var n_unchanged_bits uint = pos & 7 + var n_changed_bits uint = brotli_min_size_t(n_bits, 8-n_unchanged_bits) + var total_bits uint = n_unchanged_bits + n_changed_bits + var mask uint32 = (^((1 << total_bits) - 1)) | ((1 << n_unchanged_bits) - 1) + var unchanged_bits uint32 = uint32(array[byte_pos]) & mask + var changed_bits uint32 = bits & ((1 << n_changed_bits) - 1) + array[byte_pos] = byte(changed_bits<>= n_changed_bits + pos += n_changed_bits + } +} + +func RewindBitPosition1(new_storage_ix uint, storage_ix *uint, storage []byte) { + var bitpos uint = new_storage_ix & 7 + var mask uint = (1 << bitpos) - 1 + storage[new_storage_ix>>3] &= byte(mask) + *storage_ix = new_storage_ix +} + +var ShouldMergeBlock_kSampleRate uint = 43 + +func ShouldMergeBlock(data []byte, len uint, depths []byte) bool { + var histo = [256]uint{0} + var i uint + for i = 0; i < len; i += ShouldMergeBlock_kSampleRate { + histo[data[i]]++ + } + { + var total uint = (len + ShouldMergeBlock_kSampleRate - 1) / ShouldMergeBlock_kSampleRate + var r float64 = (FastLog2(total)+0.5)*float64(total) + 200 + for i = 0; i < 256; i++ { + r -= float64(histo[i]) * (float64(depths[i]) + FastLog2(histo[i])) + } + + return r >= 0.0 + } +} + +func ShouldUseUncompressedMode(metablock_start []byte, next_emit []byte, insertlen uint, literal_ratio uint) bool { + var compressed uint = uint(-cap(next_emit) + cap(metablock_start)) + if compressed*50 > insertlen { + return false + } else { + return literal_ratio > 980 + } +} + +func EmitUncompressedMetaBlock1(begin []byte, end []byte, storage_ix_start uint, storage_ix *uint, storage []byte) { + var len uint = uint(-cap(end) + cap(begin)) + RewindBitPosition1(storage_ix_start, storage_ix, storage) + BrotliStoreMetaBlockHeader1(uint(len), true, storage_ix, storage) + *storage_ix = (*storage_ix + 7) &^ 7 + copy(storage[*storage_ix>>3:], begin[:len]) + *storage_ix += uint(len << 3) + storage[*storage_ix>>3] = 0 +} + +var kCmdHistoSeed = [128]uint32{ + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, +} + +var BrotliCompressFragmentFastImpl_kFirstBlockSize uint = 3 << 15 +var BrotliCompressFragmentFastImpl_kMergeBlockSize uint = 1 << 16 + +func BrotliCompressFragmentFastImpl(in []byte, input_size uint, is_last bool, table []int, table_bits uint, cmd_depth []byte, cmd_bits []uint16, cmd_code_numbits *uint, cmd_code []byte, storage_ix *uint, storage []byte) { + var cmd_histo [128]uint32 + var ip_end int + var next_emit int = 0 + var base_ip int = 0 + var input int = 0 + var kInputMarginBytes uint = BROTLI_WINDOW_GAP + var kMinMatchLen uint = 5 + var metablock_start int = input + var block_size uint = brotli_min_size_t(input_size, BrotliCompressFragmentFastImpl_kFirstBlockSize) + var total_block_size uint = block_size + var mlen_storage_ix uint = *storage_ix + 3 + var lit_depth [256]byte + var lit_bits [256]uint16 + var literal_ratio uint + var ip int + var last_distance int + var shift uint = 64 - table_bits + + /* "next_emit" is a pointer to the first byte that is not covered by a + previous copy. Bytes between "next_emit" and the start of the next copy or + the end of the input will be emitted as literal bytes. */ + + /* Save the start of the first block for position and distance computations. + */ + + /* Save the bit position of the MLEN field of the meta-block header, so that + we can update it later if we decide to extend this meta-block. */ + BrotliStoreMetaBlockHeader1(block_size, false, storage_ix, storage) + + /* No block splits, no contexts. */ + BrotliWriteBits(13, 0, storage_ix, storage) + + literal_ratio = BuildAndStoreLiteralPrefixCode(in[input:], block_size, lit_depth[:], lit_bits[:], storage_ix, storage) + { + /* Store the pre-compressed command and distance prefix codes. */ + var i uint + for i = 0; i+7 < *cmd_code_numbits; i += 8 { + BrotliWriteBits(8, uint64(cmd_code[i>>3]), storage_ix, storage) + } + } + + BrotliWriteBits(*cmd_code_numbits&7, uint64(cmd_code[*cmd_code_numbits>>3]), storage_ix, storage) + + /* Initialize the command and distance histograms. We will gather + statistics of command and distance codes during the processing + of this block and use it to update the command and distance + prefix codes for the next block. */ +emit_commands: + copy(cmd_histo[:], kCmdHistoSeed[:]) + + /* "ip" is the input pointer. */ + ip = input + + last_distance = -1 + ip_end = int(uint(input) + block_size) + + if block_size >= kInputMarginBytes { + var len_limit uint = brotli_min_size_t(block_size-kMinMatchLen, input_size-kInputMarginBytes) + var ip_limit int = int(uint(input) + len_limit) + /* For the last block, we need to keep a 16 bytes margin so that we can be + sure that all distances are at most window size - 16. + For all other blocks, we only need to keep a margin of 5 bytes so that + we don't go over the block size with a copy. */ + + var next_hash uint32 + ip++ + for next_hash = Hash5(in[ip:], shift); ; { + var skip uint32 = 32 + var next_ip int = ip + /* Step 1: Scan forward in the input looking for a 5-byte-long match. + If we get close to exhausting the input then goto emit_remainder. + + Heuristic match skipping: If 32 bytes are scanned with no matches + found, start looking only at every other byte. If 32 more bytes are + scanned, look at every third byte, etc.. When a match is found, + immediately go back to looking at every byte. This is a small loss + (~5% performance, ~0.1% density) for compressible data due to more + bookkeeping, but for non-compressible data (such as JPEG) it's a huge + win since the compressor quickly "realizes" the data is incompressible + and doesn't bother looking for matches everywhere. + + The "skip" variable keeps track of how many bytes there are since the + last match; dividing it by 32 (i.e. right-shifting by five) gives the + number of bytes to move ahead for each iteration. */ + + var candidate int + assert(next_emit < ip) + + trawl: + for { + var hash uint32 = next_hash + var bytes_between_hash_lookups uint32 = skip >> 5 + skip++ + assert(hash == Hash5(in[next_ip:], shift)) + ip = next_ip + next_ip = int(uint32(ip) + bytes_between_hash_lookups) + if next_ip > ip_limit { + goto emit_remainder + } + + next_hash = Hash5(in[next_ip:], shift) + candidate = ip - last_distance + if IsMatch5(in[ip:], in[candidate:]) { + if candidate < ip { + table[hash] = int(ip - base_ip) + break + } + } + + candidate = base_ip + table[hash] + assert(candidate >= base_ip) + assert(candidate < ip) + + table[hash] = int(ip - base_ip) + if !(!IsMatch5(in[ip:], in[candidate:])) { + break + } + } + + /* Check copy distance. If candidate is not feasible, continue search. + Checking is done outside of hot loop to reduce overhead. */ + if ip-candidate > MAX_DISTANCE { + goto trawl + } + + /* Step 2: Emit the found match together with the literal bytes from + "next_emit" to the bit stream, and then see if we can find a next match + immediately afterwards. Repeat until we find no match for the input + without emitting some literal bytes. */ + { + var base int = ip + /* > 0 */ + var matched uint = 5 + FindMatchLengthWithLimit(in[candidate+5:], in[ip+5:], uint(ip_end-ip)-5) + var distance int = int(base - candidate) + /* We have a 5-byte match at ip, and we need to emit bytes in + [next_emit, ip). */ + + var insert uint = uint(base - next_emit) + ip += int(matched) + if insert < 6210 { + EmitInsertLen1(insert, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + } else if ShouldUseUncompressedMode(in[metablock_start:], in[next_emit:], insert, literal_ratio) { + EmitUncompressedMetaBlock1(in[metablock_start:], in[base:], mlen_storage_ix-3, storage_ix, storage) + input_size -= uint(base - input) + input = base + next_emit = input + goto next_block + } else { + EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + } + + EmitLiterals(in[next_emit:], insert, lit_depth[:], lit_bits[:], storage_ix, storage) + if distance == last_distance { + BrotliWriteBits(uint(cmd_depth[64]), uint64(cmd_bits[64]), storage_ix, storage) + cmd_histo[64]++ + } else { + EmitDistance1(uint(distance), cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + last_distance = distance + } + + EmitCopyLenLastDistance1(matched, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + + next_emit = ip + if ip >= ip_limit { + goto emit_remainder + } + + /* We could immediately start working at ip now, but to improve + compression we first update "table" with the hashes of some positions + within the last copy. */ + { + var input_bytes uint64 = BROTLI_UNALIGNED_LOAD64LE(in[ip-3:]) + var prev_hash uint32 = HashBytesAtOffset5(input_bytes, 0, shift) + var cur_hash uint32 = HashBytesAtOffset5(input_bytes, 3, shift) + table[prev_hash] = int(ip - base_ip - 3) + prev_hash = HashBytesAtOffset5(input_bytes, 1, shift) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset5(input_bytes, 2, shift) + table[prev_hash] = int(ip - base_ip - 1) + + candidate = base_ip + table[cur_hash] + table[cur_hash] = int(ip - base_ip) + } + } + + for IsMatch5(in[ip:], in[candidate:]) { + var base int = ip + /* We have a 5-byte match at ip, and no need to emit any literal bytes + prior to ip. */ + + var matched uint = 5 + FindMatchLengthWithLimit(in[candidate+5:], in[ip+5:], uint(ip_end-ip)-5) + if ip-candidate > MAX_DISTANCE { + break + } + ip += int(matched) + last_distance = int(base - candidate) /* > 0 */ + EmitCopyLen1(matched, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + EmitDistance1(uint(last_distance), cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + + next_emit = ip + if ip >= ip_limit { + goto emit_remainder + } + + /* We could immediately start working at ip now, but to improve + compression we first update "table" with the hashes of some positions + within the last copy. */ + { + var input_bytes uint64 = BROTLI_UNALIGNED_LOAD64LE(in[ip-3:]) + var prev_hash uint32 = HashBytesAtOffset5(input_bytes, 0, shift) + var cur_hash uint32 = HashBytesAtOffset5(input_bytes, 3, shift) + table[prev_hash] = int(ip - base_ip - 3) + prev_hash = HashBytesAtOffset5(input_bytes, 1, shift) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset5(input_bytes, 2, shift) + table[prev_hash] = int(ip - base_ip - 1) + + candidate = base_ip + table[cur_hash] + table[cur_hash] = int(ip - base_ip) + } + } + + ip++ + next_hash = Hash5(in[ip:], shift) + } + } + +emit_remainder: + assert(next_emit <= ip_end) + input += int(block_size) + input_size -= block_size + block_size = brotli_min_size_t(input_size, BrotliCompressFragmentFastImpl_kMergeBlockSize) + + /* Decide if we want to continue this meta-block instead of emitting the + last insert-only command. */ + if input_size > 0 && total_block_size+block_size <= 1<<20 && ShouldMergeBlock(in[input:], block_size, lit_depth[:]) { + assert(total_block_size > 1<<16) + + /* Update the size of the current meta-block and continue emitting commands. + We can do this because the current size and the new size both have 5 + nibbles. */ + total_block_size += block_size + + UpdateBits(20, uint32(total_block_size-1), mlen_storage_ix, storage) + goto emit_commands + } + + /* Emit the remaining bytes as literals. */ + if next_emit < ip_end { + var insert uint = uint(ip_end - next_emit) + if insert < 6210 { + EmitInsertLen1(insert, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + EmitLiterals(in[next_emit:], insert, lit_depth[:], lit_bits[:], storage_ix, storage) + } else if ShouldUseUncompressedMode(in[metablock_start:], in[next_emit:], insert, literal_ratio) { + EmitUncompressedMetaBlock1(in[metablock_start:], in[ip_end:], mlen_storage_ix-3, storage_ix, storage) + } else { + EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo[:], storage_ix, storage) + EmitLiterals(in[next_emit:], insert, lit_depth[:], lit_bits[:], storage_ix, storage) + } + } + + next_emit = ip_end + + /* If we have more data, write a new meta-block header and prefix codes and + then continue emitting commands. */ +next_block: + if input_size > 0 { + metablock_start = input + block_size = brotli_min_size_t(input_size, BrotliCompressFragmentFastImpl_kFirstBlockSize) + total_block_size = block_size + + /* Save the bit position of the MLEN field of the meta-block header, so that + we can update it later if we decide to extend this meta-block. */ + mlen_storage_ix = *storage_ix + 3 + + BrotliStoreMetaBlockHeader1(block_size, false, storage_ix, storage) + + /* No block splits, no contexts. */ + BrotliWriteBits(13, 0, storage_ix, storage) + + literal_ratio = BuildAndStoreLiteralPrefixCode(in[input:], block_size, lit_depth[:], lit_bits[:], storage_ix, storage) + BuildAndStoreCommandPrefixCode1(cmd_histo[:], cmd_depth, cmd_bits, storage_ix, storage) + goto emit_commands + } + + if !is_last { + /* If this is not the last block, update the command and distance prefix + codes for the next block and store the compressed forms. */ + cmd_code[0] = 0 + + *cmd_code_numbits = 0 + BuildAndStoreCommandPrefixCode1(cmd_histo[:], cmd_depth, cmd_bits, cmd_code_numbits, cmd_code) + } +} + +func BrotliCompressFragmentFast(input []byte, input_size uint, is_last bool, table []int, table_size uint, cmd_depth []byte, cmd_bits []uint16, cmd_code_numbits *uint, cmd_code []byte, storage_ix *uint, storage []byte) { + var initial_storage_ix uint = *storage_ix + var table_bits uint = uint(Log2FloorNonZero(table_size)) + + if input_size == 0 { + assert(is_last) + BrotliWriteBits(1, 1, storage_ix, storage) /* islast */ + BrotliWriteBits(1, 1, storage_ix, storage) /* isempty */ + *storage_ix = (*storage_ix + 7) &^ 7 + return + } + + BrotliCompressFragmentFastImpl(input, input_size, is_last, table, table_bits, cmd_depth, cmd_bits, cmd_code_numbits, cmd_code, storage_ix, storage) + + /* If output is larger than single uncompressed block, rewrite it. */ + if *storage_ix-initial_storage_ix > 31+(input_size<<3) { + EmitUncompressedMetaBlock1(input, input[input_size:], initial_storage_ix, storage_ix, storage) + } + + if is_last { + BrotliWriteBits(1, 1, storage_ix, storage) /* islast */ + BrotliWriteBits(1, 1, storage_ix, storage) /* isempty */ + *storage_ix = (*storage_ix + 7) &^ 7 + } +} diff --git a/compress_fragment_common.go b/compress_fragment_common.go new file mode 100644 index 0000000..9df6bbd --- /dev/null +++ b/compress_fragment_common.go @@ -0,0 +1,24 @@ +package brotli + +/* Compresses "input" string to the "*storage" buffer as one or more complete + meta-blocks, and updates the "*storage_ix" bit position. + + If "is_last" is 1, emits an additional empty last meta-block. + + REQUIRES: "input_size" is greater than zero, or "is_last" is 1. + REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24). + REQUIRES: "command_buf" and "literal_buf" point to at least + kCompressFragmentTwoPassBlockSize long arrays. + REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. + REQUIRES: "table_size" is a power of two + OUTPUT: maximal copy distance <= |input_size| + OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */ +const MAX_DISTANCE = 262128 + +/* kHashMul32_a multiplier has these properties: + * The multiplier must be odd. Otherwise we may lose the highest bit. + * No long streaks of ones or zeros. + * There is no effort to ensure that it is a prime, the oddity is enough + for this use. + * The number has been tuned heuristically against compression benchmarks. */ +var kHashMul32_a uint32 = 0x1E35A7BD diff --git a/compress_fragment_two_pass.go b/compress_fragment_two_pass.go new file mode 100644 index 0000000..87d4095 --- /dev/null +++ b/compress_fragment_two_pass.go @@ -0,0 +1,744 @@ +package brotli + +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function for fast encoding of an input fragment, independently from the input + history. This function uses two-pass processing: in the first pass we save + the found backward matches and literal bytes into a buffer, and in the + second pass we emit them into the bit stream using prefix codes built based + on the actual command and literal byte histograms. */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function for fast encoding of an input fragment, independently from the input + history. This function uses two-pass processing: in the first pass we save + the found backward matches and literal bytes into a buffer, and in the + second pass we emit them into the bit stream using prefix codes built based + on the actual command and literal byte histograms. */ +var kCompressFragmentTwoPassBlockSize uint = 1 << 17 + +func Hash1(p []byte, shift uint, length uint) uint32 { + var h uint64 = (BROTLI_UNALIGNED_LOAD64LE(p) << ((8 - length) * 8)) * uint64(kHashMul32_a) + return uint32(h >> shift) +} + +func HashBytesAtOffset(v uint64, offset uint, shift uint, length uint) uint32 { + assert(offset <= 8-length) + { + var h uint64 = ((v >> (8 * offset)) << ((8 - length) * 8)) * uint64(kHashMul32_a) + return uint32(h >> shift) + } +} + +func IsMatch1(p1 []byte, p2 []byte, length uint) bool { + var i uint + for i = 0; i < length && i < 6; i++ { + if p1[i] != p2[i] { + return false + } + } + + return true +} + +/* Builds a command and distance prefix code (each 64 symbols) into "depth" and + "bits" based on "histogram" and stores it into the bit stream. */ +func BuildAndStoreCommandPrefixCode(histogram []uint32, depth []byte, bits []uint16, storage_ix *uint, storage []byte) { + var tree [129]HuffmanTree + var cmd_depth = [BROTLI_NUM_COMMAND_SYMBOLS]byte{0} + /* Tree size for building a tree over 64 symbols is 2 * 64 + 1. */ + + var cmd_bits [64]uint16 + BrotliCreateHuffmanTree(histogram, 64, 15, tree[:], depth) + BrotliCreateHuffmanTree(histogram[64:], 64, 14, tree[:], depth[64:]) + + /* We have to jump through a few hoops here in order to compute + the command bits because the symbols are in a different order than in + the full alphabet. This looks complicated, but having the symbols + in this order in the command bits saves a few branches in the Emit* + functions. */ + copy(cmd_depth[:], depth[24:][:24]) + + copy(cmd_depth[24:][:], depth[:8]) + copy(cmd_depth[32:][:], depth[48:][:8]) + copy(cmd_depth[40:][:], depth[8:][:8]) + copy(cmd_depth[48:][:], depth[56:][:8]) + copy(cmd_depth[56:][:], depth[16:][:8]) + BrotliConvertBitDepthsToSymbols(cmd_depth[:], 64, cmd_bits[:]) + copy(bits, cmd_bits[24:][:8]) + copy(bits[8:], cmd_bits[40:][:8]) + copy(bits[16:], cmd_bits[56:][:8]) + copy(bits[24:], cmd_bits[:24]) + copy(bits[48:], cmd_bits[32:][:8]) + copy(bits[56:], cmd_bits[48:][:8]) + BrotliConvertBitDepthsToSymbols(depth[64:], 64, bits[64:]) + { + /* Create the bit length array for the full command alphabet. */ + var i uint + for i := 0; i < int(64); i++ { + cmd_depth[i] = 0 + } /* only 64 first values were used */ + copy(cmd_depth[:], depth[24:][:8]) + copy(cmd_depth[64:][:], depth[32:][:8]) + copy(cmd_depth[128:][:], depth[40:][:8]) + copy(cmd_depth[192:][:], depth[48:][:8]) + copy(cmd_depth[384:][:], depth[56:][:8]) + for i = 0; i < 8; i++ { + cmd_depth[128+8*i] = depth[i] + cmd_depth[256+8*i] = depth[8+i] + cmd_depth[448+8*i] = depth[16+i] + } + + BrotliStoreHuffmanTree(cmd_depth[:], BROTLI_NUM_COMMAND_SYMBOLS, tree[:], storage_ix, storage) + } + + BrotliStoreHuffmanTree(depth[64:], 64, tree[:], storage_ix, storage) +} + +func EmitInsertLen(insertlen uint32, commands *[]uint32) { + if insertlen < 6 { + (*commands)[0] = insertlen + } else if insertlen < 130 { + var tail uint32 = insertlen - 2 + var nbits uint32 = Log2FloorNonZero(uint(tail)) - 1 + var prefix uint32 = tail >> nbits + var inscode uint32 = (nbits << 1) + prefix + 2 + var extra uint32 = tail - (prefix << nbits) + (*commands)[0] = inscode | extra<<8 + } else if insertlen < 2114 { + var tail uint32 = insertlen - 66 + var nbits uint32 = Log2FloorNonZero(uint(tail)) + var code uint32 = nbits + 10 + var extra uint32 = tail - (1 << nbits) + (*commands)[0] = code | extra<<8 + } else if insertlen < 6210 { + var extra uint32 = insertlen - 2114 + (*commands)[0] = 21 | extra<<8 + } else if insertlen < 22594 { + var extra uint32 = insertlen - 6210 + (*commands)[0] = 22 | extra<<8 + } else { + var extra uint32 = insertlen - 22594 + (*commands)[0] = 23 | extra<<8 + } + + *commands = (*commands)[1:] +} + +func EmitCopyLen(copylen uint, commands *[]uint32) { + if copylen < 10 { + (*commands)[0] = uint32(copylen + 38) + } else if copylen < 134 { + var tail uint = copylen - 6 + var nbits uint = uint(Log2FloorNonZero(tail) - 1) + var prefix uint = tail >> nbits + var code uint = (nbits << 1) + prefix + 44 + var extra uint = tail - (prefix << nbits) + (*commands)[0] = uint32(code | extra<<8) + } else if copylen < 2118 { + var tail uint = copylen - 70 + var nbits uint = uint(Log2FloorNonZero(tail)) + var code uint = nbits + 52 + var extra uint = tail - (uint(1) << nbits) + (*commands)[0] = uint32(code | extra<<8) + } else { + var extra uint = copylen - 2118 + (*commands)[0] = uint32(63 | extra<<8) + } + + *commands = (*commands)[1:] +} + +func EmitCopyLenLastDistance(copylen uint, commands *[]uint32) { + if copylen < 12 { + (*commands)[0] = uint32(copylen + 20) + *commands = (*commands)[1:] + } else if copylen < 72 { + var tail uint = copylen - 8 + var nbits uint = uint(Log2FloorNonZero(tail) - 1) + var prefix uint = tail >> nbits + var code uint = (nbits << 1) + prefix + 28 + var extra uint = tail - (prefix << nbits) + (*commands)[0] = uint32(code | extra<<8) + *commands = (*commands)[1:] + } else if copylen < 136 { + var tail uint = copylen - 8 + var code uint = (tail >> 5) + 54 + var extra uint = tail & 31 + (*commands)[0] = uint32(code | extra<<8) + *commands = (*commands)[1:] + (*commands)[0] = 64 + *commands = (*commands)[1:] + } else if copylen < 2120 { + var tail uint = copylen - 72 + var nbits uint = uint(Log2FloorNonZero(tail)) + var code uint = nbits + 52 + var extra uint = tail - (uint(1) << nbits) + (*commands)[0] = uint32(code | extra<<8) + *commands = (*commands)[1:] + (*commands)[0] = 64 + *commands = (*commands)[1:] + } else { + var extra uint = copylen - 2120 + (*commands)[0] = uint32(63 | extra<<8) + *commands = (*commands)[1:] + (*commands)[0] = 64 + *commands = (*commands)[1:] + } +} + +func EmitDistance(distance uint32, commands *[]uint32) { + var d uint32 = distance + 3 + var nbits uint32 = Log2FloorNonZero(uint(d)) - 1 + var prefix uint32 = (d >> nbits) & 1 + var offset uint32 = (2 + prefix) << nbits + var distcode uint32 = 2*(nbits-1) + prefix + 80 + var extra uint32 = d - offset + (*commands)[0] = distcode | extra<<8 + *commands = (*commands)[1:] +} + +/* REQUIRES: len <= 1 << 24. */ +func BrotliStoreMetaBlockHeader(len uint, is_uncompressed bool, storage_ix *uint, storage []byte) { + var nibbles uint = 6 + + /* ISLAST */ + BrotliWriteBits(1, 0, storage_ix, storage) + + if len <= 1<<16 { + nibbles = 4 + } else if len <= 1<<20 { + nibbles = 5 + } + + BrotliWriteBits(2, uint64(nibbles)-4, storage_ix, storage) + BrotliWriteBits(nibbles*4, uint64(len)-1, storage_ix, storage) + + /* ISUNCOMPRESSED */ + BrotliWriteSingleBit(is_uncompressed, storage_ix, storage) +} + +func CreateCommands(input []byte, block_size uint, input_size uint, base_ip_ptr []byte, table []int, table_bits uint, min_match uint, literals *[]byte, commands *[]uint32) { + var ip int = 0 + var shift uint = 64 - table_bits + var ip_end int = int(block_size) + var base_ip int = -cap(base_ip_ptr) + cap(input) + var next_emit int = 0 + var last_distance int = -1 + /* "ip" is the input pointer. */ + + var kInputMarginBytes uint = BROTLI_WINDOW_GAP + + /* "next_emit" is a pointer to the first byte that is not covered by a + previous copy. Bytes between "next_emit" and the start of the next copy or + the end of the input will be emitted as literal bytes. */ + if block_size >= kInputMarginBytes { + var len_limit uint = brotli_min_size_t(block_size-min_match, input_size-kInputMarginBytes) + var ip_limit int = int(len_limit) + /* For the last block, we need to keep a 16 bytes margin so that we can be + sure that all distances are at most window size - 16. + For all other blocks, we only need to keep a margin of 5 bytes so that + we don't go over the block size with a copy. */ + + var next_hash uint32 + ip++ + for next_hash = Hash1(input[ip:], shift, min_match); ; { + var skip uint32 = 32 + var next_ip int = ip + /* Step 1: Scan forward in the input looking for a 6-byte-long match. + If we get close to exhausting the input then goto emit_remainder. + + Heuristic match skipping: If 32 bytes are scanned with no matches + found, start looking only at every other byte. If 32 more bytes are + scanned, look at every third byte, etc.. When a match is found, + immediately go back to looking at every byte. This is a small loss + (~5% performance, ~0.1% density) for compressible data due to more + bookkeeping, but for non-compressible data (such as JPEG) it's a huge + win since the compressor quickly "realizes" the data is incompressible + and doesn't bother looking for matches everywhere. + + The "skip" variable keeps track of how many bytes there are since the + last match; dividing it by 32 (ie. right-shifting by five) gives the + number of bytes to move ahead for each iteration. */ + + var candidate int + + assert(next_emit < ip) + + trawl: + for { + var hash uint32 = next_hash + var bytes_between_hash_lookups uint32 = skip >> 5 + skip++ + ip = next_ip + assert(hash == Hash1(input[ip:], shift, min_match)) + next_ip = int(uint32(ip) + bytes_between_hash_lookups) + if next_ip > ip_limit { + goto emit_remainder + } + + next_hash = Hash1(input[next_ip:], shift, min_match) + candidate = ip - last_distance + if IsMatch1(input[ip:], input[candidate:], min_match) { + if candidate < ip { + table[hash] = int(ip - base_ip) + break + } + } + + candidate = base_ip + table[hash] + assert(candidate >= base_ip) + assert(candidate < ip) + + table[hash] = int(ip - base_ip) + if !(!IsMatch1(input[ip:], input[candidate:], min_match)) { + break + } + } + + /* Check copy distance. If candidate is not feasible, continue search. + Checking is done outside of hot loop to reduce overhead. */ + if ip-candidate > MAX_DISTANCE { + goto trawl + } + + /* Step 2: Emit the found match together with the literal bytes from + "next_emit", and then see if we can find a next match immediately + afterwards. Repeat until we find no match for the input + without emitting some literal bytes. */ + { + var base int = ip + /* > 0 */ + var matched uint = min_match + FindMatchLengthWithLimit(input[uint(candidate)+min_match:], input[uint(ip)+min_match:], uint(ip_end-ip)-min_match) + var distance int = int(base - candidate) + /* We have a 6-byte match at ip, and we need to emit bytes in + [next_emit, ip). */ + + var insert int = int(base - next_emit) + ip += int(matched) + EmitInsertLen(uint32(insert), commands) + copy(*literals, input[next_emit:][:uint(insert)]) + *literals = (*literals)[insert:] + if distance == last_distance { + (*commands)[0] = 64 + *commands = (*commands)[1:] + } else { + EmitDistance(uint32(distance), commands) + last_distance = distance + } + + EmitCopyLenLastDistance(matched, commands) + + next_emit = ip + if ip >= ip_limit { + goto emit_remainder + } + { + var input_bytes uint64 + var cur_hash uint32 + /* We could immediately start working at ip now, but to improve + compression we first update "table" with the hashes of some + positions within the last copy. */ + + var prev_hash uint32 + if min_match == 4 { + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-3:]) + cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 3) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 1) + } else { + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-5:]) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 5) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 4) + prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match) + table[prev_hash] = int(ip - base_ip - 3) + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-2:]) + cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 1) + } + + candidate = base_ip + table[cur_hash] + table[cur_hash] = int(ip - base_ip) + } + } + + for ip-candidate <= MAX_DISTANCE && IsMatch1(input[ip:], input[candidate:], min_match) { + var base int = ip + /* We have a 6-byte match at ip, and no need to emit any + literal bytes prior to ip. */ + + var matched uint = min_match + FindMatchLengthWithLimit(input[uint(candidate)+min_match:], input[uint(ip)+min_match:], uint(ip_end-ip)-min_match) + ip += int(matched) + last_distance = int(base - candidate) /* > 0 */ + EmitCopyLen(matched, commands) + EmitDistance(uint32(last_distance), commands) + + next_emit = ip + if ip >= ip_limit { + goto emit_remainder + } + { + var input_bytes uint64 + var cur_hash uint32 + /* We could immediately start working at ip now, but to improve + compression we first update "table" with the hashes of some + positions within the last copy. */ + + var prev_hash uint32 + if min_match == 4 { + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-3:]) + cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 3) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match) + table[prev_hash] = int(ip - base_ip - 1) + } else { + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-5:]) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 5) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 4) + prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match) + table[prev_hash] = int(ip - base_ip - 3) + input_bytes = BROTLI_UNALIGNED_LOAD64LE(input[ip-2:]) + cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match) + prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match) + table[prev_hash] = int(ip - base_ip - 2) + prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match) + table[prev_hash] = int(ip - base_ip - 1) + } + + candidate = base_ip + table[cur_hash] + table[cur_hash] = int(ip - base_ip) + } + } + + ip++ + next_hash = Hash1(input[ip:], shift, min_match) + } + } + +emit_remainder: + assert(next_emit <= ip_end) + + /* Emit the remaining bytes as literals. */ + if next_emit < ip_end { + var insert uint32 = uint32(ip_end - next_emit) + EmitInsertLen(insert, commands) + copy(*literals, input[next_emit:][:insert]) + *literals = (*literals)[insert:] + } +} + +var StoreCommands_kNumExtraBits = [128]uint32{ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 7, + 8, + 9, + 10, + 12, + 14, + 24, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 7, + 8, + 9, + 10, + 24, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, + 14, + 14, + 15, + 15, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, +} +var StoreCommands_kInsertOffset = [24]uint32{ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 8, + 10, + 14, + 18, + 26, + 34, + 50, + 66, + 98, + 130, + 194, + 322, + 578, + 1090, + 2114, + 6210, + 22594, +} + +func StoreCommands(literals []byte, num_literals uint, commands []uint32, num_commands uint, storage_ix *uint, storage []byte) { + var lit_depths [256]byte + var lit_bits [256]uint16 + var lit_histo = [256]uint32{0} + var cmd_depths = [128]byte{0} + var cmd_bits = [128]uint16{0} + var cmd_histo = [128]uint32{0} + var i uint + for i = 0; i < num_literals; i++ { + lit_histo[literals[i]]++ + } + + BrotliBuildAndStoreHuffmanTreeFast(lit_histo[:], num_literals, /* max_bits = */ + 8, lit_depths[:], lit_bits[:], storage_ix, storage) + + for i = 0; i < num_commands; i++ { + var code uint32 = commands[i] & 0xFF + assert(code < 128) + cmd_histo[code]++ + } + + cmd_histo[1] += 1 + cmd_histo[2] += 1 + cmd_histo[64] += 1 + cmd_histo[84] += 1 + BuildAndStoreCommandPrefixCode(cmd_histo[:], cmd_depths[:], cmd_bits[:], storage_ix, storage) + + for i = 0; i < num_commands; i++ { + var cmd uint32 = commands[i] + var code uint32 = cmd & 0xFF + var extra uint32 = cmd >> 8 + assert(code < 128) + BrotliWriteBits(uint(cmd_depths[code]), uint64(cmd_bits[code]), storage_ix, storage) + BrotliWriteBits(uint(StoreCommands_kNumExtraBits[code]), uint64(extra), storage_ix, storage) + if code < 24 { + var insert uint32 = StoreCommands_kInsertOffset[code] + extra + var j uint32 + for j = 0; j < insert; j++ { + var lit byte = literals[0] + BrotliWriteBits(uint(lit_depths[lit]), uint64(lit_bits[lit]), storage_ix, storage) + literals = literals[1:] + } + } + } +} + +/* Acceptable loss for uncompressible speedup is 2% */ +const MIN_RATIO = 0.98 + +const SAMPLE_RATE = 43 + +func ShouldCompress(input []byte, input_size uint, num_literals uint) bool { + var corpus_size float64 = float64(input_size) + if float64(num_literals) < MIN_RATIO*corpus_size { + return true + } else { + var literal_histo = [256]uint32{0} + var max_total_bit_cost float64 = corpus_size * 8 * MIN_RATIO / SAMPLE_RATE + var i uint + for i = 0; i < input_size; i += SAMPLE_RATE { + literal_histo[input[i]]++ + } + + return BitsEntropy(literal_histo[:], 256) < max_total_bit_cost + } +} + +func RewindBitPosition(new_storage_ix uint, storage_ix *uint, storage []byte) { + var bitpos uint = new_storage_ix & 7 + var mask uint = (1 << bitpos) - 1 + storage[new_storage_ix>>3] &= byte(mask) + *storage_ix = new_storage_ix +} + +func EmitUncompressedMetaBlock(input []byte, input_size uint, storage_ix *uint, storage []byte) { + BrotliStoreMetaBlockHeader(input_size, true, storage_ix, storage) + *storage_ix = (*storage_ix + 7) &^ 7 + copy(storage[*storage_ix>>3:], input[:input_size]) + *storage_ix += input_size << 3 + storage[*storage_ix>>3] = 0 +} + +func BrotliCompressFragmentTwoPassImpl(input []byte, input_size uint, is_last bool, command_buf []uint32, literal_buf []byte, table []int, table_bits uint, min_match uint, storage_ix *uint, storage []byte) { + /* Save the start of the first block for position and distance computations. + */ + var base_ip []byte = input + + for input_size > 0 { + var block_size uint = brotli_min_size_t(input_size, kCompressFragmentTwoPassBlockSize) + var commands []uint32 = command_buf + var literals []byte = literal_buf + var num_literals uint + CreateCommands(input, block_size, input_size, base_ip, table, table_bits, min_match, &literals, &commands) + num_literals = uint(-cap(literals) + cap(literal_buf)) + if ShouldCompress(input, block_size, num_literals) { + var num_commands uint = uint(-cap(commands) + cap(command_buf)) + BrotliStoreMetaBlockHeader(block_size, false, storage_ix, storage) + + /* No block splits, no contexts. */ + BrotliWriteBits(13, 0, storage_ix, storage) + + StoreCommands(literal_buf, num_literals, command_buf, num_commands, storage_ix, storage) + } else { + /* Since we did not find many backward references and the entropy of + the data is close to 8 bits, we can simply emit an uncompressed block. + This makes compression speed of uncompressible data about 3x faster. */ + EmitUncompressedMetaBlock(input, block_size, storage_ix, storage) + } + + input = input[block_size:] + input_size -= block_size + } +} + +func BrotliCompressFragmentTwoPass(input []byte, input_size uint, is_last bool, command_buf []uint32, literal_buf []byte, table []int, table_size uint, storage_ix *uint, storage []byte) { + var initial_storage_ix uint = *storage_ix + var table_bits uint = uint(Log2FloorNonZero(table_size)) + var min_match uint + if table_bits <= 15 { + min_match = 4 + } else { + min_match = 6 + } + BrotliCompressFragmentTwoPassImpl(input, input_size, is_last, command_buf, literal_buf, table, table_bits, min_match, storage_ix, storage) + + /* If output is larger than single uncompressed block, rewrite it. */ + if *storage_ix-initial_storage_ix > 31+(input_size<<3) { + RewindBitPosition(initial_storage_ix, storage_ix, storage) + EmitUncompressedMetaBlock(input, input_size, storage_ix, storage) + } + + if is_last { + BrotliWriteBits(1, 1, storage_ix, storage) /* islast */ + BrotliWriteBits(1, 1, storage_ix, storage) /* isempty */ + *storage_ix = (*storage_ix + 7) &^ 7 + } +} diff --git a/constants.go b/constants.go new file mode 100644 index 0000000..cd284d3 --- /dev/null +++ b/constants.go @@ -0,0 +1,77 @@ +package brotli + +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Specification: 7.3. Encoding of the context map */ +const BROTLI_CONTEXT_MAP_MAX_RLE = 16 + +/* Specification: 2. Compressed representation overview */ +const BROTLI_MAX_NUMBER_OF_BLOCK_TYPES = 256 + +/* Specification: 3.3. Alphabet sizes: insert-and-copy length */ +const BROTLI_NUM_LITERAL_SYMBOLS = 256 + +const BROTLI_NUM_COMMAND_SYMBOLS = 704 + +const BROTLI_NUM_BLOCK_LEN_SYMBOLS = 26 + +const BROTLI_MAX_CONTEXT_MAP_SYMBOLS = (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + BROTLI_CONTEXT_MAP_MAX_RLE) + +const BROTLI_MAX_BLOCK_TYPE_SYMBOLS = (BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 2) + +/* Specification: 3.5. Complex prefix codes */ +const BROTLI_REPEAT_PREVIOUS_CODE_LENGTH = 16 + +const BROTLI_REPEAT_ZERO_CODE_LENGTH = 17 + +const BROTLI_CODE_LENGTH_CODES = (BROTLI_REPEAT_ZERO_CODE_LENGTH + 1) + +/* "code length of 8 is repeated" */ +const BROTLI_INITIAL_REPEATED_CODE_LENGTH = 8 + +/* "Large Window Brotli" */ +const BROTLI_LARGE_MAX_DISTANCE_BITS = 62 + +const BROTLI_LARGE_MIN_WBITS = 10 + +const BROTLI_LARGE_MAX_WBITS = 30 + +/* Specification: 4. Encoding of distances */ +const BROTLI_NUM_DISTANCE_SHORT_CODES = 16 + +const BROTLI_MAX_NPOSTFIX = 3 + +const BROTLI_MAX_NDIRECT = 120 + +const BROTLI_MAX_DISTANCE_BITS = 24 + +func BROTLI_DISTANCE_ALPHABET_SIZE(NPOSTFIX uint, NDIRECT uint, MAXNBITS uint) uint { + return BROTLI_NUM_DISTANCE_SHORT_CODES + NDIRECT + uint(MAXNBITS<<(NPOSTFIX+1)) +} + +/* BROTLI_NUM_DISTANCE_SYMBOLS == 1128 */ +const BROTLI_NUM_DISTANCE_SYMBOLS = 1128 + +const BROTLI_MAX_DISTANCE = 0x3FFFFFC + +const BROTLI_MAX_ALLOWED_DISTANCE = 0x7FFFFFFC + +/* 7.1. Context modes and context ID lookup for literals */ +/* "context IDs for literals are in the range of 0..63" */ +const BROTLI_LITERAL_CONTEXT_BITS = 6 + +/* 7.2. Context ID for distances */ +const BROTLI_DISTANCE_CONTEXT_BITS = 2 + +/* 9.1. Format of the Stream Header */ +/* Number of slack bytes for window size. Don't confuse + with BROTLI_NUM_DISTANCE_SHORT_CODES. */ +const BROTLI_WINDOW_GAP = 16 + +func BROTLI_MAX_BACKWARD_LIMIT(W uint) uint { + return (uint(1) << W) - BROTLI_WINDOW_GAP +} diff --git a/context.go b/context.go new file mode 100644 index 0000000..5958f7a --- /dev/null +++ b/context.go @@ -0,0 +1,2351 @@ +package brotli + +/** + * Sets the specified parameter to the given decoder instance. + * + * @param state decoder instance + * @param param parameter to set + * @param value new parameter value + * @returns ::false if parameter is unrecognized, or value is invalid + * @returns ::true if value is accepted + */ + +/** + * Creates an instance of ::BrotliDecoderState and initializes it. + * + * The instance can be used once for decoding and should then be destroyed with + * ::BrotliDecoderDestroyInstance, it cannot be reused for a new decoding + * session. + * + * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the + * case they are both zero, default memory allocators are used. @p opaque is + * passed to @p alloc_func and @p free_func when they are called. @p free_func + * has to return without doing anything when asked to free a NULL pointer. + * + * @param alloc_func custom memory allocation function + * @param free_func custom memory free function + * @param opaque custom memory manager handle + * @returns @c 0 if instance can not be allocated or initialized + * @returns pointer to initialized ::BrotliDecoderState otherwise + */ + +/** + * Deinitializes and frees ::BrotliDecoderState instance. + * + * @param state decoder instance to be cleaned up and deallocated + */ + +/** + * Performs one-shot memory-to-memory decompression. + * + * Decompresses the data in @p encoded_buffer into @p decoded_buffer, and sets + * @p *decoded_size to the decompressed length. + * + * @param encoded_size size of @p encoded_buffer + * @param encoded_buffer compressed data buffer with at least @p encoded_size + * addressable bytes + * @param[in, out] decoded_size @b in: size of @p decoded_buffer; \n + * @b out: length of decompressed data written to + * @p decoded_buffer + * @param decoded_buffer decompressed data destination buffer + * @returns ::BROTLI_DECODER_RESULT_ERROR if input is corrupted, memory + * allocation failed, or @p decoded_buffer is not large enough; + * @returns ::BROTLI_DECODER_RESULT_SUCCESS otherwise + */ + +/** + * Decompresses the input stream to the output stream. + * + * The values @p *available_in and @p *available_out must specify the number of + * bytes addressable at @p *next_in and @p *next_out respectively. + * When @p *available_out is @c 0, @p next_out is allowed to be @c NULL. + * + * After each call, @p *available_in will be decremented by the amount of input + * bytes consumed, and the @p *next_in pointer will be incremented by that + * amount. Similarly, @p *available_out will be decremented by the amount of + * output bytes written, and the @p *next_out pointer will be incremented by + * that amount. + * + * @p total_out, if it is not a null-pointer, will be set to the number + * of bytes decompressed since the last @p state initialization. + * + * @note Input is never overconsumed, so @p next_in and @p available_in could be + * passed to the next consumer after decoding is complete. + * + * @param state decoder instance + * @param[in, out] available_in @b in: amount of available input; \n + * @b out: amount of unused input + * @param[in, out] next_in pointer to the next compressed byte + * @param[in, out] available_out @b in: length of output buffer; \n + * @b out: remaining size of output buffer + * @param[in, out] next_out output buffer cursor; + * can be @c NULL if @p available_out is @c 0 + * @param[out] total_out number of bytes decompressed so far; can be @c NULL + * @returns ::BROTLI_DECODER_RESULT_ERROR if input is corrupted, memory + * allocation failed, arguments were invalid, etc.; + * use ::BrotliDecoderGetErrorCode to get detailed error code + * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT decoding is blocked until + * more input data is provided + * @returns ::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT decoding is blocked until + * more output space is provided + * @returns ::BROTLI_DECODER_RESULT_SUCCESS decoding is finished, no more + * input might be consumed and no more output will be produced + */ + +/** + * Checks if decoder has more output. + * + * @param state decoder instance + * @returns ::true, if decoder has some unconsumed output + * @returns ::false otherwise + */ + +/** + * Acquires pointer to internal output buffer. + * + * This method is used to make language bindings easier and more efficient: + * -# push data to ::BrotliDecoderDecompressStream, + * until ::BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT is reported + * -# use ::BrotliDecoderTakeOutput to peek bytes and copy to language-specific + * entity + * + * Also this could be useful if there is an output stream that is able to + * consume all the provided data (e.g. when data is saved to file system). + * + * @attention After every call to ::BrotliDecoderTakeOutput @p *size bytes of + * output are considered consumed for all consecutive calls to the + * instance methods; returned pointer becomes invalidated as well. + * + * @note Decoder output is not guaranteed to be contiguous. This means that + * after the size-unrestricted call to ::BrotliDecoderTakeOutput, + * immediate next call to ::BrotliDecoderTakeOutput may return more data. + * + * @param state decoder instance + * @param[in, out] size @b in: number of bytes caller is ready to take, @c 0 if + * any amount could be handled; \n + * @b out: amount of data pointed by returned pointer and + * considered consumed; \n + * out value is never greater than in value, unless it is @c 0 + * @returns pointer to output data + */ + +/** + * Checks if instance has already consumed input. + * + * Instance that returns ::false is considered "fresh" and could be + * reused. + * + * @param state decoder instance + * @returns ::true if decoder has already used some input bytes + * @returns ::false otherwise + */ + +/** + * Checks if decoder instance reached the final state. + * + * @param state decoder instance + * @returns ::true if decoder is in a state where it reached the end of + * the input and produced all of the output + * @returns ::false otherwise + */ + +/** + * Acquires a detailed error code. + * + * Should be used only after ::BrotliDecoderDecompressStream returns + * ::BROTLI_DECODER_RESULT_ERROR. + * + * See also ::BrotliDecoderErrorString + * + * @param state decoder instance + * @returns last saved error code + */ + +/** + * Converts error code to a c-string. + */ + +/** + * Gets a decoder library version. + * + * Look at BROTLI_VERSION for more information. + */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Lookup table to map the previous two bytes to a context id. + +There are four different context modeling modes defined here: + CONTEXT_LSB6: context id is the least significant 6 bits of the last byte, + CONTEXT_MSB6: context id is the most significant 6 bits of the last byte, + CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text, + CONTEXT_SIGNED: second-order context model tuned for signed integers. + +If |p1| and |p2| are the previous two bytes, and |mode| is current context +mode, we calculate the context as: + + context = ContextLut(mode)[p1] | ContextLut(mode)[p2 + 256]. + +For CONTEXT_UTF8 mode, if the previous two bytes are ASCII characters +(i.e. < 128), this will be equivalent to + + context = 4 * context1(p1) + context2(p2), + +where context1 is based on the previous byte in the following way: + + 0 : non-ASCII control + 1 : \t, \n, \r + 2 : space + 3 : other punctuation + 4 : " ' + 5 : % + 6 : ( < [ { + 7 : ) > ] } + 8 : , ; : + 9 : . + 10 : = + 11 : number + 12 : upper-case vowel + 13 : upper-case consonant + 14 : lower-case vowel + 15 : lower-case consonant + +and context2 is based on the second last byte: + + 0 : control, space + 1 : punctuation + 2 : upper-case letter, number + 3 : lower-case letter + +If the last byte is ASCII, and the second last byte is not (in a valid UTF8 +stream it will be a continuation byte, value between 128 and 191), the +context is the same as if the second last byte was an ASCII control or space. + +If the last byte is a UTF8 lead byte (value >= 192), then the next byte will +be a continuation byte and the context id is 2 or 3 depending on the LSB of +the last byte and to a lesser extent on the second last byte if it is ASCII. + +If the last byte is a UTF8 continuation byte, the second last byte can be: + - continuation byte: the next byte is probably ASCII or lead byte (assuming + 4-byte UTF8 characters are rare) and the context id is 0 or 1. + - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1 + - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3 + +The possible value combinations of the previous two bytes, the range of +context ids and the type of the next byte is summarized in the table below: + +|--------\-----------------------------------------------------------------| +| \ Last byte | +| Second \---------------------------------------------------------------| +| last byte \ ASCII | cont. byte | lead byte | +| \ (0-127) | (128-191) | (192-) | +|=============|===================|=====================|==================| +| ASCII | next: ASCII/lead | not valid | next: cont. | +| (0-127) | context: 4 - 63 | | context: 2 - 3 | +|-------------|-------------------|---------------------|------------------| +| cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. | +| (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 | +|-------------|-------------------|---------------------|------------------| +| lead byte | not valid | next: ASCII/lead | not valid | +| (192-207) | | context: 0 - 1 | | +|-------------|-------------------|---------------------|------------------| +| lead byte | not valid | next: cont. | not valid | +| (208-) | | context: 2 - 3 | | +|-------------|-------------------|---------------------|------------------| +*/ +const ( + CONTEXT_LSB6 = 0 + CONTEXT_MSB6 = 1 + CONTEXT_UTF8 = 2 + CONTEXT_SIGNED = 3 +) + +/* Common context lookup table for all context modes. */ +var kContextLookup = [2048]byte{ + /* CONTEXT_LSB6, last byte. */ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + + /* CONTEXT_LSB6, second last byte, */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + + /* CONTEXT_MSB6, last byte. */ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 10, + 10, + 10, + 10, + 11, + 11, + 11, + 11, + 12, + 12, + 12, + 12, + 13, + 13, + 13, + 13, + 14, + 14, + 14, + 14, + 15, + 15, + 15, + 15, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 22, + 22, + 22, + 22, + 23, + 23, + 23, + 23, + 24, + 24, + 24, + 24, + 25, + 25, + 25, + 25, + 26, + 26, + 26, + 26, + 27, + 27, + 27, + 27, + 28, + 28, + 28, + 28, + 29, + 29, + 29, + 29, + 30, + 30, + 30, + 30, + 31, + 31, + 31, + 31, + 32, + 32, + 32, + 32, + 33, + 33, + 33, + 33, + 34, + 34, + 34, + 34, + 35, + 35, + 35, + 35, + 36, + 36, + 36, + 36, + 37, + 37, + 37, + 37, + 38, + 38, + 38, + 38, + 39, + 39, + 39, + 39, + 40, + 40, + 40, + 40, + 41, + 41, + 41, + 41, + 42, + 42, + 42, + 42, + 43, + 43, + 43, + 43, + 44, + 44, + 44, + 44, + 45, + 45, + 45, + 45, + 46, + 46, + 46, + 46, + 47, + 47, + 47, + 47, + 48, + 48, + 48, + 48, + 49, + 49, + 49, + 49, + 50, + 50, + 50, + 50, + 51, + 51, + 51, + 51, + 52, + 52, + 52, + 52, + 53, + 53, + 53, + 53, + 54, + 54, + 54, + 54, + 55, + 55, + 55, + 55, + 56, + 56, + 56, + 56, + 57, + 57, + 57, + 57, + 58, + 58, + 58, + 58, + 59, + 59, + 59, + 59, + 60, + 60, + 60, + 60, + 61, + 61, + 61, + 61, + 62, + 62, + 62, + 62, + 63, + 63, + 63, + 63, + + /* CONTEXT_MSB6, second last byte, */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + + /* CONTEXT_UTF8, last byte. */ + /* ASCII range. */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8, + 12, + 16, + 12, + 12, + 20, + 12, + 16, + 24, + 28, + 12, + 12, + 32, + 12, + 36, + 12, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 32, + 32, + 24, + 40, + 28, + 12, + 12, + 48, + 52, + 52, + 52, + 48, + 52, + 52, + 52, + 48, + 52, + 52, + 52, + 52, + 52, + 48, + 52, + 52, + 52, + 52, + 52, + 48, + 52, + 52, + 52, + 52, + 52, + 24, + 12, + 28, + 12, + 12, + 12, + 56, + 60, + 60, + 60, + 56, + 60, + 60, + 60, + 56, + 60, + 60, + 60, + 60, + 60, + 56, + 60, + 60, + 60, + 60, + 60, + 56, + 60, + 60, + 60, + 60, + 60, + 24, + 12, + 28, + 12, + 0, + + /* UTF8 continuation byte range. */ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + + /* UTF8 lead byte range. */ + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + 2, + 3, + + /* CONTEXT_UTF8 second last byte. */ + /* ASCII range. */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 0, + + /* UTF8 continuation byte range. */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + + /* UTF8 lead byte range. */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + + /* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */ + 0, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 32, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 56, + + /* CONTEXT_SIGNED, second last byte. */ + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 7, +} + +type ContextLut []byte + +func BROTLI_CONTEXT_LUT(mode int) ContextLut { + return kContextLookup[mode<<9:] +} + +func BROTLI_CONTEXT(p1 byte, p2 byte, lut ContextLut) byte { + return lut[p1] | lut[256+int(p2)] +} diff --git a/decode.go b/decode.go new file mode 100644 index 0000000..38b7153 --- /dev/null +++ b/decode.go @@ -0,0 +1,2812 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/** + * @file + * API for Brotli decompression. + */ + +/** + * Result type for ::BrotliDecoderDecompress and + * ::BrotliDecoderDecompressStream functions. + */ +const ( + BROTLI_DECODER_RESULT_ERROR = 0 + BROTLI_DECODER_RESULT_SUCCESS = 1 + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2 + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3 +) + +/** + * Template that evaluates items of ::BrotliDecoderErrorCode. + * + * Example: @code {.cpp} + * // Log Brotli error code. + * switch (brotliDecoderErrorCode) { + * #define CASE_(PREFIX, NAME, CODE) \ + * case BROTLI_DECODER ## PREFIX ## NAME: \ + * LOG(INFO) << "error code:" << #NAME; \ + * break; + * #define NEWLINE_ + * BROTLI_DECODER_ERROR_CODES_LIST(CASE_, NEWLINE_) + * #undef CASE_ + * #undef NEWLINE_ + * default: LOG(FATAL) << "unknown brotli error code"; + * } + * @endcode + */ + +/** + * Error code for detailed logging / production debugging. + * + * See ::BrotliDecoderGetErrorCode and ::BROTLI_LAST_ERROR_CODE. + */ +const ( + BROTLI_DECODER_NO_ERROR = 0 + BROTLI_DECODER_SUCCESS = 1 + BROTLI_DECODER_NEEDS_MORE_INPUT = 2 + BROTLI_DECODER_NEEDS_MORE_OUTPUT = 3 + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE = -1 + BROTLI_DECODER_ERROR_FORMAT_RESERVED = -2 + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3 + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4 + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5 + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE = -6 + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE = -7 + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8 + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 = -9 + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 = -10 + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM = -11 + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY = -12 + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS = -13 + BROTLI_DECODER_ERROR_FORMAT_PADDING_1 = -14 + BROTLI_DECODER_ERROR_FORMAT_PADDING_2 = -15 + BROTLI_DECODER_ERROR_FORMAT_DISTANCE = -16 + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET = -19 + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS = -20 + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES = -21 + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS = -22 + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP = -25 + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 = -26 + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 = -27 + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES = -30 + BROTLI_DECODER_ERROR_UNREACHABLE = -31 +) + +/** + * The value of the last error code, negative integer. + * + * All other error code values are in the range from ::BROTLI_LAST_ERROR_CODE + * to @c -1. There are also 4 other possible non-error codes @c 0 .. @c 3 in + * ::BrotliDecoderErrorCode enumeration. + */ +const BROTLI_LAST_ERROR_CODE = BROTLI_DECODER_ERROR_UNREACHABLE + +/** Options to be used with ::BrotliDecoderSetParameter. */ +const ( + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0 + BROTLI_DECODER_PARAM_LARGE_WINDOW = 1 +) + +const HUFFMAN_TABLE_BITS = 8 + +const HUFFMAN_TABLE_MASK = 0xFF + +/* We need the slack region for the following reasons: + - doing up to two 16-byte copies for fast backward copying + - inserting transformed dictionary word (5 prefix + 24 base + 8 suffix) */ +var kRingBufferWriteAheadSlack uint32 = 42 + +var kCodeLengthCodeOrder = [BROTLI_CODE_LENGTH_CODES]byte{1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15} + +/* Static prefix code for the complex code length code lengths. */ +var kCodeLengthPrefixLength = [16]byte{2, 2, 2, 3, 2, 2, 2, 4, 2, 2, 2, 3, 2, 2, 2, 4} + +var kCodeLengthPrefixValue = [16]byte{0, 4, 3, 2, 0, 4, 3, 1, 0, 4, 3, 2, 0, 4, 3, 5} + +func BrotliDecoderSetParameter(state *BrotliDecoderState, p int, value uint32) bool { + if state.state != BROTLI_STATE_UNINITED { + return false + } + switch p { + case BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: + if !(value == 0) { + state.canny_ringbuffer_allocation = 0 + } else { + state.canny_ringbuffer_allocation = 1 + } + return true + + case BROTLI_DECODER_PARAM_LARGE_WINDOW: + state.large_window = (!(value == 0)) + return true + + default: + return false + } +} + +func BrotliDecoderCreateInstance() *BrotliDecoderState { + var state *BrotliDecoderState + state = new(BrotliDecoderState) + if state == nil { + return nil + } + + if !BrotliDecoderStateInit(state) { + return nil + } + + return state +} + +/* Deinitializes and frees BrotliDecoderState instance. */ +func BrotliDecoderDestroyInstance(state *BrotliDecoderState) { + if state == nil { + return + } else { + BrotliDecoderStateCleanup(state) + } +} + +/* Saves error code and converts it to BrotliDecoderResult. */ +func SaveErrorCode(s *BrotliDecoderState, e int) int { + s.error_code = int(e) + switch e { + case BROTLI_DECODER_SUCCESS: + return BROTLI_DECODER_RESULT_SUCCESS + + case BROTLI_DECODER_NEEDS_MORE_INPUT: + return BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT + + case BROTLI_DECODER_NEEDS_MORE_OUTPUT: + return BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT + + default: + return BROTLI_DECODER_RESULT_ERROR + } +} + +/* Decodes WBITS by reading 1 - 7 bits, or 0x11 for "Large Window Brotli". + Precondition: bit-reader accumulator has at least 8 bits. */ +func DecodeWindowBits(s *BrotliDecoderState, br *BrotliBitReader) int { + var n uint32 + var large_window bool = s.large_window + s.large_window = false + BrotliTakeBits(br, 1, &n) + if n == 0 { + s.window_bits = 16 + return BROTLI_DECODER_SUCCESS + } + + BrotliTakeBits(br, 3, &n) + if n != 0 { + s.window_bits = 17 + n + return BROTLI_DECODER_SUCCESS + } + + BrotliTakeBits(br, 3, &n) + if n == 1 { + if large_window { + BrotliTakeBits(br, 1, &n) + if n == 1 { + return BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS + } + + s.large_window = true + return BROTLI_DECODER_SUCCESS + } else { + return BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS + } + } + + if n != 0 { + s.window_bits = 8 + n + return BROTLI_DECODER_SUCCESS + } + + s.window_bits = 17 + return BROTLI_DECODER_SUCCESS +} + +/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */ +func DecodeVarLenUint8(s *BrotliDecoderState, br *BrotliBitReader, value *uint32) int { + var bits uint32 + switch s.substate_decode_uint8 { + case BROTLI_STATE_DECODE_UINT8_NONE: + if !BrotliSafeReadBits(br, 1, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits == 0 { + *value = 0 + return BROTLI_DECODER_SUCCESS + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_DECODE_UINT8_SHORT: + if !BrotliSafeReadBits(br, 3, &bits) { + s.substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_SHORT + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits == 0 { + *value = 1 + s.substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE + return BROTLI_DECODER_SUCCESS + } + + /* Use output value as a temporary storage. It MUST be persisted. */ + *value = bits + fallthrough + + /* Fall through. */ + case BROTLI_STATE_DECODE_UINT8_LONG: + if !BrotliSafeReadBits(br, *value, &bits) { + s.substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_LONG + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + *value = (1 << *value) + bits + s.substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE + return BROTLI_DECODER_SUCCESS + + default: + return BROTLI_DECODER_ERROR_UNREACHABLE + } +} + +/* Decodes a metablock length and flags by reading 2 - 31 bits. */ +func DecodeMetaBlockLength(s *BrotliDecoderState, br *BrotliBitReader) int { + var bits uint32 + var i int + for { + switch s.substate_metablock_header { + case BROTLI_STATE_METABLOCK_HEADER_NONE: + if !BrotliSafeReadBits(br, 1, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits != 0 { + s.is_last_metablock = 1 + } else { + s.is_last_metablock = 0 + } + s.meta_block_remaining_len = 0 + s.is_uncompressed = 0 + s.is_metadata = 0 + if s.is_last_metablock == 0 { + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NIBBLES + break + } + + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_EMPTY + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_EMPTY: + if !BrotliSafeReadBits(br, 1, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits != 0 { + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE + return BROTLI_DECODER_SUCCESS + } + + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NIBBLES + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_NIBBLES: + if !BrotliSafeReadBits(br, 2, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + s.size_nibbles = uint(byte(bits + 4)) + s.loop_counter = 0 + if bits == 3 { + s.is_metadata = 1 + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_RESERVED + break + } + + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_SIZE + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_SIZE: + i = s.loop_counter + + for ; i < int(s.size_nibbles); i++ { + if !BrotliSafeReadBits(br, 4, &bits) { + s.loop_counter = i + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if uint(i+1) == s.size_nibbles && s.size_nibbles > 4 && bits == 0 { + return BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE + } + + s.meta_block_remaining_len |= int(bits << uint(i*4)) + } + + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED: + if s.is_last_metablock == 0 { + if !BrotliSafeReadBits(br, 1, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits != 0 { + s.is_uncompressed = 1 + } else { + s.is_uncompressed = 0 + } + } + + s.meta_block_remaining_len++ + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE + return BROTLI_DECODER_SUCCESS + + case BROTLI_STATE_METABLOCK_HEADER_RESERVED: + if !BrotliSafeReadBits(br, 1, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits != 0 { + return BROTLI_DECODER_ERROR_FORMAT_RESERVED + } + + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_BYTES + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_BYTES: + if !BrotliSafeReadBits(br, 2, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits == 0 { + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE + return BROTLI_DECODER_SUCCESS + } + + s.size_nibbles = uint(byte(bits)) + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_METADATA + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER_METADATA: + i = s.loop_counter + + for ; i < int(s.size_nibbles); i++ { + if !BrotliSafeReadBits(br, 8, &bits) { + s.loop_counter = i + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if uint(i+1) == s.size_nibbles && s.size_nibbles > 1 && bits == 0 { + return BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE + } + + s.meta_block_remaining_len |= int(bits << uint(i*8)) + } + + s.meta_block_remaining_len++ + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE + return BROTLI_DECODER_SUCCESS + + default: + return BROTLI_DECODER_ERROR_UNREACHABLE + } + } +} + +/* Decodes the Huffman code. + This method doesn't read data from the bit reader, BUT drops the amount of + bits that correspond to the decoded symbol. + bits MUST contain at least 15 (BROTLI_HUFFMAN_MAX_CODE_LENGTH) valid bits. */ +func DecodeSymbol(bits uint32, table []HuffmanCode, br *BrotliBitReader) uint32 { + table = table[bits&HUFFMAN_TABLE_MASK:] + if table[0].bits > HUFFMAN_TABLE_BITS { + var nbits uint32 = uint32(table[0].bits) - HUFFMAN_TABLE_BITS + BrotliDropBits(br, HUFFMAN_TABLE_BITS) + table = table[uint32(table[0].value)+((bits>>HUFFMAN_TABLE_BITS)&BitMask(nbits)):] + } + + BrotliDropBits(br, uint32(table[0].bits)) + return uint32(table[0].value) +} + +/* Reads and decodes the next Huffman code from bit-stream. + This method peeks 16 bits of input and drops 0 - 15 of them. */ +func ReadSymbol(table []HuffmanCode, br *BrotliBitReader) uint32 { + return DecodeSymbol(BrotliGet16BitsUnmasked(br), table, br) +} + +/* Same as DecodeSymbol, but it is known that there is less than 15 bits of + input are currently available. */ +func SafeDecodeSymbol(table []HuffmanCode, br *BrotliBitReader, result *uint32) bool { + var val uint32 + var available_bits uint32 = BrotliGetAvailableBits(br) + if available_bits == 0 { + if table[0].bits == 0 { + *result = uint32(table[0].value) + return true + } + + return false /* No valid bits at all. */ + } + + val = uint32(BrotliGetBitsUnmasked(br)) + table = table[val&HUFFMAN_TABLE_MASK:] + if table[0].bits <= HUFFMAN_TABLE_BITS { + if uint32(table[0].bits) <= available_bits { + BrotliDropBits(br, uint32(table[0].bits)) + *result = uint32(table[0].value) + return true + } else { + return false /* Not enough bits for the first level. */ + } + } + + if available_bits <= HUFFMAN_TABLE_BITS { + return false /* Not enough bits to move to the second level. */ + } + + /* Speculatively drop HUFFMAN_TABLE_BITS. */ + val = (val & BitMask(uint32(table[0].bits))) >> HUFFMAN_TABLE_BITS + + available_bits -= HUFFMAN_TABLE_BITS + table = table[uint32(table[0].value)+val:] + if available_bits < uint32(table[0].bits) { + return false /* Not enough bits for the second level. */ + } + + BrotliDropBits(br, HUFFMAN_TABLE_BITS+uint32(table[0].bits)) + *result = uint32(table[0].value) + return true +} + +func SafeReadSymbol(table []HuffmanCode, br *BrotliBitReader, result *uint32) bool { + var val uint32 + if BrotliSafeGetBits(br, 15, &val) { + *result = DecodeSymbol(val, table, br) + return true + } + + return SafeDecodeSymbol(table, br, result) +} + +/* Makes a look-up in first level Huffman table. Peeks 8 bits. */ +func PreloadSymbol(safe int, table []HuffmanCode, br *BrotliBitReader, bits *uint32, value *uint32) { + if safe != 0 { + return + } + + table = table[BrotliGetBits(br, HUFFMAN_TABLE_BITS):] + *bits = uint32(table[0].bits) + *value = uint32(table[0].value) +} + +/* Decodes the next Huffman code using data prepared by PreloadSymbol. + Reads 0 - 15 bits. Also peeks 8 following bits. */ +func ReadPreloadedSymbol(table []HuffmanCode, br *BrotliBitReader, bits *uint32, value *uint32) uint32 { + var result uint32 = *value + var ext []HuffmanCode + if *bits > HUFFMAN_TABLE_BITS { + var val uint32 = BrotliGet16BitsUnmasked(br) + ext = table[val&HUFFMAN_TABLE_MASK:][*value:] + var mask uint32 = BitMask((*bits - HUFFMAN_TABLE_BITS)) + BrotliDropBits(br, HUFFMAN_TABLE_BITS) + ext = ext[(val>>HUFFMAN_TABLE_BITS)&mask:] + BrotliDropBits(br, uint32(ext[0].bits)) + result = uint32(ext[0].value) + } else { + BrotliDropBits(br, *bits) + } + + PreloadSymbol(0, table, br, bits, value) + return result +} + +func Log2Floor(x uint32) uint32 { + var result uint32 = 0 + for x != 0 { + x >>= 1 + result++ + } + + return result +} + +/* Reads (s->symbol + 1) symbols. + Totally 1..4 symbols are read, 1..11 bits each. + The list of symbols MUST NOT contain duplicates. */ +func ReadSimpleHuffmanSymbols(alphabet_size uint32, max_symbol uint32, s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var max_bits uint32 = Log2Floor(alphabet_size - 1) + var i uint32 = s.sub_loop_counter + /* max_bits == 1..11; symbol == 0..3; 1..44 bits will be read. */ + + var num_symbols uint32 = s.symbol + for i <= num_symbols { + var v uint32 + if !BrotliSafeReadBits(br, max_bits, &v) { + s.sub_loop_counter = i + s.substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_READ + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if v >= max_symbol { + return BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET + } + + s.symbols_lists_array[i] = uint16(v) + i++ + } + + for i = 0; i < num_symbols; i++ { + var k uint32 = i + 1 + for ; k <= num_symbols; k++ { + if s.symbols_lists_array[i] == s.symbols_lists_array[k] { + return BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME + } + } + } + + return BROTLI_DECODER_SUCCESS +} + +/* Process single decoded symbol code length: + A) reset the repeat variable + B) remember code length (if it is not 0) + C) extend corresponding index-chain + D) reduce the Huffman space + E) update the histogram */ +func ProcessSingleCodeLength(code_len uint32, symbol *uint32, repeat *uint32, space *uint32, prev_code_len *uint32, symbol_lists SymbolList, code_length_histo []uint16, next_symbol []int) { + *repeat = 0 + if code_len != 0 { /* code_len == 1..15 */ + SymbolListPut(symbol_lists, next_symbol[code_len], uint16(*symbol)) + next_symbol[code_len] = int(*symbol) + *prev_code_len = code_len + *space -= 32768 >> code_len + code_length_histo[code_len]++ + } + + (*symbol)++ +} + +/* Process repeated symbol code length. + A) Check if it is the extension of previous repeat sequence; if the decoded + value is not BROTLI_REPEAT_PREVIOUS_CODE_LENGTH, then it is a new + symbol-skip + B) Update repeat variable + C) Check if operation is feasible (fits alphabet) + D) For each symbol do the same operations as in ProcessSingleCodeLength + + PRECONDITION: code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH or + code_len == BROTLI_REPEAT_ZERO_CODE_LENGTH */ +func ProcessRepeatedCodeLength(code_len uint32, repeat_delta uint32, alphabet_size uint32, symbol *uint32, repeat *uint32, space *uint32, prev_code_len *uint32, repeat_code_len *uint32, symbol_lists SymbolList, code_length_histo []uint16, next_symbol []int) { + var old_repeat uint32 /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */ /* for BROTLI_REPEAT_ZERO_CODE_LENGTH */ + var extra_bits uint32 = 3 + var new_len uint32 = 0 + if code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH { + new_len = *prev_code_len + extra_bits = 2 + } + + if *repeat_code_len != new_len { + *repeat = 0 + *repeat_code_len = new_len + } + + old_repeat = *repeat + if *repeat > 0 { + *repeat -= 2 + *repeat <<= extra_bits + } + + *repeat += repeat_delta + 3 + repeat_delta = *repeat - old_repeat + if *symbol+repeat_delta > alphabet_size { + *symbol = alphabet_size + *space = 0xFFFFF + return + } + + if *repeat_code_len != 0 { + var last uint = uint(*symbol + repeat_delta) + var next int = next_symbol[*repeat_code_len] + for { + SymbolListPut(symbol_lists, next, uint16(*symbol)) + next = int(*symbol) + (*symbol)++ + if (*symbol) == uint32(last) { + break + } + } + + next_symbol[*repeat_code_len] = next + *space -= repeat_delta << (15 - *repeat_code_len) + code_length_histo[*repeat_code_len] = uint16(uint32(code_length_histo[*repeat_code_len]) + repeat_delta) + } else { + *symbol += repeat_delta + } +} + +/* Reads and decodes symbol codelengths. */ +func ReadSymbolCodeLengths(alphabet_size uint32, s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var symbol uint32 = s.symbol + var repeat uint32 = s.repeat + var space uint32 = s.space + var prev_code_len uint32 = s.prev_code_len + var repeat_code_len uint32 = s.repeat_code_len + var symbol_lists SymbolList = s.symbol_lists + var code_length_histo []uint16 = s.code_length_histo[:] + var next_symbol []int = s.next_symbol[:] + if !BrotliWarmupBitReader(br) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + var p []HuffmanCode + for symbol < alphabet_size && space > 0 { + p = s.table[:] + var code_len uint32 + if !BrotliCheckInputAmount(br, BROTLI_SHORT_FILL_BIT_WINDOW_READ) { + s.symbol = symbol + s.repeat = repeat + s.prev_code_len = prev_code_len + s.repeat_code_len = repeat_code_len + s.space = space + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + BrotliFillBitWindow16(br) + p = p[BrotliGetBitsUnmasked(br)&uint64(BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH)):] + BrotliDropBits(br, uint32(p[0].bits)) /* Use 1..5 bits. */ + code_len = uint32(p[0].value) /* code_len == 0..17 */ + if code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH { + ProcessSingleCodeLength(code_len, &symbol, &repeat, &space, &prev_code_len, symbol_lists, code_length_histo, next_symbol) /* code_len == 16..17, extra_bits == 2..3 */ + } else { + var extra_bits uint32 + if code_len == BROTLI_REPEAT_PREVIOUS_CODE_LENGTH { + extra_bits = 2 + } else { + extra_bits = 3 + } + var repeat_delta uint32 = uint32(BrotliGetBitsUnmasked(br)) & BitMask(extra_bits) + BrotliDropBits(br, extra_bits) + ProcessRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &symbol, &repeat, &space, &prev_code_len, &repeat_code_len, symbol_lists, code_length_histo, next_symbol) + } + } + + s.space = space + return BROTLI_DECODER_SUCCESS +} + +func SafeReadSymbolCodeLengths(alphabet_size uint32, s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var get_byte bool = false + var p []HuffmanCode + for s.symbol < alphabet_size && s.space > 0 { + p = s.table[:] + var code_len uint32 + var available_bits uint32 + var bits uint32 = 0 + if get_byte && !BrotliPullByte(br) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + get_byte = false + available_bits = BrotliGetAvailableBits(br) + if available_bits != 0 { + bits = uint32(BrotliGetBitsUnmasked(br)) + } + + p = p[bits&BitMask(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH):] + if uint32(p[0].bits) > available_bits { + get_byte = true + continue + } + + code_len = uint32(p[0].value) /* code_len == 0..17 */ + if code_len < BROTLI_REPEAT_PREVIOUS_CODE_LENGTH { + BrotliDropBits(br, uint32(p[0].bits)) + ProcessSingleCodeLength(code_len, &s.symbol, &s.repeat, &s.space, &s.prev_code_len, s.symbol_lists, s.code_length_histo[:], s.next_symbol[:]) /* code_len == 16..17, extra_bits == 2..3 */ + } else { + var extra_bits uint32 = code_len - 14 + var repeat_delta uint32 = (bits >> p[0].bits) & BitMask(extra_bits) + if available_bits < uint32(p[0].bits)+extra_bits { + get_byte = true + continue + } + + BrotliDropBits(br, uint32(p[0].bits)+extra_bits) + ProcessRepeatedCodeLength(code_len, repeat_delta, alphabet_size, &s.symbol, &s.repeat, &s.space, &s.prev_code_len, &s.repeat_code_len, s.symbol_lists, s.code_length_histo[:], s.next_symbol[:]) + } + } + + return BROTLI_DECODER_SUCCESS +} + +/* Reads and decodes 15..18 codes using static prefix code. + Each code is 2..4 bits long. In total 30..72 bits are used. */ +func ReadCodeLengthCodeLengths(s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var num_codes uint32 = s.repeat + var space uint32 = s.space + var i uint32 = s.sub_loop_counter + for ; i < BROTLI_CODE_LENGTH_CODES; i++ { + var code_len_idx byte = kCodeLengthCodeOrder[i] + var ix uint32 + var v uint32 + if !BrotliSafeGetBits(br, 4, &ix) { + var available_bits uint32 = BrotliGetAvailableBits(br) + if available_bits != 0 { + ix = uint32(BrotliGetBitsUnmasked(br) & 0xF) + } else { + ix = 0 + } + + if uint32(kCodeLengthPrefixLength[ix]) > available_bits { + s.sub_loop_counter = i + s.repeat = num_codes + s.space = space + s.substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + } + + v = uint32(kCodeLengthPrefixValue[ix]) + BrotliDropBits(br, uint32(kCodeLengthPrefixLength[ix])) + s.code_length_code_lengths[code_len_idx] = byte(v) + if v != 0 { + space = space - (32 >> v) + num_codes++ + s.code_length_histo[v]++ + if space-1 >= 32 { + /* space is 0 or wrapped around. */ + break + } + } + } + + if num_codes != 1 && space != 0 { + return BROTLI_DECODER_ERROR_FORMAT_CL_SPACE + } + + return BROTLI_DECODER_SUCCESS +} + +/* Decodes the Huffman tables. + There are 2 scenarios: + A) Huffman code contains only few symbols (1..4). Those symbols are read + directly; their code lengths are defined by the number of symbols. + For this scenario 4 - 49 bits will be read. + + B) 2-phase decoding: + B.1) Small Huffman table is decoded; it is specified with code lengths + encoded with predefined entropy code. 32 - 74 bits are used. + B.2) Decoded table is used to decode code lengths of symbols in resulting + Huffman table. In worst case 3520 bits are read. */ +func ReadHuffmanCode(alphabet_size uint32, max_symbol uint32, table []HuffmanCode, opt_table_size *uint32, s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + + /* Unnecessary masking, but might be good for safety. */ + alphabet_size &= 0x7FF + + /* State machine. */ + for { + switch s.substate_huffman { + case BROTLI_STATE_HUFFMAN_NONE: + if !BrotliSafeReadBits(br, 2, &s.sub_loop_counter) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + /* The value is used as follows: + 1 for simple code; + 0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */ + if s.sub_loop_counter != 1 { + s.space = 32 + s.repeat = 0 /* num_codes */ + var i int + for i = 0; i <= BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH; i++ { + s.code_length_histo[i] = 0 + } + + for i = 0; i < BROTLI_CODE_LENGTH_CODES; i++ { + s.code_length_code_lengths[i] = 0 + } + + s.substate_huffman = BROTLI_STATE_HUFFMAN_COMPLEX + continue + } + fallthrough + + /* Read symbols, codes & code lengths directly. */ + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_SIMPLE_SIZE: + if !BrotliSafeReadBits(br, 2, &s.symbol) { /* num_symbols */ + s.substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_SIZE + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + s.sub_loop_counter = 0 + fallthrough + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_SIMPLE_READ: + { + var result int = ReadSimpleHuffmanSymbols(alphabet_size, max_symbol, s) + if result != BROTLI_DECODER_SUCCESS { + return result + } + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_SIMPLE_BUILD: + { + var table_size uint32 + if s.symbol == 3 { + var bits uint32 + if !BrotliSafeReadBits(br, 1, &bits) { + s.substate_huffman = BROTLI_STATE_HUFFMAN_SIMPLE_BUILD + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + s.symbol += bits + } + + table_size = BrotliBuildSimpleHuffmanTable(table, HUFFMAN_TABLE_BITS, s.symbols_lists_array[:], s.symbol) + if opt_table_size != nil { + *opt_table_size = table_size + } + + s.substate_huffman = BROTLI_STATE_HUFFMAN_NONE + return BROTLI_DECODER_SUCCESS + } + fallthrough + + /* Decode Huffman-coded code lengths. */ + case BROTLI_STATE_HUFFMAN_COMPLEX: + { + var i uint32 + var result int = ReadCodeLengthCodeLengths(s) + if result != BROTLI_DECODER_SUCCESS { + return result + } + + BrotliBuildCodeLengthsHuffmanTable(s.table[:], s.code_length_code_lengths[:], s.code_length_histo[:]) + for i = 0; i < 16; i++ { + s.code_length_histo[i] = 0 + } + + for i = 0; i <= BROTLI_HUFFMAN_MAX_CODE_LENGTH; i++ { + s.next_symbol[i] = int(i) - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1) + SymbolListPut(s.symbol_lists, s.next_symbol[i], 0xFFFF) + } + + s.symbol = 0 + s.prev_code_len = BROTLI_INITIAL_REPEATED_CODE_LENGTH + s.repeat = 0 + s.repeat_code_len = 0 + s.space = 32768 + s.substate_huffman = BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS: + { + var table_size uint32 + var result int = ReadSymbolCodeLengths(max_symbol, s) + if result == BROTLI_DECODER_NEEDS_MORE_INPUT { + result = SafeReadSymbolCodeLengths(max_symbol, s) + } + + if result != BROTLI_DECODER_SUCCESS { + return result + } + + if s.space != 0 { + return BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE + } + + table_size = BrotliBuildHuffmanTable(table, HUFFMAN_TABLE_BITS, s.symbol_lists, s.code_length_histo[:]) + if opt_table_size != nil { + *opt_table_size = table_size + } + + s.substate_huffman = BROTLI_STATE_HUFFMAN_NONE + return BROTLI_DECODER_SUCCESS + } + fallthrough + + default: + return BROTLI_DECODER_ERROR_UNREACHABLE + } + } +} + +/* Decodes a block length by reading 3..39 bits. */ +func ReadBlockLength(table []HuffmanCode, br *BrotliBitReader) uint32 { + var code uint32 + var nbits uint32 + code = ReadSymbol(table, br) + nbits = uint32(kBlockLengthPrefixCode1[code].nbits) /* nbits == 2..24 */ + return uint32(kBlockLengthPrefixCode1[code].offset) + BrotliReadBits(br, nbits) +} + +/* WARNING: if state is not BROTLI_STATE_READ_BLOCK_LENGTH_NONE, then + reading can't be continued with ReadBlockLength. */ +func SafeReadBlockLength(s *BrotliDecoderState, result *uint32, table []HuffmanCode, br *BrotliBitReader) bool { + var index uint32 + if s.substate_read_block_length == BROTLI_STATE_READ_BLOCK_LENGTH_NONE { + if !SafeReadSymbol(table, br, &index) { + return false + } + } else { + index = s.block_length_index + } + { + var bits uint32 /* nbits == 2..24 */ + var nbits uint32 = uint32(kBlockLengthPrefixCode1[index].nbits) + if !BrotliSafeReadBits(br, nbits, &bits) { + s.block_length_index = index + s.substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX + return false + } + + *result = uint32(kBlockLengthPrefixCode1[index].offset) + bits + s.substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE + return true + } +} + +/* Transform: + 1) initialize list L with values 0, 1,... 255 + 2) For each input element X: + 2.1) let Y = L[X] + 2.2) remove X-th element from L + 2.3) prepend Y to L + 2.4) append Y to output + + In most cases max(Y) <= 7, so most of L remains intact. + To reduce the cost of initialization, we reuse L, remember the upper bound + of Y values, and reinitialize only first elements in L. + + Most of input values are 0 and 1. To reduce number of branches, we replace + inner for loop with do-while. */ +func InverseMoveToFrontTransform(v []byte, v_len uint32, state *BrotliDecoderState) { + var mtf [256]byte + var i int + for i = 1; i < 256; i++ { + mtf[i] = byte(i) + } + var mtf_1 byte + + /* Transform the input. */ + for i = 0; uint32(i) < v_len; i++ { + var index int = int(v[i]) + var value byte = mtf[index] + v[i] = value + mtf_1 = value + for index >= 1 { + index-- + mtf[index+1] = mtf[index] + } + + mtf[0] = mtf_1 + } +} + +/* Decodes a series of Huffman table using ReadHuffmanCode function. */ +func HuffmanTreeGroupDecode(group *HuffmanTreeGroup, s *BrotliDecoderState) int { + if s.substate_tree_group != BROTLI_STATE_TREE_GROUP_LOOP { + s.next = group.codes + s.htree_index = 0 + s.substate_tree_group = BROTLI_STATE_TREE_GROUP_LOOP + } + + for s.htree_index < int(group.num_htrees) { + var table_size uint32 + var result int = ReadHuffmanCode(uint32(group.alphabet_size), uint32(group.max_symbol), s.next, &table_size, s) + if result != BROTLI_DECODER_SUCCESS { + return result + } + group.htrees[s.htree_index] = s.next + s.next = s.next[table_size:] + s.htree_index++ + } + + s.substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE + return BROTLI_DECODER_SUCCESS +} + +/* Decodes a context map. + Decoding is done in 4 phases: + 1) Read auxiliary information (6..16 bits) and allocate memory. + In case of trivial context map, decoding is finished at this phase. + 2) Decode Huffman table using ReadHuffmanCode function. + This table will be used for reading context map items. + 3) Read context map items; "0" values could be run-length encoded. + 4) Optionally, apply InverseMoveToFront transform to the resulting map. */ +func DecodeContextMap(context_map_size uint32, num_htrees *uint32, context_map_arg *[]byte, s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var result int = BROTLI_DECODER_SUCCESS + + switch int(s.substate_context_map) { + case BROTLI_STATE_CONTEXT_MAP_NONE: + result = DecodeVarLenUint8(s, br, num_htrees) + if result != BROTLI_DECODER_SUCCESS { + return result + } + + (*num_htrees)++ + s.context_index = 0 + *context_map_arg = make([]byte, uint(context_map_size)) + if *context_map_arg == nil { + return BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP + } + + if *num_htrees <= 1 { + for i := 0; i < int(context_map_size); i++ { + (*context_map_arg)[i] = 0 + } + return BROTLI_DECODER_SUCCESS + } + + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_READ_PREFIX + fallthrough + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MAP_READ_PREFIX: + { + var bits uint32 + + /* In next stage ReadHuffmanCode uses at least 4 bits, so it is safe + to peek 4 bits ahead. */ + if !BrotliSafeGetBits(br, 5, &bits) { + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits&1 != 0 { /* Use RLE for zeros. */ + s.max_run_length_prefix = (bits >> 1) + 1 + BrotliDropBits(br, 5) + } else { + s.max_run_length_prefix = 0 + BrotliDropBits(br, 1) + } + + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_HUFFMAN + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MAP_HUFFMAN: + { + var alphabet_size uint32 = *num_htrees + s.max_run_length_prefix + result = ReadHuffmanCode(alphabet_size, alphabet_size, s.context_map_table[:], nil, s) + if result != BROTLI_DECODER_SUCCESS { + return result + } + s.code = 0xFFFF + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_DECODE + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MAP_DECODE: + { + var context_index uint32 = s.context_index + var max_run_length_prefix uint32 = s.max_run_length_prefix + var context_map []byte = *context_map_arg + var code uint32 = s.code + var skip_preamble bool = (code != 0xFFFF) + for context_index < context_map_size || skip_preamble { + if !skip_preamble { + if !SafeReadSymbol(s.context_map_table[:], br, &code) { + s.code = 0xFFFF + s.context_index = context_index + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if code == 0 { + context_map[context_index] = 0 + context_index++ + continue + } + + if code > max_run_length_prefix { + context_map[context_index] = byte(code - max_run_length_prefix) + context_index++ + continue + } + } else { + skip_preamble = false + } + + /* RLE sub-stage. */ + { + var reps uint32 + if !BrotliSafeReadBits(br, code, &reps) { + s.code = code + s.context_index = context_index + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + reps += 1 << code + if context_index+reps > context_map_size { + return BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT + } + + for { + context_map[context_index] = 0 + context_index++ + reps-- + if reps == 0 { + break + } + } + } + } + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MAP_TRANSFORM: + { + var bits uint32 + if !BrotliSafeReadBits(br, 1, &bits) { + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_TRANSFORM + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + if bits != 0 { + InverseMoveToFrontTransform(*context_map_arg, context_map_size, s) + } + + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE + return BROTLI_DECODER_SUCCESS + } + fallthrough + + default: + return BROTLI_DECODER_ERROR_UNREACHABLE + } +} + +/* Decodes a command or literal and updates block type ring-buffer. + Reads 3..54 bits. */ +func DecodeBlockTypeAndLength(safe int, s *BrotliDecoderState, tree_type int) bool { + var max_block_type uint32 = s.num_block_types[tree_type] + var type_tree []HuffmanCode + type_tree = s.block_type_trees[tree_type*BROTLI_HUFFMAN_MAX_SIZE_258:] + var len_tree []HuffmanCode + len_tree = s.block_len_trees[tree_type*BROTLI_HUFFMAN_MAX_SIZE_26:] + var br *BrotliBitReader = &s.br + var ringbuffer []uint32 = s.block_type_rb[tree_type*2:] + var block_type uint32 + if max_block_type <= 1 { + return false + } + + /* Read 0..15 + 3..39 bits. */ + if safe == 0 { + block_type = ReadSymbol(type_tree, br) + s.block_length[tree_type] = ReadBlockLength(len_tree, br) + } else { + var memento BrotliBitReaderState + BrotliBitReaderSaveState(br, &memento) + if !SafeReadSymbol(type_tree, br, &block_type) { + return false + } + if !SafeReadBlockLength(s, &s.block_length[tree_type], len_tree, br) { + s.substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE + BrotliBitReaderRestoreState(br, &memento) + return false + } + } + + if block_type == 1 { + block_type = ringbuffer[1] + 1 + } else if block_type == 0 { + block_type = ringbuffer[0] + } else { + block_type -= 2 + } + + if block_type >= max_block_type { + block_type -= max_block_type + } + + ringbuffer[0] = ringbuffer[1] + ringbuffer[1] = block_type + return true +} + +func DetectTrivialLiteralBlockTypes(s *BrotliDecoderState) { + var i uint + for i = 0; i < 8; i++ { + s.trivial_literal_contexts[i] = 0 + } + for i = 0; uint32(i) < s.num_block_types[0]; i++ { + var offset uint = i << BROTLI_LITERAL_CONTEXT_BITS + var error uint = 0 + var sample uint = uint(s.context_map[offset]) + var j uint + for j = 0; j < 1<>5] |= 1 << (i & 31) + } + } +} + +func PrepareLiteralDecoding(s *BrotliDecoderState) { + var context_mode byte + var trivial uint + var block_type uint32 = s.block_type_rb[1] + var context_offset uint32 = block_type << BROTLI_LITERAL_CONTEXT_BITS + s.context_map_slice = s.context_map[context_offset:] + trivial = uint(s.trivial_literal_contexts[block_type>>5]) + s.trivial_literal_context = int((trivial >> (block_type & 31)) & 1) + s.literal_htree = []HuffmanCode(s.literal_hgroup.htrees[s.context_map_slice[0]]) + context_mode = s.context_modes[block_type] & 3 + s.context_lookup = BROTLI_CONTEXT_LUT(int(context_mode)) +} + +/* Decodes the block type and updates the state for literal context. + Reads 3..54 bits. */ +func DecodeLiteralBlockSwitchInternal(safe int, s *BrotliDecoderState) bool { + if !DecodeBlockTypeAndLength(safe, s, 0) { + return false + } + + PrepareLiteralDecoding(s) + return true +} + +func DecodeLiteralBlockSwitch(s *BrotliDecoderState) { + DecodeLiteralBlockSwitchInternal(0, s) +} + +func SafeDecodeLiteralBlockSwitch(s *BrotliDecoderState) bool { + return DecodeLiteralBlockSwitchInternal(1, s) +} + +/* Block switch for insert/copy length. + Reads 3..54 bits. */ +func DecodeCommandBlockSwitchInternal(safe int, s *BrotliDecoderState) bool { + if !DecodeBlockTypeAndLength(safe, s, 1) { + return false + } + + s.htree_command = []HuffmanCode(s.insert_copy_hgroup.htrees[s.block_type_rb[3]]) + return true +} + +func DecodeCommandBlockSwitch(s *BrotliDecoderState) { + DecodeCommandBlockSwitchInternal(0, s) +} + +func SafeDecodeCommandBlockSwitch(s *BrotliDecoderState) bool { + return DecodeCommandBlockSwitchInternal(1, s) +} + +/* Block switch for distance codes. + Reads 3..54 bits. */ +func DecodeDistanceBlockSwitchInternal(safe int, s *BrotliDecoderState) bool { + if !DecodeBlockTypeAndLength(safe, s, 2) { + return false + } + + s.dist_context_map_slice = s.dist_context_map[s.block_type_rb[5]< s.ringbuffer_size { + pos = uint(s.ringbuffer_size) + } else { + pos = uint(s.pos) + } + var partial_pos_rb uint = (s.rb_roundtrips * uint(s.ringbuffer_size)) + pos + return partial_pos_rb - s.partial_pos_out +} + +/* Dumps output. + Returns BROTLI_DECODER_NEEDS_MORE_OUTPUT only if there is more output to push + and either ring-buffer is as big as window size, or |force| is true. */ +func WriteRingBuffer(s *BrotliDecoderState, available_out *uint, next_out *[]byte, total_out *uint, force bool) int { + var start []byte + start = s.ringbuffer[s.partial_pos_out&uint(s.ringbuffer_mask):] + var to_write uint = UnwrittenBytes(s, true) + var num_written uint = *available_out + if num_written > to_write { + num_written = to_write + } + + if s.meta_block_remaining_len < 0 { + return BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 + } + + if next_out != nil && *next_out == nil { + *next_out = start + } else { + if next_out != nil { + copy(*next_out, start[:num_written]) + *next_out = (*next_out)[num_written:] + } + } + + *available_out -= num_written + s.partial_pos_out += num_written + if total_out != nil { + *total_out = s.partial_pos_out + } + + if num_written < to_write { + if s.ringbuffer_size == 1<= s.ringbuffer_size { + s.pos -= s.ringbuffer_size + s.rb_roundtrips++ + if uint(s.pos) != 0 { + s.should_wrap_ringbuffer = 1 + } else { + s.should_wrap_ringbuffer = 0 + } + } + + return BROTLI_DECODER_SUCCESS +} + +func WrapRingBuffer(s *BrotliDecoderState) { + if s.should_wrap_ringbuffer != 0 { + copy(s.ringbuffer, s.ringbuffer_end[:uint(s.pos)]) + s.should_wrap_ringbuffer = 0 + } +} + +/* Allocates ring-buffer. + + s->ringbuffer_size MUST be updated by BrotliCalculateRingBufferSize before + this function is called. + + Last two bytes of ring-buffer are initialized to 0, so context calculation + could be done uniformly for the first two and all other positions. */ +func BrotliEnsureRingBuffer(s *BrotliDecoderState) bool { + var old_ringbuffer []byte = s.ringbuffer + if s.ringbuffer_size == s.new_ringbuffer_size { + return true + } + + s.ringbuffer = make([]byte, uint(s.new_ringbuffer_size)+uint(kRingBufferWriteAheadSlack)) + if s.ringbuffer == nil { + /* Restore previous value. */ + s.ringbuffer = old_ringbuffer + + return false + } + + s.ringbuffer[s.new_ringbuffer_size-2] = 0 + s.ringbuffer[s.new_ringbuffer_size-1] = 0 + + if !(old_ringbuffer == nil) { + copy(s.ringbuffer, old_ringbuffer[:uint(s.pos)]) + + old_ringbuffer = nil + } + + s.ringbuffer_size = s.new_ringbuffer_size + s.ringbuffer_mask = s.new_ringbuffer_size - 1 + s.ringbuffer_end = s.ringbuffer[s.ringbuffer_size:] + + return true +} + +func CopyUncompressedBlockToOutput(available_out *uint, next_out *[]byte, total_out *uint, s *BrotliDecoderState) int { + /* TODO: avoid allocation for single uncompressed block. */ + if !BrotliEnsureRingBuffer(s) { + return BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 + } + + /* State machine */ + for { + switch s.substate_uncompressed { + case BROTLI_STATE_UNCOMPRESSED_NONE: + { + var nbytes int = int(BrotliGetRemainingBytes(&s.br)) + if nbytes > s.meta_block_remaining_len { + nbytes = s.meta_block_remaining_len + } + + if s.pos+nbytes > s.ringbuffer_size { + nbytes = s.ringbuffer_size - s.pos + } + + /* Copy remaining bytes from s->br.buf_ to ring-buffer. */ + BrotliCopyBytes(s.ringbuffer[s.pos:], &s.br, uint(nbytes)) + + s.pos += nbytes + s.meta_block_remaining_len -= nbytes + if s.pos < 1<>1 >= min_size { + new_ringbuffer_size >>= 1 + } + } + + s.new_ringbuffer_size = new_ringbuffer_size +} + +/* Reads 1..256 2-bit context modes. */ +func ReadContextModes(s *BrotliDecoderState) int { + var br *BrotliBitReader = &s.br + var i int = s.loop_counter + + for i < int(s.num_block_types[0]) { + var bits uint32 + if !BrotliSafeReadBits(br, 2, &bits) { + s.loop_counter = i + return BROTLI_DECODER_NEEDS_MORE_INPUT + } + + s.context_modes[i] = byte(bits) + i++ + } + + return BROTLI_DECODER_SUCCESS +} + +func TakeDistanceFromRingBuffer(s *BrotliDecoderState) { + if s.distance_code == 0 { + s.dist_rb_idx-- + s.distance_code = s.dist_rb[s.dist_rb_idx&3] + + /* Compensate double distance-ring-buffer roll for dictionary items. */ + s.distance_context = 1 + } else { + var distance_code int = s.distance_code << 1 + var kDistanceShortCodeIndexOffset uint32 = 0xAAAFFF1B + var kDistanceShortCodeValueOffset uint32 = 0xFA5FA500 + var v int = (s.dist_rb_idx + int(kDistanceShortCodeIndexOffset>>uint(distance_code))) & 0x3 + /* kDistanceShortCodeIndexOffset has 2-bit values from LSB: + 3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 */ + + /* kDistanceShortCodeValueOffset has 2-bit values from LSB: + -0, 0,-0, 0,-1, 1,-2, 2,-3, 3,-1, 1,-2, 2,-3, 3 */ + s.distance_code = s.dist_rb[v] + + v = int(kDistanceShortCodeValueOffset>>uint(distance_code)) & 0x3 + if distance_code&0x3 != 0 { + s.distance_code += v + } else { + s.distance_code -= v + if s.distance_code <= 0 { + /* A huge distance will cause a () soon. + This is a little faster than failing here. */ + s.distance_code = 0x7FFFFFFF + } + } + } +} + +func SafeReadBits(br *BrotliBitReader, n_bits uint32, val *uint32) bool { + if n_bits != 0 { + return BrotliSafeReadBits(br, n_bits, val) + } else { + *val = 0 + return true + } +} + +/* Precondition: s->distance_code < 0. */ +func ReadDistanceInternal(safe int, s *BrotliDecoderState, br *BrotliBitReader) bool { + var distval int + var memento BrotliBitReaderState + var distance_tree []HuffmanCode = []HuffmanCode(s.distance_hgroup.htrees[s.dist_htree_index]) + if safe == 0 { + s.distance_code = int(ReadSymbol(distance_tree, br)) + } else { + var code uint32 + BrotliBitReaderSaveState(br, &memento) + if !SafeReadSymbol(distance_tree, br, &code) { + return false + } + + s.distance_code = int(code) + } + + /* Convert the distance code to the actual distance by possibly + looking up past distances from the s->ringbuffer. */ + s.distance_context = 0 + + if s.distance_code&^0xF == 0 { + TakeDistanceFromRingBuffer(s) + s.block_length[2]-- + return true + } + + distval = s.distance_code - int(s.num_direct_distance_codes) + if distval >= 0 { + var nbits uint32 + var postfix int + var offset int + if safe == 0 && (s.distance_postfix_bits == 0) { + nbits = (uint32(distval) >> 1) + 1 + offset = ((2 + (distval & 1)) << nbits) - 4 + s.distance_code = int(s.num_direct_distance_codes) + offset + int(BrotliReadBits(br, nbits)) + } else { + /* This branch also works well when s->distance_postfix_bits == 0. */ + var bits uint32 + postfix = distval & s.distance_postfix_mask + distval >>= s.distance_postfix_bits + nbits = (uint32(distval) >> 1) + 1 + if safe != 0 { + if !SafeReadBits(br, nbits, &bits) { + s.distance_code = -1 /* Restore precondition. */ + BrotliBitReaderRestoreState(br, &memento) + return false + } + } else { + bits = BrotliReadBits(br, nbits) + } + + offset = ((2 + (distval & 1)) << nbits) - 4 + s.distance_code = int(s.num_direct_distance_codes) + ((offset + int(bits)) << s.distance_postfix_bits) + postfix + } + } + + s.distance_code = s.distance_code - BROTLI_NUM_DISTANCE_SHORT_CODES + 1 + s.block_length[2]-- + return true +} + +func ReadDistance(s *BrotliDecoderState, br *BrotliBitReader) { + ReadDistanceInternal(0, s, br) +} + +func SafeReadDistance(s *BrotliDecoderState, br *BrotliBitReader) bool { + return ReadDistanceInternal(1, s, br) +} + +func ReadCommandInternal(safe int, s *BrotliDecoderState, br *BrotliBitReader, insert_length *int) bool { + var cmd_code uint32 + var insert_len_extra uint32 = 0 + var copy_length uint32 + var v CmdLutElement + var memento BrotliBitReaderState + if safe == 0 { + cmd_code = ReadSymbol(s.htree_command, br) + } else { + BrotliBitReaderSaveState(br, &memento) + if !SafeReadSymbol(s.htree_command, br, &cmd_code) { + return false + } + } + + v = kCmdLut[cmd_code] + s.distance_code = int(v.distance_code) + s.distance_context = int(v.context) + s.dist_htree_index = s.dist_context_map_slice[s.distance_context] + *insert_length = int(v.insert_len_offset) + if safe == 0 { + if v.insert_len_extra_bits != 0 { + insert_len_extra = BrotliReadBits(br, uint32(v.insert_len_extra_bits)) + } + + copy_length = BrotliReadBits(br, uint32(v.copy_len_extra_bits)) + } else { + if !SafeReadBits(br, uint32(v.insert_len_extra_bits), &insert_len_extra) || !SafeReadBits(br, uint32(v.copy_len_extra_bits), ©_length) { + BrotliBitReaderRestoreState(br, &memento) + return false + } + } + + s.copy_length = int(copy_length) + int(v.copy_len_offset) + s.block_length[1]-- + *insert_length += int(insert_len_extra) + return true +} + +func ReadCommand(s *BrotliDecoderState, br *BrotliBitReader, insert_length *int) { + ReadCommandInternal(0, s, br, insert_length) +} + +func SafeReadCommand(s *BrotliDecoderState, br *BrotliBitReader, insert_length *int) bool { + return ReadCommandInternal(1, s, br, insert_length) +} + +func CheckInputAmount(safe int, br *BrotliBitReader, num uint) bool { + if safe != 0 { + return true + } + + return BrotliCheckInputAmount(br, num) +} + +func ProcessCommandsInternal(safe int, s *BrotliDecoderState) int { + var pos int = s.pos + var i int = s.loop_counter + var result int = BROTLI_DECODER_SUCCESS + var br *BrotliBitReader = &s.br + var hc []HuffmanCode + + if !CheckInputAmount(safe, br, 28) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + if safe == 0 { + BrotliWarmupBitReader(br) + } + + /* Jump into state machine. */ + if s.state == BROTLI_STATE_COMMAND_BEGIN { + goto CommandBegin + } else if s.state == BROTLI_STATE_COMMAND_INNER { + goto CommandInner + } else if s.state == BROTLI_STATE_COMMAND_POST_DECODE_LITERALS { + goto CommandPostDecodeLiterals + } else if s.state == BROTLI_STATE_COMMAND_POST_WRAP_COPY { + goto CommandPostWrapCopy + } else { + return BROTLI_DECODER_ERROR_UNREACHABLE + } + +CommandBegin: + if safe != 0 { + s.state = BROTLI_STATE_COMMAND_BEGIN + } + + if !CheckInputAmount(safe, br, 28) { /* 156 bits + 7 bytes */ + s.state = BROTLI_STATE_COMMAND_BEGIN + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + if s.block_length[1] == 0 { + if safe != 0 { + if !SafeDecodeCommandBlockSwitch(s) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + DecodeCommandBlockSwitch(s) + } + + goto CommandBegin + } + + /* Read the insert/copy length in the command. */ + if safe != 0 { + if !SafeReadCommand(s, br, &i) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + ReadCommand(s, br, &i) + } + + if i == 0 { + goto CommandPostDecodeLiterals + } + + s.meta_block_remaining_len -= i + +CommandInner: + if safe != 0 { + s.state = BROTLI_STATE_COMMAND_INNER + } + + /* Read the literals in the command. */ + if s.trivial_literal_context != 0 { + var bits uint32 + var value uint32 + PreloadSymbol(safe, s.literal_htree, br, &bits, &value) + for { + if !CheckInputAmount(safe, br, 28) { /* 162 bits + 7 bytes */ + s.state = BROTLI_STATE_COMMAND_INNER + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + if s.block_length[0] == 0 { + if safe != 0 { + if !SafeDecodeLiteralBlockSwitch(s) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + DecodeLiteralBlockSwitch(s) + } + + PreloadSymbol(safe, s.literal_htree, br, &bits, &value) + if s.trivial_literal_context == 0 { + goto CommandInner + } + } + + if safe == 0 { + s.ringbuffer[pos] = byte(ReadPreloadedSymbol(s.literal_htree, br, &bits, &value)) + } else { + var literal uint32 + if !SafeReadSymbol(s.literal_htree, br, &literal) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + s.ringbuffer[pos] = byte(literal) + } + + s.block_length[0]-- + pos++ + if pos == s.ringbuffer_size { + s.state = BROTLI_STATE_COMMAND_INNER_WRITE + i-- + goto saveStateAndReturn + } + i-- + if i == 0 { + break + } + } + } else { + var p1 byte = s.ringbuffer[(pos-1)&s.ringbuffer_mask] + var p2 byte = s.ringbuffer[(pos-2)&s.ringbuffer_mask] + for { + var context byte + if !CheckInputAmount(safe, br, 28) { /* 162 bits + 7 bytes */ + s.state = BROTLI_STATE_COMMAND_INNER + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + if s.block_length[0] == 0 { + if safe != 0 { + if !SafeDecodeLiteralBlockSwitch(s) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + DecodeLiteralBlockSwitch(s) + } + + if s.trivial_literal_context != 0 { + goto CommandInner + } + } + + context = BROTLI_CONTEXT(p1, p2, s.context_lookup) + hc = []HuffmanCode(s.literal_hgroup.htrees[s.context_map_slice[context]]) + p2 = p1 + if safe == 0 { + p1 = byte(ReadSymbol(hc, br)) + } else { + var literal uint32 + if !SafeReadSymbol(hc, br, &literal) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + + p1 = byte(literal) + } + + s.ringbuffer[pos] = p1 + s.block_length[0]-- + pos++ + if pos == s.ringbuffer_size { + s.state = BROTLI_STATE_COMMAND_INNER_WRITE + i-- + goto saveStateAndReturn + } + i-- + if i == 0 { + break + } + } + } + + if s.meta_block_remaining_len <= 0 { + s.state = BROTLI_STATE_METABLOCK_DONE + goto saveStateAndReturn + } + +CommandPostDecodeLiterals: + if safe != 0 { + s.state = BROTLI_STATE_COMMAND_POST_DECODE_LITERALS + } + + if s.distance_code >= 0 { + /* Implicit distance case. */ + if s.distance_code != 0 { + s.distance_context = 0 + } else { + s.distance_context = 1 + } + + s.dist_rb_idx-- + s.distance_code = s.dist_rb[s.dist_rb_idx&3] + } else { + /* Read distance code in the command, unless it was implicitly zero. */ + if s.block_length[2] == 0 { + if safe != 0 { + if !SafeDecodeDistanceBlockSwitch(s) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + DecodeDistanceBlockSwitch(s) + } + } + + if safe != 0 { + if !SafeReadDistance(s, br) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + goto saveStateAndReturn + } + } else { + ReadDistance(s, br) + } + } + + if s.max_distance != s.max_backward_distance { + if pos < s.max_backward_distance { + s.max_distance = pos + } else { + s.max_distance = s.max_backward_distance + } + } + + i = s.copy_length + + /* Apply copy of LZ77 back-reference, or static dictionary reference if + the distance is larger than the max LZ77 distance */ + if s.distance_code > s.max_distance { + /* The maximum allowed distance is BROTLI_MAX_ALLOWED_DISTANCE = 0x7FFFFFFC. + With this choice, no signed overflow can occur after decoding + a special distance code (e.g., after adding 3 to the last distance). */ + if s.distance_code > BROTLI_MAX_ALLOWED_DISTANCE { + return BROTLI_DECODER_ERROR_FORMAT_DISTANCE + } + + if i >= BROTLI_MIN_DICTIONARY_WORD_LENGTH && i <= BROTLI_MAX_DICTIONARY_WORD_LENGTH { + var address int = s.distance_code - s.max_distance - 1 + var words *BrotliDictionary = s.dictionary + var transforms *BrotliTransforms = s.transforms + var offset int = int(s.dictionary.offsets_by_length[i]) + var shift uint32 = uint32(s.dictionary.size_bits_by_length[i]) + var mask int = int(BitMask(shift)) + var word_idx int = address & mask + var transform_idx int = address >> shift + + /* Compensate double distance-ring-buffer roll. */ + s.dist_rb_idx += s.distance_context + + offset += word_idx * i + if words.data == nil { + return BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET + } + + if transform_idx < int(transforms.num_transforms) { + var word []byte + word = words.data[offset:] + var len int = i + if transform_idx == int(transforms.cutOffTransforms[0]) { + copy(s.ringbuffer[pos:], word[:uint(len)]) + } else { + len = BrotliTransformDictionaryWord(s.ringbuffer[pos:], word, int(len), transforms, transform_idx) + } + + pos += int(len) + s.meta_block_remaining_len -= int(len) + if pos >= s.ringbuffer_size { + s.state = BROTLI_STATE_COMMAND_POST_WRITE_1 + goto saveStateAndReturn + } + } else { + return BROTLI_DECODER_ERROR_FORMAT_TRANSFORM + } + } else { + return BROTLI_DECODER_ERROR_FORMAT_DICTIONARY + } + } else { + var src_start int = (pos - s.distance_code) & s.ringbuffer_mask + var copy_dst []byte + copy_dst = s.ringbuffer[pos:] + var copy_src []byte + copy_src = s.ringbuffer[src_start:] + var dst_end int = pos + i + var src_end int = src_start + i + + /* Update the recent distances cache. */ + s.dist_rb[s.dist_rb_idx&3] = s.distance_code + + s.dist_rb_idx++ + s.meta_block_remaining_len -= i + + /* There are 32+ bytes of slack in the ring-buffer allocation. + Also, we have 16 short codes, that make these 16 bytes irrelevant + in the ring-buffer. Let's copy over them as a first guess. */ + copy(copy_dst, copy_src[:16]) + + if src_end > pos && dst_end > src_start { + /* Regions intersect. */ + goto CommandPostWrapCopy + } + + if dst_end >= s.ringbuffer_size || src_end >= s.ringbuffer_size { + /* At least one region wraps. */ + goto CommandPostWrapCopy + } + + pos += i + if i > 16 { + if i > 32 { + copy(copy_dst[16:], copy_src[16:][:uint(i-16)]) + } else { + /* This branch covers about 45% cases. + Fixed size short copy allows more compiler optimizations. */ + copy(copy_dst[16:], copy_src[16:][:16]) + } + } + } + + if s.meta_block_remaining_len <= 0 { + /* Next metablock, if any. */ + s.state = BROTLI_STATE_METABLOCK_DONE + + goto saveStateAndReturn + } else { + goto CommandBegin + } +CommandPostWrapCopy: + { + var wrap_guard int = s.ringbuffer_size - pos + for { + i-- + if i < 0 { + break + } + s.ringbuffer[pos] = s.ringbuffer[(pos-s.distance_code)&s.ringbuffer_mask] + pos++ + wrap_guard-- + if wrap_guard == 0 { + s.state = BROTLI_STATE_COMMAND_POST_WRITE_2 + goto saveStateAndReturn + } + } + } + + if s.meta_block_remaining_len <= 0 { + /* Next metablock, if any. */ + s.state = BROTLI_STATE_METABLOCK_DONE + + goto saveStateAndReturn + } else { + goto CommandBegin + } + +saveStateAndReturn: + s.pos = pos + s.loop_counter = i + return result +} + +func ProcessCommands(s *BrotliDecoderState) int { + return ProcessCommandsInternal(0, s) +} + +func SafeProcessCommands(s *BrotliDecoderState) int { + return ProcessCommandsInternal(1, s) +} + +/* Returns the maximum number of distance symbols which can only represent + distances not exceeding BROTLI_MAX_ALLOWED_DISTANCE. */ + +var BrotliMaxDistanceSymbol_bound = [BROTLI_MAX_NPOSTFIX + 1]uint32{0, 4, 12, 28} +var BrotliMaxDistanceSymbol_diff = [BROTLI_MAX_NPOSTFIX + 1]uint32{73, 126, 228, 424} + +func BrotliMaxDistanceSymbol(ndirect uint32, npostfix uint32) uint32 { + var postfix uint32 = 1 << npostfix + if ndirect < BrotliMaxDistanceSymbol_bound[npostfix] { + return ndirect + BrotliMaxDistanceSymbol_diff[npostfix] + postfix + } else if ndirect > BrotliMaxDistanceSymbol_bound[npostfix]+postfix { + return ndirect + BrotliMaxDistanceSymbol_diff[npostfix] + } else { + return BrotliMaxDistanceSymbol_bound[npostfix] + BrotliMaxDistanceSymbol_diff[npostfix] + postfix + } +} + +func BrotliDecoderDecompress(encoded_size uint, encoded_buffer []byte, decoded_size *uint, decoded_buffer []byte) int { + var s BrotliDecoderState + var result int + var total_out uint = 0 + var available_in uint = encoded_size + var next_in []byte = encoded_buffer + var available_out uint = *decoded_size + var next_out []byte = decoded_buffer + if !BrotliDecoderStateInit(&s) { + return BROTLI_DECODER_RESULT_ERROR + } + + result = BrotliDecoderDecompressStream(&s, &available_in, &next_in, &available_out, &next_out, &total_out) + *decoded_size = total_out + BrotliDecoderStateCleanup(&s) + if result != BROTLI_DECODER_RESULT_SUCCESS { + result = BROTLI_DECODER_RESULT_ERROR + } + + return result +} + +/* Invariant: input stream is never overconsumed: + - invalid input implies that the whole stream is invalid -> any amount of + input could be read and discarded + - when result is "needs more input", then at least one more byte is REQUIRED + to complete decoding; all input data MUST be consumed by decoder, so + client could swap the input buffer + - when result is "needs more output" decoder MUST ensure that it doesn't + hold more than 7 bits in bit reader; this saves client from swapping input + buffer ahead of time + - when result is "success" decoder MUST return all unused data back to input + buffer; this is possible because the invariant is held on enter */ +func BrotliDecoderDecompressStream(s *BrotliDecoderState, available_in *uint, next_in *[]byte, available_out *uint, next_out *[]byte, total_out *uint) int { + var result int = BROTLI_DECODER_SUCCESS + var br *BrotliBitReader = &s.br + + /* Ensure that |total_out| is set, even if no data will ever be pushed out. */ + if total_out != nil { + *total_out = s.partial_pos_out + } + + /* Do not try to process further in a case of unrecoverable error. */ + if int(s.error_code) < 0 { + return BROTLI_DECODER_RESULT_ERROR + } + + if *available_out != 0 && (next_out == nil || *next_out == nil) { + return SaveErrorCode(s, BROTLI_DECODER_ERROR_INVALID_ARGUMENTS) + } + + if *available_out == 0 { + next_out = nil + } + if s.buffer_length == 0 { /* Just connect bit reader to input stream. */ + br.input_len = *available_in + br.input = *next_in + br.byte_pos = 0 + } else { + /* At least one byte of input is required. More than one byte of input may + be required to complete the transaction -> reading more data must be + done in a loop -> do it in a main loop. */ + result = BROTLI_DECODER_NEEDS_MORE_INPUT + + br.input = s.buffer.u8[:] + br.byte_pos = 0 + } + + /* State machine */ + for { + if result != BROTLI_DECODER_SUCCESS { + /* Error, needs more input/output. */ + if result == BROTLI_DECODER_NEEDS_MORE_INPUT { + if s.ringbuffer != nil { /* Pro-actively push output. */ + var intermediate_result int = WriteRingBuffer(s, available_out, next_out, total_out, true) + + /* WriteRingBuffer checks s->meta_block_remaining_len validity. */ + if int(intermediate_result) < 0 { + result = intermediate_result + break + } + } + + if s.buffer_length != 0 { /* Used with internal buffer. */ + if br.byte_pos == br.input_len { + /* Successfully finished read transaction. + Accumulator contains less than 8 bits, because internal buffer + is expanded byte-by-byte until it is enough to complete read. */ + s.buffer_length = 0 + + /* Switch to input stream and restart. */ + result = BROTLI_DECODER_SUCCESS + + br.input_len = *available_in + br.input = *next_in + br.byte_pos = 0 + continue + } else if *available_in != 0 { + /* Not enough data in buffer, but can take one more byte from + input stream. */ + result = BROTLI_DECODER_SUCCESS + + s.buffer.u8[s.buffer_length] = (*next_in)[0] + s.buffer_length++ + br.input_len = uint(s.buffer_length) + *next_in = (*next_in)[1:] + (*available_in)-- + + /* Retry with more data in buffer. */ + continue + } + + /* Can't finish reading and no more input. */ + break + /* Input stream doesn't contain enough input. */ + } else { + /* Copy tail to internal buffer and return. */ + *next_in = br.input[br.byte_pos:] + + *available_in = br.input_len - br.byte_pos + for *available_in != 0 { + s.buffer.u8[s.buffer_length] = (*next_in)[0] + s.buffer_length++ + *next_in = (*next_in)[1:] + (*available_in)-- + } + + break + } + } + + /* Unreachable. */ + + /* Fail or needs more output. */ + if s.buffer_length != 0 { + /* Just consumed the buffered input and produced some output. Otherwise + it would result in "needs more input". Reset internal buffer. */ + s.buffer_length = 0 + } else { + /* Using input stream in last iteration. When decoder switches to input + stream it has less than 8 bits in accumulator, so it is safe to + return unused accumulator bits there. */ + BrotliBitReaderUnload(br) + + *available_in = br.input_len - br.byte_pos + *next_in = br.input[br.byte_pos:] + } + + break + } + + switch s.state { + /* Prepare to the first read. */ + case BROTLI_STATE_UNINITED: + if !BrotliWarmupBitReader(br) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + break + } + + /* Decode window size. */ + result = DecodeWindowBits(s, br) /* Reads 1..8 bits. */ + if result != BROTLI_DECODER_SUCCESS { + break + } + + if s.large_window { + s.state = BROTLI_STATE_LARGE_WINDOW_BITS + break + } + + s.state = BROTLI_STATE_INITIALIZE + + case BROTLI_STATE_LARGE_WINDOW_BITS: + if !BrotliSafeReadBits(br, 6, &s.window_bits) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + break + } + + if s.window_bits < BROTLI_LARGE_MIN_WBITS || s.window_bits > BROTLI_LARGE_MAX_WBITS { + result = BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS + break + } + + s.state = BROTLI_STATE_INITIALIZE + fallthrough + + /* Maximum distance, see section 9.1. of the spec. */ + /* Fall through. */ + case BROTLI_STATE_INITIALIZE: + s.max_backward_distance = (1 << s.window_bits) - BROTLI_WINDOW_GAP + + /* Allocate memory for both block_type_trees and block_len_trees. */ + s.block_type_trees = make([]HuffmanCode, (3 * (BROTLI_HUFFMAN_MAX_SIZE_258 + BROTLI_HUFFMAN_MAX_SIZE_26))) + + if s.block_type_trees == nil { + result = BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES + break + } + + s.block_len_trees = s.block_type_trees[3*BROTLI_HUFFMAN_MAX_SIZE_258:] + + s.state = BROTLI_STATE_METABLOCK_BEGIN + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_BEGIN: + BrotliDecoderStateMetablockBegin(s) + + s.state = BROTLI_STATE_METABLOCK_HEADER + fallthrough + + /* Fall through. */ + case BROTLI_STATE_METABLOCK_HEADER: + result = DecodeMetaBlockLength(s, br) + /* Reads 2 - 31 bits. */ + if result != BROTLI_DECODER_SUCCESS { + break + } + + if s.is_metadata != 0 || s.is_uncompressed != 0 { + if !BrotliJumpToByteBoundary(br) { + result = BROTLI_DECODER_ERROR_FORMAT_PADDING_1 + break + } + } + + if s.is_metadata != 0 { + s.state = BROTLI_STATE_METADATA + break + } + + if s.meta_block_remaining_len == 0 { + s.state = BROTLI_STATE_METABLOCK_DONE + break + } + + BrotliCalculateRingBufferSize(s) + if s.is_uncompressed != 0 { + s.state = BROTLI_STATE_UNCOMPRESSED + break + } + + s.loop_counter = 0 + s.state = BROTLI_STATE_HUFFMAN_CODE_0 + case BROTLI_STATE_UNCOMPRESSED: + { + result = CopyUncompressedBlockToOutput(available_out, next_out, total_out, s) + if result != BROTLI_DECODER_SUCCESS { + break + } + + s.state = BROTLI_STATE_METABLOCK_DONE + break + } + fallthrough + + case BROTLI_STATE_METADATA: + for ; s.meta_block_remaining_len > 0; s.meta_block_remaining_len-- { + var bits uint32 + + /* Read one byte and ignore it. */ + if !BrotliSafeReadBits(br, 8, &bits) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + break + } + } + + if result == BROTLI_DECODER_SUCCESS { + s.state = BROTLI_STATE_METABLOCK_DONE + } + + case BROTLI_STATE_HUFFMAN_CODE_0: + if s.loop_counter >= 3 { + s.state = BROTLI_STATE_METABLOCK_HEADER_2 + break + } + + /* Reads 1..11 bits. */ + result = DecodeVarLenUint8(s, br, &s.num_block_types[s.loop_counter]) + + if result != BROTLI_DECODER_SUCCESS { + break + } + + s.num_block_types[s.loop_counter]++ + if s.num_block_types[s.loop_counter] < 2 { + s.loop_counter++ + break + } + + s.state = BROTLI_STATE_HUFFMAN_CODE_1 + fallthrough + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_CODE_1: + { + var alphabet_size uint32 = s.num_block_types[s.loop_counter] + 2 + var tree_offset int = s.loop_counter * BROTLI_HUFFMAN_MAX_SIZE_258 + result = ReadHuffmanCode(alphabet_size, alphabet_size, s.block_type_trees[tree_offset:], nil, s) + if result != BROTLI_DECODER_SUCCESS { + break + } + s.state = BROTLI_STATE_HUFFMAN_CODE_2 + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_CODE_2: + { + var alphabet_size uint32 = BROTLI_NUM_BLOCK_LEN_SYMBOLS + var tree_offset int = s.loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26 + result = ReadHuffmanCode(alphabet_size, alphabet_size, s.block_len_trees[tree_offset:], nil, s) + if result != BROTLI_DECODER_SUCCESS { + break + } + s.state = BROTLI_STATE_HUFFMAN_CODE_3 + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_HUFFMAN_CODE_3: + { + var tree_offset int = s.loop_counter * BROTLI_HUFFMAN_MAX_SIZE_26 + if !SafeReadBlockLength(s, &s.block_length[s.loop_counter], s.block_len_trees[tree_offset:], br) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + break + } + + s.loop_counter++ + s.state = BROTLI_STATE_HUFFMAN_CODE_0 + break + } + fallthrough + case BROTLI_STATE_METABLOCK_HEADER_2: + { + var bits uint32 + if !BrotliSafeReadBits(br, 6, &bits) { + result = BROTLI_DECODER_NEEDS_MORE_INPUT + break + } + + s.distance_postfix_bits = bits & BitMask(2) + bits >>= 2 + s.num_direct_distance_codes = BROTLI_NUM_DISTANCE_SHORT_CODES + (bits << s.distance_postfix_bits) + s.distance_postfix_mask = int(BitMask(s.distance_postfix_bits)) + s.context_modes = make([]byte, uint(s.num_block_types[0])) + if s.context_modes == nil { + result = BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES + break + } + + s.loop_counter = 0 + s.state = BROTLI_STATE_CONTEXT_MODES + } + fallthrough + + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MODES: + result = ReadContextModes(s) + + if result != BROTLI_DECODER_SUCCESS { + break + } + + s.state = BROTLI_STATE_CONTEXT_MAP_1 + fallthrough + + /* Fall through. */ + case BROTLI_STATE_CONTEXT_MAP_1: + result = DecodeContextMap(s.num_block_types[0]<= 3 { + PrepareLiteralDecoding(s) + s.dist_context_map_slice = s.dist_context_map + s.htree_command = []HuffmanCode(s.insert_copy_hgroup.htrees[0]) + if !BrotliEnsureRingBuffer(s) { + result = BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 + break + } + + s.state = BROTLI_STATE_COMMAND_BEGIN + } + + break + } + fallthrough + + case BROTLI_STATE_COMMAND_BEGIN, + /* Fall through. */ + BROTLI_STATE_COMMAND_INNER, + + /* Fall through. */ + BROTLI_STATE_COMMAND_POST_DECODE_LITERALS, + + /* Fall through. */ + BROTLI_STATE_COMMAND_POST_WRAP_COPY: + result = ProcessCommands(s) + + if result == BROTLI_DECODER_NEEDS_MORE_INPUT { + result = SafeProcessCommands(s) + } + + case BROTLI_STATE_COMMAND_INNER_WRITE, + /* Fall through. */ + BROTLI_STATE_COMMAND_POST_WRITE_1, + + /* Fall through. */ + BROTLI_STATE_COMMAND_POST_WRITE_2: + result = WriteRingBuffer(s, available_out, next_out, total_out, false) + + if result != BROTLI_DECODER_SUCCESS { + break + } + + WrapRingBuffer(s) + if s.ringbuffer_size == 1<= uint64(block_size) { + return 0 + } + return block_size - uint(delta) +} + +func BrotliEncoderSetParameter(state *BrotliEncoderState, p int, value uint32) bool { + /* Changing parameters on the fly is not implemented yet. */ + if state.is_initialized_ { + return false + } + + /* TODO: Validate/clamp parameters here. */ + switch p { + case BROTLI_PARAM_MODE: + state.params.mode = int(value) + return true + + case BROTLI_PARAM_QUALITY: + state.params.quality = int(value) + return true + + case BROTLI_PARAM_LGWIN: + state.params.lgwin = uint(int(value)) + return true + + case BROTLI_PARAM_LGBLOCK: + state.params.lgblock = int(value) + return true + + case BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: + if (value != 0) && (value != 1) { + return false + } + state.params.disable_literal_context_modeling = (!(value == 0)) + return true + + case BROTLI_PARAM_SIZE_HINT: + state.params.size_hint = uint(value) + return true + + case BROTLI_PARAM_LARGE_WINDOW: + state.params.large_window = (!(value == 0)) + return true + + case BROTLI_PARAM_NPOSTFIX: + state.params.dist.distance_postfix_bits = value + return true + + case BROTLI_PARAM_NDIRECT: + state.params.dist.num_direct_distance_codes = value + return true + + default: + return false + } +} + +/* Wraps 64-bit input position to 32-bit ring-buffer position preserving + "not-a-first-lap" feature. */ +func WrapPosition(position uint64) uint32 { + var result uint32 = uint32(position) + var gb uint64 = position >> 30 + if gb > 2 { + /* Wrap every 2GiB; The first 3GB are continuous. */ + result = result&((1<<30)-1) | (uint32((gb-1)&1)+1)<<30 + } + + return result +} + +func GetBrotliStorage(s *BrotliEncoderState, size uint) []byte { + if s.storage_size_ < size { + s.storage_ = nil + s.storage_ = make([]byte, size) + s.storage_size_ = size + } + + return s.storage_ +} + +func HashTableSize(max_table_size uint, input_size uint) uint { + var htsize uint = 256 + for htsize < max_table_size && htsize < input_size { + htsize <<= 1 + } + + return htsize +} + +func GetHashTable(s *BrotliEncoderState, quality int, input_size uint, table_size *uint) []int { + var max_table_size uint = MaxHashTableSize(quality) + var htsize uint = HashTableSize(max_table_size, input_size) + /* Use smaller hash table when input.size() is smaller, since we + fill the table, incurring O(hash table size) overhead for + compression, and if the input is short, we won't need that + many hash table entries anyway. */ + + var table []int + assert(max_table_size >= 256) + if quality == FAST_ONE_PASS_COMPRESSION_QUALITY { + /* Only odd shifts are supported by fast-one-pass. */ + if htsize&0xAAAAA == 0 { + htsize <<= 1 + } + } + + if htsize <= uint(len(s.small_table_)) { + table = s.small_table_[:] + } else { + if htsize > s.large_table_size_ { + s.large_table_size_ = htsize + s.large_table_ = nil + s.large_table_ = make([]int, htsize) + } + + table = s.large_table_ + } + + *table_size = htsize + for i := 0; i < int(htsize); i++ { + table[i] = 0 + } + return table +} + +func EncodeWindowBits(lgwin int, large_window bool, last_bytes *uint16, last_bytes_bits *byte) { + if large_window { + *last_bytes = uint16((lgwin&0x3F)<<8 | 0x11) + *last_bytes_bits = 14 + } else { + if lgwin == 16 { + *last_bytes = 0 + *last_bytes_bits = 1 + } else if lgwin == 17 { + *last_bytes = 1 + *last_bytes_bits = 7 + } else if lgwin > 17 { + *last_bytes = uint16((lgwin-17)<<1 | 0x01) + *last_bytes_bits = 4 + } else { + *last_bytes = uint16((lgwin-8)<<4 | 0x01) + *last_bytes_bits = 7 + } + } +} + +/* Initializes the command and distance prefix codes for the first block. */ + +var InitCommandPrefixCodes_kDefaultCommandDepths = [128]byte{ + 0, + 4, + 4, + 5, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 0, + 0, + 0, + 4, + 4, + 4, + 4, + 4, + 5, + 5, + 6, + 6, + 6, + 6, + 7, + 7, + 7, + 7, + 10, + 10, + 10, + 10, + 10, + 10, + 0, + 4, + 4, + 5, + 5, + 5, + 6, + 6, + 7, + 8, + 8, + 9, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 7, + 7, + 7, + 8, + 10, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, +} +var InitCommandPrefixCodes_kDefaultCommandBits = [128]uint16{ + 0, + 0, + 8, + 9, + 3, + 35, + 7, + 71, + 39, + 103, + 23, + 47, + 175, + 111, + 239, + 31, + 0, + 0, + 0, + 4, + 12, + 2, + 10, + 6, + 13, + 29, + 11, + 43, + 27, + 59, + 87, + 55, + 15, + 79, + 319, + 831, + 191, + 703, + 447, + 959, + 0, + 14, + 1, + 25, + 5, + 21, + 19, + 51, + 119, + 159, + 95, + 223, + 479, + 991, + 63, + 575, + 127, + 639, + 383, + 895, + 255, + 767, + 511, + 1023, + 14, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27, + 59, + 7, + 39, + 23, + 55, + 30, + 1, + 17, + 9, + 25, + 5, + 0, + 8, + 4, + 12, + 2, + 10, + 6, + 21, + 13, + 29, + 3, + 19, + 11, + 15, + 47, + 31, + 95, + 63, + 127, + 255, + 767, + 2815, + 1791, + 3839, + 511, + 2559, + 1535, + 3583, + 1023, + 3071, + 2047, + 4095, +} +var InitCommandPrefixCodes_kDefaultCommandCode = []byte{ + 0xff, + 0x77, + 0xd5, + 0xbf, + 0xe7, + 0xde, + 0xea, + 0x9e, + 0x51, + 0x5d, + 0xde, + 0xc6, + 0x70, + 0x57, + 0xbc, + 0x58, + 0x58, + 0x58, + 0xd8, + 0xd8, + 0x58, + 0xd5, + 0xcb, + 0x8c, + 0xea, + 0xe0, + 0xc3, + 0x87, + 0x1f, + 0x83, + 0xc1, + 0x60, + 0x1c, + 0x67, + 0xb2, + 0xaa, + 0x06, + 0x83, + 0xc1, + 0x60, + 0x30, + 0x18, + 0xcc, + 0xa1, + 0xce, + 0x88, + 0x54, + 0x94, + 0x46, + 0xe1, + 0xb0, + 0xd0, + 0x4e, + 0xb2, + 0xf7, + 0x04, + 0x00, +} +var InitCommandPrefixCodes_kDefaultCommandCodeNumBits uint = 448 + +func InitCommandPrefixCodes(cmd_depths []byte, cmd_bits []uint16, cmd_code []byte, cmd_code_numbits *uint) { + copy(cmd_depths, InitCommandPrefixCodes_kDefaultCommandDepths[:]) + copy(cmd_bits, InitCommandPrefixCodes_kDefaultCommandBits[:]) + + /* Initialize the pre-compressed form of the command and distance prefix + codes. */ + copy(cmd_code, InitCommandPrefixCodes_kDefaultCommandCode) + + *cmd_code_numbits = InitCommandPrefixCodes_kDefaultCommandCodeNumBits +} + +/* Decide about the context map based on the ability of the prediction + ability of the previous byte UTF8-prefix on the next byte. The + prediction ability is calculated as Shannon entropy. Here we need + Shannon entropy instead of 'BitsEntropy' since the prefix will be + encoded with the remaining 6 bits of the following byte, and + BitsEntropy will assume that symbol to be stored alone using Huffman + coding. */ + +var ChooseContextMap_kStaticContextMapContinuation = [64]uint32{ + 1, + 1, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +} +var ChooseContextMap_kStaticContextMapSimpleUTF8 = [64]uint32{ + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +} + +func ChooseContextMap(quality int, bigram_histo []uint32, num_literal_contexts *uint, literal_context_map *[]uint32) { + var monogram_histo = [3]uint32{0} + var two_prefix_histo = [6]uint32{0} + var total uint + var i uint + var dummy uint + var entropy [4]float64 + for i = 0; i < 9; i++ { + monogram_histo[i%3] += bigram_histo[i] + two_prefix_histo[i%6] += bigram_histo[i] + } + + entropy[1] = ShannonEntropy(monogram_histo[:], 3, &dummy) + entropy[2] = (ShannonEntropy(two_prefix_histo[:], 3, &dummy) + ShannonEntropy(two_prefix_histo[3:], 3, &dummy)) + entropy[3] = 0 + for i = 0; i < 3; i++ { + entropy[3] += ShannonEntropy(bigram_histo[3*i:], 3, &dummy) + } + + total = uint(monogram_histo[0] + monogram_histo[1] + monogram_histo[2]) + assert(total != 0) + entropy[0] = 1.0 / float64(total) + entropy[1] *= entropy[0] + entropy[2] *= entropy[0] + entropy[3] *= entropy[0] + + if quality < MIN_QUALITY_FOR_HQ_CONTEXT_MODELING { + /* 3 context models is a bit slower, don't use it at lower qualities. */ + entropy[3] = entropy[1] * 10 + } + + /* If expected savings by symbol are less than 0.2 bits, skip the + context modeling -- in exchange for faster decoding speed. */ + if entropy[1]-entropy[2] < 0.2 && entropy[1]-entropy[3] < 0.2 { + *num_literal_contexts = 1 + } else if entropy[2]-entropy[3] < 0.02 { + *num_literal_contexts = 2 + *literal_context_map = ChooseContextMap_kStaticContextMapSimpleUTF8[:] + } else { + *num_literal_contexts = 3 + *literal_context_map = ChooseContextMap_kStaticContextMapContinuation[:] + } +} + +/* Decide if we want to use a more complex static context map containing 13 + context values, based on the entropy reduction of histograms over the + first 5 bits of literals. */ + +var ShouldUseComplexStaticContextMap_kStaticContextMapComplexUTF8 = [64]uint32{ + 11, + 11, + 12, + 12, + 0, + 0, + 0, + 0, + 1, + 1, + 9, + 9, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 8, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 8, + 4, + 4, + 4, + 8, + 7, + 4, + 4, + 8, + 0, + 0, + 0, + 3, + 3, + 3, + 3, + 5, + 5, + 10, + 5, + 5, + 5, + 10, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, +} + +func ShouldUseComplexStaticContextMap(input []byte, start_pos uint, length uint, mask uint, quality int, size_hint uint, num_literal_contexts *uint, literal_context_map *[]uint32) bool { + /* Try the more complex static context map only for long data. */ + if size_hint < 1<<20 { + return false + } else { + var end_pos uint = start_pos + length + var combined_histo = [32]uint32{0} + var context_histo = [13][32]uint32{[32]uint32{0}} + var total uint32 = 0 + var entropy [3]float64 + var dummy uint + var i uint + var utf8_lut ContextLut = BROTLI_CONTEXT_LUT(CONTEXT_UTF8) + /* To make entropy calculations faster and to fit on the stack, we collect + histograms over the 5 most significant bits of literals. One histogram + without context and 13 additional histograms for each context value. */ + for ; start_pos+64 <= end_pos; start_pos += 4096 { + var stride_end_pos uint = start_pos + 64 + var prev2 byte = input[start_pos&mask] + var prev1 byte = input[(start_pos+1)&mask] + var pos uint + + /* To make the analysis of the data faster we only examine 64 byte long + strides at every 4kB intervals. */ + for pos = start_pos + 2; pos < stride_end_pos; pos++ { + var literal byte = input[pos&mask] + var context byte = byte(ShouldUseComplexStaticContextMap_kStaticContextMapComplexUTF8[BROTLI_CONTEXT(prev1, prev2, utf8_lut)]) + total++ + combined_histo[literal>>3]++ + context_histo[context][literal>>3]++ + prev2 = prev1 + prev1 = literal + } + } + + entropy[1] = ShannonEntropy(combined_histo[:], 32, &dummy) + entropy[2] = 0 + for i = 0; i < 13; i++ { + entropy[2] += ShannonEntropy(context_histo[i][0:], 32, &dummy) + } + + entropy[0] = 1.0 / float64(total) + entropy[1] *= entropy[0] + entropy[2] *= entropy[0] + + /* The triggering heuristics below were tuned by compressing the individual + files of the silesia corpus. If we skip this kind of context modeling + for not very well compressible input (i.e. entropy using context modeling + is 60% of maximal entropy) or if expected savings by symbol are less + than 0.2 bits, then in every case when it triggers, the final compression + ratio is improved. Note however that this heuristics might be too strict + for some cases and could be tuned further. */ + if entropy[2] > 3.0 || entropy[1]-entropy[2] < 0.2 { + return false + } else { + *num_literal_contexts = 13 + *literal_context_map = ShouldUseComplexStaticContextMap_kStaticContextMapComplexUTF8[:] + return true + } + } +} + +func DecideOverLiteralContextModeling(input []byte, start_pos uint, length uint, mask uint, quality int, size_hint uint, num_literal_contexts *uint, literal_context_map *[]uint32) { + if quality < MIN_QUALITY_FOR_CONTEXT_MODELING || length < 64 { + return + } else if ShouldUseComplexStaticContextMap(input, start_pos, length, mask, quality, size_hint, num_literal_contexts, literal_context_map) { + } else /* Context map was already set, nothing else to do. */ + { + var end_pos uint = start_pos + length + /* Gather bi-gram data of the UTF8 byte prefixes. To make the analysis of + UTF8 data faster we only examine 64 byte long strides at every 4kB + intervals. */ + + var bigram_prefix_histo = [9]uint32{0} + for ; start_pos+64 <= end_pos; start_pos += 4096 { + var lut = [4]int{0, 0, 1, 2} + var stride_end_pos uint = start_pos + 64 + var prev int = lut[input[start_pos&mask]>>6] * 3 + var pos uint + for pos = start_pos + 1; pos < stride_end_pos; pos++ { + var literal byte = input[pos&mask] + bigram_prefix_histo[prev+lut[literal>>6]]++ + prev = lut[literal>>6] * 3 + } + } + + ChooseContextMap(quality, bigram_prefix_histo[0:], num_literal_contexts, literal_context_map) + } +} + +func ShouldCompress_encode(data []byte, mask uint, last_flush_pos uint64, bytes uint, num_literals uint, num_commands uint) bool { + /* TODO: find more precise minimal block overhead. */ + if bytes <= 2 { + return false + } + if num_commands < (bytes>>8)+2 { + if float64(num_literals) > 0.99*float64(bytes) { + var literal_histo = [256]uint32{0} + var kSampleRate uint32 = 13 + var kMinEntropy float64 = 7.92 + var bit_cost_threshold float64 = float64(bytes) * kMinEntropy / float64(kSampleRate) + var t uint = uint((uint32(bytes) + kSampleRate - 1) / kSampleRate) + var pos uint32 = uint32(last_flush_pos) + var i uint + for i = 0; i < t; i++ { + literal_histo[data[pos&uint32(mask)]]++ + pos += kSampleRate + } + + if BitsEntropy(literal_histo[:], 256) > bit_cost_threshold { + return false + } + } + } + + return true +} + +/* Chooses the literal context mode for a metablock */ +func ChooseContextMode(params *BrotliEncoderParams, data []byte, pos uint, mask uint, length uint) int { + /* We only do the computation for the option of something else than + CONTEXT_UTF8 for the highest qualities */ + if params.quality >= MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING && !BrotliIsMostlyUTF8(data, pos, mask, length, kMinUTF8Ratio) { + return CONTEXT_SIGNED + } + + return CONTEXT_UTF8 +} + +func WriteMetaBlockInternal(data []byte, mask uint, last_flush_pos uint64, bytes uint, is_last bool, literal_context_mode int, params *BrotliEncoderParams, prev_byte byte, prev_byte2 byte, num_literals uint, num_commands uint, commands []Command, saved_dist_cache []int, dist_cache []int, storage_ix *uint, storage []byte) { + var wrapped_last_flush_pos uint32 = WrapPosition(last_flush_pos) + var last_bytes uint16 + var last_bytes_bits byte + var literal_context_lut ContextLut = BROTLI_CONTEXT_LUT(literal_context_mode) + var block_params BrotliEncoderParams = *params + + if bytes == 0 { + /* Write the ISLAST and ISEMPTY bits. */ + BrotliWriteBits(2, 3, storage_ix, storage) + + *storage_ix = (*storage_ix + 7) &^ 7 + return + } + + if !ShouldCompress_encode(data, mask, last_flush_pos, bytes, num_literals, num_commands) { + /* Restore the distance cache, as its last update by + CreateBackwardReferences is now unused. */ + copy(dist_cache, saved_dist_cache[:4]) + + BrotliStoreUncompressedMetaBlock(is_last, data, uint(wrapped_last_flush_pos), mask, bytes, storage_ix, storage) + return + } + + assert(*storage_ix <= 14) + last_bytes = uint16(storage[1]<<8 | storage[0]) + last_bytes_bits = byte(*storage_ix) + if params.quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES { + BrotliStoreMetaBlockFast(data, uint(wrapped_last_flush_pos), bytes, mask, is_last, params, commands, num_commands, storage_ix, storage) + } else if params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT { + BrotliStoreMetaBlockTrivial(data, uint(wrapped_last_flush_pos), bytes, mask, is_last, params, commands, num_commands, storage_ix, storage) + } else { + var mb MetaBlockSplit + InitMetaBlockSplit(&mb) + if params.quality < MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING { + var num_literal_contexts uint = 1 + var literal_context_map []uint32 = nil + if !params.disable_literal_context_modeling { + DecideOverLiteralContextModeling(data, uint(wrapped_last_flush_pos), bytes, mask, params.quality, params.size_hint, &num_literal_contexts, &literal_context_map) + } + + BrotliBuildMetaBlockGreedy(data, uint(wrapped_last_flush_pos), mask, prev_byte, prev_byte2, literal_context_lut, num_literal_contexts, literal_context_map, commands, num_commands, &mb) + } else { + BrotliBuildMetaBlock(data, uint(wrapped_last_flush_pos), mask, &block_params, prev_byte, prev_byte2, commands, num_commands, literal_context_mode, &mb) + } + + if params.quality >= MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS { + /* The number of distance symbols effectively used for distance + histograms. It might be less than distance alphabet size + for "Large Window Brotli" (32-bit). */ + var num_effective_dist_codes uint32 = block_params.dist.alphabet_size + if num_effective_dist_codes > BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS { + num_effective_dist_codes = BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS + } + + BrotliOptimizeHistograms(num_effective_dist_codes, &mb) + } + + BrotliStoreMetaBlock(data, uint(wrapped_last_flush_pos), bytes, mask, prev_byte, prev_byte2, is_last, &block_params, literal_context_mode, commands, num_commands, &mb, storage_ix, storage) + DestroyMetaBlockSplit(&mb) + } + + if bytes+4 < *storage_ix>>3 { + /* Restore the distance cache and last byte. */ + copy(dist_cache, saved_dist_cache[:4]) + + storage[0] = byte(last_bytes) + storage[1] = byte(last_bytes >> 8) + *storage_ix = uint(last_bytes_bits) + BrotliStoreUncompressedMetaBlock(is_last, data, uint(wrapped_last_flush_pos), mask, bytes, storage_ix, storage) + } +} + +func ChooseDistanceParams(params *BrotliEncoderParams) { + var distance_postfix_bits uint32 = 0 + var num_direct_distance_codes uint32 = 0 + + if params.quality >= MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS { + var ndirect_msb uint32 + if params.mode == BROTLI_MODE_FONT { + distance_postfix_bits = 1 + num_direct_distance_codes = 12 + } else { + distance_postfix_bits = params.dist.distance_postfix_bits + num_direct_distance_codes = params.dist.num_direct_distance_codes + } + + ndirect_msb = (num_direct_distance_codes >> distance_postfix_bits) & 0x0F + if distance_postfix_bits > BROTLI_MAX_NPOSTFIX || num_direct_distance_codes > BROTLI_MAX_NDIRECT || ndirect_msb<>25)), (last_command.dist_prefix_&0x3FF == 0), &last_command.cmd_prefix_) + } +} + +/* + Processes the accumulated input data and sets |*out_size| to the length of + the new output meta-block, or to zero if no new output meta-block has been + created (in this case the processed input data is buffered internally). + If |*out_size| is positive, |*output| points to the start of the output + data. If |is_last| or |force_flush| is true, an output meta-block is + always created. However, until |is_last| is true encoder may retain up + to 7 bits of the last byte of output. To force encoder to dump the remaining + bits use WriteMetadata() to append an empty meta-data block. + Returns false if the size of the input data is larger than + input_block_size(). +*/ +func EncodeData(s *BrotliEncoderState, is_last bool, force_flush bool, out_size *uint, output *[]byte) bool { + var delta uint64 = UnprocessedInputSize(s) + var bytes uint32 = uint32(delta) + var wrapped_last_processed_pos uint32 = WrapPosition(s.last_processed_pos_) + var data []byte + var mask uint32 + var literal_context_mode int + + data = s.ringbuffer_.buffer_ + mask = s.ringbuffer_.mask_ + + /* Adding more blocks after "last" block is forbidden. */ + if s.is_last_block_emitted_ { + return false + } + if is_last { + s.is_last_block_emitted_ = true + } + + if delta > uint64(InputBlockSize(s)) { + return false + } + + if s.params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY && s.command_buf_ == nil { + s.command_buf_ = make([]uint32, kCompressFragmentTwoPassBlockSize) + s.literal_buf_ = make([]byte, kCompressFragmentTwoPassBlockSize) + } + + if s.params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY || s.params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY { + var storage []byte + var storage_ix uint = uint(s.last_bytes_bits_) + var table_size uint + var table []int + + if delta == 0 && !is_last { + /* We have no new input data and we don't have to finish the stream, so + nothing to do. */ + *out_size = 0 + + return true + } + + storage = GetBrotliStorage(s, uint(2*bytes+503)) + storage[0] = byte(s.last_bytes_) + storage[1] = byte(s.last_bytes_ >> 8) + table = GetHashTable(s, s.params.quality, uint(bytes), &table_size) + if s.params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY { + BrotliCompressFragmentFast(data[wrapped_last_processed_pos&mask:], uint(bytes), is_last, table, table_size, s.cmd_depths_[:], s.cmd_bits_[:], &s.cmd_code_numbits_, s.cmd_code_[:], &storage_ix, storage) + } else { + BrotliCompressFragmentTwoPass(data[wrapped_last_processed_pos&mask:], uint(bytes), is_last, s.command_buf_, s.literal_buf_, table, table_size, &storage_ix, storage) + } + + s.last_bytes_ = uint16(storage[storage_ix>>3]) + s.last_bytes_bits_ = byte(storage_ix & 7) + UpdateLastProcessedPos(s) + *output = storage[0:] + *out_size = storage_ix >> 3 + return true + } + { + /* Theoretical max number of commands is 1 per 2 bytes. */ + var newsize uint = uint(uint32(s.num_commands_) + bytes/2 + 1) + if newsize > s.cmd_alloc_size_ { + var new_commands []Command + + /* Reserve a bit more memory to allow merging with a next block + without reallocation: that would impact speed. */ + newsize += uint((bytes / 4) + 16) + + s.cmd_alloc_size_ = newsize + new_commands = make([]Command, newsize) + if s.commands_ != nil { + copy(new_commands, s.commands_[:s.num_commands_]) + s.commands_ = nil + } + + s.commands_ = new_commands + } + } + + InitOrStitchToPreviousBlock(&s.hasher_, data, uint(mask), &s.params, uint(wrapped_last_processed_pos), uint(bytes), is_last) + + literal_context_mode = ChooseContextMode(&s.params, data, uint(WrapPosition(s.last_flush_pos_)), uint(mask), uint(s.input_pos_-s.last_flush_pos_)) + + if s.num_commands_ != 0 && s.last_insert_len_ == 0 { + ExtendLastCommand(s, &bytes, &wrapped_last_processed_pos) + } + + if s.params.quality == ZOPFLIFICATION_QUALITY { + assert(s.params.hasher.type_ == 10) + BrotliCreateZopfliBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_, s.dist_cache_[:], &s.last_insert_len_, s.commands_[s.num_commands_:], &s.num_commands_, &s.num_literals_) + } else if s.params.quality == HQ_ZOPFLIFICATION_QUALITY { + assert(s.params.hasher.type_ == 10) + BrotliCreateHqZopfliBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_, s.dist_cache_[:], &s.last_insert_len_, s.commands_[s.num_commands_:], &s.num_commands_, &s.num_literals_) + } else { + BrotliCreateBackwardReferences(uint(bytes), uint(wrapped_last_processed_pos), data, uint(mask), &s.params, s.hasher_, s.dist_cache_[:], &s.last_insert_len_, s.commands_[s.num_commands_:], &s.num_commands_, &s.num_literals_) + } + { + var max_length uint = MaxMetablockSize(&s.params) + var max_literals uint = max_length / 8 + var max_commands uint = max_length / 8 + var processed_bytes uint = uint(s.input_pos_ - s.last_flush_pos_) + var next_input_fits_metablock bool = (processed_bytes+InputBlockSize(s) <= max_length) + var should_flush bool = (s.params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT && s.num_literals_+s.num_commands_ >= MAX_NUM_DELAYED_SYMBOLS) + /* If maximal possible additional block doesn't fit metablock, flush now. */ + /* TODO: Postpone decision until next block arrives? */ + + /* If block splitting is not used, then flush as soon as there is some + amount of commands / literals produced. */ + if !is_last && !force_flush && !should_flush && next_input_fits_metablock && s.num_literals_ < max_literals && s.num_commands_ < max_commands { + /* Merge with next input block. Everything will happen later. */ + if UpdateLastProcessedPos(s) { + HasherReset(s.hasher_) + } + + *out_size = 0 + return true + } + } + + /* Create the last insert-only command. */ + if s.last_insert_len_ > 0 { + InitInsertCommand(&s.commands_[s.num_commands_], s.last_insert_len_) + s.num_commands_++ + s.num_literals_ += s.last_insert_len_ + s.last_insert_len_ = 0 + } + + if !is_last && s.input_pos_ == s.last_flush_pos_ { + /* We have no new input data and we don't have to finish the stream, so + nothing to do. */ + *out_size = 0 + + return true + } + + assert(s.input_pos_ >= s.last_flush_pos_) + assert(s.input_pos_ > s.last_flush_pos_ || is_last) + assert(s.input_pos_-s.last_flush_pos_ <= 1<<24) + { + var metablock_size uint32 = uint32(s.input_pos_ - s.last_flush_pos_) + var storage []byte = GetBrotliStorage(s, uint(2*metablock_size+503)) + var storage_ix uint = uint(s.last_bytes_bits_) + storage[0] = byte(s.last_bytes_) + storage[1] = byte(s.last_bytes_ >> 8) + WriteMetaBlockInternal(data, uint(mask), s.last_flush_pos_, uint(metablock_size), is_last, literal_context_mode, &s.params, s.prev_byte_, s.prev_byte2_, s.num_literals_, s.num_commands_, s.commands_, s.saved_dist_cache_[:], s.dist_cache_[:], &storage_ix, storage) + s.last_bytes_ = uint16(storage[storage_ix>>3]) + s.last_bytes_bits_ = byte(storage_ix & 7) + s.last_flush_pos_ = s.input_pos_ + if UpdateLastProcessedPos(s) { + HasherReset(s.hasher_) + } + + if s.last_flush_pos_ > 0 { + s.prev_byte_ = data[(uint32(s.last_flush_pos_)-1)&mask] + } + + if s.last_flush_pos_ > 1 { + s.prev_byte2_ = data[uint32(s.last_flush_pos_-2)&mask] + } + + s.num_commands_ = 0 + s.num_literals_ = 0 + + /* Save the state of the distance cache in case we need to restore it for + emitting an uncompressed block. */ + copy(s.saved_dist_cache_[:], s.dist_cache_[:]) + + *output = storage[0:] + *out_size = storage_ix >> 3 + return true + } +} + +/* Dumps remaining output bits and metadata header to |header|. + Returns number of produced bytes. + REQUIRED: |header| should be 8-byte aligned and at least 16 bytes long. + REQUIRED: |block_size| <= (1 << 24). */ +func WriteMetadataHeader(s *BrotliEncoderState, block_size uint, header []byte) uint { + var storage_ix uint + storage_ix = uint(s.last_bytes_bits_) + header[0] = byte(s.last_bytes_) + header[1] = byte(s.last_bytes_ >> 8) + s.last_bytes_ = 0 + s.last_bytes_bits_ = 0 + + BrotliWriteBits(1, 0, &storage_ix, header) + BrotliWriteBits(2, 3, &storage_ix, header) + BrotliWriteBits(1, 0, &storage_ix, header) + if block_size == 0 { + BrotliWriteBits(2, 0, &storage_ix, header) + } else { + var nbits uint32 + if block_size == 1 { + nbits = 0 + } else { + nbits = Log2FloorNonZero(uint(uint32(block_size)-1)) + 1 + } + var nbytes uint32 = (nbits + 7) / 8 + BrotliWriteBits(2, uint64(nbytes), &storage_ix, header) + BrotliWriteBits(uint(8*nbytes), uint64(block_size)-1, &storage_ix, header) + } + + return (storage_ix + 7) >> 3 +} + +func BrotliCompressBufferQuality10(lgwin int, input_size uint, input_buffer []byte, encoded_size *uint, encoded_buffer []byte) bool { + var mask uint = BROTLI_SIZE_MAX >> 1 + var dist_cache = [4]int{4, 11, 15, 16} + var saved_dist_cache = [4]int{4, 11, 15, 16} + var ok bool = true + var max_out_size uint = *encoded_size + var total_out_size uint = 0 + var last_bytes uint16 + var last_bytes_bits byte + var hasher HasherHandle = nil + var hasher_eff_size uint = brotli_min_size_t(input_size, BROTLI_MAX_BACKWARD_LIMIT(uint(lgwin))+BROTLI_WINDOW_GAP) + var params BrotliEncoderParams + var lgmetablock int = brotli_min_int(24, lgwin+1) + var max_block_size uint + var max_metablock_size uint = uint(1) << uint(lgmetablock) + var max_literals_per_metablock uint = max_metablock_size / 8 + var max_commands_per_metablock uint = max_metablock_size / 8 + var metablock_start uint = 0 + var prev_byte byte = 0 + var prev_byte2 byte = 0 + + BrotliEncoderInitParams(¶ms) + params.quality = 10 + params.lgwin = uint(lgwin) + if lgwin > BROTLI_MAX_WINDOW_BITS { + params.large_window = true + } + + SanitizeParams(¶ms) + params.lgblock = ComputeLgBlock(¶ms) + ChooseDistanceParams(¶ms) + max_block_size = uint(1) << uint(params.lgblock) + + assert(input_size <= mask+1) + EncodeWindowBits(lgwin, params.large_window, &last_bytes, &last_bytes_bits) + InitOrStitchToPreviousBlock(&hasher, input_buffer, mask, ¶ms, 0, hasher_eff_size, true) + + for ok && metablock_start < input_size { + var metablock_end uint = brotli_min_size_t(input_size, metablock_start+max_metablock_size) + var expected_num_commands uint = (metablock_end-metablock_start)/12 + 16 + var commands []Command = nil + var num_commands uint = 0 + var last_insert_len uint = 0 + var num_literals uint = 0 + var metablock_size uint = 0 + var cmd_alloc_size uint = 0 + var is_last bool + var storage []byte + var storage_ix uint + var literal_context_mode int = ChooseContextMode(¶ms, input_buffer, metablock_start, mask, metablock_end-metablock_start) + var block_start uint + for block_start = metablock_start; block_start < metablock_end; { + var block_size uint = brotli_min_size_t(metablock_end-block_start, max_block_size) + var nodes []ZopfliNode = make([]ZopfliNode, (block_size + 1)) + var path_size uint + var new_cmd_alloc_size uint + BrotliInitZopfliNodes(nodes, block_size+1) + StitchToPreviousBlockH10(hasher, block_size, block_start, input_buffer, mask) + path_size = BrotliZopfliComputeShortestPath(block_size, block_start, input_buffer, mask, ¶ms, dist_cache[:], hasher, nodes) + + /* We allocate a command buffer in the first iteration of this loop that + will be likely big enough for the whole metablock, so that for most + inputs we will not have to reallocate in later iterations. We do the + allocation here and not before the loop, because if the input is small, + this will be allocated after the Zopfli cost model is freed, so this + will not increase peak memory usage. + TODO: If the first allocation is too small, increase command + buffer size exponentially. */ + new_cmd_alloc_size = brotli_max_size_t(expected_num_commands, num_commands+path_size+1) + + if cmd_alloc_size != new_cmd_alloc_size { + var new_commands []Command = make([]Command, new_cmd_alloc_size) + cmd_alloc_size = new_cmd_alloc_size + if commands != nil { + copy(new_commands, commands[:num_commands]) + commands = nil + } + + commands = new_commands + } + + BrotliZopfliCreateCommands(block_size, block_start, nodes[0:], dist_cache[:], &last_insert_len, ¶ms, commands[num_commands:], &num_literals) + num_commands += path_size + block_start += block_size + metablock_size += block_size + nodes = nil + if num_literals > max_literals_per_metablock || num_commands > max_commands_per_metablock { + break + } + } + + if last_insert_len > 0 { + InitInsertCommand(&commands[num_commands], last_insert_len) + num_commands++ + num_literals += last_insert_len + } + + is_last = (metablock_start+metablock_size == input_size) + storage = nil + storage_ix = uint(last_bytes_bits) + + if metablock_size == 0 { + /* Write the ISLAST and ISEMPTY bits. */ + storage = make([]byte, 16) + + storage[0] = byte(last_bytes) + storage[1] = byte(last_bytes >> 8) + BrotliWriteBits(2, 3, &storage_ix, storage) + storage_ix = (storage_ix + 7) &^ 7 + } else if !ShouldCompress_encode(input_buffer, mask, uint64(metablock_start), metablock_size, num_literals, num_commands) { + /* Restore the distance cache, as its last update by + CreateBackwardReferences is now unused. */ + copy(dist_cache[:], saved_dist_cache[:4]) + + storage = make([]byte, (metablock_size + 16)) + storage[0] = byte(last_bytes) + storage[1] = byte(last_bytes >> 8) + BrotliStoreUncompressedMetaBlock(is_last, input_buffer, metablock_start, mask, metablock_size, &storage_ix, storage) + } else { + var mb MetaBlockSplit + var block_params BrotliEncoderParams = params + InitMetaBlockSplit(&mb) + BrotliBuildMetaBlock(input_buffer, metablock_start, mask, &block_params, prev_byte, prev_byte2, commands, num_commands, literal_context_mode, &mb) + { + /* The number of distance symbols effectively used for distance + histograms. It might be less than distance alphabet size + for "Large Window Brotli" (32-bit). */ + var num_effective_dist_codes uint32 = block_params.dist.alphabet_size + if num_effective_dist_codes > BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS { + num_effective_dist_codes = BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS + } + + BrotliOptimizeHistograms(num_effective_dist_codes, &mb) + } + + storage = make([]byte, (2*metablock_size + 503)) + storage[0] = byte(last_bytes) + storage[1] = byte(last_bytes >> 8) + BrotliStoreMetaBlock(input_buffer, metablock_start, metablock_size, mask, prev_byte, prev_byte2, is_last, &block_params, literal_context_mode, commands, num_commands, &mb, &storage_ix, storage) + if metablock_size+4 < storage_ix>>3 { + /* Restore the distance cache and last byte. */ + copy(dist_cache[:], saved_dist_cache[:4]) + + storage[0] = byte(last_bytes) + storage[1] = byte(last_bytes >> 8) + storage_ix = uint(last_bytes_bits) + BrotliStoreUncompressedMetaBlock(is_last, input_buffer, metablock_start, mask, metablock_size, &storage_ix, storage) + } + + DestroyMetaBlockSplit(&mb) + } + + last_bytes = uint16(storage[storage_ix>>3]) + last_bytes_bits = byte(storage_ix & 7) + metablock_start += metablock_size + if metablock_start < input_size { + prev_byte = input_buffer[metablock_start-1] + prev_byte2 = input_buffer[metablock_start-2] + } + + /* Save the state of the distance cache in case we need to restore it for + emitting an uncompressed block. */ + copy(saved_dist_cache[:], dist_cache[:4]) + { + var out_size uint = storage_ix >> 3 + total_out_size += out_size + if total_out_size <= max_out_size { + copy(encoded_buffer, storage[:out_size]) + encoded_buffer = encoded_buffer[out_size:] + } else { + ok = false + } + } + + storage = nil + commands = nil + } + + *encoded_size = total_out_size + DestroyHasher(&hasher) + return ok +} + +func BrotliEncoderMaxCompressedSize(input_size uint) uint { + var num_large_blocks uint = input_size >> 14 + var overhead uint = 2 + (4 * num_large_blocks) + 3 + 1 + /* [window bits / empty metadata] + N * [uncompressed] + [last empty] */ + + var result uint = input_size + overhead + if input_size == 0 { + return 2 + } + if result < input_size { + return 0 + } else { + return result + } +} + +/* Wraps data to uncompressed brotli stream with minimal window size. + |output| should point at region with at least BrotliEncoderMaxCompressedSize + addressable bytes. + Returns the length of stream. */ +func MakeUncompressedStream(input []byte, input_size uint, output []byte) uint { + var size uint = input_size + var result uint = 0 + var offset uint = 0 + if input_size == 0 { + output[0] = 6 + return 1 + } + + output[result] = 0x21 + result++ /* window bits = 10, is_last = false */ + output[result] = 0x03 + result++ /* empty metadata, padding */ + for size > 0 { + var nibbles uint32 = 0 + var chunk_size uint32 + var bits uint32 + if size > 1<<24 { + chunk_size = 1 << 24 + } else { + chunk_size = uint32(size) + } + if chunk_size > 1<<16 { + if chunk_size > 1<<20 { + nibbles = 2 + } else { + nibbles = 1 + } + } + bits = nibbles<<1 | (chunk_size-1)<<3 | 1<<(19+4*nibbles) + output[result] = byte(bits) + result++ + output[result] = byte(bits >> 8) + result++ + output[result] = byte(bits >> 16) + result++ + if nibbles == 2 { + output[result] = byte(bits >> 24) + result++ + } + copy(output[result:], input[offset:][:chunk_size]) + result += uint(chunk_size) + offset += uint(chunk_size) + size -= uint(chunk_size) + } + + output[result] = 3 + result++ + return result +} + +func BrotliEncoderCompress(quality int, lgwin int, mode int, input_size uint, input_buffer []byte, encoded_size *uint, encoded_buffer []byte) bool { + var s *BrotliEncoderState + var out_size uint = *encoded_size + var input_start []byte = input_buffer + var output_start []byte = encoded_buffer + var max_out_size uint = BrotliEncoderMaxCompressedSize(input_size) + if out_size == 0 { + /* Output buffer needs at least one byte. */ + return false + } + + if input_size == 0 { + /* Handle the special case of empty input. */ + *encoded_size = 1 + + encoded_buffer[0] = 6 + return true + } + + if quality == 10 { + var lg_win int = brotli_min_int(BROTLI_LARGE_MAX_WINDOW_BITS, brotli_max_int(16, lgwin)) + /* TODO: Implement this direct path for all quality levels. */ + + var ok bool = BrotliCompressBufferQuality10(lg_win, input_size, input_buffer, encoded_size, encoded_buffer) + if !ok || (max_out_size != 0 && *encoded_size > max_out_size) { + goto fallback + } + + return true + } + + s = BrotliEncoderCreateInstance() + if s == nil { + return false + } else { + var available_in uint = input_size + var next_in []byte = input_buffer + var available_out uint = *encoded_size + var next_out []byte = encoded_buffer + var total_out uint = 0 + var result bool = false + BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, uint32(quality)) + BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, uint32(lgwin)) + BrotliEncoderSetParameter(s, BROTLI_PARAM_MODE, uint32(mode)) + BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, uint32(input_size)) + if lgwin > BROTLI_MAX_WINDOW_BITS { + BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, 1) + } + + result = BrotliEncoderCompressStream(s, int(BROTLI_OPERATION_FINISH), &available_in, &next_in, &available_out, &next_out, &total_out) + if !BrotliEncoderIsFinished(s) { + result = false + } + *encoded_size = total_out + BrotliEncoderDestroyInstance(s) + if !result || (max_out_size != 0 && *encoded_size > max_out_size) { + goto fallback + } + + return true + } + +fallback: + *encoded_size = 0 + if max_out_size == 0 { + return false + } + if out_size >= max_out_size { + *encoded_size = MakeUncompressedStream(input_start, input_size, output_start) + return true + } + + return false +} + +func InjectBytePaddingBlock(s *BrotliEncoderState) { + var seal uint32 = uint32(s.last_bytes_) + var seal_bits uint = uint(s.last_bytes_bits_) + var destination []byte + s.last_bytes_ = 0 + s.last_bytes_bits_ = 0 + + /* is_last = 0, data_nibbles = 11, reserved = 0, meta_nibbles = 00 */ + seal |= 0x6 << seal_bits + + seal_bits += 6 + + /* If we have already created storage, then append to it. + Storage is valid until next block is being compressed. */ + if s.next_out_ != nil { + destination = s.next_out_[s.available_out_:] + } else { + destination = s.tiny_buf_.u8[:] + s.next_out_ = destination + } + + destination[0] = byte(seal) + if seal_bits > 8 { + destination[1] = byte(seal >> 8) + } + if seal_bits > 16 { + destination[2] = byte(seal >> 16) + } + s.available_out_ += (seal_bits + 7) >> 3 +} + +/* Injects padding bits or pushes compressed data to output. + Returns false if nothing is done. */ +func InjectFlushOrPushOutput(s *BrotliEncoderState, available_out *uint, next_out *[]byte, total_out *uint) bool { + if s.stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED && s.last_bytes_bits_ != 0 { + InjectBytePaddingBlock(s) + return true + } + + if s.available_out_ != 0 && *available_out != 0 { + var copy_output_size uint = brotli_min_size_t(s.available_out_, *available_out) + copy(*next_out, s.next_out_[:copy_output_size]) + *next_out = (*next_out)[copy_output_size:] + *available_out -= copy_output_size + s.next_out_ = s.next_out_[copy_output_size:] + s.available_out_ -= copy_output_size + s.total_out_ += copy_output_size + if total_out != nil { + *total_out = s.total_out_ + } + return true + } + + return false +} + +func CheckFlushComplete(s *BrotliEncoderState) { + if s.stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED && s.available_out_ == 0 { + s.stream_state_ = BROTLI_STREAM_PROCESSING + s.next_out_ = nil + } +} + +func BrotliEncoderCompressStreamFast(s *BrotliEncoderState, op int, available_in *uint, next_in *[]byte, available_out *uint, next_out *[]byte, total_out *uint) bool { + var block_size_limit uint = uint(1) << s.params.lgwin + var buf_size uint = brotli_min_size_t(kCompressFragmentTwoPassBlockSize, brotli_min_size_t(*available_in, block_size_limit)) + var tmp_command_buf []uint32 = nil + var command_buf []uint32 = nil + var tmp_literal_buf []byte = nil + var literal_buf []byte = nil + if s.params.quality != FAST_ONE_PASS_COMPRESSION_QUALITY && s.params.quality != FAST_TWO_PASS_COMPRESSION_QUALITY { + return false + } + + if s.params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY { + if s.command_buf_ == nil && buf_size == kCompressFragmentTwoPassBlockSize { + s.command_buf_ = make([]uint32, kCompressFragmentTwoPassBlockSize) + s.literal_buf_ = make([]byte, kCompressFragmentTwoPassBlockSize) + } + + if s.command_buf_ != nil { + command_buf = s.command_buf_ + literal_buf = s.literal_buf_ + } else { + tmp_command_buf = make([]uint32, buf_size) + tmp_literal_buf = make([]byte, buf_size) + command_buf = tmp_command_buf + literal_buf = tmp_literal_buf + } + } + + for { + if InjectFlushOrPushOutput(s, available_out, next_out, total_out) { + continue + } + + /* Compress block only when internal output buffer is empty, stream is not + finished, there is no pending flush request, and there is either + additional input or pending operation. */ + if s.available_out_ == 0 && s.stream_state_ == BROTLI_STREAM_PROCESSING && (*available_in != 0 || op != int(BROTLI_OPERATION_PROCESS)) { + var block_size uint = brotli_min_size_t(block_size_limit, *available_in) + var is_last bool = (*available_in == block_size) && (op == int(BROTLI_OPERATION_FINISH)) + var force_flush bool = (*available_in == block_size) && (op == int(BROTLI_OPERATION_FLUSH)) + var max_out_size uint = 2*block_size + 503 + var inplace bool = true + var storage []byte = nil + var storage_ix uint = uint(s.last_bytes_bits_) + var table_size uint + var table []int + + if force_flush && block_size == 0 { + s.stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED + continue + } + + if max_out_size <= *available_out { + storage = *next_out + } else { + inplace = false + storage = GetBrotliStorage(s, max_out_size) + } + + storage[0] = byte(s.last_bytes_) + storage[1] = byte(s.last_bytes_ >> 8) + table = GetHashTable(s, s.params.quality, block_size, &table_size) + + if s.params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY { + BrotliCompressFragmentFast(*next_in, block_size, is_last, table, table_size, s.cmd_depths_[:], s.cmd_bits_[:], &s.cmd_code_numbits_, s.cmd_code_[:], &storage_ix, storage) + } else { + BrotliCompressFragmentTwoPass(*next_in, block_size, is_last, command_buf, literal_buf, table, table_size, &storage_ix, storage) + } + + *next_in = (*next_in)[block_size:] + *available_in -= block_size + if inplace { + var out_bytes uint = storage_ix >> 3 + assert(out_bytes <= *available_out) + assert(storage_ix&7 == 0 || out_bytes < *available_out) + *next_out = (*next_out)[out_bytes:] + *available_out -= out_bytes + s.total_out_ += out_bytes + if total_out != nil { + *total_out = s.total_out_ + } + } else { + var out_bytes uint = storage_ix >> 3 + s.next_out_ = storage + s.available_out_ = out_bytes + } + + s.last_bytes_ = uint16(storage[storage_ix>>3]) + s.last_bytes_bits_ = byte(storage_ix & 7) + + if force_flush { + s.stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED + } + if is_last { + s.stream_state_ = BROTLI_STREAM_FINISHED + } + continue + } + + break + } + + tmp_command_buf = nil + tmp_literal_buf = nil + CheckFlushComplete(s) + return true +} + +func ProcessMetadata(s *BrotliEncoderState, available_in *uint, next_in *[]byte, available_out *uint, next_out *[]byte, total_out *uint) bool { + if *available_in > 1<<24 { + return false + } + + /* Switch to metadata block workflow, if required. */ + if s.stream_state_ == BROTLI_STREAM_PROCESSING { + s.remaining_metadata_bytes_ = uint32(*available_in) + s.stream_state_ = BROTLI_STREAM_METADATA_HEAD + } + + if s.stream_state_ != BROTLI_STREAM_METADATA_HEAD && s.stream_state_ != BROTLI_STREAM_METADATA_BODY { + return false + } + + for { + if InjectFlushOrPushOutput(s, available_out, next_out, total_out) { + continue + } + + if s.available_out_ != 0 { + break + } + + if s.input_pos_ != s.last_flush_pos_ { + var result bool = EncodeData(s, false, true, &s.available_out_, &s.next_out_) + if !result { + return false + } + continue + } + + if s.stream_state_ == BROTLI_STREAM_METADATA_HEAD { + s.next_out_ = s.tiny_buf_.u8[:] + s.available_out_ = WriteMetadataHeader(s, uint(s.remaining_metadata_bytes_), s.next_out_) + s.stream_state_ = BROTLI_STREAM_METADATA_BODY + continue + } else { + /* Exit workflow only when there is no more input and no more output. + Otherwise client may continue producing empty metadata blocks. */ + if s.remaining_metadata_bytes_ == 0 { + s.remaining_metadata_bytes_ = BROTLI_UINT32_MAX + s.stream_state_ = BROTLI_STREAM_PROCESSING + break + } + + if *available_out != 0 { + /* Directly copy input to output. */ + var c uint32 = uint32(brotli_min_size_t(uint(s.remaining_metadata_bytes_), *available_out)) + copy(*next_out, (*next_in)[:c]) + *next_in = (*next_in)[c:] + *available_in -= uint(c) + s.remaining_metadata_bytes_ -= c + *next_out = (*next_out)[c:] + *available_out -= uint(c) + } else { + /* This guarantees progress in "TakeOutput" workflow. */ + var c uint32 = brotli_min_uint32_t(s.remaining_metadata_bytes_, 16) + s.next_out_ = s.tiny_buf_.u8[:] + copy(s.next_out_, (*next_in)[:c]) + *next_in = (*next_in)[c:] + *available_in -= uint(c) + s.remaining_metadata_bytes_ -= c + s.available_out_ = uint(c) + } + + continue + } + } + + return true +} + +func UpdateSizeHint(s *BrotliEncoderState, available_in uint) { + if s.params.size_hint == 0 { + var delta uint64 = UnprocessedInputSize(s) + var tail uint64 = uint64(available_in) + var limit uint32 = 1 << 30 + var total uint32 + if (delta >= uint64(limit)) || (tail >= uint64(limit)) || ((delta + tail) >= uint64(limit)) { + total = limit + } else { + total = uint32(delta + tail) + } + + s.params.size_hint = uint(total) + } +} + +func BrotliEncoderCompressStream(s *BrotliEncoderState, op int, available_in *uint, next_in *[]byte, available_out *uint, next_out *[]byte, total_out *uint) bool { + if !EnsureInitialized(s) { + return false + } + + /* Unfinished metadata block; check requirements. */ + if s.remaining_metadata_bytes_ != BROTLI_UINT32_MAX { + if uint32(*available_in) != s.remaining_metadata_bytes_ { + return false + } + if op != int(BROTLI_OPERATION_EMIT_METADATA) { + return false + } + } + + if op == int(BROTLI_OPERATION_EMIT_METADATA) { + UpdateSizeHint(s, 0) /* First data metablock might be emitted here. */ + return ProcessMetadata(s, available_in, next_in, available_out, next_out, total_out) + } + + if s.stream_state_ == BROTLI_STREAM_METADATA_HEAD || s.stream_state_ == BROTLI_STREAM_METADATA_BODY { + return false + } + + if s.stream_state_ != BROTLI_STREAM_PROCESSING && *available_in != 0 { + return false + } + + if s.params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY || s.params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY { + return BrotliEncoderCompressStreamFast(s, op, available_in, next_in, available_out, next_out, total_out) + } + + for { + var remaining_block_size uint = RemainingInputBlockSize(s) + + if remaining_block_size != 0 && *available_in != 0 { + var copy_input_size uint = brotli_min_size_t(remaining_block_size, *available_in) + CopyInputToRingBuffer(s, copy_input_size, *next_in) + *next_in = (*next_in)[copy_input_size:] + *available_in -= copy_input_size + continue + } + + if InjectFlushOrPushOutput(s, available_out, next_out, total_out) { + continue + } + + /* Compress data only when internal output buffer is empty, stream is not + finished and there is no pending flush request. */ + if s.available_out_ == 0 && s.stream_state_ == BROTLI_STREAM_PROCESSING { + if remaining_block_size == 0 || op != int(BROTLI_OPERATION_PROCESS) { + var is_last bool = ((*available_in == 0) && op == int(BROTLI_OPERATION_FINISH)) + var force_flush bool = ((*available_in == 0) && op == int(BROTLI_OPERATION_FLUSH)) + var result bool + UpdateSizeHint(s, *available_in) + result = EncodeData(s, is_last, force_flush, &s.available_out_, &s.next_out_) + if !result { + return false + } + if force_flush { + s.stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED + } + if is_last { + s.stream_state_ = BROTLI_STREAM_FINISHED + } + continue + } + } + + break + } + + CheckFlushComplete(s) + return true +} + +func BrotliEncoderIsFinished(s *BrotliEncoderState) bool { + return s.stream_state_ == BROTLI_STREAM_FINISHED && !BrotliEncoderHasMoreOutput(s) +} + +func BrotliEncoderHasMoreOutput(s *BrotliEncoderState) bool { + return s.available_out_ != 0 +} + +func BrotliEncoderTakeOutput(s *BrotliEncoderState, size *uint) []byte { + var consumed_size uint = s.available_out_ + var result []byte = s.next_out_ + if *size != 0 { + consumed_size = brotli_min_size_t(*size, s.available_out_) + } + + if consumed_size != 0 { + s.next_out_ = s.next_out_[consumed_size:] + s.available_out_ -= consumed_size + s.total_out_ += consumed_size + CheckFlushComplete(s) + *size = consumed_size + } else { + *size = 0 + result = nil + } + + return result +} + +func BrotliEncoderVersion() uint32 { + return BROTLI_VERSION +} diff --git a/encoder_dict.go b/encoder_dict.go new file mode 100644 index 0000000..15e02c8 --- /dev/null +++ b/encoder_dict.go @@ -0,0 +1,22 @@ +package brotli + +/* Dictionary data (words and transforms) for 1 possible context */ +type BrotliEncoderDictionary struct { + words *BrotliDictionary + cutoffTransformsCount uint32 + cutoffTransforms uint64 + hash_table []uint16 + buckets []uint16 + dict_words []DictWord +} + +func BrotliInitEncoderDictionary(dict *BrotliEncoderDictionary) { + dict.words = BrotliGetDictionary() + + dict.hash_table = kStaticDictionaryHash[:] + dict.buckets = kStaticDictionaryBuckets[:] + dict.dict_words = kStaticDictionaryWords[:] + + dict.cutoffTransformsCount = kCutoffTransformsCount + dict.cutoffTransforms = kCutoffTransforms +} diff --git a/entropy_encode.go b/entropy_encode.go new file mode 100644 index 0000000..6087d8a --- /dev/null +++ b/entropy_encode.go @@ -0,0 +1,615 @@ +package brotli + +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Entropy encoding (Huffman) utilities. */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Entropy encoding (Huffman) utilities. */ + +/* A node of a Huffman tree. */ +type HuffmanTree struct { + total_count_ uint32 + index_left_ int16 + index_right_or_value_ int16 +} + +func InitHuffmanTree(self *HuffmanTree, count uint32, left int16, right int16) { + self.total_count_ = count + self.index_left_ = left + self.index_right_or_value_ = right +} + +/* Returns 1 is assignment of depths succeeded, otherwise 0. */ + +/* This function will create a Huffman tree. + + The (data,length) contains the population counts. + The tree_limit is the maximum bit depth of the Huffman codes. + + The depth contains the tree, i.e., how many bits are used for + the symbol. + + The actual Huffman tree is constructed in the tree[] array, which has to + be at least 2 * length + 1 long. + + See http://en.wikipedia.org/wiki/Huffman_coding */ + +/* Change the population counts in a way that the consequent + Huffman tree compression, especially its RLE-part will be more + likely to compress this data more efficiently. + + length contains the size of the histogram. + counts contains the population counts. + good_for_rle is a buffer of at least length size */ + +/* Write a Huffman tree from bit depths into the bit-stream representation + of a Huffman tree. The generated Huffman tree is to be compressed once + more using a Huffman tree */ + +/* Get the actual bit values for a tree of bit depths. */ + +/* Input size optimized Shell sort. */ +type HuffmanTreeComparator func(*HuffmanTree, *HuffmanTree) bool + +var SortHuffmanTreeItems_gaps = []uint{132, 57, 23, 10, 4, 1} + +func SortHuffmanTreeItems(items []HuffmanTree, n uint, comparator HuffmanTreeComparator) { + if n < 13 { + /* Insertion sort. */ + var i uint + for i = 1; i < n; i++ { + var tmp HuffmanTree = items[i] + var k uint = i + var j uint = i - 1 + for comparator(&tmp, &items[j]) { + items[k] = items[j] + k = j + tmp10 := j + j-- + if tmp10 == 0 { + break + } + } + + items[k] = tmp + } + + return + } else { + var g int + if n < 57 { + g = 2 + } else { + g = 0 + } + for ; g < 6; g++ { + var gap uint = SortHuffmanTreeItems_gaps[g] + var i uint + for i = gap; i < n; i++ { + var j uint = i + var tmp HuffmanTree = items[i] + for ; j >= gap && comparator(&tmp, &items[j-gap]); j -= gap { + items[j] = items[j-gap] + } + + items[j] = tmp + } + } + } +} + +func BrotliSetDepth(p0 int, pool []HuffmanTree, depth []byte, max_depth int) bool { + var stack [16]int + var level int = 0 + var p int = p0 + assert(max_depth <= 15) + stack[0] = -1 + for { + if pool[p].index_left_ >= 0 { + level++ + if level > max_depth { + return false + } + stack[level] = int(pool[p].index_right_or_value_) + p = int(pool[p].index_left_) + continue + } else { + depth[pool[p].index_right_or_value_] = byte(level) + } + + for level >= 0 && stack[level] == -1 { + level-- + } + if level < 0 { + return true + } + p = stack[level] + stack[level] = -1 + } +} + +/* Sort the root nodes, least popular first. */ +func SortHuffmanTree(v0 *HuffmanTree, v1 *HuffmanTree) bool { + if v0.total_count_ != v1.total_count_ { + return v0.total_count_ < v1.total_count_ + } + + return v0.index_right_or_value_ > v1.index_right_or_value_ +} + +/* This function will create a Huffman tree. + + The catch here is that the tree cannot be arbitrarily deep. + Brotli specifies a maximum depth of 15 bits for "code trees" + and 7 bits for "code length code trees." + + count_limit is the value that is to be faked as the minimum value + and this minimum value is raised until the tree matches the + maximum length requirement. + + This algorithm is not of excellent performance for very long data blocks, + especially when population counts are longer than 2**tree_limit, but + we are not planning to use this with extremely long blocks. + + See http://en.wikipedia.org/wiki/Huffman_coding */ +func BrotliCreateHuffmanTree(data []uint32, length uint, tree_limit int, tree []HuffmanTree, depth []byte) { + var count_limit uint32 + var sentinel HuffmanTree + InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1) + + /* For block sizes below 64 kB, we never need to do a second iteration + of this loop. Probably all of our block sizes will be smaller than + that, so this loop is mostly of academic interest. If we actually + would need this, we would be better off with the Katajainen algorithm. */ + for count_limit = 1; ; count_limit *= 2 { + var n uint = 0 + var i uint + var j uint + var k uint + for i = length; i != 0; { + i-- + if data[i] != 0 { + var count uint32 = brotli_max_uint32_t(data[i], count_limit) + InitHuffmanTree(&tree[n], count, -1, int16(i)) + n++ + } + } + + if n == 1 { + depth[tree[0].index_right_or_value_] = 1 /* Only one element. */ + break + } + + SortHuffmanTreeItems(tree, n, HuffmanTreeComparator(SortHuffmanTree)) + + /* The nodes are: + [0, n): the sorted leaf nodes that we start with. + [n]: we add a sentinel here. + [n + 1, 2n): new parent nodes are added here, starting from + (n+1). These are naturally in ascending order. + [2n]: we add a sentinel at the end as well. + There will be (2n+1) elements at the end. */ + tree[n] = sentinel + + tree[n+1] = sentinel + + i = 0 /* Points to the next leaf node. */ + j = n + 1 /* Points to the next non-leaf node. */ + for k = n - 1; k != 0; k-- { + var left uint + var right uint + if tree[i].total_count_ <= tree[j].total_count_ { + left = i + i++ + } else { + left = j + j++ + } + + if tree[i].total_count_ <= tree[j].total_count_ { + right = i + i++ + } else { + right = j + j++ + } + { + /* The sentinel node becomes the parent node. */ + var j_end uint = 2*n - k + tree[j_end].total_count_ = tree[left].total_count_ + tree[right].total_count_ + tree[j_end].index_left_ = int16(left) + tree[j_end].index_right_or_value_ = int16(right) + + /* Add back the last sentinel node. */ + tree[j_end+1] = sentinel + } + } + + if BrotliSetDepth(int(2*n-1), tree[0:], depth, tree_limit) { + /* We need to pack the Huffman tree in tree_limit bits. If this was not + successful, add fake entities to the lowest values and retry. */ + break + } + } +} + +func Reverse(v []byte, start uint, end uint) { + end-- + for start < end { + var tmp byte = v[start] + v[start] = v[end] + v[end] = tmp + start++ + end-- + } +} + +func BrotliWriteHuffmanTreeRepetitions(previous_value byte, value byte, repetitions uint, tree_size *uint, tree []byte, extra_bits_data []byte) { + assert(repetitions > 0) + if previous_value != value { + tree[*tree_size] = value + extra_bits_data[*tree_size] = 0 + (*tree_size)++ + repetitions-- + } + + if repetitions == 7 { + tree[*tree_size] = value + extra_bits_data[*tree_size] = 0 + (*tree_size)++ + repetitions-- + } + + if repetitions < 3 { + var i uint + for i = 0; i < repetitions; i++ { + tree[*tree_size] = value + extra_bits_data[*tree_size] = 0 + (*tree_size)++ + } + } else { + var start uint = *tree_size + repetitions -= 3 + for { + tree[*tree_size] = BROTLI_REPEAT_PREVIOUS_CODE_LENGTH + extra_bits_data[*tree_size] = byte(repetitions & 0x3) + (*tree_size)++ + repetitions >>= 2 + if repetitions == 0 { + break + } + + repetitions-- + } + + Reverse(tree, start, *tree_size) + Reverse(extra_bits_data, start, *tree_size) + } +} + +func BrotliWriteHuffmanTreeRepetitionsZeros(repetitions uint, tree_size *uint, tree []byte, extra_bits_data []byte) { + if repetitions == 11 { + tree[*tree_size] = 0 + extra_bits_data[*tree_size] = 0 + (*tree_size)++ + repetitions-- + } + + if repetitions < 3 { + var i uint + for i = 0; i < repetitions; i++ { + tree[*tree_size] = 0 + extra_bits_data[*tree_size] = 0 + (*tree_size)++ + } + } else { + var start uint = *tree_size + repetitions -= 3 + for { + tree[*tree_size] = BROTLI_REPEAT_ZERO_CODE_LENGTH + extra_bits_data[*tree_size] = byte(repetitions & 0x7) + (*tree_size)++ + repetitions >>= 3 + if repetitions == 0 { + break + } + + repetitions-- + } + + Reverse(tree, start, *tree_size) + Reverse(extra_bits_data, start, *tree_size) + } +} + +func BrotliOptimizeHuffmanCountsForRle(length uint, counts []uint32, good_for_rle []byte) { + var nonzero_count uint = 0 + var stride uint + var limit uint + var sum uint + var streak_limit uint = 1240 + var i uint + /* Let's make the Huffman code more compatible with RLE encoding. */ + for i = 0; i < length; i++ { + if counts[i] != 0 { + nonzero_count++ + } + } + + if nonzero_count < 16 { + return + } + + for length != 0 && counts[length-1] == 0 { + length-- + } + + if length == 0 { + return /* All zeros. */ + } + + /* Now counts[0..length - 1] does not have trailing zeros. */ + { + var nonzeros uint = 0 + var smallest_nonzero uint32 = 1 << 30 + for i = 0; i < length; i++ { + if counts[i] != 0 { + nonzeros++ + if smallest_nonzero > counts[i] { + smallest_nonzero = counts[i] + } + } + } + + if nonzeros < 5 { + /* Small histogram will model it well. */ + return + } + + if smallest_nonzero < 4 { + var zeros uint = length - nonzeros + if zeros < 6 { + for i = 1; i < length-1; i++ { + if counts[i-1] != 0 && counts[i] == 0 && counts[i+1] != 0 { + counts[i] = 1 + } + } + } + } + + if nonzeros < 28 { + return + } + } + + /* 2) Let's mark all population counts that already can be encoded + with an RLE code. */ + for i := 0; i < int(length); i++ { + good_for_rle[i] = 0 + } + { + var symbol uint32 = counts[0] + /* Let's not spoil any of the existing good RLE codes. + Mark any seq of 0's that is longer as 5 as a good_for_rle. + Mark any seq of non-0's that is longer as 7 as a good_for_rle. */ + + var step uint = 0 + for i = 0; i <= length; i++ { + if i == length || counts[i] != symbol { + if (symbol == 0 && step >= 5) || (symbol != 0 && step >= 7) { + var k uint + for k = 0; k < step; k++ { + good_for_rle[i-k-1] = 1 + } + } + + step = 1 + if i != length { + symbol = counts[i] + } + } else { + step++ + } + } + } + + /* 3) Let's replace those population counts that lead to more RLE codes. + Math here is in 24.8 fixed point representation. */ + stride = 0 + + limit = uint(256*(counts[0]+counts[1]+counts[2])/3 + 420) + sum = 0 + for i = 0; i <= length; i++ { + if i == length || good_for_rle[i] != 0 || (i != 0 && good_for_rle[i-1] != 0) || (256*counts[i]-uint32(limit)+uint32(streak_limit)) >= uint32(2*streak_limit) { + if stride >= 4 || (stride >= 3 && sum == 0) { + var k uint + var count uint = (sum + stride/2) / stride + /* The stride must end, collapse what we have, if we have enough (4). */ + if count == 0 { + count = 1 + } + + if sum == 0 { + /* Don't make an all zeros stride to be upgraded to ones. */ + count = 0 + } + + for k = 0; k < stride; k++ { + /* We don't want to change value at counts[i], + that is already belonging to the next stride. Thus - 1. */ + counts[i-k-1] = uint32(count) + } + } + + stride = 0 + sum = 0 + if i < length-2 { + /* All interesting strides have a count of at least 4, */ + /* at least when non-zeros. */ + limit = uint(256*(counts[i]+counts[i+1]+counts[i+2])/3 + 420) + } else if i < length { + limit = uint(256 * counts[i]) + } else { + limit = 0 + } + } + + stride++ + if i != length { + sum += uint(counts[i]) + if stride >= 4 { + limit = (256*sum + stride/2) / stride + } + + if stride == 4 { + limit += 120 + } + } + } +} + +func DecideOverRleUse(depth []byte, length uint, use_rle_for_non_zero *bool, use_rle_for_zero *bool) { + var total_reps_zero uint = 0 + var total_reps_non_zero uint = 0 + var count_reps_zero uint = 1 + var count_reps_non_zero uint = 1 + var i uint + for i = 0; i < length; { + var value byte = depth[i] + var reps uint = 1 + var k uint + for k = i + 1; k < length && depth[k] == value; k++ { + reps++ + } + + if reps >= 3 && value == 0 { + total_reps_zero += reps + count_reps_zero++ + } + + if reps >= 4 && value != 0 { + total_reps_non_zero += reps + count_reps_non_zero++ + } + + i += reps + } + + *use_rle_for_non_zero = total_reps_non_zero > count_reps_non_zero*2 + *use_rle_for_zero = total_reps_zero > count_reps_zero*2 +} + +func BrotliWriteHuffmanTree(depth []byte, length uint, tree_size *uint, tree []byte, extra_bits_data []byte) { + var previous_value byte = BROTLI_INITIAL_REPEATED_CODE_LENGTH + var i uint + var use_rle_for_non_zero bool = false + var use_rle_for_zero bool = false + var new_length uint = length + /* Throw away trailing zeros. */ + for i = 0; i < length; i++ { + if depth[length-i-1] == 0 { + new_length-- + } else { + break + } + } + + /* First gather statistics on if it is a good idea to do RLE. */ + if length > 50 { + /* Find RLE coding for longer codes. + Shorter codes seem not to benefit from RLE. */ + DecideOverRleUse(depth, new_length, &use_rle_for_non_zero, &use_rle_for_zero) + } + + /* Actual RLE coding. */ + for i = 0; i < new_length; { + var value byte = depth[i] + var reps uint = 1 + if (value != 0 && use_rle_for_non_zero) || (value == 0 && use_rle_for_zero) { + var k uint + for k = i + 1; k < new_length && depth[k] == value; k++ { + reps++ + } + } + + if value == 0 { + BrotliWriteHuffmanTreeRepetitionsZeros(reps, tree_size, tree, extra_bits_data) + } else { + BrotliWriteHuffmanTreeRepetitions(previous_value, value, reps, tree_size, tree, extra_bits_data) + previous_value = value + } + + i += reps + } +} + +var BrotliReverseBits_kLut = [16]uint{ + 0x00, + 0x08, + 0x04, + 0x0C, + 0x02, + 0x0A, + 0x06, + 0x0E, + 0x01, + 0x09, + 0x05, + 0x0D, + 0x03, + 0x0B, + 0x07, + 0x0F, +} + +func BrotliReverseBits(num_bits uint, bits uint16) uint16 { + var retval uint = BrotliReverseBits_kLut[bits&0x0F] + var i uint + for i = 4; i < num_bits; i += 4 { + retval <<= 4 + bits = uint16(bits >> 4) + retval |= BrotliReverseBits_kLut[bits&0x0F] + } + + retval >>= ((0 - num_bits) & 0x03) + return uint16(retval) +} + +/* 0..15 are values for bits */ +const MAX_HUFFMAN_BITS = 16 + +func BrotliConvertBitDepthsToSymbols(depth []byte, len uint, bits []uint16) { + var bl_count = [MAX_HUFFMAN_BITS]uint16{0} + var next_code [MAX_HUFFMAN_BITS]uint16 + var i uint + /* In Brotli, all bit depths are [1..15] + 0 bit depth means that the symbol does not exist. */ + + var code int = 0 + for i = 0; i < len; i++ { + bl_count[depth[i]]++ + } + + bl_count[0] = 0 + next_code[0] = 0 + for i = 1; i < MAX_HUFFMAN_BITS; i++ { + code = (code + int(bl_count[i-1])) << 1 + next_code[i] = uint16(code) + } + + for i = 0; i < len; i++ { + if depth[i] != 0 { + bits[i] = BrotliReverseBits(uint(depth[i]), next_code[depth[i]]) + next_code[depth[i]]++ + } + } +} diff --git a/entropy_encode_static.go b/entropy_encode_static.go new file mode 100644 index 0000000..4436929 --- /dev/null +++ b/entropy_encode_static.go @@ -0,0 +1,4394 @@ +package brotli + +var kCodeLengthDepth = [18]byte{4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 0, 4, 4} + +var kStaticCommandCodeDepth = [BROTLI_NUM_COMMAND_SYMBOLS]byte{ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, +} + +var kStaticDistanceCodeDepth = [64]byte{ + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, +} + +var kCodeLengthBits = [18]uint32{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 15, 31, 0, 11, 7} + +func StoreStaticCodeLengthCode(storage_ix *uint, storage []byte) { + BrotliWriteBits(40, 0x0000FF55555554, storage_ix, storage) +} + +var kZeroRepsBits = [BROTLI_NUM_COMMAND_SYMBOLS]uint64{ + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000007, + 0x00000017, + 0x00000027, + 0x00000037, + 0x00000047, + 0x00000057, + 0x00000067, + 0x00000077, + 0x00000770, + 0x00000b87, + 0x00001387, + 0x00001b87, + 0x00002387, + 0x00002b87, + 0x00003387, + 0x00003b87, + 0x00000397, + 0x00000b97, + 0x00001397, + 0x00001b97, + 0x00002397, + 0x00002b97, + 0x00003397, + 0x00003b97, + 0x000003a7, + 0x00000ba7, + 0x000013a7, + 0x00001ba7, + 0x000023a7, + 0x00002ba7, + 0x000033a7, + 0x00003ba7, + 0x000003b7, + 0x00000bb7, + 0x000013b7, + 0x00001bb7, + 0x000023b7, + 0x00002bb7, + 0x000033b7, + 0x00003bb7, + 0x000003c7, + 0x00000bc7, + 0x000013c7, + 0x00001bc7, + 0x000023c7, + 0x00002bc7, + 0x000033c7, + 0x00003bc7, + 0x000003d7, + 0x00000bd7, + 0x000013d7, + 0x00001bd7, + 0x000023d7, + 0x00002bd7, + 0x000033d7, + 0x00003bd7, + 0x000003e7, + 0x00000be7, + 0x000013e7, + 0x00001be7, + 0x000023e7, + 0x00002be7, + 0x000033e7, + 0x00003be7, + 0x000003f7, + 0x00000bf7, + 0x000013f7, + 0x00001bf7, + 0x000023f7, + 0x00002bf7, + 0x000033f7, + 0x00003bf7, + 0x0001c387, + 0x0005c387, + 0x0009c387, + 0x000dc387, + 0x0011c387, + 0x0015c387, + 0x0019c387, + 0x001dc387, + 0x0001cb87, + 0x0005cb87, + 0x0009cb87, + 0x000dcb87, + 0x0011cb87, + 0x0015cb87, + 0x0019cb87, + 0x001dcb87, + 0x0001d387, + 0x0005d387, + 0x0009d387, + 0x000dd387, + 0x0011d387, + 0x0015d387, + 0x0019d387, + 0x001dd387, + 0x0001db87, + 0x0005db87, + 0x0009db87, + 0x000ddb87, + 0x0011db87, + 0x0015db87, + 0x0019db87, + 0x001ddb87, + 0x0001e387, + 0x0005e387, + 0x0009e387, + 0x000de387, + 0x0011e387, + 0x0015e387, + 0x0019e387, + 0x001de387, + 0x0001eb87, + 0x0005eb87, + 0x0009eb87, + 0x000deb87, + 0x0011eb87, + 0x0015eb87, + 0x0019eb87, + 0x001deb87, + 0x0001f387, + 0x0005f387, + 0x0009f387, + 0x000df387, + 0x0011f387, + 0x0015f387, + 0x0019f387, + 0x001df387, + 0x0001fb87, + 0x0005fb87, + 0x0009fb87, + 0x000dfb87, + 0x0011fb87, + 0x0015fb87, + 0x0019fb87, + 0x001dfb87, + 0x0001c397, + 0x0005c397, + 0x0009c397, + 0x000dc397, + 0x0011c397, + 0x0015c397, + 0x0019c397, + 0x001dc397, + 0x0001cb97, + 0x0005cb97, + 0x0009cb97, + 0x000dcb97, + 0x0011cb97, + 0x0015cb97, + 0x0019cb97, + 0x001dcb97, + 0x0001d397, + 0x0005d397, + 0x0009d397, + 0x000dd397, + 0x0011d397, + 0x0015d397, + 0x0019d397, + 0x001dd397, + 0x0001db97, + 0x0005db97, + 0x0009db97, + 0x000ddb97, + 0x0011db97, + 0x0015db97, + 0x0019db97, + 0x001ddb97, + 0x0001e397, + 0x0005e397, + 0x0009e397, + 0x000de397, + 0x0011e397, + 0x0015e397, + 0x0019e397, + 0x001de397, + 0x0001eb97, + 0x0005eb97, + 0x0009eb97, + 0x000deb97, + 0x0011eb97, + 0x0015eb97, + 0x0019eb97, + 0x001deb97, + 0x0001f397, + 0x0005f397, + 0x0009f397, + 0x000df397, + 0x0011f397, + 0x0015f397, + 0x0019f397, + 0x001df397, + 0x0001fb97, + 0x0005fb97, + 0x0009fb97, + 0x000dfb97, + 0x0011fb97, + 0x0015fb97, + 0x0019fb97, + 0x001dfb97, + 0x0001c3a7, + 0x0005c3a7, + 0x0009c3a7, + 0x000dc3a7, + 0x0011c3a7, + 0x0015c3a7, + 0x0019c3a7, + 0x001dc3a7, + 0x0001cba7, + 0x0005cba7, + 0x0009cba7, + 0x000dcba7, + 0x0011cba7, + 0x0015cba7, + 0x0019cba7, + 0x001dcba7, + 0x0001d3a7, + 0x0005d3a7, + 0x0009d3a7, + 0x000dd3a7, + 0x0011d3a7, + 0x0015d3a7, + 0x0019d3a7, + 0x001dd3a7, + 0x0001dba7, + 0x0005dba7, + 0x0009dba7, + 0x000ddba7, + 0x0011dba7, + 0x0015dba7, + 0x0019dba7, + 0x001ddba7, + 0x0001e3a7, + 0x0005e3a7, + 0x0009e3a7, + 0x000de3a7, + 0x0011e3a7, + 0x0015e3a7, + 0x0019e3a7, + 0x001de3a7, + 0x0001eba7, + 0x0005eba7, + 0x0009eba7, + 0x000deba7, + 0x0011eba7, + 0x0015eba7, + 0x0019eba7, + 0x001deba7, + 0x0001f3a7, + 0x0005f3a7, + 0x0009f3a7, + 0x000df3a7, + 0x0011f3a7, + 0x0015f3a7, + 0x0019f3a7, + 0x001df3a7, + 0x0001fba7, + 0x0005fba7, + 0x0009fba7, + 0x000dfba7, + 0x0011fba7, + 0x0015fba7, + 0x0019fba7, + 0x001dfba7, + 0x0001c3b7, + 0x0005c3b7, + 0x0009c3b7, + 0x000dc3b7, + 0x0011c3b7, + 0x0015c3b7, + 0x0019c3b7, + 0x001dc3b7, + 0x0001cbb7, + 0x0005cbb7, + 0x0009cbb7, + 0x000dcbb7, + 0x0011cbb7, + 0x0015cbb7, + 0x0019cbb7, + 0x001dcbb7, + 0x0001d3b7, + 0x0005d3b7, + 0x0009d3b7, + 0x000dd3b7, + 0x0011d3b7, + 0x0015d3b7, + 0x0019d3b7, + 0x001dd3b7, + 0x0001dbb7, + 0x0005dbb7, + 0x0009dbb7, + 0x000ddbb7, + 0x0011dbb7, + 0x0015dbb7, + 0x0019dbb7, + 0x001ddbb7, + 0x0001e3b7, + 0x0005e3b7, + 0x0009e3b7, + 0x000de3b7, + 0x0011e3b7, + 0x0015e3b7, + 0x0019e3b7, + 0x001de3b7, + 0x0001ebb7, + 0x0005ebb7, + 0x0009ebb7, + 0x000debb7, + 0x0011ebb7, + 0x0015ebb7, + 0x0019ebb7, + 0x001debb7, + 0x0001f3b7, + 0x0005f3b7, + 0x0009f3b7, + 0x000df3b7, + 0x0011f3b7, + 0x0015f3b7, + 0x0019f3b7, + 0x001df3b7, + 0x0001fbb7, + 0x0005fbb7, + 0x0009fbb7, + 0x000dfbb7, + 0x0011fbb7, + 0x0015fbb7, + 0x0019fbb7, + 0x001dfbb7, + 0x0001c3c7, + 0x0005c3c7, + 0x0009c3c7, + 0x000dc3c7, + 0x0011c3c7, + 0x0015c3c7, + 0x0019c3c7, + 0x001dc3c7, + 0x0001cbc7, + 0x0005cbc7, + 0x0009cbc7, + 0x000dcbc7, + 0x0011cbc7, + 0x0015cbc7, + 0x0019cbc7, + 0x001dcbc7, + 0x0001d3c7, + 0x0005d3c7, + 0x0009d3c7, + 0x000dd3c7, + 0x0011d3c7, + 0x0015d3c7, + 0x0019d3c7, + 0x001dd3c7, + 0x0001dbc7, + 0x0005dbc7, + 0x0009dbc7, + 0x000ddbc7, + 0x0011dbc7, + 0x0015dbc7, + 0x0019dbc7, + 0x001ddbc7, + 0x0001e3c7, + 0x0005e3c7, + 0x0009e3c7, + 0x000de3c7, + 0x0011e3c7, + 0x0015e3c7, + 0x0019e3c7, + 0x001de3c7, + 0x0001ebc7, + 0x0005ebc7, + 0x0009ebc7, + 0x000debc7, + 0x0011ebc7, + 0x0015ebc7, + 0x0019ebc7, + 0x001debc7, + 0x0001f3c7, + 0x0005f3c7, + 0x0009f3c7, + 0x000df3c7, + 0x0011f3c7, + 0x0015f3c7, + 0x0019f3c7, + 0x001df3c7, + 0x0001fbc7, + 0x0005fbc7, + 0x0009fbc7, + 0x000dfbc7, + 0x0011fbc7, + 0x0015fbc7, + 0x0019fbc7, + 0x001dfbc7, + 0x0001c3d7, + 0x0005c3d7, + 0x0009c3d7, + 0x000dc3d7, + 0x0011c3d7, + 0x0015c3d7, + 0x0019c3d7, + 0x001dc3d7, + 0x0001cbd7, + 0x0005cbd7, + 0x0009cbd7, + 0x000dcbd7, + 0x0011cbd7, + 0x0015cbd7, + 0x0019cbd7, + 0x001dcbd7, + 0x0001d3d7, + 0x0005d3d7, + 0x0009d3d7, + 0x000dd3d7, + 0x0011d3d7, + 0x0015d3d7, + 0x0019d3d7, + 0x001dd3d7, + 0x0001dbd7, + 0x0005dbd7, + 0x0009dbd7, + 0x000ddbd7, + 0x0011dbd7, + 0x0015dbd7, + 0x0019dbd7, + 0x001ddbd7, + 0x0001e3d7, + 0x0005e3d7, + 0x0009e3d7, + 0x000de3d7, + 0x0011e3d7, + 0x0015e3d7, + 0x0019e3d7, + 0x001de3d7, + 0x0001ebd7, + 0x0005ebd7, + 0x0009ebd7, + 0x000debd7, + 0x0011ebd7, + 0x0015ebd7, + 0x0019ebd7, + 0x001debd7, + 0x0001f3d7, + 0x0005f3d7, + 0x0009f3d7, + 0x000df3d7, + 0x0011f3d7, + 0x0015f3d7, + 0x0019f3d7, + 0x001df3d7, + 0x0001fbd7, + 0x0005fbd7, + 0x0009fbd7, + 0x000dfbd7, + 0x0011fbd7, + 0x0015fbd7, + 0x0019fbd7, + 0x001dfbd7, + 0x0001c3e7, + 0x0005c3e7, + 0x0009c3e7, + 0x000dc3e7, + 0x0011c3e7, + 0x0015c3e7, + 0x0019c3e7, + 0x001dc3e7, + 0x0001cbe7, + 0x0005cbe7, + 0x0009cbe7, + 0x000dcbe7, + 0x0011cbe7, + 0x0015cbe7, + 0x0019cbe7, + 0x001dcbe7, + 0x0001d3e7, + 0x0005d3e7, + 0x0009d3e7, + 0x000dd3e7, + 0x0011d3e7, + 0x0015d3e7, + 0x0019d3e7, + 0x001dd3e7, + 0x0001dbe7, + 0x0005dbe7, + 0x0009dbe7, + 0x000ddbe7, + 0x0011dbe7, + 0x0015dbe7, + 0x0019dbe7, + 0x001ddbe7, + 0x0001e3e7, + 0x0005e3e7, + 0x0009e3e7, + 0x000de3e7, + 0x0011e3e7, + 0x0015e3e7, + 0x0019e3e7, + 0x001de3e7, + 0x0001ebe7, + 0x0005ebe7, + 0x0009ebe7, + 0x000debe7, + 0x0011ebe7, + 0x0015ebe7, + 0x0019ebe7, + 0x001debe7, + 0x0001f3e7, + 0x0005f3e7, + 0x0009f3e7, + 0x000df3e7, + 0x0011f3e7, + 0x0015f3e7, + 0x0019f3e7, + 0x001df3e7, + 0x0001fbe7, + 0x0005fbe7, + 0x0009fbe7, + 0x000dfbe7, + 0x0011fbe7, + 0x0015fbe7, + 0x0019fbe7, + 0x001dfbe7, + 0x0001c3f7, + 0x0005c3f7, + 0x0009c3f7, + 0x000dc3f7, + 0x0011c3f7, + 0x0015c3f7, + 0x0019c3f7, + 0x001dc3f7, + 0x0001cbf7, + 0x0005cbf7, + 0x0009cbf7, + 0x000dcbf7, + 0x0011cbf7, + 0x0015cbf7, + 0x0019cbf7, + 0x001dcbf7, + 0x0001d3f7, + 0x0005d3f7, + 0x0009d3f7, + 0x000dd3f7, + 0x0011d3f7, + 0x0015d3f7, + 0x0019d3f7, + 0x001dd3f7, + 0x0001dbf7, + 0x0005dbf7, + 0x0009dbf7, + 0x000ddbf7, + 0x0011dbf7, + 0x0015dbf7, + 0x0019dbf7, + 0x001ddbf7, + 0x0001e3f7, + 0x0005e3f7, + 0x0009e3f7, + 0x000de3f7, + 0x0011e3f7, + 0x0015e3f7, + 0x0019e3f7, + 0x001de3f7, + 0x0001ebf7, + 0x0005ebf7, + 0x0009ebf7, + 0x000debf7, + 0x0011ebf7, + 0x0015ebf7, + 0x0019ebf7, + 0x001debf7, + 0x0001f3f7, + 0x0005f3f7, + 0x0009f3f7, + 0x000df3f7, + 0x0011f3f7, + 0x0015f3f7, + 0x0019f3f7, + 0x001df3f7, + 0x0001fbf7, + 0x0005fbf7, + 0x0009fbf7, + 0x000dfbf7, + 0x0011fbf7, + 0x0015fbf7, + 0x0019fbf7, + 0x001dfbf7, + 0x00e1c387, + 0x02e1c387, + 0x04e1c387, + 0x06e1c387, + 0x08e1c387, + 0x0ae1c387, + 0x0ce1c387, + 0x0ee1c387, + 0x00e5c387, + 0x02e5c387, + 0x04e5c387, + 0x06e5c387, + 0x08e5c387, + 0x0ae5c387, + 0x0ce5c387, + 0x0ee5c387, + 0x00e9c387, + 0x02e9c387, + 0x04e9c387, + 0x06e9c387, + 0x08e9c387, + 0x0ae9c387, + 0x0ce9c387, + 0x0ee9c387, + 0x00edc387, + 0x02edc387, + 0x04edc387, + 0x06edc387, + 0x08edc387, + 0x0aedc387, + 0x0cedc387, + 0x0eedc387, + 0x00f1c387, + 0x02f1c387, + 0x04f1c387, + 0x06f1c387, + 0x08f1c387, + 0x0af1c387, + 0x0cf1c387, + 0x0ef1c387, + 0x00f5c387, + 0x02f5c387, + 0x04f5c387, + 0x06f5c387, + 0x08f5c387, + 0x0af5c387, + 0x0cf5c387, + 0x0ef5c387, + 0x00f9c387, + 0x02f9c387, + 0x04f9c387, + 0x06f9c387, + 0x08f9c387, + 0x0af9c387, + 0x0cf9c387, + 0x0ef9c387, + 0x00fdc387, + 0x02fdc387, + 0x04fdc387, + 0x06fdc387, + 0x08fdc387, + 0x0afdc387, + 0x0cfdc387, + 0x0efdc387, + 0x00e1cb87, + 0x02e1cb87, + 0x04e1cb87, + 0x06e1cb87, + 0x08e1cb87, + 0x0ae1cb87, + 0x0ce1cb87, + 0x0ee1cb87, + 0x00e5cb87, + 0x02e5cb87, + 0x04e5cb87, + 0x06e5cb87, + 0x08e5cb87, + 0x0ae5cb87, + 0x0ce5cb87, + 0x0ee5cb87, + 0x00e9cb87, + 0x02e9cb87, + 0x04e9cb87, + 0x06e9cb87, + 0x08e9cb87, + 0x0ae9cb87, + 0x0ce9cb87, + 0x0ee9cb87, + 0x00edcb87, + 0x02edcb87, + 0x04edcb87, + 0x06edcb87, + 0x08edcb87, + 0x0aedcb87, + 0x0cedcb87, + 0x0eedcb87, + 0x00f1cb87, + 0x02f1cb87, + 0x04f1cb87, + 0x06f1cb87, + 0x08f1cb87, + 0x0af1cb87, + 0x0cf1cb87, + 0x0ef1cb87, + 0x00f5cb87, + 0x02f5cb87, + 0x04f5cb87, + 0x06f5cb87, + 0x08f5cb87, + 0x0af5cb87, + 0x0cf5cb87, + 0x0ef5cb87, + 0x00f9cb87, + 0x02f9cb87, + 0x04f9cb87, + 0x06f9cb87, + 0x08f9cb87, +} + +var kZeroRepsDepth = [BROTLI_NUM_COMMAND_SYMBOLS]uint32{ + 0, + 4, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 11, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 14, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, +} + +var kNonZeroRepsBits = [BROTLI_NUM_COMMAND_SYMBOLS]uint64{ + 0x0000000b, + 0x0000001b, + 0x0000002b, + 0x0000003b, + 0x000002cb, + 0x000006cb, + 0x00000acb, + 0x00000ecb, + 0x000002db, + 0x000006db, + 0x00000adb, + 0x00000edb, + 0x000002eb, + 0x000006eb, + 0x00000aeb, + 0x00000eeb, + 0x000002fb, + 0x000006fb, + 0x00000afb, + 0x00000efb, + 0x0000b2cb, + 0x0001b2cb, + 0x0002b2cb, + 0x0003b2cb, + 0x0000b6cb, + 0x0001b6cb, + 0x0002b6cb, + 0x0003b6cb, + 0x0000bacb, + 0x0001bacb, + 0x0002bacb, + 0x0003bacb, + 0x0000becb, + 0x0001becb, + 0x0002becb, + 0x0003becb, + 0x0000b2db, + 0x0001b2db, + 0x0002b2db, + 0x0003b2db, + 0x0000b6db, + 0x0001b6db, + 0x0002b6db, + 0x0003b6db, + 0x0000badb, + 0x0001badb, + 0x0002badb, + 0x0003badb, + 0x0000bedb, + 0x0001bedb, + 0x0002bedb, + 0x0003bedb, + 0x0000b2eb, + 0x0001b2eb, + 0x0002b2eb, + 0x0003b2eb, + 0x0000b6eb, + 0x0001b6eb, + 0x0002b6eb, + 0x0003b6eb, + 0x0000baeb, + 0x0001baeb, + 0x0002baeb, + 0x0003baeb, + 0x0000beeb, + 0x0001beeb, + 0x0002beeb, + 0x0003beeb, + 0x0000b2fb, + 0x0001b2fb, + 0x0002b2fb, + 0x0003b2fb, + 0x0000b6fb, + 0x0001b6fb, + 0x0002b6fb, + 0x0003b6fb, + 0x0000bafb, + 0x0001bafb, + 0x0002bafb, + 0x0003bafb, + 0x0000befb, + 0x0001befb, + 0x0002befb, + 0x0003befb, + 0x002cb2cb, + 0x006cb2cb, + 0x00acb2cb, + 0x00ecb2cb, + 0x002db2cb, + 0x006db2cb, + 0x00adb2cb, + 0x00edb2cb, + 0x002eb2cb, + 0x006eb2cb, + 0x00aeb2cb, + 0x00eeb2cb, + 0x002fb2cb, + 0x006fb2cb, + 0x00afb2cb, + 0x00efb2cb, + 0x002cb6cb, + 0x006cb6cb, + 0x00acb6cb, + 0x00ecb6cb, + 0x002db6cb, + 0x006db6cb, + 0x00adb6cb, + 0x00edb6cb, + 0x002eb6cb, + 0x006eb6cb, + 0x00aeb6cb, + 0x00eeb6cb, + 0x002fb6cb, + 0x006fb6cb, + 0x00afb6cb, + 0x00efb6cb, + 0x002cbacb, + 0x006cbacb, + 0x00acbacb, + 0x00ecbacb, + 0x002dbacb, + 0x006dbacb, + 0x00adbacb, + 0x00edbacb, + 0x002ebacb, + 0x006ebacb, + 0x00aebacb, + 0x00eebacb, + 0x002fbacb, + 0x006fbacb, + 0x00afbacb, + 0x00efbacb, + 0x002cbecb, + 0x006cbecb, + 0x00acbecb, + 0x00ecbecb, + 0x002dbecb, + 0x006dbecb, + 0x00adbecb, + 0x00edbecb, + 0x002ebecb, + 0x006ebecb, + 0x00aebecb, + 0x00eebecb, + 0x002fbecb, + 0x006fbecb, + 0x00afbecb, + 0x00efbecb, + 0x002cb2db, + 0x006cb2db, + 0x00acb2db, + 0x00ecb2db, + 0x002db2db, + 0x006db2db, + 0x00adb2db, + 0x00edb2db, + 0x002eb2db, + 0x006eb2db, + 0x00aeb2db, + 0x00eeb2db, + 0x002fb2db, + 0x006fb2db, + 0x00afb2db, + 0x00efb2db, + 0x002cb6db, + 0x006cb6db, + 0x00acb6db, + 0x00ecb6db, + 0x002db6db, + 0x006db6db, + 0x00adb6db, + 0x00edb6db, + 0x002eb6db, + 0x006eb6db, + 0x00aeb6db, + 0x00eeb6db, + 0x002fb6db, + 0x006fb6db, + 0x00afb6db, + 0x00efb6db, + 0x002cbadb, + 0x006cbadb, + 0x00acbadb, + 0x00ecbadb, + 0x002dbadb, + 0x006dbadb, + 0x00adbadb, + 0x00edbadb, + 0x002ebadb, + 0x006ebadb, + 0x00aebadb, + 0x00eebadb, + 0x002fbadb, + 0x006fbadb, + 0x00afbadb, + 0x00efbadb, + 0x002cbedb, + 0x006cbedb, + 0x00acbedb, + 0x00ecbedb, + 0x002dbedb, + 0x006dbedb, + 0x00adbedb, + 0x00edbedb, + 0x002ebedb, + 0x006ebedb, + 0x00aebedb, + 0x00eebedb, + 0x002fbedb, + 0x006fbedb, + 0x00afbedb, + 0x00efbedb, + 0x002cb2eb, + 0x006cb2eb, + 0x00acb2eb, + 0x00ecb2eb, + 0x002db2eb, + 0x006db2eb, + 0x00adb2eb, + 0x00edb2eb, + 0x002eb2eb, + 0x006eb2eb, + 0x00aeb2eb, + 0x00eeb2eb, + 0x002fb2eb, + 0x006fb2eb, + 0x00afb2eb, + 0x00efb2eb, + 0x002cb6eb, + 0x006cb6eb, + 0x00acb6eb, + 0x00ecb6eb, + 0x002db6eb, + 0x006db6eb, + 0x00adb6eb, + 0x00edb6eb, + 0x002eb6eb, + 0x006eb6eb, + 0x00aeb6eb, + 0x00eeb6eb, + 0x002fb6eb, + 0x006fb6eb, + 0x00afb6eb, + 0x00efb6eb, + 0x002cbaeb, + 0x006cbaeb, + 0x00acbaeb, + 0x00ecbaeb, + 0x002dbaeb, + 0x006dbaeb, + 0x00adbaeb, + 0x00edbaeb, + 0x002ebaeb, + 0x006ebaeb, + 0x00aebaeb, + 0x00eebaeb, + 0x002fbaeb, + 0x006fbaeb, + 0x00afbaeb, + 0x00efbaeb, + 0x002cbeeb, + 0x006cbeeb, + 0x00acbeeb, + 0x00ecbeeb, + 0x002dbeeb, + 0x006dbeeb, + 0x00adbeeb, + 0x00edbeeb, + 0x002ebeeb, + 0x006ebeeb, + 0x00aebeeb, + 0x00eebeeb, + 0x002fbeeb, + 0x006fbeeb, + 0x00afbeeb, + 0x00efbeeb, + 0x002cb2fb, + 0x006cb2fb, + 0x00acb2fb, + 0x00ecb2fb, + 0x002db2fb, + 0x006db2fb, + 0x00adb2fb, + 0x00edb2fb, + 0x002eb2fb, + 0x006eb2fb, + 0x00aeb2fb, + 0x00eeb2fb, + 0x002fb2fb, + 0x006fb2fb, + 0x00afb2fb, + 0x00efb2fb, + 0x002cb6fb, + 0x006cb6fb, + 0x00acb6fb, + 0x00ecb6fb, + 0x002db6fb, + 0x006db6fb, + 0x00adb6fb, + 0x00edb6fb, + 0x002eb6fb, + 0x006eb6fb, + 0x00aeb6fb, + 0x00eeb6fb, + 0x002fb6fb, + 0x006fb6fb, + 0x00afb6fb, + 0x00efb6fb, + 0x002cbafb, + 0x006cbafb, + 0x00acbafb, + 0x00ecbafb, + 0x002dbafb, + 0x006dbafb, + 0x00adbafb, + 0x00edbafb, + 0x002ebafb, + 0x006ebafb, + 0x00aebafb, + 0x00eebafb, + 0x002fbafb, + 0x006fbafb, + 0x00afbafb, + 0x00efbafb, + 0x002cbefb, + 0x006cbefb, + 0x00acbefb, + 0x00ecbefb, + 0x002dbefb, + 0x006dbefb, + 0x00adbefb, + 0x00edbefb, + 0x002ebefb, + 0x006ebefb, + 0x00aebefb, + 0x00eebefb, + 0x002fbefb, + 0x006fbefb, + 0x00afbefb, + 0x00efbefb, + 0x0b2cb2cb, + 0x1b2cb2cb, + 0x2b2cb2cb, + 0x3b2cb2cb, + 0x0b6cb2cb, + 0x1b6cb2cb, + 0x2b6cb2cb, + 0x3b6cb2cb, + 0x0bacb2cb, + 0x1bacb2cb, + 0x2bacb2cb, + 0x3bacb2cb, + 0x0becb2cb, + 0x1becb2cb, + 0x2becb2cb, + 0x3becb2cb, + 0x0b2db2cb, + 0x1b2db2cb, + 0x2b2db2cb, + 0x3b2db2cb, + 0x0b6db2cb, + 0x1b6db2cb, + 0x2b6db2cb, + 0x3b6db2cb, + 0x0badb2cb, + 0x1badb2cb, + 0x2badb2cb, + 0x3badb2cb, + 0x0bedb2cb, + 0x1bedb2cb, + 0x2bedb2cb, + 0x3bedb2cb, + 0x0b2eb2cb, + 0x1b2eb2cb, + 0x2b2eb2cb, + 0x3b2eb2cb, + 0x0b6eb2cb, + 0x1b6eb2cb, + 0x2b6eb2cb, + 0x3b6eb2cb, + 0x0baeb2cb, + 0x1baeb2cb, + 0x2baeb2cb, + 0x3baeb2cb, + 0x0beeb2cb, + 0x1beeb2cb, + 0x2beeb2cb, + 0x3beeb2cb, + 0x0b2fb2cb, + 0x1b2fb2cb, + 0x2b2fb2cb, + 0x3b2fb2cb, + 0x0b6fb2cb, + 0x1b6fb2cb, + 0x2b6fb2cb, + 0x3b6fb2cb, + 0x0bafb2cb, + 0x1bafb2cb, + 0x2bafb2cb, + 0x3bafb2cb, + 0x0befb2cb, + 0x1befb2cb, + 0x2befb2cb, + 0x3befb2cb, + 0x0b2cb6cb, + 0x1b2cb6cb, + 0x2b2cb6cb, + 0x3b2cb6cb, + 0x0b6cb6cb, + 0x1b6cb6cb, + 0x2b6cb6cb, + 0x3b6cb6cb, + 0x0bacb6cb, + 0x1bacb6cb, + 0x2bacb6cb, + 0x3bacb6cb, + 0x0becb6cb, + 0x1becb6cb, + 0x2becb6cb, + 0x3becb6cb, + 0x0b2db6cb, + 0x1b2db6cb, + 0x2b2db6cb, + 0x3b2db6cb, + 0x0b6db6cb, + 0x1b6db6cb, + 0x2b6db6cb, + 0x3b6db6cb, + 0x0badb6cb, + 0x1badb6cb, + 0x2badb6cb, + 0x3badb6cb, + 0x0bedb6cb, + 0x1bedb6cb, + 0x2bedb6cb, + 0x3bedb6cb, + 0x0b2eb6cb, + 0x1b2eb6cb, + 0x2b2eb6cb, + 0x3b2eb6cb, + 0x0b6eb6cb, + 0x1b6eb6cb, + 0x2b6eb6cb, + 0x3b6eb6cb, + 0x0baeb6cb, + 0x1baeb6cb, + 0x2baeb6cb, + 0x3baeb6cb, + 0x0beeb6cb, + 0x1beeb6cb, + 0x2beeb6cb, + 0x3beeb6cb, + 0x0b2fb6cb, + 0x1b2fb6cb, + 0x2b2fb6cb, + 0x3b2fb6cb, + 0x0b6fb6cb, + 0x1b6fb6cb, + 0x2b6fb6cb, + 0x3b6fb6cb, + 0x0bafb6cb, + 0x1bafb6cb, + 0x2bafb6cb, + 0x3bafb6cb, + 0x0befb6cb, + 0x1befb6cb, + 0x2befb6cb, + 0x3befb6cb, + 0x0b2cbacb, + 0x1b2cbacb, + 0x2b2cbacb, + 0x3b2cbacb, + 0x0b6cbacb, + 0x1b6cbacb, + 0x2b6cbacb, + 0x3b6cbacb, + 0x0bacbacb, + 0x1bacbacb, + 0x2bacbacb, + 0x3bacbacb, + 0x0becbacb, + 0x1becbacb, + 0x2becbacb, + 0x3becbacb, + 0x0b2dbacb, + 0x1b2dbacb, + 0x2b2dbacb, + 0x3b2dbacb, + 0x0b6dbacb, + 0x1b6dbacb, + 0x2b6dbacb, + 0x3b6dbacb, + 0x0badbacb, + 0x1badbacb, + 0x2badbacb, + 0x3badbacb, + 0x0bedbacb, + 0x1bedbacb, + 0x2bedbacb, + 0x3bedbacb, + 0x0b2ebacb, + 0x1b2ebacb, + 0x2b2ebacb, + 0x3b2ebacb, + 0x0b6ebacb, + 0x1b6ebacb, + 0x2b6ebacb, + 0x3b6ebacb, + 0x0baebacb, + 0x1baebacb, + 0x2baebacb, + 0x3baebacb, + 0x0beebacb, + 0x1beebacb, + 0x2beebacb, + 0x3beebacb, + 0x0b2fbacb, + 0x1b2fbacb, + 0x2b2fbacb, + 0x3b2fbacb, + 0x0b6fbacb, + 0x1b6fbacb, + 0x2b6fbacb, + 0x3b6fbacb, + 0x0bafbacb, + 0x1bafbacb, + 0x2bafbacb, + 0x3bafbacb, + 0x0befbacb, + 0x1befbacb, + 0x2befbacb, + 0x3befbacb, + 0x0b2cbecb, + 0x1b2cbecb, + 0x2b2cbecb, + 0x3b2cbecb, + 0x0b6cbecb, + 0x1b6cbecb, + 0x2b6cbecb, + 0x3b6cbecb, + 0x0bacbecb, + 0x1bacbecb, + 0x2bacbecb, + 0x3bacbecb, + 0x0becbecb, + 0x1becbecb, + 0x2becbecb, + 0x3becbecb, + 0x0b2dbecb, + 0x1b2dbecb, + 0x2b2dbecb, + 0x3b2dbecb, + 0x0b6dbecb, + 0x1b6dbecb, + 0x2b6dbecb, + 0x3b6dbecb, + 0x0badbecb, + 0x1badbecb, + 0x2badbecb, + 0x3badbecb, + 0x0bedbecb, + 0x1bedbecb, + 0x2bedbecb, + 0x3bedbecb, + 0x0b2ebecb, + 0x1b2ebecb, + 0x2b2ebecb, + 0x3b2ebecb, + 0x0b6ebecb, + 0x1b6ebecb, + 0x2b6ebecb, + 0x3b6ebecb, + 0x0baebecb, + 0x1baebecb, + 0x2baebecb, + 0x3baebecb, + 0x0beebecb, + 0x1beebecb, + 0x2beebecb, + 0x3beebecb, + 0x0b2fbecb, + 0x1b2fbecb, + 0x2b2fbecb, + 0x3b2fbecb, + 0x0b6fbecb, + 0x1b6fbecb, + 0x2b6fbecb, + 0x3b6fbecb, + 0x0bafbecb, + 0x1bafbecb, + 0x2bafbecb, + 0x3bafbecb, + 0x0befbecb, + 0x1befbecb, + 0x2befbecb, + 0x3befbecb, + 0x0b2cb2db, + 0x1b2cb2db, + 0x2b2cb2db, + 0x3b2cb2db, + 0x0b6cb2db, + 0x1b6cb2db, + 0x2b6cb2db, + 0x3b6cb2db, + 0x0bacb2db, + 0x1bacb2db, + 0x2bacb2db, + 0x3bacb2db, + 0x0becb2db, + 0x1becb2db, + 0x2becb2db, + 0x3becb2db, + 0x0b2db2db, + 0x1b2db2db, + 0x2b2db2db, + 0x3b2db2db, + 0x0b6db2db, + 0x1b6db2db, + 0x2b6db2db, + 0x3b6db2db, + 0x0badb2db, + 0x1badb2db, + 0x2badb2db, + 0x3badb2db, + 0x0bedb2db, + 0x1bedb2db, + 0x2bedb2db, + 0x3bedb2db, + 0x0b2eb2db, + 0x1b2eb2db, + 0x2b2eb2db, + 0x3b2eb2db, + 0x0b6eb2db, + 0x1b6eb2db, + 0x2b6eb2db, + 0x3b6eb2db, + 0x0baeb2db, + 0x1baeb2db, + 0x2baeb2db, + 0x3baeb2db, + 0x0beeb2db, + 0x1beeb2db, + 0x2beeb2db, + 0x3beeb2db, + 0x0b2fb2db, + 0x1b2fb2db, + 0x2b2fb2db, + 0x3b2fb2db, + 0x0b6fb2db, + 0x1b6fb2db, + 0x2b6fb2db, + 0x3b6fb2db, + 0x0bafb2db, + 0x1bafb2db, + 0x2bafb2db, + 0x3bafb2db, + 0x0befb2db, + 0x1befb2db, + 0x2befb2db, + 0x3befb2db, + 0x0b2cb6db, + 0x1b2cb6db, + 0x2b2cb6db, + 0x3b2cb6db, + 0x0b6cb6db, + 0x1b6cb6db, + 0x2b6cb6db, + 0x3b6cb6db, + 0x0bacb6db, + 0x1bacb6db, + 0x2bacb6db, + 0x3bacb6db, + 0x0becb6db, + 0x1becb6db, + 0x2becb6db, + 0x3becb6db, + 0x0b2db6db, + 0x1b2db6db, + 0x2b2db6db, + 0x3b2db6db, + 0x0b6db6db, + 0x1b6db6db, + 0x2b6db6db, + 0x3b6db6db, + 0x0badb6db, + 0x1badb6db, + 0x2badb6db, + 0x3badb6db, + 0x0bedb6db, + 0x1bedb6db, + 0x2bedb6db, + 0x3bedb6db, + 0x0b2eb6db, + 0x1b2eb6db, + 0x2b2eb6db, + 0x3b2eb6db, + 0x0b6eb6db, + 0x1b6eb6db, + 0x2b6eb6db, + 0x3b6eb6db, + 0x0baeb6db, + 0x1baeb6db, + 0x2baeb6db, + 0x3baeb6db, +} + +var kNonZeroRepsDepth = [BROTLI_NUM_COMMAND_SYMBOLS]uint32{ + 6, + 6, + 6, + 6, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, +} + +var kStaticCommandCodeBits = [BROTLI_NUM_COMMAND_SYMBOLS]uint16{ + 0, + 256, + 128, + 384, + 64, + 320, + 192, + 448, + 32, + 288, + 160, + 416, + 96, + 352, + 224, + 480, + 16, + 272, + 144, + 400, + 80, + 336, + 208, + 464, + 48, + 304, + 176, + 432, + 112, + 368, + 240, + 496, + 8, + 264, + 136, + 392, + 72, + 328, + 200, + 456, + 40, + 296, + 168, + 424, + 104, + 360, + 232, + 488, + 24, + 280, + 152, + 408, + 88, + 344, + 216, + 472, + 56, + 312, + 184, + 440, + 120, + 376, + 248, + 504, + 4, + 260, + 132, + 388, + 68, + 324, + 196, + 452, + 36, + 292, + 164, + 420, + 100, + 356, + 228, + 484, + 20, + 276, + 148, + 404, + 84, + 340, + 212, + 468, + 52, + 308, + 180, + 436, + 116, + 372, + 244, + 500, + 12, + 268, + 140, + 396, + 76, + 332, + 204, + 460, + 44, + 300, + 172, + 428, + 108, + 364, + 236, + 492, + 28, + 284, + 156, + 412, + 92, + 348, + 220, + 476, + 60, + 316, + 188, + 444, + 124, + 380, + 252, + 508, + 2, + 258, + 130, + 386, + 66, + 322, + 194, + 450, + 34, + 290, + 162, + 418, + 98, + 354, + 226, + 482, + 18, + 274, + 146, + 402, + 82, + 338, + 210, + 466, + 50, + 306, + 178, + 434, + 114, + 370, + 242, + 498, + 10, + 266, + 138, + 394, + 74, + 330, + 202, + 458, + 42, + 298, + 170, + 426, + 106, + 362, + 234, + 490, + 26, + 282, + 154, + 410, + 90, + 346, + 218, + 474, + 58, + 314, + 186, + 442, + 122, + 378, + 250, + 506, + 6, + 262, + 134, + 390, + 70, + 326, + 198, + 454, + 38, + 294, + 166, + 422, + 102, + 358, + 230, + 486, + 22, + 278, + 150, + 406, + 86, + 342, + 214, + 470, + 54, + 310, + 182, + 438, + 118, + 374, + 246, + 502, + 14, + 270, + 142, + 398, + 78, + 334, + 206, + 462, + 46, + 302, + 174, + 430, + 110, + 366, + 238, + 494, + 30, + 286, + 158, + 414, + 94, + 350, + 222, + 478, + 62, + 318, + 190, + 446, + 126, + 382, + 254, + 510, + 1, + 257, + 129, + 385, + 65, + 321, + 193, + 449, + 33, + 289, + 161, + 417, + 97, + 353, + 225, + 481, + 17, + 273, + 145, + 401, + 81, + 337, + 209, + 465, + 49, + 305, + 177, + 433, + 113, + 369, + 241, + 497, + 9, + 265, + 137, + 393, + 73, + 329, + 201, + 457, + 41, + 297, + 169, + 425, + 105, + 361, + 233, + 489, + 25, + 281, + 153, + 409, + 89, + 345, + 217, + 473, + 57, + 313, + 185, + 441, + 121, + 377, + 249, + 505, + 5, + 261, + 133, + 389, + 69, + 325, + 197, + 453, + 37, + 293, + 165, + 421, + 101, + 357, + 229, + 485, + 21, + 277, + 149, + 405, + 85, + 341, + 213, + 469, + 53, + 309, + 181, + 437, + 117, + 373, + 245, + 501, + 13, + 269, + 141, + 397, + 77, + 333, + 205, + 461, + 45, + 301, + 173, + 429, + 109, + 365, + 237, + 493, + 29, + 285, + 157, + 413, + 93, + 349, + 221, + 477, + 61, + 317, + 189, + 445, + 125, + 381, + 253, + 509, + 3, + 259, + 131, + 387, + 67, + 323, + 195, + 451, + 35, + 291, + 163, + 419, + 99, + 355, + 227, + 483, + 19, + 275, + 147, + 403, + 83, + 339, + 211, + 467, + 51, + 307, + 179, + 435, + 115, + 371, + 243, + 499, + 11, + 267, + 139, + 395, + 75, + 331, + 203, + 459, + 43, + 299, + 171, + 427, + 107, + 363, + 235, + 491, + 27, + 283, + 155, + 411, + 91, + 347, + 219, + 475, + 59, + 315, + 187, + 443, + 123, + 379, + 251, + 507, + 7, + 1031, + 519, + 1543, + 263, + 1287, + 775, + 1799, + 135, + 1159, + 647, + 1671, + 391, + 1415, + 903, + 1927, + 71, + 1095, + 583, + 1607, + 327, + 1351, + 839, + 1863, + 199, + 1223, + 711, + 1735, + 455, + 1479, + 967, + 1991, + 39, + 1063, + 551, + 1575, + 295, + 1319, + 807, + 1831, + 167, + 1191, + 679, + 1703, + 423, + 1447, + 935, + 1959, + 103, + 1127, + 615, + 1639, + 359, + 1383, + 871, + 1895, + 231, + 1255, + 743, + 1767, + 487, + 1511, + 999, + 2023, + 23, + 1047, + 535, + 1559, + 279, + 1303, + 791, + 1815, + 151, + 1175, + 663, + 1687, + 407, + 1431, + 919, + 1943, + 87, + 1111, + 599, + 1623, + 343, + 1367, + 855, + 1879, + 215, + 1239, + 727, + 1751, + 471, + 1495, + 983, + 2007, + 55, + 1079, + 567, + 1591, + 311, + 1335, + 823, + 1847, + 183, + 1207, + 695, + 1719, + 439, + 1463, + 951, + 1975, + 119, + 1143, + 631, + 1655, + 375, + 1399, + 887, + 1911, + 247, + 1271, + 759, + 1783, + 503, + 1527, + 1015, + 2039, + 15, + 1039, + 527, + 1551, + 271, + 1295, + 783, + 1807, + 143, + 1167, + 655, + 1679, + 399, + 1423, + 911, + 1935, + 79, + 1103, + 591, + 1615, + 335, + 1359, + 847, + 1871, + 207, + 1231, + 719, + 1743, + 463, + 1487, + 975, + 1999, + 47, + 1071, + 559, + 1583, + 303, + 1327, + 815, + 1839, + 175, + 1199, + 687, + 1711, + 431, + 1455, + 943, + 1967, + 111, + 1135, + 623, + 1647, + 367, + 1391, + 879, + 1903, + 239, + 1263, + 751, + 1775, + 495, + 1519, + 1007, + 2031, + 31, + 1055, + 543, + 1567, + 287, + 1311, + 799, + 1823, + 159, + 1183, + 671, + 1695, + 415, + 1439, + 927, + 1951, + 95, + 1119, + 607, + 1631, + 351, + 1375, + 863, + 1887, + 223, + 1247, + 735, + 1759, + 479, + 1503, + 991, + 2015, + 63, + 1087, + 575, + 1599, + 319, + 1343, + 831, + 1855, + 191, + 1215, + 703, + 1727, + 447, + 1471, + 959, + 1983, + 127, + 1151, + 639, + 1663, + 383, + 1407, + 895, + 1919, + 255, + 1279, + 767, + 1791, + 511, + 1535, + 1023, + 2047, +} + +func StoreStaticCommandHuffmanTree(storage_ix *uint, storage []byte) { + BrotliWriteBits(56, 0x92624416307003, storage_ix, storage) + BrotliWriteBits(3, 0x00000000, storage_ix, storage) +} + +var kStaticDistanceCodeBits = [64]uint16{ + 0, + 32, + 16, + 48, + 8, + 40, + 24, + 56, + 4, + 36, + 20, + 52, + 12, + 44, + 28, + 60, + 2, + 34, + 18, + 50, + 10, + 42, + 26, + 58, + 6, + 38, + 22, + 54, + 14, + 46, + 30, + 62, + 1, + 33, + 17, + 49, + 9, + 41, + 25, + 57, + 5, + 37, + 21, + 53, + 13, + 45, + 29, + 61, + 3, + 35, + 19, + 51, + 11, + 43, + 27, + 59, + 7, + 39, + 23, + 55, + 15, + 47, + 31, + 63, +} + +func StoreStaticDistanceHuffmanTree(storage_ix *uint, storage []byte) { + BrotliWriteBits(28, 0x0369DC03, storage_ix, storage) +} diff --git a/fast_log.go b/fast_log.go new file mode 100644 index 0000000..dacd2a4 --- /dev/null +++ b/fast_log.go @@ -0,0 +1,315 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Literal cost model to allow backward reference replacement to be efficient. + */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Literal cost model to allow backward reference replacement to be efficient. + */ + +/* Estimates how many bits the literals in the interval [pos, pos + len) in the + ring-buffer (data, mask) will take entropy coded and writes these estimates + to the cost[0..len) array. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Utilities for fast computation of logarithms. */ +func Log2FloorNonZero(n uint) uint32 { + /* TODO: generalize and move to platform.h */ + var result uint32 = 0 + for { + n >>= 1 + if n == 0 { + break + } + result++ + } + return result +} + +/* A lookup table for small values of log2(int) to be used in entropy + computation. + + ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */ +var kLog2Table = []float32{ + 0.0000000000000000, + 0.0000000000000000, + 1.0000000000000000, + 1.5849625007211563, + 2.0000000000000000, + 2.3219280948873622, + 2.5849625007211561, + 2.8073549220576042, + 3.0000000000000000, + 3.1699250014423126, + 3.3219280948873626, + 3.4594316186372978, + 3.5849625007211565, + 3.7004397181410922, + 3.8073549220576037, + 3.9068905956085187, + 4.0000000000000000, + 4.0874628412503400, + 4.1699250014423122, + 4.2479275134435852, + 4.3219280948873626, + 4.3923174227787607, + 4.4594316186372973, + 4.5235619560570131, + 4.5849625007211570, + 4.6438561897747244, + 4.7004397181410926, + 4.7548875021634691, + 4.8073549220576037, + 4.8579809951275728, + 4.9068905956085187, + 4.9541963103868758, + 5.0000000000000000, + 5.0443941193584534, + 5.0874628412503400, + 5.1292830169449664, + 5.1699250014423122, + 5.2094533656289501, + 5.2479275134435852, + 5.2854022188622487, + 5.3219280948873626, + 5.3575520046180838, + 5.3923174227787607, + 5.4262647547020979, + 5.4594316186372973, + 5.4918530963296748, + 5.5235619560570131, + 5.5545888516776376, + 5.5849625007211570, + 5.6147098441152083, + 5.6438561897747244, + 5.6724253419714961, + 5.7004397181410926, + 5.7279204545631996, + 5.7548875021634691, + 5.7813597135246599, + 5.8073549220576046, + 5.8328900141647422, + 5.8579809951275719, + 5.8826430493618416, + 5.9068905956085187, + 5.9307373375628867, + 5.9541963103868758, + 5.9772799234999168, + 6.0000000000000000, + 6.0223678130284544, + 6.0443941193584534, + 6.0660891904577721, + 6.0874628412503400, + 6.1085244567781700, + 6.1292830169449672, + 6.1497471195046822, + 6.1699250014423122, + 6.1898245588800176, + 6.2094533656289510, + 6.2288186904958804, + 6.2479275134435861, + 6.2667865406949019, + 6.2854022188622487, + 6.3037807481771031, + 6.3219280948873617, + 6.3398500028846252, + 6.3575520046180847, + 6.3750394313469254, + 6.3923174227787598, + 6.4093909361377026, + 6.4262647547020979, + 6.4429434958487288, + 6.4594316186372982, + 6.4757334309663976, + 6.4918530963296748, + 6.5077946401986964, + 6.5235619560570131, + 6.5391588111080319, + 6.5545888516776376, + 6.5698556083309478, + 6.5849625007211561, + 6.5999128421871278, + 6.6147098441152092, + 6.6293566200796095, + 6.6438561897747253, + 6.6582114827517955, + 6.6724253419714952, + 6.6865005271832185, + 6.7004397181410917, + 6.7142455176661224, + 6.7279204545631988, + 6.7414669864011465, + 6.7548875021634691, + 6.7681843247769260, + 6.7813597135246599, + 6.7944158663501062, + 6.8073549220576037, + 6.8201789624151887, + 6.8328900141647422, + 6.8454900509443757, + 6.8579809951275719, + 6.8703647195834048, + 6.8826430493618416, + 6.8948177633079437, + 6.9068905956085187, + 6.9188632372745955, + 6.9307373375628867, + 6.9425145053392399, + 6.9541963103868758, + 6.9657842846620879, + 6.9772799234999168, + 6.9886846867721664, + 7.0000000000000000, + 7.0112272554232540, + 7.0223678130284544, + 7.0334230015374501, + 7.0443941193584534, + 7.0552824355011898, + 7.0660891904577721, + 7.0768155970508317, + 7.0874628412503400, + 7.0980320829605272, + 7.1085244567781700, + 7.1189410727235076, + 7.1292830169449664, + 7.1395513523987937, + 7.1497471195046822, + 7.1598713367783891, + 7.1699250014423130, + 7.1799090900149345, + 7.1898245588800176, + 7.1996723448363644, + 7.2094533656289492, + 7.2191685204621621, + 7.2288186904958804, + 7.2384047393250794, + 7.2479275134435861, + 7.2573878426926521, + 7.2667865406949019, + 7.2761244052742384, + 7.2854022188622487, + 7.2946207488916270, + 7.3037807481771031, + 7.3128829552843557, + 7.3219280948873617, + 7.3309168781146177, + 7.3398500028846243, + 7.3487281542310781, + 7.3575520046180847, + 7.3663222142458151, + 7.3750394313469254, + 7.3837042924740528, + 7.3923174227787607, + 7.4008794362821844, + 7.4093909361377026, + 7.4178525148858991, + 7.4262647547020979, + 7.4346282276367255, + 7.4429434958487288, + 7.4512111118323299, + 7.4594316186372973, + 7.4676055500829976, + 7.4757334309663976, + 7.4838157772642564, + 7.4918530963296748, + 7.4998458870832057, + 7.5077946401986964, + 7.5156998382840436, + 7.5235619560570131, + 7.5313814605163119, + 7.5391588111080319, + 7.5468944598876373, + 7.5545888516776376, + 7.5622424242210728, + 7.5698556083309478, + 7.5774288280357487, + 7.5849625007211561, + 7.5924570372680806, + 7.5999128421871278, + 7.6073303137496113, + 7.6147098441152075, + 7.6220518194563764, + 7.6293566200796095, + 7.6366246205436488, + 7.6438561897747244, + 7.6510516911789290, + 7.6582114827517955, + 7.6653359171851765, + 7.6724253419714952, + 7.6794800995054464, + 7.6865005271832185, + 7.6934869574993252, + 7.7004397181410926, + 7.7073591320808825, + 7.7142455176661224, + 7.7210991887071856, + 7.7279204545631996, + 7.7347096202258392, + 7.7414669864011465, + 7.7481928495894596, + 7.7548875021634691, + 7.7615512324444795, + 7.7681843247769260, + 7.7747870596011737, + 7.7813597135246608, + 7.7879025593914317, + 7.7944158663501062, + 7.8008998999203047, + 7.8073549220576037, + 7.8137811912170374, + 7.8201789624151887, + 7.8265484872909159, + 7.8328900141647422, + 7.8392037880969445, + 7.8454900509443757, + 7.8517490414160571, + 7.8579809951275719, + 7.8641861446542798, + 7.8703647195834048, + 7.8765169465650002, + 7.8826430493618425, + 7.8887432488982601, + 7.8948177633079446, + 7.9008668079807496, + 7.9068905956085187, + 7.9128893362299619, + 7.9188632372745955, + 7.9248125036057813, + 7.9307373375628867, + 7.9366379390025719, + 7.9425145053392399, + 7.9483672315846778, + 7.9541963103868758, + 7.9600019320680806, + 7.9657842846620870, + 7.9715435539507720, + 7.9772799234999168, + 7.9829935746943104, + 7.9886846867721664, + 7.9943534368588578, +} + +const LOG_2_INV = 1.4426950408889634 + +/* Faster logarithm for small integers, with the property of log2(0) == 0. */ +func FastLog2(v uint) float64 { + if v < uint(len(kLog2Table)) { + return float64(kLog2Table[v]) + } + + return log2(float64(v)) +} diff --git a/find_match_length.go b/find_match_length.go new file mode 100644 index 0000000..39228f3 --- /dev/null +++ b/find_match_length.go @@ -0,0 +1,24 @@ +package brotli + +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function to find maximal matching prefixes of strings. */ +func FindMatchLengthWithLimit(s1 []byte, s2 []byte, limit uint) uint { + var matched uint = 0 + for matched < limit && s1[matched] == s2[matched] { + matched++ + } + return matched +} diff --git a/h10.go b/h10.go new file mode 100644 index 0000000..f94ad92 --- /dev/null +++ b/h10.go @@ -0,0 +1,290 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table where each hash bucket contains a binary tree of + sequences whose first 4 bytes share the same hash code. + Each sequence is 128 long and is identified by its starting + position in the input data. The binary tree is sorted by the lexicographic + order of the sequences, and it is also a max-heap with respect to the + starting positions. */ +func HashTypeLengthH10() uint { + return 4 +} + +func StoreLookaheadH10() uint { + return 128 +} + +func HashBytesH10(data []byte) uint32 { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return h >> (32 - 17) +} + +type H10 struct { + window_mask_ uint + buckets_ [1 << 17]uint32 + invalid_pos_ uint32 + forest []uint32 +} + +func SelfH10(handle HasherHandle) *H10 { + return handle.extra.(*H10) +} + +func ForestH10(self *H10) []uint32 { + return []uint32(self.forest) +} + +func InitializeH10(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H10) + var self *H10 = SelfH10(handle) + self.window_mask_ = (1 << params.lgwin) - 1 + self.invalid_pos_ = uint32(0 - self.window_mask_) + var num_nodes uint = uint(1) << params.lgwin + self.forest = make([]uint32, 2*num_nodes) +} + +func PrepareH10(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H10 = SelfH10(handle) + var invalid_pos uint32 = self.invalid_pos_ + var i uint32 + for i = 0; i < 1<<17; i++ { + self.buckets_[i] = invalid_pos + } +} + +func LeftChildIndexH10(self *H10, pos uint) uint { + return 2 * (pos & self.window_mask_) +} + +func RightChildIndexH10(self *H10, pos uint) uint { + return 2*(pos&self.window_mask_) + 1 +} + +/* Stores the hash of the next 4 bytes and in a single tree-traversal, the + hash bucket's binary tree is searched for matches and is re-rooted at the + current position. + + If less than 128 data is available, the hash bucket of the + current position is searched for matches, but the state of the hash table + is not changed, since we can not know the final sorting order of the + current (incomplete) sequence. + + This function must be called with increasing cur_ix positions. */ +func StoreAndFindMatchesH10(self *H10, data []byte, cur_ix uint, ring_buffer_mask uint, max_length uint, max_backward uint, best_len *uint, matches []BackwardMatch) []BackwardMatch { + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var max_comp_len uint = brotli_min_size_t(max_length, 128) + var should_reroot_tree bool = (max_length >= 128) + var key uint32 = HashBytesH10(data[cur_ix_masked:]) + var forest []uint32 = ForestH10(self) + var prev_ix uint = uint(self.buckets_[key]) + var node_left uint = LeftChildIndexH10(self, cur_ix) + var node_right uint = RightChildIndexH10(self, cur_ix) + var best_len_left uint = 0 + var best_len_right uint = 0 + var depth_remaining uint + /* The forest index of the rightmost node of the left subtree of the new + root, updated as we traverse and re-root the tree of the hash bucket. */ + + /* The forest index of the leftmost node of the right subtree of the new + root, updated as we traverse and re-root the tree of the hash bucket. */ + + /* The match length of the rightmost node of the left subtree of the new + root, updated as we traverse and re-root the tree of the hash bucket. */ + + /* The match length of the leftmost node of the right subtree of the new + root, updated as we traverse and re-root the tree of the hash bucket. */ + if should_reroot_tree { + self.buckets_[key] = uint32(cur_ix) + } + + for depth_remaining = 64; ; depth_remaining-- { + var backward uint = cur_ix - prev_ix + var prev_ix_masked uint = prev_ix & ring_buffer_mask + if backward == 0 || backward > max_backward || depth_remaining == 0 { + if should_reroot_tree { + forest[node_left] = self.invalid_pos_ + forest[node_right] = self.invalid_pos_ + } + + break + } + { + var cur_len uint = brotli_min_size_t(best_len_left, best_len_right) + var len uint + assert(cur_len <= 128) + len = cur_len + FindMatchLengthWithLimit(data[cur_ix_masked+cur_len:], data[prev_ix_masked+cur_len:], max_length-cur_len) + if matches != nil && len > *best_len { + *best_len = uint(len) + InitBackwardMatch(&matches[0], backward, uint(len)) + matches = matches[1:] + } + + if len >= max_comp_len { + if should_reroot_tree { + forest[node_left] = forest[LeftChildIndexH10(self, prev_ix)] + forest[node_right] = forest[RightChildIndexH10(self, prev_ix)] + } + + break + } + + if data[cur_ix_masked+len] > data[prev_ix_masked+len] { + best_len_left = uint(len) + if should_reroot_tree { + forest[node_left] = uint32(prev_ix) + } + + node_left = RightChildIndexH10(self, prev_ix) + prev_ix = uint(forest[node_left]) + } else { + best_len_right = uint(len) + if should_reroot_tree { + forest[node_right] = uint32(prev_ix) + } + + node_right = LeftChildIndexH10(self, prev_ix) + prev_ix = uint(forest[node_right]) + } + } + } + + return matches +} + +/* Finds all backward matches of &data[cur_ix & ring_buffer_mask] up to the + length of max_length and stores the position cur_ix in the hash table. + + Sets *num_matches to the number of matches found, and stores the found + matches in matches[0] to matches[*num_matches - 1]. The matches will be + sorted by strictly increasing length and (non-strictly) increasing + distance. */ +func FindAllMatchesH10(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, cur_ix uint, max_length uint, max_backward uint, gap uint, params *BrotliEncoderParams, matches []BackwardMatch) uint { + var orig_matches []BackwardMatch = matches + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var best_len uint = 1 + var short_match_max_backward uint + if params.quality != HQ_ZOPFLIFICATION_QUALITY { + short_match_max_backward = 16 + } else { + short_match_max_backward = 64 + } + var stop uint = cur_ix - short_match_max_backward + var dict_matches [BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1]uint32 + var i uint + if cur_ix < short_match_max_backward { + stop = 0 + } + for i = cur_ix - 1; i > stop && best_len <= 2; i-- { + var prev_ix uint = i + var backward uint = cur_ix - prev_ix + if backward > max_backward { + break + } + + prev_ix &= ring_buffer_mask + if data[cur_ix_masked] != data[prev_ix] || data[cur_ix_masked+1] != data[prev_ix+1] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len > best_len { + best_len = uint(len) + InitBackwardMatch(&matches[0], backward, uint(len)) + matches = matches[1:] + } + } + } + + if best_len < max_length { + matches = StoreAndFindMatchesH10(SelfH10(handle), data, cur_ix, ring_buffer_mask, max_length, max_backward, &best_len, matches) + } + + for i = 0; i <= BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN; i++ { + dict_matches[i] = kInvalidMatch + } + { + var minlen uint = brotli_max_size_t(4, best_len+1) + if BrotliFindAllStaticDictionaryMatches(dictionary, data[cur_ix_masked:], minlen, max_length, dict_matches[0:]) { + var maxlen uint = brotli_min_size_t(BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN, max_length) + var l uint + for l = minlen; l <= maxlen; l++ { + var dict_id uint32 = dict_matches[l] + if dict_id < kInvalidMatch { + var distance uint = max_backward + gap + uint(dict_id>>5) + 1 + if distance <= params.dist.max_distance { + InitDictionaryBackwardMatch(&matches[0], distance, l, uint(dict_id&31)) + matches = matches[1:] + } + } + } + } + } + + return uint(-cap(matches) + cap(orig_matches)) +} + +/* Stores the hash of the next 4 bytes and re-roots the binary tree at the + current sequence, without returning any matches. + REQUIRES: ix + 128 <= end-of-current-block */ +func StoreH10(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H10 = SelfH10(handle) + var max_backward uint = self.window_mask_ - BROTLI_WINDOW_GAP + 1 + /* Maximum distance is window size - 16, see section 9.1. of the spec. */ + StoreAndFindMatchesH10(self, data, ix, mask, 128, max_backward, nil, nil) +} + +func StoreRangeH10(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint = ix_start + var j uint = ix_start + if ix_start+63 <= ix_end { + i = ix_end - 63 + } + + if ix_start+512 <= i { + for ; j < i; j += 8 { + StoreH10(handle, data, mask, j) + } + } + + for ; i < ix_end; i++ { + StoreH10(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH10(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint) { + var self *H10 = SelfH10(handle) + if num_bytes >= HashTypeLengthH10()-1 && position >= 128 { + var i_start uint = position - 128 + 1 + var i_end uint = brotli_min_size_t(position, i_start+num_bytes) + /* Store the last `128 - 1` positions in the hasher. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + + var i uint + for i = i_start; i < i_end; i++ { + /* Maximum distance is window size - 16, see section 9.1. of the spec. + Furthermore, we have to make sure that we don't look further back + from the start of the next block than the window size, otherwise we + could access already overwritten areas of the ring-buffer. */ + var max_backward uint = self.window_mask_ - brotli_max_size_t(BROTLI_WINDOW_GAP-1, position-i) + + /* We know that i + 128 <= position + num_bytes, i.e. the + end of the current block and that we have at least + 128 tail in the ring-buffer. */ + StoreAndFindMatchesH10(self, ringbuffer, i, ringbuffer_mask, 128, max_backward, nil, nil) + } + } +} + +/* MAX_NUM_MATCHES == 64 + MAX_TREE_SEARCH_DEPTH */ +const MAX_NUM_MATCHES_H10 = 128 diff --git a/h2.go b/h2.go new file mode 100644 index 0000000..e5f09d6 --- /dev/null +++ b/h2.go @@ -0,0 +1,211 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* For BUCKET_SWEEP == 1, enabling the dictionary lookup makes compression + a little faster (0.5% - 1%) and it compresses 0.15% better on small text + and HTML inputs. */ +func HashTypeLengthH2() uint { + return 8 +} + +func StoreLookaheadH2() uint { + return 8 +} + +/* HashBytes is the function that chooses the bucket to place + the address in. The HashLongestMatch and H2 + classes have separate, different implementations of hashing. */ +func HashBytesH2(data []byte) uint32 { + var h uint64 = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8*5)) * kHashMul64) + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> (64 - 16)) +} + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size (1 << 16). Starting from the + given index, 1 buckets are used to store values of a key. */ +type H2 struct { + buckets_ [(1 << 16) + 1]uint32 +} + +func SelfH2(handle HasherHandle) *H2 { + return handle.extra.(*H2) +} + +func InitializeH2(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H2) +} + +func PrepareH2(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H2 = SelfH2(handle) + var partial_prepare_threshold uint = (4 << 16) >> 7 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH2(data[i:]) + self.buckets_[key] = 0 + } + } else { + /* It is not strictly necessary to fill this buffer here, but + not filling will make the results of the compression stochastic + (but correct). This is because random data would cause the + system to find accidentally good backward references here and there. */ + var i int + for i = 0; i < len(self.buckets_); i++ { + self.buckets_[i] = 0 + } + } +} + +/* Look at 5 bytes at &data[ix & mask]. + Compute a hash from these, and store the value somewhere within + [ix .. ix+3]. */ +func StoreH2(handle HasherHandle, data []byte, mask uint, ix uint) { + var key uint32 = HashBytesH2(data[ix&mask:]) + var off uint32 = uint32(ix>>3) % 1 + /* Wiggle the value with the bucket sweep range. */ + SelfH2(handle).buckets_[key+off] = uint32(ix) +} + +func StoreRangeH2(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH2(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH2(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint) { + if num_bytes >= HashTypeLengthH2()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH2(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH2(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH2(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH2(handle HasherHandle, distance_cache []int) { +} + +/* Find a longest backward match of &data[cur_ix & ring_buffer_mask] + up to the length of max_length and stores the position cur_ix in the + hash table. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH2(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H2 = SelfH2(handle) + var best_len_in uint = out.len + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var key uint32 = HashBytesH2(data[cur_ix_masked:]) + var compare_char int = int(data[cur_ix_masked+best_len_in]) + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = best_len_in + var cached_backward uint = uint(distance_cache[0]) + var prev_ix uint = cur_ix - cached_backward + var bucket []uint32 + out.len_code_delta = 0 + if prev_ix < cur_ix { + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char == int(data[prev_ix+best_len]) { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = uint(len) + out.distance = cached_backward + out.score = best_score + compare_char = int(data[cur_ix_masked+best_len]) + if 1 == 1 { + self.buckets_[key] = uint32(cur_ix) + return + } + } + } + } + } + + if 1 == 1 { + var backward uint + var len uint + + /* Only one to look for, don't bother to prepare for a loop. */ + prev_ix = uint(self.buckets_[key]) + + self.buckets_[key] = uint32(cur_ix) + backward = cur_ix - prev_ix + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len_in]) { + return + } + + if backward == 0 || backward > max_backward { + return + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + out.len = uint(len) + out.distance = backward + out.score = score + return + } + } + } else { + bucket = self.buckets_[key:] + var i int + prev_ix = uint(bucket[0]) + bucket = bucket[1:] + for i = 0; i < 1; (func() { i++; tmp3 := bucket; bucket = bucket[1:]; prev_ix = uint(tmp3[0]) })() { + var backward uint = cur_ix - prev_ix + var len uint + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len]) { + continue + } + + if backward == 0 || backward > max_backward { + continue + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = score + compare_char = int(data[cur_ix_masked+best_len]) + } + } + } + } + + if min_score == out.score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, true) + } + + self.buckets_[key+uint32((cur_ix>>3)%1)] = uint32(cur_ix) +} diff --git a/h3.go b/h3.go new file mode 100644 index 0000000..92e3ed1 --- /dev/null +++ b/h3.go @@ -0,0 +1,204 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func HashTypeLengthH3() uint { + return 8 +} + +func StoreLookaheadH3() uint { + return 8 +} + +/* HashBytes is the function that chooses the bucket to place + the address in. The HashLongestMatch and H3 + classes have separate, different implementations of hashing. */ +func HashBytesH3(data []byte) uint32 { + var h uint64 = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8*5)) * kHashMul64) + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> (64 - 16)) +} + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size (BUCKET_SIZE). Starting from the + given index, 2 buckets are used to store values of a key. */ +type H3 struct { + buckets_ [(1 << 16) + 2]uint32 +} + +func SelfH3(handle HasherHandle) *H3 { + return handle.extra.(*H3) +} + +func InitializeH3(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H3) +} + +func PrepareH3(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H3 = SelfH3(handle) + var partial_prepare_threshold uint = (4 << 16) >> 7 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH3(data[i:]) + for i := 0; i < int(2); i++ { + self.buckets_[key:][i] = 0 + } + } + } else { + /* It is not strictly necessary to fill this buffer here, but + not filling will make the results of the compression stochastic + (but correct). This is because random data would cause the + system to find accidentally good backward references here and there. */ + var i int + for i = 0; i < len(self.buckets_); i++ { + self.buckets_[i] = 0 + } + } +} + +/* Look at 5 bytes at &data[ix & mask]. + Compute a hash from these, and store the value somewhere within + [ix .. ix+3]. */ +func StoreH3(handle HasherHandle, data []byte, mask uint, ix uint) { + var key uint32 = HashBytesH3(data[ix&mask:]) + var off uint32 = uint32(ix>>3) % 2 + /* Wiggle the value with the bucket sweep range. */ + SelfH3(handle).buckets_[key+off] = uint32(ix) +} + +func StoreRangeH3(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH3(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH3(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint) { + if num_bytes >= HashTypeLengthH3()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH3(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH3(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH3(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH3(handle HasherHandle, distance_cache []int) { +} + +/* Find a longest backward match of &data[cur_ix & ring_buffer_mask] + up to the length of max_length and stores the position cur_ix in the + hash table. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH3(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H3 = SelfH3(handle) + var best_len_in uint = out.len + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var key uint32 = HashBytesH3(data[cur_ix_masked:]) + var compare_char int = int(data[cur_ix_masked+best_len_in]) + var best_score uint = out.score + var best_len uint = best_len_in + var cached_backward uint = uint(distance_cache[0]) + var prev_ix uint = cur_ix - cached_backward + var bucket []uint32 + out.len_code_delta = 0 + if prev_ix < cur_ix { + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char == int(data[prev_ix+best_len]) { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = uint(len) + out.distance = cached_backward + out.score = best_score + compare_char = int(data[cur_ix_masked+best_len]) + if 2 == 1 { + self.buckets_[key] = uint32(cur_ix) + return + } + } + } + } + } + + if 2 == 1 { + var backward uint + var len uint + + /* Only one to look for, don't bother to prepare for a loop. */ + prev_ix = uint(self.buckets_[key]) + + self.buckets_[key] = uint32(cur_ix) + backward = cur_ix - prev_ix + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len_in]) { + return + } + + if backward == 0 || backward > max_backward { + return + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + out.len = uint(len) + out.distance = backward + out.score = score + return + } + } + } else { + bucket = self.buckets_[key:] + var i int + prev_ix = uint(bucket[0]) + bucket = bucket[1:] + for i = 0; i < 2; (func() { i++; tmp4 := bucket; bucket = bucket[1:]; prev_ix = uint(tmp4[0]) })() { + var backward uint = cur_ix - prev_ix + var len uint + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len]) { + continue + } + + if backward == 0 || backward > max_backward { + continue + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = score + compare_char = int(data[cur_ix_masked+best_len]) + } + } + } + } + + self.buckets_[key+uint32((cur_ix>>3)%2)] = uint32(cur_ix) +} diff --git a/h35.go b/h35.go new file mode 100644 index 0000000..85672e2 --- /dev/null +++ b/h35.go @@ -0,0 +1,111 @@ +package brotli + +/* NOTE: this hasher does not search in the dictionary. It is used as + backup-hasher, the main hasher already searches in it. */ +/* NOLINT(build/header_guard) */ +/* Copyright 2018 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A + and HASHER_B. */ +func HashTypeLengthH35() uint { + var a uint = HashTypeLengthH3() + var b uint = HashTypeLengthHROLLING_FAST() + if a > b { + return a + } else { + return b + } +} + +func StoreLookaheadH35() uint { + var a uint = StoreLookaheadH3() + var b uint = StoreLookaheadHROLLING_FAST() + if a > b { + return a + } else { + return b + } +} + +type H35 struct { + ha HasherHandle + hb HasherHandle + params *BrotliEncoderParams +} + +func SelfH35(handle HasherHandle) *H35 { + return handle.extra.(*H35) +} + +func InitializeH35(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H35) + var self *H35 = SelfH35(handle) + self.ha = nil + self.hb = nil + self.params = params +} + +/* TODO: Initialize of the hashers is defered to Prepare (and params + remembered here) because we don't get the one_shot and input_size params + here that are needed to know the memory size of them. Instead provide + those params to all hashers InitializeH35 */ +func PrepareH35(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H35 = SelfH35(handle) + if self.ha == nil { + var common_a *HasherCommon + var common_b *HasherCommon + + self.ha = new(HasherCommon) + common_a = (*HasherCommon)(self.ha) + common_a.params = self.params.hasher + common_a.is_prepared_ = false + common_a.dict_num_lookups = 0 + common_a.dict_num_matches = 0 + InitializeH3(self.ha, self.params) + + self.hb = new(HasherCommon) + common_b = (*HasherCommon)(self.hb) + common_b.params = self.params.hasher + common_b.is_prepared_ = false + common_b.dict_num_lookups = 0 + common_b.dict_num_matches = 0 + InitializeHROLLING_FAST(self.hb, self.params) + } + + PrepareH3(self.ha, one_shot, input_size, data) + PrepareHROLLING_FAST(self.hb, one_shot, input_size, data) +} + +func StoreH35(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H35 = SelfH35(handle) + StoreH3(self.ha, data, mask, ix) + StoreHROLLING_FAST(self.hb, data, mask, ix) +} + +func StoreRangeH35(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var self *H35 = SelfH35(handle) + StoreRangeH3(self.ha, data, mask, ix_start, ix_end) + StoreRangeHROLLING_FAST(self.hb, data, mask, ix_start, ix_end) +} + +func StitchToPreviousBlockH35(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + var self *H35 = SelfH35(handle) + StitchToPreviousBlockH3(self.ha, num_bytes, position, ringbuffer, ring_buffer_mask) + StitchToPreviousBlockHROLLING_FAST(self.hb, num_bytes, position, ringbuffer, ring_buffer_mask) +} + +func PrepareDistanceCacheH35(handle HasherHandle, distance_cache []int) { + var self *H35 = SelfH35(handle) + PrepareDistanceCacheH3(self.ha, distance_cache) + PrepareDistanceCacheHROLLING_FAST(self.hb, &distance_cache[0]) +} + +func FindLongestMatchH35(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H35 = SelfH35(handle) + FindLongestMatchH3(self.ha, dictionary, data, ring_buffer_mask, distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out) + FindLongestMatchHROLLING_FAST(self.hb, dictionary, data, ring_buffer_mask, &distance_cache[0], cur_ix, max_length, max_backward, gap, max_distance, out) +} diff --git a/h4.go b/h4.go new file mode 100644 index 0000000..2a9fded --- /dev/null +++ b/h4.go @@ -0,0 +1,209 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func HashTypeLengthH4() uint { + return 8 +} + +func StoreLookaheadH4() uint { + return 8 +} + +/* HashBytes is the function that chooses the bucket to place + the address in. The HashLongestMatch and H4 + classes have separate, different implementations of hashing. */ +func HashBytesH4(data []byte) uint32 { + var h uint64 = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8*5)) * kHashMul64) + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> (64 - 17)) +} + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size (BUCKET_SIZE). Starting from the + given index, 4 buckets are used to store values of a key. */ +type H4 struct { + buckets_ [(1 << 17) + 4]uint32 +} + +func SelfH4(handle HasherHandle) *H4 { + return handle.extra.(*H4) +} + +func InitializeH4(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H4) +} + +func PrepareH4(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H4 = SelfH4(handle) + var partial_prepare_threshold uint = (4 << 17) >> 7 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH4(data[i:]) + for i := 0; i < int(4); i++ { + self.buckets_[key:][i] = 0 + } + } + } else { + /* It is not strictly necessary to fill this buffer here, but + not filling will make the results of the compression stochastic + (but correct). This is because random data would cause the + system to find accidentally good backward references here and there. */ + var i int + for i = 0; i < len(self.buckets_); i++ { + self.buckets_[i] = 0 + } + } +} + +/* Look at 5 bytes at &data[ix & mask]. + Compute a hash from these, and store the value somewhere within + [ix .. ix+3]. */ +func StoreH4(handle HasherHandle, data []byte, mask uint, ix uint) { + var key uint32 = HashBytesH4(data[ix&mask:]) + var off uint32 = uint32(ix>>3) % 4 + /* Wiggle the value with the bucket sweep range. */ + SelfH4(handle).buckets_[key+off] = uint32(ix) +} + +func StoreRangeH4(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH4(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH4(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint) { + if num_bytes >= HashTypeLengthH4()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH4(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH4(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH4(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH4(handle HasherHandle, distance_cache []int) { +} + +/* Find a longest backward match of &data[cur_ix & ring_buffer_mask] + up to the length of max_length and stores the position cur_ix in the + hash table. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH4(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H4 = SelfH4(handle) + var best_len_in uint = out.len + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var key uint32 = HashBytesH4(data[cur_ix_masked:]) + var compare_char int = int(data[cur_ix_masked+best_len_in]) + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = best_len_in + var cached_backward uint = uint(distance_cache[0]) + var prev_ix uint = cur_ix - cached_backward + var bucket []uint32 + out.len_code_delta = 0 + if prev_ix < cur_ix { + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char == int(data[prev_ix+best_len]) { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = uint(len) + out.distance = cached_backward + out.score = best_score + compare_char = int(data[cur_ix_masked+best_len]) + if 4 == 1 { + self.buckets_[key] = uint32(cur_ix) + return + } + } + } + } + } + + if 4 == 1 { + var backward uint + var len uint + + /* Only one to look for, don't bother to prepare for a loop. */ + prev_ix = uint(self.buckets_[key]) + + self.buckets_[key] = uint32(cur_ix) + backward = cur_ix - prev_ix + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len_in]) { + return + } + + if backward == 0 || backward > max_backward { + return + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + out.len = uint(len) + out.distance = backward + out.score = score + return + } + } + } else { + bucket = self.buckets_[key:] + var i int + prev_ix = uint(bucket[0]) + bucket = bucket[1:] + for i = 0; i < 4; (func() { i++; tmp5 := bucket; bucket = bucket[1:]; prev_ix = uint(tmp5[0]) })() { + var backward uint = cur_ix - prev_ix + var len uint + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len]) { + continue + } + + if backward == 0 || backward > max_backward { + continue + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = score + compare_char = int(data[cur_ix_masked+best_len]) + } + } + } + } + + if min_score == out.score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, true) + } + + self.buckets_[key+uint32((cur_ix>>3)%4)] = uint32(cur_ix) +} diff --git a/h40.go b/h40.go new file mode 100644 index 0000000..d858a78 --- /dev/null +++ b/h40.go @@ -0,0 +1,245 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + Hashes are stored in chains which are bucketed to groups. Group of chains + share a storage "bank". When more than "bank size" chain nodes are added, + oldest nodes are replaced; this way several chains may share a tail. */ +func HashTypeLengthH40() uint { + return 4 +} + +func StoreLookaheadH40() uint { + return 4 +} + +/* HashBytes is the function that chooses the bucket to place the address in.*/ +func HashBytesH40(data []byte) uint { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint(h >> (32 - 15)) +} + +type SlotH40 struct { + delta uint16 + next uint16 +} + +type BankH40 struct { + slots [1 << 16]SlotH40 +} + +type H40 struct { + addr [1 << 15]uint32 + head [1 << 15]uint16 + tiny_hash [65536]byte + banks [1]BankH40 + free_slot_idx [1]uint16 + max_hops uint +} + +func SelfH40(handle HasherHandle) *H40 { + return handle.extra.(*H40) +} + +func InitializeH40(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H40) + var q uint + if params.quality > 6 { + q = 7 + } else { + q = 8 + } + SelfH40(handle).max_hops = q << uint(params.quality-4) +} + +func PrepareH40(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H40 = SelfH40(handle) + var partial_prepare_threshold uint = (1 << 15) >> 6 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var bucket uint = HashBytesH40(data[i:]) + + /* See InitEmpty comment. */ + self.addr[bucket] = 0xCCCCCCCC + + self.head[bucket] = 0xCCCC + } + } else { + /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position + processed by hasher never reaches 3GB + 64M; this makes all new chains + to be terminated after the first node. */ + var i int + for i = 0; i < len(self.addr); i++ { + self.addr[i] = 0xCCCCCCCC + } + + self.head = [1 << 15]uint16{} + } + + self.tiny_hash = [65536]byte{} + self.free_slot_idx = [1]uint16{} +} + +/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend + node to corresponding chain; also update tiny_hash for current position. */ +func StoreH40(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H40 = SelfH40(handle) + var key uint = HashBytesH40(data[ix&mask:]) + var bank uint = key & (1 - 1) + var idx uint + idx = uint(self.free_slot_idx[bank]) & ((1 << 16) - 1) + self.free_slot_idx[bank]++ + var delta uint = ix - uint(self.addr[key]) + self.tiny_hash[uint16(ix)] = byte(key) + if delta > 0xFFFF { + delta = 0xFFFF + } + self.banks[bank].slots[idx].delta = uint16(delta) + self.banks[bank].slots[idx].next = self.head[key] + self.addr[key] = uint32(ix) + self.head[key] = uint16(idx) +} + +func StoreRangeH40(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH40(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH40(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + if num_bytes >= HashTypeLengthH40()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH40(handle, ringbuffer, ring_buffer_mask, position-3) + + StoreH40(handle, ringbuffer, ring_buffer_mask, position-2) + StoreH40(handle, ringbuffer, ring_buffer_mask, position-1) + } +} + +func PrepareDistanceCacheH40(handle HasherHandle, distance_cache []int) { + PrepareDistanceCache(distance_cache, 4) +} + +/* Find a longest backward match of &data[cur_ix] up to the length of + max_length and stores the position cur_ix in the hash table. + + REQUIRES: PrepareDistanceCacheH40 must be invoked for current distance cache + values; if this method is invoked repeatedly with the same distance + cache values, it is enough to invoke PrepareDistanceCacheH40 once. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH40(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H40 = SelfH40(handle) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = out.len + var i uint + var key uint = HashBytesH40(data[cur_ix_masked:]) + var tiny_hash byte = byte(key) + /* Don't accept a short copy from far away. */ + out.len = 0 + + out.len_code_delta = 0 + + /* Try last distance first. */ + for i = 0; i < 4; i++ { + var backward uint = uint(distance_cache[i]) + var prev_ix uint = (cur_ix - backward) + + /* For distance code 0 we want to consider 2-byte matches. */ + if i > 0 && self.tiny_hash[uint16(prev_ix)] != tiny_hash { + continue + } + if prev_ix >= cur_ix || backward > max_backward { + continue + } + + prev_ix &= ring_buffer_mask + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 2 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + if i != 0 { + score -= BackwardReferencePenaltyUsingLastDistance(i) + } + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + } + { + var bank uint = key & (1 - 1) + var backward uint = 0 + var hops uint = self.max_hops + var delta uint = cur_ix - uint(self.addr[key]) + var slot uint = uint(self.head[key]) + for { + tmp6 := hops + hops-- + if tmp6 == 0 { + break + } + var prev_ix uint + var last uint = slot + backward += delta + if backward > max_backward { + break + } + prev_ix = (cur_ix - backward) & ring_buffer_mask + slot = uint(self.banks[bank].slots[last].next) + delta = uint(self.banks[bank].slots[last].delta) + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + /* Comparing for >= 3 does not change the semantics, but just saves + for a few unnecessary binary logarithms in backward reference + score, since we are not interested in such short matches. */ + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + + StoreH40(handle, data, ring_buffer_mask, cur_ix) + } + + if out.score == min_score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, false) + } +} diff --git a/h41.go b/h41.go new file mode 100644 index 0000000..f57740c --- /dev/null +++ b/h41.go @@ -0,0 +1,245 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + Hashes are stored in chains which are bucketed to groups. Group of chains + share a storage "bank". When more than "bank size" chain nodes are added, + oldest nodes are replaced; this way several chains may share a tail. */ +func HashTypeLengthH41() uint { + return 4 +} + +func StoreLookaheadH41() uint { + return 4 +} + +/* HashBytes is the function that chooses the bucket to place the address in.*/ +func HashBytesH41(data []byte) uint { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint(h >> (32 - 15)) +} + +type SlotH41 struct { + delta uint16 + next uint16 +} + +type BankH41 struct { + slots [1 << 16]SlotH41 +} + +type H41 struct { + addr [1 << 15]uint32 + head [1 << 15]uint16 + tiny_hash [65536]byte + banks [1]BankH41 + free_slot_idx [1]uint16 + max_hops uint +} + +func SelfH41(handle HasherHandle) *H41 { + return handle.extra.(*H41) +} + +func InitializeH41(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H41) + var tmp uint + if params.quality > 6 { + tmp = 7 + } else { + tmp = 8 + } + SelfH41(handle).max_hops = tmp << uint(params.quality-4) +} + +func PrepareH41(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H41 = SelfH41(handle) + var partial_prepare_threshold uint = (1 << 15) >> 6 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var bucket uint = HashBytesH41(data[i:]) + + /* See InitEmpty comment. */ + self.addr[bucket] = 0xCCCCCCCC + + self.head[bucket] = 0xCCCC + } + } else { + /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position + processed by hasher never reaches 3GB + 64M; this makes all new chains + to be terminated after the first node. */ + var i int + for i = 0; i < len(self.addr); i++ { + self.addr[i] = 0xCCCCCCCC + } + + self.head = [1 << 15]uint16{} + } + + self.tiny_hash = [65536]byte{} + self.free_slot_idx = [1]uint16{} +} + +/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend + node to corresponding chain; also update tiny_hash for current position. */ +func StoreH41(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H41 = SelfH41(handle) + var key uint = HashBytesH41(data[ix&mask:]) + var bank uint = key & (1 - 1) + var idx uint + idx = uint(self.free_slot_idx[bank]) & ((1 << 16) - 1) + self.free_slot_idx[bank]++ + var delta uint = ix - uint(self.addr[key]) + self.tiny_hash[uint16(ix)] = byte(key) + if delta > 0xFFFF { + delta = 0xFFFF + } + self.banks[bank].slots[idx].delta = uint16(delta) + self.banks[bank].slots[idx].next = self.head[key] + self.addr[key] = uint32(ix) + self.head[key] = uint16(idx) +} + +func StoreRangeH41(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH41(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH41(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + if num_bytes >= HashTypeLengthH41()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH41(handle, ringbuffer, ring_buffer_mask, position-3) + + StoreH41(handle, ringbuffer, ring_buffer_mask, position-2) + StoreH41(handle, ringbuffer, ring_buffer_mask, position-1) + } +} + +func PrepareDistanceCacheH41(handle HasherHandle, distance_cache []int) { + PrepareDistanceCache(distance_cache, 10) +} + +/* Find a longest backward match of &data[cur_ix] up to the length of + max_length and stores the position cur_ix in the hash table. + + REQUIRES: PrepareDistanceCacheH41 must be invoked for current distance cache + values; if this method is invoked repeatedly with the same distance + cache values, it is enough to invoke PrepareDistanceCacheH41 once. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH41(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H41 = SelfH41(handle) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = out.len + var i uint + var key uint = HashBytesH41(data[cur_ix_masked:]) + var tiny_hash byte = byte(key) + /* Don't accept a short copy from far away. */ + out.len = 0 + + out.len_code_delta = 0 + + /* Try last distance first. */ + for i = 0; i < 10; i++ { + var backward uint = uint(distance_cache[i]) + var prev_ix uint = (cur_ix - backward) + + /* For distance code 0 we want to consider 2-byte matches. */ + if i > 0 && self.tiny_hash[uint16(prev_ix)] != tiny_hash { + continue + } + if prev_ix >= cur_ix || backward > max_backward { + continue + } + + prev_ix &= ring_buffer_mask + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 2 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + if i != 0 { + score -= BackwardReferencePenaltyUsingLastDistance(i) + } + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + } + { + var bank uint = key & (1 - 1) + var backward uint = 0 + var hops uint = self.max_hops + var delta uint = cur_ix - uint(self.addr[key]) + var slot uint = uint(self.head[key]) + for { + tmp7 := hops + hops-- + if tmp7 == 0 { + break + } + var prev_ix uint + var last uint = slot + backward += delta + if backward > max_backward { + break + } + prev_ix = (cur_ix - backward) & ring_buffer_mask + slot = uint(self.banks[bank].slots[last].next) + delta = uint(self.banks[bank].slots[last].delta) + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + /* Comparing for >= 3 does not change the semantics, but just saves + for a few unnecessary binary logarithms in backward reference + score, since we are not interested in such short matches. */ + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + + StoreH41(handle, data, ring_buffer_mask, cur_ix) + } + + if out.score == min_score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, false) + } +} diff --git a/h42.go b/h42.go new file mode 100644 index 0000000..54c91a6 --- /dev/null +++ b/h42.go @@ -0,0 +1,245 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + Hashes are stored in chains which are bucketed to groups. Group of chains + share a storage "bank". When more than "bank size" chain nodes are added, + oldest nodes are replaced; this way several chains may share a tail. */ +func HashTypeLengthH42() uint { + return 4 +} + +func StoreLookaheadH42() uint { + return 4 +} + +/* HashBytes is the function that chooses the bucket to place the address in.*/ +func HashBytesH42(data []byte) uint { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint(h >> (32 - 15)) +} + +type SlotH42 struct { + delta uint16 + next uint16 +} + +type BankH42 struct { + slots [1 << 9]SlotH42 +} + +type H42 struct { + addr [1 << 15]uint32 + head [1 << 15]uint16 + tiny_hash [65536]byte + banks [512]BankH42 + free_slot_idx [512]uint16 + max_hops uint +} + +func SelfH42(handle HasherHandle) *H42 { + return handle.extra.(*H42) +} + +func InitializeH42(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H42) + var tmp uint + if params.quality > 6 { + tmp = 7 + } else { + tmp = 8 + } + SelfH42(handle).max_hops = tmp << uint(params.quality-4) +} + +func PrepareH42(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H42 = SelfH42(handle) + var partial_prepare_threshold uint = (1 << 15) >> 6 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var bucket uint = HashBytesH42(data[i:]) + + /* See InitEmpty comment. */ + self.addr[bucket] = 0xCCCCCCCC + + self.head[bucket] = 0xCCCC + } + } else { + /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position + processed by hasher never reaches 3GB + 64M; this makes all new chains + to be terminated after the first node. */ + var i int + for i = 0; i < len(self.addr); i++ { + self.addr[i] = 0xCCCCCCCC + } + + self.head = [1 << 15]uint16{} + } + + self.tiny_hash = [65536]byte{} + self.free_slot_idx = [512]uint16{} +} + +/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend + node to corresponding chain; also update tiny_hash for current position. */ +func StoreH42(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H42 = SelfH42(handle) + var key uint = HashBytesH42(data[ix&mask:]) + var bank uint = key & (512 - 1) + var idx uint + idx = uint(self.free_slot_idx[bank]) & ((1 << 9) - 1) + self.free_slot_idx[bank]++ + var delta uint = ix - uint(self.addr[key]) + self.tiny_hash[uint16(ix)] = byte(key) + if delta > 0xFFFF { + delta = 0xFFFF + } + self.banks[bank].slots[idx].delta = uint16(delta) + self.banks[bank].slots[idx].next = self.head[key] + self.addr[key] = uint32(ix) + self.head[key] = uint16(idx) +} + +func StoreRangeH42(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH42(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH42(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + if num_bytes >= HashTypeLengthH42()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH42(handle, ringbuffer, ring_buffer_mask, position-3) + + StoreH42(handle, ringbuffer, ring_buffer_mask, position-2) + StoreH42(handle, ringbuffer, ring_buffer_mask, position-1) + } +} + +func PrepareDistanceCacheH42(handle HasherHandle, distance_cache []int) { + PrepareDistanceCache(distance_cache, 16) +} + +/* Find a longest backward match of &data[cur_ix] up to the length of + max_length and stores the position cur_ix in the hash table. + + REQUIRES: PrepareDistanceCacheH42 must be invoked for current distance cache + values; if this method is invoked repeatedly with the same distance + cache values, it is enough to invoke PrepareDistanceCacheH42 once. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH42(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H42 = SelfH42(handle) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = out.len + var i uint + var key uint = HashBytesH42(data[cur_ix_masked:]) + var tiny_hash byte = byte(key) + /* Don't accept a short copy from far away. */ + out.len = 0 + + out.len_code_delta = 0 + + /* Try last distance first. */ + for i = 0; i < 16; i++ { + var backward uint = uint(distance_cache[i]) + var prev_ix uint = (cur_ix - backward) + + /* For distance code 0 we want to consider 2-byte matches. */ + if i > 0 && self.tiny_hash[uint16(prev_ix)] != tiny_hash { + continue + } + if prev_ix >= cur_ix || backward > max_backward { + continue + } + + prev_ix &= ring_buffer_mask + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 2 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + if i != 0 { + score -= BackwardReferencePenaltyUsingLastDistance(i) + } + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + } + { + var bank uint = key & (512 - 1) + var backward uint = 0 + var hops uint = self.max_hops + var delta uint = cur_ix - uint(self.addr[key]) + var slot uint = uint(self.head[key]) + for { + tmp8 := hops + hops-- + if tmp8 == 0 { + break + } + var prev_ix uint + var last uint = slot + backward += delta + if backward > max_backward { + break + } + prev_ix = (cur_ix - backward) & ring_buffer_mask + slot = uint(self.banks[bank].slots[last].next) + delta = uint(self.banks[bank].slots[last].delta) + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + /* Comparing for >= 3 does not change the semantics, but just saves + for a few unnecessary binary logarithms in backward reference + score, since we are not interested in such short matches. */ + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + + StoreH42(handle, data, ring_buffer_mask, cur_ix) + } + + if out.score == min_score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, false) + } +} diff --git a/h5.go b/h5.go new file mode 100644 index 0000000..002bd9a --- /dev/null +++ b/h5.go @@ -0,0 +1,232 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size (bucket_size_) to a ring buffer of + fixed size (block_size_). The ring buffer contains the last block_size_ + index positions of the given hash key in the compressed data. */ +func HashTypeLengthH5() uint { + return 4 +} + +func StoreLookaheadH5() uint { + return 4 +} + +/* HashBytes is the function that chooses the bucket to place the address in. */ +func HashBytesH5(data []byte, shift int) uint32 { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> uint(shift)) +} + +type H5 struct { + bucket_size_ uint + block_size_ uint + hash_shift_ int + block_mask_ uint32 + num []uint16 + buckets []uint32 +} + +func SelfH5(handle HasherHandle) *H5 { + return handle.extra.(*H5) +} + +func NumH5(self *H5) []uint16 { + return []uint16(self.num) +} + +func BucketsH5(self *H5) []uint32 { + return []uint32(self.buckets) +} + +func InitializeH5(handle HasherHandle, params *BrotliEncoderParams) { + var common *HasherCommon = GetHasherCommon(handle) + handle.extra = new(H5) + var self *H5 = SelfH5(handle) + self.hash_shift_ = 32 - common.params.bucket_bits + self.bucket_size_ = uint(1) << uint(common.params.bucket_bits) + self.block_size_ = uint(1) << uint(common.params.block_bits) + self.block_mask_ = uint32(self.block_size_ - 1) + self.num = make([]uint16, self.bucket_size_) + self.buckets = make([]uint32, self.block_size_*self.bucket_size_) +} + +func PrepareH5(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H5 = SelfH5(handle) + var num []uint16 = NumH5(self) + var partial_prepare_threshold uint = self.bucket_size_ >> 6 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH5(data[i:], self.hash_shift_) + num[key] = 0 + } + } else { + for i := 0; i < int(self.bucket_size_); i++ { + num[i] = 0 + } + } +} + +/* Look at 4 bytes at &data[ix & mask]. + Compute a hash from these, and store the value of ix at that position. */ +func StoreH5(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H5 = SelfH5(handle) + var num []uint16 = NumH5(self) + var key uint32 = HashBytesH5(data[ix&mask:], self.hash_shift_) + var minor_ix uint = uint(num[key]) & uint(self.block_mask_) + var offset uint = minor_ix + uint(key<= HashTypeLengthH5()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH5(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH5(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH5(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH5(handle HasherHandle, distance_cache []int) { + PrepareDistanceCache(distance_cache, GetHasherCommon(handle).params.num_last_distances_to_check) +} + +/* Find a longest backward match of &data[cur_ix] up to the length of + max_length and stores the position cur_ix in the hash table. + + REQUIRES: PrepareDistanceCacheH5 must be invoked for current distance cache + values; if this method is invoked repeatedly with the same distance + cache values, it is enough to invoke PrepareDistanceCacheH5 once. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH5(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var common *HasherCommon = GetHasherCommon(handle) + var self *H5 = SelfH5(handle) + var num []uint16 = NumH5(self) + var buckets []uint32 = BucketsH5(self) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = out.len + var i uint + var bucket []uint32 + /* Don't accept a short copy from far away. */ + out.len = 0 + + out.len_code_delta = 0 + + /* Try last distance first. */ + for i = 0; i < uint(common.params.num_last_distances_to_check); i++ { + var backward uint = uint(distance_cache[i]) + var prev_ix uint = uint(cur_ix - backward) + if prev_ix >= cur_ix { + continue + } + + if backward > max_backward { + continue + } + + prev_ix &= ring_buffer_mask + + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 3 || (len == 2 && i < 2) { + /* Comparing for >= 2 does not change the semantics, but just saves for + a few unnecessary binary logarithms in backward reference score, + since we are not interested in such short matches. */ + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + if i != 0 { + score -= BackwardReferencePenaltyUsingLastDistance(i) + } + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + } + { + var key uint32 = HashBytesH5(data[cur_ix_masked:], self.hash_shift_) + bucket = buckets[key< self.block_size_ { + down = uint(num[key]) - self.block_size_ + } else { + down = 0 + } + for i = uint(num[key]); i > down; { + var prev_ix uint + i-- + prev_ix = uint(bucket[uint32(i)&self.block_mask_]) + var backward uint = cur_ix - prev_ix + if backward > max_backward { + break + } + + prev_ix &= ring_buffer_mask + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + /* Comparing for >= 3 does not change the semantics, but just saves + for a few unnecessary binary logarithms in backward reference + score, since we are not interested in such short matches. */ + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + + bucket[uint32(num[key])&self.block_mask_] = uint32(cur_ix) + num[key]++ + } + + if min_score == out.score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, false) + } +} diff --git a/h54.go b/h54.go new file mode 100644 index 0000000..201fefe --- /dev/null +++ b/h54.go @@ -0,0 +1,201 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func HashTypeLengthH54() uint { + return 8 +} + +func StoreLookaheadH54() uint { + return 8 +} + +/* HashBytes is the function that chooses the bucket to place + the address in. The HashLongestMatch and H54 + classes have separate, different implementations of hashing. */ +func HashBytesH54(data []byte) uint32 { + var h uint64 = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8*7)) * kHashMul64) + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> (64 - 20)) +} + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size ((1 << 20)). Starting from the + given index, 4 buckets are used to store values of a key. */ +type H54 struct { + buckets_ [(1 << 20) + 4]uint32 +} + +func SelfH54(handle HasherHandle) *H54 { + return handle.extra.(*H54) +} + +func InitializeH54(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H54) +} + +func PrepareH54(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H54 = SelfH54(handle) + var partial_prepare_threshold uint = (4 << 20) >> 7 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH54(data[i:]) + for i := 0; i < int(4); i++ { + self.buckets_[key:][i] = 0 + } + } + } else { + /* It is not strictly necessary to fill this buffer here, but + not filling will make the results of the compression stochastic + (but correct). This is because random data would cause the + system to find accidentally good backward references here and there. */ + self.buckets_ = [(1 << 20) + 4]uint32{} + } +} + +/* Look at 5 bytes at &data[ix & mask]. + Compute a hash from these, and store the value somewhere within + [ix .. ix+3]. */ +func StoreH54(handle HasherHandle, data []byte, mask uint, ix uint) { + var key uint32 = HashBytesH54(data[ix&mask:]) + var off uint32 = uint32(ix>>3) % 4 + /* Wiggle the value with the bucket sweep range. */ + SelfH54(handle).buckets_[key+off] = uint32(ix) +} + +func StoreRangeH54(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var i uint + for i = ix_start; i < ix_end; i++ { + StoreH54(handle, data, mask, i) + } +} + +func StitchToPreviousBlockH54(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ringbuffer_mask uint) { + if num_bytes >= HashTypeLengthH54()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH54(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH54(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH54(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH54(handle HasherHandle, distance_cache []int) { +} + +/* Find a longest backward match of &data[cur_ix & ring_buffer_mask] + up to the length of max_length and stores the position cur_ix in the + hash table. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH54(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H54 = SelfH54(handle) + var best_len_in uint = out.len + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var key uint32 = HashBytesH54(data[cur_ix_masked:]) + var compare_char int = int(data[cur_ix_masked+best_len_in]) + var best_score uint = out.score + var best_len uint = best_len_in + var cached_backward uint = uint(distance_cache[0]) + var prev_ix uint = cur_ix - cached_backward + var bucket []uint32 + out.len_code_delta = 0 + if prev_ix < cur_ix { + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char == int(data[prev_ix+best_len]) { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = uint(len) + out.distance = cached_backward + out.score = best_score + compare_char = int(data[cur_ix_masked+best_len]) + if 4 == 1 { + self.buckets_[key] = uint32(cur_ix) + return + } + } + } + } + } + + if 4 == 1 { + var backward uint + var len uint + + /* Only one to look for, don't bother to prepare for a loop. */ + prev_ix = uint(self.buckets_[key]) + + self.buckets_[key] = uint32(cur_ix) + backward = cur_ix - prev_ix + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len_in]) { + return + } + + if backward == 0 || backward > max_backward { + return + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + out.len = uint(len) + out.distance = backward + out.score = score + return + } + } + } else { + bucket = self.buckets_[key:] + var i int + prev_ix = uint(bucket[0]) + bucket = bucket[1:] + for i = 0; i < 4; (func() { i++; tmp9 := bucket; bucket = bucket[1:]; prev_ix = uint(tmp9[0]) })() { + var backward uint = cur_ix - prev_ix + var len uint + prev_ix &= uint(uint32(ring_buffer_mask)) + if compare_char != int(data[prev_ix+best_len]) { + continue + } + + if backward == 0 || backward > max_backward { + continue + } + + len = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = score + compare_char = int(data[cur_ix_masked+best_len]) + } + } + } + } + + self.buckets_[key+uint32((cur_ix>>3)%4)] = uint32(cur_ix) +} diff --git a/h55.go b/h55.go new file mode 100644 index 0000000..a8cb331 --- /dev/null +++ b/h55.go @@ -0,0 +1,109 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2018 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A + and HASHER_B. */ +func HashTypeLengthH55() uint { + var a uint = HashTypeLengthH54() + var b uint = HashTypeLengthHROLLING_FAST() + if a > b { + return a + } else { + return b + } +} + +func StoreLookaheadH55() uint { + var a uint = StoreLookaheadH54() + var b uint = StoreLookaheadHROLLING_FAST() + if a > b { + return a + } else { + return b + } +} + +type H55 struct { + ha HasherHandle + hb HasherHandle + params *BrotliEncoderParams +} + +func SelfH55(handle HasherHandle) *H55 { + return handle.extra.(*H55) +} + +func InitializeH55(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H55) + var self *H55 = SelfH55(handle) + self.ha = nil + self.hb = nil + self.params = params +} + +/* TODO: Initialize of the hashers is defered to Prepare (and params + remembered here) because we don't get the one_shot and input_size params + here that are needed to know the memory size of them. Instead provide + those params to all hashers InitializeH55 */ +func PrepareH55(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H55 = SelfH55(handle) + if self.ha == nil { + var common_a *HasherCommon + var common_b *HasherCommon + + self.ha = new(HasherCommon) + common_a = (*HasherCommon)(self.ha) + common_a.params = self.params.hasher + common_a.is_prepared_ = false + common_a.dict_num_lookups = 0 + common_a.dict_num_matches = 0 + InitializeH54(self.ha, self.params) + + self.hb = new(HasherCommon) + common_b = (*HasherCommon)(self.hb) + common_b.params = self.params.hasher + common_b.is_prepared_ = false + common_b.dict_num_lookups = 0 + common_b.dict_num_matches = 0 + InitializeHROLLING_FAST(self.hb, self.params) + } + + PrepareH54(self.ha, one_shot, input_size, data) + PrepareHROLLING_FAST(self.hb, one_shot, input_size, data) +} + +func StoreH55(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H55 = SelfH55(handle) + StoreH54(self.ha, data, mask, ix) + StoreHROLLING_FAST(self.hb, data, mask, ix) +} + +func StoreRangeH55(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var self *H55 = SelfH55(handle) + StoreRangeH54(self.ha, data, mask, ix_start, ix_end) + StoreRangeHROLLING_FAST(self.hb, data, mask, ix_start, ix_end) +} + +func StitchToPreviousBlockH55(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + var self *H55 = SelfH55(handle) + StitchToPreviousBlockH54(self.ha, num_bytes, position, ringbuffer, ring_buffer_mask) + StitchToPreviousBlockHROLLING_FAST(self.hb, num_bytes, position, ringbuffer, ring_buffer_mask) +} + +func PrepareDistanceCacheH55(handle HasherHandle, distance_cache []int) { + var self *H55 = SelfH55(handle) + PrepareDistanceCacheH54(self.ha, distance_cache) + PrepareDistanceCacheHROLLING_FAST(self.hb, &distance_cache[0]) +} + +func FindLongestMatchH55(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H55 = SelfH55(handle) + FindLongestMatchH54(self.ha, dictionary, data, ring_buffer_mask, distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out) + FindLongestMatchHROLLING_FAST(self.hb, dictionary, data, ring_buffer_mask, &distance_cache[0], cur_ix, max_length, max_backward, gap, max_distance, out) +} diff --git a/h6.go b/h6.go new file mode 100644 index 0000000..ed76d8f --- /dev/null +++ b/h6.go @@ -0,0 +1,234 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* A (forgetful) hash table to the data seen by the compressor, to + help create backward references to previous data. + + This is a hash map of fixed size (bucket_size_) to a ring buffer of + fixed size (block_size_). The ring buffer contains the last block_size_ + index positions of the given hash key in the compressed data. */ +func HashTypeLengthH6() uint { + return 8 +} + +func StoreLookaheadH6() uint { + return 8 +} + +/* HashBytes is the function that chooses the bucket to place the address in. */ +func HashBytesH6(data []byte, mask uint64, shift int) uint32 { + var h uint64 = (BROTLI_UNALIGNED_LOAD64LE(data) & mask) * kHashMul64Long + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return uint32(h >> uint(shift)) +} + +type H6 struct { + bucket_size_ uint + block_size_ uint + hash_shift_ int + hash_mask_ uint64 + block_mask_ uint32 + num []uint16 + buckets []uint32 +} + +func SelfH6(handle HasherHandle) *H6 { + return handle.extra.(*H6) +} + +func NumH6(self *H6) []uint16 { + return []uint16(self.num) +} + +func BucketsH6(self *H6) []uint32 { + return []uint32(self.buckets) +} + +func InitializeH6(handle HasherHandle, params *BrotliEncoderParams) { + var common *HasherCommon = GetHasherCommon(handle) + handle.extra = new(H6) + var self *H6 = SelfH6(handle) + self.hash_shift_ = 64 - common.params.bucket_bits + self.hash_mask_ = (^(uint64(0))) >> uint(64-8*common.params.hash_len) + self.bucket_size_ = uint(1) << uint(common.params.bucket_bits) + self.block_size_ = uint(1) << uint(common.params.block_bits) + self.block_mask_ = uint32(self.block_size_ - 1) + self.num = make([]uint16, self.bucket_size_) + self.buckets = make([]uint32, self.block_size_*self.bucket_size_) +} + +func PrepareH6(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H6 = SelfH6(handle) + var num []uint16 = NumH6(self) + var partial_prepare_threshold uint = self.bucket_size_ >> 6 + /* Partial preparation is 100 times slower (per socket). */ + if one_shot && input_size <= partial_prepare_threshold { + var i uint + for i = 0; i < input_size; i++ { + var key uint32 = HashBytesH6(data[i:], self.hash_mask_, self.hash_shift_) + num[key] = 0 + } + } else { + for i := 0; i < int(self.bucket_size_); i++ { + num[i] = 0 + } + } +} + +/* Look at 4 bytes at &data[ix & mask]. + Compute a hash from these, and store the value of ix at that position. */ +func StoreH6(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H6 = SelfH6(handle) + var num []uint16 = NumH6(self) + var key uint32 = HashBytesH6(data[ix&mask:], self.hash_mask_, self.hash_shift_) + var minor_ix uint = uint(num[key]) & uint(self.block_mask_) + var offset uint = minor_ix + uint(key<= HashTypeLengthH6()-1 && position >= 3 { + /* Prepare the hashes for three last bytes of the last write. + These could not be calculated before, since they require knowledge + of both the previous and the current block. */ + StoreH6(handle, ringbuffer, ringbuffer_mask, position-3) + + StoreH6(handle, ringbuffer, ringbuffer_mask, position-2) + StoreH6(handle, ringbuffer, ringbuffer_mask, position-1) + } +} + +func PrepareDistanceCacheH6(handle HasherHandle, distance_cache []int) { + PrepareDistanceCache(distance_cache, GetHasherCommon(handle).params.num_last_distances_to_check) +} + +/* Find a longest backward match of &data[cur_ix] up to the length of + max_length and stores the position cur_ix in the hash table. + + REQUIRES: PrepareDistanceCacheH6 must be invoked for current distance cache + values; if this method is invoked repeatedly with the same distance + cache values, it is enough to invoke PrepareDistanceCacheH6 once. + + Does not look for matches longer than max_length. + Does not look for matches further away than max_backward. + Writes the best match into |out|. + |out|->score is updated only if a better match is found. */ +func FindLongestMatchH6(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var common *HasherCommon = GetHasherCommon(handle) + var self *H6 = SelfH6(handle) + var num []uint16 = NumH6(self) + var buckets []uint32 = BucketsH6(self) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var min_score uint = out.score + var best_score uint = out.score + var best_len uint = out.len + var i uint + var bucket []uint32 + /* Don't accept a short copy from far away. */ + out.len = 0 + + out.len_code_delta = 0 + + /* Try last distance first. */ + for i = 0; i < uint(common.params.num_last_distances_to_check); i++ { + var backward uint = uint(distance_cache[i]) + var prev_ix uint = uint(cur_ix - backward) + if prev_ix >= cur_ix { + continue + } + + if backward > max_backward { + continue + } + + prev_ix &= ring_buffer_mask + + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 3 || (len == 2 && i < 2) { + /* Comparing for >= 2 does not change the semantics, but just saves for + a few unnecessary binary logarithms in backward reference score, + since we are not interested in such short matches. */ + var score uint = BackwardReferenceScoreUsingLastDistance(uint(len)) + if best_score < score { + if i != 0 { + score -= BackwardReferencePenaltyUsingLastDistance(i) + } + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + } + { + var key uint32 = HashBytesH6(data[cur_ix_masked:], self.hash_mask_, self.hash_shift_) + bucket = buckets[key< self.block_size_ { + down = uint(num[key]) - self.block_size_ + } else { + down = 0 + } + for i = uint(num[key]); i > down; { + var prev_ix uint + i-- + prev_ix = uint(bucket[uint32(i)&self.block_mask_]) + var backward uint = cur_ix - prev_ix + if backward > max_backward { + break + } + + prev_ix &= ring_buffer_mask + if cur_ix_masked+best_len > ring_buffer_mask || prev_ix+best_len > ring_buffer_mask || data[cur_ix_masked+best_len] != data[prev_ix+best_len] { + continue + } + { + var len uint = FindMatchLengthWithLimit(data[prev_ix:], data[cur_ix_masked:], max_length) + if len >= 4 { + /* Comparing for >= 3 does not change the semantics, but just saves + for a few unnecessary binary logarithms in backward reference + score, since we are not interested in such short matches. */ + var score uint = BackwardReferenceScore(uint(len), backward) + if best_score < score { + best_score = score + best_len = uint(len) + out.len = best_len + out.distance = backward + out.score = best_score + } + } + } + } + + bucket[uint32(num[key])&self.block_mask_] = uint32(cur_ix) + num[key]++ + } + + if min_score == out.score { + SearchInStaticDictionary(dictionary, handle, data[cur_ix_masked:], max_length, max_backward+gap, max_distance, out, false) + } +} diff --git a/h65.go b/h65.go new file mode 100644 index 0000000..2fdf3e4 --- /dev/null +++ b/h65.go @@ -0,0 +1,109 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2018 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A + and HASHER_B. */ +func HashTypeLengthH65() uint { + var a uint = HashTypeLengthH6() + var b uint = HashTypeLengthHROLLING() + if a > b { + return a + } else { + return b + } +} + +func StoreLookaheadH65() uint { + var a uint = StoreLookaheadH6() + var b uint = StoreLookaheadHROLLING() + if a > b { + return a + } else { + return b + } +} + +type H65 struct { + ha HasherHandle + hb HasherHandle + params *BrotliEncoderParams +} + +func SelfH65(handle HasherHandle) *H65 { + return handle.extra.(*H65) +} + +func InitializeH65(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(H65) + var self *H65 = SelfH65(handle) + self.ha = nil + self.hb = nil + self.params = params +} + +/* TODO: Initialize of the hashers is defered to Prepare (and params + remembered here) because we don't get the one_shot and input_size params + here that are needed to know the memory size of them. Instead provide + those params to all hashers InitializeH65 */ +func PrepareH65(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *H65 = SelfH65(handle) + if self.ha == nil { + var common_a *HasherCommon + var common_b *HasherCommon + + self.ha = new(HasherCommon) + common_a = (*HasherCommon)(self.ha) + common_a.params = self.params.hasher + common_a.is_prepared_ = false + common_a.dict_num_lookups = 0 + common_a.dict_num_matches = 0 + InitializeH6(self.ha, self.params) + + self.hb = new(HasherCommon) + common_b = (*HasherCommon)(self.hb) + common_b.params = self.params.hasher + common_b.is_prepared_ = false + common_b.dict_num_lookups = 0 + common_b.dict_num_matches = 0 + InitializeHROLLING(self.hb, self.params) + } + + PrepareH6(self.ha, one_shot, input_size, data) + PrepareHROLLING(self.hb, one_shot, input_size, data) +} + +func StoreH65(handle HasherHandle, data []byte, mask uint, ix uint) { + var self *H65 = SelfH65(handle) + StoreH6(self.ha, data, mask, ix) + StoreHROLLING(self.hb, data, mask, ix) +} + +func StoreRangeH65(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { + var self *H65 = SelfH65(handle) + StoreRangeH6(self.ha, data, mask, ix_start, ix_end) + StoreRangeHROLLING(self.hb, data, mask, ix_start, ix_end) +} + +func StitchToPreviousBlockH65(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + var self *H65 = SelfH65(handle) + StitchToPreviousBlockH6(self.ha, num_bytes, position, ringbuffer, ring_buffer_mask) + StitchToPreviousBlockHROLLING(self.hb, num_bytes, position, ringbuffer, ring_buffer_mask) +} + +func PrepareDistanceCacheH65(handle HasherHandle, distance_cache []int) { + var self *H65 = SelfH65(handle) + PrepareDistanceCacheH6(self.ha, distance_cache) + PrepareDistanceCacheHROLLING(self.hb, &distance_cache[0]) +} + +func FindLongestMatchH65(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache []int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *H65 = SelfH65(handle) + FindLongestMatchH6(self.ha, dictionary, data, ring_buffer_mask, distance_cache, cur_ix, max_length, max_backward, gap, max_distance, out) + FindLongestMatchHROLLING(self.hb, dictionary, data, ring_buffer_mask, &distance_cache[0], cur_ix, max_length, max_backward, gap, max_distance, out) +} diff --git a/hash.go b/hash.go new file mode 100644 index 0000000..c245f7d --- /dev/null +++ b/hash.go @@ -0,0 +1,370 @@ +package brotli + +/* Matches data against static dictionary words, and for each length l, + for which a match is found, updates matches[l] to be the minimum possible + (distance << 5) + len_code. + Returns 1 if matches have been found, otherwise 0. + Prerequisites: + matches array is at least BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1 long + all elements are initialized to kInvalidMatch */ +/* Pointer to hasher data. + * + * Excluding initialization and destruction, hasher can be passed as + * HasherHandle by value. + * + * Typically hasher data consists of 3 sections: + * * HasherCommon structure + * * private structured hasher data, depending on hasher type + * * private dynamic hasher data, depending on hasher type and parameters + * + */ +type HasherCommon struct { + params BrotliHasherParams + is_prepared_ bool + dict_num_lookups uint + dict_num_matches uint + extra interface{} +} + +type HasherHandle *HasherCommon + +func GetHasherCommon(handle HasherHandle) *HasherCommon { + return (*HasherCommon)(handle) +} + +type score_t uint + +var kCutoffTransformsCount uint32 = 10 + +/* 0, 12, 27, 23, 42, 63, 56, 48, 59, 64 */ +/* 0+0, 4+8, 8+19, 12+11, 16+26, 20+43, 24+32, 28+20, 32+27, 36+28 */ +var kCutoffTransforms uint64 = 0x071B520ADA2D3200 + +type HasherSearchResult struct { + len uint + distance uint + score uint + len_code_delta int +} + +/* kHashMul32 multiplier has these properties: + * The multiplier must be odd. Otherwise we may lose the highest bit. + * No long streaks of ones or zeros. + * There is no effort to ensure that it is a prime, the oddity is enough + for this use. + * The number has been tuned heuristically against compression benchmarks. */ +var kHashMul32 uint32 = 0x1E35A7BD + +var kHashMul64 uint64 = 0x1E35A7BD1E35A7BD + +var kHashMul64Long uint64 = 0x1FE35A7BD3579BD3 + +func Hash14(data []byte) uint32 { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return h >> (32 - 14) +} + +func PrepareDistanceCache(distance_cache []int, num_distances int) { + if num_distances > 4 { + var last_distance int = distance_cache[0] + distance_cache[4] = last_distance - 1 + distance_cache[5] = last_distance + 1 + distance_cache[6] = last_distance - 2 + distance_cache[7] = last_distance + 2 + distance_cache[8] = last_distance - 3 + distance_cache[9] = last_distance + 3 + if num_distances > 10 { + var next_last_distance int = distance_cache[1] + distance_cache[10] = next_last_distance - 1 + distance_cache[11] = next_last_distance + 1 + distance_cache[12] = next_last_distance - 2 + distance_cache[13] = next_last_distance + 2 + distance_cache[14] = next_last_distance - 3 + distance_cache[15] = next_last_distance + 3 + } + } +} + +const BROTLI_LITERAL_BYTE_SCORE = 135 + +const BROTLI_DISTANCE_BIT_PENALTY = 30 + +/* Score must be positive after applying maximal penalty. */ +const BROTLI_SCORE_BASE = (BROTLI_DISTANCE_BIT_PENALTY * 8 * 8) + +/* Usually, we always choose the longest backward reference. This function + allows for the exception of that rule. + + If we choose a backward reference that is further away, it will + usually be coded with more bits. We approximate this by assuming + log2(distance). If the distance can be expressed in terms of the + last four distances, we use some heuristic constants to estimate + the bits cost. For the first up to four literals we use the bit + cost of the literals from the literal cost model, after that we + use the average bit cost of the cost model. + + This function is used to sometimes discard a longer backward reference + when it is not much longer and the bit cost for encoding it is more + than the saved literals. + + backward_reference_offset MUST be positive. */ +func BackwardReferenceScore(copy_length uint, backward_reference_offset uint) uint { + return BROTLI_SCORE_BASE + BROTLI_LITERAL_BYTE_SCORE*uint(copy_length) - BROTLI_DISTANCE_BIT_PENALTY*uint(Log2FloorNonZero(backward_reference_offset)) +} + +func BackwardReferenceScoreUsingLastDistance(copy_length uint) uint { + return BROTLI_LITERAL_BYTE_SCORE*uint(copy_length) + BROTLI_SCORE_BASE + 15 +} + +func BackwardReferencePenaltyUsingLastDistance(distance_short_code uint) uint { + return uint(39) + ((0x1CA10 >> (distance_short_code & 0xE)) & 0xE) +} + +func TestStaticDictionaryItem(dictionary *BrotliEncoderDictionary, item uint, data []byte, max_length uint, max_backward uint, max_distance uint, out *HasherSearchResult) bool { + var len uint + var word_idx uint + var offset uint + var matchlen uint + var backward uint + var score uint + len = item & 0x1F + word_idx = item >> 5 + offset = uint(dictionary.words.offsets_by_length[len]) + len*word_idx + if len > max_length { + return false + } + + matchlen = FindMatchLengthWithLimit(data, dictionary.words.data[offset:], uint(len)) + if matchlen+uint(dictionary.cutoffTransformsCount) <= len || matchlen == 0 { + return false + } + { + var cut uint = len - matchlen + var transform_id uint = (cut << 2) + uint((dictionary.cutoffTransforms>>(cut*6))&0x3F) + backward = max_backward + 1 + word_idx + (transform_id << dictionary.words.size_bits_by_length[len]) + } + + if backward > max_distance { + return false + } + + score = BackwardReferenceScore(matchlen, backward) + if score < out.score { + return false + } + + out.len = matchlen + out.len_code_delta = int(len) - int(matchlen) + out.distance = backward + out.score = score + return true +} + +func SearchInStaticDictionary(dictionary *BrotliEncoderDictionary, handle HasherHandle, data []byte, max_length uint, max_backward uint, max_distance uint, out *HasherSearchResult, shallow bool) { + var key uint + var i uint + var self *HasherCommon = GetHasherCommon(handle) + if self.dict_num_matches < self.dict_num_lookups>>7 { + return + } + + key = uint(Hash14(data) << 1) + for i = 0; ; (func() { i++; key++ })() { + var tmp uint + if shallow { + tmp = 1 + } else { + tmp = 2 + } + if i >= tmp { + break + } + var item uint = uint(dictionary.hash_table[key]) + self.dict_num_lookups++ + if item != 0 { + var item_matches bool = TestStaticDictionaryItem(dictionary, item, data, max_length, max_backward, max_distance, out) + if item_matches { + self.dict_num_matches++ + } + } + } +} + +type BackwardMatch struct { + distance uint32 + length_and_code uint32 +} + +func InitBackwardMatch(self *BackwardMatch, dist uint, len uint) { + self.distance = uint32(dist) + self.length_and_code = uint32(len << 5) +} + +func InitDictionaryBackwardMatch(self *BackwardMatch, dist uint, len uint, len_code uint) { + self.distance = uint32(dist) + var tmp uint + if len == len_code { + tmp = 0 + } else { + tmp = len_code + } + self.length_and_code = uint32(len<<5 | tmp) +} + +func BackwardMatchLength(self *BackwardMatch) uint { + return uint(self.length_and_code >> 5) +} + +func BackwardMatchLengthCode(self *BackwardMatch) uint { + var code uint = uint(self.length_and_code) & 31 + if code != 0 { + return code + } else { + return BackwardMatchLength(self) + } +} + +func DestroyHasher(handle *HasherHandle) { + if *handle == nil { + return + } + *handle = nil +} + +func HasherReset(handle HasherHandle) { + if handle == nil { + return + } + GetHasherCommon(handle).is_prepared_ = false +} + +func HasherSetup(handle *HasherHandle, params *BrotliEncoderParams, data []byte, position uint, input_size uint, is_last bool) { + var self HasherHandle = nil + var common *HasherCommon = nil + var one_shot bool = (position == 0 && is_last) + if *handle == nil { + ChooseHasher(params, ¶ms.hasher) + self = new(HasherCommon) + *handle = self + common = GetHasherCommon(self) + common.params = params.hasher + switch common.params.type_ { + case 2: + InitializeH2(*handle, params) + case 3: + InitializeH3(*handle, params) + case 4: + InitializeH4(*handle, params) + case 5: + InitializeH5(*handle, params) + case 6: + InitializeH6(*handle, params) + case 40: + InitializeH40(*handle, params) + case 41: + InitializeH41(*handle, params) + case 42: + InitializeH42(*handle, params) + case 54: + InitializeH54(*handle, params) + case 35: + InitializeH35(*handle, params) + case 55: + InitializeH55(*handle, params) + case 65: + InitializeH65(*handle, params) + case 10: + InitializeH10(*handle, params) + break + fallthrough + + default: + break + } + + HasherReset(*handle) + } + + self = *handle + common = GetHasherCommon(self) + if !common.is_prepared_ { + switch common.params.type_ { + case 2: + PrepareH2(self, one_shot, input_size, data) + case 3: + PrepareH3(self, one_shot, input_size, data) + case 4: + PrepareH4(self, one_shot, input_size, data) + case 5: + PrepareH5(self, one_shot, input_size, data) + case 6: + PrepareH6(self, one_shot, input_size, data) + case 40: + PrepareH40(self, one_shot, input_size, data) + case 41: + PrepareH41(self, one_shot, input_size, data) + case 42: + PrepareH42(self, one_shot, input_size, data) + case 54: + PrepareH54(self, one_shot, input_size, data) + case 35: + PrepareH35(self, one_shot, input_size, data) + case 55: + PrepareH55(self, one_shot, input_size, data) + case 65: + PrepareH65(self, one_shot, input_size, data) + case 10: + PrepareH10(self, one_shot, input_size, data) + + default: + break + } + + if position == 0 { + common.dict_num_lookups = 0 + common.dict_num_matches = 0 + } + + common.is_prepared_ = true + } +} + +func InitOrStitchToPreviousBlock(handle *HasherHandle, data []byte, mask uint, params *BrotliEncoderParams, position uint, input_size uint, is_last bool) { + var self HasherHandle + HasherSetup(handle, params, data, position, input_size, is_last) + self = *handle + switch GetHasherCommon(self).params.type_ { + case 2: + StitchToPreviousBlockH2(self, input_size, position, data, mask) + case 3: + StitchToPreviousBlockH3(self, input_size, position, data, mask) + case 4: + StitchToPreviousBlockH4(self, input_size, position, data, mask) + case 5: + StitchToPreviousBlockH5(self, input_size, position, data, mask) + case 6: + StitchToPreviousBlockH6(self, input_size, position, data, mask) + case 40: + StitchToPreviousBlockH40(self, input_size, position, data, mask) + case 41: + StitchToPreviousBlockH41(self, input_size, position, data, mask) + case 42: + StitchToPreviousBlockH42(self, input_size, position, data, mask) + case 54: + StitchToPreviousBlockH54(self, input_size, position, data, mask) + case 35: + StitchToPreviousBlockH35(self, input_size, position, data, mask) + case 55: + StitchToPreviousBlockH55(self, input_size, position, data, mask) + case 65: + StitchToPreviousBlockH65(self, input_size, position, data, mask) + case 10: + StitchToPreviousBlockH10(self, input_size, position, data, mask) + + default: + break + } +} diff --git a/histogram.go b/histogram.go new file mode 100644 index 0000000..14d61fe --- /dev/null +++ b/histogram.go @@ -0,0 +1,225 @@ +package brotli + +/* The distance symbols effectively used by "Large Window Brotli" (32-bit). */ +const BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS = 544 + +type HistogramLiteral struct { + data_ [BROTLI_NUM_LITERAL_SYMBOLS]uint32 + total_count_ uint + bit_cost_ float64 +} + +func HistogramClearLiteral(self *HistogramLiteral) { + self.data_ = [BROTLI_NUM_LITERAL_SYMBOLS]uint32{} + self.total_count_ = 0 + self.bit_cost_ = HUGE_VAL +} + +func ClearHistogramsLiteral(array []HistogramLiteral, length uint) { + var i uint + for i = 0; i < length; i++ { + HistogramClearLiteral(&array[i:][0]) + } +} + +func HistogramAddLiteral(self *HistogramLiteral, val uint) { + self.data_[val]++ + self.total_count_++ +} + +func HistogramAddVectorLiteral(self *HistogramLiteral, p []byte, n uint) { + self.total_count_ += n + n += 1 + for { + n-- + if n == 0 { + break + } + self.data_[p[0]]++ + p = p[1:] + } +} + +func HistogramAddHistogramLiteral(self *HistogramLiteral, v *HistogramLiteral) { + var i uint + self.total_count_ += v.total_count_ + for i = 0; i < BROTLI_NUM_LITERAL_SYMBOLS; i++ { + self.data_[i] += v.data_[i] + } +} + +func HistogramDataSizeLiteral() uint { + return BROTLI_NUM_LITERAL_SYMBOLS +} + +type HistogramCommand struct { + data_ [BROTLI_NUM_COMMAND_SYMBOLS]uint32 + total_count_ uint + bit_cost_ float64 +} + +func HistogramClearCommand(self *HistogramCommand) { + self.data_ = [BROTLI_NUM_COMMAND_SYMBOLS]uint32{} + self.total_count_ = 0 + self.bit_cost_ = HUGE_VAL +} + +func ClearHistogramsCommand(array []HistogramCommand, length uint) { + var i uint + for i = 0; i < length; i++ { + HistogramClearCommand(&array[i:][0]) + } +} + +func HistogramAddCommand(self *HistogramCommand, val uint) { + self.data_[val]++ + self.total_count_++ +} + +func HistogramAddVectorCommand(self *HistogramCommand, p []uint16, n uint) { + self.total_count_ += n + n += 1 + for { + n-- + if n == 0 { + break + } + self.data_[p[0]]++ + p = p[1:] + } +} + +func HistogramAddHistogramCommand(self *HistogramCommand, v *HistogramCommand) { + var i uint + self.total_count_ += v.total_count_ + for i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; i++ { + self.data_[i] += v.data_[i] + } +} + +func HistogramDataSizeCommand() uint { + return BROTLI_NUM_COMMAND_SYMBOLS +} + +type HistogramDistance struct { + data_ [BROTLI_NUM_DISTANCE_SYMBOLS]uint32 + total_count_ uint + bit_cost_ float64 +} + +func HistogramClearDistance(self *HistogramDistance) { + self.data_ = [BROTLI_NUM_DISTANCE_SYMBOLS]uint32{} + self.total_count_ = 0 + self.bit_cost_ = HUGE_VAL +} + +func ClearHistogramsDistance(array []HistogramDistance, length uint) { + var i uint + for i = 0; i < length; i++ { + HistogramClearDistance(&array[i:][0]) + } +} + +func HistogramAddDistance(self *HistogramDistance, val uint) { + self.data_[val]++ + self.total_count_++ +} + +func HistogramAddVectorDistance(self *HistogramDistance, p []uint16, n uint) { + self.total_count_ += n + n += 1 + for { + n-- + if n == 0 { + break + } + self.data_[p[0]]++ + p = p[1:] + } +} + +func HistogramAddHistogramDistance(self *HistogramDistance, v *HistogramDistance) { + var i uint + self.total_count_ += v.total_count_ + for i = 0; i < BROTLI_NUM_DISTANCE_SYMBOLS; i++ { + self.data_[i] += v.data_[i] + } +} + +func HistogramDataSizeDistance() uint { + return BROTLI_NUM_DISTANCE_SYMBOLS +} + +type BlockSplitIterator struct { + split_ *BlockSplit + idx_ uint + type_ uint + length_ uint +} + +func InitBlockSplitIterator(self *BlockSplitIterator, split *BlockSplit) { + self.split_ = split + self.idx_ = 0 + self.type_ = 0 + if split.lengths != nil { + self.length_ = uint(split.lengths[0]) + } else { + self.length_ = 0 + } +} + +func BlockSplitIteratorNext(self *BlockSplitIterator) { + if self.length_ == 0 { + self.idx_++ + self.type_ = uint(self.split_.types[self.idx_]) + self.length_ = uint(self.split_.lengths[self.idx_]) + } + + self.length_-- +} + +func BrotliBuildHistogramsWithContext(cmds []Command, num_commands uint, literal_split *BlockSplit, insert_and_copy_split *BlockSplit, dist_split *BlockSplit, ringbuffer []byte, start_pos uint, mask uint, prev_byte byte, prev_byte2 byte, context_modes []int, literal_histograms []HistogramLiteral, insert_and_copy_histograms []HistogramCommand, copy_dist_histograms []HistogramDistance) { + var pos uint = start_pos + var literal_it BlockSplitIterator + var insert_and_copy_it BlockSplitIterator + var dist_it BlockSplitIterator + var i uint + + InitBlockSplitIterator(&literal_it, literal_split) + InitBlockSplitIterator(&insert_and_copy_it, insert_and_copy_split) + InitBlockSplitIterator(&dist_it, dist_split) + for i = 0; i < num_commands; i++ { + var cmd *Command = &cmds[i] + var j uint + BlockSplitIteratorNext(&insert_and_copy_it) + HistogramAddCommand(&insert_and_copy_histograms[insert_and_copy_it.type_], uint(cmd.cmd_prefix_)) + + /* TODO: unwrap iterator blocks. */ + for j = uint(cmd.insert_len_); j != 0; j-- { + var context uint + BlockSplitIteratorNext(&literal_it) + context = literal_it.type_ + if context_modes != nil { + var lut ContextLut = BROTLI_CONTEXT_LUT(context_modes[context]) + context = (context << BROTLI_LITERAL_CONTEXT_BITS) + uint(BROTLI_CONTEXT(prev_byte, prev_byte2, lut)) + } + + HistogramAddLiteral(&literal_histograms[context], uint(ringbuffer[pos&mask])) + prev_byte2 = prev_byte + prev_byte = ringbuffer[pos&mask] + pos++ + } + + pos += uint(CommandCopyLen(cmd)) + if CommandCopyLen(cmd) != 0 { + prev_byte2 = ringbuffer[(pos-2)&mask] + prev_byte = ringbuffer[(pos-1)&mask] + if cmd.cmd_prefix_ >= 128 { + var context uint + BlockSplitIteratorNext(&dist_it) + context = uint(uint32(dist_it.type_< available { + available = 0 + } else { + available = available - diff + } + position += diff + } + + position_masked = position & ring_buffer_mask + + /* wrapping around ringbuffer not handled. */ + if available > ring_buffer_mask-position_masked { + available = ring_buffer_mask - position_masked + } + + PrepareHROLLING(handle, false, available, ringbuffer[position&ring_buffer_mask:]) + self.next_ix = position +} + +func PrepareDistanceCacheHROLLING(handle HasherHandle, distance_cache *int) { +} + +func FindLongestMatchHROLLING(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache *int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *HROLLING = SelfHROLLING(handle) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var pos uint = self.next_ix + + if cur_ix&(1-1) != 0 { + return + } + + /* Not enough lookahead */ + if max_length < 32 { + return + } + + for pos = self.next_ix; pos <= cur_ix; pos += 1 { + var code uint32 = self.state & ((16777216 * 64) - 1) + var rem byte = data[pos&ring_buffer_mask] + var add byte = data[(pos+32)&ring_buffer_mask] + var found_ix uint = uint(kInvalidPosHROLLING) + + self.state = HashRollingFunctionHROLLING(self.state, add, rem, self.factor, self.factor_remove) + + if code < 16777216 { + found_ix = uint(self.table[code]) + self.table[code] = uint32(pos) + if pos == cur_ix && uint32(found_ix) != kInvalidPosHROLLING { + /* The cast to 32-bit makes backward distances up to 4GB work even + if cur_ix is above 4GB, despite using 32-bit values in the table. */ + var backward uint = uint(uint32(cur_ix - found_ix)) + if backward <= max_backward { + var found_ix_masked uint = found_ix & ring_buffer_mask + var len uint = FindMatchLengthWithLimit(data[found_ix_masked:], data[cur_ix_masked:], max_length) + if len >= 4 && len > out.len { + var score uint = BackwardReferenceScore(uint(len), backward) + if score > out.score { + out.len = uint(len) + out.distance = backward + out.score = score + out.len_code_delta = 0 + } + } + } + } + } + } + + self.next_ix = cur_ix + 1 +} diff --git a/hrolling_fast.go b/hrolling_fast.go new file mode 100644 index 0000000..a5359cf --- /dev/null +++ b/hrolling_fast.go @@ -0,0 +1,175 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2018 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Rolling hash for long distance long string matches. Stores one position + per bucket, bucket key is computed over a long region. */ +var kRollingHashMul32HROLLING_FAST uint32 = 69069 + +var kInvalidPosHROLLING_FAST uint32 = 0xffffffff + +/* This hasher uses a longer forward length, but returning a higher value here + will hurt compression by the main hasher when combined with a composite + hasher. The hasher tests for forward itself instead. */ +func HashTypeLengthHROLLING_FAST() uint { + return 4 +} + +func StoreLookaheadHROLLING_FAST() uint { + return 4 +} + +/* Computes a code from a single byte. A lookup table of 256 values could be + used, but simply adding 1 works about as good. */ +func HashByteHROLLING_FAST(byte byte) uint32 { + return uint32(byte) + 1 +} + +func HashRollingFunctionInitialHROLLING_FAST(state uint32, add byte, factor uint32) uint32 { + return uint32(factor*state + HashByteHROLLING_FAST(add)) +} + +func HashRollingFunctionHROLLING_FAST(state uint32, add byte, rem byte, factor uint32, factor_remove uint32) uint32 { + return uint32(factor*state + HashByteHROLLING_FAST(add) - factor_remove*HashByteHROLLING_FAST(rem)) +} + +type HROLLING_FAST struct { + state uint32 + table []uint32 + next_ix uint + chunk_len uint32 + factor uint32 + factor_remove uint32 +} + +func SelfHROLLING_FAST(handle HasherHandle) *HROLLING_FAST { + return handle.extra.(*HROLLING_FAST) +} + +func InitializeHROLLING_FAST(handle HasherHandle, params *BrotliEncoderParams) { + handle.extra = new(HROLLING_FAST) + var self *HROLLING_FAST = SelfHROLLING_FAST(handle) + var i uint + self.state = 0 + self.next_ix = 0 + + self.factor = kRollingHashMul32HROLLING_FAST + + /* Compute the factor of the oldest byte to remove: factor**steps modulo + 0xffffffff (the multiplications rely on 32-bit overflow) */ + self.factor_remove = 1 + + for i = 0; i < 32; i += 4 { + self.factor_remove *= self.factor + } + + self.table = make([]uint32, 16777216) + for i = 0; i < 16777216; i++ { + self.table[i] = kInvalidPosHROLLING_FAST + } +} + +func PrepareHROLLING_FAST(handle HasherHandle, one_shot bool, input_size uint, data []byte) { + var self *HROLLING_FAST = SelfHROLLING_FAST(handle) + var i uint + + /* Too small size, cannot use this hasher. */ + if input_size < 32 { + return + } + self.state = 0 + for i = 0; i < 32; i += 4 { + self.state = HashRollingFunctionInitialHROLLING_FAST(self.state, data[i], self.factor) + } +} + +func StoreHROLLING_FAST(handle HasherHandle, data []byte, mask uint, ix uint) { +} + +func StoreRangeHROLLING_FAST(handle HasherHandle, data []byte, mask uint, ix_start uint, ix_end uint) { +} + +func StitchToPreviousBlockHROLLING_FAST(handle HasherHandle, num_bytes uint, position uint, ringbuffer []byte, ring_buffer_mask uint) { + var self *HROLLING_FAST = SelfHROLLING_FAST(handle) + var position_masked uint + /* In this case we must re-initialize the hasher from scratch from the + current position. */ + + var available uint = num_bytes + if position&(4-1) != 0 { + var diff uint = 4 - (position & (4 - 1)) + if diff > available { + available = 0 + } else { + available = available - diff + } + position += diff + } + + position_masked = position & ring_buffer_mask + + /* wrapping around ringbuffer not handled. */ + if available > ring_buffer_mask-position_masked { + available = ring_buffer_mask - position_masked + } + + PrepareHROLLING_FAST(handle, false, available, ringbuffer[position&ring_buffer_mask:]) + self.next_ix = position +} + +func PrepareDistanceCacheHROLLING_FAST(handle HasherHandle, distance_cache *int) { +} + +func FindLongestMatchHROLLING_FAST(handle HasherHandle, dictionary *BrotliEncoderDictionary, data []byte, ring_buffer_mask uint, distance_cache *int, cur_ix uint, max_length uint, max_backward uint, gap uint, max_distance uint, out *HasherSearchResult) { + var self *HROLLING_FAST = SelfHROLLING_FAST(handle) + var cur_ix_masked uint = cur_ix & ring_buffer_mask + var pos uint = self.next_ix + + if cur_ix&(4-1) != 0 { + return + } + + /* Not enough lookahead */ + if max_length < 32 { + return + } + + for pos = self.next_ix; pos <= cur_ix; pos += 4 { + var code uint32 = self.state & ((16777216 * 64) - 1) + var rem byte = data[pos&ring_buffer_mask] + var add byte = data[(pos+32)&ring_buffer_mask] + var found_ix uint = uint(kInvalidPosHROLLING_FAST) + + self.state = HashRollingFunctionHROLLING_FAST(self.state, add, rem, self.factor, self.factor_remove) + + if code < 16777216 { + found_ix = uint(self.table[code]) + self.table[code] = uint32(pos) + if pos == cur_ix && uint32(found_ix) != kInvalidPosHROLLING_FAST { + /* The cast to 32-bit makes backward distances up to 4GB work even + if cur_ix is above 4GB, despite using 32-bit values in the table. */ + var backward uint = uint(uint32(cur_ix - found_ix)) + if backward <= max_backward { + var found_ix_masked uint = found_ix & ring_buffer_mask + var len uint = FindMatchLengthWithLimit(data[found_ix_masked:], data[cur_ix_masked:], max_length) + if len >= 4 && len > out.len { + var score uint = BackwardReferenceScore(uint(len), backward) + if score > out.score { + out.len = uint(len) + out.distance = backward + out.score = score + out.len_code_delta = 0 + } + } + } + } + } + } + + self.next_ix = cur_ix + 4 +} diff --git a/huffman.go b/huffman.go new file mode 100644 index 0000000..b28ea1b --- /dev/null +++ b/huffman.go @@ -0,0 +1,657 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Utilities for building Huffman decoding tables. */ +const BROTLI_HUFFMAN_MAX_CODE_LENGTH = 15 + +/* Maximum possible Huffman table size for an alphabet size of (index * 32), + max code length 15 and root table bits 8. */ +var kMaxHuffmanTableSize = []uint16{ + 256, + 402, + 436, + 468, + 500, + 534, + 566, + 598, + 630, + 662, + 694, + 726, + 758, + 790, + 822, + 854, + 886, + 920, + 952, + 984, + 1016, + 1048, + 1080, + 1112, + 1144, + 1176, + 1208, + 1240, + 1272, + 1304, + 1336, + 1368, + 1400, + 1432, + 1464, + 1496, + 1528, +} + +/* BROTLI_NUM_BLOCK_LEN_SYMBOLS == 26 */ +const BROTLI_HUFFMAN_MAX_SIZE_26 = 396 + +/* BROTLI_MAX_BLOCK_TYPE_SYMBOLS == 258 */ +const BROTLI_HUFFMAN_MAX_SIZE_258 = 632 + +/* BROTLI_MAX_CONTEXT_MAP_SYMBOLS == 272 */ +const BROTLI_HUFFMAN_MAX_SIZE_272 = 646 + +const BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH = 5 + +/* Do not create this struct directly - use the ConstructHuffmanCode + * constructor below! */ +type HuffmanCode struct { + bits byte + value uint16 +} + +func ConstructHuffmanCode(bits byte, value uint16) HuffmanCode { + var h HuffmanCode + h.bits = bits + h.value = value + return h +} + +/* Builds Huffman lookup table assuming code lengths are in symbol order. */ + +/* Builds Huffman lookup table assuming code lengths are in symbol order. + Returns size of resulting table. */ + +/* Builds a simple Huffman table. The |num_symbols| parameter is to be + interpreted as follows: 0 means 1 symbol, 1 means 2 symbols, + 2 means 3 symbols, 3 means 4 symbols with lengths [2, 2, 2, 2], + 4 means 4 symbols with lengths [1, 2, 3, 3]. */ + +/* Contains a collection of Huffman trees with the same alphabet size. */ +/* max_symbol is needed due to simple codes since log2(alphabet_size) could be + greater than log2(max_symbol). */ +type HuffmanTreeGroup struct { + htrees [][]HuffmanCode + codes []HuffmanCode + alphabet_size uint16 + max_symbol uint16 + num_htrees uint16 +} + +const BROTLI_REVERSE_BITS_MAX = 8 + +const BROTLI_REVERSE_BITS_BASE = 0 + +var kReverseBits = [1 << BROTLI_REVERSE_BITS_MAX]byte{ + 0x00, + 0x80, + 0x40, + 0xC0, + 0x20, + 0xA0, + 0x60, + 0xE0, + 0x10, + 0x90, + 0x50, + 0xD0, + 0x30, + 0xB0, + 0x70, + 0xF0, + 0x08, + 0x88, + 0x48, + 0xC8, + 0x28, + 0xA8, + 0x68, + 0xE8, + 0x18, + 0x98, + 0x58, + 0xD8, + 0x38, + 0xB8, + 0x78, + 0xF8, + 0x04, + 0x84, + 0x44, + 0xC4, + 0x24, + 0xA4, + 0x64, + 0xE4, + 0x14, + 0x94, + 0x54, + 0xD4, + 0x34, + 0xB4, + 0x74, + 0xF4, + 0x0C, + 0x8C, + 0x4C, + 0xCC, + 0x2C, + 0xAC, + 0x6C, + 0xEC, + 0x1C, + 0x9C, + 0x5C, + 0xDC, + 0x3C, + 0xBC, + 0x7C, + 0xFC, + 0x02, + 0x82, + 0x42, + 0xC2, + 0x22, + 0xA2, + 0x62, + 0xE2, + 0x12, + 0x92, + 0x52, + 0xD2, + 0x32, + 0xB2, + 0x72, + 0xF2, + 0x0A, + 0x8A, + 0x4A, + 0xCA, + 0x2A, + 0xAA, + 0x6A, + 0xEA, + 0x1A, + 0x9A, + 0x5A, + 0xDA, + 0x3A, + 0xBA, + 0x7A, + 0xFA, + 0x06, + 0x86, + 0x46, + 0xC6, + 0x26, + 0xA6, + 0x66, + 0xE6, + 0x16, + 0x96, + 0x56, + 0xD6, + 0x36, + 0xB6, + 0x76, + 0xF6, + 0x0E, + 0x8E, + 0x4E, + 0xCE, + 0x2E, + 0xAE, + 0x6E, + 0xEE, + 0x1E, + 0x9E, + 0x5E, + 0xDE, + 0x3E, + 0xBE, + 0x7E, + 0xFE, + 0x01, + 0x81, + 0x41, + 0xC1, + 0x21, + 0xA1, + 0x61, + 0xE1, + 0x11, + 0x91, + 0x51, + 0xD1, + 0x31, + 0xB1, + 0x71, + 0xF1, + 0x09, + 0x89, + 0x49, + 0xC9, + 0x29, + 0xA9, + 0x69, + 0xE9, + 0x19, + 0x99, + 0x59, + 0xD9, + 0x39, + 0xB9, + 0x79, + 0xF9, + 0x05, + 0x85, + 0x45, + 0xC5, + 0x25, + 0xA5, + 0x65, + 0xE5, + 0x15, + 0x95, + 0x55, + 0xD5, + 0x35, + 0xB5, + 0x75, + 0xF5, + 0x0D, + 0x8D, + 0x4D, + 0xCD, + 0x2D, + 0xAD, + 0x6D, + 0xED, + 0x1D, + 0x9D, + 0x5D, + 0xDD, + 0x3D, + 0xBD, + 0x7D, + 0xFD, + 0x03, + 0x83, + 0x43, + 0xC3, + 0x23, + 0xA3, + 0x63, + 0xE3, + 0x13, + 0x93, + 0x53, + 0xD3, + 0x33, + 0xB3, + 0x73, + 0xF3, + 0x0B, + 0x8B, + 0x4B, + 0xCB, + 0x2B, + 0xAB, + 0x6B, + 0xEB, + 0x1B, + 0x9B, + 0x5B, + 0xDB, + 0x3B, + 0xBB, + 0x7B, + 0xFB, + 0x07, + 0x87, + 0x47, + 0xC7, + 0x27, + 0xA7, + 0x67, + 0xE7, + 0x17, + 0x97, + 0x57, + 0xD7, + 0x37, + 0xB7, + 0x77, + 0xF7, + 0x0F, + 0x8F, + 0x4F, + 0xCF, + 0x2F, + 0xAF, + 0x6F, + 0xEF, + 0x1F, + 0x9F, + 0x5F, + 0xDF, + 0x3F, + 0xBF, + 0x7F, + 0xFF, +} + +const BROTLI_REVERSE_BITS_LOWEST = (uint64(1) << (BROTLI_REVERSE_BITS_MAX - 1 + BROTLI_REVERSE_BITS_BASE)) + +/* Returns reverse(num >> BROTLI_REVERSE_BITS_BASE, BROTLI_REVERSE_BITS_MAX), + where reverse(value, len) is the bit-wise reversal of the len least + significant bits of value. */ +func BrotliReverseBits8(num uint64) uint64 { + return uint64(kReverseBits[num]) +} + +/* Stores code in table[0], table[step], table[2*step], ..., table[end] */ +/* Assumes that end is an integer multiple of step */ +func ReplicateValue(table []HuffmanCode, step int, end int, code HuffmanCode) { + for { + end -= step + table[end] = code + if end <= 0 { + break + } + } +} + +/* Returns the table width of the next 2nd level table. |count| is the histogram + of bit lengths for the remaining symbols, |len| is the code length of the + next processed symbol. */ +func NextTableBitSize(count []uint16, len int, root_bits int) int { + var left int = 1 << uint(len-root_bits) + for len < BROTLI_HUFFMAN_MAX_CODE_LENGTH { + left -= int(count[len]) + if left <= 0 { + break + } + len++ + left <<= 1 + } + + return len - root_bits +} + +func BrotliBuildCodeLengthsHuffmanTable(table []HuffmanCode, code_lengths []byte, count []uint16) { + var code HuffmanCode /* current table entry */ /* symbol index in original or sorted table */ /* prefix code */ /* prefix code addend */ /* step size to replicate values in current table */ /* size of current table */ /* symbols sorted by code length */ + var symbol int + var key uint64 + var key_step uint64 + var step int + var table_size int + var sorted [BROTLI_CODE_LENGTH_CODES]int + var offset [BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + 1]int + var bits int + var bits_count int + /* offsets in sorted table for each length */ + assert(BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH <= BROTLI_REVERSE_BITS_MAX) + + /* Generate offsets into sorted symbol table by code length. */ + symbol = -1 + + bits = 1 + var i int + for i = 0; i < BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH; i++ { + symbol += int(count[bits]) + offset[bits] = symbol + bits++ + } + + /* Symbols with code length 0 are placed after all other symbols. */ + offset[0] = BROTLI_CODE_LENGTH_CODES - 1 + + /* Sort symbols by length, by symbol order within each length. */ + symbol = BROTLI_CODE_LENGTH_CODES + + for { + var i int + for i = 0; i < 6; i++ { + symbol-- + sorted[offset[code_lengths[symbol]]] = symbol + offset[code_lengths[symbol]]-- + } + if symbol == 0 { + break + } + } + + table_size = 1 << BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH + + /* Special case: all symbols but one have 0 code length. */ + if offset[0] == 0 { + code = ConstructHuffmanCode(0, uint16(sorted[0])) + for key = 0; key < uint64(table_size); key++ { + table[key] = code + } + + return + } + + /* Fill in table. */ + key = 0 + + key_step = BROTLI_REVERSE_BITS_LOWEST + symbol = 0 + bits = 1 + step = 2 + for { + for bits_count = int(count[bits]); bits_count != 0; bits_count-- { + code = ConstructHuffmanCode(byte(bits), uint16(sorted[symbol])) + symbol++ + ReplicateValue(table[BrotliReverseBits8(key):], step, table_size, code) + key += key_step + } + + step <<= 1 + key_step >>= 1 + bits++ + if bits > BROTLI_HUFFMAN_MAX_CODE_LENGTH_CODE_LENGTH { + break + } + } +} + +func BrotliBuildHuffmanTable(root_table []HuffmanCode, root_bits int, symbol_lists SymbolList, count []uint16) uint32 { + var code HuffmanCode /* current table entry */ /* next available space in table */ /* current code length */ /* symbol index in original or sorted table */ /* prefix code */ /* prefix code addend */ /* 2nd level table prefix code */ /* 2nd level table prefix code addend */ /* step size to replicate values in current table */ /* key length of current table */ /* size of current table */ /* sum of root table size and 2nd level table sizes */ + var table []HuffmanCode + var len int + var symbol int + var key uint64 + var key_step uint64 + var sub_key uint64 + var sub_key_step uint64 + var step int + var table_bits int + var table_size int + var total_size int + var max_length int = -1 + var bits int + var bits_count int + + assert(root_bits <= BROTLI_REVERSE_BITS_MAX) + assert(BROTLI_HUFFMAN_MAX_CODE_LENGTH-root_bits <= BROTLI_REVERSE_BITS_MAX) + + for SymbolListGet(symbol_lists, max_length) == 0xFFFF { + max_length-- + } + max_length += BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + table = root_table + table_bits = root_bits + table_size = 1 << uint(table_bits) + total_size = table_size + + /* Fill in the root table. Reduce the table size to if possible, + and create the repetitions by memcpy. */ + if table_bits > max_length { + table_bits = max_length + table_size = 1 << uint(table_bits) + } + + key = 0 + key_step = BROTLI_REVERSE_BITS_LOWEST + bits = 1 + step = 2 + for { + symbol = bits - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1) + for bits_count = int(count[bits]); bits_count != 0; bits_count-- { + symbol = int(SymbolListGet(symbol_lists, symbol)) + code = ConstructHuffmanCode(byte(bits), uint16(symbol)) + ReplicateValue(table[BrotliReverseBits8(key):], step, table_size, code) + key += key_step + } + + step <<= 1 + key_step >>= 1 + bits++ + if bits > table_bits { + break + } + } + + /* If root_bits != table_bits then replicate to fill the remaining slots. */ + for total_size != table_size { + copy(table[table_size:], table[:uint(table_size)]) + table_size <<= 1 + } + + /* Fill in 2nd level tables and add pointers to root table. */ + key_step = BROTLI_REVERSE_BITS_LOWEST >> uint(root_bits-1) + + sub_key = BROTLI_REVERSE_BITS_LOWEST << 1 + sub_key_step = BROTLI_REVERSE_BITS_LOWEST + len = root_bits + 1 + step = 2 + for ; len <= max_length; len++ { + symbol = len - (BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1) + for ; count[len] != 0; count[len]-- { + if sub_key == BROTLI_REVERSE_BITS_LOWEST<<1 { + table = table[table_size:] + table_bits = NextTableBitSize(count, int(len), root_bits) + table_size = 1 << uint(table_bits) + total_size += table_size + sub_key = BrotliReverseBits8(key) + key += key_step + root_table[sub_key] = ConstructHuffmanCode(byte(table_bits+root_bits), uint16(uint64(uint(-cap(table)+cap(root_table)))-sub_key)) + sub_key = 0 + } + + symbol = int(SymbolListGet(symbol_lists, symbol)) + code = ConstructHuffmanCode(byte(len-root_bits), uint16(symbol)) + ReplicateValue(table[BrotliReverseBits8(sub_key):], step, table_size, code) + sub_key += sub_key_step + } + + step <<= 1 + sub_key_step >>= 1 + } + + return uint32(total_size) +} + +func BrotliBuildSimpleHuffmanTable(table []HuffmanCode, root_bits int, val []uint16, num_symbols uint32) uint32 { + var table_size uint32 = 1 + var goal_size uint32 = 1 << uint(root_bits) + switch num_symbols { + case 0: + table[0] = ConstructHuffmanCode(0, val[0]) + + case 1: + if val[1] > val[0] { + table[0] = ConstructHuffmanCode(1, val[0]) + table[1] = ConstructHuffmanCode(1, val[1]) + } else { + table[0] = ConstructHuffmanCode(1, val[1]) + table[1] = ConstructHuffmanCode(1, val[0]) + } + + table_size = 2 + + case 2: + table[0] = ConstructHuffmanCode(1, val[0]) + table[2] = ConstructHuffmanCode(1, val[0]) + if val[2] > val[1] { + table[1] = ConstructHuffmanCode(2, val[1]) + table[3] = ConstructHuffmanCode(2, val[2]) + } else { + table[1] = ConstructHuffmanCode(2, val[2]) + table[3] = ConstructHuffmanCode(2, val[1]) + } + + table_size = 4 + case 3: + { + var i int + var k int + for i = 0; i < 3; i++ { + for k = i + 1; k < 4; k++ { + if val[k] < val[i] { + var t uint16 = val[k] + val[k] = val[i] + val[i] = t + } + } + } + + table[0] = ConstructHuffmanCode(2, val[0]) + table[2] = ConstructHuffmanCode(2, val[1]) + table[1] = ConstructHuffmanCode(2, val[2]) + table[3] = ConstructHuffmanCode(2, val[3]) + table_size = 4 + break + } + fallthrough + case 4: + { + if val[3] < val[2] { + var t uint16 = val[3] + val[3] = val[2] + val[2] = t + } + + table[0] = ConstructHuffmanCode(1, val[0]) + table[1] = ConstructHuffmanCode(2, val[1]) + table[2] = ConstructHuffmanCode(1, val[0]) + table[3] = ConstructHuffmanCode(3, val[2]) + table[4] = ConstructHuffmanCode(1, val[0]) + table[5] = ConstructHuffmanCode(2, val[1]) + table[6] = ConstructHuffmanCode(1, val[0]) + table[7] = ConstructHuffmanCode(3, val[3]) + table_size = 8 + break + } + } + + for table_size != goal_size { + copy(table[table_size:], table[:uint(table_size)]) + table_size <<= 1 + } + + return goal_size +} diff --git a/literal_cost.go b/literal_cost.go new file mode 100644 index 0000000..f117735 --- /dev/null +++ b/literal_cost.go @@ -0,0 +1,182 @@ +package brotli + +func UTF8Position(last uint, c uint, clamp uint) uint { + if c < 128 { + return 0 /* Next one is the 'Byte 1' again. */ + } else if c >= 192 { /* Next one is the 'Byte 2' of utf-8 encoding. */ + return brotli_min_size_t(1, clamp) + } else { + /* Let's decide over the last byte if this ends the sequence. */ + if last < 0xE0 { + return 0 /* Completed two or three byte coding. */ /* Next one is the 'Byte 3' of utf-8 encoding. */ + } else { + return brotli_min_size_t(2, clamp) + } + } +} + +func DecideMultiByteStatsLevel(pos uint, len uint, mask uint, data []byte) uint { + var counts = [3]uint{0} /* should be 2, but 1 compresses better. */ + var max_utf8 uint = 1 + var last_c uint = 0 + var i uint + for i = 0; i < len; i++ { + var c uint = uint(data[(pos+i)&mask]) + counts[UTF8Position(last_c, c, 2)]++ + last_c = c + } + + if counts[2] < 500 { + max_utf8 = 1 + } + + if counts[1]+counts[2] < 25 { + max_utf8 = 0 + } + + return max_utf8 +} + +func EstimateBitCostsForLiteralsUTF8(pos uint, len uint, mask uint, data []byte, cost []float32) { + var max_utf8 uint = DecideMultiByteStatsLevel(pos, uint(len), mask, data) + /* Bootstrap histograms. */ + var histogram = [3][256]uint{[256]uint{0}} + var window_half uint = 495 + var in_window uint = brotli_min_size_t(window_half, uint(len)) + var in_window_utf8 = [3]uint{0} + /* max_utf8 is 0 (normal ASCII single byte modeling), + 1 (for 2-byte UTF-8 modeling), or 2 (for 3-byte UTF-8 modeling). */ + + var i uint + { + var last_c uint = 0 + var utf8_pos uint = 0 + for i = 0; i < in_window; i++ { + var c uint = uint(data[(pos+i)&mask]) + histogram[utf8_pos][c]++ + in_window_utf8[utf8_pos]++ + utf8_pos = UTF8Position(last_c, c, max_utf8) + last_c = c + } + } + + /* Compute bit costs with sliding window. */ + for i = 0; i < len; i++ { + if i >= window_half { + var c uint + var last_c uint + if i < window_half+1 { + c = 0 + } else { + c = uint(data[(pos+i-window_half-1)&mask]) + } + if i < window_half+2 { + last_c = 0 + } else { + last_c = uint(data[(pos+i-window_half-2)&mask]) + } + /* Remove a byte in the past. */ + + var utf8_pos2 uint = UTF8Position(last_c, c, max_utf8) + histogram[utf8_pos2][data[(pos+i-window_half)&mask]]-- + in_window_utf8[utf8_pos2]-- + } + + if i+window_half < len { + var c uint = uint(data[(pos+i+window_half-1)&mask]) + var last_c uint = uint(data[(pos+i+window_half-2)&mask]) + /* Add a byte in the future. */ + + var utf8_pos2 uint = UTF8Position(last_c, c, max_utf8) + histogram[utf8_pos2][data[(pos+i+window_half)&mask]]++ + in_window_utf8[utf8_pos2]++ + } + { + var c uint + var last_c uint + if i < 1 { + c = 0 + } else { + c = uint(data[(pos+i-1)&mask]) + } + if i < 2 { + last_c = 0 + } else { + last_c = uint(data[(pos+i-2)&mask]) + } + var utf8_pos uint = UTF8Position(last_c, c, max_utf8) + var masked_pos uint = (pos + i) & mask + var histo uint = histogram[utf8_pos][data[masked_pos]] + var lit_cost float64 + if histo == 0 { + histo = 1 + } + + lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo) + lit_cost += 0.02905 + if lit_cost < 1.0 { + lit_cost *= 0.5 + lit_cost += 0.5 + } + + /* Make the first bytes more expensive -- seems to help, not sure why. + Perhaps because the entropy source is changing its properties + rapidly in the beginning of the file, perhaps because the beginning + of the data is a statistical "anomaly". */ + if i < 2000 { + lit_cost += 0.7 - (float64(2000-i) / 2000.0 * 0.35) + } + + cost[i] = float32(lit_cost) + } + } +} + +func BrotliEstimateBitCostsForLiterals(pos uint, len uint, mask uint, data []byte, cost []float32) { + if BrotliIsMostlyUTF8(data, pos, mask, uint(len), kMinUTF8Ratio) { + EstimateBitCostsForLiteralsUTF8(pos, uint(len), mask, data, cost) + return + } else { + var histogram = [256]uint{0} + var window_half uint = 2000 + var in_window uint = brotli_min_size_t(window_half, uint(len)) + var i uint + /* Bootstrap histogram. */ + for i = 0; i < in_window; i++ { + histogram[data[(pos+i)&mask]]++ + } + + /* Compute bit costs with sliding window. */ + for i = 0; i < len; i++ { + var histo uint + if i >= window_half { + /* Remove a byte in the past. */ + histogram[data[(pos+i-window_half)&mask]]-- + + in_window-- + } + + if i+window_half < len { + /* Add a byte in the future. */ + histogram[data[(pos+i+window_half)&mask]]++ + + in_window++ + } + + histo = histogram[data[(pos+i)&mask]] + if histo == 0 { + histo = 1 + } + { + var lit_cost float64 = FastLog2(in_window) - FastLog2(histo) + lit_cost += 0.029 + if lit_cost < 1.0 { + lit_cost *= 0.5 + lit_cost += 0.5 + } + + cost[i] = float32(lit_cost) + } + } + } +} diff --git a/memory.go b/memory.go new file mode 100644 index 0000000..affa390 --- /dev/null +++ b/memory.go @@ -0,0 +1,58 @@ +package brotli + +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Macros for memory management. */ + +/* +Dynamically grows array capacity to at least the requested size +T: data type +A: array +C: capacity +R: requested size +*/ +func brotli_ensure_capacity_uint8_t(a *[]byte, c *uint, r uint) { + if *c < r { + var new_size uint = *c + if new_size == 0 { + new_size = r + } + + for new_size < r { + new_size *= 2 + } + var new_array []byte = make([]byte, new_size) + if *c != 0 { + copy(new_array, (*a)[:*c]) + } + + *a = new_array + *c = new_size + } +} + +func brotli_ensure_capacity_uint32_t(a *[]uint32, c *uint, r uint) { + var new_array []uint32 + if *c < r { + var new_size uint = *c + if new_size == 0 { + new_size = r + } + + for new_size < r { + new_size *= 2 + } + + new_array = make([]uint32, new_size) + if *c != 0 { + copy(new_array, (*a)[:*c]) + } + + *a = new_array + *c = new_size + } +} diff --git a/metablock.go b/metablock.go new file mode 100644 index 0000000..84e8a76 --- /dev/null +++ b/metablock.go @@ -0,0 +1,585 @@ +package brotli + +/* Copyright 2014 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Brotli bit stream functions to support the low level format. There are no + compression algorithms here, just the right ordering of bits to match the + specs. */ +/* Copyright 2014 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions to convert brotli-related data structures into the + brotli bit stream. The functions here operate under + assumption that there is enough space in the storage, i.e., there are + no out-of-range checks anywhere. + + These functions do bit addressing into a byte array. The byte array + is called "storage" and the index to the bit is called storage_ix + in function arguments. */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Algorithms for distributing the literals and commands of a metablock between + block types and contexts. */ +type MetaBlockSplit struct { + literal_split BlockSplit + command_split BlockSplit + distance_split BlockSplit + literal_context_map []uint32 + literal_context_map_size uint + distance_context_map []uint32 + distance_context_map_size uint + literal_histograms []HistogramLiteral + literal_histograms_size uint + command_histograms []HistogramCommand + command_histograms_size uint + distance_histograms []HistogramDistance + distance_histograms_size uint +} + +func InitMetaBlockSplit(mb *MetaBlockSplit) { + BrotliInitBlockSplit(&mb.literal_split) + BrotliInitBlockSplit(&mb.command_split) + BrotliInitBlockSplit(&mb.distance_split) + mb.literal_context_map = nil + mb.literal_context_map_size = 0 + mb.distance_context_map = nil + mb.distance_context_map_size = 0 + mb.literal_histograms = nil + mb.literal_histograms_size = 0 + mb.command_histograms = nil + mb.command_histograms_size = 0 + mb.distance_histograms = nil + mb.distance_histograms_size = 0 +} + +func DestroyMetaBlockSplit(mb *MetaBlockSplit) { + BrotliDestroyBlockSplit(&mb.literal_split) + BrotliDestroyBlockSplit(&mb.command_split) + BrotliDestroyBlockSplit(&mb.distance_split) + mb.literal_context_map = nil + mb.distance_context_map = nil + mb.literal_histograms = nil + mb.command_histograms = nil + mb.distance_histograms = nil +} + +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Algorithms for distributing the literals and commands of a metablock between + block types and contexts. */ +func BrotliInitDistanceParams(params *BrotliEncoderParams, npostfix uint32, ndirect uint32) { + var dist_params *BrotliDistanceParams = ¶ms.dist + var alphabet_size uint32 + var max_distance uint32 + + dist_params.distance_postfix_bits = npostfix + dist_params.num_direct_distance_codes = ndirect + + alphabet_size = uint32(BROTLI_DISTANCE_ALPHABET_SIZE(uint(npostfix), uint(ndirect), BROTLI_MAX_DISTANCE_BITS)) + max_distance = ndirect + (1 << (BROTLI_MAX_DISTANCE_BITS + npostfix + 2)) - (1 << (npostfix + 2)) + + if params.large_window { + var bound = [BROTLI_MAX_NPOSTFIX + 1]uint32{0, 4, 12, 28} + var postfix uint32 = 1 << npostfix + alphabet_size = uint32(BROTLI_DISTANCE_ALPHABET_SIZE(uint(npostfix), uint(ndirect), BROTLI_LARGE_MAX_DISTANCE_BITS)) + + /* The maximum distance is set so that no distance symbol used can encode + a distance larger than BROTLI_MAX_ALLOWED_DISTANCE with all + its extra bits set. */ + if ndirect < bound[npostfix] { + max_distance = BROTLI_MAX_ALLOWED_DISTANCE - (bound[npostfix] - ndirect) + } else if ndirect >= bound[npostfix]+postfix { + max_distance = (3 << 29) - 4 + (ndirect - bound[npostfix]) + } else { + max_distance = BROTLI_MAX_ALLOWED_DISTANCE + } + } + + dist_params.alphabet_size = alphabet_size + dist_params.max_distance = uint(max_distance) +} + +func RecomputeDistancePrefixes(cmds []Command, num_commands uint, orig_params *BrotliDistanceParams, new_params *BrotliDistanceParams) { + var i uint + + if orig_params.distance_postfix_bits == new_params.distance_postfix_bits && orig_params.num_direct_distance_codes == new_params.num_direct_distance_codes { + return + } + + for i = 0; i < num_commands; i++ { + var cmd *Command = &cmds[i] + if CommandCopyLen(cmd) != 0 && cmd.cmd_prefix_ >= 128 { + PrefixEncodeCopyDistance(uint(CommandRestoreDistanceCode(cmd, orig_params)), uint(new_params.num_direct_distance_codes), uint(new_params.distance_postfix_bits), &cmd.dist_prefix_, &cmd.dist_extra_) + } + } +} + +func ComputeDistanceCost(cmds []Command, num_commands uint, orig_params *BrotliDistanceParams, new_params *BrotliDistanceParams, cost *float64) bool { + var i uint + var equal_params bool = false + var dist_prefix uint16 + var dist_extra uint32 + var extra_bits float64 = 0.0 + var histo HistogramDistance + HistogramClearDistance(&histo) + + if orig_params.distance_postfix_bits == new_params.distance_postfix_bits && orig_params.num_direct_distance_codes == new_params.num_direct_distance_codes { + equal_params = true + } + + for i = 0; i < num_commands; i++ { + var cmd *Command = &cmds[i] + if CommandCopyLen(cmd) != 0 && cmd.cmd_prefix_ >= 128 { + if equal_params { + dist_prefix = cmd.dist_prefix_ + } else { + var distance uint32 = CommandRestoreDistanceCode(cmd, orig_params) + if distance > uint32(new_params.max_distance) { + return false + } + + PrefixEncodeCopyDistance(uint(distance), uint(new_params.num_direct_distance_codes), uint(new_params.distance_postfix_bits), &dist_prefix, &dist_extra) + } + + HistogramAddDistance(&histo, uint(dist_prefix)&0x3FF) + extra_bits += float64(dist_prefix >> 10) + } + } + + *cost = BrotliPopulationCostDistance(&histo) + extra_bits + return true +} + +var BrotliBuildMetaBlock_kMaxNumberOfHistograms uint = 256 + +func BrotliBuildMetaBlock(ringbuffer []byte, pos uint, mask uint, params *BrotliEncoderParams, prev_byte byte, prev_byte2 byte, cmds []Command, num_commands uint, literal_context_mode int, mb *MetaBlockSplit) { + var distance_histograms []HistogramDistance + var literal_histograms []HistogramLiteral + var literal_context_modes []int = nil + var literal_histograms_size uint + var distance_histograms_size uint + var i uint + var literal_context_multiplier uint = 1 + var npostfix uint32 + var ndirect_msb uint32 = 0 + var check_orig bool = true + var best_dist_cost float64 = 1e99 + var orig_params BrotliEncoderParams = *params + /* Histogram ids need to fit in one byte. */ + + var new_params BrotliEncoderParams = *params + + for npostfix = 0; npostfix <= BROTLI_MAX_NPOSTFIX; npostfix++ { + for ; ndirect_msb < 16; ndirect_msb++ { + var ndirect uint32 = ndirect_msb << npostfix + var skip bool + var dist_cost float64 + BrotliInitDistanceParams(&new_params, npostfix, ndirect) + if npostfix == orig_params.dist.distance_postfix_bits && ndirect == orig_params.dist.num_direct_distance_codes { + check_orig = false + } + + skip = !ComputeDistanceCost(cmds, num_commands, &orig_params.dist, &new_params.dist, &dist_cost) + if skip || (dist_cost > best_dist_cost) { + break + } + + best_dist_cost = dist_cost + params.dist = new_params.dist + } + + if ndirect_msb > 0 { + ndirect_msb-- + } + ndirect_msb /= 2 + } + + if check_orig { + var dist_cost float64 + ComputeDistanceCost(cmds, num_commands, &orig_params.dist, &orig_params.dist, &dist_cost) + if dist_cost < best_dist_cost { + /* NB: currently unused; uncomment when more param tuning is added. */ + /* best_dist_cost = dist_cost; */ + params.dist = orig_params.dist + } + } + + RecomputeDistancePrefixes(cmds, num_commands, &orig_params.dist, ¶ms.dist) + + BrotliSplitBlock(cmds, num_commands, ringbuffer, pos, mask, params, &mb.literal_split, &mb.command_split, &mb.distance_split) + + if !params.disable_literal_context_modeling { + literal_context_multiplier = 1 << BROTLI_LITERAL_CONTEXT_BITS + literal_context_modes = make([]int, (mb.literal_split.num_types)) + for i = 0; i < mb.literal_split.num_types; i++ { + literal_context_modes[i] = literal_context_mode + } + } + + literal_histograms_size = mb.literal_split.num_types * literal_context_multiplier + literal_histograms = make([]HistogramLiteral, literal_histograms_size) + ClearHistogramsLiteral(literal_histograms, literal_histograms_size) + + distance_histograms_size = mb.distance_split.num_types << BROTLI_DISTANCE_CONTEXT_BITS + distance_histograms = make([]HistogramDistance, distance_histograms_size) + ClearHistogramsDistance(distance_histograms, distance_histograms_size) + + assert(mb.command_histograms == nil) + mb.command_histograms_size = mb.command_split.num_types + mb.command_histograms = make([]HistogramCommand, (mb.command_histograms_size)) + ClearHistogramsCommand(mb.command_histograms, mb.command_histograms_size) + + BrotliBuildHistogramsWithContext(cmds, num_commands, &mb.literal_split, &mb.command_split, &mb.distance_split, ringbuffer, pos, mask, prev_byte, prev_byte2, literal_context_modes, literal_histograms, mb.command_histograms, distance_histograms) + literal_context_modes = nil + + assert(mb.literal_context_map == nil) + mb.literal_context_map_size = mb.literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS + mb.literal_context_map = make([]uint32, (mb.literal_context_map_size)) + + assert(mb.literal_histograms == nil) + mb.literal_histograms_size = mb.literal_context_map_size + mb.literal_histograms = make([]HistogramLiteral, (mb.literal_histograms_size)) + + BrotliClusterHistogramsLiteral(literal_histograms, literal_histograms_size, BrotliBuildMetaBlock_kMaxNumberOfHistograms, mb.literal_histograms, &mb.literal_histograms_size, mb.literal_context_map) + literal_histograms = nil + + if params.disable_literal_context_modeling { + /* Distribute assignment to all contexts. */ + for i = mb.literal_split.num_types; i != 0; { + var j uint = 0 + i-- + for ; j < 1< 0 { + var entropy [BROTLI_MAX_STATIC_CONTEXTS]float64 + var combined_histo []HistogramLiteral = make([]HistogramLiteral, (2 * num_contexts)) + var combined_entropy [2 * BROTLI_MAX_STATIC_CONTEXTS]float64 + var diff = [2]float64{0.0} + /* Try merging the set of histograms for the current block type with the + respective set of histograms for the last and second last block types. + Decide over the split based on the total reduction of entropy across + all contexts. */ + + var i uint + for i = 0; i < num_contexts; i++ { + var curr_histo_ix uint = self.curr_histogram_ix_ + i + var j uint + entropy[i] = BitsEntropy(histograms[curr_histo_ix].data_[:], self.alphabet_size_) + for j = 0; j < 2; j++ { + var jx uint = j*num_contexts + i + var last_histogram_ix uint = self.last_histogram_ix_[j] + i + combined_histo[jx] = histograms[curr_histo_ix] + HistogramAddHistogramLiteral(&combined_histo[jx], &histograms[last_histogram_ix]) + combined_entropy[jx] = BitsEntropy(combined_histo[jx].data_[0:], self.alphabet_size_) + diff[j] += combined_entropy[jx] - entropy[i] - last_entropy[jx] + } + } + + if split.num_types < self.max_block_types_ && diff[0] > self.split_threshold_ && diff[1] > self.split_threshold_ { + /* Create new block. */ + split.lengths[self.num_blocks_] = uint32(self.block_size_) + + split.types[self.num_blocks_] = byte(split.num_types) + self.last_histogram_ix_[1] = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = split.num_types * num_contexts + for i = 0; i < num_contexts; i++ { + last_entropy[num_contexts+i] = last_entropy[i] + last_entropy[i] = entropy[i] + } + + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_ += num_contexts + if self.curr_histogram_ix_ < *self.histograms_size_ { + ClearHistogramsLiteral(self.histograms_[self.curr_histogram_ix_:], self.num_contexts_) + } + + self.block_size_ = 0 + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else if diff[1] < diff[0]-20.0 { + split.lengths[self.num_blocks_] = uint32(self.block_size_) + split.types[self.num_blocks_] = split.types[self.num_blocks_-2] + /* Combine this block with second last block. */ + + var tmp uint = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] + self.last_histogram_ix_[1] = tmp + for i = 0; i < num_contexts; i++ { + histograms[self.last_histogram_ix_[0]+i] = combined_histo[num_contexts+i] + last_entropy[num_contexts+i] = last_entropy[i] + last_entropy[i] = combined_entropy[num_contexts+i] + HistogramClearLiteral(&histograms[self.curr_histogram_ix_+i]) + } + + self.num_blocks_++ + self.block_size_ = 0 + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else { + /* Combine this block with last block. */ + split.lengths[self.num_blocks_-1] += uint32(self.block_size_) + + for i = 0; i < num_contexts; i++ { + histograms[self.last_histogram_ix_[0]+i] = combined_histo[i] + last_entropy[i] = combined_entropy[i] + if split.num_types == 1 { + last_entropy[num_contexts+i] = last_entropy[i] + } + + HistogramClearLiteral(&histograms[self.curr_histogram_ix_+i]) + } + + self.block_size_ = 0 + self.merge_last_count_++ + if self.merge_last_count_ > 1 { + self.target_block_size_ += self.min_block_size_ + } + } + + combined_histo = nil + } + + if is_final { + *self.histograms_size_ = split.num_types * num_contexts + split.num_blocks = self.num_blocks_ + } +} + +/* Adds the next symbol to the current block type and context. When the + current block reaches the target size, decides on merging the block. */ +func ContextBlockSplitterAddSymbol(self *ContextBlockSplitter, symbol uint, context uint) { + HistogramAddLiteral(&self.histograms_[self.curr_histogram_ix_+context], symbol) + self.block_size_++ + if self.block_size_ == self.target_block_size_ { + ContextBlockSplitterFinishBlock(self, false) /* is_final = */ + } +} + +func MapStaticContexts(num_contexts uint, static_context_map []uint32, mb *MetaBlockSplit) { + var i uint + assert(mb.literal_context_map == nil) + mb.literal_context_map_size = mb.literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS + mb.literal_context_map = make([]uint32, (mb.literal_context_map_size)) + + for i = 0; i < mb.literal_split.num_types; i++ { + var offset uint32 = uint32(i * num_contexts) + var j uint + for j = 0; j < 1<= 128 { + BlockSplitterAddSymbolDistance(&dist_blocks, uint(cmd.dist_prefix_)&0x3FF) + } + } + } + + if num_contexts == 1 { + BlockSplitterFinishBlockLiteral(&lit_blocks.plain, true) /* is_final = */ + } else { + ContextBlockSplitterFinishBlock(&lit_blocks.ctx, true) /* is_final = */ + } + + BlockSplitterFinishBlockCommand(&cmd_blocks, true) /* is_final = */ + BlockSplitterFinishBlockDistance(&dist_blocks, true) /* is_final = */ + + if num_contexts > 1 { + MapStaticContexts(num_contexts, static_context_map, mb) + } +} + +func BrotliBuildMetaBlockGreedy(ringbuffer []byte, pos uint, mask uint, prev_byte byte, prev_byte2 byte, literal_context_lut ContextLut, num_contexts uint, static_context_map []uint32, commands []Command, n_commands uint, mb *MetaBlockSplit) { + if num_contexts == 1 { + BrotliBuildMetaBlockGreedyInternal(ringbuffer, pos, mask, prev_byte, prev_byte2, literal_context_lut, 1, nil, commands, n_commands, mb) + } else { + BrotliBuildMetaBlockGreedyInternal(ringbuffer, pos, mask, prev_byte, prev_byte2, literal_context_lut, num_contexts, static_context_map, commands, n_commands, mb) + } +} + +func BrotliOptimizeHistograms(num_distance_codes uint32, mb *MetaBlockSplit) { + var good_for_rle [BROTLI_NUM_COMMAND_SYMBOLS]byte + var i uint + for i = 0; i < mb.literal_histograms_size; i++ { + BrotliOptimizeHuffmanCountsForRle(256, mb.literal_histograms[i].data_[:], good_for_rle[:]) + } + + for i = 0; i < mb.command_histograms_size; i++ { + BrotliOptimizeHuffmanCountsForRle(BROTLI_NUM_COMMAND_SYMBOLS, mb.command_histograms[i].data_[:], good_for_rle[:]) + } + + for i = 0; i < mb.distance_histograms_size; i++ { + BrotliOptimizeHuffmanCountsForRle(uint(num_distance_codes), mb.distance_histograms[i].data_[:], good_for_rle[:]) + } +} diff --git a/metablock_command.go b/metablock_command.go new file mode 100644 index 0000000..d9d9086 --- /dev/null +++ b/metablock_command.go @@ -0,0 +1,163 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Greedy block splitter for one block category (literal, command or distance). + */ +type BlockSplitterCommand struct { + alphabet_size_ uint + min_block_size_ uint + split_threshold_ float64 + num_blocks_ uint + split_ *BlockSplit + histograms_ []HistogramCommand + histograms_size_ *uint + target_block_size_ uint + block_size_ uint + curr_histogram_ix_ uint + last_histogram_ix_ [2]uint + last_entropy_ [2]float64 + merge_last_count_ uint +} + +func InitBlockSplitterCommand(self *BlockSplitterCommand, alphabet_size uint, min_block_size uint, split_threshold float64, num_symbols uint, split *BlockSplit, histograms *[]HistogramCommand, histograms_size *uint) { + var max_num_blocks uint = num_symbols/min_block_size + 1 + var max_num_types uint = brotli_min_size_t(max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES+1) + /* We have to allocate one more histogram than the maximum number of block + types for the current histogram when the meta-block is too big. */ + self.alphabet_size_ = alphabet_size + + self.min_block_size_ = min_block_size + self.split_threshold_ = split_threshold + self.num_blocks_ = 0 + self.split_ = split + self.histograms_size_ = histograms_size + self.target_block_size_ = min_block_size + self.block_size_ = 0 + self.curr_histogram_ix_ = 0 + self.merge_last_count_ = 0 + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, max_num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, max_num_blocks) + self.split_.num_blocks = max_num_blocks + assert(*histograms == nil) + *histograms_size = max_num_types + *histograms = make([]HistogramCommand, (*histograms_size)) + self.histograms_ = *histograms + + /* Clear only current histogram. */ + HistogramClearCommand(&self.histograms_[0]) + + self.last_histogram_ix_[1] = 0 + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] +} + +/* Does either of three things: + (1) emits the current block with a new block type; + (2) emits the current block with the type of the second last block; + (3) merges the current block with the last block. */ +func BlockSplitterFinishBlockCommand(self *BlockSplitterCommand, is_final bool) { + var split *BlockSplit = self.split_ + var last_entropy []float64 = self.last_entropy_[:] + var histograms []HistogramCommand = self.histograms_ + self.block_size_ = brotli_max_size_t(self.block_size_, self.min_block_size_) + if self.num_blocks_ == 0 { + /* Create first block. */ + split.lengths[0] = uint32(self.block_size_) + + split.types[0] = 0 + last_entropy[0] = BitsEntropy(histograms[0].data_[:], self.alphabet_size_) + last_entropy[1] = last_entropy[0] + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearCommand(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + } else if self.block_size_ > 0 { + var entropy float64 = BitsEntropy(histograms[self.curr_histogram_ix_].data_[:], self.alphabet_size_) + var combined_histo [2]HistogramCommand + var combined_entropy [2]float64 + var diff [2]float64 + var j uint + for j = 0; j < 2; j++ { + var last_histogram_ix uint = self.last_histogram_ix_[j] + combined_histo[j] = histograms[self.curr_histogram_ix_] + HistogramAddHistogramCommand(&combined_histo[j], &histograms[last_histogram_ix]) + combined_entropy[j] = BitsEntropy(combined_histo[j].data_[0:], self.alphabet_size_) + diff[j] = combined_entropy[j] - entropy - last_entropy[j] + } + + if split.num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES && diff[0] > self.split_threshold_ && diff[1] > self.split_threshold_ { + /* Create new block. */ + split.lengths[self.num_blocks_] = uint32(self.block_size_) + + split.types[self.num_blocks_] = byte(split.num_types) + self.last_histogram_ix_[1] = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = uint(byte(split.num_types)) + last_entropy[1] = last_entropy[0] + last_entropy[0] = entropy + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearCommand(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else if diff[1] < diff[0]-20.0 { + split.lengths[self.num_blocks_] = uint32(self.block_size_) + split.types[self.num_blocks_] = split.types[self.num_blocks_-2] + /* Combine this block with second last block. */ + + var tmp uint = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] + self.last_histogram_ix_[1] = tmp + histograms[self.last_histogram_ix_[0]] = combined_histo[1] + last_entropy[1] = last_entropy[0] + last_entropy[0] = combined_entropy[1] + self.num_blocks_++ + self.block_size_ = 0 + HistogramClearCommand(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else { + /* Combine this block with last block. */ + split.lengths[self.num_blocks_-1] += uint32(self.block_size_) + + histograms[self.last_histogram_ix_[0]] = combined_histo[0] + last_entropy[0] = combined_entropy[0] + if split.num_types == 1 { + last_entropy[1] = last_entropy[0] + } + + self.block_size_ = 0 + HistogramClearCommand(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_++ + if self.merge_last_count_ > 1 { + self.target_block_size_ += self.min_block_size_ + } + } + } + + if is_final { + *self.histograms_size_ = split.num_types + split.num_blocks = self.num_blocks_ + } +} + +/* Adds the next symbol to the current histogram. When the current histogram + reaches the target size, decides on merging the block. */ +func BlockSplitterAddSymbolCommand(self *BlockSplitterCommand, symbol uint) { + HistogramAddCommand(&self.histograms_[self.curr_histogram_ix_], symbol) + self.block_size_++ + if self.block_size_ == self.target_block_size_ { + BlockSplitterFinishBlockCommand(self, false) /* is_final = */ + } +} diff --git a/metablock_distance.go b/metablock_distance.go new file mode 100644 index 0000000..0266359 --- /dev/null +++ b/metablock_distance.go @@ -0,0 +1,163 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Greedy block splitter for one block category (literal, command or distance). + */ +type BlockSplitterDistance struct { + alphabet_size_ uint + min_block_size_ uint + split_threshold_ float64 + num_blocks_ uint + split_ *BlockSplit + histograms_ []HistogramDistance + histograms_size_ *uint + target_block_size_ uint + block_size_ uint + curr_histogram_ix_ uint + last_histogram_ix_ [2]uint + last_entropy_ [2]float64 + merge_last_count_ uint +} + +func InitBlockSplitterDistance(self *BlockSplitterDistance, alphabet_size uint, min_block_size uint, split_threshold float64, num_symbols uint, split *BlockSplit, histograms *[]HistogramDistance, histograms_size *uint) { + var max_num_blocks uint = num_symbols/min_block_size + 1 + var max_num_types uint = brotli_min_size_t(max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES+1) + /* We have to allocate one more histogram than the maximum number of block + types for the current histogram when the meta-block is too big. */ + self.alphabet_size_ = alphabet_size + + self.min_block_size_ = min_block_size + self.split_threshold_ = split_threshold + self.num_blocks_ = 0 + self.split_ = split + self.histograms_size_ = histograms_size + self.target_block_size_ = min_block_size + self.block_size_ = 0 + self.curr_histogram_ix_ = 0 + self.merge_last_count_ = 0 + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, max_num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, max_num_blocks) + self.split_.num_blocks = max_num_blocks + assert(*histograms == nil) + *histograms_size = max_num_types + *histograms = make([]HistogramDistance, (*histograms_size)) + self.histograms_ = *histograms + + /* Clear only current histogram. */ + HistogramClearDistance(&self.histograms_[0]) + + self.last_histogram_ix_[1] = 0 + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] +} + +/* Does either of three things: + (1) emits the current block with a new block type; + (2) emits the current block with the type of the second last block; + (3) merges the current block with the last block. */ +func BlockSplitterFinishBlockDistance(self *BlockSplitterDistance, is_final bool) { + var split *BlockSplit = self.split_ + var last_entropy []float64 = self.last_entropy_[:] + var histograms []HistogramDistance = self.histograms_ + self.block_size_ = brotli_max_size_t(self.block_size_, self.min_block_size_) + if self.num_blocks_ == 0 { + /* Create first block. */ + split.lengths[0] = uint32(self.block_size_) + + split.types[0] = 0 + last_entropy[0] = BitsEntropy(histograms[0].data_[:], self.alphabet_size_) + last_entropy[1] = last_entropy[0] + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearDistance(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + } else if self.block_size_ > 0 { + var entropy float64 = BitsEntropy(histograms[self.curr_histogram_ix_].data_[:], self.alphabet_size_) + var combined_histo [2]HistogramDistance + var combined_entropy [2]float64 + var diff [2]float64 + var j uint + for j = 0; j < 2; j++ { + var last_histogram_ix uint = self.last_histogram_ix_[j] + combined_histo[j] = histograms[self.curr_histogram_ix_] + HistogramAddHistogramDistance(&combined_histo[j], &histograms[last_histogram_ix]) + combined_entropy[j] = BitsEntropy(combined_histo[j].data_[0:], self.alphabet_size_) + diff[j] = combined_entropy[j] - entropy - last_entropy[j] + } + + if split.num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES && diff[0] > self.split_threshold_ && diff[1] > self.split_threshold_ { + /* Create new block. */ + split.lengths[self.num_blocks_] = uint32(self.block_size_) + + split.types[self.num_blocks_] = byte(split.num_types) + self.last_histogram_ix_[1] = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = uint(byte(split.num_types)) + last_entropy[1] = last_entropy[0] + last_entropy[0] = entropy + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearDistance(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else if diff[1] < diff[0]-20.0 { + split.lengths[self.num_blocks_] = uint32(self.block_size_) + split.types[self.num_blocks_] = split.types[self.num_blocks_-2] + /* Combine this block with second last block. */ + + var tmp uint = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] + self.last_histogram_ix_[1] = tmp + histograms[self.last_histogram_ix_[0]] = combined_histo[1] + last_entropy[1] = last_entropy[0] + last_entropy[0] = combined_entropy[1] + self.num_blocks_++ + self.block_size_ = 0 + HistogramClearDistance(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else { + /* Combine this block with last block. */ + split.lengths[self.num_blocks_-1] += uint32(self.block_size_) + + histograms[self.last_histogram_ix_[0]] = combined_histo[0] + last_entropy[0] = combined_entropy[0] + if split.num_types == 1 { + last_entropy[1] = last_entropy[0] + } + + self.block_size_ = 0 + HistogramClearDistance(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_++ + if self.merge_last_count_ > 1 { + self.target_block_size_ += self.min_block_size_ + } + } + } + + if is_final { + *self.histograms_size_ = split.num_types + split.num_blocks = self.num_blocks_ + } +} + +/* Adds the next symbol to the current histogram. When the current histogram + reaches the target size, decides on merging the block. */ +func BlockSplitterAddSymbolDistance(self *BlockSplitterDistance, symbol uint) { + HistogramAddDistance(&self.histograms_[self.curr_histogram_ix_], symbol) + self.block_size_++ + if self.block_size_ == self.target_block_size_ { + BlockSplitterFinishBlockDistance(self, false) /* is_final = */ + } +} diff --git a/metablock_literal.go b/metablock_literal.go new file mode 100644 index 0000000..66e78c9 --- /dev/null +++ b/metablock_literal.go @@ -0,0 +1,163 @@ +package brotli + +/* NOLINT(build/header_guard) */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Greedy block splitter for one block category (literal, command or distance). + */ +type BlockSplitterLiteral struct { + alphabet_size_ uint + min_block_size_ uint + split_threshold_ float64 + num_blocks_ uint + split_ *BlockSplit + histograms_ []HistogramLiteral + histograms_size_ *uint + target_block_size_ uint + block_size_ uint + curr_histogram_ix_ uint + last_histogram_ix_ [2]uint + last_entropy_ [2]float64 + merge_last_count_ uint +} + +func InitBlockSplitterLiteral(self *BlockSplitterLiteral, alphabet_size uint, min_block_size uint, split_threshold float64, num_symbols uint, split *BlockSplit, histograms *[]HistogramLiteral, histograms_size *uint) { + var max_num_blocks uint = num_symbols/min_block_size + 1 + var max_num_types uint = brotli_min_size_t(max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES+1) + /* We have to allocate one more histogram than the maximum number of block + types for the current histogram when the meta-block is too big. */ + self.alphabet_size_ = alphabet_size + + self.min_block_size_ = min_block_size + self.split_threshold_ = split_threshold + self.num_blocks_ = 0 + self.split_ = split + self.histograms_size_ = histograms_size + self.target_block_size_ = min_block_size + self.block_size_ = 0 + self.curr_histogram_ix_ = 0 + self.merge_last_count_ = 0 + brotli_ensure_capacity_uint8_t(&split.types, &split.types_alloc_size, max_num_blocks) + brotli_ensure_capacity_uint32_t(&split.lengths, &split.lengths_alloc_size, max_num_blocks) + self.split_.num_blocks = max_num_blocks + assert(*histograms == nil) + *histograms_size = max_num_types + *histograms = make([]HistogramLiteral, (*histograms_size)) + self.histograms_ = *histograms + + /* Clear only current histogram. */ + HistogramClearLiteral(&self.histograms_[0]) + + self.last_histogram_ix_[1] = 0 + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] +} + +/* Does either of three things: + (1) emits the current block with a new block type; + (2) emits the current block with the type of the second last block; + (3) merges the current block with the last block. */ +func BlockSplitterFinishBlockLiteral(self *BlockSplitterLiteral, is_final bool) { + var split *BlockSplit = self.split_ + var last_entropy []float64 = self.last_entropy_[:] + var histograms []HistogramLiteral = self.histograms_ + self.block_size_ = brotli_max_size_t(self.block_size_, self.min_block_size_) + if self.num_blocks_ == 0 { + /* Create first block. */ + split.lengths[0] = uint32(self.block_size_) + + split.types[0] = 0 + last_entropy[0] = BitsEntropy(histograms[0].data_[:], self.alphabet_size_) + last_entropy[1] = last_entropy[0] + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearLiteral(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + } else if self.block_size_ > 0 { + var entropy float64 = BitsEntropy(histograms[self.curr_histogram_ix_].data_[:], self.alphabet_size_) + var combined_histo [2]HistogramLiteral + var combined_entropy [2]float64 + var diff [2]float64 + var j uint + for j = 0; j < 2; j++ { + var last_histogram_ix uint = self.last_histogram_ix_[j] + combined_histo[j] = histograms[self.curr_histogram_ix_] + HistogramAddHistogramLiteral(&combined_histo[j], &histograms[last_histogram_ix]) + combined_entropy[j] = BitsEntropy(combined_histo[j].data_[0:], self.alphabet_size_) + diff[j] = combined_entropy[j] - entropy - last_entropy[j] + } + + if split.num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES && diff[0] > self.split_threshold_ && diff[1] > self.split_threshold_ { + /* Create new block. */ + split.lengths[self.num_blocks_] = uint32(self.block_size_) + + split.types[self.num_blocks_] = byte(split.num_types) + self.last_histogram_ix_[1] = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = uint(byte(split.num_types)) + last_entropy[1] = last_entropy[0] + last_entropy[0] = entropy + self.num_blocks_++ + split.num_types++ + self.curr_histogram_ix_++ + if self.curr_histogram_ix_ < *self.histograms_size_ { + HistogramClearLiteral(&histograms[self.curr_histogram_ix_]) + } + self.block_size_ = 0 + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else if diff[1] < diff[0]-20.0 { + split.lengths[self.num_blocks_] = uint32(self.block_size_) + split.types[self.num_blocks_] = split.types[self.num_blocks_-2] + /* Combine this block with second last block. */ + + var tmp uint = self.last_histogram_ix_[0] + self.last_histogram_ix_[0] = self.last_histogram_ix_[1] + self.last_histogram_ix_[1] = tmp + histograms[self.last_histogram_ix_[0]] = combined_histo[1] + last_entropy[1] = last_entropy[0] + last_entropy[0] = combined_entropy[1] + self.num_blocks_++ + self.block_size_ = 0 + HistogramClearLiteral(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_ = 0 + self.target_block_size_ = self.min_block_size_ + } else { + /* Combine this block with last block. */ + split.lengths[self.num_blocks_-1] += uint32(self.block_size_) + + histograms[self.last_histogram_ix_[0]] = combined_histo[0] + last_entropy[0] = combined_entropy[0] + if split.num_types == 1 { + last_entropy[1] = last_entropy[0] + } + + self.block_size_ = 0 + HistogramClearLiteral(&histograms[self.curr_histogram_ix_]) + self.merge_last_count_++ + if self.merge_last_count_ > 1 { + self.target_block_size_ += self.min_block_size_ + } + } + } + + if is_final { + *self.histograms_size_ = split.num_types + split.num_blocks = self.num_blocks_ + } +} + +/* Adds the next symbol to the current histogram. When the current histogram + reaches the target size, decides on merging the block. */ +func BlockSplitterAddSymbolLiteral(self *BlockSplitterLiteral, symbol uint) { + HistogramAddLiteral(&self.histograms_[self.curr_histogram_ix_], symbol) + self.block_size_++ + if self.block_size_ == self.target_block_size_ { + BlockSplitterFinishBlockLiteral(self, false) /* is_final = */ + } +} diff --git a/params.go b/params.go new file mode 100644 index 0000000..8110b34 --- /dev/null +++ b/params.go @@ -0,0 +1,229 @@ +package brotli + +/** + * Opaque structure that holds encoder state. + * + * Allocated and initialized with ::BrotliEncoderCreateInstance. + * Cleaned up and deallocated with ::BrotliEncoderDestroyInstance. + */ + +/** + * Sets the specified parameter to the given encoder instance. + * + * @param state encoder instance + * @param param parameter to set + * @param value new parameter value + * @returns ::false if parameter is unrecognized, or value is invalid + * @returns ::false if value of parameter can not be changed at current + * encoder state (e.g. when encoding is started, window size might be + * already encoded and therefore it is impossible to change it) + * @returns ::true if value is accepted + * @warning invalid values might be accepted in case they would not break + * encoding process. + */ + +/** + * Creates an instance of ::BrotliEncoderState and initializes it. + * + * @p alloc_func and @p free_func @b MUST be both zero or both non-zero. In the + * case they are both zero, default memory allocators are used. @p opaque is + * passed to @p alloc_func and @p free_func when they are called. @p free_func + * has to return without doing anything when asked to free a NULL pointer. + * + * @param alloc_func custom memory allocation function + * @param free_func custom memory free function + * @param opaque custom memory manager handle + * @returns @c 0 if instance can not be allocated or initialized + * @returns pointer to initialized ::BrotliEncoderState otherwise + */ + +/** + * Deinitializes and frees ::BrotliEncoderState instance. + * + * @param state decoder instance to be cleaned up and deallocated + */ + +/** + * Calculates the output size bound for the given @p input_size. + * + * @warning Result is only valid if quality is at least @c 2 and, in + * case ::BrotliEncoderCompressStream was used, no flushes + * (::BROTLI_OPERATION_FLUSH) were performed. + * + * @param input_size size of projected input + * @returns @c 0 if result does not fit @c size_t + */ + +/** + * Performs one-shot memory-to-memory compression. + * + * Compresses the data in @p input_buffer into @p encoded_buffer, and sets + * @p *encoded_size to the compressed length. + * + * @note If ::BrotliEncoderMaxCompressedSize(@p input_size) returns non-zero + * value, then output is guaranteed to be no longer than that. + * + * @param quality quality parameter value, e.g. ::BROTLI_DEFAULT_QUALITY + * @param lgwin lgwin parameter value, e.g. ::BROTLI_DEFAULT_WINDOW + * @param mode mode parameter value, e.g. ::BROTLI_DEFAULT_MODE + * @param input_size size of @p input_buffer + * @param input_buffer input data buffer with at least @p input_size + * addressable bytes + * @param[in, out] encoded_size @b in: size of @p encoded_buffer; \n + * @b out: length of compressed data written to + * @p encoded_buffer, or @c 0 if compression fails + * @param encoded_buffer compressed data destination buffer + * @returns ::false in case of compression error + * @returns ::false if output buffer is too small + * @returns ::true otherwise + */ + +/** + * Compresses input stream to output stream. + * + * The values @p *available_in and @p *available_out must specify the number of + * bytes addressable at @p *next_in and @p *next_out respectively. + * When @p *available_out is @c 0, @p next_out is allowed to be @c NULL. + * + * After each call, @p *available_in will be decremented by the amount of input + * bytes consumed, and the @p *next_in pointer will be incremented by that + * amount. Similarly, @p *available_out will be decremented by the amount of + * output bytes written, and the @p *next_out pointer will be incremented by + * that amount. + * + * @p total_out, if it is not a null-pointer, will be set to the number + * of bytes compressed since the last @p state initialization. + * + * + * + * Internally workflow consists of 3 tasks: + * -# (optionally) copy input data to internal buffer + * -# actually compress data and (optionally) store it to internal buffer + * -# (optionally) copy compressed bytes from internal buffer to output stream + * + * Whenever all 3 tasks can't move forward anymore, or error occurs, this + * method returns the control flow to caller. + * + * @p op is used to perform flush, finish the stream, or inject metadata block. + * See ::BrotliEncoderOperation for more information. + * + * Flushing the stream means forcing encoding of all input passed to encoder and + * completing the current output block, so it could be fully decoded by stream + * decoder. To perform flush set @p op to ::BROTLI_OPERATION_FLUSH. + * Under some circumstances (e.g. lack of output stream capacity) this operation + * would require several calls to ::BrotliEncoderCompressStream. The method must + * be called again until both input stream is depleted and encoder has no more + * output (see ::BrotliEncoderHasMoreOutput) after the method is called. + * + * Finishing the stream means encoding of all input passed to encoder and + * adding specific "final" marks, so stream decoder could determine that stream + * is complete. To perform finish set @p op to ::BROTLI_OPERATION_FINISH. + * Under some circumstances (e.g. lack of output stream capacity) this operation + * would require several calls to ::BrotliEncoderCompressStream. The method must + * be called again until both input stream is depleted and encoder has no more + * output (see ::BrotliEncoderHasMoreOutput) after the method is called. + * + * @warning When flushing and finishing, @p op should not change until operation + * is complete; input stream should not be swapped, reduced or + * extended as well. + * + * @param state encoder instance + * @param op requested operation + * @param[in, out] available_in @b in: amount of available input; \n + * @b out: amount of unused input + * @param[in, out] next_in pointer to the next input byte + * @param[in, out] available_out @b in: length of output buffer; \n + * @b out: remaining size of output buffer + * @param[in, out] next_out compressed output buffer cursor; + * can be @c NULL if @p available_out is @c 0 + * @param[out] total_out number of bytes produced so far; can be @c NULL + * @returns ::false if there was an error + * @returns ::true otherwise + */ + +/** + * Checks if encoder instance reached the final state. + * + * @param state encoder instance + * @returns ::true if encoder is in a state where it reached the end of + * the input and produced all of the output + * @returns ::false otherwise + */ + +/** + * Checks if encoder has more output. + * + * @param state encoder instance + * @returns ::true, if encoder has some unconsumed output + * @returns ::false otherwise + */ + +/** + * Acquires pointer to internal output buffer. + * + * This method is used to make language bindings easier and more efficient: + * -# push data to ::BrotliEncoderCompressStream, + * until ::BrotliEncoderHasMoreOutput returns BROTL_TRUE + * -# use ::BrotliEncoderTakeOutput to peek bytes and copy to language-specific + * entity + * + * Also this could be useful if there is an output stream that is able to + * consume all the provided data (e.g. when data is saved to file system). + * + * @attention After every call to ::BrotliEncoderTakeOutput @p *size bytes of + * output are considered consumed for all consecutive calls to the + * instance methods; returned pointer becomes invalidated as well. + * + * @note Encoder output is not guaranteed to be contiguous. This means that + * after the size-unrestricted call to ::BrotliEncoderTakeOutput, + * immediate next call to ::BrotliEncoderTakeOutput may return more data. + * + * @param state encoder instance + * @param[in, out] size @b in: number of bytes caller is ready to take, @c 0 if + * any amount could be handled; \n + * @b out: amount of data pointed by returned pointer and + * considered consumed; \n + * out value is never greater than in value, unless it is @c 0 + * @returns pointer to output data + */ + +/** + * Gets an encoder library version. + * + * Look at BROTLI_VERSION for more information. + */ +/* Copyright 2017 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Parameters for the Brotli encoder with chosen quality levels. */ +type BrotliHasherParams struct { + type_ int + bucket_bits int + block_bits int + hash_len int + num_last_distances_to_check int +} + +type BrotliDistanceParams struct { + distance_postfix_bits uint32 + num_direct_distance_codes uint32 + alphabet_size uint32 + max_distance uint +} + +/* Encoding parameters */ +type BrotliEncoderParams struct { + mode int + quality int + lgwin uint + lgblock int + size_hint uint + disable_literal_context_modeling bool + large_window bool + hasher BrotliHasherParams + dist BrotliDistanceParams + dictionary BrotliEncoderDictionary +} diff --git a/platform.go b/platform.go new file mode 100644 index 0000000..25e2e6c --- /dev/null +++ b/platform.go @@ -0,0 +1,167 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Bit reading helpers */ +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Macros for compiler / platform specific features and build options. + + Build options are: + * BROTLI_BUILD_32_BIT disables 64-bit optimizations + * BROTLI_BUILD_64_BIT forces to use 64-bit optimizations + * BROTLI_BUILD_BIG_ENDIAN forces to use big-endian optimizations + * BROTLI_BUILD_ENDIAN_NEUTRAL disables endian-aware optimizations + * BROTLI_BUILD_LITTLE_ENDIAN forces to use little-endian optimizations + * BROTLI_BUILD_PORTABLE disables dangerous optimizations, like unaligned + read and overlapping memcpy; this reduces decompression speed by 5% + * BROTLI_BUILD_NO_RBIT disables "rbit" optimization for ARM CPUs + * BROTLI_DEBUG dumps file name and line number when decoder detects stream + or memory error + * BROTLI_ENABLE_LOG enables asserts and dumps various state information +*/ +type brotli_reg_t uint64 + +/* Read / store values byte-wise; hopefully compiler will understand. */ +func BROTLI_UNALIGNED_LOAD16LE(p []byte) uint16 { + var in []byte = []byte(p) + return uint16(in[0] | in[1]<<8) +} + +func BROTLI_UNALIGNED_LOAD32LE(p []byte) uint32 { + var in []byte = []byte(p) + var value uint32 = uint32(in[0]) + value |= uint32(in[1]) << 8 + value |= uint32(in[2]) << 16 + value |= uint32(in[3]) << 24 + return value +} + +func BROTLI_UNALIGNED_LOAD64LE(p []byte) uint64 { + var in []byte = []byte(p) + var value uint64 = uint64(in[0]) + value |= uint64(in[1]) << 8 + value |= uint64(in[2]) << 16 + value |= uint64(in[3]) << 24 + value |= uint64(in[4]) << 32 + value |= uint64(in[5]) << 40 + value |= uint64(in[6]) << 48 + value |= uint64(in[7]) << 56 + return value +} + +func BROTLI_UNALIGNED_STORE64LE(p []byte, v uint64) { + var out []byte = []byte(p) + out[0] = byte(v) + out[1] = byte(v >> 8) + out[2] = byte(v >> 16) + out[3] = byte(v >> 24) + out[4] = byte(v >> 32) + out[5] = byte(v >> 40) + out[6] = byte(v >> 48) + out[7] = byte(v >> 56) +} + +func brotli_min_double(a float64, b float64) float64 { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_double(a float64, b float64) float64 { + if a > b { + return a + } else { + return b + } +} + +func brotli_min_float(a float32, b float32) float32 { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_float(a float32, b float32) float32 { + if a > b { + return a + } else { + return b + } +} + +func brotli_min_int(a int, b int) int { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_int(a int, b int) int { + if a > b { + return a + } else { + return b + } +} + +func brotli_min_size_t(a uint, b uint) uint { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_size_t(a uint, b uint) uint { + if a > b { + return a + } else { + return b + } +} + +func brotli_min_uint32_t(a uint32, b uint32) uint32 { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_uint32_t(a uint32, b uint32) uint32 { + if a > b { + return a + } else { + return b + } +} + +func brotli_min_uint8_t(a byte, b byte) byte { + if a < b { + return a + } else { + return b + } +} + +func brotli_max_uint8_t(a byte, b byte) byte { + if a > b { + return a + } else { + return b + } +} diff --git a/prefix.go b/prefix.go new file mode 100644 index 0000000..2e3648d --- /dev/null +++ b/prefix.go @@ -0,0 +1,51 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function to find backward reference copies. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Function to find backward reference copies. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* This class models a sequence of literals and a backward reference copy. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Functions for encoding of integers into prefix codes the amount of extra + bits, and the actual values of the extra bits. */ + +/* Here distance_code is an intermediate code, i.e. one of the special codes or + the actual distance increased by BROTLI_NUM_DISTANCE_SHORT_CODES - 1. */ +func PrefixEncodeCopyDistance(distance_code uint, num_direct_codes uint, postfix_bits uint, code *uint16, extra_bits *uint32) { + if distance_code < BROTLI_NUM_DISTANCE_SHORT_CODES+num_direct_codes { + *code = uint16(distance_code) + *extra_bits = 0 + return + } else { + var dist uint = (uint(1) << (postfix_bits + 2)) + (distance_code - BROTLI_NUM_DISTANCE_SHORT_CODES - num_direct_codes) + var bucket uint = uint(Log2FloorNonZero(dist) - 1) + var postfix_mask uint = (1 << postfix_bits) - 1 + var postfix uint = dist & postfix_mask + var prefix uint = (dist >> bucket) & 1 + var offset uint = (2 + prefix) << bucket + var nbits uint = bucket - postfix_bits + *code = uint16(nbits<<10 | (BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes + ((2*(nbits-1) + prefix) << postfix_bits) + postfix)) + *extra_bits = uint32((dist - offset) >> postfix_bits) + } +} diff --git a/prefix_dec.go b/prefix_dec.go new file mode 100644 index 0000000..01ccd02 --- /dev/null +++ b/prefix_dec.go @@ -0,0 +1,843 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Lookup tables to map prefix codes to value ranges. This is used during + decoding of the block lengths, literal insertion lengths and copy lengths. */ + +/* Represents the range of values belonging to a prefix code: + [offset, offset + 2^nbits) */ +type PrefixCodeRange1 struct { + offset uint16 + nbits byte +} + +var kBlockLengthPrefixCode1 = [BROTLI_NUM_BLOCK_LEN_SYMBOLS]struct { + offset uint16 + nbits byte +}{ + struct { + offset uint16 + nbits byte + }{1, 2}, + struct { + offset uint16 + nbits byte + }{5, 2}, + struct { + offset uint16 + nbits byte + }{9, 2}, + struct { + offset uint16 + nbits byte + }{13, 2}, + struct { + offset uint16 + nbits byte + }{17, 3}, + struct { + offset uint16 + nbits byte + }{25, 3}, + struct { + offset uint16 + nbits byte + }{33, 3}, + struct { + offset uint16 + nbits byte + }{41, 3}, + struct { + offset uint16 + nbits byte + }{49, 4}, + struct { + offset uint16 + nbits byte + }{65, 4}, + struct { + offset uint16 + nbits byte + }{81, 4}, + struct { + offset uint16 + nbits byte + }{97, 4}, + struct { + offset uint16 + nbits byte + }{113, 5}, + struct { + offset uint16 + nbits byte + }{145, 5}, + struct { + offset uint16 + nbits byte + }{177, 5}, + struct { + offset uint16 + nbits byte + }{209, 5}, + struct { + offset uint16 + nbits byte + }{241, 6}, + struct { + offset uint16 + nbits byte + }{305, 6}, + struct { + offset uint16 + nbits byte + }{369, 7}, + struct { + offset uint16 + nbits byte + }{497, 8}, + struct { + offset uint16 + nbits byte + }{753, 9}, + struct { + offset uint16 + nbits byte + }{1265, 10}, + struct { + offset uint16 + nbits byte + }{2289, 11}, + struct { + offset uint16 + nbits byte + }{4337, 12}, + struct { + offset uint16 + nbits byte + }{8433, 13}, + struct { + offset uint16 + nbits byte + }{16625, 24}, +} + +type CmdLutElement struct { + insert_len_extra_bits byte + copy_len_extra_bits byte + distance_code int8 + context byte + insert_len_offset uint16 + copy_len_offset uint16 +} + +var kCmdLut = [BROTLI_NUM_COMMAND_SYMBOLS]CmdLutElement{ + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0000, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0000, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0000, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0000, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0000, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0000, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0000, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0000, 0x0009}, + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0001, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0001, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0001, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0001, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0001, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0001, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0001, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0001, 0x0009}, + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0002, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0002, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0002, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0002, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0002, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0002, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0002, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0002, 0x0009}, + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0003, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0003, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0003, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0003, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0003, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0003, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0003, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0003, 0x0009}, + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0004, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0004, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0004, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0004, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0004, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0004, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0004, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0004, 0x0009}, + CmdLutElement{0x00, 0x00, 0, 0x00, 0x0005, 0x0002}, + CmdLutElement{0x00, 0x00, 0, 0x01, 0x0005, 0x0003}, + CmdLutElement{0x00, 0x00, 0, 0x02, 0x0005, 0x0004}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0005, 0x0005}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0005, 0x0006}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0005, 0x0007}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0005, 0x0008}, + CmdLutElement{0x00, 0x00, 0, 0x03, 0x0005, 0x0009}, + CmdLutElement{0x01, 0x00, 0, 0x00, 0x0006, 0x0002}, + CmdLutElement{0x01, 0x00, 0, 0x01, 0x0006, 0x0003}, + CmdLutElement{0x01, 0x00, 0, 0x02, 0x0006, 0x0004}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0006, 0x0005}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0006, 0x0006}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0006, 0x0007}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0006, 0x0008}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0006, 0x0009}, + CmdLutElement{0x01, 0x00, 0, 0x00, 0x0008, 0x0002}, + CmdLutElement{0x01, 0x00, 0, 0x01, 0x0008, 0x0003}, + CmdLutElement{0x01, 0x00, 0, 0x02, 0x0008, 0x0004}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0008, 0x0005}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0008, 0x0006}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0008, 0x0007}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0008, 0x0008}, + CmdLutElement{0x01, 0x00, 0, 0x03, 0x0008, 0x0009}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0000, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0000, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0000, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0000, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0000, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0000, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0000, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0000, 0x0036}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0001, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0001, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0001, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0001, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0001, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0001, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0001, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0001, 0x0036}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0002, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0002, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0002, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0002, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0002, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0002, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0002, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0002, 0x0036}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0003, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0003, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0003, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0003, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0003, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0003, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0003, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0003, 0x0036}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0004, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0004, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0004, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0004, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0004, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0004, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0004, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0004, 0x0036}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0005, 0x000a}, + CmdLutElement{0x00, 0x01, 0, 0x03, 0x0005, 0x000c}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0005, 0x000e}, + CmdLutElement{0x00, 0x02, 0, 0x03, 0x0005, 0x0012}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0005, 0x0016}, + CmdLutElement{0x00, 0x03, 0, 0x03, 0x0005, 0x001e}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0005, 0x0026}, + CmdLutElement{0x00, 0x04, 0, 0x03, 0x0005, 0x0036}, + CmdLutElement{0x01, 0x01, 0, 0x03, 0x0006, 0x000a}, + CmdLutElement{0x01, 0x01, 0, 0x03, 0x0006, 0x000c}, + CmdLutElement{0x01, 0x02, 0, 0x03, 0x0006, 0x000e}, + CmdLutElement{0x01, 0x02, 0, 0x03, 0x0006, 0x0012}, + CmdLutElement{0x01, 0x03, 0, 0x03, 0x0006, 0x0016}, + CmdLutElement{0x01, 0x03, 0, 0x03, 0x0006, 0x001e}, + CmdLutElement{0x01, 0x04, 0, 0x03, 0x0006, 0x0026}, + CmdLutElement{0x01, 0x04, 0, 0x03, 0x0006, 0x0036}, + CmdLutElement{0x01, 0x01, 0, 0x03, 0x0008, 0x000a}, + CmdLutElement{0x01, 0x01, 0, 0x03, 0x0008, 0x000c}, + CmdLutElement{0x01, 0x02, 0, 0x03, 0x0008, 0x000e}, + CmdLutElement{0x01, 0x02, 0, 0x03, 0x0008, 0x0012}, + CmdLutElement{0x01, 0x03, 0, 0x03, 0x0008, 0x0016}, + CmdLutElement{0x01, 0x03, 0, 0x03, 0x0008, 0x001e}, + CmdLutElement{0x01, 0x04, 0, 0x03, 0x0008, 0x0026}, + CmdLutElement{0x01, 0x04, 0, 0x03, 0x0008, 0x0036}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0000, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0000, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0000, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0000, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0000, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0000, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0000, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0000, 0x0009}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0001, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0001, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0001, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0001, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0001, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0001, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0001, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0001, 0x0009}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0002, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0002, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0002, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0002, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0002, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0002, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0002, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0002, 0x0009}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0003, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0003, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0003, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0003, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0003, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0003, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0003, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0003, 0x0009}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0004, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0004, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0004, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0004, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0004, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0004, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0004, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0004, 0x0009}, + CmdLutElement{0x00, 0x00, -1, 0x00, 0x0005, 0x0002}, + CmdLutElement{0x00, 0x00, -1, 0x01, 0x0005, 0x0003}, + CmdLutElement{0x00, 0x00, -1, 0x02, 0x0005, 0x0004}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0005, 0x0005}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0005, 0x0006}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0005, 0x0007}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0005, 0x0008}, + CmdLutElement{0x00, 0x00, -1, 0x03, 0x0005, 0x0009}, + CmdLutElement{0x01, 0x00, -1, 0x00, 0x0006, 0x0002}, + CmdLutElement{0x01, 0x00, -1, 0x01, 0x0006, 0x0003}, + CmdLutElement{0x01, 0x00, -1, 0x02, 0x0006, 0x0004}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0006, 0x0005}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0006, 0x0006}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0006, 0x0007}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0006, 0x0008}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0006, 0x0009}, + CmdLutElement{0x01, 0x00, -1, 0x00, 0x0008, 0x0002}, + CmdLutElement{0x01, 0x00, -1, 0x01, 0x0008, 0x0003}, + CmdLutElement{0x01, 0x00, -1, 0x02, 0x0008, 0x0004}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0008, 0x0005}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0008, 0x0006}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0008, 0x0007}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0008, 0x0008}, + CmdLutElement{0x01, 0x00, -1, 0x03, 0x0008, 0x0009}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0000, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0000, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0000, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0000, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0000, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0000, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0000, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0000, 0x0036}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0001, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0001, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0001, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0001, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0001, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0001, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0001, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0001, 0x0036}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0002, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0002, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0002, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0002, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0002, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0002, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0002, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0002, 0x0036}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0003, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0003, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0003, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0003, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0003, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0003, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0003, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0003, 0x0036}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0004, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0004, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0004, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0004, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0004, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0004, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0004, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0004, 0x0036}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0005, 0x000a}, + CmdLutElement{0x00, 0x01, -1, 0x03, 0x0005, 0x000c}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0005, 0x000e}, + CmdLutElement{0x00, 0x02, -1, 0x03, 0x0005, 0x0012}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0005, 0x0016}, + CmdLutElement{0x00, 0x03, -1, 0x03, 0x0005, 0x001e}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0005, 0x0026}, + CmdLutElement{0x00, 0x04, -1, 0x03, 0x0005, 0x0036}, + CmdLutElement{0x01, 0x01, -1, 0x03, 0x0006, 0x000a}, + CmdLutElement{0x01, 0x01, -1, 0x03, 0x0006, 0x000c}, + CmdLutElement{0x01, 0x02, -1, 0x03, 0x0006, 0x000e}, + CmdLutElement{0x01, 0x02, -1, 0x03, 0x0006, 0x0012}, + CmdLutElement{0x01, 0x03, -1, 0x03, 0x0006, 0x0016}, + CmdLutElement{0x01, 0x03, -1, 0x03, 0x0006, 0x001e}, + CmdLutElement{0x01, 0x04, -1, 0x03, 0x0006, 0x0026}, + CmdLutElement{0x01, 0x04, -1, 0x03, 0x0006, 0x0036}, + CmdLutElement{0x01, 0x01, -1, 0x03, 0x0008, 0x000a}, + CmdLutElement{0x01, 0x01, -1, 0x03, 0x0008, 0x000c}, + CmdLutElement{0x01, 0x02, -1, 0x03, 0x0008, 0x000e}, + CmdLutElement{0x01, 0x02, -1, 0x03, 0x0008, 0x0012}, + CmdLutElement{0x01, 0x03, -1, 0x03, 0x0008, 0x0016}, + CmdLutElement{0x01, 0x03, -1, 0x03, 0x0008, 0x001e}, + CmdLutElement{0x01, 0x04, -1, 0x03, 0x0008, 0x0026}, + CmdLutElement{0x01, 0x04, -1, 0x03, 0x0008, 0x0036}, + CmdLutElement{0x02, 0x00, -1, 0x00, 0x000a, 0x0002}, + CmdLutElement{0x02, 0x00, -1, 0x01, 0x000a, 0x0003}, + CmdLutElement{0x02, 0x00, -1, 0x02, 0x000a, 0x0004}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000a, 0x0005}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000a, 0x0006}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000a, 0x0007}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000a, 0x0008}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000a, 0x0009}, + CmdLutElement{0x02, 0x00, -1, 0x00, 0x000e, 0x0002}, + CmdLutElement{0x02, 0x00, -1, 0x01, 0x000e, 0x0003}, + CmdLutElement{0x02, 0x00, -1, 0x02, 0x000e, 0x0004}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000e, 0x0005}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000e, 0x0006}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000e, 0x0007}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000e, 0x0008}, + CmdLutElement{0x02, 0x00, -1, 0x03, 0x000e, 0x0009}, + CmdLutElement{0x03, 0x00, -1, 0x00, 0x0012, 0x0002}, + CmdLutElement{0x03, 0x00, -1, 0x01, 0x0012, 0x0003}, + CmdLutElement{0x03, 0x00, -1, 0x02, 0x0012, 0x0004}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x0012, 0x0005}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x0012, 0x0006}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x0012, 0x0007}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x0012, 0x0008}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x0012, 0x0009}, + CmdLutElement{0x03, 0x00, -1, 0x00, 0x001a, 0x0002}, + CmdLutElement{0x03, 0x00, -1, 0x01, 0x001a, 0x0003}, + CmdLutElement{0x03, 0x00, -1, 0x02, 0x001a, 0x0004}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x001a, 0x0005}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x001a, 0x0006}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x001a, 0x0007}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x001a, 0x0008}, + CmdLutElement{0x03, 0x00, -1, 0x03, 0x001a, 0x0009}, + CmdLutElement{0x04, 0x00, -1, 0x00, 0x0022, 0x0002}, + CmdLutElement{0x04, 0x00, -1, 0x01, 0x0022, 0x0003}, + CmdLutElement{0x04, 0x00, -1, 0x02, 0x0022, 0x0004}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0022, 0x0005}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0022, 0x0006}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0022, 0x0007}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0022, 0x0008}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0022, 0x0009}, + CmdLutElement{0x04, 0x00, -1, 0x00, 0x0032, 0x0002}, + CmdLutElement{0x04, 0x00, -1, 0x01, 0x0032, 0x0003}, + CmdLutElement{0x04, 0x00, -1, 0x02, 0x0032, 0x0004}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0032, 0x0005}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0032, 0x0006}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0032, 0x0007}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0032, 0x0008}, + CmdLutElement{0x04, 0x00, -1, 0x03, 0x0032, 0x0009}, + CmdLutElement{0x05, 0x00, -1, 0x00, 0x0042, 0x0002}, + CmdLutElement{0x05, 0x00, -1, 0x01, 0x0042, 0x0003}, + CmdLutElement{0x05, 0x00, -1, 0x02, 0x0042, 0x0004}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0042, 0x0005}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0042, 0x0006}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0042, 0x0007}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0042, 0x0008}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0042, 0x0009}, + CmdLutElement{0x05, 0x00, -1, 0x00, 0x0062, 0x0002}, + CmdLutElement{0x05, 0x00, -1, 0x01, 0x0062, 0x0003}, + CmdLutElement{0x05, 0x00, -1, 0x02, 0x0062, 0x0004}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0062, 0x0005}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0062, 0x0006}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0062, 0x0007}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0062, 0x0008}, + CmdLutElement{0x05, 0x00, -1, 0x03, 0x0062, 0x0009}, + CmdLutElement{0x02, 0x01, -1, 0x03, 0x000a, 0x000a}, + CmdLutElement{0x02, 0x01, -1, 0x03, 0x000a, 0x000c}, + CmdLutElement{0x02, 0x02, -1, 0x03, 0x000a, 0x000e}, + CmdLutElement{0x02, 0x02, -1, 0x03, 0x000a, 0x0012}, + CmdLutElement{0x02, 0x03, -1, 0x03, 0x000a, 0x0016}, + CmdLutElement{0x02, 0x03, -1, 0x03, 0x000a, 0x001e}, + CmdLutElement{0x02, 0x04, -1, 0x03, 0x000a, 0x0026}, + CmdLutElement{0x02, 0x04, -1, 0x03, 0x000a, 0x0036}, + CmdLutElement{0x02, 0x01, -1, 0x03, 0x000e, 0x000a}, + CmdLutElement{0x02, 0x01, -1, 0x03, 0x000e, 0x000c}, + CmdLutElement{0x02, 0x02, -1, 0x03, 0x000e, 0x000e}, + CmdLutElement{0x02, 0x02, -1, 0x03, 0x000e, 0x0012}, + CmdLutElement{0x02, 0x03, -1, 0x03, 0x000e, 0x0016}, + CmdLutElement{0x02, 0x03, -1, 0x03, 0x000e, 0x001e}, + CmdLutElement{0x02, 0x04, -1, 0x03, 0x000e, 0x0026}, + CmdLutElement{0x02, 0x04, -1, 0x03, 0x000e, 0x0036}, + CmdLutElement{0x03, 0x01, -1, 0x03, 0x0012, 0x000a}, + CmdLutElement{0x03, 0x01, -1, 0x03, 0x0012, 0x000c}, + CmdLutElement{0x03, 0x02, -1, 0x03, 0x0012, 0x000e}, + CmdLutElement{0x03, 0x02, -1, 0x03, 0x0012, 0x0012}, + CmdLutElement{0x03, 0x03, -1, 0x03, 0x0012, 0x0016}, + CmdLutElement{0x03, 0x03, -1, 0x03, 0x0012, 0x001e}, + CmdLutElement{0x03, 0x04, -1, 0x03, 0x0012, 0x0026}, + CmdLutElement{0x03, 0x04, -1, 0x03, 0x0012, 0x0036}, + CmdLutElement{0x03, 0x01, -1, 0x03, 0x001a, 0x000a}, + CmdLutElement{0x03, 0x01, -1, 0x03, 0x001a, 0x000c}, + CmdLutElement{0x03, 0x02, -1, 0x03, 0x001a, 0x000e}, + CmdLutElement{0x03, 0x02, -1, 0x03, 0x001a, 0x0012}, + CmdLutElement{0x03, 0x03, -1, 0x03, 0x001a, 0x0016}, + CmdLutElement{0x03, 0x03, -1, 0x03, 0x001a, 0x001e}, + CmdLutElement{0x03, 0x04, -1, 0x03, 0x001a, 0x0026}, + CmdLutElement{0x03, 0x04, -1, 0x03, 0x001a, 0x0036}, + CmdLutElement{0x04, 0x01, -1, 0x03, 0x0022, 0x000a}, + CmdLutElement{0x04, 0x01, -1, 0x03, 0x0022, 0x000c}, + CmdLutElement{0x04, 0x02, -1, 0x03, 0x0022, 0x000e}, + CmdLutElement{0x04, 0x02, -1, 0x03, 0x0022, 0x0012}, + CmdLutElement{0x04, 0x03, -1, 0x03, 0x0022, 0x0016}, + CmdLutElement{0x04, 0x03, -1, 0x03, 0x0022, 0x001e}, + CmdLutElement{0x04, 0x04, -1, 0x03, 0x0022, 0x0026}, + CmdLutElement{0x04, 0x04, -1, 0x03, 0x0022, 0x0036}, + CmdLutElement{0x04, 0x01, -1, 0x03, 0x0032, 0x000a}, + CmdLutElement{0x04, 0x01, -1, 0x03, 0x0032, 0x000c}, + CmdLutElement{0x04, 0x02, -1, 0x03, 0x0032, 0x000e}, + CmdLutElement{0x04, 0x02, -1, 0x03, 0x0032, 0x0012}, + CmdLutElement{0x04, 0x03, -1, 0x03, 0x0032, 0x0016}, + CmdLutElement{0x04, 0x03, -1, 0x03, 0x0032, 0x001e}, + CmdLutElement{0x04, 0x04, -1, 0x03, 0x0032, 0x0026}, + CmdLutElement{0x04, 0x04, -1, 0x03, 0x0032, 0x0036}, + CmdLutElement{0x05, 0x01, -1, 0x03, 0x0042, 0x000a}, + CmdLutElement{0x05, 0x01, -1, 0x03, 0x0042, 0x000c}, + CmdLutElement{0x05, 0x02, -1, 0x03, 0x0042, 0x000e}, + CmdLutElement{0x05, 0x02, -1, 0x03, 0x0042, 0x0012}, + CmdLutElement{0x05, 0x03, -1, 0x03, 0x0042, 0x0016}, + CmdLutElement{0x05, 0x03, -1, 0x03, 0x0042, 0x001e}, + CmdLutElement{0x05, 0x04, -1, 0x03, 0x0042, 0x0026}, + CmdLutElement{0x05, 0x04, -1, 0x03, 0x0042, 0x0036}, + CmdLutElement{0x05, 0x01, -1, 0x03, 0x0062, 0x000a}, + CmdLutElement{0x05, 0x01, -1, 0x03, 0x0062, 0x000c}, + CmdLutElement{0x05, 0x02, -1, 0x03, 0x0062, 0x000e}, + CmdLutElement{0x05, 0x02, -1, 0x03, 0x0062, 0x0012}, + CmdLutElement{0x05, 0x03, -1, 0x03, 0x0062, 0x0016}, + CmdLutElement{0x05, 0x03, -1, 0x03, 0x0062, 0x001e}, + CmdLutElement{0x05, 0x04, -1, 0x03, 0x0062, 0x0026}, + CmdLutElement{0x05, 0x04, -1, 0x03, 0x0062, 0x0036}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0000, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0000, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0000, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0000, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0000, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0000, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0000, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0000, 0x0846}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0001, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0001, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0001, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0001, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0001, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0001, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0001, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0001, 0x0846}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0002, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0002, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0002, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0002, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0002, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0002, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0002, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0002, 0x0846}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0003, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0003, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0003, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0003, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0003, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0003, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0003, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0003, 0x0846}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0004, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0004, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0004, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0004, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0004, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0004, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0004, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0004, 0x0846}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0005, 0x0046}, + CmdLutElement{0x00, 0x05, -1, 0x03, 0x0005, 0x0066}, + CmdLutElement{0x00, 0x06, -1, 0x03, 0x0005, 0x0086}, + CmdLutElement{0x00, 0x07, -1, 0x03, 0x0005, 0x00c6}, + CmdLutElement{0x00, 0x08, -1, 0x03, 0x0005, 0x0146}, + CmdLutElement{0x00, 0x09, -1, 0x03, 0x0005, 0x0246}, + CmdLutElement{0x00, 0x0a, -1, 0x03, 0x0005, 0x0446}, + CmdLutElement{0x00, 0x18, -1, 0x03, 0x0005, 0x0846}, + CmdLutElement{0x01, 0x05, -1, 0x03, 0x0006, 0x0046}, + CmdLutElement{0x01, 0x05, -1, 0x03, 0x0006, 0x0066}, + CmdLutElement{0x01, 0x06, -1, 0x03, 0x0006, 0x0086}, + CmdLutElement{0x01, 0x07, -1, 0x03, 0x0006, 0x00c6}, + CmdLutElement{0x01, 0x08, -1, 0x03, 0x0006, 0x0146}, + CmdLutElement{0x01, 0x09, -1, 0x03, 0x0006, 0x0246}, + CmdLutElement{0x01, 0x0a, -1, 0x03, 0x0006, 0x0446}, + CmdLutElement{0x01, 0x18, -1, 0x03, 0x0006, 0x0846}, + CmdLutElement{0x01, 0x05, -1, 0x03, 0x0008, 0x0046}, + CmdLutElement{0x01, 0x05, -1, 0x03, 0x0008, 0x0066}, + CmdLutElement{0x01, 0x06, -1, 0x03, 0x0008, 0x0086}, + CmdLutElement{0x01, 0x07, -1, 0x03, 0x0008, 0x00c6}, + CmdLutElement{0x01, 0x08, -1, 0x03, 0x0008, 0x0146}, + CmdLutElement{0x01, 0x09, -1, 0x03, 0x0008, 0x0246}, + CmdLutElement{0x01, 0x0a, -1, 0x03, 0x0008, 0x0446}, + CmdLutElement{0x01, 0x18, -1, 0x03, 0x0008, 0x0846}, + CmdLutElement{0x06, 0x00, -1, 0x00, 0x0082, 0x0002}, + CmdLutElement{0x06, 0x00, -1, 0x01, 0x0082, 0x0003}, + CmdLutElement{0x06, 0x00, -1, 0x02, 0x0082, 0x0004}, + CmdLutElement{0x06, 0x00, -1, 0x03, 0x0082, 0x0005}, + CmdLutElement{0x06, 0x00, -1, 0x03, 0x0082, 0x0006}, + CmdLutElement{0x06, 0x00, -1, 0x03, 0x0082, 0x0007}, + CmdLutElement{0x06, 0x00, -1, 0x03, 0x0082, 0x0008}, + CmdLutElement{0x06, 0x00, -1, 0x03, 0x0082, 0x0009}, + CmdLutElement{0x07, 0x00, -1, 0x00, 0x00c2, 0x0002}, + CmdLutElement{0x07, 0x00, -1, 0x01, 0x00c2, 0x0003}, + CmdLutElement{0x07, 0x00, -1, 0x02, 0x00c2, 0x0004}, + CmdLutElement{0x07, 0x00, -1, 0x03, 0x00c2, 0x0005}, + CmdLutElement{0x07, 0x00, -1, 0x03, 0x00c2, 0x0006}, + CmdLutElement{0x07, 0x00, -1, 0x03, 0x00c2, 0x0007}, + CmdLutElement{0x07, 0x00, -1, 0x03, 0x00c2, 0x0008}, + CmdLutElement{0x07, 0x00, -1, 0x03, 0x00c2, 0x0009}, + CmdLutElement{0x08, 0x00, -1, 0x00, 0x0142, 0x0002}, + CmdLutElement{0x08, 0x00, -1, 0x01, 0x0142, 0x0003}, + CmdLutElement{0x08, 0x00, -1, 0x02, 0x0142, 0x0004}, + CmdLutElement{0x08, 0x00, -1, 0x03, 0x0142, 0x0005}, + CmdLutElement{0x08, 0x00, -1, 0x03, 0x0142, 0x0006}, + CmdLutElement{0x08, 0x00, -1, 0x03, 0x0142, 0x0007}, + CmdLutElement{0x08, 0x00, -1, 0x03, 0x0142, 0x0008}, + CmdLutElement{0x08, 0x00, -1, 0x03, 0x0142, 0x0009}, + CmdLutElement{0x09, 0x00, -1, 0x00, 0x0242, 0x0002}, + CmdLutElement{0x09, 0x00, -1, 0x01, 0x0242, 0x0003}, + CmdLutElement{0x09, 0x00, -1, 0x02, 0x0242, 0x0004}, + CmdLutElement{0x09, 0x00, -1, 0x03, 0x0242, 0x0005}, + CmdLutElement{0x09, 0x00, -1, 0x03, 0x0242, 0x0006}, + CmdLutElement{0x09, 0x00, -1, 0x03, 0x0242, 0x0007}, + CmdLutElement{0x09, 0x00, -1, 0x03, 0x0242, 0x0008}, + CmdLutElement{0x09, 0x00, -1, 0x03, 0x0242, 0x0009}, + CmdLutElement{0x0a, 0x00, -1, 0x00, 0x0442, 0x0002}, + CmdLutElement{0x0a, 0x00, -1, 0x01, 0x0442, 0x0003}, + CmdLutElement{0x0a, 0x00, -1, 0x02, 0x0442, 0x0004}, + CmdLutElement{0x0a, 0x00, -1, 0x03, 0x0442, 0x0005}, + CmdLutElement{0x0a, 0x00, -1, 0x03, 0x0442, 0x0006}, + CmdLutElement{0x0a, 0x00, -1, 0x03, 0x0442, 0x0007}, + CmdLutElement{0x0a, 0x00, -1, 0x03, 0x0442, 0x0008}, + CmdLutElement{0x0a, 0x00, -1, 0x03, 0x0442, 0x0009}, + CmdLutElement{0x0c, 0x00, -1, 0x00, 0x0842, 0x0002}, + CmdLutElement{0x0c, 0x00, -1, 0x01, 0x0842, 0x0003}, + CmdLutElement{0x0c, 0x00, -1, 0x02, 0x0842, 0x0004}, + CmdLutElement{0x0c, 0x00, -1, 0x03, 0x0842, 0x0005}, + CmdLutElement{0x0c, 0x00, -1, 0x03, 0x0842, 0x0006}, + CmdLutElement{0x0c, 0x00, -1, 0x03, 0x0842, 0x0007}, + CmdLutElement{0x0c, 0x00, -1, 0x03, 0x0842, 0x0008}, + CmdLutElement{0x0c, 0x00, -1, 0x03, 0x0842, 0x0009}, + CmdLutElement{0x0e, 0x00, -1, 0x00, 0x1842, 0x0002}, + CmdLutElement{0x0e, 0x00, -1, 0x01, 0x1842, 0x0003}, + CmdLutElement{0x0e, 0x00, -1, 0x02, 0x1842, 0x0004}, + CmdLutElement{0x0e, 0x00, -1, 0x03, 0x1842, 0x0005}, + CmdLutElement{0x0e, 0x00, -1, 0x03, 0x1842, 0x0006}, + CmdLutElement{0x0e, 0x00, -1, 0x03, 0x1842, 0x0007}, + CmdLutElement{0x0e, 0x00, -1, 0x03, 0x1842, 0x0008}, + CmdLutElement{0x0e, 0x00, -1, 0x03, 0x1842, 0x0009}, + CmdLutElement{0x18, 0x00, -1, 0x00, 0x5842, 0x0002}, + CmdLutElement{0x18, 0x00, -1, 0x01, 0x5842, 0x0003}, + CmdLutElement{0x18, 0x00, -1, 0x02, 0x5842, 0x0004}, + CmdLutElement{0x18, 0x00, -1, 0x03, 0x5842, 0x0005}, + CmdLutElement{0x18, 0x00, -1, 0x03, 0x5842, 0x0006}, + CmdLutElement{0x18, 0x00, -1, 0x03, 0x5842, 0x0007}, + CmdLutElement{0x18, 0x00, -1, 0x03, 0x5842, 0x0008}, + CmdLutElement{0x18, 0x00, -1, 0x03, 0x5842, 0x0009}, + CmdLutElement{0x02, 0x05, -1, 0x03, 0x000a, 0x0046}, + CmdLutElement{0x02, 0x05, -1, 0x03, 0x000a, 0x0066}, + CmdLutElement{0x02, 0x06, -1, 0x03, 0x000a, 0x0086}, + CmdLutElement{0x02, 0x07, -1, 0x03, 0x000a, 0x00c6}, + CmdLutElement{0x02, 0x08, -1, 0x03, 0x000a, 0x0146}, + CmdLutElement{0x02, 0x09, -1, 0x03, 0x000a, 0x0246}, + CmdLutElement{0x02, 0x0a, -1, 0x03, 0x000a, 0x0446}, + CmdLutElement{0x02, 0x18, -1, 0x03, 0x000a, 0x0846}, + CmdLutElement{0x02, 0x05, -1, 0x03, 0x000e, 0x0046}, + CmdLutElement{0x02, 0x05, -1, 0x03, 0x000e, 0x0066}, + CmdLutElement{0x02, 0x06, -1, 0x03, 0x000e, 0x0086}, + CmdLutElement{0x02, 0x07, -1, 0x03, 0x000e, 0x00c6}, + CmdLutElement{0x02, 0x08, -1, 0x03, 0x000e, 0x0146}, + CmdLutElement{0x02, 0x09, -1, 0x03, 0x000e, 0x0246}, + CmdLutElement{0x02, 0x0a, -1, 0x03, 0x000e, 0x0446}, + CmdLutElement{0x02, 0x18, -1, 0x03, 0x000e, 0x0846}, + CmdLutElement{0x03, 0x05, -1, 0x03, 0x0012, 0x0046}, + CmdLutElement{0x03, 0x05, -1, 0x03, 0x0012, 0x0066}, + CmdLutElement{0x03, 0x06, -1, 0x03, 0x0012, 0x0086}, + CmdLutElement{0x03, 0x07, -1, 0x03, 0x0012, 0x00c6}, + CmdLutElement{0x03, 0x08, -1, 0x03, 0x0012, 0x0146}, + CmdLutElement{0x03, 0x09, -1, 0x03, 0x0012, 0x0246}, + CmdLutElement{0x03, 0x0a, -1, 0x03, 0x0012, 0x0446}, + CmdLutElement{0x03, 0x18, -1, 0x03, 0x0012, 0x0846}, + CmdLutElement{0x03, 0x05, -1, 0x03, 0x001a, 0x0046}, + CmdLutElement{0x03, 0x05, -1, 0x03, 0x001a, 0x0066}, + CmdLutElement{0x03, 0x06, -1, 0x03, 0x001a, 0x0086}, + CmdLutElement{0x03, 0x07, -1, 0x03, 0x001a, 0x00c6}, + CmdLutElement{0x03, 0x08, -1, 0x03, 0x001a, 0x0146}, + CmdLutElement{0x03, 0x09, -1, 0x03, 0x001a, 0x0246}, + CmdLutElement{0x03, 0x0a, -1, 0x03, 0x001a, 0x0446}, + CmdLutElement{0x03, 0x18, -1, 0x03, 0x001a, 0x0846}, + CmdLutElement{0x04, 0x05, -1, 0x03, 0x0022, 0x0046}, + CmdLutElement{0x04, 0x05, -1, 0x03, 0x0022, 0x0066}, + CmdLutElement{0x04, 0x06, -1, 0x03, 0x0022, 0x0086}, + CmdLutElement{0x04, 0x07, -1, 0x03, 0x0022, 0x00c6}, + CmdLutElement{0x04, 0x08, -1, 0x03, 0x0022, 0x0146}, + CmdLutElement{0x04, 0x09, -1, 0x03, 0x0022, 0x0246}, + CmdLutElement{0x04, 0x0a, -1, 0x03, 0x0022, 0x0446}, + CmdLutElement{0x04, 0x18, -1, 0x03, 0x0022, 0x0846}, + CmdLutElement{0x04, 0x05, -1, 0x03, 0x0032, 0x0046}, + CmdLutElement{0x04, 0x05, -1, 0x03, 0x0032, 0x0066}, + CmdLutElement{0x04, 0x06, -1, 0x03, 0x0032, 0x0086}, + CmdLutElement{0x04, 0x07, -1, 0x03, 0x0032, 0x00c6}, + CmdLutElement{0x04, 0x08, -1, 0x03, 0x0032, 0x0146}, + CmdLutElement{0x04, 0x09, -1, 0x03, 0x0032, 0x0246}, + CmdLutElement{0x04, 0x0a, -1, 0x03, 0x0032, 0x0446}, + CmdLutElement{0x04, 0x18, -1, 0x03, 0x0032, 0x0846}, + CmdLutElement{0x05, 0x05, -1, 0x03, 0x0042, 0x0046}, + CmdLutElement{0x05, 0x05, -1, 0x03, 0x0042, 0x0066}, + CmdLutElement{0x05, 0x06, -1, 0x03, 0x0042, 0x0086}, + CmdLutElement{0x05, 0x07, -1, 0x03, 0x0042, 0x00c6}, + CmdLutElement{0x05, 0x08, -1, 0x03, 0x0042, 0x0146}, + CmdLutElement{0x05, 0x09, -1, 0x03, 0x0042, 0x0246}, + CmdLutElement{0x05, 0x0a, -1, 0x03, 0x0042, 0x0446}, + CmdLutElement{0x05, 0x18, -1, 0x03, 0x0042, 0x0846}, + CmdLutElement{0x05, 0x05, -1, 0x03, 0x0062, 0x0046}, + CmdLutElement{0x05, 0x05, -1, 0x03, 0x0062, 0x0066}, + CmdLutElement{0x05, 0x06, -1, 0x03, 0x0062, 0x0086}, + CmdLutElement{0x05, 0x07, -1, 0x03, 0x0062, 0x00c6}, + CmdLutElement{0x05, 0x08, -1, 0x03, 0x0062, 0x0146}, + CmdLutElement{0x05, 0x09, -1, 0x03, 0x0062, 0x0246}, + CmdLutElement{0x05, 0x0a, -1, 0x03, 0x0062, 0x0446}, + CmdLutElement{0x05, 0x18, -1, 0x03, 0x0062, 0x0846}, + CmdLutElement{0x06, 0x01, -1, 0x03, 0x0082, 0x000a}, + CmdLutElement{0x06, 0x01, -1, 0x03, 0x0082, 0x000c}, + CmdLutElement{0x06, 0x02, -1, 0x03, 0x0082, 0x000e}, + CmdLutElement{0x06, 0x02, -1, 0x03, 0x0082, 0x0012}, + CmdLutElement{0x06, 0x03, -1, 0x03, 0x0082, 0x0016}, + CmdLutElement{0x06, 0x03, -1, 0x03, 0x0082, 0x001e}, + CmdLutElement{0x06, 0x04, -1, 0x03, 0x0082, 0x0026}, + CmdLutElement{0x06, 0x04, -1, 0x03, 0x0082, 0x0036}, + CmdLutElement{0x07, 0x01, -1, 0x03, 0x00c2, 0x000a}, + CmdLutElement{0x07, 0x01, -1, 0x03, 0x00c2, 0x000c}, + CmdLutElement{0x07, 0x02, -1, 0x03, 0x00c2, 0x000e}, + CmdLutElement{0x07, 0x02, -1, 0x03, 0x00c2, 0x0012}, + CmdLutElement{0x07, 0x03, -1, 0x03, 0x00c2, 0x0016}, + CmdLutElement{0x07, 0x03, -1, 0x03, 0x00c2, 0x001e}, + CmdLutElement{0x07, 0x04, -1, 0x03, 0x00c2, 0x0026}, + CmdLutElement{0x07, 0x04, -1, 0x03, 0x00c2, 0x0036}, + CmdLutElement{0x08, 0x01, -1, 0x03, 0x0142, 0x000a}, + CmdLutElement{0x08, 0x01, -1, 0x03, 0x0142, 0x000c}, + CmdLutElement{0x08, 0x02, -1, 0x03, 0x0142, 0x000e}, + CmdLutElement{0x08, 0x02, -1, 0x03, 0x0142, 0x0012}, + CmdLutElement{0x08, 0x03, -1, 0x03, 0x0142, 0x0016}, + CmdLutElement{0x08, 0x03, -1, 0x03, 0x0142, 0x001e}, + CmdLutElement{0x08, 0x04, -1, 0x03, 0x0142, 0x0026}, + CmdLutElement{0x08, 0x04, -1, 0x03, 0x0142, 0x0036}, + CmdLutElement{0x09, 0x01, -1, 0x03, 0x0242, 0x000a}, + CmdLutElement{0x09, 0x01, -1, 0x03, 0x0242, 0x000c}, + CmdLutElement{0x09, 0x02, -1, 0x03, 0x0242, 0x000e}, + CmdLutElement{0x09, 0x02, -1, 0x03, 0x0242, 0x0012}, + CmdLutElement{0x09, 0x03, -1, 0x03, 0x0242, 0x0016}, + CmdLutElement{0x09, 0x03, -1, 0x03, 0x0242, 0x001e}, + CmdLutElement{0x09, 0x04, -1, 0x03, 0x0242, 0x0026}, + CmdLutElement{0x09, 0x04, -1, 0x03, 0x0242, 0x0036}, + CmdLutElement{0x0a, 0x01, -1, 0x03, 0x0442, 0x000a}, + CmdLutElement{0x0a, 0x01, -1, 0x03, 0x0442, 0x000c}, + CmdLutElement{0x0a, 0x02, -1, 0x03, 0x0442, 0x000e}, + CmdLutElement{0x0a, 0x02, -1, 0x03, 0x0442, 0x0012}, + CmdLutElement{0x0a, 0x03, -1, 0x03, 0x0442, 0x0016}, + CmdLutElement{0x0a, 0x03, -1, 0x03, 0x0442, 0x001e}, + CmdLutElement{0x0a, 0x04, -1, 0x03, 0x0442, 0x0026}, + CmdLutElement{0x0a, 0x04, -1, 0x03, 0x0442, 0x0036}, + CmdLutElement{0x0c, 0x01, -1, 0x03, 0x0842, 0x000a}, + CmdLutElement{0x0c, 0x01, -1, 0x03, 0x0842, 0x000c}, + CmdLutElement{0x0c, 0x02, -1, 0x03, 0x0842, 0x000e}, + CmdLutElement{0x0c, 0x02, -1, 0x03, 0x0842, 0x0012}, + CmdLutElement{0x0c, 0x03, -1, 0x03, 0x0842, 0x0016}, + CmdLutElement{0x0c, 0x03, -1, 0x03, 0x0842, 0x001e}, + CmdLutElement{0x0c, 0x04, -1, 0x03, 0x0842, 0x0026}, + CmdLutElement{0x0c, 0x04, -1, 0x03, 0x0842, 0x0036}, + CmdLutElement{0x0e, 0x01, -1, 0x03, 0x1842, 0x000a}, + CmdLutElement{0x0e, 0x01, -1, 0x03, 0x1842, 0x000c}, + CmdLutElement{0x0e, 0x02, -1, 0x03, 0x1842, 0x000e}, + CmdLutElement{0x0e, 0x02, -1, 0x03, 0x1842, 0x0012}, + CmdLutElement{0x0e, 0x03, -1, 0x03, 0x1842, 0x0016}, + CmdLutElement{0x0e, 0x03, -1, 0x03, 0x1842, 0x001e}, + CmdLutElement{0x0e, 0x04, -1, 0x03, 0x1842, 0x0026}, + CmdLutElement{0x0e, 0x04, -1, 0x03, 0x1842, 0x0036}, + CmdLutElement{0x18, 0x01, -1, 0x03, 0x5842, 0x000a}, + CmdLutElement{0x18, 0x01, -1, 0x03, 0x5842, 0x000c}, + CmdLutElement{0x18, 0x02, -1, 0x03, 0x5842, 0x000e}, + CmdLutElement{0x18, 0x02, -1, 0x03, 0x5842, 0x0012}, + CmdLutElement{0x18, 0x03, -1, 0x03, 0x5842, 0x0016}, + CmdLutElement{0x18, 0x03, -1, 0x03, 0x5842, 0x001e}, + CmdLutElement{0x18, 0x04, -1, 0x03, 0x5842, 0x0026}, + CmdLutElement{0x18, 0x04, -1, 0x03, 0x5842, 0x0036}, + CmdLutElement{0x06, 0x05, -1, 0x03, 0x0082, 0x0046}, + CmdLutElement{0x06, 0x05, -1, 0x03, 0x0082, 0x0066}, + CmdLutElement{0x06, 0x06, -1, 0x03, 0x0082, 0x0086}, + CmdLutElement{0x06, 0x07, -1, 0x03, 0x0082, 0x00c6}, + CmdLutElement{0x06, 0x08, -1, 0x03, 0x0082, 0x0146}, + CmdLutElement{0x06, 0x09, -1, 0x03, 0x0082, 0x0246}, + CmdLutElement{0x06, 0x0a, -1, 0x03, 0x0082, 0x0446}, + CmdLutElement{0x06, 0x18, -1, 0x03, 0x0082, 0x0846}, + CmdLutElement{0x07, 0x05, -1, 0x03, 0x00c2, 0x0046}, + CmdLutElement{0x07, 0x05, -1, 0x03, 0x00c2, 0x0066}, + CmdLutElement{0x07, 0x06, -1, 0x03, 0x00c2, 0x0086}, + CmdLutElement{0x07, 0x07, -1, 0x03, 0x00c2, 0x00c6}, + CmdLutElement{0x07, 0x08, -1, 0x03, 0x00c2, 0x0146}, + CmdLutElement{0x07, 0x09, -1, 0x03, 0x00c2, 0x0246}, + CmdLutElement{0x07, 0x0a, -1, 0x03, 0x00c2, 0x0446}, + CmdLutElement{0x07, 0x18, -1, 0x03, 0x00c2, 0x0846}, + CmdLutElement{0x08, 0x05, -1, 0x03, 0x0142, 0x0046}, + CmdLutElement{0x08, 0x05, -1, 0x03, 0x0142, 0x0066}, + CmdLutElement{0x08, 0x06, -1, 0x03, 0x0142, 0x0086}, + CmdLutElement{0x08, 0x07, -1, 0x03, 0x0142, 0x00c6}, + CmdLutElement{0x08, 0x08, -1, 0x03, 0x0142, 0x0146}, + CmdLutElement{0x08, 0x09, -1, 0x03, 0x0142, 0x0246}, + CmdLutElement{0x08, 0x0a, -1, 0x03, 0x0142, 0x0446}, + CmdLutElement{0x08, 0x18, -1, 0x03, 0x0142, 0x0846}, + CmdLutElement{0x09, 0x05, -1, 0x03, 0x0242, 0x0046}, + CmdLutElement{0x09, 0x05, -1, 0x03, 0x0242, 0x0066}, + CmdLutElement{0x09, 0x06, -1, 0x03, 0x0242, 0x0086}, + CmdLutElement{0x09, 0x07, -1, 0x03, 0x0242, 0x00c6}, + CmdLutElement{0x09, 0x08, -1, 0x03, 0x0242, 0x0146}, + CmdLutElement{0x09, 0x09, -1, 0x03, 0x0242, 0x0246}, + CmdLutElement{0x09, 0x0a, -1, 0x03, 0x0242, 0x0446}, + CmdLutElement{0x09, 0x18, -1, 0x03, 0x0242, 0x0846}, + CmdLutElement{0x0a, 0x05, -1, 0x03, 0x0442, 0x0046}, + CmdLutElement{0x0a, 0x05, -1, 0x03, 0x0442, 0x0066}, + CmdLutElement{0x0a, 0x06, -1, 0x03, 0x0442, 0x0086}, + CmdLutElement{0x0a, 0x07, -1, 0x03, 0x0442, 0x00c6}, + CmdLutElement{0x0a, 0x08, -1, 0x03, 0x0442, 0x0146}, + CmdLutElement{0x0a, 0x09, -1, 0x03, 0x0442, 0x0246}, + CmdLutElement{0x0a, 0x0a, -1, 0x03, 0x0442, 0x0446}, + CmdLutElement{0x0a, 0x18, -1, 0x03, 0x0442, 0x0846}, + CmdLutElement{0x0c, 0x05, -1, 0x03, 0x0842, 0x0046}, + CmdLutElement{0x0c, 0x05, -1, 0x03, 0x0842, 0x0066}, + CmdLutElement{0x0c, 0x06, -1, 0x03, 0x0842, 0x0086}, + CmdLutElement{0x0c, 0x07, -1, 0x03, 0x0842, 0x00c6}, + CmdLutElement{0x0c, 0x08, -1, 0x03, 0x0842, 0x0146}, + CmdLutElement{0x0c, 0x09, -1, 0x03, 0x0842, 0x0246}, + CmdLutElement{0x0c, 0x0a, -1, 0x03, 0x0842, 0x0446}, + CmdLutElement{0x0c, 0x18, -1, 0x03, 0x0842, 0x0846}, + CmdLutElement{0x0e, 0x05, -1, 0x03, 0x1842, 0x0046}, + CmdLutElement{0x0e, 0x05, -1, 0x03, 0x1842, 0x0066}, + CmdLutElement{0x0e, 0x06, -1, 0x03, 0x1842, 0x0086}, + CmdLutElement{0x0e, 0x07, -1, 0x03, 0x1842, 0x00c6}, + CmdLutElement{0x0e, 0x08, -1, 0x03, 0x1842, 0x0146}, + CmdLutElement{0x0e, 0x09, -1, 0x03, 0x1842, 0x0246}, + CmdLutElement{0x0e, 0x0a, -1, 0x03, 0x1842, 0x0446}, + CmdLutElement{0x0e, 0x18, -1, 0x03, 0x1842, 0x0846}, + CmdLutElement{0x18, 0x05, -1, 0x03, 0x5842, 0x0046}, + CmdLutElement{0x18, 0x05, -1, 0x03, 0x5842, 0x0066}, + CmdLutElement{0x18, 0x06, -1, 0x03, 0x5842, 0x0086}, + CmdLutElement{0x18, 0x07, -1, 0x03, 0x5842, 0x00c6}, + CmdLutElement{0x18, 0x08, -1, 0x03, 0x5842, 0x0146}, + CmdLutElement{0x18, 0x09, -1, 0x03, 0x5842, 0x0246}, + CmdLutElement{0x18, 0x0a, -1, 0x03, 0x5842, 0x0446}, + CmdLutElement{0x18, 0x18, -1, 0x03, 0x5842, 0x0846}, +} diff --git a/quality.go b/quality.go new file mode 100644 index 0000000..d33c930 --- /dev/null +++ b/quality.go @@ -0,0 +1,196 @@ +package brotli + +const FAST_ONE_PASS_COMPRESSION_QUALITY = 0 + +const FAST_TWO_PASS_COMPRESSION_QUALITY = 1 + +const ZOPFLIFICATION_QUALITY = 10 + +const HQ_ZOPFLIFICATION_QUALITY = 11 + +const MAX_QUALITY_FOR_STATIC_ENTROPY_CODES = 2 + +const MIN_QUALITY_FOR_BLOCK_SPLIT = 4 + +const MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS = 4 + +const MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS = 4 + +const MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH = 5 + +const MIN_QUALITY_FOR_CONTEXT_MODELING = 5 + +const MIN_QUALITY_FOR_HQ_CONTEXT_MODELING = 7 + +const MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING = 10 + +/* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting, + so we buffer at most this much literals and commands. */ +const MAX_NUM_DELAYED_SYMBOLS = 0x2FFF + +/* Returns hash-table size for quality levels 0 and 1. */ +func MaxHashTableSize(quality int) uint { + if quality == FAST_ONE_PASS_COMPRESSION_QUALITY { + return 1 << 15 + } else { + return 1 << 17 + } +} + +/* The maximum length for which the zopflification uses distinct distances. */ +const MAX_ZOPFLI_LEN_QUALITY_10 = 150 + +const MAX_ZOPFLI_LEN_QUALITY_11 = 325 + +/* Do not thoroughly search when a long copy is found. */ +const BROTLI_LONG_COPY_QUICK_STEP = 16384 + +func MaxZopfliLen(params *BrotliEncoderParams) uint { + if params.quality <= 10 { + return MAX_ZOPFLI_LEN_QUALITY_10 + } else { + return MAX_ZOPFLI_LEN_QUALITY_11 + } +} + +/* Number of best candidates to evaluate to expand Zopfli chain. */ +func MaxZopfliCandidates(params *BrotliEncoderParams) uint { + if params.quality <= 10 { + return 1 + } else { + return 5 + } +} + +func SanitizeParams(params *BrotliEncoderParams) { + params.quality = brotli_min_int(BROTLI_MAX_QUALITY, brotli_max_int(BROTLI_MIN_QUALITY, params.quality)) + if params.quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES { + params.large_window = false + } + + if params.lgwin < BROTLI_MIN_WINDOW_BITS { + params.lgwin = BROTLI_MIN_WINDOW_BITS + } else { + var max_lgwin int + if params.large_window { + max_lgwin = BROTLI_LARGE_MAX_WINDOW_BITS + } else { + max_lgwin = BROTLI_MAX_WINDOW_BITS + } + if params.lgwin > uint(max_lgwin) { + params.lgwin = uint(max_lgwin) + } + } +} + +/* Returns optimized lg_block value. */ +func ComputeLgBlock(params *BrotliEncoderParams) int { + var lgblock int = params.lgblock + if params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY || params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY { + lgblock = int(params.lgwin) + } else if params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT { + lgblock = 14 + } else if lgblock == 0 { + lgblock = 16 + if params.quality >= 9 && params.lgwin > uint(lgblock) { + lgblock = brotli_min_int(18, int(params.lgwin)) + } + } else { + lgblock = brotli_min_int(BROTLI_MAX_INPUT_BLOCK_BITS, brotli_max_int(BROTLI_MIN_INPUT_BLOCK_BITS, lgblock)) + } + + return lgblock +} + +/* Returns log2 of the size of main ring buffer area. + Allocate at least lgwin + 1 bits for the ring buffer so that the newly + added block fits there completely and we still get lgwin bits and at least + read_block_size_bits + 1 bits because the copy tail length needs to be + smaller than ring-buffer size. */ +func ComputeRbBits(params *BrotliEncoderParams) int { + return 1 + brotli_max_int(int(params.lgwin), params.lgblock) +} + +func MaxMetablockSize(params *BrotliEncoderParams) uint { + var bits int = brotli_min_int(ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS) + return uint(1) << uint(bits) +} + +/* When searching for backward references and have not seen matches for a long + time, we can skip some match lookups. Unsuccessful match lookups are very + expensive and this kind of a heuristic speeds up compression quite a lot. + At first 8 byte strides are taken and every second byte is put to hasher. + After 4x more literals stride by 16 bytes, every put 4-th byte to hasher. + Applied only to qualities 2 to 9. */ +func LiteralSpreeLengthForSparseSearch(params *BrotliEncoderParams) uint { + if params.quality < 9 { + return 64 + } else { + return 512 + } +} + +func ChooseHasher(params *BrotliEncoderParams, hparams *BrotliHasherParams) { + if params.quality > 9 { + hparams.type_ = 10 + } else if params.quality == 4 && params.size_hint >= 1<<20 { + hparams.type_ = 54 + } else if params.quality < 5 { + hparams.type_ = params.quality + } else if params.lgwin <= 16 { + if params.quality < 7 { + hparams.type_ = 40 + } else if params.quality < 9 { + hparams.type_ = 41 + } else { + hparams.type_ = 42 + } + } else if params.size_hint >= 1<<20 && params.lgwin >= 19 { + hparams.type_ = 6 + hparams.block_bits = params.quality - 1 + hparams.bucket_bits = 15 + hparams.hash_len = 5 + if params.quality < 7 { + hparams.num_last_distances_to_check = 4 + } else if params.quality < 9 { + hparams.num_last_distances_to_check = 10 + } else { + hparams.num_last_distances_to_check = 16 + } + } else { + hparams.type_ = 5 + hparams.block_bits = params.quality - 1 + if params.quality < 7 { + hparams.bucket_bits = 14 + } else { + hparams.bucket_bits = 15 + } + if params.quality < 7 { + hparams.num_last_distances_to_check = 4 + } else if params.quality < 9 { + hparams.num_last_distances_to_check = 10 + } else { + hparams.num_last_distances_to_check = 16 + } + } + + if params.lgwin > 24 { + /* Different hashers for large window brotli: not for qualities <= 2, + these are too fast for large window. Not for qualities >= 10: their + hasher already works well with large window. So the changes are: + H3 --> H35: for quality 3. + H54 --> H55: for quality 4 with size hint > 1MB + H6 --> H65: for qualities 5, 6, 7, 8, 9. */ + if hparams.type_ == 3 { + hparams.type_ = 35 + } + + if hparams.type_ == 54 { + hparams.type_ = 55 + } + + if hparams.type_ == 6 { + hparams.type_ = 65 + } + } +} diff --git a/ringbuffer.go b/ringbuffer.go new file mode 100644 index 0000000..5f5d929 --- /dev/null +++ b/ringbuffer.go @@ -0,0 +1,146 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Implementation of Brotli compressor. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Sliding window over the input data. */ + +/* A RingBuffer(window_bits, tail_bits) contains `1 << window_bits' bytes of + data in a circular manner: writing a byte writes it to: + `position() % (1 << window_bits)'. + For convenience, the RingBuffer array contains another copy of the + first `1 << tail_bits' bytes: + buffer_[i] == buffer_[i + (1 << window_bits)], if i < (1 << tail_bits), + and another copy of the last two bytes: + buffer_[-1] == buffer_[(1 << window_bits) - 1] and + buffer_[-2] == buffer_[(1 << window_bits) - 2]. */ +type RingBuffer struct { + size_ uint32 + mask_ uint32 + tail_size_ uint32 + total_size_ uint32 + cur_size_ uint32 + pos_ uint32 + data_ []byte + buffer_ []byte +} + +func RingBufferInit(rb *RingBuffer) { + rb.cur_size_ = 0 + rb.pos_ = 0 + rb.data_ = nil + rb.buffer_ = nil +} + +func RingBufferSetup(params *BrotliEncoderParams, rb *RingBuffer) { + var window_bits int = ComputeRbBits(params) + var tail_bits int = params.lgblock + *(*uint32)(&rb.size_) = 1 << uint(window_bits) + *(*uint32)(&rb.mask_) = (1 << uint(window_bits)) - 1 + *(*uint32)(&rb.tail_size_) = 1 << uint(tail_bits) + *(*uint32)(&rb.total_size_) = rb.size_ + rb.tail_size_ +} + +func RingBufferFree(rb *RingBuffer) { + rb.data_ = nil +} + +/* Allocates or re-allocates data_ to the given length + plus some slack + region before and after. Fills the slack regions with zeros. */ + +var RingBufferInitBuffer_kSlackForEightByteHashingEverywhere uint = 7 + +func RingBufferInitBuffer(buflen uint32, rb *RingBuffer) { + var new_data []byte = make([]byte, (2 + uint(buflen) + RingBufferInitBuffer_kSlackForEightByteHashingEverywhere)) + var i uint + if rb.data_ != nil { + copy(new_data, rb.data_[:2+rb.cur_size_+uint32(RingBufferInitBuffer_kSlackForEightByteHashingEverywhere)]) + rb.data_ = nil + } + + rb.data_ = new_data + rb.cur_size_ = buflen + rb.buffer_ = rb.data_[2:] + rb.data_[1] = 0 + rb.data_[0] = rb.data_[1] + for i = 0; i < RingBufferInitBuffer_kSlackForEightByteHashingEverywhere; i++ { + rb.buffer_[rb.cur_size_+uint32(i)] = 0 + } +} + +func RingBufferWriteTail(bytes []byte, n uint, rb *RingBuffer) { + var masked_pos uint = uint(rb.pos_ & rb.mask_) + if uint32(masked_pos) < rb.tail_size_ { + /* Just fill the tail buffer with the beginning data. */ + var p uint = uint(rb.size_ + uint32(masked_pos)) + copy(rb.buffer_[p:], bytes[:brotli_min_size_t(n, uint(rb.tail_size_-uint32(masked_pos)))]) + } +} + +/* Push bytes into the ring buffer. */ +func RingBufferWrite(bytes []byte, n uint, rb *RingBuffer) { + if rb.pos_ == 0 && uint32(n) < rb.tail_size_ { + /* Special case for the first write: to process the first block, we don't + need to allocate the whole ring-buffer and we don't need the tail + either. However, we do this memory usage optimization only if the + first write is less than the tail size, which is also the input block + size, otherwise it is likely that other blocks will follow and we + will need to reallocate to the full size anyway. */ + rb.pos_ = uint32(n) + + RingBufferInitBuffer(rb.pos_, rb) + copy(rb.buffer_, bytes[:n]) + return + } + + if rb.cur_size_ < rb.total_size_ { + /* Lazily allocate the full buffer. */ + RingBufferInitBuffer(rb.total_size_, rb) + + /* Initialize the last two bytes to zero, so that we don't have to worry + later when we copy the last two bytes to the first two positions. */ + rb.buffer_[rb.size_-2] = 0 + + rb.buffer_[rb.size_-1] = 0 + } + { + var masked_pos uint = uint(rb.pos_ & rb.mask_) + + /* The length of the writes is limited so that we do not need to worry + about a write */ + RingBufferWriteTail(bytes, n, rb) + + if uint32(masked_pos+n) <= rb.size_ { + /* A single write fits. */ + copy(rb.buffer_[masked_pos:], bytes[:n]) + } else { + /* Split into two writes. + Copy into the end of the buffer, including the tail buffer. */ + copy(rb.buffer_[masked_pos:], bytes[:brotli_min_size_t(n, uint(rb.total_size_-uint32(masked_pos)))]) + + /* Copy into the beginning of the buffer */ + copy(rb.buffer_, bytes[rb.size_-uint32(masked_pos):][:uint32(n)-(rb.size_-uint32(masked_pos))]) + } + } + { + var not_first_lap bool = rb.pos_&(1<<31) != 0 + var rb_pos_mask uint32 = (1 << 31) - 1 + rb.data_[0] = rb.buffer_[rb.size_-2] + rb.data_[1] = rb.buffer_[rb.size_-1] + rb.pos_ = (rb.pos_ & rb_pos_mask) + uint32(uint32(n)&rb_pos_mask) + if not_first_lap { + /* Wrap, but preserve not-a-first-lap feature. */ + rb.pos_ |= 1 << 31 + } + } +} diff --git a/state.go b/state.go new file mode 100644 index 0000000..9fbe66e --- /dev/null +++ b/state.go @@ -0,0 +1,301 @@ +package brotli + +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Brotli state for partial streaming decoding. */ +const ( + BROTLI_STATE_UNINITED = iota + BROTLI_STATE_LARGE_WINDOW_BITS + BROTLI_STATE_INITIALIZE + BROTLI_STATE_METABLOCK_BEGIN + BROTLI_STATE_METABLOCK_HEADER + BROTLI_STATE_METABLOCK_HEADER_2 + BROTLI_STATE_CONTEXT_MODES + BROTLI_STATE_COMMAND_BEGIN + BROTLI_STATE_COMMAND_INNER + BROTLI_STATE_COMMAND_POST_DECODE_LITERALS + BROTLI_STATE_COMMAND_POST_WRAP_COPY + BROTLI_STATE_UNCOMPRESSED + BROTLI_STATE_METADATA + BROTLI_STATE_COMMAND_INNER_WRITE + BROTLI_STATE_METABLOCK_DONE + BROTLI_STATE_COMMAND_POST_WRITE_1 + BROTLI_STATE_COMMAND_POST_WRITE_2 + BROTLI_STATE_HUFFMAN_CODE_0 + BROTLI_STATE_HUFFMAN_CODE_1 + BROTLI_STATE_HUFFMAN_CODE_2 + BROTLI_STATE_HUFFMAN_CODE_3 + BROTLI_STATE_CONTEXT_MAP_1 + BROTLI_STATE_CONTEXT_MAP_2 + BROTLI_STATE_TREE_GROUP + BROTLI_STATE_DONE +) + +const ( + BROTLI_STATE_METABLOCK_HEADER_NONE = iota + BROTLI_STATE_METABLOCK_HEADER_EMPTY + BROTLI_STATE_METABLOCK_HEADER_NIBBLES + BROTLI_STATE_METABLOCK_HEADER_SIZE + BROTLI_STATE_METABLOCK_HEADER_UNCOMPRESSED + BROTLI_STATE_METABLOCK_HEADER_RESERVED + BROTLI_STATE_METABLOCK_HEADER_BYTES + BROTLI_STATE_METABLOCK_HEADER_METADATA +) + +const ( + BROTLI_STATE_UNCOMPRESSED_NONE = iota + BROTLI_STATE_UNCOMPRESSED_WRITE +) + +const ( + BROTLI_STATE_TREE_GROUP_NONE = iota + BROTLI_STATE_TREE_GROUP_LOOP +) + +const ( + BROTLI_STATE_CONTEXT_MAP_NONE = iota + BROTLI_STATE_CONTEXT_MAP_READ_PREFIX + BROTLI_STATE_CONTEXT_MAP_HUFFMAN + BROTLI_STATE_CONTEXT_MAP_DECODE + BROTLI_STATE_CONTEXT_MAP_TRANSFORM +) + +const ( + BROTLI_STATE_HUFFMAN_NONE = iota + BROTLI_STATE_HUFFMAN_SIMPLE_SIZE + BROTLI_STATE_HUFFMAN_SIMPLE_READ + BROTLI_STATE_HUFFMAN_SIMPLE_BUILD + BROTLI_STATE_HUFFMAN_COMPLEX + BROTLI_STATE_HUFFMAN_LENGTH_SYMBOLS +) + +const ( + BROTLI_STATE_DECODE_UINT8_NONE = iota + BROTLI_STATE_DECODE_UINT8_SHORT + BROTLI_STATE_DECODE_UINT8_LONG +) + +const ( + BROTLI_STATE_READ_BLOCK_LENGTH_NONE = iota + BROTLI_STATE_READ_BLOCK_LENGTH_SUFFIX +) + +type BrotliDecoderState struct { + state int + loop_counter int + br BrotliBitReader + buffer struct { + u64 uint64 + u8 [8]byte + } + buffer_length uint32 + pos int + max_backward_distance int + max_distance int + ringbuffer_size int + ringbuffer_mask int + dist_rb_idx int + dist_rb [4]int + error_code int + sub_loop_counter uint32 + ringbuffer []byte + ringbuffer_end []byte + htree_command []HuffmanCode + context_lookup []byte + context_map_slice []byte + dist_context_map_slice []byte + literal_hgroup HuffmanTreeGroup + insert_copy_hgroup HuffmanTreeGroup + distance_hgroup HuffmanTreeGroup + block_type_trees []HuffmanCode + block_len_trees []HuffmanCode + trivial_literal_context int + distance_context int + meta_block_remaining_len int + block_length_index uint32 + block_length [3]uint32 + num_block_types [3]uint32 + block_type_rb [6]uint32 + distance_postfix_bits uint32 + num_direct_distance_codes uint32 + distance_postfix_mask int + num_dist_htrees uint32 + dist_context_map []byte + literal_htree []HuffmanCode + dist_htree_index byte + repeat_code_len uint32 + prev_code_len uint32 + copy_length int + distance_code int + rb_roundtrips uint + partial_pos_out uint + symbol uint32 + repeat uint32 + space uint32 + table [32]HuffmanCode + symbol_lists SymbolList + symbols_lists_array [BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + BROTLI_NUM_COMMAND_SYMBOLS]uint16 + next_symbol [32]int + code_length_code_lengths [BROTLI_CODE_LENGTH_CODES]byte + code_length_histo [16]uint16 + htree_index int + next []HuffmanCode + context_index uint32 + max_run_length_prefix uint32 + code uint32 + context_map_table [BROTLI_HUFFMAN_MAX_SIZE_272]HuffmanCode + substate_metablock_header int + substate_tree_group int + substate_context_map int + substate_uncompressed int + substate_huffman int + substate_decode_uint8 int + substate_read_block_length int + is_last_metablock uint + is_uncompressed uint + is_metadata uint + should_wrap_ringbuffer uint + canny_ringbuffer_allocation uint + large_window bool + size_nibbles uint + window_bits uint32 + new_ringbuffer_size int + num_literal_htrees uint32 + context_map []byte + context_modes []byte + dictionary *BrotliDictionary + transforms *BrotliTransforms + trivial_literal_contexts [8]uint32 +} + +func BrotliDecoderStateInit(s *BrotliDecoderState) bool { + s.error_code = 0 /* BROTLI_DECODER_NO_ERROR */ + + BrotliInitBitReader(&s.br) + s.state = BROTLI_STATE_UNINITED + s.large_window = false + s.substate_metablock_header = BROTLI_STATE_METABLOCK_HEADER_NONE + s.substate_tree_group = BROTLI_STATE_TREE_GROUP_NONE + s.substate_context_map = BROTLI_STATE_CONTEXT_MAP_NONE + s.substate_uncompressed = BROTLI_STATE_UNCOMPRESSED_NONE + s.substate_huffman = BROTLI_STATE_HUFFMAN_NONE + s.substate_decode_uint8 = BROTLI_STATE_DECODE_UINT8_NONE + s.substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE + + s.buffer_length = 0 + s.loop_counter = 0 + s.pos = 0 + s.rb_roundtrips = 0 + s.partial_pos_out = 0 + + s.block_type_trees = nil + s.block_len_trees = nil + s.ringbuffer = nil + s.ringbuffer_size = 0 + s.new_ringbuffer_size = 0 + s.ringbuffer_mask = 0 + + s.context_map = nil + s.context_modes = nil + s.dist_context_map = nil + s.context_map_slice = nil + s.dist_context_map_slice = nil + + s.sub_loop_counter = 0 + + s.literal_hgroup.codes = nil + s.literal_hgroup.htrees = nil + s.insert_copy_hgroup.codes = nil + s.insert_copy_hgroup.htrees = nil + s.distance_hgroup.codes = nil + s.distance_hgroup.htrees = nil + + s.is_last_metablock = 0 + s.is_uncompressed = 0 + s.is_metadata = 0 + s.should_wrap_ringbuffer = 0 + s.canny_ringbuffer_allocation = 1 + + s.window_bits = 0 + s.max_distance = 0 + s.dist_rb[0] = 16 + s.dist_rb[1] = 15 + s.dist_rb[2] = 11 + s.dist_rb[3] = 4 + s.dist_rb_idx = 0 + s.block_type_trees = nil + s.block_len_trees = nil + + s.symbol_lists.storage = s.symbols_lists_array[:] + s.symbol_lists.offset = BROTLI_HUFFMAN_MAX_CODE_LENGTH + 1 + + s.dictionary = BrotliGetDictionary() + s.transforms = BrotliGetTransforms() + + return true +} + +func BrotliDecoderStateMetablockBegin(s *BrotliDecoderState) { + s.meta_block_remaining_len = 0 + s.block_length[0] = 1 << 24 + s.block_length[1] = 1 << 24 + s.block_length[2] = 1 << 24 + s.num_block_types[0] = 1 + s.num_block_types[1] = 1 + s.num_block_types[2] = 1 + s.block_type_rb[0] = 1 + s.block_type_rb[1] = 0 + s.block_type_rb[2] = 1 + s.block_type_rb[3] = 0 + s.block_type_rb[4] = 1 + s.block_type_rb[5] = 0 + s.context_map = nil + s.context_modes = nil + s.dist_context_map = nil + s.context_map_slice = nil + s.literal_htree = nil + s.dist_context_map_slice = nil + s.dist_htree_index = 0 + s.context_lookup = nil + s.literal_hgroup.codes = nil + s.literal_hgroup.htrees = nil + s.insert_copy_hgroup.codes = nil + s.insert_copy_hgroup.htrees = nil + s.distance_hgroup.codes = nil + s.distance_hgroup.htrees = nil +} + +func BrotliDecoderStateCleanupAfterMetablock(s *BrotliDecoderState) { + s.context_modes = nil + s.context_map = nil + s.dist_context_map = nil + s.literal_hgroup.htrees = nil + s.insert_copy_hgroup.htrees = nil + s.distance_hgroup.htrees = nil +} + +func BrotliDecoderStateCleanup(s *BrotliDecoderState) { + BrotliDecoderStateCleanupAfterMetablock(s) + + s.ringbuffer = nil + s.block_type_trees = nil +} + +func BrotliDecoderHuffmanTreeGroupInit(s *BrotliDecoderState, group *HuffmanTreeGroup, alphabet_size uint32, max_symbol uint32, ntrees uint32) bool { + var max_table_size uint = uint(kMaxHuffmanTableSize[(alphabet_size+31)>>5]) + group.alphabet_size = uint16(alphabet_size) + group.max_symbol = uint16(max_symbol) + group.num_htrees = uint16(ntrees) + group.htrees = make([][]HuffmanCode, ntrees) + group.codes = make([]HuffmanCode, (uint(ntrees) * max_table_size)) + return !(group.codes == nil) +} diff --git a/static_dict.go b/static_dict.go new file mode 100644 index 0000000..57a93bf --- /dev/null +++ b/static_dict.go @@ -0,0 +1,663 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Class to model the static dictionary. */ +const BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN = 37 + +var kInvalidMatch uint32 = 0xFFFFFFF + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +func Hash(data []byte) uint32 { + var h uint32 = BROTLI_UNALIGNED_LOAD32LE(data) * kDictHashMul32 + + /* The higher bits contain more mixture from the multiplication, + so we take our results from there. */ + return h >> uint(32-kDictNumBits) +} + +func AddMatch(distance uint, len uint, len_code uint, matches []uint32) { + var match uint32 = uint32((distance << 5) + len_code) + matches[len] = brotli_min_uint32_t(matches[len], match) +} + +func DictMatchLength(dictionary *BrotliDictionary, data []byte, id uint, len uint, maxlen uint) uint { + var offset uint = uint(dictionary.offsets_by_length[len]) + len*id + return FindMatchLengthWithLimit(dictionary.data[offset:], data, brotli_min_size_t(uint(len), maxlen)) +} + +func IsMatch(dictionary *BrotliDictionary, w DictWord, data []byte, max_length uint) bool { + if uint(w.len) > max_length { + return false + } else { + var offset uint = uint(dictionary.offsets_by_length[w.len]) + uint(w.len)*uint(w.idx) + var dict []byte = dictionary.data[offset:] + if w.transform == 0 { + /* Match against base dictionary word. */ + return FindMatchLengthWithLimit(dict, data, uint(w.len)) == uint(w.len) + } else if w.transform == 10 { + /* Match against uppercase first transform. + Note that there are only ASCII uppercase words in the lookup table. */ + return dict[0] >= 'a' && dict[0] <= 'z' && (dict[0]^32) == data[0] && FindMatchLengthWithLimit(dict[1:], data[1:], uint(w.len)-1) == uint(w.len-1) + } else { + /* Match against uppercase all transform. + Note that there are only ASCII uppercase words in the lookup table. */ + var i uint + for i = 0; i < uint(w.len); i++ { + if dict[i] >= 'a' && dict[i] <= 'z' { + if (dict[i] ^ 32) != data[i] { + return false + } + } else { + if dict[i] != data[i] { + return false + } + } + } + + return true + } + } +} + +func BrotliFindAllStaticDictionaryMatches(dictionary *BrotliEncoderDictionary, data []byte, min_length uint, max_length uint, matches []uint32) bool { + var has_found_match bool = false + { + var offset uint = uint(dictionary.buckets[Hash(data)]) + var end bool = offset == 0 + for !end { + var w DictWord + w = dictionary.dict_words[offset] + offset++ + var l uint = uint(w.len) & 0x1F + var n uint = uint(1) << dictionary.words.size_bits_by_length[l] + var id uint = uint(w.idx) + end = !(w.len&0x80 == 0) + w.len = byte(l) + if w.transform == 0 { + var matchlen uint = DictMatchLength(dictionary.words, data, id, l, max_length) + var s []byte + var minlen uint + var maxlen uint + var len uint + + /* Transform "" + BROTLI_TRANSFORM_IDENTITY + "" */ + if matchlen == l { + AddMatch(id, l, l, matches) + has_found_match = true + } + + /* Transforms "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "" and + "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "ing " */ + if matchlen >= l-1 { + AddMatch(id+12*n, l-1, l, matches) + if l+2 < max_length && data[l-1] == 'i' && data[l] == 'n' && data[l+1] == 'g' && data[l+2] == ' ' { + AddMatch(id+49*n, l+3, l, matches) + } + + has_found_match = true + } + + /* Transform "" + BROTLI_TRANSFORM_OMIT_LAST_# + "" (# = 2 .. 9) */ + minlen = min_length + + if l > 9 { + minlen = brotli_max_size_t(minlen, l-9) + } + maxlen = brotli_min_size_t(matchlen, l-2) + for len = minlen; len <= maxlen; len++ { + var cut uint = l - len + var transform_id uint = (cut << 2) + uint((dictionary.cutoffTransforms>>(cut*6))&0x3F) + AddMatch(id+transform_id*n, uint(len), l, matches) + has_found_match = true + } + + if matchlen < l || l+6 >= max_length { + continue + } + + s = data[l:] + + /* Transforms "" + BROTLI_TRANSFORM_IDENTITY + */ + if s[0] == ' ' { + AddMatch(id+n, l+1, l, matches) + if s[1] == 'a' { + if s[2] == ' ' { + AddMatch(id+28*n, l+3, l, matches) + } else if s[2] == 's' { + if s[3] == ' ' { + AddMatch(id+46*n, l+4, l, matches) + } + } else if s[2] == 't' { + if s[3] == ' ' { + AddMatch(id+60*n, l+4, l, matches) + } + } else if s[2] == 'n' { + if s[3] == 'd' && s[4] == ' ' { + AddMatch(id+10*n, l+5, l, matches) + } + } + } else if s[1] == 'b' { + if s[2] == 'y' && s[3] == ' ' { + AddMatch(id+38*n, l+4, l, matches) + } + } else if s[1] == 'i' { + if s[2] == 'n' { + if s[3] == ' ' { + AddMatch(id+16*n, l+4, l, matches) + } + } else if s[2] == 's' { + if s[3] == ' ' { + AddMatch(id+47*n, l+4, l, matches) + } + } + } else if s[1] == 'f' { + if s[2] == 'o' { + if s[3] == 'r' && s[4] == ' ' { + AddMatch(id+25*n, l+5, l, matches) + } + } else if s[2] == 'r' { + if s[3] == 'o' && s[4] == 'm' && s[5] == ' ' { + AddMatch(id+37*n, l+6, l, matches) + } + } + } else if s[1] == 'o' { + if s[2] == 'f' { + if s[3] == ' ' { + AddMatch(id+8*n, l+4, l, matches) + } + } else if s[2] == 'n' { + if s[3] == ' ' { + AddMatch(id+45*n, l+4, l, matches) + } + } + } else if s[1] == 'n' { + if s[2] == 'o' && s[3] == 't' && s[4] == ' ' { + AddMatch(id+80*n, l+5, l, matches) + } + } else if s[1] == 't' { + if s[2] == 'h' { + if s[3] == 'e' { + if s[4] == ' ' { + AddMatch(id+5*n, l+5, l, matches) + } + } else if s[3] == 'a' { + if s[4] == 't' && s[5] == ' ' { + AddMatch(id+29*n, l+6, l, matches) + } + } + } else if s[2] == 'o' { + if s[3] == ' ' { + AddMatch(id+17*n, l+4, l, matches) + } + } + } else if s[1] == 'w' { + if s[2] == 'i' && s[3] == 't' && s[4] == 'h' && s[5] == ' ' { + AddMatch(id+35*n, l+6, l, matches) + } + } + } else if s[0] == '"' { + AddMatch(id+19*n, l+1, l, matches) + if s[1] == '>' { + AddMatch(id+21*n, l+2, l, matches) + } + } else if s[0] == '.' { + AddMatch(id+20*n, l+1, l, matches) + if s[1] == ' ' { + AddMatch(id+31*n, l+2, l, matches) + if s[2] == 'T' && s[3] == 'h' { + if s[4] == 'e' { + if s[5] == ' ' { + AddMatch(id+43*n, l+6, l, matches) + } + } else if s[4] == 'i' { + if s[5] == 's' && s[6] == ' ' { + AddMatch(id+75*n, l+7, l, matches) + } + } + } + } + } else if s[0] == ',' { + AddMatch(id+76*n, l+1, l, matches) + if s[1] == ' ' { + AddMatch(id+14*n, l+2, l, matches) + } + } else if s[0] == '\n' { + AddMatch(id+22*n, l+1, l, matches) + if s[1] == '\t' { + AddMatch(id+50*n, l+2, l, matches) + } + } else if s[0] == ']' { + AddMatch(id+24*n, l+1, l, matches) + } else if s[0] == '\'' { + AddMatch(id+36*n, l+1, l, matches) + } else if s[0] == ':' { + AddMatch(id+51*n, l+1, l, matches) + } else if s[0] == '(' { + AddMatch(id+57*n, l+1, l, matches) + } else if s[0] == '=' { + if s[1] == '"' { + AddMatch(id+70*n, l+2, l, matches) + } else if s[1] == '\'' { + AddMatch(id+86*n, l+2, l, matches) + } + } else if s[0] == 'a' { + if s[1] == 'l' && s[2] == ' ' { + AddMatch(id+84*n, l+3, l, matches) + } + } else if s[0] == 'e' { + if s[1] == 'd' { + if s[2] == ' ' { + AddMatch(id+53*n, l+3, l, matches) + } + } else if s[1] == 'r' { + if s[2] == ' ' { + AddMatch(id+82*n, l+3, l, matches) + } + } else if s[1] == 's' { + if s[2] == 't' && s[3] == ' ' { + AddMatch(id+95*n, l+4, l, matches) + } + } + } else if s[0] == 'f' { + if s[1] == 'u' && s[2] == 'l' && s[3] == ' ' { + AddMatch(id+90*n, l+4, l, matches) + } + } else if s[0] == 'i' { + if s[1] == 'v' { + if s[2] == 'e' && s[3] == ' ' { + AddMatch(id+92*n, l+4, l, matches) + } + } else if s[1] == 'z' { + if s[2] == 'e' && s[3] == ' ' { + AddMatch(id+100*n, l+4, l, matches) + } + } + } else if s[0] == 'l' { + if s[1] == 'e' { + if s[2] == 's' && s[3] == 's' && s[4] == ' ' { + AddMatch(id+93*n, l+5, l, matches) + } + } else if s[1] == 'y' { + if s[2] == ' ' { + AddMatch(id+61*n, l+3, l, matches) + } + } + } else if s[0] == 'o' { + if s[1] == 'u' && s[2] == 's' && s[3] == ' ' { + AddMatch(id+106*n, l+4, l, matches) + } + } + } else { + var is_all_caps bool = (w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST) + /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and + is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL) + transform. */ + + var s []byte + if !IsMatch(dictionary.words, w, data, max_length) { + continue + } + + /* Transform "" + kUppercase{First,All} + "" */ + var tmp int + if is_all_caps { + tmp = 44 + } else { + tmp = 9 + } + AddMatch(id+uint(tmp)*n, l, l, matches) + + has_found_match = true + if l+1 >= max_length { + continue + } + + /* Transforms "" + kUppercase{First,All} + */ + s = data[l:] + + if s[0] == ' ' { + var tmp int + if is_all_caps { + tmp = 68 + } else { + tmp = 4 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + } else if s[0] == '"' { + var tmp int + if is_all_caps { + tmp = 87 + } else { + tmp = 66 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + if s[1] == '>' { + var tmp int + if is_all_caps { + tmp = 97 + } else { + tmp = 69 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } + } else if s[0] == '.' { + var tmp int + if is_all_caps { + tmp = 101 + } else { + tmp = 79 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + if s[1] == ' ' { + var tmp int + if is_all_caps { + tmp = 114 + } else { + tmp = 88 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } + } else if s[0] == ',' { + var tmp int + if is_all_caps { + tmp = 112 + } else { + tmp = 99 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + if s[1] == ' ' { + var tmp int + if is_all_caps { + tmp = 107 + } else { + tmp = 58 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } + } else if s[0] == '\'' { + var tmp int + if is_all_caps { + tmp = 94 + } else { + tmp = 74 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + } else if s[0] == '(' { + var tmp int + if is_all_caps { + tmp = 113 + } else { + tmp = 78 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + } else if s[0] == '=' { + if s[1] == '"' { + var tmp int + if is_all_caps { + tmp = 105 + } else { + tmp = 104 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } else if s[1] == '\'' { + var tmp int + if is_all_caps { + tmp = 116 + } else { + tmp = 108 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } + } + } + } + } + + /* Transforms with prefixes " " and "." */ + if max_length >= 5 && (data[0] == ' ' || data[0] == '.') { + var is_space bool = (data[0] == ' ') + var offset uint = uint(dictionary.buckets[Hash(data[1:])]) + var end bool = offset == 0 + for !end { + var w DictWord + w = dictionary.dict_words[offset] + offset++ + var l uint = uint(w.len) & 0x1F + var n uint = uint(1) << dictionary.words.size_bits_by_length[l] + var id uint = uint(w.idx) + end = !(w.len&0x80 == 0) + w.len = byte(l) + if w.transform == 0 { + var s []byte + if !IsMatch(dictionary.words, w, data[1:], max_length-1) { + continue + } + + /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + "" and + "." + BROTLI_TRANSFORM_IDENTITY + "" */ + var tmp int + if is_space { + tmp = 6 + } else { + tmp = 32 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + + has_found_match = true + if l+2 >= max_length { + continue + } + + /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + and + "." + BROTLI_TRANSFORM_IDENTITY + + */ + s = data[l+1:] + + if s[0] == ' ' { + var tmp int + if is_space { + tmp = 2 + } else { + tmp = 77 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } else if s[0] == '(' { + var tmp int + if is_space { + tmp = 89 + } else { + tmp = 67 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } else if is_space { + if s[0] == ',' { + AddMatch(id+103*n, l+2, l, matches) + if s[1] == ' ' { + AddMatch(id+33*n, l+3, l, matches) + } + } else if s[0] == '.' { + AddMatch(id+71*n, l+2, l, matches) + if s[1] == ' ' { + AddMatch(id+52*n, l+3, l, matches) + } + } else if s[0] == '=' { + if s[1] == '"' { + AddMatch(id+81*n, l+3, l, matches) + } else if s[1] == '\'' { + AddMatch(id+98*n, l+3, l, matches) + } + } + } + } else if is_space { + var is_all_caps bool = (w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST) + /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and + is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL) + transform. */ + + var s []byte + if !IsMatch(dictionary.words, w, data[1:], max_length-1) { + continue + } + + /* Transforms " " + kUppercase{First,All} + "" */ + var tmp int + if is_all_caps { + tmp = 85 + } else { + tmp = 30 + } + AddMatch(id+uint(tmp)*n, l+1, l, matches) + + has_found_match = true + if l+2 >= max_length { + continue + } + + /* Transforms " " + kUppercase{First,All} + */ + s = data[l+1:] + + if s[0] == ' ' { + var tmp int + if is_all_caps { + tmp = 83 + } else { + tmp = 15 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + } else if s[0] == ',' { + if !is_all_caps { + AddMatch(id+109*n, l+2, l, matches) + } + + if s[1] == ' ' { + var tmp int + if is_all_caps { + tmp = 111 + } else { + tmp = 65 + } + AddMatch(id+uint(tmp)*n, l+3, l, matches) + } + } else if s[0] == '.' { + var tmp int + if is_all_caps { + tmp = 115 + } else { + tmp = 96 + } + AddMatch(id+uint(tmp)*n, l+2, l, matches) + if s[1] == ' ' { + var tmp int + if is_all_caps { + tmp = 117 + } else { + tmp = 91 + } + AddMatch(id+uint(tmp)*n, l+3, l, matches) + } + } else if s[0] == '=' { + if s[1] == '"' { + var tmp int + if is_all_caps { + tmp = 110 + } else { + tmp = 118 + } + AddMatch(id+uint(tmp)*n, l+3, l, matches) + } else if s[1] == '\'' { + var tmp int + if is_all_caps { + tmp = 119 + } else { + tmp = 120 + } + AddMatch(id+uint(tmp)*n, l+3, l, matches) + } + } + } + } + } + + if max_length >= 6 { + /* Transforms with prefixes "e ", "s ", ", " and "\xC2\xA0" */ + if (data[1] == ' ' && (data[0] == 'e' || data[0] == 's' || data[0] == ',')) || (data[0] == 0xC2 && data[1] == 0xA0) { + var offset uint = uint(dictionary.buckets[Hash(data[2:])]) + var end bool = offset == 0 + for !end { + var w DictWord + w = dictionary.dict_words[offset] + offset++ + var l uint = uint(w.len) & 0x1F + var n uint = uint(1) << dictionary.words.size_bits_by_length[l] + var id uint = uint(w.idx) + end = !(w.len&0x80 == 0) + w.len = byte(l) + if w.transform == 0 && IsMatch(dictionary.words, w, data[2:], max_length-2) { + if data[0] == 0xC2 { + AddMatch(id+102*n, l+2, l, matches) + has_found_match = true + } else if l+2 < max_length && data[l+2] == ' ' { + var t uint = 13 + if data[0] == 'e' { + t = 18 + } else if data[0] == 's' { + t = 7 + } + AddMatch(id+t*n, l+3, l, matches) + has_found_match = true + } + } + } + } + } + + if max_length >= 9 { + /* Transforms with prefixes " the " and ".com/" */ + if (data[0] == ' ' && data[1] == 't' && data[2] == 'h' && data[3] == 'e' && data[4] == ' ') || (data[0] == '.' && data[1] == 'c' && data[2] == 'o' && data[3] == 'm' && data[4] == '/') { + var offset uint = uint(dictionary.buckets[Hash(data[5:])]) + var end bool = offset == 0 + for !end { + var w DictWord + w = dictionary.dict_words[offset] + offset++ + var l uint = uint(w.len) & 0x1F + var n uint = uint(1) << dictionary.words.size_bits_by_length[l] + var id uint = uint(w.idx) + end = !(w.len&0x80 == 0) + w.len = byte(l) + if w.transform == 0 && IsMatch(dictionary.words, w, data[5:], max_length-5) { + var tmp int + if data[0] == ' ' { + tmp = 41 + } else { + tmp = 72 + } + AddMatch(id+uint(tmp)*n, l+5, l, matches) + has_found_match = true + if l+5 < max_length { + var s []byte = data[l+5:] + if data[0] == ' ' { + if l+8 < max_length && s[0] == ' ' && s[1] == 'o' && s[2] == 'f' && s[3] == ' ' { + AddMatch(id+62*n, l+9, l, matches) + if l+12 < max_length && s[4] == 't' && s[5] == 'h' && s[6] == 'e' && s[7] == ' ' { + AddMatch(id+73*n, l+13, l, matches) + } + } + } + } + } + } + } + } + + return has_found_match +} diff --git a/static_dict_lut.go b/static_dict_lut.go new file mode 100644 index 0000000..a121aac --- /dev/null +++ b/static_dict_lut.go @@ -0,0 +1,75103 @@ +package brotli + +/* Copyright 2017 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +/* Copyright 2017 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Lookup table for static dictionary and transforms. */ +type DictWord struct { + len byte + transform byte + idx uint16 +} + +var kDictNumBits int = 15 + +var kDictHashMul32 uint32 = 0x1E35A7BD + +var kStaticDictionaryBuckets = [32768]uint16{ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + 6, + 0, + 0, + 0, + 0, + 0, + 20, + 0, + 0, + 0, + 21, + 0, + 22, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23, + 0, + 0, + 25, + 0, + 29, + 0, + 53, + 0, + 0, + 0, + 0, + 0, + 0, + 55, + 0, + 0, + 0, + 0, + 0, + 0, + 61, + 76, + 0, + 0, + 0, + 94, + 0, + 0, + 0, + 0, + 0, + 0, + 96, + 0, + 97, + 0, + 98, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 99, + 101, + 106, + 108, + 0, + 0, + 0, + 0, + 0, + 110, + 0, + 111, + 112, + 0, + 113, + 118, + 124, + 0, + 0, + 0, + 0, + 0, + 125, + 128, + 0, + 0, + 0, + 0, + 129, + 0, + 0, + 131, + 0, + 0, + 0, + 0, + 0, + 0, + 132, + 0, + 0, + 135, + 0, + 0, + 0, + 137, + 0, + 0, + 0, + 0, + 0, + 138, + 139, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 142, + 143, + 144, + 0, + 0, + 0, + 0, + 0, + 145, + 0, + 0, + 0, + 146, + 149, + 151, + 152, + 0, + 0, + 153, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 154, + 0, + 0, + 0, + 0, + 0, + 0, + 155, + 0, + 0, + 0, + 0, + 160, + 182, + 0, + 0, + 0, + 0, + 0, + 0, + 183, + 0, + 0, + 0, + 188, + 189, + 0, + 0, + 192, + 0, + 0, + 0, + 0, + 0, + 0, + 194, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 197, + 202, + 209, + 0, + 0, + 210, + 0, + 224, + 0, + 0, + 0, + 225, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 231, + 0, + 0, + 0, + 232, + 0, + 240, + 0, + 0, + 242, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 244, + 0, + 0, + 0, + 246, + 0, + 0, + 249, + 251, + 253, + 0, + 0, + 0, + 0, + 0, + 258, + 0, + 0, + 261, + 263, + 0, + 0, + 0, + 267, + 0, + 0, + 268, + 0, + 269, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 271, + 0, + 0, + 0, + 0, + 0, + 0, + 272, + 0, + 273, + 0, + 277, + 0, + 278, + 286, + 0, + 0, + 0, + 0, + 287, + 0, + 289, + 290, + 291, + 0, + 0, + 0, + 295, + 0, + 0, + 296, + 297, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 298, + 0, + 0, + 0, + 299, + 0, + 0, + 305, + 0, + 324, + 0, + 0, + 0, + 0, + 0, + 327, + 0, + 328, + 329, + 0, + 0, + 0, + 0, + 336, + 0, + 0, + 340, + 0, + 341, + 342, + 343, + 0, + 0, + 346, + 0, + 348, + 0, + 0, + 0, + 0, + 0, + 0, + 349, + 351, + 0, + 0, + 355, + 0, + 363, + 0, + 364, + 0, + 368, + 369, + 0, + 370, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 372, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 373, + 0, + 375, + 0, + 0, + 0, + 0, + 376, + 377, + 0, + 0, + 394, + 395, + 396, + 0, + 0, + 398, + 0, + 0, + 0, + 0, + 400, + 0, + 0, + 408, + 0, + 0, + 0, + 0, + 420, + 0, + 0, + 0, + 0, + 0, + 0, + 421, + 0, + 0, + 422, + 423, + 0, + 0, + 429, + 435, + 436, + 442, + 0, + 0, + 443, + 0, + 444, + 445, + 453, + 456, + 0, + 457, + 0, + 0, + 0, + 0, + 0, + 458, + 0, + 0, + 0, + 459, + 0, + 0, + 0, + 460, + 0, + 462, + 463, + 465, + 0, + 0, + 0, + 0, + 0, + 0, + 466, + 469, + 0, + 0, + 0, + 0, + 0, + 0, + 470, + 0, + 0, + 0, + 474, + 0, + 476, + 0, + 0, + 0, + 0, + 483, + 0, + 485, + 0, + 0, + 0, + 486, + 0, + 0, + 488, + 491, + 492, + 0, + 0, + 497, + 499, + 500, + 0, + 501, + 0, + 0, + 0, + 505, + 0, + 0, + 506, + 0, + 0, + 0, + 507, + 0, + 0, + 0, + 509, + 0, + 0, + 0, + 0, + 511, + 512, + 519, + 0, + 0, + 0, + 0, + 0, + 0, + 529, + 530, + 0, + 0, + 0, + 534, + 0, + 0, + 0, + 0, + 543, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 553, + 0, + 0, + 0, + 0, + 557, + 560, + 0, + 0, + 0, + 0, + 0, + 0, + 561, + 0, + 564, + 0, + 0, + 0, + 0, + 0, + 0, + 565, + 566, + 0, + 575, + 0, + 619, + 0, + 620, + 0, + 0, + 623, + 624, + 0, + 0, + 0, + 625, + 0, + 0, + 626, + 627, + 0, + 0, + 628, + 0, + 0, + 0, + 0, + 630, + 0, + 631, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 641, + 0, + 0, + 0, + 0, + 643, + 656, + 668, + 0, + 0, + 0, + 673, + 0, + 0, + 0, + 674, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 682, + 0, + 687, + 0, + 690, + 0, + 693, + 699, + 700, + 0, + 0, + 0, + 0, + 0, + 0, + 704, + 705, + 0, + 0, + 0, + 0, + 707, + 710, + 0, + 711, + 0, + 0, + 0, + 0, + 726, + 0, + 0, + 729, + 0, + 0, + 0, + 730, + 731, + 0, + 0, + 0, + 0, + 0, + 752, + 0, + 0, + 0, + 762, + 0, + 763, + 0, + 0, + 767, + 0, + 0, + 0, + 770, + 774, + 0, + 0, + 775, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 776, + 0, + 0, + 0, + 777, + 783, + 0, + 0, + 0, + 785, + 788, + 0, + 0, + 0, + 0, + 790, + 0, + 0, + 0, + 793, + 0, + 0, + 0, + 0, + 794, + 0, + 0, + 804, + 819, + 821, + 0, + 827, + 0, + 0, + 0, + 834, + 0, + 0, + 835, + 0, + 0, + 0, + 841, + 0, + 844, + 0, + 850, + 851, + 859, + 0, + 860, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 874, + 0, + 876, + 0, + 877, + 890, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 893, + 894, + 898, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 899, + 0, + 0, + 0, + 900, + 904, + 906, + 0, + 0, + 0, + 907, + 0, + 908, + 909, + 0, + 910, + 0, + 0, + 0, + 0, + 911, + 0, + 0, + 0, + 0, + 0, + 916, + 0, + 0, + 0, + 922, + 925, + 0, + 930, + 0, + 934, + 0, + 0, + 0, + 0, + 0, + 943, + 0, + 0, + 944, + 0, + 953, + 954, + 0, + 0, + 0, + 0, + 0, + 0, + 955, + 0, + 962, + 963, + 0, + 0, + 976, + 0, + 0, + 977, + 978, + 979, + 980, + 0, + 981, + 0, + 0, + 0, + 0, + 984, + 0, + 0, + 985, + 0, + 0, + 987, + 989, + 991, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 992, + 0, + 0, + 0, + 993, + 0, + 0, + 0, + 0, + 0, + 0, + 996, + 0, + 0, + 0, + 1000, + 0, + 0, + 0, + 0, + 0, + 1002, + 0, + 0, + 0, + 0, + 1005, + 1007, + 0, + 0, + 0, + 1009, + 0, + 0, + 0, + 1010, + 0, + 0, + 0, + 0, + 0, + 0, + 1011, + 0, + 1012, + 0, + 0, + 0, + 0, + 1014, + 1016, + 0, + 0, + 0, + 1020, + 0, + 1021, + 0, + 0, + 0, + 0, + 1022, + 0, + 0, + 0, + 1024, + 0, + 0, + 0, + 0, + 0, + 0, + 1025, + 0, + 0, + 1026, + 1027, + 0, + 0, + 0, + 0, + 0, + 1031, + 0, + 1033, + 0, + 0, + 0, + 0, + 1034, + 0, + 0, + 0, + 1037, + 1040, + 0, + 0, + 0, + 1042, + 1043, + 0, + 0, + 1053, + 0, + 1054, + 0, + 0, + 1057, + 0, + 0, + 0, + 1058, + 0, + 0, + 1060, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1061, + 0, + 0, + 1062, + 0, + 0, + 0, + 0, + 1063, + 0, + 0, + 0, + 0, + 1064, + 0, + 0, + 0, + 0, + 0, + 1065, + 0, + 0, + 0, + 0, + 1066, + 1067, + 0, + 0, + 0, + 1069, + 1070, + 1072, + 0, + 0, + 0, + 0, + 0, + 0, + 1073, + 0, + 1075, + 0, + 0, + 0, + 0, + 0, + 0, + 1080, + 1084, + 0, + 0, + 0, + 0, + 1088, + 0, + 0, + 0, + 0, + 0, + 0, + 1094, + 0, + 1095, + 0, + 1107, + 0, + 0, + 0, + 1112, + 1114, + 0, + 1119, + 0, + 1122, + 0, + 0, + 1126, + 0, + 1129, + 0, + 1130, + 0, + 0, + 0, + 0, + 0, + 1132, + 0, + 0, + 0, + 0, + 0, + 0, + 1144, + 0, + 0, + 1145, + 1146, + 0, + 1148, + 1149, + 0, + 0, + 1150, + 1151, + 0, + 0, + 0, + 0, + 1152, + 0, + 1153, + 0, + 0, + 0, + 0, + 0, + 1154, + 0, + 1163, + 0, + 0, + 0, + 1164, + 0, + 0, + 0, + 0, + 0, + 1165, + 0, + 1167, + 0, + 1170, + 0, + 0, + 0, + 0, + 0, + 1171, + 1172, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1173, + 1175, + 1177, + 0, + 1186, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1195, + 0, + 0, + 1221, + 0, + 0, + 1224, + 0, + 0, + 1227, + 0, + 0, + 0, + 0, + 0, + 1228, + 1229, + 0, + 0, + 1230, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1231, + 0, + 0, + 0, + 1233, + 0, + 0, + 1243, + 1244, + 1246, + 1248, + 0, + 0, + 0, + 0, + 1254, + 1255, + 1258, + 1259, + 0, + 0, + 0, + 1260, + 0, + 0, + 1261, + 0, + 0, + 0, + 1262, + 1264, + 0, + 0, + 1265, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1266, + 0, + 1267, + 0, + 0, + 0, + 0, + 1273, + 1274, + 1276, + 1289, + 0, + 0, + 1291, + 1292, + 1293, + 0, + 0, + 1294, + 1295, + 1296, + 0, + 0, + 0, + 0, + 1302, + 0, + 1304, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1311, + 1312, + 0, + 1314, + 0, + 1316, + 1320, + 1321, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1322, + 1323, + 1324, + 0, + 1335, + 0, + 1336, + 0, + 0, + 0, + 0, + 1341, + 1342, + 0, + 1346, + 0, + 1357, + 0, + 0, + 0, + 1358, + 1360, + 0, + 0, + 0, + 0, + 0, + 0, + 1361, + 0, + 0, + 0, + 1362, + 1365, + 0, + 1366, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1379, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1386, + 0, + 1388, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1395, + 0, + 0, + 0, + 0, + 1403, + 0, + 1405, + 0, + 0, + 1407, + 0, + 0, + 0, + 0, + 0, + 1408, + 1409, + 0, + 1410, + 0, + 0, + 0, + 1412, + 1413, + 1416, + 0, + 0, + 1429, + 1451, + 0, + 0, + 1454, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1455, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1456, + 0, + 0, + 0, + 0, + 1459, + 1460, + 1461, + 1475, + 0, + 0, + 0, + 0, + 0, + 0, + 1477, + 0, + 1480, + 0, + 1481, + 0, + 0, + 1486, + 0, + 0, + 1495, + 0, + 0, + 0, + 1496, + 0, + 0, + 1498, + 1499, + 1501, + 1520, + 1521, + 0, + 0, + 0, + 1526, + 0, + 0, + 0, + 0, + 1528, + 1529, + 0, + 1533, + 1536, + 0, + 0, + 0, + 1537, + 1538, + 1549, + 0, + 1550, + 1558, + 1559, + 1572, + 0, + 1573, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1575, + 0, + 0, + 0, + 0, + 0, + 1579, + 0, + 1599, + 0, + 1603, + 0, + 1604, + 0, + 1605, + 0, + 0, + 0, + 0, + 0, + 1608, + 1610, + 0, + 0, + 0, + 0, + 1611, + 0, + 1615, + 0, + 1616, + 1618, + 0, + 1619, + 0, + 0, + 1622, + 0, + 0, + 0, + 0, + 1634, + 0, + 0, + 0, + 1635, + 0, + 0, + 0, + 1641, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1643, + 0, + 0, + 0, + 1650, + 0, + 0, + 1652, + 0, + 0, + 0, + 0, + 0, + 1653, + 0, + 0, + 0, + 1654, + 0, + 0, + 0, + 0, + 1655, + 0, + 1662, + 0, + 0, + 1663, + 1664, + 0, + 0, + 1668, + 0, + 0, + 1669, + 1670, + 0, + 1672, + 1673, + 0, + 0, + 0, + 0, + 0, + 1674, + 0, + 0, + 0, + 1675, + 1676, + 1680, + 0, + 1682, + 0, + 0, + 1687, + 0, + 0, + 0, + 0, + 0, + 1704, + 0, + 0, + 1705, + 0, + 0, + 1721, + 0, + 0, + 0, + 0, + 1734, + 1735, + 0, + 0, + 0, + 0, + 1737, + 0, + 0, + 0, + 0, + 1739, + 0, + 0, + 1740, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1741, + 1743, + 0, + 0, + 0, + 0, + 1745, + 0, + 0, + 0, + 1749, + 0, + 0, + 0, + 1751, + 0, + 0, + 0, + 0, + 0, + 0, + 1760, + 0, + 0, + 0, + 0, + 1765, + 0, + 0, + 0, + 0, + 0, + 1784, + 0, + 1785, + 1787, + 0, + 0, + 0, + 0, + 1788, + 1789, + 0, + 0, + 0, + 0, + 1790, + 1791, + 1793, + 0, + 1798, + 1799, + 0, + 0, + 0, + 0, + 1801, + 0, + 1803, + 1805, + 0, + 0, + 0, + 1806, + 1811, + 0, + 1812, + 1814, + 0, + 1821, + 0, + 0, + 0, + 0, + 0, + 1822, + 1833, + 0, + 0, + 0, + 0, + 0, + 0, + 1848, + 0, + 0, + 0, + 0, + 0, + 0, + 1857, + 0, + 0, + 0, + 1859, + 0, + 0, + 0, + 0, + 1861, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1866, + 0, + 1921, + 1925, + 0, + 0, + 0, + 1929, + 1930, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1931, + 0, + 0, + 0, + 0, + 1932, + 0, + 0, + 0, + 1934, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1946, + 0, + 0, + 1948, + 0, + 0, + 0, + 0, + 1950, + 0, + 1957, + 0, + 1958, + 0, + 0, + 0, + 0, + 0, + 1965, + 1967, + 0, + 0, + 0, + 0, + 1968, + 0, + 1969, + 0, + 1971, + 1972, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1973, + 0, + 0, + 0, + 0, + 1975, + 0, + 0, + 0, + 0, + 1976, + 1979, + 0, + 1982, + 0, + 0, + 0, + 0, + 1984, + 1988, + 0, + 0, + 0, + 0, + 1990, + 2004, + 2008, + 0, + 0, + 0, + 2012, + 2013, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2015, + 0, + 2016, + 2017, + 0, + 0, + 0, + 0, + 2021, + 0, + 0, + 2025, + 0, + 0, + 0, + 0, + 0, + 2029, + 2036, + 2040, + 0, + 2042, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2043, + 0, + 0, + 0, + 0, + 0, + 2045, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2046, + 2047, + 0, + 2048, + 2049, + 0, + 2059, + 0, + 0, + 2063, + 0, + 2064, + 2065, + 0, + 0, + 2066, + 0, + 0, + 0, + 0, + 0, + 0, + 2069, + 0, + 0, + 0, + 0, + 2070, + 0, + 2071, + 0, + 2072, + 0, + 0, + 0, + 0, + 2080, + 2082, + 2083, + 0, + 0, + 0, + 0, + 0, + 2085, + 0, + 2086, + 2088, + 2089, + 2105, + 0, + 0, + 0, + 0, + 2107, + 0, + 0, + 2116, + 2117, + 0, + 2120, + 0, + 0, + 2122, + 0, + 0, + 0, + 0, + 0, + 2123, + 0, + 0, + 2125, + 2127, + 2128, + 0, + 0, + 0, + 2130, + 0, + 0, + 0, + 2137, + 2139, + 2140, + 2141, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2144, + 2145, + 0, + 0, + 2146, + 2149, + 0, + 0, + 0, + 0, + 2150, + 0, + 0, + 2151, + 2158, + 0, + 2159, + 0, + 2160, + 0, + 0, + 0, + 0, + 0, + 0, + 2161, + 2162, + 0, + 0, + 2194, + 2202, + 0, + 0, + 0, + 0, + 0, + 0, + 2205, + 2217, + 0, + 2220, + 0, + 2221, + 0, + 2222, + 2224, + 0, + 0, + 0, + 0, + 2237, + 0, + 0, + 0, + 0, + 0, + 2238, + 0, + 2239, + 2241, + 0, + 0, + 2242, + 0, + 0, + 0, + 0, + 0, + 2243, + 0, + 0, + 0, + 0, + 0, + 0, + 2252, + 0, + 0, + 2253, + 0, + 0, + 0, + 2257, + 2258, + 0, + 0, + 0, + 2260, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2262, + 0, + 2264, + 0, + 0, + 0, + 0, + 0, + 2269, + 2270, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2271, + 0, + 2273, + 0, + 0, + 0, + 0, + 2277, + 0, + 0, + 0, + 0, + 2278, + 0, + 0, + 0, + 0, + 2279, + 0, + 2280, + 0, + 2283, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2287, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2289, + 2290, + 0, + 0, + 0, + 0, + 2291, + 0, + 2292, + 0, + 0, + 0, + 2293, + 2295, + 2296, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2298, + 0, + 0, + 0, + 0, + 0, + 2303, + 0, + 2305, + 0, + 0, + 2306, + 0, + 2307, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2313, + 2314, + 2315, + 2316, + 0, + 0, + 2318, + 0, + 2319, + 0, + 2322, + 0, + 0, + 2323, + 0, + 2324, + 0, + 2326, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2335, + 0, + 2336, + 2338, + 2339, + 0, + 2340, + 0, + 0, + 0, + 2355, + 0, + 2375, + 0, + 2382, + 2386, + 0, + 2387, + 0, + 0, + 2394, + 0, + 0, + 0, + 0, + 2395, + 0, + 2397, + 0, + 0, + 0, + 0, + 0, + 2398, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2399, + 2402, + 2404, + 2408, + 2411, + 0, + 0, + 0, + 2413, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2415, + 0, + 0, + 2416, + 2417, + 2419, + 0, + 2420, + 0, + 0, + 0, + 0, + 0, + 2425, + 0, + 0, + 0, + 2426, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2427, + 2428, + 0, + 2429, + 0, + 0, + 2430, + 2434, + 0, + 2436, + 0, + 0, + 0, + 0, + 0, + 0, + 2441, + 2442, + 0, + 2445, + 0, + 0, + 2446, + 2457, + 0, + 2459, + 0, + 0, + 2462, + 0, + 2464, + 0, + 2477, + 0, + 2478, + 2486, + 0, + 0, + 0, + 2491, + 0, + 0, + 2493, + 0, + 0, + 2494, + 0, + 2495, + 0, + 2513, + 2523, + 0, + 0, + 0, + 0, + 2524, + 0, + 0, + 0, + 0, + 0, + 0, + 2528, + 2529, + 2530, + 0, + 0, + 2531, + 0, + 2533, + 0, + 0, + 2534, + 2535, + 0, + 2536, + 2537, + 0, + 2538, + 0, + 2539, + 2540, + 0, + 0, + 0, + 2545, + 2546, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2548, + 0, + 0, + 2549, + 0, + 2550, + 2555, + 0, + 0, + 0, + 0, + 0, + 2557, + 0, + 2560, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2561, + 0, + 2576, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2577, + 2578, + 0, + 0, + 0, + 2579, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2580, + 0, + 0, + 0, + 0, + 2581, + 0, + 0, + 0, + 0, + 2583, + 0, + 2584, + 0, + 2588, + 2590, + 0, + 0, + 0, + 2591, + 0, + 0, + 0, + 0, + 2593, + 2594, + 0, + 2595, + 0, + 2601, + 2602, + 0, + 0, + 2603, + 0, + 2605, + 0, + 0, + 0, + 2606, + 2607, + 2611, + 0, + 2615, + 0, + 0, + 0, + 2617, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2619, + 0, + 0, + 2620, + 0, + 0, + 0, + 2621, + 0, + 2623, + 0, + 2625, + 0, + 0, + 2628, + 2629, + 0, + 0, + 2635, + 2636, + 2637, + 0, + 0, + 2639, + 0, + 0, + 0, + 2642, + 0, + 0, + 0, + 0, + 2643, + 0, + 2644, + 0, + 2649, + 0, + 0, + 0, + 0, + 0, + 0, + 2655, + 2656, + 0, + 0, + 2657, + 0, + 0, + 0, + 0, + 0, + 2658, + 0, + 0, + 0, + 0, + 0, + 2659, + 0, + 0, + 0, + 0, + 2664, + 2685, + 0, + 2687, + 0, + 2688, + 0, + 0, + 2689, + 0, + 0, + 2694, + 0, + 2695, + 0, + 0, + 2698, + 0, + 2701, + 2706, + 0, + 0, + 0, + 2707, + 0, + 2709, + 2710, + 2711, + 0, + 0, + 0, + 2720, + 2730, + 2735, + 0, + 0, + 0, + 0, + 2738, + 2740, + 0, + 0, + 0, + 0, + 2747, + 0, + 0, + 0, + 0, + 0, + 0, + 2748, + 0, + 0, + 2749, + 0, + 0, + 0, + 0, + 0, + 2750, + 0, + 0, + 2752, + 2754, + 0, + 0, + 0, + 0, + 0, + 2758, + 0, + 0, + 0, + 0, + 2762, + 0, + 0, + 0, + 0, + 2763, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2764, + 2767, + 0, + 0, + 0, + 0, + 2768, + 0, + 0, + 2770, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2771, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2772, + 0, + 0, + 0, + 0, + 0, + 2773, + 2776, + 0, + 0, + 2783, + 0, + 0, + 2784, + 0, + 2789, + 0, + 2790, + 0, + 0, + 0, + 2792, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2793, + 2795, + 0, + 0, + 0, + 0, + 0, + 0, + 2796, + 0, + 0, + 0, + 0, + 0, + 0, + 2797, + 2799, + 0, + 0, + 0, + 0, + 2803, + 0, + 0, + 0, + 0, + 2806, + 0, + 2807, + 2808, + 2817, + 2819, + 0, + 0, + 0, + 0, + 0, + 2821, + 0, + 0, + 0, + 0, + 2822, + 2823, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2824, + 0, + 0, + 2828, + 0, + 2834, + 0, + 0, + 0, + 0, + 0, + 0, + 2836, + 0, + 2838, + 0, + 0, + 2839, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2841, + 0, + 0, + 0, + 2842, + 0, + 0, + 0, + 0, + 0, + 2843, + 2844, + 0, + 0, + 0, + 0, + 2846, + 0, + 0, + 2847, + 0, + 2849, + 0, + 2853, + 0, + 0, + 0, + 0, + 0, + 2857, + 0, + 0, + 0, + 0, + 2858, + 0, + 2859, + 0, + 0, + 2860, + 0, + 2862, + 2868, + 0, + 0, + 0, + 0, + 2875, + 0, + 2876, + 0, + 0, + 2877, + 2878, + 2884, + 2889, + 2890, + 0, + 0, + 2891, + 0, + 0, + 2892, + 0, + 0, + 0, + 2906, + 2912, + 0, + 2913, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2916, + 0, + 2934, + 0, + 0, + 0, + 0, + 0, + 2935, + 0, + 0, + 0, + 0, + 2939, + 0, + 2940, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2941, + 0, + 0, + 0, + 2946, + 0, + 2949, + 0, + 0, + 2950, + 2954, + 2955, + 0, + 0, + 0, + 2959, + 2961, + 0, + 0, + 2962, + 0, + 2963, + 0, + 0, + 0, + 0, + 0, + 0, + 2964, + 2965, + 2966, + 2967, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2969, + 0, + 0, + 0, + 0, + 0, + 2970, + 2975, + 0, + 2982, + 2983, + 2984, + 0, + 0, + 0, + 0, + 0, + 2989, + 0, + 0, + 2990, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2991, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2998, + 0, + 3000, + 3001, + 0, + 0, + 3002, + 0, + 0, + 0, + 3003, + 0, + 0, + 3012, + 0, + 0, + 3022, + 0, + 0, + 3024, + 0, + 0, + 3025, + 3027, + 0, + 0, + 0, + 3030, + 0, + 0, + 0, + 0, + 3034, + 3035, + 0, + 0, + 3036, + 0, + 3039, + 0, + 3049, + 0, + 0, + 3050, + 0, + 0, + 0, + 0, + 0, + 0, + 3051, + 0, + 3053, + 0, + 0, + 0, + 0, + 3057, + 0, + 3058, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3063, + 0, + 0, + 3073, + 3074, + 3078, + 3079, + 0, + 3080, + 3086, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3087, + 0, + 3092, + 0, + 3095, + 0, + 3099, + 0, + 0, + 0, + 3100, + 0, + 3101, + 3102, + 0, + 3122, + 0, + 0, + 0, + 3124, + 0, + 3125, + 0, + 0, + 0, + 0, + 0, + 0, + 3132, + 3134, + 0, + 0, + 3136, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3147, + 0, + 0, + 3149, + 0, + 0, + 0, + 0, + 0, + 3150, + 3151, + 3152, + 0, + 0, + 0, + 0, + 3158, + 0, + 0, + 3160, + 0, + 0, + 3161, + 0, + 0, + 3162, + 0, + 3163, + 3166, + 3168, + 0, + 0, + 3169, + 3170, + 0, + 0, + 3171, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3182, + 0, + 3184, + 0, + 0, + 3188, + 0, + 0, + 3194, + 0, + 0, + 0, + 0, + 0, + 0, + 3204, + 0, + 0, + 0, + 0, + 3209, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3216, + 3217, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3219, + 0, + 0, + 3220, + 3222, + 0, + 3223, + 0, + 0, + 0, + 0, + 3224, + 0, + 3225, + 3226, + 0, + 3228, + 3233, + 0, + 3239, + 3241, + 3242, + 0, + 0, + 3251, + 3252, + 3253, + 3255, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3260, + 0, + 0, + 3261, + 0, + 0, + 0, + 3267, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3271, + 0, + 0, + 0, + 3278, + 0, + 3282, + 0, + 0, + 0, + 3284, + 0, + 0, + 0, + 3285, + 3286, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3287, + 3292, + 0, + 0, + 0, + 0, + 3294, + 3296, + 0, + 0, + 3299, + 3300, + 3301, + 0, + 3302, + 0, + 0, + 0, + 0, + 0, + 3304, + 3306, + 0, + 0, + 0, + 0, + 0, + 0, + 3308, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3311, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3312, + 3314, + 3315, + 0, + 3318, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3319, + 0, + 0, + 0, + 0, + 0, + 3321, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3322, + 0, + 0, + 3324, + 3325, + 0, + 0, + 3326, + 0, + 0, + 3328, + 3329, + 3331, + 0, + 0, + 3335, + 0, + 0, + 3337, + 0, + 3338, + 0, + 0, + 0, + 0, + 3343, + 3347, + 0, + 0, + 0, + 3348, + 0, + 0, + 3351, + 0, + 0, + 0, + 0, + 0, + 0, + 3354, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3355, + 0, + 0, + 3365, + 3366, + 3367, + 0, + 0, + 0, + 0, + 0, + 0, + 3368, + 3369, + 0, + 3370, + 0, + 0, + 3373, + 0, + 0, + 3376, + 0, + 0, + 3377, + 0, + 3379, + 3387, + 0, + 0, + 0, + 0, + 0, + 3390, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3402, + 0, + 3403, + 3436, + 3437, + 3439, + 0, + 0, + 3441, + 0, + 0, + 0, + 3442, + 0, + 0, + 3449, + 0, + 0, + 0, + 3450, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3451, + 0, + 0, + 3452, + 0, + 3453, + 3456, + 0, + 3457, + 0, + 0, + 3458, + 0, + 3459, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3460, + 0, + 0, + 3469, + 3470, + 0, + 0, + 3475, + 0, + 0, + 0, + 3480, + 3487, + 3489, + 0, + 3490, + 0, + 0, + 3491, + 3499, + 0, + 3500, + 0, + 0, + 3501, + 0, + 0, + 0, + 3502, + 0, + 3514, + 0, + 0, + 0, + 3516, + 3517, + 0, + 0, + 0, + 3518, + 0, + 0, + 0, + 0, + 3520, + 3521, + 3522, + 0, + 0, + 3526, + 3530, + 0, + 0, + 0, + 0, + 3531, + 0, + 0, + 0, + 0, + 3536, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3539, + 3541, + 0, + 0, + 3542, + 3544, + 0, + 3547, + 3548, + 0, + 0, + 3550, + 0, + 3553, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3554, + 0, + 3555, + 0, + 3558, + 0, + 3559, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3563, + 0, + 3581, + 0, + 0, + 0, + 3599, + 0, + 0, + 0, + 3600, + 0, + 3601, + 0, + 3602, + 3603, + 0, + 0, + 3606, + 3608, + 0, + 3610, + 3611, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3612, + 3616, + 3619, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3624, + 3628, + 0, + 3629, + 3634, + 3635, + 0, + 0, + 0, + 0, + 0, + 0, + 3636, + 0, + 3637, + 0, + 0, + 3638, + 3651, + 0, + 0, + 0, + 0, + 0, + 0, + 3652, + 3653, + 0, + 0, + 0, + 0, + 3656, + 3657, + 0, + 0, + 0, + 0, + 0, + 3658, + 0, + 0, + 0, + 0, + 3659, + 0, + 3661, + 3663, + 3664, + 0, + 3665, + 0, + 3692, + 0, + 0, + 0, + 3694, + 3696, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3698, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3700, + 0, + 0, + 3701, + 0, + 0, + 0, + 3708, + 3709, + 0, + 0, + 0, + 3711, + 3712, + 0, + 0, + 0, + 0, + 0, + 3723, + 0, + 3724, + 3725, + 0, + 0, + 3726, + 0, + 0, + 0, + 0, + 0, + 0, + 3728, + 3729, + 0, + 3734, + 3735, + 3737, + 0, + 0, + 0, + 3743, + 0, + 3745, + 0, + 0, + 3746, + 0, + 0, + 3747, + 3748, + 0, + 3757, + 0, + 3759, + 3766, + 3767, + 0, + 3768, + 0, + 0, + 0, + 0, + 3769, + 0, + 0, + 3771, + 0, + 3774, + 0, + 0, + 0, + 0, + 0, + 0, + 3775, + 0, + 0, + 0, + 0, + 0, + 0, + 3776, + 0, + 3777, + 3786, + 0, + 3788, + 3789, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3791, + 0, + 3811, + 0, + 0, + 0, + 0, + 0, + 3814, + 3815, + 3816, + 3820, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3821, + 0, + 0, + 3825, + 0, + 0, + 0, + 0, + 3835, + 0, + 0, + 3848, + 3849, + 0, + 0, + 0, + 0, + 3850, + 3851, + 3853, + 0, + 0, + 0, + 0, + 3859, + 0, + 3860, + 3862, + 0, + 0, + 0, + 0, + 0, + 3863, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3873, + 0, + 3874, + 0, + 3875, + 3886, + 0, + 3887, + 0, + 0, + 0, + 0, + 3892, + 3913, + 0, + 3914, + 0, + 0, + 0, + 3925, + 3931, + 0, + 0, + 0, + 0, + 3934, + 3941, + 3942, + 0, + 0, + 0, + 0, + 3943, + 0, + 0, + 0, + 3944, + 0, + 0, + 0, + 0, + 0, + 3945, + 0, + 3947, + 0, + 0, + 0, + 3956, + 3957, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3958, + 0, + 3959, + 3965, + 0, + 0, + 0, + 0, + 3966, + 0, + 0, + 0, + 3967, + 0, + 0, + 0, + 3968, + 3974, + 0, + 0, + 0, + 0, + 0, + 3975, + 3977, + 3978, + 0, + 0, + 0, + 0, + 3980, + 0, + 3985, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3986, + 4011, + 0, + 0, + 4017, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4018, + 0, + 0, + 0, + 0, + 4019, + 0, + 4023, + 0, + 0, + 0, + 4027, + 4028, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4031, + 4034, + 0, + 0, + 4035, + 4037, + 4039, + 4040, + 0, + 0, + 0, + 0, + 0, + 4059, + 0, + 4060, + 4061, + 0, + 4062, + 4063, + 4066, + 0, + 0, + 4072, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4088, + 0, + 0, + 0, + 0, + 0, + 4091, + 0, + 0, + 0, + 0, + 4094, + 4095, + 0, + 0, + 4096, + 0, + 0, + 0, + 0, + 0, + 4098, + 4099, + 0, + 0, + 0, + 4101, + 0, + 4104, + 0, + 0, + 0, + 4105, + 4108, + 0, + 4113, + 0, + 0, + 4115, + 4116, + 0, + 4126, + 0, + 0, + 4127, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4128, + 4132, + 4133, + 0, + 4134, + 0, + 0, + 0, + 4137, + 0, + 0, + 4141, + 0, + 0, + 0, + 0, + 4144, + 4146, + 4147, + 0, + 0, + 0, + 0, + 4148, + 0, + 0, + 4311, + 0, + 0, + 0, + 4314, + 4329, + 0, + 4331, + 4332, + 0, + 4333, + 0, + 4334, + 0, + 0, + 0, + 4335, + 0, + 4336, + 0, + 0, + 0, + 4337, + 0, + 0, + 0, + 4342, + 4345, + 4346, + 4350, + 0, + 4351, + 4352, + 0, + 4354, + 4355, + 0, + 0, + 4364, + 0, + 0, + 0, + 0, + 4369, + 0, + 0, + 0, + 4373, + 0, + 4374, + 0, + 0, + 0, + 0, + 4377, + 0, + 0, + 0, + 0, + 4378, + 0, + 0, + 0, + 4380, + 0, + 0, + 0, + 4381, + 4382, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4384, + 0, + 0, + 0, + 0, + 4385, + 0, + 0, + 0, + 4386, + 0, + 0, + 0, + 4391, + 4398, + 0, + 0, + 0, + 0, + 4407, + 4409, + 0, + 0, + 0, + 0, + 4410, + 0, + 0, + 4411, + 0, + 4414, + 4415, + 4418, + 0, + 4427, + 4428, + 4430, + 0, + 4431, + 0, + 4448, + 0, + 0, + 0, + 0, + 0, + 4449, + 0, + 0, + 0, + 4451, + 4452, + 0, + 4453, + 4454, + 0, + 4456, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4459, + 0, + 4463, + 0, + 0, + 0, + 0, + 0, + 4466, + 0, + 4467, + 0, + 4469, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4470, + 4471, + 0, + 4473, + 0, + 0, + 4475, + 0, + 0, + 0, + 0, + 4477, + 4478, + 0, + 0, + 0, + 4479, + 4481, + 0, + 4482, + 0, + 4484, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4486, + 0, + 0, + 4488, + 0, + 0, + 4497, + 0, + 4508, + 0, + 0, + 4510, + 4511, + 0, + 4520, + 4523, + 0, + 4524, + 0, + 4525, + 0, + 4527, + 0, + 0, + 4528, + 0, + 0, + 0, + 0, + 4530, + 0, + 4531, + 0, + 0, + 4532, + 0, + 0, + 0, + 4533, + 0, + 0, + 0, + 0, + 0, + 4535, + 0, + 0, + 0, + 4536, + 0, + 0, + 0, + 0, + 0, + 4541, + 4543, + 4544, + 4545, + 4547, + 0, + 4548, + 0, + 0, + 0, + 0, + 4550, + 4551, + 0, + 4553, + 0, + 0, + 0, + 0, + 4562, + 0, + 0, + 4571, + 0, + 0, + 0, + 4574, + 0, + 0, + 0, + 4575, + 0, + 4576, + 0, + 4577, + 0, + 0, + 0, + 4581, + 0, + 0, + 0, + 0, + 0, + 4582, + 0, + 0, + 4586, + 0, + 0, + 0, + 4588, + 0, + 0, + 4597, + 0, + 4598, + 0, + 0, + 0, + 0, + 4616, + 4617, + 0, + 4618, + 0, + 0, + 0, + 0, + 4619, + 0, + 4620, + 0, + 0, + 4621, + 0, + 4624, + 0, + 0, + 0, + 0, + 0, + 4625, + 0, + 0, + 0, + 0, + 4657, + 0, + 4659, + 0, + 4667, + 0, + 0, + 0, + 4668, + 4670, + 0, + 4672, + 0, + 0, + 0, + 0, + 0, + 4673, + 4676, + 0, + 0, + 0, + 0, + 4687, + 0, + 0, + 0, + 0, + 4697, + 0, + 0, + 0, + 0, + 4699, + 0, + 4701, + 0, + 0, + 0, + 0, + 4702, + 0, + 0, + 4706, + 0, + 0, + 4713, + 0, + 0, + 0, + 4714, + 4715, + 4716, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4717, + 0, + 0, + 4720, + 0, + 4721, + 4729, + 4735, + 0, + 0, + 0, + 4737, + 0, + 0, + 0, + 4739, + 0, + 0, + 0, + 4740, + 0, + 0, + 0, + 4741, + 0, + 0, + 0, + 0, + 0, + 4742, + 0, + 4745, + 4746, + 4747, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4748, + 0, + 0, + 0, + 4749, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4751, + 4786, + 0, + 4787, + 0, + 4788, + 4796, + 0, + 0, + 4797, + 4798, + 0, + 4799, + 4806, + 4807, + 0, + 0, + 0, + 0, + 4809, + 4810, + 0, + 0, + 0, + 0, + 0, + 0, + 4811, + 0, + 0, + 0, + 0, + 0, + 4812, + 0, + 4813, + 0, + 0, + 4815, + 0, + 4821, + 4822, + 0, + 0, + 0, + 0, + 4823, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4824, + 0, + 0, + 0, + 0, + 4826, + 0, + 0, + 0, + 4828, + 0, + 4829, + 0, + 0, + 0, + 4843, + 0, + 0, + 4847, + 0, + 4853, + 4855, + 4858, + 0, + 0, + 0, + 0, + 0, + 4859, + 0, + 4864, + 0, + 0, + 4879, + 0, + 0, + 0, + 0, + 4880, + 0, + 0, + 0, + 0, + 4881, + 0, + 4882, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4883, + 0, + 0, + 0, + 0, + 4884, + 0, + 0, + 0, + 0, + 0, + 4886, + 4887, + 4888, + 4894, + 4896, + 0, + 4902, + 0, + 0, + 4905, + 0, + 0, + 4915, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4916, + 4917, + 4919, + 4921, + 0, + 0, + 0, + 0, + 0, + 4926, + 0, + 0, + 0, + 0, + 4927, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4929, + 0, + 4930, + 4931, + 0, + 4938, + 0, + 4952, + 0, + 4953, + 4957, + 4960, + 4964, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5019, + 5020, + 5022, + 0, + 0, + 0, + 0, + 0, + 5023, + 0, + 0, + 0, + 5024, + 0, + 0, + 0, + 5025, + 0, + 0, + 0, + 0, + 5028, + 0, + 0, + 0, + 0, + 5029, + 5030, + 5031, + 0, + 5033, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5034, + 5035, + 0, + 5036, + 0, + 0, + 5037, + 0, + 0, + 0, + 0, + 5038, + 0, + 0, + 5039, + 0, + 0, + 0, + 5041, + 5042, + 0, + 0, + 0, + 0, + 5044, + 5049, + 5054, + 0, + 5055, + 0, + 5057, + 0, + 0, + 0, + 5060, + 0, + 0, + 0, + 0, + 0, + 5063, + 0, + 5064, + 5065, + 0, + 5067, + 0, + 0, + 0, + 5068, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5076, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5077, + 0, + 0, + 5078, + 5080, + 0, + 0, + 5083, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5085, + 0, + 0, + 0, + 0, + 0, + 0, + 5098, + 5099, + 5101, + 5105, + 5107, + 0, + 5108, + 0, + 5109, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5110, + 0, + 0, + 0, + 0, + 0, + 5117, + 5118, + 0, + 5121, + 0, + 5122, + 0, + 0, + 5130, + 0, + 0, + 0, + 5137, + 0, + 0, + 0, + 5148, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5151, + 5154, + 0, + 0, + 0, + 5155, + 0, + 0, + 5156, + 5159, + 5161, + 0, + 0, + 0, + 0, + 5162, + 0, + 0, + 0, + 0, + 5163, + 5164, + 0, + 5166, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5167, + 0, + 0, + 0, + 5172, + 0, + 0, + 0, + 0, + 0, + 0, + 5178, + 5179, + 0, + 0, + 5190, + 0, + 0, + 5191, + 5192, + 5194, + 0, + 0, + 5198, + 5201, + 0, + 0, + 0, + 0, + 0, + 5203, + 0, + 5206, + 5209, + 0, + 0, + 0, + 0, + 0, + 0, + 5213, + 0, + 5214, + 5216, + 0, + 0, + 0, + 0, + 0, + 5217, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5218, + 5219, + 0, + 5231, + 0, + 0, + 5244, + 5249, + 0, + 5254, + 0, + 5255, + 0, + 0, + 5257, + 0, + 0, + 0, + 0, + 0, + 5258, + 0, + 5260, + 5270, + 0, + 5277, + 0, + 0, + 0, + 0, + 0, + 0, + 5280, + 5281, + 5282, + 5283, + 0, + 0, + 0, + 0, + 0, + 5284, + 0, + 5285, + 0, + 0, + 0, + 0, + 0, + 5287, + 5288, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5289, + 5291, + 0, + 0, + 5294, + 0, + 0, + 5295, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5304, + 0, + 0, + 5306, + 5307, + 5308, + 0, + 5309, + 0, + 0, + 5310, + 0, + 0, + 0, + 0, + 5311, + 5312, + 0, + 5313, + 0, + 0, + 0, + 0, + 0, + 5316, + 0, + 0, + 0, + 5317, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5325, + 0, + 0, + 0, + 0, + 0, + 0, + 5326, + 0, + 5327, + 5329, + 0, + 5332, + 0, + 0, + 0, + 0, + 5338, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5340, + 0, + 0, + 5341, + 0, + 0, + 0, + 5342, + 0, + 5343, + 5344, + 0, + 0, + 5345, + 0, + 0, + 0, + 0, + 0, + 0, + 5347, + 5348, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5349, + 0, + 5350, + 0, + 5354, + 0, + 0, + 0, + 0, + 5358, + 0, + 0, + 5359, + 0, + 0, + 5361, + 0, + 0, + 5365, + 0, + 5367, + 0, + 5373, + 0, + 0, + 0, + 5379, + 0, + 0, + 0, + 5380, + 0, + 0, + 0, + 5382, + 0, + 5384, + 0, + 0, + 0, + 0, + 0, + 0, + 5385, + 0, + 0, + 0, + 0, + 5387, + 0, + 0, + 0, + 0, + 0, + 0, + 5388, + 5390, + 5393, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5396, + 0, + 0, + 0, + 0, + 5397, + 5402, + 0, + 0, + 0, + 0, + 0, + 5403, + 0, + 0, + 0, + 5404, + 5405, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5406, + 0, + 0, + 0, + 0, + 5410, + 0, + 0, + 5411, + 0, + 5415, + 0, + 0, + 0, + 0, + 5416, + 5434, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5438, + 0, + 5440, + 0, + 0, + 0, + 0, + 0, + 0, + 5441, + 5442, + 0, + 0, + 0, + 5443, + 5444, + 5447, + 0, + 0, + 5448, + 5449, + 5451, + 0, + 0, + 0, + 5456, + 5457, + 0, + 0, + 0, + 5459, + 0, + 0, + 0, + 5461, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5464, + 0, + 5466, + 0, + 0, + 5467, + 0, + 5470, + 0, + 0, + 5473, + 0, + 0, + 5474, + 0, + 0, + 5476, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5477, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5484, + 0, + 0, + 5485, + 5486, + 0, + 0, + 0, + 0, + 0, + 5488, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5489, + 0, + 0, + 0, + 0, + 0, + 5507, + 0, + 0, + 0, + 5510, + 0, + 5511, + 0, + 0, + 5512, + 0, + 0, + 0, + 5513, + 0, + 5515, + 0, + 0, + 5516, + 5517, + 0, + 5518, + 0, + 0, + 5522, + 0, + 0, + 0, + 0, + 0, + 5534, + 5535, + 0, + 0, + 5536, + 0, + 5538, + 0, + 0, + 5543, + 0, + 5544, + 0, + 0, + 5545, + 0, + 5547, + 0, + 5557, + 0, + 0, + 5558, + 0, + 5560, + 5567, + 0, + 0, + 0, + 0, + 5568, + 0, + 0, + 0, + 5571, + 5573, + 0, + 5574, + 0, + 5575, + 0, + 0, + 0, + 0, + 5577, + 0, + 0, + 5598, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5600, + 5609, + 0, + 0, + 0, + 0, + 5610, + 0, + 0, + 5612, + 0, + 5624, + 0, + 5625, + 0, + 0, + 0, + 5629, + 0, + 5641, + 0, + 5642, + 5643, + 0, + 0, + 0, + 0, + 0, + 0, + 5651, + 0, + 0, + 0, + 5652, + 5653, + 0, + 5661, + 5662, + 5678, + 0, + 5679, + 0, + 0, + 0, + 0, + 5685, + 5686, + 0, + 0, + 0, + 0, + 0, + 5690, + 5692, + 0, + 5703, + 0, + 0, + 0, + 0, + 0, + 5706, + 0, + 0, + 0, + 0, + 5707, + 0, + 0, + 0, + 0, + 0, + 0, + 5708, + 0, + 0, + 5709, + 0, + 5710, + 0, + 0, + 0, + 5712, + 0, + 5733, + 0, + 5734, + 5735, + 0, + 0, + 5744, + 5751, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5752, + 0, + 5754, + 0, + 0, + 0, + 0, + 0, + 0, + 5757, + 5758, + 0, + 5760, + 5761, + 0, + 0, + 0, + 0, + 5763, + 5764, + 5765, + 0, + 5766, + 0, + 5767, + 5768, + 0, + 5770, + 0, + 0, + 0, + 0, + 5776, + 5780, + 0, + 0, + 0, + 0, + 5782, + 0, + 0, + 0, + 0, + 5784, + 0, + 0, + 5788, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5797, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5799, + 0, + 0, + 5801, + 0, + 0, + 0, + 5811, + 0, + 0, + 0, + 0, + 0, + 0, + 5816, + 0, + 0, + 5827, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5830, + 5831, + 0, + 0, + 5832, + 0, + 0, + 5833, + 0, + 5835, + 5844, + 5845, + 0, + 5846, + 0, + 0, + 0, + 0, + 0, + 5850, + 0, + 0, + 0, + 0, + 0, + 5852, + 0, + 5855, + 5857, + 0, + 0, + 5859, + 0, + 5861, + 0, + 0, + 5863, + 0, + 5865, + 0, + 0, + 0, + 5873, + 5875, + 0, + 0, + 0, + 5877, + 0, + 5879, + 0, + 0, + 0, + 5888, + 0, + 0, + 5889, + 5891, + 0, + 5894, + 0, + 0, + 0, + 0, + 0, + 0, + 5895, + 0, + 5897, + 0, + 0, + 0, + 0, + 0, + 0, + 5907, + 0, + 5911, + 0, + 0, + 5912, + 0, + 5913, + 5922, + 5924, + 0, + 5927, + 5928, + 0, + 0, + 0, + 0, + 5929, + 5930, + 0, + 5933, + 0, + 0, + 0, + 0, + 5949, + 0, + 0, + 5951, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 5953, + 0, + 0, + 5954, + 0, + 5959, + 5960, + 5961, + 0, + 5964, + 0, + 0, + 0, + 5976, + 5978, + 5987, + 5990, + 0, + 0, + 0, + 0, + 0, + 5991, + 0, + 5992, + 0, + 0, + 0, + 5994, + 5995, + 0, + 0, + 5996, + 0, + 0, + 6001, + 6003, + 0, + 0, + 0, + 0, + 6007, + 0, + 0, + 0, + 0, + 0, + 6008, + 0, + 0, + 6009, + 0, + 6010, + 0, + 0, + 0, + 6011, + 6015, + 0, + 6017, + 0, + 6019, + 0, + 6023, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6025, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6026, + 0, + 6030, + 0, + 0, + 6032, + 0, + 0, + 0, + 6033, + 6038, + 6040, + 0, + 0, + 0, + 6041, + 6045, + 0, + 0, + 6046, + 0, + 0, + 6053, + 0, + 0, + 6054, + 0, + 6055, + 0, + 0, + 0, + 0, + 0, + 0, + 6057, + 0, + 6063, + 0, + 0, + 0, + 6064, + 0, + 6066, + 6071, + 6072, + 0, + 0, + 0, + 0, + 0, + 0, + 6075, + 6076, + 0, + 0, + 6077, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6078, + 6079, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6080, + 0, + 6083, + 0, + 0, + 0, + 0, + 0, + 6084, + 0, + 0, + 6088, + 0, + 6089, + 0, + 0, + 6093, + 6105, + 0, + 0, + 6107, + 0, + 6110, + 0, + 0, + 0, + 6111, + 6125, + 6126, + 0, + 0, + 0, + 6129, + 0, + 0, + 0, + 0, + 6130, + 0, + 0, + 0, + 6131, + 6134, + 0, + 0, + 0, + 0, + 0, + 0, + 6142, + 0, + 0, + 0, + 0, + 0, + 6144, + 0, + 0, + 6146, + 6151, + 6153, + 0, + 6156, + 0, + 6163, + 0, + 6180, + 6181, + 0, + 0, + 0, + 0, + 0, + 6182, + 0, + 0, + 0, + 0, + 6184, + 6195, + 0, + 0, + 6206, + 0, + 6208, + 0, + 0, + 6212, + 6213, + 6214, + 0, + 6215, + 0, + 0, + 0, + 6228, + 0, + 0, + 0, + 6234, + 0, + 0, + 0, + 0, + 0, + 0, + 6235, + 6240, + 0, + 6242, + 6243, + 6244, + 0, + 6250, + 6255, + 0, + 0, + 0, + 0, + 0, + 6257, + 0, + 0, + 0, + 6258, + 6278, + 0, + 6284, + 0, + 0, + 0, + 6285, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6286, + 0, + 0, + 0, + 6320, + 0, + 0, + 6322, + 6332, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6334, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6335, + 0, + 0, + 6337, + 0, + 6338, + 0, + 6339, + 6340, + 0, + 0, + 6356, + 6357, + 6369, + 0, + 0, + 0, + 6370, + 6371, + 6372, + 0, + 6373, + 0, + 0, + 0, + 0, + 0, + 6376, + 0, + 0, + 0, + 0, + 0, + 6382, + 6383, + 6384, + 0, + 0, + 0, + 0, + 6386, + 0, + 6389, + 6397, + 6400, + 6411, + 0, + 6414, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6415, + 6416, + 0, + 0, + 0, + 0, + 0, + 0, + 6417, + 0, + 0, + 0, + 0, + 6418, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6420, + 0, + 6421, + 6423, + 6425, + 0, + 6429, + 6430, + 0, + 6433, + 6438, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6439, + 6440, + 0, + 0, + 6441, + 0, + 0, + 6444, + 0, + 0, + 0, + 0, + 6446, + 0, + 0, + 0, + 0, + 6447, + 6448, + 0, + 0, + 6450, + 0, + 0, + 0, + 6454, + 0, + 0, + 6455, + 0, + 6461, + 0, + 0, + 0, + 0, + 0, + 0, + 6462, + 0, + 0, + 6463, + 0, + 6464, + 0, + 6465, + 6467, + 0, + 0, + 0, + 6468, + 0, + 6479, + 6480, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6481, + 0, + 0, + 6485, + 6487, + 0, + 0, + 0, + 0, + 0, + 0, + 6493, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6494, + 6495, + 6496, + 0, + 0, + 0, + 0, + 0, + 6498, + 0, + 0, + 0, + 6507, + 6508, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6511, + 6512, + 0, + 0, + 0, + 0, + 6513, + 0, + 0, + 0, + 6514, + 0, + 0, + 0, + 0, + 0, + 6516, + 0, + 0, + 6517, + 6518, + 0, + 0, + 0, + 6519, + 6520, + 6521, + 0, + 6523, + 0, + 0, + 0, + 0, + 6524, + 6528, + 0, + 6530, + 0, + 0, + 6532, + 0, + 6578, + 0, + 0, + 0, + 6583, + 0, + 6584, + 0, + 0, + 0, + 6587, + 0, + 0, + 0, + 6590, + 0, + 6591, + 0, + 0, + 0, + 0, + 0, + 6592, + 0, + 0, + 0, + 0, + 6593, + 6594, + 0, + 0, + 0, + 0, + 0, + 6599, + 6600, + 0, + 0, + 6601, + 6602, + 6604, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6608, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6610, + 6611, + 0, + 6615, + 0, + 6616, + 6618, + 6620, + 0, + 6637, + 0, + 0, + 0, + 0, + 6639, + 0, + 0, + 0, + 0, + 6641, + 0, + 6642, + 0, + 0, + 0, + 6647, + 0, + 6660, + 6663, + 0, + 6664, + 0, + 6666, + 6669, + 0, + 6675, + 6676, + 6677, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6678, + 0, + 0, + 0, + 6679, + 0, + 6680, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6693, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6704, + 6705, + 6706, + 0, + 0, + 6711, + 6713, + 0, + 0, + 0, + 0, + 0, + 6716, + 0, + 0, + 0, + 6717, + 0, + 6719, + 6724, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6725, + 6726, + 0, + 0, + 0, + 0, + 0, + 6728, + 6729, + 6735, + 0, + 6737, + 6742, + 0, + 0, + 6743, + 6750, + 0, + 6751, + 0, + 0, + 6752, + 6753, + 0, + 0, + 0, + 0, + 0, + 0, + 6754, + 0, + 0, + 0, + 0, + 0, + 6756, + 0, + 0, + 0, + 0, + 0, + 0, + 6763, + 0, + 0, + 6764, + 6765, + 0, + 0, + 0, + 6770, + 0, + 0, + 0, + 6776, + 6780, + 0, + 6781, + 0, + 0, + 0, + 6783, + 0, + 6784, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6785, + 0, + 0, + 0, + 6792, + 0, + 0, + 0, + 6793, + 0, + 0, + 6802, + 0, + 0, + 0, + 0, + 0, + 6803, + 0, + 0, + 0, + 6804, + 0, + 0, + 0, + 6812, + 0, + 0, + 6823, + 0, + 6824, + 6839, + 0, + 0, + 0, + 0, + 6852, + 0, + 0, + 6854, + 0, + 6856, + 6857, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6867, + 0, + 6868, + 6870, + 6872, + 0, + 0, + 0, + 6873, + 6874, + 0, + 0, + 0, + 0, + 0, + 6875, + 0, + 0, + 6877, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6878, + 0, + 0, + 0, + 6879, + 0, + 6880, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6887, + 0, + 6888, + 6891, + 6893, + 0, + 6895, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6899, + 0, + 0, + 0, + 0, + 6901, + 0, + 0, + 0, + 0, + 6910, + 0, + 6911, + 0, + 0, + 6912, + 0, + 0, + 6913, + 6914, + 0, + 0, + 0, + 6915, + 0, + 0, + 0, + 6916, + 6919, + 0, + 0, + 0, + 0, + 0, + 0, + 6924, + 0, + 6925, + 0, + 0, + 0, + 6926, + 6927, + 6928, + 0, + 6929, + 0, + 6930, + 0, + 0, + 6931, + 6935, + 0, + 6936, + 0, + 0, + 0, + 0, + 6939, + 6940, + 6941, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6942, + 6948, + 6949, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6952, + 6954, + 6963, + 6965, + 6966, + 0, + 0, + 6967, + 6968, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6969, + 0, + 0, + 6970, + 6979, + 0, + 0, + 6980, + 0, + 0, + 6983, + 0, + 0, + 0, + 0, + 0, + 6984, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6988, + 6990, + 6992, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6995, + 0, + 0, + 0, + 7012, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7019, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7021, + 0, + 0, + 7022, + 7023, + 7028, + 0, + 7030, + 7033, + 0, + 0, + 0, + 0, + 0, + 0, + 7038, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7039, + 0, + 0, + 0, + 0, + 0, + 7046, + 0, + 7047, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7048, + 7052, + 0, + 0, + 0, + 0, + 0, + 7054, + 0, + 7060, + 0, + 0, + 0, + 0, + 7061, + 0, + 7065, + 0, + 0, + 0, + 0, + 7067, + 7069, + 0, + 7070, + 7071, + 7072, + 0, + 0, + 7078, + 0, + 7080, + 7081, + 0, + 7083, + 0, + 0, + 0, + 7084, + 7087, + 7088, + 0, + 0, + 7090, + 0, + 7093, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7107, + 0, + 0, + 7108, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7110, + 0, + 7114, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7115, + 0, + 7116, + 0, + 0, + 0, + 0, + 0, + 7117, + 0, + 0, + 7118, + 0, + 0, + 7124, + 0, + 7125, + 0, + 0, + 7126, + 0, + 0, + 0, + 0, + 7128, + 0, + 0, + 0, + 0, + 0, + 7129, + 0, + 7130, + 0, + 7132, + 7133, + 0, + 0, + 7134, + 0, + 0, + 7139, + 0, + 7148, + 7150, + 0, + 0, + 0, + 0, + 7152, + 0, + 0, + 0, + 7153, + 7156, + 7157, + 0, + 0, + 0, + 0, + 0, + 7158, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7163, + 7165, + 7169, + 0, + 7171, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7172, + 0, + 7173, + 7181, + 0, + 0, + 0, + 0, + 0, + 7182, + 7185, + 0, + 0, + 0, + 0, + 7187, + 0, + 7201, + 7204, + 0, + 0, + 0, + 0, + 0, + 7206, + 7207, + 0, + 0, + 0, + 0, + 7211, + 7216, + 0, + 7218, + 0, + 0, + 0, + 0, + 7226, + 7228, + 7230, + 7232, + 7233, + 7235, + 7237, + 0, + 0, + 0, + 0, + 7238, + 7241, + 0, + 7242, + 0, + 0, + 7247, + 0, + 0, + 0, + 7266, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7289, + 0, + 0, + 7290, + 7291, + 0, + 0, + 7292, + 0, + 7297, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7300, + 0, + 7301, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7302, + 0, + 0, + 0, + 0, + 7305, + 0, + 0, + 0, + 0, + 7307, + 0, + 7308, + 0, + 7310, + 0, + 7335, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7337, + 0, + 7343, + 7347, + 0, + 0, + 0, + 0, + 0, + 7348, + 0, + 7349, + 7350, + 7352, + 7354, + 0, + 0, + 0, + 0, + 7357, + 0, + 7358, + 7366, + 0, + 7367, + 7368, + 0, + 0, + 7373, + 0, + 0, + 0, + 7374, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7376, + 0, + 0, + 0, + 7377, + 0, + 0, + 0, + 0, + 0, + 7378, + 0, + 7379, + 7380, + 0, + 0, + 0, + 0, + 0, + 7383, + 0, + 0, + 7386, + 0, + 0, + 0, + 0, + 7398, + 0, + 0, + 0, + 7399, + 7400, + 0, + 7401, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7402, + 0, + 0, + 0, + 0, + 0, + 7405, + 0, + 0, + 0, + 0, + 0, + 7406, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7421, + 7427, + 7429, + 0, + 0, + 0, + 7435, + 0, + 0, + 7436, + 0, + 0, + 0, + 7437, + 0, + 0, + 0, + 0, + 0, + 0, + 7438, + 7443, + 0, + 7446, + 0, + 7448, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7456, + 0, + 0, + 0, + 0, + 0, + 7457, + 0, + 0, + 7461, + 0, + 0, + 0, + 0, + 0, + 7462, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7463, + 7466, + 7472, + 0, + 7476, + 0, + 0, + 7490, + 0, + 7491, + 0, + 0, + 7493, + 0, + 0, + 0, + 7498, + 7499, + 0, + 0, + 7508, + 0, + 0, + 0, + 0, + 0, + 7512, + 0, + 0, + 0, + 7513, + 7514, + 7516, + 0, + 0, + 0, + 0, + 7518, + 0, + 0, + 7519, + 7521, + 7522, + 0, + 0, + 0, + 7526, + 0, + 0, + 7529, + 0, + 0, + 7531, + 0, + 7536, + 0, + 7538, + 0, + 7539, + 0, + 0, + 7541, + 7542, + 7546, + 0, + 0, + 0, + 0, + 0, + 7547, + 0, + 7548, + 0, + 0, + 0, + 0, + 0, + 7550, + 0, + 0, + 7552, + 7553, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7554, + 7563, + 0, + 7573, + 0, + 0, + 0, + 0, + 0, + 0, + 7574, + 7576, + 0, + 7578, + 7581, + 7583, + 0, + 0, + 0, + 7584, + 0, + 7587, + 0, + 0, + 0, + 0, + 0, + 7589, + 0, + 0, + 0, + 7594, + 0, + 0, + 7595, + 0, + 0, + 7600, + 7602, + 7610, + 0, + 0, + 0, + 0, + 0, + 7612, + 0, + 7613, + 7614, + 0, + 0, + 7615, + 0, + 0, + 7616, + 0, + 7620, + 0, + 7621, + 7622, + 0, + 7623, + 0, + 0, + 0, + 0, + 7626, + 0, + 0, + 0, + 0, + 7627, + 7629, + 7631, + 0, + 0, + 7633, + 0, + 0, + 0, + 0, + 0, + 7639, + 0, + 7640, + 7642, + 0, + 0, + 7643, + 0, + 0, + 0, + 0, + 7644, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7645, + 0, + 0, + 0, + 0, + 0, + 7661, + 7662, + 7663, + 7665, + 0, + 7666, + 0, + 7667, + 0, + 7684, + 7688, + 7690, + 0, + 7691, + 0, + 0, + 0, + 0, + 0, + 0, + 7692, + 0, + 0, + 7700, + 0, + 7707, + 0, + 7708, + 0, + 7709, + 0, + 7721, + 0, + 0, + 0, + 7722, + 0, + 7724, + 0, + 0, + 0, + 0, + 0, + 0, + 7729, + 7731, + 0, + 7732, + 0, + 7733, + 7735, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7739, + 0, + 0, + 7741, + 7745, + 0, + 7748, + 0, + 0, + 0, + 7751, + 0, + 0, + 0, + 7752, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7753, + 0, + 0, + 7756, + 0, + 7757, + 0, + 7759, + 0, + 7760, + 0, + 0, + 0, + 0, + 7761, + 7768, + 0, + 0, + 7769, + 0, + 0, + 7770, + 0, + 0, + 7771, + 0, + 0, + 7772, + 0, + 0, + 7773, + 0, + 0, + 0, + 0, + 0, + 7778, + 7783, + 0, + 0, + 0, + 0, + 0, + 7784, + 7785, + 0, + 7790, + 0, + 0, + 0, + 0, + 7792, + 0, + 7798, + 0, + 0, + 0, + 0, + 0, + 7799, + 0, + 7810, + 0, + 0, + 7813, + 0, + 7814, + 0, + 7816, + 0, + 7818, + 7824, + 7825, + 7826, + 0, + 7828, + 7830, + 0, + 0, + 0, + 7840, + 0, + 7842, + 0, + 7843, + 0, + 0, + 0, + 0, + 7844, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7846, + 0, + 0, + 0, + 0, + 0, + 7856, + 7857, + 7858, + 7862, + 0, + 7865, + 0, + 0, + 7866, + 0, + 0, + 7913, + 0, + 0, + 0, + 0, + 7914, + 0, + 0, + 7915, + 7917, + 7918, + 7919, + 0, + 7920, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7921, + 7922, + 0, + 7924, + 0, + 0, + 7925, + 0, + 0, + 7927, + 0, + 7930, + 7935, + 0, + 0, + 7937, + 0, + 0, + 0, + 0, + 0, + 0, + 7939, + 0, + 7940, + 0, + 0, + 0, + 0, + 0, + 7941, + 0, + 0, + 0, + 0, + 7945, + 0, + 0, + 0, + 0, + 7949, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7950, + 0, + 7953, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7968, + 0, + 0, + 0, + 0, + 7969, + 7972, + 7992, + 0, + 7993, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 7994, + 0, + 0, + 0, + 0, + 8007, + 8008, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8010, + 0, + 0, + 0, + 8012, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8018, + 0, + 8028, + 8029, + 0, + 0, + 8030, + 0, + 0, + 8032, + 8033, + 0, + 0, + 8034, + 8036, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8037, + 0, + 0, + 0, + 8043, + 8052, + 8059, + 8060, + 0, + 0, + 8061, + 0, + 0, + 0, + 8062, + 0, + 8063, + 0, + 8064, + 0, + 8066, + 8068, + 0, + 0, + 0, + 8080, + 8081, + 0, + 8089, + 0, + 0, + 0, + 0, + 0, + 8092, + 0, + 0, + 0, + 0, + 0, + 0, + 8093, + 8110, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8111, + 0, + 0, + 0, + 0, + 0, + 8112, + 8115, + 0, + 8117, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8120, + 8121, + 8122, + 8128, + 8129, + 8130, + 8131, + 0, + 0, + 8139, + 0, + 0, + 8144, + 0, + 0, + 0, + 0, + 8145, + 8146, + 8153, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8154, + 0, + 8157, + 8160, + 8162, + 0, + 8164, + 8165, + 0, + 0, + 0, + 0, + 8166, + 8167, + 0, + 0, + 8179, + 0, + 0, + 0, + 8185, + 0, + 0, + 0, + 8186, + 0, + 0, + 8187, + 0, + 0, + 0, + 8188, + 0, + 0, + 0, + 0, + 0, + 8204, + 0, + 0, + 0, + 0, + 8210, + 0, + 0, + 0, + 0, + 0, + 8213, + 0, + 8214, + 0, + 0, + 8215, + 0, + 0, + 0, + 0, + 0, + 0, + 8218, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8219, + 0, + 8221, + 0, + 0, + 8222, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8225, + 0, + 0, + 0, + 8233, + 0, + 0, + 8242, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8247, + 0, + 8248, + 8252, + 0, + 8256, + 8257, + 0, + 0, + 8261, + 0, + 8264, + 8265, + 0, + 0, + 0, + 0, + 8267, + 0, + 0, + 0, + 8269, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8270, + 0, + 0, + 0, + 8278, + 0, + 8279, + 8283, + 0, + 0, + 8285, + 8286, + 8289, + 8292, + 0, + 0, + 0, + 0, + 8293, + 8295, + 8299, + 8300, + 8301, + 0, + 0, + 0, + 0, + 0, + 0, + 8304, + 8307, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8321, + 0, + 0, + 0, + 8322, + 8323, + 8325, + 8326, + 8327, + 0, + 0, + 8332, + 8338, + 0, + 0, + 8340, + 0, + 0, + 0, + 0, + 0, + 8350, + 0, + 0, + 8351, + 0, + 8354, + 8355, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8360, + 8372, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8377, + 0, + 0, + 0, + 0, + 8380, + 0, + 0, + 0, + 8383, + 0, + 8384, + 0, + 0, + 0, + 0, + 8386, + 8392, + 0, + 0, + 8394, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8396, + 8397, + 0, + 8398, + 0, + 8399, + 0, + 0, + 0, + 0, + 0, + 8400, + 0, + 8401, + 8410, + 8411, + 0, + 8412, + 8413, + 8422, + 0, + 0, + 0, + 0, + 8423, + 0, + 0, + 0, + 0, + 8424, + 0, + 0, + 8425, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8441, + 8442, + 0, + 0, + 0, + 0, + 0, + 0, + 8443, + 0, + 0, + 8444, + 0, + 8447, + 0, + 0, + 0, + 0, + 8451, + 0, + 8458, + 0, + 8462, + 0, + 0, + 8468, + 0, + 8469, + 0, + 0, + 0, + 8470, + 0, + 8473, + 8479, + 8480, + 0, + 0, + 0, + 0, + 8481, + 8483, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8484, + 0, + 0, + 8490, + 0, + 0, + 0, + 0, + 0, + 0, + 8491, + 8493, + 8494, + 0, + 8528, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8530, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8534, + 8538, + 8540, + 0, + 0, + 8541, + 0, + 0, + 8545, + 0, + 8557, + 0, + 0, + 8569, + 8570, + 0, + 0, + 8571, + 8574, + 8575, + 8579, + 0, + 8583, + 0, + 0, + 0, + 0, + 8591, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8606, + 0, + 8607, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8608, + 0, + 0, + 8609, + 0, + 0, + 0, + 8610, + 0, + 0, + 0, + 8611, + 0, + 0, + 8613, + 8617, + 8621, + 0, + 0, + 8622, + 0, + 8623, + 0, + 8624, + 8625, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8637, + 8638, + 8639, + 8650, + 0, + 0, + 0, + 0, + 8652, + 8654, + 8655, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8656, + 0, + 0, + 0, + 0, + 0, + 8657, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8658, + 0, + 0, + 8659, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8660, + 0, + 0, + 0, + 0, + 0, + 0, + 8661, + 8663, + 8664, + 0, + 0, + 0, + 0, + 8665, + 0, + 8669, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8671, + 8674, + 0, + 8684, + 0, + 8686, + 0, + 0, + 0, + 8689, + 0, + 0, + 0, + 8690, + 0, + 8706, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8710, + 0, + 8711, + 8713, + 8714, + 8724, + 8727, + 8728, + 8733, + 8736, + 0, + 8737, + 8739, + 0, + 0, + 0, + 0, + 8742, + 8743, + 8745, + 8754, + 0, + 0, + 0, + 0, + 8756, + 0, + 0, + 0, + 0, + 0, + 0, + 8757, + 8760, + 0, + 0, + 0, + 0, + 0, + 8762, + 8763, + 8764, + 0, + 8766, + 8769, + 8770, + 8773, + 0, + 8774, + 0, + 8779, + 0, + 0, + 0, + 0, + 8780, + 0, + 0, + 8781, + 0, + 0, + 8783, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8784, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8785, + 0, + 0, + 0, + 0, + 8786, + 0, + 0, + 0, + 0, + 8788, + 8790, + 0, + 0, + 0, + 8803, + 0, + 8813, + 8814, + 0, + 0, + 0, + 0, + 0, + 8815, + 8816, + 0, + 0, + 0, + 0, + 8818, + 0, + 0, + 0, + 0, + 8822, + 8828, + 8829, + 0, + 8831, + 0, + 0, + 0, + 0, + 8833, + 0, + 0, + 0, + 8834, + 0, + 0, + 0, + 8835, + 0, + 8836, + 0, + 0, + 0, + 8837, + 0, + 0, + 0, + 0, + 0, + 0, + 8838, + 8839, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8840, + 0, + 0, + 0, + 8841, + 0, + 8842, + 0, + 0, + 0, + 8846, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8847, + 0, + 8848, + 0, + 0, + 8864, + 0, + 0, + 8866, + 0, + 0, + 8870, + 8872, + 0, + 0, + 8873, + 8874, + 0, + 0, + 0, + 0, + 0, + 0, + 8875, + 0, + 8876, + 0, + 0, + 0, + 0, + 8896, + 8900, + 0, + 0, + 0, + 0, + 8901, + 0, + 0, + 0, + 0, + 0, + 8904, + 0, + 8907, + 0, + 0, + 0, + 0, + 8911, + 8912, + 8913, + 0, + 0, + 0, + 8914, + 0, + 8915, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8916, + 0, + 0, + 0, + 8929, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 8930, + 0, + 8932, + 0, + 8943, + 0, + 0, + 0, + 8945, + 8947, + 0, + 0, + 0, + 0, + 8949, + 0, + 8950, + 0, + 8954, + 8957, + 0, + 0, + 8970, + 0, + 0, + 0, + 0, + 8971, + 0, + 8996, + 0, + 0, + 0, + 0, + 8997, + 9000, + 0, + 0, + 0, + 0, + 9001, + 9002, + 0, + 9004, + 9009, + 9024, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9027, + 9082, + 0, + 0, + 9083, + 9089, + 0, + 0, + 0, + 0, + 0, + 0, + 9090, + 0, + 0, + 0, + 9092, + 0, + 0, + 9093, + 0, + 9095, + 0, + 0, + 9096, + 9097, + 9101, + 9102, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9112, + 0, + 0, + 0, + 0, + 0, + 0, + 9114, + 0, + 0, + 9120, + 0, + 9121, + 9122, + 0, + 0, + 0, + 9123, + 9124, + 0, + 0, + 9125, + 0, + 0, + 9126, + 0, + 9127, + 0, + 0, + 9129, + 9131, + 0, + 0, + 0, + 9132, + 0, + 0, + 9136, + 0, + 9144, + 0, + 0, + 9148, + 0, + 0, + 0, + 0, + 0, + 0, + 9149, + 0, + 9152, + 9163, + 0, + 0, + 9165, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9166, + 0, + 9169, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9170, + 0, + 0, + 0, + 0, + 9172, + 0, + 9174, + 9175, + 9176, + 0, + 9177, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9186, + 0, + 9187, + 0, + 0, + 0, + 9188, + 9189, + 0, + 0, + 9190, + 0, + 0, + 0, + 0, + 9191, + 0, + 0, + 0, + 9193, + 0, + 0, + 0, + 0, + 9197, + 9198, + 0, + 0, + 0, + 9208, + 9211, + 0, + 0, + 0, + 0, + 9216, + 9217, + 0, + 9220, + 0, + 0, + 0, + 0, + 9221, + 9222, + 9223, + 0, + 9224, + 9225, + 0, + 0, + 9227, + 0, + 9228, + 9229, + 0, + 0, + 9230, + 0, + 9232, + 0, + 9233, + 0, + 0, + 0, + 0, + 0, + 9234, + 9235, + 0, + 0, + 9237, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9238, + 9240, + 0, + 0, + 9241, + 0, + 0, + 0, + 0, + 9244, + 0, + 0, + 0, + 0, + 9247, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9248, + 0, + 0, + 0, + 9249, + 0, + 0, + 0, + 0, + 0, + 9250, + 0, + 0, + 0, + 0, + 9251, + 0, + 0, + 9252, + 9255, + 0, + 0, + 0, + 9256, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9257, + 0, + 0, + 9258, + 0, + 0, + 0, + 0, + 0, + 0, + 9259, + 0, + 0, + 0, + 0, + 0, + 9262, + 9263, + 0, + 0, + 9265, + 9266, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9268, + 9271, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9273, + 0, + 0, + 0, + 9276, + 9277, + 9279, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9280, + 0, + 0, + 9293, + 0, + 0, + 0, + 0, + 0, + 9297, + 9301, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9308, + 9309, + 9313, + 9321, + 9322, + 0, + 9326, + 9327, + 0, + 0, + 9477, + 0, + 9479, + 0, + 0, + 0, + 0, + 9482, + 0, + 0, + 0, + 9483, + 0, + 9484, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9485, + 0, + 0, + 9486, + 0, + 0, + 0, + 9489, + 0, + 0, + 0, + 0, + 9490, + 9491, + 0, + 0, + 0, + 0, + 9493, + 0, + 9495, + 9496, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9500, + 0, + 9502, + 0, + 0, + 0, + 0, + 0, + 9504, + 9507, + 0, + 9509, + 0, + 9511, + 0, + 0, + 9513, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9515, + 0, + 0, + 0, + 0, + 0, + 0, + 9516, + 9517, + 0, + 0, + 0, + 0, + 9532, + 0, + 0, + 9533, + 0, + 0, + 9538, + 0, + 9539, + 9540, + 0, + 0, + 0, + 0, + 9541, + 0, + 0, + 0, + 9542, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9544, + 9545, + 0, + 9546, + 0, + 0, + 0, + 0, + 0, + 0, + 9547, + 9548, + 0, + 0, + 0, + 9550, + 0, + 9557, + 0, + 9558, + 0, + 9561, + 0, + 9563, + 9570, + 0, + 9572, + 9574, + 9575, + 0, + 0, + 0, + 9577, + 9592, + 0, + 0, + 9596, + 0, + 0, + 0, + 9598, + 0, + 9600, + 0, + 9601, + 0, + 0, + 0, + 0, + 0, + 0, + 9608, + 0, + 9638, + 9639, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9641, + 0, + 0, + 9643, + 9644, + 9645, + 9646, + 0, + 0, + 0, + 9648, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9650, + 9654, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9655, + 0, + 0, + 0, + 0, + 0, + 9656, + 0, + 9657, + 0, + 0, + 0, + 0, + 9658, + 0, + 0, + 9659, + 0, + 0, + 9664, + 0, + 0, + 9665, + 0, + 9667, + 9669, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9671, + 0, + 9673, + 9681, + 0, + 0, + 0, + 0, + 9682, + 9683, + 9684, + 0, + 0, + 0, + 0, + 9686, + 9698, + 0, + 0, + 9700, + 9701, + 9702, + 0, + 9703, + 9717, + 0, + 0, + 0, + 0, + 9718, + 0, + 9726, + 0, + 0, + 0, + 0, + 9727, + 0, + 0, + 0, + 9728, + 0, + 9742, + 0, + 9744, + 0, + 0, + 0, + 9750, + 0, + 9754, + 9755, + 0, + 0, + 0, + 0, + 0, + 9756, + 0, + 9757, + 9768, + 0, + 9769, + 0, + 0, + 0, + 9770, + 9771, + 0, + 9773, + 0, + 9774, + 0, + 9775, + 0, + 0, + 0, + 9776, + 9777, + 9784, + 0, + 0, + 0, + 9786, + 0, + 9789, + 0, + 0, + 0, + 0, + 9793, + 9794, + 0, + 0, + 0, + 9808, + 0, + 0, + 0, + 0, + 0, + 9811, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9812, + 0, + 9820, + 0, + 9823, + 0, + 9828, + 0, + 0, + 0, + 0, + 9830, + 0, + 0, + 9833, + 9836, + 0, + 0, + 0, + 9840, + 0, + 0, + 0, + 9841, + 0, + 0, + 9842, + 0, + 9845, + 0, + 0, + 0, + 9847, + 9848, + 0, + 0, + 9855, + 0, + 0, + 0, + 0, + 0, + 0, + 9856, + 9863, + 9865, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9866, + 9867, + 9868, + 9873, + 9875, + 0, + 0, + 0, + 0, + 0, + 0, + 9880, + 0, + 9886, + 0, + 0, + 0, + 9887, + 0, + 0, + 9891, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9906, + 9907, + 9908, + 0, + 0, + 0, + 9909, + 0, + 0, + 0, + 0, + 0, + 0, + 9910, + 0, + 0, + 0, + 0, + 9913, + 0, + 0, + 0, + 0, + 9914, + 0, + 0, + 0, + 0, + 0, + 9922, + 0, + 0, + 0, + 0, + 9923, + 9925, + 0, + 0, + 0, + 0, + 0, + 0, + 9930, + 0, + 0, + 0, + 9931, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9932, + 0, + 9939, + 0, + 0, + 9940, + 9962, + 9966, + 0, + 9969, + 9970, + 0, + 0, + 9974, + 0, + 9979, + 9981, + 9982, + 0, + 0, + 0, + 9985, + 0, + 0, + 0, + 0, + 0, + 0, + 9987, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 9988, + 9993, + 0, + 0, + 9994, + 0, + 0, + 0, + 9997, + 0, + 10004, + 0, + 0, + 0, + 0, + 0, + 10007, + 10019, + 10020, + 10022, + 0, + 0, + 0, + 10031, + 0, + 0, + 0, + 0, + 0, + 10032, + 0, + 0, + 10034, + 0, + 10036, + 0, + 0, + 0, + 0, + 10038, + 0, + 10039, + 10040, + 10041, + 10042, + 0, + 0, + 0, + 0, + 0, + 10043, + 0, + 0, + 0, + 0, + 0, + 10045, + 10054, + 0, + 0, + 0, + 0, + 10055, + 0, + 0, + 10057, + 10058, + 0, + 0, + 0, + 0, + 0, + 0, + 10059, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10060, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10063, + 0, + 10066, + 0, + 0, + 0, + 10070, + 0, + 10072, + 0, + 0, + 10076, + 10077, + 0, + 0, + 10084, + 0, + 10087, + 10090, + 10091, + 0, + 0, + 0, + 10094, + 10097, + 0, + 0, + 0, + 0, + 0, + 0, + 10098, + 0, + 0, + 0, + 0, + 0, + 0, + 10103, + 0, + 10104, + 0, + 10108, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10120, + 0, + 0, + 0, + 10122, + 0, + 0, + 10125, + 0, + 0, + 0, + 0, + 10127, + 10128, + 0, + 0, + 10134, + 0, + 10135, + 10136, + 0, + 10137, + 0, + 0, + 10147, + 0, + 10149, + 10150, + 0, + 0, + 10156, + 0, + 10158, + 10159, + 10160, + 10168, + 0, + 0, + 10171, + 0, + 10173, + 0, + 0, + 0, + 10176, + 0, + 0, + 0, + 0, + 10177, + 0, + 0, + 0, + 0, + 10178, + 0, + 0, + 0, + 0, + 10194, + 0, + 10202, + 0, + 0, + 10203, + 10204, + 0, + 10205, + 10206, + 0, + 10207, + 0, + 0, + 0, + 0, + 10209, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10213, + 0, + 0, + 0, + 0, + 0, + 0, + 10217, + 0, + 10229, + 0, + 10230, + 10231, + 0, + 0, + 10232, + 0, + 0, + 10237, + 10238, + 10244, + 0, + 0, + 0, + 0, + 0, + 10250, + 0, + 10252, + 0, + 0, + 0, + 0, + 0, + 0, + 10255, + 0, + 0, + 10257, + 0, + 0, + 0, + 0, + 0, + 0, + 10258, + 0, + 10259, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10260, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10284, + 10288, + 10289, + 0, + 0, + 0, + 10290, + 0, + 10296, + 0, + 0, + 0, + 0, + 0, + 10297, + 0, + 0, + 0, + 0, + 0, + 0, + 10298, + 0, + 0, + 0, + 0, + 10299, + 10303, + 0, + 0, + 0, + 0, + 0, + 10306, + 0, + 0, + 0, + 10307, + 0, + 10308, + 0, + 0, + 0, + 0, + 10311, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10315, + 10317, + 0, + 0, + 0, + 10318, + 10319, + 0, + 10321, + 0, + 10326, + 0, + 10328, + 0, + 0, + 0, + 0, + 10329, + 0, + 0, + 10331, + 0, + 10332, + 0, + 0, + 0, + 0, + 0, + 0, + 10334, + 0, + 0, + 10335, + 10338, + 0, + 0, + 0, + 0, + 0, + 10339, + 10349, + 0, + 0, + 0, + 0, + 0, + 0, + 10351, + 0, + 10353, + 0, + 0, + 0, + 0, + 0, + 0, + 10362, + 0, + 10368, + 0, + 10369, + 0, + 0, + 0, + 10372, + 10373, + 0, + 0, + 0, + 0, + 0, + 10374, + 0, + 0, + 0, + 10375, + 0, + 10376, + 0, + 0, + 10386, + 10388, + 10390, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10391, + 0, + 0, + 10392, + 10394, + 0, + 0, + 10396, + 0, + 10397, + 0, + 10403, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10404, + 0, + 10405, + 10410, + 0, + 0, + 10411, + 0, + 10412, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10421, + 10422, + 10423, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10425, + 0, + 0, + 10427, + 0, + 0, + 10430, + 0, + 0, + 0, + 0, + 0, + 10432, + 0, + 10433, + 10434, + 0, + 0, + 0, + 0, + 10436, + 10437, + 0, + 10438, + 0, + 10439, + 0, + 10444, + 10446, + 0, + 0, + 0, + 0, + 0, + 10448, + 0, + 0, + 0, + 0, + 0, + 10449, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10451, + 0, + 10453, + 0, + 0, + 0, + 10454, + 10457, + 0, + 0, + 10459, + 0, + 10469, + 0, + 0, + 0, + 0, + 0, + 10472, + 10481, + 0, + 0, + 0, + 0, + 0, + 10482, + 10483, + 0, + 10492, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10499, + 0, + 0, + 0, + 10502, + 0, + 0, + 10510, + 0, + 10521, + 10524, + 0, + 0, + 10525, + 10526, + 10528, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10530, + 0, + 0, + 0, + 0, + 10533, + 0, + 10534, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10535, + 10536, + 0, + 0, + 10544, + 0, + 10553, + 10556, + 0, + 10557, + 10559, + 0, + 0, + 0, + 0, + 0, + 10562, + 10563, + 10564, + 0, + 10565, + 0, + 0, + 0, + 10566, + 0, + 10567, + 0, + 0, + 0, + 0, + 10575, + 0, + 0, + 10576, + 0, + 10578, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10585, + 10586, + 10587, + 10589, + 0, + 10590, + 0, + 0, + 10594, + 0, + 0, + 0, + 0, + 0, + 10598, + 0, + 0, + 10601, + 0, + 0, + 0, + 10602, + 0, + 10603, + 0, + 10604, + 0, + 10605, + 0, + 0, + 10607, + 0, + 10626, + 0, + 10627, + 0, + 0, + 0, + 0, + 0, + 10629, + 10630, + 10631, + 0, + 0, + 0, + 10646, + 0, + 0, + 0, + 10647, + 0, + 10650, + 0, + 10651, + 0, + 0, + 0, + 10652, + 10653, + 10655, + 0, + 10658, + 0, + 0, + 10659, + 0, + 10667, + 0, + 0, + 0, + 0, + 10669, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10670, + 0, + 0, + 0, + 10671, + 0, + 0, + 0, + 0, + 10672, + 10673, + 0, + 10674, + 0, + 0, + 0, + 10676, + 0, + 0, + 0, + 0, + 0, + 0, + 10678, + 0, + 10682, + 0, + 0, + 10692, + 0, + 10697, + 0, + 0, + 0, + 0, + 10698, + 0, + 0, + 0, + 10700, + 0, + 0, + 0, + 0, + 0, + 10703, + 0, + 10704, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10705, + 0, + 10715, + 10718, + 10720, + 0, + 0, + 10722, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10723, + 0, + 0, + 0, + 0, + 10726, + 0, + 0, + 0, + 0, + 0, + 10727, + 10730, + 10743, + 0, + 0, + 0, + 0, + 0, + 0, + 10744, + 0, + 0, + 10745, + 0, + 0, + 0, + 0, + 0, + 0, + 10748, + 0, + 0, + 0, + 0, + 10750, + 0, + 0, + 10752, + 10753, + 0, + 0, + 0, + 10756, + 0, + 0, + 0, + 0, + 0, + 0, + 10758, + 0, + 0, + 0, + 10759, + 0, + 10769, + 0, + 0, + 10772, + 0, + 0, + 0, + 0, + 0, + 0, + 10773, + 0, + 0, + 0, + 10777, + 0, + 0, + 10779, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10780, + 10784, + 0, + 0, + 0, + 10789, + 0, + 0, + 0, + 10791, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10795, + 0, + 0, + 10796, + 0, + 10808, + 0, + 10809, + 0, + 0, + 0, + 10810, + 0, + 0, + 0, + 10812, + 0, + 0, + 10814, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10815, + 0, + 0, + 0, + 0, + 10816, + 10817, + 0, + 0, + 0, + 0, + 10819, + 0, + 10820, + 0, + 0, + 0, + 0, + 10821, + 10822, + 10823, + 0, + 10826, + 10849, + 0, + 0, + 0, + 0, + 10850, + 0, + 0, + 10852, + 0, + 10853, + 0, + 0, + 10856, + 0, + 0, + 10857, + 10858, + 10859, + 10860, + 0, + 0, + 0, + 0, + 0, + 0, + 10863, + 0, + 10866, + 10867, + 10872, + 10890, + 0, + 0, + 10891, + 10892, + 0, + 0, + 0, + 0, + 0, + 10893, + 0, + 0, + 0, + 10896, + 10899, + 0, + 0, + 10900, + 10902, + 0, + 0, + 0, + 0, + 0, + 10903, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10905, + 0, + 10906, + 0, + 0, + 0, + 0, + 10908, + 10911, + 0, + 10912, + 0, + 0, + 10916, + 0, + 0, + 0, + 0, + 0, + 10917, + 0, + 10918, + 0, + 0, + 0, + 10923, + 0, + 0, + 0, + 0, + 0, + 10924, + 0, + 0, + 10928, + 10929, + 0, + 0, + 10930, + 0, + 0, + 0, + 10932, + 0, + 0, + 0, + 0, + 10939, + 0, + 0, + 10945, + 0, + 0, + 0, + 10947, + 0, + 0, + 10948, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10958, + 0, + 10960, + 10962, + 0, + 0, + 10964, + 0, + 0, + 0, + 10966, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 10967, + 0, + 0, + 0, + 10968, + 0, + 0, + 0, + 10973, + 0, + 0, + 0, + 0, + 0, + 10975, + 0, + 0, + 0, + 10976, + 10978, + 0, + 0, + 10982, + 10984, + 10987, + 0, + 0, + 10988, + 0, + 10989, + 0, + 0, + 10991, + 0, + 0, + 0, + 0, + 10992, + 0, + 0, + 0, + 10993, + 0, + 10995, + 0, + 0, + 0, + 10996, + 10997, + 0, + 0, + 0, + 10998, + 0, + 10999, + 0, + 11001, + 0, + 0, + 0, + 0, + 0, + 0, + 11010, + 11012, + 0, + 11013, + 11016, + 11017, + 0, + 0, + 11019, + 11020, + 11021, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11022, + 0, + 0, + 11023, + 11029, + 0, + 0, + 0, + 0, + 11031, + 0, + 0, + 0, + 11034, + 0, + 0, + 0, + 0, + 11055, + 0, + 0, + 0, + 0, + 0, + 11056, + 11060, + 0, + 0, + 0, + 0, + 0, + 0, + 11061, + 0, + 0, + 11064, + 11065, + 0, + 11066, + 0, + 11069, + 0, + 11085, + 0, + 0, + 0, + 0, + 0, + 11086, + 0, + 0, + 0, + 11088, + 0, + 0, + 0, + 11094, + 0, + 0, + 0, + 11095, + 11096, + 0, + 0, + 0, + 0, + 0, + 0, + 11097, + 11098, + 0, + 0, + 0, + 0, + 0, + 0, + 11099, + 0, + 0, + 11102, + 11108, + 0, + 0, + 0, + 11109, + 0, + 11114, + 11119, + 0, + 11131, + 0, + 0, + 0, + 11142, + 0, + 0, + 11143, + 0, + 11146, + 0, + 11147, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11148, + 0, + 11149, + 11152, + 11153, + 11154, + 0, + 11156, + 0, + 11157, + 0, + 0, + 0, + 11158, + 0, + 0, + 11159, + 11160, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11163, + 0, + 0, + 11164, + 11166, + 0, + 0, + 0, + 11172, + 11174, + 0, + 0, + 0, + 11176, + 0, + 0, + 0, + 0, + 0, + 11182, + 11183, + 0, + 0, + 0, + 11184, + 11187, + 0, + 0, + 11188, + 11189, + 0, + 0, + 0, + 0, + 0, + 0, + 11194, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11200, + 11202, + 0, + 0, + 0, + 0, + 0, + 0, + 11203, + 0, + 11204, + 0, + 0, + 0, + 0, + 0, + 11205, + 0, + 0, + 0, + 11206, + 0, + 11207, + 0, + 0, + 11209, + 0, + 11211, + 0, + 11214, + 0, + 0, + 11231, + 0, + 0, + 0, + 11293, + 11295, + 0, + 0, + 11296, + 11297, + 11302, + 0, + 0, + 0, + 11307, + 0, + 0, + 0, + 0, + 11309, + 11310, + 0, + 11311, + 0, + 0, + 0, + 11313, + 0, + 11314, + 0, + 0, + 0, + 0, + 11334, + 0, + 11338, + 0, + 0, + 0, + 11339, + 0, + 0, + 0, + 0, + 0, + 11340, + 0, + 11341, + 11342, + 0, + 11344, + 0, + 11345, + 0, + 0, + 0, + 11348, + 11349, + 0, + 0, + 11350, + 0, + 0, + 0, + 11355, + 0, + 0, + 0, + 0, + 0, + 0, + 11356, + 0, + 11357, + 11370, + 0, + 0, + 11371, + 0, + 11374, + 11376, + 0, + 0, + 0, + 11377, + 0, + 0, + 11378, + 11383, + 0, + 11386, + 11399, + 0, + 11400, + 11406, + 0, + 0, + 0, + 11408, + 0, + 0, + 11409, + 11412, + 0, + 0, + 0, + 0, + 11417, + 0, + 0, + 0, + 11418, + 0, + 11421, + 0, + 11426, + 11429, + 0, + 0, + 0, + 0, + 0, + 11430, + 0, + 11437, + 0, + 11438, + 0, + 0, + 0, + 0, + 0, + 11440, + 11453, + 0, + 0, + 0, + 0, + 0, + 0, + 11454, + 0, + 0, + 0, + 0, + 11455, + 0, + 0, + 11456, + 11460, + 11461, + 11463, + 0, + 11469, + 0, + 11473, + 0, + 0, + 0, + 0, + 11474, + 0, + 0, + 0, + 11475, + 0, + 11476, + 11477, + 11480, + 0, + 0, + 0, + 0, + 11481, + 0, + 0, + 11484, + 0, + 0, + 11487, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11497, + 0, + 0, + 11502, + 0, + 11509, + 0, + 0, + 11510, + 11511, + 11513, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11515, + 0, + 0, + 0, + 0, + 11516, + 0, + 11520, + 11521, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11529, + 11530, + 11531, + 11534, + 0, + 0, + 11543, + 0, + 0, + 0, + 0, + 0, + 11547, + 0, + 11548, + 0, + 0, + 0, + 0, + 0, + 11552, + 11556, + 0, + 11557, + 0, + 0, + 11559, + 0, + 11560, + 0, + 0, + 0, + 0, + 0, + 0, + 11561, + 0, + 0, + 11563, + 11564, + 0, + 11565, + 0, + 0, + 0, + 0, + 11567, + 0, + 0, + 0, + 11569, + 0, + 11574, + 0, + 11575, + 0, + 0, + 0, + 11577, + 0, + 11578, + 0, + 0, + 0, + 11580, + 11581, + 0, + 0, + 0, + 11582, + 11584, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11587, + 0, + 11588, + 11591, + 0, + 11595, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11596, + 0, + 11597, + 0, + 0, + 0, + 0, + 11598, + 11601, + 0, + 0, + 0, + 11602, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11603, + 11604, + 0, + 11606, + 0, + 0, + 11608, + 0, + 0, + 0, + 0, + 11610, + 0, + 0, + 11611, + 0, + 0, + 0, + 0, + 11613, + 0, + 11622, + 0, + 0, + 0, + 11623, + 0, + 0, + 0, + 0, + 11625, + 0, + 0, + 11626, + 11627, + 11628, + 11630, + 0, + 0, + 0, + 0, + 0, + 0, + 11639, + 0, + 0, + 11646, + 0, + 11648, + 11649, + 0, + 11650, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11651, + 0, + 0, + 11652, + 11653, + 11656, + 0, + 0, + 11677, + 11679, + 0, + 0, + 0, + 0, + 11680, + 0, + 0, + 11681, + 0, + 11685, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11688, + 0, + 0, + 0, + 11716, + 0, + 11719, + 0, + 0, + 0, + 0, + 0, + 11721, + 0, + 0, + 11724, + 11743, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11745, + 11748, + 11750, + 0, + 0, + 0, + 0, + 0, + 11751, + 0, + 0, + 0, + 11752, + 11754, + 0, + 11755, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11759, + 0, + 0, + 0, + 0, + 0, + 0, + 11760, + 0, + 0, + 0, + 11761, + 0, + 0, + 0, + 0, + 0, + 0, + 11766, + 11767, + 0, + 11772, + 11773, + 0, + 11774, + 0, + 0, + 11775, + 0, + 11777, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11778, + 11780, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11783, + 0, + 11784, + 0, + 0, + 0, + 11785, + 0, + 0, + 0, + 11786, + 0, + 0, + 0, + 0, + 11788, + 0, + 0, + 11789, + 11791, + 11792, + 0, + 0, + 0, + 0, + 11795, + 11834, + 11835, + 11836, + 0, + 0, + 11837, + 0, + 0, + 0, + 11838, + 0, + 0, + 11846, + 11851, + 0, + 11852, + 0, + 11869, + 0, + 0, + 0, + 11871, + 0, + 0, + 0, + 11872, + 11874, + 0, + 0, + 0, + 0, + 0, + 0, + 11875, + 0, + 11876, + 11877, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11883, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11884, + 0, + 11885, + 0, + 11886, + 0, + 0, + 11887, + 0, + 11894, + 11895, + 11897, + 11909, + 11910, + 0, + 11912, + 11918, + 0, + 0, + 11920, + 0, + 11922, + 11924, + 11927, + 11928, + 0, + 0, + 0, + 0, + 11929, + 0, + 11934, + 0, + 0, + 0, + 0, + 0, + 11941, + 11943, + 11944, + 0, + 11945, + 0, + 0, + 0, + 0, + 11948, + 11949, + 0, + 0, + 0, + 0, + 11953, + 0, + 11954, + 0, + 11955, + 0, + 11956, + 0, + 0, + 0, + 0, + 0, + 11957, + 0, + 0, + 11959, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 11961, + 0, + 0, + 0, + 0, + 0, + 11978, + 0, + 0, + 0, + 11979, + 11980, + 11986, + 11987, + 0, + 11992, + 0, + 0, + 0, + 0, + 0, + 11993, + 0, + 0, + 0, + 11994, + 0, + 11999, + 12004, + 12005, + 12006, + 0, + 0, + 0, + 0, + 0, + 12011, + 0, + 0, + 12012, + 12014, + 0, + 0, + 12015, + 0, + 0, + 12019, + 12028, + 0, + 0, + 12029, + 0, + 0, + 12032, + 12033, + 0, + 0, + 0, + 0, + 12034, + 0, + 12041, + 12043, + 0, + 0, + 12044, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12046, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12054, + 12055, + 0, + 12056, + 0, + 0, + 0, + 12060, + 12064, + 0, + 0, + 0, + 0, + 0, + 12065, + 12067, + 12068, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12074, + 0, + 0, + 0, + 12075, + 12076, + 0, + 0, + 0, + 12079, + 0, + 12081, + 12086, + 12087, + 0, + 0, + 12088, + 0, + 0, + 0, + 0, + 12089, + 0, + 12092, + 0, + 0, + 0, + 0, + 12097, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12098, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12102, + 12103, + 12104, + 12111, + 0, + 0, + 12114, + 12116, + 0, + 0, + 0, + 12118, + 0, + 0, + 0, + 12119, + 12120, + 12128, + 0, + 0, + 0, + 0, + 12130, + 0, + 0, + 0, + 0, + 0, + 0, + 12131, + 0, + 0, + 0, + 12132, + 12134, + 0, + 0, + 0, + 0, + 12137, + 0, + 12139, + 0, + 12141, + 0, + 0, + 12142, + 0, + 0, + 0, + 12144, + 0, + 0, + 0, + 0, + 0, + 12145, + 0, + 12148, + 0, + 12153, + 0, + 0, + 0, + 0, + 12154, + 12171, + 12173, + 0, + 0, + 0, + 12175, + 0, + 0, + 0, + 0, + 12178, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12183, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12184, + 0, + 0, + 0, + 12186, + 0, + 0, + 0, + 0, + 0, + 12187, + 12188, + 0, + 0, + 12189, + 0, + 12196, + 0, + 12197, + 0, + 0, + 12198, + 0, + 12201, + 0, + 0, + 0, + 0, + 12203, + 0, + 12209, + 0, + 0, + 0, + 0, + 12210, + 12211, + 12212, + 12213, + 0, + 12217, + 12218, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12222, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12223, + 0, + 0, + 12229, + 0, + 0, + 0, + 0, + 12233, + 0, + 0, + 0, + 0, + 12234, + 0, + 0, + 12236, + 12242, + 0, + 0, + 0, + 12243, + 0, + 0, + 0, + 12244, + 12253, + 0, + 12254, + 12256, + 0, + 12257, + 0, + 0, + 12275, + 0, + 0, + 0, + 0, + 0, + 12277, + 0, + 0, + 0, + 0, + 0, + 12278, + 0, + 12289, + 0, + 0, + 12290, + 0, + 12292, + 12293, + 0, + 0, + 12294, + 0, + 12295, + 0, + 0, + 12296, + 0, + 12297, + 0, + 12298, + 0, + 0, + 0, + 0, + 12301, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12309, + 0, + 12338, + 12340, + 0, + 0, + 0, + 0, + 12341, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12342, + 12343, + 0, + 12344, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12345, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12346, + 0, + 0, + 0, + 0, + 12348, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12350, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12351, + 0, + 12355, + 12356, + 12357, + 0, + 0, + 12367, + 12370, + 12371, + 0, + 0, + 0, + 0, + 0, + 12372, + 12376, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12379, + 0, + 12382, + 0, + 12383, + 0, + 0, + 12384, + 0, + 0, + 0, + 0, + 12393, + 0, + 0, + 12394, + 0, + 0, + 0, + 0, + 12398, + 12403, + 0, + 0, + 12404, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12410, + 0, + 0, + 0, + 12411, + 0, + 0, + 0, + 12412, + 0, + 0, + 0, + 0, + 12420, + 0, + 12421, + 0, + 0, + 0, + 0, + 0, + 12423, + 0, + 12425, + 12429, + 0, + 0, + 0, + 12431, + 12432, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12434, + 0, + 0, + 0, + 0, + 0, + 12435, + 12436, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12437, + 0, + 0, + 0, + 0, + 0, + 12438, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12445, + 0, + 0, + 0, + 12450, + 12451, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12452, + 12475, + 0, + 0, + 12493, + 12494, + 0, + 0, + 0, + 12495, + 0, + 0, + 0, + 0, + 12496, + 12502, + 12509, + 0, + 0, + 0, + 0, + 12510, + 0, + 12512, + 12513, + 0, + 0, + 0, + 0, + 12514, + 0, + 0, + 0, + 12515, + 0, + 12520, + 0, + 0, + 0, + 12524, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12527, + 0, + 0, + 0, + 12528, + 0, + 0, + 0, + 12529, + 0, + 0, + 0, + 0, + 0, + 12530, + 0, + 12535, + 0, + 0, + 12536, + 0, + 12538, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12540, + 0, + 12548, + 0, + 0, + 0, + 0, + 0, + 12550, + 0, + 0, + 0, + 12551, + 12552, + 0, + 0, + 0, + 12554, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12555, + 0, + 0, + 12562, + 0, + 12565, + 0, + 12566, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12569, + 0, + 0, + 0, + 12571, + 12574, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12577, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12578, + 12579, + 12603, + 0, + 12608, + 0, + 0, + 12611, + 0, + 12612, + 0, + 12615, + 0, + 12625, + 0, + 0, + 0, + 0, + 12627, + 12646, + 0, + 12648, + 0, + 0, + 12657, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12670, + 0, + 0, + 12671, + 0, + 12673, + 12677, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12679, + 0, + 12681, + 0, + 12682, + 12693, + 0, + 12694, + 0, + 12697, + 0, + 12701, + 0, + 0, + 0, + 12703, + 12704, + 0, + 0, + 0, + 0, + 12707, + 12737, + 0, + 0, + 12739, + 0, + 0, + 12740, + 0, + 0, + 12742, + 12743, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12745, + 0, + 12746, + 12747, + 0, + 12748, + 0, + 0, + 12759, + 12767, + 0, + 0, + 0, + 0, + 12773, + 0, + 12774, + 12778, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12779, + 0, + 0, + 0, + 0, + 0, + 12780, + 12793, + 0, + 12824, + 0, + 12825, + 0, + 12836, + 0, + 0, + 0, + 0, + 12839, + 0, + 12842, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12843, + 12845, + 0, + 12846, + 0, + 0, + 0, + 0, + 12847, + 0, + 0, + 12850, + 12852, + 12853, + 0, + 0, + 0, + 12854, + 0, + 0, + 0, + 12855, + 0, + 12856, + 0, + 12858, + 0, + 0, + 12859, + 0, + 12862, + 0, + 12863, + 0, + 0, + 12866, + 0, + 12869, + 12872, + 12873, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12875, + 0, + 12877, + 0, + 0, + 12878, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12884, + 12885, + 12888, + 0, + 12889, + 0, + 0, + 0, + 0, + 12893, + 0, + 0, + 0, + 12895, + 12896, + 12898, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12902, + 0, + 12909, + 12910, + 0, + 12926, + 0, + 12928, + 0, + 0, + 0, + 12929, + 0, + 12930, + 0, + 0, + 0, + 0, + 12931, + 0, + 12932, + 12933, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12934, + 0, + 12942, + 0, + 0, + 0, + 0, + 12944, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12946, + 0, + 0, + 12948, + 0, + 0, + 12949, + 0, + 0, + 0, + 0, + 12950, + 0, + 0, + 0, + 0, + 12951, + 0, + 12952, + 0, + 12953, + 0, + 0, + 0, + 12954, + 12958, + 12959, + 0, + 0, + 0, + 0, + 0, + 12960, + 12964, + 0, + 0, + 0, + 0, + 0, + 12966, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12970, + 0, + 12971, + 0, + 0, + 0, + 0, + 0, + 0, + 12972, + 0, + 0, + 12982, + 0, + 0, + 0, + 12984, + 12985, + 0, + 12986, + 12996, + 12997, + 13001, + 13002, + 0, + 0, + 0, + 0, + 13004, + 0, + 0, + 13005, + 0, + 0, + 13007, + 13009, + 0, + 13017, + 0, + 0, + 0, + 13020, + 0, + 13021, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13022, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13024, + 13027, + 0, + 0, + 0, + 0, + 0, + 13028, + 0, + 0, + 13029, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13032, + 0, + 13037, + 0, + 0, + 0, + 0, + 0, + 0, + 13040, + 0, + 0, + 13041, + 0, + 0, + 0, + 13043, + 13044, + 13046, + 0, + 0, + 0, + 0, + 13047, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13049, + 13054, + 0, + 13056, + 0, + 0, + 13060, + 13061, + 0, + 0, + 0, + 0, + 0, + 13067, + 0, + 0, + 13068, + 0, + 13071, + 0, + 0, + 0, + 0, + 0, + 13077, + 13078, + 0, + 0, + 0, + 0, + 0, + 13079, + 13080, + 13081, + 0, + 13082, + 0, + 0, + 0, + 13085, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13086, + 0, + 13087, + 13088, + 0, + 0, + 0, + 0, + 0, + 13094, + 0, + 13099, + 0, + 13100, + 0, + 0, + 0, + 13101, + 0, + 13125, + 13126, + 13128, + 13129, + 0, + 0, + 13130, + 0, + 13131, + 0, + 0, + 0, + 0, + 0, + 0, + 13134, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13150, + 0, + 13168, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13169, + 0, + 0, + 13170, + 0, + 0, + 0, + 0, + 13174, + 0, + 0, + 0, + 13176, + 0, + 0, + 0, + 0, + 0, + 13177, + 0, + 13178, + 13183, + 13187, + 0, + 0, + 0, + 13189, + 0, + 0, + 13190, + 0, + 0, + 13191, + 0, + 0, + 13206, + 0, + 0, + 0, + 13207, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13212, + 0, + 0, + 13219, + 13232, + 0, + 0, + 0, + 13241, + 0, + 13249, + 13253, + 0, + 0, + 0, + 0, + 0, + 13255, + 13259, + 0, + 13260, + 13261, + 0, + 13262, + 0, + 13272, + 0, + 0, + 0, + 0, + 13276, + 0, + 0, + 0, + 0, + 13277, + 13299, + 0, + 0, + 13301, + 13302, + 0, + 0, + 13303, + 0, + 0, + 13305, + 0, + 13310, + 0, + 0, + 0, + 13311, + 0, + 0, + 0, + 0, + 13325, + 0, + 13328, + 0, + 0, + 0, + 13329, + 0, + 0, + 0, + 0, + 0, + 0, + 13330, + 0, + 0, + 13331, + 0, + 13335, + 0, + 0, + 13342, + 0, + 0, + 0, + 0, + 0, + 13343, + 0, + 13354, + 0, + 13362, + 0, + 13366, + 13367, + 13369, + 0, + 0, + 13371, + 13372, + 0, + 13373, + 13374, + 0, + 13376, + 0, + 13380, + 13381, + 13386, + 0, + 13387, + 13388, + 0, + 13389, + 13391, + 13395, + 0, + 0, + 0, + 0, + 0, + 13401, + 13409, + 0, + 13410, + 0, + 0, + 0, + 0, + 13420, + 0, + 0, + 0, + 0, + 0, + 13422, + 0, + 0, + 0, + 0, + 13423, + 0, + 0, + 0, + 0, + 13425, + 0, + 0, + 0, + 0, + 0, + 13427, + 0, + 0, + 0, + 13428, + 0, + 0, + 13430, + 13438, + 0, + 13439, + 0, + 13445, + 0, + 13448, + 13449, + 0, + 0, + 0, + 0, + 0, + 0, + 13451, + 0, + 13457, + 0, + 0, + 0, + 0, + 13458, + 13459, + 0, + 13460, + 0, + 0, + 0, + 0, + 13464, + 13465, + 13466, + 13470, + 0, + 13471, + 13472, + 13474, + 13475, + 0, + 13476, + 0, + 0, + 13478, + 13479, + 0, + 13481, + 0, + 0, + 0, + 0, + 13487, + 0, + 13490, + 0, + 13493, + 0, + 0, + 13494, + 0, + 0, + 13495, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13496, + 13497, + 0, + 13500, + 0, + 0, + 13516, + 13522, + 0, + 0, + 13525, + 13528, + 0, + 0, + 0, + 13530, + 13535, + 0, + 13537, + 13539, + 0, + 13540, + 0, + 13543, + 0, + 13544, + 0, + 0, + 0, + 0, + 0, + 0, + 13545, + 0, + 0, + 0, + 0, + 0, + 0, + 13547, + 0, + 0, + 0, + 13549, + 13555, + 0, + 0, + 0, + 13556, + 13557, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13558, + 0, + 13563, + 0, + 0, + 0, + 0, + 13564, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13566, + 0, + 0, + 0, + 0, + 0, + 0, + 13569, + 0, + 0, + 13571, + 0, + 0, + 0, + 0, + 13573, + 0, + 0, + 0, + 0, + 0, + 0, + 13578, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13581, + 0, + 13586, + 0, + 13595, + 0, + 13600, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13601, + 13603, + 0, + 13604, + 13605, + 13606, + 13607, + 0, + 0, + 13617, + 13618, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13623, + 0, + 13625, + 13627, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13629, + 0, + 0, + 0, + 13634, + 0, + 0, + 0, + 13638, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13654, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13656, + 0, + 13659, + 0, + 0, + 13660, + 0, + 0, + 13662, + 0, + 0, + 0, + 13663, + 0, + 13664, + 0, + 0, + 0, + 0, + 0, + 13668, + 0, + 13669, + 13671, + 0, + 0, + 13672, + 0, + 0, + 0, + 0, + 0, + 0, + 13675, + 13685, + 0, + 13686, + 0, + 0, + 0, + 13687, + 0, + 0, + 0, + 13692, + 13694, + 13697, + 0, + 0, + 0, + 13702, + 0, + 0, + 0, + 0, + 0, + 13705, + 0, + 0, + 0, + 0, + 13707, + 0, + 0, + 0, + 13714, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13715, + 0, + 13716, + 13717, + 0, + 0, + 13719, + 13724, + 13730, + 13731, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13732, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13734, + 0, + 13736, + 0, + 0, + 13737, + 13738, + 13747, + 0, + 13751, + 0, + 0, + 13752, + 0, + 0, + 0, + 13753, + 0, + 13757, + 0, + 0, + 13762, + 13763, + 0, + 13764, + 13765, + 0, + 13766, + 0, + 0, + 13767, + 0, + 0, + 0, + 13768, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13769, + 0, + 0, + 13772, + 0, + 13775, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13776, + 13778, + 13787, + 0, + 0, + 0, + 13797, + 0, + 13798, + 0, + 13801, + 0, + 13804, + 13806, + 0, + 0, + 0, + 0, + 13816, + 13817, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13834, + 0, + 13836, + 0, + 0, + 13838, + 0, + 0, + 13839, + 0, + 13840, + 0, + 0, + 0, + 0, + 13842, + 0, + 0, + 0, + 0, + 0, + 0, + 13843, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13845, + 0, + 0, + 0, + 0, + 0, + 13858, + 0, + 0, + 13860, + 0, + 0, + 13861, + 0, + 0, + 13862, + 13863, + 0, + 13868, + 0, + 13869, + 13870, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13872, + 0, + 0, + 0, + 0, + 13873, + 13878, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13886, + 0, + 13888, + 13889, + 13890, + 0, + 0, + 13891, + 13894, + 0, + 13897, + 13899, + 13900, + 13904, + 0, + 0, + 13906, + 0, + 0, + 0, + 13909, + 0, + 0, + 0, + 13910, + 0, + 0, + 0, + 13911, + 0, + 0, + 0, + 0, + 0, + 13912, + 13917, + 0, + 0, + 0, + 0, + 13918, + 0, + 13919, + 0, + 0, + 13920, + 0, + 0, + 0, + 13921, + 0, + 0, + 13922, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13924, + 0, + 13927, + 0, + 0, + 0, + 0, + 0, + 13932, + 0, + 13933, + 0, + 13934, + 0, + 0, + 13935, + 0, + 13944, + 0, + 0, + 0, + 13954, + 0, + 0, + 13955, + 0, + 0, + 0, + 0, + 13956, + 0, + 13957, + 0, + 13967, + 13969, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 13970, + 13990, + 0, + 13991, + 13994, + 0, + 13995, + 0, + 0, + 0, + 0, + 13996, + 0, + 0, + 13999, + 0, + 0, + 0, + 14018, + 0, + 14019, + 0, + 14021, + 0, + 0, + 0, + 0, + 0, + 0, + 14041, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14043, + 0, + 0, + 0, + 0, + 14046, + 0, + 0, + 0, + 14048, + 14049, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14051, + 0, + 0, + 14052, + 14056, + 0, + 14063, + 0, + 14064, + 14066, + 0, + 0, + 14067, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14068, + 0, + 0, + 0, + 14072, + 0, + 14074, + 14075, + 0, + 14076, + 14079, + 14085, + 14086, + 14087, + 14093, + 0, + 0, + 0, + 0, + 14095, + 0, + 0, + 0, + 0, + 0, + 0, + 14096, + 14097, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14098, + 0, + 14102, + 0, + 0, + 0, + 0, + 0, + 14103, + 0, + 0, + 0, + 14104, + 0, + 0, + 14105, + 0, + 0, + 0, + 14107, + 14108, + 0, + 0, + 14109, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14117, + 0, + 0, + 0, + 0, + 14118, + 0, + 0, + 0, + 0, + 14119, + 0, + 0, + 14120, + 0, + 0, + 14121, + 0, + 14122, + 14127, + 0, + 14128, + 14136, + 0, + 0, + 14138, + 0, + 14140, + 0, + 0, + 0, + 14141, + 14142, + 0, + 0, + 0, + 0, + 14146, + 0, + 0, + 14149, + 0, + 14151, + 0, + 0, + 0, + 14152, + 0, + 0, + 14153, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14154, + 0, + 14156, + 14157, + 0, + 0, + 14159, + 0, + 14161, + 0, + 0, + 0, + 0, + 14162, + 0, + 0, + 0, + 0, + 0, + 0, + 14163, + 0, + 0, + 14173, + 0, + 0, + 0, + 0, + 0, + 0, + 14174, + 0, + 0, + 14176, + 0, + 0, + 14178, + 0, + 0, + 14179, + 14181, + 0, + 0, + 14182, + 14185, + 14187, + 0, + 14190, + 0, + 0, + 14197, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14198, + 0, + 0, + 0, + 0, + 0, + 0, + 14199, + 14200, + 0, + 0, + 0, + 14204, + 0, + 0, + 14208, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14231, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14234, + 0, + 0, + 14235, + 0, + 0, + 0, + 14240, + 14241, + 0, + 0, + 0, + 14246, + 0, + 0, + 0, + 14247, + 0, + 14250, + 0, + 0, + 14251, + 0, + 0, + 14254, + 0, + 0, + 14256, + 0, + 0, + 0, + 14260, + 0, + 14261, + 0, + 0, + 0, + 0, + 14262, + 14267, + 14269, + 0, + 0, + 14277, + 0, + 0, + 14278, + 0, + 14279, + 14282, + 0, + 0, + 0, + 14283, + 0, + 0, + 0, + 14284, + 14285, + 0, + 0, + 0, + 0, + 14286, + 0, + 0, + 0, + 14288, + 0, + 0, + 0, + 14289, + 0, + 14290, + 0, + 14293, + 14301, + 14302, + 14304, + 14305, + 0, + 14307, + 0, + 14308, + 14309, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14311, + 14312, + 0, + 0, + 14317, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14318, + 0, + 0, + 0, + 0, + 14320, + 0, + 0, + 0, + 0, + 14321, + 14322, + 0, + 0, + 0, + 0, + 0, + 14326, + 14329, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14330, + 14331, + 0, + 0, + 0, + 0, + 14332, + 0, + 0, + 0, + 14333, + 0, + 0, + 14337, + 14340, + 0, + 14341, + 0, + 0, + 14342, + 0, + 14345, + 14346, + 0, + 0, + 14347, + 0, + 14362, + 0, + 0, + 0, + 0, + 0, + 14364, + 14365, + 14371, + 0, + 14373, + 0, + 0, + 14374, + 0, + 14379, + 0, + 14400, + 0, + 0, + 0, + 0, + 0, + 14401, + 0, + 0, + 14405, + 0, + 14406, + 0, + 14408, + 14409, + 0, + 0, + 0, + 14417, + 0, + 0, + 14424, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14430, + 0, + 0, + 0, + 14431, + 0, + 0, + 14435, + 0, + 14440, + 0, + 0, + 0, + 0, + 0, + 0, + 14442, + 0, + 0, + 14443, + 0, + 0, + 0, + 0, + 0, + 14446, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14454, + 0, + 14457, + 0, + 14460, + 0, + 0, + 14466, + 0, + 0, + 0, + 0, + 0, + 14467, + 0, + 0, + 0, + 0, + 0, + 0, + 14469, + 0, + 14477, + 0, + 0, + 0, + 0, + 0, + 0, + 14478, + 14482, + 0, + 0, + 0, + 14483, + 0, + 0, + 0, + 14485, + 14486, + 0, + 0, + 0, + 14487, + 14488, + 14489, + 14492, + 14493, + 14494, + 14495, + 14496, + 14497, + 0, + 14499, + 0, + 14501, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14502, + 0, + 14507, + 14512, + 14513, + 14514, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14515, + 14526, + 14530, + 0, + 14537, + 0, + 14544, + 0, + 14547, + 0, + 0, + 14548, + 14550, + 14551, + 0, + 0, + 14552, + 0, + 0, + 0, + 14553, + 0, + 14554, + 0, + 0, + 0, + 0, + 14556, + 14564, + 0, + 0, + 14565, + 14566, + 0, + 0, + 0, + 0, + 0, + 0, + 14568, + 0, + 0, + 14569, + 0, + 0, + 0, + 14571, + 14576, + 0, + 0, + 14577, + 14578, + 14579, + 0, + 0, + 14580, + 0, + 0, + 0, + 0, + 14582, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14583, + 0, + 0, + 0, + 0, + 0, + 14587, + 0, + 14588, + 0, + 0, + 14600, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14601, + 0, + 0, + 14604, + 14605, + 14611, + 0, + 14613, + 0, + 0, + 0, + 0, + 14615, + 0, + 0, + 0, + 0, + 0, + 0, + 14627, + 0, + 14628, + 0, + 0, + 0, + 0, + 14631, + 0, + 14633, + 14634, + 0, + 0, + 0, + 0, + 14635, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14636, + 0, + 0, + 14639, + 14642, + 0, + 0, + 0, + 0, + 14644, + 0, + 0, + 0, + 0, + 14645, + 14646, + 0, + 14653, + 0, + 0, + 14654, + 0, + 14658, + 0, + 14661, + 0, + 0, + 0, + 14665, + 0, + 0, + 0, + 14668, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14669, + 0, + 0, + 14670, + 0, + 0, + 0, + 14680, + 0, + 0, + 14681, + 0, + 0, + 0, + 0, + 0, + 14682, + 14683, + 0, + 0, + 0, + 0, + 14686, + 0, + 0, + 0, + 0, + 14687, + 14697, + 0, + 0, + 0, + 0, + 14699, + 14705, + 14711, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14712, + 0, + 0, + 0, + 14713, + 0, + 0, + 0, + 0, + 14719, + 0, + 14720, + 14721, + 14726, + 0, + 0, + 0, + 14728, + 14729, + 0, + 0, + 0, + 0, + 14731, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14733, + 14736, + 14737, + 0, + 0, + 14740, + 14742, + 0, + 0, + 0, + 14744, + 14753, + 0, + 0, + 0, + 0, + 14755, + 14758, + 14760, + 0, + 0, + 0, + 0, + 0, + 14761, + 14762, + 14765, + 14771, + 0, + 14772, + 0, + 14773, + 14774, + 0, + 0, + 14775, + 0, + 0, + 14776, + 0, + 0, + 0, + 0, + 14777, + 0, + 14779, + 0, + 0, + 14782, + 0, + 0, + 14785, + 14786, + 14788, + 0, + 0, + 0, + 0, + 0, + 14795, + 0, + 0, + 0, + 0, + 0, + 0, + 14798, + 0, + 14803, + 14804, + 14806, + 0, + 0, + 0, + 14809, + 0, + 0, + 0, + 0, + 0, + 0, + 14810, + 0, + 0, + 0, + 0, + 14811, + 0, + 14812, + 0, + 0, + 0, + 0, + 0, + 14815, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14816, + 0, + 14818, + 0, + 0, + 0, + 0, + 0, + 0, + 14819, + 0, + 14820, + 0, + 14823, + 0, + 0, + 0, + 14824, + 0, + 0, + 14826, + 14827, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14830, + 0, + 0, + 0, + 0, + 0, + 14833, + 0, + 14845, + 0, + 0, + 0, + 0, + 0, + 14846, + 0, + 0, + 14847, + 14871, + 0, + 14873, + 0, + 14876, + 0, + 14877, + 14878, + 14880, + 0, + 0, + 0, + 0, + 0, + 14881, + 0, + 14882, + 14894, + 0, + 0, + 0, + 0, + 14895, + 0, + 14907, + 0, + 14908, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14911, + 0, + 0, + 0, + 0, + 14920, + 0, + 0, + 14931, + 0, + 14932, + 14934, + 14935, + 0, + 0, + 14936, + 0, + 14945, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 14947, + 0, + 0, + 14948, + 14949, + 14951, + 0, + 0, + 14952, + 0, + 0, + 0, + 14964, + 14973, + 0, + 0, + 14990, + 0, + 0, + 0, + 0, + 14995, + 0, + 0, + 14998, + 15001, + 0, + 0, + 15002, + 15020, + 0, + 0, + 0, + 0, + 0, + 0, + 15021, + 0, + 15022, + 0, + 0, + 0, + 0, + 15023, + 0, + 0, + 15025, + 15029, + 15033, + 0, + 0, + 0, + 15034, + 0, + 0, + 0, + 15035, + 0, + 0, + 0, + 0, + 0, + 15043, + 15044, + 0, + 0, + 0, + 15045, + 15046, + 15048, + 15050, + 0, + 15065, + 0, + 0, + 0, + 0, + 15066, + 0, + 0, + 15075, + 15082, + 15084, + 0, + 0, + 15085, + 15086, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15088, + 0, + 0, + 0, + 15089, + 0, + 0, + 0, + 0, + 15094, + 0, + 15096, + 0, + 15097, + 0, + 15100, + 0, + 0, + 15102, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15105, + 0, + 0, + 15106, + 0, + 15109, + 15113, + 0, + 0, + 0, + 15115, + 0, + 15118, + 0, + 0, + 0, + 0, + 0, + 0, + 15119, + 0, + 0, + 15120, + 0, + 0, + 0, + 0, + 0, + 15123, + 15129, + 0, + 0, + 0, + 15130, + 0, + 15131, + 0, + 0, + 15134, + 0, + 15135, + 0, + 0, + 0, + 15137, + 15138, + 0, + 0, + 0, + 0, + 0, + 0, + 15139, + 0, + 0, + 0, + 0, + 0, + 15140, + 0, + 0, + 15154, + 15162, + 0, + 15169, + 15170, + 0, + 15175, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15177, + 0, + 15178, + 15179, + 0, + 0, + 0, + 0, + 0, + 15183, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15185, + 15187, + 0, + 15194, + 15195, + 15196, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15204, + 0, + 0, + 0, + 0, + 15206, + 0, + 0, + 0, + 0, + 0, + 15207, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15213, + 0, + 15214, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15232, + 0, + 0, + 0, + 0, + 15234, + 0, + 15238, + 15240, + 0, + 15248, + 0, + 0, + 0, + 0, + 15250, + 15251, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15252, + 0, + 0, + 0, + 15255, + 15262, + 15266, + 0, + 0, + 0, + 15267, + 0, + 0, + 0, + 15277, + 15279, + 0, + 0, + 0, + 15280, + 15281, + 15282, + 0, + 0, + 0, + 0, + 0, + 15285, + 0, + 0, + 0, + 0, + 15289, + 0, + 0, + 15291, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15296, + 15297, + 0, + 0, + 15304, + 0, + 0, + 0, + 0, + 15306, + 0, + 0, + 0, + 0, + 0, + 0, + 15307, + 15308, + 0, + 15309, + 0, + 0, + 15311, + 0, + 0, + 15312, + 15313, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15314, + 15317, + 0, + 0, + 0, + 15318, + 15319, + 0, + 0, + 0, + 0, + 15320, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15321, + 0, + 0, + 0, + 0, + 0, + 15324, + 0, + 15325, + 15326, + 0, + 15330, + 0, + 0, + 0, + 0, + 15334, + 0, + 15335, + 0, + 15341, + 0, + 0, + 15342, + 0, + 0, + 15343, + 15344, + 0, + 0, + 0, + 0, + 15345, + 0, + 0, + 0, + 0, + 15347, + 0, + 0, + 15348, + 15349, + 15350, + 0, + 15356, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15357, + 0, + 15358, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15359, + 15360, + 15364, + 0, + 15380, + 0, + 0, + 0, + 0, + 0, + 15392, + 0, + 0, + 15393, + 0, + 15395, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15396, + 0, + 0, + 15397, + 15398, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15399, + 0, + 15400, + 0, + 0, + 0, + 15402, + 0, + 15405, + 15410, + 0, + 0, + 0, + 0, + 15411, + 0, + 0, + 0, + 15412, + 0, + 15416, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15428, + 0, + 15435, + 0, + 0, + 15438, + 0, + 0, + 0, + 0, + 15439, + 0, + 0, + 0, + 15440, + 0, + 0, + 0, + 15441, + 15449, + 15451, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15452, + 0, + 0, + 15455, + 0, + 0, + 0, + 15456, + 0, + 0, + 15458, + 0, + 15460, + 15461, + 0, + 0, + 0, + 0, + 0, + 15462, + 15464, + 0, + 15465, + 0, + 0, + 15466, + 0, + 0, + 15467, + 0, + 0, + 0, + 0, + 0, + 15468, + 0, + 0, + 0, + 0, + 15481, + 0, + 0, + 15484, + 0, + 15485, + 15486, + 0, + 0, + 0, + 15487, + 0, + 0, + 0, + 0, + 0, + 15488, + 0, + 15492, + 15498, + 0, + 0, + 0, + 15499, + 0, + 0, + 0, + 15500, + 0, + 15501, + 0, + 0, + 15512, + 0, + 15522, + 0, + 0, + 0, + 15524, + 0, + 15525, + 15526, + 0, + 0, + 15527, + 0, + 0, + 15545, + 15546, + 0, + 15548, + 15552, + 0, + 15553, + 0, + 0, + 0, + 15554, + 0, + 15555, + 0, + 15557, + 15565, + 15573, + 15577, + 15578, + 0, + 15582, + 0, + 15583, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15586, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15588, + 0, + 0, + 0, + 0, + 0, + 15589, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15593, + 15594, + 0, + 0, + 0, + 0, + 15595, + 0, + 0, + 0, + 0, + 0, + 0, + 15596, + 0, + 0, + 0, + 15597, + 0, + 0, + 0, + 0, + 15600, + 0, + 0, + 15601, + 0, + 0, + 0, + 0, + 15602, + 15603, + 0, + 0, + 0, + 0, + 0, + 0, + 15604, + 0, + 15609, + 0, + 0, + 15612, + 0, + 0, + 15613, + 0, + 0, + 15615, + 15617, + 15618, + 0, + 0, + 15620, + 0, + 15636, + 15637, + 0, + 0, + 15649, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15650, + 0, + 0, + 15651, + 0, + 0, + 0, + 15656, + 0, + 15658, + 0, + 0, + 0, + 15664, + 0, + 0, + 15665, + 0, + 0, + 15668, + 0, + 0, + 0, + 0, + 0, + 15669, + 0, + 0, + 15674, + 0, + 0, + 15675, + 0, + 0, + 0, + 0, + 15676, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15677, + 0, + 0, + 0, + 0, + 15678, + 0, + 0, + 0, + 0, + 0, + 15679, + 0, + 0, + 15681, + 0, + 15686, + 0, + 0, + 0, + 0, + 15687, + 0, + 15688, + 0, + 0, + 15690, + 0, + 0, + 0, + 15697, + 0, + 15699, + 15700, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15701, + 0, + 15702, + 15703, + 0, + 15704, + 0, + 15705, + 0, + 15707, + 0, + 15709, + 0, + 15712, + 15716, + 0, + 15717, + 0, + 15718, + 15720, + 0, + 0, + 0, + 0, + 0, + 15724, + 0, + 0, + 0, + 15725, + 0, + 15726, + 0, + 0, + 0, + 15740, + 0, + 15745, + 15746, + 0, + 0, + 15747, + 0, + 15748, + 0, + 0, + 0, + 0, + 0, + 15749, + 0, + 0, + 0, + 15752, + 0, + 15753, + 0, + 0, + 0, + 0, + 0, + 0, + 15759, + 0, + 0, + 0, + 15765, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15767, + 0, + 0, + 0, + 15771, + 0, + 0, + 15784, + 0, + 0, + 0, + 0, + 15785, + 15790, + 15791, + 0, + 0, + 15792, + 0, + 0, + 0, + 15807, + 0, + 15811, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15818, + 0, + 0, + 0, + 15819, + 0, + 0, + 0, + 0, + 15821, + 0, + 0, + 0, + 0, + 0, + 15822, + 15824, + 0, + 0, + 15827, + 0, + 0, + 15829, + 15831, + 0, + 15832, + 0, + 0, + 15833, + 0, + 15835, + 15838, + 15839, + 15843, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15844, + 0, + 0, + 0, + 0, + 15845, + 15851, + 15856, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15858, + 15860, + 0, + 15861, + 0, + 0, + 0, + 15864, + 0, + 0, + 0, + 0, + 15865, + 0, + 0, + 0, + 0, + 0, + 0, + 15866, + 0, + 15872, + 0, + 0, + 15876, + 0, + 0, + 0, + 0, + 15877, + 15878, + 15883, + 15885, + 0, + 0, + 15888, + 0, + 0, + 0, + 0, + 0, + 15889, + 15890, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15892, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15893, + 0, + 0, + 15894, + 0, + 0, + 0, + 15895, + 0, + 15896, + 15897, + 0, + 15898, + 15901, + 15902, + 0, + 15911, + 15915, + 0, + 15916, + 0, + 15924, + 15935, + 0, + 15937, + 0, + 0, + 0, + 0, + 0, + 15950, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15958, + 0, + 0, + 0, + 15961, + 0, + 0, + 15966, + 0, + 15967, + 0, + 0, + 15977, + 0, + 0, + 15978, + 0, + 0, + 15981, + 15982, + 15983, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 15986, + 0, + 0, + 0, + 15990, + 0, + 15991, + 15995, + 15998, + 0, + 15999, + 0, + 16000, + 0, + 0, + 0, + 0, + 16008, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16009, + 16011, + 0, + 16013, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16014, + 0, + 0, + 16015, + 16023, + 16024, + 16025, + 0, + 0, + 16026, + 0, + 16030, + 0, + 16032, + 0, + 16033, + 0, + 0, + 0, + 0, + 0, + 0, + 16035, + 16036, + 16037, + 0, + 0, + 0, + 0, + 0, + 16039, + 0, + 0, + 0, + 0, + 16041, + 0, + 0, + 0, + 0, + 0, + 16043, + 16044, + 0, + 0, + 16047, + 0, + 0, + 0, + 16048, + 0, + 0, + 16049, + 16050, + 16052, + 0, + 0, + 0, + 0, + 0, + 16055, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16056, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16058, + 16060, + 16061, + 0, + 0, + 16063, + 0, + 0, + 16064, + 0, + 0, + 0, + 16067, + 16068, + 0, + 0, + 16069, + 16078, + 0, + 0, + 0, + 16079, + 0, + 0, + 0, + 16080, + 0, + 16081, + 0, + 0, + 0, + 16088, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16089, + 16093, + 0, + 16097, + 0, + 16103, + 0, + 16104, + 16105, + 0, + 0, + 16256, + 0, + 0, + 16259, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16260, + 16261, + 0, + 0, + 16262, + 0, + 0, + 16263, + 0, + 16268, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16269, + 0, + 0, + 16270, + 16273, + 0, + 16274, + 0, + 0, + 0, + 0, + 16275, + 16276, + 16277, + 16280, + 0, + 0, + 0, + 16281, + 16284, + 0, + 0, + 0, + 16286, + 0, + 16289, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16290, + 0, + 0, + 0, + 0, + 16291, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16292, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16293, + 16295, + 16297, + 0, + 16302, + 0, + 16304, + 0, + 16305, + 0, + 16306, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16307, + 16308, + 16312, + 0, + 0, + 0, + 0, + 0, + 0, + 16313, + 16315, + 0, + 16318, + 0, + 0, + 0, + 16321, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16326, + 16333, + 16336, + 0, + 0, + 0, + 0, + 16337, + 16340, + 0, + 0, + 0, + 0, + 0, + 16345, + 0, + 0, + 16346, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16347, + 0, + 0, + 16348, + 0, + 0, + 0, + 0, + 16349, + 0, + 0, + 0, + 16350, + 0, + 16357, + 0, + 0, + 0, + 0, + 16359, + 16360, + 0, + 0, + 0, + 0, + 16362, + 16363, + 16364, + 16365, + 0, + 0, + 16366, + 0, + 0, + 0, + 0, + 16367, + 16368, + 0, + 16369, + 16374, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16376, + 0, + 0, + 0, + 0, + 16378, + 16379, + 0, + 16380, + 0, + 0, + 0, + 16381, + 16383, + 0, + 0, + 0, + 0, + 0, + 16390, + 0, + 0, + 0, + 16399, + 0, + 16402, + 16404, + 16406, + 16407, + 0, + 0, + 0, + 16409, + 16411, + 0, + 0, + 0, + 0, + 16412, + 0, + 16413, + 16415, + 16423, + 0, + 0, + 0, + 0, + 0, + 16424, + 0, + 0, + 0, + 16428, + 16434, + 16435, + 16449, + 0, + 16450, + 16451, + 0, + 0, + 0, + 16453, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16454, + 0, + 0, + 16456, + 16458, + 0, + 0, + 16459, + 0, + 0, + 16460, + 0, + 0, + 0, + 0, + 16462, + 0, + 16463, + 0, + 0, + 16466, + 0, + 0, + 0, + 0, + 0, + 16479, + 0, + 0, + 16480, + 0, + 16481, + 16484, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16485, + 0, + 0, + 0, + 0, + 0, + 0, + 16489, + 0, + 0, + 0, + 0, + 0, + 16491, + 0, + 0, + 16498, + 0, + 0, + 16503, + 0, + 16505, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16506, + 0, + 0, + 0, + 16508, + 16509, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16511, + 16513, + 0, + 0, + 0, + 16516, + 0, + 16517, + 0, + 16519, + 0, + 16529, + 0, + 0, + 16531, + 0, + 0, + 0, + 0, + 0, + 0, + 16534, + 0, + 0, + 16541, + 16542, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16543, + 16547, + 16548, + 0, + 0, + 0, + 16551, + 0, + 16552, + 0, + 0, + 0, + 16553, + 0, + 0, + 16558, + 0, + 0, + 16562, + 16565, + 0, + 0, + 0, + 16570, + 0, + 0, + 0, + 16573, + 16585, + 0, + 0, + 0, + 16586, + 16587, + 16595, + 0, + 16596, + 0, + 16598, + 0, + 0, + 0, + 16600, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16601, + 0, + 0, + 0, + 0, + 16603, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16604, + 16612, + 0, + 0, + 0, + 0, + 16613, + 0, + 16618, + 0, + 0, + 0, + 16640, + 0, + 0, + 16641, + 0, + 0, + 0, + 0, + 0, + 0, + 16645, + 0, + 0, + 0, + 0, + 16646, + 0, + 0, + 0, + 0, + 0, + 0, + 16651, + 0, + 0, + 0, + 0, + 16653, + 16654, + 0, + 0, + 0, + 16655, + 0, + 0, + 16656, + 16667, + 0, + 0, + 0, + 0, + 16671, + 0, + 16672, + 0, + 0, + 0, + 16673, + 0, + 0, + 0, + 0, + 0, + 16676, + 0, + 16686, + 0, + 0, + 0, + 0, + 16689, + 0, + 16690, + 0, + 16692, + 0, + 16693, + 0, + 16694, + 0, + 16696, + 0, + 0, + 0, + 16705, + 0, + 0, + 0, + 0, + 0, + 0, + 16707, + 0, + 0, + 0, + 16709, + 0, + 0, + 0, + 0, + 16711, + 0, + 16712, + 16713, + 0, + 0, + 0, + 16715, + 0, + 0, + 0, + 0, + 16716, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16718, + 16724, + 0, + 0, + 16726, + 16727, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16728, + 0, + 16729, + 0, + 0, + 16730, + 0, + 0, + 0, + 0, + 0, + 16731, + 0, + 0, + 0, + 16732, + 0, + 0, + 0, + 0, + 16734, + 16738, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16743, + 0, + 0, + 16745, + 0, + 0, + 0, + 0, + 0, + 16749, + 0, + 16752, + 0, + 0, + 0, + 0, + 16756, + 0, + 0, + 16758, + 0, + 16759, + 0, + 0, + 0, + 0, + 0, + 16760, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16762, + 0, + 16769, + 0, + 16770, + 0, + 16772, + 0, + 0, + 0, + 16777, + 16780, + 0, + 0, + 0, + 0, + 0, + 0, + 16781, + 0, + 0, + 16782, + 0, + 16784, + 0, + 0, + 16785, + 16787, + 16792, + 0, + 0, + 16794, + 0, + 0, + 0, + 16798, + 0, + 0, + 16809, + 0, + 0, + 16814, + 16816, + 16817, + 0, + 16819, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16820, + 0, + 0, + 16836, + 16839, + 0, + 0, + 16841, + 16851, + 16857, + 0, + 0, + 16858, + 16859, + 0, + 0, + 16860, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16862, + 0, + 16863, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16864, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16876, + 0, + 16881, + 16882, + 0, + 16885, + 16886, + 0, + 16887, + 0, + 0, + 0, + 16889, + 16891, + 0, + 0, + 0, + 0, + 0, + 16894, + 16895, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 16897, + 0, + 16898, + 0, + 0, + 0, + 0, + 0, + 16913, + 0, + 0, + 16924, + 16925, + 16926, + 0, + 0, + 16927, + 0, + 0, + 0, + 16937, + 16938, + 0, + 0, + 0, + 16940, + 16941, + 0, + 0, + 0, + 16942, + 16945, + 0, + 16946, + 16949, + 16950, + 0, + 0, + 0, + 16952, + 16955, + 0, + 0, + 0, + 16965, + 0, + 16969, + 0, + 0, + 16975, + 0, + 0, + 16976, + 0, + 0, + 0, + 0, + 16978, + 0, + 0, + 16981, + 0, + 16983, + 16989, + 0, + 0, + 0, + 0, + 16990, + 0, + 0, + 16991, + 0, + 0, + 0, + 16993, + 0, + 16994, + 16996, + 17000, + 0, + 0, + 0, + 0, + 0, + 17002, + 17004, + 0, + 17006, + 0, + 0, + 17007, + 0, + 0, + 0, + 0, + 17008, + 17013, + 17014, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17021, + 0, + 17031, + 0, + 0, + 0, + 0, + 0, + 17033, + 17036, + 0, + 17038, + 0, + 0, + 17039, + 0, + 17045, + 0, + 0, + 17046, + 17047, + 0, + 0, + 0, + 0, + 17048, + 0, + 17049, + 17050, + 0, + 17051, + 17053, + 0, + 17054, + 0, + 17055, + 0, + 0, + 0, + 0, + 0, + 17063, + 0, + 0, + 17064, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17065, + 0, + 0, + 17068, + 0, + 0, + 0, + 0, + 0, + 17072, + 0, + 0, + 0, + 0, + 0, + 0, + 17073, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17074, + 0, + 17080, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17081, + 17083, + 17084, + 0, + 0, + 0, + 17085, + 0, + 0, + 0, + 0, + 17092, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17093, + 0, + 17095, + 17102, + 0, + 0, + 0, + 0, + 0, + 0, + 17103, + 0, + 0, + 17105, + 0, + 17107, + 0, + 0, + 0, + 0, + 17114, + 0, + 0, + 0, + 0, + 0, + 17115, + 17125, + 17127, + 0, + 0, + 17128, + 0, + 0, + 0, + 17129, + 17130, + 0, + 17131, + 0, + 0, + 0, + 0, + 0, + 17132, + 17135, + 17145, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17146, + 0, + 17147, + 0, + 17148, + 0, + 0, + 0, + 0, + 0, + 0, + 17149, + 17150, + 0, + 17151, + 17153, + 0, + 17155, + 0, + 0, + 0, + 0, + 17163, + 17171, + 0, + 17174, + 0, + 0, + 0, + 0, + 17179, + 0, + 0, + 17182, + 17185, + 0, + 0, + 0, + 0, + 0, + 17186, + 0, + 0, + 17188, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17189, + 17191, + 0, + 17194, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17195, + 17196, + 17203, + 17204, + 0, + 0, + 17205, + 17217, + 0, + 0, + 0, + 0, + 0, + 17218, + 0, + 0, + 0, + 0, + 17219, + 0, + 17220, + 0, + 17221, + 0, + 0, + 17230, + 0, + 0, + 0, + 0, + 0, + 17236, + 0, + 17238, + 17239, + 0, + 0, + 0, + 17241, + 17244, + 0, + 0, + 17245, + 0, + 17248, + 0, + 0, + 17251, + 0, + 17252, + 0, + 0, + 17264, + 0, + 17266, + 0, + 0, + 0, + 17268, + 0, + 0, + 0, + 0, + 17271, + 17272, + 0, + 17273, + 0, + 17295, + 0, + 17302, + 0, + 17305, + 0, + 0, + 0, + 17306, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17308, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17309, + 0, + 17310, + 17313, + 0, + 0, + 0, + 0, + 17314, + 17315, + 0, + 17317, + 0, + 0, + 0, + 0, + 17318, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17320, + 0, + 0, + 0, + 0, + 0, + 0, + 17334, + 0, + 17344, + 17348, + 0, + 0, + 0, + 17350, + 17351, + 0, + 0, + 17353, + 0, + 0, + 17354, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17355, + 0, + 0, + 0, + 0, + 0, + 0, + 17356, + 17357, + 0, + 0, + 17359, + 0, + 0, + 0, + 17371, + 0, + 17372, + 0, + 0, + 0, + 17393, + 0, + 0, + 0, + 0, + 17394, + 0, + 0, + 0, + 0, + 0, + 17395, + 0, + 0, + 17399, + 0, + 0, + 0, + 17401, + 17417, + 0, + 17418, + 0, + 17419, + 0, + 0, + 0, + 0, + 0, + 17422, + 17423, + 0, + 0, + 0, + 0, + 0, + 17424, + 0, + 0, + 0, + 0, + 0, + 17428, + 17429, + 17433, + 0, + 0, + 0, + 17437, + 0, + 0, + 17441, + 0, + 0, + 17442, + 0, + 0, + 17453, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17454, + 17456, + 17462, + 0, + 0, + 17466, + 0, + 0, + 17468, + 0, + 0, + 17469, + 0, + 0, + 0, + 0, + 17470, + 0, + 17475, + 0, + 0, + 0, + 0, + 0, + 17479, + 0, + 0, + 0, + 17483, + 17484, + 0, + 17485, + 0, + 17486, + 0, + 17491, + 17492, + 0, + 0, + 17493, + 0, + 17494, + 17495, + 0, + 0, + 0, + 17496, + 0, + 0, + 0, + 17497, + 0, + 0, + 0, + 17502, + 0, + 0, + 0, + 0, + 0, + 17503, + 0, + 17505, + 0, + 17507, + 0, + 0, + 0, + 17512, + 17513, + 17514, + 0, + 0, + 17515, + 0, + 0, + 0, + 17519, + 0, + 0, + 0, + 17522, + 0, + 0, + 17523, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17527, + 0, + 0, + 0, + 17528, + 0, + 0, + 0, + 17534, + 0, + 0, + 0, + 0, + 17536, + 0, + 0, + 0, + 17539, + 0, + 17540, + 17543, + 17549, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17556, + 0, + 0, + 17558, + 0, + 17559, + 0, + 0, + 17560, + 0, + 0, + 0, + 17563, + 0, + 0, + 0, + 0, + 0, + 0, + 17564, + 0, + 0, + 17565, + 17566, + 0, + 17567, + 0, + 0, + 0, + 0, + 0, + 0, + 17569, + 17570, + 0, + 17575, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17581, + 0, + 0, + 0, + 17582, + 17583, + 0, + 17586, + 0, + 0, + 17587, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17588, + 0, + 0, + 0, + 0, + 17596, + 17597, + 0, + 0, + 17598, + 17600, + 0, + 0, + 0, + 0, + 0, + 0, + 17601, + 0, + 0, + 0, + 17604, + 0, + 0, + 17605, + 0, + 0, + 17607, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17612, + 0, + 0, + 17618, + 0, + 17621, + 17622, + 0, + 0, + 0, + 0, + 17623, + 0, + 0, + 17624, + 0, + 0, + 17630, + 0, + 0, + 17631, + 17633, + 17634, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17635, + 0, + 0, + 17636, + 0, + 0, + 17637, + 0, + 17638, + 0, + 17640, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17641, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17643, + 0, + 0, + 0, + 0, + 17645, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17646, + 17662, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17663, + 17664, + 0, + 17665, + 17666, + 0, + 0, + 0, + 17669, + 17671, + 17673, + 0, + 17679, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17684, + 0, + 0, + 0, + 17686, + 0, + 17714, + 0, + 0, + 17720, + 17722, + 17726, + 0, + 0, + 17728, + 0, + 0, + 17729, + 0, + 0, + 0, + 17732, + 0, + 17733, + 0, + 17734, + 0, + 0, + 0, + 17735, + 0, + 0, + 0, + 0, + 17737, + 0, + 0, + 0, + 0, + 17739, + 0, + 0, + 0, + 17741, + 17742, + 0, + 0, + 0, + 0, + 17743, + 17744, + 17745, + 0, + 0, + 0, + 17749, + 0, + 17750, + 17751, + 17752, + 17754, + 17761, + 17762, + 0, + 17763, + 0, + 17766, + 0, + 17772, + 0, + 0, + 0, + 0, + 0, + 17775, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17776, + 0, + 0, + 17777, + 0, + 0, + 17778, + 17779, + 0, + 17782, + 17783, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17784, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17821, + 0, + 0, + 0, + 17822, + 0, + 0, + 0, + 17823, + 17825, + 0, + 0, + 0, + 0, + 0, + 17826, + 17831, + 17832, + 17833, + 0, + 0, + 17845, + 0, + 0, + 0, + 17846, + 0, + 0, + 0, + 17848, + 17850, + 17854, + 0, + 17855, + 0, + 0, + 17859, + 0, + 0, + 0, + 0, + 0, + 0, + 17860, + 17861, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 17870, + 17871, + 0, + 0, + 0, + 0, + 0, + 0, + 17872, + 0, + 0, + 0, + 17879, + 0, + 0, + 0, + 17881, + 17883, + 0, + 17884, + 0, + 17885, + 0, + 0, + 17886, + 0, + 0, + 17887, + 17891, + 17953, + 0, + 0, + 0, + 0, + 17954, + 0, + 0, + 17955, + 0, + 17968, + 0, + 0, + 17972, + 0, + 0, + 0, + 0, + 0, + 17974, + 0, + 0, + 0, + 0, + 17976, + 17978, + 0, + 0, + 17983, + 0, + 0, + 0, + 0, + 18003, + 0, + 0, + 0, + 0, + 0, + 18007, + 0, + 0, + 0, + 0, + 0, + 18009, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18010, + 0, + 0, + 0, + 0, + 0, + 0, + 18012, + 0, + 0, + 18014, + 0, + 0, + 0, + 18015, + 0, + 0, + 0, + 18016, + 0, + 18017, + 0, + 0, + 0, + 18030, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18031, + 0, + 0, + 18036, + 18037, + 18038, + 0, + 0, + 18049, + 18056, + 0, + 18057, + 18058, + 0, + 18059, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18062, + 0, + 0, + 0, + 0, + 18064, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18067, + 0, + 0, + 0, + 18068, + 0, + 0, + 18075, + 0, + 0, + 18078, + 18093, + 18094, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18097, + 0, + 0, + 0, + 0, + 0, + 18098, + 18100, + 0, + 0, + 0, + 18108, + 0, + 18111, + 0, + 0, + 18112, + 0, + 18113, + 0, + 0, + 18115, + 18116, + 0, + 18118, + 0, + 0, + 0, + 0, + 18121, + 0, + 0, + 0, + 0, + 18123, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18124, + 0, + 0, + 0, + 0, + 18125, + 18126, + 0, + 18127, + 0, + 0, + 18128, + 18135, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18150, + 0, + 0, + 0, + 0, + 0, + 18151, + 18152, + 0, + 0, + 18156, + 18164, + 0, + 18166, + 18171, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18172, + 18183, + 0, + 18184, + 0, + 0, + 0, + 0, + 18185, + 0, + 18187, + 0, + 0, + 0, + 0, + 0, + 18188, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18189, + 0, + 0, + 18190, + 0, + 0, + 18191, + 18192, + 0, + 0, + 18194, + 18195, + 18196, + 0, + 0, + 0, + 18197, + 0, + 18203, + 0, + 18204, + 0, + 0, + 0, + 0, + 18205, + 0, + 0, + 0, + 18207, + 18208, + 0, + 0, + 18214, + 0, + 0, + 0, + 18215, + 18216, + 0, + 0, + 0, + 18220, + 0, + 0, + 18222, + 0, + 0, + 0, + 0, + 0, + 18223, + 0, + 18225, + 18231, + 0, + 18234, + 0, + 18235, + 0, + 0, + 0, + 0, + 18240, + 0, + 0, + 18241, + 18242, + 0, + 0, + 0, + 0, + 0, + 18243, + 18251, + 0, + 18253, + 0, + 18254, + 0, + 0, + 0, + 18266, + 0, + 0, + 0, + 0, + 0, + 0, + 18269, + 18270, + 18271, + 18273, + 18281, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18282, + 0, + 18283, + 0, + 18284, + 0, + 0, + 0, + 0, + 0, + 0, + 18285, + 0, + 18287, + 18289, + 0, + 0, + 18290, + 0, + 0, + 0, + 0, + 18308, + 0, + 0, + 0, + 18310, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18311, + 0, + 18312, + 18313, + 0, + 18315, + 0, + 0, + 18316, + 18320, + 0, + 18331, + 0, + 18332, + 0, + 18336, + 0, + 0, + 0, + 0, + 18337, + 0, + 18340, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18341, + 0, + 18344, + 18345, + 0, + 18346, + 0, + 0, + 0, + 0, + 0, + 18348, + 0, + 18351, + 0, + 0, + 18356, + 0, + 0, + 0, + 0, + 0, + 0, + 18357, + 0, + 0, + 0, + 0, + 0, + 18367, + 0, + 0, + 0, + 18368, + 0, + 18369, + 0, + 18370, + 18371, + 0, + 0, + 0, + 18437, + 18444, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18445, + 18450, + 0, + 0, + 0, + 0, + 18451, + 0, + 18452, + 0, + 0, + 0, + 18453, + 0, + 0, + 0, + 0, + 0, + 18455, + 0, + 0, + 0, + 18456, + 0, + 18457, + 0, + 18460, + 0, + 0, + 18461, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18466, + 0, + 0, + 18467, + 0, + 0, + 0, + 0, + 18473, + 0, + 0, + 0, + 18476, + 0, + 18477, + 0, + 0, + 0, + 18478, + 18479, + 18480, + 0, + 0, + 0, + 18485, + 0, + 0, + 0, + 18486, + 0, + 0, + 0, + 0, + 0, + 0, + 18488, + 18490, + 0, + 0, + 0, + 0, + 0, + 0, + 18491, + 0, + 0, + 0, + 0, + 0, + 18495, + 0, + 0, + 18496, + 0, + 0, + 0, + 0, + 0, + 0, + 18505, + 0, + 18521, + 0, + 18522, + 18523, + 0, + 0, + 0, + 18525, + 18526, + 0, + 0, + 0, + 0, + 0, + 18527, + 0, + 0, + 0, + 0, + 18532, + 18533, + 0, + 18534, + 0, + 0, + 0, + 0, + 0, + 0, + 18535, + 18537, + 0, + 18538, + 0, + 0, + 0, + 0, + 0, + 0, + 18540, + 18541, + 18542, + 18543, + 0, + 18546, + 0, + 0, + 0, + 0, + 18553, + 18556, + 0, + 0, + 18558, + 0, + 0, + 18569, + 18571, + 0, + 0, + 0, + 18572, + 0, + 18574, + 0, + 0, + 0, + 0, + 18586, + 0, + 0, + 0, + 0, + 0, + 18588, + 0, + 0, + 18589, + 0, + 0, + 0, + 0, + 0, + 0, + 18590, + 0, + 18592, + 0, + 0, + 0, + 0, + 18594, + 0, + 0, + 0, + 18596, + 0, + 0, + 18597, + 18598, + 0, + 0, + 18601, + 0, + 0, + 0, + 0, + 18602, + 0, + 0, + 0, + 18603, + 18604, + 0, + 18605, + 0, + 0, + 0, + 0, + 18608, + 0, + 0, + 18611, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18612, + 0, + 18616, + 0, + 0, + 18617, + 18619, + 0, + 0, + 0, + 18628, + 0, + 0, + 0, + 18629, + 0, + 0, + 18630, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18631, + 0, + 18632, + 0, + 0, + 18635, + 18637, + 0, + 0, + 0, + 0, + 0, + 0, + 18641, + 18643, + 18648, + 0, + 18652, + 0, + 0, + 18653, + 0, + 18655, + 18656, + 0, + 0, + 0, + 18657, + 0, + 0, + 18666, + 18674, + 0, + 0, + 0, + 0, + 18677, + 18684, + 18685, + 0, + 0, + 18686, + 0, + 0, + 18690, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18695, + 18696, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18697, + 0, + 0, + 18700, + 0, + 0, + 0, + 0, + 0, + 0, + 18702, + 0, + 18708, + 0, + 0, + 18709, + 0, + 18710, + 0, + 0, + 18711, + 0, + 18714, + 0, + 0, + 18718, + 0, + 0, + 0, + 0, + 0, + 0, + 18719, + 0, + 0, + 18722, + 0, + 18726, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18731, + 0, + 0, + 0, + 0, + 0, + 18739, + 18741, + 0, + 0, + 18742, + 0, + 18743, + 18744, + 18746, + 18748, + 0, + 18752, + 18753, + 0, + 0, + 18754, + 18763, + 0, + 18765, + 0, + 0, + 0, + 18766, + 0, + 0, + 0, + 18769, + 0, + 0, + 0, + 0, + 0, + 18773, + 18778, + 18779, + 18781, + 0, + 0, + 18784, + 18787, + 0, + 18788, + 0, + 18793, + 0, + 0, + 0, + 0, + 0, + 0, + 18795, + 0, + 0, + 18800, + 0, + 0, + 0, + 0, + 0, + 18801, + 18804, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18806, + 0, + 0, + 0, + 18811, + 18815, + 18816, + 0, + 0, + 0, + 0, + 18825, + 0, + 0, + 18827, + 18829, + 0, + 0, + 18830, + 0, + 0, + 0, + 0, + 18831, + 0, + 0, + 18832, + 0, + 0, + 0, + 0, + 18833, + 0, + 18840, + 0, + 18841, + 0, + 18842, + 0, + 0, + 0, + 0, + 18843, + 0, + 18844, + 0, + 0, + 0, + 0, + 0, + 0, + 18845, + 18846, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18848, + 0, + 0, + 0, + 18853, + 18860, + 0, + 0, + 18862, + 18866, + 0, + 0, + 18867, + 18869, + 0, + 0, + 18874, + 18881, + 18891, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18892, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18895, + 0, + 18896, + 0, + 0, + 0, + 18900, + 0, + 0, + 0, + 18901, + 0, + 18902, + 18915, + 18916, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18919, + 0, + 0, + 0, + 0, + 0, + 18920, + 0, + 0, + 0, + 18921, + 18929, + 0, + 0, + 0, + 0, + 18930, + 0, + 0, + 0, + 0, + 0, + 0, + 18932, + 0, + 0, + 0, + 0, + 18934, + 18942, + 0, + 0, + 0, + 18951, + 18957, + 0, + 0, + 0, + 0, + 18958, + 0, + 0, + 0, + 0, + 18959, + 18960, + 0, + 0, + 18961, + 0, + 0, + 18962, + 0, + 0, + 0, + 0, + 18963, + 18964, + 0, + 0, + 0, + 18965, + 0, + 18967, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 18968, + 0, + 18969, + 0, + 18970, + 18973, + 18976, + 0, + 0, + 0, + 0, + 0, + 0, + 18977, + 0, + 0, + 0, + 18981, + 0, + 0, + 0, + 18990, + 0, + 18998, + 0, + 0, + 0, + 0, + 0, + 18999, + 19003, + 0, + 0, + 19005, + 0, + 0, + 0, + 19006, + 0, + 0, + 0, + 0, + 0, + 0, + 19008, + 19011, + 0, + 0, + 19018, + 0, + 0, + 19019, + 0, + 19024, + 0, + 19031, + 19032, + 0, + 19039, + 0, + 19041, + 19050, + 0, + 0, + 0, + 19051, + 19055, + 19056, + 0, + 19059, + 19063, + 19064, + 0, + 0, + 19088, + 0, + 0, + 0, + 19093, + 19094, + 0, + 0, + 0, + 0, + 19095, + 0, + 19096, + 0, + 0, + 0, + 19097, + 0, + 0, + 19098, + 0, + 19099, + 19100, + 0, + 0, + 19103, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19111, + 0, + 0, + 0, + 0, + 0, + 0, + 19112, + 0, + 0, + 0, + 19116, + 19117, + 0, + 19121, + 19122, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19123, + 19124, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19125, + 19126, + 0, + 19128, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19129, + 19130, + 19131, + 19132, + 0, + 0, + 19146, + 0, + 0, + 19147, + 19156, + 19158, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19182, + 19185, + 0, + 0, + 19187, + 0, + 0, + 0, + 19193, + 0, + 0, + 0, + 0, + 0, + 19194, + 0, + 19197, + 0, + 0, + 0, + 0, + 19198, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19202, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19203, + 0, + 19205, + 19210, + 0, + 0, + 0, + 19213, + 0, + 19218, + 0, + 0, + 0, + 19223, + 19229, + 0, + 0, + 19230, + 0, + 0, + 19231, + 19232, + 19233, + 19239, + 0, + 0, + 0, + 0, + 0, + 19240, + 0, + 19248, + 19249, + 0, + 0, + 0, + 0, + 19254, + 0, + 19256, + 19258, + 19259, + 0, + 0, + 19261, + 0, + 19266, + 0, + 0, + 0, + 19272, + 0, + 19278, + 19281, + 19282, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19283, + 0, + 0, + 19284, + 0, + 0, + 19285, + 19287, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19288, + 19291, + 0, + 19292, + 0, + 0, + 0, + 0, + 19297, + 0, + 19298, + 0, + 0, + 0, + 0, + 19302, + 19303, + 0, + 0, + 0, + 0, + 19304, + 19305, + 0, + 0, + 0, + 0, + 19314, + 0, + 0, + 19315, + 0, + 0, + 19321, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19322, + 0, + 19333, + 0, + 19334, + 19335, + 0, + 19336, + 19337, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19346, + 0, + 0, + 19353, + 0, + 19354, + 19362, + 0, + 19366, + 19367, + 0, + 0, + 19369, + 0, + 19375, + 0, + 19377, + 19380, + 19388, + 0, + 0, + 0, + 0, + 0, + 19389, + 19390, + 0, + 0, + 0, + 0, + 19392, + 0, + 0, + 0, + 0, + 0, + 19402, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19412, + 0, + 0, + 19413, + 19422, + 0, + 19424, + 0, + 0, + 0, + 19425, + 0, + 0, + 0, + 19428, + 0, + 0, + 0, + 0, + 19431, + 0, + 0, + 0, + 0, + 0, + 19432, + 0, + 0, + 0, + 0, + 0, + 19448, + 19459, + 0, + 0, + 19461, + 0, + 19462, + 19463, + 0, + 19467, + 19474, + 19482, + 0, + 0, + 0, + 0, + 19494, + 0, + 0, + 0, + 0, + 19501, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19502, + 19504, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19505, + 0, + 0, + 0, + 0, + 19506, + 19507, + 0, + 0, + 0, + 19508, + 0, + 0, + 19511, + 0, + 0, + 19514, + 0, + 19515, + 0, + 19516, + 0, + 19518, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19530, + 0, + 19537, + 19538, + 0, + 19543, + 19546, + 0, + 19547, + 19551, + 0, + 0, + 0, + 0, + 0, + 0, + 19552, + 19553, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19555, + 0, + 0, + 19556, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19560, + 19561, + 0, + 0, + 19562, + 0, + 0, + 0, + 0, + 0, + 0, + 19565, + 19567, + 0, + 19568, + 0, + 0, + 0, + 19569, + 19570, + 0, + 19578, + 0, + 0, + 0, + 0, + 19580, + 0, + 0, + 0, + 0, + 19581, + 19584, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19585, + 19586, + 0, + 0, + 0, + 19587, + 19588, + 0, + 19589, + 0, + 0, + 0, + 0, + 0, + 0, + 19592, + 19593, + 19599, + 0, + 19600, + 0, + 0, + 19604, + 0, + 0, + 19605, + 0, + 19606, + 19608, + 19610, + 0, + 19613, + 19614, + 0, + 0, + 0, + 0, + 0, + 0, + 19616, + 19617, + 0, + 0, + 19618, + 0, + 0, + 19619, + 0, + 0, + 0, + 19620, + 19621, + 19631, + 0, + 0, + 19632, + 19634, + 19636, + 0, + 19643, + 0, + 0, + 19644, + 19658, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19659, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19675, + 19677, + 0, + 0, + 0, + 0, + 19679, + 0, + 19683, + 0, + 19684, + 0, + 0, + 0, + 0, + 0, + 0, + 19687, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19688, + 19689, + 19692, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19695, + 19697, + 0, + 0, + 0, + 0, + 0, + 19698, + 19699, + 0, + 0, + 19700, + 0, + 19702, + 0, + 0, + 19703, + 0, + 0, + 0, + 0, + 0, + 0, + 19704, + 19708, + 0, + 19710, + 0, + 19713, + 0, + 0, + 0, + 19715, + 0, + 0, + 0, + 0, + 19718, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19720, + 0, + 19722, + 0, + 0, + 19725, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19730, + 0, + 0, + 0, + 0, + 0, + 19731, + 0, + 19734, + 19735, + 19739, + 0, + 0, + 19740, + 0, + 19741, + 0, + 0, + 0, + 19746, + 0, + 0, + 19747, + 0, + 19771, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19772, + 19775, + 0, + 0, + 0, + 0, + 0, + 0, + 19778, + 0, + 0, + 0, + 0, + 0, + 19779, + 0, + 0, + 19780, + 19790, + 0, + 19791, + 0, + 0, + 19792, + 0, + 0, + 0, + 19793, + 0, + 0, + 19796, + 19797, + 0, + 0, + 0, + 19799, + 0, + 0, + 0, + 19801, + 0, + 0, + 0, + 0, + 19803, + 0, + 19804, + 0, + 19805, + 0, + 0, + 19807, + 0, + 0, + 0, + 19808, + 0, + 0, + 0, + 0, + 0, + 0, + 19809, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19816, + 0, + 19821, + 0, + 19822, + 19830, + 19831, + 0, + 0, + 0, + 19833, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19838, + 0, + 0, + 0, + 0, + 19839, + 0, + 0, + 19843, + 0, + 0, + 0, + 0, + 19845, + 0, + 0, + 0, + 0, + 19847, + 0, + 0, + 19848, + 0, + 19849, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19851, + 0, + 0, + 0, + 19854, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19864, + 0, + 19865, + 0, + 19866, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19868, + 0, + 0, + 19870, + 0, + 0, + 19871, + 0, + 0, + 19872, + 19873, + 19875, + 0, + 19880, + 19882, + 19884, + 0, + 0, + 19885, + 19886, + 19888, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19890, + 19892, + 19893, + 0, + 0, + 19894, + 0, + 0, + 0, + 19895, + 0, + 19896, + 19902, + 0, + 0, + 19903, + 0, + 0, + 19905, + 0, + 0, + 0, + 19906, + 0, + 19908, + 0, + 19909, + 19911, + 0, + 0, + 0, + 19913, + 19920, + 0, + 19938, + 19939, + 19940, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 19942, + 0, + 19943, + 0, + 19945, + 0, + 0, + 0, + 19951, + 19952, + 19954, + 19960, + 0, + 19965, + 0, + 19971, + 0, + 0, + 0, + 0, + 0, + 19975, + 0, + 19976, + 0, + 19990, + 0, + 0, + 19991, + 0, + 19993, + 0, + 19995, + 0, + 0, + 0, + 19998, + 19999, + 20001, + 0, + 20003, + 20005, + 0, + 20011, + 20012, + 0, + 0, + 0, + 0, + 0, + 0, + 20014, + 0, + 20020, + 0, + 0, + 0, + 0, + 20021, + 0, + 0, + 0, + 0, + 0, + 20023, + 20024, + 0, + 0, + 0, + 0, + 0, + 20025, + 0, + 0, + 20027, + 0, + 0, + 20029, + 0, + 0, + 20032, + 0, + 0, + 0, + 0, + 20044, + 20045, + 0, + 20048, + 20049, + 0, + 0, + 20050, + 0, + 20052, + 0, + 0, + 20054, + 20057, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20059, + 0, + 0, + 20061, + 0, + 20062, + 0, + 20064, + 0, + 0, + 20066, + 0, + 0, + 20067, + 0, + 0, + 0, + 0, + 20069, + 0, + 0, + 0, + 0, + 0, + 0, + 20070, + 20071, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20072, + 0, + 0, + 20073, + 20074, + 0, + 0, + 0, + 0, + 0, + 20075, + 0, + 20078, + 0, + 0, + 0, + 0, + 20080, + 0, + 20081, + 0, + 0, + 0, + 0, + 0, + 0, + 20095, + 0, + 20098, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20107, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20112, + 0, + 0, + 0, + 20113, + 20114, + 0, + 0, + 0, + 20115, + 20123, + 20124, + 0, + 0, + 0, + 20131, + 20133, + 20134, + 0, + 0, + 0, + 0, + 20136, + 0, + 0, + 20137, + 20138, + 20150, + 0, + 20152, + 0, + 0, + 0, + 20153, + 0, + 0, + 20154, + 0, + 0, + 0, + 20158, + 0, + 20163, + 0, + 0, + 20164, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20166, + 0, + 20168, + 0, + 20170, + 0, + 20175, + 0, + 0, + 20178, + 0, + 0, + 0, + 0, + 20223, + 0, + 0, + 0, + 0, + 20224, + 0, + 20226, + 0, + 0, + 20230, + 0, + 20231, + 0, + 0, + 0, + 0, + 20232, + 0, + 0, + 20233, + 20234, + 0, + 20244, + 0, + 20247, + 0, + 0, + 0, + 0, + 0, + 0, + 20249, + 0, + 0, + 0, + 20250, + 0, + 0, + 0, + 0, + 20251, + 0, + 20253, + 0, + 20254, + 0, + 0, + 0, + 0, + 20256, + 0, + 0, + 20264, + 0, + 0, + 0, + 0, + 20266, + 0, + 0, + 0, + 20278, + 0, + 0, + 20279, + 20282, + 0, + 0, + 0, + 0, + 0, + 20283, + 0, + 20284, + 0, + 20285, + 0, + 20287, + 20290, + 0, + 0, + 0, + 0, + 20292, + 0, + 0, + 0, + 0, + 20293, + 20297, + 0, + 0, + 0, + 0, + 0, + 0, + 20299, + 0, + 20300, + 20303, + 0, + 0, + 0, + 0, + 0, + 0, + 20307, + 0, + 0, + 20308, + 0, + 20309, + 0, + 20310, + 0, + 0, + 0, + 0, + 0, + 0, + 20312, + 0, + 0, + 0, + 20314, + 0, + 0, + 0, + 0, + 20315, + 20316, + 0, + 20322, + 0, + 0, + 0, + 0, + 0, + 0, + 20339, + 0, + 0, + 0, + 20342, + 0, + 0, + 0, + 0, + 20352, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20362, + 0, + 0, + 20365, + 0, + 20375, + 20377, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20378, + 20379, + 0, + 20380, + 0, + 0, + 20381, + 0, + 20382, + 0, + 20383, + 0, + 20388, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20390, + 20392, + 20393, + 0, + 0, + 20395, + 0, + 0, + 0, + 0, + 0, + 20396, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20398, + 20415, + 0, + 0, + 0, + 20417, + 0, + 0, + 20420, + 0, + 0, + 20426, + 20428, + 0, + 20431, + 0, + 0, + 20432, + 0, + 20433, + 20434, + 20435, + 0, + 0, + 0, + 0, + 20440, + 0, + 0, + 0, + 0, + 0, + 20442, + 0, + 20443, + 0, + 20446, + 0, + 0, + 0, + 0, + 20448, + 0, + 20451, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20452, + 20453, + 0, + 0, + 20454, + 0, + 0, + 0, + 0, + 0, + 0, + 20457, + 0, + 20458, + 0, + 0, + 0, + 20465, + 0, + 0, + 0, + 0, + 0, + 20469, + 0, + 0, + 0, + 20473, + 0, + 20476, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20477, + 0, + 0, + 20485, + 0, + 0, + 20486, + 0, + 0, + 20487, + 0, + 20496, + 0, + 20497, + 0, + 0, + 20498, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20499, + 20500, + 0, + 20501, + 0, + 0, + 0, + 0, + 0, + 20520, + 20527, + 0, + 20529, + 0, + 0, + 0, + 0, + 20539, + 0, + 0, + 20540, + 0, + 0, + 0, + 20543, + 0, + 0, + 0, + 20546, + 0, + 0, + 0, + 0, + 0, + 20548, + 0, + 0, + 20563, + 0, + 0, + 20564, + 0, + 20566, + 0, + 0, + 0, + 0, + 0, + 20589, + 0, + 0, + 0, + 0, + 20590, + 0, + 0, + 20593, + 20594, + 0, + 0, + 0, + 0, + 20595, + 0, + 20597, + 20598, + 0, + 0, + 0, + 20618, + 20620, + 0, + 0, + 0, + 0, + 20621, + 0, + 0, + 0, + 0, + 20627, + 0, + 0, + 0, + 0, + 0, + 20628, + 0, + 0, + 0, + 20629, + 0, + 20630, + 0, + 0, + 20639, + 0, + 0, + 0, + 0, + 0, + 20707, + 0, + 0, + 20709, + 0, + 0, + 0, + 20713, + 20714, + 0, + 0, + 0, + 0, + 0, + 20724, + 20725, + 0, + 0, + 0, + 0, + 20726, + 20728, + 20729, + 0, + 20733, + 0, + 20734, + 0, + 20735, + 20736, + 0, + 20737, + 0, + 0, + 20744, + 0, + 20745, + 0, + 20748, + 0, + 0, + 20749, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20750, + 0, + 0, + 0, + 0, + 20754, + 0, + 0, + 0, + 20761, + 0, + 0, + 20763, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20766, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20767, + 0, + 0, + 0, + 0, + 20768, + 0, + 20769, + 20777, + 0, + 0, + 0, + 0, + 0, + 0, + 20785, + 0, + 0, + 0, + 20786, + 20795, + 20801, + 0, + 20802, + 0, + 20807, + 0, + 0, + 20808, + 0, + 0, + 20810, + 0, + 0, + 20811, + 0, + 20812, + 0, + 0, + 0, + 0, + 0, + 20813, + 0, + 0, + 20818, + 20820, + 20821, + 0, + 0, + 0, + 20822, + 0, + 20823, + 0, + 0, + 0, + 20826, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20829, + 20830, + 20831, + 0, + 20832, + 20836, + 0, + 0, + 20839, + 0, + 0, + 20840, + 20842, + 0, + 20843, + 0, + 20844, + 0, + 20854, + 0, + 0, + 0, + 20855, + 0, + 0, + 0, + 0, + 20856, + 0, + 0, + 0, + 20869, + 0, + 0, + 20871, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20873, + 0, + 0, + 0, + 0, + 0, + 20876, + 0, + 0, + 0, + 0, + 0, + 20880, + 0, + 0, + 20882, + 0, + 0, + 0, + 0, + 20883, + 20884, + 0, + 0, + 20890, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 20891, + 0, + 0, + 0, + 0, + 0, + 20905, + 0, + 20906, + 20910, + 0, + 0, + 20912, + 20915, + 0, + 0, + 0, + 0, + 0, + 20916, + 0, + 20917, + 0, + 20919, + 20920, + 20922, + 0, + 20927, + 0, + 20928, + 20929, + 20930, + 0, + 0, + 20935, + 0, + 0, + 20939, + 0, + 0, + 20941, + 0, + 0, + 0, + 20943, + 0, + 0, + 0, + 20946, + 20947, + 0, + 0, + 0, + 0, + 0, + 20950, + 0, + 20954, + 0, + 0, + 20955, + 20964, + 0, + 0, + 20967, + 0, + 0, + 0, + 0, + 0, + 20973, + 20975, + 0, + 0, + 0, + 20984, + 0, + 20987, + 20988, + 0, + 0, + 0, + 0, + 0, + 20989, + 0, + 0, + 0, + 20995, + 0, + 20998, + 0, + 20999, + 0, + 0, + 0, + 0, + 21000, + 21001, + 0, + 0, + 0, + 0, + 21008, + 0, + 21010, + 0, + 21016, + 0, + 0, + 0, + 21017, + 21018, + 0, + 0, + 0, + 0, + 0, + 21021, + 21026, + 21027, + 21028, + 0, + 0, + 21029, + 0, + 0, + 0, + 0, + 0, + 21030, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21031, + 21032, + 0, + 0, + 0, + 0, + 0, + 21037, + 0, + 0, + 21038, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21039, + 0, + 21041, + 0, + 21046, + 21047, + 0, + 0, + 0, + 21049, + 21053, + 0, + 0, + 21057, + 21064, + 21065, + 0, + 0, + 21066, + 21067, + 0, + 0, + 0, + 21069, + 0, + 0, + 0, + 21071, + 21072, + 0, + 0, + 21073, + 0, + 21074, + 0, + 0, + 21078, + 0, + 0, + 0, + 0, + 21079, + 0, + 0, + 21080, + 21081, + 0, + 0, + 21086, + 21087, + 0, + 21089, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21091, + 0, + 21093, + 0, + 21094, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21095, + 0, + 0, + 0, + 0, + 0, + 21096, + 0, + 21098, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21099, + 0, + 0, + 21100, + 21101, + 21102, + 0, + 0, + 0, + 0, + 0, + 21103, + 0, + 21104, + 0, + 0, + 0, + 0, + 0, + 21105, + 21108, + 21109, + 0, + 0, + 21112, + 21113, + 0, + 0, + 0, + 0, + 0, + 0, + 21115, + 21122, + 21123, + 0, + 0, + 0, + 0, + 0, + 21125, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21129, + 21131, + 0, + 0, + 21134, + 0, + 0, + 0, + 21137, + 21142, + 0, + 21143, + 0, + 0, + 21144, + 0, + 21145, + 21146, + 0, + 21152, + 21154, + 21155, + 21156, + 0, + 0, + 0, + 21160, + 0, + 0, + 0, + 0, + 0, + 0, + 21161, + 0, + 21164, + 0, + 21166, + 0, + 0, + 0, + 0, + 21170, + 0, + 0, + 0, + 0, + 21171, + 0, + 0, + 21172, + 0, + 21174, + 0, + 21175, + 0, + 0, + 0, + 0, + 0, + 21176, + 21179, + 21188, + 0, + 0, + 0, + 21189, + 0, + 0, + 21190, + 0, + 0, + 0, + 21192, + 0, + 0, + 21193, + 0, + 0, + 0, + 21198, + 0, + 21212, + 0, + 0, + 21213, + 0, + 0, + 0, + 0, + 0, + 0, + 21215, + 21216, + 0, + 0, + 21223, + 21225, + 0, + 21226, + 0, + 0, + 0, + 0, + 21227, + 21228, + 0, + 0, + 21229, + 0, + 0, + 0, + 0, + 21230, + 21236, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21237, + 0, + 0, + 21238, + 21239, + 0, + 0, + 0, + 0, + 21256, + 0, + 0, + 0, + 0, + 0, + 21257, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21259, + 0, + 0, + 0, + 21263, + 0, + 21272, + 0, + 21274, + 0, + 21282, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21283, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21294, + 0, + 0, + 21297, + 0, + 0, + 0, + 0, + 21298, + 0, + 0, + 0, + 21299, + 0, + 21300, + 21302, + 0, + 21316, + 0, + 21318, + 21322, + 21323, + 0, + 21324, + 0, + 21326, + 0, + 0, + 0, + 21327, + 21328, + 0, + 0, + 0, + 21352, + 0, + 0, + 21354, + 21361, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21362, + 0, + 0, + 0, + 21363, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21366, + 0, + 0, + 21367, + 21372, + 21374, + 0, + 0, + 0, + 21375, + 21377, + 0, + 21378, + 0, + 0, + 0, + 21380, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21381, + 0, + 0, + 0, + 0, + 0, + 0, + 21382, + 0, + 21383, + 0, + 0, + 21384, + 0, + 0, + 21385, + 0, + 0, + 0, + 0, + 21389, + 21390, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21397, + 21398, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21399, + 0, + 21400, + 0, + 0, + 0, + 0, + 21402, + 0, + 0, + 0, + 21403, + 21404, + 0, + 21405, + 21406, + 0, + 0, + 0, + 21407, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21408, + 0, + 0, + 0, + 0, + 21409, + 0, + 21421, + 0, + 21422, + 0, + 0, + 0, + 21425, + 21428, + 0, + 0, + 0, + 0, + 21429, + 0, + 0, + 0, + 0, + 0, + 21433, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21434, + 0, + 21443, + 0, + 21444, + 21449, + 0, + 21452, + 0, + 21453, + 21454, + 0, + 0, + 0, + 21457, + 0, + 0, + 21458, + 0, + 0, + 0, + 21460, + 21461, + 0, + 0, + 21464, + 0, + 0, + 0, + 21473, + 21478, + 0, + 0, + 21479, + 0, + 0, + 21481, + 21483, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21484, + 0, + 0, + 21485, + 21486, + 0, + 0, + 21488, + 0, + 0, + 0, + 0, + 0, + 0, + 21523, + 0, + 0, + 21525, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21526, + 0, + 0, + 0, + 0, + 0, + 0, + 21529, + 21530, + 0, + 0, + 21531, + 0, + 0, + 21533, + 0, + 0, + 21539, + 21564, + 0, + 21567, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21575, + 0, + 0, + 0, + 0, + 21577, + 0, + 0, + 0, + 0, + 0, + 21591, + 0, + 0, + 21604, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21605, + 0, + 21606, + 0, + 0, + 21617, + 21618, + 21619, + 21620, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21623, + 0, + 0, + 0, + 0, + 21631, + 0, + 21635, + 0, + 0, + 0, + 0, + 21639, + 21646, + 21653, + 21662, + 0, + 0, + 21663, + 21664, + 0, + 21666, + 0, + 0, + 21667, + 0, + 21670, + 21672, + 21673, + 0, + 21674, + 21683, + 0, + 0, + 0, + 0, + 0, + 21684, + 0, + 21694, + 0, + 0, + 0, + 0, + 21695, + 21700, + 0, + 21703, + 0, + 21704, + 0, + 0, + 21709, + 0, + 0, + 0, + 21710, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21711, + 0, + 0, + 0, + 21712, + 0, + 21717, + 0, + 21730, + 0, + 0, + 0, + 21731, + 21733, + 0, + 0, + 0, + 0, + 21737, + 21741, + 21742, + 0, + 21747, + 0, + 0, + 0, + 21749, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21750, + 0, + 0, + 0, + 0, + 0, + 21752, + 0, + 0, + 0, + 0, + 21753, + 0, + 0, + 0, + 0, + 0, + 0, + 21755, + 21756, + 0, + 21757, + 0, + 0, + 0, + 0, + 0, + 0, + 21760, + 0, + 0, + 21763, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21764, + 0, + 0, + 21766, + 0, + 0, + 21767, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21773, + 0, + 21774, + 0, + 0, + 21775, + 0, + 0, + 0, + 0, + 21776, + 0, + 0, + 21777, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21780, + 21787, + 21788, + 21791, + 0, + 0, + 0, + 21797, + 0, + 0, + 0, + 0, + 0, + 21805, + 0, + 0, + 0, + 0, + 21806, + 0, + 21807, + 21809, + 0, + 21810, + 21811, + 0, + 21817, + 21819, + 21820, + 0, + 21823, + 0, + 21824, + 0, + 0, + 21825, + 0, + 0, + 21826, + 21832, + 0, + 0, + 0, + 0, + 0, + 21833, + 21848, + 21849, + 0, + 0, + 21867, + 21870, + 21871, + 21873, + 0, + 0, + 0, + 21874, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21875, + 0, + 21878, + 0, + 0, + 0, + 21879, + 0, + 21881, + 21886, + 0, + 0, + 0, + 0, + 21887, + 0, + 0, + 21888, + 21894, + 21895, + 21897, + 0, + 21901, + 0, + 21904, + 0, + 0, + 21906, + 0, + 0, + 0, + 21909, + 21910, + 21911, + 0, + 0, + 21912, + 0, + 0, + 21913, + 21914, + 21915, + 0, + 21919, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21921, + 0, + 0, + 21922, + 21933, + 21939, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21944, + 0, + 0, + 0, + 0, + 0, + 21945, + 0, + 21947, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21949, + 0, + 0, + 0, + 21950, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21951, + 0, + 21952, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21954, + 21957, + 0, + 0, + 0, + 0, + 21958, + 0, + 21959, + 0, + 0, + 0, + 0, + 0, + 0, + 21962, + 21963, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 21964, + 21965, + 0, + 0, + 21969, + 21970, + 0, + 0, + 0, + 21974, + 0, + 0, + 21980, + 21981, + 0, + 21982, + 0, + 0, + 0, + 0, + 0, + 21985, + 0, + 21988, + 0, + 21992, + 0, + 21999, + 0, + 0, + 0, + 0, + 0, + 0, + 22001, + 0, + 22002, + 0, + 0, + 0, + 0, + 0, + 0, + 22003, + 0, + 0, + 0, + 0, + 0, + 22004, + 0, + 0, + 0, + 22008, + 0, + 22009, + 22015, + 0, + 0, + 22016, + 0, + 0, + 0, + 22017, + 22019, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22020, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22021, + 22037, + 0, + 22039, + 0, + 0, + 0, + 22040, + 0, + 0, + 0, + 22048, + 22049, + 0, + 0, + 22053, + 22055, + 22056, + 22059, + 0, + 0, + 22060, + 22061, + 0, + 0, + 22064, + 0, + 0, + 0, + 0, + 22066, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22073, + 0, + 0, + 0, + 22074, + 22075, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22076, + 0, + 0, + 0, + 0, + 22077, + 22084, + 22099, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22104, + 0, + 0, + 22107, + 0, + 22108, + 0, + 22109, + 0, + 22110, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22111, + 22119, + 0, + 22120, + 22122, + 0, + 0, + 0, + 0, + 22125, + 0, + 0, + 0, + 22128, + 22129, + 0, + 0, + 0, + 0, + 0, + 0, + 22141, + 0, + 0, + 0, + 22142, + 0, + 0, + 22144, + 22146, + 0, + 22148, + 22149, + 22151, + 22154, + 0, + 0, + 0, + 22162, + 0, + 0, + 0, + 0, + 22164, + 22177, + 0, + 0, + 0, + 0, + 22179, + 0, + 22182, + 22183, + 0, + 0, + 22184, + 22188, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22190, + 0, + 22194, + 22201, + 0, + 0, + 22208, + 0, + 22209, + 0, + 22212, + 0, + 0, + 22215, + 0, + 22223, + 22231, + 0, + 0, + 22232, + 0, + 22234, + 0, + 0, + 22235, + 22236, + 0, + 22237, + 0, + 22240, + 0, + 0, + 0, + 0, + 0, + 22241, + 0, + 0, + 0, + 22242, + 22246, + 22247, + 0, + 0, + 0, + 22259, + 22268, + 0, + 22269, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22270, + 0, + 0, + 0, + 0, + 22271, + 0, + 22272, + 0, + 22277, + 0, + 0, + 0, + 0, + 0, + 22278, + 22280, + 22283, + 22286, + 0, + 0, + 22287, + 22289, + 0, + 0, + 22290, + 0, + 22293, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22295, + 0, + 22301, + 22302, + 0, + 0, + 0, + 22305, + 0, + 22308, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22315, + 0, + 0, + 0, + 22317, + 0, + 22334, + 0, + 0, + 0, + 22335, + 0, + 0, + 0, + 0, + 0, + 22336, + 0, + 22338, + 22344, + 0, + 22347, + 22349, + 0, + 22350, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22357, + 0, + 0, + 0, + 0, + 0, + 22358, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22359, + 22360, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22361, + 22366, + 0, + 0, + 22369, + 0, + 22370, + 22373, + 0, + 0, + 0, + 0, + 0, + 22375, + 0, + 22377, + 0, + 0, + 0, + 0, + 0, + 22378, + 0, + 0, + 0, + 0, + 22381, + 0, + 0, + 0, + 0, + 22382, + 0, + 22383, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22391, + 0, + 0, + 22392, + 22395, + 22396, + 22402, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22405, + 0, + 0, + 22406, + 0, + 0, + 22408, + 0, + 0, + 22409, + 22410, + 0, + 0, + 0, + 0, + 0, + 0, + 22424, + 0, + 0, + 0, + 0, + 22426, + 0, + 0, + 0, + 22427, + 0, + 22428, + 0, + 22432, + 0, + 22435, + 22442, + 22443, + 0, + 0, + 0, + 0, + 22444, + 0, + 0, + 0, + 0, + 0, + 22446, + 0, + 22454, + 0, + 22455, + 0, + 0, + 0, + 22465, + 0, + 22470, + 0, + 22471, + 0, + 0, + 0, + 0, + 22472, + 22473, + 0, + 22487, + 0, + 0, + 0, + 22488, + 0, + 0, + 0, + 0, + 22489, + 0, + 0, + 22499, + 0, + 0, + 0, + 0, + 0, + 0, + 22514, + 0, + 0, + 22515, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22516, + 0, + 0, + 0, + 22517, + 22520, + 0, + 0, + 0, + 22534, + 0, + 0, + 22535, + 0, + 0, + 22536, + 0, + 22540, + 22553, + 0, + 22555, + 0, + 0, + 0, + 0, + 22561, + 0, + 0, + 22562, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22566, + 0, + 0, + 0, + 0, + 22567, + 22568, + 0, + 0, + 22575, + 0, + 22579, + 0, + 22582, + 22583, + 22585, + 0, + 0, + 0, + 0, + 0, + 22586, + 0, + 0, + 22587, + 0, + 0, + 22590, + 0, + 0, + 0, + 0, + 0, + 22591, + 0, + 22592, + 0, + 0, + 0, + 0, + 0, + 22593, + 0, + 22602, + 0, + 0, + 22604, + 0, + 0, + 22609, + 0, + 0, + 22618, + 0, + 0, + 0, + 0, + 0, + 0, + 22619, + 0, + 22624, + 22625, + 0, + 0, + 22638, + 0, + 0, + 0, + 0, + 0, + 22639, + 0, + 0, + 22640, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22644, + 0, + 22645, + 22647, + 0, + 0, + 0, + 0, + 22652, + 22653, + 0, + 0, + 0, + 22654, + 0, + 22655, + 0, + 0, + 0, + 22656, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22673, + 22675, + 22676, + 0, + 0, + 22678, + 22679, + 0, + 22691, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22693, + 0, + 0, + 22696, + 0, + 22699, + 22707, + 22708, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22718, + 0, + 22719, + 0, + 0, + 0, + 0, + 22723, + 0, + 0, + 0, + 22724, + 22725, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22726, + 22728, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22729, + 0, + 0, + 22731, + 0, + 0, + 0, + 0, + 22732, + 22735, + 22736, + 0, + 0, + 0, + 0, + 22739, + 0, + 22749, + 0, + 0, + 22751, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22758, + 0, + 0, + 0, + 0, + 0, + 22760, + 0, + 0, + 0, + 0, + 0, + 22764, + 22765, + 22766, + 0, + 22768, + 0, + 0, + 0, + 0, + 0, + 22769, + 22770, + 0, + 0, + 0, + 0, + 0, + 0, + 22771, + 0, + 0, + 22772, + 22775, + 0, + 22776, + 22777, + 22780, + 0, + 0, + 22782, + 22784, + 0, + 22787, + 0, + 22789, + 22796, + 0, + 0, + 0, + 0, + 0, + 22798, + 0, + 0, + 0, + 0, + 0, + 0, + 22802, + 0, + 22803, + 22804, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22805, + 0, + 0, + 22810, + 22811, + 22814, + 22816, + 0, + 22825, + 22826, + 0, + 22831, + 22833, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22834, + 0, + 22836, + 22838, + 0, + 22839, + 0, + 0, + 0, + 0, + 0, + 22840, + 0, + 22847, + 0, + 0, + 0, + 0, + 0, + 22856, + 22857, + 0, + 22858, + 22859, + 0, + 0, + 22862, + 0, + 0, + 22864, + 0, + 0, + 0, + 0, + 22865, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22866, + 0, + 22867, + 22868, + 0, + 0, + 0, + 0, + 22869, + 0, + 22871, + 0, + 22872, + 0, + 22873, + 22881, + 22882, + 22884, + 22885, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22886, + 22887, + 0, + 22894, + 0, + 22895, + 0, + 0, + 0, + 22900, + 0, + 22901, + 0, + 0, + 0, + 0, + 22904, + 0, + 0, + 0, + 0, + 22905, + 22907, + 0, + 0, + 0, + 22915, + 22917, + 0, + 0, + 22918, + 0, + 0, + 0, + 22920, + 0, + 0, + 0, + 22929, + 22930, + 0, + 0, + 0, + 22941, + 22942, + 0, + 0, + 0, + 22943, + 0, + 0, + 0, + 22944, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22946, + 0, + 22947, + 0, + 0, + 22954, + 0, + 22956, + 0, + 0, + 22962, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22963, + 0, + 0, + 22964, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 22965, + 0, + 22968, + 0, + 0, + 0, + 22969, + 0, + 0, + 0, + 0, + 0, + 22970, + 0, + 22971, + 0, + 0, + 0, + 0, + 0, + 22978, + 0, + 0, + 22979, + 0, + 22987, + 0, + 0, + 22989, + 0, + 0, + 0, + 0, + 0, + 0, + 22990, + 0, + 23005, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23006, + 23007, + 23008, + 0, + 0, + 23023, + 23024, + 23029, + 0, + 0, + 0, + 0, + 23030, + 0, + 0, + 0, + 0, + 0, + 23032, + 0, + 0, + 0, + 0, + 0, + 23035, + 0, + 0, + 0, + 0, + 23038, + 0, + 0, + 0, + 23048, + 0, + 23049, + 23052, + 23053, + 23060, + 23061, + 0, + 23063, + 0, + 0, + 0, + 0, + 23067, + 23068, + 0, + 0, + 0, + 23069, + 23073, + 0, + 0, + 0, + 23127, + 0, + 23128, + 0, + 0, + 0, + 0, + 0, + 23129, + 0, + 23138, + 23141, + 0, + 23149, + 0, + 0, + 23150, + 0, + 0, + 0, + 23152, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23154, + 0, + 0, + 0, + 0, + 23157, + 23159, + 23160, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23180, + 0, + 0, + 0, + 0, + 23181, + 0, + 0, + 23188, + 0, + 23189, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23195, + 0, + 0, + 23196, + 23199, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23202, + 0, + 23204, + 0, + 23207, + 0, + 23209, + 23210, + 0, + 0, + 0, + 0, + 0, + 0, + 23227, + 23229, + 0, + 0, + 23230, + 23234, + 23238, + 0, + 0, + 0, + 23245, + 23246, + 23248, + 0, + 0, + 0, + 0, + 23249, + 23254, + 0, + 0, + 0, + 23265, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23268, + 0, + 23276, + 0, + 0, + 0, + 0, + 23277, + 0, + 23297, + 0, + 23298, + 0, + 0, + 0, + 0, + 23299, + 0, + 23302, + 0, + 0, + 23303, + 23312, + 0, + 0, + 23314, + 0, + 23320, + 0, + 0, + 0, + 0, + 23324, + 0, + 23325, + 0, + 23328, + 0, + 23334, + 0, + 0, + 0, + 23337, + 0, + 0, + 0, + 0, + 23343, + 23344, + 23346, + 0, + 23348, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23353, + 0, + 0, + 0, + 0, + 23355, + 0, + 23356, + 23358, + 0, + 0, + 0, + 23359, + 23360, + 0, + 23361, + 0, + 23367, + 0, + 23369, + 0, + 0, + 23373, + 0, + 23378, + 23379, + 0, + 23382, + 23383, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23387, + 0, + 0, + 0, + 0, + 0, + 0, + 23388, + 23390, + 0, + 0, + 23393, + 23398, + 0, + 0, + 0, + 23399, + 0, + 0, + 0, + 23400, + 0, + 0, + 0, + 0, + 23401, + 0, + 0, + 0, + 23415, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23416, + 0, + 23422, + 0, + 23443, + 23444, + 0, + 0, + 0, + 0, + 23448, + 0, + 23454, + 0, + 0, + 0, + 0, + 0, + 0, + 23456, + 0, + 0, + 23458, + 23464, + 0, + 0, + 0, + 0, + 0, + 0, + 23465, + 0, + 0, + 0, + 23470, + 23471, + 0, + 0, + 23472, + 0, + 0, + 0, + 23473, + 23496, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23497, + 0, + 23499, + 0, + 0, + 23502, + 0, + 0, + 23503, + 0, + 0, + 23513, + 0, + 0, + 23515, + 0, + 0, + 0, + 23517, + 0, + 0, + 0, + 0, + 23518, + 23519, + 23521, + 23524, + 0, + 23525, + 23528, + 23539, + 0, + 0, + 0, + 0, + 0, + 23541, + 0, + 0, + 23544, + 0, + 0, + 23556, + 0, + 0, + 23557, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23559, + 0, + 23560, + 0, + 0, + 23561, + 0, + 0, + 23566, + 0, + 0, + 0, + 0, + 0, + 23568, + 23569, + 23570, + 0, + 0, + 0, + 0, + 23571, + 0, + 23574, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23575, + 0, + 23579, + 0, + 0, + 23581, + 0, + 0, + 0, + 0, + 0, + 0, + 23587, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23596, + 23598, + 0, + 0, + 0, + 0, + 23602, + 23606, + 0, + 0, + 23607, + 0, + 23608, + 0, + 0, + 0, + 23614, + 23616, + 0, + 0, + 0, + 0, + 0, + 23618, + 0, + 0, + 23619, + 0, + 0, + 0, + 0, + 23621, + 23626, + 0, + 23627, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23629, + 0, + 23630, + 0, + 0, + 0, + 0, + 23634, + 0, + 23636, + 0, + 0, + 0, + 0, + 0, + 0, + 23638, + 0, + 0, + 0, + 0, + 23640, + 23667, + 0, + 23669, + 0, + 0, + 0, + 23681, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23682, + 0, + 23683, + 0, + 0, + 0, + 0, + 0, + 23684, + 0, + 0, + 0, + 23685, + 23689, + 0, + 23693, + 23694, + 23700, + 0, + 23702, + 0, + 23709, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23712, + 0, + 0, + 0, + 0, + 0, + 23714, + 0, + 0, + 23715, + 0, + 0, + 0, + 0, + 23718, + 0, + 0, + 23720, + 0, + 0, + 0, + 0, + 23722, + 0, + 0, + 0, + 23726, + 23729, + 0, + 23741, + 23746, + 0, + 23748, + 0, + 0, + 0, + 0, + 23749, + 0, + 0, + 0, + 0, + 0, + 23750, + 0, + 0, + 0, + 0, + 23751, + 0, + 23753, + 0, + 0, + 0, + 0, + 23757, + 23765, + 0, + 0, + 0, + 23770, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23771, + 0, + 23772, + 23781, + 0, + 0, + 23796, + 0, + 0, + 0, + 0, + 23798, + 0, + 23799, + 0, + 0, + 0, + 23802, + 0, + 0, + 23806, + 0, + 23807, + 0, + 0, + 23808, + 0, + 23809, + 0, + 23819, + 0, + 0, + 0, + 23821, + 0, + 23827, + 0, + 0, + 0, + 23829, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23830, + 0, + 0, + 0, + 0, + 0, + 0, + 23832, + 23833, + 23834, + 23835, + 0, + 0, + 0, + 0, + 23837, + 23838, + 0, + 0, + 0, + 0, + 0, + 23846, + 0, + 0, + 0, + 0, + 0, + 0, + 23847, + 0, + 0, + 0, + 0, + 0, + 23879, + 23881, + 0, + 0, + 23882, + 23883, + 23895, + 0, + 23899, + 0, + 0, + 0, + 0, + 23901, + 0, + 0, + 0, + 0, + 0, + 0, + 23902, + 0, + 0, + 0, + 0, + 0, + 23903, + 23905, + 0, + 23906, + 0, + 23907, + 23918, + 23919, + 23920, + 0, + 23922, + 0, + 23924, + 0, + 23927, + 0, + 23934, + 0, + 23937, + 23941, + 0, + 23942, + 23946, + 0, + 0, + 0, + 0, + 0, + 23955, + 23956, + 23958, + 0, + 0, + 0, + 0, + 0, + 0, + 23959, + 0, + 23962, + 23965, + 0, + 23966, + 0, + 0, + 0, + 0, + 23967, + 23968, + 0, + 0, + 23973, + 0, + 0, + 23974, + 0, + 0, + 0, + 0, + 23975, + 0, + 23976, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23977, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23980, + 0, + 0, + 23984, + 0, + 23985, + 0, + 0, + 23987, + 0, + 0, + 23988, + 23990, + 23991, + 0, + 0, + 0, + 0, + 0, + 0, + 23992, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23994, + 0, + 0, + 0, + 23998, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 23999, + 0, + 0, + 24003, + 0, + 24004, + 0, + 24006, + 0, + 0, + 0, + 24007, + 0, + 0, + 24008, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24009, + 0, + 0, + 24010, + 0, + 0, + 24011, + 0, + 0, + 24013, + 24014, + 0, + 0, + 24015, + 24016, + 24027, + 0, + 24028, + 24029, + 0, + 24030, + 0, + 0, + 0, + 0, + 0, + 24033, + 24034, + 0, + 24035, + 0, + 0, + 24036, + 0, + 0, + 24044, + 0, + 24048, + 24049, + 24063, + 24067, + 0, + 24068, + 24070, + 0, + 0, + 24071, + 24078, + 24087, + 0, + 24090, + 0, + 0, + 0, + 24095, + 0, + 24098, + 24101, + 24104, + 24106, + 0, + 24107, + 0, + 0, + 0, + 24108, + 0, + 0, + 0, + 0, + 24110, + 24111, + 0, + 24113, + 0, + 0, + 24115, + 24120, + 0, + 0, + 0, + 0, + 0, + 0, + 24124, + 0, + 24125, + 0, + 24126, + 0, + 24127, + 0, + 0, + 0, + 0, + 0, + 24135, + 0, + 0, + 24136, + 0, + 24137, + 24142, + 0, + 0, + 0, + 24146, + 0, + 0, + 24147, + 24149, + 24154, + 0, + 24163, + 0, + 0, + 0, + 24165, + 24166, + 24167, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24169, + 24170, + 24175, + 0, + 0, + 0, + 24178, + 0, + 0, + 24179, + 0, + 0, + 24181, + 0, + 24184, + 24197, + 0, + 24201, + 24204, + 0, + 0, + 0, + 0, + 0, + 0, + 24206, + 24212, + 24220, + 0, + 0, + 0, + 24224, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24226, + 0, + 24234, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24235, + 0, + 24236, + 0, + 0, + 0, + 0, + 0, + 24239, + 24240, + 24241, + 0, + 0, + 24248, + 0, + 0, + 24249, + 0, + 24251, + 0, + 0, + 0, + 0, + 0, + 0, + 24253, + 0, + 24268, + 0, + 0, + 0, + 24269, + 0, + 24271, + 24272, + 0, + 0, + 0, + 0, + 24273, + 0, + 0, + 24274, + 0, + 0, + 24279, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24280, + 0, + 24293, + 24294, + 0, + 0, + 0, + 0, + 0, + 0, + 24296, + 0, + 0, + 24323, + 0, + 0, + 0, + 24329, + 24330, + 24331, + 24339, + 0, + 24351, + 0, + 0, + 24369, + 24370, + 0, + 0, + 0, + 24371, + 0, + 0, + 0, + 0, + 24372, + 24373, + 24374, + 0, + 0, + 0, + 0, + 0, + 24378, + 0, + 0, + 0, + 0, + 24379, + 0, + 24381, + 0, + 24383, + 24389, + 0, + 24390, + 0, + 0, + 24394, + 24395, + 24400, + 0, + 0, + 0, + 24401, + 24402, + 0, + 24406, + 0, + 0, + 0, + 24411, + 0, + 0, + 0, + 24415, + 0, + 24416, + 0, + 0, + 0, + 0, + 0, + 24417, + 0, + 24419, + 0, + 24422, + 0, + 24423, + 24428, + 0, + 24435, + 0, + 0, + 0, + 24439, + 0, + 0, + 0, + 24440, + 24442, + 24446, + 0, + 0, + 0, + 24447, + 24448, + 24449, + 24452, + 0, + 0, + 0, + 0, + 24453, + 24457, + 0, + 0, + 24458, + 24459, + 24460, + 0, + 24465, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24470, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24471, + 0, + 24473, + 24474, + 24475, + 24476, + 0, + 24478, + 0, + 0, + 0, + 0, + 24480, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24481, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24482, + 24485, + 0, + 0, + 0, + 0, + 24486, + 0, + 0, + 0, + 24488, + 0, + 0, + 0, + 24494, + 0, + 0, + 0, + 0, + 24497, + 0, + 0, + 24498, + 0, + 0, + 0, + 24499, + 24506, + 0, + 0, + 0, + 24507, + 0, + 0, + 24511, + 0, + 0, + 24513, + 24514, + 0, + 0, + 0, + 0, + 0, + 24517, + 0, + 24518, + 0, + 24520, + 0, + 24521, + 24524, + 24525, + 0, + 0, + 0, + 0, + 0, + 24527, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24528, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24537, + 24539, + 0, + 24540, + 0, + 0, + 0, + 24548, + 0, + 0, + 0, + 0, + 0, + 24549, + 24550, + 0, + 0, + 0, + 24553, + 24554, + 0, + 24555, + 0, + 24556, + 0, + 24558, + 0, + 0, + 0, + 0, + 0, + 24560, + 0, + 0, + 0, + 24561, + 0, + 0, + 0, + 0, + 0, + 24562, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24567, + 0, + 0, + 0, + 0, + 0, + 24569, + 0, + 0, + 0, + 24574, + 0, + 24575, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24577, + 24581, + 0, + 24584, + 0, + 0, + 0, + 0, + 0, + 24585, + 0, + 0, + 0, + 0, + 0, + 24586, + 0, + 0, + 24587, + 0, + 24588, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24590, + 24591, + 0, + 0, + 0, + 0, + 24592, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24594, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24596, + 24597, + 0, + 0, + 0, + 0, + 24602, + 24603, + 0, + 0, + 0, + 0, + 24604, + 0, + 0, + 24605, + 0, + 24610, + 0, + 0, + 24611, + 0, + 0, + 0, + 0, + 24612, + 24615, + 24616, + 24624, + 0, + 0, + 0, + 24627, + 0, + 24638, + 24639, + 0, + 0, + 0, + 0, + 24640, + 0, + 0, + 0, + 24655, + 24656, + 24657, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24662, + 0, + 24663, + 24664, + 0, + 0, + 0, + 0, + 0, + 24665, + 0, + 0, + 0, + 0, + 24667, + 0, + 0, + 0, + 0, + 0, + 0, + 24668, + 24669, + 0, + 24670, + 24674, + 0, + 0, + 0, + 24675, + 0, + 24678, + 0, + 0, + 24679, + 0, + 0, + 0, + 24681, + 0, + 24683, + 0, + 0, + 0, + 0, + 24684, + 0, + 24685, + 0, + 0, + 24686, + 0, + 0, + 24688, + 24689, + 0, + 0, + 0, + 0, + 24690, + 24691, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24697, + 0, + 24698, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24709, + 0, + 0, + 0, + 0, + 0, + 24710, + 0, + 24712, + 0, + 0, + 0, + 0, + 0, + 0, + 24713, + 24714, + 0, + 24715, + 0, + 24716, + 24718, + 0, + 24719, + 0, + 0, + 0, + 0, + 24720, + 0, + 0, + 24725, + 0, + 0, + 24738, + 0, + 24749, + 24750, + 0, + 0, + 0, + 24752, + 0, + 0, + 0, + 24753, + 0, + 0, + 0, + 24758, + 0, + 0, + 0, + 0, + 0, + 24762, + 0, + 24763, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24764, + 0, + 0, + 0, + 0, + 0, + 24765, + 24767, + 24768, + 0, + 24772, + 0, + 0, + 0, + 0, + 24773, + 0, + 0, + 0, + 0, + 24777, + 0, + 0, + 0, + 0, + 0, + 24785, + 0, + 24786, + 24788, + 0, + 0, + 0, + 24789, + 0, + 0, + 0, + 0, + 24794, + 24798, + 0, + 24799, + 24800, + 0, + 0, + 0, + 24803, + 0, + 24804, + 24806, + 0, + 24807, + 0, + 0, + 0, + 24810, + 0, + 0, + 0, + 0, + 0, + 0, + 24827, + 24828, + 0, + 24835, + 0, + 0, + 0, + 0, + 0, + 0, + 24836, + 0, + 0, + 0, + 0, + 0, + 24839, + 0, + 24843, + 24844, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24847, + 0, + 0, + 24848, + 0, + 0, + 0, + 0, + 0, + 0, + 24849, + 0, + 24850, + 24851, + 0, + 0, + 0, + 24852, + 0, + 24853, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24854, + 0, + 24855, + 0, + 0, + 24868, + 0, + 0, + 0, + 24883, + 0, + 0, + 0, + 24884, + 0, + 24895, + 24897, + 0, + 0, + 0, + 0, + 0, + 24899, + 0, + 0, + 0, + 0, + 0, + 24900, + 0, + 24913, + 0, + 0, + 0, + 0, + 0, + 0, + 24914, + 0, + 0, + 24917, + 24930, + 24931, + 0, + 0, + 0, + 24932, + 0, + 0, + 24939, + 0, + 0, + 24942, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 24945, + 24950, + 0, + 24951, + 0, + 0, + 24953, + 0, + 0, + 0, + 24954, + 0, + 24959, + 0, + 0, + 0, + 24961, + 0, + 0, + 24962, + 0, + 24964, + 24968, + 24970, + 24972, + 0, + 0, + 0, + 0, + 0, + 24976, + 0, + 0, + 0, + 24977, + 0, + 24982, + 0, + 0, + 24983, + 0, + 0, + 24984, + 0, + 0, + 0, + 24993, + 0, + 0, + 0, + 24994, + 0, + 0, + 25001, + 0, + 0, + 0, + 25003, + 0, + 0, + 25018, + 0, + 0, + 25023, + 0, + 0, + 0, + 25034, + 0, + 0, + 25035, + 25036, + 0, + 25037, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25039, + 0, + 0, + 0, + 0, + 0, + 25040, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25042, + 0, + 0, + 25043, + 25045, + 0, + 0, + 0, + 0, + 0, + 0, + 25049, + 0, + 0, + 25051, + 0, + 25052, + 25053, + 0, + 0, + 25054, + 0, + 0, + 0, + 25055, + 0, + 0, + 0, + 0, + 25057, + 25059, + 0, + 0, + 25060, + 25064, + 0, + 25065, + 25069, + 25070, + 0, + 0, + 0, + 0, + 25072, + 0, + 25073, + 0, + 25090, + 0, + 0, + 25092, + 25093, + 25101, + 0, + 0, + 0, + 0, + 0, + 0, + 25105, + 25108, + 0, + 0, + 25113, + 0, + 0, + 25115, + 25116, + 0, + 0, + 0, + 0, + 0, + 0, + 25117, + 0, + 0, + 0, + 25120, + 25121, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25125, + 0, + 0, + 0, + 25126, + 0, + 25130, + 25134, + 0, + 25139, + 0, + 25143, + 0, + 0, + 0, + 25151, + 0, + 25161, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25163, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25174, + 0, + 25175, + 0, + 25207, + 0, + 0, + 0, + 25209, + 0, + 0, + 0, + 0, + 25213, + 0, + 25219, + 0, + 25223, + 0, + 25225, + 0, + 0, + 0, + 25227, + 0, + 0, + 0, + 25228, + 0, + 0, + 0, + 25229, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25231, + 25233, + 0, + 0, + 0, + 0, + 25237, + 25239, + 0, + 0, + 0, + 25243, + 0, + 0, + 0, + 25252, + 0, + 25257, + 25258, + 0, + 0, + 0, + 0, + 25260, + 25265, + 0, + 25268, + 0, + 0, + 25273, + 25324, + 0, + 25325, + 0, + 25326, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25327, + 0, + 0, + 0, + 0, + 0, + 25328, + 0, + 0, + 0, + 0, + 0, + 0, + 25332, + 0, + 0, + 0, + 25333, + 0, + 0, + 0, + 25336, + 25337, + 25338, + 0, + 0, + 25343, + 0, + 25350, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25352, + 0, + 25354, + 0, + 25375, + 0, + 25379, + 0, + 0, + 0, + 0, + 25384, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25386, + 0, + 25388, + 0, + 25390, + 0, + 0, + 25399, + 0, + 0, + 25401, + 0, + 0, + 0, + 25402, + 0, + 0, + 0, + 25407, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25413, + 25415, + 0, + 0, + 25417, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25419, + 0, + 0, + 0, + 25421, + 0, + 0, + 0, + 25424, + 0, + 0, + 0, + 0, + 25433, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25435, + 0, + 0, + 0, + 0, + 0, + 0, + 25436, + 0, + 0, + 0, + 25437, + 0, + 0, + 25440, + 0, + 0, + 0, + 0, + 0, + 0, + 25442, + 0, + 0, + 25443, + 0, + 25446, + 0, + 0, + 25449, + 0, + 0, + 0, + 25450, + 0, + 0, + 0, + 0, + 25452, + 0, + 25453, + 25454, + 25455, + 0, + 0, + 0, + 25456, + 0, + 25457, + 0, + 0, + 0, + 25459, + 0, + 25461, + 0, + 25468, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25469, + 0, + 0, + 0, + 0, + 0, + 25471, + 0, + 0, + 0, + 0, + 0, + 25474, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25475, + 0, + 0, + 0, + 0, + 25477, + 0, + 0, + 0, + 0, + 25483, + 0, + 0, + 0, + 0, + 0, + 25484, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25485, + 0, + 25497, + 0, + 0, + 25498, + 0, + 25504, + 0, + 25510, + 0, + 25512, + 0, + 0, + 25513, + 25514, + 0, + 0, + 0, + 0, + 0, + 0, + 25517, + 25518, + 25519, + 0, + 25520, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25521, + 0, + 25522, + 25527, + 25534, + 0, + 25536, + 0, + 25537, + 0, + 0, + 25548, + 25550, + 0, + 0, + 25551, + 0, + 25552, + 0, + 0, + 0, + 0, + 0, + 25554, + 0, + 25555, + 0, + 25556, + 25557, + 25568, + 0, + 0, + 0, + 25570, + 25571, + 0, + 0, + 0, + 0, + 0, + 0, + 25574, + 0, + 0, + 0, + 0, + 25579, + 0, + 0, + 0, + 25581, + 0, + 0, + 0, + 25582, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25588, + 0, + 0, + 0, + 0, + 25589, + 0, + 0, + 0, + 0, + 25590, + 0, + 25591, + 25592, + 25593, + 0, + 25594, + 0, + 0, + 0, + 25596, + 0, + 25597, + 25615, + 0, + 0, + 0, + 0, + 0, + 25618, + 0, + 0, + 0, + 0, + 25619, + 25623, + 0, + 0, + 25629, + 0, + 0, + 25631, + 0, + 0, + 0, + 25635, + 25636, + 0, + 0, + 25649, + 0, + 0, + 0, + 0, + 25654, + 0, + 0, + 0, + 25661, + 25663, + 0, + 0, + 25671, + 0, + 0, + 25678, + 25698, + 0, + 25699, + 25702, + 25703, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25704, + 0, + 0, + 0, + 0, + 0, + 25706, + 0, + 0, + 25710, + 0, + 25711, + 0, + 25712, + 0, + 25715, + 25716, + 25717, + 0, + 0, + 25718, + 25728, + 25732, + 0, + 0, + 0, + 25734, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25737, + 0, + 0, + 25739, + 0, + 0, + 0, + 25740, + 0, + 25741, + 25745, + 0, + 25746, + 0, + 25748, + 25772, + 25778, + 0, + 0, + 0, + 0, + 0, + 25780, + 0, + 0, + 0, + 0, + 25781, + 0, + 25782, + 25784, + 25785, + 0, + 0, + 0, + 25789, + 0, + 0, + 0, + 0, + 0, + 0, + 25797, + 25801, + 0, + 0, + 0, + 25808, + 25809, + 0, + 0, + 25811, + 25814, + 25815, + 0, + 0, + 25817, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25820, + 0, + 0, + 0, + 0, + 25832, + 25833, + 0, + 0, + 0, + 25846, + 0, + 0, + 0, + 25847, + 25848, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25849, + 25850, + 0, + 0, + 25851, + 0, + 0, + 25852, + 0, + 25862, + 0, + 0, + 0, + 25863, + 25865, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25867, + 25868, + 0, + 25869, + 25874, + 0, + 25875, + 0, + 25876, + 25877, + 0, + 0, + 0, + 0, + 25878, + 25902, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25903, + 25904, + 25905, + 0, + 0, + 0, + 25908, + 25909, + 0, + 0, + 0, + 0, + 25910, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25912, + 0, + 25913, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25914, + 0, + 0, + 25916, + 0, + 0, + 0, + 0, + 0, + 25917, + 25927, + 0, + 0, + 0, + 0, + 25928, + 0, + 0, + 25930, + 0, + 0, + 0, + 25933, + 0, + 0, + 25938, + 25942, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25945, + 0, + 25950, + 0, + 25956, + 0, + 0, + 25961, + 25962, + 0, + 0, + 25963, + 0, + 25964, + 25965, + 25966, + 0, + 0, + 0, + 0, + 0, + 25967, + 0, + 0, + 0, + 0, + 25968, + 0, + 0, + 0, + 25969, + 25971, + 0, + 0, + 0, + 0, + 0, + 25973, + 25975, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25978, + 0, + 25981, + 0, + 0, + 0, + 25982, + 0, + 0, + 0, + 25984, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 25993, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26002, + 0, + 0, + 0, + 26005, + 0, + 0, + 0, + 26006, + 26007, + 0, + 0, + 26014, + 26015, + 26016, + 0, + 0, + 0, + 0, + 0, + 0, + 26017, + 26018, + 26020, + 0, + 26022, + 26023, + 0, + 0, + 0, + 26024, + 26028, + 0, + 26029, + 26033, + 26034, + 26044, + 0, + 0, + 0, + 0, + 0, + 26046, + 0, + 0, + 26047, + 0, + 0, + 26049, + 0, + 26050, + 0, + 26051, + 0, + 0, + 0, + 0, + 0, + 26053, + 0, + 0, + 0, + 0, + 26054, + 26059, + 0, + 0, + 0, + 0, + 0, + 0, + 26060, + 0, + 26066, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26067, + 0, + 26069, + 0, + 0, + 26071, + 0, + 0, + 0, + 26073, + 0, + 26074, + 26077, + 0, + 0, + 0, + 0, + 26078, + 0, + 0, + 0, + 26079, + 0, + 26090, + 0, + 0, + 26094, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26095, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26096, + 26101, + 0, + 26107, + 26122, + 0, + 26124, + 0, + 0, + 26125, + 0, + 0, + 0, + 0, + 0, + 0, + 26136, + 26141, + 26155, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26164, + 26166, + 0, + 0, + 0, + 26167, + 0, + 26170, + 26171, + 0, + 0, + 26172, + 0, + 0, + 26174, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26175, + 0, + 0, + 0, + 26176, + 26177, + 0, + 26321, + 26322, + 0, + 26323, + 0, + 0, + 26324, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26325, + 0, + 26331, + 0, + 0, + 0, + 0, + 0, + 0, + 26335, + 0, + 0, + 0, + 26350, + 0, + 0, + 0, + 26379, + 0, + 0, + 26382, + 26383, + 26385, + 0, + 0, + 26392, + 26406, + 0, + 0, + 0, + 0, + 26411, + 0, + 0, + 0, + 0, + 0, + 26412, + 0, + 0, + 26420, + 0, + 0, + 26423, + 0, + 26424, + 26426, + 26432, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26435, + 0, + 26436, + 0, + 0, + 0, + 0, + 0, + 26441, + 0, + 26444, + 0, + 0, + 0, + 26446, + 0, + 0, + 0, + 0, + 26447, + 0, + 0, + 0, + 0, + 26449, + 0, + 26450, + 26452, + 0, + 26453, + 26454, + 0, + 0, + 0, + 26455, + 0, + 0, + 0, + 26456, + 0, + 0, + 26458, + 0, + 0, + 26460, + 0, + 26463, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26464, + 26470, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26473, + 0, + 0, + 26474, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26475, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26477, + 0, + 26485, + 0, + 0, + 26486, + 0, + 26487, + 0, + 0, + 26488, + 26493, + 26494, + 0, + 0, + 26495, + 0, + 26497, + 26504, + 26506, + 0, + 0, + 0, + 0, + 0, + 26507, + 0, + 0, + 0, + 0, + 0, + 26509, + 0, + 0, + 26510, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26512, + 0, + 26513, + 26515, + 0, + 0, + 0, + 26518, + 0, + 0, + 0, + 26519, + 0, + 26524, + 26526, + 0, + 0, + 0, + 26527, + 0, + 26532, + 0, + 26533, + 26537, + 26558, + 0, + 0, + 0, + 26559, + 0, + 0, + 0, + 26571, + 0, + 0, + 26573, + 0, + 26588, + 0, + 26593, + 0, + 0, + 0, + 0, + 0, + 0, + 26603, + 0, + 26604, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26606, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26607, + 26609, + 26611, + 26614, + 0, + 0, + 0, + 26616, + 26620, + 0, + 26621, + 0, + 0, + 0, + 0, + 0, + 26627, + 0, + 26629, + 0, + 0, + 26630, + 0, + 0, + 26632, + 26643, + 0, + 0, + 0, + 26644, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26646, + 26647, + 0, + 0, + 0, + 26650, + 0, + 0, + 26656, + 0, + 0, + 0, + 0, + 26663, + 26670, + 26671, + 0, + 0, + 0, + 26685, + 26686, + 26687, + 0, + 26689, + 0, + 0, + 0, + 0, + 26744, + 0, + 26745, + 0, + 26747, + 26748, + 0, + 26749, + 26750, + 26751, + 0, + 0, + 0, + 0, + 26752, + 26755, + 0, + 0, + 0, + 26756, + 26769, + 0, + 0, + 0, + 26774, + 0, + 0, + 0, + 0, + 0, + 26775, + 0, + 26777, + 26778, + 0, + 26786, + 0, + 0, + 0, + 26787, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26788, + 0, + 0, + 26789, + 0, + 0, + 0, + 0, + 0, + 26791, + 0, + 26792, + 26793, + 0, + 0, + 0, + 26794, + 0, + 26797, + 26798, + 0, + 0, + 0, + 26800, + 0, + 0, + 26803, + 0, + 26804, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26805, + 0, + 0, + 26808, + 0, + 0, + 26809, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26812, + 0, + 26825, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26826, + 0, + 0, + 26827, + 26829, + 26834, + 0, + 0, + 0, + 0, + 26835, + 0, + 0, + 26849, + 0, + 26851, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26852, + 0, + 26853, + 26857, + 0, + 26858, + 0, + 26859, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26876, + 0, + 26878, + 26882, + 26883, + 0, + 0, + 0, + 0, + 26890, + 26894, + 0, + 0, + 0, + 0, + 26895, + 26896, + 0, + 0, + 0, + 0, + 0, + 26900, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26911, + 26913, + 26914, + 26915, + 26916, + 26919, + 0, + 0, + 0, + 26921, + 26922, + 0, + 0, + 26925, + 0, + 0, + 0, + 26928, + 0, + 0, + 26929, + 26930, + 0, + 0, + 0, + 26931, + 0, + 26932, + 0, + 0, + 0, + 0, + 0, + 26933, + 0, + 0, + 0, + 0, + 0, + 0, + 26937, + 0, + 0, + 26943, + 0, + 0, + 26944, + 0, + 0, + 0, + 26946, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26956, + 0, + 26958, + 0, + 0, + 26963, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 26965, + 0, + 26969, + 26970, + 26972, + 0, + 0, + 0, + 0, + 0, + 26973, + 0, + 26974, + 0, + 26978, + 0, + 26980, + 0, + 0, + 0, + 0, + 0, + 0, + 26982, + 0, + 26986, + 26987, + 0, + 26990, + 0, + 0, + 0, + 0, + 27003, + 27006, + 0, + 0, + 27007, + 27010, + 27012, + 27013, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27014, + 27015, + 27018, + 0, + 27019, + 0, + 0, + 0, + 0, + 0, + 27025, + 0, + 0, + 0, + 27026, + 0, + 0, + 0, + 0, + 27029, + 27030, + 27031, + 27034, + 0, + 0, + 27036, + 27037, + 0, + 0, + 0, + 27038, + 27042, + 0, + 0, + 0, + 27044, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27045, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27046, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27047, + 27049, + 0, + 27050, + 0, + 0, + 0, + 27051, + 27052, + 0, + 27055, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27056, + 27058, + 27059, + 0, + 27061, + 0, + 27064, + 0, + 0, + 0, + 0, + 0, + 27069, + 0, + 0, + 27070, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27072, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27076, + 0, + 0, + 0, + 0, + 0, + 27078, + 0, + 27079, + 0, + 0, + 0, + 27081, + 0, + 0, + 0, + 0, + 0, + 0, + 27082, + 0, + 27083, + 27086, + 0, + 0, + 0, + 0, + 27087, + 0, + 0, + 0, + 0, + 0, + 27088, + 27090, + 0, + 27094, + 0, + 0, + 27095, + 0, + 27099, + 27102, + 0, + 0, + 0, + 27103, + 0, + 0, + 0, + 0, + 27105, + 0, + 0, + 0, + 27106, + 0, + 0, + 0, + 0, + 0, + 0, + 27107, + 0, + 0, + 0, + 0, + 27108, + 27117, + 0, + 0, + 0, + 0, + 27118, + 0, + 0, + 27124, + 0, + 27126, + 0, + 0, + 27130, + 27131, + 0, + 0, + 0, + 0, + 0, + 0, + 27147, + 0, + 0, + 0, + 0, + 27148, + 27149, + 0, + 0, + 0, + 0, + 27150, + 27151, + 0, + 27152, + 0, + 27159, + 0, + 0, + 0, + 27164, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27175, + 0, + 27189, + 0, + 0, + 27191, + 0, + 27193, + 0, + 27195, + 0, + 27198, + 0, + 0, + 0, + 0, + 0, + 27200, + 0, + 0, + 0, + 0, + 27202, + 0, + 0, + 0, + 0, + 27203, + 0, + 0, + 27204, + 0, + 0, + 27206, + 0, + 27207, + 0, + 0, + 0, + 0, + 27209, + 0, + 0, + 0, + 27213, + 0, + 0, + 27216, + 27219, + 27220, + 27222, + 27223, + 0, + 27224, + 0, + 27225, + 27226, + 0, + 0, + 27233, + 0, + 0, + 0, + 0, + 27235, + 0, + 27237, + 0, + 27238, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27239, + 0, + 27242, + 27243, + 0, + 27250, + 0, + 0, + 0, + 27251, + 0, + 27253, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27254, + 27255, + 27258, + 0, + 0, + 0, + 27259, + 0, + 0, + 0, + 0, + 0, + 0, + 27267, + 0, + 27276, + 27278, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27296, + 27297, + 27301, + 0, + 0, + 0, + 0, + 0, + 0, + 27302, + 0, + 0, + 0, + 0, + 0, + 0, + 27312, + 27313, + 0, + 0, + 0, + 0, + 0, + 27318, + 0, + 27320, + 0, + 27329, + 0, + 27330, + 27331, + 0, + 27332, + 0, + 0, + 0, + 0, + 27340, + 0, + 0, + 0, + 27348, + 0, + 0, + 0, + 0, + 0, + 0, + 27350, + 0, + 27351, + 0, + 0, + 0, + 0, + 27355, + 0, + 0, + 27358, + 27359, + 27361, + 0, + 0, + 0, + 27365, + 0, + 27367, + 0, + 27376, + 27378, + 0, + 0, + 27379, + 0, + 0, + 0, + 0, + 0, + 0, + 27396, + 0, + 27397, + 27404, + 0, + 0, + 0, + 0, + 0, + 27408, + 0, + 0, + 0, + 0, + 27453, + 0, + 0, + 0, + 27456, + 0, + 0, + 0, + 27458, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27459, + 0, + 0, + 0, + 27460, + 0, + 0, + 27461, + 0, + 27465, + 27467, + 0, + 0, + 27469, + 0, + 27470, + 0, + 27471, + 0, + 27477, + 27482, + 0, + 0, + 0, + 0, + 0, + 0, + 27484, + 0, + 0, + 0, + 0, + 0, + 0, + 27485, + 0, + 0, + 0, + 0, + 0, + 27493, + 0, + 27494, + 27502, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27511, + 27532, + 0, + 0, + 0, + 27533, + 27545, + 0, + 0, + 0, + 27546, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27547, + 0, + 0, + 27549, + 27550, + 0, + 27551, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27555, + 0, + 0, + 27571, + 0, + 27573, + 27574, + 27575, + 27577, + 0, + 27578, + 0, + 0, + 27579, + 27585, + 0, + 0, + 0, + 0, + 0, + 27586, + 0, + 0, + 27588, + 27589, + 0, + 0, + 0, + 0, + 27596, + 0, + 0, + 27600, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27608, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27610, + 0, + 0, + 0, + 27618, + 0, + 0, + 27620, + 0, + 0, + 0, + 27631, + 0, + 0, + 27632, + 27634, + 0, + 27636, + 27638, + 0, + 0, + 0, + 27643, + 0, + 27644, + 27649, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27651, + 27660, + 0, + 27661, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27662, + 0, + 0, + 27664, + 0, + 27665, + 0, + 0, + 0, + 27669, + 0, + 27671, + 0, + 0, + 0, + 27673, + 27674, + 0, + 0, + 0, + 27682, + 0, + 0, + 0, + 27711, + 0, + 27712, + 27713, + 27719, + 27720, + 0, + 0, + 27728, + 0, + 27729, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27731, + 0, + 0, + 27732, + 0, + 27733, + 0, + 27738, + 0, + 0, + 0, + 27742, + 0, + 0, + 0, + 27743, + 27744, + 0, + 0, + 0, + 0, + 0, + 0, + 27745, + 27746, + 0, + 0, + 0, + 27747, + 27748, + 27751, + 27752, + 0, + 0, + 0, + 27768, + 27770, + 0, + 0, + 0, + 27774, + 27775, + 0, + 27776, + 27777, + 0, + 0, + 27781, + 0, + 27784, + 0, + 27786, + 0, + 0, + 27791, + 0, + 27792, + 27793, + 27804, + 0, + 27812, + 27813, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27814, + 0, + 27825, + 0, + 27827, + 0, + 0, + 0, + 0, + 27828, + 27861, + 27862, + 0, + 0, + 0, + 27864, + 0, + 0, + 0, + 27865, + 27884, + 0, + 27889, + 0, + 0, + 0, + 0, + 0, + 27890, + 0, + 27891, + 0, + 0, + 0, + 27892, + 0, + 0, + 0, + 0, + 0, + 27897, + 27898, + 0, + 0, + 27899, + 0, + 0, + 0, + 27901, + 27905, + 0, + 0, + 27920, + 0, + 0, + 27921, + 0, + 27922, + 0, + 0, + 0, + 27931, + 27934, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27941, + 0, + 27942, + 0, + 27945, + 0, + 27947, + 27954, + 0, + 0, + 0, + 0, + 27960, + 27963, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 27964, + 27965, + 0, + 0, + 0, + 27967, + 0, + 27969, + 27975, + 0, + 27976, + 27977, + 0, + 27981, + 0, + 27983, + 28051, + 28052, + 0, + 0, + 0, + 0, + 0, + 28056, + 0, + 0, + 0, + 0, + 0, + 0, + 28058, + 28059, + 0, + 0, + 28061, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28063, + 0, + 0, + 0, + 0, + 0, + 0, + 28066, + 0, + 0, + 0, + 0, + 0, + 0, + 28069, + 28070, + 28072, + 0, + 28073, + 0, + 0, + 28074, + 0, + 0, + 0, + 0, + 28075, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28078, + 0, + 0, + 0, + 0, + 28085, + 0, + 0, + 0, + 0, + 28086, + 0, + 0, + 0, + 0, + 0, + 0, + 28088, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28090, + 0, + 28097, + 28114, + 28115, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28116, + 0, + 0, + 0, + 0, + 0, + 28118, + 0, + 28129, + 0, + 28131, + 0, + 0, + 28135, + 0, + 0, + 0, + 28140, + 28141, + 0, + 0, + 0, + 28146, + 0, + 0, + 0, + 0, + 28152, + 0, + 0, + 0, + 0, + 28155, + 28157, + 28161, + 0, + 0, + 0, + 0, + 28166, + 0, + 28167, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28172, + 0, + 0, + 0, + 0, + 0, + 0, + 28173, + 0, + 0, + 28175, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28178, + 28188, + 0, + 28190, + 0, + 0, + 0, + 0, + 0, + 28191, + 0, + 28193, + 28206, + 0, + 0, + 28207, + 28209, + 0, + 28211, + 0, + 28213, + 0, + 0, + 0, + 28215, + 28216, + 28217, + 0, + 28222, + 0, + 28223, + 28225, + 0, + 0, + 0, + 28226, + 0, + 28227, + 28229, + 28232, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28235, + 0, + 28241, + 0, + 0, + 28242, + 0, + 0, + 0, + 0, + 28243, + 0, + 0, + 0, + 28245, + 0, + 0, + 0, + 28248, + 28250, + 0, + 28251, + 28252, + 0, + 0, + 0, + 0, + 0, + 0, + 28253, + 0, + 0, + 28254, + 28255, + 0, + 0, + 28256, + 0, + 0, + 28258, + 0, + 0, + 0, + 0, + 0, + 28259, + 0, + 0, + 28260, + 0, + 0, + 28261, + 0, + 0, + 0, + 0, + 28262, + 28263, + 0, + 0, + 28264, + 0, + 0, + 0, + 28266, + 0, + 28268, + 28269, + 0, + 28270, + 28272, + 28274, + 0, + 28277, + 28278, + 0, + 0, + 0, + 28279, + 0, + 28280, + 28281, + 28283, + 0, + 28292, + 0, + 28294, + 0, + 28297, + 0, + 0, + 0, + 0, + 28299, + 0, + 0, + 0, + 0, + 0, + 28300, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28301, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28302, + 28303, + 0, + 0, + 0, + 0, + 28304, + 0, + 0, + 28305, + 0, + 28312, + 0, + 28313, + 28314, + 0, + 0, + 0, + 0, + 0, + 0, + 28315, + 0, + 0, + 0, + 28320, + 28321, + 0, + 0, + 28328, + 0, + 0, + 0, + 28329, + 28338, + 0, + 28339, + 0, + 0, + 28344, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28347, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28348, + 0, + 0, + 0, + 0, + 0, + 28411, + 0, + 28412, + 28413, + 0, + 28416, + 0, + 0, + 0, + 28420, + 0, + 0, + 0, + 0, + 0, + 28421, + 0, + 0, + 0, + 0, + 28423, + 0, + 0, + 0, + 28424, + 0, + 0, + 28428, + 0, + 0, + 0, + 0, + 0, + 28429, + 0, + 0, + 0, + 28431, + 28434, + 0, + 28458, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28464, + 0, + 0, + 0, + 0, + 28465, + 0, + 28467, + 0, + 0, + 0, + 0, + 0, + 0, + 28471, + 0, + 0, + 0, + 0, + 28474, + 0, + 28480, + 0, + 28481, + 0, + 0, + 28485, + 0, + 0, + 0, + 0, + 28486, + 28488, + 0, + 0, + 28489, + 0, + 0, + 0, + 0, + 28492, + 0, + 0, + 0, + 28495, + 0, + 28497, + 0, + 28499, + 0, + 0, + 0, + 0, + 28500, + 0, + 0, + 28502, + 28503, + 0, + 0, + 0, + 28508, + 0, + 0, + 0, + 28510, + 0, + 0, + 28512, + 28513, + 28514, + 28521, + 0, + 28526, + 0, + 28527, + 28528, + 0, + 0, + 0, + 0, + 28529, + 0, + 0, + 28532, + 0, + 0, + 28537, + 28538, + 0, + 0, + 0, + 28539, + 0, + 28548, + 0, + 28553, + 28554, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28560, + 28563, + 0, + 0, + 28564, + 0, + 0, + 0, + 0, + 28565, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28566, + 28568, + 0, + 0, + 0, + 0, + 0, + 0, + 28569, + 0, + 0, + 0, + 28570, + 0, + 28572, + 28573, + 0, + 0, + 0, + 0, + 28575, + 0, + 0, + 0, + 0, + 28576, + 28581, + 28588, + 0, + 0, + 28589, + 0, + 0, + 0, + 28590, + 28595, + 0, + 28598, + 0, + 0, + 28601, + 0, + 0, + 28605, + 0, + 0, + 0, + 0, + 28614, + 28615, + 28619, + 0, + 0, + 0, + 0, + 0, + 0, + 28620, + 0, + 28626, + 0, + 0, + 28628, + 0, + 28631, + 0, + 28632, + 0, + 0, + 0, + 0, + 0, + 0, + 28635, + 0, + 0, + 0, + 28637, + 28638, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28639, + 0, + 28643, + 0, + 0, + 28652, + 0, + 0, + 0, + 28662, + 0, + 28670, + 28671, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28672, + 28673, + 28675, + 28676, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28691, + 0, + 0, + 0, + 28695, + 0, + 0, + 0, + 28696, + 0, + 28697, + 28698, + 0, + 28705, + 0, + 28707, + 28708, + 28710, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28711, + 28728, + 0, + 0, + 0, + 28736, + 0, + 0, + 0, + 28737, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28738, + 0, + 28739, + 0, + 28741, + 0, + 0, + 28742, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28745, + 0, + 0, + 0, + 0, + 0, + 0, + 28749, + 28750, + 28752, + 28754, + 28756, + 0, + 28757, + 0, + 0, + 0, + 0, + 28759, + 28760, + 0, + 0, + 0, + 0, + 0, + 0, + 28762, + 0, + 0, + 0, + 28764, + 0, + 0, + 0, + 0, + 0, + 0, + 28766, + 0, + 28767, + 28768, + 0, + 0, + 0, + 0, + 28769, + 28770, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28771, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28772, + 0, + 28773, + 0, + 28782, + 0, + 0, + 0, + 0, + 0, + 0, + 28784, + 0, + 28785, + 0, + 28786, + 0, + 0, + 0, + 28787, + 0, + 0, + 0, + 28797, + 0, + 0, + 0, + 0, + 0, + 0, + 28799, + 0, + 0, + 28801, + 0, + 0, + 0, + 0, + 28802, + 0, + 28805, + 0, + 0, + 28806, + 0, + 0, + 28807, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28808, + 0, + 0, + 0, + 0, + 0, + 28810, + 28812, + 0, + 0, + 28816, + 28819, + 0, + 0, + 28821, + 0, + 28826, + 0, + 0, + 0, + 28842, + 28852, + 0, + 0, + 28853, + 0, + 28854, + 28855, + 0, + 0, + 0, + 28857, + 0, + 0, + 0, + 28858, + 0, + 28867, + 28868, + 28869, + 0, + 0, + 0, + 28874, + 28880, + 28882, + 28890, + 28892, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28895, + 0, + 0, + 0, + 28898, + 28899, + 0, + 0, + 0, + 28900, + 0, + 0, + 28904, + 0, + 28906, + 0, + 0, + 0, + 0, + 28907, + 0, + 0, + 0, + 0, + 0, + 0, + 28908, + 0, + 0, + 0, + 28910, + 0, + 28914, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28915, + 28916, + 28919, + 0, + 0, + 28920, + 0, + 28921, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28924, + 0, + 0, + 0, + 0, + 28926, + 28929, + 0, + 0, + 0, + 28930, + 0, + 28936, + 0, + 28939, + 0, + 0, + 0, + 0, + 28942, + 0, + 0, + 0, + 0, + 0, + 0, + 28956, + 0, + 0, + 0, + 28966, + 0, + 0, + 0, + 0, + 28967, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 28968, + 0, + 28971, + 0, + 28975, + 28976, + 0, + 28982, + 28983, + 0, + 0, + 28984, + 28989, + 28996, + 28997, + 28998, + 0, + 0, + 0, + 0, + 0, + 0, + 28999, + 0, + 0, + 0, + 0, + 0, + 29000, + 0, + 29001, + 0, + 0, + 0, + 29009, + 0, + 0, + 29011, + 0, + 0, + 29021, + 0, + 0, + 0, + 0, + 29024, + 0, + 29025, + 0, + 0, + 0, + 0, + 0, + 29026, + 0, + 0, + 0, + 29036, + 0, + 0, + 0, + 29037, + 0, + 0, + 0, + 0, + 29038, + 0, + 29045, + 0, + 29047, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29051, + 0, + 0, + 0, + 29054, + 29056, + 29062, + 0, + 29070, + 29082, + 0, + 0, + 0, + 29083, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29084, + 0, + 0, + 0, + 0, + 29085, + 29088, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29090, + 29097, + 0, + 0, + 0, + 29103, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29105, + 0, + 0, + 0, + 0, + 0, + 29107, + 0, + 29109, + 0, + 0, + 0, + 29115, + 0, + 0, + 29120, + 0, + 0, + 29138, + 29140, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29152, + 0, + 29160, + 29174, + 0, + 29176, + 0, + 0, + 29180, + 0, + 29181, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29228, + 0, + 0, + 29229, + 0, + 0, + 29230, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29234, + 0, + 0, + 0, + 29241, + 0, + 29245, + 0, + 29248, + 0, + 29250, + 29256, + 29280, + 0, + 29282, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29285, + 0, + 0, + 29286, + 29291, + 29292, + 0, + 0, + 0, + 0, + 29294, + 0, + 29295, + 0, + 0, + 0, + 0, + 0, + 29296, + 29297, + 29298, + 29300, + 0, + 29302, + 0, + 0, + 29304, + 29307, + 0, + 29312, + 0, + 0, + 0, + 29322, + 0, + 0, + 29323, + 0, + 0, + 29324, + 29326, + 29328, + 0, + 29335, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29338, + 29339, + 0, + 0, + 0, + 0, + 0, + 29341, + 29343, + 0, + 0, + 0, + 0, + 29344, + 0, + 0, + 0, + 0, + 0, + 29345, + 0, + 0, + 0, + 0, + 29346, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29347, + 29348, + 29349, + 0, + 0, + 29354, + 0, + 0, + 29355, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29357, + 0, + 0, + 0, + 0, + 29364, + 0, + 29365, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29366, + 0, + 0, + 29368, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29378, + 0, + 29381, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29386, + 0, + 0, + 0, + 0, + 0, + 0, + 29389, + 0, + 0, + 0, + 29390, + 0, + 0, + 29391, + 29397, + 0, + 29398, + 29412, + 29414, + 29418, + 29419, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29420, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29423, + 0, + 0, + 0, + 29435, + 0, + 0, + 0, + 29437, + 0, + 0, + 29439, + 0, + 29441, + 0, + 0, + 0, + 0, + 29443, + 0, + 29446, + 29450, + 29452, + 0, + 0, + 0, + 0, + 0, + 29456, + 0, + 0, + 0, + 0, + 0, + 29461, + 0, + 0, + 0, + 29464, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29468, + 0, + 29473, + 0, + 0, + 0, + 29486, + 0, + 0, + 0, + 29490, + 0, + 0, + 0, + 29491, + 29492, + 0, + 0, + 29497, + 0, + 0, + 0, + 29498, + 0, + 29499, + 0, + 29502, + 29505, + 0, + 29509, + 0, + 0, + 0, + 29510, + 0, + 0, + 0, + 29512, + 0, + 0, + 0, + 29516, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29518, + 0, + 29519, + 0, + 0, + 0, + 0, + 0, + 29520, + 29521, + 29529, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29530, + 0, + 0, + 29531, + 29538, + 0, + 29540, + 0, + 0, + 0, + 29542, + 0, + 29543, + 29544, + 29547, + 0, + 0, + 29548, + 0, + 0, + 0, + 29549, + 0, + 0, + 0, + 29550, + 0, + 0, + 29552, + 0, + 0, + 0, + 0, + 29558, + 29561, + 0, + 29562, + 29564, + 0, + 0, + 29565, + 0, + 0, + 29566, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29578, + 29584, + 29586, + 29591, + 0, + 0, + 0, + 0, + 29593, + 29594, + 0, + 0, + 29597, + 0, + 0, + 29613, + 0, + 29614, + 0, + 29615, + 0, + 0, + 0, + 0, + 29616, + 29617, + 0, + 0, + 29625, + 0, + 0, + 0, + 29632, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29633, + 0, + 0, + 0, + 0, + 0, + 29634, + 29635, + 29637, + 0, + 29638, + 0, + 29641, + 29643, + 0, + 0, + 0, + 0, + 0, + 0, + 29644, + 0, + 29645, + 0, + 29649, + 0, + 0, + 0, + 29650, + 0, + 29653, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29656, + 29659, + 0, + 0, + 29660, + 0, + 0, + 0, + 29661, + 0, + 0, + 0, + 0, + 0, + 29664, + 0, + 0, + 0, + 29671, + 29673, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29675, + 0, + 29677, + 29679, + 0, + 0, + 29684, + 0, + 0, + 0, + 0, + 0, + 29685, + 0, + 0, + 0, + 29687, + 0, + 0, + 0, + 29688, + 0, + 29689, + 29690, + 29700, + 0, + 29701, + 0, + 0, + 0, + 29702, + 0, + 29706, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29720, + 0, + 29721, + 0, + 29727, + 0, + 29733, + 29734, + 0, + 29750, + 29761, + 0, + 29763, + 0, + 0, + 0, + 0, + 0, + 29764, + 0, + 0, + 29765, + 0, + 0, + 0, + 29771, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29772, + 0, + 0, + 0, + 29773, + 29774, + 29775, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29822, + 0, + 0, + 0, + 29824, + 0, + 29825, + 0, + 0, + 0, + 0, + 0, + 29827, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29829, + 0, + 29832, + 29834, + 0, + 0, + 29835, + 0, + 0, + 29837, + 29838, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29843, + 0, + 0, + 0, + 0, + 29844, + 29845, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29849, + 0, + 0, + 29869, + 29872, + 29890, + 29905, + 0, + 0, + 0, + 0, + 0, + 29907, + 29921, + 0, + 29922, + 0, + 0, + 29923, + 29926, + 29944, + 29946, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 29947, + 29948, + 0, + 0, + 0, + 29951, + 0, + 0, + 0, + 0, + 0, + 29953, + 0, + 0, + 29956, + 0, + 29957, + 0, + 0, + 29962, + 0, + 0, + 0, + 0, + 29971, + 0, + 0, + 0, + 29972, + 0, + 0, + 0, + 0, + 0, + 29978, + 0, + 29979, + 29992, + 30007, + 30008, + 30010, + 0, + 0, + 0, + 30013, + 0, + 0, + 0, + 0, + 30014, + 30016, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30017, + 0, + 0, + 0, + 0, + 0, + 30023, + 30031, + 0, + 0, + 30033, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30034, + 0, + 30038, + 0, + 30039, + 0, + 30040, + 0, + 0, + 0, + 0, + 0, + 0, + 30067, + 30068, + 0, + 0, + 0, + 30069, + 0, + 30072, + 0, + 0, + 0, + 30073, + 0, + 0, + 0, + 0, + 30075, + 0, + 0, + 0, + 0, + 0, + 0, + 30079, + 0, + 0, + 30080, + 0, + 0, + 0, + 0, + 0, + 30082, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30084, + 30090, + 0, + 0, + 30091, + 0, + 0, + 0, + 0, + 30098, + 30118, + 0, + 30119, + 0, + 30121, + 30130, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30131, + 30132, + 30133, + 0, + 0, + 0, + 0, + 0, + 0, + 30135, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30136, + 0, + 0, + 30137, + 30138, + 0, + 0, + 0, + 30139, + 30146, + 0, + 0, + 0, + 0, + 0, + 30147, + 0, + 0, + 30148, + 30151, + 0, + 0, + 0, + 30168, + 0, + 30172, + 30173, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30180, + 30181, + 0, + 30192, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30194, + 30196, + 0, + 0, + 30199, + 0, + 0, + 30202, + 0, + 0, + 0, + 0, + 30203, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30213, + 0, + 0, + 0, + 30216, + 0, + 0, + 30217, + 0, + 0, + 0, + 30218, + 0, + 0, + 0, + 0, + 30219, + 0, + 30220, + 0, + 30222, + 30227, + 0, + 0, + 0, + 0, + 0, + 30231, + 0, + 0, + 30233, + 30235, + 0, + 0, + 0, + 0, + 30238, + 0, + 30240, + 30243, + 30245, + 0, + 30250, + 30252, + 0, + 0, + 0, + 30269, + 0, + 0, + 30271, + 30272, + 0, + 0, + 0, + 30278, + 30280, + 0, + 0, + 30282, + 0, + 30284, + 0, + 30294, + 0, + 0, + 0, + 0, + 30295, + 30296, + 0, + 0, + 0, + 0, + 0, + 30298, + 30299, + 30302, + 30304, + 30306, + 0, + 0, + 0, + 0, + 0, + 0, + 30316, + 30317, + 0, + 0, + 0, + 30318, + 0, + 0, + 0, + 30319, + 0, + 30320, + 30322, + 30326, + 0, + 0, + 0, + 0, + 0, + 30327, + 0, + 30332, + 30348, + 30349, + 0, + 0, + 30356, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30357, + 0, + 30358, + 0, + 30359, + 30360, + 0, + 0, + 30365, + 30366, + 30378, + 0, + 0, + 0, + 0, + 30379, + 0, + 0, + 30381, + 0, + 30385, + 0, + 30388, + 30397, + 0, + 0, + 0, + 30401, + 0, + 0, + 0, + 0, + 30403, + 0, + 0, + 0, + 0, + 0, + 30404, + 0, + 0, + 30405, + 0, + 30406, + 30408, + 0, + 30409, + 0, + 30410, + 0, + 0, + 0, + 30417, + 0, + 0, + 30418, + 30419, + 0, + 30420, + 0, + 30424, + 0, + 0, + 0, + 30427, + 30430, + 30432, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30433, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30436, + 0, + 30437, + 30438, + 0, + 30441, + 30442, + 0, + 0, + 0, + 30445, + 0, + 0, + 0, + 0, + 30452, + 30456, + 30457, + 0, + 0, + 0, + 30458, + 0, + 30464, + 0, + 0, + 0, + 0, + 0, + 0, + 30467, + 0, + 30469, + 0, + 0, + 0, + 0, + 0, + 30477, + 0, + 0, + 30484, + 0, + 0, + 0, + 0, + 0, + 30485, + 0, + 0, + 0, + 0, + 0, + 30486, + 30487, + 30497, + 30498, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30505, + 0, + 30508, + 0, + 0, + 0, + 30509, + 30510, + 0, + 30514, + 30516, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30523, + 0, + 30524, + 0, + 30525, + 0, + 0, + 0, + 0, + 30537, + 0, + 0, + 30538, + 0, + 0, + 0, + 0, + 0, + 30553, + 0, + 0, + 30555, + 30556, + 30558, + 30559, + 30560, + 0, + 0, + 30561, + 0, + 30562, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30563, + 30570, + 30571, + 0, + 30586, + 30587, + 0, + 0, + 30590, + 0, + 0, + 30594, + 0, + 0, + 0, + 0, + 30611, + 30612, + 30623, + 30634, + 0, + 0, + 30636, + 30640, + 30655, + 30656, + 0, + 30657, + 0, + 0, + 30658, + 30669, + 0, + 30670, + 0, + 30676, + 30678, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30679, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30695, + 0, + 0, + 30698, + 0, + 0, + 0, + 0, + 30700, + 0, + 0, + 0, + 0, + 30701, + 0, + 30702, + 30703, + 0, + 0, + 0, + 0, + 30707, + 0, + 0, + 0, + 30709, + 0, + 0, + 30710, + 30719, + 30729, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30731, + 0, + 0, + 30733, + 0, + 0, + 0, + 30734, + 0, + 0, + 0, + 0, + 0, + 30736, + 30737, + 0, + 0, + 0, + 30740, + 0, + 0, + 0, + 30743, + 0, + 30746, + 0, + 30747, + 30748, + 0, + 0, + 30751, + 30752, + 30753, + 0, + 0, + 0, + 30754, + 0, + 0, + 30760, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30763, + 0, + 30764, + 0, + 0, + 30766, + 0, + 30769, + 30770, + 30771, + 30774, + 30777, + 0, + 0, + 30779, + 30780, + 30781, + 0, + 0, + 0, + 0, + 30790, + 0, + 0, + 0, + 30792, + 0, + 0, + 0, + 0, + 30810, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30812, + 30819, + 0, + 0, + 30823, + 30824, + 0, + 30825, + 0, + 30827, + 0, + 0, + 0, + 0, + 0, + 0, + 30828, + 0, + 0, + 30830, + 0, + 0, + 0, + 30834, + 0, + 30835, + 0, + 30837, + 30838, + 0, + 30845, + 0, + 0, + 0, + 0, + 0, + 30846, + 30847, + 0, + 0, + 30849, + 0, + 30851, + 0, + 0, + 0, + 0, + 0, + 30852, + 30858, + 0, + 0, + 30859, + 0, + 30865, + 0, + 0, + 30866, + 0, + 0, + 30868, + 0, + 0, + 30869, + 0, + 0, + 0, + 30881, + 30883, + 0, + 0, + 0, + 0, + 0, + 30889, + 0, + 30891, + 0, + 0, + 0, + 0, + 30894, + 0, + 30895, + 0, + 30897, + 0, + 30898, + 0, + 0, + 0, + 30904, + 30906, + 0, + 30909, + 0, + 0, + 0, + 0, + 0, + 0, + 30910, + 0, + 0, + 0, + 30915, + 30933, + 30942, + 0, + 0, + 0, + 0, + 30943, + 0, + 0, + 30945, + 0, + 0, + 0, + 0, + 0, + 0, + 30946, + 0, + 0, + 30947, + 0, + 0, + 30955, + 30956, + 0, + 0, + 30960, + 0, + 0, + 30961, + 30962, + 30966, + 0, + 0, + 30969, + 30974, + 0, + 0, + 0, + 30976, + 0, + 0, + 30977, + 0, + 30978, + 30982, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 30994, + 30995, + 30998, + 0, + 31000, + 0, + 0, + 31001, + 0, + 0, + 31003, + 31005, + 0, + 0, + 31006, + 31011, + 0, + 0, + 31014, + 0, + 31016, + 0, + 0, + 0, + 0, + 31018, + 0, + 0, + 31020, + 31023, + 31024, + 31025, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31027, + 31028, + 31029, + 0, + 0, + 0, + 0, + 0, + 0, + 31032, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31036, + 31037, + 31038, + 0, + 0, + 0, + 31041, + 31043, + 31045, + 0, + 31047, + 0, + 0, + 0, + 31048, + 0, + 31049, + 0, + 0, + 0, + 31053, + 31054, + 31055, + 0, + 0, + 31063, + 0, + 0, + 0, + 0, + 0, + 31066, + 0, + 31068, + 31071, + 0, + 0, + 0, + 31072, + 31073, + 0, + 0, + 0, + 0, + 31075, + 0, + 0, + 31076, + 0, + 0, + 0, + 31077, + 31079, + 0, + 31080, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31087, + 0, + 31142, + 0, + 31144, + 0, + 0, + 31145, + 31146, + 31147, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31149, + 0, + 31151, + 31152, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31162, + 31171, + 31174, + 31175, + 0, + 0, + 0, + 31176, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31179, + 0, + 0, + 0, + 31186, + 0, + 0, + 0, + 31192, + 31195, + 0, + 0, + 31196, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31198, + 0, + 0, + 0, + 0, + 0, + 31199, + 0, + 0, + 0, + 31205, + 0, + 0, + 0, + 0, + 31211, + 31215, + 0, + 0, + 0, + 0, + 31231, + 0, + 31232, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31233, + 31236, + 31253, + 0, + 31254, + 0, + 0, + 0, + 0, + 0, + 0, + 31255, + 0, + 0, + 31257, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31258, + 31259, + 0, + 0, + 31260, + 0, + 31261, + 0, + 0, + 0, + 0, + 0, + 31262, + 31263, + 0, + 0, + 31264, + 0, + 31266, + 0, + 31267, + 0, + 0, + 0, + 0, + 0, + 31281, + 0, + 31282, + 0, + 31284, + 0, + 0, + 31285, + 31287, + 31288, + 0, + 0, + 31290, + 0, + 0, + 0, + 31292, + 31295, + 0, + 31299, + 0, + 31300, + 0, + 0, + 0, + 0, + 0, + 31302, + 0, + 0, + 0, + 0, + 31303, + 0, + 0, + 0, + 0, + 0, + 0, + 31304, + 0, + 0, + 0, + 0, + 0, + 31305, + 31308, + 31309, + 31315, + 0, + 31317, + 0, + 0, + 0, + 0, + 0, + 31323, + 0, + 31324, + 0, + 0, + 0, + 0, + 0, + 31325, + 31327, + 0, + 0, + 31331, + 0, + 0, + 0, + 0, + 0, + 31333, + 0, + 0, + 0, + 0, + 0, + 31336, + 0, + 0, + 31337, + 0, + 0, + 0, + 0, + 0, + 0, + 31338, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31339, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31342, + 0, + 0, + 0, + 0, + 31345, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31347, + 0, + 0, + 0, + 0, + 0, + 0, + 31348, + 0, + 0, + 31350, + 31351, + 0, + 31352, + 0, + 0, + 31354, + 0, + 0, + 0, + 0, + 31355, + 0, + 0, + 31356, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31363, + 0, + 31372, + 0, + 0, + 31373, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31376, + 0, + 31388, + 0, + 31389, + 0, + 31392, + 0, + 31401, + 0, + 31405, + 31407, + 31408, + 0, + 31409, + 0, + 0, + 0, + 0, + 0, + 0, + 31413, + 31415, + 0, + 0, + 0, + 31416, + 31418, + 0, + 0, + 0, + 0, + 0, + 0, + 31422, + 31423, + 0, + 0, + 31424, + 0, + 31425, + 31432, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31433, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31434, + 0, + 0, + 0, + 0, + 0, + 0, + 31435, + 0, + 0, + 0, + 0, + 31438, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31442, + 0, + 31444, + 0, + 31448, + 0, + 0, + 31451, + 0, + 0, + 0, + 0, + 31452, + 0, + 31461, + 31465, + 0, + 0, + 31466, + 0, + 0, + 31467, + 0, + 0, + 31468, + 0, + 0, + 0, + 31469, + 31473, + 0, + 31476, + 0, + 0, + 0, + 0, + 31489, + 31490, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31492, + 31493, + 31494, + 0, + 0, + 0, + 0, + 31501, + 31504, + 31505, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31509, + 0, + 0, + 0, + 0, + 31510, + 0, + 0, + 31511, + 0, + 0, + 31513, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31514, + 0, + 31522, + 31536, + 31539, + 31540, + 0, + 31541, + 0, + 0, + 0, + 0, + 0, + 0, + 31546, + 31553, + 31559, + 0, + 0, + 0, + 31560, + 31561, + 31562, + 0, + 0, + 31564, + 31567, + 0, + 31569, + 0, + 0, + 0, + 31570, + 0, + 0, + 0, + 0, + 31571, + 0, + 0, + 0, + 0, + 0, + 0, + 31572, + 31574, + 31580, + 31581, + 0, + 0, + 31582, + 31584, + 31585, + 31586, + 31595, + 0, + 31596, + 0, + 0, + 0, + 0, + 31597, + 0, + 31599, + 0, + 31600, + 31601, + 0, + 0, + 31603, + 31604, + 0, + 0, + 31608, + 31610, + 0, + 0, + 0, + 31611, + 0, + 31615, + 0, + 0, + 0, + 0, + 31616, + 0, + 0, + 0, + 0, + 0, + 0, + 31617, + 0, + 0, + 0, + 0, + 0, + 31618, + 0, + 0, + 0, + 0, + 0, + 0, + 31621, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31622, + 31625, + 0, + 0, + 0, + 0, + 31627, + 0, + 31641, + 0, + 0, + 31642, + 0, + 0, + 31643, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31644, + 0, + 31646, + 0, + 0, + 0, + 0, + 31648, + 0, + 0, + 0, + 31652, + 0, + 0, + 0, + 31657, + 0, + 0, + 31676, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 31689, + 31691, + 31692, + 0, + 31694, + 0, + 0, + 0, + 31696, + 0, + 31702, + 0, + 31703, + 0, +} + +var kStaticDictionaryWords = [31705]DictWord{ + DictWord{0, 0, 0}, + DictWord{8, 0, 1002}, + DictWord{136, 0, 1015}, + DictWord{4, 0, 683}, + DictWord{4, 10, 325}, + DictWord{138, 10, 125}, + DictWord{7, 11, 572}, + DictWord{ + 9, + 11, + 592, + }, + DictWord{11, 11, 680}, + DictWord{11, 11, 842}, + DictWord{11, 11, 924}, + DictWord{12, 11, 356}, + DictWord{12, 11, 550}, + DictWord{13, 11, 317}, + DictWord{13, 11, 370}, + DictWord{13, 11, 469}, + DictWord{13, 11, 471}, + DictWord{14, 11, 397}, + DictWord{18, 11, 69}, + DictWord{146, 11, 145}, + DictWord{ + 134, + 0, + 1265, + }, + DictWord{136, 11, 534}, + DictWord{134, 0, 1431}, + DictWord{11, 0, 138}, + DictWord{140, 0, 40}, + DictWord{4, 0, 155}, + DictWord{7, 0, 1689}, + DictWord{ + 4, + 10, + 718, + }, + DictWord{135, 10, 1216}, + DictWord{4, 0, 245}, + DictWord{5, 0, 151}, + DictWord{5, 0, 741}, + DictWord{6, 0, 1147}, + DictWord{7, 0, 498}, + DictWord{7, 0, 870}, + DictWord{7, 0, 1542}, + DictWord{12, 0, 213}, + DictWord{14, 0, 36}, + DictWord{14, 0, 391}, + DictWord{17, 0, 111}, + DictWord{18, 0, 6}, + DictWord{18, 0, 46}, + DictWord{ + 18, + 0, + 151, + }, + DictWord{19, 0, 36}, + DictWord{20, 0, 32}, + DictWord{20, 0, 56}, + DictWord{20, 0, 69}, + DictWord{20, 0, 102}, + DictWord{21, 0, 4}, + DictWord{22, 0, 8}, + DictWord{ + 22, + 0, + 10, + }, + DictWord{22, 0, 14}, + DictWord{150, 0, 31}, + DictWord{4, 0, 624}, + DictWord{135, 0, 1752}, + DictWord{5, 10, 124}, + DictWord{5, 10, 144}, + DictWord{6, 10, 548}, + DictWord{7, 10, 15}, + DictWord{7, 10, 153}, + DictWord{137, 10, 629}, + DictWord{6, 0, 503}, + DictWord{9, 0, 586}, + DictWord{13, 0, 468}, + DictWord{14, 0, 66}, + DictWord{ + 16, + 0, + 58, + }, + DictWord{7, 10, 1531}, + DictWord{8, 10, 416}, + DictWord{9, 10, 275}, + DictWord{10, 10, 100}, + DictWord{11, 10, 658}, + DictWord{11, 10, 979}, + DictWord{ + 12, + 10, + 86, + }, + DictWord{14, 10, 207}, + DictWord{15, 10, 20}, + DictWord{143, 10, 25}, + DictWord{5, 0, 603}, + DictWord{7, 0, 1212}, + DictWord{9, 0, 565}, + DictWord{ + 14, + 0, + 301, + }, + DictWord{5, 10, 915}, + DictWord{6, 10, 1783}, + DictWord{7, 10, 211}, + DictWord{7, 10, 1353}, + DictWord{9, 10, 83}, + DictWord{10, 10, 376}, + DictWord{ + 10, + 10, + 431, + }, + DictWord{11, 10, 543}, + DictWord{12, 10, 664}, + DictWord{13, 10, 280}, + DictWord{13, 10, 428}, + DictWord{14, 10, 128}, + DictWord{17, 10, 52}, + DictWord{ + 145, + 10, + 81, + }, + DictWord{4, 0, 492}, + DictWord{133, 0, 451}, + DictWord{135, 0, 835}, + DictWord{141, 0, 70}, + DictWord{132, 0, 539}, + DictWord{7, 11, 748}, + DictWord{ + 139, + 11, + 700, + }, + DictWord{7, 11, 1517}, + DictWord{11, 11, 597}, + DictWord{14, 11, 76}, + DictWord{14, 11, 335}, + DictWord{148, 11, 33}, + DictWord{6, 0, 113}, + DictWord{135, 0, 436}, + DictWord{4, 10, 338}, + DictWord{133, 10, 400}, + DictWord{136, 0, 718}, + DictWord{133, 11, 127}, + DictWord{133, 11, 418}, + DictWord{ + 6, + 0, + 1505, + }, + DictWord{7, 0, 520}, + DictWord{6, 11, 198}, + DictWord{11, 10, 892}, + DictWord{140, 11, 83}, + DictWord{4, 10, 221}, + DictWord{5, 10, 659}, + DictWord{ + 5, + 10, + 989, + }, + DictWord{7, 10, 697}, + DictWord{7, 10, 1211}, + DictWord{138, 10, 284}, + DictWord{135, 0, 1070}, + DictWord{5, 11, 276}, + DictWord{6, 11, 55}, + DictWord{ + 135, + 11, + 1369, + }, + DictWord{134, 0, 1515}, + DictWord{6, 11, 1752}, + DictWord{136, 11, 726}, + DictWord{138, 10, 507}, + DictWord{15, 0, 78}, + DictWord{4, 10, 188}, + DictWord{135, 10, 805}, + DictWord{5, 10, 884}, + DictWord{139, 10, 991}, + DictWord{133, 11, 764}, + DictWord{134, 10, 1653}, + DictWord{6, 11, 309}, + DictWord{ + 7, + 11, + 331, + }, + DictWord{138, 11, 550}, + DictWord{135, 11, 1861}, + DictWord{132, 11, 348}, + DictWord{135, 11, 986}, + DictWord{135, 11, 1573}, + DictWord{ + 12, + 0, + 610, + }, + DictWord{13, 0, 431}, + DictWord{144, 0, 59}, + DictWord{9, 11, 799}, + DictWord{140, 10, 166}, + DictWord{134, 0, 1530}, + DictWord{132, 0, 750}, + DictWord{132, 0, 307}, + DictWord{133, 0, 964}, + DictWord{6, 11, 194}, + DictWord{7, 11, 133}, + DictWord{10, 11, 493}, + DictWord{10, 11, 570}, + DictWord{139, 11, 664}, + DictWord{5, 11, 24}, + DictWord{5, 11, 569}, + DictWord{6, 11, 3}, + DictWord{6, 11, 119}, + DictWord{6, 11, 143}, + DictWord{6, 11, 440}, + DictWord{7, 11, 295}, + DictWord{ + 7, + 11, + 599, + }, + DictWord{7, 11, 1686}, + DictWord{7, 11, 1854}, + DictWord{8, 11, 424}, + DictWord{9, 11, 43}, + DictWord{9, 11, 584}, + DictWord{9, 11, 760}, + DictWord{ + 10, + 11, + 148, + }, + DictWord{10, 11, 328}, + DictWord{11, 11, 159}, + DictWord{11, 11, 253}, + DictWord{11, 11, 506}, + DictWord{12, 11, 487}, + DictWord{12, 11, 531}, + DictWord{144, 11, 33}, + DictWord{136, 10, 760}, + DictWord{5, 11, 14}, + DictWord{5, 11, 892}, + DictWord{6, 11, 283}, + DictWord{7, 11, 234}, + DictWord{136, 11, 537}, + DictWord{135, 11, 1251}, + DictWord{4, 11, 126}, + DictWord{8, 11, 635}, + DictWord{147, 11, 34}, + DictWord{4, 11, 316}, + DictWord{135, 11, 1561}, + DictWord{ + 6, + 0, + 999, + }, + DictWord{6, 0, 1310}, + DictWord{137, 11, 861}, + DictWord{4, 11, 64}, + DictWord{5, 11, 352}, + DictWord{5, 11, 720}, + DictWord{6, 11, 368}, + DictWord{ + 139, + 11, + 359, + }, + DictWord{4, 0, 75}, + DictWord{5, 0, 180}, + DictWord{6, 0, 500}, + DictWord{7, 0, 58}, + DictWord{7, 0, 710}, + DictWord{10, 0, 645}, + DictWord{136, 10, 770}, + DictWord{133, 0, 649}, + DictWord{6, 0, 276}, + DictWord{7, 0, 282}, + DictWord{7, 0, 879}, + DictWord{7, 0, 924}, + DictWord{8, 0, 459}, + DictWord{9, 0, 599}, + DictWord{9, 0, 754}, + DictWord{11, 0, 574}, + DictWord{12, 0, 128}, + DictWord{12, 0, 494}, + DictWord{13, 0, 52}, + DictWord{13, 0, 301}, + DictWord{15, 0, 30}, + DictWord{143, 0, 132}, + DictWord{132, 0, 200}, + DictWord{4, 10, 89}, + DictWord{5, 10, 489}, + DictWord{6, 10, 315}, + DictWord{7, 10, 553}, + DictWord{7, 10, 1745}, + DictWord{138, 10, 243}, + DictWord{135, 11, 1050}, + DictWord{7, 0, 1621}, + DictWord{6, 10, 1658}, + DictWord{9, 10, 3}, + DictWord{10, 10, 154}, + DictWord{11, 10, 641}, + DictWord{13, 10, 85}, + DictWord{13, 10, 201}, + DictWord{141, 10, 346}, + DictWord{6, 11, 175}, + DictWord{137, 11, 289}, + DictWord{5, 11, 432}, + DictWord{133, 11, 913}, + DictWord{ + 6, + 0, + 225, + }, + DictWord{137, 0, 211}, + DictWord{7, 0, 718}, + DictWord{8, 0, 687}, + DictWord{139, 0, 374}, + DictWord{4, 10, 166}, + DictWord{133, 10, 505}, + DictWord{ + 9, + 0, + 110, + }, + DictWord{134, 10, 1670}, + DictWord{8, 0, 58}, + DictWord{9, 0, 724}, + DictWord{11, 0, 809}, + DictWord{13, 0, 113}, + DictWord{145, 0, 72}, + DictWord{6, 0, 345}, + DictWord{7, 0, 1247}, + DictWord{144, 11, 82}, + DictWord{5, 11, 931}, + DictWord{134, 11, 1698}, + DictWord{8, 0, 767}, + DictWord{8, 0, 803}, + DictWord{9, 0, 301}, + DictWord{137, 0, 903}, + DictWord{139, 0, 203}, + DictWord{134, 0, 1154}, + DictWord{7, 0, 1949}, + DictWord{136, 0, 674}, + DictWord{134, 0, 259}, + DictWord{ + 135, + 0, + 1275, + }, + DictWord{5, 11, 774}, + DictWord{6, 11, 1637}, + DictWord{6, 11, 1686}, + DictWord{134, 11, 1751}, + DictWord{134, 0, 1231}, + DictWord{7, 10, 445}, + DictWord{8, 10, 307}, + DictWord{8, 10, 704}, + DictWord{10, 10, 41}, + DictWord{10, 10, 439}, + DictWord{11, 10, 237}, + DictWord{11, 10, 622}, + DictWord{140, 10, 201}, + DictWord{136, 0, 254}, + DictWord{6, 11, 260}, + DictWord{135, 11, 1484}, + DictWord{139, 0, 277}, + DictWord{135, 10, 1977}, + DictWord{4, 10, 189}, + DictWord{ + 5, + 10, + 713, + }, + DictWord{6, 11, 573}, + DictWord{136, 10, 57}, + DictWord{138, 10, 371}, + DictWord{132, 10, 552}, + DictWord{134, 11, 344}, + DictWord{133, 0, 248}, + DictWord{9, 0, 800}, + DictWord{10, 0, 693}, + DictWord{11, 0, 482}, + DictWord{11, 0, 734}, + DictWord{11, 0, 789}, + DictWord{134, 11, 240}, + DictWord{4, 0, 116}, + DictWord{ + 5, + 0, + 95, + }, + DictWord{5, 0, 445}, + DictWord{7, 0, 1688}, + DictWord{8, 0, 29}, + DictWord{9, 0, 272}, + DictWord{11, 0, 509}, + DictWord{11, 0, 915}, + DictWord{4, 11, 292}, + DictWord{4, 11, 736}, + DictWord{5, 11, 871}, + DictWord{6, 11, 171}, + DictWord{6, 11, 1689}, + DictWord{7, 11, 1324}, + DictWord{7, 11, 1944}, + DictWord{9, 11, 415}, + DictWord{9, 11, 580}, + DictWord{14, 11, 230}, + DictWord{146, 11, 68}, + DictWord{7, 0, 490}, + DictWord{13, 0, 100}, + DictWord{143, 0, 75}, + DictWord{135, 0, 1641}, + DictWord{133, 0, 543}, + DictWord{7, 11, 209}, + DictWord{8, 11, 661}, + DictWord{10, 11, 42}, + DictWord{11, 11, 58}, + DictWord{12, 11, 58}, + DictWord{12, 11, 118}, + DictWord{141, 11, 32}, + DictWord{5, 0, 181}, + DictWord{8, 0, 41}, + DictWord{6, 11, 63}, + DictWord{135, 11, 920}, + DictWord{133, 0, 657}, + DictWord{133, 11, 793}, + DictWord{138, 0, 709}, + DictWord{7, 0, 25}, + DictWord{8, 0, 202}, + DictWord{138, 0, 536}, + DictWord{5, 11, 665}, + DictWord{135, 10, 1788}, + DictWord{145, 10, 49}, + DictWord{9, 0, 423}, + DictWord{140, 0, 89}, + DictWord{5, 11, 67}, + DictWord{6, 11, 62}, + DictWord{6, 11, 374}, + DictWord{135, 11, 1391}, + DictWord{8, 0, 113}, + DictWord{ + 9, + 0, + 877, + }, + DictWord{10, 0, 554}, + DictWord{11, 0, 83}, + DictWord{12, 0, 136}, + DictWord{19, 0, 109}, + DictWord{9, 11, 790}, + DictWord{140, 11, 47}, + DictWord{ + 138, + 10, + 661, + }, + DictWord{4, 0, 963}, + DictWord{10, 0, 927}, + DictWord{14, 0, 442}, + DictWord{135, 10, 1945}, + DictWord{133, 0, 976}, + DictWord{132, 0, 206}, + DictWord{ + 4, + 11, + 391, + }, + DictWord{135, 11, 1169}, + DictWord{134, 0, 2002}, + DictWord{6, 0, 696}, + DictWord{134, 0, 1008}, + DictWord{134, 0, 1170}, + DictWord{132, 11, 271}, + DictWord{7, 0, 13}, + DictWord{8, 0, 226}, + DictWord{10, 0, 537}, + DictWord{11, 0, 570}, + DictWord{11, 0, 605}, + DictWord{11, 0, 799}, + DictWord{11, 0, 804}, + DictWord{ + 12, + 0, + 85, + }, + DictWord{12, 0, 516}, + DictWord{12, 0, 623}, + DictWord{13, 0, 112}, + DictWord{13, 0, 361}, + DictWord{14, 0, 77}, + DictWord{14, 0, 78}, + DictWord{17, 0, 28}, + DictWord{19, 0, 110}, + DictWord{140, 11, 314}, + DictWord{132, 0, 769}, + DictWord{134, 0, 1544}, + DictWord{4, 0, 551}, + DictWord{137, 0, 678}, + DictWord{5, 10, 84}, + DictWord{134, 10, 163}, + DictWord{9, 0, 57}, + DictWord{9, 0, 459}, + DictWord{10, 0, 425}, + DictWord{11, 0, 119}, + DictWord{12, 0, 184}, + DictWord{12, 0, 371}, + DictWord{ + 13, + 0, + 358, + }, + DictWord{145, 0, 51}, + DictWord{5, 0, 188}, + DictWord{5, 0, 814}, + DictWord{8, 0, 10}, + DictWord{9, 0, 421}, + DictWord{9, 0, 729}, + DictWord{10, 0, 609}, + DictWord{11, 0, 689}, + DictWord{4, 11, 253}, + DictWord{5, 10, 410}, + DictWord{5, 11, 544}, + DictWord{7, 11, 300}, + DictWord{137, 11, 340}, + DictWord{134, 0, 624}, + DictWord{138, 11, 321}, + DictWord{135, 0, 1941}, + DictWord{18, 0, 130}, + DictWord{5, 10, 322}, + DictWord{8, 10, 186}, + DictWord{9, 10, 262}, + DictWord{10, 10, 187}, + DictWord{142, 10, 208}, + DictWord{5, 11, 53}, + DictWord{5, 11, 541}, + DictWord{6, 11, 94}, + DictWord{6, 11, 499}, + DictWord{7, 11, 230}, + DictWord{139, 11, 321}, + DictWord{133, 10, 227}, + DictWord{4, 0, 378}, + DictWord{4, 11, 920}, + DictWord{5, 11, 25}, + DictWord{5, 11, 790}, + DictWord{6, 11, 457}, + DictWord{135, 11, 853}, + DictWord{137, 0, 269}, + DictWord{132, 0, 528}, + DictWord{134, 0, 1146}, + DictWord{7, 10, 1395}, + DictWord{8, 10, 486}, + DictWord{9, 10, 236}, + DictWord{9, 10, 878}, + DictWord{10, 10, 218}, + DictWord{11, 10, 95}, + DictWord{19, 10, 17}, + DictWord{147, 10, 31}, + DictWord{7, 10, 2043}, + DictWord{8, 10, 672}, + DictWord{ + 141, + 10, + 448, + }, + DictWord{134, 0, 1105}, + DictWord{134, 0, 1616}, + DictWord{134, 11, 1765}, + DictWord{140, 11, 163}, + DictWord{5, 10, 412}, + DictWord{133, 11, 822}, + DictWord{132, 11, 634}, + DictWord{6, 0, 656}, + DictWord{134, 11, 1730}, + DictWord{134, 0, 1940}, + DictWord{5, 0, 104}, + DictWord{6, 0, 173}, + DictWord{ + 135, + 0, + 1631, + }, + DictWord{136, 10, 562}, + DictWord{6, 11, 36}, + DictWord{7, 11, 658}, + DictWord{8, 11, 454}, + DictWord{147, 11, 86}, + DictWord{5, 0, 457}, + DictWord{ + 134, + 10, + 1771, + }, + DictWord{7, 0, 810}, + DictWord{8, 0, 138}, + DictWord{8, 0, 342}, + DictWord{9, 0, 84}, + DictWord{10, 0, 193}, + DictWord{11, 0, 883}, + DictWord{140, 0, 359}, + DictWord{9, 0, 620}, + DictWord{135, 10, 1190}, + DictWord{137, 10, 132}, + DictWord{7, 11, 975}, + DictWord{137, 11, 789}, + DictWord{6, 0, 95}, + DictWord{6, 0, 1934}, + DictWord{136, 0, 967}, + DictWord{141, 11, 335}, + DictWord{6, 0, 406}, + DictWord{10, 0, 409}, + DictWord{10, 0, 447}, + DictWord{11, 0, 44}, + DictWord{140, 0, 100}, + DictWord{4, 10, 317}, + DictWord{135, 10, 1279}, + DictWord{132, 0, 477}, + DictWord{134, 0, 1268}, + DictWord{6, 0, 1941}, + DictWord{8, 0, 944}, + DictWord{5, 10, 63}, + DictWord{133, 10, 509}, + DictWord{132, 0, 629}, + DictWord{132, 11, 104}, + DictWord{4, 0, 246}, + DictWord{133, 0, 375}, + DictWord{6, 0, 1636}, + DictWord{ + 132, + 10, + 288, + }, + DictWord{135, 11, 1614}, + DictWord{9, 0, 49}, + DictWord{10, 0, 774}, + DictWord{8, 10, 89}, + DictWord{8, 10, 620}, + DictWord{11, 10, 628}, + DictWord{ + 12, + 10, + 322, + }, + DictWord{143, 10, 124}, + DictWord{4, 0, 282}, + DictWord{7, 0, 1034}, + DictWord{11, 0, 398}, + DictWord{11, 0, 634}, + DictWord{12, 0, 1}, + DictWord{12, 0, 79}, + DictWord{12, 0, 544}, + DictWord{14, 0, 237}, + DictWord{17, 0, 10}, + DictWord{146, 0, 20}, + DictWord{132, 0, 824}, + DictWord{7, 11, 45}, + DictWord{9, 11, 542}, + DictWord{ + 9, + 11, + 566, + }, + DictWord{138, 11, 728}, + DictWord{5, 0, 118}, + DictWord{5, 0, 499}, + DictWord{6, 0, 476}, + DictWord{6, 0, 665}, + DictWord{6, 0, 1176}, + DictWord{ + 6, + 0, + 1196, + }, + DictWord{7, 0, 600}, + DictWord{7, 0, 888}, + DictWord{135, 0, 1096}, + DictWord{7, 0, 296}, + DictWord{7, 0, 596}, + DictWord{8, 0, 560}, + DictWord{8, 0, 586}, + DictWord{9, 0, 612}, + DictWord{11, 0, 304}, + DictWord{12, 0, 46}, + DictWord{13, 0, 89}, + DictWord{14, 0, 112}, + DictWord{145, 0, 122}, + DictWord{5, 0, 894}, + DictWord{ + 6, + 0, + 1772, + }, + DictWord{9, 0, 1009}, + DictWord{138, 10, 120}, + DictWord{5, 11, 533}, + DictWord{7, 11, 755}, + DictWord{138, 11, 780}, + DictWord{151, 10, 1}, + DictWord{ + 6, + 0, + 1474, + }, + DictWord{7, 11, 87}, + DictWord{142, 11, 288}, + DictWord{139, 0, 366}, + DictWord{137, 10, 461}, + DictWord{7, 11, 988}, + DictWord{7, 11, 1939}, + DictWord{ + 9, + 11, + 64, + }, + DictWord{9, 11, 502}, + DictWord{12, 11, 7}, + DictWord{12, 11, 34}, + DictWord{13, 11, 12}, + DictWord{13, 11, 234}, + DictWord{147, 11, 77}, + DictWord{ + 7, + 0, + 1599, + }, + DictWord{7, 0, 1723}, + DictWord{8, 0, 79}, + DictWord{8, 0, 106}, + DictWord{8, 0, 190}, + DictWord{8, 0, 302}, + DictWord{8, 0, 383}, + DictWord{8, 0, 713}, + DictWord{ + 9, + 0, + 119, + }, + DictWord{9, 0, 233}, + DictWord{9, 0, 419}, + DictWord{9, 0, 471}, + DictWord{10, 0, 181}, + DictWord{10, 0, 406}, + DictWord{11, 0, 57}, + DictWord{11, 0, 85}, + DictWord{11, 0, 120}, + DictWord{11, 0, 177}, + DictWord{11, 0, 296}, + DictWord{11, 0, 382}, + DictWord{11, 0, 454}, + DictWord{11, 0, 758}, + DictWord{11, 0, 999}, + DictWord{ + 12, + 0, + 27, + }, + DictWord{12, 0, 98}, + DictWord{12, 0, 131}, + DictWord{12, 0, 245}, + DictWord{12, 0, 312}, + DictWord{12, 0, 446}, + DictWord{12, 0, 454}, + DictWord{13, 0, 25}, + DictWord{13, 0, 98}, + DictWord{13, 0, 426}, + DictWord{13, 0, 508}, + DictWord{14, 0, 70}, + DictWord{14, 0, 163}, + DictWord{14, 0, 272}, + DictWord{14, 0, 277}, + DictWord{ + 14, + 0, + 370, + }, + DictWord{15, 0, 95}, + DictWord{15, 0, 138}, + DictWord{15, 0, 167}, + DictWord{17, 0, 38}, + DictWord{148, 0, 96}, + DictWord{135, 10, 1346}, + DictWord{ + 10, + 0, + 200, + }, + DictWord{19, 0, 2}, + DictWord{151, 0, 22}, + DictWord{135, 11, 141}, + DictWord{134, 10, 85}, + DictWord{134, 0, 1759}, + DictWord{138, 0, 372}, + DictWord{ + 145, + 0, + 16, + }, + DictWord{8, 0, 943}, + DictWord{132, 11, 619}, + DictWord{139, 11, 88}, + DictWord{5, 11, 246}, + DictWord{8, 11, 189}, + DictWord{9, 11, 355}, + DictWord{ + 9, + 11, + 512, + }, + DictWord{10, 11, 124}, + DictWord{10, 11, 453}, + DictWord{11, 11, 143}, + DictWord{11, 11, 416}, + DictWord{11, 11, 859}, + DictWord{141, 11, 341}, + DictWord{ + 5, + 0, + 258, + }, + DictWord{134, 0, 719}, + DictWord{6, 0, 1798}, + DictWord{6, 0, 1839}, + DictWord{8, 0, 900}, + DictWord{10, 0, 874}, + DictWord{10, 0, 886}, + DictWord{ + 12, + 0, + 698, + }, + DictWord{12, 0, 732}, + DictWord{12, 0, 770}, + DictWord{16, 0, 106}, + DictWord{18, 0, 163}, + DictWord{18, 0, 170}, + DictWord{18, 0, 171}, + DictWord{152, 0, 20}, + DictWord{9, 0, 707}, + DictWord{11, 0, 326}, + DictWord{11, 0, 339}, + DictWord{12, 0, 423}, + DictWord{12, 0, 502}, + DictWord{20, 0, 62}, + DictWord{9, 11, 707}, + DictWord{ + 11, + 11, + 326, + }, + DictWord{11, 11, 339}, + DictWord{12, 11, 423}, + DictWord{12, 11, 502}, + DictWord{148, 11, 62}, + DictWord{5, 0, 30}, + DictWord{7, 0, 495}, + DictWord{ + 8, + 0, + 134, + }, + DictWord{9, 0, 788}, + DictWord{140, 0, 438}, + DictWord{133, 11, 678}, + DictWord{5, 10, 279}, + DictWord{6, 10, 235}, + DictWord{7, 10, 468}, + DictWord{ + 8, + 10, + 446, + }, + DictWord{9, 10, 637}, + DictWord{10, 10, 717}, + DictWord{11, 10, 738}, + DictWord{140, 10, 514}, + DictWord{5, 11, 35}, + DictWord{6, 11, 287}, + DictWord{ + 7, + 11, + 862, + }, + DictWord{7, 11, 1886}, + DictWord{138, 11, 179}, + DictWord{7, 0, 1948}, + DictWord{7, 0, 2004}, + DictWord{132, 11, 517}, + DictWord{5, 10, 17}, + DictWord{ + 6, + 10, + 371, + }, + DictWord{137, 10, 528}, + DictWord{4, 0, 115}, + DictWord{5, 0, 669}, + DictWord{6, 0, 407}, + DictWord{8, 0, 311}, + DictWord{11, 0, 10}, + DictWord{141, 0, 5}, + DictWord{137, 0, 381}, + DictWord{5, 0, 50}, + DictWord{6, 0, 439}, + DictWord{7, 0, 780}, + DictWord{135, 0, 1040}, + DictWord{136, 11, 667}, + DictWord{11, 11, 403}, + DictWord{146, 11, 83}, + DictWord{5, 0, 1}, + DictWord{6, 0, 81}, + DictWord{138, 0, 520}, + DictWord{134, 0, 738}, + DictWord{5, 0, 482}, + DictWord{8, 0, 98}, + DictWord{9, 0, 172}, + DictWord{10, 0, 360}, + DictWord{10, 0, 700}, + DictWord{10, 0, 822}, + DictWord{11, 0, 302}, + DictWord{11, 0, 778}, + DictWord{12, 0, 50}, + DictWord{12, 0, 127}, + DictWord{ + 12, + 0, + 396, + }, + DictWord{13, 0, 62}, + DictWord{13, 0, 328}, + DictWord{14, 0, 122}, + DictWord{147, 0, 72}, + DictWord{9, 11, 157}, + DictWord{10, 11, 131}, + DictWord{ + 140, + 11, + 72, + }, + DictWord{135, 11, 714}, + DictWord{135, 11, 539}, + DictWord{5, 0, 2}, + DictWord{6, 0, 512}, + DictWord{7, 0, 797}, + DictWord{7, 0, 1494}, + DictWord{8, 0, 253}, + DictWord{8, 0, 589}, + DictWord{9, 0, 77}, + DictWord{10, 0, 1}, + DictWord{10, 0, 129}, + DictWord{10, 0, 225}, + DictWord{11, 0, 118}, + DictWord{11, 0, 226}, + DictWord{ + 11, + 0, + 251, + }, + DictWord{11, 0, 430}, + DictWord{11, 0, 701}, + DictWord{11, 0, 974}, + DictWord{11, 0, 982}, + DictWord{12, 0, 64}, + DictWord{12, 0, 260}, + DictWord{12, 0, 488}, + DictWord{140, 0, 690}, + DictWord{5, 11, 394}, + DictWord{7, 11, 367}, + DictWord{7, 11, 487}, + DictWord{7, 11, 857}, + DictWord{7, 11, 1713}, + DictWord{8, 11, 246}, + DictWord{9, 11, 537}, + DictWord{10, 11, 165}, + DictWord{12, 11, 219}, + DictWord{140, 11, 561}, + DictWord{136, 0, 557}, + DictWord{5, 10, 779}, + DictWord{5, 10, 807}, + DictWord{6, 10, 1655}, + DictWord{134, 10, 1676}, + DictWord{4, 10, 196}, + DictWord{5, 10, 558}, + DictWord{133, 10, 949}, + DictWord{11, 11, 827}, + DictWord{ + 12, + 11, + 56, + }, + DictWord{14, 11, 34}, + DictWord{143, 11, 148}, + DictWord{137, 0, 347}, + DictWord{133, 0, 572}, + DictWord{134, 0, 832}, + DictWord{4, 0, 12}, + DictWord{ + 7, + 0, + 504, + }, + DictWord{7, 0, 522}, + DictWord{7, 0, 809}, + DictWord{8, 0, 797}, + DictWord{141, 0, 88}, + DictWord{4, 10, 752}, + DictWord{133, 11, 449}, + DictWord{7, 11, 86}, + DictWord{8, 11, 103}, + DictWord{145, 11, 69}, + DictWord{7, 11, 2028}, + DictWord{138, 11, 641}, + DictWord{5, 0, 528}, + DictWord{6, 11, 1}, + DictWord{142, 11, 2}, + DictWord{134, 0, 861}, + DictWord{10, 0, 294}, + DictWord{4, 10, 227}, + DictWord{5, 10, 159}, + DictWord{5, 10, 409}, + DictWord{7, 10, 80}, + DictWord{10, 10, 479}, + DictWord{ + 12, + 10, + 418, + }, + DictWord{14, 10, 50}, + DictWord{14, 10, 249}, + DictWord{142, 10, 295}, + DictWord{7, 10, 1470}, + DictWord{8, 10, 66}, + DictWord{8, 10, 137}, + DictWord{ + 8, + 10, + 761, + }, + DictWord{9, 10, 638}, + DictWord{11, 10, 80}, + DictWord{11, 10, 212}, + DictWord{11, 10, 368}, + DictWord{11, 10, 418}, + DictWord{12, 10, 8}, + DictWord{ + 13, + 10, + 15, + }, + DictWord{16, 10, 61}, + DictWord{17, 10, 59}, + DictWord{19, 10, 28}, + DictWord{148, 10, 84}, + DictWord{20, 0, 109}, + DictWord{135, 11, 1148}, + DictWord{ + 6, + 11, + 277, + }, + DictWord{7, 11, 1274}, + DictWord{7, 11, 1386}, + DictWord{7, 11, 1392}, + DictWord{12, 11, 129}, + DictWord{146, 11, 87}, + DictWord{6, 11, 187}, + DictWord{7, 11, 39}, + DictWord{7, 11, 1203}, + DictWord{8, 11, 380}, + DictWord{8, 11, 542}, + DictWord{14, 11, 117}, + DictWord{149, 11, 28}, + DictWord{134, 0, 1187}, + DictWord{5, 0, 266}, + DictWord{9, 0, 290}, + DictWord{9, 0, 364}, + DictWord{10, 0, 293}, + DictWord{11, 0, 606}, + DictWord{142, 0, 45}, + DictWord{6, 11, 297}, + DictWord{ + 7, + 11, + 793, + }, + DictWord{139, 11, 938}, + DictWord{4, 0, 50}, + DictWord{6, 0, 594}, + DictWord{9, 0, 121}, + DictWord{10, 0, 49}, + DictWord{10, 0, 412}, + DictWord{139, 0, 834}, + DictWord{136, 0, 748}, + DictWord{7, 11, 464}, + DictWord{8, 11, 438}, + DictWord{11, 11, 105}, + DictWord{11, 11, 363}, + DictWord{12, 11, 231}, + DictWord{ + 14, + 11, + 386, + }, + DictWord{15, 11, 102}, + DictWord{148, 11, 75}, + DictWord{132, 0, 466}, + DictWord{13, 0, 399}, + DictWord{14, 0, 337}, + DictWord{6, 10, 38}, + DictWord{ + 7, + 10, + 1220, + }, + DictWord{8, 10, 185}, + DictWord{8, 10, 256}, + DictWord{9, 10, 22}, + DictWord{9, 10, 331}, + DictWord{10, 10, 738}, + DictWord{11, 10, 205}, + DictWord{ + 11, + 10, + 540, + }, + DictWord{11, 10, 746}, + DictWord{13, 10, 465}, + DictWord{142, 10, 194}, + DictWord{9, 0, 378}, + DictWord{141, 0, 162}, + DictWord{137, 0, 519}, + DictWord{ + 4, + 10, + 159, + }, + DictWord{6, 10, 115}, + DictWord{7, 10, 252}, + DictWord{7, 10, 257}, + DictWord{7, 10, 1928}, + DictWord{8, 10, 69}, + DictWord{9, 10, 384}, + DictWord{ + 10, + 10, + 91, + }, + DictWord{10, 10, 615}, + DictWord{12, 10, 375}, + DictWord{14, 10, 235}, + DictWord{18, 10, 117}, + DictWord{147, 10, 123}, + DictWord{5, 11, 604}, + DictWord{ + 5, + 10, + 911, + }, + DictWord{136, 10, 278}, + DictWord{132, 0, 667}, + DictWord{8, 0, 351}, + DictWord{9, 0, 322}, + DictWord{4, 10, 151}, + DictWord{135, 10, 1567}, + DictWord{134, 0, 902}, + DictWord{133, 10, 990}, + DictWord{12, 0, 180}, + DictWord{5, 10, 194}, + DictWord{7, 10, 1662}, + DictWord{137, 10, 90}, + DictWord{4, 0, 869}, + DictWord{134, 0, 1996}, + DictWord{134, 0, 813}, + DictWord{133, 10, 425}, + DictWord{137, 11, 761}, + DictWord{132, 0, 260}, + DictWord{133, 10, 971}, + DictWord{ + 5, + 11, + 20, + }, + DictWord{6, 11, 298}, + DictWord{7, 11, 659}, + DictWord{7, 11, 1366}, + DictWord{137, 11, 219}, + DictWord{4, 0, 39}, + DictWord{5, 0, 36}, + DictWord{ + 7, + 0, + 1843, + }, + DictWord{8, 0, 407}, + DictWord{11, 0, 144}, + DictWord{140, 0, 523}, + DictWord{4, 0, 510}, + DictWord{10, 0, 587}, + DictWord{139, 10, 752}, + DictWord{7, 0, 29}, + DictWord{7, 0, 66}, + DictWord{7, 0, 1980}, + DictWord{10, 0, 487}, + DictWord{138, 0, 809}, + DictWord{13, 0, 260}, + DictWord{14, 0, 82}, + DictWord{18, 0, 63}, + DictWord{ + 137, + 10, + 662, + }, + DictWord{5, 10, 72}, + DictWord{6, 10, 264}, + DictWord{7, 10, 21}, + DictWord{7, 10, 46}, + DictWord{7, 10, 2013}, + DictWord{8, 10, 215}, + DictWord{ + 8, + 10, + 513, + }, + DictWord{10, 10, 266}, + DictWord{139, 10, 22}, + DictWord{134, 0, 570}, + DictWord{6, 0, 565}, + DictWord{7, 0, 1667}, + DictWord{4, 11, 439}, + DictWord{ + 10, + 10, + 95, + }, + DictWord{11, 10, 603}, + DictWord{12, 11, 242}, + DictWord{13, 10, 443}, + DictWord{14, 10, 160}, + DictWord{143, 10, 4}, + DictWord{134, 0, 1464}, + DictWord{ + 134, + 10, + 431, + }, + DictWord{9, 0, 372}, + DictWord{15, 0, 2}, + DictWord{19, 0, 10}, + DictWord{19, 0, 18}, + DictWord{5, 10, 874}, + DictWord{6, 10, 1677}, + DictWord{143, 10, 0}, + DictWord{132, 0, 787}, + DictWord{6, 0, 380}, + DictWord{12, 0, 399}, + DictWord{21, 0, 19}, + DictWord{7, 10, 939}, + DictWord{7, 10, 1172}, + DictWord{7, 10, 1671}, + DictWord{9, 10, 540}, + DictWord{10, 10, 696}, + DictWord{11, 10, 265}, + DictWord{11, 10, 732}, + DictWord{11, 10, 928}, + DictWord{11, 10, 937}, + DictWord{ + 141, + 10, + 438, + }, + DictWord{137, 0, 200}, + DictWord{132, 11, 233}, + DictWord{132, 0, 516}, + DictWord{134, 11, 577}, + DictWord{132, 0, 844}, + DictWord{11, 0, 887}, + DictWord{14, 0, 365}, + DictWord{142, 0, 375}, + DictWord{132, 11, 482}, + DictWord{8, 0, 821}, + DictWord{140, 0, 44}, + DictWord{7, 0, 1655}, + DictWord{136, 0, 305}, + DictWord{5, 10, 682}, + DictWord{135, 10, 1887}, + DictWord{135, 11, 346}, + DictWord{132, 10, 696}, + DictWord{4, 0, 10}, + DictWord{7, 0, 917}, + DictWord{139, 0, 786}, + DictWord{5, 11, 795}, + DictWord{6, 11, 1741}, + DictWord{8, 11, 417}, + DictWord{137, 11, 782}, + DictWord{4, 0, 1016}, + DictWord{134, 0, 2031}, + DictWord{5, 0, 684}, + DictWord{4, 10, 726}, + DictWord{133, 10, 630}, + DictWord{6, 0, 1021}, + DictWord{134, 0, 1480}, + DictWord{8, 10, 802}, + DictWord{136, 10, 838}, + DictWord{ + 134, + 0, + 27, + }, + DictWord{134, 0, 395}, + DictWord{135, 11, 622}, + DictWord{7, 11, 625}, + DictWord{135, 11, 1750}, + DictWord{4, 11, 203}, + DictWord{135, 11, 1936}, + DictWord{6, 10, 118}, + DictWord{7, 10, 215}, + DictWord{7, 10, 1521}, + DictWord{140, 10, 11}, + DictWord{132, 0, 813}, + DictWord{136, 0, 511}, + DictWord{7, 10, 615}, + DictWord{138, 10, 251}, + DictWord{135, 10, 1044}, + DictWord{145, 0, 56}, + DictWord{133, 10, 225}, + DictWord{6, 0, 342}, + DictWord{6, 0, 496}, + DictWord{8, 0, 275}, + DictWord{137, 0, 206}, + DictWord{4, 0, 909}, + DictWord{133, 0, 940}, + DictWord{132, 0, 891}, + DictWord{7, 11, 311}, + DictWord{9, 11, 308}, + DictWord{ + 140, + 11, + 255, + }, + DictWord{4, 10, 370}, + DictWord{5, 10, 756}, + DictWord{135, 10, 1326}, + DictWord{4, 0, 687}, + DictWord{134, 0, 1596}, + DictWord{134, 0, 1342}, + DictWord{ + 6, + 10, + 1662, + }, + DictWord{7, 10, 48}, + DictWord{8, 10, 771}, + DictWord{10, 10, 116}, + DictWord{13, 10, 104}, + DictWord{14, 10, 105}, + DictWord{14, 10, 184}, + DictWord{15, 10, 168}, + DictWord{19, 10, 92}, + DictWord{148, 10, 68}, + DictWord{138, 10, 209}, + DictWord{4, 11, 400}, + DictWord{5, 11, 267}, + DictWord{135, 11, 232}, + DictWord{151, 11, 12}, + DictWord{6, 0, 41}, + DictWord{141, 0, 160}, + DictWord{141, 11, 314}, + DictWord{134, 0, 1718}, + DictWord{136, 0, 778}, + DictWord{ + 142, + 11, + 261, + }, + DictWord{134, 0, 1610}, + DictWord{133, 0, 115}, + DictWord{132, 0, 294}, + DictWord{14, 0, 314}, + DictWord{132, 10, 120}, + DictWord{132, 0, 983}, + DictWord{5, 0, 193}, + DictWord{140, 0, 178}, + DictWord{138, 10, 429}, + DictWord{5, 10, 820}, + DictWord{135, 10, 931}, + DictWord{6, 0, 994}, + DictWord{6, 0, 1051}, + DictWord{6, 0, 1439}, + DictWord{7, 0, 174}, + DictWord{133, 11, 732}, + DictWord{4, 11, 100}, + DictWord{7, 11, 679}, + DictWord{8, 11, 313}, + DictWord{138, 10, 199}, + DictWord{6, 10, 151}, + DictWord{6, 10, 1675}, + DictWord{7, 10, 383}, + DictWord{151, 10, 10}, + DictWord{6, 0, 1796}, + DictWord{8, 0, 848}, + DictWord{8, 0, 867}, + DictWord{ + 8, + 0, + 907, + }, + DictWord{10, 0, 855}, + DictWord{140, 0, 703}, + DictWord{140, 0, 221}, + DictWord{4, 0, 122}, + DictWord{5, 0, 796}, + DictWord{5, 0, 952}, + DictWord{6, 0, 1660}, + DictWord{6, 0, 1671}, + DictWord{8, 0, 567}, + DictWord{9, 0, 687}, + DictWord{9, 0, 742}, + DictWord{10, 0, 686}, + DictWord{11, 0, 682}, + DictWord{11, 0, 909}, + DictWord{ + 140, + 0, + 281, + }, + DictWord{5, 11, 362}, + DictWord{5, 11, 443}, + DictWord{6, 11, 318}, + DictWord{7, 11, 1019}, + DictWord{139, 11, 623}, + DictWord{5, 11, 463}, + DictWord{136, 11, 296}, + DictWord{11, 0, 583}, + DictWord{13, 0, 262}, + DictWord{6, 10, 1624}, + DictWord{12, 10, 422}, + DictWord{142, 10, 360}, + DictWord{5, 0, 179}, + DictWord{7, 0, 1095}, + DictWord{135, 0, 1213}, + DictWord{4, 10, 43}, + DictWord{4, 11, 454}, + DictWord{5, 10, 344}, + DictWord{133, 10, 357}, + DictWord{4, 0, 66}, + DictWord{7, 0, 722}, + DictWord{135, 0, 904}, + DictWord{134, 0, 773}, + DictWord{7, 0, 352}, + DictWord{133, 10, 888}, + DictWord{5, 11, 48}, + DictWord{5, 11, 404}, + DictWord{ + 6, + 11, + 557, + }, + DictWord{7, 11, 458}, + DictWord{8, 11, 597}, + DictWord{10, 11, 455}, + DictWord{10, 11, 606}, + DictWord{11, 11, 49}, + DictWord{11, 11, 548}, + DictWord{ + 12, + 11, + 476, + }, + DictWord{13, 11, 18}, + DictWord{141, 11, 450}, + DictWord{134, 11, 418}, + DictWord{132, 10, 711}, + DictWord{5, 11, 442}, + DictWord{ + 135, + 11, + 1984, + }, + DictWord{141, 0, 35}, + DictWord{137, 0, 152}, + DictWord{134, 0, 1197}, + DictWord{135, 11, 1093}, + DictWord{137, 11, 203}, + DictWord{137, 10, 440}, + DictWord{10, 0, 592}, + DictWord{10, 0, 753}, + DictWord{12, 0, 317}, + DictWord{12, 0, 355}, + DictWord{12, 0, 465}, + DictWord{12, 0, 469}, + DictWord{12, 0, 560}, + DictWord{12, 0, 578}, + DictWord{141, 0, 243}, + DictWord{133, 0, 564}, + DictWord{134, 0, 797}, + DictWord{5, 10, 958}, + DictWord{133, 10, 987}, + DictWord{5, 11, 55}, + DictWord{7, 11, 376}, + DictWord{140, 11, 161}, + DictWord{133, 11, 450}, + DictWord{134, 0, 556}, + DictWord{134, 0, 819}, + DictWord{11, 10, 276}, + DictWord{ + 142, + 10, + 293, + }, + DictWord{7, 0, 544}, + DictWord{138, 0, 61}, + DictWord{8, 0, 719}, + DictWord{4, 10, 65}, + DictWord{5, 10, 479}, + DictWord{5, 10, 1004}, + DictWord{7, 10, 1913}, + DictWord{8, 10, 317}, + DictWord{9, 10, 302}, + DictWord{10, 10, 612}, + DictWord{141, 10, 22}, + DictWord{4, 0, 5}, + DictWord{5, 0, 498}, + DictWord{8, 0, 637}, + DictWord{ + 9, + 0, + 521, + }, + DictWord{4, 11, 213}, + DictWord{4, 10, 261}, + DictWord{7, 11, 223}, + DictWord{7, 10, 510}, + DictWord{136, 11, 80}, + DictWord{5, 0, 927}, + DictWord{7, 0, 101}, + DictWord{4, 10, 291}, + DictWord{7, 11, 381}, + DictWord{7, 11, 806}, + DictWord{7, 11, 820}, + DictWord{8, 11, 354}, + DictWord{8, 11, 437}, + DictWord{8, 11, 787}, + DictWord{9, 10, 515}, + DictWord{9, 11, 657}, + DictWord{10, 11, 58}, + DictWord{10, 11, 339}, + DictWord{10, 11, 749}, + DictWord{11, 11, 914}, + DictWord{12, 10, 152}, + DictWord{12, 11, 162}, + DictWord{12, 10, 443}, + DictWord{13, 11, 75}, + DictWord{13, 10, 392}, + DictWord{14, 11, 106}, + DictWord{14, 11, 198}, + DictWord{ + 14, + 11, + 320, + }, + DictWord{14, 10, 357}, + DictWord{14, 11, 413}, + DictWord{146, 11, 43}, + DictWord{6, 0, 1153}, + DictWord{7, 0, 1441}, + DictWord{136, 11, 747}, + DictWord{ + 4, + 0, + 893, + }, + DictWord{5, 0, 780}, + DictWord{133, 0, 893}, + DictWord{138, 11, 654}, + DictWord{133, 11, 692}, + DictWord{133, 0, 238}, + DictWord{134, 11, 191}, + DictWord{4, 10, 130}, + DictWord{135, 10, 843}, + DictWord{6, 0, 1296}, + DictWord{5, 10, 42}, + DictWord{5, 10, 879}, + DictWord{7, 10, 245}, + DictWord{7, 10, 324}, + DictWord{ + 7, + 10, + 1532, + }, + DictWord{11, 10, 463}, + DictWord{11, 10, 472}, + DictWord{13, 10, 363}, + DictWord{144, 10, 52}, + DictWord{134, 0, 1729}, + DictWord{6, 0, 1999}, + DictWord{136, 0, 969}, + DictWord{4, 10, 134}, + DictWord{133, 10, 372}, + DictWord{4, 0, 60}, + DictWord{7, 0, 941}, + DictWord{7, 0, 1800}, + DictWord{8, 0, 314}, + DictWord{ + 9, + 0, + 700, + }, + DictWord{139, 0, 487}, + DictWord{134, 0, 1144}, + DictWord{6, 11, 162}, + DictWord{7, 11, 1960}, + DictWord{136, 11, 831}, + DictWord{132, 11, 706}, + DictWord{135, 0, 1147}, + DictWord{138, 11, 426}, + DictWord{138, 11, 89}, + DictWord{7, 0, 1853}, + DictWord{138, 0, 437}, + DictWord{136, 0, 419}, + DictWord{ + 135, + 10, + 1634, + }, + DictWord{133, 0, 828}, + DictWord{5, 0, 806}, + DictWord{7, 0, 176}, + DictWord{7, 0, 178}, + DictWord{7, 0, 1240}, + DictWord{7, 0, 1976}, + DictWord{ + 132, + 10, + 644, + }, + DictWord{135, 11, 1877}, + DictWord{5, 11, 420}, + DictWord{135, 11, 1449}, + DictWord{4, 0, 51}, + DictWord{5, 0, 39}, + DictWord{6, 0, 4}, + DictWord{7, 0, 591}, + DictWord{7, 0, 849}, + DictWord{7, 0, 951}, + DictWord{7, 0, 1613}, + DictWord{7, 0, 1760}, + DictWord{7, 0, 1988}, + DictWord{9, 0, 434}, + DictWord{10, 0, 754}, + DictWord{ + 11, + 0, + 25, + }, + DictWord{139, 0, 37}, + DictWord{10, 11, 57}, + DictWord{138, 11, 277}, + DictWord{135, 10, 540}, + DictWord{132, 11, 204}, + DictWord{135, 0, 159}, + DictWord{139, 11, 231}, + DictWord{133, 0, 902}, + DictWord{7, 0, 928}, + DictWord{7, 11, 366}, + DictWord{9, 11, 287}, + DictWord{12, 11, 199}, + DictWord{12, 11, 556}, + DictWord{140, 11, 577}, + DictWord{6, 10, 623}, + DictWord{136, 10, 789}, + DictWord{4, 10, 908}, + DictWord{5, 10, 359}, + DictWord{5, 10, 508}, + DictWord{6, 10, 1723}, + DictWord{7, 10, 343}, + DictWord{7, 10, 1996}, + DictWord{135, 10, 2026}, + DictWord{134, 0, 270}, + DictWord{4, 10, 341}, + DictWord{135, 10, 480}, + DictWord{ + 5, + 11, + 356, + }, + DictWord{135, 11, 224}, + DictWord{11, 11, 588}, + DictWord{11, 11, 864}, + DictWord{11, 11, 968}, + DictWord{143, 11, 160}, + DictWord{132, 0, 556}, + DictWord{137, 0, 801}, + DictWord{132, 0, 416}, + DictWord{142, 0, 372}, + DictWord{5, 0, 152}, + DictWord{5, 0, 197}, + DictWord{7, 0, 340}, + DictWord{7, 0, 867}, + DictWord{ + 10, + 0, + 548, + }, + DictWord{10, 0, 581}, + DictWord{11, 0, 6}, + DictWord{12, 0, 3}, + DictWord{12, 0, 19}, + DictWord{14, 0, 110}, + DictWord{142, 0, 289}, + DictWord{139, 0, 369}, + DictWord{7, 11, 630}, + DictWord{9, 11, 567}, + DictWord{11, 11, 150}, + DictWord{11, 11, 444}, + DictWord{141, 11, 119}, + DictWord{134, 11, 539}, + DictWord{ + 7, + 10, + 1995, + }, + DictWord{8, 10, 299}, + DictWord{11, 10, 890}, + DictWord{140, 10, 674}, + DictWord{7, 0, 34}, + DictWord{7, 0, 190}, + DictWord{8, 0, 28}, + DictWord{8, 0, 141}, + DictWord{8, 0, 444}, + DictWord{8, 0, 811}, + DictWord{9, 0, 468}, + DictWord{11, 0, 334}, + DictWord{12, 0, 24}, + DictWord{12, 0, 386}, + DictWord{140, 0, 576}, + DictWord{ + 133, + 0, + 757, + }, + DictWord{7, 0, 1553}, + DictWord{136, 0, 898}, + DictWord{133, 0, 721}, + DictWord{136, 0, 1012}, + DictWord{4, 0, 789}, + DictWord{5, 0, 647}, + DictWord{ + 135, + 0, + 1102, + }, + DictWord{132, 0, 898}, + DictWord{10, 0, 183}, + DictWord{4, 10, 238}, + DictWord{5, 10, 503}, + DictWord{6, 10, 179}, + DictWord{7, 10, 2003}, + DictWord{ + 8, + 10, + 381, + }, + DictWord{8, 10, 473}, + DictWord{9, 10, 149}, + DictWord{10, 10, 788}, + DictWord{15, 10, 45}, + DictWord{15, 10, 86}, + DictWord{20, 10, 110}, + DictWord{ + 150, + 10, + 57, + }, + DictWord{9, 0, 136}, + DictWord{19, 0, 107}, + DictWord{4, 10, 121}, + DictWord{5, 10, 156}, + DictWord{5, 10, 349}, + DictWord{10, 10, 605}, + DictWord{ + 142, + 10, + 342, + }, + DictWord{4, 11, 235}, + DictWord{135, 11, 255}, + DictWord{4, 11, 194}, + DictWord{5, 11, 584}, + DictWord{6, 11, 384}, + DictWord{7, 11, 583}, + DictWord{ + 10, + 11, + 761, + }, + DictWord{11, 11, 760}, + DictWord{139, 11, 851}, + DictWord{6, 10, 80}, + DictWord{6, 10, 1694}, + DictWord{7, 10, 173}, + DictWord{7, 10, 1974}, + DictWord{ + 9, + 10, + 547, + }, + DictWord{10, 10, 730}, + DictWord{14, 10, 18}, + DictWord{150, 10, 39}, + DictWord{4, 10, 923}, + DictWord{134, 10, 1711}, + DictWord{5, 0, 277}, + DictWord{141, 0, 247}, + DictWord{132, 0, 435}, + DictWord{133, 11, 562}, + DictWord{134, 0, 1311}, + DictWord{5, 11, 191}, + DictWord{137, 11, 271}, + DictWord{ + 132, + 10, + 595, + }, + DictWord{7, 11, 1537}, + DictWord{14, 11, 96}, + DictWord{143, 11, 73}, + DictWord{5, 0, 437}, + DictWord{7, 0, 502}, + DictWord{7, 0, 519}, + DictWord{7, 0, 1122}, + DictWord{7, 0, 1751}, + DictWord{14, 0, 211}, + DictWord{6, 10, 459}, + DictWord{7, 10, 1753}, + DictWord{7, 10, 1805}, + DictWord{8, 10, 658}, + DictWord{9, 10, 1}, + DictWord{11, 10, 959}, + DictWord{141, 10, 446}, + DictWord{6, 0, 814}, + DictWord{4, 11, 470}, + DictWord{5, 11, 473}, + DictWord{6, 11, 153}, + DictWord{7, 11, 1503}, + DictWord{7, 11, 1923}, + DictWord{10, 11, 701}, + DictWord{11, 11, 132}, + DictWord{11, 11, 168}, + DictWord{11, 11, 227}, + DictWord{11, 11, 320}, + DictWord{ + 11, + 11, + 436, + }, + DictWord{11, 11, 525}, + DictWord{11, 11, 855}, + DictWord{12, 11, 41}, + DictWord{12, 11, 286}, + DictWord{13, 11, 103}, + DictWord{13, 11, 284}, + DictWord{ + 14, + 11, + 255, + }, + DictWord{14, 11, 262}, + DictWord{15, 11, 117}, + DictWord{143, 11, 127}, + DictWord{5, 0, 265}, + DictWord{6, 0, 212}, + DictWord{135, 0, 28}, + DictWord{ + 138, + 0, + 750, + }, + DictWord{133, 11, 327}, + DictWord{6, 11, 552}, + DictWord{7, 11, 1754}, + DictWord{137, 11, 604}, + DictWord{134, 0, 2012}, + DictWord{132, 0, 702}, + DictWord{5, 11, 80}, + DictWord{6, 11, 405}, + DictWord{7, 11, 403}, + DictWord{7, 11, 1502}, + DictWord{7, 11, 1626}, + DictWord{8, 11, 456}, + DictWord{9, 11, 487}, + DictWord{9, 11, 853}, + DictWord{9, 11, 889}, + DictWord{10, 11, 309}, + DictWord{11, 11, 721}, + DictWord{11, 11, 994}, + DictWord{12, 11, 430}, + DictWord{ + 141, + 11, + 165, + }, + DictWord{5, 0, 808}, + DictWord{135, 0, 2045}, + DictWord{5, 0, 166}, + DictWord{8, 0, 739}, + DictWord{140, 0, 511}, + DictWord{134, 10, 490}, + DictWord{ + 4, + 11, + 453, + }, + DictWord{5, 11, 887}, + DictWord{6, 11, 535}, + DictWord{8, 11, 6}, + DictWord{136, 11, 543}, + DictWord{4, 0, 119}, + DictWord{5, 0, 170}, + DictWord{5, 0, 447}, + DictWord{7, 0, 1708}, + DictWord{7, 0, 1889}, + DictWord{9, 0, 357}, + DictWord{9, 0, 719}, + DictWord{12, 0, 486}, + DictWord{140, 0, 596}, + DictWord{137, 0, 500}, + DictWord{ + 7, + 10, + 250, + }, + DictWord{136, 10, 507}, + DictWord{132, 10, 158}, + DictWord{6, 0, 809}, + DictWord{134, 0, 1500}, + DictWord{9, 0, 327}, + DictWord{11, 0, 350}, + DictWord{11, 0, 831}, + DictWord{13, 0, 352}, + DictWord{4, 10, 140}, + DictWord{7, 10, 362}, + DictWord{8, 10, 209}, + DictWord{9, 10, 10}, + DictWord{9, 10, 503}, + DictWord{ + 9, + 10, + 614, + }, + DictWord{10, 10, 689}, + DictWord{11, 10, 327}, + DictWord{11, 10, 725}, + DictWord{12, 10, 252}, + DictWord{12, 10, 583}, + DictWord{13, 10, 192}, + DictWord{14, 10, 269}, + DictWord{14, 10, 356}, + DictWord{148, 10, 50}, + DictWord{135, 11, 741}, + DictWord{4, 0, 450}, + DictWord{7, 0, 1158}, + DictWord{19, 10, 1}, + DictWord{19, 10, 26}, + DictWord{150, 10, 9}, + DictWord{6, 0, 597}, + DictWord{135, 0, 1318}, + DictWord{134, 0, 1602}, + DictWord{6, 10, 228}, + DictWord{7, 10, 1341}, + DictWord{9, 10, 408}, + DictWord{138, 10, 343}, + DictWord{7, 0, 1375}, + DictWord{7, 0, 1466}, + DictWord{138, 0, 331}, + DictWord{132, 0, 754}, + DictWord{ + 132, + 10, + 557, + }, + DictWord{5, 11, 101}, + DictWord{6, 11, 88}, + DictWord{6, 11, 543}, + DictWord{7, 11, 1677}, + DictWord{9, 11, 100}, + DictWord{10, 11, 677}, + DictWord{ + 14, + 11, + 169, + }, + DictWord{14, 11, 302}, + DictWord{14, 11, 313}, + DictWord{15, 11, 48}, + DictWord{143, 11, 84}, + DictWord{134, 0, 1368}, + DictWord{4, 11, 310}, + DictWord{ + 9, + 11, + 795, + }, + DictWord{10, 11, 733}, + DictWord{11, 11, 451}, + DictWord{12, 11, 249}, + DictWord{14, 11, 115}, + DictWord{14, 11, 286}, + DictWord{143, 11, 100}, + DictWord{132, 10, 548}, + DictWord{10, 0, 557}, + DictWord{7, 10, 197}, + DictWord{8, 10, 142}, + DictWord{8, 10, 325}, + DictWord{9, 10, 150}, + DictWord{9, 10, 596}, + DictWord{10, 10, 353}, + DictWord{11, 10, 74}, + DictWord{11, 10, 315}, + DictWord{12, 10, 662}, + DictWord{12, 10, 681}, + DictWord{14, 10, 423}, + DictWord{ + 143, + 10, + 141, + }, + DictWord{133, 11, 587}, + DictWord{5, 0, 850}, + DictWord{136, 0, 799}, + DictWord{10, 0, 908}, + DictWord{12, 0, 701}, + DictWord{12, 0, 757}, + DictWord{ + 142, + 0, + 466, + }, + DictWord{4, 0, 62}, + DictWord{5, 0, 275}, + DictWord{18, 0, 19}, + DictWord{6, 10, 399}, + DictWord{6, 10, 579}, + DictWord{7, 10, 692}, + DictWord{7, 10, 846}, + DictWord{ + 7, + 10, + 1015, + }, + DictWord{7, 10, 1799}, + DictWord{8, 10, 403}, + DictWord{9, 10, 394}, + DictWord{10, 10, 133}, + DictWord{12, 10, 4}, + DictWord{12, 10, 297}, + DictWord{12, 10, 452}, + DictWord{16, 10, 81}, + DictWord{18, 10, 25}, + DictWord{21, 10, 14}, + DictWord{22, 10, 12}, + DictWord{151, 10, 18}, + DictWord{12, 0, 459}, + DictWord{ + 7, + 10, + 1546, + }, + DictWord{11, 10, 299}, + DictWord{142, 10, 407}, + DictWord{132, 10, 177}, + DictWord{132, 11, 498}, + DictWord{7, 11, 217}, + DictWord{ + 8, + 11, + 140, + }, + DictWord{138, 11, 610}, + DictWord{5, 10, 411}, + DictWord{135, 10, 653}, + DictWord{134, 0, 1802}, + DictWord{7, 10, 439}, + DictWord{10, 10, 727}, + DictWord{11, 10, 260}, + DictWord{139, 10, 684}, + DictWord{133, 11, 905}, + DictWord{11, 11, 580}, + DictWord{142, 11, 201}, + DictWord{134, 0, 1397}, + DictWord{ + 5, + 10, + 208, + }, + DictWord{7, 10, 753}, + DictWord{135, 10, 1528}, + DictWord{7, 0, 238}, + DictWord{7, 0, 2033}, + DictWord{8, 0, 120}, + DictWord{8, 0, 188}, + DictWord{8, 0, 659}, + DictWord{9, 0, 598}, + DictWord{10, 0, 466}, + DictWord{12, 0, 342}, + DictWord{12, 0, 588}, + DictWord{13, 0, 503}, + DictWord{14, 0, 246}, + DictWord{143, 0, 92}, + DictWord{135, 11, 1041}, + DictWord{4, 11, 456}, + DictWord{7, 11, 105}, + DictWord{7, 11, 358}, + DictWord{7, 11, 1637}, + DictWord{8, 11, 643}, + DictWord{139, 11, 483}, + DictWord{6, 0, 1318}, + DictWord{134, 0, 1324}, + DictWord{4, 0, 201}, + DictWord{7, 0, 1744}, + DictWord{8, 0, 602}, + DictWord{11, 0, 247}, + DictWord{11, 0, 826}, + DictWord{17, 0, 65}, + DictWord{133, 10, 242}, + DictWord{8, 0, 164}, + DictWord{146, 0, 62}, + DictWord{133, 10, 953}, + DictWord{139, 10, 802}, + DictWord{133, 0, 615}, + DictWord{7, 11, 1566}, + DictWord{8, 11, 269}, + DictWord{9, 11, 212}, + DictWord{9, 11, 718}, + DictWord{14, 11, 15}, + DictWord{14, 11, 132}, + DictWord{142, 11, 227}, + DictWord{133, 10, 290}, + DictWord{132, 10, 380}, + DictWord{5, 10, 52}, + DictWord{7, 10, 277}, + DictWord{9, 10, 368}, + DictWord{139, 10, 791}, + DictWord{ + 135, + 0, + 1243, + }, + DictWord{133, 11, 539}, + DictWord{11, 11, 919}, + DictWord{141, 11, 409}, + DictWord{136, 0, 968}, + DictWord{133, 11, 470}, + DictWord{134, 0, 882}, + DictWord{132, 0, 907}, + DictWord{5, 0, 100}, + DictWord{10, 0, 329}, + DictWord{12, 0, 416}, + DictWord{149, 0, 29}, + DictWord{10, 10, 138}, + DictWord{139, 10, 476}, + DictWord{5, 10, 725}, + DictWord{5, 10, 727}, + DictWord{6, 11, 91}, + DictWord{7, 11, 435}, + DictWord{135, 10, 1811}, + DictWord{4, 11, 16}, + DictWord{5, 11, 316}, + DictWord{5, 11, 842}, + DictWord{6, 11, 370}, + DictWord{6, 11, 1778}, + DictWord{8, 11, 166}, + DictWord{11, 11, 812}, + DictWord{12, 11, 206}, + DictWord{12, 11, 351}, + DictWord{14, 11, 418}, + DictWord{16, 11, 15}, + DictWord{16, 11, 34}, + DictWord{18, 11, 3}, + DictWord{19, 11, 3}, + DictWord{19, 11, 7}, + DictWord{20, 11, 4}, + DictWord{ + 149, + 11, + 21, + }, + DictWord{132, 0, 176}, + DictWord{5, 0, 636}, + DictWord{5, 0, 998}, + DictWord{7, 0, 9}, + DictWord{7, 0, 1508}, + DictWord{8, 0, 26}, + DictWord{9, 0, 317}, + DictWord{ + 9, + 0, + 358, + }, + DictWord{10, 0, 210}, + DictWord{10, 0, 292}, + DictWord{10, 0, 533}, + DictWord{11, 0, 555}, + DictWord{12, 0, 526}, + DictWord{12, 0, 607}, + DictWord{ + 13, + 0, + 263, + }, + DictWord{13, 0, 459}, + DictWord{142, 0, 271}, + DictWord{6, 0, 256}, + DictWord{8, 0, 265}, + DictWord{4, 10, 38}, + DictWord{7, 10, 307}, + DictWord{7, 10, 999}, + DictWord{7, 10, 1481}, + DictWord{7, 10, 1732}, + DictWord{7, 10, 1738}, + DictWord{9, 10, 414}, + DictWord{11, 10, 316}, + DictWord{12, 10, 52}, + DictWord{13, 10, 420}, + DictWord{147, 10, 100}, + DictWord{135, 10, 1296}, + DictWord{4, 11, 611}, + DictWord{133, 11, 606}, + DictWord{4, 0, 643}, + DictWord{142, 11, 21}, + DictWord{ + 133, + 11, + 715, + }, + DictWord{133, 10, 723}, + DictWord{6, 0, 610}, + DictWord{135, 11, 597}, + DictWord{10, 0, 127}, + DictWord{141, 0, 27}, + DictWord{6, 0, 1995}, + DictWord{ + 6, + 0, + 2001, + }, + DictWord{8, 0, 119}, + DictWord{136, 0, 973}, + DictWord{4, 11, 149}, + DictWord{138, 11, 368}, + DictWord{12, 0, 522}, + DictWord{4, 11, 154}, + DictWord{ + 5, + 10, + 109, + }, + DictWord{6, 10, 1784}, + DictWord{7, 11, 1134}, + DictWord{7, 10, 1895}, + DictWord{8, 11, 105}, + DictWord{12, 10, 296}, + DictWord{140, 10, 302}, + DictWord{4, 11, 31}, + DictWord{6, 11, 429}, + DictWord{7, 11, 962}, + DictWord{9, 11, 458}, + DictWord{139, 11, 691}, + DictWord{10, 0, 553}, + DictWord{11, 0, 876}, + DictWord{13, 0, 193}, + DictWord{13, 0, 423}, + DictWord{14, 0, 166}, + DictWord{19, 0, 84}, + DictWord{4, 11, 312}, + DictWord{5, 10, 216}, + DictWord{7, 10, 1879}, + DictWord{ + 9, + 10, + 141, + }, + DictWord{9, 10, 270}, + DictWord{9, 10, 679}, + DictWord{10, 10, 159}, + DictWord{11, 10, 197}, + DictWord{12, 10, 538}, + DictWord{12, 10, 559}, + DictWord{14, 10, 144}, + DictWord{14, 10, 167}, + DictWord{143, 10, 67}, + DictWord{134, 0, 1582}, + DictWord{7, 0, 1578}, + DictWord{135, 11, 1578}, + DictWord{ + 137, + 10, + 81, + }, + DictWord{132, 11, 236}, + DictWord{134, 10, 391}, + DictWord{134, 0, 795}, + DictWord{7, 10, 322}, + DictWord{136, 10, 249}, + DictWord{5, 11, 836}, + DictWord{ + 5, + 11, + 857, + }, + DictWord{6, 11, 1680}, + DictWord{7, 11, 59}, + DictWord{147, 11, 53}, + DictWord{135, 0, 432}, + DictWord{10, 11, 68}, + DictWord{139, 11, 494}, + DictWord{4, 11, 81}, + DictWord{139, 11, 867}, + DictWord{7, 0, 126}, + DictWord{136, 0, 84}, + DictWord{142, 11, 280}, + DictWord{5, 11, 282}, + DictWord{8, 11, 650}, + DictWord{ + 9, + 11, + 295, + }, + DictWord{9, 11, 907}, + DictWord{138, 11, 443}, + DictWord{136, 0, 790}, + DictWord{5, 10, 632}, + DictWord{138, 10, 526}, + DictWord{6, 0, 64}, + DictWord{12, 0, 377}, + DictWord{13, 0, 309}, + DictWord{14, 0, 141}, + DictWord{14, 0, 429}, + DictWord{14, 11, 141}, + DictWord{142, 11, 429}, + DictWord{134, 0, 1529}, + DictWord{6, 0, 321}, + DictWord{7, 0, 1857}, + DictWord{9, 0, 530}, + DictWord{19, 0, 99}, + DictWord{7, 10, 948}, + DictWord{7, 10, 1042}, + DictWord{8, 10, 235}, + DictWord{ + 8, + 10, + 461, + }, + DictWord{9, 10, 453}, + DictWord{10, 10, 354}, + DictWord{145, 10, 77}, + DictWord{7, 0, 1104}, + DictWord{11, 0, 269}, + DictWord{11, 0, 539}, + DictWord{ + 11, + 0, + 627, + }, + DictWord{11, 0, 706}, + DictWord{11, 0, 975}, + DictWord{12, 0, 248}, + DictWord{12, 0, 434}, + DictWord{12, 0, 600}, + DictWord{12, 0, 622}, + DictWord{ + 13, + 0, + 297, + }, + DictWord{13, 0, 485}, + DictWord{14, 0, 69}, + DictWord{14, 0, 409}, + DictWord{143, 0, 108}, + DictWord{4, 10, 362}, + DictWord{7, 10, 52}, + DictWord{7, 10, 303}, + DictWord{10, 11, 70}, + DictWord{12, 11, 26}, + DictWord{14, 11, 17}, + DictWord{14, 11, 178}, + DictWord{15, 11, 34}, + DictWord{149, 11, 12}, + DictWord{11, 0, 977}, + DictWord{141, 0, 507}, + DictWord{9, 0, 34}, + DictWord{139, 0, 484}, + DictWord{5, 10, 196}, + DictWord{6, 10, 486}, + DictWord{7, 10, 212}, + DictWord{8, 10, 309}, + DictWord{136, 10, 346}, + DictWord{6, 0, 1700}, + DictWord{7, 0, 26}, + DictWord{7, 0, 293}, + DictWord{7, 0, 382}, + DictWord{7, 0, 1026}, + DictWord{7, 0, 1087}, + DictWord{ + 7, + 0, + 2027, + }, + DictWord{8, 0, 24}, + DictWord{8, 0, 114}, + DictWord{8, 0, 252}, + DictWord{8, 0, 727}, + DictWord{8, 0, 729}, + DictWord{9, 0, 30}, + DictWord{9, 0, 199}, + DictWord{ + 9, + 0, + 231, + }, + DictWord{9, 0, 251}, + DictWord{9, 0, 334}, + DictWord{9, 0, 361}, + DictWord{9, 0, 712}, + DictWord{10, 0, 55}, + DictWord{10, 0, 60}, + DictWord{10, 0, 232}, + DictWord{ + 10, + 0, + 332, + }, + DictWord{10, 0, 384}, + DictWord{10, 0, 396}, + DictWord{10, 0, 504}, + DictWord{10, 0, 542}, + DictWord{10, 0, 652}, + DictWord{11, 0, 20}, + DictWord{11, 0, 48}, + DictWord{11, 0, 207}, + DictWord{11, 0, 291}, + DictWord{11, 0, 298}, + DictWord{11, 0, 342}, + DictWord{11, 0, 365}, + DictWord{11, 0, 394}, + DictWord{11, 0, 620}, + DictWord{11, 0, 705}, + DictWord{11, 0, 1017}, + DictWord{12, 0, 123}, + DictWord{12, 0, 340}, + DictWord{12, 0, 406}, + DictWord{12, 0, 643}, + DictWord{13, 0, 61}, + DictWord{ + 13, + 0, + 269, + }, + DictWord{13, 0, 311}, + DictWord{13, 0, 319}, + DictWord{13, 0, 486}, + DictWord{14, 0, 234}, + DictWord{15, 0, 62}, + DictWord{15, 0, 85}, + DictWord{16, 0, 71}, + DictWord{18, 0, 119}, + DictWord{20, 0, 105}, + DictWord{135, 10, 1912}, + DictWord{4, 11, 71}, + DictWord{5, 11, 376}, + DictWord{7, 11, 119}, + DictWord{138, 11, 665}, + DictWord{10, 0, 918}, + DictWord{10, 0, 926}, + DictWord{4, 10, 686}, + DictWord{136, 11, 55}, + DictWord{138, 10, 625}, + DictWord{136, 10, 706}, + DictWord{ + 132, + 11, + 479, + }, + DictWord{4, 10, 30}, + DictWord{133, 10, 43}, + DictWord{6, 0, 379}, + DictWord{7, 0, 270}, + DictWord{8, 0, 176}, + DictWord{8, 0, 183}, + DictWord{9, 0, 432}, + DictWord{ + 9, + 0, + 661, + }, + DictWord{12, 0, 247}, + DictWord{12, 0, 617}, + DictWord{18, 0, 125}, + DictWord{7, 11, 607}, + DictWord{8, 11, 99}, + DictWord{152, 11, 4}, + DictWord{ + 5, + 0, + 792, + }, + DictWord{133, 0, 900}, + DictWord{4, 11, 612}, + DictWord{133, 11, 561}, + DictWord{4, 11, 41}, + DictWord{4, 10, 220}, + DictWord{5, 11, 74}, + DictWord{ + 7, + 10, + 1535, + }, + DictWord{7, 11, 1627}, + DictWord{11, 11, 871}, + DictWord{140, 11, 619}, + DictWord{135, 0, 1920}, + DictWord{7, 11, 94}, + DictWord{11, 11, 329}, + DictWord{11, 11, 965}, + DictWord{12, 11, 241}, + DictWord{14, 11, 354}, + DictWord{15, 11, 22}, + DictWord{148, 11, 63}, + DictWord{9, 11, 209}, + DictWord{137, 11, 300}, + DictWord{134, 0, 771}, + DictWord{135, 0, 1979}, + DictWord{4, 0, 901}, + DictWord{133, 0, 776}, + DictWord{142, 0, 254}, + DictWord{133, 11, 98}, + DictWord{ + 9, + 11, + 16, + }, + DictWord{141, 11, 386}, + DictWord{133, 11, 984}, + DictWord{4, 11, 182}, + DictWord{6, 11, 205}, + DictWord{135, 11, 220}, + DictWord{7, 10, 1725}, + DictWord{ + 7, + 10, + 1774, + }, + DictWord{138, 10, 393}, + DictWord{5, 10, 263}, + DictWord{134, 10, 414}, + DictWord{4, 11, 42}, + DictWord{9, 11, 205}, + DictWord{9, 11, 786}, + DictWord{138, 11, 659}, + DictWord{14, 0, 140}, + DictWord{148, 0, 41}, + DictWord{8, 0, 440}, + DictWord{10, 0, 359}, + DictWord{6, 10, 178}, + DictWord{6, 11, 289}, + DictWord{ + 6, + 10, + 1750, + }, + DictWord{7, 11, 1670}, + DictWord{9, 10, 690}, + DictWord{10, 10, 155}, + DictWord{10, 10, 373}, + DictWord{11, 10, 698}, + DictWord{12, 11, 57}, + DictWord{13, 10, 155}, + DictWord{20, 10, 93}, + DictWord{151, 11, 4}, + DictWord{4, 0, 37}, + DictWord{5, 0, 334}, + DictWord{7, 0, 1253}, + DictWord{151, 11, 25}, + DictWord{ + 4, + 0, + 508, + }, + DictWord{4, 11, 635}, + DictWord{5, 10, 97}, + DictWord{137, 10, 393}, + DictWord{139, 11, 533}, + DictWord{4, 0, 640}, + DictWord{133, 0, 513}, + DictWord{ + 134, + 10, + 1639, + }, + DictWord{132, 11, 371}, + DictWord{4, 11, 272}, + DictWord{7, 11, 836}, + DictWord{7, 11, 1651}, + DictWord{145, 11, 89}, + DictWord{5, 11, 825}, + DictWord{6, 11, 444}, + DictWord{6, 11, 1640}, + DictWord{136, 11, 308}, + DictWord{4, 10, 191}, + DictWord{7, 10, 934}, + DictWord{8, 10, 647}, + DictWord{145, 10, 97}, + DictWord{12, 0, 246}, + DictWord{15, 0, 162}, + DictWord{19, 0, 64}, + DictWord{20, 0, 8}, + DictWord{20, 0, 95}, + DictWord{22, 0, 24}, + DictWord{152, 0, 17}, + DictWord{4, 0, 533}, + DictWord{5, 10, 165}, + DictWord{9, 10, 346}, + DictWord{138, 10, 655}, + DictWord{5, 11, 737}, + DictWord{139, 10, 885}, + DictWord{133, 10, 877}, + DictWord{ + 8, + 10, + 128, + }, + DictWord{139, 10, 179}, + DictWord{137, 11, 307}, + DictWord{140, 0, 752}, + DictWord{133, 0, 920}, + DictWord{135, 0, 1048}, + DictWord{5, 0, 153}, + DictWord{ + 6, + 0, + 580, + }, + DictWord{6, 10, 1663}, + DictWord{7, 10, 132}, + DictWord{7, 10, 1154}, + DictWord{7, 10, 1415}, + DictWord{7, 10, 1507}, + DictWord{12, 10, 493}, + DictWord{15, 10, 105}, + DictWord{151, 10, 15}, + DictWord{5, 10, 459}, + DictWord{7, 10, 1073}, + DictWord{8, 10, 241}, + DictWord{136, 10, 334}, + DictWord{138, 0, 391}, + DictWord{135, 0, 1952}, + DictWord{133, 11, 525}, + DictWord{8, 11, 641}, + DictWord{11, 11, 388}, + DictWord{140, 11, 580}, + DictWord{142, 0, 126}, + DictWord{ + 134, + 0, + 640, + }, + DictWord{132, 0, 483}, + DictWord{7, 0, 1616}, + DictWord{9, 0, 69}, + DictWord{6, 10, 324}, + DictWord{6, 10, 520}, + DictWord{7, 10, 338}, + DictWord{ + 7, + 10, + 1729, + }, + DictWord{8, 10, 228}, + DictWord{139, 10, 750}, + DictWord{5, 11, 493}, + DictWord{134, 11, 528}, + DictWord{135, 0, 734}, + DictWord{4, 11, 174}, + DictWord{135, 11, 911}, + DictWord{138, 0, 480}, + DictWord{9, 0, 495}, + DictWord{146, 0, 104}, + DictWord{135, 10, 705}, + DictWord{9, 0, 472}, + DictWord{4, 10, 73}, + DictWord{6, 10, 612}, + DictWord{7, 10, 927}, + DictWord{7, 10, 1330}, + DictWord{7, 10, 1822}, + DictWord{8, 10, 217}, + DictWord{9, 10, 765}, + DictWord{9, 10, 766}, + DictWord{10, 10, 408}, + DictWord{11, 10, 51}, + DictWord{11, 10, 793}, + DictWord{12, 10, 266}, + DictWord{15, 10, 158}, + DictWord{20, 10, 89}, + DictWord{150, 10, 32}, + DictWord{7, 11, 548}, + DictWord{137, 11, 58}, + DictWord{4, 11, 32}, + DictWord{5, 11, 215}, + DictWord{6, 11, 269}, + DictWord{7, 11, 1782}, + DictWord{7, 11, 1892}, + DictWord{10, 11, 16}, + DictWord{11, 11, 822}, + DictWord{11, 11, 954}, + DictWord{141, 11, 481}, + DictWord{132, 0, 874}, + DictWord{9, 0, 229}, + DictWord{5, 10, 389}, + DictWord{136, 10, 636}, + DictWord{7, 11, 1749}, + DictWord{136, 11, 477}, + DictWord{134, 0, 948}, + DictWord{5, 11, 308}, + DictWord{135, 11, 1088}, + DictWord{ + 4, + 0, + 748, + }, + DictWord{139, 0, 1009}, + DictWord{136, 10, 21}, + DictWord{6, 0, 555}, + DictWord{135, 0, 485}, + DictWord{5, 11, 126}, + DictWord{8, 11, 297}, + DictWord{ + 9, + 11, + 366, + }, + DictWord{9, 11, 445}, + DictWord{12, 11, 53}, + DictWord{12, 11, 374}, + DictWord{141, 11, 492}, + DictWord{7, 11, 1551}, + DictWord{139, 11, 361}, + DictWord{136, 0, 193}, + DictWord{136, 0, 472}, + DictWord{8, 0, 653}, + DictWord{13, 0, 93}, + DictWord{147, 0, 14}, + DictWord{132, 0, 984}, + DictWord{132, 11, 175}, + DictWord{5, 0, 172}, + DictWord{6, 0, 1971}, + DictWord{132, 11, 685}, + DictWord{149, 11, 8}, + DictWord{133, 11, 797}, + DictWord{13, 0, 83}, + DictWord{5, 10, 189}, + DictWord{ + 7, + 10, + 442, + }, + DictWord{7, 10, 443}, + DictWord{8, 10, 281}, + DictWord{12, 10, 174}, + DictWord{141, 10, 261}, + DictWord{134, 0, 1568}, + DictWord{133, 11, 565}, + DictWord{139, 0, 384}, + DictWord{133, 0, 260}, + DictWord{7, 0, 758}, + DictWord{7, 0, 880}, + DictWord{7, 0, 1359}, + DictWord{9, 0, 164}, + DictWord{9, 0, 167}, + DictWord{ + 10, + 0, + 156, + }, + DictWord{10, 0, 588}, + DictWord{12, 0, 101}, + DictWord{14, 0, 48}, + DictWord{15, 0, 70}, + DictWord{6, 10, 2}, + DictWord{7, 10, 1262}, + DictWord{ + 7, + 10, + 1737, + }, + DictWord{8, 10, 22}, + DictWord{8, 10, 270}, + DictWord{8, 10, 612}, + DictWord{9, 10, 312}, + DictWord{9, 10, 436}, + DictWord{10, 10, 311}, + DictWord{ + 10, + 10, + 623, + }, + DictWord{11, 10, 72}, + DictWord{11, 10, 330}, + DictWord{11, 10, 455}, + DictWord{12, 10, 321}, + DictWord{12, 10, 504}, + DictWord{12, 10, 530}, + DictWord{ + 12, + 10, + 543, + }, + DictWord{13, 10, 17}, + DictWord{13, 10, 156}, + DictWord{13, 10, 334}, + DictWord{17, 10, 60}, + DictWord{148, 10, 64}, + DictWord{4, 11, 252}, + DictWord{ + 7, + 11, + 1068, + }, + DictWord{10, 11, 434}, + DictWord{11, 11, 228}, + DictWord{11, 11, 426}, + DictWord{13, 11, 231}, + DictWord{18, 11, 106}, + DictWord{148, 11, 87}, + DictWord{7, 10, 354}, + DictWord{10, 10, 410}, + DictWord{139, 10, 815}, + DictWord{6, 0, 367}, + DictWord{7, 10, 670}, + DictWord{7, 10, 1327}, + DictWord{8, 10, 411}, + DictWord{8, 10, 435}, + DictWord{9, 10, 653}, + DictWord{9, 10, 740}, + DictWord{10, 10, 385}, + DictWord{11, 10, 222}, + DictWord{11, 10, 324}, + DictWord{11, 10, 829}, + DictWord{140, 10, 611}, + DictWord{7, 0, 1174}, + DictWord{6, 10, 166}, + DictWord{135, 10, 374}, + DictWord{146, 0, 121}, + DictWord{132, 0, 828}, + DictWord{ + 5, + 11, + 231, + }, + DictWord{138, 11, 509}, + DictWord{7, 11, 601}, + DictWord{9, 11, 277}, + DictWord{9, 11, 674}, + DictWord{10, 11, 178}, + DictWord{10, 11, 257}, + DictWord{ + 10, + 11, + 418, + }, + DictWord{11, 11, 531}, + DictWord{11, 11, 544}, + DictWord{11, 11, 585}, + DictWord{12, 11, 113}, + DictWord{12, 11, 475}, + DictWord{13, 11, 99}, + DictWord{142, 11, 428}, + DictWord{134, 0, 1541}, + DictWord{135, 11, 1779}, + DictWord{5, 0, 343}, + DictWord{134, 10, 398}, + DictWord{135, 10, 50}, + DictWord{ + 135, + 11, + 1683, + }, + DictWord{4, 0, 440}, + DictWord{7, 0, 57}, + DictWord{8, 0, 167}, + DictWord{8, 0, 375}, + DictWord{9, 0, 82}, + DictWord{9, 0, 561}, + DictWord{9, 0, 744}, + DictWord{ + 10, + 0, + 620, + }, + DictWord{137, 11, 744}, + DictWord{134, 0, 926}, + DictWord{6, 10, 517}, + DictWord{7, 10, 1159}, + DictWord{10, 10, 621}, + DictWord{139, 10, 192}, + DictWord{137, 0, 827}, + DictWord{8, 0, 194}, + DictWord{136, 0, 756}, + DictWord{10, 10, 223}, + DictWord{139, 10, 645}, + DictWord{7, 10, 64}, + DictWord{ + 136, + 10, + 245, + }, + DictWord{4, 11, 399}, + DictWord{5, 11, 119}, + DictWord{5, 11, 494}, + DictWord{7, 11, 751}, + DictWord{137, 11, 556}, + DictWord{132, 0, 808}, + DictWord{ + 135, + 0, + 22, + }, + DictWord{7, 10, 1763}, + DictWord{140, 10, 310}, + DictWord{5, 0, 639}, + DictWord{7, 0, 1249}, + DictWord{11, 0, 896}, + DictWord{134, 11, 584}, + DictWord{ + 134, + 0, + 1614, + }, + DictWord{135, 0, 860}, + DictWord{135, 11, 1121}, + DictWord{5, 10, 129}, + DictWord{6, 10, 61}, + DictWord{135, 10, 947}, + DictWord{4, 0, 102}, + DictWord{ + 7, + 0, + 815, + }, + DictWord{7, 0, 1699}, + DictWord{139, 0, 964}, + DictWord{13, 10, 505}, + DictWord{141, 10, 506}, + DictWord{139, 10, 1000}, + DictWord{ + 132, + 11, + 679, + }, + DictWord{132, 0, 899}, + DictWord{132, 0, 569}, + DictWord{5, 11, 694}, + DictWord{137, 11, 714}, + DictWord{136, 0, 795}, + DictWord{6, 0, 2045}, + DictWord{ + 139, + 11, + 7, + }, + DictWord{6, 0, 52}, + DictWord{9, 0, 104}, + DictWord{9, 0, 559}, + DictWord{12, 0, 308}, + DictWord{147, 0, 87}, + DictWord{4, 0, 301}, + DictWord{132, 0, 604}, + DictWord{133, 10, 637}, + DictWord{136, 0, 779}, + DictWord{5, 11, 143}, + DictWord{5, 11, 769}, + DictWord{6, 11, 1760}, + DictWord{7, 11, 682}, + DictWord{7, 11, 1992}, + DictWord{136, 11, 736}, + DictWord{137, 10, 590}, + DictWord{147, 0, 32}, + DictWord{137, 11, 527}, + DictWord{5, 10, 280}, + DictWord{135, 10, 1226}, + DictWord{134, 0, 494}, + DictWord{6, 0, 677}, + DictWord{6, 0, 682}, + DictWord{134, 0, 1044}, + DictWord{133, 10, 281}, + DictWord{135, 10, 1064}, + DictWord{7, 0, 508}, + DictWord{133, 11, 860}, + DictWord{6, 11, 422}, + DictWord{7, 11, 0}, + DictWord{7, 11, 1544}, + DictWord{9, 11, 577}, + DictWord{11, 11, 990}, + DictWord{12, 11, 141}, + DictWord{12, 11, 453}, + DictWord{13, 11, 47}, + DictWord{141, 11, 266}, + DictWord{134, 0, 1014}, + DictWord{5, 11, 515}, + DictWord{137, 11, 131}, + DictWord{ + 134, + 0, + 957, + }, + DictWord{132, 11, 646}, + DictWord{6, 0, 310}, + DictWord{7, 0, 1849}, + DictWord{8, 0, 72}, + DictWord{8, 0, 272}, + DictWord{8, 0, 431}, + DictWord{9, 0, 12}, + DictWord{ + 9, + 0, + 376, + }, + DictWord{10, 0, 563}, + DictWord{10, 0, 630}, + DictWord{10, 0, 796}, + DictWord{10, 0, 810}, + DictWord{11, 0, 367}, + DictWord{11, 0, 599}, + DictWord{ + 11, + 0, + 686, + }, + DictWord{140, 0, 672}, + DictWord{7, 0, 570}, + DictWord{4, 11, 396}, + DictWord{7, 10, 120}, + DictWord{7, 11, 728}, + DictWord{8, 10, 489}, + DictWord{9, 11, 117}, + DictWord{9, 10, 319}, + DictWord{10, 10, 820}, + DictWord{11, 10, 1004}, + DictWord{12, 10, 379}, + DictWord{12, 10, 679}, + DictWord{13, 10, 117}, + DictWord{ + 13, + 11, + 202, + }, + DictWord{13, 10, 412}, + DictWord{14, 10, 25}, + DictWord{15, 10, 52}, + DictWord{15, 10, 161}, + DictWord{16, 10, 47}, + DictWord{20, 11, 51}, + DictWord{ + 149, + 10, + 2, + }, + DictWord{6, 11, 121}, + DictWord{6, 11, 124}, + DictWord{6, 11, 357}, + DictWord{7, 11, 1138}, + DictWord{7, 11, 1295}, + DictWord{8, 11, 162}, + DictWord{ + 139, + 11, + 655, + }, + DictWord{8, 0, 449}, + DictWord{4, 10, 937}, + DictWord{5, 10, 801}, + DictWord{136, 11, 449}, + DictWord{139, 11, 958}, + DictWord{6, 0, 181}, + DictWord{ + 7, + 0, + 537, + }, + DictWord{8, 0, 64}, + DictWord{9, 0, 127}, + DictWord{10, 0, 496}, + DictWord{12, 0, 510}, + DictWord{141, 0, 384}, + DictWord{138, 11, 253}, + DictWord{4, 0, 244}, + DictWord{135, 0, 233}, + DictWord{133, 11, 237}, + DictWord{132, 10, 365}, + DictWord{6, 0, 1650}, + DictWord{10, 0, 702}, + DictWord{139, 0, 245}, + DictWord{ + 5, + 10, + 7, + }, + DictWord{139, 10, 774}, + DictWord{13, 0, 463}, + DictWord{20, 0, 49}, + DictWord{13, 11, 463}, + DictWord{148, 11, 49}, + DictWord{4, 10, 734}, + DictWord{ + 5, + 10, + 662, + }, + DictWord{134, 10, 430}, + DictWord{4, 10, 746}, + DictWord{135, 10, 1090}, + DictWord{5, 10, 360}, + DictWord{136, 10, 237}, + DictWord{137, 0, 338}, + DictWord{143, 11, 10}, + DictWord{7, 11, 571}, + DictWord{138, 11, 366}, + DictWord{134, 0, 1279}, + DictWord{9, 11, 513}, + DictWord{10, 11, 22}, + DictWord{10, 11, 39}, + DictWord{12, 11, 122}, + DictWord{140, 11, 187}, + DictWord{133, 0, 896}, + DictWord{146, 0, 178}, + DictWord{134, 0, 695}, + DictWord{137, 0, 808}, + DictWord{ + 134, + 11, + 587, + }, + DictWord{7, 11, 107}, + DictWord{7, 11, 838}, + DictWord{8, 11, 550}, + DictWord{138, 11, 401}, + DictWord{7, 0, 1117}, + DictWord{136, 0, 539}, + DictWord{ + 4, + 10, + 277, + }, + DictWord{5, 10, 608}, + DictWord{6, 10, 493}, + DictWord{7, 10, 457}, + DictWord{140, 10, 384}, + DictWord{133, 11, 768}, + DictWord{12, 0, 257}, + DictWord{ + 7, + 10, + 27, + }, + DictWord{135, 10, 316}, + DictWord{140, 0, 1003}, + DictWord{4, 0, 207}, + DictWord{5, 0, 586}, + DictWord{5, 0, 676}, + DictWord{6, 0, 448}, + DictWord{ + 8, + 0, + 244, + }, + DictWord{11, 0, 1}, + DictWord{13, 0, 3}, + DictWord{16, 0, 54}, + DictWord{17, 0, 4}, + DictWord{18, 0, 13}, + DictWord{133, 10, 552}, + DictWord{4, 10, 401}, + DictWord{ + 137, + 10, + 264, + }, + DictWord{5, 0, 516}, + DictWord{7, 0, 1883}, + DictWord{135, 11, 1883}, + DictWord{12, 0, 960}, + DictWord{132, 11, 894}, + DictWord{5, 0, 4}, + DictWord{ + 5, + 0, + 810, + }, + DictWord{6, 0, 13}, + DictWord{6, 0, 538}, + DictWord{6, 0, 1690}, + DictWord{6, 0, 1726}, + DictWord{7, 0, 499}, + DictWord{7, 0, 1819}, + DictWord{8, 0, 148}, + DictWord{ + 8, + 0, + 696, + }, + DictWord{8, 0, 791}, + DictWord{12, 0, 125}, + DictWord{143, 0, 9}, + DictWord{135, 0, 1268}, + DictWord{11, 0, 30}, + DictWord{14, 0, 315}, + DictWord{ + 9, + 10, + 543, + }, + DictWord{10, 10, 524}, + DictWord{12, 10, 524}, + DictWord{16, 10, 18}, + DictWord{20, 10, 26}, + DictWord{148, 10, 65}, + DictWord{6, 0, 748}, + DictWord{ + 4, + 10, + 205, + }, + DictWord{5, 10, 623}, + DictWord{7, 10, 104}, + DictWord{136, 10, 519}, + DictWord{11, 0, 542}, + DictWord{139, 0, 852}, + DictWord{140, 0, 6}, + DictWord{ + 132, + 0, + 848, + }, + DictWord{7, 0, 1385}, + DictWord{11, 0, 582}, + DictWord{11, 0, 650}, + DictWord{11, 0, 901}, + DictWord{11, 0, 949}, + DictWord{12, 0, 232}, + DictWord{12, 0, 236}, + DictWord{13, 0, 413}, + DictWord{13, 0, 501}, + DictWord{18, 0, 116}, + DictWord{7, 10, 579}, + DictWord{9, 10, 41}, + DictWord{9, 10, 244}, + DictWord{9, 10, 669}, + DictWord{10, 10, 5}, + DictWord{11, 10, 861}, + DictWord{11, 10, 951}, + DictWord{139, 10, 980}, + DictWord{4, 0, 945}, + DictWord{6, 0, 1811}, + DictWord{6, 0, 1845}, + DictWord{ + 6, + 0, + 1853, + }, + DictWord{6, 0, 1858}, + DictWord{8, 0, 862}, + DictWord{12, 0, 782}, + DictWord{12, 0, 788}, + DictWord{18, 0, 160}, + DictWord{148, 0, 117}, + DictWord{ + 132, + 10, + 717, + }, + DictWord{4, 0, 925}, + DictWord{5, 0, 803}, + DictWord{8, 0, 698}, + DictWord{138, 0, 828}, + DictWord{134, 0, 1416}, + DictWord{132, 0, 610}, + DictWord{ + 139, + 0, + 992, + }, + DictWord{6, 0, 878}, + DictWord{134, 0, 1477}, + DictWord{135, 0, 1847}, + DictWord{138, 11, 531}, + DictWord{137, 11, 539}, + DictWord{134, 11, 272}, + DictWord{133, 0, 383}, + DictWord{134, 0, 1404}, + DictWord{132, 10, 489}, + DictWord{4, 11, 9}, + DictWord{5, 11, 128}, + DictWord{7, 11, 368}, + DictWord{ + 11, + 11, + 480, + }, + DictWord{148, 11, 3}, + DictWord{136, 0, 986}, + DictWord{9, 0, 660}, + DictWord{138, 0, 347}, + DictWord{135, 10, 892}, + DictWord{136, 11, 682}, + DictWord{ + 7, + 0, + 572, + }, + DictWord{9, 0, 592}, + DictWord{11, 0, 680}, + DictWord{12, 0, 356}, + DictWord{140, 0, 550}, + DictWord{7, 0, 1411}, + DictWord{138, 11, 527}, + DictWord{ + 4, + 11, + 2, + }, + DictWord{7, 11, 545}, + DictWord{135, 11, 894}, + DictWord{137, 10, 473}, + DictWord{11, 0, 64}, + DictWord{7, 11, 481}, + DictWord{7, 10, 819}, + DictWord{9, 10, 26}, + DictWord{9, 10, 392}, + DictWord{9, 11, 792}, + DictWord{10, 10, 152}, + DictWord{10, 10, 226}, + DictWord{12, 10, 276}, + DictWord{12, 10, 426}, + DictWord{ + 12, + 10, + 589, + }, + DictWord{13, 10, 460}, + DictWord{15, 10, 97}, + DictWord{19, 10, 48}, + DictWord{148, 10, 104}, + DictWord{135, 10, 51}, + DictWord{136, 11, 445}, + DictWord{136, 11, 646}, + DictWord{135, 0, 606}, + DictWord{132, 10, 674}, + DictWord{6, 0, 1829}, + DictWord{134, 0, 1830}, + DictWord{132, 10, 770}, + DictWord{ + 5, + 10, + 79, + }, + DictWord{7, 10, 1027}, + DictWord{7, 10, 1477}, + DictWord{139, 10, 52}, + DictWord{5, 11, 530}, + DictWord{142, 11, 113}, + DictWord{134, 10, 1666}, + DictWord{ + 7, + 0, + 748, + }, + DictWord{139, 0, 700}, + DictWord{134, 10, 195}, + DictWord{133, 10, 789}, + DictWord{9, 0, 87}, + DictWord{10, 0, 365}, + DictWord{4, 10, 251}, + DictWord{ + 4, + 10, + 688, + }, + DictWord{7, 10, 513}, + DictWord{135, 10, 1284}, + DictWord{136, 11, 111}, + DictWord{133, 0, 127}, + DictWord{6, 0, 198}, + DictWord{140, 0, 83}, + DictWord{133, 11, 556}, + DictWord{133, 10, 889}, + DictWord{4, 10, 160}, + DictWord{5, 10, 330}, + DictWord{7, 10, 1434}, + DictWord{136, 10, 174}, + DictWord{5, 0, 276}, + DictWord{6, 0, 55}, + DictWord{7, 0, 1369}, + DictWord{138, 0, 864}, + DictWord{8, 11, 16}, + DictWord{140, 11, 568}, + DictWord{6, 0, 1752}, + DictWord{136, 0, 726}, + DictWord{135, 0, 1066}, + DictWord{133, 0, 764}, + DictWord{6, 11, 186}, + DictWord{137, 11, 426}, + DictWord{11, 0, 683}, + DictWord{139, 11, 683}, + DictWord{ + 6, + 0, + 309, + }, + DictWord{7, 0, 331}, + DictWord{138, 0, 550}, + DictWord{133, 10, 374}, + DictWord{6, 0, 1212}, + DictWord{6, 0, 1852}, + DictWord{7, 0, 1062}, + DictWord{ + 8, + 0, + 874, + }, + DictWord{8, 0, 882}, + DictWord{138, 0, 936}, + DictWord{132, 11, 585}, + DictWord{134, 0, 1364}, + DictWord{7, 0, 986}, + DictWord{133, 10, 731}, + DictWord{ + 6, + 0, + 723, + }, + DictWord{6, 0, 1408}, + DictWord{138, 0, 381}, + DictWord{135, 0, 1573}, + DictWord{134, 0, 1025}, + DictWord{4, 10, 626}, + DictWord{5, 10, 642}, + DictWord{ + 6, + 10, + 425, + }, + DictWord{10, 10, 202}, + DictWord{139, 10, 141}, + DictWord{4, 11, 93}, + DictWord{5, 11, 252}, + DictWord{6, 11, 229}, + DictWord{7, 11, 291}, + DictWord{ + 9, + 11, + 550, + }, + DictWord{139, 11, 644}, + DictWord{137, 11, 749}, + DictWord{137, 11, 162}, + DictWord{132, 11, 381}, + DictWord{135, 0, 1559}, + DictWord{ + 6, + 0, + 194, + }, + DictWord{7, 0, 133}, + DictWord{10, 0, 493}, + DictWord{10, 0, 570}, + DictWord{139, 0, 664}, + DictWord{5, 0, 24}, + DictWord{5, 0, 569}, + DictWord{6, 0, 3}, + DictWord{ + 6, + 0, + 119, + }, + DictWord{6, 0, 143}, + DictWord{6, 0, 440}, + DictWord{7, 0, 295}, + DictWord{7, 0, 599}, + DictWord{7, 0, 1686}, + DictWord{7, 0, 1854}, + DictWord{8, 0, 424}, + DictWord{ + 9, + 0, + 43, + }, + DictWord{9, 0, 584}, + DictWord{9, 0, 760}, + DictWord{10, 0, 148}, + DictWord{10, 0, 328}, + DictWord{11, 0, 159}, + DictWord{11, 0, 253}, + DictWord{11, 0, 506}, + DictWord{12, 0, 487}, + DictWord{140, 0, 531}, + DictWord{6, 0, 661}, + DictWord{134, 0, 1517}, + DictWord{136, 10, 835}, + DictWord{151, 10, 17}, + DictWord{5, 0, 14}, + DictWord{5, 0, 892}, + DictWord{6, 0, 283}, + DictWord{7, 0, 234}, + DictWord{136, 0, 537}, + DictWord{139, 0, 541}, + DictWord{4, 0, 126}, + DictWord{8, 0, 635}, + DictWord{ + 147, + 0, + 34, + }, + DictWord{4, 0, 316}, + DictWord{4, 0, 495}, + DictWord{135, 0, 1561}, + DictWord{4, 11, 187}, + DictWord{5, 11, 184}, + DictWord{5, 11, 690}, + DictWord{ + 7, + 11, + 1869, + }, + DictWord{138, 11, 756}, + DictWord{139, 11, 783}, + DictWord{4, 0, 998}, + DictWord{137, 0, 861}, + DictWord{136, 0, 1009}, + DictWord{139, 11, 292}, + DictWord{5, 11, 21}, + DictWord{6, 11, 77}, + DictWord{6, 11, 157}, + DictWord{7, 11, 974}, + DictWord{7, 11, 1301}, + DictWord{7, 11, 1339}, + DictWord{7, 11, 1490}, + DictWord{ + 7, + 11, + 1873, + }, + DictWord{137, 11, 628}, + DictWord{7, 11, 1283}, + DictWord{9, 11, 227}, + DictWord{9, 11, 499}, + DictWord{10, 11, 341}, + DictWord{11, 11, 325}, + DictWord{11, 11, 408}, + DictWord{14, 11, 180}, + DictWord{15, 11, 144}, + DictWord{18, 11, 47}, + DictWord{147, 11, 49}, + DictWord{4, 0, 64}, + DictWord{5, 0, 352}, + DictWord{5, 0, 720}, + DictWord{6, 0, 368}, + DictWord{139, 0, 359}, + DictWord{5, 10, 384}, + DictWord{8, 10, 455}, + DictWord{140, 10, 48}, + DictWord{5, 10, 264}, + DictWord{ + 134, + 10, + 184, + }, + DictWord{7, 0, 1577}, + DictWord{10, 0, 304}, + DictWord{10, 0, 549}, + DictWord{12, 0, 365}, + DictWord{13, 0, 220}, + DictWord{13, 0, 240}, + DictWord{ + 142, + 0, + 33, + }, + DictWord{134, 0, 1107}, + DictWord{134, 0, 929}, + DictWord{135, 0, 1142}, + DictWord{6, 0, 175}, + DictWord{137, 0, 289}, + DictWord{5, 0, 432}, + DictWord{ + 133, + 0, + 913, + }, + DictWord{6, 0, 279}, + DictWord{7, 0, 219}, + DictWord{5, 10, 633}, + DictWord{135, 10, 1323}, + DictWord{7, 0, 785}, + DictWord{7, 10, 359}, + DictWord{ + 8, + 10, + 243, + }, + DictWord{140, 10, 175}, + DictWord{139, 0, 595}, + DictWord{132, 10, 105}, + DictWord{8, 11, 398}, + DictWord{9, 11, 681}, + DictWord{139, 11, 632}, + DictWord{140, 0, 80}, + DictWord{5, 0, 931}, + DictWord{134, 0, 1698}, + DictWord{142, 11, 241}, + DictWord{134, 11, 20}, + DictWord{134, 0, 1323}, + DictWord{11, 0, 526}, + DictWord{11, 0, 939}, + DictWord{141, 0, 290}, + DictWord{5, 0, 774}, + DictWord{6, 0, 780}, + DictWord{6, 0, 1637}, + DictWord{6, 0, 1686}, + DictWord{6, 0, 1751}, + DictWord{ + 8, + 0, + 559, + }, + DictWord{141, 0, 109}, + DictWord{141, 0, 127}, + DictWord{7, 0, 1167}, + DictWord{11, 0, 934}, + DictWord{13, 0, 391}, + DictWord{17, 0, 76}, + DictWord{ + 135, + 11, + 709, + }, + DictWord{135, 0, 963}, + DictWord{6, 0, 260}, + DictWord{135, 0, 1484}, + DictWord{134, 0, 573}, + DictWord{4, 10, 758}, + DictWord{139, 11, 941}, + DictWord{135, 10, 1649}, + DictWord{145, 11, 36}, + DictWord{4, 0, 292}, + DictWord{137, 0, 580}, + DictWord{4, 0, 736}, + DictWord{5, 0, 871}, + DictWord{6, 0, 1689}, + DictWord{135, 0, 1944}, + DictWord{7, 11, 945}, + DictWord{11, 11, 713}, + DictWord{139, 11, 744}, + DictWord{134, 0, 1164}, + DictWord{135, 11, 937}, + DictWord{ + 6, + 0, + 1922, + }, + DictWord{9, 0, 982}, + DictWord{15, 0, 173}, + DictWord{15, 0, 178}, + DictWord{15, 0, 200}, + DictWord{18, 0, 189}, + DictWord{18, 0, 207}, + DictWord{21, 0, 47}, + DictWord{135, 11, 1652}, + DictWord{7, 0, 1695}, + DictWord{139, 10, 128}, + DictWord{6, 0, 63}, + DictWord{135, 0, 920}, + DictWord{133, 0, 793}, + DictWord{ + 143, + 11, + 134, + }, + DictWord{133, 10, 918}, + DictWord{5, 0, 67}, + DictWord{6, 0, 62}, + DictWord{6, 0, 374}, + DictWord{135, 0, 1391}, + DictWord{9, 0, 790}, + DictWord{12, 0, 47}, + DictWord{4, 11, 579}, + DictWord{5, 11, 226}, + DictWord{5, 11, 323}, + DictWord{135, 11, 960}, + DictWord{10, 11, 784}, + DictWord{141, 11, 191}, + DictWord{4, 0, 391}, + DictWord{135, 0, 1169}, + DictWord{137, 0, 443}, + DictWord{13, 11, 232}, + DictWord{146, 11, 35}, + DictWord{132, 10, 340}, + DictWord{132, 0, 271}, + DictWord{ + 137, + 11, + 313, + }, + DictWord{5, 11, 973}, + DictWord{137, 11, 659}, + DictWord{134, 0, 1140}, + DictWord{6, 11, 135}, + DictWord{135, 11, 1176}, + DictWord{4, 0, 253}, + DictWord{5, 0, 544}, + DictWord{7, 0, 300}, + DictWord{137, 0, 340}, + DictWord{7, 0, 897}, + DictWord{5, 10, 985}, + DictWord{7, 10, 509}, + DictWord{145, 10, 96}, + DictWord{ + 138, + 11, + 735, + }, + DictWord{135, 10, 1919}, + DictWord{138, 0, 890}, + DictWord{5, 0, 818}, + DictWord{134, 0, 1122}, + DictWord{5, 0, 53}, + DictWord{5, 0, 541}, + DictWord{ + 6, + 0, + 94, + }, + DictWord{6, 0, 499}, + DictWord{7, 0, 230}, + DictWord{139, 0, 321}, + DictWord{4, 0, 920}, + DictWord{5, 0, 25}, + DictWord{5, 0, 790}, + DictWord{6, 0, 457}, + DictWord{ + 7, + 0, + 853, + }, + DictWord{8, 0, 788}, + DictWord{142, 11, 31}, + DictWord{132, 10, 247}, + DictWord{135, 11, 314}, + DictWord{132, 0, 468}, + DictWord{7, 0, 243}, + DictWord{ + 6, + 10, + 337, + }, + DictWord{7, 10, 494}, + DictWord{8, 10, 27}, + DictWord{8, 10, 599}, + DictWord{138, 10, 153}, + DictWord{4, 10, 184}, + DictWord{5, 10, 390}, + DictWord{ + 7, + 10, + 618, + }, + DictWord{7, 10, 1456}, + DictWord{139, 10, 710}, + DictWord{134, 0, 870}, + DictWord{134, 0, 1238}, + DictWord{134, 0, 1765}, + DictWord{10, 0, 853}, + DictWord{10, 0, 943}, + DictWord{14, 0, 437}, + DictWord{14, 0, 439}, + DictWord{14, 0, 443}, + DictWord{14, 0, 446}, + DictWord{14, 0, 452}, + DictWord{14, 0, 469}, + DictWord{ + 14, + 0, + 471, + }, + DictWord{14, 0, 473}, + DictWord{16, 0, 93}, + DictWord{16, 0, 102}, + DictWord{16, 0, 110}, + DictWord{148, 0, 121}, + DictWord{4, 0, 605}, + DictWord{ + 7, + 0, + 518, + }, + DictWord{7, 0, 1282}, + DictWord{7, 0, 1918}, + DictWord{10, 0, 180}, + DictWord{139, 0, 218}, + DictWord{133, 0, 822}, + DictWord{4, 0, 634}, + DictWord{ + 11, + 0, + 916, + }, + DictWord{142, 0, 419}, + DictWord{6, 11, 281}, + DictWord{7, 11, 6}, + DictWord{8, 11, 282}, + DictWord{8, 11, 480}, + DictWord{8, 11, 499}, + DictWord{9, 11, 198}, + DictWord{10, 11, 143}, + DictWord{10, 11, 169}, + DictWord{10, 11, 211}, + DictWord{10, 11, 417}, + DictWord{10, 11, 574}, + DictWord{11, 11, 147}, + DictWord{ + 11, + 11, + 395, + }, + DictWord{12, 11, 75}, + DictWord{12, 11, 407}, + DictWord{12, 11, 608}, + DictWord{13, 11, 500}, + DictWord{142, 11, 251}, + DictWord{134, 0, 898}, + DictWord{ + 6, + 0, + 36, + }, + DictWord{7, 0, 658}, + DictWord{8, 0, 454}, + DictWord{150, 11, 48}, + DictWord{133, 11, 674}, + DictWord{135, 11, 1776}, + DictWord{4, 11, 419}, + DictWord{ + 10, + 10, + 227, + }, + DictWord{11, 10, 497}, + DictWord{11, 10, 709}, + DictWord{140, 10, 415}, + DictWord{6, 10, 360}, + DictWord{7, 10, 1664}, + DictWord{136, 10, 478}, + DictWord{137, 0, 806}, + DictWord{12, 11, 508}, + DictWord{14, 11, 102}, + DictWord{14, 11, 226}, + DictWord{144, 11, 57}, + DictWord{135, 11, 1123}, + DictWord{ + 4, + 11, + 138, + }, + DictWord{7, 11, 1012}, + DictWord{7, 11, 1280}, + DictWord{137, 11, 76}, + DictWord{5, 11, 29}, + DictWord{140, 11, 638}, + DictWord{136, 10, 699}, + DictWord{134, 0, 1326}, + DictWord{132, 0, 104}, + DictWord{135, 11, 735}, + DictWord{132, 10, 739}, + DictWord{134, 0, 1331}, + DictWord{7, 0, 260}, + DictWord{ + 135, + 11, + 260, + }, + DictWord{135, 11, 1063}, + DictWord{7, 0, 45}, + DictWord{9, 0, 542}, + DictWord{9, 0, 566}, + DictWord{10, 0, 728}, + DictWord{137, 10, 869}, + DictWord{ + 4, + 10, + 67, + }, + DictWord{5, 10, 422}, + DictWord{7, 10, 1037}, + DictWord{7, 10, 1289}, + DictWord{7, 10, 1555}, + DictWord{9, 10, 741}, + DictWord{145, 10, 108}, + DictWord{ + 139, + 0, + 263, + }, + DictWord{134, 0, 1516}, + DictWord{14, 0, 146}, + DictWord{15, 0, 42}, + DictWord{16, 0, 23}, + DictWord{17, 0, 86}, + DictWord{146, 0, 17}, + DictWord{ + 138, + 0, + 468, + }, + DictWord{136, 0, 1005}, + DictWord{4, 11, 17}, + DictWord{5, 11, 23}, + DictWord{7, 11, 995}, + DictWord{11, 11, 383}, + DictWord{11, 11, 437}, + DictWord{ + 12, + 11, + 460, + }, + DictWord{140, 11, 532}, + DictWord{7, 0, 87}, + DictWord{142, 0, 288}, + DictWord{138, 10, 96}, + DictWord{135, 11, 626}, + DictWord{144, 10, 26}, + DictWord{ + 7, + 0, + 988, + }, + DictWord{7, 0, 1939}, + DictWord{9, 0, 64}, + DictWord{9, 0, 502}, + DictWord{12, 0, 22}, + DictWord{12, 0, 34}, + DictWord{13, 0, 12}, + DictWord{13, 0, 234}, + DictWord{147, 0, 77}, + DictWord{13, 0, 133}, + DictWord{8, 10, 203}, + DictWord{11, 10, 823}, + DictWord{11, 10, 846}, + DictWord{12, 10, 482}, + DictWord{13, 10, 277}, + DictWord{13, 10, 302}, + DictWord{13, 10, 464}, + DictWord{14, 10, 205}, + DictWord{142, 10, 221}, + DictWord{4, 10, 449}, + DictWord{133, 10, 718}, + DictWord{ + 135, + 0, + 141, + }, + DictWord{6, 0, 1842}, + DictWord{136, 0, 872}, + DictWord{8, 11, 70}, + DictWord{12, 11, 171}, + DictWord{141, 11, 272}, + DictWord{4, 10, 355}, + DictWord{ + 6, + 10, + 311, + }, + DictWord{9, 10, 256}, + DictWord{138, 10, 404}, + DictWord{132, 0, 619}, + DictWord{137, 0, 261}, + DictWord{10, 11, 233}, + DictWord{10, 10, 758}, + DictWord{139, 11, 76}, + DictWord{5, 0, 246}, + DictWord{8, 0, 189}, + DictWord{9, 0, 355}, + DictWord{9, 0, 512}, + DictWord{10, 0, 124}, + DictWord{10, 0, 453}, + DictWord{ + 11, + 0, + 143, + }, + DictWord{11, 0, 416}, + DictWord{11, 0, 859}, + DictWord{141, 0, 341}, + DictWord{134, 11, 442}, + DictWord{133, 10, 827}, + DictWord{5, 10, 64}, + DictWord{ + 140, + 10, + 581, + }, + DictWord{4, 10, 442}, + DictWord{7, 10, 1047}, + DictWord{7, 10, 1352}, + DictWord{135, 10, 1643}, + DictWord{134, 11, 1709}, + DictWord{5, 0, 678}, + DictWord{6, 0, 305}, + DictWord{7, 0, 775}, + DictWord{7, 0, 1065}, + DictWord{133, 10, 977}, + DictWord{11, 11, 69}, + DictWord{12, 11, 105}, + DictWord{12, 11, 117}, + DictWord{13, 11, 213}, + DictWord{14, 11, 13}, + DictWord{14, 11, 62}, + DictWord{14, 11, 177}, + DictWord{14, 11, 421}, + DictWord{15, 11, 19}, + DictWord{146, 11, 141}, + DictWord{137, 11, 309}, + DictWord{5, 0, 35}, + DictWord{7, 0, 862}, + DictWord{7, 0, 1886}, + DictWord{138, 0, 179}, + DictWord{136, 0, 285}, + DictWord{132, 0, 517}, + DictWord{7, 11, 976}, + DictWord{9, 11, 146}, + DictWord{10, 11, 206}, + DictWord{10, 11, 596}, + DictWord{13, 11, 218}, + DictWord{142, 11, 153}, + DictWord{ + 132, + 10, + 254, + }, + DictWord{6, 0, 214}, + DictWord{12, 0, 540}, + DictWord{4, 10, 275}, + DictWord{7, 10, 1219}, + DictWord{140, 10, 376}, + DictWord{8, 0, 667}, + DictWord{ + 11, + 0, + 403, + }, + DictWord{146, 0, 83}, + DictWord{12, 0, 74}, + DictWord{10, 11, 648}, + DictWord{11, 11, 671}, + DictWord{143, 11, 46}, + DictWord{135, 0, 125}, + DictWord{ + 134, + 10, + 1753, + }, + DictWord{133, 0, 761}, + DictWord{6, 0, 912}, + DictWord{4, 11, 518}, + DictWord{6, 10, 369}, + DictWord{6, 10, 502}, + DictWord{7, 10, 1036}, + DictWord{ + 7, + 11, + 1136, + }, + DictWord{8, 10, 348}, + DictWord{9, 10, 452}, + DictWord{10, 10, 26}, + DictWord{11, 10, 224}, + DictWord{11, 10, 387}, + DictWord{11, 10, 772}, + DictWord{12, 10, 95}, + DictWord{12, 10, 629}, + DictWord{13, 10, 195}, + DictWord{13, 10, 207}, + DictWord{13, 10, 241}, + DictWord{14, 10, 260}, + DictWord{14, 10, 270}, + DictWord{143, 10, 140}, + DictWord{10, 0, 131}, + DictWord{140, 0, 72}, + DictWord{132, 10, 269}, + DictWord{5, 10, 480}, + DictWord{7, 10, 532}, + DictWord{ + 7, + 10, + 1197, + }, + DictWord{7, 10, 1358}, + DictWord{8, 10, 291}, + DictWord{11, 10, 349}, + DictWord{142, 10, 396}, + DictWord{8, 11, 689}, + DictWord{137, 11, 863}, + DictWord{ + 8, + 0, + 333, + }, + DictWord{138, 0, 182}, + DictWord{4, 11, 18}, + DictWord{7, 11, 145}, + DictWord{7, 11, 444}, + DictWord{7, 11, 1278}, + DictWord{8, 11, 49}, + DictWord{ + 8, + 11, + 400, + }, + DictWord{9, 11, 71}, + DictWord{9, 11, 250}, + DictWord{10, 11, 459}, + DictWord{12, 11, 160}, + DictWord{144, 11, 24}, + DictWord{14, 11, 35}, + DictWord{ + 142, + 11, + 191, + }, + DictWord{135, 11, 1864}, + DictWord{135, 0, 1338}, + DictWord{148, 10, 15}, + DictWord{14, 0, 94}, + DictWord{15, 0, 65}, + DictWord{16, 0, 4}, + DictWord{ + 16, + 0, + 77, + }, + DictWord{16, 0, 80}, + DictWord{145, 0, 5}, + DictWord{12, 11, 82}, + DictWord{143, 11, 36}, + DictWord{133, 11, 1010}, + DictWord{133, 0, 449}, + DictWord{ + 133, + 0, + 646, + }, + DictWord{7, 0, 86}, + DictWord{8, 0, 103}, + DictWord{135, 10, 657}, + DictWord{7, 0, 2028}, + DictWord{138, 0, 641}, + DictWord{136, 10, 533}, + DictWord{ + 134, + 0, + 1, + }, + DictWord{139, 11, 970}, + DictWord{5, 11, 87}, + DictWord{7, 11, 313}, + DictWord{7, 11, 1103}, + DictWord{10, 11, 112}, + DictWord{10, 11, 582}, + DictWord{ + 11, + 11, + 389, + }, + DictWord{11, 11, 813}, + DictWord{12, 11, 385}, + DictWord{13, 11, 286}, + DictWord{14, 11, 124}, + DictWord{146, 11, 108}, + DictWord{6, 0, 869}, + DictWord{ + 132, + 11, + 267, + }, + DictWord{6, 0, 277}, + DictWord{7, 0, 1274}, + DictWord{7, 0, 1386}, + DictWord{146, 0, 87}, + DictWord{6, 0, 187}, + DictWord{7, 0, 39}, + DictWord{7, 0, 1203}, + DictWord{8, 0, 380}, + DictWord{14, 0, 117}, + DictWord{149, 0, 28}, + DictWord{4, 10, 211}, + DictWord{4, 10, 332}, + DictWord{5, 10, 335}, + DictWord{6, 10, 238}, + DictWord{ + 7, + 10, + 269, + }, + DictWord{7, 10, 811}, + DictWord{7, 10, 1797}, + DictWord{8, 10, 836}, + DictWord{9, 10, 507}, + DictWord{141, 10, 242}, + DictWord{4, 0, 785}, + DictWord{ + 5, + 0, + 368, + }, + DictWord{6, 0, 297}, + DictWord{7, 0, 793}, + DictWord{139, 0, 938}, + DictWord{7, 0, 464}, + DictWord{8, 0, 558}, + DictWord{11, 0, 105}, + DictWord{12, 0, 231}, + DictWord{14, 0, 386}, + DictWord{15, 0, 102}, + DictWord{148, 0, 75}, + DictWord{133, 10, 1009}, + DictWord{8, 0, 877}, + DictWord{140, 0, 731}, + DictWord{ + 139, + 11, + 289, + }, + DictWord{10, 11, 249}, + DictWord{139, 11, 209}, + DictWord{132, 11, 561}, + DictWord{134, 0, 1608}, + DictWord{132, 11, 760}, + DictWord{134, 0, 1429}, + DictWord{9, 11, 154}, + DictWord{140, 11, 485}, + DictWord{5, 10, 228}, + DictWord{6, 10, 203}, + DictWord{7, 10, 156}, + DictWord{8, 10, 347}, + DictWord{ + 137, + 10, + 265, + }, + DictWord{7, 0, 1010}, + DictWord{11, 0, 733}, + DictWord{11, 0, 759}, + DictWord{13, 0, 34}, + DictWord{14, 0, 427}, + DictWord{146, 0, 45}, + DictWord{7, 10, 1131}, + DictWord{135, 10, 1468}, + DictWord{136, 11, 255}, + DictWord{7, 0, 1656}, + DictWord{9, 0, 369}, + DictWord{10, 0, 338}, + DictWord{10, 0, 490}, + DictWord{ + 11, + 0, + 154, + }, + DictWord{11, 0, 545}, + DictWord{11, 0, 775}, + DictWord{13, 0, 77}, + DictWord{141, 0, 274}, + DictWord{133, 11, 621}, + DictWord{134, 0, 1038}, + DictWord{ + 4, + 11, + 368, + }, + DictWord{135, 11, 641}, + DictWord{6, 0, 2010}, + DictWord{8, 0, 979}, + DictWord{8, 0, 985}, + DictWord{10, 0, 951}, + DictWord{138, 0, 1011}, + DictWord{ + 134, + 0, + 1005, + }, + DictWord{19, 0, 121}, + DictWord{5, 10, 291}, + DictWord{5, 10, 318}, + DictWord{7, 10, 765}, + DictWord{9, 10, 389}, + DictWord{140, 10, 548}, + DictWord{ + 5, + 0, + 20, + }, + DictWord{6, 0, 298}, + DictWord{7, 0, 659}, + DictWord{137, 0, 219}, + DictWord{7, 0, 1440}, + DictWord{11, 0, 854}, + DictWord{11, 0, 872}, + DictWord{11, 0, 921}, + DictWord{12, 0, 551}, + DictWord{13, 0, 472}, + DictWord{142, 0, 367}, + DictWord{5, 0, 490}, + DictWord{6, 0, 615}, + DictWord{6, 0, 620}, + DictWord{135, 0, 683}, + DictWord{ + 6, + 0, + 1070, + }, + DictWord{134, 0, 1597}, + DictWord{139, 0, 522}, + DictWord{132, 0, 439}, + DictWord{136, 0, 669}, + DictWord{6, 0, 766}, + DictWord{6, 0, 1143}, + DictWord{ + 6, + 0, + 1245, + }, + DictWord{10, 10, 525}, + DictWord{139, 10, 82}, + DictWord{9, 11, 92}, + DictWord{147, 11, 91}, + DictWord{6, 0, 668}, + DictWord{134, 0, 1218}, + DictWord{ + 6, + 11, + 525, + }, + DictWord{9, 11, 876}, + DictWord{140, 11, 284}, + DictWord{132, 0, 233}, + DictWord{136, 0, 547}, + DictWord{132, 10, 422}, + DictWord{5, 10, 355}, + DictWord{145, 10, 0}, + DictWord{6, 11, 300}, + DictWord{135, 11, 1515}, + DictWord{4, 0, 482}, + DictWord{137, 10, 905}, + DictWord{4, 0, 886}, + DictWord{7, 0, 346}, + DictWord{133, 11, 594}, + DictWord{133, 10, 865}, + DictWord{5, 10, 914}, + DictWord{134, 10, 1625}, + DictWord{135, 0, 334}, + DictWord{5, 0, 795}, + DictWord{ + 6, + 0, + 1741, + }, + DictWord{133, 10, 234}, + DictWord{135, 10, 1383}, + DictWord{6, 11, 1641}, + DictWord{136, 11, 820}, + DictWord{135, 0, 371}, + DictWord{7, 11, 1313}, + DictWord{138, 11, 660}, + DictWord{135, 10, 1312}, + DictWord{135, 0, 622}, + DictWord{7, 0, 625}, + DictWord{135, 0, 1750}, + DictWord{135, 0, 339}, + DictWord{ + 4, + 0, + 203, + }, + DictWord{135, 0, 1936}, + DictWord{15, 0, 29}, + DictWord{16, 0, 38}, + DictWord{15, 11, 29}, + DictWord{144, 11, 38}, + DictWord{5, 0, 338}, + DictWord{ + 135, + 0, + 1256, + }, + DictWord{135, 10, 1493}, + DictWord{10, 0, 130}, + DictWord{6, 10, 421}, + DictWord{7, 10, 61}, + DictWord{7, 10, 1540}, + DictWord{138, 10, 501}, + DictWord{ + 6, + 11, + 389, + }, + DictWord{7, 11, 149}, + DictWord{9, 11, 142}, + DictWord{138, 11, 94}, + DictWord{137, 10, 341}, + DictWord{11, 0, 678}, + DictWord{12, 0, 307}, + DictWord{142, 10, 98}, + DictWord{6, 11, 8}, + DictWord{7, 11, 1881}, + DictWord{136, 11, 91}, + DictWord{135, 0, 2044}, + DictWord{6, 0, 770}, + DictWord{6, 0, 802}, + DictWord{ + 6, + 0, + 812, + }, + DictWord{7, 0, 311}, + DictWord{9, 0, 308}, + DictWord{12, 0, 255}, + DictWord{6, 10, 102}, + DictWord{7, 10, 72}, + DictWord{15, 10, 142}, + DictWord{ + 147, + 10, + 67, + }, + DictWord{151, 10, 30}, + DictWord{135, 10, 823}, + DictWord{135, 0, 1266}, + DictWord{135, 11, 1746}, + DictWord{135, 10, 1870}, + DictWord{4, 0, 400}, + DictWord{5, 0, 267}, + DictWord{135, 0, 232}, + DictWord{7, 11, 24}, + DictWord{11, 11, 542}, + DictWord{139, 11, 852}, + DictWord{135, 11, 1739}, + DictWord{4, 11, 503}, + DictWord{135, 11, 1661}, + DictWord{5, 11, 130}, + DictWord{7, 11, 1314}, + DictWord{9, 11, 610}, + DictWord{10, 11, 718}, + DictWord{11, 11, 601}, + DictWord{ + 11, + 11, + 819, + }, + DictWord{11, 11, 946}, + DictWord{140, 11, 536}, + DictWord{10, 11, 149}, + DictWord{11, 11, 280}, + DictWord{142, 11, 336}, + DictWord{7, 0, 739}, + DictWord{11, 0, 690}, + DictWord{7, 11, 1946}, + DictWord{8, 10, 48}, + DictWord{8, 10, 88}, + DictWord{8, 10, 582}, + DictWord{8, 10, 681}, + DictWord{9, 10, 373}, + DictWord{ + 9, + 10, + 864, + }, + DictWord{11, 10, 157}, + DictWord{11, 10, 843}, + DictWord{148, 10, 27}, + DictWord{134, 0, 990}, + DictWord{4, 10, 88}, + DictWord{5, 10, 137}, + DictWord{ + 5, + 10, + 174, + }, + DictWord{5, 10, 777}, + DictWord{6, 10, 1664}, + DictWord{6, 10, 1725}, + DictWord{7, 10, 77}, + DictWord{7, 10, 426}, + DictWord{7, 10, 1317}, + DictWord{ + 7, + 10, + 1355, + }, + DictWord{8, 10, 126}, + DictWord{8, 10, 563}, + DictWord{9, 10, 523}, + DictWord{9, 10, 750}, + DictWord{10, 10, 310}, + DictWord{10, 10, 836}, + DictWord{ + 11, + 10, + 42, + }, + DictWord{11, 10, 318}, + DictWord{11, 10, 731}, + DictWord{12, 10, 68}, + DictWord{12, 10, 92}, + DictWord{12, 10, 507}, + DictWord{12, 10, 692}, + DictWord{ + 13, + 10, + 81, + }, + DictWord{13, 10, 238}, + DictWord{13, 10, 374}, + DictWord{14, 10, 436}, + DictWord{18, 10, 138}, + DictWord{19, 10, 78}, + DictWord{19, 10, 111}, + DictWord{20, 10, 55}, + DictWord{20, 10, 77}, + DictWord{148, 10, 92}, + DictWord{141, 10, 418}, + DictWord{7, 0, 1831}, + DictWord{132, 10, 938}, + DictWord{6, 0, 776}, + DictWord{134, 0, 915}, + DictWord{138, 10, 351}, + DictWord{5, 11, 348}, + DictWord{6, 11, 522}, + DictWord{6, 10, 1668}, + DictWord{7, 10, 1499}, + DictWord{8, 10, 117}, + DictWord{9, 10, 314}, + DictWord{138, 10, 174}, + DictWord{135, 10, 707}, + DictWord{132, 0, 613}, + DictWord{133, 10, 403}, + DictWord{132, 11, 392}, + DictWord{ + 5, + 11, + 433, + }, + DictWord{9, 11, 633}, + DictWord{139, 11, 629}, + DictWord{133, 0, 763}, + DictWord{132, 0, 878}, + DictWord{132, 0, 977}, + DictWord{132, 0, 100}, + DictWord{6, 0, 463}, + DictWord{4, 10, 44}, + DictWord{5, 10, 311}, + DictWord{7, 10, 639}, + DictWord{7, 10, 762}, + DictWord{7, 10, 1827}, + DictWord{9, 10, 8}, + DictWord{ + 9, + 10, + 462, + }, + DictWord{148, 10, 83}, + DictWord{134, 11, 234}, + DictWord{4, 10, 346}, + DictWord{7, 10, 115}, + DictWord{9, 10, 180}, + DictWord{9, 10, 456}, + DictWord{ + 138, + 10, + 363, + }, + DictWord{5, 0, 362}, + DictWord{5, 0, 443}, + DictWord{6, 0, 318}, + DictWord{7, 0, 1019}, + DictWord{139, 0, 623}, + DictWord{5, 0, 463}, + DictWord{8, 0, 296}, + DictWord{7, 11, 140}, + DictWord{7, 11, 1950}, + DictWord{8, 11, 680}, + DictWord{11, 11, 817}, + DictWord{147, 11, 88}, + DictWord{7, 11, 1222}, + DictWord{ + 138, + 11, + 386, + }, + DictWord{142, 0, 137}, + DictWord{132, 0, 454}, + DictWord{7, 0, 1914}, + DictWord{6, 11, 5}, + DictWord{7, 10, 1051}, + DictWord{9, 10, 545}, + DictWord{ + 11, + 11, + 249, + }, + DictWord{12, 11, 313}, + DictWord{16, 11, 66}, + DictWord{145, 11, 26}, + DictWord{135, 0, 1527}, + DictWord{145, 0, 58}, + DictWord{148, 11, 59}, + DictWord{ + 5, + 0, + 48, + }, + DictWord{5, 0, 404}, + DictWord{6, 0, 557}, + DictWord{7, 0, 458}, + DictWord{8, 0, 597}, + DictWord{10, 0, 455}, + DictWord{10, 0, 606}, + DictWord{11, 0, 49}, + DictWord{ + 11, + 0, + 548, + }, + DictWord{12, 0, 476}, + DictWord{13, 0, 18}, + DictWord{141, 0, 450}, + DictWord{5, 11, 963}, + DictWord{134, 11, 1773}, + DictWord{133, 0, 729}, + DictWord{138, 11, 586}, + DictWord{5, 0, 442}, + DictWord{135, 0, 1984}, + DictWord{134, 0, 449}, + DictWord{144, 0, 40}, + DictWord{4, 0, 853}, + DictWord{7, 11, 180}, + DictWord{8, 11, 509}, + DictWord{136, 11, 792}, + DictWord{6, 10, 185}, + DictWord{7, 10, 1899}, + DictWord{9, 10, 875}, + DictWord{139, 10, 673}, + DictWord{ + 134, + 11, + 524, + }, + DictWord{12, 0, 227}, + DictWord{4, 10, 327}, + DictWord{5, 10, 478}, + DictWord{7, 10, 1332}, + DictWord{136, 10, 753}, + DictWord{6, 0, 1491}, + DictWord{ + 5, + 10, + 1020, + }, + DictWord{133, 10, 1022}, + DictWord{4, 10, 103}, + DictWord{133, 10, 401}, + DictWord{132, 11, 931}, + DictWord{4, 10, 499}, + DictWord{135, 10, 1421}, + DictWord{5, 0, 55}, + DictWord{7, 0, 376}, + DictWord{140, 0, 161}, + DictWord{133, 0, 450}, + DictWord{6, 0, 1174}, + DictWord{134, 0, 1562}, + DictWord{10, 0, 62}, + DictWord{13, 0, 400}, + DictWord{135, 11, 1837}, + DictWord{140, 0, 207}, + DictWord{135, 0, 869}, + DictWord{4, 11, 773}, + DictWord{5, 11, 618}, + DictWord{ + 137, + 11, + 756, + }, + DictWord{132, 10, 96}, + DictWord{4, 0, 213}, + DictWord{7, 0, 223}, + DictWord{8, 0, 80}, + DictWord{135, 10, 968}, + DictWord{4, 11, 90}, + DictWord{5, 11, 337}, + DictWord{5, 11, 545}, + DictWord{7, 11, 754}, + DictWord{9, 11, 186}, + DictWord{10, 11, 72}, + DictWord{10, 11, 782}, + DictWord{11, 11, 513}, + DictWord{11, 11, 577}, + DictWord{11, 11, 610}, + DictWord{11, 11, 889}, + DictWord{11, 11, 961}, + DictWord{12, 11, 354}, + DictWord{12, 11, 362}, + DictWord{12, 11, 461}, + DictWord{ + 12, + 11, + 595, + }, + DictWord{13, 11, 79}, + DictWord{143, 11, 121}, + DictWord{7, 0, 381}, + DictWord{7, 0, 806}, + DictWord{7, 0, 820}, + DictWord{8, 0, 354}, + DictWord{8, 0, 437}, + DictWord{8, 0, 787}, + DictWord{9, 0, 657}, + DictWord{10, 0, 58}, + DictWord{10, 0, 339}, + DictWord{10, 0, 749}, + DictWord{11, 0, 914}, + DictWord{12, 0, 162}, + DictWord{ + 13, + 0, + 75, + }, + DictWord{14, 0, 106}, + DictWord{14, 0, 198}, + DictWord{14, 0, 320}, + DictWord{14, 0, 413}, + DictWord{146, 0, 43}, + DictWord{136, 0, 747}, + DictWord{ + 136, + 0, + 954, + }, + DictWord{134, 0, 1073}, + DictWord{135, 0, 556}, + DictWord{7, 11, 151}, + DictWord{9, 11, 329}, + DictWord{139, 11, 254}, + DictWord{5, 0, 692}, + DictWord{ + 134, + 0, + 1395, + }, + DictWord{6, 10, 563}, + DictWord{137, 10, 224}, + DictWord{134, 0, 191}, + DictWord{132, 0, 804}, + DictWord{9, 11, 187}, + DictWord{10, 11, 36}, + DictWord{17, 11, 44}, + DictWord{146, 11, 64}, + DictWord{7, 11, 165}, + DictWord{7, 11, 919}, + DictWord{136, 11, 517}, + DictWord{4, 11, 506}, + DictWord{5, 11, 295}, + DictWord{7, 11, 1680}, + DictWord{15, 11, 14}, + DictWord{144, 11, 5}, + DictWord{4, 0, 706}, + DictWord{6, 0, 162}, + DictWord{7, 0, 1960}, + DictWord{136, 0, 831}, + DictWord{ + 135, + 11, + 1376, + }, + DictWord{7, 11, 987}, + DictWord{9, 11, 688}, + DictWord{10, 11, 522}, + DictWord{11, 11, 788}, + DictWord{140, 11, 566}, + DictWord{150, 0, 35}, + DictWord{138, 0, 426}, + DictWord{135, 0, 1235}, + DictWord{135, 11, 1741}, + DictWord{7, 11, 389}, + DictWord{7, 11, 700}, + DictWord{7, 11, 940}, + DictWord{ + 8, + 11, + 514, + }, + DictWord{9, 11, 116}, + DictWord{9, 11, 535}, + DictWord{10, 11, 118}, + DictWord{11, 11, 107}, + DictWord{11, 11, 148}, + DictWord{11, 11, 922}, + DictWord{ + 12, + 11, + 254, + }, + DictWord{12, 11, 421}, + DictWord{142, 11, 238}, + DictWord{134, 0, 1234}, + DictWord{132, 11, 743}, + DictWord{4, 10, 910}, + DictWord{5, 10, 832}, + DictWord{135, 11, 1335}, + DictWord{141, 0, 96}, + DictWord{135, 11, 185}, + DictWord{146, 0, 149}, + DictWord{4, 0, 204}, + DictWord{137, 0, 902}, + DictWord{ + 4, + 11, + 784, + }, + DictWord{133, 11, 745}, + DictWord{136, 0, 833}, + DictWord{136, 0, 949}, + DictWord{7, 0, 366}, + DictWord{9, 0, 287}, + DictWord{12, 0, 199}, + DictWord{ + 12, + 0, + 556, + }, + DictWord{12, 0, 577}, + DictWord{5, 11, 81}, + DictWord{7, 11, 146}, + DictWord{7, 11, 1342}, + DictWord{7, 11, 1446}, + DictWord{8, 11, 53}, + DictWord{8, 11, 561}, + DictWord{8, 11, 694}, + DictWord{8, 11, 754}, + DictWord{9, 11, 97}, + DictWord{9, 11, 115}, + DictWord{9, 11, 894}, + DictWord{10, 11, 462}, + DictWord{10, 11, 813}, + DictWord{11, 11, 230}, + DictWord{11, 11, 657}, + DictWord{11, 11, 699}, + DictWord{11, 11, 748}, + DictWord{12, 11, 119}, + DictWord{12, 11, 200}, + DictWord{ + 12, + 11, + 283, + }, + DictWord{14, 11, 273}, + DictWord{145, 11, 15}, + DictWord{5, 11, 408}, + DictWord{137, 11, 747}, + DictWord{9, 11, 498}, + DictWord{140, 11, 181}, + DictWord{ + 6, + 0, + 2020, + }, + DictWord{136, 0, 992}, + DictWord{5, 0, 356}, + DictWord{135, 0, 224}, + DictWord{134, 0, 784}, + DictWord{7, 0, 630}, + DictWord{9, 0, 567}, + DictWord{ + 11, + 0, + 150, + }, + DictWord{11, 0, 444}, + DictWord{13, 0, 119}, + DictWord{8, 10, 528}, + DictWord{137, 10, 348}, + DictWord{134, 0, 539}, + DictWord{4, 10, 20}, + DictWord{ + 133, + 10, + 616, + }, + DictWord{142, 0, 27}, + DictWord{7, 11, 30}, + DictWord{8, 11, 86}, + DictWord{8, 11, 315}, + DictWord{8, 11, 700}, + DictWord{9, 11, 576}, + DictWord{9, 11, 858}, + DictWord{11, 11, 310}, + DictWord{11, 11, 888}, + DictWord{11, 11, 904}, + DictWord{12, 11, 361}, + DictWord{141, 11, 248}, + DictWord{138, 11, 839}, + DictWord{ + 134, + 0, + 755, + }, + DictWord{134, 0, 1063}, + DictWord{7, 10, 1091}, + DictWord{135, 10, 1765}, + DictWord{134, 11, 428}, + DictWord{7, 11, 524}, + DictWord{8, 11, 169}, + DictWord{8, 11, 234}, + DictWord{9, 11, 480}, + DictWord{138, 11, 646}, + DictWord{139, 0, 814}, + DictWord{7, 11, 1462}, + DictWord{139, 11, 659}, + DictWord{ + 4, + 10, + 26, + }, + DictWord{5, 10, 429}, + DictWord{6, 10, 245}, + DictWord{7, 10, 704}, + DictWord{7, 10, 1379}, + DictWord{135, 10, 1474}, + DictWord{7, 11, 1205}, + DictWord{ + 138, + 11, + 637, + }, + DictWord{139, 11, 803}, + DictWord{132, 10, 621}, + DictWord{136, 0, 987}, + DictWord{4, 11, 266}, + DictWord{8, 11, 4}, + DictWord{9, 11, 39}, + DictWord{ + 10, + 11, + 166, + }, + DictWord{11, 11, 918}, + DictWord{12, 11, 635}, + DictWord{20, 11, 10}, + DictWord{22, 11, 27}, + DictWord{150, 11, 43}, + DictWord{4, 0, 235}, + DictWord{ + 135, + 0, + 255, + }, + DictWord{4, 0, 194}, + DictWord{5, 0, 584}, + DictWord{6, 0, 384}, + DictWord{7, 0, 583}, + DictWord{10, 0, 761}, + DictWord{11, 0, 760}, + DictWord{139, 0, 851}, + DictWord{133, 10, 542}, + DictWord{134, 0, 1086}, + DictWord{133, 10, 868}, + DictWord{8, 0, 1016}, + DictWord{136, 0, 1018}, + DictWord{7, 0, 1396}, + DictWord{ + 7, + 11, + 1396, + }, + DictWord{136, 10, 433}, + DictWord{135, 10, 1495}, + DictWord{138, 10, 215}, + DictWord{141, 10, 124}, + DictWord{7, 11, 157}, + DictWord{ + 8, + 11, + 279, + }, + DictWord{9, 11, 759}, + DictWord{16, 11, 31}, + DictWord{16, 11, 39}, + DictWord{16, 11, 75}, + DictWord{18, 11, 24}, + DictWord{20, 11, 42}, + DictWord{152, 11, 1}, + DictWord{5, 0, 562}, + DictWord{134, 11, 604}, + DictWord{134, 0, 913}, + DictWord{5, 0, 191}, + DictWord{137, 0, 271}, + DictWord{4, 0, 470}, + DictWord{6, 0, 153}, + DictWord{7, 0, 1503}, + DictWord{7, 0, 1923}, + DictWord{10, 0, 701}, + DictWord{11, 0, 132}, + DictWord{11, 0, 227}, + DictWord{11, 0, 320}, + DictWord{11, 0, 436}, + DictWord{ + 11, + 0, + 525, + }, + DictWord{11, 0, 855}, + DictWord{11, 0, 873}, + DictWord{12, 0, 41}, + DictWord{12, 0, 286}, + DictWord{13, 0, 103}, + DictWord{13, 0, 284}, + DictWord{ + 14, + 0, + 255, + }, + DictWord{14, 0, 262}, + DictWord{15, 0, 117}, + DictWord{143, 0, 127}, + DictWord{7, 0, 475}, + DictWord{12, 0, 45}, + DictWord{147, 10, 112}, + DictWord{ + 132, + 11, + 567, + }, + DictWord{137, 11, 859}, + DictWord{6, 0, 713}, + DictWord{6, 0, 969}, + DictWord{6, 0, 1290}, + DictWord{134, 0, 1551}, + DictWord{133, 0, 327}, + DictWord{ + 6, + 0, + 552, + }, + DictWord{6, 0, 1292}, + DictWord{7, 0, 1754}, + DictWord{137, 0, 604}, + DictWord{4, 0, 223}, + DictWord{6, 0, 359}, + DictWord{11, 0, 3}, + DictWord{13, 0, 108}, + DictWord{14, 0, 89}, + DictWord{16, 0, 22}, + DictWord{5, 11, 762}, + DictWord{7, 11, 1880}, + DictWord{9, 11, 680}, + DictWord{139, 11, 798}, + DictWord{5, 0, 80}, + DictWord{ + 6, + 0, + 405, + }, + DictWord{7, 0, 403}, + DictWord{7, 0, 1502}, + DictWord{8, 0, 456}, + DictWord{9, 0, 487}, + DictWord{9, 0, 853}, + DictWord{9, 0, 889}, + DictWord{10, 0, 309}, + DictWord{ + 11, + 0, + 721, + }, + DictWord{11, 0, 994}, + DictWord{12, 0, 430}, + DictWord{141, 0, 165}, + DictWord{133, 11, 298}, + DictWord{132, 10, 647}, + DictWord{134, 0, 2016}, + DictWord{18, 10, 10}, + DictWord{146, 11, 10}, + DictWord{4, 0, 453}, + DictWord{5, 0, 887}, + DictWord{6, 0, 535}, + DictWord{8, 0, 6}, + DictWord{8, 0, 543}, + DictWord{ + 136, + 0, + 826, + }, + DictWord{136, 0, 975}, + DictWord{10, 0, 961}, + DictWord{138, 0, 962}, + DictWord{138, 10, 220}, + DictWord{6, 0, 1891}, + DictWord{6, 0, 1893}, + DictWord{ + 9, + 0, + 916, + }, + DictWord{9, 0, 965}, + DictWord{9, 0, 972}, + DictWord{12, 0, 801}, + DictWord{12, 0, 859}, + DictWord{12, 0, 883}, + DictWord{15, 0, 226}, + DictWord{149, 0, 51}, + DictWord{132, 10, 109}, + DictWord{135, 11, 267}, + DictWord{7, 11, 92}, + DictWord{7, 11, 182}, + DictWord{8, 11, 453}, + DictWord{9, 11, 204}, + DictWord{11, 11, 950}, + DictWord{12, 11, 94}, + DictWord{12, 11, 644}, + DictWord{16, 11, 20}, + DictWord{16, 11, 70}, + DictWord{16, 11, 90}, + DictWord{147, 11, 55}, + DictWord{ + 134, + 10, + 1746, + }, + DictWord{6, 11, 71}, + DictWord{7, 11, 845}, + DictWord{7, 11, 1308}, + DictWord{8, 11, 160}, + DictWord{137, 11, 318}, + DictWord{5, 0, 101}, + DictWord{6, 0, 88}, + DictWord{7, 0, 263}, + DictWord{7, 0, 628}, + DictWord{7, 0, 1677}, + DictWord{8, 0, 349}, + DictWord{9, 0, 100}, + DictWord{10, 0, 677}, + DictWord{14, 0, 169}, + DictWord{ + 14, + 0, + 302, + }, + DictWord{14, 0, 313}, + DictWord{15, 0, 48}, + DictWord{15, 0, 84}, + DictWord{7, 11, 237}, + DictWord{8, 11, 664}, + DictWord{9, 11, 42}, + DictWord{9, 11, 266}, + DictWord{9, 11, 380}, + DictWord{9, 11, 645}, + DictWord{10, 11, 177}, + DictWord{138, 11, 276}, + DictWord{138, 11, 69}, + DictWord{4, 0, 310}, + DictWord{7, 0, 708}, + DictWord{7, 0, 996}, + DictWord{9, 0, 795}, + DictWord{10, 0, 390}, + DictWord{10, 0, 733}, + DictWord{11, 0, 451}, + DictWord{12, 0, 249}, + DictWord{14, 0, 115}, + DictWord{ + 14, + 0, + 286, + }, + DictWord{143, 0, 100}, + DictWord{5, 0, 587}, + DictWord{4, 10, 40}, + DictWord{10, 10, 67}, + DictWord{11, 10, 117}, + DictWord{11, 10, 768}, + DictWord{ + 139, + 10, + 935, + }, + DictWord{6, 0, 1942}, + DictWord{7, 0, 512}, + DictWord{136, 0, 983}, + DictWord{7, 10, 992}, + DictWord{8, 10, 301}, + DictWord{9, 10, 722}, + DictWord{12, 10, 63}, + DictWord{13, 10, 29}, + DictWord{14, 10, 161}, + DictWord{143, 10, 18}, + DictWord{136, 11, 76}, + DictWord{139, 10, 923}, + DictWord{134, 0, 645}, + DictWord{ + 134, + 0, + 851, + }, + DictWord{4, 0, 498}, + DictWord{132, 11, 293}, + DictWord{7, 0, 217}, + DictWord{8, 0, 140}, + DictWord{10, 0, 610}, + DictWord{14, 11, 352}, + DictWord{ + 17, + 11, + 53, + }, + DictWord{18, 11, 146}, + DictWord{18, 11, 152}, + DictWord{19, 11, 11}, + DictWord{150, 11, 54}, + DictWord{134, 0, 1448}, + DictWord{138, 11, 841}, + DictWord{133, 0, 905}, + DictWord{4, 11, 605}, + DictWord{7, 11, 518}, + DictWord{7, 11, 1282}, + DictWord{7, 11, 1918}, + DictWord{10, 11, 180}, + DictWord{139, 11, 218}, + DictWord{139, 11, 917}, + DictWord{135, 10, 825}, + DictWord{140, 10, 328}, + DictWord{4, 0, 456}, + DictWord{7, 0, 105}, + DictWord{7, 0, 358}, + DictWord{7, 0, 1637}, + DictWord{8, 0, 643}, + DictWord{139, 0, 483}, + DictWord{134, 0, 792}, + DictWord{6, 11, 96}, + DictWord{135, 11, 1426}, + DictWord{137, 11, 691}, + DictWord{ + 4, + 11, + 651, + }, + DictWord{133, 11, 289}, + DictWord{7, 11, 688}, + DictWord{8, 11, 35}, + DictWord{9, 11, 511}, + DictWord{10, 11, 767}, + DictWord{147, 11, 118}, + DictWord{ + 150, + 0, + 56, + }, + DictWord{5, 0, 243}, + DictWord{5, 0, 535}, + DictWord{6, 10, 204}, + DictWord{10, 10, 320}, + DictWord{10, 10, 583}, + DictWord{13, 10, 502}, + DictWord{ + 14, + 10, + 72, + }, + DictWord{14, 10, 274}, + DictWord{14, 10, 312}, + DictWord{14, 10, 344}, + DictWord{15, 10, 159}, + DictWord{16, 10, 62}, + DictWord{16, 10, 69}, + DictWord{ + 17, + 10, + 30, + }, + DictWord{18, 10, 42}, + DictWord{18, 10, 53}, + DictWord{18, 10, 84}, + DictWord{18, 10, 140}, + DictWord{19, 10, 68}, + DictWord{19, 10, 85}, + DictWord{20, 10, 5}, + DictWord{20, 10, 45}, + DictWord{20, 10, 101}, + DictWord{22, 10, 7}, + DictWord{150, 10, 20}, + DictWord{4, 10, 558}, + DictWord{6, 10, 390}, + DictWord{7, 10, 162}, + DictWord{7, 10, 689}, + DictWord{9, 10, 360}, + DictWord{138, 10, 653}, + DictWord{146, 11, 23}, + DictWord{135, 0, 1748}, + DictWord{5, 10, 856}, + DictWord{ + 6, + 10, + 1672, + }, + DictWord{6, 10, 1757}, + DictWord{134, 10, 1781}, + DictWord{5, 0, 539}, + DictWord{5, 0, 754}, + DictWord{6, 0, 876}, + DictWord{132, 11, 704}, + DictWord{ + 135, + 11, + 1078, + }, + DictWord{5, 10, 92}, + DictWord{10, 10, 736}, + DictWord{140, 10, 102}, + DictWord{17, 0, 91}, + DictWord{5, 10, 590}, + DictWord{137, 10, 213}, + DictWord{134, 0, 1565}, + DictWord{6, 0, 91}, + DictWord{135, 0, 435}, + DictWord{4, 0, 939}, + DictWord{140, 0, 792}, + DictWord{134, 0, 1399}, + DictWord{4, 0, 16}, + DictWord{ + 5, + 0, + 316, + }, + DictWord{5, 0, 842}, + DictWord{6, 0, 370}, + DictWord{6, 0, 1778}, + DictWord{8, 0, 166}, + DictWord{11, 0, 812}, + DictWord{12, 0, 206}, + DictWord{12, 0, 351}, + DictWord{14, 0, 418}, + DictWord{16, 0, 15}, + DictWord{16, 0, 34}, + DictWord{18, 0, 3}, + DictWord{19, 0, 3}, + DictWord{19, 0, 7}, + DictWord{20, 0, 4}, + DictWord{21, 0, 21}, + DictWord{ + 4, + 11, + 720, + }, + DictWord{133, 11, 306}, + DictWord{144, 0, 95}, + DictWord{133, 11, 431}, + DictWord{132, 11, 234}, + DictWord{135, 0, 551}, + DictWord{4, 0, 999}, + DictWord{6, 0, 1966}, + DictWord{134, 0, 2042}, + DictWord{7, 0, 619}, + DictWord{10, 0, 547}, + DictWord{11, 0, 122}, + DictWord{12, 0, 601}, + DictWord{15, 0, 7}, + DictWord{148, 0, 20}, + DictWord{5, 11, 464}, + DictWord{6, 11, 236}, + DictWord{7, 11, 276}, + DictWord{7, 11, 696}, + DictWord{7, 11, 914}, + DictWord{7, 11, 1108}, + DictWord{ + 7, + 11, + 1448, + }, + DictWord{9, 11, 15}, + DictWord{9, 11, 564}, + DictWord{10, 11, 14}, + DictWord{12, 11, 565}, + DictWord{13, 11, 449}, + DictWord{14, 11, 53}, + DictWord{ + 15, + 11, + 13, + }, + DictWord{16, 11, 64}, + DictWord{145, 11, 41}, + DictWord{6, 0, 884}, + DictWord{6, 0, 1019}, + DictWord{134, 0, 1150}, + DictWord{6, 11, 1767}, + DictWord{ + 12, + 11, + 194, + }, + DictWord{145, 11, 107}, + DictWord{136, 10, 503}, + DictWord{133, 11, 840}, + DictWord{7, 0, 671}, + DictWord{134, 10, 466}, + DictWord{132, 0, 888}, + DictWord{4, 0, 149}, + DictWord{138, 0, 368}, + DictWord{4, 0, 154}, + DictWord{7, 0, 1134}, + DictWord{136, 0, 105}, + DictWord{135, 0, 983}, + DictWord{9, 11, 642}, + DictWord{11, 11, 236}, + DictWord{142, 11, 193}, + DictWord{4, 0, 31}, + DictWord{6, 0, 429}, + DictWord{7, 0, 962}, + DictWord{9, 0, 458}, + DictWord{139, 0, 691}, + DictWord{ + 6, + 0, + 643, + }, + DictWord{134, 0, 1102}, + DictWord{132, 0, 312}, + DictWord{4, 11, 68}, + DictWord{5, 11, 634}, + DictWord{6, 11, 386}, + DictWord{7, 11, 794}, + DictWord{ + 8, + 11, + 273, + }, + DictWord{9, 11, 563}, + DictWord{10, 11, 105}, + DictWord{10, 11, 171}, + DictWord{11, 11, 94}, + DictWord{139, 11, 354}, + DictWord{133, 0, 740}, + DictWord{ + 135, + 0, + 1642, + }, + DictWord{4, 11, 95}, + DictWord{7, 11, 416}, + DictWord{8, 11, 211}, + DictWord{139, 11, 830}, + DictWord{132, 0, 236}, + DictWord{138, 10, 241}, + DictWord{7, 11, 731}, + DictWord{13, 11, 20}, + DictWord{143, 11, 11}, + DictWord{5, 0, 836}, + DictWord{5, 0, 857}, + DictWord{6, 0, 1680}, + DictWord{135, 0, 59}, + DictWord{ + 10, + 0, + 68, + }, + DictWord{11, 0, 494}, + DictWord{152, 11, 6}, + DictWord{4, 0, 81}, + DictWord{139, 0, 867}, + DictWord{135, 0, 795}, + DictWord{133, 11, 689}, + DictWord{ + 4, + 0, + 1001, + }, + DictWord{5, 0, 282}, + DictWord{6, 0, 1932}, + DictWord{6, 0, 1977}, + DictWord{6, 0, 1987}, + DictWord{6, 0, 1992}, + DictWord{8, 0, 650}, + DictWord{8, 0, 919}, + DictWord{8, 0, 920}, + DictWord{8, 0, 923}, + DictWord{8, 0, 926}, + DictWord{8, 0, 927}, + DictWord{8, 0, 931}, + DictWord{8, 0, 939}, + DictWord{8, 0, 947}, + DictWord{8, 0, 956}, + DictWord{8, 0, 997}, + DictWord{9, 0, 907}, + DictWord{10, 0, 950}, + DictWord{10, 0, 953}, + DictWord{10, 0, 954}, + DictWord{10, 0, 956}, + DictWord{10, 0, 958}, + DictWord{ + 10, + 0, + 959, + }, + DictWord{10, 0, 964}, + DictWord{10, 0, 970}, + DictWord{10, 0, 972}, + DictWord{10, 0, 973}, + DictWord{10, 0, 975}, + DictWord{10, 0, 976}, + DictWord{ + 10, + 0, + 980, + }, + DictWord{10, 0, 981}, + DictWord{10, 0, 984}, + DictWord{10, 0, 988}, + DictWord{10, 0, 990}, + DictWord{10, 0, 995}, + DictWord{10, 0, 999}, + DictWord{ + 10, + 0, + 1002, + }, + DictWord{10, 0, 1003}, + DictWord{10, 0, 1005}, + DictWord{10, 0, 1006}, + DictWord{10, 0, 1008}, + DictWord{10, 0, 1009}, + DictWord{10, 0, 1012}, + DictWord{10, 0, 1014}, + DictWord{10, 0, 1015}, + DictWord{10, 0, 1019}, + DictWord{10, 0, 1020}, + DictWord{10, 0, 1022}, + DictWord{12, 0, 959}, + DictWord{12, 0, 961}, + DictWord{12, 0, 962}, + DictWord{12, 0, 963}, + DictWord{12, 0, 964}, + DictWord{12, 0, 965}, + DictWord{12, 0, 967}, + DictWord{12, 0, 968}, + DictWord{12, 0, 969}, + DictWord{12, 0, 970}, + DictWord{12, 0, 971}, + DictWord{12, 0, 972}, + DictWord{12, 0, 973}, + DictWord{12, 0, 974}, + DictWord{12, 0, 975}, + DictWord{12, 0, 976}, + DictWord{ + 12, + 0, + 977, + }, + DictWord{12, 0, 979}, + DictWord{12, 0, 981}, + DictWord{12, 0, 982}, + DictWord{12, 0, 983}, + DictWord{12, 0, 984}, + DictWord{12, 0, 985}, + DictWord{ + 12, + 0, + 986, + }, + DictWord{12, 0, 987}, + DictWord{12, 0, 989}, + DictWord{12, 0, 990}, + DictWord{12, 0, 992}, + DictWord{12, 0, 993}, + DictWord{12, 0, 995}, + DictWord{12, 0, 998}, + DictWord{12, 0, 999}, + DictWord{12, 0, 1000}, + DictWord{12, 0, 1001}, + DictWord{12, 0, 1002}, + DictWord{12, 0, 1004}, + DictWord{12, 0, 1005}, + DictWord{ + 12, + 0, + 1006, + }, + DictWord{12, 0, 1007}, + DictWord{12, 0, 1008}, + DictWord{12, 0, 1009}, + DictWord{12, 0, 1010}, + DictWord{12, 0, 1011}, + DictWord{12, 0, 1012}, + DictWord{12, 0, 1014}, + DictWord{12, 0, 1015}, + DictWord{12, 0, 1016}, + DictWord{12, 0, 1017}, + DictWord{12, 0, 1018}, + DictWord{12, 0, 1019}, + DictWord{ + 12, + 0, + 1022, + }, + DictWord{12, 0, 1023}, + DictWord{14, 0, 475}, + DictWord{14, 0, 477}, + DictWord{14, 0, 478}, + DictWord{14, 0, 479}, + DictWord{14, 0, 480}, + DictWord{ + 14, + 0, + 482, + }, + DictWord{14, 0, 483}, + DictWord{14, 0, 484}, + DictWord{14, 0, 485}, + DictWord{14, 0, 486}, + DictWord{14, 0, 487}, + DictWord{14, 0, 488}, + DictWord{14, 0, 489}, + DictWord{14, 0, 490}, + DictWord{14, 0, 491}, + DictWord{14, 0, 492}, + DictWord{14, 0, 493}, + DictWord{14, 0, 494}, + DictWord{14, 0, 495}, + DictWord{14, 0, 496}, + DictWord{14, 0, 497}, + DictWord{14, 0, 498}, + DictWord{14, 0, 499}, + DictWord{14, 0, 500}, + DictWord{14, 0, 501}, + DictWord{14, 0, 502}, + DictWord{14, 0, 503}, + DictWord{ + 14, + 0, + 504, + }, + DictWord{14, 0, 506}, + DictWord{14, 0, 507}, + DictWord{14, 0, 508}, + DictWord{14, 0, 509}, + DictWord{14, 0, 510}, + DictWord{14, 0, 511}, + DictWord{ + 16, + 0, + 113, + }, + DictWord{16, 0, 114}, + DictWord{16, 0, 115}, + DictWord{16, 0, 117}, + DictWord{16, 0, 118}, + DictWord{16, 0, 119}, + DictWord{16, 0, 121}, + DictWord{16, 0, 122}, + DictWord{16, 0, 123}, + DictWord{16, 0, 124}, + DictWord{16, 0, 125}, + DictWord{16, 0, 126}, + DictWord{16, 0, 127}, + DictWord{18, 0, 242}, + DictWord{18, 0, 243}, + DictWord{18, 0, 244}, + DictWord{18, 0, 245}, + DictWord{18, 0, 248}, + DictWord{18, 0, 249}, + DictWord{18, 0, 250}, + DictWord{18, 0, 251}, + DictWord{18, 0, 252}, + DictWord{ + 18, + 0, + 253, + }, + DictWord{18, 0, 254}, + DictWord{18, 0, 255}, + DictWord{20, 0, 125}, + DictWord{20, 0, 126}, + DictWord{148, 0, 127}, + DictWord{7, 11, 1717}, + DictWord{ + 7, + 11, + 1769, + }, + DictWord{138, 11, 546}, + DictWord{7, 11, 1127}, + DictWord{7, 11, 1572}, + DictWord{10, 11, 297}, + DictWord{10, 11, 422}, + DictWord{11, 11, 764}, + DictWord{11, 11, 810}, + DictWord{12, 11, 264}, + DictWord{13, 11, 102}, + DictWord{13, 11, 300}, + DictWord{13, 11, 484}, + DictWord{14, 11, 147}, + DictWord{ + 14, + 11, + 229, + }, + DictWord{17, 11, 71}, + DictWord{18, 11, 118}, + DictWord{147, 11, 120}, + DictWord{6, 0, 1148}, + DictWord{134, 0, 1586}, + DictWord{132, 0, 775}, + DictWord{135, 10, 954}, + DictWord{133, 11, 864}, + DictWord{133, 11, 928}, + DictWord{138, 11, 189}, + DictWord{135, 10, 1958}, + DictWord{6, 10, 549}, + DictWord{ + 8, + 10, + 34, + }, + DictWord{8, 10, 283}, + DictWord{9, 10, 165}, + DictWord{138, 10, 475}, + DictWord{5, 10, 652}, + DictWord{5, 10, 701}, + DictWord{135, 10, 449}, + DictWord{135, 11, 695}, + DictWord{4, 10, 655}, + DictWord{7, 10, 850}, + DictWord{17, 10, 75}, + DictWord{146, 10, 137}, + DictWord{140, 11, 682}, + DictWord{ + 133, + 11, + 523, + }, + DictWord{8, 0, 970}, + DictWord{136, 10, 670}, + DictWord{136, 11, 555}, + DictWord{7, 11, 76}, + DictWord{8, 11, 44}, + DictWord{9, 11, 884}, + DictWord{ + 10, + 11, + 580, + }, + DictWord{11, 11, 399}, + DictWord{11, 11, 894}, + DictWord{15, 11, 122}, + DictWord{18, 11, 144}, + DictWord{147, 11, 61}, + DictWord{6, 10, 159}, + DictWord{ + 6, + 10, + 364, + }, + DictWord{7, 10, 516}, + DictWord{7, 10, 1439}, + DictWord{137, 10, 518}, + DictWord{4, 0, 71}, + DictWord{5, 0, 376}, + DictWord{7, 0, 119}, + DictWord{ + 138, + 0, + 665, + }, + DictWord{141, 10, 151}, + DictWord{11, 0, 827}, + DictWord{14, 0, 34}, + DictWord{143, 0, 148}, + DictWord{133, 11, 518}, + DictWord{4, 0, 479}, + DictWord{ + 135, + 11, + 1787, + }, + DictWord{135, 11, 1852}, + DictWord{135, 10, 993}, + DictWord{7, 0, 607}, + DictWord{136, 0, 99}, + DictWord{134, 0, 1960}, + DictWord{132, 0, 793}, + DictWord{4, 0, 41}, + DictWord{5, 0, 74}, + DictWord{7, 0, 1627}, + DictWord{11, 0, 871}, + DictWord{140, 0, 619}, + DictWord{7, 0, 94}, + DictWord{11, 0, 329}, + DictWord{ + 11, + 0, + 965, + }, + DictWord{12, 0, 241}, + DictWord{14, 0, 354}, + DictWord{15, 0, 22}, + DictWord{148, 0, 63}, + DictWord{7, 10, 501}, + DictWord{9, 10, 111}, + DictWord{10, 10, 141}, + DictWord{11, 10, 332}, + DictWord{13, 10, 43}, + DictWord{13, 10, 429}, + DictWord{14, 10, 130}, + DictWord{14, 10, 415}, + DictWord{145, 10, 102}, + DictWord{ + 9, + 0, + 209, + }, + DictWord{137, 0, 300}, + DictWord{134, 0, 1497}, + DictWord{138, 11, 255}, + DictWord{4, 11, 934}, + DictWord{5, 11, 138}, + DictWord{136, 11, 610}, + DictWord{133, 0, 98}, + DictWord{6, 0, 1316}, + DictWord{10, 11, 804}, + DictWord{138, 11, 832}, + DictWord{8, 11, 96}, + DictWord{9, 11, 36}, + DictWord{10, 11, 607}, + DictWord{11, 11, 423}, + DictWord{11, 11, 442}, + DictWord{12, 11, 309}, + DictWord{14, 11, 199}, + DictWord{15, 11, 90}, + DictWord{145, 11, 110}, + DictWord{ + 132, + 0, + 463, + }, + DictWord{5, 10, 149}, + DictWord{136, 10, 233}, + DictWord{133, 10, 935}, + DictWord{4, 11, 652}, + DictWord{8, 11, 320}, + DictWord{9, 11, 13}, + DictWord{ + 9, + 11, + 398, + }, + DictWord{9, 11, 727}, + DictWord{10, 11, 75}, + DictWord{10, 11, 184}, + DictWord{10, 11, 230}, + DictWord{10, 11, 564}, + DictWord{10, 11, 569}, + DictWord{ + 11, + 11, + 973, + }, + DictWord{12, 11, 70}, + DictWord{12, 11, 189}, + DictWord{13, 11, 57}, + DictWord{13, 11, 257}, + DictWord{22, 11, 6}, + DictWord{150, 11, 16}, + DictWord{ + 142, + 0, + 291, + }, + DictWord{12, 10, 582}, + DictWord{146, 10, 131}, + DictWord{136, 10, 801}, + DictWord{133, 0, 984}, + DictWord{145, 11, 116}, + DictWord{4, 11, 692}, + DictWord{133, 11, 321}, + DictWord{4, 0, 182}, + DictWord{6, 0, 205}, + DictWord{135, 0, 220}, + DictWord{4, 0, 42}, + DictWord{9, 0, 205}, + DictWord{9, 0, 786}, + DictWord{ + 138, + 0, + 659, + }, + DictWord{6, 0, 801}, + DictWord{11, 11, 130}, + DictWord{140, 11, 609}, + DictWord{132, 0, 635}, + DictWord{5, 11, 345}, + DictWord{135, 11, 1016}, + DictWord{139, 0, 533}, + DictWord{132, 0, 371}, + DictWord{4, 0, 272}, + DictWord{135, 0, 836}, + DictWord{6, 0, 1282}, + DictWord{135, 11, 1100}, + DictWord{5, 0, 825}, + DictWord{134, 0, 1640}, + DictWord{135, 11, 1325}, + DictWord{133, 11, 673}, + DictWord{4, 11, 287}, + DictWord{133, 11, 1018}, + DictWord{135, 0, 357}, + DictWord{ + 6, + 0, + 467, + }, + DictWord{137, 0, 879}, + DictWord{7, 0, 317}, + DictWord{135, 0, 569}, + DictWord{6, 0, 924}, + DictWord{134, 0, 1588}, + DictWord{5, 11, 34}, + DictWord{ + 5, + 10, + 406, + }, + DictWord{10, 11, 724}, + DictWord{12, 11, 444}, + DictWord{13, 11, 354}, + DictWord{18, 11, 32}, + DictWord{23, 11, 24}, + DictWord{23, 11, 31}, + DictWord{ + 152, + 11, + 5, + }, + DictWord{6, 0, 1795}, + DictWord{6, 0, 1835}, + DictWord{6, 0, 1836}, + DictWord{6, 0, 1856}, + DictWord{8, 0, 844}, + DictWord{8, 0, 849}, + DictWord{8, 0, 854}, + DictWord{8, 0, 870}, + DictWord{8, 0, 887}, + DictWord{10, 0, 852}, + DictWord{138, 0, 942}, + DictWord{6, 10, 69}, + DictWord{135, 10, 117}, + DictWord{137, 0, 307}, + DictWord{ + 4, + 0, + 944, + }, + DictWord{6, 0, 1799}, + DictWord{6, 0, 1825}, + DictWord{10, 0, 848}, + DictWord{10, 0, 875}, + DictWord{10, 0, 895}, + DictWord{10, 0, 899}, + DictWord{ + 10, + 0, + 902, + }, + DictWord{140, 0, 773}, + DictWord{11, 0, 43}, + DictWord{13, 0, 72}, + DictWord{141, 0, 142}, + DictWord{135, 10, 1830}, + DictWord{134, 11, 382}, + DictWord{ + 4, + 10, + 432, + }, + DictWord{135, 10, 824}, + DictWord{132, 11, 329}, + DictWord{7, 0, 1820}, + DictWord{139, 11, 124}, + DictWord{133, 10, 826}, + DictWord{ + 133, + 0, + 525, + }, + DictWord{132, 11, 906}, + DictWord{7, 11, 1940}, + DictWord{136, 11, 366}, + DictWord{138, 11, 10}, + DictWord{4, 11, 123}, + DictWord{4, 11, 649}, + DictWord{ + 5, + 11, + 605, + }, + DictWord{7, 11, 1509}, + DictWord{136, 11, 36}, + DictWord{6, 0, 110}, + DictWord{135, 0, 1681}, + DictWord{133, 0, 493}, + DictWord{133, 11, 767}, + DictWord{4, 0, 174}, + DictWord{135, 0, 911}, + DictWord{138, 11, 786}, + DictWord{8, 0, 417}, + DictWord{137, 0, 782}, + DictWord{133, 10, 1000}, + DictWord{7, 0, 733}, + DictWord{137, 0, 583}, + DictWord{4, 10, 297}, + DictWord{6, 10, 529}, + DictWord{7, 10, 152}, + DictWord{7, 10, 713}, + DictWord{7, 10, 1845}, + DictWord{8, 10, 710}, + DictWord{8, 10, 717}, + DictWord{12, 10, 639}, + DictWord{140, 10, 685}, + DictWord{4, 0, 32}, + DictWord{5, 0, 215}, + DictWord{6, 0, 269}, + DictWord{7, 0, 1782}, + DictWord{ + 7, + 0, + 1892, + }, + DictWord{10, 0, 16}, + DictWord{11, 0, 822}, + DictWord{11, 0, 954}, + DictWord{141, 0, 481}, + DictWord{4, 11, 273}, + DictWord{5, 11, 658}, + DictWord{ + 133, + 11, + 995, + }, + DictWord{136, 0, 477}, + DictWord{134, 11, 72}, + DictWord{135, 11, 1345}, + DictWord{5, 0, 308}, + DictWord{7, 0, 1088}, + DictWord{4, 10, 520}, + DictWord{ + 135, + 10, + 575, + }, + DictWord{133, 11, 589}, + DictWord{5, 0, 126}, + DictWord{8, 0, 297}, + DictWord{9, 0, 366}, + DictWord{140, 0, 374}, + DictWord{7, 0, 1551}, + DictWord{ + 139, + 0, + 361, + }, + DictWord{5, 11, 117}, + DictWord{6, 11, 514}, + DictWord{6, 11, 541}, + DictWord{7, 11, 1164}, + DictWord{7, 11, 1436}, + DictWord{8, 11, 220}, + DictWord{ + 8, + 11, + 648, + }, + DictWord{10, 11, 688}, + DictWord{139, 11, 560}, + DictWord{133, 11, 686}, + DictWord{4, 0, 946}, + DictWord{6, 0, 1807}, + DictWord{8, 0, 871}, + DictWord{ + 10, + 0, + 854, + }, + DictWord{10, 0, 870}, + DictWord{10, 0, 888}, + DictWord{10, 0, 897}, + DictWord{10, 0, 920}, + DictWord{12, 0, 722}, + DictWord{12, 0, 761}, + DictWord{ + 12, + 0, + 763, + }, + DictWord{12, 0, 764}, + DictWord{14, 0, 454}, + DictWord{14, 0, 465}, + DictWord{16, 0, 107}, + DictWord{18, 0, 167}, + DictWord{18, 0, 168}, + DictWord{ + 146, + 0, + 172, + }, + DictWord{132, 0, 175}, + DictWord{135, 0, 1307}, + DictWord{132, 0, 685}, + DictWord{135, 11, 1834}, + DictWord{133, 0, 797}, + DictWord{6, 0, 745}, + DictWord{ + 6, + 0, + 858, + }, + DictWord{134, 0, 963}, + DictWord{133, 0, 565}, + DictWord{5, 10, 397}, + DictWord{6, 10, 154}, + DictWord{7, 11, 196}, + DictWord{7, 10, 676}, + DictWord{ + 8, + 10, + 443, + }, + DictWord{8, 10, 609}, + DictWord{9, 10, 24}, + DictWord{9, 10, 325}, + DictWord{10, 10, 35}, + DictWord{10, 11, 765}, + DictWord{11, 11, 347}, + DictWord{ + 11, + 10, + 535, + }, + DictWord{11, 11, 552}, + DictWord{11, 11, 576}, + DictWord{11, 10, 672}, + DictWord{11, 11, 790}, + DictWord{11, 10, 1018}, + DictWord{12, 11, 263}, + DictWord{12, 10, 637}, + DictWord{13, 11, 246}, + DictWord{13, 11, 270}, + DictWord{13, 11, 395}, + DictWord{14, 11, 74}, + DictWord{14, 11, 176}, + DictWord{ + 14, + 11, + 190, + }, + DictWord{14, 11, 398}, + DictWord{14, 11, 412}, + DictWord{15, 11, 32}, + DictWord{15, 11, 63}, + DictWord{16, 10, 30}, + DictWord{16, 11, 88}, + DictWord{ + 147, + 11, + 105, + }, + DictWord{13, 11, 84}, + DictWord{141, 11, 122}, + DictWord{4, 0, 252}, + DictWord{7, 0, 1068}, + DictWord{10, 0, 434}, + DictWord{11, 0, 228}, + DictWord{ + 11, + 0, + 426, + }, + DictWord{13, 0, 231}, + DictWord{18, 0, 106}, + DictWord{148, 0, 87}, + DictWord{137, 0, 826}, + DictWord{4, 11, 589}, + DictWord{139, 11, 282}, + DictWord{ + 5, + 11, + 381, + }, + DictWord{135, 11, 1792}, + DictWord{132, 0, 791}, + DictWord{5, 0, 231}, + DictWord{10, 0, 509}, + DictWord{133, 10, 981}, + DictWord{7, 0, 601}, + DictWord{ + 9, + 0, + 277, + }, + DictWord{9, 0, 674}, + DictWord{10, 0, 178}, + DictWord{10, 0, 418}, + DictWord{10, 0, 571}, + DictWord{11, 0, 531}, + DictWord{12, 0, 113}, + DictWord{12, 0, 475}, + DictWord{13, 0, 99}, + DictWord{142, 0, 428}, + DictWord{4, 10, 56}, + DictWord{7, 11, 616}, + DictWord{7, 10, 1791}, + DictWord{8, 10, 607}, + DictWord{8, 10, 651}, + DictWord{10, 11, 413}, + DictWord{11, 10, 465}, + DictWord{11, 10, 835}, + DictWord{12, 10, 337}, + DictWord{141, 10, 480}, + DictWord{7, 0, 1591}, + DictWord{144, 0, 43}, + DictWord{9, 10, 158}, + DictWord{138, 10, 411}, + DictWord{135, 0, 1683}, + DictWord{8, 0, 289}, + DictWord{11, 0, 45}, + DictWord{12, 0, 278}, + DictWord{140, 0, 537}, + DictWord{6, 11, 120}, + DictWord{7, 11, 1188}, + DictWord{7, 11, 1710}, + DictWord{8, 11, 286}, + DictWord{9, 11, 667}, + DictWord{11, 11, 592}, + DictWord{ + 139, + 11, + 730, + }, + DictWord{136, 10, 617}, + DictWord{135, 0, 1120}, + DictWord{135, 11, 1146}, + DictWord{139, 10, 563}, + DictWord{4, 11, 352}, + DictWord{4, 10, 369}, + DictWord{135, 11, 687}, + DictWord{143, 11, 38}, + DictWord{4, 0, 399}, + DictWord{5, 0, 119}, + DictWord{5, 0, 494}, + DictWord{7, 0, 751}, + DictWord{9, 0, 556}, + DictWord{ + 14, + 11, + 179, + }, + DictWord{15, 11, 151}, + DictWord{150, 11, 11}, + DictWord{4, 11, 192}, + DictWord{5, 11, 49}, + DictWord{6, 11, 200}, + DictWord{6, 11, 293}, + DictWord{ + 6, + 11, + 1696, + }, + DictWord{135, 11, 488}, + DictWord{4, 0, 398}, + DictWord{133, 0, 660}, + DictWord{7, 0, 1030}, + DictWord{134, 10, 622}, + DictWord{135, 11, 595}, + DictWord{141, 0, 168}, + DictWord{132, 11, 147}, + DictWord{7, 0, 973}, + DictWord{10, 10, 624}, + DictWord{142, 10, 279}, + DictWord{132, 10, 363}, + DictWord{ + 132, + 0, + 642, + }, + DictWord{133, 11, 934}, + DictWord{134, 0, 1615}, + DictWord{7, 11, 505}, + DictWord{135, 11, 523}, + DictWord{7, 0, 594}, + DictWord{7, 0, 851}, + DictWord{ + 7, + 0, + 1858, + }, + DictWord{9, 0, 411}, + DictWord{9, 0, 574}, + DictWord{9, 0, 666}, + DictWord{9, 0, 737}, + DictWord{10, 0, 346}, + DictWord{10, 0, 712}, + DictWord{11, 0, 246}, + DictWord{11, 0, 432}, + DictWord{11, 0, 517}, + DictWord{11, 0, 647}, + DictWord{11, 0, 679}, + DictWord{11, 0, 727}, + DictWord{12, 0, 304}, + DictWord{12, 0, 305}, + DictWord{ + 12, + 0, + 323, + }, + DictWord{12, 0, 483}, + DictWord{12, 0, 572}, + DictWord{12, 0, 593}, + DictWord{12, 0, 602}, + DictWord{13, 0, 95}, + DictWord{13, 0, 101}, + DictWord{ + 13, + 0, + 171, + }, + DictWord{13, 0, 315}, + DictWord{13, 0, 378}, + DictWord{13, 0, 425}, + DictWord{13, 0, 475}, + DictWord{14, 0, 63}, + DictWord{14, 0, 380}, + DictWord{14, 0, 384}, + DictWord{15, 0, 133}, + DictWord{18, 0, 112}, + DictWord{148, 0, 72}, + DictWord{135, 0, 1093}, + DictWord{132, 0, 679}, + DictWord{8, 0, 913}, + DictWord{10, 0, 903}, + DictWord{10, 0, 915}, + DictWord{12, 0, 648}, + DictWord{12, 0, 649}, + DictWord{14, 0, 455}, + DictWord{16, 0, 112}, + DictWord{138, 11, 438}, + DictWord{137, 0, 203}, + DictWord{134, 10, 292}, + DictWord{134, 0, 1492}, + DictWord{7, 0, 1374}, + DictWord{8, 0, 540}, + DictWord{5, 10, 177}, + DictWord{6, 10, 616}, + DictWord{7, 10, 827}, + DictWord{9, 10, 525}, + DictWord{138, 10, 656}, + DictWord{135, 0, 1486}, + DictWord{9, 0, 714}, + DictWord{138, 10, 31}, + DictWord{136, 0, 825}, + DictWord{ + 134, + 0, + 1511, + }, + DictWord{132, 11, 637}, + DictWord{134, 0, 952}, + DictWord{4, 10, 161}, + DictWord{133, 10, 631}, + DictWord{5, 0, 143}, + DictWord{5, 0, 769}, + DictWord{ + 6, + 0, + 1760, + }, + DictWord{7, 0, 682}, + DictWord{7, 0, 1992}, + DictWord{136, 0, 736}, + DictWord{132, 0, 700}, + DictWord{134, 0, 1540}, + DictWord{132, 11, 777}, + DictWord{ + 9, + 11, + 867, + }, + DictWord{138, 11, 837}, + DictWord{7, 0, 1557}, + DictWord{135, 10, 1684}, + DictWord{133, 0, 860}, + DictWord{6, 0, 422}, + DictWord{7, 0, 0}, + DictWord{ + 7, + 0, + 1544, + }, + DictWord{9, 0, 605}, + DictWord{11, 0, 990}, + DictWord{12, 0, 235}, + DictWord{12, 0, 453}, + DictWord{13, 0, 47}, + DictWord{13, 0, 266}, + DictWord{9, 10, 469}, + DictWord{9, 10, 709}, + DictWord{12, 10, 512}, + DictWord{14, 10, 65}, + DictWord{145, 10, 12}, + DictWord{11, 0, 807}, + DictWord{10, 10, 229}, + DictWord{11, 10, 73}, + DictWord{139, 10, 376}, + DictWord{6, 11, 170}, + DictWord{7, 11, 1080}, + DictWord{8, 11, 395}, + DictWord{8, 11, 487}, + DictWord{11, 11, 125}, + DictWord{ + 141, + 11, + 147, + }, + DictWord{5, 0, 515}, + DictWord{137, 0, 131}, + DictWord{7, 0, 1605}, + DictWord{11, 0, 962}, + DictWord{146, 0, 139}, + DictWord{132, 0, 646}, + DictWord{ + 4, + 0, + 396, + }, + DictWord{7, 0, 728}, + DictWord{9, 0, 117}, + DictWord{13, 0, 202}, + DictWord{148, 0, 51}, + DictWord{6, 0, 121}, + DictWord{6, 0, 124}, + DictWord{6, 0, 357}, + DictWord{ + 7, + 0, + 1138, + }, + DictWord{7, 0, 1295}, + DictWord{8, 0, 162}, + DictWord{8, 0, 508}, + DictWord{11, 0, 655}, + DictWord{4, 11, 535}, + DictWord{6, 10, 558}, + DictWord{ + 7, + 10, + 651, + }, + DictWord{8, 11, 618}, + DictWord{9, 10, 0}, + DictWord{10, 10, 34}, + DictWord{139, 10, 1008}, + DictWord{135, 11, 1245}, + DictWord{138, 0, 357}, + DictWord{ + 150, + 11, + 23, + }, + DictWord{133, 0, 237}, + DictWord{135, 0, 1784}, + DictWord{7, 10, 1832}, + DictWord{138, 10, 374}, + DictWord{132, 0, 713}, + DictWord{132, 11, 46}, + DictWord{6, 0, 1536}, + DictWord{10, 0, 348}, + DictWord{5, 11, 811}, + DictWord{6, 11, 1679}, + DictWord{6, 11, 1714}, + DictWord{135, 11, 2032}, + DictWord{ + 11, + 11, + 182, + }, + DictWord{142, 11, 195}, + DictWord{6, 0, 523}, + DictWord{7, 0, 738}, + DictWord{7, 10, 771}, + DictWord{7, 10, 1731}, + DictWord{9, 10, 405}, + DictWord{ + 138, + 10, + 421, + }, + DictWord{7, 11, 1458}, + DictWord{9, 11, 407}, + DictWord{139, 11, 15}, + DictWord{6, 11, 34}, + DictWord{7, 11, 69}, + DictWord{7, 11, 640}, + DictWord{ + 7, + 11, + 1089, + }, + DictWord{8, 11, 708}, + DictWord{8, 11, 721}, + DictWord{9, 11, 363}, + DictWord{9, 11, 643}, + DictWord{10, 11, 628}, + DictWord{148, 11, 98}, + DictWord{ + 133, + 0, + 434, + }, + DictWord{135, 0, 1877}, + DictWord{7, 0, 571}, + DictWord{138, 0, 366}, + DictWord{5, 10, 881}, + DictWord{133, 10, 885}, + DictWord{9, 0, 513}, + DictWord{ + 10, + 0, + 25, + }, + DictWord{10, 0, 39}, + DictWord{12, 0, 122}, + DictWord{140, 0, 187}, + DictWord{132, 0, 580}, + DictWord{5, 10, 142}, + DictWord{134, 10, 546}, + DictWord{ + 132, + 11, + 462, + }, + DictWord{137, 0, 873}, + DictWord{5, 10, 466}, + DictWord{11, 10, 571}, + DictWord{12, 10, 198}, + DictWord{13, 10, 283}, + DictWord{14, 10, 186}, + DictWord{15, 10, 21}, + DictWord{143, 10, 103}, + DictWord{7, 0, 171}, + DictWord{4, 10, 185}, + DictWord{5, 10, 257}, + DictWord{5, 10, 839}, + DictWord{5, 10, 936}, + DictWord{ + 9, + 10, + 399, + }, + DictWord{10, 10, 258}, + DictWord{10, 10, 395}, + DictWord{10, 10, 734}, + DictWord{11, 10, 1014}, + DictWord{12, 10, 23}, + DictWord{13, 10, 350}, + DictWord{14, 10, 150}, + DictWord{147, 10, 6}, + DictWord{134, 0, 625}, + DictWord{7, 0, 107}, + DictWord{7, 0, 838}, + DictWord{8, 0, 550}, + DictWord{138, 0, 401}, + DictWord{ + 5, + 11, + 73, + }, + DictWord{6, 11, 23}, + DictWord{134, 11, 338}, + DictWord{4, 0, 943}, + DictWord{6, 0, 1850}, + DictWord{12, 0, 713}, + DictWord{142, 0, 434}, + DictWord{ + 11, + 0, + 588, + }, + DictWord{11, 0, 864}, + DictWord{11, 0, 936}, + DictWord{11, 0, 968}, + DictWord{12, 0, 73}, + DictWord{12, 0, 343}, + DictWord{12, 0, 394}, + DictWord{13, 0, 275}, + DictWord{14, 0, 257}, + DictWord{15, 0, 160}, + DictWord{7, 10, 404}, + DictWord{7, 10, 1377}, + DictWord{7, 10, 1430}, + DictWord{7, 10, 2017}, + DictWord{8, 10, 149}, + DictWord{8, 10, 239}, + DictWord{8, 10, 512}, + DictWord{8, 10, 793}, + DictWord{8, 10, 818}, + DictWord{9, 10, 474}, + DictWord{9, 10, 595}, + DictWord{10, 10, 122}, + DictWord{10, 10, 565}, + DictWord{10, 10, 649}, + DictWord{10, 10, 783}, + DictWord{11, 10, 239}, + DictWord{11, 10, 295}, + DictWord{11, 10, 447}, + DictWord{ + 11, + 10, + 528, + }, + DictWord{11, 10, 639}, + DictWord{11, 10, 800}, + DictWord{12, 10, 25}, + DictWord{12, 10, 157}, + DictWord{12, 10, 316}, + DictWord{12, 10, 390}, + DictWord{ + 12, + 10, + 391, + }, + DictWord{12, 10, 395}, + DictWord{12, 10, 478}, + DictWord{12, 10, 503}, + DictWord{12, 10, 592}, + DictWord{12, 10, 680}, + DictWord{13, 10, 50}, + DictWord{13, 10, 53}, + DictWord{13, 10, 132}, + DictWord{13, 10, 198}, + DictWord{13, 10, 322}, + DictWord{13, 10, 415}, + DictWord{13, 10, 511}, + DictWord{14, 10, 71}, + DictWord{14, 10, 395}, + DictWord{15, 10, 71}, + DictWord{15, 10, 136}, + DictWord{17, 10, 123}, + DictWord{18, 10, 93}, + DictWord{147, 10, 58}, + DictWord{ + 133, + 0, + 768, + }, + DictWord{11, 0, 103}, + DictWord{142, 0, 0}, + DictWord{136, 10, 712}, + DictWord{132, 0, 799}, + DictWord{132, 0, 894}, + DictWord{7, 11, 725}, + DictWord{ + 8, + 11, + 498, + }, + DictWord{139, 11, 268}, + DictWord{135, 11, 1798}, + DictWord{135, 11, 773}, + DictWord{141, 11, 360}, + DictWord{4, 10, 377}, + DictWord{152, 10, 13}, + DictWord{135, 0, 1673}, + DictWord{132, 11, 583}, + DictWord{134, 0, 1052}, + DictWord{133, 11, 220}, + DictWord{140, 11, 69}, + DictWord{132, 11, 544}, + DictWord{ + 4, + 10, + 180, + }, + DictWord{135, 10, 1906}, + DictWord{134, 0, 272}, + DictWord{4, 0, 441}, + DictWord{134, 0, 1421}, + DictWord{4, 0, 9}, + DictWord{5, 0, 128}, + DictWord{ + 7, + 0, + 368, + }, + DictWord{11, 0, 480}, + DictWord{148, 0, 3}, + DictWord{5, 11, 176}, + DictWord{6, 11, 437}, + DictWord{6, 11, 564}, + DictWord{11, 11, 181}, + DictWord{ + 141, + 11, + 183, + }, + DictWord{132, 10, 491}, + DictWord{7, 0, 1182}, + DictWord{141, 11, 67}, + DictWord{6, 0, 1346}, + DictWord{4, 10, 171}, + DictWord{138, 10, 234}, + DictWord{ + 4, + 10, + 586, + }, + DictWord{7, 10, 1186}, + DictWord{138, 10, 631}, + DictWord{136, 0, 682}, + DictWord{134, 0, 1004}, + DictWord{15, 0, 24}, + DictWord{143, 11, 24}, + DictWord{134, 0, 968}, + DictWord{4, 0, 2}, + DictWord{6, 0, 742}, + DictWord{6, 0, 793}, + DictWord{7, 0, 545}, + DictWord{7, 0, 894}, + DictWord{9, 10, 931}, + DictWord{ + 10, + 10, + 334, + }, + DictWord{148, 10, 71}, + DictWord{136, 11, 600}, + DictWord{133, 10, 765}, + DictWord{9, 0, 769}, + DictWord{140, 0, 185}, + DictWord{4, 11, 790}, + DictWord{ + 5, + 11, + 273, + }, + DictWord{134, 11, 394}, + DictWord{7, 0, 474}, + DictWord{137, 0, 578}, + DictWord{4, 11, 135}, + DictWord{6, 11, 127}, + DictWord{7, 11, 1185}, + DictWord{ + 7, + 11, + 1511, + }, + DictWord{8, 11, 613}, + DictWord{11, 11, 5}, + DictWord{12, 11, 133}, + DictWord{12, 11, 495}, + DictWord{12, 11, 586}, + DictWord{14, 11, 385}, + DictWord{15, 11, 118}, + DictWord{17, 11, 20}, + DictWord{146, 11, 98}, + DictWord{133, 10, 424}, + DictWord{5, 0, 530}, + DictWord{142, 0, 113}, + DictWord{6, 11, 230}, + DictWord{7, 11, 961}, + DictWord{7, 11, 1085}, + DictWord{136, 11, 462}, + DictWord{7, 11, 1954}, + DictWord{137, 11, 636}, + DictWord{136, 10, 714}, + DictWord{ + 149, + 11, + 6, + }, + DictWord{135, 10, 685}, + DictWord{9, 10, 420}, + DictWord{10, 10, 269}, + DictWord{10, 10, 285}, + DictWord{10, 10, 576}, + DictWord{11, 10, 397}, + DictWord{13, 10, 175}, + DictWord{145, 10, 90}, + DictWord{132, 10, 429}, + DictWord{5, 0, 556}, + DictWord{5, 11, 162}, + DictWord{136, 11, 68}, + DictWord{132, 11, 654}, + DictWord{4, 11, 156}, + DictWord{7, 11, 998}, + DictWord{7, 11, 1045}, + DictWord{7, 11, 1860}, + DictWord{9, 11, 48}, + DictWord{9, 11, 692}, + DictWord{11, 11, 419}, + DictWord{139, 11, 602}, + DictWord{6, 0, 1317}, + DictWord{8, 0, 16}, + DictWord{9, 0, 825}, + DictWord{12, 0, 568}, + DictWord{7, 11, 1276}, + DictWord{8, 11, 474}, + DictWord{137, 11, 652}, + DictWord{18, 0, 97}, + DictWord{7, 10, 18}, + DictWord{7, 10, 699}, + DictWord{7, 10, 1966}, + DictWord{8, 10, 752}, + DictWord{9, 10, 273}, + DictWord{ + 9, + 10, + 412, + }, + DictWord{9, 10, 703}, + DictWord{10, 10, 71}, + DictWord{10, 10, 427}, + DictWord{138, 10, 508}, + DictWord{10, 0, 703}, + DictWord{7, 11, 1454}, + DictWord{138, 11, 703}, + DictWord{4, 10, 53}, + DictWord{5, 10, 186}, + DictWord{135, 10, 752}, + DictWord{134, 0, 892}, + DictWord{134, 0, 1571}, + DictWord{8, 10, 575}, + DictWord{10, 10, 289}, + DictWord{139, 10, 319}, + DictWord{6, 0, 186}, + DictWord{137, 0, 426}, + DictWord{134, 0, 1101}, + DictWord{132, 10, 675}, + DictWord{ + 132, + 0, + 585, + }, + DictWord{6, 0, 1870}, + DictWord{137, 0, 937}, + DictWord{152, 11, 10}, + DictWord{9, 11, 197}, + DictWord{10, 11, 300}, + DictWord{12, 11, 473}, + DictWord{ + 13, + 11, + 90, + }, + DictWord{141, 11, 405}, + DictWord{4, 0, 93}, + DictWord{5, 0, 252}, + DictWord{6, 0, 229}, + DictWord{7, 0, 291}, + DictWord{9, 0, 550}, + DictWord{139, 0, 644}, + DictWord{137, 0, 749}, + DictWord{9, 0, 162}, + DictWord{6, 10, 209}, + DictWord{8, 10, 468}, + DictWord{9, 10, 210}, + DictWord{11, 10, 36}, + DictWord{12, 10, 28}, + DictWord{12, 10, 630}, + DictWord{13, 10, 21}, + DictWord{13, 10, 349}, + DictWord{14, 10, 7}, + DictWord{145, 10, 13}, + DictWord{132, 0, 381}, + DictWord{132, 11, 606}, + DictWord{4, 10, 342}, + DictWord{135, 10, 1179}, + DictWord{7, 11, 1587}, + DictWord{7, 11, 1707}, + DictWord{10, 11, 528}, + DictWord{139, 11, 504}, + DictWord{ + 12, + 11, + 39, + }, + DictWord{13, 11, 265}, + DictWord{141, 11, 439}, + DictWord{4, 10, 928}, + DictWord{133, 10, 910}, + DictWord{7, 10, 1838}, + DictWord{7, 11, 1978}, + DictWord{136, 11, 676}, + DictWord{6, 0, 762}, + DictWord{6, 0, 796}, + DictWord{134, 0, 956}, + DictWord{4, 10, 318}, + DictWord{4, 10, 496}, + DictWord{7, 10, 856}, + DictWord{139, 10, 654}, + DictWord{137, 11, 242}, + DictWord{4, 11, 361}, + DictWord{133, 11, 315}, + DictWord{132, 11, 461}, + DictWord{132, 11, 472}, + DictWord{ + 132, + 0, + 857, + }, + DictWord{5, 0, 21}, + DictWord{6, 0, 77}, + DictWord{6, 0, 157}, + DictWord{7, 0, 974}, + DictWord{7, 0, 1301}, + DictWord{7, 0, 1339}, + DictWord{7, 0, 1490}, + DictWord{ + 7, + 0, + 1873, + }, + DictWord{9, 0, 628}, + DictWord{7, 10, 915}, + DictWord{8, 10, 247}, + DictWord{147, 10, 0}, + DictWord{4, 10, 202}, + DictWord{5, 10, 382}, + DictWord{ + 6, + 10, + 454, + }, + DictWord{7, 10, 936}, + DictWord{7, 10, 1803}, + DictWord{8, 10, 758}, + DictWord{9, 10, 375}, + DictWord{9, 10, 895}, + DictWord{10, 10, 743}, + DictWord{ + 10, + 10, + 792, + }, + DictWord{11, 10, 978}, + DictWord{11, 10, 1012}, + DictWord{142, 10, 109}, + DictWord{7, 11, 617}, + DictWord{10, 11, 498}, + DictWord{11, 11, 501}, + DictWord{12, 11, 16}, + DictWord{140, 11, 150}, + DictWord{7, 10, 1150}, + DictWord{7, 10, 1425}, + DictWord{7, 10, 1453}, + DictWord{10, 11, 747}, + DictWord{ + 140, + 10, + 513, + }, + DictWord{133, 11, 155}, + DictWord{11, 0, 919}, + DictWord{141, 0, 409}, + DictWord{138, 10, 791}, + DictWord{10, 0, 633}, + DictWord{139, 11, 729}, + DictWord{ + 7, + 11, + 163, + }, + DictWord{8, 11, 319}, + DictWord{9, 11, 402}, + DictWord{10, 11, 24}, + DictWord{10, 11, 681}, + DictWord{11, 11, 200}, + DictWord{11, 11, 567}, + DictWord{12, 11, 253}, + DictWord{12, 11, 410}, + DictWord{142, 11, 219}, + DictWord{5, 11, 475}, + DictWord{7, 11, 1780}, + DictWord{9, 11, 230}, + DictWord{11, 11, 297}, + DictWord{11, 11, 558}, + DictWord{14, 11, 322}, + DictWord{147, 11, 76}, + DictWord{7, 0, 332}, + DictWord{6, 10, 445}, + DictWord{137, 10, 909}, + DictWord{ + 135, + 11, + 1956, + }, + DictWord{136, 11, 274}, + DictWord{134, 10, 578}, + DictWord{135, 0, 1489}, + DictWord{135, 11, 1848}, + DictWord{5, 11, 944}, + DictWord{ + 134, + 11, + 1769, + }, + DictWord{132, 11, 144}, + DictWord{136, 10, 766}, + DictWord{4, 0, 832}, + DictWord{135, 10, 541}, + DictWord{8, 0, 398}, + DictWord{9, 0, 681}, + DictWord{ + 139, + 0, + 632, + }, + DictWord{136, 0, 645}, + DictWord{9, 0, 791}, + DictWord{10, 0, 93}, + DictWord{16, 0, 13}, + DictWord{17, 0, 23}, + DictWord{18, 0, 135}, + DictWord{19, 0, 12}, + DictWord{20, 0, 1}, + DictWord{20, 0, 12}, + DictWord{148, 0, 14}, + DictWord{6, 11, 247}, + DictWord{137, 11, 555}, + DictWord{134, 0, 20}, + DictWord{132, 0, 800}, + DictWord{135, 0, 1841}, + DictWord{139, 10, 983}, + DictWord{137, 10, 768}, + DictWord{132, 10, 584}, + DictWord{141, 11, 51}, + DictWord{6, 0, 1993}, + DictWord{ + 4, + 11, + 620, + }, + DictWord{138, 11, 280}, + DictWord{136, 0, 769}, + DictWord{11, 0, 290}, + DictWord{11, 0, 665}, + DictWord{7, 11, 1810}, + DictWord{11, 11, 866}, + DictWord{ + 12, + 11, + 103, + }, + DictWord{13, 11, 495}, + DictWord{17, 11, 67}, + DictWord{147, 11, 74}, + DictWord{134, 0, 1426}, + DictWord{139, 0, 60}, + DictWord{4, 10, 326}, + DictWord{135, 10, 1770}, + DictWord{7, 0, 1874}, + DictWord{9, 0, 641}, + DictWord{132, 10, 226}, + DictWord{6, 0, 644}, + DictWord{5, 10, 426}, + DictWord{8, 10, 30}, + DictWord{ + 9, + 10, + 2, + }, + DictWord{11, 10, 549}, + DictWord{147, 10, 122}, + DictWord{5, 11, 428}, + DictWord{138, 11, 442}, + DictWord{135, 11, 1871}, + DictWord{ + 135, + 0, + 1757, + }, + DictWord{147, 10, 117}, + DictWord{135, 0, 937}, + DictWord{135, 0, 1652}, + DictWord{6, 0, 654}, + DictWord{134, 0, 1476}, + DictWord{133, 11, 99}, + DictWord{135, 0, 527}, + DictWord{132, 10, 345}, + DictWord{4, 10, 385}, + DictWord{4, 11, 397}, + DictWord{7, 10, 265}, + DictWord{135, 10, 587}, + DictWord{4, 0, 579}, + DictWord{5, 0, 226}, + DictWord{5, 0, 323}, + DictWord{135, 0, 960}, + DictWord{134, 0, 1486}, + DictWord{8, 11, 502}, + DictWord{144, 11, 9}, + DictWord{4, 10, 347}, + DictWord{ + 5, + 10, + 423, + }, + DictWord{5, 10, 996}, + DictWord{135, 10, 1329}, + DictWord{7, 11, 727}, + DictWord{146, 11, 73}, + DictWord{4, 11, 485}, + DictWord{7, 11, 353}, + DictWord{7, 10, 1259}, + DictWord{7, 11, 1523}, + DictWord{9, 10, 125}, + DictWord{139, 10, 65}, + DictWord{6, 0, 325}, + DictWord{5, 10, 136}, + DictWord{6, 11, 366}, + DictWord{ + 7, + 11, + 1384, + }, + DictWord{7, 11, 1601}, + DictWord{136, 10, 644}, + DictWord{138, 11, 160}, + DictWord{6, 0, 1345}, + DictWord{137, 11, 282}, + DictWord{18, 0, 91}, + DictWord{147, 0, 70}, + DictWord{136, 0, 404}, + DictWord{4, 11, 157}, + DictWord{133, 11, 471}, + DictWord{133, 0, 973}, + DictWord{6, 0, 135}, + DictWord{ + 135, + 0, + 1176, + }, + DictWord{8, 11, 116}, + DictWord{11, 11, 551}, + DictWord{142, 11, 159}, + DictWord{4, 0, 549}, + DictWord{4, 10, 433}, + DictWord{133, 10, 719}, + DictWord{ + 136, + 0, + 976, + }, + DictWord{5, 11, 160}, + DictWord{7, 11, 363}, + DictWord{7, 11, 589}, + DictWord{10, 11, 170}, + DictWord{141, 11, 55}, + DictWord{144, 0, 21}, + DictWord{ + 144, + 0, + 51, + }, + DictWord{135, 0, 314}, + DictWord{135, 10, 1363}, + DictWord{4, 11, 108}, + DictWord{7, 11, 405}, + DictWord{10, 11, 491}, + DictWord{139, 11, 498}, + DictWord{146, 0, 4}, + DictWord{4, 10, 555}, + DictWord{8, 10, 536}, + DictWord{10, 10, 288}, + DictWord{139, 10, 1005}, + DictWord{135, 11, 1005}, + DictWord{6, 0, 281}, + DictWord{7, 0, 6}, + DictWord{8, 0, 282}, + DictWord{8, 0, 480}, + DictWord{8, 0, 499}, + DictWord{9, 0, 198}, + DictWord{10, 0, 143}, + DictWord{10, 0, 169}, + DictWord{ + 10, + 0, + 211, + }, + DictWord{10, 0, 417}, + DictWord{10, 0, 574}, + DictWord{11, 0, 147}, + DictWord{11, 0, 395}, + DictWord{12, 0, 75}, + DictWord{12, 0, 407}, + DictWord{12, 0, 608}, + DictWord{13, 0, 500}, + DictWord{142, 0, 251}, + DictWord{6, 0, 1093}, + DictWord{6, 0, 1405}, + DictWord{9, 10, 370}, + DictWord{138, 10, 90}, + DictWord{4, 11, 926}, + DictWord{133, 11, 983}, + DictWord{135, 0, 1776}, + DictWord{134, 0, 1528}, + DictWord{132, 0, 419}, + DictWord{132, 11, 538}, + DictWord{6, 11, 294}, + DictWord{ + 7, + 11, + 1267, + }, + DictWord{136, 11, 624}, + DictWord{135, 11, 1772}, + DictWord{138, 11, 301}, + DictWord{4, 10, 257}, + DictWord{135, 10, 2031}, + DictWord{4, 0, 138}, + DictWord{7, 0, 1012}, + DictWord{7, 0, 1280}, + DictWord{9, 0, 76}, + DictWord{135, 10, 1768}, + DictWord{132, 11, 757}, + DictWord{5, 0, 29}, + DictWord{140, 0, 638}, + DictWord{7, 11, 655}, + DictWord{135, 11, 1844}, + DictWord{7, 0, 1418}, + DictWord{6, 11, 257}, + DictWord{135, 11, 1522}, + DictWord{8, 11, 469}, + DictWord{ + 138, + 11, + 47, + }, + DictWord{142, 11, 278}, + DictWord{6, 10, 83}, + DictWord{6, 10, 1733}, + DictWord{135, 10, 1389}, + DictWord{11, 11, 204}, + DictWord{11, 11, 243}, + DictWord{140, 11, 293}, + DictWord{135, 11, 1875}, + DictWord{6, 0, 1710}, + DictWord{135, 0, 2038}, + DictWord{137, 11, 299}, + DictWord{4, 0, 17}, + DictWord{5, 0, 23}, + DictWord{7, 0, 995}, + DictWord{11, 0, 383}, + DictWord{11, 0, 437}, + DictWord{12, 0, 460}, + DictWord{140, 0, 532}, + DictWord{133, 0, 862}, + DictWord{137, 10, 696}, + DictWord{6, 0, 592}, + DictWord{138, 0, 946}, + DictWord{138, 11, 599}, + DictWord{7, 10, 1718}, + DictWord{9, 10, 95}, + DictWord{9, 10, 274}, + DictWord{10, 10, 279}, + DictWord{10, 10, 317}, + DictWord{10, 10, 420}, + DictWord{11, 10, 303}, + DictWord{11, 10, 808}, + DictWord{12, 10, 134}, + DictWord{12, 10, 367}, + DictWord{ + 13, + 10, + 149, + }, + DictWord{13, 10, 347}, + DictWord{14, 10, 349}, + DictWord{14, 10, 406}, + DictWord{18, 10, 22}, + DictWord{18, 10, 89}, + DictWord{18, 10, 122}, + DictWord{ + 147, + 10, + 47, + }, + DictWord{8, 0, 70}, + DictWord{12, 0, 171}, + DictWord{141, 0, 272}, + DictWord{133, 10, 26}, + DictWord{132, 10, 550}, + DictWord{137, 0, 812}, + DictWord{ + 10, + 0, + 233, + }, + DictWord{139, 0, 76}, + DictWord{134, 0, 988}, + DictWord{134, 0, 442}, + DictWord{136, 10, 822}, + DictWord{7, 0, 896}, + DictWord{4, 10, 902}, + DictWord{ + 5, + 10, + 809, + }, + DictWord{134, 10, 122}, + DictWord{5, 11, 150}, + DictWord{7, 11, 106}, + DictWord{8, 11, 603}, + DictWord{9, 11, 593}, + DictWord{9, 11, 634}, + DictWord{ + 10, + 11, + 44, + }, + DictWord{10, 11, 173}, + DictWord{11, 11, 462}, + DictWord{11, 11, 515}, + DictWord{13, 11, 216}, + DictWord{13, 11, 288}, + DictWord{142, 11, 400}, + DictWord{136, 0, 483}, + DictWord{135, 10, 262}, + DictWord{6, 0, 1709}, + DictWord{133, 10, 620}, + DictWord{4, 10, 34}, + DictWord{5, 10, 574}, + DictWord{7, 10, 279}, + DictWord{7, 10, 1624}, + DictWord{136, 10, 601}, + DictWord{137, 10, 170}, + DictWord{147, 0, 119}, + DictWord{12, 11, 108}, + DictWord{141, 11, 291}, + DictWord{ + 11, + 0, + 69, + }, + DictWord{12, 0, 105}, + DictWord{12, 0, 117}, + DictWord{13, 0, 213}, + DictWord{14, 0, 13}, + DictWord{14, 0, 62}, + DictWord{14, 0, 177}, + DictWord{14, 0, 421}, + DictWord{15, 0, 19}, + DictWord{146, 0, 141}, + DictWord{137, 0, 309}, + DictWord{11, 11, 278}, + DictWord{142, 11, 73}, + DictWord{7, 0, 608}, + DictWord{7, 0, 976}, + DictWord{9, 0, 146}, + DictWord{10, 0, 206}, + DictWord{10, 0, 596}, + DictWord{13, 0, 218}, + DictWord{142, 0, 153}, + DictWord{133, 10, 332}, + DictWord{6, 10, 261}, + DictWord{ + 8, + 10, + 182, + }, + DictWord{139, 10, 943}, + DictWord{4, 11, 493}, + DictWord{144, 11, 55}, + DictWord{134, 10, 1721}, + DictWord{132, 0, 768}, + DictWord{4, 10, 933}, + DictWord{133, 10, 880}, + DictWord{7, 11, 555}, + DictWord{7, 11, 1316}, + DictWord{7, 11, 1412}, + DictWord{7, 11, 1839}, + DictWord{9, 11, 192}, + DictWord{ + 9, + 11, + 589, + }, + DictWord{11, 11, 241}, + DictWord{11, 11, 676}, + DictWord{11, 11, 811}, + DictWord{11, 11, 891}, + DictWord{12, 11, 140}, + DictWord{12, 11, 346}, + DictWord{ + 12, + 11, + 479, + }, + DictWord{13, 11, 30}, + DictWord{13, 11, 49}, + DictWord{13, 11, 381}, + DictWord{14, 11, 188}, + DictWord{15, 11, 150}, + DictWord{16, 11, 76}, + DictWord{18, 11, 30}, + DictWord{148, 11, 52}, + DictWord{4, 0, 518}, + DictWord{135, 0, 1136}, + DictWord{6, 11, 568}, + DictWord{7, 11, 112}, + DictWord{7, 11, 1804}, + DictWord{8, 11, 362}, + DictWord{8, 11, 410}, + DictWord{8, 11, 830}, + DictWord{9, 11, 514}, + DictWord{11, 11, 649}, + DictWord{142, 11, 157}, + DictWord{135, 11, 673}, + DictWord{8, 0, 689}, + DictWord{137, 0, 863}, + DictWord{4, 0, 18}, + DictWord{7, 0, 145}, + DictWord{7, 0, 444}, + DictWord{7, 0, 1278}, + DictWord{8, 0, 49}, + DictWord{8, 0, 400}, + DictWord{9, 0, 71}, + DictWord{9, 0, 250}, + DictWord{10, 0, 459}, + DictWord{12, 0, 160}, + DictWord{16, 0, 24}, + DictWord{132, 11, 625}, + DictWord{140, 0, 1020}, + DictWord{4, 0, 997}, + DictWord{6, 0, 1946}, + DictWord{6, 0, 1984}, + DictWord{134, 0, 1998}, + DictWord{6, 11, 16}, + DictWord{6, 11, 158}, + DictWord{7, 11, 43}, + DictWord{ + 7, + 11, + 129, + }, + DictWord{7, 11, 181}, + DictWord{8, 11, 276}, + DictWord{8, 11, 377}, + DictWord{10, 11, 523}, + DictWord{11, 11, 816}, + DictWord{12, 11, 455}, + DictWord{ + 13, + 11, + 303, + }, + DictWord{142, 11, 135}, + DictWord{133, 10, 812}, + DictWord{134, 0, 658}, + DictWord{4, 11, 1}, + DictWord{7, 11, 1143}, + DictWord{7, 11, 1463}, + DictWord{8, 11, 61}, + DictWord{9, 11, 207}, + DictWord{9, 11, 390}, + DictWord{9, 11, 467}, + DictWord{139, 11, 836}, + DictWord{150, 11, 26}, + DictWord{140, 0, 106}, + DictWord{6, 0, 1827}, + DictWord{10, 0, 931}, + DictWord{18, 0, 166}, + DictWord{20, 0, 114}, + DictWord{4, 10, 137}, + DictWord{7, 10, 1178}, + DictWord{7, 11, 1319}, + DictWord{135, 10, 1520}, + DictWord{133, 0, 1010}, + DictWord{4, 11, 723}, + DictWord{5, 11, 895}, + DictWord{7, 11, 1031}, + DictWord{8, 11, 199}, + DictWord{8, 11, 340}, + DictWord{9, 11, 153}, + DictWord{9, 11, 215}, + DictWord{10, 11, 21}, + DictWord{10, 11, 59}, + DictWord{10, 11, 80}, + DictWord{10, 11, 224}, + DictWord{11, 11, 229}, + DictWord{11, 11, 652}, + DictWord{12, 11, 192}, + DictWord{13, 11, 146}, + DictWord{142, 11, 91}, + DictWord{132, 11, 295}, + DictWord{6, 11, 619}, + DictWord{ + 7, + 11, + 898, + }, + DictWord{7, 11, 1092}, + DictWord{8, 11, 485}, + DictWord{18, 11, 28}, + DictWord{147, 11, 116}, + DictWord{137, 11, 51}, + DictWord{6, 10, 1661}, + DictWord{ + 7, + 10, + 1975, + }, + DictWord{7, 10, 2009}, + DictWord{135, 10, 2011}, + DictWord{5, 11, 309}, + DictWord{140, 11, 211}, + DictWord{5, 0, 87}, + DictWord{7, 0, 313}, + DictWord{ + 7, + 0, + 1103, + }, + DictWord{10, 0, 208}, + DictWord{10, 0, 582}, + DictWord{11, 0, 389}, + DictWord{11, 0, 813}, + DictWord{12, 0, 385}, + DictWord{13, 0, 286}, + DictWord{ + 14, + 0, + 124, + }, + DictWord{146, 0, 108}, + DictWord{5, 11, 125}, + DictWord{8, 11, 77}, + DictWord{138, 11, 15}, + DictWord{132, 0, 267}, + DictWord{133, 0, 703}, + DictWord{ + 137, + 11, + 155, + }, + DictWord{133, 11, 439}, + DictWord{11, 11, 164}, + DictWord{140, 11, 76}, + DictWord{9, 0, 496}, + DictWord{5, 10, 89}, + DictWord{7, 10, 1915}, + DictWord{ + 9, + 10, + 185, + }, + DictWord{9, 10, 235}, + DictWord{10, 10, 64}, + DictWord{10, 10, 270}, + DictWord{10, 10, 403}, + DictWord{10, 10, 469}, + DictWord{10, 10, 529}, + DictWord{10, 10, 590}, + DictWord{11, 10, 140}, + DictWord{11, 10, 860}, + DictWord{13, 10, 1}, + DictWord{13, 10, 422}, + DictWord{14, 10, 341}, + DictWord{14, 10, 364}, + DictWord{17, 10, 93}, + DictWord{18, 10, 113}, + DictWord{19, 10, 97}, + DictWord{147, 10, 113}, + DictWord{133, 10, 695}, + DictWord{135, 0, 1121}, + DictWord{ + 5, + 10, + 6, + }, + DictWord{6, 10, 183}, + DictWord{7, 10, 680}, + DictWord{7, 10, 978}, + DictWord{7, 10, 1013}, + DictWord{7, 10, 1055}, + DictWord{12, 10, 230}, + DictWord{ + 13, + 10, + 172, + }, + DictWord{146, 10, 29}, + DictWord{4, 11, 8}, + DictWord{7, 11, 1152}, + DictWord{7, 11, 1153}, + DictWord{7, 11, 1715}, + DictWord{9, 11, 374}, + DictWord{ + 10, + 11, + 478, + }, + DictWord{139, 11, 648}, + DictWord{135, 11, 1099}, + DictWord{6, 10, 29}, + DictWord{139, 10, 63}, + DictWord{4, 0, 561}, + DictWord{10, 0, 249}, + DictWord{ + 139, + 0, + 209, + }, + DictWord{132, 0, 760}, + DictWord{7, 11, 799}, + DictWord{138, 11, 511}, + DictWord{136, 11, 87}, + DictWord{9, 0, 154}, + DictWord{140, 0, 485}, + DictWord{136, 0, 255}, + DictWord{132, 0, 323}, + DictWord{140, 0, 419}, + DictWord{132, 10, 311}, + DictWord{134, 10, 1740}, + DictWord{4, 0, 368}, + DictWord{ + 135, + 0, + 641, + }, + DictWord{7, 10, 170}, + DictWord{8, 10, 90}, + DictWord{8, 10, 177}, + DictWord{8, 10, 415}, + DictWord{11, 10, 714}, + DictWord{142, 10, 281}, + DictWord{ + 4, + 11, + 69, + }, + DictWord{5, 11, 122}, + DictWord{9, 11, 656}, + DictWord{138, 11, 464}, + DictWord{5, 11, 849}, + DictWord{134, 11, 1633}, + DictWord{8, 0, 522}, + DictWord{ + 142, + 0, + 328, + }, + DictWord{11, 10, 91}, + DictWord{13, 10, 129}, + DictWord{15, 10, 101}, + DictWord{145, 10, 125}, + DictWord{7, 0, 562}, + DictWord{8, 0, 551}, + DictWord{ + 4, + 10, + 494, + }, + DictWord{6, 10, 74}, + DictWord{7, 10, 44}, + DictWord{11, 11, 499}, + DictWord{12, 10, 17}, + DictWord{15, 10, 5}, + DictWord{148, 10, 11}, + DictWord{4, 10, 276}, + DictWord{133, 10, 296}, + DictWord{9, 0, 92}, + DictWord{147, 0, 91}, + DictWord{4, 10, 7}, + DictWord{5, 10, 90}, + DictWord{5, 10, 158}, + DictWord{6, 10, 542}, + DictWord{ + 7, + 10, + 221, + }, + DictWord{7, 10, 1574}, + DictWord{9, 10, 490}, + DictWord{10, 10, 540}, + DictWord{11, 10, 443}, + DictWord{139, 10, 757}, + DictWord{6, 0, 525}, + DictWord{ + 6, + 0, + 1976, + }, + DictWord{8, 0, 806}, + DictWord{9, 0, 876}, + DictWord{140, 0, 284}, + DictWord{5, 11, 859}, + DictWord{7, 10, 588}, + DictWord{7, 11, 1160}, + DictWord{ + 8, + 11, + 107, + }, + DictWord{9, 10, 175}, + DictWord{9, 11, 291}, + DictWord{9, 11, 439}, + DictWord{10, 10, 530}, + DictWord{10, 11, 663}, + DictWord{11, 11, 609}, + DictWord{ + 140, + 11, + 197, + }, + DictWord{7, 11, 168}, + DictWord{13, 11, 196}, + DictWord{141, 11, 237}, + DictWord{139, 0, 958}, + DictWord{133, 0, 594}, + DictWord{135, 10, 580}, + DictWord{7, 10, 88}, + DictWord{136, 10, 627}, + DictWord{6, 0, 479}, + DictWord{6, 0, 562}, + DictWord{7, 0, 1060}, + DictWord{13, 0, 6}, + DictWord{5, 10, 872}, + DictWord{ + 6, + 10, + 57, + }, + DictWord{7, 10, 471}, + DictWord{9, 10, 447}, + DictWord{137, 10, 454}, + DictWord{136, 11, 413}, + DictWord{145, 11, 19}, + DictWord{4, 11, 117}, + DictWord{ + 6, + 11, + 372, + }, + DictWord{7, 11, 1905}, + DictWord{142, 11, 323}, + DictWord{4, 11, 722}, + DictWord{139, 11, 471}, + DictWord{17, 0, 61}, + DictWord{5, 10, 31}, + DictWord{134, 10, 614}, + DictWord{8, 10, 330}, + DictWord{140, 10, 477}, + DictWord{7, 10, 1200}, + DictWord{138, 10, 460}, + DictWord{6, 10, 424}, + DictWord{ + 135, + 10, + 1866, + }, + DictWord{6, 0, 1641}, + DictWord{136, 0, 820}, + DictWord{6, 0, 1556}, + DictWord{134, 0, 1618}, + DictWord{9, 11, 5}, + DictWord{12, 11, 216}, + DictWord{ + 12, + 11, + 294, + }, + DictWord{12, 11, 298}, + DictWord{12, 11, 400}, + DictWord{12, 11, 518}, + DictWord{13, 11, 229}, + DictWord{143, 11, 139}, + DictWord{15, 11, 155}, + DictWord{144, 11, 79}, + DictWord{4, 0, 302}, + DictWord{135, 0, 1766}, + DictWord{5, 10, 13}, + DictWord{134, 10, 142}, + DictWord{6, 0, 148}, + DictWord{7, 0, 1313}, + DictWord{ + 7, + 10, + 116, + }, + DictWord{8, 10, 322}, + DictWord{8, 10, 755}, + DictWord{9, 10, 548}, + DictWord{10, 10, 714}, + DictWord{11, 10, 884}, + DictWord{141, 10, 324}, + DictWord{137, 0, 676}, + DictWord{9, 11, 88}, + DictWord{139, 11, 270}, + DictWord{5, 11, 12}, + DictWord{7, 11, 375}, + DictWord{137, 11, 438}, + DictWord{134, 0, 1674}, + DictWord{7, 10, 1472}, + DictWord{135, 10, 1554}, + DictWord{11, 0, 178}, + DictWord{7, 10, 1071}, + DictWord{7, 10, 1541}, + DictWord{7, 10, 1767}, + DictWord{ + 7, + 10, + 1806, + }, + DictWord{11, 10, 162}, + DictWord{11, 10, 242}, + DictWord{12, 10, 605}, + DictWord{15, 10, 26}, + DictWord{144, 10, 44}, + DictWord{6, 0, 389}, + DictWord{ + 7, + 0, + 149, + }, + DictWord{9, 0, 142}, + DictWord{138, 0, 94}, + DictWord{140, 11, 71}, + DictWord{145, 10, 115}, + DictWord{6, 0, 8}, + DictWord{7, 0, 1881}, + DictWord{8, 0, 91}, + DictWord{11, 11, 966}, + DictWord{12, 11, 287}, + DictWord{13, 11, 342}, + DictWord{13, 11, 402}, + DictWord{15, 11, 110}, + DictWord{143, 11, 163}, + DictWord{ + 4, + 11, + 258, + }, + DictWord{136, 11, 639}, + DictWord{6, 11, 22}, + DictWord{7, 11, 903}, + DictWord{138, 11, 577}, + DictWord{133, 11, 681}, + DictWord{135, 10, 1111}, + DictWord{135, 11, 1286}, + DictWord{9, 0, 112}, + DictWord{8, 10, 1}, + DictWord{138, 10, 326}, + DictWord{5, 10, 488}, + DictWord{6, 10, 527}, + DictWord{7, 10, 489}, + DictWord{ + 7, + 10, + 1636, + }, + DictWord{8, 10, 121}, + DictWord{8, 10, 144}, + DictWord{8, 10, 359}, + DictWord{9, 10, 193}, + DictWord{9, 10, 241}, + DictWord{9, 10, 336}, + DictWord{ + 9, + 10, + 882, + }, + DictWord{11, 10, 266}, + DictWord{11, 10, 372}, + DictWord{11, 10, 944}, + DictWord{12, 10, 401}, + DictWord{140, 10, 641}, + DictWord{4, 11, 664}, + DictWord{133, 11, 804}, + DictWord{6, 0, 747}, + DictWord{134, 0, 1015}, + DictWord{135, 0, 1746}, + DictWord{9, 10, 31}, + DictWord{10, 10, 244}, + DictWord{ + 10, + 10, + 699, + }, + DictWord{12, 10, 149}, + DictWord{141, 10, 497}, + DictWord{133, 10, 377}, + DictWord{135, 0, 24}, + DictWord{6, 0, 1352}, + DictWord{5, 11, 32}, + DictWord{ + 145, + 10, + 101, + }, + DictWord{7, 0, 1530}, + DictWord{10, 0, 158}, + DictWord{13, 0, 13}, + DictWord{13, 0, 137}, + DictWord{13, 0, 258}, + DictWord{14, 0, 111}, + DictWord{ + 14, + 0, + 225, + }, + DictWord{14, 0, 253}, + DictWord{14, 0, 304}, + DictWord{14, 0, 339}, + DictWord{14, 0, 417}, + DictWord{146, 0, 33}, + DictWord{4, 0, 503}, + DictWord{ + 135, + 0, + 1661, + }, + DictWord{5, 0, 130}, + DictWord{6, 0, 845}, + DictWord{7, 0, 1314}, + DictWord{9, 0, 610}, + DictWord{10, 0, 718}, + DictWord{11, 0, 601}, + DictWord{11, 0, 819}, + DictWord{11, 0, 946}, + DictWord{140, 0, 536}, + DictWord{10, 0, 149}, + DictWord{11, 0, 280}, + DictWord{142, 0, 336}, + DictWord{134, 0, 1401}, + DictWord{ + 135, + 0, + 1946, + }, + DictWord{8, 0, 663}, + DictWord{144, 0, 8}, + DictWord{134, 0, 1607}, + DictWord{135, 10, 2023}, + DictWord{4, 11, 289}, + DictWord{7, 11, 629}, + DictWord{ + 7, + 11, + 1698, + }, + DictWord{7, 11, 1711}, + DictWord{140, 11, 215}, + DictWord{6, 11, 450}, + DictWord{136, 11, 109}, + DictWord{10, 0, 882}, + DictWord{10, 0, 883}, + DictWord{10, 0, 914}, + DictWord{138, 0, 928}, + DictWord{133, 10, 843}, + DictWord{136, 11, 705}, + DictWord{132, 10, 554}, + DictWord{133, 10, 536}, + DictWord{ + 5, + 0, + 417, + }, + DictWord{9, 10, 79}, + DictWord{11, 10, 625}, + DictWord{145, 10, 7}, + DictWord{7, 11, 1238}, + DictWord{142, 11, 37}, + DictWord{4, 0, 392}, + DictWord{ + 135, + 0, + 1597, + }, + DictWord{5, 0, 433}, + DictWord{9, 0, 633}, + DictWord{11, 0, 629}, + DictWord{132, 10, 424}, + DictWord{7, 10, 336}, + DictWord{136, 10, 785}, + DictWord{ + 134, + 11, + 355, + }, + DictWord{6, 0, 234}, + DictWord{7, 0, 769}, + DictWord{9, 0, 18}, + DictWord{138, 0, 358}, + DictWord{4, 10, 896}, + DictWord{134, 10, 1777}, + DictWord{ + 138, + 11, + 323, + }, + DictWord{7, 0, 140}, + DictWord{7, 0, 1950}, + DictWord{8, 0, 680}, + DictWord{11, 0, 817}, + DictWord{147, 0, 88}, + DictWord{7, 0, 1222}, + DictWord{ + 138, + 0, + 386, + }, + DictWord{139, 11, 908}, + DictWord{11, 0, 249}, + DictWord{12, 0, 313}, + DictWord{16, 0, 66}, + DictWord{145, 0, 26}, + DictWord{134, 0, 5}, + DictWord{7, 10, 750}, + DictWord{9, 10, 223}, + DictWord{11, 10, 27}, + DictWord{11, 10, 466}, + DictWord{12, 10, 624}, + DictWord{14, 10, 265}, + DictWord{146, 10, 61}, + DictWord{ + 134, + 11, + 26, + }, + DictWord{134, 0, 1216}, + DictWord{5, 0, 963}, + DictWord{134, 0, 1773}, + DictWord{4, 11, 414}, + DictWord{5, 11, 467}, + DictWord{9, 11, 654}, + DictWord{ + 10, + 11, + 451, + }, + DictWord{12, 11, 59}, + DictWord{141, 11, 375}, + DictWord{135, 11, 17}, + DictWord{4, 10, 603}, + DictWord{133, 10, 661}, + DictWord{4, 10, 11}, + DictWord{ + 6, + 10, + 128, + }, + DictWord{7, 10, 231}, + DictWord{7, 10, 1533}, + DictWord{138, 10, 725}, + DictWord{135, 11, 955}, + DictWord{7, 0, 180}, + DictWord{8, 0, 509}, + DictWord{ + 136, + 0, + 792, + }, + DictWord{132, 10, 476}, + DictWord{132, 0, 1002}, + DictWord{133, 11, 538}, + DictWord{135, 10, 1807}, + DictWord{132, 0, 931}, + DictWord{7, 0, 943}, + DictWord{11, 0, 614}, + DictWord{140, 0, 747}, + DictWord{135, 0, 1837}, + DictWord{9, 10, 20}, + DictWord{10, 10, 324}, + DictWord{10, 10, 807}, + DictWord{ + 139, + 10, + 488, + }, + DictWord{134, 0, 641}, + DictWord{6, 11, 280}, + DictWord{10, 11, 502}, + DictWord{11, 11, 344}, + DictWord{140, 11, 38}, + DictWord{5, 11, 45}, + DictWord{ + 7, + 11, + 1161, + }, + DictWord{11, 11, 448}, + DictWord{11, 11, 880}, + DictWord{13, 11, 139}, + DictWord{13, 11, 407}, + DictWord{15, 11, 16}, + DictWord{17, 11, 95}, + DictWord{ + 18, + 11, + 66, + }, + DictWord{18, 11, 88}, + DictWord{18, 11, 123}, + DictWord{149, 11, 7}, + DictWord{9, 0, 280}, + DictWord{138, 0, 134}, + DictWord{22, 0, 22}, + DictWord{23, 0, 5}, + DictWord{151, 0, 29}, + DictWord{136, 11, 777}, + DictWord{4, 0, 90}, + DictWord{5, 0, 545}, + DictWord{7, 0, 754}, + DictWord{9, 0, 186}, + DictWord{10, 0, 72}, + DictWord{ + 10, + 0, + 782, + }, + DictWord{11, 0, 577}, + DictWord{11, 0, 610}, + DictWord{11, 0, 960}, + DictWord{12, 0, 354}, + DictWord{12, 0, 362}, + DictWord{12, 0, 595}, + DictWord{ + 4, + 11, + 410, + }, + DictWord{135, 11, 521}, + DictWord{135, 11, 1778}, + DictWord{5, 10, 112}, + DictWord{6, 10, 103}, + DictWord{134, 10, 150}, + DictWord{138, 10, 356}, + DictWord{132, 0, 742}, + DictWord{7, 0, 151}, + DictWord{9, 0, 329}, + DictWord{139, 0, 254}, + DictWord{8, 0, 853}, + DictWord{8, 0, 881}, + DictWord{8, 0, 911}, + DictWord{ + 8, + 0, + 912, + }, + DictWord{10, 0, 872}, + DictWord{12, 0, 741}, + DictWord{12, 0, 742}, + DictWord{152, 0, 18}, + DictWord{4, 11, 573}, + DictWord{136, 11, 655}, + DictWord{ + 6, + 0, + 921, + }, + DictWord{134, 0, 934}, + DictWord{9, 0, 187}, + DictWord{10, 0, 36}, + DictWord{11, 0, 1016}, + DictWord{17, 0, 44}, + DictWord{146, 0, 64}, + DictWord{7, 0, 833}, + DictWord{136, 0, 517}, + DictWord{4, 0, 506}, + DictWord{5, 0, 295}, + DictWord{135, 0, 1680}, + DictWord{4, 10, 708}, + DictWord{8, 10, 15}, + DictWord{9, 10, 50}, + DictWord{ + 9, + 10, + 386, + }, + DictWord{11, 10, 18}, + DictWord{11, 10, 529}, + DictWord{140, 10, 228}, + DictWord{7, 0, 251}, + DictWord{7, 0, 1701}, + DictWord{8, 0, 436}, + DictWord{ + 4, + 10, + 563, + }, + DictWord{7, 10, 592}, + DictWord{7, 10, 637}, + DictWord{7, 10, 770}, + DictWord{8, 10, 463}, + DictWord{9, 10, 60}, + DictWord{9, 10, 335}, + DictWord{9, 10, 904}, + DictWord{10, 10, 73}, + DictWord{11, 10, 434}, + DictWord{12, 10, 585}, + DictWord{13, 10, 331}, + DictWord{18, 10, 110}, + DictWord{148, 10, 60}, + DictWord{ + 132, + 10, + 502, + }, + DictWord{136, 0, 584}, + DictWord{6, 10, 347}, + DictWord{138, 10, 161}, + DictWord{7, 0, 987}, + DictWord{9, 0, 688}, + DictWord{10, 0, 522}, + DictWord{ + 11, + 0, + 788, + }, + DictWord{12, 0, 137}, + DictWord{12, 0, 566}, + DictWord{14, 0, 9}, + DictWord{14, 0, 24}, + DictWord{14, 0, 64}, + DictWord{7, 11, 899}, + DictWord{142, 11, 325}, + DictWord{4, 0, 214}, + DictWord{5, 0, 500}, + DictWord{5, 10, 102}, + DictWord{6, 10, 284}, + DictWord{7, 10, 1079}, + DictWord{7, 10, 1423}, + DictWord{7, 10, 1702}, + DictWord{ + 8, + 10, + 470, + }, + DictWord{9, 10, 554}, + DictWord{9, 10, 723}, + DictWord{139, 10, 333}, + DictWord{7, 10, 246}, + DictWord{135, 10, 840}, + DictWord{6, 10, 10}, + DictWord{ + 8, + 10, + 571, + }, + DictWord{9, 10, 739}, + DictWord{143, 10, 91}, + DictWord{133, 10, 626}, + DictWord{146, 0, 195}, + DictWord{134, 0, 1775}, + DictWord{7, 0, 389}, + DictWord{7, 0, 700}, + DictWord{7, 0, 940}, + DictWord{8, 0, 514}, + DictWord{9, 0, 116}, + DictWord{9, 0, 535}, + DictWord{10, 0, 118}, + DictWord{11, 0, 107}, + DictWord{ + 11, + 0, + 148, + }, + DictWord{11, 0, 922}, + DictWord{12, 0, 254}, + DictWord{12, 0, 421}, + DictWord{142, 0, 238}, + DictWord{5, 10, 18}, + DictWord{6, 10, 526}, + DictWord{13, 10, 24}, + DictWord{13, 10, 110}, + DictWord{19, 10, 5}, + DictWord{147, 10, 44}, + DictWord{132, 0, 743}, + DictWord{11, 0, 292}, + DictWord{4, 10, 309}, + DictWord{5, 10, 462}, + DictWord{7, 10, 970}, + DictWord{135, 10, 1097}, + DictWord{22, 10, 30}, + DictWord{150, 10, 33}, + DictWord{139, 11, 338}, + DictWord{135, 11, 1598}, + DictWord{ + 7, + 0, + 1283, + }, + DictWord{9, 0, 227}, + DictWord{11, 0, 325}, + DictWord{11, 0, 408}, + DictWord{14, 0, 180}, + DictWord{146, 0, 47}, + DictWord{4, 0, 953}, + DictWord{6, 0, 1805}, + DictWord{6, 0, 1814}, + DictWord{6, 0, 1862}, + DictWord{140, 0, 774}, + DictWord{6, 11, 611}, + DictWord{135, 11, 1733}, + DictWord{135, 11, 1464}, + DictWord{ + 5, + 0, + 81, + }, + DictWord{7, 0, 146}, + DictWord{7, 0, 1342}, + DictWord{8, 0, 53}, + DictWord{8, 0, 561}, + DictWord{8, 0, 694}, + DictWord{8, 0, 754}, + DictWord{9, 0, 115}, + DictWord{ + 9, + 0, + 179, + }, + DictWord{9, 0, 894}, + DictWord{10, 0, 462}, + DictWord{10, 0, 813}, + DictWord{11, 0, 230}, + DictWord{11, 0, 657}, + DictWord{11, 0, 699}, + DictWord{11, 0, 748}, + DictWord{12, 0, 119}, + DictWord{12, 0, 200}, + DictWord{12, 0, 283}, + DictWord{142, 0, 273}, + DictWord{5, 0, 408}, + DictWord{6, 0, 789}, + DictWord{6, 0, 877}, + DictWord{ + 6, + 0, + 1253, + }, + DictWord{6, 0, 1413}, + DictWord{137, 0, 747}, + DictWord{134, 10, 1704}, + DictWord{135, 11, 663}, + DictWord{6, 0, 1910}, + DictWord{6, 0, 1915}, + DictWord{6, 0, 1923}, + DictWord{9, 0, 913}, + DictWord{9, 0, 928}, + DictWord{9, 0, 950}, + DictWord{9, 0, 954}, + DictWord{9, 0, 978}, + DictWord{9, 0, 993}, + DictWord{12, 0, 812}, + DictWord{12, 0, 819}, + DictWord{12, 0, 831}, + DictWord{12, 0, 833}, + DictWord{12, 0, 838}, + DictWord{12, 0, 909}, + DictWord{12, 0, 928}, + DictWord{12, 0, 931}, + DictWord{12, 0, 950}, + DictWord{15, 0, 186}, + DictWord{15, 0, 187}, + DictWord{15, 0, 195}, + DictWord{15, 0, 196}, + DictWord{15, 0, 209}, + DictWord{15, 0, 215}, + DictWord{ + 15, + 0, + 236, + }, + DictWord{15, 0, 241}, + DictWord{15, 0, 249}, + DictWord{15, 0, 253}, + DictWord{18, 0, 180}, + DictWord{18, 0, 221}, + DictWord{18, 0, 224}, + DictWord{ + 18, + 0, + 227, + }, + DictWord{18, 0, 229}, + DictWord{149, 0, 60}, + DictWord{7, 0, 1826}, + DictWord{135, 0, 1938}, + DictWord{11, 0, 490}, + DictWord{18, 0, 143}, + DictWord{ + 5, + 10, + 86, + }, + DictWord{7, 10, 743}, + DictWord{9, 10, 85}, + DictWord{10, 10, 281}, + DictWord{10, 10, 432}, + DictWord{12, 10, 251}, + DictWord{13, 10, 118}, + DictWord{ + 142, + 10, + 378, + }, + DictWord{5, 10, 524}, + DictWord{133, 10, 744}, + DictWord{141, 11, 442}, + DictWord{10, 10, 107}, + DictWord{140, 10, 436}, + DictWord{135, 11, 503}, + DictWord{134, 0, 1162}, + DictWord{132, 10, 927}, + DictWord{7, 0, 30}, + DictWord{8, 0, 86}, + DictWord{8, 0, 315}, + DictWord{8, 0, 700}, + DictWord{9, 0, 576}, + DictWord{ + 9, + 0, + 858, + }, + DictWord{10, 0, 414}, + DictWord{11, 0, 310}, + DictWord{11, 0, 888}, + DictWord{11, 0, 904}, + DictWord{12, 0, 361}, + DictWord{13, 0, 248}, + DictWord{13, 0, 371}, + DictWord{14, 0, 142}, + DictWord{12, 10, 670}, + DictWord{146, 10, 94}, + DictWord{134, 0, 721}, + DictWord{4, 11, 113}, + DictWord{5, 11, 163}, + DictWord{5, 11, 735}, + DictWord{7, 11, 1009}, + DictWord{7, 10, 1149}, + DictWord{9, 11, 9}, + DictWord{9, 10, 156}, + DictWord{9, 11, 771}, + DictWord{12, 11, 90}, + DictWord{13, 11, 138}, + DictWord{13, 11, 410}, + DictWord{143, 11, 128}, + DictWord{138, 0, 839}, + DictWord{133, 10, 778}, + DictWord{137, 0, 617}, + DictWord{133, 10, 502}, + DictWord{ + 8, + 10, + 196, + }, + DictWord{10, 10, 283}, + DictWord{139, 10, 406}, + DictWord{6, 0, 428}, + DictWord{7, 0, 524}, + DictWord{8, 0, 169}, + DictWord{8, 0, 234}, + DictWord{9, 0, 480}, + DictWord{138, 0, 646}, + DictWord{133, 10, 855}, + DictWord{134, 0, 1648}, + DictWord{7, 0, 1205}, + DictWord{138, 0, 637}, + DictWord{7, 0, 1596}, + DictWord{ + 4, + 11, + 935, + }, + DictWord{133, 11, 823}, + DictWord{5, 11, 269}, + DictWord{7, 11, 434}, + DictWord{7, 11, 891}, + DictWord{8, 11, 339}, + DictWord{9, 11, 702}, + DictWord{ + 11, + 11, + 594, + }, + DictWord{11, 11, 718}, + DictWord{145, 11, 100}, + DictWord{7, 11, 878}, + DictWord{9, 11, 485}, + DictWord{141, 11, 264}, + DictWord{4, 0, 266}, + DictWord{ + 8, + 0, + 4, + }, + DictWord{9, 0, 39}, + DictWord{10, 0, 166}, + DictWord{11, 0, 918}, + DictWord{12, 0, 635}, + DictWord{20, 0, 10}, + DictWord{22, 0, 27}, + DictWord{22, 0, 43}, + DictWord{ + 22, + 0, + 52, + }, + DictWord{134, 11, 1713}, + DictWord{7, 10, 1400}, + DictWord{9, 10, 446}, + DictWord{138, 10, 45}, + DictWord{135, 11, 900}, + DictWord{132, 0, 862}, + DictWord{134, 0, 1554}, + DictWord{135, 11, 1033}, + DictWord{19, 0, 16}, + DictWord{147, 11, 16}, + DictWord{135, 11, 1208}, + DictWord{7, 0, 157}, + DictWord{ + 136, + 0, + 279, + }, + DictWord{6, 0, 604}, + DictWord{136, 0, 391}, + DictWord{13, 10, 455}, + DictWord{15, 10, 99}, + DictWord{15, 10, 129}, + DictWord{144, 10, 68}, + DictWord{ + 135, + 10, + 172, + }, + DictWord{7, 0, 945}, + DictWord{11, 0, 713}, + DictWord{139, 0, 744}, + DictWord{4, 0, 973}, + DictWord{10, 0, 877}, + DictWord{10, 0, 937}, + DictWord{ + 10, + 0, + 938, + }, + DictWord{140, 0, 711}, + DictWord{139, 0, 1022}, + DictWord{132, 10, 568}, + DictWord{142, 11, 143}, + DictWord{4, 0, 567}, + DictWord{9, 0, 859}, + DictWord{ + 132, + 10, + 732, + }, + DictWord{7, 0, 1846}, + DictWord{136, 0, 628}, + DictWord{136, 10, 733}, + DictWord{133, 0, 762}, + DictWord{4, 10, 428}, + DictWord{135, 10, 1789}, + DictWord{10, 0, 784}, + DictWord{13, 0, 191}, + DictWord{7, 10, 2015}, + DictWord{140, 10, 665}, + DictWord{133, 0, 298}, + DictWord{7, 0, 633}, + DictWord{7, 0, 905}, + DictWord{7, 0, 909}, + DictWord{7, 0, 1538}, + DictWord{9, 0, 767}, + DictWord{140, 0, 636}, + DictWord{138, 10, 806}, + DictWord{132, 0, 795}, + DictWord{139, 0, 301}, + DictWord{135, 0, 1970}, + DictWord{5, 11, 625}, + DictWord{135, 11, 1617}, + DictWord{135, 11, 275}, + DictWord{7, 11, 37}, + DictWord{8, 11, 425}, + DictWord{ + 8, + 11, + 693, + }, + DictWord{9, 11, 720}, + DictWord{10, 11, 380}, + DictWord{10, 11, 638}, + DictWord{11, 11, 273}, + DictWord{11, 11, 307}, + DictWord{11, 11, 473}, + DictWord{ + 12, + 11, + 61, + }, + DictWord{143, 11, 43}, + DictWord{135, 11, 198}, + DictWord{134, 0, 1236}, + DictWord{7, 0, 369}, + DictWord{12, 0, 644}, + DictWord{12, 0, 645}, + DictWord{144, 0, 90}, + DictWord{19, 0, 15}, + DictWord{149, 0, 27}, + DictWord{6, 0, 71}, + DictWord{7, 0, 845}, + DictWord{8, 0, 160}, + DictWord{9, 0, 318}, + DictWord{6, 10, 1623}, + DictWord{134, 10, 1681}, + DictWord{134, 0, 1447}, + DictWord{134, 0, 1255}, + DictWord{138, 0, 735}, + DictWord{8, 0, 76}, + DictWord{132, 11, 168}, + DictWord{ + 6, + 10, + 1748, + }, + DictWord{8, 10, 715}, + DictWord{9, 10, 802}, + DictWord{10, 10, 46}, + DictWord{10, 10, 819}, + DictWord{13, 10, 308}, + DictWord{14, 10, 351}, + DictWord{14, 10, 363}, + DictWord{146, 10, 67}, + DictWord{135, 11, 91}, + DictWord{6, 0, 474}, + DictWord{4, 10, 63}, + DictWord{133, 10, 347}, + DictWord{133, 10, 749}, + DictWord{138, 0, 841}, + DictWord{133, 10, 366}, + DictWord{6, 0, 836}, + DictWord{132, 11, 225}, + DictWord{135, 0, 1622}, + DictWord{135, 10, 89}, + DictWord{ + 140, + 0, + 735, + }, + DictWord{134, 0, 1601}, + DictWord{138, 11, 145}, + DictWord{6, 0, 1390}, + DictWord{137, 0, 804}, + DictWord{142, 0, 394}, + DictWord{6, 11, 15}, + DictWord{ + 7, + 11, + 70, + }, + DictWord{10, 11, 240}, + DictWord{147, 11, 93}, + DictWord{6, 0, 96}, + DictWord{135, 0, 1426}, + DictWord{4, 0, 651}, + DictWord{133, 0, 289}, + DictWord{ + 7, + 11, + 956, + }, + DictWord{7, 10, 977}, + DictWord{7, 11, 1157}, + DictWord{7, 11, 1506}, + DictWord{7, 11, 1606}, + DictWord{7, 11, 1615}, + DictWord{7, 11, 1619}, + DictWord{ + 7, + 11, + 1736, + }, + DictWord{7, 11, 1775}, + DictWord{8, 11, 590}, + DictWord{9, 11, 324}, + DictWord{9, 11, 736}, + DictWord{9, 11, 774}, + DictWord{9, 11, 776}, + DictWord{ + 9, + 11, + 784, + }, + DictWord{10, 11, 567}, + DictWord{10, 11, 708}, + DictWord{11, 11, 518}, + DictWord{11, 11, 613}, + DictWord{11, 11, 695}, + DictWord{11, 11, 716}, + DictWord{11, 11, 739}, + DictWord{11, 11, 770}, + DictWord{11, 11, 771}, + DictWord{11, 11, 848}, + DictWord{11, 11, 857}, + DictWord{11, 11, 931}, + DictWord{ + 11, + 11, + 947, + }, + DictWord{12, 11, 326}, + DictWord{12, 11, 387}, + DictWord{12, 11, 484}, + DictWord{12, 11, 528}, + DictWord{12, 11, 552}, + DictWord{12, 11, 613}, + DictWord{ + 13, + 11, + 189, + }, + DictWord{13, 11, 256}, + DictWord{13, 11, 340}, + DictWord{13, 11, 432}, + DictWord{13, 11, 436}, + DictWord{13, 11, 440}, + DictWord{13, 11, 454}, + DictWord{14, 11, 174}, + DictWord{14, 11, 220}, + DictWord{14, 11, 284}, + DictWord{14, 11, 390}, + DictWord{145, 11, 121}, + DictWord{7, 0, 688}, + DictWord{8, 0, 35}, + DictWord{9, 0, 511}, + DictWord{10, 0, 767}, + DictWord{147, 0, 118}, + DictWord{134, 0, 667}, + DictWord{4, 0, 513}, + DictWord{5, 10, 824}, + DictWord{133, 10, 941}, + DictWord{7, 10, 440}, + DictWord{8, 10, 230}, + DictWord{139, 10, 106}, + DictWord{134, 0, 2034}, + DictWord{135, 11, 1399}, + DictWord{143, 11, 66}, + DictWord{ + 135, + 11, + 1529, + }, + DictWord{4, 11, 145}, + DictWord{6, 11, 176}, + DictWord{7, 11, 395}, + DictWord{9, 11, 562}, + DictWord{144, 11, 28}, + DictWord{132, 11, 501}, + DictWord{132, 0, 704}, + DictWord{134, 0, 1524}, + DictWord{7, 0, 1078}, + DictWord{134, 11, 464}, + DictWord{6, 11, 509}, + DictWord{10, 11, 82}, + DictWord{20, 11, 91}, + DictWord{151, 11, 13}, + DictWord{4, 0, 720}, + DictWord{133, 0, 306}, + DictWord{133, 0, 431}, + DictWord{7, 0, 1196}, + DictWord{4, 10, 914}, + DictWord{5, 10, 800}, + DictWord{133, 10, 852}, + DictWord{135, 11, 1189}, + DictWord{10, 0, 54}, + DictWord{141, 10, 115}, + DictWord{7, 10, 564}, + DictWord{142, 10, 168}, + DictWord{ + 5, + 0, + 464, + }, + DictWord{6, 0, 236}, + DictWord{7, 0, 696}, + DictWord{7, 0, 914}, + DictWord{7, 0, 1108}, + DictWord{7, 0, 1448}, + DictWord{9, 0, 15}, + DictWord{9, 0, 564}, + DictWord{ + 10, + 0, + 14, + }, + DictWord{12, 0, 565}, + DictWord{13, 0, 449}, + DictWord{14, 0, 53}, + DictWord{15, 0, 13}, + DictWord{16, 0, 64}, + DictWord{17, 0, 41}, + DictWord{4, 10, 918}, + DictWord{133, 10, 876}, + DictWord{6, 0, 1418}, + DictWord{134, 10, 1764}, + DictWord{4, 10, 92}, + DictWord{133, 10, 274}, + DictWord{134, 0, 907}, + DictWord{ + 4, + 11, + 114, + }, + DictWord{8, 10, 501}, + DictWord{9, 11, 492}, + DictWord{13, 11, 462}, + DictWord{142, 11, 215}, + DictWord{4, 11, 77}, + DictWord{5, 11, 361}, + DictWord{ + 6, + 11, + 139, + }, + DictWord{6, 11, 401}, + DictWord{6, 11, 404}, + DictWord{7, 11, 413}, + DictWord{7, 11, 715}, + DictWord{7, 11, 1716}, + DictWord{11, 11, 279}, + DictWord{ + 12, + 11, + 179, + }, + DictWord{12, 11, 258}, + DictWord{13, 11, 244}, + DictWord{142, 11, 358}, + DictWord{6, 0, 1767}, + DictWord{12, 0, 194}, + DictWord{145, 0, 107}, + DictWord{ + 134, + 11, + 1717, + }, + DictWord{5, 10, 743}, + DictWord{142, 11, 329}, + DictWord{4, 10, 49}, + DictWord{7, 10, 280}, + DictWord{135, 10, 1633}, + DictWord{5, 0, 840}, + DictWord{7, 11, 1061}, + DictWord{8, 11, 82}, + DictWord{11, 11, 250}, + DictWord{12, 11, 420}, + DictWord{141, 11, 184}, + DictWord{135, 11, 724}, + DictWord{ + 134, + 0, + 900, + }, + DictWord{136, 10, 47}, + DictWord{134, 0, 1436}, + DictWord{144, 11, 0}, + DictWord{6, 0, 675}, + DictWord{7, 0, 1008}, + DictWord{7, 0, 1560}, + DictWord{ + 9, + 0, + 642, + }, + DictWord{11, 0, 236}, + DictWord{14, 0, 193}, + DictWord{5, 10, 272}, + DictWord{5, 10, 908}, + DictWord{5, 10, 942}, + DictWord{8, 10, 197}, + DictWord{9, 10, 47}, + DictWord{11, 10, 538}, + DictWord{139, 10, 742}, + DictWord{4, 0, 68}, + DictWord{5, 0, 628}, + DictWord{5, 0, 634}, + DictWord{6, 0, 386}, + DictWord{7, 0, 794}, + DictWord{ + 8, + 0, + 273, + }, + DictWord{9, 0, 563}, + DictWord{10, 0, 105}, + DictWord{10, 0, 171}, + DictWord{11, 0, 94}, + DictWord{139, 0, 354}, + DictWord{135, 10, 1911}, + DictWord{ + 137, + 10, + 891, + }, + DictWord{4, 0, 95}, + DictWord{6, 0, 1297}, + DictWord{6, 0, 1604}, + DictWord{7, 0, 416}, + DictWord{139, 0, 830}, + DictWord{6, 11, 513}, + DictWord{ + 135, + 11, + 1052, + }, + DictWord{7, 0, 731}, + DictWord{13, 0, 20}, + DictWord{143, 0, 11}, + DictWord{137, 11, 899}, + DictWord{10, 0, 850}, + DictWord{140, 0, 697}, + DictWord{ + 4, + 0, + 662, + }, + DictWord{7, 11, 1417}, + DictWord{12, 11, 382}, + DictWord{17, 11, 48}, + DictWord{152, 11, 12}, + DictWord{133, 0, 736}, + DictWord{132, 0, 861}, + DictWord{ + 4, + 10, + 407, + }, + DictWord{132, 10, 560}, + DictWord{141, 10, 490}, + DictWord{6, 11, 545}, + DictWord{7, 11, 565}, + DictWord{7, 11, 1669}, + DictWord{10, 11, 114}, + DictWord{11, 11, 642}, + DictWord{140, 11, 618}, + DictWord{6, 0, 871}, + DictWord{134, 0, 1000}, + DictWord{5, 0, 864}, + DictWord{10, 0, 648}, + DictWord{11, 0, 671}, + DictWord{15, 0, 46}, + DictWord{133, 11, 5}, + DictWord{133, 0, 928}, + DictWord{11, 0, 90}, + DictWord{13, 0, 7}, + DictWord{4, 10, 475}, + DictWord{11, 10, 35}, + DictWord{ + 13, + 10, + 71, + }, + DictWord{13, 10, 177}, + DictWord{142, 10, 422}, + DictWord{136, 0, 332}, + DictWord{135, 11, 192}, + DictWord{134, 0, 1055}, + DictWord{136, 11, 763}, + DictWord{11, 0, 986}, + DictWord{140, 0, 682}, + DictWord{7, 0, 76}, + DictWord{8, 0, 44}, + DictWord{9, 0, 884}, + DictWord{10, 0, 580}, + DictWord{11, 0, 399}, + DictWord{ + 11, + 0, + 894, + }, + DictWord{143, 0, 122}, + DictWord{135, 11, 1237}, + DictWord{135, 10, 636}, + DictWord{11, 0, 300}, + DictWord{6, 10, 222}, + DictWord{7, 10, 1620}, + DictWord{ + 8, + 10, + 409, + }, + DictWord{137, 10, 693}, + DictWord{4, 11, 87}, + DictWord{5, 11, 250}, + DictWord{10, 11, 601}, + DictWord{13, 11, 298}, + DictWord{13, 11, 353}, + DictWord{141, 11, 376}, + DictWord{5, 0, 518}, + DictWord{10, 0, 340}, + DictWord{11, 0, 175}, + DictWord{149, 0, 16}, + DictWord{140, 0, 771}, + DictWord{6, 0, 1108}, + DictWord{137, 0, 831}, + DictWord{132, 0, 836}, + DictWord{135, 0, 1852}, + DictWord{4, 0, 957}, + DictWord{6, 0, 1804}, + DictWord{8, 0, 842}, + DictWord{8, 0, 843}, + DictWord{ + 8, + 0, + 851, + }, + DictWord{8, 0, 855}, + DictWord{140, 0, 767}, + DictWord{135, 11, 814}, + DictWord{4, 11, 57}, + DictWord{7, 11, 1195}, + DictWord{7, 11, 1438}, + DictWord{ + 7, + 11, + 1548, + }, + DictWord{7, 11, 1835}, + DictWord{7, 11, 1904}, + DictWord{9, 11, 757}, + DictWord{10, 11, 604}, + DictWord{139, 11, 519}, + DictWord{133, 10, 882}, + DictWord{138, 0, 246}, + DictWord{4, 0, 934}, + DictWord{5, 0, 202}, + DictWord{8, 0, 610}, + DictWord{7, 11, 1897}, + DictWord{12, 11, 290}, + DictWord{13, 11, 80}, + DictWord{13, 11, 437}, + DictWord{145, 11, 74}, + DictWord{8, 0, 96}, + DictWord{9, 0, 36}, + DictWord{10, 0, 607}, + DictWord{10, 0, 804}, + DictWord{10, 0, 832}, + DictWord{ + 11, + 0, + 423, + }, + DictWord{11, 0, 442}, + DictWord{12, 0, 309}, + DictWord{14, 0, 199}, + DictWord{15, 0, 90}, + DictWord{145, 0, 110}, + DictWord{132, 10, 426}, + DictWord{ + 7, + 0, + 654, + }, + DictWord{8, 0, 240}, + DictWord{6, 10, 58}, + DictWord{7, 10, 745}, + DictWord{7, 10, 1969}, + DictWord{8, 10, 675}, + DictWord{9, 10, 479}, + DictWord{9, 10, 731}, + DictWord{10, 10, 330}, + DictWord{10, 10, 593}, + DictWord{10, 10, 817}, + DictWord{11, 10, 32}, + DictWord{11, 10, 133}, + DictWord{11, 10, 221}, + DictWord{ + 145, + 10, + 68, + }, + DictWord{9, 0, 13}, + DictWord{9, 0, 398}, + DictWord{9, 0, 727}, + DictWord{10, 0, 75}, + DictWord{10, 0, 184}, + DictWord{10, 0, 230}, + DictWord{10, 0, 564}, + DictWord{ + 10, + 0, + 569, + }, + DictWord{11, 0, 973}, + DictWord{12, 0, 70}, + DictWord{12, 0, 189}, + DictWord{13, 0, 57}, + DictWord{141, 0, 257}, + DictWord{4, 11, 209}, + DictWord{ + 135, + 11, + 902, + }, + DictWord{7, 0, 391}, + DictWord{137, 10, 538}, + DictWord{134, 0, 403}, + DictWord{6, 11, 303}, + DictWord{7, 11, 335}, + DictWord{7, 11, 1437}, + DictWord{ + 7, + 11, + 1668, + }, + DictWord{8, 11, 553}, + DictWord{8, 11, 652}, + DictWord{8, 11, 656}, + DictWord{9, 11, 558}, + DictWord{11, 11, 743}, + DictWord{149, 11, 18}, + DictWord{ + 132, + 11, + 559, + }, + DictWord{11, 0, 75}, + DictWord{142, 0, 267}, + DictWord{6, 0, 815}, + DictWord{141, 11, 2}, + DictWord{141, 0, 366}, + DictWord{137, 0, 631}, + DictWord{ + 133, + 11, + 1017, + }, + DictWord{5, 0, 345}, + DictWord{135, 0, 1016}, + DictWord{133, 11, 709}, + DictWord{134, 11, 1745}, + DictWord{133, 10, 566}, + DictWord{7, 0, 952}, + DictWord{6, 10, 48}, + DictWord{9, 10, 139}, + DictWord{10, 10, 399}, + DictWord{11, 10, 469}, + DictWord{12, 10, 634}, + DictWord{141, 10, 223}, + DictWord{ + 133, + 0, + 673, + }, + DictWord{9, 0, 850}, + DictWord{7, 11, 8}, + DictWord{136, 11, 206}, + DictWord{6, 0, 662}, + DictWord{149, 0, 35}, + DictWord{4, 0, 287}, + DictWord{133, 0, 1018}, + DictWord{6, 10, 114}, + DictWord{7, 10, 1224}, + DictWord{7, 10, 1556}, + DictWord{136, 10, 3}, + DictWord{8, 10, 576}, + DictWord{137, 10, 267}, + DictWord{4, 0, 884}, + DictWord{5, 0, 34}, + DictWord{10, 0, 724}, + DictWord{12, 0, 444}, + DictWord{13, 0, 354}, + DictWord{18, 0, 32}, + DictWord{23, 0, 24}, + DictWord{23, 0, 31}, + DictWord{ + 152, + 0, + 5, + }, + DictWord{133, 10, 933}, + DictWord{132, 11, 776}, + DictWord{138, 0, 151}, + DictWord{136, 0, 427}, + DictWord{134, 0, 382}, + DictWord{132, 0, 329}, + DictWord{ + 9, + 0, + 846, + }, + DictWord{10, 0, 827}, + DictWord{138, 11, 33}, + DictWord{9, 0, 279}, + DictWord{10, 0, 407}, + DictWord{14, 0, 84}, + DictWord{22, 0, 18}, + DictWord{ + 135, + 11, + 1297, + }, + DictWord{136, 11, 406}, + DictWord{132, 0, 906}, + DictWord{136, 0, 366}, + DictWord{134, 0, 843}, + DictWord{134, 0, 1443}, + DictWord{135, 0, 1372}, + DictWord{138, 0, 992}, + DictWord{4, 0, 123}, + DictWord{5, 0, 605}, + DictWord{7, 0, 1509}, + DictWord{136, 0, 36}, + DictWord{132, 0, 649}, + DictWord{8, 11, 175}, + DictWord{10, 11, 168}, + DictWord{138, 11, 573}, + DictWord{133, 0, 767}, + DictWord{134, 0, 1018}, + DictWord{135, 11, 1305}, + DictWord{12, 10, 30}, + DictWord{ + 13, + 10, + 148, + }, + DictWord{14, 10, 87}, + DictWord{14, 10, 182}, + DictWord{16, 10, 42}, + DictWord{148, 10, 70}, + DictWord{134, 11, 607}, + DictWord{4, 0, 273}, + DictWord{ + 5, + 0, + 658, + }, + DictWord{133, 0, 995}, + DictWord{6, 0, 72}, + DictWord{139, 11, 174}, + DictWord{10, 0, 483}, + DictWord{12, 0, 368}, + DictWord{7, 10, 56}, + DictWord{ + 7, + 10, + 1989, + }, + DictWord{8, 10, 337}, + DictWord{8, 10, 738}, + DictWord{9, 10, 600}, + DictWord{13, 10, 447}, + DictWord{142, 10, 92}, + DictWord{5, 11, 784}, + DictWord{ + 138, + 10, + 666, + }, + DictWord{135, 0, 1345}, + DictWord{139, 11, 882}, + DictWord{134, 0, 1293}, + DictWord{133, 0, 589}, + DictWord{134, 0, 1988}, + DictWord{5, 0, 117}, + DictWord{6, 0, 514}, + DictWord{6, 0, 541}, + DictWord{7, 0, 1164}, + DictWord{7, 0, 1436}, + DictWord{8, 0, 220}, + DictWord{8, 0, 648}, + DictWord{10, 0, 688}, + DictWord{ + 139, + 0, + 560, + }, + DictWord{136, 0, 379}, + DictWord{5, 0, 686}, + DictWord{7, 10, 866}, + DictWord{135, 10, 1163}, + DictWord{132, 10, 328}, + DictWord{9, 11, 14}, + DictWord{ + 9, + 11, + 441, + }, + DictWord{10, 11, 306}, + DictWord{139, 11, 9}, + DictWord{4, 10, 101}, + DictWord{135, 10, 1171}, + DictWord{5, 10, 833}, + DictWord{136, 10, 744}, + DictWord{5, 11, 161}, + DictWord{7, 11, 839}, + DictWord{135, 11, 887}, + DictWord{7, 0, 196}, + DictWord{10, 0, 765}, + DictWord{11, 0, 347}, + DictWord{11, 0, 552}, + DictWord{11, 0, 790}, + DictWord{12, 0, 263}, + DictWord{13, 0, 246}, + DictWord{13, 0, 270}, + DictWord{13, 0, 395}, + DictWord{14, 0, 176}, + DictWord{14, 0, 190}, + DictWord{ + 14, + 0, + 398, + }, + DictWord{14, 0, 412}, + DictWord{15, 0, 32}, + DictWord{15, 0, 63}, + DictWord{16, 0, 88}, + DictWord{147, 0, 105}, + DictWord{6, 10, 9}, + DictWord{6, 10, 397}, + DictWord{7, 10, 53}, + DictWord{7, 10, 1742}, + DictWord{10, 10, 632}, + DictWord{11, 10, 828}, + DictWord{140, 10, 146}, + DictWord{5, 0, 381}, + DictWord{135, 0, 1792}, + DictWord{134, 0, 1452}, + DictWord{135, 11, 429}, + DictWord{8, 0, 367}, + DictWord{10, 0, 760}, + DictWord{14, 0, 79}, + DictWord{20, 0, 17}, + DictWord{152, 0, 0}, + DictWord{7, 0, 616}, + DictWord{138, 0, 413}, + DictWord{11, 10, 417}, + DictWord{12, 10, 223}, + DictWord{140, 10, 265}, + DictWord{7, 11, 1611}, + DictWord{13, 11, 14}, + DictWord{15, 11, 44}, + DictWord{19, 11, 13}, + DictWord{148, 11, 76}, + DictWord{135, 0, 1229}, + DictWord{6, 0, 120}, + DictWord{7, 0, 1188}, + DictWord{7, 0, 1710}, + DictWord{8, 0, 286}, + DictWord{9, 0, 667}, + DictWord{11, 0, 592}, + DictWord{139, 0, 730}, + DictWord{135, 11, 1814}, + DictWord{135, 0, 1146}, + DictWord{4, 10, 186}, + DictWord{5, 10, 157}, + DictWord{8, 10, 168}, + DictWord{138, 10, 6}, + DictWord{4, 0, 352}, + DictWord{135, 0, 687}, + DictWord{4, 0, 192}, + DictWord{5, 0, 49}, + DictWord{ + 6, + 0, + 200, + }, + DictWord{6, 0, 293}, + DictWord{6, 0, 1696}, + DictWord{135, 0, 1151}, + DictWord{133, 10, 875}, + DictWord{5, 10, 773}, + DictWord{5, 10, 991}, + DictWord{ + 6, + 10, + 1635, + }, + DictWord{134, 10, 1788}, + DictWord{7, 10, 111}, + DictWord{136, 10, 581}, + DictWord{6, 0, 935}, + DictWord{134, 0, 1151}, + DictWord{134, 0, 1050}, + DictWord{132, 0, 650}, + DictWord{132, 0, 147}, + DictWord{11, 0, 194}, + DictWord{12, 0, 62}, + DictWord{12, 0, 88}, + DictWord{11, 11, 194}, + DictWord{12, 11, 62}, + DictWord{140, 11, 88}, + DictWord{6, 0, 339}, + DictWord{135, 0, 923}, + DictWord{134, 10, 1747}, + DictWord{7, 11, 643}, + DictWord{136, 11, 236}, + DictWord{ + 133, + 0, + 934, + }, + DictWord{7, 10, 1364}, + DictWord{7, 10, 1907}, + DictWord{141, 10, 158}, + DictWord{132, 10, 659}, + DictWord{4, 10, 404}, + DictWord{135, 10, 675}, + DictWord{7, 11, 581}, + DictWord{9, 11, 644}, + DictWord{137, 11, 699}, + DictWord{13, 0, 211}, + DictWord{14, 0, 133}, + DictWord{14, 0, 204}, + DictWord{15, 0, 64}, + DictWord{ + 15, + 0, + 69, + }, + DictWord{15, 0, 114}, + DictWord{16, 0, 10}, + DictWord{19, 0, 23}, + DictWord{19, 0, 35}, + DictWord{19, 0, 39}, + DictWord{19, 0, 51}, + DictWord{19, 0, 71}, + DictWord{19, 0, 75}, + DictWord{152, 0, 15}, + DictWord{133, 10, 391}, + DictWord{5, 11, 54}, + DictWord{135, 11, 1513}, + DictWord{7, 0, 222}, + DictWord{8, 0, 341}, + DictWord{ + 5, + 10, + 540, + }, + DictWord{134, 10, 1697}, + DictWord{134, 10, 78}, + DictWord{132, 11, 744}, + DictWord{136, 0, 293}, + DictWord{137, 11, 701}, + DictWord{ + 7, + 11, + 930, + }, + DictWord{10, 11, 402}, + DictWord{10, 11, 476}, + DictWord{13, 11, 452}, + DictWord{18, 11, 55}, + DictWord{147, 11, 104}, + DictWord{132, 0, 637}, + DictWord{133, 10, 460}, + DictWord{8, 11, 50}, + DictWord{137, 11, 624}, + DictWord{132, 11, 572}, + DictWord{134, 0, 1159}, + DictWord{4, 10, 199}, + DictWord{ + 139, + 10, + 34, + }, + DictWord{134, 0, 847}, + DictWord{134, 10, 388}, + DictWord{6, 11, 43}, + DictWord{7, 11, 38}, + DictWord{8, 11, 248}, + DictWord{9, 11, 504}, + DictWord{ + 138, + 11, + 513, + }, + DictWord{9, 0, 683}, + DictWord{4, 10, 511}, + DictWord{6, 10, 608}, + DictWord{9, 10, 333}, + DictWord{10, 10, 602}, + DictWord{11, 10, 441}, + DictWord{ + 11, + 10, + 723, + }, + DictWord{11, 10, 976}, + DictWord{140, 10, 357}, + DictWord{9, 0, 867}, + DictWord{138, 0, 837}, + DictWord{6, 0, 944}, + DictWord{135, 11, 326}, + DictWord{ + 135, + 0, + 1809, + }, + DictWord{5, 10, 938}, + DictWord{7, 11, 783}, + DictWord{136, 10, 707}, + DictWord{133, 11, 766}, + DictWord{133, 11, 363}, + DictWord{6, 0, 170}, + DictWord{7, 0, 1080}, + DictWord{8, 0, 395}, + DictWord{8, 0, 487}, + DictWord{141, 0, 147}, + DictWord{6, 11, 258}, + DictWord{140, 11, 409}, + DictWord{4, 0, 535}, + DictWord{ + 8, + 0, + 618, + }, + DictWord{5, 11, 249}, + DictWord{148, 11, 82}, + DictWord{6, 0, 1379}, + DictWord{149, 11, 15}, + DictWord{135, 0, 1625}, + DictWord{150, 0, 23}, + DictWord{ + 5, + 11, + 393, + }, + DictWord{6, 11, 378}, + DictWord{7, 11, 1981}, + DictWord{9, 11, 32}, + DictWord{9, 11, 591}, + DictWord{10, 11, 685}, + DictWord{10, 11, 741}, + DictWord{ + 142, + 11, + 382, + }, + DictWord{133, 11, 788}, + DictWord{7, 11, 1968}, + DictWord{10, 11, 19}, + DictWord{139, 11, 911}, + DictWord{7, 11, 1401}, + DictWord{ + 135, + 11, + 1476, + }, + DictWord{4, 11, 61}, + DictWord{5, 11, 58}, + DictWord{5, 11, 171}, + DictWord{5, 11, 635}, + DictWord{5, 11, 683}, + DictWord{5, 11, 700}, + DictWord{6, 11, 291}, + DictWord{6, 11, 566}, + DictWord{7, 11, 1650}, + DictWord{11, 11, 523}, + DictWord{12, 11, 273}, + DictWord{12, 11, 303}, + DictWord{15, 11, 39}, + DictWord{ + 143, + 11, + 111, + }, + DictWord{6, 10, 469}, + DictWord{7, 10, 1709}, + DictWord{138, 10, 515}, + DictWord{4, 0, 778}, + DictWord{134, 11, 589}, + DictWord{132, 0, 46}, + DictWord{ + 5, + 0, + 811, + }, + DictWord{6, 0, 1679}, + DictWord{6, 0, 1714}, + DictWord{135, 0, 2032}, + DictWord{7, 0, 1458}, + DictWord{9, 0, 407}, + DictWord{11, 0, 15}, + DictWord{12, 0, 651}, + DictWord{149, 0, 37}, + DictWord{7, 0, 938}, + DictWord{132, 10, 500}, + DictWord{6, 0, 34}, + DictWord{7, 0, 69}, + DictWord{7, 0, 1089}, + DictWord{7, 0, 1281}, + DictWord{ + 8, + 0, + 708, + }, + DictWord{8, 0, 721}, + DictWord{9, 0, 363}, + DictWord{148, 0, 98}, + DictWord{10, 11, 231}, + DictWord{147, 11, 124}, + DictWord{7, 11, 726}, + DictWord{ + 152, + 11, + 9, + }, + DictWord{5, 10, 68}, + DictWord{134, 10, 383}, + DictWord{136, 11, 583}, + DictWord{4, 11, 917}, + DictWord{133, 11, 1005}, + DictWord{11, 10, 216}, + DictWord{139, 10, 340}, + DictWord{135, 11, 1675}, + DictWord{8, 0, 441}, + DictWord{10, 0, 314}, + DictWord{143, 0, 3}, + DictWord{132, 11, 919}, + DictWord{4, 10, 337}, + DictWord{6, 10, 353}, + DictWord{7, 10, 1934}, + DictWord{8, 10, 488}, + DictWord{137, 10, 429}, + DictWord{7, 0, 889}, + DictWord{7, 10, 1795}, + DictWord{8, 10, 259}, + DictWord{9, 10, 135}, + DictWord{9, 10, 177}, + DictWord{9, 10, 860}, + DictWord{10, 10, 825}, + DictWord{11, 10, 115}, + DictWord{11, 10, 370}, + DictWord{11, 10, 405}, + DictWord{11, 10, 604}, + DictWord{12, 10, 10}, + DictWord{12, 10, 667}, + DictWord{12, 10, 669}, + DictWord{13, 10, 76}, + DictWord{14, 10, 310}, + DictWord{ + 15, + 10, + 76, + }, + DictWord{15, 10, 147}, + DictWord{148, 10, 23}, + DictWord{4, 10, 15}, + DictWord{4, 11, 255}, + DictWord{5, 10, 22}, + DictWord{5, 11, 302}, + DictWord{6, 11, 132}, + DictWord{6, 10, 244}, + DictWord{7, 10, 40}, + DictWord{7, 11, 128}, + DictWord{7, 10, 200}, + DictWord{7, 11, 283}, + DictWord{7, 10, 906}, + DictWord{7, 10, 1199}, + DictWord{ + 7, + 11, + 1299, + }, + DictWord{9, 10, 616}, + DictWord{10, 11, 52}, + DictWord{10, 11, 514}, + DictWord{10, 10, 716}, + DictWord{11, 10, 635}, + DictWord{11, 10, 801}, + DictWord{11, 11, 925}, + DictWord{12, 10, 458}, + DictWord{13, 11, 92}, + DictWord{142, 11, 309}, + DictWord{132, 0, 462}, + DictWord{137, 11, 173}, + DictWord{ + 135, + 10, + 1735, + }, + DictWord{8, 0, 525}, + DictWord{5, 10, 598}, + DictWord{7, 10, 791}, + DictWord{8, 10, 108}, + DictWord{137, 10, 123}, + DictWord{5, 0, 73}, + DictWord{6, 0, 23}, + DictWord{134, 0, 338}, + DictWord{132, 0, 676}, + DictWord{132, 10, 683}, + DictWord{7, 0, 725}, + DictWord{8, 0, 498}, + DictWord{139, 0, 268}, + DictWord{12, 0, 21}, + DictWord{151, 0, 7}, + DictWord{135, 0, 773}, + DictWord{4, 10, 155}, + DictWord{135, 10, 1689}, + DictWord{4, 0, 164}, + DictWord{5, 0, 730}, + DictWord{5, 10, 151}, + DictWord{ + 5, + 10, + 741, + }, + DictWord{6, 11, 210}, + DictWord{7, 10, 498}, + DictWord{7, 10, 870}, + DictWord{7, 10, 1542}, + DictWord{12, 10, 213}, + DictWord{14, 10, 36}, + DictWord{ + 14, + 10, + 391, + }, + DictWord{17, 10, 111}, + DictWord{18, 10, 6}, + DictWord{18, 10, 46}, + DictWord{18, 10, 151}, + DictWord{19, 10, 36}, + DictWord{20, 10, 32}, + DictWord{ + 20, + 10, + 56, + }, + DictWord{20, 10, 69}, + DictWord{20, 10, 102}, + DictWord{21, 10, 4}, + DictWord{22, 10, 8}, + DictWord{22, 10, 10}, + DictWord{22, 10, 14}, + DictWord{ + 150, + 10, + 31, + }, + DictWord{4, 10, 624}, + DictWord{135, 10, 1752}, + DictWord{4, 0, 583}, + DictWord{9, 0, 936}, + DictWord{15, 0, 214}, + DictWord{18, 0, 199}, + DictWord{24, 0, 26}, + DictWord{134, 11, 588}, + DictWord{7, 0, 1462}, + DictWord{11, 0, 659}, + DictWord{4, 11, 284}, + DictWord{134, 11, 223}, + DictWord{133, 0, 220}, + DictWord{ + 139, + 0, + 803, + }, + DictWord{132, 0, 544}, + DictWord{4, 10, 492}, + DictWord{133, 10, 451}, + DictWord{16, 0, 98}, + DictWord{148, 0, 119}, + DictWord{4, 11, 218}, + DictWord{ + 7, + 11, + 526, + }, + DictWord{143, 11, 137}, + DictWord{135, 10, 835}, + DictWord{4, 11, 270}, + DictWord{5, 11, 192}, + DictWord{6, 11, 332}, + DictWord{7, 11, 1322}, + DictWord{ + 13, + 11, + 9, + }, + DictWord{13, 10, 70}, + DictWord{14, 11, 104}, + DictWord{142, 11, 311}, + DictWord{132, 10, 539}, + DictWord{140, 11, 661}, + DictWord{5, 0, 176}, + DictWord{ + 6, + 0, + 437, + }, + DictWord{6, 0, 564}, + DictWord{11, 0, 181}, + DictWord{141, 0, 183}, + DictWord{135, 0, 1192}, + DictWord{6, 10, 113}, + DictWord{135, 10, 436}, + DictWord{136, 10, 718}, + DictWord{135, 10, 520}, + DictWord{135, 0, 1878}, + DictWord{140, 11, 196}, + DictWord{7, 11, 379}, + DictWord{8, 11, 481}, + DictWord{ + 137, + 11, + 377, + }, + DictWord{5, 11, 1003}, + DictWord{6, 11, 149}, + DictWord{137, 11, 746}, + DictWord{8, 11, 262}, + DictWord{9, 11, 627}, + DictWord{10, 11, 18}, + DictWord{ + 11, + 11, + 214, + }, + DictWord{11, 11, 404}, + DictWord{11, 11, 457}, + DictWord{11, 11, 780}, + DictWord{11, 11, 849}, + DictWord{11, 11, 913}, + DictWord{13, 11, 330}, + DictWord{13, 11, 401}, + DictWord{142, 11, 200}, + DictWord{149, 0, 26}, + DictWord{136, 11, 304}, + DictWord{132, 11, 142}, + DictWord{135, 0, 944}, + DictWord{ + 4, + 0, + 790, + }, + DictWord{5, 0, 273}, + DictWord{134, 0, 394}, + DictWord{134, 0, 855}, + DictWord{4, 0, 135}, + DictWord{6, 0, 127}, + DictWord{7, 0, 1185}, + DictWord{7, 0, 1511}, + DictWord{8, 0, 613}, + DictWord{11, 0, 5}, + DictWord{12, 0, 336}, + DictWord{12, 0, 495}, + DictWord{12, 0, 586}, + DictWord{12, 0, 660}, + DictWord{12, 0, 668}, + DictWord{ + 14, + 0, + 385, + }, + DictWord{15, 0, 118}, + DictWord{17, 0, 20}, + DictWord{146, 0, 98}, + DictWord{6, 0, 230}, + DictWord{9, 0, 752}, + DictWord{18, 0, 109}, + DictWord{12, 10, 610}, + DictWord{13, 10, 431}, + DictWord{144, 10, 59}, + DictWord{7, 0, 1954}, + DictWord{135, 11, 925}, + DictWord{4, 11, 471}, + DictWord{5, 11, 51}, + DictWord{6, 11, 602}, + DictWord{8, 11, 484}, + DictWord{10, 11, 195}, + DictWord{140, 11, 159}, + DictWord{132, 10, 307}, + DictWord{136, 11, 688}, + DictWord{132, 11, 697}, + DictWord{ + 7, + 11, + 812, + }, + DictWord{7, 11, 1261}, + DictWord{7, 11, 1360}, + DictWord{9, 11, 632}, + DictWord{140, 11, 352}, + DictWord{5, 0, 162}, + DictWord{8, 0, 68}, + DictWord{ + 133, + 10, + 964, + }, + DictWord{4, 0, 654}, + DictWord{136, 11, 212}, + DictWord{4, 0, 156}, + DictWord{7, 0, 998}, + DictWord{7, 0, 1045}, + DictWord{7, 0, 1860}, + DictWord{9, 0, 48}, + DictWord{9, 0, 692}, + DictWord{11, 0, 419}, + DictWord{139, 0, 602}, + DictWord{133, 11, 221}, + DictWord{4, 11, 373}, + DictWord{5, 11, 283}, + DictWord{6, 11, 480}, + DictWord{135, 11, 609}, + DictWord{142, 11, 216}, + DictWord{132, 0, 240}, + DictWord{6, 11, 192}, + DictWord{9, 11, 793}, + DictWord{145, 11, 55}, + DictWord{ + 4, + 10, + 75, + }, + DictWord{5, 10, 180}, + DictWord{6, 10, 500}, + DictWord{7, 10, 58}, + DictWord{7, 10, 710}, + DictWord{138, 10, 645}, + DictWord{4, 11, 132}, + DictWord{5, 11, 69}, + DictWord{5, 10, 649}, + DictWord{135, 11, 1242}, + DictWord{6, 10, 276}, + DictWord{7, 10, 282}, + DictWord{7, 10, 879}, + DictWord{7, 10, 924}, + DictWord{8, 10, 459}, + DictWord{9, 10, 599}, + DictWord{9, 10, 754}, + DictWord{11, 10, 574}, + DictWord{12, 10, 128}, + DictWord{12, 10, 494}, + DictWord{13, 10, 52}, + DictWord{13, 10, 301}, + DictWord{15, 10, 30}, + DictWord{143, 10, 132}, + DictWord{132, 10, 200}, + DictWord{4, 11, 111}, + DictWord{135, 11, 302}, + DictWord{9, 0, 197}, + DictWord{ + 10, + 0, + 300, + }, + DictWord{12, 0, 473}, + DictWord{13, 0, 90}, + DictWord{141, 0, 405}, + DictWord{132, 11, 767}, + DictWord{6, 11, 42}, + DictWord{7, 11, 1416}, + DictWord{ + 7, + 11, + 1590, + }, + DictWord{7, 11, 2005}, + DictWord{8, 11, 131}, + DictWord{8, 11, 466}, + DictWord{9, 11, 672}, + DictWord{13, 11, 252}, + DictWord{148, 11, 103}, + DictWord{ + 8, + 0, + 958, + }, + DictWord{8, 0, 999}, + DictWord{10, 0, 963}, + DictWord{138, 0, 1001}, + DictWord{135, 10, 1621}, + DictWord{135, 0, 858}, + DictWord{4, 0, 606}, + DictWord{ + 137, + 11, + 444, + }, + DictWord{6, 11, 44}, + DictWord{136, 11, 368}, + DictWord{139, 11, 172}, + DictWord{4, 11, 570}, + DictWord{133, 11, 120}, + DictWord{139, 11, 624}, + DictWord{7, 0, 1978}, + DictWord{8, 0, 676}, + DictWord{6, 10, 225}, + DictWord{137, 10, 211}, + DictWord{7, 0, 972}, + DictWord{11, 0, 102}, + DictWord{136, 10, 687}, + DictWord{6, 11, 227}, + DictWord{135, 11, 1589}, + DictWord{8, 10, 58}, + DictWord{9, 10, 724}, + DictWord{11, 10, 809}, + DictWord{13, 10, 113}, + DictWord{ + 145, + 10, + 72, + }, + DictWord{4, 0, 361}, + DictWord{133, 0, 315}, + DictWord{132, 0, 461}, + DictWord{6, 10, 345}, + DictWord{135, 10, 1247}, + DictWord{132, 0, 472}, + DictWord{ + 8, + 10, + 767, + }, + DictWord{8, 10, 803}, + DictWord{9, 10, 301}, + DictWord{137, 10, 903}, + DictWord{135, 11, 1333}, + DictWord{135, 11, 477}, + DictWord{7, 10, 1949}, + DictWord{136, 10, 674}, + DictWord{6, 0, 905}, + DictWord{138, 0, 747}, + DictWord{133, 0, 155}, + DictWord{134, 10, 259}, + DictWord{7, 0, 163}, + DictWord{8, 0, 319}, + DictWord{9, 0, 402}, + DictWord{10, 0, 24}, + DictWord{10, 0, 681}, + DictWord{11, 0, 200}, + DictWord{12, 0, 253}, + DictWord{12, 0, 410}, + DictWord{142, 0, 219}, + DictWord{ + 5, + 0, + 475, + }, + DictWord{7, 0, 1780}, + DictWord{9, 0, 230}, + DictWord{11, 0, 297}, + DictWord{11, 0, 558}, + DictWord{14, 0, 322}, + DictWord{19, 0, 76}, + DictWord{6, 11, 1667}, + DictWord{7, 11, 2036}, + DictWord{138, 11, 600}, + DictWord{136, 10, 254}, + DictWord{6, 0, 848}, + DictWord{135, 0, 1956}, + DictWord{6, 11, 511}, + DictWord{ + 140, + 11, + 132, + }, + DictWord{5, 11, 568}, + DictWord{6, 11, 138}, + DictWord{135, 11, 1293}, + DictWord{6, 0, 631}, + DictWord{137, 0, 838}, + DictWord{149, 0, 36}, + DictWord{ + 4, + 11, + 565, + }, + DictWord{8, 11, 23}, + DictWord{136, 11, 827}, + DictWord{5, 0, 944}, + DictWord{134, 0, 1769}, + DictWord{4, 0, 144}, + DictWord{6, 0, 842}, + DictWord{ + 6, + 0, + 1400, + }, + DictWord{4, 11, 922}, + DictWord{133, 11, 1023}, + DictWord{133, 10, 248}, + DictWord{9, 10, 800}, + DictWord{10, 10, 693}, + DictWord{11, 10, 482}, + DictWord{11, 10, 734}, + DictWord{139, 10, 789}, + DictWord{7, 11, 1002}, + DictWord{139, 11, 145}, + DictWord{4, 10, 116}, + DictWord{5, 10, 95}, + DictWord{5, 10, 445}, + DictWord{7, 10, 1688}, + DictWord{8, 10, 29}, + DictWord{9, 10, 272}, + DictWord{11, 10, 509}, + DictWord{139, 10, 915}, + DictWord{14, 0, 369}, + DictWord{146, 0, 72}, + DictWord{135, 10, 1641}, + DictWord{132, 11, 740}, + DictWord{133, 10, 543}, + DictWord{140, 11, 116}, + DictWord{6, 0, 247}, + DictWord{9, 0, 555}, + DictWord{ + 5, + 10, + 181, + }, + DictWord{136, 10, 41}, + DictWord{133, 10, 657}, + DictWord{136, 0, 996}, + DictWord{138, 10, 709}, + DictWord{7, 0, 189}, + DictWord{8, 10, 202}, + DictWord{ + 138, + 10, + 536, + }, + DictWord{136, 11, 402}, + DictWord{4, 11, 716}, + DictWord{141, 11, 31}, + DictWord{10, 0, 280}, + DictWord{138, 0, 797}, + DictWord{9, 10, 423}, + DictWord{140, 10, 89}, + DictWord{8, 10, 113}, + DictWord{9, 10, 877}, + DictWord{10, 10, 554}, + DictWord{11, 10, 83}, + DictWord{12, 10, 136}, + DictWord{147, 10, 109}, + DictWord{133, 10, 976}, + DictWord{7, 0, 746}, + DictWord{132, 10, 206}, + DictWord{136, 0, 526}, + DictWord{139, 0, 345}, + DictWord{136, 0, 1017}, + DictWord{ + 8, + 11, + 152, + }, + DictWord{9, 11, 53}, + DictWord{9, 11, 268}, + DictWord{9, 11, 901}, + DictWord{10, 11, 518}, + DictWord{10, 11, 829}, + DictWord{11, 11, 188}, + DictWord{ + 13, + 11, + 74, + }, + DictWord{14, 11, 46}, + DictWord{15, 11, 17}, + DictWord{15, 11, 33}, + DictWord{17, 11, 40}, + DictWord{18, 11, 36}, + DictWord{19, 11, 20}, + DictWord{22, 11, 1}, + DictWord{152, 11, 2}, + DictWord{133, 11, 736}, + DictWord{136, 11, 532}, + DictWord{5, 0, 428}, + DictWord{138, 0, 651}, + DictWord{135, 11, 681}, + DictWord{ + 135, + 0, + 1162, + }, + DictWord{7, 0, 327}, + DictWord{13, 0, 230}, + DictWord{17, 0, 113}, + DictWord{8, 10, 226}, + DictWord{10, 10, 537}, + DictWord{11, 10, 570}, + DictWord{ + 11, + 10, + 605, + }, + DictWord{11, 10, 799}, + DictWord{11, 10, 804}, + DictWord{12, 10, 85}, + DictWord{12, 10, 516}, + DictWord{12, 10, 623}, + DictWord{12, 11, 677}, + DictWord{ + 13, + 10, + 361, + }, + DictWord{14, 10, 77}, + DictWord{14, 10, 78}, + DictWord{147, 10, 110}, + DictWord{4, 0, 792}, + DictWord{7, 0, 1717}, + DictWord{10, 0, 546}, + DictWord{ + 132, + 10, + 769, + }, + DictWord{4, 11, 684}, + DictWord{136, 11, 384}, + DictWord{132, 10, 551}, + DictWord{134, 0, 1203}, + DictWord{9, 10, 57}, + DictWord{9, 10, 459}, + DictWord{10, 10, 425}, + DictWord{11, 10, 119}, + DictWord{12, 10, 184}, + DictWord{12, 10, 371}, + DictWord{13, 10, 358}, + DictWord{145, 10, 51}, + DictWord{5, 0, 672}, + DictWord{5, 10, 814}, + DictWord{8, 10, 10}, + DictWord{9, 10, 421}, + DictWord{9, 10, 729}, + DictWord{10, 10, 609}, + DictWord{139, 10, 689}, + DictWord{138, 0, 189}, + DictWord{134, 10, 624}, + DictWord{7, 11, 110}, + DictWord{7, 11, 188}, + DictWord{8, 11, 290}, + DictWord{8, 11, 591}, + DictWord{9, 11, 382}, + DictWord{9, 11, 649}, + DictWord{11, 11, 71}, + DictWord{11, 11, 155}, + DictWord{11, 11, 313}, + DictWord{12, 11, 5}, + DictWord{13, 11, 325}, + DictWord{142, 11, 287}, + DictWord{133, 0, 99}, + DictWord{6, 0, 1053}, + DictWord{135, 0, 298}, + DictWord{7, 11, 360}, + DictWord{7, 11, 425}, + DictWord{9, 11, 66}, + DictWord{9, 11, 278}, + DictWord{138, 11, 644}, + DictWord{4, 0, 397}, + DictWord{136, 0, 555}, + DictWord{137, 10, 269}, + DictWord{132, 10, 528}, + DictWord{4, 11, 900}, + DictWord{133, 11, 861}, + DictWord{ + 6, + 0, + 1157, + }, + DictWord{5, 11, 254}, + DictWord{7, 11, 985}, + DictWord{136, 11, 73}, + DictWord{7, 11, 1959}, + DictWord{136, 11, 683}, + DictWord{12, 0, 398}, + DictWord{ + 20, + 0, + 39, + }, + DictWord{21, 0, 11}, + DictWord{150, 0, 41}, + DictWord{4, 0, 485}, + DictWord{7, 0, 353}, + DictWord{135, 0, 1523}, + DictWord{6, 0, 366}, + DictWord{7, 0, 1384}, + DictWord{135, 0, 1601}, + DictWord{138, 0, 787}, + DictWord{137, 0, 282}, + DictWord{5, 10, 104}, + DictWord{6, 10, 173}, + DictWord{135, 10, 1631}, + DictWord{ + 139, + 11, + 146, + }, + DictWord{4, 0, 157}, + DictWord{133, 0, 471}, + DictWord{134, 0, 941}, + DictWord{132, 11, 725}, + DictWord{7, 0, 1336}, + DictWord{8, 10, 138}, + DictWord{ + 8, + 10, + 342, + }, + DictWord{9, 10, 84}, + DictWord{10, 10, 193}, + DictWord{11, 10, 883}, + DictWord{140, 10, 359}, + DictWord{134, 11, 196}, + DictWord{136, 0, 116}, + DictWord{133, 11, 831}, + DictWord{134, 0, 787}, + DictWord{134, 10, 95}, + DictWord{6, 10, 406}, + DictWord{10, 10, 409}, + DictWord{10, 10, 447}, + DictWord{ + 11, + 10, + 44, + }, + DictWord{140, 10, 100}, + DictWord{5, 0, 160}, + DictWord{7, 0, 363}, + DictWord{7, 0, 589}, + DictWord{10, 0, 170}, + DictWord{141, 0, 55}, + DictWord{134, 0, 1815}, + DictWord{132, 0, 866}, + DictWord{6, 0, 889}, + DictWord{6, 0, 1067}, + DictWord{6, 0, 1183}, + DictWord{4, 11, 321}, + DictWord{134, 11, 569}, + DictWord{5, 11, 848}, + DictWord{134, 11, 66}, + DictWord{4, 11, 36}, + DictWord{6, 10, 1636}, + DictWord{7, 11, 1387}, + DictWord{10, 11, 205}, + DictWord{11, 11, 755}, + DictWord{ + 141, + 11, + 271, + }, + DictWord{132, 0, 689}, + DictWord{9, 0, 820}, + DictWord{4, 10, 282}, + DictWord{7, 10, 1034}, + DictWord{11, 10, 398}, + DictWord{11, 10, 634}, + DictWord{ + 12, + 10, + 1, + }, + DictWord{12, 10, 79}, + DictWord{12, 10, 544}, + DictWord{14, 10, 237}, + DictWord{17, 10, 10}, + DictWord{146, 10, 20}, + DictWord{4, 0, 108}, + DictWord{7, 0, 804}, + DictWord{139, 0, 498}, + DictWord{132, 11, 887}, + DictWord{6, 0, 1119}, + DictWord{135, 11, 620}, + DictWord{6, 11, 165}, + DictWord{138, 11, 388}, + DictWord{ + 5, + 0, + 244, + }, + DictWord{5, 10, 499}, + DictWord{6, 10, 476}, + DictWord{7, 10, 600}, + DictWord{7, 10, 888}, + DictWord{135, 10, 1096}, + DictWord{140, 0, 609}, + DictWord{ + 135, + 0, + 1005, + }, + DictWord{4, 0, 412}, + DictWord{133, 0, 581}, + DictWord{4, 11, 719}, + DictWord{135, 11, 155}, + DictWord{7, 10, 296}, + DictWord{7, 10, 596}, + DictWord{ + 8, + 10, + 560, + }, + DictWord{8, 10, 586}, + DictWord{9, 10, 612}, + DictWord{11, 10, 304}, + DictWord{12, 10, 46}, + DictWord{13, 10, 89}, + DictWord{14, 10, 112}, + DictWord{ + 145, + 10, + 122, + }, + DictWord{4, 0, 895}, + DictWord{133, 0, 772}, + DictWord{142, 11, 307}, + DictWord{135, 0, 1898}, + DictWord{4, 0, 926}, + DictWord{133, 0, 983}, + DictWord{4, 11, 353}, + DictWord{6, 11, 146}, + DictWord{6, 11, 1789}, + DictWord{7, 11, 288}, + DictWord{7, 11, 990}, + DictWord{7, 11, 1348}, + DictWord{9, 11, 665}, + DictWord{ + 9, + 11, + 898, + }, + DictWord{11, 11, 893}, + DictWord{142, 11, 212}, + DictWord{132, 0, 538}, + DictWord{133, 11, 532}, + DictWord{6, 0, 294}, + DictWord{7, 0, 1267}, + DictWord{8, 0, 624}, + DictWord{141, 0, 496}, + DictWord{7, 0, 1325}, + DictWord{4, 11, 45}, + DictWord{135, 11, 1257}, + DictWord{138, 0, 301}, + DictWord{9, 0, 298}, + DictWord{12, 0, 291}, + DictWord{13, 0, 276}, + DictWord{14, 0, 6}, + DictWord{17, 0, 18}, + DictWord{21, 0, 32}, + DictWord{7, 10, 1599}, + DictWord{7, 10, 1723}, + DictWord{ + 8, + 10, + 79, + }, + DictWord{8, 10, 106}, + DictWord{8, 10, 190}, + DictWord{8, 10, 302}, + DictWord{8, 10, 383}, + DictWord{8, 10, 713}, + DictWord{9, 10, 119}, + DictWord{9, 10, 233}, + DictWord{9, 10, 419}, + DictWord{9, 10, 471}, + DictWord{10, 10, 181}, + DictWord{10, 10, 406}, + DictWord{11, 10, 57}, + DictWord{11, 10, 85}, + DictWord{11, 10, 120}, + DictWord{11, 10, 177}, + DictWord{11, 10, 296}, + DictWord{11, 10, 382}, + DictWord{11, 10, 454}, + DictWord{11, 10, 758}, + DictWord{11, 10, 999}, + DictWord{ + 12, + 10, + 27, + }, + DictWord{12, 10, 131}, + DictWord{12, 10, 245}, + DictWord{12, 10, 312}, + DictWord{12, 10, 446}, + DictWord{12, 10, 454}, + DictWord{13, 10, 98}, + DictWord{ + 13, + 10, + 426, + }, + DictWord{13, 10, 508}, + DictWord{14, 10, 163}, + DictWord{14, 10, 272}, + DictWord{14, 10, 277}, + DictWord{14, 10, 370}, + DictWord{15, 10, 95}, + DictWord{15, 10, 138}, + DictWord{15, 10, 167}, + DictWord{17, 10, 38}, + DictWord{148, 10, 96}, + DictWord{132, 0, 757}, + DictWord{134, 0, 1263}, + DictWord{4, 0, 820}, + DictWord{134, 10, 1759}, + DictWord{133, 0, 722}, + DictWord{136, 11, 816}, + DictWord{138, 10, 372}, + DictWord{145, 10, 16}, + DictWord{134, 0, 1039}, + DictWord{ + 4, + 0, + 991, + }, + DictWord{134, 0, 2028}, + DictWord{133, 10, 258}, + DictWord{7, 0, 1875}, + DictWord{139, 0, 124}, + DictWord{6, 11, 559}, + DictWord{6, 11, 1691}, + DictWord{135, 11, 586}, + DictWord{5, 0, 324}, + DictWord{7, 0, 881}, + DictWord{8, 10, 134}, + DictWord{9, 10, 788}, + DictWord{140, 10, 438}, + DictWord{7, 11, 1823}, + DictWord{139, 11, 693}, + DictWord{6, 0, 1348}, + DictWord{134, 0, 1545}, + DictWord{134, 0, 911}, + DictWord{132, 0, 954}, + DictWord{8, 0, 329}, + DictWord{8, 0, 414}, + DictWord{7, 10, 1948}, + DictWord{135, 10, 2004}, + DictWord{5, 0, 517}, + DictWord{6, 10, 439}, + DictWord{7, 10, 780}, + DictWord{135, 10, 1040}, + DictWord{ + 132, + 0, + 816, + }, + DictWord{5, 10, 1}, + DictWord{6, 10, 81}, + DictWord{138, 10, 520}, + DictWord{9, 0, 713}, + DictWord{10, 0, 222}, + DictWord{5, 10, 482}, + DictWord{8, 10, 98}, + DictWord{10, 10, 700}, + DictWord{10, 10, 822}, + DictWord{11, 10, 302}, + DictWord{11, 10, 778}, + DictWord{12, 10, 50}, + DictWord{12, 10, 127}, + DictWord{12, 10, 396}, + DictWord{13, 10, 62}, + DictWord{13, 10, 328}, + DictWord{14, 10, 122}, + DictWord{147, 10, 72}, + DictWord{137, 0, 33}, + DictWord{5, 10, 2}, + DictWord{7, 10, 1494}, + DictWord{136, 10, 589}, + DictWord{6, 10, 512}, + DictWord{7, 10, 797}, + DictWord{8, 10, 253}, + DictWord{9, 10, 77}, + DictWord{10, 10, 1}, + DictWord{10, 11, 108}, + DictWord{10, 10, 129}, + DictWord{10, 10, 225}, + DictWord{11, 11, 116}, + DictWord{11, 10, 118}, + DictWord{11, 10, 226}, + DictWord{11, 10, 251}, + DictWord{ + 11, + 10, + 430, + }, + DictWord{11, 10, 701}, + DictWord{11, 10, 974}, + DictWord{11, 10, 982}, + DictWord{12, 10, 64}, + DictWord{12, 10, 260}, + DictWord{12, 10, 488}, + DictWord{ + 140, + 10, + 690, + }, + DictWord{134, 11, 456}, + DictWord{133, 11, 925}, + DictWord{5, 0, 150}, + DictWord{7, 0, 106}, + DictWord{7, 0, 774}, + DictWord{8, 0, 603}, + DictWord{ + 9, + 0, + 593, + }, + DictWord{9, 0, 634}, + DictWord{10, 0, 44}, + DictWord{10, 0, 173}, + DictWord{11, 0, 462}, + DictWord{11, 0, 515}, + DictWord{13, 0, 216}, + DictWord{13, 0, 288}, + DictWord{142, 0, 400}, + DictWord{137, 10, 347}, + DictWord{5, 0, 748}, + DictWord{134, 0, 553}, + DictWord{12, 0, 108}, + DictWord{141, 0, 291}, + DictWord{7, 0, 420}, + DictWord{4, 10, 12}, + DictWord{7, 10, 522}, + DictWord{7, 10, 809}, + DictWord{8, 10, 797}, + DictWord{141, 10, 88}, + DictWord{6, 11, 193}, + DictWord{7, 11, 240}, + DictWord{ + 7, + 11, + 1682, + }, + DictWord{10, 11, 51}, + DictWord{10, 11, 640}, + DictWord{11, 11, 410}, + DictWord{13, 11, 82}, + DictWord{14, 11, 247}, + DictWord{14, 11, 331}, + DictWord{142, 11, 377}, + DictWord{133, 10, 528}, + DictWord{135, 0, 1777}, + DictWord{4, 0, 493}, + DictWord{144, 0, 55}, + DictWord{136, 11, 633}, + DictWord{ + 139, + 0, + 81, + }, + DictWord{6, 0, 980}, + DictWord{136, 0, 321}, + DictWord{148, 10, 109}, + DictWord{5, 10, 266}, + DictWord{9, 10, 290}, + DictWord{9, 10, 364}, + DictWord{ + 10, + 10, + 293, + }, + DictWord{11, 10, 606}, + DictWord{142, 10, 45}, + DictWord{6, 0, 568}, + DictWord{7, 0, 112}, + DictWord{7, 0, 1804}, + DictWord{8, 0, 362}, + DictWord{8, 0, 410}, + DictWord{8, 0, 830}, + DictWord{9, 0, 514}, + DictWord{11, 0, 649}, + DictWord{142, 0, 157}, + DictWord{4, 0, 74}, + DictWord{6, 0, 510}, + DictWord{6, 10, 594}, + DictWord{ + 9, + 10, + 121, + }, + DictWord{10, 10, 49}, + DictWord{10, 10, 412}, + DictWord{139, 10, 834}, + DictWord{134, 0, 838}, + DictWord{136, 10, 748}, + DictWord{132, 10, 466}, + DictWord{132, 0, 625}, + DictWord{135, 11, 1443}, + DictWord{4, 11, 237}, + DictWord{135, 11, 514}, + DictWord{9, 10, 378}, + DictWord{141, 10, 162}, + DictWord{6, 0, 16}, + DictWord{6, 0, 158}, + DictWord{7, 0, 43}, + DictWord{7, 0, 129}, + DictWord{7, 0, 181}, + DictWord{8, 0, 276}, + DictWord{8, 0, 377}, + DictWord{10, 0, 523}, + DictWord{ + 11, + 0, + 816, + }, + DictWord{12, 0, 455}, + DictWord{13, 0, 303}, + DictWord{142, 0, 135}, + DictWord{135, 0, 281}, + DictWord{4, 0, 1}, + DictWord{7, 0, 1143}, + DictWord{7, 0, 1463}, + DictWord{8, 0, 61}, + DictWord{9, 0, 207}, + DictWord{9, 0, 390}, + DictWord{9, 0, 467}, + DictWord{139, 0, 836}, + DictWord{6, 11, 392}, + DictWord{7, 11, 65}, + DictWord{ + 135, + 11, + 2019, + }, + DictWord{132, 10, 667}, + DictWord{4, 0, 723}, + DictWord{5, 0, 895}, + DictWord{7, 0, 1031}, + DictWord{8, 0, 199}, + DictWord{8, 0, 340}, + DictWord{9, 0, 153}, + DictWord{9, 0, 215}, + DictWord{10, 0, 21}, + DictWord{10, 0, 59}, + DictWord{10, 0, 80}, + DictWord{10, 0, 224}, + DictWord{10, 0, 838}, + DictWord{11, 0, 229}, + DictWord{ + 11, + 0, + 652, + }, + DictWord{12, 0, 192}, + DictWord{13, 0, 146}, + DictWord{142, 0, 91}, + DictWord{132, 0, 295}, + DictWord{137, 0, 51}, + DictWord{9, 11, 222}, + DictWord{ + 10, + 11, + 43, + }, + DictWord{139, 11, 900}, + DictWord{5, 0, 309}, + DictWord{140, 0, 211}, + DictWord{5, 0, 125}, + DictWord{8, 0, 77}, + DictWord{138, 0, 15}, + DictWord{136, 11, 604}, + DictWord{138, 0, 789}, + DictWord{5, 0, 173}, + DictWord{4, 10, 39}, + DictWord{7, 10, 1843}, + DictWord{8, 10, 407}, + DictWord{11, 10, 144}, + DictWord{140, 10, 523}, + DictWord{138, 11, 265}, + DictWord{133, 0, 439}, + DictWord{132, 10, 510}, + DictWord{7, 0, 648}, + DictWord{7, 0, 874}, + DictWord{11, 0, 164}, + DictWord{12, 0, 76}, + DictWord{18, 0, 9}, + DictWord{7, 10, 1980}, + DictWord{10, 10, 487}, + DictWord{138, 10, 809}, + DictWord{12, 0, 111}, + DictWord{14, 0, 294}, + DictWord{19, 0, 45}, + DictWord{13, 10, 260}, + DictWord{146, 10, 63}, + DictWord{133, 11, 549}, + DictWord{134, 10, 570}, + DictWord{4, 0, 8}, + DictWord{7, 0, 1152}, + DictWord{7, 0, 1153}, + DictWord{7, 0, 1715}, + DictWord{9, 0, 374}, + DictWord{10, 0, 478}, + DictWord{139, 0, 648}, + DictWord{135, 0, 1099}, + DictWord{5, 0, 575}, + DictWord{6, 0, 354}, + DictWord{ + 135, + 0, + 701, + }, + DictWord{7, 11, 36}, + DictWord{8, 11, 201}, + DictWord{136, 11, 605}, + DictWord{4, 10, 787}, + DictWord{136, 11, 156}, + DictWord{6, 0, 518}, + DictWord{ + 149, + 11, + 13, + }, + DictWord{140, 11, 224}, + DictWord{134, 0, 702}, + DictWord{132, 10, 516}, + DictWord{5, 11, 724}, + DictWord{10, 11, 305}, + DictWord{11, 11, 151}, + DictWord{12, 11, 33}, + DictWord{12, 11, 121}, + DictWord{12, 11, 381}, + DictWord{17, 11, 3}, + DictWord{17, 11, 27}, + DictWord{17, 11, 78}, + DictWord{18, 11, 18}, + DictWord{19, 11, 54}, + DictWord{149, 11, 5}, + DictWord{8, 0, 87}, + DictWord{4, 11, 523}, + DictWord{5, 11, 638}, + DictWord{11, 10, 887}, + DictWord{14, 10, 365}, + DictWord{ + 142, + 10, + 375, + }, + DictWord{138, 0, 438}, + DictWord{136, 10, 821}, + DictWord{135, 11, 1908}, + DictWord{6, 11, 242}, + DictWord{7, 11, 227}, + DictWord{7, 11, 1581}, + DictWord{8, 11, 104}, + DictWord{9, 11, 113}, + DictWord{9, 11, 220}, + DictWord{9, 11, 427}, + DictWord{10, 11, 74}, + DictWord{10, 11, 239}, + DictWord{11, 11, 579}, + DictWord{11, 11, 1023}, + DictWord{13, 11, 4}, + DictWord{13, 11, 204}, + DictWord{13, 11, 316}, + DictWord{18, 11, 95}, + DictWord{148, 11, 86}, + DictWord{4, 0, 69}, + DictWord{5, 0, 122}, + DictWord{5, 0, 849}, + DictWord{6, 0, 1633}, + DictWord{9, 0, 656}, + DictWord{138, 0, 464}, + DictWord{7, 0, 1802}, + DictWord{4, 10, 10}, + DictWord{ + 139, + 10, + 786, + }, + DictWord{135, 11, 861}, + DictWord{139, 0, 499}, + DictWord{7, 0, 476}, + DictWord{7, 0, 1592}, + DictWord{138, 0, 87}, + DictWord{133, 10, 684}, + DictWord{ + 4, + 0, + 840, + }, + DictWord{134, 10, 27}, + DictWord{142, 0, 283}, + DictWord{6, 0, 1620}, + DictWord{7, 11, 1328}, + DictWord{136, 11, 494}, + DictWord{5, 0, 859}, + DictWord{ + 7, + 0, + 1160, + }, + DictWord{8, 0, 107}, + DictWord{9, 0, 291}, + DictWord{9, 0, 439}, + DictWord{10, 0, 663}, + DictWord{11, 0, 609}, + DictWord{140, 0, 197}, + DictWord{ + 7, + 11, + 1306, + }, + DictWord{8, 11, 505}, + DictWord{9, 11, 482}, + DictWord{10, 11, 126}, + DictWord{11, 11, 225}, + DictWord{12, 11, 347}, + DictWord{12, 11, 449}, + DictWord{ + 13, + 11, + 19, + }, + DictWord{142, 11, 218}, + DictWord{5, 11, 268}, + DictWord{10, 11, 764}, + DictWord{12, 11, 120}, + DictWord{13, 11, 39}, + DictWord{145, 11, 127}, + DictWord{145, 10, 56}, + DictWord{7, 11, 1672}, + DictWord{10, 11, 472}, + DictWord{11, 11, 189}, + DictWord{143, 11, 51}, + DictWord{6, 10, 342}, + DictWord{6, 10, 496}, + DictWord{8, 10, 275}, + DictWord{137, 10, 206}, + DictWord{133, 0, 600}, + DictWord{4, 0, 117}, + DictWord{6, 0, 372}, + DictWord{7, 0, 1905}, + DictWord{142, 0, 323}, + DictWord{4, 10, 909}, + DictWord{5, 10, 940}, + DictWord{135, 11, 1471}, + DictWord{132, 10, 891}, + DictWord{4, 0, 722}, + DictWord{139, 0, 471}, + DictWord{4, 11, 384}, + DictWord{135, 11, 1022}, + DictWord{132, 10, 687}, + DictWord{9, 0, 5}, + DictWord{12, 0, 216}, + DictWord{12, 0, 294}, + DictWord{12, 0, 298}, + DictWord{12, 0, 400}, + DictWord{12, 0, 518}, + DictWord{13, 0, 229}, + DictWord{143, 0, 139}, + DictWord{135, 11, 1703}, + DictWord{7, 11, 1602}, + DictWord{10, 11, 698}, + DictWord{ + 12, + 11, + 212, + }, + DictWord{141, 11, 307}, + DictWord{6, 10, 41}, + DictWord{141, 10, 160}, + DictWord{135, 11, 1077}, + DictWord{9, 11, 159}, + DictWord{11, 11, 28}, + DictWord{140, 11, 603}, + DictWord{4, 0, 514}, + DictWord{7, 0, 1304}, + DictWord{138, 0, 477}, + DictWord{134, 0, 1774}, + DictWord{9, 0, 88}, + DictWord{139, 0, 270}, + DictWord{5, 0, 12}, + DictWord{7, 0, 375}, + DictWord{9, 0, 438}, + DictWord{134, 10, 1718}, + DictWord{132, 11, 515}, + DictWord{136, 10, 778}, + DictWord{8, 11, 632}, + DictWord{8, 11, 697}, + DictWord{137, 11, 854}, + DictWord{6, 0, 362}, + DictWord{6, 0, 997}, + DictWord{146, 0, 51}, + DictWord{7, 0, 816}, + DictWord{7, 0, 1241}, + DictWord{ + 9, + 0, + 283, + }, + DictWord{9, 0, 520}, + DictWord{10, 0, 213}, + DictWord{10, 0, 307}, + DictWord{10, 0, 463}, + DictWord{10, 0, 671}, + DictWord{10, 0, 746}, + DictWord{11, 0, 401}, + DictWord{11, 0, 794}, + DictWord{12, 0, 517}, + DictWord{18, 0, 107}, + DictWord{147, 0, 115}, + DictWord{133, 10, 115}, + DictWord{150, 11, 28}, + DictWord{4, 11, 136}, + DictWord{133, 11, 551}, + DictWord{142, 10, 314}, + DictWord{132, 0, 258}, + DictWord{6, 0, 22}, + DictWord{7, 0, 903}, + DictWord{7, 0, 1963}, + DictWord{8, 0, 639}, + DictWord{138, 0, 577}, + DictWord{5, 0, 681}, + DictWord{8, 0, 782}, + DictWord{13, 0, 130}, + DictWord{17, 0, 84}, + DictWord{5, 10, 193}, + DictWord{140, 10, 178}, + DictWord{ + 9, + 11, + 17, + }, + DictWord{138, 11, 291}, + DictWord{7, 11, 1287}, + DictWord{9, 11, 44}, + DictWord{10, 11, 552}, + DictWord{10, 11, 642}, + DictWord{11, 11, 839}, + DictWord{12, 11, 274}, + DictWord{12, 11, 275}, + DictWord{12, 11, 372}, + DictWord{13, 11, 91}, + DictWord{142, 11, 125}, + DictWord{135, 10, 174}, + DictWord{4, 0, 664}, + DictWord{5, 0, 804}, + DictWord{139, 0, 1013}, + DictWord{134, 0, 942}, + DictWord{6, 0, 1349}, + DictWord{6, 0, 1353}, + DictWord{6, 0, 1450}, + DictWord{7, 11, 1518}, + DictWord{139, 11, 694}, + DictWord{11, 0, 356}, + DictWord{4, 10, 122}, + DictWord{5, 10, 796}, + DictWord{5, 10, 952}, + DictWord{6, 10, 1660}, + DictWord{ + 6, + 10, + 1671, + }, + DictWord{8, 10, 567}, + DictWord{9, 10, 687}, + DictWord{9, 10, 742}, + DictWord{10, 10, 686}, + DictWord{11, 10, 682}, + DictWord{140, 10, 281}, + DictWord{ + 5, + 0, + 32, + }, + DictWord{6, 11, 147}, + DictWord{7, 11, 886}, + DictWord{9, 11, 753}, + DictWord{138, 11, 268}, + DictWord{5, 10, 179}, + DictWord{7, 10, 1095}, + DictWord{ + 135, + 10, + 1213, + }, + DictWord{4, 10, 66}, + DictWord{7, 10, 722}, + DictWord{135, 10, 904}, + DictWord{135, 10, 352}, + DictWord{9, 11, 245}, + DictWord{138, 11, 137}, + DictWord{4, 0, 289}, + DictWord{7, 0, 629}, + DictWord{7, 0, 1698}, + DictWord{7, 0, 1711}, + DictWord{12, 0, 215}, + DictWord{133, 11, 414}, + DictWord{6, 0, 1975}, + DictWord{135, 11, 1762}, + DictWord{6, 0, 450}, + DictWord{136, 0, 109}, + DictWord{141, 10, 35}, + DictWord{134, 11, 599}, + DictWord{136, 0, 705}, + DictWord{ + 133, + 0, + 664, + }, + DictWord{134, 11, 1749}, + DictWord{11, 11, 402}, + DictWord{12, 11, 109}, + DictWord{12, 11, 431}, + DictWord{13, 11, 179}, + DictWord{13, 11, 206}, + DictWord{14, 11, 175}, + DictWord{14, 11, 217}, + DictWord{16, 11, 3}, + DictWord{148, 11, 53}, + DictWord{135, 0, 1238}, + DictWord{134, 11, 1627}, + DictWord{ + 132, + 11, + 488, + }, + DictWord{13, 0, 318}, + DictWord{10, 10, 592}, + DictWord{10, 10, 753}, + DictWord{12, 10, 317}, + DictWord{12, 10, 355}, + DictWord{12, 10, 465}, + DictWord{ + 12, + 10, + 469, + }, + DictWord{12, 10, 560}, + DictWord{140, 10, 578}, + DictWord{133, 10, 564}, + DictWord{132, 11, 83}, + DictWord{140, 11, 676}, + DictWord{6, 0, 1872}, + DictWord{6, 0, 1906}, + DictWord{6, 0, 1907}, + DictWord{9, 0, 934}, + DictWord{9, 0, 956}, + DictWord{9, 0, 960}, + DictWord{9, 0, 996}, + DictWord{12, 0, 794}, + DictWord{ + 12, + 0, + 876, + }, + DictWord{12, 0, 880}, + DictWord{12, 0, 918}, + DictWord{15, 0, 230}, + DictWord{18, 0, 234}, + DictWord{18, 0, 238}, + DictWord{21, 0, 38}, + DictWord{149, 0, 62}, + DictWord{134, 10, 556}, + DictWord{134, 11, 278}, + DictWord{137, 0, 103}, + DictWord{7, 10, 544}, + DictWord{8, 10, 719}, + DictWord{138, 10, 61}, + DictWord{ + 4, + 10, + 5, + }, + DictWord{5, 10, 498}, + DictWord{8, 10, 637}, + DictWord{137, 10, 521}, + DictWord{7, 0, 777}, + DictWord{12, 0, 229}, + DictWord{12, 0, 239}, + DictWord{15, 0, 12}, + DictWord{12, 11, 229}, + DictWord{12, 11, 239}, + DictWord{143, 11, 12}, + DictWord{6, 0, 26}, + DictWord{7, 11, 388}, + DictWord{7, 11, 644}, + DictWord{139, 11, 781}, + DictWord{7, 11, 229}, + DictWord{8, 11, 59}, + DictWord{9, 11, 190}, + DictWord{9, 11, 257}, + DictWord{10, 11, 378}, + DictWord{140, 11, 191}, + DictWord{133, 10, 927}, + DictWord{135, 10, 1441}, + DictWord{4, 10, 893}, + DictWord{5, 10, 780}, + DictWord{133, 10, 893}, + DictWord{4, 0, 414}, + DictWord{5, 0, 467}, + DictWord{9, 0, 654}, + DictWord{10, 0, 451}, + DictWord{12, 0, 59}, + DictWord{141, 0, 375}, + DictWord{142, 0, 173}, + DictWord{135, 0, 17}, + DictWord{7, 0, 1350}, + DictWord{133, 10, 238}, + DictWord{135, 0, 955}, + DictWord{4, 0, 960}, + DictWord{10, 0, 887}, + DictWord{12, 0, 753}, + DictWord{18, 0, 161}, + DictWord{18, 0, 162}, + DictWord{152, 0, 19}, + DictWord{136, 11, 344}, + DictWord{6, 10, 1729}, + DictWord{137, 11, 288}, + DictWord{132, 11, 660}, + DictWord{4, 0, 217}, + DictWord{5, 0, 710}, + DictWord{7, 0, 760}, + DictWord{7, 0, 1926}, + DictWord{9, 0, 428}, + DictWord{9, 0, 708}, + DictWord{10, 0, 254}, + DictWord{10, 0, 296}, + DictWord{10, 0, 720}, + DictWord{11, 0, 109}, + DictWord{ + 11, + 0, + 255, + }, + DictWord{12, 0, 165}, + DictWord{12, 0, 315}, + DictWord{13, 0, 107}, + DictWord{13, 0, 203}, + DictWord{14, 0, 54}, + DictWord{14, 0, 99}, + DictWord{14, 0, 114}, + DictWord{14, 0, 388}, + DictWord{16, 0, 85}, + DictWord{17, 0, 9}, + DictWord{17, 0, 33}, + DictWord{20, 0, 25}, + DictWord{20, 0, 28}, + DictWord{20, 0, 29}, + DictWord{21, 0, 9}, + DictWord{21, 0, 10}, + DictWord{21, 0, 34}, + DictWord{22, 0, 17}, + DictWord{4, 10, 60}, + DictWord{7, 10, 1800}, + DictWord{8, 10, 314}, + DictWord{9, 10, 700}, + DictWord{ + 139, + 10, + 487, + }, + DictWord{7, 11, 1035}, + DictWord{138, 11, 737}, + DictWord{7, 11, 690}, + DictWord{9, 11, 217}, + DictWord{9, 11, 587}, + DictWord{140, 11, 521}, + DictWord{6, 0, 919}, + DictWord{7, 11, 706}, + DictWord{7, 11, 1058}, + DictWord{138, 11, 538}, + DictWord{7, 10, 1853}, + DictWord{138, 10, 437}, + DictWord{ + 136, + 10, + 419, + }, + DictWord{6, 0, 280}, + DictWord{10, 0, 502}, + DictWord{11, 0, 344}, + DictWord{140, 0, 38}, + DictWord{5, 0, 45}, + DictWord{7, 0, 1161}, + DictWord{11, 0, 448}, + DictWord{11, 0, 880}, + DictWord{13, 0, 139}, + DictWord{13, 0, 407}, + DictWord{15, 0, 16}, + DictWord{17, 0, 95}, + DictWord{18, 0, 66}, + DictWord{18, 0, 88}, + DictWord{ + 18, + 0, + 123, + }, + DictWord{149, 0, 7}, + DictWord{11, 11, 92}, + DictWord{11, 11, 196}, + DictWord{11, 11, 409}, + DictWord{11, 11, 450}, + DictWord{11, 11, 666}, + DictWord{ + 11, + 11, + 777, + }, + DictWord{12, 11, 262}, + DictWord{13, 11, 385}, + DictWord{13, 11, 393}, + DictWord{15, 11, 115}, + DictWord{16, 11, 45}, + DictWord{145, 11, 82}, + DictWord{136, 0, 777}, + DictWord{134, 11, 1744}, + DictWord{4, 0, 410}, + DictWord{7, 0, 521}, + DictWord{133, 10, 828}, + DictWord{134, 0, 673}, + DictWord{7, 0, 1110}, + DictWord{7, 0, 1778}, + DictWord{7, 10, 176}, + DictWord{135, 10, 178}, + DictWord{5, 10, 806}, + DictWord{7, 11, 268}, + DictWord{7, 10, 1976}, + DictWord{ + 136, + 11, + 569, + }, + DictWord{4, 11, 733}, + DictWord{9, 11, 194}, + DictWord{10, 11, 92}, + DictWord{11, 11, 198}, + DictWord{12, 11, 84}, + DictWord{12, 11, 87}, + DictWord{ + 13, + 11, + 128, + }, + DictWord{144, 11, 74}, + DictWord{5, 0, 341}, + DictWord{7, 0, 1129}, + DictWord{11, 0, 414}, + DictWord{4, 10, 51}, + DictWord{6, 10, 4}, + DictWord{7, 10, 591}, + DictWord{7, 10, 849}, + DictWord{7, 10, 951}, + DictWord{7, 10, 1613}, + DictWord{7, 10, 1760}, + DictWord{7, 10, 1988}, + DictWord{9, 10, 434}, + DictWord{10, 10, 754}, + DictWord{11, 10, 25}, + DictWord{139, 10, 37}, + DictWord{133, 10, 902}, + DictWord{135, 10, 928}, + DictWord{135, 0, 787}, + DictWord{132, 0, 436}, + DictWord{ + 134, + 10, + 270, + }, + DictWord{7, 0, 1587}, + DictWord{135, 0, 1707}, + DictWord{6, 0, 377}, + DictWord{7, 0, 1025}, + DictWord{9, 0, 613}, + DictWord{145, 0, 104}, + DictWord{ + 7, + 11, + 982, + }, + DictWord{7, 11, 1361}, + DictWord{10, 11, 32}, + DictWord{143, 11, 56}, + DictWord{139, 0, 96}, + DictWord{132, 0, 451}, + DictWord{132, 10, 416}, + DictWord{ + 142, + 10, + 372, + }, + DictWord{5, 10, 152}, + DictWord{5, 10, 197}, + DictWord{7, 11, 306}, + DictWord{7, 10, 340}, + DictWord{7, 10, 867}, + DictWord{10, 10, 548}, + DictWord{ + 10, + 10, + 581, + }, + DictWord{11, 10, 6}, + DictWord{12, 10, 3}, + DictWord{12, 10, 19}, + DictWord{14, 10, 110}, + DictWord{142, 10, 289}, + DictWord{134, 0, 680}, + DictWord{ + 134, + 11, + 609, + }, + DictWord{7, 0, 483}, + DictWord{7, 10, 190}, + DictWord{8, 10, 28}, + DictWord{8, 10, 141}, + DictWord{8, 10, 444}, + DictWord{8, 10, 811}, + DictWord{ + 9, + 10, + 468, + }, + DictWord{11, 10, 334}, + DictWord{12, 10, 24}, + DictWord{12, 10, 386}, + DictWord{140, 10, 576}, + DictWord{10, 0, 916}, + DictWord{133, 10, 757}, + DictWord{ + 5, + 10, + 721, + }, + DictWord{135, 10, 1553}, + DictWord{133, 11, 178}, + DictWord{134, 0, 937}, + DictWord{132, 10, 898}, + DictWord{133, 0, 739}, + DictWord{ + 147, + 0, + 82, + }, + DictWord{135, 0, 663}, + DictWord{146, 0, 128}, + DictWord{5, 10, 277}, + DictWord{141, 10, 247}, + DictWord{134, 0, 1087}, + DictWord{132, 10, 435}, + DictWord{ + 6, + 11, + 381, + }, + DictWord{7, 11, 645}, + DictWord{7, 11, 694}, + DictWord{136, 11, 546}, + DictWord{7, 0, 503}, + DictWord{135, 0, 1885}, + DictWord{6, 0, 1965}, + DictWord{ + 8, + 0, + 925, + }, + DictWord{138, 0, 955}, + DictWord{4, 0, 113}, + DictWord{5, 0, 163}, + DictWord{5, 0, 735}, + DictWord{7, 0, 1009}, + DictWord{9, 0, 9}, + DictWord{9, 0, 771}, + DictWord{12, 0, 90}, + DictWord{13, 0, 138}, + DictWord{13, 0, 410}, + DictWord{143, 0, 128}, + DictWord{4, 0, 324}, + DictWord{138, 0, 104}, + DictWord{7, 0, 460}, + DictWord{ + 5, + 10, + 265, + }, + DictWord{134, 10, 212}, + DictWord{133, 11, 105}, + DictWord{7, 11, 261}, + DictWord{7, 11, 1107}, + DictWord{7, 11, 1115}, + DictWord{7, 11, 1354}, + DictWord{7, 11, 1588}, + DictWord{7, 11, 1705}, + DictWord{7, 11, 1902}, + DictWord{9, 11, 465}, + DictWord{10, 11, 248}, + DictWord{10, 11, 349}, + DictWord{10, 11, 647}, + DictWord{11, 11, 527}, + DictWord{11, 11, 660}, + DictWord{11, 11, 669}, + DictWord{12, 11, 529}, + DictWord{141, 11, 305}, + DictWord{5, 11, 438}, + DictWord{ + 9, + 11, + 694, + }, + DictWord{12, 11, 627}, + DictWord{141, 11, 210}, + DictWord{152, 11, 11}, + DictWord{4, 0, 935}, + DictWord{133, 0, 823}, + DictWord{132, 10, 702}, + DictWord{ + 5, + 0, + 269, + }, + DictWord{7, 0, 434}, + DictWord{7, 0, 891}, + DictWord{8, 0, 339}, + DictWord{9, 0, 702}, + DictWord{11, 0, 594}, + DictWord{11, 0, 718}, + DictWord{17, 0, 100}, + DictWord{5, 10, 808}, + DictWord{135, 10, 2045}, + DictWord{7, 0, 1014}, + DictWord{9, 0, 485}, + DictWord{141, 0, 264}, + DictWord{134, 0, 1713}, + DictWord{7, 0, 1810}, + DictWord{11, 0, 866}, + DictWord{12, 0, 103}, + DictWord{13, 0, 495}, + DictWord{140, 11, 233}, + DictWord{4, 0, 423}, + DictWord{10, 0, 949}, + DictWord{138, 0, 1013}, + DictWord{135, 0, 900}, + DictWord{8, 11, 25}, + DictWord{138, 11, 826}, + DictWord{5, 10, 166}, + DictWord{8, 10, 739}, + DictWord{140, 10, 511}, + DictWord{ + 134, + 0, + 2018, + }, + DictWord{7, 11, 1270}, + DictWord{139, 11, 612}, + DictWord{4, 10, 119}, + DictWord{5, 10, 170}, + DictWord{5, 10, 447}, + DictWord{7, 10, 1708}, + DictWord{ + 7, + 10, + 1889, + }, + DictWord{9, 10, 357}, + DictWord{9, 10, 719}, + DictWord{12, 10, 486}, + DictWord{140, 10, 596}, + DictWord{12, 0, 574}, + DictWord{140, 11, 574}, + DictWord{132, 11, 308}, + DictWord{6, 0, 964}, + DictWord{6, 0, 1206}, + DictWord{134, 0, 1302}, + DictWord{4, 10, 450}, + DictWord{135, 10, 1158}, + DictWord{ + 135, + 11, + 150, + }, + DictWord{136, 11, 649}, + DictWord{14, 0, 213}, + DictWord{148, 0, 38}, + DictWord{9, 11, 45}, + DictWord{9, 11, 311}, + DictWord{141, 11, 42}, + DictWord{ + 134, + 11, + 521, + }, + DictWord{7, 10, 1375}, + DictWord{7, 10, 1466}, + DictWord{138, 10, 331}, + DictWord{132, 10, 754}, + DictWord{5, 11, 339}, + DictWord{7, 11, 1442}, + DictWord{14, 11, 3}, + DictWord{15, 11, 41}, + DictWord{147, 11, 66}, + DictWord{136, 11, 378}, + DictWord{134, 0, 1022}, + DictWord{5, 10, 850}, + DictWord{136, 10, 799}, + DictWord{142, 0, 143}, + DictWord{135, 0, 2029}, + DictWord{134, 11, 1628}, + DictWord{8, 0, 523}, + DictWord{150, 0, 34}, + DictWord{5, 0, 625}, + DictWord{ + 135, + 0, + 1617, + }, + DictWord{7, 0, 275}, + DictWord{7, 10, 238}, + DictWord{7, 10, 2033}, + DictWord{8, 10, 120}, + DictWord{8, 10, 188}, + DictWord{8, 10, 659}, + DictWord{ + 9, + 10, + 598, + }, + DictWord{10, 10, 466}, + DictWord{12, 10, 342}, + DictWord{12, 10, 588}, + DictWord{13, 10, 503}, + DictWord{14, 10, 246}, + DictWord{143, 10, 92}, + DictWord{ + 7, + 0, + 37, + }, + DictWord{8, 0, 425}, + DictWord{8, 0, 693}, + DictWord{9, 0, 720}, + DictWord{10, 0, 380}, + DictWord{10, 0, 638}, + DictWord{11, 0, 273}, + DictWord{11, 0, 473}, + DictWord{12, 0, 61}, + DictWord{143, 0, 43}, + DictWord{135, 11, 829}, + DictWord{135, 0, 1943}, + DictWord{132, 0, 765}, + DictWord{5, 11, 486}, + DictWord{ + 135, + 11, + 1349, + }, + DictWord{7, 11, 1635}, + DictWord{8, 11, 17}, + DictWord{10, 11, 217}, + DictWord{138, 11, 295}, + DictWord{4, 10, 201}, + DictWord{7, 10, 1744}, + DictWord{ + 8, + 10, + 602, + }, + DictWord{11, 10, 247}, + DictWord{11, 10, 826}, + DictWord{145, 10, 65}, + DictWord{138, 11, 558}, + DictWord{11, 0, 551}, + DictWord{142, 0, 159}, + DictWord{8, 10, 164}, + DictWord{146, 10, 62}, + DictWord{139, 11, 176}, + DictWord{132, 0, 168}, + DictWord{136, 0, 1010}, + DictWord{134, 0, 1994}, + DictWord{ + 135, + 0, + 91, + }, + DictWord{138, 0, 532}, + DictWord{135, 10, 1243}, + DictWord{135, 0, 1884}, + DictWord{132, 10, 907}, + DictWord{5, 10, 100}, + DictWord{10, 10, 329}, + DictWord{12, 10, 416}, + DictWord{149, 10, 29}, + DictWord{134, 11, 447}, + DictWord{132, 10, 176}, + DictWord{5, 10, 636}, + DictWord{5, 10, 998}, + DictWord{7, 10, 9}, + DictWord{7, 10, 1508}, + DictWord{8, 10, 26}, + DictWord{9, 10, 317}, + DictWord{9, 10, 358}, + DictWord{10, 10, 210}, + DictWord{10, 10, 292}, + DictWord{10, 10, 533}, + DictWord{11, 10, 555}, + DictWord{12, 10, 526}, + DictWord{12, 10, 607}, + DictWord{13, 10, 263}, + DictWord{13, 10, 459}, + DictWord{142, 10, 271}, + DictWord{ + 4, + 11, + 609, + }, + DictWord{135, 11, 756}, + DictWord{6, 0, 15}, + DictWord{7, 0, 70}, + DictWord{10, 0, 240}, + DictWord{147, 0, 93}, + DictWord{4, 11, 930}, + DictWord{133, 11, 947}, + DictWord{134, 0, 1227}, + DictWord{134, 0, 1534}, + DictWord{133, 11, 939}, + DictWord{133, 11, 962}, + DictWord{5, 11, 651}, + DictWord{8, 11, 170}, + DictWord{ + 9, + 11, + 61, + }, + DictWord{9, 11, 63}, + DictWord{10, 11, 23}, + DictWord{10, 11, 37}, + DictWord{10, 11, 834}, + DictWord{11, 11, 4}, + DictWord{11, 11, 187}, + DictWord{ + 11, + 11, + 281, + }, + DictWord{11, 11, 503}, + DictWord{11, 11, 677}, + DictWord{12, 11, 96}, + DictWord{12, 11, 130}, + DictWord{12, 11, 244}, + DictWord{14, 11, 5}, + DictWord{ + 14, + 11, + 40, + }, + DictWord{14, 11, 162}, + DictWord{14, 11, 202}, + DictWord{146, 11, 133}, + DictWord{4, 11, 406}, + DictWord{5, 11, 579}, + DictWord{12, 11, 492}, + DictWord{ + 150, + 11, + 15, + }, + DictWord{139, 0, 392}, + DictWord{6, 10, 610}, + DictWord{10, 10, 127}, + DictWord{141, 10, 27}, + DictWord{7, 0, 655}, + DictWord{7, 0, 1844}, + DictWord{ + 136, + 10, + 119, + }, + DictWord{4, 0, 145}, + DictWord{6, 0, 176}, + DictWord{7, 0, 395}, + DictWord{137, 0, 562}, + DictWord{132, 0, 501}, + DictWord{140, 11, 145}, + DictWord{ + 136, + 0, + 1019, + }, + DictWord{134, 0, 509}, + DictWord{139, 0, 267}, + DictWord{6, 11, 17}, + DictWord{7, 11, 16}, + DictWord{7, 11, 1001}, + DictWord{7, 11, 1982}, + DictWord{ + 9, + 11, + 886, + }, + DictWord{10, 11, 489}, + DictWord{10, 11, 800}, + DictWord{11, 11, 782}, + DictWord{12, 11, 320}, + DictWord{13, 11, 467}, + DictWord{14, 11, 145}, + DictWord{14, 11, 387}, + DictWord{143, 11, 119}, + DictWord{145, 11, 17}, + DictWord{6, 0, 1099}, + DictWord{133, 11, 458}, + DictWord{7, 11, 1983}, + DictWord{8, 11, 0}, + DictWord{8, 11, 171}, + DictWord{9, 11, 120}, + DictWord{9, 11, 732}, + DictWord{10, 11, 473}, + DictWord{11, 11, 656}, + DictWord{11, 11, 998}, + DictWord{18, 11, 0}, + DictWord{18, 11, 2}, + DictWord{147, 11, 21}, + DictWord{12, 11, 427}, + DictWord{146, 11, 38}, + DictWord{10, 0, 948}, + DictWord{138, 0, 968}, + DictWord{7, 10, 126}, + DictWord{136, 10, 84}, + DictWord{136, 10, 790}, + DictWord{4, 0, 114}, + DictWord{9, 0, 492}, + DictWord{13, 0, 462}, + DictWord{142, 0, 215}, + DictWord{6, 10, 64}, + DictWord{12, 10, 377}, + DictWord{141, 10, 309}, + DictWord{4, 0, 77}, + DictWord{5, 0, 361}, + DictWord{6, 0, 139}, + DictWord{6, 0, 401}, + DictWord{6, 0, 404}, + DictWord{ + 7, + 0, + 413, + }, + DictWord{7, 0, 715}, + DictWord{7, 0, 1716}, + DictWord{11, 0, 279}, + DictWord{12, 0, 179}, + DictWord{12, 0, 258}, + DictWord{13, 0, 244}, + DictWord{142, 0, 358}, + DictWord{134, 0, 1717}, + DictWord{7, 0, 772}, + DictWord{7, 0, 1061}, + DictWord{7, 0, 1647}, + DictWord{8, 0, 82}, + DictWord{11, 0, 250}, + DictWord{11, 0, 607}, + DictWord{12, 0, 311}, + DictWord{12, 0, 420}, + DictWord{13, 0, 184}, + DictWord{13, 0, 367}, + DictWord{7, 10, 1104}, + DictWord{11, 10, 269}, + DictWord{11, 10, 539}, + DictWord{11, 10, 627}, + DictWord{11, 10, 706}, + DictWord{11, 10, 975}, + DictWord{12, 10, 248}, + DictWord{12, 10, 434}, + DictWord{12, 10, 600}, + DictWord{ + 12, + 10, + 622, + }, + DictWord{13, 10, 297}, + DictWord{13, 10, 485}, + DictWord{14, 10, 69}, + DictWord{14, 10, 409}, + DictWord{143, 10, 108}, + DictWord{135, 0, 724}, + DictWord{ + 4, + 11, + 512, + }, + DictWord{4, 11, 519}, + DictWord{133, 11, 342}, + DictWord{134, 0, 1133}, + DictWord{145, 11, 29}, + DictWord{11, 10, 977}, + DictWord{141, 10, 507}, + DictWord{6, 0, 841}, + DictWord{6, 0, 1042}, + DictWord{6, 0, 1194}, + DictWord{10, 0, 993}, + DictWord{140, 0, 1021}, + DictWord{6, 11, 31}, + DictWord{7, 11, 491}, + DictWord{7, 11, 530}, + DictWord{8, 11, 592}, + DictWord{9, 10, 34}, + DictWord{11, 11, 53}, + DictWord{11, 10, 484}, + DictWord{11, 11, 779}, + DictWord{12, 11, 167}, + DictWord{12, 11, 411}, + DictWord{14, 11, 14}, + DictWord{14, 11, 136}, + DictWord{15, 11, 72}, + DictWord{16, 11, 17}, + DictWord{144, 11, 72}, + DictWord{4, 0, 1021}, + DictWord{6, 0, 2037}, + DictWord{133, 11, 907}, + DictWord{7, 0, 373}, + DictWord{8, 0, 335}, + DictWord{8, 0, 596}, + DictWord{9, 0, 488}, + DictWord{6, 10, 1700}, + DictWord{ + 7, + 10, + 293, + }, + DictWord{7, 10, 382}, + DictWord{7, 10, 1026}, + DictWord{7, 10, 1087}, + DictWord{7, 10, 2027}, + DictWord{8, 10, 252}, + DictWord{8, 10, 727}, + DictWord{ + 8, + 10, + 729, + }, + DictWord{9, 10, 30}, + DictWord{9, 10, 199}, + DictWord{9, 10, 231}, + DictWord{9, 10, 251}, + DictWord{9, 10, 334}, + DictWord{9, 10, 361}, + DictWord{9, 10, 712}, + DictWord{10, 10, 55}, + DictWord{10, 10, 60}, + DictWord{10, 10, 232}, + DictWord{10, 10, 332}, + DictWord{10, 10, 384}, + DictWord{10, 10, 396}, + DictWord{ + 10, + 10, + 504, + }, + DictWord{10, 10, 542}, + DictWord{10, 10, 652}, + DictWord{11, 10, 20}, + DictWord{11, 10, 48}, + DictWord{11, 10, 207}, + DictWord{11, 10, 291}, + DictWord{ + 11, + 10, + 298, + }, + DictWord{11, 10, 342}, + DictWord{11, 10, 365}, + DictWord{11, 10, 394}, + DictWord{11, 10, 620}, + DictWord{11, 10, 705}, + DictWord{11, 10, 1017}, + DictWord{12, 10, 123}, + DictWord{12, 10, 340}, + DictWord{12, 10, 406}, + DictWord{12, 10, 643}, + DictWord{13, 10, 61}, + DictWord{13, 10, 269}, + DictWord{ + 13, + 10, + 311, + }, + DictWord{13, 10, 319}, + DictWord{13, 10, 486}, + DictWord{14, 10, 234}, + DictWord{15, 10, 62}, + DictWord{15, 10, 85}, + DictWord{16, 10, 71}, + DictWord{ + 18, + 10, + 119, + }, + DictWord{148, 10, 105}, + DictWord{150, 0, 37}, + DictWord{4, 11, 208}, + DictWord{5, 11, 106}, + DictWord{6, 11, 531}, + DictWord{8, 11, 408}, + DictWord{ + 9, + 11, + 188, + }, + DictWord{138, 11, 572}, + DictWord{132, 0, 564}, + DictWord{6, 0, 513}, + DictWord{135, 0, 1052}, + DictWord{132, 0, 825}, + DictWord{9, 0, 899}, + DictWord{ + 140, + 11, + 441, + }, + DictWord{134, 0, 778}, + DictWord{133, 11, 379}, + DictWord{7, 0, 1417}, + DictWord{12, 0, 382}, + DictWord{17, 0, 48}, + DictWord{152, 0, 12}, + DictWord{ + 132, + 11, + 241, + }, + DictWord{7, 0, 1116}, + DictWord{6, 10, 379}, + DictWord{7, 10, 270}, + DictWord{8, 10, 176}, + DictWord{8, 10, 183}, + DictWord{9, 10, 432}, + DictWord{ + 9, + 10, + 661, + }, + DictWord{12, 10, 247}, + DictWord{12, 10, 617}, + DictWord{146, 10, 125}, + DictWord{5, 10, 792}, + DictWord{133, 10, 900}, + DictWord{6, 0, 545}, + DictWord{ + 7, + 0, + 565, + }, + DictWord{7, 0, 1669}, + DictWord{10, 0, 114}, + DictWord{11, 0, 642}, + DictWord{140, 0, 618}, + DictWord{133, 0, 5}, + DictWord{138, 11, 7}, + DictWord{ + 132, + 11, + 259, + }, + DictWord{135, 0, 192}, + DictWord{134, 0, 701}, + DictWord{136, 0, 763}, + DictWord{135, 10, 1979}, + DictWord{4, 10, 901}, + DictWord{133, 10, 776}, + DictWord{10, 0, 755}, + DictWord{147, 0, 29}, + DictWord{133, 0, 759}, + DictWord{4, 11, 173}, + DictWord{5, 11, 312}, + DictWord{5, 11, 512}, + DictWord{135, 11, 1285}, + DictWord{7, 11, 1603}, + DictWord{7, 11, 1691}, + DictWord{9, 11, 464}, + DictWord{11, 11, 195}, + DictWord{12, 11, 279}, + DictWord{12, 11, 448}, + DictWord{ + 14, + 11, + 11, + }, + DictWord{147, 11, 102}, + DictWord{7, 0, 370}, + DictWord{7, 0, 1007}, + DictWord{7, 0, 1177}, + DictWord{135, 0, 1565}, + DictWord{135, 0, 1237}, + DictWord{ + 4, + 0, + 87, + }, + DictWord{5, 0, 250}, + DictWord{141, 0, 298}, + DictWord{4, 11, 452}, + DictWord{5, 11, 583}, + DictWord{5, 11, 817}, + DictWord{6, 11, 433}, + DictWord{7, 11, 593}, + DictWord{7, 11, 720}, + DictWord{7, 11, 1378}, + DictWord{8, 11, 161}, + DictWord{9, 11, 284}, + DictWord{10, 11, 313}, + DictWord{139, 11, 886}, + DictWord{4, 11, 547}, + DictWord{135, 11, 1409}, + DictWord{136, 11, 722}, + DictWord{4, 10, 37}, + DictWord{5, 10, 334}, + DictWord{135, 10, 1253}, + DictWord{132, 10, 508}, + DictWord{ + 12, + 0, + 107, + }, + DictWord{146, 0, 31}, + DictWord{8, 11, 420}, + DictWord{139, 11, 193}, + DictWord{135, 0, 814}, + DictWord{135, 11, 409}, + DictWord{140, 0, 991}, + DictWord{4, 0, 57}, + DictWord{7, 0, 1195}, + DictWord{7, 0, 1438}, + DictWord{7, 0, 1548}, + DictWord{7, 0, 1835}, + DictWord{7, 0, 1904}, + DictWord{9, 0, 757}, + DictWord{ + 10, + 0, + 604, + }, + DictWord{139, 0, 519}, + DictWord{132, 0, 540}, + DictWord{138, 11, 308}, + DictWord{132, 10, 533}, + DictWord{136, 0, 608}, + DictWord{144, 11, 65}, + DictWord{4, 0, 1014}, + DictWord{134, 0, 2029}, + DictWord{4, 0, 209}, + DictWord{7, 0, 902}, + DictWord{5, 11, 1002}, + DictWord{136, 11, 745}, + DictWord{134, 0, 2030}, + DictWord{6, 0, 303}, + DictWord{7, 0, 335}, + DictWord{7, 0, 1437}, + DictWord{7, 0, 1668}, + DictWord{8, 0, 553}, + DictWord{8, 0, 652}, + DictWord{8, 0, 656}, + DictWord{ + 9, + 0, + 558, + }, + DictWord{11, 0, 743}, + DictWord{149, 0, 18}, + DictWord{5, 11, 575}, + DictWord{6, 11, 354}, + DictWord{135, 11, 701}, + DictWord{4, 11, 239}, + DictWord{ + 6, + 11, + 477, + }, + DictWord{7, 11, 1607}, + DictWord{11, 11, 68}, + DictWord{139, 11, 617}, + DictWord{132, 0, 559}, + DictWord{8, 0, 527}, + DictWord{18, 0, 60}, + DictWord{ + 147, + 0, + 24, + }, + DictWord{133, 10, 920}, + DictWord{138, 0, 511}, + DictWord{133, 0, 1017}, + DictWord{133, 0, 675}, + DictWord{138, 10, 391}, + DictWord{11, 0, 156}, + DictWord{135, 10, 1952}, + DictWord{138, 11, 369}, + DictWord{132, 11, 367}, + DictWord{133, 0, 709}, + DictWord{6, 0, 698}, + DictWord{134, 0, 887}, + DictWord{ + 142, + 10, + 126, + }, + DictWord{134, 0, 1745}, + DictWord{132, 10, 483}, + DictWord{13, 11, 299}, + DictWord{142, 11, 75}, + DictWord{133, 0, 714}, + DictWord{7, 0, 8}, + DictWord{ + 136, + 0, + 206, + }, + DictWord{138, 10, 480}, + DictWord{4, 11, 694}, + DictWord{9, 10, 495}, + DictWord{146, 10, 104}, + DictWord{7, 11, 1248}, + DictWord{11, 11, 621}, + DictWord{139, 11, 702}, + DictWord{140, 11, 687}, + DictWord{132, 0, 776}, + DictWord{139, 10, 1009}, + DictWord{135, 0, 1272}, + DictWord{134, 0, 1059}, + DictWord{ + 8, + 10, + 653, + }, + DictWord{13, 10, 93}, + DictWord{147, 10, 14}, + DictWord{135, 11, 213}, + DictWord{136, 0, 406}, + DictWord{133, 10, 172}, + DictWord{132, 0, 947}, + DictWord{8, 0, 175}, + DictWord{10, 0, 168}, + DictWord{138, 0, 573}, + DictWord{132, 0, 870}, + DictWord{6, 0, 1567}, + DictWord{151, 11, 28}, + DictWord{ + 134, + 11, + 472, + }, + DictWord{5, 10, 260}, + DictWord{136, 11, 132}, + DictWord{4, 11, 751}, + DictWord{11, 11, 390}, + DictWord{140, 11, 32}, + DictWord{4, 11, 409}, + DictWord{ + 133, + 11, + 78, + }, + DictWord{12, 0, 554}, + DictWord{6, 11, 473}, + DictWord{145, 11, 105}, + DictWord{133, 0, 784}, + DictWord{8, 0, 908}, + DictWord{136, 11, 306}, + DictWord{139, 0, 882}, + DictWord{6, 0, 358}, + DictWord{7, 0, 1393}, + DictWord{8, 0, 396}, + DictWord{10, 0, 263}, + DictWord{14, 0, 154}, + DictWord{16, 0, 48}, + DictWord{ + 17, + 0, + 8, + }, + DictWord{7, 11, 1759}, + DictWord{8, 11, 396}, + DictWord{10, 11, 263}, + DictWord{14, 11, 154}, + DictWord{16, 11, 48}, + DictWord{145, 11, 8}, + DictWord{ + 13, + 11, + 163, + }, + DictWord{13, 11, 180}, + DictWord{18, 11, 78}, + DictWord{148, 11, 35}, + DictWord{14, 0, 32}, + DictWord{18, 0, 85}, + DictWord{20, 0, 2}, + DictWord{152, 0, 16}, + DictWord{7, 0, 228}, + DictWord{10, 0, 770}, + DictWord{8, 10, 167}, + DictWord{8, 10, 375}, + DictWord{9, 10, 82}, + DictWord{9, 10, 561}, + DictWord{138, 10, 620}, + DictWord{132, 0, 845}, + DictWord{9, 0, 14}, + DictWord{9, 0, 441}, + DictWord{10, 0, 306}, + DictWord{139, 0, 9}, + DictWord{11, 0, 966}, + DictWord{12, 0, 287}, + DictWord{ + 13, + 0, + 342, + }, + DictWord{13, 0, 402}, + DictWord{15, 0, 110}, + DictWord{15, 0, 163}, + DictWord{8, 10, 194}, + DictWord{136, 10, 756}, + DictWord{134, 0, 1578}, + DictWord{ + 4, + 0, + 967, + }, + DictWord{6, 0, 1820}, + DictWord{6, 0, 1847}, + DictWord{140, 0, 716}, + DictWord{136, 0, 594}, + DictWord{7, 0, 1428}, + DictWord{7, 0, 1640}, + DictWord{ + 7, + 0, + 1867, + }, + DictWord{9, 0, 169}, + DictWord{9, 0, 182}, + DictWord{9, 0, 367}, + DictWord{9, 0, 478}, + DictWord{9, 0, 506}, + DictWord{9, 0, 551}, + DictWord{9, 0, 557}, + DictWord{ + 9, + 0, + 648, + }, + DictWord{9, 0, 697}, + DictWord{9, 0, 705}, + DictWord{9, 0, 725}, + DictWord{9, 0, 787}, + DictWord{9, 0, 794}, + DictWord{10, 0, 198}, + DictWord{10, 0, 214}, + DictWord{10, 0, 267}, + DictWord{10, 0, 275}, + DictWord{10, 0, 456}, + DictWord{10, 0, 551}, + DictWord{10, 0, 561}, + DictWord{10, 0, 613}, + DictWord{10, 0, 627}, + DictWord{ + 10, + 0, + 668, + }, + DictWord{10, 0, 675}, + DictWord{10, 0, 691}, + DictWord{10, 0, 695}, + DictWord{10, 0, 707}, + DictWord{10, 0, 715}, + DictWord{11, 0, 183}, + DictWord{ + 11, + 0, + 201, + }, + DictWord{11, 0, 244}, + DictWord{11, 0, 262}, + DictWord{11, 0, 352}, + DictWord{11, 0, 439}, + DictWord{11, 0, 493}, + DictWord{11, 0, 572}, + DictWord{11, 0, 591}, + DictWord{11, 0, 608}, + DictWord{11, 0, 611}, + DictWord{11, 0, 646}, + DictWord{11, 0, 674}, + DictWord{11, 0, 711}, + DictWord{11, 0, 751}, + DictWord{11, 0, 761}, + DictWord{11, 0, 776}, + DictWord{11, 0, 785}, + DictWord{11, 0, 850}, + DictWord{11, 0, 853}, + DictWord{11, 0, 862}, + DictWord{11, 0, 865}, + DictWord{11, 0, 868}, + DictWord{ + 11, + 0, + 875, + }, + DictWord{11, 0, 898}, + DictWord{11, 0, 902}, + DictWord{11, 0, 903}, + DictWord{11, 0, 910}, + DictWord{11, 0, 932}, + DictWord{11, 0, 942}, + DictWord{ + 11, + 0, + 957, + }, + DictWord{11, 0, 967}, + DictWord{11, 0, 972}, + DictWord{12, 0, 148}, + DictWord{12, 0, 195}, + DictWord{12, 0, 220}, + DictWord{12, 0, 237}, + DictWord{12, 0, 318}, + DictWord{12, 0, 339}, + DictWord{12, 0, 393}, + DictWord{12, 0, 445}, + DictWord{12, 0, 450}, + DictWord{12, 0, 474}, + DictWord{12, 0, 505}, + DictWord{12, 0, 509}, + DictWord{12, 0, 533}, + DictWord{12, 0, 591}, + DictWord{12, 0, 594}, + DictWord{12, 0, 597}, + DictWord{12, 0, 621}, + DictWord{12, 0, 633}, + DictWord{12, 0, 642}, + DictWord{ + 13, + 0, + 59, + }, + DictWord{13, 0, 60}, + DictWord{13, 0, 145}, + DictWord{13, 0, 239}, + DictWord{13, 0, 250}, + DictWord{13, 0, 329}, + DictWord{13, 0, 344}, + DictWord{13, 0, 365}, + DictWord{13, 0, 372}, + DictWord{13, 0, 387}, + DictWord{13, 0, 403}, + DictWord{13, 0, 414}, + DictWord{13, 0, 456}, + DictWord{13, 0, 470}, + DictWord{13, 0, 478}, + DictWord{13, 0, 483}, + DictWord{13, 0, 489}, + DictWord{14, 0, 55}, + DictWord{14, 0, 57}, + DictWord{14, 0, 81}, + DictWord{14, 0, 90}, + DictWord{14, 0, 148}, + DictWord{ + 14, + 0, + 239, + }, + DictWord{14, 0, 266}, + DictWord{14, 0, 321}, + DictWord{14, 0, 326}, + DictWord{14, 0, 327}, + DictWord{14, 0, 330}, + DictWord{14, 0, 347}, + DictWord{14, 0, 355}, + DictWord{14, 0, 401}, + DictWord{14, 0, 404}, + DictWord{14, 0, 411}, + DictWord{14, 0, 414}, + DictWord{14, 0, 416}, + DictWord{14, 0, 420}, + DictWord{15, 0, 61}, + DictWord{15, 0, 74}, + DictWord{15, 0, 87}, + DictWord{15, 0, 88}, + DictWord{15, 0, 94}, + DictWord{15, 0, 96}, + DictWord{15, 0, 116}, + DictWord{15, 0, 149}, + DictWord{15, 0, 154}, + DictWord{16, 0, 50}, + DictWord{16, 0, 63}, + DictWord{16, 0, 73}, + DictWord{17, 0, 2}, + DictWord{17, 0, 66}, + DictWord{17, 0, 92}, + DictWord{17, 0, 103}, + DictWord{ + 17, + 0, + 112, + }, + DictWord{17, 0, 120}, + DictWord{18, 0, 50}, + DictWord{18, 0, 54}, + DictWord{18, 0, 82}, + DictWord{18, 0, 86}, + DictWord{18, 0, 90}, + DictWord{18, 0, 111}, + DictWord{ + 18, + 0, + 115, + }, + DictWord{18, 0, 156}, + DictWord{19, 0, 40}, + DictWord{19, 0, 79}, + DictWord{20, 0, 78}, + DictWord{21, 0, 22}, + DictWord{135, 11, 883}, + DictWord{5, 0, 161}, + DictWord{135, 0, 839}, + DictWord{4, 0, 782}, + DictWord{13, 11, 293}, + DictWord{142, 11, 56}, + DictWord{133, 11, 617}, + DictWord{139, 11, 50}, + DictWord{ + 135, + 10, + 22, + }, + DictWord{145, 0, 64}, + DictWord{5, 10, 639}, + DictWord{7, 10, 1249}, + DictWord{139, 10, 896}, + DictWord{138, 0, 998}, + DictWord{135, 11, 2042}, + DictWord{ + 4, + 11, + 546, + }, + DictWord{142, 11, 233}, + DictWord{6, 0, 1043}, + DictWord{134, 0, 1574}, + DictWord{134, 0, 1496}, + DictWord{4, 10, 102}, + DictWord{7, 10, 815}, + DictWord{7, 10, 1699}, + DictWord{139, 10, 964}, + DictWord{12, 0, 781}, + DictWord{142, 0, 461}, + DictWord{4, 11, 313}, + DictWord{133, 11, 577}, + DictWord{ + 6, + 0, + 639, + }, + DictWord{6, 0, 1114}, + DictWord{137, 0, 817}, + DictWord{8, 11, 184}, + DictWord{141, 11, 433}, + DictWord{7, 0, 1814}, + DictWord{135, 11, 935}, + DictWord{ + 10, + 0, + 997, + }, + DictWord{140, 0, 958}, + DictWord{4, 0, 812}, + DictWord{137, 11, 625}, + DictWord{132, 10, 899}, + DictWord{136, 10, 795}, + DictWord{5, 11, 886}, + DictWord{6, 11, 46}, + DictWord{6, 11, 1790}, + DictWord{7, 11, 14}, + DictWord{7, 11, 732}, + DictWord{7, 11, 1654}, + DictWord{8, 11, 95}, + DictWord{8, 11, 327}, + DictWord{ + 8, + 11, + 616, + }, + DictWord{10, 11, 598}, + DictWord{10, 11, 769}, + DictWord{11, 11, 134}, + DictWord{11, 11, 747}, + DictWord{12, 11, 378}, + DictWord{142, 11, 97}, + DictWord{136, 0, 139}, + DictWord{6, 10, 52}, + DictWord{9, 10, 104}, + DictWord{9, 10, 559}, + DictWord{12, 10, 308}, + DictWord{147, 10, 87}, + DictWord{133, 11, 1021}, + DictWord{132, 10, 604}, + DictWord{132, 10, 301}, + DictWord{136, 10, 779}, + DictWord{7, 0, 643}, + DictWord{136, 0, 236}, + DictWord{132, 11, 153}, + DictWord{ + 134, + 0, + 1172, + }, + DictWord{147, 10, 32}, + DictWord{133, 11, 798}, + DictWord{6, 0, 1338}, + DictWord{132, 11, 587}, + DictWord{6, 11, 598}, + DictWord{7, 11, 42}, + DictWord{ + 8, + 11, + 695, + }, + DictWord{10, 11, 212}, + DictWord{11, 11, 158}, + DictWord{14, 11, 196}, + DictWord{145, 11, 85}, + DictWord{135, 10, 508}, + DictWord{5, 11, 957}, + DictWord{5, 11, 1008}, + DictWord{135, 11, 249}, + DictWord{4, 11, 129}, + DictWord{135, 11, 465}, + DictWord{5, 0, 54}, + DictWord{7, 11, 470}, + DictWord{7, 11, 1057}, + DictWord{7, 11, 1201}, + DictWord{9, 11, 755}, + DictWord{11, 11, 906}, + DictWord{140, 11, 527}, + DictWord{7, 11, 908}, + DictWord{146, 11, 7}, + DictWord{ + 5, + 11, + 148, + }, + DictWord{136, 11, 450}, + DictWord{144, 11, 1}, + DictWord{4, 0, 256}, + DictWord{135, 0, 1488}, + DictWord{9, 0, 351}, + DictWord{6, 10, 310}, + DictWord{ + 7, + 10, + 1849, + }, + DictWord{8, 10, 72}, + DictWord{8, 10, 272}, + DictWord{8, 10, 431}, + DictWord{9, 10, 12}, + DictWord{10, 10, 563}, + DictWord{10, 10, 630}, + DictWord{ + 10, + 10, + 796, + }, + DictWord{10, 10, 810}, + DictWord{11, 10, 367}, + DictWord{11, 10, 599}, + DictWord{11, 10, 686}, + DictWord{140, 10, 672}, + DictWord{6, 0, 1885}, + DictWord{ + 6, + 0, + 1898, + }, + DictWord{6, 0, 1899}, + DictWord{140, 0, 955}, + DictWord{4, 0, 714}, + DictWord{133, 0, 469}, + DictWord{6, 0, 1270}, + DictWord{134, 0, 1456}, + DictWord{132, 0, 744}, + DictWord{6, 0, 313}, + DictWord{7, 10, 537}, + DictWord{8, 10, 64}, + DictWord{9, 10, 127}, + DictWord{10, 10, 496}, + DictWord{12, 10, 510}, + DictWord{141, 10, 384}, + DictWord{4, 11, 217}, + DictWord{4, 10, 244}, + DictWord{5, 11, 710}, + DictWord{7, 10, 233}, + DictWord{7, 11, 1926}, + DictWord{9, 11, 428}, + DictWord{9, 11, 708}, + DictWord{10, 11, 254}, + DictWord{10, 11, 296}, + DictWord{10, 11, 720}, + DictWord{11, 11, 109}, + DictWord{11, 11, 255}, + DictWord{12, 11, 165}, + DictWord{12, 11, 315}, + DictWord{13, 11, 107}, + DictWord{13, 11, 203}, + DictWord{14, 11, 54}, + DictWord{14, 11, 99}, + DictWord{14, 11, 114}, + DictWord{ + 14, + 11, + 388, + }, + DictWord{16, 11, 85}, + DictWord{17, 11, 9}, + DictWord{17, 11, 33}, + DictWord{20, 11, 25}, + DictWord{20, 11, 28}, + DictWord{20, 11, 29}, + DictWord{21, 11, 9}, + DictWord{21, 11, 10}, + DictWord{21, 11, 34}, + DictWord{150, 11, 17}, + DictWord{138, 0, 402}, + DictWord{7, 0, 969}, + DictWord{146, 0, 55}, + DictWord{8, 0, 50}, + DictWord{ + 137, + 0, + 624, + }, + DictWord{134, 0, 1355}, + DictWord{132, 0, 572}, + DictWord{134, 10, 1650}, + DictWord{10, 10, 702}, + DictWord{139, 10, 245}, + DictWord{ + 10, + 0, + 847, + }, + DictWord{142, 0, 445}, + DictWord{6, 0, 43}, + DictWord{7, 0, 38}, + DictWord{8, 0, 248}, + DictWord{138, 0, 513}, + DictWord{133, 0, 369}, + DictWord{137, 10, 338}, + DictWord{133, 0, 766}, + DictWord{133, 0, 363}, + DictWord{133, 10, 896}, + DictWord{8, 11, 392}, + DictWord{11, 11, 54}, + DictWord{13, 11, 173}, + DictWord{ + 13, + 11, + 294, + }, + DictWord{148, 11, 7}, + DictWord{134, 0, 678}, + DictWord{7, 11, 1230}, + DictWord{136, 11, 531}, + DictWord{6, 0, 258}, + DictWord{140, 0, 409}, + DictWord{ + 5, + 0, + 249, + }, + DictWord{148, 0, 82}, + DictWord{7, 10, 1117}, + DictWord{136, 10, 539}, + DictWord{5, 0, 393}, + DictWord{6, 0, 378}, + DictWord{7, 0, 1981}, + DictWord{9, 0, 32}, + DictWord{9, 0, 591}, + DictWord{10, 0, 685}, + DictWord{10, 0, 741}, + DictWord{142, 0, 382}, + DictWord{133, 0, 788}, + DictWord{134, 0, 1281}, + DictWord{ + 134, + 0, + 1295, + }, + DictWord{7, 0, 1968}, + DictWord{141, 0, 509}, + DictWord{4, 0, 61}, + DictWord{5, 0, 58}, + DictWord{5, 0, 171}, + DictWord{5, 0, 683}, + DictWord{6, 0, 291}, + DictWord{ + 6, + 0, + 566, + }, + DictWord{7, 0, 1650}, + DictWord{11, 0, 523}, + DictWord{12, 0, 273}, + DictWord{12, 0, 303}, + DictWord{15, 0, 39}, + DictWord{143, 0, 111}, + DictWord{ + 6, + 0, + 706, + }, + DictWord{134, 0, 1283}, + DictWord{134, 0, 589}, + DictWord{135, 11, 1433}, + DictWord{133, 11, 435}, + DictWord{7, 0, 1059}, + DictWord{13, 0, 54}, + DictWord{ + 5, + 10, + 4, + }, + DictWord{5, 10, 810}, + DictWord{6, 10, 13}, + DictWord{6, 10, 538}, + DictWord{6, 10, 1690}, + DictWord{6, 10, 1726}, + DictWord{7, 10, 1819}, + DictWord{ + 8, + 10, + 148, + }, + DictWord{8, 10, 696}, + DictWord{8, 10, 791}, + DictWord{12, 10, 125}, + DictWord{143, 10, 9}, + DictWord{135, 10, 1268}, + DictWord{5, 11, 85}, + DictWord{ + 6, + 11, + 419, + }, + DictWord{7, 11, 134}, + DictWord{7, 11, 305}, + DictWord{7, 11, 361}, + DictWord{7, 11, 1337}, + DictWord{8, 11, 71}, + DictWord{140, 11, 519}, + DictWord{ + 137, + 0, + 824, + }, + DictWord{140, 11, 688}, + DictWord{5, 11, 691}, + DictWord{7, 11, 345}, + DictWord{7, 10, 1385}, + DictWord{9, 11, 94}, + DictWord{11, 10, 582}, + DictWord{ + 11, + 10, + 650, + }, + DictWord{11, 10, 901}, + DictWord{11, 10, 949}, + DictWord{12, 11, 169}, + DictWord{12, 10, 232}, + DictWord{12, 10, 236}, + DictWord{13, 10, 413}, + DictWord{13, 10, 501}, + DictWord{146, 10, 116}, + DictWord{4, 0, 917}, + DictWord{133, 0, 1005}, + DictWord{7, 0, 1598}, + DictWord{5, 11, 183}, + DictWord{6, 11, 582}, + DictWord{9, 11, 344}, + DictWord{10, 11, 679}, + DictWord{140, 11, 435}, + DictWord{4, 10, 925}, + DictWord{5, 10, 803}, + DictWord{8, 10, 698}, + DictWord{ + 138, + 10, + 828, + }, + DictWord{132, 0, 919}, + DictWord{135, 11, 511}, + DictWord{139, 10, 992}, + DictWord{4, 0, 255}, + DictWord{5, 0, 302}, + DictWord{6, 0, 132}, + DictWord{ + 7, + 0, + 128, + }, + DictWord{7, 0, 283}, + DictWord{7, 0, 1299}, + DictWord{10, 0, 52}, + DictWord{10, 0, 514}, + DictWord{11, 0, 925}, + DictWord{13, 0, 92}, + DictWord{142, 0, 309}, + DictWord{134, 0, 1369}, + DictWord{135, 10, 1847}, + DictWord{134, 0, 328}, + DictWord{7, 11, 1993}, + DictWord{136, 11, 684}, + DictWord{133, 10, 383}, + DictWord{137, 0, 173}, + DictWord{134, 11, 583}, + DictWord{134, 0, 1411}, + DictWord{19, 0, 65}, + DictWord{5, 11, 704}, + DictWord{8, 11, 357}, + DictWord{10, 11, 745}, + DictWord{14, 11, 426}, + DictWord{17, 11, 94}, + DictWord{147, 11, 57}, + DictWord{9, 10, 660}, + DictWord{138, 10, 347}, + DictWord{4, 11, 179}, + DictWord{5, 11, 198}, + DictWord{133, 11, 697}, + DictWord{7, 11, 347}, + DictWord{7, 11, 971}, + DictWord{8, 11, 181}, + DictWord{138, 11, 711}, + DictWord{141, 0, 442}, + DictWord{ + 11, + 0, + 842, + }, + DictWord{11, 0, 924}, + DictWord{13, 0, 317}, + DictWord{13, 0, 370}, + DictWord{13, 0, 469}, + DictWord{13, 0, 471}, + DictWord{14, 0, 397}, + DictWord{18, 0, 69}, + DictWord{18, 0, 145}, + DictWord{7, 10, 572}, + DictWord{9, 10, 592}, + DictWord{11, 10, 680}, + DictWord{12, 10, 356}, + DictWord{140, 10, 550}, + DictWord{14, 11, 19}, + DictWord{14, 11, 28}, + DictWord{144, 11, 29}, + DictWord{136, 0, 534}, + DictWord{4, 11, 243}, + DictWord{5, 11, 203}, + DictWord{7, 11, 19}, + DictWord{7, 11, 71}, + DictWord{7, 11, 113}, + DictWord{10, 11, 405}, + DictWord{11, 11, 357}, + DictWord{142, 11, 240}, + DictWord{6, 0, 210}, + DictWord{10, 0, 845}, + DictWord{138, 0, 862}, + DictWord{7, 11, 1351}, + DictWord{9, 11, 581}, + DictWord{10, 11, 639}, + DictWord{11, 11, 453}, + DictWord{140, 11, 584}, + DictWord{7, 11, 1450}, + DictWord{ + 139, + 11, + 99, + }, + DictWord{10, 0, 892}, + DictWord{12, 0, 719}, + DictWord{144, 0, 105}, + DictWord{4, 0, 284}, + DictWord{6, 0, 223}, + DictWord{134, 11, 492}, + DictWord{5, 11, 134}, + DictWord{6, 11, 408}, + DictWord{6, 11, 495}, + DictWord{135, 11, 1593}, + DictWord{136, 0, 529}, + DictWord{137, 0, 807}, + DictWord{4, 0, 218}, + DictWord{7, 0, 526}, + DictWord{143, 0, 137}, + DictWord{6, 0, 1444}, + DictWord{142, 11, 4}, + DictWord{132, 11, 665}, + DictWord{4, 0, 270}, + DictWord{5, 0, 192}, + DictWord{6, 0, 332}, + DictWord{7, 0, 1322}, + DictWord{4, 11, 248}, + DictWord{7, 11, 137}, + DictWord{137, 11, 349}, + DictWord{140, 0, 661}, + DictWord{7, 0, 1517}, + DictWord{11, 0, 597}, + DictWord{14, 0, 76}, + DictWord{14, 0, 335}, + DictWord{20, 0, 33}, + DictWord{7, 10, 748}, + DictWord{139, 10, 700}, + DictWord{5, 11, 371}, + DictWord{135, 11, 563}, + DictWord{146, 11, 57}, + DictWord{133, 10, 127}, + DictWord{133, 0, 418}, + DictWord{4, 11, 374}, + DictWord{7, 11, 547}, + DictWord{7, 11, 1700}, + DictWord{7, 11, 1833}, + DictWord{139, 11, 858}, + DictWord{6, 10, 198}, + DictWord{140, 10, 83}, + DictWord{7, 11, 1812}, + DictWord{13, 11, 259}, + DictWord{13, 11, 356}, + DictWord{ + 14, + 11, + 242, + }, + DictWord{147, 11, 114}, + DictWord{7, 0, 379}, + DictWord{8, 0, 481}, + DictWord{9, 0, 377}, + DictWord{5, 10, 276}, + DictWord{6, 10, 55}, + DictWord{ + 135, + 10, + 1369, + }, + DictWord{138, 11, 286}, + DictWord{5, 0, 1003}, + DictWord{6, 0, 149}, + DictWord{6, 10, 1752}, + DictWord{136, 10, 726}, + DictWord{8, 0, 262}, + DictWord{ + 9, + 0, + 627, + }, + DictWord{10, 0, 18}, + DictWord{11, 0, 214}, + DictWord{11, 0, 404}, + DictWord{11, 0, 457}, + DictWord{11, 0, 780}, + DictWord{11, 0, 913}, + DictWord{13, 0, 401}, + DictWord{14, 0, 200}, + DictWord{6, 11, 1647}, + DictWord{7, 11, 1552}, + DictWord{7, 11, 2010}, + DictWord{9, 11, 494}, + DictWord{137, 11, 509}, + DictWord{ + 135, + 0, + 742, + }, + DictWord{136, 0, 304}, + DictWord{132, 0, 142}, + DictWord{133, 10, 764}, + DictWord{6, 10, 309}, + DictWord{7, 10, 331}, + DictWord{138, 10, 550}, + DictWord{135, 10, 1062}, + DictWord{6, 11, 123}, + DictWord{7, 11, 214}, + DictWord{7, 10, 986}, + DictWord{9, 11, 728}, + DictWord{10, 11, 157}, + DictWord{11, 11, 346}, + DictWord{11, 11, 662}, + DictWord{143, 11, 106}, + DictWord{135, 10, 1573}, + DictWord{7, 0, 925}, + DictWord{137, 0, 799}, + DictWord{4, 0, 471}, + DictWord{5, 0, 51}, + DictWord{6, 0, 602}, + DictWord{8, 0, 484}, + DictWord{138, 0, 195}, + DictWord{136, 0, 688}, + DictWord{132, 0, 697}, + DictWord{6, 0, 1169}, + DictWord{6, 0, 1241}, + DictWord{6, 10, 194}, + DictWord{7, 10, 133}, + DictWord{10, 10, 493}, + DictWord{10, 10, 570}, + DictWord{139, 10, 664}, + DictWord{140, 0, 751}, + DictWord{7, 0, 929}, + DictWord{10, 0, 452}, + DictWord{11, 0, 878}, + DictWord{16, 0, 33}, + DictWord{5, 10, 24}, + DictWord{5, 10, 569}, + DictWord{6, 10, 3}, + DictWord{6, 10, 119}, + DictWord{ + 6, + 10, + 143, + }, + DictWord{6, 10, 440}, + DictWord{7, 10, 599}, + DictWord{7, 10, 1686}, + DictWord{7, 10, 1854}, + DictWord{8, 10, 424}, + DictWord{9, 10, 43}, + DictWord{ + 9, + 10, + 584, + }, + DictWord{9, 10, 760}, + DictWord{10, 10, 328}, + DictWord{11, 10, 159}, + DictWord{11, 10, 253}, + DictWord{12, 10, 487}, + DictWord{140, 10, 531}, + DictWord{ + 4, + 11, + 707, + }, + DictWord{13, 11, 106}, + DictWord{18, 11, 49}, + DictWord{147, 11, 41}, + DictWord{5, 0, 221}, + DictWord{5, 11, 588}, + DictWord{134, 11, 393}, + DictWord{134, 0, 1437}, + DictWord{6, 11, 211}, + DictWord{7, 11, 1690}, + DictWord{11, 11, 486}, + DictWord{140, 11, 369}, + DictWord{5, 10, 14}, + DictWord{5, 10, 892}, + DictWord{6, 10, 283}, + DictWord{7, 10, 234}, + DictWord{136, 10, 537}, + DictWord{4, 0, 988}, + DictWord{136, 0, 955}, + DictWord{135, 0, 1251}, + DictWord{4, 10, 126}, + DictWord{8, 10, 635}, + DictWord{147, 10, 34}, + DictWord{4, 10, 316}, + DictWord{135, 10, 1561}, + DictWord{137, 10, 861}, + DictWord{4, 10, 64}, + DictWord{ + 5, + 10, + 352, + }, + DictWord{5, 10, 720}, + DictWord{6, 10, 368}, + DictWord{139, 10, 359}, + DictWord{134, 0, 192}, + DictWord{4, 0, 132}, + DictWord{5, 0, 69}, + DictWord{ + 135, + 0, + 1242, + }, + DictWord{7, 10, 1577}, + DictWord{10, 10, 304}, + DictWord{10, 10, 549}, + DictWord{12, 10, 365}, + DictWord{13, 10, 220}, + DictWord{13, 10, 240}, + DictWord{142, 10, 33}, + DictWord{4, 0, 111}, + DictWord{7, 0, 865}, + DictWord{134, 11, 219}, + DictWord{5, 11, 582}, + DictWord{6, 11, 1646}, + DictWord{7, 11, 99}, + DictWord{ + 7, + 11, + 1962, + }, + DictWord{7, 11, 1986}, + DictWord{8, 11, 515}, + DictWord{8, 11, 773}, + DictWord{9, 11, 23}, + DictWord{9, 11, 491}, + DictWord{12, 11, 620}, + DictWord{ + 14, + 11, + 52, + }, + DictWord{145, 11, 50}, + DictWord{132, 0, 767}, + DictWord{7, 11, 568}, + DictWord{148, 11, 21}, + DictWord{6, 0, 42}, + DictWord{7, 0, 1416}, + DictWord{ + 7, + 0, + 2005, + }, + DictWord{8, 0, 131}, + DictWord{8, 0, 466}, + DictWord{9, 0, 672}, + DictWord{13, 0, 252}, + DictWord{20, 0, 103}, + DictWord{133, 11, 851}, + DictWord{ + 135, + 0, + 1050, + }, + DictWord{6, 10, 175}, + DictWord{137, 10, 289}, + DictWord{5, 10, 432}, + DictWord{133, 10, 913}, + DictWord{6, 0, 44}, + DictWord{136, 0, 368}, + DictWord{ + 135, + 11, + 784, + }, + DictWord{132, 0, 570}, + DictWord{133, 0, 120}, + DictWord{139, 10, 595}, + DictWord{140, 0, 29}, + DictWord{6, 0, 227}, + DictWord{135, 0, 1589}, + DictWord{4, 11, 98}, + DictWord{7, 11, 1365}, + DictWord{9, 11, 422}, + DictWord{9, 11, 670}, + DictWord{10, 11, 775}, + DictWord{11, 11, 210}, + DictWord{13, 11, 26}, + DictWord{13, 11, 457}, + DictWord{141, 11, 476}, + DictWord{140, 10, 80}, + DictWord{5, 10, 931}, + DictWord{134, 10, 1698}, + DictWord{133, 0, 522}, + DictWord{ + 134, + 0, + 1120, + }, + DictWord{135, 0, 1529}, + DictWord{12, 0, 739}, + DictWord{14, 0, 448}, + DictWord{142, 0, 467}, + DictWord{11, 10, 526}, + DictWord{11, 10, 939}, + DictWord{141, 10, 290}, + DictWord{5, 10, 774}, + DictWord{6, 10, 1637}, + DictWord{6, 10, 1686}, + DictWord{134, 10, 1751}, + DictWord{6, 0, 1667}, + DictWord{ + 135, + 0, + 2036, + }, + DictWord{7, 10, 1167}, + DictWord{11, 10, 934}, + DictWord{13, 10, 391}, + DictWord{145, 10, 76}, + DictWord{137, 11, 147}, + DictWord{6, 10, 260}, + DictWord{ + 7, + 10, + 1484, + }, + DictWord{11, 11, 821}, + DictWord{12, 11, 110}, + DictWord{12, 11, 153}, + DictWord{18, 11, 41}, + DictWord{150, 11, 19}, + DictWord{6, 0, 511}, + DictWord{12, 0, 132}, + DictWord{134, 10, 573}, + DictWord{5, 0, 568}, + DictWord{6, 0, 138}, + DictWord{135, 0, 1293}, + DictWord{132, 0, 1020}, + DictWord{8, 0, 258}, + DictWord{9, 0, 208}, + DictWord{137, 0, 359}, + DictWord{4, 0, 565}, + DictWord{8, 0, 23}, + DictWord{136, 0, 827}, + DictWord{134, 0, 344}, + DictWord{4, 0, 922}, + DictWord{ + 5, + 0, + 1023, + }, + DictWord{13, 11, 477}, + DictWord{14, 11, 120}, + DictWord{148, 11, 61}, + DictWord{134, 0, 240}, + DictWord{5, 11, 209}, + DictWord{6, 11, 30}, + DictWord{ + 11, + 11, + 56, + }, + DictWord{139, 11, 305}, + DictWord{6, 0, 171}, + DictWord{7, 0, 1002}, + DictWord{7, 0, 1324}, + DictWord{9, 0, 415}, + DictWord{14, 0, 230}, + DictWord{ + 18, + 0, + 68, + }, + DictWord{4, 10, 292}, + DictWord{4, 10, 736}, + DictWord{5, 10, 871}, + DictWord{6, 10, 1689}, + DictWord{7, 10, 1944}, + DictWord{137, 10, 580}, + DictWord{ + 9, + 11, + 635, + }, + DictWord{139, 11, 559}, + DictWord{4, 11, 150}, + DictWord{5, 11, 303}, + DictWord{134, 11, 327}, + DictWord{6, 10, 63}, + DictWord{135, 10, 920}, + DictWord{ + 133, + 10, + 793, + }, + DictWord{8, 11, 192}, + DictWord{10, 11, 78}, + DictWord{10, 11, 555}, + DictWord{11, 11, 308}, + DictWord{13, 11, 359}, + DictWord{147, 11, 95}, + DictWord{135, 11, 786}, + DictWord{135, 11, 1712}, + DictWord{136, 0, 402}, + DictWord{6, 0, 754}, + DictWord{6, 11, 1638}, + DictWord{7, 11, 79}, + DictWord{7, 11, 496}, + DictWord{9, 11, 138}, + DictWord{10, 11, 336}, + DictWord{11, 11, 12}, + DictWord{12, 11, 412}, + DictWord{12, 11, 440}, + DictWord{142, 11, 305}, + DictWord{4, 0, 716}, + DictWord{141, 0, 31}, + DictWord{133, 0, 982}, + DictWord{8, 0, 691}, + DictWord{8, 0, 731}, + DictWord{5, 10, 67}, + DictWord{6, 10, 62}, + DictWord{6, 10, 374}, + DictWord{ + 135, + 10, + 1391, + }, + DictWord{9, 10, 790}, + DictWord{140, 10, 47}, + DictWord{139, 11, 556}, + DictWord{151, 11, 1}, + DictWord{7, 11, 204}, + DictWord{7, 11, 415}, + DictWord{8, 11, 42}, + DictWord{10, 11, 85}, + DictWord{11, 11, 33}, + DictWord{11, 11, 564}, + DictWord{12, 11, 571}, + DictWord{149, 11, 1}, + DictWord{8, 0, 888}, + DictWord{ + 7, + 11, + 610, + }, + DictWord{135, 11, 1501}, + DictWord{4, 10, 391}, + DictWord{135, 10, 1169}, + DictWord{5, 0, 847}, + DictWord{9, 0, 840}, + DictWord{138, 0, 803}, + DictWord{137, 0, 823}, + DictWord{134, 0, 785}, + DictWord{8, 0, 152}, + DictWord{9, 0, 53}, + DictWord{9, 0, 268}, + DictWord{9, 0, 901}, + DictWord{10, 0, 518}, + DictWord{ + 10, + 0, + 829, + }, + DictWord{11, 0, 188}, + DictWord{13, 0, 74}, + DictWord{14, 0, 46}, + DictWord{15, 0, 17}, + DictWord{15, 0, 33}, + DictWord{17, 0, 40}, + DictWord{18, 0, 36}, + DictWord{ + 19, + 0, + 20, + }, + DictWord{22, 0, 1}, + DictWord{152, 0, 2}, + DictWord{4, 11, 3}, + DictWord{5, 11, 247}, + DictWord{5, 11, 644}, + DictWord{7, 11, 744}, + DictWord{7, 11, 1207}, + DictWord{7, 11, 1225}, + DictWord{7, 11, 1909}, + DictWord{146, 11, 147}, + DictWord{136, 0, 532}, + DictWord{135, 0, 681}, + DictWord{132, 10, 271}, + DictWord{ + 140, + 0, + 314, + }, + DictWord{140, 0, 677}, + DictWord{4, 0, 684}, + DictWord{136, 0, 384}, + DictWord{5, 11, 285}, + DictWord{9, 11, 67}, + DictWord{13, 11, 473}, + DictWord{ + 143, + 11, + 82, + }, + DictWord{4, 10, 253}, + DictWord{5, 10, 544}, + DictWord{7, 10, 300}, + DictWord{137, 10, 340}, + DictWord{7, 0, 110}, + DictWord{7, 0, 447}, + DictWord{8, 0, 290}, + DictWord{8, 0, 591}, + DictWord{9, 0, 382}, + DictWord{9, 0, 649}, + DictWord{11, 0, 71}, + DictWord{11, 0, 155}, + DictWord{11, 0, 313}, + DictWord{12, 0, 5}, + DictWord{13, 0, 325}, + DictWord{142, 0, 287}, + DictWord{134, 0, 1818}, + DictWord{136, 0, 1007}, + DictWord{138, 0, 321}, + DictWord{7, 0, 360}, + DictWord{7, 0, 425}, + DictWord{9, 0, 66}, + DictWord{9, 0, 278}, + DictWord{138, 0, 644}, + DictWord{133, 10, 818}, + DictWord{5, 0, 385}, + DictWord{5, 10, 541}, + DictWord{6, 10, 94}, + DictWord{6, 10, 499}, + DictWord{ + 7, + 10, + 230, + }, + DictWord{139, 10, 321}, + DictWord{4, 10, 920}, + DictWord{5, 10, 25}, + DictWord{5, 10, 790}, + DictWord{6, 10, 457}, + DictWord{7, 10, 853}, + DictWord{ + 136, + 10, + 788, + }, + DictWord{4, 0, 900}, + DictWord{133, 0, 861}, + DictWord{5, 0, 254}, + DictWord{7, 0, 985}, + DictWord{136, 0, 73}, + DictWord{7, 0, 1959}, + DictWord{ + 136, + 0, + 683, + }, + DictWord{134, 10, 1765}, + DictWord{133, 10, 822}, + DictWord{132, 10, 634}, + DictWord{4, 11, 29}, + DictWord{6, 11, 532}, + DictWord{7, 11, 1628}, + DictWord{ + 7, + 11, + 1648, + }, + DictWord{9, 11, 303}, + DictWord{9, 11, 350}, + DictWord{10, 11, 433}, + DictWord{11, 11, 97}, + DictWord{11, 11, 557}, + DictWord{11, 11, 745}, + DictWord{12, 11, 289}, + DictWord{12, 11, 335}, + DictWord{12, 11, 348}, + DictWord{12, 11, 606}, + DictWord{13, 11, 116}, + DictWord{13, 11, 233}, + DictWord{ + 13, + 11, + 466, + }, + DictWord{14, 11, 181}, + DictWord{14, 11, 209}, + DictWord{14, 11, 232}, + DictWord{14, 11, 236}, + DictWord{14, 11, 300}, + DictWord{16, 11, 41}, + DictWord{ + 148, + 11, + 97, + }, + DictWord{19, 0, 86}, + DictWord{6, 10, 36}, + DictWord{7, 10, 658}, + DictWord{136, 10, 454}, + DictWord{135, 11, 1692}, + DictWord{132, 0, 725}, + DictWord{ + 5, + 11, + 501, + }, + DictWord{7, 11, 1704}, + DictWord{9, 11, 553}, + DictWord{11, 11, 520}, + DictWord{12, 11, 557}, + DictWord{141, 11, 249}, + DictWord{134, 0, 196}, + DictWord{133, 0, 831}, + DictWord{136, 0, 723}, + DictWord{7, 0, 1897}, + DictWord{13, 0, 80}, + DictWord{13, 0, 437}, + DictWord{145, 0, 74}, + DictWord{4, 0, 992}, + DictWord{ + 6, + 0, + 627, + }, + DictWord{136, 0, 994}, + DictWord{135, 11, 1294}, + DictWord{132, 10, 104}, + DictWord{5, 0, 848}, + DictWord{6, 0, 66}, + DictWord{136, 0, 764}, + DictWord{ + 4, + 0, + 36, + }, + DictWord{7, 0, 1387}, + DictWord{10, 0, 205}, + DictWord{139, 0, 755}, + DictWord{6, 0, 1046}, + DictWord{134, 0, 1485}, + DictWord{134, 0, 950}, + DictWord{132, 0, 887}, + DictWord{14, 0, 450}, + DictWord{148, 0, 111}, + DictWord{7, 0, 620}, + DictWord{7, 0, 831}, + DictWord{9, 10, 542}, + DictWord{9, 10, 566}, + DictWord{ + 138, + 10, + 728, + }, + DictWord{6, 0, 165}, + DictWord{138, 0, 388}, + DictWord{139, 10, 263}, + DictWord{4, 0, 719}, + DictWord{135, 0, 155}, + DictWord{138, 10, 468}, + DictWord{6, 11, 453}, + DictWord{144, 11, 36}, + DictWord{134, 11, 129}, + DictWord{5, 0, 533}, + DictWord{7, 0, 755}, + DictWord{138, 0, 780}, + DictWord{134, 0, 1465}, + DictWord{4, 0, 353}, + DictWord{6, 0, 146}, + DictWord{6, 0, 1789}, + DictWord{7, 0, 427}, + DictWord{7, 0, 990}, + DictWord{7, 0, 1348}, + DictWord{9, 0, 665}, + DictWord{9, 0, 898}, + DictWord{11, 0, 893}, + DictWord{142, 0, 212}, + DictWord{7, 10, 87}, + DictWord{142, 10, 288}, + DictWord{4, 0, 45}, + DictWord{135, 0, 1257}, + DictWord{12, 0, 7}, + DictWord{7, 10, 988}, + DictWord{7, 10, 1939}, + DictWord{9, 10, 64}, + DictWord{9, 10, 502}, + DictWord{12, 10, 34}, + DictWord{13, 10, 12}, + DictWord{13, 10, 234}, + DictWord{147, 10, 77}, + DictWord{4, 0, 607}, + DictWord{5, 11, 60}, + DictWord{6, 11, 504}, + DictWord{7, 11, 614}, + DictWord{7, 11, 1155}, + DictWord{140, 11, 0}, + DictWord{ + 135, + 10, + 141, + }, + DictWord{8, 11, 198}, + DictWord{11, 11, 29}, + DictWord{140, 11, 534}, + DictWord{140, 0, 65}, + DictWord{136, 0, 816}, + DictWord{132, 10, 619}, + DictWord{139, 0, 88}, + DictWord{5, 10, 246}, + DictWord{8, 10, 189}, + DictWord{9, 10, 355}, + DictWord{9, 10, 512}, + DictWord{10, 10, 124}, + DictWord{10, 10, 453}, + DictWord{11, 10, 143}, + DictWord{11, 10, 416}, + DictWord{11, 10, 859}, + DictWord{141, 10, 341}, + DictWord{4, 11, 379}, + DictWord{135, 11, 1397}, + DictWord{ + 4, + 0, + 600, + }, + DictWord{137, 0, 621}, + DictWord{133, 0, 367}, + DictWord{134, 0, 561}, + DictWord{6, 0, 559}, + DictWord{134, 0, 1691}, + DictWord{6, 0, 585}, + DictWord{ + 134, + 11, + 585, + }, + DictWord{135, 11, 1228}, + DictWord{4, 11, 118}, + DictWord{5, 10, 678}, + DictWord{6, 11, 274}, + DictWord{6, 11, 361}, + DictWord{7, 11, 75}, + DictWord{ + 141, + 11, + 441, + }, + DictWord{135, 11, 1818}, + DictWord{137, 11, 841}, + DictWord{5, 0, 573}, + DictWord{6, 0, 287}, + DictWord{7, 10, 862}, + DictWord{7, 10, 1886}, + DictWord{138, 10, 179}, + DictWord{132, 10, 517}, + DictWord{140, 11, 693}, + DictWord{5, 11, 314}, + DictWord{6, 11, 221}, + DictWord{7, 11, 419}, + DictWord{ + 10, + 11, + 650, + }, + DictWord{11, 11, 396}, + DictWord{12, 11, 156}, + DictWord{13, 11, 369}, + DictWord{14, 11, 333}, + DictWord{145, 11, 47}, + DictWord{140, 10, 540}, + DictWord{136, 10, 667}, + DictWord{11, 10, 403}, + DictWord{146, 10, 83}, + DictWord{6, 0, 672}, + DictWord{133, 10, 761}, + DictWord{9, 0, 157}, + DictWord{10, 10, 131}, + DictWord{140, 10, 72}, + DictWord{7, 0, 714}, + DictWord{134, 11, 460}, + DictWord{134, 0, 456}, + DictWord{133, 0, 925}, + DictWord{5, 11, 682}, + DictWord{ + 135, + 11, + 1887, + }, + DictWord{136, 11, 510}, + DictWord{136, 11, 475}, + DictWord{133, 11, 1016}, + DictWord{9, 0, 19}, + DictWord{7, 11, 602}, + DictWord{8, 11, 179}, + DictWord{ + 10, + 11, + 781, + }, + DictWord{140, 11, 126}, + DictWord{6, 11, 329}, + DictWord{138, 11, 111}, + DictWord{6, 0, 822}, + DictWord{134, 0, 1473}, + DictWord{144, 11, 86}, + DictWord{11, 0, 113}, + DictWord{139, 11, 113}, + DictWord{5, 11, 821}, + DictWord{134, 11, 1687}, + DictWord{133, 10, 449}, + DictWord{7, 0, 463}, + DictWord{ + 17, + 0, + 69, + }, + DictWord{136, 10, 103}, + DictWord{7, 10, 2028}, + DictWord{138, 10, 641}, + DictWord{6, 0, 193}, + DictWord{7, 0, 240}, + DictWord{7, 0, 1682}, + DictWord{ + 10, + 0, + 51, + }, + DictWord{10, 0, 640}, + DictWord{11, 0, 410}, + DictWord{13, 0, 82}, + DictWord{14, 0, 247}, + DictWord{14, 0, 331}, + DictWord{142, 0, 377}, + DictWord{6, 0, 471}, + DictWord{11, 0, 411}, + DictWord{142, 0, 2}, + DictWord{5, 11, 71}, + DictWord{7, 11, 1407}, + DictWord{9, 11, 388}, + DictWord{9, 11, 704}, + DictWord{10, 11, 261}, + DictWord{ + 10, + 11, + 619, + }, + DictWord{11, 11, 547}, + DictWord{11, 11, 619}, + DictWord{143, 11, 157}, + DictWord{136, 0, 633}, + DictWord{135, 0, 1148}, + DictWord{6, 0, 554}, + DictWord{7, 0, 1392}, + DictWord{12, 0, 129}, + DictWord{7, 10, 1274}, + DictWord{7, 10, 1386}, + DictWord{7, 11, 2008}, + DictWord{9, 11, 337}, + DictWord{10, 11, 517}, + DictWord{146, 10, 87}, + DictWord{7, 0, 803}, + DictWord{8, 0, 542}, + DictWord{6, 10, 187}, + DictWord{7, 10, 1203}, + DictWord{8, 10, 380}, + DictWord{14, 10, 117}, + DictWord{149, 10, 28}, + DictWord{6, 10, 297}, + DictWord{7, 10, 793}, + DictWord{139, 10, 938}, + DictWord{8, 0, 438}, + DictWord{11, 0, 363}, + DictWord{7, 10, 464}, + DictWord{11, 10, 105}, + DictWord{12, 10, 231}, + DictWord{14, 10, 386}, + DictWord{15, 10, 102}, + DictWord{148, 10, 75}, + DictWord{5, 11, 16}, + DictWord{6, 11, 86}, + DictWord{6, 11, 603}, + DictWord{7, 11, 292}, + DictWord{7, 11, 561}, + DictWord{8, 11, 257}, + DictWord{8, 11, 382}, + DictWord{9, 11, 721}, + DictWord{9, 11, 778}, + DictWord{ + 11, + 11, + 581, + }, + DictWord{140, 11, 466}, + DictWord{6, 0, 717}, + DictWord{4, 11, 486}, + DictWord{133, 11, 491}, + DictWord{132, 0, 875}, + DictWord{132, 11, 72}, + DictWord{6, 11, 265}, + DictWord{135, 11, 847}, + DictWord{4, 0, 237}, + DictWord{135, 0, 514}, + DictWord{6, 0, 392}, + DictWord{7, 0, 65}, + DictWord{135, 0, 2019}, + DictWord{140, 11, 261}, + DictWord{135, 11, 922}, + DictWord{137, 11, 404}, + DictWord{12, 0, 563}, + DictWord{14, 0, 101}, + DictWord{18, 0, 129}, + DictWord{ + 7, + 10, + 1010, + }, + DictWord{11, 10, 733}, + DictWord{11, 10, 759}, + DictWord{13, 10, 34}, + DictWord{146, 10, 45}, + DictWord{7, 10, 1656}, + DictWord{9, 10, 369}, + DictWord{ + 10, + 10, + 338, + }, + DictWord{10, 10, 490}, + DictWord{11, 10, 154}, + DictWord{11, 10, 545}, + DictWord{11, 10, 775}, + DictWord{13, 10, 77}, + DictWord{141, 10, 274}, + DictWord{4, 0, 444}, + DictWord{10, 0, 146}, + DictWord{140, 0, 9}, + DictWord{139, 11, 163}, + DictWord{7, 0, 1260}, + DictWord{135, 0, 1790}, + DictWord{9, 0, 222}, + DictWord{10, 0, 43}, + DictWord{139, 0, 900}, + DictWord{137, 11, 234}, + DictWord{138, 0, 971}, + DictWord{137, 0, 761}, + DictWord{134, 0, 699}, + DictWord{ + 136, + 11, + 434, + }, + DictWord{6, 0, 1116}, + DictWord{7, 0, 1366}, + DictWord{5, 10, 20}, + DictWord{6, 11, 197}, + DictWord{6, 10, 298}, + DictWord{7, 10, 659}, + DictWord{8, 11, 205}, + DictWord{137, 10, 219}, + DictWord{132, 11, 490}, + DictWord{11, 11, 820}, + DictWord{150, 11, 51}, + DictWord{7, 10, 1440}, + DictWord{11, 10, 854}, + DictWord{ + 11, + 10, + 872, + }, + DictWord{11, 10, 921}, + DictWord{12, 10, 551}, + DictWord{13, 10, 472}, + DictWord{142, 10, 367}, + DictWord{140, 11, 13}, + DictWord{132, 0, 829}, + DictWord{12, 0, 242}, + DictWord{132, 10, 439}, + DictWord{136, 10, 669}, + DictWord{6, 0, 593}, + DictWord{6, 11, 452}, + DictWord{7, 11, 312}, + DictWord{ + 138, + 11, + 219, + }, + DictWord{4, 11, 333}, + DictWord{9, 11, 176}, + DictWord{12, 11, 353}, + DictWord{141, 11, 187}, + DictWord{7, 0, 36}, + DictWord{8, 0, 201}, + DictWord{ + 136, + 0, + 605, + }, + DictWord{140, 0, 224}, + DictWord{132, 10, 233}, + DictWord{134, 0, 1430}, + DictWord{134, 0, 1806}, + DictWord{4, 0, 523}, + DictWord{133, 0, 638}, + DictWord{ + 6, + 0, + 1889, + }, + DictWord{9, 0, 958}, + DictWord{9, 0, 971}, + DictWord{9, 0, 976}, + DictWord{12, 0, 796}, + DictWord{12, 0, 799}, + DictWord{12, 0, 808}, + DictWord{ + 12, + 0, + 835, + }, + DictWord{12, 0, 836}, + DictWord{12, 0, 914}, + DictWord{12, 0, 946}, + DictWord{15, 0, 216}, + DictWord{15, 0, 232}, + DictWord{18, 0, 183}, + DictWord{18, 0, 187}, + DictWord{18, 0, 194}, + DictWord{18, 0, 212}, + DictWord{18, 0, 232}, + DictWord{149, 0, 49}, + DictWord{132, 10, 482}, + DictWord{6, 0, 827}, + DictWord{134, 0, 1434}, + DictWord{135, 10, 346}, + DictWord{134, 0, 2043}, + DictWord{6, 0, 242}, + DictWord{7, 0, 227}, + DictWord{7, 0, 1581}, + DictWord{8, 0, 104}, + DictWord{9, 0, 113}, + DictWord{9, 0, 220}, + DictWord{9, 0, 427}, + DictWord{10, 0, 136}, + DictWord{10, 0, 239}, + DictWord{11, 0, 579}, + DictWord{11, 0, 1023}, + DictWord{13, 0, 4}, + DictWord{ + 13, + 0, + 204, + }, + DictWord{13, 0, 316}, + DictWord{148, 0, 86}, + DictWord{134, 11, 1685}, + DictWord{7, 0, 148}, + DictWord{8, 0, 284}, + DictWord{141, 0, 63}, + DictWord{ + 142, + 0, + 10, + }, + DictWord{135, 11, 584}, + DictWord{134, 0, 1249}, + DictWord{7, 0, 861}, + DictWord{135, 10, 334}, + DictWord{5, 10, 795}, + DictWord{6, 10, 1741}, + DictWord{ + 137, + 11, + 70, + }, + DictWord{132, 0, 807}, + DictWord{7, 11, 135}, + DictWord{8, 11, 7}, + DictWord{8, 11, 62}, + DictWord{9, 11, 243}, + DictWord{10, 11, 658}, + DictWord{ + 10, + 11, + 697, + }, + DictWord{11, 11, 456}, + DictWord{139, 11, 756}, + DictWord{9, 11, 395}, + DictWord{138, 11, 79}, + DictWord{137, 11, 108}, + DictWord{147, 0, 94}, + DictWord{136, 0, 494}, + DictWord{135, 11, 631}, + DictWord{135, 10, 622}, + DictWord{7, 0, 1510}, + DictWord{135, 10, 1750}, + DictWord{4, 10, 203}, + DictWord{ + 135, + 10, + 1936, + }, + DictWord{7, 11, 406}, + DictWord{7, 11, 459}, + DictWord{8, 11, 606}, + DictWord{139, 11, 726}, + DictWord{7, 0, 1306}, + DictWord{8, 0, 505}, + DictWord{ + 9, + 0, + 482, + }, + DictWord{10, 0, 126}, + DictWord{11, 0, 225}, + DictWord{12, 0, 347}, + DictWord{12, 0, 449}, + DictWord{13, 0, 19}, + DictWord{14, 0, 218}, + DictWord{142, 0, 435}, + DictWord{5, 0, 268}, + DictWord{10, 0, 764}, + DictWord{12, 0, 120}, + DictWord{13, 0, 39}, + DictWord{145, 0, 127}, + DictWord{142, 11, 68}, + DictWord{11, 10, 678}, + DictWord{140, 10, 307}, + DictWord{12, 11, 268}, + DictWord{12, 11, 640}, + DictWord{142, 11, 119}, + DictWord{135, 10, 2044}, + DictWord{133, 11, 612}, + DictWord{ + 4, + 11, + 372, + }, + DictWord{7, 11, 482}, + DictWord{8, 11, 158}, + DictWord{9, 11, 602}, + DictWord{9, 11, 615}, + DictWord{10, 11, 245}, + DictWord{10, 11, 678}, + DictWord{ + 10, + 11, + 744, + }, + DictWord{11, 11, 248}, + DictWord{139, 11, 806}, + DictWord{7, 10, 311}, + DictWord{9, 10, 308}, + DictWord{140, 10, 255}, + DictWord{4, 0, 384}, + DictWord{135, 0, 1022}, + DictWord{5, 11, 854}, + DictWord{135, 11, 1991}, + DictWord{135, 10, 1266}, + DictWord{4, 10, 400}, + DictWord{5, 10, 267}, + DictWord{ + 135, + 10, + 232, + }, + DictWord{135, 0, 1703}, + DictWord{9, 0, 159}, + DictWord{11, 0, 661}, + DictWord{140, 0, 603}, + DictWord{4, 0, 964}, + DictWord{14, 0, 438}, + DictWord{ + 14, + 0, + 444, + }, + DictWord{14, 0, 456}, + DictWord{22, 0, 60}, + DictWord{22, 0, 63}, + DictWord{9, 11, 106}, + DictWord{9, 11, 163}, + DictWord{9, 11, 296}, + DictWord{10, 11, 167}, + DictWord{10, 11, 172}, + DictWord{10, 11, 777}, + DictWord{139, 11, 16}, + DictWord{136, 0, 583}, + DictWord{132, 0, 515}, + DictWord{8, 0, 632}, + DictWord{8, 0, 697}, + DictWord{137, 0, 854}, + DictWord{5, 11, 195}, + DictWord{135, 11, 1685}, + DictWord{6, 0, 1123}, + DictWord{134, 0, 1365}, + DictWord{134, 11, 328}, + DictWord{ + 7, + 11, + 1997, + }, + DictWord{8, 11, 730}, + DictWord{139, 11, 1006}, + DictWord{4, 0, 136}, + DictWord{133, 0, 551}, + DictWord{134, 0, 1782}, + DictWord{7, 0, 1287}, + DictWord{ + 9, + 0, + 44, + }, + DictWord{10, 0, 552}, + DictWord{10, 0, 642}, + DictWord{11, 0, 839}, + DictWord{12, 0, 274}, + DictWord{12, 0, 275}, + DictWord{12, 0, 372}, + DictWord{ + 13, + 0, + 91, + }, + DictWord{142, 0, 125}, + DictWord{5, 11, 751}, + DictWord{11, 11, 797}, + DictWord{140, 11, 203}, + DictWord{133, 0, 732}, + DictWord{7, 0, 679}, + DictWord{ + 8, + 0, + 313, + }, + DictWord{4, 10, 100}, + DictWord{135, 11, 821}, + DictWord{10, 0, 361}, + DictWord{142, 0, 316}, + DictWord{134, 0, 595}, + DictWord{6, 0, 147}, + DictWord{ + 7, + 0, + 886, + }, + DictWord{9, 0, 753}, + DictWord{138, 0, 268}, + DictWord{5, 10, 362}, + DictWord{5, 10, 443}, + DictWord{6, 10, 318}, + DictWord{7, 10, 1019}, + DictWord{ + 139, + 10, + 623, + }, + DictWord{5, 10, 463}, + DictWord{136, 10, 296}, + DictWord{4, 10, 454}, + DictWord{5, 11, 950}, + DictWord{5, 11, 994}, + DictWord{134, 11, 351}, + DictWord{ + 138, + 0, + 137, + }, + DictWord{5, 10, 48}, + DictWord{5, 10, 404}, + DictWord{6, 10, 557}, + DictWord{7, 10, 458}, + DictWord{8, 10, 597}, + DictWord{10, 10, 455}, + DictWord{ + 10, + 10, + 606, + }, + DictWord{11, 10, 49}, + DictWord{11, 10, 548}, + DictWord{12, 10, 476}, + DictWord{13, 10, 18}, + DictWord{141, 10, 450}, + DictWord{133, 0, 414}, + DictWord{ + 135, + 0, + 1762, + }, + DictWord{5, 11, 421}, + DictWord{135, 11, 47}, + DictWord{5, 10, 442}, + DictWord{135, 10, 1984}, + DictWord{134, 0, 599}, + DictWord{134, 0, 1749}, + DictWord{134, 0, 1627}, + DictWord{4, 0, 488}, + DictWord{132, 11, 350}, + DictWord{137, 11, 751}, + DictWord{132, 0, 83}, + DictWord{140, 0, 676}, + DictWord{ + 133, + 11, + 967, + }, + DictWord{7, 0, 1639}, + DictWord{5, 10, 55}, + DictWord{140, 10, 161}, + DictWord{4, 11, 473}, + DictWord{7, 11, 623}, + DictWord{8, 11, 808}, + DictWord{ + 9, + 11, + 871, + }, + DictWord{9, 11, 893}, + DictWord{11, 11, 38}, + DictWord{11, 11, 431}, + DictWord{12, 11, 112}, + DictWord{12, 11, 217}, + DictWord{12, 11, 243}, + DictWord{ + 12, + 11, + 562, + }, + DictWord{12, 11, 683}, + DictWord{13, 11, 141}, + DictWord{13, 11, 197}, + DictWord{13, 11, 227}, + DictWord{13, 11, 406}, + DictWord{13, 11, 487}, + DictWord{14, 11, 156}, + DictWord{14, 11, 203}, + DictWord{14, 11, 224}, + DictWord{14, 11, 256}, + DictWord{18, 11, 58}, + DictWord{150, 11, 0}, + DictWord{ + 133, + 10, + 450, + }, + DictWord{7, 11, 736}, + DictWord{139, 11, 264}, + DictWord{134, 0, 278}, + DictWord{4, 11, 222}, + DictWord{7, 11, 286}, + DictWord{136, 11, 629}, + DictWord{ + 135, + 10, + 869, + }, + DictWord{140, 0, 97}, + DictWord{144, 0, 14}, + DictWord{134, 0, 1085}, + DictWord{4, 10, 213}, + DictWord{7, 10, 223}, + DictWord{136, 10, 80}, + DictWord{ + 7, + 0, + 388, + }, + DictWord{7, 0, 644}, + DictWord{139, 0, 781}, + DictWord{132, 0, 849}, + DictWord{7, 0, 229}, + DictWord{8, 0, 59}, + DictWord{9, 0, 190}, + DictWord{10, 0, 378}, + DictWord{140, 0, 191}, + DictWord{7, 10, 381}, + DictWord{7, 10, 806}, + DictWord{7, 10, 820}, + DictWord{8, 10, 354}, + DictWord{8, 10, 437}, + DictWord{8, 10, 787}, + DictWord{9, 10, 657}, + DictWord{10, 10, 58}, + DictWord{10, 10, 339}, + DictWord{10, 10, 749}, + DictWord{11, 10, 914}, + DictWord{12, 10, 162}, + DictWord{13, 10, 75}, + DictWord{14, 10, 106}, + DictWord{14, 10, 198}, + DictWord{14, 10, 320}, + DictWord{14, 10, 413}, + DictWord{146, 10, 43}, + DictWord{141, 11, 306}, + DictWord{ + 136, + 10, + 747, + }, + DictWord{134, 0, 1115}, + DictWord{16, 0, 94}, + DictWord{16, 0, 108}, + DictWord{136, 11, 146}, + DictWord{6, 0, 700}, + DictWord{6, 0, 817}, + DictWord{ + 134, + 0, + 1002, + }, + DictWord{133, 10, 692}, + DictWord{4, 11, 465}, + DictWord{135, 11, 1663}, + DictWord{134, 10, 191}, + DictWord{6, 0, 1414}, + DictWord{ + 135, + 11, + 913, + }, + DictWord{132, 0, 660}, + DictWord{7, 0, 1035}, + DictWord{138, 0, 737}, + DictWord{6, 10, 162}, + DictWord{7, 10, 1960}, + DictWord{136, 10, 831}, + DictWord{ + 132, + 10, + 706, + }, + DictWord{7, 0, 690}, + DictWord{9, 0, 217}, + DictWord{9, 0, 587}, + DictWord{140, 0, 521}, + DictWord{138, 10, 426}, + DictWord{135, 10, 1235}, + DictWord{ + 6, + 11, + 82, + }, + DictWord{7, 11, 138}, + DictWord{7, 11, 517}, + DictWord{9, 11, 673}, + DictWord{139, 11, 238}, + DictWord{138, 0, 272}, + DictWord{5, 11, 495}, + DictWord{ + 7, + 11, + 834, + }, + DictWord{9, 11, 733}, + DictWord{139, 11, 378}, + DictWord{134, 0, 1744}, + DictWord{132, 0, 1011}, + DictWord{7, 11, 828}, + DictWord{142, 11, 116}, + DictWord{4, 0, 733}, + DictWord{9, 0, 194}, + DictWord{10, 0, 92}, + DictWord{11, 0, 198}, + DictWord{12, 0, 84}, + DictWord{13, 0, 128}, + DictWord{133, 11, 559}, + DictWord{ + 10, + 0, + 57, + }, + DictWord{10, 0, 277}, + DictWord{6, 11, 21}, + DictWord{6, 11, 1737}, + DictWord{7, 11, 1444}, + DictWord{136, 11, 224}, + DictWord{4, 10, 204}, + DictWord{ + 137, + 10, + 902, + }, + DictWord{136, 10, 833}, + DictWord{11, 0, 348}, + DictWord{12, 0, 99}, + DictWord{18, 0, 1}, + DictWord{18, 0, 11}, + DictWord{19, 0, 4}, + DictWord{7, 10, 366}, + DictWord{9, 10, 287}, + DictWord{12, 10, 199}, + DictWord{12, 10, 556}, + DictWord{140, 10, 577}, + DictWord{6, 0, 1981}, + DictWord{136, 0, 936}, + DictWord{ + 21, + 0, + 33, + }, + DictWord{150, 0, 40}, + DictWord{5, 11, 519}, + DictWord{138, 11, 204}, + DictWord{5, 10, 356}, + DictWord{135, 10, 224}, + DictWord{134, 0, 775}, + DictWord{ + 135, + 0, + 306, + }, + DictWord{7, 10, 630}, + DictWord{9, 10, 567}, + DictWord{11, 10, 150}, + DictWord{11, 10, 444}, + DictWord{141, 10, 119}, + DictWord{5, 0, 979}, + DictWord{ + 134, + 10, + 539, + }, + DictWord{133, 0, 611}, + DictWord{4, 11, 402}, + DictWord{135, 11, 1679}, + DictWord{5, 0, 178}, + DictWord{7, 11, 2}, + DictWord{8, 11, 323}, + DictWord{ + 136, + 11, + 479, + }, + DictWord{5, 11, 59}, + DictWord{135, 11, 672}, + DictWord{4, 0, 1010}, + DictWord{6, 0, 1969}, + DictWord{138, 11, 237}, + DictWord{133, 11, 412}, + DictWord{146, 11, 34}, + DictWord{7, 11, 1740}, + DictWord{146, 11, 48}, + DictWord{134, 0, 664}, + DictWord{139, 10, 814}, + DictWord{4, 11, 85}, + DictWord{ + 135, + 11, + 549, + }, + DictWord{133, 11, 94}, + DictWord{133, 11, 457}, + DictWord{132, 0, 390}, + DictWord{134, 0, 1510}, + DictWord{4, 10, 235}, + DictWord{135, 10, 255}, + DictWord{4, 10, 194}, + DictWord{5, 10, 584}, + DictWord{6, 11, 11}, + DictWord{6, 10, 384}, + DictWord{7, 11, 187}, + DictWord{7, 10, 583}, + DictWord{10, 10, 761}, + DictWord{ + 11, + 10, + 760, + }, + DictWord{139, 10, 851}, + DictWord{4, 11, 522}, + DictWord{139, 11, 802}, + DictWord{135, 0, 493}, + DictWord{10, 11, 776}, + DictWord{13, 11, 345}, + DictWord{142, 11, 425}, + DictWord{146, 0, 37}, + DictWord{4, 11, 52}, + DictWord{135, 11, 661}, + DictWord{134, 0, 724}, + DictWord{134, 0, 829}, + DictWord{ + 133, + 11, + 520, + }, + DictWord{133, 10, 562}, + DictWord{4, 11, 281}, + DictWord{5, 11, 38}, + DictWord{7, 11, 194}, + DictWord{7, 11, 668}, + DictWord{7, 11, 1893}, + DictWord{ + 137, + 11, + 397, + }, + DictWord{5, 10, 191}, + DictWord{137, 10, 271}, + DictWord{7, 0, 1537}, + DictWord{14, 0, 96}, + DictWord{143, 0, 73}, + DictWord{5, 0, 473}, + DictWord{ + 11, + 0, + 168, + }, + DictWord{4, 10, 470}, + DictWord{6, 10, 153}, + DictWord{7, 10, 1503}, + DictWord{7, 10, 1923}, + DictWord{10, 10, 701}, + DictWord{11, 10, 132}, + DictWord{ + 11, + 10, + 227, + }, + DictWord{11, 10, 320}, + DictWord{11, 10, 436}, + DictWord{11, 10, 525}, + DictWord{11, 10, 855}, + DictWord{12, 10, 41}, + DictWord{12, 10, 286}, + DictWord{13, 10, 103}, + DictWord{13, 10, 284}, + DictWord{14, 10, 255}, + DictWord{14, 10, 262}, + DictWord{15, 10, 117}, + DictWord{143, 10, 127}, + DictWord{ + 133, + 0, + 105, + }, + DictWord{5, 0, 438}, + DictWord{9, 0, 694}, + DictWord{12, 0, 627}, + DictWord{141, 0, 210}, + DictWord{133, 10, 327}, + DictWord{6, 10, 552}, + DictWord{ + 7, + 10, + 1754, + }, + DictWord{137, 10, 604}, + DictWord{134, 0, 1256}, + DictWord{152, 0, 11}, + DictWord{5, 11, 448}, + DictWord{11, 11, 98}, + DictWord{139, 11, 524}, + DictWord{ + 7, + 0, + 1626, + }, + DictWord{5, 10, 80}, + DictWord{6, 10, 405}, + DictWord{7, 10, 403}, + DictWord{7, 10, 1502}, + DictWord{8, 10, 456}, + DictWord{9, 10, 487}, + DictWord{ + 9, + 10, + 853, + }, + DictWord{9, 10, 889}, + DictWord{10, 10, 309}, + DictWord{11, 10, 721}, + DictWord{11, 10, 994}, + DictWord{12, 10, 430}, + DictWord{13, 10, 165}, + DictWord{ + 14, + 11, + 16, + }, + DictWord{146, 11, 44}, + DictWord{132, 0, 779}, + DictWord{8, 0, 25}, + DictWord{138, 0, 826}, + DictWord{4, 10, 453}, + DictWord{5, 10, 887}, + DictWord{ + 6, + 10, + 535, + }, + DictWord{8, 10, 6}, + DictWord{8, 10, 543}, + DictWord{136, 10, 826}, + DictWord{137, 11, 461}, + DictWord{140, 11, 632}, + DictWord{132, 0, 308}, + DictWord{135, 0, 741}, + DictWord{132, 0, 671}, + DictWord{7, 0, 150}, + DictWord{8, 0, 649}, + DictWord{136, 0, 1020}, + DictWord{9, 0, 99}, + DictWord{6, 11, 336}, + DictWord{ + 8, + 11, + 552, + }, + DictWord{9, 11, 285}, + DictWord{10, 11, 99}, + DictWord{139, 11, 568}, + DictWord{134, 0, 521}, + DictWord{5, 0, 339}, + DictWord{14, 0, 3}, + DictWord{ + 15, + 0, + 41, + }, + DictWord{15, 0, 166}, + DictWord{147, 0, 66}, + DictWord{6, 11, 423}, + DictWord{7, 11, 665}, + DictWord{7, 11, 1210}, + DictWord{9, 11, 218}, + DictWord{ + 141, + 11, + 222, + }, + DictWord{6, 0, 543}, + DictWord{5, 10, 101}, + DictWord{5, 11, 256}, + DictWord{6, 10, 88}, + DictWord{7, 10, 1677}, + DictWord{9, 10, 100}, + DictWord{10, 10, 677}, + DictWord{14, 10, 169}, + DictWord{14, 10, 302}, + DictWord{14, 10, 313}, + DictWord{15, 10, 48}, + DictWord{143, 10, 84}, + DictWord{4, 10, 310}, + DictWord{ + 7, + 10, + 708, + }, + DictWord{7, 10, 996}, + DictWord{9, 10, 795}, + DictWord{10, 10, 390}, + DictWord{10, 10, 733}, + DictWord{11, 10, 451}, + DictWord{12, 10, 249}, + DictWord{ + 14, + 10, + 115, + }, + DictWord{14, 10, 286}, + DictWord{143, 10, 100}, + DictWord{133, 10, 587}, + DictWord{13, 11, 417}, + DictWord{14, 11, 129}, + DictWord{143, 11, 15}, + DictWord{134, 0, 1358}, + DictWord{136, 11, 554}, + DictWord{132, 10, 498}, + DictWord{7, 10, 217}, + DictWord{8, 10, 140}, + DictWord{138, 10, 610}, + DictWord{ + 135, + 11, + 989, + }, + DictWord{135, 11, 634}, + DictWord{6, 0, 155}, + DictWord{140, 0, 234}, + DictWord{135, 11, 462}, + DictWord{132, 11, 618}, + DictWord{ + 134, + 0, + 1628, + }, + DictWord{132, 0, 766}, + DictWord{4, 11, 339}, + DictWord{5, 10, 905}, + DictWord{135, 11, 259}, + DictWord{135, 0, 829}, + DictWord{4, 11, 759}, + DictWord{ + 141, + 11, + 169, + }, + DictWord{7, 0, 1445}, + DictWord{4, 10, 456}, + DictWord{7, 10, 358}, + DictWord{7, 10, 1637}, + DictWord{8, 10, 643}, + DictWord{139, 10, 483}, + DictWord{ + 5, + 0, + 486, + }, + DictWord{135, 0, 1349}, + DictWord{5, 11, 688}, + DictWord{135, 11, 712}, + DictWord{7, 0, 1635}, + DictWord{8, 0, 17}, + DictWord{10, 0, 217}, + DictWord{ + 10, + 0, + 295, + }, + DictWord{12, 0, 2}, + DictWord{140, 11, 2}, + DictWord{138, 0, 558}, + DictWord{150, 10, 56}, + DictWord{4, 11, 278}, + DictWord{5, 11, 465}, + DictWord{ + 135, + 11, + 1367, + }, + DictWord{136, 11, 482}, + DictWord{133, 10, 535}, + DictWord{6, 0, 1362}, + DictWord{6, 0, 1461}, + DictWord{10, 11, 274}, + DictWord{10, 11, 625}, + DictWord{139, 11, 530}, + DictWord{5, 0, 599}, + DictWord{5, 11, 336}, + DictWord{6, 11, 341}, + DictWord{6, 11, 478}, + DictWord{6, 11, 1763}, + DictWord{136, 11, 386}, + DictWord{7, 10, 1748}, + DictWord{137, 11, 151}, + DictWord{134, 0, 1376}, + DictWord{133, 10, 539}, + DictWord{135, 11, 73}, + DictWord{135, 11, 1971}, + DictWord{139, 11, 283}, + DictWord{9, 0, 93}, + DictWord{139, 0, 474}, + DictWord{6, 10, 91}, + DictWord{135, 10, 435}, + DictWord{6, 0, 447}, + DictWord{5, 11, 396}, + DictWord{134, 11, 501}, + DictWord{4, 10, 16}, + DictWord{5, 10, 316}, + DictWord{5, 10, 842}, + DictWord{6, 10, 370}, + DictWord{6, 10, 1778}, + DictWord{8, 10, 166}, + DictWord{11, 10, 812}, + DictWord{12, 10, 206}, + DictWord{12, 10, 351}, + DictWord{14, 10, 418}, + DictWord{16, 10, 15}, + DictWord{16, 10, 34}, + DictWord{18, 10, 3}, + DictWord{19, 10, 3}, + DictWord{19, 10, 7}, + DictWord{20, 10, 4}, + DictWord{149, 10, 21}, + DictWord{7, 0, 577}, + DictWord{7, 0, 1432}, + DictWord{9, 0, 475}, + DictWord{9, 0, 505}, + DictWord{9, 0, 526}, + DictWord{9, 0, 609}, + DictWord{9, 0, 689}, + DictWord{9, 0, 726}, + DictWord{9, 0, 735}, + DictWord{9, 0, 738}, + DictWord{10, 0, 556}, + DictWord{ + 10, + 0, + 674, + }, + DictWord{10, 0, 684}, + DictWord{11, 0, 89}, + DictWord{11, 0, 202}, + DictWord{11, 0, 272}, + DictWord{11, 0, 380}, + DictWord{11, 0, 415}, + DictWord{11, 0, 505}, + DictWord{11, 0, 537}, + DictWord{11, 0, 550}, + DictWord{11, 0, 562}, + DictWord{11, 0, 640}, + DictWord{11, 0, 667}, + DictWord{11, 0, 688}, + DictWord{11, 0, 847}, + DictWord{11, 0, 927}, + DictWord{11, 0, 930}, + DictWord{11, 0, 940}, + DictWord{12, 0, 144}, + DictWord{12, 0, 325}, + DictWord{12, 0, 329}, + DictWord{12, 0, 389}, + DictWord{ + 12, + 0, + 403, + }, + DictWord{12, 0, 451}, + DictWord{12, 0, 515}, + DictWord{12, 0, 604}, + DictWord{12, 0, 616}, + DictWord{12, 0, 626}, + DictWord{13, 0, 66}, + DictWord{ + 13, + 0, + 131, + }, + DictWord{13, 0, 167}, + DictWord{13, 0, 236}, + DictWord{13, 0, 368}, + DictWord{13, 0, 411}, + DictWord{13, 0, 434}, + DictWord{13, 0, 453}, + DictWord{13, 0, 461}, + DictWord{13, 0, 474}, + DictWord{14, 0, 59}, + DictWord{14, 0, 60}, + DictWord{14, 0, 139}, + DictWord{14, 0, 152}, + DictWord{14, 0, 276}, + DictWord{14, 0, 353}, + DictWord{ + 14, + 0, + 402, + }, + DictWord{15, 0, 28}, + DictWord{15, 0, 81}, + DictWord{15, 0, 123}, + DictWord{15, 0, 152}, + DictWord{18, 0, 136}, + DictWord{148, 0, 88}, + DictWord{ + 4, + 11, + 929, + }, + DictWord{133, 11, 799}, + DictWord{136, 11, 46}, + DictWord{142, 0, 307}, + DictWord{4, 0, 609}, + DictWord{7, 0, 756}, + DictWord{9, 0, 544}, + DictWord{ + 11, + 0, + 413, + }, + DictWord{144, 0, 25}, + DictWord{10, 0, 687}, + DictWord{7, 10, 619}, + DictWord{10, 10, 547}, + DictWord{11, 10, 122}, + DictWord{140, 10, 601}, + DictWord{ + 4, + 0, + 930, + }, + DictWord{133, 0, 947}, + DictWord{133, 0, 939}, + DictWord{142, 0, 21}, + DictWord{4, 11, 892}, + DictWord{133, 11, 770}, + DictWord{133, 0, 962}, + DictWord{ + 5, + 0, + 651, + }, + DictWord{8, 0, 170}, + DictWord{9, 0, 61}, + DictWord{9, 0, 63}, + DictWord{10, 0, 23}, + DictWord{10, 0, 37}, + DictWord{10, 0, 834}, + DictWord{11, 0, 4}, + DictWord{ + 11, + 0, + 187, + }, + DictWord{11, 0, 281}, + DictWord{11, 0, 503}, + DictWord{11, 0, 677}, + DictWord{12, 0, 96}, + DictWord{12, 0, 130}, + DictWord{12, 0, 244}, + DictWord{14, 0, 5}, + DictWord{14, 0, 40}, + DictWord{14, 0, 162}, + DictWord{14, 0, 202}, + DictWord{146, 0, 133}, + DictWord{4, 0, 406}, + DictWord{5, 0, 579}, + DictWord{12, 0, 492}, + DictWord{ + 150, + 0, + 15, + }, + DictWord{135, 11, 158}, + DictWord{135, 0, 597}, + DictWord{132, 0, 981}, + DictWord{132, 10, 888}, + DictWord{4, 10, 149}, + DictWord{138, 10, 368}, + DictWord{132, 0, 545}, + DictWord{4, 10, 154}, + DictWord{7, 10, 1134}, + DictWord{136, 10, 105}, + DictWord{135, 11, 2001}, + DictWord{134, 0, 1558}, + DictWord{ + 4, + 10, + 31, + }, + DictWord{6, 10, 429}, + DictWord{7, 10, 962}, + DictWord{9, 10, 458}, + DictWord{139, 10, 691}, + DictWord{132, 10, 312}, + DictWord{135, 10, 1642}, + DictWord{ + 6, + 0, + 17, + }, + DictWord{6, 0, 1304}, + DictWord{7, 0, 16}, + DictWord{7, 0, 1001}, + DictWord{9, 0, 886}, + DictWord{10, 0, 489}, + DictWord{10, 0, 800}, + DictWord{11, 0, 782}, + DictWord{12, 0, 320}, + DictWord{13, 0, 467}, + DictWord{14, 0, 145}, + DictWord{14, 0, 387}, + DictWord{143, 0, 119}, + DictWord{135, 0, 1982}, + DictWord{17, 0, 17}, + DictWord{7, 11, 1461}, + DictWord{140, 11, 91}, + DictWord{4, 10, 236}, + DictWord{132, 11, 602}, + DictWord{138, 0, 907}, + DictWord{136, 0, 110}, + DictWord{7, 0, 272}, + DictWord{19, 0, 53}, + DictWord{5, 10, 836}, + DictWord{5, 10, 857}, + DictWord{134, 10, 1680}, + DictWord{5, 0, 458}, + DictWord{7, 11, 1218}, + DictWord{136, 11, 303}, + DictWord{7, 0, 1983}, + DictWord{8, 0, 0}, + DictWord{8, 0, 171}, + DictWord{9, 0, 120}, + DictWord{9, 0, 732}, + DictWord{10, 0, 473}, + DictWord{11, 0, 656}, + DictWord{ + 11, + 0, + 998, + }, + DictWord{18, 0, 0}, + DictWord{18, 0, 2}, + DictWord{19, 0, 21}, + DictWord{10, 10, 68}, + DictWord{139, 10, 494}, + DictWord{137, 11, 662}, + DictWord{4, 11, 13}, + DictWord{5, 11, 567}, + DictWord{7, 11, 1498}, + DictWord{9, 11, 124}, + DictWord{11, 11, 521}, + DictWord{140, 11, 405}, + DictWord{4, 10, 81}, + DictWord{139, 10, 867}, + DictWord{135, 11, 1006}, + DictWord{7, 11, 800}, + DictWord{7, 11, 1783}, + DictWord{138, 11, 12}, + DictWord{9, 0, 295}, + DictWord{10, 0, 443}, + DictWord{ + 5, + 10, + 282, + }, + DictWord{8, 10, 650}, + DictWord{137, 10, 907}, + DictWord{132, 11, 735}, + DictWord{4, 11, 170}, + DictWord{4, 10, 775}, + DictWord{135, 11, 323}, + DictWord{ + 6, + 0, + 1844, + }, + DictWord{10, 0, 924}, + DictWord{11, 11, 844}, + DictWord{12, 11, 104}, + DictWord{140, 11, 625}, + DictWord{5, 11, 304}, + DictWord{7, 11, 1403}, + DictWord{140, 11, 498}, + DictWord{134, 0, 1232}, + DictWord{4, 0, 519}, + DictWord{10, 0, 70}, + DictWord{12, 0, 26}, + DictWord{14, 0, 17}, + DictWord{14, 0, 178}, + DictWord{ + 15, + 0, + 34, + }, + DictWord{149, 0, 12}, + DictWord{132, 0, 993}, + DictWord{4, 11, 148}, + DictWord{133, 11, 742}, + DictWord{6, 0, 31}, + DictWord{7, 0, 491}, + DictWord{7, 0, 530}, + DictWord{8, 0, 592}, + DictWord{11, 0, 53}, + DictWord{11, 0, 779}, + DictWord{12, 0, 167}, + DictWord{12, 0, 411}, + DictWord{14, 0, 14}, + DictWord{14, 0, 136}, + DictWord{ + 15, + 0, + 72, + }, + DictWord{16, 0, 17}, + DictWord{144, 0, 72}, + DictWord{133, 0, 907}, + DictWord{134, 0, 733}, + DictWord{133, 11, 111}, + DictWord{4, 10, 71}, + DictWord{ + 5, + 10, + 376, + }, + DictWord{7, 10, 119}, + DictWord{138, 10, 665}, + DictWord{136, 0, 55}, + DictWord{8, 0, 430}, + DictWord{136, 11, 430}, + DictWord{4, 0, 208}, + DictWord{ + 5, + 0, + 106, + }, + DictWord{6, 0, 531}, + DictWord{8, 0, 408}, + DictWord{9, 0, 188}, + DictWord{138, 0, 572}, + DictWord{12, 0, 56}, + DictWord{11, 10, 827}, + DictWord{14, 10, 34}, + DictWord{143, 10, 148}, + DictWord{134, 0, 1693}, + DictWord{133, 11, 444}, + DictWord{132, 10, 479}, + DictWord{140, 0, 441}, + DictWord{9, 0, 449}, + DictWord{ + 10, + 0, + 192, + }, + DictWord{138, 0, 740}, + DictWord{134, 0, 928}, + DictWord{4, 0, 241}, + DictWord{7, 10, 607}, + DictWord{136, 10, 99}, + DictWord{8, 11, 123}, + DictWord{ + 15, + 11, + 6, + }, + DictWord{144, 11, 7}, + DictWord{6, 11, 285}, + DictWord{8, 11, 654}, + DictWord{11, 11, 749}, + DictWord{12, 11, 190}, + DictWord{12, 11, 327}, + DictWord{ + 13, + 11, + 120, + }, + DictWord{13, 11, 121}, + DictWord{13, 11, 327}, + DictWord{15, 11, 47}, + DictWord{146, 11, 40}, + DictWord{4, 10, 41}, + DictWord{5, 10, 74}, + DictWord{ + 7, + 10, + 1627, + }, + DictWord{11, 10, 871}, + DictWord{140, 10, 619}, + DictWord{7, 0, 1525}, + DictWord{11, 10, 329}, + DictWord{11, 10, 965}, + DictWord{12, 10, 241}, + DictWord{14, 10, 354}, + DictWord{15, 10, 22}, + DictWord{148, 10, 63}, + DictWord{132, 0, 259}, + DictWord{135, 11, 183}, + DictWord{9, 10, 209}, + DictWord{ + 137, + 10, + 300, + }, + DictWord{5, 11, 937}, + DictWord{135, 11, 100}, + DictWord{133, 10, 98}, + DictWord{4, 0, 173}, + DictWord{5, 0, 312}, + DictWord{5, 0, 512}, + DictWord{ + 135, + 0, + 1285, + }, + DictWord{141, 0, 185}, + DictWord{7, 0, 1603}, + DictWord{7, 0, 1691}, + DictWord{9, 0, 464}, + DictWord{11, 0, 195}, + DictWord{12, 0, 279}, + DictWord{ + 12, + 0, + 448, + }, + DictWord{14, 0, 11}, + DictWord{147, 0, 102}, + DictWord{135, 0, 1113}, + DictWord{133, 10, 984}, + DictWord{4, 0, 452}, + DictWord{5, 0, 583}, + DictWord{ + 135, + 0, + 720, + }, + DictWord{4, 0, 547}, + DictWord{5, 0, 817}, + DictWord{6, 0, 433}, + DictWord{7, 0, 593}, + DictWord{7, 0, 1378}, + DictWord{8, 0, 161}, + DictWord{9, 0, 284}, + DictWord{ + 10, + 0, + 313, + }, + DictWord{139, 0, 886}, + DictWord{8, 0, 722}, + DictWord{4, 10, 182}, + DictWord{6, 10, 205}, + DictWord{135, 10, 220}, + DictWord{150, 0, 13}, + DictWord{ + 4, + 10, + 42, + }, + DictWord{9, 10, 205}, + DictWord{9, 10, 786}, + DictWord{138, 10, 659}, + DictWord{6, 0, 289}, + DictWord{7, 0, 1670}, + DictWord{12, 0, 57}, + DictWord{151, 0, 4}, + DictWord{132, 10, 635}, + DictWord{14, 0, 43}, + DictWord{146, 0, 21}, + DictWord{139, 10, 533}, + DictWord{135, 0, 1694}, + DictWord{8, 0, 420}, + DictWord{ + 139, + 0, + 193, + }, + DictWord{135, 0, 409}, + DictWord{132, 10, 371}, + DictWord{4, 10, 272}, + DictWord{135, 10, 836}, + DictWord{5, 10, 825}, + DictWord{134, 10, 1640}, + DictWord{5, 11, 251}, + DictWord{5, 11, 956}, + DictWord{8, 11, 268}, + DictWord{9, 11, 214}, + DictWord{146, 11, 142}, + DictWord{138, 0, 308}, + DictWord{6, 0, 1863}, + DictWord{141, 11, 37}, + DictWord{137, 10, 879}, + DictWord{7, 10, 317}, + DictWord{135, 10, 569}, + DictWord{132, 11, 294}, + DictWord{134, 0, 790}, + DictWord{ + 5, + 0, + 1002, + }, + DictWord{136, 0, 745}, + DictWord{5, 11, 346}, + DictWord{5, 11, 711}, + DictWord{136, 11, 390}, + DictWord{135, 0, 289}, + DictWord{5, 0, 504}, + DictWord{ + 11, + 0, + 68, + }, + DictWord{137, 10, 307}, + DictWord{4, 0, 239}, + DictWord{6, 0, 477}, + DictWord{7, 0, 1607}, + DictWord{139, 0, 617}, + DictWord{149, 0, 13}, + DictWord{ + 133, + 0, + 609, + }, + DictWord{133, 11, 624}, + DictWord{5, 11, 783}, + DictWord{7, 11, 1998}, + DictWord{135, 11, 2047}, + DictWord{133, 10, 525}, + DictWord{132, 0, 367}, + DictWord{132, 11, 594}, + DictWord{6, 0, 528}, + DictWord{133, 10, 493}, + DictWord{4, 10, 174}, + DictWord{135, 10, 911}, + DictWord{8, 10, 417}, + DictWord{ + 137, + 10, + 782, + }, + DictWord{132, 0, 694}, + DictWord{7, 0, 548}, + DictWord{137, 0, 58}, + DictWord{4, 10, 32}, + DictWord{5, 10, 215}, + DictWord{6, 10, 269}, + DictWord{7, 10, 1782}, + DictWord{7, 10, 1892}, + DictWord{10, 10, 16}, + DictWord{11, 10, 822}, + DictWord{11, 10, 954}, + DictWord{141, 10, 481}, + DictWord{140, 0, 687}, + DictWord{ + 7, + 0, + 1749, + }, + DictWord{136, 10, 477}, + DictWord{132, 11, 569}, + DictWord{133, 10, 308}, + DictWord{135, 10, 1088}, + DictWord{4, 0, 661}, + DictWord{138, 0, 1004}, + DictWord{5, 11, 37}, + DictWord{6, 11, 39}, + DictWord{6, 11, 451}, + DictWord{7, 11, 218}, + DictWord{7, 11, 667}, + DictWord{7, 11, 1166}, + DictWord{7, 11, 1687}, + DictWord{8, 11, 662}, + DictWord{144, 11, 2}, + DictWord{9, 0, 445}, + DictWord{12, 0, 53}, + DictWord{13, 0, 492}, + DictWord{5, 10, 126}, + DictWord{8, 10, 297}, + DictWord{ + 9, + 10, + 366, + }, + DictWord{140, 10, 374}, + DictWord{7, 10, 1551}, + DictWord{139, 10, 361}, + DictWord{148, 0, 74}, + DictWord{134, 11, 508}, + DictWord{135, 0, 213}, + DictWord{132, 10, 175}, + DictWord{132, 10, 685}, + DictWord{6, 0, 760}, + DictWord{6, 0, 834}, + DictWord{134, 0, 1248}, + DictWord{7, 11, 453}, + DictWord{7, 11, 635}, + DictWord{7, 11, 796}, + DictWord{8, 11, 331}, + DictWord{9, 11, 328}, + DictWord{9, 11, 330}, + DictWord{9, 11, 865}, + DictWord{10, 11, 119}, + DictWord{10, 11, 235}, + DictWord{11, 11, 111}, + DictWord{11, 11, 129}, + DictWord{11, 11, 240}, + DictWord{12, 11, 31}, + DictWord{12, 11, 66}, + DictWord{12, 11, 222}, + DictWord{12, 11, 269}, + DictWord{12, 11, 599}, + DictWord{12, 11, 689}, + DictWord{13, 11, 186}, + DictWord{13, 11, 364}, + DictWord{142, 11, 345}, + DictWord{7, 0, 1672}, + DictWord{ + 139, + 0, + 189, + }, + DictWord{133, 10, 797}, + DictWord{133, 10, 565}, + DictWord{6, 0, 1548}, + DictWord{6, 11, 98}, + DictWord{7, 11, 585}, + DictWord{135, 11, 702}, + DictWord{ + 9, + 0, + 968, + }, + DictWord{15, 0, 192}, + DictWord{149, 0, 56}, + DictWord{4, 10, 252}, + DictWord{6, 11, 37}, + DictWord{7, 11, 299}, + DictWord{7, 10, 1068}, + DictWord{ + 7, + 11, + 1666, + }, + DictWord{8, 11, 195}, + DictWord{8, 11, 316}, + DictWord{9, 11, 178}, + DictWord{9, 11, 276}, + DictWord{9, 11, 339}, + DictWord{9, 11, 536}, + DictWord{ + 10, + 11, + 102, + }, + DictWord{10, 11, 362}, + DictWord{10, 10, 434}, + DictWord{10, 11, 785}, + DictWord{11, 11, 55}, + DictWord{11, 11, 149}, + DictWord{11, 10, 228}, + DictWord{ + 11, + 10, + 426, + }, + DictWord{11, 11, 773}, + DictWord{13, 10, 231}, + DictWord{13, 11, 416}, + DictWord{13, 11, 419}, + DictWord{14, 11, 38}, + DictWord{14, 11, 41}, + DictWord{14, 11, 210}, + DictWord{18, 10, 106}, + DictWord{148, 10, 87}, + DictWord{4, 0, 751}, + DictWord{11, 0, 390}, + DictWord{140, 0, 32}, + DictWord{4, 0, 409}, + DictWord{133, 0, 78}, + DictWord{11, 11, 458}, + DictWord{12, 11, 15}, + DictWord{140, 11, 432}, + DictWord{7, 0, 1602}, + DictWord{10, 0, 257}, + DictWord{10, 0, 698}, + DictWord{11, 0, 544}, + DictWord{11, 0, 585}, + DictWord{12, 0, 212}, + DictWord{13, 0, 307}, + DictWord{5, 10, 231}, + DictWord{7, 10, 601}, + DictWord{9, 10, 277}, + DictWord{ + 9, + 10, + 674, + }, + DictWord{10, 10, 178}, + DictWord{10, 10, 418}, + DictWord{10, 10, 509}, + DictWord{11, 10, 531}, + DictWord{12, 10, 113}, + DictWord{12, 10, 475}, + DictWord{13, 10, 99}, + DictWord{142, 10, 428}, + DictWord{6, 0, 473}, + DictWord{145, 0, 105}, + DictWord{6, 0, 1949}, + DictWord{15, 0, 156}, + DictWord{133, 11, 645}, + DictWord{7, 10, 1591}, + DictWord{144, 10, 43}, + DictWord{135, 0, 1779}, + DictWord{135, 10, 1683}, + DictWord{4, 11, 290}, + DictWord{135, 11, 1356}, + DictWord{134, 0, 763}, + DictWord{6, 11, 70}, + DictWord{7, 11, 1292}, + DictWord{10, 11, 762}, + DictWord{139, 11, 288}, + DictWord{142, 0, 29}, + DictWord{140, 11, 428}, + DictWord{7, 0, 883}, + DictWord{7, 11, 131}, + DictWord{7, 11, 422}, + DictWord{8, 11, 210}, + DictWord{140, 11, 573}, + DictWord{134, 0, 488}, + DictWord{4, 10, 399}, + DictWord{5, 10, 119}, + DictWord{5, 10, 494}, + DictWord{7, 10, 751}, + DictWord{137, 10, 556}, + DictWord{133, 0, 617}, + DictWord{132, 11, 936}, + DictWord{ + 139, + 0, + 50, + }, + DictWord{7, 0, 1518}, + DictWord{139, 0, 694}, + DictWord{137, 0, 785}, + DictWord{4, 0, 546}, + DictWord{135, 0, 2042}, + DictWord{7, 11, 716}, + DictWord{ + 13, + 11, + 97, + }, + DictWord{141, 11, 251}, + DictWord{132, 11, 653}, + DictWord{145, 0, 22}, + DictWord{134, 0, 1016}, + DictWord{4, 0, 313}, + DictWord{133, 0, 577}, + DictWord{ + 136, + 11, + 657, + }, + DictWord{8, 0, 184}, + DictWord{141, 0, 433}, + DictWord{135, 0, 935}, + DictWord{6, 0, 720}, + DictWord{9, 0, 114}, + DictWord{146, 11, 80}, + DictWord{ + 12, + 0, + 186, + }, + DictWord{12, 0, 292}, + DictWord{14, 0, 100}, + DictWord{18, 0, 70}, + DictWord{7, 10, 594}, + DictWord{7, 10, 851}, + DictWord{7, 10, 1858}, + DictWord{ + 9, + 10, + 411, + }, + DictWord{9, 10, 574}, + DictWord{9, 10, 666}, + DictWord{9, 10, 737}, + DictWord{10, 10, 346}, + DictWord{10, 10, 712}, + DictWord{11, 10, 246}, + DictWord{ + 11, + 10, + 432, + }, + DictWord{11, 10, 517}, + DictWord{11, 10, 647}, + DictWord{11, 10, 679}, + DictWord{11, 10, 727}, + DictWord{12, 10, 304}, + DictWord{12, 10, 305}, + DictWord{12, 10, 323}, + DictWord{12, 10, 483}, + DictWord{12, 10, 572}, + DictWord{12, 10, 593}, + DictWord{12, 10, 602}, + DictWord{13, 10, 95}, + DictWord{13, 10, 101}, + DictWord{13, 10, 171}, + DictWord{13, 10, 315}, + DictWord{13, 10, 378}, + DictWord{13, 10, 425}, + DictWord{13, 10, 475}, + DictWord{14, 10, 63}, + DictWord{ + 14, + 10, + 380, + }, + DictWord{14, 10, 384}, + DictWord{15, 10, 133}, + DictWord{18, 10, 112}, + DictWord{148, 10, 72}, + DictWord{135, 10, 1093}, + DictWord{135, 11, 1836}, + DictWord{132, 10, 679}, + DictWord{137, 10, 203}, + DictWord{11, 0, 402}, + DictWord{12, 0, 109}, + DictWord{12, 0, 431}, + DictWord{13, 0, 179}, + DictWord{13, 0, 206}, + DictWord{14, 0, 217}, + DictWord{16, 0, 3}, + DictWord{148, 0, 53}, + DictWord{7, 11, 1368}, + DictWord{8, 11, 232}, + DictWord{8, 11, 361}, + DictWord{10, 11, 682}, + DictWord{138, 11, 742}, + DictWord{137, 10, 714}, + DictWord{5, 0, 886}, + DictWord{6, 0, 46}, + DictWord{6, 0, 1790}, + DictWord{7, 0, 14}, + DictWord{7, 0, 732}, + DictWord{ + 7, + 0, + 1654, + }, + DictWord{8, 0, 95}, + DictWord{8, 0, 327}, + DictWord{8, 0, 616}, + DictWord{9, 0, 892}, + DictWord{10, 0, 598}, + DictWord{10, 0, 769}, + DictWord{11, 0, 134}, + DictWord{11, 0, 747}, + DictWord{12, 0, 378}, + DictWord{14, 0, 97}, + DictWord{137, 11, 534}, + DictWord{4, 0, 969}, + DictWord{136, 10, 825}, + DictWord{137, 11, 27}, + DictWord{6, 0, 727}, + DictWord{142, 11, 12}, + DictWord{133, 0, 1021}, + DictWord{134, 0, 1190}, + DictWord{134, 11, 1657}, + DictWord{5, 10, 143}, + DictWord{ + 5, + 10, + 769, + }, + DictWord{6, 10, 1760}, + DictWord{7, 10, 682}, + DictWord{7, 10, 1992}, + DictWord{136, 10, 736}, + DictWord{132, 0, 153}, + DictWord{135, 11, 127}, + DictWord{133, 0, 798}, + DictWord{132, 0, 587}, + DictWord{6, 0, 598}, + DictWord{7, 0, 42}, + DictWord{8, 0, 695}, + DictWord{10, 0, 212}, + DictWord{11, 0, 158}, + DictWord{ + 14, + 0, + 196, + }, + DictWord{145, 0, 85}, + DictWord{133, 10, 860}, + DictWord{6, 0, 1929}, + DictWord{134, 0, 1933}, + DictWord{5, 0, 957}, + DictWord{5, 0, 1008}, + DictWord{ + 9, + 0, + 577, + }, + DictWord{12, 0, 141}, + DictWord{6, 10, 422}, + DictWord{7, 10, 0}, + DictWord{7, 10, 1544}, + DictWord{8, 11, 364}, + DictWord{11, 10, 990}, + DictWord{ + 12, + 10, + 453, + }, + DictWord{13, 10, 47}, + DictWord{141, 10, 266}, + DictWord{134, 0, 1319}, + DictWord{4, 0, 129}, + DictWord{135, 0, 465}, + DictWord{7, 0, 470}, + DictWord{ + 7, + 0, + 1057, + }, + DictWord{7, 0, 1201}, + DictWord{9, 0, 755}, + DictWord{11, 0, 906}, + DictWord{140, 0, 527}, + DictWord{7, 0, 908}, + DictWord{146, 0, 7}, + DictWord{5, 0, 148}, + DictWord{136, 0, 450}, + DictWord{5, 10, 515}, + DictWord{137, 10, 131}, + DictWord{7, 10, 1605}, + DictWord{11, 10, 962}, + DictWord{146, 10, 139}, + DictWord{ + 132, + 10, + 646, + }, + DictWord{134, 0, 1166}, + DictWord{4, 10, 396}, + DictWord{7, 10, 728}, + DictWord{9, 10, 117}, + DictWord{13, 10, 202}, + DictWord{148, 10, 51}, + DictWord{ + 6, + 10, + 121, + }, + DictWord{6, 10, 124}, + DictWord{6, 10, 357}, + DictWord{7, 10, 1138}, + DictWord{7, 10, 1295}, + DictWord{8, 10, 162}, + DictWord{139, 10, 655}, + DictWord{14, 0, 374}, + DictWord{142, 11, 374}, + DictWord{138, 0, 253}, + DictWord{139, 0, 1003}, + DictWord{5, 11, 909}, + DictWord{9, 11, 849}, + DictWord{ + 138, + 11, + 805, + }, + DictWord{133, 10, 237}, + DictWord{7, 11, 525}, + DictWord{7, 11, 1579}, + DictWord{8, 11, 497}, + DictWord{136, 11, 573}, + DictWord{137, 0, 46}, + DictWord{ + 132, + 0, + 879, + }, + DictWord{134, 0, 806}, + DictWord{135, 0, 1868}, + DictWord{6, 0, 1837}, + DictWord{134, 0, 1846}, + DictWord{6, 0, 730}, + DictWord{134, 0, 881}, + DictWord{7, 0, 965}, + DictWord{7, 0, 1460}, + DictWord{7, 0, 1604}, + DictWord{7, 11, 193}, + DictWord{7, 11, 397}, + DictWord{7, 11, 1105}, + DictWord{8, 11, 124}, + DictWord{ + 8, + 11, + 619, + }, + DictWord{9, 11, 305}, + DictWord{10, 11, 264}, + DictWord{11, 11, 40}, + DictWord{12, 11, 349}, + DictWord{13, 11, 134}, + DictWord{13, 11, 295}, + DictWord{14, 11, 155}, + DictWord{15, 11, 120}, + DictWord{146, 11, 105}, + DictWord{136, 0, 506}, + DictWord{143, 0, 10}, + DictWord{4, 11, 262}, + DictWord{7, 11, 342}, + DictWord{7, 10, 571}, + DictWord{7, 10, 1877}, + DictWord{10, 10, 366}, + DictWord{141, 11, 23}, + DictWord{133, 11, 641}, + DictWord{10, 0, 22}, + DictWord{9, 10, 513}, + DictWord{10, 10, 39}, + DictWord{12, 10, 122}, + DictWord{140, 10, 187}, + DictWord{135, 11, 1431}, + DictWord{150, 11, 49}, + DictWord{4, 11, 99}, + DictWord{ + 6, + 11, + 250, + }, + DictWord{6, 11, 346}, + DictWord{8, 11, 127}, + DictWord{138, 11, 81}, + DictWord{6, 0, 2014}, + DictWord{8, 0, 928}, + DictWord{10, 0, 960}, + DictWord{10, 0, 979}, + DictWord{140, 0, 996}, + DictWord{134, 0, 296}, + DictWord{132, 11, 915}, + DictWord{5, 11, 75}, + DictWord{9, 11, 517}, + DictWord{10, 11, 470}, + DictWord{ + 12, + 11, + 155, + }, + DictWord{141, 11, 224}, + DictWord{137, 10, 873}, + DictWord{4, 0, 854}, + DictWord{140, 11, 18}, + DictWord{134, 0, 587}, + DictWord{7, 10, 107}, + DictWord{ + 7, + 10, + 838, + }, + DictWord{8, 10, 550}, + DictWord{138, 10, 401}, + DictWord{11, 0, 636}, + DictWord{15, 0, 145}, + DictWord{17, 0, 34}, + DictWord{19, 0, 50}, + DictWord{ + 23, + 0, + 20, + }, + DictWord{11, 10, 588}, + DictWord{11, 10, 864}, + DictWord{11, 10, 968}, + DictWord{143, 10, 160}, + DictWord{135, 11, 216}, + DictWord{7, 0, 982}, + DictWord{ + 10, + 0, + 32, + }, + DictWord{143, 0, 56}, + DictWord{133, 10, 768}, + DictWord{133, 11, 954}, + DictWord{6, 11, 304}, + DictWord{7, 11, 1114}, + DictWord{8, 11, 418}, + DictWord{ + 10, + 11, + 345, + }, + DictWord{11, 11, 341}, + DictWord{11, 11, 675}, + DictWord{141, 11, 40}, + DictWord{9, 11, 410}, + DictWord{139, 11, 425}, + DictWord{136, 0, 941}, + DictWord{5, 0, 435}, + DictWord{132, 10, 894}, + DictWord{5, 0, 85}, + DictWord{6, 0, 419}, + DictWord{7, 0, 134}, + DictWord{7, 0, 305}, + DictWord{7, 0, 361}, + DictWord{ + 7, + 0, + 1337, + }, + DictWord{8, 0, 71}, + DictWord{140, 0, 519}, + DictWord{140, 0, 688}, + DictWord{135, 0, 740}, + DictWord{5, 0, 691}, + DictWord{7, 0, 345}, + DictWord{9, 0, 94}, + DictWord{140, 0, 169}, + DictWord{5, 0, 183}, + DictWord{6, 0, 582}, + DictWord{10, 0, 679}, + DictWord{140, 0, 435}, + DictWord{134, 11, 14}, + DictWord{6, 0, 945}, + DictWord{135, 0, 511}, + DictWord{134, 11, 1708}, + DictWord{5, 11, 113}, + DictWord{6, 11, 243}, + DictWord{7, 11, 1865}, + DictWord{11, 11, 161}, + DictWord{16, 11, 37}, + DictWord{145, 11, 99}, + DictWord{132, 11, 274}, + DictWord{137, 0, 539}, + DictWord{7, 0, 1993}, + DictWord{8, 0, 684}, + DictWord{134, 10, 272}, + DictWord{ + 6, + 0, + 659, + }, + DictWord{134, 0, 982}, + DictWord{4, 10, 9}, + DictWord{5, 10, 128}, + DictWord{7, 10, 368}, + DictWord{11, 10, 480}, + DictWord{148, 10, 3}, + DictWord{ + 134, + 0, + 583, + }, + DictWord{132, 0, 803}, + DictWord{133, 0, 704}, + DictWord{4, 0, 179}, + DictWord{5, 0, 198}, + DictWord{133, 0, 697}, + DictWord{7, 0, 347}, + DictWord{7, 0, 971}, + DictWord{8, 0, 181}, + DictWord{10, 0, 711}, + DictWord{135, 11, 166}, + DictWord{136, 10, 682}, + DictWord{4, 10, 2}, + DictWord{7, 10, 545}, + DictWord{7, 10, 894}, + DictWord{136, 11, 521}, + DictWord{135, 0, 481}, + DictWord{132, 0, 243}, + DictWord{5, 0, 203}, + DictWord{7, 0, 19}, + DictWord{7, 0, 71}, + DictWord{7, 0, 113}, + DictWord{ + 10, + 0, + 405, + }, + DictWord{11, 0, 357}, + DictWord{142, 0, 240}, + DictWord{5, 11, 725}, + DictWord{5, 11, 727}, + DictWord{135, 11, 1811}, + DictWord{6, 0, 826}, + DictWord{ + 137, + 11, + 304, + }, + DictWord{7, 0, 1450}, + DictWord{139, 0, 99}, + DictWord{133, 11, 654}, + DictWord{134, 0, 492}, + DictWord{5, 0, 134}, + DictWord{6, 0, 408}, + DictWord{ + 6, + 0, + 495, + }, + DictWord{7, 0, 1593}, + DictWord{6, 11, 273}, + DictWord{10, 11, 188}, + DictWord{13, 11, 377}, + DictWord{146, 11, 77}, + DictWord{9, 10, 769}, + DictWord{ + 140, + 10, + 185, + }, + DictWord{135, 11, 410}, + DictWord{142, 0, 4}, + DictWord{4, 0, 665}, + DictWord{134, 11, 1785}, + DictWord{4, 0, 248}, + DictWord{7, 0, 137}, + DictWord{ + 137, + 0, + 349, + }, + DictWord{5, 10, 530}, + DictWord{142, 10, 113}, + DictWord{7, 0, 1270}, + DictWord{139, 0, 612}, + DictWord{132, 11, 780}, + DictWord{5, 0, 371}, + DictWord{135, 0, 563}, + DictWord{135, 0, 826}, + DictWord{6, 0, 1535}, + DictWord{23, 0, 21}, + DictWord{151, 0, 23}, + DictWord{4, 0, 374}, + DictWord{7, 0, 547}, + DictWord{ + 7, + 0, + 1700, + }, + DictWord{7, 0, 1833}, + DictWord{139, 0, 858}, + DictWord{133, 10, 556}, + DictWord{7, 11, 612}, + DictWord{8, 11, 545}, + DictWord{8, 11, 568}, + DictWord{ + 8, + 11, + 642, + }, + DictWord{9, 11, 717}, + DictWord{10, 11, 541}, + DictWord{10, 11, 763}, + DictWord{11, 11, 449}, + DictWord{12, 11, 489}, + DictWord{13, 11, 153}, + DictWord{ + 13, + 11, + 296, + }, + DictWord{14, 11, 138}, + DictWord{14, 11, 392}, + DictWord{15, 11, 50}, + DictWord{16, 11, 6}, + DictWord{16, 11, 12}, + DictWord{148, 11, 9}, + DictWord{ + 9, + 0, + 311, + }, + DictWord{141, 0, 42}, + DictWord{8, 10, 16}, + DictWord{140, 10, 568}, + DictWord{6, 0, 1968}, + DictWord{6, 0, 2027}, + DictWord{138, 0, 991}, + DictWord{ + 6, + 0, + 1647, + }, + DictWord{7, 0, 1552}, + DictWord{7, 0, 2010}, + DictWord{9, 0, 494}, + DictWord{137, 0, 509}, + DictWord{133, 11, 948}, + DictWord{6, 10, 186}, + DictWord{ + 137, + 10, + 426, + }, + DictWord{134, 0, 769}, + DictWord{134, 0, 642}, + DictWord{132, 10, 585}, + DictWord{6, 0, 123}, + DictWord{7, 0, 214}, + DictWord{9, 0, 728}, + DictWord{ + 10, + 0, + 157, + }, + DictWord{11, 0, 346}, + DictWord{11, 0, 662}, + DictWord{143, 0, 106}, + DictWord{142, 11, 381}, + DictWord{135, 0, 1435}, + DictWord{4, 11, 532}, + DictWord{ + 5, + 11, + 706, + }, + DictWord{135, 11, 662}, + DictWord{5, 11, 837}, + DictWord{134, 11, 1651}, + DictWord{4, 10, 93}, + DictWord{5, 10, 252}, + DictWord{6, 10, 229}, + DictWord{ + 7, + 10, + 291, + }, + DictWord{9, 10, 550}, + DictWord{139, 10, 644}, + DictWord{148, 0, 79}, + DictWord{137, 10, 749}, + DictWord{134, 0, 1425}, + DictWord{ + 137, + 10, + 162, + }, + DictWord{4, 11, 362}, + DictWord{7, 11, 52}, + DictWord{7, 11, 303}, + DictWord{140, 11, 166}, + DictWord{132, 10, 381}, + DictWord{4, 11, 330}, + DictWord{ + 7, + 11, + 933, + }, + DictWord{7, 11, 2012}, + DictWord{136, 11, 292}, + DictWord{135, 11, 767}, + DictWord{4, 0, 707}, + DictWord{5, 0, 588}, + DictWord{6, 0, 393}, + DictWord{ + 13, + 0, + 106, + }, + DictWord{18, 0, 49}, + DictWord{147, 0, 41}, + DictWord{6, 0, 211}, + DictWord{7, 0, 1690}, + DictWord{11, 0, 486}, + DictWord{140, 0, 369}, + DictWord{ + 137, + 11, + 883, + }, + DictWord{4, 11, 703}, + DictWord{135, 11, 207}, + DictWord{4, 0, 187}, + DictWord{5, 0, 184}, + DictWord{5, 0, 690}, + DictWord{7, 0, 1869}, + DictWord{10, 0, 756}, + DictWord{139, 0, 783}, + DictWord{132, 11, 571}, + DictWord{134, 0, 1382}, + DictWord{5, 0, 175}, + DictWord{6, 10, 77}, + DictWord{6, 10, 157}, + DictWord{7, 10, 974}, + DictWord{7, 10, 1301}, + DictWord{7, 10, 1339}, + DictWord{7, 10, 1490}, + DictWord{7, 10, 1873}, + DictWord{137, 10, 628}, + DictWord{134, 0, 1493}, + DictWord{ + 5, + 11, + 873, + }, + DictWord{133, 11, 960}, + DictWord{134, 0, 1007}, + DictWord{12, 11, 93}, + DictWord{12, 11, 501}, + DictWord{13, 11, 362}, + DictWord{14, 11, 151}, + DictWord{15, 11, 40}, + DictWord{15, 11, 59}, + DictWord{16, 11, 46}, + DictWord{17, 11, 25}, + DictWord{18, 11, 14}, + DictWord{18, 11, 134}, + DictWord{19, 11, 25}, + DictWord{ + 19, + 11, + 69, + }, + DictWord{20, 11, 16}, + DictWord{20, 11, 19}, + DictWord{20, 11, 66}, + DictWord{21, 11, 23}, + DictWord{21, 11, 25}, + DictWord{150, 11, 42}, + DictWord{ + 11, + 10, + 919, + }, + DictWord{141, 10, 409}, + DictWord{134, 0, 219}, + DictWord{5, 0, 582}, + DictWord{6, 0, 1646}, + DictWord{7, 0, 99}, + DictWord{7, 0, 1962}, + DictWord{ + 7, + 0, + 1986, + }, + DictWord{8, 0, 515}, + DictWord{8, 0, 773}, + DictWord{9, 0, 23}, + DictWord{9, 0, 491}, + DictWord{12, 0, 620}, + DictWord{142, 0, 93}, + DictWord{133, 0, 851}, + DictWord{5, 11, 33}, + DictWord{134, 11, 470}, + DictWord{135, 11, 1291}, + DictWord{134, 0, 1278}, + DictWord{135, 11, 1882}, + DictWord{135, 10, 1489}, + DictWord{132, 0, 1000}, + DictWord{138, 0, 982}, + DictWord{8, 0, 762}, + DictWord{8, 0, 812}, + DictWord{137, 0, 910}, + DictWord{6, 11, 47}, + DictWord{7, 11, 90}, + DictWord{ + 7, + 11, + 664, + }, + DictWord{7, 11, 830}, + DictWord{7, 11, 1380}, + DictWord{7, 11, 2025}, + DictWord{8, 11, 448}, + DictWord{136, 11, 828}, + DictWord{4, 0, 98}, + DictWord{ + 4, + 0, + 940, + }, + DictWord{6, 0, 1819}, + DictWord{6, 0, 1834}, + DictWord{6, 0, 1841}, + DictWord{7, 0, 1365}, + DictWord{8, 0, 859}, + DictWord{8, 0, 897}, + DictWord{8, 0, 918}, + DictWord{9, 0, 422}, + DictWord{9, 0, 670}, + DictWord{10, 0, 775}, + DictWord{10, 0, 894}, + DictWord{10, 0, 909}, + DictWord{10, 0, 910}, + DictWord{10, 0, 935}, + DictWord{ + 11, + 0, + 210, + }, + DictWord{12, 0, 750}, + DictWord{12, 0, 755}, + DictWord{13, 0, 26}, + DictWord{13, 0, 457}, + DictWord{13, 0, 476}, + DictWord{16, 0, 100}, + DictWord{16, 0, 109}, + DictWord{18, 0, 173}, + DictWord{18, 0, 175}, + DictWord{8, 10, 398}, + DictWord{9, 10, 681}, + DictWord{139, 10, 632}, + DictWord{9, 11, 417}, + DictWord{ + 137, + 11, + 493, + }, + DictWord{136, 10, 645}, + DictWord{138, 0, 906}, + DictWord{134, 0, 1730}, + DictWord{134, 10, 20}, + DictWord{133, 11, 1019}, + DictWord{134, 0, 1185}, + DictWord{10, 0, 40}, + DictWord{136, 10, 769}, + DictWord{9, 0, 147}, + DictWord{134, 11, 208}, + DictWord{140, 0, 650}, + DictWord{5, 0, 209}, + DictWord{6, 0, 30}, + DictWord{11, 0, 56}, + DictWord{139, 0, 305}, + DictWord{132, 0, 553}, + DictWord{138, 11, 344}, + DictWord{6, 11, 68}, + DictWord{7, 11, 398}, + DictWord{7, 11, 448}, + DictWord{ + 7, + 11, + 1629, + }, + DictWord{7, 11, 1813}, + DictWord{8, 11, 387}, + DictWord{8, 11, 442}, + DictWord{9, 11, 710}, + DictWord{10, 11, 282}, + DictWord{138, 11, 722}, + DictWord{5, 0, 597}, + DictWord{14, 0, 20}, + DictWord{142, 11, 20}, + DictWord{135, 0, 1614}, + DictWord{135, 10, 1757}, + DictWord{4, 0, 150}, + DictWord{5, 0, 303}, + DictWord{6, 0, 327}, + DictWord{135, 10, 937}, + DictWord{16, 0, 49}, + DictWord{7, 10, 1652}, + DictWord{144, 11, 49}, + DictWord{8, 0, 192}, + DictWord{10, 0, 78}, + DictWord{ + 141, + 0, + 359, + }, + DictWord{135, 0, 786}, + DictWord{143, 0, 134}, + DictWord{6, 0, 1638}, + DictWord{7, 0, 79}, + DictWord{7, 0, 496}, + DictWord{9, 0, 138}, + DictWord{ + 10, + 0, + 336, + }, + DictWord{11, 0, 12}, + DictWord{12, 0, 412}, + DictWord{12, 0, 440}, + DictWord{142, 0, 305}, + DictWord{136, 11, 491}, + DictWord{4, 10, 579}, + DictWord{ + 5, + 10, + 226, + }, + DictWord{5, 10, 323}, + DictWord{135, 10, 960}, + DictWord{7, 0, 204}, + DictWord{7, 0, 415}, + DictWord{8, 0, 42}, + DictWord{10, 0, 85}, + DictWord{139, 0, 564}, + DictWord{132, 0, 614}, + DictWord{4, 11, 403}, + DictWord{5, 11, 441}, + DictWord{7, 11, 450}, + DictWord{11, 11, 101}, + DictWord{12, 11, 193}, + DictWord{141, 11, 430}, + DictWord{135, 11, 1927}, + DictWord{135, 11, 1330}, + DictWord{4, 0, 3}, + DictWord{5, 0, 247}, + DictWord{5, 0, 644}, + DictWord{7, 0, 744}, + DictWord{7, 0, 1207}, + DictWord{7, 0, 1225}, + DictWord{7, 0, 1909}, + DictWord{146, 0, 147}, + DictWord{136, 0, 942}, + DictWord{4, 0, 1019}, + DictWord{134, 0, 2023}, + DictWord{5, 11, 679}, + DictWord{133, 10, 973}, + DictWord{5, 0, 285}, + DictWord{9, 0, 67}, + DictWord{13, 0, 473}, + DictWord{143, 0, 82}, + DictWord{7, 11, 328}, + DictWord{137, 11, 326}, + DictWord{151, 0, 8}, + DictWord{6, 10, 135}, + DictWord{135, 10, 1176}, + DictWord{135, 11, 1128}, + DictWord{134, 0, 1309}, + DictWord{135, 11, 1796}, + DictWord{ + 135, + 10, + 314, + }, + DictWord{4, 11, 574}, + DictWord{7, 11, 350}, + DictWord{7, 11, 1024}, + DictWord{8, 11, 338}, + DictWord{9, 11, 677}, + DictWord{10, 11, 808}, + DictWord{ + 139, + 11, + 508, + }, + DictWord{7, 11, 818}, + DictWord{17, 11, 14}, + DictWord{17, 11, 45}, + DictWord{18, 11, 75}, + DictWord{148, 11, 18}, + DictWord{146, 10, 4}, + DictWord{ + 135, + 11, + 1081, + }, + DictWord{4, 0, 29}, + DictWord{6, 0, 532}, + DictWord{7, 0, 1628}, + DictWord{7, 0, 1648}, + DictWord{9, 0, 350}, + DictWord{10, 0, 433}, + DictWord{11, 0, 97}, + DictWord{11, 0, 557}, + DictWord{11, 0, 745}, + DictWord{12, 0, 289}, + DictWord{12, 0, 335}, + DictWord{12, 0, 348}, + DictWord{12, 0, 606}, + DictWord{13, 0, 116}, + DictWord{13, 0, 233}, + DictWord{13, 0, 466}, + DictWord{14, 0, 181}, + DictWord{14, 0, 209}, + DictWord{14, 0, 232}, + DictWord{14, 0, 236}, + DictWord{14, 0, 300}, + DictWord{ + 16, + 0, + 41, + }, + DictWord{148, 0, 97}, + DictWord{7, 0, 318}, + DictWord{6, 10, 281}, + DictWord{8, 10, 282}, + DictWord{8, 10, 480}, + DictWord{8, 10, 499}, + DictWord{9, 10, 198}, + DictWord{10, 10, 143}, + DictWord{10, 10, 169}, + DictWord{10, 10, 211}, + DictWord{10, 10, 417}, + DictWord{10, 10, 574}, + DictWord{11, 10, 147}, + DictWord{ + 11, + 10, + 395, + }, + DictWord{12, 10, 75}, + DictWord{12, 10, 407}, + DictWord{12, 10, 608}, + DictWord{13, 10, 500}, + DictWord{142, 10, 251}, + DictWord{135, 11, 1676}, + DictWord{135, 11, 2037}, + DictWord{135, 0, 1692}, + DictWord{5, 0, 501}, + DictWord{7, 0, 1704}, + DictWord{9, 0, 553}, + DictWord{11, 0, 520}, + DictWord{12, 0, 557}, + DictWord{141, 0, 249}, + DictWord{6, 0, 1527}, + DictWord{14, 0, 324}, + DictWord{15, 0, 55}, + DictWord{15, 0, 80}, + DictWord{14, 11, 324}, + DictWord{15, 11, 55}, + DictWord{143, 11, 80}, + DictWord{135, 10, 1776}, + DictWord{8, 0, 988}, + DictWord{137, 11, 297}, + DictWord{132, 10, 419}, + DictWord{142, 0, 223}, + DictWord{ + 139, + 11, + 234, + }, + DictWord{7, 0, 1123}, + DictWord{12, 0, 508}, + DictWord{14, 0, 102}, + DictWord{14, 0, 226}, + DictWord{144, 0, 57}, + DictWord{4, 10, 138}, + DictWord{ + 7, + 10, + 1012, + }, + DictWord{7, 10, 1280}, + DictWord{137, 10, 76}, + DictWord{7, 0, 1764}, + DictWord{5, 10, 29}, + DictWord{140, 10, 638}, + DictWord{134, 0, 2015}, + DictWord{134, 0, 1599}, + DictWord{138, 11, 56}, + DictWord{6, 11, 306}, + DictWord{7, 11, 1140}, + DictWord{7, 11, 1340}, + DictWord{8, 11, 133}, + DictWord{ + 138, + 11, + 449, + }, + DictWord{139, 11, 1011}, + DictWord{6, 10, 1710}, + DictWord{135, 10, 2038}, + DictWord{7, 11, 1763}, + DictWord{140, 11, 310}, + DictWord{6, 0, 129}, + DictWord{4, 10, 17}, + DictWord{5, 10, 23}, + DictWord{7, 10, 995}, + DictWord{11, 10, 383}, + DictWord{11, 10, 437}, + DictWord{12, 10, 460}, + DictWord{140, 10, 532}, + DictWord{5, 11, 329}, + DictWord{136, 11, 260}, + DictWord{133, 10, 862}, + DictWord{132, 0, 534}, + DictWord{6, 0, 811}, + DictWord{135, 0, 626}, + DictWord{ + 132, + 11, + 657, + }, + DictWord{4, 0, 25}, + DictWord{5, 0, 60}, + DictWord{6, 0, 504}, + DictWord{7, 0, 614}, + DictWord{7, 0, 1155}, + DictWord{12, 0, 0}, + DictWord{152, 11, 7}, + DictWord{ + 7, + 0, + 1248, + }, + DictWord{11, 0, 621}, + DictWord{139, 0, 702}, + DictWord{137, 0, 321}, + DictWord{8, 10, 70}, + DictWord{12, 10, 171}, + DictWord{141, 10, 272}, + DictWord{ + 10, + 10, + 233, + }, + DictWord{139, 10, 76}, + DictWord{4, 0, 379}, + DictWord{7, 0, 1397}, + DictWord{134, 10, 442}, + DictWord{5, 11, 66}, + DictWord{7, 11, 1896}, + DictWord{ + 136, + 11, + 288, + }, + DictWord{134, 11, 1643}, + DictWord{134, 10, 1709}, + DictWord{4, 11, 21}, + DictWord{5, 11, 91}, + DictWord{5, 11, 570}, + DictWord{5, 11, 648}, + DictWord{5, 11, 750}, + DictWord{5, 11, 781}, + DictWord{6, 11, 54}, + DictWord{6, 11, 112}, + DictWord{6, 11, 402}, + DictWord{6, 11, 1732}, + DictWord{7, 11, 315}, + DictWord{ + 7, + 11, + 749, + }, + DictWord{7, 11, 1347}, + DictWord{7, 11, 1900}, + DictWord{9, 11, 78}, + DictWord{9, 11, 508}, + DictWord{10, 11, 611}, + DictWord{11, 11, 510}, + DictWord{ + 11, + 11, + 728, + }, + DictWord{13, 11, 36}, + DictWord{14, 11, 39}, + DictWord{16, 11, 83}, + DictWord{17, 11, 124}, + DictWord{148, 11, 30}, + DictWord{4, 0, 118}, + DictWord{ + 6, + 0, + 274, + }, + DictWord{6, 0, 361}, + DictWord{7, 0, 75}, + DictWord{141, 0, 441}, + DictWord{10, 11, 322}, + DictWord{10, 11, 719}, + DictWord{139, 11, 407}, + DictWord{ + 147, + 10, + 119, + }, + DictWord{12, 11, 549}, + DictWord{14, 11, 67}, + DictWord{147, 11, 60}, + DictWord{11, 10, 69}, + DictWord{12, 10, 105}, + DictWord{12, 10, 117}, + DictWord{13, 10, 213}, + DictWord{14, 10, 13}, + DictWord{14, 10, 62}, + DictWord{14, 10, 177}, + DictWord{14, 10, 421}, + DictWord{15, 10, 19}, + DictWord{146, 10, 141}, + DictWord{9, 0, 841}, + DictWord{137, 10, 309}, + DictWord{7, 10, 608}, + DictWord{7, 10, 976}, + DictWord{8, 11, 125}, + DictWord{8, 11, 369}, + DictWord{8, 11, 524}, + DictWord{9, 10, 146}, + DictWord{10, 10, 206}, + DictWord{10, 11, 486}, + DictWord{10, 10, 596}, + DictWord{11, 11, 13}, + DictWord{11, 11, 381}, + DictWord{11, 11, 736}, + DictWord{11, 11, 766}, + DictWord{11, 11, 845}, + DictWord{13, 11, 114}, + DictWord{13, 10, 218}, + DictWord{13, 11, 292}, + DictWord{14, 11, 47}, + DictWord{ + 142, + 10, + 153, + }, + DictWord{12, 0, 693}, + DictWord{135, 11, 759}, + DictWord{5, 0, 314}, + DictWord{6, 0, 221}, + DictWord{7, 0, 419}, + DictWord{10, 0, 650}, + DictWord{11, 0, 396}, + DictWord{12, 0, 156}, + DictWord{13, 0, 369}, + DictWord{14, 0, 333}, + DictWord{145, 0, 47}, + DictWord{6, 11, 1684}, + DictWord{6, 11, 1731}, + DictWord{7, 11, 356}, + DictWord{7, 11, 1932}, + DictWord{8, 11, 54}, + DictWord{8, 11, 221}, + DictWord{9, 11, 225}, + DictWord{9, 11, 356}, + DictWord{10, 11, 77}, + DictWord{10, 11, 446}, + DictWord{10, 11, 731}, + DictWord{12, 11, 404}, + DictWord{141, 11, 491}, + DictWord{132, 11, 375}, + DictWord{4, 10, 518}, + DictWord{135, 10, 1136}, + DictWord{ + 4, + 0, + 913, + }, + DictWord{4, 11, 411}, + DictWord{11, 11, 643}, + DictWord{140, 11, 115}, + DictWord{4, 11, 80}, + DictWord{133, 11, 44}, + DictWord{8, 10, 689}, + DictWord{ + 137, + 10, + 863, + }, + DictWord{138, 0, 880}, + DictWord{4, 10, 18}, + DictWord{7, 10, 145}, + DictWord{7, 10, 444}, + DictWord{7, 10, 1278}, + DictWord{8, 10, 49}, + DictWord{ + 8, + 10, + 400, + }, + DictWord{9, 10, 71}, + DictWord{9, 10, 250}, + DictWord{10, 10, 459}, + DictWord{12, 10, 160}, + DictWord{144, 10, 24}, + DictWord{136, 0, 475}, + DictWord{ + 5, + 0, + 1016, + }, + DictWord{5, 11, 299}, + DictWord{135, 11, 1083}, + DictWord{7, 0, 602}, + DictWord{8, 0, 179}, + DictWord{10, 0, 781}, + DictWord{140, 0, 126}, + DictWord{ + 6, + 0, + 329, + }, + DictWord{138, 0, 111}, + DictWord{135, 0, 1864}, + DictWord{4, 11, 219}, + DictWord{7, 11, 1761}, + DictWord{137, 11, 86}, + DictWord{6, 0, 1888}, + DictWord{ + 6, + 0, + 1892, + }, + DictWord{6, 0, 1901}, + DictWord{6, 0, 1904}, + DictWord{9, 0, 953}, + DictWord{9, 0, 985}, + DictWord{9, 0, 991}, + DictWord{9, 0, 1001}, + DictWord{12, 0, 818}, + DictWord{12, 0, 846}, + DictWord{12, 0, 847}, + DictWord{12, 0, 861}, + DictWord{12, 0, 862}, + DictWord{12, 0, 873}, + DictWord{12, 0, 875}, + DictWord{12, 0, 877}, + DictWord{12, 0, 879}, + DictWord{12, 0, 881}, + DictWord{12, 0, 884}, + DictWord{12, 0, 903}, + DictWord{12, 0, 915}, + DictWord{12, 0, 926}, + DictWord{12, 0, 939}, + DictWord{ + 15, + 0, + 182, + }, + DictWord{15, 0, 219}, + DictWord{15, 0, 255}, + DictWord{18, 0, 191}, + DictWord{18, 0, 209}, + DictWord{18, 0, 211}, + DictWord{149, 0, 41}, + DictWord{ + 5, + 11, + 328, + }, + DictWord{135, 11, 918}, + DictWord{137, 0, 780}, + DictWord{12, 0, 82}, + DictWord{143, 0, 36}, + DictWord{133, 10, 1010}, + DictWord{5, 0, 821}, + DictWord{ + 134, + 0, + 1687, + }, + DictWord{133, 11, 514}, + DictWord{132, 0, 956}, + DictWord{134, 0, 1180}, + DictWord{10, 0, 112}, + DictWord{5, 10, 87}, + DictWord{7, 10, 313}, + DictWord{ + 7, + 10, + 1103, + }, + DictWord{10, 10, 582}, + DictWord{11, 10, 389}, + DictWord{11, 10, 813}, + DictWord{12, 10, 385}, + DictWord{13, 10, 286}, + DictWord{14, 10, 124}, + DictWord{146, 10, 108}, + DictWord{5, 0, 71}, + DictWord{7, 0, 1407}, + DictWord{9, 0, 704}, + DictWord{10, 0, 261}, + DictWord{10, 0, 619}, + DictWord{11, 0, 547}, + DictWord{11, 0, 619}, + DictWord{143, 0, 157}, + DictWord{4, 0, 531}, + DictWord{5, 0, 455}, + DictWord{5, 11, 301}, + DictWord{6, 11, 571}, + DictWord{14, 11, 49}, + DictWord{ + 146, + 11, + 102, + }, + DictWord{132, 10, 267}, + DictWord{6, 0, 385}, + DictWord{7, 0, 2008}, + DictWord{9, 0, 337}, + DictWord{138, 0, 517}, + DictWord{133, 11, 726}, + DictWord{133, 11, 364}, + DictWord{4, 11, 76}, + DictWord{7, 11, 1550}, + DictWord{9, 11, 306}, + DictWord{9, 11, 430}, + DictWord{9, 11, 663}, + DictWord{10, 11, 683}, + DictWord{11, 11, 427}, + DictWord{11, 11, 753}, + DictWord{12, 11, 334}, + DictWord{12, 11, 442}, + DictWord{14, 11, 258}, + DictWord{14, 11, 366}, + DictWord{ + 143, + 11, + 131, + }, + DictWord{6, 0, 1865}, + DictWord{6, 0, 1879}, + DictWord{6, 0, 1881}, + DictWord{6, 0, 1894}, + DictWord{6, 0, 1908}, + DictWord{9, 0, 915}, + DictWord{9, 0, 926}, + DictWord{9, 0, 940}, + DictWord{9, 0, 943}, + DictWord{9, 0, 966}, + DictWord{9, 0, 980}, + DictWord{9, 0, 989}, + DictWord{9, 0, 1005}, + DictWord{9, 0, 1010}, + DictWord{ + 12, + 0, + 813, + }, + DictWord{12, 0, 817}, + DictWord{12, 0, 840}, + DictWord{12, 0, 843}, + DictWord{12, 0, 855}, + DictWord{12, 0, 864}, + DictWord{12, 0, 871}, + DictWord{12, 0, 872}, + DictWord{12, 0, 899}, + DictWord{12, 0, 905}, + DictWord{12, 0, 924}, + DictWord{15, 0, 171}, + DictWord{15, 0, 181}, + DictWord{15, 0, 224}, + DictWord{15, 0, 235}, + DictWord{15, 0, 251}, + DictWord{146, 0, 184}, + DictWord{137, 11, 52}, + DictWord{5, 0, 16}, + DictWord{6, 0, 86}, + DictWord{6, 0, 603}, + DictWord{7, 0, 292}, + DictWord{7, 0, 561}, + DictWord{8, 0, 257}, + DictWord{8, 0, 382}, + DictWord{9, 0, 721}, + DictWord{9, 0, 778}, + DictWord{11, 0, 581}, + DictWord{140, 0, 466}, + DictWord{4, 0, 486}, + DictWord{ + 5, + 0, + 491, + }, + DictWord{135, 10, 1121}, + DictWord{4, 0, 72}, + DictWord{6, 0, 265}, + DictWord{135, 0, 1300}, + DictWord{135, 11, 1183}, + DictWord{10, 10, 249}, + DictWord{139, 10, 209}, + DictWord{132, 10, 561}, + DictWord{137, 11, 519}, + DictWord{4, 11, 656}, + DictWord{4, 10, 760}, + DictWord{135, 11, 779}, + DictWord{ + 9, + 10, + 154, + }, + DictWord{140, 10, 485}, + DictWord{135, 11, 1793}, + DictWord{135, 11, 144}, + DictWord{136, 10, 255}, + DictWord{133, 0, 621}, + DictWord{4, 10, 368}, + DictWord{135, 10, 641}, + DictWord{135, 11, 1373}, + DictWord{7, 11, 554}, + DictWord{7, 11, 605}, + DictWord{141, 11, 10}, + DictWord{137, 0, 234}, + DictWord{ + 5, + 0, + 815, + }, + DictWord{6, 0, 1688}, + DictWord{134, 0, 1755}, + DictWord{5, 11, 838}, + DictWord{5, 11, 841}, + DictWord{134, 11, 1649}, + DictWord{7, 0, 1987}, + DictWord{ + 7, + 0, + 2040, + }, + DictWord{136, 0, 743}, + DictWord{133, 11, 1012}, + DictWord{6, 0, 197}, + DictWord{136, 0, 205}, + DictWord{6, 0, 314}, + DictWord{134, 11, 314}, + DictWord{144, 11, 53}, + DictWord{6, 11, 251}, + DictWord{7, 11, 365}, + DictWord{7, 11, 1357}, + DictWord{7, 11, 1497}, + DictWord{8, 11, 154}, + DictWord{141, 11, 281}, + DictWord{133, 11, 340}, + DictWord{6, 0, 452}, + DictWord{7, 0, 312}, + DictWord{138, 0, 219}, + DictWord{138, 0, 589}, + DictWord{4, 0, 333}, + DictWord{9, 0, 176}, + DictWord{12, 0, 353}, + DictWord{141, 0, 187}, + DictWord{9, 10, 92}, + DictWord{147, 10, 91}, + DictWord{134, 0, 1110}, + DictWord{11, 0, 47}, + DictWord{139, 11, 495}, + DictWord{6, 10, 525}, + DictWord{8, 10, 806}, + DictWord{9, 10, 876}, + DictWord{140, 10, 284}, + DictWord{8, 11, 261}, + DictWord{9, 11, 144}, + DictWord{9, 11, 466}, + DictWord{10, 11, 370}, + DictWord{12, 11, 470}, + DictWord{13, 11, 144}, + DictWord{142, 11, 348}, + DictWord{137, 11, 897}, + DictWord{8, 0, 863}, + DictWord{8, 0, 864}, + DictWord{8, 0, 868}, + DictWord{8, 0, 884}, + DictWord{10, 0, 866}, + DictWord{10, 0, 868}, + DictWord{10, 0, 873}, + DictWord{10, 0, 911}, + DictWord{10, 0, 912}, + DictWord{ + 10, + 0, + 944, + }, + DictWord{12, 0, 727}, + DictWord{6, 11, 248}, + DictWord{9, 11, 546}, + DictWord{10, 11, 535}, + DictWord{11, 11, 681}, + DictWord{141, 11, 135}, + DictWord{ + 6, + 0, + 300, + }, + DictWord{135, 0, 1515}, + DictWord{134, 0, 1237}, + DictWord{139, 10, 958}, + DictWord{133, 10, 594}, + DictWord{140, 11, 250}, + DictWord{ + 134, + 0, + 1685, + }, + DictWord{134, 11, 567}, + DictWord{7, 0, 135}, + DictWord{8, 0, 7}, + DictWord{8, 0, 62}, + DictWord{9, 0, 243}, + DictWord{10, 0, 658}, + DictWord{10, 0, 697}, + DictWord{11, 0, 456}, + DictWord{139, 0, 756}, + DictWord{9, 0, 395}, + DictWord{138, 0, 79}, + DictWord{6, 10, 1641}, + DictWord{136, 10, 820}, + DictWord{4, 10, 302}, + DictWord{135, 10, 1766}, + DictWord{134, 11, 174}, + DictWord{135, 10, 1313}, + DictWord{135, 0, 631}, + DictWord{134, 10, 1674}, + DictWord{134, 11, 395}, + DictWord{138, 0, 835}, + DictWord{7, 0, 406}, + DictWord{7, 0, 459}, + DictWord{8, 0, 606}, + DictWord{139, 0, 726}, + DictWord{134, 11, 617}, + DictWord{134, 0, 979}, + DictWord{ + 6, + 10, + 389, + }, + DictWord{7, 10, 149}, + DictWord{9, 10, 142}, + DictWord{138, 10, 94}, + DictWord{5, 11, 878}, + DictWord{133, 11, 972}, + DictWord{6, 10, 8}, + DictWord{ + 7, + 10, + 1881, + }, + DictWord{8, 10, 91}, + DictWord{136, 11, 511}, + DictWord{133, 0, 612}, + DictWord{132, 11, 351}, + DictWord{4, 0, 372}, + DictWord{7, 0, 482}, + DictWord{ + 8, + 0, + 158, + }, + DictWord{9, 0, 602}, + DictWord{9, 0, 615}, + DictWord{10, 0, 245}, + DictWord{10, 0, 678}, + DictWord{10, 0, 744}, + DictWord{11, 0, 248}, + DictWord{ + 139, + 0, + 806, + }, + DictWord{5, 0, 854}, + DictWord{135, 0, 1991}, + DictWord{132, 11, 286}, + DictWord{135, 11, 344}, + DictWord{7, 11, 438}, + DictWord{7, 11, 627}, + DictWord{ + 7, + 11, + 1516, + }, + DictWord{8, 11, 40}, + DictWord{9, 11, 56}, + DictWord{9, 11, 294}, + DictWord{10, 11, 30}, + DictWord{10, 11, 259}, + DictWord{11, 11, 969}, + DictWord{ + 146, + 11, + 148, + }, + DictWord{135, 0, 1492}, + DictWord{5, 11, 259}, + DictWord{7, 11, 414}, + DictWord{7, 11, 854}, + DictWord{142, 11, 107}, + DictWord{135, 10, 1746}, + DictWord{6, 0, 833}, + DictWord{134, 0, 998}, + DictWord{135, 10, 24}, + DictWord{6, 0, 750}, + DictWord{135, 0, 1739}, + DictWord{4, 10, 503}, + DictWord{ + 135, + 10, + 1661, + }, + DictWord{5, 10, 130}, + DictWord{7, 10, 1314}, + DictWord{9, 10, 610}, + DictWord{10, 10, 718}, + DictWord{11, 10, 601}, + DictWord{11, 10, 819}, + DictWord{ + 11, + 10, + 946, + }, + DictWord{140, 10, 536}, + DictWord{10, 10, 149}, + DictWord{11, 10, 280}, + DictWord{142, 10, 336}, + DictWord{132, 11, 738}, + DictWord{ + 135, + 10, + 1946, + }, + DictWord{5, 0, 195}, + DictWord{135, 0, 1685}, + DictWord{7, 0, 1997}, + DictWord{8, 0, 730}, + DictWord{139, 0, 1006}, + DictWord{151, 11, 17}, + DictWord{ + 133, + 11, + 866, + }, + DictWord{14, 0, 463}, + DictWord{14, 0, 470}, + DictWord{150, 0, 61}, + DictWord{5, 0, 751}, + DictWord{8, 0, 266}, + DictWord{11, 0, 578}, + DictWord{ + 4, + 10, + 392, + }, + DictWord{135, 10, 1597}, + DictWord{5, 10, 433}, + DictWord{9, 10, 633}, + DictWord{139, 10, 629}, + DictWord{135, 0, 821}, + DictWord{6, 0, 715}, + DictWord{ + 134, + 0, + 1325, + }, + DictWord{133, 11, 116}, + DictWord{6, 0, 868}, + DictWord{132, 11, 457}, + DictWord{134, 0, 959}, + DictWord{6, 10, 234}, + DictWord{138, 11, 199}, + DictWord{7, 0, 1053}, + DictWord{7, 10, 1950}, + DictWord{8, 10, 680}, + DictWord{11, 10, 817}, + DictWord{147, 10, 88}, + DictWord{7, 10, 1222}, + DictWord{ + 138, + 10, + 386, + }, + DictWord{5, 0, 950}, + DictWord{5, 0, 994}, + DictWord{6, 0, 351}, + DictWord{134, 0, 1124}, + DictWord{134, 0, 1081}, + DictWord{7, 0, 1595}, + DictWord{6, 10, 5}, + DictWord{11, 10, 249}, + DictWord{12, 10, 313}, + DictWord{16, 10, 66}, + DictWord{145, 10, 26}, + DictWord{148, 0, 59}, + DictWord{5, 11, 527}, + DictWord{6, 11, 189}, + DictWord{135, 11, 859}, + DictWord{5, 10, 963}, + DictWord{6, 10, 1773}, + DictWord{11, 11, 104}, + DictWord{11, 11, 554}, + DictWord{15, 11, 60}, + DictWord{ + 143, + 11, + 125, + }, + DictWord{135, 0, 47}, + DictWord{137, 0, 684}, + DictWord{134, 11, 116}, + DictWord{134, 0, 1606}, + DictWord{134, 0, 777}, + DictWord{7, 0, 1020}, + DictWord{ + 8, + 10, + 509, + }, + DictWord{136, 10, 792}, + DictWord{135, 0, 1094}, + DictWord{132, 0, 350}, + DictWord{133, 11, 487}, + DictWord{4, 11, 86}, + DictWord{5, 11, 667}, + DictWord{5, 11, 753}, + DictWord{6, 11, 316}, + DictWord{6, 11, 455}, + DictWord{135, 11, 946}, + DictWord{7, 0, 1812}, + DictWord{13, 0, 259}, + DictWord{13, 0, 356}, + DictWord{14, 0, 242}, + DictWord{147, 0, 114}, + DictWord{132, 10, 931}, + DictWord{133, 0, 967}, + DictWord{4, 0, 473}, + DictWord{7, 0, 623}, + DictWord{8, 0, 808}, + DictWord{ + 9, + 0, + 871, + }, + DictWord{9, 0, 893}, + DictWord{11, 0, 38}, + DictWord{11, 0, 431}, + DictWord{12, 0, 112}, + DictWord{12, 0, 217}, + DictWord{12, 0, 243}, + DictWord{12, 0, 562}, + DictWord{12, 0, 663}, + DictWord{12, 0, 683}, + DictWord{13, 0, 141}, + DictWord{13, 0, 197}, + DictWord{13, 0, 227}, + DictWord{13, 0, 406}, + DictWord{13, 0, 487}, + DictWord{14, 0, 156}, + DictWord{14, 0, 203}, + DictWord{14, 0, 224}, + DictWord{14, 0, 256}, + DictWord{18, 0, 58}, + DictWord{150, 0, 0}, + DictWord{138, 0, 286}, + DictWord{ + 7, + 10, + 943, + }, + DictWord{139, 10, 614}, + DictWord{135, 10, 1837}, + DictWord{150, 11, 45}, + DictWord{132, 0, 798}, + DictWord{4, 0, 222}, + DictWord{7, 0, 286}, + DictWord{136, 0, 629}, + DictWord{4, 11, 79}, + DictWord{7, 11, 1773}, + DictWord{10, 11, 450}, + DictWord{11, 11, 589}, + DictWord{13, 11, 332}, + DictWord{13, 11, 493}, + DictWord{14, 11, 183}, + DictWord{14, 11, 334}, + DictWord{14, 11, 362}, + DictWord{14, 11, 368}, + DictWord{14, 11, 376}, + DictWord{14, 11, 379}, + DictWord{ + 19, + 11, + 90, + }, + DictWord{19, 11, 103}, + DictWord{19, 11, 127}, + DictWord{148, 11, 90}, + DictWord{5, 0, 337}, + DictWord{11, 0, 513}, + DictWord{11, 0, 889}, + DictWord{ + 11, + 0, + 961, + }, + DictWord{12, 0, 461}, + DictWord{13, 0, 79}, + DictWord{15, 0, 121}, + DictWord{4, 10, 90}, + DictWord{5, 10, 545}, + DictWord{7, 10, 754}, + DictWord{9, 10, 186}, + DictWord{10, 10, 72}, + DictWord{10, 10, 782}, + DictWord{11, 10, 577}, + DictWord{11, 10, 610}, + DictWord{12, 10, 354}, + DictWord{12, 10, 362}, + DictWord{ + 140, + 10, + 595, + }, + DictWord{141, 0, 306}, + DictWord{136, 0, 146}, + DictWord{7, 0, 1646}, + DictWord{9, 10, 329}, + DictWord{11, 10, 254}, + DictWord{141, 11, 124}, + DictWord{ + 4, + 0, + 465, + }, + DictWord{135, 0, 1663}, + DictWord{132, 0, 525}, + DictWord{133, 11, 663}, + DictWord{10, 0, 299}, + DictWord{18, 0, 74}, + DictWord{9, 10, 187}, + DictWord{ + 11, + 10, + 1016, + }, + DictWord{145, 10, 44}, + DictWord{7, 0, 165}, + DictWord{7, 0, 919}, + DictWord{4, 10, 506}, + DictWord{136, 10, 517}, + DictWord{5, 10, 295}, + DictWord{ + 135, + 10, + 1680, + }, + DictWord{133, 11, 846}, + DictWord{134, 0, 1064}, + DictWord{5, 11, 378}, + DictWord{7, 11, 1402}, + DictWord{7, 11, 1414}, + DictWord{8, 11, 465}, + DictWord{9, 11, 286}, + DictWord{10, 11, 185}, + DictWord{10, 11, 562}, + DictWord{10, 11, 635}, + DictWord{11, 11, 31}, + DictWord{11, 11, 393}, + DictWord{ + 12, + 11, + 456, + }, + DictWord{13, 11, 312}, + DictWord{18, 11, 65}, + DictWord{18, 11, 96}, + DictWord{147, 11, 89}, + DictWord{132, 0, 596}, + DictWord{7, 10, 987}, + DictWord{ + 9, + 10, + 688, + }, + DictWord{10, 10, 522}, + DictWord{11, 10, 788}, + DictWord{140, 10, 566}, + DictWord{6, 0, 82}, + DictWord{7, 0, 138}, + DictWord{7, 0, 517}, + DictWord{7, 0, 1741}, + DictWord{11, 0, 238}, + DictWord{4, 11, 648}, + DictWord{134, 10, 1775}, + DictWord{7, 0, 1233}, + DictWord{7, 10, 700}, + DictWord{7, 10, 940}, + DictWord{8, 10, 514}, + DictWord{9, 10, 116}, + DictWord{9, 10, 535}, + DictWord{10, 10, 118}, + DictWord{11, 10, 107}, + DictWord{11, 10, 148}, + DictWord{11, 10, 922}, + DictWord{ + 12, + 10, + 254, + }, + DictWord{12, 10, 421}, + DictWord{142, 10, 238}, + DictWord{4, 0, 962}, + DictWord{6, 0, 1824}, + DictWord{8, 0, 894}, + DictWord{12, 0, 708}, + DictWord{ + 12, + 0, + 725, + }, + DictWord{14, 0, 451}, + DictWord{20, 0, 94}, + DictWord{22, 0, 59}, + DictWord{150, 0, 62}, + DictWord{5, 11, 945}, + DictWord{6, 11, 1656}, + DictWord{6, 11, 1787}, + DictWord{7, 11, 167}, + DictWord{8, 11, 824}, + DictWord{9, 11, 391}, + DictWord{10, 11, 375}, + DictWord{139, 11, 185}, + DictWord{5, 0, 495}, + DictWord{7, 0, 834}, + DictWord{9, 0, 733}, + DictWord{139, 0, 378}, + DictWord{4, 10, 743}, + DictWord{135, 11, 1273}, + DictWord{6, 0, 1204}, + DictWord{7, 11, 1645}, + DictWord{8, 11, 352}, + DictWord{137, 11, 249}, + DictWord{139, 10, 292}, + DictWord{133, 0, 559}, + DictWord{132, 11, 152}, + DictWord{9, 0, 499}, + DictWord{10, 0, 341}, + DictWord{ + 15, + 0, + 144, + }, + DictWord{19, 0, 49}, + DictWord{7, 10, 1283}, + DictWord{9, 10, 227}, + DictWord{11, 10, 325}, + DictWord{11, 10, 408}, + DictWord{14, 10, 180}, + DictWord{ + 146, + 10, + 47, + }, + DictWord{6, 0, 21}, + DictWord{6, 0, 1737}, + DictWord{7, 0, 1444}, + DictWord{136, 0, 224}, + DictWord{133, 11, 1006}, + DictWord{7, 0, 1446}, + DictWord{ + 9, + 0, + 97, + }, + DictWord{17, 0, 15}, + DictWord{5, 10, 81}, + DictWord{7, 10, 146}, + DictWord{7, 10, 1342}, + DictWord{8, 10, 53}, + DictWord{8, 10, 561}, + DictWord{8, 10, 694}, + DictWord{8, 10, 754}, + DictWord{9, 10, 115}, + DictWord{9, 10, 894}, + DictWord{10, 10, 462}, + DictWord{10, 10, 813}, + DictWord{11, 10, 230}, + DictWord{11, 10, 657}, + DictWord{11, 10, 699}, + DictWord{11, 10, 748}, + DictWord{12, 10, 119}, + DictWord{12, 10, 200}, + DictWord{12, 10, 283}, + DictWord{142, 10, 273}, + DictWord{ + 5, + 10, + 408, + }, + DictWord{137, 10, 747}, + DictWord{135, 11, 431}, + DictWord{135, 11, 832}, + DictWord{6, 0, 729}, + DictWord{134, 0, 953}, + DictWord{4, 0, 727}, + DictWord{ + 8, + 0, + 565, + }, + DictWord{5, 11, 351}, + DictWord{7, 11, 264}, + DictWord{136, 11, 565}, + DictWord{134, 0, 1948}, + DictWord{5, 0, 519}, + DictWord{5, 11, 40}, + DictWord{ + 7, + 11, + 598, + }, + DictWord{7, 11, 1638}, + DictWord{8, 11, 78}, + DictWord{9, 11, 166}, + DictWord{9, 11, 640}, + DictWord{9, 11, 685}, + DictWord{9, 11, 773}, + DictWord{ + 11, + 11, + 215, + }, + DictWord{13, 11, 65}, + DictWord{14, 11, 172}, + DictWord{14, 11, 317}, + DictWord{145, 11, 6}, + DictWord{8, 11, 60}, + DictWord{9, 11, 343}, + DictWord{ + 139, + 11, + 769, + }, + DictWord{137, 11, 455}, + DictWord{134, 0, 1193}, + DictWord{140, 0, 790}, + DictWord{7, 11, 1951}, + DictWord{8, 11, 765}, + DictWord{8, 11, 772}, + DictWord{140, 11, 671}, + DictWord{7, 11, 108}, + DictWord{8, 11, 219}, + DictWord{8, 11, 388}, + DictWord{9, 11, 639}, + DictWord{9, 11, 775}, + DictWord{11, 11, 275}, + DictWord{140, 11, 464}, + DictWord{132, 11, 468}, + DictWord{7, 10, 30}, + DictWord{8, 10, 86}, + DictWord{8, 10, 315}, + DictWord{8, 10, 700}, + DictWord{9, 10, 576}, + DictWord{ + 9, + 10, + 858, + }, + DictWord{11, 10, 310}, + DictWord{11, 10, 888}, + DictWord{11, 10, 904}, + DictWord{12, 10, 361}, + DictWord{141, 10, 248}, + DictWord{5, 11, 15}, + DictWord{6, 11, 56}, + DictWord{7, 11, 1758}, + DictWord{8, 11, 500}, + DictWord{9, 11, 730}, + DictWord{11, 11, 331}, + DictWord{13, 11, 150}, + DictWord{142, 11, 282}, + DictWord{4, 0, 402}, + DictWord{7, 0, 2}, + DictWord{8, 0, 323}, + DictWord{136, 0, 479}, + DictWord{138, 10, 839}, + DictWord{11, 0, 580}, + DictWord{142, 0, 201}, + DictWord{ + 5, + 0, + 59, + }, + DictWord{135, 0, 672}, + DictWord{137, 10, 617}, + DictWord{146, 0, 34}, + DictWord{134, 11, 1886}, + DictWord{4, 0, 961}, + DictWord{136, 0, 896}, + DictWord{ + 6, + 0, + 1285, + }, + DictWord{5, 11, 205}, + DictWord{6, 11, 438}, + DictWord{137, 11, 711}, + DictWord{134, 10, 428}, + DictWord{7, 10, 524}, + DictWord{8, 10, 169}, + DictWord{8, 10, 234}, + DictWord{9, 10, 480}, + DictWord{138, 10, 646}, + DictWord{148, 0, 46}, + DictWord{141, 0, 479}, + DictWord{133, 11, 534}, + DictWord{6, 0, 2019}, + DictWord{134, 10, 1648}, + DictWord{4, 0, 85}, + DictWord{7, 0, 549}, + DictWord{7, 10, 1205}, + DictWord{138, 10, 637}, + DictWord{4, 0, 663}, + DictWord{5, 0, 94}, + DictWord{ + 7, + 11, + 235, + }, + DictWord{7, 11, 1475}, + DictWord{15, 11, 68}, + DictWord{146, 11, 120}, + DictWord{6, 11, 443}, + DictWord{9, 11, 237}, + DictWord{9, 11, 571}, + DictWord{ + 9, + 11, + 695, + }, + DictWord{10, 11, 139}, + DictWord{11, 11, 715}, + DictWord{12, 11, 417}, + DictWord{141, 11, 421}, + DictWord{132, 0, 783}, + DictWord{4, 0, 682}, + DictWord{8, 0, 65}, + DictWord{9, 10, 39}, + DictWord{10, 10, 166}, + DictWord{11, 10, 918}, + DictWord{12, 10, 635}, + DictWord{20, 10, 10}, + DictWord{22, 10, 27}, + DictWord{ + 22, + 10, + 43, + }, + DictWord{150, 10, 52}, + DictWord{6, 0, 11}, + DictWord{135, 0, 187}, + DictWord{132, 0, 522}, + DictWord{4, 0, 52}, + DictWord{135, 0, 661}, + DictWord{ + 4, + 0, + 383, + }, + DictWord{133, 0, 520}, + DictWord{135, 11, 546}, + DictWord{11, 0, 343}, + DictWord{142, 0, 127}, + DictWord{4, 11, 578}, + DictWord{7, 10, 157}, + DictWord{ + 7, + 11, + 624, + }, + DictWord{7, 11, 916}, + DictWord{8, 10, 279}, + DictWord{10, 11, 256}, + DictWord{11, 11, 87}, + DictWord{139, 11, 703}, + DictWord{134, 10, 604}, + DictWord{ + 4, + 0, + 281, + }, + DictWord{5, 0, 38}, + DictWord{7, 0, 194}, + DictWord{7, 0, 668}, + DictWord{7, 0, 1893}, + DictWord{137, 0, 397}, + DictWord{7, 10, 945}, + DictWord{11, 10, 713}, + DictWord{139, 10, 744}, + DictWord{139, 10, 1022}, + DictWord{9, 0, 635}, + DictWord{139, 0, 559}, + DictWord{5, 11, 923}, + DictWord{7, 11, 490}, + DictWord{ + 12, + 11, + 553, + }, + DictWord{13, 11, 100}, + DictWord{14, 11, 118}, + DictWord{143, 11, 75}, + DictWord{132, 0, 975}, + DictWord{132, 10, 567}, + DictWord{137, 10, 859}, + DictWord{7, 10, 1846}, + DictWord{7, 11, 1846}, + DictWord{8, 10, 628}, + DictWord{136, 11, 628}, + DictWord{148, 0, 116}, + DictWord{138, 11, 750}, + DictWord{14, 0, 51}, + DictWord{14, 11, 51}, + DictWord{15, 11, 7}, + DictWord{148, 11, 20}, + DictWord{132, 0, 858}, + DictWord{134, 0, 1075}, + DictWord{4, 11, 924}, + DictWord{ + 133, + 10, + 762, + }, + DictWord{136, 0, 535}, + DictWord{133, 0, 448}, + DictWord{10, 10, 784}, + DictWord{141, 10, 191}, + DictWord{133, 10, 298}, + DictWord{7, 0, 610}, + DictWord{135, 0, 1501}, + DictWord{7, 10, 633}, + DictWord{7, 10, 905}, + DictWord{7, 10, 909}, + DictWord{7, 10, 1538}, + DictWord{9, 10, 767}, + DictWord{140, 10, 636}, + DictWord{4, 11, 265}, + DictWord{7, 11, 807}, + DictWord{135, 11, 950}, + DictWord{5, 11, 93}, + DictWord{12, 11, 267}, + DictWord{144, 11, 26}, + DictWord{136, 0, 191}, + DictWord{139, 10, 301}, + DictWord{135, 10, 1970}, + DictWord{135, 0, 267}, + DictWord{4, 0, 319}, + DictWord{5, 0, 699}, + DictWord{138, 0, 673}, + DictWord{ + 6, + 0, + 336, + }, + DictWord{7, 0, 92}, + DictWord{7, 0, 182}, + DictWord{8, 0, 453}, + DictWord{8, 0, 552}, + DictWord{9, 0, 204}, + DictWord{9, 0, 285}, + DictWord{10, 0, 99}, + DictWord{ + 11, + 0, + 568, + }, + DictWord{11, 0, 950}, + DictWord{12, 0, 94}, + DictWord{16, 0, 20}, + DictWord{16, 0, 70}, + DictWord{19, 0, 55}, + DictWord{12, 10, 644}, + DictWord{144, 10, 90}, + DictWord{6, 0, 551}, + DictWord{7, 0, 1308}, + DictWord{7, 10, 845}, + DictWord{7, 11, 994}, + DictWord{8, 10, 160}, + DictWord{137, 10, 318}, + DictWord{19, 11, 1}, + DictWord{ + 19, + 11, + 26, + }, + DictWord{150, 11, 9}, + DictWord{7, 0, 1406}, + DictWord{9, 0, 218}, + DictWord{141, 0, 222}, + DictWord{5, 0, 256}, + DictWord{138, 0, 69}, + DictWord{ + 5, + 11, + 233, + }, + DictWord{5, 11, 320}, + DictWord{6, 11, 140}, + DictWord{7, 11, 330}, + DictWord{136, 11, 295}, + DictWord{6, 0, 1980}, + DictWord{136, 0, 952}, + DictWord{ + 4, + 0, + 833, + }, + DictWord{137, 11, 678}, + DictWord{133, 11, 978}, + DictWord{4, 11, 905}, + DictWord{6, 11, 1701}, + DictWord{137, 11, 843}, + DictWord{138, 10, 735}, + DictWord{136, 10, 76}, + DictWord{17, 0, 39}, + DictWord{148, 0, 36}, + DictWord{18, 0, 81}, + DictWord{146, 11, 81}, + DictWord{14, 0, 352}, + DictWord{17, 0, 53}, + DictWord{ + 18, + 0, + 146, + }, + DictWord{18, 0, 152}, + DictWord{19, 0, 11}, + DictWord{150, 0, 54}, + DictWord{135, 0, 634}, + DictWord{138, 10, 841}, + DictWord{132, 0, 618}, + DictWord{ + 4, + 0, + 339, + }, + DictWord{7, 0, 259}, + DictWord{17, 0, 73}, + DictWord{4, 11, 275}, + DictWord{140, 11, 376}, + DictWord{132, 11, 509}, + DictWord{7, 11, 273}, + DictWord{ + 139, + 11, + 377, + }, + DictWord{4, 0, 759}, + DictWord{13, 0, 169}, + DictWord{137, 10, 804}, + DictWord{6, 10, 96}, + DictWord{135, 10, 1426}, + DictWord{4, 10, 651}, + DictWord{133, 10, 289}, + DictWord{7, 0, 1075}, + DictWord{8, 10, 35}, + DictWord{9, 10, 511}, + DictWord{10, 10, 767}, + DictWord{147, 10, 118}, + DictWord{6, 0, 649}, + DictWord{6, 0, 670}, + DictWord{136, 0, 482}, + DictWord{5, 0, 336}, + DictWord{6, 0, 341}, + DictWord{6, 0, 478}, + DictWord{6, 0, 1763}, + DictWord{136, 0, 386}, + DictWord{ + 5, + 11, + 802, + }, + DictWord{7, 11, 2021}, + DictWord{8, 11, 805}, + DictWord{14, 11, 94}, + DictWord{15, 11, 65}, + DictWord{16, 11, 4}, + DictWord{16, 11, 77}, + DictWord{16, 11, 80}, + DictWord{145, 11, 5}, + DictWord{6, 0, 1035}, + DictWord{5, 11, 167}, + DictWord{5, 11, 899}, + DictWord{6, 11, 410}, + DictWord{137, 11, 777}, + DictWord{ + 134, + 11, + 1705, + }, + DictWord{5, 0, 924}, + DictWord{133, 0, 969}, + DictWord{132, 10, 704}, + DictWord{135, 0, 73}, + DictWord{135, 11, 10}, + DictWord{135, 10, 1078}, + DictWord{ + 5, + 11, + 11, + }, + DictWord{6, 11, 117}, + DictWord{6, 11, 485}, + DictWord{7, 11, 1133}, + DictWord{9, 11, 582}, + DictWord{9, 11, 594}, + DictWord{11, 11, 21}, + DictWord{ + 11, + 11, + 818, + }, + DictWord{12, 11, 535}, + DictWord{141, 11, 86}, + DictWord{135, 0, 1971}, + DictWord{4, 11, 264}, + DictWord{7, 11, 1067}, + DictWord{8, 11, 204}, + DictWord{8, 11, 385}, + DictWord{139, 11, 953}, + DictWord{6, 0, 1458}, + DictWord{135, 0, 1344}, + DictWord{5, 0, 396}, + DictWord{134, 0, 501}, + DictWord{4, 10, 720}, + DictWord{133, 10, 306}, + DictWord{4, 0, 929}, + DictWord{5, 0, 799}, + DictWord{8, 0, 46}, + DictWord{8, 0, 740}, + DictWord{133, 10, 431}, + DictWord{7, 11, 646}, + DictWord{ + 7, + 11, + 1730, + }, + DictWord{11, 11, 446}, + DictWord{141, 11, 178}, + DictWord{7, 0, 276}, + DictWord{5, 10, 464}, + DictWord{6, 10, 236}, + DictWord{7, 10, 696}, + DictWord{ + 7, + 10, + 914, + }, + DictWord{7, 10, 1108}, + DictWord{7, 10, 1448}, + DictWord{9, 10, 15}, + DictWord{9, 10, 564}, + DictWord{10, 10, 14}, + DictWord{12, 10, 565}, + DictWord{ + 13, + 10, + 449, + }, + DictWord{14, 10, 53}, + DictWord{15, 10, 13}, + DictWord{16, 10, 64}, + DictWord{145, 10, 41}, + DictWord{4, 0, 892}, + DictWord{133, 0, 770}, + DictWord{ + 6, + 10, + 1767, + }, + DictWord{12, 10, 194}, + DictWord{145, 10, 107}, + DictWord{135, 0, 158}, + DictWord{5, 10, 840}, + DictWord{138, 11, 608}, + DictWord{134, 0, 1432}, + DictWord{138, 11, 250}, + DictWord{8, 11, 794}, + DictWord{9, 11, 400}, + DictWord{10, 11, 298}, + DictWord{142, 11, 228}, + DictWord{151, 0, 25}, + DictWord{ + 7, + 11, + 1131, + }, + DictWord{135, 11, 1468}, + DictWord{135, 0, 2001}, + DictWord{9, 10, 642}, + DictWord{11, 10, 236}, + DictWord{142, 10, 193}, + DictWord{4, 10, 68}, + DictWord{5, 10, 634}, + DictWord{6, 10, 386}, + DictWord{7, 10, 794}, + DictWord{8, 10, 273}, + DictWord{9, 10, 563}, + DictWord{10, 10, 105}, + DictWord{10, 10, 171}, + DictWord{11, 10, 94}, + DictWord{139, 10, 354}, + DictWord{136, 11, 724}, + DictWord{132, 0, 478}, + DictWord{11, 11, 512}, + DictWord{13, 11, 205}, + DictWord{ + 19, + 11, + 30, + }, + DictWord{22, 11, 36}, + DictWord{151, 11, 19}, + DictWord{7, 0, 1461}, + DictWord{140, 0, 91}, + DictWord{6, 11, 190}, + DictWord{7, 11, 768}, + DictWord{ + 135, + 11, + 1170, + }, + DictWord{4, 0, 602}, + DictWord{8, 0, 211}, + DictWord{4, 10, 95}, + DictWord{7, 10, 416}, + DictWord{139, 10, 830}, + DictWord{7, 10, 731}, + DictWord{13, 10, 20}, + DictWord{143, 10, 11}, + DictWord{6, 0, 1068}, + DictWord{135, 0, 1872}, + DictWord{4, 0, 13}, + DictWord{5, 0, 567}, + DictWord{7, 0, 1498}, + DictWord{9, 0, 124}, + DictWord{11, 0, 521}, + DictWord{12, 0, 405}, + DictWord{135, 11, 1023}, + DictWord{135, 0, 1006}, + DictWord{132, 0, 735}, + DictWord{138, 0, 812}, + DictWord{4, 0, 170}, + DictWord{135, 0, 323}, + DictWord{6, 11, 137}, + DictWord{9, 11, 75}, + DictWord{9, 11, 253}, + DictWord{10, 11, 194}, + DictWord{138, 11, 444}, + DictWord{5, 0, 304}, + DictWord{7, 0, 1403}, + DictWord{5, 10, 864}, + DictWord{10, 10, 648}, + DictWord{11, 10, 671}, + DictWord{143, 10, 46}, + DictWord{135, 11, 1180}, + DictWord{ + 133, + 10, + 928, + }, + DictWord{4, 0, 148}, + DictWord{133, 0, 742}, + DictWord{11, 10, 986}, + DictWord{140, 10, 682}, + DictWord{133, 0, 523}, + DictWord{135, 11, 1743}, + DictWord{7, 0, 730}, + DictWord{18, 0, 144}, + DictWord{19, 0, 61}, + DictWord{8, 10, 44}, + DictWord{9, 10, 884}, + DictWord{10, 10, 580}, + DictWord{11, 10, 399}, + DictWord{ + 11, + 10, + 894, + }, + DictWord{143, 10, 122}, + DictWord{5, 11, 760}, + DictWord{7, 11, 542}, + DictWord{8, 11, 135}, + DictWord{136, 11, 496}, + DictWord{136, 0, 981}, + DictWord{133, 0, 111}, + DictWord{10, 0, 132}, + DictWord{11, 0, 191}, + DictWord{11, 0, 358}, + DictWord{139, 0, 460}, + DictWord{7, 11, 319}, + DictWord{7, 11, 355}, + DictWord{ + 7, + 11, + 763, + }, + DictWord{10, 11, 389}, + DictWord{145, 11, 43}, + DictWord{134, 0, 890}, + DictWord{134, 0, 1420}, + DictWord{136, 11, 557}, + DictWord{ + 133, + 10, + 518, + }, + DictWord{133, 0, 444}, + DictWord{135, 0, 1787}, + DictWord{135, 10, 1852}, + DictWord{8, 0, 123}, + DictWord{15, 0, 6}, + DictWord{144, 0, 7}, + DictWord{ + 6, + 0, + 2041, + }, + DictWord{10, 11, 38}, + DictWord{139, 11, 784}, + DictWord{136, 0, 932}, + DictWord{5, 0, 937}, + DictWord{135, 0, 100}, + DictWord{6, 0, 995}, + DictWord{ + 4, + 11, + 58, + }, + DictWord{5, 11, 286}, + DictWord{6, 11, 319}, + DictWord{7, 11, 402}, + DictWord{7, 11, 1254}, + DictWord{7, 11, 1903}, + DictWord{8, 11, 356}, + DictWord{ + 140, + 11, + 408, + }, + DictWord{4, 11, 389}, + DictWord{9, 11, 181}, + DictWord{9, 11, 255}, + DictWord{10, 11, 8}, + DictWord{10, 11, 29}, + DictWord{10, 11, 816}, + DictWord{ + 11, + 11, + 311, + }, + DictWord{11, 11, 561}, + DictWord{12, 11, 67}, + DictWord{141, 11, 181}, + DictWord{138, 0, 255}, + DictWord{5, 0, 138}, + DictWord{4, 10, 934}, + DictWord{ + 136, + 10, + 610, + }, + DictWord{4, 0, 965}, + DictWord{10, 0, 863}, + DictWord{138, 0, 898}, + DictWord{10, 10, 804}, + DictWord{138, 10, 832}, + DictWord{12, 0, 631}, + DictWord{ + 8, + 10, + 96, + }, + DictWord{9, 10, 36}, + DictWord{10, 10, 607}, + DictWord{11, 10, 423}, + DictWord{11, 10, 442}, + DictWord{12, 10, 309}, + DictWord{14, 10, 199}, + DictWord{ + 15, + 10, + 90, + }, + DictWord{145, 10, 110}, + DictWord{134, 0, 1394}, + DictWord{4, 0, 652}, + DictWord{8, 0, 320}, + DictWord{22, 0, 6}, + DictWord{22, 0, 16}, + DictWord{ + 9, + 10, + 13, + }, + DictWord{9, 10, 398}, + DictWord{9, 10, 727}, + DictWord{10, 10, 75}, + DictWord{10, 10, 184}, + DictWord{10, 10, 230}, + DictWord{10, 10, 564}, + DictWord{ + 10, + 10, + 569, + }, + DictWord{11, 10, 973}, + DictWord{12, 10, 70}, + DictWord{12, 10, 189}, + DictWord{13, 10, 57}, + DictWord{141, 10, 257}, + DictWord{6, 0, 897}, + DictWord{ + 134, + 0, + 1333, + }, + DictWord{4, 0, 692}, + DictWord{133, 0, 321}, + DictWord{133, 11, 373}, + DictWord{135, 0, 922}, + DictWord{5, 0, 619}, + DictWord{133, 0, 698}, + DictWord{ + 137, + 10, + 631, + }, + DictWord{5, 10, 345}, + DictWord{135, 10, 1016}, + DictWord{9, 0, 957}, + DictWord{9, 0, 1018}, + DictWord{12, 0, 828}, + DictWord{12, 0, 844}, + DictWord{ + 12, + 0, + 897, + }, + DictWord{12, 0, 901}, + DictWord{12, 0, 943}, + DictWord{15, 0, 180}, + DictWord{18, 0, 197}, + DictWord{18, 0, 200}, + DictWord{18, 0, 213}, + DictWord{ + 18, + 0, + 214, + }, + DictWord{146, 0, 226}, + DictWord{5, 0, 917}, + DictWord{134, 0, 1659}, + DictWord{135, 0, 1100}, + DictWord{134, 0, 1173}, + DictWord{134, 0, 1930}, + DictWord{5, 0, 251}, + DictWord{5, 0, 956}, + DictWord{8, 0, 268}, + DictWord{9, 0, 214}, + DictWord{146, 0, 142}, + DictWord{133, 10, 673}, + DictWord{137, 10, 850}, + DictWord{ + 4, + 10, + 287, + }, + DictWord{133, 10, 1018}, + DictWord{132, 11, 672}, + DictWord{5, 0, 346}, + DictWord{5, 0, 711}, + DictWord{8, 0, 390}, + DictWord{11, 11, 752}, + DictWord{139, 11, 885}, + DictWord{5, 10, 34}, + DictWord{10, 10, 724}, + DictWord{12, 10, 444}, + DictWord{13, 10, 354}, + DictWord{18, 10, 32}, + DictWord{23, 10, 24}, + DictWord{23, 10, 31}, + DictWord{152, 10, 5}, + DictWord{4, 11, 710}, + DictWord{134, 11, 606}, + DictWord{134, 0, 744}, + DictWord{134, 10, 382}, + DictWord{ + 133, + 11, + 145, + }, + DictWord{4, 10, 329}, + DictWord{7, 11, 884}, + DictWord{140, 11, 124}, + DictWord{4, 11, 467}, + DictWord{5, 11, 405}, + DictWord{134, 11, 544}, + DictWord{ + 9, + 10, + 846, + }, + DictWord{138, 10, 827}, + DictWord{133, 0, 624}, + DictWord{9, 11, 372}, + DictWord{15, 11, 2}, + DictWord{19, 11, 10}, + DictWord{147, 11, 18}, + DictWord{ + 4, + 11, + 387, + }, + DictWord{135, 11, 1288}, + DictWord{5, 0, 783}, + DictWord{7, 0, 1998}, + DictWord{135, 0, 2047}, + DictWord{132, 10, 906}, + DictWord{136, 10, 366}, + DictWord{135, 11, 550}, + DictWord{4, 10, 123}, + DictWord{4, 10, 649}, + DictWord{5, 10, 605}, + DictWord{7, 10, 1509}, + DictWord{136, 10, 36}, + DictWord{ + 134, + 0, + 1125, + }, + DictWord{132, 0, 594}, + DictWord{133, 10, 767}, + DictWord{135, 11, 1227}, + DictWord{136, 11, 467}, + DictWord{4, 11, 576}, + DictWord{ + 135, + 11, + 1263, + }, + DictWord{4, 0, 268}, + DictWord{7, 0, 1534}, + DictWord{135, 11, 1534}, + DictWord{4, 10, 273}, + DictWord{5, 10, 658}, + DictWord{5, 11, 919}, + DictWord{ + 5, + 10, + 995, + }, + DictWord{134, 11, 1673}, + DictWord{133, 0, 563}, + DictWord{134, 10, 72}, + DictWord{135, 10, 1345}, + DictWord{4, 11, 82}, + DictWord{5, 11, 333}, + DictWord{ + 5, + 11, + 904, + }, + DictWord{6, 11, 207}, + DictWord{7, 11, 325}, + DictWord{7, 11, 1726}, + DictWord{8, 11, 101}, + DictWord{10, 11, 778}, + DictWord{139, 11, 220}, + DictWord{5, 0, 37}, + DictWord{6, 0, 39}, + DictWord{6, 0, 451}, + DictWord{7, 0, 218}, + DictWord{7, 0, 667}, + DictWord{7, 0, 1166}, + DictWord{7, 0, 1687}, + DictWord{8, 0, 662}, + DictWord{16, 0, 2}, + DictWord{133, 10, 589}, + DictWord{134, 0, 1332}, + DictWord{133, 11, 903}, + DictWord{134, 0, 508}, + DictWord{5, 10, 117}, + DictWord{6, 10, 514}, + DictWord{6, 10, 541}, + DictWord{7, 10, 1164}, + DictWord{7, 10, 1436}, + DictWord{8, 10, 220}, + DictWord{8, 10, 648}, + DictWord{10, 10, 688}, + DictWord{11, 10, 560}, + DictWord{140, 11, 147}, + DictWord{6, 11, 555}, + DictWord{135, 11, 485}, + DictWord{133, 10, 686}, + DictWord{7, 0, 453}, + DictWord{7, 0, 635}, + DictWord{7, 0, 796}, + DictWord{8, 0, 331}, + DictWord{9, 0, 330}, + DictWord{9, 0, 865}, + DictWord{10, 0, 119}, + DictWord{10, 0, 235}, + DictWord{11, 0, 111}, + DictWord{11, 0, 129}, + DictWord{ + 11, + 0, + 240, + }, + DictWord{12, 0, 31}, + DictWord{12, 0, 66}, + DictWord{12, 0, 222}, + DictWord{12, 0, 269}, + DictWord{12, 0, 599}, + DictWord{12, 0, 684}, + DictWord{12, 0, 689}, + DictWord{12, 0, 691}, + DictWord{142, 0, 345}, + DictWord{135, 0, 1834}, + DictWord{4, 11, 705}, + DictWord{7, 11, 615}, + DictWord{138, 11, 251}, + DictWord{ + 136, + 11, + 345, + }, + DictWord{137, 0, 527}, + DictWord{6, 0, 98}, + DictWord{7, 0, 702}, + DictWord{135, 0, 991}, + DictWord{11, 0, 576}, + DictWord{14, 0, 74}, + DictWord{7, 10, 196}, + DictWord{10, 10, 765}, + DictWord{11, 10, 347}, + DictWord{11, 10, 552}, + DictWord{11, 10, 790}, + DictWord{12, 10, 263}, + DictWord{13, 10, 246}, + DictWord{ + 13, + 10, + 270, + }, + DictWord{13, 10, 395}, + DictWord{14, 10, 176}, + DictWord{14, 10, 190}, + DictWord{14, 10, 398}, + DictWord{14, 10, 412}, + DictWord{15, 10, 32}, + DictWord{ + 15, + 10, + 63, + }, + DictWord{16, 10, 88}, + DictWord{147, 10, 105}, + DictWord{134, 11, 90}, + DictWord{13, 0, 84}, + DictWord{141, 0, 122}, + DictWord{6, 0, 37}, + DictWord{ + 7, + 0, + 299, + }, + DictWord{7, 0, 1666}, + DictWord{8, 0, 195}, + DictWord{8, 0, 316}, + DictWord{9, 0, 178}, + DictWord{9, 0, 276}, + DictWord{9, 0, 339}, + DictWord{9, 0, 536}, + DictWord{ + 10, + 0, + 102, + }, + DictWord{10, 0, 362}, + DictWord{10, 0, 785}, + DictWord{11, 0, 55}, + DictWord{11, 0, 149}, + DictWord{11, 0, 773}, + DictWord{13, 0, 416}, + DictWord{ + 13, + 0, + 419, + }, + DictWord{14, 0, 38}, + DictWord{14, 0, 41}, + DictWord{142, 0, 210}, + DictWord{5, 10, 381}, + DictWord{135, 10, 1792}, + DictWord{7, 11, 813}, + DictWord{ + 12, + 11, + 497, + }, + DictWord{141, 11, 56}, + DictWord{7, 10, 616}, + DictWord{138, 10, 413}, + DictWord{133, 0, 645}, + DictWord{6, 11, 125}, + DictWord{135, 11, 1277}, + DictWord{132, 0, 290}, + DictWord{6, 0, 70}, + DictWord{7, 0, 1292}, + DictWord{10, 0, 762}, + DictWord{139, 0, 288}, + DictWord{6, 10, 120}, + DictWord{7, 10, 1188}, + DictWord{ + 7, + 10, + 1710, + }, + DictWord{8, 10, 286}, + DictWord{9, 10, 667}, + DictWord{11, 10, 592}, + DictWord{139, 10, 730}, + DictWord{135, 11, 1784}, + DictWord{7, 0, 1315}, + DictWord{135, 11, 1315}, + DictWord{134, 0, 1955}, + DictWord{135, 10, 1146}, + DictWord{7, 0, 131}, + DictWord{7, 0, 422}, + DictWord{8, 0, 210}, + DictWord{ + 140, + 0, + 573, + }, + DictWord{4, 10, 352}, + DictWord{135, 10, 687}, + DictWord{139, 0, 797}, + DictWord{143, 0, 38}, + DictWord{14, 0, 179}, + DictWord{15, 0, 151}, + DictWord{ + 150, + 0, + 11, + }, + DictWord{7, 0, 488}, + DictWord{4, 10, 192}, + DictWord{5, 10, 49}, + DictWord{6, 10, 200}, + DictWord{6, 10, 293}, + DictWord{134, 10, 1696}, + DictWord{ + 132, + 0, + 936, + }, + DictWord{135, 11, 703}, + DictWord{6, 11, 160}, + DictWord{7, 11, 1106}, + DictWord{9, 11, 770}, + DictWord{10, 11, 618}, + DictWord{11, 11, 112}, + DictWord{ + 140, + 11, + 413, + }, + DictWord{5, 0, 453}, + DictWord{134, 0, 441}, + DictWord{135, 0, 595}, + DictWord{132, 10, 650}, + DictWord{132, 10, 147}, + DictWord{6, 0, 991}, + DictWord{6, 0, 1182}, + DictWord{12, 11, 271}, + DictWord{145, 11, 109}, + DictWord{133, 10, 934}, + DictWord{140, 11, 221}, + DictWord{132, 0, 653}, + DictWord{ + 7, + 0, + 505, + }, + DictWord{135, 0, 523}, + DictWord{134, 0, 903}, + DictWord{135, 11, 479}, + DictWord{7, 11, 304}, + DictWord{9, 11, 646}, + DictWord{9, 11, 862}, + DictWord{ + 10, + 11, + 262, + }, + DictWord{11, 11, 696}, + DictWord{12, 11, 208}, + DictWord{15, 11, 79}, + DictWord{147, 11, 108}, + DictWord{146, 0, 80}, + DictWord{135, 11, 981}, + DictWord{142, 0, 432}, + DictWord{132, 0, 314}, + DictWord{137, 11, 152}, + DictWord{7, 0, 1368}, + DictWord{8, 0, 232}, + DictWord{8, 0, 361}, + DictWord{10, 0, 682}, + DictWord{138, 0, 742}, + DictWord{135, 11, 1586}, + DictWord{9, 0, 534}, + DictWord{4, 11, 434}, + DictWord{11, 11, 663}, + DictWord{12, 11, 210}, + DictWord{13, 11, 166}, + DictWord{13, 11, 310}, + DictWord{14, 11, 373}, + DictWord{147, 11, 43}, + DictWord{7, 11, 1091}, + DictWord{135, 11, 1765}, + DictWord{6, 11, 550}, + DictWord{ + 135, + 11, + 652, + }, + DictWord{137, 0, 27}, + DictWord{142, 0, 12}, + DictWord{4, 10, 637}, + DictWord{5, 11, 553}, + DictWord{7, 11, 766}, + DictWord{138, 11, 824}, + DictWord{ + 7, + 11, + 737, + }, + DictWord{8, 11, 298}, + DictWord{136, 11, 452}, + DictWord{7, 0, 736}, + DictWord{139, 0, 264}, + DictWord{134, 0, 1657}, + DictWord{133, 11, 292}, + DictWord{138, 11, 135}, + DictWord{6, 0, 844}, + DictWord{134, 0, 1117}, + DictWord{135, 0, 127}, + DictWord{9, 10, 867}, + DictWord{138, 10, 837}, + DictWord{ + 6, + 0, + 1184, + }, + DictWord{134, 0, 1208}, + DictWord{134, 0, 1294}, + DictWord{136, 0, 364}, + DictWord{6, 0, 1415}, + DictWord{7, 0, 1334}, + DictWord{11, 0, 125}, + DictWord{ + 6, + 10, + 170, + }, + DictWord{7, 11, 393}, + DictWord{8, 10, 395}, + DictWord{8, 10, 487}, + DictWord{10, 11, 603}, + DictWord{11, 11, 206}, + DictWord{141, 10, 147}, + DictWord{137, 11, 748}, + DictWord{4, 11, 912}, + DictWord{137, 11, 232}, + DictWord{4, 10, 535}, + DictWord{136, 10, 618}, + DictWord{137, 0, 792}, + DictWord{ + 7, + 11, + 1973, + }, + DictWord{136, 11, 716}, + DictWord{135, 11, 98}, + DictWord{5, 0, 909}, + DictWord{9, 0, 849}, + DictWord{138, 0, 805}, + DictWord{4, 0, 630}, + DictWord{ + 132, + 0, + 699, + }, + DictWord{5, 11, 733}, + DictWord{14, 11, 103}, + DictWord{150, 10, 23}, + DictWord{12, 11, 158}, + DictWord{18, 11, 8}, + DictWord{19, 11, 62}, + DictWord{ + 20, + 11, + 6, + }, + DictWord{22, 11, 4}, + DictWord{23, 11, 2}, + DictWord{151, 11, 9}, + DictWord{132, 0, 968}, + DictWord{132, 10, 778}, + DictWord{132, 10, 46}, + DictWord{5, 10, 811}, + DictWord{6, 10, 1679}, + DictWord{6, 10, 1714}, + DictWord{135, 10, 2032}, + DictWord{6, 0, 1446}, + DictWord{7, 10, 1458}, + DictWord{9, 10, 407}, + DictWord{ + 139, + 10, + 15, + }, + DictWord{7, 0, 206}, + DictWord{7, 0, 397}, + DictWord{7, 0, 621}, + DictWord{7, 0, 640}, + DictWord{8, 0, 124}, + DictWord{8, 0, 619}, + DictWord{9, 0, 305}, + DictWord{ + 9, + 0, + 643, + }, + DictWord{10, 0, 264}, + DictWord{10, 0, 628}, + DictWord{11, 0, 40}, + DictWord{12, 0, 349}, + DictWord{13, 0, 134}, + DictWord{13, 0, 295}, + DictWord{ + 14, + 0, + 155, + }, + DictWord{15, 0, 120}, + DictWord{18, 0, 105}, + DictWord{6, 10, 34}, + DictWord{7, 10, 1089}, + DictWord{8, 10, 708}, + DictWord{8, 10, 721}, + DictWord{9, 10, 363}, + DictWord{148, 10, 98}, + DictWord{4, 0, 262}, + DictWord{5, 0, 641}, + DictWord{135, 0, 342}, + DictWord{137, 11, 72}, + DictWord{4, 0, 99}, + DictWord{6, 0, 250}, + DictWord{ + 6, + 0, + 346, + }, + DictWord{8, 0, 127}, + DictWord{138, 0, 81}, + DictWord{132, 0, 915}, + DictWord{5, 0, 75}, + DictWord{9, 0, 517}, + DictWord{10, 0, 470}, + DictWord{12, 0, 155}, + DictWord{141, 0, 224}, + DictWord{132, 10, 462}, + DictWord{11, 11, 600}, + DictWord{11, 11, 670}, + DictWord{141, 11, 245}, + DictWord{142, 0, 83}, + DictWord{ + 5, + 10, + 73, + }, + DictWord{6, 10, 23}, + DictWord{134, 10, 338}, + DictWord{6, 0, 1031}, + DictWord{139, 11, 923}, + DictWord{7, 11, 164}, + DictWord{7, 11, 1571}, + DictWord{ + 9, + 11, + 107, + }, + DictWord{140, 11, 225}, + DictWord{134, 0, 1470}, + DictWord{133, 0, 954}, + DictWord{6, 0, 304}, + DictWord{8, 0, 418}, + DictWord{10, 0, 345}, + DictWord{ + 11, + 0, + 341, + }, + DictWord{139, 0, 675}, + DictWord{9, 0, 410}, + DictWord{139, 0, 425}, + DictWord{4, 11, 27}, + DictWord{5, 11, 484}, + DictWord{5, 11, 510}, + DictWord{6, 11, 434}, + DictWord{7, 11, 1000}, + DictWord{7, 11, 1098}, + DictWord{8, 11, 2}, + DictWord{136, 11, 200}, + DictWord{134, 0, 734}, + DictWord{140, 11, 257}, + DictWord{ + 7, + 10, + 725, + }, + DictWord{8, 10, 498}, + DictWord{139, 10, 268}, + DictWord{134, 0, 1822}, + DictWord{135, 0, 1798}, + DictWord{135, 10, 773}, + DictWord{132, 11, 460}, + DictWord{4, 11, 932}, + DictWord{133, 11, 891}, + DictWord{134, 0, 14}, + DictWord{132, 10, 583}, + DictWord{7, 10, 1462}, + DictWord{8, 11, 625}, + DictWord{ + 139, + 10, + 659, + }, + DictWord{5, 0, 113}, + DictWord{6, 0, 243}, + DictWord{6, 0, 1708}, + DictWord{7, 0, 1865}, + DictWord{11, 0, 161}, + DictWord{16, 0, 37}, + DictWord{17, 0, 99}, + DictWord{133, 10, 220}, + DictWord{134, 11, 76}, + DictWord{5, 11, 461}, + DictWord{135, 11, 1925}, + DictWord{140, 0, 69}, + DictWord{8, 11, 92}, + DictWord{ + 137, + 11, + 221, + }, + DictWord{139, 10, 803}, + DictWord{132, 10, 544}, + DictWord{4, 0, 274}, + DictWord{134, 0, 922}, + DictWord{132, 0, 541}, + DictWord{5, 0, 627}, + DictWord{ + 6, + 10, + 437, + }, + DictWord{6, 10, 564}, + DictWord{11, 10, 181}, + DictWord{141, 10, 183}, + DictWord{135, 10, 1192}, + DictWord{7, 0, 166}, + DictWord{132, 11, 763}, + DictWord{133, 11, 253}, + DictWord{134, 0, 849}, + DictWord{9, 11, 73}, + DictWord{10, 11, 110}, + DictWord{14, 11, 185}, + DictWord{145, 11, 119}, + DictWord{5, 11, 212}, + DictWord{12, 11, 35}, + DictWord{141, 11, 382}, + DictWord{133, 0, 717}, + DictWord{137, 0, 304}, + DictWord{136, 0, 600}, + DictWord{133, 0, 654}, + DictWord{ + 6, + 0, + 273, + }, + DictWord{10, 0, 188}, + DictWord{13, 0, 377}, + DictWord{146, 0, 77}, + DictWord{4, 10, 790}, + DictWord{5, 10, 273}, + DictWord{134, 10, 394}, + DictWord{ + 132, + 0, + 543, + }, + DictWord{135, 0, 410}, + DictWord{11, 0, 98}, + DictWord{11, 0, 524}, + DictWord{141, 0, 87}, + DictWord{132, 0, 941}, + DictWord{135, 11, 1175}, + DictWord{ + 4, + 0, + 250, + }, + DictWord{7, 0, 1612}, + DictWord{11, 0, 186}, + DictWord{12, 0, 133}, + DictWord{6, 10, 127}, + DictWord{7, 10, 1511}, + DictWord{8, 10, 613}, + DictWord{ + 12, + 10, + 495, + }, + DictWord{12, 10, 586}, + DictWord{12, 10, 660}, + DictWord{12, 10, 668}, + DictWord{14, 10, 385}, + DictWord{15, 10, 118}, + DictWord{17, 10, 20}, + DictWord{ + 146, + 10, + 98, + }, + DictWord{6, 0, 1785}, + DictWord{133, 11, 816}, + DictWord{134, 0, 1339}, + DictWord{7, 0, 961}, + DictWord{7, 0, 1085}, + DictWord{7, 0, 1727}, + DictWord{ + 8, + 0, + 462, + }, + DictWord{6, 10, 230}, + DictWord{135, 11, 1727}, + DictWord{9, 0, 636}, + DictWord{135, 10, 1954}, + DictWord{132, 0, 780}, + DictWord{5, 11, 869}, + DictWord{5, 11, 968}, + DictWord{6, 11, 1626}, + DictWord{8, 11, 734}, + DictWord{136, 11, 784}, + DictWord{4, 11, 542}, + DictWord{6, 11, 1716}, + DictWord{6, 11, 1727}, + DictWord{7, 11, 1082}, + DictWord{7, 11, 1545}, + DictWord{8, 11, 56}, + DictWord{8, 11, 118}, + DictWord{8, 11, 412}, + DictWord{8, 11, 564}, + DictWord{9, 11, 888}, + DictWord{9, 11, 908}, + DictWord{10, 11, 50}, + DictWord{10, 11, 423}, + DictWord{11, 11, 685}, + DictWord{11, 11, 697}, + DictWord{11, 11, 933}, + DictWord{12, 11, 299}, + DictWord{13, 11, 126}, + DictWord{13, 11, 136}, + DictWord{13, 11, 170}, + DictWord{141, 11, 190}, + DictWord{134, 11, 226}, + DictWord{4, 11, 232}, + DictWord{ + 9, + 11, + 202, + }, + DictWord{10, 11, 474}, + DictWord{140, 11, 433}, + DictWord{137, 11, 500}, + DictWord{5, 0, 529}, + DictWord{136, 10, 68}, + DictWord{132, 10, 654}, + DictWord{ + 4, + 10, + 156, + }, + DictWord{7, 10, 998}, + DictWord{7, 10, 1045}, + DictWord{7, 10, 1860}, + DictWord{9, 10, 48}, + DictWord{9, 10, 692}, + DictWord{11, 10, 419}, + DictWord{139, 10, 602}, + DictWord{7, 0, 1276}, + DictWord{8, 0, 474}, + DictWord{9, 0, 652}, + DictWord{6, 11, 108}, + DictWord{7, 11, 1003}, + DictWord{7, 11, 1181}, + DictWord{136, 11, 343}, + DictWord{7, 11, 1264}, + DictWord{7, 11, 1678}, + DictWord{11, 11, 945}, + DictWord{12, 11, 341}, + DictWord{12, 11, 471}, + DictWord{ + 140, + 11, + 569, + }, + DictWord{134, 11, 1712}, + DictWord{5, 0, 948}, + DictWord{12, 0, 468}, + DictWord{19, 0, 96}, + DictWord{148, 0, 24}, + DictWord{4, 11, 133}, + DictWord{ + 7, + 11, + 711, + }, + DictWord{7, 11, 1298}, + DictWord{7, 11, 1585}, + DictWord{135, 11, 1929}, + DictWord{6, 0, 753}, + DictWord{140, 0, 657}, + DictWord{139, 0, 941}, + DictWord{ + 6, + 11, + 99, + }, + DictWord{7, 11, 1808}, + DictWord{145, 11, 57}, + DictWord{6, 11, 574}, + DictWord{7, 11, 428}, + DictWord{7, 11, 1250}, + DictWord{10, 11, 669}, + DictWord{ + 11, + 11, + 485, + }, + DictWord{11, 11, 840}, + DictWord{12, 11, 300}, + DictWord{142, 11, 250}, + DictWord{4, 0, 532}, + DictWord{5, 0, 706}, + DictWord{135, 0, 662}, + DictWord{ + 5, + 0, + 837, + }, + DictWord{6, 0, 1651}, + DictWord{139, 0, 985}, + DictWord{7, 0, 1861}, + DictWord{9, 10, 197}, + DictWord{10, 10, 300}, + DictWord{12, 10, 473}, + DictWord{ + 13, + 10, + 90, + }, + DictWord{141, 10, 405}, + DictWord{137, 11, 252}, + DictWord{6, 11, 323}, + DictWord{135, 11, 1564}, + DictWord{4, 0, 330}, + DictWord{4, 0, 863}, + DictWord{7, 0, 933}, + DictWord{7, 0, 2012}, + DictWord{8, 0, 292}, + DictWord{7, 11, 461}, + DictWord{8, 11, 775}, + DictWord{138, 11, 435}, + DictWord{132, 10, 606}, + DictWord{ + 4, + 11, + 655, + }, + DictWord{7, 11, 850}, + DictWord{17, 11, 75}, + DictWord{146, 11, 137}, + DictWord{135, 0, 767}, + DictWord{7, 10, 1978}, + DictWord{136, 10, 676}, + DictWord{132, 0, 641}, + DictWord{135, 11, 1559}, + DictWord{134, 0, 1233}, + DictWord{137, 0, 242}, + DictWord{17, 0, 114}, + DictWord{4, 10, 361}, + DictWord{ + 133, + 10, + 315, + }, + DictWord{137, 0, 883}, + DictWord{132, 10, 461}, + DictWord{138, 0, 274}, + DictWord{134, 0, 2008}, + DictWord{134, 0, 1794}, + DictWord{4, 0, 703}, + DictWord{135, 0, 207}, + DictWord{12, 0, 285}, + DictWord{132, 10, 472}, + DictWord{132, 0, 571}, + DictWord{5, 0, 873}, + DictWord{5, 0, 960}, + DictWord{8, 0, 823}, + DictWord{9, 0, 881}, + DictWord{136, 11, 577}, + DictWord{7, 0, 617}, + DictWord{10, 0, 498}, + DictWord{11, 0, 501}, + DictWord{12, 0, 16}, + DictWord{140, 0, 150}, + DictWord{ + 138, + 10, + 747, + }, + DictWord{132, 0, 431}, + DictWord{133, 10, 155}, + DictWord{11, 0, 283}, + DictWord{11, 0, 567}, + DictWord{7, 10, 163}, + DictWord{8, 10, 319}, + DictWord{ + 9, + 10, + 402, + }, + DictWord{10, 10, 24}, + DictWord{10, 10, 681}, + DictWord{11, 10, 200}, + DictWord{12, 10, 253}, + DictWord{12, 10, 410}, + DictWord{142, 10, 219}, + DictWord{4, 11, 413}, + DictWord{5, 11, 677}, + DictWord{8, 11, 432}, + DictWord{140, 11, 280}, + DictWord{9, 0, 401}, + DictWord{5, 10, 475}, + DictWord{7, 10, 1780}, + DictWord{11, 10, 297}, + DictWord{11, 10, 558}, + DictWord{14, 10, 322}, + DictWord{147, 10, 76}, + DictWord{6, 0, 781}, + DictWord{9, 0, 134}, + DictWord{10, 0, 2}, + DictWord{ + 10, + 0, + 27, + }, + DictWord{10, 0, 333}, + DictWord{11, 0, 722}, + DictWord{143, 0, 1}, + DictWord{5, 0, 33}, + DictWord{6, 0, 470}, + DictWord{139, 0, 424}, + DictWord{ + 135, + 0, + 2006, + }, + DictWord{12, 0, 783}, + DictWord{135, 10, 1956}, + DictWord{136, 0, 274}, + DictWord{135, 0, 1882}, + DictWord{132, 0, 794}, + DictWord{135, 0, 1848}, + DictWord{5, 10, 944}, + DictWord{134, 10, 1769}, + DictWord{6, 0, 47}, + DictWord{7, 0, 90}, + DictWord{7, 0, 664}, + DictWord{7, 0, 830}, + DictWord{7, 0, 1380}, + DictWord{ + 7, + 0, + 2025, + }, + DictWord{8, 0, 448}, + DictWord{136, 0, 828}, + DictWord{132, 10, 144}, + DictWord{134, 0, 1199}, + DictWord{4, 11, 395}, + DictWord{139, 11, 762}, + DictWord{135, 11, 1504}, + DictWord{9, 0, 417}, + DictWord{137, 0, 493}, + DictWord{9, 11, 174}, + DictWord{10, 11, 164}, + DictWord{11, 11, 440}, + DictWord{11, 11, 841}, + DictWord{143, 11, 98}, + DictWord{134, 11, 426}, + DictWord{139, 11, 1002}, + DictWord{134, 0, 295}, + DictWord{134, 0, 816}, + DictWord{6, 10, 247}, + DictWord{ + 137, + 10, + 555, + }, + DictWord{133, 0, 1019}, + DictWord{4, 0, 620}, + DictWord{5, 11, 476}, + DictWord{10, 10, 280}, + DictWord{138, 10, 797}, + DictWord{139, 0, 464}, + DictWord{5, 11, 76}, + DictWord{6, 11, 458}, + DictWord{6, 11, 497}, + DictWord{7, 11, 764}, + DictWord{7, 11, 868}, + DictWord{9, 11, 658}, + DictWord{10, 11, 594}, + DictWord{ + 11, + 11, + 173, + }, + DictWord{11, 11, 566}, + DictWord{12, 11, 20}, + DictWord{12, 11, 338}, + DictWord{141, 11, 200}, + DictWord{134, 0, 208}, + DictWord{4, 11, 526}, + DictWord{7, 11, 1029}, + DictWord{135, 11, 1054}, + DictWord{132, 11, 636}, + DictWord{6, 11, 233}, + DictWord{7, 11, 660}, + DictWord{7, 11, 1124}, + DictWord{ + 17, + 11, + 31, + }, + DictWord{19, 11, 22}, + DictWord{151, 11, 14}, + DictWord{10, 0, 442}, + DictWord{133, 10, 428}, + DictWord{10, 0, 930}, + DictWord{140, 0, 778}, + DictWord{ + 6, + 0, + 68, + }, + DictWord{7, 0, 448}, + DictWord{7, 0, 1629}, + DictWord{7, 0, 1769}, + DictWord{7, 0, 1813}, + DictWord{8, 0, 442}, + DictWord{8, 0, 516}, + DictWord{9, 0, 710}, + DictWord{ + 10, + 0, + 282, + }, + DictWord{10, 0, 722}, + DictWord{7, 10, 1717}, + DictWord{138, 10, 546}, + DictWord{134, 0, 1128}, + DictWord{11, 0, 844}, + DictWord{12, 0, 104}, + DictWord{140, 0, 625}, + DictWord{4, 11, 432}, + DictWord{135, 11, 824}, + DictWord{138, 10, 189}, + DictWord{133, 0, 787}, + DictWord{133, 10, 99}, + DictWord{ + 4, + 11, + 279, + }, + DictWord{7, 11, 301}, + DictWord{137, 11, 362}, + DictWord{8, 0, 491}, + DictWord{4, 10, 397}, + DictWord{136, 10, 555}, + DictWord{4, 11, 178}, + DictWord{ + 133, + 11, + 399, + }, + DictWord{134, 0, 711}, + DictWord{144, 0, 9}, + DictWord{4, 0, 403}, + DictWord{5, 0, 441}, + DictWord{7, 0, 450}, + DictWord{10, 0, 840}, + DictWord{11, 0, 101}, + DictWord{12, 0, 193}, + DictWord{141, 0, 430}, + DictWord{135, 11, 1246}, + DictWord{12, 10, 398}, + DictWord{20, 10, 39}, + DictWord{21, 10, 11}, + DictWord{ + 150, + 10, + 41, + }, + DictWord{4, 10, 485}, + DictWord{7, 10, 353}, + DictWord{135, 10, 1523}, + DictWord{6, 10, 366}, + DictWord{7, 10, 1384}, + DictWord{7, 10, 1601}, + DictWord{ + 135, + 11, + 1912, + }, + DictWord{7, 0, 396}, + DictWord{10, 0, 160}, + DictWord{135, 11, 396}, + DictWord{137, 10, 282}, + DictWord{134, 11, 1692}, + DictWord{4, 10, 157}, + DictWord{5, 10, 471}, + DictWord{6, 11, 202}, + DictWord{10, 11, 448}, + DictWord{11, 11, 208}, + DictWord{12, 11, 360}, + DictWord{17, 11, 117}, + DictWord{ + 17, + 11, + 118, + }, + DictWord{18, 11, 27}, + DictWord{148, 11, 67}, + DictWord{133, 0, 679}, + DictWord{137, 0, 326}, + DictWord{136, 10, 116}, + DictWord{7, 11, 872}, + DictWord{ + 10, + 11, + 516, + }, + DictWord{139, 11, 167}, + DictWord{132, 11, 224}, + DictWord{5, 11, 546}, + DictWord{7, 11, 35}, + DictWord{8, 11, 11}, + DictWord{8, 11, 12}, + DictWord{ + 9, + 11, + 315, + }, + DictWord{9, 11, 533}, + DictWord{10, 11, 802}, + DictWord{11, 11, 166}, + DictWord{12, 11, 525}, + DictWord{142, 11, 243}, + DictWord{7, 0, 1128}, + DictWord{135, 11, 1920}, + DictWord{5, 11, 241}, + DictWord{8, 11, 242}, + DictWord{9, 11, 451}, + DictWord{10, 11, 667}, + DictWord{11, 11, 598}, + DictWord{ + 140, + 11, + 429, + }, + DictWord{6, 0, 737}, + DictWord{5, 10, 160}, + DictWord{7, 10, 363}, + DictWord{7, 10, 589}, + DictWord{10, 10, 170}, + DictWord{141, 10, 55}, + DictWord{ + 135, + 0, + 1796, + }, + DictWord{142, 11, 254}, + DictWord{4, 0, 574}, + DictWord{7, 0, 350}, + DictWord{7, 0, 1024}, + DictWord{8, 0, 338}, + DictWord{9, 0, 677}, + DictWord{138, 0, 808}, + DictWord{134, 0, 1096}, + DictWord{137, 11, 516}, + DictWord{7, 0, 405}, + DictWord{10, 0, 491}, + DictWord{4, 10, 108}, + DictWord{4, 11, 366}, + DictWord{ + 139, + 10, + 498, + }, + DictWord{11, 11, 337}, + DictWord{142, 11, 303}, + DictWord{134, 11, 1736}, + DictWord{7, 0, 1081}, + DictWord{140, 11, 364}, + DictWord{7, 10, 1005}, + DictWord{140, 10, 609}, + DictWord{7, 0, 1676}, + DictWord{4, 10, 895}, + DictWord{133, 10, 772}, + DictWord{135, 0, 2037}, + DictWord{6, 0, 1207}, + DictWord{ + 11, + 11, + 916, + }, + DictWord{142, 11, 419}, + DictWord{14, 11, 140}, + DictWord{148, 11, 41}, + DictWord{6, 11, 331}, + DictWord{136, 11, 623}, + DictWord{9, 0, 944}, + DictWord{ + 9, + 0, + 969, + }, + DictWord{9, 0, 1022}, + DictWord{12, 0, 913}, + DictWord{12, 0, 936}, + DictWord{15, 0, 177}, + DictWord{15, 0, 193}, + DictWord{4, 10, 926}, + DictWord{ + 133, + 10, + 983, + }, + DictWord{5, 0, 354}, + DictWord{135, 11, 506}, + DictWord{8, 0, 598}, + DictWord{9, 0, 664}, + DictWord{138, 0, 441}, + DictWord{4, 11, 640}, + DictWord{ + 133, + 11, + 513, + }, + DictWord{137, 0, 297}, + DictWord{132, 10, 538}, + DictWord{6, 10, 294}, + DictWord{7, 10, 1267}, + DictWord{136, 10, 624}, + DictWord{7, 0, 1772}, + DictWord{ + 7, + 11, + 1888, + }, + DictWord{8, 11, 289}, + DictWord{11, 11, 45}, + DictWord{12, 11, 278}, + DictWord{140, 11, 537}, + DictWord{135, 10, 1325}, + DictWord{138, 0, 751}, + DictWord{141, 0, 37}, + DictWord{134, 0, 1828}, + DictWord{132, 10, 757}, + DictWord{132, 11, 394}, + DictWord{6, 0, 257}, + DictWord{135, 0, 1522}, + DictWord{ + 4, + 0, + 582, + }, + DictWord{9, 0, 191}, + DictWord{135, 11, 1931}, + DictWord{7, 11, 574}, + DictWord{7, 11, 1719}, + DictWord{137, 11, 145}, + DictWord{132, 11, 658}, + DictWord{10, 0, 790}, + DictWord{132, 11, 369}, + DictWord{9, 11, 781}, + DictWord{10, 11, 144}, + DictWord{11, 11, 385}, + DictWord{13, 11, 161}, + DictWord{13, 11, 228}, + DictWord{13, 11, 268}, + DictWord{148, 11, 107}, + DictWord{8, 0, 469}, + DictWord{10, 0, 47}, + DictWord{136, 11, 374}, + DictWord{6, 0, 306}, + DictWord{7, 0, 1140}, + DictWord{7, 0, 1340}, + DictWord{8, 0, 133}, + DictWord{138, 0, 449}, + DictWord{139, 0, 1011}, + DictWord{7, 10, 1875}, + DictWord{139, 10, 124}, + DictWord{ + 4, + 11, + 344, + }, + DictWord{6, 11, 498}, + DictWord{139, 11, 323}, + DictWord{137, 0, 299}, + DictWord{132, 0, 837}, + DictWord{133, 11, 906}, + DictWord{5, 0, 329}, + DictWord{ + 8, + 0, + 260, + }, + DictWord{138, 0, 10}, + DictWord{134, 0, 1320}, + DictWord{4, 0, 657}, + DictWord{146, 0, 158}, + DictWord{135, 0, 1191}, + DictWord{152, 0, 7}, + DictWord{ + 6, + 0, + 1939, + }, + DictWord{8, 0, 974}, + DictWord{138, 0, 996}, + DictWord{135, 0, 1665}, + DictWord{11, 11, 126}, + DictWord{139, 11, 287}, + DictWord{143, 0, 8}, + DictWord{ + 14, + 11, + 149, + }, + DictWord{14, 11, 399}, + DictWord{143, 11, 57}, + DictWord{5, 0, 66}, + DictWord{7, 0, 1896}, + DictWord{136, 0, 288}, + DictWord{7, 0, 175}, + DictWord{ + 10, + 0, + 494, + }, + DictWord{5, 10, 150}, + DictWord{8, 10, 603}, + DictWord{9, 10, 593}, + DictWord{9, 10, 634}, + DictWord{10, 10, 173}, + DictWord{11, 10, 462}, + DictWord{ + 11, + 10, + 515, + }, + DictWord{13, 10, 216}, + DictWord{13, 10, 288}, + DictWord{142, 10, 400}, + DictWord{134, 0, 1643}, + DictWord{136, 11, 21}, + DictWord{4, 0, 21}, + DictWord{ + 5, + 0, + 91, + }, + DictWord{5, 0, 648}, + DictWord{5, 0, 750}, + DictWord{5, 0, 781}, + DictWord{6, 0, 54}, + DictWord{6, 0, 112}, + DictWord{6, 0, 402}, + DictWord{6, 0, 1732}, + DictWord{ + 7, + 0, + 315, + }, + DictWord{7, 0, 749}, + DictWord{7, 0, 1427}, + DictWord{7, 0, 1900}, + DictWord{9, 0, 78}, + DictWord{9, 0, 508}, + DictWord{10, 0, 611}, + DictWord{10, 0, 811}, + DictWord{11, 0, 510}, + DictWord{11, 0, 728}, + DictWord{13, 0, 36}, + DictWord{14, 0, 39}, + DictWord{16, 0, 83}, + DictWord{17, 0, 124}, + DictWord{148, 0, 30}, + DictWord{ + 4, + 0, + 668, + }, + DictWord{136, 0, 570}, + DictWord{10, 0, 322}, + DictWord{10, 0, 719}, + DictWord{139, 0, 407}, + DictWord{135, 11, 1381}, + DictWord{136, 11, 193}, + DictWord{12, 10, 108}, + DictWord{141, 10, 291}, + DictWord{132, 11, 616}, + DictWord{136, 11, 692}, + DictWord{8, 0, 125}, + DictWord{8, 0, 369}, + DictWord{8, 0, 524}, + DictWord{10, 0, 486}, + DictWord{11, 0, 13}, + DictWord{11, 0, 381}, + DictWord{11, 0, 736}, + DictWord{11, 0, 766}, + DictWord{11, 0, 845}, + DictWord{13, 0, 114}, + DictWord{ + 13, + 0, + 292, + }, + DictWord{142, 0, 47}, + DictWord{134, 0, 1247}, + DictWord{6, 0, 1684}, + DictWord{6, 0, 1731}, + DictWord{7, 0, 356}, + DictWord{8, 0, 54}, + DictWord{8, 0, 221}, + DictWord{9, 0, 225}, + DictWord{9, 0, 356}, + DictWord{10, 0, 77}, + DictWord{10, 0, 446}, + DictWord{10, 0, 731}, + DictWord{12, 0, 404}, + DictWord{141, 0, 491}, + DictWord{135, 10, 1777}, + DictWord{4, 11, 305}, + DictWord{4, 10, 493}, + DictWord{144, 10, 55}, + DictWord{4, 0, 951}, + DictWord{6, 0, 1809}, + DictWord{6, 0, 1849}, + DictWord{8, 0, 846}, + DictWord{8, 0, 866}, + DictWord{8, 0, 899}, + DictWord{10, 0, 896}, + DictWord{12, 0, 694}, + DictWord{142, 0, 468}, + DictWord{5, 11, 214}, + DictWord{ + 7, + 11, + 603, + }, + DictWord{8, 11, 611}, + DictWord{9, 11, 686}, + DictWord{10, 11, 88}, + DictWord{11, 11, 459}, + DictWord{11, 11, 496}, + DictWord{12, 11, 463}, + DictWord{ + 12, + 11, + 590, + }, + DictWord{13, 11, 0}, + DictWord{142, 11, 214}, + DictWord{132, 0, 411}, + DictWord{4, 0, 80}, + DictWord{133, 0, 44}, + DictWord{140, 11, 74}, + DictWord{ + 143, + 0, + 31, + }, + DictWord{7, 0, 669}, + DictWord{6, 10, 568}, + DictWord{7, 10, 1804}, + DictWord{8, 10, 362}, + DictWord{8, 10, 410}, + DictWord{8, 10, 830}, + DictWord{9, 10, 514}, + DictWord{11, 10, 649}, + DictWord{142, 10, 157}, + DictWord{7, 0, 673}, + DictWord{134, 11, 1703}, + DictWord{132, 10, 625}, + DictWord{134, 0, 1303}, + DictWord{ + 5, + 0, + 299, + }, + DictWord{135, 0, 1083}, + DictWord{138, 0, 704}, + DictWord{6, 0, 275}, + DictWord{7, 0, 408}, + DictWord{6, 10, 158}, + DictWord{7, 10, 129}, + DictWord{ + 7, + 10, + 181, + }, + DictWord{8, 10, 276}, + DictWord{8, 10, 377}, + DictWord{10, 10, 523}, + DictWord{11, 10, 816}, + DictWord{12, 10, 455}, + DictWord{13, 10, 303}, + DictWord{ + 142, + 10, + 135, + }, + DictWord{4, 0, 219}, + DictWord{7, 0, 367}, + DictWord{7, 0, 1713}, + DictWord{7, 0, 1761}, + DictWord{9, 0, 86}, + DictWord{9, 0, 537}, + DictWord{10, 0, 165}, + DictWord{12, 0, 219}, + DictWord{140, 0, 561}, + DictWord{8, 0, 216}, + DictWord{4, 10, 1}, + DictWord{4, 11, 737}, + DictWord{6, 11, 317}, + DictWord{7, 10, 1143}, + DictWord{ + 7, + 10, + 1463, + }, + DictWord{9, 10, 207}, + DictWord{9, 10, 390}, + DictWord{9, 10, 467}, + DictWord{10, 11, 98}, + DictWord{11, 11, 294}, + DictWord{11, 10, 836}, + DictWord{ + 12, + 11, + 60, + }, + DictWord{12, 11, 437}, + DictWord{13, 11, 64}, + DictWord{13, 11, 380}, + DictWord{142, 11, 430}, + DictWord{6, 11, 1758}, + DictWord{8, 11, 520}, + DictWord{9, 11, 345}, + DictWord{9, 11, 403}, + DictWord{142, 11, 350}, + DictWord{5, 11, 47}, + DictWord{10, 11, 242}, + DictWord{138, 11, 579}, + DictWord{5, 11, 139}, + DictWord{7, 11, 1168}, + DictWord{138, 11, 539}, + DictWord{135, 0, 1319}, + DictWord{4, 10, 295}, + DictWord{4, 10, 723}, + DictWord{5, 10, 895}, + DictWord{ + 7, + 10, + 1031, + }, + DictWord{8, 10, 199}, + DictWord{8, 10, 340}, + DictWord{9, 10, 153}, + DictWord{9, 10, 215}, + DictWord{10, 10, 21}, + DictWord{10, 10, 59}, + DictWord{ + 10, + 10, + 80, + }, + DictWord{10, 10, 224}, + DictWord{10, 10, 838}, + DictWord{11, 10, 229}, + DictWord{11, 10, 652}, + DictWord{12, 10, 192}, + DictWord{13, 10, 146}, + DictWord{ + 142, + 10, + 91, + }, + DictWord{140, 0, 428}, + DictWord{137, 10, 51}, + DictWord{133, 0, 514}, + DictWord{5, 10, 309}, + DictWord{140, 10, 211}, + DictWord{6, 0, 1010}, + DictWord{5, 10, 125}, + DictWord{8, 10, 77}, + DictWord{138, 10, 15}, + DictWord{4, 0, 55}, + DictWord{5, 0, 301}, + DictWord{6, 0, 571}, + DictWord{142, 0, 49}, + DictWord{ + 146, + 0, + 102, + }, + DictWord{136, 11, 370}, + DictWord{4, 11, 107}, + DictWord{7, 11, 613}, + DictWord{8, 11, 358}, + DictWord{8, 11, 439}, + DictWord{8, 11, 504}, + DictWord{ + 9, + 11, + 501, + }, + DictWord{10, 11, 383}, + DictWord{139, 11, 477}, + DictWord{132, 11, 229}, + DictWord{133, 0, 364}, + DictWord{133, 10, 439}, + DictWord{4, 11, 903}, + DictWord{135, 11, 1816}, + DictWord{11, 0, 379}, + DictWord{140, 10, 76}, + DictWord{4, 0, 76}, + DictWord{4, 0, 971}, + DictWord{7, 0, 1550}, + DictWord{9, 0, 306}, + DictWord{ + 9, + 0, + 430, + }, + DictWord{9, 0, 663}, + DictWord{10, 0, 683}, + DictWord{10, 0, 921}, + DictWord{11, 0, 427}, + DictWord{11, 0, 753}, + DictWord{12, 0, 334}, + DictWord{12, 0, 442}, + DictWord{14, 0, 258}, + DictWord{14, 0, 366}, + DictWord{143, 0, 131}, + DictWord{137, 0, 52}, + DictWord{4, 11, 47}, + DictWord{6, 11, 373}, + DictWord{7, 11, 452}, + DictWord{7, 11, 543}, + DictWord{7, 11, 1714}, + DictWord{7, 11, 1856}, + DictWord{9, 11, 6}, + DictWord{11, 11, 257}, + DictWord{139, 11, 391}, + DictWord{4, 10, 8}, + DictWord{ + 7, + 10, + 1152, + }, + DictWord{7, 10, 1153}, + DictWord{7, 10, 1715}, + DictWord{9, 10, 374}, + DictWord{10, 10, 478}, + DictWord{139, 10, 648}, + DictWord{4, 11, 785}, + DictWord{133, 11, 368}, + DictWord{135, 10, 1099}, + DictWord{135, 11, 860}, + DictWord{5, 11, 980}, + DictWord{134, 11, 1754}, + DictWord{134, 0, 1258}, + DictWord{ + 6, + 0, + 1058, + }, + DictWord{6, 0, 1359}, + DictWord{7, 11, 536}, + DictWord{7, 11, 1331}, + DictWord{136, 11, 143}, + DictWord{4, 0, 656}, + DictWord{135, 0, 779}, + DictWord{136, 10, 87}, + DictWord{5, 11, 19}, + DictWord{6, 11, 533}, + DictWord{146, 11, 126}, + DictWord{7, 0, 144}, + DictWord{138, 10, 438}, + DictWord{5, 11, 395}, + DictWord{5, 11, 951}, + DictWord{134, 11, 1776}, + DictWord{135, 0, 1373}, + DictWord{7, 0, 554}, + DictWord{7, 0, 605}, + DictWord{141, 0, 10}, + DictWord{4, 10, 69}, + DictWord{ + 5, + 10, + 122, + }, + DictWord{9, 10, 656}, + DictWord{138, 10, 464}, + DictWord{5, 10, 849}, + DictWord{134, 10, 1633}, + DictWord{5, 0, 838}, + DictWord{5, 0, 841}, + DictWord{134, 0, 1649}, + DictWord{133, 0, 1012}, + DictWord{139, 10, 499}, + DictWord{7, 10, 476}, + DictWord{7, 10, 1592}, + DictWord{138, 10, 87}, + DictWord{ + 6, + 0, + 251, + }, + DictWord{7, 0, 365}, + DictWord{7, 0, 1357}, + DictWord{7, 0, 1497}, + DictWord{8, 0, 154}, + DictWord{141, 0, 281}, + DictWord{132, 11, 441}, + DictWord{ + 132, + 11, + 695, + }, + DictWord{7, 11, 497}, + DictWord{9, 11, 387}, + DictWord{147, 11, 81}, + DictWord{133, 0, 340}, + DictWord{14, 10, 283}, + DictWord{142, 11, 283}, + DictWord{ + 134, + 0, + 810, + }, + DictWord{135, 11, 1894}, + DictWord{139, 0, 495}, + DictWord{5, 11, 284}, + DictWord{6, 11, 49}, + DictWord{6, 11, 350}, + DictWord{7, 11, 1}, + DictWord{ + 7, + 11, + 377, + }, + DictWord{7, 11, 1693}, + DictWord{8, 11, 18}, + DictWord{8, 11, 678}, + DictWord{9, 11, 161}, + DictWord{9, 11, 585}, + DictWord{9, 11, 671}, + DictWord{ + 9, + 11, + 839, + }, + DictWord{11, 11, 912}, + DictWord{141, 11, 427}, + DictWord{5, 10, 859}, + DictWord{7, 10, 1160}, + DictWord{8, 10, 107}, + DictWord{9, 10, 291}, + DictWord{ + 9, + 10, + 439, + }, + DictWord{10, 10, 663}, + DictWord{11, 10, 609}, + DictWord{140, 10, 197}, + DictWord{8, 0, 261}, + DictWord{9, 0, 144}, + DictWord{9, 0, 466}, + DictWord{ + 10, + 0, + 370, + }, + DictWord{12, 0, 470}, + DictWord{13, 0, 144}, + DictWord{142, 0, 348}, + DictWord{137, 0, 897}, + DictWord{6, 0, 248}, + DictWord{9, 0, 546}, + DictWord{10, 0, 535}, + DictWord{11, 0, 681}, + DictWord{141, 0, 135}, + DictWord{4, 0, 358}, + DictWord{135, 0, 1496}, + DictWord{134, 0, 567}, + DictWord{136, 0, 445}, + DictWord{ + 4, + 10, + 117, + }, + DictWord{6, 10, 372}, + DictWord{7, 10, 1905}, + DictWord{142, 10, 323}, + DictWord{4, 10, 722}, + DictWord{139, 10, 471}, + DictWord{6, 0, 697}, + DictWord{ + 134, + 0, + 996, + }, + DictWord{7, 11, 2007}, + DictWord{9, 11, 101}, + DictWord{9, 11, 450}, + DictWord{10, 11, 66}, + DictWord{10, 11, 842}, + DictWord{11, 11, 536}, + DictWord{ + 140, + 11, + 587, + }, + DictWord{132, 0, 577}, + DictWord{134, 0, 1336}, + DictWord{9, 10, 5}, + DictWord{12, 10, 216}, + DictWord{12, 10, 294}, + DictWord{12, 10, 298}, + DictWord{12, 10, 400}, + DictWord{12, 10, 518}, + DictWord{13, 10, 229}, + DictWord{143, 10, 139}, + DictWord{6, 0, 174}, + DictWord{138, 0, 917}, + DictWord{ + 134, + 10, + 1774, + }, + DictWord{5, 10, 12}, + DictWord{7, 10, 375}, + DictWord{9, 10, 88}, + DictWord{9, 10, 438}, + DictWord{11, 11, 62}, + DictWord{139, 10, 270}, + DictWord{ + 134, + 11, + 1766, + }, + DictWord{6, 11, 0}, + DictWord{7, 11, 84}, + DictWord{7, 10, 816}, + DictWord{7, 10, 1241}, + DictWord{9, 10, 283}, + DictWord{9, 10, 520}, + DictWord{10, 10, 213}, + DictWord{10, 10, 307}, + DictWord{10, 10, 463}, + DictWord{10, 10, 671}, + DictWord{10, 10, 746}, + DictWord{11, 10, 401}, + DictWord{11, 10, 794}, + DictWord{ + 11, + 11, + 895, + }, + DictWord{12, 10, 517}, + DictWord{17, 11, 11}, + DictWord{18, 10, 107}, + DictWord{147, 10, 115}, + DictWord{5, 0, 878}, + DictWord{133, 0, 972}, + DictWord{ + 6, + 11, + 1665, + }, + DictWord{7, 11, 256}, + DictWord{7, 11, 1388}, + DictWord{138, 11, 499}, + DictWord{4, 10, 258}, + DictWord{136, 10, 639}, + DictWord{4, 11, 22}, + DictWord{5, 11, 10}, + DictWord{6, 10, 22}, + DictWord{7, 11, 848}, + DictWord{7, 10, 903}, + DictWord{7, 10, 1963}, + DictWord{8, 11, 97}, + DictWord{138, 10, 577}, + DictWord{ + 5, + 10, + 681, + }, + DictWord{136, 10, 782}, + DictWord{133, 11, 481}, + DictWord{132, 0, 351}, + DictWord{4, 10, 664}, + DictWord{5, 10, 804}, + DictWord{139, 10, 1013}, + DictWord{6, 11, 134}, + DictWord{7, 11, 437}, + DictWord{7, 11, 959}, + DictWord{9, 11, 37}, + DictWord{14, 11, 285}, + DictWord{14, 11, 371}, + DictWord{144, 11, 60}, + DictWord{7, 11, 486}, + DictWord{8, 11, 155}, + DictWord{11, 11, 93}, + DictWord{140, 11, 164}, + DictWord{132, 0, 286}, + DictWord{7, 0, 438}, + DictWord{7, 0, 627}, + DictWord{7, 0, 1516}, + DictWord{8, 0, 40}, + DictWord{9, 0, 56}, + DictWord{9, 0, 294}, + DictWord{10, 0, 30}, + DictWord{11, 0, 969}, + DictWord{11, 0, 995}, + DictWord{146, 0, 148}, + DictWord{5, 11, 591}, + DictWord{135, 11, 337}, + DictWord{134, 0, 1950}, + DictWord{133, 10, 32}, + DictWord{138, 11, 500}, + DictWord{5, 11, 380}, + DictWord{ + 5, + 11, + 650, + }, + DictWord{136, 11, 310}, + DictWord{4, 11, 364}, + DictWord{7, 11, 1156}, + DictWord{7, 11, 1187}, + DictWord{137, 11, 409}, + DictWord{4, 0, 738}, + DictWord{134, 11, 482}, + DictWord{4, 11, 781}, + DictWord{6, 11, 487}, + DictWord{7, 11, 926}, + DictWord{8, 11, 263}, + DictWord{139, 11, 500}, + DictWord{135, 11, 418}, + DictWord{6, 0, 2047}, + DictWord{10, 0, 969}, + DictWord{4, 10, 289}, + DictWord{7, 10, 629}, + DictWord{7, 10, 1698}, + DictWord{7, 10, 1711}, + DictWord{ + 140, + 10, + 215, + }, + DictWord{6, 10, 450}, + DictWord{136, 10, 109}, + DictWord{134, 0, 818}, + DictWord{136, 10, 705}, + DictWord{133, 0, 866}, + DictWord{4, 11, 94}, + DictWord{ + 135, + 11, + 1265, + }, + DictWord{132, 11, 417}, + DictWord{134, 0, 1467}, + DictWord{135, 10, 1238}, + DictWord{4, 0, 972}, + DictWord{6, 0, 1851}, + DictWord{ + 134, + 0, + 1857, + }, + DictWord{134, 0, 355}, + DictWord{133, 0, 116}, + DictWord{132, 0, 457}, + DictWord{135, 11, 1411}, + DictWord{4, 11, 408}, + DictWord{4, 11, 741}, + DictWord{135, 11, 500}, + DictWord{134, 10, 26}, + DictWord{142, 11, 137}, + DictWord{5, 0, 527}, + DictWord{6, 0, 189}, + DictWord{7, 0, 859}, + DictWord{136, 0, 267}, + DictWord{11, 0, 104}, + DictWord{11, 0, 554}, + DictWord{15, 0, 60}, + DictWord{143, 0, 125}, + DictWord{134, 0, 1613}, + DictWord{4, 10, 414}, + DictWord{5, 10, 467}, + DictWord{ + 9, + 10, + 654, + }, + DictWord{10, 10, 451}, + DictWord{12, 10, 59}, + DictWord{141, 10, 375}, + DictWord{135, 10, 17}, + DictWord{134, 0, 116}, + DictWord{135, 11, 541}, + DictWord{135, 10, 955}, + DictWord{6, 11, 73}, + DictWord{135, 11, 177}, + DictWord{133, 11, 576}, + DictWord{134, 0, 886}, + DictWord{133, 0, 487}, + DictWord{ + 4, + 0, + 86, + }, + DictWord{5, 0, 667}, + DictWord{5, 0, 753}, + DictWord{6, 0, 316}, + DictWord{6, 0, 455}, + DictWord{135, 0, 946}, + DictWord{142, 11, 231}, + DictWord{150, 0, 45}, + DictWord{134, 0, 863}, + DictWord{134, 0, 1953}, + DictWord{6, 10, 280}, + DictWord{10, 10, 502}, + DictWord{11, 10, 344}, + DictWord{140, 10, 38}, + DictWord{4, 0, 79}, + DictWord{7, 0, 1773}, + DictWord{10, 0, 450}, + DictWord{11, 0, 589}, + DictWord{13, 0, 332}, + DictWord{13, 0, 493}, + DictWord{14, 0, 183}, + DictWord{14, 0, 334}, + DictWord{14, 0, 362}, + DictWord{14, 0, 368}, + DictWord{14, 0, 376}, + DictWord{14, 0, 379}, + DictWord{19, 0, 90}, + DictWord{19, 0, 103}, + DictWord{19, 0, 127}, + DictWord{ + 148, + 0, + 90, + }, + DictWord{5, 10, 45}, + DictWord{7, 10, 1161}, + DictWord{11, 10, 448}, + DictWord{11, 10, 880}, + DictWord{13, 10, 139}, + DictWord{13, 10, 407}, + DictWord{ + 15, + 10, + 16, + }, + DictWord{17, 10, 95}, + DictWord{18, 10, 66}, + DictWord{18, 10, 88}, + DictWord{18, 10, 123}, + DictWord{149, 10, 7}, + DictWord{136, 10, 777}, + DictWord{ + 4, + 10, + 410, + }, + DictWord{135, 10, 521}, + DictWord{135, 10, 1778}, + DictWord{135, 11, 538}, + DictWord{142, 0, 381}, + DictWord{133, 11, 413}, + DictWord{ + 134, + 0, + 1142, + }, + DictWord{6, 0, 1189}, + DictWord{136, 11, 495}, + DictWord{5, 0, 663}, + DictWord{6, 0, 1962}, + DictWord{134, 0, 2003}, + DictWord{7, 11, 54}, + DictWord{ + 8, + 11, + 312, + }, + DictWord{10, 11, 191}, + DictWord{10, 11, 614}, + DictWord{140, 11, 567}, + DictWord{132, 10, 436}, + DictWord{133, 0, 846}, + DictWord{10, 0, 528}, + DictWord{11, 0, 504}, + DictWord{7, 10, 1587}, + DictWord{135, 10, 1707}, + DictWord{5, 0, 378}, + DictWord{8, 0, 465}, + DictWord{9, 0, 286}, + DictWord{10, 0, 185}, + DictWord{ + 10, + 0, + 562, + }, + DictWord{10, 0, 635}, + DictWord{11, 0, 31}, + DictWord{11, 0, 393}, + DictWord{13, 0, 312}, + DictWord{18, 0, 65}, + DictWord{18, 0, 96}, + DictWord{147, 0, 89}, + DictWord{7, 0, 899}, + DictWord{14, 0, 325}, + DictWord{6, 11, 468}, + DictWord{7, 11, 567}, + DictWord{7, 11, 1478}, + DictWord{8, 11, 530}, + DictWord{142, 11, 290}, + DictWord{7, 0, 1880}, + DictWord{9, 0, 680}, + DictWord{139, 0, 798}, + DictWord{134, 0, 1770}, + DictWord{132, 0, 648}, + DictWord{150, 11, 35}, + DictWord{5, 0, 945}, + DictWord{6, 0, 1656}, + DictWord{6, 0, 1787}, + DictWord{7, 0, 167}, + DictWord{8, 0, 824}, + DictWord{9, 0, 391}, + DictWord{10, 0, 375}, + DictWord{139, 0, 185}, + DictWord{ + 6, + 11, + 484, + }, + DictWord{135, 11, 822}, + DictWord{134, 0, 2046}, + DictWord{7, 0, 1645}, + DictWord{8, 0, 352}, + DictWord{137, 0, 249}, + DictWord{132, 0, 152}, + DictWord{6, 0, 611}, + DictWord{135, 0, 1733}, + DictWord{6, 11, 1724}, + DictWord{135, 11, 2022}, + DictWord{133, 0, 1006}, + DictWord{141, 11, 96}, + DictWord{ + 5, + 0, + 420, + }, + DictWord{135, 0, 1449}, + DictWord{146, 11, 149}, + DictWord{135, 0, 832}, + DictWord{135, 10, 663}, + DictWord{133, 0, 351}, + DictWord{5, 0, 40}, + DictWord{ + 7, + 0, + 598, + }, + DictWord{7, 0, 1638}, + DictWord{8, 0, 78}, + DictWord{9, 0, 166}, + DictWord{9, 0, 640}, + DictWord{9, 0, 685}, + DictWord{9, 0, 773}, + DictWord{11, 0, 215}, + DictWord{13, 0, 65}, + DictWord{14, 0, 172}, + DictWord{14, 0, 317}, + DictWord{145, 0, 6}, + DictWord{8, 0, 60}, + DictWord{9, 0, 343}, + DictWord{139, 0, 769}, + DictWord{ + 134, + 0, + 1354, + }, + DictWord{132, 0, 724}, + DictWord{137, 0, 745}, + DictWord{132, 11, 474}, + DictWord{7, 0, 1951}, + DictWord{8, 0, 765}, + DictWord{8, 0, 772}, + DictWord{ + 140, + 0, + 671, + }, + DictWord{7, 0, 108}, + DictWord{8, 0, 219}, + DictWord{8, 0, 388}, + DictWord{9, 0, 775}, + DictWord{11, 0, 275}, + DictWord{140, 0, 464}, + DictWord{137, 0, 639}, + DictWord{135, 10, 503}, + DictWord{133, 11, 366}, + DictWord{5, 0, 15}, + DictWord{6, 0, 56}, + DictWord{7, 0, 1758}, + DictWord{8, 0, 500}, + DictWord{9, 0, 730}, + DictWord{ + 11, + 0, + 331, + }, + DictWord{13, 0, 150}, + DictWord{14, 0, 282}, + DictWord{5, 11, 305}, + DictWord{9, 11, 560}, + DictWord{141, 11, 208}, + DictWord{4, 10, 113}, + DictWord{ + 5, + 10, + 163, + }, + DictWord{5, 10, 735}, + DictWord{7, 10, 1009}, + DictWord{9, 10, 9}, + DictWord{9, 10, 771}, + DictWord{12, 10, 90}, + DictWord{13, 10, 138}, + DictWord{ + 13, + 10, + 410, + }, + DictWord{143, 10, 128}, + DictWord{4, 10, 324}, + DictWord{138, 10, 104}, + DictWord{135, 11, 466}, + DictWord{142, 11, 27}, + DictWord{134, 0, 1886}, + DictWord{5, 0, 205}, + DictWord{6, 0, 438}, + DictWord{9, 0, 711}, + DictWord{4, 11, 480}, + DictWord{6, 11, 167}, + DictWord{6, 11, 302}, + DictWord{6, 11, 1642}, + DictWord{ + 7, + 11, + 130, + }, + DictWord{7, 11, 656}, + DictWord{7, 11, 837}, + DictWord{7, 11, 1547}, + DictWord{7, 11, 1657}, + DictWord{8, 11, 429}, + DictWord{9, 11, 228}, + DictWord{ + 10, + 11, + 643, + }, + DictWord{13, 11, 289}, + DictWord{13, 11, 343}, + DictWord{147, 11, 101}, + DictWord{134, 0, 865}, + DictWord{6, 0, 2025}, + DictWord{136, 0, 965}, + DictWord{ + 7, + 11, + 278, + }, + DictWord{10, 11, 739}, + DictWord{11, 11, 708}, + DictWord{141, 11, 348}, + DictWord{133, 0, 534}, + DictWord{135, 11, 1922}, + DictWord{ + 137, + 0, + 691, + }, + DictWord{4, 10, 935}, + DictWord{133, 10, 823}, + DictWord{6, 0, 443}, + DictWord{9, 0, 237}, + DictWord{9, 0, 571}, + DictWord{9, 0, 695}, + DictWord{10, 0, 139}, + DictWord{11, 0, 715}, + DictWord{12, 0, 417}, + DictWord{141, 0, 421}, + DictWord{5, 10, 269}, + DictWord{7, 10, 434}, + DictWord{7, 10, 891}, + DictWord{8, 10, 339}, + DictWord{ + 9, + 10, + 702, + }, + DictWord{11, 10, 594}, + DictWord{11, 10, 718}, + DictWord{145, 10, 100}, + DictWord{6, 0, 1555}, + DictWord{7, 0, 878}, + DictWord{9, 10, 485}, + DictWord{141, 10, 264}, + DictWord{134, 10, 1713}, + DictWord{7, 10, 1810}, + DictWord{11, 10, 866}, + DictWord{12, 10, 103}, + DictWord{141, 10, 495}, + DictWord{ + 135, + 10, + 900, + }, + DictWord{6, 0, 1410}, + DictWord{9, 11, 316}, + DictWord{139, 11, 256}, + DictWord{4, 0, 995}, + DictWord{135, 0, 1033}, + DictWord{132, 0, 578}, + DictWord{10, 0, 881}, + DictWord{12, 0, 740}, + DictWord{12, 0, 743}, + DictWord{140, 0, 759}, + DictWord{132, 0, 822}, + DictWord{133, 0, 923}, + DictWord{142, 10, 143}, + DictWord{135, 11, 1696}, + DictWord{6, 11, 363}, + DictWord{7, 11, 1955}, + DictWord{136, 11, 725}, + DictWord{132, 0, 924}, + DictWord{133, 0, 665}, + DictWord{ + 135, + 10, + 2029, + }, + DictWord{135, 0, 1901}, + DictWord{4, 0, 265}, + DictWord{6, 0, 1092}, + DictWord{6, 0, 1417}, + DictWord{7, 0, 807}, + DictWord{135, 0, 950}, + DictWord{ + 5, + 0, + 93, + }, + DictWord{12, 0, 267}, + DictWord{141, 0, 498}, + DictWord{135, 0, 1451}, + DictWord{5, 11, 813}, + DictWord{135, 11, 2046}, + DictWord{5, 10, 625}, + DictWord{135, 10, 1617}, + DictWord{135, 0, 747}, + DictWord{6, 0, 788}, + DictWord{137, 0, 828}, + DictWord{7, 0, 184}, + DictWord{11, 0, 307}, + DictWord{11, 0, 400}, + DictWord{15, 0, 130}, + DictWord{5, 11, 712}, + DictWord{7, 11, 1855}, + DictWord{8, 10, 425}, + DictWord{8, 10, 693}, + DictWord{9, 10, 720}, + DictWord{10, 10, 380}, + DictWord{10, 10, 638}, + DictWord{11, 11, 17}, + DictWord{11, 10, 473}, + DictWord{12, 10, 61}, + DictWord{13, 11, 321}, + DictWord{144, 11, 67}, + DictWord{135, 0, 198}, + DictWord{6, 11, 320}, + DictWord{7, 11, 781}, + DictWord{7, 11, 1921}, + DictWord{9, 11, 55}, + DictWord{10, 11, 186}, + DictWord{10, 11, 273}, + DictWord{10, 11, 664}, + DictWord{10, 11, 801}, + DictWord{11, 11, 996}, + DictWord{11, 11, 997}, + DictWord{13, 11, 157}, + DictWord{142, 11, 170}, + DictWord{136, 11, 271}, + DictWord{ + 135, + 0, + 994, + }, + DictWord{7, 11, 103}, + DictWord{7, 11, 863}, + DictWord{11, 11, 184}, + DictWord{14, 11, 299}, + DictWord{145, 11, 62}, + DictWord{11, 10, 551}, + DictWord{142, 10, 159}, + DictWord{5, 0, 233}, + DictWord{5, 0, 320}, + DictWord{6, 0, 140}, + DictWord{8, 0, 295}, + DictWord{8, 0, 615}, + DictWord{136, 11, 615}, + DictWord{ + 133, + 0, + 978, + }, + DictWord{4, 0, 905}, + DictWord{6, 0, 1701}, + DictWord{137, 0, 843}, + DictWord{132, 10, 168}, + DictWord{4, 0, 974}, + DictWord{8, 0, 850}, + DictWord{ + 12, + 0, + 709, + }, + DictWord{12, 0, 768}, + DictWord{140, 0, 786}, + DictWord{135, 10, 91}, + DictWord{152, 0, 6}, + DictWord{138, 10, 532}, + DictWord{135, 10, 1884}, + DictWord{132, 0, 509}, + DictWord{6, 0, 1307}, + DictWord{135, 0, 273}, + DictWord{5, 11, 77}, + DictWord{7, 11, 1455}, + DictWord{10, 11, 843}, + DictWord{19, 11, 73}, + DictWord{150, 11, 5}, + DictWord{132, 11, 458}, + DictWord{135, 11, 1420}, + DictWord{6, 11, 109}, + DictWord{138, 11, 382}, + DictWord{6, 0, 201}, + DictWord{6, 11, 330}, + DictWord{7, 10, 70}, + DictWord{7, 11, 1084}, + DictWord{10, 10, 240}, + DictWord{11, 11, 142}, + DictWord{147, 10, 93}, + DictWord{7, 0, 1041}, + DictWord{ + 140, + 11, + 328, + }, + DictWord{133, 11, 354}, + DictWord{134, 0, 1040}, + DictWord{133, 0, 693}, + DictWord{134, 0, 774}, + DictWord{139, 0, 234}, + DictWord{132, 0, 336}, + DictWord{7, 0, 1399}, + DictWord{139, 10, 392}, + DictWord{20, 0, 22}, + DictWord{148, 11, 22}, + DictWord{5, 0, 802}, + DictWord{7, 0, 2021}, + DictWord{136, 0, 805}, + DictWord{ + 5, + 0, + 167, + }, + DictWord{5, 0, 899}, + DictWord{6, 0, 410}, + DictWord{137, 0, 777}, + DictWord{137, 0, 789}, + DictWord{134, 0, 1705}, + DictWord{7, 10, 655}, + DictWord{ + 135, + 10, + 1844, + }, + DictWord{4, 10, 145}, + DictWord{6, 10, 176}, + DictWord{7, 10, 395}, + DictWord{137, 10, 562}, + DictWord{132, 10, 501}, + DictWord{135, 0, 10}, + DictWord{5, 0, 11}, + DictWord{6, 0, 117}, + DictWord{6, 0, 485}, + DictWord{7, 0, 1133}, + DictWord{9, 0, 582}, + DictWord{9, 0, 594}, + DictWord{10, 0, 82}, + DictWord{11, 0, 21}, + DictWord{11, 0, 818}, + DictWord{12, 0, 535}, + DictWord{13, 0, 86}, + DictWord{20, 0, 91}, + DictWord{23, 0, 13}, + DictWord{134, 10, 509}, + DictWord{4, 0, 264}, + DictWord{ + 7, + 0, + 1067, + }, + DictWord{8, 0, 204}, + DictWord{8, 0, 385}, + DictWord{139, 0, 953}, + DictWord{139, 11, 737}, + DictWord{138, 0, 56}, + DictWord{134, 0, 1917}, + DictWord{ + 133, + 0, + 470, + }, + DictWord{10, 11, 657}, + DictWord{14, 11, 297}, + DictWord{142, 11, 361}, + DictWord{135, 11, 412}, + DictWord{7, 0, 1198}, + DictWord{7, 11, 1198}, + DictWord{8, 11, 556}, + DictWord{14, 11, 123}, + DictWord{14, 11, 192}, + DictWord{143, 11, 27}, + DictWord{7, 11, 1985}, + DictWord{14, 11, 146}, + DictWord{15, 11, 42}, + DictWord{16, 11, 23}, + DictWord{17, 11, 86}, + DictWord{146, 11, 17}, + DictWord{11, 0, 1015}, + DictWord{136, 11, 122}, + DictWord{4, 10, 114}, + DictWord{ + 9, + 10, + 492, + }, + DictWord{13, 10, 462}, + DictWord{142, 10, 215}, + DictWord{4, 10, 77}, + DictWord{5, 10, 361}, + DictWord{6, 10, 139}, + DictWord{6, 10, 401}, + DictWord{ + 6, + 10, + 404, + }, + DictWord{7, 10, 413}, + DictWord{7, 10, 715}, + DictWord{7, 10, 1716}, + DictWord{11, 10, 279}, + DictWord{12, 10, 179}, + DictWord{12, 10, 258}, + DictWord{ + 13, + 10, + 244, + }, + DictWord{142, 10, 358}, + DictWord{134, 10, 1717}, + DictWord{7, 10, 1061}, + DictWord{8, 10, 82}, + DictWord{11, 10, 250}, + DictWord{12, 10, 420}, + DictWord{141, 10, 184}, + DictWord{133, 0, 715}, + DictWord{135, 10, 724}, + DictWord{9, 0, 919}, + DictWord{9, 0, 922}, + DictWord{9, 0, 927}, + DictWord{9, 0, 933}, + DictWord{9, 0, 962}, + DictWord{9, 0, 1000}, + DictWord{9, 0, 1002}, + DictWord{9, 0, 1021}, + DictWord{12, 0, 890}, + DictWord{12, 0, 907}, + DictWord{12, 0, 930}, + DictWord{ + 15, + 0, + 207, + }, + DictWord{15, 0, 228}, + DictWord{15, 0, 238}, + DictWord{149, 0, 61}, + DictWord{8, 0, 794}, + DictWord{9, 0, 400}, + DictWord{10, 0, 298}, + DictWord{142, 0, 228}, + DictWord{5, 11, 430}, + DictWord{5, 11, 932}, + DictWord{6, 11, 131}, + DictWord{7, 11, 417}, + DictWord{9, 11, 522}, + DictWord{11, 11, 314}, + DictWord{141, 11, 390}, + DictWord{132, 0, 867}, + DictWord{8, 0, 724}, + DictWord{132, 11, 507}, + DictWord{137, 11, 261}, + DictWord{4, 11, 343}, + DictWord{133, 11, 511}, + DictWord{ + 6, + 0, + 190, + }, + DictWord{7, 0, 768}, + DictWord{135, 0, 1170}, + DictWord{6, 10, 513}, + DictWord{135, 10, 1052}, + DictWord{7, 11, 455}, + DictWord{138, 11, 591}, + DictWord{134, 0, 1066}, + DictWord{137, 10, 899}, + DictWord{14, 0, 67}, + DictWord{147, 0, 60}, + DictWord{4, 0, 948}, + DictWord{18, 0, 174}, + DictWord{146, 0, 176}, + DictWord{135, 0, 1023}, + DictWord{7, 10, 1417}, + DictWord{12, 10, 382}, + DictWord{17, 10, 48}, + DictWord{152, 10, 12}, + DictWord{134, 11, 575}, + DictWord{ + 132, + 0, + 764, + }, + DictWord{6, 10, 545}, + DictWord{7, 10, 565}, + DictWord{7, 10, 1669}, + DictWord{10, 10, 114}, + DictWord{11, 10, 642}, + DictWord{140, 10, 618}, + DictWord{ + 6, + 0, + 137, + }, + DictWord{9, 0, 75}, + DictWord{9, 0, 253}, + DictWord{10, 0, 194}, + DictWord{138, 0, 444}, + DictWord{4, 0, 756}, + DictWord{133, 10, 5}, + DictWord{8, 0, 1008}, + DictWord{135, 10, 192}, + DictWord{132, 0, 842}, + DictWord{11, 0, 643}, + DictWord{12, 0, 115}, + DictWord{136, 10, 763}, + DictWord{139, 0, 67}, + DictWord{ + 133, + 10, + 759, + }, + DictWord{4, 0, 821}, + DictWord{5, 0, 760}, + DictWord{7, 0, 542}, + DictWord{8, 0, 135}, + DictWord{8, 0, 496}, + DictWord{135, 11, 580}, + DictWord{7, 10, 370}, + DictWord{7, 10, 1007}, + DictWord{7, 10, 1177}, + DictWord{135, 10, 1565}, + DictWord{135, 10, 1237}, + DictWord{140, 0, 736}, + DictWord{7, 0, 319}, + DictWord{ + 7, + 0, + 355, + }, + DictWord{7, 0, 763}, + DictWord{10, 0, 389}, + DictWord{145, 0, 43}, + DictWord{8, 11, 333}, + DictWord{138, 11, 182}, + DictWord{4, 10, 87}, + DictWord{5, 10, 250}, + DictWord{141, 10, 298}, + DictWord{138, 0, 786}, + DictWord{134, 0, 2044}, + DictWord{8, 11, 330}, + DictWord{140, 11, 477}, + DictWord{135, 11, 1338}, + DictWord{132, 11, 125}, + DictWord{134, 0, 1030}, + DictWord{134, 0, 1083}, + DictWord{132, 11, 721}, + DictWord{135, 10, 814}, + DictWord{7, 11, 776}, + DictWord{ + 8, + 11, + 145, + }, + DictWord{147, 11, 56}, + DictWord{134, 0, 1226}, + DictWord{4, 10, 57}, + DictWord{7, 10, 1195}, + DictWord{7, 10, 1438}, + DictWord{7, 10, 1548}, + DictWord{ + 7, + 10, + 1835, + }, + DictWord{7, 10, 1904}, + DictWord{9, 10, 757}, + DictWord{10, 10, 604}, + DictWord{139, 10, 519}, + DictWord{7, 11, 792}, + DictWord{8, 11, 147}, + DictWord{10, 11, 821}, + DictWord{139, 11, 1021}, + DictWord{137, 11, 797}, + DictWord{4, 0, 58}, + DictWord{5, 0, 286}, + DictWord{6, 0, 319}, + DictWord{7, 0, 402}, + DictWord{ + 7, + 0, + 1254, + }, + DictWord{7, 0, 1903}, + DictWord{8, 0, 356}, + DictWord{140, 0, 408}, + DictWord{4, 0, 389}, + DictWord{4, 0, 815}, + DictWord{9, 0, 181}, + DictWord{9, 0, 255}, + DictWord{10, 0, 8}, + DictWord{10, 0, 29}, + DictWord{10, 0, 816}, + DictWord{11, 0, 311}, + DictWord{11, 0, 561}, + DictWord{12, 0, 67}, + DictWord{141, 0, 181}, + DictWord{ + 7, + 11, + 1472, + }, + DictWord{135, 11, 1554}, + DictWord{7, 11, 1071}, + DictWord{7, 11, 1541}, + DictWord{7, 11, 1767}, + DictWord{7, 11, 1806}, + DictWord{7, 11, 1999}, + DictWord{9, 11, 248}, + DictWord{10, 11, 400}, + DictWord{11, 11, 162}, + DictWord{11, 11, 178}, + DictWord{11, 11, 242}, + DictWord{12, 11, 605}, + DictWord{ + 15, + 11, + 26, + }, + DictWord{144, 11, 44}, + DictWord{5, 11, 168}, + DictWord{5, 11, 930}, + DictWord{8, 11, 74}, + DictWord{9, 11, 623}, + DictWord{12, 11, 500}, + DictWord{ + 12, + 11, + 579, + }, + DictWord{13, 11, 41}, + DictWord{143, 11, 93}, + DictWord{6, 11, 220}, + DictWord{7, 11, 1101}, + DictWord{141, 11, 105}, + DictWord{5, 0, 474}, + DictWord{ + 7, + 0, + 507, + }, + DictWord{4, 10, 209}, + DictWord{7, 11, 507}, + DictWord{135, 10, 902}, + DictWord{132, 0, 427}, + DictWord{6, 0, 413}, + DictWord{7, 10, 335}, + DictWord{ + 7, + 10, + 1437, + }, + DictWord{7, 10, 1668}, + DictWord{8, 10, 553}, + DictWord{8, 10, 652}, + DictWord{8, 10, 656}, + DictWord{9, 10, 558}, + DictWord{11, 10, 743}, + DictWord{ + 149, + 10, + 18, + }, + DictWord{132, 0, 730}, + DictWord{6, 11, 19}, + DictWord{7, 11, 1413}, + DictWord{139, 11, 428}, + DictWord{133, 0, 373}, + DictWord{132, 10, 559}, + DictWord{7, 11, 96}, + DictWord{8, 11, 401}, + DictWord{137, 11, 896}, + DictWord{7, 0, 799}, + DictWord{7, 0, 1972}, + DictWord{5, 10, 1017}, + DictWord{138, 10, 511}, + DictWord{135, 0, 1793}, + DictWord{7, 11, 1961}, + DictWord{7, 11, 1965}, + DictWord{8, 11, 702}, + DictWord{136, 11, 750}, + DictWord{8, 11, 150}, + DictWord{8, 11, 737}, + DictWord{140, 11, 366}, + DictWord{132, 0, 322}, + DictWord{133, 10, 709}, + DictWord{8, 11, 800}, + DictWord{9, 11, 148}, + DictWord{9, 11, 872}, + DictWord{ + 9, + 11, + 890, + }, + DictWord{11, 11, 309}, + DictWord{11, 11, 1001}, + DictWord{13, 11, 267}, + DictWord{141, 11, 323}, + DictWord{134, 10, 1745}, + DictWord{7, 0, 290}, + DictWord{136, 10, 206}, + DictWord{7, 0, 1651}, + DictWord{145, 0, 89}, + DictWord{139, 0, 2}, + DictWord{132, 0, 672}, + DictWord{6, 0, 1860}, + DictWord{8, 0, 905}, + DictWord{ + 10, + 0, + 844, + }, + DictWord{10, 0, 846}, + DictWord{10, 0, 858}, + DictWord{12, 0, 699}, + DictWord{12, 0, 746}, + DictWord{140, 0, 772}, + DictWord{135, 11, 424}, + DictWord{133, 11, 547}, + DictWord{133, 0, 737}, + DictWord{5, 11, 490}, + DictWord{6, 11, 615}, + DictWord{6, 11, 620}, + DictWord{135, 11, 683}, + DictWord{6, 0, 746}, + DictWord{134, 0, 1612}, + DictWord{132, 10, 776}, + DictWord{9, 11, 385}, + DictWord{149, 11, 17}, + DictWord{133, 0, 145}, + DictWord{135, 10, 1272}, + DictWord{ + 7, + 0, + 884, + }, + DictWord{140, 0, 124}, + DictWord{4, 0, 387}, + DictWord{135, 0, 1288}, + DictWord{5, 11, 133}, + DictWord{136, 10, 406}, + DictWord{136, 11, 187}, + DictWord{ + 6, + 0, + 679, + }, + DictWord{8, 11, 8}, + DictWord{138, 11, 0}, + DictWord{135, 0, 550}, + DictWord{135, 11, 798}, + DictWord{136, 11, 685}, + DictWord{7, 11, 1086}, + DictWord{145, 11, 46}, + DictWord{8, 10, 175}, + DictWord{10, 10, 168}, + DictWord{138, 10, 573}, + DictWord{135, 0, 1305}, + DictWord{4, 0, 576}, + DictWord{ + 135, + 0, + 1263, + }, + DictWord{6, 0, 686}, + DictWord{134, 0, 1563}, + DictWord{134, 0, 607}, + DictWord{5, 0, 919}, + DictWord{134, 0, 1673}, + DictWord{148, 0, 37}, + DictWord{ + 8, + 11, + 774, + }, + DictWord{10, 11, 670}, + DictWord{140, 11, 51}, + DictWord{133, 10, 784}, + DictWord{139, 10, 882}, + DictWord{4, 0, 82}, + DictWord{5, 0, 333}, + DictWord{ + 5, + 0, + 904, + }, + DictWord{6, 0, 207}, + DictWord{7, 0, 325}, + DictWord{7, 0, 1726}, + DictWord{8, 0, 101}, + DictWord{10, 0, 778}, + DictWord{139, 0, 220}, + DictWord{135, 11, 371}, + DictWord{132, 0, 958}, + DictWord{133, 0, 903}, + DictWord{4, 11, 127}, + DictWord{5, 11, 350}, + DictWord{6, 11, 356}, + DictWord{8, 11, 426}, + DictWord{9, 11, 572}, + DictWord{10, 11, 247}, + DictWord{139, 11, 312}, + DictWord{140, 0, 147}, + DictWord{6, 11, 59}, + DictWord{7, 11, 885}, + DictWord{9, 11, 603}, + DictWord{ + 141, + 11, + 397, + }, + DictWord{10, 0, 367}, + DictWord{9, 10, 14}, + DictWord{9, 10, 441}, + DictWord{139, 10, 9}, + DictWord{11, 10, 966}, + DictWord{12, 10, 287}, + DictWord{ + 13, + 10, + 342, + }, + DictWord{13, 10, 402}, + DictWord{15, 10, 110}, + DictWord{143, 10, 163}, + DictWord{134, 0, 690}, + DictWord{132, 0, 705}, + DictWord{9, 0, 651}, + DictWord{ + 11, + 0, + 971, + }, + DictWord{13, 0, 273}, + DictWord{7, 10, 1428}, + DictWord{7, 10, 1640}, + DictWord{7, 10, 1867}, + DictWord{9, 10, 169}, + DictWord{9, 10, 182}, + DictWord{ + 9, + 10, + 367, + }, + DictWord{9, 10, 478}, + DictWord{9, 10, 506}, + DictWord{9, 10, 551}, + DictWord{9, 10, 557}, + DictWord{9, 10, 648}, + DictWord{9, 10, 697}, + DictWord{ + 9, + 10, + 705, + }, + DictWord{9, 10, 725}, + DictWord{9, 10, 787}, + DictWord{9, 10, 794}, + DictWord{10, 10, 198}, + DictWord{10, 10, 214}, + DictWord{10, 10, 267}, + DictWord{ + 10, + 10, + 275, + }, + DictWord{10, 10, 456}, + DictWord{10, 10, 551}, + DictWord{10, 10, 561}, + DictWord{10, 10, 613}, + DictWord{10, 10, 627}, + DictWord{10, 10, 668}, + DictWord{10, 10, 675}, + DictWord{10, 10, 691}, + DictWord{10, 10, 695}, + DictWord{10, 10, 707}, + DictWord{10, 10, 715}, + DictWord{11, 10, 183}, + DictWord{ + 11, + 10, + 201, + }, + DictWord{11, 10, 262}, + DictWord{11, 10, 352}, + DictWord{11, 10, 439}, + DictWord{11, 10, 493}, + DictWord{11, 10, 572}, + DictWord{11, 10, 591}, + DictWord{ + 11, + 10, + 608, + }, + DictWord{11, 10, 611}, + DictWord{11, 10, 646}, + DictWord{11, 10, 674}, + DictWord{11, 10, 711}, + DictWord{11, 10, 751}, + DictWord{11, 10, 761}, + DictWord{11, 10, 776}, + DictWord{11, 10, 785}, + DictWord{11, 10, 850}, + DictWord{11, 10, 853}, + DictWord{11, 10, 862}, + DictWord{11, 10, 865}, + DictWord{ + 11, + 10, + 868, + }, + DictWord{11, 10, 875}, + DictWord{11, 10, 898}, + DictWord{11, 10, 902}, + DictWord{11, 10, 903}, + DictWord{11, 10, 910}, + DictWord{11, 10, 932}, + DictWord{ + 11, + 10, + 942, + }, + DictWord{11, 10, 957}, + DictWord{11, 10, 967}, + DictWord{11, 10, 972}, + DictWord{12, 10, 148}, + DictWord{12, 10, 195}, + DictWord{12, 10, 220}, + DictWord{12, 10, 237}, + DictWord{12, 10, 318}, + DictWord{12, 10, 339}, + DictWord{12, 10, 393}, + DictWord{12, 10, 445}, + DictWord{12, 10, 450}, + DictWord{ + 12, + 10, + 474, + }, + DictWord{12, 10, 505}, + DictWord{12, 10, 509}, + DictWord{12, 10, 533}, + DictWord{12, 10, 591}, + DictWord{12, 10, 594}, + DictWord{12, 10, 597}, + DictWord{ + 12, + 10, + 621, + }, + DictWord{12, 10, 633}, + DictWord{12, 10, 642}, + DictWord{13, 10, 59}, + DictWord{13, 10, 60}, + DictWord{13, 10, 145}, + DictWord{13, 10, 239}, + DictWord{13, 10, 250}, + DictWord{13, 10, 329}, + DictWord{13, 10, 344}, + DictWord{13, 10, 365}, + DictWord{13, 10, 372}, + DictWord{13, 10, 387}, + DictWord{ + 13, + 10, + 403, + }, + DictWord{13, 10, 414}, + DictWord{13, 10, 456}, + DictWord{13, 10, 470}, + DictWord{13, 10, 478}, + DictWord{13, 10, 483}, + DictWord{13, 10, 489}, + DictWord{ + 14, + 10, + 55, + }, + DictWord{14, 10, 57}, + DictWord{14, 10, 81}, + DictWord{14, 10, 90}, + DictWord{14, 10, 148}, + DictWord{14, 10, 239}, + DictWord{14, 10, 266}, + DictWord{ + 14, + 10, + 321, + }, + DictWord{14, 10, 326}, + DictWord{14, 10, 327}, + DictWord{14, 10, 330}, + DictWord{14, 10, 347}, + DictWord{14, 10, 355}, + DictWord{14, 10, 401}, + DictWord{14, 10, 404}, + DictWord{14, 10, 411}, + DictWord{14, 10, 414}, + DictWord{14, 10, 416}, + DictWord{14, 10, 420}, + DictWord{15, 10, 61}, + DictWord{ + 15, + 10, + 74, + }, + DictWord{15, 10, 87}, + DictWord{15, 10, 88}, + DictWord{15, 10, 94}, + DictWord{15, 10, 96}, + DictWord{15, 10, 116}, + DictWord{15, 10, 149}, + DictWord{ + 15, + 10, + 154, + }, + DictWord{16, 10, 50}, + DictWord{16, 10, 63}, + DictWord{16, 10, 73}, + DictWord{17, 10, 2}, + DictWord{17, 10, 66}, + DictWord{17, 10, 92}, + DictWord{17, 10, 103}, + DictWord{17, 10, 112}, + DictWord{17, 10, 120}, + DictWord{18, 10, 50}, + DictWord{18, 10, 54}, + DictWord{18, 10, 82}, + DictWord{18, 10, 86}, + DictWord{18, 10, 90}, + DictWord{18, 10, 111}, + DictWord{18, 10, 115}, + DictWord{18, 10, 156}, + DictWord{19, 10, 40}, + DictWord{19, 10, 79}, + DictWord{20, 10, 78}, + DictWord{149, 10, 22}, + DictWord{7, 0, 887}, + DictWord{5, 10, 161}, + DictWord{135, 10, 839}, + DictWord{142, 11, 98}, + DictWord{134, 0, 90}, + DictWord{138, 11, 356}, + DictWord{ + 135, + 11, + 441, + }, + DictWord{6, 11, 111}, + DictWord{7, 11, 4}, + DictWord{8, 11, 163}, + DictWord{8, 11, 776}, + DictWord{138, 11, 566}, + DictWord{134, 0, 908}, + DictWord{ + 134, + 0, + 1261, + }, + DictWord{7, 0, 813}, + DictWord{12, 0, 497}, + DictWord{141, 0, 56}, + DictWord{134, 0, 1235}, + DictWord{135, 0, 429}, + DictWord{135, 11, 1994}, + DictWord{138, 0, 904}, + DictWord{6, 0, 125}, + DictWord{7, 0, 1277}, + DictWord{137, 0, 772}, + DictWord{151, 0, 12}, + DictWord{4, 0, 841}, + DictWord{5, 0, 386}, + DictWord{ + 133, + 11, + 386, + }, + DictWord{5, 11, 297}, + DictWord{135, 11, 1038}, + DictWord{6, 0, 860}, + DictWord{6, 0, 1069}, + DictWord{135, 11, 309}, + DictWord{136, 0, 946}, + DictWord{135, 10, 1814}, + DictWord{141, 11, 418}, + DictWord{136, 11, 363}, + DictWord{10, 0, 768}, + DictWord{139, 0, 787}, + DictWord{22, 11, 30}, + DictWord{ + 150, + 11, + 33, + }, + DictWord{6, 0, 160}, + DictWord{7, 0, 1106}, + DictWord{9, 0, 770}, + DictWord{11, 0, 112}, + DictWord{140, 0, 413}, + DictWord{11, 11, 216}, + DictWord{ + 139, + 11, + 340, + }, + DictWord{136, 10, 139}, + DictWord{135, 11, 1390}, + DictWord{135, 11, 808}, + DictWord{132, 11, 280}, + DictWord{12, 0, 271}, + DictWord{17, 0, 109}, + DictWord{7, 10, 643}, + DictWord{136, 10, 236}, + DictWord{140, 11, 54}, + DictWord{4, 11, 421}, + DictWord{133, 11, 548}, + DictWord{11, 0, 719}, + DictWord{12, 0, 36}, + DictWord{141, 0, 337}, + DictWord{7, 0, 581}, + DictWord{9, 0, 644}, + DictWord{137, 0, 699}, + DictWord{11, 11, 511}, + DictWord{13, 11, 394}, + DictWord{14, 11, 298}, + DictWord{14, 11, 318}, + DictWord{146, 11, 103}, + DictWord{7, 0, 304}, + DictWord{9, 0, 646}, + DictWord{9, 0, 862}, + DictWord{11, 0, 696}, + DictWord{12, 0, 208}, + DictWord{15, 0, 79}, + DictWord{147, 0, 108}, + DictWord{4, 0, 631}, + DictWord{7, 0, 1126}, + DictWord{135, 0, 1536}, + DictWord{135, 11, 1527}, + DictWord{8, 0, 880}, + DictWord{10, 0, 869}, + DictWord{138, 0, 913}, + DictWord{7, 0, 1513}, + DictWord{5, 10, 54}, + DictWord{6, 11, 254}, + DictWord{9, 11, 109}, + DictWord{138, 11, 103}, + DictWord{135, 0, 981}, + DictWord{133, 11, 729}, + DictWord{132, 10, 744}, + DictWord{132, 0, 434}, + DictWord{134, 0, 550}, + DictWord{7, 0, 930}, + DictWord{10, 0, 476}, + DictWord{13, 0, 452}, + DictWord{19, 0, 104}, + DictWord{6, 11, 1630}, + DictWord{10, 10, 402}, + DictWord{146, 10, 55}, + DictWord{5, 0, 553}, + DictWord{138, 0, 824}, + DictWord{136, 0, 452}, + DictWord{8, 0, 151}, + DictWord{137, 10, 624}, + DictWord{132, 10, 572}, + DictWord{132, 0, 772}, + DictWord{133, 11, 671}, + DictWord{ + 133, + 0, + 292, + }, + DictWord{138, 0, 135}, + DictWord{132, 11, 889}, + DictWord{140, 11, 207}, + DictWord{9, 0, 504}, + DictWord{6, 10, 43}, + DictWord{7, 10, 38}, + DictWord{ + 8, + 10, + 248, + }, + DictWord{138, 10, 513}, + DictWord{6, 0, 1089}, + DictWord{135, 11, 1910}, + DictWord{4, 11, 627}, + DictWord{133, 11, 775}, + DictWord{135, 0, 783}, + DictWord{133, 10, 766}, + DictWord{133, 10, 363}, + DictWord{7, 0, 387}, + DictWord{135, 11, 387}, + DictWord{7, 0, 393}, + DictWord{10, 0, 603}, + DictWord{11, 0, 206}, + DictWord{7, 11, 202}, + DictWord{11, 11, 362}, + DictWord{11, 11, 948}, + DictWord{140, 11, 388}, + DictWord{6, 11, 507}, + DictWord{7, 11, 451}, + DictWord{8, 11, 389}, + DictWord{12, 11, 490}, + DictWord{13, 11, 16}, + DictWord{13, 11, 215}, + DictWord{13, 11, 351}, + DictWord{18, 11, 132}, + DictWord{147, 11, 125}, + DictWord{ + 4, + 0, + 912, + }, + DictWord{9, 0, 232}, + DictWord{135, 11, 841}, + DictWord{6, 10, 258}, + DictWord{140, 10, 409}, + DictWord{5, 10, 249}, + DictWord{148, 10, 82}, + DictWord{ + 136, + 11, + 566, + }, + DictWord{6, 0, 977}, + DictWord{135, 11, 1214}, + DictWord{7, 0, 1973}, + DictWord{136, 0, 716}, + DictWord{135, 0, 98}, + DictWord{133, 0, 733}, + DictWord{ + 5, + 11, + 912, + }, + DictWord{134, 11, 1695}, + DictWord{5, 10, 393}, + DictWord{6, 10, 378}, + DictWord{7, 10, 1981}, + DictWord{9, 10, 32}, + DictWord{9, 10, 591}, + DictWord{10, 10, 685}, + DictWord{10, 10, 741}, + DictWord{142, 10, 382}, + DictWord{133, 10, 788}, + DictWord{10, 0, 19}, + DictWord{11, 0, 911}, + DictWord{7, 10, 1968}, + DictWord{141, 10, 509}, + DictWord{5, 0, 668}, + DictWord{5, 11, 236}, + DictWord{6, 11, 572}, + DictWord{8, 11, 492}, + DictWord{11, 11, 618}, + DictWord{144, 11, 56}, + DictWord{135, 11, 1789}, + DictWord{4, 0, 360}, + DictWord{5, 0, 635}, + DictWord{5, 0, 700}, + DictWord{5, 10, 58}, + DictWord{5, 10, 171}, + DictWord{5, 10, 683}, + DictWord{ + 6, + 10, + 291, + }, + DictWord{6, 10, 566}, + DictWord{7, 10, 1650}, + DictWord{11, 10, 523}, + DictWord{12, 10, 273}, + DictWord{12, 10, 303}, + DictWord{15, 10, 39}, + DictWord{143, 10, 111}, + DictWord{133, 0, 901}, + DictWord{134, 10, 589}, + DictWord{5, 11, 190}, + DictWord{136, 11, 318}, + DictWord{140, 0, 656}, + DictWord{ + 7, + 0, + 726, + }, + DictWord{152, 0, 9}, + DictWord{4, 10, 917}, + DictWord{133, 10, 1005}, + DictWord{135, 10, 1598}, + DictWord{134, 11, 491}, + DictWord{4, 10, 919}, + DictWord{133, 11, 434}, + DictWord{137, 0, 72}, + DictWord{6, 0, 1269}, + DictWord{6, 0, 1566}, + DictWord{134, 0, 1621}, + DictWord{9, 0, 463}, + DictWord{10, 0, 595}, + DictWord{4, 10, 255}, + DictWord{5, 10, 302}, + DictWord{6, 10, 132}, + DictWord{7, 10, 128}, + DictWord{7, 10, 283}, + DictWord{7, 10, 1299}, + DictWord{10, 10, 52}, + DictWord{ + 10, + 10, + 514, + }, + DictWord{11, 10, 925}, + DictWord{13, 10, 92}, + DictWord{142, 10, 309}, + DictWord{135, 0, 1454}, + DictWord{134, 0, 1287}, + DictWord{11, 0, 600}, + DictWord{13, 0, 245}, + DictWord{137, 10, 173}, + DictWord{136, 0, 989}, + DictWord{7, 0, 164}, + DictWord{7, 0, 1571}, + DictWord{9, 0, 107}, + DictWord{140, 0, 225}, + DictWord{6, 0, 1061}, + DictWord{141, 10, 442}, + DictWord{4, 0, 27}, + DictWord{5, 0, 484}, + DictWord{5, 0, 510}, + DictWord{6, 0, 434}, + DictWord{7, 0, 1000}, + DictWord{ + 7, + 0, + 1098, + }, + DictWord{136, 0, 2}, + DictWord{7, 11, 85}, + DictWord{7, 11, 247}, + DictWord{8, 11, 585}, + DictWord{10, 11, 163}, + DictWord{138, 11, 316}, + DictWord{ + 11, + 11, + 103, + }, + DictWord{142, 11, 0}, + DictWord{134, 0, 1127}, + DictWord{4, 0, 460}, + DictWord{134, 0, 852}, + DictWord{134, 10, 210}, + DictWord{4, 0, 932}, + DictWord{ + 133, + 0, + 891, + }, + DictWord{6, 0, 588}, + DictWord{147, 11, 83}, + DictWord{8, 0, 625}, + DictWord{4, 10, 284}, + DictWord{134, 10, 223}, + DictWord{134, 0, 76}, + DictWord{8, 0, 92}, + DictWord{137, 0, 221}, + DictWord{4, 11, 124}, + DictWord{10, 11, 457}, + DictWord{11, 11, 121}, + DictWord{11, 11, 169}, + DictWord{11, 11, 422}, + DictWord{ + 11, + 11, + 870, + }, + DictWord{12, 11, 214}, + DictWord{13, 11, 389}, + DictWord{14, 11, 187}, + DictWord{143, 11, 77}, + DictWord{9, 11, 618}, + DictWord{138, 11, 482}, + DictWord{ + 4, + 10, + 218, + }, + DictWord{7, 10, 526}, + DictWord{143, 10, 137}, + DictWord{13, 0, 9}, + DictWord{14, 0, 104}, + DictWord{14, 0, 311}, + DictWord{4, 10, 270}, + DictWord{ + 5, + 10, + 192, + }, + DictWord{6, 10, 332}, + DictWord{135, 10, 1322}, + DictWord{140, 10, 661}, + DictWord{135, 11, 1193}, + DictWord{6, 11, 107}, + DictWord{7, 11, 638}, + DictWord{7, 11, 1632}, + DictWord{137, 11, 396}, + DictWord{132, 0, 763}, + DictWord{4, 0, 622}, + DictWord{5, 11, 370}, + DictWord{134, 11, 1756}, + DictWord{ + 133, + 0, + 253, + }, + DictWord{135, 0, 546}, + DictWord{9, 0, 73}, + DictWord{10, 0, 110}, + DictWord{14, 0, 185}, + DictWord{17, 0, 119}, + DictWord{133, 11, 204}, + DictWord{7, 0, 624}, + DictWord{7, 0, 916}, + DictWord{10, 0, 256}, + DictWord{139, 0, 87}, + DictWord{7, 10, 379}, + DictWord{8, 10, 481}, + DictWord{137, 10, 377}, + DictWord{5, 0, 212}, + DictWord{12, 0, 35}, + DictWord{13, 0, 382}, + DictWord{5, 11, 970}, + DictWord{134, 11, 1706}, + DictWord{9, 0, 746}, + DictWord{5, 10, 1003}, + DictWord{134, 10, 149}, + DictWord{10, 0, 150}, + DictWord{11, 0, 849}, + DictWord{13, 0, 330}, + DictWord{8, 10, 262}, + DictWord{9, 10, 627}, + DictWord{11, 10, 214}, + DictWord{11, 10, 404}, + DictWord{11, 10, 457}, + DictWord{11, 10, 780}, + DictWord{11, 10, 913}, + DictWord{13, 10, 401}, + DictWord{142, 10, 200}, + DictWord{134, 0, 1466}, + DictWord{ + 135, + 11, + 3, + }, + DictWord{6, 0, 1299}, + DictWord{4, 11, 35}, + DictWord{5, 11, 121}, + DictWord{5, 11, 483}, + DictWord{5, 11, 685}, + DictWord{6, 11, 489}, + DictWord{7, 11, 1204}, + DictWord{136, 11, 394}, + DictWord{135, 10, 742}, + DictWord{4, 10, 142}, + DictWord{136, 10, 304}, + DictWord{4, 11, 921}, + DictWord{133, 11, 1007}, + DictWord{ + 134, + 0, + 1518, + }, + DictWord{6, 0, 1229}, + DictWord{135, 0, 1175}, + DictWord{133, 0, 816}, + DictWord{12, 0, 159}, + DictWord{4, 10, 471}, + DictWord{4, 11, 712}, + DictWord{ + 5, + 10, + 51, + }, + DictWord{6, 10, 602}, + DictWord{7, 10, 925}, + DictWord{8, 10, 484}, + DictWord{138, 10, 195}, + DictWord{134, 11, 1629}, + DictWord{5, 0, 869}, + DictWord{ + 5, + 0, + 968, + }, + DictWord{6, 0, 1626}, + DictWord{8, 0, 734}, + DictWord{136, 0, 784}, + DictWord{4, 0, 542}, + DictWord{6, 0, 1716}, + DictWord{6, 0, 1727}, + DictWord{ + 7, + 0, + 1082, + }, + DictWord{7, 0, 1545}, + DictWord{8, 0, 56}, + DictWord{8, 0, 118}, + DictWord{8, 0, 412}, + DictWord{8, 0, 564}, + DictWord{9, 0, 888}, + DictWord{9, 0, 908}, + DictWord{ + 10, + 0, + 50, + }, + DictWord{10, 0, 423}, + DictWord{11, 0, 685}, + DictWord{11, 0, 697}, + DictWord{11, 0, 933}, + DictWord{12, 0, 299}, + DictWord{13, 0, 126}, + DictWord{ + 13, + 0, + 136, + }, + DictWord{13, 0, 170}, + DictWord{13, 0, 190}, + DictWord{136, 10, 688}, + DictWord{132, 10, 697}, + DictWord{4, 0, 232}, + DictWord{9, 0, 202}, + DictWord{ + 10, + 0, + 474, + }, + DictWord{140, 0, 433}, + DictWord{136, 0, 212}, + DictWord{6, 0, 108}, + DictWord{7, 0, 1003}, + DictWord{7, 0, 1181}, + DictWord{8, 0, 111}, + DictWord{ + 136, + 0, + 343, + }, + DictWord{5, 10, 221}, + DictWord{135, 11, 1255}, + DictWord{133, 11, 485}, + DictWord{134, 0, 1712}, + DictWord{142, 0, 216}, + DictWord{5, 0, 643}, + DictWord{ + 6, + 0, + 516, + }, + DictWord{4, 11, 285}, + DictWord{5, 11, 317}, + DictWord{6, 11, 301}, + DictWord{7, 11, 7}, + DictWord{8, 11, 153}, + DictWord{10, 11, 766}, + DictWord{ + 11, + 11, + 468, + }, + DictWord{12, 11, 467}, + DictWord{141, 11, 143}, + DictWord{4, 0, 133}, + DictWord{7, 0, 711}, + DictWord{7, 0, 1298}, + DictWord{135, 0, 1585}, + DictWord{ + 134, + 0, + 650, + }, + DictWord{135, 11, 512}, + DictWord{6, 0, 99}, + DictWord{7, 0, 1808}, + DictWord{145, 0, 57}, + DictWord{6, 0, 246}, + DictWord{6, 0, 574}, + DictWord{7, 0, 428}, + DictWord{9, 0, 793}, + DictWord{10, 0, 669}, + DictWord{11, 0, 485}, + DictWord{11, 0, 840}, + DictWord{12, 0, 300}, + DictWord{14, 0, 250}, + DictWord{145, 0, 55}, + DictWord{ + 4, + 10, + 132, + }, + DictWord{5, 10, 69}, + DictWord{135, 10, 1242}, + DictWord{136, 0, 1023}, + DictWord{7, 0, 302}, + DictWord{132, 10, 111}, + DictWord{135, 0, 1871}, + DictWord{132, 0, 728}, + DictWord{9, 0, 252}, + DictWord{132, 10, 767}, + DictWord{6, 0, 461}, + DictWord{7, 0, 1590}, + DictWord{7, 10, 1416}, + DictWord{7, 10, 2005}, + DictWord{8, 10, 131}, + DictWord{8, 10, 466}, + DictWord{9, 10, 672}, + DictWord{13, 10, 252}, + DictWord{148, 10, 103}, + DictWord{6, 0, 323}, + DictWord{135, 0, 1564}, + DictWord{7, 0, 461}, + DictWord{136, 0, 775}, + DictWord{6, 10, 44}, + DictWord{136, 10, 368}, + DictWord{139, 0, 172}, + DictWord{132, 0, 464}, + DictWord{4, 10, 570}, + DictWord{133, 10, 120}, + DictWord{137, 11, 269}, + DictWord{6, 10, 227}, + DictWord{135, 10, 1589}, + DictWord{6, 11, 1719}, + DictWord{6, 11, 1735}, + DictWord{ + 7, + 11, + 2016, + }, + DictWord{7, 11, 2020}, + DictWord{8, 11, 837}, + DictWord{137, 11, 852}, + DictWord{7, 0, 727}, + DictWord{146, 0, 73}, + DictWord{132, 0, 1023}, + DictWord{135, 11, 852}, + DictWord{135, 10, 1529}, + DictWord{136, 0, 577}, + DictWord{138, 11, 568}, + DictWord{134, 0, 1037}, + DictWord{8, 11, 67}, + DictWord{ + 138, + 11, + 419, + }, + DictWord{4, 0, 413}, + DictWord{5, 0, 677}, + DictWord{8, 0, 432}, + DictWord{140, 0, 280}, + DictWord{10, 0, 600}, + DictWord{6, 10, 1667}, + DictWord{ + 7, + 11, + 967, + }, + DictWord{7, 10, 2036}, + DictWord{141, 11, 11}, + DictWord{6, 10, 511}, + DictWord{140, 10, 132}, + DictWord{6, 0, 799}, + DictWord{5, 10, 568}, + DictWord{ + 6, + 10, + 138, + }, + DictWord{135, 10, 1293}, + DictWord{8, 0, 159}, + DictWord{4, 10, 565}, + DictWord{136, 10, 827}, + DictWord{7, 0, 646}, + DictWord{7, 0, 1730}, + DictWord{ + 11, + 0, + 446, + }, + DictWord{141, 0, 178}, + DictWord{4, 10, 922}, + DictWord{133, 10, 1023}, + DictWord{135, 11, 11}, + DictWord{132, 0, 395}, + DictWord{11, 0, 145}, + DictWord{135, 10, 1002}, + DictWord{9, 0, 174}, + DictWord{10, 0, 164}, + DictWord{11, 0, 440}, + DictWord{11, 0, 514}, + DictWord{11, 0, 841}, + DictWord{15, 0, 98}, + DictWord{149, 0, 20}, + DictWord{134, 0, 426}, + DictWord{10, 0, 608}, + DictWord{139, 0, 1002}, + DictWord{7, 11, 320}, + DictWord{8, 11, 51}, + DictWord{12, 11, 481}, + DictWord{12, 11, 570}, + DictWord{148, 11, 106}, + DictWord{9, 0, 977}, + DictWord{9, 0, 983}, + DictWord{132, 11, 445}, + DictWord{138, 0, 250}, + DictWord{139, 0, 100}, + DictWord{6, 0, 1982}, + DictWord{136, 10, 402}, + DictWord{133, 11, 239}, + DictWord{4, 10, 716}, + DictWord{141, 10, 31}, + DictWord{5, 0, 476}, + DictWord{7, 11, 83}, + DictWord{7, 11, 1990}, + DictWord{8, 11, 130}, + DictWord{139, 11, 720}, + DictWord{8, 10, 691}, + DictWord{136, 10, 731}, + DictWord{5, 11, 123}, + DictWord{ + 6, + 11, + 530, + }, + DictWord{7, 11, 348}, + DictWord{135, 11, 1419}, + DictWord{5, 0, 76}, + DictWord{6, 0, 458}, + DictWord{6, 0, 497}, + DictWord{7, 0, 868}, + DictWord{9, 0, 658}, + DictWord{10, 0, 594}, + DictWord{11, 0, 173}, + DictWord{11, 0, 566}, + DictWord{12, 0, 20}, + DictWord{12, 0, 338}, + DictWord{141, 0, 200}, + DictWord{9, 11, 139}, + DictWord{ + 10, + 11, + 399, + }, + DictWord{11, 11, 469}, + DictWord{12, 11, 634}, + DictWord{141, 11, 223}, + DictWord{9, 10, 840}, + DictWord{138, 10, 803}, + DictWord{133, 10, 847}, + DictWord{11, 11, 223}, + DictWord{140, 11, 168}, + DictWord{132, 11, 210}, + DictWord{8, 0, 447}, + DictWord{9, 10, 53}, + DictWord{9, 10, 268}, + DictWord{9, 10, 901}, + DictWord{10, 10, 518}, + DictWord{10, 10, 829}, + DictWord{11, 10, 188}, + DictWord{13, 10, 74}, + DictWord{14, 10, 46}, + DictWord{15, 10, 17}, + DictWord{15, 10, 33}, + DictWord{17, 10, 40}, + DictWord{18, 10, 36}, + DictWord{19, 10, 20}, + DictWord{22, 10, 1}, + DictWord{152, 10, 2}, + DictWord{4, 0, 526}, + DictWord{7, 0, 1029}, + DictWord{135, 0, 1054}, + DictWord{19, 11, 59}, + DictWord{150, 11, 2}, + DictWord{4, 0, 636}, + DictWord{6, 0, 1875}, + DictWord{6, 0, 1920}, + DictWord{9, 0, 999}, + DictWord{ + 12, + 0, + 807, + }, + DictWord{12, 0, 825}, + DictWord{15, 0, 179}, + DictWord{15, 0, 190}, + DictWord{18, 0, 182}, + DictWord{136, 10, 532}, + DictWord{6, 0, 1699}, + DictWord{ + 7, + 0, + 660, + }, + DictWord{7, 0, 1124}, + DictWord{17, 0, 31}, + DictWord{19, 0, 22}, + DictWord{151, 0, 14}, + DictWord{135, 10, 681}, + DictWord{132, 11, 430}, + DictWord{ + 140, + 10, + 677, + }, + DictWord{4, 10, 684}, + DictWord{136, 10, 384}, + DictWord{132, 11, 756}, + DictWord{133, 11, 213}, + DictWord{7, 0, 188}, + DictWord{7, 10, 110}, + DictWord{ + 8, + 10, + 290, + }, + DictWord{8, 10, 591}, + DictWord{9, 10, 382}, + DictWord{9, 10, 649}, + DictWord{11, 10, 71}, + DictWord{11, 10, 155}, + DictWord{11, 10, 313}, + DictWord{ + 12, + 10, + 5, + }, + DictWord{13, 10, 325}, + DictWord{142, 10, 287}, + DictWord{7, 10, 360}, + DictWord{7, 10, 425}, + DictWord{9, 10, 66}, + DictWord{9, 10, 278}, + DictWord{ + 138, + 10, + 644, + }, + DictWord{142, 11, 164}, + DictWord{4, 0, 279}, + DictWord{7, 0, 301}, + DictWord{137, 0, 362}, + DictWord{134, 11, 586}, + DictWord{135, 0, 1743}, + DictWord{4, 0, 178}, + DictWord{133, 0, 399}, + DictWord{4, 10, 900}, + DictWord{133, 10, 861}, + DictWord{5, 10, 254}, + DictWord{7, 10, 985}, + DictWord{136, 10, 73}, + DictWord{133, 11, 108}, + DictWord{7, 10, 1959}, + DictWord{136, 10, 683}, + DictWord{133, 11, 219}, + DictWord{4, 11, 193}, + DictWord{5, 11, 916}, + DictWord{ + 7, + 11, + 364, + }, + DictWord{10, 11, 398}, + DictWord{10, 11, 726}, + DictWord{11, 11, 317}, + DictWord{11, 11, 626}, + DictWord{12, 11, 142}, + DictWord{12, 11, 288}, + DictWord{ + 12, + 11, + 678, + }, + DictWord{13, 11, 313}, + DictWord{15, 11, 113}, + DictWord{18, 11, 114}, + DictWord{21, 11, 30}, + DictWord{150, 11, 53}, + DictWord{6, 11, 241}, + DictWord{7, 11, 907}, + DictWord{8, 11, 832}, + DictWord{9, 11, 342}, + DictWord{10, 11, 729}, + DictWord{11, 11, 284}, + DictWord{11, 11, 445}, + DictWord{11, 11, 651}, + DictWord{11, 11, 863}, + DictWord{13, 11, 398}, + DictWord{146, 11, 99}, + DictWord{132, 0, 872}, + DictWord{134, 0, 831}, + DictWord{134, 0, 1692}, + DictWord{ + 6, + 0, + 202, + }, + DictWord{6, 0, 1006}, + DictWord{9, 0, 832}, + DictWord{10, 0, 636}, + DictWord{11, 0, 208}, + DictWord{12, 0, 360}, + DictWord{17, 0, 118}, + DictWord{18, 0, 27}, + DictWord{20, 0, 67}, + DictWord{137, 11, 734}, + DictWord{132, 10, 725}, + DictWord{7, 11, 993}, + DictWord{138, 11, 666}, + DictWord{134, 0, 1954}, + DictWord{ + 134, + 10, + 196, + }, + DictWord{7, 0, 872}, + DictWord{10, 0, 516}, + DictWord{139, 0, 167}, + DictWord{133, 10, 831}, + DictWord{4, 11, 562}, + DictWord{9, 11, 254}, + DictWord{ + 139, + 11, + 879, + }, + DictWord{137, 0, 313}, + DictWord{4, 0, 224}, + DictWord{132, 11, 786}, + DictWord{11, 0, 24}, + DictWord{12, 0, 170}, + DictWord{136, 10, 723}, + DictWord{ + 5, + 0, + 546, + }, + DictWord{7, 0, 35}, + DictWord{8, 0, 11}, + DictWord{8, 0, 12}, + DictWord{9, 0, 315}, + DictWord{9, 0, 533}, + DictWord{10, 0, 802}, + DictWord{11, 0, 166}, + DictWord{ + 12, + 0, + 525, + }, + DictWord{142, 0, 243}, + DictWord{7, 0, 1937}, + DictWord{13, 10, 80}, + DictWord{13, 10, 437}, + DictWord{145, 10, 74}, + DictWord{5, 0, 241}, + DictWord{ + 8, + 0, + 242, + }, + DictWord{9, 0, 451}, + DictWord{10, 0, 667}, + DictWord{11, 0, 598}, + DictWord{140, 0, 429}, + DictWord{150, 0, 46}, + DictWord{6, 0, 1273}, + DictWord{ + 137, + 0, + 830, + }, + DictWord{5, 10, 848}, + DictWord{6, 10, 66}, + DictWord{136, 10, 764}, + DictWord{6, 0, 825}, + DictWord{134, 0, 993}, + DictWord{4, 0, 1006}, + DictWord{ + 10, + 0, + 327, + }, + DictWord{13, 0, 271}, + DictWord{4, 10, 36}, + DictWord{7, 10, 1387}, + DictWord{139, 10, 755}, + DictWord{134, 0, 1023}, + DictWord{135, 0, 1580}, + DictWord{ + 4, + 0, + 366, + }, + DictWord{137, 0, 516}, + DictWord{132, 10, 887}, + DictWord{6, 0, 1736}, + DictWord{135, 0, 1891}, + DictWord{6, 11, 216}, + DictWord{7, 11, 901}, + DictWord{ + 7, + 11, + 1343, + }, + DictWord{136, 11, 493}, + DictWord{6, 10, 165}, + DictWord{138, 10, 388}, + DictWord{7, 11, 341}, + DictWord{139, 11, 219}, + DictWord{4, 10, 719}, + DictWord{135, 10, 155}, + DictWord{134, 0, 1935}, + DictWord{132, 0, 826}, + DictWord{6, 0, 331}, + DictWord{6, 0, 1605}, + DictWord{8, 0, 623}, + DictWord{11, 0, 139}, + DictWord{139, 0, 171}, + DictWord{135, 11, 1734}, + DictWord{10, 11, 115}, + DictWord{11, 11, 420}, + DictWord{12, 11, 154}, + DictWord{13, 11, 404}, + DictWord{ + 14, + 11, + 346, + }, + DictWord{15, 11, 54}, + DictWord{143, 11, 112}, + DictWord{7, 0, 288}, + DictWord{4, 10, 353}, + DictWord{6, 10, 146}, + DictWord{6, 10, 1789}, + DictWord{ + 7, + 10, + 990, + }, + DictWord{7, 10, 1348}, + DictWord{9, 10, 665}, + DictWord{9, 10, 898}, + DictWord{11, 10, 893}, + DictWord{142, 10, 212}, + DictWord{6, 0, 916}, + DictWord{134, 0, 1592}, + DictWord{7, 0, 1888}, + DictWord{4, 10, 45}, + DictWord{135, 10, 1257}, + DictWord{5, 11, 1011}, + DictWord{136, 11, 701}, + DictWord{ + 139, + 11, + 596, + }, + DictWord{4, 11, 54}, + DictWord{5, 11, 666}, + DictWord{7, 11, 1039}, + DictWord{7, 11, 1130}, + DictWord{9, 11, 195}, + DictWord{138, 11, 302}, + DictWord{ + 134, + 0, + 1471, + }, + DictWord{134, 0, 1570}, + DictWord{132, 0, 394}, + DictWord{140, 10, 65}, + DictWord{136, 10, 816}, + DictWord{135, 0, 1931}, + DictWord{7, 0, 574}, + DictWord{135, 0, 1719}, + DictWord{134, 11, 467}, + DictWord{132, 0, 658}, + DictWord{9, 0, 781}, + DictWord{10, 0, 144}, + DictWord{11, 0, 385}, + DictWord{13, 0, 161}, + DictWord{13, 0, 228}, + DictWord{13, 0, 268}, + DictWord{20, 0, 107}, + DictWord{134, 11, 1669}, + DictWord{136, 0, 374}, + DictWord{135, 0, 735}, + DictWord{4, 0, 344}, + DictWord{6, 0, 498}, + DictWord{139, 0, 323}, + DictWord{7, 0, 586}, + DictWord{7, 0, 1063}, + DictWord{6, 10, 559}, + DictWord{134, 10, 1691}, + DictWord{137, 0, 155}, + DictWord{133, 0, 906}, + DictWord{7, 11, 122}, + DictWord{9, 11, 259}, + DictWord{10, 11, 84}, + DictWord{11, 11, 470}, + DictWord{12, 11, 541}, + DictWord{ + 141, + 11, + 379, + }, + DictWord{134, 0, 1139}, + DictWord{10, 0, 108}, + DictWord{139, 0, 116}, + DictWord{134, 10, 456}, + DictWord{133, 10, 925}, + DictWord{5, 11, 82}, + DictWord{ + 5, + 11, + 131, + }, + DictWord{7, 11, 1755}, + DictWord{8, 11, 31}, + DictWord{9, 11, 168}, + DictWord{9, 11, 764}, + DictWord{139, 11, 869}, + DictWord{134, 11, 605}, + DictWord{ + 5, + 11, + 278, + }, + DictWord{137, 11, 68}, + DictWord{4, 11, 163}, + DictWord{5, 11, 201}, + DictWord{5, 11, 307}, + DictWord{5, 11, 310}, + DictWord{6, 11, 335}, + DictWord{ + 7, + 11, + 284, + }, + DictWord{136, 11, 165}, + DictWord{135, 11, 1660}, + DictWord{6, 11, 33}, + DictWord{135, 11, 1244}, + DictWord{4, 0, 616}, + DictWord{136, 11, 483}, + DictWord{8, 0, 857}, + DictWord{8, 0, 902}, + DictWord{8, 0, 910}, + DictWord{10, 0, 879}, + DictWord{12, 0, 726}, + DictWord{4, 11, 199}, + DictWord{139, 11, 34}, + DictWord{136, 0, 692}, + DictWord{6, 10, 193}, + DictWord{7, 10, 240}, + DictWord{7, 10, 1682}, + DictWord{10, 10, 51}, + DictWord{10, 10, 640}, + DictWord{11, 10, 410}, + DictWord{13, 10, 82}, + DictWord{14, 10, 247}, + DictWord{14, 10, 331}, + DictWord{142, 10, 377}, + DictWord{6, 0, 823}, + DictWord{134, 0, 983}, + DictWord{ + 139, + 10, + 411, + }, + DictWord{132, 0, 305}, + DictWord{136, 10, 633}, + DictWord{138, 11, 203}, + DictWord{134, 0, 681}, + DictWord{6, 11, 326}, + DictWord{7, 11, 677}, + DictWord{137, 11, 425}, + DictWord{5, 0, 214}, + DictWord{7, 0, 603}, + DictWord{8, 0, 611}, + DictWord{9, 0, 686}, + DictWord{10, 0, 88}, + DictWord{11, 0, 459}, + DictWord{ + 11, + 0, + 496, + }, + DictWord{12, 0, 463}, + DictWord{12, 0, 590}, + DictWord{141, 0, 0}, + DictWord{136, 0, 1004}, + DictWord{142, 0, 23}, + DictWord{134, 0, 1703}, + DictWord{ + 147, + 11, + 8, + }, + DictWord{145, 11, 56}, + DictWord{135, 0, 1443}, + DictWord{4, 10, 237}, + DictWord{135, 10, 514}, + DictWord{6, 0, 714}, + DictWord{145, 0, 19}, + DictWord{ + 5, + 11, + 358, + }, + DictWord{7, 11, 473}, + DictWord{7, 11, 1184}, + DictWord{10, 11, 662}, + DictWord{13, 11, 212}, + DictWord{13, 11, 304}, + DictWord{13, 11, 333}, + DictWord{145, 11, 98}, + DictWord{4, 0, 737}, + DictWord{10, 0, 98}, + DictWord{11, 0, 294}, + DictWord{12, 0, 60}, + DictWord{12, 0, 437}, + DictWord{13, 0, 64}, + DictWord{ + 13, + 0, + 380, + }, + DictWord{142, 0, 430}, + DictWord{6, 10, 392}, + DictWord{7, 10, 65}, + DictWord{135, 10, 2019}, + DictWord{6, 0, 1758}, + DictWord{8, 0, 520}, + DictWord{ + 9, + 0, + 345, + }, + DictWord{9, 0, 403}, + DictWord{142, 0, 350}, + DictWord{5, 0, 47}, + DictWord{10, 0, 242}, + DictWord{138, 0, 579}, + DictWord{5, 0, 139}, + DictWord{7, 0, 1168}, + DictWord{138, 0, 539}, + DictWord{134, 0, 1459}, + DictWord{13, 0, 388}, + DictWord{141, 11, 388}, + DictWord{134, 0, 253}, + DictWord{7, 10, 1260}, + DictWord{ + 135, + 10, + 1790, + }, + DictWord{10, 0, 252}, + DictWord{9, 10, 222}, + DictWord{139, 10, 900}, + DictWord{140, 0, 745}, + DictWord{133, 11, 946}, + DictWord{4, 0, 107}, + DictWord{ + 7, + 0, + 613, + }, + DictWord{8, 0, 439}, + DictWord{8, 0, 504}, + DictWord{9, 0, 501}, + DictWord{10, 0, 383}, + DictWord{139, 0, 477}, + DictWord{135, 11, 1485}, + DictWord{ + 132, + 0, + 871, + }, + DictWord{7, 11, 411}, + DictWord{7, 11, 590}, + DictWord{8, 11, 631}, + DictWord{9, 11, 323}, + DictWord{10, 11, 355}, + DictWord{11, 11, 491}, + DictWord{ + 12, + 11, + 143, + }, + DictWord{12, 11, 402}, + DictWord{13, 11, 73}, + DictWord{14, 11, 408}, + DictWord{15, 11, 107}, + DictWord{146, 11, 71}, + DictWord{132, 0, 229}, + DictWord{132, 0, 903}, + DictWord{140, 0, 71}, + DictWord{133, 0, 549}, + DictWord{4, 0, 47}, + DictWord{6, 0, 373}, + DictWord{7, 0, 452}, + DictWord{7, 0, 543}, + DictWord{ + 7, + 0, + 1828, + }, + DictWord{7, 0, 1856}, + DictWord{9, 0, 6}, + DictWord{11, 0, 257}, + DictWord{139, 0, 391}, + DictWord{7, 11, 1467}, + DictWord{8, 11, 328}, + DictWord{ + 10, + 11, + 544, + }, + DictWord{11, 11, 955}, + DictWord{13, 11, 320}, + DictWord{145, 11, 83}, + DictWord{5, 0, 980}, + DictWord{134, 0, 1754}, + DictWord{136, 0, 865}, + DictWord{ + 5, + 0, + 705, + }, + DictWord{137, 0, 606}, + DictWord{7, 0, 161}, + DictWord{8, 10, 201}, + DictWord{136, 10, 605}, + DictWord{143, 11, 35}, + DictWord{5, 11, 835}, + DictWord{ + 6, + 11, + 483, + }, + DictWord{140, 10, 224}, + DictWord{7, 0, 536}, + DictWord{7, 0, 1331}, + DictWord{136, 0, 143}, + DictWord{134, 0, 1388}, + DictWord{5, 0, 724}, + DictWord{ + 10, + 0, + 305, + }, + DictWord{11, 0, 151}, + DictWord{12, 0, 33}, + DictWord{12, 0, 121}, + DictWord{12, 0, 381}, + DictWord{17, 0, 3}, + DictWord{17, 0, 27}, + DictWord{17, 0, 78}, + DictWord{18, 0, 18}, + DictWord{19, 0, 54}, + DictWord{149, 0, 5}, + DictWord{4, 10, 523}, + DictWord{133, 10, 638}, + DictWord{5, 0, 19}, + DictWord{134, 0, 533}, + DictWord{ + 5, + 0, + 395, + }, + DictWord{5, 0, 951}, + DictWord{134, 0, 1776}, + DictWord{135, 0, 1908}, + DictWord{132, 0, 846}, + DictWord{10, 0, 74}, + DictWord{11, 0, 663}, + DictWord{ + 12, + 0, + 210, + }, + DictWord{13, 0, 166}, + DictWord{13, 0, 310}, + DictWord{14, 0, 373}, + DictWord{18, 0, 95}, + DictWord{19, 0, 43}, + DictWord{6, 10, 242}, + DictWord{7, 10, 227}, + DictWord{7, 10, 1581}, + DictWord{8, 10, 104}, + DictWord{9, 10, 113}, + DictWord{9, 10, 220}, + DictWord{9, 10, 427}, + DictWord{10, 10, 239}, + DictWord{11, 10, 579}, + DictWord{11, 10, 1023}, + DictWord{13, 10, 4}, + DictWord{13, 10, 204}, + DictWord{13, 10, 316}, + DictWord{148, 10, 86}, + DictWord{9, 11, 716}, + DictWord{11, 11, 108}, + DictWord{13, 11, 123}, + DictWord{14, 11, 252}, + DictWord{19, 11, 38}, + DictWord{21, 11, 3}, + DictWord{151, 11, 11}, + DictWord{8, 0, 372}, + DictWord{9, 0, 122}, + DictWord{138, 0, 175}, + DictWord{132, 11, 677}, + DictWord{7, 11, 1374}, + DictWord{136, 11, 540}, + DictWord{135, 10, 861}, + DictWord{132, 0, 695}, + DictWord{ + 7, + 0, + 497, + }, + DictWord{9, 0, 387}, + DictWord{147, 0, 81}, + DictWord{136, 0, 937}, + DictWord{134, 0, 718}, + DictWord{7, 0, 1328}, + DictWord{136, 10, 494}, + DictWord{ + 132, + 11, + 331, + }, + DictWord{6, 0, 1581}, + DictWord{133, 11, 747}, + DictWord{5, 0, 284}, + DictWord{6, 0, 49}, + DictWord{6, 0, 350}, + DictWord{7, 0, 1}, + DictWord{7, 0, 377}, + DictWord{7, 0, 1693}, + DictWord{8, 0, 18}, + DictWord{8, 0, 678}, + DictWord{9, 0, 161}, + DictWord{9, 0, 585}, + DictWord{9, 0, 671}, + DictWord{9, 0, 839}, + DictWord{11, 0, 912}, + DictWord{141, 0, 427}, + DictWord{7, 10, 1306}, + DictWord{8, 10, 505}, + DictWord{9, 10, 482}, + DictWord{10, 10, 126}, + DictWord{11, 10, 225}, + DictWord{12, 10, 347}, + DictWord{12, 10, 449}, + DictWord{13, 10, 19}, + DictWord{14, 10, 218}, + DictWord{142, 10, 435}, + DictWord{10, 10, 764}, + DictWord{12, 10, 120}, + DictWord{ + 13, + 10, + 39, + }, + DictWord{145, 10, 127}, + DictWord{4, 0, 597}, + DictWord{133, 10, 268}, + DictWord{134, 0, 1094}, + DictWord{4, 0, 1008}, + DictWord{134, 0, 1973}, + DictWord{132, 0, 811}, + DictWord{139, 0, 908}, + DictWord{135, 0, 1471}, + DictWord{133, 11, 326}, + DictWord{4, 10, 384}, + DictWord{135, 10, 1022}, + DictWord{ + 7, + 0, + 1935, + }, + DictWord{8, 0, 324}, + DictWord{12, 0, 42}, + DictWord{4, 11, 691}, + DictWord{7, 11, 1935}, + DictWord{8, 11, 324}, + DictWord{9, 11, 35}, + DictWord{10, 11, 680}, + DictWord{11, 11, 364}, + DictWord{12, 11, 42}, + DictWord{13, 11, 357}, + DictWord{146, 11, 16}, + DictWord{135, 0, 2014}, + DictWord{7, 0, 2007}, + DictWord{ + 9, + 0, + 101, + }, + DictWord{9, 0, 450}, + DictWord{10, 0, 66}, + DictWord{10, 0, 842}, + DictWord{11, 0, 536}, + DictWord{12, 0, 587}, + DictWord{6, 11, 32}, + DictWord{7, 11, 385}, + DictWord{7, 11, 757}, + DictWord{7, 11, 1916}, + DictWord{8, 11, 37}, + DictWord{8, 11, 94}, + DictWord{8, 11, 711}, + DictWord{9, 11, 541}, + DictWord{10, 11, 162}, + DictWord{ + 10, + 11, + 795, + }, + DictWord{11, 11, 989}, + DictWord{11, 11, 1010}, + DictWord{12, 11, 14}, + DictWord{142, 11, 308}, + DictWord{139, 0, 586}, + DictWord{ + 135, + 10, + 1703, + }, + DictWord{7, 0, 1077}, + DictWord{11, 0, 28}, + DictWord{9, 10, 159}, + DictWord{140, 10, 603}, + DictWord{6, 0, 1221}, + DictWord{136, 10, 583}, + DictWord{ + 6, + 11, + 152, + }, + DictWord{6, 11, 349}, + DictWord{6, 11, 1682}, + DictWord{7, 11, 1252}, + DictWord{8, 11, 112}, + DictWord{9, 11, 435}, + DictWord{9, 11, 668}, + DictWord{ + 10, + 11, + 290, + }, + DictWord{10, 11, 319}, + DictWord{10, 11, 815}, + DictWord{11, 11, 180}, + DictWord{11, 11, 837}, + DictWord{12, 11, 240}, + DictWord{13, 11, 152}, + DictWord{13, 11, 219}, + DictWord{142, 11, 158}, + DictWord{139, 0, 62}, + DictWord{132, 10, 515}, + DictWord{8, 10, 632}, + DictWord{8, 10, 697}, + DictWord{ + 137, + 10, + 854, + }, + DictWord{134, 0, 1766}, + DictWord{132, 11, 581}, + DictWord{6, 11, 126}, + DictWord{7, 11, 573}, + DictWord{8, 11, 397}, + DictWord{142, 11, 44}, + DictWord{ + 150, + 0, + 28, + }, + DictWord{11, 0, 670}, + DictWord{22, 0, 25}, + DictWord{4, 10, 136}, + DictWord{133, 10, 551}, + DictWord{6, 0, 1665}, + DictWord{7, 0, 256}, + DictWord{ + 7, + 0, + 1388, + }, + DictWord{138, 0, 499}, + DictWord{4, 0, 22}, + DictWord{5, 0, 10}, + DictWord{7, 0, 1576}, + DictWord{136, 0, 97}, + DictWord{134, 10, 1782}, + DictWord{5, 0, 481}, + DictWord{7, 10, 1287}, + DictWord{9, 10, 44}, + DictWord{10, 10, 552}, + DictWord{10, 10, 642}, + DictWord{11, 10, 839}, + DictWord{12, 10, 274}, + DictWord{ + 12, + 10, + 275, + }, + DictWord{12, 10, 372}, + DictWord{13, 10, 91}, + DictWord{142, 10, 125}, + DictWord{133, 11, 926}, + DictWord{7, 11, 1232}, + DictWord{137, 11, 531}, + DictWord{6, 0, 134}, + DictWord{7, 0, 437}, + DictWord{7, 0, 1824}, + DictWord{9, 0, 37}, + DictWord{14, 0, 285}, + DictWord{142, 0, 371}, + DictWord{7, 0, 486}, + DictWord{8, 0, 155}, + DictWord{11, 0, 93}, + DictWord{140, 0, 164}, + DictWord{6, 0, 1391}, + DictWord{134, 0, 1442}, + DictWord{133, 11, 670}, + DictWord{133, 0, 591}, + DictWord{ + 6, + 10, + 147, + }, + DictWord{7, 10, 886}, + DictWord{7, 11, 1957}, + DictWord{9, 10, 753}, + DictWord{138, 10, 268}, + DictWord{5, 0, 380}, + DictWord{5, 0, 650}, + DictWord{ + 7, + 0, + 1173, + }, + DictWord{136, 0, 310}, + DictWord{4, 0, 364}, + DictWord{7, 0, 1156}, + DictWord{7, 0, 1187}, + DictWord{137, 0, 409}, + DictWord{135, 11, 1621}, + DictWord{ + 134, + 0, + 482, + }, + DictWord{133, 11, 506}, + DictWord{4, 0, 781}, + DictWord{6, 0, 487}, + DictWord{7, 0, 926}, + DictWord{8, 0, 263}, + DictWord{139, 0, 500}, + DictWord{ + 138, + 10, + 137, + }, + DictWord{135, 11, 242}, + DictWord{139, 11, 96}, + DictWord{133, 10, 414}, + DictWord{135, 10, 1762}, + DictWord{134, 0, 804}, + DictWord{5, 11, 834}, + DictWord{7, 11, 1202}, + DictWord{8, 11, 14}, + DictWord{9, 11, 481}, + DictWord{137, 11, 880}, + DictWord{134, 10, 599}, + DictWord{4, 0, 94}, + DictWord{135, 0, 1265}, + DictWord{4, 0, 415}, + DictWord{132, 0, 417}, + DictWord{5, 0, 348}, + DictWord{6, 0, 522}, + DictWord{6, 10, 1749}, + DictWord{7, 11, 1526}, + DictWord{138, 11, 465}, + DictWord{134, 10, 1627}, + DictWord{132, 0, 1012}, + DictWord{132, 10, 488}, + DictWord{4, 11, 357}, + DictWord{6, 11, 172}, + DictWord{7, 11, 143}, + DictWord{ + 137, + 11, + 413, + }, + DictWord{4, 10, 83}, + DictWord{4, 11, 590}, + DictWord{146, 11, 76}, + DictWord{140, 10, 676}, + DictWord{7, 11, 287}, + DictWord{8, 11, 355}, + DictWord{ + 9, + 11, + 293, + }, + DictWord{137, 11, 743}, + DictWord{134, 10, 278}, + DictWord{6, 0, 1803}, + DictWord{18, 0, 165}, + DictWord{24, 0, 21}, + DictWord{5, 11, 169}, + DictWord{ + 7, + 11, + 333, + }, + DictWord{136, 11, 45}, + DictWord{12, 10, 97}, + DictWord{140, 11, 97}, + DictWord{4, 0, 408}, + DictWord{4, 0, 741}, + DictWord{135, 0, 500}, + DictWord{ + 132, + 11, + 198, + }, + DictWord{7, 10, 388}, + DictWord{7, 10, 644}, + DictWord{139, 10, 781}, + DictWord{4, 11, 24}, + DictWord{5, 11, 140}, + DictWord{5, 11, 185}, + DictWord{ + 7, + 11, + 1500, + }, + DictWord{11, 11, 565}, + DictWord{139, 11, 838}, + DictWord{6, 0, 1321}, + DictWord{9, 0, 257}, + DictWord{7, 10, 229}, + DictWord{8, 10, 59}, + DictWord{ + 9, + 10, + 190, + }, + DictWord{10, 10, 378}, + DictWord{140, 10, 191}, + DictWord{4, 11, 334}, + DictWord{133, 11, 593}, + DictWord{135, 11, 1885}, + DictWord{134, 0, 1138}, + DictWord{4, 0, 249}, + DictWord{6, 0, 73}, + DictWord{135, 0, 177}, + DictWord{133, 0, 576}, + DictWord{142, 0, 231}, + DictWord{137, 0, 288}, + DictWord{132, 10, 660}, + DictWord{7, 10, 1035}, + DictWord{138, 10, 737}, + DictWord{135, 0, 1487}, + DictWord{6, 0, 989}, + DictWord{9, 0, 433}, + DictWord{7, 10, 690}, + DictWord{9, 10, 587}, + DictWord{140, 10, 521}, + DictWord{7, 0, 1264}, + DictWord{7, 0, 1678}, + DictWord{11, 0, 945}, + DictWord{12, 0, 341}, + DictWord{12, 0, 471}, + DictWord{140, 0, 569}, + DictWord{132, 11, 709}, + DictWord{133, 11, 897}, + DictWord{5, 11, 224}, + DictWord{13, 11, 174}, + DictWord{146, 11, 52}, + DictWord{135, 11, 1840}, + DictWord{ + 134, + 10, + 1744, + }, + DictWord{12, 0, 87}, + DictWord{16, 0, 74}, + DictWord{4, 10, 733}, + DictWord{9, 10, 194}, + DictWord{10, 10, 92}, + DictWord{11, 10, 198}, + DictWord{ + 12, + 10, + 84, + }, + DictWord{141, 10, 128}, + DictWord{140, 0, 779}, + DictWord{135, 0, 538}, + DictWord{4, 11, 608}, + DictWord{133, 11, 497}, + DictWord{133, 0, 413}, + DictWord{7, 11, 1375}, + DictWord{7, 11, 1466}, + DictWord{138, 11, 331}, + DictWord{136, 0, 495}, + DictWord{6, 11, 540}, + DictWord{136, 11, 136}, + DictWord{7, 0, 54}, + DictWord{8, 0, 312}, + DictWord{10, 0, 191}, + DictWord{10, 0, 614}, + DictWord{140, 0, 567}, + DictWord{6, 0, 468}, + DictWord{7, 0, 567}, + DictWord{7, 0, 1478}, + DictWord{ + 8, + 0, + 530, + }, + DictWord{14, 0, 290}, + DictWord{133, 11, 999}, + DictWord{4, 11, 299}, + DictWord{7, 10, 306}, + DictWord{135, 11, 1004}, + DictWord{142, 11, 296}, + DictWord{134, 0, 1484}, + DictWord{133, 10, 979}, + DictWord{6, 0, 609}, + DictWord{9, 0, 815}, + DictWord{12, 11, 137}, + DictWord{14, 11, 9}, + DictWord{14, 11, 24}, + DictWord{142, 11, 64}, + DictWord{133, 11, 456}, + DictWord{6, 0, 484}, + DictWord{135, 0, 822}, + DictWord{133, 10, 178}, + DictWord{136, 11, 180}, + DictWord{ + 132, + 11, + 755, + }, + DictWord{137, 0, 900}, + DictWord{135, 0, 1335}, + DictWord{6, 0, 1724}, + DictWord{135, 0, 2022}, + DictWord{135, 11, 1139}, + DictWord{5, 0, 640}, + DictWord{132, 10, 390}, + DictWord{6, 0, 1831}, + DictWord{138, 11, 633}, + DictWord{135, 11, 566}, + DictWord{4, 11, 890}, + DictWord{5, 11, 805}, + DictWord{5, 11, 819}, + DictWord{5, 11, 961}, + DictWord{6, 11, 396}, + DictWord{6, 11, 1631}, + DictWord{6, 11, 1678}, + DictWord{7, 11, 1967}, + DictWord{7, 11, 2041}, + DictWord{ + 9, + 11, + 630, + }, + DictWord{11, 11, 8}, + DictWord{11, 11, 1019}, + DictWord{12, 11, 176}, + DictWord{13, 11, 225}, + DictWord{14, 11, 292}, + DictWord{149, 11, 24}, + DictWord{ + 132, + 0, + 474, + }, + DictWord{134, 0, 1103}, + DictWord{135, 0, 1504}, + DictWord{134, 0, 1576}, + DictWord{6, 0, 961}, + DictWord{6, 0, 1034}, + DictWord{140, 0, 655}, + DictWord{11, 11, 514}, + DictWord{149, 11, 20}, + DictWord{5, 0, 305}, + DictWord{135, 11, 1815}, + DictWord{7, 11, 1505}, + DictWord{10, 11, 190}, + DictWord{ + 10, + 11, + 634, + }, + DictWord{11, 11, 792}, + DictWord{12, 11, 358}, + DictWord{140, 11, 447}, + DictWord{5, 11, 0}, + DictWord{6, 11, 536}, + DictWord{7, 11, 604}, + DictWord{ + 13, + 11, + 445, + }, + DictWord{145, 11, 126}, + DictWord{7, 0, 1236}, + DictWord{133, 10, 105}, + DictWord{4, 0, 480}, + DictWord{6, 0, 217}, + DictWord{6, 0, 302}, + DictWord{ + 6, + 0, + 1642, + }, + DictWord{7, 0, 130}, + DictWord{7, 0, 837}, + DictWord{7, 0, 1321}, + DictWord{7, 0, 1547}, + DictWord{7, 0, 1657}, + DictWord{8, 0, 429}, + DictWord{9, 0, 228}, + DictWord{13, 0, 289}, + DictWord{13, 0, 343}, + DictWord{19, 0, 101}, + DictWord{6, 11, 232}, + DictWord{6, 11, 412}, + DictWord{7, 11, 1074}, + DictWord{8, 11, 9}, + DictWord{ + 8, + 11, + 157, + }, + DictWord{8, 11, 786}, + DictWord{9, 11, 196}, + DictWord{9, 11, 352}, + DictWord{9, 11, 457}, + DictWord{10, 11, 337}, + DictWord{11, 11, 232}, + DictWord{ + 11, + 11, + 877, + }, + DictWord{12, 11, 480}, + DictWord{140, 11, 546}, + DictWord{5, 10, 438}, + DictWord{7, 11, 958}, + DictWord{9, 10, 694}, + DictWord{12, 10, 627}, + DictWord{ + 13, + 11, + 38, + }, + DictWord{141, 10, 210}, + DictWord{4, 11, 382}, + DictWord{136, 11, 579}, + DictWord{7, 0, 278}, + DictWord{10, 0, 739}, + DictWord{11, 0, 708}, + DictWord{ + 141, + 0, + 348, + }, + DictWord{4, 11, 212}, + DictWord{135, 11, 1206}, + DictWord{135, 11, 1898}, + DictWord{6, 0, 708}, + DictWord{6, 0, 1344}, + DictWord{152, 10, 11}, + DictWord{137, 11, 768}, + DictWord{134, 0, 1840}, + DictWord{140, 0, 233}, + DictWord{8, 10, 25}, + DictWord{138, 10, 826}, + DictWord{6, 0, 2017}, + DictWord{ + 133, + 11, + 655, + }, + DictWord{6, 0, 1488}, + DictWord{139, 11, 290}, + DictWord{132, 10, 308}, + DictWord{134, 0, 1590}, + DictWord{134, 0, 1800}, + DictWord{134, 0, 1259}, + DictWord{16, 0, 28}, + DictWord{6, 11, 231}, + DictWord{7, 11, 95}, + DictWord{136, 11, 423}, + DictWord{133, 11, 300}, + DictWord{135, 10, 150}, + DictWord{ + 136, + 10, + 649, + }, + DictWord{7, 11, 1874}, + DictWord{137, 11, 641}, + DictWord{6, 11, 237}, + DictWord{7, 11, 611}, + DictWord{8, 11, 100}, + DictWord{9, 11, 416}, + DictWord{ + 11, + 11, + 335, + }, + DictWord{12, 11, 173}, + DictWord{146, 11, 101}, + DictWord{137, 0, 45}, + DictWord{134, 10, 521}, + DictWord{17, 0, 36}, + DictWord{14, 11, 26}, + DictWord{ + 146, + 11, + 150, + }, + DictWord{7, 0, 1442}, + DictWord{14, 0, 22}, + DictWord{5, 10, 339}, + DictWord{15, 10, 41}, + DictWord{15, 10, 166}, + DictWord{147, 10, 66}, + DictWord{ + 8, + 0, + 378, + }, + DictWord{6, 11, 581}, + DictWord{135, 11, 1119}, + DictWord{134, 0, 1507}, + DictWord{147, 11, 117}, + DictWord{139, 0, 39}, + DictWord{134, 0, 1054}, + DictWord{6, 0, 363}, + DictWord{7, 0, 1955}, + DictWord{136, 0, 725}, + DictWord{134, 0, 2036}, + DictWord{133, 11, 199}, + DictWord{6, 0, 1871}, + DictWord{9, 0, 935}, + DictWord{9, 0, 961}, + DictWord{9, 0, 1004}, + DictWord{9, 0, 1016}, + DictWord{12, 0, 805}, + DictWord{12, 0, 852}, + DictWord{12, 0, 853}, + DictWord{12, 0, 869}, + DictWord{ + 12, + 0, + 882, + }, + DictWord{12, 0, 896}, + DictWord{12, 0, 906}, + DictWord{12, 0, 917}, + DictWord{12, 0, 940}, + DictWord{15, 0, 170}, + DictWord{15, 0, 176}, + DictWord{ + 15, + 0, + 188, + }, + DictWord{15, 0, 201}, + DictWord{15, 0, 205}, + DictWord{15, 0, 212}, + DictWord{15, 0, 234}, + DictWord{15, 0, 244}, + DictWord{18, 0, 181}, + DictWord{18, 0, 193}, + DictWord{18, 0, 196}, + DictWord{18, 0, 201}, + DictWord{18, 0, 202}, + DictWord{18, 0, 210}, + DictWord{18, 0, 217}, + DictWord{18, 0, 235}, + DictWord{18, 0, 236}, + DictWord{18, 0, 237}, + DictWord{21, 0, 54}, + DictWord{21, 0, 55}, + DictWord{21, 0, 58}, + DictWord{21, 0, 59}, + DictWord{152, 0, 22}, + DictWord{134, 10, 1628}, + DictWord{ + 137, + 0, + 805, + }, + DictWord{5, 0, 813}, + DictWord{135, 0, 2046}, + DictWord{142, 11, 42}, + DictWord{5, 0, 712}, + DictWord{6, 0, 1240}, + DictWord{11, 0, 17}, + DictWord{ + 13, + 0, + 321, + }, + DictWord{144, 0, 67}, + DictWord{132, 0, 617}, + DictWord{135, 10, 829}, + DictWord{6, 0, 320}, + DictWord{7, 0, 781}, + DictWord{7, 0, 1921}, + DictWord{9, 0, 55}, + DictWord{10, 0, 186}, + DictWord{10, 0, 273}, + DictWord{10, 0, 664}, + DictWord{10, 0, 801}, + DictWord{11, 0, 996}, + DictWord{11, 0, 997}, + DictWord{13, 0, 157}, + DictWord{142, 0, 170}, + DictWord{136, 0, 271}, + DictWord{5, 10, 486}, + DictWord{135, 10, 1349}, + DictWord{18, 11, 91}, + DictWord{147, 11, 70}, + DictWord{10, 0, 445}, + DictWord{7, 10, 1635}, + DictWord{8, 10, 17}, + DictWord{138, 10, 295}, + DictWord{136, 11, 404}, + DictWord{7, 0, 103}, + DictWord{7, 0, 863}, + DictWord{11, 0, 184}, + DictWord{145, 0, 62}, + DictWord{138, 10, 558}, + DictWord{137, 0, 659}, + DictWord{6, 11, 312}, + DictWord{6, 11, 1715}, + DictWord{10, 11, 584}, + DictWord{ + 11, + 11, + 546, + }, + DictWord{11, 11, 692}, + DictWord{12, 11, 259}, + DictWord{12, 11, 295}, + DictWord{13, 11, 46}, + DictWord{141, 11, 154}, + DictWord{134, 0, 676}, + DictWord{132, 11, 588}, + DictWord{4, 11, 231}, + DictWord{5, 11, 61}, + DictWord{6, 11, 104}, + DictWord{7, 11, 729}, + DictWord{7, 11, 964}, + DictWord{7, 11, 1658}, + DictWord{140, 11, 414}, + DictWord{6, 11, 263}, + DictWord{138, 11, 757}, + DictWord{11, 0, 337}, + DictWord{142, 0, 303}, + DictWord{135, 11, 1363}, + DictWord{ + 132, + 11, + 320, + }, + DictWord{140, 0, 506}, + DictWord{134, 10, 447}, + DictWord{5, 0, 77}, + DictWord{7, 0, 1455}, + DictWord{10, 0, 843}, + DictWord{147, 0, 73}, + DictWord{ + 7, + 10, + 577, + }, + DictWord{7, 10, 1432}, + DictWord{9, 10, 475}, + DictWord{9, 10, 505}, + DictWord{9, 10, 526}, + DictWord{9, 10, 609}, + DictWord{9, 10, 689}, + DictWord{ + 9, + 10, + 726, + }, + DictWord{9, 10, 735}, + DictWord{9, 10, 738}, + DictWord{10, 10, 556}, + DictWord{10, 10, 674}, + DictWord{10, 10, 684}, + DictWord{11, 10, 89}, + DictWord{ + 11, + 10, + 202, + }, + DictWord{11, 10, 272}, + DictWord{11, 10, 380}, + DictWord{11, 10, 415}, + DictWord{11, 10, 505}, + DictWord{11, 10, 537}, + DictWord{11, 10, 550}, + DictWord{11, 10, 562}, + DictWord{11, 10, 640}, + DictWord{11, 10, 667}, + DictWord{11, 10, 688}, + DictWord{11, 10, 847}, + DictWord{11, 10, 927}, + DictWord{ + 11, + 10, + 930, + }, + DictWord{11, 10, 940}, + DictWord{12, 10, 144}, + DictWord{12, 10, 325}, + DictWord{12, 10, 329}, + DictWord{12, 10, 389}, + DictWord{12, 10, 403}, + DictWord{ + 12, + 10, + 451, + }, + DictWord{12, 10, 515}, + DictWord{12, 10, 604}, + DictWord{12, 10, 616}, + DictWord{12, 10, 626}, + DictWord{13, 10, 66}, + DictWord{13, 10, 131}, + DictWord{13, 10, 167}, + DictWord{13, 10, 236}, + DictWord{13, 10, 368}, + DictWord{13, 10, 411}, + DictWord{13, 10, 434}, + DictWord{13, 10, 453}, + DictWord{ + 13, + 10, + 461, + }, + DictWord{13, 10, 474}, + DictWord{14, 10, 59}, + DictWord{14, 10, 60}, + DictWord{14, 10, 139}, + DictWord{14, 10, 152}, + DictWord{14, 10, 276}, + DictWord{ + 14, + 10, + 353, + }, + DictWord{14, 10, 402}, + DictWord{15, 10, 28}, + DictWord{15, 10, 81}, + DictWord{15, 10, 123}, + DictWord{15, 10, 152}, + DictWord{18, 10, 136}, + DictWord{148, 10, 88}, + DictWord{132, 0, 458}, + DictWord{135, 0, 1420}, + DictWord{6, 0, 109}, + DictWord{10, 0, 382}, + DictWord{4, 11, 405}, + DictWord{4, 10, 609}, + DictWord{7, 10, 756}, + DictWord{7, 11, 817}, + DictWord{9, 10, 544}, + DictWord{11, 10, 413}, + DictWord{14, 11, 58}, + DictWord{14, 10, 307}, + DictWord{16, 10, 25}, + DictWord{17, 11, 37}, + DictWord{146, 11, 124}, + DictWord{6, 0, 330}, + DictWord{7, 0, 1084}, + DictWord{11, 0, 142}, + DictWord{133, 11, 974}, + DictWord{4, 10, 930}, + DictWord{133, 10, 947}, + DictWord{5, 10, 939}, + DictWord{142, 11, 394}, + DictWord{16, 0, 91}, + DictWord{145, 0, 87}, + DictWord{5, 11, 235}, + DictWord{5, 10, 962}, + DictWord{7, 11, 1239}, + DictWord{11, 11, 131}, + DictWord{140, 11, 370}, + DictWord{11, 0, 492}, + DictWord{5, 10, 651}, + DictWord{8, 10, 170}, + DictWord{9, 10, 61}, + DictWord{9, 10, 63}, + DictWord{10, 10, 23}, + DictWord{10, 10, 37}, + DictWord{10, 10, 834}, + DictWord{11, 10, 4}, + DictWord{11, 10, 281}, + DictWord{11, 10, 503}, + DictWord{ + 11, + 10, + 677, + }, + DictWord{12, 10, 96}, + DictWord{12, 10, 130}, + DictWord{12, 10, 244}, + DictWord{14, 10, 5}, + DictWord{14, 10, 40}, + DictWord{14, 10, 162}, + DictWord{ + 14, + 10, + 202, + }, + DictWord{146, 10, 133}, + DictWord{4, 10, 406}, + DictWord{5, 10, 579}, + DictWord{12, 10, 492}, + DictWord{150, 10, 15}, + DictWord{9, 11, 137}, + DictWord{138, 11, 221}, + DictWord{134, 0, 1239}, + DictWord{11, 0, 211}, + DictWord{140, 0, 145}, + DictWord{7, 11, 390}, + DictWord{138, 11, 140}, + DictWord{ + 135, + 11, + 1418, + }, + DictWord{135, 11, 1144}, + DictWord{134, 0, 1049}, + DictWord{7, 0, 321}, + DictWord{6, 10, 17}, + DictWord{7, 10, 1001}, + DictWord{7, 10, 1982}, + DictWord{ + 9, + 10, + 886, + }, + DictWord{10, 10, 489}, + DictWord{10, 10, 800}, + DictWord{11, 10, 782}, + DictWord{12, 10, 320}, + DictWord{13, 10, 467}, + DictWord{14, 10, 145}, + DictWord{14, 10, 387}, + DictWord{143, 10, 119}, + DictWord{145, 10, 17}, + DictWord{5, 11, 407}, + DictWord{11, 11, 489}, + DictWord{19, 11, 37}, + DictWord{20, 11, 73}, + DictWord{150, 11, 38}, + DictWord{133, 10, 458}, + DictWord{135, 0, 1985}, + DictWord{7, 10, 1983}, + DictWord{8, 10, 0}, + DictWord{8, 10, 171}, + DictWord{ + 9, + 10, + 120, + }, + DictWord{9, 10, 732}, + DictWord{10, 10, 473}, + DictWord{11, 10, 656}, + DictWord{11, 10, 998}, + DictWord{18, 10, 0}, + DictWord{18, 10, 2}, + DictWord{ + 147, + 10, + 21, + }, + DictWord{5, 11, 325}, + DictWord{7, 11, 1483}, + DictWord{8, 11, 5}, + DictWord{8, 11, 227}, + DictWord{9, 11, 105}, + DictWord{10, 11, 585}, + DictWord{ + 140, + 11, + 614, + }, + DictWord{136, 0, 122}, + DictWord{132, 0, 234}, + DictWord{135, 11, 1196}, + DictWord{6, 0, 976}, + DictWord{6, 0, 1098}, + DictWord{134, 0, 1441}, + DictWord{ + 7, + 0, + 253, + }, + DictWord{136, 0, 549}, + DictWord{6, 11, 621}, + DictWord{13, 11, 504}, + DictWord{144, 11, 19}, + DictWord{132, 10, 519}, + DictWord{5, 0, 430}, + DictWord{ + 5, + 0, + 932, + }, + DictWord{6, 0, 131}, + DictWord{7, 0, 417}, + DictWord{9, 0, 522}, + DictWord{11, 0, 314}, + DictWord{141, 0, 390}, + DictWord{14, 0, 149}, + DictWord{14, 0, 399}, + DictWord{143, 0, 57}, + DictWord{5, 10, 907}, + DictWord{6, 10, 31}, + DictWord{6, 11, 218}, + DictWord{7, 10, 491}, + DictWord{7, 10, 530}, + DictWord{8, 10, 592}, + DictWord{11, 10, 53}, + DictWord{11, 10, 779}, + DictWord{12, 10, 167}, + DictWord{12, 10, 411}, + DictWord{14, 10, 14}, + DictWord{14, 10, 136}, + DictWord{15, 10, 72}, + DictWord{16, 10, 17}, + DictWord{144, 10, 72}, + DictWord{140, 11, 330}, + DictWord{7, 11, 454}, + DictWord{7, 11, 782}, + DictWord{136, 11, 768}, + DictWord{ + 132, + 0, + 507, + }, + DictWord{10, 11, 676}, + DictWord{140, 11, 462}, + DictWord{6, 0, 630}, + DictWord{9, 0, 811}, + DictWord{4, 10, 208}, + DictWord{5, 10, 106}, + DictWord{ + 6, + 10, + 531, + }, + DictWord{8, 10, 408}, + DictWord{9, 10, 188}, + DictWord{138, 10, 572}, + DictWord{4, 0, 343}, + DictWord{5, 0, 511}, + DictWord{134, 10, 1693}, + DictWord{ + 134, + 11, + 164, + }, + DictWord{132, 0, 448}, + DictWord{7, 0, 455}, + DictWord{138, 0, 591}, + DictWord{135, 0, 1381}, + DictWord{12, 10, 441}, + DictWord{150, 11, 50}, + DictWord{9, 10, 449}, + DictWord{10, 10, 192}, + DictWord{138, 10, 740}, + DictWord{6, 0, 575}, + DictWord{132, 10, 241}, + DictWord{134, 0, 1175}, + DictWord{ + 134, + 0, + 653, + }, + DictWord{134, 0, 1761}, + DictWord{134, 0, 1198}, + DictWord{132, 10, 259}, + DictWord{6, 11, 343}, + DictWord{7, 11, 195}, + DictWord{9, 11, 226}, + DictWord{ + 10, + 11, + 197, + }, + DictWord{10, 11, 575}, + DictWord{11, 11, 502}, + DictWord{139, 11, 899}, + DictWord{7, 0, 1127}, + DictWord{7, 0, 1572}, + DictWord{10, 0, 297}, + DictWord{10, 0, 422}, + DictWord{11, 0, 764}, + DictWord{11, 0, 810}, + DictWord{12, 0, 264}, + DictWord{13, 0, 102}, + DictWord{13, 0, 300}, + DictWord{13, 0, 484}, + DictWord{ + 14, + 0, + 147, + }, + DictWord{14, 0, 229}, + DictWord{17, 0, 71}, + DictWord{18, 0, 118}, + DictWord{147, 0, 120}, + DictWord{135, 11, 666}, + DictWord{132, 0, 678}, + DictWord{ + 4, + 10, + 173, + }, + DictWord{5, 10, 312}, + DictWord{5, 10, 512}, + DictWord{135, 10, 1285}, + DictWord{7, 10, 1603}, + DictWord{7, 10, 1691}, + DictWord{9, 10, 464}, + DictWord{11, 10, 195}, + DictWord{12, 10, 279}, + DictWord{12, 10, 448}, + DictWord{14, 10, 11}, + DictWord{147, 10, 102}, + DictWord{16, 0, 99}, + DictWord{146, 0, 164}, + DictWord{7, 11, 1125}, + DictWord{9, 11, 143}, + DictWord{11, 11, 61}, + DictWord{14, 11, 405}, + DictWord{150, 11, 21}, + DictWord{137, 11, 260}, + DictWord{ + 4, + 10, + 452, + }, + DictWord{5, 10, 583}, + DictWord{5, 10, 817}, + DictWord{6, 10, 433}, + DictWord{7, 10, 593}, + DictWord{7, 10, 720}, + DictWord{7, 10, 1378}, + DictWord{ + 8, + 10, + 161, + }, + DictWord{9, 10, 284}, + DictWord{10, 10, 313}, + DictWord{139, 10, 886}, + DictWord{132, 10, 547}, + DictWord{136, 10, 722}, + DictWord{14, 0, 35}, + DictWord{142, 0, 191}, + DictWord{141, 0, 45}, + DictWord{138, 0, 121}, + DictWord{132, 0, 125}, + DictWord{134, 0, 1622}, + DictWord{133, 11, 959}, + DictWord{ + 8, + 10, + 420, + }, + DictWord{139, 10, 193}, + DictWord{132, 0, 721}, + DictWord{135, 10, 409}, + DictWord{136, 0, 145}, + DictWord{7, 0, 792}, + DictWord{8, 0, 147}, + DictWord{ + 10, + 0, + 821, + }, + DictWord{11, 0, 970}, + DictWord{11, 0, 1021}, + DictWord{136, 11, 173}, + DictWord{134, 11, 266}, + DictWord{132, 0, 715}, + DictWord{7, 0, 1999}, + DictWord{138, 10, 308}, + DictWord{133, 0, 531}, + DictWord{5, 0, 168}, + DictWord{5, 0, 930}, + DictWord{8, 0, 74}, + DictWord{9, 0, 623}, + DictWord{12, 0, 500}, + DictWord{ + 140, + 0, + 579, + }, + DictWord{144, 0, 65}, + DictWord{138, 11, 246}, + DictWord{6, 0, 220}, + DictWord{7, 0, 1101}, + DictWord{13, 0, 105}, + DictWord{142, 11, 314}, + DictWord{ + 5, + 10, + 1002, + }, + DictWord{136, 10, 745}, + DictWord{134, 0, 960}, + DictWord{20, 0, 0}, + DictWord{148, 11, 0}, + DictWord{4, 0, 1005}, + DictWord{4, 10, 239}, + DictWord{ + 6, + 10, + 477, + }, + DictWord{7, 10, 1607}, + DictWord{11, 10, 68}, + DictWord{139, 10, 617}, + DictWord{6, 0, 19}, + DictWord{7, 0, 1413}, + DictWord{139, 0, 428}, + DictWord{ + 149, + 10, + 13, + }, + DictWord{7, 0, 96}, + DictWord{8, 0, 401}, + DictWord{8, 0, 703}, + DictWord{9, 0, 896}, + DictWord{136, 11, 300}, + DictWord{134, 0, 1595}, + DictWord{145, 0, 116}, + DictWord{136, 0, 1021}, + DictWord{7, 0, 1961}, + DictWord{7, 0, 1965}, + DictWord{7, 0, 2030}, + DictWord{8, 0, 150}, + DictWord{8, 0, 702}, + DictWord{8, 0, 737}, + DictWord{ + 8, + 0, + 750, + }, + DictWord{140, 0, 366}, + DictWord{11, 11, 75}, + DictWord{142, 11, 267}, + DictWord{132, 10, 367}, + DictWord{8, 0, 800}, + DictWord{9, 0, 148}, + DictWord{ + 9, + 0, + 872, + }, + DictWord{9, 0, 890}, + DictWord{11, 0, 309}, + DictWord{11, 0, 1001}, + DictWord{13, 0, 267}, + DictWord{13, 0, 323}, + DictWord{5, 11, 427}, + DictWord{ + 5, + 11, + 734, + }, + DictWord{7, 11, 478}, + DictWord{136, 11, 52}, + DictWord{7, 11, 239}, + DictWord{11, 11, 217}, + DictWord{142, 11, 165}, + DictWord{132, 11, 323}, + DictWord{140, 11, 419}, + DictWord{13, 0, 299}, + DictWord{142, 0, 75}, + DictWord{6, 11, 87}, + DictWord{6, 11, 1734}, + DictWord{7, 11, 20}, + DictWord{7, 11, 1056}, + DictWord{ + 8, + 11, + 732, + }, + DictWord{9, 11, 406}, + DictWord{9, 11, 911}, + DictWord{138, 11, 694}, + DictWord{134, 0, 1383}, + DictWord{132, 10, 694}, + DictWord{ + 133, + 11, + 613, + }, + DictWord{137, 0, 779}, + DictWord{4, 0, 598}, + DictWord{140, 10, 687}, + DictWord{6, 0, 970}, + DictWord{135, 0, 424}, + DictWord{133, 0, 547}, + DictWord{ + 7, + 11, + 32, + }, + DictWord{7, 11, 984}, + DictWord{8, 11, 85}, + DictWord{8, 11, 709}, + DictWord{9, 11, 579}, + DictWord{9, 11, 847}, + DictWord{9, 11, 856}, + DictWord{10, 11, 799}, + DictWord{11, 11, 258}, + DictWord{11, 11, 1007}, + DictWord{12, 11, 331}, + DictWord{12, 11, 615}, + DictWord{13, 11, 188}, + DictWord{13, 11, 435}, + DictWord{ + 14, + 11, + 8, + }, + DictWord{15, 11, 165}, + DictWord{16, 11, 27}, + DictWord{148, 11, 40}, + DictWord{6, 0, 1222}, + DictWord{134, 0, 1385}, + DictWord{132, 0, 876}, + DictWord{ + 138, + 11, + 151, + }, + DictWord{135, 10, 213}, + DictWord{4, 11, 167}, + DictWord{135, 11, 82}, + DictWord{133, 0, 133}, + DictWord{6, 11, 24}, + DictWord{7, 11, 74}, + DictWord{ + 7, + 11, + 678, + }, + DictWord{137, 11, 258}, + DictWord{5, 11, 62}, + DictWord{6, 11, 534}, + DictWord{7, 11, 684}, + DictWord{7, 11, 1043}, + DictWord{7, 11, 1072}, + DictWord{ + 8, + 11, + 280, + }, + DictWord{8, 11, 541}, + DictWord{8, 11, 686}, + DictWord{10, 11, 519}, + DictWord{11, 11, 252}, + DictWord{140, 11, 282}, + DictWord{136, 0, 187}, + DictWord{8, 0, 8}, + DictWord{10, 0, 0}, + DictWord{10, 0, 818}, + DictWord{139, 0, 988}, + DictWord{132, 11, 359}, + DictWord{11, 0, 429}, + DictWord{15, 0, 51}, + DictWord{ + 135, + 10, + 1672, + }, + DictWord{136, 0, 685}, + DictWord{5, 11, 211}, + DictWord{7, 11, 88}, + DictWord{136, 11, 627}, + DictWord{134, 0, 472}, + DictWord{136, 0, 132}, + DictWord{ + 6, + 11, + 145, + }, + DictWord{141, 11, 336}, + DictWord{4, 10, 751}, + DictWord{11, 10, 390}, + DictWord{140, 10, 32}, + DictWord{6, 0, 938}, + DictWord{6, 0, 1060}, + DictWord{ + 4, + 11, + 263, + }, + DictWord{4, 10, 409}, + DictWord{133, 10, 78}, + DictWord{137, 0, 874}, + DictWord{8, 0, 774}, + DictWord{10, 0, 670}, + DictWord{12, 0, 51}, + DictWord{ + 4, + 11, + 916, + }, + DictWord{6, 10, 473}, + DictWord{7, 10, 1602}, + DictWord{10, 10, 698}, + DictWord{12, 10, 212}, + DictWord{13, 10, 307}, + DictWord{145, 10, 105}, + DictWord{146, 0, 92}, + DictWord{143, 10, 156}, + DictWord{132, 0, 830}, + DictWord{137, 0, 701}, + DictWord{4, 11, 599}, + DictWord{6, 11, 1634}, + DictWord{7, 11, 5}, + DictWord{7, 11, 55}, + DictWord{7, 11, 67}, + DictWord{7, 11, 97}, + DictWord{7, 11, 691}, + DictWord{7, 11, 979}, + DictWord{7, 11, 1697}, + DictWord{8, 11, 207}, + DictWord{ + 8, + 11, + 214, + }, + DictWord{8, 11, 231}, + DictWord{8, 11, 294}, + DictWord{8, 11, 336}, + DictWord{8, 11, 428}, + DictWord{8, 11, 451}, + DictWord{8, 11, 460}, + DictWord{8, 11, 471}, + DictWord{8, 11, 622}, + DictWord{8, 11, 626}, + DictWord{8, 11, 679}, + DictWord{8, 11, 759}, + DictWord{8, 11, 829}, + DictWord{9, 11, 11}, + DictWord{9, 11, 246}, + DictWord{ + 9, + 11, + 484, + }, + DictWord{9, 11, 573}, + DictWord{9, 11, 706}, + DictWord{9, 11, 762}, + DictWord{9, 11, 798}, + DictWord{9, 11, 855}, + DictWord{9, 11, 870}, + DictWord{ + 9, + 11, + 912, + }, + DictWord{10, 11, 303}, + DictWord{10, 11, 335}, + DictWord{10, 11, 424}, + DictWord{10, 11, 461}, + DictWord{10, 11, 543}, + DictWord{10, 11, 759}, + DictWord{10, 11, 814}, + DictWord{11, 11, 59}, + DictWord{11, 11, 199}, + DictWord{11, 11, 235}, + DictWord{11, 11, 475}, + DictWord{11, 11, 590}, + DictWord{11, 11, 929}, + DictWord{11, 11, 963}, + DictWord{12, 11, 114}, + DictWord{12, 11, 182}, + DictWord{12, 11, 226}, + DictWord{12, 11, 332}, + DictWord{12, 11, 439}, + DictWord{ + 12, + 11, + 575, + }, + DictWord{12, 11, 598}, + DictWord{13, 11, 8}, + DictWord{13, 11, 125}, + DictWord{13, 11, 194}, + DictWord{13, 11, 287}, + DictWord{14, 11, 197}, + DictWord{ + 14, + 11, + 383, + }, + DictWord{15, 11, 53}, + DictWord{17, 11, 63}, + DictWord{19, 11, 46}, + DictWord{19, 11, 98}, + DictWord{19, 11, 106}, + DictWord{148, 11, 85}, + DictWord{ + 4, + 0, + 127, + }, + DictWord{5, 0, 350}, + DictWord{6, 0, 356}, + DictWord{8, 0, 426}, + DictWord{9, 0, 572}, + DictWord{10, 0, 247}, + DictWord{139, 0, 312}, + DictWord{134, 0, 1215}, + DictWord{6, 0, 59}, + DictWord{9, 0, 603}, + DictWord{13, 0, 397}, + DictWord{7, 11, 1853}, + DictWord{138, 11, 437}, + DictWord{134, 0, 1762}, + DictWord{ + 147, + 11, + 126, + }, + DictWord{135, 10, 883}, + DictWord{13, 0, 293}, + DictWord{142, 0, 56}, + DictWord{133, 10, 617}, + DictWord{139, 10, 50}, + DictWord{5, 11, 187}, + DictWord{ + 7, + 10, + 1518, + }, + DictWord{139, 10, 694}, + DictWord{135, 0, 441}, + DictWord{6, 0, 111}, + DictWord{7, 0, 4}, + DictWord{8, 0, 163}, + DictWord{8, 0, 776}, + DictWord{ + 138, + 0, + 566, + }, + DictWord{132, 0, 806}, + DictWord{4, 11, 215}, + DictWord{9, 11, 38}, + DictWord{10, 11, 3}, + DictWord{11, 11, 23}, + DictWord{11, 11, 127}, + DictWord{ + 139, + 11, + 796, + }, + DictWord{14, 0, 233}, + DictWord{4, 10, 546}, + DictWord{135, 10, 2042}, + DictWord{135, 0, 1994}, + DictWord{134, 0, 1739}, + DictWord{135, 11, 1530}, + DictWord{136, 0, 393}, + DictWord{5, 0, 297}, + DictWord{7, 0, 1038}, + DictWord{14, 0, 359}, + DictWord{19, 0, 52}, + DictWord{148, 0, 47}, + DictWord{135, 0, 309}, + DictWord{ + 4, + 10, + 313, + }, + DictWord{133, 10, 577}, + DictWord{8, 10, 184}, + DictWord{141, 10, 433}, + DictWord{135, 10, 935}, + DictWord{12, 10, 186}, + DictWord{ + 12, + 10, + 292, + }, + DictWord{14, 10, 100}, + DictWord{146, 10, 70}, + DictWord{136, 0, 363}, + DictWord{14, 0, 175}, + DictWord{11, 10, 402}, + DictWord{12, 10, 109}, + DictWord{ + 12, + 10, + 431, + }, + DictWord{13, 10, 179}, + DictWord{13, 10, 206}, + DictWord{14, 10, 217}, + DictWord{16, 10, 3}, + DictWord{148, 10, 53}, + DictWord{5, 10, 886}, + DictWord{ + 6, + 10, + 46, + }, + DictWord{6, 10, 1790}, + DictWord{7, 10, 14}, + DictWord{7, 10, 732}, + DictWord{7, 10, 1654}, + DictWord{8, 10, 95}, + DictWord{8, 10, 327}, + DictWord{ + 8, + 10, + 616, + }, + DictWord{9, 10, 892}, + DictWord{10, 10, 598}, + DictWord{10, 10, 769}, + DictWord{11, 10, 134}, + DictWord{11, 10, 747}, + DictWord{12, 10, 378}, + DictWord{ + 142, + 10, + 97, + }, + DictWord{136, 0, 666}, + DictWord{135, 0, 1675}, + DictWord{6, 0, 655}, + DictWord{134, 0, 1600}, + DictWord{135, 0, 808}, + DictWord{133, 10, 1021}, + DictWord{4, 11, 28}, + DictWord{5, 11, 440}, + DictWord{7, 11, 248}, + DictWord{11, 11, 833}, + DictWord{140, 11, 344}, + DictWord{134, 11, 1654}, + DictWord{ + 132, + 0, + 280, + }, + DictWord{140, 0, 54}, + DictWord{4, 0, 421}, + DictWord{133, 0, 548}, + DictWord{132, 10, 153}, + DictWord{6, 11, 339}, + DictWord{135, 11, 923}, + DictWord{ + 133, + 11, + 853, + }, + DictWord{133, 10, 798}, + DictWord{132, 10, 587}, + DictWord{6, 11, 249}, + DictWord{7, 11, 1234}, + DictWord{139, 11, 573}, + DictWord{6, 10, 598}, + DictWord{7, 10, 42}, + DictWord{8, 10, 695}, + DictWord{10, 10, 212}, + DictWord{11, 10, 158}, + DictWord{14, 10, 196}, + DictWord{145, 10, 85}, + DictWord{7, 0, 249}, + DictWord{5, 10, 957}, + DictWord{133, 10, 1008}, + DictWord{4, 10, 129}, + DictWord{135, 10, 465}, + DictWord{6, 0, 254}, + DictWord{7, 0, 842}, + DictWord{7, 0, 1659}, + DictWord{9, 0, 109}, + DictWord{10, 0, 103}, + DictWord{7, 10, 908}, + DictWord{7, 10, 1201}, + DictWord{9, 10, 755}, + DictWord{11, 10, 906}, + DictWord{12, 10, 527}, + DictWord{146, 10, 7}, + DictWord{5, 0, 262}, + DictWord{136, 10, 450}, + DictWord{144, 0, 1}, + DictWord{10, 11, 201}, + DictWord{142, 11, 319}, + DictWord{7, 11, 49}, + DictWord{ + 7, + 11, + 392, + }, + DictWord{8, 11, 20}, + DictWord{8, 11, 172}, + DictWord{8, 11, 690}, + DictWord{9, 11, 383}, + DictWord{9, 11, 845}, + DictWord{10, 11, 48}, + DictWord{ + 11, + 11, + 293, + }, + DictWord{11, 11, 832}, + DictWord{11, 11, 920}, + DictWord{141, 11, 221}, + DictWord{5, 11, 858}, + DictWord{133, 11, 992}, + DictWord{134, 0, 805}, + DictWord{139, 10, 1003}, + DictWord{6, 0, 1630}, + DictWord{134, 11, 307}, + DictWord{7, 11, 1512}, + DictWord{135, 11, 1794}, + DictWord{6, 11, 268}, + DictWord{ + 137, + 11, + 62, + }, + DictWord{135, 10, 1868}, + DictWord{133, 0, 671}, + DictWord{4, 0, 989}, + DictWord{8, 0, 972}, + DictWord{136, 0, 998}, + DictWord{132, 11, 423}, + DictWord{132, 0, 889}, + DictWord{135, 0, 1382}, + DictWord{135, 0, 1910}, + DictWord{7, 10, 965}, + DictWord{7, 10, 1460}, + DictWord{135, 10, 1604}, + DictWord{ + 4, + 0, + 627, + }, + DictWord{5, 0, 775}, + DictWord{138, 11, 106}, + DictWord{134, 11, 348}, + DictWord{7, 0, 202}, + DictWord{11, 0, 362}, + DictWord{11, 0, 948}, + DictWord{ + 140, + 0, + 388, + }, + DictWord{138, 11, 771}, + DictWord{6, 11, 613}, + DictWord{136, 11, 223}, + DictWord{6, 0, 560}, + DictWord{7, 0, 451}, + DictWord{8, 0, 389}, + DictWord{ + 12, + 0, + 490, + }, + DictWord{13, 0, 16}, + DictWord{13, 0, 215}, + DictWord{13, 0, 351}, + DictWord{18, 0, 132}, + DictWord{147, 0, 125}, + DictWord{135, 0, 841}, + DictWord{ + 136, + 0, + 566, + }, + DictWord{136, 0, 938}, + DictWord{132, 11, 670}, + DictWord{5, 0, 912}, + DictWord{6, 0, 1695}, + DictWord{140, 11, 55}, + DictWord{9, 11, 40}, + DictWord{ + 139, + 11, + 136, + }, + DictWord{7, 0, 1361}, + DictWord{7, 10, 982}, + DictWord{10, 10, 32}, + DictWord{143, 10, 56}, + DictWord{11, 11, 259}, + DictWord{140, 11, 270}, + DictWord{ + 5, + 0, + 236, + }, + DictWord{6, 0, 572}, + DictWord{8, 0, 492}, + DictWord{11, 0, 618}, + DictWord{144, 0, 56}, + DictWord{8, 11, 572}, + DictWord{9, 11, 310}, + DictWord{9, 11, 682}, + DictWord{137, 11, 698}, + DictWord{134, 0, 1854}, + DictWord{5, 0, 190}, + DictWord{136, 0, 318}, + DictWord{133, 10, 435}, + DictWord{135, 0, 1376}, + DictWord{ + 4, + 11, + 296, + }, + DictWord{6, 11, 352}, + DictWord{7, 11, 401}, + DictWord{7, 11, 1410}, + DictWord{7, 11, 1594}, + DictWord{7, 11, 1674}, + DictWord{8, 11, 63}, + DictWord{ + 8, + 11, + 660, + }, + DictWord{137, 11, 74}, + DictWord{7, 0, 349}, + DictWord{5, 10, 85}, + DictWord{6, 10, 419}, + DictWord{7, 10, 305}, + DictWord{7, 10, 361}, + DictWord{7, 10, 1337}, + DictWord{8, 10, 71}, + DictWord{140, 10, 519}, + DictWord{4, 11, 139}, + DictWord{4, 11, 388}, + DictWord{140, 11, 188}, + DictWord{6, 0, 1972}, + DictWord{6, 0, 2013}, + DictWord{8, 0, 951}, + DictWord{10, 0, 947}, + DictWord{10, 0, 974}, + DictWord{10, 0, 1018}, + DictWord{142, 0, 476}, + DictWord{140, 10, 688}, + DictWord{ + 135, + 10, + 740, + }, + DictWord{5, 10, 691}, + DictWord{7, 10, 345}, + DictWord{9, 10, 94}, + DictWord{140, 10, 169}, + DictWord{9, 0, 344}, + DictWord{5, 10, 183}, + DictWord{6, 10, 582}, + DictWord{10, 10, 679}, + DictWord{140, 10, 435}, + DictWord{135, 10, 511}, + DictWord{132, 0, 850}, + DictWord{8, 11, 441}, + DictWord{10, 11, 314}, + DictWord{ + 143, + 11, + 3, + }, + DictWord{7, 10, 1993}, + DictWord{136, 10, 684}, + DictWord{4, 11, 747}, + DictWord{6, 11, 290}, + DictWord{6, 10, 583}, + DictWord{7, 11, 649}, + DictWord{ + 7, + 11, + 1479, + }, + DictWord{135, 11, 1583}, + DictWord{133, 11, 232}, + DictWord{133, 10, 704}, + DictWord{134, 0, 910}, + DictWord{4, 10, 179}, + DictWord{5, 10, 198}, + DictWord{133, 10, 697}, + DictWord{7, 10, 347}, + DictWord{7, 10, 971}, + DictWord{8, 10, 181}, + DictWord{138, 10, 711}, + DictWord{136, 11, 525}, + DictWord{ + 14, + 0, + 19, + }, + DictWord{14, 0, 28}, + DictWord{144, 0, 29}, + DictWord{7, 0, 85}, + DictWord{7, 0, 247}, + DictWord{8, 0, 585}, + DictWord{138, 0, 163}, + DictWord{4, 0, 487}, + DictWord{ + 7, + 11, + 472, + }, + DictWord{7, 11, 1801}, + DictWord{10, 11, 748}, + DictWord{141, 11, 458}, + DictWord{4, 10, 243}, + DictWord{5, 10, 203}, + DictWord{7, 10, 19}, + DictWord{ + 7, + 10, + 71, + }, + DictWord{7, 10, 113}, + DictWord{10, 10, 405}, + DictWord{11, 10, 357}, + DictWord{142, 10, 240}, + DictWord{7, 10, 1450}, + DictWord{139, 10, 99}, + DictWord{132, 11, 425}, + DictWord{138, 0, 145}, + DictWord{147, 0, 83}, + DictWord{6, 10, 492}, + DictWord{137, 11, 247}, + DictWord{4, 0, 1013}, + DictWord{ + 134, + 0, + 2033, + }, + DictWord{5, 10, 134}, + DictWord{6, 10, 408}, + DictWord{6, 10, 495}, + DictWord{135, 10, 1593}, + DictWord{135, 0, 1922}, + DictWord{134, 11, 1768}, + DictWord{4, 0, 124}, + DictWord{10, 0, 457}, + DictWord{11, 0, 121}, + DictWord{11, 0, 169}, + DictWord{11, 0, 870}, + DictWord{11, 0, 874}, + DictWord{12, 0, 214}, + DictWord{ + 14, + 0, + 187, + }, + DictWord{143, 0, 77}, + DictWord{5, 0, 557}, + DictWord{135, 0, 1457}, + DictWord{139, 0, 66}, + DictWord{5, 11, 943}, + DictWord{6, 11, 1779}, + DictWord{ + 142, + 10, + 4, + }, + DictWord{4, 10, 248}, + DictWord{4, 10, 665}, + DictWord{7, 10, 137}, + DictWord{137, 10, 349}, + DictWord{7, 0, 1193}, + DictWord{5, 11, 245}, + DictWord{ + 6, + 11, + 576, + }, + DictWord{7, 11, 582}, + DictWord{136, 11, 225}, + DictWord{144, 0, 82}, + DictWord{7, 10, 1270}, + DictWord{139, 10, 612}, + DictWord{5, 0, 454}, + DictWord{ + 10, + 0, + 352, + }, + DictWord{138, 11, 352}, + DictWord{18, 0, 57}, + DictWord{5, 10, 371}, + DictWord{135, 10, 563}, + DictWord{135, 0, 1333}, + DictWord{6, 0, 107}, + DictWord{ + 7, + 0, + 638, + }, + DictWord{7, 0, 1632}, + DictWord{9, 0, 396}, + DictWord{134, 11, 610}, + DictWord{5, 0, 370}, + DictWord{134, 0, 1756}, + DictWord{4, 10, 374}, + DictWord{ + 7, + 10, + 547, + }, + DictWord{7, 10, 1700}, + DictWord{7, 10, 1833}, + DictWord{139, 10, 858}, + DictWord{133, 0, 204}, + DictWord{6, 0, 1305}, + DictWord{9, 10, 311}, + DictWord{ + 141, + 10, + 42, + }, + DictWord{5, 0, 970}, + DictWord{134, 0, 1706}, + DictWord{6, 10, 1647}, + DictWord{7, 10, 1552}, + DictWord{7, 10, 2010}, + DictWord{9, 10, 494}, + DictWord{137, 10, 509}, + DictWord{13, 11, 455}, + DictWord{15, 11, 99}, + DictWord{15, 11, 129}, + DictWord{144, 11, 68}, + DictWord{135, 0, 3}, + DictWord{4, 0, 35}, + DictWord{ + 5, + 0, + 121, + }, + DictWord{5, 0, 483}, + DictWord{5, 0, 685}, + DictWord{6, 0, 489}, + DictWord{6, 0, 782}, + DictWord{6, 0, 1032}, + DictWord{7, 0, 1204}, + DictWord{136, 0, 394}, + DictWord{4, 0, 921}, + DictWord{133, 0, 1007}, + DictWord{8, 11, 360}, + DictWord{138, 11, 63}, + DictWord{135, 0, 1696}, + DictWord{134, 0, 1519}, + DictWord{ + 132, + 11, + 443, + }, + DictWord{135, 11, 944}, + DictWord{6, 10, 123}, + DictWord{7, 10, 214}, + DictWord{9, 10, 728}, + DictWord{10, 10, 157}, + DictWord{11, 10, 346}, + DictWord{11, 10, 662}, + DictWord{143, 10, 106}, + DictWord{137, 0, 981}, + DictWord{135, 10, 1435}, + DictWord{134, 0, 1072}, + DictWord{132, 0, 712}, + DictWord{ + 134, + 0, + 1629, + }, + DictWord{134, 0, 728}, + DictWord{4, 11, 298}, + DictWord{137, 11, 483}, + DictWord{6, 0, 1177}, + DictWord{6, 0, 1271}, + DictWord{5, 11, 164}, + DictWord{ + 7, + 11, + 121, + }, + DictWord{142, 11, 189}, + DictWord{7, 0, 1608}, + DictWord{4, 10, 707}, + DictWord{5, 10, 588}, + DictWord{6, 10, 393}, + DictWord{13, 10, 106}, + DictWord{ + 18, + 10, + 49, + }, + DictWord{147, 10, 41}, + DictWord{23, 0, 16}, + DictWord{151, 11, 16}, + DictWord{6, 10, 211}, + DictWord{7, 10, 1690}, + DictWord{11, 10, 486}, + DictWord{140, 10, 369}, + DictWord{133, 0, 485}, + DictWord{19, 11, 15}, + DictWord{149, 11, 27}, + DictWord{4, 11, 172}, + DictWord{9, 11, 611}, + DictWord{10, 11, 436}, + DictWord{12, 11, 673}, + DictWord{141, 11, 255}, + DictWord{5, 11, 844}, + DictWord{10, 11, 484}, + DictWord{11, 11, 754}, + DictWord{12, 11, 457}, + DictWord{ + 14, + 11, + 171, + }, + DictWord{14, 11, 389}, + DictWord{146, 11, 153}, + DictWord{4, 0, 285}, + DictWord{5, 0, 27}, + DictWord{5, 0, 317}, + DictWord{6, 0, 301}, + DictWord{7, 0, 7}, + DictWord{ + 8, + 0, + 153, + }, + DictWord{10, 0, 766}, + DictWord{11, 0, 468}, + DictWord{12, 0, 467}, + DictWord{141, 0, 143}, + DictWord{134, 0, 1462}, + DictWord{9, 11, 263}, + DictWord{ + 10, + 11, + 147, + }, + DictWord{138, 11, 492}, + DictWord{133, 11, 537}, + DictWord{6, 0, 1945}, + DictWord{6, 0, 1986}, + DictWord{6, 0, 1991}, + DictWord{134, 0, 2038}, + DictWord{134, 10, 219}, + DictWord{137, 11, 842}, + DictWord{14, 0, 52}, + DictWord{17, 0, 50}, + DictWord{5, 10, 582}, + DictWord{6, 10, 1646}, + DictWord{7, 10, 99}, + DictWord{7, 10, 1962}, + DictWord{7, 10, 1986}, + DictWord{8, 10, 515}, + DictWord{8, 10, 773}, + DictWord{9, 10, 23}, + DictWord{9, 10, 491}, + DictWord{12, 10, 620}, + DictWord{142, 10, 93}, + DictWord{138, 11, 97}, + DictWord{20, 0, 21}, + DictWord{20, 0, 44}, + DictWord{133, 10, 851}, + DictWord{136, 0, 819}, + DictWord{139, 0, 917}, + DictWord{5, 11, 230}, + DictWord{5, 11, 392}, + DictWord{6, 11, 420}, + DictWord{8, 10, 762}, + DictWord{8, 10, 812}, + DictWord{9, 11, 568}, + DictWord{9, 10, 910}, + DictWord{140, 11, 612}, + DictWord{135, 0, 784}, + DictWord{15, 0, 135}, + DictWord{143, 11, 135}, + DictWord{10, 0, 454}, + DictWord{140, 0, 324}, + DictWord{4, 11, 0}, + DictWord{5, 11, 41}, + DictWord{7, 11, 1459}, + DictWord{7, 11, 1469}, + DictWord{7, 11, 1618}, + DictWord{7, 11, 1859}, + DictWord{9, 11, 549}, + DictWord{139, 11, 905}, + DictWord{4, 10, 98}, + DictWord{7, 10, 1365}, + DictWord{9, 10, 422}, + DictWord{9, 10, 670}, + DictWord{10, 10, 775}, + DictWord{11, 10, 210}, + DictWord{13, 10, 26}, + DictWord{13, 10, 457}, + DictWord{141, 10, 476}, + DictWord{6, 0, 1719}, + DictWord{6, 0, 1735}, + DictWord{7, 0, 2016}, + DictWord{7, 0, 2020}, + DictWord{8, 0, 837}, + DictWord{137, 0, 852}, + DictWord{133, 11, 696}, + DictWord{135, 0, 852}, + DictWord{132, 0, 952}, + DictWord{134, 10, 1730}, + DictWord{132, 11, 771}, + DictWord{ + 138, + 0, + 568, + }, + DictWord{137, 0, 448}, + DictWord{139, 0, 146}, + DictWord{8, 0, 67}, + DictWord{138, 0, 419}, + DictWord{133, 11, 921}, + DictWord{137, 10, 147}, + DictWord{134, 0, 1826}, + DictWord{10, 0, 657}, + DictWord{14, 0, 297}, + DictWord{142, 0, 361}, + DictWord{6, 0, 666}, + DictWord{6, 0, 767}, + DictWord{134, 0, 1542}, + DictWord{139, 0, 729}, + DictWord{6, 11, 180}, + DictWord{7, 11, 1137}, + DictWord{8, 11, 751}, + DictWord{139, 11, 805}, + DictWord{4, 11, 183}, + DictWord{7, 11, 271}, + DictWord{11, 11, 824}, + DictWord{11, 11, 952}, + DictWord{13, 11, 278}, + DictWord{13, 11, 339}, + DictWord{13, 11, 482}, + DictWord{14, 11, 424}, + DictWord{ + 148, + 11, + 99, + }, + DictWord{4, 0, 669}, + DictWord{5, 11, 477}, + DictWord{5, 11, 596}, + DictWord{6, 11, 505}, + DictWord{7, 11, 1221}, + DictWord{11, 11, 907}, + DictWord{ + 12, + 11, + 209, + }, + DictWord{141, 11, 214}, + DictWord{135, 11, 1215}, + DictWord{5, 0, 402}, + DictWord{6, 10, 30}, + DictWord{11, 10, 56}, + DictWord{139, 10, 305}, + DictWord{ + 7, + 11, + 564, + }, + DictWord{142, 11, 168}, + DictWord{139, 0, 152}, + DictWord{7, 0, 912}, + DictWord{135, 10, 1614}, + DictWord{4, 10, 150}, + DictWord{5, 10, 303}, + DictWord{134, 10, 327}, + DictWord{7, 0, 320}, + DictWord{8, 0, 51}, + DictWord{9, 0, 868}, + DictWord{10, 0, 833}, + DictWord{12, 0, 481}, + DictWord{12, 0, 570}, + DictWord{ + 148, + 0, + 106, + }, + DictWord{132, 0, 445}, + DictWord{7, 11, 274}, + DictWord{11, 11, 263}, + DictWord{11, 11, 479}, + DictWord{11, 11, 507}, + DictWord{140, 11, 277}, + DictWord{10, 0, 555}, + DictWord{11, 0, 308}, + DictWord{19, 0, 95}, + DictWord{6, 11, 1645}, + DictWord{8, 10, 192}, + DictWord{10, 10, 78}, + DictWord{141, 10, 359}, + DictWord{135, 10, 786}, + DictWord{6, 11, 92}, + DictWord{6, 11, 188}, + DictWord{7, 11, 1269}, + DictWord{7, 11, 1524}, + DictWord{7, 11, 1876}, + DictWord{10, 11, 228}, + DictWord{139, 11, 1020}, + DictWord{4, 11, 459}, + DictWord{133, 11, 966}, + DictWord{11, 0, 386}, + DictWord{6, 10, 1638}, + DictWord{7, 10, 79}, + DictWord{ + 7, + 10, + 496, + }, + DictWord{9, 10, 138}, + DictWord{10, 10, 336}, + DictWord{12, 10, 412}, + DictWord{12, 10, 440}, + DictWord{142, 10, 305}, + DictWord{133, 0, 239}, + DictWord{ + 7, + 0, + 83, + }, + DictWord{7, 0, 1990}, + DictWord{8, 0, 130}, + DictWord{139, 0, 720}, + DictWord{138, 11, 709}, + DictWord{4, 0, 143}, + DictWord{5, 0, 550}, + DictWord{ + 133, + 0, + 752, + }, + DictWord{5, 0, 123}, + DictWord{6, 0, 530}, + DictWord{7, 0, 348}, + DictWord{135, 0, 1419}, + DictWord{135, 0, 2024}, + DictWord{6, 11, 18}, + DictWord{7, 11, 179}, + DictWord{7, 11, 721}, + DictWord{7, 11, 932}, + DictWord{8, 11, 548}, + DictWord{8, 11, 757}, + DictWord{9, 11, 54}, + DictWord{9, 11, 65}, + DictWord{9, 11, 532}, + DictWord{ + 9, + 11, + 844, + }, + DictWord{10, 11, 113}, + DictWord{10, 11, 117}, + DictWord{10, 11, 236}, + DictWord{10, 11, 315}, + DictWord{10, 11, 430}, + DictWord{10, 11, 798}, + DictWord{11, 11, 153}, + DictWord{11, 11, 351}, + DictWord{11, 11, 375}, + DictWord{12, 11, 78}, + DictWord{12, 11, 151}, + DictWord{12, 11, 392}, + DictWord{ + 14, + 11, + 248, + }, + DictWord{143, 11, 23}, + DictWord{7, 10, 204}, + DictWord{7, 10, 415}, + DictWord{8, 10, 42}, + DictWord{10, 10, 85}, + DictWord{139, 10, 564}, + DictWord{ + 134, + 0, + 958, + }, + DictWord{133, 11, 965}, + DictWord{132, 0, 210}, + DictWord{135, 11, 1429}, + DictWord{138, 11, 480}, + DictWord{134, 11, 182}, + DictWord{ + 139, + 11, + 345, + }, + DictWord{10, 11, 65}, + DictWord{10, 11, 488}, + DictWord{138, 11, 497}, + DictWord{4, 10, 3}, + DictWord{5, 10, 247}, + DictWord{5, 10, 644}, + DictWord{ + 7, + 10, + 744, + }, + DictWord{7, 10, 1207}, + DictWord{7, 10, 1225}, + DictWord{7, 10, 1909}, + DictWord{146, 10, 147}, + DictWord{132, 0, 430}, + DictWord{5, 10, 285}, + DictWord{ + 9, + 10, + 67, + }, + DictWord{13, 10, 473}, + DictWord{143, 10, 82}, + DictWord{144, 11, 16}, + DictWord{7, 11, 1162}, + DictWord{9, 11, 588}, + DictWord{10, 11, 260}, + DictWord{151, 10, 8}, + DictWord{133, 0, 213}, + DictWord{138, 0, 7}, + DictWord{135, 0, 801}, + DictWord{134, 11, 1786}, + DictWord{135, 11, 308}, + DictWord{6, 0, 936}, + DictWord{134, 0, 1289}, + DictWord{133, 0, 108}, + DictWord{132, 0, 885}, + DictWord{133, 0, 219}, + DictWord{139, 0, 587}, + DictWord{4, 0, 193}, + DictWord{5, 0, 916}, + DictWord{6, 0, 1041}, + DictWord{7, 0, 364}, + DictWord{10, 0, 398}, + DictWord{10, 0, 726}, + DictWord{11, 0, 317}, + DictWord{11, 0, 626}, + DictWord{12, 0, 142}, + DictWord{12, 0, 288}, + DictWord{12, 0, 678}, + DictWord{13, 0, 313}, + DictWord{15, 0, 113}, + DictWord{146, 0, 114}, + DictWord{135, 0, 1165}, + DictWord{6, 0, 241}, + DictWord{ + 9, + 0, + 342, + }, + DictWord{10, 0, 729}, + DictWord{11, 0, 284}, + DictWord{11, 0, 445}, + DictWord{11, 0, 651}, + DictWord{11, 0, 863}, + DictWord{13, 0, 398}, + DictWord{ + 146, + 0, + 99, + }, + DictWord{7, 0, 907}, + DictWord{136, 0, 832}, + DictWord{9, 0, 303}, + DictWord{4, 10, 29}, + DictWord{6, 10, 532}, + DictWord{7, 10, 1628}, + DictWord{7, 10, 1648}, + DictWord{9, 10, 350}, + DictWord{10, 10, 433}, + DictWord{11, 10, 97}, + DictWord{11, 10, 557}, + DictWord{11, 10, 745}, + DictWord{12, 10, 289}, + DictWord{ + 12, + 10, + 335, + }, + DictWord{12, 10, 348}, + DictWord{12, 10, 606}, + DictWord{13, 10, 116}, + DictWord{13, 10, 233}, + DictWord{13, 10, 466}, + DictWord{14, 10, 181}, + DictWord{ + 14, + 10, + 209, + }, + DictWord{14, 10, 232}, + DictWord{14, 10, 236}, + DictWord{14, 10, 300}, + DictWord{16, 10, 41}, + DictWord{148, 10, 97}, + DictWord{7, 11, 423}, + DictWord{7, 10, 1692}, + DictWord{136, 11, 588}, + DictWord{6, 0, 931}, + DictWord{134, 0, 1454}, + DictWord{5, 10, 501}, + DictWord{7, 10, 1704}, + DictWord{9, 10, 553}, + DictWord{11, 10, 520}, + DictWord{12, 10, 557}, + DictWord{141, 10, 249}, + DictWord{136, 11, 287}, + DictWord{4, 0, 562}, + DictWord{9, 0, 254}, + DictWord{ + 139, + 0, + 879, + }, + DictWord{132, 0, 786}, + DictWord{14, 11, 32}, + DictWord{18, 11, 85}, + DictWord{20, 11, 2}, + DictWord{152, 11, 16}, + DictWord{135, 0, 1294}, + DictWord{ + 7, + 11, + 723, + }, + DictWord{135, 11, 1135}, + DictWord{6, 0, 216}, + DictWord{7, 0, 901}, + DictWord{7, 0, 1343}, + DictWord{8, 0, 493}, + DictWord{134, 11, 403}, + DictWord{ + 7, + 11, + 719, + }, + DictWord{8, 11, 809}, + DictWord{136, 11, 834}, + DictWord{5, 11, 210}, + DictWord{6, 11, 213}, + DictWord{7, 11, 60}, + DictWord{10, 11, 364}, + DictWord{ + 139, + 11, + 135, + }, + DictWord{7, 0, 341}, + DictWord{11, 0, 219}, + DictWord{5, 11, 607}, + DictWord{8, 11, 326}, + DictWord{136, 11, 490}, + DictWord{4, 11, 701}, + DictWord{ + 5, + 11, + 472, + }, + DictWord{5, 11, 639}, + DictWord{7, 11, 1249}, + DictWord{9, 11, 758}, + DictWord{139, 11, 896}, + DictWord{135, 11, 380}, + DictWord{135, 11, 1947}, + DictWord{139, 0, 130}, + DictWord{135, 0, 1734}, + DictWord{10, 0, 115}, + DictWord{11, 0, 420}, + DictWord{12, 0, 154}, + DictWord{13, 0, 404}, + DictWord{14, 0, 346}, + DictWord{143, 0, 54}, + DictWord{134, 10, 129}, + DictWord{4, 11, 386}, + DictWord{7, 11, 41}, + DictWord{8, 11, 405}, + DictWord{9, 11, 497}, + DictWord{11, 11, 110}, + DictWord{11, 11, 360}, + DictWord{15, 11, 37}, + DictWord{144, 11, 84}, + DictWord{141, 11, 282}, + DictWord{5, 11, 46}, + DictWord{7, 11, 1452}, + DictWord{7, 11, 1480}, + DictWord{8, 11, 634}, + DictWord{140, 11, 472}, + DictWord{4, 11, 524}, + DictWord{136, 11, 810}, + DictWord{10, 11, 238}, + DictWord{141, 11, 33}, + DictWord{ + 133, + 0, + 604, + }, + DictWord{5, 0, 1011}, + DictWord{136, 0, 701}, + DictWord{8, 0, 856}, + DictWord{8, 0, 858}, + DictWord{8, 0, 879}, + DictWord{12, 0, 702}, + DictWord{142, 0, 447}, + DictWord{4, 0, 54}, + DictWord{5, 0, 666}, + DictWord{7, 0, 1039}, + DictWord{7, 0, 1130}, + DictWord{9, 0, 195}, + DictWord{138, 0, 302}, + DictWord{4, 10, 25}, + DictWord{ + 5, + 10, + 60, + }, + DictWord{6, 10, 504}, + DictWord{7, 10, 614}, + DictWord{7, 10, 1155}, + DictWord{140, 10, 0}, + DictWord{7, 10, 1248}, + DictWord{11, 10, 621}, + DictWord{ + 139, + 10, + 702, + }, + DictWord{133, 11, 997}, + DictWord{137, 10, 321}, + DictWord{134, 0, 1669}, + DictWord{134, 0, 1791}, + DictWord{4, 10, 379}, + DictWord{ + 135, + 10, + 1397, + }, + DictWord{138, 11, 372}, + DictWord{5, 11, 782}, + DictWord{5, 11, 829}, + DictWord{134, 11, 1738}, + DictWord{135, 0, 1228}, + DictWord{4, 10, 118}, + DictWord{6, 10, 274}, + DictWord{6, 10, 361}, + DictWord{7, 10, 75}, + DictWord{141, 10, 441}, + DictWord{132, 0, 623}, + DictWord{9, 11, 279}, + DictWord{10, 11, 407}, + DictWord{14, 11, 84}, + DictWord{150, 11, 18}, + DictWord{137, 10, 841}, + DictWord{135, 0, 798}, + DictWord{140, 10, 693}, + DictWord{5, 10, 314}, + DictWord{6, 10, 221}, + DictWord{7, 10, 419}, + DictWord{10, 10, 650}, + DictWord{11, 10, 396}, + DictWord{12, 10, 156}, + DictWord{13, 10, 369}, + DictWord{14, 10, 333}, + DictWord{ + 145, + 10, + 47, + }, + DictWord{135, 11, 1372}, + DictWord{7, 0, 122}, + DictWord{9, 0, 259}, + DictWord{10, 0, 84}, + DictWord{11, 0, 470}, + DictWord{12, 0, 541}, + DictWord{ + 141, + 0, + 379, + }, + DictWord{134, 0, 837}, + DictWord{8, 0, 1013}, + DictWord{4, 11, 78}, + DictWord{5, 11, 96}, + DictWord{5, 11, 182}, + DictWord{7, 11, 1724}, + DictWord{ + 7, + 11, + 1825, + }, + DictWord{10, 11, 394}, + DictWord{10, 11, 471}, + DictWord{11, 11, 532}, + DictWord{14, 11, 340}, + DictWord{145, 11, 88}, + DictWord{134, 0, 577}, + DictWord{135, 11, 1964}, + DictWord{132, 10, 913}, + DictWord{134, 0, 460}, + DictWord{8, 0, 891}, + DictWord{10, 0, 901}, + DictWord{10, 0, 919}, + DictWord{10, 0, 932}, + DictWord{12, 0, 715}, + DictWord{12, 0, 728}, + DictWord{12, 0, 777}, + DictWord{14, 0, 457}, + DictWord{144, 0, 103}, + DictWord{5, 0, 82}, + DictWord{5, 0, 131}, + DictWord{ + 7, + 0, + 1755, + }, + DictWord{8, 0, 31}, + DictWord{9, 0, 168}, + DictWord{9, 0, 764}, + DictWord{139, 0, 869}, + DictWord{136, 10, 475}, + DictWord{6, 0, 605}, + DictWord{ + 5, + 10, + 1016, + }, + DictWord{9, 11, 601}, + DictWord{9, 11, 619}, + DictWord{10, 11, 505}, + DictWord{10, 11, 732}, + DictWord{11, 11, 355}, + DictWord{140, 11, 139}, + DictWord{ + 7, + 10, + 602, + }, + DictWord{8, 10, 179}, + DictWord{10, 10, 781}, + DictWord{140, 10, 126}, + DictWord{134, 0, 1246}, + DictWord{6, 10, 329}, + DictWord{138, 10, 111}, + DictWord{6, 11, 215}, + DictWord{7, 11, 1028}, + DictWord{7, 11, 1473}, + DictWord{7, 11, 1721}, + DictWord{9, 11, 424}, + DictWord{138, 11, 779}, + DictWord{5, 0, 278}, + DictWord{137, 0, 68}, + DictWord{6, 0, 932}, + DictWord{6, 0, 1084}, + DictWord{144, 0, 86}, + DictWord{4, 0, 163}, + DictWord{5, 0, 201}, + DictWord{5, 0, 307}, + DictWord{ + 5, + 0, + 310, + }, + DictWord{6, 0, 335}, + DictWord{7, 0, 284}, + DictWord{7, 0, 1660}, + DictWord{136, 0, 165}, + DictWord{136, 0, 781}, + DictWord{134, 0, 707}, + DictWord{6, 0, 33}, + DictWord{135, 0, 1244}, + DictWord{5, 10, 821}, + DictWord{6, 11, 67}, + DictWord{6, 10, 1687}, + DictWord{7, 11, 258}, + DictWord{7, 11, 1630}, + DictWord{9, 11, 354}, + DictWord{9, 11, 675}, + DictWord{10, 11, 830}, + DictWord{14, 11, 80}, + DictWord{145, 11, 80}, + DictWord{6, 11, 141}, + DictWord{7, 11, 225}, + DictWord{9, 11, 59}, + DictWord{9, 11, 607}, + DictWord{10, 11, 312}, + DictWord{11, 11, 687}, + DictWord{12, 11, 555}, + DictWord{13, 11, 373}, + DictWord{13, 11, 494}, + DictWord{148, 11, 58}, + DictWord{134, 0, 1113}, + DictWord{9, 0, 388}, + DictWord{5, 10, 71}, + DictWord{7, 10, 1407}, + DictWord{9, 10, 704}, + DictWord{10, 10, 261}, + DictWord{10, 10, 619}, + DictWord{11, 10, 547}, + DictWord{11, 10, 619}, + DictWord{143, 10, 157}, + DictWord{7, 0, 1953}, + DictWord{136, 0, 720}, + DictWord{138, 0, 203}, + DictWord{ + 7, + 10, + 2008, + }, + DictWord{9, 10, 337}, + DictWord{138, 10, 517}, + DictWord{6, 0, 326}, + DictWord{7, 0, 677}, + DictWord{137, 0, 425}, + DictWord{139, 11, 81}, + DictWord{ + 7, + 0, + 1316, + }, + DictWord{7, 0, 1412}, + DictWord{7, 0, 1839}, + DictWord{9, 0, 589}, + DictWord{11, 0, 241}, + DictWord{11, 0, 676}, + DictWord{11, 0, 811}, + DictWord{11, 0, 891}, + DictWord{12, 0, 140}, + DictWord{12, 0, 346}, + DictWord{12, 0, 479}, + DictWord{13, 0, 140}, + DictWord{13, 0, 381}, + DictWord{14, 0, 188}, + DictWord{18, 0, 30}, + DictWord{148, 0, 108}, + DictWord{5, 0, 416}, + DictWord{6, 10, 86}, + DictWord{6, 10, 603}, + DictWord{7, 10, 292}, + DictWord{7, 10, 561}, + DictWord{8, 10, 257}, + DictWord{ + 8, + 10, + 382, + }, + DictWord{9, 10, 721}, + DictWord{9, 10, 778}, + DictWord{11, 10, 581}, + DictWord{140, 10, 466}, + DictWord{4, 10, 486}, + DictWord{133, 10, 491}, + DictWord{134, 0, 1300}, + DictWord{132, 10, 72}, + DictWord{7, 0, 847}, + DictWord{6, 10, 265}, + DictWord{7, 11, 430}, + DictWord{139, 11, 46}, + DictWord{5, 11, 602}, + DictWord{6, 11, 106}, + DictWord{7, 11, 1786}, + DictWord{7, 11, 1821}, + DictWord{7, 11, 2018}, + DictWord{9, 11, 418}, + DictWord{137, 11, 763}, + DictWord{5, 0, 358}, + DictWord{7, 0, 535}, + DictWord{7, 0, 1184}, + DictWord{10, 0, 662}, + DictWord{13, 0, 212}, + DictWord{13, 0, 304}, + DictWord{13, 0, 333}, + DictWord{145, 0, 98}, + DictWord{ + 5, + 11, + 65, + }, + DictWord{6, 11, 416}, + DictWord{7, 11, 1720}, + DictWord{7, 11, 1924}, + DictWord{8, 11, 677}, + DictWord{10, 11, 109}, + DictWord{11, 11, 14}, + DictWord{ + 11, + 11, + 70, + }, + DictWord{11, 11, 569}, + DictWord{11, 11, 735}, + DictWord{15, 11, 153}, + DictWord{148, 11, 80}, + DictWord{6, 0, 1823}, + DictWord{8, 0, 839}, + DictWord{ + 8, + 0, + 852, + }, + DictWord{8, 0, 903}, + DictWord{10, 0, 940}, + DictWord{12, 0, 707}, + DictWord{140, 0, 775}, + DictWord{135, 11, 1229}, + DictWord{6, 0, 1522}, + DictWord{ + 140, + 0, + 654, + }, + DictWord{136, 11, 595}, + DictWord{139, 0, 163}, + DictWord{141, 0, 314}, + DictWord{132, 0, 978}, + DictWord{4, 0, 601}, + DictWord{6, 0, 2035}, + DictWord{137, 10, 234}, + DictWord{5, 10, 815}, + DictWord{6, 10, 1688}, + DictWord{134, 10, 1755}, + DictWord{133, 0, 946}, + DictWord{136, 0, 434}, + DictWord{ + 6, + 10, + 197, + }, + DictWord{136, 10, 205}, + DictWord{7, 0, 411}, + DictWord{7, 0, 590}, + DictWord{8, 0, 631}, + DictWord{9, 0, 323}, + DictWord{10, 0, 355}, + DictWord{11, 0, 491}, + DictWord{12, 0, 143}, + DictWord{12, 0, 402}, + DictWord{13, 0, 73}, + DictWord{14, 0, 408}, + DictWord{15, 0, 107}, + DictWord{146, 0, 71}, + DictWord{7, 0, 1467}, + DictWord{ + 8, + 0, + 328, + }, + DictWord{10, 0, 544}, + DictWord{11, 0, 955}, + DictWord{12, 0, 13}, + DictWord{13, 0, 320}, + DictWord{145, 0, 83}, + DictWord{142, 0, 410}, + DictWord{ + 11, + 0, + 511, + }, + DictWord{13, 0, 394}, + DictWord{14, 0, 298}, + DictWord{14, 0, 318}, + DictWord{146, 0, 103}, + DictWord{6, 10, 452}, + DictWord{7, 10, 312}, + DictWord{ + 138, + 10, + 219, + }, + DictWord{138, 10, 589}, + DictWord{4, 10, 333}, + DictWord{9, 10, 176}, + DictWord{12, 10, 353}, + DictWord{141, 10, 187}, + DictWord{135, 11, 329}, + DictWord{132, 11, 469}, + DictWord{5, 0, 835}, + DictWord{134, 0, 483}, + DictWord{134, 11, 1743}, + DictWord{5, 11, 929}, + DictWord{6, 11, 340}, + DictWord{8, 11, 376}, + DictWord{136, 11, 807}, + DictWord{134, 10, 1685}, + DictWord{132, 0, 677}, + DictWord{5, 11, 218}, + DictWord{7, 11, 1610}, + DictWord{138, 11, 83}, + DictWord{ + 5, + 11, + 571, + }, + DictWord{135, 11, 1842}, + DictWord{132, 11, 455}, + DictWord{137, 0, 70}, + DictWord{135, 0, 1405}, + DictWord{7, 10, 135}, + DictWord{8, 10, 7}, + DictWord{ + 8, + 10, + 62, + }, + DictWord{9, 10, 243}, + DictWord{10, 10, 658}, + DictWord{10, 10, 697}, + DictWord{11, 10, 456}, + DictWord{139, 10, 756}, + DictWord{9, 10, 395}, + DictWord{138, 10, 79}, + DictWord{137, 0, 108}, + DictWord{6, 11, 161}, + DictWord{7, 11, 372}, + DictWord{137, 11, 597}, + DictWord{132, 11, 349}, + DictWord{ + 132, + 0, + 777, + }, + DictWord{132, 0, 331}, + DictWord{135, 10, 631}, + DictWord{133, 0, 747}, + DictWord{6, 11, 432}, + DictWord{6, 11, 608}, + DictWord{139, 11, 322}, + DictWord{138, 10, 835}, + DictWord{5, 11, 468}, + DictWord{7, 11, 1809}, + DictWord{10, 11, 325}, + DictWord{11, 11, 856}, + DictWord{12, 11, 345}, + DictWord{ + 143, + 11, + 104, + }, + DictWord{133, 11, 223}, + DictWord{7, 10, 406}, + DictWord{7, 10, 459}, + DictWord{8, 10, 606}, + DictWord{139, 10, 726}, + DictWord{132, 11, 566}, + DictWord{142, 0, 68}, + DictWord{4, 11, 59}, + DictWord{135, 11, 1394}, + DictWord{6, 11, 436}, + DictWord{139, 11, 481}, + DictWord{4, 11, 48}, + DictWord{5, 11, 271}, + DictWord{135, 11, 953}, + DictWord{139, 11, 170}, + DictWord{5, 11, 610}, + DictWord{136, 11, 457}, + DictWord{133, 11, 755}, + DictWord{135, 11, 1217}, + DictWord{ + 133, + 10, + 612, + }, + DictWord{132, 11, 197}, + DictWord{132, 0, 505}, + DictWord{4, 10, 372}, + DictWord{7, 10, 482}, + DictWord{8, 10, 158}, + DictWord{9, 10, 602}, + DictWord{ + 9, + 10, + 615, + }, + DictWord{10, 10, 245}, + DictWord{10, 10, 678}, + DictWord{10, 10, 744}, + DictWord{11, 10, 248}, + DictWord{139, 10, 806}, + DictWord{133, 0, 326}, + DictWord{5, 10, 854}, + DictWord{135, 10, 1991}, + DictWord{4, 0, 691}, + DictWord{146, 0, 16}, + DictWord{6, 0, 628}, + DictWord{9, 0, 35}, + DictWord{10, 0, 680}, + DictWord{10, 0, 793}, + DictWord{11, 0, 364}, + DictWord{13, 0, 357}, + DictWord{143, 0, 164}, + DictWord{138, 0, 654}, + DictWord{6, 0, 32}, + DictWord{7, 0, 385}, + DictWord{ + 7, + 0, + 757, + }, + DictWord{7, 0, 1916}, + DictWord{8, 0, 37}, + DictWord{8, 0, 94}, + DictWord{8, 0, 711}, + DictWord{9, 0, 541}, + DictWord{10, 0, 162}, + DictWord{10, 0, 795}, + DictWord{ + 11, + 0, + 989, + }, + DictWord{11, 0, 1010}, + DictWord{12, 0, 14}, + DictWord{142, 0, 308}, + DictWord{133, 11, 217}, + DictWord{6, 0, 152}, + DictWord{6, 0, 349}, + DictWord{ + 6, + 0, + 1682, + }, + DictWord{7, 0, 1252}, + DictWord{8, 0, 112}, + DictWord{9, 0, 435}, + DictWord{9, 0, 668}, + DictWord{10, 0, 290}, + DictWord{10, 0, 319}, + DictWord{10, 0, 815}, + DictWord{11, 0, 180}, + DictWord{11, 0, 837}, + DictWord{12, 0, 240}, + DictWord{13, 0, 152}, + DictWord{13, 0, 219}, + DictWord{142, 0, 158}, + DictWord{4, 0, 581}, + DictWord{134, 0, 726}, + DictWord{5, 10, 195}, + DictWord{135, 10, 1685}, + DictWord{6, 0, 126}, + DictWord{7, 0, 573}, + DictWord{8, 0, 397}, + DictWord{142, 0, 44}, + DictWord{138, 0, 89}, + DictWord{7, 10, 1997}, + DictWord{8, 10, 730}, + DictWord{139, 10, 1006}, + DictWord{134, 0, 1531}, + DictWord{134, 0, 1167}, + DictWord{ + 5, + 0, + 926, + }, + DictWord{12, 0, 203}, + DictWord{133, 10, 751}, + DictWord{4, 11, 165}, + DictWord{7, 11, 1398}, + DictWord{135, 11, 1829}, + DictWord{7, 0, 1232}, + DictWord{137, 0, 531}, + DictWord{135, 10, 821}, + DictWord{134, 0, 943}, + DictWord{133, 0, 670}, + DictWord{4, 0, 880}, + DictWord{139, 0, 231}, + DictWord{ + 134, + 0, + 1617, + }, + DictWord{135, 0, 1957}, + DictWord{5, 11, 9}, + DictWord{7, 11, 297}, + DictWord{7, 11, 966}, + DictWord{140, 11, 306}, + DictWord{6, 0, 975}, + DictWord{ + 134, + 0, + 985, + }, + DictWord{5, 10, 950}, + DictWord{5, 10, 994}, + DictWord{134, 10, 351}, + DictWord{12, 11, 21}, + DictWord{151, 11, 7}, + DictWord{5, 11, 146}, + DictWord{ + 6, + 11, + 411, + }, + DictWord{138, 11, 721}, + DictWord{7, 0, 242}, + DictWord{135, 0, 1942}, + DictWord{6, 11, 177}, + DictWord{135, 11, 467}, + DictWord{5, 0, 421}, + DictWord{ + 7, + 10, + 47, + }, + DictWord{137, 10, 684}, + DictWord{5, 0, 834}, + DictWord{7, 0, 1202}, + DictWord{8, 0, 14}, + DictWord{9, 0, 481}, + DictWord{137, 0, 880}, + DictWord{138, 0, 465}, + DictWord{6, 0, 688}, + DictWord{9, 0, 834}, + DictWord{132, 10, 350}, + DictWord{132, 0, 855}, + DictWord{4, 0, 357}, + DictWord{6, 0, 172}, + DictWord{7, 0, 143}, + DictWord{137, 0, 413}, + DictWord{133, 11, 200}, + DictWord{132, 0, 590}, + DictWord{7, 10, 1812}, + DictWord{13, 10, 259}, + DictWord{13, 10, 356}, + DictWord{ + 14, + 10, + 242, + }, + DictWord{147, 10, 114}, + DictWord{133, 10, 967}, + DictWord{11, 0, 114}, + DictWord{4, 10, 473}, + DictWord{7, 10, 623}, + DictWord{8, 10, 808}, + DictWord{ + 9, + 10, + 871, + }, + DictWord{9, 10, 893}, + DictWord{11, 10, 431}, + DictWord{12, 10, 112}, + DictWord{12, 10, 217}, + DictWord{12, 10, 243}, + DictWord{12, 10, 562}, + DictWord{ + 12, + 10, + 663, + }, + DictWord{12, 10, 683}, + DictWord{13, 10, 141}, + DictWord{13, 10, 197}, + DictWord{13, 10, 227}, + DictWord{13, 10, 406}, + DictWord{13, 10, 487}, + DictWord{14, 10, 156}, + DictWord{14, 10, 203}, + DictWord{14, 10, 224}, + DictWord{14, 10, 256}, + DictWord{18, 10, 58}, + DictWord{150, 10, 0}, + DictWord{ + 138, + 10, + 286, + }, + DictWord{4, 10, 222}, + DictWord{7, 10, 286}, + DictWord{136, 10, 629}, + DictWord{5, 0, 169}, + DictWord{7, 0, 333}, + DictWord{136, 0, 45}, + DictWord{ + 134, + 11, + 481, + }, + DictWord{132, 0, 198}, + DictWord{4, 0, 24}, + DictWord{5, 0, 140}, + DictWord{5, 0, 185}, + DictWord{7, 0, 1500}, + DictWord{11, 0, 565}, + DictWord{11, 0, 838}, + DictWord{4, 11, 84}, + DictWord{7, 11, 1482}, + DictWord{10, 11, 76}, + DictWord{138, 11, 142}, + DictWord{133, 0, 585}, + DictWord{141, 10, 306}, + DictWord{ + 133, + 11, + 1015, + }, + DictWord{4, 11, 315}, + DictWord{5, 11, 507}, + DictWord{135, 11, 1370}, + DictWord{136, 10, 146}, + DictWord{6, 0, 691}, + DictWord{134, 0, 1503}, + DictWord{ + 4, + 0, + 334, + }, + DictWord{133, 0, 593}, + DictWord{4, 10, 465}, + DictWord{135, 10, 1663}, + DictWord{142, 11, 173}, + DictWord{135, 0, 913}, + DictWord{12, 0, 116}, + DictWord{134, 11, 1722}, + DictWord{134, 0, 1360}, + DictWord{132, 0, 802}, + DictWord{8, 11, 222}, + DictWord{8, 11, 476}, + DictWord{9, 11, 238}, + DictWord{ + 11, + 11, + 516, + }, + DictWord{11, 11, 575}, + DictWord{15, 11, 109}, + DictWord{146, 11, 100}, + DictWord{6, 0, 308}, + DictWord{9, 0, 673}, + DictWord{7, 10, 138}, + DictWord{ + 7, + 10, + 517, + }, + DictWord{139, 10, 238}, + DictWord{132, 0, 709}, + DictWord{6, 0, 1876}, + DictWord{6, 0, 1895}, + DictWord{9, 0, 994}, + DictWord{9, 0, 1006}, + DictWord{ + 12, + 0, + 829, + }, + DictWord{12, 0, 888}, + DictWord{12, 0, 891}, + DictWord{146, 0, 185}, + DictWord{148, 10, 94}, + DictWord{4, 0, 228}, + DictWord{133, 0, 897}, + DictWord{ + 7, + 0, + 1840, + }, + DictWord{5, 10, 495}, + DictWord{7, 10, 834}, + DictWord{9, 10, 733}, + DictWord{139, 10, 378}, + DictWord{133, 10, 559}, + DictWord{6, 10, 21}, + DictWord{ + 6, + 10, + 1737, + }, + DictWord{7, 10, 1444}, + DictWord{136, 10, 224}, + DictWord{4, 0, 608}, + DictWord{133, 0, 497}, + DictWord{6, 11, 40}, + DictWord{135, 11, 1781}, + DictWord{134, 0, 1573}, + DictWord{135, 0, 2039}, + DictWord{6, 0, 540}, + DictWord{136, 0, 136}, + DictWord{4, 0, 897}, + DictWord{5, 0, 786}, + DictWord{133, 10, 519}, + DictWord{6, 0, 1878}, + DictWord{6, 0, 1884}, + DictWord{9, 0, 938}, + DictWord{9, 0, 948}, + DictWord{9, 0, 955}, + DictWord{9, 0, 973}, + DictWord{9, 0, 1012}, + DictWord{ + 12, + 0, + 895, + }, + DictWord{12, 0, 927}, + DictWord{143, 0, 254}, + DictWord{134, 0, 1469}, + DictWord{133, 0, 999}, + DictWord{4, 0, 299}, + DictWord{135, 0, 1004}, + DictWord{ + 4, + 0, + 745, + }, + DictWord{133, 0, 578}, + DictWord{136, 11, 574}, + DictWord{133, 0, 456}, + DictWord{134, 0, 1457}, + DictWord{7, 0, 1679}, + DictWord{132, 10, 402}, + DictWord{7, 0, 693}, + DictWord{8, 0, 180}, + DictWord{12, 0, 163}, + DictWord{8, 10, 323}, + DictWord{136, 10, 479}, + DictWord{11, 10, 580}, + DictWord{142, 10, 201}, + DictWord{5, 10, 59}, + DictWord{135, 10, 672}, + DictWord{132, 11, 354}, + DictWord{146, 10, 34}, + DictWord{4, 0, 755}, + DictWord{135, 11, 1558}, + DictWord{ + 7, + 0, + 1740, + }, + DictWord{146, 0, 48}, + DictWord{4, 10, 85}, + DictWord{135, 10, 549}, + DictWord{139, 0, 338}, + DictWord{133, 10, 94}, + DictWord{134, 0, 1091}, + DictWord{135, 11, 469}, + DictWord{12, 0, 695}, + DictWord{12, 0, 704}, + DictWord{20, 0, 113}, + DictWord{5, 11, 830}, + DictWord{14, 11, 338}, + DictWord{148, 11, 81}, + DictWord{135, 0, 1464}, + DictWord{6, 10, 11}, + DictWord{135, 10, 187}, + DictWord{135, 0, 975}, + DictWord{13, 0, 335}, + DictWord{132, 10, 522}, + DictWord{ + 134, + 0, + 1979, + }, + DictWord{5, 11, 496}, + DictWord{135, 11, 203}, + DictWord{4, 10, 52}, + DictWord{135, 10, 661}, + DictWord{7, 0, 1566}, + DictWord{8, 0, 269}, + DictWord{ + 9, + 0, + 212, + }, + DictWord{9, 0, 718}, + DictWord{14, 0, 15}, + DictWord{14, 0, 132}, + DictWord{142, 0, 227}, + DictWord{4, 0, 890}, + DictWord{5, 0, 805}, + DictWord{5, 0, 819}, + DictWord{ + 5, + 0, + 961, + }, + DictWord{6, 0, 396}, + DictWord{6, 0, 1631}, + DictWord{6, 0, 1678}, + DictWord{7, 0, 1967}, + DictWord{7, 0, 2041}, + DictWord{9, 0, 630}, + DictWord{11, 0, 8}, + DictWord{11, 0, 1019}, + DictWord{12, 0, 176}, + DictWord{13, 0, 225}, + DictWord{14, 0, 292}, + DictWord{21, 0, 24}, + DictWord{4, 10, 383}, + DictWord{133, 10, 520}, + DictWord{134, 11, 547}, + DictWord{135, 11, 1748}, + DictWord{5, 11, 88}, + DictWord{137, 11, 239}, + DictWord{146, 11, 128}, + DictWord{7, 11, 650}, + DictWord{ + 135, + 11, + 1310, + }, + DictWord{4, 10, 281}, + DictWord{5, 10, 38}, + DictWord{7, 10, 194}, + DictWord{7, 10, 668}, + DictWord{7, 10, 1893}, + DictWord{137, 10, 397}, + DictWord{135, 0, 1815}, + DictWord{9, 10, 635}, + DictWord{139, 10, 559}, + DictWord{7, 0, 1505}, + DictWord{10, 0, 190}, + DictWord{10, 0, 634}, + DictWord{11, 0, 792}, + DictWord{12, 0, 358}, + DictWord{140, 0, 447}, + DictWord{5, 0, 0}, + DictWord{6, 0, 536}, + DictWord{7, 0, 604}, + DictWord{13, 0, 445}, + DictWord{145, 0, 126}, + DictWord{ + 7, + 11, + 1076, + }, + DictWord{9, 11, 80}, + DictWord{11, 11, 78}, + DictWord{11, 11, 421}, + DictWord{11, 11, 534}, + DictWord{140, 11, 545}, + DictWord{8, 0, 966}, + DictWord{ + 10, + 0, + 1023, + }, + DictWord{14, 11, 369}, + DictWord{146, 11, 72}, + DictWord{135, 11, 1641}, + DictWord{6, 0, 232}, + DictWord{6, 0, 412}, + DictWord{7, 0, 1074}, + DictWord{ + 8, + 0, + 9, + }, + DictWord{8, 0, 157}, + DictWord{8, 0, 786}, + DictWord{9, 0, 196}, + DictWord{9, 0, 352}, + DictWord{9, 0, 457}, + DictWord{10, 0, 337}, + DictWord{11, 0, 232}, + DictWord{ + 11, + 0, + 877, + }, + DictWord{12, 0, 480}, + DictWord{140, 0, 546}, + DictWord{135, 0, 958}, + DictWord{4, 0, 382}, + DictWord{136, 0, 579}, + DictWord{4, 0, 212}, + DictWord{ + 135, + 0, + 1206, + }, + DictWord{4, 11, 497}, + DictWord{5, 11, 657}, + DictWord{135, 11, 1584}, + DictWord{132, 0, 681}, + DictWord{8, 0, 971}, + DictWord{138, 0, 965}, + DictWord{ + 5, + 10, + 448, + }, + DictWord{136, 10, 535}, + DictWord{14, 0, 16}, + DictWord{146, 0, 44}, + DictWord{11, 0, 584}, + DictWord{11, 0, 616}, + DictWord{14, 0, 275}, + DictWord{ + 11, + 11, + 584, + }, + DictWord{11, 11, 616}, + DictWord{142, 11, 275}, + DictWord{136, 11, 13}, + DictWord{7, 10, 610}, + DictWord{135, 10, 1501}, + DictWord{7, 11, 642}, + DictWord{8, 11, 250}, + DictWord{11, 11, 123}, + DictWord{11, 11, 137}, + DictWord{13, 11, 48}, + DictWord{142, 11, 95}, + DictWord{133, 0, 655}, + DictWord{17, 0, 67}, + DictWord{147, 0, 74}, + DictWord{134, 0, 751}, + DictWord{134, 0, 1967}, + DictWord{6, 0, 231}, + DictWord{136, 0, 423}, + DictWord{5, 0, 300}, + DictWord{138, 0, 1016}, + DictWord{4, 10, 319}, + DictWord{5, 10, 699}, + DictWord{138, 10, 673}, + DictWord{6, 0, 237}, + DictWord{7, 0, 611}, + DictWord{8, 0, 100}, + DictWord{9, 0, 416}, + DictWord{ + 11, + 0, + 335, + }, + DictWord{12, 0, 173}, + DictWord{18, 0, 101}, + DictWord{6, 10, 336}, + DictWord{8, 10, 552}, + DictWord{9, 10, 285}, + DictWord{10, 10, 99}, + DictWord{ + 139, + 10, + 568, + }, + DictWord{134, 0, 1370}, + DictWord{7, 10, 1406}, + DictWord{9, 10, 218}, + DictWord{141, 10, 222}, + DictWord{133, 10, 256}, + DictWord{ + 135, + 0, + 1208, + }, + DictWord{14, 11, 213}, + DictWord{148, 11, 38}, + DictWord{6, 0, 1219}, + DictWord{135, 11, 1642}, + DictWord{13, 0, 417}, + DictWord{14, 0, 129}, + DictWord{143, 0, 15}, + DictWord{10, 11, 545}, + DictWord{140, 11, 301}, + DictWord{17, 10, 39}, + DictWord{148, 10, 36}, + DictWord{133, 0, 199}, + DictWord{4, 11, 904}, + DictWord{133, 11, 794}, + DictWord{12, 0, 427}, + DictWord{146, 0, 38}, + DictWord{134, 0, 949}, + DictWord{8, 0, 665}, + DictWord{135, 10, 634}, + DictWord{ + 132, + 10, + 618, + }, + DictWord{135, 10, 259}, + DictWord{132, 10, 339}, + DictWord{133, 11, 761}, + DictWord{141, 10, 169}, + DictWord{132, 10, 759}, + DictWord{5, 0, 688}, + DictWord{7, 0, 539}, + DictWord{135, 0, 712}, + DictWord{7, 11, 386}, + DictWord{138, 11, 713}, + DictWord{134, 0, 1186}, + DictWord{6, 11, 7}, + DictWord{6, 11, 35}, + DictWord{ + 7, + 11, + 147, + }, + DictWord{7, 11, 1069}, + DictWord{7, 11, 1568}, + DictWord{7, 11, 1575}, + DictWord{7, 11, 1917}, + DictWord{8, 11, 43}, + DictWord{8, 11, 208}, + DictWord{ + 9, + 11, + 128, + }, + DictWord{9, 11, 866}, + DictWord{10, 11, 20}, + DictWord{11, 11, 981}, + DictWord{147, 11, 33}, + DictWord{7, 11, 893}, + DictWord{8, 10, 482}, + DictWord{141, 11, 424}, + DictWord{6, 0, 312}, + DictWord{6, 0, 1715}, + DictWord{10, 0, 584}, + DictWord{11, 0, 546}, + DictWord{11, 0, 692}, + DictWord{12, 0, 259}, + DictWord{ + 12, + 0, + 295, + }, + DictWord{13, 0, 46}, + DictWord{141, 0, 154}, + DictWord{5, 10, 336}, + DictWord{6, 10, 341}, + DictWord{6, 10, 478}, + DictWord{6, 10, 1763}, + DictWord{ + 136, + 10, + 386, + }, + DictWord{137, 0, 151}, + DictWord{132, 0, 588}, + DictWord{152, 0, 4}, + DictWord{6, 11, 322}, + DictWord{9, 11, 552}, + DictWord{11, 11, 274}, + DictWord{ + 13, + 11, + 209, + }, + DictWord{13, 11, 499}, + DictWord{14, 11, 85}, + DictWord{15, 11, 126}, + DictWord{145, 11, 70}, + DictWord{135, 10, 73}, + DictWord{4, 0, 231}, + DictWord{ + 5, + 0, + 61, + }, + DictWord{6, 0, 104}, + DictWord{7, 0, 729}, + DictWord{7, 0, 964}, + DictWord{7, 0, 1658}, + DictWord{140, 0, 414}, + DictWord{6, 0, 263}, + DictWord{138, 0, 757}, + DictWord{135, 10, 1971}, + DictWord{4, 0, 612}, + DictWord{133, 0, 561}, + DictWord{132, 0, 320}, + DictWord{135, 10, 1344}, + DictWord{8, 11, 83}, + DictWord{ + 8, + 11, + 817, + }, + DictWord{9, 11, 28}, + DictWord{9, 11, 29}, + DictWord{9, 11, 885}, + DictWord{10, 11, 387}, + DictWord{11, 11, 633}, + DictWord{11, 11, 740}, + DictWord{ + 13, + 11, + 235, + }, + DictWord{13, 11, 254}, + DictWord{15, 11, 143}, + DictWord{143, 11, 146}, + DictWord{5, 10, 396}, + DictWord{134, 10, 501}, + DictWord{140, 11, 49}, + DictWord{132, 0, 225}, + DictWord{4, 10, 929}, + DictWord{5, 10, 799}, + DictWord{8, 10, 46}, + DictWord{136, 10, 740}, + DictWord{4, 0, 405}, + DictWord{7, 0, 817}, + DictWord{ + 14, + 0, + 58, + }, + DictWord{17, 0, 37}, + DictWord{146, 0, 124}, + DictWord{133, 0, 974}, + DictWord{4, 11, 412}, + DictWord{133, 11, 581}, + DictWord{4, 10, 892}, + DictWord{ + 133, + 10, + 770, + }, + DictWord{4, 0, 996}, + DictWord{134, 0, 2026}, + DictWord{4, 0, 527}, + DictWord{5, 0, 235}, + DictWord{7, 0, 1239}, + DictWord{11, 0, 131}, + DictWord{ + 140, + 0, + 370, + }, + DictWord{9, 0, 16}, + DictWord{13, 0, 386}, + DictWord{135, 11, 421}, + DictWord{7, 0, 956}, + DictWord{7, 0, 1157}, + DictWord{7, 0, 1506}, + DictWord{7, 0, 1606}, + DictWord{7, 0, 1615}, + DictWord{7, 0, 1619}, + DictWord{7, 0, 1736}, + DictWord{7, 0, 1775}, + DictWord{8, 0, 590}, + DictWord{9, 0, 324}, + DictWord{9, 0, 736}, + DictWord{ + 9, + 0, + 774, + }, + DictWord{9, 0, 776}, + DictWord{9, 0, 784}, + DictWord{10, 0, 567}, + DictWord{10, 0, 708}, + DictWord{11, 0, 518}, + DictWord{11, 0, 613}, + DictWord{11, 0, 695}, + DictWord{11, 0, 716}, + DictWord{11, 0, 739}, + DictWord{11, 0, 770}, + DictWord{11, 0, 771}, + DictWord{11, 0, 848}, + DictWord{11, 0, 857}, + DictWord{11, 0, 931}, + DictWord{ + 11, + 0, + 947, + }, + DictWord{12, 0, 326}, + DictWord{12, 0, 387}, + DictWord{12, 0, 484}, + DictWord{12, 0, 528}, + DictWord{12, 0, 552}, + DictWord{12, 0, 613}, + DictWord{ + 13, + 0, + 189, + }, + DictWord{13, 0, 256}, + DictWord{13, 0, 340}, + DictWord{13, 0, 432}, + DictWord{13, 0, 436}, + DictWord{13, 0, 440}, + DictWord{13, 0, 454}, + DictWord{14, 0, 174}, + DictWord{14, 0, 220}, + DictWord{14, 0, 284}, + DictWord{14, 0, 390}, + DictWord{145, 0, 121}, + DictWord{135, 10, 158}, + DictWord{9, 0, 137}, + DictWord{138, 0, 221}, + DictWord{4, 11, 110}, + DictWord{10, 11, 415}, + DictWord{10, 11, 597}, + DictWord{142, 11, 206}, + DictWord{141, 11, 496}, + DictWord{135, 11, 205}, + DictWord{ + 151, + 10, + 25, + }, + DictWord{135, 11, 778}, + DictWord{7, 11, 1656}, + DictWord{7, 10, 2001}, + DictWord{9, 11, 369}, + DictWord{10, 11, 338}, + DictWord{10, 11, 490}, + DictWord{11, 11, 154}, + DictWord{11, 11, 545}, + DictWord{11, 11, 775}, + DictWord{13, 11, 77}, + DictWord{141, 11, 274}, + DictWord{4, 11, 444}, + DictWord{ + 10, + 11, + 146, + }, + DictWord{140, 11, 9}, + DictWord{7, 0, 390}, + DictWord{138, 0, 140}, + DictWord{135, 0, 1144}, + DictWord{134, 0, 464}, + DictWord{7, 10, 1461}, + DictWord{ + 140, + 10, + 91, + }, + DictWord{132, 10, 602}, + DictWord{4, 11, 283}, + DictWord{135, 11, 1194}, + DictWord{5, 0, 407}, + DictWord{11, 0, 204}, + DictWord{11, 0, 243}, + DictWord{ + 11, + 0, + 489, + }, + DictWord{12, 0, 293}, + DictWord{19, 0, 37}, + DictWord{20, 0, 73}, + DictWord{150, 0, 38}, + DictWord{7, 0, 1218}, + DictWord{136, 0, 303}, + DictWord{ + 5, + 0, + 325, + }, + DictWord{8, 0, 5}, + DictWord{8, 0, 227}, + DictWord{9, 0, 105}, + DictWord{10, 0, 585}, + DictWord{12, 0, 614}, + DictWord{4, 10, 13}, + DictWord{5, 10, 567}, + DictWord{ + 7, + 10, + 1498, + }, + DictWord{9, 10, 124}, + DictWord{11, 10, 521}, + DictWord{140, 10, 405}, + DictWord{135, 10, 1006}, + DictWord{7, 0, 800}, + DictWord{10, 0, 12}, + DictWord{134, 11, 1720}, + DictWord{135, 0, 1783}, + DictWord{132, 10, 735}, + DictWord{138, 10, 812}, + DictWord{4, 10, 170}, + DictWord{135, 10, 323}, + DictWord{ + 6, + 0, + 621, + }, + DictWord{13, 0, 504}, + DictWord{144, 0, 89}, + DictWord{5, 10, 304}, + DictWord{135, 10, 1403}, + DictWord{137, 11, 216}, + DictWord{6, 0, 920}, + DictWord{ + 6, + 0, + 1104, + }, + DictWord{9, 11, 183}, + DictWord{139, 11, 286}, + DictWord{4, 0, 376}, + DictWord{133, 10, 742}, + DictWord{134, 0, 218}, + DictWord{8, 0, 641}, + DictWord{ + 11, + 0, + 388, + }, + DictWord{140, 0, 580}, + DictWord{7, 0, 454}, + DictWord{7, 0, 782}, + DictWord{8, 0, 768}, + DictWord{140, 0, 686}, + DictWord{137, 11, 33}, + DictWord{ + 133, + 10, + 111, + }, + DictWord{144, 0, 0}, + DictWord{10, 0, 676}, + DictWord{140, 0, 462}, + DictWord{6, 0, 164}, + DictWord{136, 11, 735}, + DictWord{133, 10, 444}, + DictWord{ + 150, + 0, + 50, + }, + DictWord{7, 11, 1862}, + DictWord{12, 11, 491}, + DictWord{12, 11, 520}, + DictWord{13, 11, 383}, + DictWord{14, 11, 244}, + DictWord{146, 11, 12}, + DictWord{ + 5, + 11, + 132, + }, + DictWord{9, 11, 486}, + DictWord{9, 11, 715}, + DictWord{10, 11, 458}, + DictWord{11, 11, 373}, + DictWord{11, 11, 668}, + DictWord{11, 11, 795}, + DictWord{11, 11, 897}, + DictWord{12, 11, 272}, + DictWord{12, 11, 424}, + DictWord{12, 11, 539}, + DictWord{12, 11, 558}, + DictWord{14, 11, 245}, + DictWord{ + 14, + 11, + 263, + }, + DictWord{14, 11, 264}, + DictWord{14, 11, 393}, + DictWord{142, 11, 403}, + DictWord{8, 10, 123}, + DictWord{15, 10, 6}, + DictWord{144, 10, 7}, + DictWord{ + 6, + 0, + 285, + }, + DictWord{8, 0, 654}, + DictWord{11, 0, 749}, + DictWord{12, 0, 190}, + DictWord{12, 0, 327}, + DictWord{13, 0, 120}, + DictWord{13, 0, 121}, + DictWord{13, 0, 327}, + DictWord{15, 0, 47}, + DictWord{146, 0, 40}, + DictWord{5, 11, 8}, + DictWord{6, 11, 89}, + DictWord{6, 11, 400}, + DictWord{7, 11, 1569}, + DictWord{7, 11, 1623}, + DictWord{ + 7, + 11, + 1850, + }, + DictWord{8, 11, 218}, + DictWord{8, 11, 422}, + DictWord{9, 11, 570}, + DictWord{138, 11, 626}, + DictWord{6, 11, 387}, + DictWord{7, 11, 882}, + DictWord{141, 11, 111}, + DictWord{6, 0, 343}, + DictWord{7, 0, 195}, + DictWord{9, 0, 226}, + DictWord{10, 0, 197}, + DictWord{10, 0, 575}, + DictWord{11, 0, 502}, + DictWord{ + 11, + 0, + 899, + }, + DictWord{6, 11, 224}, + DictWord{7, 11, 877}, + DictWord{137, 11, 647}, + DictWord{5, 10, 937}, + DictWord{135, 10, 100}, + DictWord{135, 11, 790}, + DictWord{150, 0, 29}, + DictWord{147, 0, 8}, + DictWord{134, 0, 1812}, + DictWord{149, 0, 8}, + DictWord{135, 11, 394}, + DictWord{7, 0, 1125}, + DictWord{9, 0, 143}, + DictWord{ + 11, + 0, + 61, + }, + DictWord{14, 0, 405}, + DictWord{150, 0, 21}, + DictWord{10, 11, 755}, + DictWord{147, 11, 29}, + DictWord{9, 11, 378}, + DictWord{141, 11, 162}, + DictWord{135, 10, 922}, + DictWord{5, 10, 619}, + DictWord{133, 10, 698}, + DictWord{134, 0, 1327}, + DictWord{6, 0, 1598}, + DictWord{137, 0, 575}, + DictWord{ + 9, + 11, + 569, + }, + DictWord{12, 11, 12}, + DictWord{12, 11, 81}, + DictWord{12, 11, 319}, + DictWord{13, 11, 69}, + DictWord{14, 11, 259}, + DictWord{16, 11, 87}, + DictWord{ + 17, + 11, + 1, + }, + DictWord{17, 11, 21}, + DictWord{17, 11, 24}, + DictWord{18, 11, 15}, + DictWord{18, 11, 56}, + DictWord{18, 11, 59}, + DictWord{18, 11, 127}, + DictWord{18, 11, 154}, + DictWord{19, 11, 19}, + DictWord{148, 11, 31}, + DictWord{6, 0, 895}, + DictWord{135, 11, 1231}, + DictWord{5, 0, 959}, + DictWord{7, 11, 124}, + DictWord{136, 11, 38}, + DictWord{5, 11, 261}, + DictWord{7, 11, 78}, + DictWord{7, 11, 199}, + DictWord{8, 11, 815}, + DictWord{9, 11, 126}, + DictWord{138, 11, 342}, + DictWord{5, 10, 917}, + DictWord{134, 10, 1659}, + DictWord{7, 0, 1759}, + DictWord{5, 11, 595}, + DictWord{135, 11, 1863}, + DictWord{136, 0, 173}, + DictWord{134, 0, 266}, + DictWord{ + 142, + 0, + 261, + }, + DictWord{132, 11, 628}, + DictWord{5, 10, 251}, + DictWord{5, 10, 956}, + DictWord{8, 10, 268}, + DictWord{9, 10, 214}, + DictWord{146, 10, 142}, + DictWord{ + 7, + 11, + 266, + }, + DictWord{136, 11, 804}, + DictWord{135, 11, 208}, + DictWord{6, 11, 79}, + DictWord{7, 11, 1021}, + DictWord{135, 11, 1519}, + DictWord{11, 11, 704}, + DictWord{141, 11, 396}, + DictWord{5, 10, 346}, + DictWord{5, 10, 711}, + DictWord{136, 10, 390}, + DictWord{136, 11, 741}, + DictWord{134, 11, 376}, + DictWord{ + 134, + 0, + 1427, + }, + DictWord{6, 0, 1033}, + DictWord{6, 0, 1217}, + DictWord{136, 0, 300}, + DictWord{133, 10, 624}, + DictWord{6, 11, 100}, + DictWord{7, 11, 244}, + DictWord{ + 7, + 11, + 632, + }, + DictWord{7, 11, 1609}, + DictWord{8, 11, 178}, + DictWord{8, 11, 638}, + DictWord{141, 11, 58}, + DictWord{6, 0, 584}, + DictWord{5, 10, 783}, + DictWord{ + 7, + 10, + 1998, + }, + DictWord{135, 10, 2047}, + DictWord{5, 0, 427}, + DictWord{5, 0, 734}, + DictWord{7, 0, 478}, + DictWord{136, 0, 52}, + DictWord{7, 0, 239}, + DictWord{ + 11, + 0, + 217, + }, + DictWord{142, 0, 165}, + DictWord{134, 0, 1129}, + DictWord{6, 0, 168}, + DictWord{6, 0, 1734}, + DictWord{7, 0, 20}, + DictWord{7, 0, 1056}, + DictWord{8, 0, 732}, + DictWord{9, 0, 406}, + DictWord{9, 0, 911}, + DictWord{138, 0, 694}, + DictWord{132, 10, 594}, + DictWord{133, 11, 791}, + DictWord{7, 11, 686}, + DictWord{8, 11, 33}, + DictWord{8, 11, 238}, + DictWord{10, 11, 616}, + DictWord{11, 11, 467}, + DictWord{11, 11, 881}, + DictWord{13, 11, 217}, + DictWord{13, 11, 253}, + DictWord{ + 142, + 11, + 268, + }, + DictWord{137, 11, 476}, + DictWord{134, 0, 418}, + DictWord{133, 0, 613}, + DictWord{132, 0, 632}, + DictWord{132, 11, 447}, + DictWord{7, 0, 32}, + DictWord{ + 7, + 0, + 984, + }, + DictWord{8, 0, 85}, + DictWord{8, 0, 709}, + DictWord{9, 0, 579}, + DictWord{9, 0, 847}, + DictWord{9, 0, 856}, + DictWord{10, 0, 799}, + DictWord{11, 0, 258}, + DictWord{ + 11, + 0, + 1007, + }, + DictWord{12, 0, 331}, + DictWord{12, 0, 615}, + DictWord{13, 0, 188}, + DictWord{13, 0, 435}, + DictWord{14, 0, 8}, + DictWord{15, 0, 165}, + DictWord{ + 16, + 0, + 27, + }, + DictWord{20, 0, 40}, + DictWord{144, 11, 35}, + DictWord{4, 11, 128}, + DictWord{5, 11, 415}, + DictWord{6, 11, 462}, + DictWord{7, 11, 294}, + DictWord{7, 11, 578}, + DictWord{10, 11, 710}, + DictWord{139, 11, 86}, + DictWord{5, 0, 694}, + DictWord{136, 0, 909}, + DictWord{7, 0, 1109}, + DictWord{11, 0, 7}, + DictWord{5, 10, 37}, + DictWord{ + 6, + 10, + 39, + }, + DictWord{6, 10, 451}, + DictWord{7, 10, 218}, + DictWord{7, 10, 1166}, + DictWord{7, 10, 1687}, + DictWord{8, 10, 662}, + DictWord{144, 10, 2}, + DictWord{ + 136, + 11, + 587, + }, + DictWord{6, 11, 427}, + DictWord{7, 11, 1018}, + DictWord{138, 11, 692}, + DictWord{4, 11, 195}, + DictWord{6, 10, 508}, + DictWord{135, 11, 802}, + DictWord{4, 0, 167}, + DictWord{135, 0, 82}, + DictWord{5, 0, 62}, + DictWord{6, 0, 24}, + DictWord{6, 0, 534}, + DictWord{7, 0, 74}, + DictWord{7, 0, 678}, + DictWord{7, 0, 684}, + DictWord{ + 7, + 0, + 1043, + }, + DictWord{7, 0, 1072}, + DictWord{8, 0, 280}, + DictWord{8, 0, 541}, + DictWord{8, 0, 686}, + DictWord{9, 0, 258}, + DictWord{10, 0, 519}, + DictWord{11, 0, 252}, + DictWord{140, 0, 282}, + DictWord{138, 0, 33}, + DictWord{4, 0, 359}, + DictWord{133, 11, 738}, + DictWord{7, 0, 980}, + DictWord{9, 0, 328}, + DictWord{13, 0, 186}, + DictWord{13, 0, 364}, + DictWord{7, 10, 635}, + DictWord{7, 10, 796}, + DictWord{8, 10, 331}, + DictWord{9, 10, 330}, + DictWord{9, 10, 865}, + DictWord{10, 10, 119}, + DictWord{ + 10, + 10, + 235, + }, + DictWord{11, 10, 111}, + DictWord{11, 10, 129}, + DictWord{11, 10, 240}, + DictWord{12, 10, 31}, + DictWord{12, 10, 66}, + DictWord{12, 10, 222}, + DictWord{12, 10, 269}, + DictWord{12, 10, 599}, + DictWord{12, 10, 684}, + DictWord{12, 10, 689}, + DictWord{12, 10, 691}, + DictWord{142, 10, 345}, + DictWord{ + 137, + 10, + 527, + }, + DictWord{6, 0, 596}, + DictWord{7, 0, 585}, + DictWord{135, 10, 702}, + DictWord{134, 11, 1683}, + DictWord{133, 0, 211}, + DictWord{6, 0, 145}, + DictWord{ + 141, + 0, + 336, + }, + DictWord{134, 0, 1130}, + DictWord{7, 0, 873}, + DictWord{6, 10, 37}, + DictWord{7, 10, 1666}, + DictWord{8, 10, 195}, + DictWord{8, 10, 316}, + DictWord{ + 9, + 10, + 178, + }, + DictWord{9, 10, 276}, + DictWord{9, 10, 339}, + DictWord{9, 10, 536}, + DictWord{10, 10, 102}, + DictWord{10, 10, 362}, + DictWord{10, 10, 785}, + DictWord{ + 11, + 10, + 55, + }, + DictWord{11, 10, 149}, + DictWord{11, 10, 773}, + DictWord{13, 10, 416}, + DictWord{13, 10, 419}, + DictWord{14, 10, 38}, + DictWord{14, 10, 41}, + DictWord{ + 142, + 10, + 210, + }, + DictWord{8, 0, 840}, + DictWord{136, 0, 841}, + DictWord{132, 0, 263}, + DictWord{5, 11, 3}, + DictWord{8, 11, 578}, + DictWord{9, 11, 118}, + DictWord{ + 10, + 11, + 705, + }, + DictWord{12, 11, 383}, + DictWord{141, 11, 279}, + DictWord{132, 0, 916}, + DictWord{133, 11, 229}, + DictWord{133, 10, 645}, + DictWord{15, 0, 155}, + DictWord{16, 0, 79}, + DictWord{8, 11, 102}, + DictWord{10, 11, 578}, + DictWord{10, 11, 672}, + DictWord{12, 11, 496}, + DictWord{13, 11, 408}, + DictWord{14, 11, 121}, + DictWord{145, 11, 106}, + DictWord{4, 0, 599}, + DictWord{5, 0, 592}, + DictWord{6, 0, 1634}, + DictWord{7, 0, 5}, + DictWord{7, 0, 55}, + DictWord{7, 0, 67}, + DictWord{7, 0, 97}, + DictWord{7, 0, 691}, + DictWord{7, 0, 979}, + DictWord{7, 0, 1600}, + DictWord{7, 0, 1697}, + DictWord{8, 0, 207}, + DictWord{8, 0, 214}, + DictWord{8, 0, 231}, + DictWord{8, 0, 294}, + DictWord{8, 0, 336}, + DictWord{8, 0, 428}, + DictWord{8, 0, 471}, + DictWord{8, 0, 622}, + DictWord{8, 0, 626}, + DictWord{8, 0, 679}, + DictWord{8, 0, 759}, + DictWord{8, 0, 829}, + DictWord{9, 0, 11}, + DictWord{9, 0, 246}, + DictWord{9, 0, 484}, + DictWord{9, 0, 573}, + DictWord{9, 0, 706}, + DictWord{9, 0, 762}, + DictWord{9, 0, 798}, + DictWord{9, 0, 855}, + DictWord{9, 0, 870}, + DictWord{9, 0, 912}, + DictWord{10, 0, 303}, + DictWord{10, 0, 335}, + DictWord{10, 0, 424}, + DictWord{10, 0, 461}, + DictWord{10, 0, 543}, + DictWord{ + 10, + 0, + 759, + }, + DictWord{10, 0, 814}, + DictWord{11, 0, 59}, + DictWord{11, 0, 199}, + DictWord{11, 0, 235}, + DictWord{11, 0, 590}, + DictWord{11, 0, 631}, + DictWord{11, 0, 929}, + DictWord{11, 0, 963}, + DictWord{11, 0, 987}, + DictWord{12, 0, 114}, + DictWord{12, 0, 182}, + DictWord{12, 0, 226}, + DictWord{12, 0, 332}, + DictWord{12, 0, 439}, + DictWord{12, 0, 575}, + DictWord{12, 0, 598}, + DictWord{12, 0, 675}, + DictWord{13, 0, 8}, + DictWord{13, 0, 125}, + DictWord{13, 0, 194}, + DictWord{13, 0, 287}, + DictWord{ + 14, + 0, + 197, + }, + DictWord{14, 0, 383}, + DictWord{15, 0, 53}, + DictWord{17, 0, 63}, + DictWord{19, 0, 46}, + DictWord{19, 0, 98}, + DictWord{19, 0, 106}, + DictWord{148, 0, 85}, + DictWord{ + 7, + 0, + 1356, + }, + DictWord{132, 10, 290}, + DictWord{6, 10, 70}, + DictWord{7, 10, 1292}, + DictWord{10, 10, 762}, + DictWord{139, 10, 288}, + DictWord{150, 11, 55}, + DictWord{4, 0, 593}, + DictWord{8, 11, 115}, + DictWord{8, 11, 350}, + DictWord{9, 11, 489}, + DictWord{10, 11, 128}, + DictWord{11, 11, 306}, + DictWord{12, 11, 373}, + DictWord{14, 11, 30}, + DictWord{17, 11, 79}, + DictWord{147, 11, 80}, + DictWord{135, 11, 1235}, + DictWord{134, 0, 1392}, + DictWord{4, 11, 230}, + DictWord{ + 133, + 11, + 702, + }, + DictWord{147, 0, 126}, + DictWord{7, 10, 131}, + DictWord{7, 10, 422}, + DictWord{8, 10, 210}, + DictWord{140, 10, 573}, + DictWord{134, 0, 1179}, + DictWord{ + 139, + 11, + 435, + }, + DictWord{139, 10, 797}, + DictWord{134, 11, 1728}, + DictWord{4, 0, 162}, + DictWord{18, 11, 26}, + DictWord{19, 11, 42}, + DictWord{20, 11, 43}, + DictWord{21, 11, 0}, + DictWord{23, 11, 27}, + DictWord{152, 11, 14}, + DictWord{132, 10, 936}, + DictWord{6, 0, 765}, + DictWord{5, 10, 453}, + DictWord{134, 10, 441}, + DictWord{133, 0, 187}, + DictWord{135, 0, 1286}, + DictWord{6, 0, 635}, + DictWord{6, 0, 904}, + DictWord{6, 0, 1210}, + DictWord{134, 0, 1489}, + DictWord{4, 0, 215}, + DictWord{ + 8, + 0, + 890, + }, + DictWord{9, 0, 38}, + DictWord{10, 0, 923}, + DictWord{11, 0, 23}, + DictWord{11, 0, 127}, + DictWord{139, 0, 796}, + DictWord{6, 0, 1165}, + DictWord{ + 134, + 0, + 1306, + }, + DictWord{7, 0, 716}, + DictWord{13, 0, 97}, + DictWord{141, 0, 251}, + DictWord{132, 10, 653}, + DictWord{136, 0, 657}, + DictWord{146, 10, 80}, + DictWord{ + 5, + 11, + 622, + }, + DictWord{7, 11, 1032}, + DictWord{11, 11, 26}, + DictWord{11, 11, 213}, + DictWord{11, 11, 707}, + DictWord{12, 11, 380}, + DictWord{13, 11, 226}, + DictWord{141, 11, 355}, + DictWord{6, 0, 299}, + DictWord{5, 11, 70}, + DictWord{6, 11, 334}, + DictWord{9, 11, 171}, + DictWord{11, 11, 637}, + DictWord{12, 11, 202}, + DictWord{14, 11, 222}, + DictWord{145, 11, 42}, + DictWord{142, 0, 134}, + DictWord{4, 11, 23}, + DictWord{5, 11, 313}, + DictWord{5, 11, 1014}, + DictWord{6, 11, 50}, + DictWord{ + 6, + 11, + 51, + }, + DictWord{7, 11, 142}, + DictWord{7, 11, 384}, + DictWord{9, 11, 783}, + DictWord{139, 11, 741}, + DictWord{4, 11, 141}, + DictWord{7, 11, 559}, + DictWord{ + 8, + 11, + 640, + }, + DictWord{9, 11, 460}, + DictWord{12, 11, 183}, + DictWord{141, 11, 488}, + DictWord{136, 11, 614}, + DictWord{7, 10, 1368}, + DictWord{8, 10, 232}, + DictWord{8, 10, 361}, + DictWord{10, 10, 682}, + DictWord{138, 10, 742}, + DictWord{137, 10, 534}, + DictWord{6, 0, 1082}, + DictWord{140, 0, 658}, + DictWord{ + 137, + 10, + 27, + }, + DictWord{135, 0, 2002}, + DictWord{142, 10, 12}, + DictWord{4, 0, 28}, + DictWord{5, 0, 440}, + DictWord{7, 0, 248}, + DictWord{11, 0, 833}, + DictWord{140, 0, 344}, + DictWord{7, 10, 736}, + DictWord{139, 10, 264}, + DictWord{134, 10, 1657}, + DictWord{134, 0, 1654}, + DictWord{138, 0, 531}, + DictWord{5, 11, 222}, + DictWord{ + 9, + 11, + 140, + }, + DictWord{138, 11, 534}, + DictWord{6, 0, 634}, + DictWord{6, 0, 798}, + DictWord{134, 0, 840}, + DictWord{138, 11, 503}, + DictWord{135, 10, 127}, + DictWord{133, 0, 853}, + DictWord{5, 11, 154}, + DictWord{7, 11, 1491}, + DictWord{10, 11, 379}, + DictWord{138, 11, 485}, + DictWord{6, 0, 249}, + DictWord{7, 0, 1234}, + DictWord{139, 0, 573}, + DictWord{133, 11, 716}, + DictWord{7, 11, 1570}, + DictWord{140, 11, 542}, + DictWord{136, 10, 364}, + DictWord{138, 0, 527}, + DictWord{ + 4, + 11, + 91, + }, + DictWord{5, 11, 388}, + DictWord{5, 11, 845}, + DictWord{6, 11, 206}, + DictWord{6, 11, 252}, + DictWord{6, 11, 365}, + DictWord{7, 11, 136}, + DictWord{7, 11, 531}, + DictWord{8, 11, 264}, + DictWord{136, 11, 621}, + DictWord{134, 0, 1419}, + DictWord{135, 11, 1441}, + DictWord{7, 0, 49}, + DictWord{7, 0, 392}, + DictWord{8, 0, 20}, + DictWord{8, 0, 172}, + DictWord{8, 0, 690}, + DictWord{9, 0, 383}, + DictWord{9, 0, 845}, + DictWord{10, 0, 48}, + DictWord{11, 0, 293}, + DictWord{11, 0, 832}, + DictWord{ + 11, + 0, + 920, + }, + DictWord{11, 0, 984}, + DictWord{141, 0, 221}, + DictWord{5, 0, 858}, + DictWord{133, 0, 992}, + DictWord{5, 0, 728}, + DictWord{137, 10, 792}, + DictWord{ + 5, + 10, + 909, + }, + DictWord{9, 10, 849}, + DictWord{138, 10, 805}, + DictWord{7, 0, 525}, + DictWord{7, 0, 1579}, + DictWord{8, 0, 497}, + DictWord{136, 0, 573}, + DictWord{6, 0, 268}, + DictWord{137, 0, 62}, + DictWord{135, 11, 576}, + DictWord{134, 0, 1201}, + DictWord{5, 11, 771}, + DictWord{5, 11, 863}, + DictWord{5, 11, 898}, + DictWord{ + 6, + 11, + 1632, + }, + DictWord{6, 11, 1644}, + DictWord{134, 11, 1780}, + DictWord{133, 11, 331}, + DictWord{7, 0, 193}, + DictWord{7, 0, 1105}, + DictWord{10, 0, 495}, + DictWord{ + 7, + 10, + 397, + }, + DictWord{8, 10, 124}, + DictWord{8, 10, 619}, + DictWord{9, 10, 305}, + DictWord{11, 10, 40}, + DictWord{12, 10, 349}, + DictWord{13, 10, 134}, + DictWord{ + 13, + 10, + 295, + }, + DictWord{14, 10, 155}, + DictWord{15, 10, 120}, + DictWord{146, 10, 105}, + DictWord{138, 0, 106}, + DictWord{6, 0, 859}, + DictWord{5, 11, 107}, + DictWord{ + 7, + 11, + 201, + }, + DictWord{136, 11, 518}, + DictWord{6, 11, 446}, + DictWord{135, 11, 1817}, + DictWord{13, 0, 23}, + DictWord{4, 10, 262}, + DictWord{135, 10, 342}, + DictWord{133, 10, 641}, + DictWord{137, 11, 851}, + DictWord{6, 0, 925}, + DictWord{137, 0, 813}, + DictWord{132, 11, 504}, + DictWord{6, 0, 613}, + DictWord{ + 136, + 0, + 223, + }, + DictWord{4, 10, 99}, + DictWord{6, 10, 250}, + DictWord{6, 10, 346}, + DictWord{8, 10, 127}, + DictWord{138, 10, 81}, + DictWord{136, 0, 953}, + DictWord{ + 132, + 10, + 915, + }, + DictWord{139, 11, 892}, + DictWord{5, 10, 75}, + DictWord{9, 10, 517}, + DictWord{10, 10, 470}, + DictWord{12, 10, 155}, + DictWord{141, 10, 224}, + DictWord{ + 4, + 0, + 666, + }, + DictWord{7, 0, 1017}, + DictWord{7, 11, 996}, + DictWord{138, 11, 390}, + DictWord{5, 11, 883}, + DictWord{133, 11, 975}, + DictWord{14, 10, 83}, + DictWord{ + 142, + 11, + 83, + }, + DictWord{4, 0, 670}, + DictWord{5, 11, 922}, + DictWord{134, 11, 1707}, + DictWord{135, 0, 216}, + DictWord{9, 0, 40}, + DictWord{11, 0, 136}, + DictWord{ + 135, + 11, + 787, + }, + DictWord{5, 10, 954}, + DictWord{5, 11, 993}, + DictWord{7, 11, 515}, + DictWord{137, 11, 91}, + DictWord{139, 0, 259}, + DictWord{7, 0, 1114}, + DictWord{ + 9, + 0, + 310, + }, + DictWord{9, 0, 682}, + DictWord{10, 0, 440}, + DictWord{13, 0, 40}, + DictWord{6, 10, 304}, + DictWord{8, 10, 418}, + DictWord{11, 10, 341}, + DictWord{ + 139, + 10, + 675, + }, + DictWord{14, 0, 296}, + DictWord{9, 10, 410}, + DictWord{139, 10, 425}, + DictWord{10, 11, 377}, + DictWord{12, 11, 363}, + DictWord{13, 11, 68}, + DictWord{ + 13, + 11, + 94, + }, + DictWord{14, 11, 108}, + DictWord{142, 11, 306}, + DictWord{7, 0, 1401}, + DictWord{135, 0, 1476}, + DictWord{4, 0, 296}, + DictWord{6, 0, 475}, + DictWord{ + 7, + 0, + 401, + }, + DictWord{7, 0, 1410}, + DictWord{7, 0, 1594}, + DictWord{7, 0, 1674}, + DictWord{8, 0, 63}, + DictWord{8, 0, 660}, + DictWord{137, 0, 74}, + DictWord{4, 0, 139}, + DictWord{4, 0, 388}, + DictWord{140, 0, 188}, + DictWord{132, 0, 797}, + DictWord{132, 11, 766}, + DictWord{5, 11, 103}, + DictWord{7, 11, 921}, + DictWord{8, 11, 580}, + DictWord{8, 11, 593}, + DictWord{8, 11, 630}, + DictWord{138, 11, 28}, + DictWord{4, 11, 911}, + DictWord{5, 11, 867}, + DictWord{133, 11, 1013}, + DictWord{134, 10, 14}, + DictWord{134, 0, 1572}, + DictWord{134, 10, 1708}, + DictWord{21, 0, 39}, + DictWord{5, 10, 113}, + DictWord{6, 10, 243}, + DictWord{7, 10, 1865}, + DictWord{ + 11, + 10, + 161, + }, + DictWord{16, 10, 37}, + DictWord{145, 10, 99}, + DictWord{7, 11, 1563}, + DictWord{141, 11, 182}, + DictWord{5, 11, 135}, + DictWord{6, 11, 519}, + DictWord{ + 7, + 11, + 1722, + }, + DictWord{10, 11, 271}, + DictWord{11, 11, 261}, + DictWord{145, 11, 54}, + DictWord{132, 10, 274}, + DictWord{134, 0, 1594}, + DictWord{4, 11, 300}, + DictWord{5, 11, 436}, + DictWord{135, 11, 484}, + DictWord{4, 0, 747}, + DictWord{6, 0, 290}, + DictWord{7, 0, 649}, + DictWord{7, 0, 1479}, + DictWord{135, 0, 1583}, + DictWord{133, 11, 535}, + DictWord{147, 11, 82}, + DictWord{133, 0, 232}, + DictWord{137, 0, 887}, + DictWord{135, 10, 166}, + DictWord{136, 0, 521}, + DictWord{4, 0, 14}, + DictWord{7, 0, 472}, + DictWord{7, 0, 1801}, + DictWord{10, 0, 748}, + DictWord{141, 0, 458}, + DictWord{134, 0, 741}, + DictWord{134, 0, 992}, + DictWord{16, 0, 111}, + DictWord{137, 10, 304}, + DictWord{4, 0, 425}, + DictWord{5, 11, 387}, + DictWord{7, 11, 557}, + DictWord{12, 11, 547}, + DictWord{142, 11, 86}, + DictWord{ + 135, + 11, + 1747, + }, + DictWord{5, 10, 654}, + DictWord{135, 11, 1489}, + DictWord{7, 0, 789}, + DictWord{4, 11, 6}, + DictWord{5, 11, 708}, + DictWord{136, 11, 75}, + DictWord{ + 6, + 10, + 273, + }, + DictWord{10, 10, 188}, + DictWord{13, 10, 377}, + DictWord{146, 10, 77}, + DictWord{6, 0, 1593}, + DictWord{4, 11, 303}, + DictWord{7, 11, 619}, + DictWord{ + 10, + 11, + 547, + }, + DictWord{10, 11, 687}, + DictWord{11, 11, 122}, + DictWord{140, 11, 601}, + DictWord{134, 0, 1768}, + DictWord{135, 10, 410}, + DictWord{138, 11, 772}, + DictWord{11, 0, 233}, + DictWord{139, 10, 524}, + DictWord{5, 0, 943}, + DictWord{134, 0, 1779}, + DictWord{134, 10, 1785}, + DictWord{136, 11, 529}, + DictWord{ + 132, + 0, + 955, + }, + DictWord{5, 0, 245}, + DictWord{6, 0, 576}, + DictWord{7, 0, 582}, + DictWord{136, 0, 225}, + DictWord{132, 10, 780}, + DictWord{142, 0, 241}, + DictWord{ + 134, + 0, + 1943, + }, + DictWord{4, 11, 106}, + DictWord{7, 11, 310}, + DictWord{7, 11, 1785}, + DictWord{10, 11, 690}, + DictWord{139, 11, 717}, + DictWord{134, 0, 1284}, + DictWord{5, 11, 890}, + DictWord{133, 11, 988}, + DictWord{6, 11, 626}, + DictWord{142, 11, 431}, + DictWord{10, 11, 706}, + DictWord{145, 11, 32}, + DictWord{ + 137, + 11, + 332, + }, + DictWord{132, 11, 698}, + DictWord{135, 0, 709}, + DictWord{5, 10, 948}, + DictWord{138, 11, 17}, + DictWord{136, 0, 554}, + DictWord{134, 0, 1564}, + DictWord{139, 10, 941}, + DictWord{132, 0, 443}, + DictWord{134, 0, 909}, + DictWord{134, 11, 84}, + DictWord{142, 0, 280}, + DictWord{4, 10, 532}, + DictWord{5, 10, 706}, + DictWord{135, 10, 662}, + DictWord{132, 0, 729}, + DictWord{5, 10, 837}, + DictWord{6, 10, 1651}, + DictWord{139, 10, 985}, + DictWord{135, 10, 1861}, + DictWord{ + 4, + 0, + 348, + }, + DictWord{152, 11, 3}, + DictWord{5, 11, 986}, + DictWord{6, 11, 130}, + DictWord{7, 11, 1582}, + DictWord{8, 11, 458}, + DictWord{10, 11, 101}, + DictWord{ + 10, + 11, + 318, + }, + DictWord{138, 11, 823}, + DictWord{134, 0, 758}, + DictWord{4, 0, 298}, + DictWord{137, 0, 848}, + DictWord{4, 10, 330}, + DictWord{7, 10, 933}, + DictWord{ + 7, + 10, + 2012, + }, + DictWord{136, 10, 292}, + DictWord{7, 11, 1644}, + DictWord{137, 11, 129}, + DictWord{6, 0, 1422}, + DictWord{9, 0, 829}, + DictWord{135, 10, 767}, + DictWord{5, 0, 164}, + DictWord{7, 0, 121}, + DictWord{142, 0, 189}, + DictWord{7, 0, 812}, + DictWord{7, 0, 1261}, + DictWord{7, 0, 1360}, + DictWord{9, 0, 632}, + DictWord{ + 140, + 0, + 352, + }, + DictWord{135, 11, 1788}, + DictWord{139, 0, 556}, + DictWord{135, 11, 997}, + DictWord{145, 10, 114}, + DictWord{4, 0, 172}, + DictWord{9, 0, 611}, + DictWord{10, 0, 436}, + DictWord{12, 0, 673}, + DictWord{13, 0, 255}, + DictWord{137, 10, 883}, + DictWord{11, 0, 530}, + DictWord{138, 10, 274}, + DictWord{133, 0, 844}, + DictWord{134, 0, 984}, + DictWord{13, 0, 232}, + DictWord{18, 0, 35}, + DictWord{4, 10, 703}, + DictWord{135, 10, 207}, + DictWord{132, 10, 571}, + DictWord{9, 0, 263}, + DictWord{10, 0, 147}, + DictWord{138, 0, 492}, + DictWord{7, 11, 1756}, + DictWord{137, 11, 98}, + DictWord{5, 10, 873}, + DictWord{5, 10, 960}, + DictWord{8, 10, 823}, + DictWord{137, 10, 881}, + DictWord{133, 0, 537}, + DictWord{132, 0, 859}, + DictWord{7, 11, 1046}, + DictWord{139, 11, 160}, + DictWord{137, 0, 842}, + DictWord{ + 139, + 10, + 283, + }, + DictWord{5, 10, 33}, + DictWord{6, 10, 470}, + DictWord{139, 10, 424}, + DictWord{6, 11, 45}, + DictWord{7, 11, 433}, + DictWord{8, 11, 129}, + DictWord{ + 9, + 11, + 21, + }, + DictWord{10, 11, 392}, + DictWord{11, 11, 79}, + DictWord{12, 11, 499}, + DictWord{13, 11, 199}, + DictWord{141, 11, 451}, + DictWord{135, 0, 1291}, + DictWord{135, 10, 1882}, + DictWord{7, 11, 558}, + DictWord{136, 11, 353}, + DictWord{134, 0, 1482}, + DictWord{5, 0, 230}, + DictWord{5, 0, 392}, + DictWord{6, 0, 420}, + DictWord{9, 0, 568}, + DictWord{140, 0, 612}, + DictWord{6, 0, 262}, + DictWord{7, 10, 90}, + DictWord{7, 10, 664}, + DictWord{7, 10, 830}, + DictWord{7, 10, 1380}, + DictWord{ + 7, + 10, + 2025, + }, + DictWord{8, 11, 81}, + DictWord{8, 10, 448}, + DictWord{8, 10, 828}, + DictWord{9, 11, 189}, + DictWord{9, 11, 201}, + DictWord{11, 11, 478}, + DictWord{ + 11, + 11, + 712, + }, + DictWord{141, 11, 338}, + DictWord{142, 0, 31}, + DictWord{5, 11, 353}, + DictWord{151, 11, 26}, + DictWord{132, 0, 753}, + DictWord{4, 0, 0}, + DictWord{ + 5, + 0, + 41, + }, + DictWord{7, 0, 1459}, + DictWord{7, 0, 1469}, + DictWord{7, 0, 1859}, + DictWord{9, 0, 549}, + DictWord{139, 0, 905}, + DictWord{9, 10, 417}, + DictWord{ + 137, + 10, + 493, + }, + DictWord{135, 11, 1113}, + DictWord{133, 0, 696}, + DictWord{141, 11, 448}, + DictWord{134, 10, 295}, + DictWord{132, 0, 834}, + DictWord{4, 0, 771}, + DictWord{5, 10, 1019}, + DictWord{6, 11, 25}, + DictWord{7, 11, 855}, + DictWord{7, 11, 1258}, + DictWord{144, 11, 32}, + DictWord{134, 0, 1076}, + DictWord{133, 0, 921}, + DictWord{133, 0, 674}, + DictWord{4, 11, 4}, + DictWord{7, 11, 1118}, + DictWord{7, 11, 1320}, + DictWord{7, 11, 1706}, + DictWord{8, 11, 277}, + DictWord{9, 11, 622}, + DictWord{10, 11, 9}, + DictWord{11, 11, 724}, + DictWord{12, 11, 350}, + DictWord{12, 11, 397}, + DictWord{13, 11, 28}, + DictWord{13, 11, 159}, + DictWord{15, 11, 89}, + DictWord{18, 11, 5}, + DictWord{19, 11, 9}, + DictWord{20, 11, 34}, + DictWord{150, 11, 47}, + DictWord{134, 10, 208}, + DictWord{6, 0, 444}, + DictWord{136, 0, 308}, + DictWord{ + 6, + 0, + 180, + }, + DictWord{7, 0, 1137}, + DictWord{8, 0, 751}, + DictWord{139, 0, 805}, + DictWord{4, 0, 183}, + DictWord{7, 0, 271}, + DictWord{11, 0, 824}, + DictWord{ + 11, + 0, + 952, + }, + DictWord{13, 0, 278}, + DictWord{13, 0, 339}, + DictWord{13, 0, 482}, + DictWord{14, 0, 424}, + DictWord{148, 0, 99}, + DictWord{7, 11, 317}, + DictWord{ + 135, + 11, + 569, + }, + DictWord{4, 0, 19}, + DictWord{5, 0, 477}, + DictWord{5, 0, 596}, + DictWord{6, 0, 505}, + DictWord{7, 0, 1221}, + DictWord{11, 0, 907}, + DictWord{12, 0, 209}, + DictWord{141, 0, 214}, + DictWord{135, 0, 1215}, + DictWord{6, 0, 271}, + DictWord{7, 0, 398}, + DictWord{8, 0, 387}, + DictWord{10, 0, 344}, + DictWord{7, 10, 448}, + DictWord{ + 7, + 10, + 1629, + }, + DictWord{7, 10, 1813}, + DictWord{8, 10, 442}, + DictWord{9, 10, 710}, + DictWord{10, 10, 282}, + DictWord{138, 10, 722}, + DictWord{11, 10, 844}, + DictWord{12, 10, 104}, + DictWord{140, 10, 625}, + DictWord{134, 11, 255}, + DictWord{133, 10, 787}, + DictWord{134, 0, 1645}, + DictWord{11, 11, 956}, + DictWord{ + 151, + 11, + 3, + }, + DictWord{6, 0, 92}, + DictWord{6, 0, 188}, + DictWord{7, 0, 209}, + DictWord{7, 0, 1269}, + DictWord{7, 0, 1524}, + DictWord{7, 0, 1876}, + DictWord{8, 0, 661}, + DictWord{10, 0, 42}, + DictWord{10, 0, 228}, + DictWord{11, 0, 58}, + DictWord{11, 0, 1020}, + DictWord{12, 0, 58}, + DictWord{12, 0, 118}, + DictWord{141, 0, 32}, + DictWord{ + 4, + 0, + 459, + }, + DictWord{133, 0, 966}, + DictWord{4, 11, 536}, + DictWord{7, 11, 1141}, + DictWord{10, 11, 723}, + DictWord{139, 11, 371}, + DictWord{140, 0, 330}, + DictWord{134, 0, 1557}, + DictWord{7, 11, 285}, + DictWord{135, 11, 876}, + DictWord{136, 10, 491}, + DictWord{135, 11, 560}, + DictWord{6, 0, 18}, + DictWord{7, 0, 179}, + DictWord{7, 0, 932}, + DictWord{8, 0, 548}, + DictWord{8, 0, 757}, + DictWord{9, 0, 54}, + DictWord{9, 0, 65}, + DictWord{9, 0, 532}, + DictWord{9, 0, 844}, + DictWord{10, 0, 113}, + DictWord{10, 0, 117}, + DictWord{10, 0, 315}, + DictWord{10, 0, 560}, + DictWord{10, 0, 622}, + DictWord{10, 0, 798}, + DictWord{11, 0, 153}, + DictWord{11, 0, 351}, + DictWord{ + 11, + 0, + 375, + }, + DictWord{12, 0, 78}, + DictWord{12, 0, 151}, + DictWord{12, 0, 392}, + DictWord{12, 0, 666}, + DictWord{14, 0, 248}, + DictWord{143, 0, 23}, + DictWord{ + 6, + 0, + 1742, + }, + DictWord{132, 11, 690}, + DictWord{4, 10, 403}, + DictWord{5, 10, 441}, + DictWord{7, 10, 450}, + DictWord{10, 10, 840}, + DictWord{11, 10, 101}, + DictWord{ + 12, + 10, + 193, + }, + DictWord{141, 10, 430}, + DictWord{133, 0, 965}, + DictWord{134, 0, 182}, + DictWord{10, 0, 65}, + DictWord{10, 0, 488}, + DictWord{138, 0, 497}, + DictWord{135, 11, 1346}, + DictWord{6, 0, 973}, + DictWord{6, 0, 1158}, + DictWord{10, 11, 200}, + DictWord{19, 11, 2}, + DictWord{151, 11, 22}, + DictWord{4, 11, 190}, + DictWord{133, 11, 554}, + DictWord{133, 10, 679}, + DictWord{7, 0, 328}, + DictWord{137, 10, 326}, + DictWord{133, 11, 1001}, + DictWord{9, 0, 588}, + DictWord{ + 138, + 0, + 260, + }, + DictWord{133, 11, 446}, + DictWord{135, 10, 1128}, + DictWord{135, 10, 1796}, + DictWord{147, 11, 119}, + DictWord{134, 0, 1786}, + DictWord{ + 6, + 0, + 1328, + }, + DictWord{6, 0, 1985}, + DictWord{8, 0, 962}, + DictWord{138, 0, 1017}, + DictWord{135, 0, 308}, + DictWord{11, 0, 508}, + DictWord{4, 10, 574}, + DictWord{ + 7, + 10, + 350, + }, + DictWord{7, 10, 1024}, + DictWord{8, 10, 338}, + DictWord{9, 10, 677}, + DictWord{138, 10, 808}, + DictWord{138, 11, 752}, + DictWord{135, 10, 1081}, + DictWord{137, 11, 96}, + DictWord{7, 10, 1676}, + DictWord{135, 10, 2037}, + DictWord{136, 0, 588}, + DictWord{132, 11, 304}, + DictWord{133, 0, 614}, + DictWord{ + 140, + 0, + 793, + }, + DictWord{136, 0, 287}, + DictWord{137, 10, 297}, + DictWord{141, 10, 37}, + DictWord{6, 11, 53}, + DictWord{6, 11, 199}, + DictWord{7, 11, 1408}, + DictWord{ + 8, + 11, + 32, + }, + DictWord{8, 11, 93}, + DictWord{9, 11, 437}, + DictWord{10, 11, 397}, + DictWord{10, 11, 629}, + DictWord{11, 11, 593}, + DictWord{11, 11, 763}, + DictWord{ + 13, + 11, + 326, + }, + DictWord{145, 11, 35}, + DictWord{134, 11, 105}, + DictWord{9, 11, 320}, + DictWord{10, 11, 506}, + DictWord{138, 11, 794}, + DictWord{5, 11, 114}, + DictWord{5, 11, 255}, + DictWord{141, 11, 285}, + DictWord{140, 0, 290}, + DictWord{7, 11, 2035}, + DictWord{8, 11, 19}, + DictWord{9, 11, 89}, + DictWord{138, 11, 831}, + DictWord{134, 0, 1136}, + DictWord{7, 0, 719}, + DictWord{8, 0, 796}, + DictWord{8, 0, 809}, + DictWord{8, 0, 834}, + DictWord{6, 10, 306}, + DictWord{7, 10, 1140}, + DictWord{ + 7, + 10, + 1340, + }, + DictWord{8, 10, 133}, + DictWord{138, 10, 449}, + DictWord{139, 10, 1011}, + DictWord{5, 0, 210}, + DictWord{6, 0, 213}, + DictWord{7, 0, 60}, + DictWord{ + 10, + 0, + 364, + }, + DictWord{139, 0, 135}, + DictWord{5, 0, 607}, + DictWord{8, 0, 326}, + DictWord{136, 0, 490}, + DictWord{138, 11, 176}, + DictWord{132, 0, 701}, + DictWord{ + 5, + 0, + 472, + }, + DictWord{7, 0, 380}, + DictWord{137, 0, 758}, + DictWord{135, 0, 1947}, + DictWord{6, 0, 1079}, + DictWord{138, 0, 278}, + DictWord{138, 11, 391}, + DictWord{ + 5, + 10, + 329, + }, + DictWord{8, 10, 260}, + DictWord{139, 11, 156}, + DictWord{4, 0, 386}, + DictWord{7, 0, 41}, + DictWord{8, 0, 405}, + DictWord{8, 0, 728}, + DictWord{9, 0, 497}, + DictWord{11, 0, 110}, + DictWord{11, 0, 360}, + DictWord{15, 0, 37}, + DictWord{144, 0, 84}, + DictWord{5, 0, 46}, + DictWord{7, 0, 1452}, + DictWord{7, 0, 1480}, + DictWord{ + 8, + 0, + 634, + }, + DictWord{140, 0, 472}, + DictWord{136, 0, 961}, + DictWord{4, 0, 524}, + DictWord{136, 0, 810}, + DictWord{10, 0, 238}, + DictWord{141, 0, 33}, + DictWord{ + 132, + 10, + 657, + }, + DictWord{152, 10, 7}, + DictWord{133, 0, 532}, + DictWord{5, 0, 997}, + DictWord{135, 10, 1665}, + DictWord{7, 11, 594}, + DictWord{7, 11, 851}, + DictWord{ + 7, + 11, + 1858, + }, + DictWord{9, 11, 411}, + DictWord{9, 11, 574}, + DictWord{9, 11, 666}, + DictWord{9, 11, 737}, + DictWord{10, 11, 346}, + DictWord{10, 11, 712}, + DictWord{ + 11, + 11, + 246, + }, + DictWord{11, 11, 432}, + DictWord{11, 11, 517}, + DictWord{11, 11, 647}, + DictWord{11, 11, 679}, + DictWord{11, 11, 727}, + DictWord{12, 11, 304}, + DictWord{12, 11, 305}, + DictWord{12, 11, 323}, + DictWord{12, 11, 483}, + DictWord{12, 11, 572}, + DictWord{12, 11, 593}, + DictWord{12, 11, 602}, + DictWord{ + 13, + 11, + 95, + }, + DictWord{13, 11, 101}, + DictWord{13, 11, 171}, + DictWord{13, 11, 315}, + DictWord{13, 11, 378}, + DictWord{13, 11, 425}, + DictWord{13, 11, 475}, + DictWord{ + 14, + 11, + 63, + }, + DictWord{14, 11, 380}, + DictWord{14, 11, 384}, + DictWord{15, 11, 133}, + DictWord{18, 11, 112}, + DictWord{148, 11, 72}, + DictWord{5, 11, 955}, + DictWord{136, 11, 814}, + DictWord{134, 0, 1301}, + DictWord{5, 10, 66}, + DictWord{7, 10, 1896}, + DictWord{136, 10, 288}, + DictWord{133, 11, 56}, + DictWord{ + 134, + 10, + 1643, + }, + DictWord{6, 0, 1298}, + DictWord{148, 11, 100}, + DictWord{5, 0, 782}, + DictWord{5, 0, 829}, + DictWord{6, 0, 671}, + DictWord{6, 0, 1156}, + DictWord{6, 0, 1738}, + DictWord{137, 11, 621}, + DictWord{4, 0, 306}, + DictWord{5, 0, 570}, + DictWord{7, 0, 1347}, + DictWord{5, 10, 91}, + DictWord{5, 10, 648}, + DictWord{5, 10, 750}, + DictWord{ + 5, + 10, + 781, + }, + DictWord{6, 10, 54}, + DictWord{6, 10, 112}, + DictWord{6, 10, 402}, + DictWord{6, 10, 1732}, + DictWord{7, 10, 315}, + DictWord{7, 10, 749}, + DictWord{ + 7, + 10, + 1900, + }, + DictWord{9, 10, 78}, + DictWord{9, 10, 508}, + DictWord{10, 10, 611}, + DictWord{10, 10, 811}, + DictWord{11, 10, 510}, + DictWord{11, 10, 728}, + DictWord{ + 13, + 10, + 36, + }, + DictWord{14, 10, 39}, + DictWord{16, 10, 83}, + DictWord{17, 10, 124}, + DictWord{148, 10, 30}, + DictWord{8, 10, 570}, + DictWord{9, 11, 477}, + DictWord{ + 141, + 11, + 78, + }, + DictWord{4, 11, 639}, + DictWord{10, 11, 4}, + DictWord{10, 10, 322}, + DictWord{10, 10, 719}, + DictWord{11, 10, 407}, + DictWord{11, 11, 638}, + DictWord{ + 12, + 11, + 177, + }, + DictWord{148, 11, 57}, + DictWord{7, 0, 1823}, + DictWord{139, 0, 693}, + DictWord{7, 0, 759}, + DictWord{5, 11, 758}, + DictWord{8, 10, 125}, + DictWord{ + 8, + 10, + 369, + }, + DictWord{8, 10, 524}, + DictWord{10, 10, 486}, + DictWord{11, 10, 13}, + DictWord{11, 10, 381}, + DictWord{11, 10, 736}, + DictWord{11, 10, 766}, + DictWord{ + 11, + 10, + 845, + }, + DictWord{13, 10, 114}, + DictWord{13, 10, 292}, + DictWord{142, 10, 47}, + DictWord{7, 0, 1932}, + DictWord{6, 10, 1684}, + DictWord{6, 10, 1731}, + DictWord{7, 10, 356}, + DictWord{8, 10, 54}, + DictWord{8, 10, 221}, + DictWord{9, 10, 225}, + DictWord{9, 10, 356}, + DictWord{10, 10, 77}, + DictWord{10, 10, 446}, + DictWord{ + 10, + 10, + 731, + }, + DictWord{12, 10, 404}, + DictWord{141, 10, 491}, + DictWord{135, 11, 552}, + DictWord{135, 11, 1112}, + DictWord{4, 0, 78}, + DictWord{5, 0, 96}, + DictWord{ + 5, + 0, + 182, + }, + DictWord{6, 0, 1257}, + DictWord{7, 0, 1724}, + DictWord{7, 0, 1825}, + DictWord{10, 0, 394}, + DictWord{10, 0, 471}, + DictWord{11, 0, 532}, + DictWord{ + 14, + 0, + 340, + }, + DictWord{145, 0, 88}, + DictWord{139, 11, 328}, + DictWord{135, 0, 1964}, + DictWord{132, 10, 411}, + DictWord{4, 10, 80}, + DictWord{5, 10, 44}, + DictWord{ + 137, + 11, + 133, + }, + DictWord{5, 11, 110}, + DictWord{6, 11, 169}, + DictWord{6, 11, 1702}, + DictWord{7, 11, 400}, + DictWord{8, 11, 538}, + DictWord{9, 11, 184}, + DictWord{ + 9, + 11, + 524, + }, + DictWord{140, 11, 218}, + DictWord{4, 0, 521}, + DictWord{5, 10, 299}, + DictWord{7, 10, 1083}, + DictWord{140, 11, 554}, + DictWord{6, 11, 133}, + DictWord{ + 9, + 11, + 353, + }, + DictWord{12, 11, 628}, + DictWord{146, 11, 79}, + DictWord{6, 0, 215}, + DictWord{7, 0, 584}, + DictWord{7, 0, 1028}, + DictWord{7, 0, 1473}, + DictWord{ + 7, + 0, + 1721, + }, + DictWord{9, 0, 424}, + DictWord{138, 0, 779}, + DictWord{7, 0, 857}, + DictWord{7, 0, 1209}, + DictWord{7, 10, 1713}, + DictWord{9, 10, 537}, + DictWord{ + 10, + 10, + 165, + }, + DictWord{12, 10, 219}, + DictWord{140, 10, 561}, + DictWord{4, 10, 219}, + DictWord{6, 11, 93}, + DictWord{7, 11, 1422}, + DictWord{7, 10, 1761}, + DictWord{ + 7, + 11, + 1851, + }, + DictWord{8, 11, 673}, + DictWord{9, 10, 86}, + DictWord{9, 11, 529}, + DictWord{140, 11, 43}, + DictWord{137, 11, 371}, + DictWord{136, 0, 671}, + DictWord{ + 5, + 0, + 328, + }, + DictWord{135, 0, 918}, + DictWord{132, 0, 529}, + DictWord{9, 11, 25}, + DictWord{10, 11, 467}, + DictWord{138, 11, 559}, + DictWord{4, 11, 335}, + DictWord{ + 135, + 11, + 942, + }, + DictWord{134, 0, 716}, + DictWord{134, 0, 1509}, + DictWord{6, 0, 67}, + DictWord{7, 0, 258}, + DictWord{7, 0, 1630}, + DictWord{9, 0, 354}, + DictWord{ + 9, + 0, + 675, + }, + DictWord{10, 0, 830}, + DictWord{14, 0, 80}, + DictWord{17, 0, 80}, + DictWord{140, 10, 428}, + DictWord{134, 0, 1112}, + DictWord{6, 0, 141}, + DictWord{7, 0, 225}, + DictWord{9, 0, 59}, + DictWord{9, 0, 607}, + DictWord{10, 0, 312}, + DictWord{11, 0, 687}, + DictWord{12, 0, 555}, + DictWord{13, 0, 373}, + DictWord{13, 0, 494}, + DictWord{ + 148, + 0, + 58, + }, + DictWord{133, 10, 514}, + DictWord{8, 11, 39}, + DictWord{10, 11, 773}, + DictWord{11, 11, 84}, + DictWord{12, 11, 205}, + DictWord{142, 11, 1}, + DictWord{ + 8, + 0, + 783, + }, + DictWord{5, 11, 601}, + DictWord{133, 11, 870}, + DictWord{136, 11, 594}, + DictWord{4, 10, 55}, + DictWord{5, 10, 301}, + DictWord{6, 10, 571}, + DictWord{ + 14, + 10, + 49, + }, + DictWord{146, 10, 102}, + DictWord{132, 11, 181}, + DictWord{134, 11, 1652}, + DictWord{133, 10, 364}, + DictWord{4, 11, 97}, + DictWord{5, 11, 147}, + DictWord{6, 11, 286}, + DictWord{7, 11, 1362}, + DictWord{141, 11, 176}, + DictWord{4, 10, 76}, + DictWord{7, 10, 1550}, + DictWord{9, 10, 306}, + DictWord{9, 10, 430}, + DictWord{9, 10, 663}, + DictWord{10, 10, 683}, + DictWord{11, 10, 427}, + DictWord{11, 10, 753}, + DictWord{12, 10, 334}, + DictWord{12, 10, 442}, + DictWord{ + 14, + 10, + 258, + }, + DictWord{14, 10, 366}, + DictWord{143, 10, 131}, + DictWord{137, 10, 52}, + DictWord{6, 0, 955}, + DictWord{134, 0, 1498}, + DictWord{6, 11, 375}, + DictWord{ + 7, + 11, + 169, + }, + DictWord{7, 11, 254}, + DictWord{136, 11, 780}, + DictWord{7, 0, 430}, + DictWord{11, 0, 46}, + DictWord{14, 0, 343}, + DictWord{142, 11, 343}, + DictWord{ + 135, + 0, + 1183, + }, + DictWord{5, 0, 602}, + DictWord{7, 0, 2018}, + DictWord{9, 0, 418}, + DictWord{9, 0, 803}, + DictWord{135, 11, 1447}, + DictWord{8, 0, 677}, + DictWord{ + 135, + 11, + 1044, + }, + DictWord{139, 11, 285}, + DictWord{4, 10, 656}, + DictWord{135, 10, 779}, + DictWord{135, 10, 144}, + DictWord{5, 11, 629}, + DictWord{ + 135, + 11, + 1549, + }, + DictWord{135, 10, 1373}, + DictWord{138, 11, 209}, + DictWord{7, 10, 554}, + DictWord{7, 10, 605}, + DictWord{141, 10, 10}, + DictWord{5, 10, 838}, + DictWord{ + 5, + 10, + 841, + }, + DictWord{134, 10, 1649}, + DictWord{133, 10, 1012}, + DictWord{6, 0, 1357}, + DictWord{134, 0, 1380}, + DictWord{144, 0, 53}, + DictWord{6, 0, 590}, + DictWord{7, 10, 365}, + DictWord{7, 10, 1357}, + DictWord{7, 10, 1497}, + DictWord{8, 10, 154}, + DictWord{141, 10, 281}, + DictWord{133, 10, 340}, + DictWord{ + 132, + 11, + 420, + }, + DictWord{135, 0, 329}, + DictWord{147, 11, 32}, + DictWord{4, 0, 469}, + DictWord{10, 11, 429}, + DictWord{139, 10, 495}, + DictWord{8, 10, 261}, + DictWord{ + 9, + 10, + 144, + }, + DictWord{9, 10, 466}, + DictWord{10, 10, 370}, + DictWord{12, 10, 470}, + DictWord{13, 10, 144}, + DictWord{142, 10, 348}, + DictWord{142, 0, 460}, + DictWord{4, 11, 325}, + DictWord{9, 10, 897}, + DictWord{138, 11, 125}, + DictWord{6, 0, 1743}, + DictWord{6, 10, 248}, + DictWord{9, 10, 546}, + DictWord{10, 10, 535}, + DictWord{11, 10, 681}, + DictWord{141, 10, 135}, + DictWord{4, 0, 990}, + DictWord{5, 0, 929}, + DictWord{6, 0, 340}, + DictWord{8, 0, 376}, + DictWord{8, 0, 807}, + DictWord{ + 8, + 0, + 963, + }, + DictWord{8, 0, 980}, + DictWord{138, 0, 1007}, + DictWord{134, 0, 1603}, + DictWord{140, 0, 250}, + DictWord{4, 11, 714}, + DictWord{133, 11, 469}, + DictWord{134, 10, 567}, + DictWord{136, 10, 445}, + DictWord{5, 0, 218}, + DictWord{7, 0, 1610}, + DictWord{8, 0, 646}, + DictWord{10, 0, 83}, + DictWord{11, 11, 138}, + DictWord{140, 11, 40}, + DictWord{7, 0, 1512}, + DictWord{135, 0, 1794}, + DictWord{135, 11, 1216}, + DictWord{11, 0, 0}, + DictWord{16, 0, 78}, + DictWord{132, 11, 718}, + DictWord{133, 0, 571}, + DictWord{132, 0, 455}, + DictWord{134, 0, 1012}, + DictWord{5, 11, 124}, + DictWord{5, 11, 144}, + DictWord{6, 11, 548}, + DictWord{7, 11, 15}, + DictWord{7, 11, 153}, + DictWord{137, 11, 629}, + DictWord{142, 11, 10}, + DictWord{6, 11, 75}, + DictWord{7, 11, 1531}, + DictWord{8, 11, 416}, + DictWord{9, 11, 240}, + DictWord{9, 11, 275}, + DictWord{10, 11, 100}, + DictWord{11, 11, 658}, + DictWord{11, 11, 979}, + DictWord{12, 11, 86}, + DictWord{13, 11, 468}, + DictWord{14, 11, 66}, + DictWord{14, 11, 207}, + DictWord{15, 11, 20}, + DictWord{15, 11, 25}, + DictWord{144, 11, 58}, + DictWord{132, 10, 577}, + DictWord{5, 11, 141}, + DictWord{ + 5, + 11, + 915, + }, + DictWord{6, 11, 1783}, + DictWord{7, 11, 211}, + DictWord{7, 11, 698}, + DictWord{7, 11, 1353}, + DictWord{9, 11, 83}, + DictWord{9, 11, 281}, + DictWord{ + 10, + 11, + 376, + }, + DictWord{10, 11, 431}, + DictWord{11, 11, 543}, + DictWord{12, 11, 664}, + DictWord{13, 11, 280}, + DictWord{13, 11, 428}, + DictWord{14, 11, 61}, + DictWord{ + 14, + 11, + 128, + }, + DictWord{17, 11, 52}, + DictWord{145, 11, 81}, + DictWord{6, 0, 161}, + DictWord{7, 0, 372}, + DictWord{137, 0, 597}, + DictWord{132, 0, 349}, + DictWord{ + 10, + 11, + 702, + }, + DictWord{139, 11, 245}, + DictWord{134, 0, 524}, + DictWord{134, 10, 174}, + DictWord{6, 0, 432}, + DictWord{9, 0, 751}, + DictWord{139, 0, 322}, + DictWord{147, 11, 94}, + DictWord{4, 11, 338}, + DictWord{133, 11, 400}, + DictWord{5, 0, 468}, + DictWord{10, 0, 325}, + DictWord{11, 0, 856}, + DictWord{12, 0, 345}, + DictWord{143, 0, 104}, + DictWord{133, 0, 223}, + DictWord{132, 0, 566}, + DictWord{4, 11, 221}, + DictWord{5, 11, 659}, + DictWord{5, 11, 989}, + DictWord{7, 11, 697}, + DictWord{7, 11, 1211}, + DictWord{138, 11, 284}, + DictWord{135, 11, 1070}, + DictWord{4, 0, 59}, + DictWord{135, 0, 1394}, + DictWord{6, 0, 436}, + DictWord{11, 0, 481}, + DictWord{5, 10, 878}, + DictWord{133, 10, 972}, + DictWord{4, 0, 48}, + DictWord{5, 0, 271}, + DictWord{135, 0, 953}, + DictWord{5, 0, 610}, + DictWord{136, 0, 457}, + DictWord{ + 4, + 0, + 773, + }, + DictWord{5, 0, 618}, + DictWord{137, 0, 756}, + DictWord{133, 0, 755}, + DictWord{135, 0, 1217}, + DictWord{138, 11, 507}, + DictWord{132, 10, 351}, + DictWord{132, 0, 197}, + DictWord{143, 11, 78}, + DictWord{4, 11, 188}, + DictWord{7, 11, 805}, + DictWord{11, 11, 276}, + DictWord{142, 11, 293}, + DictWord{ + 5, + 11, + 884, + }, + DictWord{139, 11, 991}, + DictWord{132, 10, 286}, + DictWord{10, 0, 259}, + DictWord{10, 0, 428}, + DictWord{7, 10, 438}, + DictWord{7, 10, 627}, + DictWord{ + 7, + 10, + 1516, + }, + DictWord{8, 10, 40}, + DictWord{9, 10, 56}, + DictWord{9, 10, 294}, + DictWord{11, 10, 969}, + DictWord{11, 10, 995}, + DictWord{146, 10, 148}, + DictWord{ + 4, + 0, + 356, + }, + DictWord{5, 0, 217}, + DictWord{5, 0, 492}, + DictWord{5, 0, 656}, + DictWord{8, 0, 544}, + DictWord{136, 11, 544}, + DictWord{5, 0, 259}, + DictWord{6, 0, 1230}, + DictWord{7, 0, 414}, + DictWord{7, 0, 854}, + DictWord{142, 0, 107}, + DictWord{132, 0, 1007}, + DictWord{15, 0, 14}, + DictWord{144, 0, 5}, + DictWord{6, 0, 1580}, + DictWord{ + 132, + 10, + 738, + }, + DictWord{132, 11, 596}, + DictWord{132, 0, 673}, + DictWord{133, 10, 866}, + DictWord{6, 0, 1843}, + DictWord{135, 11, 1847}, + DictWord{4, 0, 165}, + DictWord{7, 0, 1398}, + DictWord{135, 0, 1829}, + DictWord{135, 11, 1634}, + DictWord{147, 11, 65}, + DictWord{6, 0, 885}, + DictWord{6, 0, 1009}, + DictWord{ + 137, + 0, + 809, + }, + DictWord{133, 10, 116}, + DictWord{132, 10, 457}, + DictWord{136, 11, 770}, + DictWord{9, 0, 498}, + DictWord{12, 0, 181}, + DictWord{10, 11, 361}, + DictWord{142, 11, 316}, + DictWord{134, 11, 595}, + DictWord{5, 0, 9}, + DictWord{7, 0, 297}, + DictWord{7, 0, 966}, + DictWord{140, 0, 306}, + DictWord{4, 11, 89}, + DictWord{ + 5, + 11, + 489, + }, + DictWord{6, 11, 315}, + DictWord{7, 11, 553}, + DictWord{7, 11, 1745}, + DictWord{138, 11, 243}, + DictWord{134, 0, 1487}, + DictWord{132, 0, 437}, + DictWord{ + 5, + 0, + 146, + }, + DictWord{6, 0, 411}, + DictWord{138, 0, 721}, + DictWord{5, 10, 527}, + DictWord{6, 10, 189}, + DictWord{135, 10, 859}, + DictWord{11, 10, 104}, + DictWord{ + 11, + 10, + 554, + }, + DictWord{15, 10, 60}, + DictWord{143, 10, 125}, + DictWord{6, 11, 1658}, + DictWord{9, 11, 3}, + DictWord{10, 11, 154}, + DictWord{11, 11, 641}, + DictWord{13, 11, 85}, + DictWord{13, 11, 201}, + DictWord{141, 11, 346}, + DictWord{6, 0, 177}, + DictWord{135, 0, 467}, + DictWord{134, 0, 1377}, + DictWord{ + 134, + 10, + 116, + }, + DictWord{136, 11, 645}, + DictWord{4, 11, 166}, + DictWord{5, 11, 505}, + DictWord{6, 11, 1670}, + DictWord{137, 11, 110}, + DictWord{133, 10, 487}, + DictWord{ + 4, + 10, + 86, + }, + DictWord{5, 10, 667}, + DictWord{5, 10, 753}, + DictWord{6, 10, 316}, + DictWord{6, 10, 455}, + DictWord{135, 10, 946}, + DictWord{133, 0, 200}, + DictWord{132, 0, 959}, + DictWord{6, 0, 1928}, + DictWord{134, 0, 1957}, + DictWord{139, 11, 203}, + DictWord{150, 10, 45}, + DictWord{4, 10, 79}, + DictWord{7, 10, 1773}, + DictWord{10, 10, 450}, + DictWord{11, 10, 589}, + DictWord{13, 10, 332}, + DictWord{13, 10, 493}, + DictWord{14, 10, 183}, + DictWord{14, 10, 334}, + DictWord{ + 14, + 10, + 362, + }, + DictWord{14, 10, 368}, + DictWord{14, 10, 376}, + DictWord{14, 10, 379}, + DictWord{19, 10, 90}, + DictWord{19, 10, 103}, + DictWord{19, 10, 127}, + DictWord{148, 10, 90}, + DictWord{6, 0, 1435}, + DictWord{135, 11, 1275}, + DictWord{134, 0, 481}, + DictWord{7, 11, 445}, + DictWord{8, 11, 307}, + DictWord{8, 11, 704}, + DictWord{10, 11, 41}, + DictWord{10, 11, 439}, + DictWord{11, 11, 237}, + DictWord{11, 11, 622}, + DictWord{140, 11, 201}, + DictWord{135, 11, 869}, + DictWord{ + 4, + 0, + 84, + }, + DictWord{7, 0, 1482}, + DictWord{10, 0, 76}, + DictWord{138, 0, 142}, + DictWord{11, 11, 277}, + DictWord{144, 11, 14}, + DictWord{135, 11, 1977}, + DictWord{ + 4, + 11, + 189, + }, + DictWord{5, 11, 713}, + DictWord{136, 11, 57}, + DictWord{133, 0, 1015}, + DictWord{138, 11, 371}, + DictWord{4, 0, 315}, + DictWord{5, 0, 507}, + DictWord{ + 135, + 0, + 1370, + }, + DictWord{4, 11, 552}, + DictWord{142, 10, 381}, + DictWord{9, 0, 759}, + DictWord{16, 0, 31}, + DictWord{16, 0, 39}, + DictWord{16, 0, 75}, + DictWord{18, 0, 24}, + DictWord{20, 0, 42}, + DictWord{152, 0, 1}, + DictWord{134, 0, 712}, + DictWord{134, 0, 1722}, + DictWord{133, 10, 663}, + DictWord{133, 10, 846}, + DictWord{ + 8, + 0, + 222, + }, + DictWord{8, 0, 476}, + DictWord{9, 0, 238}, + DictWord{11, 0, 516}, + DictWord{11, 0, 575}, + DictWord{15, 0, 109}, + DictWord{146, 0, 100}, + DictWord{7, 0, 1402}, + DictWord{7, 0, 1414}, + DictWord{12, 0, 456}, + DictWord{5, 10, 378}, + DictWord{8, 10, 465}, + DictWord{9, 10, 286}, + DictWord{10, 10, 185}, + DictWord{10, 10, 562}, + DictWord{10, 10, 635}, + DictWord{11, 10, 31}, + DictWord{11, 10, 393}, + DictWord{13, 10, 312}, + DictWord{18, 10, 65}, + DictWord{18, 10, 96}, + DictWord{147, 10, 89}, + DictWord{4, 0, 986}, + DictWord{6, 0, 1958}, + DictWord{6, 0, 2032}, + DictWord{8, 0, 934}, + DictWord{138, 0, 985}, + DictWord{7, 10, 1880}, + DictWord{9, 10, 680}, + DictWord{139, 10, 798}, + DictWord{134, 10, 1770}, + DictWord{145, 11, 49}, + DictWord{132, 11, 614}, + DictWord{132, 10, 648}, + DictWord{5, 10, 945}, + DictWord{ + 6, + 10, + 1656, + }, + DictWord{6, 10, 1787}, + DictWord{7, 10, 167}, + DictWord{8, 10, 824}, + DictWord{9, 10, 391}, + DictWord{10, 10, 375}, + DictWord{139, 10, 185}, + DictWord{138, 11, 661}, + DictWord{7, 0, 1273}, + DictWord{135, 11, 1945}, + DictWord{7, 0, 706}, + DictWord{7, 0, 1058}, + DictWord{138, 0, 538}, + DictWord{7, 10, 1645}, + DictWord{8, 10, 352}, + DictWord{137, 10, 249}, + DictWord{132, 10, 152}, + DictWord{11, 0, 92}, + DictWord{11, 0, 196}, + DictWord{11, 0, 409}, + DictWord{11, 0, 450}, + DictWord{11, 0, 666}, + DictWord{11, 0, 777}, + DictWord{12, 0, 262}, + DictWord{13, 0, 385}, + DictWord{13, 0, 393}, + DictWord{15, 0, 115}, + DictWord{16, 0, 45}, + DictWord{145, 0, 82}, + DictWord{133, 10, 1006}, + DictWord{6, 0, 40}, + DictWord{135, 0, 1781}, + DictWord{9, 11, 614}, + DictWord{139, 11, 327}, + DictWord{5, 10, 420}, + DictWord{135, 10, 1449}, + DictWord{135, 0, 431}, + DictWord{10, 0, 97}, + DictWord{135, 10, 832}, + DictWord{6, 0, 423}, + DictWord{7, 0, 665}, + DictWord{ + 135, + 0, + 1210, + }, + DictWord{7, 0, 237}, + DictWord{8, 0, 664}, + DictWord{9, 0, 42}, + DictWord{9, 0, 266}, + DictWord{9, 0, 380}, + DictWord{9, 0, 645}, + DictWord{10, 0, 177}, + DictWord{ + 138, + 0, + 276, + }, + DictWord{7, 0, 264}, + DictWord{133, 10, 351}, + DictWord{8, 0, 213}, + DictWord{5, 10, 40}, + DictWord{7, 10, 598}, + DictWord{7, 10, 1638}, + DictWord{ + 9, + 10, + 166, + }, + DictWord{9, 10, 640}, + DictWord{9, 10, 685}, + DictWord{9, 10, 773}, + DictWord{11, 10, 215}, + DictWord{13, 10, 65}, + DictWord{14, 10, 172}, + DictWord{ + 14, + 10, + 317, + }, + DictWord{145, 10, 6}, + DictWord{5, 11, 84}, + DictWord{134, 11, 163}, + DictWord{8, 10, 60}, + DictWord{9, 10, 343}, + DictWord{139, 10, 769}, + DictWord{ + 137, + 0, + 455, + }, + DictWord{133, 11, 410}, + DictWord{8, 0, 906}, + DictWord{12, 0, 700}, + DictWord{12, 0, 706}, + DictWord{140, 0, 729}, + DictWord{21, 11, 33}, + DictWord{ + 150, + 11, + 40, + }, + DictWord{7, 10, 1951}, + DictWord{8, 10, 765}, + DictWord{8, 10, 772}, + DictWord{140, 10, 671}, + DictWord{7, 10, 108}, + DictWord{8, 10, 219}, + DictWord{ + 8, + 10, + 388, + }, + DictWord{9, 10, 639}, + DictWord{9, 10, 775}, + DictWord{11, 10, 275}, + DictWord{140, 10, 464}, + DictWord{5, 11, 322}, + DictWord{7, 11, 1941}, + DictWord{ + 8, + 11, + 186, + }, + DictWord{9, 11, 262}, + DictWord{10, 11, 187}, + DictWord{14, 11, 208}, + DictWord{146, 11, 130}, + DictWord{139, 0, 624}, + DictWord{8, 0, 574}, + DictWord{ + 5, + 11, + 227, + }, + DictWord{140, 11, 29}, + DictWord{7, 11, 1546}, + DictWord{11, 11, 299}, + DictWord{142, 11, 407}, + DictWord{5, 10, 15}, + DictWord{6, 10, 56}, + DictWord{ + 7, + 10, + 1758, + }, + DictWord{8, 10, 500}, + DictWord{9, 10, 730}, + DictWord{11, 10, 331}, + DictWord{13, 10, 150}, + DictWord{142, 10, 282}, + DictWord{7, 11, 1395}, + DictWord{8, 11, 486}, + DictWord{9, 11, 236}, + DictWord{9, 11, 878}, + DictWord{10, 11, 218}, + DictWord{11, 11, 95}, + DictWord{19, 11, 17}, + DictWord{147, 11, 31}, + DictWord{135, 11, 2043}, + DictWord{4, 0, 354}, + DictWord{146, 11, 4}, + DictWord{140, 11, 80}, + DictWord{135, 0, 1558}, + DictWord{134, 10, 1886}, + DictWord{ + 5, + 10, + 205, + }, + DictWord{6, 10, 438}, + DictWord{137, 10, 711}, + DictWord{133, 11, 522}, + DictWord{133, 10, 534}, + DictWord{7, 0, 235}, + DictWord{7, 0, 1475}, + DictWord{ + 15, + 0, + 68, + }, + DictWord{146, 0, 120}, + DictWord{137, 10, 691}, + DictWord{4, 0, 942}, + DictWord{6, 0, 1813}, + DictWord{8, 0, 917}, + DictWord{10, 0, 884}, + DictWord{ + 12, + 0, + 696, + }, + DictWord{12, 0, 717}, + DictWord{12, 0, 723}, + DictWord{12, 0, 738}, + DictWord{12, 0, 749}, + DictWord{12, 0, 780}, + DictWord{16, 0, 97}, + DictWord{146, 0, 169}, + DictWord{6, 10, 443}, + DictWord{8, 11, 562}, + DictWord{9, 10, 237}, + DictWord{9, 10, 571}, + DictWord{9, 10, 695}, + DictWord{10, 10, 139}, + DictWord{11, 10, 715}, + DictWord{12, 10, 417}, + DictWord{141, 10, 421}, + DictWord{135, 0, 957}, + DictWord{133, 0, 830}, + DictWord{134, 11, 1771}, + DictWord{146, 0, 23}, + DictWord{ + 5, + 0, + 496, + }, + DictWord{6, 0, 694}, + DictWord{7, 0, 203}, + DictWord{7, 11, 1190}, + DictWord{137, 11, 620}, + DictWord{137, 11, 132}, + DictWord{6, 0, 547}, + DictWord{ + 134, + 0, + 1549, + }, + DictWord{8, 11, 258}, + DictWord{9, 11, 208}, + DictWord{137, 11, 359}, + DictWord{4, 0, 864}, + DictWord{5, 0, 88}, + DictWord{137, 0, 239}, + DictWord{ + 135, + 11, + 493, + }, + DictWord{4, 11, 317}, + DictWord{135, 11, 1279}, + DictWord{132, 11, 477}, + DictWord{4, 10, 578}, + DictWord{5, 11, 63}, + DictWord{133, 11, 509}, + DictWord{ + 7, + 0, + 650, + }, + DictWord{135, 0, 1310}, + DictWord{7, 0, 1076}, + DictWord{9, 0, 80}, + DictWord{11, 0, 78}, + DictWord{11, 0, 421}, + DictWord{11, 0, 534}, + DictWord{ + 140, + 0, + 545, + }, + DictWord{132, 11, 288}, + DictWord{12, 0, 553}, + DictWord{14, 0, 118}, + DictWord{133, 10, 923}, + DictWord{7, 0, 274}, + DictWord{11, 0, 479}, + DictWord{ + 139, + 0, + 507, + }, + DictWord{8, 11, 89}, + DictWord{8, 11, 620}, + DictWord{9, 11, 49}, + DictWord{10, 11, 774}, + DictWord{11, 11, 628}, + DictWord{12, 11, 322}, + DictWord{ + 143, + 11, + 124, + }, + DictWord{4, 0, 497}, + DictWord{135, 0, 1584}, + DictWord{7, 0, 261}, + DictWord{7, 0, 1115}, + DictWord{7, 0, 1354}, + DictWord{7, 0, 1404}, + DictWord{ + 7, + 0, + 1588, + }, + DictWord{7, 0, 1705}, + DictWord{7, 0, 1902}, + DictWord{9, 0, 465}, + DictWord{10, 0, 248}, + DictWord{10, 0, 349}, + DictWord{10, 0, 647}, + DictWord{11, 0, 527}, + DictWord{11, 0, 660}, + DictWord{11, 0, 669}, + DictWord{12, 0, 529}, + DictWord{13, 0, 305}, + DictWord{132, 10, 924}, + DictWord{133, 10, 665}, + DictWord{ + 136, + 0, + 13, + }, + DictWord{6, 0, 791}, + DictWord{138, 11, 120}, + DictWord{7, 0, 642}, + DictWord{8, 0, 250}, + DictWord{11, 0, 123}, + DictWord{11, 0, 137}, + DictWord{13, 0, 48}, + DictWord{142, 0, 95}, + DictWord{4, 10, 265}, + DictWord{7, 10, 807}, + DictWord{135, 10, 950}, + DictWord{5, 10, 93}, + DictWord{140, 10, 267}, + DictWord{135, 0, 1429}, + DictWord{4, 0, 949}, + DictWord{10, 0, 885}, + DictWord{10, 0, 891}, + DictWord{10, 0, 900}, + DictWord{10, 0, 939}, + DictWord{12, 0, 760}, + DictWord{142, 0, 449}, + DictWord{139, 11, 366}, + DictWord{132, 0, 818}, + DictWord{134, 11, 85}, + DictWord{135, 10, 994}, + DictWord{7, 0, 330}, + DictWord{5, 10, 233}, + DictWord{5, 10, 320}, + DictWord{6, 10, 140}, + DictWord{136, 10, 295}, + DictWord{4, 0, 1004}, + DictWord{8, 0, 982}, + DictWord{136, 0, 993}, + DictWord{133, 10, 978}, + DictWord{4, 10, 905}, + DictWord{6, 10, 1701}, + DictWord{137, 10, 843}, + DictWord{10, 0, 545}, + DictWord{140, 0, 301}, + DictWord{6, 0, 947}, + DictWord{134, 0, 1062}, + DictWord{ + 134, + 0, + 1188, + }, + DictWord{4, 0, 904}, + DictWord{5, 0, 794}, + DictWord{152, 10, 6}, + DictWord{134, 0, 1372}, + DictWord{135, 11, 608}, + DictWord{5, 11, 279}, + DictWord{ + 6, + 11, + 235, + }, + DictWord{7, 11, 468}, + DictWord{8, 11, 446}, + DictWord{9, 11, 637}, + DictWord{10, 11, 717}, + DictWord{11, 11, 738}, + DictWord{140, 11, 514}, + DictWord{ + 132, + 10, + 509, + }, + DictWord{5, 11, 17}, + DictWord{6, 11, 371}, + DictWord{137, 11, 528}, + DictWord{132, 0, 693}, + DictWord{4, 11, 115}, + DictWord{5, 11, 669}, + DictWord{ + 6, + 11, + 407, + }, + DictWord{8, 11, 311}, + DictWord{11, 11, 10}, + DictWord{141, 11, 5}, + DictWord{11, 0, 377}, + DictWord{7, 10, 273}, + DictWord{137, 11, 381}, + DictWord{ + 135, + 0, + 695, + }, + DictWord{7, 0, 386}, + DictWord{138, 0, 713}, + DictWord{135, 10, 1041}, + DictWord{134, 0, 1291}, + DictWord{6, 0, 7}, + DictWord{6, 0, 35}, + DictWord{ + 7, + 0, + 147, + }, + DictWord{7, 0, 1069}, + DictWord{7, 0, 1568}, + DictWord{7, 0, 1575}, + DictWord{7, 0, 1917}, + DictWord{8, 0, 43}, + DictWord{8, 0, 208}, + DictWord{9, 0, 128}, + DictWord{ + 9, + 0, + 866, + }, + DictWord{10, 0, 20}, + DictWord{11, 0, 981}, + DictWord{147, 0, 33}, + DictWord{7, 0, 893}, + DictWord{141, 0, 424}, + DictWord{139, 10, 234}, + DictWord{ + 150, + 11, + 56, + }, + DictWord{5, 11, 779}, + DictWord{5, 11, 807}, + DictWord{6, 11, 1655}, + DictWord{134, 11, 1676}, + DictWord{5, 10, 802}, + DictWord{7, 10, 2021}, + DictWord{136, 10, 805}, + DictWord{4, 11, 196}, + DictWord{5, 10, 167}, + DictWord{5, 11, 558}, + DictWord{5, 10, 899}, + DictWord{5, 11, 949}, + DictWord{6, 10, 410}, + DictWord{137, 10, 777}, + DictWord{137, 10, 789}, + DictWord{134, 10, 1705}, + DictWord{8, 0, 904}, + DictWord{140, 0, 787}, + DictWord{6, 0, 322}, + DictWord{9, 0, 552}, + DictWord{11, 0, 274}, + DictWord{13, 0, 209}, + DictWord{13, 0, 499}, + DictWord{14, 0, 85}, + DictWord{15, 0, 126}, + DictWord{145, 0, 70}, + DictWord{135, 10, 10}, + DictWord{ + 5, + 10, + 11, + }, + DictWord{6, 10, 117}, + DictWord{6, 10, 485}, + DictWord{7, 10, 1133}, + DictWord{9, 10, 582}, + DictWord{9, 10, 594}, + DictWord{11, 10, 21}, + DictWord{ + 11, + 10, + 818, + }, + DictWord{12, 10, 535}, + DictWord{141, 10, 86}, + DictWord{4, 10, 264}, + DictWord{7, 10, 1067}, + DictWord{8, 10, 204}, + DictWord{8, 10, 385}, + DictWord{139, 10, 953}, + DictWord{132, 11, 752}, + DictWord{138, 10, 56}, + DictWord{133, 10, 470}, + DictWord{6, 0, 1808}, + DictWord{8, 0, 83}, + DictWord{8, 0, 742}, + DictWord{8, 0, 817}, + DictWord{9, 0, 28}, + DictWord{9, 0, 29}, + DictWord{9, 0, 885}, + DictWord{10, 0, 387}, + DictWord{11, 0, 633}, + DictWord{11, 0, 740}, + DictWord{13, 0, 235}, + DictWord{13, 0, 254}, + DictWord{15, 0, 143}, + DictWord{143, 0, 146}, + DictWord{140, 0, 49}, + DictWord{134, 0, 1832}, + DictWord{4, 11, 227}, + DictWord{5, 11, 159}, + DictWord{5, 11, 409}, + DictWord{7, 11, 80}, + DictWord{10, 11, 294}, + DictWord{10, 11, 479}, + DictWord{12, 11, 418}, + DictWord{14, 11, 50}, + DictWord{14, 11, 249}, + DictWord{142, 11, 295}, + DictWord{7, 11, 1470}, + DictWord{8, 11, 66}, + DictWord{8, 11, 137}, + DictWord{8, 11, 761}, + DictWord{9, 11, 638}, + DictWord{11, 11, 80}, + DictWord{11, 11, 212}, + DictWord{11, 11, 368}, + DictWord{11, 11, 418}, + DictWord{12, 11, 8}, + DictWord{13, 11, 15}, + DictWord{16, 11, 61}, + DictWord{17, 11, 59}, + DictWord{19, 11, 28}, + DictWord{148, 11, 84}, + DictWord{139, 10, 1015}, + DictWord{138, 11, 468}, + DictWord{135, 0, 421}, + DictWord{6, 0, 415}, + DictWord{ + 7, + 0, + 1049, + }, + DictWord{137, 0, 442}, + DictWord{6, 11, 38}, + DictWord{7, 11, 1220}, + DictWord{8, 11, 185}, + DictWord{8, 11, 256}, + DictWord{9, 11, 22}, + DictWord{ + 9, + 11, + 331, + }, + DictWord{10, 11, 738}, + DictWord{11, 11, 205}, + DictWord{11, 11, 540}, + DictWord{11, 11, 746}, + DictWord{13, 11, 399}, + DictWord{13, 11, 465}, + DictWord{ + 14, + 11, + 88, + }, + DictWord{142, 11, 194}, + DictWord{139, 0, 289}, + DictWord{133, 10, 715}, + DictWord{4, 0, 110}, + DictWord{10, 0, 415}, + DictWord{10, 0, 597}, + DictWord{142, 0, 206}, + DictWord{4, 11, 159}, + DictWord{6, 11, 115}, + DictWord{7, 11, 252}, + DictWord{7, 11, 257}, + DictWord{7, 11, 1928}, + DictWord{8, 11, 69}, + DictWord{ + 9, + 11, + 384, + }, + DictWord{10, 11, 91}, + DictWord{10, 11, 615}, + DictWord{12, 11, 375}, + DictWord{14, 11, 235}, + DictWord{18, 11, 117}, + DictWord{147, 11, 123}, + DictWord{5, 11, 911}, + DictWord{136, 11, 278}, + DictWord{7, 0, 205}, + DictWord{7, 0, 2000}, + DictWord{8, 10, 794}, + DictWord{9, 10, 400}, + DictWord{10, 10, 298}, + DictWord{142, 10, 228}, + DictWord{135, 11, 1774}, + DictWord{4, 11, 151}, + DictWord{7, 11, 1567}, + DictWord{8, 11, 351}, + DictWord{137, 11, 322}, + DictWord{ + 136, + 10, + 724, + }, + DictWord{133, 11, 990}, + DictWord{7, 0, 1539}, + DictWord{11, 0, 512}, + DictWord{13, 0, 205}, + DictWord{19, 0, 30}, + DictWord{22, 0, 36}, + DictWord{23, 0, 19}, + DictWord{135, 11, 1539}, + DictWord{5, 11, 194}, + DictWord{7, 11, 1662}, + DictWord{9, 11, 90}, + DictWord{140, 11, 180}, + DictWord{6, 10, 190}, + DictWord{ + 7, + 10, + 768, + }, + DictWord{135, 10, 1170}, + DictWord{134, 0, 1340}, + DictWord{4, 0, 283}, + DictWord{135, 0, 1194}, + DictWord{133, 11, 425}, + DictWord{133, 11, 971}, + DictWord{12, 0, 549}, + DictWord{14, 10, 67}, + DictWord{147, 10, 60}, + DictWord{135, 10, 1023}, + DictWord{134, 0, 1720}, + DictWord{138, 11, 587}, + DictWord{ + 5, + 11, + 72, + }, + DictWord{6, 11, 264}, + DictWord{7, 11, 21}, + DictWord{7, 11, 46}, + DictWord{7, 11, 2013}, + DictWord{8, 11, 215}, + DictWord{8, 11, 513}, + DictWord{10, 11, 266}, + DictWord{139, 11, 22}, + DictWord{5, 0, 319}, + DictWord{135, 0, 534}, + DictWord{6, 10, 137}, + DictWord{9, 10, 75}, + DictWord{9, 10, 253}, + DictWord{10, 10, 194}, + DictWord{138, 10, 444}, + DictWord{7, 0, 1180}, + DictWord{20, 0, 112}, + DictWord{6, 11, 239}, + DictWord{7, 11, 118}, + DictWord{10, 11, 95}, + DictWord{11, 11, 603}, + DictWord{13, 11, 443}, + DictWord{14, 11, 160}, + DictWord{143, 11, 4}, + DictWord{134, 11, 431}, + DictWord{5, 11, 874}, + DictWord{6, 11, 1677}, + DictWord{ + 11, + 10, + 643, + }, + DictWord{12, 10, 115}, + DictWord{143, 11, 0}, + DictWord{134, 0, 967}, + DictWord{6, 11, 65}, + DictWord{7, 11, 939}, + DictWord{7, 11, 1172}, + DictWord{ + 7, + 11, + 1671, + }, + DictWord{9, 11, 540}, + DictWord{10, 11, 696}, + DictWord{11, 11, 265}, + DictWord{11, 11, 732}, + DictWord{11, 11, 928}, + DictWord{11, 11, 937}, + DictWord{ + 12, + 11, + 399, + }, + DictWord{13, 11, 438}, + DictWord{149, 11, 19}, + DictWord{137, 11, 200}, + DictWord{135, 0, 1940}, + DictWord{5, 10, 760}, + DictWord{7, 10, 542}, + DictWord{8, 10, 135}, + DictWord{136, 10, 496}, + DictWord{140, 11, 44}, + DictWord{7, 11, 1655}, + DictWord{136, 11, 305}, + DictWord{7, 10, 319}, + DictWord{ + 7, + 10, + 355, + }, + DictWord{7, 10, 763}, + DictWord{10, 10, 389}, + DictWord{145, 10, 43}, + DictWord{136, 0, 735}, + DictWord{138, 10, 786}, + DictWord{137, 11, 19}, + DictWord{132, 11, 696}, + DictWord{5, 0, 132}, + DictWord{9, 0, 486}, + DictWord{9, 0, 715}, + DictWord{10, 0, 458}, + DictWord{11, 0, 373}, + DictWord{11, 0, 668}, + DictWord{ + 11, + 0, + 795, + }, + DictWord{11, 0, 897}, + DictWord{12, 0, 272}, + DictWord{12, 0, 424}, + DictWord{12, 0, 539}, + DictWord{12, 0, 558}, + DictWord{14, 0, 245}, + DictWord{ + 14, + 0, + 263, + }, + DictWord{14, 0, 264}, + DictWord{14, 0, 393}, + DictWord{142, 0, 403}, + DictWord{10, 0, 38}, + DictWord{139, 0, 784}, + DictWord{132, 0, 838}, + DictWord{ + 4, + 11, + 302, + }, + DictWord{135, 11, 1766}, + DictWord{133, 0, 379}, + DictWord{5, 0, 8}, + DictWord{6, 0, 89}, + DictWord{6, 0, 400}, + DictWord{7, 0, 1569}, + DictWord{7, 0, 1623}, + DictWord{7, 0, 1850}, + DictWord{8, 0, 218}, + DictWord{8, 0, 422}, + DictWord{9, 0, 570}, + DictWord{10, 0, 626}, + DictWord{4, 11, 726}, + DictWord{133, 11, 630}, + DictWord{ + 4, + 0, + 1017, + }, + DictWord{138, 0, 660}, + DictWord{6, 0, 387}, + DictWord{7, 0, 882}, + DictWord{141, 0, 111}, + DictWord{6, 0, 224}, + DictWord{7, 0, 877}, + DictWord{ + 137, + 0, + 647, + }, + DictWord{4, 10, 58}, + DictWord{5, 10, 286}, + DictWord{6, 10, 319}, + DictWord{7, 10, 402}, + DictWord{7, 10, 1254}, + DictWord{7, 10, 1903}, + DictWord{ + 8, + 10, + 356, + }, + DictWord{140, 10, 408}, + DictWord{135, 0, 790}, + DictWord{9, 0, 510}, + DictWord{10, 0, 53}, + DictWord{4, 10, 389}, + DictWord{9, 10, 181}, + DictWord{ + 10, + 10, + 29, + }, + DictWord{10, 10, 816}, + DictWord{11, 10, 311}, + DictWord{11, 10, 561}, + DictWord{12, 10, 67}, + DictWord{141, 10, 181}, + DictWord{142, 0, 458}, + DictWord{ + 6, + 11, + 118, + }, + DictWord{7, 11, 215}, + DictWord{7, 11, 1521}, + DictWord{140, 11, 11}, + DictWord{134, 0, 954}, + DictWord{135, 0, 394}, + DictWord{134, 0, 1367}, + DictWord{5, 11, 225}, + DictWord{133, 10, 373}, + DictWord{132, 0, 882}, + DictWord{7, 0, 1409}, + DictWord{135, 10, 1972}, + DictWord{135, 10, 1793}, + DictWord{ + 4, + 11, + 370, + }, + DictWord{5, 11, 756}, + DictWord{135, 11, 1326}, + DictWord{150, 11, 13}, + DictWord{7, 11, 354}, + DictWord{10, 11, 410}, + DictWord{139, 11, 815}, + DictWord{6, 11, 1662}, + DictWord{7, 11, 48}, + DictWord{8, 11, 771}, + DictWord{10, 11, 116}, + DictWord{13, 11, 104}, + DictWord{14, 11, 105}, + DictWord{14, 11, 184}, + DictWord{15, 11, 168}, + DictWord{19, 11, 92}, + DictWord{148, 11, 68}, + DictWord{7, 0, 124}, + DictWord{136, 0, 38}, + DictWord{5, 0, 261}, + DictWord{7, 0, 78}, + DictWord{ + 7, + 0, + 199, + }, + DictWord{8, 0, 815}, + DictWord{9, 0, 126}, + DictWord{10, 0, 342}, + DictWord{140, 0, 647}, + DictWord{4, 0, 628}, + DictWord{140, 0, 724}, + DictWord{7, 0, 266}, + DictWord{8, 0, 804}, + DictWord{7, 10, 1651}, + DictWord{145, 10, 89}, + DictWord{135, 0, 208}, + DictWord{134, 0, 1178}, + DictWord{6, 0, 79}, + DictWord{135, 0, 1519}, + DictWord{132, 10, 672}, + DictWord{133, 10, 737}, + DictWord{136, 0, 741}, + DictWord{132, 11, 120}, + DictWord{4, 0, 710}, + DictWord{6, 0, 376}, + DictWord{ + 134, + 0, + 606, + }, + DictWord{134, 0, 1347}, + DictWord{134, 0, 1494}, + DictWord{6, 0, 850}, + DictWord{6, 0, 1553}, + DictWord{137, 0, 821}, + DictWord{5, 10, 145}, + DictWord{ + 134, + 11, + 593, + }, + DictWord{7, 0, 1311}, + DictWord{140, 0, 135}, + DictWord{4, 0, 467}, + DictWord{5, 0, 405}, + DictWord{134, 0, 544}, + DictWord{5, 11, 820}, + DictWord{ + 135, + 11, + 931, + }, + DictWord{6, 0, 100}, + DictWord{7, 0, 244}, + DictWord{7, 0, 632}, + DictWord{7, 0, 1609}, + DictWord{8, 0, 178}, + DictWord{8, 0, 638}, + DictWord{141, 0, 58}, + DictWord{4, 10, 387}, + DictWord{135, 10, 1288}, + DictWord{6, 11, 151}, + DictWord{6, 11, 1675}, + DictWord{7, 11, 383}, + DictWord{151, 11, 10}, + DictWord{ + 132, + 0, + 481, + }, + DictWord{135, 10, 550}, + DictWord{134, 0, 1378}, + DictWord{6, 11, 1624}, + DictWord{11, 11, 11}, + DictWord{12, 11, 422}, + DictWord{13, 11, 262}, + DictWord{142, 11, 360}, + DictWord{133, 0, 791}, + DictWord{4, 11, 43}, + DictWord{5, 11, 344}, + DictWord{133, 11, 357}, + DictWord{7, 0, 1227}, + DictWord{140, 0, 978}, + DictWord{7, 0, 686}, + DictWord{8, 0, 33}, + DictWord{8, 0, 238}, + DictWord{10, 0, 616}, + DictWord{11, 0, 467}, + DictWord{11, 0, 881}, + DictWord{13, 0, 217}, + DictWord{ + 13, + 0, + 253, + }, + DictWord{142, 0, 268}, + DictWord{137, 0, 857}, + DictWord{8, 0, 467}, + DictWord{8, 0, 1006}, + DictWord{7, 11, 148}, + DictWord{8, 11, 284}, + DictWord{ + 141, + 11, + 63, + }, + DictWord{4, 10, 576}, + DictWord{135, 10, 1263}, + DictWord{133, 11, 888}, + DictWord{5, 10, 919}, + DictWord{134, 10, 1673}, + DictWord{20, 10, 37}, + DictWord{148, 11, 37}, + DictWord{132, 0, 447}, + DictWord{132, 11, 711}, + DictWord{4, 0, 128}, + DictWord{5, 0, 415}, + DictWord{6, 0, 462}, + DictWord{7, 0, 294}, + DictWord{ + 7, + 0, + 578, + }, + DictWord{10, 0, 710}, + DictWord{139, 0, 86}, + DictWord{4, 10, 82}, + DictWord{5, 10, 333}, + DictWord{5, 10, 904}, + DictWord{6, 10, 207}, + DictWord{7, 10, 325}, + DictWord{7, 10, 1726}, + DictWord{8, 10, 101}, + DictWord{10, 10, 778}, + DictWord{139, 10, 220}, + DictWord{136, 0, 587}, + DictWord{137, 11, 440}, + DictWord{ + 133, + 10, + 903, + }, + DictWord{6, 0, 427}, + DictWord{7, 0, 1018}, + DictWord{138, 0, 692}, + DictWord{4, 0, 195}, + DictWord{135, 0, 802}, + DictWord{140, 10, 147}, + DictWord{ + 134, + 0, + 1546, + }, + DictWord{134, 0, 684}, + DictWord{132, 10, 705}, + DictWord{136, 0, 345}, + DictWord{11, 11, 678}, + DictWord{140, 11, 307}, + DictWord{ + 133, + 0, + 365, + }, + DictWord{134, 0, 1683}, + DictWord{4, 11, 65}, + DictWord{5, 11, 479}, + DictWord{5, 11, 1004}, + DictWord{7, 11, 1913}, + DictWord{8, 11, 317}, + DictWord{ + 9, + 11, + 302, + }, + DictWord{10, 11, 612}, + DictWord{141, 11, 22}, + DictWord{138, 0, 472}, + DictWord{4, 11, 261}, + DictWord{135, 11, 510}, + DictWord{134, 10, 90}, + DictWord{142, 0, 433}, + DictWord{151, 0, 28}, + DictWord{4, 11, 291}, + DictWord{7, 11, 101}, + DictWord{9, 11, 515}, + DictWord{12, 11, 152}, + DictWord{12, 11, 443}, + DictWord{13, 11, 392}, + DictWord{142, 11, 357}, + DictWord{140, 0, 997}, + DictWord{5, 0, 3}, + DictWord{8, 0, 578}, + DictWord{9, 0, 118}, + DictWord{10, 0, 705}, + DictWord{ + 141, + 0, + 279, + }, + DictWord{135, 11, 1266}, + DictWord{7, 10, 813}, + DictWord{12, 10, 497}, + DictWord{141, 10, 56}, + DictWord{133, 0, 229}, + DictWord{6, 10, 125}, + DictWord{135, 10, 1277}, + DictWord{8, 0, 102}, + DictWord{10, 0, 578}, + DictWord{10, 0, 672}, + DictWord{12, 0, 496}, + DictWord{13, 0, 408}, + DictWord{14, 0, 121}, + DictWord{17, 0, 106}, + DictWord{151, 10, 12}, + DictWord{6, 0, 866}, + DictWord{134, 0, 1080}, + DictWord{136, 0, 1022}, + DictWord{4, 11, 130}, + DictWord{135, 11, 843}, + DictWord{5, 11, 42}, + DictWord{5, 11, 879}, + DictWord{7, 11, 245}, + DictWord{7, 11, 324}, + DictWord{7, 11, 1532}, + DictWord{11, 11, 463}, + DictWord{11, 11, 472}, + DictWord{13, 11, 363}, + DictWord{144, 11, 52}, + DictWord{150, 0, 55}, + DictWord{8, 0, 115}, + DictWord{8, 0, 350}, + DictWord{9, 0, 489}, + DictWord{10, 0, 128}, + DictWord{ + 11, + 0, + 306, + }, + DictWord{12, 0, 373}, + DictWord{14, 0, 30}, + DictWord{17, 0, 79}, + DictWord{19, 0, 80}, + DictWord{4, 11, 134}, + DictWord{133, 11, 372}, + DictWord{ + 134, + 0, + 657, + }, + DictWord{134, 0, 933}, + DictWord{135, 11, 1147}, + DictWord{4, 0, 230}, + DictWord{133, 0, 702}, + DictWord{134, 0, 1728}, + DictWord{4, 0, 484}, + DictWord{ + 18, + 0, + 26, + }, + DictWord{19, 0, 42}, + DictWord{20, 0, 43}, + DictWord{21, 0, 0}, + DictWord{23, 0, 27}, + DictWord{152, 0, 14}, + DictWord{7, 0, 185}, + DictWord{135, 0, 703}, + DictWord{ + 6, + 0, + 417, + }, + DictWord{10, 0, 618}, + DictWord{7, 10, 1106}, + DictWord{9, 10, 770}, + DictWord{11, 10, 112}, + DictWord{140, 10, 413}, + DictWord{134, 0, 803}, + DictWord{132, 11, 644}, + DictWord{134, 0, 1262}, + DictWord{7, 11, 540}, + DictWord{12, 10, 271}, + DictWord{145, 10, 109}, + DictWord{135, 11, 123}, + DictWord{ + 132, + 0, + 633, + }, + DictWord{134, 11, 623}, + DictWord{4, 11, 908}, + DictWord{5, 11, 359}, + DictWord{5, 11, 508}, + DictWord{6, 11, 1723}, + DictWord{7, 11, 343}, + DictWord{ + 7, + 11, + 1996, + }, + DictWord{135, 11, 2026}, + DictWord{135, 0, 479}, + DictWord{10, 0, 262}, + DictWord{7, 10, 304}, + DictWord{9, 10, 646}, + DictWord{9, 10, 862}, + DictWord{ + 11, + 10, + 696, + }, + DictWord{12, 10, 208}, + DictWord{15, 10, 79}, + DictWord{147, 10, 108}, + DictWord{4, 11, 341}, + DictWord{135, 11, 480}, + DictWord{134, 0, 830}, + DictWord{5, 0, 70}, + DictWord{5, 0, 622}, + DictWord{6, 0, 334}, + DictWord{7, 0, 1032}, + DictWord{9, 0, 171}, + DictWord{11, 0, 26}, + DictWord{11, 0, 213}, + DictWord{ + 11, + 0, + 637, + }, + DictWord{11, 0, 707}, + DictWord{12, 0, 202}, + DictWord{12, 0, 380}, + DictWord{13, 0, 226}, + DictWord{13, 0, 355}, + DictWord{14, 0, 222}, + DictWord{145, 0, 42}, + DictWord{135, 10, 981}, + DictWord{143, 0, 217}, + DictWord{137, 11, 114}, + DictWord{4, 0, 23}, + DictWord{4, 0, 141}, + DictWord{5, 0, 313}, + DictWord{5, 0, 1014}, + DictWord{6, 0, 50}, + DictWord{6, 0, 51}, + DictWord{7, 0, 142}, + DictWord{7, 0, 384}, + DictWord{7, 0, 559}, + DictWord{8, 0, 640}, + DictWord{9, 0, 460}, + DictWord{9, 0, 783}, + DictWord{11, 0, 741}, + DictWord{12, 0, 183}, + DictWord{141, 0, 488}, + DictWord{141, 0, 360}, + DictWord{7, 0, 1586}, + DictWord{7, 11, 1995}, + DictWord{8, 11, 299}, + DictWord{11, 11, 890}, + DictWord{140, 11, 674}, + DictWord{132, 10, 434}, + DictWord{7, 0, 652}, + DictWord{134, 10, 550}, + DictWord{7, 0, 766}, + DictWord{5, 10, 553}, + DictWord{138, 10, 824}, + DictWord{7, 0, 737}, + DictWord{8, 0, 298}, + DictWord{136, 10, 452}, + DictWord{4, 11, 238}, + DictWord{5, 11, 503}, + DictWord{6, 11, 179}, + DictWord{7, 11, 2003}, + DictWord{8, 11, 381}, + DictWord{8, 11, 473}, + DictWord{9, 11, 149}, + DictWord{10, 11, 183}, + DictWord{15, 11, 45}, + DictWord{143, 11, 86}, + DictWord{133, 10, 292}, + DictWord{5, 0, 222}, + DictWord{9, 0, 655}, + DictWord{138, 0, 534}, + DictWord{138, 10, 135}, + DictWord{4, 11, 121}, + DictWord{5, 11, 156}, + DictWord{5, 11, 349}, + DictWord{9, 11, 136}, + DictWord{10, 11, 605}, + DictWord{14, 11, 342}, + DictWord{147, 11, 107}, + DictWord{137, 0, 906}, + DictWord{6, 0, 1013}, + DictWord{134, 0, 1250}, + DictWord{6, 0, 1956}, + DictWord{6, 0, 2009}, + DictWord{8, 0, 991}, + DictWord{144, 0, 120}, + DictWord{135, 11, 1192}, + DictWord{ + 138, + 0, + 503, + }, + DictWord{5, 0, 154}, + DictWord{7, 0, 1491}, + DictWord{10, 0, 379}, + DictWord{138, 0, 485}, + DictWord{6, 0, 1867}, + DictWord{6, 0, 1914}, + DictWord{6, 0, 1925}, + DictWord{9, 0, 917}, + DictWord{9, 0, 925}, + DictWord{9, 0, 932}, + DictWord{9, 0, 951}, + DictWord{9, 0, 1007}, + DictWord{9, 0, 1013}, + DictWord{12, 0, 806}, + DictWord{ + 12, + 0, + 810, + }, + DictWord{12, 0, 814}, + DictWord{12, 0, 816}, + DictWord{12, 0, 824}, + DictWord{12, 0, 832}, + DictWord{12, 0, 837}, + DictWord{12, 0, 863}, + DictWord{ + 12, + 0, + 868, + }, + DictWord{12, 0, 870}, + DictWord{12, 0, 889}, + DictWord{12, 0, 892}, + DictWord{12, 0, 900}, + DictWord{12, 0, 902}, + DictWord{12, 0, 908}, + DictWord{12, 0, 933}, + DictWord{12, 0, 942}, + DictWord{12, 0, 949}, + DictWord{12, 0, 954}, + DictWord{15, 0, 175}, + DictWord{15, 0, 203}, + DictWord{15, 0, 213}, + DictWord{15, 0, 218}, + DictWord{15, 0, 225}, + DictWord{15, 0, 231}, + DictWord{15, 0, 239}, + DictWord{15, 0, 248}, + DictWord{15, 0, 252}, + DictWord{18, 0, 190}, + DictWord{18, 0, 204}, + DictWord{ + 18, + 0, + 215, + }, + DictWord{18, 0, 216}, + DictWord{18, 0, 222}, + DictWord{18, 0, 225}, + DictWord{18, 0, 230}, + DictWord{18, 0, 239}, + DictWord{18, 0, 241}, + DictWord{ + 21, + 0, + 42, + }, + DictWord{21, 0, 43}, + DictWord{21, 0, 44}, + DictWord{21, 0, 45}, + DictWord{21, 0, 46}, + DictWord{21, 0, 53}, + DictWord{24, 0, 27}, + DictWord{152, 0, 31}, + DictWord{ + 133, + 0, + 716, + }, + DictWord{135, 0, 844}, + DictWord{4, 0, 91}, + DictWord{5, 0, 388}, + DictWord{5, 0, 845}, + DictWord{6, 0, 206}, + DictWord{6, 0, 252}, + DictWord{6, 0, 365}, + DictWord{ + 7, + 0, + 136, + }, + DictWord{7, 0, 531}, + DictWord{136, 0, 621}, + DictWord{7, 10, 393}, + DictWord{10, 10, 603}, + DictWord{139, 10, 206}, + DictWord{6, 11, 80}, + DictWord{ + 6, + 11, + 1694, + }, + DictWord{7, 11, 173}, + DictWord{7, 11, 1974}, + DictWord{9, 11, 547}, + DictWord{10, 11, 730}, + DictWord{14, 11, 18}, + DictWord{150, 11, 39}, + DictWord{137, 0, 748}, + DictWord{4, 11, 923}, + DictWord{134, 11, 1711}, + DictWord{4, 10, 912}, + DictWord{137, 10, 232}, + DictWord{7, 10, 98}, + DictWord{7, 10, 1973}, + DictWord{136, 10, 716}, + DictWord{14, 0, 103}, + DictWord{133, 10, 733}, + DictWord{132, 11, 595}, + DictWord{12, 0, 158}, + DictWord{18, 0, 8}, + DictWord{19, 0, 62}, + DictWord{20, 0, 6}, + DictWord{22, 0, 4}, + DictWord{23, 0, 2}, + DictWord{23, 0, 9}, + DictWord{5, 11, 240}, + DictWord{6, 11, 459}, + DictWord{7, 11, 12}, + DictWord{7, 11, 114}, + DictWord{7, 11, 502}, + DictWord{7, 11, 1751}, + DictWord{7, 11, 1753}, + DictWord{7, 11, 1805}, + DictWord{8, 11, 658}, + DictWord{9, 11, 1}, + DictWord{11, 11, 959}, + DictWord{13, 11, 446}, + DictWord{142, 11, 211}, + DictWord{135, 0, 576}, + DictWord{5, 0, 771}, + DictWord{5, 0, 863}, + DictWord{5, 0, 898}, + DictWord{6, 0, 648}, + DictWord{ + 6, + 0, + 1632, + }, + DictWord{6, 0, 1644}, + DictWord{134, 0, 1780}, + DictWord{133, 0, 331}, + DictWord{7, 11, 633}, + DictWord{7, 11, 905}, + DictWord{7, 11, 909}, + DictWord{ + 7, + 11, + 1538, + }, + DictWord{9, 11, 767}, + DictWord{140, 11, 636}, + DictWord{140, 0, 632}, + DictWord{5, 0, 107}, + DictWord{7, 0, 201}, + DictWord{136, 0, 518}, + DictWord{ + 6, + 0, + 446, + }, + DictWord{7, 0, 1817}, + DictWord{134, 11, 490}, + DictWord{9, 0, 851}, + DictWord{141, 0, 510}, + DictWord{7, 11, 250}, + DictWord{8, 11, 506}, + DictWord{ + 136, + 11, + 507, + }, + DictWord{4, 0, 504}, + DictWord{137, 10, 72}, + DictWord{132, 11, 158}, + DictWord{4, 11, 140}, + DictWord{7, 11, 362}, + DictWord{8, 11, 209}, + DictWord{ + 9, + 11, + 10, + }, + DictWord{9, 11, 160}, + DictWord{9, 11, 503}, + DictWord{10, 11, 689}, + DictWord{11, 11, 350}, + DictWord{11, 11, 553}, + DictWord{11, 11, 725}, + DictWord{ + 12, + 11, + 252, + }, + DictWord{12, 11, 583}, + DictWord{13, 11, 192}, + DictWord{13, 11, 352}, + DictWord{14, 11, 269}, + DictWord{14, 11, 356}, + DictWord{148, 11, 50}, + DictWord{6, 11, 597}, + DictWord{135, 11, 1318}, + DictWord{135, 10, 1454}, + DictWord{5, 0, 883}, + DictWord{5, 0, 975}, + DictWord{8, 0, 392}, + DictWord{148, 0, 7}, + DictWord{6, 11, 228}, + DictWord{7, 11, 1341}, + DictWord{9, 11, 408}, + DictWord{138, 11, 343}, + DictWord{11, 11, 348}, + DictWord{11, 10, 600}, + DictWord{12, 11, 99}, + DictWord{13, 10, 245}, + DictWord{18, 11, 1}, + DictWord{18, 11, 11}, + DictWord{147, 11, 4}, + DictWord{134, 11, 296}, + DictWord{5, 0, 922}, + DictWord{134, 0, 1707}, + DictWord{132, 11, 557}, + DictWord{4, 11, 548}, + DictWord{7, 10, 164}, + DictWord{7, 10, 1571}, + DictWord{9, 10, 107}, + DictWord{140, 10, 225}, + DictWord{ + 7, + 11, + 197, + }, + DictWord{8, 11, 142}, + DictWord{8, 11, 325}, + DictWord{9, 11, 150}, + DictWord{9, 11, 596}, + DictWord{10, 11, 350}, + DictWord{10, 11, 353}, + DictWord{ + 11, + 11, + 74, + }, + DictWord{11, 11, 315}, + DictWord{14, 11, 423}, + DictWord{143, 11, 141}, + DictWord{5, 0, 993}, + DictWord{7, 0, 515}, + DictWord{137, 0, 91}, + DictWord{4, 0, 131}, + DictWord{8, 0, 200}, + DictWord{5, 10, 484}, + DictWord{5, 10, 510}, + DictWord{6, 10, 434}, + DictWord{7, 10, 1000}, + DictWord{7, 10, 1098}, + DictWord{136, 10, 2}, + DictWord{152, 0, 10}, + DictWord{4, 11, 62}, + DictWord{5, 11, 83}, + DictWord{6, 11, 399}, + DictWord{6, 11, 579}, + DictWord{7, 11, 692}, + DictWord{7, 11, 846}, + DictWord{ + 7, + 11, + 1015, + }, + DictWord{7, 11, 1799}, + DictWord{8, 11, 403}, + DictWord{9, 11, 394}, + DictWord{10, 11, 133}, + DictWord{12, 11, 4}, + DictWord{12, 11, 297}, + DictWord{ + 12, + 11, + 452, + }, + DictWord{16, 11, 81}, + DictWord{18, 11, 19}, + DictWord{18, 11, 25}, + DictWord{21, 11, 14}, + DictWord{22, 11, 12}, + DictWord{151, 11, 18}, + DictWord{ + 140, + 11, + 459, + }, + DictWord{132, 11, 177}, + DictWord{7, 0, 1433}, + DictWord{9, 0, 365}, + DictWord{137, 11, 365}, + DictWord{132, 10, 460}, + DictWord{5, 0, 103}, + DictWord{ + 6, + 0, + 2004, + }, + DictWord{7, 0, 921}, + DictWord{8, 0, 580}, + DictWord{8, 0, 593}, + DictWord{8, 0, 630}, + DictWord{10, 0, 28}, + DictWord{5, 11, 411}, + DictWord{ + 135, + 11, + 653, + }, + DictWord{4, 10, 932}, + DictWord{133, 10, 891}, + DictWord{4, 0, 911}, + DictWord{5, 0, 867}, + DictWord{5, 0, 1013}, + DictWord{7, 0, 2034}, + DictWord{8, 0, 798}, + DictWord{136, 0, 813}, + DictWord{7, 11, 439}, + DictWord{10, 11, 727}, + DictWord{11, 11, 260}, + DictWord{139, 11, 684}, + DictWord{136, 10, 625}, + DictWord{ + 5, + 11, + 208, + }, + DictWord{7, 11, 753}, + DictWord{135, 11, 1528}, + DictWord{5, 0, 461}, + DictWord{7, 0, 1925}, + DictWord{12, 0, 39}, + DictWord{13, 0, 265}, + DictWord{ + 13, + 0, + 439, + }, + DictWord{134, 10, 76}, + DictWord{6, 0, 853}, + DictWord{8, 10, 92}, + DictWord{137, 10, 221}, + DictWord{5, 0, 135}, + DictWord{6, 0, 519}, + DictWord{7, 0, 1722}, + DictWord{10, 0, 271}, + DictWord{11, 0, 261}, + DictWord{145, 0, 54}, + DictWord{139, 11, 814}, + DictWord{14, 0, 338}, + DictWord{148, 0, 81}, + DictWord{4, 0, 300}, + DictWord{133, 0, 436}, + DictWord{5, 0, 419}, + DictWord{5, 0, 687}, + DictWord{7, 0, 864}, + DictWord{9, 0, 470}, + DictWord{135, 11, 864}, + DictWord{9, 0, 836}, + DictWord{ + 133, + 11, + 242, + }, + DictWord{134, 0, 1937}, + DictWord{4, 10, 763}, + DictWord{133, 11, 953}, + DictWord{132, 10, 622}, + DictWord{132, 0, 393}, + DictWord{ + 133, + 10, + 253, + }, + DictWord{8, 0, 357}, + DictWord{10, 0, 745}, + DictWord{14, 0, 426}, + DictWord{17, 0, 94}, + DictWord{19, 0, 57}, + DictWord{135, 10, 546}, + DictWord{5, 11, 615}, + DictWord{146, 11, 37}, + DictWord{9, 10, 73}, + DictWord{10, 10, 110}, + DictWord{14, 10, 185}, + DictWord{145, 10, 119}, + DictWord{11, 0, 703}, + DictWord{7, 10, 624}, + DictWord{7, 10, 916}, + DictWord{10, 10, 256}, + DictWord{139, 10, 87}, + DictWord{133, 11, 290}, + DictWord{5, 10, 212}, + DictWord{12, 10, 35}, + DictWord{ + 141, + 10, + 382, + }, + DictWord{132, 11, 380}, + DictWord{5, 11, 52}, + DictWord{7, 11, 277}, + DictWord{9, 11, 368}, + DictWord{139, 11, 791}, + DictWord{133, 0, 387}, + DictWord{ + 10, + 11, + 138, + }, + DictWord{139, 11, 476}, + DictWord{4, 0, 6}, + DictWord{5, 0, 708}, + DictWord{136, 0, 75}, + DictWord{7, 0, 1351}, + DictWord{9, 0, 581}, + DictWord{10, 0, 639}, + DictWord{11, 0, 453}, + DictWord{140, 0, 584}, + DictWord{132, 0, 303}, + DictWord{138, 0, 772}, + DictWord{135, 10, 1175}, + DictWord{4, 0, 749}, + DictWord{ + 5, + 10, + 816, + }, + DictWord{6, 11, 256}, + DictWord{7, 11, 307}, + DictWord{7, 11, 999}, + DictWord{7, 11, 1481}, + DictWord{7, 11, 1732}, + DictWord{7, 11, 1738}, + DictWord{ + 8, + 11, + 265, + }, + DictWord{9, 11, 414}, + DictWord{11, 11, 316}, + DictWord{12, 11, 52}, + DictWord{13, 11, 420}, + DictWord{147, 11, 100}, + DictWord{135, 11, 1296}, + DictWord{ + 6, + 0, + 1065, + }, + DictWord{5, 10, 869}, + DictWord{5, 10, 968}, + DictWord{6, 10, 1626}, + DictWord{8, 10, 734}, + DictWord{136, 10, 784}, + DictWord{4, 10, 542}, + DictWord{ + 6, + 10, + 1716, + }, + DictWord{6, 10, 1727}, + DictWord{7, 10, 1082}, + DictWord{7, 10, 1545}, + DictWord{8, 10, 56}, + DictWord{8, 10, 118}, + DictWord{8, 10, 412}, + DictWord{ + 8, + 10, + 564, + }, + DictWord{9, 10, 888}, + DictWord{9, 10, 908}, + DictWord{10, 10, 50}, + DictWord{10, 10, 423}, + DictWord{11, 10, 685}, + DictWord{11, 10, 697}, + DictWord{11, 10, 933}, + DictWord{12, 10, 299}, + DictWord{13, 10, 126}, + DictWord{13, 10, 136}, + DictWord{13, 10, 170}, + DictWord{141, 10, 190}, + DictWord{ + 134, + 0, + 226, + }, + DictWord{4, 0, 106}, + DictWord{7, 0, 310}, + DictWord{11, 0, 717}, + DictWord{133, 11, 723}, + DictWord{5, 0, 890}, + DictWord{5, 0, 988}, + DictWord{4, 10, 232}, + DictWord{9, 10, 202}, + DictWord{10, 10, 474}, + DictWord{140, 10, 433}, + DictWord{6, 0, 626}, + DictWord{142, 0, 431}, + DictWord{10, 0, 706}, + DictWord{150, 0, 44}, + DictWord{13, 0, 51}, + DictWord{6, 10, 108}, + DictWord{7, 10, 1003}, + DictWord{7, 10, 1181}, + DictWord{8, 10, 111}, + DictWord{136, 10, 343}, + DictWord{132, 0, 698}, + DictWord{5, 11, 109}, + DictWord{6, 11, 1784}, + DictWord{7, 11, 1895}, + DictWord{12, 11, 296}, + DictWord{140, 11, 302}, + DictWord{134, 0, 828}, + DictWord{ + 134, + 10, + 1712, + }, + DictWord{138, 0, 17}, + DictWord{7, 0, 1929}, + DictWord{4, 10, 133}, + DictWord{5, 11, 216}, + DictWord{7, 10, 711}, + DictWord{7, 10, 1298}, + DictWord{ + 7, + 10, + 1585, + }, + DictWord{7, 11, 1879}, + DictWord{9, 11, 141}, + DictWord{9, 11, 270}, + DictWord{9, 11, 679}, + DictWord{10, 11, 159}, + DictWord{10, 11, 553}, + DictWord{ + 11, + 11, + 197, + }, + DictWord{11, 11, 438}, + DictWord{12, 11, 538}, + DictWord{12, 11, 559}, + DictWord{13, 11, 193}, + DictWord{13, 11, 423}, + DictWord{14, 11, 144}, + DictWord{14, 11, 166}, + DictWord{14, 11, 167}, + DictWord{15, 11, 67}, + DictWord{147, 11, 84}, + DictWord{141, 11, 127}, + DictWord{7, 11, 1872}, + DictWord{ + 137, + 11, + 81, + }, + DictWord{6, 10, 99}, + DictWord{7, 10, 1808}, + DictWord{145, 10, 57}, + DictWord{134, 11, 391}, + DictWord{5, 0, 689}, + DictWord{6, 0, 84}, + DictWord{7, 0, 1250}, + DictWord{6, 10, 574}, + DictWord{7, 10, 428}, + DictWord{10, 10, 669}, + DictWord{11, 10, 485}, + DictWord{11, 10, 840}, + DictWord{12, 10, 300}, + DictWord{ + 142, + 10, + 250, + }, + DictWord{7, 11, 322}, + DictWord{136, 11, 249}, + DictWord{7, 11, 432}, + DictWord{135, 11, 1649}, + DictWord{135, 10, 1871}, + DictWord{137, 10, 252}, + DictWord{6, 11, 155}, + DictWord{140, 11, 234}, + DictWord{7, 0, 871}, + DictWord{19, 0, 27}, + DictWord{147, 11, 27}, + DictWord{140, 0, 498}, + DictWord{5, 0, 986}, + DictWord{6, 0, 130}, + DictWord{138, 0, 823}, + DictWord{6, 0, 1793}, + DictWord{7, 0, 1582}, + DictWord{8, 0, 458}, + DictWord{10, 0, 101}, + DictWord{10, 0, 318}, + DictWord{ + 10, + 0, + 945, + }, + DictWord{12, 0, 734}, + DictWord{16, 0, 104}, + DictWord{18, 0, 177}, + DictWord{6, 10, 323}, + DictWord{135, 10, 1564}, + DictWord{5, 11, 632}, + DictWord{ + 138, + 11, + 526, + }, + DictWord{10, 0, 435}, + DictWord{7, 10, 461}, + DictWord{136, 10, 775}, + DictWord{6, 11, 144}, + DictWord{7, 11, 948}, + DictWord{7, 11, 1042}, + DictWord{ + 7, + 11, + 1857, + }, + DictWord{8, 11, 235}, + DictWord{8, 11, 461}, + DictWord{9, 11, 453}, + DictWord{9, 11, 530}, + DictWord{10, 11, 354}, + DictWord{17, 11, 77}, + DictWord{ + 19, + 11, + 99, + }, + DictWord{148, 11, 79}, + DictWord{138, 0, 966}, + DictWord{7, 0, 1644}, + DictWord{137, 0, 129}, + DictWord{135, 0, 997}, + DictWord{136, 0, 502}, + DictWord{ + 5, + 11, + 196, + }, + DictWord{6, 11, 486}, + DictWord{7, 11, 212}, + DictWord{8, 11, 309}, + DictWord{136, 11, 346}, + DictWord{7, 10, 727}, + DictWord{146, 10, 73}, + DictWord{132, 0, 823}, + DictWord{132, 11, 686}, + DictWord{135, 0, 1927}, + DictWord{4, 0, 762}, + DictWord{7, 0, 1756}, + DictWord{137, 0, 98}, + DictWord{136, 10, 577}, + DictWord{24, 0, 8}, + DictWord{4, 11, 30}, + DictWord{5, 11, 43}, + DictWord{152, 11, 8}, + DictWord{7, 0, 1046}, + DictWord{139, 0, 160}, + DictWord{7, 0, 492}, + DictWord{ + 4, + 10, + 413, + }, + DictWord{5, 10, 677}, + DictWord{7, 11, 492}, + DictWord{8, 10, 432}, + DictWord{140, 10, 280}, + DictWord{6, 0, 45}, + DictWord{7, 0, 433}, + DictWord{8, 0, 129}, + DictWord{9, 0, 21}, + DictWord{10, 0, 392}, + DictWord{11, 0, 79}, + DictWord{12, 0, 499}, + DictWord{13, 0, 199}, + DictWord{141, 0, 451}, + DictWord{7, 0, 558}, + DictWord{ + 136, + 0, + 353, + }, + DictWord{4, 11, 220}, + DictWord{7, 11, 1535}, + DictWord{9, 11, 93}, + DictWord{139, 11, 474}, + DictWord{7, 10, 646}, + DictWord{7, 10, 1730}, + DictWord{ + 11, + 10, + 446, + }, + DictWord{141, 10, 178}, + DictWord{133, 0, 785}, + DictWord{134, 0, 1145}, + DictWord{8, 0, 81}, + DictWord{9, 0, 189}, + DictWord{9, 0, 201}, + DictWord{ + 11, + 0, + 478, + }, + DictWord{11, 0, 712}, + DictWord{141, 0, 338}, + DictWord{5, 0, 353}, + DictWord{151, 0, 26}, + DictWord{11, 0, 762}, + DictWord{132, 10, 395}, + DictWord{ + 134, + 0, + 2024, + }, + DictWord{4, 0, 611}, + DictWord{133, 0, 606}, + DictWord{9, 10, 174}, + DictWord{10, 10, 164}, + DictWord{11, 10, 440}, + DictWord{11, 10, 841}, + DictWord{ + 143, + 10, + 98, + }, + DictWord{134, 10, 426}, + DictWord{10, 10, 608}, + DictWord{139, 10, 1002}, + DictWord{138, 10, 250}, + DictWord{6, 0, 25}, + DictWord{7, 0, 855}, + DictWord{7, 0, 1258}, + DictWord{144, 0, 32}, + DictWord{7, 11, 1725}, + DictWord{138, 11, 393}, + DictWord{5, 11, 263}, + DictWord{134, 11, 414}, + DictWord{6, 0, 2011}, + DictWord{133, 10, 476}, + DictWord{4, 0, 4}, + DictWord{7, 0, 1118}, + DictWord{7, 0, 1320}, + DictWord{7, 0, 1706}, + DictWord{8, 0, 277}, + DictWord{9, 0, 622}, + DictWord{ + 10, + 0, + 9, + }, + DictWord{11, 0, 724}, + DictWord{12, 0, 350}, + DictWord{12, 0, 397}, + DictWord{13, 0, 28}, + DictWord{13, 0, 159}, + DictWord{15, 0, 89}, + DictWord{18, 0, 5}, + DictWord{ + 19, + 0, + 9, + }, + DictWord{20, 0, 34}, + DictWord{22, 0, 47}, + DictWord{6, 11, 178}, + DictWord{6, 11, 1750}, + DictWord{8, 11, 251}, + DictWord{9, 11, 690}, + DictWord{ + 10, + 11, + 155, + }, + DictWord{10, 11, 196}, + DictWord{10, 11, 373}, + DictWord{11, 11, 698}, + DictWord{13, 11, 155}, + DictWord{148, 11, 93}, + DictWord{5, 11, 97}, + DictWord{ + 137, + 11, + 393, + }, + DictWord{7, 0, 764}, + DictWord{11, 0, 461}, + DictWord{12, 0, 172}, + DictWord{5, 10, 76}, + DictWord{6, 10, 458}, + DictWord{6, 10, 497}, + DictWord{ + 7, + 10, + 868, + }, + DictWord{9, 10, 658}, + DictWord{10, 10, 594}, + DictWord{11, 10, 566}, + DictWord{12, 10, 338}, + DictWord{141, 10, 200}, + DictWord{134, 0, 1449}, + DictWord{138, 11, 40}, + DictWord{134, 11, 1639}, + DictWord{134, 0, 1445}, + DictWord{6, 0, 1168}, + DictWord{4, 10, 526}, + DictWord{7, 10, 1029}, + DictWord{ + 135, + 10, + 1054, + }, + DictWord{4, 11, 191}, + DictWord{7, 11, 934}, + DictWord{8, 11, 647}, + DictWord{145, 11, 97}, + DictWord{132, 10, 636}, + DictWord{6, 0, 233}, + DictWord{ + 7, + 10, + 660, + }, + DictWord{7, 10, 1124}, + DictWord{17, 10, 31}, + DictWord{19, 10, 22}, + DictWord{151, 10, 14}, + DictWord{6, 10, 1699}, + DictWord{136, 11, 110}, + DictWord{ + 12, + 11, + 246, + }, + DictWord{15, 11, 162}, + DictWord{19, 11, 64}, + DictWord{20, 11, 8}, + DictWord{20, 11, 95}, + DictWord{22, 11, 24}, + DictWord{152, 11, 17}, + DictWord{ + 5, + 11, + 165, + }, + DictWord{9, 11, 346}, + DictWord{138, 11, 655}, + DictWord{5, 11, 319}, + DictWord{135, 11, 534}, + DictWord{134, 0, 255}, + DictWord{9, 0, 216}, + DictWord{ + 8, + 11, + 128, + }, + DictWord{139, 11, 179}, + DictWord{9, 0, 183}, + DictWord{139, 0, 286}, + DictWord{11, 0, 956}, + DictWord{151, 0, 3}, + DictWord{4, 0, 536}, + DictWord{ + 7, + 0, + 1141, + }, + DictWord{10, 0, 723}, + DictWord{139, 0, 371}, + DictWord{4, 10, 279}, + DictWord{7, 10, 301}, + DictWord{137, 10, 362}, + DictWord{7, 0, 285}, + DictWord{ + 5, + 11, + 57, + }, + DictWord{6, 11, 101}, + DictWord{6, 11, 1663}, + DictWord{7, 11, 132}, + DictWord{7, 11, 1048}, + DictWord{7, 11, 1154}, + DictWord{7, 11, 1415}, + DictWord{ + 7, + 11, + 1507, + }, + DictWord{12, 11, 493}, + DictWord{15, 11, 105}, + DictWord{151, 11, 15}, + DictWord{5, 11, 459}, + DictWord{7, 11, 1073}, + DictWord{7, 10, 1743}, + DictWord{ + 8, + 11, + 241, + }, + DictWord{136, 11, 334}, + DictWord{4, 10, 178}, + DictWord{133, 10, 399}, + DictWord{135, 0, 560}, + DictWord{132, 0, 690}, + DictWord{135, 0, 1246}, + DictWord{18, 0, 157}, + DictWord{147, 0, 63}, + DictWord{10, 0, 599}, + DictWord{11, 0, 33}, + DictWord{12, 0, 571}, + DictWord{149, 0, 1}, + DictWord{6, 11, 324}, + DictWord{ + 6, + 11, + 520, + }, + DictWord{7, 11, 338}, + DictWord{7, 11, 1616}, + DictWord{7, 11, 1729}, + DictWord{8, 11, 228}, + DictWord{9, 11, 69}, + DictWord{139, 11, 750}, + DictWord{ + 7, + 0, + 1862, + }, + DictWord{12, 0, 491}, + DictWord{12, 0, 520}, + DictWord{13, 0, 383}, + DictWord{142, 0, 244}, + DictWord{135, 11, 734}, + DictWord{134, 10, 1692}, + DictWord{10, 0, 448}, + DictWord{11, 0, 630}, + DictWord{17, 0, 117}, + DictWord{6, 10, 202}, + DictWord{7, 11, 705}, + DictWord{12, 10, 360}, + DictWord{17, 10, 118}, + DictWord{18, 10, 27}, + DictWord{148, 10, 67}, + DictWord{4, 11, 73}, + DictWord{6, 11, 612}, + DictWord{7, 11, 927}, + DictWord{7, 11, 1822}, + DictWord{8, 11, 217}, + DictWord{ + 9, + 11, + 472, + }, + DictWord{9, 11, 765}, + DictWord{9, 11, 766}, + DictWord{10, 11, 408}, + DictWord{11, 11, 51}, + DictWord{11, 11, 793}, + DictWord{12, 11, 266}, + DictWord{ + 15, + 11, + 158, + }, + DictWord{20, 11, 89}, + DictWord{150, 11, 32}, + DictWord{4, 0, 190}, + DictWord{133, 0, 554}, + DictWord{133, 0, 1001}, + DictWord{5, 11, 389}, + DictWord{ + 8, + 11, + 636, + }, + DictWord{137, 11, 229}, + DictWord{5, 0, 446}, + DictWord{7, 10, 872}, + DictWord{10, 10, 516}, + DictWord{139, 10, 167}, + DictWord{137, 10, 313}, + DictWord{132, 10, 224}, + DictWord{134, 0, 1313}, + DictWord{5, 10, 546}, + DictWord{7, 10, 35}, + DictWord{8, 10, 11}, + DictWord{8, 10, 12}, + DictWord{9, 10, 315}, + DictWord{9, 10, 533}, + DictWord{10, 10, 802}, + DictWord{11, 10, 166}, + DictWord{12, 10, 525}, + DictWord{142, 10, 243}, + DictWord{6, 0, 636}, + DictWord{137, 0, 837}, + DictWord{5, 10, 241}, + DictWord{8, 10, 242}, + DictWord{9, 10, 451}, + DictWord{10, 10, 667}, + DictWord{11, 10, 598}, + DictWord{140, 10, 429}, + DictWord{22, 10, 46}, + DictWord{150, 11, 46}, + DictWord{136, 11, 472}, + DictWord{11, 0, 278}, + DictWord{142, 0, 73}, + DictWord{141, 11, 185}, + DictWord{132, 0, 868}, + DictWord{ + 134, + 0, + 972, + }, + DictWord{4, 10, 366}, + DictWord{137, 10, 516}, + DictWord{138, 0, 1010}, + DictWord{5, 11, 189}, + DictWord{6, 10, 1736}, + DictWord{7, 11, 442}, + DictWord{ + 7, + 11, + 443, + }, + DictWord{8, 11, 281}, + DictWord{12, 11, 174}, + DictWord{13, 11, 83}, + DictWord{141, 11, 261}, + DictWord{139, 11, 384}, + DictWord{6, 11, 2}, + DictWord{ + 7, + 11, + 191, + }, + DictWord{7, 11, 446}, + DictWord{7, 11, 758}, + DictWord{7, 11, 1262}, + DictWord{7, 11, 1737}, + DictWord{8, 11, 22}, + DictWord{8, 11, 270}, + DictWord{ + 8, + 11, + 612, + }, + DictWord{9, 11, 4}, + DictWord{9, 11, 167}, + DictWord{9, 11, 312}, + DictWord{9, 11, 436}, + DictWord{10, 11, 156}, + DictWord{10, 11, 216}, + DictWord{ + 10, + 11, + 311, + }, + DictWord{10, 11, 623}, + DictWord{11, 11, 72}, + DictWord{11, 11, 330}, + DictWord{11, 11, 455}, + DictWord{12, 11, 101}, + DictWord{12, 11, 321}, + DictWord{ + 12, + 11, + 504, + }, + DictWord{12, 11, 530}, + DictWord{12, 11, 543}, + DictWord{13, 11, 17}, + DictWord{13, 11, 156}, + DictWord{13, 11, 334}, + DictWord{14, 11, 48}, + DictWord{15, 11, 70}, + DictWord{17, 11, 60}, + DictWord{148, 11, 64}, + DictWord{6, 10, 331}, + DictWord{136, 10, 623}, + DictWord{135, 0, 1231}, + DictWord{132, 0, 304}, + DictWord{6, 11, 60}, + DictWord{7, 11, 670}, + DictWord{7, 11, 1327}, + DictWord{8, 11, 411}, + DictWord{8, 11, 435}, + DictWord{9, 11, 653}, + DictWord{9, 11, 740}, + DictWord{10, 11, 385}, + DictWord{11, 11, 222}, + DictWord{11, 11, 324}, + DictWord{11, 11, 829}, + DictWord{140, 11, 611}, + DictWord{7, 0, 506}, + DictWord{6, 11, 166}, + DictWord{7, 11, 374}, + DictWord{135, 11, 1174}, + DictWord{14, 11, 43}, + DictWord{146, 11, 21}, + DictWord{135, 11, 1694}, + DictWord{135, 10, 1888}, + DictWord{ + 5, + 11, + 206, + }, + DictWord{134, 11, 398}, + DictWord{135, 11, 50}, + DictWord{150, 0, 26}, + DictWord{6, 0, 53}, + DictWord{6, 0, 199}, + DictWord{7, 0, 1408}, + DictWord{ + 8, + 0, + 32, + }, + DictWord{8, 0, 93}, + DictWord{10, 0, 397}, + DictWord{10, 0, 629}, + DictWord{11, 0, 593}, + DictWord{11, 0, 763}, + DictWord{13, 0, 326}, + DictWord{145, 0, 35}, + DictWord{134, 0, 105}, + DictWord{132, 10, 394}, + DictWord{4, 0, 843}, + DictWord{138, 0, 794}, + DictWord{11, 0, 704}, + DictWord{141, 0, 396}, + DictWord{5, 0, 114}, + DictWord{5, 0, 255}, + DictWord{141, 0, 285}, + DictWord{6, 0, 619}, + DictWord{7, 0, 898}, + DictWord{7, 0, 1092}, + DictWord{8, 0, 485}, + DictWord{18, 0, 28}, + DictWord{ + 19, + 0, + 116, + }, + DictWord{135, 10, 1931}, + DictWord{9, 0, 145}, + DictWord{7, 10, 574}, + DictWord{135, 10, 1719}, + DictWord{7, 0, 2035}, + DictWord{8, 0, 19}, + DictWord{ + 9, + 0, + 89, + }, + DictWord{138, 0, 831}, + DictWord{132, 10, 658}, + DictWord{6, 11, 517}, + DictWord{7, 11, 1159}, + DictWord{10, 11, 621}, + DictWord{139, 11, 192}, + DictWord{ + 7, + 0, + 1933, + }, + DictWord{7, 11, 1933}, + DictWord{9, 10, 781}, + DictWord{10, 10, 144}, + DictWord{11, 10, 385}, + DictWord{13, 10, 161}, + DictWord{13, 10, 228}, + DictWord{13, 10, 268}, + DictWord{148, 10, 107}, + DictWord{136, 10, 374}, + DictWord{10, 11, 223}, + DictWord{139, 11, 645}, + DictWord{135, 0, 1728}, + DictWord{ + 7, + 11, + 64, + }, + DictWord{7, 11, 289}, + DictWord{136, 11, 245}, + DictWord{4, 10, 344}, + DictWord{6, 10, 498}, + DictWord{139, 10, 323}, + DictWord{136, 0, 746}, + DictWord{ + 135, + 10, + 1063, + }, + DictWord{137, 10, 155}, + DictWord{4, 0, 987}, + DictWord{6, 0, 1964}, + DictWord{6, 0, 1974}, + DictWord{6, 0, 1990}, + DictWord{136, 0, 995}, + DictWord{133, 11, 609}, + DictWord{133, 10, 906}, + DictWord{134, 0, 1550}, + DictWord{134, 0, 874}, + DictWord{5, 11, 129}, + DictWord{6, 11, 61}, + DictWord{ + 135, + 11, + 947, + }, + DictWord{4, 0, 1018}, + DictWord{6, 0, 1938}, + DictWord{6, 0, 2021}, + DictWord{134, 0, 2039}, + DictWord{132, 0, 814}, + DictWord{11, 0, 126}, + DictWord{ + 139, + 0, + 287, + }, + DictWord{134, 0, 1264}, + DictWord{5, 0, 955}, + DictWord{136, 0, 814}, + DictWord{141, 11, 506}, + DictWord{132, 11, 314}, + DictWord{6, 0, 981}, + DictWord{139, 11, 1000}, + DictWord{5, 0, 56}, + DictWord{8, 0, 892}, + DictWord{8, 0, 915}, + DictWord{140, 0, 776}, + DictWord{148, 0, 100}, + DictWord{10, 0, 4}, + DictWord{ + 10, + 0, + 13, + }, + DictWord{11, 0, 638}, + DictWord{148, 0, 57}, + DictWord{148, 11, 74}, + DictWord{5, 0, 738}, + DictWord{132, 10, 616}, + DictWord{133, 11, 637}, + DictWord{ + 136, + 10, + 692, + }, + DictWord{133, 0, 758}, + DictWord{132, 10, 305}, + DictWord{137, 11, 590}, + DictWord{5, 11, 280}, + DictWord{135, 11, 1226}, + DictWord{ + 134, + 11, + 494, + }, + DictWord{135, 0, 1112}, + DictWord{133, 11, 281}, + DictWord{13, 0, 44}, + DictWord{14, 0, 214}, + DictWord{5, 10, 214}, + DictWord{7, 10, 603}, + DictWord{ + 8, + 10, + 611, + }, + DictWord{9, 10, 686}, + DictWord{10, 10, 88}, + DictWord{11, 10, 459}, + DictWord{11, 10, 496}, + DictWord{12, 10, 463}, + DictWord{140, 10, 590}, + DictWord{ + 139, + 0, + 328, + }, + DictWord{135, 11, 1064}, + DictWord{137, 0, 133}, + DictWord{7, 0, 168}, + DictWord{13, 0, 196}, + DictWord{141, 0, 237}, + DictWord{134, 10, 1703}, + DictWord{134, 0, 1152}, + DictWord{135, 0, 1245}, + DictWord{5, 0, 110}, + DictWord{6, 0, 169}, + DictWord{6, 0, 1702}, + DictWord{7, 0, 400}, + DictWord{8, 0, 538}, + DictWord{ + 9, + 0, + 184, + }, + DictWord{9, 0, 524}, + DictWord{140, 0, 218}, + DictWord{6, 0, 1816}, + DictWord{10, 0, 871}, + DictWord{12, 0, 769}, + DictWord{140, 0, 785}, + DictWord{ + 132, + 11, + 630, + }, + DictWord{7, 11, 33}, + DictWord{7, 11, 120}, + DictWord{8, 11, 489}, + DictWord{9, 11, 319}, + DictWord{10, 11, 820}, + DictWord{11, 11, 1004}, + DictWord{ + 12, + 11, + 379, + }, + DictWord{13, 11, 117}, + DictWord{13, 11, 412}, + DictWord{14, 11, 25}, + DictWord{15, 11, 52}, + DictWord{15, 11, 161}, + DictWord{16, 11, 47}, + DictWord{149, 11, 2}, + DictWord{6, 0, 133}, + DictWord{8, 0, 413}, + DictWord{9, 0, 353}, + DictWord{139, 0, 993}, + DictWord{145, 10, 19}, + DictWord{4, 11, 937}, + DictWord{ + 133, + 11, + 801, + }, + DictWord{134, 0, 978}, + DictWord{6, 0, 93}, + DictWord{6, 0, 1508}, + DictWord{7, 0, 1422}, + DictWord{7, 0, 1851}, + DictWord{8, 0, 673}, + DictWord{9, 0, 529}, + DictWord{140, 0, 43}, + DictWord{6, 0, 317}, + DictWord{10, 0, 512}, + DictWord{4, 10, 737}, + DictWord{11, 10, 294}, + DictWord{12, 10, 60}, + DictWord{12, 10, 437}, + DictWord{13, 10, 64}, + DictWord{13, 10, 380}, + DictWord{142, 10, 430}, + DictWord{9, 0, 371}, + DictWord{7, 11, 1591}, + DictWord{144, 11, 43}, + DictWord{6, 10, 1758}, + DictWord{8, 10, 520}, + DictWord{9, 10, 345}, + DictWord{9, 10, 403}, + DictWord{142, 10, 350}, + DictWord{5, 0, 526}, + DictWord{10, 10, 242}, + DictWord{ + 138, + 10, + 579, + }, + DictWord{9, 0, 25}, + DictWord{10, 0, 467}, + DictWord{138, 0, 559}, + DictWord{5, 10, 139}, + DictWord{7, 10, 1168}, + DictWord{138, 10, 539}, + DictWord{ + 4, + 0, + 335, + }, + DictWord{135, 0, 942}, + DictWord{140, 0, 754}, + DictWord{132, 11, 365}, + DictWord{11, 0, 182}, + DictWord{142, 0, 195}, + DictWord{142, 11, 29}, + DictWord{ + 5, + 11, + 7, + }, + DictWord{139, 11, 774}, + DictWord{4, 11, 746}, + DictWord{135, 11, 1090}, + DictWord{8, 0, 39}, + DictWord{10, 0, 773}, + DictWord{11, 0, 84}, + DictWord{ + 12, + 0, + 205, + }, + DictWord{142, 0, 1}, + DictWord{5, 0, 601}, + DictWord{5, 0, 870}, + DictWord{5, 11, 360}, + DictWord{136, 11, 237}, + DictWord{132, 0, 181}, + DictWord{ + 136, + 0, + 370, + }, + DictWord{134, 0, 1652}, + DictWord{8, 0, 358}, + DictWord{4, 10, 107}, + DictWord{7, 10, 613}, + DictWord{8, 10, 439}, + DictWord{8, 10, 504}, + DictWord{ + 9, + 10, + 501, + }, + DictWord{10, 10, 383}, + DictWord{139, 10, 477}, + DictWord{132, 10, 229}, + DictWord{137, 11, 785}, + DictWord{4, 0, 97}, + DictWord{5, 0, 147}, + DictWord{ + 6, + 0, + 286, + }, + DictWord{7, 0, 1362}, + DictWord{141, 0, 176}, + DictWord{6, 0, 537}, + DictWord{7, 0, 788}, + DictWord{7, 0, 1816}, + DictWord{132, 10, 903}, + DictWord{ + 140, + 10, + 71, + }, + DictWord{6, 0, 743}, + DictWord{134, 0, 1223}, + DictWord{6, 0, 375}, + DictWord{7, 0, 169}, + DictWord{7, 0, 254}, + DictWord{8, 0, 780}, + DictWord{135, 11, 1493}, + DictWord{7, 0, 1714}, + DictWord{4, 10, 47}, + DictWord{6, 10, 373}, + DictWord{7, 10, 452}, + DictWord{7, 10, 543}, + DictWord{7, 10, 1856}, + DictWord{9, 10, 6}, + DictWord{ + 11, + 10, + 257, + }, + DictWord{139, 10, 391}, + DictWord{6, 0, 896}, + DictWord{136, 0, 1003}, + DictWord{135, 0, 1447}, + DictWord{137, 11, 341}, + DictWord{5, 10, 980}, + DictWord{134, 10, 1754}, + DictWord{145, 11, 22}, + DictWord{4, 11, 277}, + DictWord{5, 11, 608}, + DictWord{6, 11, 493}, + DictWord{7, 11, 457}, + DictWord{ + 140, + 11, + 384, + }, + DictWord{7, 10, 536}, + DictWord{7, 10, 1331}, + DictWord{136, 10, 143}, + DictWord{140, 0, 744}, + DictWord{7, 11, 27}, + DictWord{135, 11, 316}, + DictWord{ + 18, + 0, + 126, + }, + DictWord{5, 10, 19}, + DictWord{134, 10, 533}, + DictWord{4, 0, 788}, + DictWord{11, 0, 41}, + DictWord{5, 11, 552}, + DictWord{5, 11, 586}, + DictWord{ + 5, + 11, + 676, + }, + DictWord{6, 11, 448}, + DictWord{8, 11, 244}, + DictWord{11, 11, 1}, + DictWord{11, 11, 41}, + DictWord{13, 11, 3}, + DictWord{16, 11, 54}, + DictWord{17, 11, 4}, + DictWord{146, 11, 13}, + DictWord{4, 0, 985}, + DictWord{6, 0, 1801}, + DictWord{4, 11, 401}, + DictWord{137, 11, 264}, + DictWord{5, 10, 395}, + DictWord{5, 10, 951}, + DictWord{134, 10, 1776}, + DictWord{5, 0, 629}, + DictWord{135, 0, 1549}, + DictWord{11, 10, 663}, + DictWord{12, 10, 210}, + DictWord{13, 10, 166}, + DictWord{ + 13, + 10, + 310, + }, + DictWord{14, 10, 373}, + DictWord{147, 10, 43}, + DictWord{9, 11, 543}, + DictWord{10, 11, 524}, + DictWord{11, 11, 30}, + DictWord{12, 11, 524}, + DictWord{ + 14, + 11, + 315, + }, + DictWord{16, 11, 18}, + DictWord{20, 11, 26}, + DictWord{148, 11, 65}, + DictWord{4, 11, 205}, + DictWord{5, 11, 623}, + DictWord{7, 11, 104}, + DictWord{ + 136, + 11, + 519, + }, + DictWord{5, 0, 293}, + DictWord{134, 0, 601}, + DictWord{7, 11, 579}, + DictWord{9, 11, 41}, + DictWord{9, 11, 244}, + DictWord{9, 11, 669}, + DictWord{ + 10, + 11, + 5, + }, + DictWord{11, 11, 861}, + DictWord{11, 11, 951}, + DictWord{139, 11, 980}, + DictWord{132, 11, 717}, + DictWord{132, 10, 695}, + DictWord{7, 10, 497}, + DictWord{ + 9, + 10, + 387, + }, + DictWord{147, 10, 81}, + DictWord{132, 0, 420}, + DictWord{142, 0, 37}, + DictWord{6, 0, 1134}, + DictWord{6, 0, 1900}, + DictWord{12, 0, 830}, + DictWord{ + 12, + 0, + 878, + }, + DictWord{12, 0, 894}, + DictWord{15, 0, 221}, + DictWord{143, 0, 245}, + DictWord{132, 11, 489}, + DictWord{7, 0, 1570}, + DictWord{140, 0, 542}, + DictWord{ + 8, + 0, + 933, + }, + DictWord{136, 0, 957}, + DictWord{6, 0, 1371}, + DictWord{7, 0, 31}, + DictWord{8, 0, 373}, + DictWord{5, 10, 284}, + DictWord{6, 10, 49}, + DictWord{6, 10, 350}, + DictWord{7, 10, 377}, + DictWord{7, 10, 1693}, + DictWord{8, 10, 678}, + DictWord{9, 10, 161}, + DictWord{9, 10, 585}, + DictWord{9, 10, 671}, + DictWord{9, 10, 839}, + DictWord{11, 10, 912}, + DictWord{141, 10, 427}, + DictWord{135, 11, 892}, + DictWord{4, 0, 325}, + DictWord{138, 0, 125}, + DictWord{139, 11, 47}, + DictWord{ + 132, + 10, + 597, + }, + DictWord{138, 0, 323}, + DictWord{6, 0, 1547}, + DictWord{7, 11, 1605}, + DictWord{9, 11, 473}, + DictWord{11, 11, 962}, + DictWord{146, 11, 139}, + DictWord{ + 139, + 10, + 908, + }, + DictWord{7, 11, 819}, + DictWord{9, 11, 26}, + DictWord{9, 11, 392}, + DictWord{10, 11, 152}, + DictWord{10, 11, 226}, + DictWord{11, 11, 19}, + DictWord{ + 12, + 11, + 276, + }, + DictWord{12, 11, 426}, + DictWord{12, 11, 589}, + DictWord{13, 11, 460}, + DictWord{15, 11, 97}, + DictWord{19, 11, 48}, + DictWord{148, 11, 104}, + DictWord{135, 11, 51}, + DictWord{4, 0, 718}, + DictWord{135, 0, 1216}, + DictWord{6, 0, 1896}, + DictWord{6, 0, 1905}, + DictWord{6, 0, 1912}, + DictWord{9, 0, 947}, + DictWord{ + 9, + 0, + 974, + }, + DictWord{12, 0, 809}, + DictWord{12, 0, 850}, + DictWord{12, 0, 858}, + DictWord{12, 0, 874}, + DictWord{12, 0, 887}, + DictWord{12, 0, 904}, + DictWord{ + 12, + 0, + 929, + }, + DictWord{12, 0, 948}, + DictWord{12, 0, 952}, + DictWord{15, 0, 198}, + DictWord{15, 0, 206}, + DictWord{15, 0, 220}, + DictWord{15, 0, 227}, + DictWord{15, 0, 247}, + DictWord{18, 0, 188}, + DictWord{21, 0, 48}, + DictWord{21, 0, 50}, + DictWord{24, 0, 25}, + DictWord{24, 0, 29}, + DictWord{7, 11, 761}, + DictWord{7, 11, 1051}, + DictWord{ + 137, + 11, + 545, + }, + DictWord{5, 0, 124}, + DictWord{5, 0, 144}, + DictWord{6, 0, 548}, + DictWord{7, 0, 15}, + DictWord{7, 0, 153}, + DictWord{137, 0, 629}, + DictWord{ + 135, + 11, + 606, + }, + DictWord{135, 10, 2014}, + DictWord{7, 10, 2007}, + DictWord{9, 11, 46}, + DictWord{9, 10, 101}, + DictWord{9, 10, 450}, + DictWord{10, 10, 66}, + DictWord{ + 10, + 10, + 842, + }, + DictWord{11, 10, 536}, + DictWord{140, 10, 587}, + DictWord{6, 0, 75}, + DictWord{7, 0, 1531}, + DictWord{8, 0, 416}, + DictWord{9, 0, 240}, + DictWord{9, 0, 275}, + DictWord{10, 0, 100}, + DictWord{11, 0, 658}, + DictWord{11, 0, 979}, + DictWord{12, 0, 86}, + DictWord{14, 0, 207}, + DictWord{15, 0, 20}, + DictWord{143, 0, 25}, + DictWord{ + 5, + 0, + 141, + }, + DictWord{5, 0, 915}, + DictWord{6, 0, 1783}, + DictWord{7, 0, 211}, + DictWord{7, 0, 698}, + DictWord{7, 0, 1353}, + DictWord{9, 0, 83}, + DictWord{9, 0, 281}, + DictWord{ + 10, + 0, + 376, + }, + DictWord{10, 0, 431}, + DictWord{11, 0, 543}, + DictWord{12, 0, 664}, + DictWord{13, 0, 280}, + DictWord{13, 0, 428}, + DictWord{14, 0, 61}, + DictWord{ + 14, + 0, + 128, + }, + DictWord{17, 0, 52}, + DictWord{145, 0, 81}, + DictWord{132, 11, 674}, + DictWord{135, 0, 533}, + DictWord{149, 0, 6}, + DictWord{132, 11, 770}, + DictWord{ + 133, + 0, + 538, + }, + DictWord{5, 11, 79}, + DictWord{7, 11, 1027}, + DictWord{7, 11, 1477}, + DictWord{139, 11, 52}, + DictWord{139, 10, 62}, + DictWord{4, 0, 338}, + DictWord{ + 133, + 0, + 400, + }, + DictWord{5, 11, 789}, + DictWord{134, 11, 195}, + DictWord{4, 11, 251}, + DictWord{4, 11, 688}, + DictWord{7, 11, 513}, + DictWord{7, 11, 1284}, + DictWord{ + 9, + 11, + 87, + }, + DictWord{138, 11, 365}, + DictWord{134, 10, 1766}, + DictWord{6, 0, 0}, + DictWord{7, 0, 84}, + DictWord{11, 0, 895}, + DictWord{145, 0, 11}, + DictWord{ + 139, + 0, + 892, + }, + DictWord{4, 0, 221}, + DictWord{5, 0, 659}, + DictWord{7, 0, 697}, + DictWord{7, 0, 1211}, + DictWord{138, 0, 284}, + DictWord{133, 0, 989}, + DictWord{ + 133, + 11, + 889, + }, + DictWord{4, 11, 160}, + DictWord{5, 11, 330}, + DictWord{7, 11, 1434}, + DictWord{136, 11, 174}, + DictWord{6, 10, 1665}, + DictWord{7, 10, 256}, + DictWord{ + 7, + 10, + 1388, + }, + DictWord{10, 10, 499}, + DictWord{139, 10, 670}, + DictWord{7, 0, 848}, + DictWord{4, 10, 22}, + DictWord{5, 10, 10}, + DictWord{136, 10, 97}, + DictWord{ + 138, + 0, + 507, + }, + DictWord{133, 10, 481}, + DictWord{4, 0, 188}, + DictWord{135, 0, 805}, + DictWord{5, 0, 884}, + DictWord{6, 0, 732}, + DictWord{139, 0, 991}, + DictWord{ + 135, + 11, + 968, + }, + DictWord{11, 11, 636}, + DictWord{15, 11, 145}, + DictWord{17, 11, 34}, + DictWord{19, 11, 50}, + DictWord{151, 11, 20}, + DictWord{7, 0, 959}, + DictWord{ + 16, + 0, + 60, + }, + DictWord{6, 10, 134}, + DictWord{7, 10, 437}, + DictWord{9, 10, 37}, + DictWord{14, 10, 285}, + DictWord{142, 10, 371}, + DictWord{7, 10, 486}, + DictWord{ + 8, + 10, + 155, + }, + DictWord{11, 10, 93}, + DictWord{140, 10, 164}, + DictWord{134, 0, 1653}, + DictWord{7, 0, 337}, + DictWord{133, 10, 591}, + DictWord{6, 0, 1989}, + DictWord{ + 8, + 0, + 922, + }, + DictWord{8, 0, 978}, + DictWord{133, 11, 374}, + DictWord{132, 0, 638}, + DictWord{138, 0, 500}, + DictWord{133, 11, 731}, + DictWord{5, 10, 380}, + DictWord{ + 5, + 10, + 650, + }, + DictWord{136, 10, 310}, + DictWord{138, 11, 381}, + DictWord{4, 10, 364}, + DictWord{7, 10, 1156}, + DictWord{7, 10, 1187}, + DictWord{137, 10, 409}, + DictWord{137, 11, 224}, + DictWord{140, 0, 166}, + DictWord{134, 10, 482}, + DictWord{4, 11, 626}, + DictWord{5, 11, 642}, + DictWord{6, 11, 425}, + DictWord{ + 10, + 11, + 202, + }, + DictWord{139, 11, 141}, + DictWord{4, 10, 781}, + DictWord{6, 10, 487}, + DictWord{7, 10, 926}, + DictWord{8, 10, 263}, + DictWord{139, 10, 500}, + DictWord{ + 135, + 0, + 418, + }, + DictWord{4, 10, 94}, + DictWord{135, 10, 1265}, + DictWord{136, 0, 760}, + DictWord{132, 10, 417}, + DictWord{136, 11, 835}, + DictWord{5, 10, 348}, + DictWord{134, 10, 522}, + DictWord{6, 0, 1277}, + DictWord{134, 0, 1538}, + DictWord{139, 11, 541}, + DictWord{135, 11, 1597}, + DictWord{5, 11, 384}, + DictWord{ + 8, + 11, + 455, + }, + DictWord{140, 11, 48}, + DictWord{136, 0, 770}, + DictWord{5, 11, 264}, + DictWord{134, 11, 184}, + DictWord{4, 0, 89}, + DictWord{5, 0, 489}, + DictWord{ + 6, + 0, + 315, + }, + DictWord{7, 0, 553}, + DictWord{7, 0, 1745}, + DictWord{138, 0, 243}, + DictWord{4, 10, 408}, + DictWord{4, 10, 741}, + DictWord{135, 10, 500}, + DictWord{ + 134, + 0, + 1396, + }, + DictWord{133, 0, 560}, + DictWord{6, 0, 1658}, + DictWord{9, 0, 3}, + DictWord{10, 0, 154}, + DictWord{11, 0, 641}, + DictWord{13, 0, 85}, + DictWord{13, 0, 201}, + DictWord{141, 0, 346}, + DictWord{135, 11, 1595}, + DictWord{5, 11, 633}, + DictWord{6, 11, 28}, + DictWord{7, 11, 219}, + DictWord{135, 11, 1323}, + DictWord{ + 9, + 11, + 769, + }, + DictWord{140, 11, 185}, + DictWord{135, 11, 785}, + DictWord{7, 11, 359}, + DictWord{8, 11, 243}, + DictWord{140, 11, 175}, + DictWord{138, 0, 586}, + DictWord{ + 7, + 0, + 1271, + }, + DictWord{134, 10, 73}, + DictWord{132, 11, 105}, + DictWord{4, 0, 166}, + DictWord{5, 0, 505}, + DictWord{134, 0, 1670}, + DictWord{133, 10, 576}, + DictWord{4, 11, 324}, + DictWord{138, 11, 104}, + DictWord{142, 10, 231}, + DictWord{6, 0, 637}, + DictWord{7, 10, 1264}, + DictWord{7, 10, 1678}, + DictWord{ + 11, + 10, + 945, + }, + DictWord{12, 10, 341}, + DictWord{12, 10, 471}, + DictWord{12, 10, 569}, + DictWord{23, 11, 21}, + DictWord{151, 11, 23}, + DictWord{8, 11, 559}, + DictWord{ + 141, + 11, + 109, + }, + DictWord{134, 0, 1947}, + DictWord{7, 0, 445}, + DictWord{8, 0, 307}, + DictWord{8, 0, 704}, + DictWord{10, 0, 41}, + DictWord{10, 0, 439}, + DictWord{ + 11, + 0, + 237, + }, + DictWord{11, 0, 622}, + DictWord{140, 0, 201}, + DictWord{135, 11, 963}, + DictWord{135, 0, 1977}, + DictWord{4, 0, 189}, + DictWord{5, 0, 713}, + DictWord{ + 136, + 0, + 57, + }, + DictWord{138, 0, 371}, + DictWord{135, 10, 538}, + DictWord{132, 0, 552}, + DictWord{6, 0, 883}, + DictWord{133, 10, 413}, + DictWord{6, 0, 923}, + DictWord{ + 132, + 11, + 758, + }, + DictWord{138, 11, 215}, + DictWord{136, 10, 495}, + DictWord{7, 10, 54}, + DictWord{8, 10, 312}, + DictWord{10, 10, 191}, + DictWord{10, 10, 614}, + DictWord{140, 10, 567}, + DictWord{7, 11, 351}, + DictWord{139, 11, 128}, + DictWord{7, 0, 875}, + DictWord{6, 10, 468}, + DictWord{7, 10, 1478}, + DictWord{8, 10, 530}, + DictWord{142, 10, 290}, + DictWord{135, 0, 1788}, + DictWord{17, 0, 49}, + DictWord{133, 11, 918}, + DictWord{12, 11, 398}, + DictWord{20, 11, 39}, + DictWord{ + 21, + 11, + 11, + }, + DictWord{150, 11, 41}, + DictWord{10, 0, 661}, + DictWord{6, 10, 484}, + DictWord{135, 10, 822}, + DictWord{135, 0, 1945}, + DictWord{134, 0, 794}, + DictWord{ + 137, + 10, + 900, + }, + DictWord{135, 10, 1335}, + DictWord{6, 10, 1724}, + DictWord{135, 10, 2022}, + DictWord{132, 11, 340}, + DictWord{134, 0, 1135}, + DictWord{ + 4, + 0, + 784, + }, + DictWord{133, 0, 745}, + DictWord{5, 0, 84}, + DictWord{134, 0, 163}, + DictWord{133, 0, 410}, + DictWord{4, 0, 976}, + DictWord{5, 11, 985}, + DictWord{7, 11, 509}, + DictWord{7, 11, 529}, + DictWord{145, 11, 96}, + DictWord{132, 10, 474}, + DictWord{134, 0, 703}, + DictWord{135, 11, 1919}, + DictWord{5, 0, 322}, + DictWord{ + 8, + 0, + 186, + }, + DictWord{9, 0, 262}, + DictWord{10, 0, 187}, + DictWord{142, 0, 208}, + DictWord{135, 10, 1504}, + DictWord{133, 0, 227}, + DictWord{9, 0, 560}, + DictWord{ + 13, + 0, + 208, + }, + DictWord{133, 10, 305}, + DictWord{132, 11, 247}, + DictWord{7, 0, 1395}, + DictWord{8, 0, 486}, + DictWord{9, 0, 236}, + DictWord{9, 0, 878}, + DictWord{ + 10, + 0, + 218, + }, + DictWord{11, 0, 95}, + DictWord{19, 0, 17}, + DictWord{147, 0, 31}, + DictWord{7, 0, 2043}, + DictWord{8, 0, 672}, + DictWord{141, 0, 448}, + DictWord{4, 11, 184}, + DictWord{5, 11, 390}, + DictWord{6, 11, 337}, + DictWord{7, 11, 23}, + DictWord{7, 11, 494}, + DictWord{7, 11, 618}, + DictWord{7, 11, 1456}, + DictWord{8, 11, 27}, + DictWord{ + 8, + 11, + 599, + }, + DictWord{10, 11, 153}, + DictWord{139, 11, 710}, + DictWord{135, 0, 466}, + DictWord{135, 10, 1236}, + DictWord{6, 0, 167}, + DictWord{7, 0, 186}, + DictWord{7, 0, 656}, + DictWord{10, 0, 643}, + DictWord{4, 10, 480}, + DictWord{6, 10, 302}, + DictWord{6, 10, 1642}, + DictWord{7, 10, 837}, + DictWord{7, 10, 1547}, + DictWord{ + 7, + 10, + 1657, + }, + DictWord{8, 10, 429}, + DictWord{9, 10, 228}, + DictWord{13, 10, 289}, + DictWord{13, 10, 343}, + DictWord{147, 10, 101}, + DictWord{134, 0, 1428}, + DictWord{134, 0, 1440}, + DictWord{5, 0, 412}, + DictWord{7, 10, 278}, + DictWord{10, 10, 739}, + DictWord{11, 10, 708}, + DictWord{141, 10, 348}, + DictWord{ + 134, + 0, + 1118, + }, + DictWord{136, 0, 562}, + DictWord{148, 11, 46}, + DictWord{9, 0, 316}, + DictWord{139, 0, 256}, + DictWord{134, 0, 1771}, + DictWord{135, 0, 1190}, + DictWord{137, 0, 132}, + DictWord{10, 11, 227}, + DictWord{11, 11, 497}, + DictWord{11, 11, 709}, + DictWord{140, 11, 415}, + DictWord{143, 0, 66}, + DictWord{6, 11, 360}, + DictWord{7, 11, 1664}, + DictWord{136, 11, 478}, + DictWord{144, 10, 28}, + DictWord{4, 0, 317}, + DictWord{135, 0, 1279}, + DictWord{5, 0, 63}, + DictWord{ + 133, + 0, + 509, + }, + DictWord{136, 11, 699}, + DictWord{145, 10, 36}, + DictWord{134, 0, 1475}, + DictWord{11, 11, 343}, + DictWord{142, 11, 127}, + DictWord{132, 11, 739}, + DictWord{132, 0, 288}, + DictWord{135, 11, 1757}, + DictWord{8, 0, 89}, + DictWord{8, 0, 620}, + DictWord{9, 0, 608}, + DictWord{11, 0, 628}, + DictWord{12, 0, 322}, + DictWord{143, 0, 124}, + DictWord{134, 0, 1225}, + DictWord{7, 0, 1189}, + DictWord{4, 11, 67}, + DictWord{5, 11, 422}, + DictWord{6, 10, 363}, + DictWord{7, 11, 1037}, + DictWord{7, 11, 1289}, + DictWord{7, 11, 1555}, + DictWord{7, 10, 1955}, + DictWord{8, 10, 725}, + DictWord{9, 11, 741}, + DictWord{145, 11, 108}, + DictWord{ + 134, + 0, + 1468, + }, + DictWord{6, 0, 689}, + DictWord{134, 0, 1451}, + DictWord{138, 0, 120}, + DictWord{151, 0, 1}, + DictWord{137, 10, 805}, + DictWord{142, 0, 329}, + DictWord{ + 5, + 10, + 813, + }, + DictWord{135, 10, 2046}, + DictWord{135, 0, 226}, + DictWord{138, 11, 96}, + DictWord{7, 0, 1855}, + DictWord{5, 10, 712}, + DictWord{11, 10, 17}, + DictWord{13, 10, 321}, + DictWord{144, 10, 67}, + DictWord{9, 0, 461}, + DictWord{6, 10, 320}, + DictWord{7, 10, 781}, + DictWord{7, 10, 1921}, + DictWord{9, 10, 55}, + DictWord{ + 10, + 10, + 186, + }, + DictWord{10, 10, 273}, + DictWord{10, 10, 664}, + DictWord{10, 10, 801}, + DictWord{11, 10, 996}, + DictWord{11, 10, 997}, + DictWord{13, 10, 157}, + DictWord{142, 10, 170}, + DictWord{8, 11, 203}, + DictWord{8, 10, 271}, + DictWord{11, 11, 823}, + DictWord{11, 11, 846}, + DictWord{12, 11, 482}, + DictWord{ + 13, + 11, + 133, + }, + DictWord{13, 11, 277}, + DictWord{13, 11, 302}, + DictWord{13, 11, 464}, + DictWord{14, 11, 205}, + DictWord{142, 11, 221}, + DictWord{135, 0, 1346}, + DictWord{4, 11, 449}, + DictWord{133, 11, 718}, + DictWord{134, 0, 85}, + DictWord{14, 0, 299}, + DictWord{7, 10, 103}, + DictWord{7, 10, 863}, + DictWord{11, 10, 184}, + DictWord{145, 10, 62}, + DictWord{4, 11, 355}, + DictWord{6, 11, 311}, + DictWord{9, 11, 256}, + DictWord{138, 11, 404}, + DictWord{137, 10, 659}, + DictWord{ + 138, + 11, + 758, + }, + DictWord{133, 11, 827}, + DictWord{5, 11, 64}, + DictWord{140, 11, 581}, + DictWord{134, 0, 1171}, + DictWord{4, 11, 442}, + DictWord{7, 11, 1047}, + DictWord{ + 7, + 11, + 1352, + }, + DictWord{135, 11, 1643}, + DictWord{132, 0, 980}, + DictWord{5, 11, 977}, + DictWord{6, 11, 288}, + DictWord{7, 11, 528}, + DictWord{135, 11, 1065}, + DictWord{5, 0, 279}, + DictWord{6, 0, 235}, + DictWord{7, 0, 468}, + DictWord{8, 0, 446}, + DictWord{9, 0, 637}, + DictWord{10, 0, 717}, + DictWord{11, 0, 738}, + DictWord{ + 140, + 0, + 514, + }, + DictWord{132, 0, 293}, + DictWord{11, 10, 337}, + DictWord{142, 10, 303}, + DictWord{136, 11, 285}, + DictWord{5, 0, 17}, + DictWord{6, 0, 371}, + DictWord{ + 9, + 0, + 528, + }, + DictWord{12, 0, 364}, + DictWord{132, 11, 254}, + DictWord{5, 10, 77}, + DictWord{7, 10, 1455}, + DictWord{10, 10, 843}, + DictWord{147, 10, 73}, + DictWord{ + 150, + 0, + 5, + }, + DictWord{132, 10, 458}, + DictWord{6, 11, 12}, + DictWord{7, 11, 1219}, + DictWord{145, 11, 73}, + DictWord{135, 10, 1420}, + DictWord{6, 10, 109}, + DictWord{138, 10, 382}, + DictWord{135, 11, 125}, + DictWord{6, 10, 330}, + DictWord{7, 10, 1084}, + DictWord{139, 10, 142}, + DictWord{6, 11, 369}, + DictWord{ + 6, + 11, + 502, + }, + DictWord{7, 11, 1036}, + DictWord{8, 11, 348}, + DictWord{9, 11, 452}, + DictWord{10, 11, 26}, + DictWord{11, 11, 224}, + DictWord{11, 11, 387}, + DictWord{ + 11, + 11, + 772, + }, + DictWord{12, 11, 95}, + DictWord{12, 11, 629}, + DictWord{13, 11, 195}, + DictWord{13, 11, 207}, + DictWord{13, 11, 241}, + DictWord{14, 11, 260}, + DictWord{ + 14, + 11, + 270, + }, + DictWord{143, 11, 140}, + DictWord{132, 11, 269}, + DictWord{5, 11, 480}, + DictWord{7, 11, 532}, + DictWord{7, 11, 1197}, + DictWord{7, 11, 1358}, + DictWord{8, 11, 291}, + DictWord{11, 11, 349}, + DictWord{142, 11, 396}, + DictWord{150, 0, 48}, + DictWord{10, 0, 601}, + DictWord{13, 0, 353}, + DictWord{141, 0, 376}, + DictWord{5, 0, 779}, + DictWord{5, 0, 807}, + DictWord{6, 0, 1655}, + DictWord{134, 0, 1676}, + DictWord{142, 11, 223}, + DictWord{4, 0, 196}, + DictWord{5, 0, 558}, + DictWord{133, 0, 949}, + DictWord{148, 11, 15}, + DictWord{135, 11, 1764}, + DictWord{134, 0, 1322}, + DictWord{132, 0, 752}, + DictWord{139, 0, 737}, + DictWord{ + 135, + 11, + 657, + }, + DictWord{136, 11, 533}, + DictWord{135, 0, 412}, + DictWord{4, 0, 227}, + DictWord{5, 0, 159}, + DictWord{5, 0, 409}, + DictWord{7, 0, 80}, + DictWord{8, 0, 556}, + DictWord{10, 0, 479}, + DictWord{12, 0, 418}, + DictWord{14, 0, 50}, + DictWord{14, 0, 123}, + DictWord{14, 0, 192}, + DictWord{14, 0, 249}, + DictWord{14, 0, 295}, + DictWord{143, 0, 27}, + DictWord{7, 0, 1470}, + DictWord{8, 0, 66}, + DictWord{8, 0, 137}, + DictWord{8, 0, 761}, + DictWord{9, 0, 638}, + DictWord{11, 0, 80}, + DictWord{11, 0, 212}, + DictWord{11, 0, 368}, + DictWord{11, 0, 418}, + DictWord{12, 0, 8}, + DictWord{13, 0, 15}, + DictWord{16, 0, 61}, + DictWord{17, 0, 59}, + DictWord{19, 0, 28}, + DictWord{ + 148, + 0, + 84, + }, + DictWord{135, 10, 1985}, + DictWord{4, 11, 211}, + DictWord{4, 11, 332}, + DictWord{5, 11, 335}, + DictWord{6, 11, 238}, + DictWord{7, 11, 269}, + DictWord{ + 7, + 11, + 811, + }, + DictWord{7, 11, 1797}, + DictWord{8, 10, 122}, + DictWord{8, 11, 836}, + DictWord{9, 11, 507}, + DictWord{141, 11, 242}, + DictWord{6, 0, 683}, + DictWord{ + 134, + 0, + 1252, + }, + DictWord{4, 0, 873}, + DictWord{132, 10, 234}, + DictWord{134, 0, 835}, + DictWord{6, 0, 38}, + DictWord{7, 0, 1220}, + DictWord{8, 0, 185}, + DictWord{8, 0, 256}, + DictWord{9, 0, 22}, + DictWord{9, 0, 331}, + DictWord{10, 0, 738}, + DictWord{11, 0, 205}, + DictWord{11, 0, 540}, + DictWord{11, 0, 746}, + DictWord{13, 0, 465}, + DictWord{ + 14, + 0, + 88, + }, + DictWord{142, 0, 194}, + DictWord{138, 0, 986}, + DictWord{5, 11, 1009}, + DictWord{12, 11, 582}, + DictWord{146, 11, 131}, + DictWord{4, 0, 159}, + DictWord{ + 6, + 0, + 115, + }, + DictWord{7, 0, 252}, + DictWord{7, 0, 257}, + DictWord{7, 0, 1928}, + DictWord{8, 0, 69}, + DictWord{9, 0, 384}, + DictWord{10, 0, 91}, + DictWord{10, 0, 615}, + DictWord{ + 12, + 0, + 375, + }, + DictWord{14, 0, 235}, + DictWord{18, 0, 117}, + DictWord{147, 0, 123}, + DictWord{133, 0, 911}, + DictWord{136, 0, 278}, + DictWord{5, 10, 430}, + DictWord{ + 5, + 10, + 932, + }, + DictWord{6, 10, 131}, + DictWord{7, 10, 417}, + DictWord{9, 10, 522}, + DictWord{11, 10, 314}, + DictWord{141, 10, 390}, + DictWord{14, 10, 149}, + DictWord{14, 10, 399}, + DictWord{143, 10, 57}, + DictWord{4, 0, 151}, + DictWord{7, 0, 1567}, + DictWord{136, 0, 749}, + DictWord{5, 11, 228}, + DictWord{6, 11, 203}, + DictWord{ + 7, + 11, + 156, + }, + DictWord{8, 11, 347}, + DictWord{137, 11, 265}, + DictWord{132, 10, 507}, + DictWord{10, 0, 989}, + DictWord{140, 0, 956}, + DictWord{133, 0, 990}, + DictWord{5, 0, 194}, + DictWord{6, 0, 927}, + DictWord{7, 0, 1662}, + DictWord{9, 0, 90}, + DictWord{140, 0, 564}, + DictWord{4, 10, 343}, + DictWord{133, 10, 511}, + DictWord{133, 0, 425}, + DictWord{7, 10, 455}, + DictWord{138, 10, 591}, + DictWord{4, 0, 774}, + DictWord{7, 11, 476}, + DictWord{7, 11, 1592}, + DictWord{138, 11, 87}, + DictWord{5, 0, 971}, + DictWord{135, 10, 1381}, + DictWord{5, 11, 318}, + DictWord{147, 11, 121}, + DictWord{5, 11, 291}, + DictWord{7, 11, 765}, + DictWord{9, 11, 389}, + DictWord{140, 11, 548}, + DictWord{134, 10, 575}, + DictWord{4, 0, 827}, + DictWord{12, 0, 646}, + DictWord{12, 0, 705}, + DictWord{12, 0, 712}, + DictWord{140, 0, 714}, + DictWord{139, 0, 752}, + DictWord{137, 0, 662}, + DictWord{5, 0, 72}, + DictWord{6, 0, 264}, + DictWord{7, 0, 21}, + DictWord{7, 0, 46}, + DictWord{7, 0, 2013}, + DictWord{ + 8, + 0, + 215, + }, + DictWord{8, 0, 513}, + DictWord{10, 0, 266}, + DictWord{139, 0, 22}, + DictWord{139, 11, 522}, + DictWord{6, 0, 239}, + DictWord{7, 0, 118}, + DictWord{10, 0, 95}, + DictWord{11, 0, 603}, + DictWord{13, 0, 443}, + DictWord{14, 0, 160}, + DictWord{143, 0, 4}, + DictWord{6, 0, 431}, + DictWord{134, 0, 669}, + DictWord{7, 10, 1127}, + DictWord{ + 7, + 10, + 1572, + }, + DictWord{10, 10, 297}, + DictWord{10, 10, 422}, + DictWord{11, 10, 764}, + DictWord{11, 10, 810}, + DictWord{12, 10, 264}, + DictWord{13, 10, 102}, + DictWord{13, 10, 300}, + DictWord{13, 10, 484}, + DictWord{14, 10, 147}, + DictWord{14, 10, 229}, + DictWord{17, 10, 71}, + DictWord{18, 10, 118}, + DictWord{ + 147, + 10, + 120, + }, + DictWord{5, 0, 874}, + DictWord{6, 0, 1677}, + DictWord{15, 0, 0}, + DictWord{10, 11, 525}, + DictWord{139, 11, 82}, + DictWord{6, 0, 65}, + DictWord{7, 0, 939}, + DictWord{ + 7, + 0, + 1172, + }, + DictWord{7, 0, 1671}, + DictWord{9, 0, 540}, + DictWord{10, 0, 696}, + DictWord{11, 0, 265}, + DictWord{11, 0, 732}, + DictWord{11, 0, 928}, + DictWord{ + 11, + 0, + 937, + }, + DictWord{141, 0, 438}, + DictWord{134, 0, 1350}, + DictWord{136, 11, 547}, + DictWord{132, 11, 422}, + DictWord{5, 11, 355}, + DictWord{145, 11, 0}, + DictWord{137, 11, 905}, + DictWord{5, 0, 682}, + DictWord{135, 0, 1887}, + DictWord{132, 0, 809}, + DictWord{4, 0, 696}, + DictWord{133, 11, 865}, + DictWord{6, 0, 1074}, + DictWord{6, 0, 1472}, + DictWord{14, 10, 35}, + DictWord{142, 10, 191}, + DictWord{5, 11, 914}, + DictWord{134, 11, 1625}, + DictWord{133, 11, 234}, + DictWord{ + 135, + 11, + 1383, + }, + DictWord{137, 11, 780}, + DictWord{132, 10, 125}, + DictWord{4, 0, 726}, + DictWord{133, 0, 630}, + DictWord{8, 0, 802}, + DictWord{136, 0, 838}, + DictWord{132, 10, 721}, + DictWord{6, 0, 1337}, + DictWord{7, 0, 776}, + DictWord{19, 0, 56}, + DictWord{136, 10, 145}, + DictWord{132, 0, 970}, + DictWord{7, 10, 792}, + DictWord{8, 10, 147}, + DictWord{10, 10, 821}, + DictWord{139, 10, 1021}, + DictWord{139, 10, 970}, + DictWord{8, 0, 940}, + DictWord{137, 0, 797}, + DictWord{ + 135, + 11, + 1312, + }, + DictWord{9, 0, 248}, + DictWord{10, 0, 400}, + DictWord{7, 11, 816}, + DictWord{7, 11, 1241}, + DictWord{7, 10, 1999}, + DictWord{9, 11, 283}, + DictWord{ + 9, + 11, + 520, + }, + DictWord{10, 11, 213}, + DictWord{10, 11, 307}, + DictWord{10, 11, 463}, + DictWord{10, 11, 671}, + DictWord{10, 11, 746}, + DictWord{11, 11, 401}, + DictWord{ + 11, + 11, + 794, + }, + DictWord{12, 11, 517}, + DictWord{18, 11, 107}, + DictWord{147, 11, 115}, + DictWord{6, 0, 1951}, + DictWord{134, 0, 2040}, + DictWord{ + 135, + 11, + 339, + }, + DictWord{13, 0, 41}, + DictWord{15, 0, 93}, + DictWord{5, 10, 168}, + DictWord{5, 10, 930}, + DictWord{8, 10, 74}, + DictWord{9, 10, 623}, + DictWord{12, 10, 500}, + DictWord{140, 10, 579}, + DictWord{6, 0, 118}, + DictWord{7, 0, 215}, + DictWord{7, 0, 1521}, + DictWord{140, 0, 11}, + DictWord{6, 10, 220}, + DictWord{7, 10, 1101}, + DictWord{141, 10, 105}, + DictWord{6, 11, 421}, + DictWord{7, 11, 61}, + DictWord{7, 11, 1540}, + DictWord{10, 11, 11}, + DictWord{138, 11, 501}, + DictWord{7, 0, 615}, + DictWord{138, 0, 251}, + DictWord{140, 11, 631}, + DictWord{135, 0, 1044}, + DictWord{6, 10, 19}, + DictWord{7, 10, 1413}, + DictWord{139, 10, 428}, + DictWord{ + 133, + 0, + 225, + }, + DictWord{7, 10, 96}, + DictWord{8, 10, 401}, + DictWord{8, 10, 703}, + DictWord{137, 10, 896}, + DictWord{145, 10, 116}, + DictWord{6, 11, 102}, + DictWord{ + 7, + 11, + 72, + }, + DictWord{15, 11, 142}, + DictWord{147, 11, 67}, + DictWord{7, 10, 1961}, + DictWord{7, 10, 1965}, + DictWord{8, 10, 702}, + DictWord{136, 10, 750}, + DictWord{ + 7, + 10, + 2030, + }, + DictWord{8, 10, 150}, + DictWord{8, 10, 737}, + DictWord{12, 10, 366}, + DictWord{151, 11, 30}, + DictWord{4, 0, 370}, + DictWord{5, 0, 756}, + DictWord{ + 7, + 0, + 1326, + }, + DictWord{135, 11, 823}, + DictWord{8, 10, 800}, + DictWord{9, 10, 148}, + DictWord{9, 10, 872}, + DictWord{9, 10, 890}, + DictWord{11, 10, 309}, + DictWord{ + 11, + 10, + 1001, + }, + DictWord{13, 10, 267}, + DictWord{141, 10, 323}, + DictWord{6, 0, 1662}, + DictWord{7, 0, 48}, + DictWord{8, 0, 771}, + DictWord{10, 0, 116}, + DictWord{ + 13, + 0, + 104, + }, + DictWord{14, 0, 105}, + DictWord{14, 0, 184}, + DictWord{15, 0, 168}, + DictWord{19, 0, 92}, + DictWord{148, 0, 68}, + DictWord{10, 0, 209}, + DictWord{ + 135, + 11, + 1870, + }, + DictWord{7, 11, 68}, + DictWord{8, 11, 48}, + DictWord{8, 11, 88}, + DictWord{8, 11, 582}, + DictWord{8, 11, 681}, + DictWord{9, 11, 373}, + DictWord{9, 11, 864}, + DictWord{11, 11, 157}, + DictWord{11, 11, 336}, + DictWord{11, 11, 843}, + DictWord{148, 11, 27}, + DictWord{134, 0, 930}, + DictWord{4, 11, 88}, + DictWord{5, 11, 137}, + DictWord{5, 11, 174}, + DictWord{5, 11, 777}, + DictWord{6, 11, 1664}, + DictWord{6, 11, 1725}, + DictWord{7, 11, 77}, + DictWord{7, 11, 426}, + DictWord{7, 11, 1317}, + DictWord{7, 11, 1355}, + DictWord{8, 11, 126}, + DictWord{8, 11, 563}, + DictWord{9, 11, 523}, + DictWord{9, 11, 750}, + DictWord{10, 11, 310}, + DictWord{10, 11, 836}, + DictWord{11, 11, 42}, + DictWord{11, 11, 318}, + DictWord{11, 11, 731}, + DictWord{12, 11, 68}, + DictWord{12, 11, 92}, + DictWord{12, 11, 507}, + DictWord{12, 11, 692}, + DictWord{13, 11, 81}, + DictWord{13, 11, 238}, + DictWord{13, 11, 374}, + DictWord{18, 11, 138}, + DictWord{19, 11, 78}, + DictWord{19, 11, 111}, + DictWord{20, 11, 55}, + DictWord{20, 11, 77}, + DictWord{148, 11, 92}, + DictWord{4, 11, 938}, + DictWord{135, 11, 1831}, + DictWord{5, 10, 547}, + DictWord{7, 10, 424}, + DictWord{ + 8, + 11, + 617, + }, + DictWord{138, 11, 351}, + DictWord{6, 0, 1286}, + DictWord{6, 11, 1668}, + DictWord{7, 11, 1499}, + DictWord{8, 11, 117}, + DictWord{9, 11, 314}, + DictWord{ + 138, + 11, + 174, + }, + DictWord{6, 0, 759}, + DictWord{6, 0, 894}, + DictWord{7, 11, 707}, + DictWord{139, 11, 563}, + DictWord{4, 0, 120}, + DictWord{135, 0, 1894}, + DictWord{ + 9, + 0, + 385, + }, + DictWord{149, 0, 17}, + DictWord{138, 0, 429}, + DictWord{133, 11, 403}, + DictWord{5, 0, 820}, + DictWord{135, 0, 931}, + DictWord{10, 0, 199}, + DictWord{ + 133, + 10, + 133, + }, + DictWord{6, 0, 151}, + DictWord{6, 0, 1675}, + DictWord{7, 0, 383}, + DictWord{151, 0, 10}, + DictWord{6, 0, 761}, + DictWord{136, 10, 187}, + DictWord{ + 8, + 0, + 365, + }, + DictWord{10, 10, 0}, + DictWord{10, 10, 818}, + DictWord{139, 10, 988}, + DictWord{4, 11, 44}, + DictWord{5, 11, 311}, + DictWord{6, 11, 156}, + DictWord{ + 7, + 11, + 639, + }, + DictWord{7, 11, 762}, + DictWord{7, 11, 1827}, + DictWord{9, 11, 8}, + DictWord{9, 11, 462}, + DictWord{148, 11, 83}, + DictWord{4, 11, 346}, + DictWord{7, 11, 115}, + DictWord{9, 11, 180}, + DictWord{9, 11, 456}, + DictWord{138, 11, 363}, + DictWord{136, 10, 685}, + DictWord{7, 0, 1086}, + DictWord{145, 0, 46}, + DictWord{ + 6, + 0, + 1624, + }, + DictWord{11, 0, 11}, + DictWord{12, 0, 422}, + DictWord{13, 0, 444}, + DictWord{142, 0, 360}, + DictWord{6, 0, 1020}, + DictWord{6, 0, 1260}, + DictWord{ + 134, + 0, + 1589, + }, + DictWord{4, 0, 43}, + DictWord{5, 0, 344}, + DictWord{5, 0, 357}, + DictWord{14, 0, 472}, + DictWord{150, 0, 58}, + DictWord{6, 0, 1864}, + DictWord{6, 0, 1866}, + DictWord{6, 0, 1868}, + DictWord{6, 0, 1869}, + DictWord{6, 0, 1874}, + DictWord{6, 0, 1877}, + DictWord{6, 0, 1903}, + DictWord{6, 0, 1911}, + DictWord{9, 0, 920}, + DictWord{ + 9, + 0, + 921, + }, + DictWord{9, 0, 924}, + DictWord{9, 0, 946}, + DictWord{9, 0, 959}, + DictWord{9, 0, 963}, + DictWord{9, 0, 970}, + DictWord{9, 0, 997}, + DictWord{9, 0, 1008}, + DictWord{ + 9, + 0, + 1017, + }, + DictWord{12, 0, 795}, + DictWord{12, 0, 797}, + DictWord{12, 0, 798}, + DictWord{12, 0, 800}, + DictWord{12, 0, 803}, + DictWord{12, 0, 811}, + DictWord{ + 12, + 0, + 820, + }, + DictWord{12, 0, 821}, + DictWord{12, 0, 839}, + DictWord{12, 0, 841}, + DictWord{12, 0, 848}, + DictWord{12, 0, 911}, + DictWord{12, 0, 921}, + DictWord{12, 0, 922}, + DictWord{12, 0, 925}, + DictWord{12, 0, 937}, + DictWord{12, 0, 944}, + DictWord{12, 0, 945}, + DictWord{12, 0, 953}, + DictWord{15, 0, 184}, + DictWord{15, 0, 191}, + DictWord{15, 0, 199}, + DictWord{15, 0, 237}, + DictWord{15, 0, 240}, + DictWord{15, 0, 243}, + DictWord{15, 0, 246}, + DictWord{18, 0, 203}, + DictWord{21, 0, 40}, + DictWord{ + 21, + 0, + 52, + }, + DictWord{21, 0, 57}, + DictWord{24, 0, 23}, + DictWord{24, 0, 28}, + DictWord{152, 0, 30}, + DictWord{134, 0, 725}, + DictWord{145, 11, 58}, + DictWord{133, 0, 888}, + DictWord{137, 10, 874}, + DictWord{4, 0, 711}, + DictWord{8, 10, 774}, + DictWord{10, 10, 670}, + DictWord{140, 10, 51}, + DictWord{144, 11, 40}, + DictWord{ + 6, + 11, + 185, + }, + DictWord{7, 11, 1899}, + DictWord{139, 11, 673}, + DictWord{137, 10, 701}, + DictWord{137, 0, 440}, + DictWord{4, 11, 327}, + DictWord{5, 11, 478}, + DictWord{ + 7, + 11, + 1332, + }, + DictWord{8, 11, 753}, + DictWord{140, 11, 227}, + DictWord{4, 10, 127}, + DictWord{5, 10, 350}, + DictWord{6, 10, 356}, + DictWord{8, 10, 426}, + DictWord{ + 9, + 10, + 572, + }, + DictWord{10, 10, 247}, + DictWord{139, 10, 312}, + DictWord{5, 11, 1020}, + DictWord{133, 11, 1022}, + DictWord{4, 11, 103}, + DictWord{ + 133, + 11, + 401, + }, + DictWord{6, 0, 1913}, + DictWord{6, 0, 1926}, + DictWord{6, 0, 1959}, + DictWord{9, 0, 914}, + DictWord{9, 0, 939}, + DictWord{9, 0, 952}, + DictWord{9, 0, 979}, + DictWord{ + 9, + 0, + 990, + }, + DictWord{9, 0, 998}, + DictWord{9, 0, 1003}, + DictWord{9, 0, 1023}, + DictWord{12, 0, 827}, + DictWord{12, 0, 834}, + DictWord{12, 0, 845}, + DictWord{ + 12, + 0, + 912, + }, + DictWord{12, 0, 935}, + DictWord{12, 0, 951}, + DictWord{15, 0, 172}, + DictWord{15, 0, 174}, + DictWord{18, 0, 198}, + DictWord{149, 0, 63}, + DictWord{5, 0, 958}, + DictWord{5, 0, 987}, + DictWord{4, 11, 499}, + DictWord{135, 11, 1421}, + DictWord{7, 0, 885}, + DictWord{6, 10, 59}, + DictWord{6, 10, 1762}, + DictWord{9, 10, 603}, + DictWord{141, 10, 397}, + DictWord{10, 11, 62}, + DictWord{141, 11, 164}, + DictWord{4, 0, 847}, + DictWord{135, 0, 326}, + DictWord{11, 0, 276}, + DictWord{142, 0, 293}, + DictWord{4, 0, 65}, + DictWord{5, 0, 479}, + DictWord{5, 0, 1004}, + DictWord{7, 0, 1913}, + DictWord{8, 0, 317}, + DictWord{9, 0, 302}, + DictWord{10, 0, 612}, + DictWord{ + 13, + 0, + 22, + }, + DictWord{132, 11, 96}, + DictWord{4, 0, 261}, + DictWord{135, 0, 510}, + DictWord{135, 0, 1514}, + DictWord{6, 10, 111}, + DictWord{7, 10, 4}, + DictWord{8, 10, 163}, + DictWord{8, 10, 776}, + DictWord{138, 10, 566}, + DictWord{4, 0, 291}, + DictWord{9, 0, 515}, + DictWord{12, 0, 152}, + DictWord{12, 0, 443}, + DictWord{13, 0, 392}, + DictWord{142, 0, 357}, + DictWord{7, 11, 399}, + DictWord{135, 11, 1492}, + DictWord{4, 0, 589}, + DictWord{139, 0, 282}, + DictWord{6, 11, 563}, + DictWord{ + 135, + 10, + 1994, + }, + DictWord{5, 10, 297}, + DictWord{135, 10, 1038}, + DictWord{4, 0, 130}, + DictWord{7, 0, 843}, + DictWord{135, 0, 1562}, + DictWord{5, 0, 42}, + DictWord{ + 5, + 0, + 879, + }, + DictWord{7, 0, 245}, + DictWord{7, 0, 324}, + DictWord{7, 0, 1532}, + DictWord{11, 0, 463}, + DictWord{11, 0, 472}, + DictWord{13, 0, 363}, + DictWord{144, 0, 52}, + DictWord{4, 0, 134}, + DictWord{133, 0, 372}, + DictWord{133, 0, 680}, + DictWord{136, 10, 363}, + DictWord{6, 0, 1997}, + DictWord{8, 0, 935}, + DictWord{136, 0, 977}, + DictWord{4, 0, 810}, + DictWord{135, 0, 1634}, + DictWord{135, 10, 1675}, + DictWord{7, 0, 1390}, + DictWord{4, 11, 910}, + DictWord{133, 11, 832}, + DictWord{ + 7, + 10, + 808, + }, + DictWord{8, 11, 266}, + DictWord{139, 11, 578}, + DictWord{132, 0, 644}, + DictWord{4, 0, 982}, + DictWord{138, 0, 867}, + DictWord{132, 10, 280}, + DictWord{ + 135, + 0, + 540, + }, + DictWord{140, 10, 54}, + DictWord{135, 0, 123}, + DictWord{134, 0, 1978}, + DictWord{4, 10, 421}, + DictWord{133, 10, 548}, + DictWord{6, 0, 623}, + DictWord{136, 0, 789}, + DictWord{4, 0, 908}, + DictWord{5, 0, 359}, + DictWord{5, 0, 508}, + DictWord{6, 0, 1723}, + DictWord{7, 0, 343}, + DictWord{7, 0, 1996}, + DictWord{ + 135, + 0, + 2026, + }, + DictWord{134, 0, 1220}, + DictWord{4, 0, 341}, + DictWord{135, 0, 480}, + DictWord{6, 10, 254}, + DictWord{9, 10, 109}, + DictWord{138, 10, 103}, + DictWord{ + 134, + 0, + 888, + }, + DictWord{8, 11, 528}, + DictWord{137, 11, 348}, + DictWord{7, 0, 1995}, + DictWord{8, 0, 299}, + DictWord{11, 0, 890}, + DictWord{12, 0, 674}, + DictWord{ + 4, + 11, + 20, + }, + DictWord{133, 11, 616}, + DictWord{135, 11, 1094}, + DictWord{134, 10, 1630}, + DictWord{4, 0, 238}, + DictWord{5, 0, 503}, + DictWord{6, 0, 179}, + DictWord{ + 7, + 0, + 2003, + }, + DictWord{8, 0, 381}, + DictWord{8, 0, 473}, + DictWord{9, 0, 149}, + DictWord{10, 0, 788}, + DictWord{15, 0, 45}, + DictWord{15, 0, 86}, + DictWord{20, 0, 110}, + DictWord{150, 0, 57}, + DictWord{133, 10, 671}, + DictWord{4, 11, 26}, + DictWord{5, 11, 429}, + DictWord{6, 11, 245}, + DictWord{7, 11, 704}, + DictWord{7, 11, 1379}, + DictWord{135, 11, 1474}, + DictWord{4, 0, 121}, + DictWord{5, 0, 156}, + DictWord{5, 0, 349}, + DictWord{9, 0, 431}, + DictWord{10, 0, 605}, + DictWord{142, 0, 342}, + DictWord{ + 7, + 11, + 943, + }, + DictWord{139, 11, 614}, + DictWord{132, 10, 889}, + DictWord{132, 11, 621}, + DictWord{7, 10, 1382}, + DictWord{7, 11, 1382}, + DictWord{ + 135, + 10, + 1910, + }, + DictWord{132, 10, 627}, + DictWord{133, 10, 775}, + DictWord{133, 11, 542}, + DictWord{133, 11, 868}, + DictWord{136, 11, 433}, + DictWord{6, 0, 1373}, + DictWord{7, 0, 1011}, + DictWord{11, 10, 362}, + DictWord{11, 10, 948}, + DictWord{140, 10, 388}, + DictWord{6, 0, 80}, + DictWord{7, 0, 173}, + DictWord{9, 0, 547}, + DictWord{10, 0, 730}, + DictWord{14, 0, 18}, + DictWord{22, 0, 39}, + DictWord{135, 11, 1495}, + DictWord{6, 0, 1694}, + DictWord{135, 0, 1974}, + DictWord{140, 0, 196}, + DictWord{4, 0, 923}, + DictWord{6, 0, 507}, + DictWord{6, 0, 1711}, + DictWord{7, 10, 451}, + DictWord{8, 10, 389}, + DictWord{12, 10, 490}, + DictWord{13, 10, 16}, + DictWord{ + 13, + 10, + 215, + }, + DictWord{13, 10, 351}, + DictWord{18, 10, 132}, + DictWord{147, 10, 125}, + DictWord{6, 0, 646}, + DictWord{134, 0, 1047}, + DictWord{135, 10, 841}, + DictWord{136, 10, 566}, + DictWord{6, 0, 1611}, + DictWord{135, 0, 1214}, + DictWord{139, 0, 926}, + DictWord{132, 11, 525}, + DictWord{132, 0, 595}, + DictWord{ + 5, + 0, + 240, + }, + DictWord{6, 0, 459}, + DictWord{7, 0, 12}, + DictWord{7, 0, 114}, + DictWord{7, 0, 949}, + DictWord{7, 0, 1753}, + DictWord{7, 0, 1805}, + DictWord{8, 0, 658}, + DictWord{ + 9, + 0, + 1, + }, + DictWord{11, 0, 959}, + DictWord{141, 0, 446}, + DictWord{5, 10, 912}, + DictWord{134, 10, 1695}, + DictWord{132, 0, 446}, + DictWord{7, 11, 62}, + DictWord{ + 12, + 11, + 45, + }, + DictWord{147, 11, 112}, + DictWord{5, 10, 236}, + DictWord{6, 10, 572}, + DictWord{8, 10, 492}, + DictWord{11, 10, 618}, + DictWord{144, 10, 56}, + DictWord{ + 5, + 10, + 190, + }, + DictWord{136, 10, 318}, + DictWord{135, 10, 1376}, + DictWord{4, 11, 223}, + DictWord{6, 11, 359}, + DictWord{11, 11, 3}, + DictWord{13, 11, 108}, + DictWord{ + 14, + 11, + 89, + }, + DictWord{144, 11, 22}, + DictWord{132, 11, 647}, + DictWord{134, 0, 490}, + DictWord{134, 0, 491}, + DictWord{134, 0, 1584}, + DictWord{ + 135, + 11, + 685, + }, + DictWord{138, 11, 220}, + DictWord{7, 0, 250}, + DictWord{136, 0, 507}, + DictWord{132, 0, 158}, + DictWord{4, 0, 140}, + DictWord{7, 0, 362}, + DictWord{8, 0, 209}, + DictWord{9, 0, 10}, + DictWord{9, 0, 160}, + DictWord{9, 0, 503}, + DictWord{9, 0, 614}, + DictWord{10, 0, 689}, + DictWord{11, 0, 327}, + DictWord{11, 0, 553}, + DictWord{ + 11, + 0, + 725, + }, + DictWord{11, 0, 767}, + DictWord{12, 0, 252}, + DictWord{12, 0, 583}, + DictWord{13, 0, 192}, + DictWord{14, 0, 269}, + DictWord{14, 0, 356}, + DictWord{148, 0, 50}, + DictWord{19, 0, 1}, + DictWord{19, 0, 26}, + DictWord{150, 0, 9}, + DictWord{132, 11, 109}, + DictWord{6, 0, 228}, + DictWord{7, 0, 1341}, + DictWord{9, 0, 408}, + DictWord{ + 138, + 0, + 343, + }, + DictWord{4, 0, 373}, + DictWord{5, 0, 283}, + DictWord{6, 0, 480}, + DictWord{7, 0, 609}, + DictWord{10, 0, 860}, + DictWord{138, 0, 878}, + DictWord{6, 0, 779}, + DictWord{134, 0, 1209}, + DictWord{4, 0, 557}, + DictWord{7, 11, 263}, + DictWord{7, 11, 628}, + DictWord{136, 11, 349}, + DictWord{132, 0, 548}, + DictWord{7, 0, 197}, + DictWord{8, 0, 142}, + DictWord{8, 0, 325}, + DictWord{9, 0, 150}, + DictWord{9, 0, 596}, + DictWord{10, 0, 350}, + DictWord{10, 0, 353}, + DictWord{11, 0, 74}, + DictWord{ + 11, + 0, + 315, + }, + DictWord{12, 0, 662}, + DictWord{12, 0, 681}, + DictWord{14, 0, 423}, + DictWord{143, 0, 141}, + DictWord{4, 11, 40}, + DictWord{10, 11, 67}, + DictWord{ + 11, + 11, + 117, + }, + DictWord{11, 11, 768}, + DictWord{139, 11, 935}, + DictWord{7, 11, 992}, + DictWord{8, 11, 301}, + DictWord{9, 11, 722}, + DictWord{12, 11, 63}, + DictWord{ + 13, + 11, + 29, + }, + DictWord{14, 11, 161}, + DictWord{143, 11, 18}, + DictWord{6, 0, 1490}, + DictWord{138, 11, 532}, + DictWord{5, 0, 580}, + DictWord{7, 0, 378}, + DictWord{ + 7, + 0, + 674, + }, + DictWord{7, 0, 1424}, + DictWord{15, 0, 83}, + DictWord{16, 0, 11}, + DictWord{15, 11, 83}, + DictWord{144, 11, 11}, + DictWord{6, 0, 1057}, + DictWord{6, 0, 1335}, + DictWord{10, 0, 316}, + DictWord{7, 10, 85}, + DictWord{7, 10, 247}, + DictWord{8, 10, 585}, + DictWord{138, 10, 163}, + DictWord{4, 0, 169}, + DictWord{5, 0, 83}, + DictWord{ + 6, + 0, + 399, + }, + DictWord{6, 0, 579}, + DictWord{6, 0, 1513}, + DictWord{7, 0, 692}, + DictWord{7, 0, 846}, + DictWord{7, 0, 1015}, + DictWord{7, 0, 1799}, + DictWord{8, 0, 403}, + DictWord{9, 0, 394}, + DictWord{10, 0, 133}, + DictWord{12, 0, 4}, + DictWord{12, 0, 297}, + DictWord{12, 0, 452}, + DictWord{16, 0, 81}, + DictWord{18, 0, 25}, + DictWord{21, 0, 14}, + DictWord{22, 0, 12}, + DictWord{151, 0, 18}, + DictWord{134, 0, 1106}, + DictWord{7, 0, 1546}, + DictWord{11, 0, 299}, + DictWord{142, 0, 407}, + DictWord{134, 0, 1192}, + DictWord{132, 0, 177}, + DictWord{5, 0, 411}, + DictWord{135, 0, 653}, + DictWord{7, 0, 439}, + DictWord{10, 0, 727}, + DictWord{11, 0, 260}, + DictWord{139, 0, 684}, + DictWord{138, 10, 145}, + DictWord{147, 10, 83}, + DictWord{5, 0, 208}, + DictWord{7, 0, 753}, + DictWord{135, 0, 1528}, + DictWord{137, 11, 617}, + DictWord{ + 135, + 10, + 1922, + }, + DictWord{135, 11, 825}, + DictWord{11, 0, 422}, + DictWord{13, 0, 389}, + DictWord{4, 10, 124}, + DictWord{10, 10, 457}, + DictWord{11, 10, 121}, + DictWord{ + 11, + 10, + 169, + }, + DictWord{11, 10, 870}, + DictWord{12, 10, 214}, + DictWord{14, 10, 187}, + DictWord{143, 10, 77}, + DictWord{11, 0, 615}, + DictWord{15, 0, 58}, + DictWord{ + 11, + 11, + 615, + }, + DictWord{143, 11, 58}, + DictWord{9, 0, 618}, + DictWord{138, 0, 482}, + DictWord{6, 0, 1952}, + DictWord{6, 0, 1970}, + DictWord{142, 0, 505}, + DictWord{ + 7, + 10, + 1193, + }, + DictWord{135, 11, 1838}, + DictWord{133, 0, 242}, + DictWord{135, 10, 1333}, + DictWord{6, 10, 107}, + DictWord{7, 10, 638}, + DictWord{ + 7, + 10, + 1632, + }, + DictWord{137, 10, 396}, + DictWord{133, 0, 953}, + DictWord{5, 10, 370}, + DictWord{134, 10, 1756}, + DictWord{5, 11, 28}, + DictWord{6, 11, 204}, + DictWord{ + 10, + 11, + 320, + }, + DictWord{10, 11, 583}, + DictWord{13, 11, 502}, + DictWord{14, 11, 72}, + DictWord{14, 11, 274}, + DictWord{14, 11, 312}, + DictWord{14, 11, 344}, + DictWord{15, 11, 159}, + DictWord{16, 11, 62}, + DictWord{16, 11, 69}, + DictWord{17, 11, 30}, + DictWord{18, 11, 42}, + DictWord{18, 11, 53}, + DictWord{18, 11, 84}, + DictWord{18, 11, 140}, + DictWord{19, 11, 68}, + DictWord{19, 11, 85}, + DictWord{20, 11, 5}, + DictWord{20, 11, 45}, + DictWord{20, 11, 101}, + DictWord{22, 11, 7}, + DictWord{ + 150, + 11, + 20, + }, + DictWord{4, 11, 558}, + DictWord{6, 11, 390}, + DictWord{7, 11, 162}, + DictWord{7, 11, 689}, + DictWord{9, 11, 360}, + DictWord{138, 11, 653}, + DictWord{ + 11, + 0, + 802, + }, + DictWord{141, 0, 67}, + DictWord{133, 10, 204}, + DictWord{133, 0, 290}, + DictWord{5, 10, 970}, + DictWord{134, 10, 1706}, + DictWord{132, 0, 380}, + DictWord{5, 0, 52}, + DictWord{7, 0, 277}, + DictWord{9, 0, 368}, + DictWord{139, 0, 791}, + DictWord{5, 11, 856}, + DictWord{6, 11, 1672}, + DictWord{6, 11, 1757}, + DictWord{ + 6, + 11, + 1781, + }, + DictWord{7, 11, 1150}, + DictWord{7, 11, 1425}, + DictWord{7, 11, 1453}, + DictWord{140, 11, 513}, + DictWord{5, 11, 92}, + DictWord{7, 10, 3}, + DictWord{ + 10, + 11, + 736, + }, + DictWord{140, 11, 102}, + DictWord{4, 0, 112}, + DictWord{5, 0, 653}, + DictWord{5, 10, 483}, + DictWord{5, 10, 685}, + DictWord{6, 10, 489}, + DictWord{ + 7, + 10, + 1204, + }, + DictWord{136, 10, 394}, + DictWord{132, 10, 921}, + DictWord{6, 0, 1028}, + DictWord{133, 10, 1007}, + DictWord{5, 11, 590}, + DictWord{9, 11, 213}, + DictWord{145, 11, 91}, + DictWord{135, 10, 1696}, + DictWord{10, 0, 138}, + DictWord{139, 0, 476}, + DictWord{5, 0, 725}, + DictWord{5, 0, 727}, + DictWord{135, 0, 1811}, + DictWord{4, 0, 979}, + DictWord{6, 0, 1821}, + DictWord{6, 0, 1838}, + DictWord{8, 0, 876}, + DictWord{8, 0, 883}, + DictWord{8, 0, 889}, + DictWord{8, 0, 893}, + DictWord{ + 8, + 0, + 895, + }, + DictWord{10, 0, 934}, + DictWord{12, 0, 720}, + DictWord{14, 0, 459}, + DictWord{148, 0, 123}, + DictWord{135, 11, 551}, + DictWord{4, 0, 38}, + DictWord{6, 0, 435}, + DictWord{7, 0, 307}, + DictWord{7, 0, 999}, + DictWord{7, 0, 1481}, + DictWord{7, 0, 1732}, + DictWord{7, 0, 1738}, + DictWord{8, 0, 371}, + DictWord{9, 0, 414}, + DictWord{ + 11, + 0, + 316, + }, + DictWord{12, 0, 52}, + DictWord{13, 0, 420}, + DictWord{147, 0, 100}, + DictWord{135, 0, 1296}, + DictWord{132, 10, 712}, + DictWord{134, 10, 1629}, + DictWord{133, 0, 723}, + DictWord{134, 0, 651}, + DictWord{136, 11, 191}, + DictWord{9, 11, 791}, + DictWord{10, 11, 93}, + DictWord{11, 11, 301}, + DictWord{16, 11, 13}, + DictWord{17, 11, 23}, + DictWord{18, 11, 135}, + DictWord{19, 11, 12}, + DictWord{20, 11, 1}, + DictWord{20, 11, 12}, + DictWord{148, 11, 14}, + DictWord{136, 11, 503}, + DictWord{6, 11, 466}, + DictWord{135, 11, 671}, + DictWord{6, 0, 1200}, + DictWord{134, 0, 1330}, + DictWord{135, 0, 1255}, + DictWord{134, 0, 986}, + DictWord{ + 5, + 0, + 109, + }, + DictWord{6, 0, 1784}, + DictWord{7, 0, 1895}, + DictWord{12, 0, 296}, + DictWord{140, 0, 302}, + DictWord{135, 11, 983}, + DictWord{133, 10, 485}, + DictWord{ + 134, + 0, + 660, + }, + DictWord{134, 0, 800}, + DictWord{5, 0, 216}, + DictWord{5, 0, 294}, + DictWord{6, 0, 591}, + DictWord{7, 0, 1879}, + DictWord{9, 0, 141}, + DictWord{9, 0, 270}, + DictWord{9, 0, 679}, + DictWord{10, 0, 159}, + DictWord{11, 0, 197}, + DictWord{11, 0, 438}, + DictWord{12, 0, 538}, + DictWord{12, 0, 559}, + DictWord{14, 0, 144}, + DictWord{ + 14, + 0, + 167, + }, + DictWord{15, 0, 67}, + DictWord{4, 10, 285}, + DictWord{5, 10, 317}, + DictWord{6, 10, 301}, + DictWord{7, 10, 7}, + DictWord{8, 10, 153}, + DictWord{ + 10, + 10, + 766, + }, + DictWord{11, 10, 468}, + DictWord{12, 10, 467}, + DictWord{141, 10, 143}, + DictWord{136, 0, 945}, + DictWord{134, 0, 1090}, + DictWord{137, 0, 81}, + DictWord{12, 11, 468}, + DictWord{19, 11, 96}, + DictWord{148, 11, 24}, + DictWord{134, 0, 391}, + DictWord{138, 11, 241}, + DictWord{7, 0, 322}, + DictWord{136, 0, 249}, + DictWord{134, 0, 1412}, + DictWord{135, 11, 795}, + DictWord{5, 0, 632}, + DictWord{138, 0, 526}, + DictWord{136, 10, 819}, + DictWord{6, 0, 144}, + DictWord{7, 0, 948}, + DictWord{7, 0, 1042}, + DictWord{8, 0, 235}, + DictWord{8, 0, 461}, + DictWord{9, 0, 453}, + DictWord{9, 0, 796}, + DictWord{10, 0, 354}, + DictWord{17, 0, 77}, + DictWord{ + 135, + 11, + 954, + }, + DictWord{139, 10, 917}, + DictWord{6, 0, 940}, + DictWord{134, 0, 1228}, + DictWord{4, 0, 362}, + DictWord{7, 0, 52}, + DictWord{135, 0, 303}, + DictWord{ + 6, + 11, + 549, + }, + DictWord{8, 11, 34}, + DictWord{8, 11, 283}, + DictWord{9, 11, 165}, + DictWord{138, 11, 475}, + DictWord{7, 11, 370}, + DictWord{7, 11, 1007}, + DictWord{ + 7, + 11, + 1177, + }, + DictWord{135, 11, 1565}, + DictWord{5, 11, 652}, + DictWord{5, 11, 701}, + DictWord{135, 11, 449}, + DictWord{5, 0, 196}, + DictWord{6, 0, 486}, + DictWord{ + 7, + 0, + 212, + }, + DictWord{8, 0, 309}, + DictWord{136, 0, 346}, + DictWord{6, 10, 1719}, + DictWord{6, 10, 1735}, + DictWord{7, 10, 2016}, + DictWord{7, 10, 2020}, + DictWord{ + 8, + 10, + 837, + }, + DictWord{137, 10, 852}, + DictWord{6, 11, 159}, + DictWord{6, 11, 364}, + DictWord{7, 11, 516}, + DictWord{7, 11, 1439}, + DictWord{137, 11, 518}, + DictWord{135, 0, 1912}, + DictWord{135, 0, 1290}, + DictWord{132, 0, 686}, + DictWord{141, 11, 151}, + DictWord{138, 0, 625}, + DictWord{136, 0, 706}, + DictWord{ + 138, + 10, + 568, + }, + DictWord{139, 0, 412}, + DictWord{4, 0, 30}, + DictWord{133, 0, 43}, + DictWord{8, 10, 67}, + DictWord{138, 10, 419}, + DictWord{7, 0, 967}, + DictWord{ + 141, + 0, + 11, + }, + DictWord{12, 0, 758}, + DictWord{14, 0, 441}, + DictWord{142, 0, 462}, + DictWord{10, 10, 657}, + DictWord{14, 10, 297}, + DictWord{142, 10, 361}, + DictWord{ + 139, + 10, + 729, + }, + DictWord{4, 0, 220}, + DictWord{135, 0, 1535}, + DictWord{7, 11, 501}, + DictWord{9, 11, 111}, + DictWord{10, 11, 141}, + DictWord{11, 11, 332}, + DictWord{ + 13, + 11, + 43, + }, + DictWord{13, 11, 429}, + DictWord{14, 11, 130}, + DictWord{14, 11, 415}, + DictWord{145, 11, 102}, + DictWord{4, 0, 950}, + DictWord{6, 0, 1859}, + DictWord{ + 7, + 0, + 11, + }, + DictWord{8, 0, 873}, + DictWord{12, 0, 710}, + DictWord{12, 0, 718}, + DictWord{12, 0, 748}, + DictWord{12, 0, 765}, + DictWord{148, 0, 124}, + DictWord{ + 5, + 11, + 149, + }, + DictWord{5, 11, 935}, + DictWord{136, 11, 233}, + DictWord{142, 11, 291}, + DictWord{134, 0, 1579}, + DictWord{7, 0, 890}, + DictWord{8, 10, 51}, + DictWord{ + 9, + 10, + 868, + }, + DictWord{10, 10, 833}, + DictWord{12, 10, 481}, + DictWord{12, 10, 570}, + DictWord{148, 10, 106}, + DictWord{141, 0, 2}, + DictWord{132, 10, 445}, + DictWord{136, 11, 801}, + DictWord{135, 0, 1774}, + DictWord{7, 0, 1725}, + DictWord{138, 0, 393}, + DictWord{5, 0, 263}, + DictWord{134, 0, 414}, + DictWord{ + 132, + 11, + 322, + }, + DictWord{133, 10, 239}, + DictWord{7, 0, 456}, + DictWord{7, 10, 1990}, + DictWord{8, 10, 130}, + DictWord{139, 10, 720}, + DictWord{137, 0, 818}, + DictWord{ + 5, + 10, + 123, + }, + DictWord{6, 10, 530}, + DictWord{7, 10, 348}, + DictWord{135, 10, 1419}, + DictWord{135, 10, 2024}, + DictWord{6, 0, 178}, + DictWord{6, 0, 1750}, + DictWord{8, 0, 251}, + DictWord{9, 0, 690}, + DictWord{10, 0, 155}, + DictWord{10, 0, 196}, + DictWord{10, 0, 373}, + DictWord{11, 0, 698}, + DictWord{13, 0, 155}, + DictWord{ + 148, + 0, + 93, + }, + DictWord{5, 0, 97}, + DictWord{137, 0, 393}, + DictWord{134, 0, 674}, + DictWord{11, 0, 223}, + DictWord{140, 0, 168}, + DictWord{132, 10, 210}, + DictWord{ + 139, + 11, + 464, + }, + DictWord{6, 0, 1639}, + DictWord{146, 0, 159}, + DictWord{139, 11, 2}, + DictWord{7, 0, 934}, + DictWord{8, 0, 647}, + DictWord{17, 0, 97}, + DictWord{19, 0, 59}, + DictWord{150, 0, 2}, + DictWord{132, 0, 191}, + DictWord{5, 0, 165}, + DictWord{9, 0, 346}, + DictWord{10, 0, 655}, + DictWord{11, 0, 885}, + DictWord{4, 10, 430}, + DictWord{135, 11, 357}, + DictWord{133, 0, 877}, + DictWord{5, 10, 213}, + DictWord{133, 11, 406}, + DictWord{8, 0, 128}, + DictWord{139, 0, 179}, + DictWord{6, 11, 69}, + DictWord{135, 11, 117}, + DictWord{135, 0, 1297}, + DictWord{11, 11, 43}, + DictWord{13, 11, 72}, + DictWord{141, 11, 142}, + DictWord{135, 11, 1830}, + DictWord{ + 142, + 0, + 164, + }, + DictWord{5, 0, 57}, + DictWord{6, 0, 101}, + DictWord{6, 0, 586}, + DictWord{6, 0, 1663}, + DictWord{7, 0, 132}, + DictWord{7, 0, 1154}, + DictWord{7, 0, 1415}, + DictWord{7, 0, 1507}, + DictWord{12, 0, 493}, + DictWord{15, 0, 105}, + DictWord{151, 0, 15}, + DictWord{5, 0, 459}, + DictWord{7, 0, 1073}, + DictWord{8, 0, 241}, + DictWord{ + 136, + 0, + 334, + }, + DictWord{133, 11, 826}, + DictWord{133, 10, 108}, + DictWord{5, 10, 219}, + DictWord{10, 11, 132}, + DictWord{11, 11, 191}, + DictWord{11, 11, 358}, + DictWord{139, 11, 460}, + DictWord{6, 0, 324}, + DictWord{6, 0, 520}, + DictWord{7, 0, 338}, + DictWord{7, 0, 1729}, + DictWord{8, 0, 228}, + DictWord{139, 0, 750}, + DictWord{ + 21, + 0, + 30, + }, + DictWord{22, 0, 53}, + DictWord{4, 10, 193}, + DictWord{5, 10, 916}, + DictWord{7, 10, 364}, + DictWord{10, 10, 398}, + DictWord{10, 10, 726}, + DictWord{ + 11, + 10, + 317, + }, + DictWord{11, 10, 626}, + DictWord{12, 10, 142}, + DictWord{12, 10, 288}, + DictWord{12, 10, 678}, + DictWord{13, 10, 313}, + DictWord{15, 10, 113}, + DictWord{146, 10, 114}, + DictWord{6, 11, 110}, + DictWord{135, 11, 1681}, + DictWord{135, 0, 910}, + DictWord{6, 10, 241}, + DictWord{7, 10, 907}, + DictWord{8, 10, 832}, + DictWord{9, 10, 342}, + DictWord{10, 10, 729}, + DictWord{11, 10, 284}, + DictWord{11, 10, 445}, + DictWord{11, 10, 651}, + DictWord{11, 10, 863}, + DictWord{ + 13, + 10, + 398, + }, + DictWord{146, 10, 99}, + DictWord{7, 0, 705}, + DictWord{9, 0, 734}, + DictWord{5, 11, 1000}, + DictWord{7, 11, 733}, + DictWord{137, 11, 583}, + DictWord{4, 0, 73}, + DictWord{6, 0, 612}, + DictWord{7, 0, 927}, + DictWord{7, 0, 1822}, + DictWord{8, 0, 217}, + DictWord{9, 0, 765}, + DictWord{9, 0, 766}, + DictWord{10, 0, 408}, + DictWord{ + 11, + 0, + 51, + }, + DictWord{11, 0, 793}, + DictWord{12, 0, 266}, + DictWord{15, 0, 158}, + DictWord{20, 0, 89}, + DictWord{150, 0, 32}, + DictWord{7, 0, 1330}, + DictWord{4, 11, 297}, + DictWord{6, 11, 529}, + DictWord{7, 11, 152}, + DictWord{7, 11, 713}, + DictWord{7, 11, 1845}, + DictWord{8, 11, 710}, + DictWord{8, 11, 717}, + DictWord{140, 11, 639}, + DictWord{5, 0, 389}, + DictWord{136, 0, 636}, + DictWord{134, 0, 1409}, + DictWord{4, 10, 562}, + DictWord{9, 10, 254}, + DictWord{139, 10, 879}, + DictWord{134, 0, 893}, + DictWord{132, 10, 786}, + DictWord{4, 11, 520}, + DictWord{135, 11, 575}, + DictWord{136, 0, 21}, + DictWord{140, 0, 721}, + DictWord{136, 0, 959}, + DictWord{ + 7, + 11, + 1428, + }, + DictWord{7, 11, 1640}, + DictWord{9, 11, 169}, + DictWord{9, 11, 182}, + DictWord{9, 11, 367}, + DictWord{9, 11, 478}, + DictWord{9, 11, 506}, + DictWord{ + 9, + 11, + 551, + }, + DictWord{9, 11, 648}, + DictWord{9, 11, 651}, + DictWord{9, 11, 697}, + DictWord{9, 11, 705}, + DictWord{9, 11, 725}, + DictWord{9, 11, 787}, + DictWord{9, 11, 794}, + DictWord{10, 11, 198}, + DictWord{10, 11, 214}, + DictWord{10, 11, 267}, + DictWord{10, 11, 275}, + DictWord{10, 11, 456}, + DictWord{10, 11, 551}, + DictWord{ + 10, + 11, + 561, + }, + DictWord{10, 11, 613}, + DictWord{10, 11, 627}, + DictWord{10, 11, 668}, + DictWord{10, 11, 675}, + DictWord{10, 11, 691}, + DictWord{10, 11, 695}, + DictWord{10, 11, 707}, + DictWord{10, 11, 715}, + DictWord{11, 11, 183}, + DictWord{11, 11, 201}, + DictWord{11, 11, 244}, + DictWord{11, 11, 262}, + DictWord{ + 11, + 11, + 352, + }, + DictWord{11, 11, 439}, + DictWord{11, 11, 493}, + DictWord{11, 11, 572}, + DictWord{11, 11, 591}, + DictWord{11, 11, 608}, + DictWord{11, 11, 611}, + DictWord{ + 11, + 11, + 646, + }, + DictWord{11, 11, 674}, + DictWord{11, 11, 711}, + DictWord{11, 11, 751}, + DictWord{11, 11, 761}, + DictWord{11, 11, 776}, + DictWord{11, 11, 785}, + DictWord{11, 11, 850}, + DictWord{11, 11, 853}, + DictWord{11, 11, 862}, + DictWord{11, 11, 865}, + DictWord{11, 11, 868}, + DictWord{11, 11, 898}, + DictWord{ + 11, + 11, + 902, + }, + DictWord{11, 11, 903}, + DictWord{11, 11, 910}, + DictWord{11, 11, 932}, + DictWord{11, 11, 942}, + DictWord{11, 11, 957}, + DictWord{11, 11, 967}, + DictWord{ + 11, + 11, + 972, + }, + DictWord{12, 11, 148}, + DictWord{12, 11, 195}, + DictWord{12, 11, 220}, + DictWord{12, 11, 237}, + DictWord{12, 11, 318}, + DictWord{12, 11, 339}, + DictWord{12, 11, 393}, + DictWord{12, 11, 445}, + DictWord{12, 11, 450}, + DictWord{12, 11, 474}, + DictWord{12, 11, 509}, + DictWord{12, 11, 533}, + DictWord{ + 12, + 11, + 591, + }, + DictWord{12, 11, 594}, + DictWord{12, 11, 597}, + DictWord{12, 11, 621}, + DictWord{12, 11, 633}, + DictWord{12, 11, 642}, + DictWord{13, 11, 59}, + DictWord{ + 13, + 11, + 60, + }, + DictWord{13, 11, 145}, + DictWord{13, 11, 239}, + DictWord{13, 11, 250}, + DictWord{13, 11, 273}, + DictWord{13, 11, 329}, + DictWord{13, 11, 344}, + DictWord{13, 11, 365}, + DictWord{13, 11, 372}, + DictWord{13, 11, 387}, + DictWord{13, 11, 403}, + DictWord{13, 11, 414}, + DictWord{13, 11, 456}, + DictWord{ + 13, + 11, + 478, + }, + DictWord{13, 11, 483}, + DictWord{13, 11, 489}, + DictWord{14, 11, 55}, + DictWord{14, 11, 57}, + DictWord{14, 11, 81}, + DictWord{14, 11, 90}, + DictWord{ + 14, + 11, + 148, + }, + DictWord{14, 11, 239}, + DictWord{14, 11, 266}, + DictWord{14, 11, 321}, + DictWord{14, 11, 326}, + DictWord{14, 11, 327}, + DictWord{14, 11, 330}, + DictWord{ + 14, + 11, + 347, + }, + DictWord{14, 11, 355}, + DictWord{14, 11, 401}, + DictWord{14, 11, 411}, + DictWord{14, 11, 414}, + DictWord{14, 11, 416}, + DictWord{14, 11, 420}, + DictWord{15, 11, 61}, + DictWord{15, 11, 74}, + DictWord{15, 11, 87}, + DictWord{15, 11, 88}, + DictWord{15, 11, 94}, + DictWord{15, 11, 96}, + DictWord{15, 11, 116}, + DictWord{15, 11, 149}, + DictWord{15, 11, 154}, + DictWord{16, 11, 50}, + DictWord{16, 11, 63}, + DictWord{16, 11, 73}, + DictWord{17, 11, 2}, + DictWord{17, 11, 66}, + DictWord{ + 17, + 11, + 92, + }, + DictWord{17, 11, 103}, + DictWord{17, 11, 112}, + DictWord{18, 11, 50}, + DictWord{18, 11, 54}, + DictWord{18, 11, 82}, + DictWord{18, 11, 86}, + DictWord{ + 18, + 11, + 90, + }, + DictWord{18, 11, 111}, + DictWord{18, 11, 115}, + DictWord{18, 11, 156}, + DictWord{19, 11, 40}, + DictWord{19, 11, 79}, + DictWord{20, 11, 78}, + DictWord{ + 149, + 11, + 22, + }, + DictWord{137, 11, 170}, + DictWord{134, 0, 1433}, + DictWord{135, 11, 1307}, + DictWord{139, 11, 411}, + DictWord{5, 0, 189}, + DictWord{7, 0, 442}, + DictWord{7, 0, 443}, + DictWord{8, 0, 281}, + DictWord{12, 0, 174}, + DictWord{141, 0, 261}, + DictWord{6, 10, 216}, + DictWord{7, 10, 901}, + DictWord{7, 10, 1343}, + DictWord{136, 10, 493}, + DictWord{5, 11, 397}, + DictWord{6, 11, 154}, + DictWord{7, 10, 341}, + DictWord{7, 11, 676}, + DictWord{8, 11, 443}, + DictWord{8, 11, 609}, + DictWord{ + 9, + 11, + 24, + }, + DictWord{9, 11, 325}, + DictWord{10, 11, 35}, + DictWord{11, 10, 219}, + DictWord{11, 11, 535}, + DictWord{11, 11, 672}, + DictWord{11, 11, 1018}, + DictWord{12, 11, 637}, + DictWord{144, 11, 30}, + DictWord{6, 0, 2}, + DictWord{7, 0, 191}, + DictWord{7, 0, 446}, + DictWord{7, 0, 1262}, + DictWord{7, 0, 1737}, + DictWord{8, 0, 22}, + DictWord{8, 0, 270}, + DictWord{8, 0, 612}, + DictWord{9, 0, 4}, + DictWord{9, 0, 312}, + DictWord{9, 0, 436}, + DictWord{9, 0, 626}, + DictWord{10, 0, 216}, + DictWord{10, 0, 311}, + DictWord{10, 0, 521}, + DictWord{10, 0, 623}, + DictWord{11, 0, 72}, + DictWord{11, 0, 330}, + DictWord{11, 0, 455}, + DictWord{12, 0, 321}, + DictWord{12, 0, 504}, + DictWord{12, 0, 530}, + DictWord{12, 0, 543}, + DictWord{13, 0, 17}, + DictWord{13, 0, 156}, + DictWord{13, 0, 334}, + DictWord{14, 0, 131}, + DictWord{17, 0, 60}, + DictWord{ + 148, + 0, + 64, + }, + DictWord{7, 0, 354}, + DictWord{10, 0, 410}, + DictWord{139, 0, 815}, + DictWord{139, 10, 130}, + DictWord{7, 10, 1734}, + DictWord{137, 11, 631}, + DictWord{ + 12, + 0, + 425, + }, + DictWord{15, 0, 112}, + DictWord{10, 10, 115}, + DictWord{11, 10, 420}, + DictWord{13, 10, 404}, + DictWord{14, 10, 346}, + DictWord{143, 10, 54}, + DictWord{ + 6, + 0, + 60, + }, + DictWord{6, 0, 166}, + DictWord{7, 0, 374}, + DictWord{7, 0, 670}, + DictWord{7, 0, 1327}, + DictWord{8, 0, 411}, + DictWord{8, 0, 435}, + DictWord{9, 0, 653}, + DictWord{ + 9, + 0, + 740, + }, + DictWord{10, 0, 385}, + DictWord{11, 0, 222}, + DictWord{11, 0, 324}, + DictWord{11, 0, 829}, + DictWord{140, 0, 611}, + DictWord{7, 0, 1611}, + DictWord{ + 13, + 0, + 14, + }, + DictWord{15, 0, 44}, + DictWord{19, 0, 13}, + DictWord{148, 0, 76}, + DictWord{133, 11, 981}, + DictWord{4, 11, 56}, + DictWord{7, 11, 1791}, + DictWord{8, 11, 607}, + DictWord{8, 11, 651}, + DictWord{11, 11, 465}, + DictWord{11, 11, 835}, + DictWord{12, 11, 337}, + DictWord{141, 11, 480}, + DictWord{6, 0, 1478}, + DictWord{ + 5, + 10, + 1011, + }, + DictWord{136, 10, 701}, + DictWord{139, 0, 596}, + DictWord{5, 0, 206}, + DictWord{134, 0, 398}, + DictWord{4, 10, 54}, + DictWord{5, 10, 666}, + DictWord{ + 7, + 10, + 1039, + }, + DictWord{7, 10, 1130}, + DictWord{9, 10, 195}, + DictWord{138, 10, 302}, + DictWord{7, 0, 50}, + DictWord{9, 11, 158}, + DictWord{138, 11, 411}, + DictWord{ + 135, + 11, + 1120, + }, + DictWord{6, 0, 517}, + DictWord{7, 0, 1159}, + DictWord{10, 0, 621}, + DictWord{11, 0, 192}, + DictWord{134, 10, 1669}, + DictWord{4, 0, 592}, + DictWord{ + 6, + 0, + 600, + }, + DictWord{135, 0, 1653}, + DictWord{10, 0, 223}, + DictWord{139, 0, 645}, + DictWord{136, 11, 139}, + DictWord{7, 0, 64}, + DictWord{136, 0, 245}, + DictWord{ + 142, + 0, + 278, + }, + DictWord{6, 11, 622}, + DictWord{135, 11, 1030}, + DictWord{136, 0, 604}, + DictWord{134, 0, 1502}, + DictWord{138, 0, 265}, + DictWord{ + 141, + 11, + 168, + }, + DictWord{7, 0, 1763}, + DictWord{140, 0, 310}, + DictWord{7, 10, 798}, + DictWord{139, 11, 719}, + DictWord{7, 11, 160}, + DictWord{10, 11, 624}, + DictWord{ + 142, + 11, + 279, + }, + DictWord{132, 11, 363}, + DictWord{7, 10, 122}, + DictWord{9, 10, 259}, + DictWord{10, 10, 84}, + DictWord{11, 10, 470}, + DictWord{12, 10, 541}, + DictWord{141, 10, 379}, + DictWord{5, 0, 129}, + DictWord{6, 0, 61}, + DictWord{135, 0, 947}, + DictWord{134, 0, 1356}, + DictWord{135, 11, 1191}, + DictWord{13, 0, 505}, + DictWord{141, 0, 506}, + DictWord{11, 0, 1000}, + DictWord{5, 10, 82}, + DictWord{5, 10, 131}, + DictWord{7, 10, 1755}, + DictWord{8, 10, 31}, + DictWord{9, 10, 168}, + DictWord{9, 10, 764}, + DictWord{139, 10, 869}, + DictWord{134, 0, 966}, + DictWord{134, 10, 605}, + DictWord{134, 11, 292}, + DictWord{5, 11, 177}, + DictWord{ + 6, + 11, + 616, + }, + DictWord{7, 11, 827}, + DictWord{9, 11, 525}, + DictWord{138, 11, 656}, + DictWord{135, 11, 1486}, + DictWord{138, 11, 31}, + DictWord{5, 10, 278}, + DictWord{137, 10, 68}, + DictWord{4, 10, 163}, + DictWord{5, 10, 201}, + DictWord{5, 10, 307}, + DictWord{5, 10, 310}, + DictWord{6, 10, 335}, + DictWord{7, 10, 284}, + DictWord{136, 10, 165}, + DictWord{6, 0, 839}, + DictWord{135, 10, 1660}, + DictWord{136, 10, 781}, + DictWord{6, 10, 33}, + DictWord{135, 10, 1244}, + DictWord{ + 133, + 0, + 637, + }, + DictWord{4, 11, 161}, + DictWord{133, 11, 631}, + DictWord{137, 0, 590}, + DictWord{7, 10, 1953}, + DictWord{136, 10, 720}, + DictWord{5, 0, 280}, + DictWord{ + 7, + 0, + 1226, + }, + DictWord{138, 10, 203}, + DictWord{134, 0, 1386}, + DictWord{5, 0, 281}, + DictWord{6, 0, 1026}, + DictWord{6, 10, 326}, + DictWord{7, 10, 677}, + DictWord{ + 137, + 10, + 425, + }, + DictWord{7, 11, 1557}, + DictWord{135, 11, 1684}, + DictWord{135, 0, 1064}, + DictWord{9, 11, 469}, + DictWord{9, 11, 709}, + DictWord{12, 11, 512}, + DictWord{14, 11, 65}, + DictWord{145, 11, 12}, + DictWord{134, 0, 917}, + DictWord{10, 11, 229}, + DictWord{11, 11, 73}, + DictWord{11, 11, 376}, + DictWord{ + 139, + 11, + 433, + }, + DictWord{7, 0, 555}, + DictWord{9, 0, 192}, + DictWord{13, 0, 30}, + DictWord{13, 0, 49}, + DictWord{15, 0, 150}, + DictWord{16, 0, 76}, + DictWord{20, 0, 52}, + DictWord{ + 7, + 10, + 1316, + }, + DictWord{7, 10, 1412}, + DictWord{7, 10, 1839}, + DictWord{9, 10, 589}, + DictWord{11, 10, 241}, + DictWord{11, 10, 676}, + DictWord{11, 10, 811}, + DictWord{11, 10, 891}, + DictWord{12, 10, 140}, + DictWord{12, 10, 346}, + DictWord{12, 10, 479}, + DictWord{13, 10, 381}, + DictWord{14, 10, 188}, + DictWord{ + 146, + 10, + 30, + }, + DictWord{149, 0, 15}, + DictWord{6, 0, 1882}, + DictWord{6, 0, 1883}, + DictWord{6, 0, 1897}, + DictWord{9, 0, 945}, + DictWord{9, 0, 1014}, + DictWord{9, 0, 1020}, + DictWord{12, 0, 823}, + DictWord{12, 0, 842}, + DictWord{12, 0, 866}, + DictWord{12, 0, 934}, + DictWord{15, 0, 242}, + DictWord{146, 0, 208}, + DictWord{6, 0, 965}, + DictWord{134, 0, 1499}, + DictWord{7, 0, 33}, + DictWord{7, 0, 120}, + DictWord{8, 0, 489}, + DictWord{9, 0, 319}, + DictWord{10, 0, 820}, + DictWord{11, 0, 1004}, + DictWord{ + 12, + 0, + 379, + }, + DictWord{12, 0, 679}, + DictWord{13, 0, 117}, + DictWord{13, 0, 412}, + DictWord{14, 0, 25}, + DictWord{15, 0, 52}, + DictWord{15, 0, 161}, + DictWord{16, 0, 47}, + DictWord{149, 0, 2}, + DictWord{6, 11, 558}, + DictWord{7, 11, 651}, + DictWord{8, 11, 421}, + DictWord{9, 11, 0}, + DictWord{138, 11, 34}, + DictWord{4, 0, 937}, + DictWord{ + 5, + 0, + 801, + }, + DictWord{7, 0, 473}, + DictWord{5, 10, 358}, + DictWord{7, 10, 1184}, + DictWord{10, 10, 662}, + DictWord{13, 10, 212}, + DictWord{13, 10, 304}, + DictWord{ + 13, + 10, + 333, + }, + DictWord{145, 10, 98}, + DictWord{132, 0, 877}, + DictWord{6, 0, 693}, + DictWord{134, 0, 824}, + DictWord{132, 0, 365}, + DictWord{7, 11, 1832}, + DictWord{ + 138, + 11, + 374, + }, + DictWord{5, 0, 7}, + DictWord{139, 0, 774}, + DictWord{4, 0, 734}, + DictWord{5, 0, 662}, + DictWord{134, 0, 430}, + DictWord{4, 0, 746}, + DictWord{ + 135, + 0, + 1090, + }, + DictWord{5, 0, 360}, + DictWord{8, 0, 237}, + DictWord{10, 0, 231}, + DictWord{147, 0, 124}, + DictWord{138, 11, 348}, + DictWord{6, 11, 6}, + DictWord{7, 11, 81}, + DictWord{7, 11, 771}, + DictWord{7, 11, 1731}, + DictWord{9, 11, 405}, + DictWord{138, 11, 421}, + DictWord{6, 0, 740}, + DictWord{137, 0, 822}, + DictWord{ + 133, + 10, + 946, + }, + DictWord{7, 0, 1485}, + DictWord{136, 0, 929}, + DictWord{7, 10, 411}, + DictWord{8, 10, 631}, + DictWord{9, 10, 323}, + DictWord{10, 10, 355}, + DictWord{ + 11, + 10, + 491, + }, + DictWord{12, 10, 143}, + DictWord{12, 10, 402}, + DictWord{13, 10, 73}, + DictWord{14, 10, 408}, + DictWord{15, 10, 107}, + DictWord{146, 10, 71}, + DictWord{ + 135, + 10, + 590, + }, + DictWord{5, 11, 881}, + DictWord{133, 11, 885}, + DictWord{150, 11, 25}, + DictWord{4, 0, 852}, + DictWord{5, 11, 142}, + DictWord{134, 11, 546}, + DictWord{7, 10, 1467}, + DictWord{8, 10, 328}, + DictWord{10, 10, 544}, + DictWord{11, 10, 955}, + DictWord{13, 10, 320}, + DictWord{145, 10, 83}, + DictWord{9, 0, 17}, + DictWord{10, 0, 291}, + DictWord{11, 10, 511}, + DictWord{13, 10, 394}, + DictWord{14, 10, 298}, + DictWord{14, 10, 318}, + DictWord{146, 10, 103}, + DictWord{5, 11, 466}, + DictWord{11, 11, 571}, + DictWord{12, 11, 198}, + DictWord{13, 11, 283}, + DictWord{14, 11, 186}, + DictWord{15, 11, 21}, + DictWord{143, 11, 103}, + DictWord{ + 134, + 0, + 1001, + }, + DictWord{4, 11, 185}, + DictWord{5, 11, 257}, + DictWord{5, 11, 839}, + DictWord{5, 11, 936}, + DictWord{7, 11, 171}, + DictWord{9, 11, 399}, + DictWord{ + 10, + 11, + 258, + }, + DictWord{10, 11, 395}, + DictWord{10, 11, 734}, + DictWord{11, 11, 1014}, + DictWord{12, 11, 23}, + DictWord{13, 11, 350}, + DictWord{14, 11, 150}, + DictWord{147, 11, 6}, + DictWord{143, 0, 35}, + DictWord{132, 0, 831}, + DictWord{5, 10, 835}, + DictWord{134, 10, 483}, + DictWord{4, 0, 277}, + DictWord{5, 0, 608}, + DictWord{ + 6, + 0, + 493, + }, + DictWord{7, 0, 457}, + DictWord{12, 0, 384}, + DictWord{7, 11, 404}, + DictWord{7, 11, 1377}, + DictWord{7, 11, 1430}, + DictWord{7, 11, 2017}, + DictWord{ + 8, + 11, + 149, + }, + DictWord{8, 11, 239}, + DictWord{8, 11, 512}, + DictWord{8, 11, 793}, + DictWord{8, 11, 818}, + DictWord{9, 11, 474}, + DictWord{9, 11, 595}, + DictWord{ + 10, + 11, + 122, + }, + DictWord{10, 11, 565}, + DictWord{10, 11, 649}, + DictWord{10, 11, 783}, + DictWord{11, 11, 239}, + DictWord{11, 11, 295}, + DictWord{11, 11, 447}, + DictWord{ + 11, + 11, + 528, + }, + DictWord{11, 11, 639}, + DictWord{11, 11, 800}, + DictWord{11, 11, 936}, + DictWord{12, 11, 25}, + DictWord{12, 11, 73}, + DictWord{12, 11, 77}, + DictWord{12, 11, 157}, + DictWord{12, 11, 316}, + DictWord{12, 11, 390}, + DictWord{12, 11, 391}, + DictWord{12, 11, 394}, + DictWord{12, 11, 395}, + DictWord{ + 12, + 11, + 478, + }, + DictWord{12, 11, 503}, + DictWord{12, 11, 592}, + DictWord{12, 11, 680}, + DictWord{13, 11, 50}, + DictWord{13, 11, 53}, + DictWord{13, 11, 132}, + DictWord{ + 13, + 11, + 198, + }, + DictWord{13, 11, 275}, + DictWord{13, 11, 322}, + DictWord{13, 11, 415}, + DictWord{14, 11, 71}, + DictWord{14, 11, 257}, + DictWord{14, 11, 395}, + DictWord{15, 11, 71}, + DictWord{15, 11, 136}, + DictWord{17, 11, 123}, + DictWord{18, 11, 93}, + DictWord{147, 11, 58}, + DictWord{134, 0, 1351}, + DictWord{7, 0, 27}, + DictWord{135, 0, 316}, + DictWord{136, 11, 712}, + DictWord{136, 0, 984}, + DictWord{133, 0, 552}, + DictWord{137, 0, 264}, + DictWord{132, 0, 401}, + DictWord{6, 0, 710}, + DictWord{6, 0, 1111}, + DictWord{134, 0, 1343}, + DictWord{134, 0, 1211}, + DictWord{9, 0, 543}, + DictWord{10, 0, 524}, + DictWord{11, 0, 108}, + DictWord{11, 0, 653}, + DictWord{12, 0, 524}, + DictWord{13, 0, 123}, + DictWord{14, 0, 252}, + DictWord{16, 0, 18}, + DictWord{19, 0, 38}, + DictWord{20, 0, 26}, + DictWord{20, 0, 65}, + DictWord{ + 21, + 0, + 3, + }, + DictWord{151, 0, 11}, + DictWord{4, 0, 205}, + DictWord{5, 0, 623}, + DictWord{7, 0, 104}, + DictWord{8, 0, 519}, + DictWord{137, 0, 716}, + DictWord{132, 10, 677}, + DictWord{4, 11, 377}, + DictWord{152, 11, 13}, + DictWord{135, 11, 1673}, + DictWord{7, 0, 579}, + DictWord{9, 0, 41}, + DictWord{9, 0, 244}, + DictWord{9, 0, 669}, + DictWord{ + 10, + 0, + 5, + }, + DictWord{11, 0, 861}, + DictWord{11, 0, 951}, + DictWord{139, 0, 980}, + DictWord{132, 0, 717}, + DictWord{136, 0, 1011}, + DictWord{132, 0, 805}, + DictWord{ + 4, + 11, + 180, + }, + DictWord{135, 11, 1906}, + DictWord{132, 10, 777}, + DictWord{132, 10, 331}, + DictWord{132, 0, 489}, + DictWord{6, 0, 1024}, + DictWord{4, 11, 491}, + DictWord{133, 10, 747}, + DictWord{135, 11, 1182}, + DictWord{4, 11, 171}, + DictWord{138, 11, 234}, + DictWord{4, 11, 586}, + DictWord{7, 11, 1186}, + DictWord{ + 138, + 11, + 631, + }, + DictWord{135, 0, 892}, + DictWord{135, 11, 336}, + DictWord{9, 11, 931}, + DictWord{10, 11, 334}, + DictWord{148, 11, 71}, + DictWord{137, 0, 473}, + DictWord{6, 0, 864}, + DictWord{12, 0, 659}, + DictWord{139, 11, 926}, + DictWord{7, 0, 819}, + DictWord{9, 0, 26}, + DictWord{9, 0, 392}, + DictWord{10, 0, 152}, + DictWord{ + 10, + 0, + 226, + }, + DictWord{11, 0, 19}, + DictWord{12, 0, 276}, + DictWord{12, 0, 426}, + DictWord{12, 0, 589}, + DictWord{13, 0, 460}, + DictWord{15, 0, 97}, + DictWord{19, 0, 48}, + DictWord{148, 0, 104}, + DictWord{135, 0, 51}, + DictWord{133, 10, 326}, + DictWord{4, 10, 691}, + DictWord{146, 10, 16}, + DictWord{9, 0, 130}, + DictWord{11, 0, 765}, + DictWord{10, 10, 680}, + DictWord{10, 10, 793}, + DictWord{141, 10, 357}, + DictWord{133, 11, 765}, + DictWord{8, 0, 229}, + DictWord{6, 10, 32}, + DictWord{7, 10, 385}, + DictWord{7, 10, 757}, + DictWord{7, 10, 1916}, + DictWord{8, 10, 94}, + DictWord{8, 10, 711}, + DictWord{9, 10, 541}, + DictWord{10, 10, 162}, + DictWord{10, 10, 795}, + DictWord{11, 10, 989}, + DictWord{11, 10, 1010}, + DictWord{12, 10, 14}, + DictWord{142, 10, 308}, + DictWord{7, 11, 474}, + DictWord{137, 11, 578}, + DictWord{ + 132, + 0, + 674, + }, + DictWord{132, 0, 770}, + DictWord{5, 0, 79}, + DictWord{7, 0, 1027}, + DictWord{7, 0, 1477}, + DictWord{139, 0, 52}, + DictWord{133, 11, 424}, + DictWord{ + 134, + 0, + 1666, + }, + DictWord{6, 0, 409}, + DictWord{6, 10, 349}, + DictWord{6, 10, 1682}, + DictWord{7, 10, 1252}, + DictWord{8, 10, 112}, + DictWord{8, 11, 714}, + DictWord{ + 9, + 10, + 435, + }, + DictWord{9, 10, 668}, + DictWord{10, 10, 290}, + DictWord{10, 10, 319}, + DictWord{10, 10, 815}, + DictWord{11, 10, 180}, + DictWord{11, 10, 837}, + DictWord{ + 12, + 10, + 240, + }, + DictWord{13, 10, 152}, + DictWord{13, 10, 219}, + DictWord{142, 10, 158}, + DictWord{5, 0, 789}, + DictWord{134, 0, 195}, + DictWord{4, 0, 251}, + DictWord{ + 4, + 0, + 688, + }, + DictWord{7, 0, 513}, + DictWord{135, 0, 1284}, + DictWord{132, 10, 581}, + DictWord{9, 11, 420}, + DictWord{10, 11, 269}, + DictWord{10, 11, 285}, + DictWord{10, 11, 576}, + DictWord{11, 11, 397}, + DictWord{13, 11, 175}, + DictWord{145, 11, 90}, + DictWord{6, 10, 126}, + DictWord{7, 10, 573}, + DictWord{8, 10, 397}, + DictWord{142, 10, 44}, + DictWord{132, 11, 429}, + DictWord{133, 0, 889}, + DictWord{4, 0, 160}, + DictWord{5, 0, 330}, + DictWord{7, 0, 1434}, + DictWord{136, 0, 174}, + DictWord{7, 11, 18}, + DictWord{7, 11, 699}, + DictWord{7, 11, 1966}, + DictWord{8, 11, 752}, + DictWord{9, 11, 273}, + DictWord{9, 11, 412}, + DictWord{9, 11, 703}, + DictWord{ + 10, + 11, + 71, + }, + DictWord{10, 11, 427}, + DictWord{10, 11, 508}, + DictWord{146, 11, 97}, + DictWord{6, 0, 872}, + DictWord{134, 0, 899}, + DictWord{133, 10, 926}, + DictWord{134, 0, 1126}, + DictWord{134, 0, 918}, + DictWord{4, 11, 53}, + DictWord{5, 11, 186}, + DictWord{135, 11, 752}, + DictWord{7, 0, 268}, + DictWord{136, 0, 569}, + DictWord{134, 0, 1224}, + DictWord{6, 0, 1361}, + DictWord{7, 10, 1232}, + DictWord{137, 10, 531}, + DictWord{8, 11, 575}, + DictWord{10, 11, 289}, + DictWord{ + 139, + 11, + 319, + }, + DictWord{133, 10, 670}, + DictWord{132, 11, 675}, + DictWord{133, 0, 374}, + DictWord{135, 10, 1957}, + DictWord{133, 0, 731}, + DictWord{11, 0, 190}, + DictWord{15, 0, 49}, + DictWord{11, 11, 190}, + DictWord{143, 11, 49}, + DictWord{4, 0, 626}, + DictWord{5, 0, 506}, + DictWord{5, 0, 642}, + DictWord{6, 0, 425}, + DictWord{ + 10, + 0, + 202, + }, + DictWord{139, 0, 141}, + DictWord{137, 0, 444}, + DictWord{7, 10, 242}, + DictWord{135, 10, 1942}, + DictWord{6, 11, 209}, + DictWord{8, 11, 468}, + DictWord{ + 9, + 11, + 210, + }, + DictWord{11, 11, 36}, + DictWord{12, 11, 28}, + DictWord{12, 11, 630}, + DictWord{13, 11, 21}, + DictWord{13, 11, 349}, + DictWord{14, 11, 7}, + DictWord{ + 145, + 11, + 13, + }, + DictWord{4, 11, 342}, + DictWord{135, 11, 1179}, + DictWord{5, 10, 834}, + DictWord{7, 10, 1202}, + DictWord{8, 10, 14}, + DictWord{9, 10, 481}, + DictWord{ + 137, + 10, + 880, + }, + DictWord{4, 11, 928}, + DictWord{133, 11, 910}, + DictWord{4, 11, 318}, + DictWord{4, 11, 496}, + DictWord{7, 11, 856}, + DictWord{139, 11, 654}, + DictWord{136, 0, 835}, + DictWord{7, 0, 1526}, + DictWord{138, 10, 465}, + DictWord{151, 0, 17}, + DictWord{135, 0, 477}, + DictWord{4, 10, 357}, + DictWord{6, 10, 172}, + DictWord{7, 10, 143}, + DictWord{137, 10, 413}, + DictWord{6, 0, 1374}, + DictWord{138, 0, 994}, + DictWord{18, 0, 76}, + DictWord{132, 10, 590}, + DictWord{7, 0, 287}, + DictWord{8, 0, 355}, + DictWord{9, 0, 293}, + DictWord{137, 0, 743}, + DictWord{134, 0, 1389}, + DictWord{7, 11, 915}, + DictWord{8, 11, 247}, + DictWord{147, 11, 0}, + DictWord{ + 4, + 11, + 202, + }, + DictWord{5, 11, 382}, + DictWord{6, 11, 454}, + DictWord{7, 11, 936}, + DictWord{7, 11, 1803}, + DictWord{8, 11, 758}, + DictWord{9, 11, 375}, + DictWord{ + 9, + 11, + 895, + }, + DictWord{10, 11, 743}, + DictWord{10, 11, 792}, + DictWord{11, 11, 978}, + DictWord{11, 11, 1012}, + DictWord{142, 11, 109}, + DictWord{5, 0, 384}, + DictWord{8, 0, 455}, + DictWord{140, 0, 48}, + DictWord{132, 11, 390}, + DictWord{5, 10, 169}, + DictWord{7, 10, 333}, + DictWord{136, 10, 45}, + DictWord{5, 0, 264}, + DictWord{134, 0, 184}, + DictWord{138, 11, 791}, + DictWord{133, 11, 717}, + DictWord{132, 10, 198}, + DictWord{6, 11, 445}, + DictWord{7, 11, 332}, + DictWord{ + 137, + 11, + 909, + }, + DictWord{136, 0, 1001}, + DictWord{4, 10, 24}, + DictWord{5, 10, 140}, + DictWord{5, 10, 185}, + DictWord{7, 10, 1500}, + DictWord{11, 10, 565}, + DictWord{ + 139, + 10, + 838, + }, + DictWord{134, 11, 578}, + DictWord{5, 0, 633}, + DictWord{6, 0, 28}, + DictWord{135, 0, 1323}, + DictWord{132, 0, 851}, + DictWord{136, 11, 267}, + DictWord{ + 7, + 0, + 359, + }, + DictWord{8, 0, 243}, + DictWord{140, 0, 175}, + DictWord{4, 10, 334}, + DictWord{133, 10, 593}, + DictWord{141, 11, 87}, + DictWord{136, 11, 766}, + DictWord{10, 0, 287}, + DictWord{12, 0, 138}, + DictWord{10, 11, 287}, + DictWord{140, 11, 138}, + DictWord{4, 0, 105}, + DictWord{132, 0, 740}, + DictWord{140, 10, 116}, + DictWord{134, 0, 857}, + DictWord{135, 11, 1841}, + DictWord{6, 0, 1402}, + DictWord{137, 0, 819}, + DictWord{132, 11, 584}, + DictWord{132, 10, 709}, + DictWord{ + 133, + 10, + 897, + }, + DictWord{5, 0, 224}, + DictWord{13, 0, 174}, + DictWord{146, 0, 52}, + DictWord{135, 10, 1840}, + DictWord{4, 10, 608}, + DictWord{133, 10, 497}, + DictWord{139, 11, 60}, + DictWord{4, 0, 758}, + DictWord{135, 0, 1649}, + DictWord{4, 11, 226}, + DictWord{4, 11, 326}, + DictWord{135, 11, 1770}, + DictWord{5, 11, 426}, + DictWord{8, 11, 30}, + DictWord{9, 11, 2}, + DictWord{11, 11, 549}, + DictWord{147, 11, 122}, + DictWord{135, 10, 2039}, + DictWord{6, 10, 540}, + DictWord{ + 136, + 10, + 136, + }, + DictWord{4, 0, 573}, + DictWord{8, 0, 655}, + DictWord{4, 10, 897}, + DictWord{133, 10, 786}, + DictWord{7, 0, 351}, + DictWord{139, 0, 128}, + DictWord{ + 133, + 10, + 999, + }, + DictWord{4, 10, 299}, + DictWord{135, 10, 1004}, + DictWord{133, 0, 918}, + DictWord{132, 11, 345}, + DictWord{4, 11, 385}, + DictWord{7, 11, 265}, + DictWord{135, 11, 587}, + DictWord{133, 10, 456}, + DictWord{136, 10, 180}, + DictWord{6, 0, 687}, + DictWord{134, 0, 1537}, + DictWord{4, 11, 347}, + DictWord{ + 5, + 11, + 423, + }, + DictWord{5, 11, 996}, + DictWord{135, 11, 1329}, + DictWord{132, 10, 755}, + DictWord{7, 11, 1259}, + DictWord{9, 11, 125}, + DictWord{11, 11, 65}, + DictWord{140, 11, 285}, + DictWord{5, 11, 136}, + DictWord{6, 11, 136}, + DictWord{136, 11, 644}, + DictWord{134, 0, 1525}, + DictWord{4, 0, 1009}, + DictWord{ + 135, + 0, + 1139, + }, + DictWord{139, 10, 338}, + DictWord{132, 0, 340}, + DictWord{135, 10, 1464}, + DictWord{8, 0, 847}, + DictWord{10, 0, 861}, + DictWord{10, 0, 876}, + DictWord{ + 10, + 0, + 889, + }, + DictWord{10, 0, 922}, + DictWord{10, 0, 929}, + DictWord{10, 0, 933}, + DictWord{12, 0, 784}, + DictWord{140, 0, 791}, + DictWord{139, 0, 176}, + DictWord{ + 9, + 11, + 134, + }, + DictWord{10, 11, 2}, + DictWord{10, 11, 27}, + DictWord{10, 11, 333}, + DictWord{11, 11, 722}, + DictWord{143, 11, 1}, + DictWord{4, 11, 433}, + DictWord{ + 133, + 11, + 719, + }, + DictWord{5, 0, 985}, + DictWord{7, 0, 509}, + DictWord{7, 0, 529}, + DictWord{145, 0, 96}, + DictWord{132, 0, 615}, + DictWord{4, 10, 890}, + DictWord{ + 5, + 10, + 805, + }, + DictWord{5, 10, 819}, + DictWord{5, 10, 961}, + DictWord{6, 10, 396}, + DictWord{6, 10, 1631}, + DictWord{6, 10, 1678}, + DictWord{7, 10, 1967}, + DictWord{ + 7, + 10, + 2041, + }, + DictWord{9, 10, 630}, + DictWord{11, 10, 8}, + DictWord{11, 10, 1019}, + DictWord{12, 10, 176}, + DictWord{13, 10, 225}, + DictWord{14, 10, 292}, + DictWord{ + 149, + 10, + 24, + }, + DictWord{135, 0, 1919}, + DictWord{134, 0, 1131}, + DictWord{144, 11, 21}, + DictWord{144, 11, 51}, + DictWord{135, 10, 1815}, + DictWord{4, 0, 247}, + DictWord{7, 10, 1505}, + DictWord{10, 10, 190}, + DictWord{10, 10, 634}, + DictWord{11, 10, 792}, + DictWord{12, 10, 358}, + DictWord{140, 10, 447}, + DictWord{ + 5, + 10, + 0, + }, + DictWord{6, 10, 536}, + DictWord{7, 10, 604}, + DictWord{13, 10, 445}, + DictWord{145, 10, 126}, + DictWord{4, 0, 184}, + DictWord{5, 0, 390}, + DictWord{6, 0, 337}, + DictWord{7, 0, 23}, + DictWord{7, 0, 494}, + DictWord{7, 0, 618}, + DictWord{7, 0, 1456}, + DictWord{8, 0, 27}, + DictWord{8, 0, 599}, + DictWord{10, 0, 153}, + DictWord{ + 139, + 0, + 710, + }, + DictWord{6, 10, 232}, + DictWord{6, 10, 412}, + DictWord{7, 10, 1074}, + DictWord{8, 10, 9}, + DictWord{8, 10, 157}, + DictWord{8, 10, 786}, + DictWord{9, 10, 196}, + DictWord{9, 10, 352}, + DictWord{9, 10, 457}, + DictWord{10, 10, 337}, + DictWord{11, 10, 232}, + DictWord{11, 10, 877}, + DictWord{12, 10, 480}, + DictWord{ + 140, + 10, + 546, + }, + DictWord{13, 0, 38}, + DictWord{135, 10, 958}, + DictWord{4, 10, 382}, + DictWord{136, 10, 579}, + DictWord{4, 10, 212}, + DictWord{135, 10, 1206}, + DictWord{ + 4, + 11, + 555, + }, + DictWord{8, 11, 536}, + DictWord{138, 11, 288}, + DictWord{11, 11, 139}, + DictWord{139, 11, 171}, + DictWord{9, 11, 370}, + DictWord{138, 11, 90}, + DictWord{132, 0, 1015}, + DictWord{134, 0, 1088}, + DictWord{5, 10, 655}, + DictWord{135, 11, 977}, + DictWord{134, 0, 1585}, + DictWord{17, 10, 67}, + DictWord{ + 147, + 10, + 74, + }, + DictWord{10, 0, 227}, + DictWord{11, 0, 497}, + DictWord{11, 0, 709}, + DictWord{140, 0, 415}, + DictWord{6, 0, 360}, + DictWord{7, 0, 1664}, + DictWord{ + 136, + 0, + 478, + }, + DictWord{7, 0, 95}, + DictWord{6, 10, 231}, + DictWord{136, 10, 423}, + DictWord{140, 11, 65}, + DictWord{4, 11, 257}, + DictWord{135, 11, 2031}, + DictWord{ + 135, + 11, + 1768, + }, + DictWord{133, 10, 300}, + DictWord{139, 11, 211}, + DictWord{136, 0, 699}, + DictWord{6, 10, 237}, + DictWord{7, 10, 611}, + DictWord{8, 10, 100}, + DictWord{9, 10, 416}, + DictWord{11, 10, 335}, + DictWord{12, 10, 173}, + DictWord{146, 10, 101}, + DictWord{14, 0, 26}, + DictWord{146, 0, 150}, + DictWord{6, 0, 581}, + DictWord{135, 0, 1119}, + DictWord{135, 10, 1208}, + DictWord{132, 0, 739}, + DictWord{6, 11, 83}, + DictWord{6, 11, 1733}, + DictWord{135, 11, 1389}, + DictWord{ + 137, + 0, + 869, + }, + DictWord{4, 0, 67}, + DictWord{5, 0, 422}, + DictWord{7, 0, 1037}, + DictWord{7, 0, 1289}, + DictWord{7, 0, 1555}, + DictWord{9, 0, 741}, + DictWord{145, 0, 108}, + DictWord{133, 10, 199}, + DictWord{12, 10, 427}, + DictWord{146, 10, 38}, + DictWord{136, 0, 464}, + DictWord{142, 0, 42}, + DictWord{10, 0, 96}, + DictWord{8, 11, 501}, + DictWord{137, 11, 696}, + DictWord{134, 11, 592}, + DictWord{4, 0, 512}, + DictWord{4, 0, 966}, + DictWord{5, 0, 342}, + DictWord{6, 0, 1855}, + DictWord{8, 0, 869}, + DictWord{8, 0, 875}, + DictWord{8, 0, 901}, + DictWord{144, 0, 26}, + DictWord{8, 0, 203}, + DictWord{11, 0, 823}, + DictWord{11, 0, 846}, + DictWord{12, 0, 482}, + DictWord{ + 13, + 0, + 277, + }, + DictWord{13, 0, 302}, + DictWord{13, 0, 464}, + DictWord{14, 0, 205}, + DictWord{142, 0, 221}, + DictWord{4, 0, 449}, + DictWord{133, 0, 718}, + DictWord{ + 7, + 11, + 1718, + }, + DictWord{9, 11, 95}, + DictWord{9, 11, 274}, + DictWord{10, 11, 279}, + DictWord{10, 11, 317}, + DictWord{10, 11, 420}, + DictWord{11, 11, 303}, + DictWord{ + 11, + 11, + 808, + }, + DictWord{12, 11, 134}, + DictWord{12, 11, 367}, + DictWord{13, 11, 149}, + DictWord{13, 11, 347}, + DictWord{14, 11, 349}, + DictWord{14, 11, 406}, + DictWord{18, 11, 22}, + DictWord{18, 11, 89}, + DictWord{18, 11, 122}, + DictWord{147, 11, 47}, + DictWord{133, 11, 26}, + DictWord{4, 0, 355}, + DictWord{6, 0, 311}, + DictWord{ + 9, + 0, + 256, + }, + DictWord{138, 0, 404}, + DictWord{132, 11, 550}, + DictWord{10, 0, 758}, + DictWord{6, 10, 312}, + DictWord{6, 10, 1715}, + DictWord{10, 10, 584}, + DictWord{11, 10, 546}, + DictWord{11, 10, 692}, + DictWord{12, 10, 259}, + DictWord{12, 10, 295}, + DictWord{13, 10, 46}, + DictWord{141, 10, 154}, + DictWord{ + 136, + 11, + 822, + }, + DictWord{5, 0, 827}, + DictWord{4, 11, 902}, + DictWord{5, 11, 809}, + DictWord{6, 11, 122}, + DictWord{135, 11, 896}, + DictWord{5, 0, 64}, + DictWord{140, 0, 581}, + DictWord{4, 0, 442}, + DictWord{6, 0, 739}, + DictWord{7, 0, 1047}, + DictWord{7, 0, 1352}, + DictWord{7, 0, 1643}, + DictWord{7, 11, 1911}, + DictWord{9, 11, 449}, + DictWord{10, 11, 192}, + DictWord{138, 11, 740}, + DictWord{135, 11, 262}, + DictWord{132, 10, 588}, + DictWord{133, 11, 620}, + DictWord{5, 0, 977}, + DictWord{ + 6, + 0, + 288, + }, + DictWord{7, 0, 528}, + DictWord{4, 11, 34}, + DictWord{5, 11, 574}, + DictWord{7, 11, 279}, + DictWord{7, 11, 1624}, + DictWord{136, 11, 601}, + DictWord{ + 6, + 0, + 1375, + }, + DictWord{4, 10, 231}, + DictWord{5, 10, 61}, + DictWord{6, 10, 104}, + DictWord{7, 10, 729}, + DictWord{7, 10, 964}, + DictWord{7, 10, 1658}, + DictWord{ + 140, + 10, + 414, + }, + DictWord{6, 10, 263}, + DictWord{138, 10, 757}, + DictWord{132, 10, 320}, + DictWord{4, 0, 254}, + DictWord{7, 0, 1309}, + DictWord{5, 11, 332}, + DictWord{ + 135, + 11, + 1309, + }, + DictWord{6, 11, 261}, + DictWord{8, 11, 182}, + DictWord{139, 11, 943}, + DictWord{132, 10, 225}, + DictWord{6, 0, 12}, + DictWord{135, 0, 1219}, + DictWord{4, 0, 275}, + DictWord{12, 0, 376}, + DictWord{6, 11, 1721}, + DictWord{141, 11, 490}, + DictWord{4, 11, 933}, + DictWord{133, 11, 880}, + DictWord{6, 0, 951}, + DictWord{6, 0, 1109}, + DictWord{6, 0, 1181}, + DictWord{7, 0, 154}, + DictWord{4, 10, 405}, + DictWord{7, 10, 817}, + DictWord{14, 10, 58}, + DictWord{17, 10, 37}, + DictWord{ + 146, + 10, + 124, + }, + DictWord{6, 0, 1520}, + DictWord{133, 10, 974}, + DictWord{134, 0, 1753}, + DictWord{6, 0, 369}, + DictWord{6, 0, 502}, + DictWord{7, 0, 1036}, + DictWord{ + 8, + 0, + 348, + }, + DictWord{9, 0, 452}, + DictWord{10, 0, 26}, + DictWord{11, 0, 224}, + DictWord{11, 0, 387}, + DictWord{11, 0, 772}, + DictWord{12, 0, 95}, + DictWord{12, 0, 629}, + DictWord{13, 0, 195}, + DictWord{13, 0, 207}, + DictWord{13, 0, 241}, + DictWord{14, 0, 260}, + DictWord{14, 0, 270}, + DictWord{143, 0, 140}, + DictWord{132, 0, 269}, + DictWord{5, 0, 480}, + DictWord{7, 0, 532}, + DictWord{7, 0, 1197}, + DictWord{7, 0, 1358}, + DictWord{8, 0, 291}, + DictWord{11, 0, 349}, + DictWord{142, 0, 396}, + DictWord{ + 5, + 10, + 235, + }, + DictWord{7, 10, 1239}, + DictWord{11, 10, 131}, + DictWord{140, 10, 370}, + DictWord{7, 10, 956}, + DictWord{7, 10, 1157}, + DictWord{7, 10, 1506}, + DictWord{ + 7, + 10, + 1606, + }, + DictWord{7, 10, 1615}, + DictWord{7, 10, 1619}, + DictWord{7, 10, 1736}, + DictWord{7, 10, 1775}, + DictWord{8, 10, 590}, + DictWord{9, 10, 324}, + DictWord{9, 10, 736}, + DictWord{9, 10, 774}, + DictWord{9, 10, 776}, + DictWord{9, 10, 784}, + DictWord{10, 10, 567}, + DictWord{10, 10, 708}, + DictWord{11, 10, 518}, + DictWord{11, 10, 613}, + DictWord{11, 10, 695}, + DictWord{11, 10, 716}, + DictWord{11, 10, 739}, + DictWord{11, 10, 770}, + DictWord{11, 10, 771}, + DictWord{ + 11, + 10, + 848, + }, + DictWord{11, 10, 857}, + DictWord{11, 10, 931}, + DictWord{11, 10, 947}, + DictWord{12, 10, 326}, + DictWord{12, 10, 387}, + DictWord{12, 10, 484}, + DictWord{ + 12, + 10, + 528, + }, + DictWord{12, 10, 552}, + DictWord{12, 10, 613}, + DictWord{13, 10, 189}, + DictWord{13, 10, 256}, + DictWord{13, 10, 340}, + DictWord{13, 10, 432}, + DictWord{13, 10, 436}, + DictWord{13, 10, 440}, + DictWord{13, 10, 454}, + DictWord{14, 10, 174}, + DictWord{14, 10, 220}, + DictWord{14, 10, 284}, + DictWord{ + 14, + 10, + 390, + }, + DictWord{145, 10, 121}, + DictWord{8, 11, 598}, + DictWord{9, 11, 664}, + DictWord{138, 11, 441}, + DictWord{9, 10, 137}, + DictWord{138, 10, 221}, + DictWord{133, 11, 812}, + DictWord{148, 0, 15}, + DictWord{134, 0, 1341}, + DictWord{6, 0, 1017}, + DictWord{4, 11, 137}, + DictWord{7, 11, 1178}, + DictWord{ + 135, + 11, + 1520, + }, + DictWord{7, 10, 390}, + DictWord{138, 10, 140}, + DictWord{7, 11, 1260}, + DictWord{135, 11, 1790}, + DictWord{137, 11, 191}, + DictWord{ + 135, + 10, + 1144, + }, + DictWord{6, 0, 1810}, + DictWord{7, 0, 657}, + DictWord{8, 0, 886}, + DictWord{10, 0, 857}, + DictWord{14, 0, 440}, + DictWord{144, 0, 96}, + DictWord{8, 0, 533}, + DictWord{6, 11, 1661}, + DictWord{7, 11, 1975}, + DictWord{7, 11, 2009}, + DictWord{135, 11, 2011}, + DictWord{6, 0, 1453}, + DictWord{134, 10, 464}, + DictWord{ + 132, + 11, + 715, + }, + DictWord{5, 10, 407}, + DictWord{11, 10, 204}, + DictWord{11, 10, 243}, + DictWord{11, 10, 489}, + DictWord{12, 10, 293}, + DictWord{19, 10, 37}, + DictWord{20, 10, 73}, + DictWord{150, 10, 38}, + DictWord{133, 11, 703}, + DictWord{4, 0, 211}, + DictWord{7, 0, 1483}, + DictWord{5, 10, 325}, + DictWord{8, 10, 5}, + DictWord{ + 8, + 10, + 227, + }, + DictWord{9, 10, 105}, + DictWord{10, 10, 585}, + DictWord{140, 10, 614}, + DictWord{4, 0, 332}, + DictWord{5, 0, 335}, + DictWord{6, 0, 238}, + DictWord{ + 7, + 0, + 269, + }, + DictWord{7, 0, 811}, + DictWord{7, 0, 1797}, + DictWord{8, 0, 836}, + DictWord{9, 0, 507}, + DictWord{141, 0, 242}, + DictWord{5, 11, 89}, + DictWord{7, 11, 1915}, + DictWord{9, 11, 185}, + DictWord{9, 11, 235}, + DictWord{9, 11, 496}, + DictWord{10, 11, 64}, + DictWord{10, 11, 270}, + DictWord{10, 11, 403}, + DictWord{10, 11, 469}, + DictWord{10, 11, 529}, + DictWord{10, 11, 590}, + DictWord{11, 11, 140}, + DictWord{11, 11, 860}, + DictWord{13, 11, 1}, + DictWord{13, 11, 422}, + DictWord{14, 11, 341}, + DictWord{14, 11, 364}, + DictWord{17, 11, 93}, + DictWord{18, 11, 113}, + DictWord{19, 11, 97}, + DictWord{147, 11, 113}, + DictWord{133, 11, 695}, + DictWord{ + 16, + 0, + 19, + }, + DictWord{5, 11, 6}, + DictWord{6, 11, 183}, + DictWord{6, 10, 621}, + DictWord{7, 11, 680}, + DictWord{7, 11, 978}, + DictWord{7, 11, 1013}, + DictWord{7, 11, 1055}, + DictWord{12, 11, 230}, + DictWord{13, 11, 172}, + DictWord{13, 10, 504}, + DictWord{146, 11, 29}, + DictWord{136, 0, 156}, + DictWord{133, 0, 1009}, + DictWord{ + 6, + 11, + 29, + }, + DictWord{139, 11, 63}, + DictWord{134, 0, 820}, + DictWord{134, 10, 218}, + DictWord{7, 10, 454}, + DictWord{7, 10, 782}, + DictWord{8, 10, 768}, + DictWord{ + 140, + 10, + 686, + }, + DictWord{5, 0, 228}, + DictWord{6, 0, 203}, + DictWord{7, 0, 156}, + DictWord{8, 0, 347}, + DictWord{9, 0, 265}, + DictWord{18, 0, 39}, + DictWord{20, 0, 54}, + DictWord{21, 0, 31}, + DictWord{22, 0, 3}, + DictWord{23, 0, 0}, + DictWord{15, 11, 8}, + DictWord{18, 11, 39}, + DictWord{20, 11, 54}, + DictWord{21, 11, 31}, + DictWord{22, 11, 3}, + DictWord{151, 11, 0}, + DictWord{7, 0, 1131}, + DictWord{135, 0, 1468}, + DictWord{144, 10, 0}, + DictWord{134, 0, 1276}, + DictWord{10, 10, 676}, + DictWord{ + 140, + 10, + 462, + }, + DictWord{132, 11, 311}, + DictWord{134, 11, 1740}, + DictWord{7, 11, 170}, + DictWord{8, 11, 90}, + DictWord{8, 11, 177}, + DictWord{8, 11, 415}, + DictWord{ + 11, + 11, + 714, + }, + DictWord{142, 11, 281}, + DictWord{134, 10, 164}, + DictWord{6, 0, 1792}, + DictWord{138, 0, 849}, + DictWord{150, 10, 50}, + DictWord{5, 0, 291}, + DictWord{5, 0, 318}, + DictWord{7, 0, 765}, + DictWord{9, 0, 389}, + DictWord{12, 0, 548}, + DictWord{8, 11, 522}, + DictWord{142, 11, 328}, + DictWord{11, 11, 91}, + DictWord{ + 13, + 11, + 129, + }, + DictWord{15, 11, 101}, + DictWord{145, 11, 125}, + DictWord{4, 11, 494}, + DictWord{6, 11, 74}, + DictWord{7, 11, 44}, + DictWord{7, 11, 407}, + DictWord{ + 8, + 11, + 551, + }, + DictWord{12, 11, 17}, + DictWord{15, 11, 5}, + DictWord{148, 11, 11}, + DictWord{4, 11, 276}, + DictWord{133, 11, 296}, + DictWord{6, 10, 343}, + DictWord{ + 7, + 10, + 195, + }, + DictWord{7, 11, 1777}, + DictWord{9, 10, 226}, + DictWord{10, 10, 197}, + DictWord{10, 10, 575}, + DictWord{11, 10, 502}, + DictWord{139, 10, 899}, + DictWord{ + 10, + 0, + 525, + }, + DictWord{139, 0, 82}, + DictWord{14, 0, 453}, + DictWord{4, 11, 7}, + DictWord{5, 11, 90}, + DictWord{5, 11, 158}, + DictWord{6, 11, 542}, + DictWord{7, 11, 221}, + DictWord{7, 11, 1574}, + DictWord{9, 11, 490}, + DictWord{10, 11, 540}, + DictWord{11, 11, 443}, + DictWord{139, 11, 757}, + DictWord{135, 0, 666}, + DictWord{ + 22, + 10, + 29, + }, + DictWord{150, 11, 29}, + DictWord{4, 0, 422}, + DictWord{147, 10, 8}, + DictWord{5, 0, 355}, + DictWord{145, 0, 0}, + DictWord{6, 0, 1873}, + DictWord{9, 0, 918}, + DictWord{7, 11, 588}, + DictWord{9, 11, 175}, + DictWord{138, 11, 530}, + DictWord{143, 11, 31}, + DictWord{11, 0, 165}, + DictWord{7, 10, 1125}, + DictWord{9, 10, 143}, + DictWord{14, 10, 405}, + DictWord{150, 10, 21}, + DictWord{9, 0, 260}, + DictWord{137, 0, 905}, + DictWord{5, 11, 872}, + DictWord{6, 11, 57}, + DictWord{6, 11, 479}, + DictWord{ + 6, + 11, + 562, + }, + DictWord{7, 11, 471}, + DictWord{7, 11, 1060}, + DictWord{9, 11, 447}, + DictWord{9, 11, 454}, + DictWord{141, 11, 6}, + DictWord{138, 11, 704}, + DictWord{133, 0, 865}, + DictWord{5, 0, 914}, + DictWord{134, 0, 1625}, + DictWord{133, 0, 234}, + DictWord{7, 0, 1383}, + DictWord{5, 11, 31}, + DictWord{6, 11, 614}, + DictWord{145, 11, 61}, + DictWord{7, 11, 1200}, + DictWord{138, 11, 460}, + DictWord{6, 11, 424}, + DictWord{135, 11, 1866}, + DictWord{136, 0, 306}, + DictWord{ + 5, + 10, + 959, + }, + DictWord{12, 11, 30}, + DictWord{13, 11, 148}, + DictWord{14, 11, 87}, + DictWord{14, 11, 182}, + DictWord{16, 11, 42}, + DictWord{18, 11, 92}, + DictWord{ + 148, + 11, + 70, + }, + DictWord{6, 0, 1919}, + DictWord{6, 0, 1921}, + DictWord{9, 0, 923}, + DictWord{9, 0, 930}, + DictWord{9, 0, 941}, + DictWord{9, 0, 949}, + DictWord{9, 0, 987}, + DictWord{ + 9, + 0, + 988, + }, + DictWord{9, 0, 992}, + DictWord{12, 0, 802}, + DictWord{12, 0, 815}, + DictWord{12, 0, 856}, + DictWord{12, 0, 885}, + DictWord{12, 0, 893}, + DictWord{ + 12, + 0, + 898, + }, + DictWord{12, 0, 919}, + DictWord{12, 0, 920}, + DictWord{12, 0, 941}, + DictWord{12, 0, 947}, + DictWord{15, 0, 183}, + DictWord{15, 0, 185}, + DictWord{15, 0, 189}, + DictWord{15, 0, 197}, + DictWord{15, 0, 202}, + DictWord{15, 0, 233}, + DictWord{18, 0, 218}, + DictWord{18, 0, 219}, + DictWord{18, 0, 233}, + DictWord{143, 11, 156}, + DictWord{135, 10, 1759}, + DictWord{136, 10, 173}, + DictWord{13, 0, 163}, + DictWord{13, 0, 180}, + DictWord{18, 0, 78}, + DictWord{20, 0, 35}, + DictWord{5, 11, 13}, + DictWord{134, 11, 142}, + DictWord{134, 10, 266}, + DictWord{6, 11, 97}, + DictWord{7, 11, 116}, + DictWord{8, 11, 322}, + DictWord{8, 11, 755}, + DictWord{9, 11, 548}, + DictWord{10, 11, 714}, + DictWord{11, 11, 884}, + DictWord{141, 11, 324}, + DictWord{135, 0, 1312}, + DictWord{9, 0, 814}, + DictWord{137, 11, 676}, + DictWord{ + 133, + 0, + 707, + }, + DictWord{135, 0, 1493}, + DictWord{6, 0, 421}, + DictWord{7, 0, 61}, + DictWord{7, 0, 1540}, + DictWord{10, 0, 11}, + DictWord{138, 0, 501}, + DictWord{12, 0, 733}, + DictWord{12, 0, 766}, + DictWord{7, 11, 866}, + DictWord{135, 11, 1163}, + DictWord{137, 0, 341}, + DictWord{142, 0, 98}, + DictWord{145, 11, 115}, + DictWord{ + 135, + 11, + 1111, + }, + DictWord{136, 10, 300}, + DictWord{136, 0, 1014}, + DictWord{8, 11, 1}, + DictWord{9, 11, 112}, + DictWord{138, 11, 326}, + DictWord{132, 11, 730}, + DictWord{5, 11, 488}, + DictWord{6, 11, 527}, + DictWord{7, 11, 489}, + DictWord{7, 11, 1636}, + DictWord{8, 11, 121}, + DictWord{8, 11, 144}, + DictWord{8, 11, 359}, + DictWord{ + 9, + 11, + 193, + }, + DictWord{9, 11, 241}, + DictWord{9, 11, 336}, + DictWord{9, 11, 882}, + DictWord{11, 11, 266}, + DictWord{11, 11, 372}, + DictWord{11, 11, 944}, + DictWord{ + 12, + 11, + 401, + }, + DictWord{140, 11, 641}, + DictWord{6, 0, 971}, + DictWord{134, 0, 1121}, + DictWord{6, 0, 102}, + DictWord{7, 0, 72}, + DictWord{15, 0, 142}, + DictWord{ + 147, + 0, + 67, + }, + DictWord{151, 0, 30}, + DictWord{135, 0, 823}, + DictWord{134, 0, 1045}, + DictWord{5, 10, 427}, + DictWord{5, 10, 734}, + DictWord{7, 10, 478}, + DictWord{ + 136, + 10, + 52, + }, + DictWord{7, 0, 1930}, + DictWord{11, 10, 217}, + DictWord{142, 10, 165}, + DictWord{6, 0, 1512}, + DictWord{135, 0, 1870}, + DictWord{9, 11, 31}, + DictWord{ + 10, + 11, + 244, + }, + DictWord{10, 11, 699}, + DictWord{12, 11, 149}, + DictWord{141, 11, 497}, + DictWord{133, 11, 377}, + DictWord{145, 11, 101}, + DictWord{ + 10, + 11, + 158, + }, + DictWord{13, 11, 13}, + DictWord{13, 11, 137}, + DictWord{13, 11, 258}, + DictWord{14, 11, 111}, + DictWord{14, 11, 225}, + DictWord{14, 11, 253}, + DictWord{ + 14, + 11, + 304, + }, + DictWord{14, 11, 339}, + DictWord{14, 11, 417}, + DictWord{146, 11, 33}, + DictWord{6, 0, 87}, + DictWord{6, 10, 1734}, + DictWord{7, 10, 20}, + DictWord{ + 7, + 10, + 1056, + }, + DictWord{8, 10, 732}, + DictWord{9, 10, 406}, + DictWord{9, 10, 911}, + DictWord{138, 10, 694}, + DictWord{134, 0, 1243}, + DictWord{137, 0, 245}, + DictWord{ + 7, + 0, + 68, + }, + DictWord{8, 0, 48}, + DictWord{8, 0, 88}, + DictWord{8, 0, 582}, + DictWord{8, 0, 681}, + DictWord{9, 0, 373}, + DictWord{9, 0, 864}, + DictWord{11, 0, 157}, + DictWord{ + 11, + 0, + 336, + }, + DictWord{11, 0, 843}, + DictWord{148, 0, 27}, + DictWord{8, 11, 663}, + DictWord{144, 11, 8}, + DictWord{133, 10, 613}, + DictWord{4, 0, 88}, + DictWord{ + 5, + 0, + 137, + }, + DictWord{5, 0, 174}, + DictWord{5, 0, 777}, + DictWord{6, 0, 1664}, + DictWord{6, 0, 1725}, + DictWord{7, 0, 77}, + DictWord{7, 0, 426}, + DictWord{7, 0, 1317}, + DictWord{ + 7, + 0, + 1355, + }, + DictWord{8, 0, 126}, + DictWord{8, 0, 563}, + DictWord{9, 0, 523}, + DictWord{9, 0, 750}, + DictWord{10, 0, 310}, + DictWord{10, 0, 836}, + DictWord{11, 0, 42}, + DictWord{11, 0, 318}, + DictWord{11, 0, 731}, + DictWord{12, 0, 68}, + DictWord{12, 0, 92}, + DictWord{12, 0, 507}, + DictWord{12, 0, 692}, + DictWord{13, 0, 81}, + DictWord{ + 13, + 0, + 238, + }, + DictWord{13, 0, 374}, + DictWord{14, 0, 436}, + DictWord{18, 0, 138}, + DictWord{19, 0, 78}, + DictWord{19, 0, 111}, + DictWord{20, 0, 55}, + DictWord{20, 0, 77}, + DictWord{148, 0, 92}, + DictWord{141, 0, 418}, + DictWord{4, 0, 938}, + DictWord{137, 0, 625}, + DictWord{138, 0, 351}, + DictWord{5, 11, 843}, + DictWord{7, 10, 32}, + DictWord{ + 7, + 10, + 984, + }, + DictWord{8, 10, 85}, + DictWord{8, 10, 709}, + DictWord{9, 10, 579}, + DictWord{9, 10, 847}, + DictWord{9, 10, 856}, + DictWord{10, 10, 799}, + DictWord{ + 11, + 10, + 258, + }, + DictWord{11, 10, 1007}, + DictWord{12, 10, 331}, + DictWord{12, 10, 615}, + DictWord{13, 10, 188}, + DictWord{13, 10, 435}, + DictWord{14, 10, 8}, + DictWord{ + 15, + 10, + 165, + }, + DictWord{16, 10, 27}, + DictWord{148, 10, 40}, + DictWord{6, 0, 1668}, + DictWord{7, 0, 1499}, + DictWord{8, 0, 117}, + DictWord{9, 0, 314}, + DictWord{ + 138, + 0, + 174, + }, + DictWord{135, 0, 707}, + DictWord{132, 11, 554}, + DictWord{133, 11, 536}, + DictWord{5, 0, 403}, + DictWord{5, 11, 207}, + DictWord{9, 11, 79}, + DictWord{ + 11, + 11, + 625, + }, + DictWord{145, 11, 7}, + DictWord{132, 11, 424}, + DictWord{136, 11, 785}, + DictWord{4, 10, 167}, + DictWord{135, 10, 82}, + DictWord{9, 0, 7}, + DictWord{ + 23, + 0, + 6, + }, + DictWord{9, 11, 7}, + DictWord{151, 11, 6}, + DictWord{6, 0, 282}, + DictWord{5, 10, 62}, + DictWord{6, 10, 534}, + DictWord{7, 10, 74}, + DictWord{7, 10, 678}, + DictWord{ + 7, + 10, + 684, + }, + DictWord{7, 10, 1043}, + DictWord{7, 10, 1072}, + DictWord{8, 10, 280}, + DictWord{8, 10, 541}, + DictWord{8, 10, 686}, + DictWord{9, 10, 258}, + DictWord{ + 10, + 10, + 519, + }, + DictWord{11, 10, 252}, + DictWord{140, 10, 282}, + DictWord{138, 10, 33}, + DictWord{132, 10, 359}, + DictWord{4, 0, 44}, + DictWord{5, 0, 311}, + DictWord{ + 6, + 0, + 156, + }, + DictWord{7, 0, 639}, + DictWord{7, 0, 762}, + DictWord{7, 0, 1827}, + DictWord{9, 0, 8}, + DictWord{9, 0, 462}, + DictWord{148, 0, 83}, + DictWord{7, 11, 769}, + DictWord{ + 9, + 11, + 18, + }, + DictWord{138, 11, 358}, + DictWord{4, 0, 346}, + DictWord{7, 0, 115}, + DictWord{9, 0, 180}, + DictWord{9, 0, 456}, + DictWord{10, 0, 363}, + DictWord{ + 4, + 11, + 896, + }, + DictWord{134, 11, 1777}, + DictWord{133, 10, 211}, + DictWord{7, 0, 761}, + DictWord{7, 0, 1051}, + DictWord{137, 0, 545}, + DictWord{6, 10, 145}, + DictWord{ + 141, + 10, + 336, + }, + DictWord{7, 11, 750}, + DictWord{9, 11, 223}, + DictWord{11, 11, 27}, + DictWord{11, 11, 466}, + DictWord{12, 11, 624}, + DictWord{14, 11, 265}, + DictWord{146, 11, 61}, + DictWord{6, 0, 752}, + DictWord{6, 0, 768}, + DictWord{6, 0, 1195}, + DictWord{6, 0, 1254}, + DictWord{6, 0, 1619}, + DictWord{137, 0, 835}, + DictWord{ + 6, + 0, + 1936, + }, + DictWord{8, 0, 930}, + DictWord{136, 0, 960}, + DictWord{132, 10, 263}, + DictWord{132, 11, 249}, + DictWord{12, 0, 653}, + DictWord{132, 10, 916}, + DictWord{4, 11, 603}, + DictWord{133, 11, 661}, + DictWord{8, 0, 344}, + DictWord{4, 11, 11}, + DictWord{6, 11, 128}, + DictWord{7, 11, 231}, + DictWord{7, 11, 1533}, + DictWord{138, 11, 725}, + DictWord{134, 0, 1483}, + DictWord{134, 0, 875}, + DictWord{6, 0, 185}, + DictWord{7, 0, 1899}, + DictWord{9, 0, 875}, + DictWord{139, 0, 673}, + DictWord{15, 10, 155}, + DictWord{144, 10, 79}, + DictWord{7, 0, 93}, + DictWord{7, 0, 210}, + DictWord{7, 0, 1223}, + DictWord{8, 0, 451}, + DictWord{8, 0, 460}, + DictWord{ + 11, + 0, + 353, + }, + DictWord{11, 0, 475}, + DictWord{4, 10, 599}, + DictWord{6, 10, 1634}, + DictWord{7, 10, 67}, + DictWord{7, 10, 691}, + DictWord{7, 10, 979}, + DictWord{ + 7, + 10, + 1697, + }, + DictWord{8, 10, 207}, + DictWord{8, 10, 214}, + DictWord{8, 10, 231}, + DictWord{8, 10, 294}, + DictWord{8, 10, 336}, + DictWord{8, 10, 428}, + DictWord{ + 8, + 10, + 471, + }, + DictWord{8, 10, 622}, + DictWord{8, 10, 626}, + DictWord{8, 10, 679}, + DictWord{8, 10, 759}, + DictWord{8, 10, 829}, + DictWord{9, 10, 11}, + DictWord{9, 10, 246}, + DictWord{9, 10, 484}, + DictWord{9, 10, 573}, + DictWord{9, 10, 706}, + DictWord{9, 10, 762}, + DictWord{9, 10, 798}, + DictWord{9, 10, 855}, + DictWord{9, 10, 870}, + DictWord{ + 9, + 10, + 912, + }, + DictWord{10, 10, 303}, + DictWord{10, 10, 335}, + DictWord{10, 10, 424}, + DictWord{10, 10, 461}, + DictWord{10, 10, 543}, + DictWord{10, 10, 759}, + DictWord{10, 10, 814}, + DictWord{11, 10, 59}, + DictWord{11, 10, 235}, + DictWord{11, 10, 590}, + DictWord{11, 10, 929}, + DictWord{11, 10, 963}, + DictWord{ + 11, + 10, + 987, + }, + DictWord{12, 10, 114}, + DictWord{12, 10, 182}, + DictWord{12, 10, 226}, + DictWord{12, 10, 332}, + DictWord{12, 10, 439}, + DictWord{12, 10, 575}, + DictWord{ + 12, + 10, + 598, + }, + DictWord{12, 10, 675}, + DictWord{13, 10, 8}, + DictWord{13, 10, 125}, + DictWord{13, 10, 194}, + DictWord{13, 10, 287}, + DictWord{14, 10, 197}, + DictWord{14, 10, 383}, + DictWord{15, 10, 53}, + DictWord{17, 10, 63}, + DictWord{19, 10, 46}, + DictWord{19, 10, 98}, + DictWord{19, 10, 106}, + DictWord{148, 10, 85}, + DictWord{132, 11, 476}, + DictWord{4, 0, 327}, + DictWord{5, 0, 478}, + DictWord{7, 0, 1332}, + DictWord{136, 0, 753}, + DictWord{5, 0, 1020}, + DictWord{133, 0, 1022}, + DictWord{135, 11, 1807}, + DictWord{4, 0, 103}, + DictWord{133, 0, 401}, + DictWord{4, 0, 499}, + DictWord{135, 0, 1421}, + DictWord{10, 0, 207}, + DictWord{13, 0, 164}, + DictWord{147, 10, 126}, + DictWord{9, 11, 20}, + DictWord{10, 11, 324}, + DictWord{139, 11, 488}, + DictWord{132, 0, 96}, + DictWord{9, 11, 280}, + DictWord{ + 138, + 11, + 134, + }, + DictWord{135, 0, 968}, + DictWord{133, 10, 187}, + DictWord{135, 10, 1286}, + DictWord{5, 11, 112}, + DictWord{6, 11, 103}, + DictWord{134, 11, 150}, + DictWord{8, 0, 914}, + DictWord{10, 0, 3}, + DictWord{4, 10, 215}, + DictWord{9, 10, 38}, + DictWord{11, 10, 23}, + DictWord{11, 10, 127}, + DictWord{139, 10, 796}, + DictWord{ + 135, + 0, + 399, + }, + DictWord{6, 0, 563}, + DictWord{137, 0, 224}, + DictWord{6, 0, 704}, + DictWord{134, 0, 1214}, + DictWord{4, 11, 708}, + DictWord{8, 11, 15}, + DictWord{ + 9, + 11, + 50, + }, + DictWord{9, 11, 386}, + DictWord{11, 11, 18}, + DictWord{11, 11, 529}, + DictWord{140, 11, 228}, + DictWord{4, 11, 563}, + DictWord{7, 11, 109}, + DictWord{ + 7, + 11, + 592, + }, + DictWord{7, 11, 637}, + DictWord{7, 11, 770}, + DictWord{7, 11, 1701}, + DictWord{8, 11, 436}, + DictWord{8, 11, 463}, + DictWord{9, 11, 60}, + DictWord{9, 11, 335}, + DictWord{9, 11, 904}, + DictWord{10, 11, 73}, + DictWord{11, 11, 434}, + DictWord{12, 11, 585}, + DictWord{13, 11, 331}, + DictWord{18, 11, 110}, + DictWord{ + 148, + 11, + 60, + }, + DictWord{134, 0, 1559}, + DictWord{132, 11, 502}, + DictWord{6, 11, 347}, + DictWord{138, 11, 161}, + DictWord{4, 11, 33}, + DictWord{5, 11, 102}, + DictWord{ + 5, + 11, + 500, + }, + DictWord{6, 11, 284}, + DictWord{7, 11, 1079}, + DictWord{7, 11, 1423}, + DictWord{7, 11, 1702}, + DictWord{8, 11, 470}, + DictWord{9, 11, 554}, + DictWord{ + 9, + 11, + 723, + }, + DictWord{139, 11, 333}, + DictWord{7, 11, 246}, + DictWord{135, 11, 840}, + DictWord{6, 11, 10}, + DictWord{8, 11, 571}, + DictWord{9, 11, 739}, + DictWord{ + 143, + 11, + 91, + }, + DictWord{8, 0, 861}, + DictWord{10, 0, 905}, + DictWord{12, 0, 730}, + DictWord{12, 0, 789}, + DictWord{133, 11, 626}, + DictWord{134, 0, 946}, + DictWord{ + 5, + 0, + 746, + }, + DictWord{12, 0, 333}, + DictWord{14, 0, 332}, + DictWord{12, 11, 333}, + DictWord{142, 11, 332}, + DictWord{5, 11, 18}, + DictWord{6, 11, 526}, + DictWord{ + 13, + 11, + 24, + }, + DictWord{13, 11, 110}, + DictWord{19, 11, 5}, + DictWord{147, 11, 44}, + DictWord{4, 0, 910}, + DictWord{5, 0, 832}, + DictWord{135, 10, 2002}, + DictWord{ + 10, + 11, + 768, + }, + DictWord{139, 11, 787}, + DictWord{4, 11, 309}, + DictWord{5, 11, 462}, + DictWord{7, 11, 970}, + DictWord{135, 11, 1097}, + DictWord{4, 10, 28}, + DictWord{ + 5, + 10, + 440, + }, + DictWord{7, 10, 248}, + DictWord{11, 10, 833}, + DictWord{140, 10, 344}, + DictWord{134, 10, 1654}, + DictWord{6, 0, 632}, + DictWord{6, 0, 652}, + DictWord{ + 6, + 0, + 1272, + }, + DictWord{6, 0, 1384}, + DictWord{134, 0, 1560}, + DictWord{134, 11, 1704}, + DictWord{6, 0, 1393}, + DictWord{133, 10, 853}, + DictWord{6, 10, 249}, + DictWord{7, 10, 1234}, + DictWord{139, 10, 573}, + DictWord{5, 11, 86}, + DictWord{7, 11, 743}, + DictWord{9, 11, 85}, + DictWord{10, 11, 281}, + DictWord{10, 11, 432}, + DictWord{11, 11, 490}, + DictWord{12, 11, 251}, + DictWord{13, 11, 118}, + DictWord{14, 11, 378}, + DictWord{146, 11, 143}, + DictWord{5, 11, 524}, + DictWord{ + 133, + 11, + 744, + }, + DictWord{134, 0, 1514}, + DictWord{10, 0, 201}, + DictWord{142, 0, 319}, + DictWord{7, 0, 717}, + DictWord{10, 0, 510}, + DictWord{7, 10, 392}, + DictWord{ + 8, + 10, + 20, + }, + DictWord{8, 10, 172}, + DictWord{8, 10, 690}, + DictWord{9, 10, 383}, + DictWord{9, 10, 845}, + DictWord{11, 10, 293}, + DictWord{11, 10, 832}, + DictWord{ + 11, + 10, + 920, + }, + DictWord{11, 10, 984}, + DictWord{141, 10, 221}, + DictWord{134, 0, 1381}, + DictWord{5, 10, 858}, + DictWord{133, 10, 992}, + DictWord{8, 0, 528}, + DictWord{137, 0, 348}, + DictWord{10, 11, 107}, + DictWord{140, 11, 436}, + DictWord{4, 0, 20}, + DictWord{133, 0, 616}, + DictWord{134, 0, 1251}, + DictWord{ + 132, + 11, + 927, + }, + DictWord{10, 11, 123}, + DictWord{12, 11, 670}, + DictWord{13, 11, 371}, + DictWord{14, 11, 142}, + DictWord{146, 11, 94}, + DictWord{134, 0, 1163}, + DictWord{ + 7, + 11, + 1149, + }, + DictWord{137, 11, 156}, + DictWord{134, 0, 307}, + DictWord{133, 11, 778}, + DictWord{7, 0, 1091}, + DictWord{135, 0, 1765}, + DictWord{ + 5, + 11, + 502, + }, + DictWord{6, 10, 268}, + DictWord{137, 10, 62}, + DictWord{8, 11, 196}, + DictWord{10, 11, 283}, + DictWord{139, 11, 406}, + DictWord{4, 0, 26}, + DictWord{ + 5, + 0, + 429, + }, + DictWord{6, 0, 245}, + DictWord{7, 0, 704}, + DictWord{7, 0, 1379}, + DictWord{135, 0, 1474}, + DictWord{133, 11, 855}, + DictWord{132, 0, 881}, + DictWord{ + 4, + 0, + 621, + }, + DictWord{135, 11, 1596}, + DictWord{7, 11, 1400}, + DictWord{9, 11, 446}, + DictWord{138, 11, 45}, + DictWord{6, 0, 736}, + DictWord{138, 10, 106}, + DictWord{133, 0, 542}, + DictWord{134, 0, 348}, + DictWord{133, 0, 868}, + DictWord{136, 0, 433}, + DictWord{135, 0, 1495}, + DictWord{138, 0, 771}, + DictWord{ + 6, + 10, + 613, + }, + DictWord{136, 10, 223}, + DictWord{138, 0, 215}, + DictWord{141, 0, 124}, + DictWord{136, 11, 391}, + DictWord{135, 11, 172}, + DictWord{132, 10, 670}, + DictWord{140, 0, 55}, + DictWord{9, 10, 40}, + DictWord{139, 10, 136}, + DictWord{7, 0, 62}, + DictWord{147, 0, 112}, + DictWord{132, 0, 856}, + DictWord{132, 11, 568}, + DictWord{12, 0, 270}, + DictWord{139, 10, 259}, + DictWord{8, 0, 572}, + DictWord{137, 0, 698}, + DictWord{4, 11, 732}, + DictWord{9, 10, 310}, + DictWord{137, 10, 682}, + DictWord{142, 10, 296}, + DictWord{134, 0, 939}, + DictWord{136, 11, 733}, + DictWord{135, 11, 1435}, + DictWord{7, 10, 1401}, + DictWord{135, 10, 1476}, + DictWord{6, 0, 352}, + DictWord{4, 10, 296}, + DictWord{7, 10, 401}, + DictWord{7, 10, 1410}, + DictWord{7, 10, 1594}, + DictWord{7, 10, 1674}, + DictWord{8, 10, 63}, + DictWord{ + 8, + 10, + 660, + }, + DictWord{137, 10, 74}, + DictWord{4, 11, 428}, + DictWord{133, 11, 668}, + DictWord{4, 10, 139}, + DictWord{4, 10, 388}, + DictWord{140, 10, 188}, + DictWord{7, 11, 2015}, + DictWord{140, 11, 665}, + DictWord{132, 0, 647}, + DictWord{146, 0, 10}, + DictWord{138, 0, 220}, + DictWord{142, 0, 464}, + DictWord{ + 132, + 0, + 109, + }, + DictWord{134, 0, 1746}, + DictWord{6, 0, 515}, + DictWord{4, 10, 747}, + DictWord{6, 11, 1623}, + DictWord{6, 11, 1681}, + DictWord{7, 10, 649}, + DictWord{ + 7, + 10, + 1479, + }, + DictWord{135, 10, 1583}, + DictWord{133, 10, 232}, + DictWord{135, 0, 566}, + DictWord{137, 10, 887}, + DictWord{4, 0, 40}, + DictWord{10, 0, 67}, + DictWord{ + 11, + 0, + 117, + }, + DictWord{11, 0, 768}, + DictWord{139, 0, 935}, + DictWord{132, 0, 801}, + DictWord{7, 0, 992}, + DictWord{8, 0, 301}, + DictWord{9, 0, 722}, + DictWord{ + 12, + 0, + 63, + }, + DictWord{13, 0, 29}, + DictWord{14, 0, 161}, + DictWord{143, 0, 18}, + DictWord{139, 0, 923}, + DictWord{6, 11, 1748}, + DictWord{8, 11, 715}, + DictWord{9, 11, 802}, + DictWord{10, 11, 46}, + DictWord{10, 11, 819}, + DictWord{13, 11, 308}, + DictWord{14, 11, 351}, + DictWord{14, 11, 363}, + DictWord{146, 11, 67}, + DictWord{ + 137, + 11, + 745, + }, + DictWord{7, 0, 1145}, + DictWord{4, 10, 14}, + DictWord{7, 10, 1801}, + DictWord{10, 10, 748}, + DictWord{141, 10, 458}, + DictWord{4, 11, 63}, + DictWord{ + 5, + 11, + 347, + }, + DictWord{134, 11, 474}, + DictWord{135, 0, 568}, + DictWord{4, 10, 425}, + DictWord{7, 11, 577}, + DictWord{7, 11, 1432}, + DictWord{9, 11, 475}, + DictWord{ + 9, + 11, + 505, + }, + DictWord{9, 11, 526}, + DictWord{9, 11, 609}, + DictWord{9, 11, 689}, + DictWord{9, 11, 726}, + DictWord{9, 11, 735}, + DictWord{9, 11, 738}, + DictWord{ + 10, + 11, + 556, + }, + DictWord{10, 11, 674}, + DictWord{10, 11, 684}, + DictWord{11, 11, 89}, + DictWord{11, 11, 202}, + DictWord{11, 11, 272}, + DictWord{11, 11, 380}, + DictWord{ + 11, + 11, + 415, + }, + DictWord{11, 11, 505}, + DictWord{11, 11, 537}, + DictWord{11, 11, 550}, + DictWord{11, 11, 562}, + DictWord{11, 11, 640}, + DictWord{11, 11, 667}, + DictWord{11, 11, 688}, + DictWord{11, 11, 847}, + DictWord{11, 11, 927}, + DictWord{11, 11, 930}, + DictWord{11, 11, 940}, + DictWord{12, 11, 144}, + DictWord{ + 12, + 11, + 325, + }, + DictWord{12, 11, 329}, + DictWord{12, 11, 389}, + DictWord{12, 11, 403}, + DictWord{12, 11, 451}, + DictWord{12, 11, 515}, + DictWord{12, 11, 604}, + DictWord{ + 12, + 11, + 616, + }, + DictWord{12, 11, 626}, + DictWord{13, 11, 66}, + DictWord{13, 11, 131}, + DictWord{13, 11, 167}, + DictWord{13, 11, 236}, + DictWord{13, 11, 368}, + DictWord{13, 11, 411}, + DictWord{13, 11, 434}, + DictWord{13, 11, 453}, + DictWord{13, 11, 461}, + DictWord{13, 11, 474}, + DictWord{14, 11, 59}, + DictWord{14, 11, 60}, + DictWord{14, 11, 139}, + DictWord{14, 11, 152}, + DictWord{14, 11, 276}, + DictWord{14, 11, 353}, + DictWord{14, 11, 402}, + DictWord{15, 11, 28}, + DictWord{ + 15, + 11, + 81, + }, + DictWord{15, 11, 123}, + DictWord{15, 11, 152}, + DictWord{18, 11, 136}, + DictWord{148, 11, 88}, + DictWord{137, 0, 247}, + DictWord{135, 11, 1622}, + DictWord{ + 9, + 11, + 544, + }, + DictWord{11, 11, 413}, + DictWord{144, 11, 25}, + DictWord{4, 0, 645}, + DictWord{7, 0, 825}, + DictWord{6, 10, 1768}, + DictWord{135, 11, 89}, + DictWord{140, 0, 328}, + DictWord{5, 10, 943}, + DictWord{134, 10, 1779}, + DictWord{134, 0, 1363}, + DictWord{5, 10, 245}, + DictWord{6, 10, 576}, + DictWord{7, 10, 582}, + DictWord{136, 10, 225}, + DictWord{134, 0, 1280}, + DictWord{5, 11, 824}, + DictWord{133, 11, 941}, + DictWord{7, 11, 440}, + DictWord{8, 11, 230}, + DictWord{ + 139, + 11, + 106, + }, + DictWord{5, 0, 28}, + DictWord{6, 0, 204}, + DictWord{10, 0, 320}, + DictWord{10, 0, 583}, + DictWord{13, 0, 502}, + DictWord{14, 0, 72}, + DictWord{14, 0, 274}, + DictWord{14, 0, 312}, + DictWord{14, 0, 344}, + DictWord{15, 0, 159}, + DictWord{16, 0, 62}, + DictWord{16, 0, 69}, + DictWord{17, 0, 30}, + DictWord{18, 0, 42}, + DictWord{ + 18, + 0, + 53, + }, + DictWord{18, 0, 84}, + DictWord{18, 0, 140}, + DictWord{19, 0, 68}, + DictWord{19, 0, 85}, + DictWord{20, 0, 5}, + DictWord{20, 0, 45}, + DictWord{20, 0, 101}, + DictWord{ + 22, + 0, + 7, + }, + DictWord{150, 0, 20}, + DictWord{4, 0, 558}, + DictWord{6, 0, 390}, + DictWord{7, 0, 162}, + DictWord{7, 0, 689}, + DictWord{9, 0, 360}, + DictWord{138, 0, 653}, + DictWord{134, 0, 764}, + DictWord{6, 0, 862}, + DictWord{137, 0, 833}, + DictWord{5, 0, 856}, + DictWord{6, 0, 1672}, + DictWord{6, 0, 1757}, + DictWord{134, 0, 1781}, + DictWord{ + 5, + 0, + 92, + }, + DictWord{10, 0, 736}, + DictWord{140, 0, 102}, + DictWord{6, 0, 1927}, + DictWord{6, 0, 1944}, + DictWord{8, 0, 924}, + DictWord{8, 0, 948}, + DictWord{ + 10, + 0, + 967, + }, + DictWord{138, 0, 978}, + DictWord{134, 0, 1479}, + DictWord{5, 0, 590}, + DictWord{8, 0, 360}, + DictWord{9, 0, 213}, + DictWord{138, 0, 63}, + DictWord{ + 134, + 0, + 1521, + }, + DictWord{6, 0, 709}, + DictWord{134, 0, 891}, + DictWord{132, 10, 443}, + DictWord{13, 0, 477}, + DictWord{14, 0, 120}, + DictWord{148, 0, 61}, + DictWord{ + 4, + 11, + 914, + }, + DictWord{5, 11, 800}, + DictWord{133, 11, 852}, + DictWord{10, 11, 54}, + DictWord{141, 11, 115}, + DictWord{4, 11, 918}, + DictWord{133, 11, 876}, + DictWord{139, 11, 152}, + DictWord{4, 11, 92}, + DictWord{133, 11, 274}, + DictWord{135, 11, 1901}, + DictWord{9, 11, 800}, + DictWord{10, 11, 693}, + DictWord{ + 11, + 11, + 482, + }, + DictWord{11, 11, 734}, + DictWord{139, 11, 789}, + DictWord{9, 0, 483}, + DictWord{132, 10, 298}, + DictWord{6, 0, 1213}, + DictWord{141, 11, 498}, + DictWord{135, 11, 1451}, + DictWord{133, 11, 743}, + DictWord{4, 0, 1022}, + DictWord{10, 0, 1000}, + DictWord{12, 0, 957}, + DictWord{12, 0, 980}, + DictWord{ + 12, + 0, + 1013, + }, + DictWord{14, 0, 481}, + DictWord{144, 0, 116}, + DictWord{8, 0, 503}, + DictWord{17, 0, 29}, + DictWord{4, 11, 49}, + DictWord{7, 11, 280}, + DictWord{ + 135, + 11, + 1633, + }, + DictWord{135, 0, 1712}, + DictWord{134, 0, 466}, + DictWord{136, 11, 47}, + DictWord{5, 10, 164}, + DictWord{7, 10, 121}, + DictWord{142, 10, 189}, + DictWord{ + 7, + 10, + 812, + }, + DictWord{7, 10, 1261}, + DictWord{7, 10, 1360}, + DictWord{9, 10, 632}, + DictWord{140, 10, 352}, + DictWord{139, 10, 556}, + DictWord{132, 0, 731}, + DictWord{5, 11, 272}, + DictWord{5, 11, 908}, + DictWord{5, 11, 942}, + DictWord{7, 11, 1008}, + DictWord{7, 11, 1560}, + DictWord{8, 11, 197}, + DictWord{9, 11, 47}, + DictWord{11, 11, 538}, + DictWord{139, 11, 742}, + DictWord{4, 10, 172}, + DictWord{9, 10, 611}, + DictWord{10, 10, 436}, + DictWord{12, 10, 673}, + DictWord{ + 141, + 10, + 255, + }, + DictWord{133, 10, 844}, + DictWord{10, 0, 484}, + DictWord{11, 0, 754}, + DictWord{12, 0, 457}, + DictWord{14, 0, 171}, + DictWord{14, 0, 389}, + DictWord{ + 146, + 0, + 153, + }, + DictWord{9, 10, 263}, + DictWord{10, 10, 147}, + DictWord{138, 10, 492}, + DictWord{137, 11, 891}, + DictWord{138, 0, 241}, + DictWord{133, 10, 537}, + DictWord{6, 0, 2005}, + DictWord{136, 0, 964}, + DictWord{137, 10, 842}, + DictWord{151, 11, 8}, + DictWord{4, 11, 407}, + DictWord{132, 11, 560}, + DictWord{ + 135, + 11, + 1884, + }, + DictWord{6, 0, 1100}, + DictWord{134, 0, 1242}, + DictWord{135, 0, 954}, + DictWord{5, 10, 230}, + DictWord{5, 10, 392}, + DictWord{6, 10, 420}, + DictWord{ + 9, + 10, + 568, + }, + DictWord{140, 10, 612}, + DictWord{4, 11, 475}, + DictWord{11, 11, 35}, + DictWord{11, 11, 90}, + DictWord{13, 11, 7}, + DictWord{13, 11, 71}, + DictWord{ + 13, + 11, + 177, + }, + DictWord{142, 11, 422}, + DictWord{136, 11, 332}, + DictWord{135, 0, 1958}, + DictWord{6, 0, 549}, + DictWord{8, 0, 34}, + DictWord{8, 0, 283}, + DictWord{ + 9, + 0, + 165, + }, + DictWord{138, 0, 475}, + DictWord{10, 0, 952}, + DictWord{12, 0, 966}, + DictWord{140, 0, 994}, + DictWord{5, 0, 652}, + DictWord{5, 0, 701}, + DictWord{ + 135, + 0, + 449, + }, + DictWord{4, 0, 655}, + DictWord{7, 0, 850}, + DictWord{17, 0, 75}, + DictWord{146, 0, 137}, + DictWord{4, 0, 146}, + DictWord{7, 0, 1618}, + DictWord{8, 0, 670}, + DictWord{ + 5, + 10, + 41, + }, + DictWord{7, 10, 1459}, + DictWord{7, 10, 1469}, + DictWord{7, 10, 1859}, + DictWord{9, 10, 549}, + DictWord{139, 10, 905}, + DictWord{133, 10, 696}, + DictWord{6, 0, 159}, + DictWord{6, 0, 364}, + DictWord{7, 0, 516}, + DictWord{137, 0, 518}, + DictWord{135, 0, 1439}, + DictWord{6, 11, 222}, + DictWord{7, 11, 636}, + DictWord{ + 7, + 11, + 1620, + }, + DictWord{8, 11, 409}, + DictWord{9, 11, 693}, + DictWord{139, 11, 77}, + DictWord{13, 0, 151}, + DictWord{141, 11, 45}, + DictWord{6, 0, 1027}, + DictWord{ + 4, + 11, + 336, + }, + DictWord{132, 10, 771}, + DictWord{139, 11, 392}, + DictWord{10, 11, 121}, + DictWord{11, 11, 175}, + DictWord{149, 11, 16}, + DictWord{8, 0, 950}, + DictWord{138, 0, 983}, + DictWord{133, 10, 921}, + DictWord{135, 0, 993}, + DictWord{6, 10, 180}, + DictWord{7, 10, 1137}, + DictWord{8, 10, 751}, + DictWord{ + 139, + 10, + 805, + }, + DictWord{7, 0, 501}, + DictWord{9, 0, 111}, + DictWord{10, 0, 141}, + DictWord{11, 0, 332}, + DictWord{13, 0, 43}, + DictWord{13, 0, 429}, + DictWord{14, 0, 130}, + DictWord{14, 0, 415}, + DictWord{145, 0, 102}, + DictWord{4, 10, 183}, + DictWord{5, 11, 882}, + DictWord{7, 10, 271}, + DictWord{11, 10, 824}, + DictWord{11, 10, 952}, + DictWord{13, 10, 278}, + DictWord{13, 10, 339}, + DictWord{13, 10, 482}, + DictWord{14, 10, 424}, + DictWord{148, 10, 99}, + DictWord{4, 10, 19}, + DictWord{5, 10, 477}, + DictWord{5, 10, 596}, + DictWord{6, 10, 505}, + DictWord{7, 10, 1221}, + DictWord{11, 10, 907}, + DictWord{12, 10, 209}, + DictWord{141, 10, 214}, + DictWord{ + 135, + 10, + 1215, + }, + DictWord{133, 0, 452}, + DictWord{132, 11, 426}, + DictWord{5, 0, 149}, + DictWord{136, 0, 233}, + DictWord{133, 0, 935}, + DictWord{6, 11, 58}, + DictWord{ + 7, + 11, + 654, + }, + DictWord{7, 11, 745}, + DictWord{7, 11, 1969}, + DictWord{8, 11, 240}, + DictWord{8, 11, 675}, + DictWord{9, 11, 479}, + DictWord{9, 11, 731}, + DictWord{ + 10, + 11, + 330, + }, + DictWord{10, 11, 593}, + DictWord{10, 11, 817}, + DictWord{11, 11, 32}, + DictWord{11, 11, 133}, + DictWord{11, 11, 221}, + DictWord{145, 11, 68}, + DictWord{ + 12, + 0, + 582, + }, + DictWord{18, 0, 131}, + DictWord{7, 11, 102}, + DictWord{137, 11, 538}, + DictWord{136, 0, 801}, + DictWord{134, 10, 1645}, + DictWord{132, 0, 70}, + DictWord{6, 10, 92}, + DictWord{6, 10, 188}, + DictWord{7, 10, 1269}, + DictWord{7, 10, 1524}, + DictWord{7, 10, 1876}, + DictWord{10, 10, 228}, + DictWord{139, 10, 1020}, + DictWord{4, 10, 459}, + DictWord{133, 10, 966}, + DictWord{138, 0, 369}, + DictWord{16, 0, 36}, + DictWord{140, 10, 330}, + DictWord{141, 11, 366}, + DictWord{ + 7, + 0, + 721, + }, + DictWord{10, 0, 236}, + DictWord{12, 0, 204}, + DictWord{6, 10, 18}, + DictWord{7, 10, 932}, + DictWord{8, 10, 757}, + DictWord{9, 10, 54}, + DictWord{9, 10, 65}, + DictWord{9, 10, 844}, + DictWord{10, 10, 113}, + DictWord{10, 10, 315}, + DictWord{10, 10, 798}, + DictWord{11, 10, 153}, + DictWord{12, 10, 151}, + DictWord{12, 10, 392}, + DictWord{12, 10, 666}, + DictWord{142, 10, 248}, + DictWord{7, 0, 241}, + DictWord{10, 0, 430}, + DictWord{8, 10, 548}, + DictWord{9, 10, 532}, + DictWord{10, 10, 117}, + DictWord{11, 10, 351}, + DictWord{11, 10, 375}, + DictWord{143, 10, 23}, + DictWord{134, 10, 1742}, + DictWord{133, 10, 965}, + DictWord{133, 11, 566}, + DictWord{ + 6, + 11, + 48, + }, + DictWord{135, 11, 63}, + DictWord{134, 10, 182}, + DictWord{10, 10, 65}, + DictWord{10, 10, 488}, + DictWord{138, 10, 497}, + DictWord{6, 11, 114}, + DictWord{7, 11, 1224}, + DictWord{7, 11, 1556}, + DictWord{136, 11, 3}, + DictWord{134, 0, 1817}, + DictWord{8, 11, 576}, + DictWord{137, 11, 267}, + DictWord{ + 6, + 0, + 1078, + }, + DictWord{144, 0, 16}, + DictWord{9, 10, 588}, + DictWord{138, 10, 260}, + DictWord{138, 0, 1021}, + DictWord{5, 0, 406}, + DictWord{134, 0, 2022}, + DictWord{133, 11, 933}, + DictWord{6, 0, 69}, + DictWord{135, 0, 117}, + DictWord{7, 0, 1830}, + DictWord{136, 11, 427}, + DictWord{4, 0, 432}, + DictWord{135, 0, 824}, + DictWord{134, 10, 1786}, + DictWord{133, 0, 826}, + DictWord{139, 11, 67}, + DictWord{133, 11, 759}, + DictWord{135, 10, 308}, + DictWord{137, 0, 816}, + DictWord{ + 133, + 0, + 1000, + }, + DictWord{4, 0, 297}, + DictWord{6, 0, 529}, + DictWord{7, 0, 152}, + DictWord{7, 0, 713}, + DictWord{7, 0, 1845}, + DictWord{8, 0, 710}, + DictWord{8, 0, 717}, + DictWord{12, 0, 639}, + DictWord{140, 0, 685}, + DictWord{7, 0, 423}, + DictWord{136, 10, 588}, + DictWord{136, 10, 287}, + DictWord{136, 0, 510}, + DictWord{ + 134, + 0, + 1048, + }, + DictWord{6, 0, 618}, + DictWord{7, 11, 56}, + DictWord{7, 11, 1989}, + DictWord{8, 11, 337}, + DictWord{8, 11, 738}, + DictWord{9, 11, 600}, + DictWord{ + 10, + 11, + 483, + }, + DictWord{12, 11, 37}, + DictWord{13, 11, 447}, + DictWord{142, 11, 92}, + DictWord{4, 0, 520}, + DictWord{135, 0, 575}, + DictWord{8, 0, 990}, + DictWord{ + 138, + 0, + 977, + }, + DictWord{135, 11, 774}, + DictWord{9, 11, 347}, + DictWord{11, 11, 24}, + DictWord{140, 11, 170}, + DictWord{136, 11, 379}, + DictWord{140, 10, 290}, + DictWord{132, 11, 328}, + DictWord{4, 0, 321}, + DictWord{134, 0, 569}, + DictWord{4, 11, 101}, + DictWord{135, 11, 1171}, + DictWord{7, 0, 723}, + DictWord{7, 0, 1135}, + DictWord{5, 11, 833}, + DictWord{136, 11, 744}, + DictWord{7, 10, 719}, + DictWord{8, 10, 809}, + DictWord{136, 10, 834}, + DictWord{8, 0, 921}, + DictWord{136, 10, 796}, + DictWord{5, 10, 210}, + DictWord{6, 10, 213}, + DictWord{7, 10, 60}, + DictWord{10, 10, 364}, + DictWord{139, 10, 135}, + DictWord{5, 0, 397}, + DictWord{6, 0, 154}, + DictWord{7, 0, 676}, + DictWord{8, 0, 443}, + DictWord{8, 0, 609}, + DictWord{9, 0, 24}, + DictWord{9, 0, 325}, + DictWord{10, 0, 35}, + DictWord{11, 0, 535}, + DictWord{11, 0, 672}, + DictWord{11, 0, 1018}, + DictWord{12, 0, 637}, + DictWord{16, 0, 30}, + DictWord{5, 10, 607}, + DictWord{8, 10, 326}, + DictWord{136, 10, 490}, + DictWord{4, 10, 701}, + DictWord{5, 10, 472}, + DictWord{6, 11, 9}, + DictWord{6, 11, 397}, + DictWord{7, 11, 53}, + DictWord{7, 11, 1742}, + DictWord{9, 10, 758}, + DictWord{10, 11, 632}, + DictWord{ + 11, + 11, + 828, + }, + DictWord{140, 11, 146}, + DictWord{135, 10, 380}, + DictWord{135, 10, 1947}, + DictWord{148, 11, 109}, + DictWord{10, 10, 278}, + DictWord{ + 138, + 11, + 278, + }, + DictWord{134, 0, 856}, + DictWord{7, 0, 139}, + DictWord{4, 10, 386}, + DictWord{8, 10, 405}, + DictWord{8, 10, 728}, + DictWord{9, 10, 497}, + DictWord{ + 11, + 10, + 110, + }, + DictWord{11, 10, 360}, + DictWord{15, 10, 37}, + DictWord{144, 10, 84}, + DictWord{141, 0, 282}, + DictWord{133, 0, 981}, + DictWord{5, 0, 288}, + DictWord{ + 7, + 10, + 1452, + }, + DictWord{7, 10, 1480}, + DictWord{8, 10, 634}, + DictWord{140, 10, 472}, + DictWord{7, 0, 1890}, + DictWord{8, 11, 367}, + DictWord{10, 11, 760}, + DictWord{ + 14, + 11, + 79, + }, + DictWord{20, 11, 17}, + DictWord{152, 11, 0}, + DictWord{4, 10, 524}, + DictWord{136, 10, 810}, + DictWord{4, 0, 56}, + DictWord{7, 0, 1791}, + DictWord{ + 8, + 0, + 607, + }, + DictWord{8, 0, 651}, + DictWord{11, 0, 465}, + DictWord{11, 0, 835}, + DictWord{12, 0, 337}, + DictWord{141, 0, 480}, + DictWord{10, 10, 238}, + DictWord{ + 141, + 10, + 33, + }, + DictWord{11, 11, 417}, + DictWord{12, 11, 223}, + DictWord{140, 11, 265}, + DictWord{9, 0, 158}, + DictWord{10, 0, 411}, + DictWord{140, 0, 261}, + DictWord{ + 133, + 10, + 532, + }, + DictWord{133, 10, 997}, + DictWord{12, 11, 186}, + DictWord{12, 11, 292}, + DictWord{14, 11, 100}, + DictWord{146, 11, 70}, + DictWord{6, 0, 1403}, + DictWord{136, 0, 617}, + DictWord{134, 0, 1205}, + DictWord{139, 0, 563}, + DictWord{4, 0, 242}, + DictWord{134, 0, 333}, + DictWord{4, 11, 186}, + DictWord{5, 11, 157}, + DictWord{8, 11, 168}, + DictWord{138, 11, 6}, + DictWord{132, 0, 369}, + DictWord{133, 11, 875}, + DictWord{5, 10, 782}, + DictWord{5, 10, 829}, + DictWord{ + 134, + 10, + 1738, + }, + DictWord{134, 0, 622}, + DictWord{135, 11, 1272}, + DictWord{6, 0, 1407}, + DictWord{7, 11, 111}, + DictWord{136, 11, 581}, + DictWord{7, 10, 1823}, + DictWord{139, 10, 693}, + DictWord{7, 0, 160}, + DictWord{10, 0, 624}, + DictWord{142, 0, 279}, + DictWord{132, 0, 363}, + DictWord{10, 11, 589}, + DictWord{12, 11, 111}, + DictWord{13, 11, 260}, + DictWord{14, 11, 82}, + DictWord{18, 11, 63}, + DictWord{147, 11, 45}, + DictWord{7, 11, 1364}, + DictWord{7, 11, 1907}, + DictWord{ + 141, + 11, + 158, + }, + DictWord{4, 11, 404}, + DictWord{4, 11, 659}, + DictWord{135, 11, 675}, + DictWord{13, 11, 211}, + DictWord{14, 11, 133}, + DictWord{14, 11, 204}, + DictWord{ + 15, + 11, + 64, + }, + DictWord{15, 11, 69}, + DictWord{15, 11, 114}, + DictWord{16, 11, 10}, + DictWord{19, 11, 23}, + DictWord{19, 11, 35}, + DictWord{19, 11, 39}, + DictWord{ + 19, + 11, + 51, + }, + DictWord{19, 11, 71}, + DictWord{19, 11, 75}, + DictWord{152, 11, 15}, + DictWord{4, 10, 78}, + DictWord{5, 10, 96}, + DictWord{5, 10, 182}, + DictWord{7, 10, 1724}, + DictWord{7, 10, 1825}, + DictWord{10, 10, 394}, + DictWord{10, 10, 471}, + DictWord{11, 10, 532}, + DictWord{14, 10, 340}, + DictWord{145, 10, 88}, + DictWord{ + 135, + 10, + 1964, + }, + DictWord{133, 11, 391}, + DictWord{11, 11, 887}, + DictWord{14, 11, 365}, + DictWord{142, 11, 375}, + DictWord{5, 11, 540}, + DictWord{6, 11, 1697}, + DictWord{7, 11, 222}, + DictWord{136, 11, 341}, + DictWord{134, 11, 78}, + DictWord{9, 0, 601}, + DictWord{9, 0, 619}, + DictWord{10, 0, 505}, + DictWord{10, 0, 732}, + DictWord{11, 0, 355}, + DictWord{140, 0, 139}, + DictWord{134, 0, 292}, + DictWord{139, 0, 174}, + DictWord{5, 0, 177}, + DictWord{6, 0, 616}, + DictWord{7, 0, 827}, + DictWord{ + 9, + 0, + 525, + }, + DictWord{138, 0, 656}, + DictWord{10, 0, 31}, + DictWord{6, 10, 215}, + DictWord{7, 10, 1028}, + DictWord{7, 10, 1473}, + DictWord{7, 10, 1721}, + DictWord{ + 9, + 10, + 424, + }, + DictWord{138, 10, 779}, + DictWord{135, 10, 584}, + DictWord{136, 11, 293}, + DictWord{134, 0, 685}, + DictWord{135, 11, 1868}, + DictWord{ + 133, + 11, + 460, + }, + DictWord{7, 0, 647}, + DictWord{6, 10, 67}, + DictWord{7, 10, 1630}, + DictWord{9, 10, 354}, + DictWord{9, 10, 675}, + DictWord{10, 10, 830}, + DictWord{ + 14, + 10, + 80, + }, + DictWord{145, 10, 80}, + DictWord{4, 0, 161}, + DictWord{133, 0, 631}, + DictWord{6, 10, 141}, + DictWord{7, 10, 225}, + DictWord{9, 10, 59}, + DictWord{9, 10, 607}, + DictWord{10, 10, 312}, + DictWord{11, 10, 687}, + DictWord{12, 10, 555}, + DictWord{13, 10, 373}, + DictWord{13, 10, 494}, + DictWord{148, 10, 58}, + DictWord{ + 7, + 11, + 965, + }, + DictWord{7, 11, 1460}, + DictWord{135, 11, 1604}, + DictWord{136, 10, 783}, + DictWord{134, 11, 388}, + DictWord{6, 0, 722}, + DictWord{6, 0, 1267}, + DictWord{ + 4, + 11, + 511, + }, + DictWord{9, 11, 333}, + DictWord{9, 11, 379}, + DictWord{10, 11, 602}, + DictWord{11, 11, 441}, + DictWord{11, 11, 723}, + DictWord{11, 11, 976}, + DictWord{140, 11, 357}, + DictWord{134, 0, 1797}, + DictWord{135, 0, 1684}, + DictWord{9, 0, 469}, + DictWord{9, 0, 709}, + DictWord{12, 0, 512}, + DictWord{14, 0, 65}, + DictWord{17, 0, 12}, + DictWord{5, 11, 938}, + DictWord{136, 11, 707}, + DictWord{7, 0, 1230}, + DictWord{136, 0, 531}, + DictWord{10, 0, 229}, + DictWord{11, 0, 73}, + DictWord{ + 11, + 0, + 376, + }, + DictWord{139, 0, 433}, + DictWord{12, 0, 268}, + DictWord{12, 0, 640}, + DictWord{142, 0, 119}, + DictWord{7, 10, 430}, + DictWord{139, 10, 46}, + DictWord{ + 6, + 0, + 558, + }, + DictWord{7, 0, 651}, + DictWord{8, 0, 421}, + DictWord{9, 0, 0}, + DictWord{10, 0, 34}, + DictWord{139, 0, 1008}, + DictWord{6, 0, 106}, + DictWord{7, 0, 1786}, + DictWord{7, 0, 1821}, + DictWord{9, 0, 102}, + DictWord{9, 0, 763}, + DictWord{5, 10, 602}, + DictWord{7, 10, 2018}, + DictWord{137, 10, 418}, + DictWord{5, 0, 65}, + DictWord{ + 6, + 0, + 416, + }, + DictWord{7, 0, 1720}, + DictWord{7, 0, 1924}, + DictWord{10, 0, 109}, + DictWord{11, 0, 14}, + DictWord{11, 0, 70}, + DictWord{11, 0, 569}, + DictWord{11, 0, 735}, + DictWord{15, 0, 153}, + DictWord{20, 0, 80}, + DictWord{136, 10, 677}, + DictWord{135, 11, 1625}, + DictWord{137, 11, 772}, + DictWord{136, 0, 595}, + DictWord{ + 6, + 11, + 469, + }, + DictWord{7, 11, 1709}, + DictWord{138, 11, 515}, + DictWord{7, 0, 1832}, + DictWord{138, 0, 374}, + DictWord{9, 0, 106}, + DictWord{9, 0, 163}, + DictWord{ + 9, + 0, + 296, + }, + DictWord{10, 0, 167}, + DictWord{10, 0, 172}, + DictWord{10, 0, 777}, + DictWord{139, 0, 16}, + DictWord{6, 0, 6}, + DictWord{7, 0, 81}, + DictWord{7, 0, 771}, + DictWord{ + 7, + 0, + 1731, + }, + DictWord{9, 0, 405}, + DictWord{138, 0, 421}, + DictWord{4, 11, 500}, + DictWord{135, 11, 938}, + DictWord{5, 11, 68}, + DictWord{134, 11, 383}, + DictWord{ + 5, + 0, + 881, + }, + DictWord{133, 0, 885}, + DictWord{6, 0, 854}, + DictWord{6, 0, 1132}, + DictWord{6, 0, 1495}, + DictWord{6, 0, 1526}, + DictWord{6, 0, 1533}, + DictWord{ + 134, + 0, + 1577, + }, + DictWord{4, 11, 337}, + DictWord{6, 11, 353}, + DictWord{7, 11, 1934}, + DictWord{8, 11, 488}, + DictWord{137, 11, 429}, + DictWord{7, 11, 236}, + DictWord{ + 7, + 11, + 1795, + }, + DictWord{8, 11, 259}, + DictWord{9, 11, 135}, + DictWord{9, 11, 177}, + DictWord{10, 11, 825}, + DictWord{11, 11, 115}, + DictWord{11, 11, 370}, + DictWord{ + 11, + 11, + 405, + }, + DictWord{11, 11, 604}, + DictWord{12, 11, 10}, + DictWord{12, 11, 667}, + DictWord{12, 11, 669}, + DictWord{13, 11, 76}, + DictWord{14, 11, 310}, + DictWord{15, 11, 76}, + DictWord{15, 11, 147}, + DictWord{148, 11, 23}, + DictWord{5, 0, 142}, + DictWord{134, 0, 546}, + DictWord{4, 11, 15}, + DictWord{5, 11, 22}, + DictWord{ + 6, + 11, + 244, + }, + DictWord{7, 11, 40}, + DictWord{7, 11, 200}, + DictWord{7, 11, 906}, + DictWord{7, 11, 1199}, + DictWord{9, 11, 616}, + DictWord{10, 11, 716}, + DictWord{ + 11, + 11, + 635, + }, + DictWord{11, 11, 801}, + DictWord{140, 11, 458}, + DictWord{5, 0, 466}, + DictWord{11, 0, 571}, + DictWord{12, 0, 198}, + DictWord{13, 0, 283}, + DictWord{ + 14, + 0, + 186, + }, + DictWord{15, 0, 21}, + DictWord{15, 0, 103}, + DictWord{135, 10, 329}, + DictWord{4, 0, 185}, + DictWord{5, 0, 257}, + DictWord{5, 0, 839}, + DictWord{5, 0, 936}, + DictWord{9, 0, 399}, + DictWord{10, 0, 258}, + DictWord{10, 0, 395}, + DictWord{10, 0, 734}, + DictWord{11, 0, 1014}, + DictWord{12, 0, 23}, + DictWord{13, 0, 350}, + DictWord{ + 14, + 0, + 150, + }, + DictWord{19, 0, 6}, + DictWord{135, 11, 1735}, + DictWord{12, 11, 36}, + DictWord{141, 11, 337}, + DictWord{5, 11, 598}, + DictWord{7, 11, 791}, + DictWord{ + 8, + 11, + 108, + }, + DictWord{137, 11, 123}, + DictWord{132, 10, 469}, + DictWord{7, 0, 404}, + DictWord{7, 0, 1377}, + DictWord{7, 0, 1430}, + DictWord{7, 0, 2017}, + DictWord{ + 8, + 0, + 149, + }, + DictWord{8, 0, 239}, + DictWord{8, 0, 512}, + DictWord{8, 0, 793}, + DictWord{8, 0, 818}, + DictWord{9, 0, 474}, + DictWord{9, 0, 595}, + DictWord{10, 0, 122}, + DictWord{10, 0, 565}, + DictWord{10, 0, 649}, + DictWord{10, 0, 783}, + DictWord{11, 0, 239}, + DictWord{11, 0, 295}, + DictWord{11, 0, 447}, + DictWord{11, 0, 528}, + DictWord{ + 11, + 0, + 639, + }, + DictWord{11, 0, 800}, + DictWord{12, 0, 25}, + DictWord{12, 0, 77}, + DictWord{12, 0, 157}, + DictWord{12, 0, 256}, + DictWord{12, 0, 316}, + DictWord{12, 0, 390}, + DictWord{12, 0, 391}, + DictWord{12, 0, 395}, + DictWord{12, 0, 478}, + DictWord{12, 0, 503}, + DictWord{12, 0, 592}, + DictWord{12, 0, 680}, + DictWord{13, 0, 50}, + DictWord{13, 0, 53}, + DictWord{13, 0, 132}, + DictWord{13, 0, 198}, + DictWord{13, 0, 322}, + DictWord{13, 0, 415}, + DictWord{13, 0, 511}, + DictWord{14, 0, 71}, + DictWord{ + 14, + 0, + 395, + }, + DictWord{15, 0, 71}, + DictWord{15, 0, 136}, + DictWord{17, 0, 123}, + DictWord{18, 0, 93}, + DictWord{147, 0, 58}, + DictWord{136, 0, 712}, + DictWord{ + 134, + 10, + 1743, + }, + DictWord{5, 10, 929}, + DictWord{6, 10, 340}, + DictWord{8, 10, 376}, + DictWord{136, 10, 807}, + DictWord{6, 0, 1848}, + DictWord{8, 0, 860}, + DictWord{ + 10, + 0, + 856, + }, + DictWord{10, 0, 859}, + DictWord{10, 0, 925}, + DictWord{10, 0, 941}, + DictWord{140, 0, 762}, + DictWord{6, 0, 629}, + DictWord{6, 0, 906}, + DictWord{9, 0, 810}, + DictWord{140, 0, 652}, + DictWord{5, 10, 218}, + DictWord{7, 10, 1610}, + DictWord{138, 10, 83}, + DictWord{7, 10, 1512}, + DictWord{135, 10, 1794}, + DictWord{ + 4, + 0, + 377, + }, + DictWord{24, 0, 13}, + DictWord{4, 11, 155}, + DictWord{7, 11, 1689}, + DictWord{11, 10, 0}, + DictWord{144, 10, 78}, + DictWord{4, 11, 164}, + DictWord{5, 11, 151}, + DictWord{5, 11, 730}, + DictWord{5, 11, 741}, + DictWord{7, 11, 498}, + DictWord{7, 11, 870}, + DictWord{7, 11, 1542}, + DictWord{12, 11, 213}, + DictWord{14, 11, 36}, + DictWord{14, 11, 391}, + DictWord{17, 11, 111}, + DictWord{18, 11, 6}, + DictWord{18, 11, 46}, + DictWord{18, 11, 151}, + DictWord{19, 11, 36}, + DictWord{20, 11, 32}, + DictWord{20, 11, 56}, + DictWord{20, 11, 69}, + DictWord{20, 11, 102}, + DictWord{21, 11, 4}, + DictWord{22, 11, 8}, + DictWord{22, 11, 10}, + DictWord{22, 11, 14}, + DictWord{ + 150, + 11, + 31, + }, + DictWord{7, 0, 1842}, + DictWord{133, 10, 571}, + DictWord{4, 10, 455}, + DictWord{4, 11, 624}, + DictWord{135, 11, 1752}, + DictWord{134, 0, 1501}, + DictWord{4, 11, 492}, + DictWord{5, 11, 451}, + DictWord{6, 10, 161}, + DictWord{7, 10, 372}, + DictWord{137, 10, 597}, + DictWord{132, 10, 349}, + DictWord{4, 0, 180}, + DictWord{135, 0, 1906}, + DictWord{135, 11, 835}, + DictWord{141, 11, 70}, + DictWord{132, 0, 491}, + DictWord{137, 10, 751}, + DictWord{6, 10, 432}, + DictWord{ + 139, + 10, + 322, + }, + DictWord{4, 0, 171}, + DictWord{138, 0, 234}, + DictWord{6, 11, 113}, + DictWord{135, 11, 436}, + DictWord{4, 0, 586}, + DictWord{7, 0, 1186}, + DictWord{ + 138, + 0, + 631, + }, + DictWord{5, 10, 468}, + DictWord{10, 10, 325}, + DictWord{11, 10, 856}, + DictWord{12, 10, 345}, + DictWord{143, 10, 104}, + DictWord{5, 10, 223}, + DictWord{10, 11, 592}, + DictWord{10, 11, 753}, + DictWord{12, 11, 317}, + DictWord{12, 11, 355}, + DictWord{12, 11, 465}, + DictWord{12, 11, 469}, + DictWord{ + 12, + 11, + 560, + }, + DictWord{12, 11, 578}, + DictWord{141, 11, 243}, + DictWord{132, 10, 566}, + DictWord{135, 11, 520}, + DictWord{4, 10, 59}, + DictWord{135, 10, 1394}, + DictWord{6, 10, 436}, + DictWord{139, 10, 481}, + DictWord{9, 0, 931}, + DictWord{10, 0, 334}, + DictWord{20, 0, 71}, + DictWord{4, 10, 48}, + DictWord{5, 10, 271}, + DictWord{ + 7, + 10, + 953, + }, + DictWord{135, 11, 1878}, + DictWord{11, 0, 170}, + DictWord{5, 10, 610}, + DictWord{136, 10, 457}, + DictWord{133, 10, 755}, + DictWord{6, 0, 1587}, + DictWord{135, 10, 1217}, + DictWord{4, 10, 197}, + DictWord{149, 11, 26}, + DictWord{133, 11, 585}, + DictWord{137, 11, 521}, + DictWord{133, 0, 765}, + DictWord{ + 133, + 10, + 217, + }, + DictWord{139, 11, 586}, + DictWord{133, 0, 424}, + DictWord{9, 11, 752}, + DictWord{12, 11, 610}, + DictWord{13, 11, 431}, + DictWord{16, 11, 59}, + DictWord{146, 11, 109}, + DictWord{136, 0, 714}, + DictWord{7, 0, 685}, + DictWord{132, 11, 307}, + DictWord{9, 0, 420}, + DictWord{10, 0, 269}, + DictWord{10, 0, 285}, + DictWord{10, 0, 576}, + DictWord{11, 0, 397}, + DictWord{13, 0, 175}, + DictWord{145, 0, 90}, + DictWord{132, 0, 429}, + DictWord{133, 11, 964}, + DictWord{9, 11, 463}, + DictWord{138, 11, 595}, + DictWord{7, 0, 18}, + DictWord{7, 0, 699}, + DictWord{7, 0, 1966}, + DictWord{8, 0, 752}, + DictWord{9, 0, 273}, + DictWord{9, 0, 412}, + DictWord{ + 9, + 0, + 703, + }, + DictWord{10, 0, 71}, + DictWord{10, 0, 427}, + DictWord{138, 0, 508}, + DictWord{4, 10, 165}, + DictWord{7, 10, 1398}, + DictWord{135, 10, 1829}, + DictWord{ + 4, + 0, + 53, + }, + DictWord{5, 0, 186}, + DictWord{7, 0, 752}, + DictWord{7, 0, 828}, + DictWord{142, 0, 116}, + DictWord{8, 0, 575}, + DictWord{10, 0, 289}, + DictWord{139, 0, 319}, + DictWord{132, 0, 675}, + DictWord{134, 0, 1424}, + DictWord{4, 11, 75}, + DictWord{5, 11, 180}, + DictWord{6, 11, 500}, + DictWord{7, 11, 58}, + DictWord{7, 11, 710}, + DictWord{138, 11, 645}, + DictWord{133, 11, 649}, + DictWord{6, 11, 276}, + DictWord{7, 11, 282}, + DictWord{7, 11, 879}, + DictWord{7, 11, 924}, + DictWord{8, 11, 459}, + DictWord{9, 11, 599}, + DictWord{9, 11, 754}, + DictWord{11, 11, 574}, + DictWord{12, 11, 128}, + DictWord{12, 11, 494}, + DictWord{13, 11, 52}, + DictWord{13, 11, 301}, + DictWord{15, 11, 30}, + DictWord{143, 11, 132}, + DictWord{6, 0, 647}, + DictWord{134, 0, 1095}, + DictWord{5, 10, 9}, + DictWord{7, 10, 297}, + DictWord{7, 10, 966}, + DictWord{140, 10, 306}, + DictWord{132, 11, 200}, + DictWord{134, 0, 1334}, + DictWord{5, 10, 146}, + DictWord{6, 10, 411}, + DictWord{138, 10, 721}, + DictWord{ + 6, + 0, + 209, + }, + DictWord{6, 0, 1141}, + DictWord{6, 0, 1288}, + DictWord{8, 0, 468}, + DictWord{9, 0, 210}, + DictWord{11, 0, 36}, + DictWord{12, 0, 28}, + DictWord{12, 0, 630}, + DictWord{13, 0, 21}, + DictWord{13, 0, 349}, + DictWord{14, 0, 7}, + DictWord{145, 0, 13}, + DictWord{6, 10, 177}, + DictWord{135, 10, 467}, + DictWord{4, 0, 342}, + DictWord{ + 135, + 0, + 1179, + }, + DictWord{10, 11, 454}, + DictWord{140, 11, 324}, + DictWord{4, 0, 928}, + DictWord{133, 0, 910}, + DictWord{7, 0, 1838}, + DictWord{6, 11, 225}, + DictWord{ + 137, + 11, + 211, + }, + DictWord{16, 0, 101}, + DictWord{20, 0, 115}, + DictWord{20, 0, 118}, + DictWord{148, 0, 122}, + DictWord{4, 0, 496}, + DictWord{135, 0, 856}, + DictWord{ + 4, + 0, + 318, + }, + DictWord{11, 0, 654}, + DictWord{7, 11, 718}, + DictWord{139, 11, 102}, + DictWord{8, 11, 58}, + DictWord{9, 11, 724}, + DictWord{11, 11, 809}, + DictWord{ + 13, + 11, + 113, + }, + DictWord{145, 11, 72}, + DictWord{5, 10, 200}, + DictWord{6, 11, 345}, + DictWord{135, 11, 1247}, + DictWord{8, 11, 767}, + DictWord{8, 11, 803}, + DictWord{ + 9, + 11, + 301, + }, + DictWord{137, 11, 903}, + DictWord{7, 0, 915}, + DictWord{8, 0, 247}, + DictWord{19, 0, 0}, + DictWord{7, 11, 1949}, + DictWord{136, 11, 674}, + DictWord{ + 4, + 0, + 202, + }, + DictWord{5, 0, 382}, + DictWord{6, 0, 454}, + DictWord{7, 0, 936}, + DictWord{7, 0, 1803}, + DictWord{8, 0, 758}, + DictWord{9, 0, 375}, + DictWord{9, 0, 895}, + DictWord{ + 10, + 0, + 743, + }, + DictWord{10, 0, 792}, + DictWord{11, 0, 978}, + DictWord{11, 0, 1012}, + DictWord{142, 0, 109}, + DictWord{7, 0, 1150}, + DictWord{7, 0, 1425}, + DictWord{ + 7, + 0, + 1453, + }, + DictWord{140, 0, 513}, + DictWord{134, 11, 259}, + DictWord{138, 0, 791}, + DictWord{11, 0, 821}, + DictWord{12, 0, 110}, + DictWord{12, 0, 153}, + DictWord{ + 18, + 0, + 41, + }, + DictWord{150, 0, 19}, + DictWord{134, 10, 481}, + DictWord{132, 0, 796}, + DictWord{6, 0, 445}, + DictWord{9, 0, 909}, + DictWord{136, 11, 254}, + DictWord{ + 10, + 0, + 776, + }, + DictWord{13, 0, 345}, + DictWord{142, 0, 425}, + DictWord{4, 10, 84}, + DictWord{7, 10, 1482}, + DictWord{10, 10, 76}, + DictWord{138, 10, 142}, + DictWord{ + 135, + 11, + 742, + }, + DictWord{6, 0, 578}, + DictWord{133, 10, 1015}, + DictWord{6, 0, 1387}, + DictWord{4, 10, 315}, + DictWord{5, 10, 507}, + DictWord{135, 10, 1370}, + DictWord{4, 0, 438}, + DictWord{133, 0, 555}, + DictWord{136, 0, 766}, + DictWord{133, 11, 248}, + DictWord{134, 10, 1722}, + DictWord{4, 11, 116}, + DictWord{5, 11, 95}, + DictWord{5, 11, 445}, + DictWord{7, 11, 1688}, + DictWord{8, 11, 29}, + DictWord{9, 11, 272}, + DictWord{11, 11, 509}, + DictWord{139, 11, 915}, + DictWord{135, 0, 541}, + DictWord{133, 11, 543}, + DictWord{8, 10, 222}, + DictWord{8, 10, 476}, + DictWord{9, 10, 238}, + DictWord{11, 10, 516}, + DictWord{11, 10, 575}, + DictWord{ + 15, + 10, + 109, + }, + DictWord{146, 10, 100}, + DictWord{6, 0, 880}, + DictWord{134, 0, 1191}, + DictWord{5, 11, 181}, + DictWord{136, 11, 41}, + DictWord{134, 0, 1506}, + DictWord{132, 11, 681}, + DictWord{7, 11, 25}, + DictWord{8, 11, 202}, + DictWord{138, 11, 536}, + DictWord{139, 0, 983}, + DictWord{137, 0, 768}, + DictWord{132, 0, 584}, + DictWord{9, 11, 423}, + DictWord{140, 11, 89}, + DictWord{8, 11, 113}, + DictWord{9, 11, 877}, + DictWord{10, 11, 554}, + DictWord{11, 11, 83}, + DictWord{12, 11, 136}, + DictWord{147, 11, 109}, + DictWord{7, 10, 706}, + DictWord{7, 10, 1058}, + DictWord{138, 10, 538}, + DictWord{133, 11, 976}, + DictWord{4, 11, 206}, + DictWord{ + 135, + 11, + 746, + }, + DictWord{136, 11, 526}, + DictWord{140, 0, 737}, + DictWord{11, 10, 92}, + DictWord{11, 10, 196}, + DictWord{11, 10, 409}, + DictWord{11, 10, 450}, + DictWord{11, 10, 666}, + DictWord{11, 10, 777}, + DictWord{12, 10, 262}, + DictWord{13, 10, 385}, + DictWord{13, 10, 393}, + DictWord{15, 10, 115}, + DictWord{ + 16, + 10, + 45, + }, + DictWord{145, 10, 82}, + DictWord{4, 0, 226}, + DictWord{4, 0, 326}, + DictWord{7, 0, 1770}, + DictWord{4, 11, 319}, + DictWord{5, 11, 699}, + DictWord{138, 11, 673}, + DictWord{6, 10, 40}, + DictWord{135, 10, 1781}, + DictWord{5, 0, 426}, + DictWord{8, 0, 30}, + DictWord{9, 0, 2}, + DictWord{11, 0, 549}, + DictWord{147, 0, 122}, + DictWord{ + 6, + 0, + 1161, + }, + DictWord{134, 0, 1329}, + DictWord{138, 10, 97}, + DictWord{6, 10, 423}, + DictWord{7, 10, 665}, + DictWord{135, 10, 1210}, + DictWord{7, 11, 13}, + DictWord{ + 8, + 11, + 226, + }, + DictWord{10, 11, 537}, + DictWord{11, 11, 570}, + DictWord{11, 11, 605}, + DictWord{11, 11, 799}, + DictWord{11, 11, 804}, + DictWord{12, 11, 85}, + DictWord{12, 11, 516}, + DictWord{12, 11, 623}, + DictWord{13, 11, 112}, + DictWord{13, 11, 361}, + DictWord{14, 11, 77}, + DictWord{14, 11, 78}, + DictWord{17, 11, 28}, + DictWord{147, 11, 110}, + DictWord{132, 11, 769}, + DictWord{132, 11, 551}, + DictWord{132, 11, 728}, + DictWord{147, 0, 117}, + DictWord{9, 11, 57}, + DictWord{ + 9, + 11, + 459, + }, + DictWord{10, 11, 425}, + DictWord{11, 11, 119}, + DictWord{12, 11, 184}, + DictWord{12, 11, 371}, + DictWord{13, 11, 358}, + DictWord{145, 11, 51}, + DictWord{ + 5, + 11, + 188, + }, + DictWord{5, 11, 814}, + DictWord{8, 11, 10}, + DictWord{9, 11, 421}, + DictWord{9, 11, 729}, + DictWord{10, 11, 609}, + DictWord{139, 11, 689}, + DictWord{134, 11, 624}, + DictWord{135, 11, 298}, + DictWord{135, 0, 462}, + DictWord{4, 0, 345}, + DictWord{139, 10, 624}, + DictWord{136, 10, 574}, + DictWord{ + 4, + 0, + 385, + }, + DictWord{7, 0, 265}, + DictWord{135, 0, 587}, + DictWord{6, 0, 808}, + DictWord{132, 11, 528}, + DictWord{133, 0, 398}, + DictWord{132, 10, 354}, + DictWord{ + 4, + 0, + 347, + }, + DictWord{5, 0, 423}, + DictWord{5, 0, 996}, + DictWord{135, 0, 1329}, + DictWord{135, 10, 1558}, + DictWord{7, 0, 1259}, + DictWord{9, 0, 125}, + DictWord{ + 139, + 0, + 65, + }, + DictWord{5, 0, 136}, + DictWord{6, 0, 136}, + DictWord{136, 0, 644}, + DictWord{5, 11, 104}, + DictWord{6, 11, 173}, + DictWord{135, 11, 1631}, + DictWord{ + 135, + 0, + 469, + }, + DictWord{133, 10, 830}, + DictWord{4, 0, 278}, + DictWord{5, 0, 465}, + DictWord{135, 0, 1367}, + DictWord{7, 11, 810}, + DictWord{8, 11, 138}, + DictWord{ + 8, + 11, + 342, + }, + DictWord{9, 11, 84}, + DictWord{10, 11, 193}, + DictWord{11, 11, 883}, + DictWord{140, 11, 359}, + DictWord{5, 10, 496}, + DictWord{135, 10, 203}, + DictWord{ + 4, + 0, + 433, + }, + DictWord{133, 0, 719}, + DictWord{6, 11, 95}, + DictWord{134, 10, 547}, + DictWord{5, 10, 88}, + DictWord{137, 10, 239}, + DictWord{6, 11, 406}, + DictWord{ + 10, + 11, + 409, + }, + DictWord{10, 11, 447}, + DictWord{11, 11, 44}, + DictWord{140, 11, 100}, + DictWord{134, 0, 1423}, + DictWord{7, 10, 650}, + DictWord{135, 10, 1310}, + DictWord{134, 0, 749}, + DictWord{135, 11, 1243}, + DictWord{135, 0, 1363}, + DictWord{6, 0, 381}, + DictWord{7, 0, 645}, + DictWord{7, 0, 694}, + DictWord{8, 0, 546}, + DictWord{7, 10, 1076}, + DictWord{9, 10, 80}, + DictWord{11, 10, 78}, + DictWord{11, 10, 421}, + DictWord{11, 10, 534}, + DictWord{140, 10, 545}, + DictWord{ + 134, + 11, + 1636, + }, + DictWord{135, 11, 1344}, + DictWord{12, 0, 277}, + DictWord{7, 10, 274}, + DictWord{11, 10, 479}, + DictWord{139, 10, 507}, + DictWord{6, 0, 705}, + DictWord{ + 6, + 0, + 783, + }, + DictWord{6, 0, 1275}, + DictWord{6, 0, 1481}, + DictWord{4, 11, 282}, + DictWord{7, 11, 1034}, + DictWord{11, 11, 398}, + DictWord{11, 11, 634}, + DictWord{ + 12, + 11, + 1, + }, + DictWord{12, 11, 79}, + DictWord{12, 11, 544}, + DictWord{14, 11, 237}, + DictWord{17, 11, 10}, + DictWord{146, 11, 20}, + DictWord{134, 0, 453}, + DictWord{ + 4, + 0, + 555, + }, + DictWord{8, 0, 536}, + DictWord{10, 0, 288}, + DictWord{11, 0, 1005}, + DictWord{4, 10, 497}, + DictWord{135, 10, 1584}, + DictWord{5, 11, 118}, + DictWord{ + 5, + 11, + 499, + }, + DictWord{6, 11, 476}, + DictWord{7, 11, 600}, + DictWord{7, 11, 888}, + DictWord{135, 11, 1096}, + DictWord{138, 0, 987}, + DictWord{7, 0, 1107}, + DictWord{ + 7, + 10, + 261, + }, + DictWord{7, 10, 1115}, + DictWord{7, 10, 1354}, + DictWord{7, 10, 1588}, + DictWord{7, 10, 1705}, + DictWord{7, 10, 1902}, + DictWord{9, 10, 465}, + DictWord{10, 10, 248}, + DictWord{10, 10, 349}, + DictWord{10, 10, 647}, + DictWord{11, 10, 527}, + DictWord{11, 10, 660}, + DictWord{11, 10, 669}, + DictWord{ + 12, + 10, + 529, + }, + DictWord{141, 10, 305}, + DictWord{7, 11, 296}, + DictWord{7, 11, 596}, + DictWord{8, 11, 560}, + DictWord{8, 11, 586}, + DictWord{9, 11, 612}, + DictWord{ + 11, + 11, + 100, + }, + DictWord{11, 11, 304}, + DictWord{12, 11, 46}, + DictWord{13, 11, 89}, + DictWord{14, 11, 112}, + DictWord{145, 11, 122}, + DictWord{9, 0, 370}, + DictWord{ + 138, + 0, + 90, + }, + DictWord{136, 10, 13}, + DictWord{132, 0, 860}, + DictWord{7, 10, 642}, + DictWord{8, 10, 250}, + DictWord{11, 10, 123}, + DictWord{11, 10, 137}, + DictWord{ + 13, + 10, + 48, + }, + DictWord{142, 10, 95}, + DictWord{135, 10, 1429}, + DictWord{137, 11, 321}, + DictWord{132, 0, 257}, + DictWord{135, 0, 2031}, + DictWord{7, 0, 1768}, + DictWord{7, 11, 1599}, + DictWord{7, 11, 1723}, + DictWord{8, 11, 79}, + DictWord{8, 11, 106}, + DictWord{8, 11, 190}, + DictWord{8, 11, 302}, + DictWord{8, 11, 383}, + DictWord{9, 11, 119}, + DictWord{9, 11, 233}, + DictWord{9, 11, 298}, + DictWord{9, 11, 419}, + DictWord{9, 11, 471}, + DictWord{10, 11, 181}, + DictWord{10, 11, 406}, + DictWord{11, 11, 57}, + DictWord{11, 11, 85}, + DictWord{11, 11, 120}, + DictWord{11, 11, 177}, + DictWord{11, 11, 296}, + DictWord{11, 11, 382}, + DictWord{11, 11, 454}, + DictWord{11, 11, 758}, + DictWord{11, 11, 999}, + DictWord{12, 11, 27}, + DictWord{12, 11, 98}, + DictWord{12, 11, 131}, + DictWord{12, 11, 245}, + DictWord{ + 12, + 11, + 312, + }, + DictWord{12, 11, 446}, + DictWord{12, 11, 454}, + DictWord{13, 11, 25}, + DictWord{13, 11, 98}, + DictWord{13, 11, 426}, + DictWord{13, 11, 508}, + DictWord{ + 14, + 11, + 6, + }, + DictWord{14, 11, 163}, + DictWord{14, 11, 272}, + DictWord{14, 11, 277}, + DictWord{14, 11, 370}, + DictWord{15, 11, 95}, + DictWord{15, 11, 138}, + DictWord{ + 15, + 11, + 167, + }, + DictWord{17, 11, 18}, + DictWord{17, 11, 38}, + DictWord{20, 11, 96}, + DictWord{149, 11, 32}, + DictWord{5, 11, 722}, + DictWord{134, 11, 1759}, + DictWord{145, 11, 16}, + DictWord{6, 0, 1071}, + DictWord{134, 0, 1561}, + DictWord{10, 10, 545}, + DictWord{140, 10, 301}, + DictWord{6, 0, 83}, + DictWord{6, 0, 1733}, + DictWord{135, 0, 1389}, + DictWord{4, 0, 835}, + DictWord{135, 0, 1818}, + DictWord{133, 11, 258}, + DictWord{4, 10, 904}, + DictWord{133, 10, 794}, + DictWord{ + 134, + 0, + 2006, + }, + DictWord{5, 11, 30}, + DictWord{7, 11, 495}, + DictWord{8, 11, 134}, + DictWord{9, 11, 788}, + DictWord{140, 11, 438}, + DictWord{135, 11, 2004}, + DictWord{ + 137, + 0, + 696, + }, + DictWord{5, 11, 50}, + DictWord{6, 11, 439}, + DictWord{7, 11, 780}, + DictWord{135, 11, 1040}, + DictWord{7, 11, 772}, + DictWord{7, 11, 1104}, + DictWord{ + 7, + 11, + 1647, + }, + DictWord{11, 11, 269}, + DictWord{11, 11, 539}, + DictWord{11, 11, 607}, + DictWord{11, 11, 627}, + DictWord{11, 11, 706}, + DictWord{11, 11, 975}, + DictWord{12, 11, 248}, + DictWord{12, 11, 311}, + DictWord{12, 11, 434}, + DictWord{12, 11, 600}, + DictWord{12, 11, 622}, + DictWord{13, 11, 297}, + DictWord{ + 13, + 11, + 367, + }, + DictWord{13, 11, 485}, + DictWord{14, 11, 69}, + DictWord{14, 11, 409}, + DictWord{143, 11, 108}, + DictWord{5, 11, 1}, + DictWord{6, 11, 81}, + DictWord{ + 138, + 11, + 520, + }, + DictWord{7, 0, 1718}, + DictWord{9, 0, 95}, + DictWord{9, 0, 274}, + DictWord{10, 0, 279}, + DictWord{10, 0, 317}, + DictWord{10, 0, 420}, + DictWord{11, 0, 303}, + DictWord{11, 0, 808}, + DictWord{12, 0, 134}, + DictWord{12, 0, 367}, + DictWord{13, 0, 149}, + DictWord{13, 0, 347}, + DictWord{14, 0, 349}, + DictWord{14, 0, 406}, + DictWord{ + 18, + 0, + 22, + }, + DictWord{18, 0, 89}, + DictWord{18, 0, 122}, + DictWord{147, 0, 47}, + DictWord{5, 11, 482}, + DictWord{8, 11, 98}, + DictWord{9, 11, 172}, + DictWord{10, 11, 222}, + DictWord{10, 11, 700}, + DictWord{10, 11, 822}, + DictWord{11, 11, 302}, + DictWord{11, 11, 778}, + DictWord{12, 11, 50}, + DictWord{12, 11, 127}, + DictWord{ + 12, + 11, + 396, + }, + DictWord{13, 11, 62}, + DictWord{13, 11, 328}, + DictWord{14, 11, 122}, + DictWord{147, 11, 72}, + DictWord{7, 10, 386}, + DictWord{138, 10, 713}, + DictWord{ + 6, + 10, + 7, + }, + DictWord{6, 10, 35}, + DictWord{7, 10, 147}, + DictWord{7, 10, 1069}, + DictWord{7, 10, 1568}, + DictWord{7, 10, 1575}, + DictWord{7, 10, 1917}, + DictWord{ + 8, + 10, + 43, + }, + DictWord{8, 10, 208}, + DictWord{9, 10, 128}, + DictWord{9, 10, 866}, + DictWord{10, 10, 20}, + DictWord{11, 10, 981}, + DictWord{147, 10, 33}, + DictWord{ + 133, + 0, + 26, + }, + DictWord{132, 0, 550}, + DictWord{5, 11, 2}, + DictWord{7, 11, 1494}, + DictWord{136, 11, 589}, + DictWord{6, 11, 512}, + DictWord{7, 11, 797}, + DictWord{ + 8, + 11, + 253, + }, + DictWord{9, 11, 77}, + DictWord{10, 11, 1}, + DictWord{10, 11, 129}, + DictWord{10, 11, 225}, + DictWord{11, 11, 118}, + DictWord{11, 11, 226}, + DictWord{ + 11, + 11, + 251, + }, + DictWord{11, 11, 430}, + DictWord{11, 11, 701}, + DictWord{11, 11, 974}, + DictWord{11, 11, 982}, + DictWord{12, 11, 64}, + DictWord{12, 11, 260}, + DictWord{ + 12, + 11, + 488, + }, + DictWord{140, 11, 690}, + DictWord{7, 10, 893}, + DictWord{141, 10, 424}, + DictWord{134, 0, 901}, + DictWord{136, 0, 822}, + DictWord{4, 0, 902}, + DictWord{5, 0, 809}, + DictWord{134, 0, 122}, + DictWord{6, 0, 807}, + DictWord{134, 0, 1366}, + DictWord{7, 0, 262}, + DictWord{5, 11, 748}, + DictWord{134, 11, 553}, + DictWord{133, 0, 620}, + DictWord{4, 0, 34}, + DictWord{5, 0, 574}, + DictWord{7, 0, 279}, + DictWord{7, 0, 1624}, + DictWord{136, 0, 601}, + DictWord{9, 0, 170}, + DictWord{ + 6, + 10, + 322, + }, + DictWord{9, 10, 552}, + DictWord{11, 10, 274}, + DictWord{13, 10, 209}, + DictWord{13, 10, 499}, + DictWord{14, 10, 85}, + DictWord{15, 10, 126}, + DictWord{ + 145, + 10, + 70, + }, + DictWord{132, 0, 537}, + DictWord{4, 11, 12}, + DictWord{7, 11, 420}, + DictWord{7, 11, 522}, + DictWord{7, 11, 809}, + DictWord{8, 11, 797}, + DictWord{ + 141, + 11, + 88, + }, + DictWord{133, 0, 332}, + DictWord{8, 10, 83}, + DictWord{8, 10, 742}, + DictWord{8, 10, 817}, + DictWord{9, 10, 28}, + DictWord{9, 10, 29}, + DictWord{9, 10, 885}, + DictWord{10, 10, 387}, + DictWord{11, 10, 633}, + DictWord{11, 10, 740}, + DictWord{13, 10, 235}, + DictWord{13, 10, 254}, + DictWord{15, 10, 143}, + DictWord{ + 143, + 10, + 146, + }, + DictWord{6, 0, 1909}, + DictWord{9, 0, 964}, + DictWord{12, 0, 822}, + DictWord{12, 0, 854}, + DictWord{12, 0, 865}, + DictWord{12, 0, 910}, + DictWord{12, 0, 938}, + DictWord{15, 0, 169}, + DictWord{15, 0, 208}, + DictWord{15, 0, 211}, + DictWord{18, 0, 205}, + DictWord{18, 0, 206}, + DictWord{18, 0, 220}, + DictWord{18, 0, 223}, + DictWord{152, 0, 24}, + DictWord{140, 10, 49}, + DictWord{5, 11, 528}, + DictWord{135, 11, 1580}, + DictWord{6, 0, 261}, + DictWord{8, 0, 182}, + DictWord{139, 0, 943}, + DictWord{134, 0, 1721}, + DictWord{4, 0, 933}, + DictWord{133, 0, 880}, + DictWord{136, 11, 321}, + DictWord{5, 11, 266}, + DictWord{9, 11, 290}, + DictWord{9, 11, 364}, + DictWord{10, 11, 293}, + DictWord{11, 11, 606}, + DictWord{142, 11, 45}, + DictWord{6, 0, 1609}, + DictWord{4, 11, 50}, + DictWord{6, 11, 510}, + DictWord{6, 11, 594}, + DictWord{9, 11, 121}, + DictWord{10, 11, 49}, + DictWord{10, 11, 412}, + DictWord{139, 11, 834}, + DictWord{7, 0, 895}, + DictWord{136, 11, 748}, + DictWord{132, 11, 466}, + DictWord{4, 10, 110}, + DictWord{10, 10, 415}, + DictWord{10, 10, 597}, + DictWord{142, 10, 206}, + DictWord{133, 0, 812}, + DictWord{135, 11, 281}, + DictWord{ + 6, + 0, + 1890, + }, + DictWord{6, 0, 1902}, + DictWord{6, 0, 1916}, + DictWord{9, 0, 929}, + DictWord{9, 0, 942}, + DictWord{9, 0, 975}, + DictWord{9, 0, 984}, + DictWord{9, 0, 986}, + DictWord{ + 9, + 0, + 1011, + }, + DictWord{9, 0, 1019}, + DictWord{12, 0, 804}, + DictWord{12, 0, 851}, + DictWord{12, 0, 867}, + DictWord{12, 0, 916}, + DictWord{12, 0, 923}, + DictWord{ + 15, + 0, + 194, + }, + DictWord{15, 0, 204}, + DictWord{15, 0, 210}, + DictWord{15, 0, 222}, + DictWord{15, 0, 223}, + DictWord{15, 0, 229}, + DictWord{15, 0, 250}, + DictWord{ + 18, + 0, + 179, + }, + DictWord{18, 0, 186}, + DictWord{18, 0, 192}, + DictWord{7, 10, 205}, + DictWord{135, 10, 2000}, + DictWord{132, 11, 667}, + DictWord{135, 0, 778}, + DictWord{ + 4, + 0, + 137, + }, + DictWord{7, 0, 1178}, + DictWord{135, 0, 1520}, + DictWord{134, 0, 1314}, + DictWord{4, 11, 242}, + DictWord{134, 11, 333}, + DictWord{6, 0, 1661}, + DictWord{7, 0, 1975}, + DictWord{7, 0, 2009}, + DictWord{135, 0, 2011}, + DictWord{134, 0, 1591}, + DictWord{4, 10, 283}, + DictWord{135, 10, 1194}, + DictWord{ + 11, + 0, + 820, + }, + DictWord{150, 0, 51}, + DictWord{4, 11, 39}, + DictWord{5, 11, 36}, + DictWord{7, 11, 1843}, + DictWord{8, 11, 407}, + DictWord{11, 11, 144}, + DictWord{ + 140, + 11, + 523, + }, + DictWord{134, 10, 1720}, + DictWord{4, 11, 510}, + DictWord{7, 11, 29}, + DictWord{7, 11, 66}, + DictWord{7, 11, 1980}, + DictWord{10, 11, 487}, + DictWord{ + 10, + 11, + 809, + }, + DictWord{146, 11, 9}, + DictWord{5, 0, 89}, + DictWord{7, 0, 1915}, + DictWord{9, 0, 185}, + DictWord{9, 0, 235}, + DictWord{10, 0, 64}, + DictWord{10, 0, 270}, + DictWord{10, 0, 403}, + DictWord{10, 0, 469}, + DictWord{10, 0, 529}, + DictWord{10, 0, 590}, + DictWord{11, 0, 140}, + DictWord{11, 0, 860}, + DictWord{13, 0, 1}, + DictWord{ + 13, + 0, + 422, + }, + DictWord{14, 0, 341}, + DictWord{14, 0, 364}, + DictWord{17, 0, 93}, + DictWord{18, 0, 113}, + DictWord{19, 0, 97}, + DictWord{147, 0, 113}, + DictWord{133, 0, 695}, + DictWord{6, 0, 987}, + DictWord{134, 0, 1160}, + DictWord{5, 0, 6}, + DictWord{6, 0, 183}, + DictWord{7, 0, 680}, + DictWord{7, 0, 978}, + DictWord{7, 0, 1013}, + DictWord{ + 7, + 0, + 1055, + }, + DictWord{12, 0, 230}, + DictWord{13, 0, 172}, + DictWord{146, 0, 29}, + DictWord{134, 11, 570}, + DictWord{132, 11, 787}, + DictWord{134, 11, 518}, + DictWord{ + 6, + 0, + 29, + }, + DictWord{139, 0, 63}, + DictWord{132, 11, 516}, + DictWord{136, 11, 821}, + DictWord{132, 0, 311}, + DictWord{134, 0, 1740}, + DictWord{7, 0, 170}, + DictWord{8, 0, 90}, + DictWord{8, 0, 177}, + DictWord{8, 0, 415}, + DictWord{11, 0, 714}, + DictWord{14, 0, 281}, + DictWord{136, 10, 735}, + DictWord{134, 0, 1961}, + DictWord{ + 135, + 11, + 1405, + }, + DictWord{4, 11, 10}, + DictWord{7, 11, 917}, + DictWord{139, 11, 786}, + DictWord{5, 10, 132}, + DictWord{9, 10, 486}, + DictWord{9, 10, 715}, + DictWord{ + 10, + 10, + 458, + }, + DictWord{11, 10, 373}, + DictWord{11, 10, 668}, + DictWord{11, 10, 795}, + DictWord{11, 10, 897}, + DictWord{12, 10, 272}, + DictWord{12, 10, 424}, + DictWord{12, 10, 539}, + DictWord{12, 10, 558}, + DictWord{14, 10, 245}, + DictWord{14, 10, 263}, + DictWord{14, 10, 264}, + DictWord{14, 10, 393}, + DictWord{ + 142, + 10, + 403, + }, + DictWord{11, 0, 91}, + DictWord{13, 0, 129}, + DictWord{15, 0, 101}, + DictWord{145, 0, 125}, + DictWord{135, 0, 1132}, + DictWord{4, 0, 494}, + DictWord{6, 0, 74}, + DictWord{7, 0, 44}, + DictWord{7, 0, 407}, + DictWord{12, 0, 17}, + DictWord{15, 0, 5}, + DictWord{148, 0, 11}, + DictWord{133, 10, 379}, + DictWord{5, 0, 270}, + DictWord{ + 5, + 11, + 684, + }, + DictWord{6, 10, 89}, + DictWord{6, 10, 400}, + DictWord{7, 10, 1569}, + DictWord{7, 10, 1623}, + DictWord{7, 10, 1850}, + DictWord{8, 10, 218}, + DictWord{ + 8, + 10, + 422, + }, + DictWord{9, 10, 570}, + DictWord{138, 10, 626}, + DictWord{4, 0, 276}, + DictWord{133, 0, 296}, + DictWord{6, 0, 1523}, + DictWord{134, 11, 27}, + DictWord{ + 6, + 10, + 387, + }, + DictWord{7, 10, 882}, + DictWord{141, 10, 111}, + DictWord{6, 10, 224}, + DictWord{7, 10, 877}, + DictWord{137, 10, 647}, + DictWord{135, 10, 790}, + DictWord{ + 4, + 0, + 7, + }, + DictWord{5, 0, 90}, + DictWord{5, 0, 158}, + DictWord{6, 0, 542}, + DictWord{7, 0, 221}, + DictWord{7, 0, 1574}, + DictWord{9, 0, 490}, + DictWord{10, 0, 540}, + DictWord{ + 11, + 0, + 443, + }, + DictWord{139, 0, 757}, + DictWord{7, 0, 588}, + DictWord{9, 0, 175}, + DictWord{138, 0, 530}, + DictWord{135, 10, 394}, + DictWord{142, 11, 23}, + DictWord{ + 134, + 0, + 786, + }, + DictWord{135, 0, 580}, + DictWord{7, 0, 88}, + DictWord{136, 0, 627}, + DictWord{5, 0, 872}, + DictWord{6, 0, 57}, + DictWord{7, 0, 471}, + DictWord{9, 0, 447}, + DictWord{137, 0, 454}, + DictWord{6, 11, 342}, + DictWord{6, 11, 496}, + DictWord{8, 11, 275}, + DictWord{137, 11, 206}, + DictWord{4, 11, 909}, + DictWord{133, 11, 940}, + DictWord{6, 0, 735}, + DictWord{132, 11, 891}, + DictWord{8, 0, 845}, + DictWord{8, 0, 916}, + DictWord{135, 10, 1409}, + DictWord{5, 0, 31}, + DictWord{134, 0, 614}, + DictWord{11, 0, 458}, + DictWord{12, 0, 15}, + DictWord{140, 0, 432}, + DictWord{8, 0, 330}, + DictWord{140, 0, 477}, + DictWord{4, 0, 530}, + DictWord{5, 0, 521}, + DictWord{ + 7, + 0, + 1200, + }, + DictWord{10, 0, 460}, + DictWord{132, 11, 687}, + DictWord{6, 0, 424}, + DictWord{135, 0, 1866}, + DictWord{9, 0, 569}, + DictWord{12, 0, 12}, + DictWord{ + 12, + 0, + 81, + }, + DictWord{12, 0, 319}, + DictWord{13, 0, 69}, + DictWord{14, 0, 259}, + DictWord{16, 0, 87}, + DictWord{17, 0, 1}, + DictWord{17, 0, 21}, + DictWord{17, 0, 24}, + DictWord{ + 18, + 0, + 15, + }, + DictWord{18, 0, 56}, + DictWord{18, 0, 59}, + DictWord{18, 0, 127}, + DictWord{18, 0, 154}, + DictWord{19, 0, 19}, + DictWord{148, 0, 31}, + DictWord{7, 0, 1302}, + DictWord{136, 10, 38}, + DictWord{134, 11, 253}, + DictWord{5, 10, 261}, + DictWord{7, 10, 78}, + DictWord{7, 10, 199}, + DictWord{8, 10, 815}, + DictWord{9, 10, 126}, + DictWord{138, 10, 342}, + DictWord{5, 0, 595}, + DictWord{135, 0, 1863}, + DictWord{6, 11, 41}, + DictWord{141, 11, 160}, + DictWord{5, 0, 13}, + DictWord{134, 0, 142}, + DictWord{6, 0, 97}, + DictWord{7, 0, 116}, + DictWord{8, 0, 322}, + DictWord{8, 0, 755}, + DictWord{9, 0, 548}, + DictWord{10, 0, 714}, + DictWord{11, 0, 884}, + DictWord{13, 0, 324}, + DictWord{7, 11, 1304}, + DictWord{138, 11, 477}, + DictWord{132, 10, 628}, + DictWord{134, 11, 1718}, + DictWord{7, 10, 266}, + DictWord{136, 10, 804}, + DictWord{135, 10, 208}, + DictWord{7, 0, 1021}, + DictWord{6, 10, 79}, + DictWord{135, 10, 1519}, + DictWord{7, 0, 1472}, + DictWord{135, 0, 1554}, + DictWord{6, 11, 362}, + DictWord{146, 11, 51}, + DictWord{7, 0, 1071}, + DictWord{7, 0, 1541}, + DictWord{7, 0, 1767}, + DictWord{7, 0, 1806}, + DictWord{11, 0, 162}, + DictWord{11, 0, 242}, + DictWord{11, 0, 452}, + DictWord{12, 0, 605}, + DictWord{15, 0, 26}, + DictWord{144, 0, 44}, + DictWord{136, 10, 741}, + DictWord{133, 11, 115}, + DictWord{145, 0, 115}, + DictWord{134, 10, 376}, + DictWord{6, 0, 1406}, + DictWord{134, 0, 1543}, + DictWord{5, 11, 193}, + DictWord{12, 11, 178}, + DictWord{13, 11, 130}, + DictWord{ + 145, + 11, + 84, + }, + DictWord{135, 0, 1111}, + DictWord{8, 0, 1}, + DictWord{9, 0, 650}, + DictWord{10, 0, 326}, + DictWord{5, 11, 705}, + DictWord{137, 11, 606}, + DictWord{5, 0, 488}, + DictWord{6, 0, 527}, + DictWord{7, 0, 489}, + DictWord{7, 0, 1636}, + DictWord{8, 0, 121}, + DictWord{8, 0, 144}, + DictWord{8, 0, 359}, + DictWord{9, 0, 193}, + DictWord{9, 0, 241}, + DictWord{9, 0, 336}, + DictWord{9, 0, 882}, + DictWord{11, 0, 266}, + DictWord{11, 0, 372}, + DictWord{11, 0, 944}, + DictWord{12, 0, 401}, + DictWord{140, 0, 641}, + DictWord{135, 11, 174}, + DictWord{6, 0, 267}, + DictWord{7, 10, 244}, + DictWord{7, 10, 632}, + DictWord{7, 10, 1609}, + DictWord{8, 10, 178}, + DictWord{8, 10, 638}, + DictWord{141, 10, 58}, + DictWord{134, 0, 1983}, + DictWord{134, 0, 1155}, + DictWord{134, 0, 1575}, + DictWord{134, 0, 1438}, + DictWord{9, 0, 31}, + DictWord{ + 10, + 0, + 244, + }, + DictWord{10, 0, 699}, + DictWord{12, 0, 149}, + DictWord{141, 0, 497}, + DictWord{133, 0, 377}, + DictWord{4, 11, 122}, + DictWord{5, 11, 796}, + DictWord{ + 5, + 11, + 952, + }, + DictWord{6, 11, 1660}, + DictWord{6, 11, 1671}, + DictWord{8, 11, 567}, + DictWord{9, 11, 687}, + DictWord{9, 11, 742}, + DictWord{10, 11, 686}, + DictWord{ + 11, + 11, + 356, + }, + DictWord{11, 11, 682}, + DictWord{140, 11, 281}, + DictWord{145, 0, 101}, + DictWord{11, 11, 0}, + DictWord{144, 11, 78}, + DictWord{5, 11, 179}, + DictWord{ + 5, + 10, + 791, + }, + DictWord{7, 11, 1095}, + DictWord{135, 11, 1213}, + DictWord{8, 11, 372}, + DictWord{9, 11, 122}, + DictWord{138, 11, 175}, + DictWord{7, 10, 686}, + DictWord{8, 10, 33}, + DictWord{8, 10, 238}, + DictWord{10, 10, 616}, + DictWord{11, 10, 467}, + DictWord{11, 10, 881}, + DictWord{13, 10, 217}, + DictWord{13, 10, 253}, + DictWord{142, 10, 268}, + DictWord{9, 0, 476}, + DictWord{4, 11, 66}, + DictWord{7, 11, 722}, + DictWord{135, 11, 904}, + DictWord{7, 11, 352}, + DictWord{137, 11, 684}, + DictWord{135, 0, 2023}, + DictWord{135, 0, 1836}, + DictWord{132, 10, 447}, + DictWord{5, 0, 843}, + DictWord{144, 0, 35}, + DictWord{137, 11, 779}, + DictWord{ + 141, + 11, + 35, + }, + DictWord{4, 10, 128}, + DictWord{5, 10, 415}, + DictWord{6, 10, 462}, + DictWord{7, 10, 294}, + DictWord{7, 10, 578}, + DictWord{10, 10, 710}, + DictWord{ + 139, + 10, + 86, + }, + DictWord{132, 0, 554}, + DictWord{133, 0, 536}, + DictWord{136, 10, 587}, + DictWord{5, 0, 207}, + DictWord{9, 0, 79}, + DictWord{11, 0, 625}, + DictWord{ + 145, + 0, + 7, + }, + DictWord{7, 0, 1371}, + DictWord{6, 10, 427}, + DictWord{138, 10, 692}, + DictWord{4, 0, 424}, + DictWord{4, 10, 195}, + DictWord{135, 10, 802}, + DictWord{ + 8, + 0, + 785, + }, + DictWord{133, 11, 564}, + DictWord{135, 0, 336}, + DictWord{4, 0, 896}, + DictWord{6, 0, 1777}, + DictWord{134, 11, 556}, + DictWord{137, 11, 103}, + DictWord{134, 10, 1683}, + DictWord{7, 11, 544}, + DictWord{8, 11, 719}, + DictWord{138, 11, 61}, + DictWord{138, 10, 472}, + DictWord{4, 11, 5}, + DictWord{5, 11, 498}, + DictWord{136, 11, 637}, + DictWord{7, 0, 750}, + DictWord{9, 0, 223}, + DictWord{11, 0, 27}, + DictWord{11, 0, 466}, + DictWord{12, 0, 624}, + DictWord{14, 0, 265}, + DictWord{ + 146, + 0, + 61, + }, + DictWord{12, 0, 238}, + DictWord{18, 0, 155}, + DictWord{12, 11, 238}, + DictWord{146, 11, 155}, + DictWord{151, 10, 28}, + DictWord{133, 11, 927}, + DictWord{12, 0, 383}, + DictWord{5, 10, 3}, + DictWord{8, 10, 578}, + DictWord{9, 10, 118}, + DictWord{10, 10, 705}, + DictWord{141, 10, 279}, + DictWord{4, 11, 893}, + DictWord{ + 5, + 11, + 780, + }, + DictWord{133, 11, 893}, + DictWord{4, 0, 603}, + DictWord{133, 0, 661}, + DictWord{4, 0, 11}, + DictWord{6, 0, 128}, + DictWord{7, 0, 231}, + DictWord{ + 7, + 0, + 1533, + }, + DictWord{10, 0, 725}, + DictWord{5, 10, 229}, + DictWord{5, 11, 238}, + DictWord{135, 11, 1350}, + DictWord{8, 10, 102}, + DictWord{10, 10, 578}, + DictWord{ + 10, + 10, + 672, + }, + DictWord{12, 10, 496}, + DictWord{13, 10, 408}, + DictWord{14, 10, 121}, + DictWord{145, 10, 106}, + DictWord{132, 0, 476}, + DictWord{134, 0, 1552}, + DictWord{134, 11, 1729}, + DictWord{8, 10, 115}, + DictWord{8, 10, 350}, + DictWord{9, 10, 489}, + DictWord{10, 10, 128}, + DictWord{11, 10, 306}, + DictWord{ + 12, + 10, + 373, + }, + DictWord{14, 10, 30}, + DictWord{17, 10, 79}, + DictWord{19, 10, 80}, + DictWord{150, 10, 55}, + DictWord{135, 0, 1807}, + DictWord{4, 0, 680}, + DictWord{ + 4, + 11, + 60, + }, + DictWord{7, 11, 760}, + DictWord{7, 11, 1800}, + DictWord{8, 11, 314}, + DictWord{9, 11, 700}, + DictWord{139, 11, 487}, + DictWord{4, 10, 230}, + DictWord{ + 5, + 10, + 702, + }, + DictWord{148, 11, 94}, + DictWord{132, 11, 228}, + DictWord{139, 0, 435}, + DictWord{9, 0, 20}, + DictWord{10, 0, 324}, + DictWord{10, 0, 807}, + DictWord{ + 139, + 0, + 488, + }, + DictWord{6, 10, 1728}, + DictWord{136, 11, 419}, + DictWord{4, 10, 484}, + DictWord{18, 10, 26}, + DictWord{19, 10, 42}, + DictWord{20, 10, 43}, + DictWord{ + 21, + 10, + 0, + }, + DictWord{23, 10, 27}, + DictWord{152, 10, 14}, + DictWord{135, 0, 1431}, + DictWord{133, 11, 828}, + DictWord{5, 0, 112}, + DictWord{6, 0, 103}, + DictWord{ + 6, + 0, + 150, + }, + DictWord{7, 0, 1303}, + DictWord{9, 0, 292}, + DictWord{10, 0, 481}, + DictWord{20, 0, 13}, + DictWord{7, 11, 176}, + DictWord{7, 11, 178}, + DictWord{7, 11, 1110}, + DictWord{10, 11, 481}, + DictWord{148, 11, 13}, + DictWord{138, 0, 356}, + DictWord{4, 11, 51}, + DictWord{5, 11, 39}, + DictWord{6, 11, 4}, + DictWord{7, 11, 591}, + DictWord{ + 7, + 11, + 849, + }, + DictWord{7, 11, 951}, + DictWord{7, 11, 1129}, + DictWord{7, 11, 1613}, + DictWord{7, 11, 1760}, + DictWord{7, 11, 1988}, + DictWord{9, 11, 434}, + DictWord{10, 11, 754}, + DictWord{11, 11, 25}, + DictWord{11, 11, 37}, + DictWord{139, 11, 414}, + DictWord{6, 0, 1963}, + DictWord{134, 0, 2000}, + DictWord{ + 132, + 10, + 633, + }, + DictWord{6, 0, 1244}, + DictWord{133, 11, 902}, + DictWord{135, 11, 928}, + DictWord{140, 0, 18}, + DictWord{138, 0, 204}, + DictWord{135, 11, 1173}, + DictWord{134, 0, 867}, + DictWord{4, 0, 708}, + DictWord{8, 0, 15}, + DictWord{9, 0, 50}, + DictWord{9, 0, 386}, + DictWord{11, 0, 18}, + DictWord{11, 0, 529}, + DictWord{140, 0, 228}, + DictWord{134, 11, 270}, + DictWord{4, 0, 563}, + DictWord{7, 0, 109}, + DictWord{7, 0, 592}, + DictWord{7, 0, 637}, + DictWord{7, 0, 770}, + DictWord{8, 0, 463}, + DictWord{ + 9, + 0, + 60, + }, + DictWord{9, 0, 335}, + DictWord{9, 0, 904}, + DictWord{10, 0, 73}, + DictWord{11, 0, 434}, + DictWord{12, 0, 585}, + DictWord{13, 0, 331}, + DictWord{18, 0, 110}, + DictWord{148, 0, 60}, + DictWord{132, 0, 502}, + DictWord{14, 11, 359}, + DictWord{19, 11, 52}, + DictWord{148, 11, 47}, + DictWord{6, 11, 377}, + DictWord{7, 11, 1025}, + DictWord{9, 11, 613}, + DictWord{145, 11, 104}, + DictWord{6, 0, 347}, + DictWord{10, 0, 161}, + DictWord{5, 10, 70}, + DictWord{5, 10, 622}, + DictWord{6, 10, 334}, + DictWord{ + 7, + 10, + 1032, + }, + DictWord{9, 10, 171}, + DictWord{11, 10, 26}, + DictWord{11, 10, 213}, + DictWord{11, 10, 637}, + DictWord{11, 10, 707}, + DictWord{12, 10, 202}, + DictWord{12, 10, 380}, + DictWord{13, 10, 226}, + DictWord{13, 10, 355}, + DictWord{14, 10, 222}, + DictWord{145, 10, 42}, + DictWord{132, 11, 416}, + DictWord{4, 0, 33}, + DictWord{5, 0, 102}, + DictWord{6, 0, 284}, + DictWord{7, 0, 1079}, + DictWord{7, 0, 1423}, + DictWord{7, 0, 1702}, + DictWord{8, 0, 470}, + DictWord{9, 0, 554}, + DictWord{ + 9, + 0, + 723, + }, + DictWord{11, 0, 333}, + DictWord{142, 11, 372}, + DictWord{5, 11, 152}, + DictWord{5, 11, 197}, + DictWord{7, 11, 340}, + DictWord{7, 11, 867}, + DictWord{ + 10, + 11, + 548, + }, + DictWord{10, 11, 581}, + DictWord{11, 11, 6}, + DictWord{12, 11, 3}, + DictWord{12, 11, 19}, + DictWord{14, 11, 110}, + DictWord{142, 11, 289}, + DictWord{ + 7, + 0, + 246, + }, + DictWord{135, 0, 840}, + DictWord{6, 0, 10}, + DictWord{8, 0, 571}, + DictWord{9, 0, 739}, + DictWord{143, 0, 91}, + DictWord{6, 0, 465}, + DictWord{7, 0, 1465}, + DictWord{ + 4, + 10, + 23, + }, + DictWord{4, 10, 141}, + DictWord{5, 10, 313}, + DictWord{5, 10, 1014}, + DictWord{6, 10, 50}, + DictWord{7, 10, 142}, + DictWord{7, 10, 559}, + DictWord{ + 8, + 10, + 640, + }, + DictWord{9, 10, 460}, + DictWord{9, 10, 783}, + DictWord{11, 10, 741}, + DictWord{12, 10, 183}, + DictWord{141, 10, 488}, + DictWord{133, 0, 626}, + DictWord{ + 136, + 0, + 614, + }, + DictWord{138, 0, 237}, + DictWord{7, 11, 34}, + DictWord{7, 11, 190}, + DictWord{8, 11, 28}, + DictWord{8, 11, 141}, + DictWord{8, 11, 444}, + DictWord{ + 8, + 11, + 811, + }, + DictWord{9, 11, 468}, + DictWord{11, 11, 334}, + DictWord{12, 11, 24}, + DictWord{12, 11, 386}, + DictWord{140, 11, 576}, + DictWord{133, 11, 757}, + DictWord{ + 5, + 0, + 18, + }, + DictWord{6, 0, 526}, + DictWord{13, 0, 24}, + DictWord{13, 0, 110}, + DictWord{19, 0, 5}, + DictWord{147, 0, 44}, + DictWord{6, 0, 506}, + DictWord{134, 11, 506}, + DictWord{135, 11, 1553}, + DictWord{4, 0, 309}, + DictWord{5, 0, 462}, + DictWord{7, 0, 970}, + DictWord{7, 0, 1097}, + DictWord{22, 0, 30}, + DictWord{22, 0, 33}, + DictWord{ + 7, + 11, + 1385, + }, + DictWord{11, 11, 582}, + DictWord{11, 11, 650}, + DictWord{11, 11, 901}, + DictWord{11, 11, 949}, + DictWord{12, 11, 232}, + DictWord{12, 11, 236}, + DictWord{13, 11, 413}, + DictWord{13, 11, 501}, + DictWord{146, 11, 116}, + DictWord{9, 0, 140}, + DictWord{5, 10, 222}, + DictWord{138, 10, 534}, + DictWord{6, 0, 1056}, + DictWord{137, 10, 906}, + DictWord{134, 0, 1704}, + DictWord{138, 10, 503}, + DictWord{134, 0, 1036}, + DictWord{5, 10, 154}, + DictWord{7, 10, 1491}, + DictWord{ + 10, + 10, + 379, + }, + DictWord{138, 10, 485}, + DictWord{4, 11, 383}, + DictWord{133, 10, 716}, + DictWord{134, 0, 1315}, + DictWord{5, 0, 86}, + DictWord{7, 0, 743}, + DictWord{ + 9, + 0, + 85, + }, + DictWord{10, 0, 281}, + DictWord{10, 0, 432}, + DictWord{11, 0, 825}, + DictWord{12, 0, 251}, + DictWord{13, 0, 118}, + DictWord{142, 0, 378}, + DictWord{ + 8, + 0, + 264, + }, + DictWord{4, 10, 91}, + DictWord{5, 10, 388}, + DictWord{5, 10, 845}, + DictWord{6, 10, 206}, + DictWord{6, 10, 252}, + DictWord{6, 10, 365}, + DictWord{7, 10, 136}, + DictWord{7, 10, 531}, + DictWord{136, 10, 621}, + DictWord{5, 0, 524}, + DictWord{133, 0, 744}, + DictWord{5, 11, 277}, + DictWord{141, 11, 247}, + DictWord{ + 132, + 11, + 435, + }, + DictWord{10, 0, 107}, + DictWord{140, 0, 436}, + DictWord{132, 0, 927}, + DictWord{10, 0, 123}, + DictWord{12, 0, 670}, + DictWord{146, 0, 94}, + DictWord{ + 7, + 0, + 1149, + }, + DictWord{9, 0, 156}, + DictWord{138, 0, 957}, + DictWord{5, 11, 265}, + DictWord{6, 11, 212}, + DictWord{135, 11, 28}, + DictWord{133, 0, 778}, + DictWord{ + 133, + 0, + 502, + }, + DictWord{8, 0, 196}, + DictWord{10, 0, 283}, + DictWord{139, 0, 406}, + DictWord{135, 10, 576}, + DictWord{136, 11, 535}, + DictWord{134, 0, 1312}, + DictWord{ + 5, + 10, + 771, + }, + DictWord{5, 10, 863}, + DictWord{5, 10, 898}, + DictWord{6, 10, 1632}, + DictWord{6, 10, 1644}, + DictWord{134, 10, 1780}, + DictWord{5, 0, 855}, + DictWord{5, 10, 331}, + DictWord{135, 11, 1487}, + DictWord{132, 11, 702}, + DictWord{5, 11, 808}, + DictWord{135, 11, 2045}, + DictWord{7, 0, 1400}, + DictWord{ + 9, + 0, + 446, + }, + DictWord{138, 0, 45}, + DictWord{140, 10, 632}, + DictWord{132, 0, 1003}, + DictWord{5, 11, 166}, + DictWord{8, 11, 739}, + DictWord{140, 11, 511}, + DictWord{ + 5, + 10, + 107, + }, + DictWord{7, 10, 201}, + DictWord{136, 10, 518}, + DictWord{6, 10, 446}, + DictWord{135, 10, 1817}, + DictWord{134, 0, 1532}, + DictWord{ + 134, + 0, + 1097, + }, + DictWord{4, 11, 119}, + DictWord{5, 11, 170}, + DictWord{5, 11, 447}, + DictWord{7, 11, 1708}, + DictWord{7, 11, 1889}, + DictWord{9, 11, 357}, + DictWord{ + 9, + 11, + 719, + }, + DictWord{12, 11, 486}, + DictWord{140, 11, 596}, + DictWord{9, 10, 851}, + DictWord{141, 10, 510}, + DictWord{7, 0, 612}, + DictWord{8, 0, 545}, + DictWord{ + 8, + 0, + 568, + }, + DictWord{8, 0, 642}, + DictWord{9, 0, 717}, + DictWord{10, 0, 541}, + DictWord{10, 0, 763}, + DictWord{11, 0, 449}, + DictWord{12, 0, 489}, + DictWord{13, 0, 153}, + DictWord{13, 0, 296}, + DictWord{14, 0, 138}, + DictWord{14, 0, 392}, + DictWord{15, 0, 50}, + DictWord{16, 0, 6}, + DictWord{16, 0, 12}, + DictWord{20, 0, 9}, + DictWord{ + 132, + 10, + 504, + }, + DictWord{4, 11, 450}, + DictWord{135, 11, 1158}, + DictWord{11, 0, 54}, + DictWord{13, 0, 173}, + DictWord{13, 0, 294}, + DictWord{5, 10, 883}, + DictWord{ + 5, + 10, + 975, + }, + DictWord{8, 10, 392}, + DictWord{148, 10, 7}, + DictWord{13, 0, 455}, + DictWord{15, 0, 99}, + DictWord{15, 0, 129}, + DictWord{144, 0, 68}, + DictWord{135, 0, 172}, + DictWord{132, 11, 754}, + DictWord{5, 10, 922}, + DictWord{134, 10, 1707}, + DictWord{134, 0, 1029}, + DictWord{17, 11, 39}, + DictWord{148, 11, 36}, + DictWord{ + 4, + 0, + 568, + }, + DictWord{5, 10, 993}, + DictWord{7, 10, 515}, + DictWord{137, 10, 91}, + DictWord{132, 0, 732}, + DictWord{10, 0, 617}, + DictWord{138, 11, 617}, + DictWord{ + 134, + 0, + 974, + }, + DictWord{7, 0, 989}, + DictWord{10, 0, 377}, + DictWord{12, 0, 363}, + DictWord{13, 0, 68}, + DictWord{13, 0, 94}, + DictWord{14, 0, 108}, + DictWord{ + 142, + 0, + 306, + }, + DictWord{136, 0, 733}, + DictWord{132, 0, 428}, + DictWord{7, 0, 1789}, + DictWord{135, 11, 1062}, + DictWord{7, 0, 2015}, + DictWord{140, 0, 665}, + DictWord{135, 10, 1433}, + DictWord{5, 0, 287}, + DictWord{7, 10, 921}, + DictWord{8, 10, 580}, + DictWord{8, 10, 593}, + DictWord{8, 10, 630}, + DictWord{138, 10, 28}, + DictWord{138, 0, 806}, + DictWord{4, 10, 911}, + DictWord{5, 10, 867}, + DictWord{5, 10, 1013}, + DictWord{7, 10, 2034}, + DictWord{8, 10, 798}, + DictWord{136, 10, 813}, + DictWord{134, 0, 1539}, + DictWord{8, 11, 523}, + DictWord{150, 11, 34}, + DictWord{135, 11, 740}, + DictWord{7, 11, 238}, + DictWord{7, 11, 2033}, + DictWord{ + 8, + 11, + 120, + }, + DictWord{8, 11, 188}, + DictWord{8, 11, 659}, + DictWord{9, 11, 598}, + DictWord{10, 11, 466}, + DictWord{12, 11, 342}, + DictWord{12, 11, 588}, + DictWord{ + 13, + 11, + 503, + }, + DictWord{14, 11, 246}, + DictWord{143, 11, 92}, + DictWord{7, 0, 1563}, + DictWord{141, 0, 182}, + DictWord{5, 10, 135}, + DictWord{6, 10, 519}, + DictWord{ + 7, + 10, + 1722, + }, + DictWord{10, 10, 271}, + DictWord{11, 10, 261}, + DictWord{145, 10, 54}, + DictWord{14, 10, 338}, + DictWord{148, 10, 81}, + DictWord{7, 0, 484}, + DictWord{ + 4, + 10, + 300, + }, + DictWord{133, 10, 436}, + DictWord{145, 11, 114}, + DictWord{6, 0, 1623}, + DictWord{134, 0, 1681}, + DictWord{133, 11, 640}, + DictWord{4, 11, 201}, + DictWord{7, 11, 1744}, + DictWord{8, 11, 602}, + DictWord{11, 11, 247}, + DictWord{11, 11, 826}, + DictWord{145, 11, 65}, + DictWord{8, 11, 164}, + DictWord{ + 146, + 11, + 62, + }, + DictWord{6, 0, 1833}, + DictWord{6, 0, 1861}, + DictWord{136, 0, 878}, + DictWord{134, 0, 1569}, + DictWord{8, 10, 357}, + DictWord{10, 10, 745}, + DictWord{ + 14, + 10, + 426, + }, + DictWord{17, 10, 94}, + DictWord{147, 10, 57}, + DictWord{12, 0, 93}, + DictWord{12, 0, 501}, + DictWord{13, 0, 362}, + DictWord{14, 0, 151}, + DictWord{15, 0, 40}, + DictWord{15, 0, 59}, + DictWord{16, 0, 46}, + DictWord{17, 0, 25}, + DictWord{18, 0, 14}, + DictWord{18, 0, 134}, + DictWord{19, 0, 25}, + DictWord{19, 0, 69}, + DictWord{ + 20, + 0, + 16, + }, + DictWord{20, 0, 19}, + DictWord{20, 0, 66}, + DictWord{21, 0, 23}, + DictWord{21, 0, 25}, + DictWord{150, 0, 42}, + DictWord{6, 0, 1748}, + DictWord{8, 0, 715}, + DictWord{ + 9, + 0, + 802, + }, + DictWord{10, 0, 46}, + DictWord{10, 0, 819}, + DictWord{13, 0, 308}, + DictWord{14, 0, 351}, + DictWord{14, 0, 363}, + DictWord{146, 0, 67}, + DictWord{ + 132, + 0, + 994, + }, + DictWord{4, 0, 63}, + DictWord{133, 0, 347}, + DictWord{132, 0, 591}, + DictWord{133, 0, 749}, + DictWord{7, 11, 1577}, + DictWord{10, 11, 304}, + DictWord{ + 10, + 11, + 549, + }, + DictWord{11, 11, 424}, + DictWord{12, 11, 365}, + DictWord{13, 11, 220}, + DictWord{13, 11, 240}, + DictWord{142, 11, 33}, + DictWord{133, 0, 366}, + DictWord{ + 7, + 0, + 557, + }, + DictWord{12, 0, 547}, + DictWord{14, 0, 86}, + DictWord{133, 10, 387}, + DictWord{135, 0, 1747}, + DictWord{132, 11, 907}, + DictWord{5, 11, 100}, + DictWord{10, 11, 329}, + DictWord{12, 11, 416}, + DictWord{149, 11, 29}, + DictWord{4, 10, 6}, + DictWord{5, 10, 708}, + DictWord{136, 10, 75}, + DictWord{7, 10, 1351}, + DictWord{9, 10, 581}, + DictWord{10, 10, 639}, + DictWord{11, 10, 453}, + DictWord{140, 10, 584}, + DictWord{7, 0, 89}, + DictWord{132, 10, 303}, + DictWord{138, 10, 772}, + DictWord{132, 11, 176}, + DictWord{5, 11, 636}, + DictWord{5, 11, 998}, + DictWord{8, 11, 26}, + DictWord{137, 11, 358}, + DictWord{7, 11, 9}, + DictWord{7, 11, 1508}, + DictWord{9, 11, 317}, + DictWord{10, 11, 210}, + DictWord{10, 11, 292}, + DictWord{10, 11, 533}, + DictWord{11, 11, 555}, + DictWord{12, 11, 526}, + DictWord{ + 12, + 11, + 607, + }, + DictWord{13, 11, 263}, + DictWord{13, 11, 459}, + DictWord{142, 11, 271}, + DictWord{134, 0, 1463}, + DictWord{6, 0, 772}, + DictWord{6, 0, 1137}, + DictWord{ + 139, + 11, + 595, + }, + DictWord{7, 0, 977}, + DictWord{139, 11, 66}, + DictWord{138, 0, 893}, + DictWord{20, 0, 48}, + DictWord{148, 11, 48}, + DictWord{5, 0, 824}, + DictWord{ + 133, + 0, + 941, + }, + DictWord{134, 11, 295}, + DictWord{7, 0, 1543}, + DictWord{7, 0, 1785}, + DictWord{10, 0, 690}, + DictWord{4, 10, 106}, + DictWord{139, 10, 717}, + DictWord{ + 7, + 0, + 440, + }, + DictWord{8, 0, 230}, + DictWord{139, 0, 106}, + DictWord{5, 10, 890}, + DictWord{133, 10, 988}, + DictWord{6, 10, 626}, + DictWord{142, 10, 431}, + DictWord{ + 10, + 11, + 127, + }, + DictWord{141, 11, 27}, + DictWord{17, 0, 32}, + DictWord{10, 10, 706}, + DictWord{150, 10, 44}, + DictWord{132, 0, 216}, + DictWord{137, 0, 332}, + DictWord{4, 10, 698}, + DictWord{136, 11, 119}, + DictWord{139, 11, 267}, + DictWord{138, 10, 17}, + DictWord{11, 11, 526}, + DictWord{11, 11, 939}, + DictWord{ + 141, + 11, + 290, + }, + DictWord{7, 11, 1167}, + DictWord{11, 11, 934}, + DictWord{13, 11, 391}, + DictWord{145, 11, 76}, + DictWord{139, 11, 39}, + DictWord{134, 10, 84}, + DictWord{ + 4, + 0, + 914, + }, + DictWord{5, 0, 800}, + DictWord{133, 0, 852}, + DictWord{10, 0, 416}, + DictWord{141, 0, 115}, + DictWord{7, 0, 564}, + DictWord{142, 0, 168}, + DictWord{ + 4, + 0, + 918, + }, + DictWord{133, 0, 876}, + DictWord{134, 0, 1764}, + DictWord{152, 0, 3}, + DictWord{4, 0, 92}, + DictWord{5, 0, 274}, + DictWord{7, 11, 126}, + DictWord{136, 11, 84}, + DictWord{140, 10, 498}, + DictWord{136, 11, 790}, + DictWord{8, 0, 501}, + DictWord{5, 10, 986}, + DictWord{6, 10, 130}, + DictWord{7, 10, 1582}, + DictWord{ + 8, + 10, + 458, + }, + DictWord{10, 10, 101}, + DictWord{10, 10, 318}, + DictWord{138, 10, 823}, + DictWord{6, 11, 64}, + DictWord{12, 11, 377}, + DictWord{141, 11, 309}, + DictWord{ + 5, + 0, + 743, + }, + DictWord{138, 0, 851}, + DictWord{4, 0, 49}, + DictWord{7, 0, 280}, + DictWord{135, 0, 1633}, + DictWord{134, 0, 879}, + DictWord{136, 0, 47}, + DictWord{ + 7, + 10, + 1644, + }, + DictWord{137, 10, 129}, + DictWord{132, 0, 865}, + DictWord{134, 0, 1202}, + DictWord{9, 11, 34}, + DictWord{139, 11, 484}, + DictWord{135, 10, 997}, + DictWord{5, 0, 272}, + DictWord{5, 0, 908}, + DictWord{5, 0, 942}, + DictWord{8, 0, 197}, + DictWord{9, 0, 47}, + DictWord{11, 0, 538}, + DictWord{139, 0, 742}, + DictWord{ + 6, + 11, + 1700, + }, + DictWord{7, 11, 26}, + DictWord{7, 11, 293}, + DictWord{7, 11, 382}, + DictWord{7, 11, 1026}, + DictWord{7, 11, 1087}, + DictWord{7, 11, 2027}, + DictWord{ + 8, + 11, + 24, + }, + DictWord{8, 11, 114}, + DictWord{8, 11, 252}, + DictWord{8, 11, 727}, + DictWord{8, 11, 729}, + DictWord{9, 11, 30}, + DictWord{9, 11, 199}, + DictWord{9, 11, 231}, + DictWord{9, 11, 251}, + DictWord{9, 11, 334}, + DictWord{9, 11, 361}, + DictWord{9, 11, 488}, + DictWord{9, 11, 712}, + DictWord{10, 11, 55}, + DictWord{10, 11, 60}, + DictWord{ + 10, + 11, + 232, + }, + DictWord{10, 11, 332}, + DictWord{10, 11, 384}, + DictWord{10, 11, 396}, + DictWord{10, 11, 504}, + DictWord{10, 11, 542}, + DictWord{10, 11, 652}, + DictWord{11, 11, 20}, + DictWord{11, 11, 48}, + DictWord{11, 11, 207}, + DictWord{11, 11, 291}, + DictWord{11, 11, 298}, + DictWord{11, 11, 342}, + DictWord{ + 11, + 11, + 365, + }, + DictWord{11, 11, 394}, + DictWord{11, 11, 620}, + DictWord{11, 11, 705}, + DictWord{11, 11, 1017}, + DictWord{12, 11, 123}, + DictWord{12, 11, 340}, + DictWord{12, 11, 406}, + DictWord{12, 11, 643}, + DictWord{13, 11, 61}, + DictWord{13, 11, 269}, + DictWord{13, 11, 311}, + DictWord{13, 11, 319}, + DictWord{13, 11, 486}, + DictWord{14, 11, 234}, + DictWord{15, 11, 62}, + DictWord{15, 11, 85}, + DictWord{16, 11, 71}, + DictWord{18, 11, 119}, + DictWord{148, 11, 105}, + DictWord{ + 6, + 0, + 1455, + }, + DictWord{150, 11, 37}, + DictWord{135, 10, 1927}, + DictWord{135, 0, 1911}, + DictWord{137, 0, 891}, + DictWord{7, 10, 1756}, + DictWord{137, 10, 98}, + DictWord{7, 10, 1046}, + DictWord{139, 10, 160}, + DictWord{132, 0, 761}, + DictWord{6, 11, 379}, + DictWord{7, 11, 270}, + DictWord{7, 11, 1116}, + DictWord{ + 8, + 11, + 176, + }, + DictWord{8, 11, 183}, + DictWord{9, 11, 432}, + DictWord{9, 11, 661}, + DictWord{12, 11, 247}, + DictWord{12, 11, 617}, + DictWord{146, 11, 125}, + DictWord{ + 6, + 10, + 45, + }, + DictWord{7, 10, 433}, + DictWord{8, 10, 129}, + DictWord{9, 10, 21}, + DictWord{10, 10, 392}, + DictWord{11, 10, 79}, + DictWord{12, 10, 499}, + DictWord{ + 13, + 10, + 199, + }, + DictWord{141, 10, 451}, + DictWord{4, 0, 407}, + DictWord{5, 11, 792}, + DictWord{133, 11, 900}, + DictWord{132, 0, 560}, + DictWord{135, 0, 183}, + DictWord{ + 13, + 0, + 490, + }, + DictWord{7, 10, 558}, + DictWord{136, 10, 353}, + DictWord{4, 0, 475}, + DictWord{6, 0, 731}, + DictWord{11, 0, 35}, + DictWord{13, 0, 71}, + DictWord{13, 0, 177}, + DictWord{14, 0, 422}, + DictWord{133, 10, 785}, + DictWord{8, 10, 81}, + DictWord{9, 10, 189}, + DictWord{9, 10, 201}, + DictWord{11, 10, 478}, + DictWord{11, 10, 712}, + DictWord{141, 10, 338}, + DictWord{4, 0, 418}, + DictWord{4, 0, 819}, + DictWord{133, 10, 353}, + DictWord{151, 10, 26}, + DictWord{4, 11, 901}, + DictWord{ + 133, + 11, + 776, + }, + DictWord{132, 0, 575}, + DictWord{7, 0, 818}, + DictWord{16, 0, 92}, + DictWord{17, 0, 14}, + DictWord{17, 0, 45}, + DictWord{18, 0, 75}, + DictWord{148, 0, 18}, + DictWord{ + 6, + 0, + 222, + }, + DictWord{7, 0, 636}, + DictWord{7, 0, 1620}, + DictWord{8, 0, 409}, + DictWord{9, 0, 693}, + DictWord{139, 0, 77}, + DictWord{6, 10, 25}, + DictWord{7, 10, 855}, + DictWord{7, 10, 1258}, + DictWord{144, 10, 32}, + DictWord{6, 0, 1880}, + DictWord{6, 0, 1887}, + DictWord{6, 0, 1918}, + DictWord{6, 0, 1924}, + DictWord{9, 0, 967}, + DictWord{9, 0, 995}, + DictWord{9, 0, 1015}, + DictWord{12, 0, 826}, + DictWord{12, 0, 849}, + DictWord{12, 0, 857}, + DictWord{12, 0, 860}, + DictWord{12, 0, 886}, + DictWord{ + 12, + 0, + 932, + }, + DictWord{18, 0, 228}, + DictWord{18, 0, 231}, + DictWord{146, 0, 240}, + DictWord{134, 0, 633}, + DictWord{134, 0, 1308}, + DictWord{4, 11, 37}, + DictWord{ + 5, + 11, + 334, + }, + DictWord{135, 11, 1253}, + DictWord{10, 0, 86}, + DictWord{4, 10, 4}, + DictWord{7, 10, 1118}, + DictWord{7, 10, 1320}, + DictWord{7, 10, 1706}, + DictWord{ + 8, + 10, + 277, + }, + DictWord{9, 10, 622}, + DictWord{11, 10, 724}, + DictWord{12, 10, 350}, + DictWord{12, 10, 397}, + DictWord{13, 10, 28}, + DictWord{13, 10, 159}, + DictWord{ + 15, + 10, + 89, + }, + DictWord{18, 10, 5}, + DictWord{19, 10, 9}, + DictWord{20, 10, 34}, + DictWord{150, 10, 47}, + DictWord{132, 11, 508}, + DictWord{137, 11, 448}, + DictWord{ + 12, + 11, + 107, + }, + DictWord{146, 11, 31}, + DictWord{132, 0, 817}, + DictWord{134, 0, 663}, + DictWord{133, 0, 882}, + DictWord{134, 0, 914}, + DictWord{132, 11, 540}, + DictWord{132, 11, 533}, + DictWord{136, 11, 608}, + DictWord{8, 0, 885}, + DictWord{138, 0, 865}, + DictWord{132, 0, 426}, + DictWord{6, 0, 58}, + DictWord{7, 0, 745}, + DictWord{7, 0, 1969}, + DictWord{8, 0, 399}, + DictWord{8, 0, 675}, + DictWord{9, 0, 479}, + DictWord{9, 0, 731}, + DictWord{10, 0, 330}, + DictWord{10, 0, 593}, + DictWord{ + 10, + 0, + 817, + }, + DictWord{11, 0, 32}, + DictWord{11, 0, 133}, + DictWord{11, 0, 221}, + DictWord{145, 0, 68}, + DictWord{134, 10, 255}, + DictWord{7, 0, 102}, + DictWord{ + 137, + 0, + 538, + }, + DictWord{137, 10, 216}, + DictWord{7, 11, 253}, + DictWord{136, 11, 549}, + DictWord{135, 11, 912}, + DictWord{9, 10, 183}, + DictWord{139, 10, 286}, + DictWord{11, 10, 956}, + DictWord{151, 10, 3}, + DictWord{8, 11, 527}, + DictWord{18, 11, 60}, + DictWord{147, 11, 24}, + DictWord{4, 10, 536}, + DictWord{7, 10, 1141}, + DictWord{10, 10, 723}, + DictWord{139, 10, 371}, + DictWord{133, 11, 920}, + DictWord{7, 0, 876}, + DictWord{135, 10, 285}, + DictWord{135, 10, 560}, + DictWord{ + 132, + 10, + 690, + }, + DictWord{142, 11, 126}, + DictWord{11, 10, 33}, + DictWord{12, 10, 571}, + DictWord{149, 10, 1}, + DictWord{133, 0, 566}, + DictWord{9, 0, 139}, + DictWord{ + 10, + 0, + 399, + }, + DictWord{11, 0, 469}, + DictWord{12, 0, 634}, + DictWord{13, 0, 223}, + DictWord{132, 11, 483}, + DictWord{6, 0, 48}, + DictWord{135, 0, 63}, + DictWord{18, 0, 12}, + DictWord{7, 10, 1862}, + DictWord{12, 10, 491}, + DictWord{12, 10, 520}, + DictWord{13, 10, 383}, + DictWord{142, 10, 244}, + DictWord{135, 11, 1665}, + DictWord{132, 11, 448}, + DictWord{9, 11, 495}, + DictWord{146, 11, 104}, + DictWord{6, 0, 114}, + DictWord{7, 0, 1224}, + DictWord{7, 0, 1556}, + DictWord{136, 0, 3}, + DictWord{ + 4, + 10, + 190, + }, + DictWord{133, 10, 554}, + DictWord{8, 0, 576}, + DictWord{9, 0, 267}, + DictWord{133, 10, 1001}, + DictWord{133, 10, 446}, + DictWord{133, 0, 933}, + DictWord{139, 11, 1009}, + DictWord{8, 11, 653}, + DictWord{13, 11, 93}, + DictWord{147, 11, 14}, + DictWord{6, 0, 692}, + DictWord{6, 0, 821}, + DictWord{134, 0, 1077}, + DictWord{5, 11, 172}, + DictWord{135, 11, 801}, + DictWord{138, 0, 752}, + DictWord{4, 0, 375}, + DictWord{134, 0, 638}, + DictWord{134, 0, 1011}, + DictWord{ + 140, + 11, + 540, + }, + DictWord{9, 0, 96}, + DictWord{133, 11, 260}, + DictWord{139, 11, 587}, + DictWord{135, 10, 1231}, + DictWord{12, 0, 30}, + DictWord{13, 0, 148}, + DictWord{ + 14, + 0, + 87, + }, + DictWord{14, 0, 182}, + DictWord{16, 0, 42}, + DictWord{20, 0, 70}, + DictWord{132, 10, 304}, + DictWord{6, 0, 1398}, + DictWord{7, 0, 56}, + DictWord{7, 0, 1989}, + DictWord{8, 0, 337}, + DictWord{8, 0, 738}, + DictWord{9, 0, 600}, + DictWord{12, 0, 37}, + DictWord{13, 0, 447}, + DictWord{142, 0, 92}, + DictWord{138, 0, 666}, + DictWord{ + 5, + 0, + 394, + }, + DictWord{7, 0, 487}, + DictWord{136, 0, 246}, + DictWord{9, 0, 437}, + DictWord{6, 10, 53}, + DictWord{6, 10, 199}, + DictWord{7, 10, 1408}, + DictWord{8, 10, 32}, + DictWord{8, 10, 93}, + DictWord{10, 10, 397}, + DictWord{10, 10, 629}, + DictWord{11, 10, 593}, + DictWord{11, 10, 763}, + DictWord{13, 10, 326}, + DictWord{145, 10, 35}, + DictWord{134, 10, 105}, + DictWord{9, 0, 320}, + DictWord{10, 0, 506}, + DictWord{138, 10, 794}, + DictWord{7, 11, 57}, + DictWord{8, 11, 167}, + DictWord{8, 11, 375}, + DictWord{9, 11, 82}, + DictWord{9, 11, 561}, + DictWord{10, 11, 620}, + DictWord{10, 11, 770}, + DictWord{11, 10, 704}, + DictWord{141, 10, 396}, + DictWord{6, 0, 1003}, + DictWord{5, 10, 114}, + DictWord{5, 10, 255}, + DictWord{141, 10, 285}, + DictWord{7, 0, 866}, + DictWord{135, 0, 1163}, + DictWord{133, 11, 531}, + DictWord{ + 132, + 0, + 328, + }, + DictWord{7, 10, 2035}, + DictWord{8, 10, 19}, + DictWord{9, 10, 89}, + DictWord{138, 10, 831}, + DictWord{8, 11, 194}, + DictWord{136, 11, 756}, + DictWord{ + 136, + 0, + 1000, + }, + DictWord{5, 11, 453}, + DictWord{134, 11, 441}, + DictWord{4, 0, 101}, + DictWord{5, 0, 833}, + DictWord{7, 0, 1171}, + DictWord{136, 0, 744}, + DictWord{ + 133, + 0, + 726, + }, + DictWord{136, 10, 746}, + DictWord{138, 0, 176}, + DictWord{6, 0, 9}, + DictWord{6, 0, 397}, + DictWord{7, 0, 53}, + DictWord{7, 0, 1742}, + DictWord{10, 0, 632}, + DictWord{11, 0, 828}, + DictWord{140, 0, 146}, + DictWord{135, 11, 22}, + DictWord{145, 11, 64}, + DictWord{132, 0, 839}, + DictWord{11, 0, 417}, + DictWord{12, 0, 223}, + DictWord{140, 0, 265}, + DictWord{4, 11, 102}, + DictWord{7, 11, 815}, + DictWord{7, 11, 1699}, + DictWord{139, 11, 964}, + DictWord{5, 10, 955}, + DictWord{ + 136, + 10, + 814, + }, + DictWord{6, 0, 1931}, + DictWord{6, 0, 2007}, + DictWord{18, 0, 246}, + DictWord{146, 0, 247}, + DictWord{8, 0, 198}, + DictWord{11, 0, 29}, + DictWord{140, 0, 534}, + DictWord{135, 0, 1771}, + DictWord{6, 0, 846}, + DictWord{7, 11, 1010}, + DictWord{11, 11, 733}, + DictWord{11, 11, 759}, + DictWord{12, 11, 563}, + DictWord{ + 13, + 11, + 34, + }, + DictWord{14, 11, 101}, + DictWord{18, 11, 45}, + DictWord{146, 11, 129}, + DictWord{4, 0, 186}, + DictWord{5, 0, 157}, + DictWord{8, 0, 168}, + DictWord{138, 0, 6}, + DictWord{132, 11, 899}, + DictWord{133, 10, 56}, + DictWord{148, 10, 100}, + DictWord{133, 0, 875}, + DictWord{5, 0, 773}, + DictWord{5, 0, 991}, + DictWord{6, 0, 1635}, + DictWord{134, 0, 1788}, + DictWord{6, 0, 1274}, + DictWord{9, 0, 477}, + DictWord{141, 0, 78}, + DictWord{4, 0, 639}, + DictWord{7, 0, 111}, + DictWord{8, 0, 581}, + DictWord{ + 12, + 0, + 177, + }, + DictWord{6, 11, 52}, + DictWord{9, 11, 104}, + DictWord{9, 11, 559}, + DictWord{10, 10, 4}, + DictWord{10, 10, 13}, + DictWord{11, 10, 638}, + DictWord{ + 12, + 11, + 308, + }, + DictWord{19, 11, 87}, + DictWord{148, 10, 57}, + DictWord{132, 11, 604}, + DictWord{4, 11, 301}, + DictWord{133, 10, 738}, + DictWord{133, 10, 758}, + DictWord{134, 0, 1747}, + DictWord{7, 11, 1440}, + DictWord{11, 11, 854}, + DictWord{11, 11, 872}, + DictWord{11, 11, 921}, + DictWord{12, 11, 551}, + DictWord{ + 13, + 11, + 472, + }, + DictWord{142, 11, 367}, + DictWord{7, 0, 1364}, + DictWord{7, 0, 1907}, + DictWord{141, 0, 158}, + DictWord{134, 0, 873}, + DictWord{4, 0, 404}, + DictWord{ + 4, + 0, + 659, + }, + DictWord{7, 0, 552}, + DictWord{135, 0, 675}, + DictWord{135, 10, 1112}, + DictWord{139, 10, 328}, + DictWord{7, 11, 508}, + DictWord{137, 10, 133}, + DictWord{133, 0, 391}, + DictWord{5, 10, 110}, + DictWord{6, 10, 169}, + DictWord{6, 10, 1702}, + DictWord{7, 10, 400}, + DictWord{8, 10, 538}, + DictWord{9, 10, 184}, + DictWord{ + 9, + 10, + 524, + }, + DictWord{140, 10, 218}, + DictWord{6, 11, 310}, + DictWord{7, 11, 1849}, + DictWord{8, 11, 72}, + DictWord{8, 11, 272}, + DictWord{8, 11, 431}, + DictWord{ + 9, + 11, + 12, + }, + DictWord{9, 11, 351}, + DictWord{10, 11, 563}, + DictWord{10, 11, 630}, + DictWord{10, 11, 810}, + DictWord{11, 11, 367}, + DictWord{11, 11, 599}, + DictWord{11, 11, 686}, + DictWord{140, 11, 672}, + DictWord{5, 0, 540}, + DictWord{6, 0, 1697}, + DictWord{136, 0, 668}, + DictWord{132, 0, 883}, + DictWord{134, 0, 78}, + DictWord{12, 0, 628}, + DictWord{18, 0, 79}, + DictWord{6, 10, 133}, + DictWord{9, 10, 353}, + DictWord{139, 10, 993}, + DictWord{6, 11, 181}, + DictWord{7, 11, 537}, + DictWord{ + 8, + 11, + 64, + }, + DictWord{9, 11, 127}, + DictWord{10, 11, 496}, + DictWord{12, 11, 510}, + DictWord{141, 11, 384}, + DictWord{6, 10, 93}, + DictWord{7, 10, 1422}, + DictWord{ + 7, + 10, + 1851, + }, + DictWord{8, 10, 673}, + DictWord{9, 10, 529}, + DictWord{140, 10, 43}, + DictWord{137, 10, 371}, + DictWord{134, 0, 1460}, + DictWord{134, 0, 962}, + DictWord{4, 11, 244}, + DictWord{135, 11, 233}, + DictWord{9, 10, 25}, + DictWord{10, 10, 467}, + DictWord{138, 10, 559}, + DictWord{4, 10, 335}, + DictWord{ + 135, + 10, + 942, + }, + DictWord{133, 0, 460}, + DictWord{135, 11, 334}, + DictWord{134, 11, 1650}, + DictWord{4, 0, 199}, + DictWord{139, 0, 34}, + DictWord{5, 10, 601}, + DictWord{ + 8, + 10, + 39, + }, + DictWord{10, 10, 773}, + DictWord{11, 10, 84}, + DictWord{12, 10, 205}, + DictWord{142, 10, 1}, + DictWord{133, 10, 870}, + DictWord{134, 0, 388}, + DictWord{14, 0, 474}, + DictWord{148, 0, 120}, + DictWord{133, 11, 369}, + DictWord{139, 0, 271}, + DictWord{4, 0, 511}, + DictWord{9, 0, 333}, + DictWord{9, 0, 379}, + DictWord{ + 10, + 0, + 602, + }, + DictWord{11, 0, 441}, + DictWord{11, 0, 723}, + DictWord{11, 0, 976}, + DictWord{12, 0, 357}, + DictWord{132, 10, 181}, + DictWord{134, 0, 608}, + DictWord{134, 10, 1652}, + DictWord{22, 0, 49}, + DictWord{137, 11, 338}, + DictWord{140, 0, 988}, + DictWord{134, 0, 617}, + DictWord{5, 0, 938}, + DictWord{136, 0, 707}, + DictWord{132, 10, 97}, + DictWord{5, 10, 147}, + DictWord{6, 10, 286}, + DictWord{7, 10, 1362}, + DictWord{141, 10, 176}, + DictWord{6, 0, 756}, + DictWord{ + 134, + 0, + 1149, + }, + DictWord{133, 11, 896}, + DictWord{6, 10, 375}, + DictWord{7, 10, 169}, + DictWord{7, 10, 254}, + DictWord{136, 10, 780}, + DictWord{134, 0, 1583}, + DictWord{135, 10, 1447}, + DictWord{139, 0, 285}, + DictWord{7, 11, 1117}, + DictWord{8, 11, 393}, + DictWord{136, 11, 539}, + DictWord{135, 0, 344}, + DictWord{ + 6, + 0, + 469, + }, + DictWord{7, 0, 1709}, + DictWord{138, 0, 515}, + DictWord{5, 10, 629}, + DictWord{135, 10, 1549}, + DictWord{5, 11, 4}, + DictWord{5, 11, 810}, + DictWord{ + 6, + 11, + 13, + }, + DictWord{6, 11, 538}, + DictWord{6, 11, 1690}, + DictWord{6, 11, 1726}, + DictWord{7, 11, 499}, + DictWord{7, 11, 1819}, + DictWord{8, 11, 148}, + DictWord{ + 8, + 11, + 696, + }, + DictWord{8, 11, 791}, + DictWord{12, 11, 125}, + DictWord{13, 11, 54}, + DictWord{143, 11, 9}, + DictWord{135, 11, 1268}, + DictWord{137, 0, 404}, + DictWord{ + 132, + 0, + 500, + }, + DictWord{5, 0, 68}, + DictWord{134, 0, 383}, + DictWord{11, 0, 216}, + DictWord{139, 0, 340}, + DictWord{4, 11, 925}, + DictWord{5, 11, 803}, + DictWord{ + 8, + 11, + 698, + }, + DictWord{138, 11, 828}, + DictWord{4, 0, 337}, + DictWord{6, 0, 353}, + DictWord{7, 0, 1934}, + DictWord{8, 0, 488}, + DictWord{137, 0, 429}, + DictWord{7, 0, 236}, + DictWord{7, 0, 1795}, + DictWord{8, 0, 259}, + DictWord{9, 0, 135}, + DictWord{9, 0, 177}, + DictWord{9, 0, 860}, + DictWord{10, 0, 825}, + DictWord{11, 0, 115}, + DictWord{ + 11, + 0, + 370, + }, + DictWord{11, 0, 405}, + DictWord{11, 0, 604}, + DictWord{12, 0, 10}, + DictWord{12, 0, 667}, + DictWord{12, 0, 669}, + DictWord{13, 0, 76}, + DictWord{14, 0, 310}, + DictWord{15, 0, 76}, + DictWord{15, 0, 147}, + DictWord{148, 0, 23}, + DictWord{4, 0, 15}, + DictWord{4, 0, 490}, + DictWord{5, 0, 22}, + DictWord{6, 0, 244}, + DictWord{7, 0, 40}, + DictWord{7, 0, 200}, + DictWord{7, 0, 906}, + DictWord{7, 0, 1199}, + DictWord{9, 0, 616}, + DictWord{10, 0, 716}, + DictWord{11, 0, 635}, + DictWord{11, 0, 801}, + DictWord{ + 140, + 0, + 458, + }, + DictWord{12, 0, 756}, + DictWord{132, 10, 420}, + DictWord{134, 0, 1504}, + DictWord{6, 0, 757}, + DictWord{133, 11, 383}, + DictWord{6, 0, 1266}, + DictWord{ + 135, + 0, + 1735, + }, + DictWord{5, 0, 598}, + DictWord{7, 0, 791}, + DictWord{8, 0, 108}, + DictWord{9, 0, 123}, + DictWord{7, 10, 1570}, + DictWord{140, 10, 542}, + DictWord{ + 142, + 11, + 410, + }, + DictWord{9, 11, 660}, + DictWord{138, 11, 347}, +} diff --git a/symbol_list.go b/symbol_list.go new file mode 100644 index 0000000..52806d6 --- /dev/null +++ b/symbol_list.go @@ -0,0 +1,21 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Utilities for building Huffman decoding tables. */ +type SymbolList struct { + storage []uint16 + offset int +} + +func SymbolListGet(sl SymbolList, i int) uint16 { + return sl.storage[i+sl.offset] +} + +func SymbolListPut(sl SymbolList, i int, val uint16) { + sl.storage[i+sl.offset] = val +} diff --git a/transform.go b/transform.go new file mode 100644 index 0000000..d9965f3 --- /dev/null +++ b/transform.go @@ -0,0 +1,662 @@ +package brotli + +/* transforms is a part of ABI, but not API. + + It means that there are some functions that are supposed to be in "common" + library, but header itself is not placed into include/brotli. This way, + aforementioned functions will be available only to brotli internals. +*/ +const ( + BROTLI_TRANSFORM_IDENTITY = 0 + BROTLI_TRANSFORM_OMIT_LAST_1 = 1 + BROTLI_TRANSFORM_OMIT_LAST_2 = 2 + BROTLI_TRANSFORM_OMIT_LAST_3 = 3 + BROTLI_TRANSFORM_OMIT_LAST_4 = 4 + BROTLI_TRANSFORM_OMIT_LAST_5 = 5 + BROTLI_TRANSFORM_OMIT_LAST_6 = 6 + BROTLI_TRANSFORM_OMIT_LAST_7 = 7 + BROTLI_TRANSFORM_OMIT_LAST_8 = 8 + BROTLI_TRANSFORM_OMIT_LAST_9 = 9 + BROTLI_TRANSFORM_UPPERCASE_FIRST = 10 + BROTLI_TRANSFORM_UPPERCASE_ALL = 11 + BROTLI_TRANSFORM_OMIT_FIRST_1 = 12 + BROTLI_TRANSFORM_OMIT_FIRST_2 = 13 + BROTLI_TRANSFORM_OMIT_FIRST_3 = 14 + BROTLI_TRANSFORM_OMIT_FIRST_4 = 15 + BROTLI_TRANSFORM_OMIT_FIRST_5 = 16 + BROTLI_TRANSFORM_OMIT_FIRST_6 = 17 + BROTLI_TRANSFORM_OMIT_FIRST_7 = 18 + BROTLI_TRANSFORM_OMIT_FIRST_8 = 19 + BROTLI_TRANSFORM_OMIT_FIRST_9 = 20 + BROTLI_TRANSFORM_SHIFT_FIRST = 21 + BROTLI_TRANSFORM_SHIFT_ALL = 22 + iota - 22 + BROTLI_NUM_TRANSFORM_TYPES +) + +const BROTLI_TRANSFORMS_MAX_CUT_OFF = BROTLI_TRANSFORM_OMIT_LAST_9 + +type BrotliTransforms struct { + prefix_suffix_size uint16 + prefix_suffix []byte + prefix_suffix_map []uint16 + num_transforms uint32 + transforms []byte + params []byte + cutOffTransforms [BROTLI_TRANSFORMS_MAX_CUT_OFF + 1]int16 +} + +/* T is BrotliTransforms*; result is uint8_t. */ +func BROTLI_TRANSFORM_PREFIX_ID(t *BrotliTransforms, I int) byte { + return t.transforms[(I*3)+0] +} + +func BROTLI_TRANSFORM_TYPE(t *BrotliTransforms, I int) byte { + return t.transforms[(I*3)+1] +} + +func BROTLI_TRANSFORM_SUFFIX_ID(t *BrotliTransforms, I int) byte { + return t.transforms[(I*3)+2] +} + +/* T is BrotliTransforms*; result is const uint8_t*. */ +func BROTLI_TRANSFORM_PREFIX(t *BrotliTransforms, I int) []byte { + return t.prefix_suffix[t.prefix_suffix_map[BROTLI_TRANSFORM_PREFIX_ID(t, I)]:] +} + +func BROTLI_TRANSFORM_SUFFIX(t *BrotliTransforms, I int) []byte { + return t.prefix_suffix[t.prefix_suffix_map[BROTLI_TRANSFORM_SUFFIX_ID(t, I)]:] +} + +/* RFC 7932 transforms string data */ +var kPrefixSuffix string = "\001 \002, \010 of the \004 of \002s \001.\005 and \004 " + "in \001\"\004 to \002\">\001\n\002. \001]\005 for \003 a \006 " + "that \001'\006 with \006 from \004 by \001(\006. T" + "he \004 on \004 as \004 is \004ing \002\n\t\001:\003ed " + "\002=\"\004 at \003ly \001,\002='\005.com/\007. This \005" + " not \003er \003al \004ful \004ive \005less \004es" + "t \004ize \002\xc2\xa0\004ous \005 the \002e \000" + +/* 0x _0 _2 __5 _E _3 _6 _8 _E */ + +/* 2x _3_ _5 _A_ _D_ _F _2 _4 _A _E */ + +/* 4x _5_ _7 _E _5 _A _C */ + +/* 6x _3 _8 _D _2 _7_ _ _A _C */ + +/* 8x _0 _ _3 _8 _C _E _ _1 _7 _F */ + +/* Ax _5 _9 _D _2 _7 _D */ + +/* Cx _2 _7___ ___ _A _F _5 _8 */ +var kPrefixSuffixMap = [50]uint16{ + 0x00, + 0x02, + 0x05, + 0x0E, + 0x13, + 0x16, + 0x18, + 0x1E, + 0x23, + 0x25, + 0x2A, + 0x2D, + 0x2F, + 0x32, + 0x34, + 0x3A, + 0x3E, + 0x45, + 0x47, + 0x4E, + 0x55, + 0x5A, + 0x5C, + 0x63, + 0x68, + 0x6D, + 0x72, + 0x77, + 0x7A, + 0x7C, + 0x80, + 0x83, + 0x88, + 0x8C, + 0x8E, + 0x91, + 0x97, + 0x9F, + 0xA5, + 0xA9, + 0xAD, + 0xB2, + 0xB7, + 0xBD, + 0xC2, + 0xC7, + 0xCA, + 0xCF, + 0xD5, + 0xD8, +} + +/* RFC 7932 transforms */ +var kTransformsData = []byte{ + 49, + BROTLI_TRANSFORM_IDENTITY, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 0, + 0, + BROTLI_TRANSFORM_IDENTITY, + 0, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_1, + 49, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 47, + 0, + BROTLI_TRANSFORM_IDENTITY, + 49, + 4, + BROTLI_TRANSFORM_IDENTITY, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 3, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 6, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_2, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_1, + 49, + 1, + BROTLI_TRANSFORM_IDENTITY, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 1, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 7, + 49, + BROTLI_TRANSFORM_IDENTITY, + 9, + 48, + BROTLI_TRANSFORM_IDENTITY, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 8, + 49, + BROTLI_TRANSFORM_IDENTITY, + 5, + 49, + BROTLI_TRANSFORM_IDENTITY, + 10, + 49, + BROTLI_TRANSFORM_IDENTITY, + 11, + 49, + BROTLI_TRANSFORM_OMIT_LAST_3, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 13, + 49, + BROTLI_TRANSFORM_IDENTITY, + 14, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_3, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_2, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 15, + 49, + BROTLI_TRANSFORM_IDENTITY, + 16, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 12, + 5, + BROTLI_TRANSFORM_IDENTITY, + 49, + 0, + BROTLI_TRANSFORM_IDENTITY, + 1, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_4, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 18, + 49, + BROTLI_TRANSFORM_IDENTITY, + 17, + 49, + BROTLI_TRANSFORM_IDENTITY, + 19, + 49, + BROTLI_TRANSFORM_IDENTITY, + 20, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_5, + 49, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_6, + 49, + 47, + BROTLI_TRANSFORM_IDENTITY, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_4, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 22, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 23, + 49, + BROTLI_TRANSFORM_IDENTITY, + 24, + 49, + BROTLI_TRANSFORM_IDENTITY, + 25, + 49, + BROTLI_TRANSFORM_OMIT_LAST_7, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_1, + 26, + 49, + BROTLI_TRANSFORM_IDENTITY, + 27, + 49, + BROTLI_TRANSFORM_IDENTITY, + 28, + 0, + BROTLI_TRANSFORM_IDENTITY, + 12, + 49, + BROTLI_TRANSFORM_IDENTITY, + 29, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_9, + 49, + 49, + BROTLI_TRANSFORM_OMIT_FIRST_7, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_6, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 21, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 1, + 49, + BROTLI_TRANSFORM_OMIT_LAST_8, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 31, + 49, + BROTLI_TRANSFORM_IDENTITY, + 32, + 47, + BROTLI_TRANSFORM_IDENTITY, + 3, + 49, + BROTLI_TRANSFORM_OMIT_LAST_5, + 49, + 49, + BROTLI_TRANSFORM_OMIT_LAST_9, + 49, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 1, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 8, + 5, + BROTLI_TRANSFORM_IDENTITY, + 21, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 0, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 10, + 49, + BROTLI_TRANSFORM_IDENTITY, + 30, + 0, + BROTLI_TRANSFORM_IDENTITY, + 5, + 35, + BROTLI_TRANSFORM_IDENTITY, + 49, + 47, + BROTLI_TRANSFORM_IDENTITY, + 2, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 17, + 49, + BROTLI_TRANSFORM_IDENTITY, + 36, + 49, + BROTLI_TRANSFORM_IDENTITY, + 33, + 5, + BROTLI_TRANSFORM_IDENTITY, + 0, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 21, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 5, + 49, + BROTLI_TRANSFORM_IDENTITY, + 37, + 0, + BROTLI_TRANSFORM_IDENTITY, + 30, + 49, + BROTLI_TRANSFORM_IDENTITY, + 38, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 0, + 49, + BROTLI_TRANSFORM_IDENTITY, + 39, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 49, + 49, + BROTLI_TRANSFORM_IDENTITY, + 34, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 8, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 12, + 0, + BROTLI_TRANSFORM_IDENTITY, + 21, + 49, + BROTLI_TRANSFORM_IDENTITY, + 40, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 12, + 49, + BROTLI_TRANSFORM_IDENTITY, + 41, + 49, + BROTLI_TRANSFORM_IDENTITY, + 42, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 17, + 49, + BROTLI_TRANSFORM_IDENTITY, + 43, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 5, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 10, + 0, + BROTLI_TRANSFORM_IDENTITY, + 34, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 33, + 49, + BROTLI_TRANSFORM_IDENTITY, + 44, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 5, + 45, + BROTLI_TRANSFORM_IDENTITY, + 49, + 0, + BROTLI_TRANSFORM_IDENTITY, + 33, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 30, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 30, + 49, + BROTLI_TRANSFORM_IDENTITY, + 46, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 1, + 49, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 34, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 33, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 30, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 1, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 33, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 21, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 12, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 5, + 49, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 34, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 12, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 30, + 0, + BROTLI_TRANSFORM_UPPERCASE_ALL, + 34, + 0, + BROTLI_TRANSFORM_UPPERCASE_FIRST, + 34, +} + +var kBrotliTransforms = BrotliTransforms{ + 217, + []byte(kPrefixSuffix), + kPrefixSuffixMap[:], + 121, + kTransformsData, + nil, /* no extra parameters */ + [BROTLI_TRANSFORMS_MAX_CUT_OFF + 1]int16{0, 12, 27, 23, 42, 63, 56, 48, 59, 64}, +} + +func BrotliGetTransforms() *BrotliTransforms { + return &kBrotliTransforms +} + +func ToUpperCase(p []byte) int { + if p[0] < 0xC0 { + if p[0] >= 'a' && p[0] <= 'z' { + p[0] ^= 32 + } + + return 1 + } + + /* An overly simplified uppercasing model for UTF-8. */ + if p[0] < 0xE0 { + p[1] ^= 32 + return 2 + } + + /* An arbitrary transform for three byte characters. */ + p[2] ^= 5 + + return 3 +} + +func Shift(word []byte, word_len int, parameter uint16) int { + /* Limited sign extension: scalar < (1 << 24). */ + var scalar uint32 = (uint32(parameter) & 0x7FFF) + (0x1000000 - (uint32(parameter) & 0x8000)) + if word[0] < 0x80 { + /* 1-byte rune / 0sssssss / 7 bit scalar (ASCII). */ + scalar += uint32(word[0]) + + word[0] = byte(scalar & 0x7F) + return 1 + } else if word[0] < 0xC0 { + /* Continuation / 10AAAAAA. */ + return 1 + } else if word[0] < 0xE0 { + /* 2-byte rune / 110sssss AAssssss / 11 bit scalar. */ + if word_len < 2 { + return 1 + } + scalar += uint32(word[1]&0x3F | (word[0]&0x1F)<<6) + word[0] = byte(0xC0 | (scalar>>6)&0x1F) + word[1] = byte(uint32(word[1]&0xC0) | scalar&0x3F) + return 2 + } else if word[0] < 0xF0 { + /* 3-byte rune / 1110ssss AAssssss BBssssss / 16 bit scalar. */ + if word_len < 3 { + return word_len + } + scalar += uint32(word[2]&0x3F | (word[1]&0x3F)<<6 | (word[0]&0x0F)<<12) + word[0] = byte(0xE0 | (scalar>>12)&0x0F) + word[1] = byte(uint32(word[1]&0xC0) | (scalar>>6)&0x3F) + word[2] = byte(uint32(word[2]&0xC0) | scalar&0x3F) + return 3 + } else if word[0] < 0xF8 { + /* 4-byte rune / 11110sss AAssssss BBssssss CCssssss / 21 bit scalar. */ + if word_len < 4 { + return word_len + } + scalar += uint32(word[3]&0x3F | (word[2]&0x3F)<<6 | (word[1]&0x3F)<<12 | (word[0]&0x07)<<18) + word[0] = byte(0xF0 | (scalar>>18)&0x07) + word[1] = byte(uint32(word[1]&0xC0) | (scalar>>12)&0x3F) + word[2] = byte(uint32(word[2]&0xC0) | (scalar>>6)&0x3F) + word[3] = byte(uint32(word[3]&0xC0) | scalar&0x3F) + return 4 + } + + return 1 +} + +func BrotliTransformDictionaryWord(dst []byte, word []byte, len int, transforms *BrotliTransforms, transform_idx int) int { + var idx int = 0 + var prefix []byte = BROTLI_TRANSFORM_PREFIX(transforms, transform_idx) + var type_ byte = BROTLI_TRANSFORM_TYPE(transforms, transform_idx) + var suffix []byte = BROTLI_TRANSFORM_SUFFIX(transforms, transform_idx) + { + var prefix_len int = int(prefix[0]) + prefix = prefix[1:] + for { + tmp1 := prefix_len + prefix_len-- + if tmp1 == 0 { + break + } + dst[idx] = prefix[0] + idx++ + prefix = prefix[1:] + } + } + { + var t int = int(type_) + var i int = 0 + if t <= BROTLI_TRANSFORM_OMIT_LAST_9 { + len -= t + } else if t >= BROTLI_TRANSFORM_OMIT_FIRST_1 && t <= BROTLI_TRANSFORM_OMIT_FIRST_9 { + var skip int = t - (BROTLI_TRANSFORM_OMIT_FIRST_1 - 1) + word = word[skip:] + len -= skip + } + + for i < len { + dst[idx] = word[i] + idx++ + i++ + } + if t == BROTLI_TRANSFORM_UPPERCASE_FIRST { + ToUpperCase(dst[idx-len:]) + } else if t == BROTLI_TRANSFORM_UPPERCASE_ALL { + var uppercase []byte = dst + uppercase = uppercase[idx-len:] + for len > 0 { + var step int = ToUpperCase(uppercase) + uppercase = uppercase[step:] + len -= step + } + } else if t == BROTLI_TRANSFORM_SHIFT_FIRST { + var param uint16 = uint16(transforms.params[transform_idx*2] + (transforms.params[transform_idx*2+1] << 8)) + Shift(dst[idx-len:], int(len), param) + } else if t == BROTLI_TRANSFORM_SHIFT_ALL { + var param uint16 = uint16(transforms.params[transform_idx*2] + (transforms.params[transform_idx*2+1] << 8)) + var shift []byte = dst + shift = shift[idx-len:] + for len > 0 { + var step int = Shift(shift, int(len), param) + shift = shift[step:] + len -= step + } + } + } + { + var suffix_len int = int(suffix[0]) + suffix = suffix[1:] + for { + tmp2 := suffix_len + suffix_len-- + if tmp2 == 0 { + break + } + dst[idx] = suffix[0] + idx++ + suffix = suffix[1:] + } + return idx + } +} diff --git a/types.go b/types.go new file mode 100644 index 0000000..446fc85 --- /dev/null +++ b/types.go @@ -0,0 +1,15 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/** + * @file + * Common types used in decoder and encoder API. + */ +const BROTLI_UINT32_MAX = (^(uint32(0))) + +const BROTLI_SIZE_MAX = (^(uint(0))) diff --git a/utf8_util.go b/utf8_util.go new file mode 100644 index 0000000..e2dde14 --- /dev/null +++ b/utf8_util.go @@ -0,0 +1,77 @@ +package brotli + +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Heuristics for deciding about the UTF8-ness of strings. */ +/* Copyright 2013 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Heuristics for deciding about the UTF8-ness of strings. */ +var kMinUTF8Ratio float64 = 0.75 + +/* Returns 1 if at least min_fraction of the bytes between pos and + pos + length in the (data, mask) ring-buffer is UTF8-encoded, otherwise + returns 0. */ +func BrotliParseAsUTF8(symbol *int, input []byte, size uint) uint { + /* ASCII */ + if input[0]&0x80 == 0 { + *symbol = int(input[0]) + if *symbol > 0 { + return 1 + } + } + + /* 2-byte UTF8 */ + if size > 1 && input[0]&0xE0 == 0xC0 && input[1]&0xC0 == 0x80 { + *symbol = (int(input[0])&0x1F)<<6 | int(input[1])&0x3F + if *symbol > 0x7F { + return 2 + } + } + + /* 3-byte UFT8 */ + if size > 2 && input[0]&0xF0 == 0xE0 && input[1]&0xC0 == 0x80 && input[2]&0xC0 == 0x80 { + *symbol = (int(input[0])&0x0F)<<12 | (int(input[1])&0x3F)<<6 | int(input[2])&0x3F + if *symbol > 0x7FF { + return 3 + } + } + + /* 4-byte UFT8 */ + if size > 3 && input[0]&0xF8 == 0xF0 && input[1]&0xC0 == 0x80 && input[2]&0xC0 == 0x80 && input[3]&0xC0 == 0x80 { + *symbol = (int(input[0])&0x07)<<18 | (int(input[1])&0x3F)<<12 | (int(input[2])&0x3F)<<6 | int(input[3])&0x3F + if *symbol > 0xFFFF && *symbol <= 0x10FFFF { + return 4 + } + } + + /* Not UTF8, emit a special symbol above the UTF8-code space */ + *symbol = 0x110000 | int(input[0]) + + return 1 +} + +/* Returns 1 if at least min_fraction of the data is UTF8-encoded.*/ +func BrotliIsMostlyUTF8(data []byte, pos uint, mask uint, length uint, min_fraction float64) bool { + var size_utf8 uint = 0 + var i uint = 0 + for i < length { + var symbol int + var current_data []byte + current_data = data[(pos+i)&mask:] + var bytes_read uint = BrotliParseAsUTF8(&symbol, current_data, length-i) + i += bytes_read + if symbol < 0x110000 { + size_utf8 += bytes_read + } + } + + return float64(size_utf8) > min_fraction*float64(length) +} diff --git a/util.go b/util.go new file mode 100644 index 0000000..e89b1c9 --- /dev/null +++ b/util.go @@ -0,0 +1,15 @@ +package brotli + +import "math" + +const HUGE_VAL = math.MaxFloat64 + +func assert(cond bool) { + if !cond { + panic("assertion failure") + } +} + +func log2(n float64) float64 { + return math.Log2(n) +} diff --git a/version.go b/version.go new file mode 100644 index 0000000..cf4918f --- /dev/null +++ b/version.go @@ -0,0 +1,23 @@ +package brotli + +/* Copyright 2016 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Version definition. */ + +/* This macro should only be used when library is compiled together with client. + If library is dynamically linked, use BrotliDecoderVersion and + BrotliEncoderVersion methods. */ + +/* Semantic version, calculated as (MAJOR << 24) | (MINOR << 12) | PATCH */ +const BROTLI_VERSION = 0x1000007 + +/* This macro is used by build system to produce Libtool-friendly soname. See + https://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html +*/ + +/* ABI version, calculated as (CURRENT << 24) | (REVISION << 12) | AGE */ +const BROTLI_ABI_VERSION = 0x1007000 diff --git a/write_bits.go b/write_bits.go new file mode 100644 index 0000000..1043af9 --- /dev/null +++ b/write_bits.go @@ -0,0 +1,93 @@ +package brotli + +/* Uses the slow shortest-path block splitter and does context clustering. + The distance parameters are dynamically selected based on the commands + which get recomputed under the new distance parameters. The new distance + parameters are stored into *params. */ + +/* Uses a fast greedy block splitter that tries to merge current block with the + last or the second last block and uses a static context clustering which + is the same for all block types. */ +/* All Store functions here will use a storage_ix, which is always the bit + position for the current storage. */ + +/* REQUIRES: length > 0 */ +/* REQUIRES: length <= (1 << 24) */ + +/* Stores the meta-block without doing any block splitting, just collects + one histogram per block category and uses that for entropy coding. + REQUIRES: length > 0 + REQUIRES: length <= (1 << 24) */ + +/* Same as above, but uses static prefix codes for histograms with a only a few + symbols, and uses static code length prefix codes for all other histograms. + REQUIRES: length > 0 + REQUIRES: length <= (1 << 24) */ + +/* This is for storing uncompressed blocks (simple raw storage of + bytes-as-bytes). + REQUIRES: length > 0 + REQUIRES: length <= (1 << 24) */ +/* Copyright 2015 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Static entropy codes used for faster meta-block encoding. */ +/* Copyright 2010 Google Inc. All Rights Reserved. + + Distributed under MIT license. + See file LICENSE for detail or copy at https://opensource.org/licenses/MIT +*/ + +/* Write bits into a byte array. */ + +/*#define BIT_WRITER_DEBUG */ + +/* This function writes bits into bytes in increasing addresses, and within + a byte least-significant-bit first. + + The function can write up to 56 bits in one go with WriteBits + Example: let's assume that 3 bits (Rs below) have been written already: + + BYTE-0 BYTE+1 BYTE+2 + + 0000 0RRR 0000 0000 0000 0000 + + Now, we could write 5 or less bits in MSB by just sifting by 3 + and OR'ing to BYTE-0. + + For n bits, we take the last 5 bits, OR that with high bits in BYTE-0, + and locate the rest in BYTE+1, BYTE+2, etc. */ +func BrotliWriteBits(n_bits uint, bits uint64, pos *uint, array []byte) { + var array_pos []byte = array[*pos>>3:] + var bits_reserved_in_first_byte uint = (*pos & 7) + /* implicit & 0xFF is assumed for uint8_t arithmetics */ + + var bits_left_to_write uint + bits <<= bits_reserved_in_first_byte + array_pos[0] |= byte(bits) + array_pos = array_pos[1:] + for bits_left_to_write = n_bits + bits_reserved_in_first_byte; bits_left_to_write >= 9; bits_left_to_write -= 8 { + bits >>= 8 + array_pos[0] = byte(bits) + array_pos = array_pos[1:] + } + + array_pos[0] = 0 + *pos += n_bits +} + +func BrotliWriteSingleBit(bit bool, pos *uint, array []byte) { + if bit { + BrotliWriteBits(1, 1, pos, array) + } else { + BrotliWriteBits(1, 0, pos, array) + } +} + +func BrotliWriteBitsPrepareStorage(pos uint, array []byte) { + assert(pos&7 == 0) + array[pos>>3] = 0 +}