nohup: ignoring input
Settings:
  Output files: "GCA_009914755.4.*.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: 32
  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:
  GCA_009914755.4.fa
Building a SMALL index
Reading reference sizes
  Time reading reference sizes: 00:00:27
Calculating joined length
Writing header
Reserving space for joined string
Joining reference sequences
  Time to join reference sequences: 00:00:21
bmax according to bmaxDivN setting: 97415377
Using parameters --bmax 73061533 --dcv 1024
  Doing ahead-of-time memory usage test
  Passed!  Constructing with these parameters: --bmax 73061533 --dcv 1024
Constructing suffix-array element generator
Building DifferenceCoverSample
  Building sPrime
  Building sPrimeOrder
  V-Sorting samples
  V-Sorting samples time: 00:00:38
  Allocating rank array
  Ranking v-sort output
  Ranking v-sort output time: 00:00:26
  Invoking Larsson-Sadakane on ranks
  Invoking Larsson-Sadakane on ranks time: 00:00:41
  Sanity-checking and returning
Building samples
Reserving space for 86 sample suffixes
Generating random suffixes
QSorting 86 sample offsets, eliminating duplicates
QSorting sample offsets, eliminating duplicates time: 00:00:00
Multikey QSorting 86 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 13, merged 36; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 9, merged 6; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 5, merged 7; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 4, merged 4; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 1, merged 3; iterating...
Avg bucket size: 4.94808e+07 (target: 73061532)
Converting suffix-array elements to index image
Allocating ftab, absorbFtab
Entering Ebwt loop
Getting block 2 of 63
Getting block 1 of 63
  Reserving size (73061533) for bucket 2
  Reserving size (73061533) for bucket 1
Getting block 3 of 63
Getting block 4 of 63
Getting block 5 of 63
Getting block 6 of 63
Getting block 7 of 63
  Reserving size (73061533) for bucket 3
  Reserving size (73061533) for bucket 4
Getting block 8 of 63
  Calculating Z arrays for bucket 1
  Reserving size (73061533) for bucket 5
  Reserving size (73061533) for bucket 6
  Reserving size (73061533) for bucket 7
  Reserving size (73061533) for bucket 8
  Calculating Z arrays for bucket 2
  Entering block accumulator loop for bucket 1:
  Calculating Z arrays for bucket 8
  Entering block accumulator loop for bucket 2:
  Entering block accumulator loop for bucket 8:
  Calculating Z arrays for bucket 6
  Calculating Z arrays for bucket 3
  Calculating Z arrays for bucket 7
  Calculating Z arrays for bucket 4
  Calculating Z arrays for bucket 5
  Entering block accumulator loop for bucket 6:
  Entering block accumulator loop for bucket 3:
  Entering block accumulator loop for bucket 7:
  Entering block accumulator loop for bucket 4:
  Entering block accumulator loop for bucket 5:
  bucket 1: 10%
  bucket 2: 10%
  bucket 3: 10%
  bucket 4: 10%
  bucket 5: 10%
  bucket 6: 10%
  bucket 8: 10%
  bucket 7: 10%
  bucket 1: 20%
  bucket 2: 20%
  bucket 3: 20%
  bucket 4: 20%
  bucket 5: 20%
  bucket 6: 20%
  bucket 8: 20%
  bucket 7: 20%
  bucket 1: 30%
  bucket 3: 30%
  bucket 2: 30%
  bucket 5: 30%
  bucket 6: 30%
  bucket 4: 30%
  bucket 8: 30%
  bucket 1: 40%
  bucket 7: 30%
  bucket 3: 40%
  bucket 2: 40%
  bucket 5: 40%
  bucket 6: 40%
  bucket 1: 50%
  bucket 4: 40%
  bucket 8: 40%
  bucket 7: 40%
  bucket 2: 50%
  bucket 3: 50%
  bucket 5: 50%
  bucket 1: 60%
  bucket 4: 50%
  bucket 6: 50%
  bucket 8: 50%
  bucket 7: 50%
  bucket 2: 60%
  bucket 3: 60%
  bucket 1: 70%
  bucket 5: 60%
  bucket 4: 60%
  bucket 6: 60%
  bucket 8: 60%
  bucket 2: 70%
  bucket 3: 70%
  bucket 7: 60%
  bucket 1: 80%
  bucket 5: 70%
  bucket 4: 70%
  bucket 6: 70%
  bucket 2: 80%
  bucket 8: 70%
  bucket 3: 80%
  bucket 7: 70%
  bucket 1: 90%
  bucket 5: 80%
  bucket 4: 80%
  bucket 6: 80%
  bucket 2: 90%
  bucket 3: 90%
  bucket 8: 80%
  bucket 1: 100%
  Sorting block of length 39841499 for bucket 1
  (Using difference cover)
  bucket 7: 80%
  bucket 5: 90%
  bucket 4: 90%
  bucket 2: 100%
  Sorting block of length 45750114 for bucket 2
  (Using difference cover)
  bucket 6: 90%
  bucket 3: 100%
  Sorting block of length 47729641 for bucket 3
  (Using difference cover)
  bucket 8: 90%
  bucket 5: 100%
  Sorting block of length 59356211 for bucket 5
  (Using difference cover)
  bucket 7: 90%
  bucket 4: 100%
  Sorting block of length 47146750 for bucket 4
  (Using difference cover)
  bucket 6: 100%
  Sorting block of length 31575258 for bucket 6
  (Using difference cover)
  bucket 8: 100%
  Sorting block of length 36519317 for bucket 8
  (Using difference cover)
  bucket 7: 100%
  Sorting block of length 54211430 for bucket 7
  (Using difference cover)
  Sorting block time: 00:00:23
Returning block of 39841500 for bucket 1
Getting block 9 of 63
  Reserving size (73061533) for bucket 9
  Calculating Z arrays for bucket 9
  Entering block accumulator loop for bucket 9:
  bucket 9: 10%
  bucket 9: 20%
  Sorting block time: 00:00:27
Returning block of 36519318 for bucket 8
  Sorting block time: 00:00:32
Returning block of 47729642 for bucket 3
  Sorting block time: 00:00:33
Returning block of 45750115 for bucket 2
Getting block 10 of 63
  Reserving size (73061533) for bucket 10
  Calculating Z arrays for bucket 10
  Entering block accumulator loop for bucket 10:
Getting block 11 of 63
  Reserving size (73061533) for bucket 11
  Calculating Z arrays for bucket 11
  Entering block accumulator loop for bucket 11:
  bucket 9: 30%
Getting block 12 of 63
  Reserving size (73061533) for bucket 12
  Calculating Z arrays for bucket 12
  Entering block accumulator loop for bucket 12:
  Sorting block time: 00:00:34
Returning block of 47146751 for bucket 4
  Sorting block time: 00:00:34
Returning block of 31575259 for bucket 6
  bucket 10: 10%
Getting block 13 of 63
  Reserving size (73061533) for bucket 13
  Calculating Z arrays for bucket 13
  Entering block accumulator loop for bucket 13:
Getting block 14 of 63
  Reserving size (73061533) for bucket 14
  Calculating Z arrays for bucket 14
  Entering block accumulator loop for bucket 14:
  bucket 11: 10%
  bucket 9: 40%
  bucket 12: 10%
  Sorting block time: 00:00:40
Returning block of 59356212 for bucket 5
  bucket 10: 20%
  bucket 9: 50%
  bucket 11: 20%
  bucket 13: 10%
  bucket 14: 10%
  bucket 12: 20%
Getting block 15 of 63
  Reserving size (73061533) for bucket 15
  Calculating Z arrays for bucket 15
  Entering block accumulator loop for bucket 15:
  bucket 10: 30%
  Sorting block time: 00:00:42
Returning block of 54211431 for bucket 7
  bucket 9: 60%
  bucket 11: 30%
  bucket 13: 20%
  bucket 14: 20%
  bucket 12: 30%
  bucket 15: 10%
Getting block 16 of 63
  Reserving size (73061533) for bucket 16
  Calculating Z arrays for bucket 16
  Entering block accumulator loop for bucket 16:
  bucket 10: 40%
  bucket 9: 70%
  bucket 11: 40%
  bucket 13: 30%
  bucket 14: 30%
  bucket 12: 40%
  bucket 15: 20%
  bucket 16: 10%
  bucket 10: 50%
  bucket 9: 80%
  bucket 11: 50%
  bucket 13: 40%
  bucket 12: 50%
  bucket 14: 40%
  bucket 16: 20%
  bucket 15: 30%
  bucket 10: 60%
  bucket 9: 90%
  bucket 11: 60%
  bucket 13: 50%
  bucket 14: 50%
  bucket 12: 60%
  bucket 15: 40%
  bucket 16: 30%
  bucket 10: 70%
  bucket 9: 100%
  Sorting block of length 67357268 for bucket 9
  (Using difference cover)
  bucket 11: 70%
  bucket 14: 60%
  bucket 15: 50%
  bucket 16: 40%
  bucket 13: 60%
  bucket 12: 70%
  bucket 10: 80%
  bucket 11: 80%
  bucket 15: 60%
  bucket 16: 50%
  bucket 14: 70%
  bucket 12: 80%
  bucket 13: 70%
  bucket 10: 90%
  bucket 11: 90%
  bucket 16: 60%
  bucket 15: 70%
  bucket 14: 80%
  bucket 12: 90%
  bucket 10: 100%
  Sorting block of length 51477260 for bucket 10
  (Using difference cover)
  bucket 13: 80%
  bucket 11: 100%
  Sorting block of length 33596021 for bucket 11
  (Using difference cover)
  bucket 16: 70%
  bucket 15: 80%
  bucket 14: 90%
  bucket 12: 100%
  Sorting block of length 72687885 for bucket 12
  (Using difference cover)
  bucket 13: 90%
  bucket 15: 90%
  bucket 16: 80%
  bucket 14: 100%
  Sorting block of length 27407245 for bucket 14
  (Using difference cover)
  bucket 13: 100%
  Sorting block of length 57813395 for bucket 13
  (Using difference cover)
  bucket 15: 100%
  Sorting block of length 48310489 for bucket 15
  (Using difference cover)
  bucket 16: 90%
  bucket 16: 100%
  Sorting block of length 31560353 for bucket 16
  (Using difference cover)
  Sorting block time: 00:00:24
