require Bio::Tools::Blast::HSP;

    $hspObj = eval{ new Bio::Tools::Blast::HSP(-DATA    =>\@hspData, 
					       -PARENT  =>$sbjct_object, 
					       -NAME    =>$hspCount,
 		                               -PROGRAM =>'TBLASTN',
					       );
		};

#--------------------
    my( $self, $queryName, $sbjctName, $OUT) = @_;
    my($resNum, $count);
    
    $self->_set_residues() unless defined $self->{'_identicalRes_query'};

    printf( $OUT "\n%10s:\n    %10s\n", "HITS", "-----" );
    foreach( @{ $self->{'_matchSeq'}} ) {
	printf( $OUT "%15s%s\n", "", $_ );
    }		
    
    print $OUT "\n\U$queryName\E\n------------\n";
    printf( $OUT "\n%5s%s:\n%5s%s\n\t", "", "IDENTICAL RESIDUES IN $queryName (n=$self->{'_numIdentical'})", 
	   "", "--------------------------------------------" );
    $count = 0;
    foreach $resNum ( sort keys %{ $self->{'_identicalRes_query' }} ) {
	$count++;
	print $OUT "$resNum";
	$count > 0 and print $OUT +( $count % 15 ? ", " : "\n\t");
    }
    
    print $OUT "\n";

    my $justConserved = ($self->{'_numConserved'})-($self->{'_numIdentical'});
    printf( $OUT "\n%5s%s:\n%5s%s\n\t", "","CONSERVED RESIDUES IN $queryName (n=$justConserved)", 
	   "", "--------------------------------------------" );
    $count = 0;
    foreach $resNum ( sort keys %{ $self->{'_conservedRes_query' }} ) { 
	$count++;
	print $OUT "$resNum";
	$count > 0 and print $OUT +( $count % 15 ? ", " : "\n\t");
    }
    
    
    print $OUT "\n\n\U$sbjctName\E\n------------\n";
    printf( $OUT "\n%5s%s:\n%5s%s\n\t", "", "IDENTICAL RESIDUES IN $sbjctName (n=$self->{'_numIdentical'})", 
	   "", "--------------------------------------------" );
    $count = 0;
    foreach $resNum ( sort keys %{ $self->{'_identicalRes_sbjct' }} ) {
	$count++;
	print $OUT "$resNum";
	$count > 0 and print $OUT +( $count % 15 ? ", " : "\n\t");
    }
    
    print $OUT "\n";
    $justConserved = ($self->{'_numConserved'})-($self->{'_numIdentical'});
    printf( $OUT "\n%5s%s:\n%5s%s\n\t", "","CONSERVED RESIDUES IN $sbjctName (n=$justConserved)", 
	   "", "--------------------------------------------" );
    $count       = 0;
    foreach $resNum ( sort keys %{ $self->{'_conservedRes_sbjct' }} ) { 
	$count++;
	print $OUT "$resNum";
	$count > 0 and print $OUT +( $count % 15 ? ", " : "\n\t");
    }

#------------------
    my( $self, $seqType, $name, $OUT ) = @_;
    
    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    # Sensitive to member name changes.
    my $mem = "_\L$seqType\E";
    printf( $OUT "\n%10s: %s\n%10s  %s\n", "\U$seqType\E", "$name", "-----",
	   ('-'x ((CORE::length $name) + 2)) );
    printf( $OUT "%13s: %d\n", "START", $self->{$mem.'Start'} );
    printf( $OUT "%13s: %d\n", "STOP", $self->{$mem.'Stop'} );
    printf( $OUT "%13s:\n ", "SEQ" );
    foreach( @{ $self->{$mem.'Seq'}} ) {
	printf( $OUT "%15s%s\n", "", $_);
    }

#----------------
    my( $self, %param ) = @_;
    
    $self->SUPER::_initialize( %param );

    # The gapped and program booleans may be needed after the HSP object
    # is built.
#    $self->{'_gapped'} = $param{-GAPPED} || 0;
    $self->{'_prog'} = $param{-PROGRAM} || 0;  
    $self->_set_data( @{$param{-DATA}} );
}

#####################################################################################
##                                  ACCESSORS                                      ##
#####################################################################################

