Settings:
Output files: "Olurida_v081.*.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:
/gscratch/srlab/sam/data/O_lurida/oly_genome_assemblies/Olurida_v081.fa
Building a SMALL index
Reading reference sizes
Time reading reference sizes: 00:00:09
Calculating joined length
Writing header
Reserving space for joined string
Joining reference sequences
Time to join reference sequences: 00:00:04
bmax according to bmaxDivN setting: 9618349
Using parameters --bmax 7213762 --dcv 1024
Doing ahead-of-time memory usage test
Passed! Constructing with these parameters: --bmax 7213762 --dcv 1024
Constructing suffix-array element generator
Building DifferenceCoverSample
Building sPrime
Building sPrimeOrder
V-Sorting samples
V-Sorting samples time: 00:00:08
Allocating rank array
Ranking v-sort output
Ranking v-sort output time: 00:00:04
Invoking Larsson-Sadakane on ranks
Invoking Larsson-Sadakane on ranks time: 00:00:09
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 300 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 42, merged 123; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 25, merged 19; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 7, merged 19; 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 1, merged 3; iterating...
Avg bucket size: 5.15433e+06 (target: 7213761)
Converting suffix-array elements to index image
Allocating ftab, absorbFtab
Entering Ebwt loop
Getting block 2 of 209
Getting block 1 of 209
Reserving size (7213762) for bucket 2
Reserving size (7213762) for bucket 1
Getting block 3 of 209
Getting block 4 of 209
Getting block 5 of 209
Getting block 6 of 209
Getting block 7 of 209
Calculating Z arrays for bucket 2
Getting block 8 of 209
Calculating Z arrays for bucket 1
Reserving size (7213762) for bucket 3
Reserving size (7213762) for bucket 4
Getting block 9 of 209
Reserving size (7213762) for bucket 5
Reserving size (7213762) for bucket 6
Reserving size (7213762) for bucket 7
Entering block accumulator loop for bucket 2:
Reserving size (7213762) for bucket 8
Getting block 10 of 209
Getting block 11 of 209
Getting block 12 of 209
Getting block 13 of 209
Getting block 14 of 209
Getting block 15 of 209
Getting block 16 of 209
Getting block 17 of 209
Getting block 18 of 209
Getting block 19 of 209
Getting block 20 of 209
Entering block accumulator loop for bucket 1:
Getting block 21 of 209
Getting block 22 of 209
Calculating Z arrays for bucket 3
Calculating Z arrays for bucket 4
Reserving size (7213762) for bucket 9
Getting block 23 of 209
Getting block 24 of 209
Getting block 25 of 209
Getting block 26 of 209
Getting block 27 of 209
Calculating Z arrays for bucket 5
Calculating Z arrays for bucket 7
Calculating Z arrays for bucket 6
Calculating Z arrays for bucket 8
Reserving size (7213762) for bucket 10
Reserving size (7213762) for bucket 11
Reserving size (7213762) for bucket 12
Reserving size (7213762) for bucket 13
Reserving size (7213762) for bucket 14
Reserving size (7213762) for bucket 15
Reserving size (7213762) for bucket 16
Reserving size (7213762) for bucket 17
Reserving size (7213762) for bucket 18
Reserving size (7213762) for bucket 19
Reserving size (7213762) for bucket 20
Reserving size (7213762) for bucket 21
Reserving size (7213762) for bucket 22
Entering block accumulator loop for bucket 3:
Calculating Z arrays for bucket 9
Entering block accumulator loop for bucket 4:
Reserving size (7213762) for bucket 23
Reserving size (7213762) for bucket 24
Reserving size (7213762) for bucket 25
Reserving size (7213762) for bucket 26
Reserving size (7213762) for bucket 27
Entering block accumulator loop for bucket 5:
Entering block accumulator loop for bucket 7:
Entering block accumulator loop for bucket 6:
Calculating Z arrays for bucket 10
Calculating Z arrays for bucket 11
Calculating Z arrays for bucket 13
Calculating Z arrays for bucket 12
Calculating Z arrays for bucket 14
Entering block accumulator loop for bucket 8:
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
Entering block accumulator loop for bucket 9:
Calculating Z arrays for bucket 23
Calculating Z arrays for bucket 24
Calculating Z arrays for bucket 26
Calculating Z arrays for bucket 25
Calculating Z arrays for bucket 27
Entering block accumulator loop for bucket 10:
Entering block accumulator loop for bucket 11:
Entering block accumulator loop for bucket 13:
Entering block accumulator loop for bucket 12:
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 26:
Entering block accumulator loop for bucket 27:
Entering block accumulator loop for bucket 25:
bucket 1: 10%
bucket 2: 10%
bucket 4: 10%
bucket 9: 10%
bucket 3: 10%
bucket 8: 10%
bucket 5: 10%
bucket 7: 10%
bucket 6: 10%
bucket 11: 10%
bucket 12: 10%
bucket 17: 10%
bucket 10: 10%
bucket 16: 10%
bucket 13: 10%
bucket 15: 10%
bucket 20: 10%
bucket 19: 10%
bucket 21: 10%
bucket 18: 10%
bucket 14: 10%
bucket 24: 10%
bucket 26: 10%
bucket 25: 10%
bucket 27: 10%
bucket 22: 10%
bucket 23: 10%
bucket 1: 20%
bucket 2: 20%
bucket 4: 20%
bucket 3: 20%
bucket 9: 20%
bucket 8: 20%
bucket 7: 20%
bucket 6: 20%
bucket 11: 20%
bucket 12: 20%
bucket 5: 20%
bucket 17: 20%
bucket 16: 20%
bucket 13: 20%
bucket 15: 20%
bucket 10: 20%
bucket 20: 20%
bucket 14: 20%
bucket 19: 20%
bucket 21: 20%
bucket 18: 20%
bucket 25: 20%
bucket 24: 20%
bucket 22: 20%
bucket 26: 20%
bucket 27: 20%
bucket 23: 20%
bucket 1: 30%
bucket 2: 30%
bucket 4: 30%
bucket 3: 30%
bucket 9: 30%
bucket 8: 30%
bucket 7: 30%
bucket 6: 30%
bucket 11: 30%
bucket 12: 30%
bucket 17: 30%
bucket 5: 30%
bucket 16: 30%
bucket 13: 30%
bucket 15: 30%
bucket 10: 30%
bucket 20: 30%
bucket 14: 30%
bucket 19: 30%
bucket 21: 30%
bucket 18: 30%
bucket 22: 30%
bucket 25: 30%
bucket 24: 30%
bucket 26: 30%
bucket 27: 30%
bucket 23: 30%
bucket 1: 40%
bucket 2: 40%
bucket 4: 40%
bucket 3: 40%
bucket 9: 40%
bucket 8: 40%
bucket 7: 40%
bucket 6: 40%
bucket 12: 40%
bucket 11: 40%
bucket 17: 40%
bucket 13: 40%
bucket 16: 40%
bucket 5: 40%
bucket 15: 40%
bucket 10: 40%
bucket 20: 40%
bucket 14: 40%
bucket 21: 40%
bucket 19: 40%
bucket 18: 40%
bucket 1: 50%
bucket 2: 50%
bucket 22: 40%
bucket 25: 40%
bucket 24: 40%
bucket 26: 40%
bucket 27: 40%
bucket 23: 40%
bucket 4: 50%
bucket 3: 50%
bucket 9: 50%
bucket 8: 50%
bucket 7: 50%
bucket 6: 50%
bucket 12: 50%
bucket 11: 50%
bucket 17: 50%
bucket 13: 50%
bucket 16: 50%
bucket 10: 50%
bucket 15: 50%
bucket 5: 50%
bucket 20: 50%
bucket 14: 50%
bucket 1: 60%
bucket 2: 60%
bucket 21: 50%
bucket 19: 50%
bucket 18: 50%
bucket 22: 50%
bucket 25: 50%
bucket 4: 60%
bucket 24: 50%
bucket 3: 60%
bucket 26: 50%
bucket 27: 50%
bucket 23: 50%
bucket 9: 60%
bucket 8: 60%
bucket 7: 60%
bucket 6: 60%
bucket 12: 60%
bucket 11: 60%
bucket 17: 60%
bucket 13: 60%
bucket 10: 60%
bucket 1: 70%
bucket 15: 60%
bucket 16: 60%
bucket 2: 70%
bucket 5: 60%
bucket 20: 60%
bucket 14: 60%
bucket 18: 60%
bucket 21: 60%
bucket 19: 60%
bucket 4: 70%
bucket 3: 70%
bucket 22: 60%
bucket 25: 60%
bucket 24: 60%
bucket 9: 70%
bucket 8: 70%
bucket 26: 60%
bucket 7: 70%
bucket 27: 60%
bucket 6: 70%
bucket 23: 60%
bucket 12: 70%
bucket 11: 70%
bucket 1: 80%
bucket 17: 70%
bucket 13: 70%
bucket 2: 80%
bucket 10: 70%
bucket 15: 70%
bucket 5: 70%
bucket 16: 70%
bucket 14: 70%
bucket 20: 70%
bucket 4: 80%
bucket 18: 70%
bucket 21: 70%
bucket 3: 80%
bucket 19: 70%
bucket 9: 80%
bucket 22: 70%
bucket 8: 80%
bucket 25: 70%
bucket 7: 80%
bucket 24: 70%
bucket 6: 80%
bucket 1: 90%
bucket 12: 80%
bucket 11: 80%
bucket 26: 70%
bucket 2: 90%
bucket 27: 70%
bucket 23: 70%
bucket 17: 80%
bucket 13: 80%
bucket 10: 80%
bucket 15: 80%
bucket 16: 80%
bucket 5: 80%
bucket 20: 80%
bucket 14: 80%
bucket 4: 90%
bucket 3: 90%
bucket 18: 80%
bucket 21: 80%
bucket 19: 80%
bucket 9: 90%
bucket 8: 90%
bucket 1: 100%
Sorting block of length 3171720 for bucket 1
(Using difference cover)
bucket 7: 90%
bucket 6: 90%
bucket 22: 80%
bucket 2: 100%
Sorting block of length 4762015 for bucket 2
(Using difference cover)
bucket 12: 90%
bucket 25: 80%
bucket 11: 90%
bucket 24: 80%
bucket 17: 90%
bucket 26: 80%
bucket 13: 90%
bucket 27: 80%
bucket 10: 90%
bucket 23: 80%
bucket 15: 90%
bucket 16: 90%
bucket 5: 90%
bucket 4: 100%
Sorting block of length 4739999 for bucket 4
(Using difference cover)
bucket 3: 100%
Sorting block of length 4403627 for bucket 3
(Using difference cover)
bucket 14: 90%
bucket 20: 90%
bucket 9: 100%
Sorting block of length 2687520 for bucket 9
(Using difference cover)
bucket 18: 90%
bucket 21: 90%
Sorting block time: 00:00:01
Returning block of 3171721 for bucket 1
bucket 8: 100%
Sorting block of length 5005218 for bucket 8
(Using difference cover)
bucket 19: 90%
Getting block 28 of 209
Reserving size (7213762) for bucket 28
Calculating Z arrays for bucket 28
Entering block accumulator loop for bucket 28:
bucket 7: 100%
Sorting block of length 6311815 for bucket 7
(Using difference cover)
bucket 6: 100%
Sorting block of length 7060539 for bucket 6
(Using difference cover)
bucket 12: 100%
Sorting block of length 4913329 for bucket 12
(Using difference cover)
bucket 22: 90%
bucket 11: 100%
Sorting block of length 4896501 for bucket 11
(Using difference cover)
bucket 25: 90%
bucket 17: 100%
Sorting block of length 2912872 for bucket 17
(Using difference cover)
bucket 24: 90%
bucket 13: 100%
Sorting block of length 6600618 for bucket 13
(Using difference cover)
bucket 10: 100%
Sorting block of length 7065763 for bucket 10
(Using difference cover)
bucket 5: 100%
Sorting block of length 6399520 for bucket 5
(Using difference cover)
bucket 26: 90%
bucket 15: 100%
Sorting block of length 6968479 for bucket 15
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4762016 for bucket 2
bucket 16: 100%
Sorting block of length 5636004 for bucket 16
(Using difference cover)
bucket 27: 90%
bucket 23: 90%
Getting block 29 of 209
Reserving size (7213762) for bucket 29
Calculating Z arrays for bucket 29
Entering block accumulator loop for bucket 29:
bucket 14: 100%
Sorting block of length 6742167 for bucket 14
(Using difference cover)
bucket 20: 100%
Sorting block of length 2949745 for bucket 20
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 2687521 for bucket 9
bucket 18: 100%
Sorting block of length 5325965 for bucket 18
(Using difference cover)
Getting block 30 of 209
Reserving size (7213762) for bucket 30
Calculating Z arrays for bucket 30
Entering block accumulator loop for bucket 30:
bucket 21: 100%
Sorting block of length 5695741 for bucket 21
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4403628 for bucket 3
bucket 19: 100%
Sorting block of length 5738281 for bucket 19
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4740000 for bucket 4
Getting block 31 of 209
Reserving size (7213762) for bucket 31
Calculating Z arrays for bucket 31
Entering block accumulator loop for bucket 31:
bucket 28: 10%
Getting block 32 of 209
Reserving size (7213762) for bucket 32
Calculating Z arrays for bucket 32
Entering block accumulator loop for bucket 32:
bucket 22: 100%
Sorting block of length 7145261 for bucket 22
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 2912873 for bucket 17
bucket 25: 100%
Sorting block of length 3767552 for bucket 25
(Using difference cover)
Getting block 33 of 209
Reserving size (7213762) for bucket 33
Calculating Z arrays for bucket 33
Entering block accumulator loop for bucket 33:
bucket 24: 100%
Sorting block of length 6852413 for bucket 24
(Using difference cover)
bucket 26: 100%
Sorting block of length 5702713 for bucket 26
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 2949746 for bucket 20
Sorting block time: 00:00:02
Returning block of 5005219 for bucket 8
bucket 23: 100%
Sorting block of length 6581325 for bucket 23
(Using difference cover)
bucket 27: 100%
Sorting block of length 6320632 for bucket 27
(Using difference cover)
bucket 29: 10%
Getting block 34 of 209
Reserving size (7213762) for bucket 34
Calculating Z arrays for bucket 34
Entering block accumulator loop for bucket 34:
Getting block 35 of 209
Reserving size (7213762) for bucket 35
Calculating Z arrays for bucket 35
Entering block accumulator loop for bucket 35:
Sorting block time: 00:00:02
Returning block of 4913330 for bucket 12
Sorting block time: 00:00:02
Returning block of 4896502 for bucket 11
Getting block 36 of 209
Reserving size (7213762) for bucket 36
Calculating Z arrays for bucket 36
Entering block accumulator loop for bucket 36:
Getting block 37 of 209
Reserving size (7213762) for bucket 37
Calculating Z arrays for bucket 37
Entering block accumulator loop for bucket 37:
bucket 30: 10%
Sorting block time: 00:00:02
Returning block of 6311816 for bucket 7
Getting block 38 of 209
Reserving size (7213762) for bucket 38
Calculating Z arrays for bucket 38
Entering block accumulator loop for bucket 38:
bucket 31: 10%
bucket 28: 20%
bucket 32: 10%
Sorting block time: 00:00:02
Returning block of 5636005 for bucket 16
Sorting block time: 00:00:02
Returning block of 6399521 for bucket 5
bucket 33: 10%
Sorting block time: 00:00:03
Returning block of 6600619 for bucket 13
Sorting block time: 00:00:03
Returning block of 7060540 for bucket 6
Getting block 39 of 209
Reserving size (7213762) for bucket 39
Calculating Z arrays for bucket 39
Entering block accumulator loop for bucket 39:
Sorting block time: 00:00:02
Returning block of 3767553 for bucket 25
Getting block 40 of 209
Reserving size (7213762) for bucket 40
Calculating Z arrays for bucket 40
Entering block accumulator loop for bucket 40:
Getting block 41 of 209
Reserving size (7213762) for bucket 41
Calculating Z arrays for bucket 41
Entering block accumulator loop for bucket 41:
Getting block 42 of 209
Reserving size (7213762) for bucket 42
Calculating Z arrays for bucket 42
Entering block accumulator loop for bucket 42:
Getting block 43 of 209
Reserving size (7213762) for bucket 43
Calculating Z arrays for bucket 43
Entering block accumulator loop for bucket 43:
Sorting block time: 00:00:02
Returning block of 5325966 for bucket 18
Sorting block time: 00:00:02
Returning block of 5695742 for bucket 21
Sorting block time: 00:00:03
Returning block of 7065764 for bucket 10
Sorting block time: 00:00:02
Returning block of 5738282 for bucket 19
Getting block 44 of 209
Reserving size (7213762) for bucket 44
Calculating Z arrays for bucket 44
Entering block accumulator loop for bucket 44:
Getting block 45 of 209
Reserving size (7213762) for bucket 45
Calculating Z arrays for bucket 45
Entering block accumulator loop for bucket 45:
bucket 29: 20%
Sorting block time: 00:00:02
Returning block of 6742168 for bucket 14
Sorting block time: 00:00:02
Returning block of 6968480 for bucket 15
bucket 34: 10%
Getting block 46 of 209
Reserving size (7213762) for bucket 46
Calculating Z arrays for bucket 46
Entering block accumulator loop for bucket 46:
bucket 35: 10%
Getting block 47 of 209
Reserving size (7213762) for bucket 47
Calculating Z arrays for bucket 47
Entering block accumulator loop for bucket 47:
Getting block 48 of 209
Reserving size (7213762) for bucket 48
Calculating Z arrays for bucket 48
Entering block accumulator loop for bucket 48:
Getting block 49 of 209
Reserving size (7213762) for bucket 49
Calculating Z arrays for bucket 49
Entering block accumulator loop for bucket 49:
bucket 36: 10%
bucket 30: 20%
bucket 37: 10%
bucket 28: 30%
Sorting block time: 00:00:01
Returning block of 5702714 for bucket 26
bucket 31: 20%
Sorting block time: 00:00:02
Returning block of 7145262 for bucket 22
bucket 38: 10%
bucket 32: 20%
Getting block 50 of 209
Reserving size (7213762) for bucket 50
Calculating Z arrays for bucket 50
Entering block accumulator loop for bucket 50:
Sorting block time: 00:00:02
Returning block of 6852414 for bucket 24
Sorting block time: 00:00:02
Returning block of 6320633 for bucket 27
Getting block 51 of 209
Reserving size (7213762) for bucket 51
Calculating Z arrays for bucket 51
Entering block accumulator loop for bucket 51:
Getting block 52 of 209
Reserving size (7213762) for bucket 52
Calculating Z arrays for bucket 52
Entering block accumulator loop for bucket 52:
Getting block 53 of 209
Reserving size (7213762) for bucket 53
Calculating Z arrays for bucket 53
Entering block accumulator loop for bucket 53:
Sorting block time: 00:00:02
Returning block of 6581326 for bucket 23
bucket 33: 20%
bucket 39: 10%
Getting block 54 of 209
Reserving size (7213762) for bucket 54
Calculating Z arrays for bucket 54
Entering block accumulator loop for bucket 54:
bucket 42: 10%
bucket 40: 10%
bucket 41: 10%
bucket 43: 10%
bucket 29: 30%
bucket 44: 10%
bucket 46: 10%
bucket 35: 20%
bucket 45: 10%
bucket 34: 20%
bucket 47: 10%
bucket 30: 30%
bucket 49: 10%
bucket 48: 10%
bucket 36: 20%
bucket 37: 20%
bucket 28: 40%
bucket 31: 30%
bucket 32: 30%
bucket 38: 20%
bucket 50: 10%
bucket 51: 10%
bucket 33: 30%
bucket 52: 10%
bucket 53: 10%
bucket 39: 20%
bucket 29: 40%
bucket 42: 20%
bucket 54: 10%
bucket 40: 20%
bucket 41: 20%
bucket 43: 20%
bucket 44: 20%
bucket 46: 20%
bucket 35: 30%
bucket 34: 30%
bucket 30: 40%
bucket 45: 20%
bucket 49: 20%
bucket 47: 20%
bucket 48: 20%
bucket 37: 30%
bucket 36: 30%
bucket 28: 50%
bucket 31: 40%
bucket 32: 40%
bucket 50: 20%
bucket 38: 30%
bucket 33: 40%
bucket 51: 20%
bucket 52: 20%
bucket 39: 30%
bucket 53: 20%
bucket 29: 50%
bucket 42: 30%
bucket 40: 30%
bucket 41: 30%
bucket 54: 20%
bucket 46: 30%
bucket 43: 30%
bucket 44: 30%
bucket 35: 40%
bucket 30: 50%
bucket 34: 40%
bucket 49: 30%
bucket 47: 30%
bucket 28: 60%
bucket 45: 30%
bucket 36: 40%
bucket 37: 40%
bucket 48: 30%
bucket 31: 50%
bucket 32: 50%
bucket 50: 30%
bucket 38: 40%
bucket 33: 50%
bucket 29: 60%
bucket 39: 40%
bucket 51: 30%
bucket 52: 30%
bucket 53: 30%
bucket 42: 40%
bucket 40: 40%
bucket 41: 40%
bucket 46: 40%
bucket 54: 30%
bucket 35: 50%
bucket 30: 60%
bucket 44: 40%
bucket 43: 40%
bucket 28: 70%
bucket 34: 50%
bucket 49: 40%
bucket 47: 40%
bucket 36: 50%
bucket 37: 50%
bucket 48: 40%
bucket 31: 60%
bucket 45: 40%
bucket 32: 60%
bucket 50: 40%
bucket 33: 60%
bucket 38: 50%
bucket 29: 70%
bucket 39: 50%
bucket 52: 40%
bucket 51: 40%
bucket 53: 40%
bucket 42: 50%
bucket 46: 50%
bucket 40: 50%
bucket 30: 70%
bucket 41: 50%
bucket 35: 60%
bucket 28: 80%
bucket 44: 50%
bucket 54: 40%
bucket 49: 50%
bucket 43: 50%
bucket 34: 60%
bucket 31: 70%
bucket 47: 50%
bucket 36: 60%
bucket 37: 60%
bucket 48: 50%
bucket 45: 50%
bucket 32: 70%
bucket 50: 50%
bucket 33: 70%
bucket 29: 80%
bucket 38: 60%
bucket 39: 60%
bucket 52: 50%
bucket 42: 60%
bucket 46: 60%
bucket 30: 80%
bucket 53: 50%
bucket 51: 50%
bucket 35: 70%
bucket 40: 60%
bucket 28: 90%
bucket 41: 60%
bucket 44: 60%
bucket 49: 60%
bucket 31: 80%
bucket 54: 50%
bucket 36: 70%
bucket 34: 70%
bucket 43: 60%
bucket 37: 70%
bucket 47: 60%
bucket 48: 60%
bucket 32: 80%
bucket 45: 60%
bucket 50: 60%
bucket 33: 80%
bucket 29: 90%
bucket 38: 70%
bucket 39: 70%
bucket 30: 90%
bucket 46: 70%
bucket 28: 100%
Sorting block of length 5808211 for bucket 28
(Using difference cover)
bucket 42: 70%
bucket 35: 80%
bucket 52: 60%
bucket 53: 60%
bucket 40: 70%
bucket 51: 60%
bucket 41: 70%
bucket 31: 90%
bucket 44: 70%
bucket 49: 70%
bucket 36: 80%
bucket 37: 80%
bucket 47: 70%
bucket 34: 80%
bucket 43: 70%
bucket 48: 70%
bucket 54: 60%
bucket 32: 90%
bucket 29: 100%
Sorting block of length 5257516 for bucket 29
(Using difference cover)
bucket 33: 90%
bucket 45: 70%
bucket 50: 70%
bucket 38: 80%
bucket 39: 80%
bucket 30: 100%
Sorting block of length 5325552 for bucket 30
(Using difference cover)
bucket 46: 80%
bucket 35: 90%
bucket 42: 80%
bucket 31: 100%
Sorting block of length 2229924 for bucket 31
(Using difference cover)
bucket 52: 70%
bucket 40: 80%
bucket 53: 70%
bucket 49: 80%
bucket 41: 80%
bucket 44: 80%
bucket 51: 70%
bucket 36: 90%
bucket 37: 90%
bucket 47: 80%
bucket 34: 90%
Sorting block time: 00:00:02
Returning block of 5808212 for bucket 28
bucket 32: 100%
Sorting block of length 6444390 for bucket 32
(Using difference cover)
bucket 48: 80%
bucket 43: 80%
bucket 54: 70%
Getting block 55 of 209
Reserving size (7213762) for bucket 55
Calculating Z arrays for bucket 55
Entering block accumulator loop for bucket 55:
bucket 33: 100%
Sorting block of length 4224620 for bucket 33
(Using difference cover)
bucket 50: 80%
bucket 45: 80%
Sorting block time: 00:00:00
Returning block of 2229925 for bucket 31
Getting block 56 of 209
Reserving size (7213762) for bucket 56
Calculating Z arrays for bucket 56
Entering block accumulator loop for bucket 56:
Sorting block time: 00:00:01
Returning block of 5257517 for bucket 29
Getting block 57 of 209
Reserving size (7213762) for bucket 57
Calculating Z arrays for bucket 57
Entering block accumulator loop for bucket 57:
bucket 39: 90%
bucket 38: 90%
bucket 46: 90%
bucket 35: 100%
Sorting block of length 5477441 for bucket 35
(Using difference cover)
bucket 42: 90%
bucket 49: 90%
bucket 40: 90%
bucket 52: 80%
bucket 41: 90%
bucket 44: 90%
bucket 36: 100%
Sorting block of length 5431995 for bucket 36
(Using difference cover)
bucket 51: 80%
bucket 47: 90%
bucket 37: 100%
Sorting block of length 3330372 for bucket 37
(Using difference cover)
bucket 34: 100%
Sorting block of length 6100643 for bucket 34
(Using difference cover)
bucket 53: 80%
bucket 43: 90%
bucket 48: 90%
Sorting block time: 00:00:02
Returning block of 5325553 for bucket 30
bucket 55: 10%
bucket 54: 80%
Getting block 58 of 209
Reserving size (7213762) for bucket 58
Calculating Z arrays for bucket 58
Entering block accumulator loop for bucket 58:
Sorting block time: 00:00:01
Returning block of 4224621 for bucket 33
bucket 50: 90%
bucket 45: 90%
Getting block 59 of 209
Reserving size (7213762) for bucket 59
Calculating Z arrays for bucket 59
Entering block accumulator loop for bucket 59:
bucket 56: 10%
bucket 39: 100%
Sorting block of length 2838820 for bucket 39
(Using difference cover)
bucket 57: 10%
bucket 46: 100%
Sorting block of length 4205064 for bucket 46
(Using difference cover)
bucket 38: 100%
Sorting block of length 6863330 for bucket 38
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6444391 for bucket 32
Getting block 60 of 209
Reserving size (7213762) for bucket 60
Calculating Z arrays for bucket 60
Entering block accumulator loop for bucket 60:
bucket 42: 100%
Sorting block of length 3280312 for bucket 42
(Using difference cover)
bucket 49: 100%
Sorting block of length 3935873 for bucket 49
(Using difference cover)
bucket 41: 100%
Sorting block of length 6510803 for bucket 41
(Using difference cover)
bucket 44: 100%
Sorting block of length 983615 for bucket 44
(Using difference cover)
bucket 40: 100%
Sorting block of length 6897536 for bucket 40
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3330373 for bucket 37
bucket 52: 90%
Getting block 61 of 209
Reserving size (7213762) for bucket 61
Calculating Z arrays for bucket 61
Entering block accumulator loop for bucket 61:
bucket 51: 90%
bucket 47: 100%
Sorting block of length 7174695 for bucket 47
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 5477442 for bucket 35
bucket 48: 100%
Sorting block of length 5636887 for bucket 48
(Using difference cover)
Getting block 62 of 209
Reserving size (7213762) for bucket 62
Calculating Z arrays for bucket 62
Entering block accumulator loop for bucket 62:
bucket 43: 100%
Sorting block of length 6837231 for bucket 43
(Using difference cover)
bucket 53: 90%
Sorting block time: 00:00:00
Returning block of 983616 for bucket 44
Getting block 63 of 209
Reserving size (7213762) for bucket 63
Calculating Z arrays for bucket 63
Entering block accumulator loop for bucket 63:
Sorting block time: 00:00:01
Returning block of 5431996 for bucket 36
bucket 55: 20%
bucket 58: 10%
bucket 54: 90%
Sorting block time: 00:00:01
Returning block of 2838821 for bucket 39
Getting block 64 of 209
Reserving size (7213762) for bucket 64
Calculating Z arrays for bucket 64
Entering block accumulator loop for bucket 64:
bucket 50: 100%
Sorting block of length 6000765 for bucket 50
(Using difference cover)
Getting block 65 of 209
Reserving size (7213762) for bucket 65
Calculating Z arrays for bucket 65
Entering block accumulator loop for bucket 65:
bucket 45: 100%
Sorting block of length 7036592 for bucket 45
(Using difference cover)
bucket 59: 10%
bucket 56: 20%
Sorting block time: 00:00:02
Returning block of 6100644 for bucket 34
Sorting block time: 00:00:01
Returning block of 3280313 for bucket 42
bucket 57: 20%
Sorting block time: 00:00:01
Returning block of 4205065 for bucket 46
Getting block 66 of 209
Reserving size (7213762) for bucket 66
Calculating Z arrays for bucket 66
Entering block accumulator loop for bucket 66:
Getting block 67 of 209
Reserving size (7213762) for bucket 67
Calculating Z arrays for bucket 67
Entering block accumulator loop for bucket 67:
Getting block 68 of 209
Reserving size (7213762) for bucket 68
Calculating Z arrays for bucket 68
Entering block accumulator loop for bucket 68:
Sorting block time: 00:00:01
Returning block of 3935874 for bucket 49
bucket 60: 10%
Getting block 69 of 209
Reserving size (7213762) for bucket 69
Calculating Z arrays for bucket 69
Entering block accumulator loop for bucket 69:
bucket 52: 100%
Sorting block of length 6541955 for bucket 52
(Using difference cover)
bucket 51: 100%
Sorting block of length 7043732 for bucket 51
(Using difference cover)
bucket 61: 10%
bucket 53: 100%
Sorting block of length 6592454 for bucket 53
(Using difference cover)
bucket 62: 10%
Sorting block time: 00:00:02
Returning block of 6863331 for bucket 38
bucket 55: 30%
bucket 63: 10%
bucket 58: 20%
bucket 65: 10%
bucket 54: 100%
Sorting block of length 6597329 for bucket 54
(Using difference cover)
Getting block 70 of 209
Reserving size (7213762) for bucket 70
Calculating Z arrays for bucket 70
Entering block accumulator loop for bucket 70:
Sorting block time: 00:00:02
Returning block of 5636888 for bucket 48
Getting block 71 of 209
Reserving size (7213762) for bucket 71
Calculating Z arrays for bucket 71
Entering block accumulator loop for bucket 71:
Sorting block time: 00:00:02
Returning block of 6510804 for bucket 41
bucket 59: 20%
Sorting block time: 00:00:02
Returning block of 6897537 for bucket 40
bucket 64: 10%
bucket 56: 30%
Getting block 72 of 209
Reserving size (7213762) for bucket 72
Calculating Z arrays for bucket 72
Entering block accumulator loop for bucket 72:
bucket 66: 10%
Getting block 73 of 209
Reserving size (7213762) for bucket 73
Calculating Z arrays for bucket 73
Entering block accumulator loop for bucket 73:
bucket 57: 30%
bucket 67: 10%
bucket 68: 10%
Sorting block time: 00:00:02
Returning block of 7174696 for bucket 47
bucket 69: 10%
bucket 60: 20%
Sorting block time: 00:00:02
Returning block of 6837232 for bucket 43
Sorting block time: 00:00:02
Returning block of 6000766 for bucket 50
Getting block 74 of 209
Reserving size (7213762) for bucket 74
Calculating Z arrays for bucket 74
Entering block accumulator loop for bucket 74:
Getting block 75 of 209
Reserving size (7213762) for bucket 75
Calculating Z arrays for bucket 75
Entering block accumulator loop for bucket 75:
Getting block 76 of 209
Reserving size (7213762) for bucket 76
Calculating Z arrays for bucket 76
Entering block accumulator loop for bucket 76:
bucket 61: 20%
Sorting block time: 00:00:02
Returning block of 7036593 for bucket 45
bucket 62: 20%
Getting block 77 of 209
Reserving size (7213762) for bucket 77
Calculating Z arrays for bucket 77
Entering block accumulator loop for bucket 77:
bucket 55: 40%
bucket 65: 20%
bucket 58: 30%
bucket 70: 10%
bucket 63: 20%
bucket 71: 10%
Sorting block time: 00:00:02
Returning block of 6541956 for bucket 52
bucket 59: 30%
bucket 66: 20%
Getting block 78 of 209
Reserving size (7213762) for bucket 78
Calculating Z arrays for bucket 78
Entering block accumulator loop for bucket 78:
bucket 72: 10%
bucket 56: 40%
Sorting block time: 00:00:02
Returning block of 6592455 for bucket 53
bucket 73: 10%
bucket 64: 20%
bucket 57: 40%
bucket 67: 20%
Getting block 79 of 209
Reserving size (7213762) for bucket 79
Calculating Z arrays for bucket 79
Entering block accumulator loop for bucket 79:
bucket 68: 20%
Sorting block time: 00:00:03
Returning block of 7043733 for bucket 51
bucket 69: 20%
Sorting block time: 00:00:02
Returning block of 6597330 for bucket 54
bucket 60: 30%
Getting block 80 of 209
Reserving size (7213762) for bucket 80
Calculating Z arrays for bucket 80
Entering block accumulator loop for bucket 80:
Getting block 81 of 209
Reserving size (7213762) for bucket 81
Calculating Z arrays for bucket 81
Entering block accumulator loop for bucket 81:
bucket 74: 10%
bucket 75: 10%
bucket 76: 10%
bucket 61: 30%
bucket 62: 30%
bucket 65: 30%
bucket 55: 50%
bucket 77: 10%
bucket 70: 20%
bucket 58: 40%
bucket 63: 30%
bucket 71: 20%
bucket 66: 30%
bucket 59: 40%
bucket 78: 10%
bucket 72: 20%
bucket 56: 50%
bucket 73: 20%
bucket 57: 50%
bucket 79: 10%
bucket 67: 30%
bucket 69: 30%
bucket 68: 30%
bucket 64: 30%
bucket 80: 10%
bucket 81: 10%
bucket 60: 40%
bucket 74: 20%
bucket 75: 20%
bucket 76: 20%
bucket 61: 40%
bucket 65: 40%
bucket 70: 30%
bucket 55: 60%
bucket 62: 40%
bucket 58: 50%
bucket 77: 20%
bucket 66: 40%
bucket 71: 30%
bucket 63: 40%
bucket 59: 50%
bucket 78: 20%
bucket 72: 30%
bucket 56: 60%
bucket 79: 20%
bucket 73: 30%
bucket 69: 40%
bucket 57: 60%
bucket 67: 40%
bucket 68: 40%
bucket 80: 20%
bucket 81: 20%
bucket 64: 40%
bucket 60: 50%
bucket 74: 30%
bucket 75: 30%
bucket 76: 30%
bucket 61: 50%
bucket 65: 50%
bucket 70: 40%
bucket 55: 70%
bucket 58: 60%
bucket 62: 50%
bucket 66: 50%
bucket 77: 30%
bucket 71: 40%
bucket 78: 30%
bucket 59: 60%
bucket 72: 40%
bucket 63: 50%
bucket 79: 30%
bucket 69: 50%
bucket 56: 70%
bucket 73: 40%
bucket 57: 70%
bucket 67: 50%
bucket 68: 50%
bucket 80: 30%
bucket 81: 30%
bucket 74: 40%
bucket 60: 60%
bucket 75: 40%
bucket 64: 50%
bucket 76: 40%
bucket 65: 60%
bucket 61: 60%
bucket 70: 50%
bucket 55: 80%
bucket 66: 60%
bucket 58: 70%
bucket 62: 60%
bucket 77: 40%
bucket 71: 50%
bucket 78: 40%
bucket 59: 70%
bucket 79: 40%
bucket 69: 60%
bucket 63: 60%
bucket 56: 80%
bucket 72: 50%
bucket 73: 50%
bucket 67: 60%
bucket 57: 80%
bucket 80: 40%
bucket 81: 40%
bucket 68: 60%
bucket 74: 50%
bucket 60: 70%
bucket 75: 50%
bucket 65: 70%
bucket 70: 60%
bucket 61: 70%
bucket 66: 70%
bucket 64: 60%
bucket 55: 90%
bucket 76: 50%
bucket 58: 80%
bucket 62: 70%
bucket 71: 60%
bucket 77: 50%
bucket 78: 50%
bucket 79: 50%
bucket 69: 70%
bucket 59: 80%
bucket 63: 70%
bucket 56: 90%
bucket 72: 60%
bucket 80: 50%
bucket 67: 70%
bucket 73: 60%
bucket 57: 90%
bucket 68: 70%
bucket 81: 50%
bucket 74: 60%
bucket 65: 80%
bucket 75: 60%
bucket 60: 80%
bucket 70: 70%
bucket 66: 80%
bucket 61: 80%
bucket 55: 100%
Sorting block of length 3979355 for bucket 55
(Using difference cover)
bucket 76: 60%
bucket 58: 90%
bucket 64: 70%
bucket 62: 80%
bucket 79: 60%
bucket 71: 70%
bucket 78: 60%
bucket 69: 80%
bucket 77: 60%
bucket 59: 90%
bucket 80: 60%
bucket 72: 70%
bucket 56: 100%
Sorting block of length 6261232 for bucket 56
(Using difference cover)
bucket 67: 80%
bucket 73: 70%
bucket 63: 80%
bucket 57: 100%
Sorting block of length 5754575 for bucket 57
(Using difference cover)
bucket 81: 60%
bucket 68: 80%
bucket 65: 90%
bucket 74: 70%
bucket 75: 70%
bucket 66: 90%
bucket 70: 80%
bucket 60: 90%
Sorting block time: 00:00:01
Returning block of 3979356 for bucket 55
Getting block 82 of 209
Reserving size (7213762) for bucket 82
Calculating Z arrays for bucket 82
Entering block accumulator loop for bucket 82:
bucket 61: 90%
bucket 76: 70%
bucket 58: 100%
Sorting block of length 6833672 for bucket 58
(Using difference cover)
bucket 79: 70%
bucket 62: 90%
bucket 71: 80%
bucket 69: 90%
bucket 78: 70%
bucket 64: 80%
bucket 77: 70%
bucket 59: 100%
Sorting block of length 2137733 for bucket 59
(Using difference cover)
bucket 80: 70%
bucket 72: 80%
bucket 81: 70%
bucket 67: 90%
bucket 68: 90%
bucket 73: 80%
bucket 63: 90%
bucket 65: 100%
Sorting block of length 6211604 for bucket 65
(Using difference cover)
bucket 66: 100%
Sorting block of length 1720561 for bucket 66
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5754576 for bucket 57
bucket 74: 80%
Sorting block time: 00:00:02
Returning block of 6261233 for bucket 56
bucket 75: 80%
bucket 70: 90%
Getting block 83 of 209
Reserving size (7213762) for bucket 83
Calculating Z arrays for bucket 83
Entering block accumulator loop for bucket 83:
bucket 82: 10%
Sorting block time: 00:00:01
Returning block of 2137734 for bucket 59
bucket 60: 100%
Sorting block of length 6215897 for bucket 60
(Using difference cover)
Getting block 84 of 209
Reserving size (7213762) for bucket 84
Calculating Z arrays for bucket 84
Entering block accumulator loop for bucket 84:
Getting block 85 of 209
Reserving size (7213762) for bucket 85
Calculating Z arrays for bucket 85
Entering block accumulator loop for bucket 85:
bucket 61: 100%
Sorting block of length 6816058 for bucket 61
(Using difference cover)
bucket 76: 80%
bucket 79: 80%
bucket 69: 100%
Sorting block of length 4194339 for bucket 69
(Using difference cover)
Sorting block time: 00:00:00
Returning block of 1720562 for bucket 66
bucket 78: 80%
bucket 62: 100%
Sorting block of length 6132908 for bucket 62
(Using difference cover)
bucket 71: 90%
Getting block 86 of 209
Reserving size (7213762) for bucket 86
Calculating Z arrays for bucket 86
Entering block accumulator loop for bucket 86:
bucket 80: 80%
bucket 64: 90%
bucket 77: 80%
bucket 81: 80%
bucket 72: 90%
bucket 67: 100%
Sorting block of length 7213226 for bucket 67
(Using difference cover)
bucket 68: 100%
Sorting block of length 6157313 for bucket 68
(Using difference cover)
bucket 73: 90%
bucket 63: 100%
Sorting block of length 5685800 for bucket 63
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6833673 for bucket 58
bucket 70: 100%
Sorting block of length 3647510 for bucket 70
(Using difference cover)
Getting block 87 of 209
Reserving size (7213762) for bucket 87
Calculating Z arrays for bucket 87
Entering block accumulator loop for bucket 87:
bucket 82: 20%
bucket 74: 90%
bucket 75: 90%
bucket 83: 10%
bucket 84: 10%
bucket 85: 10%
bucket 79: 90%
bucket 76: 90%
bucket 78: 90%
bucket 71: 100%
Sorting block of length 5024740 for bucket 71
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4194340 for bucket 69
bucket 86: 10%
Getting block 88 of 209
Reserving size (7213762) for bucket 88
Calculating Z arrays for bucket 88
Entering block accumulator loop for bucket 88:
Sorting block time: 00:00:02
Returning block of 6211605 for bucket 65
bucket 80: 90%
Sorting block time: 00:00:02
Returning block of 6215898 for bucket 60
bucket 81: 90%
Getting block 89 of 209
Reserving size (7213762) for bucket 89
Calculating Z arrays for bucket 89
Entering block accumulator loop for bucket 89:
bucket 72: 100%
Sorting block of length 4283225 for bucket 72
(Using difference cover)
bucket 77: 90%
Getting block 90 of 209
Reserving size (7213762) for bucket 90
Calculating Z arrays for bucket 90
Entering block accumulator loop for bucket 90:
bucket 64: 100%
Sorting block of length 4508252 for bucket 64
(Using difference cover)
bucket 73: 100%
Sorting block of length 6253749 for bucket 73
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3647511 for bucket 70
Getting block 91 of 209
Reserving size (7213762) for bucket 91
Calculating Z arrays for bucket 91
Entering block accumulator loop for bucket 91:
bucket 82: 30%
Sorting block time: 00:00:02
Returning block of 6132909 for bucket 62
bucket 83: 20%
Sorting block time: 00:00:02
Returning block of 6816059 for bucket 61
bucket 87: 10%
bucket 75: 100%
Sorting block of length 4244755 for bucket 75
(Using difference cover)
bucket 74: 100%
Sorting block of length 6199664 for bucket 74
(Using difference cover)
Getting block 92 of 209
Reserving size (7213762) for bucket 92
Calculating Z arrays for bucket 92
Entering block accumulator loop for bucket 92:
Sorting block time: 00:00:02
Returning block of 6157314 for bucket 68
Getting block 93 of 209
Reserving size (7213762) for bucket 93
Calculating Z arrays for bucket 93
Entering block accumulator loop for bucket 93:
bucket 84: 20%
bucket 85: 20%
bucket 79: 100%
Sorting block of length 6107104 for bucket 79
(Using difference cover)
Getting block 94 of 209
Reserving size (7213762) for bucket 94
Calculating Z arrays for bucket 94
Entering block accumulator loop for bucket 94:
bucket 76: 100%
Sorting block of length 4239795 for bucket 76
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5685801 for bucket 63
bucket 78: 100%
Sorting block of length 3108929 for bucket 78
(Using difference cover)
bucket 86: 20%
Getting block 95 of 209
Reserving size (7213762) for bucket 95
Calculating Z arrays for bucket 95
Entering block accumulator loop for bucket 95:
bucket 88: 10%
bucket 80: 100%
Sorting block of length 4261140 for bucket 80
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7213227 for bucket 67
Sorting block time: 00:00:01
Returning block of 5024741 for bucket 71
bucket 81: 100%
Sorting block of length 6486229 for bucket 81
(Using difference cover)
Getting block 96 of 209
Reserving size (7213762) for bucket 96
Calculating Z arrays for bucket 96
Entering block accumulator loop for bucket 96:
Getting block 97 of 209
Reserving size (7213762) for bucket 97
Calculating Z arrays for bucket 97
Entering block accumulator loop for bucket 97:
bucket 89: 10%
bucket 90: 10%
Sorting block time: 00:00:01
Returning block of 4283226 for bucket 72
bucket 77: 100%
Sorting block of length 6836584 for bucket 77
(Using difference cover)
Getting block 98 of 209
Reserving size (7213762) for bucket 98
Calculating Z arrays for bucket 98
Entering block accumulator loop for bucket 98:
Sorting block time: 00:00:01
Returning block of 4508253 for bucket 64
Getting block 99 of 209
Reserving size (7213762) for bucket 99
Calculating Z arrays for bucket 99
Entering block accumulator loop for bucket 99:
bucket 82: 40%
bucket 91: 10%
bucket 83: 30%
bucket 87: 20%
bucket 84: 30%
Sorting block time: 00:00:01
Returning block of 4244756 for bucket 75
bucket 92: 10%
bucket 85: 30%
bucket 93: 10%
Getting block 100 of 209
Reserving size (7213762) for bucket 100
Calculating Z arrays for bucket 100
Entering block accumulator loop for bucket 100:
Sorting block time: 00:00:01
Returning block of 3108930 for bucket 78
bucket 94: 10%
Getting block 101 of 209
Reserving size (7213762) for bucket 101
Calculating Z arrays for bucket 101
Entering block accumulator loop for bucket 101:
Sorting block time: 00:00:02
Returning block of 6253750 for bucket 73
Sorting block time: 00:00:01
Returning block of 4239796 for bucket 76
Getting block 102 of 209
Reserving size (7213762) for bucket 102
Calculating Z arrays for bucket 102
Entering block accumulator loop for bucket 102:
Getting block 103 of 209
Reserving size (7213762) for bucket 103
Calculating Z arrays for bucket 103
Entering block accumulator loop for bucket 103:
bucket 86: 30%
Sorting block time: 00:00:01
Returning block of 4261141 for bucket 80
bucket 88: 20%
bucket 95: 10%
Sorting block time: 00:00:01
Returning block of 6107105 for bucket 79
Getting block 104 of 209
Reserving size (7213762) for bucket 104
Calculating Z arrays for bucket 104
Entering block accumulator loop for bucket 104:
Sorting block time: 00:00:01
Returning block of 6199665 for bucket 74
Getting block 105 of 209
Reserving size (7213762) for bucket 105
Calculating Z arrays for bucket 105
Entering block accumulator loop for bucket 105:
bucket 89: 20%
Getting block 106 of 209
Reserving size (7213762) for bucket 106
Calculating Z arrays for bucket 106
Entering block accumulator loop for bucket 106:
bucket 90: 20%
bucket 96: 10%
bucket 97: 10%
bucket 98: 10%
bucket 82: 50%
bucket 83: 40%
bucket 99: 10%
bucket 91: 20%
Sorting block time: 00:00:02
Returning block of 6486230 for bucket 81
bucket 87: 30%
Getting block 107 of 209
Reserving size (7213762) for bucket 107
Calculating Z arrays for bucket 107
Entering block accumulator loop for bucket 107:
bucket 84: 40%
bucket 85: 40%
bucket 92: 20%
bucket 93: 20%
Sorting block time: 00:00:02
Returning block of 6836585 for bucket 77
bucket 100: 10%
bucket 94: 20%
bucket 101: 10%
Getting block 108 of 209
Reserving size (7213762) for bucket 108
Calculating Z arrays for bucket 108
Entering block accumulator loop for bucket 108:
bucket 86: 40%
bucket 88: 30%
bucket 103: 10%
bucket 95: 20%
bucket 104: 10%
bucket 89: 30%
bucket 102: 10%
bucket 105: 10%
bucket 90: 30%
bucket 106: 10%
bucket 82: 60%
bucket 97: 20%
bucket 96: 20%
bucket 83: 50%
bucket 98: 20%
bucket 99: 20%
bucket 91: 30%
bucket 87: 40%
bucket 84: 50%
bucket 85: 50%
bucket 107: 10%
bucket 93: 30%
bucket 92: 30%
bucket 94: 30%
bucket 100: 20%
bucket 101: 20%
bucket 108: 10%
bucket 86: 50%
bucket 88: 40%
bucket 103: 20%
bucket 95: 30%
bucket 104: 20%
bucket 89: 40%
bucket 82: 70%
bucket 105: 20%
bucket 90: 40%
bucket 83: 60%
bucket 106: 20%
bucket 97: 30%
bucket 96: 30%
bucket 102: 20%
bucket 98: 30%
bucket 87: 50%
bucket 91: 40%
bucket 99: 30%
bucket 84: 60%
bucket 85: 60%
bucket 93: 40%
bucket 92: 40%
bucket 107: 20%
bucket 94: 40%
bucket 100: 30%
bucket 88: 50%
bucket 86: 60%
bucket 101: 30%
bucket 108: 20%
bucket 95: 40%
bucket 103: 30%
bucket 82: 80%
bucket 89: 50%
bucket 104: 30%
bucket 83: 70%
bucket 90: 50%
bucket 105: 30%
bucket 106: 30%
bucket 97: 40%
bucket 96: 40%
bucket 87: 60%
bucket 98: 40%
bucket 91: 50%
bucket 84: 70%
bucket 85: 70%
bucket 99: 40%
bucket 102: 30%
bucket 93: 50%
bucket 92: 50%
bucket 107: 30%
bucket 94: 50%
bucket 88: 60%
bucket 86: 70%
bucket 100: 40%
bucket 101: 40%
bucket 82: 90%
bucket 108: 30%
bucket 95: 50%
bucket 103: 40%
bucket 83: 80%
bucket 89: 60%
bucket 104: 40%
bucket 90: 60%
bucket 105: 40%
bucket 97: 50%
bucket 106: 40%
bucket 96: 50%
bucket 87: 70%
bucket 84: 80%
bucket 98: 50%
bucket 91: 60%
bucket 85: 80%
bucket 99: 50%
bucket 93: 60%
bucket 92: 60%
bucket 102: 40%
bucket 107: 40%
bucket 88: 70%
bucket 94: 60%
bucket 86: 80%
bucket 82: 100%
Sorting block of length 5806478 for bucket 82
(Using difference cover)
bucket 101: 50%
bucket 100: 50%
bucket 83: 90%
bucket 95: 60%
bucket 108: 40%
bucket 103: 50%
bucket 89: 70%
bucket 104: 50%
bucket 90: 70%
bucket 105: 50%
bucket 87: 80%
bucket 84: 90%
bucket 97: 60%
bucket 106: 50%
bucket 96: 60%
bucket 85: 90%
bucket 91: 70%
bucket 98: 60%
bucket 93: 70%
bucket 99: 60%
bucket 92: 70%
bucket 88: 80%
bucket 94: 70%
bucket 86: 90%
bucket 107: 50%
bucket 83: 100%
Sorting block of length 6687103 for bucket 83
(Using difference cover)
bucket 102: 50%
bucket 101: 60%
Sorting block time: 00:00:01
Returning block of 5806479 for bucket 82
bucket 95: 70%
bucket 100: 60%
bucket 89: 80%
bucket 108: 50%
bucket 103: 60%
Getting block 109 of 209
Reserving size (7213762) for bucket 109
Calculating Z arrays for bucket 109
Entering block accumulator loop for bucket 109:
bucket 90: 80%
bucket 104: 60%
bucket 105: 60%
bucket 87: 90%
bucket 84: 100%
Sorting block of length 5647283 for bucket 84
(Using difference cover)
bucket 85: 100%
Sorting block of length 4544736 for bucket 85
(Using difference cover)
bucket 97: 70%
bucket 106: 60%
bucket 96: 70%
bucket 91: 80%
bucket 98: 70%
bucket 93: 80%
bucket 99: 70%
bucket 92: 80%
bucket 88: 90%
bucket 86: 100%
Sorting block of length 5185417 for bucket 86
(Using difference cover)
bucket 94: 80%
bucket 107: 60%
bucket 95: 80%
bucket 101: 70%
bucket 89: 90%
bucket 100: 70%
bucket 109: 10%
bucket 103: 70%
bucket 102: 60%
bucket 108: 60%
bucket 90: 90%
bucket 104: 70%
bucket 87: 100%
Sorting block of length 5638435 for bucket 87
(Using difference cover)
bucket 105: 70%
Sorting block time: 00:00:02
Returning block of 6687104 for bucket 83
Sorting block time: 00:00:01
Returning block of 4544737 for bucket 85
Getting block 110 of 209
Reserving size (7213762) for bucket 110
Calculating Z arrays for bucket 110
Entering block accumulator loop for bucket 110:
Getting block 111 of 209
Reserving size (7213762) for bucket 111
Calculating Z arrays for bucket 111
Entering block accumulator loop for bucket 111:
bucket 97: 80%
bucket 91: 90%
bucket 106: 70%
bucket 96: 80%
bucket 98: 80%
bucket 93: 90%
Sorting block time: 00:00:01
Returning block of 5647284 for bucket 84
bucket 92: 90%
bucket 99: 80%
Getting block 112 of 209
Reserving size (7213762) for bucket 112
Calculating Z arrays for bucket 112
Entering block accumulator loop for bucket 112:
bucket 88: 100%
Sorting block of length 2120262 for bucket 88
(Using difference cover)
bucket 94: 90%
Sorting block time: 00:00:02
Returning block of 5185418 for bucket 86
bucket 107: 70%
bucket 95: 90%
bucket 89: 100%
Sorting block of length 6334271 for bucket 89
(Using difference cover)
Getting block 113 of 209
Reserving size (7213762) for bucket 113
Calculating Z arrays for bucket 113
Entering block accumulator loop for bucket 113:
bucket 101: 80%
bucket 109: 20%
bucket 100: 80%
bucket 103: 80%
bucket 108: 70%
Sorting block time: 00:00:01
Returning block of 2120263 for bucket 88
Getting block 114 of 209
Reserving size (7213762) for bucket 114
Calculating Z arrays for bucket 114
Entering block accumulator loop for bucket 114:
bucket 90: 100%
Sorting block of length 7020336 for bucket 90
(Using difference cover)
bucket 104: 80%
bucket 102: 70%
bucket 111: 10%
bucket 105: 80%
bucket 110: 10%
Sorting block time: 00:00:02
Returning block of 5638436 for bucket 87
bucket 97: 90%
bucket 106: 80%
bucket 93: 100%
Sorting block of length 2644034 for bucket 93
(Using difference cover)
bucket 98: 90%
Getting block 115 of 209
Reserving size (7213762) for bucket 115
Calculating Z arrays for bucket 115
Entering block accumulator loop for bucket 115:
bucket 91: 100%
Sorting block of length 2678403 for bucket 91
(Using difference cover)
bucket 96: 90%
bucket 92: 100%
Sorting block of length 6945783 for bucket 92
(Using difference cover)
bucket 99: 90%
bucket 112: 10%
bucket 94: 100%
Sorting block of length 6124744 for bucket 94
(Using difference cover)
bucket 107: 80%
bucket 95: 100%
Sorting block of length 5699837 for bucket 95
(Using difference cover)
bucket 109: 30%
bucket 101: 90%
bucket 100: 90%
bucket 113: 10%
Sorting block time: 00:00:00
Returning block of 2644035 for bucket 93
bucket 103: 90%
Getting block 116 of 209
Reserving size (7213762) for bucket 116
Calculating Z arrays for bucket 116
Entering block accumulator loop for bucket 116:
bucket 108: 80%
Sorting block time: 00:00:00
Returning block of 2678404 for bucket 91
Getting block 117 of 209
Reserving size (7213762) for bucket 117
Calculating Z arrays for bucket 117
Entering block accumulator loop for bucket 117:
bucket 104: 90%
Sorting block time: 00:00:02
Returning block of 6334272 for bucket 89
bucket 105: 90%
bucket 111: 20%
bucket 114: 10%
bucket 110: 20%
bucket 102: 80%
bucket 106: 90%
Getting block 118 of 209
Reserving size (7213762) for bucket 118
Calculating Z arrays for bucket 118
Entering block accumulator loop for bucket 118:
bucket 98: 100%
Sorting block of length 2494215 for bucket 98
(Using difference cover)
bucket 115: 10%
bucket 97: 100%
Sorting block of length 6444954 for bucket 97
(Using difference cover)
bucket 96: 100%
Sorting block of length 6207134 for bucket 96
(Using difference cover)
bucket 99: 100%
Sorting block of length 5808115 for bucket 99
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7020337 for bucket 90
bucket 112: 20%
Getting block 119 of 209
Reserving size (7213762) for bucket 119
Calculating Z arrays for bucket 119
Entering block accumulator loop for bucket 119:
bucket 107: 90%
bucket 109: 40%
Sorting block time: 00:00:02
Returning block of 6124745 for bucket 94
Sorting block time: 00:00:01
Returning block of 2494216 for bucket 98
bucket 101: 100%
Sorting block of length 4001471 for bucket 101
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6945784 for bucket 92
bucket 100: 100%
Sorting block of length 6031746 for bucket 100
(Using difference cover)
bucket 103: 100%
Sorting block of length 4017666 for bucket 103
(Using difference cover)
bucket 116: 10%
Getting block 120 of 209
Reserving size (7213762) for bucket 120
Calculating Z arrays for bucket 120
Entering block accumulator loop for bucket 120:
Getting block 121 of 209
Reserving size (7213762) for bucket 121
Calculating Z arrays for bucket 121
Entering block accumulator loop for bucket 121:
bucket 113: 20%
Getting block 122 of 209
Reserving size (7213762) for bucket 122
Calculating Z arrays for bucket 122
Entering block accumulator loop for bucket 122:
Sorting block time: 00:00:02
Returning block of 5699838 for bucket 95
bucket 117: 10%
bucket 104: 100%
Sorting block of length 6878832 for bucket 104
(Using difference cover)
Getting block 123 of 209
Reserving size (7213762) for bucket 123
Calculating Z arrays for bucket 123
Entering block accumulator loop for bucket 123:
bucket 108: 90%
bucket 111: 30%
bucket 110: 30%
bucket 105: 100%
Sorting block of length 3388685 for bucket 105
(Using difference cover)
bucket 114: 20%
bucket 106: 100%
Sorting block of length 6545102 for bucket 106
(Using difference cover)
bucket 118: 10%
bucket 115: 20%
bucket 102: 90%
bucket 112: 30%
bucket 119: 10%
Sorting block time: 00:00:02
Returning block of 5808116 for bucket 99
Sorting block time: 00:00:02
Returning block of 6207135 for bucket 96
Getting block 124 of 209
Reserving size (7213762) for bucket 124
Calculating Z arrays for bucket 124
Entering block accumulator loop for bucket 124:
bucket 107: 100%
Sorting block of length 6947390 for bucket 107
(Using difference cover)
Getting block 125 of 209
Reserving size (7213762) for bucket 125
Calculating Z arrays for bucket 125
Entering block accumulator loop for bucket 125:
Sorting block time: 00:00:02
Returning block of 6444955 for bucket 97
bucket 109: 50%
Sorting block time: 00:00:01
Returning block of 4017667 for bucket 103
Sorting block time: 00:00:01
Returning block of 4001472 for bucket 101
Getting block 126 of 209
Reserving size (7213762) for bucket 126
Calculating Z arrays for bucket 126
Entering block accumulator loop for bucket 126:
Getting block 127 of 209
Reserving size (7213762) for bucket 127
Calculating Z arrays for bucket 127
Entering block accumulator loop for bucket 127:
Getting block 128 of 209
Reserving size (7213762) for bucket 128
Calculating Z arrays for bucket 128
Entering block accumulator loop for bucket 128:
bucket 116: 20%
Sorting block time: 00:00:01
Returning block of 3388686 for bucket 105
bucket 120: 10%
bucket 113: 30%
bucket 121: 10%
Getting block 129 of 209
Reserving size (7213762) for bucket 129
Calculating Z arrays for bucket 129
Entering block accumulator loop for bucket 129:
bucket 122: 10%
bucket 117: 20%
bucket 123: 10%
bucket 108: 100%
Sorting block of length 5927607 for bucket 108
(Using difference cover)
bucket 110: 40%
bucket 111: 40%
Sorting block time: 00:00:02
Returning block of 6031747 for bucket 100
bucket 114: 30%
bucket 118: 20%
Getting block 130 of 209
Reserving size (7213762) for bucket 130
bucket 115: 30%
Calculating Z arrays for bucket 130
Entering block accumulator loop for bucket 130:
bucket 112: 40%
Sorting block time: 00:00:02
Returning block of 6878833 for bucket 104
bucket 102: 100%
Sorting block of length 5859534 for bucket 102
(Using difference cover)
bucket 119: 20%
Getting block 131 of 209
Reserving size (7213762) for bucket 131
Calculating Z arrays for bucket 131
Entering block accumulator loop for bucket 131:
bucket 124: 10%
Sorting block time: 00:00:02
Returning block of 6545103 for bucket 106
bucket 125: 10%
bucket 109: 60%
Getting block 132 of 209
Reserving size (7213762) for bucket 132
Calculating Z arrays for bucket 132
Entering block accumulator loop for bucket 132:
bucket 126: 10%
bucket 127: 10%
bucket 128: 10%
bucket 116: 30%
bucket 120: 20%
bucket 129: 10%
bucket 113: 40%
bucket 122: 20%
bucket 121: 20%
bucket 123: 20%
bucket 117: 30%
Sorting block time: 00:00:02
Returning block of 6947391 for bucket 107
bucket 110: 50%
bucket 111: 50%
bucket 114: 40%
Getting block 133 of 209
Reserving size (7213762) for bucket 133
Calculating Z arrays for bucket 133
Entering block accumulator loop for bucket 133:
Sorting block time: 00:00:02
Returning block of 5927608 for bucket 108
bucket 115: 40%
bucket 118: 30%
bucket 130: 10%
Getting block 134 of 209
Reserving size (7213762) for bucket 134
Calculating Z arrays for bucket 134
Entering block accumulator loop for bucket 134:
bucket 112: 50%
bucket 119: 30%
bucket 124: 20%
bucket 131: 10%
bucket 125: 20%
bucket 109: 70%
bucket 126: 20%
bucket 127: 20%
bucket 128: 20%
bucket 132: 10%
Sorting block time: 00:00:02
Returning block of 5859535 for bucket 102
bucket 116: 40%
bucket 129: 20%
Getting block 135 of 209
Reserving size (7213762) for bucket 135
Calculating Z arrays for bucket 135
Entering block accumulator loop for bucket 135:
bucket 120: 30%
bucket 113: 50%
bucket 123: 30%
bucket 122: 30%
bucket 121: 30%
bucket 117: 40%
bucket 110: 60%
bucket 111: 60%
bucket 114: 50%
bucket 133: 10%
bucket 115: 50%
bucket 118: 40%
bucket 130: 20%
bucket 134: 10%
bucket 112: 60%
bucket 119: 40%
bucket 124: 30%
bucket 125: 30%
bucket 131: 20%
bucket 109: 80%
bucket 126: 30%
bucket 128: 30%
bucket 127: 30%
bucket 132: 20%
bucket 116: 50%
bucket 129: 30%
bucket 123: 40%
bucket 113: 60%
bucket 120: 40%
bucket 122: 40%
bucket 135: 10%
bucket 121: 40%
bucket 117: 50%
bucket 110: 70%
bucket 111: 70%
bucket 114: 60%
bucket 115: 60%
bucket 133: 20%
bucket 118: 50%
bucket 130: 30%
bucket 134: 20%
bucket 112: 70%
bucket 124: 40%
bucket 125: 40%
bucket 119: 50%
bucket 131: 30%
bucket 126: 40%
bucket 109: 90%
bucket 128: 40%
bucket 127: 40%
bucket 132: 30%
bucket 129: 40%
bucket 116: 60%
bucket 123: 50%
bucket 122: 50%
bucket 113: 70%
bucket 120: 50%
bucket 135: 20%
bucket 121: 50%
bucket 117: 60%
bucket 110: 80%
bucket 111: 80%
bucket 115: 70%
bucket 114: 70%
bucket 133: 30%
bucket 130: 40%
bucket 118: 60%
bucket 134: 30%
bucket 125: 50%
bucket 112: 80%
bucket 124: 50%
bucket 119: 60%
bucket 126: 50%
bucket 128: 50%
bucket 127: 50%
bucket 109: 100%
Sorting block of length 4908840 for bucket 109
(Using difference cover)
bucket 131: 40%
bucket 129: 50%
bucket 123: 60%
bucket 116: 70%
bucket 132: 40%
bucket 122: 60%
bucket 113: 80%
bucket 120: 60%
bucket 135: 30%
bucket 121: 60%
bucket 117: 70%
bucket 110: 90%
bucket 111: 90%
bucket 115: 80%
bucket 114: 80%
bucket 133: 40%
bucket 130: 50%
bucket 118: 70%
bucket 125: 60%
bucket 134: 40%
bucket 124: 60%
bucket 112: 90%
bucket 128: 60%
bucket 126: 60%
bucket 127: 60%
bucket 119: 70%
bucket 131: 50%
Sorting block time: 00:00:01
Returning block of 4908841 for bucket 109
bucket 123: 70%
bucket 129: 60%
Getting block 136 of 209
Reserving size (7213762) for bucket 136
Calculating Z arrays for bucket 136
Entering block accumulator loop for bucket 136:
bucket 116: 80%
bucket 132: 50%
bucket 122: 70%
bucket 113: 90%
bucket 120: 70%
bucket 135: 40%
bucket 117: 80%
bucket 121: 70%
bucket 110: 100%
Sorting block of length 2833995 for bucket 110
(Using difference cover)
bucket 111: 100%
Sorting block of length 5273010 for bucket 111
(Using difference cover)
bucket 115: 90%
bucket 114: 90%
bucket 133: 50%
bucket 130: 60%
bucket 118: 80%
bucket 125: 70%
bucket 124: 70%
bucket 128: 70%
bucket 126: 70%
bucket 134: 50%
bucket 127: 70%
bucket 112: 100%
Sorting block of length 5438576 for bucket 112
(Using difference cover)
bucket 119: 80%
bucket 131: 60%
bucket 123: 80%
Sorting block time: 00:00:01
Returning block of 2833996 for bucket 110
bucket 129: 70%
Getting block 137 of 209
Reserving size (7213762) for bucket 137
Calculating Z arrays for bucket 137
Entering block accumulator loop for bucket 137:
bucket 136: 10%
bucket 116: 90%
bucket 132: 60%
bucket 122: 80%
bucket 113: 100%
Sorting block of length 4938317 for bucket 113
(Using difference cover)
bucket 120: 80%
bucket 135: 50%
bucket 117: 90%
bucket 121: 80%
Sorting block time: 00:00:01
Returning block of 5273011 for bucket 111
bucket 115: 100%
Sorting block of length 5381358 for bucket 115
(Using difference cover)
Getting block 138 of 209
Reserving size (7213762) for bucket 138
Calculating Z arrays for bucket 138
Entering block accumulator loop for bucket 138:
bucket 114: 100%
Sorting block of length 3566101 for bucket 114
(Using difference cover)
bucket 133: 60%
bucket 125: 80%
bucket 118: 90%
bucket 130: 70%
bucket 128: 80%
bucket 126: 80%
bucket 124: 80%
bucket 127: 80%
bucket 134: 60%
bucket 119: 90%
bucket 131: 70%
bucket 123: 90%
bucket 129: 80%
Sorting block time: 00:00:02
Returning block of 5438577 for bucket 112
bucket 136: 20%
bucket 116: 100%
Sorting block of length 2667613 for bucket 116
(Using difference cover)
bucket 137: 10%
Getting block 139 of 209
Reserving size (7213762) for bucket 139
Calculating Z arrays for bucket 139
Entering block accumulator loop for bucket 139:
bucket 122: 90%
bucket 132: 70%
bucket 120: 90%
Sorting block time: 00:00:01
Returning block of 4938318 for bucket 113
bucket 135: 60%
bucket 117: 100%
Sorting block of length 3485737 for bucket 117
(Using difference cover)
Getting block 140 of 209
Reserving size (7213762) for bucket 140
Calculating Z arrays for bucket 140
Entering block accumulator loop for bucket 140:
Sorting block time: 00:00:01
Returning block of 3566102 for bucket 114
bucket 121: 90%
Getting block 141 of 209
Reserving size (7213762) for bucket 141
Calculating Z arrays for bucket 141
Entering block accumulator loop for bucket 141:
bucket 138: 10%
bucket 125: 90%
Sorting block time: 00:00:02
Returning block of 5381359 for bucket 115
Sorting block time: 00:00:01
Returning block of 2667614 for bucket 116
bucket 133: 70%
Getting block 142 of 209
Reserving size (7213762) for bucket 142
Calculating Z arrays for bucket 142
Entering block accumulator loop for bucket 142:
bucket 118: 100%
Sorting block of length 3751513 for bucket 118
(Using difference cover)
bucket 128: 90%
Getting block 143 of 209
Reserving size (7213762) for bucket 143
Calculating Z arrays for bucket 143
Entering block accumulator loop for bucket 143:
bucket 130: 80%
bucket 126: 90%
bucket 124: 90%
bucket 127: 90%
bucket 134: 70%
bucket 123: 100%
Sorting block of length 3667890 for bucket 123
(Using difference cover)
bucket 119: 100%
Sorting block of length 5494874 for bucket 119
(Using difference cover)
bucket 129: 90%
bucket 131: 80%
bucket 136: 30%
bucket 137: 20%
Sorting block time: 00:00:01
Returning block of 3485738 for bucket 117
bucket 122: 100%
Sorting block of length 4487511 for bucket 122
(Using difference cover)
bucket 139: 10%
Getting block 144 of 209
Reserving size (7213762) for bucket 144
Calculating Z arrays for bucket 144
Entering block accumulator loop for bucket 144:
bucket 132: 80%
bucket 120: 100%
Sorting block of length 5386580 for bucket 120
(Using difference cover)
bucket 135: 70%
bucket 140: 10%
bucket 121: 100%
Sorting block of length 5235432 for bucket 121
(Using difference cover)
bucket 141: 10%
Sorting block time: 00:00:01
Returning block of 3751514 for bucket 118
bucket 125: 100%
Sorting block of length 2420581 for bucket 125
(Using difference cover)
bucket 138: 20%
Getting block 145 of 209
Reserving size (7213762) for bucket 145
Calculating Z arrays for bucket 145
Entering block accumulator loop for bucket 145:
bucket 128: 100%
Sorting block of length 6384719 for bucket 128
(Using difference cover)
bucket 133: 80%
bucket 126: 100%
Sorting block of length 5155848 for bucket 126
(Using difference cover)
bucket 142: 10%
bucket 127: 100%
Sorting block of length 3544808 for bucket 127
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3667891 for bucket 123
bucket 124: 100%
Sorting block of length 5171964 for bucket 124
(Using difference cover)
bucket 130: 90%
Getting block 146 of 209
Reserving size (7213762) for bucket 146
Calculating Z arrays for bucket 146
Entering block accumulator loop for bucket 146:
bucket 143: 10%
bucket 134: 80%
bucket 129: 100%
Sorting block of length 5155912 for bucket 129
(Using difference cover)
bucket 131: 90%
bucket 136: 40%
Sorting block time: 00:00:02
Returning block of 4487512 for bucket 122
Sorting block time: 00:00:01
Returning block of 2420582 for bucket 125
Sorting block time: 00:00:02
Returning block of 5494875 for bucket 119
bucket 137: 30%
bucket 144: 10%
bucket 139: 20%
Getting block 147 of 209
Reserving size (7213762) for bucket 147
Calculating Z arrays for bucket 147
Entering block accumulator loop for bucket 147:
bucket 132: 90%
Getting block 148 of 209
Reserving size (7213762) for bucket 148
Calculating Z arrays for bucket 148
Entering block accumulator loop for bucket 148:
Getting block 149 of 209
Reserving size (7213762) for bucket 149
Calculating Z arrays for bucket 149
Entering block accumulator loop for bucket 149:
bucket 135: 80%
bucket 140: 20%
Sorting block time: 00:00:01
Returning block of 5386581 for bucket 120
Sorting block time: 00:00:01
Returning block of 3544809 for bucket 127
Getting block 150 of 209
Reserving size (7213762) for bucket 150
Calculating Z arrays for bucket 150
Entering block accumulator loop for bucket 150:
bucket 141: 20%
Getting block 151 of 209
Reserving size (7213762) for bucket 151
Calculating Z arrays for bucket 151
Entering block accumulator loop for bucket 151:
bucket 145: 10%
bucket 138: 30%
Sorting block time: 00:00:01
Returning block of 5235433 for bucket 121
Getting block 152 of 209
Reserving size (7213762) for bucket 152
Calculating Z arrays for bucket 152
Entering block accumulator loop for bucket 152:
bucket 133: 90%
Sorting block time: 00:00:02
Returning block of 5155849 for bucket 126
bucket 146: 10%
bucket 142: 20%
bucket 130: 100%
Sorting block of length 6435377 for bucket 130
(Using difference cover)
Getting block 153 of 209
Reserving size (7213762) for bucket 153
Calculating Z arrays for bucket 153
Entering block accumulator loop for bucket 153:
Sorting block time: 00:00:02
Returning block of 5171965 for bucket 124
Getting block 154 of 209
Reserving size (7213762) for bucket 154
Calculating Z arrays for bucket 154
Entering block accumulator loop for bucket 154:
bucket 134: 90%
Sorting block time: 00:00:02
Returning block of 6384720 for bucket 128
bucket 131: 100%
Sorting block of length 4926713 for bucket 131
(Using difference cover)
bucket 143: 20%
Sorting block time: 00:00:01
Returning block of 5155913 for bucket 129
Getting block 155 of 209
Reserving size (7213762) for bucket 155
Calculating Z arrays for bucket 155
Entering block accumulator loop for bucket 155:
bucket 136: 50%
Getting block 156 of 209
Reserving size (7213762) for bucket 156
Calculating Z arrays for bucket 156
Entering block accumulator loop for bucket 156:
bucket 144: 20%
bucket 147: 10%
bucket 139: 30%
bucket 137: 40%
bucket 148: 10%
bucket 132: 100%
Sorting block of length 5235463 for bucket 132
(Using difference cover)
bucket 149: 10%
bucket 135: 90%
bucket 140: 30%
bucket 150: 10%
bucket 145: 20%
bucket 151: 10%
bucket 141: 30%
bucket 138: 40%
bucket 152: 10%
bucket 146: 20%
bucket 133: 100%
Sorting block of length 2651279 for bucket 133
(Using difference cover)
bucket 142: 30%
bucket 153: 10%
bucket 154: 10%
bucket 134: 100%
Sorting block of length 5032459 for bucket 134
(Using difference cover)
bucket 155: 10%
Sorting block time: 00:00:01
Returning block of 4926714 for bucket 131
bucket 136: 60%
Sorting block time: 00:00:01
Returning block of 6435378 for bucket 130
bucket 156: 10%
Getting block 157 of 209
Reserving size (7213762) for bucket 157
Calculating Z arrays for bucket 157
Entering block accumulator loop for bucket 157:
bucket 144: 30%
bucket 147: 20%
bucket 143: 30%
Getting block 158 of 209
Reserving size (7213762) for bucket 158
Calculating Z arrays for bucket 158
Entering block accumulator loop for bucket 158:
bucket 139: 40%
bucket 148: 20%
bucket 137: 50%
bucket 149: 20%
Sorting block time: 00:00:01
Returning block of 2651280 for bucket 133
Sorting block time: 00:00:02
Returning block of 5235464 for bucket 132
Getting block 159 of 209
Reserving size (7213762) for bucket 159
Calculating Z arrays for bucket 159
Entering block accumulator loop for bucket 159:
Getting block 160 of 209
Reserving size (7213762) for bucket 160
Calculating Z arrays for bucket 160
Entering block accumulator loop for bucket 160:
bucket 135: 100%
Sorting block of length 3429989 for bucket 135
(Using difference cover)
bucket 140: 40%
bucket 150: 20%
bucket 145: 30%
bucket 151: 20%
bucket 138: 50%
bucket 141: 40%
bucket 152: 20%
bucket 146: 30%
bucket 153: 20%
bucket 142: 40%
bucket 154: 20%
bucket 155: 20%
Sorting block time: 00:00:02
Returning block of 5032460 for bucket 134
bucket 156: 20%
bucket 136: 70%
bucket 144: 40%
bucket 157: 10%
bucket 147: 30%
Getting block 161 of 209
Reserving size (7213762) for bucket 161
Calculating Z arrays for bucket 161
Entering block accumulator loop for bucket 161:
bucket 158: 10%
Sorting block time: 00:00:01
Returning block of 3429990 for bucket 135
bucket 148: 30%
Getting block 162 of 209
Reserving size (7213762) for bucket 162
Calculating Z arrays for bucket 162
Entering block accumulator loop for bucket 162:
bucket 139: 50%
bucket 149: 30%
bucket 137: 60%
bucket 159: 10%
bucket 143: 40%
bucket 160: 10%
bucket 150: 30%
bucket 145: 40%
bucket 140: 50%
bucket 138: 60%
bucket 151: 30%
bucket 152: 30%
bucket 141: 50%
bucket 146: 40%
bucket 153: 30%
bucket 142: 50%
bucket 155: 30%
bucket 154: 30%
bucket 156: 30%
bucket 144: 50%
bucket 136: 80%
bucket 157: 20%
bucket 147: 40%
bucket 158: 20%
bucket 148: 40%
bucket 161: 10%
bucket 149: 40%
bucket 162: 10%
bucket 139: 60%
bucket 137: 70%
bucket 159: 20%
bucket 160: 20%
bucket 150: 40%
bucket 145: 50%
bucket 143: 50%
bucket 140: 60%
bucket 152: 40%
bucket 138: 70%
bucket 151: 40%
bucket 146: 50%
bucket 141: 60%
bucket 153: 40%
bucket 155: 40%
bucket 142: 60%
bucket 154: 40%
bucket 156: 40%
bucket 144: 60%
bucket 147: 50%
bucket 157: 30%
bucket 136: 90%
bucket 158: 30%
bucket 148: 50%
bucket 149: 50%
bucket 159: 30%
bucket 161: 20%
bucket 162: 20%
bucket 139: 70%
bucket 137: 80%
bucket 160: 30%
bucket 150: 50%
bucket 145: 60%
bucket 152: 50%
bucket 138: 80%
bucket 140: 70%
bucket 151: 50%
bucket 146: 60%
bucket 153: 50%
bucket 143: 60%
bucket 141: 70%
bucket 155: 50%
bucket 142: 70%
bucket 154: 50%
bucket 156: 50%
bucket 144: 70%
bucket 147: 60%
bucket 157: 40%
bucket 158: 40%
bucket 136: 100%
Sorting block of length 4326180 for bucket 136
(Using difference cover)
bucket 148: 60%
bucket 149: 60%
bucket 159: 40%
bucket 162: 30%
bucket 139: 80%
bucket 161: 30%
bucket 160: 40%
bucket 137: 90%
bucket 150: 60%
bucket 145: 70%
bucket 152: 60%
bucket 138: 90%
bucket 146: 70%
bucket 140: 80%
bucket 151: 60%
bucket 153: 60%
bucket 141: 80%
bucket 155: 60%
bucket 143: 70%
bucket 142: 80%
bucket 156: 60%
bucket 154: 60%
Sorting block time: 00:00:01
Returning block of 4326181 for bucket 136
bucket 144: 80%
Getting block 163 of 209
Reserving size (7213762) for bucket 163
Calculating Z arrays for bucket 163
Entering block accumulator loop for bucket 163:
bucket 147: 70%
bucket 158: 50%
bucket 157: 50%
bucket 148: 70%
bucket 159: 50%
bucket 149: 70%
bucket 162: 40%
bucket 139: 90%
bucket 160: 50%
bucket 161: 40%
bucket 150: 70%
bucket 145: 80%
bucket 137: 100%
Sorting block of length 7091434 for bucket 137
(Using difference cover)
bucket 152: 70%
bucket 146: 80%
bucket 138: 100%
Sorting block of length 4467895 for bucket 138
(Using difference cover)
bucket 153: 70%
bucket 151: 70%
bucket 140: 90%
bucket 155: 70%
bucket 141: 90%
bucket 156: 70%
bucket 144: 90%
bucket 154: 70%
bucket 142: 90%
bucket 143: 80%
bucket 158: 60%
bucket 147: 80%
bucket 163: 10%
bucket 157: 60%
bucket 148: 80%
bucket 159: 60%
bucket 149: 80%
bucket 160: 60%
bucket 162: 50%
bucket 139: 100%
Sorting block of length 4662248 for bucket 139
(Using difference cover)
bucket 150: 80%
bucket 145: 90%
bucket 161: 50%
bucket 152: 80%
Sorting block time: 00:00:01
Returning block of 4467896 for bucket 138
bucket 146: 90%
Getting block 164 of 209
Reserving size (7213762) for bucket 164
Calculating Z arrays for bucket 164
Entering block accumulator loop for bucket 164:
bucket 153: 80%
bucket 151: 80%
bucket 155: 80%
bucket 140: 100%
Sorting block of length 5136321 for bucket 140
(Using difference cover)
bucket 141: 100%
Sorting block of length 4490105 for bucket 141
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7091435 for bucket 137
bucket 156: 80%
bucket 144: 100%
Sorting block of length 5727088 for bucket 144
(Using difference cover)
bucket 154: 80%
bucket 158: 70%
Getting block 165 of 209
Reserving size (7213762) for bucket 165
Calculating Z arrays for bucket 165
Entering block accumulator loop for bucket 165:
bucket 147: 90%
bucket 142: 100%
Sorting block of length 6396690 for bucket 142
(Using difference cover)
bucket 157: 70%
bucket 163: 20%
bucket 148: 90%
bucket 159: 70%
bucket 149: 90%
bucket 143: 90%
bucket 160: 70%
bucket 150: 90%
bucket 162: 60%
bucket 145: 100%
Sorting block of length 6675355 for bucket 145
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4662249 for bucket 139
bucket 152: 90%
Getting block 166 of 209
Reserving size (7213762) for bucket 166
Calculating Z arrays for bucket 166
Entering block accumulator loop for bucket 166:
bucket 146: 100%
Sorting block of length 4767507 for bucket 146
(Using difference cover)
bucket 161: 60%
bucket 153: 90%
bucket 164: 10%
bucket 155: 90%
bucket 151: 90%
Sorting block time: 00:00:02
Returning block of 5136322 for bucket 140
Getting block 167 of 209
Reserving size (7213762) for bucket 167
Calculating Z arrays for bucket 167
Entering block accumulator loop for bucket 167:
bucket 156: 90%
bucket 154: 90%
Sorting block time: 00:00:01
Returning block of 4490106 for bucket 141
bucket 147: 100%
Sorting block of length 4761813 for bucket 147
(Using difference cover)
bucket 157: 80%
Getting block 168 of 209
Reserving size (7213762) for bucket 168
Calculating Z arrays for bucket 168
Entering block accumulator loop for bucket 168:
bucket 165: 10%
bucket 158: 80%
bucket 159: 80%
Sorting block time: 00:00:02
Returning block of 5727089 for bucket 144
bucket 148: 100%
Sorting block of length 2806043 for bucket 148
(Using difference cover)
bucket 163: 30%
bucket 149: 100%
Sorting block of length 6942990 for bucket 149
(Using difference cover)
Getting block 169 of 209
Reserving size (7213762) for bucket 169
Calculating Z arrays for bucket 169
Entering block accumulator loop for bucket 169:
bucket 160: 80%
bucket 150: 100%
Sorting block of length 2229767 for bucket 150
(Using difference cover)
bucket 162: 70%
bucket 152: 100%
Sorting block of length 2559294 for bucket 152
(Using difference cover)
bucket 143: 100%
Sorting block of length 6130604 for bucket 143
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6396691 for bucket 142
bucket 166: 10%
Sorting block time: 00:00:01
Returning block of 4767508 for bucket 146
bucket 153: 100%
Sorting block of length 6479149 for bucket 153
(Using difference cover)
Getting block 170 of 209
Reserving size (7213762) for bucket 170
Calculating Z arrays for bucket 170
Entering block accumulator loop for bucket 170:
bucket 161: 70%
bucket 164: 20%
bucket 155: 100%
Sorting block of length 2844822 for bucket 155
(Using difference cover)
Getting block 171 of 209
Reserving size (7213762) for bucket 171
Calculating Z arrays for bucket 171
Entering block accumulator loop for bucket 171:
bucket 151: 100%
Sorting block of length 6679353 for bucket 151
(Using difference cover)
bucket 156: 100%
Sorting block of length 6655512 for bucket 156
(Using difference cover)
Sorting block time: 00:00:00
Returning block of 2229768 for bucket 150
bucket 167: 10%
Sorting block time: 00:00:00
Returning block of 2806044 for bucket 148
Sorting block time: 00:00:02
Returning block of 6675356 for bucket 145
Getting block 172 of 209
Reserving size (7213762) for bucket 172
Calculating Z arrays for bucket 172
Entering block accumulator loop for bucket 172:
Getting block 173 of 209
Reserving size (7213762) for bucket 173
Calculating Z arrays for bucket 173
Entering block accumulator loop for bucket 173:
bucket 154: 100%
Sorting block of length 6321776 for bucket 154
(Using difference cover)
Getting block 174 of 209
Reserving size (7213762) for bucket 174
Calculating Z arrays for bucket 174
Entering block accumulator loop for bucket 174:
Sorting block time: 00:00:01
Returning block of 2559295 for bucket 152
bucket 157: 90%
bucket 158: 90%
Getting block 175 of 209
Reserving size (7213762) for bucket 175
Calculating Z arrays for bucket 175
Entering block accumulator loop for bucket 175:
bucket 165: 20%
bucket 159: 90%
bucket 168: 10%
Sorting block time: 00:00:02
Returning block of 4761814 for bucket 147
Sorting block time: 00:00:01
Returning block of 2844823 for bucket 155
Getting block 176 of 209
Reserving size (7213762) for bucket 176
Calculating Z arrays for bucket 176
Entering block accumulator loop for bucket 176:
bucket 163: 40%
Getting block 177 of 209
Reserving size (7213762) for bucket 177
Calculating Z arrays for bucket 177
Entering block accumulator loop for bucket 177:
bucket 160: 90%
bucket 169: 10%
bucket 162: 80%
bucket 170: 10%
bucket 166: 20%
bucket 164: 30%
bucket 171: 10%
bucket 161: 80%
Sorting block time: 00:00:02
Returning block of 6942991 for bucket 149
Sorting block time: 00:00:02
Returning block of 6130605 for bucket 143
Sorting block time: 00:00:02
Returning block of 6479150 for bucket 153
bucket 167: 20%
Getting block 178 of 209
Reserving size (7213762) for bucket 178
Calculating Z arrays for bucket 178
Entering block accumulator loop for bucket 178:
Getting block 179 of 209
Reserving size (7213762) for bucket 179
Calculating Z arrays for bucket 179
Entering block accumulator loop for bucket 179:
bucket 172: 10%
Getting block 180 of 209
Reserving size (7213762) for bucket 180
Calculating Z arrays for bucket 180
Entering block accumulator loop for bucket 180:
bucket 173: 10%
bucket 157: 100%
Sorting block of length 5834255 for bucket 157
(Using difference cover)
bucket 174: 10%
bucket 158: 100%
Sorting block of length 4547935 for bucket 158
(Using difference cover)
bucket 175: 10%
bucket 159: 100%
Sorting block of length 2677279 for bucket 159
(Using difference cover)
bucket 165: 30%
bucket 168: 20%
bucket 163: 50%
Sorting block time: 00:00:02
Returning block of 6679354 for bucket 151
bucket 177: 10%
bucket 176: 10%
bucket 160: 100%
Sorting block of length 5642434 for bucket 160
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6655513 for bucket 156
Getting block 181 of 209
Reserving size (7213762) for bucket 181
Calculating Z arrays for bucket 181
Entering block accumulator loop for bucket 181:
bucket 169: 20%
Sorting block time: 00:00:02
Returning block of 6321777 for bucket 154
bucket 162: 90%
Getting block 182 of 209
Reserving size (7213762) for bucket 182
Calculating Z arrays for bucket 182
Entering block accumulator loop for bucket 182:
Getting block 183 of 209
Reserving size (7213762) for bucket 183
Calculating Z arrays for bucket 183
Entering block accumulator loop for bucket 183:
bucket 170: 20%
bucket 166: 30%
bucket 164: 40%
bucket 171: 20%
bucket 161: 90%
Sorting block time: 00:00:01
Returning block of 2677280 for bucket 159
Getting block 184 of 209
Reserving size (7213762) for bucket 184
Calculating Z arrays for bucket 184
Entering block accumulator loop for bucket 184:
bucket 167: 30%
bucket 179: 10%
bucket 172: 20%
bucket 178: 10%
Sorting block time: 00:00:01
Returning block of 4547936 for bucket 158
bucket 180: 10%
bucket 174: 20%
Getting block 185 of 209
Reserving size (7213762) for bucket 185
Calculating Z arrays for bucket 185
Entering block accumulator loop for bucket 185:
bucket 175: 20%
bucket 173: 20%
bucket 165: 40%
bucket 168: 30%
Sorting block time: 00:00:02
Returning block of 5834256 for bucket 157
bucket 163: 60%
bucket 177: 20%
bucket 176: 20%
Getting block 186 of 209
Reserving size (7213762) for bucket 186
Calculating Z arrays for bucket 186
Entering block accumulator loop for bucket 186:
bucket 169: 30%
bucket 181: 10%
bucket 162: 100%
Sorting block of length 5661063 for bucket 162
(Using difference cover)
bucket 182: 10%
Sorting block time: 00:00:02
Returning block of 5642435 for bucket 160
bucket 183: 10%
bucket 170: 30%
Getting block 187 of 209
Reserving size (7213762) for bucket 187
Calculating Z arrays for bucket 187
Entering block accumulator loop for bucket 187:
bucket 164: 50%
bucket 166: 40%
bucket 171: 30%
bucket 161: 100%
Sorting block of length 4226775 for bucket 161
(Using difference cover)
bucket 184: 10%
bucket 167: 40%
bucket 179: 20%
bucket 172: 30%
bucket 178: 20%
bucket 180: 20%
bucket 174: 30%
bucket 185: 10%
bucket 175: 30%
bucket 173: 30%
bucket 165: 50%
bucket 168: 40%
bucket 163: 70%
bucket 177: 30%
bucket 186: 10%
bucket 176: 30%
bucket 169: 40%
bucket 181: 20%
bucket 182: 20%
bucket 170: 40%
bucket 183: 20%
Sorting block time: 00:00:02
Returning block of 5661064 for bucket 162
bucket 164: 60%
Sorting block time: 00:00:02
Returning block of 4226776 for bucket 161
bucket 187: 10%
bucket 166: 50%
bucket 171: 40%
Getting block 188 of 209
Reserving size (7213762) for bucket 188
Calculating Z arrays for bucket 188
Entering block accumulator loop for bucket 188:
Getting block 189 of 209
Reserving size (7213762) for bucket 189
Calculating Z arrays for bucket 189
Entering block accumulator loop for bucket 189:
bucket 184: 20%
bucket 167: 50%
bucket 179: 30%
bucket 172: 40%
bucket 178: 30%
bucket 180: 30%
bucket 174: 40%
bucket 175: 40%
bucket 185: 20%
bucket 165: 60%
bucket 163: 80%
bucket 173: 40%
bucket 168: 50%
bucket 177: 40%
bucket 186: 20%
bucket 176: 40%
bucket 169: 50%
bucket 181: 30%
bucket 170: 50%
bucket 182: 30%
bucket 183: 30%
bucket 164: 70%
bucket 188: 10%
bucket 189: 10%
bucket 171: 50%
bucket 187: 20%
bucket 166: 60%
bucket 184: 30%
bucket 167: 60%
bucket 179: 40%
bucket 172: 50%
bucket 178: 40%
bucket 174: 50%
bucket 175: 50%
bucket 180: 40%
bucket 185: 30%
bucket 165: 70%
bucket 163: 90%
bucket 177: 50%
bucket 168: 60%
bucket 173: 50%
bucket 186: 30%
bucket 169: 60%
bucket 176: 50%
bucket 170: 60%
bucket 181: 40%
bucket 182: 40%
bucket 164: 80%
bucket 188: 20%
bucket 189: 20%
bucket 183: 40%
bucket 171: 60%
bucket 166: 70%
bucket 187: 30%
bucket 184: 40%
bucket 167: 70%
bucket 179: 50%
bucket 172: 60%
bucket 175: 60%
bucket 174: 60%
bucket 185: 40%
bucket 180: 50%
bucket 178: 50%
bucket 163: 100%
Sorting block of length 5131915 for bucket 163
(Using difference cover)
bucket 165: 80%
bucket 177: 60%
bucket 168: 70%
bucket 186: 40%
bucket 173: 60%
bucket 169: 70%
bucket 170: 70%
bucket 188: 30%
bucket 189: 30%
bucket 176: 60%
bucket 181: 50%
bucket 164: 90%
bucket 182: 50%
bucket 183: 50%
bucket 171: 70%
bucket 166: 80%
bucket 187: 40%
bucket 184: 50%
bucket 167: 80%
bucket 179: 60%
bucket 172: 70%
bucket 175: 70%
bucket 185: 50%
bucket 180: 60%
bucket 178: 60%
bucket 174: 70%
bucket 165: 90%
Sorting block time: 00:00:02
Returning block of 5131916 for bucket 163
bucket 177: 70%
bucket 168: 80%
Getting block 190 of 209
Reserving size (7213762) for bucket 190
Calculating Z arrays for bucket 190
Entering block accumulator loop for bucket 190:
bucket 186: 50%
bucket 173: 70%
bucket 170: 80%
bucket 169: 80%
bucket 189: 40%
bucket 188: 40%
bucket 164: 100%
Sorting block of length 5145489 for bucket 164
(Using difference cover)
bucket 176: 70%
bucket 181: 60%
bucket 182: 60%
bucket 183: 60%
bucket 171: 80%
bucket 166: 90%
bucket 187: 50%
bucket 184: 60%
bucket 167: 90%
bucket 179: 70%
bucket 172: 80%
bucket 175: 80%
bucket 185: 60%
bucket 180: 70%
bucket 174: 80%
bucket 178: 70%
bucket 177: 80%
bucket 165: 100%
Sorting block of length 4964116 for bucket 165
(Using difference cover)
bucket 190: 10%
bucket 168: 90%
bucket 186: 60%
bucket 189: 50%
bucket 188: 50%
bucket 170: 90%
bucket 169: 90%
bucket 173: 80%
bucket 176: 80%
bucket 181: 70%
bucket 183: 70%
bucket 171: 90%
Sorting block time: 00:00:02
Returning block of 5145490 for bucket 164
bucket 182: 70%
Getting block 191 of 209
Reserving size (7213762) for bucket 191
Calculating Z arrays for bucket 191
Entering block accumulator loop for bucket 191:
bucket 166: 100%
Sorting block of length 5899099 for bucket 166
(Using difference cover)
bucket 187: 60%
bucket 167: 100%
Sorting block of length 2812792 for bucket 167
(Using difference cover)
bucket 184: 70%
bucket 179: 80%
bucket 172: 90%
bucket 175: 90%
bucket 185: 70%
bucket 180: 80%
bucket 174: 90%
bucket 190: 20%
bucket 178: 80%
bucket 177: 90%
Sorting block time: 00:00:01
Returning block of 4964117 for bucket 165
Getting block 192 of 209
Reserving size (7213762) for bucket 192
Calculating Z arrays for bucket 192
Entering block accumulator loop for bucket 192:
bucket 186: 70%
bucket 188: 60%
bucket 168: 100%
Sorting block of length 6840711 for bucket 168
(Using difference cover)
bucket 189: 60%
bucket 170: 100%
Sorting block of length 3570181 for bucket 170
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 2812793 for bucket 167
bucket 169: 100%
Sorting block of length 5827949 for bucket 169
(Using difference cover)
Getting block 193 of 209
Reserving size (7213762) for bucket 193
Calculating Z arrays for bucket 193
Entering block accumulator loop for bucket 193:
bucket 173: 90%
bucket 171: 100%
Sorting block of length 3836287 for bucket 171
(Using difference cover)
bucket 183: 80%
bucket 176: 90%
bucket 191: 10%
bucket 182: 80%
bucket 181: 80%
bucket 187: 70%
bucket 184: 80%
bucket 179: 90%
Sorting block time: 00:00:01
Returning block of 5899100 for bucket 166
Getting block 194 of 209
Reserving size (7213762) for bucket 194
Calculating Z arrays for bucket 194
Entering block accumulator loop for bucket 194:
bucket 172: 100%
Sorting block of length 5965964 for bucket 172
(Using difference cover)
bucket 175: 100%
Sorting block of length 5916690 for bucket 175
(Using difference cover)
bucket 185: 80%
bucket 190: 30%
bucket 180: 90%
bucket 174: 100%
Sorting block of length 7092445 for bucket 174
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3570182 for bucket 170
bucket 178: 90%
bucket 177: 100%
Sorting block of length 1515060 for bucket 177
(Using difference cover)
Getting block 195 of 209
Reserving size (7213762) for bucket 195
Calculating Z arrays for bucket 195
Entering block accumulator loop for bucket 195:
bucket 192: 10%
bucket 188: 70%
bucket 189: 70%
bucket 186: 80%
Sorting block time: 00:00:01
Returning block of 3836288 for bucket 171
bucket 193: 10%
Getting block 196 of 209
Reserving size (7213762) for bucket 196
Calculating Z arrays for bucket 196
Entering block accumulator loop for bucket 196:
bucket 191: 20%
Sorting block time: 00:00:00
Returning block of 1515061 for bucket 177
Getting block 197 of 209
Reserving size (7213762) for bucket 197
Calculating Z arrays for bucket 197
Entering block accumulator loop for bucket 197:
bucket 173: 100%
Sorting block of length 6011171 for bucket 173
(Using difference cover)
bucket 183: 90%
bucket 182: 90%
bucket 176: 100%
Sorting block of length 6122666 for bucket 176
(Using difference cover)
bucket 181: 90%
Sorting block time: 00:00:01
Returning block of 5827950 for bucket 169
Getting block 198 of 209
Reserving size (7213762) for bucket 198
Calculating Z arrays for bucket 198
Entering block accumulator loop for bucket 198:
Sorting block time: 00:00:02
Returning block of 6840712 for bucket 168
bucket 187: 80%
bucket 179: 100%
Sorting block of length 2352006 for bucket 179
(Using difference cover)
bucket 184: 90%
Getting block 199 of 209
Reserving size (7213762) for bucket 199
Calculating Z arrays for bucket 199
Entering block accumulator loop for bucket 199:
bucket 194: 10%
bucket 190: 40%
bucket 185: 90%
bucket 195: 10%
bucket 180: 100%
Sorting block of length 5830836 for bucket 180
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5965965 for bucket 172
bucket 192: 20%
bucket 178: 100%
Sorting block of length 6526592 for bucket 178
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 5916691 for bucket 175
bucket 188: 80%
bucket 189: 80%
Getting block 200 of 209
Reserving size (7213762) for bucket 200
Calculating Z arrays for bucket 200
Entering block accumulator loop for bucket 200:
Getting block 201 of 209
Reserving size (7213762) for bucket 201
Calculating Z arrays for bucket 201
Entering block accumulator loop for bucket 201:
bucket 186: 90%
Sorting block time: 00:00:00
Returning block of 2352007 for bucket 179
Getting block 202 of 209
Reserving size (7213762) for bucket 202
Calculating Z arrays for bucket 202
Entering block accumulator loop for bucket 202:
bucket 196: 10%
bucket 193: 20%
bucket 191: 30%
bucket 197: 10%
bucket 183: 100%
Sorting block of length 4153528 for bucket 183
(Using difference cover)
bucket 182: 100%
Sorting block of length 5843553 for bucket 182
(Using difference cover)
bucket 181: 100%
Sorting block of length 6476099 for bucket 181
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7092446 for bucket 174
bucket 198: 10%
bucket 194: 20%
bucket 184: 100%
Sorting block of length 3989724 for bucket 184
(Using difference cover)
bucket 187: 90%
Getting block 203 of 209
Reserving size (7213762) for bucket 203
Calculating Z arrays for bucket 203
Entering block accumulator loop for bucket 203:
bucket 199: 10%
Sorting block time: 00:00:02
Returning block of 6011172 for bucket 173
bucket 190: 50%
Sorting block time: 00:00:02
Returning block of 6122667 for bucket 176
bucket 185: 100%
Sorting block of length 3702181 for bucket 185
(Using difference cover)
Getting block 204 of 209
Reserving size (7213762) for bucket 204
Calculating Z arrays for bucket 204
Entering block accumulator loop for bucket 204:
Getting block 205 of 209
Reserving size (7213762) for bucket 205
Calculating Z arrays for bucket 205
Entering block accumulator loop for bucket 205:
bucket 195: 20%
bucket 192: 30%
bucket 188: 90%
bucket 189: 90%
bucket 200: 10%
bucket 201: 10%
bucket 186: 100%
Sorting block of length 4730884 for bucket 186
(Using difference cover)
bucket 196: 20%
bucket 202: 10%
Sorting block time: 00:00:02
Returning block of 5830837 for bucket 180
bucket 191: 40%
bucket 193: 30%
Getting block 206 of 209
Reserving size (7213762) for bucket 206
Calculating Z arrays for bucket 206
Entering block accumulator loop for bucket 206:
bucket 197: 20%
Sorting block time: 00:00:01
Returning block of 4153529 for bucket 183
Getting block 207 of 209
Reserving size (7213762) for bucket 207
Calculating Z arrays for bucket 207
Entering block accumulator loop for bucket 207:
Sorting block time: 00:00:02
Returning block of 6526593 for bucket 178
bucket 198: 20%
Sorting block time: 00:00:01
Returning block of 3989725 for bucket 184
Getting block 208 of 209
Reserving size (7213762) for bucket 208
Calculating Z arrays for bucket 208
Entering block accumulator loop for bucket 208:
bucket 194: 30%
bucket 203: 10%
Getting block 209 of 209
Reserving size (7213762) for bucket 209
Calculating Z arrays for bucket 209
Entering block accumulator loop for bucket 209:
bucket 199: 20%
Sorting block time: 00:00:01
Returning block of 3702182 for bucket 185
Sorting block time: 00:00:02
Returning block of 5843554 for bucket 182
bucket 187: 100%
Sorting block of length 7137358 for bucket 187
(Using difference cover)
bucket 190: 60%
Sorting block time: 00:00:02
Returning block of 6476100 for bucket 181
bucket 204: 10%
bucket 205: 10%
bucket 195: 30%
bucket 192: 40%
bucket 188: 100%
Sorting block of length 6670865 for bucket 188
(Using difference cover)
bucket 189: 100%
Sorting block of length 5594756 for bucket 189
(Using difference cover)
bucket 200: 20%
bucket 201: 20%
bucket 191: 50%
bucket 196: 30%
bucket 202: 20%
bucket 193: 40%
Sorting block time: 00:00:01
Returning block of 4730885 for bucket 186
bucket 206: 10%
bucket 197: 30%
bucket 209: 10%
bucket 207: 10%
bucket 208: 10%
bucket 198: 30%
bucket 194: 40%
bucket 203: 20%
bucket 199: 30%
bucket 190: 70%
bucket 204: 20%
bucket 205: 20%
bucket 192: 50%
bucket 195: 40%
bucket 209: 20%
bucket 200: 30%
bucket 201: 30%
bucket 191: 60%
bucket 196: 40%
bucket 202: 30%
Sorting block time: 00:00:02
Returning block of 5594757 for bucket 189
bucket 193: 50%
bucket 206: 20%
Sorting block time: 00:00:02
Returning block of 7137359 for bucket 187
bucket 197: 40%
bucket 207: 20%
Sorting block time: 00:00:02
Returning block of 6670866 for bucket 188
bucket 208: 20%
bucket 198: 40%
bucket 203: 30%
bucket 194: 50%
bucket 199: 40%
bucket 190: 80%
bucket 209: 30%
bucket 204: 30%
bucket 205: 30%
bucket 192: 60%
bucket 195: 50%
bucket 200: 40%
bucket 191: 70%
bucket 201: 40%
bucket 196: 50%
bucket 202: 40%
bucket 206: 30%
bucket 197: 50%
bucket 193: 60%
bucket 207: 30%
bucket 209: 40%
bucket 208: 30%
bucket 198: 50%
bucket 203: 40%
bucket 194: 60%
bucket 199: 50%
bucket 190: 90%
bucket 204: 40%
bucket 192: 70%
bucket 205: 40%
bucket 195: 60%
bucket 200: 50%
bucket 191: 80%
bucket 201: 50%
bucket 209: 50%
bucket 196: 60%
bucket 206: 40%
bucket 202: 50%
bucket 197: 60%
bucket 193: 70%
bucket 207: 40%
bucket 208: 40%
bucket 198: 60%
bucket 203: 50%
bucket 194: 70%
bucket 190: 100%
Sorting block of length 2077924 for bucket 190
(Using difference cover)
bucket 199: 60%
bucket 204: 50%
bucket 192: 80%
bucket 209: 60%
bucket 205: 50%
bucket 195: 70%
bucket 191: 90%
bucket 200: 60%
Sorting block time: 00:00:00
Returning block of 2077925 for bucket 190
bucket 201: 60%
bucket 196: 70%
bucket 206: 50%
bucket 202: 60%
bucket 197: 70%
bucket 193: 80%
bucket 207: 50%
bucket 208: 50%
bucket 203: 60%
bucket 198: 70%
bucket 194: 80%
bucket 209: 70%
bucket 199: 70%
bucket 204: 60%
bucket 192: 90%
bucket 205: 60%
bucket 195: 80%
bucket 191: 100%
Sorting block of length 6419136 for bucket 191
(Using difference cover)
bucket 200: 70%
bucket 201: 70%
bucket 196: 80%
bucket 206: 60%
bucket 202: 70%
bucket 209: 80%
bucket 197: 80%
bucket 193: 90%
bucket 208: 60%
bucket 207: 60%
bucket 203: 70%
bucket 198: 80%
bucket 194: 90%
bucket 199: 80%
bucket 204: 70%
bucket 192: 100%
Sorting block of length 3150475 for bucket 192
(Using difference cover)
bucket 205: 70%
bucket 195: 90%
bucket 209: 90%
bucket 200: 80%
bucket 196: 90%
bucket 206: 70%
bucket 201: 80%
bucket 202: 80%
bucket 197: 90%
bucket 208: 70%
bucket 193: 100%
Sorting block of length 6731344 for bucket 193
(Using difference cover)
bucket 207: 70%
Sorting block time: 00:00:01
Returning block of 6419137 for bucket 191
Sorting block time: 00:00:01
Returning block of 3150476 for bucket 192
bucket 203: 80%
bucket 198: 90%
bucket 194: 100%
Sorting block of length 2842999 for bucket 194
(Using difference cover)
bucket 199: 90%
bucket 204: 80%
bucket 209: 100%
Sorting block of length 6309461 for bucket 209
(Using difference cover)
bucket 205: 80%
bucket 195: 100%
Sorting block of length 5907065 for bucket 195
(Using difference cover)
bucket 200: 90%
bucket 206: 80%
bucket 196: 100%
Sorting block of length 6032705 for bucket 196
(Using difference cover)
Sorting block time: 00:00:00
Returning block of 2843000 for bucket 194
bucket 201: 90%
bucket 202: 90%
bucket 197: 100%
Sorting block of length 4540764 for bucket 197
(Using difference cover)
bucket 208: 80%
bucket 207: 80%
bucket 203: 90%
bucket 198: 100%
Sorting block of length 2884106 for bucket 198
(Using difference cover)
bucket 199: 100%
Sorting block of length 4868813 for bucket 199
(Using difference cover)
bucket 204: 90%
Sorting block time: 00:00:02
Returning block of 6731345 for bucket 193
bucket 205: 90%
bucket 200: 100%
Sorting block of length 7112534 for bucket 200
(Using difference cover)
bucket 206: 90%
Sorting block time: 00:00:02
Returning block of 6309462 for bucket 209
bucket 201: 100%
Sorting block of length 4151109 for bucket 201
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5907066 for bucket 195
Sorting block time: 00:00:01
Returning block of 2884107 for bucket 198
Sorting block time: 00:00:01
Returning block of 4540765 for bucket 197
bucket 202: 100%
Sorting block of length 6957512 for bucket 202
(Using difference cover)
bucket 207: 90%
bucket 203: 100%
Sorting block of length 5349136 for bucket 203
(Using difference cover)
bucket 208: 90%
Sorting block time: 00:00:02
Returning block of 6032706 for bucket 196
bucket 204: 100%
Sorting block of length 6037669 for bucket 204
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4868814 for bucket 199
bucket 205: 100%
Sorting block of length 5593162 for bucket 205
(Using difference cover)
bucket 206: 100%
Sorting block of length 6539622 for bucket 206
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4151110 for bucket 201
bucket 207: 100%
Sorting block of length 6965907 for bucket 207
(Using difference cover)
bucket 208: 100%
Sorting block of length 3207872 for bucket 208
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7112535 for bucket 200
Sorting block time: 00:00:02
Returning block of 5349137 for bucket 203
Sorting block time: 00:00:02
Returning block of 6957513 for bucket 202
Sorting block time: 00:00:02
Returning block of 6037670 for bucket 204
Sorting block time: 00:00:01
Returning block of 3207873 for bucket 208
Sorting block time: 00:00:02
Returning block of 5593163 for bucket 205
Sorting block time: 00:00:02
Returning block of 6539623 for bucket 206
Sorting block time: 00:00:02
Returning block of 6965908 for bucket 207
Exited Ebwt loop
fchr[A]: 0
fchr[C]: 341519526
fchr[G]: 538577822
fchr[T]: 735626959
fchr[$]: 1077255099
Exiting Ebwt::buildToDisk()
Returning from initFromVector
Wrote 371984998 bytes to primary EBWT file: Olurida_v081.1.bt2
Wrote 269313780 bytes to secondary EBWT file: Olurida_v081.2.bt2
Re-opening _in1 and _in2 as input streams
Returning from Ebwt constructor
Headers:
len: 1077255099
bwtLen: 1077255100
sz: 269313775
bwtSz: 269313775
lineRate: 6
offRate: 4
offMask: 0xfffffff0
ftabChars: 10
eftabLen: 20
eftabSz: 80
ftabLen: 1048577
ftabSz: 4194308
offsLen: 67328444
offsSz: 269313776
lineSz: 64
sideSz: 64
sideBwtSz: 48
sideBwtLen: 192
numSides: 5610704
numLines: 5610704
ebwtTotLen: 359085056
ebwtTotSz: 359085056
color: 0
reverse: 0
Total time for call to driver() for forward index: 00:02:59
Reading reference sizes
Time reading reference sizes: 00:00:07
Calculating joined length
Writing header
Reserving space for joined string
Joining reference sequences
Time to join reference sequences: 00:00:05
Time to reverse reference sequence: 00:00:01
bmax according to bmaxDivN setting: 9618349
Using parameters --bmax 7213762 --dcv 1024
Doing ahead-of-time memory usage test
Passed! Constructing with these parameters: --bmax 7213762 --dcv 1024
Constructing suffix-array element generator
Building DifferenceCoverSample
Building sPrime
Building sPrimeOrder
V-Sorting samples
V-Sorting samples time: 00:00:08
Allocating rank array
Ranking v-sort output
Ranking v-sort output time: 00:00:05
Invoking Larsson-Sadakane on ranks
Invoking Larsson-Sadakane on ranks time: 00:00:09
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 300 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 41, merged 141; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 27, merged 17; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 13, merged 18; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 4, merged 9; iterating...
Splitting and merging
Splitting and merging time: 00:00:00
Split 2, merged 0; iterating...
Avg bucket size: 5.30667e+06 (target: 7213761)
Converting suffix-array elements to index image
Allocating ftab, absorbFtab
Entering Ebwt loop
Getting block 1 of 203
Getting block 2 of 203
Reserving size (7213762) for bucket 1
Reserving size (7213762) for bucket 2
Getting block 3 of 203
Getting block 4 of 203
Getting block 5 of 203
Getting block 6 of 203
Getting block 7 of 203
Getting block 8 of 203
Getting block 9 of 203
Getting block 10 of 203
Getting block 11 of 203
Getting block 12 of 203
Calculating Z arrays for bucket 1
Getting block 13 of 203
Getting block 14 of 203
Calculating Z arrays for bucket 2
Reserving size (7213762) for bucket 3
Reserving size (7213762) for bucket 4
Reserving size (7213762) for bucket 5
Reserving size (7213762) for bucket 6
Reserving size (7213762) for bucket 7
Getting block 15 of 203
Reserving size (7213762) for bucket 8
Reserving size (7213762) for bucket 9
Reserving size (7213762) for bucket 10
Reserving size (7213762) for bucket 11
Reserving size (7213762) for bucket 12
Entering block accumulator loop for bucket 1:
Reserving size (7213762) for bucket 13
Getting block 16 of 203
Getting block 17 of 203
Reserving size (7213762) for bucket 14
Getting block 18 of 203
Getting block 19 of 203
Getting block 20 of 203
Getting block 21 of 203
Getting block 22 of 203
Getting block 23 of 203
Getting block 24 of 203
Calculating Z arrays for bucket 3
Getting block 25 of 203
Getting block 26 of 203
Entering block accumulator loop for bucket 2:
Getting block 27 of 203
Calculating Z arrays for bucket 4
Calculating Z arrays for bucket 5
Calculating Z arrays for bucket 6
Calculating Z arrays for bucket 7
Reserving size (7213762) for bucket 15
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
Reserving size (7213762) for bucket 16
Reserving size (7213762) for bucket 17
Calculating Z arrays for bucket 14
Reserving size (7213762) for bucket 18
Reserving size (7213762) for bucket 19
Reserving size (7213762) for bucket 20
Reserving size (7213762) for bucket 21
Reserving size (7213762) for bucket 22
Reserving size (7213762) for bucket 23
Reserving size (7213762) for bucket 24
Entering block accumulator loop for bucket 3:
Reserving size (7213762) for bucket 25
Reserving size (7213762) for bucket 26
Reserving size (7213762) for bucket 27
Entering block accumulator loop for bucket 4:
Entering block accumulator loop for bucket 5:
Calculating Z arrays for bucket 15
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:
Calculating Z arrays for bucket 16
Entering block accumulator loop for bucket 13:
Calculating Z arrays for bucket 17
Calculating Z arrays for bucket 18
Entering block accumulator loop for bucket 14:
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 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 20:
Entering block accumulator loop for bucket 21:
Entering block accumulator loop for bucket 19:
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 26:
Entering block accumulator loop for bucket 25:
Entering block accumulator loop for bucket 27:
bucket 1: 10%
bucket 2: 10%
bucket 3: 10%
bucket 4: 10%
bucket 8: 10%
bucket 5: 10%
bucket 6: 10%
bucket 7: 10%
bucket 12: 10%
bucket 9: 10%
bucket 10: 10%
bucket 13: 10%
bucket 14: 10%
bucket 16: 10%
bucket 20: 10%
bucket 19: 10%
bucket 18: 10%
bucket 11: 10%
bucket 17: 10%
bucket 21: 10%
bucket 23: 10%
bucket 26: 10%
bucket 25: 10%
bucket 24: 10%
bucket 27: 10%
bucket 22: 10%
bucket 15: 10%
bucket 1: 20%
bucket 2: 20%
bucket 3: 20%
bucket 4: 20%
bucket 8: 20%
bucket 5: 20%
bucket 6: 20%
bucket 7: 20%
bucket 12: 20%
bucket 9: 20%
bucket 10: 20%
bucket 19: 20%
bucket 20: 20%
bucket 14: 20%
bucket 18: 20%
bucket 16: 20%
bucket 11: 20%
bucket 17: 20%
bucket 13: 20%
bucket 21: 20%
bucket 23: 20%
bucket 25: 20%
bucket 26: 20%
bucket 15: 20%
bucket 24: 20%
bucket 22: 20%
bucket 27: 20%
bucket 1: 30%
bucket 2: 30%
bucket 3: 30%
bucket 4: 30%
bucket 8: 30%
bucket 5: 30%
bucket 6: 30%
bucket 7: 30%
bucket 12: 30%
bucket 19: 30%
bucket 9: 30%
bucket 10: 30%
bucket 20: 30%
bucket 18: 30%
bucket 14: 30%
bucket 16: 30%
bucket 11: 30%
bucket 17: 30%
bucket 21: 30%
bucket 13: 30%
bucket 23: 30%
bucket 25: 30%
bucket 26: 30%
bucket 24: 30%
bucket 15: 30%
bucket 22: 30%
bucket 27: 30%
bucket 1: 40%
bucket 3: 40%
bucket 4: 40%
bucket 2: 40%
bucket 8: 40%
bucket 5: 40%
bucket 6: 40%
bucket 7: 40%
bucket 12: 40%
bucket 19: 40%
bucket 9: 40%
bucket 10: 40%
bucket 20: 40%
bucket 18: 40%
bucket 14: 40%
bucket 11: 40%
bucket 17: 40%
bucket 16: 40%
bucket 21: 40%
bucket 1: 50%
bucket 13: 40%
bucket 23: 40%
bucket 25: 40%
bucket 15: 40%
bucket 24: 40%
bucket 26: 40%
bucket 27: 40%
bucket 22: 40%
bucket 4: 50%
bucket 3: 50%
bucket 2: 50%
bucket 8: 50%
bucket 5: 50%
bucket 6: 50%
bucket 7: 50%
bucket 12: 50%
bucket 19: 50%
bucket 9: 50%
bucket 10: 50%
bucket 18: 50%
bucket 20: 50%
bucket 14: 50%
bucket 1: 60%
bucket 11: 50%
bucket 17: 50%
bucket 16: 50%
bucket 21: 50%
bucket 23: 50%
bucket 15: 50%
bucket 13: 50%
bucket 4: 60%
bucket 3: 60%
bucket 25: 50%
bucket 24: 50%
bucket 26: 50%
bucket 2: 60%
bucket 22: 50%
bucket 27: 50%
bucket 8: 60%
bucket 5: 60%
bucket 6: 60%
bucket 7: 60%
bucket 1: 70%
bucket 12: 60%
bucket 19: 60%
bucket 9: 60%
bucket 10: 60%
bucket 18: 60%
bucket 20: 60%
bucket 14: 60%
bucket 17: 60%
bucket 11: 60%
bucket 16: 60%
bucket 21: 60%
bucket 3: 70%
bucket 4: 70%
bucket 2: 70%
bucket 15: 60%
bucket 23: 60%
bucket 13: 60%
bucket 8: 70%
bucket 25: 60%
bucket 5: 70%
bucket 24: 60%
bucket 26: 60%
bucket 6: 70%
bucket 22: 60%
bucket 27: 60%
bucket 7: 70%
bucket 1: 80%
bucket 12: 70%
bucket 19: 70%
bucket 10: 70%
bucket 9: 70%
bucket 18: 70%
bucket 20: 70%
bucket 14: 70%
bucket 17: 70%
bucket 11: 70%
bucket 16: 70%
bucket 3: 80%
bucket 4: 80%
bucket 21: 70%
bucket 2: 80%
bucket 15: 70%
bucket 8: 80%
bucket 13: 70%
bucket 23: 70%
bucket 5: 80%
bucket 6: 80%
bucket 1: 90%
bucket 25: 70%
bucket 24: 70%
bucket 26: 70%
bucket 7: 80%
bucket 22: 70%
bucket 27: 70%
bucket 12: 80%
bucket 19: 80%
bucket 10: 80%
bucket 9: 80%
bucket 18: 80%
bucket 14: 80%
bucket 20: 80%
bucket 16: 80%
bucket 17: 80%
bucket 4: 90%
bucket 3: 90%
bucket 11: 80%
bucket 2: 90%
bucket 21: 80%
bucket 8: 90%
bucket 1: 100%
Sorting block of length 3104813 for bucket 1
(Using difference cover)
bucket 5: 90%
bucket 15: 80%
bucket 13: 80%
bucket 6: 90%
bucket 23: 80%
bucket 25: 80%
bucket 7: 90%
bucket 24: 80%
bucket 26: 80%
bucket 12: 90%
bucket 19: 90%
bucket 22: 80%
bucket 27: 80%
bucket 10: 90%
bucket 9: 90%
bucket 14: 90%
bucket 18: 90%
bucket 4: 100%
Sorting block of length 4438618 for bucket 4
(Using difference cover)
bucket 3: 100%
Sorting block of length 7142543 for bucket 3
(Using difference cover)
bucket 20: 90%
bucket 16: 90%
bucket 2: 100%
Sorting block of length 6468714 for bucket 2
(Using difference cover)
bucket 17: 90%
Sorting block time: 00:00:01
Returning block of 3104814 for bucket 1
bucket 11: 90%
Getting block 28 of 203
Reserving size (7213762) for bucket 28
Calculating Z arrays for bucket 28
Entering block accumulator loop for bucket 28:
bucket 8: 100%
Sorting block of length 4622820 for bucket 8
(Using difference cover)
bucket 21: 90%
bucket 5: 100%
Sorting block of length 5316310 for bucket 5
(Using difference cover)
bucket 6: 100%
Sorting block of length 6816090 for bucket 6
(Using difference cover)
bucket 15: 90%
bucket 13: 90%
bucket 23: 90%
bucket 7: 100%
Sorting block of length 5983251 for bucket 7
(Using difference cover)
bucket 25: 90%
bucket 12: 100%
Sorting block of length 2571177 for bucket 12
(Using difference cover)
bucket 24: 90%
bucket 26: 90%
bucket 19: 100%
Sorting block of length 2260398 for bucket 19
(Using difference cover)
bucket 10: 100%
Sorting block of length 6537245 for bucket 10
(Using difference cover)
bucket 9: 100%
Sorting block of length 6600674 for bucket 9
(Using difference cover)
bucket 22: 90%
bucket 27: 90%
bucket 14: 100%
Sorting block of length 7047929 for bucket 14
(Using difference cover)
bucket 18: 100%
Sorting block of length 6955540 for bucket 18
(Using difference cover)
bucket 20: 100%
Sorting block of length 5322946 for bucket 20
(Using difference cover)
bucket 16: 100%
Sorting block of length 3934238 for bucket 16
(Using difference cover)
bucket 17: 100%
Sorting block of length 4311301 for bucket 17
(Using difference cover)
bucket 11: 100%
Sorting block of length 6806521 for bucket 11
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4438619 for bucket 4
bucket 21: 100%
Sorting block of length 6172379 for bucket 21
(Using difference cover)
bucket 28: 10%
Getting block 29 of 203
Reserving size (7213762) for bucket 29
Calculating Z arrays for bucket 29
Entering block accumulator loop for bucket 29:
bucket 15: 100%
Sorting block of length 6108609 for bucket 15
(Using difference cover)
bucket 13: 100%
Sorting block of length 5756538 for bucket 13
(Using difference cover)
Sorting block time: 00:00:00
Returning block of 2260399 for bucket 19
Getting block 30 of 203
Reserving size (7213762) for bucket 30
Calculating Z arrays for bucket 30
Entering block accumulator loop for bucket 30:
Sorting block time: 00:00:00
Returning block of 2571178 for bucket 12
bucket 23: 100%
Sorting block of length 2465720 for bucket 23
(Using difference cover)
Getting block 31 of 203
Reserving size (7213762) for bucket 31
Calculating Z arrays for bucket 31
Entering block accumulator loop for bucket 31:
bucket 25: 100%
Sorting block of length 5645569 for bucket 25
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4622821 for bucket 8
bucket 24: 100%
Sorting block of length 4777965 for bucket 24
(Using difference cover)
bucket 26: 100%
Sorting block of length 6519770 for bucket 26
(Using difference cover)
Getting block 32 of 203
Reserving size (7213762) for bucket 32
Calculating Z arrays for bucket 32
Entering block accumulator loop for bucket 32:
bucket 22: 100%
Sorting block of length 4751923 for bucket 22
(Using difference cover)
bucket 27: 100%
Sorting block of length 4333590 for bucket 27
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6468715 for bucket 2
Sorting block time: 00:00:02
Returning block of 5316311 for bucket 5
Sorting block time: 00:00:02
Returning block of 7142544 for bucket 3
Getting block 33 of 203
Reserving size (7213762) for bucket 33
Calculating Z arrays for bucket 33
Entering block accumulator loop for bucket 33:
Getting block 34 of 203
Reserving size (7213762) for bucket 34
Calculating Z arrays for bucket 34
Entering block accumulator loop for bucket 34:
Getting block 35 of 203
Reserving size (7213762) for bucket 35
Calculating Z arrays for bucket 35
Entering block accumulator loop for bucket 35:
Sorting block time: 00:00:01
Returning block of 2465721 for bucket 23
Sorting block time: 00:00:01
Returning block of 3934239 for bucket 16
bucket 28: 20%
Getting block 36 of 203
Reserving size (7213762) for bucket 36
Calculating Z arrays for bucket 36
Entering block accumulator loop for bucket 36:
bucket 29: 10%
Getting block 37 of 203
Reserving size (7213762) for bucket 37
Calculating Z arrays for bucket 37
Entering block accumulator loop for bucket 37:
bucket 30: 10%
Sorting block time: 00:00:02
Returning block of 4311302 for bucket 17
Sorting block time: 00:00:03
Returning block of 6816091 for bucket 6
Sorting block time: 00:00:03
Returning block of 5983252 for bucket 7
bucket 31: 10%
Getting block 38 of 203
Reserving size (7213762) for bucket 38
Calculating Z arrays for bucket 38
Entering block accumulator loop for bucket 38:
Getting block 39 of 203
Reserving size (7213762) for bucket 39
Calculating Z arrays for bucket 39
Entering block accumulator loop for bucket 39:
Getting block 40 of 203
Reserving size (7213762) for bucket 40
Calculating Z arrays for bucket 40
Entering block accumulator loop for bucket 40:
Sorting block time: 00:00:02
Returning block of 6537246 for bucket 10
Sorting block time: 00:00:02
Returning block of 5322947 for bucket 20
Sorting block time: 00:00:02
Returning block of 6600675 for bucket 9
Getting block 41 of 203
Reserving size (7213762) for bucket 41
Calculating Z arrays for bucket 41
Entering block accumulator loop for bucket 41:
Getting block 42 of 203
Reserving size (7213762) for bucket 42
Calculating Z arrays for bucket 42
Entering block accumulator loop for bucket 42:
bucket 32: 10%
Getting block 43 of 203
Reserving size (7213762) for bucket 43
Calculating Z arrays for bucket 43
Entering block accumulator loop for bucket 43:
Sorting block time: 00:00:02
Returning block of 7047930 for bucket 14
Sorting block time: 00:00:02
Returning block of 6955541 for bucket 18
Getting block 44 of 203
Reserving size (7213762) for bucket 44
Calculating Z arrays for bucket 44
Entering block accumulator loop for bucket 44:
Sorting block time: 00:00:02
Returning block of 5756539 for bucket 13
Sorting block time: 00:00:01
Returning block of 4777966 for bucket 24
Getting block 45 of 203
Reserving size (7213762) for bucket 45
Calculating Z arrays for bucket 45
Entering block accumulator loop for bucket 45:
Sorting block time: 00:00:02
Returning block of 6172380 for bucket 21
bucket 33: 10%
Getting block 46 of 203
Reserving size (7213762) for bucket 46
Calculating Z arrays for bucket 46
Entering block accumulator loop for bucket 46:
Getting block 47 of 203
Reserving size (7213762) for bucket 47
Calculating Z arrays for bucket 47
Entering block accumulator loop for bucket 47:
Sorting block time: 00:00:02
Returning block of 6806522 for bucket 11
bucket 34: 10%
Sorting block time: 00:00:02
Returning block of 6108610 for bucket 15
Sorting block time: 00:00:01
Returning block of 5645570 for bucket 25
Sorting block time: 00:00:01
Returning block of 4333591 for bucket 27
bucket 35: 10%
Getting block 48 of 203
Reserving size (7213762) for bucket 48
Calculating Z arrays for bucket 48
Entering block accumulator loop for bucket 48:
bucket 28: 30%
Getting block 49 of 203
Reserving size (7213762) for bucket 49
Calculating Z arrays for bucket 49
Entering block accumulator loop for bucket 49:
Getting block 50 of 203
Reserving size (7213762) for bucket 50
Calculating Z arrays for bucket 50
Entering block accumulator loop for bucket 50:
Getting block 51 of 203
Reserving size (7213762) for bucket 51
Calculating Z arrays for bucket 51
Entering block accumulator loop for bucket 51:
bucket 36: 10%
Getting block 52 of 203
Reserving size (7213762) for bucket 52
Calculating Z arrays for bucket 52
Entering block accumulator loop for bucket 52:
bucket 29: 20%
bucket 37: 10%
Sorting block time: 00:00:02
Returning block of 4751924 for bucket 22
Sorting block time: 00:00:02
Returning block of 6519771 for bucket 26
bucket 30: 20%
Getting block 53 of 203
Reserving size (7213762) for bucket 53
Calculating Z arrays for bucket 53
Entering block accumulator loop for bucket 53:
bucket 31: 20%
Getting block 54 of 203
Reserving size (7213762) for bucket 54
Calculating Z arrays for bucket 54
Entering block accumulator loop for bucket 54:
bucket 38: 10%
bucket 39: 10%
bucket 40: 10%
bucket 41: 10%
bucket 32: 20%
bucket 42: 10%
bucket 43: 10%
bucket 44: 10%
bucket 33: 20%
bucket 34: 20%
bucket 28: 40%
bucket 45: 10%
bucket 46: 10%
bucket 35: 20%
bucket 47: 10%
bucket 49: 10%
bucket 50: 10%
bucket 51: 10%
bucket 29: 30%
bucket 52: 10%
bucket 48: 10%
bucket 37: 20%
bucket 36: 20%
bucket 30: 30%
bucket 53: 10%
bucket 31: 30%
bucket 38: 20%
bucket 54: 10%
bucket 39: 20%
bucket 40: 20%
bucket 32: 30%
bucket 41: 20%
bucket 42: 20%
bucket 43: 20%
bucket 28: 50%
bucket 44: 20%
bucket 34: 30%
bucket 33: 30%
bucket 35: 30%
bucket 49: 20%
bucket 50: 20%
bucket 46: 20%
bucket 29: 40%
bucket 45: 20%
bucket 51: 20%
bucket 52: 20%
bucket 37: 30%
bucket 36: 30%
bucket 47: 20%
bucket 48: 20%
bucket 30: 40%
bucket 53: 20%
bucket 31: 40%
bucket 38: 30%
bucket 54: 20%
bucket 39: 30%
bucket 40: 30%
bucket 32: 40%
bucket 41: 30%
bucket 42: 30%
bucket 43: 30%
bucket 28: 60%
bucket 34: 40%
bucket 33: 40%
bucket 44: 30%
bucket 49: 30%
bucket 50: 30%
bucket 35: 40%
bucket 29: 50%
bucket 37: 40%
bucket 52: 30%
bucket 51: 30%
bucket 46: 30%
bucket 36: 40%
bucket 45: 30%
bucket 30: 50%
bucket 48: 30%
bucket 31: 50%
bucket 47: 30%
bucket 38: 40%
bucket 53: 30%
bucket 39: 40%
bucket 54: 30%
bucket 40: 40%
bucket 32: 50%
bucket 41: 40%
bucket 28: 70%
bucket 42: 40%
bucket 43: 40%
bucket 34: 50%
bucket 33: 50%
bucket 49: 40%
bucket 44: 40%
bucket 50: 40%
bucket 29: 60%
bucket 35: 50%
bucket 37: 50%
bucket 52: 40%
bucket 51: 40%
bucket 30: 60%
bucket 36: 50%
bucket 46: 40%
bucket 31: 60%
bucket 45: 40%
bucket 38: 50%
bucket 53: 40%
bucket 48: 40%
bucket 47: 40%
bucket 39: 50%
bucket 32: 60%
bucket 40: 50%
bucket 54: 40%
bucket 41: 50%
bucket 28: 80%
bucket 42: 50%
bucket 34: 60%
bucket 43: 50%
bucket 33: 60%
bucket 49: 50%
bucket 29: 70%
bucket 50: 50%
bucket 37: 60%
bucket 44: 50%
bucket 52: 50%
bucket 35: 60%
bucket 51: 50%
bucket 30: 70%
bucket 36: 60%
bucket 31: 70%
bucket 38: 60%
bucket 46: 50%
bucket 53: 50%
bucket 45: 50%
bucket 48: 50%
bucket 32: 70%
bucket 47: 50%
bucket 39: 60%
bucket 40: 60%
bucket 54: 50%
bucket 28: 90%
bucket 41: 60%
bucket 34: 70%
bucket 42: 60%
bucket 33: 70%
bucket 43: 60%
bucket 29: 80%
bucket 49: 60%
bucket 50: 60%
bucket 37: 70%
bucket 52: 60%
bucket 35: 70%
bucket 44: 60%
bucket 51: 60%
bucket 30: 80%
bucket 31: 80%
bucket 38: 70%
bucket 36: 70%
bucket 46: 60%
bucket 53: 60%
bucket 45: 60%
bucket 32: 80%
bucket 48: 60%
bucket 39: 70%
bucket 40: 70%
bucket 28: 100%
Sorting block of length 5307990 for bucket 28
(Using difference cover)
bucket 47: 60%
bucket 54: 60%
bucket 41: 70%
bucket 34: 80%
bucket 33: 80%
bucket 29: 90%
bucket 49: 70%
bucket 42: 70%
bucket 50: 70%
bucket 43: 70%
bucket 37: 80%
bucket 52: 70%
bucket 35: 80%
bucket 51: 70%
bucket 30: 90%
bucket 44: 70%
bucket 31: 90%
bucket 38: 80%
bucket 36: 80%
bucket 53: 70%
bucket 46: 70%
bucket 32: 90%
bucket 45: 70%
bucket 39: 80%
bucket 40: 80%
bucket 48: 70%
bucket 54: 70%
bucket 47: 70%
bucket 41: 80%
Sorting block time: 00:00:02
Returning block of 5307991 for bucket 28
Getting block 55 of 203
Reserving size (7213762) for bucket 55
Calculating Z arrays for bucket 55
Entering block accumulator loop for bucket 55:
bucket 34: 90%
bucket 29: 100%
Sorting block of length 6873965 for bucket 29
(Using difference cover)
bucket 33: 90%
bucket 49: 80%
bucket 50: 80%
bucket 37: 90%
bucket 42: 80%
bucket 52: 80%
bucket 43: 80%
bucket 30: 100%
Sorting block of length 5077374 for bucket 30
(Using difference cover)
bucket 51: 80%
bucket 35: 90%
bucket 31: 100%
Sorting block of length 6192101 for bucket 31
(Using difference cover)
bucket 38: 90%
bucket 44: 80%
bucket 36: 90%
bucket 53: 80%
bucket 32: 100%
Sorting block of length 5439103 for bucket 32
(Using difference cover)
bucket 46: 80%
bucket 39: 90%
bucket 40: 90%
bucket 45: 80%
bucket 48: 80%
bucket 54: 80%
bucket 41: 90%
bucket 47: 80%
bucket 34: 100%
Sorting block of length 2773915 for bucket 34
(Using difference cover)
bucket 55: 10%
bucket 33: 100%
Sorting block of length 6225857 for bucket 33
(Using difference cover)
bucket 49: 90%
bucket 50: 90%
bucket 37: 100%
Sorting block of length 4493730 for bucket 37
(Using difference cover)
bucket 52: 90%
bucket 42: 90%
bucket 43: 90%
bucket 51: 90%
bucket 35: 100%
Sorting block of length 7096025 for bucket 35
(Using difference cover)
bucket 38: 100%
Sorting block of length 4671740 for bucket 38
(Using difference cover)
bucket 44: 90%
bucket 36: 100%
Sorting block of length 6919013 for bucket 36
(Using difference cover)
bucket 53: 90%
Sorting block time: 00:00:02
Returning block of 5077375 for bucket 30
bucket 46: 90%
Sorting block time: 00:00:01
Returning block of 2773916 for bucket 34
Getting block 56 of 203
Reserving size (7213762) for bucket 56
Calculating Z arrays for bucket 56
Entering block accumulator loop for bucket 56:
bucket 40: 100%
Sorting block of length 4962705 for bucket 40
(Using difference cover)
bucket 39: 100%
Sorting block of length 6101734 for bucket 39
(Using difference cover)
Getting block 57 of 203
Reserving size (7213762) for bucket 57
Calculating Z arrays for bucket 57
Entering block accumulator loop for bucket 57:
bucket 45: 90%
Sorting block time: 00:00:02
Returning block of 5439104 for bucket 32
bucket 48: 90%
bucket 54: 90%
bucket 41: 100%
Sorting block of length 3408476 for bucket 41
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6873966 for bucket 29
Getting block 58 of 203
Reserving size (7213762) for bucket 58
Calculating Z arrays for bucket 58
Entering block accumulator loop for bucket 58:
Sorting block time: 00:00:02
Returning block of 6192102 for bucket 31
bucket 49: 100%
Sorting block of length 3768431 for bucket 49
(Using difference cover)
bucket 55: 20%
Getting block 59 of 203
Reserving size (7213762) for bucket 59
Calculating Z arrays for bucket 59
Entering block accumulator loop for bucket 59:
bucket 50: 100%
Sorting block of length 4801539 for bucket 50
(Using difference cover)
Getting block 60 of 203
Reserving size (7213762) for bucket 60
Calculating Z arrays for bucket 60
Entering block accumulator loop for bucket 60:
bucket 47: 90%
bucket 52: 100%
Sorting block of length 3724100 for bucket 52
(Using difference cover)
bucket 42: 100%
Sorting block of length 5691492 for bucket 42
(Using difference cover)
bucket 51: 100%
Sorting block of length 4207040 for bucket 51
(Using difference cover)
bucket 43: 100%
Sorting block of length 5664682 for bucket 43
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4493731 for bucket 37
bucket 44: 100%
Sorting block of length 6726471 for bucket 44
(Using difference cover)
Getting block 61 of 203
Reserving size (7213762) for bucket 61
Calculating Z arrays for bucket 61
Entering block accumulator loop for bucket 61:
Sorting block time: 00:00:02
Returning block of 4671741 for bucket 38
Getting block 62 of 203
Reserving size (7213762) for bucket 62
Calculating Z arrays for bucket 62
Entering block accumulator loop for bucket 62:
bucket 53: 100%
Sorting block of length 5993977 for bucket 53
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6225858 for bucket 33
Getting block 63 of 203
Reserving size (7213762) for bucket 63
Calculating Z arrays for bucket 63
Entering block accumulator loop for bucket 63:
bucket 56: 10%
bucket 46: 100%
Sorting block of length 4361879 for bucket 46
(Using difference cover)
bucket 57: 10%
Sorting block time: 00:00:01
Returning block of 3408477 for bucket 41
bucket 45: 100%
Sorting block of length 6930349 for bucket 45
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4962706 for bucket 40
bucket 54: 100%
Sorting block of length 5682134 for bucket 54
(Using difference cover)
Getting block 64 of 203
Reserving size (7213762) for bucket 64
Calculating Z arrays for bucket 64
Entering block accumulator loop for bucket 64:
Sorting block time: 00:00:01
Returning block of 3768432 for bucket 49
bucket 48: 100%
Sorting block of length 5193760 for bucket 48
(Using difference cover)
bucket 58: 10%
Getting block 65 of 203
Reserving size (7213762) for bucket 65
Calculating Z arrays for bucket 65
Entering block accumulator loop for bucket 65:
Getting block 66 of 203
Reserving size (7213762) for bucket 66
Calculating Z arrays for bucket 66
Entering block accumulator loop for bucket 66:
bucket 55: 30%
bucket 59: 10%
bucket 60: 10%
bucket 47: 100%
Sorting block of length 3197690 for bucket 47
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 3724101 for bucket 52
Sorting block time: 00:00:02
Returning block of 4801540 for bucket 50
Sorting block time: 00:00:02
Returning block of 4207041 for bucket 51
Sorting block time: 00:00:02
Returning block of 6101735 for bucket 39
Sorting block time: 00:00:03
Returning block of 7096026 for bucket 35
Getting block 67 of 203
Reserving size (7213762) for bucket 67
Calculating Z arrays for bucket 67
Entering block accumulator loop for bucket 67:
Getting block 68 of 203
Reserving size (7213762) for bucket 68
Calculating Z arrays for bucket 68
Entering block accumulator loop for bucket 68:
Getting block 69 of 203
Reserving size (7213762) for bucket 69
Calculating Z arrays for bucket 69
Entering block accumulator loop for bucket 69:
Getting block 70 of 203
Reserving size (7213762) for bucket 70
Calculating Z arrays for bucket 70
Entering block accumulator loop for bucket 70:
Getting block 71 of 203
Reserving size (7213762) for bucket 71
Calculating Z arrays for bucket 71
Entering block accumulator loop for bucket 71:
Sorting block time: 00:00:03
Returning block of 6919014 for bucket 36
bucket 61: 10%
Getting block 72 of 203
Reserving size (7213762) for bucket 72
Calculating Z arrays for bucket 72
Entering block accumulator loop for bucket 72:
bucket 62: 10%
bucket 56: 20%
bucket 63: 10%
Sorting block time: 00:00:02
Returning block of 5691493 for bucket 42
bucket 57: 20%
Getting block 73 of 203
Reserving size (7213762) for bucket 73
Calculating Z arrays for bucket 73
Entering block accumulator loop for bucket 73:
Sorting block time: 00:00:02
Returning block of 5664683 for bucket 43
Sorting block time: 00:00:02
Returning block of 5993978 for bucket 53
Getting block 74 of 203
Reserving size (7213762) for bucket 74
Calculating Z arrays for bucket 74
Entering block accumulator loop for bucket 74:
Sorting block time: 00:00:02
Returning block of 4361880 for bucket 46
bucket 58: 20%
bucket 66: 10%
bucket 55: 40%
bucket 64: 10%
Sorting block time: 00:00:01
Returning block of 3197691 for bucket 47
Getting block 75 of 203
Reserving size (7213762) for bucket 75
Calculating Z arrays for bucket 75
Entering block accumulator loop for bucket 75:
Getting block 76 of 203
Reserving size (7213762) for bucket 76
Calculating Z arrays for bucket 76
Entering block accumulator loop for bucket 76:
bucket 59: 20%
Getting block 77 of 203
Reserving size (7213762) for bucket 77
Calculating Z arrays for bucket 77
Entering block accumulator loop for bucket 77:
bucket 60: 20%
bucket 65: 10%
Sorting block time: 00:00:02
Returning block of 6726472 for bucket 44
Sorting block time: 00:00:02
Returning block of 5682135 for bucket 54
bucket 67: 10%
bucket 69: 10%
Getting block 78 of 203
Reserving size (7213762) for bucket 78
Calculating Z arrays for bucket 78
Entering block accumulator loop for bucket 78:
bucket 68: 10%
Getting block 79 of 203
Reserving size (7213762) for bucket 79
Calculating Z arrays for bucket 79
Entering block accumulator loop for bucket 79:
bucket 70: 10%
bucket 71: 10%
bucket 61: 20%
Sorting block time: 00:00:02
Returning block of 5193761 for bucket 48
Getting block 80 of 203
Reserving size (7213762) for bucket 80
Calculating Z arrays for bucket 80
Entering block accumulator loop for bucket 80:
bucket 72: 10%
bucket 62: 20%
bucket 56: 30%
bucket 57: 30%
bucket 63: 20%
Sorting block time: 00:00:03
Returning block of 6930350 for bucket 45
bucket 73: 10%
Getting block 81 of 203
Reserving size (7213762) for bucket 81
Calculating Z arrays for bucket 81
Entering block accumulator loop for bucket 81:
bucket 74: 10%
bucket 58: 30%
bucket 55: 50%
bucket 66: 20%
bucket 77: 10%
bucket 64: 20%
bucket 59: 30%
bucket 76: 10%
bucket 75: 10%
bucket 60: 30%
bucket 67: 20%
bucket 78: 10%
bucket 69: 20%
bucket 65: 20%
bucket 68: 20%
bucket 79: 10%
bucket 70: 20%
bucket 71: 20%
bucket 61: 30%
bucket 80: 10%
bucket 56: 40%
bucket 72: 20%
bucket 62: 30%
bucket 57: 40%
bucket 63: 30%
bucket 81: 10%
bucket 73: 20%
bucket 55: 60%
bucket 58: 40%
bucket 74: 20%
bucket 66: 30%
bucket 77: 20%
bucket 59: 40%
bucket 76: 20%
bucket 64: 30%
bucket 75: 20%
bucket 67: 30%
bucket 60: 40%
bucket 78: 20%
bucket 69: 30%
bucket 68: 30%
bucket 79: 20%
bucket 70: 30%
bucket 65: 30%
bucket 71: 30%
bucket 61: 40%
bucket 80: 20%
bucket 56: 50%
bucket 72: 30%
bucket 62: 40%
bucket 57: 50%
bucket 63: 40%
bucket 81: 20%
bucket 73: 30%
bucket 55: 70%
bucket 66: 40%
bucket 58: 50%
bucket 74: 30%
bucket 77: 30%
bucket 59: 50%
bucket 76: 30%
bucket 75: 30%
bucket 64: 40%
bucket 67: 40%
bucket 60: 50%
bucket 78: 30%
bucket 69: 40%
bucket 68: 40%
bucket 79: 30%
bucket 70: 40%
bucket 71: 40%
bucket 61: 50%
bucket 80: 30%
bucket 65: 40%
bucket 56: 60%
bucket 72: 40%
bucket 57: 60%
bucket 62: 50%
bucket 81: 30%
bucket 63: 50%
bucket 73: 40%
bucket 55: 80%
bucket 66: 50%
bucket 58: 60%
bucket 77: 40%
bucket 74: 40%
bucket 59: 60%
bucket 76: 40%
bucket 67: 50%
bucket 75: 40%
bucket 64: 50%
bucket 78: 40%
bucket 69: 50%
bucket 79: 40%
bucket 68: 50%
bucket 60: 60%
bucket 70: 50%
bucket 71: 50%
bucket 80: 40%
bucket 61: 60%
bucket 56: 70%
bucket 65: 50%
bucket 72: 50%
bucket 57: 70%
bucket 62: 60%
bucket 81: 40%
bucket 55: 90%
bucket 63: 60%
bucket 73: 50%
bucket 77: 50%
bucket 66: 60%
bucket 58: 70%
bucket 74: 50%
bucket 59: 70%
bucket 76: 50%
bucket 67: 60%
bucket 78: 50%
bucket 69: 60%
bucket 75: 50%
bucket 79: 50%
bucket 64: 60%
bucket 68: 60%
bucket 60: 70%
bucket 70: 60%
bucket 80: 50%
bucket 71: 60%
bucket 61: 70%
bucket 56: 80%
bucket 57: 80%
bucket 72: 60%
bucket 81: 50%
bucket 65: 60%
bucket 62: 70%
bucket 55: 100%
Sorting block of length 6731640 for bucket 55
(Using difference cover)
bucket 77: 60%
bucket 66: 70%
bucket 73: 60%
bucket 63: 70%
bucket 58: 80%
bucket 74: 60%
bucket 59: 80%
bucket 67: 70%
bucket 76: 60%
bucket 78: 60%
bucket 69: 70%
bucket 79: 60%
bucket 68: 70%
bucket 75: 60%
bucket 64: 70%
bucket 60: 80%
bucket 70: 70%
bucket 80: 60%
bucket 71: 70%
bucket 56: 90%
bucket 61: 80%
bucket 57: 90%
bucket 72: 70%
bucket 81: 60%
bucket 62: 80%
bucket 77: 70%
bucket 65: 70%
bucket 66: 80%
bucket 58: 90%
bucket 74: 70%
bucket 63: 80%
bucket 67: 80%
bucket 76: 70%
bucket 73: 70%
bucket 59: 90%
bucket 78: 70%
bucket 69: 80%
bucket 79: 70%
bucket 68: 80%
bucket 64: 80%
Sorting block time: 00:00:02
Returning block of 6731641 for bucket 55
bucket 60: 90%
bucket 75: 70%
bucket 80: 70%
Getting block 82 of 203
Reserving size (7213762) for bucket 82
Calculating Z arrays for bucket 82
Entering block accumulator loop for bucket 82:
bucket 70: 80%
bucket 56: 100%
Sorting block of length 4022081 for bucket 56
(Using difference cover)
bucket 61: 90%
bucket 71: 80%
bucket 57: 100%
Sorting block of length 5922778 for bucket 57
(Using difference cover)
bucket 72: 80%
bucket 81: 70%
bucket 77: 80%
bucket 62: 90%
bucket 66: 90%
bucket 74: 80%
bucket 65: 80%
bucket 58: 100%
Sorting block of length 7096566 for bucket 58
(Using difference cover)
bucket 67: 90%
bucket 63: 90%
bucket 76: 80%
bucket 78: 80%
bucket 69: 90%
bucket 59: 100%
Sorting block of length 2943018 for bucket 59
(Using difference cover)
bucket 79: 80%
bucket 68: 90%
bucket 73: 80%
bucket 64: 90%
bucket 80: 80%
Sorting block time: 00:00:01
Returning block of 4022082 for bucket 56
bucket 82: 10%
bucket 60: 100%
Sorting block of length 6575273 for bucket 60
(Using difference cover)
bucket 70: 90%
bucket 75: 80%
Getting block 83 of 203
Reserving size (7213762) for bucket 83
Calculating Z arrays for bucket 83
Entering block accumulator loop for bucket 83:
bucket 61: 100%
Sorting block of length 4432744 for bucket 61
(Using difference cover)
bucket 71: 90%
bucket 81: 80%
bucket 72: 90%
bucket 77: 90%
Sorting block time: 00:00:01
Returning block of 2943019 for bucket 59
Getting block 84 of 203
Reserving size (7213762) for bucket 84
Calculating Z arrays for bucket 84
Entering block accumulator loop for bucket 84:
bucket 66: 100%
Sorting block of length 6603666 for bucket 66
(Using difference cover)
bucket 62: 100%
Sorting block of length 6723578 for bucket 62
(Using difference cover)
bucket 67: 100%
Sorting block of length 4696820 for bucket 67
(Using difference cover)
bucket 74: 90%
bucket 78: 90%
bucket 69: 100%
Sorting block of length 6682231 for bucket 69
(Using difference cover)
bucket 63: 100%
Sorting block of length 5439415 for bucket 63
(Using difference cover)
bucket 76: 90%
Sorting block time: 00:00:02
Returning block of 5922779 for bucket 57
bucket 65: 90%
bucket 79: 90%
bucket 68: 100%
Sorting block of length 6257443 for bucket 68
(Using difference cover)
Getting block 85 of 203
Reserving size (7213762) for bucket 85
Calculating Z arrays for bucket 85
Entering block accumulator loop for bucket 85:
bucket 73: 90%
bucket 80: 90%
bucket 82: 20%
bucket 64: 100%
Sorting block of length 5916501 for bucket 64
(Using difference cover)
bucket 70: 100%
Sorting block of length 5457166 for bucket 70
(Using difference cover)
bucket 75: 90%
bucket 83: 10%
bucket 71: 100%
Sorting block of length 7084045 for bucket 71
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4432745 for bucket 61
Getting block 86 of 203
Reserving size (7213762) for bucket 86
Calculating Z arrays for bucket 86
Entering block accumulator loop for bucket 86:
bucket 81: 90%
Sorting block time: 00:00:02
Returning block of 7096567 for bucket 58
bucket 77: 100%
Sorting block of length 5691928 for bucket 77
(Using difference cover)
bucket 72: 100%
Sorting block of length 5030927 for bucket 72
(Using difference cover)
Getting block 87 of 203
Reserving size (7213762) for bucket 87
Calculating Z arrays for bucket 87
Entering block accumulator loop for bucket 87:
bucket 84: 10%
bucket 74: 100%
Sorting block of length 2634665 for bucket 74
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6575274 for bucket 60
bucket 78: 100%
Sorting block of length 6068536 for bucket 78
(Using difference cover)
bucket 79: 100%
Sorting block of length 5132748 for bucket 79
(Using difference cover)
bucket 76: 100%
Sorting block of length 7114623 for bucket 76
(Using difference cover)
Getting block 88 of 203
Reserving size (7213762) for bucket 88
Calculating Z arrays for bucket 88
Entering block accumulator loop for bucket 88:
Sorting block time: 00:00:01
Returning block of 4696821 for bucket 67
bucket 65: 100%
Sorting block of length 6510151 for bucket 65
(Using difference cover)
Getting block 89 of 203
Reserving size (7213762) for bucket 89
Calculating Z arrays for bucket 89
Entering block accumulator loop for bucket 89:
bucket 85: 10%
bucket 80: 100%
Sorting block of length 3888893 for bucket 80
(Using difference cover)
bucket 73: 100%
Sorting block of length 4595158 for bucket 73
(Using difference cover)
bucket 82: 30%
bucket 75: 100%
Sorting block of length 5334395 for bucket 75
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5439416 for bucket 63
bucket 83: 20%
Sorting block time: 00:00:02
Returning block of 6603667 for bucket 66
Sorting block time: 00:00:02
Returning block of 6723579 for bucket 62
Sorting block time: 00:00:01
Returning block of 2634666 for bucket 74
Getting block 90 of 203
Reserving size (7213762) for bucket 90
Calculating Z arrays for bucket 90
Entering block accumulator loop for bucket 90:
Getting block 91 of 203
Reserving size (7213762) for bucket 91
Calculating Z arrays for bucket 91
Entering block accumulator loop for bucket 91:
Sorting block time: 00:00:02
Returning block of 6682232 for bucket 69
bucket 81: 100%
Sorting block of length 4700942 for bucket 81
(Using difference cover)
Getting block 92 of 203
Reserving size (7213762) for bucket 92
Calculating Z arrays for bucket 92
Entering block accumulator loop for bucket 92:
Sorting block time: 00:00:02
Returning block of 6257444 for bucket 68
bucket 86: 10%
Getting block 93 of 203
Reserving size (7213762) for bucket 93
Calculating Z arrays for bucket 93
Entering block accumulator loop for bucket 93:
Getting block 94 of 203
Reserving size (7213762) for bucket 94
Calculating Z arrays for bucket 94
Entering block accumulator loop for bucket 94:
Getting block 95 of 203
Reserving size (7213762) for bucket 95
Calculating Z arrays for bucket 95
Entering block accumulator loop for bucket 95:
Sorting block time: 00:00:01
Returning block of 5457167 for bucket 70
Sorting block time: 00:00:02
Returning block of 5916502 for bucket 64
bucket 87: 10%
bucket 84: 20%
Getting block 96 of 203
Reserving size (7213762) for bucket 96
Calculating Z arrays for bucket 96
Entering block accumulator loop for bucket 96:
Getting block 97 of 203
Reserving size (7213762) for bucket 97
Calculating Z arrays for bucket 97
Entering block accumulator loop for bucket 97:
Sorting block time: 00:00:01
Returning block of 5030928 for bucket 72
Getting block 98 of 203
Reserving size (7213762) for bucket 98
Calculating Z arrays for bucket 98
Entering block accumulator loop for bucket 98:
Sorting block time: 00:00:02
Returning block of 5691929 for bucket 77
bucket 88: 10%
Sorting block time: 00:00:01
Returning block of 3888894 for bucket 80
bucket 89: 10%
Getting block 99 of 203
Reserving size (7213762) for bucket 99
Calculating Z arrays for bucket 99
Entering block accumulator loop for bucket 99:
bucket 85: 20%
Sorting block time: 00:00:02
Returning block of 7084046 for bucket 71
Getting block 100 of 203
Reserving size (7213762) for bucket 100
Calculating Z arrays for bucket 100
Entering block accumulator loop for bucket 100:
bucket 82: 40%
Sorting block time: 00:00:02
Returning block of 5132749 for bucket 79
Getting block 101 of 203
Reserving size (7213762) for bucket 101
Calculating Z arrays for bucket 101
Entering block accumulator loop for bucket 101:
Getting block 102 of 203
Reserving size (7213762) for bucket 102
Calculating Z arrays for bucket 102
Entering block accumulator loop for bucket 102:
Sorting block time: 00:00:02
Returning block of 6068537 for bucket 78
Sorting block time: 00:00:01
Returning block of 4595159 for bucket 73
bucket 83: 30%
Getting block 103 of 203
Reserving size (7213762) for bucket 103
Calculating Z arrays for bucket 103
Entering block accumulator loop for bucket 103:
Getting block 104 of 203
Reserving size (7213762) for bucket 104
Calculating Z arrays for bucket 104
Entering block accumulator loop for bucket 104:
bucket 91: 10%
bucket 90: 10%
bucket 86: 20%
Sorting block time: 00:00:01
Returning block of 4700943 for bucket 81
Sorting block time: 00:00:02
Returning block of 7114624 for bucket 76
bucket 92: 10%
bucket 93: 10%
Getting block 105 of 203
Reserving size (7213762) for bucket 105
Calculating Z arrays for bucket 105
Entering block accumulator loop for bucket 105:
bucket 94: 10%
Sorting block time: 00:00:02
Returning block of 5334396 for bucket 75
bucket 95: 10%
Getting block 106 of 203
Reserving size (7213762) for bucket 106
Calculating Z arrays for bucket 106
Entering block accumulator loop for bucket 106:
Sorting block time: 00:00:03
Returning block of 6510152 for bucket 65
bucket 87: 20%
bucket 84: 30%
Getting block 107 of 203
Reserving size (7213762) for bucket 107
Calculating Z arrays for bucket 107
Entering block accumulator loop for bucket 107:
Getting block 108 of 203
Reserving size (7213762) for bucket 108
Calculating Z arrays for bucket 108
Entering block accumulator loop for bucket 108:
bucket 96: 10%
bucket 97: 10%
bucket 98: 10%
bucket 88: 20%
bucket 82: 50%
bucket 89: 20%
bucket 85: 30%
bucket 99: 10%
bucket 100: 10%
bucket 102: 10%
bucket 83: 40%
bucket 101: 10%
bucket 103: 10%
bucket 104: 10%
bucket 91: 20%
bucket 86: 30%
bucket 90: 20%
bucket 92: 20%
bucket 93: 20%
bucket 94: 20%
bucket 105: 10%
bucket 106: 10%
bucket 87: 30%
bucket 95: 20%
bucket 84: 40%
bucket 107: 10%
bucket 108: 10%
bucket 96: 20%
bucket 97: 20%
bucket 88: 30%
bucket 82: 60%
bucket 98: 20%
bucket 85: 40%
bucket 89: 30%
bucket 99: 20%
bucket 100: 20%
bucket 102: 20%
bucket 83: 50%
bucket 103: 20%
bucket 104: 20%
bucket 101: 20%
bucket 91: 30%
bucket 86: 40%
bucket 90: 30%
bucket 93: 30%
bucket 92: 30%
bucket 94: 30%
bucket 106: 20%
bucket 87: 40%
bucket 105: 20%
bucket 84: 50%
bucket 95: 30%
bucket 108: 20%
bucket 107: 20%
bucket 82: 70%
bucket 97: 30%
bucket 88: 40%
bucket 96: 30%
bucket 98: 30%
bucket 85: 50%
bucket 89: 40%
bucket 99: 30%
bucket 102: 30%
bucket 100: 30%
bucket 83: 60%
bucket 103: 30%
bucket 104: 30%
bucket 86: 50%
bucket 91: 40%
bucket 90: 40%
bucket 93: 40%
bucket 87: 50%
bucket 106: 30%
bucket 92: 40%
bucket 94: 40%
bucket 84: 60%
bucket 101: 30%
bucket 105: 30%
bucket 95: 40%
bucket 82: 80%
bucket 108: 30%
bucket 107: 30%
bucket 88: 50%
bucket 85: 60%
bucket 97: 40%
bucket 89: 50%
bucket 98: 40%
bucket 96: 40%
bucket 102: 40%
bucket 99: 40%
bucket 83: 70%
bucket 100: 40%
bucket 103: 40%
bucket 104: 40%
bucket 86: 60%
bucket 91: 50%
bucket 90: 50%
bucket 87: 60%
bucket 93: 50%
bucket 106: 40%
bucket 84: 70%
bucket 94: 50%
bucket 82: 90%
bucket 92: 50%
bucket 105: 40%
bucket 95: 50%
bucket 108: 40%
bucket 101: 40%
bucket 107: 40%
bucket 88: 60%
bucket 85: 70%
bucket 89: 60%
bucket 97: 50%
bucket 98: 50%
bucket 96: 50%
bucket 102: 50%
bucket 83: 80%
bucket 99: 50%
bucket 100: 50%
bucket 103: 50%
bucket 104: 50%
bucket 86: 70%
bucket 91: 60%
bucket 82: 100%
Sorting block of length 5307465 for bucket 82
(Using difference cover)
bucket 87: 70%
bucket 90: 60%
bucket 84: 80%
bucket 106: 50%
bucket 93: 60%
bucket 94: 60%
bucket 92: 60%
bucket 105: 50%
bucket 108: 50%
bucket 95: 60%
bucket 85: 80%
bucket 107: 50%
bucket 88: 70%
bucket 89: 70%
bucket 101: 50%
bucket 97: 60%
bucket 98: 60%
bucket 96: 60%
bucket 102: 60%
bucket 83: 90%
bucket 99: 60%
bucket 103: 60%
bucket 100: 60%
bucket 86: 80%
bucket 104: 60%
bucket 87: 80%
bucket 91: 70%
bucket 84: 90%
bucket 90: 70%
bucket 106: 60%
bucket 93: 70%
Sorting block time: 00:00:02
Returning block of 5307466 for bucket 82
bucket 94: 70%
Getting block 109 of 203
Reserving size (7213762) for bucket 109
Calculating Z arrays for bucket 109
Entering block accumulator loop for bucket 109:
bucket 92: 70%
bucket 105: 60%
bucket 108: 60%
bucket 85: 90%
bucket 95: 70%
bucket 88: 80%
bucket 107: 60%
bucket 89: 80%
bucket 98: 70%
bucket 97: 70%
bucket 101: 60%
bucket 96: 70%
bucket 102: 70%
bucket 83: 100%
Sorting block of length 6412791 for bucket 83
(Using difference cover)
bucket 99: 70%
bucket 103: 70%
bucket 86: 90%
bucket 100: 70%
bucket 104: 70%
bucket 87: 90%
bucket 84: 100%
Sorting block of length 5554205 for bucket 84
(Using difference cover)
bucket 91: 80%
bucket 106: 70%
bucket 90: 80%
bucket 93: 80%
bucket 94: 80%
bucket 109: 10%
bucket 105: 70%
bucket 92: 80%
bucket 108: 70%
bucket 85: 100%
Sorting block of length 2960433 for bucket 85
(Using difference cover)
bucket 88: 90%
bucket 95: 80%
bucket 89: 90%
bucket 107: 70%
bucket 98: 80%
bucket 97: 80%
bucket 102: 80%
bucket 96: 80%
bucket 101: 70%
bucket 103: 80%
bucket 99: 80%
Sorting block time: 00:00:01
Returning block of 2960434 for bucket 85
bucket 86: 100%
Sorting block of length 5982259 for bucket 86
(Using difference cover)
Getting block 110 of 203
Reserving size (7213762) for bucket 110
Calculating Z arrays for bucket 110
Entering block accumulator loop for bucket 110:
bucket 104: 80%
bucket 87: 100%
Sorting block of length 3185617 for bucket 87
(Using difference cover)
bucket 100: 80%
bucket 106: 80%
Sorting block time: 00:00:02
Returning block of 6412792 for bucket 83
bucket 91: 90%
bucket 90: 90%
bucket 93: 90%
bucket 94: 90%
Getting block 111 of 203
Reserving size (7213762) for bucket 111
Calculating Z arrays for bucket 111
Entering block accumulator loop for bucket 111:
bucket 109: 20%
Sorting block time: 00:00:01
Returning block of 5554206 for bucket 84
bucket 105: 80%
bucket 92: 90%
bucket 108: 80%
Getting block 112 of 203
Reserving size (7213762) for bucket 112
Calculating Z arrays for bucket 112
Entering block accumulator loop for bucket 112:
bucket 88: 100%
Sorting block of length 5376269 for bucket 88
(Using difference cover)
bucket 89: 100%
Sorting block of length 3514943 for bucket 89
(Using difference cover)
bucket 95: 90%
bucket 107: 80%
bucket 98: 90%
bucket 97: 90%
bucket 102: 90%
Sorting block time: 00:00:01
Returning block of 3185618 for bucket 87
bucket 96: 90%
Getting block 113 of 203
Reserving size (7213762) for bucket 113
Calculating Z arrays for bucket 113
Entering block accumulator loop for bucket 113:
bucket 103: 90%
bucket 101: 80%
bucket 99: 90%
bucket 110: 10%
bucket 104: 90%
bucket 106: 90%
bucket 100: 90%
bucket 90: 100%
Sorting block of length 6389911 for bucket 90
(Using difference cover)
bucket 91: 100%
Sorting block of length 6702921 for bucket 91
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3514944 for bucket 89
bucket 93: 100%
Sorting block of length 4695887 for bucket 93
(Using difference cover)
bucket 94: 100%
Sorting block of length 5986451 for bucket 94
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5982260 for bucket 86
Getting block 114 of 203
Reserving size (7213762) for bucket 114
Calculating Z arrays for bucket 114
Entering block accumulator loop for bucket 114:
bucket 109: 30%
bucket 111: 10%
bucket 105: 90%
bucket 108: 90%
Getting block 115 of 203
Reserving size (7213762) for bucket 115
Calculating Z arrays for bucket 115
Entering block accumulator loop for bucket 115:
bucket 92: 100%
Sorting block of length 7109570 for bucket 92
(Using difference cover)
bucket 112: 10%
bucket 95: 100%
Sorting block of length 5348195 for bucket 95
(Using difference cover)
bucket 107: 90%
Sorting block time: 00:00:01
Returning block of 5376270 for bucket 88
Getting block 116 of 203
Reserving size (7213762) for bucket 116
Calculating Z arrays for bucket 116
Entering block accumulator loop for bucket 116:
bucket 98: 100%
Sorting block of length 3647029 for bucket 98
(Using difference cover)
bucket 102: 100%
Sorting block of length 4440959 for bucket 102
(Using difference cover)
bucket 97: 100%
Sorting block of length 6736724 for bucket 97
(Using difference cover)
bucket 113: 10%
bucket 96: 100%
Sorting block of length 6758096 for bucket 96
(Using difference cover)
bucket 103: 100%
Sorting block of length 6351041 for bucket 103
(Using difference cover)
bucket 110: 20%
bucket 99: 100%
Sorting block of length 5638683 for bucket 99
(Using difference cover)
bucket 104: 100%
Sorting block of length 6342602 for bucket 104
(Using difference cover)
bucket 106: 100%
Sorting block of length 3691882 for bucket 106
(Using difference cover)
bucket 101: 90%
bucket 100: 100%
Sorting block of length 5632831 for bucket 100
(Using difference cover)
bucket 114: 10%
bucket 109: 40%
bucket 108: 100%
Sorting block of length 6504372 for bucket 108
(Using difference cover)
bucket 111: 20%
Sorting block time: 00:00:01
Returning block of 4695888 for bucket 93
bucket 115: 10%
bucket 105: 100%
Sorting block of length 5356934 for bucket 105
(Using difference cover)
Getting block 117 of 203
Reserving size (7213762) for bucket 117
Calculating Z arrays for bucket 117
Entering block accumulator loop for bucket 117:
bucket 112: 20%
Sorting block time: 00:00:01
Returning block of 3647030 for bucket 98
Sorting block time: 00:00:01
Returning block of 5986452 for bucket 94
bucket 107: 100%
Sorting block of length 6953328 for bucket 107
(Using difference cover)
Getting block 118 of 203
Reserving size (7213762) for bucket 118
Calculating Z arrays for bucket 118
Entering block accumulator loop for bucket 118:
bucket 116: 10%
Sorting block time: 00:00:02
Returning block of 6702922 for bucket 91
Getting block 119 of 203
Reserving size (7213762) for bucket 119
Calculating Z arrays for bucket 119
Entering block accumulator loop for bucket 119:
Sorting block time: 00:00:02
Returning block of 5348196 for bucket 95
Getting block 120 of 203
Reserving size (7213762) for bucket 120
Calculating Z arrays for bucket 120
Entering block accumulator loop for bucket 120:
Sorting block time: 00:00:02
Returning block of 6389912 for bucket 90
Sorting block time: 00:00:02
Returning block of 4440960 for bucket 102
bucket 113: 20%
Getting block 121 of 203
Reserving size (7213762) for bucket 121
Calculating Z arrays for bucket 121
Entering block accumulator loop for bucket 121:
Getting block 122 of 203
Reserving size (7213762) for bucket 122
Calculating Z arrays for bucket 122
Entering block accumulator loop for bucket 122:
Getting block 123 of 203
Reserving size (7213762) for bucket 123
Calculating Z arrays for bucket 123
Entering block accumulator loop for bucket 123:
Sorting block time: 00:00:01
Returning block of 3691883 for bucket 106
Getting block 124 of 203
Reserving size (7213762) for bucket 124
Calculating Z arrays for bucket 124
Entering block accumulator loop for bucket 124:
bucket 110: 30%
Sorting block time: 00:00:02
Returning block of 7109571 for bucket 92
Getting block 125 of 203
Reserving size (7213762) for bucket 125
Calculating Z arrays for bucket 125
Entering block accumulator loop for bucket 125:
bucket 114: 20%
Sorting block time: 00:00:02
Returning block of 6736725 for bucket 97
bucket 101: 100%
Sorting block of length 3716886 for bucket 101
(Using difference cover)
bucket 111: 30%
bucket 109: 50%
bucket 115: 20%
Sorting block time: 00:00:01
Returning block of 5638684 for bucket 99
Sorting block time: 00:00:01
Returning block of 6351042 for bucket 103
bucket 117: 10%
bucket 112: 30%
Getting block 126 of 203
Reserving size (7213762) for bucket 126
Calculating Z arrays for bucket 126
Entering block accumulator loop for bucket 126:
Sorting block time: 00:00:03
Returning block of 6758097 for bucket 96
Sorting block time: 00:00:02
Returning block of 5632832 for bucket 100
Getting block 127 of 203
Reserving size (7213762) for bucket 127
Calculating Z arrays for bucket 127
Entering block accumulator loop for bucket 127:
Getting block 128 of 203
Reserving size (7213762) for bucket 128
Calculating Z arrays for bucket 128
Entering block accumulator loop for bucket 128:
Getting block 129 of 203
Reserving size (7213762) for bucket 129
Calculating Z arrays for bucket 129
Entering block accumulator loop for bucket 129:
Sorting block time: 00:00:02
Returning block of 5356935 for bucket 105
bucket 118: 10%
Sorting block time: 00:00:02
Returning block of 6342603 for bucket 104
Getting block 130 of 203
Reserving size (7213762) for bucket 130
Calculating Z arrays for bucket 130
Entering block accumulator loop for bucket 130:
Getting block 131 of 203
Reserving size (7213762) for bucket 131
Calculating Z arrays for bucket 131
Entering block accumulator loop for bucket 131:
bucket 116: 20%
Getting block 132 of 203
Reserving size (7213762) for bucket 132
Calculating Z arrays for bucket 132
Entering block accumulator loop for bucket 132:
bucket 119: 10%
Sorting block time: 00:00:02
Returning block of 6504373 for bucket 108
bucket 120: 10%
bucket 121: 10%
Getting block 133 of 203
Reserving size (7213762) for bucket 133
Calculating Z arrays for bucket 133
Entering block accumulator loop for bucket 133:
bucket 113: 30%
bucket 122: 10%
bucket 123: 10%
bucket 124: 10%
bucket 110: 40%
Sorting block time: 00:00:02
Returning block of 3716887 for bucket 101
Getting block 134 of 203
Reserving size (7213762) for bucket 134
Calculating Z arrays for bucket 134
Entering block accumulator loop for bucket 134:
Sorting block time: 00:00:03
Returning block of 6953329 for bucket 107
bucket 114: 30%
bucket 125: 10%
bucket 109: 60%
bucket 111: 40%
Getting block 135 of 203
Reserving size (7213762) for bucket 135
Calculating Z arrays for bucket 135
Entering block accumulator loop for bucket 135:
bucket 115: 30%
bucket 117: 20%
bucket 112: 40%
bucket 126: 10%
bucket 127: 10%
bucket 118: 20%
bucket 128: 10%
bucket 129: 10%
bucket 130: 10%
bucket 116: 30%
bucket 119: 20%
bucket 132: 10%
bucket 120: 20%
bucket 131: 10%
bucket 121: 20%
bucket 122: 20%
bucket 113: 40%
bucket 133: 10%
bucket 123: 20%
bucket 110: 50%
bucket 124: 20%
bucket 114: 40%
bucket 109: 70%
bucket 134: 10%
bucket 125: 20%
bucket 111: 50%
bucket 117: 30%
bucket 115: 40%
bucket 112: 50%
bucket 135: 10%
bucket 126: 20%
bucket 118: 30%
bucket 127: 20%
bucket 128: 20%
bucket 129: 20%
bucket 130: 20%
bucket 119: 30%
bucket 116: 40%
bucket 132: 20%
bucket 120: 30%
bucket 131: 20%
bucket 121: 30%
bucket 122: 30%
bucket 113: 50%
bucket 133: 20%
bucket 110: 60%
bucket 123: 30%
bucket 124: 30%
bucket 114: 50%
bucket 109: 80%
bucket 117: 40%
bucket 112: 60%
bucket 111: 60%
bucket 125: 30%
bucket 134: 20%
bucket 115: 50%
bucket 135: 20%
bucket 118: 40%
bucket 126: 30%
bucket 127: 30%
bucket 119: 40%
bucket 128: 30%
bucket 129: 30%
bucket 130: 30%
bucket 116: 50%
bucket 120: 40%
bucket 132: 30%
bucket 121: 40%
bucket 131: 30%
bucket 122: 40%
bucket 113: 60%
bucket 133: 30%
bucket 110: 70%
bucket 123: 40%
bucket 124: 40%
bucket 109: 90%
bucket 114: 60%
bucket 117: 50%
bucket 112: 70%
bucket 111: 70%
bucket 115: 60%
bucket 125: 40%
bucket 134: 30%
bucket 118: 50%
bucket 135: 30%
bucket 126: 40%
bucket 119: 50%
bucket 120: 50%
bucket 127: 40%
bucket 116: 60%
bucket 128: 40%
bucket 129: 40%
bucket 130: 40%
bucket 132: 40%
bucket 121: 50%
bucket 122: 50%
bucket 113: 70%
bucket 131: 40%
bucket 110: 80%
bucket 133: 40%
bucket 123: 50%
bucket 109: 100%
Sorting block of length 7063691 for bucket 109
(Using difference cover)
bucket 114: 70%
bucket 124: 50%
bucket 117: 60%
bucket 112: 80%
bucket 111: 80%
bucket 115: 70%
bucket 118: 60%
bucket 125: 50%
bucket 134: 40%
bucket 135: 40%
bucket 126: 50%
bucket 119: 60%
bucket 120: 60%
bucket 116: 70%
bucket 127: 50%
bucket 130: 50%
bucket 128: 50%
bucket 129: 50%
bucket 121: 60%
bucket 132: 50%
bucket 122: 60%
bucket 113: 80%
bucket 131: 50%
bucket 110: 90%
bucket 133: 50%
bucket 117: 70%
bucket 114: 80%
bucket 123: 60%
bucket 112: 90%
bucket 124: 60%
bucket 115: 80%
bucket 111: 90%
bucket 118: 70%
bucket 125: 60%
bucket 134: 50%
bucket 119: 70%
bucket 120: 70%
bucket 126: 60%
bucket 135: 50%
bucket 116: 80%
bucket 121: 70%
bucket 127: 60%
bucket 130: 60%
bucket 132: 60%
bucket 128: 60%
bucket 122: 70%
Sorting block time: 00:00:02
Returning block of 7063692 for bucket 109
bucket 113: 90%
bucket 129: 60%
Getting block 136 of 203
Reserving size (7213762) for bucket 136
Calculating Z arrays for bucket 136
Entering block accumulator loop for bucket 136:
bucket 131: 60%
bucket 110: 100%
Sorting block of length 4947745 for bucket 110
(Using difference cover)
bucket 133: 60%
bucket 114: 90%
bucket 112: 100%
Sorting block of length 2451937 for bucket 112
(Using difference cover)
bucket 117: 80%
bucket 123: 70%
bucket 118: 80%
bucket 124: 70%
bucket 115: 90%
bucket 111: 100%
Sorting block of length 5215155 for bucket 111
(Using difference cover)
bucket 125: 70%
bucket 120: 80%
bucket 119: 80%
bucket 134: 60%
bucket 126: 70%
bucket 116: 90%
Sorting block time: 00:00:00
Returning block of 2451938 for bucket 112
bucket 135: 60%
Getting block 137 of 203
Reserving size (7213762) for bucket 137
Calculating Z arrays for bucket 137
Entering block accumulator loop for bucket 137:
bucket 130: 70%
bucket 132: 70%
bucket 127: 70%
bucket 128: 70%
bucket 121: 80%
bucket 122: 80%
bucket 113: 100%
Sorting block of length 7205857 for bucket 113
(Using difference cover)
bucket 136: 10%
bucket 129: 70%
bucket 131: 70%
Sorting block time: 00:00:01
Returning block of 4947746 for bucket 110
bucket 133: 70%
bucket 114: 100%
Sorting block of length 5873268 for bucket 114
(Using difference cover)
Getting block 138 of 203
Reserving size (7213762) for bucket 138
Calculating Z arrays for bucket 138
Entering block accumulator loop for bucket 138:
bucket 117: 90%
bucket 118: 90%
bucket 123: 80%
bucket 115: 100%
Sorting block of length 6688424 for bucket 115
(Using difference cover)
bucket 124: 80%
Sorting block time: 00:00:01
Returning block of 5215156 for bucket 111
Getting block 139 of 203
Reserving size (7213762) for bucket 139
Calculating Z arrays for bucket 139
Entering block accumulator loop for bucket 139:
bucket 120: 90%
bucket 125: 80%
bucket 119: 90%
bucket 134: 70%
bucket 116: 100%
Sorting block of length 6000481 for bucket 116
(Using difference cover)
bucket 126: 80%
bucket 135: 70%
bucket 132: 80%
bucket 130: 80%
bucket 137: 10%
bucket 121: 90%
bucket 127: 80%
bucket 122: 90%
bucket 128: 80%
bucket 136: 20%
bucket 129: 80%
bucket 131: 80%
bucket 117: 100%
Sorting block of length 5381934 for bucket 117
(Using difference cover)
bucket 133: 80%
bucket 118: 100%
Sorting block of length 2406300 for bucket 118
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 7205858 for bucket 113
bucket 124: 90%
bucket 123: 90%
Sorting block time: 00:00:02
Returning block of 5873269 for bucket 114
bucket 138: 10%
bucket 120: 100%
Sorting block of length 5125879 for bucket 120
(Using difference cover)
bucket 139: 10%
bucket 119: 100%
Sorting block of length 6963270 for bucket 119
(Using difference cover)
bucket 125: 90%
Getting block 140 of 203
Reserving size (7213762) for bucket 140
Calculating Z arrays for bucket 140
Entering block accumulator loop for bucket 140:
Getting block 141 of 203
Reserving size (7213762) for bucket 141
Calculating Z arrays for bucket 141
Entering block accumulator loop for bucket 141:
Sorting block time: 00:00:02
Returning block of 6688425 for bucket 115
bucket 134: 80%
Sorting block time: 00:00:01
Returning block of 2406301 for bucket 118
bucket 126: 90%
Getting block 142 of 203
Reserving size (7213762) for bucket 142
Calculating Z arrays for bucket 142
Entering block accumulator loop for bucket 142:
Getting block 143 of 203
Reserving size (7213762) for bucket 143
Calculating Z arrays for bucket 143
Entering block accumulator loop for bucket 143:
bucket 130: 90%
bucket 135: 80%
bucket 137: 20%
bucket 127: 90%
bucket 122: 100%
Sorting block of length 6428105 for bucket 122
(Using difference cover)
bucket 132: 90%
bucket 121: 100%
Sorting block of length 6400289 for bucket 121
(Using difference cover)
bucket 128: 90%
Sorting block time: 00:00:01
Returning block of 6000482 for bucket 116
Getting block 144 of 203
Reserving size (7213762) for bucket 144
Calculating Z arrays for bucket 144
Entering block accumulator loop for bucket 144:
bucket 136: 30%
bucket 129: 90%
bucket 131: 90%
bucket 133: 90%
bucket 124: 100%
Sorting block of length 5938435 for bucket 124
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 5125880 for bucket 120
bucket 123: 100%
Sorting block of length 6327586 for bucket 123
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5381935 for bucket 117
bucket 139: 20%
Getting block 145 of 203
Reserving size (7213762) for bucket 145
Calculating Z arrays for bucket 145
Entering block accumulator loop for bucket 145:
bucket 140: 10%
bucket 125: 100%
Sorting block of length 4643079 for bucket 125
(Using difference cover)
Getting block 146 of 203
Reserving size (7213762) for bucket 146
Calculating Z arrays for bucket 146
Entering block accumulator loop for bucket 146:
bucket 141: 10%
bucket 138: 20%
bucket 134: 90%
bucket 142: 10%
bucket 126: 100%
Sorting block of length 3855841 for bucket 126
(Using difference cover)
bucket 143: 10%
bucket 130: 100%
Sorting block of length 1579303 for bucket 130
(Using difference cover)
bucket 135: 90%
bucket 132: 100%
Sorting block of length 1990091 for bucket 132
(Using difference cover)
bucket 127: 100%
Sorting block of length 5758882 for bucket 127
(Using difference cover)
bucket 137: 30%
bucket 128: 100%
Sorting block of length 3980023 for bucket 128
(Using difference cover)
bucket 144: 10%
bucket 136: 40%
bucket 129: 100%
Sorting block of length 6294481 for bucket 129
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6963271 for bucket 119
bucket 131: 100%
Sorting block of length 5773486 for bucket 131
(Using difference cover)
Sorting block time: 00:00:00
Returning block of 1579304 for bucket 130
Getting block 147 of 203
Reserving size (7213762) for bucket 147
Calculating Z arrays for bucket 147
Entering block accumulator loop for bucket 147:
bucket 133: 100%
Sorting block of length 6754643 for bucket 133
(Using difference cover)
Getting block 148 of 203
Reserving size (7213762) for bucket 148
Calculating Z arrays for bucket 148
Entering block accumulator loop for bucket 148:
Sorting block time: 00:00:00
Returning block of 1990092 for bucket 132
Getting block 149 of 203
Reserving size (7213762) for bucket 149
Calculating Z arrays for bucket 149
Entering block accumulator loop for bucket 149:
Sorting block time: 00:00:02
Returning block of 6428106 for bucket 122
Sorting block time: 00:00:02
Returning block of 6400290 for bucket 121
bucket 139: 30%
Getting block 150 of 203
Reserving size (7213762) for bucket 150
Calculating Z arrays for bucket 150
Entering block accumulator loop for bucket 150:
Getting block 151 of 203
Reserving size (7213762) for bucket 151
Calculating Z arrays for bucket 151
Entering block accumulator loop for bucket 151:
bucket 140: 20%
Sorting block time: 00:00:01
Returning block of 3855842 for bucket 126
bucket 141: 20%
bucket 146: 10%
bucket 145: 10%
Sorting block time: 00:00:02
Returning block of 5938436 for bucket 124
Getting block 152 of 203
Reserving size (7213762) for bucket 152
Calculating Z arrays for bucket 152
Entering block accumulator loop for bucket 152:
Sorting block time: 00:00:02
Returning block of 4643080 for bucket 125
Getting block 153 of 203
Reserving size (7213762) for bucket 153
Calculating Z arrays for bucket 153
Entering block accumulator loop for bucket 153:
bucket 142: 20%
bucket 134: 100%
Sorting block of length 6932201 for bucket 134
(Using difference cover)
Getting block 154 of 203
Reserving size (7213762) for bucket 154
Calculating Z arrays for bucket 154
Entering block accumulator loop for bucket 154:
bucket 143: 20%
Sorting block time: 00:00:01
Returning block of 3980024 for bucket 128
Getting block 155 of 203
Reserving size (7213762) for bucket 155
Calculating Z arrays for bucket 155
Entering block accumulator loop for bucket 155:
bucket 135: 100%
Sorting block of length 5705280 for bucket 135
(Using difference cover)
bucket 138: 30%
bucket 137: 40%
Sorting block time: 00:00:02
Returning block of 6327587 for bucket 123
bucket 144: 20%
bucket 136: 50%
Getting block 156 of 203
Reserving size (7213762) for bucket 156
Calculating Z arrays for bucket 156
Entering block accumulator loop for bucket 156:
Sorting block time: 00:00:01
Returning block of 5758883 for bucket 127
bucket 147: 10%
Getting block 157 of 203
Reserving size (7213762) for bucket 157
Calculating Z arrays for bucket 157
Entering block accumulator loop for bucket 157:
bucket 148: 10%
bucket 149: 10%
Sorting block time: 00:00:02
Returning block of 5773487 for bucket 131
bucket 139: 40%
bucket 150: 10%
Sorting block time: 00:00:02
Returning block of 6294482 for bucket 129
bucket 140: 30%
bucket 151: 10%
Getting block 158 of 203
Reserving size (7213762) for bucket 158
Calculating Z arrays for bucket 158
Entering block accumulator loop for bucket 158:
bucket 141: 30%
bucket 146: 20%
Sorting block time: 00:00:02
Returning block of 6754644 for bucket 133
Getting block 159 of 203
Reserving size (7213762) for bucket 159
Calculating Z arrays for bucket 159
Entering block accumulator loop for bucket 159:
bucket 145: 20%
bucket 152: 10%
bucket 153: 10%
Getting block 160 of 203
Reserving size (7213762) for bucket 160
Calculating Z arrays for bucket 160
Entering block accumulator loop for bucket 160:
bucket 142: 30%
bucket 154: 10%
bucket 143: 30%
bucket 155: 10%
bucket 137: 50%
Sorting block time: 00:00:02
Returning block of 5705281 for bucket 135
bucket 156: 10%
bucket 136: 60%
bucket 144: 30%
bucket 138: 40%
Getting block 161 of 203
Reserving size (7213762) for bucket 161
Calculating Z arrays for bucket 161
Entering block accumulator loop for bucket 161:
Sorting block time: 00:00:02
Returning block of 6932202 for bucket 134
bucket 147: 20%
bucket 157: 10%
Getting block 162 of 203
Reserving size (7213762) for bucket 162
Calculating Z arrays for bucket 162
Entering block accumulator loop for bucket 162:
bucket 148: 20%
bucket 149: 20%
bucket 150: 20%
bucket 139: 50%
bucket 140: 40%
bucket 151: 20%
bucket 158: 10%
bucket 141: 40%
bucket 146: 30%
bucket 159: 10%
bucket 152: 20%
bucket 145: 30%
bucket 153: 20%
bucket 142: 40%
bucket 160: 10%
bucket 154: 20%
bucket 143: 40%
bucket 155: 20%
bucket 137: 60%
bucket 156: 20%
bucket 136: 70%
bucket 144: 40%
bucket 147: 30%
bucket 161: 10%
bucket 157: 20%
bucket 162: 10%
bucket 138: 50%
bucket 148: 30%
bucket 149: 30%
bucket 139: 60%
bucket 150: 30%
bucket 140: 50%
bucket 141: 50%
bucket 158: 20%
bucket 151: 30%
bucket 146: 40%
bucket 159: 20%
bucket 153: 30%
bucket 142: 50%
bucket 152: 30%
bucket 145: 40%
bucket 160: 20%
bucket 154: 30%
bucket 143: 50%
bucket 155: 30%
bucket 137: 70%
bucket 156: 30%
bucket 136: 80%
bucket 144: 50%
bucket 147: 40%
bucket 161: 20%
bucket 157: 30%
bucket 162: 20%
bucket 148: 40%
bucket 139: 70%
bucket 140: 60%
bucket 150: 40%
bucket 149: 40%
bucket 138: 60%
bucket 141: 60%
bucket 158: 30%
bucket 151: 40%
bucket 146: 50%
bucket 159: 30%
bucket 142: 60%
bucket 153: 40%
bucket 152: 40%
bucket 145: 50%
bucket 154: 40%
bucket 160: 30%
bucket 155: 40%
bucket 143: 60%
bucket 156: 40%
bucket 136: 90%
bucket 144: 60%
bucket 137: 80%
bucket 147: 50%
bucket 161: 30%
bucket 157: 40%
bucket 162: 30%
bucket 148: 50%
bucket 140: 70%
bucket 139: 80%
bucket 150: 50%
bucket 141: 70%
bucket 149: 50%
bucket 158: 40%
bucket 142: 70%
bucket 153: 50%
bucket 151: 50%
bucket 146: 60%
bucket 159: 40%
bucket 152: 50%
bucket 138: 70%
bucket 154: 50%
bucket 145: 60%
bucket 160: 40%
bucket 155: 50%
bucket 143: 70%
bucket 156: 50%
bucket 136: 100%
Sorting block of length 1628398 for bucket 136
(Using difference cover)
bucket 144: 70%
bucket 147: 60%
bucket 137: 90%
bucket 161: 40%
bucket 157: 50%
bucket 162: 40%
bucket 148: 60%
Sorting block time: 00:00:01
Returning block of 1628399 for bucket 136
bucket 140: 80%
Getting block 163 of 203
Reserving size (7213762) for bucket 163
Calculating Z arrays for bucket 163
Entering block accumulator loop for bucket 163:
bucket 139: 90%
bucket 150: 60%
bucket 141: 80%
bucket 142: 80%
bucket 153: 60%
bucket 158: 50%
bucket 149: 60%
bucket 146: 70%
bucket 151: 60%
bucket 159: 50%
bucket 152: 60%
bucket 154: 60%
bucket 145: 70%
bucket 155: 60%
bucket 160: 50%
bucket 143: 80%
bucket 138: 80%
bucket 156: 60%
bucket 147: 70%
bucket 144: 80%
bucket 137: 100%
Sorting block of length 6204205 for bucket 137
(Using difference cover)
bucket 161: 50%
bucket 157: 60%
bucket 148: 70%
bucket 162: 50%
bucket 140: 90%
bucket 163: 10%
bucket 139: 100%
Sorting block of length 7064031 for bucket 139
(Using difference cover)
bucket 150: 70%
bucket 142: 90%
bucket 153: 70%
bucket 141: 90%
bucket 158: 60%
bucket 146: 80%
bucket 159: 60%
bucket 151: 70%
bucket 149: 70%
bucket 152: 70%
bucket 154: 70%
bucket 155: 70%
bucket 160: 60%
bucket 145: 80%
bucket 143: 90%
bucket 156: 70%
bucket 147: 80%
bucket 144: 90%
bucket 138: 90%
bucket 161: 60%
bucket 157: 70%
Sorting block time: 00:00:02
Returning block of 6204206 for bucket 137
bucket 140: 100%
Sorting block of length 5349465 for bucket 140
(Using difference cover)
bucket 162: 60%
bucket 163: 20%
bucket 148: 80%
bucket 150: 80%
bucket 142: 100%
Sorting block of length 2188382 for bucket 142
(Using difference cover)
bucket 153: 80%
Getting block 164 of 203
Reserving size (7213762) for bucket 164
Calculating Z arrays for bucket 164
Entering block accumulator loop for bucket 164:
bucket 141: 100%
Sorting block of length 5038771 for bucket 141
(Using difference cover)
bucket 158: 70%
bucket 159: 70%
bucket 146: 90%
bucket 151: 80%
bucket 149: 80%
bucket 152: 80%
bucket 154: 80%
bucket 155: 80%
bucket 143: 100%
Sorting block of length 5835835 for bucket 143
(Using difference cover)
bucket 160: 70%
bucket 145: 90%
Sorting block time: 00:00:02
Returning block of 7064032 for bucket 139
Sorting block time: 00:00:00
Returning block of 2188383 for bucket 142
Getting block 165 of 203
Reserving size (7213762) for bucket 165
Calculating Z arrays for bucket 165
Entering block accumulator loop for bucket 165:
Getting block 166 of 203
Reserving size (7213762) for bucket 166
Calculating Z arrays for bucket 166
Entering block accumulator loop for bucket 166:
bucket 156: 80%
bucket 147: 90%
bucket 144: 100%
Sorting block of length 5949653 for bucket 144
(Using difference cover)
bucket 138: 100%
Sorting block of length 6449640 for bucket 138
(Using difference cover)
bucket 161: 70%
bucket 163: 30%
bucket 157: 80%
bucket 148: 90%
bucket 162: 70%
bucket 153: 90%
bucket 150: 90%
bucket 164: 10%
bucket 158: 80%
bucket 159: 80%
bucket 146: 100%
Sorting block of length 3377075 for bucket 146
(Using difference cover)
bucket 151: 90%
bucket 152: 90%
bucket 149: 90%
Sorting block time: 00:00:01
Returning block of 5038772 for bucket 141
Sorting block time: 00:00:01
Returning block of 5349466 for bucket 140
bucket 154: 90%
bucket 155: 90%
Getting block 167 of 203
Reserving size (7213762) for bucket 167
Calculating Z arrays for bucket 167
Entering block accumulator loop for bucket 167:
Getting block 168 of 203
Reserving size (7213762) for bucket 168
Calculating Z arrays for bucket 168
Entering block accumulator loop for bucket 168:
bucket 160: 80%
bucket 145: 100%
Sorting block of length 6454173 for bucket 145
(Using difference cover)
bucket 166: 10%
bucket 165: 10%
Sorting block time: 00:00:02
Returning block of 5835836 for bucket 143
bucket 156: 90%
bucket 147: 100%
Sorting block of length 1101889 for bucket 147
(Using difference cover)
Getting block 169 of 203
Reserving size (7213762) for bucket 169
Calculating Z arrays for bucket 169
Entering block accumulator loop for bucket 169:
Sorting block time: 00:00:00
Returning block of 1101890 for bucket 147
Getting block 170 of 203
Reserving size (7213762) for bucket 170
Calculating Z arrays for bucket 170
Entering block accumulator loop for bucket 170:
Sorting block time: 00:00:02
Returning block of 5949654 for bucket 144
Sorting block time: 00:00:01
Returning block of 3377076 for bucket 146
bucket 161: 80%
Getting block 171 of 203
Reserving size (7213762) for bucket 171
Calculating Z arrays for bucket 171
Entering block accumulator loop for bucket 171:
Getting block 172 of 203
Reserving size (7213762) for bucket 172
Calculating Z arrays for bucket 172
Entering block accumulator loop for bucket 172:
bucket 163: 40%
bucket 153: 100%
Sorting block of length 5786146 for bucket 153
(Using difference cover)
bucket 157: 90%
bucket 148: 100%
Sorting block of length 9334066 for bucket 148
(Using difference cover)
bucket 162: 80%
bucket 150: 100%
Sorting block of length 6918502 for bucket 150
(Using difference cover)
bucket 164: 20%
bucket 158: 90%
bucket 159: 90%
bucket 151: 100%
Sorting block of length 7003140 for bucket 151
(Using difference cover)
bucket 152: 100%
Sorting block of length 5944341 for bucket 152
(Using difference cover)
bucket 154: 100%
Sorting block of length 6051433 for bucket 154
(Using difference cover)
bucket 149: 100%
Sorting block of length 5287304 for bucket 149
(Using difference cover)
bucket 155: 100%
Sorting block of length 6738866 for bucket 155
(Using difference cover)
bucket 168: 10%
bucket 167: 10%
Sorting block time: 00:00:02
Returning block of 6449641 for bucket 138
bucket 160: 90%
Getting block 173 of 203
Reserving size (7213762) for bucket 173
Calculating Z arrays for bucket 173
Entering block accumulator loop for bucket 173:
bucket 166: 20%
bucket 165: 20%
bucket 156: 100%
Sorting block of length 6040312 for bucket 156
(Using difference cover)
bucket 169: 10%
bucket 170: 10%
Sorting block time: 00:00:02
Returning block of 6454174 for bucket 145
bucket 171: 10%
bucket 163: 50%
bucket 161: 90%
bucket 172: 10%
Getting block 174 of 203
Reserving size (7213762) for bucket 174
Calculating Z arrays for bucket 174
Entering block accumulator loop for bucket 174:
bucket 157: 100%
Sorting block of length 6742973 for bucket 157
(Using difference cover)
bucket 162: 90%
bucket 164: 30%
bucket 158: 100%
Sorting block of length 5129800 for bucket 158
(Using difference cover)
bucket 159: 100%
Sorting block of length 3801908 for bucket 159
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5786147 for bucket 153
Getting block 175 of 203
Reserving size (7213762) for bucket 175
Calculating Z arrays for bucket 175
Entering block accumulator loop for bucket 175:
bucket 168: 20%
bucket 167: 20%
bucket 160: 100%
Sorting block of length 6067589 for bucket 160
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 5944342 for bucket 152
bucket 166: 30%
bucket 173: 10%
bucket 165: 30%
Getting block 176 of 203
Reserving size (7213762) for bucket 176
Calculating Z arrays for bucket 176
Entering block accumulator loop for bucket 176:
Sorting block time: 00:00:02
Returning block of 5287305 for bucket 149
bucket 169: 20%
Sorting block time: 00:00:03
Returning block of 6918503 for bucket 150
Getting block 177 of 203
Reserving size (7213762) for bucket 177
Calculating Z arrays for bucket 177
Entering block accumulator loop for bucket 177:
Sorting block time: 00:00:02
Returning block of 6051434 for bucket 154
Sorting block time: 00:00:02
Returning block of 6738867 for bucket 155
bucket 170: 20%
Getting block 178 of 203
Reserving size (7213762) for bucket 178
Calculating Z arrays for bucket 178
Entering block accumulator loop for bucket 178:
Getting block 179 of 203
Reserving size (7213762) for bucket 179
Calculating Z arrays for bucket 179
Entering block accumulator loop for bucket 179:
Getting block 180 of 203
Reserving size (7213762) for bucket 180
Calculating Z arrays for bucket 180
Entering block accumulator loop for bucket 180:
Sorting block time: 00:00:02
Returning block of 7003141 for bucket 151
Sorting block time: 00:00:03
Returning block of 9334067 for bucket 148
bucket 171: 20%
bucket 163: 60%
bucket 172: 20%
bucket 161: 100%
Sorting block of length 4179723 for bucket 161
(Using difference cover)
Getting block 181 of 203
Reserving size (7213762) for bucket 181
Calculating Z arrays for bucket 181
Entering block accumulator loop for bucket 181:
Sorting block time: 00:00:02
Returning block of 6040313 for bucket 156
Sorting block time: 00:00:01
Returning block of 3801909 for bucket 159
bucket 174: 10%
Getting block 182 of 203
Reserving size (7213762) for bucket 182
Calculating Z arrays for bucket 182
Entering block accumulator loop for bucket 182:
bucket 162: 100%
Sorting block of length 6883098 for bucket 162
(Using difference cover)
Getting block 183 of 203
Reserving size (7213762) for bucket 183
Calculating Z arrays for bucket 183
Entering block accumulator loop for bucket 183:
Getting block 184 of 203
Reserving size (7213762) for bucket 184
Calculating Z arrays for bucket 184
Entering block accumulator loop for bucket 184:
bucket 164: 40%
Sorting block time: 00:00:01
Returning block of 5129801 for bucket 158
Getting block 185 of 203
Reserving size (7213762) for bucket 185
Calculating Z arrays for bucket 185
Entering block accumulator loop for bucket 185:
bucket 175: 10%
bucket 168: 30%
bucket 167: 30%
Sorting block time: 00:00:02
Returning block of 6742974 for bucket 157
bucket 166: 40%
Getting block 186 of 203
Reserving size (7213762) for bucket 186
Calculating Z arrays for bucket 186
Entering block accumulator loop for bucket 186:
bucket 165: 40%
bucket 173: 20%
bucket 176: 10%
bucket 169: 30%
bucket 177: 10%
Sorting block time: 00:00:02
Returning block of 6067590 for bucket 160
bucket 170: 30%
bucket 178: 10%
bucket 179: 10%
Getting block 187 of 203
Reserving size (7213762) for bucket 187
Calculating Z arrays for bucket 187
Entering block accumulator loop for bucket 187:
bucket 180: 10%
Sorting block time: 00:00:01
Returning block of 4179724 for bucket 161
bucket 171: 30%
bucket 163: 70%
bucket 181: 10%
bucket 172: 30%
Getting block 188 of 203
Reserving size (7213762) for bucket 188
Calculating Z arrays for bucket 188
Entering block accumulator loop for bucket 188:
bucket 182: 10%
bucket 183: 10%
bucket 174: 20%
bucket 184: 10%
bucket 164: 50%
bucket 185: 10%
bucket 175: 20%
bucket 168: 40%
Sorting block time: 00:00:02
Returning block of 6883099 for bucket 162
bucket 167: 40%
Getting block 189 of 203
Reserving size (7213762) for bucket 189
Calculating Z arrays for bucket 189
Entering block accumulator loop for bucket 189:
bucket 186: 10%
bucket 166: 50%
bucket 165: 50%
bucket 173: 30%
bucket 176: 20%
bucket 169: 40%
bucket 177: 20%
bucket 170: 40%
bucket 187: 10%
bucket 178: 20%
bucket 179: 20%
bucket 180: 20%
bucket 181: 20%
bucket 171: 40%
bucket 163: 80%
bucket 188: 10%
bucket 182: 20%
bucket 183: 20%
bucket 172: 40%
bucket 184: 20%
bucket 174: 30%
bucket 185: 20%
bucket 164: 60%
bucket 175: 30%
bucket 168: 50%
bucket 186: 20%
bucket 189: 10%
bucket 167: 50%
bucket 166: 60%
bucket 165: 60%
bucket 176: 30%
bucket 173: 40%
bucket 169: 50%
bucket 177: 30%
bucket 187: 20%
bucket 170: 50%
bucket 178: 30%
bucket 179: 30%
bucket 181: 30%
bucket 171: 50%
bucket 180: 30%
bucket 163: 90%
bucket 182: 30%
bucket 188: 20%
bucket 183: 30%
bucket 172: 50%
bucket 184: 30%
bucket 185: 30%
bucket 174: 40%
bucket 164: 70%
bucket 175: 40%
bucket 168: 60%
bucket 186: 30%
bucket 189: 20%
bucket 167: 60%
bucket 166: 70%
bucket 165: 70%
bucket 176: 40%
bucket 173: 50%
bucket 169: 60%
bucket 187: 30%
bucket 177: 40%
bucket 170: 60%
bucket 178: 40%
bucket 181: 40%
bucket 179: 40%
bucket 171: 60%
bucket 163: 100%
Sorting block of length 3312876 for bucket 163
(Using difference cover)
bucket 182: 40%
bucket 183: 40%
bucket 188: 30%
bucket 180: 40%
bucket 184: 40%
bucket 185: 40%
bucket 172: 60%
bucket 174: 50%
bucket 164: 80%
bucket 175: 50%
bucket 186: 40%
bucket 168: 70%
bucket 189: 30%
bucket 165: 80%
bucket 166: 80%
bucket 176: 50%
bucket 167: 70%
bucket 169: 70%
Sorting block time: 00:00:01
Returning block of 3312877 for bucket 163
bucket 173: 60%
bucket 187: 40%
Getting block 190 of 203
Reserving size (7213762) for bucket 190
Calculating Z arrays for bucket 190
Entering block accumulator loop for bucket 190:
bucket 177: 50%
bucket 170: 70%
bucket 181: 50%
bucket 178: 50%
bucket 183: 50%
bucket 179: 50%
bucket 182: 50%
bucket 171: 70%
bucket 188: 40%
bucket 185: 50%
bucket 184: 50%
bucket 180: 50%
bucket 172: 70%
bucket 174: 60%
bucket 164: 90%
bucket 175: 60%
bucket 186: 50%
bucket 168: 80%
bucket 189: 40%
bucket 165: 90%
bucket 166: 90%
bucket 176: 60%
bucket 169: 80%
bucket 187: 50%
bucket 173: 70%
bucket 167: 80%
bucket 190: 10%
bucket 181: 60%
bucket 170: 80%
bucket 177: 60%
bucket 178: 60%
bucket 182: 60%
bucket 183: 60%
bucket 171: 80%
bucket 179: 60%
bucket 185: 60%
bucket 188: 50%
bucket 184: 60%
bucket 180: 60%
bucket 174: 70%
bucket 172: 80%
bucket 164: 100%
Sorting block of length 5258100 for bucket 164
(Using difference cover)
bucket 186: 60%
bucket 175: 70%
bucket 168: 90%
bucket 189: 50%
bucket 165: 100%
Sorting block of length 5127247 for bucket 165
(Using difference cover)
bucket 166: 100%
Sorting block of length 5769692 for bucket 166
(Using difference cover)
bucket 176: 70%
bucket 187: 60%
bucket 169: 90%
bucket 173: 80%
bucket 181: 70%
bucket 167: 90%
bucket 170: 90%
bucket 190: 20%
bucket 177: 70%
bucket 182: 70%
bucket 183: 70%
bucket 178: 70%
bucket 171: 90%
bucket 185: 70%
bucket 179: 70%
bucket 184: 70%
bucket 188: 60%
bucket 180: 70%
bucket 174: 80%
bucket 186: 70%
bucket 172: 90%
bucket 175: 80%
Sorting block time: 00:00:01
Returning block of 5258101 for bucket 164
Getting block 191 of 203
Reserving size (7213762) for bucket 191
Calculating Z arrays for bucket 191
Entering block accumulator loop for bucket 191:
bucket 168: 100%
Sorting block of length 6798658 for bucket 168
(Using difference cover)
bucket 189: 60%
Sorting block time: 00:00:01
Returning block of 5127248 for bucket 165
bucket 187: 70%
bucket 176: 80%
bucket 169: 100%
Sorting block of length 4829539 for bucket 169
(Using difference cover)
Getting block 192 of 203
Reserving size (7213762) for bucket 192
Calculating Z arrays for bucket 192
Entering block accumulator loop for bucket 192:
bucket 181: 80%
Sorting block time: 00:00:02
Returning block of 5769693 for bucket 166
bucket 173: 90%
bucket 190: 30%
bucket 170: 100%
Sorting block of length 5602479 for bucket 170
(Using difference cover)
bucket 183: 80%
Getting block 193 of 203
Reserving size (7213762) for bucket 193
Calculating Z arrays for bucket 193
Entering block accumulator loop for bucket 193:
bucket 182: 80%
bucket 167: 100%
Sorting block of length 7059782 for bucket 167
(Using difference cover)
bucket 177: 80%
bucket 185: 80%
bucket 171: 100%
Sorting block of length 4484719 for bucket 171
(Using difference cover)
bucket 178: 80%
bucket 184: 80%
bucket 188: 70%
bucket 179: 80%
bucket 180: 80%
bucket 174: 90%
bucket 186: 80%
bucket 172: 100%
Sorting block of length 3756852 for bucket 172
(Using difference cover)
bucket 175: 90%
bucket 191: 10%
bucket 189: 70%
bucket 187: 80%
Sorting block time: 00:00:01
Returning block of 4829540 for bucket 169
bucket 192: 10%
bucket 176: 90%
bucket 181: 90%
Getting block 194 of 203
Reserving size (7213762) for bucket 194
Calculating Z arrays for bucket 194
Entering block accumulator loop for bucket 194:
bucket 190: 40%
Sorting block time: 00:00:01
Returning block of 4484720 for bucket 171
bucket 173: 100%
Sorting block of length 6021574 for bucket 173
(Using difference cover)
bucket 183: 90%
bucket 193: 10%
bucket 182: 90%
bucket 185: 90%
Getting block 195 of 203
Reserving size (7213762) for bucket 195
Calculating Z arrays for bucket 195
Entering block accumulator loop for bucket 195:
bucket 177: 90%
Sorting block time: 00:00:01
Returning block of 5602480 for bucket 170
bucket 178: 90%
bucket 184: 90%
bucket 188: 80%
Sorting block time: 00:00:02
Returning block of 6798659 for bucket 168
Getting block 196 of 203
Reserving size (7213762) for bucket 196
Calculating Z arrays for bucket 196
Entering block accumulator loop for bucket 196:
bucket 179: 90%
Getting block 197 of 203
Reserving size (7213762) for bucket 197
Calculating Z arrays for bucket 197
Entering block accumulator loop for bucket 197:
bucket 186: 90%
Sorting block time: 00:00:02
Returning block of 3756853 for bucket 172
bucket 180: 90%
bucket 174: 100%
Sorting block of length 7183980 for bucket 174
(Using difference cover)
Getting block 198 of 203
Reserving size (7213762) for bucket 198
Calculating Z arrays for bucket 198
Entering block accumulator loop for bucket 198:
bucket 175: 100%
Sorting block of length 2116095 for bucket 175
(Using difference cover)
bucket 191: 20%
bucket 189: 80%
Sorting block time: 00:00:02
Returning block of 7059783 for bucket 167
bucket 187: 90%
bucket 192: 20%
Getting block 199 of 203
Reserving size (7213762) for bucket 199
Calculating Z arrays for bucket 199
Entering block accumulator loop for bucket 199:
bucket 181: 100%
Sorting block of length 4396953 for bucket 181
(Using difference cover)
bucket 176: 100%
Sorting block of length 4350321 for bucket 176
(Using difference cover)
bucket 194: 10%
bucket 190: 50%
Sorting block time: 00:00:00
Returning block of 2116096 for bucket 175
bucket 183: 100%
Sorting block of length 5551830 for bucket 183
(Using difference cover)
bucket 193: 20%
bucket 185: 100%
Sorting block of length 3767736 for bucket 185
(Using difference cover)
Getting block 200 of 203
Reserving size (7213762) for bucket 200
Calculating Z arrays for bucket 200
Entering block accumulator loop for bucket 200:
bucket 182: 100%
Sorting block of length 6021202 for bucket 182
(Using difference cover)
bucket 195: 10%
bucket 177: 100%
Sorting block of length 3657510 for bucket 177
(Using difference cover)
bucket 184: 100%
Sorting block of length 5455006 for bucket 184
(Using difference cover)
bucket 178: 100%
Sorting block of length 4430598 for bucket 178
(Using difference cover)
bucket 196: 10%
bucket 188: 90%
bucket 197: 10%
bucket 179: 100%
Sorting block of length 5563724 for bucket 179
(Using difference cover)
bucket 186: 100%
Sorting block of length 4678821 for bucket 186
(Using difference cover)
bucket 198: 10%
bucket 180: 100%
Sorting block of length 5977570 for bucket 180
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 6021575 for bucket 173
bucket 191: 30%
Getting block 201 of 203
Reserving size (7213762) for bucket 201
Calculating Z arrays for bucket 201
Entering block accumulator loop for bucket 201:
bucket 189: 90%
bucket 187: 100%
Sorting block of length 3928126 for bucket 187
(Using difference cover)
bucket 192: 30%
Sorting block time: 00:00:02
Returning block of 4350322 for bucket 176
bucket 199: 10%
Sorting block time: 00:00:02
Returning block of 3767737 for bucket 185
Getting block 202 of 203
Reserving size (7213762) for bucket 202
Calculating Z arrays for bucket 202
Entering block accumulator loop for bucket 202:
bucket 194: 20%
Getting block 203 of 203
Reserving size (7213762) for bucket 203
Calculating Z arrays for bucket 203
Entering block accumulator loop for bucket 203:
bucket 190: 60%
bucket 193: 30%
bucket 200: 10%
bucket 195: 20%
Sorting block time: 00:00:02
Returning block of 4396954 for bucket 181
Sorting block time: 00:00:01
Returning block of 3657511 for bucket 177
bucket 196: 20%
bucket 188: 100%
Sorting block of length 6271016 for bucket 188
(Using difference cover)
bucket 197: 20%
Sorting block time: 00:00:02
Returning block of 7183981 for bucket 174
Sorting block time: 00:00:02
Returning block of 6021203 for bucket 182
Sorting block time: 00:00:01
Returning block of 4678822 for bucket 186
Sorting block time: 00:00:01
Returning block of 4430599 for bucket 178
bucket 198: 20%
bucket 191: 40%
Sorting block time: 00:00:02
Returning block of 5551831 for bucket 183
bucket 203: 10%
bucket 201: 10%
bucket 189: 100%
Sorting block of length 6352031 for bucket 189
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5455007 for bucket 184
Sorting block time: 00:00:02
Returning block of 5563725 for bucket 179
Sorting block time: 00:00:02
Returning block of 5977571 for bucket 180
Sorting block time: 00:00:02
Returning block of 3928127 for bucket 187
bucket 199: 20%
bucket 192: 40%
bucket 202: 10%
bucket 194: 30%
bucket 190: 70%
bucket 200: 20%
bucket 195: 30%
bucket 193: 40%
bucket 196: 30%
bucket 197: 30%
bucket 203: 20%
bucket 198: 30%
bucket 191: 50%
bucket 201: 20%
Sorting block time: 00:00:02
Returning block of 6271017 for bucket 188
bucket 199: 30%
bucket 192: 50%
bucket 202: 20%
bucket 194: 40%
bucket 200: 30%
bucket 190: 80%
bucket 195: 40%
Sorting block time: 00:00:01
Returning block of 6352032 for bucket 189
bucket 203: 30%
bucket 193: 50%
bucket 197: 40%
bucket 196: 40%
bucket 198: 40%
bucket 191: 60%
bucket 201: 30%
bucket 203: 40%
bucket 199: 40%
bucket 202: 30%
bucket 192: 60%
bucket 200: 40%
bucket 195: 50%
bucket 194: 50%
bucket 190: 90%
bucket 193: 60%
bucket 197: 50%
bucket 196: 50%
bucket 203: 50%
bucket 198: 50%
bucket 201: 40%
bucket 191: 70%
bucket 202: 40%
bucket 199: 50%
bucket 192: 70%
bucket 200: 50%
bucket 195: 60%
bucket 194: 60%
bucket 190: 100%
Sorting block of length 4246868 for bucket 190
(Using difference cover)
bucket 203: 60%
bucket 193: 70%
bucket 196: 60%
bucket 197: 60%
bucket 198: 60%
bucket 201: 50%
bucket 191: 80%
bucket 202: 50%
bucket 203: 70%
bucket 199: 60%
bucket 200: 60%
bucket 195: 70%
bucket 194: 70%
Sorting block time: 00:00:01
Returning block of 4246869 for bucket 190
bucket 192: 80%
bucket 193: 80%
bucket 196: 70%
bucket 197: 70%
bucket 198: 70%
bucket 203: 80%
bucket 201: 60%
bucket 202: 60%
bucket 199: 70%
bucket 191: 90%
bucket 200: 70%
bucket 195: 80%
bucket 194: 80%
bucket 192: 90%
bucket 203: 90%
bucket 193: 90%
bucket 196: 80%
bucket 197: 80%
bucket 198: 80%
bucket 201: 70%
bucket 202: 70%
bucket 199: 80%
bucket 191: 100%
Sorting block of length 5825888 for bucket 191
(Using difference cover)
bucket 200: 80%
bucket 203: 100%
Sorting block of length 581539 for bucket 203
(Using difference cover)
bucket 195: 90%
Sorting block time: 00:00:00
Returning block of 581540 for bucket 203
bucket 194: 90%
bucket 192: 100%
Sorting block of length 4976491 for bucket 192
(Using difference cover)
bucket 193: 100%
Sorting block of length 5203727 for bucket 193
(Using difference cover)
bucket 198: 90%
bucket 196: 90%
bucket 197: 90%
bucket 201: 80%
bucket 202: 80%
bucket 199: 90%
bucket 200: 90%
bucket 195: 100%
Sorting block of length 4453484 for bucket 195
(Using difference cover)
bucket 194: 100%
Sorting block of length 3588039 for bucket 194
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4976492 for bucket 192
Sorting block time: 00:00:01
Returning block of 5825889 for bucket 191
bucket 198: 100%
Sorting block of length 3950412 for bucket 198
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 5203728 for bucket 193
bucket 196: 100%
Sorting block of length 6754228 for bucket 196
(Using difference cover)
bucket 197: 100%
Sorting block of length 4356663 for bucket 197
(Using difference cover)
bucket 201: 90%
bucket 202: 90%
bucket 199: 100%
Sorting block of length 4390973 for bucket 199
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4453485 for bucket 195
bucket 200: 100%
Sorting block of length 7152442 for bucket 200
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 3588040 for bucket 194
Sorting block time: 00:00:01
Returning block of 3950413 for bucket 198
bucket 201: 100%
Sorting block of length 5284637 for bucket 201
(Using difference cover)
Sorting block time: 00:00:01
Returning block of 4356664 for bucket 197
bucket 202: 100%
Sorting block of length 6682407 for bucket 202
(Using difference cover)
Sorting block time: 00:00:02
Returning block of 4390974 for bucket 199
Sorting block time: 00:00:02
Returning block of 6754229 for bucket 196
Sorting block time: 00:00:02
Returning block of 7152443 for bucket 200
Sorting block time: 00:00:02
Returning block of 5284638 for bucket 201
Sorting block time: 00:00:02
Returning block of 6682408 for bucket 202
Exited Ebwt loop
fchr[A]: 0
fchr[C]: 341519526
fchr[G]: 538577822
fchr[T]: 735626959
fchr[$]: 1077255099
Exiting Ebwt::buildToDisk()
Returning from initFromVector
Wrote 371984998 bytes to primary EBWT file: Olurida_v081.rev.1.bt2
Wrote 269313780 bytes to secondary EBWT file: Olurida_v081.rev.2.bt2
Re-opening _in1 and _in2 as input streams
Returning from Ebwt constructor
Headers:
len: 1077255099
bwtLen: 1077255100
sz: 269313775
bwtSz: 269313775
lineRate: 6
offRate: 4
offMask: 0xfffffff0
ftabChars: 10
eftabLen: 20
eftabSz: 80
ftabLen: 1048577
ftabSz: 4194308
offsLen: 67328444
offsSz: 269313776
lineSz: 64
sideSz: 64
sideBwtSz: 48
sideBwtLen: 192
numSides: 5610704
numLines: 5610704
ebwtTotLen: 359085056
ebwtTotSz: 359085056
color: 0
reverse: 1
Total time for backward call to driver() for mirror index: 00:02:55
812215 reads; of these:
812215 (100.00%) were unpaired; of these:
497269 (61.22%) aligned 0 times
267103 (32.89%) aligned exactly 1 time
47843 (5.89%) aligned >1 times
38.78% overall alignment rate
[bam_sort_core] merging from 0 files and 28 in-memory blocks...