Summary Help
AddBlastBlocks
Add blast hits as blocks
AddBlastBlocks: Add blast hits as blocks
    SequencesFromOther: Copy sequences from other block set
    ConSeq: Blocks to consensus sequences
    FilterSeqs: FilterSeqs
    BlastFinder: BlastFinder
        Output: Output block set
        BlastRunner: Blast runner
        ImportBlastHits: Import blast hits
        FileCopy: Copy file
        FileCopy: Copy file
        FileRemover: Remove file
        FileRemover: Remove file
    DeConSeq: Build blocks from blocks, set to sequences of blocks of other
    Clear: Remove all blocks and/or sequences from blockset
  • other: Input blocks
  • target: Blast hits sliced from input blocks

Blocks to consensus sequences:
  --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                     ('asis', 'compact' or 'compact_low_n')

FilterSeqs:
  --blast-min-length arg (=100) min length of blast hit

Output block set:
  --out-export-alignment arg (=1) use alignment information if available
  --out-export-contents arg (=1)  print contents of fragments
  --out-mask arg                  mask of output files (${block} is replaced 
                                  with block name)

Blast runner:
  --blast-plus arg (=0)                 Use blast+ (otherwise blast)
  --evalue arg (=0.001)                 Max acceptable e-value of hit
  --remove-after arg (=0)               remove file out-hits
  --skip-low-complexity-regions arg (=0)
                                        Tell blast not to search in low 
                                        complexity regions

Copy file:
  --blast-cons-dst arg (=:null) Destination of copy

Copy file:
  --blast-hits-dst arg (=:null) Destination of copy

Remove all blocks and/or sequences from blockset:
  --clear-blocks arg (=1) Remove blocks
  --clear-bsas arg (=1)   Remove block set alignments

