miga-base 1.2.17.0 → 1.2.17.1

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

@@ -0,0 +1,90 @@
+#!/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

@@ -0,0 +1,123 @@
+#!/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

@@ -0,0 +1,97 @@
+#!/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

@@ -0,0 +1,234 @@
+#!/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

@@ -0,0 +1,83 @@
+#!/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

@@ -0,0 +1,60 @@
+#!/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";
+