#--------------
    my $self = shift;
    my @data = @_;
    my @queryList  = ();  # 'Query' = SEQUENCE USED TO QUERY THE DATABASE.
    my @sbjctList  = ();  # 'Sbjct' = HOMOLOGOUS SEQUENCE FOUND IN THE DATABASE.
    my @matchList  = ();
    my $matchLine  = 0;   # Alternating boolean: when true, load 'match' data.
    my @linedat = ();
    
    $DEBUG and print STDERR "$ID: set_data()\n";

    my($line, $aln_row_len, $length_diff);
    $length_diff = 0;

    # Collecting data for all lines in the alignment
    # and then storing the collections for possible processing later.
    #
    # Note that "match" lines may not be properly padded with spaces.
    # This loop now properly handles such cases:
    # Query: 1141 PSLVELTIRDCPRLEVGPMIRSLPKFPMLKKLDLAVANIIEEDLDVIGSLEELVIXXXXX 1200
    #             PSLVELTIRDCPRLEVGPMIRSLPKFPMLKKLDLAVANIIEEDLDVIGSLEELVI
    # Sbjct: 1141 PSLVELTIRDCPRLEVGPMIRSLPKFPMLKKLDLAVANIIEEDLDVIGSLEELVILSLKL 1200

    foreach $line( @data ) {
	next if $line =~ /^\s*$/;

	if( $line =~ /^ ?Score/ ) {
	    $self->_set_score_stats( $line );
	} elsif( $line =~ /^ ?(Identities|Positives|Strand)/ ) {
	    $self->_set_match_stats( $line );
	} elsif( $line =~ /^ ?Frame = ([\d+-]+)/ ) {
	    # Version 2.0.8 has Frame information on a separate line.
	   $self->{'_frame'} = $1;
	} elsif( $line =~ /^(Query:?[\s\d]+)([^\s\d]+)/ ) {
	    push @queryList, $line;
	    $self->{'_match_indent'} = CORE::length $1;
	    $aln_row_len = (CORE::length $1) + (CORE::length $2);
	    $matchLine = 1;
	} elsif( $matchLine ) {
	    # Pad the match line with spaces if necessary.
	    $length_diff = $aln_row_len - CORE::length $line;
	    $length_diff and $line .= ' 'x $length_diff;
	    push @matchList, $line;
	    $matchLine = 0;
	} elsif( $line =~ /^Sbjct/ ) {
	    push @sbjctList, $line;
	}
    }

    # Storing the query and sbjct lists in case they are needed later.
    # We could make this conditional to save memory.
    $self->{'_queryList'} =\@ queryList; 
    $self->{'_sbjctList'} =\@ sbjctList; 

    # Storing the match list in case it is needed later.
    $self->{'_matchList'} =\@ matchList;

    if(not defined ($self->{'_numIdentical'})) {
      $self->throw("Can't parse match statistics.",
		   "Possibly a new or unrecognized Blast format.");
    }

    if(!scalar @queryList or !scalar @sbjctList) {
        $self->throw("Can't find query or sbjct alignment lines.",
	  	     "Possibly unrecognized Blast format.");
      }

#-------------------
    my $self = shift;

## DEBUGGING CODE:
#    if($self->parent->name eq '1AK5_' and $self->parent->parent->name eq 'YAR073W') {
#	print "\n_set_match_seq() called for HSP ", $self->name, " of hit ${\$self->parent->name} in query ${\$self->parent->parent->name}"; <STDIN>;
 #   }

    ref($self->{'_matchList'}) || $self->throw("Can't set HSP match sequence: No data");
    
    my @data = @{$self->{'_matchList'}};

    my(@sequence);
    foreach( @data ) {
	chomp($_);
	## Remove leading spaces; (note: aln may begin with a space
	## which is why we can't use s/^ +//).
	s/^ {$self->{'_match_indent'}}//;   
	push @sequence, $_;
    }
    # Liberate some memory.
    @{$self->{'_matchList'}} = undef;
    $self->{'_matchList'} = undef;

    $self->{'_matchSeq'} =\@ sequence;

