Mercurial > repos > dave > pipelign

comparison test-data/files/merge.log @ 0:9a3a2e04f47a draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author dave
date Mon, 10 Jun 2019 16:04:10 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:9a3a2e04f47a
1 inputfile = orig
2 2 x 70 - 70 d
3 outputhat23=1
4 treein = 0
5 compacttree = 0
6 stacksize: 8192 kb
7 generating a scoring matrix for nucleotide (dist=200) ... done
8 All-to-all alignment.
9 0 / 2 (by thread 0)
10 tbfast-pair (nuc) Version 7.407
11 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
12 1 thread(s)
13
14 outputhat23=1
15 Loading 'hat3.seed' ...
16 done.
17 Writing hat3 for iterative refinement
18 generating a scoring matrix for nucleotide (dist=200) ... done
19 Gap Penalty = -1.53, +0.00, +0.00
20 tbutree = 1, compacttree = 0
21 Constructing a UPGMA tree ...
22
23 0 / 2
24 done.
25
26 Progressive alignment ...
27
28 STEP 1 /1 (thread 0)
29 done.
30 tbfast (nuc) Version 7.407
31 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
32 1 thread(s)
33
34 minimumweight = 0.000010
35 autosubalignment = 0.000000
36 nthread = 1
37 randomseed = 0
38 blosum 62 / kimura 200
39 poffset = 0
40 niter = 1
41 sueff_global = 0.100000
42 nadd = 1
43 Loading 'hat3' ... done.
44 generating a scoring matrix for nucleotide (dist=200) ... done
45
46
47 0 / 2
48 Segment 1/ 1 1- 72
49 001-0000-1 (thread 1) identical
50
51 Converged.
52
53 Reached 1
54 done
55 dvtditr (nuc) Version 7.407
56 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
57 1 thread(s)
58
59
60 Strategy:
61 L-INS-i (Probably most accurate, very slow)
62 Iterative refinement method (<1) with LOCAL pairwise alignment information
63
64 If unsure which option to use, try 'mafft --auto input > output'.
65 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
66
67 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
68 It tends to insert more gaps into gap-rich regions than previous versions.
69 To disable this change, add the --leavegappyregion option.
70
71 inputfile = orig
72 3 x 70 - 70 d
73 nadd = 1
74 generating a scoring matrix for nucleotide (dist=200) ... done
75
76 0 / 2 (thread 0)dndpre (nuc) Version 7.407
77 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
78 1 thread(s)
79
80 generating a scoring matrix for nucleotide (dist=200) ... done
81 All-to-all alignment.
82
83
84 ##### writing hat3
85 pairlocalalign (nuc) Version 7.407
86 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
87 1 thread(s)
88
89 nadd = 1
90 ppenalty_ex = -10
91 nthread = 1
92 blosum 62 / kimura 200
93 sueff_global = 0.100000
94 norg = 2
95 njobc = 3
96 Loading 'hat3' ...
97 done.
98 generating a scoring matrix for nucleotide (dist=200) ... done
99 Loading 'hat2n' (aligned sequences - new sequences) ... done.
100 Loading 'hat2i' (aligned sequences) ... done.
101
102 0 / 1 (thread 0)
103 c
104
105 Combining ..
106 0 / 1
107 0 / 1
108
109 done.
110
111
112 done.
113
114 addsingle (nuc) Version 7.407
115 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
116 1 thread(s)
117
118
119 Strategy:
120 Multi-INS-fragment (Not tested.)
121 ?
122
123 If unsure which option to use, try 'mafft --auto input > output'.
124 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
125
126 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
127 It tends to insert more gaps into gap-rich regions than previous versions.
128 To disable this change, add the --leavegappyregion option.
129
130 inputfile = orig
131 4 x 83 - 70 d
132 nadd = 1
133 generating a scoring matrix for nucleotide (dist=200) ... done
134
135 0 / 3 (thread 0)dndpre (nuc) Version 7.407
136 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
137 1 thread(s)
138
139 generating a scoring matrix for nucleotide (dist=200) ... done
140 All-to-all alignment.
141
142
143 ##### writing hat3
144 pairlocalalign (nuc) Version 7.407
145 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
146 1 thread(s)
147
148 nadd = 1
149 ppenalty_ex = -10
150 nthread = 1
151 blosum 62 / kimura 200
152 sueff_global = 0.100000
153 norg = 3
154 njobc = 4
155 Loading 'hat3' ...
156 done.
157 generating a scoring matrix for nucleotide (dist=200) ... done
158 Loading 'hat2n' (aligned sequences - new sequences) ... done.
159 Loading 'hat2i' (aligned sequences) ... done.
160
161 0 / 1 (thread 0)
162 c
163
164 Combining ..
165 0 / 1
166 0 / 1
167
168 done.
169
170
171 done.
172
173 addsingle (nuc) Version 7.407
174 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
175 1 thread(s)
176
177
178 Strategy:
179 Multi-INS-fragment (Not tested.)
180 ?
181
182 If unsure which option to use, try 'mafft --auto input > output'.
183 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
184
185 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
186 It tends to insert more gaps into gap-rich regions than previous versions.
187 To disable this change, add the --leavegappyregion option.
188
189 inputfile = orig
190 2 x 70 - 70 d
191 outputhat23=1
192 treein = 0
193 compacttree = 0
194 stacksize: 8192 kb
195 generating a scoring matrix for nucleotide (dist=200) ... done
196 All-to-all alignment.
197 0 / 2 (by thread 0)
198 tbfast-pair (nuc) Version 7.407
199 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
200 1 thread(s)
201
202 outputhat23=1
203 Loading 'hat3.seed' ...
204 done.
205 Writing hat3 for iterative refinement
206 generating a scoring matrix for nucleotide (dist=200) ... done
207 Gap Penalty = -1.53, +0.00, +0.00
208 tbutree = 1, compacttree = 0
209 Constructing a UPGMA tree ...
210
211 0 / 2
212 done.
213
214 Progressive alignment ...
215
216 STEP 1 /1 (thread 0)
217 done.
218 tbfast (nuc) Version 7.407
219 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
220 1 thread(s)
221
222 minimumweight = 0.000010
223 autosubalignment = 0.000000
224 nthread = 1
225 randomseed = 0
226 blosum 62 / kimura 200
227 poffset = 0
228 niter = 1
229 sueff_global = 0.100000
230 nadd = 1
231 Loading 'hat3' ... done.
232 generating a scoring matrix for nucleotide (dist=200) ... done
233
234
235 0 / 2
236 Segment 1/ 1 1- 91
237 001-0000-1 (thread 1) identical
238
239 Converged.
240
241 Reached 1
242 done
243 dvtditr (nuc) Version 7.407
244 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
245 1 thread(s)
246
247
248 Strategy:
249 L-INS-i (Probably most accurate, very slow)
250 Iterative refinement method (<1) with LOCAL pairwise alignment information
251
252 If unsure which option to use, try 'mafft --auto input > output'.
253 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
254
255 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
256 It tends to insert more gaps into gap-rich regions than previous versions.
257 To disable this change, add the --leavegappyregion option.
258
259 inputfile = orig
260 2 x 70 - 70 d
261 outputhat23=1
262 treein = 0
263 compacttree = 0
264 stacksize: 8192 kb
265 generating a scoring matrix for nucleotide (dist=200) ... done
266 All-to-all alignment.
267 0 / 2 (by thread 0)
268 tbfast-pair (nuc) Version 7.407
269 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
270 1 thread(s)
271
272 outputhat23=1
273 Loading 'hat3.seed' ...
274 done.
275 Writing hat3 for iterative refinement
276 generating a scoring matrix for nucleotide (dist=200) ... done
277 Gap Penalty = -1.53, +0.00, +0.00
278 tbutree = 1, compacttree = 0
279 Constructing a UPGMA tree ...
280
281 0 / 2
282 done.
283
284 Progressive alignment ...
285
286 STEP 1 /1 (thread 0)
287 done.
288 tbfast (nuc) Version 7.407
289 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
290 1 thread(s)
291
292 minimumweight = 0.000010
293 autosubalignment = 0.000000
294 nthread = 1
295 randomseed = 0
296 blosum 62 / kimura 200
297 poffset = 0
298 niter = 1
299 sueff_global = 0.100000
300 nadd = 1
301 Loading 'hat3' ... done.
302 generating a scoring matrix for nucleotide (dist=200) ... done
303
304
305 0 / 2
306 Segment 1/ 1 1- 108
307 001-0000-1 (thread 1) identical
308
309 Converged.
310
311 Reached 1
312 done
313 dvtditr (nuc) Version 7.407
314 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
315 1 thread(s)
316
317
318 Strategy:
319 L-INS-i (Probably most accurate, very slow)
320 Iterative refinement method (<1) with LOCAL pairwise alignment information
321
322 If unsure which option to use, try 'mafft --auto input > output'.
323 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
324
325 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
326 It tends to insert more gaps into gap-rich regions than previous versions.
327 To disable this change, add the --leavegappyregion option.
328
329 inputfile = orig
330 2 x 70 - 70 d
331 outputhat23=1
332 treein = 0
333 compacttree = 0
334 stacksize: 8192 kb
335 generating a scoring matrix for nucleotide (dist=200) ... done
336 All-to-all alignment.
337 0 / 2 (by thread 0)
338 tbfast-pair (nuc) Version 7.407
339 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
340 1 thread(s)
341
342 outputhat23=1
343 Loading 'hat3.seed' ...
344 done.
345 Writing hat3 for iterative refinement
346 generating a scoring matrix for nucleotide (dist=200) ... done
347 Gap Penalty = -1.53, +0.00, +0.00
348 tbutree = 1, compacttree = 0
349 Constructing a UPGMA tree ...
350
351 0 / 2
352 done.
353
354 Progressive alignment ...
355
356 STEP 1 /1 (thread 0)
357 done.
358 tbfast (nuc) Version 7.407
359 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
360 1 thread(s)
361
362 minimumweight = 0.000010
363 autosubalignment = 0.000000
364 nthread = 1
365 randomseed = 0
366 blosum 62 / kimura 200
367 poffset = 0
368 niter = 1
369 sueff_global = 0.100000
370 nadd = 1
371 Loading 'hat3' ... done.
372 generating a scoring matrix for nucleotide (dist=200) ... done
373
374
375 0 / 2
376 Segment 1/ 1 1- 92
377 001-0000-1 (thread 1) identical
378 001-0000-1 (thread 1) better
379
380 Reached 1
381 done
382 dvtditr (nuc) Version 7.407
383 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
384 1 thread(s)
385
386
387 Strategy:
388 L-INS-i (Probably most accurate, very slow)
389 Iterative refinement method (<1) with LOCAL pairwise alignment information
390
391 If unsure which option to use, try 'mafft --auto input > output'.
392 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
393
394 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
395 It tends to insert more gaps into gap-rich regions than previous versions.
396 To disable this change, add the --leavegappyregion option.
397
398 inputfile = orig
399 3 x 76 - 70 d
400 nadd = 1
401 generating a scoring matrix for nucleotide (dist=200) ... done
402
403 0 / 2 (thread 0)dndpre (nuc) Version 7.407
404 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
405 1 thread(s)
406
407 generating a scoring matrix for nucleotide (dist=200) ... done
408 All-to-all alignment.
409
410
411 ##### writing hat3
412 pairlocalalign (nuc) Version 7.407
413 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
414 1 thread(s)
415
416 nadd = 1
417 ppenalty_ex = -10
418 nthread = 1
419 blosum 62 / kimura 200
420 sueff_global = 0.100000
421 norg = 2
422 njobc = 3
423 Loading 'hat3' ...
424 done.
425 generating a scoring matrix for nucleotide (dist=200) ... done
426 Loading 'hat2n' (aligned sequences - new sequences) ... done.
427 Loading 'hat2i' (aligned sequences) ... done.
428
429 0 / 1 (thread 0)
430 c
431
432 Combining ..
433 0 / 1
434 0 / 1
435
436 done.
437
438
439 done.
440
441 addsingle (nuc) Version 7.407
442 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
443 1 thread(s)
444
445
446 Strategy:
447 Multi-INS-fragment (Not tested.)
448 ?
449
450 If unsure which option to use, try 'mafft --auto input > output'.
451 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
452
453 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
454 It tends to insert more gaps into gap-rich regions than previous versions.
455 To disable this change, add the --leavegappyregion option.
456
457 inputfile = orig
458 2 x 70 - 70 d
459 outputhat23=1
460 treein = 0
461 compacttree = 0
462 stacksize: 8192 kb
463 generating a scoring matrix for nucleotide (dist=200) ... done
464 All-to-all alignment.
465 0 / 2 (by thread 0)
466 tbfast-pair (nuc) Version 7.407
467 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
468 1 thread(s)
469
470 outputhat23=1
471 Loading 'hat3.seed' ...
472 done.
473 Writing hat3 for iterative refinement
474 generating a scoring matrix for nucleotide (dist=200) ... done
475 Gap Penalty = -1.53, +0.00, +0.00
476 tbutree = 1, compacttree = 0
477 Constructing a UPGMA tree ...
478
479 0 / 2
480 done.
481
482 Progressive alignment ...
483
484 STEP 1 /1 (thread 0)
485 done.
486 tbfast (nuc) Version 7.407
487 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
488 1 thread(s)
489
490 minimumweight = 0.000010
491 autosubalignment = 0.000000
492 nthread = 1
493 randomseed = 0
494 blosum 62 / kimura 200
495 poffset = 0
496 niter = 1
497 sueff_global = 0.100000
498 nadd = 1
499 Loading 'hat3' ... done.
500 generating a scoring matrix for nucleotide (dist=200) ... done
501
502
503 0 / 2
504 Segment 1/ 1 1- 118
505 001-0000-1 (thread 1) identical
506
507 Converged.
508
509 Reached 1
510 done
511 dvtditr (nuc) Version 7.407
512 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
513 1 thread(s)
514
515
516 Strategy:
517 L-INS-i (Probably most accurate, very slow)
518 Iterative refinement method (<1) with LOCAL pairwise alignment information
519
520 If unsure which option to use, try 'mafft --auto input > output'.
521 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
522
523 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
524 It tends to insert more gaps into gap-rich regions than previous versions.
525 To disable this change, add the --leavegappyregion option.
526
527 inputfile = orig
528 2 x 70 - 70 d
529 outputhat23=1
530 treein = 0
531 compacttree = 0
532 stacksize: 8192 kb
533 generating a scoring matrix for nucleotide (dist=200) ... done
534 All-to-all alignment.
535 0 / 2 (by thread 0)
536 tbfast-pair (nuc) Version 7.407
537 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
538 1 thread(s)
539
540 outputhat23=1
541 Loading 'hat3.seed' ...
542 done.
543 Writing hat3 for iterative refinement
544 generating a scoring matrix for nucleotide (dist=200) ... done
545 Gap Penalty = -1.53, +0.00, +0.00
546 tbutree = 1, compacttree = 0
547 Constructing a UPGMA tree ...
548
549 0 / 2
550 done.
551
552 Progressive alignment ...
553
554 STEP 1 /1 (thread 0)
555 done.
556 tbfast (nuc) Version 7.407
557 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
558 1 thread(s)
559
560 minimumweight = 0.000010
561 autosubalignment = 0.000000
562 nthread = 1
563 randomseed = 0
564 blosum 62 / kimura 200
565 poffset = 0
566 niter = 1
567 sueff_global = 0.100000
568 nadd = 1
569 Loading 'hat3' ... done.
570 generating a scoring matrix for nucleotide (dist=200) ... done
571
572
573 0 / 2
574 Segment 1/ 1 1- 115
575 001-0000-1 (thread 1) identical
576
577 Converged.
578
579 Reached 1
580 done
581 dvtditr (nuc) Version 7.407
582 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
583 1 thread(s)
584
585
586 Strategy:
587 L-INS-i (Probably most accurate, very slow)
588 Iterative refinement method (<1) with LOCAL pairwise alignment information
589
590 If unsure which option to use, try 'mafft --auto input > output'.
591 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
592
593 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
594 It tends to insert more gaps into gap-rich regions than previous versions.
595 To disable this change, add the --leavegappyregion option.
596
597 inputfile = orig
598 2 x 70 - 70 d
599 outputhat23=1
600 treein = 0
601 compacttree = 0
602 stacksize: 8192 kb
603 generating a scoring matrix for nucleotide (dist=200) ... done
604 All-to-all alignment.
605 0 / 2 (by thread 0)
606 tbfast-pair (nuc) Version 7.407
607 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
608 1 thread(s)
609
610 outputhat23=1
611 Loading 'hat3.seed' ...
612 done.
613 Writing hat3 for iterative refinement
614 generating a scoring matrix for nucleotide (dist=200) ... done
615 Gap Penalty = -1.53, +0.00, +0.00
616 tbutree = 1, compacttree = 0
617 Constructing a UPGMA tree ...
618
619 0 / 2
620 done.
621
622 Progressive alignment ...
623
624 STEP 1 /1 (thread 0)
625 done.
626 tbfast (nuc) Version 7.407
627 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
628 1 thread(s)
629
630 minimumweight = 0.000010
631 autosubalignment = 0.000000
632 nthread = 1
633 randomseed = 0
634 blosum 62 / kimura 200
635 poffset = 0
636 niter = 1
637 sueff_global = 0.100000
638 nadd = 1
639 Loading 'hat3' ... done.
640 generating a scoring matrix for nucleotide (dist=200) ... done
641
642
643 0 / 2
644 Segment 1/ 1 1- 94
645 001-0000-1 (thread 1) identical
646
647 Converged.
648
649 Reached 1
650 done
651 dvtditr (nuc) Version 7.407
652 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
653 1 thread(s)
654
655
656 Strategy:
657 L-INS-i (Probably most accurate, very slow)
658 Iterative refinement method (<1) with LOCAL pairwise alignment information
659
660 If unsure which option to use, try 'mafft --auto input > output'.
661 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
662
663 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
664 It tends to insert more gaps into gap-rich regions than previous versions.
665 To disable this change, add the --leavegappyregion option.
666
667 inputfile = orig
668 2 x 70 - 70 d
669 outputhat23=1
670 treein = 0
671 compacttree = 0
672 stacksize: 8192 kb
673 generating a scoring matrix for nucleotide (dist=200) ... done
674 All-to-all alignment.
675 0 / 2 (by thread 0)
676 tbfast-pair (nuc) Version 7.407
677 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
678 1 thread(s)
679
680 outputhat23=1
681 Loading 'hat3.seed' ...
682 done.
683 Writing hat3 for iterative refinement
684 generating a scoring matrix for nucleotide (dist=200) ... done
685 Gap Penalty = -1.53, +0.00, +0.00
686 tbutree = 1, compacttree = 0
687 Constructing a UPGMA tree ...
688
689 0 / 2
690 done.
691
692 Progressive alignment ...
693
694 STEP 1 /1 (thread 0)
695 done.
696 tbfast (nuc) Version 7.407
697 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
698 1 thread(s)
699
700 minimumweight = 0.000010
701 autosubalignment = 0.000000
702 nthread = 1
703 randomseed = 0
704 blosum 62 / kimura 200
705 poffset = 0
706 niter = 1
707 sueff_global = 0.100000
708 nadd = 1
709 Loading 'hat3' ... done.
710 generating a scoring matrix for nucleotide (dist=200) ... done
711
712
713 0 / 2
714 Segment 1/ 1 1- 87
715 001-0000-1 (thread 1) identical
716 001-0000-1 (thread 1) better
717
718 Reached 1
719 done
720 dvtditr (nuc) Version 7.407
721 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
722 1 thread(s)
723
724
725 Strategy:
726 L-INS-i (Probably most accurate, very slow)
727 Iterative refinement method (<1) with LOCAL pairwise alignment information
728
729 If unsure which option to use, try 'mafft --auto input > output'.
730 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
731
732 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
733 It tends to insert more gaps into gap-rich regions than previous versions.
734 To disable this change, add the --leavegappyregion option.
735
736 inputfile = orig
737 3 x 80 - 70 d
738 nadd = 1
739 generating a scoring matrix for nucleotide (dist=200) ... done
740
741 0 / 2 (thread 0)dndpre (nuc) Version 7.407
742 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
743 1 thread(s)
744
745 generating a scoring matrix for nucleotide (dist=200) ... done
746 All-to-all alignment.
747
748
749 ##### writing hat3
750 pairlocalalign (nuc) Version 7.407
751 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
752 1 thread(s)
753
754 nadd = 1
755 ppenalty_ex = -10
756 nthread = 1
757 blosum 62 / kimura 200
758 sueff_global = 0.100000
759 norg = 2
760 njobc = 3
761 Loading 'hat3' ...
762 done.
763 generating a scoring matrix for nucleotide (dist=200) ... done
764 Loading 'hat2n' (aligned sequences - new sequences) ... done.
765 Loading 'hat2i' (aligned sequences) ... done.
766
767 0 / 1 (thread 0)
768 c
769
770 Combining ..
771 0 / 1
772 0 / 1
773
774 done.
775
776
777 done.
778
779 addsingle (nuc) Version 7.407
780 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
781 1 thread(s)
782
783
784 Strategy:
785 Multi-INS-fragment (Not tested.)
786 ?
787
788 If unsure which option to use, try 'mafft --auto input > output'.
789 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
790
791 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
792 It tends to insert more gaps into gap-rich regions than previous versions.
793 To disable this change, add the --leavegappyregion option.
794
795 inputfile = orig
796 3 x 84 - 70 d
797 nadd = 1
798 generating a scoring matrix for nucleotide (dist=200) ... done
799
800 0 / 2 (thread 0)dndpre (nuc) Version 7.407
801 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
802 1 thread(s)
803
804 generating a scoring matrix for nucleotide (dist=200) ... done
805 All-to-all alignment.
806
807
808 ##### writing hat3
809 pairlocalalign (nuc) Version 7.407
810 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
811 1 thread(s)
812
813 nadd = 1
814 ppenalty_ex = -10
815 nthread = 1
816 blosum 62 / kimura 200
817 sueff_global = 0.100000
818 norg = 2
819 njobc = 3
820 Loading 'hat3' ...
821 done.
822 generating a scoring matrix for nucleotide (dist=200) ... done
823 Loading 'hat2n' (aligned sequences - new sequences) ... done.
824 Loading 'hat2i' (aligned sequences) ... done.
825
826 0 / 1 (thread 0)
827 c
828
829 Combining ..
830 0 / 1
831 0 / 1
832
833 done.
834
835
836 done.
837
838 addsingle (nuc) Version 7.407
839 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
840 1 thread(s)
841
842
843 Strategy:
844 Multi-INS-fragment (Not tested.)
845 ?
846
847 If unsure which option to use, try 'mafft --auto input > output'.
848 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
849
850 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
851 It tends to insert more gaps into gap-rich regions than previous versions.
852 To disable this change, add the --leavegappyregion option.
853
854 inputfile = orig
855 4 x 82 - 75 d
856 nthread = 1
857 nthreadpair = 1
858 nthreadtb = 1
859 ppenalty_ex = 0
860 stacksize: 8192 kb
861 nsubalignments = 2
862 maxmem = 2
863 generating a scoring matrix for nucleotide (dist=200) ... done
864 Gap Penalty = -1.53, +0.00, +0.00
865
866
867
868 Making a distance matrix ..
869
870 1 / 4 (thread 0)
871 done.
872
873 Constructing a UPGMA tree ...
874
875
876 0 / 4
877 done.
878
879 Checking subalignment 1:
880 -> OK
881 Checking subalignment 2:
882 -> OK
883 Progressive alignment 1/2...
884
885 STEP 3 / 3 (thread 0) f
886 done.
887
888 Making a distance matrix from msa..
889
890 0 / 4 (thread 0)
891 done.
892
893 Constructing a UPGMA tree ...
894
895
896 0 / 4
897 done.
898
899 Checking subalignment 1:
900 -> OK
901 Checking subalignment 2:
902 -> OK
903 Progressive alignment 2/2...
904
905 STEP 3 / 3 (thread 0) f
906 done.
907
908 disttbfast (nuc) Version 7.407
909 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
910 1 thread(s)
911
912 generating a scoring matrix for nucleotide (dist=200) ... done
913
914 0 / 4 (thread 0)dndpre (nuc) Version 7.407
915 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
916 1 thread(s)
917
918 minimumweight = 0.000010
919 autosubalignment = 0.000000
920 nthread = 1
921 randomseed = 0
922 blosum 62 / kimura 200
923 poffset = 0
924 niter = 1
925 sueff_global = 0.100000
926 nadd = 1
927 nsubalignments = 2
928 maxmem = 2
929 generating a scoring matrix for nucleotide (dist=200) ... done
930
931
932
933 0 / 4
934
935 Checking subalignment 1:
936 1 2
937 -> OK
938
939 Checking subalignment 2:
940 3 4
941 -> OK
942 Segment 1/ 1 1- 91
943 001-0000-0 (thread 1) skip
944
945 001-0001-1 (thread 1) skip
946
947 001-0002-0 (thread 1) skip
948
949 001-0003-1 (thread 1) skip
950
951 001-0004-1 (thread 1) identical
952 001-0004-1 (thread 1) better
953
954 Reached 1
955 done
956 dvtditr (nuc) Version 7.407
957 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
958 1 thread(s)
959
960
961 Strategy:
962 FFT-NS-i (Standard)
963 Iterative refinement method (max. 1 iterations)
964
965 If unsure which option to use, try 'mafft --auto input > output'.
966 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
967
968 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
969 It tends to insert more gaps into gap-rich regions than previous versions.
970 To disable this change, add the --leavegappyregion option.
971
972 inputfile = orig
973 2 x 70 - 70 d
974 outputhat23=1
975 treein = 0
976 compacttree = 0
977 stacksize: 8192 kb
978 generating a scoring matrix for nucleotide (dist=200) ... done
979 All-to-all alignment.
980 0 / 2 (by thread 0)
981 tbfast-pair (nuc) Version 7.407
982 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
983 1 thread(s)
984
985 outputhat23=1
986 Loading 'hat3.seed' ...
987 done.
988 Writing hat3 for iterative refinement
989 generating a scoring matrix for nucleotide (dist=200) ... done
990 Gap Penalty = -1.53, +0.00, +0.00
991 tbutree = 1, compacttree = 0
992 Constructing a UPGMA tree ...
993
994 0 / 2
995 done.
996
997 Progressive alignment ...
998
999 STEP 1 /1 (thread 0)
1000 done.
1001 tbfast (nuc) Version 7.407
1002 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1003 1 thread(s)
1004
1005 minimumweight = 0.000010
1006 autosubalignment = 0.000000
1007 nthread = 1
1008 randomseed = 0
1009 blosum 62 / kimura 200
1010 poffset = 0
1011 niter = 1
1012 sueff_global = 0.100000
1013 nadd = 1
1014 Loading 'hat3' ... done.
1015 generating a scoring matrix for nucleotide (dist=200) ... done
1016
1017
1018 0 / 2
1019 Segment 1/ 1 1- 78
1020 001-0000-1 (thread 1) identical
1021 001-0000-1 (thread 1) better
1022
1023 Reached 1
1024 done
1025 dvtditr (nuc) Version 7.407
1026 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1027 1 thread(s)
1028
1029
1030 Strategy:
1031 L-INS-i (Probably most accurate, very slow)
1032 Iterative refinement method (<1) with LOCAL pairwise alignment information
1033
1034 If unsure which option to use, try 'mafft --auto input > output'.
1035 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1036
1037 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1038 It tends to insert more gaps into gap-rich regions than previous versions.
1039 To disable this change, add the --leavegappyregion option.
1040
1041 inputfile = orig
1042 2 x 70 - 70 d
1043 outputhat23=1
1044 treein = 0
1045 compacttree = 0
1046 stacksize: 8192 kb
1047 generating a scoring matrix for nucleotide (dist=200) ... done
1048 All-to-all alignment.
1049 0 / 2 (by thread 0)
1050 tbfast-pair (nuc) Version 7.407
1051 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1052 1 thread(s)
1053
1054 outputhat23=1
1055 Loading 'hat3.seed' ...
1056 done.
1057 Writing hat3 for iterative refinement
1058 generating a scoring matrix for nucleotide (dist=200) ... done
1059 Gap Penalty = -1.53, +0.00, +0.00
1060 tbutree = 1, compacttree = 0
1061 Constructing a UPGMA tree ...
1062
1063 0 / 2
1064 done.
1065
1066 Progressive alignment ...
1067
1068 STEP 1 /1 (thread 0)
1069 done.
1070 tbfast (nuc) Version 7.407
1071 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1072 1 thread(s)
1073
1074 minimumweight = 0.000010
1075 autosubalignment = 0.000000
1076 nthread = 1
1077 randomseed = 0
1078 blosum 62 / kimura 200
1079 poffset = 0
1080 niter = 1
1081 sueff_global = 0.100000
1082 nadd = 1
1083 Loading 'hat3' ... done.
1084 generating a scoring matrix for nucleotide (dist=200) ... done
1085
1086
1087 0 / 2
1088 Segment 1/ 1 1- 73
1089 001-0000-1 (thread 1) identical
1090 001-0000-1 (thread 1) better
1091
1092 Reached 1
1093 done
1094 dvtditr (nuc) Version 7.407
1095 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1096 1 thread(s)
1097
1098
1099 Strategy:
1100 L-INS-i (Probably most accurate, very slow)
1101 Iterative refinement method (<1) with LOCAL pairwise alignment information
1102
1103 If unsure which option to use, try 'mafft --auto input > output'.
1104 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1105
1106 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1107 It tends to insert more gaps into gap-rich regions than previous versions.
1108 To disable this change, add the --leavegappyregion option.
1109
1110 inputfile = orig
1111 2 x 70 - 70 d
1112 outputhat23=1
1113 treein = 0
1114 compacttree = 0
1115 stacksize: 8192 kb
1116 generating a scoring matrix for nucleotide (dist=200) ... done
1117 All-to-all alignment.
1118 0 / 2 (by thread 0)
1119 tbfast-pair (nuc) Version 7.407
1120 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1121 1 thread(s)
1122
1123 outputhat23=1
1124 Loading 'hat3.seed' ...
1125 done.
1126 Writing hat3 for iterative refinement
1127 generating a scoring matrix for nucleotide (dist=200) ... done
1128 Gap Penalty = -1.53, +0.00, +0.00
1129 tbutree = 1, compacttree = 0
1130 Constructing a UPGMA tree ...
1131
1132 0 / 2
1133 done.
1134
1135 Progressive alignment ...
1136
1137 STEP 1 /1 (thread 0)
1138 done.
1139 tbfast (nuc) Version 7.407
1140 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1141 1 thread(s)
1142
1143 minimumweight = 0.000010
1144 autosubalignment = 0.000000
1145 nthread = 1
1146 randomseed = 0
1147 blosum 62 / kimura 200
1148 poffset = 0
1149 niter = 1
1150 sueff_global = 0.100000
1151 nadd = 1
1152 Loading 'hat3' ... done.
1153 generating a scoring matrix for nucleotide (dist=200) ... done
1154
1155
1156 0 / 2
1157 Segment 1/ 1 1- 84
1158 001-0000-1 (thread 1) identical
1159
1160 Converged.
1161
1162 Reached 1
1163 done
1164 dvtditr (nuc) Version 7.407
1165 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1166 1 thread(s)
1167
1168
1169 Strategy:
1170 L-INS-i (Probably most accurate, very slow)
1171 Iterative refinement method (<1) with LOCAL pairwise alignment information
1172
1173 If unsure which option to use, try 'mafft --auto input > output'.
1174 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1175
1176 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1177 It tends to insert more gaps into gap-rich regions than previous versions.
1178 To disable this change, add the --leavegappyregion option.
1179
1180 inputfile = orig
1181 2 x 70 - 70 d
1182 outputhat23=1
1183 treein = 0
1184 compacttree = 0
1185 stacksize: 8192 kb
1186 generating a scoring matrix for nucleotide (dist=200) ... done
1187 All-to-all alignment.
1188 0 / 2 (by thread 0)
1189 tbfast-pair (nuc) Version 7.407
1190 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1191 1 thread(s)
1192
1193 outputhat23=1
1194 Loading 'hat3.seed' ...
1195 done.
1196 Writing hat3 for iterative refinement
1197 generating a scoring matrix for nucleotide (dist=200) ... done
1198 Gap Penalty = -1.53, +0.00, +0.00
1199 tbutree = 1, compacttree = 0
1200 Constructing a UPGMA tree ...
1201
1202 0 / 2
1203 done.
1204
1205 Progressive alignment ...
1206
1207 STEP 1 /1 (thread 0)
1208 done.
1209 tbfast (nuc) Version 7.407
1210 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1211 1 thread(s)
1212
1213 minimumweight = 0.000010
1214 autosubalignment = 0.000000
1215 nthread = 1
1216 randomseed = 0
1217 blosum 62 / kimura 200
1218 poffset = 0
1219 niter = 1
1220 sueff_global = 0.100000
1221 nadd = 1
1222 Loading 'hat3' ... done.
1223 generating a scoring matrix for nucleotide (dist=200) ... done
1224
1225
1226 0 / 2
1227 Segment 1/ 1 1- 88
1228 001-0000-1 (thread 1) identical
1229
1230 Converged.
1231
1232 Reached 1
1233 done
1234 dvtditr (nuc) Version 7.407
1235 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1236 1 thread(s)
1237
1238
1239 Strategy:
1240 L-INS-i (Probably most accurate, very slow)
1241 Iterative refinement method (<1) with LOCAL pairwise alignment information
1242
1243 If unsure which option to use, try 'mafft --auto input > output'.
1244 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1245
1246 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1247 It tends to insert more gaps into gap-rich regions than previous versions.
1248 To disable this change, add the --leavegappyregion option.
1249
1250 inputfile = orig
1251 2 x 70 - 70 d
1252 outputhat23=1
1253 treein = 0
1254 compacttree = 0
1255 stacksize: 8192 kb
1256 generating a scoring matrix for nucleotide (dist=200) ... done
1257 All-to-all alignment.
1258 0 / 2 (by thread 0)
1259 tbfast-pair (nuc) Version 7.407
1260 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1261 1 thread(s)
1262
1263 outputhat23=1
1264 Loading 'hat3.seed' ...
1265 done.
1266 Writing hat3 for iterative refinement
1267 generating a scoring matrix for nucleotide (dist=200) ... done
1268 Gap Penalty = -1.53, +0.00, +0.00
1269 tbutree = 1, compacttree = 0
1270 Constructing a UPGMA tree ...
1271
1272 0 / 2
1273 done.
1274
1275 Progressive alignment ...
1276
1277 STEP 1 /1 (thread 0)
1278 done.
1279 tbfast (nuc) Version 7.407
1280 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1281 1 thread(s)
1282
1283 minimumweight = 0.000010
1284 autosubalignment = 0.000000
1285 nthread = 1
1286 randomseed = 0
1287 blosum 62 / kimura 200
1288 poffset = 0
1289 niter = 1
1290 sueff_global = 0.100000
1291 nadd = 1
1292 Loading 'hat3' ... done.
1293 generating a scoring matrix for nucleotide (dist=200) ... done
1294
1295
1296 0 / 2
1297 Segment 1/ 1 1- 105
1298 001-0000-1 (thread 1) identical
1299 001-0000-1 (thread 1) better
1300
1301 Reached 1
1302 done
1303 dvtditr (nuc) Version 7.407
1304 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1305 1 thread(s)
1306
1307
1308 Strategy:
1309 L-INS-i (Probably most accurate, very slow)
1310 Iterative refinement method (<1) with LOCAL pairwise alignment information
1311
1312 If unsure which option to use, try 'mafft --auto input > output'.
1313 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1314
1315 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1316 It tends to insert more gaps into gap-rich regions than previous versions.
1317 To disable this change, add the --leavegappyregion option.
1318
1319 inputfile = orig
1320 2 x 70 - 70 d
1321 outputhat23=1
1322 treein = 0
1323 compacttree = 0
1324 stacksize: 8192 kb
1325 generating a scoring matrix for nucleotide (dist=200) ... done
1326 All-to-all alignment.
1327 0 / 2 (by thread 0)
1328 tbfast-pair (nuc) Version 7.407
1329 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1330 1 thread(s)
1331
1332 outputhat23=1
1333 Loading 'hat3.seed' ...
1334 done.
1335 Writing hat3 for iterative refinement
1336 generating a scoring matrix for nucleotide (dist=200) ... done
1337 Gap Penalty = -1.53, +0.00, +0.00
1338 tbutree = 1, compacttree = 0
1339 Constructing a UPGMA tree ...
1340
1341 0 / 2
1342 done.
1343
1344 Progressive alignment ...
1345
1346 STEP 1 /1 (thread 0)
1347 done.
1348 tbfast (nuc) Version 7.407
1349 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1350 1 thread(s)
1351
1352 minimumweight = 0.000010
1353 autosubalignment = 0.000000
1354 nthread = 1
1355 randomseed = 0
1356 blosum 62 / kimura 200
1357 poffset = 0
1358 niter = 1
1359 sueff_global = 0.100000
1360 nadd = 1
1361 Loading 'hat3' ... done.
1362 generating a scoring matrix for nucleotide (dist=200) ... done
1363
1364
1365 0 / 2
1366 Segment 1/ 1 1- 77
1367 001-0000-1 (thread 1) identical
1368 001-0000-1 (thread 1) better
1369
1370 Reached 1
1371 done
1372 dvtditr (nuc) Version 7.407
1373 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1374 1 thread(s)
1375
1376
1377 Strategy:
1378 L-INS-i (Probably most accurate, very slow)
1379 Iterative refinement method (<1) with LOCAL pairwise alignment information
1380
1381 If unsure which option to use, try 'mafft --auto input > output'.
1382 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1383
1384 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1385 It tends to insert more gaps into gap-rich regions than previous versions.
1386 To disable this change, add the --leavegappyregion option.
1387
1388 inputfile = orig
1389 3 x 76 - 70 d
1390 nadd = 1
1391 generating a scoring matrix for nucleotide (dist=200) ... done
1392
1393 0 / 2 (thread 0)dndpre (nuc) Version 7.407
1394 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1395 1 thread(s)
1396
1397 generating a scoring matrix for nucleotide (dist=200) ... done
1398 All-to-all alignment.
1399
1400
1401 ##### writing hat3
1402 pairlocalalign (nuc) Version 7.407
1403 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1404 1 thread(s)
1405
1406 nadd = 1
1407 ppenalty_ex = -10
1408 nthread = 1
1409 blosum 62 / kimura 200
1410 sueff_global = 0.100000
1411 norg = 2
1412 njobc = 3
1413 Loading 'hat3' ...
1414 done.
1415 generating a scoring matrix for nucleotide (dist=200) ... done
1416 Loading 'hat2n' (aligned sequences - new sequences) ... done.
1417 Loading 'hat2i' (aligned sequences) ... done.
1418
1419 0 / 1 (thread 0)
1420 c
1421
1422 Combining ..
1423 0 / 1
1424 0 / 1
1425
1426 done.
1427
1428
1429 done.
1430
1431 addsingle (nuc) Version 7.407
1432 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1433 1 thread(s)
1434
1435
1436 Strategy:
1437 Multi-INS-fragment (Not tested.)
1438 ?
1439
1440 If unsure which option to use, try 'mafft --auto input > output'.
1441 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1442
1443 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1444 It tends to insert more gaps into gap-rich regions than previous versions.
1445 To disable this change, add the --leavegappyregion option.
1446
1447 inputfile = orig
1448 3 x 79 - 70 d
1449 nadd = 1
1450 generating a scoring matrix for nucleotide (dist=200) ... done
1451
1452 0 / 2 (thread 0)dndpre (nuc) Version 7.407
1453 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1454 1 thread(s)
1455
1456 generating a scoring matrix for nucleotide (dist=200) ... done
1457 All-to-all alignment.
1458
1459
1460 ##### writing hat3
1461 pairlocalalign (nuc) Version 7.407
1462 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1463 1 thread(s)
1464
1465 nadd = 1
1466 ppenalty_ex = -10
1467 nthread = 1
1468 blosum 62 / kimura 200
1469 sueff_global = 0.100000
1470 norg = 2
1471 njobc = 3
1472 Loading 'hat3' ...
1473 done.
1474 generating a scoring matrix for nucleotide (dist=200) ... done
1475 Loading 'hat2n' (aligned sequences - new sequences) ... done.
1476 Loading 'hat2i' (aligned sequences) ... done.
1477
1478 0 / 1 (thread 0)
1479 c
1480
1481 Combining ..
1482 0 / 1
1483 0 / 1
1484
1485 done.
1486
1487
1488 done.
1489
1490 addsingle (nuc) Version 7.407
1491 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1492 1 thread(s)
1493
1494
1495 Strategy:
1496 Multi-INS-fragment (Not tested.)
1497 ?
1498
1499 If unsure which option to use, try 'mafft --auto input > output'.
1500 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1501
1502 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1503 It tends to insert more gaps into gap-rich regions than previous versions.
1504 To disable this change, add the --leavegappyregion option.
1505
1506 inputfile = orig
1507 3 x 80 - 70 d
1508 nadd = 1
1509 generating a scoring matrix for nucleotide (dist=200) ... done
1510
1511 0 / 2 (thread 0)dndpre (nuc) Version 7.407
1512 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1513 1 thread(s)
1514
1515 generating a scoring matrix for nucleotide (dist=200) ... done
1516 All-to-all alignment.
1517
1518
1519 ##### writing hat3
1520 pairlocalalign (nuc) Version 7.407
1521 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1522 1 thread(s)
1523
1524 nadd = 1
1525 ppenalty_ex = -10
1526 nthread = 1
1527 blosum 62 / kimura 200
1528 sueff_global = 0.100000
1529 norg = 2
1530 njobc = 3
1531 Loading 'hat3' ...
1532 done.
1533 generating a scoring matrix for nucleotide (dist=200) ... done
1534 Loading 'hat2n' (aligned sequences - new sequences) ... done.
1535 Loading 'hat2i' (aligned sequences) ... done.
1536
1537 0 / 1 (thread 0)
1538 c
1539
1540 Combining ..
1541 0 / 1
1542 0 / 1
1543
1544 done.
1545
1546
1547 done.
1548
1549 addsingle (nuc) Version 7.407
1550 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1551 1 thread(s)
1552
1553
1554 Strategy:
1555 Multi-INS-fragment (Not tested.)
1556 ?
1557
1558 If unsure which option to use, try 'mafft --auto input > output'.
1559 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1560
1561 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1562 It tends to insert more gaps into gap-rich regions than previous versions.
1563 To disable this change, add the --leavegappyregion option.
1564
1565 inputfile = orig
1566 2 x 70 - 70 d
1567 outputhat23=1
1568 treein = 0
1569 compacttree = 0
1570 stacksize: 8192 kb
1571 generating a scoring matrix for nucleotide (dist=200) ... done
1572 All-to-all alignment.
1573 0 / 2 (by thread 0)
1574 tbfast-pair (nuc) Version 7.407
1575 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1576 1 thread(s)
1577
1578 outputhat23=1
1579 Loading 'hat3.seed' ...
1580 done.
1581 Writing hat3 for iterative refinement
1582 generating a scoring matrix for nucleotide (dist=200) ... done
1583 Gap Penalty = -1.53, +0.00, +0.00
1584 tbutree = 1, compacttree = 0
1585 Constructing a UPGMA tree ...
1586
1587 0 / 2
1588 done.
1589
1590 Progressive alignment ...
1591
1592 STEP 1 /1 (thread 0)
1593 done.
1594 tbfast (nuc) Version 7.407
1595 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1596 1 thread(s)
1597
1598 minimumweight = 0.000010
1599 autosubalignment = 0.000000
1600 nthread = 1
1601 randomseed = 0
1602 blosum 62 / kimura 200
1603 poffset = 0
1604 niter = 1
1605 sueff_global = 0.100000
1606 nadd = 1
1607 Loading 'hat3' ... done.
1608 generating a scoring matrix for nucleotide (dist=200) ... done
1609
1610
1611 0 / 2
1612 Segment 1/ 1 1- 97
1613 001-0000-1 (thread 1) identical
1614 001-0000-1 (thread 1) better
1615
1616 Reached 1
1617 done
1618 dvtditr (nuc) Version 7.407
1619 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1620 1 thread(s)
1621
1622
1623 Strategy:
1624 L-INS-i (Probably most accurate, very slow)
1625 Iterative refinement method (<1) with LOCAL pairwise alignment information
1626
1627 If unsure which option to use, try 'mafft --auto input > output'.
1628 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1629
1630 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1631 It tends to insert more gaps into gap-rich regions than previous versions.
1632 To disable this change, add the --leavegappyregion option.
1633
1634 inputfile = orig
1635 2 x 70 - 70 d
1636 outputhat23=1
1637 treein = 0
1638 compacttree = 0
1639 stacksize: 8192 kb
1640 generating a scoring matrix for nucleotide (dist=200) ... done
1641 All-to-all alignment.
1642 0 / 2 (by thread 0)
1643 tbfast-pair (nuc) Version 7.407
1644 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1645 1 thread(s)
1646
1647 outputhat23=1
1648 Loading 'hat3.seed' ...
1649 done.
1650 Writing hat3 for iterative refinement
1651 generating a scoring matrix for nucleotide (dist=200) ... done
1652 Gap Penalty = -1.53, +0.00, +0.00
1653 tbutree = 1, compacttree = 0
1654 Constructing a UPGMA tree ...
1655
1656 0 / 2
1657 done.
1658
1659 Progressive alignment ...
1660
1661 STEP 1 /1 (thread 0)
1662 done.
1663 tbfast (nuc) Version 7.407
1664 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1665 1 thread(s)
1666
1667 minimumweight = 0.000010
1668 autosubalignment = 0.000000
1669 nthread = 1
1670 randomseed = 0
1671 blosum 62 / kimura 200
1672 poffset = 0
1673 niter = 1
1674 sueff_global = 0.100000
1675 nadd = 1
1676 Loading 'hat3' ... done.
1677 generating a scoring matrix for nucleotide (dist=200) ... done
1678
1679
1680 0 / 2
1681 Segment 1/ 1 1- 72
1682 001-0000-1 (thread 1) identical
1683 001-0000-1 (thread 1) better
1684
1685 Reached 1
1686 done
1687 dvtditr (nuc) Version 7.407
1688 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1689 1 thread(s)
1690
1691
1692 Strategy:
1693 L-INS-i (Probably most accurate, very slow)
1694 Iterative refinement method (<1) with LOCAL pairwise alignment information
1695
1696 If unsure which option to use, try 'mafft --auto input > output'.
1697 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1698
1699 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1700 It tends to insert more gaps into gap-rich regions than previous versions.
1701 To disable this change, add the --leavegappyregion option.
1702
1703 inputfile = orig
1704 2 x 70 - 70 d
1705 outputhat23=1
1706 treein = 0
1707 compacttree = 0
1708 stacksize: 8192 kb
1709 generating a scoring matrix for nucleotide (dist=200) ... done
1710 All-to-all alignment.
1711 0 / 2 (by thread 0)
1712 tbfast-pair (nuc) Version 7.407
1713 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1714 1 thread(s)
1715
1716 outputhat23=1
1717 Loading 'hat3.seed' ...
1718 done.
1719 Writing hat3 for iterative refinement
1720 generating a scoring matrix for nucleotide (dist=200) ... done
1721 Gap Penalty = -1.53, +0.00, +0.00
1722 tbutree = 1, compacttree = 0
1723 Constructing a UPGMA tree ...
1724
1725 0 / 2
1726 done.
1727
1728 Progressive alignment ...
1729
1730 STEP 1 /1 (thread 0)
1731 done.
1732 tbfast (nuc) Version 7.407
1733 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1734 1 thread(s)
1735
1736 minimumweight = 0.000010
1737 autosubalignment = 0.000000
1738 nthread = 1
1739 randomseed = 0
1740 blosum 62 / kimura 200
1741 poffset = 0
1742 niter = 1
1743 sueff_global = 0.100000
1744 nadd = 1
1745 Loading 'hat3' ... done.
1746 generating a scoring matrix for nucleotide (dist=200) ... done
1747
1748
1749 0 / 2
1750 Segment 1/ 1 1- 97
1751 001-0000-1 (thread 1) identical
1752 001-0000-1 (thread 1) better
1753
1754 Reached 1
1755 done
1756 dvtditr (nuc) Version 7.407
1757 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1758 1 thread(s)
1759
1760
1761 Strategy:
1762 L-INS-i (Probably most accurate, very slow)
1763 Iterative refinement method (<1) with LOCAL pairwise alignment information
1764
1765 If unsure which option to use, try 'mafft --auto input > output'.
1766 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1767
1768 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1769 It tends to insert more gaps into gap-rich regions than previous versions.
1770 To disable this change, add the --leavegappyregion option.
1771
1772 inputfile = orig
1773 2 x 70 - 70 d
1774 outputhat23=1
1775 treein = 0
1776 compacttree = 0
1777 stacksize: 8192 kb
1778 generating a scoring matrix for nucleotide (dist=200) ... done
1779 All-to-all alignment.
1780 0 / 2 (by thread 0)
1781 tbfast-pair (nuc) Version 7.407
1782 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1783 1 thread(s)
1784
1785 outputhat23=1
1786 Loading 'hat3.seed' ...
1787 done.
1788 Writing hat3 for iterative refinement
1789 generating a scoring matrix for nucleotide (dist=200) ... done
1790 Gap Penalty = -1.53, +0.00, +0.00
1791 tbutree = 1, compacttree = 0
1792 Constructing a UPGMA tree ...
1793
1794 0 / 2
1795 done.
1796
1797 Progressive alignment ...
1798
1799 STEP 1 /1 (thread 0)
1800 done.
1801 tbfast (nuc) Version 7.407
1802 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1803 1 thread(s)
1804
1805 minimumweight = 0.000010
1806 autosubalignment = 0.000000
1807 nthread = 1
1808 randomseed = 0
1809 blosum 62 / kimura 200
1810 poffset = 0
1811 niter = 1
1812 sueff_global = 0.100000
1813 nadd = 1
1814 Loading 'hat3' ... done.
1815 generating a scoring matrix for nucleotide (dist=200) ... done
1816
1817
1818 0 / 2
1819 Segment 1/ 1 1- 89
1820 001-0000-1 (thread 1) identical
1821
1822 Converged.
1823
1824 Reached 1
1825 done
1826 dvtditr (nuc) Version 7.407
1827 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1828 1 thread(s)
1829
1830
1831 Strategy:
1832 L-INS-i (Probably most accurate, very slow)
1833 Iterative refinement method (<1) with LOCAL pairwise alignment information
1834
1835 If unsure which option to use, try 'mafft --auto input > output'.
1836 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1837
1838 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1839 It tends to insert more gaps into gap-rich regions than previous versions.
1840 To disable this change, add the --leavegappyregion option.
1841
1842 inputfile = orig
1843 3 x 95 - 70 d
1844 nadd = 1
1845 generating a scoring matrix for nucleotide (dist=200) ... done
1846
1847 0 / 2 (thread 0)dndpre (nuc) Version 7.407
1848 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1849 1 thread(s)
1850
1851 generating a scoring matrix for nucleotide (dist=200) ... done
1852 All-to-all alignment.
1853
1854
1855 ##### writing hat3
1856 pairlocalalign (nuc) Version 7.407
1857 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1858 1 thread(s)
1859
1860 nadd = 1
1861 ppenalty_ex = -10
1862 nthread = 1
1863 blosum 62 / kimura 200
1864 sueff_global = 0.100000
1865 norg = 2
1866 njobc = 3
1867 Loading 'hat3' ...
1868 done.
1869 generating a scoring matrix for nucleotide (dist=200) ... done
1870 Loading 'hat2n' (aligned sequences - new sequences) ... done.
1871 Loading 'hat2i' (aligned sequences) ... done.
1872
1873 0 / 1 (thread 0)
1874 c
1875
1876 Combining ..
1877 0 / 1
1878 0 / 1
1879
1880 done.
1881
1882
1883 done.
1884
1885 addsingle (nuc) Version 7.407
1886 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1887 1 thread(s)
1888
1889
1890 Strategy:
1891 Multi-INS-fragment (Not tested.)
1892 ?
1893
1894 If unsure which option to use, try 'mafft --auto input > output'.
1895 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1896
1897 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1898 It tends to insert more gaps into gap-rich regions than previous versions.
1899 To disable this change, add the --leavegappyregion option.
1900
1901 inputfile = orig
1902 2 x 70 - 70 d
1903 outputhat23=1
1904 treein = 0
1905 compacttree = 0
1906 stacksize: 8192 kb
1907 generating a scoring matrix for nucleotide (dist=200) ... done
1908 All-to-all alignment.
1909 0 / 2 (by thread 0)
1910 tbfast-pair (nuc) Version 7.407
1911 alg=L, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1912 1 thread(s)
1913
1914 outputhat23=1
1915 Loading 'hat3.seed' ...
1916 done.
1917 Writing hat3 for iterative refinement
1918 generating a scoring matrix for nucleotide (dist=200) ... done
1919 Gap Penalty = -1.53, +0.00, +0.00
1920 tbutree = 1, compacttree = 0
1921 Constructing a UPGMA tree ...
1922
1923 0 / 2
1924 done.
1925
1926 Progressive alignment ...
1927
1928 STEP 1 /1 (thread 0)
1929 done.
1930 tbfast (nuc) Version 7.407
1931 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1932 1 thread(s)
1933
1934 minimumweight = 0.000010
1935 autosubalignment = 0.000000
1936 nthread = 1
1937 randomseed = 0
1938 blosum 62 / kimura 200
1939 poffset = 0
1940 niter = 1
1941 sueff_global = 0.100000
1942 nadd = 1
1943 Loading 'hat3' ... done.
1944 generating a scoring matrix for nucleotide (dist=200) ... done
1945
1946
1947 0 / 2
1948 Segment 1/ 1 1- 95
1949 001-0000-1 (thread 1) identical
1950
1951 Converged.
1952
1953 Reached 1
1954 done
1955 dvtditr (nuc) Version 7.407
1956 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
1957 1 thread(s)
1958
1959
1960 Strategy:
1961 L-INS-i (Probably most accurate, very slow)
1962 Iterative refinement method (<1) with LOCAL pairwise alignment information
1963
1964 If unsure which option to use, try 'mafft --auto input > output'.
1965 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
1966
1967 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
1968 It tends to insert more gaps into gap-rich regions than previous versions.
1969 To disable this change, add the --leavegappyregion option.
1970
1971 inputfile = orig
1972 3 x 71 - 70 d
1973 nadd = 1
1974 generating a scoring matrix for nucleotide (dist=200) ... done
1975
1976 0 / 2 (thread 0)dndpre (nuc) Version 7.407
1977 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1978 1 thread(s)
1979
1980 generating a scoring matrix for nucleotide (dist=200) ... done
1981 All-to-all alignment.
1982
1983
1984 ##### writing hat3
1985 pairlocalalign (nuc) Version 7.407
1986 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
1987 1 thread(s)
1988
1989 nadd = 1
1990 ppenalty_ex = -10
1991 nthread = 1
1992 blosum 62 / kimura 200
1993 sueff_global = 0.100000
1994 norg = 2
1995 njobc = 3
1996 Loading 'hat3' ...
1997 done.
1998 generating a scoring matrix for nucleotide (dist=200) ... done
1999 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2000 Loading 'hat2i' (aligned sequences) ... done.
2001
2002 0 / 1 (thread 0)
2003 c
2004
2005 Combining ..
2006 0 / 1
2007 0 / 1
2008
2009 done.
2010
2011
2012 done.
2013
2014 addsingle (nuc) Version 7.407
2015 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2016 1 thread(s)
2017
2018
2019 Strategy:
2020 Multi-INS-fragment (Not tested.)
2021 ?
2022
2023 If unsure which option to use, try 'mafft --auto input > output'.
2024 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2025
2026 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2027 It tends to insert more gaps into gap-rich regions than previous versions.
2028 To disable this change, add the --leavegappyregion option.
2029
2030 inputfile = orig
2031 5 x 110 - 70 d
2032 nadd = 1
2033 generating a scoring matrix for nucleotide (dist=200) ... done
2034
2035 0 / 4 (thread 0)dndpre (nuc) Version 7.407
2036 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2037 1 thread(s)
2038
2039 generating a scoring matrix for nucleotide (dist=200) ... done
2040 All-to-all alignment.
2041
2042
2043 ##### writing hat3
2044 pairlocalalign (nuc) Version 7.407
2045 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2046 1 thread(s)
2047
2048 nadd = 1
2049 ppenalty_ex = -10
2050 nthread = 1
2051 blosum 62 / kimura 200
2052 sueff_global = 0.100000
2053 norg = 4
2054 njobc = 5
2055 Loading 'hat3' ...
2056 done.
2057 generating a scoring matrix for nucleotide (dist=200) ... done
2058 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2059 Loading 'hat2i' (aligned sequences) ... done.
2060
2061 0 / 1 (thread 0)
2062 c
2063
2064 Combining ..
2065 0 / 1
2066 0 / 1
2067
2068 done.
2069
2070
2071 done.
2072
2073 addsingle (nuc) Version 7.407
2074 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2075 1 thread(s)
2076
2077
2078 Strategy:
2079 Multi-INS-fragment (Not tested.)
2080 ?
2081
2082 If unsure which option to use, try 'mafft --auto input > output'.
2083 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2084
2085 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2086 It tends to insert more gaps into gap-rich regions than previous versions.
2087 To disable this change, add the --leavegappyregion option.
2088
2089 inputfile = orig
2090 3 x 90 - 70 d
2091 nadd = 1
2092 generating a scoring matrix for nucleotide (dist=200) ... done
2093
2094 0 / 2 (thread 0)dndpre (nuc) Version 7.407
2095 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2096 1 thread(s)
2097
2098 generating a scoring matrix for nucleotide (dist=200) ... done
2099 All-to-all alignment.
2100
2101
2102 ##### writing hat3
2103 pairlocalalign (nuc) Version 7.407
2104 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2105 1 thread(s)
2106
2107 nadd = 1
2108 ppenalty_ex = -10
2109 nthread = 1
2110 blosum 62 / kimura 200
2111 sueff_global = 0.100000
2112 norg = 2
2113 njobc = 3
2114 Loading 'hat3' ...
2115 done.
2116 generating a scoring matrix for nucleotide (dist=200) ... done
2117 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2118 Loading 'hat2i' (aligned sequences) ... done.
2119
2120 0 / 1 (thread 0)
2121 c
2122
2123 Combining ..
2124 0 / 1
2125 0 / 1
2126
2127 done.
2128
2129
2130 done.
2131
2132 addsingle (nuc) Version 7.407
2133 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2134 1 thread(s)
2135
2136
2137 Strategy:
2138 Multi-INS-fragment (Not tested.)
2139 ?
2140
2141 If unsure which option to use, try 'mafft --auto input > output'.
2142 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2143
2144 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2145 It tends to insert more gaps into gap-rich regions than previous versions.
2146 To disable this change, add the --leavegappyregion option.
2147
2148 inputfile = orig
2149 4 x 107 - 99 d
2150 nthread = 1
2151 nthreadpair = 1
2152 nthreadtb = 1
2153 ppenalty_ex = 0
2154 stacksize: 8192 kb
2155 nsubalignments = 2
2156 maxmem = 2
2157 generating a scoring matrix for nucleotide (dist=200) ... done
2158 Gap Penalty = -1.53, +0.00, +0.00
2159
2160
2161
2162 Making a distance matrix ..
2163
2164 1 / 4 (thread 0)
2165 done.
2166
2167 Constructing a UPGMA tree ...
2168
2169
2170 0 / 4
2171 ###################################################################
2172 # WARNING: Group 2 is forced to be a monophyletic cluster.
2173 ###################################################################
2174 Reallocated inconsistentpairlist, size=2
2175
2176 done.
2177
2178 Checking subalignment 1:
2179 -> OK
2180 Checking subalignment 2:
2181 -> OK
2182 Progressive alignment 1/2...
2183
2184 STEP 3 / 3 (thread 0) f
2185 done.
2186
2187 Making a distance matrix from msa..
2188
2189 0 / 4 (thread 0)
2190 done.
2191
2192 Constructing a UPGMA tree ...
2193
2194
2195 0 / 4
2196 done.
2197
2198 Checking subalignment 1:
2199 -> OK
2200 Checking subalignment 2:
2201 -> OK
2202 Progressive alignment 2/2...
2203
2204 STEP 3 / 3 (thread 0) f
2205 done.
2206
2207 disttbfast (nuc) Version 7.407
2208 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2209 1 thread(s)
2210
2211 generating a scoring matrix for nucleotide (dist=200) ... done
2212
2213 0 / 4 (thread 0)dndpre (nuc) Version 7.407
2214 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
2215 1 thread(s)
2216
2217 minimumweight = 0.000010
2218 autosubalignment = 0.000000
2219 nthread = 1
2220 randomseed = 0
2221 blosum 62 / kimura 200
2222 poffset = 0
2223 niter = 1
2224 sueff_global = 0.100000
2225 nadd = 1
2226 nsubalignments = 2
2227 maxmem = 2
2228 generating a scoring matrix for nucleotide (dist=200) ... done
2229
2230
2231
2232 0 / 4
2233
2234 Checking subalignment 1:
2235 1 2
2236 -> OK
2237
2238 Checking subalignment 2:
2239 3 4
2240 -> OK
2241 Segment 1/ 1 1- 156
2242 001-0000-0 (thread 1) skip
2243
2244 001-0001-1 (thread 1) skip
2245
2246 001-0002-0 (thread 1) skip
2247
2248 001-0003-1 (thread 1) skip
2249
2250 001-0004-1 (thread 1) identical
2251 001-0004-1 (thread 1) worse
2252
2253 Converged.
2254
2255 Reached 1
2256 done
2257 dvtditr (nuc) Version 7.407
2258 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2259 1 thread(s)
2260
2261
2262 Strategy:
2263 FFT-NS-i (Standard)
2264 Iterative refinement method (max. 1 iterations)
2265
2266 If unsure which option to use, try 'mafft --auto input > output'.
2267 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2268
2269 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2270 It tends to insert more gaps into gap-rich regions than previous versions.
2271 To disable this change, add the --leavegappyregion option.
2272
2273 inputfile = orig
2274 5 x 91 - 78 d
2275 nthread = 1
2276 nthreadpair = 1
2277 nthreadtb = 1
2278 ppenalty_ex = 0
2279 stacksize: 8192 kb
2280 nsubalignments = 2
2281 maxmem = 3
2282 generating a scoring matrix for nucleotide (dist=200) ... done
2283 Gap Penalty = -1.53, +0.00, +0.00
2284
2285
2286
2287 Making a distance matrix ..
2288
2289 1 / 5 (thread 0)
2290 done.
2291
2292 Constructing a UPGMA tree ...
2293
2294
2295 0 / 5
2296 done.
2297
2298 Checking subalignment 1:
2299 -> OK
2300 Checking subalignment 2:
2301 -> OK
2302 Progressive alignment 1/2...
2303
2304 STEP 4 / 4 (thread 0) f
2305 done.
2306
2307 Making a distance matrix from msa..
2308
2309 0 / 5 (thread 0)
2310 done.
2311
2312 Constructing a UPGMA tree ...
2313
2314
2315 0 / 5
2316 done.
2317
2318 Checking subalignment 1:
2319 -> OK
2320 Checking subalignment 2:
2321 -> OK
2322 Progressive alignment 2/2...
2323
2324 STEP 4 / 4 (thread 0) f
2325 done.
2326
2327 disttbfast (nuc) Version 7.407
2328 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2329 1 thread(s)
2330
2331 generating a scoring matrix for nucleotide (dist=200) ... done
2332
2333 0 / 5 (thread 0)dndpre (nuc) Version 7.407
2334 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
2335 1 thread(s)
2336
2337 minimumweight = 0.000010
2338 autosubalignment = 0.000000
2339 nthread = 1
2340 randomseed = 0
2341 blosum 62 / kimura 200
2342 poffset = 0
2343 niter = 1
2344 sueff_global = 0.100000
2345 nadd = 1
2346 nsubalignments = 2
2347 maxmem = 3
2348 generating a scoring matrix for nucleotide (dist=200) ... done
2349
2350
2351
2352 0 / 5
2353
2354 Checking subalignment 1:
2355 1 2
2356 -> OK
2357
2358 Checking subalignment 2:
2359 3 4 5
2360 -> OK
2361 Segment 1/ 1 1- 108
2362 001-0000-0 (thread 1) skip
2363
2364 001-0001-1 (thread 1) skip
2365
2366 001-0002-0 (thread 1) skip
2367
2368 001-0003-1 (thread 1) skip
2369
2370 001-0004-0 (thread 1) skip
2371
2372 001-0005-1 (thread 1) skip
2373
2374 001-0006-1 (thread 1) identical
2375 001-0006-1 (thread 1) better
2376
2377 Reached 1
2378 done
2379 dvtditr (nuc) Version 7.407
2380 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2381 1 thread(s)
2382
2383
2384 Strategy:
2385 FFT-NS-i (Standard)
2386 Iterative refinement method (max. 1 iterations)
2387
2388 If unsure which option to use, try 'mafft --auto input > output'.
2389 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2390
2391 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2392 It tends to insert more gaps into gap-rich regions than previous versions.
2393 To disable this change, add the --leavegappyregion option.
2394
2395 inputfile = orig
2396 4 x 117 - 114 d
2397 nthread = 1
2398 nthreadpair = 1
2399 nthreadtb = 1
2400 ppenalty_ex = 0
2401 stacksize: 8192 kb
2402 nsubalignments = 2
2403 maxmem = 2
2404 generating a scoring matrix for nucleotide (dist=200) ... done
2405 Gap Penalty = -1.53, +0.00, +0.00
2406
2407
2408
2409 Making a distance matrix ..
2410
2411 1 / 4 (thread 0)
2412 done.
2413
2414 Constructing a UPGMA tree ...
2415
2416
2417 0 / 4
2418 done.
2419
2420 Checking subalignment 1:
2421 -> OK
2422 Checking subalignment 2:
2423 -> OK
2424 Progressive alignment 1/2...
2425
2426 STEP 3 / 3 (thread 0) f
2427 done.
2428
2429 Making a distance matrix from msa..
2430
2431 0 / 4 (thread 0)
2432 done.
2433
2434 Constructing a UPGMA tree ...
2435
2436
2437 0 / 4
2438 done.
2439
2440 Checking subalignment 1:
2441 -> OK
2442 Checking subalignment 2:
2443 -> OK
2444 Progressive alignment 2/2...
2445
2446 STEP 3 / 3 (thread 0) f
2447 done.
2448
2449 disttbfast (nuc) Version 7.407
2450 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2451 1 thread(s)
2452
2453 generating a scoring matrix for nucleotide (dist=200) ... done
2454
2455 0 / 4 (thread 0)dndpre (nuc) Version 7.407
2456 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
2457 1 thread(s)
2458
2459 minimumweight = 0.000010
2460 autosubalignment = 0.000000
2461 nthread = 1
2462 randomseed = 0
2463 blosum 62 / kimura 200
2464 poffset = 0
2465 niter = 1
2466 sueff_global = 0.100000
2467 nadd = 1
2468 nsubalignments = 2
2469 maxmem = 2
2470 generating a scoring matrix for nucleotide (dist=200) ... done
2471
2472
2473
2474 0 / 4
2475
2476 Checking subalignment 1:
2477 1 2
2478 -> OK
2479
2480 Checking subalignment 2:
2481 3 4
2482 -> OK
2483 Segment 1/ 2 1- 62
2484 001-0000-0 (thread 1) skip
2485
2486 001-0001-1 (thread 1) skip
2487
2488 001-0002-0 (thread 1) skip
2489
2490 001-0003-1 (thread 1) skip
2491
2492 001-0004-1 (thread 1) identical
2493
2494 Converged.
2495
2496 Reached 1
2497 Segment 2/ 2 62- 134
2498 001-0000-0 (thread 1) skip
2499
2500 001-0001-1 (thread 1) skip
2501
2502 001-0002-0 (thread 1) skip
2503
2504 001-0003-1 (thread 1) skip
2505
2506 001-0004-1 (thread 1) identical
2507 001-0004-1 (thread 1) better
2508
2509 Reached 1
2510 done
2511 dvtditr (nuc) Version 7.407
2512 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2513 1 thread(s)
2514
2515
2516 Strategy:
2517 FFT-NS-i (Standard)
2518 Iterative refinement method (max. 1 iterations)
2519
2520 If unsure which option to use, try 'mafft --auto input > output'.
2521 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2522
2523 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2524 It tends to insert more gaps into gap-rich regions than previous versions.
2525 To disable this change, add the --leavegappyregion option.
2526
2527 inputfile = orig
2528 3 x 78 - 70 d
2529 nadd = 1
2530 generating a scoring matrix for nucleotide (dist=200) ... done
2531
2532 0 / 2 (thread 0)dndpre (nuc) Version 7.407
2533 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2534 1 thread(s)
2535
2536 generating a scoring matrix for nucleotide (dist=200) ... done
2537 All-to-all alignment.
2538
2539
2540 ##### writing hat3
2541 pairlocalalign (nuc) Version 7.407
2542 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2543 1 thread(s)
2544
2545 nadd = 1
2546 ppenalty_ex = -10
2547 nthread = 1
2548 blosum 62 / kimura 200
2549 sueff_global = 0.100000
2550 norg = 2
2551 njobc = 3
2552 Loading 'hat3' ...
2553 done.
2554 generating a scoring matrix for nucleotide (dist=200) ... done
2555 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2556 Loading 'hat2i' (aligned sequences) ... done.
2557
2558 0 / 1 (thread 0)
2559 c
2560
2561 Combining ..
2562 0 / 1
2563 0 / 1
2564
2565 done.
2566
2567
2568 done.
2569
2570 addsingle (nuc) Version 7.407
2571 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2572 1 thread(s)
2573
2574
2575 Strategy:
2576 Multi-INS-fragment (Not tested.)
2577 ?
2578
2579 If unsure which option to use, try 'mafft --auto input > output'.
2580 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2581
2582 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2583 It tends to insert more gaps into gap-rich regions than previous versions.
2584 To disable this change, add the --leavegappyregion option.
2585
2586 inputfile = orig
2587 4 x 102 - 70 d
2588 nadd = 1
2589 generating a scoring matrix for nucleotide (dist=200) ... done
2590
2591 0 / 3 (thread 0)dndpre (nuc) Version 7.407
2592 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2593 1 thread(s)
2594
2595 generating a scoring matrix for nucleotide (dist=200) ... done
2596 All-to-all alignment.
2597
2598
2599 ##### writing hat3
2600 pairlocalalign (nuc) Version 7.407
2601 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2602 1 thread(s)
2603
2604 nadd = 1
2605 ppenalty_ex = -10
2606 nthread = 1
2607 blosum 62 / kimura 200
2608 sueff_global = 0.100000
2609 norg = 3
2610 njobc = 4
2611 Loading 'hat3' ...
2612 done.
2613 generating a scoring matrix for nucleotide (dist=200) ... done
2614 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2615 Loading 'hat2i' (aligned sequences) ... done.
2616
2617 0 / 1 (thread 0)
2618 c
2619
2620 Combining ..
2621 0 / 1
2622 0 / 1
2623
2624 done.
2625
2626
2627 done.
2628
2629 addsingle (nuc) Version 7.407
2630 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2631 1 thread(s)
2632
2633
2634 Strategy:
2635 Multi-INS-fragment (Not tested.)
2636 ?
2637
2638 If unsure which option to use, try 'mafft --auto input > output'.
2639 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2640
2641 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2642 It tends to insert more gaps into gap-rich regions than previous versions.
2643 To disable this change, add the --leavegappyregion option.
2644
2645 inputfile = orig
2646 5 x 84 - 70 d
2647 nadd = 1
2648 generating a scoring matrix for nucleotide (dist=200) ... done
2649
2650 0 / 4 (thread 0)dndpre (nuc) Version 7.407
2651 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2652 1 thread(s)
2653
2654 generating a scoring matrix for nucleotide (dist=200) ... done
2655 All-to-all alignment.
2656
2657
2658 ##### writing hat3
2659 pairlocalalign (nuc) Version 7.407
2660 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2661 1 thread(s)
2662
2663 nadd = 1
2664 ppenalty_ex = -10
2665 nthread = 1
2666 blosum 62 / kimura 200
2667 sueff_global = 0.100000
2668 norg = 4
2669 njobc = 5
2670 Loading 'hat3' ...
2671 done.
2672 generating a scoring matrix for nucleotide (dist=200) ... done
2673 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2674 Loading 'hat2i' (aligned sequences) ... done.
2675
2676 0 / 1 (thread 0)
2677 c
2678
2679 Combining ..
2680 0 / 1
2681 0 / 1
2682
2683 done.
2684
2685
2686 done.
2687
2688 addsingle (nuc) Version 7.407
2689 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2690 1 thread(s)
2691
2692
2693 Strategy:
2694 Multi-INS-fragment (Not tested.)
2695 ?
2696
2697 If unsure which option to use, try 'mafft --auto input > output'.
2698 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2699
2700 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2701 It tends to insert more gaps into gap-rich regions than previous versions.
2702 To disable this change, add the --leavegappyregion option.
2703
2704 inputfile = orig
2705 3 x 72 - 70 d
2706 nadd = 1
2707 generating a scoring matrix for nucleotide (dist=200) ... done
2708
2709 0 / 2 (thread 0)dndpre (nuc) Version 7.407
2710 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2711 1 thread(s)
2712
2713 generating a scoring matrix for nucleotide (dist=200) ... done
2714 All-to-all alignment.
2715
2716
2717 ##### writing hat3
2718 pairlocalalign (nuc) Version 7.407
2719 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
2720 1 thread(s)
2721
2722 nadd = 1
2723 ppenalty_ex = -10
2724 nthread = 1
2725 blosum 62 / kimura 200
2726 sueff_global = 0.100000
2727 norg = 2
2728 njobc = 3
2729 Loading 'hat3' ...
2730 done.
2731 generating a scoring matrix for nucleotide (dist=200) ... done
2732 Loading 'hat2n' (aligned sequences - new sequences) ... done.
2733 Loading 'hat2i' (aligned sequences) ... done.
2734
2735 0 / 1 (thread 0)
2736 c
2737
2738 Combining ..
2739 0 / 1
2740 0 / 1
2741
2742 done.
2743
2744
2745 done.
2746
2747 addsingle (nuc) Version 7.407
2748 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2749 1 thread(s)
2750
2751
2752 Strategy:
2753 Multi-INS-fragment (Not tested.)
2754 ?
2755
2756 If unsure which option to use, try 'mafft --auto input > output'.
2757 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2758
2759 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2760 It tends to insert more gaps into gap-rich regions than previous versions.
2761 To disable this change, add the --leavegappyregion option.
2762
2763 inputfile = orig
2764 4 x 99 - 76 d
2765 nthread = 1
2766 nthreadpair = 1
2767 nthreadtb = 1
2768 ppenalty_ex = 0
2769 stacksize: 8192 kb
2770 nsubalignments = 2
2771 maxmem = 2
2772 generating a scoring matrix for nucleotide (dist=200) ... done
2773 Gap Penalty = -1.53, +0.00, +0.00
2774
2775
2776
2777 Making a distance matrix ..
2778
2779 1 / 4 (thread 0)
2780 done.
2781
2782 Constructing a UPGMA tree ...
2783
2784
2785 0 / 4
2786 ###################################################################
2787 # WARNING: Group 2 is forced to be a monophyletic cluster.
2788 ###################################################################
2789
2790 done.
2791
2792 Checking subalignment 1:
2793 -> OK
2794 Checking subalignment 2:
2795 -> OK
2796 Progressive alignment 1/2...
2797
2798 STEP 3 / 3 (thread 0) f
2799 done.
2800
2801 Making a distance matrix from msa..
2802
2803 0 / 4 (thread 0)
2804 done.
2805
2806 Constructing a UPGMA tree ...
2807
2808
2809 0 / 4
2810 done.
2811
2812 Checking subalignment 1:
2813 -> OK
2814 Checking subalignment 2:
2815 -> OK
2816 Progressive alignment 2/2...
2817
2818 STEP 3 / 3 (thread 0) f
2819 done.
2820
2821 disttbfast (nuc) Version 7.407
2822 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2823 1 thread(s)
2824
2825 generating a scoring matrix for nucleotide (dist=200) ... done
2826
2827 0 / 4 (thread 0)dndpre (nuc) Version 7.407
2828 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
2829 1 thread(s)
2830
2831 minimumweight = 0.000010
2832 autosubalignment = 0.000000
2833 nthread = 1
2834 randomseed = 0
2835 blosum 62 / kimura 200
2836 poffset = 0
2837 niter = 1
2838 sueff_global = 0.100000
2839 nadd = 1
2840 nsubalignments = 2
2841 maxmem = 2
2842 generating a scoring matrix for nucleotide (dist=200) ... done
2843
2844
2845
2846 0 / 4
2847
2848 Checking subalignment 1:
2849 1 2
2850 -> OK
2851
2852 Checking subalignment 2:
2853 3 4
2854 -> OK
2855 Segment 1/ 1 1- 103
2856 001-0000-0 (thread 1) skip
2857
2858 001-0001-1 (thread 1) skip
2859
2860 001-0002-0 (thread 1) skip
2861
2862 001-0003-1 (thread 1) skip
2863
2864 001-0004-1 (thread 1) identical
2865 001-0004-1 (thread 1) better
2866
2867 Reached 1
2868 done
2869 dvtditr (nuc) Version 7.407
2870 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2871 1 thread(s)
2872
2873
2874 Strategy:
2875 FFT-NS-i (Standard)
2876 Iterative refinement method (max. 1 iterations)
2877
2878 If unsure which option to use, try 'mafft --auto input > output'.
2879 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
2880
2881 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
2882 It tends to insert more gaps into gap-rich regions than previous versions.
2883 To disable this change, add the --leavegappyregion option.
2884
2885 inputfile = orig
2886 5 x 101 - 72 d
2887 nthread = 1
2888 nthreadpair = 1
2889 nthreadtb = 1
2890 ppenalty_ex = 0
2891 stacksize: 8192 kb
2892 nsubalignments = 2
2893 maxmem = 3
2894 generating a scoring matrix for nucleotide (dist=200) ... done
2895 Gap Penalty = -1.53, +0.00, +0.00
2896
2897
2898
2899 Making a distance matrix ..
2900
2901 1 / 5 (thread 0)
2902 done.
2903
2904 Constructing a UPGMA tree ...
2905
2906
2907 0 / 5
2908 done.
2909
2910 Checking subalignment 1:
2911 -> OK
2912 Checking subalignment 2:
2913 -> OK
2914 Progressive alignment 1/2...
2915
2916 STEP 4 / 4 (thread 0) f
2917 done.
2918
2919 Making a distance matrix from msa..
2920
2921 0 / 5 (thread 0)
2922 done.
2923
2924 Constructing a UPGMA tree ...
2925
2926
2927 0 / 5
2928 done.
2929
2930 Checking subalignment 1:
2931 -> OK
2932 Checking subalignment 2:
2933 -> OK
2934 Progressive alignment 2/2...
2935
2936 STEP 4 / 4 (thread 0) f
2937 done.
2938
2939 disttbfast (nuc) Version 7.407
2940 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2941 1 thread(s)
2942
2943 generating a scoring matrix for nucleotide (dist=200) ... done
2944
2945 0 / 5 (thread 0)dndpre (nuc) Version 7.407
2946 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
2947 1 thread(s)
2948
2949 minimumweight = 0.000010
2950 autosubalignment = 0.000000
2951 nthread = 1
2952 randomseed = 0
2953 blosum 62 / kimura 200
2954 poffset = 0
2955 niter = 1
2956 sueff_global = 0.100000
2957 nadd = 1
2958 nsubalignments = 2
2959 maxmem = 3
2960 generating a scoring matrix for nucleotide (dist=200) ... done
2961
2962
2963
2964 0 / 5
2965
2966 Checking subalignment 1:
2967 1 2 3
2968 -> OK
2969
2970 Checking subalignment 2:
2971 4 5
2972 -> OK
2973 Segment 1/ 1 1- 102
2974 001-0000-0 (thread 1) skip
2975
2976 001-0001-1 (thread 1) skip
2977
2978 001-0002-0 (thread 1) skip
2979
2980 001-0003-1 (thread 1) skip
2981
2982 001-0004-0 (thread 1) skip
2983
2984 001-0005-1 (thread 1) skip
2985
2986 001-0006-1 (thread 1) identical
2987
2988 Converged.
2989
2990 Reached 1
2991 done
2992 dvtditr (nuc) Version 7.407
2993 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
2994 1 thread(s)
2995
2996
2997 Strategy:
2998 FFT-NS-i (Standard)
2999 Iterative refinement method (max. 1 iterations)
3000
3001 If unsure which option to use, try 'mafft --auto input > output'.
3002 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3003
3004 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3005 It tends to insert more gaps into gap-rich regions than previous versions.
3006 To disable this change, add the --leavegappyregion option.
3007
3008 inputfile = orig
3009 4 x 95 - 71 d
3010 nthread = 1
3011 nthreadpair = 1
3012 nthreadtb = 1
3013 ppenalty_ex = 0
3014 stacksize: 8192 kb
3015 nsubalignments = 2
3016 maxmem = 2
3017 generating a scoring matrix for nucleotide (dist=200) ... done
3018 Gap Penalty = -1.53, +0.00, +0.00
3019
3020
3021
3022 Making a distance matrix ..
3023
3024 1 / 4 (thread 0)
3025 done.
3026
3027 Constructing a UPGMA tree ...
3028
3029
3030 0 / 4
3031 done.
3032
3033 Checking subalignment 1:
3034 -> OK
3035 Checking subalignment 2:
3036 -> OK
3037 Progressive alignment 1/2...
3038
3039 STEP 3 / 3 (thread 0) f
3040 done.
3041
3042 Making a distance matrix from msa..
3043
3044 0 / 4 (thread 0)
3045 done.
3046
3047 Constructing a UPGMA tree ...
3048
3049
3050 0 / 4
3051 done.
3052
3053 Checking subalignment 1:
3054 -> OK
3055 Checking subalignment 2:
3056 -> OK
3057 Progressive alignment 2/2...
3058
3059 STEP 3 / 3 (thread 0) f
3060 done.
3061
3062 disttbfast (nuc) Version 7.407
3063 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3064 1 thread(s)
3065
3066 generating a scoring matrix for nucleotide (dist=200) ... done
3067
3068 0 / 4 (thread 0)dndpre (nuc) Version 7.407
3069 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3070 1 thread(s)
3071
3072 minimumweight = 0.000010
3073 autosubalignment = 0.000000
3074 nthread = 1
3075 randomseed = 0
3076 blosum 62 / kimura 200
3077 poffset = 0
3078 niter = 1
3079 sueff_global = 0.100000
3080 nadd = 1
3081 nsubalignments = 2
3082 maxmem = 2
3083 generating a scoring matrix for nucleotide (dist=200) ... done
3084
3085
3086
3087 0 / 4
3088
3089 Checking subalignment 1:
3090 1 2
3091 -> OK
3092
3093 Checking subalignment 2:
3094 3 4
3095 -> OK
3096 Segment 1/ 1 1- 114
3097 001-0000-0 (thread 1) skip
3098
3099 001-0001-1 (thread 1) skip
3100
3101 001-0002-0 (thread 1) skip
3102
3103 001-0003-1 (thread 1) skip
3104
3105 001-0004-1 (thread 1) identical
3106 001-0004-1 (thread 1) better
3107
3108 Reached 1
3109 done
3110 dvtditr (nuc) Version 7.407
3111 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3112 1 thread(s)
3113
3114
3115 Strategy:
3116 FFT-NS-i (Standard)
3117 Iterative refinement method (max. 1 iterations)
3118
3119 If unsure which option to use, try 'mafft --auto input > output'.
3120 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3121
3122 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3123 It tends to insert more gaps into gap-rich regions than previous versions.
3124 To disable this change, add the --leavegappyregion option.
3125
3126 inputfile = orig
3127 4 x 102 - 70 d
3128 nadd = 1
3129 generating a scoring matrix for nucleotide (dist=200) ... done
3130
3131 0 / 3 (thread 0)dndpre (nuc) Version 7.407
3132 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3133 1 thread(s)
3134
3135 generating a scoring matrix for nucleotide (dist=200) ... done
3136 All-to-all alignment.
3137
3138
3139 ##### writing hat3
3140 pairlocalalign (nuc) Version 7.407
3141 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3142 1 thread(s)
3143
3144 nadd = 1
3145 ppenalty_ex = -10
3146 nthread = 1
3147 blosum 62 / kimura 200
3148 sueff_global = 0.100000
3149 norg = 3
3150 njobc = 4
3151 Loading 'hat3' ...
3152 done.
3153 generating a scoring matrix for nucleotide (dist=200) ... done
3154 Loading 'hat2n' (aligned sequences - new sequences) ... done.
3155 Loading 'hat2i' (aligned sequences) ... done.
3156
3157 0 / 1 (thread 0)
3158 c
3159
3160 Combining ..
3161 0 / 1
3162 0 / 1
3163
3164 done.
3165
3166
3167 done.
3168
3169 addsingle (nuc) Version 7.407
3170 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3171 1 thread(s)
3172
3173
3174 Strategy:
3175 Multi-INS-fragment (Not tested.)
3176 ?
3177
3178 If unsure which option to use, try 'mafft --auto input > output'.
3179 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3180
3181 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3182 It tends to insert more gaps into gap-rich regions than previous versions.
3183 To disable this change, add the --leavegappyregion option.
3184
3185 inputfile = orig
3186 6 x 115 - 96 d
3187 nthread = 1
3188 nthreadpair = 1
3189 nthreadtb = 1
3190 ppenalty_ex = 0
3191 stacksize: 8192 kb
3192 nsubalignments = 2
3193 maxmem = 3
3194 generating a scoring matrix for nucleotide (dist=200) ... done
3195 Gap Penalty = -1.53, +0.00, +0.00
3196
3197
3198
3199 Making a distance matrix ..
3200
3201 1 / 6 (thread 0)
3202 done.
3203
3204 Constructing a UPGMA tree ...
3205
3206
3207 0 / 6
3208 done.
3209
3210 Checking subalignment 1:
3211 -> OK
3212 Checking subalignment 2:
3213 -> OK
3214 Progressive alignment 1/2...
3215
3216 STEP 5 / 5 (thread 0) f
3217 done.
3218
3219 Making a distance matrix from msa..
3220
3221 0 / 6 (thread 0)
3222 done.
3223
3224 Constructing a UPGMA tree ...
3225
3226
3227 0 / 6
3228 done.
3229
3230 Checking subalignment 1:
3231 -> OK
3232 Checking subalignment 2:
3233 -> OK
3234 Progressive alignment 2/2...
3235
3236 STEP 5 / 5 (thread 0) f
3237 done.
3238
3239 disttbfast (nuc) Version 7.407
3240 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3241 1 thread(s)
3242
3243 generating a scoring matrix for nucleotide (dist=200) ... done
3244
3245 0 / 6 (thread 0)dndpre (nuc) Version 7.407
3246 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3247 1 thread(s)
3248
3249 minimumweight = 0.000010
3250 autosubalignment = 0.000000
3251 nthread = 1
3252 randomseed = 0
3253 blosum 62 / kimura 200
3254 poffset = 0
3255 niter = 1
3256 sueff_global = 0.100000
3257 nadd = 1
3258 nsubalignments = 2
3259 maxmem = 3
3260 generating a scoring matrix for nucleotide (dist=200) ... done
3261
3262
3263
3264 0 / 6
3265
3266 Checking subalignment 1:
3267 1 2 3
3268 -> OK
3269
3270 Checking subalignment 2:
3271 4 5 6
3272 -> OK
3273 Segment 1/ 1 1- 154
3274 001-0000-0 (thread 1) skip
3275
3276 001-0001-1 (thread 1) skip
3277
3278 001-0002-0 (thread 1) skip
3279
3280 001-0003-1 (thread 1) skip
3281
3282 001-0004-0 (thread 1) skip
3283
3284 001-0005-1 (thread 1) skip
3285
3286 001-0006-0 (thread 1) skip
3287
3288 001-0007-1 (thread 1) skip
3289
3290 001-0008-1 (thread 1) identical
3291 001-0008-1 (thread 1) better
3292
3293 Reached 1
3294 done
3295 dvtditr (nuc) Version 7.407
3296 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3297 1 thread(s)
3298
3299
3300 Strategy:
3301 FFT-NS-i (Standard)
3302 Iterative refinement method (max. 1 iterations)
3303
3304 If unsure which option to use, try 'mafft --auto input > output'.
3305 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3306
3307 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3308 It tends to insert more gaps into gap-rich regions than previous versions.
3309 To disable this change, add the --leavegappyregion option.
3310
3311 inputfile = orig
3312 6 x 110 - 70 d
3313 nadd = 1
3314 generating a scoring matrix for nucleotide (dist=200) ... done
3315
3316 0 / 5 (thread 0)dndpre (nuc) Version 7.407
3317 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3318 1 thread(s)
3319
3320 generating a scoring matrix for nucleotide (dist=200) ... done
3321 All-to-all alignment.
3322
3323
3324 ##### writing hat3
3325 pairlocalalign (nuc) Version 7.407
3326 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3327 1 thread(s)
3328
3329 nadd = 1
3330 ppenalty_ex = -10
3331 nthread = 1
3332 blosum 62 / kimura 200
3333 sueff_global = 0.100000
3334 norg = 5
3335 njobc = 6
3336 Loading 'hat3' ...
3337 done.
3338 generating a scoring matrix for nucleotide (dist=200) ... done
3339 Loading 'hat2n' (aligned sequences - new sequences) ... done.
3340 Loading 'hat2i' (aligned sequences) ... done.
3341
3342 0 / 1 (thread 0)
3343 c
3344
3345 Combining ..
3346 0 / 1
3347 0 / 1
3348
3349 done.
3350
3351
3352 done.
3353
3354 addsingle (nuc) Version 7.407
3355 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3356 1 thread(s)
3357
3358
3359 Strategy:
3360 Multi-INS-fragment (Not tested.)
3361 ?
3362
3363 If unsure which option to use, try 'mafft --auto input > output'.
3364 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3365
3366 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3367 It tends to insert more gaps into gap-rich regions than previous versions.
3368 To disable this change, add the --leavegappyregion option.
3369
3370 inputfile = orig
3371 4 x 108 - 70 d
3372 nadd = 1
3373 generating a scoring matrix for nucleotide (dist=200) ... done
3374
3375 0 / 3 (thread 0)dndpre (nuc) Version 7.407
3376 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3377 1 thread(s)
3378
3379 generating a scoring matrix for nucleotide (dist=200) ... done
3380 All-to-all alignment.
3381
3382
3383 ##### writing hat3
3384 pairlocalalign (nuc) Version 7.407
3385 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
3386 1 thread(s)
3387
3388 nadd = 1
3389 ppenalty_ex = -10
3390 nthread = 1
3391 blosum 62 / kimura 200
3392 sueff_global = 0.100000
3393 norg = 3
3394 njobc = 4
3395 Loading 'hat3' ...
3396 done.
3397 generating a scoring matrix for nucleotide (dist=200) ... done
3398 Loading 'hat2n' (aligned sequences - new sequences) ... done.
3399 Loading 'hat2i' (aligned sequences) ... done.
3400
3401 0 / 1 (thread 0)
3402 c
3403
3404 Combining ..
3405 0 / 1
3406 0 / 1
3407
3408 done.
3409
3410
3411 done.
3412
3413 addsingle (nuc) Version 7.407
3414 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3415 1 thread(s)
3416
3417
3418 Strategy:
3419 Multi-INS-fragment (Not tested.)
3420 ?
3421
3422 If unsure which option to use, try 'mafft --auto input > output'.
3423 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3424
3425 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3426 It tends to insert more gaps into gap-rich regions than previous versions.
3427 To disable this change, add the --leavegappyregion option.
3428
3429 inputfile = orig
3430 5 x 93 - 87 d
3431 nthread = 1
3432 nthreadpair = 1
3433 nthreadtb = 1
3434 ppenalty_ex = 0
3435 stacksize: 8192 kb
3436 nsubalignments = 2
3437 maxmem = 3
3438 generating a scoring matrix for nucleotide (dist=200) ... done
3439 Gap Penalty = -1.53, +0.00, +0.00
3440
3441
3442
3443 Making a distance matrix ..
3444
3445 1 / 5 (thread 0)
3446 done.
3447
3448 Constructing a UPGMA tree ...
3449
3450
3451 0 / 5
3452 done.
3453
3454 Checking subalignment 1:
3455 -> OK
3456 Checking subalignment 2:
3457 -> OK
3458 Progressive alignment 1/2...
3459
3460 STEP 4 / 4 (thread 0) f
3461 done.
3462
3463 Making a distance matrix from msa..
3464
3465 0 / 5 (thread 0)
3466 done.
3467
3468 Constructing a UPGMA tree ...
3469
3470
3471 0 / 5
3472 done.
3473
3474 Checking subalignment 1:
3475 -> OK
3476 Checking subalignment 2:
3477 -> OK
3478 Progressive alignment 2/2...
3479
3480 STEP 4 / 4 (thread 0) f
3481 done.
3482
3483 disttbfast (nuc) Version 7.407
3484 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3485 1 thread(s)
3486
3487 generating a scoring matrix for nucleotide (dist=200) ... done
3488
3489 0 / 5 (thread 0)dndpre (nuc) Version 7.407
3490 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3491 1 thread(s)
3492
3493 minimumweight = 0.000010
3494 autosubalignment = 0.000000
3495 nthread = 1
3496 randomseed = 0
3497 blosum 62 / kimura 200
3498 poffset = 0
3499 niter = 1
3500 sueff_global = 0.100000
3501 nadd = 1
3502 nsubalignments = 2
3503 maxmem = 3
3504 generating a scoring matrix for nucleotide (dist=200) ... done
3505
3506
3507
3508 0 / 5
3509
3510 Checking subalignment 1:
3511 1 2
3512 -> OK
3513
3514 Checking subalignment 2:
3515 3 4 5
3516 -> OK
3517 Segment 1/ 1 1- 102
3518 001-0000-0 (thread 1) skip
3519
3520 001-0001-1 (thread 1) skip
3521
3522 001-0002-0 (thread 1) skip
3523
3524 001-0003-1 (thread 1) skip
3525
3526 001-0004-0 (thread 1) skip
3527
3528 001-0005-1 (thread 1) skip
3529
3530 001-0006-1 (thread 1) identical
3531 001-0006-1 (thread 1) better
3532
3533 Reached 1
3534 done
3535 dvtditr (nuc) Version 7.407
3536 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3537 1 thread(s)
3538
3539
3540 Strategy:
3541 FFT-NS-i (Standard)
3542 Iterative refinement method (max. 1 iterations)
3543
3544 If unsure which option to use, try 'mafft --auto input > output'.
3545 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3546
3547 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3548 It tends to insert more gaps into gap-rich regions than previous versions.
3549 To disable this change, add the --leavegappyregion option.
3550
3551 inputfile = orig
3552 8 x 98 - 87 d
3553 nthread = 1
3554 nthreadpair = 1
3555 nthreadtb = 1
3556 ppenalty_ex = 0
3557 stacksize: 8192 kb
3558 nsubalignments = 2
3559 maxmem = 5
3560 generating a scoring matrix for nucleotide (dist=200) ... done
3561 Gap Penalty = -1.53, +0.00, +0.00
3562
3563
3564
3565 Making a distance matrix ..
3566
3567 1 / 8 (thread 0)
3568 done.
3569
3570 Constructing a UPGMA tree ...
3571
3572
3573 0 / 8
3574 done.
3575
3576 Checking subalignment 1:
3577 -> OK
3578 Checking subalignment 2:
3579 -> OK
3580 Progressive alignment 1/2...
3581
3582 STEP 7 / 7 (thread 0) f
3583 done.
3584
3585 Making a distance matrix from msa..
3586
3587 0 / 8 (thread 0)
3588 done.
3589
3590 Constructing a UPGMA tree ...
3591
3592
3593 0 / 8
3594 done.
3595
3596 Checking subalignment 1:
3597 -> OK
3598 Checking subalignment 2:
3599 -> OK
3600 Progressive alignment 2/2...
3601
3602 STEP 7 / 7 (thread 0) f
3603 done.
3604
3605 disttbfast (nuc) Version 7.407
3606 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3607 1 thread(s)
3608
3609 generating a scoring matrix for nucleotide (dist=200) ... done
3610
3611 0 / 8 (thread 0)dndpre (nuc) Version 7.407
3612 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3613 1 thread(s)
3614
3615 minimumweight = 0.000010
3616 autosubalignment = 0.000000
3617 nthread = 1
3618 randomseed = 0
3619 blosum 62 / kimura 200
3620 poffset = 0
3621 niter = 1
3622 sueff_global = 0.100000
3623 nadd = 1
3624 nsubalignments = 2
3625 maxmem = 5
3626 generating a scoring matrix for nucleotide (dist=200) ... done
3627
3628
3629
3630 0 / 8
3631
3632 Checking subalignment 1:
3633 1 2 3
3634 -> OK
3635
3636 Checking subalignment 2:
3637 4 5 6 7 8
3638 -> OK
3639 Segment 1/ 1 1- 105
3640 001-0000-0 (thread 1) skip
3641
3642 001-0001-1 (thread 1) skip
3643
3644 001-0002-0 (thread 1) skip
3645
3646 001-0003-1 (thread 1) skip
3647
3648 001-0004-0 (thread 1) skip
3649
3650 001-0005-1 (thread 1) skip
3651
3652 001-0006-0 (thread 1) skip
3653
3654 001-0007-1 (thread 1) skip
3655
3656 001-0008-0 (thread 1) skip
3657
3658 001-0009-1 (thread 1) skip
3659
3660 001-0010-0 (thread 1) skip
3661
3662 001-0011-1 (thread 1) skip
3663
3664 001-0012-1 (thread 1) identical
3665
3666 Converged.
3667
3668 Reached 1
3669 done
3670 dvtditr (nuc) Version 7.407
3671 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3672 1 thread(s)
3673
3674
3675 Strategy:
3676 FFT-NS-i (Standard)
3677 Iterative refinement method (max. 1 iterations)
3678
3679 If unsure which option to use, try 'mafft --auto input > output'.
3680 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3681
3682 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3683 It tends to insert more gaps into gap-rich regions than previous versions.
3684 To disable this change, add the --leavegappyregion option.
3685
3686 inputfile = orig
3687 5 x 97 - 74 d
3688 nthread = 1
3689 nthreadpair = 1
3690 nthreadtb = 1
3691 ppenalty_ex = 0
3692 stacksize: 8192 kb
3693 nsubalignments = 2
3694 maxmem = 3
3695 generating a scoring matrix for nucleotide (dist=200) ... done
3696 Gap Penalty = -1.53, +0.00, +0.00
3697
3698
3699
3700 Making a distance matrix ..
3701
3702 1 / 5 (thread 0)
3703 done.
3704
3705 Constructing a UPGMA tree ...
3706
3707
3708 0 / 5
3709 done.
3710
3711 Checking subalignment 1:
3712 -> OK
3713 Checking subalignment 2:
3714 -> OK
3715 Progressive alignment 1/2...
3716
3717 STEP 4 / 4 (thread 0) f
3718 done.
3719
3720 Making a distance matrix from msa..
3721
3722 0 / 5 (thread 0)
3723 done.
3724
3725 Constructing a UPGMA tree ...
3726
3727
3728 0 / 5
3729 done.
3730
3731 Checking subalignment 1:
3732 -> OK
3733 Checking subalignment 2:
3734 -> OK
3735 Progressive alignment 2/2...
3736
3737 STEP 4 / 4 (thread 0) f
3738 done.
3739
3740 disttbfast (nuc) Version 7.407
3741 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3742 1 thread(s)
3743
3744 generating a scoring matrix for nucleotide (dist=200) ... done
3745
3746 0 / 5 (thread 0)dndpre (nuc) Version 7.407
3747 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3748 1 thread(s)
3749
3750 minimumweight = 0.000010
3751 autosubalignment = 0.000000
3752 nthread = 1
3753 randomseed = 0
3754 blosum 62 / kimura 200
3755 poffset = 0
3756 niter = 1
3757 sueff_global = 0.100000
3758 nadd = 1
3759 nsubalignments = 2
3760 maxmem = 3
3761 generating a scoring matrix for nucleotide (dist=200) ... done
3762
3763
3764
3765 0 / 5
3766
3767 Checking subalignment 1:
3768 1 2 3
3769 -> OK
3770
3771 Checking subalignment 2:
3772 4 5
3773 -> OK
3774 Segment 1/ 1 1- 109
3775 001-0000-0 (thread 1) skip
3776
3777 001-0001-1 (thread 1) skip
3778
3779 001-0002-0 (thread 1) skip
3780
3781 001-0003-1 (thread 1) skip
3782
3783 001-0004-0 (thread 1) skip
3784
3785 001-0005-1 (thread 1) skip
3786
3787 001-0006-1 (thread 1) identical
3788 001-0006-1 (thread 1) better
3789
3790 Reached 1
3791 done
3792 dvtditr (nuc) Version 7.407
3793 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3794 1 thread(s)
3795
3796
3797 Strategy:
3798 FFT-NS-i (Standard)
3799 Iterative refinement method (max. 1 iterations)
3800
3801 If unsure which option to use, try 'mafft --auto input > output'.
3802 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3803
3804 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3805 It tends to insert more gaps into gap-rich regions than previous versions.
3806 To disable this change, add the --leavegappyregion option.
3807
3808 inputfile = orig
3809 6 x 106 - 87 d
3810 nthread = 1
3811 nthreadpair = 1
3812 nthreadtb = 1
3813 ppenalty_ex = 0
3814 stacksize: 8192 kb
3815 nsubalignments = 2
3816 maxmem = 4
3817 generating a scoring matrix for nucleotide (dist=200) ... done
3818 Gap Penalty = -1.53, +0.00, +0.00
3819
3820
3821
3822 Making a distance matrix ..
3823
3824 1 / 6 (thread 0)
3825 done.
3826
3827 Constructing a UPGMA tree ...
3828
3829
3830 0 / 6
3831 done.
3832
3833 Checking subalignment 1:
3834 -> OK
3835 Checking subalignment 2:
3836 -> OK
3837 Progressive alignment 1/2...
3838
3839 STEP 5 / 5 (thread 0) f
3840 done.
3841
3842 Making a distance matrix from msa..
3843
3844 0 / 6 (thread 0)
3845 done.
3846
3847 Constructing a UPGMA tree ...
3848
3849
3850 0 / 6
3851 done.
3852
3853 Checking subalignment 1:
3854 -> OK
3855 Checking subalignment 2:
3856 -> OK
3857 Progressive alignment 2/2...
3858
3859 STEP 5 / 5 (thread 0) f
3860 done.
3861
3862 disttbfast (nuc) Version 7.407
3863 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3864 1 thread(s)
3865
3866 generating a scoring matrix for nucleotide (dist=200) ... done
3867
3868 0 / 6 (thread 0)dndpre (nuc) Version 7.407
3869 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3870 1 thread(s)
3871
3872 minimumweight = 0.000010
3873 autosubalignment = 0.000000
3874 nthread = 1
3875 randomseed = 0
3876 blosum 62 / kimura 200
3877 poffset = 0
3878 niter = 1
3879 sueff_global = 0.100000
3880 nadd = 1
3881 nsubalignments = 2
3882 maxmem = 4
3883 generating a scoring matrix for nucleotide (dist=200) ... done
3884
3885
3886
3887 0 / 6
3888
3889 Checking subalignment 1:
3890 1 2
3891 -> OK
3892
3893 Checking subalignment 2:
3894 3 4 5 6
3895 -> OK
3896 Segment 1/ 1 1- 127
3897 001-0000-0 (thread 1) skip
3898
3899 001-0001-1 (thread 1) skip
3900
3901 001-0002-0 (thread 1) skip
3902
3903 001-0003-1 (thread 1) skip
3904
3905 001-0004-0 (thread 1) skip
3906
3907 001-0005-1 (thread 1) skip
3908
3909 001-0006-0 (thread 1) skip
3910
3911 001-0007-1 (thread 1) skip
3912
3913 001-0008-1 (thread 1) identical
3914 001-0008-1 (thread 1) better
3915
3916 Reached 1
3917 done
3918 dvtditr (nuc) Version 7.407
3919 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3920 1 thread(s)
3921
3922
3923 Strategy:
3924 FFT-NS-i (Standard)
3925 Iterative refinement method (max. 1 iterations)
3926
3927 If unsure which option to use, try 'mafft --auto input > output'.
3928 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
3929
3930 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
3931 It tends to insert more gaps into gap-rich regions than previous versions.
3932 To disable this change, add the --leavegappyregion option.
3933
3934 inputfile = orig
3935 8 x 101 - 91 d
3936 nthread = 1
3937 nthreadpair = 1
3938 nthreadtb = 1
3939 ppenalty_ex = 0
3940 stacksize: 8192 kb
3941 nsubalignments = 2
3942 maxmem = 5
3943 generating a scoring matrix for nucleotide (dist=200) ... done
3944 Gap Penalty = -1.53, +0.00, +0.00
3945
3946
3947
3948 Making a distance matrix ..
3949
3950 1 / 8 (thread 0)
3951 done.
3952
3953 Constructing a UPGMA tree ...
3954
3955
3956 0 / 8
3957 done.
3958
3959 Checking subalignment 1:
3960 -> OK
3961 Checking subalignment 2:
3962 -> OK
3963 Progressive alignment 1/2...
3964
3965 STEP 7 / 7 (thread 0) f
3966 done.
3967
3968 Making a distance matrix from msa..
3969
3970 0 / 8 (thread 0)
3971 done.
3972
3973 Constructing a UPGMA tree ...
3974
3975
3976 0 / 8
3977 done.
3978
3979 Checking subalignment 1:
3980 -> OK
3981 Checking subalignment 2:
3982 -> OK
3983 Progressive alignment 2/2...
3984
3985 STEP 7 / 7 (thread 0) f
3986 done.
3987
3988 disttbfast (nuc) Version 7.407
3989 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
3990 1 thread(s)
3991
3992 generating a scoring matrix for nucleotide (dist=200) ... done
3993
3994 0 / 8 (thread 0)dndpre (nuc) Version 7.407
3995 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
3996 1 thread(s)
3997
3998 minimumweight = 0.000010
3999 autosubalignment = 0.000000
4000 nthread = 1
4001 randomseed = 0
4002 blosum 62 / kimura 200
4003 poffset = 0
4004 niter = 1
4005 sueff_global = 0.100000
4006 nadd = 1
4007 nsubalignments = 2
4008 maxmem = 5
4009 generating a scoring matrix for nucleotide (dist=200) ... done
4010
4011
4012
4013 0 / 8
4014
4015 Checking subalignment 1:
4016 1 2 3 4 5
4017 -> OK
4018
4019 Checking subalignment 2:
4020 6 7 8
4021 -> OK
4022 Segment 1/ 1 1- 102
4023 001-0000-0 (thread 1) skip
4024
4025 001-0001-1 (thread 1) skip
4026
4027 001-0002-0 (thread 1) skip
4028
4029 001-0003-1 (thread 1) skip
4030
4031 001-0004-0 (thread 1) skip
4032
4033 001-0005-1 (thread 1) skip
4034
4035 001-0006-0 (thread 1) skip
4036
4037 001-0007-1 (thread 1) skip
4038
4039 001-0008-0 (thread 1) skip
4040
4041 001-0009-1 (thread 1) skip
4042
4043 001-0010-0 (thread 1) skip
4044
4045 001-0011-1 (thread 1) skip
4046
4047 001-0012-1 (thread 1) identical
4048 001-0012-1 (thread 1) worse
4049
4050 Converged.
4051
4052 Reached 1
4053 done
4054 dvtditr (nuc) Version 7.407
4055 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4056 1 thread(s)
4057
4058
4059 Strategy:
4060 FFT-NS-i (Standard)
4061 Iterative refinement method (max. 1 iterations)
4062
4063 If unsure which option to use, try 'mafft --auto input > output'.
4064 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4065
4066 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4067 It tends to insert more gaps into gap-rich regions than previous versions.
4068 To disable this change, add the --leavegappyregion option.
4069
4070 inputfile = orig
4071 6 x 99 - 85 d
4072 nthread = 1
4073 nthreadpair = 1
4074 nthreadtb = 1
4075 ppenalty_ex = 0
4076 stacksize: 8192 kb
4077 nsubalignments = 2
4078 maxmem = 4
4079 generating a scoring matrix for nucleotide (dist=200) ... done
4080 Gap Penalty = -1.53, +0.00, +0.00
4081
4082
4083
4084 Making a distance matrix ..
4085
4086 1 / 6 (thread 0)
4087 done.
4088
4089 Constructing a UPGMA tree ...
4090
4091
4092 0 / 6
4093 ###################################################################
4094 # WARNING: Group 2 is forced to be a monophyletic cluster.
4095 ###################################################################
4096 Reallocated inconsistentpairlist, size=2
4097
4098 done.
4099
4100 Checking subalignment 1:
4101 -> OK
4102 Checking subalignment 2:
4103 -> OK
4104 Progressive alignment 1/2...
4105
4106 STEP 5 / 5 (thread 0) f
4107 done.
4108
4109 Making a distance matrix from msa..
4110
4111 0 / 6 (thread 0)
4112 done.
4113
4114 Constructing a UPGMA tree ...
4115
4116
4117 0 / 6
4118 done.
4119
4120 Checking subalignment 1:
4121 -> OK
4122 Checking subalignment 2:
4123 -> OK
4124 Progressive alignment 2/2...
4125
4126 STEP 5 / 5 (thread 0) f
4127 done.
4128
4129 disttbfast (nuc) Version 7.407
4130 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4131 1 thread(s)
4132
4133 generating a scoring matrix for nucleotide (dist=200) ... done
4134
4135 0 / 6 (thread 0)dndpre (nuc) Version 7.407
4136 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
4137 1 thread(s)
4138
4139 minimumweight = 0.000010
4140 autosubalignment = 0.000000
4141 nthread = 1
4142 randomseed = 0
4143 blosum 62 / kimura 200
4144 poffset = 0
4145 niter = 1
4146 sueff_global = 0.100000
4147 nadd = 1
4148 nsubalignments = 2
4149 maxmem = 4
4150 generating a scoring matrix for nucleotide (dist=200) ... done
4151
4152
4153
4154 0 / 6
4155
4156 Checking subalignment 1:
4157 1 2
4158 -> OK
4159
4160 Checking subalignment 2:
4161 3 4 5 6
4162 -> OK
4163 Segment 1/ 1 1- 123
4164 001-0000-0 (thread 1) skip
4165
4166 001-0001-1 (thread 1) skip
4167
4168 001-0002-0 (thread 1) skip
4169
4170 001-0003-1 (thread 1) skip
4171
4172 001-0004-0 (thread 1) skip
4173
4174 001-0005-1 (thread 1) skip
4175
4176 001-0006-0 (thread 1) skip
4177
4178 001-0007-1 (thread 1) skip
4179
4180 001-0008-1 (thread 1) identical
4181 001-0008-1 (thread 1) better
4182
4183 Reached 1
4184 done
4185 dvtditr (nuc) Version 7.407
4186 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4187 1 thread(s)
4188
4189
4190 Strategy:
4191 FFT-NS-i (Standard)
4192 Iterative refinement method (max. 1 iterations)
4193
4194 If unsure which option to use, try 'mafft --auto input > output'.
4195 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4196
4197 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4198 It tends to insert more gaps into gap-rich regions than previous versions.
4199 To disable this change, add the --leavegappyregion option.
4200
4201 inputfile = orig
4202 6 x 115 - 94 d
4203 nthread = 1
4204 nthreadpair = 1
4205 nthreadtb = 1
4206 ppenalty_ex = 0
4207 stacksize: 8192 kb
4208 nsubalignments = 2
4209 maxmem = 4
4210 generating a scoring matrix for nucleotide (dist=200) ... done
4211 Gap Penalty = -1.53, +0.00, +0.00
4212
4213
4214
4215 Making a distance matrix ..
4216
4217 1 / 6 (thread 0)
4218 done.
4219
4220 Constructing a UPGMA tree ...
4221
4222
4223 0 / 6
4224 done.
4225
4226 Checking subalignment 1:
4227 -> OK
4228 Checking subalignment 2:
4229 -> OK
4230 Progressive alignment 1/2...
4231
4232 STEP 5 / 5 (thread 0) f
4233 done.
4234
4235 Making a distance matrix from msa..
4236
4237 0 / 6 (thread 0)
4238 done.
4239
4240 Constructing a UPGMA tree ...
4241
4242
4243 0 / 6
4244 done.
4245
4246 Checking subalignment 1:
4247 -> OK
4248 Checking subalignment 2:
4249 -> OK
4250 Progressive alignment 2/2...
4251
4252 STEP 5 / 5 (thread 0) f
4253 done.
4254
4255 disttbfast (nuc) Version 7.407
4256 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4257 1 thread(s)
4258
4259 generating a scoring matrix for nucleotide (dist=200) ... done
4260
4261 0 / 6 (thread 0)dndpre (nuc) Version 7.407
4262 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
4263 1 thread(s)
4264
4265 minimumweight = 0.000010
4266 autosubalignment = 0.000000
4267 nthread = 1
4268 randomseed = 0
4269 blosum 62 / kimura 200
4270 poffset = 0
4271 niter = 1
4272 sueff_global = 0.100000
4273 nadd = 1
4274 nsubalignments = 2
4275 maxmem = 4
4276 generating a scoring matrix for nucleotide (dist=200) ... done
4277
4278
4279
4280 0 / 6
4281
4282 Checking subalignment 1:
4283 1 2 3 4
4284 -> OK
4285
4286 Checking subalignment 2:
4287 5 6
4288 -> OK
4289 Segment 1/ 1 1- 141
4290 001-0000-0 (thread 1) skip
4291
4292 001-0001-1 (thread 1) skip
4293
4294 001-0002-0 (thread 1) skip
4295
4296 001-0003-1 (thread 1) skip
4297
4298 001-0004-0 (thread 1) skip
4299
4300 001-0005-1 (thread 1) skip
4301
4302 001-0006-0 (thread 1) skip
4303
4304 001-0007-1 (thread 1) skip
4305
4306 001-0008-1 (thread 1) identical
4307
4308 Converged.
4309
4310 Reached 1
4311 done
4312 dvtditr (nuc) Version 7.407
4313 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4314 1 thread(s)
4315
4316
4317 Strategy:
4318 FFT-NS-i (Standard)
4319 Iterative refinement method (max. 1 iterations)
4320
4321 If unsure which option to use, try 'mafft --auto input > output'.
4322 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4323
4324 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4325 It tends to insert more gaps into gap-rich regions than previous versions.
4326 To disable this change, add the --leavegappyregion option.
4327
4328 inputfile = orig
4329 7 x 120 - 70 d
4330 nadd = 1
4331 generating a scoring matrix for nucleotide (dist=200) ... done
4332
4333 0 / 6 (thread 0)dndpre (nuc) Version 7.407
4334 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4335 1 thread(s)
4336
4337 generating a scoring matrix for nucleotide (dist=200) ... done
4338 All-to-all alignment.
4339
4340
4341 ##### writing hat3
4342 pairlocalalign (nuc) Version 7.407
4343 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4344 1 thread(s)
4345
4346 nadd = 1
4347 ppenalty_ex = -10
4348 nthread = 1
4349 blosum 62 / kimura 200
4350 sueff_global = 0.100000
4351 norg = 6
4352 njobc = 7
4353 Loading 'hat3' ...
4354 done.
4355 generating a scoring matrix for nucleotide (dist=200) ... done
4356 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4357 Loading 'hat2i' (aligned sequences) ... done.
4358
4359 0 / 1 (thread 0)
4360 c
4361
4362 Combining ..
4363 0 / 1
4364 0 / 1
4365
4366 done.
4367
4368
4369 done.
4370
4371 addsingle (nuc) Version 7.407
4372 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4373 1 thread(s)
4374
4375
4376 Strategy:
4377 Multi-INS-fragment (Not tested.)
4378 ?
4379
4380 If unsure which option to use, try 'mafft --auto input > output'.
4381 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4382
4383 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4384 It tends to insert more gaps into gap-rich regions than previous versions.
4385 To disable this change, add the --leavegappyregion option.
4386
4387 inputfile = orig
4388 6 x 99 - 70 d
4389 nadd = 1
4390 generating a scoring matrix for nucleotide (dist=200) ... done
4391
4392 0 / 5 (thread 0)dndpre (nuc) Version 7.407
4393 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4394 1 thread(s)
4395
4396 generating a scoring matrix for nucleotide (dist=200) ... done
4397 All-to-all alignment.
4398
4399
4400 ##### writing hat3
4401 pairlocalalign (nuc) Version 7.407
4402 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4403 1 thread(s)
4404
4405 nadd = 1
4406 ppenalty_ex = -10
4407 nthread = 1
4408 blosum 62 / kimura 200
4409 sueff_global = 0.100000
4410 norg = 5
4411 njobc = 6
4412 Loading 'hat3' ...
4413 done.
4414 generating a scoring matrix for nucleotide (dist=200) ... done
4415 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4416 Loading 'hat2i' (aligned sequences) ... done.
4417
4418 0 / 1 (thread 0)
4419 c
4420
4421 Combining ..
4422 0 / 1
4423 0 / 1
4424
4425 done.
4426
4427
4428 done.
4429
4430 addsingle (nuc) Version 7.407
4431 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4432 1 thread(s)
4433
4434
4435 Strategy:
4436 Multi-INS-fragment (Not tested.)
4437 ?
4438
4439 If unsure which option to use, try 'mafft --auto input > output'.
4440 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4441
4442 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4443 It tends to insert more gaps into gap-rich regions than previous versions.
4444 To disable this change, add the --leavegappyregion option.
4445
4446 inputfile = orig
4447 9 x 104 - 70 d
4448 nadd = 1
4449 generating a scoring matrix for nucleotide (dist=200) ... done
4450
4451 0 / 8 (thread 0)dndpre (nuc) Version 7.407
4452 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4453 1 thread(s)
4454
4455 generating a scoring matrix for nucleotide (dist=200) ... done
4456 All-to-all alignment.
4457
4458
4459 ##### writing hat3
4460 pairlocalalign (nuc) Version 7.407
4461 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4462 1 thread(s)
4463
4464 nadd = 1
4465 ppenalty_ex = -10
4466 nthread = 1
4467 blosum 62 / kimura 200
4468 sueff_global = 0.100000
4469 norg = 8
4470 njobc = 9
4471 Loading 'hat3' ...
4472 done.
4473 generating a scoring matrix for nucleotide (dist=200) ... done
4474 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4475 Loading 'hat2i' (aligned sequences) ... done.
4476
4477 0 / 1 (thread 0)
4478 c
4479
4480 Combining ..
4481 0 / 1
4482 0 / 1
4483
4484 done.
4485
4486
4487 done.
4488
4489 addsingle (nuc) Version 7.407
4490 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4491 1 thread(s)
4492
4493
4494 Strategy:
4495 Multi-INS-fragment (Not tested.)
4496 ?
4497
4498 If unsure which option to use, try 'mafft --auto input > output'.
4499 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4500
4501 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4502 It tends to insert more gaps into gap-rich regions than previous versions.
4503 To disable this change, add the --leavegappyregion option.
4504
4505 inputfile = orig
4506 6 x 108 - 70 d
4507 nadd = 1
4508 generating a scoring matrix for nucleotide (dist=200) ... done
4509
4510 0 / 5 (thread 0)dndpre (nuc) Version 7.407
4511 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4512 1 thread(s)
4513
4514 generating a scoring matrix for nucleotide (dist=200) ... done
4515 All-to-all alignment.
4516
4517
4518 ##### writing hat3
4519 pairlocalalign (nuc) Version 7.407
4520 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4521 1 thread(s)
4522
4523 nadd = 1
4524 ppenalty_ex = -10
4525 nthread = 1
4526 blosum 62 / kimura 200
4527 sueff_global = 0.100000
4528 norg = 5
4529 njobc = 6
4530 Loading 'hat3' ...
4531 done.
4532 generating a scoring matrix for nucleotide (dist=200) ... done
4533 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4534 Loading 'hat2i' (aligned sequences) ... done.
4535
4536 0 / 1 (thread 0)
4537 c
4538
4539 Combining ..
4540 0 / 1
4541 0 / 1
4542
4543 done.
4544
4545
4546 done.
4547
4548 addsingle (nuc) Version 7.407
4549 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4550 1 thread(s)
4551
4552
4553 Strategy:
4554 Multi-INS-fragment (Not tested.)
4555 ?
4556
4557 If unsure which option to use, try 'mafft --auto input > output'.
4558 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4559
4560 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4561 It tends to insert more gaps into gap-rich regions than previous versions.
4562 To disable this change, add the --leavegappyregion option.
4563
4564 inputfile = orig
4565 8 x 126 - 83 d
4566 nthread = 1
4567 nthreadpair = 1
4568 nthreadtb = 1
4569 ppenalty_ex = 0
4570 stacksize: 8192 kb
4571 nsubalignments = 2
4572 maxmem = 6
4573 generating a scoring matrix for nucleotide (dist=200) ... done
4574 Gap Penalty = -1.53, +0.00, +0.00
4575
4576
4577
4578 Making a distance matrix ..
4579
4580 1 / 8 (thread 0)
4581 done.
4582
4583 Constructing a UPGMA tree ...
4584
4585
4586 0 / 8
4587 done.
4588
4589 Checking subalignment 1:
4590 -> OK
4591 Checking subalignment 2:
4592 -> OK
4593 Progressive alignment 1/2...
4594
4595 STEP 7 / 7 (thread 0) f
4596 done.
4597
4598 Making a distance matrix from msa..
4599
4600 0 / 8 (thread 0)
4601 done.
4602
4603 Constructing a UPGMA tree ...
4604
4605
4606 0 / 8
4607 done.
4608
4609 Checking subalignment 1:
4610 -> OK
4611 Checking subalignment 2:
4612 -> OK
4613 Progressive alignment 2/2...
4614
4615 STEP 7 / 7 (thread 0) f
4616 done.
4617
4618 disttbfast (nuc) Version 7.407
4619 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4620 1 thread(s)
4621
4622 generating a scoring matrix for nucleotide (dist=200) ... done
4623
4624 0 / 8 (thread 0)dndpre (nuc) Version 7.407
4625 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
4626 1 thread(s)
4627
4628 minimumweight = 0.000010
4629 autosubalignment = 0.000000
4630 nthread = 1
4631 randomseed = 0
4632 blosum 62 / kimura 200
4633 poffset = 0
4634 niter = 1
4635 sueff_global = 0.100000
4636 nadd = 1
4637 nsubalignments = 2
4638 maxmem = 6
4639 generating a scoring matrix for nucleotide (dist=200) ... done
4640
4641
4642
4643 0 / 8
4644
4645 Checking subalignment 1:
4646 1 2
4647 -> OK
4648
4649 Checking subalignment 2:
4650 3 4 5 6 7 8
4651 -> OK
4652 Segment 1/ 1 1- 130
4653 001-0000-0 (thread 1) skip
4654
4655 001-0001-1 (thread 1) skip
4656
4657 001-0002-0 (thread 1) skip
4658
4659 001-0003-1 (thread 1) skip
4660
4661 001-0004-0 (thread 1) skip
4662
4663 001-0005-1 (thread 1) skip
4664
4665 001-0006-0 (thread 1) skip
4666
4667 001-0007-1 (thread 1) skip
4668
4669 001-0008-0 (thread 1) skip
4670
4671 001-0009-1 (thread 1) skip
4672
4673 001-0010-0 (thread 1) skip
4674
4675 001-0011-1 (thread 1) skip
4676
4677 001-0012-1 (thread 1) identical
4678 001-0012-1 (thread 1) better
4679
4680 Reached 1
4681 done
4682 dvtditr (nuc) Version 7.407
4683 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4684 1 thread(s)
4685
4686
4687 Strategy:
4688 FFT-NS-i (Standard)
4689 Iterative refinement method (max. 1 iterations)
4690
4691 If unsure which option to use, try 'mafft --auto input > output'.
4692 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4693
4694 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4695 It tends to insert more gaps into gap-rich regions than previous versions.
4696 To disable this change, add the --leavegappyregion option.
4697
4698 inputfile = orig
4699 7 x 100 - 70 d
4700 nadd = 1
4701 generating a scoring matrix for nucleotide (dist=200) ... done
4702
4703 0 / 6 (thread 0)dndpre (nuc) Version 7.407
4704 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4705 1 thread(s)
4706
4707 generating a scoring matrix for nucleotide (dist=200) ... done
4708 All-to-all alignment.
4709
4710
4711 ##### writing hat3
4712 pairlocalalign (nuc) Version 7.407
4713 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4714 1 thread(s)
4715
4716 nadd = 1
4717 ppenalty_ex = -10
4718 nthread = 1
4719 blosum 62 / kimura 200
4720 sueff_global = 0.100000
4721 norg = 6
4722 njobc = 7
4723 Loading 'hat3' ...
4724 done.
4725 generating a scoring matrix for nucleotide (dist=200) ... done
4726 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4727 Loading 'hat2i' (aligned sequences) ... done.
4728
4729 0 / 1 (thread 0)
4730 c
4731
4732 Combining ..
4733 0 / 1
4734 0 / 1
4735
4736 done.
4737
4738
4739 done.
4740
4741 addsingle (nuc) Version 7.407
4742 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4743 1 thread(s)
4744
4745
4746 Strategy:
4747 Multi-INS-fragment (Not tested.)
4748 ?
4749
4750 If unsure which option to use, try 'mafft --auto input > output'.
4751 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4752
4753 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4754 It tends to insert more gaps into gap-rich regions than previous versions.
4755 To disable this change, add the --leavegappyregion option.
4756
4757 inputfile = orig
4758 7 x 140 - 70 d
4759 nadd = 1
4760 generating a scoring matrix for nucleotide (dist=200) ... done
4761
4762 0 / 6 (thread 0)dndpre (nuc) Version 7.407
4763 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4764 1 thread(s)
4765
4766 generating a scoring matrix for nucleotide (dist=200) ... done
4767 All-to-all alignment.
4768
4769
4770 ##### writing hat3
4771 pairlocalalign (nuc) Version 7.407
4772 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
4773 1 thread(s)
4774
4775 nadd = 1
4776 ppenalty_ex = -10
4777 nthread = 1
4778 blosum 62 / kimura 200
4779 sueff_global = 0.100000
4780 norg = 6
4781 njobc = 7
4782 Loading 'hat3' ...
4783 done.
4784 generating a scoring matrix for nucleotide (dist=200) ... done
4785 Loading 'hat2n' (aligned sequences - new sequences) ... done.
4786 Loading 'hat2i' (aligned sequences) ... done.
4787
4788 0 / 1 (thread 0)
4789 c
4790
4791 Combining ..
4792 0 / 1
4793 0 / 1
4794
4795 done.
4796
4797
4798 done.
4799
4800 addsingle (nuc) Version 7.407
4801 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4802 1 thread(s)
4803
4804
4805 Strategy:
4806 Multi-INS-fragment (Not tested.)
4807 ?
4808
4809 If unsure which option to use, try 'mafft --auto input > output'.
4810 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4811
4812 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4813 It tends to insert more gaps into gap-rich regions than previous versions.
4814 To disable this change, add the --leavegappyregion option.
4815
4816 inputfile = orig
4817 13 x 128 - 123 d
4818 nthread = 1
4819 nthreadpair = 1
4820 nthreadtb = 1
4821 ppenalty_ex = 0
4822 stacksize: 8192 kb
4823 nsubalignments = 2
4824 maxmem = 7
4825 generating a scoring matrix for nucleotide (dist=200) ... done
4826 Gap Penalty = -1.53, +0.00, +0.00
4827
4828
4829
4830 Making a distance matrix ..
4831
4832 1 / 13 (thread 0)
4833 done.
4834
4835 Constructing a UPGMA tree ...
4836
4837
4838 0 / 13
4839 10 / 13
4840 done.
4841
4842 Checking subalignment 1:
4843 -> OK
4844 Checking subalignment 2:
4845 -> OK
4846 Progressive alignment 1/2...
4847
4848 STEP 12 / 12 (thread 0) f
4849 done.
4850
4851 Making a distance matrix from msa..
4852
4853 0 / 13 (thread 0)
4854 done.
4855
4856 Constructing a UPGMA tree ...
4857
4858
4859 0 / 13
4860 10 / 13
4861 done.
4862
4863 Checking subalignment 1:
4864 -> OK
4865 Checking subalignment 2:
4866 -> OK
4867 Progressive alignment 2/2...
4868
4869 STEP 12 / 12 (thread 0) f
4870 done.
4871
4872 disttbfast (nuc) Version 7.407
4873 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4874 1 thread(s)
4875
4876 generating a scoring matrix for nucleotide (dist=200) ... done
4877
4878 0 / 13 (thread 0)dndpre (nuc) Version 7.407
4879 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
4880 1 thread(s)
4881
4882 minimumweight = 0.000010
4883 autosubalignment = 0.000000
4884 nthread = 1
4885 randomseed = 0
4886 blosum 62 / kimura 200
4887 poffset = 0
4888 niter = 1
4889 sueff_global = 0.100000
4890 nadd = 1
4891 nsubalignments = 2
4892 maxmem = 7
4893 generating a scoring matrix for nucleotide (dist=200) ... done
4894
4895
4896
4897 0 / 13
4898 10 / 13
4899
4900 Checking subalignment 1:
4901 1 2 3 4 5 6
4902 -> OK
4903
4904 Checking subalignment 2:
4905 7 8 9 10 11 12 13
4906 -> OK
4907 Segment 1/ 1 1- 163
4908 001-0000-0 (thread 1) skip
4909
4910 001-0001-1 (thread 1) skip
4911
4912 001-0002-0 (thread 1) skip
4913
4914 001-0003-1 (thread 1) skip
4915
4916 001-0004-0 (thread 1) skip
4917
4918 001-0005-1 (thread 1) skip
4919
4920 001-0006-0 (thread 1) skip
4921
4922 001-0007-1 (thread 1) skip
4923
4924 001-0008-0 (thread 1) skip
4925
4926 001-0009-1 (thread 1) skip
4927
4928 001-0010-0 (thread 1) skip
4929
4930 001-0011-1 (thread 1) skip
4931
4932 001-0012-0 (thread 1) skip
4933
4934 001-0013-1 (thread 1) skip
4935
4936 001-0014-0 (thread 1) skip
4937
4938 001-0015-1 (thread 1) skip
4939
4940 001-0016-0 (thread 1) skip
4941
4942 001-0017-1 (thread 1) skip
4943
4944 001-0018-0 (thread 1) skip
4945
4946 001-0019-1 (thread 1) skip
4947
4948 001-0020-0 (thread 1) skip
4949
4950 001-0021-1 (thread 1) skip
4951
4952 001-0022-1 (thread 1) identical
4953 001-0022-1 (thread 1) better
4954
4955 Reached 1
4956 done
4957 dvtditr (nuc) Version 7.407
4958 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
4959 1 thread(s)
4960
4961
4962 Strategy:
4963 FFT-NS-i (Standard)
4964 Iterative refinement method (max. 1 iterations)
4965
4966 If unsure which option to use, try 'mafft --auto input > output'.
4967 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
4968
4969 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
4970 It tends to insert more gaps into gap-rich regions than previous versions.
4971 To disable this change, add the --leavegappyregion option.
4972
4973 inputfile = orig
4974 10 x 130 - 111 d
4975 nthread = 1
4976 nthreadpair = 1
4977 nthreadtb = 1
4978 ppenalty_ex = 0
4979 stacksize: 8192 kb
4980 nsubalignments = 2
4981 maxmem = 6
4982 generating a scoring matrix for nucleotide (dist=200) ... done
4983 Gap Penalty = -1.53, +0.00, +0.00
4984
4985
4986
4987 Making a distance matrix ..
4988
4989 1 / 10 (thread 0)
4990 done.
4991
4992 Constructing a UPGMA tree ...
4993
4994
4995 0 / 10
4996 done.
4997
4998 Checking subalignment 1:
4999 -> OK
5000 Checking subalignment 2:
5001 -> OK
5002 Progressive alignment 1/2...
5003
5004 STEP 9 / 9 (thread 0) f
5005 done.
5006
5007 Making a distance matrix from msa..
5008
5009 0 / 10 (thread 0)
5010 done.
5011
5012 Constructing a UPGMA tree ...
5013
5014
5015 0 / 10
5016 done.
5017
5018 Checking subalignment 1:
5019 -> OK
5020 Checking subalignment 2:
5021 -> OK
5022 Progressive alignment 2/2...
5023
5024 STEP 9 / 9 (thread 0) f
5025 done.
5026
5027 disttbfast (nuc) Version 7.407
5028 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5029 1 thread(s)
5030
5031 generating a scoring matrix for nucleotide (dist=200) ... done
5032
5033 0 / 10 (thread 0)dndpre (nuc) Version 7.407
5034 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5035 1 thread(s)
5036
5037 minimumweight = 0.000010
5038 autosubalignment = 0.000000
5039 nthread = 1
5040 randomseed = 0
5041 blosum 62 / kimura 200
5042 poffset = 0
5043 niter = 1
5044 sueff_global = 0.100000
5045 nadd = 1
5046 nsubalignments = 2
5047 maxmem = 6
5048 generating a scoring matrix for nucleotide (dist=200) ... done
5049
5050
5051
5052 0 / 10
5053
5054 Checking subalignment 1:
5055 1 2 3 4
5056 -> OK
5057
5058 Checking subalignment 2:
5059 5 6 7 8 9 10
5060 -> OK
5061 Segment 1/ 1 1- 142
5062 001-0000-0 (thread 1) skip
5063
5064 001-0001-1 (thread 1) skip
5065
5066 001-0002-0 (thread 1) skip
5067
5068 001-0003-1 (thread 1) skip
5069
5070 001-0004-0 (thread 1) skip
5071
5072 001-0005-1 (thread 1) skip
5073
5074 001-0006-0 (thread 1) skip
5075
5076 001-0007-1 (thread 1) skip
5077
5078 001-0008-0 (thread 1) skip
5079
5080 001-0009-1 (thread 1) skip
5081
5082 001-0010-0 (thread 1) skip
5083
5084 001-0011-1 (thread 1) skip
5085
5086 001-0012-0 (thread 1) skip
5087
5088 001-0013-1 (thread 1) skip
5089
5090 001-0014-0 (thread 1) skip
5091
5092 001-0015-1 (thread 1) skip
5093
5094 001-0016-1 (thread 1) identical
5095
5096 Converged.
5097
5098 Reached 1
5099 done
5100 dvtditr (nuc) Version 7.407
5101 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5102 1 thread(s)
5103
5104
5105 Strategy:
5106 FFT-NS-i (Standard)
5107 Iterative refinement method (max. 1 iterations)
5108
5109 If unsure which option to use, try 'mafft --auto input > output'.
5110 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5111
5112 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5113 It tends to insert more gaps into gap-rich regions than previous versions.
5114 To disable this change, add the --leavegappyregion option.
5115
5116 inputfile = orig
5117 16 x 129 - 101 d
5118 nthread = 1
5119 nthreadpair = 1
5120 nthreadtb = 1
5121 ppenalty_ex = 0
5122 stacksize: 8192 kb
5123 nsubalignments = 2
5124 maxmem = 8
5125 generating a scoring matrix for nucleotide (dist=200) ... done
5126 Gap Penalty = -1.53, +0.00, +0.00
5127
5128
5129
5130 Making a distance matrix ..
5131
5132 1 / 16 (thread 0)
5133 done.
5134
5135 Constructing a UPGMA tree ...
5136
5137
5138 0 / 16
5139 10 / 16
5140 done.
5141
5142 Checking subalignment 1:
5143 -> OK
5144 Checking subalignment 2:
5145 -> OK
5146 Progressive alignment 1/2...
5147
5148 STEP 15 / 15 (thread 0) f
5149 done.
5150
5151 Making a distance matrix from msa..
5152
5153 0 / 16 (thread 0)
5154 done.
5155
5156 Constructing a UPGMA tree ...
5157
5158
5159 0 / 16
5160 10 / 16
5161 done.
5162
5163 Checking subalignment 1:
5164 -> OK
5165 Checking subalignment 2:
5166 -> OK
5167 Progressive alignment 2/2...
5168
5169 STEP 15 / 15 (thread 0) f
5170 done.
5171
5172 disttbfast (nuc) Version 7.407
5173 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5174 1 thread(s)
5175
5176 generating a scoring matrix for nucleotide (dist=200) ... done
5177
5178 0 / 16 (thread 0)dndpre (nuc) Version 7.407
5179 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5180 1 thread(s)
5181
5182 minimumweight = 0.000010
5183 autosubalignment = 0.000000
5184 nthread = 1
5185 randomseed = 0
5186 blosum 62 / kimura 200
5187 poffset = 0
5188 niter = 1
5189 sueff_global = 0.100000
5190 nadd = 1
5191 nsubalignments = 2
5192 maxmem = 8
5193 generating a scoring matrix for nucleotide (dist=200) ... done
5194
5195
5196
5197 0 / 16
5198 10 / 16
5199
5200 Checking subalignment 1:
5201 1 2 3 4 5 6 7 8
5202 -> OK
5203
5204 Checking subalignment 2:
5205 9 10 11 12 13 14 15 16
5206 -> OK
5207 Segment 1/ 1 1- 152
5208 001-0000-0 (thread 1) skip
5209
5210 001-0001-1 (thread 1) skip
5211
5212 001-0002-0 (thread 1) skip
5213
5214 001-0003-1 (thread 1) skip
5215
5216 001-0004-0 (thread 1) skip
5217
5218 001-0005-1 (thread 1) skip
5219
5220 001-0006-0 (thread 1) skip
5221
5222 001-0007-1 (thread 1) skip
5223
5224 001-0008-0 (thread 1) skip
5225
5226 001-0009-1 (thread 1) skip
5227
5228 001-0010-0 (thread 1) skip
5229
5230 001-0011-1 (thread 1) skip
5231
5232 001-0012-0 (thread 1) skip
5233
5234 001-0013-1 (thread 1) skip
5235
5236 001-0014-0 (thread 1) skip
5237
5238 001-0015-1 (thread 1) skip
5239
5240 001-0016-0 (thread 1) skip
5241
5242 001-0017-1 (thread 1) skip
5243
5244 001-0018-0 (thread 1) skip
5245
5246 001-0019-1 (thread 1) skip
5247
5248 001-0020-0 (thread 1) skip
5249
5250 001-0021-1 (thread 1) skip
5251
5252 001-0022-0 (thread 1) skip
5253
5254 001-0023-1 (thread 1) skip
5255
5256 001-0024-0 (thread 1) skip
5257
5258 001-0025-1 (thread 1) skip
5259
5260 001-0026-0 (thread 1) skip
5261
5262 001-0027-1 (thread 1) skip
5263
5264 001-0028-1 (thread 1) identical
5265 001-0028-1 (thread 1) better
5266
5267 Reached 1
5268 done
5269 dvtditr (nuc) Version 7.407
5270 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5271 1 thread(s)
5272
5273
5274 Strategy:
5275 FFT-NS-i (Standard)
5276 Iterative refinement method (max. 1 iterations)
5277
5278 If unsure which option to use, try 'mafft --auto input > output'.
5279 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5280
5281 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5282 It tends to insert more gaps into gap-rich regions than previous versions.
5283 To disable this change, add the --leavegappyregion option.
5284
5285 inputfile = orig
5286 10 x 108 - 96 d
5287 nthread = 1
5288 nthreadpair = 1
5289 nthreadtb = 1
5290 ppenalty_ex = 0
5291 stacksize: 8192 kb
5292 nsubalignments = 2
5293 maxmem = 7
5294 generating a scoring matrix for nucleotide (dist=200) ... done
5295 Gap Penalty = -1.53, +0.00, +0.00
5296
5297
5298
5299 Making a distance matrix ..
5300
5301 1 / 10 (thread 0)
5302 done.
5303
5304 Constructing a UPGMA tree ...
5305
5306
5307 0 / 10
5308 done.
5309
5310 Checking subalignment 1:
5311 -> OK
5312 Checking subalignment 2:
5313 -> OK
5314 Progressive alignment 1/2...
5315
5316 STEP 9 / 9 (thread 0) f
5317 done.
5318
5319 Making a distance matrix from msa..
5320
5321 0 / 10 (thread 0)
5322 done.
5323
5324 Constructing a UPGMA tree ...
5325
5326
5327 0 / 10
5328 done.
5329
5330 Checking subalignment 1:
5331 -> OK
5332 Checking subalignment 2:
5333 -> OK
5334 Progressive alignment 2/2...
5335
5336 STEP 9 / 9 (thread 0) f
5337 done.
5338
5339 disttbfast (nuc) Version 7.407
5340 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5341 1 thread(s)
5342
5343 generating a scoring matrix for nucleotide (dist=200) ... done
5344
5345 0 / 10 (thread 0)dndpre (nuc) Version 7.407
5346 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5347 1 thread(s)
5348
5349 minimumweight = 0.000010
5350 autosubalignment = 0.000000
5351 nthread = 1
5352 randomseed = 0
5353 blosum 62 / kimura 200
5354 poffset = 0
5355 niter = 1
5356 sueff_global = 0.100000
5357 nadd = 1
5358 nsubalignments = 2
5359 maxmem = 7
5360 generating a scoring matrix for nucleotide (dist=200) ... done
5361
5362
5363
5364 0 / 10
5365
5366 Checking subalignment 1:
5367 1 2 3
5368 -> OK
5369
5370 Checking subalignment 2:
5371 4 5 6 7 8 9 10
5372 -> OK
5373 Segment 1/ 1 1- 122
5374 001-0000-0 (thread 1) skip
5375
5376 001-0001-1 (thread 1) skip
5377
5378 001-0002-0 (thread 1) skip
5379
5380 001-0003-1 (thread 1) skip
5381
5382 001-0004-0 (thread 1) skip
5383
5384 001-0005-1 (thread 1) skip
5385
5386 001-0006-0 (thread 1) skip
5387
5388 001-0007-1 (thread 1) skip
5389
5390 001-0008-0 (thread 1) skip
5391
5392 001-0009-1 (thread 1) skip
5393
5394 001-0010-0 (thread 1) skip
5395
5396 001-0011-1 (thread 1) skip
5397
5398 001-0012-0 (thread 1) skip
5399
5400 001-0013-1 (thread 1) skip
5401
5402 001-0014-0 (thread 1) skip
5403
5404 001-0015-1 (thread 1) skip
5405
5406 001-0016-1 (thread 1) identical
5407 001-0016-1 (thread 1) better
5408
5409 Reached 1
5410 done
5411 dvtditr (nuc) Version 7.407
5412 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5413 1 thread(s)
5414
5415
5416 Strategy:
5417 FFT-NS-i (Standard)
5418 Iterative refinement method (max. 1 iterations)
5419
5420 If unsure which option to use, try 'mafft --auto input > output'.
5421 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5422
5423 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5424 It tends to insert more gaps into gap-rich regions than previous versions.
5425 To disable this change, add the --leavegappyregion option.
5426
5427 inputfile = orig
5428 8 x 140 - 70 d
5429 nadd = 1
5430 generating a scoring matrix for nucleotide (dist=200) ... done
5431
5432 0 / 7 (thread 0)dndpre (nuc) Version 7.407
5433 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
5434 1 thread(s)
5435
5436 generating a scoring matrix for nucleotide (dist=200) ... done
5437 All-to-all alignment.
5438
5439
5440 ##### writing hat3
5441 pairlocalalign (nuc) Version 7.407
5442 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
5443 1 thread(s)
5444
5445 nadd = 1
5446 ppenalty_ex = -10
5447 nthread = 1
5448 blosum 62 / kimura 200
5449 sueff_global = 0.100000
5450 norg = 7
5451 njobc = 8
5452 Loading 'hat3' ...
5453 done.
5454 generating a scoring matrix for nucleotide (dist=200) ... done
5455 Loading 'hat2n' (aligned sequences - new sequences) ... done.
5456 Loading 'hat2i' (aligned sequences) ... done.
5457
5458 0 / 1 (thread 0)
5459 c
5460
5461 Combining ..
5462 0 / 1
5463 0 / 1
5464
5465 done.
5466
5467
5468 done.
5469
5470 addsingle (nuc) Version 7.407
5471 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5472 1 thread(s)
5473
5474
5475 Strategy:
5476 Multi-INS-fragment (Not tested.)
5477 ?
5478
5479 If unsure which option to use, try 'mafft --auto input > output'.
5480 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5481
5482 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5483 It tends to insert more gaps into gap-rich regions than previous versions.
5484 To disable this change, add the --leavegappyregion option.
5485
5486 inputfile = orig
5487 17 x 151 - 113 d
5488 nthread = 1
5489 nthreadpair = 1
5490 nthreadtb = 1
5491 ppenalty_ex = 0
5492 stacksize: 8192 kb
5493 nsubalignments = 2
5494 maxmem = 13
5495 generating a scoring matrix for nucleotide (dist=200) ... done
5496 Gap Penalty = -1.53, +0.00, +0.00
5497
5498
5499
5500 Making a distance matrix ..
5501
5502 1 / 17 (thread 0)
5503 done.
5504
5505 Constructing a UPGMA tree ...
5506
5507
5508 0 / 17
5509 10 / 17
5510 done.
5511
5512 Checking subalignment 1:
5513 -> OK
5514 Checking subalignment 2:
5515 -> OK
5516 Progressive alignment 1/2...
5517
5518 STEP 16 / 16 (thread 0) f
5519 done.
5520
5521 Making a distance matrix from msa..
5522
5523 0 / 17 (thread 0)
5524 done.
5525
5526 Constructing a UPGMA tree ...
5527
5528
5529 0 / 17
5530 10 / 17
5531 done.
5532
5533 Checking subalignment 1:
5534 -> OK
5535 Checking subalignment 2:
5536 -> OK
5537 Progressive alignment 2/2...
5538
5539 STEP 16 / 16 (thread 0) f
5540 done.
5541
5542 disttbfast (nuc) Version 7.407
5543 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5544 1 thread(s)
5545
5546 generating a scoring matrix for nucleotide (dist=200) ... done
5547
5548 0 / 17 (thread 0)dndpre (nuc) Version 7.407
5549 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5550 1 thread(s)
5551
5552 minimumweight = 0.000010
5553 autosubalignment = 0.000000
5554 nthread = 1
5555 randomseed = 0
5556 blosum 62 / kimura 200
5557 poffset = 0
5558 niter = 1
5559 sueff_global = 0.100000
5560 nadd = 1
5561 nsubalignments = 2
5562 maxmem = 13
5563 generating a scoring matrix for nucleotide (dist=200) ... done
5564
5565
5566
5567 0 / 17
5568 10 / 17
5569
5570 Checking subalignment 1:
5571 1 2 3 4 5 6 7 8 9 10 11 12 13
5572 -> OK
5573
5574 Checking subalignment 2:
5575 14 15 16 17
5576 -> OK
5577 Segment 1/ 1 1- 166
5578 001-0000-0 (thread 1) skip
5579
5580 001-0001-1 (thread 1) skip
5581
5582 001-0002-0 (thread 1) skip
5583
5584 001-0003-1 (thread 1) skip
5585
5586 001-0004-0 (thread 1) skip
5587
5588 001-0005-1 (thread 1) skip
5589
5590 001-0006-0 (thread 1) skip
5591
5592 001-0007-1 (thread 1) skip
5593
5594 001-0008-0 (thread 1) skip
5595
5596 001-0009-1 (thread 1) skip
5597
5598 001-0010-0 (thread 1) skip
5599
5600 001-0011-1 (thread 1) skip
5601
5602 001-0012-0 (thread 1) skip
5603
5604 001-0013-1 (thread 1) skip
5605
5606 001-0014-0 (thread 1) skip
5607
5608 001-0015-1 (thread 1) skip
5609
5610 001-0016-0 (thread 1) skip
5611
5612 001-0017-1 (thread 1) skip
5613
5614 001-0018-0 (thread 1) skip
5615
5616 001-0019-1 (thread 1) skip
5617
5618 001-0020-0 (thread 1) skip
5619
5620 001-0021-1 (thread 1) skip
5621
5622 001-0022-0 (thread 1) skip
5623
5624 001-0023-1 (thread 1) skip
5625
5626 001-0024-0 (thread 1) skip
5627
5628 001-0025-1 (thread 1) skip
5629
5630 001-0026-0 (thread 1) skip
5631
5632 001-0027-1 (thread 1) skip
5633
5634 001-0028-0 (thread 1) skip
5635
5636 001-0029-1 (thread 1) skip
5637
5638 001-0030-1 (thread 1) identical
5639 001-0030-1 (thread 1) better
5640
5641 Reached 1
5642 done
5643 dvtditr (nuc) Version 7.407
5644 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5645 1 thread(s)
5646
5647
5648 Strategy:
5649 FFT-NS-i (Standard)
5650 Iterative refinement method (max. 1 iterations)
5651
5652 If unsure which option to use, try 'mafft --auto input > output'.
5653 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5654
5655 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5656 It tends to insert more gaps into gap-rich regions than previous versions.
5657 To disable this change, add the --leavegappyregion option.
5658
5659 inputfile = orig
5660 11 x 141 - 70 d
5661 nadd = 1
5662 generating a scoring matrix for nucleotide (dist=200) ... done
5663
5664 0 / 10 (thread 0)dndpre (nuc) Version 7.407
5665 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
5666 1 thread(s)
5667
5668 generating a scoring matrix for nucleotide (dist=200) ... done
5669 All-to-all alignment.
5670
5671
5672 ##### writing hat3
5673 pairlocalalign (nuc) Version 7.407
5674 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
5675 1 thread(s)
5676
5677 nadd = 1
5678 ppenalty_ex = -10
5679 nthread = 1
5680 blosum 62 / kimura 200
5681 sueff_global = 0.100000
5682 norg = 10
5683 njobc = 11
5684 Loading 'hat3' ...
5685 done.
5686 generating a scoring matrix for nucleotide (dist=200) ... done
5687 Loading 'hat2n' (aligned sequences - new sequences) ... done.
5688 Loading 'hat2i' (aligned sequences) ... done.
5689
5690 0 / 1 (thread 0)
5691 c
5692
5693 Combining ..
5694 0 / 1
5695 0 / 1
5696
5697 done.
5698
5699
5700 done.
5701
5702 addsingle (nuc) Version 7.407
5703 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5704 1 thread(s)
5705
5706
5707 Strategy:
5708 Multi-INS-fragment (Not tested.)
5709 ?
5710
5711 If unsure which option to use, try 'mafft --auto input > output'.
5712 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5713
5714 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5715 It tends to insert more gaps into gap-rich regions than previous versions.
5716 To disable this change, add the --leavegappyregion option.
5717
5718 inputfile = orig
5719 22 x 157 - 112 d
5720 nthread = 1
5721 nthreadpair = 1
5722 nthreadtb = 1
5723 ppenalty_ex = 0
5724 stacksize: 8192 kb
5725 nsubalignments = 2
5726 maxmem = 16
5727 generating a scoring matrix for nucleotide (dist=200) ... done
5728 Gap Penalty = -1.53, +0.00, +0.00
5729
5730
5731
5732 Making a distance matrix ..
5733
5734 1 / 22 (thread 0)
5735 done.
5736
5737 Constructing a UPGMA tree ...
5738
5739
5740 0 / 22
5741 10 / 22
5742 20 / 22
5743 done.
5744
5745 Checking subalignment 1:
5746 -> OK
5747 Checking subalignment 2:
5748 -> OK
5749 Progressive alignment 1/2...
5750
5751 STEP 21 / 21 (thread 0) f
5752 done.
5753
5754 Making a distance matrix from msa..
5755
5756 0 / 22 (thread 0)
5757 done.
5758
5759 Constructing a UPGMA tree ...
5760
5761
5762 0 / 22
5763 10 / 22
5764 20 / 22
5765 done.
5766
5767 Checking subalignment 1:
5768 -> OK
5769 Checking subalignment 2:
5770 -> OK
5771 Progressive alignment 2/2...
5772
5773 STEP 21 / 21 (thread 0) f
5774 done.
5775
5776 disttbfast (nuc) Version 7.407
5777 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5778 1 thread(s)
5779
5780 generating a scoring matrix for nucleotide (dist=200) ... done
5781
5782 0 / 22 (thread 0)dndpre (nuc) Version 7.407
5783 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5784 1 thread(s)
5785
5786 minimumweight = 0.000010
5787 autosubalignment = 0.000000
5788 nthread = 1
5789 randomseed = 0
5790 blosum 62 / kimura 200
5791 poffset = 0
5792 niter = 1
5793 sueff_global = 0.100000
5794 nadd = 1
5795 nsubalignments = 2
5796 maxmem = 16
5797 generating a scoring matrix for nucleotide (dist=200) ... done
5798
5799
5800
5801 0 / 22
5802 10 / 22
5803 20 / 22
5804
5805 Checking subalignment 1:
5806 1 2 3 4 5 6
5807 -> OK
5808
5809 Checking subalignment 2:
5810 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
5811 -> OK
5812 Segment 1/ 1 1- 170
5813 001-0000-0 (thread 1) skip
5814
5815 001-0001-1 (thread 1) skip
5816
5817 001-0002-0 (thread 1) skip
5818
5819 001-0003-1 (thread 1) skip
5820
5821 001-0004-0 (thread 1) skip
5822
5823 001-0005-1 (thread 1) skip
5824
5825 001-0006-0 (thread 1) skip
5826
5827 001-0007-1 (thread 1) skip
5828
5829 001-0008-0 (thread 1) skip
5830
5831 001-0009-1 (thread 1) skip
5832
5833 001-0010-0 (thread 1) skip
5834
5835 001-0011-1 (thread 1) skip
5836
5837 001-0012-0 (thread 1) skip
5838
5839 001-0013-1 (thread 1) skip
5840
5841 001-0014-0 (thread 1) skip
5842
5843 001-0015-1 (thread 1) skip
5844
5845 001-0016-0 (thread 1) skip
5846
5847 001-0017-1 (thread 1) skip
5848
5849 001-0018-0 (thread 1) skip
5850
5851 001-0019-1 (thread 1) skip
5852
5853 001-0020-0 (thread 1) skip
5854
5855 001-0021-1 (thread 1) skip
5856
5857 001-0022-0 (thread 1) skip
5858
5859 001-0023-1 (thread 1) skip
5860
5861 001-0024-0 (thread 1) skip
5862
5863 001-0025-1 (thread 1) skip
5864
5865 001-0026-0 (thread 1) skip
5866
5867 001-0027-1 (thread 1) skip
5868
5869 001-0028-0 (thread 1) skip
5870
5871 001-0029-1 (thread 1) skip
5872
5873 001-0030-0 (thread 1) skip
5874
5875 001-0031-1 (thread 1) skip
5876
5877 001-0032-0 (thread 1) skip
5878
5879 001-0033-1 (thread 1) skip
5880
5881 001-0034-0 (thread 1) skip
5882
5883 001-0035-1 (thread 1) skip
5884
5885 001-0036-0 (thread 1) skip
5886
5887 001-0037-1 (thread 1) skip
5888
5889 001-0038-0 (thread 1) skip
5890
5891 001-0039-1 (thread 1) skip
5892
5893 001-0040-1 (thread 1) identical
5894 001-0040-1 (thread 1) worse
5895
5896 Converged.
5897
5898 Reached 1
5899 done
5900 dvtditr (nuc) Version 7.407
5901 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5902 1 thread(s)
5903
5904
5905 Strategy:
5906 FFT-NS-i (Standard)
5907 Iterative refinement method (max. 1 iterations)
5908
5909 If unsure which option to use, try 'mafft --auto input > output'.
5910 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
5911
5912 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
5913 It tends to insert more gaps into gap-rich regions than previous versions.
5914 To disable this change, add the --leavegappyregion option.
5915
5916 inputfile = orig
5917 12 x 121 - 96 d
5918 nthread = 1
5919 nthreadpair = 1
5920 nthreadtb = 1
5921 ppenalty_ex = 0
5922 stacksize: 8192 kb
5923 nsubalignments = 2
5924 maxmem = 10
5925 generating a scoring matrix for nucleotide (dist=200) ... done
5926 Gap Penalty = -1.53, +0.00, +0.00
5927
5928
5929
5930 Making a distance matrix ..
5931
5932 1 / 12 (thread 0)
5933 done.
5934
5935 Constructing a UPGMA tree ...
5936
5937
5938 0 / 12
5939 ###################################################################
5940 # WARNING: Group 2 is forced to be a monophyletic cluster.
5941 ###################################################################
5942 Reallocated inconsistentpairlist, size=2
5943
5944 10 / 12
5945 done.
5946
5947 Checking subalignment 1:
5948 -> OK
5949 Checking subalignment 2:
5950 -> OK
5951 Progressive alignment 1/2...
5952
5953 STEP 11 / 11 (thread 0) f
5954 done.
5955
5956 Making a distance matrix from msa..
5957
5958 0 / 12 (thread 0)
5959 done.
5960
5961 Constructing a UPGMA tree ...
5962
5963
5964 0 / 12
5965 10 / 12
5966 done.
5967
5968 Checking subalignment 1:
5969 -> OK
5970 Checking subalignment 2:
5971 -> OK
5972 Progressive alignment 2/2...
5973
5974 STEP 11 / 11 (thread 0) f
5975 done.
5976
5977 disttbfast (nuc) Version 7.407
5978 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
5979 1 thread(s)
5980
5981 generating a scoring matrix for nucleotide (dist=200) ... done
5982
5983 0 / 12 (thread 0)dndpre (nuc) Version 7.407
5984 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
5985 1 thread(s)
5986
5987 minimumweight = 0.000010
5988 autosubalignment = 0.000000
5989 nthread = 1
5990 randomseed = 0
5991 blosum 62 / kimura 200
5992 poffset = 0
5993 niter = 1
5994 sueff_global = 0.100000
5995 nadd = 1
5996 nsubalignments = 2
5997 maxmem = 10
5998 generating a scoring matrix for nucleotide (dist=200) ... done
5999
6000
6001
6002 0 / 12
6003 10 / 12
6004
6005 Checking subalignment 1:
6006 1 2 3 4 5 6 7 8 9 10
6007 -> OK
6008
6009 Checking subalignment 2:
6010 11 12
6011 -> OK
6012 Segment 1/ 1 1- 122
6013 001-0000-0 (thread 1) skip
6014
6015 001-0001-1 (thread 1) skip
6016
6017 001-0002-0 (thread 1) skip
6018
6019 001-0003-1 (thread 1) skip
6020
6021 001-0004-0 (thread 1) skip
6022
6023 001-0005-1 (thread 1) skip
6024
6025 001-0006-0 (thread 1) skip
6026
6027 001-0007-1 (thread 1) skip
6028
6029 001-0008-0 (thread 1) skip
6030
6031 001-0009-1 (thread 1) skip
6032
6033 001-0010-0 (thread 1) skip
6034
6035 001-0011-1 (thread 1) skip
6036
6037 001-0012-0 (thread 1) skip
6038
6039 001-0013-1 (thread 1) skip
6040
6041 001-0014-0 (thread 1) skip
6042
6043 001-0015-1 (thread 1) skip
6044
6045 001-0016-0 (thread 1) skip
6046
6047 001-0017-1 (thread 1) skip
6048
6049 001-0018-0 (thread 1) skip
6050
6051 001-0019-1 (thread 1) skip
6052
6053 001-0020-1 (thread 1) identical
6054 001-0020-1 (thread 1) worse
6055
6056 Converged.
6057
6058 Reached 1
6059 done
6060 dvtditr (nuc) Version 7.407
6061 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6062 1 thread(s)
6063
6064
6065 Strategy:
6066 FFT-NS-i (Standard)
6067 Iterative refinement method (max. 1 iterations)
6068
6069 If unsure which option to use, try 'mafft --auto input > output'.
6070 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6071
6072 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6073 It tends to insert more gaps into gap-rich regions than previous versions.
6074 To disable this change, add the --leavegappyregion option.
6075
6076 inputfile = orig
6077 10 x 142 - 88 d
6078 nthread = 1
6079 nthreadpair = 1
6080 nthreadtb = 1
6081 ppenalty_ex = 0
6082 stacksize: 8192 kb
6083 nsubalignments = 2
6084 maxmem = 8
6085 generating a scoring matrix for nucleotide (dist=200) ... done
6086 Gap Penalty = -1.53, +0.00, +0.00
6087
6088
6089
6090 Making a distance matrix ..
6091
6092 1 / 10 (thread 0)
6093 done.
6094
6095 Constructing a UPGMA tree ...
6096
6097
6098 0 / 10
6099 done.
6100
6101 Checking subalignment 1:
6102 -> OK
6103 Checking subalignment 2:
6104 -> OK
6105 Progressive alignment 1/2...
6106
6107 STEP 9 / 9 (thread 0) f
6108 done.
6109
6110 Making a distance matrix from msa..
6111
6112 0 / 10 (thread 0)
6113 done.
6114
6115 Constructing a UPGMA tree ...
6116
6117
6118 0 / 10
6119 done.
6120
6121 Checking subalignment 1:
6122 -> OK
6123 Checking subalignment 2:
6124 -> OK
6125 Progressive alignment 2/2...
6126
6127 STEP 9 / 9 (thread 0) f
6128 done.
6129
6130 disttbfast (nuc) Version 7.407
6131 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6132 1 thread(s)
6133
6134 generating a scoring matrix for nucleotide (dist=200) ... done
6135
6136 0 / 10 (thread 0)dndpre (nuc) Version 7.407
6137 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
6138 1 thread(s)
6139
6140 minimumweight = 0.000010
6141 autosubalignment = 0.000000
6142 nthread = 1
6143 randomseed = 0
6144 blosum 62 / kimura 200
6145 poffset = 0
6146 niter = 1
6147 sueff_global = 0.100000
6148 nadd = 1
6149 nsubalignments = 2
6150 maxmem = 8
6151 generating a scoring matrix for nucleotide (dist=200) ... done
6152
6153
6154
6155 0 / 10
6156
6157 Checking subalignment 1:
6158 1 2
6159 -> OK
6160
6161 Checking subalignment 2:
6162 3 4 5 6 7 8 9 10
6163 -> OK
6164 Segment 1/ 1 1- 157
6165 001-0000-0 (thread 1) skip
6166
6167 001-0001-1 (thread 1) skip
6168
6169 001-0002-0 (thread 1) skip
6170
6171 001-0003-1 (thread 1) skip
6172
6173 001-0004-0 (thread 1) skip
6174
6175 001-0005-1 (thread 1) skip
6176
6177 001-0006-0 (thread 1) skip
6178
6179 001-0007-1 (thread 1) skip
6180
6181 001-0008-0 (thread 1) skip
6182
6183 001-0009-1 (thread 1) skip
6184
6185 001-0010-0 (thread 1) skip
6186
6187 001-0011-1 (thread 1) skip
6188
6189 001-0012-0 (thread 1) skip
6190
6191 001-0013-1 (thread 1) skip
6192
6193 001-0014-0 (thread 1) skip
6194
6195 001-0015-1 (thread 1) skip
6196
6197 001-0016-1 (thread 1) identical
6198 001-0016-1 (thread 1) better
6199
6200 Reached 1
6201 done
6202 dvtditr (nuc) Version 7.407
6203 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6204 1 thread(s)
6205
6206
6207 Strategy:
6208 FFT-NS-i (Standard)
6209 Iterative refinement method (max. 1 iterations)
6210
6211 If unsure which option to use, try 'mafft --auto input > output'.
6212 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6213
6214 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6215 It tends to insert more gaps into gap-rich regions than previous versions.
6216 To disable this change, add the --leavegappyregion option.
6217
6218 inputfile = orig
6219 21 x 168 - 155 d
6220 nthread = 1
6221 nthreadpair = 1
6222 nthreadtb = 1
6223 ppenalty_ex = 0
6224 stacksize: 8192 kb
6225 nsubalignments = 2
6226 maxmem = 17
6227 generating a scoring matrix for nucleotide (dist=200) ... done
6228 Gap Penalty = -1.53, +0.00, +0.00
6229
6230
6231
6232 Making a distance matrix ..
6233
6234 1 / 21 (thread 0)
6235 done.
6236
6237 Constructing a UPGMA tree ...
6238
6239
6240 0 / 21
6241 10 / 21
6242 done.
6243
6244 Checking subalignment 1:
6245 -> OK
6246 Checking subalignment 2:
6247 -> OK
6248 Progressive alignment 1/2...
6249
6250 STEP 20 / 20 (thread 0) f
6251 done.
6252
6253 Making a distance matrix from msa..
6254
6255 0 / 21 (thread 0)
6256 done.
6257
6258 Constructing a UPGMA tree ...
6259
6260
6261 0 / 21
6262 10 / 21
6263 done.
6264
6265 Checking subalignment 1:
6266 -> OK
6267 Checking subalignment 2:
6268 -> OK
6269 Progressive alignment 2/2...
6270
6271 STEP 20 / 20 (thread 0) f
6272 done.
6273
6274 disttbfast (nuc) Version 7.407
6275 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6276 1 thread(s)
6277
6278 generating a scoring matrix for nucleotide (dist=200) ... done
6279
6280 0 / 21 (thread 0)dndpre (nuc) Version 7.407
6281 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
6282 1 thread(s)
6283
6284 minimumweight = 0.000010
6285 autosubalignment = 0.000000
6286 nthread = 1
6287 randomseed = 0
6288 blosum 62 / kimura 200
6289 poffset = 0
6290 niter = 1
6291 sueff_global = 0.100000
6292 nadd = 1
6293 nsubalignments = 2
6294 maxmem = 17
6295 generating a scoring matrix for nucleotide (dist=200) ... done
6296
6297
6298
6299 0 / 21
6300 10 / 21
6301
6302 Checking subalignment 1:
6303 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
6304 -> OK
6305
6306 Checking subalignment 2:
6307 18 19 20 21
6308 -> OK
6309 Segment 1/ 1 1- 209
6310 001-0000-0 (thread 1) skip
6311
6312 001-0001-1 (thread 1) skip
6313
6314 001-0002-0 (thread 1) skip
6315
6316 001-0003-1 (thread 1) skip
6317
6318 001-0004-0 (thread 1) skip
6319
6320 001-0005-1 (thread 1) skip
6321
6322 001-0006-0 (thread 1) skip
6323
6324 001-0007-1 (thread 1) skip
6325
6326 001-0008-0 (thread 1) skip
6327
6328 001-0009-1 (thread 1) skip
6329
6330 001-0010-0 (thread 1) skip
6331
6332 001-0011-1 (thread 1) skip
6333
6334 001-0012-0 (thread 1) skip
6335
6336 001-0013-1 (thread 1) skip
6337
6338 001-0014-0 (thread 1) skip
6339
6340 001-0015-1 (thread 1) skip
6341
6342 001-0016-0 (thread 1) skip
6343
6344 001-0017-1 (thread 1) skip
6345
6346 001-0018-0 (thread 1) skip
6347
6348 001-0019-1 (thread 1) skip
6349
6350 001-0020-0 (thread 1) skip
6351
6352 001-0021-1 (thread 1) skip
6353
6354 001-0022-0 (thread 1) skip
6355
6356 001-0023-1 (thread 1) skip
6357
6358 001-0024-0 (thread 1) skip
6359
6360 001-0025-1 (thread 1) skip
6361
6362 001-0026-0 (thread 1) skip
6363
6364 001-0027-1 (thread 1) skip
6365
6366 001-0028-0 (thread 1) skip
6367
6368 001-0029-1 (thread 1) skip
6369
6370 001-0030-0 (thread 1) skip
6371
6372 001-0031-1 (thread 1) skip
6373
6374 001-0032-0 (thread 1) skip
6375
6376 001-0033-1 (thread 1) skip
6377
6378 001-0034-0 (thread 1) skip
6379
6380 001-0035-1 (thread 1) skip
6381
6382 001-0036-0 (thread 1) skip
6383
6384 001-0037-1 (thread 1) skip
6385
6386 001-0038-1 (thread 1) identical
6387 001-0038-1 (thread 1) better
6388
6389 Reached 1
6390 done
6391 dvtditr (nuc) Version 7.407
6392 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6393 1 thread(s)
6394
6395
6396 Strategy:
6397 FFT-NS-i (Standard)
6398 Iterative refinement method (max. 1 iterations)
6399
6400 If unsure which option to use, try 'mafft --auto input > output'.
6401 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6402
6403 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6404 It tends to insert more gaps into gap-rich regions than previous versions.
6405 To disable this change, add the --leavegappyregion option.
6406
6407 inputfile = orig
6408 12 x 141 - 70 d
6409 nadd = 1
6410 generating a scoring matrix for nucleotide (dist=200) ... done
6411
6412 0 / 11 (thread 0)dndpre (nuc) Version 7.407
6413 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6414 1 thread(s)
6415
6416 generating a scoring matrix for nucleotide (dist=200) ... done
6417 All-to-all alignment.
6418 10 / 11 (by thread 0)
6419
6420 ##### writing hat3
6421 pairlocalalign (nuc) Version 7.407
6422 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6423 1 thread(s)
6424
6425 nadd = 1
6426 ppenalty_ex = -10
6427 nthread = 1
6428 blosum 62 / kimura 200
6429 sueff_global = 0.100000
6430 norg = 11
6431 njobc = 12
6432 Loading 'hat3' ...
6433 done.
6434 generating a scoring matrix for nucleotide (dist=200) ... done
6435 Loading 'hat2n' (aligned sequences - new sequences) ... done.
6436 Loading 'hat2i' (aligned sequences) ... done.
6437
6438 0 / 1 (thread 0)
6439 c
6440
6441 Combining ..
6442 0 / 1
6443 0 / 1
6444
6445 done.
6446
6447
6448 done.
6449
6450 addsingle (nuc) Version 7.407
6451 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6452 1 thread(s)
6453
6454
6455 Strategy:
6456 Multi-INS-fragment (Not tested.)
6457 ?
6458
6459 If unsure which option to use, try 'mafft --auto input > output'.
6460 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6461
6462 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6463 It tends to insert more gaps into gap-rich regions than previous versions.
6464 To disable this change, add the --leavegappyregion option.
6465
6466 inputfile = orig
6467 24 x 169 - 74 d
6468 nthread = 1
6469 nthreadpair = 1
6470 nthreadtb = 1
6471 ppenalty_ex = 0
6472 stacksize: 8192 kb
6473 nsubalignments = 2
6474 maxmem = 22
6475 generating a scoring matrix for nucleotide (dist=200) ... done
6476 Gap Penalty = -1.53, +0.00, +0.00
6477
6478
6479
6480 Making a distance matrix ..
6481
6482 1 / 24 (thread 0)
6483 done.
6484
6485 Constructing a UPGMA tree ...
6486
6487
6488 0 / 24
6489 10 / 24
6490 20 / 24
6491 done.
6492
6493 Checking subalignment 1:
6494 -> OK
6495 Checking subalignment 2:
6496 -> OK
6497 Progressive alignment 1/2...
6498
6499 STEP 23 / 23 (thread 0) f
6500 done.
6501
6502 Making a distance matrix from msa..
6503
6504 0 / 24 (thread 0)
6505 done.
6506
6507 Constructing a UPGMA tree ...
6508
6509
6510 0 / 24
6511 10 / 24
6512 20 / 24
6513 done.
6514
6515 Checking subalignment 1:
6516 -> OK
6517 Checking subalignment 2:
6518 -> OK
6519 Progressive alignment 2/2...
6520
6521 STEP 23 / 23 (thread 0) f
6522 done.
6523
6524 disttbfast (nuc) Version 7.407
6525 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6526 1 thread(s)
6527
6528 generating a scoring matrix for nucleotide (dist=200) ... done
6529
6530 0 / 24 (thread 0)dndpre (nuc) Version 7.407
6531 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
6532 1 thread(s)
6533
6534 minimumweight = 0.000010
6535 autosubalignment = 0.000000
6536 nthread = 1
6537 randomseed = 0
6538 blosum 62 / kimura 200
6539 poffset = 0
6540 niter = 1
6541 sueff_global = 0.100000
6542 nadd = 1
6543 nsubalignments = 2
6544 maxmem = 22
6545 generating a scoring matrix for nucleotide (dist=200) ... done
6546
6547
6548
6549 0 / 24
6550 10 / 24
6551 20 / 24
6552
6553 Checking subalignment 1:
6554 1 2
6555 -> OK
6556
6557 Checking subalignment 2:
6558 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
6559 -> OK
6560 Segment 1/ 1 1- 174
6561 001-0000-0 (thread 1) skip
6562
6563 001-0001-1 (thread 1) skip
6564
6565 001-0002-0 (thread 1) skip
6566
6567 001-0003-1 (thread 1) skip
6568
6569 001-0004-0 (thread 1) skip
6570
6571 001-0005-1 (thread 1) skip
6572
6573 001-0006-0 (thread 1) skip
6574
6575 001-0007-1 (thread 1) skip
6576
6577 001-0008-0 (thread 1) skip
6578
6579 001-0009-1 (thread 1) skip
6580
6581 001-0010-0 (thread 1) skip
6582
6583 001-0011-1 (thread 1) skip
6584
6585 001-0012-0 (thread 1) skip
6586
6587 001-0013-1 (thread 1) skip
6588
6589 001-0014-0 (thread 1) skip
6590
6591 001-0015-1 (thread 1) skip
6592
6593 001-0016-0 (thread 1) skip
6594
6595 001-0017-1 (thread 1) skip
6596
6597 001-0018-0 (thread 1) skip
6598
6599 001-0019-1 (thread 1) skip
6600
6601 001-0020-0 (thread 1) skip
6602
6603 001-0021-1 (thread 1) skip
6604
6605 001-0022-0 (thread 1) skip
6606
6607 001-0023-1 (thread 1) skip
6608
6609 001-0024-0 (thread 1) skip
6610
6611 001-0025-1 (thread 1) skip
6612
6613 001-0026-0 (thread 1) skip
6614
6615 001-0027-1 (thread 1) skip
6616
6617 001-0028-0 (thread 1) skip
6618
6619 001-0029-1 (thread 1) skip
6620
6621 001-0030-0 (thread 1) skip
6622
6623 001-0031-1 (thread 1) skip
6624
6625 001-0032-0 (thread 1) skip
6626
6627 001-0033-1 (thread 1) skip
6628
6629 001-0034-0 (thread 1) skip
6630
6631 001-0035-1 (thread 1) skip
6632
6633 001-0036-0 (thread 1) skip
6634
6635 001-0037-1 (thread 1) skip
6636
6637 001-0038-0 (thread 1) skip
6638
6639 001-0039-1 (thread 1) skip
6640
6641 001-0040-0 (thread 1) skip
6642
6643 001-0041-1 (thread 1) skip
6644
6645 001-0042-0 (thread 1) skip
6646
6647 001-0043-1 (thread 1) skip
6648
6649 001-0044-1 (thread 1) identical
6650 001-0044-1 (thread 1) better
6651
6652 Reached 1
6653 done
6654 dvtditr (nuc) Version 7.407
6655 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6656 1 thread(s)
6657
6658
6659 Strategy:
6660 FFT-NS-i (Standard)
6661 Iterative refinement method (max. 1 iterations)
6662
6663 If unsure which option to use, try 'mafft --auto input > output'.
6664 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6665
6666 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6667 It tends to insert more gaps into gap-rich regions than previous versions.
6668 To disable this change, add the --leavegappyregion option.
6669
6670 inputfile = orig
6671 13 x 121 - 70 d
6672 nadd = 1
6673 generating a scoring matrix for nucleotide (dist=200) ... done
6674
6675 0 / 12 (thread 0)dndpre (nuc) Version 7.407
6676 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6677 1 thread(s)
6678
6679 generating a scoring matrix for nucleotide (dist=200) ... done
6680 All-to-all alignment.
6681
6682
6683 ##### writing hat3
6684 pairlocalalign (nuc) Version 7.407
6685 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6686 1 thread(s)
6687
6688 nadd = 1
6689 ppenalty_ex = -10
6690 nthread = 1
6691 blosum 62 / kimura 200
6692 sueff_global = 0.100000
6693 norg = 12
6694 njobc = 13
6695 Loading 'hat3' ...
6696 done.
6697 generating a scoring matrix for nucleotide (dist=200) ... done
6698 Loading 'hat2n' (aligned sequences - new sequences) ... done.
6699 Loading 'hat2i' (aligned sequences) ... done.
6700
6701 0 / 1 (thread 0)
6702 c
6703
6704 Combining ..
6705 0 / 1
6706 0 / 1
6707
6708 done.
6709
6710
6711 done.
6712
6713 addsingle (nuc) Version 7.407
6714 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6715 1 thread(s)
6716
6717
6718 Strategy:
6719 Multi-INS-fragment (Not tested.)
6720 ?
6721
6722 If unsure which option to use, try 'mafft --auto input > output'.
6723 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6724
6725 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6726 It tends to insert more gaps into gap-rich regions than previous versions.
6727 To disable this change, add the --leavegappyregion option.
6728
6729 inputfile = orig
6730 26 x 186 - 107 d
6731 nthread = 1
6732 nthreadpair = 1
6733 nthreadtb = 1
6734 ppenalty_ex = 0
6735 stacksize: 8192 kb
6736 nsubalignments = 2
6737 maxmem = 21
6738 generating a scoring matrix for nucleotide (dist=200) ... done
6739 Gap Penalty = -1.53, +0.00, +0.00
6740
6741
6742
6743 Making a distance matrix ..
6744
6745 1 / 26 (thread 0)
6746 done.
6747
6748 Constructing a UPGMA tree ...
6749
6750
6751 0 / 26
6752 10 / 26
6753 20 / 26
6754 done.
6755
6756 Checking subalignment 1:
6757 -> OK
6758 Checking subalignment 2:
6759 -> OK
6760 Progressive alignment 1/2...
6761
6762 STEP 25 / 25 (thread 0) f
6763 done.
6764
6765 Making a distance matrix from msa..
6766
6767 0 / 26 (thread 0)
6768 done.
6769
6770 Constructing a UPGMA tree ...
6771
6772
6773 0 / 26
6774 10 / 26
6775 20 / 26
6776 done.
6777
6778 Checking subalignment 1:
6779 -> OK
6780 Checking subalignment 2:
6781 -> OK
6782 Progressive alignment 2/2...
6783
6784 STEP 25 / 25 (thread 0) f
6785 done.
6786
6787 disttbfast (nuc) Version 7.407
6788 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6789 1 thread(s)
6790
6791 generating a scoring matrix for nucleotide (dist=200) ... done
6792
6793 0 / 26 (thread 0)dndpre (nuc) Version 7.407
6794 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
6795 1 thread(s)
6796
6797 minimumweight = 0.000010
6798 autosubalignment = 0.000000
6799 nthread = 1
6800 randomseed = 0
6801 blosum 62 / kimura 200
6802 poffset = 0
6803 niter = 1
6804 sueff_global = 0.100000
6805 nadd = 1
6806 nsubalignments = 2
6807 maxmem = 21
6808 generating a scoring matrix for nucleotide (dist=200) ... done
6809
6810
6811
6812 0 / 26
6813 10 / 26
6814 20 / 26
6815
6816 Checking subalignment 1:
6817 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
6818 -> OK
6819
6820 Checking subalignment 2:
6821 22 23 24 25 26
6822 -> OK
6823 Segment 1/ 1 1- 199
6824 001-0000-0 (thread 1) skip
6825
6826 001-0001-1 (thread 1) skip
6827
6828 001-0002-0 (thread 1) skip
6829
6830 001-0003-1 (thread 1) skip
6831
6832 001-0004-0 (thread 1) skip
6833
6834 001-0005-1 (thread 1) skip
6835
6836 001-0006-0 (thread 1) skip
6837
6838 001-0007-1 (thread 1) skip
6839
6840 001-0008-0 (thread 1) skip
6841
6842 001-0009-1 (thread 1) skip
6843
6844 001-0010-0 (thread 1) skip
6845
6846 001-0011-1 (thread 1) skip
6847
6848 001-0012-0 (thread 1) skip
6849
6850 001-0013-1 (thread 1) skip
6851
6852 001-0014-0 (thread 1) skip
6853
6854 001-0015-1 (thread 1) skip
6855
6856 001-0016-0 (thread 1) skip
6857
6858 001-0017-1 (thread 1) skip
6859
6860 001-0018-0 (thread 1) skip
6861
6862 001-0019-1 (thread 1) skip
6863
6864 001-0020-0 (thread 1) skip
6865
6866 001-0021-1 (thread 1) skip
6867
6868 001-0022-0 (thread 1) skip
6869
6870 001-0023-1 (thread 1) skip
6871
6872 001-0024-0 (thread 1) skip
6873
6874 001-0025-1 (thread 1) skip
6875
6876 001-0026-0 (thread 1) skip
6877
6878 001-0027-1 (thread 1) skip
6879
6880 001-0028-0 (thread 1) skip
6881
6882 001-0029-1 (thread 1) skip
6883
6884 001-0030-0 (thread 1) skip
6885
6886 001-0031-1 (thread 1) skip
6887
6888 001-0032-0 (thread 1) skip
6889
6890 001-0033-1 (thread 1) skip
6891
6892 001-0034-0 (thread 1) skip
6893
6894 001-0035-1 (thread 1) skip
6895
6896 001-0036-0 (thread 1) skip
6897
6898 001-0037-1 (thread 1) skip
6899
6900 001-0038-0 (thread 1) skip
6901
6902 001-0039-1 (thread 1) skip
6903
6904 001-0040-0 (thread 1) skip
6905
6906 001-0041-1 (thread 1) skip
6907
6908 001-0042-0 (thread 1) skip
6909
6910 001-0043-1 (thread 1) skip
6911
6912 001-0044-0 (thread 1) skip
6913
6914 001-0045-1 (thread 1) skip
6915
6916 001-0046-0 (thread 1) skip
6917
6918 001-0047-1 (thread 1) skip
6919
6920 001-0048-1 (thread 1) identical
6921 001-0048-1 (thread 1) worse
6922
6923 Converged.
6924
6925 Reached 1
6926 done
6927 dvtditr (nuc) Version 7.407
6928 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6929 1 thread(s)
6930
6931
6932 Strategy:
6933 FFT-NS-i (Standard)
6934 Iterative refinement method (max. 1 iterations)
6935
6936 If unsure which option to use, try 'mafft --auto input > output'.
6937 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6938
6939 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6940 It tends to insert more gaps into gap-rich regions than previous versions.
6941 To disable this change, add the --leavegappyregion option.
6942
6943 inputfile = orig
6944 25 x 173 - 70 d
6945 nadd = 1
6946 generating a scoring matrix for nucleotide (dist=200) ... done
6947
6948 0 / 24 (thread 0)dndpre (nuc) Version 7.407
6949 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6950 1 thread(s)
6951
6952 generating a scoring matrix for nucleotide (dist=200) ... done
6953 All-to-all alignment.
6954
6955
6956 ##### writing hat3
6957 pairlocalalign (nuc) Version 7.407
6958 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
6959 1 thread(s)
6960
6961 nadd = 1
6962 ppenalty_ex = -10
6963 nthread = 1
6964 blosum 62 / kimura 200
6965 sueff_global = 0.100000
6966 norg = 24
6967 njobc = 25
6968 Loading 'hat3' ...
6969 done.
6970 generating a scoring matrix for nucleotide (dist=200) ... done
6971 Loading 'hat2n' (aligned sequences - new sequences) ... done.
6972 Loading 'hat2i' (aligned sequences) ... done.
6973
6974 0 / 1 (thread 0)
6975 c
6976
6977 Combining ..
6978 0 / 1
6979 0 / 1
6980
6981 done.
6982
6983
6984 done.
6985
6986 addsingle (nuc) Version 7.407
6987 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
6988 1 thread(s)
6989
6990
6991 Strategy:
6992 Multi-INS-fragment (Not tested.)
6993 ?
6994
6995 If unsure which option to use, try 'mafft --auto input > output'.
6996 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
6997
6998 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
6999 It tends to insert more gaps into gap-rich regions than previous versions.
7000 To disable this change, add the --leavegappyregion option.
7001
7002 inputfile = orig
7003 23 x 142 - 130 d
7004 nthread = 1
7005 nthreadpair = 1
7006 nthreadtb = 1
7007 ppenalty_ex = 0
7008 stacksize: 8192 kb
7009 nsubalignments = 2
7010 maxmem = 13
7011 generating a scoring matrix for nucleotide (dist=200) ... done
7012 Gap Penalty = -1.53, +0.00, +0.00
7013
7014
7015
7016 Making a distance matrix ..
7017
7018 1 / 23 (thread 0)
7019 done.
7020
7021 Constructing a UPGMA tree ...
7022
7023
7024 0 / 23
7025 10 / 23
7026 20 / 23
7027 done.
7028
7029 Checking subalignment 1:
7030 -> OK
7031 Checking subalignment 2:
7032 -> OK
7033 Progressive alignment 1/2...
7034
7035 STEP 22 / 22 (thread 0) f
7036 done.
7037
7038 Making a distance matrix from msa..
7039
7040 0 / 23 (thread 0)
7041 done.
7042
7043 Constructing a UPGMA tree ...
7044
7045
7046 0 / 23
7047 10 / 23
7048 20 / 23
7049 done.
7050
7051 Checking subalignment 1:
7052 -> OK
7053 Checking subalignment 2:
7054 -> OK
7055 Progressive alignment 2/2...
7056
7057 STEP 22 / 22 (thread 0) f
7058 done.
7059
7060 disttbfast (nuc) Version 7.407
7061 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7062 1 thread(s)
7063
7064 generating a scoring matrix for nucleotide (dist=200) ... done
7065
7066 0 / 23 (thread 0)dndpre (nuc) Version 7.407
7067 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
7068 1 thread(s)
7069
7070 minimumweight = 0.000010
7071 autosubalignment = 0.000000
7072 nthread = 1
7073 randomseed = 0
7074 blosum 62 / kimura 200
7075 poffset = 0
7076 niter = 1
7077 sueff_global = 0.100000
7078 nadd = 1
7079 nsubalignments = 2
7080 maxmem = 13
7081 generating a scoring matrix for nucleotide (dist=200) ... done
7082
7083
7084
7085 0 / 23
7086 10 / 23
7087 20 / 23
7088
7089 Checking subalignment 1:
7090 1 2 3 4 5 6 7 8 9 10 11 12 13
7091 -> OK
7092
7093 Checking subalignment 2:
7094 14 15 16 17 18 19 20 21 22 23
7095 -> OK
7096 Segment 1/ 1 1- 155
7097 001-0000-0 (thread 1) skip
7098
7099 001-0001-1 (thread 1) skip
7100
7101 001-0002-0 (thread 1) skip
7102
7103 001-0003-1 (thread 1) skip
7104
7105 001-0004-0 (thread 1) skip
7106
7107 001-0005-1 (thread 1) skip
7108
7109 001-0006-0 (thread 1) skip
7110
7111 001-0007-1 (thread 1) skip
7112
7113 001-0008-0 (thread 1) skip
7114
7115 001-0009-1 (thread 1) skip
7116
7117 001-0010-0 (thread 1) skip
7118
7119 001-0011-1 (thread 1) skip
7120
7121 001-0012-0 (thread 1) skip
7122
7123 001-0013-1 (thread 1) skip
7124
7125 001-0014-0 (thread 1) skip
7126
7127 001-0015-1 (thread 1) skip
7128
7129 001-0016-0 (thread 1) skip
7130
7131 001-0017-1 (thread 1) skip
7132
7133 001-0018-0 (thread 1) skip
7134
7135 001-0019-1 (thread 1) skip
7136
7137 001-0020-0 (thread 1) skip
7138
7139 001-0021-1 (thread 1) skip
7140
7141 001-0022-0 (thread 1) skip
7142
7143 001-0023-1 (thread 1) skip
7144
7145 001-0024-0 (thread 1) skip
7146
7147 001-0025-1 (thread 1) skip
7148
7149 001-0026-0 (thread 1) skip
7150
7151 001-0027-1 (thread 1) skip
7152
7153 001-0028-0 (thread 1) skip
7154
7155 001-0029-1 (thread 1) skip
7156
7157 001-0030-0 (thread 1) skip
7158
7159 001-0031-1 (thread 1) skip
7160
7161 001-0032-0 (thread 1) skip
7162
7163 001-0033-1 (thread 1) skip
7164
7165 001-0034-0 (thread 1) skip
7166
7167 001-0035-1 (thread 1) skip
7168
7169 001-0036-0 (thread 1) skip
7170
7171 001-0037-1 (thread 1) skip
7172
7173 001-0038-0 (thread 1) skip
7174
7175 001-0039-1 (thread 1) skip
7176
7177 001-0040-0 (thread 1) skip
7178
7179 001-0041-1 (thread 1) skip
7180
7181 001-0042-1 (thread 1) identical
7182
7183 Converged.
7184
7185 Reached 1
7186 done
7187 dvtditr (nuc) Version 7.407
7188 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7189 1 thread(s)
7190
7191
7192 Strategy:
7193 FFT-NS-i (Standard)
7194 Iterative refinement method (max. 1 iterations)
7195
7196 If unsure which option to use, try 'mafft --auto input > output'.
7197 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
7198
7199 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
7200 It tends to insert more gaps into gap-rich regions than previous versions.
7201 To disable this change, add the --leavegappyregion option.
7202
7203 inputfile = orig
7204 38 x 198 - 155 d
7205 nthread = 1
7206 nthreadpair = 1
7207 nthreadtb = 1
7208 ppenalty_ex = 0
7209 stacksize: 8192 kb
7210 nsubalignments = 2
7211 maxmem = 26
7212 generating a scoring matrix for nucleotide (dist=200) ... done
7213 Gap Penalty = -1.53, +0.00, +0.00
7214
7215
7216
7217 Making a distance matrix ..
7218
7219 1 / 38 (thread 0)
7220 done.
7221
7222 Constructing a UPGMA tree ...
7223
7224
7225 0 / 38
7226 10 / 38
7227 20 / 38
7228 30 / 38
7229 done.
7230
7231 Checking subalignment 1:
7232 -> OK
7233 Checking subalignment 2:
7234 -> OK
7235 Progressive alignment 1/2...
7236
7237 STEP 37 / 37 (thread 0) f
7238 done.
7239
7240 Making a distance matrix from msa..
7241
7242 0 / 38 (thread 0)
7243 done.
7244
7245 Constructing a UPGMA tree ...
7246
7247
7248 0 / 38
7249 10 / 38
7250 20 / 38
7251 30 / 38
7252 done.
7253
7254 Checking subalignment 1:
7255 -> OK
7256 Checking subalignment 2:
7257 -> OK
7258 Progressive alignment 2/2...
7259
7260 STEP 37 / 37 (thread 0) f
7261 done.
7262
7263 disttbfast (nuc) Version 7.407
7264 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7265 1 thread(s)
7266
7267 generating a scoring matrix for nucleotide (dist=200) ... done
7268
7269 0 / 38 (thread 0)dndpre (nuc) Version 7.407
7270 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
7271 1 thread(s)
7272
7273 minimumweight = 0.000010
7274 autosubalignment = 0.000000
7275 nthread = 1
7276 randomseed = 0
7277 blosum 62 / kimura 200
7278 poffset = 0
7279 niter = 1
7280 sueff_global = 0.100000
7281 nadd = 1
7282 nsubalignments = 2
7283 maxmem = 26
7284 generating a scoring matrix for nucleotide (dist=200) ... done
7285
7286
7287
7288 0 / 38
7289 10 / 38
7290 20 / 38
7291 30 / 38
7292
7293 Checking subalignment 1:
7294 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
7295 -> OK
7296
7297 Checking subalignment 2:
7298 27 28 29 30 31 32 33 34 35 36 37 38
7299 -> OK
7300 Segment 1/ 1 1- 205
7301 001-0000-0 (thread 1) skip
7302
7303 001-0001-1 (thread 1) skip
7304
7305 001-0002-0 (thread 1) skip
7306
7307 001-0003-1 (thread 1) skip
7308
7309 001-0004-0 (thread 1) skip
7310
7311 001-0005-1 (thread 1) skip
7312
7313 001-0006-0 (thread 1) skip
7314
7315 001-0007-1 (thread 1) skip
7316
7317 001-0008-0 (thread 1) skip
7318
7319 001-0009-1 (thread 1) skip
7320
7321 001-0010-0 (thread 1) skip
7322
7323 001-0011-1 (thread 1) skip
7324
7325 001-0012-0 (thread 1) skip
7326
7327 001-0013-1 (thread 1) skip
7328
7329 001-0014-0 (thread 1) skip
7330
7331 001-0015-1 (thread 1) skip
7332
7333 001-0016-0 (thread 1) skip
7334
7335 001-0017-1 (thread 1) skip
7336
7337 001-0018-0 (thread 1) skip
7338
7339 001-0019-1 (thread 1) skip
7340
7341 001-0020-0 (thread 1) skip
7342
7343 001-0021-1 (thread 1) skip
7344
7345 001-0022-0 (thread 1) skip
7346
7347 001-0023-1 (thread 1) skip
7348
7349 001-0024-0 (thread 1) skip
7350
7351 001-0025-1 (thread 1) skip
7352
7353 001-0026-0 (thread 1) skip
7354
7355 001-0027-1 (thread 1) skip
7356
7357 001-0028-0 (thread 1) skip
7358
7359 001-0029-1 (thread 1) skip
7360
7361 001-0030-0 (thread 1) skip
7362
7363 001-0031-1 (thread 1) skip
7364
7365 001-0032-0 (thread 1) skip
7366
7367 001-0033-1 (thread 1) skip
7368
7369 001-0034-0 (thread 1) skip
7370
7371 001-0035-1 (thread 1) skip
7372
7373 001-0036-0 (thread 1) skip
7374
7375 001-0037-1 (thread 1) skip
7376
7377 001-0038-0 (thread 1) skip
7378
7379 001-0039-1 (thread 1) skip
7380
7381 001-0040-0 (thread 1) skip
7382
7383 001-0041-1 (thread 1) skip
7384
7385 001-0042-0 (thread 1) skip
7386
7387 001-0043-1 (thread 1) skip
7388
7389 001-0044-0 (thread 1) skip
7390
7391 001-0045-1 (thread 1) skip
7392
7393 001-0046-0 (thread 1) skip
7394
7395 001-0047-1 (thread 1) skip
7396
7397 001-0048-0 (thread 1) skip
7398
7399 001-0049-1 (thread 1) skip
7400
7401 001-0050-0 (thread 1) skip
7402
7403 001-0051-1 (thread 1) skip
7404
7405 001-0052-0 (thread 1) skip
7406
7407 001-0053-1 (thread 1) skip
7408
7409 001-0054-0 (thread 1) skip
7410
7411 001-0055-1 (thread 1) skip
7412
7413 001-0056-0 (thread 1) skip
7414
7415 001-0057-1 (thread 1) skip
7416
7417 001-0058-0 (thread 1) skip
7418
7419 001-0059-1 (thread 1) skip
7420
7421 001-0060-0 (thread 1) skip
7422
7423 001-0061-1 (thread 1) skip
7424
7425 001-0062-0 (thread 1) skip
7426
7427 001-0063-1 (thread 1) skip
7428
7429 001-0064-0 (thread 1) skip
7430
7431 001-0065-1 (thread 1) skip
7432
7433 001-0066-0 (thread 1) skip
7434
7435 001-0067-1 (thread 1) skip
7436
7437 001-0068-0 (thread 1) skip
7438
7439 001-0069-1 (thread 1) skip
7440
7441 001-0070-0 (thread 1) skip
7442
7443 001-0071-1 (thread 1) skip
7444
7445 001-0072-1 (thread 1) identical
7446 001-0072-1 (thread 1) better
7447
7448 Reached 1
7449 done
7450 dvtditr (nuc) Version 7.407
7451 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7452 1 thread(s)
7453
7454
7455 Strategy:
7456 FFT-NS-i (Standard)
7457 Iterative refinement method (max. 1 iterations)
7458
7459 If unsure which option to use, try 'mafft --auto input > output'.
7460 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
7461
7462 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
7463 It tends to insert more gaps into gap-rich regions than previous versions.
7464 To disable this change, add the --leavegappyregion option.
7465
7466 inputfile = orig
7467 34 x 182 - 104 d
7468 nthread = 1
7469 nthreadpair = 1
7470 nthreadtb = 1
7471 ppenalty_ex = 0
7472 stacksize: 8192 kb
7473 nsubalignments = 2
7474 maxmem = 25
7475 generating a scoring matrix for nucleotide (dist=200) ... done
7476 Gap Penalty = -1.53, +0.00, +0.00
7477
7478
7479
7480 Making a distance matrix ..
7481
7482 1 / 34 (thread 0)
7483 done.
7484
7485 Constructing a UPGMA tree ...
7486
7487
7488 0 / 34
7489 10 / 34
7490 20 / 34
7491 30 / 34
7492 done.
7493
7494 Checking subalignment 1:
7495 -> OK
7496 Checking subalignment 2:
7497 -> OK
7498 Progressive alignment 1/2...
7499
7500 STEP 33 / 33 (thread 0) f
7501 done.
7502
7503 Making a distance matrix from msa..
7504
7505 0 / 34 (thread 0)
7506 done.
7507
7508 Constructing a UPGMA tree ...
7509
7510
7511 0 / 34
7512 10 / 34
7513 20 / 34
7514 30 / 34
7515 done.
7516
7517 Checking subalignment 1:
7518 -> OK
7519 Checking subalignment 2:
7520 -> OK
7521 Progressive alignment 2/2...
7522
7523 STEP 33 / 33 (thread 0) f
7524 done.
7525
7526 disttbfast (nuc) Version 7.407
7527 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7528 1 thread(s)
7529
7530 generating a scoring matrix for nucleotide (dist=200) ... done
7531
7532 0 / 34 (thread 0)dndpre (nuc) Version 7.407
7533 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
7534 1 thread(s)
7535
7536 minimumweight = 0.000010
7537 autosubalignment = 0.000000
7538 nthread = 1
7539 randomseed = 0
7540 blosum 62 / kimura 200
7541 poffset = 0
7542 niter = 1
7543 sueff_global = 0.100000
7544 nadd = 1
7545 nsubalignments = 2
7546 maxmem = 25
7547 generating a scoring matrix for nucleotide (dist=200) ... done
7548
7549
7550
7551 0 / 34
7552 10 / 34
7553 20 / 34
7554 30 / 34
7555
7556 Checking subalignment 1:
7557 1 2 3 4 5 6 7 8 9
7558 -> OK
7559
7560 Checking subalignment 2:
7561 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
7562 -> OK
7563 Segment 1/ 1 1- 188
7564 001-0000-0 (thread 1) skip
7565
7566 001-0001-1 (thread 1) skip
7567
7568 001-0002-0 (thread 1) skip
7569
7570 001-0003-1 (thread 1) skip
7571
7572 001-0004-0 (thread 1) skip
7573
7574 001-0005-1 (thread 1) skip
7575
7576 001-0006-0 (thread 1) skip
7577
7578 001-0007-1 (thread 1) skip
7579
7580 001-0008-0 (thread 1) skip
7581
7582 001-0009-1 (thread 1) skip
7583
7584 001-0010-0 (thread 1) skip
7585
7586 001-0011-1 (thread 1) skip
7587
7588 001-0012-0 (thread 1) skip
7589
7590 001-0013-1 (thread 1) skip
7591
7592 001-0014-0 (thread 1) skip
7593
7594 001-0015-1 (thread 1) skip
7595
7596 001-0016-0 (thread 1) skip
7597
7598 001-0017-1 (thread 1) skip
7599
7600 001-0018-0 (thread 1) skip
7601
7602 001-0019-1 (thread 1) skip
7603
7604 001-0020-0 (thread 1) skip
7605
7606 001-0021-1 (thread 1) skip
7607
7608 001-0022-0 (thread 1) skip
7609
7610 001-0023-1 (thread 1) skip
7611
7612 001-0024-0 (thread 1) skip
7613
7614 001-0025-1 (thread 1) skip
7615
7616 001-0026-0 (thread 1) skip
7617
7618 001-0027-1 (thread 1) skip
7619
7620 001-0028-0 (thread 1) skip
7621
7622 001-0029-1 (thread 1) skip
7623
7624 001-0030-0 (thread 1) skip
7625
7626 001-0031-1 (thread 1) skip
7627
7628 001-0032-0 (thread 1) skip
7629
7630 001-0033-1 (thread 1) skip
7631
7632 001-0034-0 (thread 1) skip
7633
7634 001-0035-1 (thread 1) skip
7635
7636 001-0036-0 (thread 1) skip
7637
7638 001-0037-1 (thread 1) skip
7639
7640 001-0038-0 (thread 1) skip
7641
7642 001-0039-1 (thread 1) skip
7643
7644 001-0040-0 (thread 1) skip
7645
7646 001-0041-1 (thread 1) skip
7647
7648 001-0042-0 (thread 1) skip
7649
7650 001-0043-1 (thread 1) skip
7651
7652 001-0044-0 (thread 1) skip
7653
7654 001-0045-1 (thread 1) skip
7655
7656 001-0046-0 (thread 1) skip
7657
7658 001-0047-1 (thread 1) skip
7659
7660 001-0048-0 (thread 1) skip
7661
7662 001-0049-1 (thread 1) skip
7663
7664 001-0050-0 (thread 1) skip
7665
7666 001-0051-1 (thread 1) skip
7667
7668 001-0052-0 (thread 1) skip
7669
7670 001-0053-1 (thread 1) skip
7671
7672 001-0054-0 (thread 1) skip
7673
7674 001-0055-1 (thread 1) skip
7675
7676 001-0056-0 (thread 1) skip
7677
7678 001-0057-1 (thread 1) skip
7679
7680 001-0058-0 (thread 1) skip
7681
7682 001-0059-1 (thread 1) skip
7683
7684 001-0060-0 (thread 1) skip
7685
7686 001-0061-1 (thread 1) skip
7687
7688 001-0062-0 (thread 1) skip
7689
7690 001-0063-1 (thread 1) skip
7691
7692 001-0064-1 (thread 1) identical
7693 001-0064-1 (thread 1) better
7694
7695 Reached 1
7696 done
7697 dvtditr (nuc) Version 7.407
7698 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7699 1 thread(s)
7700
7701
7702 Strategy:
7703 FFT-NS-i (Standard)
7704 Iterative refinement method (max. 1 iterations)
7705
7706 If unsure which option to use, try 'mafft --auto input > output'.
7707 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
7708
7709 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
7710 It tends to insert more gaps into gap-rich regions than previous versions.
7711 To disable this change, add the --leavegappyregion option.
7712
7713 inputfile = orig
7714 24 x 154 - 70 d
7715 nadd = 1
7716 generating a scoring matrix for nucleotide (dist=200) ... done
7717
7718 0 / 23 (thread 0)dndpre (nuc) Version 7.407
7719 alg=X, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
7720 1 thread(s)
7721
7722 generating a scoring matrix for nucleotide (dist=200) ... done
7723 All-to-all alignment.
7724
7725
7726 ##### writing hat3
7727 pairlocalalign (nuc) Version 7.407
7728 alg=Y, model=DNA200 (2), 2.00 (6.00), -0.10 (-0.30), noshift, amax=0.0
7729 1 thread(s)
7730
7731 nadd = 1
7732 ppenalty_ex = -10
7733 nthread = 1
7734 blosum 62 / kimura 200
7735 sueff_global = 0.100000
7736 norg = 23
7737 njobc = 24
7738 Loading 'hat3' ...
7739 done.
7740 generating a scoring matrix for nucleotide (dist=200) ... done
7741 Loading 'hat2n' (aligned sequences - new sequences) ... done.
7742 Loading 'hat2i' (aligned sequences) ... done.
7743
7744 0 / 1 (thread 0)
7745 c
7746
7747 Combining ..
7748 0 / 1
7749 0 / 1
7750
7751 done.
7752
7753
7754 done.
7755
7756 addsingle (nuc) Version 7.407
7757 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7758 1 thread(s)
7759
7760
7761 Strategy:
7762 Multi-INS-fragment (Not tested.)
7763 ?
7764
7765 If unsure which option to use, try 'mafft --auto input > output'.
7766 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
7767
7768 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
7769 It tends to insert more gaps into gap-rich regions than previous versions.
7770 To disable this change, add the --leavegappyregion option.
7771
7772 inputfile = orig
7773 38 x 187 - 149 d
7774 nthread = 1
7775 nthreadpair = 1
7776 nthreadtb = 1
7777 ppenalty_ex = 0
7778 stacksize: 8192 kb
7779 nsubalignments = 2
7780 maxmem = 34
7781 generating a scoring matrix for nucleotide (dist=200) ... done
7782 Gap Penalty = -1.53, +0.00, +0.00
7783
7784
7785
7786 Making a distance matrix ..
7787
7788 1 / 38 (thread 0)
7789 done.
7790
7791 Constructing a UPGMA tree ...
7792
7793
7794 0 / 38
7795 10 / 38
7796 20 / 38
7797 30 / 38
7798 done.
7799
7800 Checking subalignment 1:
7801 -> OK
7802 Checking subalignment 2:
7803 -> OK
7804 Progressive alignment 1/2...
7805
7806 STEP 37 / 37 (thread 0) f
7807 done.
7808
7809 Making a distance matrix from msa..
7810
7811 0 / 38 (thread 0)
7812 done.
7813
7814 Constructing a UPGMA tree ...
7815
7816
7817 0 / 38
7818 10 / 38
7819 20 / 38
7820 30 / 38
7821 done.
7822
7823 Checking subalignment 1:
7824 -> OK
7825 Checking subalignment 2:
7826 -> OK
7827 Progressive alignment 2/2...
7828
7829 STEP 37 / 37 (thread 0) f
7830 done.
7831
7832 disttbfast (nuc) Version 7.407
7833 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
7834 1 thread(s)
7835
7836 generating a scoring matrix for nucleotide (dist=200) ... done
7837
7838 0 / 38 (thread 0)dndpre (nuc) Version 7.407
7839 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
7840 1 thread(s)
7841
7842 minimumweight = 0.000010
7843 autosubalignment = 0.000000
7844 nthread = 1
7845 randomseed = 0
7846 blosum 62 / kimura 200
7847 poffset = 0
7848 niter = 1
7849 sueff_global = 0.100000
7850 nadd = 1
7851 nsubalignments = 2
7852 maxmem = 34
7853 generating a scoring matrix for nucleotide (dist=200) ... done
7854
7855
7856
7857 0 / 38
7858 10 / 38
7859 20 / 38
7860 30 / 38
7861
7862 Checking subalignment 1:
7863 1 2 3 4
7864 -> OK
7865
7866 Checking subalignment 2:
7867 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
7868 -> OK
7869 Segment 1/ 1 1- 216
7870 001-0000-0 (thread 1) skip
7871
7872 001-0001-1 (thread 1) skip
7873
7874 001-0002-0 (thread 1) skip
7875
7876 001-0003-1 (thread 1) skip
7877
7878 001-0004-0 (thread 1) skip
7879
7880 001-0005-1 (thread 1) skip
7881
7882 001-0006-0 (thread 1) skip
7883
7884 001-0007-1 (thread 1) skip
7885
7886 001-0008-0 (thread 1) skip
7887
7888 001-0009-1 (thread 1) skip
7889
7890 001-0010-0 (thread 1) skip
7891
7892 001-0011-1 (thread 1) skip
7893
7894 001-0012-0 (thread 1) skip
7895
7896 001-0013-1 (thread 1) skip
7897
7898 001-0014-0 (thread 1) skip
7899
7900 001-0015-1 (thread 1) skip
7901
7902 001-0016-0 (thread 1) skip
7903
7904 001-0017-1 (thread 1) skip
7905
7906 001-0018-0 (thread 1) skip
7907
7908 001-0019-1 (thread 1) skip
7909
7910 001-0020-0 (thread 1) skip
7911
7912 001-0021-1 (thread 1) skip
7913
7914 001-0022-0 (thread 1) skip
7915
7916 001-0023-1 (thread 1) skip
7917
7918 001-0024-0 (thread 1) skip
7919
7920 001-0025-1 (thread 1) skip
7921
7922 001-0026-0 (thread 1) skip
7923
7924 001-0027-1 (thread 1) skip
7925
7926 001-0028-0 (thread 1) skip
7927
7928 001-0029-1 (thread 1) skip
7929
7930 001-0030-0 (thread 1) skip
7931
7932 001-0031-1 (thread 1) skip
7933
7934 001-0032-0 (thread 1) skip
7935
7936 001-0033-1 (thread 1) skip
7937
7938 001-0034-0 (thread 1) skip
7939
7940 001-0035-1 (thread 1) skip
7941
7942 001-0036-0 (thread 1) skip
7943
7944 001-0037-1 (thread 1) skip
7945
7946 001-0038-0 (thread 1) skip
7947
7948 001-0039-1 (thread 1) skip
7949
7950 001-0040-0 (thread 1) skip
7951
7952 001-0041-1 (thread 1) skip
7953
7954 001-0042-0 (thread 1) skip
7955
7956 001-0043-1 (thread 1) skip
7957
7958 001-0044-0 (thread 1) skip
7959
7960 001-0045-1 (thread 1) skip
7961
7962 001-0046-0 (thread 1) skip
7963
7964 001-0047-1 (thread 1) skip
7965
7966 001-0048-0 (thread 1) skip
7967
7968 001-0049-1 (thread 1) skip
7969
7970 001-0050-0 (thread 1) skip
7971
7972 001-0051-1 (thread 1) skip
7973
7974 001-0052-0 (thread 1) skip
7975
7976 001-0053-1 (thread 1) skip
7977
7978 001-0054-0 (thread 1) skip
7979
7980 001-0055-1 (thread 1) skip
7981
7982 001-0056-0 (thread 1) skip
7983
7984 001-0057-1 (thread 1) skip
7985
7986 001-0058-0 (thread 1) skip
7987
7988 001-0059-1 (thread 1) skip
7989
7990 001-0060-0 (thread 1) skip
7991
7992 001-0061-1 (thread 1) skip
7993
7994 001-0062-0 (thread 1) skip
7995
7996 001-0063-1 (thread 1) skip
7997
7998 001-0064-0 (thread 1) skip
7999
8000 001-0065-1 (thread 1) skip
8001
8002 001-0066-0 (thread 1) skip
8003
8004 001-0067-1 (thread 1) skip
8005
8006 001-0068-0 (thread 1) skip
8007
8008 001-0069-1 (thread 1) skip
8009
8010 001-0070-0 (thread 1) skip
8011
8012 001-0071-1 (thread 1) skip
8013
8014 001-0072-1 (thread 1) identical
8015 001-0072-1 (thread 1) worse
8016
8017 Converged.
8018
8019 Reached 1
8020 done
8021 dvtditr (nuc) Version 7.407
8022 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
8023 1 thread(s)
8024
8025
8026 Strategy:
8027 FFT-NS-i (Standard)
8028 Iterative refinement method (max. 1 iterations)
8029
8030 If unsure which option to use, try 'mafft --auto input > output'.
8031 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
8032
8033 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
8034 It tends to insert more gaps into gap-rich regions than previous versions.
8035 To disable this change, add the --leavegappyregion option.
8036
8037 inputfile = orig
8038 76 x 215 - 206 d
8039 nthread = 1
8040 nthreadpair = 1
8041 nthreadtb = 1
8042 ppenalty_ex = 0
8043 stacksize: 8192 kb
8044 nsubalignments = 2
8045 maxmem = 38
8046 generating a scoring matrix for nucleotide (dist=200) ... done
8047 Gap Penalty = -1.53, +0.00, +0.00
8048
8049
8050
8051 Making a distance matrix ..
8052
8053 1 / 76 (thread 0)
8054 done.
8055
8056 Constructing a UPGMA tree ...
8057
8058
8059 0 / 76
8060 10 / 76
8061 20 / 76
8062 30 / 76
8063 40 / 76
8064 50 / 76
8065 60 / 76
8066 70 / 76
8067 done.
8068
8069 Checking subalignment 1:
8070 -> OK
8071 Checking subalignment 2:
8072 -> OK
8073 Progressive alignment 1/2...
8074
8075 STEP 75 / 75 (thread 0) f
8076 done.
8077
8078 Making a distance matrix from msa..
8079
8080 0 / 76 (thread 0)
8081 done.
8082
8083 Constructing a UPGMA tree ...
8084
8085
8086 0 / 76
8087 10 / 76
8088 20 / 76
8089 30 / 76
8090 40 / 76
8091 50 / 76
8092 60 / 76
8093 70 / 76
8094 done.
8095
8096 Checking subalignment 1:
8097 -> OK
8098 Checking subalignment 2:
8099 -> OK
8100 Progressive alignment 2/2...
8101
8102 STEP 75 / 75 (thread 0) f
8103 done.
8104
8105 disttbfast (nuc) Version 7.407
8106 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
8107 1 thread(s)
8108
8109 generating a scoring matrix for nucleotide (dist=200) ... done
8110
8111 0 / 76 (thread 0)dndpre (nuc) Version 7.407
8112 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
8113 1 thread(s)
8114
8115 minimumweight = 0.000010
8116 autosubalignment = 0.000000
8117 nthread = 1
8118 randomseed = 0
8119 blosum 62 / kimura 200
8120 poffset = 0
8121 niter = 1
8122 sueff_global = 0.100000
8123 nadd = 1
8124 nsubalignments = 2
8125 maxmem = 38
8126 generating a scoring matrix for nucleotide (dist=200) ... done
8127
8128
8129
8130 0 / 76
8131 10 / 76
8132 20 / 76
8133 30 / 76
8134 40 / 76
8135 50 / 76
8136 60 / 76
8137 70 / 76
8138
8139 Checking subalignment 1:
8140 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
8141 -> OK
8142
8143 Checking subalignment 2:
8144 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
8145 -> OK
8146 Segment 1/ 1 1- 285
8147 001-0000-0 (thread 1) skip
8148
8149 001-0001-1 (thread 1) skip
8150
8151 001-0002-0 (thread 1) skip
8152
8153 001-0003-1 (thread 1) skip
8154
8155 001-0004-0 (thread 1) skip
8156
8157 001-0005-1 (thread 1) skip
8158
8159 001-0006-0 (thread 1) skip
8160
8161 001-0007-1 (thread 1) skip
8162
8163 001-0008-0 (thread 1) skip
8164
8165 001-0009-1 (thread 1) skip
8166
8167 001-0010-0 (thread 1) skip
8168
8169 001-0011-1 (thread 1) skip
8170
8171 001-0012-0 (thread 1) skip
8172
8173 001-0013-1 (thread 1) skip
8174
8175 001-0014-0 (thread 1) skip
8176
8177 001-0015-1 (thread 1) skip
8178
8179 001-0016-0 (thread 1) skip
8180
8181 001-0017-1 (thread 1) skip
8182
8183 001-0018-0 (thread 1) skip
8184
8185 001-0019-1 (thread 1) skip
8186
8187 001-0020-0 (thread 1) skip
8188
8189 001-0021-1 (thread 1) skip
8190
8191 001-0022-0 (thread 1) skip
8192
8193 001-0023-1 (thread 1) skip
8194
8195 001-0024-0 (thread 1) skip
8196
8197 001-0025-1 (thread 1) skip
8198
8199 001-0026-0 (thread 1) skip
8200
8201 001-0027-1 (thread 1) skip
8202
8203 001-0028-0 (thread 1) skip
8204
8205 001-0029-1 (thread 1) skip
8206
8207 001-0030-0 (thread 1) skip
8208
8209 001-0031-1 (thread 1) skip
8210
8211 001-0032-0 (thread 1) skip
8212
8213 001-0033-1 (thread 1) skip
8214
8215 001-0034-0 (thread 1) skip
8216
8217 001-0035-1 (thread 1) skip
8218
8219 001-0036-0 (thread 1) skip
8220
8221 001-0037-1 (thread 1) skip
8222
8223 001-0038-0 (thread 1) skip
8224
8225 001-0039-1 (thread 1) skip
8226
8227 001-0040-0 (thread 1) skip
8228
8229 001-0041-1 (thread 1) skip
8230
8231 001-0042-0 (thread 1) skip
8232
8233 001-0043-1 (thread 1) skip
8234
8235 001-0044-0 (thread 1) skip
8236
8237 001-0045-1 (thread 1) skip
8238
8239 001-0046-0 (thread 1) skip
8240
8241 001-0047-1 (thread 1) skip
8242
8243 001-0048-0 (thread 1) skip
8244
8245 001-0049-1 (thread 1) skip
8246
8247 001-0050-0 (thread 1) skip
8248
8249 001-0051-1 (thread 1) skip
8250
8251 001-0052-0 (thread 1) skip
8252
8253 001-0053-1 (thread 1) skip
8254
8255 001-0054-0 (thread 1) skip
8256
8257 001-0055-1 (thread 1) skip
8258
8259 001-0056-0 (thread 1) skip
8260
8261 001-0057-1 (thread 1) skip
8262
8263 001-0058-0 (thread 1) skip
8264
8265 001-0059-1 (thread 1) skip
8266
8267 001-0060-0 (thread 1) skip
8268
8269 001-0061-1 (thread 1) skip
8270
8271 001-0062-0 (thread 1) skip
8272
8273 001-0063-1 (thread 1) skip
8274
8275 001-0064-0 (thread 1) skip
8276
8277 001-0065-1 (thread 1) skip
8278
8279 001-0066-0 (thread 1) skip
8280
8281 001-0067-1 (thread 1) skip
8282
8283 001-0068-0 (thread 1) skip
8284
8285 001-0069-1 (thread 1) skip
8286
8287 001-0070-0 (thread 1) skip
8288
8289 001-0071-1 (thread 1) skip
8290
8291 001-0072-0 (thread 1) skip
8292
8293 001-0073-1 (thread 1) skip
8294
8295 001-0074-0 (thread 1) skip
8296
8297 001-0075-1 (thread 1) skip
8298
8299 001-0076-0 (thread 1) skip
8300
8301 001-0077-1 (thread 1) skip
8302
8303 001-0078-0 (thread 1) skip
8304
8305 001-0079-1 (thread 1) skip
8306
8307 001-0080-0 (thread 1) skip
8308
8309 001-0081-1 (thread 1) skip
8310
8311 001-0082-0 (thread 1) skip
8312
8313 001-0083-1 (thread 1) skip
8314
8315 001-0084-0 (thread 1) skip
8316
8317 001-0085-1 (thread 1) skip
8318
8319 001-0086-0 (thread 1) skip
8320
8321 001-0087-1 (thread 1) skip
8322
8323 001-0088-0 (thread 1) skip
8324
8325 001-0089-1 (thread 1) skip
8326
8327 001-0090-0 (thread 1) skip
8328
8329 001-0091-1 (thread 1) skip
8330
8331 001-0092-0 (thread 1) skip
8332
8333 001-0093-1 (thread 1) skip
8334
8335 001-0094-0 (thread 1) skip
8336
8337 001-0095-1 (thread 1) skip
8338
8339 001-0096-0 (thread 1) skip
8340
8341 001-0097-1 (thread 1) skip
8342
8343 001-0098-0 (thread 1) skip
8344
8345 001-0099-1 (thread 1) skip
8346
8347 001-0100-0 (thread 1) skip
8348
8349 001-0101-1 (thread 1) skip
8350
8351 001-0102-0 (thread 1) skip
8352
8353 001-0103-1 (thread 1) skip
8354
8355 001-0104-0 (thread 1) skip
8356
8357 001-0105-1 (thread 1) skip
8358
8359 001-0106-0 (thread 1) skip
8360
8361 001-0107-1 (thread 1) skip
8362
8363 001-0108-0 (thread 1) skip
8364
8365 001-0109-1 (thread 1) skip
8366
8367 001-0110-0 (thread 1) skip
8368
8369 001-0111-1 (thread 1) skip
8370
8371 001-0112-0 (thread 1) skip
8372
8373 001-0113-1 (thread 1) skip
8374
8375 001-0114-0 (thread 1) skip
8376
8377 001-0115-1 (thread 1) skip
8378
8379 001-0116-0 (thread 1) skip
8380
8381 001-0117-1 (thread 1) skip
8382
8383 001-0118-0 (thread 1) skip
8384
8385 001-0119-1 (thread 1) skip
8386
8387 001-0120-0 (thread 1) skip
8388
8389 001-0121-1 (thread 1) skip
8390
8391 001-0122-0 (thread 1) skip
8392
8393 001-0123-1 (thread 1) skip
8394
8395 001-0124-0 (thread 1) skip
8396
8397 001-0125-1 (thread 1) skip
8398
8399 001-0126-0 (thread 1) skip
8400
8401 001-0127-1 (thread 1) skip
8402
8403 001-0128-0 (thread 1) skip
8404
8405 001-0129-1 (thread 1) skip
8406
8407 001-0130-0 (thread 1) skip
8408
8409 001-0131-1 (thread 1) skip
8410
8411 001-0132-0 (thread 1) skip
8412
8413 001-0133-1 (thread 1) skip
8414
8415 001-0134-0 (thread 1) skip
8416
8417 001-0135-1 (thread 1) skip
8418
8419 001-0136-0 (thread 1) skip
8420
8421 001-0137-1 (thread 1) skip
8422
8423 001-0138-0 (thread 1) skip
8424
8425 001-0139-1 (thread 1) skip
8426
8427 001-0140-0 (thread 1) skip
8428
8429 001-0141-1 (thread 1) skip
8430
8431 001-0142-0 (thread 1) skip
8432
8433 001-0143-1 (thread 1) skip
8434
8435 001-0144-0 (thread 1) skip
8436
8437 001-0145-1 (thread 1) skip
8438
8439 001-0146-0 (thread 1) skip
8440
8441 001-0147-1 (thread 1) skip
8442
8443 001-0148-1 (thread 1) identical
8444 001-0148-1 (thread 1) better
8445
8446 Reached 1
8447 done
8448 dvtditr (nuc) Version 7.407
8449 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
8450 1 thread(s)
8451
8452
8453 Strategy:
8454 FFT-NS-i (Standard)
8455 Iterative refinement method (max. 1 iterations)
8456
8457 If unsure which option to use, try 'mafft --auto input > output'.
8458 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
8459
8460 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
8461 It tends to insert more gaps into gap-rich regions than previous versions.
8462 To disable this change, add the --leavegappyregion option.
8463
8464 inputfile = orig
8465 100 x 273 - 156 d
8466 nthread = 1
8467 nthreadpair = 1
8468 nthreadtb = 1
8469 ppenalty_ex = 0
8470 stacksize: 8192 kb
8471 nsubalignments = 2
8472 maxmem = 76
8473 generating a scoring matrix for nucleotide (dist=200) ... done
8474 Gap Penalty = -1.53, +0.00, +0.00
8475
8476
8477
8478 Making a distance matrix ..
8479
8480 1 / 100 (thread 0)
8481 done.
8482
8483 Constructing a UPGMA tree ...
8484
8485
8486 0 / 100
8487 10 / 100
8488 20 / 100
8489 30 / 100
8490 40 / 100
8491 50 / 100
8492 60 / 100
8493 70 / 100
8494 80 / 100
8495 90 / 100
8496 done.
8497
8498 Checking subalignment 1:
8499 -> OK
8500 Checking subalignment 2:
8501 -> OK
8502 Progressive alignment 1/2...
8503
8504 STEP 99 / 99 (thread 0) f
8505 done.
8506
8507 Making a distance matrix from msa..
8508
8509 0 / 100 (thread 0)
8510 done.
8511
8512 Constructing a UPGMA tree ...
8513
8514
8515 0 / 100
8516 10 / 100
8517 20 / 100
8518 30 / 100
8519 40 / 100
8520 50 / 100
8521 60 / 100
8522 70 / 100
8523 80 / 100
8524 90 / 100
8525 done.
8526
8527 Checking subalignment 1:
8528 -> OK
8529 Checking subalignment 2:
8530 -> OK
8531 Progressive alignment 2/2...
8532
8533 STEP 99 / 99 (thread 0) f
8534 done.
8535
8536 disttbfast (nuc) Version 7.407
8537 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
8538 1 thread(s)
8539
8540 generating a scoring matrix for nucleotide (dist=200) ... done
8541
8542 0 / 100 (thread 0)dndpre (nuc) Version 7.407
8543 alg=X, model=DNA200 (2), 1.53 (4.59), 0.37 (1.11), noshift, amax=0.0
8544 1 thread(s)
8545
8546 minimumweight = 0.000010
8547 autosubalignment = 0.000000
8548 nthread = 1
8549 randomseed = 0
8550 blosum 62 / kimura 200
8551 poffset = 0
8552 niter = 1
8553 sueff_global = 0.100000
8554 nadd = 1
8555 nsubalignments = 2
8556 maxmem = 76
8557 generating a scoring matrix for nucleotide (dist=200) ... done
8558
8559
8560
8561 0 / 100
8562 10 / 100
8563 20 / 100
8564 30 / 100
8565 40 / 100
8566 50 / 100
8567 60 / 100
8568 70 / 100
8569 80 / 100
8570 90 / 100
8571
8572 Checking subalignment 1:
8573 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
8574 -> OK
8575
8576 Checking subalignment 2:
8577 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
8578 -> OK
8579 Segment 1/ 1 1- 279
8580 001-0000-0 (thread 1) skip
8581
8582 001-0001-1 (thread 1) skip
8583
8584 001-0002-0 (thread 1) skip
8585
8586 001-0003-1 (thread 1) skip
8587
8588 001-0004-0 (thread 1) skip
8589
8590 001-0005-1 (thread 1) skip
8591
8592 001-0006-0 (thread 1) skip
8593
8594 001-0007-1 (thread 1) skip
8595
8596 001-0008-0 (thread 1) skip
8597
8598 001-0009-1 (thread 1) skip
8599
8600 001-0010-0 (thread 1) skip
8601
8602 001-0011-1 (thread 1) skip
8603
8604 001-0012-0 (thread 1) skip
8605
8606 001-0013-1 (thread 1) skip
8607
8608 001-0014-0 (thread 1) skip
8609
8610 001-0015-1 (thread 1) skip
8611
8612 001-0016-0 (thread 1) skip
8613
8614 001-0017-1 (thread 1) skip
8615
8616 001-0018-0 (thread 1) skip
8617
8618 001-0019-1 (thread 1) skip
8619
8620 001-0020-0 (thread 1) skip
8621
8622 001-0021-1 (thread 1) skip
8623
8624 001-0022-0 (thread 1) skip
8625
8626 001-0023-1 (thread 1) skip
8627
8628 001-0024-0 (thread 1) skip
8629
8630 001-0025-1 (thread 1) skip
8631
8632 001-0026-0 (thread 1) skip
8633
8634 001-0027-1 (thread 1) skip
8635
8636 001-0028-0 (thread 1) skip
8637
8638 001-0029-1 (thread 1) skip
8639
8640 001-0030-0 (thread 1) skip
8641
8642 001-0031-1 (thread 1) skip
8643
8644 001-0032-0 (thread 1) skip
8645
8646 001-0033-1 (thread 1) skip
8647
8648 001-0034-0 (thread 1) skip
8649
8650 001-0035-1 (thread 1) skip
8651
8652 001-0036-0 (thread 1) skip
8653
8654 001-0037-1 (thread 1) skip
8655
8656 001-0038-0 (thread 1) skip
8657
8658 001-0039-1 (thread 1) skip
8659
8660 001-0040-0 (thread 1) skip
8661
8662 001-0041-1 (thread 1) skip
8663
8664 001-0042-0 (thread 1) skip
8665
8666 001-0043-1 (thread 1) skip
8667
8668 001-0044-0 (thread 1) skip
8669
8670 001-0045-1 (thread 1) skip
8671
8672 001-0046-0 (thread 1) skip
8673
8674 001-0047-1 (thread 1) skip
8675
8676 001-0048-0 (thread 1) skip
8677
8678 001-0049-1 (thread 1) skip
8679
8680 001-0050-0 (thread 1) skip
8681
8682 001-0051-1 (thread 1) skip
8683
8684 001-0052-0 (thread 1) skip
8685
8686 001-0053-1 (thread 1) skip
8687
8688 001-0054-0 (thread 1) skip
8689
8690 001-0055-1 (thread 1) skip
8691
8692 001-0056-0 (thread 1) skip
8693
8694 001-0057-1 (thread 1) skip
8695
8696 001-0058-0 (thread 1) skip
8697
8698 001-0059-1 (thread 1) skip
8699
8700 001-0060-0 (thread 1) skip
8701
8702 001-0061-1 (thread 1) skip
8703
8704 001-0062-0 (thread 1) skip
8705
8706 001-0063-1 (thread 1) skip
8707
8708 001-0064-0 (thread 1) skip
8709
8710 001-0065-1 (thread 1) skip
8711
8712 001-0066-0 (thread 1) skip
8713
8714 001-0067-1 (thread 1) skip
8715
8716 001-0068-0 (thread 1) skip
8717
8718 001-0069-1 (thread 1) skip
8719
8720 001-0070-0 (thread 1) skip
8721
8722 001-0071-1 (thread 1) skip
8723
8724 001-0072-0 (thread 1) skip
8725
8726 001-0073-1 (thread 1) skip
8727
8728 001-0074-0 (thread 1) skip
8729
8730 001-0075-1 (thread 1) skip
8731
8732 001-0076-0 (thread 1) skip
8733
8734 001-0077-1 (thread 1) skip
8735
8736 001-0078-0 (thread 1) skip
8737
8738 001-0079-1 (thread 1) skip
8739
8740 001-0080-0 (thread 1) skip
8741
8742 001-0081-1 (thread 1) skip
8743
8744 001-0082-0 (thread 1) skip
8745
8746 001-0083-1 (thread 1) skip
8747
8748 001-0084-0 (thread 1) skip
8749
8750 001-0085-1 (thread 1) skip
8751
8752 001-0086-0 (thread 1) skip
8753
8754 001-0087-1 (thread 1) skip
8755
8756 001-0088-0 (thread 1) skip
8757
8758 001-0089-1 (thread 1) skip
8759
8760 001-0090-0 (thread 1) skip
8761
8762 001-0091-1 (thread 1) skip
8763
8764 001-0092-0 (thread 1) skip
8765
8766 001-0093-1 (thread 1) skip
8767
8768 001-0094-0 (thread 1) skip
8769
8770 001-0095-1 (thread 1) skip
8771
8772 001-0096-0 (thread 1) skip
8773
8774 001-0097-1 (thread 1) skip
8775
8776 001-0098-0 (thread 1) skip
8777
8778 001-0099-1 (thread 1) skip
8779
8780 001-0100-0 (thread 1) skip
8781
8782 001-0101-1 (thread 1) skip
8783
8784 001-0102-0 (thread 1) skip
8785
8786 001-0103-1 (thread 1) skip
8787
8788 001-0104-0 (thread 1) skip
8789
8790 001-0105-1 (thread 1) skip
8791
8792 001-0106-0 (thread 1) skip
8793
8794 001-0107-1 (thread 1) skip
8795
8796 001-0108-0 (thread 1) skip
8797
8798 001-0109-1 (thread 1) skip
8799
8800 001-0110-0 (thread 1) skip
8801
8802 001-0111-1 (thread 1) skip
8803
8804 001-0112-0 (thread 1) skip
8805
8806 001-0113-1 (thread 1) skip
8807
8808 001-0114-0 (thread 1) skip
8809
8810 001-0115-1 (thread 1) skip
8811
8812 001-0116-0 (thread 1) skip
8813
8814 001-0117-1 (thread 1) skip
8815
8816 001-0118-0 (thread 1) skip
8817
8818 001-0119-1 (thread 1) skip
8819
8820 001-0120-0 (thread 1) skip
8821
8822 001-0121-1 (thread 1) skip
8823
8824 001-0122-0 (thread 1) skip
8825
8826 001-0123-1 (thread 1) skip
8827
8828 001-0124-0 (thread 1) skip
8829
8830 001-0125-1 (thread 1) skip
8831
8832 001-0126-0 (thread 1) skip
8833
8834 001-0127-1 (thread 1) skip
8835
8836 001-0128-0 (thread 1) skip
8837
8838 001-0129-1 (thread 1) skip
8839
8840 001-0130-0 (thread 1) skip
8841
8842 001-0131-1 (thread 1) skip
8843
8844 001-0132-0 (thread 1) skip
8845
8846 001-0133-1 (thread 1) skip
8847
8848 001-0134-0 (thread 1) skip
8849
8850 001-0135-1 (thread 1) skip
8851
8852 001-0136-0 (thread 1) skip
8853
8854 001-0137-1 (thread 1) skip
8855
8856 001-0138-0 (thread 1) skip
8857
8858 001-0139-1 (thread 1) skip
8859
8860 001-0140-0 (thread 1) skip
8861
8862 001-0141-1 (thread 1) skip
8863
8864 001-0142-0 (thread 1) skip
8865
8866 001-0143-1 (thread 1) skip
8867
8868 001-0144-0 (thread 1) skip
8869
8870 001-0145-1 (thread 1) skip
8871
8872 001-0146-0 (thread 1) skip
8873
8874 001-0147-1 (thread 1) skip
8875
8876 001-0148-0 (thread 1) skip
8877
8878 001-0149-1 (thread 1) skip
8879
8880 001-0150-0 (thread 1) skip
8881
8882 001-0151-1 (thread 1) skip
8883
8884 001-0152-0 (thread 1) skip
8885
8886 001-0153-1 (thread 1) skip
8887
8888 001-0154-0 (thread 1) skip
8889
8890 001-0155-1 (thread 1) skip
8891
8892 001-0156-0 (thread 1) skip
8893
8894 001-0157-1 (thread 1) skip
8895
8896 001-0158-0 (thread 1) skip
8897
8898 001-0159-1 (thread 1) skip
8899
8900 001-0160-0 (thread 1) skip
8901
8902 001-0161-1 (thread 1) skip
8903
8904 001-0162-0 (thread 1) skip
8905
8906 001-0163-1 (thread 1) skip
8907
8908 001-0164-0 (thread 1) skip
8909
8910 001-0165-1 (thread 1) skip
8911
8912 001-0166-0 (thread 1) skip
8913
8914 001-0167-1 (thread 1) skip
8915
8916 001-0168-0 (thread 1) skip
8917
8918 001-0169-1 (thread 1) skip
8919
8920 001-0170-0 (thread 1) skip
8921
8922 001-0171-1 (thread 1) skip
8923
8924 001-0172-0 (thread 1) skip
8925
8926 001-0173-1 (thread 1) skip
8927
8928 001-0174-0 (thread 1) skip
8929
8930 001-0175-1 (thread 1) skip
8931
8932 001-0176-0 (thread 1) skip
8933
8934 001-0177-1 (thread 1) skip
8935
8936 001-0178-0 (thread 1) skip
8937
8938 001-0179-1 (thread 1) skip
8939
8940 001-0180-0 (thread 1) skip
8941
8942 001-0181-1 (thread 1) skip
8943
8944 001-0182-0 (thread 1) skip
8945
8946 001-0183-1 (thread 1) skip
8947
8948 001-0184-0 (thread 1) skip
8949
8950 001-0185-1 (thread 1) skip
8951
8952 001-0186-0 (thread 1) skip
8953
8954 001-0187-1 (thread 1) skip
8955
8956 001-0188-0 (thread 1) skip
8957
8958 001-0189-1 (thread 1) skip
8959
8960 001-0190-0 (thread 1) skip
8961
8962 001-0191-1 (thread 1) skip
8963
8964 001-0192-0 (thread 1) skip
8965
8966 001-0193-1 (thread 1) skip
8967
8968 001-0194-0 (thread 1) skip
8969
8970 001-0195-1 (thread 1) skip
8971
8972 001-0196-1 (thread 1) identical
8973 001-0196-1 (thread 1) worse
8974
8975 Converged.
8976
8977 Reached 1
8978 done
8979 dvtditr (nuc) Version 7.407
8980 alg=A, model=DNA200 (2), 1.53 (4.59), -0.00 (-0.00), noshift, amax=0.0
8981 1 thread(s)
8982
8983
8984 Strategy:
8985 FFT-NS-i (Standard)
8986 Iterative refinement method (max. 1 iterations)
8987
8988 If unsure which option to use, try 'mafft --auto input > output'.
8989 For more information, see 'mafft --help', 'mafft --man' and the mafft page.
8990
8991 The default gap scoring scheme has been changed in version 7.110 (2013 Oct).
8992 It tends to insert more gaps into gap-rich regions than previous versions.
8993 To disable this change, add the --leavegappyregion option.
8994