Returning block of 33596022 for bucket 11
  Sorting block time: 00:00:18
Returning block of 27407246 for bucket 14
Getting block 17 of 63
  Reserving size (73061533) for bucket 17
  Calculating Z arrays for bucket 17
  Entering block accumulator loop for bucket 17:
Getting block 18 of 63
  Reserving size (73061533) for bucket 18
  Calculating Z arrays for bucket 18
  Entering block accumulator loop for bucket 18:
  bucket 17: 10%
  bucket 18: 10%
  Sorting block time: 00:00:34
Returning block of 51477261 for bucket 10
  Sorting block time: 00:00:45
Returning block of 67357269 for bucket 9
  bucket 17: 20%
Getting block 19 of 63
  Reserving size (73061533) for bucket 19
  Calculating Z arrays for bucket 19
  Entering block accumulator loop for bucket 19:
  bucket 18: 20%
Getting block 20 of 63
  Reserving size (73061533) for bucket 20
  Calculating Z arrays for bucket 20
  Entering block accumulator loop for bucket 20:
  bucket 17: 30%
  bucket 19: 10%
  bucket 18: 30%
  bucket 20: 10%
  Sorting block time: 00:00:26
Returning block of 31560354 for bucket 16
  bucket 17: 40%
  Sorting block time: 00:00:34
Returning block of 57813396 for bucket 13
  bucket 19: 20%
  bucket 18: 40%
Getting block 21 of 63
  Reserving size (73061533) for bucket 21
  Calculating Z arrays for bucket 21
  Entering block accumulator loop for bucket 21:
  Sorting block time: 00:00:34
Returning block of 48310490 for bucket 15
  bucket 20: 20%
Getting block 22 of 63
  Reserving size (73061533) for bucket 22
  Calculating Z arrays for bucket 22
  Entering block accumulator loop for bucket 22:
  bucket 17: 50%
  Sorting block time: 00:00:43
Returning block of 72687886 for bucket 12
  bucket 18: 50%
  bucket 19: 30%
Getting block 23 of 63
  Reserving size (73061533) for bucket 23
  Calculating Z arrays for bucket 23
  Entering block accumulator loop for bucket 23:
  bucket 21: 10%
  bucket 20: 30%
  bucket 22: 10%
Getting block 24 of 63
  Reserving size (73061533) for bucket 24
  Calculating Z arrays for bucket 24
  Entering block accumulator loop for bucket 24:
  bucket 17: 60%
  bucket 19: 40%
  bucket 18: 60%
  bucket 23: 10%
  bucket 21: 20%
  bucket 22: 20%
  bucket 20: 40%
  bucket 24: 10%
  bucket 17: 70%
  bucket 19: 50%
  bucket 18: 70%
  bucket 21: 30%
  bucket 23: 20%
  bucket 22: 30%
  bucket 24: 20%
  bucket 20: 50%
  bucket 17: 80%
  bucket 19: 60%
  bucket 18: 80%
  bucket 23: 30%
  bucket 21: 40%
  bucket 22: 40%
  bucket 24: 30%
  bucket 20: 60%
  bucket 17: 90%
  bucket 19: 70%
  bucket 18: 90%
  bucket 21: 50%
  bucket 23: 40%
  bucket 22: 50%
  bucket 24: 40%
  bucket 17: 100%
  Sorting block of length 72255361 for bucket 17
  (Using difference cover)
  bucket 19: 80%
  bucket 18: 100%
  Sorting block of length 30350216 for bucket 18
  (Using difference cover)
  bucket 20: 70%
  bucket 23: 50%
  bucket 21: 60%
  bucket 22: 60%
  bucket 24: 50%
  bucket 19: 90%
  bucket 20: 80%
  bucket 21: 70%
  bucket 23: 60%
  bucket 22: 70%
  bucket 24: 60%
  bucket 19: 100%
  Sorting block of length 49964059 for bucket 19
  (Using difference cover)
  bucket 20: 90%
  bucket 21: 80%
  bucket 23: 70%
  bucket 22: 80%
  bucket 24: 70%
  bucket 20: 100%
  Sorting block of length 44970677 for bucket 20
  (Using difference cover)
  bucket 21: 90%
  bucket 23: 80%
  bucket 22: 90%
  bucket 24: 80%
  bucket 21: 100%
  Sorting block of length 67489329 for bucket 21
  (Using difference cover)
  Sorting block time: 00:00:21
Returning block of 30350217 for bucket 18
  bucket 23: 90%
  bucket 22: 100%
  Sorting block of length 15127015 for bucket 22
  (Using difference cover)
Getting block 25 of 63
  Reserving size (73061533) for bucket 25
  Calculating Z arrays for bucket 25
  Entering block accumulator loop for bucket 25:
  bucket 24: 90%
  bucket 23: 100%
  Sorting block of length 69689112 for bucket 23
  (Using difference cover)
  bucket 25: 10%
  bucket 24: 100%
  Sorting block of length 71022513 for bucket 24
  (Using difference cover)
  bucket 25: 20%
  Sorting block time: 00:00:12
Returning block of 15127016 for bucket 22
Getting block 26 of 63
  Reserving size (73061533) for bucket 26
  Calculating Z arrays for bucket 26
  Entering block accumulator loop for bucket 26:
  bucket 25: 30%
  bucket 26: 10%
  bucket 25: 40%
  bucket 26: 20%
  bucket 25: 50%
  Sorting block time: 00:00:34
Returning block of 44970678 for bucket 20
  bucket 26: 30%
  bucket 25: 60%
Getting block 27 of 63
  Reserving size (73061533) for bucket 27
  Calculating Z arrays for bucket 27
  Entering block accumulator loop for bucket 27:
  bucket 26: 40%
  bucket 25: 70%
  bucket 27: 10%
  bucket 26: 50%
  Sorting block time: 00:00:51
Returning block of 49964060 for bucket 19
  bucket 25: 80%
  bucket 27: 20%
Getting block 28 of 63
  Reserving size (73061533) for bucket 28
  Calculating Z arrays for bucket 28
  Entering block accumulator loop for bucket 28:
  bucket 26: 60%
  bucket 25: 90%
  bucket 27: 30%
  bucket 28: 10%
  Sorting block time: 00:00:48
Returning block of 67489330 for bucket 21
  Sorting block time: 00:01:09
Returning block of 72255362 for bucket 17
  bucket 26: 70%
  bucket 25: 100%
  Sorting block of length 36534849 for bucket 25
  (Using difference cover)
Getting block 29 of 63
  Reserving size (73061533) for bucket 29
  Calculating Z arrays for bucket 29
  Entering block accumulator loop for bucket 29:
  bucket 27: 40%
Getting block 30 of 63
  Reserving size (73061533) for bucket 30
  Calculating Z arrays for bucket 30
  Entering block accumulator loop for bucket 30:
  Sorting block time: 00:00:47
Returning block of 69689113 for bucket 23
  bucket 28: 20%
  bucket 26: 80%
Getting block 31 of 63
  Reserving size (73061533) for bucket 31
  Calculating Z arrays for bucket 31
  Entering block accumulator loop for bucket 31:
  bucket 29: 10%
  bucket 27: 50%
  bucket 30: 10%
  bucket 28: 30%
  bucket 26: 90%
  bucket 31: 10%
  bucket 29: 20%
  bucket 27: 60%
  bucket 26: 100%
  Sorting block of length 39167379 for bucket 26
  (Using difference cover)
  bucket 30: 20%
  bucket 28: 40%
  bucket 29: 30%
  bucket 27: 70%
  bucket 31: 20%
  Sorting block time: 00:01:00
Returning block of 71022514 for bucket 24
  bucket 28: 50%
  bucket 30: 30%
  bucket 27: 80%
  bucket 29: 40%
Getting block 32 of 63
  Reserving size (73061533) for bucket 32
  Calculating Z arrays for bucket 32
  Entering block accumulator loop for bucket 32:
  bucket 31: 30%
  bucket 28: 60%
  bucket 30: 40%
  bucket 29: 50%
  bucket 27: 90%
  bucket 32: 10%
  bucket 31: 40%
  bucket 28: 70%
  bucket 30: 50%
  bucket 27: 100%
  Sorting block of length 66300509 for bucket 27
  (Using difference cover)
  bucket 29: 60%
  Sorting block time: 00:00:31
Returning block of 36534850 for bucket 25
  bucket 31: 50%
  bucket 32: 20%
  bucket 28: 80%
  bucket 30: 60%
Getting block 33 of 63
  Reserving size (73061533) for bucket 33
  Calculating Z arrays for bucket 33
  Entering block accumulator loop for bucket 33:
  bucket 29: 70%
  bucket 32: 30%
  bucket 31: 60%
  Sorting block time: 00:00:24
Returning block of 39167380 for bucket 26
  bucket 28: 90%
  bucket 30: 70%
