miga-base 1.2.15.2 → 1.2.15.4

data/utils/enveomics/Scripts/BlastTab.taxid2taxrank.pl

@@ -1,90 +0,0 @@
-#!/usr/bin/env perl
-#
-# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
-# @license artistic 2.0
-# @update  Oct-13-2015
-#
-
-use warnings;
-use strict;
-
-my($blast, $nodes, $names, $rank, $bh) = @ARGV;
-($blast and $nodes and $names) or die <<HELP
-
-Takes a BLAST with NCBI Taxonomy IDs as subjects and replaces them by names at a
-given taxonomic rank.
-
-Usage:
-   $0 tax_blast.txt nodes.dmp names.dmp[ rank[ best-hit]] > taxrank_blast.txt
-
-   tax_blast.txt	BLAST output, where subject IDs are NCBI Taxonomy IDs.
-   nodes.dmp		Nodes file from NCBI Taxonomy*.
-   names.dmp		Names file from NCBI Taxonomy*.
-   rank			The rank to be reported.  All the reported nodes will
-   			have the same rank.  By default, genus.  To see
-			supported values, run:
-			cut -f 5 nodes.dmp | sort -u
-   best-hit		A word (yes or no) telling the program whether or not it
-   			should take into account the best hit per query only.
-			By default: yes.
-   taxrank_list.txt	BLAST-like output, where subject IDs are Taxonomy names.
-
-   * Download from ftp://ftp.ncbi.nih.gov/pub/taxonomy/taxdump.tar.gz
-
-HELP
-;
-$rank ||= "genus";
-$bh   ||= "yes";
-
-# %nodes structure:
-#   taxid => [parent's taxid, rank, nil, name, name type]
-
-print STDERR "Reading $nodes.\n";
-open NODES, "<", $nodes or die "Cannot read file: $nodes: $!\n";
-my %nodes = map { my @a=split /\t\|\t/; ($a[0] => [$a[1], $a[2]]) } <NODES>;
-close NODES;
-
-print STDERR "Reading $names.\n";
-open NAMES, "<", $names or die "Cannot read file: $names: $!\n";
-while(<NAMES>){
-   my @a=split /\t\|\t/;
-   next if exists $nodes{$a[0]}->[3] and
-      $nodes{$a[0]}->[4] eq "scientific name";
-   next if exists $nodes{$a[0]}->[3] and
-      $a[3] ne "scientific name";
-   $nodes{$a[0]}->[3] = $a[1];
-   $nodes{$a[0]}->[4] = $a[3];
-}
-close NAMES;
-
-my $i     = 0;
-my $nomap = 0;
-my $qry   = "";
-open BLAST, "<", $blast or die "Cannot read file: $blast: $!\n";
-HIT:while(<BLAST>){
-   if(/^#/){
-      print $_;
-      next;
-   }
-   chomp;
-   my @row = split /\t/;
-   next if $bh eq "yes" and $row[0] eq $qry;
-   $i++;
-   print STDERR " Mapping hit $i\r" unless $i%10;
-   exists $nodes{$row[1]} or die "Cannot find Taxonomy node: $row[1].\n";
-   my $n = $nodes{$row[1]};
-   while($n->[1] ne $rank){
-      if($n->[0] eq $nodes{$n->[0]}->[0]){
-	 $nomap++;
-	 next HIT;
-      }
-      $n = $nodes{$n->[0]};
-   }
-   $row[1] = $n->[3];
-   print "".join("\t", @row)."\n";
-}
-close BLAST;
-print STDERR " Mapped $i hits\n";
-print STDERR
-   " WARNING: $nomap hits above rank or in a lineage without rank.\n" if $nomap;
-

data/utils/enveomics/Scripts/BlastTab.topHits_sorted.rb