## DEBUGGING CODE:
#    if($self->parent->name eq '1AK5_' and $self->parent->parent->name eq 'YAR073W') {
#	print "RETURNING: $self->{'_matchSeq'}:\n   @{$self->{'_matchSeq'}}";<STDIN>;
#    }

    $self->{'_matchSeq'};

#--------------------
    my ($self, $data) = @_;

    if($data =~ m!Identities = (\d+)/(\d+)!) {
      # blast1 or 2 format
      $self->{'_numIdentical'} = $1;
      $self->{'_totalLength'}  = $2;
    }
    
    if($data =~ m!Positives = (\d+)/(\d+)!) {
      # blast1 or 2 format
      $self->{'_numConserved'} = $1;
      $self->{'_totalLength'}  = $2;
    }
    
    if($data =~ m!Frame = ([\d+-]+)!) { 
      $self->{'_frame'} = $1; 
    }

    # Strand data is not always present in this line.
    # _set_seq() will also set strand information.
    if($data =~ m!Strand = (\w+) / (\w+)!) { 
	$self->{'_queryStrand'} = $1; 
	$self->{'_sbjctStrand'} = $2; 
    }

#    if($data =~ m!Gaps = (\d+)/(\d+)!) {
#	 $self->{'_totalGaps'} = $1;
#    } else {
#	 $self->{'_totalGaps'} = 0;
#    }

#------------------
    my $self      = shift;
    my @sequence  = ();

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    # Using hashes to avoid saving duplicate residue numbers.
    my %identicalList_query = ();
    my %identicalList_sbjct = ();
    my %conservedList_query = ();
    my %conservedList_sbjct = ();
    
    my $aref = $self->_set_match_seq() if not ref $self->{'_matchSeq'};
    $aref  ||= $self->{'_matchSeq'};
    my $seqString = join('', @$aref );

    my $qseq = join('',@{$self->{'_querySeq'}});
    my $sseq = join('',@{$self->{'_sbjctSeq'}});
    my $resCount_query = $self->{'_queryStop'} || 0;
    my $resCount_sbjct = $self->{'_sbjctStop'} || 0;

    my $prog = $self->{'_prog'};
    if($prog !~ /^BLASTP|^BLASTN/) {
	if($prog eq 'TBLASTN') {
	    $resCount_sbjct /= 3;
	} elsif($prog eq 'BLASTX') {
	    $resCount_query /= 3;
	} elsif($prog eq 'TBLASTX') {
	    $resCount_query /= 3;
	    $resCount_sbjct /= 3;
	}
    }

    my ($mchar, $schar, $qchar);
    while( $mchar = chop($seqString) ) {
	($qchar, $schar) = (chop($qseq), chop($sseq));
	if( $mchar eq '+' ) { 
	    $conservedList_query{ $resCount_query } = 1; 
	    $conservedList_sbjct{ $resCount_sbjct } = 1; 
	} elsif( $mchar ne ' ' ) { 
	    $identicalList_query{ $resCount_query } = 1; 
	    $identicalList_sbjct{ $resCount_sbjct } = 1;
	}
	$resCount_query-- if $qchar ne $GAP_SYMBOL;
	$resCount_sbjct-- if $schar ne $GAP_SYMBOL;
    }
    $self->{'_identicalRes_query'} =\% identicalList_query;
    $self->{'_conservedRes_query'} =\% conservedList_query;
    $self->{'_identicalRes_sbjct'} =\% identicalList_sbjct;
    $self->{'_conservedRes_sbjct'} =\% conservedList_sbjct;