Getting block 34 of 63
  Reserving size (73061533) for bucket 34
  Calculating Z arrays for bucket 34
  Entering block accumulator loop for bucket 34:
  bucket 33: 10%
  bucket 29: 80%
  bucket 28: 100%
  Sorting block of length 67922256 for bucket 28
  (Using difference cover)
  bucket 31: 70%
  bucket 32: 40%
  bucket 30: 80%
  bucket 34: 10%
  bucket 29: 90%
  bucket 33: 20%
  bucket 31: 80%
  bucket 32: 50%
  bucket 30: 90%
  bucket 34: 20%
  bucket 29: 100%
  Sorting block of length 33179705 for bucket 29
  (Using difference cover)
  bucket 33: 30%
  bucket 31: 90%
  bucket 32: 60%
  bucket 30: 100%
  Sorting block of length 56969780 for bucket 30
  (Using difference cover)
  bucket 34: 30%
  bucket 31: 100%
  Sorting block of length 39668086 for bucket 31
  (Using difference cover)
  bucket 32: 70%
  bucket 33: 40%
  bucket 34: 40%
  bucket 32: 80%
  bucket 33: 50%
  bucket 34: 50%
  bucket 32: 90%
  bucket 34: 60%
  bucket 33: 60%
  Sorting block time: 00:00:21
Returning block of 33179706 for bucket 29
  bucket 32: 100%
  Sorting block of length 44464046 for bucket 32
  (Using difference cover)
Getting block 35 of 63
  Reserving size (73061533) for bucket 35
  Calculating Z arrays for bucket 35
  Entering block accumulator loop for bucket 35:
  bucket 34: 70%
  bucket 33: 70%
  Sorting block time: 00:00:43
Returning block of 66300510 for bucket 27
  bucket 35: 10%
  bucket 34: 80%
Getting block 36 of 63
  Reserving size (73061533) for bucket 36
  Calculating Z arrays for bucket 36
  Entering block accumulator loop for bucket 36:
  Sorting block time: 00:00:23
Returning block of 39668087 for bucket 31
  bucket 33: 80%
Getting block 37 of 63
  Reserving size (73061533) for bucket 37
  Calculating Z arrays for bucket 37
  Entering block accumulator loop for bucket 37:
  bucket 35: 20%
  bucket 34: 90%
  bucket 36: 10%
  bucket 33: 90%
  bucket 37: 10%
  bucket 35: 30%
  bucket 34: 100%
  Sorting block of length 45502179 for bucket 34
  (Using difference cover)
  Sorting block time: 00:00:35
Returning block of 56969781 for bucket 30
  bucket 36: 20%
Getting block 38 of 63
  Reserving size (73061533) for bucket 38
  Calculating Z arrays for bucket 38
  Entering block accumulator loop for bucket 38:
  bucket 37: 20%
  bucket 33: 100%
  Sorting block of length 70715608 for bucket 33
  (Using difference cover)
  Sorting block time: 00:00:48
Returning block of 67922257 for bucket 28
  bucket 35: 40%
  bucket 36: 30%
Getting block 39 of 63
  Reserving size (73061533) for bucket 39
  Calculating Z arrays for bucket 39
  Entering block accumulator loop for bucket 39:
  bucket 38: 10%
  bucket 37: 30%
  bucket 35: 50%
  bucket 36: 40%
  bucket 39: 10%
  bucket 38: 20%
  Sorting block time: 00:00:29
Returning block of 44464047 for bucket 32
  bucket 35: 60%
  bucket 37: 40%
Getting block 40 of 63
  Reserving size (73061533) for bucket 40
  Calculating Z arrays for bucket 40
  Entering block accumulator loop for bucket 40:
  bucket 36: 50%
  bucket 39: 20%
  bucket 38: 30%
  bucket 37: 50%
  bucket 35: 70%
  bucket 40: 10%
  bucket 36: 60%
  bucket 39: 30%
  bucket 38: 40%
  bucket 37: 60%
  bucket 40: 20%
  bucket 35: 80%
  bucket 36: 70%
  bucket 39: 40%
  bucket 38: 50%
  Sorting block time: 00:00:29
Returning block of 45502180 for bucket 34
  bucket 37: 70%
  bucket 40: 30%
  bucket 35: 90%
  bucket 36: 80%
Getting block 41 of 63
  Reserving size (73061533) for bucket 41
  Calculating Z arrays for bucket 41
  Entering block accumulator loop for bucket 41:
  bucket 39: 50%
  bucket 38: 60%
  bucket 40: 40%
  bucket 37: 80%
  bucket 35: 100%
  Sorting block of length 36811975 for bucket 35
  (Using difference cover)
  bucket 41: 10%
  bucket 36: 90%
  bucket 39: 60%
  bucket 38: 70%
  bucket 40: 50%
  bucket 37: 90%
  bucket 41: 20%
  bucket 36: 100%
  Sorting block of length 51877539 for bucket 36
  (Using difference cover)
  bucket 39: 70%
  bucket 38: 80%
  bucket 40: 60%
  bucket 37: 100%
  Sorting block of length 53946516 for bucket 37
  (Using difference cover)
  bucket 41: 30%
  bucket 39: 80%
  bucket 38: 90%
  bucket 40: 70%
  bucket 41: 40%
  bucket 39: 90%
  bucket 38: 100%
  Sorting block of length 69539475 for bucket 38
  (Using difference cover)
  bucket 40: 80%
  bucket 41: 50%
  bucket 39: 100%
  Sorting block of length 44102403 for bucket 39
  (Using difference cover)
  bucket 40: 90%
  Sorting block time: 00:00:22
Returning block of 36811976 for bucket 35
  bucket 41: 60%
Getting block 42 of 63
  Reserving size (73061533) for bucket 42
  Calculating Z arrays for bucket 42
  Entering block accumulator loop for bucket 42:
  bucket 40: 100%
  Sorting block of length 69441406 for bucket 40
  (Using difference cover)
  bucket 41: 70%
  bucket 42: 10%
  Sorting block time: 00:01:00
Returning block of 70715609 for bucket 33
  bucket 41: 80%
  bucket 42: 20%
Getting block 43 of 63
  Reserving size (73061533) for bucket 43
  Calculating Z arrays for bucket 43
  Entering block accumulator loop for bucket 43:
  bucket 41: 90%
  bucket 42: 30%
  bucket 43: 10%
  bucket 41: 100%
  Sorting block of length 17875947 for bucket 41
  (Using difference cover)
  Sorting block time: 00:00:32
Returning block of 53946517 for bucket 37
  bucket 43: 20%
  bucket 42: 40%
Getting block 44 of 63
  Reserving size (73061533) for bucket 44
  Calculating Z arrays for bucket 44
  Entering block accumulator loop for bucket 44:
  Sorting block time: 00:00:39
Returning block of 51877540 for bucket 36
Getting block 45 of 63
  Reserving size (73061533) for bucket 45
  Calculating Z arrays for bucket 45
  Entering block accumulator loop for bucket 45:
  bucket 43: 30%
  bucket 42: 50%
  bucket 44: 10%
  Sorting block time: 00:00:11
Returning block of 17875948 for bucket 41
Getting block 46 of 63
  Reserving size (73061533) for bucket 46
  Calculating Z arrays for bucket 46
  Entering block accumulator loop for bucket 46:
  bucket 43: 40%
  bucket 45: 10%
  bucket 42: 60%
  bucket 44: 20%
  bucket 46: 10%
  bucket 43: 50%
  bucket 42: 70%
  bucket 45: 20%
  bucket 44: 30%
  Sorting block time: 00:00:39
Returning block of 44102404 for bucket 39
  Sorting block time: 00:00:43
Returning block of 69539476 for bucket 38
Getting block 47 of 63
  Reserving size (73061533) for bucket 47
  Calculating Z arrays for bucket 47
  Entering block accumulator loop for bucket 47:
  bucket 46: 20%
  bucket 43: 60%
  bucket 42: 80%
  bucket 44: 40%
  bucket 45: 30%
Getting block 48 of 63
  Reserving size (73061533) for bucket 48
  Calculating Z arrays for bucket 48
  Entering block accumulator loop for bucket 48:
  bucket 47: 10%
  bucket 46: 30%
  Sorting block time: 00:00:40
Returning block of 69441407 for bucket 40
  bucket 43: 70%
  bucket 42: 90%
  bucket 44: 50%
  bucket 48: 10%
  bucket 45: 40%
Getting block 49 of 63
  Reserving size (73061533) for bucket 49
  Calculating Z arrays for bucket 49
  Entering block accumulator loop for bucket 49:
  bucket 47: 20%
  bucket 46: 40%
  bucket 43: 80%
  bucket 42: 100%
  Sorting block of length 70098261 for bucket 42
  (Using difference cover)
  bucket 48: 20%
  bucket 44: 60%
  bucket 47: 30%
  bucket 46: 50%
  bucket 49: 10%
  bucket 45: 50%
  bucket 48: 30%
  bucket 43: 90%
  bucket 44: 70%
  bucket 47: 40%
  bucket 46: 60%
  bucket 49: 20%
  bucket 45: 60%
  bucket 48: 40%
  bucket 43: 100%
  Sorting block of length 23217924 for bucket 43
  (Using difference cover)
  bucket 44: 80%
  bucket 47: 50%
  bucket 46: 70%
  bucket 49: 30%
  bucket 48: 50%
  bucket 45: 70%
  bucket 47: 60%
  bucket 44: 90%
  bucket 46: 80%
  bucket 49: 40%
  bucket 48: 60%
  bucket 47: 70%
  bucket 44: 100%
  Sorting block of length 54186686 for bucket 44
  (Using difference cover)
  bucket 45: 80%
  bucket 46: 90%
  bucket 49: 50%
  bucket 48: 70%
  Sorting block time: 00:00:13