@@ -1,123 +0,0 @@
-#!/usr/bin/env ruby
-
-# frozen_string_literal: true
-
-$:.push File.expand_path('../lib', __FILE__)
-require 'enveomics_rb/enveomics'
-require 'enveomics_rb/match'
-$VERSION = 1.0
-
-o = { n: 5, sortby: :bitscore, out: '-' }
-OptionParser.new do |opts|
-  opts.version = $VERSION
-  Enveomics.opt_banner(
-    opts, 'Reports the top-N best hits of a BLAST, pre-sorted by query',
-    "#{File.basename($0)} -i in.tsv -o out.tsv [options]"
-  )
-  
-  opts.separator 'Mandatory'
-  opts.on(
-    '-i', '--blast FILE',
-    'Path to the BLAST file',
-    'Supports compression with .gz extension, use - for STDIN'
-  ) { |v| o[:in] = v }
-  opts.on(
-    '-o', '--out FILE',
-    'Output filtered BLAST file',
-    'Supports compression with .gz extension, use - for STDOUT (default)'
-  ) { |v| o[:out] = v }
-  opts.separator ''
-  opts.separator 'Filter Options'
-  opts.on(
-    '-n', '--top INTEGER', Integer,
-    'Maximum number of hits to report for each query',
-    "By default: #{o[:n]}"
-  ) { |v| o[:n] = v }
-  opts.on(
-    '-s', '--sort-by STRING',
-    'Parameter used to detect the "best" hits',
-    'Any of: bitscore (default), evalue, identity, length, no (pick first)'
-  ) { |v| o[:sortby] = v.to_sym }
-  opts.separator ''
-  opts.separator 'Other Options'
-  opts.on('-q', '--quiet', 'Run quietly (no STDERR output)') { $QUIET = true }
-  opts.on('-h', '--help', 'Display this screen') { puts opts; exit }
-  opts.separator ''
-end.parse!
-
-raise Enveomics::OptionError.new('-i is mandatory') if o[:in].nil?
-unless o[:sortby] == :no || Enveomics::Match.column(o[:sortby])
-  raise Enveomics::OptionError.new("Unrecognized value for -s: #{o[:sortby]}")
-end
-
-class Enveomics::Match
-  attr_accessor :sortby
-
-  def <=>(other)
-    ans = send(sortby) <=> other.send(sortby)
-    sortby == :evalue ? ans : ans * -1
-  end
-end
-
-class Enveomics::MatchSet
-  attr_reader :query, :hits, :sortby
-
-  def initialize(sortby)
-    @hits = []
-    @query = nil
-    @sortby = sortby
-  end
-
-  def <<(hit)
-    @query ||= hit.qry
-    unless query == hit.qry
-      raise "Inconsistent query, expecting #{query}"
-    end
-
-    @hits << hit.tap { |i| i.sortby = sortby }
-  end
-
-  def empty?
-    hits.empty?
-  end
-
-  def filter!(n)
-    @hits.sort! unless sortby == :no
-    @hits.slice!(n, @hits.length)
-  end
-
-  def to_s
-    hits.join("\n")
-  end
-end
-
-begin
-  ifh = reader(o[:in])
-  ofh = writer(o[:out])
-
-  say 'Parsing BLAST'
-  hs = Enveomics::MatchSet.new(o[:sortby])
-  lno = 0
-  ifh.each do |ln|
-    lno += 1
-    hit = Enveomics::Match.new(ln)
-    if hs.query != hit.qry
-      hs.filter! o[:n]
-      ofh.puts hs unless hs.empty?
-      hs = Enveomics::MatchSet.new(o[:sortby])
-      say_inline("Parsing line #{lno}... \r")
-    end
-    hs << hit
-  end
-  say("Parsed #{lno} lines    ")
-  ifh.close
-
-  hs.filter! o[:n]
-  ofh.puts hs unless hs.empty?
-  ofh.close
-rescue => err
-  $stderr.puts "Exception: #{err}\n\n"
-  err.backtrace.reverse.each { |l| $stderr.puts "DEBUG: %s\n" % l }
-  err
-end
-

data/utils/enveomics/Scripts/Chao1.pl