#--------------------
    my ($self, $data) = @_;

    my ($expect, $p);

    if($data =~ /Score = +([\d.e+-]+) bits \(([\d.e+-]+)\), +Expect = +([\d.e+-]+)/) {
	# blast2 format n = 1
	$self->{'_bits'}   = $1;
	$self->{'_score'}  = $2;
	$expect            = $3;
    } elsif($data =~ /Score = +([\d.e+-]+) bits \(([\d.e+-]+)\), +Expect\((\d+)\) = +([\d.e+-]+)/) {
	# blast2 format n > 1
	$self->{'_bits'}   = $1;
	$self->{'_score'}  = $2;
	$self->{'_n'}      = $3;
	$expect            = $4;

    } elsif($data =~ /Score = +([\d.e+-]+) \(([\d.e+-]+) bits\), +Expect = +([\d.e+-]+), P = +([\d.e-]+)/) {
	# blast1 format, n = 1
	$self->{'_score'}  = $1;
	$self->{'_bits'}   = $2;
	$expect            = $3;
	$p                 = $4;

    } elsif($data =~ /Score = +([\d.e+-]+) \(([\d.e+-]+) bits\), +Expect = +([\d.e+-]+), +Sum P\((\d+)\) = +([\d.e-]+)/) {
	# blast1 format, n > 1
	$self->{'_score'}  = $1;
	$self->{'_bits'}   = $2;
	$expect            = $3;
	$self->{'_n'}      = $4;
	$p                 = $5;

    } else {
	$self->throw("Can't parse score statistics: unrecognized format.", "$data");
    }

    $expect = "1$expect" if $expect =~ /^e/i;    
    $p      = "1$p"      if defined $p and $p=~ /^e/i; 

    $self->{'_expect'} = $expect;
    $self->{'_p'}      = $p || undef;