Returning block of 23217925 for bucket 43
  bucket 47: 80%
Getting block 50 of 63
  Reserving size (73061533) for bucket 50
  Calculating Z arrays for bucket 50
  Entering block accumulator loop for bucket 50:
  bucket 46: 100%
  Sorting block of length 69123827 for bucket 46
  (Using difference cover)
  bucket 45: 90%
  bucket 49: 60%
  bucket 48: 80%
  bucket 47: 90%
  bucket 50: 10%
  bucket 49: 70%
  bucket 48: 90%
  bucket 45: 100%
  Sorting block of length 33297176 for bucket 45
  (Using difference cover)
  bucket 47: 100%
  Sorting block of length 54999862 for bucket 47
  (Using difference cover)
  bucket 50: 20%
  bucket 48: 100%
  Sorting block of length 58918039 for bucket 48
  (Using difference cover)
  bucket 49: 80%
  bucket 50: 30%
  bucket 49: 90%
  Sorting block time: 00:00:40
Returning block of 70098262 for bucket 42
  bucket 50: 40%
  bucket 49: 100%
  Sorting block of length 35227925 for bucket 49
  (Using difference cover)
Getting block 51 of 63
  Reserving size (73061533) for bucket 51
  Calculating Z arrays for bucket 51
  Entering block accumulator loop for bucket 51:
  bucket 50: 50%
  bucket 51: 10%
  bucket 50: 60%
  Sorting block time: 00:00:21
Returning block of 33297177 for bucket 45
  Sorting block time: 00:00:32
Returning block of 54186687 for bucket 44
Getting block 52 of 63
  Reserving size (73061533) for bucket 52
  Calculating Z arrays for bucket 52
  Entering block accumulator loop for bucket 52:
  bucket 51: 20%
Getting block 53 of 63
  Reserving size (73061533) for bucket 53
  Calculating Z arrays for bucket 53
  Entering block accumulator loop for bucket 53:
  bucket 50: 70%
  bucket 52: 10%
  bucket 51: 30%
  bucket 53: 10%
  bucket 50: 80%
  bucket 52: 20%
  Sorting block time: 00:00:37
Returning block of 69123828 for bucket 46
  bucket 51: 40%
  bucket 53: 20%
Getting block 54 of 63
  Reserving size (73061533) for bucket 54
  Calculating Z arrays for bucket 54
  Entering block accumulator loop for bucket 54:
  Sorting block time: 00:00:32
Returning block of 54999863 for bucket 47
  bucket 50: 90%
  bucket 52: 30%
  bucket 51: 50%
Getting block 55 of 63
  Reserving size (73061533) for bucket 55
  Calculating Z arrays for bucket 55
  Entering block accumulator loop for bucket 55:
  Sorting block time: 00:00:23
Returning block of 35227926 for bucket 49
  bucket 53: 30%
Getting block 56 of 63
  Reserving size (73061533) for bucket 56
  Calculating Z arrays for bucket 56
  Entering block accumulator loop for bucket 56:
  bucket 50: 100%
  Sorting block of length 56591646 for bucket 50
  (Using difference cover)
  bucket 54: 10%
  bucket 52: 40%
  bucket 51: 60%
  bucket 55: 10%
  bucket 53: 40%
  bucket 56: 10%
  Sorting block time: 00:00:39
Returning block of 58918040 for bucket 48
  bucket 54: 20%
  bucket 52: 50%
  bucket 51: 70%
  bucket 55: 20%
Getting block 57 of 63
  Reserving size (73061533) for bucket 57
  Calculating Z arrays for bucket 57
  Entering block accumulator loop for bucket 57:
  bucket 56: 20%
  bucket 53: 50%
  bucket 52: 60%
  bucket 54: 30%
  bucket 51: 80%
  bucket 57: 10%
  bucket 55: 30%
  bucket 56: 30%
  bucket 52: 70%
  bucket 53: 60%
  bucket 54: 40%
  bucket 51: 90%
  bucket 57: 20%
  bucket 55: 40%
  bucket 56: 40%
  bucket 52: 80%
  bucket 54: 50%
  bucket 53: 70%
  bucket 51: 100%
  Sorting block of length 51664587 for bucket 51
  (Using difference cover)
  bucket 57: 30%
  bucket 55: 50%
  bucket 56: 50%
  bucket 52: 90%
  bucket 54: 60%
  bucket 53: 80%
  bucket 57: 40%
  bucket 55: 60%
  bucket 52: 100%
  Sorting block of length 40503967 for bucket 52
  (Using difference cover)
  bucket 56: 60%
  bucket 54: 70%
  bucket 53: 90%
  bucket 57: 50%
  bucket 55: 70%
  bucket 56: 70%
  bucket 54: 80%
  bucket 53: 100%
  Sorting block of length 57807797 for bucket 53
  (Using difference cover)
  bucket 57: 60%
  bucket 55: 80%
  Sorting block time: 00:00:36
Returning block of 56591647 for bucket 50
  bucket 56: 80%
  bucket 54: 90%
Getting block 58 of 63
  Reserving size (73061533) for bucket 58
  Calculating Z arrays for bucket 58
  Entering block accumulator loop for bucket 58:
  bucket 57: 70%
  bucket 55: 90%
  bucket 56: 90%
  bucket 54: 100%
  Sorting block of length 58611397 for bucket 54
  (Using difference cover)
  bucket 58: 10%
  bucket 57: 80%
  bucket 55: 100%
  Sorting block of length 29577643 for bucket 55
  (Using difference cover)
  bucket 56: 100%
  Sorting block of length 59645600 for bucket 56
  (Using difference cover)
  bucket 58: 20%
  bucket 57: 90%
  bucket 58: 30%
  bucket 57: 100%
  Sorting block of length 17369491 for bucket 57
  (Using difference cover)
  Sorting block time: 00:00:26
Returning block of 40503968 for bucket 52
Getting block 59 of 63
  Reserving size (73061533) for bucket 59
  Calculating Z arrays for bucket 59
  Entering block accumulator loop for bucket 59:
  bucket 58: 40%
  bucket 59: 10%
  bucket 58: 50%
  Sorting block time: 00:00:42
Returning block of 51664588 for bucket 51
  Sorting block time: 00:00:11
Returning block of 17369492 for bucket 57
  bucket 59: 20%
Getting block 60 of 63
  Reserving size (73061533) for bucket 60
  Calculating Z arrays for bucket 60
  Entering block accumulator loop for bucket 60:
Getting block 61 of 63
  Reserving size (73061533) for bucket 61
  Calculating Z arrays for bucket 61
  Entering block accumulator loop for bucket 61:
  bucket 58: 60%
  Sorting block time: 00:00:34
Returning block of 57807798 for bucket 53
  bucket 59: 30%
  bucket 60: 10%
  bucket 61: 10%
  bucket 58: 70%
Getting block 62 of 63
  Reserving size (73061533) for bucket 62
  Calculating Z arrays for bucket 62
  Entering block accumulator loop for bucket 62:
  bucket 59: 40%
  bucket 60: 20%
  Sorting block time: 00:00:28
Returning block of 29577644 for bucket 55
  bucket 61: 20%
Getting block 63 of 63
  Reserving size (73061533) for bucket 63
  Calculating Z arrays for bucket 63
  Entering block accumulator loop for bucket 63:
  bucket 58: 80%
  bucket 62: 10%
  bucket 59: 50%
  bucket 60: 30%
  bucket 63: 10%
  bucket 61: 30%
  bucket 62: 20%
  Sorting block time: 00:00:33
Returning block of 59645601 for bucket 56
  bucket 58: 90%
  Sorting block time: 00:00:37
Returning block of 58611398 for bucket 54
  bucket 63: 20%
  bucket 59: 60%
  bucket 60: 40%
  bucket 61: 40%
  bucket 62: 30%
  bucket 58: 100%
  Sorting block of length 54867705 for bucket 58
  (Using difference cover)
  bucket 63: 30%
  bucket 59: 70%
  bucket 60: 50%
  bucket 61: 50%
  bucket 62: 40%
  bucket 63: 40%
  bucket 59: 80%
  bucket 60: 60%
  bucket 63: 50%
  bucket 61: 60%
  bucket 62: 50%
  bucket 63: 60%
  bucket 59: 90%
  bucket 60: 70%
  bucket 61: 70%
  bucket 62: 60%
  bucket 63: 70%
  bucket 59: 100%
  Sorting block of length 66017867 for bucket 59
  (Using difference cover)
  bucket 60: 80%
  bucket 62: 70%
  bucket 61: 80%
  bucket 63: 80%
  bucket 60: 90%
  bucket 63: 90%
  bucket 62: 80%
  bucket 61: 90%
  bucket 63: 100%
  Sorting block of length 22522733 for bucket 63
  (Using difference cover)
  bucket 60: 100%
  Sorting block of length 60780494 for bucket 60
  (Using difference cover)
  bucket 62: 90%
  bucket 61: 100%
  Sorting block of length 60317285 for bucket 61
  (Using difference cover)
  Sorting block time: 00:00:28
Returning block of 54867706 for bucket 58
  bucket 62: 100%
  Sorting block of length 64716020 for bucket 62
  (Using difference cover)
  Sorting block time: 00:00:12
Returning block of 22522734 for bucket 63
  Sorting block time: 00:00:33
Returning block of 60317286 for bucket 61
  Sorting block time: 00:00:45
Returning block of 66017868 for bucket 59
  Sorting block time: 00:00:42
Returning block of 60780495 for bucket 60
  Sorting block time: 00:00:39