@@ -1,97 +0,0 @@
-#!/usr/bin/env perl
-#
-# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
-# @license artistic license 2.0
-# @update  Dec-29-2015
-#
-
-use warnings;
-use strict;
-use Getopt::Std;
-use List::Util qw/min max/;
-
-sub VERSION_MESSAGE(){print "Home-made Chao1 (enveomics)\n"}
-sub HELP_MESSAGE(){die "
-Description:
-   Takes a table of OTU abundance in one or more samples and calculates the
-   chao1 index (with 95% Confidence Interval) for each sample.  To use it with
-   Qiime OTU Tables, run it as:
-   $0 -i OTU_Table.txt -c 1 -h
-
-Usage:
-   $0 [opts]
-
-   -i <str>	* Input table (columns:samples, rows:OTUs).
-   -r <int>	Number of rows to ignore.  By default: 0.
-   -c <int>	Number of columns to ignore.  By default: 0.
-   -C <int>	Number of columns to ignore at the end. By default: 0.
-   -d <str>	Delimiter.  Supported escaped characters are: \"\\t\"
-		(tabulation), and \"\\0\" (null bit).  By default: \"\\t\".
-   -h		If set, the first row is assumed to have the names of the
-		samples.
-   --help	This help message.
-
-   * Mandatory.
-
-To improve:
-   o Account for n1==0 and n2==0 cases.  See http://www.mothur.org/wiki/Chao.
-
-"}
-
-my %o;
-getopts('i:c:C:r:d:h', \%o);
-
-&HELP_MESSAGE() unless $o{i};
-$o{c} ||= 0;
-$o{C} ||= 0;
-$o{r} ||= 0;
-$o{d} ||= "\\t";
-
-$o{d}="\t" if $o{d} eq "\\t";
-$o{d}="\0" if $o{d} eq "\\0";
-
-my @names = ();
-my @values = ();
-open TABLE, "<", $o{i} or die "Cannot open file: ".$o{i}.": $!\n";
-<TABLE> for (1 .. $o{r});
-if($o{h}){
-   my $h = <TABLE>;
-   $h or die "Empty table!\n";
-   chomp $h;
-   @names = split $o{d}, $h;
-   shift @names for (1 .. $o{c});
-   pop @names for (1 .. $o{C});
-}
-while(<TABLE>){
-   chomp;
-   my @ln = split $o{d};
-   shift @ln for (1 .. $o{c});
-   pop @ln for (1 .. $o{C});
-   push @{$values[$_] ||= []}, $ln[$_] for (0 .. $#ln);
-}
-close TABLE;
-
-print "Sample\tObs\tChao1\tChao1_LB\tChao1_UL\n";
-for my $i (0 .. $#values){
-   print "".(exists $names[$i] ? $names[$i] : $i).$o{d};
-   my $n1=0;
-   my $n2=0;
-   my $ob=0;
-   for my $v (@{$values[$i]}){
-      $n1++ if $v==1;
-      $n2++ if $v==2;
-      $ob++ if $v>=1;
-   }
-   if($ob and $n1 and $n2){
-      my $m   = $n1/$n2;
-      my $ch  = $ob + (($n1**2)/(2*$n2));
-      my $var = ($n2*((($m**4)/4) + ($m**3) + (($m**2)/2)));
-      my $c   = exp(1.96*sqrt(log(1+ $var/(($ch-$ob)**2))));
-      my $lc  = max($ob + ($ch-$ob)/$c, $ob);
-      my $uc  = $ob + $c*($ch-$ob);
-      print "".join($o{d}, $ob, $ch, $lc, $uc)."\n"
-   }else{
-      print "".join($o{d}, $ob, $ob, 0, 0)."\n"
-   }
-}
-

data/utils/enveomics/Scripts/CharTable.classify.rb

@@ -1,234 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author  Luis M. Rodriguez-R
-# @update  Jan-13-2016
-# @license artistic license 2.0
-#
-
-require "optparse"
-
-o = {:q=>false}
-ARGV << "-h" if ARGV.size==0
-OptionParser.new do |opts|
-   opts.banner = "
-Uses a dichotomous key to classify objects parsing a character table.
-
-Usage: #{$0} [options]"
-   opts.separator ""
-   opts.separator "Input Options (mandatory)"
-   opts.on("-t", "--table FILE",
-      "Input table containing the states (columns) per object (row).",
-      "It must be tab-delimited and with row and column names.",
-      "See Tests/anthrax-cansnp-data.tsv for an example."){ |v| o[:table]=v }
-   opts.on("-k", "--key FILE",
-      "Input table containing the dychotomous key in linked style, defined in",
-      "four columns (can contain #-lead comment lines):",
-      "  1. ID of the step, typically a sequential integer.",
-      "  2. Name of character to evaluate. Must coincide with the -t headers.",
-      "  3. First character decision (see below).",
-      "  4. Second character decision (see below).",
-      "A character decision must be formated as: state (must coincide with the",
-      "values in -t), colon (:), step to follow. If the state is * (star) any",
-      "state triggers the decision (this should be the norm in column 4). The",
-      "step to follow should be a step ID in square brackets, or the name of",
-      "the classification. See Tests/anthrax-cansnp-key.tsv for an example."
-      ){ |v| o[:key]=v }
-   opts.separator ""
-   opts.separator "Output Options"
-   opts.on("-c", "--classification FILE",
-      "Two-column table with the classification of the input objects."
-      ){ |v| o[:class]=v }
-   opts.on("-n", "--newick FILE",
-      "Tree containing all the classified objects. This only makes sense for",
-      "synoptic keys."){ |v| o[:nwk]=v }
-   opts.separator ""
-   opts.separator "Additional Options"
-   opts.on("-q", "--quiet", "Run quietly (no STDERR output)."){ o[:q] = true }
-   opts.on("-h", "--help", "Display this screen.") do
-      puts opts
-      exit
-   end
-   opts.separator ""
-end.parse!
-abort "-t is mandatory" if o[:table].nil?
-abort "-k is mandatory" if o[:key].nil?
-
-##### Extensions:
-class String
-   def nwk_sanitize() self.gsub(/[\(\):;,"'\s]/,'_') ; end
-end
-
-##### Classes:
-module Dychotomous
-   class Decision
-      attr_reader :state, :terminal, :conclusion
-      def initialize(string)
-	 r = string.split /:/
-	 @state = r[0]
-	 @terminal = !(r[1] =~ /^\[(.*)\]$/)
-	 @conclusion = @terminal ? r[1] : $1
-      end
-      def ==(state)
-         return true if self.state == '*'
-	 self.state == state.to_s
-      end
-   end
-   class Character
-      attr_reader :name, :a, :b
-      def initialize(name, a, b)
-	 @name = name
-	 @a = a
-	 @b = b
-      end
-      def eval(object)
-	 state = object.state(self.name)
-	 return self.a if self.a == state
-	 return self.b if self.b == state
-	 raise "Impossible to make a decision for #{object.name} based on " +
-	    "character #{self.name}. Offending state: #{state.to_s}."
-      end
-   end
-   class Key
-      attr_reader :first
-      def initialize(file)
-	 @characters = {}
-	 fh = File.open(file, 'r')
-	 while ln = fh.gets
-	    next if ln=~/^#/ or ln=~/^\s*$/
-	    r = ln.chomp.split /\t/
-	    @characters[ r[0] ] = Character.new(r[1],
-	       Decision.new(r[2]), Decision.new(r[3]))
-	    @first = @characters[ r[0] ] if @first.nil?
-	 end
-	 fh.close
-      end
-      def [](name)
-	 raise "Cannot find character #{name} in key." if @characters[name].nil?
-	 @characters[name]
-      end
-   end
-end
-module CharData
-   class Object
-      attr_reader :name, :states
-      def initialize(name)
-	 @name = name
-	 @states = {}
-      end
-      def <<(state) @states[state.character] = state ; end
-      def state(name) @states[name] ; end
-   end
-   class State
-      attr_reader :character, :state
-      def initialize(character, state)
-	 @character = character
-	 @state = state
-      end
-      def to_s() self.state.to_s ; end
-   end
-   class Table
-      attr_reader :objects
-      def initialize(file)
-	 @objects = []
-	 fh = File.open(file, 'r')
-	 header = fh.gets.chomp.split(/\t/)
-	 while ln = fh.gets
-	    next if ln=~/^#/ or ln=~/^\s*$/
-	    r = ln.chomp.split /\t/
-	    o = Object.new(r[0])
-	    (1 .. r.size).each{ |i| o << State.new(header[i], r[i]) }
-	    self << o
-	 end
-	 fh.close
-      end
-      def <<(object) @objects << object ; end
-   end
-end
-module ClassData
-   class Classification
-      attr_reader :key, :object, :result
-      def initialize key, object
-	 @key = key
-	 @object = object
-	 self.classify!
-      end
-      def classify!
-	 @result = self.key.first.eval(object)
-	 while ! self.result.terminal
-	    @result = self.key[ self.result.conclusion ].eval(object)
-	 end
-      end
-   end
-   class Collection
-      attr_reader :key, :table, :classifications
-      def initialize(key, table)
-	 @key = key
-	 @table = table
-	 @classifications = []
-	 self.classify!
-      end
-      def classify!
-	 table.objects.each do |object|
-	    @classifications << Classification.new(key, object)
-	 end
-      end
-      def classified_as(conclusion)
-         self.classifications.select{ |c|
-	    c.result.conclusion==conclusion }.map{ |c| c.object }
-      end
-      def to_nwk
-	 self.to_nwk_node(self.key.first) + ";"
-      end
-      def to_nwk_node(node)
-	 if node.is_a? Dychotomous::Character
-	    a = self.to_nwk_node(node.a)
-	    b = self.to_nwk_node(node.b)
-	    return "" if (a + b)==""
-	    return "(" + a + b + ")#{node.name.nwk_sanitize}" if a=="" or b==""
-	    return "(" + self.to_nwk_node(node.a) + "," +
-	       self.to_nwk_node(node.b) + ")#{node.name.nwk_sanitize}"
-	 end
-	 if node.is_a? Dychotomous::Decision and node.terminal
-	    objects = self.classified_as(node.conclusion)
-	    return '' if objects.empty?
-	    return objects[0].name.nwk_sanitize if objects.size==1
-	    return "(" + objects.map{|o| o.name.nwk_sanitize}.join(",") + ")"
-	 end
-	 return self.to_nwk_node( self.key[node.conclusion] ) if
-	    node.is_a? Dychotomous::Decision
-	 raise "Unsupported class: to_nwk_node: #{node}."
-      end
-   end
-end
-
-##### MAIN:
-begin
-   $stderr.puts "Reading dychotomous key." unless o[:q]
-   key = Dychotomous::Key.new(o[:key])
-   $stderr.puts "Reading character table." unless o[:q]
-   table = CharData::Table.new(o[:table])
-   $stderr.puts "Classifying objects." unless o[:q]
-   classif = ClassData::Collection.new(key, table)
-   
-   unless o[:class].nil?
-      $stderr.puts "Generating classification table." unless o[:q]
-      fh = File.open(o[:class], 'w')
-      classif.classifications.each do |c|
-         fh.puts c.object.name + "\t" + c.result.conclusion
-      end
-      fh.close
-   end
-
-   unless o[:nwk].nil?
-      $stderr.puts "Generating classification tree." unless o[:q]
-      fh = File.open(o[:nwk], 'w')
-      fh.puts classif.to_nwk
-      fh.close
-   end
-   
-rescue => err
-   $stderr.puts "Exception: #{err}\n\n"
-   err.backtrace.each { |l| $stderr.puts l + "\n" }
-   err
-end

data/utils/enveomics/Scripts/EBIseq2tax.rb

@@ -1,83 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
-# @update  Oct-13-2015
-# @license Artistic License 2.0
-#
-
-$:.push File.expand_path(File.dirname(__FILE__) + "/lib")
-require "enveomics_rb/remote_data"
-use "nokogiri"
-
-#================================[ Options parsing ]
-$o = {
-   q: false, ids: [], dbfrom: "uniprotkb", header: true,
-   ret: "ScientificName",
-   ranks: %w(superkingdom phylum class order family genus species)}
-
-OptionParser.new do |opt|
-   opt.banner = "
-   Maps a list of EBI-supported IDs to their corresponding NCBI taxonomy using
-   EBI RESTful API. Avoid using this script on millions of entries at a time,
-   since each entry elicits requests to EBI and NCBI servers.
-
-   Usage: #{$0} [options]".gsub(/^ +/,"")
-   opt.separator ""
-   opt.on("-i", "--ids ID1,ID2,...", Array,
-      "Comma-separated list of EBI IDs. Required unless -I is passed."
-      ){ |v| $o[:ids]=v }
-   opt.on("-I", "--infile FILE",
-      "Raw text file containing the list of EBI IDs, one per line.",
-      "Required unless -i is passed."){ |v| $o[:infile]=v }
-   opt.on("-d", "--database DB",
-      "EBI database defining the EBI IDs. By default: " + $o[:dbfrom].to_s + "."
-      ){ |v| $o[:dbfrom]=v }
-   opt.on("-r", "--ranks RANK1,RANK2,...", Array,
-      "Taxonomic ranks to report. By default:",
-      $o[:ranks].join(",") + "."){ |v| $o[:ranks]=v }
-   opt.on("-n", "--noheader",
-      "Do not includ a header in the output."){ $o[:header]=false }
-   opt.on("-t", "--taxids",
-      "Return Taxonomy IDs instead of scientific names."){ $o[:ret]="TaxId" }
-   opt.on("-q", "--quiet", "Run quietly."){ |v| $o[:q]=true }
-   opt.on("-h", "--help","Display this screen") do
-      puts opt
-      exit
-   end
-   opt.separator ""
-end.parse!
-
-#================================[ Main ]
-begin
-   $o[:ids] += File.readlines($o[:infile]).map{ |l| l.chomp } unless
-      $o[:infile].nil?
-   $o[:ranks].map!{ |r| r.downcase }
-   puts (["ID", "TaxId"] + $o[:ranks].map{ |r| r.capitalize }).join("\t") if
-      $o[:header]
-   $o[:ids].each do |id|
-      id = $1 if id =~ /^[a-z]+\|\S+\|(\S+)/
-      taxid = RemoteData.ebiseq2taxid(id, $o[:dbfrom])
-      if taxid.nil?
-	 warn "Cannot find link to taxonomy: #{id}"
-	 next
-      end
-      taxonomy = {}
-      unless taxid.nil?
-	 doc = Nokogiri::XML( RemoteData.efetch({db: "taxonomy", id: taxid}) )
-	 taxonomy[ doc.at_xpath("/TaxaSet/Taxon/Rank").content ] =
-	    doc.at_xpath("/TaxaSet/Taxon/#{$o[:ret]}").content
-	 doc.xpath("/TaxaSet/Taxon/LineageEx/Taxon").each do |taxon|
-	    taxonomy[ taxon.at_xpath("./Rank").content ] =
-	       taxon.at_xpath("./#{$o[:ret]}").content
-	 end
-      end
-      puts ([id, taxid] +
-	 $o[:ranks].map{ |rank| taxonomy[ rank ] ||= "" }).join("\t")
-   end # $o[:ids].each
-rescue => err
-   $stderr.puts "Exception: #{err}\n\n"
-   err.backtrace.each { |l| $stderr.puts l + "\n" }
-   err
-end
-

data/utils/enveomics/Scripts/FastA.N50.pl

@@ -1,60 +0,0 @@
-#!/usr/bin/env perl
-
-# @author: Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
-# @license: Artistic-2.0
-
-use strict;
-use warnings;
-use List::Util qw/sum min max/;
-
-my ($seqs, $minlen, $n__) = @ARGV;
-$seqs or die "
-Description:
-  Calculates the N50 value of a set of sequences.  Alternatively, it
-  can calculate other N** values.  It also calculates the total number
-  of sequences, the total added length, and the longest sequence length.
-
-Usage:
-  $0 seqs.fa [minlen [**]]
-
-  seqs.fa	A FastA file containing the sequences
-  minlen	(optional) The minimum length to take into consideration
-  		By default: 0
-  **		(optional) Value N** to calculate.  By default: 50 (N50)
-
-";
-
-$minlen ||= 0;
-$n__    ||= 50;
-
-my @len = ();
-open SEQ, "<", $seqs or die "Cannot open file: $seqs: $!\n";
-while(<SEQ>){
-  if(/^>/){
-    push @len, 0;
-  }else{
-    next if /^;/;
-    chomp;
-    s/\W//g;
-    $len[-1] += length $_;
-  }
-}
-close SEQ;
-
-@len = sort { $a <=> $b } map { $_ >= $minlen ? $_ : () } @len;
-my $tot = (sum(@len) || 0);
-
-my $thr = $n__ * $tot / 100;
-my $pos = 0;
-for(@len){
-  $pos += $_;
-  if($pos >= $thr){
-    print "N$n__: $_\n";
-    last;
-  }
-}
-
-print "Sequences: " . scalar(@len) . "\n";
-print "Total length: $tot\n";
-print "Longest sequence: " . pop(@len) . "\n";
-