AddBlastBlocksToSelf
AddBlastBlocksToSelf: AddBlastBlocksToSelf
    Filter: Filter blocks
    Rest: Add to target blocks of nucleotides, not included to other
    AddBlastBlocks: Add blast hits as blocks
        SequencesFromOther: Copy sequences from other block set
        ConSeq: Blocks to consensus sequences
        FilterSeqs: FilterSeqs
        BlastFinder: BlastFinder
            Output: Output block set
            BlastRunner: Blast runner
            ImportBlastHits: Import blast hits
            FileCopy: Copy file
            FileCopy: Copy file
            FileRemover: Remove file
            FileRemover: Remove file
        DeConSeq: Build blocks from blocks, set to sequences of blocks of other
        Clear: Remove all blocks and/or sequences from blockset
    
    Filter blocks:
      --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
      --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                 other blockset
      --max-block arg (=-1)      Maximum block size (-1 = all)
      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
      --max-gaps arg (=0.2)      Max gap columns percentage
      --max-identity arg (=1)    Maximum block identity
      --max-spreading arg (=0.2) Maximum fragment length spreading
      --min-block arg (=2)       Minimum block size
      --min-fragment arg (=100)  Minimum fragment length
      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                 known)
      --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                 known, columns without gaps as 1, columns with 
                                 gaps as 0.5)
      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                 avg)
    
    Add to target blocks of nucleotides, not included to other:
      --skip-rest arg (=0)  do not add unique fragments to block set
    
    Blocks to consensus sequences:
      --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                         ('asis', 'compact' or 'compact_low_n')
    
    FilterSeqs:
      --blast-min-length arg (=100) min length of blast hit
    
    Output block set:
      --out-export-alignment arg (=1) use alignment information if available
      --out-export-contents arg (=1)  print contents of fragments
      --out-mask arg                  mask of output files (${block} is replaced 
                                      with block name)
    
    Blast runner:
      --blast-plus arg (=0)                 Use blast+ (otherwise blast)
      --evalue arg (=0.001)                 Max acceptable e-value of hit
      --remove-after arg (=0)               remove file out-hits
      --skip-low-complexity-regions arg (=0)
                                            Tell blast not to search in low 
                                            complexity regions
    
    Copy file:
      --blast-cons-dst arg (=:null) Destination of copy
    
    Copy file:
      --blast-hits-dst arg (=:null) Destination of copy
    
    Remove all blocks and/or sequences from blockset:
      --clear-blocks arg (=1) Remove blocks
      --clear-bsas arg (=1)   Remove block set alignments
    
    
    AddGenes
    Add genes from EBI genes description
    
    
    • target: Blockset where genes are added
    
    Add genes from EBI genes description:
      --in-genes arg        input database files with genes
      --product arg (=1)    Append product name to block name
    
    
    AddingLoopBySize
    Align and move overlapless from other to target
    AddingLoopBySize: Align and move overlapless from other to target
        AddingLoop: AddingLoop
            Align: LiteAlign + Filter + SelfOverlapsResolver
                MetaAligner: Align blocks with one of possible aligners
                    ExternalAligner: External aligner
                    MafftAligner: Mafft aligner
                    MuscleAligner: Muscle aligner
                    MultipleAligner: Internal aligner
                    SimilarAligner: Align blocks with high similarity
                    DummyAligner: Align by adding gaps to sequences
                SelfOverlapsResolver: Resolve self-overlaps
                MetaAligner: Align blocks with one of possible aligners
                    ExternalAligner: External aligner
                    MafftAligner: Mafft aligner
                    MuscleAligner: Muscle aligner
                    MultipleAligner: Internal aligner
                    SimilarAligner: Align blocks with high similarity
                    DummyAligner: Align by adding gaps to sequences
                AlignLoop: AlignLoop
                    MoveGaps: Move terminal letters inside
                    CutGaps: Cut terminal gaps
                    Filter: Filter blocks
            SmthUnion: SmthUnion
    
    • other: source blockset
    • target: destination blockset
    
    Align blocks with one of possible aligners:
      --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                    multiple, similar, dummy). Specify several 
                                    types, separated by comma, the first working 
                                    one will be used or the last one if all fail.
      --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                    'compact')
    
    External aligner:
      --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                            Template of command for external 
                                            aligner
    
    Mafft aligner:
      --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                            Template of command for external 
                                            aligner
      --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                            ('map' or 'compact')
    
    Muscle aligner:
      --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                            Template of command for external 
                                            aligner
      --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                            ('map' or 'compact')
    
    Internal aligner:
      --batch arg (=100)          batch size for pair aligner
      --gap-penalty arg (=2)      Gap open or extension penalty
      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                  states of pair alignment. The more gap_range, the
                                  more time.
      --max-errors arg (=11)      Max number of errors in pair alignment
      --mismatch-penalty arg (=1) Mismatch penalty
    
    Align blocks with high similarity:
      --aligned-check arg (=10) Min equal aligned part
      --gap-check arg (=2)      Min number of equal columns after single gap
      --min-identity arg (=0.9) Min identity of block
      --min-length arg (=100)   Min length of fragment
      --mismatch-check arg (=1) Min number of equal columns after single mismatch
    
    Move terminal letters inside:
      --max-tail arg (=3)        Max length of tail
      --max-tail-to-gap arg (=1) Max tail length to gap length ratio
    
    Cut terminal gaps:
      --cut-strict arg (=0) cut more gaps
    
    Filter blocks:
      --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
      --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                 other blockset
      --max-block arg (=-1)      Maximum block size (-1 = all)
      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
      --max-gaps arg (=0.2)      Max gap columns percentage
      --max-identity arg (=1)    Maximum block identity
      --max-spreading arg (=0.2) Maximum fragment length spreading
      --min-block arg (=2)       Minimum block size
      --min-fragment arg (=100)  Minimum fragment length
      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                 known)
      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                 avg)
    
    
    Align
    LiteAlign + Filter + SelfOverlapsResolver
    Align: LiteAlign + Filter + SelfOverlapsResolver
        MetaAligner: Align blocks with one of possible aligners
            ExternalAligner: External aligner
            MafftAligner: Mafft aligner
            MuscleAligner: Muscle aligner
            MultipleAligner: Internal aligner
            SimilarAligner: Align blocks with high similarity
            DummyAligner: Align by adding gaps to sequences
        SelfOverlapsResolver: Resolve self-overlaps
        MetaAligner: Align blocks with one of possible aligners
            ExternalAligner: External aligner
            MafftAligner: Mafft aligner
            MuscleAligner: Muscle aligner
            MultipleAligner: Internal aligner
            SimilarAligner: Align blocks with high similarity
            DummyAligner: Align by adding gaps to sequences
        AlignLoop: AlignLoop
            MoveGaps: Move terminal letters inside
            CutGaps: Cut terminal gaps
            Filter: Filter blocks
    
    • target: Aligned blockset
    
    Align blocks with one of possible aligners:
      --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                    multiple, similar, dummy). Specify several 
                                    types, separated by comma, the first working 
                                    one will be used or the last one if all fail.
      --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                    'compact')
    
    External aligner:
      --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                            Template of command for external 
                                            aligner
    
    Mafft aligner:
      --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                            Template of command for external 
                                            aligner
      --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                            ('map' or 'compact')
    
    Muscle aligner:
      --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                            Template of command for external 
                                            aligner
      --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                            ('map' or 'compact')
    
    Internal aligner:
      --batch arg (=100)          batch size for pair aligner
      --gap-penalty arg (=2)      Gap open or extension penalty
      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                  states of pair alignment. The more gap_range, the
                                  more time.
      --max-errors arg (=11)      Max number of errors in pair alignment
      --mismatch-penalty arg (=1) Mismatch penalty
    
    Align blocks with high similarity:
      --aligned-check arg (=10) Min equal aligned part
      --gap-check arg (=2)      Min number of equal columns after single gap
      --min-identity arg (=0.9) Min identity of block
      --min-length arg (=100)   Min length of fragment
      --mismatch-check arg (=1) Min number of equal columns after single mismatch
    
    Move terminal letters inside:
      --max-tail arg (=3)        Max length of tail
      --max-tail-to-gap arg (=1) Max tail length to gap length ratio
    
    Cut terminal gaps:
      --cut-strict arg (=0) cut more gaps
    
    Filter blocks:
      --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
      --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                 other blockset
      --max-block arg (=-1)      Maximum block size (-1 = all)
      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
      --max-gaps arg (=0.2)      Max gap columns percentage
      --max-identity arg (=1)    Maximum block identity
      --max-spreading arg (=0.2) Maximum fragment length spreading
      --min-block arg (=2)       Minimum block size
      --min-fragment arg (=100)  Minimum fragment length
      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                 known)
      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                 avg)
    
    
    AllOptions
    Print HTML help about all global options
    
    
      
      Print HTML help about all global options:
        --out arg (=:cout)      Output file
        --remove-after arg (=0) remove file out
      
      
      AllProcessors
      Print HTML help about all processors
      
      
        
        Print HTML help about all processors:
          --out arg (=:cout)      Output file
          --remove-after arg (=0) remove file out
        
        
        AnchorBlastJoiner
        AnchorBlastJoiner: AnchorBlastJoiner
            Hash: Print hash of blockset
            TrySmth: Try to do something, align (and filter), restore original if worse
                Union: Add clones of blocks from other to this block set
                UniqueNames: Set unique names to all blocks of this block set
                MetaProcessor: Any processor
                RemoveNames: Remove all blocks and/or sequences names
                Align: LiteAlign + Filter + SelfOverlapsResolver
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    SelfOverlapsResolver: Resolve self-overlaps
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    AlignLoop: AlignLoop
                        MoveGaps: Move terminal letters inside
                        CutGaps: Cut terminal gaps
                        Filter: Filter blocks
                Move: Move all blocks from other blockset to target blockset
                AddingLoopBySize: Align and move overlapless from other to target
                    AddingLoop: AddingLoop
                        Align: LiteAlign + Filter + SelfOverlapsResolver
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            SelfOverlapsResolver: Resolve self-overlaps
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            AlignLoop: AlignLoop
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                        SmthUnion: SmthUnion
                UniqueNames: Set unique names to all blocks of this block set
                ReAlign: Realign blocks
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    Filter: Filter blocks
                Clear: Remove all blocks and/or sequences from blockset
            Hash: Print hash of blockset
            TrySmth: Try to do something, align (and filter), restore original if worse
                Union: Add clones of blocks from other to this block set
                UniqueNames: Set unique names to all blocks of this block set
                MetaProcessor: Any processor
                RemoveNames: Remove all blocks and/or sequences names
                Align: LiteAlign + Filter + SelfOverlapsResolver
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    SelfOverlapsResolver: Resolve self-overlaps
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    AlignLoop: AlignLoop
                        MoveGaps: Move terminal letters inside
                        CutGaps: Cut terminal gaps
                        Filter: Filter blocks
                Move: Move all blocks from other blockset to target blockset
                AddingLoopBySize: Align and move overlapless from other to target
                    AddingLoop: AddingLoop
                        Align: LiteAlign + Filter + SelfOverlapsResolver
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            SelfOverlapsResolver: Resolve self-overlaps
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            AlignLoop: AlignLoop
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                        SmthUnion: SmthUnion
                UniqueNames: Set unique names to all blocks of this block set
                ReAlign: Realign blocks
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    Filter: Filter blocks
                Clear: Remove all blocks and/or sequences from blockset
            Hash: Print hash of blockset
            TrySmth: Try to do something, align (and filter), restore original if worse
                Union: Add clones of blocks from other to this block set
                UniqueNames: Set unique names to all blocks of this block set
                MetaProcessor: Any processor
                RemoveNames: Remove all blocks and/or sequences names
                Align: LiteAlign + Filter + SelfOverlapsResolver
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    SelfOverlapsResolver: Resolve self-overlaps
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    AlignLoop: AlignLoop
                        MoveGaps: Move terminal letters inside
                        CutGaps: Cut terminal gaps
                        Filter: Filter blocks
                Move: Move all blocks from other blockset to target blockset
                AddingLoopBySize: Align and move overlapless from other to target
                    AddingLoop: AddingLoop
                        Align: LiteAlign + Filter + SelfOverlapsResolver
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            SelfOverlapsResolver: Resolve self-overlaps
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            AlignLoop: AlignLoop
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                        SmthUnion: SmthUnion
                UniqueNames: Set unique names to all blocks of this block set
                ReAlign: Realign blocks
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    Filter: Filter blocks
                Clear: Remove all blocks and/or sequences from blockset
            Hash: Print hash of blockset
            TrySmth: Try to do something, align (and filter), restore original if worse
                Union: Add clones of blocks from other to this block set
                UniqueNames: Set unique names to all blocks of this block set
                MetaProcessor: Any processor
                RemoveNames: Remove all blocks and/or sequences names
                Align: LiteAlign + Filter + SelfOverlapsResolver
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    SelfOverlapsResolver: Resolve self-overlaps
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    AlignLoop: AlignLoop
                        MoveGaps: Move terminal letters inside
                        CutGaps: Cut terminal gaps
                        Filter: Filter blocks
                Move: Move all blocks from other blockset to target blockset
                AddingLoopBySize: Align and move overlapless from other to target
                    AddingLoop: AddingLoop
                        Align: LiteAlign + Filter + SelfOverlapsResolver
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            SelfOverlapsResolver: Resolve self-overlaps
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            AlignLoop: AlignLoop
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                        SmthUnion: SmthUnion
                UniqueNames: Set unique names to all blocks of this block set
                ReAlign: Realign blocks
                    MetaAligner: Align blocks with one of possible aligners
                        ExternalAligner: External aligner
                        MafftAligner: Mafft aligner
                        MuscleAligner: Muscle aligner
                        MultipleAligner: Internal aligner
                        SimilarAligner: Align blocks with high similarity
                        DummyAligner: Align by adding gaps to sequences
                    Filter: Filter blocks
                Clear: Remove all blocks and/or sequences from blockset
            Hash: Print hash of blockset
            Info: Print human readable summary and statistics
                Stats: Print human readable summary and statistics about block set
        
          
          Print hash of blockset:
            --hash-file arg         Output file with blockset hash
            --remove-after arg (=0) remove file hash-file
          
          Any processor:
            --smth-opts arg         options for processor
          
          Align blocks with one of possible aligners:
            --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                          multiple, similar, dummy). Specify several 
                                          types, separated by comma, the first working 
                                          one will be used or the last one if all fail.
            --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                          'compact')
          
          External aligner:
            --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                  Template of command for external 
                                                  aligner
          
          Mafft aligner:
            --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                  Template of command for external 
                                                  aligner
            --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                  ('map' or 'compact')
          
          Muscle aligner:
            --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                  Template of command for external 
                                                  aligner
            --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                  ('map' or 'compact')
          
          Internal aligner:
            --batch arg (=100)          batch size for pair aligner
            --gap-penalty arg (=2)      Gap open or extension penalty
            --gap-range arg (=15)       Max distance from main diagonal of considered 
                                        states of pair alignment. The more gap_range, the
                                        more time.
            --max-errors arg (=11)      Max number of errors in pair alignment
            --mismatch-penalty arg (=1) Mismatch penalty
          
          Align blocks with high similarity:
            --aligned-check arg (=10) Min equal aligned part
            --gap-check arg (=2)      Min number of equal columns after single gap
            --min-identity arg (=0.9) Min identity of block
            --min-length arg (=100)   Min length of fragment
            --mismatch-check arg (=1) Min number of equal columns after single mismatch
          
          Move terminal letters inside:
            --max-tail arg (=3)        Max length of tail
            --max-tail-to-gap arg (=1) Max tail length to gap length ratio
          
          Cut terminal gaps:
            --cut-strict arg (=0) cut more gaps
          
          Filter blocks:
            --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
            --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                       other blockset
            --max-block arg (=-1)      Maximum block size (-1 = all)
            --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
            --max-gaps arg (=0.2)      Max gap columns percentage
            --max-identity arg (=1)    Maximum block identity
            --max-spreading arg (=0.2) Maximum fragment length spreading
            --min-block arg (=2)       Minimum block size
            --min-fragment arg (=100)  Minimum fragment length
            --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                       known)
            --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                       avg)
          
          Realign blocks:
            --force-realign arg (=0) If realigned block is worse, realign anyway
          
          Print human readable summary and statistics about block set:
            --out-stats arg       Output file with statistics
          
          
          AnchorFinder
          Find anchors
          
          
          • target: Blockset to search anchors in
          
          Find anchors:
            --anchor-fp arg (=0.1)               Probability of false positive in Bloom 
                                                 filter (first step of AnchorFinder)
            --anchor-similar arg (=1)            If neighbour anchors are skipped
            --anchor-size arg (=20)              anchor size
            --max-anchor-fragments arg (=100000) Maximum number of anchors fragments to 
                                                 return
          
          
          AnchorJoiner
          AnchorJoiner: AnchorJoiner
              Hash: Print hash of blockset
              TrySmth: Try to do something, align (and filter), restore original if worse
                  Union: Add clones of blocks from other to this block set
                  UniqueNames: Set unique names to all blocks of this block set
                  MetaProcessor: Any processor
                  RemoveNames: Remove all blocks and/or sequences names
                  Align: LiteAlign + Filter + SelfOverlapsResolver
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      SelfOverlapsResolver: Resolve self-overlaps
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      AlignLoop: AlignLoop
                          MoveGaps: Move terminal letters inside
                          CutGaps: Cut terminal gaps
                          Filter: Filter blocks
                  Move: Move all blocks from other blockset to target blockset
                  AddingLoopBySize: Align and move overlapless from other to target
                      AddingLoop: AddingLoop
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                          SmthUnion: SmthUnion
                  UniqueNames: Set unique names to all blocks of this block set
                  ReAlign: Realign blocks
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      Filter: Filter blocks
                  Clear: Remove all blocks and/or sequences from blockset
              Hash: Print hash of blockset
              TrySmth: Try to do something, align (and filter), restore original if worse
                  Union: Add clones of blocks from other to this block set
                  UniqueNames: Set unique names to all blocks of this block set
                  MetaProcessor: Any processor
                  RemoveNames: Remove all blocks and/or sequences names
                  Align: LiteAlign + Filter + SelfOverlapsResolver
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      SelfOverlapsResolver: Resolve self-overlaps
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      AlignLoop: AlignLoop
                          MoveGaps: Move terminal letters inside
                          CutGaps: Cut terminal gaps
                          Filter: Filter blocks
                  Move: Move all blocks from other blockset to target blockset
                  AddingLoopBySize: Align and move overlapless from other to target
                      AddingLoop: AddingLoop
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                          SmthUnion: SmthUnion
                  UniqueNames: Set unique names to all blocks of this block set
                  ReAlign: Realign blocks
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      Filter: Filter blocks
                  Clear: Remove all blocks and/or sequences from blockset
              Hash: Print hash of blockset
              TrySmth: Try to do something, align (and filter), restore original if worse
                  Union: Add clones of blocks from other to this block set
                  UniqueNames: Set unique names to all blocks of this block set
                  MetaProcessor: Any processor
                  RemoveNames: Remove all blocks and/or sequences names
                  Align: LiteAlign + Filter + SelfOverlapsResolver
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      SelfOverlapsResolver: Resolve self-overlaps
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      AlignLoop: AlignLoop
                          MoveGaps: Move terminal letters inside
                          CutGaps: Cut terminal gaps
                          Filter: Filter blocks
                  Move: Move all blocks from other blockset to target blockset
                  AddingLoopBySize: Align and move overlapless from other to target
                      AddingLoop: AddingLoop
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                          SmthUnion: SmthUnion
                  UniqueNames: Set unique names to all blocks of this block set
                  ReAlign: Realign blocks
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      Filter: Filter blocks
                  Clear: Remove all blocks and/or sequences from blockset
              Hash: Print hash of blockset
              Info: Print human readable summary and statistics
                  Stats: Print human readable summary and statistics about block set
          
            
            Print hash of blockset:
              --hash-file arg         Output file with blockset hash
              --remove-after arg (=0) remove file hash-file
            
            Any processor:
              --smth-opts arg         options for processor
            
            Align blocks with one of possible aligners:
              --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                            multiple, similar, dummy). Specify several 
                                            types, separated by comma, the first working 
                                            one will be used or the last one if all fail.
              --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                            'compact')
            
            External aligner:
              --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                    Template of command for external 
                                                    aligner
            
            Mafft aligner:
              --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                    Template of command for external 
                                                    aligner
              --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                    ('map' or 'compact')
            
            Muscle aligner:
              --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                    Template of command for external 
                                                    aligner
              --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                    ('map' or 'compact')
            
            Internal aligner:
              --batch arg (=100)          batch size for pair aligner
              --gap-penalty arg (=2)      Gap open or extension penalty
              --gap-range arg (=15)       Max distance from main diagonal of considered 
                                          states of pair alignment. The more gap_range, the
                                          more time.
              --max-errors arg (=11)      Max number of errors in pair alignment
              --mismatch-penalty arg (=1) Mismatch penalty
            
            Align blocks with high similarity:
              --aligned-check arg (=10) Min equal aligned part
              --gap-check arg (=2)      Min number of equal columns after single gap
              --min-identity arg (=0.9) Min identity of block
              --min-length arg (=100)   Min length of fragment
              --mismatch-check arg (=1) Min number of equal columns after single mismatch
            
            Move terminal letters inside:
              --max-tail arg (=3)        Max length of tail
              --max-tail-to-gap arg (=1) Max tail length to gap length ratio
            
            Cut terminal gaps:
              --cut-strict arg (=0) cut more gaps
            
            Filter blocks:
              --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
              --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                         other blockset
              --max-block arg (=-1)      Maximum block size (-1 = all)
              --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
              --max-gaps arg (=0.2)      Max gap columns percentage
              --max-identity arg (=1)    Maximum block identity
              --max-spreading arg (=0.2) Maximum fragment length spreading
              --min-block arg (=2)       Minimum block size
              --min-fragment arg (=100)  Minimum fragment length
              --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                         known)
              --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                         avg)
            
            Realign blocks:
              --force-realign arg (=0) If realigned block is worse, realign anyway
            
            Print human readable summary and statistics about block set:
              --out-stats arg       Output file with statistics
            
            
            AnchorJoinerFast
            AnchorJoinerFast: AnchorJoinerFast
                Hash: Print hash of blockset
                TrySmth: Try to do something, align (and filter), restore original if worse
                    Union: Add clones of blocks from other to this block set
                    UniqueNames: Set unique names to all blocks of this block set
                    MetaProcessor: Any processor
                    RemoveNames: Remove all blocks and/or sequences names
                    Align: LiteAlign + Filter + SelfOverlapsResolver
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        SelfOverlapsResolver: Resolve self-overlaps
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        AlignLoop: AlignLoop
                            MoveGaps: Move terminal letters inside
                            CutGaps: Cut terminal gaps
                            Filter: Filter blocks
                    Move: Move all blocks from other blockset to target blockset
                    AddingLoopBySize: Align and move overlapless from other to target
                        AddingLoop: AddingLoop
                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                SelfOverlapsResolver: Resolve self-overlaps
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                AlignLoop: AlignLoop
                                    MoveGaps: Move terminal letters inside
                                    CutGaps: Cut terminal gaps
                                    Filter: Filter blocks
                            SmthUnion: SmthUnion
                    UniqueNames: Set unique names to all blocks of this block set
                    ReAlign: Realign blocks
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        Filter: Filter blocks
                    Clear: Remove all blocks and/or sequences from blockset
                Hash: Print hash of blockset
                TrySmth: Try to do something, align (and filter), restore original if worse
                    Union: Add clones of blocks from other to this block set
                    UniqueNames: Set unique names to all blocks of this block set
                    MetaProcessor: Any processor
                    RemoveNames: Remove all blocks and/or sequences names
                    Align: LiteAlign + Filter + SelfOverlapsResolver
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        SelfOverlapsResolver: Resolve self-overlaps
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        AlignLoop: AlignLoop
                            MoveGaps: Move terminal letters inside
                            CutGaps: Cut terminal gaps
                            Filter: Filter blocks
                    Move: Move all blocks from other blockset to target blockset
                    AddingLoopBySize: Align and move overlapless from other to target
                        AddingLoop: AddingLoop
                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                SelfOverlapsResolver: Resolve self-overlaps
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                AlignLoop: AlignLoop
                                    MoveGaps: Move terminal letters inside
                                    CutGaps: Cut terminal gaps
                                    Filter: Filter blocks
                            SmthUnion: SmthUnion
                    UniqueNames: Set unique names to all blocks of this block set
                    ReAlign: Realign blocks
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        Filter: Filter blocks
                    Clear: Remove all blocks and/or sequences from blockset
                Hash: Print hash of blockset
                TrySmth: Try to do something, align (and filter), restore original if worse
                    Union: Add clones of blocks from other to this block set
                    UniqueNames: Set unique names to all blocks of this block set
                    MetaProcessor: Any processor
                    RemoveNames: Remove all blocks and/or sequences names
                    Align: LiteAlign + Filter + SelfOverlapsResolver
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        SelfOverlapsResolver: Resolve self-overlaps
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        AlignLoop: AlignLoop
                            MoveGaps: Move terminal letters inside
                            CutGaps: Cut terminal gaps
                            Filter: Filter blocks
                    Move: Move all blocks from other blockset to target blockset
                    AddingLoopBySize: Align and move overlapless from other to target
                        AddingLoop: AddingLoop
                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                SelfOverlapsResolver: Resolve self-overlaps
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                AlignLoop: AlignLoop
                                    MoveGaps: Move terminal letters inside
                                    CutGaps: Cut terminal gaps
                                    Filter: Filter blocks
                            SmthUnion: SmthUnion
                    UniqueNames: Set unique names to all blocks of this block set
                    ReAlign: Realign blocks
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        Filter: Filter blocks
                    Clear: Remove all blocks and/or sequences from blockset
                Hash: Print hash of blockset
                Info: Print human readable summary and statistics
                    Stats: Print human readable summary and statistics about block set
            
              
              Print hash of blockset:
                --hash-file arg         Output file with blockset hash
                --remove-after arg (=0) remove file hash-file
              
              Any processor:
                --smth-opts arg         options for processor
              
              Align blocks with one of possible aligners:
                --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                              multiple, similar, dummy). Specify several 
                                              types, separated by comma, the first working 
                                              one will be used or the last one if all fail.
                --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                              'compact')
              
              External aligner:
                --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                      Template of command for external 
                                                      aligner
              
              Mafft aligner:
                --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                      Template of command for external 
                                                      aligner
                --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                      ('map' or 'compact')
              
              Muscle aligner:
                --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                      Template of command for external 
                                                      aligner
                --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                      ('map' or 'compact')
              
              Internal aligner:
                --batch arg (=100)          batch size for pair aligner
                --gap-penalty arg (=2)      Gap open or extension penalty
                --gap-range arg (=15)       Max distance from main diagonal of considered 
                                            states of pair alignment. The more gap_range, the
                                            more time.
                --max-errors arg (=11)      Max number of errors in pair alignment
                --mismatch-penalty arg (=1) Mismatch penalty
              
              Align blocks with high similarity:
                --aligned-check arg (=10) Min equal aligned part
                --gap-check arg (=2)      Min number of equal columns after single gap
                --min-identity arg (=0.9) Min identity of block
                --min-length arg (=100)   Min length of fragment
                --mismatch-check arg (=1) Min number of equal columns after single mismatch
              
              Move terminal letters inside:
                --max-tail arg (=3)        Max length of tail
                --max-tail-to-gap arg (=1) Max tail length to gap length ratio
              
              Cut terminal gaps:
                --cut-strict arg (=0) cut more gaps
              
              Filter blocks:
                --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                           other blockset
                --max-block arg (=-1)      Maximum block size (-1 = all)
                --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                --max-gaps arg (=0.2)      Max gap columns percentage
                --max-identity arg (=1)    Maximum block identity
                --max-spreading arg (=0.2) Maximum fragment length spreading
                --min-block arg (=2)       Minimum block size
                --min-fragment arg (=100)  Minimum fragment length
                --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                           known)
                --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                           avg)
              
              Realign blocks:
                --force-realign arg (=0) If realigned block is worse, realign anyway
              
              Print human readable summary and statistics about block set:
                --out-stats arg       Output file with statistics
              
              
              AnchorLoop
              AnchorLoop: AnchorLoop
                  Filter: Filter blocks
                  Rest: Add to target blocks of nucleotides, not included to other
                  ConSeq: Blocks to consensus sequences
                  AnchorFinder: Find anchors
                  MoveUnchanged: Move unchanged blocks from other to target
                  Clear: Remove all blocks and/or sequences from blockset
                  DummyAligner: Align by adding gaps to sequences
                  UniqueNames: Set unique names to all blocks of this block set
                  Union: Add clones of blocks from other to this block set
                  ExtendAndAlign: ExtendAndAlign
                      FragmentsExtender: Move block's boundaries and align only new parts
                          MetaAligner: Align blocks with one of possible aligners
                              ExternalAligner: External aligner
                              MafftAligner: Mafft aligner
                              MuscleAligner: Muscle aligner
                              MultipleAligner: Internal aligner
                              SimilarAligner: Align blocks with high similarity
                              DummyAligner: Align by adding gaps to sequences
                      Align: LiteAlign + Filter + SelfOverlapsResolver
                          MetaAligner: Align blocks with one of possible aligners
                              ExternalAligner: External aligner
                              MafftAligner: Mafft aligner
                              MuscleAligner: Muscle aligner
                              MultipleAligner: Internal aligner
                              SimilarAligner: Align blocks with high similarity
                              DummyAligner: Align by adding gaps to sequences
                          SelfOverlapsResolver: Resolve self-overlaps
                          MetaAligner: Align blocks with one of possible aligners
                              ExternalAligner: External aligner
                              MafftAligner: Mafft aligner
                              MuscleAligner: Muscle aligner
                              MultipleAligner: Internal aligner
                              SimilarAligner: Align blocks with high similarity
                              DummyAligner: Align by adding gaps to sequences
                          AlignLoop: AlignLoop
                              MoveGaps: Move terminal letters inside
                              CutGaps: Cut terminal gaps
                              Filter: Filter blocks
                  RemoveWithSameName: Remove from target blocks with names from other
                  SplitExtendable: Find extendable subblocks
                      Filter: Filter blocks
                      FragmentsExtender: Move block's boundaries and align only new parts
                          MetaAligner: Align blocks with one of possible aligners
                              ExternalAligner: External aligner
                              MafftAligner: Mafft aligner
                              MuscleAligner: Muscle aligner
                              MultipleAligner: Internal aligner
                              SimilarAligner: Align blocks with high similarity
                              DummyAligner: Align by adding gaps to sequences
                  RemoveNames: Remove all blocks and/or sequences names
                  DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                  ExtendLoop: ExtendLoop
                      MoveUnchanged: Move unchanged blocks from other to target
                      ExtendAndAlign: ExtendAndAlign
                          FragmentsExtender: Move block's boundaries and align only new parts
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                      Move: Move all blocks from other blockset to target blockset
                      AddingLoopBySize: Align and move overlapless from other to target
                          AddingLoop: AddingLoop
                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                  MetaAligner: Align blocks with one of possible aligners
                                      ExternalAligner: External aligner
                                      MafftAligner: Mafft aligner
                                      MuscleAligner: Muscle aligner
                                      MultipleAligner: Internal aligner
                                      SimilarAligner: Align blocks with high similarity
                                      DummyAligner: Align by adding gaps to sequences
                                  SelfOverlapsResolver: Resolve self-overlaps
                                  MetaAligner: Align blocks with one of possible aligners
                                      ExternalAligner: External aligner
                                      MafftAligner: Mafft aligner
                                      MuscleAligner: Muscle aligner
                                      MultipleAligner: Internal aligner
                                      SimilarAligner: Align blocks with high similarity
                                      DummyAligner: Align by adding gaps to sequences
                                  AlignLoop: AlignLoop
                                      MoveGaps: Move terminal letters inside
                                      CutGaps: Cut terminal gaps
                                      Filter: Filter blocks
                              SmthUnion: SmthUnion
                      Clear: Remove all blocks and/or sequences from blockset
                      Move: Move all blocks from other blockset to target blockset
                      Clear: Remove all blocks and/or sequences from blockset
                  ExtendLoop: ExtendLoop
                      MoveUnchanged: Move unchanged blocks from other to target
                      ExtendAndAlign: ExtendAndAlign
                          FragmentsExtender: Move block's boundaries and align only new parts
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                      Move: Move all blocks from other blockset to target blockset
                      AddingLoopBySize: Align and move overlapless from other to target
                          AddingLoop: AddingLoop
                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                  MetaAligner: Align blocks with one of possible aligners
                                      ExternalAligner: External aligner
                                      MafftAligner: Mafft aligner
                                      MuscleAligner: Muscle aligner
                                      MultipleAligner: Internal aligner
                                      SimilarAligner: Align blocks with high similarity
                                      DummyAligner: Align by adding gaps to sequences
                                  SelfOverlapsResolver: Resolve self-overlaps
                                  MetaAligner: Align blocks with one of possible aligners
                                      ExternalAligner: External aligner
                                      MafftAligner: Mafft aligner
                                      MuscleAligner: Muscle aligner
                                      MultipleAligner: Internal aligner
                                      SimilarAligner: Align blocks with high similarity
                                      DummyAligner: Align by adding gaps to sequences
                                  AlignLoop: AlignLoop
                                      MoveGaps: Move terminal letters inside
                                      CutGaps: Cut terminal gaps
                                      Filter: Filter blocks
                              SmthUnion: SmthUnion
                      Clear: Remove all blocks and/or sequences from blockset
                      Move: Move all blocks from other blockset to target blockset
                      Clear: Remove all blocks and/or sequences from blockset
                  DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                  Align: LiteAlign + Filter + SelfOverlapsResolver
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      SelfOverlapsResolver: Resolve self-overlaps
                      MetaAligner: Align blocks with one of possible aligners
                          ExternalAligner: External aligner
                          MafftAligner: Mafft aligner
                          MuscleAligner: Muscle aligner
                          MultipleAligner: Internal aligner
                          SimilarAligner: Align blocks with high similarity
                          DummyAligner: Align by adding gaps to sequences
                      AlignLoop: AlignLoop
                          MoveGaps: Move terminal letters inside
                          CutGaps: Cut terminal gaps
                          Filter: Filter blocks
                  Move: Move all blocks from other blockset to target blockset
                  Clear: Remove all blocks and/or sequences from blockset
                  Clear: Remove all blocks and/or sequences from blockset
                  Clear: Remove all blocks and/or sequences from blockset
              
                
                Filter blocks:
                  --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                  --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                             other blockset
                  --max-block arg (=-1)      Maximum block size (-1 = all)
                  --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                  --max-gaps arg (=0.2)      Max gap columns percentage
                  --max-identity arg (=1)    Maximum block identity
                  --max-spreading arg (=0.2) Maximum fragment length spreading
                  --min-block arg (=2)       Minimum block size
                  --min-fragment arg (=100)  Minimum fragment length
                  --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                             known)
                  --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                             known, columns without gaps as 1, columns with 
                                             gaps as 0.5)
                  --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                             avg)
                
                Add to target blocks of nucleotides, not included to other:
                  --skip-rest arg (=0)  do not add unique fragments to block set
                
                Blocks to consensus sequences:
                  --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                     ('asis', 'compact' or 'compact_low_n')
                
                Find anchors:
                  --anchor-fp arg (=0.1)               Probability of false positive in Bloom 
                                                       filter (first step of AnchorFinder)
                  --anchor-similar arg (=1)            If neighbour anchors are skipped
                  --anchor-size arg (=20)              anchor size
                  --max-anchor-fragments arg (=100000) Maximum number of anchors fragments to 
                                                       return
                
                Remove all blocks and/or sequences from blockset:
                  --clear-blocks arg (=1) Remove blocks
                  --clear-bsas arg (=1)   Remove block set alignments
                  --clear-seqs arg (=0)   Remove sequences (warning: this makes dangling 
                                          pointers from orphaned blocks, if they remain)
                
                Align by adding gaps to sequences:
                  --row-type arg (=compact) way of storing alignments in memory ('map' or 
                                            'compact')
                
                Move block's boundaries and align only new parts:
                  --extend-length arg (=100) Length of extended part
                
                Align blocks with one of possible aligners:
                  --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                multiple, similar, dummy). Specify several 
                                                types, separated by comma, the first working 
                                                one will be used or the last one if all fail.
                
                External aligner:
                  --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                        Template of command for external 
                                                        aligner
                
                Mafft aligner:
                  --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                        Template of command for external 
                                                        aligner
                  --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                        ('map' or 'compact')
                
                Muscle aligner:
                  --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                        Template of command for external 
                                                        aligner
                  --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                        ('map' or 'compact')
                
                Internal aligner:
                  --batch arg (=100)          batch size for pair aligner
                  --gap-penalty arg (=2)      Gap open or extension penalty
                  --gap-range arg (=15)       Max distance from main diagonal of considered 
                                              states of pair alignment. The more gap_range, the
                                              more time.
                  --max-errors arg (=11)      Max number of errors in pair alignment
                  --mismatch-penalty arg (=1) Mismatch penalty
                
                Align blocks with high similarity:
                  --aligned-check arg (=10) Min equal aligned part
                  --gap-check arg (=2)      Min number of equal columns after single gap
                  --min-length arg (=100)   Min length of fragment
                  --mismatch-check arg (=1) Min number of equal columns after single mismatch
                
                Move terminal letters inside:
                  --max-tail arg (=3)        Max length of tail
                  --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                
                Cut terminal gaps:
                  --cut-strict arg (=0) cut more gaps
                
                Move block's boundaries and align only new parts:
                  --extend-length-portion arg (=0) Length of extended part portion in source
                
                
                AnchorLoopFast
                AnchorLoopFast: AnchorLoopFast
                    Filter: Filter blocks
                    Rest: Add to target blocks of nucleotides, not included to other
                    ConSeq: Blocks to consensus sequences
                    AnchorFinder: Find anchors
                    MoveUnchanged: Move unchanged blocks from other to target
                    Clear: Remove all blocks and/or sequences from blockset
                    DummyAligner: Align by adding gaps to sequences
                    ExtendAndAlign: ExtendAndAlign
                        FragmentsExtender: Move block's boundaries and align only new parts
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                        Align: LiteAlign + Filter + SelfOverlapsResolver
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            SelfOverlapsResolver: Resolve self-overlaps
                            MetaAligner: Align blocks with one of possible aligners
                                ExternalAligner: External aligner
                                MafftAligner: Mafft aligner
                                MuscleAligner: Muscle aligner
                                MultipleAligner: Internal aligner
                                SimilarAligner: Align blocks with high similarity
                                DummyAligner: Align by adding gaps to sequences
                            AlignLoop: AlignLoop
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                    ExtendLoopFast: ExtendLoopFast
                        MoveUnchanged: Move unchanged blocks from other to target
                        ExtendAndFix: ExtendAndFix
                            FragmentsExtender: Move block's boundaries and align only new parts
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                            FixEnds: Cut bad aligned ends
                        Move: Move all blocks from other blockset to target blockset
                        OverlaplessUnion: Add clones of blocks from other, non-overlapping target
                        Clear: Remove all blocks and/or sequences from blockset
                        Move: Move all blocks from other blockset to target blockset
                        Clear: Remove all blocks and/or sequences from blockset
                    DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                    Align: LiteAlign + Filter + SelfOverlapsResolver
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        SelfOverlapsResolver: Resolve self-overlaps
                        MetaAligner: Align blocks with one of possible aligners
                            ExternalAligner: External aligner
                            MafftAligner: Mafft aligner
                            MuscleAligner: Muscle aligner
                            MultipleAligner: Internal aligner
                            SimilarAligner: Align blocks with high similarity
                            DummyAligner: Align by adding gaps to sequences
                        AlignLoop: AlignLoop
                            MoveGaps: Move terminal letters inside
                            CutGaps: Cut terminal gaps
                            Filter: Filter blocks
                    Clear: Remove all blocks and/or sequences from blockset
                
                  
                  Filter blocks:
                    --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                    --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                               other blockset
                    --max-block arg (=-1)      Maximum block size (-1 = all)
                    --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                    --max-gaps arg (=0.2)      Max gap columns percentage
                    --max-identity arg (=1)    Maximum block identity
                    --max-spreading arg (=0.2) Maximum fragment length spreading
                    --min-block arg (=2)       Minimum block size
                    --min-fragment arg (=100)  Minimum fragment length
                    --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                               known)
                    --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                               known, columns without gaps as 1, columns with 
                                               gaps as 0.5)
                    --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                               avg)
                  
                  Add to target blocks of nucleotides, not included to other:
                    --skip-rest arg (=0)  do not add unique fragments to block set
                  
                  Blocks to consensus sequences:
                    --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                       ('asis', 'compact' or 'compact_low_n')
                  
                  Find anchors:
                    --anchor-fp arg (=0.1)               Probability of false positive in Bloom 
                                                         filter (first step of AnchorFinder)
                    --anchor-similar arg (=1)            If neighbour anchors are skipped
                    --anchor-size arg (=20)              anchor size
                    --max-anchor-fragments arg (=100000) Maximum number of anchors fragments to 
                                                         return
                  
                  Remove all blocks and/or sequences from blockset:
                    --clear-blocks arg (=1) Remove blocks
                    --clear-bsas arg (=1)   Remove block set alignments
                    --clear-seqs arg (=0)   Remove sequences (warning: this makes dangling 
                                            pointers from orphaned blocks, if they remain)
                  
                  Align by adding gaps to sequences:
                    --row-type arg (=compact) way of storing alignments in memory ('map' or 
                                              'compact')
                  
                  Move block's boundaries and align only new parts:
                    --extend-length arg (=100) Length of extended part
                  
                  Align blocks with one of possible aligners:
                    --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                  multiple, similar, dummy). Specify several 
                                                  types, separated by comma, the first working 
                                                  one will be used or the last one if all fail.
                  
                  External aligner:
                    --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                          Template of command for external 
                                                          aligner
                  
                  Mafft aligner:
                    --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                          Template of command for external 
                                                          aligner
                    --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                          ('map' or 'compact')
                  
                  Muscle aligner:
                    --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                          Template of command for external 
                                                          aligner
                    --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                          ('map' or 'compact')
                  
                  Internal aligner:
                    --batch arg (=100)          batch size for pair aligner
                    --gap-penalty arg (=2)      Gap open or extension penalty
                    --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                states of pair alignment. The more gap_range, the
                                                more time.
                    --max-errors arg (=11)      Max number of errors in pair alignment
                    --mismatch-penalty arg (=1) Mismatch penalty
                  
                  Align blocks with high similarity:
                    --aligned-check arg (=10) Min equal aligned part
                    --gap-check arg (=2)      Min number of equal columns after single gap
                    --min-length arg (=100)   Min length of fragment
                    --mismatch-check arg (=1) Min number of equal columns after single mismatch
                  
                  Move terminal letters inside:
                    --max-tail arg (=3)        Max length of tail
                    --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                  
                  Cut terminal gaps:
                    --cut-strict arg (=0) cut more gaps
                  
                  Add clones of blocks from other, non-overlapping target:
                    --ou-filter arg (=0)  Do not copy good blocks to target, but remove bad 
                                          blocks from other
                  
                  
                  AreBlocksGood
                  Print if all blocks in block set are good
                  AreBlocksGood: Print if all blocks in block set are good
                      MoveGaps: Move terminal letters inside
                      CutGaps: Cut terminal gaps
                      Filter: Filter blocks
                  
                  • target: Target blockset to be tested
                  
                  Print if all blocks in block set are good:
                    --max-block arg (=-1)      Maximum block size (-1 = all)
                    --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                    --max-gaps arg (=0.2)      Max gap columns percentage
                    --max-identity arg (=1)    Maximum block identity
                    --max-spreading arg (=0.2) Maximum fragment length spreading
                    --min-block arg (=2)       Minimum block size
                    --min-fragment arg (=100)  Minimum fragment length
                    --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                               known)
                    --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                               known, columns without gaps as 1, columns with 
                                               gaps as 0.5)
                    --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                               avg)
                    --out-is-pangenome arg     Output file with verdict
                    --remove-after arg (=0)    remove file out-is-pangenome
                    --respect-minor arg (=1)   Do not check length and alignment of minor blocks
                  
                  Move terminal letters inside:
                    --max-tail arg (=3)        Max length of tail
                    --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                    --row-type arg (=compact)  way of storing alignments in memory ('map' or 
                                               'compact')
                  
                  Cut terminal gaps:
                    --cut-strict arg (=0) cut more gaps
                  
                  Filter blocks:
                    --find-subblocks arg (=1) Find and add good subblocks of bad blocks
                    --good-to-other arg (=0)  Do not remove bad blocks, but copy good blocks to 
                                              other blockset
                  
                  
                  BlastFinder
                  BlastFinder: BlastFinder
                      Output: Output block set
                      BlastRunner: Blast runner
                      ImportBlastHits: Import blast hits
                      FileCopy: Copy file
                      FileCopy: Copy file
                      FileRemover: Remove file
                      FileRemover: Remove file
                  
                  • target: Blockset in which hits are searched
                  
                  Output block set:
                    --out-export-alignment arg (=1) use alignment information if available
                    --out-export-contents arg (=1)  print contents of fragments
                    --out-mask arg                  mask of output files (${block} is replaced 
                                                    with block name)
                  
                  Blast runner:
                    --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                    --evalue arg (=0.001)                 Max acceptable e-value of hit
                    --remove-after arg (=0)               remove file out-hits
                    --skip-low-complexity-regions arg (=0)
                                                          Tell blast not to search in low 
                                                          complexity regions
                  
                  Import blast hits:
                    --blast-min-length arg (=100) min length of blast hit
                  
                  Copy file:
                    --blast-cons-dst arg (=:null) Destination of copy
                  
                  Copy file:
                    --blast-hits-dst arg (=:null) Destination of copy
                  
                  
                  BlastRunner
                  Blast runner
                  
                  
                    
                    Blast runner:
                      --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                      --evalue arg (=0.001)                 Max acceptable e-value of hit
                      --in-consensus arg                    Input files with consensuses
                      --out-hits arg                        Output file with blast hits
                      --remove-after arg (=0)               remove file out-hits
                      --skip-low-complexity-regions arg (=0)
                                                            Tell blast not to search in low 
                                                            complexity regions
                    
                    
                    BlockFinder
                    Locate block by sequence of its fragments
                    BlockFinder: Locate block by sequence of its fragments
                        FragmentFinder: Locate fragment by its sequence
                        OverlapFinder: Finds blocks from 'bank', overlapping with 'pattern', results are copied to 'hits'
                    
                    • other: where to look for
                    • target: where to look for
                    
                    Locate block by sequence of its fragments:
                      --pattern arg         Sequence searched for
                    
                    Locate fragment by its sequence:
                      --max-matches arg (=1000) Maximum number of matches
                    
                    
                    BlockInfo
                    Print information about blocks
                    
                    
                    • target: Target blockset
                    
                    Print information about blocks:
                      --info-count-seqs arg (=0) Add columns with orrurences in each sequence
                      --info-file arg            output file with all blocks
                      --info-mask arg            mask of output files (${block} is replaced with 
                                                 block name)
                    
                    
                    BlocksExpander
                    Add fragments to blocks using information about neighbours (deprecated)
                    
                    
                    • target: Target blockset
                    
                    Add fragments to blocks using information about neighbours (deprecated):
                      --batch arg (=100)          batch size for pair aligner
                      --gap-penalty arg (=2)      Gap open or extension penalty
                      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                  states of pair alignment. The more gap_range, the
                                                  more time.
                      --max-errors arg (=11)      Max number of errors in pair alignment
                      --mismatch-penalty arg (=1) Mismatch penalty
                    
                    
                    CheckNoOverlaps
                    Make sure no blocks overlap other blocks, else throw
                    CheckNoOverlaps: Make sure no blocks overlap other blocks, else throw
                        CheckNoOverlapsImpl: Resolve overlaping fragments (deprecated)
                        Connector: Connect all the fragments (prev-next)
                        CheckNoOverlapsImpl: Resolve overlaping fragments (deprecated)
                    
                    • target: Target blockset
                    
                    Connect all the fragments (prev-next):
                      --connect-circular arg (=0) Connect last and first fragments of circular 
                                                  chromosomes
                    
                    
                    CheckPangenome
                    CheckPangenome: CheckPangenome
                        In: Input block set
                        IsPangenome: Print if block set is good pangenome
                            AreBlocksGood: Print if all blocks in block set are good
                                MoveGaps: Move terminal letters inside
                                CutGaps: Cut terminal gaps
                                Filter: Filter blocks
                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                SelfOverlapsResolver: Resolve self-overlaps
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                                AlignLoop: AlignLoop
                                    MoveGaps: Move terminal letters inside
                                    CutGaps: Cut terminal gaps
                                    Filter: Filter blocks
                            AddBlastBlocks: Add blast hits as blocks
                                SequencesFromOther: Copy sequences from other block set
                                ConSeq: Blocks to consensus sequences
                                FilterSeqs: FilterSeqs
                                BlastFinder: BlastFinder
                                    Output: Output block set
                                    BlastRunner: Blast runner
                                    ImportBlastHits: Import blast hits
                                    FileCopy: Copy file
                                    FileCopy: Copy file
                                    FileRemover: Remove file
                                    FileRemover: Remove file
                                DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                                Clear: Remove all blocks and/or sequences from blockset
                            TrySmth: Try to do something, align (and filter), restore original if worse
                                Union: Add clones of blocks from other to this block set
                                UniqueNames: Set unique names to all blocks of this block set
                                MetaProcessor: Any processor
                                RemoveNames: Remove all blocks and/or sequences names
                                Align: LiteAlign + Filter + SelfOverlapsResolver
                                    MetaAligner: Align blocks with one of possible aligners
                                        ExternalAligner: External aligner
                                        MafftAligner: Mafft aligner
                                        MuscleAligner: Muscle aligner
                                        MultipleAligner: Internal aligner
                                        SimilarAligner: Align blocks with high similarity
                                        DummyAligner: Align by adding gaps to sequences
                                    SelfOverlapsResolver: Resolve self-overlaps
                                    MetaAligner: Align blocks with one of possible aligners
                                        ExternalAligner: External aligner
                                        MafftAligner: Mafft aligner
                                        MuscleAligner: Muscle aligner
                                        MultipleAligner: Internal aligner
                                        SimilarAligner: Align blocks with high similarity
                                        DummyAligner: Align by adding gaps to sequences
                                    AlignLoop: AlignLoop
                                        MoveGaps: Move terminal letters inside
                                        CutGaps: Cut terminal gaps
                                        Filter: Filter blocks
                                Move: Move all blocks from other blockset to target blockset
                                AddingLoopBySize: Align and move overlapless from other to target
                                    AddingLoop: AddingLoop
                                        Align: LiteAlign + Filter + SelfOverlapsResolver
                                            MetaAligner: Align blocks with one of possible aligners
                                                ExternalAligner: External aligner
                                                MafftAligner: Mafft aligner
                                                MuscleAligner: Muscle aligner
                                                MultipleAligner: Internal aligner
                                                SimilarAligner: Align blocks with high similarity
                                                DummyAligner: Align by adding gaps to sequences
                                            SelfOverlapsResolver: Resolve self-overlaps
                                            MetaAligner: Align blocks with one of possible aligners
                                                ExternalAligner: External aligner
                                                MafftAligner: Mafft aligner
                                                MuscleAligner: Muscle aligner
                                                MultipleAligner: Internal aligner
                                                SimilarAligner: Align blocks with high similarity
                                                DummyAligner: Align by adding gaps to sequences
                                            AlignLoop: AlignLoop
                                                MoveGaps: Move terminal letters inside
                                                CutGaps: Cut terminal gaps
                                                Filter: Filter blocks
                                        SmthUnion: SmthUnion
                                UniqueNames: Set unique names to all blocks of this block set
                                ReAlign: Realign blocks
                                    MetaAligner: Align blocks with one of possible aligners
                                        ExternalAligner: External aligner
                                        MafftAligner: Mafft aligner
                                        MuscleAligner: Muscle aligner
                                        MultipleAligner: Internal aligner
                                        SimilarAligner: Align blocks with high similarity
                                        DummyAligner: Align by adding gaps to sequences
                                    Filter: Filter blocks
                                Clear: Remove all blocks and/or sequences from blockset
                    
                      
                      Input block set:
                        --in-blocks arg (=pangenome.bs)    input fasta file(s) with blocks
                        --row-type arg (=compact)          way of storing alignments in memory ('map'
                                                           or 'compact')
                        --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                           ('asis', 'compact' or 'compact_low_n')
                      
                      Print if all blocks in block set are good:
                        --max-block arg (=-1)      Maximum block size (-1 = all)
                        --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                        --max-gaps arg (=0.2)      Max gap columns percentage
                        --max-identity arg (=1)    Maximum block identity
                        --max-spreading arg (=0.2) Maximum fragment length spreading
                        --min-block arg (=2)       Minimum block size
                        --min-fragment arg (=100)  Minimum fragment length
                        --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                   known)
                        --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                   known, columns without gaps as 1, columns with 
                                                   gaps as 0.5)
                        --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                   avg)
                        --out-is-pangenome arg     Output file with verdict
                        --remove-after arg (=0)    remove file out-is-pangenome
                        --respect-minor arg (=1)   Do not check length and alignment of minor blocks
                      
                      Move terminal letters inside:
                        --max-tail arg (=3)        Max length of tail
                        --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                      
                      Cut terminal gaps:
                        --cut-strict arg (=0) cut more gaps
                      
                      Filter blocks:
                        --find-subblocks arg (=1) Find and add good subblocks of bad blocks
                        --good-to-other arg (=0)  Do not remove bad blocks, but copy good blocks to 
                                                  other blockset
                      
                      Align blocks with one of possible aligners:
                        --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                      multiple, similar, dummy). Specify several 
                                                      types, separated by comma, the first working 
                                                      one will be used or the last one if all fail.
                      
                      External aligner:
                        --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                              Template of command for external 
                                                              aligner
                      
                      Mafft aligner:
                        --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                              Template of command for external 
                                                              aligner
                        --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                              ('map' or 'compact')
                      
                      Muscle aligner:
                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                              Template of command for external 
                                                              aligner
                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                              ('map' or 'compact')
                      
                      Internal aligner:
                        --batch arg (=100)          batch size for pair aligner
                        --gap-penalty arg (=2)      Gap open or extension penalty
                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                    states of pair alignment. The more gap_range, the
                                                    more time.
                        --max-errors arg (=11)      Max number of errors in pair alignment
                        --mismatch-penalty arg (=1) Mismatch penalty
                      
                      Align blocks with high similarity:
                        --aligned-check arg (=10) Min equal aligned part
                        --gap-check arg (=2)      Min number of equal columns after single gap
                        --min-length arg (=100)   Min length of fragment
                        --mismatch-check arg (=1) Min number of equal columns after single mismatch
                      
                      FilterSeqs:
                        --blast-min-length arg (=100) min length of blast hit
                      
                      Output block set:
                        --out-export-alignment arg (=1) use alignment information if available
                        --out-export-contents arg (=1)  print contents of fragments
                        --out-mask arg                  mask of output files (${block} is replaced 
                                                        with block name)
                      
                      Blast runner:
                        --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                        --evalue arg (=0.001)                 Max acceptable e-value of hit
                        --skip-low-complexity-regions arg (=0)
                                                              Tell blast not to search in low 
                                                              complexity regions
                      
                      Copy file:
                        --blast-cons-dst arg (=:null) Destination of copy
                      
                      Copy file:
                        --blast-hits-dst arg (=:null) Destination of copy
                      
                      Remove all blocks and/or sequences from blockset:
                        --clear-blocks arg (=1) Remove blocks
                        --clear-bsas arg (=1)   Remove block set alignments
                      
                      Any processor:
                        --smth-opts arg         options for processor
                      
                      Realign blocks:
                        --force-realign arg (=0) If realigned block is worse, realign anyway
                      
                      
                      ChrBSA
                      Build block set alignments from all chromosomes
                      ChrBSA: Build block set alignments from all chromosomes
                          FindBSA: Build block set alignment
                      
                      • target: Target blockset
                      
                      Build block set alignment:
                        --bsa-name arg        Name of new block set alignment
                        --bsa-seqs arg        List of sequences used for alignment, sequence groups 
                                              can be selected by genome name or chromosome name, 
                                              'all' means all sequences of block set
                      
                      
                      CleanUp
                      Connect, resolve overlaps, expand, filter (deprecated)
                      CleanUp: Connect, resolve overlaps, expand, filter (deprecated)
                          CleanUpLoop: CleanUpLoop
                              FragmentsExpander: Expand fragments (deprecated)
                              Filter: Filter blocks
                              OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
                              Connector: Connect all the fragments (prev-next)
                              Joiner: Join blocks
                                  MetaAligner: Align blocks with one of possible aligners
                                      ExternalAligner: External aligner
                                      MafftAligner: Mafft aligner
                                      MuscleAligner: Muscle aligner
                                      MultipleAligner: Internal aligner
                                      SimilarAligner: Align blocks with high similarity
                                      DummyAligner: Align by adding gaps to sequences
                          Filter: Filter blocks
                          Connector: Connect all the fragments (prev-next)
                          FragmentsExpander: Expand fragments (deprecated)
                      
                      • target: Target blockset
                      
                      Expand fragments (deprecated):
                        --batch arg (=100)          batch size for pair aligner
                        --gap-penalty arg (=2)      Gap open or extension penalty
                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                    states of pair alignment. The more gap_range, the
                                                    more time.
                        --max-errors arg (=11)      Max number of errors in pair alignment
                        --max-overlap arg (=200)    max number of positions added after first overlap
                                                    occur
                        --mismatch-penalty arg (=1) Mismatch penalty
                        --ori arg (=0)              direction of expansion
                      
                      Filter blocks:
                        --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                        --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                   other blockset
                        --max-block arg (=-1)      Maximum block size (-1 = all)
                        --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                        --max-gaps arg (=0.2)      Max gap columns percentage
                        --max-identity arg (=1)    Maximum block identity
                        --max-spreading arg (=0.2) Maximum fragment length spreading
                        --min-block arg (=2)       Minimum block size
                        --min-fragment arg (=100)  Minimum fragment length
                        --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                   known)
                        --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                   known, columns without gaps as 1, columns with 
                                                   gaps as 0.5)
                        --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                   avg)
                      
                      Resolve overlaping fragments (version 2, deprecated):
                        --min-distance arg (=30) Min distance between fragment boundaries
                      
                      Connect all the fragments (prev-next):
                        --connect-circular arg (=0) Connect last and first fragments of circular 
                                                    chromosomes
                      
                      Join blocks:
                        --join-max-dist arg (=100)    Max allowed distance when joining fragments
                        --join-to-fragment arg (=0.5) Max allowed gap length to fragment length ratio
                                                      when joining fragments
                        --join-to-gap arg (=1.5)      Max allowed ratio of gaps' lengths (inside a 
                                                      block) when joining
                      
                      Align blocks with one of possible aligners:
                        --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                      multiple, similar, dummy). Specify several 
                                                      types, separated by comma, the first working 
                                                      one will be used or the last one if all fail.
                        --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                      'compact')
                      
                      External aligner:
                        --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                              Template of command for external 
                                                              aligner
                      
                      Mafft aligner:
                        --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                              Template of command for external 
                                                              aligner
                        --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                              ('map' or 'compact')
                      
                      Muscle aligner:
                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                              Template of command for external 
                                                              aligner
                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                              ('map' or 'compact')
                      
                      Align blocks with high similarity:
                        --aligned-check arg (=10) Min equal aligned part
                        --gap-check arg (=2)      Min number of equal columns after single gap
                        --min-length arg (=100)   Min length of fragment
                        --mismatch-check arg (=1) Min number of equal columns after single mismatch
                      
                      
                      Clear
                      Remove all blocks and/or sequences from blockset
                      
                      
                      • target: Target blockset
                      
                      Remove all blocks and/or sequences from blockset:
                        --clear-blocks arg (=1) Remove blocks
                        --clear-bsas arg (=1)   Remove block set alignments
                        --clear-seqs arg (=0)   Remove sequences (warning: this makes dangling 
                                                pointers from orphaned blocks, if they remain)
                      
                      
                      ConSeq
                      Blocks to consensus sequences
                      
                      
                      • other: Blockset, from which blocks are taken
                      • target: Blockset, where consensus sequences are added
                      
                      Blocks to consensus sequences:
                        --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                           ('asis', 'compact' or 'compact_low_n')
                      
                      
                      Connector
                      Connect all the fragments (prev-next)
                      
                      
                      • target: Target blockset
                      
                      Connect all the fragments (prev-next):
                        --connect-circular arg (=0) Connect last and first fragments of circular 
                                                    chromosomes
                      
                      
                      Consensus
                      Consensus writer
                      Consensus: Consensus writer
                          ConSeq: Blocks to consensus sequences
                          Output: Output block set
                          Clear: Remove all blocks and/or sequences from blockset
                      
                      • target: Target blockset
                      
                      Blocks to consensus sequences:
                        --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                           ('asis', 'compact' or 'compact_low_n')
                      
                      Output block set:
                        --cons-export-alignment arg (=1) use alignment information if available
                        --cons-export-contents arg (=1)  print contents of fragments
                        --cons-file arg                  output file with all blocks
                        --cons-mask arg                  mask of output files (${block} is replaced 
                                                         with block name)
                      
                      Remove all blocks and/or sequences from blockset:
                        --clear-bsas arg (=1) Remove block set alignments
                      
                      
                      ConsensusTree
                      Print consensus tree
                      ConsensusTree: Print consensus tree
                          BranchGenerator: BranchGenerator
                              PrintTree: Build and print newick trees of blocks
                                  FragmentDistance: Calculate distance between fragments in block
                      
                      • target: Target blockset
                      
                      Print consensus tree:
                        --bootstrap-diagnostic-min-block arg (=4)
                                                              Minimum block used to calculate number 
                                                              of diagnostic positions
                        --bootstrap-diagnostic-stem arg (=1)  If only stem blocks are used to 
                                                              calculate number of diagnostic 
                                                              positions
                        --bootstrap-percent arg (=0)          If bootstrap is percentage
                        --bootstrap-print arg (=in-braces)    How to print bootstrap values ('no', 
                                                              'in-braces', 'before-length')
                        --bootstrap-values arg (=diagnostic-positions)
                                                              What to use as bootstrap values 
                                                              ('blocks', 'length', 
                                                              'diagnostic-positions')
                        --out-branch arg                      Output file with branches
                        --out-consensus-tree arg              Output file with consensus tree
                        --print-branches arg (=1)             If branches are logged
                        --remove-after arg (=0)               remove file out-consensus-tree
                        --tree-pseudo-leafs arg (=0)          Convert each leaf to short branch 
                                                              (workaround to make viewer programs 
                                                              show bootstrap values of leafs)
                      
                      BranchGenerator:
                        --log arg (=1)         block weight is log(number of nonidentical positions) 
                                               (otherwse linear)
                        --min-noident arg (=5) Minimum number of nonidentical positions in block
                      
                      Build and print newick trees of blocks:
                        --tree-file arg         output file with all blocks
                        --tree-mask arg         mask of output files (${block} is replaced with block
                                                name)
                        --tree-method arg (=nj) Method of tree construction (upgma/nj)
                      
                      Calculate distance between fragments in block:
                        --tree-distance-file arg         output file with all blocks
                        --tree-distance-mask arg         mask of output files (${block} is replaced 
                                                         with block name)
                      
                      
                      CutGaps
                      Cut terminal gaps
                      
                      
                      • target: Target blockset
                      
                      Cut terminal gaps:
                        --cut-strict arg (=0)     cut more gaps
                        --row-type arg (=compact) way of storing alignments in memory ('map' or 
                                                  'compact')
                      
                      
                      DeConSeq
                      Build blocks from blocks, set to sequences of blocks of other
                      
                      
                      • other: From where consensus blocks are taken
                      • target: Where new blocks are added
                      
                      
                      DummyAligner
                      Align by adding gaps to sequences
                      
                      
                      • target: Target blockset
                      
                      Align by adding gaps to sequences:
                        --row-type arg (=compact) way of storing alignments in memory ('map' or 
                                                  'compact')
                      
                      
                      ExactStemBSA
                      Replace all non-stem blocks with gaps in block set alignment
                      
                      
                      • target: Target blockset
                      
                      Replace all non-stem blocks with gaps in block set alignment:
                        --bsa-min-length arg (=100) Min length of accepted block
                        --bsa-stem-improve arg (=1) Move fragments and remove pure gaps
                      
                      
                      ExtendAndAlign
                      ExtendAndAlign: ExtendAndAlign
                          FragmentsExtender: Move block's boundaries and align only new parts
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                          Align: LiteAlign + Filter + SelfOverlapsResolver
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              SelfOverlapsResolver: Resolve self-overlaps
                              MetaAligner: Align blocks with one of possible aligners
                                  ExternalAligner: External aligner
                                  MafftAligner: Mafft aligner
                                  MuscleAligner: Muscle aligner
                                  MultipleAligner: Internal aligner
                                  SimilarAligner: Align blocks with high similarity
                                  DummyAligner: Align by adding gaps to sequences
                              AlignLoop: AlignLoop
                                  MoveGaps: Move terminal letters inside
                                  CutGaps: Cut terminal gaps
                                  Filter: Filter blocks
                      
                        
                        Move block's boundaries and align only new parts:
                          --extend-length arg (=100) Length of extended part
                        
                        Align blocks with one of possible aligners:
                          --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                        multiple, similar, dummy). Specify several 
                                                        types, separated by comma, the first working 
                                                        one will be used or the last one if all fail.
                          --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                        'compact')
                        
                        External aligner:
                          --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                Template of command for external 
                                                                aligner
                        
                        Mafft aligner:
                          --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                Template of command for external 
                                                                aligner
                          --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                ('map' or 'compact')
                        
                        Muscle aligner:
                          --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                Template of command for external 
                                                                aligner
                          --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                ('map' or 'compact')
                        
                        Internal aligner:
                          --batch arg (=100)          batch size for pair aligner
                          --gap-penalty arg (=2)      Gap open or extension penalty
                          --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                      states of pair alignment. The more gap_range, the
                                                      more time.
                          --max-errors arg (=11)      Max number of errors in pair alignment
                          --mismatch-penalty arg (=1) Mismatch penalty
                        
                        Align blocks with high similarity:
                          --aligned-check arg (=10) Min equal aligned part
                          --gap-check arg (=2)      Min number of equal columns after single gap
                          --min-identity arg (=0.9) Min identity of block
                          --min-length arg (=100)   Min length of fragment
                          --mismatch-check arg (=1) Min number of equal columns after single mismatch
                        
                        Move terminal letters inside:
                          --max-tail arg (=3)        Max length of tail
                          --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                        
                        Cut terminal gaps:
                          --cut-strict arg (=0) cut more gaps
                        
                        Filter blocks:
                          --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                          --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                     other blockset
                          --max-block arg (=-1)      Maximum block size (-1 = all)
                          --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                          --max-gaps arg (=0.2)      Max gap columns percentage
                          --max-identity arg (=1)    Maximum block identity
                          --max-spreading arg (=0.2) Maximum fragment length spreading
                          --min-block arg (=2)       Minimum block size
                          --min-fragment arg (=100)  Minimum fragment length
                          --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                     known)
                          --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                     avg)
                        
                        
                        ExtendAndFix
                        ExtendAndFix: ExtendAndFix
                            FragmentsExtender: Move block's boundaries and align only new parts
                                MetaAligner: Align blocks with one of possible aligners
                                    ExternalAligner: External aligner
                                    MafftAligner: Mafft aligner
                                    MuscleAligner: Muscle aligner
                                    MultipleAligner: Internal aligner
                                    SimilarAligner: Align blocks with high similarity
                                    DummyAligner: Align by adding gaps to sequences
                            FixEnds: Cut bad aligned ends
                        
                          
                          Move block's boundaries and align only new parts:
                            --extend-length arg (=100) Length of extended part
                          
                          Align blocks with one of possible aligners:
                            --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                          multiple, similar, dummy). Specify several 
                                                          types, separated by comma, the first working 
                                                          one will be used or the last one if all fail.
                            --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                          'compact')
                          
                          External aligner:
                            --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                  Template of command for external 
                                                                  aligner
                          
                          Mafft aligner:
                            --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                  Template of command for external 
                                                                  aligner
                            --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                  ('map' or 'compact')
                          
                          Muscle aligner:
                            --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                  Template of command for external 
                                                                  aligner
                            --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                  ('map' or 'compact')
                          
                          Internal aligner:
                            --batch arg (=100)          batch size for pair aligner
                            --gap-penalty arg (=2)      Gap open or extension penalty
                            --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                        states of pair alignment. The more gap_range, the
                                                        more time.
                            --max-errors arg (=11)      Max number of errors in pair alignment
                            --mismatch-penalty arg (=1) Mismatch penalty
                          
                          Align blocks with high similarity:
                            --aligned-check arg (=10) Min equal aligned part
                            --gap-check arg (=2)      Min number of equal columns after single gap
                            --min-identity arg (=0.9) Min identity of block
                            --min-length arg (=100)   Min length of fragment
                            --mismatch-check arg (=1) Min number of equal columns after single mismatch
                          
                          Cut bad aligned ends:
                            --max-block arg (=-1)      Maximum block size (-1 = all)
                            --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                            --max-gaps arg (=0.2)      Max gap columns percentage
                            --max-identity arg (=1)    Maximum block identity
                            --max-spreading arg (=0.2) Maximum fragment length spreading
                            --min-block arg (=2)       Minimum block size
                            --min-fragment arg (=100)  Minimum fragment length
                            --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                       known)
                            --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                       avg)
                          
                          
                          ExtendLoop
                          ExtendLoop: ExtendLoop
                              MoveUnchanged: Move unchanged blocks from other to target
                              ExtendAndAlign: ExtendAndAlign
                                  FragmentsExtender: Move block's boundaries and align only new parts
                                      MetaAligner: Align blocks with one of possible aligners
                                          ExternalAligner: External aligner
                                          MafftAligner: Mafft aligner
                                          MuscleAligner: Muscle aligner
                                          MultipleAligner: Internal aligner
                                          SimilarAligner: Align blocks with high similarity
                                          DummyAligner: Align by adding gaps to sequences
                                  Align: LiteAlign + Filter + SelfOverlapsResolver
                                      MetaAligner: Align blocks with one of possible aligners
                                          ExternalAligner: External aligner
                                          MafftAligner: Mafft aligner
                                          MuscleAligner: Muscle aligner
                                          MultipleAligner: Internal aligner
                                          SimilarAligner: Align blocks with high similarity
                                          DummyAligner: Align by adding gaps to sequences
                                      SelfOverlapsResolver: Resolve self-overlaps
                                      MetaAligner: Align blocks with one of possible aligners
                                          ExternalAligner: External aligner
                                          MafftAligner: Mafft aligner
                                          MuscleAligner: Muscle aligner
                                          MultipleAligner: Internal aligner
                                          SimilarAligner: Align blocks with high similarity
                                          DummyAligner: Align by adding gaps to sequences
                                      AlignLoop: AlignLoop
                                          MoveGaps: Move terminal letters inside
                                          CutGaps: Cut terminal gaps
                                          Filter: Filter blocks
                              Move: Move all blocks from other blockset to target blockset
                              AddingLoopBySize: Align and move overlapless from other to target
                                  AddingLoop: AddingLoop
                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                          MetaAligner: Align blocks with one of possible aligners
                                              ExternalAligner: External aligner
                                              MafftAligner: Mafft aligner
                                              MuscleAligner: Muscle aligner
                                              MultipleAligner: Internal aligner
                                              SimilarAligner: Align blocks with high similarity
                                              DummyAligner: Align by adding gaps to sequences
                                          SelfOverlapsResolver: Resolve self-overlaps
                                          MetaAligner: Align blocks with one of possible aligners
                                              ExternalAligner: External aligner
                                              MafftAligner: Mafft aligner
                                              MuscleAligner: Muscle aligner
                                              MultipleAligner: Internal aligner
                                              SimilarAligner: Align blocks with high similarity
                                              DummyAligner: Align by adding gaps to sequences
                                          AlignLoop: AlignLoop
                                              MoveGaps: Move terminal letters inside
                                              CutGaps: Cut terminal gaps
                                              Filter: Filter blocks
                                      SmthUnion: SmthUnion
                              Clear: Remove all blocks and/or sequences from blockset
                              Move: Move all blocks from other blockset to target blockset
                              Clear: Remove all blocks and/or sequences from blockset
                          
                            
                            Move block's boundaries and align only new parts:
                              --extend-length arg (=100) Length of extended part
                            
                            Align blocks with one of possible aligners:
                              --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                            multiple, similar, dummy). Specify several 
                                                            types, separated by comma, the first working 
                                                            one will be used or the last one if all fail.
                              --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                            'compact')
                            
                            External aligner:
                              --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                    Template of command for external 
                                                                    aligner
                            
                            Mafft aligner:
                              --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                    Template of command for external 
                                                                    aligner
                              --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                    ('map' or 'compact')
                            
                            Muscle aligner:
                              --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                    Template of command for external 
                                                                    aligner
                              --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                    ('map' or 'compact')
                            
                            Internal aligner:
                              --batch arg (=100)          batch size for pair aligner
                              --gap-penalty arg (=2)      Gap open or extension penalty
                              --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                          states of pair alignment. The more gap_range, the
                                                          more time.
                              --max-errors arg (=11)      Max number of errors in pair alignment
                              --mismatch-penalty arg (=1) Mismatch penalty
                            
                            Align blocks with high similarity:
                              --aligned-check arg (=10) Min equal aligned part
                              --gap-check arg (=2)      Min number of equal columns after single gap
                              --min-identity arg (=0.9) Min identity of block
                              --min-length arg (=100)   Min length of fragment
                              --mismatch-check arg (=1) Min number of equal columns after single mismatch
                            
                            Move terminal letters inside:
                              --max-tail arg (=3)        Max length of tail
                              --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                            
                            Cut terminal gaps:
                              --cut-strict arg (=0) cut more gaps
                            
                            Filter blocks:
                              --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                              --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                         other blockset
                              --max-block arg (=-1)      Maximum block size (-1 = all)
                              --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                              --max-gaps arg (=0.2)      Max gap columns percentage
                              --max-identity arg (=1)    Maximum block identity
                              --max-spreading arg (=0.2) Maximum fragment length spreading
                              --min-block arg (=2)       Minimum block size
                              --min-fragment arg (=100)  Minimum fragment length
                              --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                         known)
                              --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                         avg)
                            
                            
                            ExtendLoopFast
                            ExtendLoopFast: ExtendLoopFast
                                MoveUnchanged: Move unchanged blocks from other to target
                                ExtendAndFix: ExtendAndFix
                                    FragmentsExtender: Move block's boundaries and align only new parts
                                        MetaAligner: Align blocks with one of possible aligners
                                            ExternalAligner: External aligner
                                            MafftAligner: Mafft aligner
                                            MuscleAligner: Muscle aligner
                                            MultipleAligner: Internal aligner
                                            SimilarAligner: Align blocks with high similarity
                                            DummyAligner: Align by adding gaps to sequences
                                    FixEnds: Cut bad aligned ends
                                Move: Move all blocks from other blockset to target blockset
                                OverlaplessUnion: Add clones of blocks from other, non-overlapping target
                                Clear: Remove all blocks and/or sequences from blockset
                                Move: Move all blocks from other blockset to target blockset
                                Clear: Remove all blocks and/or sequences from blockset
                            
                              
                              Move block's boundaries and align only new parts:
                                --extend-length arg (=100) Length of extended part
                              
                              Align blocks with one of possible aligners:
                                --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                              multiple, similar, dummy). Specify several 
                                                              types, separated by comma, the first working 
                                                              one will be used or the last one if all fail.
                                --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                              'compact')
                              
                              External aligner:
                                --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                      Template of command for external 
                                                                      aligner
                              
                              Mafft aligner:
                                --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                      Template of command for external 
                                                                      aligner
                                --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                      ('map' or 'compact')
                              
                              Muscle aligner:
                                --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                      Template of command for external 
                                                                      aligner
                                --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                      ('map' or 'compact')
                              
                              Internal aligner:
                                --batch arg (=100)          batch size for pair aligner
                                --gap-penalty arg (=2)      Gap open or extension penalty
                                --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                            states of pair alignment. The more gap_range, the
                                                            more time.
                                --max-errors arg (=11)      Max number of errors in pair alignment
                                --mismatch-penalty arg (=1) Mismatch penalty
                              
                              Align blocks with high similarity:
                                --aligned-check arg (=10) Min equal aligned part
                                --gap-check arg (=2)      Min number of equal columns after single gap
                                --min-identity arg (=0.9) Min identity of block
                                --min-length arg (=100)   Min length of fragment
                                --mismatch-check arg (=1) Min number of equal columns after single mismatch
                              
                              Cut bad aligned ends:
                                --max-block arg (=-1)      Maximum block size (-1 = all)
                                --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                --max-gaps arg (=0.2)      Max gap columns percentage
                                --max-identity arg (=1)    Maximum block identity
                                --max-spreading arg (=0.2) Maximum fragment length spreading
                                --min-block arg (=2)       Minimum block size
                                --min-fragment arg (=100)  Minimum fragment length
                                --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                           known)
                                --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                           avg)
                              
                              Add clones of blocks from other, non-overlapping target:
                                --ou-filter arg (=0)  Do not copy good blocks to target, but remove bad 
                                                      blocks from other
                              
                              
                              ExternalAligner
                              External aligner
                              
                              
                              • target: Target blockset
                              
                              External aligner:
                                --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                      Template of command for external 
                                                                      aligner
                                --row-type arg (=compact)             way of storing alignments in memory 
                                                                      ('map' or 'compact')
                              
                              
                              ExtractGenes
                              ExtractGenes: ExtractGenes
                                  In: Input block set
                                  AddGenes: Add genes from EBI genes description
                                  Output: Output block set
                              
                                
                                Input block set:
                                  --in-blocks arg (=genomes-renamed.fasta)
                                                                        input fasta file(s) with blocks
                                  --row-type arg (=compact)             way of storing alignments in memory 
                                                                        ('map' or 'compact')
                                  --seq-storage arg (=compact_low_n)    way of storing sequences in memory 
                                                                        ('asis', 'compact' or 'compact_low_n')
                                
                                Add genes from EBI genes description:
                                  --in-genes arg (=features.embl) input database files with genes
                                  --product arg (=1)              Append product name to block name
                                
                                Output block set:
                                  --out-dump-block arg (=1)       dump blocks
                                  --out-dump-seq arg (=0)         dump sequences before blocks
                                  --out-export-alignment arg (=1) use alignment information if available
                                  --out-file arg (=features.bs)   output file with all blocks
                                  --out-mask arg                  mask of output files (${block} is replaced 
                                                                  with block name)
                                
                                
                                FastaBSA
                                Print block set alignment as fasta
                                
                                
                                • target: Target blockset
                                
                                Print block set alignment as fasta:
                                  --bsa-fasta arg         Output fasta file with block set alignment
                                  --bsa-name arg          Name of block set alignment.
                                  --remove-after arg (=0) remove file bsa-fasta
                                
                                
                                FileCopy
                                Copy file
                                
                                
                                  
                                  Copy file:
                                    --dst arg (=:null)    Destination of copy
                                    --src arg             Source file to copy
                                  
                                  
                                  FileRemover
                                  Remove file
                                  
                                  
                                    
                                    Remove file:
                                      --filename arg        File to be removed
                                    
                                    
                                    Filter
                                    Filter blocks
                                    
                                    
                                    • other: Target blockset for good blocks (if --good-to-other)
                                    • target: Filtered blockset
                                    
                                    Filter blocks:
                                      --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                      --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                 other blockset
                                      --max-block arg (=-1)      Maximum block size (-1 = all)
                                      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                      --max-gaps arg (=0.2)      Max gap columns percentage
                                      --max-identity arg (=1)    Maximum block identity
                                      --max-spreading arg (=0.2) Maximum fragment length spreading
                                      --min-block arg (=2)       Minimum block size
                                      --min-fragment arg (=100)  Minimum fragment length
                                      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                 known)
                                      --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                 known, columns without gaps as 1, columns with 
                                                                 gaps as 0.5)
                                      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                 avg)
                                    
                                    
                                    FindBSA
                                    Build block set alignment
                                    
                                    
                                    • target: Target blockset
                                    
                                    Build block set alignment:
                                      --bsa-name arg        Name of new block set alignment
                                      --bsa-seqs arg        List of sequences used for alignment, sequence groups 
                                                            can be selected by genome name or chromosome name, 
                                                            'all' means all sequences of block set
                                    
                                    
                                    FindGeneConversion
                                    FindGeneConversion: FindGeneConversion
                                        FragmentDistance: Calculate distance between fragments in block
                                    
                                    • other: Where gene conversion is searched
                                    • target: Where results are added
                                    
                                    Calculate distance between fragments in block:
                                      --distance-file arg         output file with all blocks
                                      --distance-mask arg         mask of output files (${block} is replaced with 
                                                                  block name)
                                    
                                    
                                    FindGeneGroups
                                    Find groups of gene parts according to pangenome
                                    
                                    
                                    • genes: Blocks of this block set represent genes
                                    • pangenome: Similar parts of genomes
                                    • target: Where gene groups are written to
                                    
                                    
                                    FindLowSimilar
                                    Find regions of low similarity in blocks
                                    
                                    
                                    • other: Source blocks
                                    • target: Destination for low similarity sub-blocks
                                    
                                    Find regions of low similarity in blocks:
                                      --max-block arg (=-1)      Maximum block size (-1 = all)
                                      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                      --max-gaps arg (=0.2)      Max gap columns percentage
                                      --max-identity arg (=1)    Maximum block identity
                                      --max-spreading arg (=0.2) Maximum fragment length spreading
                                      --min-block arg (=2)       Minimum block size
                                      --min-fragment arg (=100)  Minimum fragment length
                                      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                 known)
                                      --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                 known, columns without gaps as 1, columns with 
                                                                 gaps as 0.5)
                                      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                 avg)
                                    
                                    
                                    FixEnds
                                    Cut bad aligned ends
                                    
                                    
                                    • target: Target blockset
                                    
                                    Cut bad aligned ends:
                                      --max-block arg (=-1)      Maximum block size (-1 = all)
                                      --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                      --max-gaps arg (=0.2)      Max gap columns percentage
                                      --max-identity arg (=1)    Maximum block identity
                                      --max-spreading arg (=0.2) Maximum fragment length spreading
                                      --min-block arg (=2)       Minimum block size
                                      --min-fragment arg (=100)  Minimum fragment length
                                      --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                 known)
                                      --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                 known, columns without gaps as 1, columns with 
                                                                 gaps as 0.5)
                                      --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                 avg)
                                    
                                    
                                    FragmentDistance
                                    Calculate distance between fragments in block
                                    
                                    
                                    • target: Target blockset
                                    
                                    Calculate distance between fragments in block:
                                      --distance-file arg         output file with all blocks
                                      --distance-mask arg         mask of output files (${block} is replaced with 
                                                                  block name)
                                    
                                    
                                    FragmentFinder
                                    Locate fragment by its sequence
                                    
                                    
                                    • target: search in sequences, add fragments
                                    
                                    Locate fragment by its sequence:
                                      --max-matches arg (=1000) Maximum number of matches
                                      --pattern arg             Sequence searched for
                                    
                                    
                                    FragmentsExpander
                                    Expand fragments (deprecated)
                                    
                                    
                                    • target: Target blockset
                                    
                                    Expand fragments (deprecated):
                                      --batch arg (=100)          batch size for pair aligner
                                      --gap-penalty arg (=2)      Gap open or extension penalty
                                      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                  states of pair alignment. The more gap_range, the
                                                                  more time.
                                      --max-errors arg (=11)      Max number of errors in pair alignment
                                      --max-overlap arg (=0)      max number of positions added after first overlap
                                                                  occur
                                      --mismatch-penalty arg (=1) Mismatch penalty
                                      --ori arg (=0)              direction of expansion
                                    
                                    
                                    FragmentsExtender
                                    Move block's boundaries and align only new parts
                                    FragmentsExtender: Move block's boundaries and align only new parts
                                        MetaAligner: Align blocks with one of possible aligners
                                            ExternalAligner: External aligner
                                            MafftAligner: Mafft aligner
                                            MuscleAligner: Muscle aligner
                                            MultipleAligner: Internal aligner
                                            SimilarAligner: Align blocks with high similarity
                                            DummyAligner: Align by adding gaps to sequences
                                    
                                    • target: Target blockset
                                    
                                    Move block's boundaries and align only new parts:
                                      --extend-length arg (=100)       Length of extended part
                                      --extend-length-portion arg (=0) Length of extended part portion in source
                                    
                                    Align blocks with one of possible aligners:
                                      --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                    multiple, similar, dummy). Specify several 
                                                                    types, separated by comma, the first working 
                                                                    one will be used or the last one if all fail.
                                      --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                    'compact')
                                    
                                    External aligner:
                                      --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                            Template of command for external 
                                                                            aligner
                                    
                                    Mafft aligner:
                                      --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                            Template of command for external 
                                                                            aligner
                                      --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                            ('map' or 'compact')
                                    
                                    Muscle aligner:
                                      --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                            Template of command for external 
                                                                            aligner
                                      --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                            ('map' or 'compact')
                                    
                                    Internal aligner:
                                      --batch arg (=100)          batch size for pair aligner
                                      --gap-penalty arg (=2)      Gap open or extension penalty
                                      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                  states of pair alignment. The more gap_range, the
                                                                  more time.
                                      --max-errors arg (=11)      Max number of errors in pair alignment
                                      --mismatch-penalty arg (=1) Mismatch penalty
                                    
                                    Align blocks with high similarity:
                                      --aligned-check arg (=10) Min equal aligned part
                                      --gap-check arg (=2)      Min number of equal columns after single gap
                                      --min-identity arg (=0.9) Min identity of block
                                      --min-length arg (=100)   Min length of fragment
                                      --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                    
                                    
                                    GetData
                                    Download genomes from Web
                                    
                                    
                                      
                                      Download genomes from Web:
                                        --data arg              Output file
                                        --remove-after arg (=0) remove file data
                                        --table arg             Table of genomes
                                        --type arg (=fasta)     Type of content downloaded (fasta|genes)
                                      
                                      
                                      GetFasta
                                      GetFasta: GetFasta
                                          GetData: Download genomes from Web
                                      
                                        
                                        Download genomes from Web:
                                          --data arg (=genomes-raw.fasta) Output file
                                          --remove-after arg (=0)         remove file data
                                          --table arg (=genomes.tsv)      Table of genomes
                                        
                                        
                                        GetGenes
                                        GetGenes: GetGenes
                                            GetData: Download genomes from Web
                                        
                                          
                                          Download genomes from Web:
                                            --data arg (=features.embl) Output file
                                            --remove-after arg (=0)     remove file data
                                            --table arg (=genomes.tsv)  Table of genomes
                                          
                                          
                                          Hash
                                          Print hash of blockset
                                          
                                          
                                          • target: Target blockset
                                          
                                          Print hash of blockset:
                                            --hash-file arg         Output file with blockset hash
                                            --remove-after arg (=0) remove file hash-file
                                          
                                          
                                          ImportBlastHits
                                          Import blast hits
                                          
                                          
                                          • other: Consensuses (blocks or sequences) on which blast was run
                                          • target: Where hits are added
                                          
                                          Import blast hits:
                                            --blast-hits arg              results of blast -m 8
                                            --blast-min-length arg (=100) min length of blast hit
                                          
                                          
                                          In
                                          Input block set
                                          
                                          
                                          • target: Default blockset where blocks are added
                                          
                                          Input block set:
                                            --in-blocks arg                    input fasta file(s) with blocks
                                            --row-type arg (=compact)          way of storing alignments in memory ('map'
                                                                               or 'compact')
                                            --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                                               ('asis', 'compact' or 'compact_low_n')
                                          
                                          
                                          Info
                                          Print human readable summary and statistics
                                          Info: Print human readable summary and statistics
                                              Stats: Print human readable summary and statistics about block set
                                          
                                          • target: Target blockset
                                          
                                          Print human readable summary and statistics about block set:
                                            --out-stats arg         Output file with statistics
                                            --remove-after arg (=0) remove file out-stats
                                          
                                          
                                          InputBSA
                                          Input block set alignment
                                          
                                          
                                          • target: Target blockset
                                          
                                          Input block set alignment:
                                            --in-bsa arg          input file(s) with block set alignments
                                          
                                          
                                          IsPangenome
                                          Print if block set is good pangenome
                                          IsPangenome: Print if block set is good pangenome
                                              AreBlocksGood: Print if all blocks in block set are good
                                                  MoveGaps: Move terminal letters inside
                                                  CutGaps: Cut terminal gaps
                                                  Filter: Filter blocks
                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                  MetaAligner: Align blocks with one of possible aligners
                                                      ExternalAligner: External aligner
                                                      MafftAligner: Mafft aligner
                                                      MuscleAligner: Muscle aligner
                                                      MultipleAligner: Internal aligner
                                                      SimilarAligner: Align blocks with high similarity
                                                      DummyAligner: Align by adding gaps to sequences
                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                  MetaAligner: Align blocks with one of possible aligners
                                                      ExternalAligner: External aligner
                                                      MafftAligner: Mafft aligner
                                                      MuscleAligner: Muscle aligner
                                                      MultipleAligner: Internal aligner
                                                      SimilarAligner: Align blocks with high similarity
                                                      DummyAligner: Align by adding gaps to sequences
                                                  AlignLoop: AlignLoop
                                                      MoveGaps: Move terminal letters inside
                                                      CutGaps: Cut terminal gaps
                                                      Filter: Filter blocks
                                              AddBlastBlocks: Add blast hits as blocks
                                                  SequencesFromOther: Copy sequences from other block set
                                                  ConSeq: Blocks to consensus sequences
                                                  FilterSeqs: FilterSeqs
                                                  BlastFinder: BlastFinder
                                                      Output: Output block set
                                                      BlastRunner: Blast runner
                                                      ImportBlastHits: Import blast hits
                                                      FileCopy: Copy file
                                                      FileCopy: Copy file
                                                      FileRemover: Remove file
                                                      FileRemover: Remove file
                                                  DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                                                  Clear: Remove all blocks and/or sequences from blockset
                                              TrySmth: Try to do something, align (and filter), restore original if worse
                                                  Union: Add clones of blocks from other to this block set
                                                  UniqueNames: Set unique names to all blocks of this block set
                                                  MetaProcessor: Any processor
                                                  RemoveNames: Remove all blocks and/or sequences names
                                                  Align: LiteAlign + Filter + SelfOverlapsResolver
                                                      MetaAligner: Align blocks with one of possible aligners
                                                          ExternalAligner: External aligner
                                                          MafftAligner: Mafft aligner
                                                          MuscleAligner: Muscle aligner
                                                          MultipleAligner: Internal aligner
                                                          SimilarAligner: Align blocks with high similarity
                                                          DummyAligner: Align by adding gaps to sequences
                                                      SelfOverlapsResolver: Resolve self-overlaps
                                                      MetaAligner: Align blocks with one of possible aligners
                                                          ExternalAligner: External aligner
                                                          MafftAligner: Mafft aligner
                                                          MuscleAligner: Muscle aligner
                                                          MultipleAligner: Internal aligner
                                                          SimilarAligner: Align blocks with high similarity
                                                          DummyAligner: Align by adding gaps to sequences
                                                      AlignLoop: AlignLoop
                                                          MoveGaps: Move terminal letters inside
                                                          CutGaps: Cut terminal gaps
                                                          Filter: Filter blocks
                                                  Move: Move all blocks from other blockset to target blockset
                                                  AddingLoopBySize: Align and move overlapless from other to target
                                                      AddingLoop: AddingLoop
                                                          Align: LiteAlign + Filter + SelfOverlapsResolver
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              SelfOverlapsResolver: Resolve self-overlaps
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              AlignLoop: AlignLoop
                                                                  MoveGaps: Move terminal letters inside
                                                                  CutGaps: Cut terminal gaps
                                                                  Filter: Filter blocks
                                                          SmthUnion: SmthUnion
                                                  UniqueNames: Set unique names to all blocks of this block set
                                                  ReAlign: Realign blocks
                                                      MetaAligner: Align blocks with one of possible aligners
                                                          ExternalAligner: External aligner
                                                          MafftAligner: Mafft aligner
                                                          MuscleAligner: Muscle aligner
                                                          MultipleAligner: Internal aligner
                                                          SimilarAligner: Align blocks with high similarity
                                                          DummyAligner: Align by adding gaps to sequences
                                                      Filter: Filter blocks
                                                  Clear: Remove all blocks and/or sequences from blockset
                                          
                                          • all-blast-hits: All blast hits
                                          • blast-hits: Good blast hits
                                          • joined: Results of joining neighbour blocks
                                          • non-internal-hits: Non-internal blast hits
                                          • target: Target blockset to be tested
                                          
                                          Print if all blocks in block set are good:
                                            --max-block arg (=-1)      Maximum block size (-1 = all)
                                            --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                            --max-gaps arg (=0.2)      Max gap columns percentage
                                            --max-identity arg (=1)    Maximum block identity
                                            --max-spreading arg (=0.2) Maximum fragment length spreading
                                            --min-block arg (=2)       Minimum block size
                                            --min-fragment arg (=100)  Minimum fragment length
                                            --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                       known)
                                            --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                       known, columns without gaps as 1, columns with 
                                                                       gaps as 0.5)
                                            --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                       avg)
                                            --out-is-pangenome arg     Output file with verdict
                                            --remove-after arg (=0)    remove file out-is-pangenome
                                            --respect-minor arg (=1)   Do not check length and alignment of minor blocks
                                          
                                          Move terminal letters inside:
                                            --max-tail arg (=3)        Max length of tail
                                            --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                            --row-type arg (=compact)  way of storing alignments in memory ('map' or 
                                                                       'compact')
                                          
                                          Cut terminal gaps:
                                            --cut-strict arg (=0) cut more gaps
                                          
                                          Filter blocks:
                                            --find-subblocks arg (=1) Find and add good subblocks of bad blocks
                                            --good-to-other arg (=0)  Do not remove bad blocks, but copy good blocks to 
                                                                      other blockset
                                          
                                          Align blocks with one of possible aligners:
                                            --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                          multiple, similar, dummy). Specify several 
                                                                          types, separated by comma, the first working 
                                                                          one will be used or the last one if all fail.
                                          
                                          External aligner:
                                            --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                  Template of command for external 
                                                                                  aligner
                                          
                                          Mafft aligner:
                                            --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                  Template of command for external 
                                                                                  aligner
                                            --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                  ('map' or 'compact')
                                          
                                          Muscle aligner:
                                            --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                  Template of command for external 
                                                                                  aligner
                                            --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                  ('map' or 'compact')
                                          
                                          Internal aligner:
                                            --batch arg (=100)          batch size for pair aligner
                                            --gap-penalty arg (=2)      Gap open or extension penalty
                                            --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                        states of pair alignment. The more gap_range, the
                                                                        more time.
                                            --max-errors arg (=11)      Max number of errors in pair alignment
                                            --mismatch-penalty arg (=1) Mismatch penalty
                                          
                                          Align blocks with high similarity:
                                            --aligned-check arg (=10) Min equal aligned part
                                            --gap-check arg (=2)      Min number of equal columns after single gap
                                            --min-length arg (=100)   Min length of fragment
                                            --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                          
                                          Blocks to consensus sequences:
                                            --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                                               ('asis', 'compact' or 'compact_low_n')
                                          
                                          FilterSeqs:
                                            --blast-min-length arg (=100) min length of blast hit
                                          
                                          Output block set:
                                            --out-export-alignment arg (=1) use alignment information if available
                                            --out-export-contents arg (=1)  print contents of fragments
                                            --out-mask arg                  mask of output files (${block} is replaced 
                                                                            with block name)
                                          
                                          Blast runner:
                                            --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                                            --evalue arg (=0.001)                 Max acceptable e-value of hit
                                            --skip-low-complexity-regions arg (=0)
                                                                                  Tell blast not to search in low 
                                                                                  complexity regions
                                          
                                          Copy file:
                                            --blast-cons-dst arg (=:null) Destination of copy
                                          
                                          Copy file:
                                            --blast-hits-dst arg (=:null) Destination of copy
                                          
                                          Remove all blocks and/or sequences from blockset:
                                            --clear-blocks arg (=1) Remove blocks
                                            --clear-bsas arg (=1)   Remove block set alignments
                                          
                                          Any processor:
                                            --smth-opts arg         options for processor
                                          
                                          Realign blocks:
                                            --force-realign arg (=0) If realigned block is worse, realign anyway
                                          
                                          
                                          Joiner
                                          Join blocks
                                          Joiner: Join blocks
                                              MetaAligner: Align blocks with one of possible aligners
                                                  ExternalAligner: External aligner
                                                  MafftAligner: Mafft aligner
                                                  MuscleAligner: Muscle aligner
                                                  MultipleAligner: Internal aligner
                                                  SimilarAligner: Align blocks with high similarity
                                                  DummyAligner: Align by adding gaps to sequences
                                          
                                          • target: Target blockset
                                          
                                          Join blocks:
                                            --join-max-dist arg (=-1)    Max allowed distance when joining fragments
                                            --join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio 
                                                                         when joining fragments
                                            --join-to-gap arg (=-1)      Max allowed ratio of gaps' lengths (inside a 
                                                                         block) when joining
                                          
                                          Align blocks with one of possible aligners:
                                            --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                          multiple, similar, dummy). Specify several 
                                                                          types, separated by comma, the first working 
                                                                          one will be used or the last one if all fail.
                                            --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                          'compact')
                                          
                                          External aligner:
                                            --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                  Template of command for external 
                                                                                  aligner
                                          
                                          Mafft aligner:
                                            --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                  Template of command for external 
                                                                                  aligner
                                            --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                  ('map' or 'compact')
                                          
                                          Muscle aligner:
                                            --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                  Template of command for external 
                                                                                  aligner
                                            --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                  ('map' or 'compact')
                                          
                                          Internal aligner:
                                            --batch arg (=100)          batch size for pair aligner
                                            --gap-penalty arg (=2)      Gap open or extension penalty
                                            --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                        states of pair alignment. The more gap_range, the
                                                                        more time.
                                            --max-errors arg (=11)      Max number of errors in pair alignment
                                            --mismatch-penalty arg (=1) Mismatch penalty
                                          
                                          Align blocks with high similarity:
                                            --aligned-check arg (=10) Min equal aligned part
                                            --gap-check arg (=2)      Min number of equal columns after single gap
                                            --min-identity arg (=0.9) Min identity of block
                                            --min-length arg (=100)   Min length of fragment
                                            --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                          
                                          
                                          JoinerP
                                          JoinerP: JoinerP
                                              Filter: Filter blocks
                                              OriByMajority: Set ori so that most nucleotides have ori=1
                                              Rest: Add to target blocks of nucleotides, not included to other
                                              MergeUnique: Merge unique fragments with both common neighbours
                                              MetaAligner: Align blocks with one of possible aligners
                                                  ExternalAligner: External aligner
                                                  MafftAligner: Mafft aligner
                                                  MuscleAligner: Muscle aligner
                                                  MultipleAligner: Internal aligner
                                                  SimilarAligner: Align blocks with high similarity
                                                  DummyAligner: Align by adding gaps to sequences
                                              Joiner: Join blocks
                                                  MetaAligner: Align blocks with one of possible aligners
                                                      ExternalAligner: External aligner
                                                      MafftAligner: Mafft aligner
                                                      MuscleAligner: Muscle aligner
                                                      MultipleAligner: Internal aligner
                                                      SimilarAligner: Align blocks with high similarity
                                                      DummyAligner: Align by adding gaps to sequences
                                              Rest: Add to target blocks of nucleotides, not included to other
                                          
                                            
                                            Filter blocks:
                                              --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                              --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                         other blockset
                                              --max-block arg (=-1)      Maximum block size (-1 = all)
                                              --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                              --max-gaps arg (=0.2)      Max gap columns percentage
                                              --max-identity arg (=1)    Maximum block identity
                                              --max-spreading arg (=0.2) Maximum fragment length spreading
                                              --min-block arg (=2)       Minimum block size
                                              --min-fragment arg (=100)  Minimum fragment length
                                              --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                         known)
                                              --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                         known, columns without gaps as 1, columns with 
                                                                         gaps as 0.5)
                                              --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                         avg)
                                            
                                            Add to target blocks of nucleotides, not included to other:
                                              --skip-rest arg (=0)  do not add unique fragments to block set
                                            
                                            Align blocks with one of possible aligners:
                                              --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                            multiple, similar, dummy). Specify several 
                                                                            types, separated by comma, the first working 
                                                                            one will be used or the last one if all fail.
                                              --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                            'compact')
                                            
                                            External aligner:
                                              --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                    Template of command for external 
                                                                                    aligner
                                            
                                            Mafft aligner:
                                              --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                    Template of command for external 
                                                                                    aligner
                                              --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                    ('map' or 'compact')
                                            
                                            Muscle aligner:
                                              --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                    Template of command for external 
                                                                                    aligner
                                              --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                    ('map' or 'compact')
                                            
                                            Internal aligner:
                                              --batch arg (=100)          batch size for pair aligner
                                              --gap-penalty arg (=2)      Gap open or extension penalty
                                              --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                          states of pair alignment. The more gap_range, the
                                                                          more time.
                                              --max-errors arg (=11)      Max number of errors in pair alignment
                                              --mismatch-penalty arg (=1) Mismatch penalty
                                            
                                            Align blocks with high similarity:
                                              --aligned-check arg (=10) Min equal aligned part
                                              --gap-check arg (=2)      Min number of equal columns after single gap
                                              --min-length arg (=100)   Min length of fragment
                                              --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                            
                                            Join blocks:
                                              --join-max-dist arg (=-1)    Max allowed distance when joining fragments
                                              --join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio 
                                                                           when joining fragments
                                              --join-to-gap arg (=-1)      Max allowed ratio of gaps' lengths (inside a 
                                                                           block) when joining
                                            
                                            
                                            LinkEqualFragments
                                            Link fragments equal to fragments from other block set
                                            
                                            
                                            • other: Blockset fragments of which are searched in target blockset
                                            • target: Blockset where fragments, equal to ones from other blockset, are replaced and blocks are marked as weak
                                            
                                            
                                            LiteAlign
                                            Align, move and cut gap
                                            LiteAlign: Align, move and cut gap
                                                MetaAligner: Align blocks with one of possible aligners
                                                    ExternalAligner: External aligner
                                                    MafftAligner: Mafft aligner
                                                    MuscleAligner: Muscle aligner
                                                    MultipleAligner: Internal aligner
                                                    SimilarAligner: Align blocks with high similarity
                                                    DummyAligner: Align by adding gaps to sequences
                                                LiteAlignLoop: LiteAlignLoop
                                                    MoveGaps: Move terminal letters inside
                                                    CutGaps: Cut terminal gaps
                                            
                                            • target: Aligned blockset
                                            
                                            Align blocks with one of possible aligners:
                                              --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                            multiple, similar, dummy). Specify several 
                                                                            types, separated by comma, the first working 
                                                                            one will be used or the last one if all fail.
                                              --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                            'compact')
                                            
                                            External aligner:
                                              --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                    Template of command for external 
                                                                                    aligner
                                            
                                            Mafft aligner:
                                              --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                    Template of command for external 
                                                                                    aligner
                                              --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                    ('map' or 'compact')
                                            
                                            Muscle aligner:
                                              --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                    Template of command for external 
                                                                                    aligner
                                              --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                    ('map' or 'compact')
                                            
                                            Internal aligner:
                                              --batch arg (=100)          batch size for pair aligner
                                              --gap-penalty arg (=2)      Gap open or extension penalty
                                              --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                          states of pair alignment. The more gap_range, the
                                                                          more time.
                                              --max-errors arg (=11)      Max number of errors in pair alignment
                                              --mismatch-penalty arg (=1) Mismatch penalty
                                            
                                            Align blocks with high similarity:
                                              --aligned-check arg (=10) Min equal aligned part
                                              --gap-check arg (=2)      Min number of equal columns after single gap
                                              --min-identity arg (=0.9) Min identity of block
                                              --min-length arg (=100)   Min length of fragment
                                              --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                            
                                            Move terminal letters inside:
                                              --max-tail arg (=3)        Max length of tail
                                              --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                            
                                            Cut terminal gaps:
                                              --cut-strict arg (=0) cut more gaps
                                            
                                            
                                            LiteFilter
                                            Filter blocks (checks only frangment length and block size)
                                            
                                            
                                              
                                              Filter blocks (checks only frangment length and block size):
                                                --min-block arg (=2)        Minimum block size
                                                --min-fragment arg (=100)   Minimum fragment length
                                                --remove-fragments arg (=1) Delete individual fragments instead of whole 
                                                                            block
                                              
                                              
                                              LiteJoinerP
                                              LiteJoinerP: LiteJoinerP
                                                  LiteFilter: Filter blocks (checks only frangment length and block size)
                                                  OriByMajority: Set ori so that most nucleotides have ori=1
                                                  Joiner: Join blocks
                                                      MetaAligner: Align blocks with one of possible aligners
                                                          ExternalAligner: External aligner
                                                          MafftAligner: Mafft aligner
                                                          MuscleAligner: Muscle aligner
                                                          MultipleAligner: Internal aligner
                                                          SimilarAligner: Align blocks with high similarity
                                                          DummyAligner: Align by adding gaps to sequences
                                              
                                                
                                                Filter blocks (checks only frangment length and block size):
                                                  --min-block arg (=2)        Minimum block size
                                                  --min-fragment arg (=100)   Minimum fragment length
                                                  --remove-fragments arg (=1) Delete individual fragments instead of whole 
                                                                              block
                                                
                                                Join blocks:
                                                  --join-max-dist arg (=-1)    Max allowed distance when joining fragments
                                                  --join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio 
                                                                               when joining fragments
                                                  --join-to-gap arg (=-1)      Max allowed ratio of gaps' lengths (inside a 
                                                                               block) when joining
                                                
                                                Align blocks with one of possible aligners:
                                                  --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                multiple, similar, dummy). Specify several 
                                                                                types, separated by comma, the first working 
                                                                                one will be used or the last one if all fail.
                                                  --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                'compact')
                                                
                                                External aligner:
                                                  --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                        Template of command for external 
                                                                                        aligner
                                                
                                                Mafft aligner:
                                                  --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                        Template of command for external 
                                                                                        aligner
                                                  --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                        ('map' or 'compact')
                                                
                                                Muscle aligner:
                                                  --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                        Template of command for external 
                                                                                        aligner
                                                  --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                        ('map' or 'compact')
                                                
                                                Internal aligner:
                                                  --batch arg (=100)          batch size for pair aligner
                                                  --gap-penalty arg (=2)      Gap open or extension penalty
                                                  --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                              states of pair alignment. The more gap_range, the
                                                                              more time.
                                                  --max-errors arg (=11)      Max number of errors in pair alignment
                                                  --mismatch-penalty arg (=1) Mismatch penalty
                                                
                                                Align blocks with high similarity:
                                                  --aligned-check arg (=10) Min equal aligned part
                                                  --gap-check arg (=2)      Min number of equal columns after single gap
                                                  --min-identity arg (=0.9) Min identity of block
                                                  --min-length arg (=100)   Min length of fragment
                                                  --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                
                                                
                                                MafftAligner
                                                Mafft aligner
                                                
                                                
                                                • target: Target blockset
                                                
                                                Mafft aligner:
                                                  --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                        Template of command for external 
                                                                                        aligner
                                                  --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                        ('map' or 'compact')
                                                
                                                
                                                MakePangenome
                                                MakePangenome: MakePangenome
                                                    AnchorJoinerFast: AnchorJoinerFast
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        Info: Print human readable summary and statistics
                                                            Stats: Print human readable summary and statistics about block set
                                                    AnchorJoiner: AnchorJoiner
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        Info: Print human readable summary and statistics
                                                            Stats: Print human readable summary and statistics about block set
                                                    AnchorBlastJoiner: AnchorBlastJoiner
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        TrySmth: Try to do something, align (and filter), restore original if worse
                                                            Union: Add clones of blocks from other to this block set
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            MetaProcessor: Any processor
                                                            RemoveNames: Remove all blocks and/or sequences names
                                                            Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                SelfOverlapsResolver: Resolve self-overlaps
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                AlignLoop: AlignLoop
                                                                    MoveGaps: Move terminal letters inside
                                                                    CutGaps: Cut terminal gaps
                                                                    Filter: Filter blocks
                                                            Move: Move all blocks from other blockset to target blockset
                                                            AddingLoopBySize: Align and move overlapless from other to target
                                                                AddingLoop: AddingLoop
                                                                    Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        SelfOverlapsResolver: Resolve self-overlaps
                                                                        MetaAligner: Align blocks with one of possible aligners
                                                                            ExternalAligner: External aligner
                                                                            MafftAligner: Mafft aligner
                                                                            MuscleAligner: Muscle aligner
                                                                            MultipleAligner: Internal aligner
                                                                            SimilarAligner: Align blocks with high similarity
                                                                            DummyAligner: Align by adding gaps to sequences
                                                                        AlignLoop: AlignLoop
                                                                            MoveGaps: Move terminal letters inside
                                                                            CutGaps: Cut terminal gaps
                                                                            Filter: Filter blocks
                                                                    SmthUnion: SmthUnion
                                                            UniqueNames: Set unique names to all blocks of this block set
                                                            ReAlign: Realign blocks
                                                                MetaAligner: Align blocks with one of possible aligners
                                                                    ExternalAligner: External aligner
                                                                    MafftAligner: Mafft aligner
                                                                    MuscleAligner: Muscle aligner
                                                                    MultipleAligner: Internal aligner
                                                                    SimilarAligner: Align blocks with high similarity
                                                                    DummyAligner: Align by adding gaps to sequences
                                                                Filter: Filter blocks
                                                            Clear: Remove all blocks and/or sequences from blockset
                                                        Hash: Print hash of blockset
                                                        Info: Print human readable summary and statistics
                                                            Stats: Print human readable summary and statistics about block set
                                                    RemoveNames: Remove all blocks and/or sequences names
                                                    UniqueNames: Set unique names to all blocks of this block set
                                                    Rest: Add to target blocks of nucleotides, not included to other
                                                    MergeUnique: Merge unique fragments with both common neighbours
                                                    MetaAligner: Align blocks with one of possible aligners
                                                        ExternalAligner: External aligner
                                                        MafftAligner: Mafft aligner
                                                        MuscleAligner: Muscle aligner
                                                        MultipleAligner: Internal aligner
                                                        SimilarAligner: Align blocks with high similarity
                                                        DummyAligner: Align by adding gaps to sequences
                                                
                                                  
                                                  Print hash of blockset:
                                                    --hash-file arg         Output file with blockset hash
                                                    --remove-after arg (=0) remove file hash-file
                                                  
                                                  Any processor:
                                                    --smth-opts arg         options for processor
                                                  
                                                  Align blocks with one of possible aligners:
                                                    --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                  multiple, similar, dummy). Specify several 
                                                                                  types, separated by comma, the first working 
                                                                                  one will be used or the last one if all fail.
                                                    --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                  'compact')
                                                  
                                                  External aligner:
                                                    --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                          Template of command for external 
                                                                                          aligner
                                                  
                                                  Mafft aligner:
                                                    --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                          Template of command for external 
                                                                                          aligner
                                                    --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                          ('map' or 'compact')
                                                  
                                                  Muscle aligner:
                                                    --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                          Template of command for external 
                                                                                          aligner
                                                    --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                          ('map' or 'compact')
                                                  
                                                  Internal aligner:
                                                    --batch arg (=100)          batch size for pair aligner
                                                    --gap-penalty arg (=2)      Gap open or extension penalty
                                                    --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                states of pair alignment. The more gap_range, the
                                                                                more time.
                                                    --max-errors arg (=11)      Max number of errors in pair alignment
                                                    --mismatch-penalty arg (=1) Mismatch penalty
                                                  
                                                  Align blocks with high similarity:
                                                    --aligned-check arg (=10) Min equal aligned part
                                                    --gap-check arg (=2)      Min number of equal columns after single gap
                                                    --min-identity arg (=0.9) Min identity of block
                                                    --min-length arg (=100)   Min length of fragment
                                                    --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                  
                                                  Move terminal letters inside:
                                                    --max-tail arg (=3)        Max length of tail
                                                    --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                  
                                                  Cut terminal gaps:
                                                    --cut-strict arg (=0) cut more gaps
                                                  
                                                  Filter blocks:
                                                    --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                    --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                               other blockset
                                                    --max-block arg (=-1)      Maximum block size (-1 = all)
                                                    --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                    --max-gaps arg (=0.2)      Max gap columns percentage
                                                    --max-identity arg (=1)    Maximum block identity
                                                    --max-spreading arg (=0.2) Maximum fragment length spreading
                                                    --min-block arg (=2)       Minimum block size
                                                    --min-fragment arg (=100)  Minimum fragment length
                                                    --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                               known)
                                                    --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                               avg)
                                                  
                                                  Realign blocks:
                                                    --force-realign arg (=0) If realigned block is worse, realign anyway
                                                  
                                                  Print human readable summary and statistics about block set:
                                                    --out-stats arg       Output file with statistics
                                                  
                                                  Add to target blocks of nucleotides, not included to other:
                                                    --skip-rest arg (=0)  do not add unique fragments to block set
                                                  
                                                  
                                                  MarkNonWeak
                                                  Mark all blocks non-weak
                                                  
                                                  
                                                  • target: Target blockset
                                                  
                                                  
                                                  MergeStemJoin
                                                  MergeStemJoin: MergeStemJoin
                                                      Rest: Add to target blocks of nucleotides, not included to other
                                                      MergeUnique: Merge unique fragments with both common neighbours
                                                      MetaAligner: Align blocks with one of possible aligners
                                                          ExternalAligner: External aligner
                                                          MafftAligner: Mafft aligner
                                                          MuscleAligner: Muscle aligner
                                                          MultipleAligner: Internal aligner
                                                          SimilarAligner: Align blocks with high similarity
                                                          DummyAligner: Align by adding gaps to sequences
                                                      Stem: Filter out blocks not represented in at least one of genomes
                                                      Joiner: Join blocks
                                                          MetaAligner: Align blocks with one of possible aligners
                                                              ExternalAligner: External aligner
                                                              MafftAligner: Mafft aligner
                                                              MuscleAligner: Muscle aligner
                                                              MultipleAligner: Internal aligner
                                                              SimilarAligner: Align blocks with high similarity
                                                              DummyAligner: Align by adding gaps to sequences
                                                  
                                                    
                                                    Add to target blocks of nucleotides, not included to other:
                                                      --skip-rest arg (=0)  do not add unique fragments to block set
                                                    
                                                    Align blocks with one of possible aligners:
                                                      --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                    multiple, similar, dummy). Specify several 
                                                                                    types, separated by comma, the first working 
                                                                                    one will be used or the last one if all fail.
                                                      --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                    'compact')
                                                    
                                                    External aligner:
                                                      --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                            Template of command for external 
                                                                                            aligner
                                                    
                                                    Mafft aligner:
                                                      --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                            Template of command for external 
                                                                                            aligner
                                                      --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                            ('map' or 'compact')
                                                    
                                                    Muscle aligner:
                                                      --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                            Template of command for external 
                                                                                            aligner
                                                      --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                            ('map' or 'compact')
                                                    
                                                    Internal aligner:
                                                      --batch arg (=100)          batch size for pair aligner
                                                      --gap-penalty arg (=2)      Gap open or extension penalty
                                                      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                  states of pair alignment. The more gap_range, the
                                                                                  more time.
                                                      --max-errors arg (=11)      Max number of errors in pair alignment
                                                      --mismatch-penalty arg (=1) Mismatch penalty
                                                    
                                                    Align blocks with high similarity:
                                                      --aligned-check arg (=10) Min equal aligned part
                                                      --gap-check arg (=2)      Min number of equal columns after single gap
                                                      --min-identity arg (=0.9) Min identity of block
                                                      --min-length arg (=100)   Min length of fragment
                                                      --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                    
                                                    Join blocks:
                                                      --join-max-dist arg (=-1)    Max allowed distance when joining fragments
                                                      --join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio 
                                                                                   when joining fragments
                                                      --join-to-gap arg (=-1)      Max allowed ratio of gaps' lengths (inside a 
                                                                                   block) when joining
                                                    
                                                    
                                                    MergeUnique
                                                    Merge unique fragments with both common neighbours
                                                    
                                                    
                                                    • target: Target blockset
                                                    
                                                    
                                                    MetaAligner
                                                    Align blocks with one of possible aligners
                                                    MetaAligner: Align blocks with one of possible aligners
                                                        ExternalAligner: External aligner
                                                        MafftAligner: Mafft aligner
                                                        MuscleAligner: Muscle aligner
                                                        MultipleAligner: Internal aligner
                                                        SimilarAligner: Align blocks with high similarity
                                                        DummyAligner: Align by adding gaps to sequences
                                                    
                                                    • target: Target blockset
                                                    
                                                    Align blocks with one of possible aligners:
                                                      --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                    multiple, similar, dummy). Specify several 
                                                                                    types, separated by comma, the first working 
                                                                                    one will be used or the last one if all fail.
                                                      --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                    'compact')
                                                    
                                                    External aligner:
                                                      --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                            Template of command for external 
                                                                                            aligner
                                                    
                                                    Mafft aligner:
                                                      --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                            Template of command for external 
                                                                                            aligner
                                                      --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                            ('map' or 'compact')
                                                    
                                                    Muscle aligner:
                                                      --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                            Template of command for external 
                                                                                            aligner
                                                      --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                            ('map' or 'compact')
                                                    
                                                    Internal aligner:
                                                      --batch arg (=100)          batch size for pair aligner
                                                      --gap-penalty arg (=2)      Gap open or extension penalty
                                                      --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                  states of pair alignment. The more gap_range, the
                                                                                  more time.
                                                      --max-errors arg (=11)      Max number of errors in pair alignment
                                                      --mismatch-penalty arg (=1) Mismatch penalty
                                                    
                                                    Align blocks with high similarity:
                                                      --aligned-check arg (=10) Min equal aligned part
                                                      --gap-check arg (=2)      Min number of equal columns after single gap
                                                      --min-identity arg (=0.9) Min identity of block
                                                      --min-length arg (=100)   Min length of fragment
                                                      --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                    
                                                    
                                                    MetaProcessor
                                                    Any processor
                                                    
                                                    
                                                    • other: Other blockset
                                                    • target: Target blockset
                                                    
                                                    Any processor:
                                                      --opts arg            options for processor
                                                      --processor arg       processor name
                                                    
                                                    
                                                    MkDir
                                                    Create directory
                                                    
                                                    
                                                      
                                                      Create directory:
                                                        --dirname arg         Dir to be created
                                                      
                                                      
                                                      Move
                                                      Move all blocks from other blockset to target blockset
                                                      
                                                      
                                                      • other: Source from where blocks are moved
                                                      • target: Destination to where blocks are moved
                                                      
                                                      
                                                      MoveGaps
                                                      Move terminal letters inside
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      Move terminal letters inside:
                                                        --max-tail arg (=3)        Max length of tail
                                                        --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                        --row-type arg (=compact)  way of storing alignments in memory ('map' or 
                                                                                   'compact')
                                                      
                                                      
                                                      MoveUnchanged
                                                      Move unchanged blocks from other to target
                                                      
                                                      
                                                      • other: Where unchanged blocks are looked for
                                                      • target: Where unchanged blocks are moved to
                                                      
                                                      
                                                      MultipleAligner
                                                      Internal aligner
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      Internal aligner:
                                                        --batch arg (=100)          batch size for pair aligner
                                                        --gap-penalty arg (=2)      Gap open or extension penalty
                                                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                    states of pair alignment. The more gap_range, the
                                                                                    more time.
                                                        --max-errors arg (=11)      Max number of errors in pair alignment
                                                        --mismatch-penalty arg (=1) Mismatch penalty
                                                        --row-type arg (=compact)   way of storing alignments in memory ('map' or 
                                                                                    'compact')
                                                      
                                                      
                                                      MuscleAligner
                                                      Muscle aligner
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      Muscle aligner:
                                                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      
                                                      MutationsSequences
                                                      Create a seq. per genome of mutations and map blocks
                                                      MutationsSequences: Create a seq. per genome of mutations and map blocks
                                                          PrintMutations: Find all mutations in block
                                                      
                                                      • other: Exact Stem of pangenome
                                                      • target: Where new sequences composed from mutationsare added
                                                      
                                                      Create a seq. per genome of mutations and map blocks:
                                                        --mutation-distance arg (=0)       Distance to sequence around mutation to 
                                                                                           keep
                                                        --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                                                           ('asis', 'compact' or 'compact_low_n')
                                                      
                                                      Find all mutations in block:
                                                        --file arg            output file with all blocks
                                                        --mask arg            mask of output files (${block} is replaced with block 
                                                                              name)
                                                      
                                                      
                                                      OldMakePangenome
                                                      Run blast and Joiner until this block set becomes pangenome (deprecated)
                                                      OldMakePangenome: Run blast and Joiner until this block set becomes pangenome (deprecated)
                                                          Filter: Filter blocks
                                                          Clear: Remove all blocks and/or sequences from blockset
                                                          Union: Add clones of blocks from other to this block set
                                                          Joiner: Join blocks
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                          Filter: Filter blocks
                                                          Align: LiteAlign + Filter + SelfOverlapsResolver
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              SelfOverlapsResolver: Resolve self-overlaps
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              AlignLoop: AlignLoop
                                                                  MoveGaps: Move terminal letters inside
                                                                  CutGaps: Cut terminal gaps
                                                                  Filter: Filter blocks
                                                          Filter: Filter blocks
                                                          OverlaplessUnion: Add clones of blocks from other, non-overlapping target
                                                          Clear: Remove all blocks and/or sequences from blockset
                                                          Rest: Add to target blocks of nucleotides, not included to other
                                                          AddBlastBlocks: Add blast hits as blocks
                                                              SequencesFromOther: Copy sequences from other block set
                                                              ConSeq: Blocks to consensus sequences
                                                              FilterSeqs: FilterSeqs
                                                              BlastFinder: BlastFinder
                                                                  Output: Output block set
                                                                  BlastRunner: Blast runner
                                                                  ImportBlastHits: Import blast hits
                                                                  FileCopy: Copy file
                                                                  FileCopy: Copy file
                                                                  FileRemover: Remove file
                                                                  FileRemover: Remove file
                                                              DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                                                              Clear: Remove all blocks and/or sequences from blockset
                                                          OneByOne: Split blockset according to hits, processed one by one
                                                              Filter: Filter blocks
                                                              LiteAlign: Align, move and cut gap
                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                      ExternalAligner: External aligner
                                                                      MafftAligner: Mafft aligner
                                                                      MuscleAligner: Muscle aligner
                                                                      MultipleAligner: Internal aligner
                                                                      SimilarAligner: Align blocks with high similarity
                                                                      DummyAligner: Align by adding gaps to sequences
                                                                  LiteAlignLoop: LiteAlignLoop
                                                                      MoveGaps: Move terminal letters inside
                                                                      CutGaps: Cut terminal gaps
                                                          Filter: Filter blocks
                                                          Align: LiteAlign + Filter + SelfOverlapsResolver
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              SelfOverlapsResolver: Resolve self-overlaps
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              AlignLoop: AlignLoop
                                                                  MoveGaps: Move terminal letters inside
                                                                  CutGaps: Cut terminal gaps
                                                                  Filter: Filter blocks
                                                          Filter: Filter blocks
                                                          Rest: Add to target blocks of nucleotides, not included to other
                                                          RemoveNames: Remove all blocks and/or sequences names
                                                          UniqueNames: Set unique names to all blocks of this block set
                                                          Info: Print human readable summary and statistics
                                                              Stats: Print human readable summary and statistics about block set
                                                      
                                                      • target: Target blockset with pre-pangenome, which is evolved to pangenome
                                                      
                                                      Filter blocks:
                                                        --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                        --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                   other blockset
                                                        --max-block arg (=-1)      Maximum block size (-1 = all)
                                                        --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                        --max-gaps arg (=0.2)      Max gap columns percentage
                                                        --max-identity arg (=1)    Maximum block identity
                                                        --max-spreading arg (=0.2) Maximum fragment length spreading
                                                        --min-block arg (=2)       Minimum block size
                                                        --min-fragment arg (=100)  Minimum fragment length
                                                        --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                   known)
                                                        --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                                   known, columns without gaps as 1, columns with 
                                                                                   gaps as 0.5)
                                                        --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                   avg)
                                                      
                                                      Remove all blocks and/or sequences from blockset:
                                                        --clear-blocks arg (=1) Remove blocks
                                                        --clear-bsas arg (=1)   Remove block set alignments
                                                        --clear-seqs arg (=0)   Remove sequences (warning: this makes dangling 
                                                                                pointers from orphaned blocks, if they remain)
                                                      
                                                      Join blocks:
                                                        --join-max-dist arg (=-1)    Max allowed distance when joining fragments
                                                        --join-to-fragment arg (=-1) Max allowed gap length to fragment length ratio 
                                                                                     when joining fragments
                                                        --join-to-gap arg (=-1)      Max allowed ratio of gaps' lengths (inside a 
                                                                                     block) when joining
                                                      
                                                      Align blocks with one of possible aligners:
                                                        --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                      multiple, similar, dummy). Specify several 
                                                                                      types, separated by comma, the first working 
                                                                                      one will be used or the last one if all fail.
                                                        --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                      'compact')
                                                      
                                                      External aligner:
                                                        --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                      
                                                      Mafft aligner:
                                                        --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Muscle aligner:
                                                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Internal aligner:
                                                        --batch arg (=100)          batch size for pair aligner
                                                        --gap-penalty arg (=2)      Gap open or extension penalty
                                                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                    states of pair alignment. The more gap_range, the
                                                                                    more time.
                                                        --max-errors arg (=11)      Max number of errors in pair alignment
                                                        --mismatch-penalty arg (=1) Mismatch penalty
                                                      
                                                      Align blocks with high similarity:
                                                        --aligned-check arg (=10) Min equal aligned part
                                                        --gap-check arg (=2)      Min number of equal columns after single gap
                                                        --min-length arg (=100)   Min length of fragment
                                                        --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                      
                                                      Move terminal letters inside:
                                                        --max-tail arg (=3)        Max length of tail
                                                        --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                      
                                                      Cut terminal gaps:
                                                        --cut-strict arg (=0) cut more gaps
                                                      
                                                      Add clones of blocks from other, non-overlapping target:
                                                        --ou-filter arg (=0)  Do not copy good blocks to target, but remove bad 
                                                                              blocks from other
                                                        --ou-move arg (=0)    Move blocks from other to target
                                                      
                                                      Add to target blocks of nucleotides, not included to other:
                                                        --skip-rest arg (=0)  do not add unique fragments to block set
                                                      
                                                      Blocks to consensus sequences:
                                                        --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                                                           ('asis', 'compact' or 'compact_low_n')
                                                      
                                                      FilterSeqs:
                                                        --blast-min-length arg (=100) min length of blast hit
                                                      
                                                      Output block set:
                                                        --out-export-alignment arg (=1) use alignment information if available
                                                        --out-export-contents arg (=1)  print contents of fragments
                                                        --out-mask arg                  mask of output files (${block} is replaced 
                                                                                        with block name)
                                                      
                                                      Blast runner:
                                                        --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                                                        --evalue arg (=0.001)                 Max acceptable e-value of hit
                                                        --remove-after arg (=0)               remove file out-hits
                                                        --skip-low-complexity-regions arg (=0)
                                                                                              Tell blast not to search in low 
                                                                                              complexity regions
                                                      
                                                      Copy file:
                                                        --blast-cons-dst arg (=:null) Destination of copy
                                                      
                                                      Copy file:
                                                        --blast-hits-dst arg (=:null) Destination of copy
                                                      
                                                      Remove all blocks and/or sequences names:
                                                        --remove-blocks-names arg (=1) Remove blocks names
                                                      
                                                      Print human readable summary and statistics about block set:
                                                        --out-stats arg       Output file with statistics
                                                      
                                                      
                                                      OldMakePrePangenome
                                                      Run anchor finder, expand blocks and resolve overlaps (deprecated)
                                                      OldMakePrePangenome: Run anchor finder, expand blocks and resolve overlaps (deprecated)
                                                          AnchorFinder: Find anchors
                                                          Connector: Connect all the fragments (prev-next)
                                                          FragmentsExpander: Expand fragments (deprecated)
                                                          Filter: Filter blocks
                                                          OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
                                                          Filter: Filter blocks
                                                          FragmentsExpander: Expand fragments (deprecated)
                                                          OverlapsResolver2: Resolve overlaping fragments (version 2, deprecated)
                                                          Align: LiteAlign + Filter + SelfOverlapsResolver
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              SelfOverlapsResolver: Resolve self-overlaps
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              AlignLoop: AlignLoop
                                                                  MoveGaps: Move terminal letters inside
                                                                  CutGaps: Cut terminal gaps
                                                                  Filter: Filter blocks
                                                          Filter: Filter blocks
                                                          Rest: Add to target blocks of nucleotides, not included to other
                                                      
                                                      • target: Target blockset with sequences on which pre-pangenome is built
                                                      
                                                      Find anchors:
                                                        --anchor-fp arg (=0.1)               Probability of false positive in Bloom 
                                                                                             filter (first step of AnchorFinder)
                                                        --anchor-similar arg (=1)            If neighbour anchors are skipped
                                                        --anchor-size arg (=20)              anchor size
                                                        --max-anchor-fragments arg (=100000) Maximum number of anchors fragments to 
                                                                                             return
                                                      
                                                      Connect all the fragments (prev-next):
                                                        --connect-circular arg (=0) Connect last and first fragments of circular 
                                                                                    chromosomes
                                                      
                                                      Expand fragments (deprecated):
                                                        --batch arg (=100)          batch size for pair aligner
                                                        --gap-penalty arg (=2)      Gap open or extension penalty
                                                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                    states of pair alignment. The more gap_range, the
                                                                                    more time.
                                                        --max-errors arg (=11)      Max number of errors in pair alignment
                                                        --mismatch-penalty arg (=1) Mismatch penalty
                                                        --ori arg (=0)              direction of expansion
                                                      
                                                      Filter blocks:
                                                        --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                        --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                   other blockset
                                                        --max-block arg (=-1)      Maximum block size (-1 = all)
                                                        --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                        --max-gaps arg (=0.2)      Max gap columns percentage
                                                        --max-identity arg (=1)    Maximum block identity
                                                        --max-spreading arg (=0.2) Maximum fragment length spreading
                                                        --min-block arg (=2)       Minimum block size
                                                        --min-fragment arg (=100)  Minimum fragment length
                                                        --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                   known)
                                                        --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                                   known, columns without gaps as 1, columns with 
                                                                                   gaps as 0.5)
                                                        --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                   avg)
                                                      
                                                      Resolve overlaping fragments (version 2, deprecated):
                                                        --min-distance arg (=30) Min distance between fragment boundaries
                                                      
                                                      Align blocks with one of possible aligners:
                                                        --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                      multiple, similar, dummy). Specify several 
                                                                                      types, separated by comma, the first working 
                                                                                      one will be used or the last one if all fail.
                                                        --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                      'compact')
                                                      
                                                      External aligner:
                                                        --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                      
                                                      Mafft aligner:
                                                        --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Muscle aligner:
                                                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Align blocks with high similarity:
                                                        --aligned-check arg (=10) Min equal aligned part
                                                        --gap-check arg (=2)      Min number of equal columns after single gap
                                                        --min-length arg (=100)   Min length of fragment
                                                        --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                      
                                                      Move terminal letters inside:
                                                        --max-tail arg (=3)        Max length of tail
                                                        --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                      
                                                      Cut terminal gaps:
                                                        --cut-strict arg (=0) cut more gaps
                                                      
                                                      Add to target blocks of nucleotides, not included to other:
                                                        --skip-rest arg (=0)  do not add unique fragments to block set
                                                      
                                                      
                                                      OneByOne
                                                      Split blockset according to hits, processed one by one
                                                      OneByOne: Split blockset according to hits, processed one by one
                                                          Filter: Filter blocks
                                                          LiteAlign: Align, move and cut gap
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                              LiteAlignLoop: LiteAlignLoop
                                                                  MoveGaps: Move terminal letters inside
                                                                  CutGaps: Cut terminal gaps
                                                      
                                                      • other: Source of added blocks
                                                      • target: Destination of added blocks
                                                      
                                                      Filter blocks:
                                                        --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                        --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                   other blockset
                                                        --max-block arg (=-1)      Maximum block size (-1 = all)
                                                        --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                        --max-gaps arg (=0.2)      Max gap columns percentage
                                                        --max-identity arg (=1)    Maximum block identity
                                                        --max-spreading arg (=0.2) Maximum fragment length spreading
                                                        --min-block arg (=2)       Minimum block size
                                                        --min-fragment arg (=100)  Minimum fragment length
                                                        --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                   known)
                                                        --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                                   known, columns without gaps as 1, columns with 
                                                                                   gaps as 0.5)
                                                        --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                   avg)
                                                      
                                                      Align blocks with one of possible aligners:
                                                        --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                      multiple, similar, dummy). Specify several 
                                                                                      types, separated by comma, the first working 
                                                                                      one will be used or the last one if all fail.
                                                        --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                      'compact')
                                                      
                                                      External aligner:
                                                        --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                      
                                                      Mafft aligner:
                                                        --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Muscle aligner:
                                                        --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                              Template of command for external 
                                                                                              aligner
                                                        --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                              ('map' or 'compact')
                                                      
                                                      Internal aligner:
                                                        --batch arg (=100)          batch size for pair aligner
                                                        --gap-penalty arg (=2)      Gap open or extension penalty
                                                        --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                    states of pair alignment. The more gap_range, the
                                                                                    more time.
                                                        --max-errors arg (=11)      Max number of errors in pair alignment
                                                        --mismatch-penalty arg (=1) Mismatch penalty
                                                      
                                                      Align blocks with high similarity:
                                                        --aligned-check arg (=10) Min equal aligned part
                                                        --gap-check arg (=2)      Min number of equal columns after single gap
                                                        --min-length arg (=100)   Min length of fragment
                                                        --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                      
                                                      Move terminal letters inside:
                                                        --max-tail arg (=3)        Max length of tail
                                                        --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                      
                                                      Cut terminal gaps:
                                                        --cut-strict arg (=0) cut more gaps
                                                      
                                                      
                                                      OriByMajority
                                                      Set ori so that most nucleotides have ori=1
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      
                                                      Output
                                                      Output block set
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      Output block set:
                                                        --out-dump-block arg (=1)       dump blocks
                                                        --out-dump-seq arg (=0)         dump sequences before blocks
                                                        --out-export-alignment arg (=1) use alignment information if available
                                                        --out-export-contents arg (=1)  print contents of fragments
                                                        --out-file arg                  output file with all blocks
                                                        --out-mask arg                  mask of output files (${block} is replaced 
                                                                                        with block name)
                                                      
                                                      
                                                      OutputPipe
                                                      Grace output
                                                      OutputPipe: Grace output
                                                          OriByMajority: Set ori so that most nucleotides have ori=1
                                                          Connector: Connect all the fragments (prev-next)
                                                          Rest: Add to target blocks of nucleotides, not included to other
                                                          Connector: Connect all the fragments (prev-next)
                                                          UniqueNames: Set unique names to all blocks of this block set
                                                          Output: Output block set
                                                      
                                                      • target: Target blockset
                                                      
                                                      Connect all the fragments (prev-next):
                                                        --connect-circular arg (=0) Connect last and first fragments of circular 
                                                                                    chromosomes
                                                      
                                                      Add to target blocks of nucleotides, not included to other:
                                                        --skip-rest arg (=0)  do not add unique fragments to block set
                                                      
                                                      Output block set:
                                                        --out-dump-block arg (=1)       dump blocks
                                                        --out-dump-seq arg (=0)         dump sequences before blocks
                                                        --out-export-alignment arg (=1) use alignment information if available
                                                        --out-export-contents arg (=1)  print contents of fragments
                                                        --out-file arg                  output file with all blocks
                                                        --out-mask arg                  mask of output files (${block} is replaced 
                                                                                        with block name)
                                                      
                                                      
                                                      OverlapFinder
                                                      Finds blocks from 'bank', overlapping with 'pattern', results are copied to 'hits'
                                                      
                                                      
                                                      • bank: where to find overlapping blocks
                                                      • hits: overlapping blocks from bank are copied here
                                                      • pattern: overlaps are looked for with these blocks
                                                      
                                                      
                                                      OverlaplessUnion
                                                      Add clones of blocks from other, non-overlapping target
                                                      
                                                      
                                                      • other: Source of blocks addition
                                                      • target: Destination of blocks addition
                                                      
                                                      Add clones of blocks from other, non-overlapping target:
                                                        --ou-filter arg (=0)  Do not copy good blocks to target, but remove bad 
                                                                              blocks from other
                                                        --ou-move arg (=0)    Move blocks from other to target
                                                      
                                                      
                                                      OverlapsResolver
                                                      Resolve overlaping fragments (deprecated)
                                                      
                                                      
                                                      • target: Target blockset
                                                      
                                                      
                                                      OverlapsResolver2
                                                      Resolve overlaping fragments (version 2, deprecated)
                                                      
                                                      
                                                      • other: Where input blocks are taken
                                                      • target: Where resolved blocks are added
                                                      
                                                      Resolve overlaping fragments (version 2, deprecated):
                                                        --min-distance arg (=30) Min distance between fragment boundaries
                                                      
                                                      
                                                      Pangenome
                                                      Pangenome: Pangenome
                                                          In: Input block set
                                                          MakePangenome: MakePangenome
                                                              AnchorJoinerFast: AnchorJoinerFast
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  Info: Print human readable summary and statistics
                                                                      Stats: Print human readable summary and statistics about block set
                                                              AnchorJoiner: AnchorJoiner
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  Info: Print human readable summary and statistics
                                                                      Stats: Print human readable summary and statistics about block set
                                                              AnchorBlastJoiner: AnchorBlastJoiner
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  Hash: Print hash of blockset
                                                                  Info: Print human readable summary and statistics
                                                                      Stats: Print human readable summary and statistics about block set
                                                              RemoveNames: Remove all blocks and/or sequences names
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Rest: Add to target blocks of nucleotides, not included to other
                                                              MergeUnique: Merge unique fragments with both common neighbours
                                                              MetaAligner: Align blocks with one of possible aligners
                                                                  ExternalAligner: External aligner
                                                                  MafftAligner: Mafft aligner
                                                                  MuscleAligner: Muscle aligner
                                                                  MultipleAligner: Internal aligner
                                                                  SimilarAligner: Align blocks with high similarity
                                                                  DummyAligner: Align by adding gaps to sequences
                                                          OutputPipe: Grace output
                                                              OriByMajority: Set ori so that most nucleotides have ori=1
                                                              Connector: Connect all the fragments (prev-next)
                                                              Rest: Add to target blocks of nucleotides, not included to other
                                                              Connector: Connect all the fragments (prev-next)
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                      
                                                        
                                                        Input block set:
                                                          --in-blocks arg (=genomes-renamed.fasta)
                                                                                                input fasta file(s) with blocks
                                                          --row-type arg (=compact)             way of storing alignments in memory 
                                                                                                ('map' or 'compact')
                                                          --seq-storage arg (=compact_low_n)    way of storing sequences in memory 
                                                                                                ('asis', 'compact' or 'compact_low_n')
                                                        
                                                        Print hash of blockset:
                                                          --hash-file arg         Output file with blockset hash
                                                          --remove-after arg (=0) remove file hash-file
                                                        
                                                        Any processor:
                                                          --smth-opts arg         options for processor
                                                        
                                                        Align blocks with one of possible aligners:
                                                          --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                        multiple, similar, dummy). Specify several 
                                                                                        types, separated by comma, the first working 
                                                                                        one will be used or the last one if all fail.
                                                        
                                                        External aligner:
                                                          --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                Template of command for external 
                                                                                                aligner
                                                        
                                                        Mafft aligner:
                                                          --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                Template of command for external 
                                                                                                aligner
                                                          --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                                ('map' or 'compact')
                                                        
                                                        Muscle aligner:
                                                          --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                                Template of command for external 
                                                                                                aligner
                                                          --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                                ('map' or 'compact')
                                                        
                                                        Internal aligner:
                                                          --batch arg (=100)          batch size for pair aligner
                                                          --gap-penalty arg (=2)      Gap open or extension penalty
                                                          --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                      states of pair alignment. The more gap_range, the
                                                                                      more time.
                                                          --max-errors arg (=11)      Max number of errors in pair alignment
                                                          --mismatch-penalty arg (=1) Mismatch penalty
                                                        
                                                        Align blocks with high similarity:
                                                          --aligned-check arg (=10) Min equal aligned part
                                                          --gap-check arg (=2)      Min number of equal columns after single gap
                                                          --min-identity arg (=0.9) Min identity of block
                                                          --min-length arg (=100)   Min length of fragment
                                                          --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                        
                                                        Move terminal letters inside:
                                                          --max-tail arg (=3)        Max length of tail
                                                          --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                        
                                                        Cut terminal gaps:
                                                          --cut-strict arg (=0) cut more gaps
                                                        
                                                        Filter blocks:
                                                          --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                          --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                     other blockset
                                                          --max-block arg (=-1)      Maximum block size (-1 = all)
                                                          --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                          --max-gaps arg (=0.2)      Max gap columns percentage
                                                          --max-identity arg (=1)    Maximum block identity
                                                          --max-spreading arg (=0.2) Maximum fragment length spreading
                                                          --min-block arg (=2)       Minimum block size
                                                          --min-fragment arg (=100)  Minimum fragment length
                                                          --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                     known)
                                                          --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                     avg)
                                                        
                                                        Realign blocks:
                                                          --force-realign arg (=0) If realigned block is worse, realign anyway
                                                        
                                                        Print human readable summary and statistics about block set:
                                                          --out-stats arg       Output file with statistics
                                                        
                                                        Add to target blocks of nucleotides, not included to other:
                                                          --skip-rest arg (=0)  do not add unique fragments to block set
                                                        
                                                        Connect all the fragments (prev-next):
                                                          --connect-circular arg (=0) Connect last and first fragments of circular 
                                                                                      chromosomes
                                                        
                                                        Output block set:
                                                          --out-dump-block arg (=1)       dump blocks
                                                          --out-dump-seq arg (=0)         dump sequences before blocks
                                                          --out-export-alignment arg (=1) use alignment information if available
                                                          --out-export-contents arg (=1)  print contents of fragments
                                                          --out-file arg (=pangenome.bs)  output file with all blocks
                                                          --out-mask arg                  mask of output files (${block} is replaced 
                                                                                          with block name)
                                                        
                                                        
                                                        Partition
                                                        Split fragments of target according to fragments of other
                                                        
                                                        
                                                        • other: Splitting rules (boundaries)
                                                        • target: Blocks to split
                                                        
                                                        
                                                        Pipe
                                                        
                                                        
                                                          
                                                          
                                                          PostProcessing
                                                          Postprocess pangenome
                                                          PostProcessing: Postprocess pangenome
                                                              In: Input block set
                                                              BlockInfo: Print information about blocks
                                                              Info: Print human readable summary and statistics
                                                                  Stats: Print human readable summary and statistics about block set
                                                              Hash: Print hash of blockset
                                                              Union: Add clones of blocks from other to this block set
                                                              Stem: Filter out blocks not represented in at least one of genomes
                                                              MkDir: Create directory
                                                              IsPangenome: Print if block set is good pangenome
                                                                  AreBlocksGood: Print if all blocks in block set are good
                                                                      MoveGaps: Move terminal letters inside
                                                                      CutGaps: Cut terminal gaps
                                                                      Filter: Filter blocks
                                                                  Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                      MetaAligner: Align blocks with one of possible aligners
                                                                          ExternalAligner: External aligner
                                                                          MafftAligner: Mafft aligner
                                                                          MuscleAligner: Muscle aligner
                                                                          MultipleAligner: Internal aligner
                                                                          SimilarAligner: Align blocks with high similarity
                                                                          DummyAligner: Align by adding gaps to sequences
                                                                      SelfOverlapsResolver: Resolve self-overlaps
                                                                      MetaAligner: Align blocks with one of possible aligners
                                                                          ExternalAligner: External aligner
                                                                          MafftAligner: Mafft aligner
                                                                          MuscleAligner: Muscle aligner
                                                                          MultipleAligner: Internal aligner
                                                                          SimilarAligner: Align blocks with high similarity
                                                                          DummyAligner: Align by adding gaps to sequences
                                                                      AlignLoop: AlignLoop
                                                                          MoveGaps: Move terminal letters inside
                                                                          CutGaps: Cut terminal gaps
                                                                          Filter: Filter blocks
                                                                  AddBlastBlocks: Add blast hits as blocks
                                                                      SequencesFromOther: Copy sequences from other block set
                                                                      ConSeq: Blocks to consensus sequences
                                                                      FilterSeqs: FilterSeqs
                                                                      BlastFinder: BlastFinder
                                                                          Output: Output block set
                                                                          BlastRunner: Blast runner
                                                                          ImportBlastHits: Import blast hits
                                                                          FileCopy: Copy file
                                                                          FileCopy: Copy file
                                                                          FileRemover: Remove file
                                                                          FileRemover: Remove file
                                                                      DeConSeq: Build blocks from blocks, set to sequences of blocks of other
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                              MkDir: Create directory
                                                              PrintMutations: Find all mutations in block
                                                              MutationsSequences: Create a seq. per genome of mutations and map blocks
                                                                  PrintMutations: Find all mutations in block
                                                              Output: Output block set
                                                              Output: Output block set
                                                              MkDir: Create directory
                                                              PrintTree: Build and print newick trees of blocks
                                                                  FragmentDistance: Calculate distance between fragments in block
                                                              ConsensusTree: Print consensus tree
                                                                  BranchGenerator: BranchGenerator
                                                                      PrintTree: Build and print newick trees of blocks
                                                                          FragmentDistance: Calculate distance between fragments in block
                                                              ConsensusTree: Print consensus tree
                                                                  BranchGenerator: BranchGenerator
                                                                      PrintTree: Build and print newick trees of blocks
                                                                          FragmentDistance: Calculate distance between fragments in block
                                                              FragmentDistance: Calculate distance between fragments in block
                                                              ChrBSA: Build block set alignments from all chromosomes
                                                                  FindBSA: Build block set alignment
                                                              PrintBSA: Print block set alignment
                                                              ExactStemBSA: Replace all non-stem blocks with gaps in block set alignment
                                                              PrintBSA: Print block set alignment
                                                              SplitRepeats: Find splittable blocks-repeats and split them
                                                                  PrintTree: Build and print newick trees of blocks
                                                                      FragmentDistance: Calculate distance between fragments in block
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                              FindLowSimilar: Find regions of low similarity in blocks
                                                              UniqueNames: Set unique names to all blocks of this block set
                                                              Output: Output block set
                                                              BlockInfo: Print information about blocks
                                                          
                                                            
                                                            Input block set:
                                                              --in-blocks arg (=pangenome.bs)    input fasta file(s) with blocks
                                                              --row-type arg (=compact)          way of storing alignments in memory ('map'
                                                                                                 or 'compact')
                                                              --seq-storage arg (=compact_low_n) way of storing sequences in memory 
                                                                                                 ('asis', 'compact' or 'compact_low_n')
                                                            
                                                            Print information about blocks:
                                                              --info-mask arg         mask of output files (${block} is replaced with block
                                                                                      name)
                                                            
                                                            Print human readable summary and statistics about block set:
                                                              --out-stats arg (=pangenome.info) Output file with statistics
                                                              --remove-after arg (=0)           remove file out-stats
                                                            
                                                            Print hash of blockset:
                                                              --hash-file arg (=pangenome.hash) Output file with blockset hash
                                                            
                                                            Print if all blocks in block set are good:
                                                              --max-block arg (=-1)                 Maximum block size (-1 = all)
                                                              --max-fragment arg (=-1)              Maximum fragment length (-1 = all)
                                                              --max-gaps arg (=0.2)                 Max gap columns percentage
                                                              --max-identity arg (=1)               Maximum block identity
                                                              --max-spreading arg (=0.2)            Maximum fragment length spreading
                                                              --min-block arg (=2)                  Minimum block size
                                                              --min-fragment arg (=100)             Minimum fragment length
                                                              --min-gaps arg (=0)                   Min gap columns percentage (only if 
                                                                                                    alignment is known)
                                                              --min-identity arg (=0.9)             Minimum block identity (only if 
                                                                                                    alignment is known, columns without 
                                                                                                    gaps as 1, columns with gaps as 0.5)
                                                              --min-spreading arg (=0)              Minimum fragment length spreading ((max
                                                                                                    - min) / avg)
                                                              --out-is-pangenome arg (=check/isgood)
                                                                                                    Output file with verdict
                                                              --respect-minor arg (=1)              Do not check length and alignment of 
                                                                                                    minor blocks
                                                            
                                                            Move terminal letters inside:
                                                              --max-tail arg (=3)        Max length of tail
                                                              --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                            
                                                            Cut terminal gaps:
                                                              --cut-strict arg (=0) cut more gaps
                                                            
                                                            Filter blocks:
                                                              --find-subblocks arg (=1) Find and add good subblocks of bad blocks
                                                              --good-to-other arg (=0)  Do not remove bad blocks, but copy good blocks to 
                                                                                        other blockset
                                                            
                                                            Align blocks with one of possible aligners:
                                                              --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                            multiple, similar, dummy). Specify several 
                                                                                            types, separated by comma, the first working 
                                                                                            one will be used or the last one if all fail.
                                                            
                                                            External aligner:
                                                              --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                    Template of command for external 
                                                                                                    aligner
                                                            
                                                            Mafft aligner:
                                                              --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                    Template of command for external 
                                                                                                    aligner
                                                              --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                                    ('map' or 'compact')
                                                            
                                                            Muscle aligner:
                                                              --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                                    Template of command for external 
                                                                                                    aligner
                                                              --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                                    ('map' or 'compact')
                                                            
                                                            Internal aligner:
                                                              --batch arg (=100)          batch size for pair aligner
                                                              --gap-penalty arg (=2)      Gap open or extension penalty
                                                              --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                          states of pair alignment. The more gap_range, the
                                                                                          more time.
                                                              --max-errors arg (=11)      Max number of errors in pair alignment
                                                              --mismatch-penalty arg (=1) Mismatch penalty
                                                            
                                                            Align blocks with high similarity:
                                                              --aligned-check arg (=10) Min equal aligned part
                                                              --gap-check arg (=2)      Min number of equal columns after single gap
                                                              --min-length arg (=100)   Min length of fragment
                                                              --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                            
                                                            FilterSeqs:
                                                              --blast-min-length arg (=100) min length of blast hit
                                                            
                                                            Output block set:
                                                              --out-export-alignment arg (=1) use alignment information if available
                                                              --out-export-contents arg (=1)  print contents of fragments
                                                              --out-mask arg                  mask of output files (${block} is replaced 
                                                                                              with block name)
                                                            
                                                            Blast runner:
                                                              --blast-plus arg (=0)                 Use blast+ (otherwise blast)
                                                              --evalue arg (=0.001)                 Max acceptable e-value of hit
                                                              --skip-low-complexity-regions arg (=0)
                                                                                                    Tell blast not to search in low 
                                                                                                    complexity regions
                                                            
                                                            Copy file:
                                                              --blast-cons-dst arg (=check/consensuses.fasta)
                                                                                                    Destination of copy
                                                            
                                                            Copy file:
                                                              --blast-hits-dst arg (=check/hits.blast)
                                                                                                    Destination of copy
                                                            
                                                            Remove all blocks and/or sequences from blockset:
                                                              --clear-blocks arg (=1) Remove blocks
                                                              --clear-bsas arg (=1)   Remove block set alignments
                                                            
                                                            Any processor:
                                                              --smth-opts arg         options for processor
                                                            
                                                            Realign blocks:
                                                              --force-realign arg (=0) If realigned block is worse, realign anyway
                                                            
                                                            Output block set:
                                                              --out-dump-block arg (=1) dump blocks
                                                              --out-dump-seq arg (=0)   dump sequences before blocks
                                                            
                                                            Find all mutations in block:
                                                              --mask arg            mask of output files (${block} is replaced with block 
                                                                                    name)
                                                            
                                                            Create a seq. per genome of mutations and map blocks:
                                                              --mutation-distance arg (=1) Distance to sequence around mutation to keep
                                                            
                                                            Find all mutations in block:
                                                              --file arg            output file with all blocks
                                                            
                                                            Build and print newick trees of blocks:
                                                              --tree-file arg (=trees/all_trees.tsv)
                                                                                                    output file with all blocks
                                                              --tree-mask arg                       mask of output files (${block} is 
                                                                                                    replaced with block name)
                                                              --tree-method arg (=nj)               Method of tree construction (upgma/nj)
                                                            
                                                            Calculate distance between fragments in block:
                                                              --tree-distance-file arg         output file with all blocks
                                                              --tree-distance-mask arg         mask of output files (${block} is replaced 
                                                                                               with block name)
                                                            
                                                            Print consensus tree:
                                                              --nj-bootstrap-diagnostic-min-block arg (=4)
                                                                                                    Minimum block used to calculate number 
                                                                                                    of diagnostic positions
                                                              --nj-bootstrap-diagnostic-stem arg (=1)
                                                                                                    If only stem blocks are used to 
                                                                                                    calculate number of diagnostic 
                                                                                                    positions
                                                              --nj-bootstrap-percent arg (=0)       If bootstrap is percentage
                                                              --nj-bootstrap-print arg (=before-length)
                                                                                                    How to print bootstrap values ('no', 
                                                                                                    'in-braces', 'before-length')
                                                              --nj-bootstrap-values arg (=diagnostic-positions)
                                                                                                    What to use as bootstrap values 
                                                                                                    ('blocks', 'length', 
                                                                                                    'diagnostic-positions')
                                                              --nj-out-branch arg (=trees/nj.branch)
                                                                                                    Output file with branches
                                                              --nj-out-consensus-tree arg (=trees/nj-constree.tre)
                                                                                                    Output file with consensus tree
                                                              --nj-print-branches arg (=1)          If branches are logged
                                                              --nj-remove-after arg (=0)            remove file out-consensus-tree
                                                              --nj-tree-pseudo-leafs arg (=1)       Convert each leaf to short branch 
                                                                                                    (workaround to make viewer programs 
                                                                                                    show bootstrap values of leafs)
                                                            
                                                            BranchGenerator:
                                                              --nj-log arg (=1)         block weight is log(number of nonidentical 
                                                                                        positions) (otherwse linear)
                                                              --nj-min-noident arg (=5) Minimum number of nonidentical positions in block
                                                            
                                                            Build and print newick trees of blocks:
                                                              --nj-tree-file arg         output file with all blocks
                                                              --nj-tree-mask arg         mask of output files (${block} is replaced with 
                                                                                         block name)
                                                            
                                                            Calculate distance between fragments in block:
                                                              --nj-tree-distance-file arg         output file with all blocks
                                                              --nj-tree-distance-mask arg         mask of output files (${block} is 
                                                                                                  replaced with block name)
                                                            
                                                            Print consensus tree:
                                                              --upgma-bootstrap-diagnostic-min-block arg (=4)
                                                                                                    Minimum block used to calculate number 
                                                                                                    of diagnostic positions
                                                              --upgma-bootstrap-diagnostic-stem arg (=1)
                                                                                                    If only stem blocks are used to 
                                                                                                    calculate number of diagnostic 
                                                                                                    positions
                                                              --upgma-bootstrap-percent arg (=0)    If bootstrap is percentage
                                                              --upgma-bootstrap-print arg (=before-length)
                                                                                                    How to print bootstrap values ('no', 
                                                                                                    'in-braces', 'before-length')
                                                              --upgma-bootstrap-values arg (=diagnostic-positions)
                                                                                                    What to use as bootstrap values 
                                                                                                    ('blocks', 'length', 
                                                                                                    'diagnostic-positions')
                                                              --upgma-out-branch arg (=trees/upgma.branch)
                                                                                                    Output file with branches
                                                              --upgma-out-consensus-tree arg (=trees/upgma-constree.tre)
                                                                                                    Output file with consensus tree
                                                              --upgma-print-branches arg (=1)       If branches are logged
                                                              --upgma-remove-after arg (=0)         remove file out-consensus-tree
                                                              --upgma-tree-pseudo-leafs arg (=1)    Convert each leaf to short branch 
                                                                                                    (workaround to make viewer programs 
                                                                                                    show bootstrap values of leafs)
                                                            
                                                            BranchGenerator:
                                                              --upgma-log arg (=1)         block weight is log(number of nonidentical 
                                                                                           positions) (otherwse linear)
                                                              --upgma-min-noident arg (=5) Minimum number of nonidentical positions in 
                                                                                           block
                                                            
                                                            Build and print newick trees of blocks:
                                                              --upgma-tree-file arg         output file with all blocks
                                                              --upgma-tree-mask arg         mask of output files (${block} is replaced with
                                                                                            block name)
                                                            
                                                            Calculate distance between fragments in block:
                                                              --upgma-tree-distance-file arg        output file with all blocks
                                                              --upgma-tree-distance-mask arg        mask of output files (${block} is 
                                                                                                    replaced with block name)
                                                                                                    number of threads
                                                            
                                                            Calculate distance between fragments in block:
                                                              --distance-file arg (=trees/distances.tsv)
                                                                                                    output file with all blocks
                                                              --distance-mask arg                   mask of output files (${block} is 
                                                                                                    replaced with block name)
                                                            
                                                            Build block set alignment:
                                                              --bsa-name arg        Name of new block set alignment
                                                              --bsa-seqs arg        List of sequences used for alignment, sequence groups 
                                                                                    can be selected by genome name or chromosome name, 
                                                                                    'all' means all sequences of block set
                                                            
                                                            Print block set alignment:
                                                              --bsa-blocks arg (=1)       Print block names in alignment (else fragments)
                                                              --bsa-conservative arg (=1) Print conservative columns line
                                                              --bsa-orientation arg (=1)  Print orientation after fragment
                                                            
                                                            Replace all non-stem blocks with gaps in block set alignment:
                                                              --bsa-min-length arg (=100) Min length of accepted block
                                                              --bsa-stem-improve arg (=1) Move fragments and remove pure gaps
                                                            
                                                            Find splittable blocks-repeats and split them:
                                                              --min-diagnostic-mutations arg (=2) Min number of diagnostic mutations in 
                                                                                                  part of block splitted out
                                                              --min-mutations arg (=4)            Min number of mutations in candidate 
                                                                                                  block to be splited
                                                            
                                                            
                                                            Prepare
                                                            Prepare: Prepare
                                                                GetFasta: GetFasta
                                                                    GetData: Download genomes from Web
                                                                Rename: Rename
                                                                    In: Input block set
                                                                    ReplaceNames: Replace names in downloaded sequences according to table
                                                                    Output: Output block set
                                                                GetGenes: GetGenes
                                                                    GetData: Download genomes from Web
                                                                AddGenes: Add genes from EBI genes description
                                                                Output: Output block set
                                                            
                                                              
                                                              Download genomes from Web:
                                                                --remove-after arg (=0)    remove file data
                                                                --table arg (=genomes.tsv) Table of genomes
                                                              
                                                              Input block set:
                                                                --in-blocks arg (=genomes-raw.fasta) input fasta file(s) with blocks
                                                                --row-type arg (=compact)            way of storing alignments in memory 
                                                                                                     ('map' or 'compact')
                                                                --seq-storage arg (=compact_low_n)   way of storing sequences in memory 
                                                                                                     ('asis', 'compact' or 'compact_low_n')
                                                              
                                                              Output block set:
                                                                --out-dump-block arg (=1)             dump blocks
                                                                --out-export-alignment arg (=1)       use alignment information if available
                                                                --out-export-contents arg (=1)        print contents of fragments
                                                                --out-file arg (=genomes-renamed.fasta)
                                                                                                      output file with all blocks
                                                                --out-mask arg                        mask of output files (${block} is 
                                                                                                      replaced with block name)
                                                              
                                                              Add genes from EBI genes description:
                                                                --in-genes arg (=features.embl) input database files with genes
                                                                --product arg (=1)              Append product name to block name
                                                              
                                                              Output block set:
                                                                --out-dump-seq arg (=0) dump sequences before blocks
                                                              
                                                              
                                                              PrintBSA
                                                              Print block set alignment
                                                              
                                                              
                                                              • target: Target blockset
                                                              
                                                              Print block set alignment:
                                                                --bsa-blocks arg (=1)       Print block names in alignment (else fragments)
                                                                --bsa-conservative arg (=1) Print conservative columns line
                                                                --bsa-orientation arg (=1)  Print orientation after fragment
                                                                --out-bsa arg               Output file with block set alignment
                                                                --remove-after arg (=0)     remove file out-bsa
                                                              
                                                              
                                                              PrintGeneGroups
                                                              Print information about gene groups
                                                              
                                                              
                                                              • pangenome: Similar parts of genomes
                                                              • target: Gene groups, weak blocks
                                                              
                                                              Print information about gene groups:
                                                                --file arg            output file with all blocks
                                                                --mask arg            mask of output files (${block} is replaced with block 
                                                                                      name)
                                                              
                                                              
                                                              PrintMutations
                                                              Find all mutations in block
                                                              
                                                              
                                                              • target: Target blockset
                                                              
                                                              Find all mutations in block:
                                                                --file arg            output file with all blocks
                                                                --mask arg            mask of output files (${block} is replaced with block 
                                                                                      name)
                                                              
                                                              
                                                              PrintOverlaps
                                                              Print ASCII diagram with all fragments overlapping with a block
                                                              
                                                              
                                                              • other: Container blocks (outer)
                                                              • target: Contained blocks (internal)
                                                              
                                                              Print ASCII diagram with all fragments overlapping with a block:
                                                                --overlaps-bottom-scale arg (=1)   if bottom scale is printed
                                                                --overlaps-file arg                output file with all blocks
                                                                --overlaps-marker arg (=*)         char used to mark fragment
                                                                --overlaps-mask arg                mask of output files (${block} is replaced
                                                                                                   with block name)
                                                                --overlaps-print-block arg (=1)    if block name is printed
                                                                --overlaps-print-fragment arg (=0) if fragment name is printed
                                                                --overlaps-top-scale arg (=1)      if top scale is printed
                                                                --overlaps-width arg (=76)         max allowed line width of output
                                                              
                                                              
                                                              PrintPartition
                                                              Print overlaps between two block sets as table
                                                              
                                                              
                                                              • other: Blocks with which overlaps are searched
                                                              • target: Blocks in which overlaps are searched
                                                              
                                                              Print overlaps between two block sets as table:
                                                                --file arg            output file with all blocks
                                                                --mask arg            mask of output files (${block} is replaced with block 
                                                                                      name)
                                                              
                                                              
                                                              PrintTree
                                                              Build and print newick trees of blocks
                                                              PrintTree: Build and print newick trees of blocks
                                                                  FragmentDistance: Calculate distance between fragments in block
                                                              
                                                              • target: Target blockset
                                                              
                                                              Build and print newick trees of blocks:
                                                                --tree-file arg         output file with all blocks
                                                                --tree-mask arg         mask of output files (${block} is replaced with block
                                                                                        name)
                                                                --tree-method arg (=nj) Method of tree construction (upgma/nj)
                                                              
                                                              Calculate distance between fragments in block:
                                                                --tree-distance-file arg         output file with all blocks
                                                                --tree-distance-mask arg         mask of output files (${block} is replaced 
                                                                                                 with block name)
                                                              
                                                              
                                                              Processor
                                                              
                                                              
                                                                
                                                                
                                                                ReAlign
                                                                Realign blocks
                                                                ReAlign: Realign blocks
                                                                    MetaAligner: Align blocks with one of possible aligners
                                                                        ExternalAligner: External aligner
                                                                        MafftAligner: Mafft aligner
                                                                        MuscleAligner: Muscle aligner
                                                                        MultipleAligner: Internal aligner
                                                                        SimilarAligner: Align blocks with high similarity
                                                                        DummyAligner: Align by adding gaps to sequences
                                                                    Filter: Filter blocks
                                                                
                                                                • target: Target blockset
                                                                
                                                                Realign blocks:
                                                                  --force-realign arg (=0) If realigned block is worse, realign anyway
                                                                
                                                                Align blocks with one of possible aligners:
                                                                  --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                                multiple, similar, dummy). Specify several 
                                                                                                types, separated by comma, the first working 
                                                                                                one will be used or the last one if all fail.
                                                                  --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                                'compact')
                                                                
                                                                External aligner:
                                                                  --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                        Template of command for external 
                                                                                                        aligner
                                                                
                                                                Mafft aligner:
                                                                  --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                        Template of command for external 
                                                                                                        aligner
                                                                  --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                                        ('map' or 'compact')
                                                                
                                                                Muscle aligner:
                                                                  --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                                        Template of command for external 
                                                                                                        aligner
                                                                  --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                                        ('map' or 'compact')
                                                                
                                                                Internal aligner:
                                                                  --batch arg (=100)          batch size for pair aligner
                                                                  --gap-penalty arg (=2)      Gap open or extension penalty
                                                                  --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                              states of pair alignment. The more gap_range, the
                                                                                              more time.
                                                                  --max-errors arg (=11)      Max number of errors in pair alignment
                                                                  --mismatch-penalty arg (=1) Mismatch penalty
                                                                
                                                                Align blocks with high similarity:
                                                                  --aligned-check arg (=10) Min equal aligned part
                                                                  --gap-check arg (=2)      Min number of equal columns after single gap
                                                                  --min-identity arg (=0.9) Min identity of block
                                                                  --min-length arg (=100)   Min length of fragment
                                                                  --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                                
                                                                Filter blocks:
                                                                  --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                                  --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                             other blockset
                                                                  --max-block arg (=-1)      Maximum block size (-1 = all)
                                                                  --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                                  --max-gaps arg (=0.2)      Max gap columns percentage
                                                                  --max-identity arg (=1)    Maximum block identity
                                                                  --max-spreading arg (=0.2) Maximum fragment length spreading
                                                                  --min-block arg (=2)       Minimum block size
                                                                  --min-fragment arg (=100)  Minimum fragment length
                                                                  --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                             known)
                                                                  --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                             avg)
                                                                
                                                                
                                                                RemoveAlignment
                                                                Remove alignment from blocks
                                                                
                                                                
                                                                • target: Target blockset
                                                                
                                                                
                                                                RemoveMinorBlocks
                                                                Remove minor blocks (name starts with "m")
                                                                
                                                                
                                                                • target: Target block set
                                                                
                                                                
                                                                RemoveNames
                                                                Remove all blocks and/or sequences names
                                                                
                                                                
                                                                • target: Target blockset
                                                                
                                                                Remove all blocks and/or sequences names:
                                                                  --remove-blocks-names arg (=1) Remove blocks names
                                                                  --remove-seqs-names arg (=1)   Remove seqences names
                                                                
                                                                
                                                                RemoveWeak
                                                                Remove weak blocks
                                                                
                                                                
                                                                • target: Target blockset
                                                                
                                                                
                                                                RemoveWithSameName
                                                                Remove from target blocks with names from other
                                                                
                                                                
                                                                • other: Reference blocks
                                                                • target: Modified blockset
                                                                
                                                                
                                                                Rename
                                                                Rename: Rename
                                                                    In: Input block set
                                                                    ReplaceNames: Replace names in downloaded sequences according to table
                                                                    Output: Output block set
                                                                
                                                                  
                                                                  Input block set:
                                                                    --in-blocks arg (=genomes-raw.fasta) input fasta file(s) with blocks
                                                                    --row-type arg (=compact)            way of storing alignments in memory 
                                                                                                         ('map' or 'compact')
                                                                    --seq-storage arg (=compact_low_n)   way of storing sequences in memory 
                                                                                                         ('asis', 'compact' or 'compact_low_n')
                                                                  
                                                                  Replace names in downloaded sequences according to table:
                                                                    --table arg (=genomes.tsv) Table of genomes
                                                                  
                                                                  Output block set:
                                                                    --out-dump-block arg (=1)             dump blocks
                                                                    --out-export-alignment arg (=1)       use alignment information if available
                                                                    --out-export-contents arg (=1)        print contents of fragments
                                                                    --out-file arg (=genomes-renamed.fasta)
                                                                                                          output file with all blocks
                                                                    --out-mask arg                        mask of output files (${block} is 
                                                                                                          replaced with block name)
                                                                  
                                                                  
                                                                  ReplaceNames
                                                                  Replace names in downloaded sequences according to table
                                                                  
                                                                  
                                                                  • target: Modified blockset
                                                                  
                                                                  Replace names in downloaded sequences according to table:
                                                                    --table arg           Table of genomes
                                                                  
                                                                  
                                                                  Rest
                                                                  Add to target blocks of nucleotides, not included to other
                                                                  
                                                                  
                                                                  • other: Input blocks
                                                                  • target: Where created blocks are added
                                                                  
                                                                  Add to target blocks of nucleotides, not included to other:
                                                                    --skip-rest arg (=0)  do not add unique fragments to block set
                                                                  
                                                                  
                                                                  SameChr
                                                                  Filter out blocks fragments located on different chromosomes
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  
                                                                  SelfOverlapsResolver
                                                                  Resolve self-overlaps
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  
                                                                  SequencesFromOther
                                                                  Copy sequences from other block set
                                                                  
                                                                  
                                                                  • other: Source
                                                                  • target: Destination
                                                                  
                                                                  
                                                                  SimilarAligner
                                                                  Align blocks with high similarity
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  Align blocks with high similarity:
                                                                    --aligned-check arg (=10) Min equal aligned part
                                                                    --gap-check arg (=2)      Min number of equal columns after single gap
                                                                    --min-identity arg (=0.9) Min identity of block
                                                                    --min-length arg (=100)   Min length of fragment
                                                                    --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                                    --row-type arg (=compact) way of storing alignments in memory ('map' or 
                                                                                              'compact')
                                                                  
                                                                  
                                                                  SplitExtendable
                                                                  Find extendable subblocks
                                                                  SplitExtendable: Find extendable subblocks
                                                                      Filter: Filter blocks
                                                                      FragmentsExtender: Move block's boundaries and align only new parts
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                  
                                                                  • other: source blocks
                                                                  • target: output, extended good blocks
                                                                  
                                                                  Filter blocks:
                                                                    --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                                    --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                               other blockset
                                                                    --max-block arg (=-1)      Maximum block size (-1 = all)
                                                                    --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                                    --max-gaps arg (=0.2)      Max gap columns percentage
                                                                    --max-identity arg (=1)    Maximum block identity
                                                                    --max-spreading arg (=0.2) Maximum fragment length spreading
                                                                    --min-block arg (=2)       Minimum block size
                                                                    --min-fragment arg (=100)  Minimum fragment length
                                                                    --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                               known)
                                                                    --min-identity arg (=0.9)  Minimum block identity (only if alignment is 
                                                                                               known, columns without gaps as 1, columns with 
                                                                                               gaps as 0.5)
                                                                    --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                               avg)
                                                                  
                                                                  Move block's boundaries and align only new parts:
                                                                    --extend-length arg (=100)       Length of extended part
                                                                    --extend-length-portion arg (=0) Length of extended part portion in source
                                                                  
                                                                  Align blocks with one of possible aligners:
                                                                    --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                                  multiple, similar, dummy). Specify several 
                                                                                                  types, separated by comma, the first working 
                                                                                                  one will be used or the last one if all fail.
                                                                    --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                                  'compact')
                                                                  
                                                                  External aligner:
                                                                    --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                  
                                                                  Mafft aligner:
                                                                    --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                    --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                                          ('map' or 'compact')
                                                                  
                                                                  Muscle aligner:
                                                                    --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                    --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                                          ('map' or 'compact')
                                                                  
                                                                  Internal aligner:
                                                                    --batch arg (=100)          batch size for pair aligner
                                                                    --gap-penalty arg (=2)      Gap open or extension penalty
                                                                    --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                                states of pair alignment. The more gap_range, the
                                                                                                more time.
                                                                    --max-errors arg (=11)      Max number of errors in pair alignment
                                                                    --mismatch-penalty arg (=1) Mismatch penalty
                                                                  
                                                                  Align blocks with high similarity:
                                                                    --aligned-check arg (=10) Min equal aligned part
                                                                    --gap-check arg (=2)      Min number of equal columns after single gap
                                                                    --min-length arg (=100)   Min length of fragment
                                                                    --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                                  
                                                                  
                                                                  SplitRepeats
                                                                  Find splittable blocks-repeats and split them
                                                                  SplitRepeats: Find splittable blocks-repeats and split them
                                                                      PrintTree: Build and print newick trees of blocks
                                                                          FragmentDistance: Calculate distance between fragments in block
                                                                  
                                                                  • other: Input blocks (const)
                                                                  • target: Destination for weak blocks
                                                                  
                                                                  Find splittable blocks-repeats and split them:
                                                                    --min-diagnostic-mutations arg (=2) Min number of diagnostic mutations in 
                                                                                                        part of block splitted out
                                                                    --min-mutations arg (=4)            Min number of mutations in candidate 
                                                                                                        block to be splited
                                                                  
                                                                  Build and print newick trees of blocks:
                                                                    --tree-file arg         output file with all blocks
                                                                    --tree-mask arg         mask of output files (${block} is replaced with block
                                                                                            name)
                                                                    --tree-method arg (=nj) Method of tree construction (upgma/nj)
                                                                  
                                                                  Calculate distance between fragments in block:
                                                                    --tree-distance-file arg         output file with all blocks
                                                                    --tree-distance-mask arg         mask of output files (${block} is replaced 
                                                                                                     with block name)
                                                                  
                                                                  
                                                                  Stats
                                                                  Print human readable summary and statistics about block set
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  Print human readable summary and statistics about block set:
                                                                    --out-stats arg         Output file with statistics
                                                                    --remove-after arg (=0) remove file out-stats
                                                                  
                                                                  
                                                                  Stem
                                                                  Filter out blocks not represented in at least one of genomes
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  Filter out blocks not represented in at least one of genomes:
                                                                    --exact arg (=0)      Require exactly one fragment in each genome
                                                                  
                                                                  
                                                                  StickBoundaries
                                                                  Turn nearby fragment boundaries into one
                                                                  
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  Turn nearby fragment boundaries into one:
                                                                    --min-distance arg (=30) Min distance between fragment boundaries
                                                                  
                                                                  
                                                                  Subtract
                                                                  Remove from target fragments that have overlaps with other
                                                                  
                                                                  
                                                                  • other: Blocks to which overlaps are found
                                                                  • target: Blocks which are removed if overlap with blocks from other
                                                                  
                                                                  Remove from target fragments that have overlaps with other:
                                                                    --subtract-equal arg (=0) Delete only equal fragments
                                                                  
                                                                  
                                                                  TrySmth
                                                                  Try to do something, align (and filter), restore original if worse
                                                                  TrySmth: Try to do something, align (and filter), restore original if worse
                                                                      Union: Add clones of blocks from other to this block set
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      MetaProcessor: Any processor
                                                                      RemoveNames: Remove all blocks and/or sequences names
                                                                      Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          SelfOverlapsResolver: Resolve self-overlaps
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          AlignLoop: AlignLoop
                                                                              MoveGaps: Move terminal letters inside
                                                                              CutGaps: Cut terminal gaps
                                                                              Filter: Filter blocks
                                                                      Move: Move all blocks from other blockset to target blockset
                                                                      AddingLoopBySize: Align and move overlapless from other to target
                                                                          AddingLoop: AddingLoop
                                                                              Align: LiteAlign + Filter + SelfOverlapsResolver
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  SelfOverlapsResolver: Resolve self-overlaps
                                                                                  MetaAligner: Align blocks with one of possible aligners
                                                                                      ExternalAligner: External aligner
                                                                                      MafftAligner: Mafft aligner
                                                                                      MuscleAligner: Muscle aligner
                                                                                      MultipleAligner: Internal aligner
                                                                                      SimilarAligner: Align blocks with high similarity
                                                                                      DummyAligner: Align by adding gaps to sequences
                                                                                  AlignLoop: AlignLoop
                                                                                      MoveGaps: Move terminal letters inside
                                                                                      CutGaps: Cut terminal gaps
                                                                                      Filter: Filter blocks
                                                                              SmthUnion: SmthUnion
                                                                      UniqueNames: Set unique names to all blocks of this block set
                                                                      ReAlign: Realign blocks
                                                                          MetaAligner: Align blocks with one of possible aligners
                                                                              ExternalAligner: External aligner
                                                                              MafftAligner: Mafft aligner
                                                                              MuscleAligner: Muscle aligner
                                                                              MultipleAligner: Internal aligner
                                                                              SimilarAligner: Align blocks with high similarity
                                                                              DummyAligner: Align by adding gaps to sequences
                                                                          Filter: Filter blocks
                                                                      Clear: Remove all blocks and/or sequences from blockset
                                                                  
                                                                  • target: Target blockset
                                                                  
                                                                  Any processor:
                                                                    --smth-opts arg         options for processor
                                                                    --smth-processor arg    processor name
                                                                  
                                                                  Align blocks with one of possible aligners:
                                                                    --aligner-type arg (=similar) Type of aligner (external, mafft, muscle, 
                                                                                                  multiple, similar, dummy). Specify several 
                                                                                                  types, separated by comma, the first working 
                                                                                                  one will be used or the last one if all fail.
                                                                    --row-type arg (=compact)     way of storing alignments in memory ('map' or 
                                                                                                  'compact')
                                                                  
                                                                  External aligner:
                                                                    --aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                  
                                                                  Mafft aligner:
                                                                    --mafft-aligner-cmd arg (=mafft --quiet --retree 1 --maxiterate 1 %1% > %2%)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                    --mafft-row-type arg (=compact)       way of storing alignments in memory 
                                                                                                          ('map' or 'compact')
                                                                  
                                                                  Muscle aligner:
                                                                    --muscle-aligner-cmd arg (=muscle -quiet -in %1% -out %2% -maxiters 1 -diags1)
                                                                                                          Template of command for external 
                                                                                                          aligner
                                                                    --muscle-row-type arg (=compact)      way of storing alignments in memory 
                                                                                                          ('map' or 'compact')
                                                                  
                                                                  Internal aligner:
                                                                    --batch arg (=100)          batch size for pair aligner
                                                                    --gap-penalty arg (=2)      Gap open or extension penalty
                                                                    --gap-range arg (=15)       Max distance from main diagonal of considered 
                                                                                                states of pair alignment. The more gap_range, the
                                                                                                more time.
                                                                    --max-errors arg (=11)      Max number of errors in pair alignment
                                                                    --mismatch-penalty arg (=1) Mismatch penalty
                                                                  
                                                                  Align blocks with high similarity:
                                                                    --aligned-check arg (=10) Min equal aligned part
                                                                    --gap-check arg (=2)      Min number of equal columns after single gap
                                                                    --min-identity arg (=0.9) Min identity of block
                                                                    --min-length arg (=100)   Min length of fragment
                                                                    --mismatch-check arg (=1) Min number of equal columns after single mismatch
                                                                  
                                                                  Move terminal letters inside:
                                                                    --max-tail arg (=3)        Max length of tail
                                                                    --max-tail-to-gap arg (=1) Max tail length to gap length ratio
                                                                  
                                                                  Cut terminal gaps:
                                                                    --cut-strict arg (=0) cut more gaps
                                                                  
                                                                  Filter blocks:
                                                                    --find-subblocks arg (=1)  Find and add good subblocks of bad blocks
                                                                    --good-to-other arg (=0)   Do not remove bad blocks, but copy good blocks to 
                                                                                               other blockset
                                                                    --max-block arg (=-1)      Maximum block size (-1 = all)
                                                                    --max-fragment arg (=-1)   Maximum fragment length (-1 = all)
                                                                    --max-gaps arg (=0.2)      Max gap columns percentage
                                                                    --max-identity arg (=1)    Maximum block identity
                                                                    --max-spreading arg (=0.2) Maximum fragment length spreading
                                                                    --min-block arg (=2)       Minimum block size
                                                                    --min-fragment arg (=100)  Minimum fragment length
                                                                    --min-gaps arg (=0)        Min gap columns percentage (only if alignment is 
                                                                                               known)
                                                                    --min-spreading arg (=0)   Minimum fragment length spreading ((max - min) / 
                                                                                               avg)
                                                                  
                                                                  Realign blocks:
                                                                    --force-realign arg (=0) If realigned block is worse, realign anyway
                                                                  
                                                                  
                                                                  Union
                                                                  Add clones of blocks from other to this block set
                                                                  
                                                                  
                                                                  • other: Source of blocks copying
                                                                  • target: Destination of blocks copying
                                                                  
                                                                  
                                                                  UniqueNames
                                                                  Set unique names to all blocks of this block set
                                                                  
                                                                  
                                                                  • target: Target blockset