Returning block of 64716021 for bucket 62
Exited Ebwt loop
fchr[A]: 0
fchr[C]: 923878813
fchr[G]: 1557575547
fchr[T]: 2194298091
fchr[$]: 3117292070
Exiting Ebwt::buildToDisk()
Returning from initFromVector
Wrote 1043292532 bytes to primary EBWT file: GCA_009914755.4.1.bt2
Wrote 779323024 bytes to secondary EBWT file: GCA_009914755.4.2.bt2
Re-opening _in1 and _in2 as input streams
Returning from Ebwt constructor
Headers:
    len: 3117292070
    bwtLen: 3117292071
    sz: 779323018
    bwtSz: 779323018
    lineRate: 6
    offRate: 4
    offMask: 0xfffffff0
    ftabChars: 10
    eftabLen: 20
    eftabSz: 80
    ftabLen: 1048577
    ftabSz: 4194308
    offsLen: 194830755
    offsSz: 779323020
    lineSz: 64
    sideSz: 64
    sideBwtSz: 48
    sideBwtLen: 192
    numSides: 16235897
    numLines: 16235897
    ebwtTotLen: 1039097408
    ebwtTotSz: 1039097408
    color: 0
    reverse: 0
Total time for call to driver() for forward index: 00:16:47
Reading reference sizes
  Time reading reference sizes: 00:00:24
Calculating joined length
Writing header
Reserving space for joined string
Joining reference sequences
  Time to join reference sequences: 00:02:08
  Time to reverse reference sequence: 00:00:03
bmax according to bmaxDivN setting: 97415377
Using parameters --bmax 73061533 --dcv 1024
  Doing ahead-of-time memory usage test
  Passed!  Constructing with these parameters: --bmax 73061533 --dcv 1024
Constructing suffix-array element generator
Building DifferenceCoverSample
  Building sPrime
  Building sPrimeOrder
  V-Sorting samples
  V-Sorting samples time: 00:00:42
  Allocating rank array
  Ranking v-sort output
  Ranking v-sort output time: 00:00:25
  Invoking Larsson-Sadakane on ranks
  Invoking Larsson-Sadakane on ranks time: 00:00:41
  Sanity-checking and returning
Building samples
Reserving space for 86 sample suffixes
Generating random suffixes
QSorting 86 sample offsets, eliminating duplicates
QSorting sample offsets, eliminating duplicates time: 00:00:00
Multikey QSorting 86 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 9, merged 39; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 5, merged 6; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 5, merged 2; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 2, merged 2; iterating...
Splitting and merging
  Splitting and merging time: 00:00:00
Split 1, merged 1; iterating...
Avg bucket size: 5.28355e+07 (target: 73061532)
Converting suffix-array elements to index image
Allocating ftab, absorbFtab
Entering Ebwt loop
Getting block 1 of 59
  Reserving size (73061533) for bucket 1
Getting block 2 of 59
  Reserving size (73061533) for bucket 2
Getting block 3 of 59
Getting block 4 of 59
Getting block 5 of 59
Getting block 6 of 59
Getting block 7 of 59
Getting block 8 of 59
  Calculating Z arrays for bucket 1
  Reserving size (73061533) for bucket 3
  Calculating Z arrays for bucket 2
  Reserving size (73061533) for bucket 4
  Reserving size (73061533) for bucket 5
  Reserving size (73061533) for bucket 6
  Reserving size (73061533) for bucket 7
  Reserving size (73061533) for bucket 8
  Entering block accumulator loop for bucket 1:
  Calculating Z arrays for bucket 3
  Entering block accumulator loop for bucket 2:
  Calculating Z arrays for bucket 4
  Calculating Z arrays for bucket 6
  Calculating Z arrays for bucket 5
  Calculating Z arrays for bucket 8
  Entering block accumulator loop for bucket 5:
  Entering block accumulator loop for bucket 3:
  Entering block accumulator loop for bucket 8:
  Entering block accumulator loop for bucket 4:
  Entering block accumulator loop for bucket 6:
  Calculating Z arrays for bucket 7
  Entering block accumulator loop for bucket 7:
  bucket 2: 10%
  bucket 1: 10%
  bucket 3: 10%
  bucket 5: 10%
  bucket 4: 10%
  bucket 8: 10%
  bucket 7: 10%
  bucket 6: 10%
  bucket 2: 20%
  bucket 1: 20%
  bucket 3: 20%
  bucket 5: 20%
  bucket 4: 20%
  bucket 6: 20%
  bucket 7: 20%
  bucket 8: 20%
  bucket 1: 30%
  bucket 2: 30%
  bucket 3: 30%
  bucket 5: 30%
  bucket 4: 30%
  bucket 6: 30%
  bucket 7: 30%
  bucket 8: 30%
  bucket 1: 40%
  bucket 2: 40%
  bucket 3: 40%
  bucket 5: 40%
  bucket 4: 40%
  bucket 1: 50%
  bucket 2: 50%
  bucket 6: 40%
  bucket 7: 40%
  bucket 8: 40%
  bucket 3: 50%
  bucket 5: 50%
  bucket 4: 50%
  bucket 1: 60%
  bucket 2: 60%
  bucket 6: 50%
  bucket 7: 50%
  bucket 8: 50%
  bucket 3: 60%
  bucket 5: 60%
  bucket 4: 60%
  bucket 1: 70%
  bucket 2: 70%
  bucket 6: 60%
  bucket 7: 60%
  bucket 3: 70%
  bucket 8: 60%
  bucket 5: 70%
  bucket 1: 80%
  bucket 4: 70%
  bucket 2: 80%
  bucket 6: 70%
  bucket 1: 90%
  bucket 3: 80%
  bucket 5: 80%
  bucket 7: 70%
  bucket 2: 90%
  bucket 4: 80%
  bucket 8: 70%
  bucket 1: 100%
  Sorting block of length 61135380 for bucket 1
  (Using difference cover)
  bucket 3: 90%
  bucket 5: 90%
  bucket 6: 80%
  bucket 2: 100%
  Sorting block of length 47566633 for bucket 2
  (Using difference cover)
  bucket 7: 80%
  bucket 4: 90%
  bucket 8: 80%
  bucket 3: 100%
  Sorting block of length 57226607 for bucket 3
  (Using difference cover)
  bucket 5: 100%
  Sorting block of length 20489490 for bucket 5
  (Using difference cover)
  bucket 6: 90%
  bucket 4: 100%
  Sorting block of length 70231503 for bucket 4
  (Using difference cover)
  bucket 7: 90%
  bucket 8: 90%
  bucket 6: 100%
  Sorting block of length 59377120 for bucket 6
  (Using difference cover)
  bucket 7: 100%
  Sorting block of length 68440970 for bucket 7
  (Using difference cover)
  bucket 8: 100%
  Sorting block of length 69973728 for bucket 8
  (Using difference cover)
  Sorting block time: 00:00:13
Returning block of 20489491 for bucket 5
Getting block 9 of 59
  Reserving size (73061533) for bucket 9
  Calculating Z arrays for bucket 9
  Entering block accumulator loop for bucket 9:
  bucket 9: 10%
  bucket 9: 20%
  bucket 9: 30%
  Sorting block time: 00:00:31
Returning block of 47566634 for bucket 2
  bucket 9: 40%
  Sorting block time: 00:00:32
Returning block of 61135381 for bucket 1
Getting block 10 of 59
  Reserving size (73061533) for bucket 10
  Calculating Z arrays for bucket 10
  Entering block accumulator loop for bucket 10:
  Sorting block time: 00:00:31
Returning block of 57226608 for bucket 3
Getting block 11 of 59
  Reserving size (73061533) for bucket 11
  Calculating Z arrays for bucket 11
  Entering block accumulator loop for bucket 11:
  bucket 9: 50%
  Sorting block time: 00:00:29
Returning block of 59377121 for bucket 6
  bucket 10: 10%
Getting block 12 of 59
  Reserving size (73061533) for bucket 12
  Calculating Z arrays for bucket 12
  Entering block accumulator loop for bucket 12:
  bucket 11: 10%
  bucket 9: 60%
Getting block 13 of 59
  Reserving size (73061533) for bucket 13
  Calculating Z arrays for bucket 13
  Entering block accumulator loop for bucket 13:
  bucket 12: 10%
  bucket 10: 20%
  bucket 11: 20%
  bucket 9: 70%
  bucket 13: 10%
  bucket 12: 20%
  bucket 10: 30%
  Sorting block time: 00:00:38
Returning block of 68440971 for bucket 7
  bucket 11: 30%
  bucket 9: 80%
  bucket 13: 20%
  bucket 12: 30%
  bucket 10: 40%
Getting block 14 of 59
  Reserving size (73061533) for bucket 14
  Calculating Z arrays for bucket 14
  Entering block accumulator loop for bucket 14:
  bucket 11: 40%
  bucket 9: 90%
  bucket 13: 30%
  Sorting block time: 00:00:43
Returning block of 69973729 for bucket 8
  bucket 10: 50%
  bucket 12: 40%
  bucket 14: 10%
  bucket 9: 100%
  Sorting block of length 65424881 for bucket 9
  (Using difference cover)
  bucket 11: 50%
  bucket 13: 40%
Getting block 15 of 59
  Reserving size (73061533) for bucket 15
  Calculating Z arrays for bucket 15
  Entering block accumulator loop for bucket 15:
  bucket 10: 60%
  bucket 12: 50%
  bucket 14: 20%
  bucket 11: 60%
  bucket 15: 10%
  bucket 13: 50%
  bucket 10: 70%
  bucket 12: 60%
  Sorting block time: 00:00:55
Returning block of 70231504 for bucket 4
  bucket 14: 30%
  bucket 11: 70%
  bucket 15: 20%
  bucket 13: 60%