#-------------
    my $self      = shift;
    my $seqType   = shift;
    my @data      = @_;
    my @ranges    = ();
    my @sequence  = ();
    my $numGaps   = 0;

    foreach( @data ) {
	if( m/(\d+) *(\D+) *(\d+)/) {
	    push @ranges, ( $1, $3 ) ;
	    push @sequence, $2;
	} else {
	    $self->warn("Bad sequence data: $_");
	}
    }

    (scalar(@sequence) and scalar(@ranges)) || $self->throw("Can't set sequence: missing data",
							    "Possibly unrecognized Blast format.");
 
    # Sensitive to member name changes.
    $seqType = "_\L$seqType\E";
    $self->{$seqType.'Start'} = $ranges[0];
    $self->{$seqType.'Stop'}  = $ranges[ $#ranges ];
    $self->{$seqType.'Seq'}   =\@ sequence;
	
    $self->{$seqType.'Length'} = abs($ranges[ $#ranges ] - $ranges[0]) + 1;

    # Adjust lengths for BLASTX, TBLASTN, TBLASTX sequences
    # Converting nucl coords to amino acid coords.

    my $prog = $self->{'_prog'};
    if($prog eq 'TBLASTN' and $seqType eq '_sbjct') {
	$self->{$seqType.'Length'} /= 3;
    } elsif($prog eq 'BLASTX' and $seqType eq '_query') {
	$self->{$seqType.'Length'} /= 3;
    } elsif($prog eq 'TBLASTX') {
	$self->{$seqType.'Length'} /= 3;
    }

    $self->{$seqType.'Strand'} = 'Plus' if $prog =~ /BLAST[NX]/;

    # Normalize sequence endpoints so that start < end.
    # Reverse complement or 'minus strand' HSPs get flipped here.
    if($self->{$seqType.'Start'} > $self->{$seqType.'Stop'}) {
	($self->{$seqType.'Start'}, $self->{$seqType.'Stop'}) = 
	    ($self->{$seqType.'Stop'}, $self->{$seqType.'Start'});
	$self->{$seqType.'Strand'} = 'Minus';
    } 

    ## Count number of gaps in each seq. Only need to do this for gapped Blasts.
#    if($self->{'_gapped'}) {
	my $seqstr = join('', @sequence);
	$seqstr =~ s/\s//g;
        my $num_gaps = CORE::length($seqstr) - $self->{$seqType.'Length'};
	$self->{$seqType.'Gaps'} = $num_gaps if $num_gaps > 0;
#    }

    my $self = shift;

    $self->_set_seq('query', @{$self->{'_queryList'}});
    $self->_set_seq('sbjct', @{$self->{'_sbjctList'}});

    # Liberate some memory.
    @{$self->{'_queryList'}} = @{$self->{'_sbjctList'}} = ();
    undef $self->{'_queryList'};
    undef $self->{'_sbjctList'};

    $self->{'_set_seq_data'} = 1;

 my $self = shift; $self->{'_bits'};

#------------------
# This is not the slickest connectivity algorithm, but will do for now.
    my @a = @_;
    my ($from, $to, $i, @ca, $consec);
    
    $consec = 0;
    for($i=0; $i < @a; $i++) {
	not $from and do{ $from = $a[$i]; next; };
	if($a[$i] == $a[$i-1]+1) {
	    $to = $a[$i];
	    $consec++;
	} else {
	    if($consec == 1) { $from .= ",$to"; }
	    else { $from .= $consec>1 ? "\-$to" : ""; }
	    push @ca, split(',', $from);
	    $from =  $a[$i];
	    $consec = 0;
	    $to = undef;
	}
    }
    if(defined $to) {
	if($consec == 1) { $from .= ",$to"; }
	else { $from .= $consec>1 ? "\-$to" : ""; }
    }
    push @ca, split(',', $from) if $from;

    @ca;
}


1;
__END__

#####################################################################################
#                                  END OF CLASS
#####################################################################################

#-----------
    my( $self, %param ) = @_;
    
     my $sbjctName = $self->parent->name();
    my $queryName = $self->parent->parent->name();
    my $layout = $self->parent->parent->_layout();
    
    my $OUT = $self->set_display(%param);
    
    printf( $OUT "%-15s: %d\n", "LENGTH TOTAL", $self->length('total') );
    printf( $OUT "%-15s: %d\n", "LENGTH QUERY", $self->length('query') );
    printf( $OUT "%-15s: %d\n", "LENGTH SBJCT", $self->length('sbjct') );
    printf( $OUT "%-15s: %d\n", "GAPS QUERY", $self->gaps('query') );
    printf( $OUT "%-15s: %d\n", "GAPS SBJCT", $self->gaps('sbjct') );
    printf( $OUT "%-15s: %d\n", "SCORE", $self->{'_score'} );
    printf( $OUT "%-15s: %0.1f\n", "BITS", $self->{'_bits'} );
    if($layout == 1) {
	printf( $OUT "%-15s: %.1e\n", "P-VAL", $self->{'_p'} );
	printf( $OUT "%-15s: %.1e\n", "EXPECT", $self->{'_expect'} );
    } else {
	printf( $OUT "%-15s: %.1e\n", "EXPECT", $self->{'_expect'} );
    }

    my $queryLength = $self->length('query'); 

    printf( $OUT "%-15s: %d (%0.0f%%)\n", "IDENTICAL", $self->{'_numIdentical'}, 
	   $self->{'_numIdentical'}/$queryLength * 100 );
    printf( $OUT "%-15s: %d (%0.0f%%)  %s\n ", "CONSERVED", $self->{'_numConserved'}, 
	   $self->{'_numConserved'}/$queryLength * 100,
	   "includes identical" );
    
    $self->_display_seq('query', $queryName, $OUT);
    $self->_display_seq('sbjct', $sbjctName, $OUT);
    $self->_display_matches($queryName, $sbjctName, $OUT);

#----------
    my ($self, $seqType) = @_;

    $seqType ||= (wantarray ? 'list' : 'query');

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    if($seqType =~ /list|array/i) {
	return ($self->{'_queryStop'}, $self->{'_sbjctStop'});
    } else {
	## Sensitive to member name changes.
	$seqType = "_\L$seqType\E";
	return $self->{$seqType.'Stop'};
    }

 my $self = shift; $self->{'_expect'};

#--------------------
# The value is calculated as opposed to storing it from the parsed results.
# This saves storage and also permits flexibility in determining for which
# sequence (query or sbjct) the figure is to be calculated.
 
    my( $self, $seqType ) = @_;
    $seqType ||= 'total';

    if($seqType ne 'total') {
      $self->_set_seq_data() unless $self->{'_set_seq_data'};
    }

    ## Sensitive to member name format.
    $seqType = "_\L$seqType\E";

    sprintf( "%.2f", $self->{'_numConserved'}/$self->{$seqType.'Length'});

#-------------------
# The value is calculated as opposed to storing it from the parsed results.
# This saves storage and also permits flexibility in determining for which
# sequence (query or sbjct) the figure is to be calculated.

    my( $self, $seqType ) = @_;
    $seqType ||= 'total';

    if($seqType ne 'total') {
      $self->_set_seq_data() unless $self->{'_set_seq_data'};
    }
    ## Sensitive to member name format.
    $seqType = "_\L$seqType\E";

    sprintf( "%.2f", $self->{'_numIdentical'}/$self->{$seqType.'Length'});

 my $self = shift; $self->{'_frame'} || '';

#---------
    my( $self, $seqType ) = @_;

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    $seqType  ||= (wantarray ? 'list' : 'total');

    if($seqType =~ /list|array/i) {
	return (($self->{'_queryGaps'} || 0), ($self->{'_sbjctGaps'} || 0));
    }

    if($seqType eq 'total') {
	return ($self->{'_queryGaps'} + $self->{'_sbjctGaps'}) || 0;
    } else {
	## Sensitive to member name format.
	$seqType = "_\L$seqType\E";
	return $self->{$seqType.'Gaps'} || 0;
    }

#------------
    my $self = shift;
    
    require Bio::UnivAln;
    
    my $qseq = $self->seq('query');
    my $sseq = $self->seq('sbjct');

    my $desc = sprintf "HSP #%s of query %s vs. sbjct %s", 
	      $self->name, $self->parent->parent->name, $self->parent->name;

    my $type = $self->{'_prog'} =~ /P$|^T/ ? 'amino' : 'dna';

    Bio::UnivAln->new( -seqs => [$qseq, $sseq],
		       -desc => $desc,
		       -type => $type,
		       );

#---------------
    my ($self, %param) = @_;
    my $seq = $param{-SEQ} || $param{'-seq'} || 'sbjct';  # 'query' or 'sbjct'
    my $homolScore = $self->homol_score();
    # Sensitive to member name changes.
    $seq = "_\L$seq\E";
    
    $self->_set_seq_data() unless $self->{'_set_seq_data'};
    return ( $homolScore.' '.$self->{$seq.'Start'}.' '.$self->{$seq.'Stop'});

#----------------
    my $self = shift;
    
    if( $self->{'_bits'} >= $SCORE_CUTOFFS[0] ) { 1 }
    elsif($self->{'_bits'} < $SCORE_CUTOFFS[0] and 
	  $self->{'_bits'} >= $SCORE_CUTOFFS[1] ) { 2 }
    else  { 3 }
}


#####################################################################################
##                                  CLASS METHODS                                  ##
#####################################################################################

#-----------
    my( $self, $type ) = @_;
    $type  ||= 'total';

    $type ne 'total' and $self->_set_seq_data() unless $self->{'_set_seq_data'};

    ## Sensitive to member name format.
    $type = "_\L$type\E";
    $self->{$type.'Length'};

#-----------
    my( $self, %param ) = @_;
    my(@data);
    my($seqType, $beg, $end) = ($param{-SEQ}, $param{-START}, $param{-STOP});
    $seqType ||= 'query';

    if(!defined $beg && !defined $end) {
	## Get data for the whole alignment.
	push @data, ($self->{'_numIdentical'}, $self->{'_numConserved'});
    } else {
	## Get the substring representing the desired sub-section of aln.
	$beg ||= 0;
	$end ||= 0;
	my($start,$stop) = $self->range($seqType);
	if($beg == 0) { $beg = $start; $end = $beg+$end; }
	elsif($end == 0) { $end = $stop; $beg = $end-$beg; }

	if($end >= $stop) { $end = $stop; } ##ML changed from if (end >stop)
	else { $end += 1;}   ##ML moved from commented position below, makes
                             ##more sense here
#	if($end > $stop) { $end = $stop; }
	if($beg < $start) { $beg = $start; }
#	else { $end += 1;}

#	my $seq = substr($self->seq_str('match'), $beg-$start, ($end-$beg));

	## ML: START fix for substr out of range error ------------------
	my $seq = "";
	if (($self->{'_prog'} eq 'TBLASTN') and ($seqType eq 'sbjct'))
	{
	    $seq = substr($self->seq_str('match'),
			  int(($beg-$start)/3), int(($end-$beg+1)/3));

	} elsif (($self->{'_prog'} eq 'BLASTX') and ($seqType eq 'query'))
	{
	    $seq = substr($self->seq_str('match'),
			  int(($beg-$start)/3), int(($end-$beg+1)/3));
	} else {
	    $seq = substr($self->seq_str('match'), 
			  $beg-$start, ($end-$beg));
	}
	## ML: End of fix for  substr out of range error -----------------

	
	## ML: debugging code
	## This is where we get our exception.  Try printing out the values going
	## into this:
	##
#	 print STDERR 
#	     qq(*------------MY EXCEPTION --------------------\nSeq: ") , 
#	     $self->seq_str("$seqType"), qq("\n),$self->name,",(  index:";
#	 print STDERR  $beg-$start, ", len: ", $end-$beg," ), (HSPRealLen:", 
#	     CORE::length $self->seq_str("$seqType");
#	 print STDERR ", HSPCalcLen: ", $stop - $start +1 ," ), 
#	     ( beg: $beg, end: $end ), ( start: $start, stop: stop )\n";
	 ## ML: END DEBUGGING CODE----------

	if(!CORE::length $seq) {
	    $self->throw("Undefined sub-sequence ($beg,$end). Valid range = $start - $stop");
	}
	## Get data for a substring.
#	printf "Collecting HSP subsection data: beg,end = %d,%d; start,stop = %d,%d\n%s<---\n", $beg, $end, $start, $stop, $seq;
#	printf "Original match seq:\n%s\n",$self->seq_str('match');
	$seq =~ s/ //g;  # remove space (no info).
	my $len_cons = CORE::length $seq;
	$seq =~ s/\+//g;  # remove '+' characters (conservative substitutions)
	my $len_id = CORE::length $seq;
	push @data, ($len_id, $len_cons);
#	printf "  HSP = %s\n  id = %d; cons = %d\n", $self->name, $len_id, $len_cons; <STDIN>;
    }
    @data;

 my $self = shift; $self->{'_n'} || '';

#-------------------
    my( $self) = shift;

    $self->{'_numConserved'};

#-------------------
    my( $self) = shift;

    $self->{'_numIdentical'};

 my $self = shift; $self->{'_p'};

#----------
    my ($self, $seqType) = @_;

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    $seqType ||= 'query';
    ## Sensitive to member name changes.
    $seqType = "_\L$seqType\E";

    return ($self->{$seqType.'Start'},$self->{$seqType.'Stop'});

 my $self = shift; $self->{'_score'};

  #-------
    my($self,$seqType) = @_; 
    $seqType ||= 'query';
    my $str = $self->seq_str($seqType);
    my $num =  $self->name;
    my $name = $seqType =~ /query/i 
	            ? $self->parent->parent->name 
	            : $self->parent->name; 
	
    require Bio::Seq;

    new Bio::Seq (-ID   => $name,
		  -SEQ  => $str,
		  -DESC => "Blast HSP #$num, $seqType sequence",
		  );

#---------------
    my ($self, $seq, $class, $collapse) = @_;

    $seq  ||= 'query';
    $class ||= 'identical';
    $collapse ||= 0;

    $self->_set_residues() unless defined $self->{'_identicalRes_query'};

    $seq  = ($seq !~ /^q/i ? 'sbjct' : 'query');
    $class = ($class !~ /^id/i ? 'conserved' : 'identical');

    ## Sensitive to member name changes.
    $seq  = "_\L$seq\E";
    $class = "_\L$class\E";

    my @ary = sort { $a <=> $b } keys %{ $self->{"${class}Res$seq"}};

    return $collapse ? &collapse_nums(@ary) : @ary;

  #------------
    my($self,$seqType) = @_; 

    ## Sensitive to member name changes.
    $seqType = "_\L$seqType\E";

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    if($seqType =~ /sbjct|query/) {
	my $seq = join('',@{$self->{$seqType.'Seq'}}); 
	$seq =~ s/\s+//g;
	return $seq;

    } elsif( $seqType =~ /match/i) {
	# Only need to call _set_match_seq() if the match seq is requested.
	my $aref = $self->_set_match_seq() unless ref $self->{'_matchSeq'};
	$aref =  $self->{'_matchSeq'};

## DEBUGGING CODE:
#	if($self->parent->name eq '1AK5_' and $self->parent->parent->name eq 'YAR073W') {
#	    print "seq_str():\n   @$aref";<STDIN>;
#	}

	return join('',@$aref); 

    } else {
	$self->throw("Invalid or undefined sequence type: $seqType",
		     "Valid types: query, sbjct, match");
    }

 #-----------
    my $self = shift; 
    my $val ||= defined($self->{'_p'}) ? $self->{'_p'} : $self->{'_expect'};
    $val;

#----------
    my ($self, $seqType) = @_;

    $seqType ||= (wantarray ? 'list' : 'query');

    $self->_set_seq_data() unless $self->{'_set_seq_data'};

    if($seqType =~ /list|array/i) {
	return ($self->{'_queryStart'}, $self->{'_sbjctStart'});
    } else {
	## Sensitive to member name changes.
	$seqType = "_\L$seqType\E";
	return $self->{$seqType.'Start'};
    }

#-----------
    my( $self, $seqType ) = @_;
    $seqType  ||= (wantarray ? 'list' : 'query');

    return '' if $seqType eq 'query' and $self->{'_prog'} eq 'TBLASTN';

    ## Sensitive to member name format.
    $seqType = "_\L$seqType\E";

    # $seqType could be '_list'.
    $self->{'_queryStrand'} or $self->_set_seq_data() unless $self->{'_set_seq_data'};

    if($seqType  =~ /list|array/i) {
	return ('','') unless defined $self->{'_queryStrand'};
	return ($self->{'_queryStrand'}, $self->{'_sbjctStrand'});
    }
    local $^W = 0;
    $STRAND_SYMBOL{$self->{$seqType.'Strand'}} || 0;
}


