Path to genome folder specified as: /gscratch/srlab/sr320/data/lambda/ Using 28 threads for the top and bottom strand indexing processes each, so using 56 cores in total Aligner to be used: >> Bowtie 2 << (default) Writing bisulfite genomes out into a single MFA (multi FastA) file Bismark Genome Preparation - Step I: Preparing folders Path to Bowtie 2 specified as: /gscratch/srlab/programs/bowtie2-2.3.4.1-linux-x86_64/ Bisulfite Genome Indexer version v0.21.0 (last modified: 05 Feb 2019) Created Bisulfite Genome folder /gscratch/srlab/sr320/data/lambda/Bisulfite_Genome/ Created Bisulfite Genome folder /gscratch/srlab/sr320/data/lambda/Bisulfite_Genome/CT_conversion/ Created Bisulfite Genome folder /gscratch/srlab/sr320/data/lambda/Bisulfite_Genome/GA_conversion/ Step I - Prepare genome folders - completed Bismark Genome Preparation - Step II: Bisulfite converting reference genome conversions performed: chromosome C->T G->A J02459.1 11362 12820 Total number of conversions performed: C->T: 11362 G->A: 12820 Step II - Genome bisulfite conversions - completed Bismark Genome Preparation - Step III: Launching the Bowtie 2 indexer Please be aware that this process can - depending on genome size - take several hours! Preparing indexing of CT converted genome in /gscratch/srlab/sr320/data/lambda/Bisulfite_Genome/CT_conversion/ Parent process: Starting to index C->T converted genome with the following command: /gscratch/srlab/programs/bowtie2-2.3.4.1-linux-x86_64/bowtie2-build -f genome_mfa.CT_conversion.fa BS_CT --threads 28 Settings: Output files: "BS_CT.*.bt2" Line rate: 6 (line is 64 bytes) Lines per side: 1 (side is 64 bytes) Offset rate: 4 (one in 16) FTable chars: 10 Strings: unpacked Max bucket size: default Max bucket size, sqrt multiplier: default Max bucket size, len divisor: 112 Difference-cover sample period: 1024 Endianness: little Actual local endianness: little Sanity checking: disabled Assertions: disabled Random seed: 0 Sizeofs: void*:8, int:4, long:8, size_t:8 Input files DNA, FASTA: genome_mfa.CT_conversion.fa Building a SMALL index Reading reference sizes Time reading reference sizes: 00:00:00 Calculating joined length Writing header Reserving space for joined string Joining reference sequences Time to join reference sequences: 00:00:00 bmax according to bmaxDivN setting: 433 Using parameters --bmax 325 --dcv 1024 Doing ahead-of-time memory usage test Passed! Constructing with these parameters: --bmax 325 --dcv 1024 Constructing suffix-array element generator Building DifferenceCoverSample Building sPrime Building sPrimeOrder V-Sorting samples V-Sorting samples time: 00:00:00 Allocating rank array Ranking v-sort output Ranking v-sort output time: 00:00:00 Invoking Larsson-Sadakane on ranks Invoking Larsson-Sadakane on ranks time: 00:00:00 Sanity-checking and returning Building samples Reserving space for 300 sample suffixes Generating random suffixes QSorting 300 sample offsets, eliminating duplicates QSorting sample offsets, eliminating duplicates time: 00:00:00 Multikey QSorting 299 samples (Using difference cover) Multikey QSorting samples time: 00:00:00 Calculating bucket sizes Splitting and merging Splitting and merging time: 00:00:00 Split 38, merged 134; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 21, merged 19; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 10, merged 13; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 4, merged 7; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 2, merged 3; iterating... Avg bucket size: 242.734 (target: 324) Converting suffix-array elements to index image Allocating ftab, absorbFtab Entering Ebwt loop Getting block 1 of 199 Getting block 2 of 199 Reserving size (325) for bucket 1 Reserving size (325) for bucket 2 Getting block 3 of 199 Getting block 4 of 199 Getting block 5 of 199 Getting block 6 of 199 Getting block 7 of 199 Getting block 8 of 199 Getting block 9 of 199 Getting block 10 of 199 Getting block 11 of 199 Calculating Z arrays for bucket 1 Getting block 12 of 199 Getting block 13 of 199 Getting block 14 of 199 Getting block 15 of 199 Getting block 16 of 199 Getting block 17 of 199 Getting block 18 of 199 Getting block 19 of 199 Getting block 20 of 199 Getting block 21 of 199 Getting block 22 of 199 Getting block 23 of 199 Getting block 24 of 199 Getting block 25 of 199 Getting block 26 of 199 Getting block 27 of 199 Calculating Z arrays for bucket 2 Reserving size (325) for bucket 3 Reserving size (325) for bucket 4 Reserving size (325) for bucket 5 Reserving size (325) for bucket 6 Reserving size (325) for bucket 7 Reserving size (325) for bucket 8 Reserving size (325) for bucket 9 Reserving size (325) for bucket 10 Reserving size (325) for bucket 11 Entering block accumulator loop for bucket 1: Reserving size (325) for bucket 12 Reserving size (325) for bucket 13 Reserving size (325) for bucket 14 Reserving size (325) for bucket 15 Reserving size (325) for bucket 16 Reserving size (325) for bucket 17 Reserving size (325) for bucket 18 Reserving size (325) for bucket 19 Reserving size (325) for bucket 20 Reserving size (325) for bucket 21 Reserving size (325) for bucket 22 Reserving size (325) for bucket 23 Reserving size (325) for bucket 24 Reserving size (325) for bucket 25 Reserving size (325) for bucket 26 Reserving size (325) for bucket 27 Calculating Z arrays for bucket 3 Calculating Z arrays for bucket 4 Entering block accumulator loop for bucket 2: Calculating Z arrays for bucket 5 Calculating Z arrays for bucket 6 Calculating Z arrays for bucket 7 Calculating Z arrays for bucket 8 Calculating Z arrays for bucket 9 Calculating Z arrays for bucket 10 Calculating Z arrays for bucket 11 Calculating Z arrays for bucket 12 Calculating Z arrays for bucket 13 Calculating Z arrays for bucket 14 Calculating Z arrays for bucket 15 Calculating Z arrays for bucket 16 Calculating Z arrays for bucket 17 Calculating Z arrays for bucket 18 Calculating Z arrays for bucket 19 Calculating Z arrays for bucket 20 Calculating Z arrays for bucket 21 Calculating Z arrays for bucket 22 Calculating Z arrays for bucket 23 Calculating Z arrays for bucket 24 Calculating Z arrays for bucket 25 Calculating Z arrays for bucket 26 Calculating Z arrays for bucket 27 Entering block accumulator loop for bucket 3: Entering block accumulator loop for bucket 4: Entering block accumulator loop for bucket 5: Entering block accumulator loop for bucket 6: Entering block accumulator loop for bucket 7: Entering block accumulator loop for bucket 8: Entering block accumulator loop for bucket 9: Entering block accumulator loop for bucket 10: Entering block accumulator loop for bucket 11: bucket 1: 10% Entering block accumulator loop for bucket 12: Entering block accumulator loop for bucket 13: Entering block accumulator loop for bucket 14: Entering block accumulator loop for bucket 15: Entering block accumulator loop for bucket 16: Entering block accumulator loop for bucket 17: Entering block accumulator loop for bucket 18: Entering block accumulator loop for bucket 19: Entering block accumulator loop for bucket 20: Entering block accumulator loop for bucket 21: Entering block accumulator loop for bucket 22: Entering block accumulator loop for bucket 23: Entering block accumulator loop for bucket 24: Entering block accumulator loop for bucket 25: Entering block accumulator loop for bucket 26: Entering block accumulator loop for bucket 27: bucket 2: 10% bucket 1: 20% bucket 3: 10% bucket 4: 10% bucket 5: 10% bucket 6: 10% bucket 1: 30% bucket 2: 20% bucket 7: 10% bucket 9: 10% bucket 12: 10% bucket 8: 10% bucket 10: 10% bucket 11: 10% bucket 13: 10% bucket 14: 10% bucket 16: 10% bucket 15: 10% bucket 17: 10% bucket 19: 10% bucket 18: 10% bucket 21: 10% bucket 20: 10% bucket 22: 10% bucket 23: 10% bucket 26: 10% bucket 27: 10% bucket 24: 10% bucket 25: 10% bucket 3: 20% bucket 4: 20% bucket 1: 40% bucket 5: 20% bucket 6: 20% bucket 2: 30% bucket 7: 20% bucket 9: 20% bucket 12: 20% bucket 8: 20% bucket 10: 20% bucket 11: 20% bucket 13: 20% bucket 14: 20% bucket 16: 20% bucket 15: 20% bucket 17: 20% bucket 19: 20% bucket 18: 20% bucket 21: 20% bucket 20: 20% bucket 22: 20% bucket 23: 20% bucket 26: 20% bucket 27: 20% bucket 24: 20% bucket 25: 20% bucket 3: 30% bucket 1: 50% bucket 4: 30% bucket 5: 30% bucket 6: 30% bucket 2: 40% bucket 7: 30% bucket 9: 30% bucket 12: 30% bucket 8: 30% bucket 10: 30% bucket 11: 30% bucket 13: 30% bucket 14: 30% bucket 16: 30% bucket 15: 30% bucket 17: 30% bucket 19: 30% bucket 18: 30% bucket 21: 30% bucket 20: 30% bucket 22: 30% bucket 23: 30% bucket 26: 30% bucket 27: 30% bucket 24: 30% bucket 25: 30% bucket 1: 60% bucket 3: 40% bucket 4: 40% bucket 5: 40% bucket 6: 40% bucket 2: 50% bucket 7: 40% bucket 9: 40% bucket 12: 40% bucket 8: 40% bucket 10: 40% bucket 11: 40% bucket 13: 40% bucket 14: 40% bucket 16: 40% bucket 15: 40% bucket 17: 40% bucket 19: 40% bucket 18: 40% bucket 21: 40% bucket 20: 40% bucket 22: 40% bucket 23: 40% bucket 26: 40% bucket 1: 70% bucket 27: 40% bucket 24: 40% bucket 25: 40% bucket 3: 50% bucket 4: 50% bucket 5: 50% bucket 6: 50% bucket 2: 60% bucket 7: 50% bucket 9: 50% bucket 12: 50% bucket 8: 50% bucket 10: 50% bucket 11: 50% bucket 13: 50% bucket 14: 50% bucket 16: 50% bucket 15: 50% bucket 17: 50% bucket 19: 50% bucket 18: 50% bucket 21: 50% bucket 20: 50% bucket 1: 80% bucket 22: 50% bucket 23: 50% bucket 26: 50% bucket 27: 50% bucket 24: 50% bucket 25: 50% bucket 3: 60% bucket 4: 60% bucket 5: 60% bucket 6: 60% bucket 2: 70% bucket 7: 60% bucket 9: 60% bucket 12: 60% bucket 8: 60% bucket 10: 60% bucket 11: 60% bucket 13: 60% bucket 14: 60% bucket 16: 60% bucket 15: 60% bucket 17: 60% bucket 19: 60% bucket 18: 60% bucket 1: 90% bucket 21: 60% bucket 20: 60% bucket 22: 60% bucket 23: 60% bucket 26: 60% bucket 27: 60% bucket 24: 60% bucket 25: 60% bucket 3: 70% bucket 4: 70% bucket 5: 70% bucket 6: 70% bucket 2: 80% bucket 7: 70% bucket 9: 70% bucket 12: 70% bucket 8: 70% bucket 10: 70% bucket 11: 70% bucket 13: 70% bucket 14: 70% bucket 16: 70% bucket 15: 70% bucket 17: 70% bucket 1: 100% bucket 19: 70% bucket 18: 70% bucket 21: 70% bucket 20: 70% bucket 22: 70% bucket 23: 70% bucket 26: 70% bucket 27: 70% bucket 24: 70% bucket 25: 70% bucket 3: 80% bucket 4: 80% bucket 5: 80% bucket 6: 80% bucket 2: 90% bucket 7: 80% bucket 9: 80% bucket 12: 80% bucket 8: 80% bucket 10: 80% Sorting block of length 320 for bucket 1 (Using difference cover) bucket 11: 80% bucket 13: 80% bucket 14: 80% bucket 16: 80% bucket 15: 80% bucket 17: 80% bucket 19: 80% bucket 18: 80% bucket 21: 80% bucket 20: 80% bucket 22: 80% bucket 23: 80% bucket 26: 80% bucket 27: 80% bucket 24: 80% bucket 25: 80% bucket 3: 90% bucket 4: 90% bucket 5: 90% bucket 2: 100% bucket 6: 90% bucket 7: 90% bucket 9: 90% bucket 12: 90% bucket 8: 90% bucket 10: 90% Sorting block time: 00:00:00 bucket 11: 90% bucket 13: 90% bucket 14: 90% bucket 16: 90% bucket 15: 90% bucket 17: 90% bucket 19: 90% bucket 18: 90% bucket 21: 90% bucket 20: 90% bucket 22: 90% bucket 23: 90% bucket 26: 90% bucket 27: 90% bucket 24: 90% bucket 25: 90% Sorting block of length 214 for bucket 2 (Using difference cover) bucket 3: 100% bucket 4: 100% bucket 5: 100% bucket 6: 100% Returning block of 321 for bucket 1 bucket 7: 100% bucket 9: 100% bucket 12: 100% bucket 8: 100% bucket 10: 100% bucket 11: 100% bucket 13: 100% bucket 14: 100% bucket 16: 100% bucket 15: 100% bucket 17: 100% bucket 19: 100% bucket 18: 100% bucket 21: 100% bucket 20: 100% bucket 22: 100% bucket 23: 100% bucket 26: 100% bucket 27: 100% bucket 24: 100% Sorting block of length 255 for bucket 3 (Using difference cover) bucket 25: 100% Sorting block of length 241 for bucket 4 (Using difference cover) Sorting block of length 273 for bucket 5 Sorting block time: 00:00:00 (Using difference cover) Sorting block of length 139 for bucket 6 (Using difference cover) Sorting block of length 225 for bucket 7 (Using difference cover) Sorting block of length 199 for bucket 9 (Using difference cover) Sorting block of length 281 for bucket 12 (Using difference cover) Sorting block of length 282 for bucket 8 (Using difference cover) Sorting block of length 316 for bucket 10 (Using difference cover) Sorting block of length 188 for bucket 11 (Using difference cover) Sorting block of length 276 for bucket 13 (Using difference cover) Sorting block of length 300 for bucket 14 (Using difference cover) Sorting block of length 176 for bucket 16 (Using difference cover) Sorting block of length 208 for bucket 15 (Using difference cover) Sorting block of length 219 for bucket 17 (Using difference cover) Sorting block of length 215 for bucket 19 (Using difference cover) Sorting block of length 313 for bucket 18 (Using difference cover) Sorting block of length 252 for bucket 21 (Using difference cover) Sorting block of length 324 for bucket 20 (Using difference cover) Sorting block of length 273 for bucket 23 (Using difference cover) Sorting block of length 287 for bucket 22 (Using difference cover) Sorting block of length 228 for bucket 26 (Using difference cover) Sorting block of length 236 for bucket 27 (Using difference cover) Sorting block of length 324 for bucket 24 (Using difference cover) Sorting block of length 311 for bucket 25 (Using difference cover) Returning block of 215 for bucket 2 Getting block 28 of 199 Reserving size (325) for bucket 28 Calculating Z arrays for bucket 28 Entering block accumulator loop for bucket 28: bucket 28: 10% bucket 28: 20% bucket 28: 30% bucket 28: 40% bucket 28: 50% bucket 28: 60% bucket 28: 70% Getting block 29 of 199 Reserving size (325) for bucket 29 Calculating Z arrays for bucket 29 bucket 28: 80% Entering block accumulator loop for bucket 29: bucket 28: 90% bucket 29: 10% bucket 28: 100% Sorting block of length 313 for bucket 28 (Using difference cover) bucket 29: 20% bucket 29: 30% bucket 29: 40% bucket 29: 50% bucket 29: 60% bucket 29: 70% bucket 29: 80% bucket 29: 90% bucket 29: 100% Sorting block of length 238 for bucket 29 (Using difference cover) Sorting block time: 00:00:00 Returning block of 314 for bucket 28 Sorting block time: 00:00:00 Returning block of 256 for bucket 3 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 229 for bucket 26 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 325 for bucket 20 Sorting block time: 00:00:00 Returning block of 274 for bucket 23 Returning block of 274 for bucket 5 Sorting block time: 00:00:00 Returning block of 283 for bucket 8 Returning block of 200 for bucket 9 Sorting block time: 00:00:00 Returning block of 216 for bucket 19 Sorting block time: 00:00:00 Returning block of 220 for bucket 17 Returning block of 301 for bucket 14 Returning block of 177 for bucket 16 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 189 for bucket 11 Sorting block time: 00:00:00 Returning block of 242 for bucket 4 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 314 for bucket 18 Sorting block time: 00:00:00 Returning block of 140 for bucket 6 Getting block 30 of 199 Returning block of 237 for bucket 27 Returning block of 312 for bucket 25 Returning block of 277 for bucket 13 Returning block of 209 for bucket 15 Returning block of 239 for bucket 29 Returning block of 288 for bucket 22 Returning block of 282 for bucket 12 Returning block of 325 for bucket 24 Returning block of 226 for bucket 7 Returning block of 253 for bucket 21 Returning block of 317 for bucket 10 Reserving size (325) for bucket 30 Getting block 31 of 199 Calculating Z arrays for bucket 30 Reserving size (325) for bucket 31 Calculating Z arrays for bucket 31 Entering block accumulator loop for bucket 30: Entering block accumulator loop for bucket 31: bucket 31: 10% bucket 30: 10% bucket 31: 20% Getting block 32 of 199 Reserving size (325) for bucket 32 bucket 30: 20% Calculating Z arrays for bucket 32 bucket 31: 30% Entering block accumulator loop for bucket 32: bucket 30: 30% bucket 31: 40% bucket 32: 10% bucket 31: 50% bucket 30: 40% bucket 31: 60% bucket 32: 20% bucket 30: 50% bucket 31: 70% bucket 32: 30% bucket 30: 60% bucket 31: 80% bucket 32: 40% Getting block 33 of 199 bucket 31: 90% bucket 30: 70% Reserving size (325) for bucket 33 Calculating Z arrays for bucket 33 bucket 32: 50% bucket 31: 100% Entering block accumulator loop for bucket 33: Sorting block of length 323 for bucket 31 (Using difference cover) bucket 30: 80% bucket 32: 60% bucket 33: 10% bucket 30: 90% bucket 32: 70% bucket 33: 20% bucket 30: 100% Sorting block of length 190 for bucket 30 (Using difference cover) bucket 32: 80% Sorting block time: 00:00:00 Returning block of 324 for bucket 31 bucket 33: 30% bucket 32: 90% Getting block 34 of 199 bucket 33: 40% Reserving size (325) for bucket 34 Calculating Z arrays for bucket 34 bucket 32: 100% Sorting block of length 324 for bucket 32 (Using difference cover) Entering block accumulator loop for bucket 34: bucket 33: 50% bucket 33: 60% bucket 34: 10% bucket 33: 70% bucket 34: 20% bucket 33: 80% bucket 34: 30% Sorting block time: 00:00:00 Returning block of 191 for bucket 30 bucket 33: 90% bucket 34: 40% Sorting block time: 00:00:00 bucket 33: 100% Returning block of 325 for bucket 32 Sorting block of length 205 for bucket 33 (Using difference cover) bucket 34: 50% Getting block 35 of 199 Reserving size (325) for bucket 35 Calculating Z arrays for bucket 35 Entering block accumulator loop for bucket 35: bucket 34: 60% bucket 35: 10% bucket 34: 70% bucket 35: 20% bucket 34: 80% bucket 35: 30% Sorting block time: 00:00:00 Returning block of 206 for bucket 33 bucket 34: 90% Getting block 36 of 199 bucket 35: 40% Reserving size (325) for bucket 36 Calculating Z arrays for bucket 36 bucket 34: 100% Sorting block of length 318 for bucket 34 (Using difference cover) Entering block accumulator loop for bucket 36: bucket 35: 50% bucket 36: 10% bucket 35: 60% bucket 36: 20% bucket 35: 70% bucket 36: 30% bucket 35: 80% bucket 36: 40% Sorting block time: 00:00:00 Returning block of 319 for bucket 34 Getting block 37 of 199 bucket 35: 90% Reserving size (325) for bucket 37 Calculating Z arrays for bucket 37 bucket 36: 50% Entering block accumulator loop for bucket 37: bucket 35: 100% Sorting block of length 102 for bucket 35 (Using difference cover) bucket 36: 60% bucket 37: 10% bucket 36: 70% bucket 37: 20% bucket 36: 80% bucket 37: 30% Sorting block time: 00:00:00 Returning block of 103 for bucket 35 bucket 36: 90% bucket 37: 40% bucket 36: 100% Sorting block of length 300 for bucket 36 (Using difference cover) bucket 37: 50% Getting block 38 of 199 Reserving size (325) for bucket 38 Calculating Z arrays for bucket 38 bucket 37: 60% Entering block accumulator loop for bucket 38: bucket 37: 70% bucket 38: 10% Sorting block time: 00:00:00 Returning block of 301 for bucket 36 bucket 37: 80% bucket 38: 20% Getting block 39 of 199 bucket 37: 90% Reserving size (325) for bucket 39 bucket 38: 30% Calculating Z arrays for bucket 39 Entering block accumulator loop for bucket 39: bucket 37: 100% Sorting block of length 162 for bucket 37 (Using difference cover) bucket 38: 40% bucket 39: 10% bucket 38: 50% bucket 39: 20% bucket 38: 60% bucket 39: 30% Sorting block time: 00:00:00 Returning block of 163 for bucket 37 bucket 38: 70% bucket 39: 40% bucket 38: 80% bucket 39: 50% bucket 38: 90% bucket 39: 60% Getting block 40 of 199 Reserving size (325) for bucket 40 Calculating Z arrays for bucket 40 Entering block accumulator loop for bucket 40: bucket 39: 70% bucket 38: 100% Sorting block of length 210 for bucket 38 (Using difference cover) bucket 40: 10% bucket 39: 80% bucket 40: 20% bucket 39: 90% bucket 40: 30% bucket 39: 100% Sorting block of length 287 for bucket 39 (Using difference cover) bucket 40: 40% Getting block 41 of 199 Sorting block time: 00:00:00 Returning block of 211 for bucket 38 Reserving size (325) for bucket 41 Calculating Z arrays for bucket 41 bucket 40: 50% Entering block accumulator loop for bucket 41: bucket 40: 60% bucket 41: 10% bucket 40: 70% bucket 41: 20% bucket 40: 80% Sorting block time: 00:00:00 Returning block of 288 for bucket 39 bucket 41: 30% bucket 40: 90% bucket 41: 40% Getting block 42 of 199 bucket 40: 100% Reserving size (325) for bucket 42 Sorting block of length 229 for bucket 40 (Using difference cover) Calculating Z arrays for bucket 42 bucket 41: 50% Entering block accumulator loop for bucket 42: bucket 41: 60% bucket 42: 10% bucket 41: 70% bucket 42: 20% Sorting block time: 00:00:00 Returning block of 230 for bucket 40 bucket 41: 80% bucket 42: 30% Getting block 43 of 199 bucket 41: 90% bucket 42: 40% Reserving size (325) for bucket 43 Calculating Z arrays for bucket 43 Entering block accumulator loop for bucket 43: bucket 41: 100% bucket 42: 50% Sorting block of length 317 for bucket 41 (Using difference cover) bucket 43: 10% bucket 42: 60% bucket 43: 20% bucket 42: 70% bucket 43: 30% bucket 42: 80% Sorting block time: 00:00:00 Returning block of 318 for bucket 41 bucket 43: 40% Getting block 44 of 199 Reserving size (325) for bucket 44 Calculating Z arrays for bucket 44 bucket 42: 90% Entering block accumulator loop for bucket 44: bucket 43: 50% bucket 42: 100% Sorting block of length 304 for bucket 42 (Using difference cover) bucket 44: 10% bucket 43: 60% bucket 44: 20% bucket 43: 70% bucket 44: 30% bucket 43: 80% Getting block 45 of 199 bucket 44: 40% Reserving size (325) for bucket 45 bucket 43: 90% Calculating Z arrays for bucket 45 Sorting block time: 00:00:00 Returning block of 305 for bucket 42 Entering block accumulator loop for bucket 45: bucket 44: 50% bucket 43: 100% Sorting block of length 285 for bucket 43 (Using difference cover) bucket 45: 10% bucket 44: 60% bucket 45: 20% bucket 44: 70% bucket 45: 30% bucket 44: 80% bucket 45: 40% Sorting block time: 00:00:00 Returning block of 286 for bucket 43 bucket 44: 90% Getting block 46 of 199 Reserving size (325) for bucket 46 Calculating Z arrays for bucket 46 bucket 45: 50% Entering block accumulator loop for bucket 46: bucket 44: 100% Sorting block of length 232 for bucket 44 (Using difference cover) bucket 45: 60% bucket 46: 10% bucket 46: 20% bucket 45: 70% Getting block 47 of 199 Reserving size (325) for bucket 47 bucket 46: 30% Calculating Z arrays for bucket 47 bucket 45: 80% Entering block accumulator loop for bucket 47: Sorting block time: 00:00:00 Returning block of 233 for bucket 44 bucket 46: 40% bucket 45: 90% bucket 47: 10% bucket 46: 50% bucket 45: 100% Sorting block of length 238 for bucket 45 (Using difference cover) bucket 47: 20% bucket 46: 60% bucket 47: 30% bucket 46: 70% bucket 47: 40% bucket 46: 80% Sorting block time: 00:00:00 Returning block of 239 for bucket 45 bucket 47: 50% Getting block 48 of 199 Reserving size (325) for bucket 48 Calculating Z arrays for bucket 48 bucket 46: 90% Entering block accumulator loop for bucket 48: bucket 47: 60% bucket 46: 100% bucket 48: 10% Sorting block of length 146 for bucket 46 (Using difference cover) bucket 47: 70% Getting block 49 of 199 Reserving size (325) for bucket 49 bucket 48: 20% Calculating Z arrays for bucket 49 bucket 47: 80% Entering block accumulator loop for bucket 49: bucket 48: 30% bucket 47: 90% bucket 49: 10% bucket 48: 40% Sorting block time: 00:00:00 Returning block of 147 for bucket 46 bucket 47: 100% Sorting block of length 252 for bucket 47 (Using difference cover) bucket 49: 20% bucket 48: 50% bucket 49: 30% bucket 48: 60% Getting block 50 of 199 Reserving size (325) for bucket 50 Calculating Z arrays for bucket 50 Entering block accumulator loop for bucket 50: bucket 48: 70% bucket 49: 40% Sorting block time: 00:00:00 Returning block of 253 for bucket 47 bucket 50: 10% bucket 48: 80% bucket 49: 50% bucket 50: 20% bucket 48: 90% bucket 49: 60% bucket 50: 30% Getting block 51 of 199 bucket 48: 100% Reserving size (325) for bucket 51 bucket 49: 70% Sorting block of length 315 for bucket 48 (Using difference cover) Calculating Z arrays for bucket 51 bucket 50: 40% Entering block accumulator loop for bucket 51: bucket 49: 80% bucket 50: 50% bucket 51: 10% bucket 49: 90% bucket 50: 60% bucket 51: 20% bucket 49: 100% bucket 50: 70% Sorting block of length 143 for bucket 49 (Using difference cover) bucket 51: 30% bucket 50: 80% bucket 50: 90% bucket 51: 40% bucket 50: 100% Sorting block of length 259 for bucket 50 (Using difference cover) Getting block 52 of 199 Sorting block time: 00:00:00 Returning block of 316 for bucket 48 bucket 51: 50% Reserving size (325) for bucket 52 Calculating Z arrays for bucket 52 Entering block accumulator loop for bucket 52: bucket 51: 60% bucket 52: 10% bucket 51: 70% Sorting block time: 00:00:00 Returning block of 144 for bucket 49 bucket 52: 20% bucket 51: 80% Sorting block time: 00:00:00 Returning block of 260 for bucket 50 bucket 52: 30% bucket 51: 90% Getting block 53 of 199 Reserving size (325) for bucket 53 Calculating Z arrays for bucket 53 Entering block accumulator loop for bucket 53: bucket 51: 100% bucket 52: 40% Sorting block of length 156 for bucket 51 (Using difference cover) bucket 53: 10% bucket 52: 50% bucket 53: 20% bucket 52: 60% bucket 53: 30% bucket 52: 70% bucket 53: 40% Getting block 54 of 199 Reserving size (325) for bucket 54 Calculating Z arrays for bucket 54 Sorting block time: 00:00:00 Returning block of 157 for bucket 51 bucket 52: 80% bucket 53: 50% Entering block accumulator loop for bucket 54: bucket 53: 60% bucket 52: 90% bucket 54: 10% bucket 53: 70% bucket 54: 20% bucket 52: 100% Sorting block of length 187 for bucket 52 (Using difference cover) bucket 53: 80% bucket 54: 30% Getting block 55 of 199 Reserving size (325) for bucket 55 Calculating Z arrays for bucket 55 bucket 53: 90% Entering block accumulator loop for bucket 55: bucket 54: 40% bucket 53: 100% Sorting block of length 220 for bucket 53 (Using difference cover) bucket 55: 10% bucket 54: 50% bucket 54: 60% bucket 55: 20% bucket 54: 70% bucket 55: 30% bucket 54: 80% bucket 55: 40% Sorting block time: 00:00:00 Returning block of 188 for bucket 52 Getting block 56 of 199 bucket 54: 90% Sorting block time: 00:00:00 Reserving size (325) for bucket 56 Returning block of 221 for bucket 53 bucket 55: 50% Calculating Z arrays for bucket 56 bucket 54: 100% Entering block accumulator loop for bucket 56: Sorting block of length 292 for bucket 54 (Using difference cover) bucket 55: 60% bucket 55: 70% bucket 56: 10% bucket 55: 80% bucket 56: 20% bucket 55: 90% bucket 56: 30% bucket 55: 100% Sorting block of length 220 for bucket 55 (Using difference cover) bucket 56: 40% Sorting block time: 00:00:00 Returning block of 293 for bucket 54 bucket 56: 50% bucket 56: 60% Sorting block time: 00:00:00 Returning block of 221 for bucket 55 Getting block 57 of 199 bucket 56: 70% Reserving size (325) for bucket 57 Calculating Z arrays for bucket 57 Entering block accumulator loop for bucket 57: bucket 56: 80% bucket 57: 10% bucket 56: 90% bucket 57: 20% bucket 56: 100% Sorting block of length 228 for bucket 56 (Using difference cover) bucket 57: 30% Getting block 58 of 199 Reserving size (325) for bucket 58 Calculating Z arrays for bucket 58 bucket 57: 40% Entering block accumulator loop for bucket 58: bucket 57: 50% bucket 58: 10% bucket 57: 60% Sorting block time: 00:00:00 Returning block of 229 for bucket 56 bucket 58: 20% bucket 57: 70% bucket 58: 30% Getting block 59 of 199 Reserving size (325) for bucket 59 Calculating Z arrays for bucket 59 bucket 57: 80% Entering block accumulator loop for bucket 59: bucket 58: 40% bucket 57: 90% bucket 58: 50% bucket 59: 10% bucket 57: 100% bucket 58: 60% Sorting block of length 155 for bucket 57 (Using difference cover) bucket 59: 20% bucket 58: 70% bucket 59: 30% bucket 58: 80% Getting block 60 of 199 Reserving size (325) for bucket 60 Calculating Z arrays for bucket 60 Entering block accumulator loop for bucket 60: bucket 59: 40% bucket 58: 90% Sorting block time: 00:00:00 Returning block of 156 for bucket 57 bucket 60: 10% bucket 59: 50% bucket 58: 100% Sorting block of length 260 for bucket 58 (Using difference cover) bucket 60: 20% bucket 59: 60% bucket 60: 30% bucket 59: 70% bucket 60: 40% Getting block 61 of 199 bucket 59: 80% bucket 60: 50% Reserving size (325) for bucket 61 Calculating Z arrays for bucket 61 Entering block accumulator loop for bucket 61: Sorting block time: 00:00:00 bucket 60: 60% Returning block of 261 for bucket 58 bucket 59: 90% bucket 60: 70% bucket 61: 10% bucket 59: 100% bucket 60: 80% Sorting block of length 237 for bucket 59 (Using difference cover) bucket 61: 20% bucket 60: 90% Getting block 62 of 199 bucket 61: 30% bucket 60: 100% Reserving size (325) for bucket 62 Sorting block of length 252 for bucket 60 (Using difference cover) Calculating Z arrays for bucket 62 Entering block accumulator loop for bucket 62: bucket 61: 40% bucket 62: 10% bucket 61: 50% bucket 61: 60% bucket 62: 20% bucket 61: 70% Sorting block time: 00:00:00 Returning block of 238 for bucket 59 bucket 62: 30% Getting block 63 of 199 Reserving size (325) for bucket 63 bucket 61: 80% Calculating Z arrays for bucket 63 Sorting block time: 00:00:00 Returning block of 253 for bucket 60 bucket 62: 40% Entering block accumulator loop for bucket 63: bucket 61: 90% bucket 62: 50% bucket 63: 10% bucket 61: 100% Sorting block of length 123 for bucket 61 (Using difference cover) bucket 62: 60% bucket 63: 20% bucket 62: 70% Getting block 64 of 199 bucket 63: 30% Reserving size (325) for bucket 64 Calculating Z arrays for bucket 64 bucket 62: 80% Entering block accumulator loop for bucket 64: bucket 63: 40% bucket 62: 90% bucket 64: 10% Sorting block time: 00:00:00 bucket 63: 50% Returning block of 124 for bucket 61 bucket 62: 100% Sorting block of length 312 for bucket 62 (Using difference cover) bucket 64: 20% bucket 63: 60% bucket 63: 70% bucket 64: 30% bucket 63: 80% bucket 64: 40% Sorting block time: 00:00:00 Returning block of 313 for bucket 62 bucket 63: 90% bucket 64: 50% Getting block 65 of 199 bucket 63: 100% bucket 64: 60% Reserving size (325) for bucket 65 Sorting block of length 283 for bucket 63 (Using difference cover) Calculating Z arrays for bucket 65 Entering block accumulator loop for bucket 65: bucket 64: 70% bucket 65: 10% bucket 64: 80% bucket 65: 20% bucket 64: 90% Sorting block time: 00:00:00 Returning block of 284 for bucket 63 bucket 65: 30% bucket 64: 100% Sorting block of length 230 for bucket 64 (Using difference cover) Getting block 66 of 199 Reserving size (325) for bucket 66 Calculating Z arrays for bucket 66 bucket 65: 40% Entering block accumulator loop for bucket 66: bucket 65: 50% bucket 66: 10% bucket 65: 60% Sorting block time: 00:00:00 Returning block of 231 for bucket 64 bucket 66: 20% bucket 65: 70% bucket 65: 80% bucket 66: 30% Getting block 67 of 199 Reserving size (325) for bucket 67 Calculating Z arrays for bucket 67 Entering block accumulator loop for bucket 67: bucket 65: 90% bucket 66: 40% bucket 65: 100% Sorting block of length 297 for bucket 65 (Using difference cover) bucket 67: 10% bucket 66: 50% bucket 67: 20% bucket 66: 60% bucket 66: 70% bucket 67: 30% Sorting block time: 00:00:00 Returning block of 298 for bucket 65 bucket 66: 80% bucket 67: 40% bucket 66: 90% bucket 67: 50% Getting block 68 of 199 Reserving size (325) for bucket 68 Calculating Z arrays for bucket 68 Entering block accumulator loop for bucket 68: bucket 66: 100% bucket 67: 60% Sorting block of length 146 for bucket 66 (Using difference cover) bucket 68: 10% bucket 67: 70% bucket 68: 20% bucket 67: 80% bucket 68: 30% bucket 67: 90% Sorting block time: 00:00:00 Getting block 69 of 199 Returning block of 147 for bucket 66 Reserving size (325) for bucket 69 bucket 68: 40% Calculating Z arrays for bucket 69 bucket 67: 100% Sorting block of length 228 for bucket 67 (Using difference cover) Entering block accumulator loop for bucket 69: bucket 68: 50% bucket 69: 10% bucket 68: 60% bucket 68: 70% bucket 69: 20% Sorting block time: 00:00:00 bucket 68: 80% Returning block of 229 for bucket 67 bucket 69: 30% bucket 68: 90% Getting block 70 of 199 Reserving size (325) for bucket 70 bucket 69: 40% Calculating Z arrays for bucket 70 Entering block accumulator loop for bucket 70: bucket 68: 100% Sorting block of length 305 for bucket 68 (Using difference cover) bucket 69: 50% bucket 70: 10% bucket 69: 60% bucket 69: 70% bucket 70: 20% bucket 69: 80% bucket 70: 30% Sorting block time: 00:00:00 Returning block of 306 for bucket 68 Getting block 71 of 199 Reserving size (325) for bucket 71 Calculating Z arrays for bucket 71 bucket 69: 90% bucket 70: 40% Entering block accumulator loop for bucket 71: bucket 69: 100% Sorting block of length 318 for bucket 69 (Using difference cover) bucket 70: 50% bucket 71: 10% bucket 70: 60% bucket 71: 20% bucket 70: 70% Getting block 72 of 199 Reserving size (325) for bucket 72 bucket 71: 30% Calculating Z arrays for bucket 72 bucket 70: 80% Entering block accumulator loop for bucket 72: Sorting block time: 00:00:00 Returning block of 319 for bucket 69 bucket 71: 40% bucket 70: 90% bucket 72: 10% bucket 71: 50% bucket 70: 100% Sorting block of length 216 for bucket 70 (Using difference cover) bucket 72: 20% bucket 71: 60% bucket 72: 30% Getting block 73 of 199 bucket 71: 70% Reserving size (325) for bucket 73 Calculating Z arrays for bucket 73 Entering block accumulator loop for bucket 73: bucket 72: 40% bucket 71: 80% Sorting block time: 00:00:00 Returning block of 217 for bucket 70 bucket 72: 50% bucket 73: 10% bucket 71: 90% bucket 72: 60% bucket 73: 20% bucket 71: 100% Sorting block of length 272 for bucket 71 (Using difference cover) bucket 72: 70% bucket 73: 30% bucket 72: 80% bucket 73: 40% bucket 72: 90% bucket 73: 50% Sorting block time: 00:00:00 Returning block of 273 for bucket 71 bucket 72: 100% Sorting block of length 116 for bucket 72 (Using difference cover) bucket 73: 60% Getting block 74 of 199 Reserving size (325) for bucket 74 Calculating Z arrays for bucket 74 Entering block accumulator loop for bucket 74: bucket 73: 70% bucket 73: 80% bucket 74: 10% Getting block 75 of 199 Reserving size (325) for bucket 75 Calculating Z arrays for bucket 75 Sorting block time: 00:00:00 Returning block of 117 for bucket 72 Entering block accumulator loop for bucket 75: bucket 73: 90% bucket 74: 20% bucket 73: 100% Sorting block of length 322 for bucket 73 (Using difference cover) bucket 75: 10% bucket 74: 30% bucket 75: 20% bucket 74: 40% bucket 75: 30% bucket 74: 50% Sorting block time: 00:00:00 Returning block of 323 for bucket 73 bucket 74: 60% bucket 75: 40% bucket 74: 70% bucket 75: 50% Getting block 76 of 199 Reserving size (325) for bucket 76 Calculating Z arrays for bucket 76 bucket 74: 80% Entering block accumulator loop for bucket 76: bucket 75: 60% bucket 74: 90% bucket 75: 70% bucket 76: 10% bucket 74: 100% Sorting block of length 316 for bucket 74 (Using difference cover) bucket 75: 80% bucket 76: 20% bucket 75: 90% bucket 76: 30% Getting block 77 of 199 Reserving size (325) for bucket 77 Calculating Z arrays for bucket 77 bucket 75: 100% Sorting block of length 252 for bucket 75 (Using difference cover) Entering block accumulator loop for bucket 77: bucket 76: 40% Sorting block time: 00:00:00 Returning block of 317 for bucket 74 bucket 76: 50% bucket 77: 10% bucket 76: 60% bucket 77: 20% bucket 76: 70% bucket 77: 30% Sorting block time: 00:00:00 Getting block 78 of 199 Returning block of 253 for bucket 75 Reserving size (325) for bucket 78 bucket 76: 80% Calculating Z arrays for bucket 78 bucket 77: 40% Entering block accumulator loop for bucket 78: bucket 76: 90% bucket 77: 50% bucket 78: 10% bucket 76: 100% bucket 77: 60% Sorting block of length 290 for bucket 76 (Using difference cover) bucket 78: 20% bucket 77: 70% bucket 78: 30% bucket 77: 80% Getting block 79 of 199 Reserving size (325) for bucket 79 bucket 78: 40% Sorting block time: 00:00:00 bucket 77: 90% Calculating Z arrays for bucket 79 Returning block of 291 for bucket 76 Entering block accumulator loop for bucket 79: bucket 78: 50% bucket 77: 100% Sorting block of length 194 for bucket 77 (Using difference cover) bucket 79: 10% bucket 78: 60% bucket 78: 70% bucket 79: 20% bucket 78: 80% bucket 79: 30% Sorting block time: 00:00:00 Returning block of 195 for bucket 77 Getting block 80 of 199 Reserving size (325) for bucket 80 Calculating Z arrays for bucket 80 bucket 78: 90% Entering block accumulator loop for bucket 80: bucket 79: 40% bucket 78: 100% Sorting block of length 247 for bucket 78 (Using difference cover) bucket 80: 10% bucket 79: 50% bucket 80: 20% bucket 79: 60% Getting block 81 of 199 Reserving size (325) for bucket 81 Calculating Z arrays for bucket 81 bucket 80: 30% bucket 79: 70% Entering block accumulator loop for bucket 81: Sorting block time: 00:00:00 Returning block of 248 for bucket 78 bucket 80: 40% bucket 79: 80% bucket 81: 10% bucket 80: 50% bucket 79: 90% bucket 81: 20% bucket 80: 60% bucket 79: 100% bucket 81: 30% Sorting block of length 192 for bucket 79 (Using difference cover) bucket 80: 70% bucket 81: 40% bucket 80: 80% Getting block 82 of 199 Reserving size (325) for bucket 82 Calculating Z arrays for bucket 82 bucket 81: 50% Entering block accumulator loop for bucket 82: bucket 80: 90% bucket 81: 60% Sorting block time: 00:00:00 Returning block of 193 for bucket 79 bucket 80: 100% bucket 82: 10% Sorting block of length 267 for bucket 80 (Using difference cover) bucket 81: 70% bucket 82: 20% bucket 81: 80% bucket 82: 30% Getting block 83 of 199 bucket 81: 90% Reserving size (325) for bucket 83 Calculating Z arrays for bucket 83 Entering block accumulator loop for bucket 83: bucket 82: 40% bucket 81: 100% Sorting block of length 303 for bucket 81 (Using difference cover) bucket 82: 50% Sorting block time: 00:00:00 bucket 83: 10% Returning block of 268 for bucket 80 bucket 82: 60% bucket 83: 20% Getting block 84 of 199 Reserving size (325) for bucket 84 Calculating Z arrays for bucket 84 bucket 82: 70% Entering block accumulator loop for bucket 84: bucket 83: 30% bucket 82: 80% Sorting block time: 00:00:00 Returning block of 304 for bucket 81 bucket 84: 10% bucket 83: 40% bucket 82: 90% bucket 83: 50% bucket 84: 20% bucket 82: 100% Sorting block of length 254 for bucket 82 (Using difference cover) bucket 83: 60% bucket 84: 30% bucket 83: 70% bucket 84: 40% Getting block 85 of 199 Reserving size (325) for bucket 85 Calculating Z arrays for bucket 85 bucket 83: 80% Entering block accumulator loop for bucket 85: bucket 84: 50% Sorting block time: 00:00:00 Returning block of 255 for bucket 82 bucket 83: 90% bucket 85: 10% bucket 84: 60% bucket 83: 100% Sorting block of length 267 for bucket 83 (Using difference cover) bucket 85: 20% bucket 84: 70% bucket 85: 30% bucket 84: 80% Getting block 86 of 199 Reserving size (325) for bucket 86 Calculating Z arrays for bucket 86 Entering block accumulator loop for bucket 86: bucket 85: 40% bucket 84: 90% bucket 85: 50% Sorting block time: 00:00:00 bucket 86: 10% Returning block of 268 for bucket 83 bucket 84: 100% Sorting block of length 212 for bucket 84 (Using difference cover) bucket 85: 60% bucket 86: 20% bucket 85: 70% bucket 86: 30% bucket 85: 80% Getting block 87 of 199 Reserving size (325) for bucket 87 Calculating Z arrays for bucket 87 bucket 86: 40% Entering block accumulator loop for bucket 87: bucket 85: 90% Sorting block time: 00:00:00 Returning block of 213 for bucket 84 bucket 86: 50% bucket 85: 100% bucket 87: 10% Sorting block of length 309 for bucket 85 (Using difference cover) bucket 86: 60% bucket 87: 20% bucket 86: 70% bucket 87: 30% Getting block 88 of 199 Reserving size (325) for bucket 88 bucket 86: 80% Calculating Z arrays for bucket 88 Entering block accumulator loop for bucket 88: bucket 87: 40% bucket 86: 90% Sorting block time: 00:00:00 bucket 88: 10% Returning block of 310 for bucket 85 bucket 87: 50% bucket 88: 20% bucket 86: 100% Sorting block of length 289 for bucket 86 (Using difference cover) bucket 87: 60% bucket 88: 30% bucket 88: 40% bucket 87: 70% bucket 88: 50% bucket 87: 80% bucket 88: 60% Sorting block time: 00:00:00 Returning block of 290 for bucket 86 bucket 88: 70% bucket 87: 90% Getting block 89 of 199 Reserving size (325) for bucket 89 Calculating Z arrays for bucket 89 bucket 88: 80% Entering block accumulator loop for bucket 89: bucket 87: 100% Sorting block of length 263 for bucket 87 (Using difference cover) bucket 88: 90% bucket 89: 10% bucket 88: 100% Sorting block of length 133 for bucket 88 (Using difference cover) bucket 89: 20% bucket 89: 30% Getting block 90 of 199 Reserving size (325) for bucket 90 Calculating Z arrays for bucket 90 Entering block accumulator loop for bucket 90: bucket 89: 40% bucket 90: 10% bucket 89: 50% Sorting block time: 00:00:00 Returning block of 264 for bucket 87 Sorting block time: 00:00:00 Returning block of 134 for bucket 88 bucket 89: 60% bucket 90: 20% bucket 89: 70% bucket 90: 30% Getting block 91 of 199 Reserving size (325) for bucket 91 Calculating Z arrays for bucket 91 bucket 89: 80% Entering block accumulator loop for bucket 91: bucket 90: 40% bucket 89: 90% bucket 90: 50% bucket 91: 10% bucket 89: 100% Sorting block of length 283 for bucket 89 (Using difference cover) bucket 90: 60% bucket 91: 20% Getting block 92 of 199 Reserving size (325) for bucket 92 Calculating Z arrays for bucket 92 bucket 90: 70% Entering block accumulator loop for bucket 92: bucket 91: 30% bucket 92: 10% bucket 90: 80% bucket 92: 20% Sorting block time: 00:00:00 bucket 91: 40% Returning block of 284 for bucket 89 bucket 90: 90% bucket 92: 30% bucket 91: 50% bucket 90: 100% Sorting block of length 288 for bucket 90 (Using difference cover) bucket 92: 40% bucket 91: 60% Getting block 93 of 199 bucket 92: 50% Reserving size (325) for bucket 93 Calculating Z arrays for bucket 93 Entering block accumulator loop for bucket 93: bucket 91: 70% bucket 92: 60% bucket 92: 70% bucket 91: 80% bucket 93: 10% bucket 92: 80% Sorting block time: 00:00:00 Returning block of 289 for bucket 90 bucket 91: 90% bucket 93: 20% bucket 92: 90% Getting block 94 of 199 Reserving size (325) for bucket 94 Calculating Z arrays for bucket 94 bucket 92: 100% bucket 91: 100% Sorting block of length 287 for bucket 92 (Using difference cover) Sorting block of length 51 for bucket 91 (Using difference cover) Entering block accumulator loop for bucket 94: bucket 93: 30% bucket 94: 10% bucket 93: 40% bucket 94: 20% bucket 93: 50% Getting block 95 of 199 Reserving size (325) for bucket 95 Calculating Z arrays for bucket 95 bucket 94: 30% bucket 93: 60% Entering block accumulator loop for bucket 95: bucket 94: 40% bucket 93: 70% Sorting block time: 00:00:00 Returning block of 288 for bucket 92 bucket 95: 10% Sorting block time: 00:00:00 Returning block of 52 for bucket 91 bucket 94: 50% bucket 93: 80% bucket 95: 20% bucket 94: 60% bucket 93: 90% Getting block 96 of 199 Reserving size (325) for bucket 96 Calculating Z arrays for bucket 96 bucket 94: 70% bucket 95: 30% bucket 93: 100% Entering block accumulator loop for bucket 96: Sorting block of length 290 for bucket 93 (Using difference cover) bucket 94: 80% bucket 95: 40% bucket 96: 10% bucket 94: 90% bucket 95: 50% bucket 94: 100% bucket 96: 20% Sorting block of length 255 for bucket 94 (Using difference cover) bucket 95: 60% bucket 96: 30% bucket 95: 70% Getting block 97 of 199 Reserving size (325) for bucket 97 Calculating Z arrays for bucket 97 Entering block accumulator loop for bucket 97: bucket 96: 40% bucket 95: 80% Sorting block time: 00:00:00 Returning block of 291 for bucket 93 bucket 97: 10% Sorting block time: 00:00:00 Returning block of 256 for bucket 94 bucket 96: 50% bucket 95: 90% bucket 97: 20% bucket 96: 60% bucket 95: 100% Sorting block of length 311 for bucket 95 (Using difference cover) bucket 97: 30% bucket 96: 70% Getting block 98 of 199 Reserving size (325) for bucket 98 Calculating Z arrays for bucket 98 bucket 97: 40% Entering block accumulator loop for bucket 98: bucket 96: 80% bucket 97: 50% bucket 96: 90% bucket 98: 10% Sorting block time: 00:00:00 Returning block of 312 for bucket 95 bucket 97: 60% bucket 96: 100% bucket 98: 20% Sorting block of length 309 for bucket 96 (Using difference cover) bucket 97: 70% Getting block 99 of 199 bucket 98: 30% Reserving size (325) for bucket 99 bucket 97: 80% Calculating Z arrays for bucket 99 Entering block accumulator loop for bucket 99: bucket 98: 40% bucket 97: 90% bucket 99: 10% bucket 98: 50% bucket 97: 100% Sorting block of length 184 for bucket 97 (Using difference cover) Sorting block time: 00:00:00 Returning block of 310 for bucket 96 bucket 98: 60% bucket 99: 20% bucket 98: 70% bucket 99: 30% bucket 98: 80% Getting block 100 of 199 bucket 99: 40% Reserving size (325) for bucket 100 Calculating Z arrays for bucket 100 bucket 98: 90% Sorting block time: 00:00:00 Returning block of 185 for bucket 97 Entering block accumulator loop for bucket 100: bucket 99: 50% bucket 98: 100% Sorting block of length 293 for bucket 98 (Using difference cover) bucket 100: 10% bucket 99: 60% bucket 100: 20% bucket 99: 70% bucket 99: 80% bucket 100: 30% Sorting block time: 00:00:00 Returning block of 294 for bucket 98 bucket 99: 90% bucket 100: 40% Getting block 101 of 199 Reserving size (325) for bucket 101 Calculating Z arrays for bucket 101 Entering block accumulator loop for bucket 101: bucket 99: 100% Sorting block of length 140 for bucket 99 (Using difference cover) bucket 100: 50% bucket 101: 10% bucket 100: 60% bucket 101: 20% bucket 100: 70% Getting block 102 of 199 Reserving size (325) for bucket 102 Calculating Z arrays for bucket 102 Sorting block time: 00:00:00 Returning block of 141 for bucket 99 Entering block accumulator loop for bucket 102: bucket 101: 30% bucket 100: 80% bucket 101: 40% bucket 100: 90% bucket 102: 10% bucket 101: 50% bucket 100: 100% Sorting block of length 246 for bucket 100 (Using difference cover) bucket 102: 20% bucket 101: 60% bucket 102: 30% Getting block 103 of 199 bucket 101: 70% Reserving size (325) for bucket 103 Calculating Z arrays for bucket 103 Entering block accumulator loop for bucket 103: bucket 102: 40% bucket 101: 80% Sorting block time: 00:00:00 Returning block of 247 for bucket 100 bucket 103: 10% bucket 102: 50% bucket 101: 90% bucket 103: 20% Getting block 104 of 199 bucket 101: 100% bucket 102: 60% Reserving size (325) for bucket 104 Sorting block of length 265 for bucket 101 (Using difference cover) bucket 103: 30% Calculating Z arrays for bucket 104 Entering block accumulator loop for bucket 104: bucket 102: 70% bucket 103: 40% bucket 104: 10% bucket 102: 80% bucket 103: 50% Getting block 105 of 199 bucket 104: 20% Reserving size (325) for bucket 105 Calculating Z arrays for bucket 105 bucket 103: 60% bucket 102: 90% Entering block accumulator loop for bucket 105: Sorting block time: 00:00:00 Returning block of 266 for bucket 101 bucket 104: 30% bucket 103: 70% bucket 105: 10% bucket 102: 100% Sorting block of length 175 for bucket 102 (Using difference cover) bucket 104: 40% bucket 103: 80% bucket 105: 20% bucket 104: 50% bucket 103: 90% bucket 105: 30% bucket 104: 60% bucket 103: 100% Sorting block time: 00:00:00 Sorting block of length 319 for bucket 103 (Using difference cover) Returning block of 176 for bucket 102 Getting block 106 of 199 bucket 105: 40% bucket 104: 70% Reserving size (325) for bucket 106 Calculating Z arrays for bucket 106 Entering block accumulator loop for bucket 106: bucket 105: 50% bucket 104: 80% bucket 106: 10% bucket 105: 60% bucket 104: 90% bucket 106: 20% Getting block 107 of 199 Reserving size (325) for bucket 107 Sorting block time: 00:00:00 Returning block of 320 for bucket 103 bucket 105: 70% Calculating Z arrays for bucket 107 bucket 106: 30% bucket 104: 100% Sorting block of length 215 for bucket 104 (Using difference cover) Entering block accumulator loop for bucket 107: bucket 105: 80% bucket 106: 40% bucket 107: 10% bucket 106: 50% bucket 105: 90% bucket 107: 20% bucket 106: 60% bucket 105: 100% Sorting block of length 283 for bucket 105 (Using difference cover) Sorting block time: 00:00:00 Returning block of 216 for bucket 104 bucket 107: 30% bucket 106: 70% Getting block 108 of 199 Reserving size (325) for bucket 108 Calculating Z arrays for bucket 108 Entering block accumulator loop for bucket 108: bucket 107: 40% bucket 106: 80% bucket 108: 10% bucket 106: 90% bucket 107: 50% bucket 108: 20% bucket 106: 100% bucket 107: 60% Sorting block of length 217 for bucket 106 (Using difference cover) Sorting block time: 00:00:00 Returning block of 284 for bucket 105 Getting block 109 of 199 bucket 108: 30% Reserving size (325) for bucket 109 bucket 107: 70% Calculating Z arrays for bucket 109 Entering block accumulator loop for bucket 109: bucket 108: 40% bucket 107: 80% bucket 109: 10% Sorting block time: 00:00:00 bucket 108: 50% Returning block of 218 for bucket 106 bucket 107: 90% bucket 109: 20% bucket 108: 60% bucket 107: 100% Sorting block of length 201 for bucket 107 (Using difference cover) Getting block 110 of 199 Reserving size (325) for bucket 110 Calculating Z arrays for bucket 110 bucket 109: 30% bucket 108: 70% Entering block accumulator loop for bucket 110: bucket 109: 40% bucket 108: 80% bucket 110: 10% bucket 109: 50% bucket 108: 90% bucket 110: 20% Sorting block time: 00:00:00 Returning block of 202 for bucket 107 bucket 109: 60% bucket 108: 100% bucket 110: 30% Sorting block of length 266 for bucket 108 (Using difference cover) bucket 109: 70% bucket 110: 40% Getting block 111 of 199 bucket 110: 50% bucket 109: 80% Reserving size (325) for bucket 111 Calculating Z arrays for bucket 111 Entering block accumulator loop for bucket 111: bucket 110: 60% Sorting block time: 00:00:00 Returning block of 267 for bucket 108 bucket 109: 90% bucket 111: 10% bucket 110: 70% bucket 109: 100% Sorting block of length 205 for bucket 109 (Using difference cover) bucket 111: 20% bucket 110: 80% bucket 111: 30% bucket 110: 90% Getting block 112 of 199 Reserving size (325) for bucket 112 Calculating Z arrays for bucket 112 bucket 111: 40% bucket 110: 100% Entering block accumulator loop for bucket 112: Sorting block of length 211 for bucket 110 (Using difference cover) Sorting block time: 00:00:00 Returning block of 206 for bucket 109 bucket 111: 50% bucket 112: 10% bucket 111: 60% bucket 112: 20% bucket 111: 70% Sorting block time: 00:00:00 Returning block of 212 for bucket 110 bucket 112: 30% bucket 111: 80% bucket 112: 40% bucket 111: 90% bucket 112: 50% bucket 111: 100% Sorting block of length 315 for bucket 111 (Using difference cover) bucket 112: 60% Getting block 113 of 199 Reserving size (325) for bucket 113 Calculating Z arrays for bucket 113 Entering block accumulator loop for bucket 113: bucket 112: 70% bucket 113: 10% bucket 112: 80% Sorting block time: 00:00:00 Returning block of 316 for bucket 111 bucket 113: 20% bucket 112: 90% bucket 113: 30% bucket 112: 100% Sorting block of length 273 for bucket 112 (Using difference cover) bucket 113: 40% bucket 113: 50% Getting block 114 of 199 Reserving size (325) for bucket 114 Calculating Z arrays for bucket 114 Entering block accumulator loop for bucket 114: bucket 113: 60% Sorting block time: 00:00:00 Returning block of 274 for bucket 112 bucket 114: 10% bucket 113: 70% bucket 114: 20% bucket 113: 80% bucket 114: 30% Getting block 115 of 199 Reserving size (325) for bucket 115 bucket 113: 90% Calculating Z arrays for bucket 115 Entering block accumulator loop for bucket 115: bucket 114: 40% bucket 113: 100% Sorting block of length 292 for bucket 113 (Using difference cover) bucket 115: 10% bucket 114: 50% bucket 115: 20% bucket 114: 60% bucket 115: 30% bucket 114: 70% Getting block 116 of 199 bucket 115: 40% Sorting block time: 00:00:00 Reserving size (325) for bucket 116 bucket 114: 80% Returning block of 293 for bucket 113 Calculating Z arrays for bucket 116 Entering block accumulator loop for bucket 116: bucket 115: 50% bucket 114: 90% bucket 115: 60% bucket 116: 10% bucket 114: 100% Sorting block of length 111 for bucket 114 (Using difference cover) bucket 115: 70% bucket 116: 20% Getting block 117 of 199 bucket 115: 80% Reserving size (325) for bucket 117 bucket 116: 30% Calculating Z arrays for bucket 117 Sorting block time: 00:00:00 Returning block of 112 for bucket 114 Entering block accumulator loop for bucket 117: bucket 115: 90% bucket 116: 40% bucket 115: 100% bucket 117: 10% Sorting block of length 220 for bucket 115 (Using difference cover) bucket 116: 50% bucket 117: 20% bucket 116: 60% Getting block 118 of 199 Reserving size (325) for bucket 118 Calculating Z arrays for bucket 118 bucket 117: 30% Entering block accumulator loop for bucket 118: bucket 116: 70% Sorting block time: 00:00:00 Returning block of 221 for bucket 115 bucket 117: 40% bucket 118: 10% bucket 116: 80% bucket 117: 50% bucket 118: 20% bucket 116: 90% bucket 117: 60% bucket 118: 30% bucket 116: 100% Sorting block of length 248 for bucket 116 (Using difference cover) Getting block 119 of 199 Reserving size (325) for bucket 119 bucket 117: 70% Calculating Z arrays for bucket 119 bucket 118: 40% Entering block accumulator loop for bucket 119: bucket 117: 80% bucket 119: 10% bucket 118: 50% bucket 119: 20% bucket 117: 90% bucket 118: 60% bucket 119: 30% Sorting block time: 00:00:00 Returning block of 249 for bucket 116 bucket 117: 100% bucket 118: 70% Sorting block of length 262 for bucket 117 (Using difference cover) bucket 119: 40% bucket 118: 80% bucket 119: 50% Getting block 120 of 199 Reserving size (325) for bucket 120 Calculating Z arrays for bucket 120 bucket 119: 60% bucket 118: 90% Entering block accumulator loop for bucket 120: bucket 119: 70% bucket 118: 100% Sorting block of length 121 for bucket 118 (Using difference cover) Sorting block time: 00:00:00 Returning block of 263 for bucket 117 bucket 120: 10% bucket 119: 80% bucket 119: 90% bucket 120: 20% bucket 119: 100% Sorting block of length 306 for bucket 119 (Using difference cover) Getting block 121 of 199 Reserving size (325) for bucket 121 Calculating Z arrays for bucket 121 bucket 120: 30% Entering block accumulator loop for bucket 121: bucket 120: 40% bucket 121: 10% bucket 120: 50% bucket 121: 20% bucket 120: 60% Sorting block time: 00:00:00 Returning block of 122 for bucket 118 bucket 121: 30% Getting block 122 of 199 Reserving size (325) for bucket 122 Sorting block time: 00:00:00 Calculating Z arrays for bucket 122 Returning block of 307 for bucket 119 bucket 120: 70% Entering block accumulator loop for bucket 122: bucket 121: 40% bucket 120: 80% bucket 122: 10% bucket 121: 50% bucket 120: 90% bucket 122: 20% bucket 121: 60% bucket 120: 100% bucket 122: 30% Sorting block of length 322 for bucket 120 (Using difference cover) Getting block 123 of 199 bucket 121: 70% Reserving size (325) for bucket 123 Calculating Z arrays for bucket 123 Entering block accumulator loop for bucket 123: bucket 122: 40% bucket 121: 80% bucket 123: 10% bucket 122: 50% bucket 121: 90% Sorting block time: 00:00:00 bucket 123: 20% Returning block of 323 for bucket 120 bucket 122: 60% bucket 121: 100% Sorting block of length 235 for bucket 121 (Using difference cover) bucket 123: 30% Getting block 124 of 199 Reserving size (325) for bucket 124 bucket 122: 70% Calculating Z arrays for bucket 124 Entering block accumulator loop for bucket 124: bucket 123: 40% bucket 122: 80% bucket 123: 50% bucket 124: 10% bucket 122: 90% Sorting block time: 00:00:00 Returning block of 236 for bucket 121 bucket 123: 60% bucket 124: 20% bucket 122: 100% Sorting block of length 298 for bucket 122 (Using difference cover) bucket 123: 70% bucket 124: 30% Getting block 125 of 199 Reserving size (325) for bucket 125 Calculating Z arrays for bucket 125 Entering block accumulator loop for bucket 125: bucket 123: 80% bucket 124: 40% bucket 125: 10% bucket 123: 90% bucket 124: 50% bucket 125: 20% bucket 123: 100% Sorting block of length 285 for bucket 123 (Using difference cover) Sorting block time: 00:00:00 Returning block of 299 for bucket 122 bucket 124: 60% bucket 125: 30% bucket 124: 70% bucket 125: 40% bucket 124: 80% bucket 125: 50% Sorting block time: 00:00:00 Returning block of 286 for bucket 123 Getting block 126 of 199 Reserving size (325) for bucket 126 Calculating Z arrays for bucket 126 bucket 125: 60% bucket 124: 90% Entering block accumulator loop for bucket 126: bucket 125: 70% bucket 124: 100% Sorting block of length 248 for bucket 124 (Using difference cover) bucket 126: 10% bucket 125: 80% bucket 126: 20% bucket 125: 90% bucket 125: 100% bucket 126: 30% Sorting block of length 310 for bucket 125 Sorting block time: 00:00:00 (Using difference cover) Returning block of 249 for bucket 124 Getting block 127 of 199 Reserving size (325) for bucket 127 Calculating Z arrays for bucket 127 bucket 126: 40% Entering block accumulator loop for bucket 127: bucket 126: 50% bucket 127: 10% bucket 126: 60% Sorting block time: 00:00:00 Returning block of 311 for bucket 125 bucket 127: 20% bucket 126: 70% bucket 127: 30% bucket 126: 80% Getting block 128 of 199 Reserving size (325) for bucket 128 Calculating Z arrays for bucket 128 bucket 127: 40% Entering block accumulator loop for bucket 128: bucket 126: 90% bucket 127: 50% bucket 126: 100% Sorting block of length 183 for bucket 126 (Using difference cover) bucket 128: 10% bucket 127: 60% Getting block 129 of 199 bucket 128: 20% bucket 127: 70% Reserving size (325) for bucket 129 Calculating Z arrays for bucket 129 Entering block accumulator loop for bucket 129: bucket 127: 80% bucket 128: 30% Sorting block time: 00:00:00 Returning block of 184 for bucket 126 bucket 127: 90% bucket 129: 10% bucket 128: 40% bucket 127: 100% bucket 129: 20% Sorting block of length 294 for bucket 127 (Using difference cover) bucket 128: 50% Getting block 130 of 199 Reserving size (325) for bucket 130 Calculating Z arrays for bucket 130 bucket 129: 30% Entering block accumulator loop for bucket 130: bucket 128: 60% bucket 129: 40% bucket 130: 10% bucket 128: 70% bucket 129: 50% Sorting block time: 00:00:00 bucket 130: 20% Returning block of 295 for bucket 127 bucket 128: 80% bucket 129: 60% bucket 130: 30% Getting block 131 of 199 Reserving size (325) for bucket 131 Calculating Z arrays for bucket 131 bucket 129: 70% bucket 128: 90% Entering block accumulator loop for bucket 131: bucket 130: 40% bucket 129: 80% bucket 128: 100% Sorting block of length 212 for bucket 128 (Using difference cover) bucket 131: 10% bucket 130: 50% bucket 129: 90% bucket 131: 20% bucket 130: 60% bucket 129: 100% Sorting block of length 275 for bucket 129 (Using difference cover) Getting block 132 of 199 Reserving size (325) for bucket 132 Calculating Z arrays for bucket 132 bucket 131: 30% bucket 130: 70% Entering block accumulator loop for bucket 132: bucket 131: 40% bucket 130: 80% bucket 132: 10% Sorting block time: 00:00:00 bucket 131: 50% Returning block of 213 for bucket 128 bucket 130: 90% bucket 132: 20% Sorting block time: 00:00:00 Returning block of 276 for bucket 129 bucket 131: 60% bucket 130: 100% Sorting block of length 280 for bucket 130 (Using difference cover) bucket 132: 30% Getting block 133 of 199 bucket 131: 70% Reserving size (325) for bucket 133 Calculating Z arrays for bucket 133 Entering block accumulator loop for bucket 133: bucket 132: 40% bucket 131: 80% bucket 133: 10% bucket 132: 50% bucket 131: 90% bucket 133: 20% Sorting block time: 00:00:00 Returning block of 281 for bucket 130 bucket 132: 60% bucket 131: 100% Sorting block of length 287 for bucket 131 (Using difference cover) bucket 133: 30% Getting block 134 of 199 Reserving size (325) for bucket 134 bucket 132: 70% Calculating Z arrays for bucket 134 Entering block accumulator loop for bucket 134: bucket 133: 40% bucket 132: 80% bucket 133: 50% bucket 134: 10% bucket 132: 90% bucket 133: 60% Sorting block time: 00:00:00 Returning block of 288 for bucket 131 bucket 134: 20% bucket 132: 100% Sorting block of length 295 for bucket 132 (Using difference cover) bucket 133: 70% Getting block 135 of 199 bucket 134: 30% Reserving size (325) for bucket 135 bucket 133: 80% Calculating Z arrays for bucket 135 Entering block accumulator loop for bucket 135: bucket 134: 40% bucket 133: 90% bucket 135: 10% bucket 133: 100% bucket 134: 50% Sorting block of length 263 for bucket 133 (Using difference cover) Sorting block time: 00:00:00 Returning block of 296 for bucket 132 bucket 135: 20% Getting block 136 of 199 Reserving size (325) for bucket 136 bucket 134: 60% Calculating Z arrays for bucket 136 Entering block accumulator loop for bucket 136: bucket 135: 30% bucket 134: 70% bucket 136: 10% bucket 135: 40% bucket 134: 80% Sorting block time: 00:00:00 Returning block of 264 for bucket 133 bucket 136: 20% bucket 135: 50% bucket 134: 90% Getting block 137 of 199 Reserving size (325) for bucket 137 Calculating Z arrays for bucket 137 bucket 136: 30% bucket 135: 60% Entering block accumulator loop for bucket 137: bucket 134: 100% Sorting block of length 298 for bucket 134 (Using difference cover) bucket 136: 40% bucket 135: 70% bucket 137: 10% bucket 136: 50% bucket 135: 80% bucket 137: 20% bucket 136: 60% bucket 137: 30% bucket 135: 90% Sorting block time: 00:00:00 Returning block of 299 for bucket 134 bucket 136: 70% bucket 137: 40% bucket 135: 100% Sorting block of length 297 for bucket 135 (Using difference cover) bucket 136: 80% bucket 137: 50% Getting block 138 of 199 bucket 137: 60% Reserving size (325) for bucket 138 bucket 136: 90% Calculating Z arrays for bucket 138 Entering block accumulator loop for bucket 138: bucket 137: 70% bucket 136: 100% Sorting block of length 324 for bucket 136 (Using difference cover) bucket 138: 10% bucket 137: 80% bucket 137: 90% bucket 138: 20% bucket 137: 100% Sorting block of length 131 for bucket 137 (Using difference cover) bucket 138: 30% Sorting block time: 00:00:00 Returning block of 298 for bucket 135 bucket 138: 40% Getting block 139 of 199 Reserving size (325) for bucket 139 Calculating Z arrays for bucket 139 Entering block accumulator loop for bucket 139: bucket 138: 50% Sorting block time: 00:00:00 Returning block of 325 for bucket 136 bucket 139: 10% bucket 138: 60% Sorting block time: 00:00:00 Returning block of 132 for bucket 137 bucket 139: 20% bucket 138: 70% Getting block 140 of 199 Reserving size (325) for bucket 140 Calculating Z arrays for bucket 140 bucket 139: 30% bucket 138: 80% Entering block accumulator loop for bucket 140: bucket 139: 40% bucket 138: 90% bucket 140: 10% bucket 139: 50% bucket 138: 100% Sorting block of length 311 for bucket 138 (Using difference cover) bucket 140: 20% bucket 139: 60% bucket 140: 30% bucket 139: 70% bucket 140: 40% bucket 139: 80% Getting block 141 of 199 Reserving size (325) for bucket 141 Calculating Z arrays for bucket 141 bucket 140: 50% Sorting block time: 00:00:00 bucket 139: 90% Returning block of 312 for bucket 138 Entering block accumulator loop for bucket 141: bucket 140: 60% bucket 139: 100% Sorting block of length 285 for bucket 139 (Using difference cover) bucket 141: 10% bucket 140: 70% bucket 141: 20% bucket 140: 80% bucket 141: 30% Sorting block time: 00:00:00 Returning block of 286 for bucket 139 bucket 140: 90% bucket 141: 40% bucket 140: 100% Sorting block of length 208 for bucket 140 (Using difference cover) bucket 141: 50% bucket 141: 60% bucket 141: 70% Sorting block time: 00:00:00 Returning block of 209 for bucket 140 bucket 141: 80% bucket 141: 90% bucket 141: 100% Sorting block of length 258 for bucket 141 (Using difference cover) Sorting block time: 00:00:00 Returning block of 259 for bucket 141 Getting block 142 of 199 Reserving size (325) for bucket 142 Calculating Z arrays for bucket 142 Entering block accumulator loop for bucket 142: bucket 142: 10% bucket 142: 20% bucket 142: 30% Getting block 143 of 199 Reserving size (325) for bucket 143 Calculating Z arrays for bucket 143 bucket 142: 40% Entering block accumulator loop for bucket 143: bucket 142: 50% bucket 143: 10% bucket 142: 60% bucket 143: 20% bucket 142: 70% bucket 143: 30% bucket 142: 80% Getting block 144 of 199 bucket 143: 40% Reserving size (325) for bucket 144 Calculating Z arrays for bucket 144 Entering block accumulator loop for bucket 144: bucket 142: 90% bucket 143: 50% bucket 144: 10% bucket 142: 100% Sorting block of length 313 for bucket 142 (Using difference cover) bucket 143: 60% bucket 144: 20% bucket 143: 70% Getting block 145 of 199 Reserving size (325) for bucket 145 Calculating Z arrays for bucket 145 bucket 144: 30% bucket 143: 80% Entering block accumulator loop for bucket 145: Sorting block time: 00:00:00 Returning block of 314 for bucket 142 bucket 144: 40% bucket 143: 90% bucket 145: 10% bucket 144: 50% bucket 143: 100% Sorting block of length 300 for bucket 143 (Using difference cover) Getting block 146 of 199 bucket 145: 20% Reserving size (325) for bucket 146 Calculating Z arrays for bucket 146 bucket 144: 60% Entering block accumulator loop for bucket 146: bucket 145: 30% bucket 144: 70% bucket 146: 10% bucket 145: 40% Sorting block time: 00:00:00 Returning block of 301 for bucket 143 bucket 144: 80% bucket 146: 20% bucket 145: 50% bucket 144: 90% Getting block 147 of 199 Reserving size (325) for bucket 147 bucket 146: 30% Calculating Z arrays for bucket 147 bucket 145: 60% Entering block accumulator loop for bucket 147: bucket 144: 100% Sorting block of length 225 for bucket 144 (Using difference cover) bucket 146: 40% bucket 145: 70% bucket 147: 10% bucket 146: 50% bucket 145: 80% bucket 147: 20% bucket 146: 60% Sorting block time: 00:00:00 Getting block 148 of 199 Returning block of 226 for bucket 144 Reserving size (325) for bucket 148 bucket 145: 90% Calculating Z arrays for bucket 148 bucket 147: 30% Entering block accumulator loop for bucket 148: bucket 146: 70% bucket 145: 100% bucket 148: 10% Sorting block of length 241 for bucket 145 (Using difference cover) bucket 147: 40% bucket 146: 80% bucket 148: 20% bucket 147: 50% bucket 146: 90% bucket 148: 30% bucket 148: 40% bucket 147: 60% bucket 146: 100% Sorting block time: 00:00:00 Sorting block of length 251 for bucket 146 (Using difference cover) Returning block of 242 for bucket 145 Getting block 149 of 199 bucket 148: 50% Reserving size (325) for bucket 149 Calculating Z arrays for bucket 149 bucket 147: 70% Entering block accumulator loop for bucket 149: bucket 148: 60% bucket 147: 80% bucket 148: 70% bucket 149: 10% bucket 148: 80% bucket 147: 90% Sorting block time: 00:00:00 Getting block 150 of 199 Returning block of 252 for bucket 146 Reserving size (325) for bucket 150 bucket 149: 20% Calculating Z arrays for bucket 150 bucket 148: 90% Entering block accumulator loop for bucket 150: bucket 147: 100% Sorting block of length 165 for bucket 147 (Using difference cover) bucket 148: 100% Sorting block of length 285 for bucket 148 (Using difference cover) bucket 149: 30% bucket 150: 10% bucket 150: 20% bucket 149: 40% bucket 150: 30% Getting block 151 of 199 Reserving size (325) for bucket 151 Calculating Z arrays for bucket 151 bucket 149: 50% bucket 150: 40% Entering block accumulator loop for bucket 151: bucket 150: 50% bucket 151: 10% bucket 149: 60% Sorting block time: 00:00:00 Returning block of 166 for bucket 147 bucket 150: 60% bucket 151: 20% Sorting block time: 00:00:00 Returning block of 286 for bucket 148 bucket 149: 70% bucket 150: 70% bucket 151: 30% Getting block 152 of 199 Reserving size (325) for bucket 152 bucket 150: 80% Calculating Z arrays for bucket 152 bucket 149: 80% bucket 151: 40% Entering block accumulator loop for bucket 152: bucket 150: 90% bucket 151: 50% bucket 149: 90% bucket 152: 10% bucket 150: 100% Sorting block of length 214 for bucket 150 (Using difference cover) bucket 151: 60% bucket 149: 100% Sorting block of length 314 for bucket 149 (Using difference cover) bucket 152: 20% bucket 151: 70% Getting block 153 of 199 Reserving size (325) for bucket 153 bucket 152: 30% Calculating Z arrays for bucket 153 bucket 151: 80% Entering block accumulator loop for bucket 153: bucket 152: 40% bucket 151: 90% bucket 153: 10% Sorting block time: 00:00:00 Returning block of 215 for bucket 150 bucket 151: 100% bucket 152: 50% Sorting block of length 111 for bucket 151 (Using difference cover) bucket 153: 20% Sorting block time: 00:00:00 Returning block of 315 for bucket 149 bucket 152: 60% bucket 153: 30% bucket 152: 70% Getting block 154 of 199 bucket 153: 40% Reserving size (325) for bucket 154 Calculating Z arrays for bucket 154 Entering block accumulator loop for bucket 154: bucket 152: 80% Sorting block time: 00:00:00 Returning block of 112 for bucket 151 bucket 153: 50% bucket 154: 10% bucket 152: 90% bucket 153: 60% bucket 154: 20% bucket 152: 100% Sorting block of length 258 for bucket 152 (Using difference cover) bucket 153: 70% bucket 154: 30% Getting block 155 of 199 Reserving size (325) for bucket 155 Calculating Z arrays for bucket 155 bucket 153: 80% Entering block accumulator loop for bucket 155: bucket 154: 40% bucket 153: 90% bucket 155: 10% bucket 154: 50% Sorting block time: 00:00:00 Returning block of 259 for bucket 152 bucket 153: 100% bucket 155: 20% Sorting block of length 180 for bucket 153 (Using difference cover) bucket 154: 60% bucket 155: 30% bucket 154: 70% bucket 155: 40% Getting block 156 of 199 Reserving size (325) for bucket 156 Calculating Z arrays for bucket 156 bucket 154: 80% Sorting block time: 00:00:00 Returning block of 181 for bucket 153 Entering block accumulator loop for bucket 156: bucket 155: 50% bucket 154: 90% bucket 156: 10% bucket 155: 60% bucket 154: 100% Sorting block of length 191 for bucket 154 (Using difference cover) bucket 156: 20% bucket 155: 70% Getting block 157 of 199 bucket 156: 30% Reserving size (325) for bucket 157 bucket 155: 80% Calculating Z arrays for bucket 157 Entering block accumulator loop for bucket 157: bucket 156: 40% Sorting block time: 00:00:00 Returning block of 192 for bucket 154 bucket 155: 90% bucket 157: 10% bucket 156: 50% bucket 155: 100% Sorting block of length 44 for bucket 155 (Using difference cover) bucket 157: 20% bucket 156: 60% Getting block 158 of 199 Reserving size (325) for bucket 158 Calculating Z arrays for bucket 158 bucket 157: 30% Entering block accumulator loop for bucket 158: bucket 156: 70% bucket 157: 40% Sorting block time: 00:00:00 bucket 156: 80% bucket 158: 10% Returning block of 45 for bucket 155 bucket 157: 50% bucket 156: 90% bucket 158: 20% bucket 157: 60% bucket 156: 100% Sorting block of length 306 for bucket 156 (Using difference cover) Getting block 159 of 199 bucket 158: 30% Reserving size (325) for bucket 159 Calculating Z arrays for bucket 159 bucket 157: 70% Entering block accumulator loop for bucket 159: bucket 158: 40% bucket 157: 80% bucket 159: 10% bucket 158: 50% bucket 157: 90% Sorting block time: 00:00:00 bucket 159: 20% Returning block of 307 for bucket 156 Getting block 160 of 199 bucket 158: 60% Reserving size (325) for bucket 160 Calculating Z arrays for bucket 160 bucket 157: 100% Sorting block of length 261 for bucket 157 (Using difference cover) bucket 159: 30% Entering block accumulator loop for bucket 160: bucket 158: 70% bucket 159: 40% bucket 160: 10% bucket 158: 80% Getting block 161 of 199 bucket 160: 20% bucket 159: 50% Sorting block time: 00:00:00 Reserving size (325) for bucket 161 Returning block of 262 for bucket 157 bucket 158: 90% Calculating Z arrays for bucket 161 Entering block accumulator loop for bucket 161: bucket 160: 30% bucket 159: 60% bucket 158: 100% Sorting block of length 274 for bucket 158 (Using difference cover) bucket 161: 10% bucket 160: 40% bucket 159: 70% bucket 161: 20% bucket 160: 50% bucket 159: 80% bucket 161: 30% bucket 160: 60% bucket 161: 40% bucket 159: 90% Sorting block time: 00:00:00 Returning block of 275 for bucket 158 bucket 160: 70% bucket 161: 50% Getting block 162 of 199 Reserving size (325) for bucket 162 Calculating Z arrays for bucket 162 bucket 159: 100% Sorting block of length 302 for bucket 159 (Using difference cover) Entering block accumulator loop for bucket 162: bucket 161: 60% bucket 160: 80% bucket 161: 70% bucket 160: 90% bucket 162: 10% bucket 161: 80% Getting block 163 of 199 Reserving size (325) for bucket 163 Calculating Z arrays for bucket 163 bucket 160: 100% Sorting block of length 88 for bucket 160 (Using difference cover) bucket 161: 90% bucket 162: 20% Entering block accumulator loop for bucket 163: bucket 161: 100% Sorting block of length 244 for bucket 161 (Using difference cover) bucket 162: 30% bucket 163: 10% bucket 162: 40% bucket 163: 20% Sorting block time: 00:00:00 Returning block of 303 for bucket 159 Getting block 164 of 199 bucket 162: 50% Reserving size (325) for bucket 164 bucket 163: 30% Calculating Z arrays for bucket 164 Entering block accumulator loop for bucket 164: bucket 162: 60% bucket 163: 40% bucket 164: 10% Sorting block time: 00:00:00 Returning block of 89 for bucket 160 bucket 162: 70% bucket 163: 50% Sorting block time: 00:00:00 Returning block of 245 for bucket 161 bucket 164: 20% bucket 162: 80% bucket 163: 60% Getting block 165 of 199 bucket 164: 30% Reserving size (325) for bucket 165 Calculating Z arrays for bucket 165 Entering block accumulator loop for bucket 165: bucket 162: 90% bucket 163: 70% bucket 164: 40% bucket 165: 10% bucket 162: 100% Sorting block of length 126 for bucket 162 (Using difference cover) bucket 163: 80% bucket 164: 50% Getting block 166 of 199 Reserving size (325) for bucket 166 bucket 165: 20% Calculating Z arrays for bucket 166 Entering block accumulator loop for bucket 166: bucket 163: 90% bucket 164: 60% bucket 165: 30% bucket 166: 10% bucket 163: 100% bucket 164: 70% Sorting block of length 264 for bucket 163 (Using difference cover) bucket 165: 40% bucket 166: 20% bucket 164: 80% bucket 165: 50% bucket 166: 30% bucket 164: 90% Getting block 167 of 199 Reserving size (325) for bucket 167 bucket 165: 60% Calculating Z arrays for bucket 167 Entering block accumulator loop for bucket 167: bucket 166: 40% bucket 164: 100% Sorting block of length 67 for bucket 164 (Using difference cover) Sorting block time: 00:00:00 bucket 165: 70% Returning block of 127 for bucket 162 bucket 167: 10% bucket 166: 50% bucket 165: 80% bucket 167: 20% bucket 166: 60% Getting block 168 of 199 bucket 167: 30% Reserving size (325) for bucket 168 bucket 165: 90% Sorting block time: 00:00:00 Calculating Z arrays for bucket 168 Returning block of 265 for bucket 163 bucket 166: 70% bucket 167: 40% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 168: Returning block of 68 for bucket 164 bucket 165: 100% Sorting block of length 283 for bucket 165 (Using difference cover) bucket 167: 50% bucket 166: 80% bucket 167: 60% bucket 168: 10% Getting block 169 of 199 bucket 166: 90% Reserving size (325) for bucket 169 bucket 167: 70% Calculating Z arrays for bucket 169 bucket 168: 20% Entering block accumulator loop for bucket 169: bucket 167: 80% bucket 166: 100% Sorting block of length 238 for bucket 166 (Using difference cover) bucket 167: 90% bucket 168: 30% bucket 169: 10% bucket 167: 100% Sorting block of length 220 for bucket 167 (Using difference cover) bucket 168: 40% Getting block 170 of 199 bucket 169: 20% Reserving size (325) for bucket 170 Calculating Z arrays for bucket 170 Entering block accumulator loop for bucket 170: bucket 168: 50% Sorting block time: 00:00:00 Returning block of 284 for bucket 165 bucket 169: 30% bucket 170: 10% bucket 168: 60% bucket 169: 40% bucket 170: 20% bucket 168: 70% bucket 169: 50% Sorting block time: 00:00:00 Returning block of 239 for bucket 166 bucket 170: 30% Getting block 171 of 199 Sorting block time: 00:00:00 bucket 168: 80% Reserving size (325) for bucket 171 Returning block of 221 for bucket 167 bucket 169: 60% Calculating Z arrays for bucket 171 bucket 170: 40% Entering block accumulator loop for bucket 171: bucket 168: 90% bucket 169: 70% bucket 171: 10% bucket 170: 50% bucket 168: 100% Sorting block of length 186 for bucket 168 (Using difference cover) bucket 169: 80% bucket 171: 20% bucket 170: 60% bucket 171: 30% bucket 169: 90% bucket 170: 70% bucket 171: 40% bucket 169: 100% Sorting block of length 317 for bucket 169 (Using difference cover) Getting block 172 of 199 Reserving size (325) for bucket 172 bucket 170: 80% Calculating Z arrays for bucket 172 bucket 171: 50% Entering block accumulator loop for bucket 172: bucket 171: 60% bucket 170: 90% bucket 172: 10% bucket 171: 70% bucket 170: 100% Sorting block of length 115 for bucket 170 (Using difference cover) bucket 172: 20% Sorting block time: 00:00:00 Returning block of 187 for bucket 168 bucket 171: 80% bucket 172: 30% Getting block 173 of 199 Reserving size (325) for bucket 173 Calculating Z arrays for bucket 173 bucket 171: 90% Entering block accumulator loop for bucket 173: bucket 172: 40% bucket 171: 100% Sorting block of length 317 for bucket 171 (Using difference cover) bucket 173: 10% Sorting block time: 00:00:00 Returning block of 318 for bucket 169 bucket 172: 50% Getting block 174 of 199 bucket 173: 20% Reserving size (325) for bucket 174 Calculating Z arrays for bucket 174 bucket 172: 60% Entering block accumulator loop for bucket 174: bucket 173: 30% bucket 172: 70% Sorting block time: 00:00:00 Returning block of 116 for bucket 170 bucket 174: 10% bucket 173: 40% Sorting block time: 00:00:00 bucket 172: 80% Returning block of 318 for bucket 171 bucket 174: 20% bucket 173: 50% bucket 172: 90% bucket 174: 30% bucket 173: 60% bucket 172: 100% Getting block 175 of 199 Sorting block of length 62 for bucket 172 (Using difference cover) Reserving size (325) for bucket 175 bucket 174: 40% Calculating Z arrays for bucket 175 bucket 173: 70% Entering block accumulator loop for bucket 175: bucket 174: 50% bucket 173: 80% bucket 175: 10% bucket 174: 60% Getting block 176 of 199 bucket 173: 90% Reserving size (325) for bucket 176 bucket 175: 20% Sorting block time: 00:00:00 Calculating Z arrays for bucket 176 Returning block of 63 for bucket 172 bucket 174: 70% Entering block accumulator loop for bucket 176: bucket 173: 100% Sorting block of length 320 for bucket 173 (Using difference cover) bucket 175: 30% bucket 176: 10% bucket 174: 80% bucket 175: 40% bucket 176: 20% bucket 174: 90% bucket 176: 30% bucket 175: 50% Getting block 177 of 199 bucket 174: 100% Sorting block time: 00:00:00 Reserving size (325) for bucket 177 Sorting block of length 232 for bucket 174 (Using difference cover) Returning block of 321 for bucket 173 Calculating Z arrays for bucket 177 bucket 176: 40% bucket 175: 60% Entering block accumulator loop for bucket 177: bucket 176: 50% bucket 175: 70% bucket 177: 10% bucket 176: 60% bucket 175: 80% bucket 177: 20% bucket 176: 70% Sorting block time: 00:00:00 Returning block of 233 for bucket 174 Getting block 178 of 199 Reserving size (325) for bucket 178 Calculating Z arrays for bucket 178 bucket 175: 90% bucket 177: 30% bucket 176: 80% Entering block accumulator loop for bucket 178: bucket 175: 100% bucket 176: 90% Sorting block of length 295 for bucket 175 (Using difference cover) bucket 177: 40% bucket 178: 10% bucket 176: 100% Sorting block of length 317 for bucket 176 (Using difference cover) bucket 177: 50% bucket 178: 20% Getting block 179 of 199 Reserving size (325) for bucket 179 Calculating Z arrays for bucket 179 Entering block accumulator loop for bucket 179: bucket 177: 60% bucket 178: 30% bucket 179: 10% bucket 178: 40% bucket 177: 70% bucket 179: 20% Sorting block time: 00:00:00 Returning block of 296 for bucket 175 bucket 179: 30% bucket 178: 50% bucket 177: 80% Sorting block time: 00:00:00 Returning block of 318 for bucket 176 bucket 179: 40% bucket 178: 60% bucket 177: 90% bucket 179: 50% bucket 178: 70% bucket 179: 60% bucket 177: 100% Sorting block of length 216 for bucket 177 (Using difference cover) Getting block 180 of 199 Reserving size (325) for bucket 180 Calculating Z arrays for bucket 180 Entering block accumulator loop for bucket 180: bucket 179: 70% bucket 178: 80% bucket 180: 10% bucket 179: 80% bucket 178: 90% bucket 180: 20% bucket 179: 90% bucket 178: 100% bucket 180: 30% Sorting block of length 269 for bucket 178 (Using difference cover) bucket 179: 100% Sorting block of length 232 for bucket 179 (Using difference cover) bucket 180: 40% Sorting block time: 00:00:00 Returning block of 217 for bucket 177 Getting block 181 of 199 Reserving size (325) for bucket 181 Calculating Z arrays for bucket 181 bucket 180: 50% Entering block accumulator loop for bucket 181: bucket 180: 60% bucket 181: 10% bucket 180: 70% bucket 180: 80% bucket 181: 20% bucket 180: 90% Getting block 182 of 199 Reserving size (325) for bucket 182 Calculating Z arrays for bucket 182 bucket 181: 30% bucket 180: 100% Entering block accumulator loop for bucket 182: Sorting block of length 304 for bucket 180 (Using difference cover) Sorting block time: 00:00:00 Returning block of 270 for bucket 178 bucket 181: 40% bucket 182: 10% bucket 181: 50% bucket 182: 20% bucket 182: 30% bucket 181: 60% Sorting block time: 00:00:00 Returning block of 233 for bucket 179 Getting block 183 of 199 bucket 182: 40% Sorting block time: 00:00:00 Reserving size (325) for bucket 183 Returning block of 305 for bucket 180 Calculating Z arrays for bucket 183 bucket 181: 70% Entering block accumulator loop for bucket 183: bucket 182: 50% bucket 181: 80% bucket 182: 60% bucket 183: 10% bucket 181: 90% bucket 182: 70% bucket 183: 20% Getting block 184 of 199 bucket 181: 100% Reserving size (325) for bucket 184 bucket 182: 80% Sorting block of length 244 for bucket 181 (Using difference cover) Calculating Z arrays for bucket 184 bucket 183: 30% Entering block accumulator loop for bucket 184: bucket 182: 90% bucket 183: 40% bucket 182: 100% bucket 184: 10% Sorting block of length 243 for bucket 182 (Using difference cover) bucket 183: 50% bucket 184: 20% Getting block 185 of 199 bucket 183: 60% Reserving size (325) for bucket 185 Calculating Z arrays for bucket 185 bucket 184: 30% Entering block accumulator loop for bucket 185: bucket 183: 70% bucket 184: 40% Sorting block time: 00:00:00 Returning block of 245 for bucket 181 bucket 185: 10% bucket 183: 80% Sorting block time: 00:00:00 Returning block of 244 for bucket 182 bucket 184: 50% bucket 185: 20% bucket 183: 90% Getting block 186 of 199 Reserving size (325) for bucket 186 bucket 184: 60% Calculating Z arrays for bucket 186 bucket 185: 30% Entering block accumulator loop for bucket 186: bucket 183: 100% Sorting block of length 110 for bucket 183 (Using difference cover) bucket 184: 70% bucket 185: 40% bucket 186: 10% bucket 184: 80% bucket 185: 50% bucket 186: 20% bucket 184: 90% bucket 185: 60% Getting block 187 of 199 bucket 186: 30% Sorting block time: 00:00:00 Reserving size (325) for bucket 187 Returning block of 111 for bucket 183 Calculating Z arrays for bucket 187 bucket 184: 100% bucket 185: 70% Sorting block of length 299 for bucket 184 (Using difference cover) Entering block accumulator loop for bucket 187: bucket 186: 40% bucket 185: 80% bucket 186: 50% bucket 187: 10% bucket 185: 90% bucket 186: 60% bucket 187: 20% Getting block 188 of 199 Sorting block time: 00:00:00 Returning block of 300 for bucket 184 Reserving size (325) for bucket 188 bucket 185: 100% Calculating Z arrays for bucket 188 Sorting block of length 173 for bucket 185 (Using difference cover) bucket 186: 70% bucket 187: 30% Entering block accumulator loop for bucket 188: bucket 186: 80% bucket 187: 40% bucket 188: 10% bucket 186: 90% bucket 187: 50% bucket 188: 20% Sorting block time: 00:00:00 Returning block of 174 for bucket 185 Getting block 189 of 199 Reserving size (325) for bucket 189 Calculating Z arrays for bucket 189 bucket 186: 100% bucket 187: 60% Sorting block of length 196 for bucket 186 (Using difference cover) bucket 188: 30% Entering block accumulator loop for bucket 189: bucket 187: 70% bucket 188: 40% bucket 189: 10% bucket 187: 80% bucket 188: 50% bucket 189: 20% Sorting block time: 00:00:00 Returning block of 197 for bucket 186 Getting block 190 of 199 bucket 187: 90% Reserving size (325) for bucket 190 bucket 188: 60% Calculating Z arrays for bucket 190 bucket 189: 30% Entering block accumulator loop for bucket 190: bucket 187: 100% Sorting block of length 177 for bucket 187 (Using difference cover) bucket 188: 70% bucket 189: 40% bucket 190: 10% bucket 188: 80% Getting block 191 of 199 bucket 189: 50% Reserving size (325) for bucket 191 bucket 190: 20% Calculating Z arrays for bucket 191 Entering block accumulator loop for bucket 191: bucket 188: 90% Sorting block time: 00:00:00 Returning block of 178 for bucket 187 bucket 189: 60% bucket 190: 30% bucket 191: 10% bucket 188: 100% Sorting block of length 187 for bucket 188 (Using difference cover) bucket 191: 20% bucket 189: 70% bucket 190: 40% bucket 191: 30% bucket 189: 80% bucket 190: 50% Getting block 192 of 199 bucket 191: 40% Reserving size (325) for bucket 192 Calculating Z arrays for bucket 192 Entering block accumulator loop for bucket 192: bucket 189: 90% bucket 191: 50% bucket 190: 60% Sorting block time: 00:00:00 Returning block of 188 for bucket 188 bucket 191: 60% bucket 189: 100% bucket 192: 10% Sorting block of length 280 for bucket 189 (Using difference cover) bucket 190: 70% bucket 191: 70% bucket 192: 20% bucket 191: 80% bucket 190: 80% Getting block 193 of 199 Reserving size (325) for bucket 193 Calculating Z arrays for bucket 193 bucket 191: 90% bucket 192: 30% Entering block accumulator loop for bucket 193: bucket 190: 90% bucket 191: 100% Sorting block of length 324 for bucket 191 (Using difference cover) bucket 192: 40% bucket 193: 10% bucket 190: 100% Sorting block of length 260 for bucket 190 (Using difference cover) bucket 192: 50% bucket 193: 20% Getting block 194 of 199 Reserving size (325) for bucket 194 bucket 193: 30% Calculating Z arrays for bucket 194 bucket 192: 60% Entering block accumulator loop for bucket 194: Sorting block time: 00:00:00 Returning block of 281 for bucket 189 bucket 193: 40% bucket 192: 70% bucket 194: 10% bucket 193: 50% bucket 192: 80% bucket 194: 20% bucket 193: 60% bucket 192: 90% Sorting block time: 00:00:00 bucket 194: 30% Returning block of 325 for bucket 191 bucket 193: 70% Sorting block time: 00:00:00 Returning block of 261 for bucket 190 Getting block 195 of 199 bucket 192: 100% bucket 194: 40% Reserving size (325) for bucket 195 Sorting block of length 311 for bucket 192 Calculating Z arrays for bucket 195 (Using difference cover) bucket 193: 80% Entering block accumulator loop for bucket 195: bucket 194: 50% bucket 195: 10% bucket 193: 90% bucket 194: 60% bucket 195: 20% bucket 193: 100% Sorting block of length 89 for bucket 193 (Using difference cover) bucket 195: 30% Getting block 196 of 199 bucket 194: 70% Reserving size (325) for bucket 196 Calculating Z arrays for bucket 196 bucket 195: 40% Entering block accumulator loop for bucket 196: bucket 194: 80% bucket 195: 50% Sorting block time: 00:00:00 Returning block of 312 for bucket 192 bucket 196: 10% bucket 195: 60% bucket 194: 90% Sorting block time: 00:00:00 Returning block of 90 for bucket 193 bucket 195: 70% bucket 196: 20% bucket 194: 100% Sorting block of length 268 for bucket 194 (Using difference cover) bucket 195: 80% Getting block 197 of 199 Reserving size (325) for bucket 197 bucket 196: 30% Calculating Z arrays for bucket 197 bucket 195: 90% Entering block accumulator loop for bucket 197: bucket 195: 100% bucket 196: 40% Sorting block of length 213 for bucket 195 (Using difference cover) bucket 197: 10% bucket 196: 50% bucket 197: 20% bucket 196: 60% Getting block 198 of 199 bucket 197: 30% Reserving size (325) for bucket 198 Calculating Z arrays for bucket 198 bucket 196: 70% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 198: Returning block of 269 for bucket 194 Sorting block time: 00:00:00 Returning block of 214 for bucket 195 bucket 197: 40% bucket 196: 80% bucket 198: 10% bucket 197: 50% bucket 196: 90% bucket 198: 20% bucket 197: 60% bucket 196: 100% Sorting block of length 270 for bucket 196 (Using difference cover) Getting block 199 of 199 Reserving size (325) for bucket 199 Calculating Z arrays for bucket 199 bucket 198: 30% Entering block accumulator loop for bucket 199: bucket 197: 70% bucket 199: 10% bucket 198: 40% bucket 197: 80% bucket 199: 20% Sorting block time: 00:00:00 Returning block of 271 for bucket 196 bucket 198: 50% bucket 199: 30% bucket 197: 90% bucket 199: 40% bucket 198: 60% bucket 197: 100% Sorting block of length 297 for bucket 197 (Using difference cover) bucket 199: 50% bucket 198: 70% bucket 199: 60% bucket 198: 80% bucket 199: 70% bucket 199: 80% bucket 198: 90% Sorting block time: 00:00:00 Returning block of 298 for bucket 197 bucket 199: 90% bucket 198: 100% Sorting block of length 31 for bucket 198 (Using difference cover) bucket 199: 100% Sorting block of length 314 for bucket 199 (Using difference cover) Sorting block time: 00:00:00 Returning block of 32 for bucket 198 Sorting block time: 00:00:00 Returning block of 315 for bucket 199 Exited Ebwt loop fchr[A]: 0 fchr[C]: 12334 fchr[G]: 12334 fchr[T]: 25154 fchr[$]: 48502 Exiting Ebwt::buildToDisk() Returning from initFromVector Wrote 4210679 bytes to primary EBWT file: BS_CT.1.bt2 Wrote 12132 bytes to secondary EBWT file: BS_CT.2.bt2 Re-opening _in1 and _in2 as input streams Returning from Ebwt constructor Headers: len: 48502 bwtLen: 48503 sz: 12126 bwtSz: 12126 lineRate: 6 offRate: 4 offMask: 0xfffffff0 ftabChars: 10 eftabLen: 20 eftabSz: 80 ftabLen: 1048577 ftabSz: 4194308 offsLen: 3032 offsSz: 12128 lineSz: 64 sideSz: 64 sideBwtSz: 48 sideBwtLen: 192 numSides: 253 numLines: 253 ebwtTotLen: 16192 ebwtTotSz: 16192 color: 0 reverse: 0 Total time for call to driver() for forward index: 00:00:00 Reading reference sizes Time reading reference sizes: 00:00:00 Calculating joined length Writing header Reserving space for joined string Joining reference sequences Time to join reference sequences: 00:00:00 Time to reverse reference sequence: 00:00:00 bmax according to bmaxDivN setting: 433 Using parameters --bmax 325 --dcv 1024 Doing ahead-of-time memory usage test Passed! Constructing with these parameters: --bmax 325 --dcv 1024 Constructing suffix-array element generator Building DifferenceCoverSample Building sPrime Building sPrimeOrder V-Sorting samples V-Sorting samples time: 00:00:00 Allocating rank array Ranking v-sort output Ranking v-sort output time: 00:00:00 Invoking Larsson-Sadakane on ranks Invoking Larsson-Sadakane on ranks time: 00:00:00 Sanity-checking and returning Building samples Reserving space for 300 sample suffixes Generating random suffixes QSorting 300 sample offsets, eliminating duplicates QSorting sample offsets, eliminating duplicates time: 00:00:00 Multikey QSorting 299 samples (Using difference cover) Multikey QSorting samples time: 00:00:00 Calculating bucket sizes Splitting and merging Splitting and merging time: 00:00:00 Split 40, merged 133; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 22, merged 15; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 8, merged 13; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 2, merged 4; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 1, merged 3; iterating... Avg bucket size: 235.6 (target: 324) Converting suffix-array elements to index image Allocating ftab, absorbFtab Entering Ebwt loop Getting block 1 of 205 Reserving size (325) for bucket 1 Getting block 2 of 205 Calculating Z arrays for bucket 1 Reserving size (325) for bucket 2 Getting block 3 of 205 Getting block 4 of 205 Getting block 5 of 205 Getting block 6 of 205 Getting block 7 of 205 Getting block 8 of 205 Entering block accumulator loop for bucket 1: Calculating Z arrays for bucket 2 Reserving size (325) for bucket 3 Getting block 9 of 205 Getting block 10 of 205 Reserving size (325) for bucket 4 Reserving size (325) for bucket 5 Getting block 11 of 205 Reserving size (325) for bucket 6 Reserving size (325) for bucket 7 Reserving size (325) for bucket 8 Getting block 12 of 205 Getting block 13 of 205 Getting block 14 of 205 Getting block 15 of 205 Getting block 16 of 205 Getting block 17 of 205 Getting block 18 of 205 Getting block 19 of 205 Getting block 20 of 205 Getting block 21 of 205 Getting block 22 of 205 Getting block 23 of 205 Getting block 24 of 205 Getting block 25 of 205 Getting block 26 of 205 Entering block accumulator loop for bucket 2: Calculating Z arrays for bucket 3 Reserving size (325) for bucket 9 Reserving size (325) for bucket 10 Calculating Z arrays for bucket 4 Calculating Z arrays for bucket 5 Reserving size (325) for bucket 11 Getting block 27 of 205 Calculating Z arrays for bucket 6 Calculating Z arrays for bucket 7 Calculating Z arrays for bucket 8 Reserving size (325) for bucket 12 Reserving size (325) for bucket 13 bucket 1: 10% Reserving size (325) for bucket 14 Reserving size (325) for bucket 15 Reserving size (325) for bucket 16 Reserving size (325) for bucket 17 Reserving size (325) for bucket 18 Reserving size (325) for bucket 19 Reserving size (325) for bucket 20 Reserving size (325) for bucket 21 Reserving size (325) for bucket 22 Reserving size (325) for bucket 23 Reserving size (325) for bucket 24 Reserving size (325) for bucket 25 Reserving size (325) for bucket 26 Entering block accumulator loop for bucket 3: Calculating Z arrays for bucket 9 Calculating Z arrays for bucket 10 Entering block accumulator loop for bucket 4: Calculating Z arrays for bucket 11 Entering block accumulator loop for bucket 5: Reserving size (325) for bucket 27 Entering block accumulator loop for bucket 6: Entering block accumulator loop for bucket 7: Calculating Z arrays for bucket 12 Entering block accumulator loop for bucket 8: Calculating Z arrays for bucket 13 Calculating Z arrays for bucket 14 Calculating Z arrays for bucket 15 Calculating Z arrays for bucket 16 bucket 1: 20% Calculating Z arrays for bucket 17 Calculating Z arrays for bucket 18 Calculating Z arrays for bucket 19 Calculating Z arrays for bucket 20 Calculating Z arrays for bucket 21 Calculating Z arrays for bucket 22 Calculating Z arrays for bucket 23 Calculating Z arrays for bucket 24 Calculating Z arrays for bucket 25 Calculating Z arrays for bucket 26 Entering block accumulator loop for bucket 9: Entering block accumulator loop for bucket 10: bucket 2: 10% Entering block accumulator loop for bucket 11: Calculating Z arrays for bucket 27 Entering block accumulator loop for bucket 12: Entering block accumulator loop for bucket 13: Entering block accumulator loop for bucket 14: Entering block accumulator loop for bucket 15: Entering block accumulator loop for bucket 16: Entering block accumulator loop for bucket 17: bucket 1: 30% Entering block accumulator loop for bucket 18: Entering block accumulator loop for bucket 19: Entering block accumulator loop for bucket 20: Entering block accumulator loop for bucket 21: Entering block accumulator loop for bucket 22: Entering block accumulator loop for bucket 23: Entering block accumulator loop for bucket 24: Entering block accumulator loop for bucket 25: Entering block accumulator loop for bucket 26: bucket 3: 10% bucket 4: 10% Entering block accumulator loop for bucket 27: bucket 2: 20% bucket 5: 10% bucket 6: 10% bucket 7: 10% bucket 8: 10% bucket 1: 40% bucket 9: 10% bucket 10: 10% bucket 11: 10% bucket 3: 20% bucket 4: 20% bucket 12: 10% bucket 13: 10% bucket 2: 30% bucket 14: 10% bucket 15: 10% bucket 5: 20% bucket 16: 10% bucket 6: 20% bucket 7: 20% bucket 1: 50% bucket 17: 10% bucket 8: 20% bucket 18: 10% bucket 20: 10% bucket 19: 10% bucket 21: 10% bucket 22: 10% bucket 23: 10% bucket 24: 10% bucket 25: 10% bucket 26: 10% bucket 9: 20% bucket 27: 10% bucket 10: 20% bucket 11: 20% bucket 3: 30% bucket 4: 30% bucket 12: 20% bucket 2: 40% bucket 13: 20% bucket 15: 20% bucket 14: 20% bucket 5: 30% bucket 6: 30% bucket 1: 60% bucket 16: 20% bucket 7: 30% bucket 8: 30% bucket 17: 20% bucket 18: 20% bucket 20: 20% bucket 19: 20% bucket 21: 20% bucket 22: 20% bucket 23: 20% bucket 24: 20% bucket 9: 30% bucket 25: 20% bucket 26: 20% bucket 10: 30% bucket 11: 30% bucket 27: 20% bucket 3: 40% bucket 4: 40% bucket 12: 30% bucket 2: 50% bucket 15: 30% bucket 13: 30% bucket 5: 40% bucket 14: 30% bucket 1: 70% bucket 6: 40% bucket 7: 40% bucket 16: 30% bucket 8: 40% bucket 17: 30% bucket 18: 30% bucket 20: 30% bucket 19: 30% bucket 21: 30% bucket 22: 30% bucket 23: 30% bucket 24: 30% bucket 9: 40% bucket 25: 30% bucket 10: 40% bucket 26: 30% bucket 11: 40% bucket 3: 50% bucket 27: 30% bucket 4: 50% bucket 12: 40% bucket 15: 40% bucket 2: 60% bucket 13: 40% bucket 1: 80% bucket 5: 50% bucket 14: 40% bucket 6: 50% bucket 7: 50% bucket 16: 40% bucket 8: 50% bucket 17: 40% bucket 18: 40% bucket 20: 40% bucket 19: 40% bucket 21: 40% bucket 22: 40% bucket 23: 40% bucket 24: 40% bucket 9: 50% bucket 25: 40% bucket 10: 50% bucket 26: 40% bucket 11: 50% bucket 3: 60% bucket 4: 60% bucket 27: 40% bucket 15: 50% bucket 12: 50% bucket 2: 70% bucket 1: 90% bucket 13: 50% bucket 5: 60% bucket 14: 50% bucket 6: 60% bucket 7: 60% bucket 16: 50% bucket 8: 60% bucket 17: 50% bucket 18: 50% bucket 20: 50% bucket 19: 50% bucket 21: 50% bucket 22: 50% bucket 23: 50% bucket 24: 50% bucket 9: 60% bucket 25: 50% bucket 10: 60% bucket 11: 60% bucket 26: 50% bucket 3: 70% bucket 4: 70% bucket 15: 60% bucket 27: 50% bucket 1: 100% bucket 12: 60% bucket 2: 80% bucket 5: 70% bucket 13: 60% bucket 14: 60% bucket 6: 70% bucket 7: 70% bucket 8: 70% bucket 16: 60% bucket 17: 60% bucket 18: 60% bucket 20: 60% bucket 19: 60% bucket 21: 60% bucket 22: 60% bucket 23: 60% bucket 24: 60% bucket 9: 70% bucket 10: 70% Sorting block of length 247 for bucket 1 (Using difference cover) bucket 11: 70% bucket 25: 60% bucket 3: 80% bucket 15: 70% bucket 4: 80% bucket 26: 60% bucket 12: 70% bucket 27: 60% bucket 2: 90% bucket 5: 80% bucket 13: 70% bucket 14: 70% bucket 6: 80% bucket 7: 80% bucket 8: 80% bucket 16: 70% bucket 17: 70% bucket 18: 70% bucket 20: 70% bucket 19: 70% bucket 21: 70% bucket 22: 70% bucket 23: 70% bucket 24: 70% bucket 9: 80% bucket 10: 80% bucket 11: 80% bucket 15: 80% bucket 3: 90% bucket 25: 70% bucket 4: 90% bucket 12: 80% bucket 26: 70% bucket 2: 100% bucket 5: 90% bucket 27: 70% bucket 13: 80% bucket 14: 80% bucket 6: 90% bucket 7: 90% bucket 8: 90% bucket 16: 80% bucket 17: 80% bucket 18: 80% bucket 20: 80% bucket 19: 80% bucket 21: 80% bucket 22: 80% bucket 23: 80% Sorting block time: 00:00:00 bucket 24: 80% bucket 9: 90% bucket 10: 90% bucket 15: 90% bucket 11: 90% Sorting block of length 192 for bucket 2 (Using difference cover) bucket 3: 100% bucket 4: 100% bucket 25: 80% bucket 12: 90% bucket 26: 80% bucket 5: 100% bucket 13: 90% bucket 14: 90% bucket 27: 80% bucket 6: 100% bucket 7: 100% bucket 8: 100% bucket 16: 90% bucket 17: 90% bucket 18: 90% bucket 20: 90% bucket 19: 90% bucket 21: 90% Returning block of 248 for bucket 1 bucket 22: 90% bucket 23: 90% bucket 24: 90% bucket 9: 100% bucket 15: 100% bucket 10: 100% Sorting block time: 00:00:00 Sorting block of length 190 for bucket 3 (Using difference cover) bucket 11: 100% Sorting block of length 324 for bucket 4 (Using difference cover) Sorting block of length 274 for bucket 5 (Using difference cover) bucket 12: 100% bucket 25: 90% Sorting block of length 148 for bucket 6 (Using difference cover) bucket 26: 90% Sorting block of length 222 for bucket 7 (Using difference cover) bucket 13: 100% Sorting block of length 282 for bucket 8 (Using difference cover) bucket 14: 100% bucket 27: 90% bucket 16: 100% bucket 17: 100% bucket 18: 100% bucket 20: 100% bucket 19: 100% bucket 21: 100% Sorting block of length 186 for bucket 9 (Using difference cover) bucket 22: 100% Sorting block of length 309 for bucket 15 (Using difference cover) Sorting block of length 283 for bucket 10 (Using difference cover) Returning block of 193 for bucket 2 bucket 23: 100% bucket 24: 100% Sorting block of length 66 for bucket 11 (Using difference cover) Sorting block of length 305 for bucket 12 (Using difference cover) bucket 25: 100% Sorting block of length 301 for bucket 13 (Using difference cover) bucket 26: 100% Sorting block of length 103 for bucket 14 (Using difference cover) Sorting block of length 278 for bucket 16 (Using difference cover) Sorting block of length 263 for bucket 17 (Using difference cover) Sorting block of length 313 for bucket 18 (Using difference cover) Sorting block of length 283 for bucket 20 (Using difference cover) Sorting block of length 143 for bucket 19 (Using difference cover) bucket 27: 100% Sorting block of length 314 for bucket 21 (Using difference cover) Sorting block of length 216 for bucket 22 (Using difference cover) Sorting block of length 269 for bucket 23 Sorting block of length 178 for bucket 24 (Using difference cover) (Using difference cover) Sorting block of length 234 for bucket 25 (Using difference cover) Sorting block of length 278 for bucket 26 (Using difference cover) Sorting block of length 259 for bucket 27 (Using difference cover) Getting block 28 of 205 Getting block 29 of 205 Reserving size (325) for bucket 28 Reserving size (325) for bucket 29 Calculating Z arrays for bucket 28 Calculating Z arrays for bucket 29 Entering block accumulator loop for bucket 28: Entering block accumulator loop for bucket 29: bucket 28: 10% bucket 29: 10% bucket 28: 20% bucket 29: 20% bucket 28: 30% bucket 29: 30% bucket 28: 40% bucket 29: 40% bucket 28: 50% bucket 29: 50% bucket 28: 60% bucket 29: 60% bucket 28: 70% bucket 29: 70% bucket 28: 80% bucket 29: 80% bucket 28: 90% bucket 29: 90% bucket 28: 100% Sorting block of length 148 for bucket 28 (Using difference cover) bucket 29: 100% Sorting block of length 298 for bucket 29 (Using difference cover) Sorting block time: 00:00:00 Returning block of 191 for bucket 3 Getting block 30 of 205 Reserving size (325) for bucket 30 Calculating Z arrays for bucket 30 Entering block accumulator loop for bucket 30: bucket 30: 10% bucket 30: 20% bucket 30: 30% bucket 30: 40% bucket 30: 50% bucket 30: 60% bucket 30: 70% bucket 30: 80% bucket 30: 90% bucket 30: 100% Sorting block of length 250 for bucket 30 (Using difference cover) Sorting block time: 00:00:00 Returning block of 325 for bucket 4 Getting block 31 of 205 Reserving size (325) for bucket 31 Calculating Z arrays for bucket 31 Entering block accumulator loop for bucket 31: bucket 31: 10% bucket 31: 20% bucket 31: 30% bucket 31: 40% bucket 31: 50% bucket 31: 60% bucket 31: 70% bucket 31: 80% bucket 31: 90% bucket 31: 100% Sorting block of length 293 for bucket 31 (Using difference cover) Sorting block time: 00:00:00 Returning block of 315 for bucket 21 Sorting block time: 00:00:00 Returning block of 310 for bucket 15 Sorting block time: 00:00:00 Returning block of 275 for bucket 5 Getting block 32 of 205 Reserving size (325) for bucket 32 Calculating Z arrays for bucket 32 Entering block accumulator loop for bucket 32: bucket 32: 10% Getting block 33 of 205 bucket 32: 20% Reserving size (325) for bucket 33 Calculating Z arrays for bucket 33 Entering block accumulator loop for bucket 33: bucket 32: 30% bucket 33: 10% bucket 32: 40% Getting block 34 of 205 Reserving size (325) for bucket 34 Calculating Z arrays for bucket 34 bucket 33: 20% Entering block accumulator loop for bucket 34: bucket 32: 50% Sorting block time: 00:00:00 Returning block of 302 for bucket 13 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 33: 30% Sorting block time: 00:00:00 bucket 32: 60% Sorting block time: 00:00:00 Returning block of 314 for bucket 18 Returning block of 187 for bucket 9 Sorting block time: 00:00:00 bucket 34: 10% Returning block of 223 for bucket 7 Returning block of 149 for bucket 6 Returning block of 144 for bucket 19 Returning block of 284 for bucket 20 bucket 33: 40% bucket 32: 70% Returning block of 283 for bucket 8 bucket 34: 20% Getting block 35 of 205 bucket 33: 50% bucket 32: 80% Reserving size (325) for bucket 35 Calculating Z arrays for bucket 35 bucket 34: 30% Entering block accumulator loop for bucket 35: bucket 33: 60% bucket 32: 90% bucket 34: 40% bucket 33: 70% bucket 35: 10% bucket 32: 100% Sorting block of length 320 for bucket 32 (Using difference cover) Getting block 36 of 205 bucket 34: 50% Reserving size (325) for bucket 36 bucket 33: 80% Calculating Z arrays for bucket 36 bucket 35: 20% Entering block accumulator loop for bucket 36: bucket 34: 60% bucket 33: 90% Getting block 37 of 205 bucket 36: 10% bucket 35: 30% Reserving size (325) for bucket 37 bucket 34: 70% Calculating Z arrays for bucket 37 bucket 33: 100% Sorting block of length 313 for bucket 33 (Using difference cover) bucket 36: 20% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 37: Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 35: 40% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 67 for bucket 11 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 104 for bucket 14 Sorting block time: 00:00:00 bucket 34: 80% Returning block of 217 for bucket 22 Sorting block time: 00:00:00 Returning block of 279 for bucket 26 Sorting block time: 00:00:00 Returning block of 264 for bucket 17 Sorting block time: 00:00:00 Returning block of 284 for bucket 10 Returning block of 260 for bucket 27 bucket 36: 30% Returning block of 270 for bucket 23 Returning block of 179 for bucket 24 Returning block of 279 for bucket 16 Returning block of 251 for bucket 30 bucket 35: 50% Returning block of 299 for bucket 29 bucket 34: 90% Returning block of 235 for bucket 25 Returning block of 306 for bucket 12 bucket 37: 10% bucket 36: 40% Getting block 38 of 205 bucket 35: 60% bucket 34: 100% Reserving size (325) for bucket 38 Sorting block of length 301 for bucket 34 (Using difference cover) Getting block 39 of 205 bucket 36: 50% Calculating Z arrays for bucket 38 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 37: 20% bucket 35: 70% Reserving size (325) for bucket 39 Returning block of 149 for bucket 28 Returning block of 314 for bucket 33 Returning block of 294 for bucket 31 Entering block accumulator loop for bucket 38: bucket 36: 60% Calculating Z arrays for bucket 39 bucket 35: 80% bucket 37: 30% Getting block 40 of 205 Entering block accumulator loop for bucket 39: bucket 36: 70% Reserving size (325) for bucket 40 bucket 35: 90% Calculating Z arrays for bucket 40 Sorting block time: 00:00:00 bucket 37: 40% bucket 38: 10% Returning block of 321 for bucket 32 bucket 36: 80% Entering block accumulator loop for bucket 40: bucket 35: 100% Getting block 41 of 205 Sorting block time: 00:00:00 bucket 39: 10% Sorting block of length 284 for bucket 35 (Using difference cover) bucket 37: 50% Reserving size (325) for bucket 41 Returning block of 302 for bucket 34 bucket 36: 90% bucket 38: 20% Calculating Z arrays for bucket 41 bucket 40: 10% bucket 39: 20% bucket 37: 60% Getting block 42 of 205 Entering block accumulator loop for bucket 41: bucket 36: 100% Reserving size (325) for bucket 42 bucket 38: 30% Sorting block of length 174 for bucket 36 (Using difference cover) Calculating Z arrays for bucket 42 bucket 40: 20% bucket 37: 70% bucket 39: 30% Entering block accumulator loop for bucket 42: Getting block 43 of 205 bucket 41: 10% bucket 38: 40% Reserving size (325) for bucket 43 Calculating Z arrays for bucket 43 bucket 40: 30% bucket 37: 80% bucket 39: 40% Entering block accumulator loop for bucket 43: Getting block 44 of 205 Reserving size (325) for bucket 44 bucket 41: 20% bucket 38: 50% Calculating Z arrays for bucket 44 bucket 42: 10% bucket 40: 40% bucket 37: 90% bucket 39: 50% Entering block accumulator loop for bucket 44: bucket 43: 10% bucket 41: 30% bucket 38: 60% bucket 42: 20% bucket 40: 50% Sorting block time: 00:00:00 bucket 37: 100% bucket 39: 60% Sorting block time: 00:00:00 Returning block of 285 for bucket 35 bucket 43: 20% bucket 44: 10% bucket 41: 40% Sorting block of length 304 for bucket 37 (Using difference cover) bucket 38: 70% Getting block 45 of 205 Returning block of 175 for bucket 36 bucket 42: 30% bucket 40: 60% bucket 39: 70% bucket 43: 30% Reserving size (325) for bucket 45 bucket 44: 20% bucket 41: 50% bucket 38: 80% Getting block 46 of 205 Calculating Z arrays for bucket 45 bucket 42: 40% bucket 40: 70% bucket 39: 80% bucket 43: 40% Reserving size (325) for bucket 46 Entering block accumulator loop for bucket 45: bucket 44: 30% bucket 41: 60% bucket 38: 90% Calculating Z arrays for bucket 46 Sorting block time: 00:00:00 Getting block 47 of 205 bucket 42: 50% bucket 40: 80% bucket 39: 90% Returning block of 305 for bucket 37 bucket 43: 50% Reserving size (325) for bucket 47 Entering block accumulator loop for bucket 46: bucket 44: 40% bucket 41: 70% bucket 38: 100% Calculating Z arrays for bucket 47 bucket 42: 60% bucket 45: 10% bucket 40: 90% bucket 39: 100% Sorting block of length 152 for bucket 38 (Using difference cover) Getting block 48 of 205 bucket 43: 60% Entering block accumulator loop for bucket 47: bucket 41: 80% bucket 44: 50% Sorting block of length 323 for bucket 39 (Using difference cover) bucket 42: 70% Reserving size (325) for bucket 48 bucket 40: 100% bucket 46: 10% bucket 45: 20% bucket 43: 70% Calculating Z arrays for bucket 48 Getting block 49 of 205 bucket 41: 90% Sorting block of length 181 for bucket 40 (Using difference cover) bucket 44: 60% bucket 42: 80% Reserving size (325) for bucket 49 Entering block accumulator loop for bucket 48: bucket 46: 20% bucket 43: 80% bucket 47: 10% Getting block 50 of 205 bucket 45: 30% Calculating Z arrays for bucket 49 bucket 41: 100% bucket 44: 70% bucket 42: 90% Reserving size (325) for bucket 50 Sorting block of length 173 for bucket 41 (Using difference cover) bucket 43: 90% bucket 46: 30% Entering block accumulator loop for bucket 49: Calculating Z arrays for bucket 50 Getting block 51 of 205 bucket 47: 20% bucket 45: 40% bucket 44: 80% bucket 42: 100% bucket 48: 10% Reserving size (325) for bucket 51 Entering block accumulator loop for bucket 50: bucket 43: 100% bucket 46: 40% Sorting block of length 158 for bucket 42 (Using difference cover) Calculating Z arrays for bucket 51 bucket 47: 30% bucket 44: 90% bucket 45: 50% Sorting block of length 291 for bucket 43 (Using difference cover) bucket 49: 10% Getting block 52 of 205 bucket 48: 20% Entering block accumulator loop for bucket 51: bucket 46: 50% bucket 44: 100% bucket 47: 40% bucket 50: 10% Reserving size (325) for bucket 52 bucket 45: 60% Getting block 53 of 205 Sorting block of length 145 for bucket 44 (Using difference cover) bucket 49: 20% Calculating Z arrays for bucket 52 bucket 48: 30% bucket 46: 60% Reserving size (325) for bucket 53 bucket 47: 50% bucket 50: 20% bucket 45: 70% bucket 51: 10% Entering block accumulator loop for bucket 52: Calculating Z arrays for bucket 53 Getting block 54 of 205 bucket 49: 30% bucket 46: 70% bucket 48: 40% Reserving size (325) for bucket 54 Entering block accumulator loop for bucket 53: bucket 47: 60% bucket 45: 80% bucket 50: 30% Getting block 55 of 205 bucket 51: 20% Calculating Z arrays for bucket 54 bucket 46: 80% Sorting block time: 00:00:00 bucket 52: 10% bucket 49: 40% Reserving size (325) for bucket 55 bucket 48: 50% bucket 47: 70% bucket 45: 90% Returning block of 153 for bucket 38 Entering block accumulator loop for bucket 54: bucket 50: 40% bucket 51: 30% Calculating Z arrays for bucket 55 bucket 46: 90% bucket 53: 10% bucket 49: 50% bucket 52: 20% Getting block 56 of 205 bucket 47: 80% bucket 48: 60% bucket 45: 100% Entering block accumulator loop for bucket 55: bucket 50: 50% bucket 51: 40% Reserving size (325) for bucket 56 bucket 46: 100% Sorting block of length 282 for bucket 45 (Using difference cover) Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 49: 60% bucket 53: 20% bucket 52: 30% bucket 54: 10% bucket 47: 90% Calculating Z arrays for bucket 56 Sorting block of length 311 for bucket 46 (Using difference cover) bucket 48: 70% Returning block of 324 for bucket 39 Returning block of 182 for bucket 40 bucket 50: 60% bucket 51: 50% bucket 49: 70% bucket 55: 10% Entering block accumulator loop for bucket 56: bucket 53: 30% bucket 52: 40% bucket 47: 100% bucket 54: 20% Getting block 57 of 205 bucket 48: 80% Sorting block time: 00:00:00 bucket 50: 70% Sorting block of length 238 for bucket 47 (Using difference cover) bucket 51: 60% bucket 49: 80% Reserving size (325) for bucket 57 bucket 55: 20% Getting block 58 of 205 Returning block of 174 for bucket 41 bucket 52: 50% bucket 53: 40% bucket 54: 30% bucket 48: 90% bucket 56: 10% bucket 50: 80% Calculating Z arrays for bucket 57 Reserving size (325) for bucket 58 bucket 51: 70% bucket 49: 90% bucket 55: 30% bucket 52: 60% bucket 53: 50% bucket 54: 40% Calculating Z arrays for bucket 58 Getting block 59 of 205 bucket 48: 100% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 57: bucket 56: 20% bucket 50: 90% Sorting block time: 00:00:00 Getting block 60 of 205 bucket 51: 80% Sorting block time: 00:00:00 bucket 49: 100% Reserving size (325) for bucket 59 bucket 55: 40% Entering block accumulator loop for bucket 58: Sorting block of length 289 for bucket 48 bucket 52: 70% (Using difference cover) Returning block of 292 for bucket 43 bucket 54: 50% Sorting block time: 00:00:00 bucket 53: 60% Returning block of 146 for bucket 44 Reserving size (325) for bucket 60 Returning block of 159 for bucket 42 Sorting block of length 225 for bucket 49 (Using difference cover) bucket 56: 30% Calculating Z arrays for bucket 59 bucket 50: 100% Getting block 61 of 205 bucket 51: 90% bucket 55: 50% Returning block of 283 for bucket 45 bucket 52: 80% bucket 57: 10% Calculating Z arrays for bucket 60 bucket 54: 60% bucket 53: 70% Getting block 62 of 205 Sorting block of length 316 for bucket 50 (Using difference cover) Entering block accumulator loop for bucket 59: Reserving size (325) for bucket 61 bucket 56: 40% bucket 58: 10% Getting block 63 of 205 bucket 51: 100% bucket 55: 60% Entering block accumulator loop for bucket 60: Reserving size (325) for bucket 62 bucket 52: 90% bucket 57: 20% Calculating Z arrays for bucket 61 bucket 54: 70% bucket 53: 80% Reserving size (325) for bucket 63 Sorting block of length 154 for bucket 51 (Using difference cover) Getting block 64 of 205 bucket 56: 50% Calculating Z arrays for bucket 62 bucket 58: 20% Entering block accumulator loop for bucket 61: bucket 55: 70% Calculating Z arrays for bucket 63 Reserving size (325) for bucket 64 Getting block 65 of 205 bucket 57: 30% bucket 59: 10% bucket 52: 100% Sorting block time: 00:00:00 bucket 54: 80% Entering block accumulator loop for bucket 62: bucket 53: 90% bucket 60: 10% Calculating Z arrays for bucket 64 Entering block accumulator loop for bucket 63: bucket 56: 60% Reserving size (325) for bucket 65 bucket 58: 30% bucket 55: 80% Sorting block of length 218 for bucket 52 (Using difference cover) Returning block of 312 for bucket 46 bucket 57: 40% bucket 59: 20% Entering block accumulator loop for bucket 64: bucket 54: 90% Calculating Z arrays for bucket 65 bucket 61: 10% bucket 53: 100% bucket 60: 20% bucket 56: 70% bucket 58: 40% bucket 55: 90% Getting block 66 of 205 bucket 62: 10% bucket 57: 50% Entering block accumulator loop for bucket 65: bucket 59: 30% Sorting block of length 312 for bucket 53 (Using difference cover) bucket 63: 10% bucket 54: 100% Reserving size (325) for bucket 66 bucket 61: 20% bucket 60: 30% bucket 64: 10% bucket 56: 80% bucket 58: 50% bucket 55: 100% bucket 62: 20% Getting block 67 of 205 Sorting block of length 147 for bucket 54 Sorting block time: 00:00:00 (Using difference cover) bucket 57: 60% Calculating Z arrays for bucket 66 bucket 59: 40% bucket 63: 20% Sorting block of length 243 for bucket 55 (Using difference cover) bucket 61: 30% bucket 64: 20% Reserving size (325) for bucket 67 bucket 60: 40% Returning block of 239 for bucket 47 bucket 56: 90% bucket 65: 10% bucket 62: 30% bucket 58: 60% Getting block 68 of 205 Entering block accumulator loop for bucket 66: bucket 57: 70% bucket 59: 50% Calculating Z arrays for bucket 67 bucket 63: 30% bucket 64: 30% bucket 61: 40% bucket 60: 50% Reserving size (325) for bucket 68 bucket 56: 100% Getting block 69 of 205 bucket 62: 40% bucket 65: 20% bucket 58: 70% Entering block accumulator loop for bucket 67: Getting block 70 of 205 Calculating Z arrays for bucket 68 Sorting block of length 174 for bucket 56 (Using difference cover) bucket 57: 80% bucket 59: 60% bucket 64: 40% Reserving size (325) for bucket 69 bucket 63: 40% bucket 61: 50% bucket 60: 60% bucket 66: 10% Reserving size (325) for bucket 70 bucket 62: 50% Getting block 71 of 205 Entering block accumulator loop for bucket 68: bucket 65: 30% bucket 58: 80% Calculating Z arrays for bucket 69 bucket 64: 50% bucket 57: 90% Calculating Z arrays for bucket 70 bucket 59: 70% Reserving size (325) for bucket 71 bucket 63: 50% bucket 61: 60% bucket 60: 70% bucket 67: 10% bucket 66: 20% bucket 62: 60% Getting block 72 of 205 Entering block accumulator loop for bucket 69: Entering block accumulator loop for bucket 70: Calculating Z arrays for bucket 71 bucket 65: 40% bucket 64: 60% bucket 58: 90% bucket 57: 100% bucket 59: 80% Reserving size (325) for bucket 72 bucket 63: 60% bucket 68: 10% Getting block 73 of 205 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 61: 70% Sorting block time: 00:00:00 bucket 60: 80% bucket 66: 30% bucket 62: 70% bucket 67: 20% Entering block accumulator loop for bucket 71: Sorting block of length 189 for bucket 57 (Using difference cover) Calculating Z arrays for bucket 72 bucket 65: 50% bucket 64: 70% bucket 58: 100% Returning block of 290 for bucket 48 Reserving size (325) for bucket 73 Returning block of 226 for bucket 49 bucket 59: 90% Returning block of 155 for bucket 51 bucket 63: 70% bucket 69: 10% bucket 68: 20% bucket 70: 10% bucket 61: 80% bucket 66: 40% bucket 60: 90% bucket 62: 80% Entering block accumulator loop for bucket 72: bucket 67: 30% Sorting block of length 256 for bucket 58 (Using difference cover) Calculating Z arrays for bucket 73 bucket 64: 80% bucket 65: 60% Getting block 74 of 205 bucket 59: 100% bucket 63: 80% bucket 69: 20% bucket 68: 30% bucket 71: 10% bucket 70: 20% bucket 66: 50% bucket 61: 90% bucket 60: 100% bucket 62: 90% Entering block accumulator loop for bucket 73: bucket 67: 40% Reserving size (325) for bucket 74 Sorting block of length 276 for bucket 59 (Using difference cover) bucket 64: 90% bucket 65: 70% Sorting block of length 318 for bucket 60 (Using difference cover) bucket 63: 90% bucket 69: 30% bucket 72: 10% bucket 68: 40% Calculating Z arrays for bucket 74 bucket 70: 30% bucket 71: 20% bucket 66: 60% bucket 61: 100% Getting block 75 of 205 bucket 62: 100% bucket 67: 50% bucket 64: 100% bucket 65: 80% Entering block accumulator loop for bucket 74: Getting block 76 of 205 bucket 63: 100% bucket 69: 40% Sorting block of length 293 for bucket 61 (Using difference cover) bucket 68: 50% bucket 73: 10% bucket 72: 20% Reserving size (325) for bucket 75 Sorting block of length 301 for bucket 62 (Using difference cover) bucket 70: 40% Sorting block of length 211 for bucket 64 (Using difference cover) bucket 71: 30% bucket 66: 70% Reserving size (325) for bucket 76 Sorting block of length 292 for bucket 63 (Using difference cover) bucket 67: 60% bucket 65: 90% Calculating Z arrays for bucket 75 bucket 69: 50% bucket 68: 60% bucket 73: 20% bucket 72: 30% Calculating Z arrays for bucket 76 bucket 70: 50% Getting block 77 of 205 bucket 71: 40% bucket 66: 80% bucket 74: 10% Entering block accumulator loop for bucket 75: bucket 65: 100% Entering block accumulator loop for bucket 76: bucket 67: 70% Reserving size (325) for bucket 77 bucket 69: 60% bucket 68: 70% bucket 73: 30% bucket 72: 40% Sorting block of length 172 for bucket 65 (Using difference cover) bucket 70: 60% bucket 71: 50% Calculating Z arrays for bucket 77 bucket 66: 90% bucket 74: 20% bucket 67: 80% bucket 69: 70% bucket 73: 40% bucket 68: 80% bucket 72: 50% Entering block accumulator loop for bucket 77: bucket 75: 10% bucket 70: 70% bucket 71: 60% bucket 76: 10% bucket 66: 100% bucket 74: 30% bucket 73: 50% bucket 69: 80% bucket 67: 90% Sorting block of length 292 for bucket 66 (Using difference cover) bucket 68: 90% bucket 72: 60% bucket 70: 80% bucket 75: 20% bucket 71: 70% bucket 77: 10% bucket 76: 20% bucket 74: 40% bucket 73: 60% bucket 69: 90% bucket 67: 100% bucket 68: 100% bucket 72: 70% bucket 70: 90% bucket 75: 30% bucket 71: 80% Sorting block of length 175 for bucket 67 (Using difference cover) Sorting block of length 315 for bucket 68 (Using difference cover) bucket 77: 20% bucket 74: 50% bucket 76: 30% bucket 73: 70% bucket 69: 100% bucket 72: 80% bucket 70: 100% bucket 75: 40% bucket 71: 90% Sorting block of length 253 for bucket 69 (Using difference cover) Sorting block of length 195 for bucket 70 (Using difference cover) bucket 77: 30% bucket 74: 60% bucket 76: 40% bucket 73: 80% bucket 72: 90% bucket 75: 50% bucket 71: 100% Sorting block of length 253 for bucket 71 (Using difference cover) bucket 77: 40% Sorting block time: 00:00:00 Returning block of 317 for bucket 50 bucket 74: 70% bucket 76: 50% bucket 73: 90% bucket 72: 100% bucket 75: 60% bucket 77: 50% Sorting block of length 127 for bucket 72 (Using difference cover) bucket 74: 80% bucket 76: 60% bucket 73: 100% Sorting block of length 241 for bucket 73 (Using difference cover) bucket 75: 70% bucket 77: 60% bucket 74: 90% bucket 76: 70% bucket 75: 80% bucket 77: 70% bucket 74: 100% Sorting block of length 135 for bucket 74 (Using difference cover) bucket 76: 80% Getting block 78 of 205 bucket 75: 90% bucket 77: 80% Reserving size (325) for bucket 78 Calculating Z arrays for bucket 78 Entering block accumulator loop for bucket 78: bucket 76: 90% bucket 75: 100% bucket 77: 90% Sorting block of length 301 for bucket 75 (Using difference cover) bucket 76: 100% bucket 78: 10% Sorting block of length 280 for bucket 76 (Using difference cover) bucket 77: 100% Sorting block of length 256 for bucket 77 (Using difference cover) Sorting block time: 00:00:00 Returning block of 313 for bucket 53 bucket 78: 20% bucket 78: 30% bucket 78: 40% Getting block 79 of 205 bucket 78: 50% Reserving size (325) for bucket 79 Calculating Z arrays for bucket 79 Entering block accumulator loop for bucket 79: bucket 78: 60% bucket 79: 10% bucket 78: 70% bucket 79: 20% bucket 78: 80% bucket 79: 30% bucket 78: 90% bucket 79: 40% bucket 79: 50% bucket 78: 100% Sorting block of length 106 for bucket 78 (Using difference cover) bucket 79: 60% bucket 79: 70% bucket 79: 80% bucket 79: 90% bucket 79: 100% Sorting block of length 307 for bucket 79 (Using difference cover) Sorting block time: 00:00:00 Returning block of 148 for bucket 54 Sorting block time: 00:00:00 Returning block of 219 for bucket 52 Getting block 80 of 205 Reserving size (325) for bucket 80 Calculating Z arrays for bucket 80 Entering block accumulator loop for bucket 80: bucket 80: 10% Getting block 81 of 205 Reserving size (325) for bucket 81 bucket 80: 20% Calculating Z arrays for bucket 81 Entering block accumulator loop for bucket 81: bucket 80: 30% bucket 81: 10% bucket 80: 40% bucket 80: 50% bucket 81: 20% bucket 80: 60% bucket 81: 30% bucket 80: 70% bucket 81: 40% bucket 81: 50% bucket 80: 80% bucket 81: 60% bucket 80: 90% bucket 81: 70% bucket 80: 100% Sorting block of length 257 for bucket 80 (Using difference cover) bucket 81: 80% bucket 81: 90% bucket 81: 100% Sorting block of length 261 for bucket 81 (Using difference cover) Sorting block time: 00:00:00 Returning block of 244 for bucket 55 Sorting block time: 00:00:00 Returning block of 257 for bucket 58 Getting block 82 of 205 Reserving size (325) for bucket 82 Calculating Z arrays for bucket 82 Entering block accumulator loop for bucket 82: Getting block 83 of 205 Reserving size (325) for bucket 83 Calculating Z arrays for bucket 83 Entering block accumulator loop for bucket 83: bucket 82: 10% bucket 83: 10% bucket 82: 20% bucket 83: 20% bucket 82: 30% Sorting block time: 00:00:00 Returning block of 175 for bucket 56 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 212 for bucket 64 Returning block of 319 for bucket 60 bucket 83: 30% Sorting block time: 00:00:00 bucket 82: 40% Returning block of 190 for bucket 57 bucket 83: 40% bucket 82: 50% Sorting block time: 00:00:00 bucket 83: 50% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 293 for bucket 63 Returning block of 302 for bucket 62 Sorting block time: 00:00:00 Returning block of 294 for bucket 61 bucket 82: 60% Returning block of 173 for bucket 65 bucket 83: 60% Getting block 84 of 205 Reserving size (325) for bucket 84 Calculating Z arrays for bucket 84 Entering block accumulator loop for bucket 84: bucket 82: 70% bucket 83: 70% Getting block 85 of 205 Reserving size (325) for bucket 85 Calculating Z arrays for bucket 85 bucket 84: 10% Entering block accumulator loop for bucket 85: bucket 82: 80% bucket 83: 80% bucket 85: 10% bucket 84: 20% bucket 83: 90% bucket 82: 90% bucket 85: 20% bucket 84: 30% Getting block 86 of 205 bucket 83: 100% bucket 85: 30% Reserving size (325) for bucket 86 Sorting block of length 212 for bucket 83 (Using difference cover) bucket 82: 100% Calculating Z arrays for bucket 86 bucket 84: 40% bucket 85: 40% Sorting block of length 114 for bucket 82 (Using difference cover) Getting block 87 of 205 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 86: Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 176 for bucket 67 Sorting block time: 00:00:00 Reserving size (325) for bucket 87 Returning block of 254 for bucket 71 bucket 85: 50% Returning block of 277 for bucket 59 Returning block of 107 for bucket 78 Returning block of 196 for bucket 70 Returning block of 257 for bucket 77 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 316 for bucket 68 bucket 84: 50% Sorting block time: 00:00:00 Returning block of 128 for bucket 72 Returning block of 136 for bucket 74 Returning block of 281 for bucket 76 Returning block of 254 for bucket 69 Returning block of 302 for bucket 75 Returning block of 293 for bucket 66 Calculating Z arrays for bucket 87 bucket 85: 60% bucket 86: 10% Returning block of 242 for bucket 73 Returning block of 308 for bucket 79 Returning block of 262 for bucket 81 bucket 84: 60% Entering block accumulator loop for bucket 87: bucket 85: 70% Getting block 88 of 205 bucket 86: 20% Getting block 89 of 205 Getting block 90 of 205 Reserving size (325) for bucket 88 Reserving size (325) for bucket 89 Reserving size (325) for bucket 90 bucket 85: 80% Calculating Z arrays for bucket 88 bucket 84: 70% Calculating Z arrays for bucket 89 Calculating Z arrays for bucket 90 Getting block 91 of 205 bucket 86: 30% bucket 87: 10% Entering block accumulator loop for bucket 88: Entering block accumulator loop for bucket 89: Sorting block time: 00:00:00 Sorting block time: 00:00:00 Reserving size (325) for bucket 91 Entering block accumulator loop for bucket 90: bucket 85: 90% Returning block of 115 for bucket 82 Returning block of 258 for bucket 80 Sorting block time: 00:00:00 bucket 84: 80% Calculating Z arrays for bucket 91 Getting block 92 of 205 bucket 86: 40% bucket 87: 20% bucket 85: 100% Returning block of 213 for bucket 83 bucket 88: 10% Reserving size (325) for bucket 92 Entering block accumulator loop for bucket 91: bucket 89: 10% Sorting block of length 313 for bucket 85 (Using difference cover) bucket 90: 10% bucket 84: 90% Calculating Z arrays for bucket 92 Getting block 93 of 205 bucket 86: 50% bucket 87: 30% bucket 88: 20% Reserving size (325) for bucket 93 Entering block accumulator loop for bucket 92: bucket 89: 20% Getting block 94 of 205 Calculating Z arrays for bucket 93 bucket 90: 20% bucket 84: 100% Reserving size (325) for bucket 94 bucket 87: 40% bucket 86: 60% bucket 91: 10% Sorting block of length 236 for bucket 84 (Using difference cover) bucket 88: 30% Entering block accumulator loop for bucket 93: Calculating Z arrays for bucket 94 bucket 89: 30% bucket 90: 30% bucket 92: 10% bucket 87: 50% Entering block accumulator loop for bucket 94: bucket 86: 70% bucket 91: 20% bucket 88: 40% Getting block 95 of 205 bucket 89: 40% bucket 90: 40% Reserving size (325) for bucket 95 bucket 92: 20% bucket 93: 10% bucket 87: 60% Calculating Z arrays for bucket 95 bucket 94: 10% bucket 91: 30% bucket 88: 50% bucket 86: 80% bucket 89: 50% bucket 90: 50% Entering block accumulator loop for bucket 95: bucket 92: 30% bucket 93: 20% bucket 87: 70% bucket 94: 20% bucket 91: 40% bucket 88: 60% bucket 89: 60% bucket 86: 90% bucket 90: 60% Sorting block time: 00:00:00 bucket 92: 40% bucket 93: 30% bucket 95: 10% bucket 94: 30% Sorting block time: 00:00:00 Getting block 96 of 205 Returning block of 314 for bucket 85 bucket 87: 80% bucket 91: 50% bucket 88: 70% Returning block of 237 for bucket 84 bucket 89: 70% Reserving size (325) for bucket 96 bucket 86: 100% bucket 90: 70% bucket 92: 50% bucket 93: 40% bucket 94: 40% bucket 95: 20% Calculating Z arrays for bucket 96 Sorting block of length 242 for bucket 86 (Using difference cover) bucket 87: 90% bucket 91: 60% bucket 88: 80% Getting block 97 of 205 bucket 89: 80% Entering block accumulator loop for bucket 96: bucket 90: 80% bucket 92: 60% bucket 94: 50% bucket 93: 50% bucket 95: 30% Reserving size (325) for bucket 97 Getting block 98 of 205 bucket 87: 100% bucket 91: 70% bucket 88: 90% Calculating Z arrays for bucket 97 Reserving size (325) for bucket 98 bucket 89: 90% Sorting block of length 192 for bucket 87 (Using difference cover) bucket 90: 90% bucket 94: 60% bucket 92: 70% Getting block 99 of 205 bucket 93: 60% bucket 95: 40% Calculating Z arrays for bucket 98 Entering block accumulator loop for bucket 97: bucket 96: 10% bucket 91: 80% Reserving size (325) for bucket 99 bucket 88: 100% bucket 89: 100% Getting block 100 of 205 bucket 90: 100% bucket 94: 70% Entering block accumulator loop for bucket 98: Calculating Z arrays for bucket 99 bucket 92: 80% Sorting block of length 260 for bucket 88 (Using difference cover) Sorting block of length 272 for bucket 89 (Using difference cover) bucket 95: 50% bucket 93: 70% Reserving size (325) for bucket 100 Sorting block of length 158 for bucket 90 (Using difference cover) bucket 96: 20% Sorting block time: 00:00:00 bucket 91: 90% Entering block accumulator loop for bucket 99: bucket 97: 10% bucket 94: 80% Calculating Z arrays for bucket 100 bucket 92: 90% Getting block 101 of 205 Returning block of 243 for bucket 86 bucket 95: 60% bucket 93: 80% bucket 98: 10% Entering block accumulator loop for bucket 100: bucket 96: 30% Reserving size (325) for bucket 101 bucket 91: 100% Getting block 102 of 205 bucket 94: 90% bucket 97: 20% bucket 92: 100% Calculating Z arrays for bucket 101 Sorting block of length 299 for bucket 91 (Using difference cover) Reserving size (325) for bucket 102 bucket 95: 70% bucket 99: 10% bucket 93: 90% Getting block 103 of 205 Sorting block of length 125 for bucket 92 (Using difference cover) bucket 98: 20% bucket 96: 40% Entering block accumulator loop for bucket 101: Calculating Z arrays for bucket 102 bucket 94: 100% bucket 97: 30% bucket 100: 10% Reserving size (325) for bucket 103 bucket 95: 80% bucket 99: 20% Sorting block of length 188 for bucket 94 (Using difference cover) Getting block 104 of 205 bucket 93: 100% Entering block accumulator loop for bucket 102: Calculating Z arrays for bucket 103 bucket 96: 50% bucket 98: 30% Reserving size (325) for bucket 104 Sorting block of length 238 for bucket 93 (Using difference cover) bucket 97: 40% bucket 100: 20% bucket 101: 10% bucket 95: 90% Entering block accumulator loop for bucket 103: Calculating Z arrays for bucket 104 bucket 99: 30% bucket 96: 60% bucket 98: 40% Entering block accumulator loop for bucket 104: bucket 97: 50% bucket 100: 30% bucket 102: 10% bucket 101: 20% bucket 95: 100% Getting block 105 of 205 Sorting block of length 243 for bucket 95 (Using difference cover) bucket 99: 40% bucket 103: 10% Reserving size (325) for bucket 105 bucket 98: 50% bucket 96: 70% bucket 97: 60% bucket 100: 40% bucket 104: 10% bucket 101: 30% Calculating Z arrays for bucket 105 bucket 102: 20% bucket 99: 50% Getting block 106 of 205 bucket 103: 20% Entering block accumulator loop for bucket 105: Reserving size (325) for bucket 106 bucket 98: 60% bucket 100: 50% bucket 96: 80% bucket 97: 70% Calculating Z arrays for bucket 106 bucket 101: 40% bucket 104: 20% bucket 102: 30% bucket 99: 60% bucket 103: 30% Entering block accumulator loop for bucket 106: bucket 100: 60% bucket 98: 70% bucket 105: 10% Getting block 107 of 205 bucket 96: 90% bucket 97: 80% bucket 101: 50% bucket 104: 30% bucket 102: 40% Reserving size (325) for bucket 107 bucket 103: 40% bucket 99: 70% bucket 100: 70% Calculating Z arrays for bucket 107 Getting block 108 of 205 bucket 98: 80% bucket 106: 10% bucket 105: 20% bucket 96: 100% bucket 101: 60% bucket 97: 90% Reserving size (325) for bucket 108 bucket 104: 40% Entering block accumulator loop for bucket 107: bucket 102: 50% bucket 103: 50% Sorting block of length 125 for bucket 96 (Using difference cover) bucket 99: 80% bucket 100: 80% Calculating Z arrays for bucket 108 bucket 106: 20% bucket 105: 30% bucket 101: 70% bucket 97: 100% bucket 104: 50% Getting block 109 of 205 bucket 102: 60% bucket 103: 60% Entering block accumulator loop for bucket 108: bucket 98: 90% Sorting block of length 261 for bucket 97 (Using difference cover) bucket 99: 90% Reserving size (325) for bucket 109 bucket 100: 90% Getting block 110 of 205 bucket 106: 30% bucket 107: 10% bucket 105: 40% bucket 101: 80% bucket 104: 60% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Calculating Z arrays for bucket 109 bucket 102: 70% bucket 103: 70% Reserving size (325) for bucket 110 bucket 98: 100% bucket 99: 100% Returning block of 193 for bucket 87 Sorting block time: 00:00:00 bucket 100: 100% Getting block 111 of 205 Returning block of 261 for bucket 88 bucket 106: 40% bucket 108: 10% Entering block accumulator loop for bucket 109: Calculating Z arrays for bucket 110 bucket 107: 20% bucket 105: 50% Sorting block of length 181 for bucket 98 (Using difference cover) Sorting block of length 188 for bucket 99 (Using difference cover) bucket 101: 90% bucket 104: 70% Returning block of 189 for bucket 94 Sorting block of length 170 for bucket 100 (Using difference cover) bucket 102: 80% bucket 103: 80% Reserving size (325) for bucket 111 Entering block accumulator loop for bucket 110: bucket 106: 50% bucket 108: 20% bucket 107: 30% bucket 105: 60% bucket 101: 100% bucket 104: 80% Calculating Z arrays for bucket 111 Getting block 112 of 205 bucket 102: 90% Sorting block of length 175 for bucket 101 (Using difference cover) bucket 103: 90% bucket 109: 10% Reserving size (325) for bucket 112 Getting block 113 of 205 bucket 106: 60% bucket 108: 30% Entering block accumulator loop for bucket 111: Getting block 114 of 205 bucket 107: 40% bucket 105: 70% bucket 104: 90% Calculating Z arrays for bucket 112 Reserving size (325) for bucket 113 bucket 110: 10% bucket 103: 100% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 109: 20% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Reserving size (325) for bucket 114 Sorting block time: 00:00:00 bucket 106: 70% bucket 108: 40% bucket 102: 100% Calculating Z arrays for bucket 113 Entering block accumulator loop for bucket 112: Sorting block of length 265 for bucket 103 (Using difference cover) Returning block of 300 for bucket 91 Returning block of 126 for bucket 92 Returning block of 239 for bucket 93 bucket 107: 50% Returning block of 273 for bucket 89 Calculating Z arrays for bucket 114 Getting block 115 of 205 Returning block of 159 for bucket 90 Sorting block time: 00:00:00 bucket 104: 100% bucket 105: 80% bucket 110: 20% Sorting block of length 295 for bucket 102 (Using difference cover) bucket 111: 10% bucket 109: 30% Entering block accumulator loop for bucket 113: bucket 108: 50% bucket 106: 80% Reserving size (325) for bucket 115 Entering block accumulator loop for bucket 114: Returning block of 262 for bucket 97 Sorting block of length 244 for bucket 104 (Using difference cover) bucket 107: 60% Getting block 116 of 205 bucket 110: 30% bucket 105: 90% Calculating Z arrays for bucket 115 bucket 112: 10% bucket 111: 20% bucket 109: 40% bucket 108: 60% bucket 106: 90% Sorting block time: 00:00:00 Reserving size (325) for bucket 116 Getting block 117 of 205 Entering block accumulator loop for bucket 115: bucket 107: 70% bucket 113: 10% bucket 110: 40% Returning block of 126 for bucket 96 bucket 112: 20% Calculating Z arrays for bucket 116 bucket 114: 10% Reserving size (325) for bucket 117 bucket 105: 100% Getting block 118 of 205 bucket 111: 30% bucket 109: 50% bucket 108: 70% bucket 106: 100% Calculating Z arrays for bucket 117 Entering block accumulator loop for bucket 116: Sorting block of length 95 for bucket 105 (Using difference cover) bucket 113: 20% bucket 107: 80% bucket 110: 50% Reserving size (325) for bucket 118 bucket 112: 30% Getting block 119 of 205 Sorting block of length 304 for bucket 106 (Using difference cover) bucket 114: 20% Sorting block time: 00:00:00 bucket 115: 10% Entering block accumulator loop for bucket 117: bucket 111: 40% bucket 109: 60% bucket 108: 80% Calculating Z arrays for bucket 118 Reserving size (325) for bucket 119 bucket 113: 30% bucket 110: 60% bucket 112: 40% bucket 107: 90% Returning block of 244 for bucket 95 Getting block 120 of 205 bucket 116: 10% Calculating Z arrays for bucket 119 bucket 114: 30% bucket 115: 20% Entering block accumulator loop for bucket 118: Getting block 121 of 205 bucket 111: 50% bucket 109: 70% bucket 108: 90% Reserving size (325) for bucket 120 bucket 112: 50% bucket 113: 40% bucket 110: 70% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 119: Getting block 122 of 205 bucket 107: 100% bucket 117: 10% Reserving size (325) for bucket 121 bucket 116: 20% bucket 114: 40% Calculating Z arrays for bucket 120 bucket 115: 30% Returning block of 176 for bucket 101 Returning block of 189 for bucket 99 bucket 111: 60% bucket 109: 80% Reserving size (325) for bucket 122 bucket 112: 60% bucket 108: 100% Sorting block of length 301 for bucket 107 (Using difference cover) bucket 113: 50% Calculating Z arrays for bucket 121 bucket 110: 80% bucket 118: 10% Entering block accumulator loop for bucket 120: bucket 117: 20% bucket 116: 30% bucket 114: 50% bucket 115: 40% Calculating Z arrays for bucket 122 Sorting block of length 131 for bucket 108 (Using difference cover) bucket 111: 70% bucket 119: 10% bucket 109: 90% Sorting block time: 00:00:00 bucket 112: 70% Getting block 123 of 205 Entering block accumulator loop for bucket 121: Getting block 124 of 205 bucket 113: 60% bucket 110: 90% bucket 118: 20% Entering block accumulator loop for bucket 122: bucket 117: 30% bucket 116: 40% Returning block of 266 for bucket 103 bucket 114: 60% bucket 115: 50% Reserving size (325) for bucket 123 bucket 111: 80% Sorting block time: 00:00:00 Reserving size (325) for bucket 124 Sorting block time: 00:00:00 bucket 112: 80% bucket 119: 20% bucket 109: 100% Getting block 125 of 205 bucket 120: 10% bucket 113: 70% bucket 110: 100% bucket 118: 30% Calculating Z arrays for bucket 123 bucket 117: 40% Sorting block time: 00:00:00 Returning block of 171 for bucket 100 bucket 116: 50% Returning block of 182 for bucket 98 Calculating Z arrays for bucket 124 bucket 114: 70% bucket 115: 60% Sorting block of length 279 for bucket 109 (Using difference cover) Reserving size (325) for bucket 125 Getting block 126 of 205 bucket 121: 10% bucket 112: 90% bucket 111: 90% Sorting block of length 251 for bucket 110 (Using difference cover) bucket 119: 30% Returning block of 296 for bucket 102 Entering block accumulator loop for bucket 123: bucket 120: 20% bucket 122: 10% bucket 113: 80% bucket 118: 40% bucket 117: 50% Entering block accumulator loop for bucket 124: bucket 116: 60% Calculating Z arrays for bucket 125 Reserving size (325) for bucket 126 bucket 114: 80% bucket 115: 70% bucket 112: 100% bucket 121: 20% bucket 111: 100% bucket 119: 40% Getting block 127 of 205 bucket 120: 30% Calculating Z arrays for bucket 126 bucket 122: 20% Entering block accumulator loop for bucket 125: bucket 113: 90% bucket 118: 50% bucket 117: 60% bucket 116: 70% bucket 114: 90% Sorting block of length 158 for bucket 112 (Using difference cover) Sorting block of length 224 for bucket 111 (Using difference cover) Getting block 128 of 205 Reserving size (325) for bucket 127 bucket 121: 30% bucket 123: 10% Entering block accumulator loop for bucket 126: bucket 119: 50% bucket 115: 80% bucket 124: 10% bucket 120: 40% bucket 122: 30% bucket 113: 100% Sorting block time: 00:00:00 bucket 118: 60% bucket 117: 70% Reserving size (325) for bucket 128 bucket 116: 80% Sorting block time: 00:00:00 bucket 114: 100% Calculating Z arrays for bucket 127 Getting block 129 of 205 bucket 121: 40% bucket 123: 20% Sorting block of length 321 for bucket 113 Sorting block time: 00:00:00 (Using difference cover) bucket 125: 10% Getting block 130 of 205 Returning block of 96 for bucket 105 bucket 119: 60% Calculating Z arrays for bucket 128 bucket 115: 90% bucket 124: 20% bucket 120: 50% Returning block of 305 for bucket 106 bucket 122: 40% Sorting block of length 298 for bucket 114 (Using difference cover) bucket 118: 70% bucket 117: 80% Reserving size (325) for bucket 129 Entering block accumulator loop for bucket 127: bucket 116: 90% Returning block of 132 for bucket 108 Reserving size (325) for bucket 130 bucket 126: 10% bucket 121: 50% bucket 123: 30% bucket 125: 20% Entering block accumulator loop for bucket 128: bucket 119: 70% bucket 115: 100% bucket 124: 30% bucket 120: 60% Calculating Z arrays for bucket 129 bucket 122: 50% Sorting block time: 00:00:00 Calculating Z arrays for bucket 130 bucket 118: 80% bucket 117: 90% bucket 116: 100% Sorting block of length 229 for bucket 115 (Using difference cover) Sorting block time: 00:00:00 bucket 126: 20% bucket 121: 60% bucket 123: 40% bucket 125: 30% Returning block of 245 for bucket 104 Entering block accumulator loop for bucket 129: bucket 119: 80% Entering block accumulator loop for bucket 130: Sorting block of length 118 for bucket 116 (Using difference cover) bucket 124: 40% Getting block 131 of 205 bucket 120: 70% Returning block of 302 for bucket 107 bucket 127: 10% bucket 122: 60% bucket 118: 90% bucket 117: 100% bucket 128: 10% bucket 126: 30% bucket 121: 70% bucket 123: 50% bucket 125: 40% Sorting block time: 00:00:00 Reserving size (325) for bucket 131 Getting block 132 of 205 bucket 119: 90% bucket 124: 50% bucket 120: 80% Sorting block of length 283 for bucket 117 (Using difference cover) bucket 127: 20% Sorting block time: 00:00:00 bucket 122: 70% bucket 118: 100% Getting block 133 of 205 Returning block of 280 for bucket 109 Calculating Z arrays for bucket 131 bucket 129: 10% Reserving size (325) for bucket 132 bucket 128: 20% bucket 130: 10% bucket 126: 40% bucket 121: 80% bucket 123: 60% bucket 125: 50% Getting block 134 of 205 Returning block of 252 for bucket 110 bucket 119: 100% Sorting block of length 249 for bucket 118 (Using difference cover) bucket 124: 60% bucket 120: 90% Reserving size (325) for bucket 133 bucket 127: 30% bucket 122: 80% Entering block accumulator loop for bucket 131: Calculating Z arrays for bucket 132 bucket 129: 20% bucket 130: 20% Reserving size (325) for bucket 134 bucket 128: 30% bucket 126: 50% Sorting block of length 125 for bucket 119 (Using difference cover) bucket 121: 90% bucket 123: 70% bucket 125: 60% Calculating Z arrays for bucket 133 Getting block 135 of 205 bucket 124: 70% bucket 120: 100% Calculating Z arrays for bucket 134 Entering block accumulator loop for bucket 132: bucket 127: 40% bucket 122: 90% bucket 130: 30% bucket 129: 30% bucket 128: 40% bucket 126: 60% Reserving size (325) for bucket 135 Getting block 136 of 205 bucket 121: 100% Entering block accumulator loop for bucket 133: bucket 123: 80% Sorting block of length 246 for bucket 120 (Using difference cover) bucket 125: 70% Entering block accumulator loop for bucket 134: bucket 124: 80% bucket 131: 10% Calculating Z arrays for bucket 135 Reserving size (325) for bucket 136 Sorting block of length 183 for bucket 121 (Using difference cover) bucket 130: 40% bucket 127: 50% bucket 122: 100% bucket 129: 40% bucket 128: 50% bucket 126: 70% Getting block 137 of 205 Calculating Z arrays for bucket 136 bucket 123: 90% Entering block accumulator loop for bucket 135: bucket 125: 80% bucket 124: 90% Sorting block of length 317 for bucket 122 (Using difference cover) bucket 132: 10% bucket 131: 20% Reserving size (325) for bucket 137 bucket 130: 50% Entering block accumulator loop for bucket 136: bucket 129: 50% bucket 127: 60% bucket 133: 10% bucket 128: 60% bucket 126: 80% bucket 134: 10% Calculating Z arrays for bucket 137 bucket 123: 100% bucket 125: 90% bucket 124: 100% bucket 130: 60% bucket 132: 20% bucket 131: 30% Sorting block of length 270 for bucket 123 (Using difference cover) bucket 129: 60% bucket 135: 10% Sorting block of length 282 for bucket 124 (Using difference cover) Entering block accumulator loop for bucket 137: bucket 127: 70% bucket 133: 20% bucket 128: 70% bucket 126: 90% bucket 134: 20% bucket 130: 70% bucket 125: 100% bucket 136: 10% bucket 132: 30% bucket 131: 40% bucket 129: 70% bucket 135: 20% Sorting block of length 111 for bucket 125 (Using difference cover) bucket 127: 80% bucket 133: 30% bucket 128: 80% bucket 130: 80% bucket 126: 100% bucket 134: 30% bucket 136: 20% bucket 137: 10% bucket 129: 80% Sorting block of length 257 for bucket 126 (Using difference cover) bucket 132: 40% bucket 131: 50% bucket 135: 30% bucket 130: 90% bucket 127: 90% bucket 133: 40% bucket 128: 90% bucket 134: 40% bucket 136: 30% bucket 129: 90% bucket 137: 20% bucket 130: 100% bucket 132: 50% Sorting block of length 200 for bucket 130 (Using difference cover) bucket 131: 60% bucket 135: 40% bucket 127: 100% bucket 133: 50% bucket 128: 100% bucket 134: 50% bucket 129: 100% bucket 136: 40% Sorting block of length 277 for bucket 127 (Using difference cover) bucket 137: 30% Sorting block of length 258 for bucket 128 (Using difference cover) bucket 132: 60% Sorting block of length 222 for bucket 129 (Using difference cover) bucket 131: 70% bucket 135: 50% bucket 133: 60% bucket 134: 60% bucket 136: 50% bucket 137: 40% bucket 132: 70% bucket 131: 80% bucket 135: 60% bucket 133: 70% bucket 134: 70% bucket 136: 60% bucket 137: 50% bucket 132: 80% bucket 131: 90% bucket 135: 70% bucket 133: 80% bucket 134: 80% bucket 136: 70% bucket 137: 60% bucket 132: 90% bucket 131: 100% bucket 135: 80% Sorting block of length 297 for bucket 131 (Using difference cover) Sorting block time: 00:00:00 bucket 133: 90% bucket 134: 90% bucket 136: 80% Returning block of 225 for bucket 111 bucket 137: 70% bucket 132: 100% bucket 135: 90% Sorting block of length 280 for bucket 132 (Using difference cover) Sorting block time: 00:00:00 bucket 133: 100% bucket 134: 100% bucket 136: 90% Returning block of 159 for bucket 112 Sorting block of length 60 for bucket 133 (Using difference cover) Sorting block of length 314 for bucket 134 (Using difference cover) bucket 137: 80% bucket 135: 100% bucket 136: 100% Sorting block of length 438 for bucket 135 (Using difference cover) Sorting block of length 247 for bucket 136 (Using difference cover) Getting block 138 of 205 Reserving size (325) for bucket 138 bucket 137: 90% Calculating Z arrays for bucket 138 Entering block accumulator loop for bucket 138: bucket 137: 100% Sorting block of length 137 for bucket 137 (Using difference cover) Getting block 139 of 205 bucket 138: 10% Reserving size (325) for bucket 139 Calculating Z arrays for bucket 139 Entering block accumulator loop for bucket 139: bucket 138: 20% bucket 139: 10% bucket 138: 30% bucket 139: 20% bucket 138: 40% bucket 139: 30% bucket 138: 50% bucket 139: 40% bucket 138: 60% bucket 139: 50% bucket 138: 70% bucket 139: 60% bucket 138: 80% bucket 139: 70% bucket 138: 90% bucket 139: 80% bucket 138: 100% Sorting block of length 301 for bucket 138 (Using difference cover) bucket 139: 90% bucket 139: 100% Sorting block of length 295 for bucket 139 (Using difference cover) Sorting block time: 00:00:00 Returning block of 299 for bucket 114 Getting block 140 of 205 Reserving size (325) for bucket 140 Calculating Z arrays for bucket 140 Entering block accumulator loop for bucket 140: Sorting block time: 00:00:00 bucket 140: 10% Returning block of 230 for bucket 115 bucket 140: 20% bucket 140: 30% bucket 140: 40% Getting block 141 of 205 Reserving size (325) for bucket 141 Calculating Z arrays for bucket 141 Entering block accumulator loop for bucket 141: bucket 140: 50% bucket 140: 60% bucket 141: 10% bucket 140: 70% bucket 141: 20% bucket 140: 80% bucket 141: 30% bucket 140: 90% bucket 141: 40% bucket 140: 100% Sorting block of length 312 for bucket 140 (Using difference cover) bucket 141: 50% Sorting block time: 00:00:00 Returning block of 119 for bucket 116 bucket 141: 60% Sorting block time: 00:00:00 Returning block of 322 for bucket 113 bucket 141: 70% bucket 141: 80% bucket 141: 90% Getting block 142 of 205 Reserving size (325) for bucket 142 Calculating Z arrays for bucket 142 bucket 141: 100% Sorting block of length 194 for bucket 141 (Using difference cover) Entering block accumulator loop for bucket 142: bucket 142: 10% Getting block 143 of 205 bucket 142: 20% Reserving size (325) for bucket 143 Calculating Z arrays for bucket 143 Entering block accumulator loop for bucket 143: bucket 142: 30% bucket 143: 10% bucket 142: 40% bucket 142: 50% bucket 143: 20% bucket 142: 60% bucket 143: 30% bucket 142: 70% bucket 143: 40% bucket 142: 80% bucket 143: 50% bucket 142: 90% bucket 142: 100% bucket 143: 60% Sorting block of length 206 for bucket 142 (Using difference cover) bucket 143: 70% bucket 143: 80% bucket 143: 90% bucket 143: 100% Sorting block of length 192 for bucket 143 (Using difference cover) Sorting block time: 00:00:00 Returning block of 126 for bucket 119 Sorting block time: 00:00:00 Returning block of 250 for bucket 118 Sorting block time: 00:00:00 Getting block 144 of 205 Sorting block time: 00:00:00 Returning block of 284 for bucket 117 Reserving size (325) for bucket 144 Returning block of 247 for bucket 120 Calculating Z arrays for bucket 144 Entering block accumulator loop for bucket 144: Sorting block time: 00:00:00 Returning block of 112 for bucket 125 bucket 144: 10% Sorting block time: 00:00:00 Returning block of 184 for bucket 121 Sorting block time: 00:00:00 Getting block 145 of 205 Returning block of 271 for bucket 123 Reserving size (325) for bucket 145 Calculating Z arrays for bucket 145 bucket 144: 20% Entering block accumulator loop for bucket 145: Getting block 146 of 205 bucket 144: 30% Reserving size (325) for bucket 146 bucket 145: 10% Calculating Z arrays for bucket 146 Entering block accumulator loop for bucket 146: Getting block 147 of 205 Sorting block time: 00:00:00 bucket 144: 40% bucket 145: 20% Reserving size (325) for bucket 147 Returning block of 318 for bucket 122 Calculating Z arrays for bucket 147 bucket 146: 10% bucket 144: 50% Entering block accumulator loop for bucket 147: bucket 145: 30% Getting block 148 of 205 Reserving size (325) for bucket 148 Calculating Z arrays for bucket 148 bucket 146: 20% bucket 144: 60% Entering block accumulator loop for bucket 148: bucket 145: 40% bucket 147: 10% bucket 146: 30% bucket 144: 70% bucket 145: 50% bucket 147: 20% bucket 148: 10% bucket 146: 40% bucket 145: 60% bucket 144: 80% bucket 147: 30% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 148: 20% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 258 for bucket 126 Sorting block time: 00:00:00 Returning block of 223 for bucket 129 Returning block of 283 for bucket 124 Sorting block time: 00:00:00 bucket 146: 50% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 201 for bucket 130 Returning block of 278 for bucket 127 bucket 145: 70% bucket 147: 40% bucket 144: 90% bucket 148: 30% Returning block of 281 for bucket 132 Returning block of 248 for bucket 136 Returning block of 259 for bucket 128 Getting block 149 of 205 bucket 146: 60% bucket 145: 80% bucket 147: 50% bucket 148: 40% bucket 144: 100% Reserving size (325) for bucket 149 Getting block 150 of 205 Sorting block of length 242 for bucket 144 (Using difference cover) Calculating Z arrays for bucket 149 Reserving size (325) for bucket 150 bucket 146: 70% bucket 145: 90% bucket 147: 60% Calculating Z arrays for bucket 150 Sorting block time: 00:00:00 Getting block 151 of 205 Sorting block time: 00:00:00 bucket 148: 50% Entering block accumulator loop for bucket 149: Returning block of 61 for bucket 133 Reserving size (325) for bucket 151 Entering block accumulator loop for bucket 150: Returning block of 315 for bucket 134 bucket 146: 80% bucket 145: 100% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 147: 70% Sorting block time: 00:00:00 Calculating Z arrays for bucket 151 bucket 148: 60% Returning block of 138 for bucket 137 Sorting block of length 245 for bucket 145 (Using difference cover) Getting block 152 of 205 Returning block of 296 for bucket 139 Returning block of 298 for bucket 131 Entering block accumulator loop for bucket 151: bucket 149: 10% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 146: 90% bucket 147: 80% Reserving size (325) for bucket 152 bucket 150: 10% bucket 148: 70% Sorting block time: 00:00:00 Getting block 153 of 205 Sorting block time: 00:00:00 Returning block of 207 for bucket 142 Sorting block time: 00:00:00 Returning block of 313 for bucket 140 Calculating Z arrays for bucket 152 Sorting block time: 00:00:00 Returning block of 193 for bucket 143 bucket 149: 20% Reserving size (325) for bucket 153 Getting block 154 of 205 bucket 146: 100% Returning block of 302 for bucket 138 bucket 147: 90% Returning block of 195 for bucket 141 bucket 150: 20% bucket 148: 80% Returning block of 439 for bucket 135 bucket 151: 10% Entering block accumulator loop for bucket 152: Calculating Z arrays for bucket 153 Reserving size (325) for bucket 154 Sorting block of length 85 for bucket 146 (Using difference cover) Getting block 155 of 205 bucket 149: 30% bucket 147: 100% Sorting block time: 00:00:00 Getting block 156 of 205 Calculating Z arrays for bucket 154 bucket 150: 30% bucket 148: 90% Entering block accumulator loop for bucket 153: Reserving size (325) for bucket 155 bucket 151: 20% Sorting block of length 250 for bucket 147 (Using difference cover) Returning block of 243 for bucket 144 Reserving size (325) for bucket 156 Entering block accumulator loop for bucket 154: bucket 149: 40% Calculating Z arrays for bucket 155 bucket 152: 10% bucket 150: 40% bucket 148: 100% Calculating Z arrays for bucket 156 Getting block 157 of 205 bucket 151: 30% Entering block accumulator loop for bucket 155: Sorting block of length 292 for bucket 148 (Using difference cover) Sorting block time: 00:00:00 Reserving size (325) for bucket 157 bucket 153: 10% bucket 149: 50% Entering block accumulator loop for bucket 156: bucket 152: 20% Getting block 158 of 205 bucket 150: 50% Returning block of 246 for bucket 145 Calculating Z arrays for bucket 157 bucket 154: 10% bucket 151: 40% Reserving size (325) for bucket 158 bucket 153: 20% bucket 149: 60% Entering block accumulator loop for bucket 157: bucket 152: 30% bucket 155: 10% Calculating Z arrays for bucket 158 Getting block 159 of 205 bucket 150: 60% bucket 154: 20% bucket 151: 50% Reserving size (325) for bucket 159 bucket 156: 10% Entering block accumulator loop for bucket 158: bucket 153: 30% bucket 149: 70% Calculating Z arrays for bucket 159 bucket 152: 40% bucket 155: 20% bucket 150: 70% bucket 157: 10% bucket 154: 30% bucket 151: 60% Entering block accumulator loop for bucket 159: bucket 156: 20% bucket 153: 40% Getting block 160 of 205 bucket 149: 80% bucket 152: 50% Reserving size (325) for bucket 160 bucket 158: 10% bucket 155: 30% bucket 150: 80% bucket 157: 20% Calculating Z arrays for bucket 160 bucket 154: 40% bucket 151: 70% bucket 156: 30% bucket 153: 50% bucket 159: 10% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 149: 90% Getting block 161 of 205 bucket 152: 60% Entering block accumulator loop for bucket 160: bucket 158: 20% Sorting block time: 00:00:00 Returning block of 251 for bucket 147 Returning block of 86 for bucket 146 bucket 150: 90% bucket 155: 40% bucket 157: 30% Reserving size (325) for bucket 161 bucket 154: 50% bucket 151: 80% bucket 156: 40% bucket 153: 60% Returning block of 293 for bucket 148 bucket 159: 20% bucket 149: 100% bucket 152: 70% bucket 158: 30% Calculating Z arrays for bucket 161 bucket 150: 100% Getting block 162 of 205 bucket 155: 50% bucket 157: 40% Sorting block of length 220 for bucket 149 (Using difference cover) bucket 154: 60% bucket 160: 10% bucket 151: 90% Getting block 163 of 205 bucket 156: 50% Sorting block of length 181 for bucket 150 (Using difference cover) bucket 153: 70% Reserving size (325) for bucket 162 Entering block accumulator loop for bucket 161: bucket 159: 30% bucket 152: 80% bucket 158: 40% Reserving size (325) for bucket 163 bucket 157: 50% bucket 155: 60% Getting block 164 of 205 bucket 154: 70% Calculating Z arrays for bucket 162 bucket 160: 20% bucket 151: 100% bucket 156: 60% Calculating Z arrays for bucket 163 Getting block 165 of 205 bucket 153: 80% Reserving size (325) for bucket 164 bucket 159: 40% bucket 152: 90% bucket 158: 50% Sorting block of length 242 for bucket 151 (Using difference cover) Entering block accumulator loop for bucket 162: bucket 157: 60% Reserving size (325) for bucket 165 bucket 155: 70% Entering block accumulator loop for bucket 163: Calculating Z arrays for bucket 164 bucket 154: 80% bucket 161: 10% bucket 160: 30% Getting block 166 of 205 bucket 156: 70% Calculating Z arrays for bucket 165 bucket 153: 90% bucket 159: 50% bucket 152: 100% bucket 158: 60% Entering block accumulator loop for bucket 164: bucket 157: 70% Sorting block time: 00:00:00 Reserving size (325) for bucket 166 bucket 155: 80% Entering block accumulator loop for bucket 165: bucket 154: 90% bucket 161: 20% Sorting block of length 91 for bucket 152 (Using difference cover) bucket 160: 40% Returning block of 221 for bucket 149 bucket 162: 10% Calculating Z arrays for bucket 166 bucket 156: 80% bucket 153: 100% bucket 163: 10% bucket 159: 60% bucket 158: 70% bucket 157: 80% bucket 155: 90% bucket 154: 100% bucket 161: 30% Sorting block of length 321 for bucket 153 (Using difference cover) bucket 164: 10% Entering block accumulator loop for bucket 166: bucket 160: 50% bucket 162: 20% Sorting block of length 232 for bucket 154 (Using difference cover) Sorting block time: 00:00:00 bucket 156: 90% bucket 165: 10% bucket 163: 20% bucket 159: 70% bucket 158: 80% Getting block 167 of 205 bucket 157: 90% Getting block 168 of 205 bucket 155: 100% bucket 161: 40% Returning block of 182 for bucket 150 bucket 164: 20% bucket 160: 60% bucket 162: 30% Reserving size (325) for bucket 167 bucket 165: 20% bucket 156: 100% Reserving size (325) for bucket 168 bucket 163: 30% Sorting block of length 257 for bucket 155 (Using difference cover) bucket 166: 10% bucket 159: 80% bucket 158: 90% Getting block 169 of 205 bucket 157: 100% Calculating Z arrays for bucket 167 bucket 161: 50% Sorting block of length 305 for bucket 156 (Using difference cover) Calculating Z arrays for bucket 168 bucket 164: 30% bucket 160: 70% bucket 162: 40% bucket 165: 30% Reserving size (325) for bucket 169 bucket 163: 40% Sorting block of length 309 for bucket 157 (Using difference cover) Getting block 170 of 205 bucket 166: 20% Entering block accumulator loop for bucket 167: bucket 159: 90% bucket 158: 100% Entering block accumulator loop for bucket 168: Getting block 171 of 205 bucket 161: 60% Calculating Z arrays for bucket 169 bucket 164: 40% Reserving size (325) for bucket 170 bucket 160: 80% Sorting block time: 00:00:00 bucket 162: 50% bucket 165: 40% Sorting block of length 270 for bucket 158 (Using difference cover) bucket 163: 50% Getting block 172 of 205 Reserving size (325) for bucket 171 bucket 166: 30% bucket 159: 100% Calculating Z arrays for bucket 170 Entering block accumulator loop for bucket 169: Returning block of 243 for bucket 151 bucket 161: 70% bucket 164: 50% bucket 160: 90% Reserving size (325) for bucket 172 bucket 162: 60% Calculating Z arrays for bucket 171 bucket 165: 50% bucket 167: 10% Sorting block of length 120 for bucket 159 (Using difference cover) bucket 168: 10% bucket 163: 60% Entering block accumulator loop for bucket 170: Getting block 173 of 205 bucket 166: 40% Calculating Z arrays for bucket 172 bucket 161: 80% Entering block accumulator loop for bucket 171: bucket 164: 60% bucket 160: 100% bucket 162: 70% Getting block 174 of 205 bucket 165: 60% Reserving size (325) for bucket 173 bucket 167: 20% Entering block accumulator loop for bucket 172: bucket 168: 20% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 169: 10% Getting block 175 of 205 Sorting block of length 264 for bucket 160 (Using difference cover) bucket 163: 70% bucket 166: 50% Reserving size (325) for bucket 174 bucket 161: 90% bucket 164: 70% Calculating Z arrays for bucket 173 bucket 162: 80% bucket 170: 10% Returning block of 92 for bucket 152 Returning block of 322 for bucket 153 bucket 165: 70% Reserving size (325) for bucket 175 bucket 167: 30% bucket 171: 10% Getting block 176 of 205 bucket 168: 30% Calculating Z arrays for bucket 174 bucket 169: 20% bucket 163: 80% bucket 166: 60% Entering block accumulator loop for bucket 173: Sorting block time: 00:00:00 bucket 161: 100% bucket 164: 80% Calculating Z arrays for bucket 175 bucket 162: 90% bucket 172: 10% bucket 170: 20% Reserving size (325) for bucket 176 bucket 165: 80% Getting block 177 of 205 Entering block accumulator loop for bucket 174: bucket 167: 40% bucket 171: 20% Returning block of 233 for bucket 154 Sorting block of length 315 for bucket 161 (Using difference cover) bucket 168: 40% Getting block 178 of 205 bucket 169: 30% Entering block accumulator loop for bucket 175: bucket 163: 90% bucket 166: 70% Calculating Z arrays for bucket 176 bucket 164: 90% Reserving size (325) for bucket 177 bucket 162: 100% bucket 172: 20% bucket 170: 30% bucket 165: 90% Reserving size (325) for bucket 178 bucket 167: 50% bucket 173: 10% bucket 171: 30% Calculating Z arrays for bucket 177 bucket 168: 50% Getting block 179 of 205 Entering block accumulator loop for bucket 176: Sorting block of length 116 for bucket 162 Sorting block time: 00:00:00 (Using difference cover) bucket 169: 40% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 163: 100% Sorting block time: 00:00:00 bucket 166: 80% Calculating Z arrays for bucket 178 bucket 164: 100% Getting block 180 of 205 bucket 174: 10% bucket 172: 30% bucket 170: 40% bucket 165: 100% Entering block accumulator loop for bucket 177: Reserving size (325) for bucket 179 bucket 167: 60% bucket 173: 20% Returning block of 306 for bucket 156 bucket 175: 10% bucket 171: 40% Returning block of 310 for bucket 157 bucket 168: 60% Returning block of 271 for bucket 158 Sorting block of length 283 for bucket 163 (Using difference cover) Returning block of 258 for bucket 155 Sorting block of length 264 for bucket 164 (Using difference cover) Entering block accumulator loop for bucket 178: Reserving size (325) for bucket 180 bucket 169: 50% bucket 166: 90% Sorting block of length 273 for bucket 165 (Using difference cover) Calculating Z arrays for bucket 179 bucket 174: 20% bucket 172: 40% bucket 170: 50% Getting block 181 of 205 bucket 176: 10% bucket 167: 70% bucket 173: 30% bucket 175: 20% bucket 171: 50% bucket 168: 70% Calculating Z arrays for bucket 180 Entering block accumulator loop for bucket 179: Reserving size (325) for bucket 181 bucket 169: 60% bucket 166: 100% bucket 177: 10% bucket 174: 30% bucket 172: 50% bucket 170: 60% Getting block 182 of 205 Calculating Z arrays for bucket 181 Entering block accumulator loop for bucket 180: bucket 176: 20% bucket 167: 80% Sorting block of length 229 for bucket 166 (Using difference cover) bucket 173: 40% Getting block 183 of 205 bucket 175: 30% bucket 171: 60% bucket 168: 80% bucket 178: 10% Reserving size (325) for bucket 182 bucket 169: 70% Entering block accumulator loop for bucket 181: bucket 177: 20% bucket 174: 40% bucket 172: 60% bucket 170: 70% bucket 179: 10% Reserving size (325) for bucket 183 bucket 176: 30% Sorting block time: 00:00:00 bucket 167: 90% Calculating Z arrays for bucket 182 bucket 173: 50% bucket 175: 40% bucket 171: 70% bucket 168: 90% Sorting block time: 00:00:00 bucket 178: 20% bucket 180: 10% bucket 169: 80% Calculating Z arrays for bucket 183 Getting block 184 of 205 Returning block of 121 for bucket 159 bucket 177: 30% bucket 174: 50% bucket 172: 70% bucket 170: 80% Entering block accumulator loop for bucket 182: bucket 179: 20% Returning block of 265 for bucket 160 Getting block 185 of 205 bucket 176: 40% bucket 167: 100% bucket 173: 60% bucket 181: 10% bucket 175: 50% Reserving size (325) for bucket 184 bucket 171: 80% Entering block accumulator loop for bucket 183: bucket 168: 100% bucket 178: 30% bucket 180: 20% bucket 169: 90% bucket 177: 40% bucket 174: 60% Reserving size (325) for bucket 185 bucket 172: 80% bucket 170: 90% Sorting block of length 183 for bucket 167 (Using difference cover) bucket 179: 30% Calculating Z arrays for bucket 184 bucket 176: 50% Sorting block of length 248 for bucket 168 (Using difference cover) bucket 173: 70% bucket 181: 20% bucket 175: 60% bucket 171: 90% Calculating Z arrays for bucket 185 bucket 178: 40% bucket 180: 30% bucket 169: 100% bucket 177: 50% bucket 174: 70% bucket 182: 10% bucket 172: 90% bucket 170: 100% Entering block accumulator loop for bucket 184: Getting block 186 of 205 bucket 179: 40% bucket 176: 60% bucket 183: 10% Entering block accumulator loop for bucket 185: Sorting block of length 194 for bucket 169 (Using difference cover) bucket 173: 80% bucket 181: 30% bucket 175: 70% bucket 171: 100% bucket 178: 50% Sorting block of length 150 for bucket 170 (Using difference cover) Getting block 187 of 205 Sorting block time: 00:00:00 bucket 180: 40% Reserving size (325) for bucket 186 bucket 177: 60% bucket 174: 80% bucket 172: 100% bucket 182: 20% bucket 179: 50% bucket 176: 70% Sorting block of length 253 for bucket 171 (Using difference cover) bucket 183: 20% Reserving size (325) for bucket 187 Returning block of 316 for bucket 161 bucket 173: 90% bucket 181: 40% Calculating Z arrays for bucket 186 bucket 175: 80% bucket 178: 60% Sorting block of length 149 for bucket 172 (Using difference cover) bucket 184: 10% bucket 180: 50% bucket 177: 70% bucket 174: 90% Calculating Z arrays for bucket 187 bucket 185: 10% bucket 182: 30% bucket 179: 60% bucket 176: 80% Entering block accumulator loop for bucket 186: bucket 183: 30% bucket 173: 100% bucket 181: 50% bucket 175: 90% bucket 178: 70% Entering block accumulator loop for bucket 187: bucket 184: 20% bucket 180: 60% Sorting block of length 311 for bucket 173 (Using difference cover) bucket 177: 80% bucket 174: 100% bucket 185: 20% bucket 182: 40% bucket 179: 70% bucket 176: 90% bucket 183: 40% bucket 181: 60% bucket 175: 100% Sorting block of length 256 for bucket 174 (Using difference cover) bucket 178: 80% bucket 186: 10% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 184: 30% Sorting block time: 00:00:00 bucket 180: 70% Sorting block time: 00:00:00 Getting block 188 of 205 bucket 177: 90% Sorting block of length 262 for bucket 175 (Using difference cover) bucket 185: 30% bucket 187: 10% bucket 182: 50% bucket 179: 80% Returning block of 265 for bucket 164 Returning block of 274 for bucket 165 bucket 176: 100% Returning block of 117 for bucket 162 bucket 181: 70% bucket 183: 50% Returning block of 284 for bucket 163 Reserving size (325) for bucket 188 bucket 178: 90% bucket 186: 20% bucket 184: 40% bucket 180: 80% bucket 177: 100% bucket 185: 40% Sorting block of length 296 for bucket 176 (Using difference cover) bucket 187: 20% bucket 182: 60% bucket 179: 90% Calculating Z arrays for bucket 188 bucket 181: 80% Sorting block of length 80 for bucket 177 (Using difference cover) bucket 183: 60% bucket 178: 100% bucket 186: 30% bucket 184: 50% bucket 180: 90% bucket 185: 50% Entering block accumulator loop for bucket 188: Sorting block of length 310 for bucket 178 (Using difference cover) bucket 187: 30% bucket 182: 70% bucket 179: 100% bucket 181: 90% Getting block 189 of 205 bucket 183: 70% bucket 186: 40% Sorting block of length 292 for bucket 179 (Using difference cover) bucket 184: 60% bucket 185: 60% bucket 180: 100% Sorting block time: 00:00:00 Reserving size (325) for bucket 189 bucket 187: 40% bucket 182: 80% bucket 181: 100% bucket 188: 10% Sorting block of length 322 for bucket 180 (Using difference cover) Getting block 190 of 205 Returning block of 230 for bucket 166 bucket 183: 80% bucket 186: 50% Calculating Z arrays for bucket 189 Sorting block of length 156 for bucket 181 (Using difference cover) bucket 184: 70% bucket 185: 70% Reserving size (325) for bucket 190 bucket 187: 50% bucket 182: 90% bucket 188: 20% Getting block 191 of 205 Entering block accumulator loop for bucket 189: Calculating Z arrays for bucket 190 Getting block 192 of 205 bucket 186: 60% bucket 183: 90% Reserving size (325) for bucket 191 bucket 184: 80% bucket 185: 80% Reserving size (325) for bucket 192 Entering block accumulator loop for bucket 190: bucket 187: 60% Calculating Z arrays for bucket 191 bucket 182: 100% bucket 188: 30% Calculating Z arrays for bucket 192 bucket 186: 70% Sorting block of length 176 for bucket 182 (Using difference cover) bucket 189: 10% Entering block accumulator loop for bucket 191: bucket 183: 100% Getting block 193 of 205 bucket 185: 90% bucket 184: 90% Entering block accumulator loop for bucket 192: bucket 187: 70% Sorting block of length 319 for bucket 183 (Using difference cover) Reserving size (325) for bucket 193 bucket 190: 10% bucket 188: 40% bucket 186: 80% bucket 189: 20% Calculating Z arrays for bucket 193 bucket 185: 100% bucket 184: 100% bucket 187: 80% Sorting block of length 214 for bucket 185 (Using difference cover) bucket 191: 10% Sorting block of length 296 for bucket 184 (Using difference cover) Entering block accumulator loop for bucket 193: bucket 190: 20% bucket 192: 10% bucket 186: 90% bucket 189: 30% bucket 188: 50% bucket 187: 90% bucket 191: 20% bucket 192: 20% bucket 190: 30% bucket 186: 100% bucket 189: 40% Sorting block of length 312 for bucket 186 (Using difference cover) bucket 193: 10% bucket 187: 100% bucket 188: 60% bucket 191: 30% bucket 192: 30% Sorting block of length 112 for bucket 187 (Using difference cover) bucket 190: 40% bucket 189: 50% bucket 193: 20% bucket 192: 40% bucket 188: 70% bucket 191: 40% bucket 189: 60% bucket 190: 50% bucket 193: 30% bucket 192: 50% bucket 188: 80% bucket 191: 50% bucket 189: 70% bucket 190: 60% bucket 192: 60% bucket 193: 40% bucket 189: 80% bucket 188: 90% bucket 191: 60% bucket 192: 70% bucket 190: 70% bucket 193: 50% bucket 189: 90% bucket 192: 80% bucket 188: 100% bucket 191: 70% Sorting block of length 232 for bucket 188 (Using difference cover) bucket 190: 80% bucket 193: 60% bucket 189: 100% bucket 192: 90% Sorting block of length 133 for bucket 189 (Using difference cover) bucket 191: 80% bucket 190: 90% bucket 193: 70% bucket 192: 100% Sorting block of length 312 for bucket 192 (Using difference cover) bucket 191: 90% bucket 190: 100% bucket 193: 80% Sorting block of length 197 for bucket 190 (Using difference cover) bucket 191: 100% Sorting block of length 195 for bucket 191 (Using difference cover) bucket 193: 90% bucket 193: 100% Sorting block of length 149 for bucket 193 (Using difference cover) Sorting block time: 00:00:00 Returning block of 184 for bucket 167 Getting block 194 of 205 Reserving size (325) for bucket 194 Calculating Z arrays for bucket 194 Entering block accumulator loop for bucket 194: bucket 194: 10% bucket 194: 20% bucket 194: 30% bucket 194: 40% bucket 194: 50% bucket 194: 60% bucket 194: 70% bucket 194: 80% bucket 194: 90% bucket 194: 100% Sorting block of length 301 for bucket 194 (Using difference cover) Sorting block time: 00:00:00 Returning block of 249 for bucket 168 Sorting block time: 00:00:00 Returning block of 195 for bucket 169 Getting block 195 of 205 Reserving size (325) for bucket 195 Calculating Z arrays for bucket 195 Entering block accumulator loop for bucket 195: Sorting block time: 00:00:00 Returning block of 151 for bucket 170 Getting block 196 of 205 Reserving size (325) for bucket 196 Calculating Z arrays for bucket 196 bucket 195: 10% Entering block accumulator loop for bucket 196: bucket 195: 20% bucket 196: 10% bucket 195: 30% bucket 196: 20% Getting block 197 of 205 Reserving size (325) for bucket 197 Calculating Z arrays for bucket 197 Sorting block time: 00:00:00 Returning block of 312 for bucket 173 Entering block accumulator loop for bucket 197: bucket 195: 40% bucket 196: 30% bucket 197: 10% bucket 195: 50% bucket 196: 40% bucket 197: 20% bucket 195: 60% bucket 196: 50% bucket 197: 30% bucket 195: 70% bucket 196: 60% Getting block 198 of 205 Reserving size (325) for bucket 198 Calculating Z arrays for bucket 198 bucket 197: 40% Entering block accumulator loop for bucket 198: bucket 195: 80% bucket 196: 70% bucket 197: 50% bucket 195: 90% bucket 196: 80% bucket 198: 10% bucket 197: 60% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 263 for bucket 175 Sorting block time: 00:00:00 Returning block of 177 for bucket 182 Sorting block time: 00:00:00 bucket 195: 100% bucket 196: 90% Sorting block time: 00:00:00 Returning block of 150 for bucket 193 Sorting block time: 00:00:00 bucket 198: 20% bucket 197: 70% Returning block of 254 for bucket 171 Sorting block of length 88 for bucket 195 (Using difference cover) Returning block of 257 for bucket 174 Returning block of 150 for bucket 172 bucket 196: 100% bucket 197: 80% bucket 198: 30% Sorting block of length 313 for bucket 196 (Using difference cover) Getting block 199 of 205 Reserving size (325) for bucket 199 Calculating Z arrays for bucket 199 bucket 197: 90% Entering block accumulator loop for bucket 199: bucket 198: 40% Sorting block time: 00:00:00 Returning block of 313 for bucket 192 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 197: 100% Returning block of 297 for bucket 176 Sorting block time: 00:00:00 Returning block of 293 for bucket 179 Sorting block time: 00:00:00 Returning block of 323 for bucket 180 Returning block of 81 for bucket 177 Returning block of 311 for bucket 178 Returning block of 157 for bucket 181 bucket 199: 10% Sorting block of length 223 for bucket 197 (Using difference cover) Returning block of 313 for bucket 186 bucket 198: 50% Returning block of 113 for bucket 187 Getting block 200 of 205 bucket 199: 20% Getting block 201 of 205 Reserving size (325) for bucket 200 Reserving size (325) for bucket 201 bucket 198: 60% Calculating Z arrays for bucket 200 Getting block 202 of 205 Calculating Z arrays for bucket 201 bucket 199: 30% Reserving size (325) for bucket 202 Entering block accumulator loop for bucket 200: Sorting block time: 00:00:00 Sorting block time: 00:00:00 Calculating Z arrays for bucket 202 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 201: Returning block of 134 for bucket 189 Returning block of 198 for bucket 190 bucket 198: 70% Returning block of 215 for bucket 185 Returning block of 233 for bucket 188 Returning block of 297 for bucket 184 Entering block accumulator loop for bucket 202: bucket 199: 40% bucket 200: 10% bucket 198: 80% Getting block 203 of 205 Reserving size (325) for bucket 203 Calculating Z arrays for bucket 203 bucket 201: 10% bucket 199: 50% Entering block accumulator loop for bucket 203: bucket 200: 20% bucket 202: 10% bucket 198: 90% bucket 201: 20% bucket 199: 60% bucket 200: 30% bucket 202: 20% bucket 203: 10% bucket 198: 100% Sorting block of length 237 for bucket 198 (Using difference cover) Getting block 204 of 205 bucket 201: 30% bucket 199: 70% Reserving size (325) for bucket 204 bucket 200: 40% bucket 202: 30% Calculating Z arrays for bucket 204 bucket 203: 20% Getting block 205 of 205 Entering block accumulator loop for bucket 204: Reserving size (325) for bucket 205 bucket 201: 40% bucket 199: 80% Calculating Z arrays for bucket 205 bucket 200: 50% bucket 202: 40% bucket 203: 30% Entering block accumulator loop for bucket 205: bucket 201: 50% bucket 199: 90% bucket 204: 10% bucket 200: 60% bucket 205: 10% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 202: 50% bucket 203: 40% Sorting block time: 00:00:00 Returning block of 196 for bucket 191 Returning block of 89 for bucket 195 bucket 201: 60% Sorting block time: 00:00:00 Returning block of 320 for bucket 183 Sorting block time: 00:00:00 bucket 199: 100% bucket 205: 20% bucket 204: 20% bucket 200: 70% bucket 202: 60% Returning block of 314 for bucket 196 bucket 203: 50% Returning block of 302 for bucket 194 Sorting block of length 322 for bucket 199 (Using difference cover) bucket 201: 70% bucket 205: 30% bucket 204: 30% bucket 200: 80% bucket 202: 70% bucket 203: 60% Sorting block time: 00:00:00 Returning block of 224 for bucket 197 bucket 201: 80% bucket 205: 40% bucket 204: 40% bucket 200: 90% bucket 202: 80% bucket 203: 70% bucket 205: 50% bucket 201: 90% bucket 204: 50% bucket 200: 100% bucket 202: 90% Sorting block of length 260 for bucket 200 (Using difference cover) bucket 203: 80% bucket 205: 60% bucket 201: 100% Sorting block of length 273 for bucket 201 (Using difference cover) bucket 204: 60% bucket 202: 100% Sorting block of length 315 for bucket 202 (Using difference cover) bucket 205: 70% bucket 203: 90% Sorting block time: 00:00:00 Returning block of 238 for bucket 198 bucket 204: 70% bucket 205: 80% bucket 203: 100% Sorting block of length 99 for bucket 203 (Using difference cover) bucket 205: 90% bucket 204: 80% bucket 205: 100% Sorting block of length 314 for bucket 205 (Using difference cover) bucket 204: 90% bucket 204: 100% Sorting block of length 241 for bucket 204 (Using difference cover) Sorting block time: 00:00:00 Returning block of 323 for bucket 199 Sorting block time: 00:00:00 Returning block of 261 for bucket 200 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 100 for bucket 203 Sorting block time: 00:00:00 Returning block of 274 for bucket 201 Returning block of 315 for bucket 205 Returning block of 316 for bucket 202 Sorting block time: 00:00:00 Returning block of 242 for bucket 204 Exited Ebwt loop fchr[A]: 0 fchr[C]: 12334 fchr[G]: 12334 fchr[T]: 25154 fchr[$]: 48502 Exiting Ebwt::buildToDisk() Returning from initFromVector Wrote 4210679 bytes to primary EBWT file: BS_CT.rev.1.bt2 Wrote 12132 bytes to secondary EBWT file: BS_CT.rev.2.bt2 Re-opening _in1 and _in2 as input streams Returning from Ebwt constructor Headers: len: 48502 bwtLen: 48503 sz: 12126 bwtSz: 12126 lineRate: 6 offRate: 4 offMask: 0xfffffff0 ftabChars: 10 eftabLen: 20 eftabSz: 80 ftabLen: 1048577 ftabSz: 4194308 offsLen: 3032 offsSz: 12128 lineSz: 64 sideSz: 64 sideBwtSz: 48 sideBwtLen: 192 numSides: 253 numLines: 253 ebwtTotLen: 16192 ebwtTotSz: 16192 color: 0 reverse: 1 Total time for backward call to driver() for mirror index: 00:00:00 Preparing indexing of GA converted genome in /gscratch/srlab/sr320/data/lambda/Bisulfite_Genome/GA_conversion/ Child process: Starting to index G->A converted genome with the following command: /gscratch/srlab/programs/bowtie2-2.3.4.1-linux-x86_64/bowtie2-build -f genome_mfa.GA_conversion.fa BS_GA --threads 28 Settings: Output files: "BS_GA.*.bt2" Line rate: 6 (line is 64 bytes) Lines per side: 1 (side is 64 bytes) Offset rate: 4 (one in 16) FTable chars: 10 Strings: unpacked Max bucket size: default Max bucket size, sqrt multiplier: default Max bucket size, len divisor: 112 Difference-cover sample period: 1024 Endianness: little Actual local endianness: little Sanity checking: disabled Assertions: disabled Random seed: 0 Sizeofs: void*:8, int:4, long:8, size_t:8 Input files DNA, FASTA: genome_mfa.GA_conversion.fa Building a SMALL index Reading reference sizes Time reading reference sizes: 00:00:00 Calculating joined length Writing header Reserving space for joined string Joining reference sequences Time to join reference sequences: 00:00:00 bmax according to bmaxDivN setting: 433 Using parameters --bmax 325 --dcv 1024 Doing ahead-of-time memory usage test Passed! Constructing with these parameters: --bmax 325 --dcv 1024 Constructing suffix-array element generator Building DifferenceCoverSample Building sPrime Building sPrimeOrder V-Sorting samples V-Sorting samples time: 00:00:00 Allocating rank array Ranking v-sort output Ranking v-sort output time: 00:00:00 Invoking Larsson-Sadakane on ranks Invoking Larsson-Sadakane on ranks time: 00:00:00 Sanity-checking and returning Building samples Reserving space for 300 sample suffixes Generating random suffixes QSorting 300 sample offsets, eliminating duplicates QSorting sample offsets, eliminating duplicates time: 00:00:00 Multikey QSorting 299 samples (Using difference cover) Multikey QSorting samples time: 00:00:00 Calculating bucket sizes Splitting and merging Splitting and merging time: 00:00:00 Split 45, merged 140; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 28, merged 24; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 13, merged 14; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 5, merged 10; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 2, merged 3; iterating... Avg bucket size: 239.114 (target: 324) Converting suffix-array elements to index image Allocating ftab, absorbFtab Entering Ebwt loop Getting block 1 of 202 Reserving size (325) for bucket 1 Getting block 2 of 202 Getting block 3 of 202 Getting block 4 of 202 Calculating Z arrays for bucket 1 Reserving size (325) for bucket 2 Reserving size (325) for bucket 3 Reserving size (325) for bucket 4 Getting block 5 of 202 Getting block 6 of 202 Getting block 7 of 202 Getting block 8 of 202 Getting block 9 of 202 Getting block 10 of 202 Getting block 11 of 202 Getting block 12 of 202 Calculating Z arrays for bucket 2 Entering block accumulator loop for bucket 1: Getting block 13 of 202 Getting block 14 of 202 Getting block 15 of 202 Getting block 16 of 202 Getting block 17 of 202 Getting block 18 of 202 Getting block 19 of 202 Getting block 20 of 202 Getting block 21 of 202 Getting block 22 of 202 Getting block 23 of 202 Getting block 24 of 202 Getting block 25 of 202 Getting block 26 of 202 Getting block 27 of 202 Calculating Z arrays for bucket 3 Calculating Z arrays for bucket 4 Reserving size (325) for bucket 5 Reserving size (325) for bucket 6 Reserving size (325) for bucket 7 Reserving size (325) for bucket 8 Reserving size (325) for bucket 9 Reserving size (325) for bucket 10 Reserving size (325) for bucket 11 Reserving size (325) for bucket 12 Reserving size (325) for bucket 13 Entering block accumulator loop for bucket 2: Reserving size (325) for bucket 14 Reserving size (325) for bucket 15 Reserving size (325) for bucket 16 Reserving size (325) for bucket 17 Reserving size (325) for bucket 18 Reserving size (325) for bucket 19 Reserving size (325) for bucket 20 Reserving size (325) for bucket 21 Reserving size (325) for bucket 22 Reserving size (325) for bucket 23 Reserving size (325) for bucket 24 Reserving size (325) for bucket 25 Reserving size (325) for bucket 26 Reserving size (325) for bucket 27 Calculating Z arrays for bucket 5 Entering block accumulator loop for bucket 3: Calculating Z arrays for bucket 6 Entering block accumulator loop for bucket 4: Calculating Z arrays for bucket 7 Calculating Z arrays for bucket 8 Calculating Z arrays for bucket 9 Calculating Z arrays for bucket 10 Calculating Z arrays for bucket 11 Calculating Z arrays for bucket 12 Calculating Z arrays for bucket 13 Calculating Z arrays for bucket 14 Calculating Z arrays for bucket 15 Calculating Z arrays for bucket 16 bucket 1: 10% Calculating Z arrays for bucket 17 Calculating Z arrays for bucket 18 Calculating Z arrays for bucket 19 Calculating Z arrays for bucket 20 Calculating Z arrays for bucket 21 Calculating Z arrays for bucket 22 Calculating Z arrays for bucket 23 Calculating Z arrays for bucket 24 Calculating Z arrays for bucket 25 Calculating Z arrays for bucket 26 Calculating Z arrays for bucket 27 Entering block accumulator loop for bucket 5: Entering block accumulator loop for bucket 6: Entering block accumulator loop for bucket 7: Entering block accumulator loop for bucket 8: Entering block accumulator loop for bucket 9: Entering block accumulator loop for bucket 10: Entering block accumulator loop for bucket 11: Entering block accumulator loop for bucket 12: Entering block accumulator loop for bucket 13: Entering block accumulator loop for bucket 14: Entering block accumulator loop for bucket 15: Entering block accumulator loop for bucket 16: bucket 2: 10% Entering block accumulator loop for bucket 17: Entering block accumulator loop for bucket 18: Entering block accumulator loop for bucket 19: bucket 1: 20% Entering block accumulator loop for bucket 20: Entering block accumulator loop for bucket 21: Entering block accumulator loop for bucket 22: Entering block accumulator loop for bucket 23: Entering block accumulator loop for bucket 24: Entering block accumulator loop for bucket 25: Entering block accumulator loop for bucket 26: Entering block accumulator loop for bucket 27: bucket 3: 10% bucket 4: 10% bucket 2: 20% bucket 1: 30% bucket 5: 10% bucket 6: 10% bucket 7: 10% bucket 10: 10% bucket 3: 20% bucket 9: 10% bucket 8: 10% bucket 4: 20% bucket 11: 10% bucket 12: 10% bucket 13: 10% bucket 15: 10% bucket 14: 10% bucket 2: 30% bucket 20: 10% bucket 19: 10% bucket 16: 10% bucket 18: 10% bucket 17: 10% bucket 21: 10% bucket 1: 40% bucket 24: 10% bucket 25: 10% bucket 22: 10% bucket 23: 10% bucket 5: 20% bucket 26: 10% bucket 27: 10% bucket 6: 20% bucket 7: 20% bucket 10: 20% bucket 3: 30% bucket 9: 20% bucket 8: 20% bucket 4: 30% bucket 11: 20% bucket 12: 20% bucket 13: 20% bucket 15: 20% bucket 2: 40% bucket 14: 20% bucket 20: 20% bucket 19: 20% bucket 16: 20% bucket 18: 20% bucket 17: 20% bucket 1: 50% bucket 21: 20% bucket 24: 20% bucket 25: 20% bucket 22: 20% bucket 5: 30% bucket 23: 20% bucket 26: 20% bucket 27: 20% bucket 6: 30% bucket 7: 30% bucket 10: 30% bucket 3: 40% bucket 9: 30% bucket 8: 30% bucket 4: 40% bucket 11: 30% bucket 12: 30% bucket 13: 30% bucket 2: 50% bucket 15: 30% bucket 14: 30% bucket 20: 30% bucket 19: 30% bucket 16: 30% bucket 18: 30% bucket 1: 60% bucket 17: 30% bucket 21: 30% bucket 24: 30% bucket 25: 30% bucket 5: 40% bucket 22: 30% bucket 23: 30% bucket 26: 30% bucket 27: 30% bucket 6: 40% bucket 7: 40% bucket 10: 40% bucket 3: 50% bucket 9: 40% bucket 8: 40% bucket 4: 50% bucket 11: 40% bucket 12: 40% bucket 13: 40% bucket 2: 60% bucket 15: 40% bucket 14: 40% bucket 20: 40% bucket 19: 40% bucket 16: 40% bucket 1: 70% bucket 18: 40% bucket 17: 40% bucket 21: 40% bucket 24: 40% bucket 25: 40% bucket 5: 50% bucket 22: 40% bucket 23: 40% bucket 26: 40% bucket 27: 40% bucket 6: 50% bucket 7: 50% bucket 10: 50% bucket 3: 60% bucket 9: 50% bucket 8: 50% bucket 4: 60% bucket 11: 50% bucket 12: 50% bucket 13: 50% bucket 2: 70% bucket 15: 50% bucket 14: 50% bucket 20: 50% bucket 19: 50% bucket 1: 80% bucket 16: 50% bucket 18: 50% bucket 17: 50% bucket 21: 50% bucket 24: 50% bucket 5: 60% bucket 25: 50% bucket 22: 50% bucket 23: 50% bucket 26: 50% bucket 27: 50% bucket 6: 60% bucket 7: 60% bucket 10: 60% bucket 3: 70% bucket 9: 60% bucket 8: 60% bucket 4: 70% bucket 11: 60% bucket 12: 60% bucket 13: 60% bucket 2: 80% bucket 15: 60% bucket 14: 60% bucket 20: 60% bucket 19: 60% bucket 1: 90% bucket 16: 60% bucket 18: 60% bucket 17: 60% bucket 21: 60% bucket 24: 60% bucket 5: 70% bucket 25: 60% bucket 22: 60% bucket 23: 60% bucket 26: 60% bucket 27: 60% bucket 6: 70% bucket 7: 70% bucket 10: 70% bucket 3: 80% bucket 9: 70% bucket 8: 70% bucket 4: 80% bucket 11: 70% bucket 12: 70% bucket 13: 70% bucket 2: 90% bucket 15: 70% bucket 14: 70% bucket 20: 70% bucket 19: 70% bucket 1: 100% bucket 16: 70% bucket 18: 70% bucket 17: 70% bucket 24: 70% bucket 21: 70% bucket 5: 80% bucket 25: 70% bucket 22: 70% bucket 23: 70% bucket 26: 70% bucket 27: 70% bucket 7: 80% bucket 6: 80% bucket 10: 80% bucket 3: 90% bucket 9: 80% bucket 8: 80% bucket 4: 90% bucket 11: 80% bucket 12: 80% Sorting block of length 315 for bucket 1 (Using difference cover) bucket 13: 80% bucket 2: 100% bucket 15: 80% bucket 14: 80% bucket 20: 80% bucket 19: 80% bucket 16: 80% bucket 18: 80% bucket 17: 80% bucket 24: 80% bucket 21: 80% bucket 5: 90% bucket 25: 80% bucket 22: 80% bucket 23: 80% bucket 26: 80% bucket 27: 80% bucket 7: 90% bucket 10: 90% bucket 6: 90% bucket 3: 100% bucket 9: 90% Sorting block of length 289 for bucket 2 (Using difference cover) bucket 8: 90% bucket 4: 100% bucket 11: 90% bucket 12: 90% bucket 13: 90% bucket 15: 90% bucket 14: 90% bucket 20: 90% bucket 19: 90% bucket 16: 90% bucket 18: 90% bucket 17: 90% bucket 24: 90% bucket 21: 90% bucket 5: 100% Sorting block of length 84 for bucket 3 (Using difference cover) bucket 25: 90% bucket 22: 90% bucket 23: 90% bucket 26: 90% bucket 27: 90% bucket 7: 100% bucket 10: 100% Sorting block of length 300 for bucket 4 (Using difference cover) bucket 6: 100% bucket 9: 100% bucket 8: 100% bucket 11: 100% bucket 12: 100% bucket 13: 100% bucket 15: 100% Sorting block of length 82 for bucket 5 (Using difference cover) bucket 14: 100% bucket 20: 100% bucket 19: 100% bucket 16: 100% bucket 18: 100% bucket 17: 100% bucket 24: 100% bucket 21: 100% Sorting block of length 320 for bucket 7 (Using difference cover) Sorting block of length 237 for bucket 10 (Using difference cover) bucket 25: 100% bucket 22: 100% Sorting block of length 319 for bucket 6 (Using difference cover) Sorting block of length 98 for bucket 9 (Using difference cover) bucket 23: 100% bucket 26: 100% Sorting block of length 324 for bucket 8 (Using difference cover) bucket 27: 100% Sorting block of length 212 for bucket 11 (Using difference cover) Sorting block of length 243 for bucket 12 (Using difference cover) Sorting block of length 314 for bucket 13 (Using difference cover) Sorting block of length 280 for bucket 15 (Using difference cover) Sorting block of length 324 for bucket 14 (Using difference cover) Sorting block of length 153 for bucket 20 (Using difference cover) Sorting block of length 268 for bucket 19 (Using difference cover) Sorting block of length 319 for bucket 16 (Using difference cover) Sorting block of length 273 for bucket 18 (Using difference cover) Sorting block of length 123 for bucket 17 (Using difference cover) Sorting block of length 309 for bucket 24 (Using difference cover) Sorting block time: 00:00:00 Sorting block of length 314 for bucket 21 (Using difference cover) Sorting block of length 188 for bucket 25 (Using difference cover) Sorting block of length 194 for bucket 22 (Using difference cover) Sorting block of length 315 for bucket 23 (Using difference cover) Sorting block of length 178 for bucket 26 (Using difference cover) Sorting block of length 308 for bucket 27 (Using difference cover) Returning block of 316 for bucket 1 Getting block 28 of 202 Reserving size (325) for bucket 28 Calculating Z arrays for bucket 28 Entering block accumulator loop for bucket 28: bucket 28: 10% bucket 28: 20% bucket 28: 30% bucket 28: 40% bucket 28: 50% bucket 28: 60% bucket 28: 70% bucket 28: 80% bucket 28: 90% bucket 28: 100% Sorting block of length 277 for bucket 28 (Using difference cover) Sorting block time: 00:00:00 Returning block of 290 for bucket 2 Getting block 29 of 202 Reserving size (325) for bucket 29 Calculating Z arrays for bucket 29 Entering block accumulator loop for bucket 29: bucket 29: 10% bucket 29: 20% bucket 29: 30% bucket 29: 40% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 154 for bucket 20 Sorting block time: 00:00:00 Returning block of 238 for bucket 10 Sorting block time: 00:00:00 Returning block of 325 for bucket 8 bucket 29: 50% Sorting block time: 00:00:00 Returning block of 274 for bucket 18 Returning block of 281 for bucket 15 Sorting block time: 00:00:00 Returning block of 320 for bucket 6 bucket 29: 60% Returning block of 83 for bucket 5 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 189 for bucket 25 bucket 29: 70% Returning block of 321 for bucket 7 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 244 for bucket 12 Sorting block time: 00:00:00 Getting block 30 of 202 Returning block of 179 for bucket 26 Returning block of 99 for bucket 9 Sorting block time: 00:00:00 Returning block of 195 for bucket 22 Returning block of 213 for bucket 11 bucket 29: 80% Reserving size (325) for bucket 30 Sorting block time: 00:00:00 Returning block of 278 for bucket 28 Sorting block time: 00:00:00 Calculating Z arrays for bucket 30 Sorting block time: 00:00:00 Returning block of 320 for bucket 16 Sorting block time: 00:00:00 Returning block of 85 for bucket 3 Returning block of 124 for bucket 17 Sorting block time: 00:00:00 bucket 29: 90% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 30: Sorting block time: 00:00:00 Getting block 31 of 202 Sorting block time: 00:00:00 Returning block of 301 for bucket 4 Sorting block time: 00:00:00 Returning block of 269 for bucket 19 Sorting block time: 00:00:00 Returning block of 310 for bucket 24 Sorting block time: 00:00:00 Returning block of 315 for bucket 13 Reserving size (325) for bucket 31 Returning block of 309 for bucket 27 Returning block of 325 for bucket 14 bucket 29: 100% Returning block of 315 for bucket 21 Getting block 32 of 202 Returning block of 316 for bucket 23 Calculating Z arrays for bucket 31 bucket 30: 10% Sorting block of length 224 for bucket 29 (Using difference cover) Reserving size (325) for bucket 32 Getting block 33 of 202 Getting block 34 of 202 Entering block accumulator loop for bucket 31: Calculating Z arrays for bucket 32 Reserving size (325) for bucket 33 Reserving size (325) for bucket 34 bucket 30: 20% Calculating Z arrays for bucket 33 Entering block accumulator loop for bucket 32: Calculating Z arrays for bucket 34 Getting block 35 of 202 Entering block accumulator loop for bucket 33: Reserving size (325) for bucket 35 Entering block accumulator loop for bucket 34: Calculating Z arrays for bucket 35 bucket 31: 10% bucket 30: 30% Getting block 36 of 202 Entering block accumulator loop for bucket 35: bucket 32: 10% Reserving size (325) for bucket 36 bucket 33: 10% Calculating Z arrays for bucket 36 bucket 34: 10% Sorting block time: 00:00:00 bucket 31: 20% bucket 30: 40% Returning block of 225 for bucket 29 Entering block accumulator loop for bucket 36: bucket 32: 20% bucket 35: 10% bucket 33: 20% bucket 34: 20% Getting block 37 of 202 bucket 31: 30% bucket 30: 50% Reserving size (325) for bucket 37 bucket 36: 10% bucket 32: 30% Calculating Z arrays for bucket 37 bucket 35: 20% bucket 33: 30% bucket 34: 30% Getting block 38 of 202 bucket 31: 40% bucket 30: 60% Entering block accumulator loop for bucket 37: Reserving size (325) for bucket 38 bucket 36: 20% bucket 32: 40% Calculating Z arrays for bucket 38 bucket 35: 30% bucket 33: 40% bucket 34: 40% bucket 31: 50% bucket 30: 70% Entering block accumulator loop for bucket 38: bucket 36: 30% bucket 32: 50% bucket 37: 10% bucket 35: 40% bucket 33: 50% Getting block 39 of 202 bucket 34: 50% bucket 31: 60% bucket 30: 80% Reserving size (325) for bucket 39 bucket 36: 40% bucket 32: 60% Calculating Z arrays for bucket 39 bucket 38: 10% bucket 35: 50% bucket 37: 20% bucket 33: 60% bucket 34: 60% bucket 31: 70% Entering block accumulator loop for bucket 39: bucket 30: 90% bucket 36: 50% Getting block 40 of 202 bucket 32: 70% bucket 35: 60% bucket 38: 20% Reserving size (325) for bucket 40 bucket 33: 70% bucket 37: 30% bucket 34: 70% bucket 31: 80% Calculating Z arrays for bucket 40 bucket 30: 100% bucket 36: 60% Getting block 41 of 202 bucket 32: 80% bucket 39: 10% bucket 35: 70% Sorting block of length 286 for bucket 30 (Using difference cover) bucket 38: 30% Entering block accumulator loop for bucket 40: Reserving size (325) for bucket 41 bucket 33: 80% bucket 37: 40% bucket 34: 80% bucket 31: 90% bucket 36: 70% Calculating Z arrays for bucket 41 Getting block 42 of 202 bucket 32: 90% bucket 39: 20% bucket 35: 80% bucket 38: 40% Reserving size (325) for bucket 42 Entering block accumulator loop for bucket 41: bucket 33: 90% bucket 37: 50% bucket 34: 90% bucket 31: 100% bucket 36: 80% Calculating Z arrays for bucket 42 bucket 40: 10% bucket 32: 100% Sorting block of length 248 for bucket 31 (Using difference cover) bucket 39: 30% bucket 35: 90% bucket 38: 50% Sorting block of length 309 for bucket 32 (Using difference cover) bucket 33: 100% Entering block accumulator loop for bucket 42: bucket 37: 60% bucket 34: 100% bucket 36: 90% bucket 41: 10% bucket 40: 20% Sorting block of length 303 for bucket 33 (Using difference cover) bucket 39: 40% Sorting block of length 56 for bucket 34 (Using difference cover) bucket 35: 100% bucket 38: 60% bucket 37: 70% bucket 36: 100% bucket 41: 20% Sorting block of length 304 for bucket 35 (Using difference cover) Getting block 43 of 202 bucket 40: 30% Sorting block of length 50 for bucket 36 Sorting block time: 00:00:00 (Using difference cover) bucket 42: 10% bucket 39: 50% Reserving size (325) for bucket 43 bucket 38: 70% Returning block of 287 for bucket 30 bucket 37: 80% bucket 41: 30% Calculating Z arrays for bucket 43 bucket 40: 40% Getting block 44 of 202 bucket 42: 20% bucket 39: 60% Entering block accumulator loop for bucket 43: Reserving size (325) for bucket 44 bucket 38: 80% bucket 41: 40% bucket 37: 90% Calculating Z arrays for bucket 44 Getting block 45 of 202 bucket 40: 50% bucket 39: 70% Reserving size (325) for bucket 45 bucket 42: 30% Entering block accumulator loop for bucket 44: bucket 43: 10% bucket 41: 50% Calculating Z arrays for bucket 45 bucket 38: 90% bucket 37: 100% bucket 40: 60% bucket 39: 80% Sorting block of length 289 for bucket 37 (Using difference cover) Getting block 46 of 202 Entering block accumulator loop for bucket 45: bucket 42: 40% bucket 43: 20% bucket 41: 60% Reserving size (325) for bucket 46 bucket 38: 100% bucket 40: 70% bucket 44: 10% bucket 39: 90% Calculating Z arrays for bucket 46 Sorting block of length 48 for bucket 38 (Using difference cover) bucket 43: 30% bucket 42: 50% bucket 41: 70% Entering block accumulator loop for bucket 46: bucket 45: 10% bucket 40: 80% Getting block 47 of 202 bucket 44: 20% bucket 39: 100% bucket 43: 40% Reserving size (325) for bucket 47 bucket 41: 80% Sorting block of length 312 for bucket 39 (Using difference cover) bucket 42: 60% Calculating Z arrays for bucket 47 bucket 45: 20% bucket 40: 90% Getting block 48 of 202 bucket 44: 30% bucket 43: 50% bucket 46: 10% bucket 41: 90% Reserving size (325) for bucket 48 Entering block accumulator loop for bucket 47: bucket 42: 70% Calculating Z arrays for bucket 48 bucket 45: 30% bucket 40: 100% Getting block 49 of 202 bucket 43: 60% Sorting block of length 266 for bucket 40 bucket 44: 40% (Using difference cover) Entering block accumulator loop for bucket 48: Reserving size (325) for bucket 49 bucket 41: 100% bucket 46: 20% bucket 42: 80% Calculating Z arrays for bucket 49 bucket 45: 40% bucket 47: 10% Sorting block of length 296 for bucket 41 (Using difference cover) bucket 43: 70% bucket 44: 50% Getting block 50 of 202 Entering block accumulator loop for bucket 49: bucket 48: 10% Reserving size (325) for bucket 50 bucket 46: 30% bucket 42: 90% bucket 45: 50% Calculating Z arrays for bucket 50 bucket 47: 20% bucket 43: 80% bucket 44: 60% bucket 48: 20% Entering block accumulator loop for bucket 50: Getting block 51 of 202 bucket 46: 40% bucket 49: 10% bucket 45: 60% bucket 42: 100% Reserving size (325) for bucket 51 bucket 43: 90% bucket 47: 30% bucket 44: 70% bucket 48: 30% Sorting block of length 185 for bucket 42 (Using difference cover) Getting block 52 of 202 Calculating Z arrays for bucket 51 bucket 49: 20% bucket 46: 50% Sorting block time: 00:00:00 bucket 50: 10% bucket 45: 70% bucket 43: 100% Reserving size (325) for bucket 52 bucket 44: 80% bucket 47: 40% bucket 48: 40% Returning block of 249 for bucket 31 Entering block accumulator loop for bucket 51: Sorting block time: 00:00:00 Sorting block of length 283 for bucket 43 (Using difference cover) Calculating Z arrays for bucket 52 bucket 49: 30% Getting block 53 of 202 bucket 46: 60% bucket 50: 20% bucket 45: 80% Returning block of 57 for bucket 34 bucket 44: 90% bucket 47: 50% bucket 48: 50% Entering block accumulator loop for bucket 52: Reserving size (325) for bucket 53 bucket 49: 40% Getting block 54 of 202 bucket 46: 70% bucket 50: 30% Calculating Z arrays for bucket 53 bucket 45: 90% bucket 51: 10% bucket 44: 100% Reserving size (325) for bucket 54 Getting block 55 of 202 bucket 47: 60% bucket 48: 60% bucket 49: 50% Entering block accumulator loop for bucket 53: Sorting block of length 256 for bucket 44 (Using difference cover) Calculating Z arrays for bucket 54 bucket 52: 10% bucket 46: 80% bucket 50: 40% Reserving size (325) for bucket 55 bucket 45: 100% bucket 51: 20% Getting block 56 of 202 bucket 47: 70% bucket 48: 70% bucket 49: 60% Entering block accumulator loop for bucket 54: Calculating Z arrays for bucket 55 Sorting block of length 281 for bucket 45 (Using difference cover) bucket 52: 20% Reserving size (325) for bucket 56 bucket 50: 50% bucket 46: 90% Getting block 57 of 202 bucket 51: 30% bucket 53: 10% Entering block accumulator loop for bucket 55: bucket 47: 80% bucket 48: 80% bucket 49: 70% Calculating Z arrays for bucket 56 Reserving size (325) for bucket 57 Sorting block time: 00:00:00 bucket 52: 30% bucket 50: 60% bucket 46: 100% bucket 54: 10% Calculating Z arrays for bucket 57 bucket 51: 40% Getting block 58 of 202 Returning block of 304 for bucket 33 bucket 53: 20% Entering block accumulator loop for bucket 56: bucket 47: 90% Sorting block of length 253 for bucket 46 (Using difference cover) bucket 48: 90% bucket 49: 80% Entering block accumulator loop for bucket 57: Reserving size (325) for bucket 58 Sorting block time: 00:00:00 bucket 52: 40% bucket 50: 70% Sorting block time: 00:00:00 bucket 55: 10% Getting block 59 of 202 bucket 54: 20% bucket 51: 50% bucket 53: 30% Calculating Z arrays for bucket 58 Returning block of 305 for bucket 35 bucket 47: 100% Returning block of 310 for bucket 32 bucket 48: 100% bucket 49: 90% Reserving size (325) for bucket 59 bucket 52: 50% bucket 50: 80% bucket 55: 20% Sorting block of length 110 for bucket 47 (Using difference cover) Entering block accumulator loop for bucket 58: bucket 54: 30% bucket 51: 60% bucket 56: 10% Sorting block of length 318 for bucket 48 (Using difference cover) bucket 53: 40% bucket 57: 10% Sorting block time: 00:00:00 Calculating Z arrays for bucket 59 bucket 49: 100% Sorting block time: 00:00:00 bucket 52: 60% Getting block 60 of 202 bucket 50: 90% bucket 55: 30% bucket 54: 40% Returning block of 313 for bucket 39 bucket 51: 70% Returning block of 290 for bucket 37 bucket 56: 20% Sorting block of length 245 for bucket 49 (Using difference cover) Entering block accumulator loop for bucket 59: Reserving size (325) for bucket 60 bucket 53: 50% bucket 57: 20% bucket 52: 70% bucket 58: 10% bucket 50: 100% bucket 55: 40% Getting block 61 of 202 bucket 54: 50% Calculating Z arrays for bucket 60 bucket 51: 80% Getting block 62 of 202 bucket 56: 30% Sorting block of length 161 for bucket 50 (Using difference cover) Reserving size (325) for bucket 61 Sorting block time: 00:00:00 bucket 53: 60% bucket 57: 30% bucket 52: 80% bucket 58: 20% Reserving size (325) for bucket 62 Entering block accumulator loop for bucket 60: bucket 55: 50% bucket 54: 60% Calculating Z arrays for bucket 61 bucket 59: 10% Returning block of 51 for bucket 36 bucket 51: 90% bucket 56: 40% Calculating Z arrays for bucket 62 Getting block 63 of 202 bucket 53: 70% bucket 57: 40% bucket 52: 90% Entering block accumulator loop for bucket 61: bucket 58: 30% Getting block 64 of 202 bucket 55: 60% bucket 54: 70% Sorting block time: 00:00:00 Reserving size (325) for bucket 63 Entering block accumulator loop for bucket 62: bucket 59: 20% bucket 51: 100% bucket 56: 50% Reserving size (325) for bucket 64 bucket 60: 10% bucket 53: 80% bucket 57: 50% Returning block of 49 for bucket 38 Calculating Z arrays for bucket 63 bucket 52: 100% bucket 58: 40% Sorting block of length 308 for bucket 51 (Using difference cover) bucket 55: 70% Calculating Z arrays for bucket 64 bucket 54: 80% bucket 59: 30% bucket 61: 10% bucket 56: 60% Sorting block of length 226 for bucket 52 (Using difference cover) Entering block accumulator loop for bucket 63: bucket 60: 20% bucket 53: 90% bucket 57: 60% Entering block accumulator loop for bucket 64: bucket 62: 10% bucket 58: 50% bucket 55: 80% bucket 54: 90% bucket 59: 40% bucket 61: 20% bucket 56: 70% Getting block 65 of 202 bucket 60: 30% bucket 53: 100% bucket 57: 70% Getting block 66 of 202 Reserving size (325) for bucket 65 bucket 62: 20% Sorting block time: 00:00:00 bucket 63: 10% bucket 58: 60% Sorting block of length 191 for bucket 53 (Using difference cover) bucket 55: 90% bucket 54: 100% bucket 64: 10% Reserving size (325) for bucket 66 bucket 59: 50% Calculating Z arrays for bucket 65 bucket 61: 30% bucket 56: 80% Returning block of 297 for bucket 41 bucket 60: 40% bucket 57: 80% Sorting block of length 311 for bucket 54 (Using difference cover) bucket 62: 30% bucket 63: 20% Calculating Z arrays for bucket 66 bucket 58: 70% bucket 55: 100% Entering block accumulator loop for bucket 65: bucket 64: 20% bucket 59: 60% bucket 61: 40% bucket 56: 90% Sorting block of length 149 for bucket 55 (Using difference cover) bucket 60: 50% Entering block accumulator loop for bucket 66: bucket 57: 90% bucket 63: 30% bucket 62: 40% bucket 58: 80% bucket 64: 30% bucket 59: 70% bucket 61: 50% bucket 56: 100% bucket 60: 60% Sorting block of length 249 for bucket 56 (Using difference cover) Getting block 67 of 202 bucket 65: 10% bucket 57: 100% bucket 63: 40% bucket 62: 50% bucket 58: 90% Reserving size (325) for bucket 67 bucket 64: 40% bucket 66: 10% bucket 59: 80% Sorting block of length 305 for bucket 57 (Using difference cover) bucket 61: 60% Sorting block time: 00:00:00 bucket 60: 70% Sorting block time: 00:00:00 Calculating Z arrays for bucket 67 bucket 65: 20% bucket 63: 50% Sorting block time: 00:00:00 bucket 62: 60% Returning block of 186 for bucket 42 Returning block of 267 for bucket 40 bucket 58: 100% bucket 64: 50% bucket 59: 90% bucket 66: 20% Returning block of 284 for bucket 43 Entering block accumulator loop for bucket 67: bucket 61: 70% bucket 60: 80% Sorting block of length 243 for bucket 58 (Using difference cover) bucket 63: 60% bucket 65: 30% bucket 62: 70% bucket 64: 60% bucket 59: 100% bucket 66: 30% Sorting block of length 296 for bucket 59 (Using difference cover) bucket 61: 80% bucket 60: 90% bucket 63: 70% Getting block 68 of 202 bucket 65: 40% bucket 62: 80% Reserving size (325) for bucket 68 bucket 64: 70% bucket 67: 10% Calculating Z arrays for bucket 68 bucket 66: 40% bucket 63: 80% bucket 61: 90% bucket 60: 100% Entering block accumulator loop for bucket 68: bucket 65: 50% Sorting block of length 213 for bucket 60 (Using difference cover) bucket 62: 90% Getting block 69 of 202 bucket 64: 80% bucket 67: 20% bucket 63: 90% bucket 66: 50% Reserving size (325) for bucket 69 bucket 61: 100% bucket 65: 60% Calculating Z arrays for bucket 69 Sorting block time: 00:00:00 Sorting block of length 288 for bucket 61 (Using difference cover) bucket 62: 100% bucket 68: 10% Returning block of 257 for bucket 44 bucket 64: 90% bucket 63: 100% Entering block accumulator loop for bucket 69: Sorting block of length 239 for bucket 62 (Using difference cover) bucket 67: 30% bucket 66: 60% bucket 65: 70% Sorting block of length 203 for bucket 63 (Using difference cover) bucket 68: 20% Getting block 70 of 202 bucket 64: 100% Reserving size (325) for bucket 70 Sorting block of length 318 for bucket 64 (Using difference cover) Calculating Z arrays for bucket 70 bucket 67: 40% bucket 66: 70% bucket 65: 80% bucket 69: 10% Entering block accumulator loop for bucket 70: bucket 68: 30% Getting block 71 of 202 bucket 67: 50% bucket 66: 80% Reserving size (325) for bucket 71 bucket 65: 90% bucket 69: 20% bucket 68: 40% bucket 70: 10% Calculating Z arrays for bucket 71 bucket 67: 60% Entering block accumulator loop for bucket 71: bucket 66: 90% bucket 65: 100% bucket 69: 30% Sorting block of length 309 for bucket 65 (Using difference cover) bucket 68: 50% bucket 70: 20% bucket 67: 70% bucket 66: 100% bucket 71: 10% Sorting block of length 296 for bucket 66 (Using difference cover) bucket 69: 40% bucket 68: 60% bucket 70: 30% bucket 67: 80% bucket 71: 20% bucket 69: 50% bucket 68: 70% Sorting block time: 00:00:00 Returning block of 282 for bucket 45 bucket 70: 40% bucket 67: 90% bucket 71: 30% bucket 69: 60% bucket 68: 80% bucket 70: 50% bucket 67: 100% Sorting block of length 189 for bucket 67 (Using difference cover) bucket 69: 70% bucket 71: 40% bucket 68: 90% bucket 70: 60% Sorting block time: 00:00:00 Returning block of 111 for bucket 47 bucket 69: 80% bucket 71: 50% bucket 68: 100% bucket 70: 70% Getting block 72 of 202 Sorting block of length 307 for bucket 68 (Using difference cover) Reserving size (325) for bucket 72 bucket 69: 90% Calculating Z arrays for bucket 72 bucket 71: 60% bucket 70: 80% Entering block accumulator loop for bucket 72: bucket 69: 100% Sorting block of length 316 for bucket 69 (Using difference cover) bucket 71: 70% bucket 70: 90% bucket 72: 10% Getting block 73 of 202 Reserving size (325) for bucket 73 Calculating Z arrays for bucket 73 bucket 71: 80% bucket 70: 100% Sorting block of length 263 for bucket 70 (Using difference cover) Entering block accumulator loop for bucket 73: bucket 72: 20% bucket 71: 90% bucket 73: 10% bucket 72: 30% bucket 71: 100% Sorting block of length 271 for bucket 71 (Using difference cover) bucket 73: 20% bucket 72: 40% bucket 73: 30% bucket 72: 50% bucket 72: 60% bucket 73: 40% bucket 72: 70% bucket 73: 50% bucket 72: 80% bucket 73: 60% bucket 72: 90% bucket 73: 70% bucket 72: 100% Sorting block of length 321 for bucket 72 (Using difference cover) bucket 73: 80% bucket 73: 90% bucket 73: 100% Sorting block of length 310 for bucket 73 (Using difference cover) Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 254 for bucket 46 Returning block of 319 for bucket 48 Getting block 74 of 202 Reserving size (325) for bucket 74 Calculating Z arrays for bucket 74 Entering block accumulator loop for bucket 74: bucket 74: 10% Getting block 75 of 202 Reserving size (325) for bucket 75 Calculating Z arrays for bucket 75 Entering block accumulator loop for bucket 75: bucket 74: 20% bucket 75: 10% bucket 74: 30% bucket 75: 20% bucket 74: 40% bucket 75: 30% bucket 74: 50% bucket 74: 60% bucket 75: 40% bucket 74: 70% bucket 75: 50% Sorting block time: 00:00:00 Returning block of 246 for bucket 49 bucket 74: 80% Sorting block time: 00:00:00 bucket 75: 60% Returning block of 162 for bucket 50 bucket 74: 90% bucket 75: 70% bucket 74: 100% Sorting block of length 212 for bucket 74 (Using difference cover) bucket 75: 80% Getting block 76 of 202 Reserving size (325) for bucket 76 Calculating Z arrays for bucket 76 Entering block accumulator loop for bucket 76: bucket 75: 90% bucket 76: 10% Getting block 77 of 202 Reserving size (325) for bucket 77 Calculating Z arrays for bucket 77 bucket 75: 100% Sorting block of length 258 for bucket 75 (Using difference cover) Entering block accumulator loop for bucket 77: bucket 76: 20% bucket 76: 30% bucket 77: 10% bucket 76: 40% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 77: 20% Returning block of 227 for bucket 52 Returning block of 309 for bucket 51 bucket 76: 50% bucket 77: 30% bucket 76: 60% bucket 77: 40% bucket 76: 70% Getting block 78 of 202 bucket 77: 50% Reserving size (325) for bucket 78 Calculating Z arrays for bucket 78 bucket 76: 80% Entering block accumulator loop for bucket 78: bucket 77: 60% bucket 76: 90% Getting block 79 of 202 bucket 78: 10% Reserving size (325) for bucket 79 Calculating Z arrays for bucket 79 bucket 77: 70% bucket 76: 100% Entering block accumulator loop for bucket 79: Sorting block of length 294 for bucket 76 (Using difference cover) bucket 78: 20% bucket 77: 80% bucket 79: 10% bucket 78: 30% bucket 77: 90% bucket 79: 20% bucket 78: 40% bucket 77: 100% Sorting block of length 324 for bucket 77 (Using difference cover) bucket 79: 30% bucket 78: 50% bucket 79: 40% bucket 78: 60% bucket 79: 50% bucket 78: 70% Sorting block time: 00:00:00 Returning block of 150 for bucket 55 bucket 79: 60% bucket 78: 80% bucket 79: 70% bucket 78: 90% bucket 79: 80% bucket 78: 100% Sorting block of length 265 for bucket 78 (Using difference cover) Getting block 80 of 202 bucket 79: 90% Reserving size (325) for bucket 80 Calculating Z arrays for bucket 80 Sorting block time: 00:00:00 Returning block of 192 for bucket 53 Entering block accumulator loop for bucket 80: bucket 79: 100% Sorting block of length 275 for bucket 79 (Using difference cover) bucket 80: 10% Sorting block time: 00:00:00 Returning block of 306 for bucket 57 Sorting block time: 00:00:00 bucket 80: 20% Sorting block time: 00:00:00 Returning block of 312 for bucket 54 Returning block of 250 for bucket 56 Getting block 81 of 202 Reserving size (325) for bucket 81 bucket 80: 30% Calculating Z arrays for bucket 81 Entering block accumulator loop for bucket 81: bucket 80: 40% Getting block 82 of 202 bucket 81: 10% Reserving size (325) for bucket 82 bucket 80: 50% Calculating Z arrays for bucket 82 Entering block accumulator loop for bucket 82: Getting block 83 of 202 bucket 80: 60% bucket 81: 20% Reserving size (325) for bucket 83 Calculating Z arrays for bucket 83 bucket 82: 10% Entering block accumulator loop for bucket 83: bucket 80: 70% bucket 81: 30% bucket 82: 20% bucket 83: 10% bucket 80: 80% Getting block 84 of 202 Reserving size (325) for bucket 84 Calculating Z arrays for bucket 84 bucket 81: 40% bucket 82: 30% Entering block accumulator loop for bucket 84: bucket 83: 20% bucket 80: 90% bucket 81: 50% bucket 82: 40% bucket 84: 10% bucket 80: 100% Sorting block time: 00:00:00 bucket 83: 30% Sorting block of length 129 for bucket 80 (Using difference cover) Returning block of 214 for bucket 60 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 81: 60% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 82: 50% Returning block of 240 for bucket 62 Returning block of 310 for bucket 65 Returning block of 244 for bucket 58 bucket 84: 20% Returning block of 297 for bucket 59 bucket 83: 40% bucket 81: 70% bucket 82: 60% bucket 84: 30% Getting block 85 of 202 bucket 83: 50% Reserving size (325) for bucket 85 bucket 82: 70% bucket 81: 80% Calculating Z arrays for bucket 85 Sorting block time: 00:00:00 Returning block of 190 for bucket 67 bucket 84: 40% Entering block accumulator loop for bucket 85: bucket 83: 60% bucket 82: 80% bucket 81: 90% Getting block 86 of 202 bucket 84: 50% Reserving size (325) for bucket 86 bucket 85: 10% Calculating Z arrays for bucket 86 bucket 83: 70% bucket 82: 90% bucket 81: 100% Entering block accumulator loop for bucket 86: Sorting block of length 214 for bucket 81 (Using difference cover) bucket 84: 60% bucket 85: 20% Getting block 87 of 202 bucket 83: 80% bucket 82: 100% Reserving size (325) for bucket 87 Sorting block of length 176 for bucket 82 (Using difference cover) Calculating Z arrays for bucket 87 bucket 86: 10% bucket 84: 70% bucket 85: 30% Entering block accumulator loop for bucket 87: bucket 83: 90% Getting block 88 of 202 Reserving size (325) for bucket 88 Calculating Z arrays for bucket 88 bucket 86: 20% bucket 84: 80% Entering block accumulator loop for bucket 88: bucket 85: 40% Sorting block time: 00:00:00 bucket 83: 100% Sorting block time: 00:00:00 bucket 87: 10% Returning block of 289 for bucket 61 Sorting block time: 00:00:00 Returning block of 308 for bucket 68 Sorting block of length 294 for bucket 83 (Using difference cover) bucket 86: 30% Returning block of 204 for bucket 63 Sorting block time: 00:00:00 bucket 84: 90% Sorting block time: 00:00:00 bucket 85: 50% bucket 88: 10% Sorting block time: 00:00:00 bucket 87: 20% Getting block 89 of 202 Returning block of 297 for bucket 66 Returning block of 319 for bucket 64 Returning block of 317 for bucket 69 bucket 86: 40% Reserving size (325) for bucket 89 Getting block 90 of 202 bucket 84: 100% bucket 85: 60% bucket 88: 20% bucket 87: 30% Calculating Z arrays for bucket 89 Reserving size (325) for bucket 90 Sorting block of length 155 for bucket 84 (Using difference cover) Getting block 91 of 202 bucket 86: 50% Sorting block time: 00:00:00 Calculating Z arrays for bucket 90 Entering block accumulator loop for bucket 89: Reserving size (325) for bucket 91 bucket 85: 70% Returning block of 272 for bucket 71 bucket 88: 30% bucket 87: 40% Entering block accumulator loop for bucket 90: Calculating Z arrays for bucket 91 bucket 86: 60% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Getting block 92 of 202 Sorting block time: 00:00:00 bucket 85: 80% Returning block of 264 for bucket 70 Returning block of 311 for bucket 73 Entering block accumulator loop for bucket 91: Reserving size (325) for bucket 92 Getting block 93 of 202 Returning block of 322 for bucket 72 bucket 88: 40% bucket 89: 10% bucket 87: 50% bucket 86: 70% bucket 90: 10% bucket 85: 90% Calculating Z arrays for bucket 92 Reserving size (325) for bucket 93 Getting block 94 of 202 Calculating Z arrays for bucket 93 bucket 88: 50% Entering block accumulator loop for bucket 92: bucket 89: 20% Reserving size (325) for bucket 94 Getting block 95 of 202 bucket 87: 60% bucket 86: 80% Entering block accumulator loop for bucket 93: bucket 90: 20% bucket 85: 100% bucket 91: 10% Calculating Z arrays for bucket 94 Reserving size (325) for bucket 95 Getting block 96 of 202 bucket 88: 60% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 89: 30% Sorting block of length 236 for bucket 85 (Using difference cover) Calculating Z arrays for bucket 95 bucket 87: 70% bucket 86: 90% Entering block accumulator loop for bucket 94: Reserving size (325) for bucket 96 Returning block of 213 for bucket 74 bucket 92: 10% bucket 90: 30% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 259 for bucket 75 bucket 91: 20% Getting block 97 of 202 Entering block accumulator loop for bucket 95: bucket 93: 10% bucket 88: 70% Calculating Z arrays for bucket 96 bucket 89: 40% Returning block of 325 for bucket 77 Returning block of 276 for bucket 79 Returning block of 295 for bucket 76 bucket 87: 80% bucket 86: 100% Reserving size (325) for bucket 97 bucket 92: 20% bucket 90: 40% bucket 91: 30% Entering block accumulator loop for bucket 96: bucket 93: 20% bucket 88: 80% bucket 94: 10% bucket 89: 50% Sorting block of length 306 for bucket 86 (Using difference cover) Calculating Z arrays for bucket 97 Getting block 98 of 202 bucket 87: 90% Getting block 99 of 202 bucket 92: 30% bucket 95: 10% bucket 90: 50% bucket 91: 40% bucket 93: 30% Reserving size (325) for bucket 98 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 97: Sorting block time: 00:00:00 bucket 88: 90% Sorting block time: 00:00:00 bucket 89: 60% Sorting block time: 00:00:00 bucket 94: 20% Sorting block time: 00:00:00 Reserving size (325) for bucket 99 bucket 96: 10% bucket 87: 100% Calculating Z arrays for bucket 98 Getting block 100 of 202 Returning block of 130 for bucket 80 Returning block of 177 for bucket 82 Returning block of 295 for bucket 83 bucket 92: 40% bucket 95: 20% bucket 90: 60% Returning block of 266 for bucket 78 bucket 91: 50% bucket 93: 40% Returning block of 215 for bucket 81 Calculating Z arrays for bucket 99 Sorting block of length 296 for bucket 87 (Using difference cover) bucket 88: 100% bucket 89: 70% Entering block accumulator loop for bucket 98: Sorting block time: 00:00:00 Reserving size (325) for bucket 100 bucket 94: 30% bucket 96: 20% bucket 97: 10% bucket 92: 50% bucket 95: 30% bucket 90: 70% Entering block accumulator loop for bucket 99: bucket 91: 60% Sorting block of length 292 for bucket 88 (Using difference cover) bucket 93: 50% Getting block 101 of 202 Returning block of 156 for bucket 84 Calculating Z arrays for bucket 100 Getting block 102 of 202 bucket 89: 80% bucket 94: 40% bucket 97: 20% bucket 96: 30% bucket 92: 60% Getting block 103 of 202 bucket 95: 40% bucket 90: 80% Reserving size (325) for bucket 101 bucket 91: 70% bucket 93: 60% Reserving size (325) for bucket 102 Entering block accumulator loop for bucket 100: bucket 98: 10% Getting block 104 of 202 Reserving size (325) for bucket 103 bucket 89: 90% bucket 99: 10% bucket 97: 30% Calculating Z arrays for bucket 101 bucket 94: 50% bucket 96: 40% bucket 92: 70% Calculating Z arrays for bucket 102 Getting block 105 of 202 bucket 95: 50% bucket 90: 90% Reserving size (325) for bucket 104 Calculating Z arrays for bucket 103 bucket 91: 80% bucket 93: 70% Getting block 106 of 202 bucket 98: 20% Entering block accumulator loop for bucket 101: bucket 89: 100% Reserving size (325) for bucket 105 bucket 97: 40% bucket 99: 20% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 102: Calculating Z arrays for bucket 104 bucket 94: 60% bucket 96: 50% bucket 92: 80% Entering block accumulator loop for bucket 103: Reserving size (325) for bucket 106 bucket 100: 10% bucket 90: 100% bucket 95: 60% Sorting block of length 167 for bucket 89 (Using difference cover) Calculating Z arrays for bucket 105 bucket 91: 90% bucket 93: 80% Returning block of 237 for bucket 85 Getting block 107 of 202 bucket 98: 30% Entering block accumulator loop for bucket 104: Sorting block time: 00:00:00 bucket 97: 50% Sorting block time: 00:00:00 Calculating Z arrays for bucket 106 bucket 99: 30% Sorting block of length 181 for bucket 90 (Using difference cover) bucket 94: 70% bucket 96: 60% bucket 92: 90% Entering block accumulator loop for bucket 105: bucket 100: 20% bucket 101: 10% Getting block 108 of 202 bucket 95: 70% Reserving size (325) for bucket 107 bucket 91: 100% bucket 93: 90% Returning block of 307 for bucket 86 Returning block of 297 for bucket 87 Entering block accumulator loop for bucket 106: bucket 102: 10% bucket 98: 40% Getting block 109 of 202 bucket 97: 60% bucket 103: 10% bucket 99: 40% Reserving size (325) for bucket 108 Sorting block time: 00:00:00 bucket 94: 80% bucket 96: 70% Calculating Z arrays for bucket 107 bucket 92: 100% Sorting block of length 217 for bucket 91 (Using difference cover) bucket 100: 30% bucket 101: 20% bucket 95: 80% bucket 93: 100% bucket 104: 10% Reserving size (325) for bucket 109 Calculating Z arrays for bucket 108 Returning block of 293 for bucket 88 bucket 102: 20% bucket 98: 50% bucket 97: 70% Sorting block time: 00:00:00 Sorting block of length 315 for bucket 92 (Using difference cover) bucket 103: 20% Getting block 110 of 202 Entering block accumulator loop for bucket 107: bucket 105: 10% bucket 99: 50% bucket 94: 90% bucket 96: 80% Sorting block of length 122 for bucket 93 (Using difference cover) Getting block 111 of 202 Calculating Z arrays for bucket 109 bucket 100: 40% bucket 106: 10% bucket 101: 30% bucket 95: 90% bucket 104: 20% Getting block 112 of 202 Entering block accumulator loop for bucket 108: Returning block of 168 for bucket 89 Reserving size (325) for bucket 110 bucket 102: 30% bucket 97: 80% bucket 98: 60% bucket 103: 30% Reserving size (325) for bucket 111 bucket 105: 20% bucket 99: 60% bucket 94: 100% Entering block accumulator loop for bucket 109: bucket 96: 90% Getting block 113 of 202 Reserving size (325) for bucket 112 bucket 106: 20% bucket 100: 50% Sorting block time: 00:00:00 Getting block 114 of 202 Calculating Z arrays for bucket 110 bucket 101: 40% bucket 104: 30% bucket 95: 100% Calculating Z arrays for bucket 111 Sorting block of length 249 for bucket 94 (Using difference cover) bucket 107: 10% bucket 97: 90% bucket 102: 40% bucket 103: 40% bucket 98: 70% Reserving size (325) for bucket 113 Calculating Z arrays for bucket 112 bucket 105: 30% bucket 99: 70% Returning block of 182 for bucket 90 Reserving size (325) for bucket 114 bucket 96: 100% bucket 108: 10% Entering block accumulator loop for bucket 110: bucket 106: 30% Sorting block of length 105 for bucket 95 (Using difference cover) bucket 100: 60% Entering block accumulator loop for bucket 111: Getting block 115 of 202 bucket 104: 40% bucket 101: 50% Calculating Z arrays for bucket 113 bucket 107: 20% bucket 109: 10% Entering block accumulator loop for bucket 112: bucket 97: 100% bucket 103: 50% Calculating Z arrays for bucket 114 bucket 102: 50% Sorting block of length 324 for bucket 96 (Using difference cover) bucket 98: 80% bucket 105: 40% bucket 99: 80% Getting block 116 of 202 bucket 108: 20% Reserving size (325) for bucket 115 bucket 106: 40% Entering block accumulator loop for bucket 113: bucket 100: 70% Sorting block of length 188 for bucket 97 (Using difference cover) bucket 104: 50% Entering block accumulator loop for bucket 114: bucket 101: 60% bucket 107: 30% bucket 109: 20% bucket 103: 60% Reserving size (325) for bucket 116 bucket 102: 60% Calculating Z arrays for bucket 115 bucket 110: 10% bucket 105: 50% bucket 98: 90% bucket 111: 10% bucket 99: 90% bucket 108: 30% bucket 106: 50% Getting block 117 of 202 Calculating Z arrays for bucket 116 bucket 112: 10% bucket 100: 80% bucket 104: 60% Entering block accumulator loop for bucket 115: bucket 107: 40% bucket 109: 30% bucket 101: 70% bucket 103: 70% Reserving size (325) for bucket 117 bucket 113: 10% bucket 102: 70% bucket 110: 20% bucket 105: 60% Entering block accumulator loop for bucket 116: bucket 111: 20% bucket 98: 100% bucket 114: 10% bucket 108: 40% bucket 106: 60% bucket 99: 100% Sorting block time: 00:00:00 Calculating Z arrays for bucket 117 bucket 112: 20% bucket 104: 70% bucket 100: 90% bucket 107: 50% bucket 109: 40% bucket 103: 80% Sorting block of length 279 for bucket 98 (Using difference cover) bucket 101: 80% bucket 113: 20% bucket 110: 30% bucket 102: 80% Sorting block of length 300 for bucket 99 (Using difference cover) Returning block of 218 for bucket 91 bucket 105: 70% bucket 111: 30% Entering block accumulator loop for bucket 117: bucket 114: 20% bucket 108: 50% bucket 115: 10% bucket 106: 70% bucket 112: 30% bucket 104: 80% bucket 107: 60% bucket 100: 100% bucket 109: 50% bucket 116: 10% bucket 103: 90% bucket 113: 30% bucket 101: 90% Sorting block time: 00:00:00 bucket 110: 40% bucket 102: 90% bucket 105: 80% bucket 111: 40% Sorting block of length 316 for bucket 100 (Using difference cover) bucket 114: 30% bucket 108: 60% bucket 106: 80% bucket 115: 20% bucket 112: 40% bucket 104: 90% bucket 107: 70% Returning block of 316 for bucket 92 bucket 109: 60% bucket 103: 100% bucket 116: 20% bucket 113: 40% bucket 117: 10% bucket 110: 50% bucket 101: 100% bucket 105: 90% bucket 111: 50% bucket 102: 100% bucket 114: 40% bucket 108: 70% Sorting block of length 256 for bucket 103 bucket 106: 90% (Using difference cover) Sorting block time: 00:00:00 bucket 115: 30% Sorting block time: 00:00:00 Getting block 118 of 202 bucket 112: 50% bucket 104: 100% bucket 107: 80% Sorting block of length 302 for bucket 101 (Using difference cover) bucket 109: 70% Sorting block of length 311 for bucket 102 (Using difference cover) bucket 113: 50% bucket 117: 20% bucket 116: 30% bucket 110: 60% Returning block of 250 for bucket 94 bucket 105: 100% bucket 111: 60% Returning block of 123 for bucket 93 bucket 114: 50% Reserving size (325) for bucket 118 bucket 108: 80% Sorting block of length 197 for bucket 104 (Using difference cover) bucket 106: 100% bucket 115: 40% bucket 112: 60% bucket 107: 90% bucket 109: 80% Sorting block of length 198 for bucket 105 (Using difference cover) bucket 113: 60% bucket 117: 30% bucket 116: 40% Calculating Z arrays for bucket 118 bucket 110: 70% bucket 111: 70% Sorting block of length 303 for bucket 106 (Using difference cover) Getting block 119 of 202 bucket 114: 60% bucket 108: 90% bucket 115: 50% bucket 112: 70% bucket 107: 100% Entering block accumulator loop for bucket 118: bucket 109: 90% bucket 117: 40% Reserving size (325) for bucket 119 bucket 113: 70% bucket 116: 50% bucket 110: 80% bucket 111: 80% Sorting block of length 234 for bucket 107 (Using difference cover) bucket 114: 70% bucket 108: 100% bucket 115: 60% Calculating Z arrays for bucket 119 Getting block 120 of 202 bucket 112: 80% bucket 117: 50% bucket 109: 100% Sorting block of length 268 for bucket 108 (Using difference cover) bucket 113: 80% bucket 116: 60% Reserving size (325) for bucket 120 bucket 110: 90% Entering block accumulator loop for bucket 119: bucket 111: 90% Getting block 121 of 202 bucket 114: 80% bucket 118: 10% Sorting block of length 156 for bucket 109 (Using difference cover) bucket 115: 70% Calculating Z arrays for bucket 120 bucket 117: 60% bucket 112: 90% Reserving size (325) for bucket 121 bucket 113: 90% bucket 116: 70% Sorting block time: 00:00:00 bucket 110: 100% bucket 111: 100% Entering block accumulator loop for bucket 120: bucket 114: 90% Calculating Z arrays for bucket 121 bucket 118: 20% bucket 115: 80% Returning block of 106 for bucket 95 bucket 117: 70% Sorting block of length 260 for bucket 110 (Using difference cover) Sorting block of length 195 for bucket 111 (Using difference cover) bucket 112: 100% bucket 119: 10% bucket 113: 100% Entering block accumulator loop for bucket 121: bucket 116: 80% bucket 114: 100% bucket 118: 30% bucket 115: 90% Sorting block of length 159 for bucket 112 (Using difference cover) bucket 117: 80% Sorting block of length 219 for bucket 113 (Using difference cover) Sorting block of length 186 for bucket 114 (Using difference cover) bucket 120: 10% bucket 119: 20% bucket 116: 90% bucket 118: 40% bucket 115: 100% bucket 117: 90% Sorting block of length 251 for bucket 115 (Using difference cover) bucket 121: 10% bucket 120: 20% bucket 119: 30% bucket 118: 50% Getting block 122 of 202 bucket 116: 100% bucket 117: 100% Reserving size (325) for bucket 122 Sorting block of length 258 for bucket 116 (Using difference cover) Sorting block of length 245 for bucket 117 (Using difference cover) Calculating Z arrays for bucket 122 bucket 121: 20% bucket 120: 30% bucket 119: 40% bucket 118: 60% Entering block accumulator loop for bucket 122: bucket 121: 30% bucket 120: 40% bucket 119: 50% bucket 118: 70% bucket 122: 10% bucket 121: 40% bucket 120: 50% bucket 119: 60% bucket 118: 80% bucket 122: 20% bucket 121: 50% bucket 120: 60% bucket 119: 70% bucket 118: 90% bucket 122: 30% bucket 121: 60% bucket 120: 70% bucket 119: 80% bucket 118: 100% Sorting block of length 180 for bucket 118 (Using difference cover) bucket 122: 40% Sorting block time: 00:00:00 Returning block of 189 for bucket 97 bucket 121: 70% bucket 120: 80% bucket 119: 90% bucket 122: 50% bucket 121: 80% bucket 120: 90% bucket 119: 100% Sorting block of length 178 for bucket 119 (Using difference cover) bucket 122: 60% bucket 121: 90% bucket 120: 100% Sorting block of length 159 for bucket 120 (Using difference cover) Getting block 123 of 202 Reserving size (325) for bucket 123 bucket 122: 70% Calculating Z arrays for bucket 123 bucket 121: 100% Sorting block of length 171 for bucket 121 (Using difference cover) Entering block accumulator loop for bucket 123: bucket 122: 80% bucket 123: 10% bucket 122: 90% Sorting block time: 00:00:00 Returning block of 325 for bucket 96 bucket 123: 20% bucket 122: 100% Sorting block of length 275 for bucket 122 (Using difference cover) bucket 123: 30% bucket 123: 40% Getting block 124 of 202 Reserving size (325) for bucket 124 Calculating Z arrays for bucket 124 bucket 123: 50% Entering block accumulator loop for bucket 124: bucket 123: 60% bucket 124: 10% bucket 123: 70% bucket 124: 20% bucket 123: 80% bucket 124: 30% bucket 123: 90% bucket 124: 40% bucket 123: 100% Sorting block time: 00:00:00 Sorting block of length 278 for bucket 123 (Using difference cover) Sorting block time: 00:00:00 Returning block of 280 for bucket 98 bucket 124: 50% Returning block of 301 for bucket 99 bucket 124: 60% bucket 124: 70% Getting block 125 of 202 bucket 124: 80% Reserving size (325) for bucket 125 Calculating Z arrays for bucket 125 Entering block accumulator loop for bucket 125: bucket 124: 90% Getting block 126 of 202 Reserving size (325) for bucket 126 Calculating Z arrays for bucket 126 bucket 125: 10% Entering block accumulator loop for bucket 126: bucket 124: 100% Sorting block of length 141 for bucket 124 (Using difference cover) bucket 125: 20% bucket 126: 10% bucket 125: 30% bucket 126: 20% bucket 125: 40% bucket 126: 30% bucket 125: 50% bucket 126: 40% bucket 125: 60% bucket 126: 50% bucket 125: 70% bucket 126: 60% bucket 125: 80% bucket 126: 70% bucket 125: 90% bucket 126: 80% bucket 125: 100% Sorting block of length 247 for bucket 125 (Using difference cover) bucket 126: 90% bucket 126: 100% Sorting block of length 239 for bucket 126 (Using difference cover) Sorting block time: 00:00:00 Returning block of 257 for bucket 103 Getting block 127 of 202 Reserving size (325) for bucket 127 Calculating Z arrays for bucket 127 Entering block accumulator loop for bucket 127: bucket 127: 10% Sorting block time: 00:00:00 Returning block of 312 for bucket 102 bucket 127: 20% bucket 127: 30% Sorting block time: 00:00:00 Returning block of 317 for bucket 100 Getting block 128 of 202 bucket 127: 40% Reserving size (325) for bucket 128 Calculating Z arrays for bucket 128 Entering block accumulator loop for bucket 128: bucket 127: 50% bucket 128: 10% bucket 127: 60% Getting block 129 of 202 Reserving size (325) for bucket 129 Calculating Z arrays for bucket 129 bucket 128: 20% Entering block accumulator loop for bucket 129: bucket 127: 70% bucket 128: 30% bucket 129: 10% bucket 127: 80% bucket 128: 40% bucket 127: 90% bucket 129: 20% bucket 128: 50% bucket 127: 100% Sorting block of length 208 for bucket 127 (Using difference cover) bucket 129: 30% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 128: 60% Sorting block time: 00:00:00 Returning block of 199 for bucket 105 Returning block of 235 for bucket 107 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 157 for bucket 109 Returning block of 304 for bucket 106 Returning block of 303 for bucket 101 Returning block of 198 for bucket 104 bucket 129: 40% bucket 128: 70% Getting block 130 of 202 Reserving size (325) for bucket 130 Calculating Z arrays for bucket 130 Entering block accumulator loop for bucket 130: bucket 129: 50% bucket 128: 80% bucket 130: 10% bucket 129: 60% bucket 128: 90% Getting block 131 of 202 Reserving size (325) for bucket 131 Calculating Z arrays for bucket 131 Entering block accumulator loop for bucket 131: bucket 130: 20% bucket 128: 100% bucket 129: 70% Sorting block of length 266 for bucket 128 (Using difference cover) bucket 131: 10% Getting block 132 of 202 Reserving size (325) for bucket 132 Calculating Z arrays for bucket 132 bucket 130: 30% bucket 129: 80% Entering block accumulator loop for bucket 132: bucket 131: 20% bucket 130: 40% bucket 132: 10% bucket 129: 90% bucket 131: 30% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 252 for bucket 115 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 248 for bucket 125 Sorting block time: 00:00:00 Returning block of 220 for bucket 113 Returning block of 172 for bucket 121 Returning block of 261 for bucket 110 Returning block of 246 for bucket 117 Returning block of 259 for bucket 116 bucket 132: 20% Sorting block time: 00:00:00 bucket 130: 50% Sorting block time: 00:00:00 bucket 129: 100% Sorting block time: 00:00:00 bucket 131: 40% Sorting block time: 00:00:00 Returning block of 269 for bucket 108 Sorting block time: 00:00:00 Getting block 133 of 202 Returning block of 187 for bucket 114 Sorting block of length 293 for bucket 129 (Using difference cover) Returning block of 196 for bucket 111 Returning block of 160 for bucket 112 bucket 132: 30% Returning block of 179 for bucket 119 Reserving size (325) for bucket 133 bucket 130: 60% bucket 131: 50% Getting block 134 of 202 Calculating Z arrays for bucket 133 Getting block 135 of 202 bucket 132: 40% Reserving size (325) for bucket 134 Reserving size (325) for bucket 135 Entering block accumulator loop for bucket 133: Calculating Z arrays for bucket 134 Calculating Z arrays for bucket 135 bucket 131: 60% bucket 130: 70% Getting block 136 of 202 Entering block accumulator loop for bucket 134: Entering block accumulator loop for bucket 135: bucket 132: 50% Reserving size (325) for bucket 136 bucket 133: 10% Calculating Z arrays for bucket 136 Sorting block time: 00:00:00 bucket 131: 70% Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 130: 80% Returning block of 276 for bucket 122 Getting block 137 of 202 Returning block of 181 for bucket 118 Returning block of 160 for bucket 120 Entering block accumulator loop for bucket 136: bucket 132: 60% bucket 135: 10% bucket 134: 10% bucket 133: 20% Reserving size (325) for bucket 137 bucket 131: 80% bucket 130: 90% Calculating Z arrays for bucket 137 Getting block 138 of 202 bucket 132: 70% bucket 135: 20% Reserving size (325) for bucket 138 Entering block accumulator loop for bucket 137: bucket 134: 20% Sorting block time: 00:00:00 bucket 133: 30% Calculating Z arrays for bucket 138 Sorting block time: 00:00:00 bucket 131: 90% Returning block of 142 for bucket 124 bucket 136: 10% Sorting block time: 00:00:00 bucket 130: 100% Returning block of 240 for bucket 126 bucket 132: 80% bucket 135: 30% Entering block accumulator loop for bucket 138: Getting block 139 of 202 bucket 134: 30% Returning block of 279 for bucket 123 bucket 133: 40% Sorting block of length 141 for bucket 130 (Using difference cover) bucket 137: 10% bucket 131: 100% bucket 136: 20% Reserving size (325) for bucket 139 bucket 132: 90% bucket 135: 40% Getting block 140 of 202 Sorting block time: 00:00:00 bucket 134: 40% Sorting block time: 00:00:00 Sorting block of length 303 for bucket 131 (Using difference cover) Calculating Z arrays for bucket 139 bucket 133: 50% Reserving size (325) for bucket 140 bucket 137: 20% Returning block of 209 for bucket 127 bucket 138: 10% Returning block of 267 for bucket 128 bucket 136: 30% Sorting block time: 00:00:00 bucket 132: 100% bucket 135: 50% Getting block 141 of 202 Entering block accumulator loop for bucket 139: bucket 134: 50% Calculating Z arrays for bucket 140 bucket 133: 60% bucket 137: 30% Returning block of 294 for bucket 129 Sorting block of length 101 for bucket 132 (Using difference cover) Getting block 142 of 202 bucket 138: 20% Reserving size (325) for bucket 141 bucket 136: 40% bucket 135: 60% Entering block accumulator loop for bucket 140: Getting block 143 of 202 Getting block 144 of 202 bucket 134: 60% Reserving size (325) for bucket 142 bucket 133: 70% bucket 137: 40% Calculating Z arrays for bucket 141 Sorting block time: 00:00:00 Reserving size (325) for bucket 143 bucket 138: 30% Reserving size (325) for bucket 144 Getting block 145 of 202 bucket 139: 10% Calculating Z arrays for bucket 142 bucket 136: 50% bucket 135: 70% Returning block of 142 for bucket 130 Calculating Z arrays for bucket 143 Getting block 146 of 202 Entering block accumulator loop for bucket 141: Calculating Z arrays for bucket 144 bucket 134: 70% bucket 133: 80% Reserving size (325) for bucket 145 bucket 137: 50% bucket 140: 10% Entering block accumulator loop for bucket 142: bucket 138: 40% bucket 139: 20% Sorting block time: 00:00:00 Reserving size (325) for bucket 146 Entering block accumulator loop for bucket 143: bucket 136: 60% bucket 135: 80% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 144: Calculating Z arrays for bucket 145 Getting block 147 of 202 bucket 133: 90% bucket 134: 80% Returning block of 304 for bucket 131 Calculating Z arrays for bucket 146 bucket 137: 60% bucket 140: 20% bucket 138: 50% Returning block of 102 for bucket 132 Getting block 148 of 202 bucket 139: 30% Entering block accumulator loop for bucket 145: Reserving size (325) for bucket 147 bucket 135: 90% bucket 136: 70% bucket 141: 10% bucket 142: 10% Entering block accumulator loop for bucket 146: bucket 133: 100% bucket 134: 90% Reserving size (325) for bucket 148 bucket 137: 70% bucket 140: 30% Calculating Z arrays for bucket 147 bucket 143: 10% bucket 138: 60% bucket 144: 10% bucket 139: 40% Sorting block of length 228 for bucket 133 (Using difference cover) Calculating Z arrays for bucket 148 bucket 135: 100% Getting block 149 of 202 bucket 136: 80% bucket 142: 20% bucket 141: 20% Entering block accumulator loop for bucket 147: bucket 134: 100% bucket 137: 80% bucket 145: 10% bucket 140: 40% Sorting block of length 75 for bucket 135 (Using difference cover) Getting block 150 of 202 Entering block accumulator loop for bucket 148: bucket 143: 20% bucket 138: 70% Reserving size (325) for bucket 149 bucket 144: 20% bucket 139: 50% bucket 146: 10% Sorting block of length 263 for bucket 134 (Using difference cover) bucket 142: 30% bucket 136: 90% Reserving size (325) for bucket 150 bucket 141: 30% bucket 137: 90% Calculating Z arrays for bucket 149 Getting block 151 of 202 bucket 140: 50% bucket 145: 20% bucket 143: 30% bucket 138: 80% Calculating Z arrays for bucket 150 bucket 144: 30% bucket 139: 60% Sorting block time: 00:00:00 bucket 146: 20% bucket 147: 10% bucket 142: 40% bucket 136: 100% Reserving size (325) for bucket 151 Entering block accumulator loop for bucket 149: bucket 141: 40% bucket 148: 10% Getting block 152 of 202 bucket 137: 100% Entering block accumulator loop for bucket 150: Returning block of 229 for bucket 133 bucket 140: 60% bucket 145: 30% bucket 143: 40% bucket 138: 90% Sorting block of length 309 for bucket 136 (Using difference cover) bucket 144: 40% Sorting block time: 00:00:00 Calculating Z arrays for bucket 151 bucket 139: 70% Getting block 153 of 202 bucket 146: 30% bucket 147: 20% bucket 142: 50% Reserving size (325) for bucket 152 Sorting block of length 289 for bucket 137 (Using difference cover) bucket 141: 50% bucket 148: 20% Getting block 154 of 202 Returning block of 76 for bucket 135 bucket 140: 70% bucket 145: 40% bucket 143: 50% Entering block accumulator loop for bucket 151: bucket 138: 100% Reserving size (325) for bucket 153 bucket 144: 50% Sorting block time: 00:00:00 bucket 139: 80% bucket 149: 10% Calculating Z arrays for bucket 152 Getting block 155 of 202 bucket 142: 60% bucket 147: 30% bucket 146: 40% Reserving size (325) for bucket 154 bucket 150: 10% bucket 141: 60% bucket 148: 30% Sorting block of length 226 for bucket 138 (Using difference cover) Getting block 156 of 202 Sorting block time: 00:00:00 Calculating Z arrays for bucket 153 bucket 140: 80% Returning block of 264 for bucket 134 bucket 145: 50% bucket 143: 60% Entering block accumulator loop for bucket 152: bucket 144: 60% bucket 139: 90% bucket 149: 20% Reserving size (325) for bucket 155 Getting block 157 of 202 bucket 142: 70% Sorting block time: 00:00:00 Calculating Z arrays for bucket 154 bucket 147: 40% bucket 146: 50% bucket 150: 20% Sorting block time: 00:00:00 Reserving size (325) for bucket 156 Returning block of 310 for bucket 136 bucket 141: 70% bucket 151: 10% bucket 148: 40% Entering block accumulator loop for bucket 153: Getting block 158 of 202 bucket 140: 90% bucket 145: 60% bucket 143: 70% bucket 139: 100% bucket 144: 70% bucket 149: 30% Calculating Z arrays for bucket 155 Reserving size (325) for bucket 157 Returning block of 290 for bucket 137 bucket 142: 80% Getting block 159 of 202 Entering block accumulator loop for bucket 154: Getting block 160 of 202 Returning block of 227 for bucket 138 Calculating Z arrays for bucket 156 bucket 147: 50% bucket 150: 30% bucket 146: 60% Getting block 161 of 202 Reserving size (325) for bucket 158 bucket 141: 80% bucket 151: 20% bucket 148: 50% Sorting block of length 246 for bucket 139 (Using difference cover) bucket 152: 10% bucket 140: 100% bucket 145: 70% bucket 143: 80% bucket 144: 80% bucket 149: 40% Calculating Z arrays for bucket 157 Getting block 162 of 202 Entering block accumulator loop for bucket 155: Reserving size (325) for bucket 159 bucket 142: 90% Reserving size (325) for bucket 160 Entering block accumulator loop for bucket 156: Reserving size (325) for bucket 161 Calculating Z arrays for bucket 158 bucket 147: 60% bucket 150: 40% bucket 153: 10% bucket 146: 70% bucket 141: 90% bucket 151: 30% Sorting block of length 230 for bucket 140 Sorting block time: 00:00:00 (Using difference cover) bucket 148: 60% Reserving size (325) for bucket 162 Getting block 163 of 202 Entering block accumulator loop for bucket 157: bucket 152: 20% bucket 145: 80% bucket 143: 90% bucket 144: 90% bucket 149: 50% Calculating Z arrays for bucket 159 bucket 142: 100% Calculating Z arrays for bucket 160 Calculating Z arrays for bucket 161 bucket 154: 10% Entering block accumulator loop for bucket 158: Getting block 164 of 202 Returning block of 247 for bucket 139 bucket 147: 70% bucket 150: 50% bucket 153: 20% Getting block 165 of 202 Calculating Z arrays for bucket 162 bucket 146: 80% Sorting block time: 00:00:00 bucket 141: 100% Reserving size (325) for bucket 163 bucket 151: 40% bucket 148: 70% bucket 152: 30% bucket 145: 90% bucket 143: 100% bucket 144: 100% bucket 149: 60% Sorting block of length 308 for bucket 142 (Using difference cover) Entering block accumulator loop for bucket 159: Entering block accumulator loop for bucket 160: Entering block accumulator loop for bucket 161: bucket 155: 10% Reserving size (325) for bucket 164 bucket 156: 10% Sorting block time: 00:00:00 bucket 154: 20% Reserving size (325) for bucket 165 Returning block of 231 for bucket 140 Entering block accumulator loop for bucket 162: bucket 147: 80% bucket 150: 60% bucket 153: 30% bucket 146: 90% Sorting block of length 247 for bucket 141 (Using difference cover) Calculating Z arrays for bucket 163 Sorting block of length 321 for bucket 143 (Using difference cover) bucket 157: 10% Sorting block of length 204 for bucket 144 (Using difference cover) bucket 151: 50% bucket 148: 80% bucket 152: 40% bucket 145: 100% bucket 149: 70% Calculating Z arrays for bucket 164 bucket 158: 10% bucket 155: 20% bucket 156: 20% Returning block of 309 for bucket 142 Calculating Z arrays for bucket 165 bucket 154: 30% bucket 147: 90% bucket 150: 70% Getting block 166 of 202 bucket 153: 40% Entering block accumulator loop for bucket 163: bucket 146: 100% Sorting block of length 194 for bucket 145 (Using difference cover) bucket 157: 20% bucket 151: 60% bucket 148: 90% Entering block accumulator loop for bucket 164: bucket 159: 10% bucket 160: 10% bucket 161: 10% bucket 152: 50% bucket 149: 80% bucket 158: 20% Entering block accumulator loop for bucket 165: bucket 155: 30% bucket 156: 30% Getting block 167 of 202 Reserving size (325) for bucket 166 bucket 162: 10% bucket 154: 40% Sorting block of length 289 for bucket 146 (Using difference cover) bucket 147: 100% bucket 150: 80% bucket 153: 50% bucket 157: 30% bucket 151: 70% bucket 148: 100% bucket 159: 20% bucket 160: 20% bucket 161: 20% bucket 149: 90% bucket 152: 60% bucket 158: 30% Reserving size (325) for bucket 167 Calculating Z arrays for bucket 166 bucket 155: 40% bucket 156: 40% Sorting block of length 207 for bucket 147 (Using difference cover) bucket 162: 20% Getting block 168 of 202 bucket 154: 50% bucket 163: 10% Sorting block of length 255 for bucket 148 (Using difference cover) bucket 150: 90% bucket 164: 10% bucket 157: 40% bucket 153: 60% bucket 151: 80% Calculating Z arrays for bucket 167 bucket 159: 30% bucket 165: 10% bucket 160: 30% bucket 161: 30% Entering block accumulator loop for bucket 166: bucket 149: 100% bucket 158: 40% bucket 152: 70% Sorting block time: 00:00:00 Reserving size (325) for bucket 168 bucket 155: 50% bucket 156: 50% bucket 162: 30% Sorting block time: 00:00:00 bucket 154: 60% bucket 163: 20% Entering block accumulator loop for bucket 167: bucket 164: 20% bucket 150: 100% bucket 157: 50% bucket 153: 70% bucket 151: 90% Sorting block of length 121 for bucket 149 (Using difference cover) bucket 159: 40% bucket 160: 40% Returning block of 248 for bucket 141 bucket 161: 40% bucket 165: 20% Calculating Z arrays for bucket 168 Returning block of 205 for bucket 144 bucket 158: 50% bucket 152: 80% bucket 155: 60% Sorting block of length 226 for bucket 150 (Using difference cover) bucket 162: 40% bucket 156: 60% bucket 154: 70% bucket 163: 30% bucket 164: 30% bucket 166: 10% bucket 157: 60% bucket 153: 80% bucket 151: 100% bucket 160: 50% bucket 159: 50% Entering block accumulator loop for bucket 168: Sorting block time: 00:00:00 bucket 161: 50% bucket 165: 30% bucket 167: 10% bucket 158: 60% bucket 155: 70% bucket 152: 90% bucket 162: 50% bucket 156: 70% bucket 154: 80% bucket 163: 40% Sorting block of length 88 for bucket 151 (Using difference cover) bucket 164: 40% bucket 166: 20% Returning block of 322 for bucket 143 bucket 157: 70% bucket 153: 90% bucket 160: 60% bucket 159: 60% bucket 161: 60% bucket 165: 40% Getting block 169 of 202 bucket 167: 20% bucket 158: 70% bucket 155: 80% bucket 162: 60% bucket 152: 100% bucket 154: 90% Sorting block time: 00:00:00 bucket 156: 80% bucket 163: 50% bucket 164: 50% bucket 166: 30% bucket 168: 10% Reserving size (325) for bucket 169 Sorting block time: 00:00:00 Getting block 170 of 202 bucket 157: 80% bucket 160: 70% bucket 153: 100% bucket 161: 70% bucket 159: 70% Sorting block of length 244 for bucket 152 (Using difference cover) Returning block of 290 for bucket 146 bucket 165: 50% bucket 167: 30% bucket 155: 90% bucket 158: 80% bucket 162: 70% bucket 154: 100% Calculating Z arrays for bucket 169 Returning block of 195 for bucket 145 bucket 156: 90% Reserving size (325) for bucket 170 bucket 163: 60% bucket 164: 60% bucket 166: 40% Sorting block of length 211 for bucket 153 (Using difference cover) bucket 168: 20% bucket 157: 90% bucket 160: 80% bucket 161: 80% bucket 159: 80% Sorting block of length 128 for bucket 154 (Using difference cover) bucket 167: 40% Entering block accumulator loop for bucket 169: Calculating Z arrays for bucket 170 bucket 165: 60% bucket 155: 100% bucket 158: 90% bucket 162: 80% bucket 156: 100% bucket 163: 70% bucket 164: 70% bucket 166: 50% bucket 168: 30% bucket 160: 90% bucket 157: 100% bucket 161: 90% Entering block accumulator loop for bucket 170: Sorting block of length 283 for bucket 155 (Using difference cover) bucket 159: 90% Sorting block of length 208 for bucket 156 (Using difference cover) Sorting block time: 00:00:00 Getting block 171 of 202 bucket 167: 50% bucket 165: 70% bucket 162: 90% Sorting block of length 276 for bucket 157 (Using difference cover) bucket 158: 100% bucket 163: 80% bucket 164: 80% bucket 166: 60% bucket 168: 40% bucket 169: 10% bucket 160: 100% Returning block of 256 for bucket 148 bucket 161: 100% Reserving size (325) for bucket 171 bucket 159: 100% Sorting block of length 287 for bucket 158 (Using difference cover) Getting block 172 of 202 bucket 167: 60% bucket 162: 100% bucket 165: 80% Sorting block of length 282 for bucket 160 (Using difference cover) bucket 163: 90% bucket 170: 10% bucket 164: 90% Sorting block of length 248 for bucket 161 (Using difference cover) Calculating Z arrays for bucket 171 Sorting block time: 00:00:00 Getting block 173 of 202 Sorting block time: 00:00:00 bucket 166: 70% Sorting block of length 189 for bucket 159 (Using difference cover) bucket 168: 50% bucket 169: 20% Reserving size (325) for bucket 172 Sorting block of length 291 for bucket 162 (Using difference cover) bucket 167: 70% bucket 165: 90% Returning block of 122 for bucket 149 Reserving size (325) for bucket 173 Entering block accumulator loop for bucket 171: Returning block of 227 for bucket 150 bucket 163: 100% bucket 170: 20% bucket 164: 100% Calculating Z arrays for bucket 172 bucket 166: 80% Sorting block time: 00:00:00 bucket 168: 60% bucket 169: 30% Calculating Z arrays for bucket 173 bucket 167: 80% Sorting block of length 89 for bucket 163 (Using difference cover) Sorting block of length 298 for bucket 164 (Using difference cover) Getting block 174 of 202 bucket 165: 100% Returning block of 208 for bucket 147 Entering block accumulator loop for bucket 172: bucket 170: 30% bucket 166: 90% bucket 168: 70% Entering block accumulator loop for bucket 173: bucket 169: 40% bucket 171: 10% Reserving size (325) for bucket 174 bucket 167: 90% Sorting block of length 255 for bucket 165 (Using difference cover) Calculating Z arrays for bucket 174 bucket 170: 40% Getting block 175 of 202 bucket 166: 100% bucket 168: 80% bucket 169: 50% bucket 171: 20% Reserving size (325) for bucket 175 Entering block accumulator loop for bucket 174: Sorting block of length 290 for bucket 166 (Using difference cover) bucket 173: 10% bucket 167: 100% bucket 172: 10% Getting block 176 of 202 Calculating Z arrays for bucket 175 bucket 170: 50% bucket 168: 90% Sorting block of length 233 for bucket 167 (Using difference cover) bucket 171: 30% bucket 169: 60% Reserving size (325) for bucket 176 bucket 173: 20% Entering block accumulator loop for bucket 175: bucket 172: 20% Calculating Z arrays for bucket 176 bucket 174: 10% Getting block 177 of 202 bucket 170: 60% bucket 168: 100% bucket 171: 40% Entering block accumulator loop for bucket 176: Reserving size (325) for bucket 177 bucket 173: 30% bucket 169: 70% Sorting block of length 264 for bucket 168 (Using difference cover) bucket 172: 30% Calculating Z arrays for bucket 177 bucket 174: 20% bucket 175: 10% bucket 170: 70% bucket 171: 50% bucket 173: 40% Entering block accumulator loop for bucket 177: bucket 169: 80% bucket 176: 10% bucket 172: 40% bucket 174: 30% bucket 175: 20% bucket 170: 80% bucket 173: 50% bucket 171: 60% bucket 177: 10% bucket 169: 90% bucket 176: 20% bucket 174: 40% bucket 172: 50% bucket 175: 30% bucket 170: 90% bucket 173: 60% bucket 171: 70% bucket 177: 20% bucket 169: 100% bucket 176: 30% bucket 174: 50% Sorting block of length 121 for bucket 169 (Using difference cover) bucket 175: 40% bucket 172: 60% bucket 173: 70% bucket 170: 100% bucket 177: 30% bucket 171: 80% Sorting block of length 288 for bucket 170 (Using difference cover) bucket 176: 40% bucket 174: 60% bucket 175: 50% bucket 173: 80% bucket 172: 70% bucket 177: 40% bucket 171: 90% bucket 174: 70% bucket 173: 90% bucket 176: 50% bucket 175: 60% bucket 172: 80% bucket 177: 50% bucket 171: 100% Sorting block of length 104 for bucket 171 (Using difference cover) bucket 173: 100% bucket 174: 80% Sorting block of length 310 for bucket 173 (Using difference cover) bucket 175: 70% bucket 172: 90% bucket 176: 60% bucket 177: 60% bucket 174: 90% bucket 175: 80% bucket 172: 100% Sorting block of length 229 for bucket 172 (Using difference cover) bucket 177: 70% bucket 176: 70% bucket 174: 100% Sorting block of length 310 for bucket 174 (Using difference cover) bucket 175: 90% bucket 177: 80% bucket 176: 80% bucket 175: 100% Sorting block of length 117 for bucket 175 (Using difference cover) bucket 177: 90% bucket 176: 90% bucket 177: 100% Sorting block of length 292 for bucket 177 (Using difference cover) bucket 176: 100% Sorting block of length 153 for bucket 176 (Using difference cover) Sorting block time: 00:00:00 Returning block of 89 for bucket 151 Getting block 178 of 202 Reserving size (325) for bucket 178 Calculating Z arrays for bucket 178 Entering block accumulator loop for bucket 178: bucket 178: 10% bucket 178: 20% bucket 178: 30% bucket 178: 40% bucket 178: 50% bucket 178: 60% bucket 178: 70% bucket 178: 80% bucket 178: 90% bucket 178: 100% Sorting block of length 31 for bucket 178 (Using difference cover) Sorting block time: 00:00:00 Returning block of 129 for bucket 154 Sorting block time: 00:00:00 Returning block of 212 for bucket 153 Getting block 179 of 202 Reserving size (325) for bucket 179 Calculating Z arrays for bucket 179 Entering block accumulator loop for bucket 179: bucket 179: 10% Getting block 180 of 202 Reserving size (325) for bucket 180 Calculating Z arrays for bucket 180 Entering block accumulator loop for bucket 180: bucket 179: 20% bucket 180: 10% bucket 179: 30% bucket 180: 20% bucket 179: 40% bucket 180: 30% bucket 179: 50% bucket 180: 40% bucket 180: 50% bucket 179: 60% bucket 180: 60% bucket 179: 70% bucket 180: 70% bucket 179: 80% bucket 180: 80% bucket 179: 90% bucket 180: 90% bucket 179: 100% bucket 180: 100% Sorting block of length 323 for bucket 179 (Using difference cover) Sorting block of length 248 for bucket 180 (Using difference cover) Sorting block time: 00:00:00 Returning block of 292 for bucket 162 Sorting block time: 00:00:00 Returning block of 245 for bucket 152 Sorting block time: 00:00:00 Returning block of 284 for bucket 155 Sorting block time: 00:00:00 Returning block of 288 for bucket 158 Getting block 181 of 202 Reserving size (325) for bucket 181 Calculating Z arrays for bucket 181 Entering block accumulator loop for bucket 181: bucket 181: 10% bucket 181: 20% Getting block 182 of 202 Reserving size (325) for bucket 182 Calculating Z arrays for bucket 182 Entering block accumulator loop for bucket 182: bucket 181: 30% Getting block 183 of 202 bucket 181: 40% bucket 182: 10% Reserving size (325) for bucket 183 Calculating Z arrays for bucket 183 Entering block accumulator loop for bucket 183: bucket 181: 50% bucket 182: 20% Getting block 184 of 202 Reserving size (325) for bucket 184 Calculating Z arrays for bucket 184 bucket 183: 10% bucket 182: 30% bucket 181: 60% Entering block accumulator loop for bucket 184: bucket 183: 20% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 190 for bucket 159 Sorting block time: 00:00:00 Returning block of 299 for bucket 164 Returning block of 230 for bucket 172 Sorting block time: 00:00:00 bucket 182: 40% Sorting block time: 00:00:00 Returning block of 122 for bucket 169 Sorting block time: 00:00:00 bucket 181: 70% bucket 184: 10% Sorting block time: 00:00:00 Returning block of 249 for bucket 161 bucket 183: 30% Sorting block time: 00:00:00 Returning block of 277 for bucket 157 Returning block of 209 for bucket 156 Returning block of 265 for bucket 168 Returning block of 283 for bucket 160 bucket 182: 50% Returning block of 291 for bucket 166 Sorting block time: 00:00:00 bucket 181: 80% bucket 184: 20% bucket 183: 40% Returning block of 234 for bucket 167 Getting block 185 of 202 bucket 182: 60% Reserving size (325) for bucket 185 bucket 181: 90% bucket 184: 30% Calculating Z arrays for bucket 185 bucket 183: 50% Entering block accumulator loop for bucket 185: Sorting block time: 00:00:00 Getting block 186 of 202 Returning block of 105 for bucket 171 bucket 182: 70% Reserving size (325) for bucket 186 bucket 181: 100% bucket 184: 40% Sorting block time: 00:00:00 bucket 183: 60% Sorting block time: 00:00:00 bucket 185: 10% Calculating Z arrays for bucket 186 Sorting block of length 294 for bucket 181 (Using difference cover) Returning block of 256 for bucket 165 Returning block of 90 for bucket 163 bucket 182: 80% Entering block accumulator loop for bucket 186: bucket 184: 50% bucket 183: 70% bucket 185: 20% Getting block 187 of 202 bucket 182: 90% Reserving size (325) for bucket 187 Getting block 188 of 202 Calculating Z arrays for bucket 187 Reserving size (325) for bucket 188 bucket 185: 30% bucket 184: 60% bucket 186: 10% bucket 183: 80% Calculating Z arrays for bucket 188 Entering block accumulator loop for bucket 187: bucket 182: 100% bucket 185: 40% Entering block accumulator loop for bucket 188: Sorting block of length 256 for bucket 182 (Using difference cover) Getting block 189 of 202 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 186: 20% bucket 184: 70% bucket 183: 90% Returning block of 154 for bucket 176 Reserving size (325) for bucket 189 Returning block of 311 for bucket 174 Returning block of 289 for bucket 170 bucket 185: 50% bucket 187: 10% Calculating Z arrays for bucket 189 bucket 186: 30% bucket 188: 10% bucket 184: 80% bucket 183: 100% Getting block 190 of 202 Entering block accumulator loop for bucket 189: Sorting block of length 283 for bucket 183 (Using difference cover) Reserving size (325) for bucket 190 bucket 185: 60% Getting block 191 of 202 bucket 187: 20% bucket 186: 40% bucket 188: 20% Calculating Z arrays for bucket 190 bucket 184: 90% Reserving size (325) for bucket 191 bucket 189: 10% Entering block accumulator loop for bucket 190: bucket 185: 70% Calculating Z arrays for bucket 191 Getting block 192 of 202 Sorting block time: 00:00:00 bucket 187: 30% Sorting block time: 00:00:00 bucket 186: 50% bucket 188: 30% Returning block of 118 for bucket 175 Entering block accumulator loop for bucket 191: bucket 184: 100% Reserving size (325) for bucket 192 bucket 189: 20% Returning block of 311 for bucket 173 bucket 185: 80% Sorting block of length 127 for bucket 184 (Using difference cover) bucket 190: 10% bucket 187: 40% Calculating Z arrays for bucket 192 bucket 186: 60% Sorting block time: 00:00:00 bucket 188: 40% Sorting block time: 00:00:00 Getting block 193 of 202 bucket 189: 30% bucket 185: 90% bucket 191: 10% Returning block of 293 for bucket 177 Entering block accumulator loop for bucket 192: bucket 190: 20% Returning block of 32 for bucket 178 Reserving size (325) for bucket 193 bucket 187: 50% bucket 186: 70% bucket 188: 50% bucket 189: 40% bucket 185: 100% bucket 191: 20% Calculating Z arrays for bucket 193 Getting block 194 of 202 bucket 190: 30% Sorting block of length 229 for bucket 185 (Using difference cover) Entering block accumulator loop for bucket 193: Reserving size (325) for bucket 194 bucket 186: 80% Getting block 195 of 202 bucket 187: 60% bucket 192: 10% bucket 188: 60% bucket 189: 50% bucket 191: 30% Calculating Z arrays for bucket 194 bucket 190: 40% Reserving size (325) for bucket 195 bucket 186: 90% Entering block accumulator loop for bucket 194: bucket 192: 20% Sorting block time: 00:00:00 Calculating Z arrays for bucket 195 Getting block 196 of 202 bucket 187: 70% bucket 188: 70% bucket 193: 10% bucket 191: 40% bucket 189: 60% Returning block of 295 for bucket 181 bucket 190: 50% Entering block accumulator loop for bucket 195: Reserving size (325) for bucket 196 bucket 186: 100% bucket 192: 30% bucket 194: 10% bucket 193: 20% bucket 188: 80% bucket 187: 80% Calculating Z arrays for bucket 196 bucket 191: 50% Sorting block of length 285 for bucket 186 (Using difference cover) bucket 189: 70% Getting block 197 of 202 bucket 190: 60% Sorting block time: 00:00:00 bucket 192: 40% bucket 194: 20% Entering block accumulator loop for bucket 196: bucket 193: 30% bucket 188: 90% Sorting block time: 00:00:00 bucket 195: 10% Reserving size (325) for bucket 197 bucket 187: 90% Getting block 198 of 202 Returning block of 249 for bucket 180 bucket 191: 60% bucket 189: 80% bucket 190: 70% Returning block of 324 for bucket 179 bucket 192: 50% bucket 194: 30% Calculating Z arrays for bucket 197 bucket 193: 40% Reserving size (325) for bucket 198 bucket 188: 100% bucket 195: 20% bucket 187: 100% Getting block 199 of 202 bucket 191: 70% bucket 189: 90% bucket 196: 10% bucket 190: 80% Entering block accumulator loop for bucket 197: Calculating Z arrays for bucket 198 Sorting block of length 265 for bucket 188 (Using difference cover) Sorting block time: 00:00:00 Getting block 200 of 202 Sorting block of length 315 for bucket 187 (Using difference cover) bucket 194: 40% bucket 192: 60% bucket 193: 50% Reserving size (325) for bucket 199 bucket 195: 30% bucket 191: 80% Entering block accumulator loop for bucket 198: bucket 189: 100% bucket 196: 20% bucket 190: 90% Returning block of 257 for bucket 182 Reserving size (325) for bucket 200 Sorting block time: 00:00:00 Getting block 201 of 202 Sorting block time: 00:00:00 Calculating Z arrays for bucket 199 bucket 194: 50% bucket 192: 70% Sorting block of length 321 for bucket 189 (Using difference cover) bucket 193: 60% Getting block 202 of 202 bucket 195: 40% bucket 197: 10% bucket 191: 90% Calculating Z arrays for bucket 200 Returning block of 128 for bucket 184 Returning block of 284 for bucket 183 Reserving size (325) for bucket 201 bucket 190: 100% Entering block accumulator loop for bucket 199: bucket 198: 10% Reserving size (325) for bucket 202 bucket 196: 30% bucket 194: 60% bucket 192: 80% Sorting block time: 00:00:00 bucket 193: 70% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 200: bucket 195: 50% bucket 197: 20% Calculating Z arrays for bucket 201 bucket 191: 100% Sorting block of length 312 for bucket 190 (Using difference cover) Calculating Z arrays for bucket 202 bucket 198: 20% Returning block of 286 for bucket 186 Returning block of 230 for bucket 185 bucket 196: 40% bucket 192: 90% bucket 194: 70% Sorting block of length 224 for bucket 191 (Using difference cover) Entering block accumulator loop for bucket 201: bucket 193: 80% bucket 197: 30% bucket 195: 60% Entering block accumulator loop for bucket 202: bucket 199: 10% bucket 198: 30% bucket 200: 10% bucket 196: 50% bucket 192: 100% bucket 194: 80% bucket 193: 90% bucket 197: 40% Sorting block of length 300 for bucket 192 (Using difference cover) bucket 195: 70% bucket 199: 20% bucket 198: 40% bucket 201: 10% bucket 202: 10% bucket 200: 20% bucket 196: 60% bucket 194: 90% bucket 193: 100% bucket 197: 50% bucket 199: 30% bucket 195: 80% Sorting block of length 277 for bucket 193 (Using difference cover) bucket 202: 20% bucket 198: 50% bucket 201: 20% bucket 200: 30% bucket 196: 70% bucket 194: 100% bucket 199: 40% bucket 197: 60% bucket 195: 90% bucket 202: 30% Sorting block of length 183 for bucket 194 (Using difference cover) bucket 201: 30% bucket 198: 60% bucket 200: 40% bucket 196: 80% bucket 199: 50% bucket 202: 40% bucket 197: 70% bucket 195: 100% bucket 201: 40% Sorting block of length 277 for bucket 195 (Using difference cover) bucket 198: 70% bucket 200: 50% bucket 202: 50% bucket 196: 90% bucket 199: 60% bucket 197: 80% bucket 201: 50% bucket 198: 80% bucket 202: 60% bucket 200: 60% bucket 196: 100% bucket 197: 90% bucket 199: 70% Sorting block of length 122 for bucket 196 (Using difference cover) bucket 201: 60% bucket 202: 70% bucket 198: 90% bucket 200: 70% bucket 197: 100% bucket 199: 80% Sorting block of length 204 for bucket 197 (Using difference cover) bucket 202: 80% bucket 201: 70% bucket 198: 100% Sorting block of length 317 for bucket 198 (Using difference cover) bucket 200: 80% bucket 199: 90% bucket 202: 90% bucket 201: 80% bucket 202: 100% bucket 200: 90% Sorting block of length 204 for bucket 202 (Using difference cover) bucket 199: 100% bucket 201: 90% Sorting block of length 286 for bucket 199 (Using difference cover) bucket 200: 100% Sorting block of length 154 for bucket 200 (Using difference cover) Sorting block time: 00:00:00 Returning block of 266 for bucket 188 bucket 201: 100% Sorting block of length 307 for bucket 201 (Using difference cover) Sorting block time: 00:00:00 Returning block of 316 for bucket 187 Sorting block time: 00:00:00 Returning block of 322 for bucket 189 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 278 for bucket 193 Sorting block time: 00:00:00 Returning block of 313 for bucket 190 Returning block of 225 for bucket 191 Sorting block time: 00:00:00 Returning block of 205 for bucket 202 Sorting block time: 00:00:00 Returning block of 318 for bucket 198 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 278 for bucket 195 Sorting block time: 00:00:00 Returning block of 123 for bucket 196 Sorting block time: 00:00:00 Returning block of 155 for bucket 200 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 301 for bucket 192 Returning block of 287 for bucket 199 Returning block of 308 for bucket 201 Returning block of 205 for bucket 197 Returning block of 184 for bucket 194 Exited Ebwt loop fchr[A]: 0 fchr[C]: 25154 fchr[G]: 36516 fchr[T]: 36516 fchr[$]: 48502 Exiting Ebwt::buildToDisk() Returning from initFromVector Wrote 4210679 bytes to primary EBWT file: BS_GA.1.bt2 Wrote 12132 bytes to secondary EBWT file: BS_GA.2.bt2 Re-opening _in1 and _in2 as input streams Returning from Ebwt constructor Headers: len: 48502 bwtLen: 48503 sz: 12126 bwtSz: 12126 lineRate: 6 offRate: 4 offMask: 0xfffffff0 ftabChars: 10 eftabLen: 20 eftabSz: 80 ftabLen: 1048577 ftabSz: 4194308 offsLen: 3032 offsSz: 12128 lineSz: 64 sideSz: 64 sideBwtSz: 48 sideBwtLen: 192 numSides: 253 numLines: 253 ebwtTotLen: 16192 ebwtTotSz: 16192 color: 0 reverse: 0 Total time for call to driver() for forward index: 00:00:00 Reading reference sizes Time reading reference sizes: 00:00:00 Calculating joined length Writing header Reserving space for joined string Joining reference sequences Time to join reference sequences: 00:00:00 Time to reverse reference sequence: 00:00:00 bmax according to bmaxDivN setting: 433 Using parameters --bmax 325 --dcv 1024 Doing ahead-of-time memory usage test Passed! Constructing with these parameters: --bmax 325 --dcv 1024 Constructing suffix-array element generator Building DifferenceCoverSample Building sPrime Building sPrimeOrder V-Sorting samples V-Sorting samples time: 00:00:00 Allocating rank array Ranking v-sort output Ranking v-sort output time: 00:00:00 Invoking Larsson-Sadakane on ranks Invoking Larsson-Sadakane on ranks time: 00:00:00 Sanity-checking and returning Building samples Reserving space for 300 sample suffixes Generating random suffixes QSorting 300 sample offsets, eliminating duplicates QSorting sample offsets, eliminating duplicates time: 00:00:00 Multikey QSorting 299 samples (Using difference cover) Multikey QSorting samples time: 00:00:00 Calculating bucket sizes Splitting and merging Splitting and merging time: 00:00:00 Split 35, merged 129; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 19, merged 13; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 8, merged 12; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 2, merged 3; iterating... Splitting and merging Splitting and merging time: 00:00:00 Split 1, merged 2; iterating... Avg bucket size: 234.451 (target: 324) Converting suffix-array elements to index image Allocating ftab, absorbFtab Entering Ebwt loop Getting block 1 of 206 Reserving size (325) for bucket 1 Getting block 2 of 206 Getting block 3 of 206 Getting block 4 of 206 Calculating Z arrays for bucket 1 Reserving size (325) for bucket 2 Reserving size (325) for bucket 3 Reserving size (325) for bucket 4 Getting block 5 of 206 Getting block 6 of 206 Getting block 7 of 206 Entering block accumulator loop for bucket 1: Getting block 8 of 206 Getting block 9 of 206 Getting block 10 of 206 Calculating Z arrays for bucket 2 Getting block 11 of 206 Getting block 12 of 206 Getting block 13 of 206 Getting block 14 of 206 Getting block 15 of 206 Getting block 16 of 206 Getting block 17 of 206 Calculating Z arrays for bucket 3 Getting block 18 of 206 Getting block 19 of 206 Getting block 20 of 206 Getting block 21 of 206 Getting block 22 of 206 Getting block 23 of 206 Getting block 24 of 206 Getting block 25 of 206 Getting block 26 of 206 Calculating Z arrays for bucket 4 Reserving size (325) for bucket 5 Reserving size (325) for bucket 6 Reserving size (325) for bucket 7 Reserving size (325) for bucket 8 Reserving size (325) for bucket 9 Reserving size (325) for bucket 10 Reserving size (325) for bucket 11 Entering block accumulator loop for bucket 2: Reserving size (325) for bucket 12 Reserving size (325) for bucket 13 Reserving size (325) for bucket 14 Reserving size (325) for bucket 15 Reserving size (325) for bucket 16 Reserving size (325) for bucket 17 Entering block accumulator loop for bucket 3: Reserving size (325) for bucket 18 Reserving size (325) for bucket 19 Reserving size (325) for bucket 20 Reserving size (325) for bucket 21 Reserving size (325) for bucket 22 Reserving size (325) for bucket 23 Reserving size (325) for bucket 24 Reserving size (325) for bucket 25 Reserving size (325) for bucket 26 Getting block 27 of 206 Calculating Z arrays for bucket 5 Calculating Z arrays for bucket 6 Entering block accumulator loop for bucket 4: Calculating Z arrays for bucket 7 Calculating Z arrays for bucket 8 Calculating Z arrays for bucket 9 Calculating Z arrays for bucket 10 Calculating Z arrays for bucket 11 bucket 1: 10% Calculating Z arrays for bucket 12 Calculating Z arrays for bucket 13 Calculating Z arrays for bucket 14 Calculating Z arrays for bucket 15 Calculating Z arrays for bucket 16 Calculating Z arrays for bucket 17 Calculating Z arrays for bucket 18 Calculating Z arrays for bucket 19 Calculating Z arrays for bucket 20 Calculating Z arrays for bucket 21 Calculating Z arrays for bucket 22 Calculating Z arrays for bucket 23 Calculating Z arrays for bucket 24 Calculating Z arrays for bucket 25 Calculating Z arrays for bucket 26 Reserving size (325) for bucket 27 Entering block accumulator loop for bucket 5: Entering block accumulator loop for bucket 6: Entering block accumulator loop for bucket 7: Entering block accumulator loop for bucket 8: Entering block accumulator loop for bucket 9: Entering block accumulator loop for bucket 10: Entering block accumulator loop for bucket 11: Entering block accumulator loop for bucket 12: bucket 1: 20% Entering block accumulator loop for bucket 13: Entering block accumulator loop for bucket 14: Entering block accumulator loop for bucket 15: bucket 2: 10% Entering block accumulator loop for bucket 16: Entering block accumulator loop for bucket 17: bucket 3: 10% Entering block accumulator loop for bucket 18: Entering block accumulator loop for bucket 19: Entering block accumulator loop for bucket 20: Entering block accumulator loop for bucket 21: Entering block accumulator loop for bucket 22: Entering block accumulator loop for bucket 24: Entering block accumulator loop for bucket 23: Calculating Z arrays for bucket 27 Entering block accumulator loop for bucket 25: Entering block accumulator loop for bucket 26: bucket 4: 10% bucket 1: 30% bucket 3: 20% bucket 2: 20% Entering block accumulator loop for bucket 27: bucket 5: 10% bucket 3: 30% bucket 1: 40% bucket 10: 10% bucket 6: 10% bucket 11: 10% bucket 7: 10% bucket 8: 10% bucket 9: 10% bucket 4: 20% bucket 14: 10% bucket 15: 10% bucket 12: 10% bucket 13: 10% bucket 17: 10% bucket 16: 10% bucket 18: 10% bucket 19: 10% bucket 20: 10% bucket 2: 30% bucket 21: 10% bucket 24: 10% bucket 22: 10% bucket 23: 10% bucket 25: 10% bucket 26: 10% bucket 3: 40% bucket 5: 20% bucket 1: 50% bucket 10: 20% bucket 6: 20% bucket 11: 20% bucket 7: 20% bucket 8: 20% bucket 4: 30% bucket 9: 20% bucket 27: 10% bucket 14: 20% bucket 15: 20% bucket 12: 20% bucket 13: 20% bucket 17: 20% bucket 16: 20% bucket 18: 20% bucket 19: 20% bucket 24: 20% bucket 2: 40% bucket 20: 20% bucket 21: 20% bucket 22: 20% bucket 3: 50% bucket 23: 20% bucket 25: 20% bucket 1: 60% bucket 5: 30% bucket 26: 20% bucket 10: 30% bucket 11: 30% bucket 6: 30% bucket 7: 30% bucket 8: 30% bucket 4: 40% bucket 9: 30% bucket 27: 20% bucket 14: 30% bucket 15: 30% bucket 12: 30% bucket 13: 30% bucket 17: 30% bucket 24: 30% bucket 16: 30% bucket 18: 30% bucket 19: 30% bucket 2: 50% bucket 3: 60% bucket 20: 30% bucket 21: 30% bucket 22: 30% bucket 1: 70% bucket 23: 30% bucket 25: 30% bucket 5: 40% bucket 10: 40% bucket 11: 40% bucket 26: 30% bucket 6: 40% bucket 7: 40% bucket 8: 40% bucket 4: 50% bucket 9: 40% bucket 27: 30% bucket 14: 40% bucket 15: 40% bucket 24: 40% bucket 12: 40% bucket 13: 40% bucket 17: 40% bucket 16: 40% bucket 3: 70% bucket 18: 40% bucket 19: 40% bucket 2: 60% bucket 20: 40% bucket 1: 80% bucket 21: 40% bucket 22: 40% bucket 23: 40% bucket 5: 50% bucket 25: 40% bucket 11: 50% bucket 10: 50% bucket 26: 40% bucket 6: 50% bucket 7: 50% bucket 8: 50% bucket 4: 60% bucket 9: 50% bucket 24: 50% bucket 27: 40% bucket 14: 50% bucket 15: 50% bucket 12: 50% bucket 3: 80% bucket 13: 50% bucket 17: 50% bucket 16: 50% bucket 18: 50% bucket 19: 50% bucket 2: 70% bucket 1: 90% bucket 20: 50% bucket 21: 50% bucket 22: 50% bucket 23: 50% bucket 5: 60% bucket 11: 60% bucket 25: 50% bucket 10: 60% bucket 6: 60% bucket 26: 50% bucket 7: 60% bucket 24: 60% bucket 8: 60% bucket 4: 70% bucket 9: 60% bucket 27: 50% bucket 14: 60% bucket 3: 90% bucket 15: 60% bucket 12: 60% bucket 13: 60% bucket 17: 60% bucket 16: 60% bucket 1: 100% bucket 18: 60% bucket 19: 60% bucket 2: 80% bucket 20: 60% bucket 21: 60% bucket 22: 60% bucket 23: 60% bucket 11: 70% bucket 5: 70% bucket 10: 70% bucket 25: 60% bucket 6: 70% bucket 24: 70% bucket 26: 60% bucket 7: 70% bucket 8: 70% bucket 4: 80% bucket 3: 100% bucket 9: 70% bucket 27: 60% Sorting block of length 149 for bucket 1 (Using difference cover) bucket 14: 70% bucket 15: 70% bucket 12: 70% bucket 13: 70% bucket 17: 70% bucket 16: 70% bucket 18: 70% bucket 19: 70% bucket 2: 90% bucket 20: 70% bucket 21: 70% bucket 22: 70% bucket 11: 80% bucket 23: 70% bucket 5: 80% bucket 10: 80% bucket 24: 80% Sorting block time: 00:00:00 Sorting block of length 122 for bucket 3 (Using difference cover) bucket 25: 70% bucket 6: 80% bucket 26: 70% bucket 7: 80% bucket 8: 80% bucket 4: 90% bucket 9: 80% bucket 27: 70% bucket 14: 80% bucket 15: 80% bucket 12: 80% bucket 13: 80% bucket 17: 80% bucket 16: 80% bucket 18: 80% bucket 2: 100% bucket 19: 80% bucket 20: 80% Sorting block time: 00:00:00 bucket 11: 90% bucket 21: 80% bucket 22: 80% bucket 24: 90% Returning block of 150 for bucket 1 bucket 5: 90% bucket 23: 80% bucket 10: 90% bucket 25: 80% bucket 6: 90% bucket 26: 80% bucket 7: 90% bucket 8: 90% bucket 4: 100% bucket 9: 90% bucket 27: 80% bucket 14: 90% bucket 15: 90% Sorting block of length 292 for bucket 2 (Using difference cover) bucket 12: 90% bucket 13: 90% Returning block of 123 for bucket 3 bucket 17: 90% bucket 16: 90% bucket 18: 90% bucket 19: 90% bucket 11: 100% bucket 20: 90% bucket 24: 100% bucket 21: 90% bucket 22: 90% bucket 5: 100% bucket 23: 90% bucket 10: 100% bucket 25: 90% Sorting block of length 311 for bucket 4 (Using difference cover) bucket 26: 90% bucket 7: 100% bucket 8: 100% bucket 9: 100% bucket 27: 90% bucket 14: 100% bucket 15: 100% bucket 6: 100% bucket 12: 100% Sorting block of length 235 for bucket 11 (Using difference cover) Sorting block of length 256 for bucket 24 (Using difference cover) bucket 17: 100% bucket 16: 100% Sorting block of length 146 for bucket 5 (Using difference cover) bucket 18: 100% Sorting block of length 239 for bucket 10 (Using difference cover) bucket 19: 100% bucket 20: 100% bucket 21: 100% bucket 22: 100% Sorting block of length 120 for bucket 7 (Using difference cover) bucket 23: 100% Sorting block of length 321 for bucket 8 (Using difference cover) Sorting block of length 206 for bucket 9 (Using difference cover) bucket 25: 100% Sorting block of length 148 for bucket 14 (Using difference cover) Sorting block of length 321 for bucket 15 (Using difference cover) Getting block 28 of 206 bucket 26: 100% Sorting block of length 283 for bucket 6 (Using difference cover) Sorting block of length 166 for bucket 12 (Using difference cover) bucket 27: 100% bucket 13: 100% Sorting block of length 248 for bucket 17 (Using difference cover) Sorting block of length 128 for bucket 16 (Using difference cover) Sorting block of length 275 for bucket 18 (Using difference cover) Sorting block of length 282 for bucket 19 (Using difference cover) Sorting block of length 166 for bucket 20 (Using difference cover) Sorting block of length 288 for bucket 21 (Using difference cover) Sorting block of length 146 for bucket 22 (Using difference cover) Sorting block of length 302 for bucket 23 (Using difference cover) Sorting block of length 300 for bucket 25 (Using difference cover) Reserving size (325) for bucket 28 Sorting block of length 276 for bucket 26 (Using difference cover) Getting block 29 of 206 Sorting block of length 196 for bucket 27 (Using difference cover) Sorting block of length 200 for bucket 13 Calculating Z arrays for bucket 28 (Using difference cover) Reserving size (325) for bucket 29 Calculating Z arrays for bucket 29 Entering block accumulator loop for bucket 28: Entering block accumulator loop for bucket 29: bucket 28: 10% bucket 29: 10% bucket 28: 20% bucket 28: 30% bucket 29: 20% bucket 28: 40% bucket 29: 30% Sorting block time: 00:00:00 Returning block of 293 for bucket 2 bucket 28: 50% bucket 29: 40% bucket 28: 60% bucket 28: 70% bucket 29: 50% bucket 28: 80% bucket 29: 60% Getting block 30 of 206 bucket 28: 90% Reserving size (325) for bucket 30 Calculating Z arrays for bucket 30 Entering block accumulator loop for bucket 30: bucket 29: 70% bucket 28: 100% Sorting block of length 155 for bucket 28 (Using difference cover) bucket 30: 10% bucket 29: 80% bucket 30: 20% bucket 29: 90% bucket 30: 30% bucket 29: 100% Sorting block of length 302 for bucket 29 (Using difference cover) bucket 30: 40% bucket 30: 50% bucket 30: 60% bucket 30: 70% bucket 30: 80% bucket 30: 90% bucket 30: 100% Sorting block of length 156 for bucket 30 (Using difference cover) Sorting block time: 00:00:00 Returning block of 312 for bucket 4 Getting block 31 of 206 Reserving size (325) for bucket 31 Calculating Z arrays for bucket 31 Entering block accumulator loop for bucket 31: bucket 31: 10% bucket 31: 20% bucket 31: 30% bucket 31: 40% bucket 31: 50% bucket 31: 60% bucket 31: 70% bucket 31: 80% bucket 31: 90% bucket 31: 100% Sorting block of length 252 for bucket 31 (Using difference cover) Sorting block time: 00:00:00 Returning block of 257 for bucket 24 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 147 for bucket 5 Returning block of 276 for bucket 18 Sorting block time: 00:00:00 Returning block of 236 for bucket 11 Getting block 32 of 206 Reserving size (325) for bucket 32 Calculating Z arrays for bucket 32 Entering block accumulator loop for bucket 32: bucket 32: 10% Sorting block time: 00:00:00 Returning block of 157 for bucket 30 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Getting block 33 of 206 Returning block of 121 for bucket 7 Sorting block time: 00:00:00 Returning block of 249 for bucket 17 Reserving size (325) for bucket 33 bucket 32: 20% Returning block of 201 for bucket 13 Sorting block time: 00:00:00 Calculating Z arrays for bucket 33 Returning block of 277 for bucket 26 Entering block accumulator loop for bucket 33: bucket 32: 30% Getting block 34 of 206 Reserving size (325) for bucket 34 Calculating Z arrays for bucket 34 Sorting block time: 00:00:00 Returning block of 284 for bucket 6 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 240 for bucket 10 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 32: 40% Entering block accumulator loop for bucket 34: bucket 33: 10% Returning block of 289 for bucket 21 Returning block of 207 for bucket 9 Returning block of 149 for bucket 14 bucket 32: 50% Getting block 35 of 206 bucket 33: 20% Reserving size (325) for bucket 35 Getting block 36 of 206 Calculating Z arrays for bucket 35 Reserving size (325) for bucket 36 bucket 32: 60% bucket 34: 10% Calculating Z arrays for bucket 36 bucket 33: 30% Entering block accumulator loop for bucket 35: Entering block accumulator loop for bucket 36: bucket 32: 70% bucket 34: 20% bucket 33: 40% Getting block 37 of 206 bucket 35: 10% bucket 32: 80% Reserving size (325) for bucket 37 bucket 36: 10% bucket 33: 50% Calculating Z arrays for bucket 37 bucket 34: 30% bucket 32: 90% bucket 35: 20% Entering block accumulator loop for bucket 37: bucket 33: 60% bucket 36: 20% Getting block 38 of 206 bucket 32: 100% bucket 34: 40% Reserving size (325) for bucket 38 Sorting block of length 181 for bucket 32 (Using difference cover) bucket 35: 30% bucket 33: 70% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 37: 10% Sorting block time: 00:00:00 Calculating Z arrays for bucket 38 bucket 36: 30% Returning block of 167 for bucket 20 Sorting block time: 00:00:00 Returning block of 156 for bucket 28 Returning block of 167 for bucket 12 Sorting block time: 00:00:00 Returning block of 147 for bucket 22 Sorting block time: 00:00:00 bucket 34: 50% Sorting block time: 00:00:00 Returning block of 283 for bucket 19 Sorting block time: 00:00:00 bucket 33: 80% Sorting block time: 00:00:00 bucket 35: 40% Entering block accumulator loop for bucket 38: Returning block of 322 for bucket 8 bucket 37: 20% Sorting block time: 00:00:00 bucket 36: 40% Returning block of 322 for bucket 15 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 301 for bucket 25 Getting block 39 of 206 Returning block of 303 for bucket 23 Returning block of 303 for bucket 29 Returning block of 129 for bucket 16 bucket 34: 60% bucket 33: 90% Returning block of 197 for bucket 27 bucket 35: 50% Getting block 40 of 206 Returning block of 182 for bucket 32 Returning block of 253 for bucket 31 bucket 37: 30% bucket 36: 50% Reserving size (325) for bucket 39 Getting block 41 of 206 bucket 38: 10% Reserving size (325) for bucket 40 bucket 33: 100% bucket 34: 70% bucket 35: 60% Calculating Z arrays for bucket 39 Getting block 42 of 206 Reserving size (325) for bucket 41 Calculating Z arrays for bucket 40 Sorting block of length 235 for bucket 33 (Using difference cover) bucket 37: 40% bucket 36: 60% Entering block accumulator loop for bucket 39: Reserving size (325) for bucket 42 Getting block 43 of 206 Calculating Z arrays for bucket 41 bucket 38: 20% bucket 34: 80% bucket 35: 70% Entering block accumulator loop for bucket 40: Getting block 44 of 206 Calculating Z arrays for bucket 42 Reserving size (325) for bucket 43 bucket 37: 50% bucket 36: 70% Entering block accumulator loop for bucket 41: Reserving size (325) for bucket 44 Calculating Z arrays for bucket 43 Getting block 45 of 206 bucket 38: 30% bucket 34: 90% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 42: bucket 39: 10% bucket 35: 80% Calculating Z arrays for bucket 44 Reserving size (325) for bucket 45 Entering block accumulator loop for bucket 43: bucket 37: 60% Returning block of 236 for bucket 33 bucket 36: 80% bucket 40: 10% Calculating Z arrays for bucket 45 Getting block 46 of 206 bucket 38: 40% bucket 39: 20% bucket 34: 100% Entering block accumulator loop for bucket 44: bucket 41: 10% bucket 35: 90% Reserving size (325) for bucket 46 Entering block accumulator loop for bucket 45: bucket 37: 70% Getting block 47 of 206 Sorting block of length 164 for bucket 34 (Using difference cover) bucket 36: 90% bucket 42: 10% bucket 40: 20% bucket 39: 30% Calculating Z arrays for bucket 46 bucket 38: 50% bucket 43: 10% Reserving size (325) for bucket 47 bucket 41: 20% bucket 35: 100% bucket 37: 80% Getting block 48 of 206 Entering block accumulator loop for bucket 46: bucket 39: 40% Calculating Z arrays for bucket 47 bucket 36: 100% bucket 44: 10% bucket 42: 20% Sorting block of length 290 for bucket 35 (Using difference cover) bucket 40: 30% bucket 45: 10% Reserving size (325) for bucket 48 bucket 38: 60% bucket 43: 20% Sorting block time: 00:00:00 Sorting block of length 219 for bucket 36 (Using difference cover) bucket 41: 30% Entering block accumulator loop for bucket 47: bucket 37: 90% bucket 39: 50% Calculating Z arrays for bucket 48 bucket 44: 20% Getting block 49 of 206 bucket 42: 30% Returning block of 165 for bucket 34 bucket 40: 40% bucket 45: 20% bucket 46: 10% bucket 38: 70% Getting block 50 of 206 bucket 43: 30% bucket 41: 40% Entering block accumulator loop for bucket 48: bucket 39: 60% Reserving size (325) for bucket 49 bucket 37: 100% bucket 44: 30% bucket 42: 40% Reserving size (325) for bucket 50 bucket 40: 50% bucket 47: 10% bucket 45: 30% Calculating Z arrays for bucket 49 bucket 46: 20% bucket 38: 80% Sorting block time: 00:00:00 Sorting block of length 278 for bucket 37 (Using difference cover) Getting block 51 of 206 bucket 39: 70% bucket 41: 50% bucket 43: 40% Calculating Z arrays for bucket 50 bucket 44: 40% bucket 42: 50% Entering block accumulator loop for bucket 49: Returning block of 291 for bucket 35 Getting block 52 of 206 bucket 40: 60% bucket 48: 10% bucket 47: 20% bucket 45: 40% Reserving size (325) for bucket 51 Sorting block time: 00:00:00 bucket 46: 30% bucket 38: 90% bucket 39: 80% Entering block accumulator loop for bucket 50: bucket 41: 60% Reserving size (325) for bucket 52 bucket 43: 50% bucket 44: 50% bucket 42: 60% Returning block of 220 for bucket 36 Calculating Z arrays for bucket 51 Getting block 53 of 206 bucket 40: 70% bucket 48: 20% bucket 47: 30% Getting block 54 of 206 bucket 45: 50% Calculating Z arrays for bucket 52 bucket 39: 90% bucket 46: 40% bucket 38: 100% bucket 49: 10% bucket 41: 70% Reserving size (325) for bucket 53 Entering block accumulator loop for bucket 51: bucket 43: 60% Sorting block time: 00:00:00 bucket 44: 60% bucket 42: 70% Reserving size (325) for bucket 54 bucket 40: 80% Entering block accumulator loop for bucket 52: Sorting block of length 245 for bucket 38 (Using difference cover) Getting block 55 of 206 bucket 48: 30% bucket 47: 40% bucket 50: 10% bucket 39: 100% Calculating Z arrays for bucket 53 bucket 45: 60% Returning block of 279 for bucket 37 bucket 46: 50% bucket 49: 20% bucket 41: 80% Calculating Z arrays for bucket 54 Getting block 56 of 206 bucket 43: 70% bucket 44: 70% Reserving size (325) for bucket 55 bucket 42: 80% bucket 40: 90% Sorting block of length 304 for bucket 39 (Using difference cover) Entering block accumulator loop for bucket 53: bucket 48: 40% bucket 47: 50% bucket 50: 20% bucket 45: 70% bucket 51: 10% Reserving size (325) for bucket 56 Getting block 57 of 206 Entering block accumulator loop for bucket 54: bucket 46: 60% bucket 49: 30% Calculating Z arrays for bucket 55 bucket 41: 90% Getting block 58 of 206 bucket 52: 10% bucket 44: 80% bucket 43: 80% bucket 42: 90% bucket 40: 100% Calculating Z arrays for bucket 56 Reserving size (325) for bucket 57 Sorting block time: 00:00:00 bucket 48: 50% Getting block 59 of 206 bucket 47: 60% bucket 50: 30% Sorting block time: 00:00:00 bucket 45: 80% bucket 51: 20% Reserving size (325) for bucket 58 Entering block accumulator loop for bucket 55: Getting block 60 of 206 bucket 49: 40% bucket 46: 70% Sorting block of length 284 for bucket 40 (Using difference cover) bucket 41: 100% bucket 52: 20% Calculating Z arrays for bucket 57 bucket 53: 10% bucket 44: 90% Returning block of 246 for bucket 38 Entering block accumulator loop for bucket 56: bucket 42: 100% Reserving size (325) for bucket 59 bucket 43: 90% Returning block of 305 for bucket 39 Sorting block time: 00:00:00 Calculating Z arrays for bucket 58 bucket 54: 10% bucket 48: 60% bucket 47: 70% Reserving size (325) for bucket 60 bucket 50: 40% bucket 45: 90% bucket 51: 30% Sorting block of length 44 for bucket 41 (Using difference cover) bucket 49: 50% bucket 46: 80% Entering block accumulator loop for bucket 57: bucket 52: 30% Sorting block of length 355 for bucket 42 (Using difference cover) Calculating Z arrays for bucket 59 bucket 44: 100% Returning block of 285 for bucket 40 bucket 53: 20% Entering block accumulator loop for bucket 58: Calculating Z arrays for bucket 60 bucket 43: 100% bucket 54: 20% bucket 48: 70% bucket 55: 10% bucket 47: 80% Getting block 61 of 206 bucket 50: 50% bucket 45: 100% bucket 51: 40% bucket 49: 60% bucket 46: 90% Getting block 62 of 206 Getting block 63 of 206 Getting block 64 of 206 Sorting block of length 209 for bucket 44 bucket 52: 40% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 59: bucket 56: 10% (Using difference cover) Sorting block of length 53 for bucket 43 (Using difference cover) Entering block accumulator loop for bucket 60: bucket 53: 30% Sorting block time: 00:00:00 Reserving size (325) for bucket 61 bucket 54: 30% bucket 48: 80% Sorting block of length 323 for bucket 45 (Using difference cover) bucket 55: 20% bucket 47: 90% Getting block 65 of 206 Reserving size (325) for bucket 62 bucket 50: 60% Reserving size (325) for bucket 63 bucket 51: 50% bucket 49: 70% Reserving size (325) for bucket 64 bucket 46: 100% bucket 57: 10% Returning block of 45 for bucket 41 bucket 52: 50% Getting block 66 of 206 Returning block of 356 for bucket 42 Calculating Z arrays for bucket 61 bucket 56: 20% bucket 58: 10% bucket 53: 40% bucket 54: 40% Reserving size (325) for bucket 65 Calculating Z arrays for bucket 62 bucket 48: 90% Calculating Z arrays for bucket 63 bucket 55: 30% bucket 47: 100% Calculating Z arrays for bucket 64 Sorting block of length 236 for bucket 46 (Using difference cover) bucket 50: 70% bucket 51: 60% bucket 49: 80% bucket 57: 20% bucket 52: 60% Reserving size (325) for bucket 66 bucket 59: 10% bucket 60: 10% Getting block 67 of 206 Entering block accumulator loop for bucket 61: Calculating Z arrays for bucket 65 Entering block accumulator loop for bucket 62: bucket 56: 30% Sorting block of length 97 for bucket 47 (Using difference cover) Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 58: 20% bucket 53: 50% Entering block accumulator loop for bucket 63: bucket 54: 50% Entering block accumulator loop for bucket 64: bucket 48: 100% bucket 55: 40% bucket 50: 80% bucket 51: 70% bucket 52: 70% bucket 49: 90% bucket 57: 30% Calculating Z arrays for bucket 66 Reserving size (325) for bucket 67 Entering block accumulator loop for bucket 65: bucket 59: 20% bucket 60: 20% Returning block of 210 for bucket 44 Returning block of 54 for bucket 43 bucket 56: 40% Sorting block of length 249 for bucket 48 (Using difference cover) bucket 58: 30% bucket 53: 60% bucket 54: 60% bucket 55: 50% bucket 50: 90% bucket 52: 80% bucket 51: 80% bucket 49: 100% bucket 57: 40% Calculating Z arrays for bucket 67 Getting block 68 of 206 Entering block accumulator loop for bucket 66: bucket 62: 10% bucket 61: 10% bucket 59: 30% Getting block 69 of 206 bucket 60: 30% bucket 56: 50% Sorting block time: 00:00:00 bucket 63: 10% bucket 64: 10% Sorting block of length 318 for bucket 49 (Using difference cover) bucket 58: 40% bucket 53: 70% bucket 54: 70% Reserving size (325) for bucket 68 bucket 52: 90% bucket 55: 60% Entering block accumulator loop for bucket 67: bucket 50: 100% bucket 51: 90% bucket 57: 50% bucket 62: 20% bucket 65: 10% bucket 61: 20% bucket 59: 40% Reserving size (325) for bucket 69 Returning block of 324 for bucket 45 bucket 60: 40% bucket 56: 60% bucket 63: 20% Calculating Z arrays for bucket 68 bucket 64: 20% bucket 58: 50% Sorting block of length 152 for bucket 50 (Using difference cover) bucket 53: 80% bucket 54: 80% bucket 52: 100% bucket 55: 70% bucket 51: 100% bucket 57: 60% Getting block 70 of 206 bucket 62: 30% Calculating Z arrays for bucket 69 Getting block 71 of 206 bucket 66: 10% bucket 65: 20% bucket 61: 30% bucket 59: 50% Entering block accumulator loop for bucket 68: bucket 60: 50% bucket 56: 70% Sorting block of length 308 for bucket 52 (Using difference cover) bucket 64: 30% Sorting block of length 319 for bucket 51 (Using difference cover) bucket 67: 10% bucket 58: 60% Reserving size (325) for bucket 70 bucket 53: 90% bucket 54: 90% Reserving size (325) for bucket 71 bucket 55: 80% Entering block accumulator loop for bucket 69: bucket 62: 40% bucket 63: 30% bucket 57: 70% bucket 66: 20% bucket 65: 30% bucket 61: 40% bucket 59: 60% bucket 60: 60% bucket 56: 80% Calculating Z arrays for bucket 70 bucket 64: 40% Calculating Z arrays for bucket 71 bucket 67: 20% bucket 58: 70% bucket 53: 100% Sorting block time: 00:00:00 Getting block 72 of 206 Sorting block time: 00:00:00 bucket 54: 100% bucket 62: 50% bucket 55: 90% bucket 63: 40% bucket 57: 80% bucket 68: 10% bucket 66: 30% bucket 65: 40% bucket 61: 50% Entering block accumulator loop for bucket 70: bucket 59: 70% Entering block accumulator loop for bucket 71: bucket 60: 70% bucket 56: 90% Sorting block of length 237 for bucket 53 (Using difference cover) Sorting block time: 00:00:00 Returning block of 98 for bucket 47 bucket 64: 50% Reserving size (325) for bucket 72 Returning block of 237 for bucket 46 Sorting block of length 300 for bucket 54 (Using difference cover) bucket 69: 10% bucket 67: 30% bucket 58: 80% bucket 62: 60% bucket 55: 100% bucket 63: 50% bucket 57: 90% bucket 68: 20% bucket 66: 40% bucket 65: 50% bucket 61: 60% bucket 59: 80% Returning block of 250 for bucket 48 bucket 60: 80% bucket 56: 100% Calculating Z arrays for bucket 72 bucket 64: 60% Sorting block of length 239 for bucket 55 (Using difference cover) bucket 62: 70% bucket 69: 20% bucket 67: 40% bucket 58: 90% bucket 70: 10% bucket 63: 60% bucket 57: 100% bucket 71: 10% bucket 68: 30% bucket 66: 50% Sorting block of length 140 for bucket 56 (Using difference cover) bucket 65: 60% bucket 61: 70% Entering block accumulator loop for bucket 72: bucket 59: 90% bucket 60: 90% bucket 62: 80% bucket 64: 70% Sorting block of length 237 for bucket 57 (Using difference cover) bucket 69: 30% Sorting block time: 00:00:00 bucket 67: 50% bucket 58: 100% Sorting block time: 00:00:00 Getting block 73 of 206 bucket 70: 20% bucket 63: 70% Sorting block time: 00:00:00 bucket 71: 20% bucket 68: 40% bucket 66: 60% bucket 65: 70% bucket 61: 80% Returning block of 309 for bucket 52 bucket 62: 90% bucket 59: 100% bucket 60: 100% Sorting block of length 244 for bucket 58 (Using difference cover) Returning block of 319 for bucket 49 bucket 64: 80% Reserving size (325) for bucket 73 Getting block 74 of 206 bucket 69: 40% Returning block of 153 for bucket 50 bucket 67: 60% bucket 70: 30% bucket 63: 80% Sorting block time: 00:00:00 Getting block 75 of 206 bucket 72: 10% bucket 71: 30% bucket 68: 50% Sorting block of length 130 for bucket 59 (Using difference cover) Sorting block of length 295 for bucket 60 (Using difference cover) bucket 66: 70% bucket 65: 80% bucket 61: 90% bucket 62: 100% Calculating Z arrays for bucket 73 Reserving size (325) for bucket 74 bucket 64: 90% Returning block of 320 for bucket 51 bucket 69: 50% Reserving size (325) for bucket 75 bucket 67: 70% bucket 70: 40% bucket 63: 90% bucket 72: 20% bucket 71: 40% bucket 68: 60% Sorting block of length 308 for bucket 62 (Using difference cover) Calculating Z arrays for bucket 74 Entering block accumulator loop for bucket 73: bucket 66: 80% bucket 65: 90% bucket 61: 100% Calculating Z arrays for bucket 75 bucket 64: 100% bucket 69: 60% bucket 67: 80% bucket 70: 50% bucket 63: 100% Entering block accumulator loop for bucket 74: bucket 72: 30% bucket 71: 50% Sorting block of length 273 for bucket 61 (Using difference cover) bucket 68: 70% Sorting block of length 290 for bucket 64 (Using difference cover) Getting block 76 of 206 Entering block accumulator loop for bucket 75: Sorting block of length 222 for bucket 63 (Using difference cover) bucket 66: 90% bucket 65: 100% bucket 69: 70% bucket 67: 90% bucket 73: 10% bucket 70: 60% Reserving size (325) for bucket 76 bucket 72: 40% bucket 71: 60% bucket 68: 80% Sorting block of length 115 for bucket 65 (Using difference cover) Getting block 77 of 206 Calculating Z arrays for bucket 76 bucket 66: 100% bucket 74: 10% bucket 73: 20% bucket 69: 80% bucket 67: 100% Reserving size (325) for bucket 77 bucket 70: 70% Sorting block of length 306 for bucket 66 (Using difference cover) bucket 75: 10% Getting block 78 of 206 bucket 72: 50% Entering block accumulator loop for bucket 76: bucket 71: 70% Sorting block of length 262 for bucket 67 (Using difference cover) bucket 68: 90% Calculating Z arrays for bucket 77 bucket 73: 30% bucket 74: 20% bucket 69: 90% Reserving size (325) for bucket 78 bucket 70: 80% Getting block 79 of 206 bucket 75: 20% Entering block accumulator loop for bucket 77: bucket 72: 60% Calculating Z arrays for bucket 78 bucket 71: 80% bucket 73: 40% Reserving size (325) for bucket 79 bucket 68: 100% bucket 74: 30% bucket 69: 100% bucket 76: 10% bucket 70: 90% Calculating Z arrays for bucket 79 Entering block accumulator loop for bucket 78: bucket 75: 30% Sorting block of length 179 for bucket 68 (Using difference cover) Sorting block of length 248 for bucket 69 (Using difference cover) bucket 72: 70% bucket 73: 50% bucket 71: 90% Entering block accumulator loop for bucket 79: bucket 74: 40% bucket 77: 10% bucket 76: 20% bucket 70: 100% bucket 75: 40% Sorting block time: 00:00:00 Sorting block of length 245 for bucket 70 (Using difference cover) bucket 73: 60% Returning block of 301 for bucket 54 bucket 72: 80% bucket 71: 100% bucket 74: 50% bucket 78: 10% bucket 77: 20% bucket 76: 30% bucket 75: 50% Sorting block of length 304 for bucket 71 (Using difference cover) bucket 79: 10% bucket 73: 70% bucket 72: 90% bucket 74: 60% bucket 77: 30% bucket 78: 20% bucket 76: 40% bucket 75: 60% bucket 79: 20% bucket 73: 80% bucket 72: 100% bucket 74: 70% Sorting block of length 193 for bucket 72 (Using difference cover) bucket 77: 40% bucket 76: 50% bucket 78: 30% bucket 75: 70% bucket 73: 90% bucket 79: 30% Getting block 80 of 206 bucket 74: 80% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Reserving size (325) for bucket 80 Returning block of 240 for bucket 55 Sorting block time: 00:00:00 Returning block of 141 for bucket 56 bucket 77: 50% Calculating Z arrays for bucket 80 bucket 76: 60% bucket 73: 100% bucket 75: 80% bucket 78: 40% Returning block of 238 for bucket 53 bucket 79: 40% bucket 74: 90% Sorting block of length 264 for bucket 73 (Using difference cover) Entering block accumulator loop for bucket 80: bucket 77: 60% bucket 76: 70% bucket 75: 90% bucket 78: 50% bucket 79: 50% bucket 74: 100% Sorting block of length 283 for bucket 74 (Using difference cover) bucket 77: 70% bucket 76: 80% Getting block 81 of 206 bucket 80: 10% bucket 75: 100% Reserving size (325) for bucket 81 bucket 78: 60% bucket 79: 60% Sorting block of length 323 for bucket 75 (Using difference cover) Calculating Z arrays for bucket 81 bucket 77: 80% bucket 76: 90% bucket 80: 20% Entering block accumulator loop for bucket 81: Getting block 82 of 206 bucket 79: 70% Reserving size (325) for bucket 82 bucket 78: 70% Calculating Z arrays for bucket 82 bucket 77: 90% bucket 76: 100% bucket 80: 30% Sorting block of length 167 for bucket 76 (Using difference cover) Entering block accumulator loop for bucket 82: bucket 81: 10% bucket 79: 80% bucket 78: 80% bucket 77: 100% Sorting block of length 316 for bucket 77 (Using difference cover) bucket 80: 40% Getting block 83 of 206 bucket 81: 20% Reserving size (325) for bucket 83 bucket 79: 90% bucket 82: 10% Calculating Z arrays for bucket 83 bucket 78: 90% bucket 80: 50% Entering block accumulator loop for bucket 83: bucket 81: 30% bucket 79: 100% Sorting block of length 246 for bucket 79 (Using difference cover) bucket 82: 20% bucket 78: 100% bucket 80: 60% Sorting block of length 181 for bucket 78 (Using difference cover) bucket 81: 40% bucket 83: 10% bucket 82: 30% bucket 80: 70% bucket 81: 50% bucket 83: 20% bucket 82: 40% bucket 80: 80% bucket 81: 60% bucket 83: 30% bucket 82: 50% Sorting block time: 00:00:00 Returning block of 245 for bucket 58 bucket 80: 90% bucket 81: 70% bucket 83: 40% bucket 82: 60% bucket 80: 100% Sorting block of length 170 for bucket 80 (Using difference cover) bucket 81: 80% bucket 83: 50% bucket 82: 70% bucket 81: 90% bucket 82: 80% bucket 83: 60% Getting block 84 of 206 Reserving size (325) for bucket 84 Calculating Z arrays for bucket 84 bucket 81: 100% Sorting block of length 255 for bucket 81 (Using difference cover) Entering block accumulator loop for bucket 84: bucket 82: 90% bucket 83: 70% bucket 84: 10% bucket 82: 100% Sorting block of length 174 for bucket 82 (Using difference cover) bucket 84: 20% bucket 83: 80% bucket 84: 30% bucket 83: 90% bucket 84: 40% bucket 84: 50% bucket 83: 100% Sorting block of length 271 for bucket 83 (Using difference cover) bucket 84: 60% bucket 84: 70% bucket 84: 80% bucket 84: 90% bucket 84: 100% Sorting block of length 125 for bucket 84 (Using difference cover) Sorting block time: 00:00:00 Returning block of 238 for bucket 57 Getting block 85 of 206 Reserving size (325) for bucket 85 Calculating Z arrays for bucket 85 Entering block accumulator loop for bucket 85: bucket 85: 10% bucket 85: 20% bucket 85: 30% bucket 85: 40% bucket 85: 50% bucket 85: 60% bucket 85: 70% Sorting block time: 00:00:00 Returning block of 131 for bucket 59 bucket 85: 80% Sorting block time: 00:00:00 Returning block of 223 for bucket 63 Sorting block time: 00:00:00 Returning block of 296 for bucket 60 bucket 85: 90% bucket 85: 100% Sorting block of length 271 for bucket 85 (Using difference cover) Getting block 86 of 206 Reserving size (325) for bucket 86 Calculating Z arrays for bucket 86 Entering block accumulator loop for bucket 86: bucket 86: 10% Getting block 87 of 206 bucket 86: 20% Reserving size (325) for bucket 87 Calculating Z arrays for bucket 87 Entering block accumulator loop for bucket 87: Getting block 88 of 206 bucket 86: 30% Reserving size (325) for bucket 88 Calculating Z arrays for bucket 88 Entering block accumulator loop for bucket 88: bucket 86: 40% bucket 87: 10% Sorting block time: 00:00:00 bucket 86: 50% Returning block of 307 for bucket 66 bucket 88: 10% bucket 87: 20% bucket 86: 60% bucket 88: 20% bucket 87: 30% bucket 86: 70% bucket 88: 30% bucket 86: 80% bucket 87: 40% bucket 86: 90% bucket 88: 40% Getting block 89 of 206 bucket 87: 50% Reserving size (325) for bucket 89 Calculating Z arrays for bucket 89 bucket 86: 100% Sorting block of length 255 for bucket 86 (Using difference cover) Entering block accumulator loop for bucket 89: bucket 88: 50% bucket 87: 60% bucket 88: 60% bucket 89: 10% bucket 87: 70% bucket 88: 70% bucket 89: 20% bucket 87: 80% Sorting block time: 00:00:00 Returning block of 263 for bucket 67 bucket 88: 80% bucket 89: 30% bucket 87: 90% bucket 88: 90% Sorting block time: 00:00:00 Returning block of 291 for bucket 64 bucket 89: 40% bucket 87: 100% Sorting block of length 245 for bucket 87 (Using difference cover) bucket 88: 100% Sorting block of length 235 for bucket 88 (Using difference cover) bucket 89: 50% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Getting block 90 of 206 Returning block of 249 for bucket 69 Returning block of 274 for bucket 61 Reserving size (325) for bucket 90 Calculating Z arrays for bucket 90 bucket 89: 60% Entering block accumulator loop for bucket 90: Sorting block time: 00:00:00 Returning block of 309 for bucket 62 Sorting block time: 00:00:00 Returning block of 116 for bucket 65 bucket 89: 70% Getting block 91 of 206 bucket 90: 10% Reserving size (325) for bucket 91 Calculating Z arrays for bucket 91 Sorting block time: 00:00:00 Returning block of 180 for bucket 68 Entering block accumulator loop for bucket 91: Sorting block time: 00:00:00 bucket 89: 80% Returning block of 324 for bucket 75 bucket 90: 20% Getting block 92 of 206 Reserving size (325) for bucket 92 Calculating Z arrays for bucket 92 bucket 89: 90% bucket 91: 10% Entering block accumulator loop for bucket 92: bucket 90: 30% Getting block 93 of 206 Reserving size (325) for bucket 93 bucket 89: 100% Calculating Z arrays for bucket 93 bucket 91: 20% Sorting block of length 247 for bucket 89 (Using difference cover) bucket 92: 10% bucket 90: 40% Entering block accumulator loop for bucket 93: Getting block 94 of 206 Reserving size (325) for bucket 94 Calculating Z arrays for bucket 94 bucket 91: 30% Entering block accumulator loop for bucket 94: bucket 92: 20% bucket 90: 50% bucket 93: 10% bucket 91: 40% Sorting block time: 00:00:00 Getting block 95 of 206 Returning block of 168 for bucket 76 bucket 94: 10% Reserving size (325) for bucket 95 bucket 92: 30% bucket 90: 60% Calculating Z arrays for bucket 95 bucket 93: 20% bucket 91: 50% Entering block accumulator loop for bucket 95: bucket 94: 20% bucket 92: 40% Getting block 96 of 206 bucket 90: 70% Reserving size (325) for bucket 96 bucket 93: 30% bucket 91: 60% Calculating Z arrays for bucket 96 bucket 94: 30% bucket 95: 10% bucket 92: 50% Entering block accumulator loop for bucket 96: bucket 90: 80% Sorting block time: 00:00:00 Getting block 97 of 206 bucket 93: 40% Returning block of 182 for bucket 78 bucket 91: 70% Reserving size (325) for bucket 97 bucket 94: 40% bucket 95: 20% bucket 92: 60% Calculating Z arrays for bucket 97 Sorting block time: 00:00:00 bucket 90: 90% Sorting block time: 00:00:00 bucket 96: 10% bucket 93: 50% Sorting block time: 00:00:00 Returning block of 194 for bucket 72 bucket 91: 80% Returning block of 246 for bucket 70 Entering block accumulator loop for bucket 97: bucket 94: 50% bucket 95: 30% Getting block 98 of 206 Returning block of 305 for bucket 71 bucket 92: 70% bucket 90: 100% bucket 96: 20% bucket 93: 60% Reserving size (325) for bucket 98 bucket 91: 90% Sorting block of length 286 for bucket 90 (Using difference cover) Sorting block time: 00:00:00 bucket 94: 60% bucket 95: 40% Calculating Z arrays for bucket 98 Returning block of 317 for bucket 77 bucket 92: 80% bucket 97: 10% Sorting block time: 00:00:00 Getting block 99 of 206 Sorting block time: 00:00:00 bucket 96: 30% bucket 93: 70% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 98: bucket 91: 100% bucket 94: 70% Returning block of 284 for bucket 74 bucket 95: 50% Reserving size (325) for bucket 99 Returning block of 247 for bucket 79 Returning block of 265 for bucket 73 Returning block of 256 for bucket 81 bucket 92: 90% Sorting block of length 214 for bucket 91 (Using difference cover) Getting block 100 of 206 bucket 97: 20% bucket 96: 40% Calculating Z arrays for bucket 99 bucket 93: 80% bucket 94: 80% bucket 95: 60% Reserving size (325) for bucket 100 Getting block 101 of 206 bucket 98: 10% bucket 92: 100% Entering block accumulator loop for bucket 99: Calculating Z arrays for bucket 100 Reserving size (325) for bucket 101 bucket 97: 30% bucket 96: 50% Sorting block of length 290 for bucket 92 (Using difference cover) bucket 94: 90% bucket 93: 90% Calculating Z arrays for bucket 101 bucket 95: 70% Getting block 102 of 206 Entering block accumulator loop for bucket 100: Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 98: 20% bucket 97: 40% Entering block accumulator loop for bucket 101: Sorting block time: 00:00:00 Reserving size (325) for bucket 102 bucket 96: 60% Returning block of 175 for bucket 82 Returning block of 236 for bucket 88 Returning block of 126 for bucket 84 Returning block of 272 for bucket 83 bucket 99: 10% bucket 94: 100% Getting block 103 of 206 Returning block of 171 for bucket 80 bucket 93: 100% bucket 95: 80% Calculating Z arrays for bucket 102 bucket 98: 30% Sorting block time: 00:00:00 bucket 97: 50% bucket 96: 70% bucket 100: 10% Sorting block of length 271 for bucket 94 (Using difference cover) Reserving size (325) for bucket 103 Sorting block of length 159 for bucket 93 (Using difference cover) bucket 99: 20% Returning block of 256 for bucket 86 Getting block 104 of 206 Entering block accumulator loop for bucket 102: bucket 101: 10% bucket 95: 90% Calculating Z arrays for bucket 103 Getting block 105 of 206 bucket 98: 40% bucket 97: 60% bucket 96: 80% bucket 100: 20% Reserving size (325) for bucket 104 bucket 99: 30% Getting block 106 of 206 Reserving size (325) for bucket 105 Entering block accumulator loop for bucket 103: bucket 101: 20% Calculating Z arrays for bucket 104 bucket 95: 100% Reserving size (325) for bucket 106 Getting block 107 of 206 Calculating Z arrays for bucket 105 bucket 98: 50% bucket 97: 70% bucket 96: 90% bucket 100: 30% Sorting block of length 225 for bucket 95 (Using difference cover) bucket 99: 40% bucket 102: 10% Entering block accumulator loop for bucket 104: Calculating Z arrays for bucket 106 Reserving size (325) for bucket 107 Entering block accumulator loop for bucket 105: bucket 101: 30% bucket 98: 60% Getting block 108 of 206 bucket 103: 10% bucket 97: 80% Calculating Z arrays for bucket 107 bucket 96: 100% bucket 100: 40% Getting block 109 of 206 Entering block accumulator loop for bucket 106: bucket 99: 50% Reserving size (325) for bucket 108 bucket 102: 20% Sorting block of length 291 for bucket 96 (Using difference cover) Entering block accumulator loop for bucket 107: bucket 101: 40% bucket 104: 10% bucket 98: 70% Reserving size (325) for bucket 109 bucket 103: 20% Calculating Z arrays for bucket 108 bucket 97: 90% Getting block 110 of 206 bucket 105: 10% bucket 100: 50% bucket 99: 60% Calculating Z arrays for bucket 109 bucket 102: 30% bucket 101: 50% Reserving size (325) for bucket 110 Entering block accumulator loop for bucket 108: bucket 104: 20% bucket 98: 80% Getting block 111 of 206 bucket 106: 10% bucket 103: 30% bucket 97: 100% Entering block accumulator loop for bucket 109: Calculating Z arrays for bucket 110 bucket 107: 10% Sorting block time: 00:00:00 Getting block 112 of 206 bucket 105: 20% bucket 100: 60% Reserving size (325) for bucket 111 bucket 99: 70% bucket 102: 40% bucket 101: 60% Sorting block of length 311 for bucket 97 (Using difference cover) bucket 104: 30% bucket 98: 90% Returning block of 272 for bucket 85 Entering block accumulator loop for bucket 110: Reserving size (325) for bucket 112 bucket 106: 20% bucket 103: 40% Calculating Z arrays for bucket 111 bucket 107: 20% Getting block 113 of 206 bucket 108: 10% bucket 105: 30% bucket 100: 70% bucket 99: 80% Calculating Z arrays for bucket 112 bucket 102: 50% bucket 101: 70% bucket 109: 10% bucket 104: 40% bucket 98: 100% Entering block accumulator loop for bucket 111: Reserving size (325) for bucket 113 bucket 106: 30% bucket 103: 50% bucket 107: 30% Entering block accumulator loop for bucket 112: bucket 108: 20% bucket 105: 40% Sorting block of length 285 for bucket 98 (Using difference cover) bucket 100: 80% bucket 110: 10% bucket 99: 90% Calculating Z arrays for bucket 113 bucket 102: 60% bucket 101: 80% bucket 109: 20% Sorting block time: 00:00:00 bucket 104: 50% Getting block 114 of 206 bucket 107: 40% bucket 106: 40% bucket 103: 60% bucket 108: 30% Entering block accumulator loop for bucket 113: bucket 105: 50% Returning block of 246 for bucket 87 bucket 100: 90% Sorting block time: 00:00:00 Reserving size (325) for bucket 114 bucket 111: 10% bucket 110: 20% bucket 99: 100% bucket 102: 70% bucket 112: 10% bucket 101: 90% bucket 109: 30% bucket 104: 60% bucket 107: 50% bucket 106: 50% bucket 103: 70% bucket 108: 40% bucket 105: 60% Returning block of 248 for bucket 89 Calculating Z arrays for bucket 114 Sorting block of length 158 for bucket 99 (Using difference cover) bucket 100: 100% bucket 111: 20% bucket 110: 30% bucket 112: 20% bucket 102: 80% bucket 101: 100% bucket 109: 40% bucket 113: 10% bucket 107: 60% bucket 104: 70% Entering block accumulator loop for bucket 114: bucket 106: 60% bucket 103: 80% Sorting block of length 213 for bucket 100 (Using difference cover) bucket 108: 50% bucket 105: 70% Sorting block of length 138 for bucket 101 (Using difference cover) bucket 112: 30% bucket 111: 30% bucket 110: 40% bucket 102: 90% bucket 109: 50% bucket 107: 70% bucket 113: 20% Getting block 115 of 206 bucket 104: 80% bucket 106: 70% bucket 103: 90% bucket 112: 40% bucket 108: 60% bucket 105: 80% Reserving size (325) for bucket 115 bucket 111: 40% bucket 110: 50% bucket 114: 10% bucket 107: 80% Getting block 116 of 206 bucket 109: 60% bucket 102: 100% bucket 113: 30% Calculating Z arrays for bucket 115 bucket 112: 50% bucket 104: 90% bucket 106: 80% bucket 103: 100% Reserving size (325) for bucket 116 Sorting block of length 306 for bucket 102 (Using difference cover) bucket 108: 70% bucket 105: 90% bucket 111: 50% bucket 110: 60% bucket 107: 90% bucket 114: 20% Entering block accumulator loop for bucket 115: Sorting block of length 317 for bucket 103 (Using difference cover) Calculating Z arrays for bucket 116 bucket 109: 70% bucket 112: 60% bucket 113: 40% bucket 104: 100% bucket 106: 90% bucket 111: 60% bucket 108: 80% bucket 105: 100% bucket 107: 100% Entering block accumulator loop for bucket 116: bucket 110: 70% Sorting block of length 119 for bucket 104 (Using difference cover) bucket 114: 30% bucket 112: 70% Sorting block of length 278 for bucket 105 (Using difference cover) Sorting block of length 88 for bucket 107 (Using difference cover) bucket 109: 80% bucket 113: 50% bucket 115: 10% bucket 111: 70% bucket 106: 100% bucket 108: 90% bucket 110: 80% bucket 112: 80% bucket 114: 40% Sorting block of length 280 for bucket 106 (Using difference cover) bucket 116: 10% Sorting block time: 00:00:00 bucket 113: 60% bucket 109: 90% bucket 115: 20% bucket 111: 80% bucket 112: 90% Returning block of 215 for bucket 91 bucket 110: 90% bucket 108: 100% bucket 114: 50% bucket 116: 20% bucket 113: 70% Sorting block time: 00:00:00 Sorting block of length 285 for bucket 108 Sorting block time: 00:00:00 Sorting block time: 00:00:00 (Using difference cover) bucket 109: 100% bucket 112: 100% bucket 115: 30% bucket 111: 90% Returning block of 287 for bucket 90 Returning block of 291 for bucket 92 Returning block of 272 for bucket 94 bucket 110: 100% Sorting block of length 101 for bucket 109 (Using difference cover) Sorting block of length 279 for bucket 112 (Using difference cover) bucket 114: 60% bucket 116: 30% bucket 113: 80% Sorting block of length 307 for bucket 110 (Using difference cover) bucket 115: 40% bucket 111: 100% Sorting block of length 272 for bucket 111 (Using difference cover) Getting block 117 of 206 bucket 114: 70% bucket 116: 40% Reserving size (325) for bucket 117 bucket 113: 90% Calculating Z arrays for bucket 117 Getting block 118 of 206 bucket 115: 50% Reserving size (325) for bucket 118 Entering block accumulator loop for bucket 117: Calculating Z arrays for bucket 118 bucket 114: 80% bucket 116: 50% bucket 113: 100% Entering block accumulator loop for bucket 118: Sorting block of length 74 for bucket 113 (Using difference cover) bucket 115: 60% bucket 117: 10% bucket 114: 90% bucket 116: 60% Getting block 119 of 206 bucket 118: 10% bucket 115: 70% Reserving size (325) for bucket 119 bucket 117: 20% Calculating Z arrays for bucket 119 bucket 114: 100% bucket 116: 70% Sorting block of length 253 for bucket 114 (Using difference cover) Entering block accumulator loop for bucket 119: bucket 118: 20% Getting block 120 of 206 bucket 115: 80% bucket 117: 30% Reserving size (325) for bucket 120 bucket 116: 80% Calculating Z arrays for bucket 120 Entering block accumulator loop for bucket 120: bucket 119: 10% bucket 118: 30% bucket 115: 90% bucket 117: 40% bucket 116: 90% bucket 119: 20% Sorting block time: 00:00:00 bucket 120: 10% bucket 118: 40% Returning block of 226 for bucket 95 bucket 115: 100% bucket 117: 50% bucket 116: 100% Sorting block of length 220 for bucket 115 (Using difference cover) bucket 120: 20% bucket 119: 30% Sorting block of length 197 for bucket 116 (Using difference cover) bucket 118: 50% bucket 117: 60% bucket 120: 30% bucket 119: 40% Sorting block time: 00:00:00 Returning block of 160 for bucket 93 bucket 118: 60% bucket 117: 70% bucket 120: 40% bucket 119: 50% Getting block 121 of 206 Reserving size (325) for bucket 121 Calculating Z arrays for bucket 121 bucket 120: 50% bucket 118: 70% Entering block accumulator loop for bucket 121: bucket 117: 80% bucket 119: 60% bucket 120: 60% bucket 118: 80% bucket 117: 90% bucket 121: 10% bucket 119: 70% bucket 120: 70% Getting block 122 of 206 Reserving size (325) for bucket 122 Calculating Z arrays for bucket 122 bucket 118: 90% Entering block accumulator loop for bucket 122: bucket 117: 100% bucket 121: 20% bucket 120: 80% bucket 119: 80% Sorting block of length 267 for bucket 117 (Using difference cover) bucket 118: 100% Sorting block time: 00:00:00 Sorting block of length 150 for bucket 118 (Using difference cover) Returning block of 286 for bucket 98 bucket 120: 90% bucket 121: 30% bucket 122: 10% bucket 119: 90% bucket 120: 100% Sorting block of length 276 for bucket 120 (Using difference cover) bucket 121: 40% bucket 122: 20% bucket 119: 100% Sorting block of length 243 for bucket 119 (Using difference cover) bucket 121: 50% bucket 122: 30% bucket 121: 60% bucket 122: 40% bucket 121: 70% Getting block 123 of 206 bucket 122: 50% Reserving size (325) for bucket 123 Calculating Z arrays for bucket 123 Entering block accumulator loop for bucket 123: bucket 121: 80% bucket 122: 60% bucket 121: 90% bucket 123: 10% bucket 122: 70% bucket 121: 100% Sorting block of length 101 for bucket 121 (Using difference cover) bucket 123: 20% bucket 122: 80% bucket 123: 30% bucket 122: 90% bucket 123: 40% Sorting block time: 00:00:00 Returning block of 292 for bucket 96 bucket 122: 100% Sorting block of length 308 for bucket 122 (Using difference cover) bucket 123: 50% bucket 123: 60% bucket 123: 70% Getting block 124 of 206 Reserving size (325) for bucket 124 Calculating Z arrays for bucket 124 Sorting block time: 00:00:00 Returning block of 312 for bucket 97 Entering block accumulator loop for bucket 124: bucket 123: 80% bucket 124: 10% bucket 123: 90% bucket 124: 20% bucket 123: 100% Sorting block of length 303 for bucket 123 (Using difference cover) Getting block 125 of 206 Reserving size (325) for bucket 125 bucket 124: 30% Calculating Z arrays for bucket 125 Entering block accumulator loop for bucket 125: bucket 124: 40% bucket 125: 10% bucket 124: 50% bucket 125: 20% bucket 124: 60% bucket 125: 30% bucket 124: 70% bucket 125: 40% bucket 124: 80% bucket 125: 50% bucket 124: 90% bucket 125: 60% Sorting block time: 00:00:00 Returning block of 159 for bucket 99 bucket 124: 100% Sorting block of length 275 for bucket 124 (Using difference cover) bucket 125: 70% Sorting block time: 00:00:00 Returning block of 307 for bucket 102 bucket 125: 80% bucket 125: 90% Getting block 126 of 206 Reserving size (325) for bucket 126 Calculating Z arrays for bucket 126 bucket 125: 100% Sorting block of length 246 for bucket 125 (Using difference cover) Entering block accumulator loop for bucket 126: Getting block 127 of 206 Reserving size (325) for bucket 127 bucket 126: 10% Calculating Z arrays for bucket 127 Entering block accumulator loop for bucket 127: bucket 126: 20% bucket 127: 10% bucket 126: 30% bucket 127: 20% Sorting block time: 00:00:00 Returning block of 120 for bucket 104 Sorting block time: 00:00:00 Returning block of 89 for bucket 107 bucket 126: 40% bucket 127: 30% bucket 126: 50% bucket 127: 40% bucket 127: 50% bucket 126: 60% Getting block 128 of 206 Reserving size (325) for bucket 128 Calculating Z arrays for bucket 128 bucket 127: 60% Sorting block time: 00:00:00 Returning block of 214 for bucket 100 Entering block accumulator loop for bucket 128: bucket 126: 70% bucket 127: 70% Getting block 129 of 206 Reserving size (325) for bucket 129 Calculating Z arrays for bucket 129 bucket 126: 80% bucket 128: 10% Entering block accumulator loop for bucket 129: bucket 127: 80% Sorting block time: 00:00:00 Returning block of 318 for bucket 103 Sorting block time: 00:00:00 Returning block of 139 for bucket 101 Sorting block time: 00:00:00 bucket 126: 90% bucket 128: 20% bucket 129: 10% Returning block of 279 for bucket 105 bucket 127: 90% bucket 129: 20% Getting block 130 of 206 bucket 126: 100% bucket 128: 30% Reserving size (325) for bucket 130 Sorting block of length 288 for bucket 126 (Using difference cover) bucket 127: 100% Calculating Z arrays for bucket 130 bucket 129: 30% Sorting block of length 281 for bucket 127 (Using difference cover) Entering block accumulator loop for bucket 130: bucket 128: 40% Getting block 131 of 206 Reserving size (325) for bucket 131 bucket 129: 40% Calculating Z arrays for bucket 131 Entering block accumulator loop for bucket 131: bucket 130: 10% bucket 128: 50% bucket 129: 50% Getting block 132 of 206 Reserving size (325) for bucket 132 Calculating Z arrays for bucket 132 bucket 131: 10% bucket 130: 20% Entering block accumulator loop for bucket 132: bucket 129: 60% bucket 128: 60% Getting block 133 of 206 bucket 131: 20% Reserving size (325) for bucket 133 bucket 130: 30% bucket 129: 70% Calculating Z arrays for bucket 133 bucket 132: 10% bucket 128: 70% Entering block accumulator loop for bucket 133: bucket 131: 30% bucket 129: 80% bucket 130: 40% bucket 132: 20% bucket 128: 80% bucket 133: 10% bucket 129: 90% bucket 131: 40% bucket 130: 50% bucket 132: 30% Sorting block time: 00:00:00 bucket 128: 90% Returning block of 102 for bucket 109 bucket 129: 100% bucket 133: 20% bucket 131: 50% bucket 130: 60% Sorting block of length 203 for bucket 129 (Using difference cover) bucket 132: 40% bucket 128: 100% Sorting block of length 312 for bucket 128 (Using difference cover) Sorting block time: 00:00:00 Returning block of 198 for bucket 116 bucket 133: 30% Sorting block time: 00:00:00 bucket 131: 60% Sorting block time: 00:00:00 bucket 130: 70% Returning block of 281 for bucket 106 bucket 132: 50% Returning block of 280 for bucket 112 Sorting block time: 00:00:00 bucket 133: 40% Sorting block time: 00:00:00 Returning block of 286 for bucket 108 Sorting block time: 00:00:00 bucket 131: 70% bucket 130: 80% Returning block of 308 for bucket 110 bucket 132: 60% Returning block of 254 for bucket 114 Getting block 134 of 206 bucket 133: 50% Reserving size (325) for bucket 134 bucket 131: 80% Calculating Z arrays for bucket 134 bucket 130: 90% Getting block 135 of 206 Entering block accumulator loop for bucket 134: bucket 132: 70% Reserving size (325) for bucket 135 Calculating Z arrays for bucket 135 bucket 133: 60% bucket 131: 90% Entering block accumulator loop for bucket 135: bucket 130: 100% Sorting block of length 231 for bucket 130 (Using difference cover) bucket 134: 10% bucket 132: 80% bucket 133: 70% bucket 131: 100% Sorting block of length 103 for bucket 131 (Using difference cover) bucket 135: 10% bucket 134: 20% Getting block 136 of 206 bucket 132: 90% Reserving size (325) for bucket 136 bucket 133: 80% Calculating Z arrays for bucket 136 bucket 134: 30% bucket 135: 20% Entering block accumulator loop for bucket 136: bucket 132: 100% Sorting block of length 293 for bucket 132 (Using difference cover) bucket 133: 90% bucket 134: 40% Getting block 137 of 206 bucket 135: 30% bucket 136: 10% Reserving size (325) for bucket 137 Calculating Z arrays for bucket 137 bucket 134: 50% Entering block accumulator loop for bucket 137: bucket 133: 100% Sorting block of length 290 for bucket 133 (Using difference cover) bucket 135: 40% bucket 136: 20% bucket 134: 60% Getting block 138 of 206 bucket 137: 10% Reserving size (325) for bucket 138 Calculating Z arrays for bucket 138 Getting block 139 of 206 bucket 135: 50% bucket 136: 30% bucket 134: 70% Reserving size (325) for bucket 139 Entering block accumulator loop for bucket 138: bucket 137: 20% Calculating Z arrays for bucket 139 Sorting block time: 00:00:00 Returning block of 75 for bucket 113 Sorting block time: 00:00:00 bucket 135: 60% Sorting block time: 00:00:00 bucket 134: 80% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 139: bucket 136: 40% Returning block of 244 for bucket 119 Returning block of 151 for bucket 118 Returning block of 273 for bucket 111 bucket 137: 30% bucket 138: 10% Getting block 140 of 206 bucket 135: 70% bucket 134: 90% bucket 136: 50% Reserving size (325) for bucket 140 Calculating Z arrays for bucket 140 Getting block 141 of 206 bucket 137: 40% bucket 139: 10% bucket 138: 20% Reserving size (325) for bucket 141 Entering block accumulator loop for bucket 140: bucket 134: 100% Sorting block time: 00:00:00 bucket 135: 80% bucket 136: 60% Calculating Z arrays for bucket 141 Sorting block of length 262 for bucket 134 (Using difference cover) Returning block of 102 for bucket 121 bucket 137: 50% bucket 139: 20% bucket 138: 30% Entering block accumulator loop for bucket 141: bucket 135: 90% bucket 136: 70% bucket 140: 10% Getting block 142 of 206 Reserving size (325) for bucket 142 bucket 137: 60% Calculating Z arrays for bucket 142 bucket 139: 30% bucket 138: 40% bucket 135: 100% Entering block accumulator loop for bucket 142: bucket 136: 80% Sorting block of length 304 for bucket 135 (Using difference cover) bucket 141: 10% bucket 140: 20% bucket 137: 70% bucket 139: 40% bucket 138: 50% Getting block 143 of 206 bucket 136: 90% Reserving size (325) for bucket 143 bucket 142: 10% bucket 141: 20% Sorting block time: 00:00:00 Calculating Z arrays for bucket 143 Sorting block time: 00:00:00 bucket 140: 30% bucket 137: 80% bucket 139: 50% bucket 138: 60% Sorting block time: 00:00:00 Getting block 144 of 206 Returning block of 268 for bucket 117 Returning block of 221 for bucket 115 bucket 136: 100% Entering block accumulator loop for bucket 143: bucket 142: 20% Returning block of 277 for bucket 120 Reserving size (325) for bucket 144 bucket 141: 30% bucket 140: 40% bucket 137: 90% bucket 139: 60% bucket 138: 70% Sorting block of length 158 for bucket 136 (Using difference cover) Calculating Z arrays for bucket 144 bucket 142: 30% Getting block 145 of 206 bucket 141: 40% Entering block accumulator loop for bucket 144: bucket 140: 50% Reserving size (325) for bucket 145 bucket 139: 70% bucket 138: 80% bucket 137: 100% bucket 143: 10% Calculating Z arrays for bucket 145 bucket 142: 40% Sorting block of length 222 for bucket 137 (Using difference cover) bucket 141: 50% Entering block accumulator loop for bucket 145: Getting block 146 of 206 bucket 140: 60% bucket 139: 80% bucket 138: 90% bucket 143: 20% bucket 144: 10% Reserving size (325) for bucket 146 bucket 142: 50% bucket 141: 60% Calculating Z arrays for bucket 146 Getting block 147 of 206 bucket 140: 70% bucket 139: 90% bucket 138: 100% bucket 143: 30% bucket 145: 10% Reserving size (325) for bucket 147 Entering block accumulator loop for bucket 146: bucket 144: 20% bucket 142: 60% Sorting block of length 161 for bucket 138 (Using difference cover) bucket 141: 70% Calculating Z arrays for bucket 147 Getting block 148 of 206 bucket 140: 80% bucket 139: 100% bucket 143: 40% bucket 145: 20% Reserving size (325) for bucket 148 Entering block accumulator loop for bucket 147: bucket 144: 30% bucket 142: 70% Sorting block of length 294 for bucket 139 (Using difference cover) Calculating Z arrays for bucket 148 bucket 141: 80% bucket 146: 10% bucket 140: 90% bucket 143: 50% bucket 145: 30% Entering block accumulator loop for bucket 148: bucket 142: 80% bucket 144: 40% bucket 141: 90% bucket 146: 20% bucket 147: 10% bucket 143: 60% bucket 140: 100% bucket 145: 40% Sorting block of length 257 for bucket 140 (Using difference cover) bucket 142: 90% bucket 148: 10% bucket 144: 50% bucket 141: 100% bucket 146: 30% bucket 147: 20% bucket 143: 70% Sorting block of length 197 for bucket 141 (Using difference cover) bucket 145: 50% bucket 148: 20% bucket 142: 100% Sorting block time: 00:00:00 bucket 144: 60% bucket 146: 40% Sorting block of length 170 for bucket 142 (Using difference cover) Returning block of 309 for bucket 122 bucket 143: 80% bucket 147: 30% bucket 148: 30% bucket 145: 60% bucket 144: 70% bucket 146: 50% bucket 143: 90% bucket 148: 40% bucket 147: 40% bucket 145: 70% bucket 144: 80% bucket 146: 60% bucket 143: 100% Sorting block of length 317 for bucket 143 (Using difference cover) bucket 148: 50% Sorting block time: 00:00:00 Returning block of 304 for bucket 123 bucket 147: 50% bucket 145: 80% bucket 144: 90% bucket 146: 70% bucket 148: 60% Getting block 149 of 206 bucket 147: 60% Reserving size (325) for bucket 149 bucket 145: 90% bucket 144: 100% Calculating Z arrays for bucket 149 bucket 148: 70% bucket 146: 80% Sorting block of length 244 for bucket 144 (Using difference cover) Entering block accumulator loop for bucket 149: bucket 147: 70% bucket 145: 100% bucket 148: 80% Sorting block of length 269 for bucket 145 (Using difference cover) bucket 146: 90% Getting block 150 of 206 Reserving size (325) for bucket 150 Calculating Z arrays for bucket 150 bucket 147: 80% bucket 148: 90% bucket 149: 10% Entering block accumulator loop for bucket 150: bucket 146: 100% Sorting block of length 219 for bucket 146 (Using difference cover) bucket 148: 100% Sorting block of length 184 for bucket 148 (Using difference cover) bucket 147: 90% Sorting block time: 00:00:00 bucket 149: 20% bucket 150: 10% Returning block of 276 for bucket 124 Sorting block time: 00:00:00 Returning block of 247 for bucket 125 bucket 147: 100% bucket 149: 30% Sorting block of length 168 for bucket 147 (Using difference cover) bucket 150: 20% bucket 149: 40% bucket 150: 30% bucket 149: 50% Getting block 151 of 206 bucket 150: 40% Reserving size (325) for bucket 151 Calculating Z arrays for bucket 151 bucket 149: 60% Entering block accumulator loop for bucket 151: bucket 150: 50% bucket 149: 70% bucket 151: 10% Getting block 152 of 206 bucket 150: 60% Reserving size (325) for bucket 152 Calculating Z arrays for bucket 152 bucket 149: 80% bucket 151: 20% Entering block accumulator loop for bucket 152: bucket 150: 70% bucket 149: 90% bucket 151: 30% bucket 152: 10% bucket 150: 80% bucket 149: 100% bucket 151: 40% Sorting block of length 213 for bucket 149 (Using difference cover) bucket 152: 20% bucket 150: 90% Sorting block time: 00:00:00 Returning block of 313 for bucket 128 bucket 151: 50% bucket 152: 30% Sorting block time: 00:00:00 Returning block of 289 for bucket 126 Sorting block time: 00:00:00 bucket 150: 100% Returning block of 282 for bucket 127 Sorting block of length 269 for bucket 150 (Using difference cover) bucket 151: 60% bucket 152: 40% bucket 151: 70% bucket 152: 50% bucket 151: 80% bucket 152: 60% Getting block 153 of 206 Reserving size (325) for bucket 153 Calculating Z arrays for bucket 153 Entering block accumulator loop for bucket 153: bucket 151: 90% bucket 152: 70% bucket 153: 10% bucket 151: 100% Getting block 154 of 206 bucket 152: 80% Sorting block of length 296 for bucket 151 (Using difference cover) Reserving size (325) for bucket 154 Calculating Z arrays for bucket 154 bucket 153: 20% Entering block accumulator loop for bucket 154: bucket 152: 90% bucket 153: 30% bucket 154: 10% bucket 152: 100% Getting block 155 of 206 Sorting block of length 252 for bucket 152 (Using difference cover) Reserving size (325) for bucket 155 Calculating Z arrays for bucket 155 bucket 153: 40% bucket 154: 20% Entering block accumulator loop for bucket 155: bucket 153: 50% bucket 154: 30% bucket 155: 10% Sorting block time: 00:00:00 Returning block of 204 for bucket 129 bucket 153: 60% bucket 155: 20% bucket 154: 40% bucket 153: 70% bucket 155: 30% bucket 154: 50% bucket 153: 80% bucket 155: 40% bucket 154: 60% bucket 153: 90% Getting block 156 of 206 Reserving size (325) for bucket 156 Calculating Z arrays for bucket 156 bucket 155: 50% bucket 154: 70% Entering block accumulator loop for bucket 156: bucket 153: 100% Sorting block of length 203 for bucket 153 (Using difference cover) bucket 155: 60% bucket 154: 80% bucket 156: 10% bucket 155: 70% bucket 156: 20% bucket 154: 90% bucket 155: 80% bucket 156: 30% bucket 154: 100% Sorting block of length 125 for bucket 154 (Using difference cover) bucket 155: 90% bucket 156: 40% Sorting block time: 00:00:00 Returning block of 232 for bucket 130 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 294 for bucket 132 Returning block of 305 for bucket 135 bucket 155: 100% bucket 156: 50% Sorting block of length 253 for bucket 155 (Using difference cover) bucket 156: 60% Sorting block time: 00:00:00 Returning block of 104 for bucket 131 Sorting block time: 00:00:00 Returning block of 291 for bucket 133 bucket 156: 70% Getting block 157 of 206 Reserving size (325) for bucket 157 Calculating Z arrays for bucket 157 Entering block accumulator loop for bucket 157: bucket 156: 80% Getting block 158 of 206 Reserving size (325) for bucket 158 Calculating Z arrays for bucket 158 bucket 156: 90% bucket 157: 10% Entering block accumulator loop for bucket 158: bucket 156: 100% Sorting block of length 269 for bucket 156 (Using difference cover) Getting block 159 of 206 bucket 157: 20% bucket 158: 10% Reserving size (325) for bucket 159 Calculating Z arrays for bucket 159 Entering block accumulator loop for bucket 159: bucket 158: 20% bucket 157: 30% Getting block 160 of 206 Reserving size (325) for bucket 160 Calculating Z arrays for bucket 160 bucket 159: 10% Entering block accumulator loop for bucket 160: bucket 158: 30% bucket 157: 40% bucket 159: 20% Getting block 161 of 206 bucket 160: 10% Reserving size (325) for bucket 161 bucket 158: 40% Calculating Z arrays for bucket 161 bucket 157: 50% bucket 159: 30% Entering block accumulator loop for bucket 161: bucket 160: 20% bucket 158: 50% bucket 157: 60% bucket 159: 40% bucket 160: 30% bucket 161: 10% bucket 158: 60% bucket 157: 70% bucket 159: 50% bucket 160: 40% bucket 161: 20% bucket 158: 70% bucket 159: 60% bucket 157: 80% bucket 160: 50% bucket 158: 80% bucket 161: 30% bucket 159: 70% bucket 160: 60% bucket 157: 90% bucket 158: 90% bucket 161: 40% bucket 159: 80% bucket 160: 70% bucket 158: 100% bucket 157: 100% Sorting block of length 306 for bucket 158 (Using difference cover) Sorting block of length 285 for bucket 157 (Using difference cover) bucket 161: 50% bucket 159: 90% bucket 160: 80% bucket 161: 60% bucket 159: 100% bucket 160: 90% Sorting block of length 221 for bucket 159 (Using difference cover) bucket 161: 70% bucket 160: 100% Sorting block of length 315 for bucket 160 (Using difference cover) bucket 161: 80% Sorting block time: 00:00:00 Returning block of 258 for bucket 140 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 263 for bucket 134 Returning block of 162 for bucket 138 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 bucket 161: 90% Returning block of 198 for bucket 141 Returning block of 159 for bucket 136 Returning block of 223 for bucket 137 bucket 161: 100% Sorting block of length 148 for bucket 161 Sorting block time: 00:00:00 (Using difference cover) Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 318 for bucket 143 Returning block of 171 for bucket 142 Returning block of 295 for bucket 139 Getting block 162 of 206 Reserving size (325) for bucket 162 Calculating Z arrays for bucket 162 Entering block accumulator loop for bucket 162: Getting block 163 of 206 Reserving size (325) for bucket 163 Calculating Z arrays for bucket 163 bucket 162: 10% Entering block accumulator loop for bucket 163: Getting block 164 of 206 Reserving size (325) for bucket 164 bucket 162: 20% Calculating Z arrays for bucket 164 bucket 163: 10% Entering block accumulator loop for bucket 164: Getting block 165 of 206 bucket 162: 30% Reserving size (325) for bucket 165 Calculating Z arrays for bucket 165 bucket 163: 20% Entering block accumulator loop for bucket 165: bucket 164: 10% bucket 162: 40% bucket 163: 30% bucket 165: 10% Getting block 166 of 206 bucket 164: 20% Reserving size (325) for bucket 166 bucket 162: 50% Calculating Z arrays for bucket 166 bucket 165: 20% bucket 163: 40% Entering block accumulator loop for bucket 166: Getting block 167 of 206 bucket 164: 30% Reserving size (325) for bucket 167 bucket 162: 60% bucket 165: 30% Calculating Z arrays for bucket 167 bucket 163: 50% Entering block accumulator loop for bucket 167: bucket 166: 10% bucket 164: 40% bucket 162: 70% bucket 165: 40% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Getting block 168 of 206 Sorting block time: 00:00:00 Returning block of 270 for bucket 145 Returning block of 245 for bucket 144 bucket 166: 20% Returning block of 253 for bucket 152 Sorting block time: 00:00:00 bucket 163: 60% Reserving size (325) for bucket 168 bucket 167: 10% bucket 162: 80% bucket 165: 50% bucket 164: 50% Returning block of 220 for bucket 146 Calculating Z arrays for bucket 168 bucket 166: 30% bucket 163: 70% bucket 167: 20% Getting block 169 of 206 bucket 162: 90% bucket 165: 60% Entering block accumulator loop for bucket 168: bucket 164: 60% Reserving size (325) for bucket 169 Getting block 170 of 206 bucket 166: 40% Calculating Z arrays for bucket 169 bucket 163: 80% bucket 167: 30% Reserving size (325) for bucket 170 bucket 165: 70% bucket 162: 100% Entering block accumulator loop for bucket 169: bucket 164: 70% Calculating Z arrays for bucket 170 bucket 168: 10% Sorting block of length 182 for bucket 162 (Using difference cover) bucket 166: 50% bucket 163: 90% bucket 167: 40% bucket 165: 80% Getting block 171 of 206 Entering block accumulator loop for bucket 170: bucket 164: 80% bucket 168: 20% Reserving size (325) for bucket 171 bucket 166: 60% Getting block 172 of 206 bucket 169: 10% bucket 165: 90% bucket 163: 100% bucket 167: 50% Calculating Z arrays for bucket 171 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Reserving size (325) for bucket 172 Sorting block time: 00:00:00 bucket 164: 90% Sorting block of length 217 for bucket 163 (Using difference cover) Sorting block time: 00:00:00 bucket 168: 30% bucket 166: 70% Returning block of 214 for bucket 149 Getting block 173 of 206 Returning block of 169 for bucket 147 bucket 170: 10% Calculating Z arrays for bucket 172 Returning block of 185 for bucket 148 bucket 165: 100% bucket 169: 20% Entering block accumulator loop for bucket 171: bucket 167: 60% Returning block of 204 for bucket 153 bucket 164: 100% Reserving size (325) for bucket 173 bucket 166: 80% bucket 168: 40% Entering block accumulator loop for bucket 172: Sorting block time: 00:00:00 Sorting block of length 234 for bucket 165 (Using difference cover) Sorting block time: 00:00:00 bucket 170: 20% Getting block 174 of 206 Sorting block of length 191 for bucket 164 (Using difference cover) Calculating Z arrays for bucket 173 bucket 169: 30% bucket 167: 70% Returning block of 270 for bucket 150 Sorting block time: 00:00:00 Returning block of 254 for bucket 155 bucket 166: 90% Reserving size (325) for bucket 174 bucket 168: 50% bucket 171: 10% bucket 170: 30% Entering block accumulator loop for bucket 173: bucket 167: 80% bucket 169: 40% bucket 172: 10% Returning block of 297 for bucket 151 Getting block 175 of 206 Calculating Z arrays for bucket 174 Getting block 176 of 206 bucket 166: 100% bucket 168: 60% bucket 171: 20% bucket 170: 40% bucket 167: 90% Sorting block time: 00:00:00 Sorting block time: 00:00:00 Reserving size (325) for bucket 175 Getting block 177 of 206 Sorting block time: 00:00:00 bucket 169: 50% Reserving size (325) for bucket 176 Entering block accumulator loop for bucket 174: Sorting block time: 00:00:00 bucket 172: 20% Sorting block of length 281 for bucket 166 (Using difference cover) Returning block of 307 for bucket 158 Returning block of 222 for bucket 159 bucket 173: 10% Calculating Z arrays for bucket 175 bucket 168: 70% Reserving size (325) for bucket 177 Getting block 178 of 206 Returning block of 126 for bucket 154 bucket 171: 30% bucket 167: 100% Sorting block time: 00:00:00 Calculating Z arrays for bucket 176 bucket 170: 50% Returning block of 286 for bucket 157 bucket 169: 60% bucket 172: 30% Calculating Z arrays for bucket 177 Entering block accumulator loop for bucket 175: Reserving size (325) for bucket 178 bucket 173: 20% Returning block of 270 for bucket 156 bucket 168: 80% Sorting block time: 00:00:00 Sorting block of length 91 for bucket 167 (Using difference cover) Entering block accumulator loop for bucket 176: bucket 171: 40% Calculating Z arrays for bucket 178 bucket 170: 60% Getting block 179 of 206 Entering block accumulator loop for bucket 177: bucket 169: 70% bucket 174: 10% Returning block of 316 for bucket 160 bucket 172: 40% bucket 173: 30% bucket 168: 90% Entering block accumulator loop for bucket 178: Reserving size (325) for bucket 179 Sorting block time: 00:00:00 bucket 171: 50% bucket 175: 10% bucket 170: 70% Getting block 180 of 206 bucket 169: 80% Sorting block time: 00:00:00 Getting block 181 of 206 bucket 174: 20% Calculating Z arrays for bucket 179 bucket 172: 50% bucket 168: 100% Returning block of 149 for bucket 161 bucket 173: 40% bucket 176: 10% bucket 177: 10% Reserving size (325) for bucket 180 Returning block of 183 for bucket 162 Reserving size (325) for bucket 181 bucket 175: 20% bucket 170: 80% Getting block 182 of 206 bucket 171: 60% bucket 169: 90% Sorting block of length 324 for bucket 168 (Using difference cover) Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Entering block accumulator loop for bucket 179: bucket 178: 10% bucket 174: 30% Getting block 183 of 206 bucket 172: 60% Calculating Z arrays for bucket 180 Calculating Z arrays for bucket 181 Sorting block time: 00:00:00 bucket 173: 50% Sorting block time: 00:00:00 bucket 176: 20% bucket 177: 20% Reserving size (325) for bucket 182 bucket 175: 30% bucket 170: 90% Returning block of 235 for bucket 165 Returning block of 192 for bucket 164 Returning block of 218 for bucket 163 Getting block 184 of 206 bucket 171: 70% bucket 169: 100% Reserving size (325) for bucket 183 bucket 178: 20% Returning block of 92 for bucket 167 Entering block accumulator loop for bucket 180: Returning block of 282 for bucket 166 Sorting block time: 00:00:00 bucket 174: 40% Entering block accumulator loop for bucket 181: bucket 172: 70% Getting block 185 of 206 Calculating Z arrays for bucket 182 bucket 173: 60% bucket 176: 30% bucket 177: 30% bucket 175: 40% bucket 170: 100% Reserving size (325) for bucket 184 Sorting block of length 77 for bucket 169 (Using difference cover) Calculating Z arrays for bucket 183 bucket 171: 80% Returning block of 325 for bucket 168 bucket 178: 30% Getting block 186 of 206 Reserving size (325) for bucket 185 bucket 179: 10% bucket 174: 50% Entering block accumulator loop for bucket 182: bucket 172: 80% Sorting block of length 251 for bucket 170 (Using difference cover) Calculating Z arrays for bucket 184 bucket 173: 70% bucket 176: 40% bucket 177: 40% Entering block accumulator loop for bucket 183: Reserving size (325) for bucket 186 Calculating Z arrays for bucket 185 Getting block 187 of 206 bucket 171: 90% bucket 180: 10% bucket 178: 40% bucket 181: 10% bucket 175: 50% bucket 179: 20% Getting block 188 of 206 Entering block accumulator loop for bucket 184: bucket 174: 60% Getting block 189 of 206 bucket 172: 90% Calculating Z arrays for bucket 186 bucket 173: 80% Entering block accumulator loop for bucket 185: Reserving size (325) for bucket 187 bucket 176: 50% bucket 177: 50% bucket 171: 100% bucket 180: 20% Reserving size (325) for bucket 188 bucket 178: 50% bucket 181: 20% bucket 182: 10% Reserving size (325) for bucket 189 bucket 175: 60% Getting block 190 of 206 bucket 179: 30% Sorting block time: 00:00:00 Entering block accumulator loop for bucket 186: Calculating Z arrays for bucket 187 bucket 174: 70% Sorting block time: 00:00:00 Getting block 191 of 206 Sorting block of length 99 for bucket 171 (Using difference cover) bucket 183: 10% bucket 172: 100% Calculating Z arrays for bucket 188 bucket 173: 90% bucket 176: 60% Calculating Z arrays for bucket 189 bucket 177: 60% bucket 180: 30% Reserving size (325) for bucket 190 Getting block 192 of 206 bucket 178: 60% bucket 181: 30% bucket 184: 10% bucket 182: 20% Returning block of 78 for bucket 169 bucket 175: 70% Entering block accumulator loop for bucket 187: Returning block of 252 for bucket 170 bucket 185: 10% bucket 179: 40% Sorting block time: 00:00:00 bucket 174: 80% Reserving size (325) for bucket 191 Sorting block of length 299 for bucket 172 (Using difference cover) Entering block accumulator loop for bucket 188: bucket 183: 20% Entering block accumulator loop for bucket 189: Calculating Z arrays for bucket 190 bucket 173: 100% Reserving size (325) for bucket 192 bucket 176: 70% bucket 177: 70% bucket 180: 40% bucket 178: 70% Getting block 193 of 206 bucket 181: 40% bucket 184: 20% bucket 182: 30% bucket 186: 10% bucket 175: 80% Returning block of 100 for bucket 171 bucket 185: 20% Sorting block time: 00:00:00 bucket 179: 50% Calculating Z arrays for bucket 191 bucket 174: 90% Getting block 194 of 206 Getting block 195 of 206 bucket 183: 30% Sorting block of length 253 for bucket 173 (Using difference cover) Entering block accumulator loop for bucket 190: Calculating Z arrays for bucket 192 Reserving size (325) for bucket 193 bucket 176: 80% bucket 177: 80% bucket 178: 80% bucket 180: 50% bucket 187: 10% bucket 181: 50% Returning block of 300 for bucket 172 bucket 184: 30% bucket 182: 40% bucket 186: 20% bucket 175: 90% Getting block 196 of 206 Entering block accumulator loop for bucket 191: Reserving size (325) for bucket 194 bucket 185: 30% bucket 179: 60% Sorting block time: 00:00:00 Reserving size (325) for bucket 195 bucket 188: 10% bucket 189: 10% bucket 174: 100% Getting block 197 of 206 Entering block accumulator loop for bucket 192: Calculating Z arrays for bucket 193 bucket 183: 40% bucket 176: 90% bucket 177: 90% bucket 178: 90% bucket 180: 60% bucket 187: 20% bucket 181: 60% Reserving size (325) for bucket 196 bucket 184: 40% bucket 182: 50% bucket 186: 30% bucket 175: 100% Calculating Z arrays for bucket 194 Returning block of 254 for bucket 173 Calculating Z arrays for bucket 195 Sorting block of length 81 for bucket 174 (Using difference cover) bucket 185: 40% bucket 179: 70% bucket 188: 20% Reserving size (325) for bucket 197 bucket 189: 20% bucket 190: 10% Entering block accumulator loop for bucket 193: Getting block 198 of 206 bucket 176: 100% Calculating Z arrays for bucket 196 bucket 183: 50% bucket 177: 100% bucket 178: 100% bucket 180: 70% bucket 187: 30% Sorting block of length 323 for bucket 175 (Using difference cover) bucket 181: 70% bucket 191: 10% Entering block accumulator loop for bucket 194: bucket 182: 60% bucket 184: 50% bucket 186: 40% Entering block accumulator loop for bucket 195: Getting block 199 of 206 Calculating Z arrays for bucket 197 bucket 179: 80% bucket 188: 30% bucket 185: 50% Reserving size (325) for bucket 198 bucket 190: 20% Sorting block of length 297 for bucket 176 (Using difference cover) bucket 189: 30% bucket 192: 10% Entering block accumulator loop for bucket 196: Sorting block of length 211 for bucket 177 (Using difference cover) Sorting block of length 259 for bucket 178 (Using difference cover) bucket 183: 60% bucket 180: 80% bucket 187: 40% bucket 181: 80% Reserving size (325) for bucket 199 bucket 191: 20% bucket 182: 70% bucket 184: 60% Entering block accumulator loop for bucket 197: bucket 186: 50% Calculating Z arrays for bucket 198 Sorting block time: 00:00:00 bucket 188: 40% bucket 179: 90% bucket 193: 10% bucket 185: 60% bucket 190: 30% bucket 192: 20% bucket 189: 40% Getting block 200 of 206 bucket 194: 10% bucket 183: 70% bucket 180: 90% Calculating Z arrays for bucket 199 bucket 181: 90% bucket 187: 50% bucket 195: 10% Returning block of 82 for bucket 174 Entering block accumulator loop for bucket 198: bucket 182: 80% bucket 191: 30% bucket 184: 70% bucket 186: 60% bucket 188: 50% bucket 179: 100% Reserving size (325) for bucket 200 bucket 196: 10% bucket 190: 40% bucket 185: 70% bucket 192: 30% bucket 193: 20% bucket 189: 50% bucket 194: 20% Entering block accumulator loop for bucket 199: bucket 183: 80% bucket 180: 100% bucket 181: 100% bucket 187: 60% bucket 195: 20% bucket 197: 10% Sorting block of length 254 for bucket 179 (Using difference cover) bucket 182: 90% Calculating Z arrays for bucket 200 bucket 191: 40% bucket 184: 80% bucket 188: 60% bucket 186: 70% bucket 196: 20% bucket 190: 50% bucket 185: 80% bucket 192: 40% bucket 189: 60% bucket 194: 30% Sorting block time: 00:00:00 bucket 193: 30% Sorting block time: 00:00:00 Sorting block of length 299 for bucket 180 (Using difference cover) Sorting block of length 279 for bucket 181 (Using difference cover) bucket 183: 90% bucket 198: 10% bucket 187: 70% bucket 195: 30% bucket 197: 20% Entering block accumulator loop for bucket 200: bucket 182: 100% bucket 188: 70% bucket 184: 90% bucket 191: 50% bucket 186: 80% bucket 190: 60% bucket 196: 30% Returning block of 324 for bucket 175 bucket 185: 90% bucket 192: 50% bucket 189: 70% bucket 194: 40% Sorting block time: 00:00:00 Getting block 201 of 206 Sorting block time: 00:00:00 Returning block of 260 for bucket 178 bucket 199: 10% bucket 193: 40% bucket 183: 100% Sorting block of length 276 for bucket 182 (Using difference cover) bucket 198: 20% bucket 187: 80% bucket 195: 40% bucket 197: 30% bucket 188: 80% bucket 184: 100% bucket 190: 70% bucket 191: 60% bucket 186: 90% Returning block of 298 for bucket 176 bucket 196: 40% Reserving size (325) for bucket 201 Returning block of 212 for bucket 177 bucket 185: 100% bucket 192: 60% bucket 189: 80% bucket 194: 50% Sorting block of length 298 for bucket 183 (Using difference cover) bucket 199: 20% bucket 200: 10% bucket 193: 50% Sorting block of length 273 for bucket 184 (Using difference cover) bucket 198: 30% bucket 187: 90% Sorting block time: 00:00:00 bucket 188: 90% bucket 195: 50% bucket 197: 40% bucket 190: 80% Calculating Z arrays for bucket 201 bucket 191: 70% bucket 186: 100% Sorting block of length 319 for bucket 185 (Using difference cover) bucket 196: 50% bucket 192: 70% bucket 189: 90% bucket 194: 60% bucket 199: 30% Getting block 202 of 206 Returning block of 255 for bucket 179 bucket 200: 20% bucket 193: 60% bucket 198: 40% bucket 188: 100% bucket 187: 100% Entering block accumulator loop for bucket 201: Sorting block of length 140 for bucket 186 (Using difference cover) bucket 195: 60% bucket 190: 90% bucket 197: 50% bucket 191: 80% Getting block 203 of 206 bucket 196: 60% bucket 192: 80% bucket 189: 100% bucket 194: 70% Reserving size (325) for bucket 202 Getting block 204 of 206 bucket 199: 40% Sorting block of length 202 for bucket 188 (Using difference cover) Sorting block of length 285 for bucket 187 (Using difference cover) bucket 200: 30% bucket 193: 70% bucket 198: 50% Reserving size (325) for bucket 203 bucket 195: 70% bucket 190: 100% Sorting block of length 292 for bucket 189 (Using difference cover) Getting block 205 of 206 bucket 197: 60% Calculating Z arrays for bucket 202 bucket 191: 90% bucket 196: 70% Reserving size (325) for bucket 204 bucket 192: 90% bucket 194: 80% bucket 199: 50% Calculating Z arrays for bucket 203 bucket 201: 10% Sorting block of length 224 for bucket 190 (Using difference cover) bucket 200: 40% bucket 193: 80% Reserving size (325) for bucket 205 bucket 198: 60% bucket 195: 80% Entering block accumulator loop for bucket 202: Calculating Z arrays for bucket 204 Getting block 206 of 206 bucket 197: 70% bucket 191: 100% bucket 196: 80% Entering block accumulator loop for bucket 203: bucket 194: 90% bucket 192: 100% Calculating Z arrays for bucket 205 bucket 199: 60% bucket 201: 20% Entering block accumulator loop for bucket 204: Reserving size (325) for bucket 206 bucket 193: 90% Sorting block time: 00:00:00 bucket 200: 50% bucket 198: 70% bucket 195: 90% Sorting block of length 109 for bucket 191 (Using difference cover) bucket 197: 80% Sorting block of length 300 for bucket 192 (Using difference cover) bucket 196: 90% Entering block accumulator loop for bucket 205: bucket 194: 100% Calculating Z arrays for bucket 206 Returning block of 280 for bucket 181 bucket 199: 70% bucket 201: 30% bucket 202: 10% bucket 193: 100% bucket 198: 80% bucket 200: 60% bucket 195: 100% Sorting block time: 00:00:00 bucket 203: 10% Sorting block of length 296 for bucket 194 (Using difference cover) bucket 197: 90% Entering block accumulator loop for bucket 206: bucket 196: 100% bucket 204: 10% Sorting block of length 211 for bucket 193 (Using difference cover) bucket 199: 80% Sorting block of length 239 for bucket 195 (Using difference cover) Returning block of 300 for bucket 180 bucket 201: 40% bucket 202: 20% bucket 198: 90% bucket 200: 70% bucket 203: 20% Sorting block of length 116 for bucket 196 (Using difference cover) bucket 205: 10% bucket 197: 100% bucket 204: 20% bucket 199: 90% bucket 201: 50% bucket 206: 10% bucket 202: 30% bucket 198: 100% Sorting block of length 273 for bucket 197 (Using difference cover) bucket 200: 80% bucket 203: 30% bucket 205: 20% Sorting block of length 298 for bucket 198 (Using difference cover) bucket 204: 30% bucket 206: 20% bucket 199: 100% bucket 201: 60% bucket 202: 40% bucket 200: 90% Sorting block of length 310 for bucket 199 (Using difference cover) bucket 203: 40% bucket 205: 30% bucket 206: 30% bucket 204: 40% bucket 201: 70% bucket 202: 50% bucket 200: 100% Sorting block of length 317 for bucket 200 (Using difference cover) bucket 206: 40% bucket 203: 50% bucket 205: 40% bucket 201: 80% bucket 204: 50% bucket 202: 60% bucket 206: 50% bucket 203: 60% bucket 201: 90% bucket 205: 50% bucket 204: 60% bucket 202: 70% bucket 206: 60% bucket 203: 70% bucket 201: 100% Sorting block of length 259 for bucket 201 (Using difference cover) bucket 204: 70% bucket 205: 60% bucket 206: 70% bucket 202: 80% bucket 203: 80% bucket 204: 80% bucket 206: 80% bucket 205: 70% bucket 202: 90% bucket 203: 90% bucket 206: 90% bucket 204: 90% bucket 205: 80% bucket 202: 100% bucket 206: 100% bucket 203: 100% Sorting block of length 256 for bucket 202 (Using difference cover) Sorting block of length 182 for bucket 206 (Using difference cover) Sorting block of length 230 for bucket 203 (Using difference cover) bucket 204: 100% bucket 205: 90% Sorting block of length 176 for bucket 204 (Using difference cover) bucket 205: 100% Sorting block of length 301 for bucket 205 (Using difference cover) Sorting block time: 00:00:00 Returning block of 274 for bucket 184 Sorting block time: 00:00:00 Returning block of 277 for bucket 182 Sorting block time: 00:00:00 Returning block of 299 for bucket 183 Sorting block time: 00:00:00 Returning block of 203 for bucket 188 Sorting block time: 00:00:00 Returning block of 320 for bucket 185 Sorting block time: 00:00:00 Returning block of 183 for bucket 206 Sorting block time: 00:00:00 Returning block of 286 for bucket 187 Sorting block time: 00:00:00 Returning block of 260 for bucket 201 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 297 for bucket 194 Returning block of 212 for bucket 193 Sorting block time: 00:00:00 Returning block of 141 for bucket 186 Sorting block time: 00:00:00 Returning block of 293 for bucket 189 Returning block of 301 for bucket 192 Returning block of 257 for bucket 202 Returning block of 117 for bucket 196 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 225 for bucket 190 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Sorting block time: 00:00:00 Returning block of 231 for bucket 203 Returning block of 240 for bucket 195 Returning block of 274 for bucket 197 Returning block of 177 for bucket 204 Returning block of 110 for bucket 191 Returning block of 302 for bucket 205 Returning block of 299 for bucket 198 Returning block of 318 for bucket 200 Returning block of 311 for bucket 199 Exited Ebwt loop fchr[A]: 0 fchr[C]: 25154 fchr[G]: 36516 fchr[T]: 36516 fchr[$]: 48502 Exiting Ebwt::buildToDisk() Returning from initFromVector Wrote 4210679 bytes to primary EBWT file: BS_GA.rev.1.bt2 Wrote 12132 bytes to secondary EBWT file: BS_GA.rev.2.bt2 Re-opening _in1 and _in2 as input streams Returning from Ebwt constructor Headers: len: 48502 bwtLen: 48503 sz: 12126 bwtSz: 12126 lineRate: 6 offRate: 4 offMask: 0xfffffff0 ftabChars: 10 eftabLen: 20 eftabSz: 80 ftabLen: 1048577 ftabSz: 4194308 offsLen: 3032 offsSz: 12128 lineSz: 64 sideSz: 64 sideBwtSz: 48 sideBwtLen: 192 numSides: 253 numLines: 253 ebwtTotLen: 16192 ebwtTotSz: 16192 color: 0 reverse: 1 Total time for backward call to driver() for mirror index: 00:00:00