Getting block 16 of 59
  Reserving size (73061533) for bucket 16
  Calculating Z arrays for bucket 16
  Entering block accumulator loop for bucket 16:
  bucket 10: 80%
  bucket 12: 70%
  bucket 14: 40%
  bucket 11: 80%
  bucket 15: 30%
  bucket 13: 70%
  bucket 10: 90%
  bucket 16: 10%
  bucket 12: 80%
  bucket 14: 50%
  bucket 11: 90%
  bucket 15: 40%
  bucket 13: 80%
  bucket 10: 100%
  Sorting block of length 46877066 for bucket 10
  (Using difference cover)
  bucket 12: 90%
  bucket 16: 20%
  bucket 14: 60%
  bucket 11: 100%
  Sorting block of length 45535936 for bucket 11
  (Using difference cover)
  bucket 15: 50%
  bucket 13: 90%
  bucket 12: 100%
  Sorting block of length 42307292 for bucket 12
  (Using difference cover)
  bucket 16: 30%
  bucket 14: 70%
  bucket 15: 60%
  bucket 13: 100%
  Sorting block of length 50404622 for bucket 13
  (Using difference cover)
  bucket 16: 40%
  bucket 14: 80%
  bucket 15: 70%
  bucket 16: 50%
  bucket 14: 90%
  bucket 15: 80%
  bucket 16: 60%
  bucket 14: 100%
  Sorting block of length 57766806 for bucket 14
  (Using difference cover)
  bucket 15: 90%
  bucket 16: 70%
  bucket 15: 100%
  Sorting block of length 17377650 for bucket 15
  (Using difference cover)
  bucket 16: 80%
  Sorting block time: 00:00:39
Returning block of 65424882 for bucket 9
  bucket 16: 90%
Getting block 17 of 59
  Reserving size (73061533) for bucket 17
  Calculating Z arrays for bucket 17
  Entering block accumulator loop for bucket 17:
  Sorting block time: 00:00:27
Returning block of 46877067 for bucket 10
Getting block 18 of 59
  Reserving size (73061533) for bucket 18
  Calculating Z arrays for bucket 18
  Entering block accumulator loop for bucket 18:
  bucket 16: 100%
  Sorting block of length 69295816 for bucket 16
  (Using difference cover)
  bucket 17: 10%
  Sorting block time: 00:00:13
Returning block of 17377651 for bucket 15
Getting block 19 of 59
  Reserving size (73061533) for bucket 19
  Calculating Z arrays for bucket 19
  Entering block accumulator loop for bucket 19:
  bucket 18: 10%
  bucket 17: 20%
  Sorting block time: 00:00:33
Returning block of 45535937 for bucket 11
  bucket 19: 10%
Getting block 20 of 59
  Reserving size (73061533) for bucket 20
  Calculating Z arrays for bucket 20
  Entering block accumulator loop for bucket 20:
  bucket 17: 30%
  Sorting block time: 00:00:30
Returning block of 50404623 for bucket 13
  bucket 18: 20%
  Sorting block time: 00:00:33
Returning block of 42307293 for bucket 12
Getting block 21 of 59
  Reserving size (73061533) for bucket 21
  Calculating Z arrays for bucket 21
  Entering block accumulator loop for bucket 21:
Getting block 22 of 59
  Reserving size (73061533) for bucket 22
  Calculating Z arrays for bucket 22
  Entering block accumulator loop for bucket 22:
  bucket 19: 20%
  bucket 20: 10%
  bucket 17: 40%
  bucket 18: 30%
  bucket 21: 10%
  bucket 22: 10%
  bucket 19: 30%
  bucket 20: 20%
  bucket 17: 50%
  bucket 18: 40%
  bucket 21: 20%
  bucket 22: 20%
  bucket 19: 40%
  bucket 17: 60%
  bucket 20: 30%
  bucket 18: 50%
  bucket 21: 30%
  Sorting block time: 00:00:36
Returning block of 57766807 for bucket 14
  bucket 22: 30%
  bucket 19: 50%
  bucket 17: 70%
  bucket 20: 40%
Getting block 23 of 59
  Reserving size (73061533) for bucket 23
  Calculating Z arrays for bucket 23
  Entering block accumulator loop for bucket 23:
  bucket 18: 60%
  bucket 21: 40%
  bucket 19: 60%
  bucket 22: 40%
  bucket 17: 80%
  bucket 20: 50%
  bucket 23: 10%
  bucket 18: 70%
  bucket 21: 50%
  bucket 17: 90%
  bucket 19: 70%
  bucket 22: 50%
  bucket 20: 60%
  bucket 23: 20%
  bucket 21: 60%
  bucket 18: 80%
  bucket 17: 100%
  Sorting block of length 45992616 for bucket 17
  (Using difference cover)
  bucket 19: 80%
  bucket 22: 60%
  bucket 20: 70%
  Sorting block time: 00:00:36
Returning block of 69295817 for bucket 16
  bucket 23: 30%
  bucket 21: 70%
  bucket 19: 90%
  bucket 18: 90%
  bucket 20: 80%
  bucket 22: 70%
Getting block 24 of 59
  Reserving size (73061533) for bucket 24
  Calculating Z arrays for bucket 24
  Entering block accumulator loop for bucket 24:
  bucket 23: 40%
  bucket 21: 80%
  bucket 19: 100%
  Sorting block of length 54247990 for bucket 19
  (Using difference cover)
  bucket 18: 100%
  Sorting block of length 52970266 for bucket 18
  (Using difference cover)
  bucket 20: 90%
  bucket 22: 80%
  bucket 24: 10%
  bucket 23: 50%
  bucket 21: 90%
  bucket 20: 100%
  Sorting block of length 27580145 for bucket 20
  (Using difference cover)
  bucket 22: 90%
  bucket 23: 60%
  bucket 24: 20%
  bucket 21: 100%
  Sorting block of length 72772167 for bucket 21
  (Using difference cover)
  bucket 22: 100%
  Sorting block of length 60502112 for bucket 22
  (Using difference cover)
  bucket 23: 70%
  bucket 24: 30%
  bucket 23: 80%
  bucket 24: 40%
  Sorting block time: 00:00:24
Returning block of 45992617 for bucket 17
  bucket 23: 90%
Getting block 25 of 59
  Reserving size (73061533) for bucket 25
  Calculating Z arrays for bucket 25
  Entering block accumulator loop for bucket 25:
  bucket 24: 50%
  Sorting block time: 00:00:16
Returning block of 27580146 for bucket 20
Getting block 26 of 59
  Reserving size (73061533) for bucket 26
  Calculating Z arrays for bucket 26
  Entering block accumulator loop for bucket 26:
  bucket 23: 100%
  Sorting block of length 18841338 for bucket 23
  (Using difference cover)
  bucket 24: 60%
  bucket 25: 10%
  bucket 26: 10%
  bucket 24: 70%
  bucket 25: 20%
  Sorting block time: 00:00:28
Returning block of 52970267 for bucket 18
  bucket 26: 20%
  bucket 24: 80%
  Sorting block time: 00:00:31
Returning block of 54247991 for bucket 19
Getting block 27 of 59
  Reserving size (73061533) for bucket 27
  Calculating Z arrays for bucket 27
  Entering block accumulator loop for bucket 27:
  bucket 25: 30%
  Sorting block time: 00:00:10
Returning block of 18841339 for bucket 23
Getting block 28 of 59
  Reserving size (73061533) for bucket 28
  Calculating Z arrays for bucket 28
  Entering block accumulator loop for bucket 28:
Getting block 29 of 59
  Reserving size (73061533) for bucket 29
  Calculating Z arrays for bucket 29
  Entering block accumulator loop for bucket 29:
  bucket 24: 90%
  bucket 26: 30%
  bucket 27: 10%
  bucket 25: 40%
  bucket 28: 10%
  bucket 29: 10%
  bucket 24: 100%
  Sorting block of length 56632658 for bucket 24
  (Using difference cover)
  bucket 26: 40%
  bucket 27: 20%
  bucket 25: 50%
  Sorting block time: 00:00:30
Returning block of 60502113 for bucket 22
  bucket 28: 20%
  bucket 29: 20%
Getting block 30 of 59
  Reserving size (73061533) for bucket 30
  Calculating Z arrays for bucket 30
  Entering block accumulator loop for bucket 30:
  bucket 26: 50%
  bucket 25: 60%
  bucket 27: 30%
  bucket 28: 30%
  bucket 29: 30%
  bucket 30: 10%
  Sorting block time: 00:00:39
Returning block of 72772168 for bucket 21
  bucket 26: 60%
  bucket 25: 70%
  bucket 27: 40%
Getting block 31 of 59
  Reserving size (73061533) for bucket 31
  Calculating Z arrays for bucket 31
  Entering block accumulator loop for bucket 31:
  bucket 28: 40%
  bucket 29: 40%
  bucket 30: 20%
  bucket 26: 70%
  bucket 25: 80%
  bucket 27: 50%
  bucket 28: 50%
  bucket 31: 10%
  bucket 29: 50%
  bucket 30: 30%
  bucket 25: 90%
  bucket 26: 80%
  bucket 27: 60%
  bucket 28: 60%
  bucket 29: 60%
  bucket 30: 40%
  bucket 31: 20%
  bucket 25: 100%
  Sorting block of length 19666678 for bucket 25
  (Using difference cover)
  bucket 26: 90%
  bucket 27: 70%
  bucket 28: 70%
  bucket 29: 70%
  bucket 30: 50%
  bucket 26: 100%
  Sorting block of length 72639097 for bucket 26
  (Using difference cover)
  bucket 27: 80%
  bucket 31: 30%
  bucket 28: 80%
  bucket 29: 80%
  bucket 30: 60%
  bucket 27: 90%
  Sorting block time: 00:00:10