#####################################################################################
##                            INSTANCE METHODS                                     ##
#####################################################################################

   http://bio.perl.org/Core/Latest
   ftp://bio.perl.org/pub/DIST

    bioperl-l@bioperl.org          - General discussion
    http://bio.perl.org/MailList.html             - About the mailing lists

    bioperl-bugs@bio.perl.org                   
    http://bugzilla.bioperl.org/

 Bio::Tools::Blast::Sbjct.pm   - Blast hit object.
 Bio::Tools::Blast.pm          - Blast object.
 Bio::Seq.pm                   - Biosequence object  
 Bio::UnivAln.pm               - Biosequence alignment object.
 Bio::Root::Object.pm          - Proposed base class for all Bioperl objects.

 http://bio.perl.org/Core/POD/Tools/Blast/Sbjct.pm.html

 http://bio.perl.org/Projects/modules.html  - Online module documentation
 http://bio.perl.org/Projects/Blast/        - Bioperl Blast Project     
 http://bio.perl.org/                       - Bioperl Project Homepage

 FIELD           VALUE
 --------------------------------------------------------------
 (member names are mostly self-explanatory)

 _score              :
 _bits               :
 _p                  :
 _n                  : Integer. The 'N' value listed in parenthesis with P/Expect value:
                     : e.g., P(3) = 1.2e-30  ---> (N = 3).
                     : Not defined in NCBI Blast2 with gaps.
                     : To obtain the number of HSPs, use Bio::Tools::Blast::Sbjct::num_hsps().
 _expect             :
 _queryLength        : 
 _queryGaps          : 
 _queryStart         :
 _queryStop          :
 _querySeq           :
 _sbjctLength        :
 _sbjctGaps          :
 _sbjctStart         :
 _sbjctStop          :
 _sbjctSeq           :
 _matchSeq           : String. Contains the symbols between the query and sbjct lines
                       which indicate identical (letter) and conserved ('+') matches
                       or a mismatch (' ').
 _numIdentical       :
 _numConserved       :
 _identicalRes_query :
 _identicalRes_sbjct :
 _conservedRes_query :
 _conservedRes_sbjct :
 _match_indent       : The number of leading space characters on each line containing
                       the match symbols. _match_indent is 13 in this example:
                         Query:   285 QNSAPWGLARISHRERLNLGSFNKYLYDDDAG
                                      Q +APWGLARIS       G+ + Y YD+ AG
                         ^^^^^^^^^^^^^ 

 INHERITED DATA MEMBERS 

 _name          : From Bio::Root::Object.pm. 
		:
 _parent        : From Bio::Root::Object.pm. This member contains a reference to the
		: Bio::Tools::Blast::Sbjct.pm object to which this hit belongs.