Returning block of 19666679 for bucket 25
Getting block 32 of 59
  Reserving size (73061533) for bucket 32
  Calculating Z arrays for bucket 32
  Entering block accumulator loop for bucket 32:
  bucket 31: 40%
  bucket 28: 90%
  bucket 29: 90%
  bucket 30: 70%
  bucket 27: 100%
  Sorting block of length 35615825 for bucket 27
  (Using difference cover)
  Sorting block time: 00:00:37
Returning block of 56632659 for bucket 24
  bucket 32: 10%
  bucket 28: 100%
  Sorting block of length 72591177 for bucket 28
  (Using difference cover)
  bucket 31: 50%
  bucket 29: 100%
  Sorting block of length 68582167 for bucket 29
  (Using difference cover)
Getting block 33 of 59
  Reserving size (73061533) for bucket 33
  Calculating Z arrays for bucket 33
  Entering block accumulator loop for bucket 33:
  bucket 30: 80%
  bucket 32: 20%
  bucket 31: 60%
  bucket 33: 10%
  bucket 30: 90%
  bucket 32: 30%
  bucket 33: 20%
  bucket 30: 100%
  Sorting block of length 25759242 for bucket 30
  (Using difference cover)
  bucket 31: 70%
  bucket 32: 40%
  bucket 33: 30%
  bucket 31: 80%
  bucket 32: 50%
  Sorting block time: 00:00:19
Returning block of 35615826 for bucket 27
Getting block 34 of 59
  Reserving size (73061533) for bucket 34
  Calculating Z arrays for bucket 34
  Entering block accumulator loop for bucket 34:
  bucket 33: 40%
  bucket 32: 60%
  bucket 31: 90%
  bucket 34: 10%
  bucket 33: 50%
  bucket 32: 70%
  Sorting block time: 00:00:15
Returning block of 25759243 for bucket 30
  bucket 34: 20%
  bucket 31: 100%
  Sorting block of length 61552086 for bucket 31
  (Using difference cover)
Getting block 35 of 59
  Reserving size (73061533) for bucket 35
  Calculating Z arrays for bucket 35
  Entering block accumulator loop for bucket 35:
  Sorting block time: 00:00:39
Returning block of 72639098 for bucket 26
  bucket 33: 60%
  bucket 32: 80%
  bucket 34: 30%
Getting block 36 of 59
  Reserving size (73061533) for bucket 36
  Calculating Z arrays for bucket 36
  Entering block accumulator loop for bucket 36:
  bucket 35: 10%
  bucket 33: 70%
  bucket 32: 90%
  bucket 36: 10%
  bucket 34: 40%
  bucket 35: 20%
  bucket 33: 80%
  bucket 32: 100%
  Sorting block of length 57432245 for bucket 32
  (Using difference cover)
  bucket 36: 20%
  bucket 34: 50%
  bucket 35: 30%
  bucket 33: 90%
  bucket 36: 30%
  bucket 34: 60%
  bucket 35: 40%
  bucket 33: 100%
  Sorting block of length 64389779 for bucket 33
  (Using difference cover)
  Sorting block time: 00:00:47
Returning block of 72591178 for bucket 28
  bucket 36: 40%
  bucket 34: 70%
Getting block 37 of 59
  Reserving size (73061533) for bucket 37
  Calculating Z arrays for bucket 37
  Entering block accumulator loop for bucket 37:
  bucket 35: 50%
  Sorting block time: 00:00:50
Returning block of 68582168 for bucket 29
  bucket 36: 50%
  bucket 34: 80%
  bucket 37: 10%
Getting block 38 of 59
  Reserving size (73061533) for bucket 38
  Calculating Z arrays for bucket 38
  Entering block accumulator loop for bucket 38:
  bucket 35: 60%
  bucket 36: 60%
  bucket 34: 90%
  bucket 37: 20%
  bucket 38: 10%
  bucket 35: 70%
  bucket 36: 70%
  bucket 34: 100%
  Sorting block of length 59066616 for bucket 34
  (Using difference cover)
  bucket 37: 30%
  bucket 35: 80%
  bucket 38: 20%
  Sorting block time: 00:00:39
Returning block of 61552087 for bucket 31
  bucket 36: 80%
  bucket 37: 40%
  bucket 35: 90%
  bucket 38: 30%
Getting block 39 of 59
  Reserving size (73061533) for bucket 39
  Calculating Z arrays for bucket 39
  Entering block accumulator loop for bucket 39:
  Sorting block time: 00:00:31
Returning block of 57432246 for bucket 32
  bucket 36: 90%
  bucket 37: 50%
  bucket 35: 100%
  Sorting block of length 61678638 for bucket 35
  (Using difference cover)
Getting block 40 of 59
  Reserving size (73061533) for bucket 40
  Calculating Z arrays for bucket 40
  Entering block accumulator loop for bucket 40:
  bucket 38: 40%
  bucket 39: 10%
  bucket 36: 100%
  Sorting block of length 13940627 for bucket 36
  (Using difference cover)
  bucket 37: 60%
  bucket 40: 10%
  bucket 38: 50%
  bucket 39: 20%
  bucket 37: 70%
  bucket 40: 20%
  Sorting block time: 00:00:07
Returning block of 13940628 for bucket 36
Getting block 41 of 59
  Reserving size (73061533) for bucket 41
  Calculating Z arrays for bucket 41
  Entering block accumulator loop for bucket 41:
  bucket 38: 60%
  bucket 39: 30%
  Sorting block time: 00:00:37
Returning block of 64389780 for bucket 33
  bucket 37: 80%
Getting block 42 of 59
  Reserving size (73061533) for bucket 42
  Calculating Z arrays for bucket 42
  Entering block accumulator loop for bucket 42:
  bucket 40: 30%
  bucket 38: 70%
  bucket 41: 10%
  bucket 39: 40%
  bucket 37: 90%
  bucket 40: 40%
  bucket 42: 10%
  bucket 38: 80%
  bucket 41: 20%
  bucket 39: 50%
  bucket 37: 100%
  Sorting block of length 68272344 for bucket 37
  (Using difference cover)
  bucket 40: 50%
  bucket 38: 90%
  bucket 41: 30%
  bucket 42: 20%
  bucket 39: 60%
  Sorting block time: 00:00:34
Returning block of 59066617 for bucket 34
  bucket 40: 60%
Getting block 43 of 59
  Reserving size (73061533) for bucket 43
  Calculating Z arrays for bucket 43
  Entering block accumulator loop for bucket 43:
  bucket 38: 100%
  Sorting block of length 71390673 for bucket 38
  (Using difference cover)
  bucket 41: 40%
  bucket 39: 70%
  bucket 42: 30%
  bucket 43: 10%
  bucket 40: 70%
  bucket 41: 50%
  bucket 39: 80%
  bucket 42: 40%
  bucket 43: 20%
  bucket 40: 80%
  bucket 41: 60%
  bucket 39: 90%
  bucket 42: 50%
  bucket 43: 30%
  bucket 40: 90%
  bucket 41: 70%
  bucket 39: 100%
  Sorting block of length 64852052 for bucket 39
  (Using difference cover)
  Sorting block time: 00:00:45
Returning block of 61678639 for bucket 35
  bucket 43: 40%
  bucket 42: 60%
Getting block 44 of 59
  Reserving size (73061533) for bucket 44
  Calculating Z arrays for bucket 44
  Entering block accumulator loop for bucket 44:
  bucket 40: 100%
  Sorting block of length 59439881 for bucket 40
  (Using difference cover)
  bucket 41: 80%
  bucket 43: 50%
  bucket 44: 10%
  bucket 42: 70%
  bucket 41: 90%
  bucket 43: 60%
  bucket 44: 20%
  bucket 42: 80%
  bucket 41: 100%
  Sorting block of length 32120240 for bucket 41
  (Using difference cover)
  bucket 43: 70%
  bucket 44: 30%
  bucket 42: 90%
  bucket 43: 80%
  bucket 44: 40%
  bucket 43: 90%
  bucket 42: 100%
  Sorting block of length 47218374 for bucket 42
  (Using difference cover)
  bucket 44: 50%
  Sorting block time: 00:00:50
Returning block of 68272345 for bucket 37
  bucket 43: 100%
  Sorting block of length 67212272 for bucket 43
  (Using difference cover)
  bucket 44: 60%
Getting block 45 of 59
  Reserving size (73061533) for bucket 45
  Calculating Z arrays for bucket 45
  Entering block accumulator loop for bucket 45:
  bucket 45: 10%
  Sorting block time: 00:00:22
Returning block of 32120241 for bucket 41
  bucket 44: 70%
Getting block 46 of 59
  Reserving size (73061533) for bucket 46
  Calculating Z arrays for bucket 46
  Entering block accumulator loop for bucket 46:
  Sorting block time: 00:00:54
Returning block of 71390674 for bucket 38
  Sorting block time: 00:00:36
Returning block of 59439882 for bucket 40
  Sorting block time: 00:00:39
Returning block of 64852053 for bucket 39
  bucket 44: 80%
  bucket 45: 20%
  bucket 46: 10%
Getting block 47 of 59
  Reserving size (73061533) for bucket 47
  Calculating Z arrays for bucket 47
  Entering block accumulator loop for bucket 47:
Getting block 48 of 59
  Reserving size (73061533) for bucket 48
  Calculating Z arrays for bucket 48
  Entering block accumulator loop for bucket 48:
Getting block 49 of 59
  Reserving size (73061533) for bucket 49
  Calculating Z arrays for bucket 49
  Entering block accumulator loop for bucket 49:
  bucket 44: 90%
  bucket 45: 30%
  bucket 46: 20%
  bucket 47: 10%
  bucket 48: 10%
  bucket 49: 10%
  bucket 44: 100%
  Sorting block of length 70781936 for bucket 44
  (Using difference cover)
  bucket 45: 40%
  bucket 46: 30%
  bucket 47: 20%
  bucket 48: 20%
  bucket 49: 20%
  bucket 45: 50%
  bucket 46: 40%
  Sorting block time: 00:00:30
Returning block of 47218375 for bucket 42
  bucket 47: 30%
  bucket 49: 30%
  bucket 48: 30%
Getting block 50 of 59
  Reserving size (73061533) for bucket 50
  Calculating Z arrays for bucket 50
  Entering block accumulator loop for bucket 50:
  bucket 45: 60%
  bucket 46: 50%
  bucket 47: 40%
  bucket 48: 40%
  bucket 49: 40%
  bucket 50: 10%
  bucket 45: 70%
  bucket 46: 60%
  bucket 47: 50%
  bucket 48: 50%
  bucket 49: 50%
  bucket 50: 20%
  bucket 45: 80%
  bucket 46: 70%
  bucket 47: 60%
  bucket 48: 60%
  bucket 49: 60%
  bucket 50: 30%
  bucket 45: 90%
  bucket 46: 80%
  bucket 47: 70%
  bucket 48: 70%
  bucket 49: 70%
  bucket 46: 90%
  bucket 45: 100%
  Sorting block of length 62440570 for bucket 45
  (Using difference cover)
  bucket 50: 40%
  bucket 47: 80%
  bucket 46: 100%
  Sorting block of length 45272198 for bucket 46
  (Using difference cover)
  bucket 48: 80%
  bucket 49: 80%
  bucket 50: 50%
  Sorting block time: 00:00:55
Returning block of 67212273 for bucket 43
  bucket 47: 90%
  bucket 49: 90%
  bucket 48: 90%
  bucket 50: 60%
Getting block 51 of 59
  Reserving size (73061533) for bucket 51
  Calculating Z arrays for bucket 51
  Entering block accumulator loop for bucket 51:
  bucket 47: 100%
  Sorting block of length 62419983 for bucket 47
  (Using difference cover)
  bucket 49: 100%
  Sorting block of length 29465220 for bucket 49
  (Using difference cover)
  bucket 48: 100%
  Sorting block of length 54224365 for bucket 48
  (Using difference cover)
  bucket 50: 70%
  bucket 51: 10%
  bucket 50: 80%
  bucket 51: 20%
  Sorting block time: 00:00:49
Returning block of 70781937 for bucket 44
  bucket 50: 90%
Getting block 52 of 59
  Reserving size (73061533) for bucket 52
  Calculating Z arrays for bucket 52
  Entering block accumulator loop for bucket 52:
  bucket 51: 30%
  bucket 50: 100%
  Sorting block of length 57542245 for bucket 50
  (Using difference cover)
  bucket 52: 10%
  Sorting block time: 00:00:16
Returning block of 29465221 for bucket 49
  bucket 51: 40%
Getting block 53 of 59
  Reserving size (73061533) for bucket 53
  Calculating Z arrays for bucket 53
  Entering block accumulator loop for bucket 53:
  Sorting block time: 00:00:29
Returning block of 45272199 for bucket 46
  bucket 52: 20%
Getting block 54 of 59
  Reserving size (73061533) for bucket 54
  Calculating Z arrays for bucket 54
  Entering block accumulator loop for bucket 54:
  bucket 51: 50%
  bucket 53: 10%
  bucket 52: 30%
  bucket 54: 10%
  bucket 51: 60%
  bucket 53: 20%
  Sorting block time: 00:00:29
Returning block of 54224366 for bucket 48
  bucket 52: 40%
  bucket 54: 20%
  bucket 51: 70%
Getting block 55 of 59
  Reserving size (73061533) for bucket 55
  Calculating Z arrays for bucket 55
  Entering block accumulator loop for bucket 55:
  Sorting block time: 00:00:45
Returning block of 62440571 for bucket 45
  bucket 53: 30%
  bucket 52: 50%
Getting block 56 of 59
  Reserving size (73061533) for bucket 56
  Calculating Z arrays for bucket 56
  Entering block accumulator loop for bucket 56:
  bucket 54: 30%
  bucket 55: 10%
  Sorting block time: 00:00:37
Returning block of 62419984 for bucket 47
  bucket 51: 80%
  bucket 53: 40%
  bucket 52: 60%
  bucket 56: 10%
  bucket 54: 40%
Getting block 57 of 59
  Reserving size (73061533) for bucket 57
  Calculating Z arrays for bucket 57
  Entering block accumulator loop for bucket 57:
  bucket 55: 20%
  bucket 51: 90%
  bucket 53: 50%
  bucket 57: 10%
  bucket 52: 70%
  bucket 54: 50%
  bucket 56: 20%
  bucket 55: 30%
  bucket 51: 100%
  Sorting block of length 68704561 for bucket 51
  (Using difference cover)
  bucket 53: 60%
  bucket 54: 60%
  bucket 56: 30%
  bucket 57: 20%
  bucket 52: 80%
  Sorting block time: 00:00:35
Returning block of 57542246 for bucket 50
  bucket 55: 40%
  bucket 53: 70%
  bucket 54: 70%
  bucket 56: 40%
  bucket 52: 90%
Getting block 58 of 59
  Reserving size (73061533) for bucket 58
  Calculating Z arrays for bucket 58
  Entering block accumulator loop for bucket 58:
  bucket 57: 30%
  bucket 55: 50%
  bucket 53: 80%
  bucket 54: 80%
  bucket 58: 10%
  bucket 52: 100%
  Sorting block of length 55999998 for bucket 52
  (Using difference cover)
  bucket 57: 40%
  bucket 56: 50%
  bucket 55: 60%
  bucket 53: 90%
  bucket 54: 90%
  bucket 58: 20%
  bucket 56: 60%
  bucket 57: 50%
  bucket 55: 70%
  bucket 53: 100%
  Sorting block of length 61840887 for bucket 53
  (Using difference cover)
  bucket 54: 100%
  Sorting block of length 28693855 for bucket 54
  (Using difference cover)
  bucket 58: 30%
  bucket 57: 60%
  bucket 56: 70%
  bucket 55: 80%
  bucket 58: 40%
  bucket 57: 70%
  bucket 56: 80%
  bucket 55: 90%
  bucket 58: 50%
  bucket 57: 80%
  bucket 56: 90%
  bucket 55: 100%
  Sorting block of length 58520972 for bucket 55
  (Using difference cover)
  bucket 58: 60%
  bucket 57: 90%
  bucket 56: 100%
  Sorting block of length 64897257 for bucket 56
  (Using difference cover)
  bucket 58: 70%
  bucket 57: 100%
  Sorting block of length 52968816 for bucket 57
  (Using difference cover)
  Sorting block time: 00:00:43
Returning block of 68704562 for bucket 51
  bucket 58: 80%
  Sorting block time: 00:00:26
Returning block of 28693856 for bucket 54
  Sorting block time: 00:00:34
Returning block of 55999999 for bucket 52
Getting block 59 of 59
  Reserving size (73061533) for bucket 59
  Calculating Z arrays for bucket 59
  Entering block accumulator loop for bucket 59:
  bucket 58: 90%
  bucket 59: 10%
  bucket 58: 100%
  Sorting block of length 48629766 for bucket 58
  (Using difference cover)
  bucket 59: 20%
  bucket 59: 30%
  bucket 59: 40%
  Sorting block time: 00:00:39
Returning block of 61840888 for bucket 53
  bucket 59: 50%
  bucket 59: 60%
  bucket 59: 70%
  Sorting block time: 00:00:29
Returning block of 52968817 for bucket 57
  Sorting block time: 00:00:37
Returning block of 58520973 for bucket 55
  bucket 59: 80%
  Sorting block time: 00:00:39
Returning block of 64897258 for bucket 56
  bucket 59: 90%
  bucket 59: 100%
  Sorting block of length 32498578 for bucket 59
  (Using difference cover)
  Sorting block time: 00:00:28
Returning block of 48629767 for bucket 58
  Sorting block time: 00:00:17
Returning block of 32498579 for bucket 59
Exited Ebwt loop
fchr[A]: 0
fchr[C]: 923878813
fchr[G]: 1557575547
fchr[T]: 2194298091
fchr[$]: 3117292070
Exiting Ebwt::buildToDisk()
Returning from initFromVector
Wrote 1043292532 bytes to primary EBWT file: GCA_009914755.4.rev.1.bt2
Wrote 779323024 bytes to secondary EBWT file: GCA_009914755.4.rev.2.bt2
Re-opening _in1 and _in2 as input streams
Returning from Ebwt constructor
Headers:
    len: 3117292070
    bwtLen: 3117292071
    sz: 779323018
    bwtSz: 779323018
    lineRate: 6
    offRate: 4
    offMask: 0xfffffff0
    ftabChars: 10
    eftabLen: 20
    eftabSz: 80
    ftabLen: 1048577
    ftabSz: 4194308
    offsLen: 194830755
    offsSz: 779323020
    lineSz: 64
    sideSz: 64
    sideBwtSz: 48
    sideBwtLen: 192
    numSides: 16235897
    numLines: 16235897
    ebwtTotLen: 1039097408
    ebwtTotSz: 1039097408
    color: 0
    reverse: 1
Total time for backward call to driver() for mirror index: 00:17:00